diff --git a/CMakeLists.txt b/CMakeLists.txt
index b0834fa..ba6be72 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,6 +10,7 @@ add_subdirectory( third_party/nlohmann_json )
 add_subdirectory( third_party/spdlog )
 add_subdirectory( third_party/libogg )
 add_subdirectory( third_party/socket.io-client-cpp )
+add_subdirectory( third_party/libdatachannel )
 
 option(USE_ALSA_ADAPTER "Use ALSA Adapter" OFF)
 if(USE_ALSA_ADAPTER)
diff --git a/src/Services/AudioStreamService.h b/src/Services/AudioStreamService.h
index adb6db3..e91b4ed 100644
--- a/src/Services/AudioStreamService.h
+++ b/src/Services/AudioStreamService.h
@@ -1,102 +1,135 @@
+// src/Services/AudioStreamService.h
 #pragma once
 
-#include <sio_client.h>
 #include <atomic>
-#include <spdlog/spdlog.h>
+#include <chrono>
+#include <filesystem>
 #include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
 #include <utility>
+#include <vector>
+#include <cstdio>
+#include <array>
+
+#include <spdlog/spdlog.h>
+
+#include "WhipClient.h"
+#include "ConfigService.h"
 
 namespace snoop {
 
 class AudioStreamService {
-    std::shared_ptr<sio::client> m_client;
-    std::string m_guid;
-    std::atomic<bool> m_isConnected = false;
-    std::atomic<bool> m_isInStreaming = false;
-    std::vector<char> m_audioBuffer;
-    std::mutex m_bufferMutex;
-    const unsigned long long int FLUSH_PERIOD = 5000;
-    const std::vector<char> PACKET_DELIMITER = {
-        static_cast<char>(0xFF),
-        static_cast<char>(0xFE),
-        static_cast<char>(0xFD),
-        static_cast<char>(0xFC)
-    };
-    unsigned long long int m_flushedAt = 0;
+    std::shared_ptr<ConfigService> m_cfg;
+
+    // WHIP
+    std::unique_ptr<WhipClient> m_whip;
+    std::mutex m_whipMutex;
+    std::string m_tmpKeyPath; // temp key extracted from keyctl (deleted on Stop)
 
 public:
-    explicit AudioStreamService( std::shared_ptr<sio::client> client, std::string guid ) :
-        m_client( std::move( client ) ),
-        m_guid( std::move( guid ) ) {
-        SetupEventListeners();
-    }
+    explicit AudioStreamService(std::shared_ptr<ConfigService> cfg)
+        : m_cfg(std::move(cfg)) {}
 
     ~AudioStreamService() {
-        this->m_isConnected = false;
-        this->m_isInStreaming = false;
+        StopWhip();
     }
 
-    void SendAudioData( const char* input, size_t size ) {
-        if( !this->m_isConnected || !this->m_isInStreaming ) {
-            return;
+    // Feed raw PCM (float32 interleaved), frames = samples per channel
+    void OnPCM(const float* interleaved, size_t frames) {
+        std::lock_guard lk(m_whipMutex);
+        if (m_whip) m_whip->PushPCM(interleaved, frames);
+    }
+
+    bool StartWhip(const std::string& whipUrl, int sampleRate=48000, int channels=1) {
+        std::lock_guard lk(m_whipMutex);
+        if (m_whip) {
+            spdlog::info("WHIP already started");
+            return true;
+        }
+        if (!m_cfg) {
+            spdlog::error("StartWhip requires ConfigService");
+            return false;
         }
 
-        std::lock_guard lock( m_bufferMutex );
-        this->m_audioBuffer.insert(m_audioBuffer.end(), PACKET_DELIMITER.begin(), PACKET_DELIMITER.end());
-        this->m_audioBuffer.insert( m_audioBuffer.end(), input, input + size );
+        // certs from enrollment
+        std::filesystem::path ca  = "/etc/iot/keys/issuing_ca.pem";
+        if (!std::filesystem::exists(ca)) ca = "/etc/iot/keys/ca_chain.pem";
+        std::filesystem::path crt = "/etc/iot/keys/device.crt.pem";
 
-        auto now = std::chrono::system_clock::now();
-        auto currentTime = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
-        if( currentTime >= this->m_flushedAt + FLUSH_PERIOD ) {
-            FlushBuffer();
+        // extract client key via keyctl
+        auto tmpKey = ExtractClientKeyTemp();
+        if (!tmpKey) {
+            spdlog::error("Cannot extract client key for WHIP (keyctl user iot-client-key)");
+            return false;
+        }
+
+        WhipClient::Params p{
+            .whipUrl   = whipUrl,
+            .caPath    = ca.string(),
+            .crtPath   = crt.string(),
+            .keyPath   = tmpKey->string(),
+            .sampleRate= sampleRate,
+            .channels  = channels
+        };
+        m_whip = std::make_unique<WhipClient>(p);
+        try {
+            m_whip->Start();
+            spdlog::info("WHIP started");
+            m_tmpKeyPath = *tmpKey;
+            return true;
+        } catch (const std::exception& e) {
+            spdlog::error("WHIP start failed: {}", e.what());
+            std::error_code ec; std::filesystem::remove(*tmpKey, ec);
+            m_whip.reset();
+            return false;
+        }
+    }
+
+    void StopWhip() {
+        std::lock_guard lk(m_whipMutex);
+        if (m_whip) {
+            m_whip->Stop();
+            m_whip.reset();
+        }
+        if (!m_tmpKeyPath.empty()) {
+            std::error_code ec; std::filesystem::remove(m_tmpKeyPath, ec);
+            m_tmpKeyPath.clear();
         }
     }
 
 private:
-    void SetupEventListeners() {
-        this->m_client->set_open_listener( [this]() {
-            spdlog::info( "Connected to server" );
-            this->m_client->socket( "/livestream" )->emit( "register_device", m_guid );
-            this->m_isConnected = true;
-        } );
+    static std::optional<std::filesystem::path> ExtractClientKeyTemp() {
+        auto exec = [](const std::string& cmd) {
+            std::array<char, 4096> buf{};
+            std::string out;
+            FILE* pipe = popen((cmd + " 2>&1").c_str(), "r");
+            if (!pipe) return std::string{};
+            while (fgets(buf.data(), (int)buf.size(), pipe) != nullptr) out.append(buf.data());
+            pclose(pipe);
+            return out;
+        };
+        auto trim = [](std::string s){
+            auto b=s.find_first_not_of(" \t\r\n"), e=s.find_last_not_of(" \t\r\n");
+            return (b==std::string::npos) ? std::string{} : s.substr(b, e-b+1);
+        };
 
-        this->m_client->set_close_listener( [this]( sio::client::close_reason const& reason ) {
-            this->m_isConnected = false;
-            this->m_isInStreaming = false;
-            spdlog::info( "Disconnected from server" );
-        } );
+        std::string id = trim(exec("keyctl search @s user iot-client-key | tail -n1"));
+        if (id.empty()) return std::nullopt;
 
-        this->m_client->set_fail_listener( []() {
-            spdlog::info( "Failed to connect to server" );
-        } );
-
-        this->m_client->socket( "/livestream" )->on( "start_streaming", [this]( sio::event& ev ) {
-            spdlog::info( "Start streaming command received" );
-            this->m_isInStreaming = true;
-            auto now = std::chrono::system_clock::now();
-            this->m_flushedAt = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
-        } );
-
-        this->m_client->socket( "/livestream" )->on( "stop_streaming", [this]( sio::event& ev ) {
-            spdlog::info( "Stop streaming command received" );
-            this->m_isInStreaming = false;
-            std::lock_guard lock( this->m_bufferMutex );
-            this->m_audioBuffer.clear();
-        } );
-    }
-
-    void FlushBuffer() {
-        if( this->m_audioBuffer.empty() ) {
-            return;
+        char tmpl[] = "/run/iot-whip-keyXXXXXX";
+        int fd = mkstemp(tmpl);
+        if (fd < 0) return std::nullopt;
+        close(fd);
+        std::filesystem::path p(tmpl);
+        exec("keyctl pipe " + id + " > " + p.string());
+        if (!std::filesystem::exists(p) || std::filesystem::file_size(p) == 0) {
+            std::error_code ec; std::filesystem::remove(p, ec);
+            return std::nullopt;
         }
-
-        this->m_client->socket( "/livestream" )->emit( "audio_data",
-                                                       std::make_shared<std::string>( this->m_audioBuffer.data(), this->m_audioBuffer.size() )
-            );
-        this->m_audioBuffer.clear();
-        auto now = std::chrono::system_clock::now();
-        this->m_flushedAt = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
+        return p;
     }
 };
 
-}
\ No newline at end of file
+} // namespace snoop
diff --git a/src/Services/AudioWriterService.h b/src/Services/AudioWriterService.h
index fd79128..6c79087 100644
--- a/src/Services/AudioWriterService.h
+++ b/src/Services/AudioWriterService.h
@@ -5,177 +5,459 @@
 #include <thread>
 #include <atomic>
 #include <chrono>
-#include <httplib.h>
 #include <mutex>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <array>
+#include <optional>
+
+#include <spdlog/spdlog.h>
+#include <httplib.h> // build with CPPHTTPLIB_OPENSSL_SUPPORT
+#include <sys/wait.h>
 
 #include "AudioWriters/OggAudioWriter.h"
 #include "ConfigService.h"
 
+namespace snoop
+{
 
-namespace snoop {
+    class AudioWriterService
+    {
+        std::shared_ptr<ConfigService> m_configService;
+        std::shared_ptr<OggAudioWriter> m_oggWriter;
+        std::string m_destinationDirectoryPath;
+        std::string m_queueDirectoryPath;
 
-class AudioWriterService {
-    std::shared_ptr<ConfigService> m_configService;
-    std::shared_ptr<OggAudioWriter> m_oggWriter;
-    std::string m_destinationDirectoryPath;
-    std::string m_queueDirectoryPath;
-    std::thread m_writingThread;
-    std::thread m_uploadThread;
-    std::mutex m_fetchFilePathsMutex;
-    unsigned long long int m_currentRecordStartedAt = 0;
-    std::string m_currentRecordFilePath;
-    std::atomic<bool> m_isIntermission = false;
+        std::thread m_writingThread;
+        std::thread m_uploadThread;
 
-public:
-    explicit AudioWriterService( std::shared_ptr<ConfigService> configService, std::string destinationDirectoryPath ) :
-        m_configService( std::move( configService ) ),
-        m_destinationDirectoryPath( std::move( destinationDirectoryPath ) ),
-        m_oggWriter( std::make_shared<OggAudioWriter>( 48000, 1 ) ) {
-        if( !this->m_destinationDirectoryPath.empty() && !this->m_destinationDirectoryPath.ends_with( "/" ) ) {
-            this->m_destinationDirectoryPath.append( "/" );
-        }
-        this->m_queueDirectoryPath = this->m_destinationDirectoryPath + "queue/";
-        std::filesystem::create_directories( this->m_queueDirectoryPath );
-        this->MoveToQueueUncompletedRecords();
-        this->m_writingThread = std::thread( [this]() {
-            this->WritingThread();
-        } );
-        this->m_uploadThread = std::thread( [this]() {
-            this->UploadThread();
-        } );
-        spdlog::info( "AudioWriterService::AudioWriterService()" );
-    }
+        std::mutex m_fetchFilePathsMutex;
+        std::mutex m_stateMutex;
 
-    void WriteAudioData( const char* data, size_t size, size_t frames ) {
-        this->m_oggWriter->Write( data, size, frames );
-    }
+        unsigned long long int m_currentRecordStartedAt = 0;
+        std::string m_currentRecordFilePath;
 
-    ~AudioWriterService() {
-        this->m_isIntermission = true;
-        this->m_writingThread.join();
-        this->m_uploadThread.join();
-    }
+        std::atomic<bool> m_isIntermission = false;
 
-private:
-    void MoveToQueueUncompletedRecords() {
-        std::vector<std::filesystem::path> files;
-        for( const auto& entry: std::filesystem::directory_iterator( this->m_destinationDirectoryPath ) ) {
-            files.push_back( entry.path() );
-        }
-        for( const auto& file: files ) {
-            if( file.filename().string() != "queue" ) {
-                spdlog::info( "Move uncompleted record {} to queue", file.filename().string() );
-                this->MoveToUploadQueue( file.string() );
-            }
-        }
-    }
+        // New recording control flags
+        std::atomic<bool> m_recordingEnabled{false};
+        std::atomic<bool> m_stopAfterCurrentSegment{false};
 
-    void WritingThread() {
-        auto now = std::chrono::system_clock::now();
-        this->m_currentRecordStartedAt = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
-        this->m_currentRecordFilePath = this->m_destinationDirectoryPath + std::to_string( this->m_currentRecordStartedAt );
-        this->m_oggWriter->StartWriting( this->m_currentRecordFilePath );
+    public:
+        explicit AudioWriterService(std::shared_ptr<ConfigService> configService, std::string destinationDirectoryPath)
+            : m_configService(std::move(configService)),
+              m_destinationDirectoryPath(std::move(destinationDirectoryPath)),
+              m_oggWriter(std::make_shared<OggAudioWriter>(48000, 1))
+        {
 
-
-        while( !m_isIntermission ) {
-            now = std::chrono::system_clock::now();
-            auto currentRecordDuration = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count() -
-                this->m_currentRecordStartedAt;
-            if( currentRecordDuration >= this->m_configService->GetRecordingDuration() ) {
-                this->m_oggWriter->StopWriting();
-                this->MoveToUploadQueue( this->m_currentRecordFilePath );
-                this->m_currentRecordStartedAt = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
-                this->m_currentRecordFilePath = this->m_destinationDirectoryPath + std::to_string( this->m_currentRecordStartedAt );
-                this->m_oggWriter->StartWriting( this->m_currentRecordFilePath );
-            }
-            std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ) );
-        }
-
-        this->m_oggWriter->StopWriting();
-        this->MoveToUploadQueue( this->m_currentRecordFilePath );
-        // TODO: Move to upload queue
-    }
-
-    void MoveToUploadQueue( const std::string& filePath ) {
-        spdlog::info( "AudioWriterService::MoveToUploadQueue( {} )", filePath );
-        std::lock_guard lock( this->m_fetchFilePathsMutex );
-        auto now = std::chrono::system_clock::now();
-        auto recordStoppedAt = std::chrono::duration_cast<std::chrono::milliseconds>( now.time_since_epoch() ).count();
-        if( std::filesystem::exists( filePath ) ) {
-            auto fileName = std::filesystem::path( filePath ).filename().string() + "-" + std::to_string( recordStoppedAt );
-            std::filesystem::rename( filePath, m_queueDirectoryPath + fileName );
-        }
-    }
-
-    void UploadThread() {
-        while (!m_isIntermission) {
-            std::vector<std::filesystem::path> files;
+            if (!this->m_destinationDirectoryPath.empty() && !this->m_destinationDirectoryPath.ends_with("/"))
             {
-                std::lock_guard l(this->m_fetchFilePathsMutex);
-                try {
-                    for (const auto& entry : std::filesystem::directory_iterator(this->m_queueDirectoryPath)) {
-                        files.push_back(entry.path());
-                    }
-                } catch (const std::exception& e) {
-                    spdlog::error("Error reading queue directory: {}", e.what());
+                this->m_destinationDirectoryPath.append("/");
+            }
+            this->m_queueDirectoryPath = this->m_destinationDirectoryPath + "queue/";
+            std::filesystem::create_directories(this->m_queueDirectoryPath);
+            this->MoveToQueueUncompletedRecords();
+
+            // Start background threads
+            this->m_writingThread = std::thread([this]()
+                                                { this->WritingThread(); });
+            this->m_uploadThread = std::thread([this]()
+                                               { this->UploadThread(); });
+
+            spdlog::info("AudioWriterService constructed; initial recordingEnabled=false");
+        }
+
+        ~AudioWriterService()
+        {
+            this->m_isIntermission = true;
+            if (this->m_writingThread.joinable())
+                this->m_writingThread.join();
+            if (this->m_uploadThread.joinable())
+                this->m_uploadThread.join();
+        }
+
+        // -------- Public control API (called from DeviceControlService handlers) --------
+
+        // Begin a new recording cycle immediately (creates a fresh segment and starts writing).
+        void StartRecording()
+        {
+            std::lock_guard<std::mutex> lk(this->m_stateMutex);
+            if (m_recordingEnabled.load())
+            {
+                spdlog::info("StartRecording ignored: already recording");
+                return;
+            }
+            m_stopAfterCurrentSegment = false;
+            m_recordingEnabled = true;
+            spdlog::info("Recording enabled");
+        }
+
+        // Graceful stop: finish the current segment at the next rotation boundary, then stop.
+        void StopRecordingGracefully()
+        {
+            std::lock_guard<std::mutex> lk(this->m_stateMutex);
+            if (!m_recordingEnabled.load())
+            {
+                spdlog::info("StopRecordingGracefully ignored: not recording");
+                return;
+            }
+            m_stopAfterCurrentSegment = true;
+            spdlog::info("Recording will stop after current segment completes");
+        }
+
+        bool IsRecording() const
+        {
+            return m_recordingEnabled.load();
+        }
+
+        // Called from the encoder callback — only writes when recording is enabled
+        void WriteAudioData(const char *data, size_t size, size_t frames)
+        {
+            if (!m_recordingEnabled.load())
+                return;
+            this->m_oggWriter->Write(data, size, frames);
+        }
+
+        // stops recording immidiately, when deep_sleep  received
+        void StopRecordingNow()
+        {
+            std::lock_guard<std::mutex> lk(this->m_stateMutex);
+            if (!m_recordingEnabled.load())
+            {
+                spdlog::info("StopRecordingNow ignored: not recording");
+                return;
+            }
+            // Force-close current segment right away, enqueue, and disable recording.
+            this->m_oggWriter->StopWriting();
+            this->MoveToUploadQueue(this->m_currentRecordFilePath);
+            m_recordingEnabled = false;
+            m_stopAfterCurrentSegment = false;
+            spdlog::info("Recording stopped immediately (deep sleep)");
+        }
+
+    private:
+        // ----------------------- Helpers (exec, keyctl, HTTPS mTLS) -----------------------
+
+        static std::string Trim(const std::string &s)
+        {
+            auto b = s.find_first_not_of(" \t\r\n");
+            auto e = s.find_last_not_of(" \t\r\n");
+            if (b == std::string::npos)
+                return "";
+            return s.substr(b, e - b + 1);
+        }
+
+        static std::string Exec(const std::string &cmd)
+        {
+            std::array<char, 4096> buf{};
+            std::string out;
+            FILE *pipe = popen((cmd + " 2>&1").c_str(), "r");
+            if (!pipe)
+                throw std::runtime_error("popen failed: " + cmd);
+            while (fgets(buf.data(), (int)buf.size(), pipe) != nullptr)
+                out.append(buf.data());
+            int rc = pclose(pipe);
+            int exitCode = WIFEXITED(rc) ? WEXITSTATUS(rc) : rc;
+            if (exitCode != 0)
+                spdlog::warn("Command '{}' exited with code {}", cmd, exitCode);
+            return out;
+        }
+
+        static std::filesystem::path ExtractClientKeyFromKernelKeyring()
+        {
+            std::string id = Trim(Exec("keyctl search @s user iot-client-key | tail -n1"));
+            if (id.empty())
+                throw std::runtime_error("iot-client-key not found in keyring");
+            char tmpl[] = "/run/iot-keyXXXXXX";
+            int fd = mkstemp(tmpl);
+            if (fd < 0)
+                throw std::runtime_error("mkstemp failed for client key");
+            close(fd);
+            std::filesystem::path p(tmpl);
+            Exec("keyctl pipe " + id + " > " + p.string());
+            if (std::filesystem::file_size(p) == 0)
+            {
+                std::error_code ec;
+                std::filesystem::remove(p, ec);
+                throw std::runtime_error("keyctl pipe produced empty client key");
+            }
+            return p;
+        }
+
+        struct Url
+        {
+            std::string scheme;
+            std::string host;
+            int port = 0;
+        };
+
+        static Url ParseBase(const std::string &base)
+        {
+            std::regex re(R"(^\s*(https?)://([^/:]+)(?::(\d+))?\s*$)");
+            std::smatch m;
+            if (!std::regex_match(base, m, re))
+            {
+                throw std::runtime_error("Invalid base URL: " + base);
+            }
+            Url u;
+            u.scheme = m[1].str();
+            u.host = m[2].str();
+            u.port = m[3].matched ? std::stoi(m[3].str()) : (u.scheme == "https" ? 443 : 80);
+            return u;
+        }
+
+        std::unique_ptr<httplib::Client> MakeClientMTLS(const Url &u,
+                                                        const std::filesystem::path &ca,
+                                                        const std::filesystem::path &crt,
+                                                        const std::filesystem::path &key)
+        {
+            if (u.scheme == "https")
+            {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+                auto cli = std::make_unique<httplib::SSLClient>(u.host.c_str(), u.port);
+                cli->enable_server_certificate_verification(true);
+                cli->set_ca_cert_path(ca.string().c_str());
+                cli->set_client_cert_file(crt.string().c_str(), key.string().c_str(), nullptr);
+                cli->set_connection_timeout(10);
+                cli->set_read_timeout(120);
+                cli->set_write_timeout(120);
+                return cli;
+#else
+                throw std::runtime_error("HTTPS baseUrl but CPPHTTPLIB_OPENSSL_SUPPORT is not enabled");
+#endif
+            }
+            else
+            {
+                auto cli = std::make_unique<httplib::Client>(u.host.c_str(), u.port);
+                cli->set_connection_timeout(10);
+                cli->set_read_timeout(120);
+                cli->set_write_timeout(120);
+                return cli;
+            }
+        }
+
+        // ----------------------------- Existing logic (adjusted) -----------------------------
+
+        void MoveToQueueUncompletedRecords()
+        {
+            std::vector<std::filesystem::path> files;
+            for (const auto &entry : std::filesystem::directory_iterator(this->m_destinationDirectoryPath))
+            {
+                files.push_back(entry.path());
+            }
+            for (const auto &file : files)
+            {
+                if (file.filename().string() != "queue")
+                {
+                    spdlog::info("Move uncompleted record {} to queue", file.filename().string());
+                    this->MoveToUploadQueue(file.string());
+                }
+            }
+        }
+
+        void WritingThread()
+        {
+            // recording starts ONLY when StartRecording() is called
+            while (!m_isIntermission)
+            {
+                if (!m_recordingEnabled.load())
+                {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+                    continue;
+                }
+
+                // Start a fresh segment
+                auto now = std::chrono::system_clock::now();
+                this->m_currentRecordStartedAt =
+                    std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+                this->m_currentRecordFilePath = this->m_destinationDirectoryPath + std::to_string(this->m_currentRecordStartedAt);
+                this->m_oggWriter->StartWriting(this->m_currentRecordFilePath);
+                spdlog::info("Recording segment started: {}", this->m_currentRecordFilePath);
+
+                // Write until duration elapses
+                const auto segDurationMs = this->m_configService->GetRecordingDuration();
+                while (!m_isIntermission && m_recordingEnabled.load())
+                {
+                    now = std::chrono::system_clock::now();
+                    auto currentRecordDuration =
+                        std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count() - this->m_currentRecordStartedAt;
+                    if (currentRecordDuration >= segDurationMs)
+                        break;
+                    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+                }
+
+                // Close current segment and enqueue
+                this->m_oggWriter->StopWriting();
+                this->MoveToUploadQueue(this->m_currentRecordFilePath);
+                spdlog::info("Recording segment finished: {}", this->m_currentRecordFilePath);
+
+                // If graceful stop requested, stop after finishing this segment
+                if (m_stopAfterCurrentSegment.load())
+                {
+                    m_recordingEnabled = false;
+                    m_stopAfterCurrentSegment = false;
+                    spdlog::info("Recording disabled after graceful stop");
                 }
             }
 
-            for (const auto& filePath : files) {
-                auto fileName = filePath.filename().string();
-                spdlog::info("Processing file: {}", fileName);
+            // If exiting service while in a middle of a segment, ensure clean close
+            if (m_recordingEnabled.load())
+            {
+                this->m_oggWriter->StopWriting();
+                this->MoveToUploadQueue(this->m_currentRecordFilePath);
+                m_recordingEnabled = false;
+            }
+        }
 
-                size_t delimiterPos = fileName.find('-');
-                if (delimiterPos != std::string::npos) {
-                    std::string startedAt = fileName.substr(0, delimiterPos);
-                    std::string stoppedAt = fileName.substr(delimiterPos + 1);
+        void MoveToUploadQueue(const std::string &filePath)
+        {
+            spdlog::info("MoveToUploadQueue( {} )", filePath);
+            std::lock_guard lock(this->m_fetchFilePathsMutex);
+            auto now = std::chrono::system_clock::now();
+            auto recordStoppedAt = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+            if (std::filesystem::exists(filePath))
+            {
+                auto fileName = std::filesystem::path(filePath).filename().string() + "-" + std::to_string(recordStoppedAt);
+                std::filesystem::rename(filePath, m_queueDirectoryPath + fileName);
+            }
+        }
 
-                    try {
-                        spdlog::info("Attempting to upload file...");
-                        if (SendRecordedFile(filePath.string(), stoull(startedAt), stoull(stoppedAt))) {
-                            spdlog::info("File uploaded, deleting: {}", filePath.string());
-                            std::filesystem::remove(filePath);
-                        } else {
-                            spdlog::warn("Failed to upload file: {}", filePath.string());
+        void UploadThread()
+        {
+            const auto baseUrl = this->m_configService->GetBaseUrl();
+            Url url = ParseBase(baseUrl);
+
+            // certs from enrollment
+            std::filesystem::path ca = "/etc/iot/keys/issuing_ca.pem";
+            if (!std::filesystem::exists(ca))
+                ca = "/etc/iot/keys/ca_chain.pem";
+            const std::filesystem::path crt = "/etc/iot/keys/device.crt.pem";
+
+            while (!m_isIntermission)
+            {
+                std::vector<std::filesystem::path> files;
+                {
+                    std::lock_guard l(this->m_fetchFilePathsMutex);
+                    try
+                    {
+                        for (const auto &entry : std::filesystem::directory_iterator(this->m_queueDirectoryPath))
+                        {
+                            if (entry.is_regular_file())
+                                files.push_back(entry.path());
                         }
-                    } catch (const std::exception& e) {
-                        spdlog::error("Exception during file upload: {}", e.what());
+                    }
+                    catch (const std::exception &e)
+                    {
+                        spdlog::error("Error reading queue directory: {}", e.what());
                     }
                 }
+
+                // Prepare client key (temp file) for this upload pass
+                std::optional<std::filesystem::path> tmpKey;
+                try
+                {
+                    tmpKey = ExtractClientKeyFromKernelKeyring();
+                }
+                catch (const std::exception &e)
+                {
+                    spdlog::error("Cannot extract client key for mTLS: {}", e.what());
+                    // Wait a bit and retry later
+                    std::this_thread::sleep_for(std::chrono::seconds(1));
+                    continue;
+                }
+
+                try
+                {
+                    auto client = MakeClientMTLS(url, ca, crt, *tmpKey);
+
+                    for (const auto &filePath : files)
+                    {
+                        auto fileName = filePath.filename().string();
+                        spdlog::info("Uploading file: {}", fileName);
+
+                        size_t delimiterPos = fileName.find('-');
+                        if (delimiterPos == std::string::npos)
+                        {
+                            spdlog::warn("Unexpected filename format, skipping: {}", fileName);
+                            continue;
+                        }
+                        std::string startedAt = fileName.substr(0, delimiterPos);
+                        std::string stoppedAt = fileName.substr(delimiterPos + 1);
+
+                        try
+                        {
+                            if (SendRecordedFileMTLS(*client, filePath.string(),
+                                                     std::stoull(startedAt),
+                                                     std::stoull(stoppedAt)))
+                            {
+                                spdlog::info("File uploaded, deleting: {}", filePath.string());
+                                std::filesystem::remove(filePath);
+                            }
+                            else
+                            {
+                                spdlog::warn("Failed to upload file: {}", filePath.string());
+                            }
+                        }
+                        catch (const std::exception &e)
+                        {
+                            spdlog::error("Exception during file upload: {}", e.what());
+                        }
+                    }
+                }
+                catch (const std::exception &e)
+                {
+                    spdlog::error("mTLS client setup failed: {}", e.what());
+                }
+
+                // cleanup temp key asap
+                if (tmpKey)
+                {
+                    std::error_code ec;
+                    std::filesystem::remove(*tmpKey, ec);
+                }
+
+                std::this_thread::sleep_for(std::chrono::milliseconds(800));
             }
-            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-        }
-    }
-
-
-
-    bool SendRecordedFile( const std::string& filepath, unsigned long long int startedAt, unsigned long long stoppedAt ) {
-        spdlog::info( "SendRecordedFile: {}", filepath );
-        httplib::Client client( this->m_configService->GetBaseUrl() );
-
-        std::ifstream ifs( filepath, std::ios::binary );
-        if( !ifs ) {
-            throw std::runtime_error( "Failed to open file" );
         }
 
-        std::vector<char> buffer( ( std::istreambuf_iterator<char>( ifs ) ), ( std::istreambuf_iterator<char>() ) );
-        auto res = client.Post(
-            std::string( "/records/upload/" ),
-            httplib::MultipartFormDataItems{
-                { "file", std::string( buffer.begin(), buffer.end() ), "file.ogg", "audio/ogg" },
-                { "guid", this->m_configService->GetGuid() },
-                { "startedAt", std::to_string( startedAt ) },
-                { "stoppedAt", std::to_string( stoppedAt ) },
-            } );
+        bool SendRecordedFileMTLS(httplib::Client &client,
+                                  const std::string &filepath,
+                                  unsigned long long int startedAt,
+                                  unsigned long long int stoppedAt)
+        {
+            spdlog::info("SendRecordedFile (mTLS): {}", filepath);
+            std::ifstream ifs(filepath, std::ios::binary);
+            if (!ifs)
+                throw std::runtime_error("Failed to open file: " + filepath);
 
-        if( res && res->status == 201 ) {
-            spdlog::info( "File uploaded successfully" );
-            return true;
+            std::vector<char> buffer((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+
+            // Multipart form: file + guid + times (same fields as before)
+            const std::string guid = this->m_configService->GetGuid();
+            httplib::MultipartFormDataItems items = {
+                {"file", std::string(buffer.begin(), buffer.end()), "file.ogg", "audio/ogg"},
+                {"guid", guid, "", "text/plain"},
+                {"startedAt", std::to_string(startedAt), "", "text/plain"},
+                {"stoppedAt", std::to_string(stoppedAt), "", "text/plain"},
+            };
+
+            auto res = client.Post("/api/records/upload/", items);
+            if (res && (res->status == 201 || res->status == 200))
+            {
+                spdlog::info("File uploaded successfully: HTTP {}", res->status);
+                return true;
+            }
+            if (res)
+            {
+                spdlog::error("Upload failed: HTTP {}, body: {}", res->status, res->body);
+            }
+            else
+            {
+                spdlog::error("Upload failed: no response");
+            }
+            return false;
         }
+    };
 
-        spdlog::error( "Failed to upload file" );
-        return false;
-    }
-};
-
-}
\ No newline at end of file
+} // namespace snoop
diff --git a/src/Services/DeviceControlService.h b/src/Services/DeviceControlService.h
index d5753f1..6c49ccb 100644
--- a/src/Services/DeviceControlService.h
+++ b/src/Services/DeviceControlService.h
@@ -17,279 +17,505 @@
 #include <spdlog/spdlog.h>
 #include <nlohmann/json.hpp>
 
-#include <httplib.h>              // build with CPPHTTPLIB_OPENSSL_SUPPORT
-#include <sys/wait.h>             // for WEXITSTATUS
+#include <httplib.h>  // build with CPPHTTPLIB_OPENSSL_SUPPORT
+#include <sys/wait.h> // for WEXITSTATUS
 
 #include "ConfigService.h"
 
-namespace snoop {
+namespace snoop
+{
 
-class DeviceControlService {
-public:
-    struct Task {
-        uint64_t id{};
-        std::string type;
-        nlohmann::json payload = nlohmann::json::object();
-    };
-
-    // Handler returns: {success, result_json_string, error_message}
-    using HandlerResult = std::tuple<bool, std::string, std::string>;
-    using TaskHandler   = std::function<HandlerResult(const Task&)>;
-
-    struct Handlers {
-        // Fill any you implement. Unset => default “not implemented”.
-        TaskHandler onStartStream;
-        TaskHandler onStopStream;
-        TaskHandler onStartRecording;
-        TaskHandler onStopRecording;
-        TaskHandler onUpdateConfig;
-        TaskHandler onSetDeepSleep;
-    };
-
-    DeviceControlService(std::shared_ptr<ConfigService> cfg, Handlers handlers)
-        : m_cfg(std::move(cfg)), m_handlers(std::move(handlers)) {
-        m_stop = false;
-        m_thread = std::thread(&DeviceControlService::RunLoop, this);
-    }
-
-    ~DeviceControlService() {
-        m_stop = true;
-        if (m_thread.joinable()) m_thread.join();
-    }
-
-private:
-    std::shared_ptr<ConfigService> m_cfg;
-    Handlers m_handlers;
-    std::thread m_thread;
-    std::atomic<bool> m_stop{false};
-
-    // --- helpers ---
-    static std::string Trim(const std::string& s) {
-        auto b = s.find_first_not_of(" \t\r\n");
-        auto e = s.find_last_not_of(" \t\r\n");
-        if (b == std::string::npos) return "";
-        return s.substr(b, e - b + 1);
-    }
-
-    static std::string Exec(const std::string& cmd) {
-        std::array<char, 4096> buf{};
-        std::string out;
-        FILE* pipe = popen((cmd + " 2>&1").c_str(), "r");
-        if (!pipe) throw std::runtime_error("popen failed: " + cmd);
-        while (fgets(buf.data(), (int)buf.size(), pipe) != nullptr) out.append(buf.data());
-        int rc = pclose(pipe);
-        int exitCode = WIFEXITED(rc) ? WEXITSTATUS(rc) : rc;
-        if (exitCode != 0) spdlog::warn("Command '{}' exited with code {}", cmd, exitCode);
-        return out;
-    }
-
-    struct Url {
-        std::string scheme; // http/https
-        std::string host;   // hostname or ip
-        int port = 0;       // default if 0
-    };
-
-    static Url ParseBase(const std::string& base) {
-        // very small parser: scheme://host[:port]
-        std::regex re(R"(^\s*(https?)://([^/:]+)(?::(\d+))?\s*$)");
-        std::smatch m;
-        if (!std::regex_match(base, m, re)) {
-            throw std::runtime_error("Invalid base URL for DeviceControlService: " + base);
-        }
-        Url u;
-        u.scheme = m[1].str();
-        u.host   = m[2].str();
-        u.port   = m[3].matched ? std::stoi(m[3].str()) : (u.scheme == "https" ? 443 : 80);
-        return u;
-    }
-
-    // dumps the client key from keyring to a temp file and returns its path
-    static std::filesystem::path ExtractClientKeyFromKernelKeyring() {
-        std::string id = Trim(Exec("keyctl search @s user iot-client-key | tail -n1"));
-        if (id.empty()) throw std::runtime_error("iot-client-key not found in keyring");
-        // Create a secure temp file
-        char tmpl[] = "/run/iot-keyXXXXXX";
-        int fd = mkstemp(tmpl);
-        if (fd < 0) throw std::runtime_error("mkstemp failed for client key");
-        close(fd);
-        std::filesystem::path p(tmpl);
-
-        // Pipe the key payload into the temp file
-        std::string cmd = "keyctl pipe " + id + " > " + p.string();
-        Exec(cmd);
-
-        // quick sanity
-        if (std::filesystem::file_size(p) == 0) {
-            std::error_code ec; std::filesystem::remove(p, ec);
-            throw std::runtime_error("keyctl pipe produced empty client key");
-        }
-        return p;
-    }
-
-    // Create HTTPS client configured for mTLS (or HTTP if base is http)
-    std::unique_ptr<httplib::Client> MakeClient(const Url& u,
-                                                const std::filesystem::path& ca,
-                                                const std::filesystem::path& crt,
-                                                const std::filesystem::path& key) {
-        if (u.scheme == "https") {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-            auto cli = std::make_unique<httplib::SSLClient>(u.host.c_str(), u.port);
-            cli->enable_server_certificate_verification(true);
-            cli->set_ca_cert_path(ca.string().c_str());
-            cli->set_client_cert_file(crt.string().c_str(), key.string().c_str(), nullptr);
-            // Recommended timeouts for long polling-ish flows
-            cli->set_connection_timeout(10);
-            cli->set_read_timeout(60);
-            cli->set_write_timeout(60);
-            return cli;
-#else
-            throw std::runtime_error("CPPHTTPLIB_OPENSSL_SUPPORT not enabled but https URL provided");
-#endif
-        } else {
-            auto cli = std::make_unique<httplib::Client>(u.host.c_str(), u.port);
-            cli->set_connection_timeout(10);
-            cli->set_read_timeout(60);
-            cli->set_write_timeout(60);
-            return cli;
-        }
-    }
-
-    // simple jittered sleep
-    void SleepWithJitterOnce(std::mt19937& rng, int baseSec, int jitterSec) {
-        if (baseSec < 0) baseSec = 0;
-        if (jitterSec < 0) jitterSec = 0;
-        std::uniform_int_distribution<int> dist(-jitterSec, +jitterSec);
-        int delay = baseSec + dist(rng);
-        if (delay < 0) delay = 0;
-        std::this_thread::sleep_for(std::chrono::seconds(delay));
-    }
-
-    // default fallback if handler is not provided
-    static HandlerResult NotImplemented(const Task& t) {
-        std::string msg = "Handler not implemented for type: " + t.type;
-        spdlog::warn("{}", msg);
-        return {false, "{}", msg};
-    }
-
-    TaskHandler ResolveHandler(std::string_view type) const {
-        if (type == "start_stream")     return m_handlers.onStartStream ? m_handlers.onStartStream : NotImplemented;
-        if (type == "stop_stream")      return m_handlers.onStopStream ? m_handlers.onStopStream : NotImplemented;
-        if (type == "start_recording")  return m_handlers.onStartRecording ? m_handlers.onStartRecording : NotImplemented;
-        if (type == "stop_recording")   return m_handlers.onStopRecording ? m_handlers.onStopRecording : NotImplemented;
-        if (type == "update_config")    return m_handlers.onUpdateConfig ? m_handlers.onUpdateConfig : NotImplemented;
-        if (type == "set_deep_sleep")   return m_handlers.onSetDeepSleep ? m_handlers.onSetDeepSleep : NotImplemented;
-        return NotImplemented;
-    }
-
-    static std::vector<Task> ParseTasks(const std::string& body) {
-        // server might return single object or array
-        std::vector<Task> tasks;
-        auto j = nlohmann::json::parse(body);
-
-        auto push_one = [&](const nlohmann::json& x){
-            Task t;
-            t.id    = x.value("id", 0);
-            t.type  = x.value("type", "");
-            try {
-                if (x.contains("payload")) {
-                    const auto& raw = x.at("payload");
-                    if (raw.is_string()) {
-                        // payload is quoted JSON string -> parse inner if valid, else keep as string
-                        try { t.payload = nlohmann::json::parse(raw.get<std::string>()); }
-                        catch (...) { t.payload = raw.get<std::string>(); }
-                    } else if (raw.is_object() || raw.is_array()) {
-                        t.payload = raw;
-                    } else {
-                        t.payload = nlohmann::json::object();
-                    }
-                }
-            } catch (...) { t.payload = nlohmann::json::object(); }
-            tasks.push_back(std::move(t));
+    class DeviceControlService
+    {
+    public:
+        struct Task
+        {
+            uint64_t id{};
+            std::string type;
+            nlohmann::json payload = nlohmann::json::object();
         };
 
-        if (j.is_array()) {
-            for (auto& it : j) push_one(it);
-        } else if (j.is_object()) {
-            push_one(j);
-        }
-        return tasks;
-    }
+        // Handler returns: {success, result_json_string, error_message}
+        using HandlerResult = std::tuple<bool, std::string, std::string>;
+        using TaskHandler = std::function<HandlerResult(const Task &)>;
 
-    void PostResult(httplib::Client& cli, const std::string& guid,
-                    uint64_t taskId, bool success,
-                    const std::string& resultJson, const std::string& err) {
-        nlohmann::json dto = {
-            {"taskId", taskId},
-            {"success", success},
-            {"result",  resultJson.empty() ? "{}" : resultJson},
-            {"error",   err}
+        struct Handlers
+        {
+            // Fill any you implement. Unset => default “not implemented”.
+            TaskHandler onStartStream;
+            TaskHandler onStopStream;
+            TaskHandler onStartRecording;
+            TaskHandler onStopRecording;
+            TaskHandler onUpdateConfig;
+            TaskHandler onSetDeepSleep;
         };
-        std::string path = "/api/tasks/" + guid;
-        auto res = cli.Post(path.c_str(), dto.dump(), "application/json");
-        if (!res) {
-            spdlog::error("POST {} failed (no response)", path);
-            return;
+
+        struct Controls
+        {
+            std::function<void()> stopStreamNow;    // e.g., streamer.StopWhip()
+            std::function<void()> stopRecordingNow; // e.g., writerService->StopRecordingNow()
+        };
+
+        // DeviceControlService(std::shared_ptr<ConfigService> cfg, Handlers handlers)
+        //     : m_cfg(std::move(cfg)), m_handlers(std::move(handlers))
+        // {
+        //     m_stop = false;
+        //     m_thread = std::thread(&DeviceControlService::RunLoop, this);
+        // }
+
+        DeviceControlService(std::shared_ptr<ConfigService> cfg, Handlers handlers, Controls controls)
+            : m_cfg(std::move(cfg)), m_handlers(std::move(handlers)), m_controls(std::move(controls))
+        {
+            m_stop = false;
+            m_thread = std::thread(&DeviceControlService::RunLoop, this);
         }
-        spdlog::info("POST {} -> HTTP {}", path, res->status);
-    }
 
-    void RunLoop() {
-        const std::string guid = m_cfg->GetGuid();
-        const auto base = m_cfg->GetBaseUrl();
-        Url url = ParseBase(base);
+        ~DeviceControlService()
+        {
+            m_stop = true;
+            if (m_thread.joinable())
+                m_thread.join();
+        }
 
-        // Cert paths from enrollment step
-        std::filesystem::path ca  = "/etc/iot/keys/issuing_ca.pem";   // or ca_chain.pem if you prefer
-        if (!std::filesystem::exists(ca)) ca = "/etc/iot/keys/ca_chain.pem";
-        std::filesystem::path crt = "/etc/iot/keys/device.crt.pem";
-
-        std::mt19937 rng{std::random_device{}()};
-
-        while (!m_stop) {
-            // Extract client key from kernel keyring to a temp file each cycle (kept minimal on disk)
-            std::optional<std::filesystem::path> tmpKey;
-            try {
-                tmpKey = ExtractClientKeyFromKernelKeyring();
-            } catch (const std::exception& e) {
-                spdlog::error("Key extraction failed: {}", e.what());
-                SleepWithJitterOnce(rng, m_cfg->GetPollingSeconds(), m_cfg->GetJitterSeconds());
-                continue;
+        void ArmDeepSleep(long long startMs, long long stopMs)
+        {
+            // Record sleep-until, and if we’re already inside the window, act now.
+            const auto now = NowMs();
+            if (stopMs <= startMs)
+            {
+                spdlog::warn("ArmDeepSleep: stop<=start");
+                return;
             }
 
-            try {
-                auto cli = MakeClient(url, ca, crt, *tmpKey);
-
-                // --- GET /tasks/:guid
-                const std::string getPath = "/api/tasks/" + guid;
-                spdlog::info("GET {}", getPath);
-                auto res = cli->Get(getPath.c_str());
-                if (!res) {
-                    spdlog::warn("GET {} failed (no response)", getPath);
-                } else if (res->status == 204) {
-                    spdlog::debug("No tasks (204).");
-                } else if (res->status >= 200 && res->status < 300) {
-                    auto tasks = ParseTasks(res->body);
-                    for (const auto& t : tasks) {
-                        auto handler = ResolveHandler(t.type);
-                        auto [ok, resultJson, err] = handler(t);
-                        PostResult(*cli, guid, t.id, ok, resultJson, err);
-                    }
-                } else {
-                    spdlog::warn("GET {} -> HTTP {}, body: {}", getPath, res->status, res->body);
-                }
-            } catch (const std::exception& e) {
-                spdlog::error("Task loop error: {}", e.what());
+            // If already inside window -> enter immediately
+            if (now >= startMs && now < stopMs)
+            {
+                EnterDeepSleepUntil(stopMs);
             }
+            else
+            {
+                // Otherwise, set a future "until" and the loop will enter at startMs.
+                // We’ll keep both values:
+                m_sleepStartMs = startMs;
+                m_sleepUntilMs = stopMs;
+            }
+        }
 
-            // cleanup temp key ASAP
-            if (tmpKey) {
+    private:
+        std::shared_ptr<ConfigService> m_cfg;
+        Handlers m_handlers;
+        std::thread m_thread;
+        std::atomic<bool> m_stop{false};
+
+        std::atomic<long long> m_sleepUntilMs{0}; // epoch ms; 0 = not sleeping
+        std::atomic<long long> m_sleepStartMs{0};
+
+        Controls m_controls;
+
+        // --- helpers ---
+        static std::string Trim(const std::string &s)
+        {
+            auto b = s.find_first_not_of(" \t\r\n");
+            auto e = s.find_last_not_of(" \t\r\n");
+            if (b == std::string::npos)
+                return "";
+            return s.substr(b, e - b + 1);
+        }
+
+        static std::string Exec(const std::string &cmd)
+        {
+            std::array<char, 4096> buf{};
+            std::string out;
+            FILE *pipe = popen((cmd + " 2>&1").c_str(), "r");
+            if (!pipe)
+                throw std::runtime_error("popen failed: " + cmd);
+            while (fgets(buf.data(), (int)buf.size(), pipe) != nullptr)
+                out.append(buf.data());
+            int rc = pclose(pipe);
+            int exitCode = WIFEXITED(rc) ? WEXITSTATUS(rc) : rc;
+            if (exitCode != 0)
+                spdlog::warn("Command '{}' exited with code {}", cmd, exitCode);
+            return out;
+        }
+
+        struct Url
+        {
+            std::string scheme; // http/https
+            std::string host;   // hostname or ip
+            int port = 0;       // default if 0
+        };
+
+        static Url ParseBase(const std::string &base)
+        {
+            // very small parser: scheme://host[:port]
+            std::regex re(R"(^\s*(https?)://([^/:]+)(?::(\d+))?\s*$)");
+            std::smatch m;
+            if (!std::regex_match(base, m, re))
+            {
+                throw std::runtime_error("Invalid base URL for DeviceControlService: " + base);
+            }
+            Url u;
+            u.scheme = m[1].str();
+            u.host = m[2].str();
+            u.port = m[3].matched ? std::stoi(m[3].str()) : (u.scheme == "https" ? 443 : 80);
+            return u;
+        }
+
+        static long long NowMs()
+        {
+            using namespace std::chrono;
+            return duration_cast<milliseconds>(system_clock::now().time_since_epoch()).count();
+        }
+
+        static std::optional<long long> ParseRfc3339UtcToMs(const std::string &s)
+        {
+            // Minimal, robust-ish parser for "YYYY-MM-DDTHH:MM:SS[.frac]Z"
+            // For production, consider date::parse or a small RFC3339 lib.
+            std::tm tm{};
+            char z = 'Z';
+            double frac = 0.0;
+            int n = 0;
+            // accept with optional fractional seconds
+            if (sscanf(s.c_str(), "%d-%d-%dT%d:%d:%d%n", &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+                       &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &n) != 6)
+                return std::nullopt;
+            tm.tm_year -= 1900;
+            tm.tm_mon -= 1;
+            const char *p = s.c_str() + n;
+            if (*p == '.')
+            {
+                // consume fractional
+                ++p;
+                while (isdigit(*p))
+                    ++p; // ignore exact fraction
+            }
+            if (*p != 'Z')
+                return std::nullopt;
+            time_t tt = timegm(&tm);
+            if (tt < 0)
+                return std::nullopt;
+            return (long long)tt * 1000LL;
+        }
+
+        static std::optional<long long> JsonTimeToMs(const nlohmann::json &j)
+        {
+            if (j.contains("start_ms") && j.contains("stop_ms"))
+            {
+                return j.at("stop_ms").get<long long>(); // caller will use start_ms separately
+            }
+            if (j.contains("start") && j.contains("stop") && j["start"].is_string() && j["stop"].is_string())
+            {
+                auto sMs = ParseRfc3339UtcToMs(j["start"].get<std::string>());
+                auto eMs = ParseRfc3339UtcToMs(j["stop"].get<std::string>());
+                if (sMs && eMs)
+                    return *eMs; // caller will use start separately
+            }
+            if (j.contains("start") && j["start"].is_string() &&
+                j["start"].get<std::string>() == "now" && j.contains("for_s"))
+            {
+                long long forS = j["for_s"].get<long long>();
+                return NowMs() + forS * 1000LL;
+            }
+            return std::nullopt;
+        }
+
+        // dumps the client key from keyring to a temp file and returns its path
+        static std::filesystem::path ExtractClientKeyFromKernelKeyring()
+        {
+            std::string id = Trim(Exec("keyctl search @s user iot-client-key | tail -n1"));
+            if (id.empty())
+                throw std::runtime_error("iot-client-key not found in keyring");
+            // Create a secure temp file
+            char tmpl[] = "/run/iot-keyXXXXXX";
+            int fd = mkstemp(tmpl);
+            if (fd < 0)
+                throw std::runtime_error("mkstemp failed for client key");
+            close(fd);
+            std::filesystem::path p(tmpl);
+
+            // Pipe the key payload into the temp file
+            std::string cmd = "keyctl pipe " + id + " > " + p.string();
+            Exec(cmd);
+
+            // quick sanity
+            if (std::filesystem::file_size(p) == 0)
+            {
                 std::error_code ec;
-                std::filesystem::remove(*tmpKey, ec);
+                std::filesystem::remove(p, ec);
+                throw std::runtime_error("keyctl pipe produced empty client key");
             }
-
-            SleepWithJitterOnce(rng, m_cfg->GetPollingSeconds(), m_cfg->GetJitterSeconds());
+            return p;
         }
-    }
-};
+
+        // Create HTTPS client configured for mTLS (or HTTP if base is http)
+        std::unique_ptr<httplib::Client> MakeClient(const Url &u,
+                                                    const std::filesystem::path &ca,
+                                                    const std::filesystem::path &crt,
+                                                    const std::filesystem::path &key)
+        {
+            if (u.scheme == "https")
+            {
+#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+                auto cli = std::make_unique<httplib::SSLClient>(u.host.c_str(), u.port);
+                cli->enable_server_certificate_verification(true);
+                cli->set_ca_cert_path(ca.string().c_str());
+                cli->set_client_cert_file(crt.string().c_str(), key.string().c_str(), nullptr);
+                // Recommended timeouts for long polling-ish flows
+                cli->set_connection_timeout(10);
+                cli->set_read_timeout(60);
+                cli->set_write_timeout(60);
+                return cli;
+#else
+                throw std::runtime_error("CPPHTTPLIB_OPENSSL_SUPPORT not enabled but https URL provided");
+#endif
+            }
+            else
+            {
+                auto cli = std::make_unique<httplib::Client>(u.host.c_str(), u.port);
+                cli->set_connection_timeout(10);
+                cli->set_read_timeout(60);
+                cli->set_write_timeout(60);
+                return cli;
+            }
+        }
+
+        // simple jittered sleep
+        void SleepWithJitterOnce(std::mt19937 &rng, int baseSec, int jitterSec)
+        {
+            if (baseSec < 0)
+                baseSec = 0;
+            if (jitterSec < 0)
+                jitterSec = 0;
+            std::uniform_int_distribution<int> dist(-jitterSec, +jitterSec);
+            int delay = baseSec + dist(rng);
+            if (delay < 0)
+                delay = 0;
+            std::this_thread::sleep_for(std::chrono::seconds(delay));
+        }
+
+        // default fallback if handler is not provided
+        static HandlerResult NotImplemented(const Task &t)
+        {
+            std::string msg = "Handler not implemented for type: " + t.type;
+            spdlog::warn("{}", msg);
+            return {false, "{}", msg};
+        }
+
+        TaskHandler ResolveHandler(std::string_view type) const
+        {
+            if (type == "start_stream")
+                return m_handlers.onStartStream ? m_handlers.onStartStream : NotImplemented;
+            if (type == "stop_stream")
+                return m_handlers.onStopStream ? m_handlers.onStopStream : NotImplemented;
+            if (type == "start_recording")
+                return m_handlers.onStartRecording ? m_handlers.onStartRecording : NotImplemented;
+            if (type == "stop_recording")
+                return m_handlers.onStopRecording ? m_handlers.onStopRecording : NotImplemented;
+            if (type == "update_config")
+                return m_handlers.onUpdateConfig ? m_handlers.onUpdateConfig : NotImplemented;
+            if (type == "set_deep_sleep")
+                return m_handlers.onSetDeepSleep ? m_handlers.onSetDeepSleep : NotImplemented;
+            return NotImplemented;
+        }
+
+        static std::vector<Task> ParseTasks(const std::string &body)
+        {
+            // server might return single object or array
+            std::vector<Task> tasks;
+            auto j = nlohmann::json::parse(body);
+
+            auto push_one = [&](const nlohmann::json &x)
+            {
+                Task t;
+                t.id = x.value("id", 0);
+                t.type = x.value("type", "");
+                try
+                {
+                    if (x.contains("payload"))
+                    {
+                        const auto &raw = x.at("payload");
+                        if (raw.is_string())
+                        {
+                            // payload is quoted JSON string -> parse inner if valid, else keep as string
+                            try
+                            {
+                                t.payload = nlohmann::json::parse(raw.get<std::string>());
+                            }
+                            catch (...)
+                            {
+                                t.payload = raw.get<std::string>();
+                            }
+                        }
+                        else if (raw.is_object() || raw.is_array())
+                        {
+                            t.payload = raw;
+                        }
+                        else
+                        {
+                            t.payload = nlohmann::json::object();
+                        }
+                    }
+                }
+                catch (...)
+                {
+                    t.payload = nlohmann::json::object();
+                }
+                tasks.push_back(std::move(t));
+            };
+
+            if (j.is_array())
+            {
+                for (auto &it : j)
+                    push_one(it);
+            }
+            else if (j.is_object())
+            {
+                push_one(j);
+            }
+            return tasks;
+        }
+
+        void PostResult(httplib::Client &cli, const std::string &guid,
+                        uint64_t taskId, bool success,
+                        const std::string &resultJson, const std::string &err)
+        {
+            nlohmann::json dto = {
+                {"taskId", taskId},
+                {"success", success},
+                {"result", resultJson.empty() ? "{}" : resultJson},
+                {"error", err}};
+            std::string path = "/api/tasks/" + guid;
+            auto res = cli.Post(path.c_str(), dto.dump(), "application/json");
+            if (!res)
+            {
+                spdlog::error("POST {} failed (no response)", path);
+                return;
+            }
+            spdlog::info("POST {} -> HTTP {}", path, res->status);
+        }
+
+        void EnterDeepSleepUntil(long long stopMs)
+        {
+            m_sleepStartMs = NowMs();
+            m_sleepUntilMs = stopMs;
+            spdlog::info("Entering deep sleep until {} ms", stopMs);
+            // Stop stream & recording immediately
+            if (m_controls.stopStreamNow)
+                m_controls.stopStreamNow();
+            if (m_controls.stopRecordingNow)
+                m_controls.stopRecordingNow();
+        }
+
+        void RunLoop()
+        {
+            const std::string guid = m_cfg->GetGuid();
+            const auto base = m_cfg->GetBaseUrl();
+            Url url = ParseBase(base);
+
+            // Cert paths from enrollment step
+            std::filesystem::path ca = "/etc/iot/keys/issuing_ca.pem"; // or ca_chain.pem if you prefer
+            if (!std::filesystem::exists(ca))
+                ca = "/etc/iot/keys/ca_chain.pem";
+            std::filesystem::path crt = "/etc/iot/keys/device.crt.pem";
+
+            std::mt19937 rng{std::random_device{}()};
+
+            while (!m_stop)
+            {
+                // Extract client key from kernel keyring to a temp file each cycle (kept minimal on disk)
+                std::optional<std::filesystem::path> tmpKey;
+                try
+                {
+                    tmpKey = ExtractClientKeyFromKernelKeyring();
+                }
+                catch (const std::exception &e)
+                {
+                    spdlog::error("Key extraction failed: {}", e.what());
+                    SleepWithJitterOnce(rng, m_cfg->GetPollingSeconds(), m_cfg->GetJitterSeconds());
+                    continue;
+                }
+                const auto now = NowMs();
+                const auto startMs = m_sleepStartMs.load();
+                const auto untilMs = m_sleepUntilMs.load();
+
+                if (untilMs > 0)
+                {
+                    if (now < startMs)
+                    {
+                        // Not yet time to sleep: wait until start (no network calls)
+                        auto waitMs = std::min<long long>(startMs - now, 60'000);
+                        std::this_thread::sleep_for(std::chrono::milliseconds(waitMs));
+                        continue;
+                    }
+                    if (now >= startMs && now < untilMs)
+                    {
+                        // In deep sleep window: do not send any requests; just wait
+                        auto waitMs = std::min<long long>(untilMs - now, 60'000);
+                        std::this_thread::sleep_for(std::chrono::milliseconds(waitMs));
+                        // On first entry, ensure we stopped immediately
+                        if (now - startMs < 1200)
+                        { // within ~1.2s window
+                            if (m_controls.stopStreamNow)
+                                m_controls.stopStreamNow();
+                            if (m_controls.stopRecordingNow)
+                                m_controls.stopRecordingNow();
+                        }
+                        continue;
+                    }
+                    if (now >= untilMs)
+                    {
+                        // Sleep period over; clear flags and resume normal polling
+                        m_sleepStartMs = 0;
+                        m_sleepUntilMs = 0;
+                        spdlog::info("Deep sleep finished; resuming operation");
+                    }
+                    try
+                    {
+                        auto cli = MakeClient(url, ca, crt, *tmpKey);
+
+                        // --- GET /tasks/:guid
+                        const std::string getPath = "/api/tasks/" + guid;
+                        spdlog::info("GET {}", getPath);
+                        auto res = cli->Get(getPath.c_str());
+                        if (!res)
+                        {
+                            spdlog::warn("GET {} failed (no response)", getPath);
+                        }
+                        else if (res->status == 204)
+                        {
+                            spdlog::debug("No tasks (204).");
+                        }
+                        else if (res->status >= 200 && res->status < 300)
+                        {
+                            auto tasks = ParseTasks(res->body);
+                            for (const auto &t : tasks)
+                            {
+                                auto handler = ResolveHandler(t.type);
+                                auto [ok, resultJson, err] = handler(t);
+                                PostResult(*cli, guid, t.id, ok, resultJson, err);
+                            }
+                        }
+                        else
+                        {
+                            spdlog::warn("GET {} -> HTTP {}, body: {}", getPath, res->status, res->body);
+                        }
+                    }
+                    catch (const std::exception &e)
+                    {
+                        spdlog::error("Task loop error: {}", e.what());
+                    }
+
+                    // cleanup temp key ASAP
+                    if (tmpKey)
+                    {
+                        std::error_code ec;
+                        std::filesystem::remove(*tmpKey, ec);
+                    }
+
+                    SleepWithJitterOnce(rng, m_cfg->GetPollingSeconds(), m_cfg->GetJitterSeconds());
+                }
+            }
+        }
+    };
 
 } // namespace snoop
diff --git a/src/Services/WhipClient.h b/src/Services/WhipClient.h
new file mode 100644
index 0000000..7bdeffd
--- /dev/null
+++ b/src/Services/WhipClient.h
@@ -0,0 +1,223 @@
+// src/Services/WhipClient.h
+#pragma once
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <atomic>
+#include <mutex>
+#include <optional>
+#include <filesystem>
+#include <vector>
+#include <regex>
+#include <array>
+
+#include <spdlog/spdlog.h>
+#include <nlohmann/json.hpp>
+#include <httplib.h> // build with CPPHTTPLIB_OPENSSL_SUPPORT
+
+#include <rtc/rtc.hpp> // libdatachannel
+
+namespace snoop {
+
+class WhipClient {
+public:
+    struct Params {
+        std::string whipUrl;   // full WHIP endpoint (may already include ?token=...)
+        std::string caPath;    // CA chain
+        std::string crtPath;   // client cert
+        std::string keyPath;   // client key (temp extracted from keyctl)
+        int sampleRate = 48000;
+        int channels   = 1;
+    };
+
+    explicit WhipClient(Params p)
+        : m_p(std::move(p)) {}
+
+    ~WhipClient() {
+        Stop();
+    }
+
+    void Start() {
+        std::lock_guard lk(m_mtx);
+        if (m_started) return;
+
+        // ----- PeerConnection -----
+        rtc::Configuration cfg;
+        // No STUN/TURN required for MediaMTX WHIP (server is public/ICE-lite).
+        // cfg.iceServers = { }; // default
+
+        m_pc = std::make_shared<rtc::PeerConnection>(cfg);
+
+        // Optional: observe connection state / ICE
+        m_pc->onStateChange([this](rtc::PeerConnection::State s){
+            spdlog::info("WHIP pc state: {}", (int)s);
+        });
+        m_pc->onGatheringStateChange([this](rtc::PeerConnection::GatheringState s){
+            spdlog::info("WHIP gathering state: {}", (int)s);
+        });
+        m_pc->onLocalDescription([this](rtc::Description desc){
+            // When we have the local SDP, POST (WHIP) to get the answer
+            try {
+                const std::string offer = std::string(desc);
+                auto [answer, resourceUrl] = PostOfferWHIP(offer);
+                m_resourceUrl = resourceUrl;
+                m_pc->setRemoteDescription(rtc::Description(answer, "answer"));
+                spdlog::info("WHIP remote description set");
+            } catch (const std::exception& e) {
+                spdlog::error("WHIP POST offer failed: {}", e.what());
+            }
+        });
+        m_pc->onLocalCandidate([this](rtc::Candidate c) {
+            // Trickle via PATCH to WHIP resource (if server requires)
+            if (!m_resourceUrl.has_value()) return;
+            try {
+                PatchCandidateWHIP(c);
+            } catch (const std::exception& e) {
+                spdlog::warn("WHIP PATCH candidate failed: {}", e.what());
+            }
+        });
+
+        // ----- Audio track / source -----
+        m_audioSource = rtc::CreateAudioSource(m_p.sampleRate, m_p.channels);
+        m_track = m_pc->addTrack(m_audioSource);
+
+        // ----- Create offer -----
+        m_pc->setLocalDescription(); // triggers onLocalDescription callback
+
+        m_started = true;
+    }
+
+    void Stop() {
+        std::lock_guard lk(m_mtx);
+        if (!m_started) return;
+
+        if (m_track)      m_track = nullptr;
+        if (m_audioSource) m_audioSource = nullptr;
+        if (m_pc)         m_pc = nullptr;
+
+        // No explicit WHIP DELETE here, but you can add it if server supports deleting the resource.
+
+        // cleanup resource url
+        m_resourceUrl.reset();
+        m_started = false;
+    }
+
+    // Feed PCM (float32) in interleaved format. frames = samples per channel.
+    void PushPCM(const float* interleaved, size_t frames) {
+        std::lock_guard lk(m_mtx);
+        if (!m_audioSource) return;
+        // libdatachannel expects planar/int16? Actually CreateAudioSource accepts float32
+        // and uses (frames, channels) to encode Opus internally.
+        // Push signature is: audioSource->pushFloat(interleaved, frames, channels, sampleRate)
+        m_audioSource->pushFloat(interleaved, (int)frames, m_p.channels, m_p.sampleRate);
+    }
+
+private:
+    Params m_p;
+    std::shared_ptr<rtc::PeerConnection> m_pc;
+    std::shared_ptr<rtc::AudioSource>    m_audioSource;
+    std::shared_ptr<rtc::Track>          m_track;
+    std::optional<std::string>           m_resourceUrl;
+    std::mutex m_mtx;
+    std::atomic<bool> m_started{false};
+
+    // --- WHIP HTTP helpers (mTLS-capable) ---
+
+    static std::tuple<std::string,std::string> ExtractAnswerAndLocation(const httplib::Result& r) {
+        // WHIP server responds 201 Created, body = SDP answer (text/plain),
+        // Location header = resource URL for PATCH candidates.
+        if (!r) throw std::runtime_error("No HTTP result");
+        if (r->status != 201 && r->status != 200)
+            throw std::runtime_error("Unexpected WHIP status: " + std::to_string(r->status));
+        std::string answer = r->body;
+        std::string resourceUrl;
+        if (r->has_header("Location")) resourceUrl = r->get_header_value("Location");
+        return {answer, resourceUrl};
+    }
+
+    std::pair<std::string,std::string> PostOfferWHIP(const std::string& sdpOffer) {
+        auto [cli, path] = MakeClientForUrl(m_p.whipUrl);
+        // WHIP requires:
+        // POST <endpoint>  Content-Type: application/sdp    Body: offer SDP
+        // Response: 201 Created, body: answer SDP, Location: resource URL
+        auto res = cli->Post(path.c_str(), sdpOffer, "application/sdp");
+        auto [answer, resUrl] = ExtractAnswerAndLocation(res);
+        return {answer, resUrl};
+    }
+
+    void PatchCandidateWHIP(const rtc::Candidate& cand) {
+        if (!m_resourceUrl) return;
+        auto [cli, path] = MakeClientForUrl(*m_resourceUrl);
+        // WHIP trickle: PATCH resource with Content-Type: application/trickle-ice-sdpfrag
+        // Body is an SDP fragment with "a=candidate:..."
+        std::string frag = "a=" + std::string(cand);
+        auto res = cli->Patch(path.c_str(), frag, "application/trickle-ice-sdpfrag");
+        if (!res || (res->status < 200 || res->status >= 300)) {
+            spdlog::warn("WHIP PATCH {} -> {}", path, res ? res->status : -1);
+        }
+    }
+
+    // Parse URL, return httplib client + path, configured with mTLS if https
+    static std::pair<std::unique_ptr<httplib::Client>, std::string>
+    MakeClientForUrl(const std::string& url) {
+        // scheme://host[:port]/path...
+        static const std::regex re(R"(^(https?)://([^/:]+)(?::(\d+))?(/.*)?$)");
+        std::smatch m;
+        if (!std::regex_match(url, m, re)) {
+            throw std::runtime_error("Invalid URL: " + url);
+        }
+        std::string scheme = m[1].str();
+        std::string host   = m[2].str();
+        int port           = m[3].matched ? std::stoi(m[3].str()) : (scheme=="https"?443:80);
+        std::string path   = m[4].matched ? m[4].str() : "/";
+
+        // We need the mTLS params; capture via thread-local? We’ll pass via this pointer.
+        // To access instance fields here, make this non-static or pass params through a lambda.
+        // Simpler: look up global thread-local; or we restructure to capture this.
+        // For cleanliness, we’ll make a non-static wrapper below.
+        throw std::logic_error("Use MakeClientForUrl_inst instead");
+    }
+
+    std::pair<std::unique_ptr<httplib::Client>, std::string>
+    MakeClientForUrl_inst(const std::string& url) {
+        static const std::regex re(R"(^(https?)://([^/:]+)(?::(\d+))?(/.*)?$)");
+        std::smatch m;
+        if (!std::regex_match(url, m, re)) {
+            throw std::runtime_error("Invalid URL: " + url);
+        }
+        std::string scheme = m[1].str();
+        std::string host   = m[2].str();
+        int port           = m[3].matched ? std::stoi(m[3].str()) : (scheme=="https"?443:80);
+        std::string path   = m[4].matched ? m[4].str() : "/";
+
+        if (scheme == "https") {
+#ifndef CPPHTTPLIB_OPENSSL_SUPPORT
+            throw std::runtime_error("https URL but CPPHTTPLIB_OPENSSL_SUPPORT not enabled");
+#else
+            auto cli = std::make_unique<httplib::SSLClient>(host.c_str(), port);
+            cli->enable_server_certificate_verification(true);
+            cli->set_ca_cert_path(m_p.caPath.c_str());
+            cli->set_client_cert_file(m_p.crtPath.c_str(), m_p.keyPath.c_str(), nullptr);
+            cli->set_connection_timeout(10);
+            cli->set_read_timeout(60);
+            cli->set_write_timeout(60);
+            return {std::move(cli), path};
+#endif
+        } else {
+            auto cli = std::make_unique<httplib::Client>(host.c_str(), port);
+            cli->set_connection_timeout(10);
+            cli->set_read_timeout(60);
+            cli->set_write_timeout(60);
+            return {std::move(cli), path};
+        }
+    }
+
+    // Overload to call instance version
+    std::pair<std::unique_ptr<httplib::Client>, std::string>
+    MakeClientForUrl(const std::string& url) {
+        return MakeClientForUrl_inst(url);
+    }
+};
+
+} // namespace snoop
diff --git a/src/main.cpp b/src/main.cpp
index 1134ef2..a8b07fa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -43,6 +43,35 @@ namespace snoop
                     spdlog::info("First-run enrollment completed.");
                 }
             }
+
+            auto writerService = std::make_shared<AudioWriterService>(configService, "records");
+
+            // WHIP-only streamer
+            AudioStreamService streamer(configService);
+
+            // PCM tap -> feed WHIP
+            std::function<void(const float *, int)> pcmTap =
+                [&](const float *interleaved, int frames)
+            {
+                streamer.OnPCM(interleaved, static_cast<size_t>(frames));
+            };
+
+            // Encoder: keep writing to local Ogg via writerService; (no Socket.IO send)
+            TAudioEncoder encoder(sampleRate, channels, framesPerBuffer, [&](auto input, auto size) -> int
+                                  {
+                writerService->WriteAudioData(input, size, framesPerBuffer);
+                return paContinue; },
+                                  pcmTap // NEW: raw PCM to WHIP
+            );
+
+            snoop::DeviceControlService::Controls controls{
+                .stopStreamNow = [&]()
+                { streamer.StopWhip(); },
+                .stopRecordingNow = [&]()
+                { writerService->StopRecordingNow(); }};
+
+            g_taskSvc = std::make_unique<snoop::DeviceControlService>(configService, handlers, controls);
+
             // ------------------------------
             {
                 snoop::DeviceControlService::Handlers handlers{};
@@ -51,24 +80,41 @@ namespace snoop
                 {
                     spdlog::info("start_stream payload: {}", t.payload.dump());
                     // TODO: start your streaming pipeline using payload["whipUrl"], etc.
-                    return snoop::DeviceControlService::HandlerResult{true, R"({"status":"started"})", ""};
+                    std::string whipUrl;
+                    try
+                    {
+                        if (t.payload.contains("whipUrl"))
+                            whipUrl = t.payload.at("whipUrl").get<std::string>();
+                    }
+                    catch (...)
+                    {
+                    }
+                    if (whipUrl.empty())
+                    {
+                        return snoop::DeviceControlService::HandlerResult{false, "{}", "whipUrl missing"};
+                    }
+                    bool ok = streamer.StartWhip(whipUrl, sampleRate, channels);
+                    return snoop::DeviceControlService::HandlerResult{ok, R"({"whip":"started"})", ok ? "" : "failed"};
                 };
                 handlers.onStopStream = [](const snoop::DeviceControlService::Task &t)
                 {
                     spdlog::info("stop_stream payload: {}", t.payload.dump());
                     // TODO: stop streaming
+                    streamer.StopWhip();
                     return snoop::DeviceControlService::HandlerResult{true, R"({"status":"stopped"})", ""};
                 };
                 handlers.onStartRecording = [&](const snoop::DeviceControlService::Task &t)
                 {
                     spdlog::info("start_recording payload: {}", t.payload.dump());
                     // TODO: if you gate writes in AudioWriterService, flip to recording mode here
+                    writerService->StartRecording();
                     return snoop::DeviceControlService::HandlerResult{true, R"({"recording":"on"})", ""};
                 };
                 handlers.onStopRecording = [&](const snoop::DeviceControlService::Task &t)
                 {
                     spdlog::info("stop_recording payload: {}", t.payload.dump());
                     // TODO: flip to recording off
+                    writerService->StopRecordingGracefully();
                     return snoop::DeviceControlService::HandlerResult{true, R"({"recording":"off"})", ""};
                 };
                 handlers.onUpdateConfig = [&](const snoop::DeviceControlService::Task &t)
@@ -104,26 +150,55 @@ namespace snoop
                 {
                     spdlog::info("set_deep_sleep payload: {}", t.payload.dump());
                     // TODO: use platform power management or just extend sleep window
-                    return snoop::DeviceControlService::HandlerResult{true, R"({"sleep":"scheduled"})", ""};
+
+                    try
+                    {
+                        long long startMs = 0, stopMs = 0;
+                        if (t.payload.contains("start_ms") && t.payload.contains("stop_ms"))
+                        {
+                            startMs = t.payload.at("start_ms").get<long long>();
+                            stopMs = t.payload.at("stop_ms").get<long long>();
+                        }
+                        else if (t.payload.contains("start") && t.payload.contains("stop"))
+                        {
+                            auto s = snoop::DeviceControlService::ParseRfc3339UtcToMs(t.payload["start"].get<std::string>());
+                            auto e = snoop::DeviceControlService::ParseRfc3339UtcToMs(t.payload["stop"].get<std::string>());
+                            if (!s || !e)
+                                throw std::runtime_error("Invalid RFC3339 times");
+                            startMs = *s;
+                            stopMs = *e;
+                        }
+                        else if (t.payload.contains("start") && t.payload["start"].is_string() && t.payload["start"].get<std::string>() == "now" && t.payload.contains("for_s"))
+                        {
+                            startMs = snoop::DeviceControlService::NowMs();
+                            stopMs = startMs + t.payload["for_s"].get<long long>() * 1000LL;
+                        }
+                        else
+                        {
+                            throw std::runtime_error("Missing/invalid start/stop time");
+                        }
+                        if (stopMs <= startMs)
+                            throw std::runtime_error("stop <= start");
+
+                        g_taskSvc->ArmDeepSleep(startMs, stopMs);
+                        return snoop::DeviceControlService::HandlerResult{
+                            true,
+                            std::string("{\"start_ms\":") + std::to_string(startMs) + ",\"stop_ms\":" + std::to_string(stopMs) + "}",
+                            ""};
+                    }
+                    catch (const std::exception &e)
+                    {
+                        return snoop::DeviceControlService::HandlerResult{false, "{}", e.what()};
+                    }
                 };
 
-                static std::unique_ptr<snoop::DeviceControlService> g_taskSvc;
-                g_taskSvc = std::make_unique<snoop::DeviceControlService>(configService, handlers);
+                // static std::unique_ptr<snoop::DeviceControlService> g_taskSvc;
+                // g_taskSvc = std::make_unique<snoop::DeviceControlService>(configService, handlers);
             }
-            auto sioClient = std::make_shared<sio::client>();
-            sioClient->connect(configService->GetBaseUrl());
-
-            auto writerService = std::make_shared<AudioWriterService>(configService, "records");
-            AudioStreamService streamer(sioClient, configService->GetGuid());
-            TAudioEncoder encoder(sampleRate, channels, framesPerBuffer, [&](auto input, auto size) -> int
-                                  {
-             streamer.SendAudioData( input, size );
-             writerService->WriteAudioData( input, size, framesPerBuffer );
-             return paContinue; });
 
             while (true)
             {
-                sleep(1000);
+                std::this_thread::sleep_for(std::chrono::seconds(1));
             }
         }
         catch (const std::exception &ex)
diff --git a/third_party/libdatachannel b/third_party/libdatachannel
new file mode 160000
index 0000000..d7719c3
--- /dev/null
+++ b/third_party/libdatachannel
@@ -0,0 +1 @@
+Subproject commit d7719c31302e1078908928718b2d86a99bdc7755
diff --git a/third_party/socket.io-client-cpp/.github/workflows/ci.yml b/third_party/socket.io-client-cpp/.github/workflows/ci.yml
deleted file mode 100644
index c8e65c6..0000000
--- a/third_party/socket.io-client-cpp/.github/workflows/ci.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: CI
-
-on:
-  push:
-  pull_request:
-  schedule:
-    - cron: '0 0 * * 0'
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-      fail-fast: false
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2.0.0
-
-    - name: Build project
-      uses: nicledomaS/cmake_build_action@v1.3
-      with:
-        submodule_update: ON
-        run_tests: ON
-        unit_test_build: -DBUILD_UNIT_TESTS=ON
-        cmake_args: -DCMAKE_CXX_FLAGS=-std=c++11
diff --git a/third_party/socket.io-client-cpp/.gitignore b/third_party/socket.io-client-cpp/.gitignore
deleted file mode 100644
index 376798d..0000000
--- a/third_party/socket.io-client-cpp/.gitignore
+++ /dev/null
@@ -1,12 +0,0 @@
-build/
-**/*.user
-
-CMakeCache.txt
-CMakeFiles/
-Makefile
-cmake_install.cmake
-install_manifest.txt
-libsioclient.a
-sio_test
-.DS_Store
-.cache/
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/.gitmodules b/third_party/socket.io-client-cpp/.gitmodules
deleted file mode 100644
index 6c67223..0000000
--- a/third_party/socket.io-client-cpp/.gitmodules
+++ /dev/null
@@ -1,9 +0,0 @@
-[submodule "lib/websocketpp"]
-	path = lib/websocketpp
-	url = https://github.com/zaphoyd/websocketpp.git
-[submodule "lib/rapidjson"]
-	path = lib/rapidjson
-	url = https://github.com/miloyip/rapidjson.git
-[submodule "lib/asio"]
-	path = lib/asio
-	url = https://github.com/chriskohlhoff/asio.git
diff --git a/third_party/socket.io-client-cpp/API.md b/third_party/socket.io-client-cpp/API.md
deleted file mode 100644
index 4ad0e37..0000000
--- a/third_party/socket.io-client-cpp/API.md
+++ /dev/null
@@ -1,209 +0,0 @@
-## API
-### *Overview*
-There're just 3 roles in this library - `socket`, `client` and `message`.
-
-`client` is for physical connection while `socket` is for "namespace" (which is like a logical channel), which means one `socket` paired with one namespace, and one `client` paired with one physical connection.
-
-Since a physical connection can have multiple namespaces (which is called multiplex), a `client` object may have multiple `socket` objects, each of which is bound to a distinct `namespace`.
-
-Use `client` to setup the connection to the server, manange the connection status, also session id for the connection.
-
-Use `socket` to send messages under namespace and receives messages in the namespace, also handle special types of message.
-
-The `message` is just about the content you want to send, with text, binary or structured combinations.
-
-### *Socket*
-#### Constructors
-Sockets are all managed by `client`, no public constructors.
-
-You can get it's pointer by `client.socket(namespace)`.
-
-#### Event Emitter
-`void emit(std::string const& name, message::list const& msglist, std::function<void (message::ptr const&)> const& ack)`
-
-Universal event emission interface, by applying implicit conversion magic, it is backward compatible with all previous `emit` interfaces.
-
-#### Event Bindings
-`void on(std::string const& event_name,event_listener const& func)`
-
-`void on(std::string const& event_name,event_listener_aux const& func)`
-
-Bind a callback to specified event name. Same as `socket.on()` function in JS, `event_listener` is for full content event object, `event_listener_aux` is for convenience.
-
-`void off(std::string const& event_name)`
-
-Unbind the event callback with specified name.
-
-`void off_all()`
-
-Clear all event bindings (not including the error listener).
-
-`void on_error(error_listener const& l)`
-
-Bind the error handler for socket.io error messages.
-
-`void off_error()`
-
-Unbind the error handler.
-
-```C++
-//event object:
-class event
-{
-public:
-    const std::string& get_nsp() const;
-
-    const std::string& get_name() const;
-
-    const message::ptr& get_message() const;
-
-    bool need_ack() const;
-
-    void put_ack_message(message::ptr const& ack_message);
-
-    message::ptr const& get_ack_message() const;
-   ...
-};
-//event listener declare:
-typedef std::function<void(const std::string& name,message::ptr const& message,bool need_ack, message::ptr& ack_message)> event_listener_aux;
-
-typedef std::function<void(event& event)> event_listener;
-
-typedef std::function<void(message::ptr const& message)> error_listener;
-
-```
-
-#### Connect and close socket
-`connect` will happen for existing `socket`s automatically when `client` have opened up the physical connection.
-
-`socket` opened with connected `client` will connect to its namespace immediately.
-
-`void close()`
-
-Positively disconnect from namespace.
-
-#### Get name of namespace
-`std::string const& get_namespace() const`
-
-Get current namespace name which the client is inside.
-
-### *Client*
-#### Constructors
-`client()` default constructor.
-
-#### Connection Listeners
-`void set_open_listener(con_listener const& l)`
-
-Call when websocket is open, especially means good connectivity.
-
-`void set_fail_listener(con_listener const& l)`
-
-Call when failed in connecting.
-
-`void set_close_listener(close_listener const& l)`
-
-Call when closed or drop. See `client::close_reason`
-
-```C++
-//connection listener declare:
-enum close_reason
-{
-    close_reason_normal,
-    close_reason_drop
-};
-typedef std::function<void(void)> con_listener;
-
-typedef std::function<void(close_reason const& reason)> close_listener;
-```
-#### Socket listeners
-`void set_socket_open_listener(socket_listener const& l)`
-
-Set listener for socket connect event, called when any sockets being ready to send message.
-
-`void set_socket_close_listener(socket_listener const& l)`
-
-Set listener for socket close event, called when any sockets being closed, afterward, corresponding `socket` object will be cleared from client.
-
-```C++
-    //socket_listener declare:
-    typedef std::function<void(std::string const& nsp)> socket_listener;
-```
-
-#### Connect and Close
-`void connect(const std::string& uri)`
-
-Connect to socket.io server, e.g., `client.connect("ws://localhost:3000");`
-
-`void close()`
-
-Close the client, return immediately.
-
-`void sync_close()`
-
-Close the client, don't return until it is really closed.
-
-`bool opened() const`
-
-Check if client's connection is opened.
-
-#### Transparent reconnecting
-`void set_reconnect_attempts(int attempts)`
-
-Set max reconnect attempts, set to 0 to disable transparent reconnecting.
-
-`void set_reconnect_delay(unsigned millis)`
-
-Set minimum delay for reconnecting, this is the delay for 1st reconnecting attempt,
-then the delay duration grows by attempts made.
-
-`void set_reconnect_delay_max(unsigned millis)`
-
-Set maximum delay for reconnecting.
-
-`void set_reconnecting_listener(con_listener const& l)`
-
-Set listener for reconnecting is in process.
-
-`void set_reconnect_listener(reconnect_listener const& l)`
-
-Set listener for reconnecting event, called once a delayed connecting is scheduled.
-
-#### Logs
-`void set_logs_default()`
-
-Configure logs to the default level (connect, disconnect, app)
-
-`void set_logs_quiet()`
-
-Configure logs to the quiet level
-
-`void set_logs_verbose()`
-
-Configure logs to the verbose level
-
-#### Namespace
-`socket::ptr socket(std::string const& nsp)`
-
-Get a pointer to a socket which is paired with the specified namespace.
-
-#### Session ID
-`std::string const& get_sessionid() const`
-
-Get socket.io session id.
-
-### *Message*
-`message` Base class of all message object.
-
-`int_message` message contains a 64-bit integer.
-
-`double_message` message contains a double.
-
-`string_message` message contains a string.
-
-`array_message` message contains a `vector<message::ptr>`.
-
-`object_message` message contains a `map<string,message::ptr>`.
-
-`message::ptr` pointer to `message` object, it will be one of its derived classes, judge by `message.get_flag()`.
-
-All designated constructor of `message` objects is hidden, you need to create message and get the `message::ptr` by `[derived]_message:create()`.
diff --git a/third_party/socket.io-client-cpp/CHANGELOG.md b/third_party/socket.io-client-cpp/CHANGELOG.md
deleted file mode 100644
index d169167..0000000
--- a/third_party/socket.io-client-cpp/CHANGELOG.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# [2.1.0](https://github.com/socketio/socket.io-client-cpp/compare/2.0.0...2.1.0) (2021-10-12)
-
-
-### Bug Fixes
-
-* fix ASIO_STANDALONE release build trying to use boost::random ([#301](https://github.com/socketio/socket.io-client-cpp/issues/301)) ([168ce9d](https://github.com/socketio/socket.io-client-cpp/commit/168ce9d10b4ac667c43fe16b4cf530f6a3749235))
-* fix LOG call syntax ([#301](https://github.com/socketio/socket.io-client-cpp/issues/301)) ([c09221f](https://github.com/socketio/socket.io-client-cpp/commit/c09221f357effe1a5a0fc0e7d7902eba1ab0484d))
-
-
-### Features
-
-* support TLSv1.2 and newer ([#321](https://github.com/socketio/socket.io-client-cpp/issues/321)) ([7c60ba9](https://github.com/socketio/socket.io-client-cpp/commit/7c60ba9d1e5e58de57f127025bcf69f4baecd2b4))
-
-
-
-# [3.1.0](https://github.com/socketio/socket.io-client-cpp/compare/3.0.0...3.1.0) (2021-10-12)
-
-
-### Bug Fixes
-
-* lower the minimum CMake supported version ([b196fa7](https://github.com/socketio/socket.io-client-cpp/commit/b196fa7537cd3f7bed626ead873a7b71d1293c0d))
-* handle closing sockets upon on_fail events ([d1c73b7](https://github.com/socketio/socket.io-client-cpp/commit/d1c73b73a8f536da3d353eac2a560af9791b13e3))
-* resolve client_impl::ping LOG call syntax in debug builds ([e7de4eb](https://github.com/socketio/socket.io-client-cpp/commit/e7de4ebf64f4f49e18594a2c093c07beb963579a))
-
-
-### Features
-
-* allow resource path to be set in connection URI ([#134](https://github.com/socketio/socket.io-client-cpp/issues/134)) ([36a8cd4](https://github.com/socketio/socket.io-client-cpp/commit/36a8cd45272aa51f0f6ef27aa4744dbc6e8421f7))
-* add support for logging configuration ([1b42ce7](https://github.com/socketio/socket.io-client-cpp/commit/1b42ce738f4c3e260f79bcb143bfe6efcdce5709))
-* support TLSv1.2 and newer ([#321](https://github.com/socketio/socket.io-client-cpp/issues/321)) ([82d39a9](https://github.com/socketio/socket.io-client-cpp/commit/82d39a90ef118500a0329d214eec331db983bd74))
-
-
-
-# [3.0.0](https://github.com/socketio/socket.io-client-cpp/compare/2.0.0...3.0.0) (2021-01-09)
-
-
-### Features
-
-* add support for Socket.IO v3 ([ec4d540](https://github.com/socketio/socket.io-client-cpp/commit/ec4d540ad54593604ac2091e67ffc2a6d9a00db6))
-
diff --git a/third_party/socket.io-client-cpp/CMakeLists.txt b/third_party/socket.io-client-cpp/CMakeLists.txt
deleted file mode 100644
index 150cc33..0000000
--- a/third_party/socket.io-client-cpp/CMakeLists.txt
+++ /dev/null
@@ -1,177 +0,0 @@
-cmake_minimum_required(VERSION 3.12...3.27)
-
-PROJECT(sioclient
-    VERSION 3.1.0
-)
-
-option(BUILD_SHARED_LIBS "Build the shared library" OFF)
-option(BUILD_UNIT_TESTS "Builds unit tests target" OFF)
-option(USE_SUBMODULES "Use source in local submodules instead of system libraries" ON)
-option(DISABLE_LOGGING "Do not print logging messages" OFF)
-
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-    set(DEFAULT_BUILD_TYPE "Release")
-    message(STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as none was specified.")
-    set(CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE STRING "Choose the type of build." FORCE)
-
-    # Set the possible values of build type for cmake-gui
-    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
-endif()
-
-# Only do these if this is the main project, and not if it is included through add_subdirectory
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-    # Testing only available if this is the main app
-    # Note this needs to be done in the main CMakeLists
-    # since it calls enable_testing, which must be in the
-    # main CMakeLists.
-    include(CTest)
-endif()
-
-add_definitions(
-    # These will force ASIO to compile without Boost
-    -DBOOST_DATE_TIME_NO_LIB
-    -DBOOST_REGEX_NO_LIB
-    -DASIO_STANDALONE
-
-    # These will force sioclient to compile with C++11
-    -D_WEBSOCKETPP_CPP11_STL_
-    -D_WEBSOCKETPP_CPP11_FUNCTIONAL_
-    -D_WEBSOCKETPP_CPP11_TYPE_TRAITS_
-    -D_WEBSOCKETPP_CPP11_CHRONO_
-)
-
-if (DISABLE_LOGGING)
-    add_definitions(-DSIO_DISABLE_LOGGING)
-endif()
-
-set(ALL_SRC
-    "src/sio_client.cpp"
-    "src/sio_socket.cpp"
-    "src/internal/sio_client_impl.cpp"
-    "src/internal/sio_packet.cpp"
-)
-add_library(sioclient ${ALL_SRC})
-
-if(USE_SUBMODULES)
-    set(MODULE_INCLUDE_DIRS
-        ${CMAKE_CURRENT_LIST_DIR}/lib/websocketpp
-        ${CMAKE_CURRENT_LIST_DIR}/lib/rapidjson/include
-        ${CMAKE_CURRENT_LIST_DIR}/lib/asio/asio/include
-    )
-else()
-    find_package(websocketpp CONFIG REQUIRED)
-    find_package(asio CONFIG REQUIRED)
-    find_package(RapidJSON CONFIG REQUIRED)
-    target_link_libraries(sioclient PRIVATE websocketpp::websocketpp asio::asio rapidjson)
-endif()
-
-include(GNUInstallDirs)
-
-target_include_directories(sioclient
-    PUBLIC
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    PRIVATE
-    ${MODULE_INCLUDE_DIRS}
-)
-
-target_compile_features(sioclient PUBLIC cxx_std_11)
-
-find_package(Threads REQUIRED)
-target_link_libraries(sioclient PUBLIC Threads::Threads)
-
-if(BUILD_SHARED_LIBS)
-    set_target_properties(sioclient
-        PROPERTIES
-        SOVERSION ${PROJECT_VERSION_MAJOR}
-        VERSION ${PROJECT_VERSION}
-    )
-endif()
-
-list(APPEND TARGET_LIBRARIES sioclient)
-
-find_package(OpenSSL)
-
-if(OPENSSL_FOUND)
-    add_library(sioclient_tls ${ALL_SRC})
-    target_include_directories(sioclient_tls PUBLIC
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-        PRIVATE
-        ${MODULE_INCLUDE_DIRS}
-        ${OPENSSL_INCLUDE_DIR}
-    )
-
-    target_compile_features(sioclient_tls PUBLIC cxx_std_11)
-    target_link_libraries(sioclient_tls PRIVATE OpenSSL::SSL OpenSSL::Crypto)
-    if (NOT USE_SUBMODULES)
-        target_link_libraries(sioclient_tls PRIVATE websocketpp::websocketpp asio asio::asio rapidjson)
-    endif()
-
-    target_compile_definitions(sioclient_tls PRIVATE -DSIO_TLS)
-    target_link_libraries(sioclient_tls PUBLIC Threads::Threads)
-
-    if(BUILD_SHARED_LIBS)
-        set_target_properties(sioclient_tls
-            PROPERTIES
-            SOVERSION ${PROJECT_VERSION_MAJOR}
-            VERSION ${PROJECT_VERSION}
-        )
-    endif()
-
-    list(APPEND TARGET_LIBRARIES sioclient_tls)
-endif()
-
-export(PACKAGE sioclient)
-
-file(GLOB ALL_HEADERS ${CMAKE_CURRENT_LIST_DIR}/src/*.h)
-install(FILES ${ALL_HEADERS}
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)
-
-install(TARGETS ${TARGET_LIBRARIES} EXPORT sioclientTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
-# === generate a CMake Config File ===
-include(CMakePackageConfigHelpers)
-set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/sioclient)
-string(REGEX REPLACE "([^;]+)" "find_dependency(\\1)" _find_dependency_calls "${_package_dependencies}")
-string(REPLACE ";" "\n" _find_dependency_calls "${_find_dependency_calls}")
-
-write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientConfigVersion.cmake"
-    VERSION ${sioclient_VERSION}
-    COMPATIBILITY AnyNewerVersion
-)
-
-export(EXPORT sioclientTargets
-    FILE "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientTargets.cmake"
-    NAMESPACE sioclient::
-)
-
-configure_package_config_file(sioclientConfig.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientConfig.cmake"
-    INSTALL_DESTINATION "${ConfigPackageLocation}"
-)
-
-install(EXPORT sioclientTargets
-    NAMESPACE
-    sioclient::
-    DESTINATION
-    ${ConfigPackageLocation}
-)
-install(
-    FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientConfig.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientConfigVersion.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/sioclient/sioclientTargets.cmake"
-    DESTINATION
-    ${ConfigPackageLocation}
-)
-
-if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING) OR BUILD_UNIT_TESTS)
-    add_subdirectory(test)
-endif()
diff --git a/third_party/socket.io-client-cpp/INSTALL.md b/third_party/socket.io-client-cpp/INSTALL.md
deleted file mode 100644
index 480ed04..0000000
--- a/third_party/socket.io-client-cpp/INSTALL.md
+++ /dev/null
@@ -1,39 +0,0 @@
-## Install
-
-### With CMake
-1. Use `git clone --recurse-submodules https://github.com/socketio/socket.io-client-cpp.git` to clone your local repo.
-2. Run `cmake  ./`
-3. Run `make install`(if makefile generated) or open generated project (if project file generated) to build.
-4. Outputs is under `./build`, link with the all static libs under `./build/lib` and  include headers under `./build/include` in your client code where you want to use it.
-
-### Without CMake
-1. Use `git clone --recurse-submodules https://github.com/socketio/socket.io-client-cpp.git` to clone your local repo.
-2. Add `./lib/asio/asio/include`, `./lib/websocketpp` and `./lib/rapidjson/include` to headers search path.
-3. Include all files under `./src` in your project, add `sio_client.cpp`,`sio_socket.cpp`,`internal/sio_client_impl.cpp`, `internal/sio_packet.cpp` to source list.
-4. Add `BOOST_DATE_TIME_NO_LIB`, `BOOST_REGEX_NO_LIB`, `ASIO_STANDALONE`, `_WEBSOCKETPP_CPP11_STL_` and `_WEBSOCKETPP_CPP11_FUNCTIONAL_` to the preprocessor definitions
-5. Include `sio_client.h` in your client code where you want to use it.
-
-### With vcpkg
-
-You can download and install the Socket.IO C++ client using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
-
-```bash
-git clone https://github.com/Microsoft/vcpkg.git
-cd vcpkg
-./bootstrap-vcpkg.sh
-./vcpkg integrate install
-./vcpkg install socket-io-client
-```
-
-The Socket.IO client port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
-
-### With Conan
-
-You can install pre-built binaries for Socket.IO C++ client or build it from source using [Conan](https://conan.io/). Use the following command:
-
-```
-conan install --requires="sioclient/[*]" --build=missing
-```
-
-The Socket.IO client Conan recipe is kept up to date by Conan maintainers and community contributors.
-If the version is out of date, please [create an issue or pull request](https://github.com/conan-io/conan-center-index) on the ConanCenterIndex repository.
diff --git a/third_party/socket.io-client-cpp/INSTALL_IOS.md b/third_party/socket.io-client-cpp/INSTALL_IOS.md
deleted file mode 100644
index e154cf8..0000000
--- a/third_party/socket.io-client-cpp/INSTALL_IOS.md
+++ /dev/null
@@ -1,27 +0,0 @@
-## iOS
-
-### Option 1: Create a static library
-
-1. Create a static library
-1. Copy the header files into xcode
-
-Use the static libraries generated by the example project [iOS example project](examples/iOS)
-
-Create one for
-- release iphoneos
-- release simulator
-- debug iphoneos
-- debug simulator
-
-Join the debug libraries and the release libraries with e.g.
-```
-libtool -static -o libUniversalRelease.a Release-iphoneos/libsioclient.a Release-iphonesimulator/libsioclient.a
-libtool -static -o libUniversalDebug.a Debug-iphoneos/libsioclient.a Debug-iphonesimulator/libsioclient.a
-```
-
-
-### Option 2: Manual integration
-
-Use this [shell](https://gist.github.com/melode11/a90114a2abf009ca22ea) to download and build boost completely automattically. It installs boost to `<shell folder>/prefix`.
-
-See the [iOS example project](examples/iOS) for how to integrate the rest.
diff --git a/third_party/socket.io-client-cpp/LICENSE b/third_party/socket.io-client-cpp/LICENSE
deleted file mode 100644
index fe9aa3b..0000000
--- a/third_party/socket.io-client-cpp/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2015, Melo Yao
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to all conditions.
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/third_party/socket.io-client-cpp/README.md b/third_party/socket.io-client-cpp/README.md
deleted file mode 100644
index 3b09397..0000000
--- a/third_party/socket.io-client-cpp/README.md
+++ /dev/null
@@ -1,131 +0,0 @@
-# Socket.IO C++ Client
-
-[![Build Status](https://github.com/socketio/socket.io-client-cpp/workflows/CI/badge.svg)](https://github.com/socketio/socket.io-client-cpp/actions)
-
-By virtue of being written in C++, this client works in several different platforms. The [examples](https://github.com/socketio/socket.io-client-cpp/tree/master/examples) folder contains an iPhone, QT and Console example chat client! It depends on [websocket++](https://github.com/zaphoyd/websocketpp) and is inspired by [socket.io-clientpp](https://github.com/ebshimizu/socket.io-clientpp).
-
-[![Clients with iPhone, QT, Console and web](https://cldup.com/ukvVVZmvYV.png)](https://github.com/socketio/socket.io-client-cpp/tree/master/examples)
-
-## Compatibility table
-
-<table>
-  <tr>
-    <th rowspan="2">C++ Client version</th>
-    <th colspan="2">Socket.IO server version</th>
-  </tr>
-  <tr>
-    <td align="center">1.x / 2.x</td>
-    <td align="center">3.x / 4.x</td>
-  </tr>
-  <tr>
-    <td>2.x (<code>2.x</code> branch)</td>
-    <td align="center">YES</td>
-    <td align="center">YES, with <code><a href="https://socket.io/docs/v4/server-initialization/#allowEIO3">allowEIO3: true</a></code></td>
-  </tr>
-  <tr>
-    <td>3.x (<code>master</code> branch)</td>
-    <td align="center">NO</td>
-    <td align="center">YES</td>
-  </tr>
-</table>
-
-## Features
-
-- 100% written in modern C++11
-- Binary support
-- Automatic JSON encoding
-- Multiplex support
-- Similar API to the Socket.IO JS client
-- Cross platform
-
-Note: Only the WebSocket transport is currently implemented (no fallback to HTTP long-polling)
-
-## Installation alternatives
-
-* [With CMAKE](./INSTALL.md#with-cmake)
-* [Without CMAKE](./INSTALL.md#without-cmake)
-* [With VCPKG](./INSTALL.md#with-vcpkg)
-* [With Conan](./INSTALL.md#with-conan)
-* [iOS and OS X](./INSTALL_IOS.md)
- * Option 1: Cocoapods
- * Option 2: Create a static library
- * Option 3: Manual integration
-
-
-## Quickstart
-
-** [Full overview of API can be seen here](./API.md) **
-
-
-The APIs are similar to the JS client.
-
-#### Connect to a server
-```C++
-sio::client h;
-h.connect("http://127.0.0.1:3000");
-```
-
-#### Emit an event
-
-```C++
-// emit event name only:
-h.socket()->emit("login");
-
-// emit text
-h.socket()->emit("add user", username);
-
-// emit binary
-char buf[100];
-h.socket()->emit("add user", std::make_shared<std::string>(buf,100));
-
-// emit message object with lambda ack handler
-h.socket()->emit("add user", string_message::create(username), [&](message::list const& msg) {
-});
-
-// emit multiple arguments
-message::list li("sports");
-li.push(string_message::create("economics"));
-socket->emit("categories", li);
-```
-Items in `message::list` will be expanded in server side event callback function as function arguments.
-
-#### Bind an event
-
-##### Bind with function pointer
-```C++
-void OnMessage(sio::event &)
-{
-
-}
-h.socket()->on("new message", &OnMessage);
-```
-
-##### Bind with lambda
-```C++
-h.socket()->on("login", [&](sio::event& ev)
-{
-    //handle login message
-    //post to UI thread if any UI updating.
-});
-```
-
-##### Bind with member function
-```C++
-class MessageHandler
-{
-public:
-    void OnMessage(sio::event &);
-};
-MessageHandler mh;
-h.socket()->on("new message",std::bind( &MessageHandler::OnMessage,&mh,std::placeholders::_1));
-```
-
-#### Using namespace
-```C++
-h.socket("/chat")->emit("add user", username);
-```
-** [Full overview of API can be seen here](./API.md) **
-
-## License
-
-MIT
diff --git a/third_party/socket.io-client-cpp/examples/Console/CMakeLists.txt b/third_party/socket.io-client-cpp/examples/Console/CMakeLists.txt
deleted file mode 100644
index 0ca9213..0000000
--- a/third_party/socket.io-client-cpp/examples/Console/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
-find_package(Threads REQUIRED)
-include(${CMAKE_CURRENT_SOURCE_DIR}/../../CMakeLists.txt)
-add_executable(sio_console_demo main.cpp)
-target_link_libraries(sio_console_demo sioclient)
-target_link_libraries(sio_console_demo Threads::Threads)
-target_compile_features(sio_console_demo PRIVATE cxx_std_11)
-message(STATUS ${Boost_INCLUDE_DIRS} )
-#target_include_directories(sio_console_demo PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../src" ${Boost_INCLUDE_DIRS} )
diff --git a/third_party/socket.io-client-cpp/examples/Console/README.md b/third_party/socket.io-client-cpp/examples/Console/README.md
deleted file mode 100644
index 95bc4db..0000000
--- a/third_party/socket.io-client-cpp/examples/Console/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-#SioChatDemo setup
-This Demo is create with `Visual Studio 2012 Update 4` , It is a simple console app, connect to official [socket.io chatroom example](https://github.com/Automattic/socket.io/tree/master/examples/chat) as a chat client.
-
-You can choose a nickname, send/receive message in the chat room, and see join/left information as well.
-##boost for windows
-Please download boost package from [boost.org](www.boost.org), and unpack to `boost` folder.
-Please make sure there's no redundent folder levels under it (by check if `bootstrap.bat` is directly under `boost` folder).
-
-cd to `boost` folder, and run `bootstrap.bat`
-
-Then run:
-
- ```shell
- bjam stage --toolset=msvc --with-system --with-date_time --with-random --stagedir="release" link=static runtime-link=shared threading=multi release
- bjam stage --toolset=msvc --with-system --with-date_time --with-random --stagedir="debug" link=static runtime-link=shared threading=multi debug
- ```
-After done this, use Visual studio command line tool, go to `boost\release` folder, run
-
-```shell
-lib.exe /OUT:boost.lib *
-```
-
-And do then same thing in `boost\debug` folder.
-
-then you can open the VS project `SioChatDemo.sln` to build and run.
-
-##Visual studio version
-Microsoft start to support c++11 after `Visual studio 2012 Update 4`. Please make sure you're using up-to-date version.
diff --git a/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.sln b/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.sln
deleted file mode 100644
index 8f76064..0000000
--- a/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.sln
+++ /dev/null
@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SioChatDemo", "SioChatDemo.vcxproj", "{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}.Debug|Win32.ActiveCfg = Debug|Win32
-		{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}.Debug|Win32.Build.0 = Debug|Win32
-		{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}.Release|Win32.ActiveCfg = Release|Win32
-		{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.vcxproj b/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.vcxproj
deleted file mode 100644
index 470e82f..0000000
--- a/third_party/socket.io-client-cpp/examples/Console/SioChatDemo/SioChatDemo.vcxproj
+++ /dev/null
@@ -1,101 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{3503FCEB-2C8E-441A-A57C-B9DEE9171CF4}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <RootNamespace>SioChatDemo</RootNamespace>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v110</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>D:\BoostRoot\include\boost-1_55;$(SolutionDir)..\..\..\lib\websocketpp;$(SolutionDir)..\..\..\lib\rapidjson\include;$(IncludePath)</IncludePath>
-    <LibraryPath>D:\boost_1_55_0\boost_build\debug\lib;$(SolutionDir)boost\$(Configuration)\lib;$(LibraryPath)</LibraryPath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(SolutionDir)boost;$(SolutionDir)..\..\..\lib\websocketpp;$(SolutionDir)..\..\..\lib\rapidjson\include;$(IncludePath)</IncludePath>
-    <LibraryPath>$(SolutionDir)boost\$(Configuration)\lib;$(LibraryPath)</LibraryPath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>_SCL_SECURE_NO_WARNINGS;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <SDLCheck>true</SDLCheck>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>boost.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>_SCL_SECURE_NO_WARNINGS;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <SDLCheck>true</SDLCheck>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>boost.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="..\..\..\src\internal\sio_client_impl.h" />
-    <ClInclude Include="..\..\..\src\internal\sio_packet.h" />
-    <ClInclude Include="..\..\..\src\sio_client.h" />
-    <ClInclude Include="..\..\..\src\sio_message.h" />
-    <ClInclude Include="..\..\..\src\sio_socket.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\..\..\src\internal\sio_client_impl.cpp" />
-    <ClCompile Include="..\..\..\src\internal\sio_packet.cpp" />
-    <ClCompile Include="..\..\..\src\sio_client.cpp" />
-    <ClCompile Include="..\..\..\src\sio_socket.cpp" />
-    <ClCompile Include="..\main.cpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/examples/Console/main.cpp b/third_party/socket.io-client-cpp/examples/Console/main.cpp
deleted file mode 100644
index 9a95dfb..0000000
--- a/third_party/socket.io-client-cpp/examples/Console/main.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-//  sio_test_sample.cpp
-//
-//  Created by Melo Yao on 3/24/15.
-//
-
-#include "../../src/sio_client.h"
-
-#include <functional>
-#include <iostream>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <string>
-#ifdef WIN32
-#define HIGHLIGHT(__O__) std::cout<<__O__<<std::endl
-#define EM(__O__) std::cout<<__O__<<std::endl
-
-#include <stdio.h>
-#include <tchar.h>
-#define MAIN_FUNC int _tmain(int argc, _TCHAR* argv[])
-#else
-#define HIGHLIGHT(__O__) std::cout<<"\e[1;31m"<<__O__<<"\e[0m"<<std::endl
-#define EM(__O__) std::cout<<"\e[1;30;1m"<<__O__<<"\e[0m"<<std::endl
-
-#define MAIN_FUNC int main(int argc ,const char* args[])
-#endif
-
-using namespace sio;
-using namespace std;
-std::mutex _lock;
-
-std::condition_variable_any _cond;
-bool connect_finish = false;
-
-class connection_listener
-{
-    sio::client &handler;
-
-public:
-    
-    connection_listener(sio::client& h):
-    handler(h)
-    {
-    }
-    
-
-    void on_connected()
-    {
-        _lock.lock();
-        _cond.notify_all();
-        connect_finish = true;
-        _lock.unlock();
-    }
-    void on_close(client::close_reason const& reason)
-    {
-        std::cout<<"sio closed "<<std::endl;
-        exit(0);
-    }
-    
-    void on_fail()
-    {
-        std::cout<<"sio failed "<<std::endl;
-        exit(0);
-    }
-};
-
-int participants = -1;
-
-socket::ptr current_socket;
-
-void bind_events()
-{
-	current_socket->on("new message", sio::socket::event_listener_aux([&](string const& name, message::ptr const& data, bool isAck,message::list &ack_resp)
-                       {
-                           _lock.lock();
-                           string user = data->get_map()["username"]->get_string();
-                           string message = data->get_map()["message"]->get_string();
-                           EM(user<<":"<<message);
-                           _lock.unlock();
-                       }));
-    
-    current_socket->on("user joined",sio::socket::event_listener_aux([&](string const& name, message::ptr const& data, bool isAck,message::list &ack_resp)
-                       {
-                           _lock.lock();
-                           string user = data->get_map()["username"]->get_string();
-                           participants  = data->get_map()["numUsers"]->get_int();
-                           bool plural = participants !=1;
-                           
-                           //     abc "
-                           HIGHLIGHT(user<<" joined"<<"\nthere"<<(plural?" are ":"'s ")<< participants<<(plural?" participants":" participant"));
-                           _lock.unlock();
-                       }));
-    current_socket->on("user left", sio::socket::event_listener_aux([&](string const& name, message::ptr const& data, bool isAck,message::list &ack_resp)
-                       {
-                           _lock.lock();
-                           string user = data->get_map()["username"]->get_string();
-                           participants  = data->get_map()["numUsers"]->get_int();
-                           bool plural = participants !=1;
-                           HIGHLIGHT(user<<" left"<<"\nthere"<<(plural?" are ":"'s ")<< participants<<(plural?" participants":" participant"));
-                           _lock.unlock();
-                       }));
-}
-
-MAIN_FUNC
-{
-
-    sio::client h;
-    connection_listener l(h);
-    
-    h.set_open_listener(std::bind(&connection_listener::on_connected, &l));
-    h.set_close_listener(std::bind(&connection_listener::on_close, &l,std::placeholders::_1));
-    h.set_fail_listener(std::bind(&connection_listener::on_fail, &l));
-    h.connect("http://127.0.0.1:3000");
-    _lock.lock();
-    if(!connect_finish)
-    {
-        _cond.wait(_lock);
-    }
-    _lock.unlock();
-	current_socket = h.socket();
-Login:
-    string nickname;
-    while (nickname.length() == 0) {
-        HIGHLIGHT("Type your nickname:");
-        
-        getline(cin, nickname);
-    }
-	current_socket->on("login", sio::socket::event_listener_aux([&](string const& name, message::ptr const& data, bool isAck,message::list &ack_resp){
-        _lock.lock();
-        participants = data->get_map()["numUsers"]->get_int();
-        bool plural = participants !=1;
-        HIGHLIGHT("Welcome to Socket.IO Chat-\nthere"<<(plural?" are ":"'s ")<< participants<<(plural?" participants":" participant"));
-        _cond.notify_all();
-        _lock.unlock();
-        current_socket->off("login");
-    }));
-    current_socket->emit("add user", nickname);
-    _lock.lock();
-    if (participants<0) {
-        _cond.wait(_lock);
-    }
-    _lock.unlock();
-    bind_events();
-    
-    HIGHLIGHT("Start to chat,commands:\n'$exit' : exit chat\n'$nsp <namespace>' : change namespace");
-    for (std::string line; std::getline(std::cin, line);) {
-        if(line.length()>0)
-        {
-            if(line == "$exit")
-            {
-                break;
-            }
-            else if(line.length() > 5&&line.substr(0,5) == "$nsp ")
-            {
-                string new_nsp = line.substr(5);
-                if(new_nsp == current_socket->get_namespace())
-                {
-                    continue;
-                }
-                current_socket->off_all();
-                current_socket->off_error();
-                //per socket.io, default nsp should never been closed.
-                if(current_socket->get_namespace() != "/")
-                {
-                    current_socket->close();
-                }
-                current_socket = h.socket(new_nsp);
-                bind_events();
-                //if change to default nsp, we do not need to login again (since it is not closed).
-                if(current_socket->get_namespace() == "/")
-                {
-                    continue;
-                }
-                goto Login;
-            }
-            current_socket->emit("new message", line);
-            _lock.lock();
-            EM("\t\t\t"<<line<<":"<<"You");
-            _lock.unlock();
-        }
-    }
-    HIGHLIGHT("Closing...");
-    h.sync_close();
-    h.clear_con_listeners();
-	return 0;
-}
-
diff --git a/third_party/socket.io-client-cpp/examples/QT/.gitignore b/third_party/socket.io-client-cpp/examples/QT/.gitignore
deleted file mode 100644
index dd07bff..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-build-*
diff --git a/third_party/socket.io-client-cpp/examples/QT/README.md b/third_party/socket.io-client-cpp/examples/QT/README.md
deleted file mode 100644
index a26610d..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/README.md
+++ /dev/null
@@ -1,290 +0,0 @@
-![Demo shot](https://cldup.com/98tHyoJJE7.gif)
-
-In this tutorial we’ll learn how to create a QT chat application that communicates with a [Socket.IO Node.JS chat server](https://github.com/Automattic/socket.io/tree/master/examples/chat).
-
-### Introduction
-To follow along, start by cloning the repository: [socket.io-client-cpp](https://github.com/socketio/socket.io-client-cpp).
-Using:
-
-```bash
-git clone --recurse-submodules https://github.com/socketio/socket.io-client-cpp.git
-```
-
-The app has the following features:
-
-* Sending a message to all users joining to the room.
-
-* Notifies when each user joins or leaves.
-
-* Notifies when an user start typing a message.
-
-###Install QT community
-Visit [QT community download link](http://www.qt.io/download-open-source/#section-2) to get the install package.
-Just install it with default installation option.
-
-###Create a QT GUI application.
-Launch QT Creator.
-In welcome page, select `New Project`, create a `QT Widget Application`, named it `SioChatDemo`
-The project structure is like:
-
-```
-SioChatDemo
-    |__ SioChatDemo.pro
-    |__Headers
-    |   |__mainwindow.h
-    |__Sources
-    |   |__main.cpp
-    |   |__mainwindow.cpp
-    |__Forms
-        |__mainwindow.ui
-```
-
-### Import SioClient and config compile options.
-Let's copy the SioClient into the QT project as a subfolder `sioclient`.
-
-Edit `SioChatDemo.pro` to config paths and compile options, simply add:
-
-```bash
-SOURCES += ./sioclient/src/sio_client.cpp \
-           ./sioclient/src/sio_packet.cpp 
-
-HEADERS  += ./sioclient/src/sio_client.h \
-            ./sioclient/src/sio_message.h
-
-INCLUDEPATH += $$PWD/sioclient/lib/rapidjson/include
-INCLUDEPATH += $$PWD/sioclient/lib/websocketpp
-```
-
-Also add two additional compile option
-
-```bash
-CONFIG+=no_keywords
-CONFIG+=c++11
-```
-
-`no_keywords` is for preventing qmake treat some function's name `emit` as the keyword of signal-slot mechanism.
-`c++11` ask for C++11 support.
-
-### Make up mainwindow ui.
-Make up a simple ui by drag and drop widget from `Widget box` in left side.
-
-We finally end up with this:
-
-![QT mainwindow](https://cldup.com/RI98CYpYL5.png)
-
-It contains:
-
-* a `QLineEdit` at the top for nickname inputing, named `nickNameEdit`
-
-* a `QPushButton` at the topright for login, named `loginBtn`
-
-* a `QListWidget` at the center for showing messages, named `listView`
-
-* a `QLineEdit` at the bottom for typing message, named `messageEdit`
-
-* a `QPushButton` at the bottomright for sending message, named `sendBtn`
-
-### Add Slots in mainwindow
-Slots need to be added in `mainwindow` class to handle UI events.They are
-
-* click login button
-
-* click send message button
-
-* text change in messageEdit(for typing status)
-
-* message editing is returned (for sending message by return)
-
-Insert following code into `MainWindow` class in `mainwindow.h` 
-
-```C++
-public Q_SLOTS:
-    void SendBtnClicked();
-    void TypingChanged();
-    void LoginClicked();
-    void OnMessageReturn();
-```
-
-### Connect UI event signal and slots together
-Open `mainwindow.ui` in Design mode. switch to `signals/slots` mode by check `Menu->Edit->Edit Signals/Slots`
-
-By press left mouse on widget and drag on to the window (cursor will become a sign of electrical ground), to open the connection editor.
-
-In the connection editor, edit the slots of MainWindow at the right side, add Those slots function name added in `mainwindow.h` before.
-
-Then we'll be able to connect the event signal from widget with our own slots.
-
-We finally end up with this:
-
-![QT signals&slots](https://cldup.com/Vsb-UXG3FC.jpg)
-
-### Adding UI refresh Signals/Slots
-`sio::client`'s callbacks are not in UI thread. However, UI is required to be updated by those callbacks, so we need some `Signal` for non-UI thread to "request" `Slots` functions been called in UI thread. Say if we want to signal `QListWidgetItem` being added, add:
-
-```C++
-//In mainwindow.h
-Q_SIGNALS:
-    void RequestAddListItem(QListWidgetItem *item);
-private Q_SLOTS:
-    void AddListItem(QListWidgetItem *item);
-```
-
-```C++
-//In mainwindow.cpp
-void MainWindow::AddListItem(QListWidgetItem* item)
-{
-    this->findChild<QListWidget*>("listView")->addItem(item);
-}
-```
-
-Then connect them in `MainWindow` constructor.
-
-```C++
-    connect(this,SIGNAL(RequestAddListItem(QListWidgetItem*)),this,SLOT(AddListItem(QListWidgetItem*)));
-```
-
-### Init sio::client in MainWindow
-For single window applications, simply let `MainWindow` class holding the `sio::client` object:
-
-declare a `unique_ptr` member of `sio::client` and Several event handling functions in `mainwindow.h`
-
-```C++
-private:
-    void OnNewMessage(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnUserJoined(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnUserLeft(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnTyping(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnStopTyping(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnLogin(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp);
-    void OnConnected();
-    void OnClosed(client::close_reason const& reason);
-    void OnFailed();
-
-    std::unique_ptr<client> _io;
-```
-
-Init `sio::client` and setup event bindings for default `socket` in `MainWindow` constructor.
-
-And we also need to handle the connectivity events, handle the connect and disconnect events.
-
-Now the `MainWindow` constructor:
-
-```C++
-MainWindow::MainWindow(QWidget *parent) :
-    QMainWindow(parent),
-    ui(new Ui::MainWindow),
-    _io(new client())
-{
-    ui->setupUi(this);
-    using std::placeholders::_1;
-    using std::placeholders::_2;
-    using std::placeholders::_3;
-    using std::placeholders::_4;
-    socket::ptr sock = _io->socket();
-    sock->on("new message",std::bind(&MainWindow::OnNewMessage,this,_1,_2,_3,_4));
-    sock->on("user joined",std::bind(&MainWindow::OnUserJoined,this,_1,_2,_3,_4));
-    sock->on("user left",std::bind(&MainWindow::OnUserLeft,this,_1,_2,_3,_4));
-    sock->on("typing",std::bind(&MainWindow::OnTyping,this,_1,_2,_3,_4));
-    sock->on("stop typing",std::bind(&MainWindow::OnStopTyping,this,_1,_2,_3,_4));
-    sock->on("login",std::bind(&MainWindow::OnLogin,this,_1,_2,_3,_4));
-    //default socket opened, also we have "set_open_listener" for monitoring physical connection opened.
-    _io->set_socket_open_listener(std::bind(&MainWindow::OnConnected,this,std::placeholders::_1));
-    //physical connection closed or drop.
-    _io->set_close_listener(std::bind(&MainWindow::OnClosed,this,_1));
-    //physical connection fail to establish.
-    _io->set_fail_listener(std::bind(&MainWindow::OnFailed,this));
-    connect(this,SIGNAL(RequestAddListItem(QListWidgetItem*)),this,SLOT(AddListItem(QListWidgetItem*)));
-}
-```
-
-### Managing connection state
-We have several connection listeners for connection events.
-
-First we want to send login message once we're connected, get the default `socket` from `client` to do that.
-
-```C++
-void MainWindow::OnConnected()
-{
-    QByteArray bytes = m_name.toUtf8();
-    std::string nickName(bytes.data(),bytes.length());
-    _io->socket()->emit("add user", nickName);
-}
-```
-
-Then if connection is closed or failed, we need to restore to the UI before connect.
-
-```C++
-void MainWindow::OnClosed(client::close_reason const& reason)
-{
-    //restore UI to pre-login state
-}
-
-void MainWindow::OnFailed()
-{
-    //restore UI to pre-login state
-}
-
-```
-
-If `MainWindow` is exit, we need to clear event bindings and listeners.
-
-the `sio::client` object will be destruct by `unique_ptr`
-
-```C++
-MainWindow::~MainWindow()
-{
-    _io->socket()->off_all();
-    _io->socket()->off_error();
-    delete ui;
-}
-```
-
-### Handle socket.io events
-We'll need to handle socket.io events in our functions bind to socket.io events.
-For example, we need to show received messages to the `listView`
-
-```C++
-void MainWindow::OnNewMessage(std::string const& name,message::ptr const& data,bool hasAck,message::ptr &ack_resp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        std::string msg = data->get_map()["message"]->get_string();
-        std::string name = data->get_map()["username"]->get_string();
-        QString label = QString::fromUtf8(name.data(),name.length());
-        label.append(':');
-        label.append(QString::fromUtf8(msg.data(),msg.length()));
-        QListWidgetItem *item= new QListWidgetItem(label);
-        //emit RequestAddListItem signal
-        //so that 'AddListItem' will be executed in UI thread.
-        Q_EMIT RequestAddListItem(item);
-    }
-}
-```
-
-### Sending chat message
-When `sendBtn` is clicked, we need to send the text in `messageEdit` to chatroom.
-Add code to `SendBtnClicked()`:
-
-```C++
-void MainWindow::SendBtnClicked()
-{
-    QLineEdit* messageEdit = this->findChild<QLineEdit*>("messageEdit");
-    QString text = messageEdit->text();
-    if(text.length()>0)
-    {
-        QByteArray bytes = text.toUtf8();
-        std::string msg(bytes.data(),bytes.length());
-        _io->socket()->emit("new message",msg);//emit new message
-        text.append(":You");
-        QListWidgetItem *item = new QListWidgetItem(text);
-        item->setTextAlignment(Qt::AlignRight);
-        Q_EMIT RequestAddListItem(item);
-        messageEdit->clear();
-    }
-}
-```
-
-### Further reading
-You can run [Demo project](https://github.com/socketio/socket.io-client-cpp/tree/master/examples/QT/SioChatDemo) to have a closer look. 
-Before running, please follow the [instructions](../../README.md#with_cmake) to make the sioclient library.
-
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/.gitignore b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/.gitignore
deleted file mode 100644
index adead72..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-SioChatDemo.pro.user
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/SioChatDemo.pro b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/SioChatDemo.pro
deleted file mode 100644
index ff29287..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/SioChatDemo.pro
+++ /dev/null
@@ -1,44 +0,0 @@
-#-------------------------------------------------
-#
-# Project created by QtCreator 2015-03-30T19:25:23
-#
-#-------------------------------------------------
-
-QT       += core gui
-
-greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
-
-TARGET = SioChatDemo
-TEMPLATE = app
-
-CONFIG+=no_keywords
-CONFIG+=c++11
-
-SOURCES += main.cpp\
-        mainwindow.cpp \
-    nicknamedialog.cpp
-
-HEADERS  += mainwindow.h \
-    nicknamedialog.h
-
-FORMS    += mainwindow.ui \
-    nicknamedialog.ui
-
-CONFIG(debug, debug|release):DEFINES +=DEBUG=1
-
-
-INCLUDEPATH += $$PWD/../../../build/include
-DEPENDPATH += $$PWD/../../../build/lib
-
-CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build/lib/Release/ -lsioclient
-else:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build/lib/Debug/ -lsioclient
-
-
-CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build/lib/Release/ -lboost_random
-else:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build/lib/Debug/ -lboost_random
-
-CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build/lib/Release/ -lboost_system
-else:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build/lib/Debug/ -lboost_system
-
-CONFIG(release, debug|release): LIBS += -L$$PWD/../../../build/lib/Release/ -lboost_date_time
-else:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../build/lib/Debug/ -lboost_date_time
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/.gitignore b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/.gitignore
deleted file mode 100644
index d594dec..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-osx/*
-src/*
-src
-osx
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/boost.sh b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/boost.sh
deleted file mode 100644
index 808430f..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/boost/boost.sh
+++ /dev/null
@@ -1,378 +0,0 @@
-#===============================================================================
-# Filename:  boost.sh
-# Author:    Pete Goodliffe
-# Copyright: (c) Copyright 2009 Pete Goodliffe
-# Licence:   Please feel free to use this, with attribution
-# Modified version
-#===============================================================================
-#
-# Builds a Boost framework for the iPhone.
-# Creates a set of universal libraries that can be used on an iPhone and in the
-# iPhone simulator. Then creates a pseudo-framework to make using boost in Xcode
-# less painful.
-#
-# To configure the script, define:
-#    BOOST_LIBS:        which libraries to build
-#    IPHONE_SDKVERSION: iPhone SDK version (e.g. 5.1)
-#
-# Then go get the source tar.bz of the boost you want to build, shove it in the
-# same directory as this script, and run "./boost.sh". Grab a cuppa. And voila.
-#===============================================================================
-
-: ${BOOST_LIBS:="random regex graph random chrono thread signals filesystem system date_time"}
-: ${IPHONE_SDKVERSION:=`xcodebuild -showsdks | grep iphoneos | egrep "[[:digit:]]+\.[[:digit:]]+" -o | tail -1`}
-: ${OSX_SDKVERSION:=10.8}
-: ${XCODE_ROOT:=`xcode-select -print-path`}
-: ${EXTRA_CPPFLAGS:="-DBOOST_AC_USE_PTHREADS -DBOOST_SP_USE_PTHREADS -std=c++11 -stdlib=libc++"}
-
-# The EXTRA_CPPFLAGS definition works around a thread race issue in
-# shared_ptr. I encountered this historically and have not verified that
-# the fix is no longer required. Without using the posix thread primitives
-# an invalid compare-and-swap ARM instruction (non-thread-safe) was used for the
-# shared_ptr use count causing nasty and subtle bugs.
-#
-# Should perhaps also consider/use instead: -BOOST_SP_USE_PTHREADS
-
-: ${TARBALLDIR:=`pwd`}
-: ${SRCDIR:=`pwd`/src}
-: ${IOSBUILDDIR:=`pwd`/ios/build}
-: ${OSXBUILDDIR:=`pwd`/osx/build}
-: ${PREFIXDIR:=`pwd`/ios/prefix}
-: ${IOSFRAMEWORKDIR:=`pwd`/ios/framework}
-: ${OSXFRAMEWORKDIR:=`pwd`/osx/framework}
-: ${COMPILER:="clang++"}
-
-: ${BOOST_VERSION:=1.55.0}
-: ${BOOST_VERSION2:=1_55_0}
-
-BOOST_TARBALL=$TARBALLDIR/boost_$BOOST_VERSION2.tar.bz2
-BOOST_SRC=$SRCDIR/boost_${BOOST_VERSION2}
-
-#===============================================================================
-ARM_DEV_CMD="xcrun --sdk iphoneos"
-SIM_DEV_CMD="xcrun --sdk iphonesimulator"
-OSX_DEV_CMD="xcrun --sdk macosx"
-
-ARM_COMBINED_LIB=$IOSBUILDDIR/lib_boost_arm.a
-SIM_COMBINED_LIB=$IOSBUILDDIR/lib_boost_x86.a
-
-#===============================================================================
-
-
-#===============================================================================
-# Functions
-#===============================================================================
-
-abort()
-{
-    echo
-    echo "Aborted: $@"
-    exit 1
-}
-
-doneSection()
-{
-    echo
-    echo "================================================================="
-    echo "Done"
-    echo
-}
-
-#===============================================================================
-
-cleanEverythingReadyToStart()
-{
-    echo Cleaning everything before we start to build...
-
-    rm -rf iphone-build iphonesim-build osx-build
-    rm -rf $IOSBUILDDIR
-    rm -rf $OSXBUILDDIR
-    rm -rf $PREFIXDIR
-    rm -rf $IOSFRAMEWORKDIR/$FRAMEWORK_NAME.framework
-    rm -rf $OSXFRAMEWORKDIR/$FRAMEWORK_NAME.framework
-
-    doneSection
-}
-
-#===============================================================================
-
-downloadBoost()
-{
-    if [ ! -s $TARBALLDIR/boost_${BOOST_VERSION2}.tar.bz2 ]; then
-        echo "Downloading boost ${BOOST_VERSION}"
-        curl -L -o $TARBALLDIR/boost_${BOOST_VERSION2}.tar.bz2 http://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/boost_${BOOST_VERSION2}.tar.bz2/download
-    fi
-
-    doneSection
-}
-
-#===============================================================================
-
-unpackBoost()
-{
-    [ -f "$BOOST_TARBALL" ] || abort "Source tarball missing."
-
-    echo Unpacking boost into $SRCDIR...
-
-    [ -d $SRCDIR ]    || mkdir -p $SRCDIR
-    [ -d $BOOST_SRC ] || ( cd $SRCDIR; tar xfj $BOOST_TARBALL )
-    [ -d $BOOST_SRC ] && echo "    ...unpacked as $BOOST_SRC"
-
-    doneSection
-}
-
-#===============================================================================
-
-restoreBoost()
-{
-    cp $BOOST_SRC/tools/build/v2/user-config.jam-bk $BOOST_SRC/tools/build/v2/user-config.jam
-}
-
-#===============================================================================
-
-updateBoost()
-{
-    echo Updating boost into $BOOST_SRC...
-
-    cp $BOOST_SRC/tools/build/v2/user-config.jam $BOOST_SRC/tools/build/v2/user-config.jam-bk
-
-    cat >> $BOOST_SRC/tools/build/v2/user-config.jam <<EOF
-using darwin : ${IPHONE_SDKVERSION}~iphone
-: $XCODE_ROOT/Toolchains/XcodeDefault.xctoolchain/usr/bin/$COMPILER -arch armv6 -arch armv7 -arch armv7s -arch arm64 -fvisibility=hidden -fvisibility-inlines-hidden $EXTRA_CPPFLAGS
-: <striper> <root>$XCODE_ROOT/Platforms/iPhoneOS.platform/Developer
-: <architecture>arm <target-os>iphone
-;
-using darwin : ${IPHONE_SDKVERSION}~iphonesim
-: $XCODE_ROOT/Toolchains/XcodeDefault.xctoolchain/usr/bin/$COMPILER -arch i386 -arch x86_64 -fvisibility=hidden -fvisibility-inlines-hidden $EXTRA_CPPFLAGS
-: <striper> <root>$XCODE_ROOT/Platforms/iPhoneSimulator.platform/Developer
-: <architecture>x86 <target-os>iphone
-;
-EOF
-
-    doneSection
-}
-
-#===============================================================================
-
-inventMissingHeaders()
-{
-    # These files are missing in the ARM iPhoneOS SDK, but they are in the simulator.
-    # They are supported on the device, so we copy them from x86 SDK to a staging area
-    # to use them on ARM, too.
-    echo Invent missing headers
-
-    cp $XCODE_ROOT/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator${IPHONE_SDKVERSION}.sdk/usr/include/{crt_externs,bzlib}.h $BOOST_SRC
-}
-
-#===============================================================================
-
-bootstrapBoost()
-{
-    cd $BOOST_SRC
-
-    BOOST_LIBS_COMMA=$(echo $BOOST_LIBS | sed -e "s/ /,/g")
-    echo "Bootstrapping (with libs $BOOST_LIBS_COMMA)"
-    ./bootstrap.sh --with-libraries=$BOOST_LIBS_COMMA
-
-    doneSection
-}
-
-#===============================================================================
-
-buildBoostForIPhoneOS()
-{
-    cd $BOOST_SRC
-
-    # Install this one so we can copy the includes for the frameworks...
-    ./bjam -j16 --build-dir=iphone-build --stagedir=iphone-build/stage --prefix=$PREFIXDIR toolset=darwin architecture=arm target-os=iphone macosx-version=iphone-${IPHONE_SDKVERSION} define=_LITTLE_ENDIAN link=static stage
-    ./bjam -j16 --build-dir=iphone-build --stagedir=iphone-build/stage --prefix=$PREFIXDIR toolset=darwin architecture=arm target-os=iphone macosx-version=iphone-${IPHONE_SDKVERSION} define=_LITTLE_ENDIAN link=static install
-    doneSection
-
-    ./bjam -j16 --build-dir=iphonesim-build --stagedir=iphonesim-build/stage --toolset=darwin-${IPHONE_SDKVERSION}~iphonesim architecture=x86 target-os=iphone macosx-version=iphonesim-${IPHONE_SDKVERSION} link=static stage
-    doneSection
-
-  #  ./b2 -j16 --build-dir=osx-build --stagedir=osx-build/stage toolset=clang cxxflags="-std=c++11 -stdlib=libc++ -arch i386 -arch x86_64" linkflags="-stdlib=libc++" link=static threading=multi stage
-    doneSection
-}
-
-#===============================================================================
-
-scrunchAllLibsTogetherInOneLibPerPlatform()
-{
-    cd $BOOST_SRC
-
-    mkdir -p $IOSBUILDDIR/armv6/obj
-    mkdir -p $IOSBUILDDIR/armv7/obj
-    mkdir -p $IOSBUILDDIR/armv7s/obj
-	mkdir -p $IOSBUILDDIR/arm64/obj
-    mkdir -p $IOSBUILDDIR/i386/obj
-	mkdir -p $IOSBUILDDIR/x86_64/obj
-
-    mkdir -p $OSXBUILDDIR/i386/obj
-    mkdir -p $OSXBUILDDIR/x86_64/obj
-
-    ALL_LIBS=""
-
-    echo Splitting all existing fat binaries...
-
-    for NAME in $BOOST_LIBS; do
-        ALL_LIBS="$ALL_LIBS libboost_$NAME.a"
-
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv6 -o $IOSBUILDDIR/armv6/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv7 -o $IOSBUILDDIR/armv7/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv7s -o $IOSBUILDDIR/armv7s/libboost_$NAME.a
-		$ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin arm64 -o $IOSBUILDDIR/arm64/libboost_$NAME.a
-
-		$ARM_DEV_CMD lipo "iphonesim-build/stage/lib/libboost_$NAME.a" -thin i386 -o $IOSBUILDDIR/i386/libboost_$NAME.a
-		$ARM_DEV_CMD lipo "iphonesim-build/stage/lib/libboost_$NAME.a" -thin x86_64 -o $IOSBUILDDIR/x86_64/libboost_$NAME.a
-
-        $ARM_DEV_CMD lipo "osx-build/stage/lib/libboost_$NAME.a" -thin i386 -o $OSXBUILDDIR/i386/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "osx-build/stage/lib/libboost_$NAME.a" -thin x86_64 -o $OSXBUILDDIR/x86_64/libboost_$NAME.a
-    done
-
-    echo "Decomposing each architecture's .a files"
-
-    for NAME in $ALL_LIBS; do
-        echo Decomposing $NAME...
-        (cd $IOSBUILDDIR/armv6/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/armv7/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/armv7s/obj; ar -x ../$NAME );
-		(cd $IOSBUILDDIR/arm64/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/i386/obj; ar -x ../$NAME );
-		(cd $IOSBUILDDIR/x86_64/obj; ar -x ../$NAME );
-
-        (cd $OSXBUILDDIR/i386/obj; ar -x ../$NAME );
-        (cd $OSXBUILDDIR/x86_64/obj; ar -x ../$NAME );
-    done
-
-    echo "Linking each architecture into an uberlib ($ALL_LIBS => libboost.a )"
-
-    rm $IOSBUILDDIR/*/libboost.a
-    
-    echo ...armv6
-    (cd $IOSBUILDDIR/armv6; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...armv7
-    (cd $IOSBUILDDIR/armv7; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...armv7s
-    (cd $IOSBUILDDIR/armv7s; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...arm64
-    (cd $IOSBUILDDIR/arm64; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...i386
-    (cd $IOSBUILDDIR/i386;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...x86_64
-    (cd $IOSBUILDDIR/x86_64;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-
-    rm $OSXBUILDDIR/*/libboost.a
-    echo ...osx-i386
-    (cd $OSXBUILDDIR/i386;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-
-    echo ...x86_64
-    (cd $OSXBUILDDIR/x86_64;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-}
-
-#===============================================================================
-buildFramework()
-{
-    : ${1:?}
-    FRAMEWORKDIR=$1
-    BUILDDIR=$2
-
-    VERSION_TYPE=Alpha
-    FRAMEWORK_NAME=boost
-    FRAMEWORK_VERSION=A
-
-    FRAMEWORK_CURRENT_VERSION=$BOOST_VERSION
-    FRAMEWORK_COMPATIBILITY_VERSION=$BOOST_VERSION
-
-    FRAMEWORK_BUNDLE=$FRAMEWORKDIR/$FRAMEWORK_NAME.framework
-    echo "Framework: Building $FRAMEWORK_BUNDLE from $BUILDDIR..."
-
-    rm -rf $FRAMEWORK_BUNDLE
-
-    echo "Framework: Setting up directories..."
-    mkdir -p $FRAMEWORK_BUNDLE
-    mkdir -p $FRAMEWORK_BUNDLE/Versions
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Resources
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Headers
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Documentation
-
-    echo "Framework: Creating symlinks..."
-    ln -s $FRAMEWORK_VERSION               $FRAMEWORK_BUNDLE/Versions/Current
-    ln -s Versions/Current/Headers         $FRAMEWORK_BUNDLE/Headers
-    ln -s Versions/Current/Resources       $FRAMEWORK_BUNDLE/Resources
-    ln -s Versions/Current/Documentation   $FRAMEWORK_BUNDLE/Documentation
-    ln -s Versions/Current/$FRAMEWORK_NAME $FRAMEWORK_BUNDLE/$FRAMEWORK_NAME
-
-    FRAMEWORK_INSTALL_NAME=$FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/$FRAMEWORK_NAME
-
-    echo "Lipoing library into $FRAMEWORK_INSTALL_NAME..."
-    $ARM_DEV_CMD lipo -create $BUILDDIR/*/libboost.a -o "$FRAMEWORK_INSTALL_NAME" || abort "Lipo $1 failed"
-
-    echo "Framework: Copying includes..."
-    cp -r $PREFIXDIR/include/boost/*  $FRAMEWORK_BUNDLE/Headers/
-
-    echo "Framework: Creating plist..."
-    cat > $FRAMEWORK_BUNDLE/Resources/Info.plist <<EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-<key>CFBundleDevelopmentRegion</key>
-<string>English</string>
-<key>CFBundleExecutable</key>
-<string>${FRAMEWORK_NAME}</string>
-<key>CFBundleIdentifier</key>
-<string>org.boost</string>
-<key>CFBundleInfoDictionaryVersion</key>
-<string>6.0</string>
-<key>CFBundlePackageType</key>
-<string>FMWK</string>
-<key>CFBundleSignature</key>
-<string>????</string>
-<key>CFBundleVersion</key>
-<string>${FRAMEWORK_CURRENT_VERSION}</string>
-</dict>
-</plist>
-EOF
-
-    doneSection
-}
-
-#===============================================================================
-# Execution starts here
-#===============================================================================
-
-mkdir -p $IOSBUILDDIR
-
-cleanEverythingReadyToStart #may want to comment if repeatedly running during dev
-restoreBoost
-
-echo "BOOST_VERSION:     $BOOST_VERSION"
-echo "BOOST_LIBS:        $BOOST_LIBS"
-echo "BOOST_SRC:         $BOOST_SRC"
-echo "IOSBUILDDIR:       $IOSBUILDDIR"
-echo "OSXBUILDDIR:       $OSXBUILDDIR"
-echo "PREFIXDIR:         $PREFIXDIR"
-echo "IOSFRAMEWORKDIR:   $IOSFRAMEWORKDIR"
-echo "OSXFRAMEWORKDIR:   $OSXFRAMEWORKDIR"
-echo "IPHONE_SDKVERSION: $IPHONE_SDKVERSION"
-echo "XCODE_ROOT:        $XCODE_ROOT"
-echo "COMPILER:          $COMPILER"
-echo
-
-downloadBoost
-unpackBoost
-inventMissingHeaders
-bootstrapBoost
-updateBoost
-buildBoostForIPhoneOS
-scrunchAllLibsTogetherInOneLibPerPlatform
-buildFramework $IOSFRAMEWORKDIR $IOSBUILDDIR
-buildFramework $OSXFRAMEWORKDIR $OSXBUILDDIR
-
-restoreBoost
-
-echo "Completed successfully"
-
-#===============================================================================
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/main.cpp b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/main.cpp
deleted file mode 100644
index b48f94e..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/main.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "mainwindow.h"
-#include <QApplication>
-
-int main(int argc, char *argv[])
-{
-    QApplication a(argc, argv);
-    MainWindow w;
-    w.show();
-
-    return a.exec();
-}
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.cpp b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.cpp
deleted file mode 100644
index 83a4165..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#include "mainwindow.h"
-#include "ui_mainwindow.h"
-#include <functional>
-#include <mutex>
-#include <cstdlib>
-
-#define kURL "ws://localhost:3000"
-#ifdef WIN32
-#define BIND_EVENT(IO,EV,FN) \
-    do{ \
-        socket::event_listener_aux l = FN;\
-        IO->on(EV,l);\
-    } while(0)
-
-#else
-#define BIND_EVENT(IO,EV,FN) \
-    IO->on(EV,FN)
-#endif
-
-MainWindow::MainWindow(QWidget *parent) :
-    QMainWindow(parent),
-    ui(new Ui::MainWindow),
-    _io(new client()),
-    m_typingItem(NULL),
-    m_dialog()
-{
-    ui->setupUi(this);
-    using std::placeholders::_1;
-    using std::placeholders::_2;
-    using std::placeholders::_3;
-    using std::placeholders::_4;
-    socket::ptr sock = _io->socket();
-    BIND_EVENT(sock,"new message",std::bind(&MainWindow::OnNewMessage,this,_1,_2,_3,_4));
-    BIND_EVENT(sock,"user joined",std::bind(&MainWindow::OnUserJoined,this,_1,_2,_3,_4));
-    BIND_EVENT(sock,"user left",std::bind(&MainWindow::OnUserLeft,this,_1,_2,_3,_4));
-    BIND_EVENT(sock,"typing",std::bind(&MainWindow::OnTyping,this,_1,_2,_3,_4));
-    BIND_EVENT(sock,"stop typing",std::bind(&MainWindow::OnStopTyping,this,_1,_2,_3,_4));
-    BIND_EVENT(sock,"login",std::bind(&MainWindow::OnLogin,this,_1,_2,_3,_4));
-    _io->set_socket_open_listener(std::bind(&MainWindow::OnConnected,this,std::placeholders::_1));
-    _io->set_close_listener(std::bind(&MainWindow::OnClosed,this,_1));
-    _io->set_fail_listener(std::bind(&MainWindow::OnFailed,this));
-
-    connect(this,SIGNAL(RequestAddListItem(QListWidgetItem*)),this,SLOT(AddListItem(QListWidgetItem*)));
-    connect(this,SIGNAL(RequestRemoveListItem(QListWidgetItem*)),this,SLOT(RemoveListItem(QListWidgetItem*)));
-    connect(this,SIGNAL(RequestToggleInputs(bool)),this,SLOT(ToggleInputs(bool)));
-}
-
-MainWindow::~MainWindow()
-{
-    _io->socket()->off_all();
-    _io->socket()->off_error();
-    delete ui;
-}
-
-void MainWindow::SendBtnClicked()
-{
-    QLineEdit* messageEdit = this->findChild<QLineEdit*>("messageEdit");
-    QString text = messageEdit->text();
-    if(text.length()>0)
-    {
-        QByteArray bytes = text.toUtf8();
-        std::string msg(bytes.data(),bytes.length());
-        _io->socket()->emit("new message",msg);
-        text.append(" : You");
-        QListWidgetItem *item = new QListWidgetItem(text);
-        item->setTextAlignment(Qt::AlignRight);
-        Q_EMIT RequestAddListItem(item);
-        messageEdit->clear();
-    }
-}
-
-void MainWindow::OnMessageReturn()
-{
-    this->SendBtnClicked();
-}
-
-void MainWindow::ShowLoginDialog()
-{
-    m_dialog.reset(new NicknameDialog(this));
-    connect(m_dialog.get(),SIGNAL(accepted()),this,SLOT(NicknameAccept()));
-    connect(m_dialog.get(),SIGNAL(rejected()),this,SLOT(NicknameCancelled()));
-    m_dialog->exec();
-}
-
-void MainWindow::showEvent(QShowEvent *event)
-{
-    ShowLoginDialog();
-}
-
-
-void MainWindow::TypingStop()
-{
-    m_timer.reset();
-    _io->socket()->emit("stop typing");
-}
-
-void MainWindow::TypingChanged()
-{
-    if(m_timer&&m_timer->isActive())
-    {
-        m_timer->stop();
-    }
-    else
-    {
-        _io->socket()->emit("typing");
-    }
-    m_timer.reset(new QTimer(this));
-    connect(m_timer.get(),SIGNAL(timeout()),this,SLOT(TypingStop()));
-    m_timer->setSingleShot(true);
-    m_timer->start(1000);
-}
-
-void MainWindow::NicknameAccept()
-{
-    m_name = m_dialog->getNickname();
-    if(m_name.length()>0)
-    {
-        _io->connect(kURL);
-    }
-}
-
-void MainWindow::NicknameCancelled()
-{
-    QApplication::exit();
-}
-
-void MainWindow::AddListItem(QListWidgetItem* item)
-{
-    this->findChild<QListWidget*>("listView")->addItem(item);
-}
-
-void MainWindow::RemoveListItem(QListWidgetItem* item)
-{
-    QListWidget* list = this->findChild<QListWidget*>("listView");
-    int row = list->row(item);
-    delete list->takeItem(row);
-}
-
-
-void MainWindow::OnNewMessage(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-
-    if(data->get_flag() == message::flag_object)
-    {
-        std::string msg = data->get_map()["message"]->get_string();
-        std::string username = data->get_map()["username"]->get_string();
-        QString label = QString::fromUtf8(username.data(),username.length());
-        label.append(" : ");
-        label.append(QString::fromUtf8(msg.data(),msg.length()));
-        QListWidgetItem *item= new QListWidgetItem(label);
-        Q_EMIT RequestAddListItem(item);
-    }
-}
-
-void MainWindow::OnUserJoined(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        std::string name = data->get_map()["username"]->get_string();
-        int numUser = data->get_map()["numUsers"]->get_int();
-        QString label = QString::fromUtf8(name.data(),name.length());
-        bool plural = numUser != 1;
-        label.append(" joined\n");
-        label.append(plural?"there are ":"there's ");
-        QString digits;
-        while(numUser>=10)
-        {
-            digits.insert(0,QChar((numUser%10)+'0'));
-            numUser/=10;
-        }
-        digits.insert(0,QChar(numUser+'0'));
-        label.append(digits);
-        label.append(plural?" participants":" participant");
-        QListWidgetItem *item= new QListWidgetItem(label);
-        item->setTextAlignment(Qt::AlignHCenter);
-        QFont font;
-        font.setPointSize(9);
-        item->setFont(font);
-        Q_EMIT RequestAddListItem(item);
-    }
-
-}
-
-void MainWindow::OnUserLeft(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        std::string name = data->get_map()["username"]->get_string();
-        int numUser = data->get_map()["numUsers"]->get_int();
-        QString label = QString::fromUtf8(name.data(),name.length());
-        bool plural = numUser != 1;
-        label.append(" left\n");
-        label.append(plural?"there are ":"there's ");
-        QString digits;
-        while(numUser>=10)
-        {
-            digits.insert(0,QChar((numUser%10)+'0'));
-            numUser/=10;
-        }
-        digits.insert(0,QChar(numUser+'0'));
-        label.append(digits);
-        label.append(plural?" participants":" participant");
-        QListWidgetItem *item= new QListWidgetItem(label);
-        item->setTextAlignment(Qt::AlignHCenter);
-        QFont font;
-        font.setPointSize(9);
-        item->setFont(font);
-        Q_EMIT RequestAddListItem(item);
-    }
-}
-
-void MainWindow::OnTyping(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-    if(m_typingItem == NULL)
-    {
-        std::string name = data->get_map()["username"]->get_string();
-        QString label = QString::fromUtf8(name.data(),name.length());
-        label.append("  is typing...");
-        QListWidgetItem *item = new QListWidgetItem(label);
-        item->setTextColor(QColor(200,200,200,255));
-        m_typingItem = item;
-        Q_EMIT RequestAddListItem(item);
-    }
-}
-
-void MainWindow::OnStopTyping(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-    if(m_typingItem != NULL)
-    {
-        Q_EMIT RequestRemoveListItem(m_typingItem);
-        m_typingItem = NULL;
-    }
-}
-
-void MainWindow::OnLogin(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp)
-{
-    Q_EMIT RequestToggleInputs(true);
-    int numUser = data->get_map()["numUsers"]->get_int();
-
-    QString digits;
-    bool plural = numUser !=1;
-    while(numUser>=10)
-    {
-        digits.insert(0,QChar((numUser%10)+'0'));
-        numUser/=10;
-    }
-
-    digits.insert(0,QChar(numUser+'0'));
-    digits.insert(0,plural?"there are ":"there's ");
-    digits.append(plural? " participants":" participant");
-    QListWidgetItem *item = new QListWidgetItem(digits);
-    item->setTextAlignment(Qt::AlignHCenter);
-    QFont font;
-    font.setPointSize(9);
-    item->setFont(font);
-    Q_EMIT RequestAddListItem(item);
-}
-
-void MainWindow::OnConnected(std::string const& nsp)
-{
-    QByteArray bytes = m_name.toUtf8();
-    std::string nickName(bytes.data(),bytes.length());
-    _io->socket()->emit("add user", nickName);
-}
-
-void MainWindow::OnClosed(client::close_reason const& reason)
-{
-    Q_EMIT RequestToggleInputs(false);
-}
-
-void MainWindow::OnFailed()
-{
-    Q_EMIT RequestToggleInputs(false);
-}
-
-void MainWindow::ToggleInputs(bool loginOrNot)
-{
-    if(loginOrNot)//already login
-    {
-        this->findChild<QWidget*>("messageEdit")->setEnabled(true);
-        this->findChild<QWidget*>("listView")->setEnabled(true);
-//        this->findChild<QWidget*>("sendBtn")->setEnabled(true);
-    }
-    else
-    {
-        this->findChild<QWidget*>("messageEdit")->setEnabled(false);
-        this->findChild<QWidget*>("listView")->setEnabled(false);
-//        this->findChild<QWidget*>("sendBtn")->setEnabled(false);
-        ShowLoginDialog();
-    }
-}
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.h b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.h
deleted file mode 100644
index df32afe..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef MAINWINDOW_H
-#define MAINWINDOW_H
-
-#include <QMainWindow>
-#include <QListWidget>
-#include <QPushButton>
-#include <QPlainTextEdit>
-#include <QTimer>
-#include <sio_client.h>
-#include "nicknamedialog.h"
-namespace Ui {
-class MainWindow;
-}
-
-using namespace sio;
-
-class MainWindow : public QMainWindow
-{
-    Q_OBJECT
-
-public:
-    explicit MainWindow(QWidget *parent = 0);
-    ~MainWindow();
-
-public Q_SLOTS:
-    void SendBtnClicked();
-    void TypingChanged();
-    void OnMessageReturn();
-protected:
-    void showEvent(QShowEvent* event);
-
-Q_SIGNALS:
-    void RequestAddListItem(QListWidgetItem *item);
-    void RequestRemoveListItem(QListWidgetItem *item);
-    void RequestToggleInputs(bool loginOrNot);
-private Q_SLOTS:
-    void AddListItem(QListWidgetItem *item);
-    void RemoveListItem(QListWidgetItem *item);
-    void ToggleInputs(bool loginOrNot);
-    void TypingStop();
-    void NicknameAccept();
-    void NicknameCancelled();
-private:
-    void OnNewMessage(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnUserJoined(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnUserLeft(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnTyping(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnStopTyping(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnLogin(std::string const& name,message::ptr const& data,bool hasAck,message::list &ack_resp);
-    void OnConnected(std::string const& nsp);
-    void OnClosed(client::close_reason const& reason);
-    void OnFailed();
-    void ShowLoginDialog();
-
-    Ui::MainWindow *ui;
-
-    std::unique_ptr<client> _io;
-
-    std::unique_ptr<NicknameDialog> m_dialog;
-
-    QString m_name;
-
-    std::unique_ptr<QTimer> m_timer;
-
-    QListWidgetItem *m_typingItem;
-};
-
-#endif // MAINWINDOW_H
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.ui b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.ui
deleted file mode 100644
index 205cf77..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/mainwindow.ui
+++ /dev/null
@@ -1,131 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>MainWindow</class>
- <widget class="QMainWindow" name="MainWindow">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>366</width>
-    <height>549</height>
-   </rect>
-  </property>
-  <property name="sizePolicy">
-   <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-    <horstretch>0</horstretch>
-    <verstretch>0</verstretch>
-   </sizepolicy>
-  </property>
-  <property name="windowTitle">
-   <string>Socket.IO Chat</string>
-  </property>
-  <property name="unifiedTitleAndToolBarOnMac">
-   <bool>false</bool>
-  </property>
-  <widget class="QWidget" name="centralWidget">
-   <widget class="QListWidget" name="listView">
-    <property name="enabled">
-     <bool>false</bool>
-    </property>
-    <property name="geometry">
-     <rect>
-      <x>8</x>
-      <y>11</y>
-      <width>350</width>
-      <height>461</height>
-     </rect>
-    </property>
-    <property name="sizePolicy">
-     <sizepolicy hsizetype="Fixed" vsizetype="Expanding">
-      <horstretch>0</horstretch>
-      <verstretch>0</verstretch>
-     </sizepolicy>
-    </property>
-    <property name="sizeIncrement">
-     <size>
-      <width>0</width>
-      <height>0</height>
-     </size>
-    </property>
-   </widget>
-   <widget class="QLineEdit" name="messageEdit">
-    <property name="enabled">
-     <bool>false</bool>
-    </property>
-    <property name="geometry">
-     <rect>
-      <x>8</x>
-      <y>480</y>
-      <width>350</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="placeholderText">
-     <string>Type here...</string>
-    </property>
-   </widget>
-  </widget>
-  <widget class="QMenuBar" name="menuBar">
-   <property name="geometry">
-    <rect>
-     <x>0</x>
-     <y>0</y>
-     <width>366</width>
-     <height>22</height>
-    </rect>
-   </property>
-  </widget>
-  <widget class="QToolBar" name="mainToolBar">
-   <attribute name="toolBarArea">
-    <enum>TopToolBarArea</enum>
-   </attribute>
-   <attribute name="toolBarBreak">
-    <bool>false</bool>
-   </attribute>
-  </widget>
-  <widget class="QStatusBar" name="statusBar"/>
- </widget>
- <layoutdefault spacing="6" margin="11"/>
- <resources/>
- <connections>
-  <connection>
-   <sender>messageEdit</sender>
-   <signal>returnPressed()</signal>
-   <receiver>MainWindow</receiver>
-   <slot>OnMessageReturn()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>116</x>
-     <y>524</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>30</x>
-     <y>545</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>messageEdit</sender>
-   <signal>textChanged(QString)</signal>
-   <receiver>MainWindow</receiver>
-   <slot>TypingChanged()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>73</x>
-     <y>531</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>70</x>
-     <y>510</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
- <slots>
-  <slot>SendBtnClicked(bool)</slot>
-  <slot>TypingChanged()</slot>
-  <slot>LoginClicked()</slot>
-  <slot>OnMessageReturn()</slot>
-  <slot>SendBtnClicked()</slot>
- </slots>
-</ui>
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.cpp b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.cpp
deleted file mode 100644
index 7b9a274..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "nicknamedialog.h"
-#include "ui_nicknamedialog.h"
-#include <QTimer>
-NicknameDialog::NicknameDialog(QWidget *parent) :
-    QDialog(parent),
-    ui(new Ui::NicknameDialog)
-{
-    ui->setupUi(this);
-}
-
-NicknameDialog::~NicknameDialog()
-{
-    delete ui;
-}
-
-const QString& NicknameDialog::getNickname() const
-{
-    return m_nickName;
-}
-
-void NicknameDialog::exitApp()
-{
-    QApplication::quit();
-}
-
-void NicknameDialog::closeEvent(QCloseEvent *event)
-{
-    QTimer::singleShot(0,this,SLOT(exitApp()));
-}
-
-void NicknameDialog::accept()
-{
-    if(this->findChild<QLineEdit*>("nicknameEdit")->text().length()>0)
-    {
-        m_nickName = this->findChild<QLineEdit*>("nicknameEdit")->text();
-        done(QDialog::Accepted);
-    }
-}
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.h b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.h
deleted file mode 100644
index 6eda6a6..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef NICKNAMEDIALOG_H
-#define NICKNAMEDIALOG_H
-
-#include <QDialog>
-
-namespace Ui {
-class NicknameDialog;
-}
-
-class NicknameDialog : public QDialog
-{
-    Q_OBJECT
-
-public Q_SLOTS:
-    void accept();
-    void exitApp();
-public:
-    explicit NicknameDialog(QWidget *parent = 0);
-    ~NicknameDialog();
-
-    const QString& getNickname() const;
-    void closeEvent(QCloseEvent *);
-private:
-    Ui::NicknameDialog *ui;
-    QString m_nickName;
-};
-
-#endif // NICKNAMEDIALOG_H
diff --git a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.ui b/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.ui
deleted file mode 100644
index 1ed85b4..0000000
--- a/third_party/socket.io-client-cpp/examples/QT/SioChatDemo/nicknamedialog.ui
+++ /dev/null
@@ -1,106 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>NicknameDialog</class>
- <widget class="QDialog" name="NicknameDialog">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>366</width>
-    <height>151</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Login</string>
-  </property>
-  <widget class="QDialogButtonBox" name="buttonBox">
-   <property name="geometry">
-    <rect>
-     <x>30</x>
-     <y>99</y>
-     <width>311</width>
-     <height>32</height>
-    </rect>
-   </property>
-   <property name="orientation">
-    <enum>Qt::Horizontal</enum>
-   </property>
-   <property name="standardButtons">
-    <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
-   </property>
-  </widget>
-  <widget class="QLineEdit" name="nicknameEdit">
-   <property name="geometry">
-    <rect>
-     <x>27</x>
-     <y>60</y>
-     <width>311</width>
-     <height>20</height>
-    </rect>
-   </property>
-   <property name="placeholderText">
-    <string>Type nickname here...</string>
-   </property>
-  </widget>
-  <widget class="QLabel" name="label">
-   <property name="geometry">
-    <rect>
-     <x>44</x>
-     <y>23</y>
-     <width>271</width>
-     <height>21</height>
-    </rect>
-   </property>
-   <property name="font">
-    <font>
-     <pointsize>15</pointsize>
-    </font>
-   </property>
-   <property name="text">
-    <string>What's your nickname?</string>
-   </property>
-   <property name="alignment">
-    <set>Qt::AlignCenter</set>
-   </property>
-  </widget>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>accepted()</signal>
-   <receiver>NicknameDialog</receiver>
-   <slot>accept()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>298</x>
-     <y>97</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>298</x>
-     <y>108</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>buttonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>NicknameDialog</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>210</x>
-     <y>125</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>202</x>
-     <y>84</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
- <slots>
-  <slot>checkAccept()</slot>
-  <slot>checkAcc()</slot>
- </slots>
-</ui>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/README.md b/third_party/socket.io-client-cpp/examples/iOS/README.md
deleted file mode 100644
index 21efc10..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-#SIOClient iOS chat room demo
-## What is this
-This is a iOS project run on xcode 6, you can use this single view application chatting in the official [chat room demo](https://github.com/Automattic/socket.io/tree/master/examples/chat).
-
-## How to setup
-Suppose you're using your Mac's shell, under your workspace folder, run
-```shell
-git clone --recurse-submodules https://github.com/socketio/socket.io-client-cpp.git
-```
-Step in the demo folder
-```shell
-cd ./socket.io-client-cpp/examples/iOS/SioChatDemo
-```
-you will see a shell script named `boost.sh` under folder `boost`,Run
-```shell
-cd ./boost
-bash ./boost.sh
-```
-Please stand by with patient, this step will take about one or two hours depends on your network.
-When done, open `SioChatDemo.xcodeproj` file in the parent folder with xcode.
-Just compile and run the `SioChatDemo` target.
-Now, if you have your chat room server run on your local machine, you can chat with device to device or device to web.
-
-## Use sioclient as static lib on iOS
-There's a target named `sioclient` in the Demo project, That is the exactly right config for buiding the `sioclient` as a static library on iOS. 
-With the static library file `libsioclient.a` and two exported headers `sio_client.h` and `sio_message.h`, you won't need to config anything again and again in your integrating projects.
-
-## About the `boost.sh`
-The `boost.sh` is copied from [boostmake_ios](https://github.com/alist/boostmake_ios),it is worked on my machine for boost 1.55.0
-there're lot's versions of boost build shells, you can choose what you like.
-
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/.gitignore b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/.gitignore
deleted file mode 100644
index 9af9076..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/**/xcuserdata/
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.pbxproj b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.pbxproj
deleted file mode 100644
index f4c9ee4..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,722 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		CE1D31A01AD5087800895150 /* sio_packet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE1D319E1AD5087800895150 /* sio_packet.cpp */; };
-		CE1D31A11AD5087800895150 /* sio_packet.h in Headers */ = {isa = PBXBuildFile; fileRef = CE1D319F1AD5087800895150 /* sio_packet.h */; };
-		CE2958691ACE4589000ABD30 /* sio_client_impl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE2958671ACE442F000ABD30 /* sio_client_impl.cpp */; };
-		CE29586A1ACE4592000ABD30 /* sio_socket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE2958621ACE2CD6000ABD30 /* sio_socket.cpp */; };
-		CE3B3B401AC8F365003CEB94 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = CE3B3B3F1AC8F365003CEB94 /* main.m */; };
-		CE3B3B431AC8F365003CEB94 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = CE3B3B421AC8F365003CEB94 /* AppDelegate.m */; };
-		CE3B3B4B1AC8F365003CEB94 /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = CE3B3B4A1AC8F365003CEB94 /* Images.xcassets */; };
-		CE3B3B4E1AC8F365003CEB94 /* LaunchScreen.xib in Resources */ = {isa = PBXBuildFile; fileRef = CE3B3B4C1AC8F365003CEB94 /* LaunchScreen.xib */; };
-		CE3B3B5A1AC8F365003CEB94 /* SioChatDemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = CE3B3B591AC8F365003CEB94 /* SioChatDemoTests.m */; };
-		CE3B3B651AC8F385003CEB94 /* CRViewController.mm in Sources */ = {isa = PBXBuildFile; fileRef = CE3B3B641AC8F385003CEB94 /* CRViewController.mm */; };
-		CE3B3B751AC8F438003CEB94 /* libsioclient.a in Frameworks */ = {isa = PBXBuildFile; fileRef = CE3B3B6A1AC8F438003CEB94 /* libsioclient.a */; };
-		CE3B3E6D1AC8FE59003CEB94 /* libsioclient.a in Frameworks */ = {isa = PBXBuildFile; fileRef = CE3B3B6A1AC8F438003CEB94 /* libsioclient.a */; };
-		CE3B3E6F1AC9139B003CEB94 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = CE3B3E6E1AC9139B003CEB94 /* Main.storyboard */; };
-		CE3B3E8C1ACA5446003CEB94 /* sio_client.cpp in Sources */ = {isa = PBXBuildFile; fileRef = CE3B3E871ACA5446003CEB94 /* sio_client.cpp */; };
-		CE3B3E8D1ACA5446003CEB94 /* sio_client.h in Headers */ = {isa = PBXBuildFile; fileRef = CE3B3E881ACA5446003CEB94 /* sio_client.h */; };
-		CE3B3E8E1ACA5446003CEB94 /* sio_message.h in Headers */ = {isa = PBXBuildFile; fileRef = CE3B3E891ACA5446003CEB94 /* sio_message.h */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXContainerItemProxy section */
-		CE3B3B541AC8F365003CEB94 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = CE3B3B321AC8F365003CEB94 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = CE3B3B391AC8F365003CEB94;
-			remoteInfo = SioChatDemo;
-		};
-		CE3B3B761AC8F438003CEB94 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = CE3B3B321AC8F365003CEB94 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = CE3B3B691AC8F438003CEB94;
-			remoteInfo = sioclient;
-		};
-		CE3B3E6B1AC8FE54003CEB94 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = CE3B3B321AC8F365003CEB94 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = CE3B3B691AC8F438003CEB94;
-			remoteInfo = sioclient;
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXCopyFilesBuildPhase section */
-		CE3B3B681AC8F438003CEB94 /* CopyFiles */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 2147483647;
-			dstPath = "include/$(PRODUCT_NAME)";
-			dstSubfolderSpec = 16;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXCopyFilesBuildPhase section */
-
-/* Begin PBXFileReference section */
-		CE1D319E1AD5087800895150 /* sio_packet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sio_packet.cpp; sourceTree = "<group>"; };
-		CE1D319F1AD5087800895150 /* sio_packet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sio_packet.h; sourceTree = "<group>"; };
-		CE2958621ACE2CD6000ABD30 /* sio_socket.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sio_socket.cpp; sourceTree = "<group>"; };
-		CE2958631ACE2CD6000ABD30 /* sio_socket.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sio_socket.h; sourceTree = "<group>"; };
-		CE2958661ACE2CDD000ABD30 /* sio_client_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sio_client_impl.h; sourceTree = "<group>"; };
-		CE2958671ACE442F000ABD30 /* sio_client_impl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sio_client_impl.cpp; sourceTree = "<group>"; };
-		CE3B3B3A1AC8F365003CEB94 /* SioChatDemo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = SioChatDemo.app; sourceTree = BUILT_PRODUCTS_DIR; };
-		CE3B3B3E1AC8F365003CEB94 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		CE3B3B3F1AC8F365003CEB94 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
-		CE3B3B411AC8F365003CEB94 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = "<group>"; };
-		CE3B3B421AC8F365003CEB94 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = "<group>"; };
-		CE3B3B4A1AC8F365003CEB94 /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Images.xcassets; sourceTree = "<group>"; };
-		CE3B3B4D1AC8F365003CEB94 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/LaunchScreen.xib; sourceTree = "<group>"; };
-		CE3B3B531AC8F365003CEB94 /* SioChatDemoTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SioChatDemoTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		CE3B3B581AC8F365003CEB94 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		CE3B3B591AC8F365003CEB94 /* SioChatDemoTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SioChatDemoTests.m; sourceTree = "<group>"; };
-		CE3B3B631AC8F385003CEB94 /* CRViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CRViewController.h; sourceTree = "<group>"; };
-		CE3B3B641AC8F385003CEB94 /* CRViewController.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CRViewController.mm; sourceTree = "<group>"; };
-		CE3B3B6A1AC8F438003CEB94 /* libsioclient.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libsioclient.a; sourceTree = BUILT_PRODUCTS_DIR; };
-		CE3B3B741AC8F438003CEB94 /* sioclientTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = sioclientTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
-		CE3B3B7A1AC8F438003CEB94 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		CE3B3E6E1AC9139B003CEB94 /* Main.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; path = Main.storyboard; sourceTree = "<group>"; };
-		CE3B3E871ACA5446003CEB94 /* sio_client.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sio_client.cpp; sourceTree = "<group>"; };
-		CE3B3E881ACA5446003CEB94 /* sio_client.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sio_client.h; sourceTree = "<group>"; };
-		CE3B3E891ACA5446003CEB94 /* sio_message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sio_message.h; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		CE3B3B371AC8F365003CEB94 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3E6D1AC8FE59003CEB94 /* libsioclient.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B501AC8F365003CEB94 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B671AC8F438003CEB94 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B711AC8F438003CEB94 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3B751AC8F438003CEB94 /* libsioclient.a in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		CE2958651ACE2CDD000ABD30 /* internal */ = {
-			isa = PBXGroup;
-			children = (
-				CE1D319E1AD5087800895150 /* sio_packet.cpp */,
-				CE1D319F1AD5087800895150 /* sio_packet.h */,
-				CE2958661ACE2CDD000ABD30 /* sio_client_impl.h */,
-				CE2958671ACE442F000ABD30 /* sio_client_impl.cpp */,
-			);
-			path = internal;
-			sourceTree = "<group>";
-		};
-		CE3B3B311AC8F365003CEB94 = {
-			isa = PBXGroup;
-			children = (
-				CE3B3E861ACA5446003CEB94 /* src */,
-				CE3B3B3C1AC8F365003CEB94 /* SioChatDemo */,
-				CE3B3B561AC8F365003CEB94 /* SioChatDemoTests */,
-				CE3B3B6B1AC8F438003CEB94 /* sioclient */,
-				CE3B3B781AC8F438003CEB94 /* sioclientTests */,
-				CE3B3B3B1AC8F365003CEB94 /* Products */,
-			);
-			sourceTree = "<group>";
-		};
-		CE3B3B3B1AC8F365003CEB94 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B3A1AC8F365003CEB94 /* SioChatDemo.app */,
-				CE3B3B531AC8F365003CEB94 /* SioChatDemoTests.xctest */,
-				CE3B3B6A1AC8F438003CEB94 /* libsioclient.a */,
-				CE3B3B741AC8F438003CEB94 /* sioclientTests.xctest */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		CE3B3B3C1AC8F365003CEB94 /* SioChatDemo */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3E6E1AC9139B003CEB94 /* Main.storyboard */,
-				CE3B3B411AC8F365003CEB94 /* AppDelegate.h */,
-				CE3B3B421AC8F365003CEB94 /* AppDelegate.m */,
-				CE3B3B631AC8F385003CEB94 /* CRViewController.h */,
-				CE3B3B641AC8F385003CEB94 /* CRViewController.mm */,
-				CE3B3B4A1AC8F365003CEB94 /* Images.xcassets */,
-				CE3B3B4C1AC8F365003CEB94 /* LaunchScreen.xib */,
-				CE3B3B3D1AC8F365003CEB94 /* Supporting Files */,
-			);
-			path = SioChatDemo;
-			sourceTree = "<group>";
-		};
-		CE3B3B3D1AC8F365003CEB94 /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B3E1AC8F365003CEB94 /* Info.plist */,
-				CE3B3B3F1AC8F365003CEB94 /* main.m */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		CE3B3B561AC8F365003CEB94 /* SioChatDemoTests */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B591AC8F365003CEB94 /* SioChatDemoTests.m */,
-				CE3B3B571AC8F365003CEB94 /* Supporting Files */,
-			);
-			path = SioChatDemoTests;
-			sourceTree = "<group>";
-		};
-		CE3B3B571AC8F365003CEB94 /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B581AC8F365003CEB94 /* Info.plist */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		CE3B3B6B1AC8F438003CEB94 /* sioclient */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			path = sioclient;
-			sourceTree = "<group>";
-		};
-		CE3B3B781AC8F438003CEB94 /* sioclientTests */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B791AC8F438003CEB94 /* Supporting Files */,
-			);
-			path = sioclientTests;
-			sourceTree = "<group>";
-		};
-		CE3B3B791AC8F438003CEB94 /* Supporting Files */ = {
-			isa = PBXGroup;
-			children = (
-				CE3B3B7A1AC8F438003CEB94 /* Info.plist */,
-			);
-			name = "Supporting Files";
-			sourceTree = "<group>";
-		};
-		CE3B3E861ACA5446003CEB94 /* src */ = {
-			isa = PBXGroup;
-			children = (
-				CE2958651ACE2CDD000ABD30 /* internal */,
-				CE2958621ACE2CD6000ABD30 /* sio_socket.cpp */,
-				CE2958631ACE2CD6000ABD30 /* sio_socket.h */,
-				CE3B3E871ACA5446003CEB94 /* sio_client.cpp */,
-				CE3B3E881ACA5446003CEB94 /* sio_client.h */,
-				CE3B3E891ACA5446003CEB94 /* sio_message.h */,
-			);
-			name = src;
-			path = ../../../src;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		CE3B3E681AC8F511003CEB94 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3E8E1ACA5446003CEB94 /* sio_message.h in Headers */,
-				CE1D31A11AD5087800895150 /* sio_packet.h in Headers */,
-				CE3B3E8D1ACA5446003CEB94 /* sio_client.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		CE3B3B391AC8F365003CEB94 /* SioChatDemo */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = CE3B3B5D1AC8F365003CEB94 /* Build configuration list for PBXNativeTarget "SioChatDemo" */;
-			buildPhases = (
-				CE3B3B361AC8F365003CEB94 /* Sources */,
-				CE3B3B371AC8F365003CEB94 /* Frameworks */,
-				CE3B3B381AC8F365003CEB94 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				CE3B3E6C1AC8FE54003CEB94 /* PBXTargetDependency */,
-			);
-			name = SioChatDemo;
-			productName = SioChatDemo;
-			productReference = CE3B3B3A1AC8F365003CEB94 /* SioChatDemo.app */;
-			productType = "com.apple.product-type.application";
-		};
-		CE3B3B521AC8F365003CEB94 /* SioChatDemoTests */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = CE3B3B601AC8F365003CEB94 /* Build configuration list for PBXNativeTarget "SioChatDemoTests" */;
-			buildPhases = (
-				CE3B3B4F1AC8F365003CEB94 /* Sources */,
-				CE3B3B501AC8F365003CEB94 /* Frameworks */,
-				CE3B3B511AC8F365003CEB94 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				CE3B3B551AC8F365003CEB94 /* PBXTargetDependency */,
-			);
-			name = SioChatDemoTests;
-			productName = SioChatDemoTests;
-			productReference = CE3B3B531AC8F365003CEB94 /* SioChatDemoTests.xctest */;
-			productType = "com.apple.product-type.bundle.unit-test";
-		};
-		CE3B3B691AC8F438003CEB94 /* sioclient */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = CE3B3B7B1AC8F438003CEB94 /* Build configuration list for PBXNativeTarget "sioclient" */;
-			buildPhases = (
-				CE3B3B661AC8F438003CEB94 /* Sources */,
-				CE3B3B671AC8F438003CEB94 /* Frameworks */,
-				CE3B3B681AC8F438003CEB94 /* CopyFiles */,
-				CE3B3E681AC8F511003CEB94 /* Headers */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = sioclient;
-			productName = sioclient;
-			productReference = CE3B3B6A1AC8F438003CEB94 /* libsioclient.a */;
-			productType = "com.apple.product-type.library.static";
-		};
-		CE3B3B731AC8F438003CEB94 /* sioclientTests */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = CE3B3B7E1AC8F438003CEB94 /* Build configuration list for PBXNativeTarget "sioclientTests" */;
-			buildPhases = (
-				CE3B3B701AC8F438003CEB94 /* Sources */,
-				CE3B3B711AC8F438003CEB94 /* Frameworks */,
-				CE3B3B721AC8F438003CEB94 /* Resources */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				CE3B3B771AC8F438003CEB94 /* PBXTargetDependency */,
-			);
-			name = sioclientTests;
-			productName = sioclientTests;
-			productReference = CE3B3B741AC8F438003CEB94 /* sioclientTests.xctest */;
-			productType = "com.apple.product-type.bundle.unit-test";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		CE3B3B321AC8F365003CEB94 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 0610;
-				ORGANIZATIONNAME = "Melo Yao";
-				TargetAttributes = {
-					CE3B3B391AC8F365003CEB94 = {
-						CreatedOnToolsVersion = 6.1.1;
-					};
-					CE3B3B521AC8F365003CEB94 = {
-						CreatedOnToolsVersion = 6.1.1;
-						TestTargetID = CE3B3B391AC8F365003CEB94;
-					};
-					CE3B3B691AC8F438003CEB94 = {
-						CreatedOnToolsVersion = 6.1.1;
-					};
-					CE3B3B731AC8F438003CEB94 = {
-						CreatedOnToolsVersion = 6.1.1;
-					};
-				};
-			};
-			buildConfigurationList = CE3B3B351AC8F365003CEB94 /* Build configuration list for PBXProject "SioChatDemo" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 0;
-			knownRegions = (
-				en,
-				Base,
-			);
-			mainGroup = CE3B3B311AC8F365003CEB94;
-			productRefGroup = CE3B3B3B1AC8F365003CEB94 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				CE3B3B391AC8F365003CEB94 /* SioChatDemo */,
-				CE3B3B521AC8F365003CEB94 /* SioChatDemoTests */,
-				CE3B3B691AC8F438003CEB94 /* sioclient */,
-				CE3B3B731AC8F438003CEB94 /* sioclientTests */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		CE3B3B381AC8F365003CEB94 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3E6F1AC9139B003CEB94 /* Main.storyboard in Resources */,
-				CE3B3B4E1AC8F365003CEB94 /* LaunchScreen.xib in Resources */,
-				CE3B3B4B1AC8F365003CEB94 /* Images.xcassets in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B511AC8F365003CEB94 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B721AC8F438003CEB94 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		CE3B3B361AC8F365003CEB94 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3B431AC8F365003CEB94 /* AppDelegate.m in Sources */,
-				CE3B3B401AC8F365003CEB94 /* main.m in Sources */,
-				CE3B3B651AC8F385003CEB94 /* CRViewController.mm in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B4F1AC8F365003CEB94 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE3B3B5A1AC8F365003CEB94 /* SioChatDemoTests.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B661AC8F438003CEB94 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				CE29586A1ACE4592000ABD30 /* sio_socket.cpp in Sources */,
-				CE1D31A01AD5087800895150 /* sio_packet.cpp in Sources */,
-				CE2958691ACE4589000ABD30 /* sio_client_impl.cpp in Sources */,
-				CE3B3E8C1ACA5446003CEB94 /* sio_client.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		CE3B3B701AC8F438003CEB94 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		CE3B3B551AC8F365003CEB94 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = CE3B3B391AC8F365003CEB94 /* SioChatDemo */;
-			targetProxy = CE3B3B541AC8F365003CEB94 /* PBXContainerItemProxy */;
-		};
-		CE3B3B771AC8F438003CEB94 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = CE3B3B691AC8F438003CEB94 /* sioclient */;
-			targetProxy = CE3B3B761AC8F438003CEB94 /* PBXContainerItemProxy */;
-		};
-		CE3B3E6C1AC8FE54003CEB94 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = CE3B3B691AC8F438003CEB94 /* sioclient */;
-			targetProxy = CE3B3E6B1AC8FE54003CEB94 /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin PBXVariantGroup section */
-		CE3B3B4C1AC8F365003CEB94 /* LaunchScreen.xib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				CE3B3B4D1AC8F365003CEB94 /* Base */,
-			);
-			name = LaunchScreen.xib;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		CE3B3B5B1AC8F365003CEB94 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.1;
-				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
-			};
-			name = Debug;
-		};
-		CE3B3B5C1AC8F365003CEB94 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libc++";
-				CLANG_ENABLE_MODULES = YES;
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN_UNREACHABLE_CODE = YES;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
-				COPY_PHASE_STRIP = YES;
-				ENABLE_NS_ASSERTIONS = NO;
-				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 8.1;
-				MTL_ENABLE_DEBUG_INFO = NO;
-				SDKROOT = iphoneos;
-				TARGETED_DEVICE_FAMILY = "1,2";
-				VALIDATE_PRODUCT = YES;
-			};
-			name = Release;
-		};
-		CE3B3B5E1AC8F365003CEB94 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				INFOPLIST_FILE = SioChatDemo/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Debug;
-		};
-		CE3B3B5F1AC8F365003CEB94 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				INFOPLIST_FILE = SioChatDemo/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Release;
-		};
-		CE3B3B611AC8F365003CEB94 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				BUNDLE_LOADER = "$(TEST_HOST)";
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = SioChatDemoTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/SioChatDemo.app/SioChatDemo";
-			};
-			name = Debug;
-		};
-		CE3B3B621AC8F365003CEB94 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				BUNDLE_LOADER = "$(TEST_HOST)";
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = SioChatDemoTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/SioChatDemo.app/SioChatDemo";
-			};
-			name = Release;
-		};
-		CE3B3B7C1AC8F438003CEB94 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SIOROOT)/lib/websocketpp",
-					"$(SIOROOT)/lib/rapidjson/include",
-					"$(SRCROOT)/boost/ios/prefix/include",
-				);
-				LIBRARY_SEARCH_PATHS = "$(SRCROOT)/boost/ios/build/$(CURRENT_ARCH)/";
-				OTHER_LDFLAGS = "-ObjC";
-				OTHER_LIBTOOLFLAGS = "-lboost_random -lboost_date_time -lboost_system";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SIOROOT = "$(SRCROOT)/../../../";
-				SKIP_INSTALL = YES;
-			};
-			name = Debug;
-		};
-		CE3B3B7D1AC8F438003CEB94 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				HEADER_SEARCH_PATHS = (
-					"$(inherited)",
-					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
-					"$(SIOROOT)/lib/websocketpp",
-					"$(SIOROOT)/lib/rapidjson/include",
-					"$(SRCROOT)/boost/ios/prefix/include",
-				);
-				LIBRARY_SEARCH_PATHS = "$(SRCROOT)/boost/ios/build/$(CURRENT_ARCH)/";
-				OTHER_LDFLAGS = "-ObjC";
-				OTHER_LIBTOOLFLAGS = "-lboost_random -lboost_date_time -lboost_system";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-				SIOROOT = "$(SRCROOT)/../../../";
-				SKIP_INSTALL = YES;
-			};
-			name = Release;
-		};
-		CE3B3B7F1AC8F438003CEB94 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = sioclientTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Debug;
-		};
-		CE3B3B801AC8F438003CEB94 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(SDKROOT)/Developer/Library/Frameworks",
-					"$(inherited)",
-				);
-				INFOPLIST_FILE = sioclientTests/Info.plist;
-				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		CE3B3B351AC8F365003CEB94 /* Build configuration list for PBXProject "SioChatDemo" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				CE3B3B5B1AC8F365003CEB94 /* Debug */,
-				CE3B3B5C1AC8F365003CEB94 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		CE3B3B5D1AC8F365003CEB94 /* Build configuration list for PBXNativeTarget "SioChatDemo" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				CE3B3B5E1AC8F365003CEB94 /* Debug */,
-				CE3B3B5F1AC8F365003CEB94 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		CE3B3B601AC8F365003CEB94 /* Build configuration list for PBXNativeTarget "SioChatDemoTests" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				CE3B3B611AC8F365003CEB94 /* Debug */,
-				CE3B3B621AC8F365003CEB94 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		CE3B3B7B1AC8F438003CEB94 /* Build configuration list for PBXNativeTarget "sioclient" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				CE3B3B7C1AC8F438003CEB94 /* Debug */,
-				CE3B3B7D1AC8F438003CEB94 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		CE3B3B7E1AC8F438003CEB94 /* Build configuration list for PBXNativeTarget "sioclientTests" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				CE3B3B7F1AC8F438003CEB94 /* Debug */,
-				CE3B3B801AC8F438003CEB94 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = CE3B3B321AC8F365003CEB94 /* Project object */;
-}
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
deleted file mode 100644
index bda55db..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/contents.xcworkspacedata
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:SioChatDemo.xcodeproj">
-   </FileRef>
-</Workspace>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/xcshareddata/SioChatDemo.xccheckout b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/xcshareddata/SioChatDemo.xccheckout
deleted file mode 100644
index 08b50da..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo.xcodeproj/project.xcworkspace/xcshareddata/SioChatDemo.xccheckout
+++ /dev/null
@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IDESourceControlProjectFavoriteDictionaryKey</key>
-	<false/>
-	<key>IDESourceControlProjectIdentifier</key>
-	<string>F1CE472E-3AF3-4EDA-9B64-F9DD83C665BC</string>
-	<key>IDESourceControlProjectName</key>
-	<string>SioChatDemo</string>
-	<key>IDESourceControlProjectOriginsDictionary</key>
-	<dict>
-		<key>21C71CD5ED4B8C77974DDBAF056104F039A3B593</key>
-		<string>https://github.com/socketio/socket.io-client-cpp.git</string>
-		<key>7448E718372DB7A4B0D01E27524ED3F8AE51A902</key>
-		<string>https://github.com/miloyip/rapidjson.git</string>
-		<key>995AABD49A028E610D29FFC44D560D9DAC1EAC0B</key>
-		<string>https://github.com/zaphoyd/websocketpp.git</string>
-	</dict>
-	<key>IDESourceControlProjectPath</key>
-	<string>examples/iOS/SioChatDemo/SioChatDemo.xcodeproj</string>
-	<key>IDESourceControlProjectRelativeInstallPathDictionary</key>
-	<dict>
-		<key>21C71CD5ED4B8C77974DDBAF056104F039A3B593</key>
-		<string>../../../../..</string>
-		<key>7448E718372DB7A4B0D01E27524ED3F8AE51A902</key>
-		<string>../../../../..lib/rapidjson</string>
-		<key>995AABD49A028E610D29FFC44D560D9DAC1EAC0B</key>
-		<string>../../../../..lib/websocketpp</string>
-	</dict>
-	<key>IDESourceControlProjectURL</key>
-	<string>https://github.com/socketio/socket.io-client-cpp.git</string>
-	<key>IDESourceControlProjectVersion</key>
-	<integer>111</integer>
-	<key>IDESourceControlProjectWCCIdentifier</key>
-	<string>21C71CD5ED4B8C77974DDBAF056104F039A3B593</string>
-	<key>IDESourceControlProjectWCConfigurations</key>
-	<array>
-		<dict>
-			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
-			<string>public.vcs.git</string>
-			<key>IDESourceControlWCCIdentifierKey</key>
-			<string>7448E718372DB7A4B0D01E27524ED3F8AE51A902</string>
-			<key>IDESourceControlWCCName</key>
-			<string>rapidjson</string>
-		</dict>
-		<dict>
-			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
-			<string>public.vcs.git</string>
-			<key>IDESourceControlWCCIdentifierKey</key>
-			<string>21C71CD5ED4B8C77974DDBAF056104F039A3B593</string>
-			<key>IDESourceControlWCCName</key>
-			<string>sioclient</string>
-		</dict>
-		<dict>
-			<key>IDESourceControlRepositoryExtensionIdentifierKey</key>
-			<string>public.vcs.git</string>
-			<key>IDESourceControlWCCIdentifierKey</key>
-			<string>995AABD49A028E610D29FFC44D560D9DAC1EAC0B</string>
-			<key>IDESourceControlWCCName</key>
-			<string>websocketpp</string>
-		</dict>
-	</array>
-</dict>
-</plist>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.h b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.h
deleted file mode 100644
index 98c3992..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.h
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-//  AppDelegate.h
-//  SioChatDemo
-//
-//  Created by Melo Yao on 3/30/15.
-//  Copyright (c) 2015 Melo Yao. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-
-@interface AppDelegate : UIResponder <UIApplicationDelegate>
-
-@property (strong, nonatomic) UIWindow *window;
-
-
-@end
-
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.m b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.m
deleted file mode 100644
index 7409e0b..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/AppDelegate.m
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-//  AppDelegate.m
-//  SioChatDemo
-//
-//  Created by Melo Yao on 3/30/15.
-//  Copyright (c) 2015 Melo Yao. All rights reserved.
-//
-
-#import "AppDelegate.h"
-
-@interface AppDelegate ()
-
-@end
-
-@implementation AppDelegate
-
-
-- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
-    // Override point for customization after application launch.
-    return YES;
-}
-
-- (void)applicationWillResignActive:(UIApplication *)application {
-    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
-    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
-}
-
-- (void)applicationDidEnterBackground:(UIApplication *)application {
-    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
-    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
-}
-
-- (void)applicationWillEnterForeground:(UIApplication *)application {
-    // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
-}
-
-- (void)applicationDidBecomeActive:(UIApplication *)application {
-    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
-}
-
-- (void)applicationWillTerminate:(UIApplication *)application {
-    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
-}
-
-@end
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Base.lproj/LaunchScreen.xib b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Base.lproj/LaunchScreen.xib
deleted file mode 100644
index 7a4f7d6..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Base.lproj/LaunchScreen.xib
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="6214" systemVersion="14A314h" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES">
-    <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="6207"/>
-        <capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1"/>
-    </dependencies>
-    <objects>
-        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner"/>
-        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
-        <view contentMode="scaleToFill" id="iN0-l3-epB">
-            <rect key="frame" x="0.0" y="0.0" width="480" height="480"/>
-            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-            <subviews>
-                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="  Copyright (c) 2015 Melo Yao. All rights reserved." textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="8ie-xW-0ye">
-                    <rect key="frame" x="20" y="439" width="441" height="21"/>
-                    <fontDescription key="fontDescription" type="system" pointSize="17"/>
-                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
-                    <nil key="highlightedColor"/>
-                </label>
-                <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="SioChatDemo" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="kId-c2-rCX">
-                    <rect key="frame" x="20" y="140" width="441" height="43"/>
-                    <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
-                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
-                    <nil key="highlightedColor"/>
-                </label>
-            </subviews>
-            <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
-            <constraints>
-                <constraint firstItem="kId-c2-rCX" firstAttribute="centerY" secondItem="iN0-l3-epB" secondAttribute="bottom" multiplier="1/3" constant="1" id="5cJ-9S-tgC"/>
-                <constraint firstAttribute="centerX" secondItem="kId-c2-rCX" secondAttribute="centerX" id="Koa-jz-hwk"/>
-                <constraint firstAttribute="bottom" secondItem="8ie-xW-0ye" secondAttribute="bottom" constant="20" id="Kzo-t9-V3l"/>
-                <constraint firstItem="8ie-xW-0ye" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="MfP-vx-nX0"/>
-                <constraint firstAttribute="centerX" secondItem="8ie-xW-0ye" secondAttribute="centerX" id="ZEH-qu-HZ9"/>
-                <constraint firstItem="kId-c2-rCX" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" constant="20" symbolic="YES" id="fvb-Df-36g"/>
-            </constraints>
-            <nil key="simulatedStatusBarMetrics"/>
-            <freeformSimulatedSizeMetrics key="simulatedDestinationMetrics"/>
-            <point key="canvasLocation" x="548" y="455"/>
-        </view>
-    </objects>
-</document>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.h b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.h
deleted file mode 100644
index 901296c..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.h
+++ /dev/null
@@ -1,12 +0,0 @@
-//
-//  CRViewController.h
-//  ChatRoom
-//
-//  Created by Melo Yao on 3/30/15.
-//
-
-#import <UIKit/UIKit.h>
-
-@interface CRViewController : UIViewController
-
-@end
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.mm b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.mm
deleted file mode 100644
index 6bac43d..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/CRViewController.mm
+++ /dev/null
@@ -1,453 +0,0 @@
-//
-//  CRViewController.m
-//  ChatRoom
-//
-//  Created by Melo Yao on 3/30/15.
-//
-
-#import "CRViewController.h"
-#include "sio_client.h"
-
-typedef enum MessageFlag
-{
-    Message_System,
-    Message_Other,
-    Message_You
-};
-
-@interface MessageItem : NSObject
-@property NSString* message;
-@property MessageFlag flag; //0 system info, 1 other message, 2 your message
-@end
-
-@implementation MessageItem
-
-@end
-
-@interface CRViewController ()<UITableViewDataSource,UITableViewDelegate,NSURLConnectionDelegate,NSURLConnectionDataDelegate,UITextFieldDelegate>
-{
-    sio::client *_io;
-    NSMutableArray *_receivedMessage;
-    NSMutableSet *_typingUsers;
-    NSString* _name;
-    NSInteger _userCount;
-    NSTimer* _inputTimer;
-}
-@property (weak, nonatomic) IBOutlet UILabel *infoLabel;
-@property (weak, nonatomic) IBOutlet UILabel *typingLabel;
-
-@property (strong, nonatomic) IBOutlet UIView *loginPage;
-@property (weak, nonatomic) IBOutlet UITextField *nickName;
-- (IBAction)onSend:(id)sender;
-
-@property (weak, nonatomic) IBOutlet UITableView *tableView;
-@property (weak, nonatomic) IBOutlet UIButton *sendBtn;
-@property (weak, nonatomic) IBOutlet UITextField *messageField;
-@property (weak, nonatomic) IBOutlet UIView *messageArea;
-
--(void)onNewMessage:(NSString*) message from:(NSString*) name;
-
--(void)onUserJoined:(NSString*)user participants:(NSInteger) num;
-
--(void)onUserLeft:(NSString*) user participants:(NSInteger) num;
-
--(void)onUserTyping:(NSString*) user;
-
--(void)onUserStopTyping:(NSString*) user;
-
--(void)onLogin:(NSInteger) numParticipants;
-
--(void)onConnected;
-
--(void)onDisconnected;
-
--(void) updateUser:(NSString*)user count:(NSInteger) num joinOrLeft:(BOOL) isJoin;
-
-@end
-
-using namespace std;
-
-using namespace sio;
-
-void OnNewMessage(CFTypeRef ctrl,string const& name,sio::message::ptr const& data,bool needACK,sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSString* msg = [NSString stringWithUTF8String:data->get_map()["message"]->get_string().data()];
-        NSString* user = [NSString stringWithUTF8String:data->get_map()["username"]->get_string().data()];
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onNewMessage:msg from:user];
-        });
-    }
-   
-}
-
-void OnTyping(CFTypeRef ctrl,string const& name,sio::message::ptr const& data,bool needACK,sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSString* user = [NSString stringWithUTF8String:data->get_map()["username"]->get_string().data()];
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onUserTyping:user];
-        });
-    }
-}
-
-void OnStopTyping(CFTypeRef ctrl,string const& name,sio::message::ptr const& data,bool needACK,sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSString* user = [NSString stringWithUTF8String:data->get_map()["username"]->get_string().data()];
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onUserStopTyping:user];
-        });
-    }
-}
-
-void OnUserJoined(CFTypeRef ctrl, string const& name, sio::message::ptr const& data, bool needACK, sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSString* user = [NSString stringWithUTF8String:data->get_map()["username"]->get_string().data()];
-        NSInteger num = data->get_map()["numUsers"]->get_int();
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onUserJoined:user participants:num];
-        });
-    }
-}
-
-void OnUserLeft(CFTypeRef ctrl, string const& name, sio::message::ptr const& data, bool needACK, sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSString* user = [NSString stringWithUTF8String:data->get_map()["username"]->get_string().data()];
-        NSInteger num = data->get_map()["numUsers"]->get_int();
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onUserLeft:user participants:num];
-        });
-    }
-}
-
-
-void OnLogin(CFTypeRef ctrl, string const& name, sio::message::ptr const& data, bool needACK, sio::message::list ackResp)
-{
-    if(data->get_flag() == message::flag_object)
-    {
-        NSInteger num = data->get_map()["numUsers"]->get_int();
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [((__bridge CRViewController*)ctrl) onLogin:num];
-        });
-    }
-}
-
-void OnConnected(CFTypeRef ctrl,std::string nsp)
-{
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [((__bridge CRViewController*)ctrl) onConnected];
-    });
-}
-
-void OnFailed(CFTypeRef ctrl)
-{
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [((__bridge CRViewController*)ctrl) onDisconnected];
-    });
-}
-
-void OnClose(CFTypeRef ctrl,sio::client::close_reason const& reason)
-{
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [((__bridge CRViewController*)ctrl) onDisconnected];
-    });
-}
-
-
-@implementation CRViewController
-
--(void)awakeFromNib
-{
-    _receivedMessage = [NSMutableArray array];
-    _typingUsers = [NSMutableSet set];
-    _io = new sio::client();
-    [self.loginPage setFrame:self.view.bounds];
-    [self.view addSubview:self.loginPage];
-    self.nickName.enabled = YES;
-}
-
-- (void)viewDidLoad
-{
-    [super viewDidLoad];
-	// Do any additional setup after loading the view, typically from a nib.
-}
-
--(void)viewWillAppear:(BOOL)animated
-{
-    _io->set_socket_open_listener(std::bind(&OnConnected, (__bridge CFTypeRef)self,std::placeholders::_1));
-    _io->set_close_listener(std::bind(&OnClose, (__bridge CFTypeRef)self, std::placeholders::_1));
-    _io->set_fail_listener(std::bind(&OnFailed, (__bridge CFTypeRef)self));
-}
-
--(void)keyboardWillShow:(NSNotification*)notification
-{
-    CGFloat height = [[notification.userInfo objectForKey:UIKeyboardFrameBeginUserInfoKey] CGRectValue].size.height;
-    // Animate the current view out of the way
-    [UIView animateWithDuration:0.35 animations:^{
-        self.messageArea.transform = CGAffineTransformMakeTranslation(0, -height);
-    }];
-}
-
-
--(void)keyboardWillHide {
-    [UIView animateWithDuration:0.35 animations:^{
-         self.messageArea.transform = CGAffineTransformIdentity;
-    }];
-}
-
--(void)viewDidDisappear:(BOOL)animated
-{
-    _io->socket()->off_all();
-    _io->set_open_listener(nullptr);
-    _io->set_close_listener(nullptr);
-    _io->close();
-}
-
--(void)onNewMessage:(NSString*) message from:(NSString*) name
-{
-    MessageItem *item = [[MessageItem alloc] init];
-
-    item.flag = [name isEqualToString:_name]?Message_You:Message_Other;
-    item.message = item.flag == Message_You? [NSString stringWithFormat:@"%@:%@",message,name]:[NSString stringWithFormat:@"%@:%@",name,message];
-    [_receivedMessage addObject:item];
-    [_tableView reloadData];
-    
-    if(![_messageField isFirstResponder])
-    {
-        [_tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:[_receivedMessage count]-1 inSection:0] atScrollPosition:UITableViewScrollPositionBottom animated:YES];
-    }
-}
-
--(void)onUserJoined:(NSString*)user participants:(NSInteger) num
-{
-    _userCount = num;
-    [self updateUser:user count:num joinOrLeft:YES];
-}
-
--(void)onUserLeft:(NSString*) user participants:(NSInteger) num
-{
-    [_typingUsers removeObject:user];//protective removal.
-    [self updateTyping];
-    _userCount = num;
-    [self updateUser:user count:num joinOrLeft:NO];
-}
-
--(void)onUserTyping:(NSString*) user
-{
-    [_typingUsers addObject:user];
-    [self updateTyping];
-}
-
--(void)onUserStopTyping:(NSString*) user
-{
-    [_typingUsers removeObject:user];
-    [self updateTyping];
-}
-
--(void)onLogin:(NSInteger) numParticipants
-{
-    _name = _nickName.text;
-    _userCount = numParticipants;
-    [self.loginPage removeFromSuperview];
-    
-    [self updateUser:nil count:_userCount joinOrLeft:YES];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(keyboardWillShow:)
-                                                 name:UIKeyboardWillShowNotification
-                                               object:nil];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(keyboardWillHide)
-                                                 name:UIKeyboardWillHideNotification
-                                               object:nil];
-    
-}
-
-- (void)didReceiveMemoryWarning
-{
-    [super didReceiveMemoryWarning];
-    // Dispose of any resources that can be recreated.
-}
-
-- (IBAction)onSend:(id)sender {
-    if ([_messageField.text length]>0 && [_name length]>0) {
-        _io->socket()->emit("new message",[_messageField.text UTF8String]);
-        MessageItem *item = [[MessageItem alloc] init];
-        
-        item.flag = Message_You;
-        item.message = [NSString stringWithFormat:@"%@:You",_messageField.text];
-        [_receivedMessage addObject:item];
-        [_tableView reloadData];
-        [_tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:[_receivedMessage count]-1 inSection:0] atScrollPosition:UITableViewScrollPositionBottom animated:YES];
-    }
-    
-    self.messageField.text = nil;
-    [self.messageField resignFirstResponder];
-}
-
--(void)onConnected
-{
-    _io->socket()->emit("add user", [self.nickName.text UTF8String]);
-}
-
--(void)onDisconnected
-{
-    if([self.loginPage superview] == nil)
-    {
-        [self.view addSubview:self.loginPage];
-    }
-    self.nickName.enabled = YES;
-    
-    [[NSNotificationCenter defaultCenter] removeObserver:self
-                                                    name:UIKeyboardWillShowNotification
-                                                  object:nil];
-    
-    [[NSNotificationCenter defaultCenter] removeObserver:self
-                                                    name:UIKeyboardWillHideNotification
-                                                  object:nil];
-}
-
--(void) updateUser:(NSString*)user count:(NSInteger) num joinOrLeft:(BOOL) isJoin
-{
-    _userCount = num;
-    MessageItem *item = [[MessageItem alloc] init];
-    
-    item.flag = Message_System;
-    if (user) {
-        item.message = [NSString stringWithFormat:@"%@ %@\n%@",user,isJoin?@"joined":@"left",num==1?@"there's 1 participant":[NSString stringWithFormat:@"there are %ld participants",num]];
-    }
-    else
-    {
-        item.message = [NSString stringWithFormat:@"Welcome to Socket.IO Chat-\n%@",num==1?@"there's 1 participant":[NSString stringWithFormat:@"there are %ld participants",num]];
-    }
-
-    [_receivedMessage addObject:item];
-    [_tableView reloadData];
-    if(![_messageField isFirstResponder])
-    {
-        [_tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:[_receivedMessage count]-1 inSection:0] atScrollPosition:UITableViewScrollPositionBottom animated:YES];
-    }
-}
-
--(void) inputTimeout
-{
-    _inputTimer = nil;
-    _io->socket()->emit("stop typing", "");
-}
-
--(BOOL)textField:(UITextField *)textField shouldChangeCharactersInRange:(NSRange)range replacementString:(NSString *)string
-{
-    if(textField == self.messageField)
-    {
-        if(_inputTimer.valid)
-        {
-            [_inputTimer setFireDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];
-        }
-        else
-        {
-            _io->socket()->emit("typing", "");
-            _inputTimer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(inputTimeout) userInfo:nil repeats:NO];
-        }
-    }
-    return YES;
-}
-
-- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
-{
-    return [_receivedMessage count];
-}
-
-// Row display. Implementers should *always* try to reuse cells by setting each cell's reuseIdentifier and querying for available reusable cells with dequeueReusableCellWithIdentifier:
-// Cell gets various attributes set automatically based on table (separators) and data source (accessory views, editing controls)
-
-- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
-{
-    UITableViewCell* cell = [tableView dequeueReusableCellWithIdentifier:@"Msg"];
-    MessageItem* item = [_receivedMessage objectAtIndex:indexPath.row];
-    cell.textLabel.text = item.message;
-    switch (item.flag) {
-        case Message_System:
-            cell.textLabel.textAlignment = NSTextAlignmentCenter;
-            [cell.textLabel setFont:[UIFont fontWithName:[cell.textLabel.font fontName] size:12]];
-            break;
-        case Message_Other:
-            [cell.textLabel setFont:[UIFont fontWithName:[cell.textLabel.font fontName] size:15]];
-            cell.textLabel.textAlignment = NSTextAlignmentLeft;
-            break;
-        case Message_You:
-            [cell.textLabel setFont:[UIFont fontWithName:[cell.textLabel.font fontName] size:15]];
-            cell.textLabel.textAlignment = NSTextAlignmentRight;
-            break;
-        default:
-            break;
-    }
-    return cell;
-}
-
--(void)scrollViewDidScroll:(UIScrollView *)scrollView
-{
-    if ([self.messageField isFirstResponder]) {
-        [self.messageField resignFirstResponder];
-    }
-}
-
--(BOOL)textFieldShouldReturn:(UITextField *)textField
-{
-    if (textField == self.nickName) {
-        if ([self.nickName.text length] > 0) {
-            
-            using std::placeholders::_1;
-            using std::placeholders::_2;
-            using std::placeholders::_3;
-            using std::placeholders::_4;
-            socket::ptr socket = _io->socket();
-            
-            socket->on("new message", std::bind(&OnNewMessage, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            socket->on("typing", std::bind(&OnTyping, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            socket->on("stop typing", std::bind(&OnStopTyping, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            socket->on("user joined", std::bind(&OnUserJoined, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            socket->on("user left", std::bind(&OnUserLeft, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            socket->on("login", std::bind(&OnLogin, (__bridge CFTypeRef)self, _1,_2,_3,_4));
-            _io->connect("ws://localhost:3000");
-            self.nickName.enabled = NO;
-        }
-    }
-    else if(textField == self.messageField)
-    {
-        [self onSend:textField];
-    }
-    return YES;
-}
-
--(void)updateTyping
-{
-    NSString* typingMsg = nil;
-    NSString* name = [_typingUsers anyObject];
-    if (name) {
-        if([_typingUsers count]>1)
-        {
-            typingMsg = [NSString stringWithFormat:@"%@ and %ld more are typing",name,[_typingUsers count]];
-        }
-        else
-        {
-            typingMsg =[NSString stringWithFormat:@"%@ is typing",name];
-        }
-    }
-    self.typingLabel.text = typingMsg;
-}
-
-- (void)dealloc
-{
-    delete _io;
-}
-
-@end
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Images.xcassets/AppIcon.appiconset/Contents.json b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Images.xcassets/AppIcon.appiconset/Contents.json
deleted file mode 100644
index 36d2c80..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Images.xcassets/AppIcon.appiconset/Contents.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
-  "images" : [
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "29x29",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "40x40",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "iphone",
-      "size" : "60x60",
-      "scale" : "3x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "29x29",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "29x29",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "40x40",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "40x40",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "76x76",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "ipad",
-      "size" : "76x76",
-      "scale" : "2x"
-    }
-  ],
-  "info" : {
-    "version" : 1,
-    "author" : "xcode"
-  }
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Info.plist b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Info.plist
deleted file mode 100644
index 2ea7aa0..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Info.plist
+++ /dev/null
@@ -1,47 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.socketio.melode.$(PRODUCT_NAME:rfc1034identifier)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-	<key>UILaunchStoryboardName</key>
-	<string>LaunchScreen</string>
-	<key>UIMainStoryboardFile</key>
-	<string>Main</string>
-	<key>UIRequiredDeviceCapabilities</key>
-	<array>
-		<string>armv7</string>
-	</array>
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-	<key>UISupportedInterfaceOrientations~ipad</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
-</plist>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Main.storyboard b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Main.storyboard
deleted file mode 100644
index 498284a..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/Main.storyboard
+++ /dev/null
@@ -1,127 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="6254" systemVersion="14C109" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" initialViewController="FVA-Ip-uIE">
-    <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="6247"/>
-    </dependencies>
-    <scenes>
-        <!--View Controller-->
-        <scene sceneID="4B5-FI-8YR">
-            <objects>
-                <viewController id="FVA-Ip-uIE" customClass="CRViewController" sceneMemberID="viewController">
-                    <view key="view" contentMode="scaleToFill" id="j56-Sc-Uve">
-                        <rect key="frame" x="0.0" y="0.0" width="320" height="480"/>
-                        <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
-                        <subviews>
-                            <tableView clipsSubviews="YES" contentMode="scaleToFill" alwaysBounceVertical="YES" dataMode="prototypes" style="plain" separatorStyle="none" rowHeight="44" sectionHeaderHeight="22" sectionFooterHeight="22" id="Zd9-dA-z1N">
-                                <rect key="frame" x="0.0" y="20" width="320" height="396"/>
-                                <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-                                <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
-                                <prototypes>
-                                    <tableViewCell contentMode="scaleToFill" selectionStyle="blue" hidesAccessoryWhenEditing="NO" indentationLevel="1" indentationWidth="0.0" reuseIdentifier="Msg" textLabel="c7q-ly-Hf0" style="IBUITableViewCellStyleDefault" id="13Y-SW-wci">
-                                        <rect key="frame" x="0.0" y="22" width="320" height="44"/>
-                                        <autoresizingMask key="autoresizingMask"/>
-                                        <tableViewCellContentView key="contentView" opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="center" tableViewCell="13Y-SW-wci" id="CkG-vX-yh5">
-                                            <rect key="frame" x="0.0" y="0.0" width="320" height="43"/>
-                                            <autoresizingMask key="autoresizingMask"/>
-                                            <subviews>
-                                                <label opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="left" text="Title" lineBreakMode="tailTruncation" numberOfLines="2" baselineAdjustment="alignBaselines" minimumScaleFactor="0.5" id="c7q-ly-Hf0">
-                                                    <rect key="frame" x="15" y="0.0" width="290" height="43"/>
-                                                    <autoresizingMask key="autoresizingMask"/>
-                                                    <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="18"/>
-                                                    <color key="textColor" cocoaTouchSystemColor="darkTextColor"/>
-                                                    <nil key="highlightedColor"/>
-                                                </label>
-                                            </subviews>
-                                        </tableViewCellContentView>
-                                    </tableViewCell>
-                                </prototypes>
-                                <connections>
-                                    <outlet property="dataSource" destination="FVA-Ip-uIE" id="gbf-ws-uXu"/>
-                                    <outlet property="delegate" destination="FVA-Ip-uIE" id="Y5j-aM-c5q"/>
-                                </connections>
-                            </tableView>
-                            <view contentMode="scaleToFill" id="yh5-ME-DKM">
-                                <rect key="frame" x="0.0" y="416" width="320" height="64"/>
-                                <autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMinY="YES"/>
-                                <subviews>
-                                    <textField opaque="NO" clipsSubviews="YES" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" placeholder="Type here..." minimumFontSize="17" id="Eq9-78-qhY">
-                                        <rect key="frame" x="8" y="26" width="250" height="30"/>
-                                        <autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMaxY="YES"/>
-                                        <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="14"/>
-                                        <textInputTraits key="textInputTraits" returnKeyType="send"/>
-                                        <connections>
-                                            <outlet property="delegate" destination="FVA-Ip-uIE" id="tUP-2R-seQ"/>
-                                        </connections>
-                                    </textField>
-                                    <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" id="wwz-tj-MLo">
-                                        <rect key="frame" x="8" y="3" width="250" height="21"/>
-                                        <autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMaxY="YES"/>
-                                        <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="14"/>
-                                        <color key="textColor" white="0.33333333333333331" alpha="1" colorSpace="calibratedWhite"/>
-                                        <nil key="highlightedColor"/>
-                                    </label>
-                                    <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" lineBreakMode="middleTruncation" id="WZS-UQ-rXy">
-                                        <rect key="frame" x="266" y="30" width="46" height="22"/>
-                                        <autoresizingMask key="autoresizingMask" flexibleMinX="YES" flexibleMaxY="YES"/>
-                                        <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="18"/>
-                                        <state key="normal" title="Send">
-                                            <color key="titleColor" white="0.0" alpha="1" colorSpace="calibratedWhite"/>
-                                            <color key="titleShadowColor" white="0.5" alpha="1" colorSpace="calibratedWhite"/>
-                                        </state>
-                                        <connections>
-                                            <action selector="onSend:" destination="FVA-Ip-uIE" eventType="touchUpInside" id="0VT-Nd-fdz"/>
-                                        </connections>
-                                    </button>
-                                </subviews>
-                                <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
-                            </view>
-                        </subviews>
-                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
-                        <color key="tintColor" white="0.0" alpha="1" colorSpace="calibratedWhite"/>
-                    </view>
-                    <extendedEdge key="edgesForExtendedLayout" bottom="YES"/>
-                    <connections>
-                        <outlet property="loginPage" destination="FDy-KL-ozA" id="zBO-Gk-9OU"/>
-                        <outlet property="messageArea" destination="yh5-ME-DKM" id="nFQ-Zd-Gmx"/>
-                        <outlet property="messageField" destination="Eq9-78-qhY" id="HDE-p4-jGM"/>
-                        <outlet property="nickName" destination="Xat-ec-Oga" id="xyE-A7-aZ5"/>
-                        <outlet property="sendBtn" destination="WZS-UQ-rXy" id="nbZ-e0-RoK"/>
-                        <outlet property="tableView" destination="Zd9-dA-z1N" id="Ekd-Is-nd5"/>
-                        <outlet property="typingLabel" destination="wwz-tj-MLo" id="GxR-Bb-TGT"/>
-                    </connections>
-                </viewController>
-                <placeholder placeholderIdentifier="IBFirstResponder" id="X4s-OP-QGg" userLabel="First Responder" sceneMemberID="firstResponder"/>
-                <view contentMode="scaleToFill" id="FDy-KL-ozA">
-                    <rect key="frame" x="0.0" y="0.0" width="320" height="568"/>
-                    <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
-                    <subviews>
-                        <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Your Nickname:" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" id="Vbn-qK-OOg">
-                            <rect key="frame" x="40" y="200" width="240" height="50"/>
-                            <autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMaxY="YES"/>
-                            <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="20"/>
-                            <color key="textColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="calibratedRGB"/>
-                            <nil key="highlightedColor"/>
-                        </label>
-                        <textField opaque="NO" clipsSubviews="YES" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="center" borderStyle="roundedRect" minimumFontSize="17" id="Xat-ec-Oga">
-                            <rect key="frame" x="40" y="269" width="240" height="30"/>
-                            <autoresizingMask key="autoresizingMask" widthSizable="YES" flexibleMaxY="YES"/>
-                            <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
-                            <fontDescription key="fontDescription" name="HelveticaNeue-Light" family="Helvetica Neue" pointSize="16"/>
-                            <textInputTraits key="textInputTraits" returnKeyType="done"/>
-                            <connections>
-                                <outlet property="delegate" destination="FVA-Ip-uIE" id="fDd-Hi-o32"/>
-                            </connections>
-                        </textField>
-                    </subviews>
-                    <color key="backgroundColor" white="0.0" alpha="1" colorSpace="calibratedWhite"/>
-                </view>
-            </objects>
-            <point key="canvasLocation" x="99" y="-451"/>
-        </scene>
-    </scenes>
-    <simulatedMetricsContainer key="defaultSimulatedMetrics">
-        <simulatedStatusBarMetrics key="statusBar"/>
-        <simulatedOrientationMetrics key="orientation"/>
-        <simulatedScreenMetrics key="destination"/>
-    </simulatedMetricsContainer>
-</document>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/main.m b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/main.m
deleted file mode 100644
index e25aff0..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemo/main.m
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-//  main.m
-//  SioChatDemo
-//
-//  Created by Melo Yao on 3/30/15.
-//  Copyright (c) 2015 Melo Yao. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-#import "AppDelegate.h"
-
-int main(int argc, char * argv[]) {
-    @autoreleasepool {
-        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
-    }
-}
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/Info.plist b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/Info.plist
deleted file mode 100644
index dc26a15..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/Info.plist
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.socketio.melode.$(PRODUCT_NAME:rfc1034identifier)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-</dict>
-</plist>
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/SioChatDemoTests.m b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/SioChatDemoTests.m
deleted file mode 100644
index b3edc09..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/SioChatDemoTests/SioChatDemoTests.m
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-//  SioChatDemoTests.m
-//  SioChatDemoTests
-//
-//  Created by Melo Yao on 3/30/15.
-//  Copyright (c) 2015 Melo Yao. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-#import <XCTest/XCTest.h>
-
-@interface SioChatDemoTests : XCTestCase
-
-@end
-
-@implementation SioChatDemoTests
-
-- (void)setUp {
-    [super setUp];
-    // Put setup code here. This method is called before the invocation of each test method in the class.
-}
-
-- (void)tearDown {
-    // Put teardown code here. This method is called after the invocation of each test method in the class.
-    [super tearDown];
-}
-
-- (void)testExample {
-    // This is an example of a functional test case.
-    XCTAssert(YES, @"Pass");
-}
-
-- (void)testPerformanceExample {
-    // This is an example of a performance test case.
-    [self measureBlock:^{
-        // Put the code you want to measure the time of here.
-    }];
-}
-
-@end
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/.gitignore b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/.gitignore
deleted file mode 100644
index 5cf83bf..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-ios/*
-osx/*
-src/*
-boost_*
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/boost.sh b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/boost.sh
deleted file mode 100644
index 808430f..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/boost/boost.sh
+++ /dev/null
@@ -1,378 +0,0 @@
-#===============================================================================
-# Filename:  boost.sh
-# Author:    Pete Goodliffe
-# Copyright: (c) Copyright 2009 Pete Goodliffe
-# Licence:   Please feel free to use this, with attribution
-# Modified version
-#===============================================================================
-#
-# Builds a Boost framework for the iPhone.
-# Creates a set of universal libraries that can be used on an iPhone and in the
-# iPhone simulator. Then creates a pseudo-framework to make using boost in Xcode
-# less painful.
-#
-# To configure the script, define:
-#    BOOST_LIBS:        which libraries to build
-#    IPHONE_SDKVERSION: iPhone SDK version (e.g. 5.1)
-#
-# Then go get the source tar.bz of the boost you want to build, shove it in the
-# same directory as this script, and run "./boost.sh". Grab a cuppa. And voila.
-#===============================================================================
-
-: ${BOOST_LIBS:="random regex graph random chrono thread signals filesystem system date_time"}
-: ${IPHONE_SDKVERSION:=`xcodebuild -showsdks | grep iphoneos | egrep "[[:digit:]]+\.[[:digit:]]+" -o | tail -1`}
-: ${OSX_SDKVERSION:=10.8}
-: ${XCODE_ROOT:=`xcode-select -print-path`}
-: ${EXTRA_CPPFLAGS:="-DBOOST_AC_USE_PTHREADS -DBOOST_SP_USE_PTHREADS -std=c++11 -stdlib=libc++"}
-
-# The EXTRA_CPPFLAGS definition works around a thread race issue in
-# shared_ptr. I encountered this historically and have not verified that
-# the fix is no longer required. Without using the posix thread primitives
-# an invalid compare-and-swap ARM instruction (non-thread-safe) was used for the
-# shared_ptr use count causing nasty and subtle bugs.
-#
-# Should perhaps also consider/use instead: -BOOST_SP_USE_PTHREADS
-
-: ${TARBALLDIR:=`pwd`}
-: ${SRCDIR:=`pwd`/src}
-: ${IOSBUILDDIR:=`pwd`/ios/build}
-: ${OSXBUILDDIR:=`pwd`/osx/build}
-: ${PREFIXDIR:=`pwd`/ios/prefix}
-: ${IOSFRAMEWORKDIR:=`pwd`/ios/framework}
-: ${OSXFRAMEWORKDIR:=`pwd`/osx/framework}
-: ${COMPILER:="clang++"}
-
-: ${BOOST_VERSION:=1.55.0}
-: ${BOOST_VERSION2:=1_55_0}
-
-BOOST_TARBALL=$TARBALLDIR/boost_$BOOST_VERSION2.tar.bz2
-BOOST_SRC=$SRCDIR/boost_${BOOST_VERSION2}
-
-#===============================================================================
-ARM_DEV_CMD="xcrun --sdk iphoneos"
-SIM_DEV_CMD="xcrun --sdk iphonesimulator"
-OSX_DEV_CMD="xcrun --sdk macosx"
-
-ARM_COMBINED_LIB=$IOSBUILDDIR/lib_boost_arm.a
-SIM_COMBINED_LIB=$IOSBUILDDIR/lib_boost_x86.a
-
-#===============================================================================
-
-
-#===============================================================================
-# Functions
-#===============================================================================
-
-abort()
-{
-    echo
-    echo "Aborted: $@"
-    exit 1
-}
-
-doneSection()
-{
-    echo
-    echo "================================================================="
-    echo "Done"
-    echo
-}
-
-#===============================================================================
-
-cleanEverythingReadyToStart()
-{
-    echo Cleaning everything before we start to build...
-
-    rm -rf iphone-build iphonesim-build osx-build
-    rm -rf $IOSBUILDDIR
-    rm -rf $OSXBUILDDIR
-    rm -rf $PREFIXDIR
-    rm -rf $IOSFRAMEWORKDIR/$FRAMEWORK_NAME.framework
-    rm -rf $OSXFRAMEWORKDIR/$FRAMEWORK_NAME.framework
-
-    doneSection
-}
-
-#===============================================================================
-
-downloadBoost()
-{
-    if [ ! -s $TARBALLDIR/boost_${BOOST_VERSION2}.tar.bz2 ]; then
-        echo "Downloading boost ${BOOST_VERSION}"
-        curl -L -o $TARBALLDIR/boost_${BOOST_VERSION2}.tar.bz2 http://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/boost_${BOOST_VERSION2}.tar.bz2/download
-    fi
-
-    doneSection
-}
-
-#===============================================================================
-
-unpackBoost()
-{
-    [ -f "$BOOST_TARBALL" ] || abort "Source tarball missing."
-
-    echo Unpacking boost into $SRCDIR...
-
-    [ -d $SRCDIR ]    || mkdir -p $SRCDIR
-    [ -d $BOOST_SRC ] || ( cd $SRCDIR; tar xfj $BOOST_TARBALL )
-    [ -d $BOOST_SRC ] && echo "    ...unpacked as $BOOST_SRC"
-
-    doneSection
-}
-
-#===============================================================================
-
-restoreBoost()
-{
-    cp $BOOST_SRC/tools/build/v2/user-config.jam-bk $BOOST_SRC/tools/build/v2/user-config.jam
-}
-
-#===============================================================================
-
-updateBoost()
-{
-    echo Updating boost into $BOOST_SRC...
-
-    cp $BOOST_SRC/tools/build/v2/user-config.jam $BOOST_SRC/tools/build/v2/user-config.jam-bk
-
-    cat >> $BOOST_SRC/tools/build/v2/user-config.jam <<EOF
-using darwin : ${IPHONE_SDKVERSION}~iphone
-: $XCODE_ROOT/Toolchains/XcodeDefault.xctoolchain/usr/bin/$COMPILER -arch armv6 -arch armv7 -arch armv7s -arch arm64 -fvisibility=hidden -fvisibility-inlines-hidden $EXTRA_CPPFLAGS
-: <striper> <root>$XCODE_ROOT/Platforms/iPhoneOS.platform/Developer
-: <architecture>arm <target-os>iphone
-;
-using darwin : ${IPHONE_SDKVERSION}~iphonesim
-: $XCODE_ROOT/Toolchains/XcodeDefault.xctoolchain/usr/bin/$COMPILER -arch i386 -arch x86_64 -fvisibility=hidden -fvisibility-inlines-hidden $EXTRA_CPPFLAGS
-: <striper> <root>$XCODE_ROOT/Platforms/iPhoneSimulator.platform/Developer
-: <architecture>x86 <target-os>iphone
-;
-EOF
-
-    doneSection
-}
-
-#===============================================================================
-
-inventMissingHeaders()
-{
-    # These files are missing in the ARM iPhoneOS SDK, but they are in the simulator.
-    # They are supported on the device, so we copy them from x86 SDK to a staging area
-    # to use them on ARM, too.
-    echo Invent missing headers
-
-    cp $XCODE_ROOT/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator${IPHONE_SDKVERSION}.sdk/usr/include/{crt_externs,bzlib}.h $BOOST_SRC
-}
-
-#===============================================================================
-
-bootstrapBoost()
-{
-    cd $BOOST_SRC
-
-    BOOST_LIBS_COMMA=$(echo $BOOST_LIBS | sed -e "s/ /,/g")
-    echo "Bootstrapping (with libs $BOOST_LIBS_COMMA)"
-    ./bootstrap.sh --with-libraries=$BOOST_LIBS_COMMA
-
-    doneSection
-}
-
-#===============================================================================
-
-buildBoostForIPhoneOS()
-{
-    cd $BOOST_SRC
-
-    # Install this one so we can copy the includes for the frameworks...
-    ./bjam -j16 --build-dir=iphone-build --stagedir=iphone-build/stage --prefix=$PREFIXDIR toolset=darwin architecture=arm target-os=iphone macosx-version=iphone-${IPHONE_SDKVERSION} define=_LITTLE_ENDIAN link=static stage
-    ./bjam -j16 --build-dir=iphone-build --stagedir=iphone-build/stage --prefix=$PREFIXDIR toolset=darwin architecture=arm target-os=iphone macosx-version=iphone-${IPHONE_SDKVERSION} define=_LITTLE_ENDIAN link=static install
-    doneSection
-
-    ./bjam -j16 --build-dir=iphonesim-build --stagedir=iphonesim-build/stage --toolset=darwin-${IPHONE_SDKVERSION}~iphonesim architecture=x86 target-os=iphone macosx-version=iphonesim-${IPHONE_SDKVERSION} link=static stage
-    doneSection
-
-  #  ./b2 -j16 --build-dir=osx-build --stagedir=osx-build/stage toolset=clang cxxflags="-std=c++11 -stdlib=libc++ -arch i386 -arch x86_64" linkflags="-stdlib=libc++" link=static threading=multi stage
-    doneSection
-}
-
-#===============================================================================
-
-scrunchAllLibsTogetherInOneLibPerPlatform()
-{
-    cd $BOOST_SRC
-
-    mkdir -p $IOSBUILDDIR/armv6/obj
-    mkdir -p $IOSBUILDDIR/armv7/obj
-    mkdir -p $IOSBUILDDIR/armv7s/obj
-	mkdir -p $IOSBUILDDIR/arm64/obj
-    mkdir -p $IOSBUILDDIR/i386/obj
-	mkdir -p $IOSBUILDDIR/x86_64/obj
-
-    mkdir -p $OSXBUILDDIR/i386/obj
-    mkdir -p $OSXBUILDDIR/x86_64/obj
-
-    ALL_LIBS=""
-
-    echo Splitting all existing fat binaries...
-
-    for NAME in $BOOST_LIBS; do
-        ALL_LIBS="$ALL_LIBS libboost_$NAME.a"
-
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv6 -o $IOSBUILDDIR/armv6/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv7 -o $IOSBUILDDIR/armv7/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin armv7s -o $IOSBUILDDIR/armv7s/libboost_$NAME.a
-		$ARM_DEV_CMD lipo "iphone-build/stage/lib/libboost_$NAME.a" -thin arm64 -o $IOSBUILDDIR/arm64/libboost_$NAME.a
-
-		$ARM_DEV_CMD lipo "iphonesim-build/stage/lib/libboost_$NAME.a" -thin i386 -o $IOSBUILDDIR/i386/libboost_$NAME.a
-		$ARM_DEV_CMD lipo "iphonesim-build/stage/lib/libboost_$NAME.a" -thin x86_64 -o $IOSBUILDDIR/x86_64/libboost_$NAME.a
-
-        $ARM_DEV_CMD lipo "osx-build/stage/lib/libboost_$NAME.a" -thin i386 -o $OSXBUILDDIR/i386/libboost_$NAME.a
-        $ARM_DEV_CMD lipo "osx-build/stage/lib/libboost_$NAME.a" -thin x86_64 -o $OSXBUILDDIR/x86_64/libboost_$NAME.a
-    done
-
-    echo "Decomposing each architecture's .a files"
-
-    for NAME in $ALL_LIBS; do
-        echo Decomposing $NAME...
-        (cd $IOSBUILDDIR/armv6/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/armv7/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/armv7s/obj; ar -x ../$NAME );
-		(cd $IOSBUILDDIR/arm64/obj; ar -x ../$NAME );
-        (cd $IOSBUILDDIR/i386/obj; ar -x ../$NAME );
-		(cd $IOSBUILDDIR/x86_64/obj; ar -x ../$NAME );
-
-        (cd $OSXBUILDDIR/i386/obj; ar -x ../$NAME );
-        (cd $OSXBUILDDIR/x86_64/obj; ar -x ../$NAME );
-    done
-
-    echo "Linking each architecture into an uberlib ($ALL_LIBS => libboost.a )"
-
-    rm $IOSBUILDDIR/*/libboost.a
-    
-    echo ...armv6
-    (cd $IOSBUILDDIR/armv6; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...armv7
-    (cd $IOSBUILDDIR/armv7; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...armv7s
-    (cd $IOSBUILDDIR/armv7s; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...arm64
-    (cd $IOSBUILDDIR/arm64; $ARM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...i386
-    (cd $IOSBUILDDIR/i386;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-    echo ...x86_64
-    (cd $IOSBUILDDIR/x86_64;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-
-    rm $OSXBUILDDIR/*/libboost.a
-    echo ...osx-i386
-    (cd $OSXBUILDDIR/i386;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-
-    echo ...x86_64
-    (cd $OSXBUILDDIR/x86_64;  $SIM_DEV_CMD ar crus libboost.a obj/*.o; )
-}
-
-#===============================================================================
-buildFramework()
-{
-    : ${1:?}
-    FRAMEWORKDIR=$1
-    BUILDDIR=$2
-
-    VERSION_TYPE=Alpha
-    FRAMEWORK_NAME=boost
-    FRAMEWORK_VERSION=A
-
-    FRAMEWORK_CURRENT_VERSION=$BOOST_VERSION
-    FRAMEWORK_COMPATIBILITY_VERSION=$BOOST_VERSION
-
-    FRAMEWORK_BUNDLE=$FRAMEWORKDIR/$FRAMEWORK_NAME.framework
-    echo "Framework: Building $FRAMEWORK_BUNDLE from $BUILDDIR..."
-
-    rm -rf $FRAMEWORK_BUNDLE
-
-    echo "Framework: Setting up directories..."
-    mkdir -p $FRAMEWORK_BUNDLE
-    mkdir -p $FRAMEWORK_BUNDLE/Versions
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Resources
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Headers
-    mkdir -p $FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/Documentation
-
-    echo "Framework: Creating symlinks..."
-    ln -s $FRAMEWORK_VERSION               $FRAMEWORK_BUNDLE/Versions/Current
-    ln -s Versions/Current/Headers         $FRAMEWORK_BUNDLE/Headers
-    ln -s Versions/Current/Resources       $FRAMEWORK_BUNDLE/Resources
-    ln -s Versions/Current/Documentation   $FRAMEWORK_BUNDLE/Documentation
-    ln -s Versions/Current/$FRAMEWORK_NAME $FRAMEWORK_BUNDLE/$FRAMEWORK_NAME
-
-    FRAMEWORK_INSTALL_NAME=$FRAMEWORK_BUNDLE/Versions/$FRAMEWORK_VERSION/$FRAMEWORK_NAME
-
-    echo "Lipoing library into $FRAMEWORK_INSTALL_NAME..."
-    $ARM_DEV_CMD lipo -create $BUILDDIR/*/libboost.a -o "$FRAMEWORK_INSTALL_NAME" || abort "Lipo $1 failed"
-
-    echo "Framework: Copying includes..."
-    cp -r $PREFIXDIR/include/boost/*  $FRAMEWORK_BUNDLE/Headers/
-
-    echo "Framework: Creating plist..."
-    cat > $FRAMEWORK_BUNDLE/Resources/Info.plist <<EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-<key>CFBundleDevelopmentRegion</key>
-<string>English</string>
-<key>CFBundleExecutable</key>
-<string>${FRAMEWORK_NAME}</string>
-<key>CFBundleIdentifier</key>
-<string>org.boost</string>
-<key>CFBundleInfoDictionaryVersion</key>
-<string>6.0</string>
-<key>CFBundlePackageType</key>
-<string>FMWK</string>
-<key>CFBundleSignature</key>
-<string>????</string>
-<key>CFBundleVersion</key>
-<string>${FRAMEWORK_CURRENT_VERSION}</string>
-</dict>
-</plist>
-EOF
-
-    doneSection
-}
-
-#===============================================================================
-# Execution starts here
-#===============================================================================
-
-mkdir -p $IOSBUILDDIR
-
-cleanEverythingReadyToStart #may want to comment if repeatedly running during dev
-restoreBoost
-
-echo "BOOST_VERSION:     $BOOST_VERSION"
-echo "BOOST_LIBS:        $BOOST_LIBS"
-echo "BOOST_SRC:         $BOOST_SRC"
-echo "IOSBUILDDIR:       $IOSBUILDDIR"
-echo "OSXBUILDDIR:       $OSXBUILDDIR"
-echo "PREFIXDIR:         $PREFIXDIR"
-echo "IOSFRAMEWORKDIR:   $IOSFRAMEWORKDIR"
-echo "OSXFRAMEWORKDIR:   $OSXFRAMEWORKDIR"
-echo "IPHONE_SDKVERSION: $IPHONE_SDKVERSION"
-echo "XCODE_ROOT:        $XCODE_ROOT"
-echo "COMPILER:          $COMPILER"
-echo
-
-downloadBoost
-unpackBoost
-inventMissingHeaders
-bootstrapBoost
-updateBoost
-buildBoostForIPhoneOS
-scrunchAllLibsTogetherInOneLibPerPlatform
-buildFramework $IOSFRAMEWORKDIR $IOSBUILDDIR
-buildFramework $OSXFRAMEWORKDIR $OSXBUILDDIR
-
-restoreBoost
-
-echo "Completed successfully"
-
-#===============================================================================
diff --git a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/sioclientTests/Info.plist b/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/sioclientTests/Info.plist
deleted file mode 100644
index dc26a15..0000000
--- a/third_party/socket.io-client-cpp/examples/iOS/SioChatDemo/sioclientTests/Info.plist
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>en</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.socketio.melode.$(PRODUCT_NAME:rfc1034identifier)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1</string>
-</dict>
-</plist>
diff --git a/third_party/socket.io-client-cpp/lib/asio/.appveyor.yml b/third_party/socket.io-client-cpp/lib/asio/.appveyor.yml
deleted file mode 100644
index 53f5ed5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/.appveyor.yml
+++ /dev/null
@@ -1,118 +0,0 @@
-version: "{branch} (#{build})"
-
-image:
-  - Visual Studio 2015
-  - Visual Studio 2017
-  - Visual Studio 2019
-
-environment:
-  DEBUG: 1
-  WARNINGS: 1
-  matrix:
-    - STANDALONE: 1
-      HEADER_ONLY: 1
-      MSVC: 1
-    - STANDALONE: 1
-      SEPARATE_COMPILATION: 1
-      MSVC: 1
-    - STANDALONE: 1
-      MINGW: 1
-    - STANDALONE: 1
-      CXXLATEST: 1
-      MSVC: 1
-    - STANDALONE: 1
-      HEADER_ONLY: 1
-      WIN9X: 1
-      MSVC: 1
-    - STANDALONE: 1
-      SEPARATE_COMPILATION: 1
-      WIN9X: 1
-      MSVC: 1
-    - USING_BOOST: 1
-      HEADER_ONLY: 1
-      MSVC: 1
-    - USING_BOOST: 1
-      SEPARATE_COMPILATION: 1
-      MSVC: 1
-    - USING_BOOST: 1
-      MINGW: 1
-
-for:
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2015
-          MSVC: 1
-    environment:
-      BOOSTDIR: C:\Libraries\boost_1_67_0
-    build_script:
-      - call "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x64
-      - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x86_amd64
-      - cd asio\src
-      - nmake -f Makefile.msc
-      - nmake -f Makefile.msc check
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2017
-          MSVC: 1
-    environment:
-      BOOSTDIR: C:\Libraries\boost_1_69_0
-      _WIN32_WINNT: 0x0603
-    build_script:
-      - call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x86_amd64
-      - cd asio\src
-      - nmake -f Makefile.msc
-      - nmake -f Makefile.msc check
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2019
-          MSVC: 1
-    environment:
-      BOOSTDIR: C:\Libraries\boost_1_83_0
-      _WIN32_WINNT: 0x0A00
-    build_script:
-      - call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsall.bat" x86_amd64
-      - cd asio\src
-      - nmake -f Makefile.msc
-      - nmake -f Makefile.msc check
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2019
-          MINGW: 1
-    environment:
-      BOOSTDIR: C:/Libraries/boost_1_83_0
-    build_script:
-      - PATH=C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;C:\msys64\usr\bin;%PATH%
-      - cd asio\src
-      - mingw32-make -f Makefile.mgw
-      - mingw32-make -f Makefile.mgw check
-
-matrix:
-  exclude:
-    - image: Visual Studio 2015
-      HEADER_ONLY: 1
-    - image: Visual Studio 2015
-      CXXLATEST: 1
-    - image: Visual Studio 2015
-      WIN9X: 1
-    - image: Visual Studio 2015
-      USING_BOOST: 1
-    - image: Visual Studio 2015
-      MINGW: 1
-    - image: Visual Studio 2017
-      SEPARATE_COMPILATION: 1
-    - image: Visual Studio 2017
-      CXXLATEST: 1
-    - image: Visual Studio 2017
-      WIN9X: 1
-    - image: Visual Studio 2017
-      USING_BOOST: 1
-    - image: Visual Studio 2017
-      MINGW: 1
-    - image: Visual Studio 2019
-      HEADER_ONLY: 1
-    - image: Visual Studio 2019
-      WIN9X: 1
diff --git a/third_party/socket.io-client-cpp/lib/asio/.cirrus.yml b/third_party/socket.io-client-cpp/lib/asio/.cirrus.yml
deleted file mode 100644
index 073f297..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/.cirrus.yml
+++ /dev/null
@@ -1,16 +0,0 @@
-freebsd_instance:
-  image_family: freebsd-14-0
-  cpu: 1
-
-env:
-  CXXFLAGS: -std=c++14 -Wall -Wextra -O2
-
-task:
-  install_script:
-    - pkg install -y autoconf automake pkgconf
-  build_script:
-    - cd asio
-    - ./autogen.sh
-    - ./configure --with-boost=no
-    - make
-    - make check
diff --git a/third_party/socket.io-client-cpp/lib/asio/.github/workflows/ci.yml b/third_party/socket.io-client-cpp/lib/asio/.github/workflows/ci.yml
deleted file mode 100644
index a80ab18..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/.github/workflows/ci.yml
+++ /dev/null
@@ -1,343 +0,0 @@
-name: asio CI
-
-on:
-  push:
-    branches: [ master, citest-* ]
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        build-type: ['sanity']
-        runs-on: [ubuntu-20.04, ubuntu-22.04, macos-latest]
-        compiler: [g++-8, g++-9, g++-10, g++-12, clang++-10, clang++-14, g++]
-        cxx-std: ['c++11', 'c++14', 'c++17', 'c++2a', 'c++20']
-        separate-compilation: ['', '--enable-separate-compilation']
-        optim-level: ['-O0']
-        no-deprecated: ['']
-        select-reactor: ['', '-DASIO_DISABLE_EPOLL', '-DASIO_DISABLE_KQUEUE']
-        handler-tracking: ['']
-        boost: ['']
-        boost-url: ['']
-        exclude:
-          # New compilers don't run on ubuntu 20.04
-          - runs-on: ubuntu-20.04
-            compiler: g++-12
-          - runs-on: ubuntu-20.04
-            compiler: clang++-14
-          # Older compilers don't run on ubuntu 22.04
-          - runs-on: ubuntu-22.04
-            compiler: g++-8
-          - runs-on: ubuntu-22.04
-            compiler: clang++-10
-          # Unversioned g++ doesn't run on ubuntu
-          - runs-on: ubuntu-20.04
-            compiler: g++
-          - runs-on: ubuntu-22.04
-            compiler: g++
-          # Versioned g++ and clang++ don't run on macOS
-          - runs-on: macos-latest
-            compiler: g++-8
-          - runs-on: macos-latest
-            compiler: g++-9
-          - runs-on: macos-latest
-            compiler: g++-10
-          - runs-on: macos-latest
-            compiler: g++-12
-          - runs-on: macos-latest
-            compiler: clang++-10
-          - runs-on: macos-latest
-            compiler: clang++-14
-          # Older compilers don't support newer std variants
-          - compiler: g++-8
-            cxx-std: c++20
-          - compiler: g++-9
-            cxx-std: c++20
-          - compiler: g++-10
-            cxx-std: c++2a
-          - compiler: g++-12
-            cxx-std: c++2a
-          - compiler: clang++-10
-            cxx-std: c++20
-          - compiler: clang++-14
-            cxx-std: c++20
-          - compiler: clang++-14
-            cxx-std: c++2a
-          - runs-on: macos-latest
-            cxx-std: c++20
-          # Specifying the select reactor is OS-specific
-          - runs-on: ubuntu-20.04
-            select-reactor: -DASIO_DISABLE_KQUEUE
-          - runs-on: ubuntu-22.04
-            select-reactor: -DASIO_DISABLE_KQUEUE
-          - runs-on: macos-latest
-            select-reactor: -DASIO_DISABLE_EPOLL
-          # Trim builds that use separate compilation
-          - compiler: g++-8
-            separate-compilation: --enable-separate-compilation
-          - compiler: g++-9
-            separate-compilation: --enable-separate-compilation
-          - compiler: g++-10
-            separate-compilation: --enable-separate-compilation
-          - runs-on: macos-latest
-            cxx-std: c++14
-            separate-compilation: --enable-separate-compilation
-          - runs-on: macos-latest
-            cxx-std: c++17
-            separate-compilation: --enable-separate-compilation
-          # Trim builds that use select reactor
-          - compiler: g++-8
-            select-reactor: -DASIO_DISABLE_EPOLL
-          - compiler: g++-9
-            select-reactor: -DASIO_DISABLE_EPOLL
-          - compiler: g++-10
-            select-reactor: -DASIO_DISABLE_EPOLL
-        include:
-          #
-          # Linux / g++-12 -std=c++20 -fcoroutines / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: ubuntu-22.04
-            compiler: g++-12
-            cxx-std: c++20 -fcoroutines
-            optim-level: -O2
-          #
-          # Linux / g++-12 -std=c++17 / -O2 / boost 1.76
-          #
-          - build-type: full
-            runs-on: ubuntu-22.04
-            compiler: g++-12
-            cxx-std: c++17
-            optim-level: -O2
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_76_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.76.0/source/boost_1_76_0.tar.bz2
-          #
-          # Linux / g++-10 / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            optim-level: -O2
-          #
-          # Linux / g++-10 / -O0 / standalone / handler tracking
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            optim-level: -O0
-            handler-tracking: -DASIO_ENABLE_HANDLER_TRACKING
-          #
-          # Linux / g++-10 / -O0 / standalone / epoll disabled
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            optim-level: -O0
-            select-reactor: -DASIO_DISABLE_EPOLL
-          #
-          # Linux / g++-10 / -O0 / standalone / separate compilation / handler tracking
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-            handler-tracking: -DASIO_ENABLE_HANDLER_TRACKING
-          #
-          # Linux / g++-10 / -O0 / standalone / separate compilation / epoll disabled
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-            select-reactor: -DASIO_DISABLE_EPOLL
-          #
-          # Linux / g++-10 / -O2 / boost 1.83
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            optim-level: -O2
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-          #
-          # Linux / g++-10 / -O0 / boost 1.83 / epoll disabled
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            optim-level: -O0
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-            select-reactor: -DASIO_DISABLE_EPOLL
-          #
-          # Linux / g++-10 / -O0 / boost 1.83 / separate compilation
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-10
-            cxx-std: c++14
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-          #
-          # Linux / g++-8 / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-8
-            cxx-std: c++11
-            optim-level: -O2
-          #
-          # Linux / g++-8 / -O0 / standalone / separate compilation
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-8
-            cxx-std: c++11
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-          #
-          # Linux / g++-8 -std=c++11 / -O2 / boost 1.83
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: g++-8
-            cxx-std: c++11
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O2
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-          #
-          # Linux / clang++-14 -std=c++2a / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: ubuntu-22.04
-            compiler: clang++-14
-            cxx-std: c++2a
-            cxx-stdlib: -stdlib=libc++
-            optim-level: -O2
-          #
-          # Linux / clang++-14 -std=c++11 / -O0 / standalone / separate compilation
-          #
-          - build-type: full
-            runs-on: ubuntu-22.04
-            compiler: clang++-14
-            cxx-std: c++11
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-          #
-          # Linux / clang++-14 -std=c++20 / -O2 / standalone / separate compilation
-          #
-          - build-type: full
-            runs-on: ubuntu-22.04
-            compiler: clang++-14
-            cxx-std: c++20
-            cxx-stdlib: -stdlib=libc++
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O2
-          #
-          # Linux / clang++-10 -std=c++11 / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: ubuntu-20.04
-            compiler: clang++-10
-            cxx-std: c++11
-            optim-level: -O2
-          #
-          # macOS / c++2a -fcoroutines-ts / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++2a -fcoroutines-ts
-            optim-level: -O2
-          #
-          # macOS / c++11 / -O2 / standalone
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++11
-            optim-level: -O2
-          #
-          # macOS / c++11 / -O0 / standalone / kqueue disabled
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++11
-            optim-level: -O0
-            select-reactor: -DASIO_DISABLE_KQUEUE
-          #
-          # macOS / c++11 / -O0 / standalone / separate compilation
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++11
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-          #
-          # macOS / c++11 / -O2 / boost 1.83
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++11
-            optim-level: -O2
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-          #
-          # macOS / c++11 / -O2 / boost 1.83 / separate compilation
-          #
-          - build-type: full
-            runs-on: macos-latest
-            compiler: g++
-            cxx-std: c++11
-            separate-compilation: --enable-separate-compilation
-            optim-level: -O0
-            with-boost: --with-boost=$GITHUB_WORKSPACE/boost_1_83_0
-            boost-url: https://boostorg.jfrog.io/artifactory/main/release/1.83.0/source/boost_1_83_0.tar.bz2
-    runs-on: ${{ matrix.runs-on }}
-    env:
-      CXX: ${{ matrix.compiler }}
-      CXXFLAGS: -std=${{ matrix.cxx-std }} ${{ matrix.cxx-stdlib }} ${{ matrix.optim-level }} -Wall -Wextra ${{ matrix.no-deprecated }} ${{ matrix.select-reactor }} ${{ matrix.handler-tracking }}
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install autotools
-      if: startsWith(matrix.runs-on, 'macos')
-      run: brew install automake
-    - name: Install compiler
-      if: startsWith(matrix.runs-on, 'ubuntu')
-      run: sudo apt-get install -y ${{ matrix.compiler }}
-    - name: Install boost
-      if: startsWith(matrix.with-boost, '--with-boost=$GITHUB_WORKSPACE')
-      run: |
-        wget --quiet -O - ${{ matrix.boost-url }} | tar -xj
-    - name: Configure
-      working-directory: asio
-      run: |
-        ./autogen.sh
-        ./configure ${{ matrix.separate-compilation }} ${{ matrix.with-boost }}
-    - name: Line length check
-      working-directory: asio
-      run: perl ./boostify.pl --includes-only
-    - name: Sanity check
-      if: startsWith(matrix.build-type, 'sanity')
-      working-directory: asio/src/tests
-      run: make unit/io_context.log unit/ip/tcp.log unit/ts/net.log
-    - name: Build
-      if: startsWith(matrix.build-type, 'full')
-      working-directory: asio
-      run: make && make check
diff --git a/third_party/socket.io-client-cpp/lib/asio/.gitignore b/third_party/socket.io-client-cpp/lib/asio/.gitignore
deleted file mode 100644
index e6c8ff1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-/*.cpp
-/*.hpp
-/boost
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/.gitignore
deleted file mode 100644
index 3925217..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/.gitignore
+++ /dev/null
@@ -1,24 +0,0 @@
-Makefile
-Makefile.in
-aclocal.m4
-asio.pc
-autom4te.cache
-compile
-config.guess
-config.log
-config.status
-config.sub
-configure
-depcomp
-install-sh
-missing
-test-driver
-/doc
-/lib
-/boostified
-/tsified
-*.gz
-*.bz2
-*.zip
-/*.cpp
-/*.hpp
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/COPYING b/third_party/socket.io-client-cpp/lib/asio/asio/COPYING
deleted file mode 100644
index da1a2db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/COPYING
+++ /dev/null
@@ -1,4 +0,0 @@
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/INSTALL b/third_party/socket.io-client-cpp/lib/asio/asio/INSTALL
deleted file mode 100644
index 1dd78db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/INSTALL
+++ /dev/null
@@ -1,5 +0,0 @@
-See doc/index.html for information on:
-  - External dependencies
-  - Using, building, and configuring Asio
-  - Supported platforms
-  - How to build the tests and examples
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/LICENSE_1_0.txt b/third_party/socket.io-client-cpp/lib/asio/asio/LICENSE_1_0.txt
deleted file mode 100644
index 36b7cd9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/LICENSE_1_0.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/Makefile.am
deleted file mode 100644
index bc4f75b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/Makefile.am
+++ /dev/null
@@ -1,22 +0,0 @@
-AUTOMAKE_OPTIONS = foreign dist-bzip2 dist-zip
-
-pkgconfig_DATA = asio.pc
-pkgconfigdir = $(libdir)/pkgconfig
-
-SUBDIRS = include src
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/aclocal.m4 \
-	$(srcdir)/configure \
-	$(srcdir)/config.guess \
-	$(srcdir)/config.sub \
-	$(srcdir)/depcomp \
-	$(srcdir)/install-sh \
-	$(srcdir)/missing \
-	$(srcdir)/mkinstalldirs \
-	$(srcdir)/Makefile.in \
-	asio-*.tar.gz
-
-EXTRA_DIST = \
-	LICENSE_1_0.txt \
-	doc
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/README b/third_party/socket.io-client-cpp/lib/asio/asio/README
deleted file mode 100644
index d37299f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/README
+++ /dev/null
@@ -1,4 +0,0 @@
-asio version 1.31.0
-Released Monday, 05 August 2024.
-
-See doc/index.html for API documentation and a tutorial.
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/asio.manifest b/third_party/socket.io-client-cpp/lib/asio/asio/asio.manifest
deleted file mode 100644
index 3ce0f40..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/asio.manifest
+++ /dev/null
@@ -1,7116 +0,0 @@
-/
-/aclocal.m4
-/asio.pc.in
-/compile
-/config.guess
-/config.sub
-/configure
-/configure.ac
-/COPYING
-/depcomp
-/doc/
-/doc/1.png
-/doc/2.png
-/doc/3.png
-/doc/4.png
-/doc/5.png
-/doc/6.png
-/doc/7.png
-/doc/8.png
-/doc/asio/
-/doc/asio/examples/
-/doc/asio/examples/cpp11_examples.html
-/doc/asio/examples/cpp14_examples.html
-/doc/asio/examples/cpp17_examples.html
-/doc/asio/examples/cpp20_examples.html
-/doc/asio/examples.html
-/doc/asio/history.html
-/doc/asio/index.html
-/doc/asio/net_ts.html
-/doc/asio/overview/
-/doc/asio/overview/basics.html
-/doc/asio/overview/channels.html
-/doc/asio/overview/composition/
-/doc/asio/overview/composition/compose.html
-/doc/asio/overview/composition/coro.html
-/doc/asio/overview/composition/coroutine.html
-/doc/asio/overview/composition/cpp20_coroutines.html
-/doc/asio/overview/composition/deferred.html
-/doc/asio/overview/composition/futures.html
-/doc/asio/overview/composition.html
-/doc/asio/overview/composition/immediate_completion.html
-/doc/asio/overview/composition/parallel_group.html
-/doc/asio/overview/composition/promises.html
-/doc/asio/overview/composition/spawn.html
-/doc/asio/overview/composition/token_adapters.html
-/doc/asio/overview/composition/type_erasure.html
-/doc/asio/overview/core/
-/doc/asio/overview/core/allocation.html
-/doc/asio/overview/core/async.html
-/doc/asio/overview/core/buffers.html
-/doc/asio/overview/core/cancellation.html
-/doc/asio/overview/core/concurrency_hint.html
-/doc/asio/overview/core/handler_tracking.html
-/doc/asio/overview/core.html
-/doc/asio/overview/core/line_based.html
-/doc/asio/overview/core/reactor.html
-/doc/asio/overview/core/strands.html
-/doc/asio/overview/core/streams.html
-/doc/asio/overview/core/threads.html
-/doc/asio/overview/cpp2011/
-/doc/asio/overview/cpp2011/array.html
-/doc/asio/overview/cpp2011/atomic.html
-/doc/asio/overview/cpp2011/chrono.html
-/doc/asio/overview/cpp2011.html
-/doc/asio/overview/cpp2011/move_handlers.html
-/doc/asio/overview/cpp2011/move_objects.html
-/doc/asio/overview/cpp2011/shared_ptr.html
-/doc/asio/overview/cpp2011/system_error.html
-/doc/asio/overview/cpp2011/variadic.html
-/doc/asio/overview/files.html
-/doc/asio/overview.html
-/doc/asio/overview/implementation.html
-/doc/asio/overview/model/
-/doc/asio/overview/model/allocators.html
-/doc/asio/overview/model/associators.html
-/doc/asio/overview/model/async_agents.html
-/doc/asio/overview/model/async_ops.html
-/doc/asio/overview/model/cancellation.html
-/doc/asio/overview/model/child_agents.html
-/doc/asio/overview/model/completion_tokens.html
-/doc/asio/overview/model/executors.html
-/doc/asio/overview/model/higher_levels.html
-/doc/asio/overview/model.html
-/doc/asio/overview/model/library_elements.html
-/doc/asio/overview/networking/
-/doc/asio/overview/networking/bsd_sockets.html
-/doc/asio/overview/networking.html
-/doc/asio/overview/networking/iostreams.html
-/doc/asio/overview/networking/other_protocols.html
-/doc/asio/overview/networking/protocols.html
-/doc/asio/overview/pipes.html
-/doc/asio/overview/posix/
-/doc/asio/overview/posix/fork.html
-/doc/asio/overview/posix.html
-/doc/asio/overview/posix/local.html
-/doc/asio/overview/posix/stream_descriptor.html
-/doc/asio/overview/rationale.html
-/doc/asio/overview/serial_ports.html
-/doc/asio/overview/signals.html
-/doc/asio/overview/ssl.html
-/doc/asio/overview/timers.html
-/doc/asio/overview/windows/
-/doc/asio/overview/windows.html
-/doc/asio/overview/windows/object_handle.html
-/doc/asio/overview/windows/random_access_handle.html
-/doc/asio/overview/windows/stream_handle.html
-/doc/asio.png
-/doc/asio/reference/
-/doc/asio/reference/AcceptableProtocol.html
-/doc/asio/reference/AcceptHandler.html
-/doc/asio/reference/AcceptToken.html
-/doc/asio/reference/allocator_binder/
-/doc/asio/reference/allocator_binder/allocator_binder/
-/doc/asio/reference/allocator_binder/_allocator_binder.html
-/doc/asio/reference/allocator_binder/allocator_binder.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload1.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload2.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload3.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload4.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload5.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload6.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload7.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload8.html
-/doc/asio/reference/allocator_binder/allocator_binder/overload9.html
-/doc/asio/reference/allocator_binder/allocator_type.html
-/doc/asio/reference/allocator_binder/argument_type.html
-/doc/asio/reference/allocator_binder/first_argument_type.html
-/doc/asio/reference/allocator_binder/get/
-/doc/asio/reference/allocator_binder/get_allocator.html
-/doc/asio/reference/allocator_binder/get.html
-/doc/asio/reference/allocator_binder/get/overload1.html
-/doc/asio/reference/allocator_binder/get/overload2.html
-/doc/asio/reference/allocator_binder.html
-/doc/asio/reference/allocator_binder/operator_lp__rp_/
-/doc/asio/reference/allocator_binder/operator_lp__rp_.html
-/doc/asio/reference/allocator_binder/operator_lp__rp_/overload1.html
-/doc/asio/reference/allocator_binder/operator_lp__rp_/overload2.html
-/doc/asio/reference/allocator_binder/result_type.html
-/doc/asio/reference/allocator_binder/second_argument_type.html
-/doc/asio/reference/allocator_binder/target_type.html
-/doc/asio/reference/any_completion_executor/
-/doc/asio/reference/any_completion_executor/any_completion_executor/
-/doc/asio/reference/any_completion_executor/_any_completion_executor.html
-/doc/asio/reference/any_completion_executor/any_completion_executor.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload10.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload1.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload2.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload3.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload4.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload5.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload6.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload7.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload8.html
-/doc/asio/reference/any_completion_executor/any_completion_executor/overload9.html
-/doc/asio/reference/any_completion_executor/context.html
-/doc/asio/reference/any_completion_executor/execute.html
-/doc/asio/reference/any_completion_executor.html
-/doc/asio/reference/any_completion_executor/operator_bool.html
-/doc/asio/reference/any_completion_executor/operator_eq_/
-/doc/asio/reference/any_completion_executor/operator_eq__eq_/
-/doc/asio/reference/any_completion_executor/operator_eq__eq_.html
-/doc/asio/reference/any_completion_executor/operator_eq__eq_/overload1.html
-/doc/asio/reference/any_completion_executor/operator_eq__eq_/overload2.html
-/doc/asio/reference/any_completion_executor/operator_eq__eq_/overload3.html
-/doc/asio/reference/any_completion_executor/operator_eq_.html
-/doc/asio/reference/any_completion_executor/operator_eq_/overload1.html
-/doc/asio/reference/any_completion_executor/operator_eq_/overload2.html
-/doc/asio/reference/any_completion_executor/operator_eq_/overload3.html
-/doc/asio/reference/any_completion_executor/operator_not__eq_/
-/doc/asio/reference/any_completion_executor/operator_not__eq_.html
-/doc/asio/reference/any_completion_executor/operator_not__eq_/overload1.html
-/doc/asio/reference/any_completion_executor/operator_not__eq_/overload2.html
-/doc/asio/reference/any_completion_executor/operator_not__eq_/overload3.html
-/doc/asio/reference/any_completion_executor/prefer/
-/doc/asio/reference/any_completion_executor/prefer.html
-/doc/asio/reference/any_completion_executor/prefer/overload1.html
-/doc/asio/reference/any_completion_executor/prefer/overload2.html
-/doc/asio/reference/any_completion_executor/prefer/overload3.html
-/doc/asio/reference/any_completion_executor/prefer/overload4.html
-/doc/asio/reference/any_completion_executor/prefer/overload5.html
-/doc/asio/reference/any_completion_executor/prefer/overload6.html
-/doc/asio/reference/any_completion_executor/query.html
-/doc/asio/reference/any_completion_executor/require/
-/doc/asio/reference/any_completion_executor/require.html
-/doc/asio/reference/any_completion_executor/require/overload1.html
-/doc/asio/reference/any_completion_executor/require/overload2.html
-/doc/asio/reference/any_completion_executor/swap/
-/doc/asio/reference/any_completion_executor/swap.html
-/doc/asio/reference/any_completion_executor/swap/overload1.html
-/doc/asio/reference/any_completion_executor/swap/overload2.html
-/doc/asio/reference/any_completion_executor/target/
-/doc/asio/reference/any_completion_executor/target.html
-/doc/asio/reference/any_completion_executor/target/overload1.html
-/doc/asio/reference/any_completion_executor/target/overload2.html
-/doc/asio/reference/any_completion_executor/target_type.html
-/doc/asio/reference/any_completion_handler/
-/doc/asio/reference/any_completion_handler_allocator/
-/doc/asio/reference/any_completion_handler_allocator/allocate.html
-/doc/asio/reference/any_completion_handler_allocator/any_completion_handler_allocator.html
-/doc/asio/reference/any_completion_handler_allocator/deallocate.html
-/doc/asio/reference/any_completion_handler_allocator.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/any_completion_handler_allocator.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/operator_eq__eq_.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/operator_not__eq_.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind/
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind/other.html
-/doc/asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/value_type.html
-/doc/asio/reference/any_completion_handler_allocator/operator_eq__eq_.html
-/doc/asio/reference/any_completion_handler_allocator/operator_not__eq_.html
-/doc/asio/reference/any_completion_handler_allocator__rebind/
-/doc/asio/reference/any_completion_handler_allocator__rebind.html
-/doc/asio/reference/any_completion_handler_allocator__rebind/other.html
-/doc/asio/reference/any_completion_handler/allocator_type.html
-/doc/asio/reference/any_completion_handler_allocator/value_type.html
-/doc/asio/reference/any_completion_handler/any_completion_handler/
-/doc/asio/reference/any_completion_handler/_any_completion_handler.html
-/doc/asio/reference/any_completion_handler/any_completion_handler.html
-/doc/asio/reference/any_completion_handler/any_completion_handler/overload1.html
-/doc/asio/reference/any_completion_handler/any_completion_handler/overload2.html
-/doc/asio/reference/any_completion_handler/any_completion_handler/overload3.html
-/doc/asio/reference/any_completion_handler/any_completion_handler/overload4.html
-/doc/asio/reference/any_completion_handler/cancellation_slot_type.html
-/doc/asio/reference/any_completion_handler/get_allocator.html
-/doc/asio/reference/any_completion_handler/get_cancellation_slot.html
-/doc/asio/reference/any_completion_handler.html
-/doc/asio/reference/any_completion_handler/operator_bool.html
-/doc/asio/reference/any_completion_handler/operator_eq_/
-/doc/asio/reference/any_completion_handler/operator_eq__eq_/
-/doc/asio/reference/any_completion_handler/operator_eq__eq_.html
-/doc/asio/reference/any_completion_handler/operator_eq__eq_/overload1.html
-/doc/asio/reference/any_completion_handler/operator_eq__eq_/overload2.html
-/doc/asio/reference/any_completion_handler/operator_eq_.html
-/doc/asio/reference/any_completion_handler/operator_eq_/overload1.html
-/doc/asio/reference/any_completion_handler/operator_eq_/overload2.html
-/doc/asio/reference/any_completion_handler/operator_lp__rp_.html
-/doc/asio/reference/any_completion_handler/operator_not__eq_/
-/doc/asio/reference/any_completion_handler/operator_not__eq_.html
-/doc/asio/reference/any_completion_handler/operator_not__eq_/overload1.html
-/doc/asio/reference/any_completion_handler/operator_not__eq_/overload2.html
-/doc/asio/reference/any_completion_handler/operator_not_.html
-/doc/asio/reference/any_completion_handler/swap.html
-/doc/asio/reference/any_io_executor/
-/doc/asio/reference/any_io_executor/any_io_executor/
-/doc/asio/reference/any_io_executor/_any_io_executor.html
-/doc/asio/reference/any_io_executor/any_io_executor.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload10.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload1.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload2.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload3.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload4.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload5.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload6.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload7.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload8.html
-/doc/asio/reference/any_io_executor/any_io_executor/overload9.html
-/doc/asio/reference/any_io_executor/context.html
-/doc/asio/reference/any_io_executor/execute.html
-/doc/asio/reference/any_io_executor.html
-/doc/asio/reference/any_io_executor/operator_bool.html
-/doc/asio/reference/any_io_executor/operator_eq_/
-/doc/asio/reference/any_io_executor/operator_eq__eq_/
-/doc/asio/reference/any_io_executor/operator_eq__eq_.html
-/doc/asio/reference/any_io_executor/operator_eq__eq_/overload1.html
-/doc/asio/reference/any_io_executor/operator_eq__eq_/overload2.html
-/doc/asio/reference/any_io_executor/operator_eq__eq_/overload3.html
-/doc/asio/reference/any_io_executor/operator_eq_.html
-/doc/asio/reference/any_io_executor/operator_eq_/overload1.html
-/doc/asio/reference/any_io_executor/operator_eq_/overload2.html
-/doc/asio/reference/any_io_executor/operator_eq_/overload3.html
-/doc/asio/reference/any_io_executor/operator_not__eq_/
-/doc/asio/reference/any_io_executor/operator_not__eq_.html
-/doc/asio/reference/any_io_executor/operator_not__eq_/overload1.html
-/doc/asio/reference/any_io_executor/operator_not__eq_/overload2.html
-/doc/asio/reference/any_io_executor/operator_not__eq_/overload3.html
-/doc/asio/reference/any_io_executor/prefer/
-/doc/asio/reference/any_io_executor/prefer.html
-/doc/asio/reference/any_io_executor/prefer/overload1.html
-/doc/asio/reference/any_io_executor/prefer/overload2.html
-/doc/asio/reference/any_io_executor/prefer/overload3.html
-/doc/asio/reference/any_io_executor/prefer/overload4.html
-/doc/asio/reference/any_io_executor/prefer/overload5.html
-/doc/asio/reference/any_io_executor/prefer/overload6.html
-/doc/asio/reference/any_io_executor/prefer/overload7.html
-/doc/asio/reference/any_io_executor/query.html
-/doc/asio/reference/any_io_executor/require/
-/doc/asio/reference/any_io_executor/require.html
-/doc/asio/reference/any_io_executor/require/overload1.html
-/doc/asio/reference/any_io_executor/require/overload2.html
-/doc/asio/reference/any_io_executor/require/overload3.html
-/doc/asio/reference/any_io_executor/swap/
-/doc/asio/reference/any_io_executor/swap.html
-/doc/asio/reference/any_io_executor/swap/overload1.html
-/doc/asio/reference/any_io_executor/swap/overload2.html
-/doc/asio/reference/any_io_executor/target/
-/doc/asio/reference/any_io_executor/target.html
-/doc/asio/reference/any_io_executor/target/overload1.html
-/doc/asio/reference/any_io_executor/target/overload2.html
-/doc/asio/reference/any_io_executor/target_type.html
-/doc/asio/reference/append.html
-/doc/asio/reference/append_t/
-/doc/asio/reference/append_t/append_t.html
-/doc/asio/reference/append_t.html
-/doc/asio/reference/append_t/token_.html
-/doc/asio/reference/append_t/values_.html
-/doc/asio/reference/asio_handler_is_continuation.html
-/doc/asio/reference/associated_allocator/
-/doc/asio/reference/associated_allocator/get/
-/doc/asio/reference/associated_allocator/get.html
-/doc/asio/reference/associated_allocator/get/overload1.html
-/doc/asio/reference/associated_allocator/get/overload2.html
-/doc/asio/reference/associated_allocator.html
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get.html
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/overload1.html
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/overload2.html
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.html
-/doc/asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/type.html
-/doc/asio/reference/associated_allocator_t.html
-/doc/asio/reference/associated_allocator/type.html
-/doc/asio/reference/associated_cancellation_slot/
-/doc/asio/reference/associated_cancellation_slot/get/
-/doc/asio/reference/associated_cancellation_slot/get.html
-/doc/asio/reference/associated_cancellation_slot/get/overload1.html
-/doc/asio/reference/associated_cancellation_slot/get/overload2.html
-/doc/asio/reference/associated_cancellation_slot.html
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get.html
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/overload1.html
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/overload2.html
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.html
-/doc/asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/type.html
-/doc/asio/reference/associated_cancellation_slot_t.html
-/doc/asio/reference/associated_cancellation_slot/type.html
-/doc/asio/reference/associated_executor/
-/doc/asio/reference/associated_executor/get/
-/doc/asio/reference/associated_executor/get.html
-/doc/asio/reference/associated_executor/get/overload1.html
-/doc/asio/reference/associated_executor/get/overload2.html
-/doc/asio/reference/associated_executor.html
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get.html
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/overload1.html
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/overload2.html
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.html
-/doc/asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/type.html
-/doc/asio/reference/associated_executor_t.html
-/doc/asio/reference/associated_executor/type.html
-/doc/asio/reference/associated_immediate_executor/
-/doc/asio/reference/associated_immediate_executor/get.html
-/doc/asio/reference/associated_immediate_executor.html
-/doc/asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/
-/doc/asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get.html
-/doc/asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.html
-/doc/asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/type.html
-/doc/asio/reference/associated_immediate_executor_t.html
-/doc/asio/reference/associated_immediate_executor/type.html
-/doc/asio/reference/associator.html
-/doc/asio/reference/as_tuple.html
-/doc/asio/reference/as_tuple_t/
-/doc/asio/reference/as_tuple_t/as_default_on.html
-/doc/asio/reference/as_tuple_t/as_default_on_t.html
-/doc/asio/reference/as_tuple_t/as_tuple_t/
-/doc/asio/reference/as_tuple_t/as_tuple_t.html
-/doc/asio/reference/as_tuple_t/as_tuple_t/overload1.html
-/doc/asio/reference/as_tuple_t/as_tuple_t/overload2.html
-/doc/asio/reference/as_tuple_t__default_constructor_tag.html
-/doc/asio/reference/as_tuple_t__executor_with_default/
-/doc/asio/reference/as_tuple_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/as_tuple_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/as_tuple_t__executor_with_default.html
-/doc/asio/reference/as_tuple_t.html
-/doc/asio/reference/as_tuple_t/token_.html
-/doc/asio/reference/async_completion/
-/doc/asio/reference/async_completion/async_completion.html
-/doc/asio/reference/async_completion/completion_handler.html
-/doc/asio/reference/async_completion/completion_handler_type.html
-/doc/asio/reference/async_completion.html
-/doc/asio/reference/async_completion/result.html
-/doc/asio/reference/async_compose.html
-/doc/asio/reference/async_connect/
-/doc/asio/reference/async_connect.html
-/doc/asio/reference/async_connect/overload1.html
-/doc/asio/reference/async_connect/overload2.html
-/doc/asio/reference/async_connect/overload3.html
-/doc/asio/reference/async_connect/overload4.html
-/doc/asio/reference/async_connect/overload5.html
-/doc/asio/reference/async_connect/overload6.html
-/doc/asio/reference/asynchronous_operations.html
-/doc/asio/reference/asynchronous_socket_operations.html
-/doc/asio/reference/async_immediate/
-/doc/asio/reference/async_immediate.html
-/doc/asio/reference/async_immediate/overload1.html
-/doc/asio/reference/async_immediate/overload2.html
-/doc/asio/reference/async_initiate.html
-/doc/asio/reference/AsyncRandomAccessReadDevice.html
-/doc/asio/reference/AsyncRandomAccessWriteDevice.html
-/doc/asio/reference/async_read/
-/doc/asio/reference/async_read_at/
-/doc/asio/reference/async_read_at.html
-/doc/asio/reference/async_read_at/overload1.html
-/doc/asio/reference/async_read_at/overload2.html
-/doc/asio/reference/async_read_at/overload3.html
-/doc/asio/reference/async_read_at/overload4.html
-/doc/asio/reference/async_read.html
-/doc/asio/reference/async_read/overload1.html
-/doc/asio/reference/async_read/overload2.html
-/doc/asio/reference/async_read/overload3.html
-/doc/asio/reference/async_read/overload4.html
-/doc/asio/reference/async_read/overload5.html
-/doc/asio/reference/async_read/overload6.html
-/doc/asio/reference/async_read/overload7.html
-/doc/asio/reference/async_read/overload8.html
-/doc/asio/reference/AsyncReadStream.html
-/doc/asio/reference/async_read_until/
-/doc/asio/reference/async_read_until.html
-/doc/asio/reference/async_read_until/overload10.html
-/doc/asio/reference/async_read_until/overload11.html
-/doc/asio/reference/async_read_until/overload12.html
-/doc/asio/reference/async_read_until/overload1.html
-/doc/asio/reference/async_read_until/overload2.html
-/doc/asio/reference/async_read_until/overload3.html
-/doc/asio/reference/async_read_until/overload4.html
-/doc/asio/reference/async_read_until/overload5.html
-/doc/asio/reference/async_read_until/overload6.html
-/doc/asio/reference/async_read_until/overload7.html
-/doc/asio/reference/async_read_until/overload8.html
-/doc/asio/reference/async_read_until/overload9.html
-/doc/asio/reference/async_result/
-/doc/asio/reference/async_result/async_result.html
-/doc/asio/reference/async_result/completion_handler_type.html
-/doc/asio/reference/async_result/get.html
-/doc/asio/reference/async_result.html
-/doc/asio/reference/async_result/initiate.html
-/doc/asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/
-/doc/asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/handler_type.html
-/doc/asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.html
-/doc/asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/initiate.html
-/doc/asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/return_type.html
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/async_result.html
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/completion_handler_type.html
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/get.html
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.html
-/doc/asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/return_type.html
-/doc/asio/reference/async_result/return_type.html
-/doc/asio/reference/async_write/
-/doc/asio/reference/async_write_at/
-/doc/asio/reference/async_write_at.html
-/doc/asio/reference/async_write_at/overload1.html
-/doc/asio/reference/async_write_at/overload2.html
-/doc/asio/reference/async_write_at/overload3.html
-/doc/asio/reference/async_write_at/overload4.html
-/doc/asio/reference/async_write.html
-/doc/asio/reference/async_write/overload1.html
-/doc/asio/reference/async_write/overload2.html
-/doc/asio/reference/async_write/overload3.html
-/doc/asio/reference/async_write/overload4.html
-/doc/asio/reference/async_write/overload5.html
-/doc/asio/reference/async_write/overload6.html
-/doc/asio/reference/async_write/overload7.html
-/doc/asio/reference/async_write/overload8.html
-/doc/asio/reference/AsyncWriteStream.html
-/doc/asio/reference/awaitable/
-/doc/asio/reference/awaitable/awaitable/
-/doc/asio/reference/awaitable/_awaitable.html
-/doc/asio/reference/awaitable/awaitable.html
-/doc/asio/reference/awaitable/awaitable/overload1.html
-/doc/asio/reference/awaitable/awaitable/overload2.html
-/doc/asio/reference/awaitable/executor_type.html
-/doc/asio/reference/awaitable.html
-/doc/asio/reference/awaitable/operator_eq_.html
-/doc/asio/reference/awaitable/valid.html
-/doc/asio/reference/awaitable/value_type.html
-/doc/asio/reference/bad_executor/
-/doc/asio/reference/bad_executor/bad_executor.html
-/doc/asio/reference/bad_executor.html
-/doc/asio/reference/bad_executor/what.html
-/doc/asio/reference/basic_datagram_socket/
-/doc/asio/reference/basic_datagram_socket/assign/
-/doc/asio/reference/basic_datagram_socket/assign.html
-/doc/asio/reference/basic_datagram_socket/assign/overload1.html
-/doc/asio/reference/basic_datagram_socket/assign/overload2.html
-/doc/asio/reference/basic_datagram_socket/async_connect.html
-/doc/asio/reference/basic_datagram_socket/async_receive/
-/doc/asio/reference/basic_datagram_socket/async_receive_from/
-/doc/asio/reference/basic_datagram_socket/async_receive_from.html
-/doc/asio/reference/basic_datagram_socket/async_receive_from/overload1.html
-/doc/asio/reference/basic_datagram_socket/async_receive_from/overload2.html
-/doc/asio/reference/basic_datagram_socket/async_receive.html
-/doc/asio/reference/basic_datagram_socket/async_receive/overload1.html
-/doc/asio/reference/basic_datagram_socket/async_receive/overload2.html
-/doc/asio/reference/basic_datagram_socket/async_send/
-/doc/asio/reference/basic_datagram_socket/async_send.html
-/doc/asio/reference/basic_datagram_socket/async_send/overload1.html
-/doc/asio/reference/basic_datagram_socket/async_send/overload2.html
-/doc/asio/reference/basic_datagram_socket/async_send_to/
-/doc/asio/reference/basic_datagram_socket/async_send_to.html
-/doc/asio/reference/basic_datagram_socket/async_send_to/overload1.html
-/doc/asio/reference/basic_datagram_socket/async_send_to/overload2.html
-/doc/asio/reference/basic_datagram_socket/async_wait.html
-/doc/asio/reference/basic_datagram_socket/at_mark/
-/doc/asio/reference/basic_datagram_socket/at_mark.html
-/doc/asio/reference/basic_datagram_socket/at_mark/overload1.html
-/doc/asio/reference/basic_datagram_socket/at_mark/overload2.html
-/doc/asio/reference/basic_datagram_socket/available/
-/doc/asio/reference/basic_datagram_socket/available.html
-/doc/asio/reference/basic_datagram_socket/available/overload1.html
-/doc/asio/reference/basic_datagram_socket/available/overload2.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/
-/doc/asio/reference/basic_datagram_socket/_basic_datagram_socket.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload10.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload1.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload2.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload3.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload4.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload5.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload6.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload7.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload8.html
-/doc/asio/reference/basic_datagram_socket/basic_datagram_socket/overload9.html
-/doc/asio/reference/basic_datagram_socket/bind/
-/doc/asio/reference/basic_datagram_socket/bind.html
-/doc/asio/reference/basic_datagram_socket/bind/overload1.html
-/doc/asio/reference/basic_datagram_socket/bind/overload2.html
-/doc/asio/reference/basic_datagram_socket/broadcast.html
-/doc/asio/reference/basic_datagram_socket/bytes_readable.html
-/doc/asio/reference/basic_datagram_socket/cancel/
-/doc/asio/reference/basic_datagram_socket/cancel.html
-/doc/asio/reference/basic_datagram_socket/cancel/overload1.html
-/doc/asio/reference/basic_datagram_socket/cancel/overload2.html
-/doc/asio/reference/basic_datagram_socket/close/
-/doc/asio/reference/basic_datagram_socket/close.html
-/doc/asio/reference/basic_datagram_socket/close/overload1.html
-/doc/asio/reference/basic_datagram_socket/close/overload2.html
-/doc/asio/reference/basic_datagram_socket/connect/
-/doc/asio/reference/basic_datagram_socket/connect.html
-/doc/asio/reference/basic_datagram_socket/connect/overload1.html
-/doc/asio/reference/basic_datagram_socket/connect/overload2.html
-/doc/asio/reference/basic_datagram_socket/debug.html
-/doc/asio/reference/basic_datagram_socket/do_not_route.html
-/doc/asio/reference/basic_datagram_socket/enable_connection_aborted.html
-/doc/asio/reference/basic_datagram_socket/endpoint_type.html
-/doc/asio/reference/basic_datagram_socket/executor_type.html
-/doc/asio/reference/basic_datagram_socket/get_executor.html
-/doc/asio/reference/basic_datagram_socket/get_option/
-/doc/asio/reference/basic_datagram_socket/get_option.html
-/doc/asio/reference/basic_datagram_socket/get_option/overload1.html
-/doc/asio/reference/basic_datagram_socket/get_option/overload2.html
-/doc/asio/reference/basic_datagram_socket.html
-/doc/asio/reference/basic_datagram_socket/io_control/
-/doc/asio/reference/basic_datagram_socket/io_control.html
-/doc/asio/reference/basic_datagram_socket/io_control/overload1.html
-/doc/asio/reference/basic_datagram_socket/io_control/overload2.html
-/doc/asio/reference/basic_datagram_socket/is_open.html
-/doc/asio/reference/basic_datagram_socket/keep_alive.html
-/doc/asio/reference/basic_datagram_socket/linger.html
-/doc/asio/reference/basic_datagram_socket/local_endpoint/
-/doc/asio/reference/basic_datagram_socket/local_endpoint.html
-/doc/asio/reference/basic_datagram_socket/local_endpoint/overload1.html
-/doc/asio/reference/basic_datagram_socket/local_endpoint/overload2.html
-/doc/asio/reference/basic_datagram_socket/lowest_layer/
-/doc/asio/reference/basic_datagram_socket/lowest_layer.html
-/doc/asio/reference/basic_datagram_socket/lowest_layer/overload1.html
-/doc/asio/reference/basic_datagram_socket/lowest_layer/overload2.html
-/doc/asio/reference/basic_datagram_socket/lowest_layer_type.html
-/doc/asio/reference/basic_datagram_socket/max_connections.html
-/doc/asio/reference/basic_datagram_socket/max_listen_connections.html
-/doc/asio/reference/basic_datagram_socket/message_do_not_route.html
-/doc/asio/reference/basic_datagram_socket/message_end_of_record.html
-/doc/asio/reference/basic_datagram_socket/message_flags.html
-/doc/asio/reference/basic_datagram_socket/message_out_of_band.html
-/doc/asio/reference/basic_datagram_socket/message_peek.html
-/doc/asio/reference/basic_datagram_socket/native_handle.html
-/doc/asio/reference/basic_datagram_socket/native_handle_type.html
-/doc/asio/reference/basic_datagram_socket/native_non_blocking/
-/doc/asio/reference/basic_datagram_socket/native_non_blocking.html
-/doc/asio/reference/basic_datagram_socket/native_non_blocking/overload1.html
-/doc/asio/reference/basic_datagram_socket/native_non_blocking/overload2.html
-/doc/asio/reference/basic_datagram_socket/native_non_blocking/overload3.html
-/doc/asio/reference/basic_datagram_socket/non_blocking/
-/doc/asio/reference/basic_datagram_socket/non_blocking.html
-/doc/asio/reference/basic_datagram_socket/non_blocking/overload1.html
-/doc/asio/reference/basic_datagram_socket/non_blocking/overload2.html
-/doc/asio/reference/basic_datagram_socket/non_blocking/overload3.html
-/doc/asio/reference/basic_datagram_socket/open/
-/doc/asio/reference/basic_datagram_socket/open.html
-/doc/asio/reference/basic_datagram_socket/open/overload1.html
-/doc/asio/reference/basic_datagram_socket/open/overload2.html
-/doc/asio/reference/basic_datagram_socket/operator_eq_/
-/doc/asio/reference/basic_datagram_socket/operator_eq_.html
-/doc/asio/reference/basic_datagram_socket/operator_eq_/overload1.html
-/doc/asio/reference/basic_datagram_socket/operator_eq_/overload2.html
-/doc/asio/reference/basic_datagram_socket/out_of_band_inline.html
-/doc/asio/reference/basic_datagram_socket/protocol_type.html
-/doc/asio/reference/basic_datagram_socket__rebind_executor/
-/doc/asio/reference/basic_datagram_socket__rebind_executor.html
-/doc/asio/reference/basic_datagram_socket__rebind_executor/other.html
-/doc/asio/reference/basic_datagram_socket/receive/
-/doc/asio/reference/basic_datagram_socket/receive_buffer_size.html
-/doc/asio/reference/basic_datagram_socket/receive_from/
-/doc/asio/reference/basic_datagram_socket/receive_from.html
-/doc/asio/reference/basic_datagram_socket/receive_from/overload1.html
-/doc/asio/reference/basic_datagram_socket/receive_from/overload2.html
-/doc/asio/reference/basic_datagram_socket/receive_from/overload3.html
-/doc/asio/reference/basic_datagram_socket/receive.html
-/doc/asio/reference/basic_datagram_socket/receive_low_watermark.html
-/doc/asio/reference/basic_datagram_socket/receive/overload1.html
-/doc/asio/reference/basic_datagram_socket/receive/overload2.html
-/doc/asio/reference/basic_datagram_socket/receive/overload3.html
-/doc/asio/reference/basic_datagram_socket/release/
-/doc/asio/reference/basic_datagram_socket/release.html
-/doc/asio/reference/basic_datagram_socket/release/overload1.html
-/doc/asio/reference/basic_datagram_socket/release/overload2.html
-/doc/asio/reference/basic_datagram_socket/remote_endpoint/
-/doc/asio/reference/basic_datagram_socket/remote_endpoint.html
-/doc/asio/reference/basic_datagram_socket/remote_endpoint/overload1.html
-/doc/asio/reference/basic_datagram_socket/remote_endpoint/overload2.html
-/doc/asio/reference/basic_datagram_socket/reuse_address.html
-/doc/asio/reference/basic_datagram_socket/send/
-/doc/asio/reference/basic_datagram_socket/send_buffer_size.html
-/doc/asio/reference/basic_datagram_socket/send.html
-/doc/asio/reference/basic_datagram_socket/send_low_watermark.html
-/doc/asio/reference/basic_datagram_socket/send/overload1.html
-/doc/asio/reference/basic_datagram_socket/send/overload2.html
-/doc/asio/reference/basic_datagram_socket/send/overload3.html
-/doc/asio/reference/basic_datagram_socket/send_to/
-/doc/asio/reference/basic_datagram_socket/send_to.html
-/doc/asio/reference/basic_datagram_socket/send_to/overload1.html
-/doc/asio/reference/basic_datagram_socket/send_to/overload2.html
-/doc/asio/reference/basic_datagram_socket/send_to/overload3.html
-/doc/asio/reference/basic_datagram_socket/set_option/
-/doc/asio/reference/basic_datagram_socket/set_option.html
-/doc/asio/reference/basic_datagram_socket/set_option/overload1.html
-/doc/asio/reference/basic_datagram_socket/set_option/overload2.html
-/doc/asio/reference/basic_datagram_socket/shutdown/
-/doc/asio/reference/basic_datagram_socket/shutdown.html
-/doc/asio/reference/basic_datagram_socket/shutdown/overload1.html
-/doc/asio/reference/basic_datagram_socket/shutdown/overload2.html
-/doc/asio/reference/basic_datagram_socket/shutdown_type.html
-/doc/asio/reference/basic_datagram_socket/wait/
-/doc/asio/reference/basic_datagram_socket/wait.html
-/doc/asio/reference/basic_datagram_socket/wait/overload1.html
-/doc/asio/reference/basic_datagram_socket/wait/overload2.html
-/doc/asio/reference/basic_datagram_socket/wait_type.html
-/doc/asio/reference/basic_deadline_timer/
-/doc/asio/reference/basic_deadline_timer/async_wait.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/
-/doc/asio/reference/basic_deadline_timer/_basic_deadline_timer.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload1.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload2.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload3.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload4.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload5.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload6.html
-/doc/asio/reference/basic_deadline_timer/basic_deadline_timer/overload7.html
-/doc/asio/reference/basic_deadline_timer/cancel/
-/doc/asio/reference/basic_deadline_timer/cancel.html
-/doc/asio/reference/basic_deadline_timer/cancel_one/
-/doc/asio/reference/basic_deadline_timer/cancel_one.html
-/doc/asio/reference/basic_deadline_timer/cancel_one/overload1.html
-/doc/asio/reference/basic_deadline_timer/cancel_one/overload2.html
-/doc/asio/reference/basic_deadline_timer/cancel/overload1.html
-/doc/asio/reference/basic_deadline_timer/cancel/overload2.html
-/doc/asio/reference/basic_deadline_timer/duration_type.html
-/doc/asio/reference/basic_deadline_timer/executor_type.html
-/doc/asio/reference/basic_deadline_timer/expires_at/
-/doc/asio/reference/basic_deadline_timer/expires_at.html
-/doc/asio/reference/basic_deadline_timer/expires_at/overload1.html
-/doc/asio/reference/basic_deadline_timer/expires_at/overload2.html
-/doc/asio/reference/basic_deadline_timer/expires_at/overload3.html
-/doc/asio/reference/basic_deadline_timer/expires_from_now/
-/doc/asio/reference/basic_deadline_timer/expires_from_now.html
-/doc/asio/reference/basic_deadline_timer/expires_from_now/overload1.html
-/doc/asio/reference/basic_deadline_timer/expires_from_now/overload2.html
-/doc/asio/reference/basic_deadline_timer/expires_from_now/overload3.html
-/doc/asio/reference/basic_deadline_timer/get_executor.html
-/doc/asio/reference/basic_deadline_timer.html
-/doc/asio/reference/basic_deadline_timer/operator_eq_.html
-/doc/asio/reference/basic_deadline_timer__rebind_executor/
-/doc/asio/reference/basic_deadline_timer__rebind_executor.html
-/doc/asio/reference/basic_deadline_timer__rebind_executor/other.html
-/doc/asio/reference/basic_deadline_timer/time_type.html
-/doc/asio/reference/basic_deadline_timer/traits_type.html
-/doc/asio/reference/basic_deadline_timer/wait/
-/doc/asio/reference/basic_deadline_timer/wait.html
-/doc/asio/reference/basic_deadline_timer/wait/overload1.html
-/doc/asio/reference/basic_deadline_timer/wait/overload2.html
-/doc/asio/reference/basic_file/
-/doc/asio/reference/basic_file/append.html
-/doc/asio/reference/basic_file/assign/
-/doc/asio/reference/basic_file/assign.html
-/doc/asio/reference/basic_file/assign/overload1.html
-/doc/asio/reference/basic_file/assign/overload2.html
-/doc/asio/reference/basic_file/basic_file/
-/doc/asio/reference/basic_file/_basic_file.html
-/doc/asio/reference/basic_file/basic_file.html
-/doc/asio/reference/basic_file/basic_file/overload10.html
-/doc/asio/reference/basic_file/basic_file/overload1.html
-/doc/asio/reference/basic_file/basic_file/overload2.html
-/doc/asio/reference/basic_file/basic_file/overload3.html
-/doc/asio/reference/basic_file/basic_file/overload4.html
-/doc/asio/reference/basic_file/basic_file/overload5.html
-/doc/asio/reference/basic_file/basic_file/overload6.html
-/doc/asio/reference/basic_file/basic_file/overload7.html
-/doc/asio/reference/basic_file/basic_file/overload8.html
-/doc/asio/reference/basic_file/basic_file/overload9.html
-/doc/asio/reference/basic_file/cancel/
-/doc/asio/reference/basic_file/cancel.html
-/doc/asio/reference/basic_file/cancel/overload1.html
-/doc/asio/reference/basic_file/cancel/overload2.html
-/doc/asio/reference/basic_file/close/
-/doc/asio/reference/basic_file/close.html
-/doc/asio/reference/basic_file/close/overload1.html
-/doc/asio/reference/basic_file/close/overload2.html
-/doc/asio/reference/basic_file/create.html
-/doc/asio/reference/basic_file/exclusive.html
-/doc/asio/reference/basic_file/executor_type.html
-/doc/asio/reference/basic_file/flags.html
-/doc/asio/reference/basic_file/get_executor.html
-/doc/asio/reference/basic_file.html
-/doc/asio/reference/basic_file/is_open.html
-/doc/asio/reference/basic_file/native_handle.html
-/doc/asio/reference/basic_file/native_handle_type.html
-/doc/asio/reference/basic_file/open/
-/doc/asio/reference/basic_file/open.html
-/doc/asio/reference/basic_file/open/overload1.html
-/doc/asio/reference/basic_file/open/overload2.html
-/doc/asio/reference/basic_file/open/overload3.html
-/doc/asio/reference/basic_file/open/overload4.html
-/doc/asio/reference/basic_file/operator_eq_/
-/doc/asio/reference/basic_file/operator_eq_.html
-/doc/asio/reference/basic_file/operator_eq_/overload1.html
-/doc/asio/reference/basic_file/operator_eq_/overload2.html
-/doc/asio/reference/basic_file/read_only.html
-/doc/asio/reference/basic_file/read_write.html
-/doc/asio/reference/basic_file__rebind_executor/
-/doc/asio/reference/basic_file__rebind_executor.html
-/doc/asio/reference/basic_file__rebind_executor/other.html
-/doc/asio/reference/basic_file/release/
-/doc/asio/reference/basic_file/release.html
-/doc/asio/reference/basic_file/release/overload1.html
-/doc/asio/reference/basic_file/release/overload2.html
-/doc/asio/reference/basic_file/resize/
-/doc/asio/reference/basic_file/resize.html
-/doc/asio/reference/basic_file/resize/overload1.html
-/doc/asio/reference/basic_file/resize/overload2.html
-/doc/asio/reference/basic_file/seek_basis.html
-/doc/asio/reference/basic_file/size/
-/doc/asio/reference/basic_file/size.html
-/doc/asio/reference/basic_file/size/overload1.html
-/doc/asio/reference/basic_file/size/overload2.html
-/doc/asio/reference/basic_file/sync_all/
-/doc/asio/reference/basic_file/sync_all.html
-/doc/asio/reference/basic_file/sync_all_on_write.html
-/doc/asio/reference/basic_file/sync_all/overload1.html
-/doc/asio/reference/basic_file/sync_all/overload2.html
-/doc/asio/reference/basic_file/sync_data/
-/doc/asio/reference/basic_file/sync_data.html
-/doc/asio/reference/basic_file/sync_data/overload1.html
-/doc/asio/reference/basic_file/sync_data/overload2.html
-/doc/asio/reference/basic_file/truncate.html
-/doc/asio/reference/basic_file/write_only.html
-/doc/asio/reference/basic_io_object/
-/doc/asio/reference/basic_io_object/basic_io_object/
-/doc/asio/reference/basic_io_object/_basic_io_object.html
-/doc/asio/reference/basic_io_object/basic_io_object.html
-/doc/asio/reference/basic_io_object/basic_io_object/overload1.html
-/doc/asio/reference/basic_io_object/basic_io_object/overload2.html
-/doc/asio/reference/basic_io_object/basic_io_object/overload3.html
-/doc/asio/reference/basic_io_object/executor_type.html
-/doc/asio/reference/basic_io_object/get_executor.html
-/doc/asio/reference/basic_io_object/get_implementation/
-/doc/asio/reference/basic_io_object/get_implementation.html
-/doc/asio/reference/basic_io_object/get_implementation/overload1.html
-/doc/asio/reference/basic_io_object/get_implementation/overload2.html
-/doc/asio/reference/basic_io_object/get_io_context.html
-/doc/asio/reference/basic_io_object/get_io_service.html
-/doc/asio/reference/basic_io_object/get_service/
-/doc/asio/reference/basic_io_object/get_service.html
-/doc/asio/reference/basic_io_object/get_service/overload1.html
-/doc/asio/reference/basic_io_object/get_service/overload2.html
-/doc/asio/reference/basic_io_object.html
-/doc/asio/reference/basic_io_object/implementation_type.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/_basic_io_object.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload1.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload2.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload3.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/executor_type.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_executor.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/overload1.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/overload2.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_io_context.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_io_service.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/overload1.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/overload2.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/implementation_type.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/operator_eq_.html
-/doc/asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/service_type.html
-/doc/asio/reference/basic_io_object/operator_eq_.html
-/doc/asio/reference/basic_io_object/service_type.html
-/doc/asio/reference/basic_random_access_file/
-/doc/asio/reference/basic_random_access_file/append.html
-/doc/asio/reference/basic_random_access_file/assign/
-/doc/asio/reference/basic_random_access_file/assign.html
-/doc/asio/reference/basic_random_access_file/assign/overload1.html
-/doc/asio/reference/basic_random_access_file/assign/overload2.html
-/doc/asio/reference/basic_random_access_file/async_read_some_at.html
-/doc/asio/reference/basic_random_access_file/async_write_some_at.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/
-/doc/asio/reference/basic_random_access_file/_basic_random_access_file.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload10.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload1.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload2.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload3.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload4.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload5.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload6.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload7.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload8.html
-/doc/asio/reference/basic_random_access_file/basic_random_access_file/overload9.html
-/doc/asio/reference/basic_random_access_file/cancel/
-/doc/asio/reference/basic_random_access_file/cancel.html
-/doc/asio/reference/basic_random_access_file/cancel/overload1.html
-/doc/asio/reference/basic_random_access_file/cancel/overload2.html
-/doc/asio/reference/basic_random_access_file/close/
-/doc/asio/reference/basic_random_access_file/close.html
-/doc/asio/reference/basic_random_access_file/close/overload1.html
-/doc/asio/reference/basic_random_access_file/close/overload2.html
-/doc/asio/reference/basic_random_access_file/create.html
-/doc/asio/reference/basic_random_access_file/exclusive.html
-/doc/asio/reference/basic_random_access_file/executor_type.html
-/doc/asio/reference/basic_random_access_file/flags.html
-/doc/asio/reference/basic_random_access_file/get_executor.html
-/doc/asio/reference/basic_random_access_file.html
-/doc/asio/reference/basic_random_access_file/is_open.html
-/doc/asio/reference/basic_random_access_file/native_handle.html
-/doc/asio/reference/basic_random_access_file/native_handle_type.html
-/doc/asio/reference/basic_random_access_file/open/
-/doc/asio/reference/basic_random_access_file/open.html
-/doc/asio/reference/basic_random_access_file/open/overload1.html
-/doc/asio/reference/basic_random_access_file/open/overload2.html
-/doc/asio/reference/basic_random_access_file/open/overload3.html
-/doc/asio/reference/basic_random_access_file/open/overload4.html
-/doc/asio/reference/basic_random_access_file/operator_eq_/
-/doc/asio/reference/basic_random_access_file/operator_eq_.html
-/doc/asio/reference/basic_random_access_file/operator_eq_/overload1.html
-/doc/asio/reference/basic_random_access_file/operator_eq_/overload2.html
-/doc/asio/reference/basic_random_access_file/read_only.html
-/doc/asio/reference/basic_random_access_file/read_some_at/
-/doc/asio/reference/basic_random_access_file/read_some_at.html
-/doc/asio/reference/basic_random_access_file/read_some_at/overload1.html
-/doc/asio/reference/basic_random_access_file/read_some_at/overload2.html
-/doc/asio/reference/basic_random_access_file/read_write.html
-/doc/asio/reference/basic_random_access_file__rebind_executor/
-/doc/asio/reference/basic_random_access_file__rebind_executor.html
-/doc/asio/reference/basic_random_access_file__rebind_executor/other.html
-/doc/asio/reference/basic_random_access_file/release/
-/doc/asio/reference/basic_random_access_file/release.html
-/doc/asio/reference/basic_random_access_file/release/overload1.html
-/doc/asio/reference/basic_random_access_file/release/overload2.html
-/doc/asio/reference/basic_random_access_file/resize/
-/doc/asio/reference/basic_random_access_file/resize.html
-/doc/asio/reference/basic_random_access_file/resize/overload1.html
-/doc/asio/reference/basic_random_access_file/resize/overload2.html
-/doc/asio/reference/basic_random_access_file/seek_basis.html
-/doc/asio/reference/basic_random_access_file/size/
-/doc/asio/reference/basic_random_access_file/size.html
-/doc/asio/reference/basic_random_access_file/size/overload1.html
-/doc/asio/reference/basic_random_access_file/size/overload2.html
-/doc/asio/reference/basic_random_access_file/sync_all/
-/doc/asio/reference/basic_random_access_file/sync_all.html
-/doc/asio/reference/basic_random_access_file/sync_all_on_write.html
-/doc/asio/reference/basic_random_access_file/sync_all/overload1.html
-/doc/asio/reference/basic_random_access_file/sync_all/overload2.html
-/doc/asio/reference/basic_random_access_file/sync_data/
-/doc/asio/reference/basic_random_access_file/sync_data.html
-/doc/asio/reference/basic_random_access_file/sync_data/overload1.html
-/doc/asio/reference/basic_random_access_file/sync_data/overload2.html
-/doc/asio/reference/basic_random_access_file/truncate.html
-/doc/asio/reference/basic_random_access_file/write_only.html
-/doc/asio/reference/basic_random_access_file/write_some_at/
-/doc/asio/reference/basic_random_access_file/write_some_at.html
-/doc/asio/reference/basic_random_access_file/write_some_at/overload1.html
-/doc/asio/reference/basic_random_access_file/write_some_at/overload2.html
-/doc/asio/reference/basic_raw_socket/
-/doc/asio/reference/basic_raw_socket/assign/
-/doc/asio/reference/basic_raw_socket/assign.html
-/doc/asio/reference/basic_raw_socket/assign/overload1.html
-/doc/asio/reference/basic_raw_socket/assign/overload2.html
-/doc/asio/reference/basic_raw_socket/async_connect.html
-/doc/asio/reference/basic_raw_socket/async_receive/
-/doc/asio/reference/basic_raw_socket/async_receive_from/
-/doc/asio/reference/basic_raw_socket/async_receive_from.html
-/doc/asio/reference/basic_raw_socket/async_receive_from/overload1.html
-/doc/asio/reference/basic_raw_socket/async_receive_from/overload2.html
-/doc/asio/reference/basic_raw_socket/async_receive.html
-/doc/asio/reference/basic_raw_socket/async_receive/overload1.html
-/doc/asio/reference/basic_raw_socket/async_receive/overload2.html
-/doc/asio/reference/basic_raw_socket/async_send/
-/doc/asio/reference/basic_raw_socket/async_send.html
-/doc/asio/reference/basic_raw_socket/async_send/overload1.html
-/doc/asio/reference/basic_raw_socket/async_send/overload2.html
-/doc/asio/reference/basic_raw_socket/async_send_to/
-/doc/asio/reference/basic_raw_socket/async_send_to.html
-/doc/asio/reference/basic_raw_socket/async_send_to/overload1.html
-/doc/asio/reference/basic_raw_socket/async_send_to/overload2.html
-/doc/asio/reference/basic_raw_socket/async_wait.html
-/doc/asio/reference/basic_raw_socket/at_mark/
-/doc/asio/reference/basic_raw_socket/at_mark.html
-/doc/asio/reference/basic_raw_socket/at_mark/overload1.html
-/doc/asio/reference/basic_raw_socket/at_mark/overload2.html
-/doc/asio/reference/basic_raw_socket/available/
-/doc/asio/reference/basic_raw_socket/available.html
-/doc/asio/reference/basic_raw_socket/available/overload1.html
-/doc/asio/reference/basic_raw_socket/available/overload2.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/
-/doc/asio/reference/basic_raw_socket/_basic_raw_socket.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload10.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload1.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload2.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload3.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload4.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload5.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload6.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload7.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload8.html
-/doc/asio/reference/basic_raw_socket/basic_raw_socket/overload9.html
-/doc/asio/reference/basic_raw_socket/bind/
-/doc/asio/reference/basic_raw_socket/bind.html
-/doc/asio/reference/basic_raw_socket/bind/overload1.html
-/doc/asio/reference/basic_raw_socket/bind/overload2.html
-/doc/asio/reference/basic_raw_socket/broadcast.html
-/doc/asio/reference/basic_raw_socket/bytes_readable.html
-/doc/asio/reference/basic_raw_socket/cancel/
-/doc/asio/reference/basic_raw_socket/cancel.html
-/doc/asio/reference/basic_raw_socket/cancel/overload1.html
-/doc/asio/reference/basic_raw_socket/cancel/overload2.html
-/doc/asio/reference/basic_raw_socket/close/
-/doc/asio/reference/basic_raw_socket/close.html
-/doc/asio/reference/basic_raw_socket/close/overload1.html
-/doc/asio/reference/basic_raw_socket/close/overload2.html
-/doc/asio/reference/basic_raw_socket/connect/
-/doc/asio/reference/basic_raw_socket/connect.html
-/doc/asio/reference/basic_raw_socket/connect/overload1.html
-/doc/asio/reference/basic_raw_socket/connect/overload2.html
-/doc/asio/reference/basic_raw_socket/debug.html
-/doc/asio/reference/basic_raw_socket/do_not_route.html
-/doc/asio/reference/basic_raw_socket/enable_connection_aborted.html
-/doc/asio/reference/basic_raw_socket/endpoint_type.html
-/doc/asio/reference/basic_raw_socket/executor_type.html
-/doc/asio/reference/basic_raw_socket/get_executor.html
-/doc/asio/reference/basic_raw_socket/get_option/
-/doc/asio/reference/basic_raw_socket/get_option.html
-/doc/asio/reference/basic_raw_socket/get_option/overload1.html
-/doc/asio/reference/basic_raw_socket/get_option/overload2.html
-/doc/asio/reference/basic_raw_socket.html
-/doc/asio/reference/basic_raw_socket/io_control/
-/doc/asio/reference/basic_raw_socket/io_control.html
-/doc/asio/reference/basic_raw_socket/io_control/overload1.html
-/doc/asio/reference/basic_raw_socket/io_control/overload2.html
-/doc/asio/reference/basic_raw_socket/is_open.html
-/doc/asio/reference/basic_raw_socket/keep_alive.html
-/doc/asio/reference/basic_raw_socket/linger.html
-/doc/asio/reference/basic_raw_socket/local_endpoint/
-/doc/asio/reference/basic_raw_socket/local_endpoint.html
-/doc/asio/reference/basic_raw_socket/local_endpoint/overload1.html
-/doc/asio/reference/basic_raw_socket/local_endpoint/overload2.html
-/doc/asio/reference/basic_raw_socket/lowest_layer/
-/doc/asio/reference/basic_raw_socket/lowest_layer.html
-/doc/asio/reference/basic_raw_socket/lowest_layer/overload1.html
-/doc/asio/reference/basic_raw_socket/lowest_layer/overload2.html
-/doc/asio/reference/basic_raw_socket/lowest_layer_type.html
-/doc/asio/reference/basic_raw_socket/max_connections.html
-/doc/asio/reference/basic_raw_socket/max_listen_connections.html
-/doc/asio/reference/basic_raw_socket/message_do_not_route.html
-/doc/asio/reference/basic_raw_socket/message_end_of_record.html
-/doc/asio/reference/basic_raw_socket/message_flags.html
-/doc/asio/reference/basic_raw_socket/message_out_of_band.html
-/doc/asio/reference/basic_raw_socket/message_peek.html
-/doc/asio/reference/basic_raw_socket/native_handle.html
-/doc/asio/reference/basic_raw_socket/native_handle_type.html
-/doc/asio/reference/basic_raw_socket/native_non_blocking/
-/doc/asio/reference/basic_raw_socket/native_non_blocking.html
-/doc/asio/reference/basic_raw_socket/native_non_blocking/overload1.html
-/doc/asio/reference/basic_raw_socket/native_non_blocking/overload2.html
-/doc/asio/reference/basic_raw_socket/native_non_blocking/overload3.html
-/doc/asio/reference/basic_raw_socket/non_blocking/
-/doc/asio/reference/basic_raw_socket/non_blocking.html
-/doc/asio/reference/basic_raw_socket/non_blocking/overload1.html
-/doc/asio/reference/basic_raw_socket/non_blocking/overload2.html
-/doc/asio/reference/basic_raw_socket/non_blocking/overload3.html
-/doc/asio/reference/basic_raw_socket/open/
-/doc/asio/reference/basic_raw_socket/open.html
-/doc/asio/reference/basic_raw_socket/open/overload1.html
-/doc/asio/reference/basic_raw_socket/open/overload2.html
-/doc/asio/reference/basic_raw_socket/operator_eq_/
-/doc/asio/reference/basic_raw_socket/operator_eq_.html
-/doc/asio/reference/basic_raw_socket/operator_eq_/overload1.html
-/doc/asio/reference/basic_raw_socket/operator_eq_/overload2.html
-/doc/asio/reference/basic_raw_socket/out_of_band_inline.html
-/doc/asio/reference/basic_raw_socket/protocol_type.html
-/doc/asio/reference/basic_raw_socket__rebind_executor/
-/doc/asio/reference/basic_raw_socket__rebind_executor.html
-/doc/asio/reference/basic_raw_socket__rebind_executor/other.html
-/doc/asio/reference/basic_raw_socket/receive/
-/doc/asio/reference/basic_raw_socket/receive_buffer_size.html
-/doc/asio/reference/basic_raw_socket/receive_from/
-/doc/asio/reference/basic_raw_socket/receive_from.html
-/doc/asio/reference/basic_raw_socket/receive_from/overload1.html
-/doc/asio/reference/basic_raw_socket/receive_from/overload2.html
-/doc/asio/reference/basic_raw_socket/receive_from/overload3.html
-/doc/asio/reference/basic_raw_socket/receive.html
-/doc/asio/reference/basic_raw_socket/receive_low_watermark.html
-/doc/asio/reference/basic_raw_socket/receive/overload1.html
-/doc/asio/reference/basic_raw_socket/receive/overload2.html
-/doc/asio/reference/basic_raw_socket/receive/overload3.html
-/doc/asio/reference/basic_raw_socket/release/
-/doc/asio/reference/basic_raw_socket/release.html
-/doc/asio/reference/basic_raw_socket/release/overload1.html
-/doc/asio/reference/basic_raw_socket/release/overload2.html
-/doc/asio/reference/basic_raw_socket/remote_endpoint/
-/doc/asio/reference/basic_raw_socket/remote_endpoint.html
-/doc/asio/reference/basic_raw_socket/remote_endpoint/overload1.html
-/doc/asio/reference/basic_raw_socket/remote_endpoint/overload2.html
-/doc/asio/reference/basic_raw_socket/reuse_address.html
-/doc/asio/reference/basic_raw_socket/send/
-/doc/asio/reference/basic_raw_socket/send_buffer_size.html
-/doc/asio/reference/basic_raw_socket/send.html
-/doc/asio/reference/basic_raw_socket/send_low_watermark.html
-/doc/asio/reference/basic_raw_socket/send/overload1.html
-/doc/asio/reference/basic_raw_socket/send/overload2.html
-/doc/asio/reference/basic_raw_socket/send/overload3.html
-/doc/asio/reference/basic_raw_socket/send_to/
-/doc/asio/reference/basic_raw_socket/send_to.html
-/doc/asio/reference/basic_raw_socket/send_to/overload1.html
-/doc/asio/reference/basic_raw_socket/send_to/overload2.html
-/doc/asio/reference/basic_raw_socket/send_to/overload3.html
-/doc/asio/reference/basic_raw_socket/set_option/
-/doc/asio/reference/basic_raw_socket/set_option.html
-/doc/asio/reference/basic_raw_socket/set_option/overload1.html
-/doc/asio/reference/basic_raw_socket/set_option/overload2.html
-/doc/asio/reference/basic_raw_socket/shutdown/
-/doc/asio/reference/basic_raw_socket/shutdown.html
-/doc/asio/reference/basic_raw_socket/shutdown/overload1.html
-/doc/asio/reference/basic_raw_socket/shutdown/overload2.html
-/doc/asio/reference/basic_raw_socket/shutdown_type.html
-/doc/asio/reference/basic_raw_socket/wait/
-/doc/asio/reference/basic_raw_socket/wait.html
-/doc/asio/reference/basic_raw_socket/wait/overload1.html
-/doc/asio/reference/basic_raw_socket/wait/overload2.html
-/doc/asio/reference/basic_raw_socket/wait_type.html
-/doc/asio/reference/basic_readable_pipe/
-/doc/asio/reference/basic_readable_pipe/assign/
-/doc/asio/reference/basic_readable_pipe/assign.html
-/doc/asio/reference/basic_readable_pipe/assign/overload1.html
-/doc/asio/reference/basic_readable_pipe/assign/overload2.html
-/doc/asio/reference/basic_readable_pipe/async_read_some.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/
-/doc/asio/reference/basic_readable_pipe/_basic_readable_pipe.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload1.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload2.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload3.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload4.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload5.html
-/doc/asio/reference/basic_readable_pipe/basic_readable_pipe/overload6.html
-/doc/asio/reference/basic_readable_pipe/cancel/
-/doc/asio/reference/basic_readable_pipe/cancel.html
-/doc/asio/reference/basic_readable_pipe/cancel/overload1.html
-/doc/asio/reference/basic_readable_pipe/cancel/overload2.html
-/doc/asio/reference/basic_readable_pipe/close/
-/doc/asio/reference/basic_readable_pipe/close.html
-/doc/asio/reference/basic_readable_pipe/close/overload1.html
-/doc/asio/reference/basic_readable_pipe/close/overload2.html
-/doc/asio/reference/basic_readable_pipe/executor_type.html
-/doc/asio/reference/basic_readable_pipe/get_executor.html
-/doc/asio/reference/basic_readable_pipe.html
-/doc/asio/reference/basic_readable_pipe/is_open.html
-/doc/asio/reference/basic_readable_pipe/lowest_layer/
-/doc/asio/reference/basic_readable_pipe/lowest_layer.html
-/doc/asio/reference/basic_readable_pipe/lowest_layer/overload1.html
-/doc/asio/reference/basic_readable_pipe/lowest_layer/overload2.html
-/doc/asio/reference/basic_readable_pipe/lowest_layer_type.html
-/doc/asio/reference/basic_readable_pipe/native_handle.html
-/doc/asio/reference/basic_readable_pipe/native_handle_type.html
-/doc/asio/reference/basic_readable_pipe/operator_eq_/
-/doc/asio/reference/basic_readable_pipe/operator_eq_.html
-/doc/asio/reference/basic_readable_pipe/operator_eq_/overload1.html
-/doc/asio/reference/basic_readable_pipe/operator_eq_/overload2.html
-/doc/asio/reference/basic_readable_pipe/read_some/
-/doc/asio/reference/basic_readable_pipe/read_some.html
-/doc/asio/reference/basic_readable_pipe/read_some/overload1.html
-/doc/asio/reference/basic_readable_pipe/read_some/overload2.html
-/doc/asio/reference/basic_readable_pipe__rebind_executor/
-/doc/asio/reference/basic_readable_pipe__rebind_executor.html
-/doc/asio/reference/basic_readable_pipe__rebind_executor/other.html
-/doc/asio/reference/basic_readable_pipe/release/
-/doc/asio/reference/basic_readable_pipe/release.html
-/doc/asio/reference/basic_readable_pipe/release/overload1.html
-/doc/asio/reference/basic_readable_pipe/release/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/
-/doc/asio/reference/basic_seq_packet_socket/assign/
-/doc/asio/reference/basic_seq_packet_socket/assign.html
-/doc/asio/reference/basic_seq_packet_socket/assign/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/assign/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/async_connect.html
-/doc/asio/reference/basic_seq_packet_socket/async_receive/
-/doc/asio/reference/basic_seq_packet_socket/async_receive.html
-/doc/asio/reference/basic_seq_packet_socket/async_receive/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/async_receive/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/async_send.html
-/doc/asio/reference/basic_seq_packet_socket/async_wait.html
-/doc/asio/reference/basic_seq_packet_socket/at_mark/
-/doc/asio/reference/basic_seq_packet_socket/at_mark.html
-/doc/asio/reference/basic_seq_packet_socket/at_mark/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/at_mark/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/available/
-/doc/asio/reference/basic_seq_packet_socket/available.html
-/doc/asio/reference/basic_seq_packet_socket/available/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/available/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/
-/doc/asio/reference/basic_seq_packet_socket/_basic_seq_packet_socket.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload10.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload3.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload4.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload5.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload6.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload7.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload8.html
-/doc/asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload9.html
-/doc/asio/reference/basic_seq_packet_socket/bind/
-/doc/asio/reference/basic_seq_packet_socket/bind.html
-/doc/asio/reference/basic_seq_packet_socket/bind/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/bind/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/broadcast.html
-/doc/asio/reference/basic_seq_packet_socket/bytes_readable.html
-/doc/asio/reference/basic_seq_packet_socket/cancel/
-/doc/asio/reference/basic_seq_packet_socket/cancel.html
-/doc/asio/reference/basic_seq_packet_socket/cancel/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/cancel/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/close/
-/doc/asio/reference/basic_seq_packet_socket/close.html
-/doc/asio/reference/basic_seq_packet_socket/close/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/close/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/connect/
-/doc/asio/reference/basic_seq_packet_socket/connect.html
-/doc/asio/reference/basic_seq_packet_socket/connect/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/connect/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/debug.html
-/doc/asio/reference/basic_seq_packet_socket/do_not_route.html
-/doc/asio/reference/basic_seq_packet_socket/enable_connection_aborted.html
-/doc/asio/reference/basic_seq_packet_socket/endpoint_type.html
-/doc/asio/reference/basic_seq_packet_socket/executor_type.html
-/doc/asio/reference/basic_seq_packet_socket/get_executor.html
-/doc/asio/reference/basic_seq_packet_socket/get_option/
-/doc/asio/reference/basic_seq_packet_socket/get_option.html
-/doc/asio/reference/basic_seq_packet_socket/get_option/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/get_option/overload2.html
-/doc/asio/reference/basic_seq_packet_socket.html
-/doc/asio/reference/basic_seq_packet_socket/io_control/
-/doc/asio/reference/basic_seq_packet_socket/io_control.html
-/doc/asio/reference/basic_seq_packet_socket/io_control/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/io_control/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/is_open.html
-/doc/asio/reference/basic_seq_packet_socket/keep_alive.html
-/doc/asio/reference/basic_seq_packet_socket/linger.html
-/doc/asio/reference/basic_seq_packet_socket/local_endpoint/
-/doc/asio/reference/basic_seq_packet_socket/local_endpoint.html
-/doc/asio/reference/basic_seq_packet_socket/local_endpoint/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/local_endpoint/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/lowest_layer/
-/doc/asio/reference/basic_seq_packet_socket/lowest_layer.html
-/doc/asio/reference/basic_seq_packet_socket/lowest_layer/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/lowest_layer/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/lowest_layer_type.html
-/doc/asio/reference/basic_seq_packet_socket/max_connections.html
-/doc/asio/reference/basic_seq_packet_socket/max_listen_connections.html
-/doc/asio/reference/basic_seq_packet_socket/message_do_not_route.html
-/doc/asio/reference/basic_seq_packet_socket/message_end_of_record.html
-/doc/asio/reference/basic_seq_packet_socket/message_flags.html
-/doc/asio/reference/basic_seq_packet_socket/message_out_of_band.html
-/doc/asio/reference/basic_seq_packet_socket/message_peek.html
-/doc/asio/reference/basic_seq_packet_socket/native_handle.html
-/doc/asio/reference/basic_seq_packet_socket/native_handle_type.html
-/doc/asio/reference/basic_seq_packet_socket/native_non_blocking/
-/doc/asio/reference/basic_seq_packet_socket/native_non_blocking.html
-/doc/asio/reference/basic_seq_packet_socket/native_non_blocking/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/native_non_blocking/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/native_non_blocking/overload3.html
-/doc/asio/reference/basic_seq_packet_socket/non_blocking/
-/doc/asio/reference/basic_seq_packet_socket/non_blocking.html
-/doc/asio/reference/basic_seq_packet_socket/non_blocking/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/non_blocking/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/non_blocking/overload3.html
-/doc/asio/reference/basic_seq_packet_socket/open/
-/doc/asio/reference/basic_seq_packet_socket/open.html
-/doc/asio/reference/basic_seq_packet_socket/open/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/open/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/operator_eq_/
-/doc/asio/reference/basic_seq_packet_socket/operator_eq_.html
-/doc/asio/reference/basic_seq_packet_socket/operator_eq_/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/operator_eq_/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/out_of_band_inline.html
-/doc/asio/reference/basic_seq_packet_socket/protocol_type.html
-/doc/asio/reference/basic_seq_packet_socket__rebind_executor/
-/doc/asio/reference/basic_seq_packet_socket__rebind_executor.html
-/doc/asio/reference/basic_seq_packet_socket__rebind_executor/other.html
-/doc/asio/reference/basic_seq_packet_socket/receive/
-/doc/asio/reference/basic_seq_packet_socket/receive_buffer_size.html
-/doc/asio/reference/basic_seq_packet_socket/receive.html
-/doc/asio/reference/basic_seq_packet_socket/receive_low_watermark.html
-/doc/asio/reference/basic_seq_packet_socket/receive/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/receive/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/receive/overload3.html
-/doc/asio/reference/basic_seq_packet_socket/release/
-/doc/asio/reference/basic_seq_packet_socket/release.html
-/doc/asio/reference/basic_seq_packet_socket/release/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/release/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/remote_endpoint/
-/doc/asio/reference/basic_seq_packet_socket/remote_endpoint.html
-/doc/asio/reference/basic_seq_packet_socket/remote_endpoint/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/remote_endpoint/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/reuse_address.html
-/doc/asio/reference/basic_seq_packet_socket/send/
-/doc/asio/reference/basic_seq_packet_socket/send_buffer_size.html
-/doc/asio/reference/basic_seq_packet_socket/send.html
-/doc/asio/reference/basic_seq_packet_socket/send_low_watermark.html
-/doc/asio/reference/basic_seq_packet_socket/send/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/send/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/set_option/
-/doc/asio/reference/basic_seq_packet_socket/set_option.html
-/doc/asio/reference/basic_seq_packet_socket/set_option/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/set_option/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/shutdown/
-/doc/asio/reference/basic_seq_packet_socket/shutdown.html
-/doc/asio/reference/basic_seq_packet_socket/shutdown/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/shutdown/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/shutdown_type.html
-/doc/asio/reference/basic_seq_packet_socket/wait/
-/doc/asio/reference/basic_seq_packet_socket/wait.html
-/doc/asio/reference/basic_seq_packet_socket/wait/overload1.html
-/doc/asio/reference/basic_seq_packet_socket/wait/overload2.html
-/doc/asio/reference/basic_seq_packet_socket/wait_type.html
-/doc/asio/reference/basic_serial_port/
-/doc/asio/reference/basic_serial_port/assign/
-/doc/asio/reference/basic_serial_port/assign.html
-/doc/asio/reference/basic_serial_port/assign/overload1.html
-/doc/asio/reference/basic_serial_port/assign/overload2.html
-/doc/asio/reference/basic_serial_port/async_read_some.html
-/doc/asio/reference/basic_serial_port/async_write_some.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/
-/doc/asio/reference/basic_serial_port/_basic_serial_port.html
-/doc/asio/reference/basic_serial_port/basic_serial_port.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload10.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload1.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload2.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload3.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload4.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload5.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload6.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload7.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload8.html
-/doc/asio/reference/basic_serial_port/basic_serial_port/overload9.html
-/doc/asio/reference/basic_serial_port/cancel/
-/doc/asio/reference/basic_serial_port/cancel.html
-/doc/asio/reference/basic_serial_port/cancel/overload1.html
-/doc/asio/reference/basic_serial_port/cancel/overload2.html
-/doc/asio/reference/basic_serial_port/close/
-/doc/asio/reference/basic_serial_port/close.html
-/doc/asio/reference/basic_serial_port/close/overload1.html
-/doc/asio/reference/basic_serial_port/close/overload2.html
-/doc/asio/reference/basic_serial_port/executor_type.html
-/doc/asio/reference/basic_serial_port/get_executor.html
-/doc/asio/reference/basic_serial_port/get_option/
-/doc/asio/reference/basic_serial_port/get_option.html
-/doc/asio/reference/basic_serial_port/get_option/overload1.html
-/doc/asio/reference/basic_serial_port/get_option/overload2.html
-/doc/asio/reference/basic_serial_port.html
-/doc/asio/reference/basic_serial_port/is_open.html
-/doc/asio/reference/basic_serial_port/lowest_layer/
-/doc/asio/reference/basic_serial_port/lowest_layer.html
-/doc/asio/reference/basic_serial_port/lowest_layer/overload1.html
-/doc/asio/reference/basic_serial_port/lowest_layer/overload2.html
-/doc/asio/reference/basic_serial_port/lowest_layer_type.html
-/doc/asio/reference/basic_serial_port/native_handle.html
-/doc/asio/reference/basic_serial_port/native_handle_type.html
-/doc/asio/reference/basic_serial_port/open/
-/doc/asio/reference/basic_serial_port/open.html
-/doc/asio/reference/basic_serial_port/open/overload1.html
-/doc/asio/reference/basic_serial_port/open/overload2.html
-/doc/asio/reference/basic_serial_port/operator_eq_/
-/doc/asio/reference/basic_serial_port/operator_eq_.html
-/doc/asio/reference/basic_serial_port/operator_eq_/overload1.html
-/doc/asio/reference/basic_serial_port/operator_eq_/overload2.html
-/doc/asio/reference/basic_serial_port/read_some/
-/doc/asio/reference/basic_serial_port/read_some.html
-/doc/asio/reference/basic_serial_port/read_some/overload1.html
-/doc/asio/reference/basic_serial_port/read_some/overload2.html
-/doc/asio/reference/basic_serial_port__rebind_executor/
-/doc/asio/reference/basic_serial_port__rebind_executor.html
-/doc/asio/reference/basic_serial_port__rebind_executor/other.html
-/doc/asio/reference/basic_serial_port/send_break/
-/doc/asio/reference/basic_serial_port/send_break.html
-/doc/asio/reference/basic_serial_port/send_break/overload1.html
-/doc/asio/reference/basic_serial_port/send_break/overload2.html
-/doc/asio/reference/basic_serial_port/set_option/
-/doc/asio/reference/basic_serial_port/set_option.html
-/doc/asio/reference/basic_serial_port/set_option/overload1.html
-/doc/asio/reference/basic_serial_port/set_option/overload2.html
-/doc/asio/reference/basic_serial_port/write_some/
-/doc/asio/reference/basic_serial_port/write_some.html
-/doc/asio/reference/basic_serial_port/write_some/overload1.html
-/doc/asio/reference/basic_serial_port/write_some/overload2.html
-/doc/asio/reference/basic_signal_set/
-/doc/asio/reference/basic_signal_set/add/
-/doc/asio/reference/basic_signal_set/add.html
-/doc/asio/reference/basic_signal_set/add/overload1.html
-/doc/asio/reference/basic_signal_set/add/overload2.html
-/doc/asio/reference/basic_signal_set/add/overload3.html
-/doc/asio/reference/basic_signal_set/add/overload4.html
-/doc/asio/reference/basic_signal_set/async_wait.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/
-/doc/asio/reference/basic_signal_set/_basic_signal_set.html
-/doc/asio/reference/basic_signal_set/basic_signal_set.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload1.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload2.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload3.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload4.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload5.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload6.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload7.html
-/doc/asio/reference/basic_signal_set/basic_signal_set/overload8.html
-/doc/asio/reference/basic_signal_set/cancel/
-/doc/asio/reference/basic_signal_set/cancel.html
-/doc/asio/reference/basic_signal_set/cancel/overload1.html
-/doc/asio/reference/basic_signal_set/cancel/overload2.html
-/doc/asio/reference/basic_signal_set/clear/
-/doc/asio/reference/basic_signal_set/clear.html
-/doc/asio/reference/basic_signal_set/clear/overload1.html
-/doc/asio/reference/basic_signal_set/clear/overload2.html
-/doc/asio/reference/basic_signal_set/executor_type.html
-/doc/asio/reference/basic_signal_set/flags.html
-/doc/asio/reference/basic_signal_set/flags_t.html
-/doc/asio/reference/basic_signal_set/get_executor.html
-/doc/asio/reference/basic_signal_set.html
-/doc/asio/reference/basic_signal_set__rebind_executor/
-/doc/asio/reference/basic_signal_set__rebind_executor.html
-/doc/asio/reference/basic_signal_set__rebind_executor/other.html
-/doc/asio/reference/basic_signal_set/remove/
-/doc/asio/reference/basic_signal_set/remove.html
-/doc/asio/reference/basic_signal_set/remove/overload1.html
-/doc/asio/reference/basic_signal_set/remove/overload2.html
-/doc/asio/reference/basic_socket/
-/doc/asio/reference/basic_socket_acceptor/
-/doc/asio/reference/basic_socket_acceptor/accept/
-/doc/asio/reference/basic_socket_acceptor/accept.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload10.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload11.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload12.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload13.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload14.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload15.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload16.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload1.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload2.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload3.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload4.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload5.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload6.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload7.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload8.html
-/doc/asio/reference/basic_socket_acceptor/accept/overload9.html
-/doc/asio/reference/basic_socket_acceptor/assign/
-/doc/asio/reference/basic_socket_acceptor/assign.html
-/doc/asio/reference/basic_socket_acceptor/assign/overload1.html
-/doc/asio/reference/basic_socket_acceptor/assign/overload2.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/
-/doc/asio/reference/basic_socket_acceptor/async_accept.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload1.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload2.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload3.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload4.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload5.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload6.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload7.html
-/doc/asio/reference/basic_socket_acceptor/async_accept/overload8.html
-/doc/asio/reference/basic_socket_acceptor/async_wait.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/
-/doc/asio/reference/basic_socket_acceptor/_basic_socket_acceptor.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload10.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload1.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload2.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload3.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload4.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload5.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload6.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload7.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload8.html
-/doc/asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload9.html
-/doc/asio/reference/basic_socket_acceptor/bind/
-/doc/asio/reference/basic_socket_acceptor/bind.html
-/doc/asio/reference/basic_socket_acceptor/bind/overload1.html
-/doc/asio/reference/basic_socket_acceptor/bind/overload2.html
-/doc/asio/reference/basic_socket_acceptor/broadcast.html
-/doc/asio/reference/basic_socket_acceptor/bytes_readable.html
-/doc/asio/reference/basic_socket_acceptor/cancel/
-/doc/asio/reference/basic_socket_acceptor/cancel.html
-/doc/asio/reference/basic_socket_acceptor/cancel/overload1.html
-/doc/asio/reference/basic_socket_acceptor/cancel/overload2.html
-/doc/asio/reference/basic_socket_acceptor/close/
-/doc/asio/reference/basic_socket_acceptor/close.html
-/doc/asio/reference/basic_socket_acceptor/close/overload1.html
-/doc/asio/reference/basic_socket_acceptor/close/overload2.html
-/doc/asio/reference/basic_socket_acceptor/debug.html
-/doc/asio/reference/basic_socket_acceptor/do_not_route.html
-/doc/asio/reference/basic_socket_acceptor/enable_connection_aborted.html
-/doc/asio/reference/basic_socket_acceptor/endpoint_type.html
-/doc/asio/reference/basic_socket_acceptor/executor_type.html
-/doc/asio/reference/basic_socket_acceptor/get_executor.html
-/doc/asio/reference/basic_socket_acceptor/get_option/
-/doc/asio/reference/basic_socket_acceptor/get_option.html
-/doc/asio/reference/basic_socket_acceptor/get_option/overload1.html
-/doc/asio/reference/basic_socket_acceptor/get_option/overload2.html
-/doc/asio/reference/basic_socket_acceptor.html
-/doc/asio/reference/basic_socket_acceptor/io_control/
-/doc/asio/reference/basic_socket_acceptor/io_control.html
-/doc/asio/reference/basic_socket_acceptor/io_control/overload1.html
-/doc/asio/reference/basic_socket_acceptor/io_control/overload2.html
-/doc/asio/reference/basic_socket_acceptor/is_open.html
-/doc/asio/reference/basic_socket_acceptor/keep_alive.html
-/doc/asio/reference/basic_socket_acceptor/linger.html
-/doc/asio/reference/basic_socket_acceptor/listen/
-/doc/asio/reference/basic_socket_acceptor/listen.html
-/doc/asio/reference/basic_socket_acceptor/listen/overload1.html
-/doc/asio/reference/basic_socket_acceptor/listen/overload2.html
-/doc/asio/reference/basic_socket_acceptor/local_endpoint/
-/doc/asio/reference/basic_socket_acceptor/local_endpoint.html
-/doc/asio/reference/basic_socket_acceptor/local_endpoint/overload1.html
-/doc/asio/reference/basic_socket_acceptor/local_endpoint/overload2.html
-/doc/asio/reference/basic_socket_acceptor/max_connections.html
-/doc/asio/reference/basic_socket_acceptor/max_listen_connections.html
-/doc/asio/reference/basic_socket_acceptor/message_do_not_route.html
-/doc/asio/reference/basic_socket_acceptor/message_end_of_record.html
-/doc/asio/reference/basic_socket_acceptor/message_flags.html
-/doc/asio/reference/basic_socket_acceptor/message_out_of_band.html
-/doc/asio/reference/basic_socket_acceptor/message_peek.html
-/doc/asio/reference/basic_socket_acceptor/native_handle.html
-/doc/asio/reference/basic_socket_acceptor/native_handle_type.html
-/doc/asio/reference/basic_socket_acceptor/native_non_blocking/
-/doc/asio/reference/basic_socket_acceptor/native_non_blocking.html
-/doc/asio/reference/basic_socket_acceptor/native_non_blocking/overload1.html
-/doc/asio/reference/basic_socket_acceptor/native_non_blocking/overload2.html
-/doc/asio/reference/basic_socket_acceptor/native_non_blocking/overload3.html
-/doc/asio/reference/basic_socket_acceptor/non_blocking/
-/doc/asio/reference/basic_socket_acceptor/non_blocking.html
-/doc/asio/reference/basic_socket_acceptor/non_blocking/overload1.html
-/doc/asio/reference/basic_socket_acceptor/non_blocking/overload2.html
-/doc/asio/reference/basic_socket_acceptor/non_blocking/overload3.html
-/doc/asio/reference/basic_socket_acceptor/open/
-/doc/asio/reference/basic_socket_acceptor/open.html
-/doc/asio/reference/basic_socket_acceptor/open/overload1.html
-/doc/asio/reference/basic_socket_acceptor/open/overload2.html
-/doc/asio/reference/basic_socket_acceptor/operator_eq_/
-/doc/asio/reference/basic_socket_acceptor/operator_eq_.html
-/doc/asio/reference/basic_socket_acceptor/operator_eq_/overload1.html
-/doc/asio/reference/basic_socket_acceptor/operator_eq_/overload2.html
-/doc/asio/reference/basic_socket_acceptor/out_of_band_inline.html
-/doc/asio/reference/basic_socket_acceptor/protocol_type.html
-/doc/asio/reference/basic_socket_acceptor__rebind_executor/
-/doc/asio/reference/basic_socket_acceptor__rebind_executor.html
-/doc/asio/reference/basic_socket_acceptor__rebind_executor/other.html
-/doc/asio/reference/basic_socket_acceptor/receive_buffer_size.html
-/doc/asio/reference/basic_socket_acceptor/receive_low_watermark.html
-/doc/asio/reference/basic_socket_acceptor/release/
-/doc/asio/reference/basic_socket_acceptor/release.html
-/doc/asio/reference/basic_socket_acceptor/release/overload1.html
-/doc/asio/reference/basic_socket_acceptor/release/overload2.html
-/doc/asio/reference/basic_socket_acceptor/reuse_address.html
-/doc/asio/reference/basic_socket_acceptor/send_buffer_size.html
-/doc/asio/reference/basic_socket_acceptor/send_low_watermark.html
-/doc/asio/reference/basic_socket_acceptor/set_option/
-/doc/asio/reference/basic_socket_acceptor/set_option.html
-/doc/asio/reference/basic_socket_acceptor/set_option/overload1.html
-/doc/asio/reference/basic_socket_acceptor/set_option/overload2.html
-/doc/asio/reference/basic_socket_acceptor/shutdown_type.html
-/doc/asio/reference/basic_socket_acceptor/wait/
-/doc/asio/reference/basic_socket_acceptor/wait.html
-/doc/asio/reference/basic_socket_acceptor/wait/overload1.html
-/doc/asio/reference/basic_socket_acceptor/wait/overload2.html
-/doc/asio/reference/basic_socket_acceptor/wait_type.html
-/doc/asio/reference/basic_socket/assign/
-/doc/asio/reference/basic_socket/assign.html
-/doc/asio/reference/basic_socket/assign/overload1.html
-/doc/asio/reference/basic_socket/assign/overload2.html
-/doc/asio/reference/basic_socket/async_connect.html
-/doc/asio/reference/basic_socket/async_wait.html
-/doc/asio/reference/basic_socket/at_mark/
-/doc/asio/reference/basic_socket/at_mark.html
-/doc/asio/reference/basic_socket/at_mark/overload1.html
-/doc/asio/reference/basic_socket/at_mark/overload2.html
-/doc/asio/reference/basic_socket/available/
-/doc/asio/reference/basic_socket/available.html
-/doc/asio/reference/basic_socket/available/overload1.html
-/doc/asio/reference/basic_socket/available/overload2.html
-/doc/asio/reference/basic_socket/basic_socket/
-/doc/asio/reference/basic_socket/_basic_socket.html
-/doc/asio/reference/basic_socket/basic_socket.html
-/doc/asio/reference/basic_socket/basic_socket/overload10.html
-/doc/asio/reference/basic_socket/basic_socket/overload1.html
-/doc/asio/reference/basic_socket/basic_socket/overload2.html
-/doc/asio/reference/basic_socket/basic_socket/overload3.html
-/doc/asio/reference/basic_socket/basic_socket/overload4.html
-/doc/asio/reference/basic_socket/basic_socket/overload5.html
-/doc/asio/reference/basic_socket/basic_socket/overload6.html
-/doc/asio/reference/basic_socket/basic_socket/overload7.html
-/doc/asio/reference/basic_socket/basic_socket/overload8.html
-/doc/asio/reference/basic_socket/basic_socket/overload9.html
-/doc/asio/reference/basic_socket/bind/
-/doc/asio/reference/basic_socket/bind.html
-/doc/asio/reference/basic_socket/bind/overload1.html
-/doc/asio/reference/basic_socket/bind/overload2.html
-/doc/asio/reference/basic_socket/broadcast.html
-/doc/asio/reference/basic_socket/bytes_readable.html
-/doc/asio/reference/basic_socket/cancel/
-/doc/asio/reference/basic_socket/cancel.html
-/doc/asio/reference/basic_socket/cancel/overload1.html
-/doc/asio/reference/basic_socket/cancel/overload2.html
-/doc/asio/reference/basic_socket/close/
-/doc/asio/reference/basic_socket/close.html
-/doc/asio/reference/basic_socket/close/overload1.html
-/doc/asio/reference/basic_socket/close/overload2.html
-/doc/asio/reference/basic_socket/connect/
-/doc/asio/reference/basic_socket/connect.html
-/doc/asio/reference/basic_socket/connect/overload1.html
-/doc/asio/reference/basic_socket/connect/overload2.html
-/doc/asio/reference/basic_socket/debug.html
-/doc/asio/reference/basic_socket/do_not_route.html
-/doc/asio/reference/basic_socket/enable_connection_aborted.html
-/doc/asio/reference/basic_socket/endpoint_type.html
-/doc/asio/reference/basic_socket/executor_type.html
-/doc/asio/reference/basic_socket/get_executor.html
-/doc/asio/reference/basic_socket/get_option/
-/doc/asio/reference/basic_socket/get_option.html
-/doc/asio/reference/basic_socket/get_option/overload1.html
-/doc/asio/reference/basic_socket/get_option/overload2.html
-/doc/asio/reference/basic_socket.html
-/doc/asio/reference/basic_socket/io_control/
-/doc/asio/reference/basic_socket/io_control.html
-/doc/asio/reference/basic_socket/io_control/overload1.html
-/doc/asio/reference/basic_socket/io_control/overload2.html
-/doc/asio/reference/basic_socket_iostream/
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream/
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream.html
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream/overload1.html
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream/overload2.html
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream/overload3.html
-/doc/asio/reference/basic_socket_iostream/basic_socket_iostream/overload4.html
-/doc/asio/reference/basic_socket_iostream/clock_type.html
-/doc/asio/reference/basic_socket_iostream/close.html
-/doc/asio/reference/basic_socket_iostream/connect.html
-/doc/asio/reference/basic_socket_iostream/duration.html
-/doc/asio/reference/basic_socket_iostream/duration_type.html
-/doc/asio/reference/basic_socket_iostream/endpoint_type.html
-/doc/asio/reference/basic_socket_iostream/error.html
-/doc/asio/reference/basic_socket_iostream/expires_after.html
-/doc/asio/reference/basic_socket_iostream/expires_at/
-/doc/asio/reference/basic_socket_iostream/expires_at.html
-/doc/asio/reference/basic_socket_iostream/expires_at/overload1.html
-/doc/asio/reference/basic_socket_iostream/expires_at/overload2.html
-/doc/asio/reference/basic_socket_iostream/expires_from_now/
-/doc/asio/reference/basic_socket_iostream/expires_from_now.html
-/doc/asio/reference/basic_socket_iostream/expires_from_now/overload1.html
-/doc/asio/reference/basic_socket_iostream/expires_from_now/overload2.html
-/doc/asio/reference/basic_socket_iostream/expiry.html
-/doc/asio/reference/basic_socket_iostream.html
-/doc/asio/reference/basic_socket_iostream/operator_eq_.html
-/doc/asio/reference/basic_socket_iostream/protocol_type.html
-/doc/asio/reference/basic_socket_iostream/rdbuf.html
-/doc/asio/reference/basic_socket_iostream/socket.html
-/doc/asio/reference/basic_socket_iostream/time_point.html
-/doc/asio/reference/basic_socket_iostream/time_type.html
-/doc/asio/reference/basic_socket/is_open.html
-/doc/asio/reference/basic_socket/keep_alive.html
-/doc/asio/reference/basic_socket/linger.html
-/doc/asio/reference/basic_socket/local_endpoint/
-/doc/asio/reference/basic_socket/local_endpoint.html
-/doc/asio/reference/basic_socket/local_endpoint/overload1.html
-/doc/asio/reference/basic_socket/local_endpoint/overload2.html
-/doc/asio/reference/basic_socket/lowest_layer/
-/doc/asio/reference/basic_socket/lowest_layer.html
-/doc/asio/reference/basic_socket/lowest_layer/overload1.html
-/doc/asio/reference/basic_socket/lowest_layer/overload2.html
-/doc/asio/reference/basic_socket/lowest_layer_type.html
-/doc/asio/reference/basic_socket/max_connections.html
-/doc/asio/reference/basic_socket/max_listen_connections.html
-/doc/asio/reference/basic_socket/message_do_not_route.html
-/doc/asio/reference/basic_socket/message_end_of_record.html
-/doc/asio/reference/basic_socket/message_flags.html
-/doc/asio/reference/basic_socket/message_out_of_band.html
-/doc/asio/reference/basic_socket/message_peek.html
-/doc/asio/reference/basic_socket/native_handle.html
-/doc/asio/reference/basic_socket/native_handle_type.html
-/doc/asio/reference/basic_socket/native_non_blocking/
-/doc/asio/reference/basic_socket/native_non_blocking.html
-/doc/asio/reference/basic_socket/native_non_blocking/overload1.html
-/doc/asio/reference/basic_socket/native_non_blocking/overload2.html
-/doc/asio/reference/basic_socket/native_non_blocking/overload3.html
-/doc/asio/reference/basic_socket/non_blocking/
-/doc/asio/reference/basic_socket/non_blocking.html
-/doc/asio/reference/basic_socket/non_blocking/overload1.html
-/doc/asio/reference/basic_socket/non_blocking/overload2.html
-/doc/asio/reference/basic_socket/non_blocking/overload3.html
-/doc/asio/reference/basic_socket/open/
-/doc/asio/reference/basic_socket/open.html
-/doc/asio/reference/basic_socket/open/overload1.html
-/doc/asio/reference/basic_socket/open/overload2.html
-/doc/asio/reference/basic_socket/operator_eq_/
-/doc/asio/reference/basic_socket/operator_eq_.html
-/doc/asio/reference/basic_socket/operator_eq_/overload1.html
-/doc/asio/reference/basic_socket/operator_eq_/overload2.html
-/doc/asio/reference/basic_socket/out_of_band_inline.html
-/doc/asio/reference/basic_socket/protocol_type.html
-/doc/asio/reference/basic_socket__rebind_executor/
-/doc/asio/reference/basic_socket__rebind_executor.html
-/doc/asio/reference/basic_socket__rebind_executor/other.html
-/doc/asio/reference/basic_socket/receive_buffer_size.html
-/doc/asio/reference/basic_socket/receive_low_watermark.html
-/doc/asio/reference/basic_socket/release/
-/doc/asio/reference/basic_socket/release.html
-/doc/asio/reference/basic_socket/release/overload1.html
-/doc/asio/reference/basic_socket/release/overload2.html
-/doc/asio/reference/basic_socket/remote_endpoint/
-/doc/asio/reference/basic_socket/remote_endpoint.html
-/doc/asio/reference/basic_socket/remote_endpoint/overload1.html
-/doc/asio/reference/basic_socket/remote_endpoint/overload2.html
-/doc/asio/reference/basic_socket/reuse_address.html
-/doc/asio/reference/basic_socket/send_buffer_size.html
-/doc/asio/reference/basic_socket/send_low_watermark.html
-/doc/asio/reference/basic_socket/set_option/
-/doc/asio/reference/basic_socket/set_option.html
-/doc/asio/reference/basic_socket/set_option/overload1.html
-/doc/asio/reference/basic_socket/set_option/overload2.html
-/doc/asio/reference/basic_socket/shutdown/
-/doc/asio/reference/basic_socket/shutdown.html
-/doc/asio/reference/basic_socket/shutdown/overload1.html
-/doc/asio/reference/basic_socket/shutdown/overload2.html
-/doc/asio/reference/basic_socket/shutdown_type.html
-/doc/asio/reference/basic_socket_streambuf/
-/doc/asio/reference/basic_socket_streambuf/basic_socket_streambuf/
-/doc/asio/reference/basic_socket_streambuf/_basic_socket_streambuf.html
-/doc/asio/reference/basic_socket_streambuf/basic_socket_streambuf.html
-/doc/asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload1.html
-/doc/asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload2.html
-/doc/asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload3.html
-/doc/asio/reference/basic_socket_streambuf/clock_type.html
-/doc/asio/reference/basic_socket_streambuf/close.html
-/doc/asio/reference/basic_socket_streambuf/connect/
-/doc/asio/reference/basic_socket_streambuf/connect.html
-/doc/asio/reference/basic_socket_streambuf/connect/overload1.html
-/doc/asio/reference/basic_socket_streambuf/connect/overload2.html
-/doc/asio/reference/basic_socket_streambuf/duration.html
-/doc/asio/reference/basic_socket_streambuf/duration_type.html
-/doc/asio/reference/basic_socket_streambuf/endpoint_type.html
-/doc/asio/reference/basic_socket_streambuf/error.html
-/doc/asio/reference/basic_socket_streambuf/expires_after.html
-/doc/asio/reference/basic_socket_streambuf/expires_at/
-/doc/asio/reference/basic_socket_streambuf/expires_at.html
-/doc/asio/reference/basic_socket_streambuf/expires_at/overload1.html
-/doc/asio/reference/basic_socket_streambuf/expires_at/overload2.html
-/doc/asio/reference/basic_socket_streambuf/expires_from_now/
-/doc/asio/reference/basic_socket_streambuf/expires_from_now.html
-/doc/asio/reference/basic_socket_streambuf/expires_from_now/overload1.html
-/doc/asio/reference/basic_socket_streambuf/expires_from_now/overload2.html
-/doc/asio/reference/basic_socket_streambuf/expiry.html
-/doc/asio/reference/basic_socket_streambuf.html
-/doc/asio/reference/basic_socket_streambuf/operator_eq_.html
-/doc/asio/reference/basic_socket_streambuf/overflow.html
-/doc/asio/reference/basic_socket_streambuf/protocol_type.html
-/doc/asio/reference/basic_socket_streambuf/puberror.html
-/doc/asio/reference/basic_socket_streambuf/setbuf.html
-/doc/asio/reference/basic_socket_streambuf/socket.html
-/doc/asio/reference/basic_socket_streambuf/sync.html
-/doc/asio/reference/basic_socket_streambuf/time_point.html
-/doc/asio/reference/basic_socket_streambuf/time_type.html
-/doc/asio/reference/basic_socket_streambuf/underflow.html
-/doc/asio/reference/basic_socket/wait/
-/doc/asio/reference/basic_socket/wait.html
-/doc/asio/reference/basic_socket/wait/overload1.html
-/doc/asio/reference/basic_socket/wait/overload2.html
-/doc/asio/reference/basic_socket/wait_type.html
-/doc/asio/reference/basic_streambuf/
-/doc/asio/reference/basic_streambuf/basic_streambuf.html
-/doc/asio/reference/basic_streambuf/capacity.html
-/doc/asio/reference/basic_streambuf/commit.html
-/doc/asio/reference/basic_streambuf/const_buffers_type.html
-/doc/asio/reference/basic_streambuf/consume.html
-/doc/asio/reference/basic_streambuf/data.html
-/doc/asio/reference/basic_streambuf.html
-/doc/asio/reference/basic_streambuf/max_size.html
-/doc/asio/reference/basic_streambuf/mutable_buffers_type.html
-/doc/asio/reference/basic_streambuf/overflow.html
-/doc/asio/reference/basic_streambuf/prepare.html
-/doc/asio/reference/basic_streambuf_ref/
-/doc/asio/reference/basic_streambuf_ref/basic_streambuf_ref/
-/doc/asio/reference/basic_streambuf_ref/basic_streambuf_ref.html
-/doc/asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload1.html
-/doc/asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload2.html
-/doc/asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload3.html
-/doc/asio/reference/basic_streambuf_ref/capacity.html
-/doc/asio/reference/basic_streambuf_ref/commit.html
-/doc/asio/reference/basic_streambuf_ref/const_buffers_type.html
-/doc/asio/reference/basic_streambuf_ref/consume.html
-/doc/asio/reference/basic_streambuf_ref/data.html
-/doc/asio/reference/basic_streambuf_ref.html
-/doc/asio/reference/basic_streambuf_ref/max_size.html
-/doc/asio/reference/basic_streambuf_ref/mutable_buffers_type.html
-/doc/asio/reference/basic_streambuf_ref/prepare.html
-/doc/asio/reference/basic_streambuf_ref/size.html
-/doc/asio/reference/basic_streambuf/reserve.html
-/doc/asio/reference/basic_streambuf/size.html
-/doc/asio/reference/basic_streambuf/underflow.html
-/doc/asio/reference/basic_stream_file/
-/doc/asio/reference/basic_stream_file/append.html
-/doc/asio/reference/basic_stream_file/assign/
-/doc/asio/reference/basic_stream_file/assign.html
-/doc/asio/reference/basic_stream_file/assign/overload1.html
-/doc/asio/reference/basic_stream_file/assign/overload2.html
-/doc/asio/reference/basic_stream_file/async_read_some.html
-/doc/asio/reference/basic_stream_file/async_write_some.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/
-/doc/asio/reference/basic_stream_file/_basic_stream_file.html
-/doc/asio/reference/basic_stream_file/basic_stream_file.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload10.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload1.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload2.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload3.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload4.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload5.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload6.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload7.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload8.html
-/doc/asio/reference/basic_stream_file/basic_stream_file/overload9.html
-/doc/asio/reference/basic_stream_file/cancel/
-/doc/asio/reference/basic_stream_file/cancel.html
-/doc/asio/reference/basic_stream_file/cancel/overload1.html
-/doc/asio/reference/basic_stream_file/cancel/overload2.html
-/doc/asio/reference/basic_stream_file/close/
-/doc/asio/reference/basic_stream_file/close.html
-/doc/asio/reference/basic_stream_file/close/overload1.html
-/doc/asio/reference/basic_stream_file/close/overload2.html
-/doc/asio/reference/basic_stream_file/create.html
-/doc/asio/reference/basic_stream_file/exclusive.html
-/doc/asio/reference/basic_stream_file/executor_type.html
-/doc/asio/reference/basic_stream_file/flags.html
-/doc/asio/reference/basic_stream_file/get_executor.html
-/doc/asio/reference/basic_stream_file.html
-/doc/asio/reference/basic_stream_file/is_open.html
-/doc/asio/reference/basic_stream_file/native_handle.html
-/doc/asio/reference/basic_stream_file/native_handle_type.html
-/doc/asio/reference/basic_stream_file/open/
-/doc/asio/reference/basic_stream_file/open.html
-/doc/asio/reference/basic_stream_file/open/overload1.html
-/doc/asio/reference/basic_stream_file/open/overload2.html
-/doc/asio/reference/basic_stream_file/open/overload3.html
-/doc/asio/reference/basic_stream_file/open/overload4.html
-/doc/asio/reference/basic_stream_file/operator_eq_/
-/doc/asio/reference/basic_stream_file/operator_eq_.html
-/doc/asio/reference/basic_stream_file/operator_eq_/overload1.html
-/doc/asio/reference/basic_stream_file/operator_eq_/overload2.html
-/doc/asio/reference/basic_stream_file/read_only.html
-/doc/asio/reference/basic_stream_file/read_some/
-/doc/asio/reference/basic_stream_file/read_some.html
-/doc/asio/reference/basic_stream_file/read_some/overload1.html
-/doc/asio/reference/basic_stream_file/read_some/overload2.html
-/doc/asio/reference/basic_stream_file/read_write.html
-/doc/asio/reference/basic_stream_file__rebind_executor/
-/doc/asio/reference/basic_stream_file__rebind_executor.html
-/doc/asio/reference/basic_stream_file__rebind_executor/other.html
-/doc/asio/reference/basic_stream_file/release/
-/doc/asio/reference/basic_stream_file/release.html
-/doc/asio/reference/basic_stream_file/release/overload1.html
-/doc/asio/reference/basic_stream_file/release/overload2.html
-/doc/asio/reference/basic_stream_file/resize/
-/doc/asio/reference/basic_stream_file/resize.html
-/doc/asio/reference/basic_stream_file/resize/overload1.html
-/doc/asio/reference/basic_stream_file/resize/overload2.html
-/doc/asio/reference/basic_stream_file/seek/
-/doc/asio/reference/basic_stream_file/seek_basis.html
-/doc/asio/reference/basic_stream_file/seek.html
-/doc/asio/reference/basic_stream_file/seek/overload1.html
-/doc/asio/reference/basic_stream_file/seek/overload2.html
-/doc/asio/reference/basic_stream_file/size/
-/doc/asio/reference/basic_stream_file/size.html
-/doc/asio/reference/basic_stream_file/size/overload1.html
-/doc/asio/reference/basic_stream_file/size/overload2.html
-/doc/asio/reference/basic_stream_file/sync_all/
-/doc/asio/reference/basic_stream_file/sync_all.html
-/doc/asio/reference/basic_stream_file/sync_all_on_write.html
-/doc/asio/reference/basic_stream_file/sync_all/overload1.html
-/doc/asio/reference/basic_stream_file/sync_all/overload2.html
-/doc/asio/reference/basic_stream_file/sync_data/
-/doc/asio/reference/basic_stream_file/sync_data.html
-/doc/asio/reference/basic_stream_file/sync_data/overload1.html
-/doc/asio/reference/basic_stream_file/sync_data/overload2.html
-/doc/asio/reference/basic_stream_file/truncate.html
-/doc/asio/reference/basic_stream_file/write_only.html
-/doc/asio/reference/basic_stream_file/write_some/
-/doc/asio/reference/basic_stream_file/write_some.html
-/doc/asio/reference/basic_stream_file/write_some/overload1.html
-/doc/asio/reference/basic_stream_file/write_some/overload2.html
-/doc/asio/reference/basic_stream_socket/
-/doc/asio/reference/basic_stream_socket/assign/
-/doc/asio/reference/basic_stream_socket/assign.html
-/doc/asio/reference/basic_stream_socket/assign/overload1.html
-/doc/asio/reference/basic_stream_socket/assign/overload2.html
-/doc/asio/reference/basic_stream_socket/async_connect.html
-/doc/asio/reference/basic_stream_socket/async_read_some.html
-/doc/asio/reference/basic_stream_socket/async_receive/
-/doc/asio/reference/basic_stream_socket/async_receive.html
-/doc/asio/reference/basic_stream_socket/async_receive/overload1.html
-/doc/asio/reference/basic_stream_socket/async_receive/overload2.html
-/doc/asio/reference/basic_stream_socket/async_send/
-/doc/asio/reference/basic_stream_socket/async_send.html
-/doc/asio/reference/basic_stream_socket/async_send/overload1.html
-/doc/asio/reference/basic_stream_socket/async_send/overload2.html
-/doc/asio/reference/basic_stream_socket/async_wait.html
-/doc/asio/reference/basic_stream_socket/async_write_some.html
-/doc/asio/reference/basic_stream_socket/at_mark/
-/doc/asio/reference/basic_stream_socket/at_mark.html
-/doc/asio/reference/basic_stream_socket/at_mark/overload1.html
-/doc/asio/reference/basic_stream_socket/at_mark/overload2.html
-/doc/asio/reference/basic_stream_socket/available/
-/doc/asio/reference/basic_stream_socket/available.html
-/doc/asio/reference/basic_stream_socket/available/overload1.html
-/doc/asio/reference/basic_stream_socket/available/overload2.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/
-/doc/asio/reference/basic_stream_socket/_basic_stream_socket.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload10.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload1.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload2.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload3.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload4.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload5.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload6.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload7.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload8.html
-/doc/asio/reference/basic_stream_socket/basic_stream_socket/overload9.html
-/doc/asio/reference/basic_stream_socket/bind/
-/doc/asio/reference/basic_stream_socket/bind.html
-/doc/asio/reference/basic_stream_socket/bind/overload1.html
-/doc/asio/reference/basic_stream_socket/bind/overload2.html
-/doc/asio/reference/basic_stream_socket/broadcast.html
-/doc/asio/reference/basic_stream_socket/bytes_readable.html
-/doc/asio/reference/basic_stream_socket/cancel/
-/doc/asio/reference/basic_stream_socket/cancel.html
-/doc/asio/reference/basic_stream_socket/cancel/overload1.html
-/doc/asio/reference/basic_stream_socket/cancel/overload2.html
-/doc/asio/reference/basic_stream_socket/close/
-/doc/asio/reference/basic_stream_socket/close.html
-/doc/asio/reference/basic_stream_socket/close/overload1.html
-/doc/asio/reference/basic_stream_socket/close/overload2.html
-/doc/asio/reference/basic_stream_socket/connect/
-/doc/asio/reference/basic_stream_socket/connect.html
-/doc/asio/reference/basic_stream_socket/connect/overload1.html
-/doc/asio/reference/basic_stream_socket/connect/overload2.html
-/doc/asio/reference/basic_stream_socket/debug.html
-/doc/asio/reference/basic_stream_socket/do_not_route.html
-/doc/asio/reference/basic_stream_socket/enable_connection_aborted.html
-/doc/asio/reference/basic_stream_socket/endpoint_type.html
-/doc/asio/reference/basic_stream_socket/executor_type.html
-/doc/asio/reference/basic_stream_socket/get_executor.html
-/doc/asio/reference/basic_stream_socket/get_option/
-/doc/asio/reference/basic_stream_socket/get_option.html
-/doc/asio/reference/basic_stream_socket/get_option/overload1.html
-/doc/asio/reference/basic_stream_socket/get_option/overload2.html
-/doc/asio/reference/basic_stream_socket.html
-/doc/asio/reference/basic_stream_socket/io_control/
-/doc/asio/reference/basic_stream_socket/io_control.html
-/doc/asio/reference/basic_stream_socket/io_control/overload1.html
-/doc/asio/reference/basic_stream_socket/io_control/overload2.html
-/doc/asio/reference/basic_stream_socket/is_open.html
-/doc/asio/reference/basic_stream_socket/keep_alive.html
-/doc/asio/reference/basic_stream_socket/linger.html
-/doc/asio/reference/basic_stream_socket/local_endpoint/
-/doc/asio/reference/basic_stream_socket/local_endpoint.html
-/doc/asio/reference/basic_stream_socket/local_endpoint/overload1.html
-/doc/asio/reference/basic_stream_socket/local_endpoint/overload2.html
-/doc/asio/reference/basic_stream_socket/lowest_layer/
-/doc/asio/reference/basic_stream_socket/lowest_layer.html
-/doc/asio/reference/basic_stream_socket/lowest_layer/overload1.html
-/doc/asio/reference/basic_stream_socket/lowest_layer/overload2.html
-/doc/asio/reference/basic_stream_socket/lowest_layer_type.html
-/doc/asio/reference/basic_stream_socket/max_connections.html
-/doc/asio/reference/basic_stream_socket/max_listen_connections.html
-/doc/asio/reference/basic_stream_socket/message_do_not_route.html
-/doc/asio/reference/basic_stream_socket/message_end_of_record.html
-/doc/asio/reference/basic_stream_socket/message_flags.html
-/doc/asio/reference/basic_stream_socket/message_out_of_band.html
-/doc/asio/reference/basic_stream_socket/message_peek.html
-/doc/asio/reference/basic_stream_socket/native_handle.html
-/doc/asio/reference/basic_stream_socket/native_handle_type.html
-/doc/asio/reference/basic_stream_socket/native_non_blocking/
-/doc/asio/reference/basic_stream_socket/native_non_blocking.html
-/doc/asio/reference/basic_stream_socket/native_non_blocking/overload1.html
-/doc/asio/reference/basic_stream_socket/native_non_blocking/overload2.html
-/doc/asio/reference/basic_stream_socket/native_non_blocking/overload3.html
-/doc/asio/reference/basic_stream_socket/non_blocking/
-/doc/asio/reference/basic_stream_socket/non_blocking.html
-/doc/asio/reference/basic_stream_socket/non_blocking/overload1.html
-/doc/asio/reference/basic_stream_socket/non_blocking/overload2.html
-/doc/asio/reference/basic_stream_socket/non_blocking/overload3.html
-/doc/asio/reference/basic_stream_socket/open/
-/doc/asio/reference/basic_stream_socket/open.html
-/doc/asio/reference/basic_stream_socket/open/overload1.html
-/doc/asio/reference/basic_stream_socket/open/overload2.html
-/doc/asio/reference/basic_stream_socket/operator_eq_/
-/doc/asio/reference/basic_stream_socket/operator_eq_.html
-/doc/asio/reference/basic_stream_socket/operator_eq_/overload1.html
-/doc/asio/reference/basic_stream_socket/operator_eq_/overload2.html
-/doc/asio/reference/basic_stream_socket/out_of_band_inline.html
-/doc/asio/reference/basic_stream_socket/protocol_type.html
-/doc/asio/reference/basic_stream_socket/read_some/
-/doc/asio/reference/basic_stream_socket/read_some.html
-/doc/asio/reference/basic_stream_socket/read_some/overload1.html
-/doc/asio/reference/basic_stream_socket/read_some/overload2.html
-/doc/asio/reference/basic_stream_socket__rebind_executor/
-/doc/asio/reference/basic_stream_socket__rebind_executor.html
-/doc/asio/reference/basic_stream_socket__rebind_executor/other.html
-/doc/asio/reference/basic_stream_socket/receive/
-/doc/asio/reference/basic_stream_socket/receive_buffer_size.html
-/doc/asio/reference/basic_stream_socket/receive.html
-/doc/asio/reference/basic_stream_socket/receive_low_watermark.html
-/doc/asio/reference/basic_stream_socket/receive/overload1.html
-/doc/asio/reference/basic_stream_socket/receive/overload2.html
-/doc/asio/reference/basic_stream_socket/receive/overload3.html
-/doc/asio/reference/basic_stream_socket/release/
-/doc/asio/reference/basic_stream_socket/release.html
-/doc/asio/reference/basic_stream_socket/release/overload1.html
-/doc/asio/reference/basic_stream_socket/release/overload2.html
-/doc/asio/reference/basic_stream_socket/remote_endpoint/
-/doc/asio/reference/basic_stream_socket/remote_endpoint.html
-/doc/asio/reference/basic_stream_socket/remote_endpoint/overload1.html
-/doc/asio/reference/basic_stream_socket/remote_endpoint/overload2.html
-/doc/asio/reference/basic_stream_socket/reuse_address.html
-/doc/asio/reference/basic_stream_socket/send/
-/doc/asio/reference/basic_stream_socket/send_buffer_size.html
-/doc/asio/reference/basic_stream_socket/send.html
-/doc/asio/reference/basic_stream_socket/send_low_watermark.html
-/doc/asio/reference/basic_stream_socket/send/overload1.html
-/doc/asio/reference/basic_stream_socket/send/overload2.html
-/doc/asio/reference/basic_stream_socket/send/overload3.html
-/doc/asio/reference/basic_stream_socket/set_option/
-/doc/asio/reference/basic_stream_socket/set_option.html
-/doc/asio/reference/basic_stream_socket/set_option/overload1.html
-/doc/asio/reference/basic_stream_socket/set_option/overload2.html
-/doc/asio/reference/basic_stream_socket/shutdown/
-/doc/asio/reference/basic_stream_socket/shutdown.html
-/doc/asio/reference/basic_stream_socket/shutdown/overload1.html
-/doc/asio/reference/basic_stream_socket/shutdown/overload2.html
-/doc/asio/reference/basic_stream_socket/shutdown_type.html
-/doc/asio/reference/basic_stream_socket/wait/
-/doc/asio/reference/basic_stream_socket/wait.html
-/doc/asio/reference/basic_stream_socket/wait/overload1.html
-/doc/asio/reference/basic_stream_socket/wait/overload2.html
-/doc/asio/reference/basic_stream_socket/wait_type.html
-/doc/asio/reference/basic_stream_socket/write_some/
-/doc/asio/reference/basic_stream_socket/write_some.html
-/doc/asio/reference/basic_stream_socket/write_some/overload1.html
-/doc/asio/reference/basic_stream_socket/write_some/overload2.html
-/doc/asio/reference/basic_system_executor/
-/doc/asio/reference/basic_system_executor/basic_system_executor.html
-/doc/asio/reference/basic_system_executor/context.html
-/doc/asio/reference/basic_system_executor/defer.html
-/doc/asio/reference/basic_system_executor/dispatch.html
-/doc/asio/reference/basic_system_executor/execute.html
-/doc/asio/reference/basic_system_executor.html
-/doc/asio/reference/basic_system_executor/on_work_finished.html
-/doc/asio/reference/basic_system_executor/on_work_started.html
-/doc/asio/reference/basic_system_executor/operator_eq__eq_.html
-/doc/asio/reference/basic_system_executor/operator_not__eq_.html
-/doc/asio/reference/basic_system_executor/post.html
-/doc/asio/reference/basic_system_executor/query/
-/doc/asio/reference/basic_system_executor/query.html
-/doc/asio/reference/basic_system_executor/query/overload1.html
-/doc/asio/reference/basic_system_executor/query/overload2.html
-/doc/asio/reference/basic_system_executor/query/overload3.html
-/doc/asio/reference/basic_system_executor/query__static/
-/doc/asio/reference/basic_system_executor/query__static.html
-/doc/asio/reference/basic_system_executor/query__static/overload1.html
-/doc/asio/reference/basic_system_executor/query__static/overload2.html
-/doc/asio/reference/basic_system_executor/query__static/overload3.html
-/doc/asio/reference/basic_system_executor/query__static/overload4.html
-/doc/asio/reference/basic_system_executor/require/
-/doc/asio/reference/basic_system_executor/require.html
-/doc/asio/reference/basic_system_executor/require/overload1.html
-/doc/asio/reference/basic_system_executor/require/overload2.html
-/doc/asio/reference/basic_system_executor/require/overload3.html
-/doc/asio/reference/basic_system_executor/require/overload4.html
-/doc/asio/reference/basic_system_executor/require/overload5.html
-/doc/asio/reference/basic_system_executor/require/overload6.html
-/doc/asio/reference/basic_system_executor/require/overload7.html
-/doc/asio/reference/basic_waitable_timer/
-/doc/asio/reference/basic_waitable_timer/async_wait.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/
-/doc/asio/reference/basic_waitable_timer/_basic_waitable_timer.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload1.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload2.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload3.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload4.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload5.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload6.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload7.html
-/doc/asio/reference/basic_waitable_timer/basic_waitable_timer/overload8.html
-/doc/asio/reference/basic_waitable_timer/cancel/
-/doc/asio/reference/basic_waitable_timer/cancel.html
-/doc/asio/reference/basic_waitable_timer/cancel_one/
-/doc/asio/reference/basic_waitable_timer/cancel_one.html
-/doc/asio/reference/basic_waitable_timer/cancel_one/overload1.html
-/doc/asio/reference/basic_waitable_timer/cancel_one/overload2.html
-/doc/asio/reference/basic_waitable_timer/cancel/overload1.html
-/doc/asio/reference/basic_waitable_timer/cancel/overload2.html
-/doc/asio/reference/basic_waitable_timer/clock_type.html
-/doc/asio/reference/basic_waitable_timer/duration.html
-/doc/asio/reference/basic_waitable_timer/executor_type.html
-/doc/asio/reference/basic_waitable_timer/expires_after.html
-/doc/asio/reference/basic_waitable_timer/expires_at/
-/doc/asio/reference/basic_waitable_timer/expires_at.html
-/doc/asio/reference/basic_waitable_timer/expires_at/overload1.html
-/doc/asio/reference/basic_waitable_timer/expires_at/overload2.html
-/doc/asio/reference/basic_waitable_timer/expires_at/overload3.html
-/doc/asio/reference/basic_waitable_timer/expires_from_now/
-/doc/asio/reference/basic_waitable_timer/expires_from_now.html
-/doc/asio/reference/basic_waitable_timer/expires_from_now/overload1.html
-/doc/asio/reference/basic_waitable_timer/expires_from_now/overload2.html
-/doc/asio/reference/basic_waitable_timer/expires_from_now/overload3.html
-/doc/asio/reference/basic_waitable_timer/expiry.html
-/doc/asio/reference/basic_waitable_timer/get_executor.html
-/doc/asio/reference/basic_waitable_timer.html
-/doc/asio/reference/basic_waitable_timer/operator_eq_/
-/doc/asio/reference/basic_waitable_timer/operator_eq_.html
-/doc/asio/reference/basic_waitable_timer/operator_eq_/overload1.html
-/doc/asio/reference/basic_waitable_timer/operator_eq_/overload2.html
-/doc/asio/reference/basic_waitable_timer__rebind_executor/
-/doc/asio/reference/basic_waitable_timer__rebind_executor.html
-/doc/asio/reference/basic_waitable_timer__rebind_executor/other.html
-/doc/asio/reference/basic_waitable_timer/time_point.html
-/doc/asio/reference/basic_waitable_timer/traits_type.html
-/doc/asio/reference/basic_waitable_timer/wait/
-/doc/asio/reference/basic_waitable_timer/wait.html
-/doc/asio/reference/basic_waitable_timer/wait/overload1.html
-/doc/asio/reference/basic_waitable_timer/wait/overload2.html
-/doc/asio/reference/basic_writable_pipe/
-/doc/asio/reference/basic_writable_pipe/assign/
-/doc/asio/reference/basic_writable_pipe/assign.html
-/doc/asio/reference/basic_writable_pipe/assign/overload1.html
-/doc/asio/reference/basic_writable_pipe/assign/overload2.html
-/doc/asio/reference/basic_writable_pipe/async_write_some.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/
-/doc/asio/reference/basic_writable_pipe/_basic_writable_pipe.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload1.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload2.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload3.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload4.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload5.html
-/doc/asio/reference/basic_writable_pipe/basic_writable_pipe/overload6.html
-/doc/asio/reference/basic_writable_pipe/cancel/
-/doc/asio/reference/basic_writable_pipe/cancel.html
-/doc/asio/reference/basic_writable_pipe/cancel/overload1.html
-/doc/asio/reference/basic_writable_pipe/cancel/overload2.html
-/doc/asio/reference/basic_writable_pipe/close/
-/doc/asio/reference/basic_writable_pipe/close.html
-/doc/asio/reference/basic_writable_pipe/close/overload1.html
-/doc/asio/reference/basic_writable_pipe/close/overload2.html
-/doc/asio/reference/basic_writable_pipe/executor_type.html
-/doc/asio/reference/basic_writable_pipe/get_executor.html
-/doc/asio/reference/basic_writable_pipe.html
-/doc/asio/reference/basic_writable_pipe/is_open.html
-/doc/asio/reference/basic_writable_pipe/lowest_layer/
-/doc/asio/reference/basic_writable_pipe/lowest_layer.html
-/doc/asio/reference/basic_writable_pipe/lowest_layer/overload1.html
-/doc/asio/reference/basic_writable_pipe/lowest_layer/overload2.html
-/doc/asio/reference/basic_writable_pipe/lowest_layer_type.html
-/doc/asio/reference/basic_writable_pipe/native_handle.html
-/doc/asio/reference/basic_writable_pipe/native_handle_type.html
-/doc/asio/reference/basic_writable_pipe/operator_eq_/
-/doc/asio/reference/basic_writable_pipe/operator_eq_.html
-/doc/asio/reference/basic_writable_pipe/operator_eq_/overload1.html
-/doc/asio/reference/basic_writable_pipe/operator_eq_/overload2.html
-/doc/asio/reference/basic_writable_pipe__rebind_executor/
-/doc/asio/reference/basic_writable_pipe__rebind_executor.html
-/doc/asio/reference/basic_writable_pipe__rebind_executor/other.html
-/doc/asio/reference/basic_writable_pipe/release/
-/doc/asio/reference/basic_writable_pipe/release.html
-/doc/asio/reference/basic_writable_pipe/release/overload1.html
-/doc/asio/reference/basic_writable_pipe/release/overload2.html
-/doc/asio/reference/basic_writable_pipe/write_some/
-/doc/asio/reference/basic_writable_pipe/write_some.html
-/doc/asio/reference/basic_writable_pipe/write_some/overload1.html
-/doc/asio/reference/basic_writable_pipe/write_some/overload2.html
-/doc/asio/reference/basic_yield_context/
-/doc/asio/reference/basic_yield_context/basic_yield_context.html
-/doc/asio/reference/basic_yield_context/cancellation_slot_type.html
-/doc/asio/reference/basic_yield_context/cancelled.html
-/doc/asio/reference/basic_yield_context/executor_type.html
-/doc/asio/reference/basic_yield_context/get_cancellation_slot.html
-/doc/asio/reference/basic_yield_context/get_cancellation_state.html
-/doc/asio/reference/basic_yield_context/get_executor.html
-/doc/asio/reference/basic_yield_context.html
-/doc/asio/reference/basic_yield_context/operator_lb__rb_.html
-/doc/asio/reference/basic_yield_context/reset_cancellation_state/
-/doc/asio/reference/basic_yield_context/reset_cancellation_state.html
-/doc/asio/reference/basic_yield_context/reset_cancellation_state/overload1.html
-/doc/asio/reference/basic_yield_context/reset_cancellation_state/overload2.html
-/doc/asio/reference/basic_yield_context/reset_cancellation_state/overload3.html
-/doc/asio/reference/basic_yield_context/throw_if_cancelled/
-/doc/asio/reference/basic_yield_context/throw_if_cancelled.html
-/doc/asio/reference/basic_yield_context/throw_if_cancelled/overload1.html
-/doc/asio/reference/basic_yield_context/throw_if_cancelled/overload2.html
-/doc/asio/reference/bind_allocator/
-/doc/asio/reference/bind_allocator.html
-/doc/asio/reference/bind_allocator/overload1.html
-/doc/asio/reference/bind_allocator/overload2.html
-/doc/asio/reference/bind_cancellation_slot/
-/doc/asio/reference/bind_cancellation_slot.html
-/doc/asio/reference/bind_cancellation_slot/overload1.html
-/doc/asio/reference/bind_cancellation_slot/overload2.html
-/doc/asio/reference/bind_executor/
-/doc/asio/reference/bind_executor.html
-/doc/asio/reference/bind_executor/overload1.html
-/doc/asio/reference/bind_executor/overload2.html
-/doc/asio/reference/bind_executor/overload3.html
-/doc/asio/reference/bind_executor/overload4.html
-/doc/asio/reference/bind_immediate_executor/
-/doc/asio/reference/bind_immediate_executor.html
-/doc/asio/reference/bind_immediate_executor/overload1.html
-/doc/asio/reference/bind_immediate_executor/overload2.html
-/doc/asio/reference/buffer/
-/doc/asio/reference/buffer_cast/
-/doc/asio/reference/buffer_cast.html
-/doc/asio/reference/buffer_cast/overload1.html
-/doc/asio/reference/buffer_cast/overload2.html
-/doc/asio/reference/buffer_copy/
-/doc/asio/reference/buffer_copy.html
-/doc/asio/reference/buffer_copy/overload1.html
-/doc/asio/reference/buffer_copy/overload2.html
-/doc/asio/reference/BufferedHandshakeHandler.html
-/doc/asio/reference/BufferedHandshakeToken.html
-/doc/asio/reference/buffered_read_stream/
-/doc/asio/reference/buffered_read_stream/async_fill.html
-/doc/asio/reference/buffered_read_stream/async_read_some.html
-/doc/asio/reference/buffered_read_stream/async_write_some.html
-/doc/asio/reference/buffered_read_stream/buffered_read_stream/
-/doc/asio/reference/buffered_read_stream/buffered_read_stream.html
-/doc/asio/reference/buffered_read_stream/buffered_read_stream/overload1.html
-/doc/asio/reference/buffered_read_stream/buffered_read_stream/overload2.html
-/doc/asio/reference/buffered_read_stream/close/
-/doc/asio/reference/buffered_read_stream/close.html
-/doc/asio/reference/buffered_read_stream/close/overload1.html
-/doc/asio/reference/buffered_read_stream/close/overload2.html
-/doc/asio/reference/buffered_read_stream/default_buffer_size.html
-/doc/asio/reference/buffered_read_stream/executor_type.html
-/doc/asio/reference/buffered_read_stream/fill/
-/doc/asio/reference/buffered_read_stream/fill.html
-/doc/asio/reference/buffered_read_stream/fill/overload1.html
-/doc/asio/reference/buffered_read_stream/fill/overload2.html
-/doc/asio/reference/buffered_read_stream/get_executor.html
-/doc/asio/reference/buffered_read_stream.html
-/doc/asio/reference/buffered_read_stream/in_avail/
-/doc/asio/reference/buffered_read_stream/in_avail.html
-/doc/asio/reference/buffered_read_stream/in_avail/overload1.html
-/doc/asio/reference/buffered_read_stream/in_avail/overload2.html
-/doc/asio/reference/buffered_read_stream/lowest_layer/
-/doc/asio/reference/buffered_read_stream/lowest_layer.html
-/doc/asio/reference/buffered_read_stream/lowest_layer/overload1.html
-/doc/asio/reference/buffered_read_stream/lowest_layer/overload2.html
-/doc/asio/reference/buffered_read_stream/lowest_layer_type.html
-/doc/asio/reference/buffered_read_stream/next_layer.html
-/doc/asio/reference/buffered_read_stream/next_layer_type.html
-/doc/asio/reference/buffered_read_stream/peek/
-/doc/asio/reference/buffered_read_stream/peek.html
-/doc/asio/reference/buffered_read_stream/peek/overload1.html
-/doc/asio/reference/buffered_read_stream/peek/overload2.html
-/doc/asio/reference/buffered_read_stream/read_some/
-/doc/asio/reference/buffered_read_stream/read_some.html
-/doc/asio/reference/buffered_read_stream/read_some/overload1.html
-/doc/asio/reference/buffered_read_stream/read_some/overload2.html
-/doc/asio/reference/buffered_read_stream/write_some/
-/doc/asio/reference/buffered_read_stream/write_some.html
-/doc/asio/reference/buffered_read_stream/write_some/overload1.html
-/doc/asio/reference/buffered_read_stream/write_some/overload2.html
-/doc/asio/reference/buffered_stream/
-/doc/asio/reference/buffered_stream/async_fill.html
-/doc/asio/reference/buffered_stream/async_flush.html
-/doc/asio/reference/buffered_stream/async_read_some.html
-/doc/asio/reference/buffered_stream/async_write_some.html
-/doc/asio/reference/buffered_stream/buffered_stream/
-/doc/asio/reference/buffered_stream/buffered_stream.html
-/doc/asio/reference/buffered_stream/buffered_stream/overload1.html
-/doc/asio/reference/buffered_stream/buffered_stream/overload2.html
-/doc/asio/reference/buffered_stream/close/
-/doc/asio/reference/buffered_stream/close.html
-/doc/asio/reference/buffered_stream/close/overload1.html
-/doc/asio/reference/buffered_stream/close/overload2.html
-/doc/asio/reference/buffered_stream/executor_type.html
-/doc/asio/reference/buffered_stream/fill/
-/doc/asio/reference/buffered_stream/fill.html
-/doc/asio/reference/buffered_stream/fill/overload1.html
-/doc/asio/reference/buffered_stream/fill/overload2.html
-/doc/asio/reference/buffered_stream/flush/
-/doc/asio/reference/buffered_stream/flush.html
-/doc/asio/reference/buffered_stream/flush/overload1.html
-/doc/asio/reference/buffered_stream/flush/overload2.html
-/doc/asio/reference/buffered_stream/get_executor.html
-/doc/asio/reference/buffered_stream.html
-/doc/asio/reference/buffered_stream/in_avail/
-/doc/asio/reference/buffered_stream/in_avail.html
-/doc/asio/reference/buffered_stream/in_avail/overload1.html
-/doc/asio/reference/buffered_stream/in_avail/overload2.html
-/doc/asio/reference/buffered_stream/lowest_layer/
-/doc/asio/reference/buffered_stream/lowest_layer.html
-/doc/asio/reference/buffered_stream/lowest_layer/overload1.html
-/doc/asio/reference/buffered_stream/lowest_layer/overload2.html
-/doc/asio/reference/buffered_stream/lowest_layer_type.html
-/doc/asio/reference/buffered_stream/next_layer.html
-/doc/asio/reference/buffered_stream/next_layer_type.html
-/doc/asio/reference/buffered_stream/peek/
-/doc/asio/reference/buffered_stream/peek.html
-/doc/asio/reference/buffered_stream/peek/overload1.html
-/doc/asio/reference/buffered_stream/peek/overload2.html
-/doc/asio/reference/buffered_stream/read_some/
-/doc/asio/reference/buffered_stream/read_some.html
-/doc/asio/reference/buffered_stream/read_some/overload1.html
-/doc/asio/reference/buffered_stream/read_some/overload2.html
-/doc/asio/reference/buffered_stream/write_some/
-/doc/asio/reference/buffered_stream/write_some.html
-/doc/asio/reference/buffered_stream/write_some/overload1.html
-/doc/asio/reference/buffered_stream/write_some/overload2.html
-/doc/asio/reference/buffered_write_stream/
-/doc/asio/reference/buffered_write_stream/async_flush.html
-/doc/asio/reference/buffered_write_stream/async_read_some.html
-/doc/asio/reference/buffered_write_stream/async_write_some.html
-/doc/asio/reference/buffered_write_stream/buffered_write_stream/
-/doc/asio/reference/buffered_write_stream/buffered_write_stream.html
-/doc/asio/reference/buffered_write_stream/buffered_write_stream/overload1.html
-/doc/asio/reference/buffered_write_stream/buffered_write_stream/overload2.html
-/doc/asio/reference/buffered_write_stream/close/
-/doc/asio/reference/buffered_write_stream/close.html
-/doc/asio/reference/buffered_write_stream/close/overload1.html
-/doc/asio/reference/buffered_write_stream/close/overload2.html
-/doc/asio/reference/buffered_write_stream/default_buffer_size.html
-/doc/asio/reference/buffered_write_stream/executor_type.html
-/doc/asio/reference/buffered_write_stream/flush/
-/doc/asio/reference/buffered_write_stream/flush.html
-/doc/asio/reference/buffered_write_stream/flush/overload1.html
-/doc/asio/reference/buffered_write_stream/flush/overload2.html
-/doc/asio/reference/buffered_write_stream/get_executor.html
-/doc/asio/reference/buffered_write_stream.html
-/doc/asio/reference/buffered_write_stream/in_avail/
-/doc/asio/reference/buffered_write_stream/in_avail.html
-/doc/asio/reference/buffered_write_stream/in_avail/overload1.html
-/doc/asio/reference/buffered_write_stream/in_avail/overload2.html
-/doc/asio/reference/buffered_write_stream/lowest_layer/
-/doc/asio/reference/buffered_write_stream/lowest_layer.html
-/doc/asio/reference/buffered_write_stream/lowest_layer/overload1.html
-/doc/asio/reference/buffered_write_stream/lowest_layer/overload2.html
-/doc/asio/reference/buffered_write_stream/lowest_layer_type.html
-/doc/asio/reference/buffered_write_stream/next_layer.html
-/doc/asio/reference/buffered_write_stream/next_layer_type.html
-/doc/asio/reference/buffered_write_stream/peek/
-/doc/asio/reference/buffered_write_stream/peek.html
-/doc/asio/reference/buffered_write_stream/peek/overload1.html
-/doc/asio/reference/buffered_write_stream/peek/overload2.html
-/doc/asio/reference/buffered_write_stream/read_some/
-/doc/asio/reference/buffered_write_stream/read_some.html
-/doc/asio/reference/buffered_write_stream/read_some/overload1.html
-/doc/asio/reference/buffered_write_stream/read_some/overload2.html
-/doc/asio/reference/buffered_write_stream/write_some/
-/doc/asio/reference/buffered_write_stream/write_some.html
-/doc/asio/reference/buffered_write_stream/write_some/overload1.html
-/doc/asio/reference/buffered_write_stream/write_some/overload2.html
-/doc/asio/reference/buffer.html
-/doc/asio/reference/buffer_literals__operator_quot__quot__buf/
-/doc/asio/reference/buffer_literals__operator_quot__quot__buf.html
-/doc/asio/reference/buffer_literals__operator_quot__quot__buf/overload1.html
-/doc/asio/reference/buffer_literals__operator_quot__quot__buf/overload2.html
-/doc/asio/reference/buffer/overload10.html
-/doc/asio/reference/buffer/overload11.html
-/doc/asio/reference/buffer/overload12.html
-/doc/asio/reference/buffer/overload13.html
-/doc/asio/reference/buffer/overload14.html
-/doc/asio/reference/buffer/overload15.html
-/doc/asio/reference/buffer/overload16.html
-/doc/asio/reference/buffer/overload17.html
-/doc/asio/reference/buffer/overload18.html
-/doc/asio/reference/buffer/overload19.html
-/doc/asio/reference/buffer/overload1.html
-/doc/asio/reference/buffer/overload20.html
-/doc/asio/reference/buffer/overload21.html
-/doc/asio/reference/buffer/overload22.html
-/doc/asio/reference/buffer/overload23.html
-/doc/asio/reference/buffer/overload24.html
-/doc/asio/reference/buffer/overload25.html
-/doc/asio/reference/buffer/overload26.html
-/doc/asio/reference/buffer/overload27.html
-/doc/asio/reference/buffer/overload28.html
-/doc/asio/reference/buffer/overload29.html
-/doc/asio/reference/buffer/overload2.html
-/doc/asio/reference/buffer/overload30.html
-/doc/asio/reference/buffer/overload31.html
-/doc/asio/reference/buffer/overload32.html
-/doc/asio/reference/buffer/overload33.html
-/doc/asio/reference/buffer/overload34.html
-/doc/asio/reference/buffer/overload35.html
-/doc/asio/reference/buffer/overload36.html
-/doc/asio/reference/buffer/overload37.html
-/doc/asio/reference/buffer/overload38.html
-/doc/asio/reference/buffer/overload3.html
-/doc/asio/reference/buffer/overload4.html
-/doc/asio/reference/buffer/overload5.html
-/doc/asio/reference/buffer/overload6.html
-/doc/asio/reference/buffer/overload7.html
-/doc/asio/reference/buffer/overload8.html
-/doc/asio/reference/buffer/overload9.html
-/doc/asio/reference/buffer_registration/
-/doc/asio/reference/buffer_registration/allocator_type.html
-/doc/asio/reference/buffer_registration/at.html
-/doc/asio/reference/buffer_registration/begin.html
-/doc/asio/reference/buffer_registration/buffer_registration/
-/doc/asio/reference/buffer_registration/_buffer_registration.html
-/doc/asio/reference/buffer_registration/buffer_registration.html
-/doc/asio/reference/buffer_registration/buffer_registration/overload1.html
-/doc/asio/reference/buffer_registration/buffer_registration/overload2.html
-/doc/asio/reference/buffer_registration/buffer_registration/overload3.html
-/doc/asio/reference/buffer_registration/cbegin.html
-/doc/asio/reference/buffer_registration/cend.html
-/doc/asio/reference/buffer_registration/const_iterator.html
-/doc/asio/reference/buffer_registration/end.html
-/doc/asio/reference/buffer_registration.html
-/doc/asio/reference/buffer_registration/iterator.html
-/doc/asio/reference/buffer_registration/operator_eq_.html
-/doc/asio/reference/buffer_registration/operator_lb__rb_.html
-/doc/asio/reference/buffer_registration/size.html
-/doc/asio/reference/buffers_begin.html
-/doc/asio/reference/buffers_end.html
-/doc/asio/reference/buffer_sequence_begin/
-/doc/asio/reference/buffer_sequence_begin.html
-/doc/asio/reference/buffer_sequence_begin/overload1.html
-/doc/asio/reference/buffer_sequence_begin/overload2.html
-/doc/asio/reference/buffer_sequence_begin/overload3.html
-/doc/asio/reference/buffer_sequence_begin/overload4.html
-/doc/asio/reference/buffer_sequence_begin/overload5.html
-/doc/asio/reference/buffer_sequence_begin/overload6.html
-/doc/asio/reference/buffer_sequence_end/
-/doc/asio/reference/buffer_sequence_end.html
-/doc/asio/reference/buffer_sequence_end/overload1.html
-/doc/asio/reference/buffer_sequence_end/overload2.html
-/doc/asio/reference/buffer_sequence_end/overload3.html
-/doc/asio/reference/buffer_sequence_end/overload4.html
-/doc/asio/reference/buffer_sequence_end/overload5.html
-/doc/asio/reference/buffer_sequence_end/overload6.html
-/doc/asio/reference/buffers_iterator/
-/doc/asio/reference/buffers_iterator/begin.html
-/doc/asio/reference/buffers_iterator/buffers_iterator.html
-/doc/asio/reference/buffers_iterator/difference_type.html
-/doc/asio/reference/buffers_iterator/end.html
-/doc/asio/reference/buffers_iterator.html
-/doc/asio/reference/buffers_iterator/iterator_category.html
-/doc/asio/reference/buffers_iterator/operator_arrow_.html
-/doc/asio/reference/buffers_iterator/operator_eq__eq_.html
-/doc/asio/reference/buffers_iterator/operator_gt__eq_.html
-/doc/asio/reference/buffers_iterator/operator_gt_.html
-/doc/asio/reference/buffers_iterator/operator_lb__rb_.html
-/doc/asio/reference/buffers_iterator/operator_lt__eq_.html
-/doc/asio/reference/buffers_iterator/operator_lt_.html
-/doc/asio/reference/buffers_iterator/operator_minus_/
-/doc/asio/reference/buffers_iterator/operator_minus__eq_.html
-/doc/asio/reference/buffers_iterator/operator_minus_.html
-/doc/asio/reference/buffers_iterator/operator_minus__minus_/
-/doc/asio/reference/buffers_iterator/operator_minus__minus_.html
-/doc/asio/reference/buffers_iterator/operator_minus__minus_/overload1.html
-/doc/asio/reference/buffers_iterator/operator_minus__minus_/overload2.html
-/doc/asio/reference/buffers_iterator/operator_minus_/overload1.html
-/doc/asio/reference/buffers_iterator/operator_minus_/overload2.html
-/doc/asio/reference/buffers_iterator/operator_not__eq_.html
-/doc/asio/reference/buffers_iterator/operator_plus_/
-/doc/asio/reference/buffers_iterator/operator_plus__eq_.html
-/doc/asio/reference/buffers_iterator/operator_plus_.html
-/doc/asio/reference/buffers_iterator/operator_plus_/overload1.html
-/doc/asio/reference/buffers_iterator/operator_plus_/overload2.html
-/doc/asio/reference/buffers_iterator/operator_plus__plus_/
-/doc/asio/reference/buffers_iterator/operator_plus__plus_.html
-/doc/asio/reference/buffers_iterator/operator_plus__plus_/overload1.html
-/doc/asio/reference/buffers_iterator/operator_plus__plus_/overload2.html
-/doc/asio/reference/buffers_iterator/operator_star_.html
-/doc/asio/reference/buffers_iterator/pointer.html
-/doc/asio/reference/buffers_iterator/reference.html
-/doc/asio/reference/buffers_iterator/value_type.html
-/doc/asio/reference/buffer_size.html
-/doc/asio/reference/cancel_after/
-/doc/asio/reference/cancel_after.html
-/doc/asio/reference/cancel_after/overload1.html
-/doc/asio/reference/cancel_after/overload2.html
-/doc/asio/reference/cancel_after/overload3.html
-/doc/asio/reference/cancel_after/overload4.html
-/doc/asio/reference/cancel_after/overload5.html
-/doc/asio/reference/cancel_after/overload6.html
-/doc/asio/reference/cancel_after_t/
-/doc/asio/reference/cancel_after_t/cancel_after_t.html
-/doc/asio/reference/cancel_after_t/cancel_type_.html
-/doc/asio/reference/cancel_after_t.html
-/doc/asio/reference/cancel_after_timer/
-/doc/asio/reference/cancel_after_timer/cancel_after_timer.html
-/doc/asio/reference/cancel_after_timer/cancel_type_.html
-/doc/asio/reference/cancel_after_timer.html
-/doc/asio/reference/cancel_after_timer/timeout_.html
-/doc/asio/reference/cancel_after_timer/timer_.html
-/doc/asio/reference/cancel_after_timer/token_.html
-/doc/asio/reference/cancel_after_t/timeout_.html
-/doc/asio/reference/cancel_after_t/token_.html
-/doc/asio/reference/cancel_at/
-/doc/asio/reference/cancel_at.html
-/doc/asio/reference/cancel_at/overload1.html
-/doc/asio/reference/cancel_at/overload2.html
-/doc/asio/reference/cancel_at/overload3.html
-/doc/asio/reference/cancel_at/overload4.html
-/doc/asio/reference/cancel_at/overload5.html
-/doc/asio/reference/cancel_at/overload6.html
-/doc/asio/reference/cancel_at_t/
-/doc/asio/reference/cancel_at_t/cancel_at_t.html
-/doc/asio/reference/cancel_at_t/cancel_type_.html
-/doc/asio/reference/cancel_at_t/expiry_.html
-/doc/asio/reference/cancel_at_t.html
-/doc/asio/reference/cancel_at_timer/
-/doc/asio/reference/cancel_at_timer/cancel_at_timer.html
-/doc/asio/reference/cancel_at_timer/cancel_type_.html
-/doc/asio/reference/cancel_at_timer/expiry_.html
-/doc/asio/reference/cancel_at_timer.html
-/doc/asio/reference/cancel_at_timer/timer_.html
-/doc/asio/reference/cancel_at_timer/token_.html
-/doc/asio/reference/cancel_at_t/token_.html
-/doc/asio/reference/cancellation_filter/
-/doc/asio/reference/cancellation_filter.html
-/doc/asio/reference/cancellation_filter/operator_lp__rp_.html
-/doc/asio/reference/CancellationHandler.html
-/doc/asio/reference/cancellation_signal/
-/doc/asio/reference/cancellation_signal/_cancellation_signal.html
-/doc/asio/reference/cancellation_signal/cancellation_signal.html
-/doc/asio/reference/cancellation_signal/emit.html
-/doc/asio/reference/cancellation_signal.html
-/doc/asio/reference/cancellation_signal/slot.html
-/doc/asio/reference/cancellation_slot/
-/doc/asio/reference/cancellation_slot/assign.html
-/doc/asio/reference/cancellation_slot_binder/
-/doc/asio/reference/cancellation_slot_binder/argument_type.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/
-/doc/asio/reference/cancellation_slot_binder/_cancellation_slot_binder.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload1.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload2.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload3.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload4.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload5.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload6.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload7.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload8.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload9.html
-/doc/asio/reference/cancellation_slot_binder/cancellation_slot_type.html
-/doc/asio/reference/cancellation_slot_binder/first_argument_type.html
-/doc/asio/reference/cancellation_slot_binder/get/
-/doc/asio/reference/cancellation_slot_binder/get_cancellation_slot.html
-/doc/asio/reference/cancellation_slot_binder/get.html
-/doc/asio/reference/cancellation_slot_binder/get/overload1.html
-/doc/asio/reference/cancellation_slot_binder/get/overload2.html
-/doc/asio/reference/cancellation_slot_binder.html
-/doc/asio/reference/cancellation_slot_binder/operator_lp__rp_/
-/doc/asio/reference/cancellation_slot_binder/operator_lp__rp_.html
-/doc/asio/reference/cancellation_slot_binder/operator_lp__rp_/overload1.html
-/doc/asio/reference/cancellation_slot_binder/operator_lp__rp_/overload2.html
-/doc/asio/reference/cancellation_slot_binder/result_type.html
-/doc/asio/reference/cancellation_slot_binder/second_argument_type.html
-/doc/asio/reference/cancellation_slot_binder/target_type.html
-/doc/asio/reference/cancellation_slot/cancellation_slot.html
-/doc/asio/reference/cancellation_slot/clear.html
-/doc/asio/reference/cancellation_slot/emplace.html
-/doc/asio/reference/cancellation_slot/has_handler.html
-/doc/asio/reference/CancellationSlot.html
-/doc/asio/reference/cancellation_slot.html
-/doc/asio/reference/cancellation_slot/is_connected.html
-/doc/asio/reference/cancellation_slot/operator_eq__eq_.html
-/doc/asio/reference/cancellation_slot/operator_not__eq_.html
-/doc/asio/reference/cancellation_state/
-/doc/asio/reference/cancellation_state/cancellation_state/
-/doc/asio/reference/cancellation_state/cancellation_state.html
-/doc/asio/reference/cancellation_state/cancellation_state/overload1.html
-/doc/asio/reference/cancellation_state/cancellation_state/overload2.html
-/doc/asio/reference/cancellation_state/cancellation_state/overload3.html
-/doc/asio/reference/cancellation_state/cancellation_state/overload4.html
-/doc/asio/reference/cancellation_state/cancelled.html
-/doc/asio/reference/cancellation_state/clear.html
-/doc/asio/reference/cancellation_state.html
-/doc/asio/reference/cancellation_state/slot.html
-/doc/asio/reference/cancellation_type.html
-/doc/asio/reference/cancellation_type_t.html
-/doc/asio/reference/can_prefer.html
-/doc/asio/reference/can_query.html
-/doc/asio/reference/can_require_concept.html
-/doc/asio/reference/can_require.html
-/doc/asio/reference/co_composed.html
-/doc/asio/reference/CompletionCondition.html
-/doc/asio/reference/completion_signature_of/
-/doc/asio/reference/completion_signature_of.html
-/doc/asio/reference/completion_signature_of_t.html
-/doc/asio/reference/completion_signature_of/type.html
-/doc/asio/reference/composed.html
-/doc/asio/reference/connect/
-/doc/asio/reference/ConnectCondition.html
-/doc/asio/reference/ConnectHandler.html
-/doc/asio/reference/connect.html
-/doc/asio/reference/connect/overload10.html
-/doc/asio/reference/connect/overload11.html
-/doc/asio/reference/connect/overload12.html
-/doc/asio/reference/connect/overload1.html
-/doc/asio/reference/connect/overload2.html
-/doc/asio/reference/connect/overload3.html
-/doc/asio/reference/connect/overload4.html
-/doc/asio/reference/connect/overload5.html
-/doc/asio/reference/connect/overload6.html
-/doc/asio/reference/connect/overload7.html
-/doc/asio/reference/connect/overload8.html
-/doc/asio/reference/connect/overload9.html
-/doc/asio/reference/connect_pipe/
-/doc/asio/reference/connect_pipe.html
-/doc/asio/reference/connect_pipe/overload1.html
-/doc/asio/reference/connect_pipe/overload2.html
-/doc/asio/reference/ConnectToken.html
-/doc/asio/reference/consign.html
-/doc/asio/reference/consign_t/
-/doc/asio/reference/consign_t/consign_t.html
-/doc/asio/reference/consign_t.html
-/doc/asio/reference/const_buffer/
-/doc/asio/reference/const_buffer/const_buffer/
-/doc/asio/reference/const_buffer/const_buffer.html
-/doc/asio/reference/const_buffer/const_buffer/overload1.html
-/doc/asio/reference/const_buffer/const_buffer/overload2.html
-/doc/asio/reference/const_buffer/const_buffer/overload3.html
-/doc/asio/reference/const_buffer/data.html
-/doc/asio/reference/const_buffer.html
-/doc/asio/reference/const_buffer/operator_plus_/
-/doc/asio/reference/const_buffer/operator_plus__eq_.html
-/doc/asio/reference/const_buffer/operator_plus_.html
-/doc/asio/reference/const_buffer/operator_plus_/overload1.html
-/doc/asio/reference/const_buffer/operator_plus_/overload2.html
-/doc/asio/reference/const_buffers_1/
-/doc/asio/reference/const_buffers_1/begin.html
-/doc/asio/reference/const_buffers_1/const_buffers_1/
-/doc/asio/reference/const_buffers_1/const_buffers_1.html
-/doc/asio/reference/const_buffers_1/const_buffers_1/overload1.html
-/doc/asio/reference/const_buffers_1/const_buffers_1/overload2.html
-/doc/asio/reference/const_buffers_1/const_iterator.html
-/doc/asio/reference/const_buffers_1/data.html
-/doc/asio/reference/const_buffers_1/end.html
-/doc/asio/reference/const_buffers_1.html
-/doc/asio/reference/const_buffers_1/operator_plus_/
-/doc/asio/reference/const_buffers_1/operator_plus__eq_.html
-/doc/asio/reference/const_buffers_1/operator_plus_.html
-/doc/asio/reference/const_buffers_1/operator_plus_/overload1.html
-/doc/asio/reference/const_buffers_1/operator_plus_/overload2.html
-/doc/asio/reference/const_buffers_1/size.html
-/doc/asio/reference/const_buffers_1/value_type.html
-/doc/asio/reference/ConstBufferSequence.html
-/doc/asio/reference/const_buffer/size.html
-/doc/asio/reference/const_registered_buffer/
-/doc/asio/reference/const_registered_buffer/buffer.html
-/doc/asio/reference/const_registered_buffer/const_registered_buffer/
-/doc/asio/reference/const_registered_buffer/const_registered_buffer.html
-/doc/asio/reference/const_registered_buffer/const_registered_buffer/overload1.html
-/doc/asio/reference/const_registered_buffer/const_registered_buffer/overload2.html
-/doc/asio/reference/const_registered_buffer/data.html
-/doc/asio/reference/const_registered_buffer.html
-/doc/asio/reference/const_registered_buffer/id.html
-/doc/asio/reference/const_registered_buffer/operator_plus_/
-/doc/asio/reference/const_registered_buffer/operator_plus__eq_.html
-/doc/asio/reference/const_registered_buffer/operator_plus_.html
-/doc/asio/reference/const_registered_buffer/operator_plus_/overload1.html
-/doc/asio/reference/const_registered_buffer/operator_plus_/overload2.html
-/doc/asio/reference/const_registered_buffer/size.html
-/doc/asio/reference/coroutine/
-/doc/asio/reference/coroutine/coroutine.html
-/doc/asio/reference/coroutine.html
-/doc/asio/reference/coroutine/is_child.html
-/doc/asio/reference/coroutine/is_complete.html
-/doc/asio/reference/coroutine/is_parent.html
-/doc/asio/reference/co_spawn/
-/doc/asio/reference/co_spawn.html
-/doc/asio/reference/co_spawn/overload1.html
-/doc/asio/reference/co_spawn/overload2.html
-/doc/asio/reference/co_spawn/overload3.html
-/doc/asio/reference/co_spawn/overload4.html
-/doc/asio/reference/co_spawn/overload5.html
-/doc/asio/reference/co_spawn/overload6.html
-/doc/asio/reference/deadline_timer.html
-/doc/asio/reference/default_completion_token/
-/doc/asio/reference/default_completion_token.html
-/doc/asio/reference/default_completion_token_t.html
-/doc/asio/reference/default_completion_token/type.html
-/doc/asio/reference/defer/
-/doc/asio/reference/defer.html
-/doc/asio/reference/defer/overload1.html
-/doc/asio/reference/defer/overload2.html
-/doc/asio/reference/defer/overload3.html
-/doc/asio/reference/deferred_async_operation/
-/doc/asio/reference/deferred_async_operation/deferred_async_operation.html
-/doc/asio/reference/deferred_async_operation.html
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/deferred_async_operation.html
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.html
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_.html
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_async_operation/operator_lp__rp_/
-/doc/asio/reference/deferred_async_operation/operator_lp__rp_.html
-/doc/asio/reference/deferred_async_operation/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_async_operation/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_conditional/
-/doc/asio/reference/deferred_conditional/deferred_conditional.html
-/doc/asio/reference/deferred_conditional.html
-/doc/asio/reference/deferred_conditional/operator_lp__rp_/
-/doc/asio/reference/deferred_conditional/operator_lp__rp_.html
-/doc/asio/reference/deferred_conditional/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_conditional/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_conditional/otherwise.html
-/doc/asio/reference/deferred_conditional/then.html
-/doc/asio/reference/deferred_function/
-/doc/asio/reference/deferred_function/deferred_function.html
-/doc/asio/reference/deferred_function/function_.html
-/doc/asio/reference/deferred_function.html
-/doc/asio/reference/deferred_function/operator_lp__rp_/
-/doc/asio/reference/deferred_function/operator_lp__rp_.html
-/doc/asio/reference/deferred_function/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_function/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred.html
-/doc/asio/reference/deferred_init_tag.html
-/doc/asio/reference/deferred_noop/
-/doc/asio/reference/deferred_noop.html
-/doc/asio/reference/deferred_noop/operator_lp__rp_/
-/doc/asio/reference/deferred_noop/operator_lp__rp_.html
-/doc/asio/reference/deferred_noop/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_noop/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_sequence/
-/doc/asio/reference/deferred_sequence/deferred_sequence.html
-/doc/asio/reference/deferred_sequence.html
-/doc/asio/reference/deferred_sequence/operator_lp__rp_/
-/doc/asio/reference/deferred_sequence/operator_lp__rp_.html
-/doc/asio/reference/deferred_sequence/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_sequence/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_signatures.html
-/doc/asio/reference/deferred_t/
-/doc/asio/reference/deferred_t/as_default_on.html
-/doc/asio/reference/deferred_t/as_default_on_t.html
-/doc/asio/reference/deferred_t/deferred_t.html
-/doc/asio/reference/deferred_t__executor_with_default/
-/doc/asio/reference/deferred_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/deferred_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/deferred_t__executor_with_default.html
-/doc/asio/reference/deferred_t.html
-/doc/asio/reference/deferred_t/operator_lp__rp_/
-/doc/asio/reference/deferred_t/operator_lp__rp_.html
-/doc/asio/reference/deferred_t/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_t/operator_lp__rp_/overload2.html
-/doc/asio/reference/deferred_t/values.html
-/doc/asio/reference/deferred_t/when.html
-/doc/asio/reference/deferred_values/
-/doc/asio/reference/deferred_values/deferred_values.html
-/doc/asio/reference/deferred_values.html
-/doc/asio/reference/deferred_values__initiate/
-/doc/asio/reference/deferred_values__initiate.html
-/doc/asio/reference/deferred_values__initiate/operator_lp__rp_.html
-/doc/asio/reference/deferred_values/operator_lp__rp_/
-/doc/asio/reference/deferred_values/operator_lp__rp_.html
-/doc/asio/reference/deferred_values/operator_lp__rp_/overload1.html
-/doc/asio/reference/deferred_values/operator_lp__rp_/overload2.html
-/doc/asio/reference/detached.html
-/doc/asio/reference/detached_t/
-/doc/asio/reference/detached_t/as_default_on.html
-/doc/asio/reference/detached_t/as_default_on_t.html
-/doc/asio/reference/detached_t/detached_t.html
-/doc/asio/reference/detached_t__executor_with_default/
-/doc/asio/reference/detached_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/detached_t__executor_with_default/executor_with_default/
-/doc/asio/reference/detached_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/detached_t__executor_with_default/executor_with_default/overload1.html
-/doc/asio/reference/detached_t__executor_with_default/executor_with_default/overload2.html
-/doc/asio/reference/detached_t__executor_with_default.html
-/doc/asio/reference/detached_t.html
-/doc/asio/reference/disable_cancellation.html
-/doc/asio/reference/dispatch/
-/doc/asio/reference/dispatch.html
-/doc/asio/reference/dispatch/overload1.html
-/doc/asio/reference/dispatch/overload2.html
-/doc/asio/reference/dispatch/overload3.html
-/doc/asio/reference/dynamic_buffer/
-/doc/asio/reference/DynamicBuffer.html
-/doc/asio/reference/dynamic_buffer.html
-/doc/asio/reference/dynamic_buffer/overload1.html
-/doc/asio/reference/dynamic_buffer/overload2.html
-/doc/asio/reference/dynamic_buffer/overload3.html
-/doc/asio/reference/dynamic_buffer/overload4.html
-/doc/asio/reference/DynamicBuffer_v1.html
-/doc/asio/reference/DynamicBuffer_v2.html
-/doc/asio/reference/dynamic_string_buffer/
-/doc/asio/reference/dynamic_string_buffer/capacity.html
-/doc/asio/reference/dynamic_string_buffer/commit.html
-/doc/asio/reference/dynamic_string_buffer/const_buffers_type.html
-/doc/asio/reference/dynamic_string_buffer/consume.html
-/doc/asio/reference/dynamic_string_buffer/data/
-/doc/asio/reference/dynamic_string_buffer/data.html
-/doc/asio/reference/dynamic_string_buffer/data/overload1.html
-/doc/asio/reference/dynamic_string_buffer/data/overload2.html
-/doc/asio/reference/dynamic_string_buffer/data/overload3.html
-/doc/asio/reference/dynamic_string_buffer/dynamic_string_buffer/
-/doc/asio/reference/dynamic_string_buffer/dynamic_string_buffer.html
-/doc/asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload1.html
-/doc/asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload2.html
-/doc/asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload3.html
-/doc/asio/reference/dynamic_string_buffer/grow.html
-/doc/asio/reference/dynamic_string_buffer.html
-/doc/asio/reference/dynamic_string_buffer/max_size.html
-/doc/asio/reference/dynamic_string_buffer/mutable_buffers_type.html
-/doc/asio/reference/dynamic_string_buffer/prepare.html
-/doc/asio/reference/dynamic_string_buffer/shrink.html
-/doc/asio/reference/dynamic_string_buffer/size.html
-/doc/asio/reference/dynamic_vector_buffer/
-/doc/asio/reference/dynamic_vector_buffer/capacity.html
-/doc/asio/reference/dynamic_vector_buffer/commit.html
-/doc/asio/reference/dynamic_vector_buffer/const_buffers_type.html
-/doc/asio/reference/dynamic_vector_buffer/consume.html
-/doc/asio/reference/dynamic_vector_buffer/data/
-/doc/asio/reference/dynamic_vector_buffer/data.html
-/doc/asio/reference/dynamic_vector_buffer/data/overload1.html
-/doc/asio/reference/dynamic_vector_buffer/data/overload2.html
-/doc/asio/reference/dynamic_vector_buffer/data/overload3.html
-/doc/asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/
-/doc/asio/reference/dynamic_vector_buffer/dynamic_vector_buffer.html
-/doc/asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload1.html
-/doc/asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload2.html
-/doc/asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload3.html
-/doc/asio/reference/dynamic_vector_buffer/grow.html
-/doc/asio/reference/dynamic_vector_buffer.html
-/doc/asio/reference/dynamic_vector_buffer/max_size.html
-/doc/asio/reference/dynamic_vector_buffer/mutable_buffers_type.html
-/doc/asio/reference/dynamic_vector_buffer/prepare.html
-/doc/asio/reference/dynamic_vector_buffer/shrink.html
-/doc/asio/reference/dynamic_vector_buffer/size.html
-/doc/asio/reference/enable_partial_cancellation.html
-/doc/asio/reference/enable_terminal_cancellation.html
-/doc/asio/reference/enable_total_cancellation.html
-/doc/asio/reference/Endpoint.html
-/doc/asio/reference/EndpointSequence.html
-/doc/asio/reference/error__addrinfo_category.html
-/doc/asio/reference/error__addrinfo_errors__gt_/
-/doc/asio/reference/error__addrinfo_errors__gt_.html
-/doc/asio/reference/error__addrinfo_errors__gt_/value.html
-/doc/asio/reference/error__addrinfo_errors.html
-/doc/asio/reference/error__basic_errors__gt_/
-/doc/asio/reference/error__basic_errors__gt_.html
-/doc/asio/reference/error__basic_errors__gt_/value.html
-/doc/asio/reference/error__basic_errors.html
-/doc/asio/reference/error_category.html
-/doc/asio/reference/error__clear.html
-/doc/asio/reference/error_code.html
-/doc/asio/reference/error__get_addrinfo_category.html
-/doc/asio/reference/error__get_misc_category.html
-/doc/asio/reference/error__get_netdb_category.html
-/doc/asio/reference/error__get_ssl_category.html
-/doc/asio/reference/error__get_system_category.html
-/doc/asio/reference/error__make_error_code/
-/doc/asio/reference/error__make_error_code.html
-/doc/asio/reference/error__make_error_code/overload1.html
-/doc/asio/reference/error__make_error_code/overload2.html
-/doc/asio/reference/error__make_error_code/overload3.html
-/doc/asio/reference/error__make_error_code/overload4.html
-/doc/asio/reference/error__make_error_code/overload5.html
-/doc/asio/reference/error__misc_category.html
-/doc/asio/reference/error__misc_errors__gt_/
-/doc/asio/reference/error__misc_errors__gt_.html
-/doc/asio/reference/error__misc_errors__gt_/value.html
-/doc/asio/reference/error__misc_errors.html
-/doc/asio/reference/error__netdb_category.html
-/doc/asio/reference/error__netdb_errors__gt_/
-/doc/asio/reference/error__netdb_errors__gt_.html
-/doc/asio/reference/error__netdb_errors__gt_/value.html
-/doc/asio/reference/error__netdb_errors.html
-/doc/asio/reference/error__ssl_category.html
-/doc/asio/reference/error__ssl_errors__gt_/
-/doc/asio/reference/error__ssl_errors__gt_.html
-/doc/asio/reference/error__ssl_errors__gt_/value.html
-/doc/asio/reference/error__ssl_errors.html
-/doc/asio/reference/error__system_category.html
-/doc/asio/reference/execution__allocator.html
-/doc/asio/reference/execution__allocator_t/
-/doc/asio/reference/execution__allocator_t/allocator_t.html
-/doc/asio/reference/execution__allocator_t.html
-/doc/asio/reference/execution__allocator_t/is_applicable_property_v.html
-/doc/asio/reference/execution__allocator_t/is_preferable.html
-/doc/asio/reference/execution__allocator_t/is_requirable.html
-/doc/asio/reference/execution__allocator_t/value.html
-/doc/asio/reference/execution__any_executor/
-/doc/asio/reference/execution__any_executor/any_executor/
-/doc/asio/reference/execution__any_executor/_any_executor.html
-/doc/asio/reference/execution__any_executor/any_executor.html
-/doc/asio/reference/execution__any_executor/any_executor/overload10.html
-/doc/asio/reference/execution__any_executor/any_executor/overload1.html
-/doc/asio/reference/execution__any_executor/any_executor/overload2.html
-/doc/asio/reference/execution__any_executor/any_executor/overload3.html
-/doc/asio/reference/execution__any_executor/any_executor/overload4.html
-/doc/asio/reference/execution__any_executor/any_executor/overload5.html
-/doc/asio/reference/execution__any_executor/any_executor/overload6.html
-/doc/asio/reference/execution__any_executor/any_executor/overload7.html
-/doc/asio/reference/execution__any_executor/any_executor/overload8.html
-/doc/asio/reference/execution__any_executor/any_executor/overload9.html
-/doc/asio/reference/execution__any_executor/context.html
-/doc/asio/reference/execution__any_executor/execute.html
-/doc/asio/reference/execution__any_executor.html
-/doc/asio/reference/execution__any_executor/operator_bool.html
-/doc/asio/reference/execution__any_executor/operator_eq_/
-/doc/asio/reference/execution__any_executor/operator_eq__eq_/
-/doc/asio/reference/execution__any_executor/operator_eq__eq_.html
-/doc/asio/reference/execution__any_executor/operator_eq__eq_/overload1.html
-/doc/asio/reference/execution__any_executor/operator_eq__eq_/overload2.html
-/doc/asio/reference/execution__any_executor/operator_eq__eq_/overload3.html
-/doc/asio/reference/execution__any_executor/operator_eq_.html
-/doc/asio/reference/execution__any_executor/operator_eq_/overload1.html
-/doc/asio/reference/execution__any_executor/operator_eq_/overload2.html
-/doc/asio/reference/execution__any_executor/operator_eq_/overload3.html
-/doc/asio/reference/execution__any_executor/operator_eq_/overload4.html
-/doc/asio/reference/execution__any_executor/operator_not__eq_/
-/doc/asio/reference/execution__any_executor/operator_not__eq_.html
-/doc/asio/reference/execution__any_executor/operator_not__eq_/overload1.html
-/doc/asio/reference/execution__any_executor/operator_not__eq_/overload2.html
-/doc/asio/reference/execution__any_executor/operator_not__eq_/overload3.html
-/doc/asio/reference/execution__any_executor/prefer.html
-/doc/asio/reference/execution__any_executor/query.html
-/doc/asio/reference/execution__any_executor/require.html
-/doc/asio/reference/execution__any_executor/swap.html
-/doc/asio/reference/execution__any_executor/target/
-/doc/asio/reference/execution__any_executor/target.html
-/doc/asio/reference/execution__any_executor/target/overload1.html
-/doc/asio/reference/execution__any_executor/target/overload2.html
-/doc/asio/reference/execution__any_executor/target_type.html
-/doc/asio/reference/execution__bad_executor/
-/doc/asio/reference/execution__bad_executor/bad_executor.html
-/doc/asio/reference/execution__bad_executor.html
-/doc/asio/reference/execution__bad_executor/what.html
-/doc/asio/reference/execution__blocking_adaptation.html
-/doc/asio/reference/execution__blocking_adaptation_t/
-/doc/asio/reference/execution__blocking_adaptation_t/allowed.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/allowed_t.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/is_preferable.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/is_requirable.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_adaptation_t__allowed_t/value.html
-/doc/asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/
-/doc/asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t.html
-/doc/asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload1.html
-/doc/asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload2.html
-/doc/asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload3.html
-/doc/asio/reference/execution__blocking_adaptation_t/disallowed.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/disallowed_t.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/is_preferable.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/is_requirable.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_adaptation_t__disallowed_t/value.html
-/doc/asio/reference/execution__blocking_adaptation_t.html
-/doc/asio/reference/execution__blocking_adaptation_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_adaptation_t/is_preferable.html
-/doc/asio/reference/execution__blocking_adaptation_t/is_requirable.html
-/doc/asio/reference/execution__blocking_adaptation_t/operator_eq__eq_.html
-/doc/asio/reference/execution__blocking_adaptation_t/operator_not__eq_.html
-/doc/asio/reference/execution__blocking_adaptation_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking.html
-/doc/asio/reference/execution__blocking_t/
-/doc/asio/reference/execution__blocking_t/always.html
-/doc/asio/reference/execution__blocking_t__always_t/
-/doc/asio/reference/execution__blocking_t__always_t/always_t.html
-/doc/asio/reference/execution__blocking_t__always_t.html
-/doc/asio/reference/execution__blocking_t__always_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_t__always_t/is_preferable.html
-/doc/asio/reference/execution__blocking_t__always_t/is_requirable.html
-/doc/asio/reference/execution__blocking_t__always_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_t__always_t/value.html
-/doc/asio/reference/execution__blocking_t/blocking_t/
-/doc/asio/reference/execution__blocking_t/blocking_t.html
-/doc/asio/reference/execution__blocking_t/blocking_t/overload1.html
-/doc/asio/reference/execution__blocking_t/blocking_t/overload2.html
-/doc/asio/reference/execution__blocking_t/blocking_t/overload3.html
-/doc/asio/reference/execution__blocking_t/blocking_t/overload4.html
-/doc/asio/reference/execution__blocking_t.html
-/doc/asio/reference/execution__blocking_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_t/is_preferable.html
-/doc/asio/reference/execution__blocking_t/is_requirable.html
-/doc/asio/reference/execution__blocking_t/never.html
-/doc/asio/reference/execution__blocking_t__never_t/
-/doc/asio/reference/execution__blocking_t__never_t.html
-/doc/asio/reference/execution__blocking_t__never_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_t__never_t/is_preferable.html
-/doc/asio/reference/execution__blocking_t__never_t/is_requirable.html
-/doc/asio/reference/execution__blocking_t__never_t/never_t.html
-/doc/asio/reference/execution__blocking_t__never_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_t__never_t/value.html
-/doc/asio/reference/execution__blocking_t/operator_eq__eq_.html
-/doc/asio/reference/execution__blocking_t/operator_not__eq_.html
-/doc/asio/reference/execution__blocking_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_t/possibly.html
-/doc/asio/reference/execution__blocking_t__possibly_t/
-/doc/asio/reference/execution__blocking_t__possibly_t.html
-/doc/asio/reference/execution__blocking_t__possibly_t/is_applicable_property_v.html
-/doc/asio/reference/execution__blocking_t__possibly_t/is_preferable.html
-/doc/asio/reference/execution__blocking_t__possibly_t/is_requirable.html
-/doc/asio/reference/execution__blocking_t__possibly_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__blocking_t__possibly_t/possibly_t.html
-/doc/asio/reference/execution__blocking_t__possibly_t/value.html
-/doc/asio/reference/execution_context/
-/doc/asio/reference/execution_context/add_service.html
-/doc/asio/reference/execution__context_as.html
-/doc/asio/reference/execution__context_as_t/
-/doc/asio/reference/execution__context_as_t.html
-/doc/asio/reference/execution__context_as_t/is_applicable_property_v.html
-/doc/asio/reference/execution__context_as_t/is_preferable.html
-/doc/asio/reference/execution__context_as_t/is_requirable.html
-/doc/asio/reference/execution__context_as_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution_context/destroy.html
-/doc/asio/reference/execution_context/_execution_context.html
-/doc/asio/reference/execution_context/execution_context.html
-/doc/asio/reference/execution_context/fork_event.html
-/doc/asio/reference/execution_context/has_service.html
-/doc/asio/reference/ExecutionContext.html
-/doc/asio/reference/execution__context.html
-/doc/asio/reference/execution_context.html
-/doc/asio/reference/execution_context__id/
-/doc/asio/reference/execution_context__id.html
-/doc/asio/reference/execution_context__id/id.html
-/doc/asio/reference/execution_context/make_service.html
-/doc/asio/reference/execution_context/notify_fork.html
-/doc/asio/reference/execution_context__service/
-/doc/asio/reference/execution_context__service/context.html
-/doc/asio/reference/execution_context__service.html
-/doc/asio/reference/execution_context__service/notify_fork.html
-/doc/asio/reference/execution_context__service/_service.html
-/doc/asio/reference/execution_context__service/service.html
-/doc/asio/reference/execution_context__service/shutdown.html
-/doc/asio/reference/execution_context/shutdown.html
-/doc/asio/reference/execution__context_t/
-/doc/asio/reference/execution__context_t.html
-/doc/asio/reference/execution__context_t/is_applicable_property_v.html
-/doc/asio/reference/execution__context_t/is_preferable.html
-/doc/asio/reference/execution__context_t/is_requirable.html
-/doc/asio/reference/execution__context_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution_context/use_service/
-/doc/asio/reference/execution_context/use_service.html
-/doc/asio/reference/execution_context/use_service/overload1.html
-/doc/asio/reference/execution_context/use_service/overload2.html
-/doc/asio/reference/execution__invocable_archetype/
-/doc/asio/reference/execution__invocable_archetype.html
-/doc/asio/reference/execution__invocable_archetype/operator_lp__rp_.html
-/doc/asio/reference/execution__is_executor.html
-/doc/asio/reference/execution__mapping.html
-/doc/asio/reference/execution__mapping_t/
-/doc/asio/reference/execution__mapping_t.html
-/doc/asio/reference/execution__mapping_t/is_applicable_property_v.html
-/doc/asio/reference/execution__mapping_t/is_preferable.html
-/doc/asio/reference/execution__mapping_t/is_requirable.html
-/doc/asio/reference/execution__mapping_t/mapping_t/
-/doc/asio/reference/execution__mapping_t/mapping_t.html
-/doc/asio/reference/execution__mapping_t/mapping_t/overload1.html
-/doc/asio/reference/execution__mapping_t/mapping_t/overload2.html
-/doc/asio/reference/execution__mapping_t/mapping_t/overload3.html
-/doc/asio/reference/execution__mapping_t/mapping_t/overload4.html
-/doc/asio/reference/execution__mapping_t/new_thread.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/
-/doc/asio/reference/execution__mapping_t__new_thread_t.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/is_applicable_property_v.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/is_preferable.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/is_requirable.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/new_thread_t.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__mapping_t__new_thread_t/value.html
-/doc/asio/reference/execution__mapping_t/operator_eq__eq_.html
-/doc/asio/reference/execution__mapping_t/operator_not__eq_.html
-/doc/asio/reference/execution__mapping_t/other.html
-/doc/asio/reference/execution__mapping_t__other_t/
-/doc/asio/reference/execution__mapping_t__other_t.html
-/doc/asio/reference/execution__mapping_t__other_t/is_applicable_property_v.html
-/doc/asio/reference/execution__mapping_t__other_t/is_preferable.html
-/doc/asio/reference/execution__mapping_t__other_t/is_requirable.html
-/doc/asio/reference/execution__mapping_t__other_t/other_t.html
-/doc/asio/reference/execution__mapping_t__other_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__mapping_t__other_t/value.html
-/doc/asio/reference/execution__mapping_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__mapping_t/thread.html
-/doc/asio/reference/execution__mapping_t__thread_t/
-/doc/asio/reference/execution__mapping_t__thread_t.html
-/doc/asio/reference/execution__mapping_t__thread_t/is_applicable_property_v.html
-/doc/asio/reference/execution__mapping_t__thread_t/is_preferable.html
-/doc/asio/reference/execution__mapping_t__thread_t/is_requirable.html
-/doc/asio/reference/execution__mapping_t__thread_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__mapping_t__thread_t/thread_t.html
-/doc/asio/reference/execution__mapping_t__thread_t/value.html
-/doc/asio/reference/execution__occupancy.html
-/doc/asio/reference/execution__occupancy_t/
-/doc/asio/reference/execution__occupancy_t.html
-/doc/asio/reference/execution__occupancy_t/is_applicable_property_v.html
-/doc/asio/reference/execution__occupancy_t/is_preferable.html
-/doc/asio/reference/execution__occupancy_t/is_requirable.html
-/doc/asio/reference/execution__occupancy_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__outstanding_work.html
-/doc/asio/reference/execution__outstanding_work_t/
-/doc/asio/reference/execution__outstanding_work_t.html
-/doc/asio/reference/execution__outstanding_work_t/is_applicable_property_v.html
-/doc/asio/reference/execution__outstanding_work_t/is_preferable.html
-/doc/asio/reference/execution__outstanding_work_t/is_requirable.html
-/doc/asio/reference/execution__outstanding_work_t/operator_eq__eq_.html
-/doc/asio/reference/execution__outstanding_work_t/operator_not__eq_.html
-/doc/asio/reference/execution__outstanding_work_t/outstanding_work_t/
-/doc/asio/reference/execution__outstanding_work_t/outstanding_work_t.html
-/doc/asio/reference/execution__outstanding_work_t/outstanding_work_t/overload1.html
-/doc/asio/reference/execution__outstanding_work_t/outstanding_work_t/overload2.html
-/doc/asio/reference/execution__outstanding_work_t/outstanding_work_t/overload3.html
-/doc/asio/reference/execution__outstanding_work_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__outstanding_work_t/tracked.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/
-/doc/asio/reference/execution__outstanding_work_t__tracked_t.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/is_applicable_property_v.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/is_preferable.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/is_requirable.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/tracked_t.html
-/doc/asio/reference/execution__outstanding_work_t__tracked_t/value.html
-/doc/asio/reference/execution__outstanding_work_t/untracked.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/
-/doc/asio/reference/execution__outstanding_work_t__untracked_t.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/is_applicable_property_v.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/is_preferable.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/is_requirable.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/untracked_t.html
-/doc/asio/reference/execution__outstanding_work_t__untracked_t/value.html
-/doc/asio/reference/execution__prefer_only/
-/doc/asio/reference/execution__prefer_only.html
-/doc/asio/reference/execution__prefer_only/is_applicable_property_v.html
-/doc/asio/reference/execution__prefer_only/is_preferable.html
-/doc/asio/reference/execution__prefer_only/is_requirable.html
-/doc/asio/reference/execution__prefer_only/polymorphic_query_result_type.html
-/doc/asio/reference/execution__relationship.html
-/doc/asio/reference/execution__relationship_t/
-/doc/asio/reference/execution__relationship_t/continuation.html
-/doc/asio/reference/execution__relationship_t__continuation_t/
-/doc/asio/reference/execution__relationship_t__continuation_t/continuation_t.html
-/doc/asio/reference/execution__relationship_t__continuation_t.html
-/doc/asio/reference/execution__relationship_t__continuation_t/is_applicable_property_v.html
-/doc/asio/reference/execution__relationship_t__continuation_t/is_preferable.html
-/doc/asio/reference/execution__relationship_t__continuation_t/is_requirable.html
-/doc/asio/reference/execution__relationship_t__continuation_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__relationship_t__continuation_t/value.html
-/doc/asio/reference/execution__relationship_t/fork.html
-/doc/asio/reference/execution__relationship_t__fork_t/
-/doc/asio/reference/execution__relationship_t__fork_t/fork_t.html
-/doc/asio/reference/execution__relationship_t__fork_t.html
-/doc/asio/reference/execution__relationship_t__fork_t/is_applicable_property_v.html
-/doc/asio/reference/execution__relationship_t__fork_t/is_preferable.html
-/doc/asio/reference/execution__relationship_t__fork_t/is_requirable.html
-/doc/asio/reference/execution__relationship_t__fork_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__relationship_t__fork_t/value.html
-/doc/asio/reference/execution__relationship_t.html
-/doc/asio/reference/execution__relationship_t/is_applicable_property_v.html
-/doc/asio/reference/execution__relationship_t/is_preferable.html
-/doc/asio/reference/execution__relationship_t/is_requirable.html
-/doc/asio/reference/execution__relationship_t/operator_eq__eq_.html
-/doc/asio/reference/execution__relationship_t/operator_not__eq_.html
-/doc/asio/reference/execution__relationship_t/polymorphic_query_result_type.html
-/doc/asio/reference/execution__relationship_t/relationship_t/
-/doc/asio/reference/execution__relationship_t/relationship_t.html
-/doc/asio/reference/execution__relationship_t/relationship_t/overload1.html
-/doc/asio/reference/execution__relationship_t/relationship_t/overload2.html
-/doc/asio/reference/execution__relationship_t/relationship_t/overload3.html
-/doc/asio/reference/executor/
-/doc/asio/reference/Executor1.html
-/doc/asio/reference/executor_arg.html
-/doc/asio/reference/executor_arg_t/
-/doc/asio/reference/executor_arg_t/executor_arg_t.html
-/doc/asio/reference/executor_arg_t.html
-/doc/asio/reference/executor_binder/
-/doc/asio/reference/executor_binder/argument_type.html
-/doc/asio/reference/executor_binder/executor_binder/
-/doc/asio/reference/executor_binder/_executor_binder.html
-/doc/asio/reference/executor_binder/executor_binder.html
-/doc/asio/reference/executor_binder/executor_binder/overload1.html
-/doc/asio/reference/executor_binder/executor_binder/overload2.html
-/doc/asio/reference/executor_binder/executor_binder/overload3.html
-/doc/asio/reference/executor_binder/executor_binder/overload4.html
-/doc/asio/reference/executor_binder/executor_binder/overload5.html
-/doc/asio/reference/executor_binder/executor_binder/overload6.html
-/doc/asio/reference/executor_binder/executor_binder/overload7.html
-/doc/asio/reference/executor_binder/executor_binder/overload8.html
-/doc/asio/reference/executor_binder/executor_binder/overload9.html
-/doc/asio/reference/executor_binder/executor_type.html
-/doc/asio/reference/executor_binder/first_argument_type.html
-/doc/asio/reference/executor_binder/get/
-/doc/asio/reference/executor_binder/get_executor.html
-/doc/asio/reference/executor_binder/get.html
-/doc/asio/reference/executor_binder/get/overload1.html
-/doc/asio/reference/executor_binder/get/overload2.html
-/doc/asio/reference/executor_binder.html
-/doc/asio/reference/executor_binder/operator_lp__rp_/
-/doc/asio/reference/executor_binder/operator_lp__rp_.html
-/doc/asio/reference/executor_binder/operator_lp__rp_/overload1.html
-/doc/asio/reference/executor_binder/operator_lp__rp_/overload2.html
-/doc/asio/reference/executor_binder/result_type.html
-/doc/asio/reference/executor_binder/second_argument_type.html
-/doc/asio/reference/executor_binder/target_type.html
-/doc/asio/reference/executor/context.html
-/doc/asio/reference/executor/defer.html
-/doc/asio/reference/executor/dispatch.html
-/doc/asio/reference/executor/executor/
-/doc/asio/reference/executor/_executor.html
-/doc/asio/reference/executor/executor.html
-/doc/asio/reference/executor/executor/overload1.html
-/doc/asio/reference/executor/executor/overload2.html
-/doc/asio/reference/executor/executor/overload3.html
-/doc/asio/reference/executor/executor/overload4.html
-/doc/asio/reference/executor/executor/overload5.html
-/doc/asio/reference/executor/executor/overload6.html
-/doc/asio/reference/executor/executor/overload7.html
-/doc/asio/reference/executor/executor/overload8.html
-/doc/asio/reference/executor/executor/overload9.html
-/doc/asio/reference/executor.html
-/doc/asio/reference/executor/on_work_finished.html
-/doc/asio/reference/executor/on_work_started.html
-/doc/asio/reference/executor/operator_eq_/
-/doc/asio/reference/executor/operator_eq__eq_.html
-/doc/asio/reference/executor/operator_eq_.html
-/doc/asio/reference/executor/operator_eq_/overload1.html
-/doc/asio/reference/executor/operator_eq_/overload2.html
-/doc/asio/reference/executor/operator_eq_/overload3.html
-/doc/asio/reference/executor/operator_eq_/overload4.html
-/doc/asio/reference/executor/operator_not__eq_.html
-/doc/asio/reference/executor/operator_unspecified_bool_type.html
-/doc/asio/reference/executor/post.html
-/doc/asio/reference/executor/target/
-/doc/asio/reference/executor/target.html
-/doc/asio/reference/executor/target/overload1.html
-/doc/asio/reference/executor/target/overload2.html
-/doc/asio/reference/executor/target_type.html
-/doc/asio/reference/executor/unspecified_bool_true.html
-/doc/asio/reference/executor/unspecified_bool_type.html
-/doc/asio/reference/executor__unspecified_bool_type_t.html
-/doc/asio/reference/executor_work_guard/
-/doc/asio/reference/executor_work_guard/executor_type.html
-/doc/asio/reference/executor_work_guard/executor_work_guard/
-/doc/asio/reference/executor_work_guard/_executor_work_guard.html
-/doc/asio/reference/executor_work_guard/executor_work_guard.html
-/doc/asio/reference/executor_work_guard/executor_work_guard/overload1.html
-/doc/asio/reference/executor_work_guard/executor_work_guard/overload2.html
-/doc/asio/reference/executor_work_guard/executor_work_guard/overload3.html
-/doc/asio/reference/executor_work_guard/get_executor.html
-/doc/asio/reference/executor_work_guard.html
-/doc/asio/reference/executor_work_guard/owns_work.html
-/doc/asio/reference/executor_work_guard/reset.html
-/doc/asio/reference/experimental__as_single.html
-/doc/asio/reference/experimental__as_single_t/
-/doc/asio/reference/experimental__as_single_t/as_default_on.html
-/doc/asio/reference/experimental__as_single_t/as_default_on_t.html
-/doc/asio/reference/experimental__as_single_t/as_single_t/
-/doc/asio/reference/experimental__as_single_t/as_single_t.html
-/doc/asio/reference/experimental__as_single_t/as_single_t/overload1.html
-/doc/asio/reference/experimental__as_single_t/as_single_t/overload2.html
-/doc/asio/reference/experimental__as_single_t__default_constructor_tag.html
-/doc/asio/reference/experimental__as_single_t__executor_with_default/
-/doc/asio/reference/experimental__as_single_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/
-/doc/asio/reference/experimental__as_single_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/overload1.html
-/doc/asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/overload2.html
-/doc/asio/reference/experimental__as_single_t__executor_with_default.html
-/doc/asio/reference/experimental__as_single_t.html
-/doc/asio/reference/experimental__as_single_t/token_.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload1.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload2.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload3.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload4.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload5.html
-/doc/asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload6.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload1.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload2.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload3.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload4.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload5.html
-/doc/asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload6.html
-/doc/asio/reference/experimental__basic_channel/
-/doc/asio/reference/experimental__basic_channel/async_receive.html
-/doc/asio/reference/experimental__basic_channel/async_send.html
-/doc/asio/reference/experimental__basic_channel/basic_channel/
-/doc/asio/reference/experimental__basic_channel/_basic_channel.html
-/doc/asio/reference/experimental__basic_channel/basic_channel.html
-/doc/asio/reference/experimental__basic_channel/basic_channel/overload1.html
-/doc/asio/reference/experimental__basic_channel/basic_channel/overload2.html
-/doc/asio/reference/experimental__basic_channel/basic_channel/overload3.html
-/doc/asio/reference/experimental__basic_channel/basic_channel/overload4.html
-/doc/asio/reference/experimental__basic_channel/cancel.html
-/doc/asio/reference/experimental__basic_channel/capacity.html
-/doc/asio/reference/experimental__basic_channel/close.html
-/doc/asio/reference/experimental__basic_channel/executor_type.html
-/doc/asio/reference/experimental__basic_channel/get_executor.html
-/doc/asio/reference/experimental__basic_channel.html
-/doc/asio/reference/experimental__basic_channel/is_open.html
-/doc/asio/reference/experimental__basic_channel/operator_eq_/
-/doc/asio/reference/experimental__basic_channel/operator_eq_.html
-/doc/asio/reference/experimental__basic_channel/operator_eq_/overload1.html
-/doc/asio/reference/experimental__basic_channel/operator_eq_/overload2.html
-/doc/asio/reference/experimental__basic_channel/ready.html
-/doc/asio/reference/experimental__basic_channel__rebind_executor/
-/doc/asio/reference/experimental__basic_channel__rebind_executor.html
-/doc/asio/reference/experimental__basic_channel__rebind_executor/other.html
-/doc/asio/reference/experimental__basic_channel/reset.html
-/doc/asio/reference/experimental__basic_channel/traits_type.html
-/doc/asio/reference/experimental__basic_channel/try_receive.html
-/doc/asio/reference/experimental__basic_channel/try_send.html
-/doc/asio/reference/experimental__basic_channel/try_send_n.html
-/doc/asio/reference/experimental__basic_channel/try_send_n_via_dispatch.html
-/doc/asio/reference/experimental__basic_channel/try_send_via_dispatch.html
-/doc/asio/reference/experimental__basic_concurrent_channel/
-/doc/asio/reference/experimental__basic_concurrent_channel/async_receive.html
-/doc/asio/reference/experimental__basic_concurrent_channel/async_send.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/
-/doc/asio/reference/experimental__basic_concurrent_channel/_basic_concurrent_channel.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload1.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload2.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload3.html
-/doc/asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload4.html
-/doc/asio/reference/experimental__basic_concurrent_channel/cancel.html
-/doc/asio/reference/experimental__basic_concurrent_channel/capacity.html
-/doc/asio/reference/experimental__basic_concurrent_channel/close.html
-/doc/asio/reference/experimental__basic_concurrent_channel/executor_type.html
-/doc/asio/reference/experimental__basic_concurrent_channel/get_executor.html
-/doc/asio/reference/experimental__basic_concurrent_channel.html
-/doc/asio/reference/experimental__basic_concurrent_channel/is_open.html
-/doc/asio/reference/experimental__basic_concurrent_channel/operator_eq_/
-/doc/asio/reference/experimental__basic_concurrent_channel/operator_eq_.html
-/doc/asio/reference/experimental__basic_concurrent_channel/operator_eq_/overload1.html
-/doc/asio/reference/experimental__basic_concurrent_channel/operator_eq_/overload2.html
-/doc/asio/reference/experimental__basic_concurrent_channel/ready.html
-/doc/asio/reference/experimental__basic_concurrent_channel__rebind_executor/
-/doc/asio/reference/experimental__basic_concurrent_channel__rebind_executor.html
-/doc/asio/reference/experimental__basic_concurrent_channel__rebind_executor/other.html
-/doc/asio/reference/experimental__basic_concurrent_channel/reset.html
-/doc/asio/reference/experimental__basic_concurrent_channel/traits_type.html
-/doc/asio/reference/experimental__basic_concurrent_channel/try_receive.html
-/doc/asio/reference/experimental__basic_concurrent_channel/try_send.html
-/doc/asio/reference/experimental__basic_concurrent_channel/try_send_n.html
-/doc/asio/reference/experimental__basic_concurrent_channel/try_send_n_via_dispatch.html
-/doc/asio/reference/experimental__basic_concurrent_channel/try_send_via_dispatch.html
-/doc/asio/reference/experimental__channel.html
-/doc/asio/reference/experimental__channel_traits/
-/doc/asio/reference/experimental__channel_traits__container/
-/doc/asio/reference/experimental__channel_traits__container.html
-/doc/asio/reference/experimental__channel_traits__container/type.html
-/doc/asio/reference/experimental__channel_traits.html
-/doc/asio/reference/experimental__channel_traits/invoke_receive_cancelled.html
-/doc/asio/reference/experimental__channel_traits/invoke_receive_closed.html
-/doc/asio/reference/experimental__channel_traits__rebind/
-/doc/asio/reference/experimental__channel_traits__rebind.html
-/doc/asio/reference/experimental__channel_traits__rebind/other.html
-/doc/asio/reference/experimental__channel_traits/receive_cancelled_signature.html
-/doc/asio/reference/experimental__channel_traits/receive_closed_signature.html
-/doc/asio/reference/experimental__concurrent_channel.html
-/doc/asio/reference/experimental__coro/
-/doc/asio/reference/experimental__coro/allocator_type.html
-/doc/asio/reference/experimental__coro/async_resume/
-/doc/asio/reference/experimental__coro/async_resume.html
-/doc/asio/reference/experimental__coro/async_resume/overload1.html
-/doc/asio/reference/experimental__coro/async_resume/overload2.html
-/doc/asio/reference/experimental__coro/completion_handler.html
-/doc/asio/reference/experimental__coro/coro/
-/doc/asio/reference/experimental__coro/_coro.html
-/doc/asio/reference/experimental__coro/coro.html
-/doc/asio/reference/experimental__coro/coro/overload1.html
-/doc/asio/reference/experimental__coro/coro/overload2.html
-/doc/asio/reference/experimental__coro/coro/overload3.html
-/doc/asio/reference/experimental__coro/error_type.html
-/doc/asio/reference/experimental__coro/executor_type.html
-/doc/asio/reference/experimental__coro/get_allocator.html
-/doc/asio/reference/experimental__coro/get_executor.html
-/doc/asio/reference/experimental__coro.html
-/doc/asio/reference/experimental__coro/input_type.html
-/doc/asio/reference/experimental__coro/is_noexcept.html
-/doc/asio/reference/experimental__coro/is_open.html
-/doc/asio/reference/experimental__coro/operator_bool.html
-/doc/asio/reference/experimental__coro/operator_co_await.html
-/doc/asio/reference/experimental__coro/operator_eq_/
-/doc/asio/reference/experimental__coro/operator_eq_.html
-/doc/asio/reference/experimental__coro/operator_eq_/overload1.html
-/doc/asio/reference/experimental__coro/operator_eq_/overload2.html
-/doc/asio/reference/experimental__coro/operator_lp__rp_.html
-/doc/asio/reference/experimental__coro/promise_type.html
-/doc/asio/reference/experimental__coro/result_type.html
-/doc/asio/reference/experimental__coro/return_type.html
-/doc/asio/reference/experimental__coro/signature_type.html
-/doc/asio/reference/experimental__coro_traits/
-/doc/asio/reference/experimental__coro_traits/completion_handler.html
-/doc/asio/reference/experimental__coro_traits/error_type.html
-/doc/asio/reference/experimental__coro/traits.html
-/doc/asio/reference/experimental__coro_traits.html
-/doc/asio/reference/experimental__coro_traits/input_type.html
-/doc/asio/reference/experimental__coro_traits/is_noexcept.html
-/doc/asio/reference/experimental__coro_traits/result_type.html
-/doc/asio/reference/experimental__coro_traits/return_type.html
-/doc/asio/reference/experimental__coro_traits/signature_type.html
-/doc/asio/reference/experimental__coro_traits/yield_type.html
-/doc/asio/reference/experimental__coro/yield_type.html
-/doc/asio/reference/experimental__co_spawn/
-/doc/asio/reference/experimental__co_spawn.html
-/doc/asio/reference/experimental__co_spawn/overload1.html
-/doc/asio/reference/experimental__co_spawn/overload2.html
-/doc/asio/reference/experimental__co_spawn/overload3.html
-/doc/asio/reference/experimental__co_spawn/overload4.html
-/doc/asio/reference/experimental__co_spawn/overload5.html
-/doc/asio/reference/experimental__co_spawn/overload6.html
-/doc/asio/reference/experimental__error__channel_category.html
-/doc/asio/reference/experimental__error__channel_errors__gt_/
-/doc/asio/reference/experimental__error__channel_errors__gt_.html
-/doc/asio/reference/experimental__error__channel_errors__gt_/value.html
-/doc/asio/reference/experimental__error__channel_errors.html
-/doc/asio/reference/experimental__error__get_channel_category.html
-/doc/asio/reference/experimental__error__make_error_code.html
-/doc/asio/reference/experimental__generator.html
-/doc/asio/reference/experimental__is_async_operation_range/
-/doc/asio/reference/experimental__is_async_operation_range.html
-/doc/asio/reference/experimental__is_async_operation_range/value.html
-/doc/asio/reference/experimental__is_promise.html
-/doc/asio/reference/experimental__is_promise_lt__promise_lt__Ts_ellipsis___gt___gt_.html
-/doc/asio/reference/experimental__is_promise_v.html
-/doc/asio/reference/experimental__make_parallel_group/
-/doc/asio/reference/experimental__make_parallel_group.html
-/doc/asio/reference/experimental__make_parallel_group/overload1.html
-/doc/asio/reference/experimental__make_parallel_group/overload2.html
-/doc/asio/reference/experimental__make_parallel_group/overload3.html
-/doc/asio/reference/experimental__parallel_group/
-/doc/asio/reference/experimental__parallel_group/async_wait.html
-/doc/asio/reference/experimental__parallel_group.html
-/doc/asio/reference/experimental__parallel_group/parallel_group.html
-/doc/asio/reference/experimental__parallel_group/signature.html
-/doc/asio/reference/experimental__promise/
-/doc/asio/reference/experimental__promise/cancel.html
-/doc/asio/reference/experimental__promise/completed.html
-/doc/asio/reference/experimental__promise.html
-/doc/asio/reference/experimental__promise/operator_lp__rp_.html
-/doc/asio/reference/experimental__promise/promise/
-/doc/asio/reference/experimental__promise/_promise.html
-/doc/asio/reference/experimental__promise/promise.html
-/doc/asio/reference/experimental__promise/promise/overload1.html
-/doc/asio/reference/experimental__promise/promise/overload2.html
-/doc/asio/reference/experimental__promise/promise/overload3.html
-/doc/asio/reference/experimental__promise_value_type/
-/doc/asio/reference/experimental__promise/value_type.html
-/doc/asio/reference/experimental__promise_value_type.html
-/doc/asio/reference/experimental__promise_value_type_lt__gt_/
-/doc/asio/reference/experimental__promise_value_type_lt__gt_.html
-/doc/asio/reference/experimental__promise_value_type_lt__gt_/type.html
-/doc/asio/reference/experimental__promise_value_type_lt__T__gt_/
-/doc/asio/reference/experimental__promise_value_type_lt__T__gt_.html
-/doc/asio/reference/experimental__promise_value_type_lt__T__gt_/type.html
-/doc/asio/reference/experimental__promise_value_type/type.html
-/doc/asio/reference/experimental__ranged_parallel_group/
-/doc/asio/reference/experimental__ranged_parallel_group/async_wait.html
-/doc/asio/reference/experimental__ranged_parallel_group.html
-/doc/asio/reference/experimental__ranged_parallel_group/ranged_parallel_group.html
-/doc/asio/reference/experimental__ranged_parallel_group/signature.html
-/doc/asio/reference/experimental__task.html
-/doc/asio/reference/experimental__use_coro.html
-/doc/asio/reference/experimental__use_coro_t/
-/doc/asio/reference/experimental__use_coro_t/allocator_type.html
-/doc/asio/reference/experimental__use_coro_t/as_default_on.html
-/doc/asio/reference/experimental__use_coro_t/as_default_on_t.html
-/doc/asio/reference/experimental__use_coro_t__executor_with_default/
-/doc/asio/reference/experimental__use_coro_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/experimental__use_coro_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/experimental__use_coro_t__executor_with_default.html
-/doc/asio/reference/experimental__use_coro_t/get_allocator.html
-/doc/asio/reference/experimental__use_coro_t.html
-/doc/asio/reference/experimental__use_coro_t/rebind.html
-/doc/asio/reference/experimental__use_coro_t/use_coro_t/
-/doc/asio/reference/experimental__use_coro_t/use_coro_t.html
-/doc/asio/reference/experimental__use_coro_t/use_coro_t/overload1.html
-/doc/asio/reference/experimental__use_coro_t/use_coro_t/overload2.html
-/doc/asio/reference/experimental__use_promise.html
-/doc/asio/reference/experimental__use_promise_t/
-/doc/asio/reference/experimental__use_promise_t/allocator_type.html
-/doc/asio/reference/experimental__use_promise_t/as_default_on.html
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/overload1.html
-/doc/asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/overload2.html
-/doc/asio/reference/experimental__use_promise_t__executor_with_default.html
-/doc/asio/reference/experimental__use_promise_t/get_allocator.html
-/doc/asio/reference/experimental__use_promise_t.html
-/doc/asio/reference/experimental__use_promise_t/rebind.html
-/doc/asio/reference/experimental__use_promise_t/use_promise_t/
-/doc/asio/reference/experimental__use_promise_t/use_promise_t.html
-/doc/asio/reference/experimental__use_promise_t/use_promise_t/overload1.html
-/doc/asio/reference/experimental__use_promise_t/use_promise_t/overload2.html
-/doc/asio/reference/experimental__wait_for_all/
-/doc/asio/reference/experimental__wait_for_all.html
-/doc/asio/reference/experimental__wait_for_all/operator_lp__rp_.html
-/doc/asio/reference/experimental__wait_for_one/
-/doc/asio/reference/experimental__wait_for_one_error/
-/doc/asio/reference/experimental__wait_for_one_error.html
-/doc/asio/reference/experimental__wait_for_one_error/operator_lp__rp_/
-/doc/asio/reference/experimental__wait_for_one_error/operator_lp__rp_.html
-/doc/asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload1.html
-/doc/asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload2.html
-/doc/asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload3.html
-/doc/asio/reference/experimental__wait_for_one_error/wait_for_one_error.html
-/doc/asio/reference/experimental__wait_for_one.html
-/doc/asio/reference/experimental__wait_for_one/operator_lp__rp_.html
-/doc/asio/reference/experimental__wait_for_one_success/
-/doc/asio/reference/experimental__wait_for_one_success.html
-/doc/asio/reference/experimental__wait_for_one_success/operator_lp__rp_/
-/doc/asio/reference/experimental__wait_for_one_success/operator_lp__rp_.html
-/doc/asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload1.html
-/doc/asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload2.html
-/doc/asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload3.html
-/doc/asio/reference/experimental__wait_for_one_success/wait_for_one_success.html
-/doc/asio/reference/experimental__wait_for_one/wait_for_one.html
-/doc/asio/reference/file_base/
-/doc/asio/reference/file_base/append.html
-/doc/asio/reference/file_base/create.html
-/doc/asio/reference/file_base/exclusive.html
-/doc/asio/reference/file_base/_file_base.html
-/doc/asio/reference/file_base/flags.html
-/doc/asio/reference/file_base.html
-/doc/asio/reference/file_base/read_only.html
-/doc/asio/reference/file_base/read_write.html
-/doc/asio/reference/file_base/seek_basis.html
-/doc/asio/reference/file_base/sync_all_on_write.html
-/doc/asio/reference/file_base/truncate.html
-/doc/asio/reference/file_base/write_only.html
-/doc/asio/reference/generic__basic_endpoint/
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint.html
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/overload1.html
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/overload2.html
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/overload3.html
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/overload4.html
-/doc/asio/reference/generic__basic_endpoint/basic_endpoint/overload5.html
-/doc/asio/reference/generic__basic_endpoint/capacity.html
-/doc/asio/reference/generic__basic_endpoint/data/
-/doc/asio/reference/generic__basic_endpoint/data.html
-/doc/asio/reference/generic__basic_endpoint/data/overload1.html
-/doc/asio/reference/generic__basic_endpoint/data/overload2.html
-/doc/asio/reference/generic__basic_endpoint/data_type.html
-/doc/asio/reference/generic__basic_endpoint.html
-/doc/asio/reference/generic__basic_endpoint/operator_eq_/
-/doc/asio/reference/generic__basic_endpoint/operator_eq__eq_.html
-/doc/asio/reference/generic__basic_endpoint/operator_eq_.html
-/doc/asio/reference/generic__basic_endpoint/operator_eq_/overload1.html
-/doc/asio/reference/generic__basic_endpoint/operator_eq_/overload2.html
-/doc/asio/reference/generic__basic_endpoint/operator_gt__eq_.html
-/doc/asio/reference/generic__basic_endpoint/operator_gt_.html
-/doc/asio/reference/generic__basic_endpoint/operator_lt__eq_.html
-/doc/asio/reference/generic__basic_endpoint/operator_lt_.html
-/doc/asio/reference/generic__basic_endpoint/operator_not__eq_.html
-/doc/asio/reference/generic__basic_endpoint/protocol.html
-/doc/asio/reference/generic__basic_endpoint/protocol_type.html
-/doc/asio/reference/generic__basic_endpoint/resize.html
-/doc/asio/reference/generic__basic_endpoint/size.html
-/doc/asio/reference/generic__datagram_protocol/
-/doc/asio/reference/generic__datagram_protocol/datagram_protocol/
-/doc/asio/reference/generic__datagram_protocol/datagram_protocol.html
-/doc/asio/reference/generic__datagram_protocol/datagram_protocol/overload1.html
-/doc/asio/reference/generic__datagram_protocol/datagram_protocol/overload2.html
-/doc/asio/reference/generic__datagram_protocol/endpoint.html
-/doc/asio/reference/generic__datagram_protocol/family.html
-/doc/asio/reference/generic__datagram_protocol.html
-/doc/asio/reference/generic__datagram_protocol/operator_eq__eq_.html
-/doc/asio/reference/generic__datagram_protocol/operator_not__eq_.html
-/doc/asio/reference/generic__datagram_protocol/protocol.html
-/doc/asio/reference/generic__datagram_protocol/socket.html
-/doc/asio/reference/generic__datagram_protocol/type.html
-/doc/asio/reference/generic__raw_protocol/
-/doc/asio/reference/generic__raw_protocol/endpoint.html
-/doc/asio/reference/generic__raw_protocol/family.html
-/doc/asio/reference/generic__raw_protocol.html
-/doc/asio/reference/generic__raw_protocol/operator_eq__eq_.html
-/doc/asio/reference/generic__raw_protocol/operator_not__eq_.html
-/doc/asio/reference/generic__raw_protocol/protocol.html
-/doc/asio/reference/generic__raw_protocol/raw_protocol/
-/doc/asio/reference/generic__raw_protocol/raw_protocol.html
-/doc/asio/reference/generic__raw_protocol/raw_protocol/overload1.html
-/doc/asio/reference/generic__raw_protocol/raw_protocol/overload2.html
-/doc/asio/reference/generic__raw_protocol/socket.html
-/doc/asio/reference/generic__raw_protocol/type.html
-/doc/asio/reference/generic__seq_packet_protocol/
-/doc/asio/reference/generic__seq_packet_protocol/endpoint.html
-/doc/asio/reference/generic__seq_packet_protocol/family.html
-/doc/asio/reference/generic__seq_packet_protocol.html
-/doc/asio/reference/generic__seq_packet_protocol/operator_eq__eq_.html
-/doc/asio/reference/generic__seq_packet_protocol/operator_not__eq_.html
-/doc/asio/reference/generic__seq_packet_protocol/protocol.html
-/doc/asio/reference/generic__seq_packet_protocol/seq_packet_protocol/
-/doc/asio/reference/generic__seq_packet_protocol/seq_packet_protocol.html
-/doc/asio/reference/generic__seq_packet_protocol/seq_packet_protocol/overload1.html
-/doc/asio/reference/generic__seq_packet_protocol/seq_packet_protocol/overload2.html
-/doc/asio/reference/generic__seq_packet_protocol/socket.html
-/doc/asio/reference/generic__seq_packet_protocol/type.html
-/doc/asio/reference/generic__stream_protocol/
-/doc/asio/reference/generic__stream_protocol/endpoint.html
-/doc/asio/reference/generic__stream_protocol/family.html
-/doc/asio/reference/generic__stream_protocol.html
-/doc/asio/reference/generic__stream_protocol/iostream.html
-/doc/asio/reference/generic__stream_protocol/operator_eq__eq_.html
-/doc/asio/reference/generic__stream_protocol/operator_not__eq_.html
-/doc/asio/reference/generic__stream_protocol/protocol.html
-/doc/asio/reference/generic__stream_protocol/socket.html
-/doc/asio/reference/generic__stream_protocol/stream_protocol/
-/doc/asio/reference/generic__stream_protocol/stream_protocol.html
-/doc/asio/reference/generic__stream_protocol/stream_protocol/overload1.html
-/doc/asio/reference/generic__stream_protocol/stream_protocol/overload2.html
-/doc/asio/reference/generic__stream_protocol/type.html
-/doc/asio/reference/get_associated_allocator/
-/doc/asio/reference/get_associated_allocator.html
-/doc/asio/reference/get_associated_allocator/overload1.html
-/doc/asio/reference/get_associated_allocator/overload2.html
-/doc/asio/reference/get_associated_cancellation_slot/
-/doc/asio/reference/get_associated_cancellation_slot.html
-/doc/asio/reference/get_associated_cancellation_slot/overload1.html
-/doc/asio/reference/get_associated_cancellation_slot/overload2.html
-/doc/asio/reference/get_associated_executor/
-/doc/asio/reference/get_associated_executor.html
-/doc/asio/reference/get_associated_executor/overload1.html
-/doc/asio/reference/get_associated_executor/overload2.html
-/doc/asio/reference/get_associated_executor/overload3.html
-/doc/asio/reference/get_associated_immediate_executor/
-/doc/asio/reference/get_associated_immediate_executor.html
-/doc/asio/reference/get_associated_immediate_executor/overload1.html
-/doc/asio/reference/get_associated_immediate_executor/overload2.html
-/doc/asio/reference/GettableSerialPortOption.html
-/doc/asio/reference/GettableSocketOption.html
-/doc/asio/reference/Handler.html
-/doc/asio/reference/HandshakeHandler.html
-/doc/asio/reference/HandshakeToken.html
-/doc/asio/reference/high_resolution_timer.html
-/doc/asio/reference.html
-/doc/asio/reference/immediate_executor_binder/
-/doc/asio/reference/immediate_executor_binder/argument_type.html
-/doc/asio/reference/immediate_executor_binder/first_argument_type.html
-/doc/asio/reference/immediate_executor_binder/get/
-/doc/asio/reference/immediate_executor_binder/get.html
-/doc/asio/reference/immediate_executor_binder/get_immediate_executor.html
-/doc/asio/reference/immediate_executor_binder/get/overload1.html
-/doc/asio/reference/immediate_executor_binder/get/overload2.html
-/doc/asio/reference/immediate_executor_binder.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/
-/doc/asio/reference/immediate_executor_binder/_immediate_executor_binder.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload1.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload2.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload3.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload4.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload5.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload6.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload7.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload8.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_binder/overload9.html
-/doc/asio/reference/immediate_executor_binder/immediate_executor_type.html
-/doc/asio/reference/immediate_executor_binder/operator_lp__rp_/
-/doc/asio/reference/immediate_executor_binder/operator_lp__rp_.html
-/doc/asio/reference/immediate_executor_binder/operator_lp__rp_/overload1.html
-/doc/asio/reference/immediate_executor_binder/operator_lp__rp_/overload2.html
-/doc/asio/reference/immediate_executor_binder/result_type.html
-/doc/asio/reference/immediate_executor_binder/second_argument_type.html
-/doc/asio/reference/immediate_executor_binder/target_type.html
-/doc/asio/reference/InternetProtocol.html
-/doc/asio/reference/invalid_service_owner/
-/doc/asio/reference/invalid_service_owner.html
-/doc/asio/reference/invalid_service_owner/invalid_service_owner.html
-/doc/asio/reference/io_context/
-/doc/asio/reference/io_context__basic_executor_type/
-/doc/asio/reference/io_context__basic_executor_type/basic_executor_type/
-/doc/asio/reference/io_context__basic_executor_type/_basic_executor_type.html
-/doc/asio/reference/io_context__basic_executor_type/basic_executor_type.html
-/doc/asio/reference/io_context__basic_executor_type/basic_executor_type/overload1.html
-/doc/asio/reference/io_context__basic_executor_type/basic_executor_type/overload2.html
-/doc/asio/reference/io_context__basic_executor_type/context.html
-/doc/asio/reference/io_context__basic_executor_type/defer.html
-/doc/asio/reference/io_context__basic_executor_type/dispatch.html
-/doc/asio/reference/io_context__basic_executor_type/execute.html
-/doc/asio/reference/io_context__basic_executor_type.html
-/doc/asio/reference/io_context__basic_executor_type/on_work_finished.html
-/doc/asio/reference/io_context__basic_executor_type/on_work_started.html
-/doc/asio/reference/io_context__basic_executor_type/operator_eq_/
-/doc/asio/reference/io_context__basic_executor_type/operator_eq__eq_.html
-/doc/asio/reference/io_context__basic_executor_type/operator_eq_.html
-/doc/asio/reference/io_context__basic_executor_type/operator_eq_/overload1.html
-/doc/asio/reference/io_context__basic_executor_type/operator_eq_/overload2.html
-/doc/asio/reference/io_context__basic_executor_type/operator_not__eq_.html
-/doc/asio/reference/io_context__basic_executor_type/post.html
-/doc/asio/reference/io_context__basic_executor_type/query/
-/doc/asio/reference/io_context__basic_executor_type/query.html
-/doc/asio/reference/io_context__basic_executor_type/query/overload1.html
-/doc/asio/reference/io_context__basic_executor_type/query/overload2.html
-/doc/asio/reference/io_context__basic_executor_type/query/overload3.html
-/doc/asio/reference/io_context__basic_executor_type/query/overload4.html
-/doc/asio/reference/io_context__basic_executor_type/query/overload5.html
-/doc/asio/reference/io_context__basic_executor_type/query__static/
-/doc/asio/reference/io_context__basic_executor_type/query__static.html
-/doc/asio/reference/io_context__basic_executor_type/query__static/overload1.html
-/doc/asio/reference/io_context__basic_executor_type/query__static/overload2.html
-/doc/asio/reference/io_context__basic_executor_type/require/
-/doc/asio/reference/io_context__basic_executor_type/require.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload1.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload2.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload3.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload4.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload5.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload6.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload7.html
-/doc/asio/reference/io_context__basic_executor_type/require/overload8.html
-/doc/asio/reference/io_context__basic_executor_type/running_in_this_thread.html
-/doc/asio/reference/io_context/count_type.html
-/doc/asio/reference/io_context/destroy.html
-/doc/asio/reference/io_context/dispatch.html
-/doc/asio/reference/io_context/executor_type.html
-/doc/asio/reference/io_context/fork_event.html
-/doc/asio/reference/io_context/get_executor.html
-/doc/asio/reference/io_context.html
-/doc/asio/reference/io_context/io_context/
-/doc/asio/reference/io_context/_io_context.html
-/doc/asio/reference/io_context/io_context.html
-/doc/asio/reference/io_context/io_context/overload1.html
-/doc/asio/reference/io_context/io_context/overload2.html
-/doc/asio/reference/io_context/notify_fork.html
-/doc/asio/reference/io_context/poll/
-/doc/asio/reference/io_context/poll.html
-/doc/asio/reference/io_context/poll_one/
-/doc/asio/reference/io_context/poll_one.html
-/doc/asio/reference/io_context/poll_one/overload1.html
-/doc/asio/reference/io_context/poll_one/overload2.html
-/doc/asio/reference/io_context/poll/overload1.html
-/doc/asio/reference/io_context/poll/overload2.html
-/doc/asio/reference/io_context/post.html
-/doc/asio/reference/io_context/reset.html
-/doc/asio/reference/io_context/restart.html
-/doc/asio/reference/io_context/run/
-/doc/asio/reference/io_context/run_for.html
-/doc/asio/reference/io_context/run.html
-/doc/asio/reference/io_context/run_one/
-/doc/asio/reference/io_context/run_one_for.html
-/doc/asio/reference/io_context/run_one.html
-/doc/asio/reference/io_context/run_one/overload1.html
-/doc/asio/reference/io_context/run_one/overload2.html
-/doc/asio/reference/io_context/run_one_until.html
-/doc/asio/reference/io_context/run/overload1.html
-/doc/asio/reference/io_context/run/overload2.html
-/doc/asio/reference/io_context/run_until.html
-/doc/asio/reference/io_context__service/
-/doc/asio/reference/io_context__service/context.html
-/doc/asio/reference/io_context__service/get_io_context.html
-/doc/asio/reference/io_context__service.html
-/doc/asio/reference/io_context__service/_service.html
-/doc/asio/reference/io_context__service/service.html
-/doc/asio/reference/io_context/shutdown.html
-/doc/asio/reference/io_context/stop.html
-/doc/asio/reference/io_context/stopped.html
-/doc/asio/reference/io_context__strand/
-/doc/asio/reference/io_context__strand/context.html
-/doc/asio/reference/io_context__strand/defer.html
-/doc/asio/reference/io_context__strand/dispatch/
-/doc/asio/reference/io_context__strand/dispatch.html
-/doc/asio/reference/io_context__strand/dispatch/overload1.html
-/doc/asio/reference/io_context__strand/dispatch/overload2.html
-/doc/asio/reference/io_context__strand.html
-/doc/asio/reference/io_context__strand/on_work_finished.html
-/doc/asio/reference/io_context__strand/on_work_started.html
-/doc/asio/reference/io_context__strand/operator_eq__eq_.html
-/doc/asio/reference/io_context__strand/operator_not__eq_.html
-/doc/asio/reference/io_context__strand/post/
-/doc/asio/reference/io_context__strand/post.html
-/doc/asio/reference/io_context__strand/post/overload1.html
-/doc/asio/reference/io_context__strand/post/overload2.html
-/doc/asio/reference/io_context__strand/running_in_this_thread.html
-/doc/asio/reference/io_context__strand/strand/
-/doc/asio/reference/io_context__strand/_strand.html
-/doc/asio/reference/io_context__strand/strand.html
-/doc/asio/reference/io_context__strand/strand/overload1.html
-/doc/asio/reference/io_context__strand/strand/overload2.html
-/doc/asio/reference/io_context__strand/wrap.html
-/doc/asio/reference/io_context/use_service.html
-/doc/asio/reference/io_context__work/
-/doc/asio/reference/io_context__work/get_io_context.html
-/doc/asio/reference/io_context__work.html
-/doc/asio/reference/io_context__work/work/
-/doc/asio/reference/io_context__work/_work.html
-/doc/asio/reference/io_context__work/work.html
-/doc/asio/reference/io_context__work/work/overload1.html
-/doc/asio/reference/io_context__work/work/overload2.html
-/doc/asio/reference/io_context/wrap.html
-/doc/asio/reference/IoControlCommand.html
-/doc/asio/reference/IoObjectService.html
-/doc/asio/reference/io_service.html
-/doc/asio/reference/ip__address/
-/doc/asio/reference/ip__address/address/
-/doc/asio/reference/ip__address/address.html
-/doc/asio/reference/ip__address/address/overload1.html
-/doc/asio/reference/ip__address/address/overload2.html
-/doc/asio/reference/ip__address/address/overload3.html
-/doc/asio/reference/ip__address/address/overload4.html
-/doc/asio/reference/ip__address/address/overload5.html
-/doc/asio/reference/ip__address/from_string/
-/doc/asio/reference/ip__address/from_string.html
-/doc/asio/reference/ip__address/from_string/overload1.html
-/doc/asio/reference/ip__address/from_string/overload2.html
-/doc/asio/reference/ip__address/from_string/overload3.html
-/doc/asio/reference/ip__address/from_string/overload4.html
-/doc/asio/reference/ip__address__gt_/
-/doc/asio/reference/ip__address__gt_.html
-/doc/asio/reference/ip__address__gt_/operator_lp__rp_.html
-/doc/asio/reference/ip__address.html
-/doc/asio/reference/ip__address/is_loopback.html
-/doc/asio/reference/ip__address/is_multicast.html
-/doc/asio/reference/ip__address/is_unspecified.html
-/doc/asio/reference/ip__address/is_v4.html
-/doc/asio/reference/ip__address/is_v6.html
-/doc/asio/reference/ip__address/make_address/
-/doc/asio/reference/ip__address/make_address.html
-/doc/asio/reference/ip__address/make_address/overload1.html
-/doc/asio/reference/ip__address/make_address/overload2.html
-/doc/asio/reference/ip__address/make_address/overload3.html
-/doc/asio/reference/ip__address/make_address/overload4.html
-/doc/asio/reference/ip__address/make_address/overload5.html
-/doc/asio/reference/ip__address/make_address/overload6.html
-/doc/asio/reference/ip__address/operator_eq_/
-/doc/asio/reference/ip__address/operator_eq__eq_.html
-/doc/asio/reference/ip__address/operator_eq_.html
-/doc/asio/reference/ip__address/operator_eq_/overload1.html
-/doc/asio/reference/ip__address/operator_eq_/overload2.html
-/doc/asio/reference/ip__address/operator_eq_/overload3.html
-/doc/asio/reference/ip__address/operator_eq_/overload4.html
-/doc/asio/reference/ip__address/operator_gt__eq_.html
-/doc/asio/reference/ip__address/operator_gt_.html
-/doc/asio/reference/ip__address/operator_lt__eq_.html
-/doc/asio/reference/ip__address/operator_lt_.html
-/doc/asio/reference/ip__address/operator_lt__lt_.html
-/doc/asio/reference/ip__address/operator_not__eq_.html
-/doc/asio/reference/ip__address/to_string/
-/doc/asio/reference/ip__address/to_string.html
-/doc/asio/reference/ip__address/to_string/overload1.html
-/doc/asio/reference/ip__address/to_string/overload2.html
-/doc/asio/reference/ip__address/to_v4.html
-/doc/asio/reference/ip__address/to_v6.html
-/doc/asio/reference/ip__address_v4/
-/doc/asio/reference/ip__address_v4/address_v4/
-/doc/asio/reference/ip__address_v4/address_v4.html
-/doc/asio/reference/ip__address_v4/address_v4/overload1.html
-/doc/asio/reference/ip__address_v4/address_v4/overload2.html
-/doc/asio/reference/ip__address_v4/address_v4/overload3.html
-/doc/asio/reference/ip__address_v4/address_v4/overload4.html
-/doc/asio/reference/ip__address_v4/address_v4/overload5.html
-/doc/asio/reference/ip__address_v4/any.html
-/doc/asio/reference/ip__address_v4/broadcast/
-/doc/asio/reference/ip__address_v4/broadcast.html
-/doc/asio/reference/ip__address_v4/broadcast/overload1.html
-/doc/asio/reference/ip__address_v4/broadcast/overload2.html
-/doc/asio/reference/ip__address_v4/bytes_type.html
-/doc/asio/reference/ip__address_v4/from_string/
-/doc/asio/reference/ip__address_v4/from_string.html
-/doc/asio/reference/ip__address_v4/from_string/overload1.html
-/doc/asio/reference/ip__address_v4/from_string/overload2.html
-/doc/asio/reference/ip__address_v4/from_string/overload3.html
-/doc/asio/reference/ip__address_v4/from_string/overload4.html
-/doc/asio/reference/ip__address_v4__gt_/
-/doc/asio/reference/ip__address_v4__gt_.html
-/doc/asio/reference/ip__address_v4__gt_/operator_lp__rp_.html
-/doc/asio/reference/ip__address_v4.html
-/doc/asio/reference/ip__address_v4/is_class_a.html
-/doc/asio/reference/ip__address_v4/is_class_b.html
-/doc/asio/reference/ip__address_v4/is_class_c.html
-/doc/asio/reference/ip__address_v4/is_loopback.html
-/doc/asio/reference/ip__address_v4/is_multicast.html
-/doc/asio/reference/ip__address_v4/is_unspecified.html
-/doc/asio/reference/ip__address_v4_iterator.html
-/doc/asio/reference/ip__address_v4/loopback.html
-/doc/asio/reference/ip__address_v4/make_address_v4/
-/doc/asio/reference/ip__address_v4/make_address_v4.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload1.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload2.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload3.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload4.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload5.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload6.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload7.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload8.html
-/doc/asio/reference/ip__address_v4/make_address_v4/overload9.html
-/doc/asio/reference/ip__address_v4/make_network_v4/
-/doc/asio/reference/ip__address_v4/make_network_v4.html
-/doc/asio/reference/ip__address_v4/make_network_v4/overload1.html
-/doc/asio/reference/ip__address_v4/make_network_v4/overload2.html
-/doc/asio/reference/ip__address_v4/netmask.html
-/doc/asio/reference/ip__address_v4/operator_eq_/
-/doc/asio/reference/ip__address_v4/operator_eq__eq_.html
-/doc/asio/reference/ip__address_v4/operator_eq_.html
-/doc/asio/reference/ip__address_v4/operator_eq_/overload1.html
-/doc/asio/reference/ip__address_v4/operator_eq_/overload2.html
-/doc/asio/reference/ip__address_v4/operator_gt__eq_.html
-/doc/asio/reference/ip__address_v4/operator_gt_.html
-/doc/asio/reference/ip__address_v4/operator_lt__eq_.html
-/doc/asio/reference/ip__address_v4/operator_lt_.html
-/doc/asio/reference/ip__address_v4/operator_lt__lt_/
-/doc/asio/reference/ip__address_v4/operator_lt__lt_.html
-/doc/asio/reference/ip__address_v4/operator_lt__lt_/overload1.html
-/doc/asio/reference/ip__address_v4/operator_lt__lt_/overload2.html
-/doc/asio/reference/ip__address_v4/operator_not__eq_.html
-/doc/asio/reference/ip__address_v4_range.html
-/doc/asio/reference/ip__address_v4/to_bytes.html
-/doc/asio/reference/ip__address_v4/to_string/
-/doc/asio/reference/ip__address_v4/to_string.html
-/doc/asio/reference/ip__address_v4/to_string/overload1.html
-/doc/asio/reference/ip__address_v4/to_string/overload2.html
-/doc/asio/reference/ip__address_v4/to_uint.html
-/doc/asio/reference/ip__address_v4/to_ulong.html
-/doc/asio/reference/ip__address_v4/uint_type.html
-/doc/asio/reference/ip__address_v6/
-/doc/asio/reference/ip__address_v6/address_v6/
-/doc/asio/reference/ip__address_v6/address_v6.html
-/doc/asio/reference/ip__address_v6/address_v6/overload1.html
-/doc/asio/reference/ip__address_v6/address_v6/overload2.html
-/doc/asio/reference/ip__address_v6/address_v6/overload3.html
-/doc/asio/reference/ip__address_v6/address_v6/overload4.html
-/doc/asio/reference/ip__address_v6/any.html
-/doc/asio/reference/ip__address_v6/bytes_type.html
-/doc/asio/reference/ip__address_v6/from_string/
-/doc/asio/reference/ip__address_v6/from_string.html
-/doc/asio/reference/ip__address_v6/from_string/overload1.html
-/doc/asio/reference/ip__address_v6/from_string/overload2.html
-/doc/asio/reference/ip__address_v6/from_string/overload3.html
-/doc/asio/reference/ip__address_v6/from_string/overload4.html
-/doc/asio/reference/ip__address_v6__gt_/
-/doc/asio/reference/ip__address_v6__gt_.html
-/doc/asio/reference/ip__address_v6__gt_/operator_lp__rp_.html
-/doc/asio/reference/ip__address_v6.html
-/doc/asio/reference/ip__address_v6/is_link_local.html
-/doc/asio/reference/ip__address_v6/is_loopback.html
-/doc/asio/reference/ip__address_v6/is_multicast_global.html
-/doc/asio/reference/ip__address_v6/is_multicast.html
-/doc/asio/reference/ip__address_v6/is_multicast_link_local.html
-/doc/asio/reference/ip__address_v6/is_multicast_node_local.html
-/doc/asio/reference/ip__address_v6/is_multicast_org_local.html
-/doc/asio/reference/ip__address_v6/is_multicast_site_local.html
-/doc/asio/reference/ip__address_v6/is_site_local.html
-/doc/asio/reference/ip__address_v6/is_unspecified.html
-/doc/asio/reference/ip__address_v6/is_v4_compatible.html
-/doc/asio/reference/ip__address_v6/is_v4_mapped.html
-/doc/asio/reference/ip__address_v6_iterator.html
-/doc/asio/reference/ip__address_v6/loopback.html
-/doc/asio/reference/ip__address_v6/make_address_v6/
-/doc/asio/reference/ip__address_v6/make_address_v6.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload1.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload2.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload3.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload4.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload5.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload6.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload7.html
-/doc/asio/reference/ip__address_v6/make_address_v6/overload8.html
-/doc/asio/reference/ip__address_v6/make_network_v6.html
-/doc/asio/reference/ip__address_v6/operator_eq_/
-/doc/asio/reference/ip__address_v6/operator_eq__eq_.html
-/doc/asio/reference/ip__address_v6/operator_eq_.html
-/doc/asio/reference/ip__address_v6/operator_eq_/overload1.html
-/doc/asio/reference/ip__address_v6/operator_eq_/overload2.html
-/doc/asio/reference/ip__address_v6/operator_gt__eq_.html
-/doc/asio/reference/ip__address_v6/operator_gt_.html
-/doc/asio/reference/ip__address_v6/operator_lt__eq_.html
-/doc/asio/reference/ip__address_v6/operator_lt_.html
-/doc/asio/reference/ip__address_v6/operator_lt__lt_/
-/doc/asio/reference/ip__address_v6/operator_lt__lt_.html
-/doc/asio/reference/ip__address_v6/operator_lt__lt_/overload1.html
-/doc/asio/reference/ip__address_v6/operator_lt__lt_/overload2.html
-/doc/asio/reference/ip__address_v6/operator_not__eq_.html
-/doc/asio/reference/ip__address_v6_range.html
-/doc/asio/reference/ip__address_v6/scope_id/
-/doc/asio/reference/ip__address_v6/scope_id.html
-/doc/asio/reference/ip__address_v6/scope_id/overload1.html
-/doc/asio/reference/ip__address_v6/scope_id/overload2.html
-/doc/asio/reference/ip__address_v6/to_bytes.html
-/doc/asio/reference/ip__address_v6/to_string/
-/doc/asio/reference/ip__address_v6/to_string.html
-/doc/asio/reference/ip__address_v6/to_string/overload1.html
-/doc/asio/reference/ip__address_v6/to_string/overload2.html
-/doc/asio/reference/ip__address_v6/to_v4.html
-/doc/asio/reference/ip__address_v6/v4_compatible.html
-/doc/asio/reference/ip__address_v6/v4_mapped.html
-/doc/asio/reference/ip__bad_address_cast/
-/doc/asio/reference/ip__bad_address_cast/bad_address_cast/
-/doc/asio/reference/ip__bad_address_cast/_bad_address_cast.html
-/doc/asio/reference/ip__bad_address_cast/bad_address_cast.html
-/doc/asio/reference/ip__bad_address_cast/bad_address_cast/overload1.html
-/doc/asio/reference/ip__bad_address_cast/bad_address_cast/overload2.html
-/doc/asio/reference/ip__bad_address_cast.html
-/doc/asio/reference/ip__bad_address_cast/what.html
-/doc/asio/reference/ip__basic_address_iterator.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload3.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/difference_type.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/iterator_category.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_arrow_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq__eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_not__eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_star_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/pointer.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/reference.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/value_type.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload3.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/difference_type.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/iterator_category.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_arrow_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq__eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_not__eq_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/overload1.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/overload2.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_star_.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/pointer.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/reference.html
-/doc/asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/value_type.html
-/doc/asio/reference/ip__basic_address_range.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload1.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload2.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload3.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload4.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/begin.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/empty.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/end.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/find.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/iterator.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v4__gt_/size.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload1.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload2.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload3.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload4.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/begin.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/empty.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/end.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/find.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/iterator.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_endpoint/
-/doc/asio/reference/ip__basic_endpoint/address/
-/doc/asio/reference/ip__basic_endpoint/address.html
-/doc/asio/reference/ip__basic_endpoint/address/overload1.html
-/doc/asio/reference/ip__basic_endpoint/address/overload2.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/overload1.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/overload2.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/overload3.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/overload4.html
-/doc/asio/reference/ip__basic_endpoint/basic_endpoint/overload5.html
-/doc/asio/reference/ip__basic_endpoint/capacity.html
-/doc/asio/reference/ip__basic_endpoint/data/
-/doc/asio/reference/ip__basic_endpoint/data.html
-/doc/asio/reference/ip__basic_endpoint/data/overload1.html
-/doc/asio/reference/ip__basic_endpoint/data/overload2.html
-/doc/asio/reference/ip__basic_endpoint/data_type.html
-/doc/asio/reference/ip__basic_endpoint.html
-/doc/asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_/
-/doc/asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_.html
-/doc/asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_/operator_lp__rp_.html
-/doc/asio/reference/ip__basic_endpoint/operator_eq_/
-/doc/asio/reference/ip__basic_endpoint/operator_eq__eq_.html
-/doc/asio/reference/ip__basic_endpoint/operator_eq_.html
-/doc/asio/reference/ip__basic_endpoint/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_endpoint/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_endpoint/operator_gt__eq_.html
-/doc/asio/reference/ip__basic_endpoint/operator_gt_.html
-/doc/asio/reference/ip__basic_endpoint/operator_lt__eq_.html
-/doc/asio/reference/ip__basic_endpoint/operator_lt_.html
-/doc/asio/reference/ip__basic_endpoint/operator_lt__lt_.html
-/doc/asio/reference/ip__basic_endpoint/operator_not__eq_.html
-/doc/asio/reference/ip__basic_endpoint/port/
-/doc/asio/reference/ip__basic_endpoint/port.html
-/doc/asio/reference/ip__basic_endpoint/port/overload1.html
-/doc/asio/reference/ip__basic_endpoint/port/overload2.html
-/doc/asio/reference/ip__basic_endpoint/protocol.html
-/doc/asio/reference/ip__basic_endpoint/protocol_type.html
-/doc/asio/reference/ip__basic_endpoint/resize.html
-/doc/asio/reference/ip__basic_endpoint/size.html
-/doc/asio/reference/ip__basic_resolver/
-/doc/asio/reference/ip__basic_resolver/address_configured.html
-/doc/asio/reference/ip__basic_resolver/all_matching.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/
-/doc/asio/reference/ip__basic_resolver/async_resolve.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload1.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload2.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload3.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload4.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload5.html
-/doc/asio/reference/ip__basic_resolver/async_resolve/overload6.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver/
-/doc/asio/reference/ip__basic_resolver/_basic_resolver.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver/overload1.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver/overload2.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver/overload3.html
-/doc/asio/reference/ip__basic_resolver/basic_resolver/overload4.html
-/doc/asio/reference/ip__basic_resolver/cancel.html
-/doc/asio/reference/ip__basic_resolver/canonical_name.html
-/doc/asio/reference/ip__basic_resolver/endpoint_type.html
-/doc/asio/reference/ip__basic_resolver_entry/
-/doc/asio/reference/ip__basic_resolver_entry/basic_resolver_entry/
-/doc/asio/reference/ip__basic_resolver_entry/basic_resolver_entry.html
-/doc/asio/reference/ip__basic_resolver_entry/basic_resolver_entry/overload1.html
-/doc/asio/reference/ip__basic_resolver_entry/basic_resolver_entry/overload2.html
-/doc/asio/reference/ip__basic_resolver_entry/endpoint.html
-/doc/asio/reference/ip__basic_resolver_entry/endpoint_type.html
-/doc/asio/reference/ip__basic_resolver_entry/host_name/
-/doc/asio/reference/ip__basic_resolver_entry/host_name.html
-/doc/asio/reference/ip__basic_resolver_entry/host_name/overload1.html
-/doc/asio/reference/ip__basic_resolver_entry/host_name/overload2.html
-/doc/asio/reference/ip__basic_resolver_entry.html
-/doc/asio/reference/ip__basic_resolver_entry/operator_endpoint_type.html
-/doc/asio/reference/ip__basic_resolver_entry/protocol_type.html
-/doc/asio/reference/ip__basic_resolver_entry/service_name/
-/doc/asio/reference/ip__basic_resolver_entry/service_name.html
-/doc/asio/reference/ip__basic_resolver_entry/service_name/overload1.html
-/doc/asio/reference/ip__basic_resolver_entry/service_name/overload2.html
-/doc/asio/reference/ip__basic_resolver/executor_type.html
-/doc/asio/reference/ip__basic_resolver/flags.html
-/doc/asio/reference/ip__basic_resolver/get_executor.html
-/doc/asio/reference/ip__basic_resolver.html
-/doc/asio/reference/ip__basic_resolver_iterator/
-/doc/asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/
-/doc/asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator.html
-/doc/asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload1.html
-/doc/asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload2.html
-/doc/asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload3.html
-/doc/asio/reference/ip__basic_resolver_iterator/dereference.html
-/doc/asio/reference/ip__basic_resolver_iterator/difference_type.html
-/doc/asio/reference/ip__basic_resolver_iterator/equal.html
-/doc/asio/reference/ip__basic_resolver/iterator.html
-/doc/asio/reference/ip__basic_resolver_iterator.html
-/doc/asio/reference/ip__basic_resolver_iterator/increment.html
-/doc/asio/reference/ip__basic_resolver_iterator/index_.html
-/doc/asio/reference/ip__basic_resolver_iterator/iterator_category.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_arrow_.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_eq_/
-/doc/asio/reference/ip__basic_resolver_iterator/operator_eq__eq_.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_eq_.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_not__eq_.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/
-/doc/asio/reference/ip__basic_resolver_iterator/operator_plus__plus_.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/overload1.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/overload2.html
-/doc/asio/reference/ip__basic_resolver_iterator/operator_star_.html
-/doc/asio/reference/ip__basic_resolver_iterator/pointer.html
-/doc/asio/reference/ip__basic_resolver_iterator/reference.html
-/doc/asio/reference/ip__basic_resolver_iterator/values_.html
-/doc/asio/reference/ip__basic_resolver_iterator/value_type.html
-/doc/asio/reference/ip__basic_resolver/numeric_host.html
-/doc/asio/reference/ip__basic_resolver/numeric_service.html
-/doc/asio/reference/ip__basic_resolver/operator_eq_/
-/doc/asio/reference/ip__basic_resolver/operator_eq_.html
-/doc/asio/reference/ip__basic_resolver/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_resolver/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_resolver/passive.html
-/doc/asio/reference/ip__basic_resolver/protocol_type.html
-/doc/asio/reference/ip__basic_resolver_query/
-/doc/asio/reference/ip__basic_resolver_query/address_configured.html
-/doc/asio/reference/ip__basic_resolver_query/all_matching.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload1.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload2.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload3.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload4.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload5.html
-/doc/asio/reference/ip__basic_resolver_query/basic_resolver_query/overload6.html
-/doc/asio/reference/ip__basic_resolver_query/canonical_name.html
-/doc/asio/reference/ip__basic_resolver_query/flags.html
-/doc/asio/reference/ip__basic_resolver_query/hints.html
-/doc/asio/reference/ip__basic_resolver_query/host_name.html
-/doc/asio/reference/ip__basic_resolver/query.html
-/doc/asio/reference/ip__basic_resolver_query.html
-/doc/asio/reference/ip__basic_resolver_query/numeric_host.html
-/doc/asio/reference/ip__basic_resolver_query/numeric_service.html
-/doc/asio/reference/ip__basic_resolver_query/passive.html
-/doc/asio/reference/ip__basic_resolver_query/protocol_type.html
-/doc/asio/reference/ip__basic_resolver_query/service_name.html
-/doc/asio/reference/ip__basic_resolver_query/v4_mapped.html
-/doc/asio/reference/ip__basic_resolver__rebind_executor/
-/doc/asio/reference/ip__basic_resolver__rebind_executor.html
-/doc/asio/reference/ip__basic_resolver__rebind_executor/other.html
-/doc/asio/reference/ip__basic_resolver/resolve/
-/doc/asio/reference/ip__basic_resolver/resolve.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload10.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload11.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload12.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload1.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload2.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload3.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload4.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload5.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload6.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload7.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload8.html
-/doc/asio/reference/ip__basic_resolver/resolve/overload9.html
-/doc/asio/reference/ip__basic_resolver_results/
-/doc/asio/reference/ip__basic_resolver_results/basic_resolver_results/
-/doc/asio/reference/ip__basic_resolver_results/basic_resolver_results.html
-/doc/asio/reference/ip__basic_resolver_results/basic_resolver_results/overload1.html
-/doc/asio/reference/ip__basic_resolver_results/basic_resolver_results/overload2.html
-/doc/asio/reference/ip__basic_resolver_results/basic_resolver_results/overload3.html
-/doc/asio/reference/ip__basic_resolver_results/begin.html
-/doc/asio/reference/ip__basic_resolver_results/cbegin.html
-/doc/asio/reference/ip__basic_resolver_results/cend.html
-/doc/asio/reference/ip__basic_resolver_results/const_iterator.html
-/doc/asio/reference/ip__basic_resolver_results/const_reference.html
-/doc/asio/reference/ip__basic_resolver_results/dereference.html
-/doc/asio/reference/ip__basic_resolver_results/difference_type.html
-/doc/asio/reference/ip__basic_resolver_results/empty.html
-/doc/asio/reference/ip__basic_resolver_results/end.html
-/doc/asio/reference/ip__basic_resolver_results/endpoint_type.html
-/doc/asio/reference/ip__basic_resolver_results/equal.html
-/doc/asio/reference/ip__basic_resolver_results.html
-/doc/asio/reference/ip__basic_resolver_results/increment.html
-/doc/asio/reference/ip__basic_resolver_results/index_.html
-/doc/asio/reference/ip__basic_resolver_results/iterator_category.html
-/doc/asio/reference/ip__basic_resolver_results/iterator.html
-/doc/asio/reference/ip__basic_resolver_results/max_size.html
-/doc/asio/reference/ip__basic_resolver_results/operator_arrow_.html
-/doc/asio/reference/ip__basic_resolver_results/operator_eq_/
-/doc/asio/reference/ip__basic_resolver_results/operator_eq__eq_.html
-/doc/asio/reference/ip__basic_resolver_results/operator_eq_.html
-/doc/asio/reference/ip__basic_resolver_results/operator_eq_/overload1.html
-/doc/asio/reference/ip__basic_resolver_results/operator_eq_/overload2.html
-/doc/asio/reference/ip__basic_resolver_results/operator_not__eq_.html
-/doc/asio/reference/ip__basic_resolver_results/operator_plus__plus_/
-/doc/asio/reference/ip__basic_resolver_results/operator_plus__plus_.html
-/doc/asio/reference/ip__basic_resolver_results/operator_plus__plus_/overload1.html
-/doc/asio/reference/ip__basic_resolver_results/operator_plus__plus_/overload2.html
-/doc/asio/reference/ip__basic_resolver_results/operator_star_.html
-/doc/asio/reference/ip__basic_resolver_results/pointer.html
-/doc/asio/reference/ip__basic_resolver_results/protocol_type.html
-/doc/asio/reference/ip__basic_resolver_results/reference.html
-/doc/asio/reference/ip__basic_resolver_results/size.html
-/doc/asio/reference/ip__basic_resolver_results/size_type.html
-/doc/asio/reference/ip__basic_resolver_results/swap.html
-/doc/asio/reference/ip__basic_resolver/results_type.html
-/doc/asio/reference/ip__basic_resolver_results/values_.html
-/doc/asio/reference/ip__basic_resolver_results/value_type.html
-/doc/asio/reference/ip__basic_resolver/v4_mapped.html
-/doc/asio/reference/ip__host_name/
-/doc/asio/reference/ip__host_name.html
-/doc/asio/reference/ip__host_name/overload1.html
-/doc/asio/reference/ip__host_name/overload2.html
-/doc/asio/reference/ip__icmp/
-/doc/asio/reference/ip__icmp/endpoint.html
-/doc/asio/reference/ip__icmp/family.html
-/doc/asio/reference/ip__icmp.html
-/doc/asio/reference/ip__icmp/operator_eq__eq_.html
-/doc/asio/reference/ip__icmp/operator_not__eq_.html
-/doc/asio/reference/ip__icmp/protocol.html
-/doc/asio/reference/ip__icmp/resolver.html
-/doc/asio/reference/ip__icmp/socket.html
-/doc/asio/reference/ip__icmp/type.html
-/doc/asio/reference/ip__icmp/v4.html
-/doc/asio/reference/ip__icmp/v6.html
-/doc/asio/reference/ip__multicast__enable_loopback.html
-/doc/asio/reference/ip__multicast__hops.html
-/doc/asio/reference/ip__multicast__join_group.html
-/doc/asio/reference/ip__multicast__leave_group.html
-/doc/asio/reference/ip__multicast__outbound_interface.html
-/doc/asio/reference/ip__network_v4/
-/doc/asio/reference/ip__network_v4/address.html
-/doc/asio/reference/ip__network_v4/broadcast.html
-/doc/asio/reference/ip__network_v4/canonical.html
-/doc/asio/reference/ip__network_v4/hosts.html
-/doc/asio/reference/ip__network_v4.html
-/doc/asio/reference/ip__network_v4/is_host.html
-/doc/asio/reference/ip__network_v4/is_subnet_of.html
-/doc/asio/reference/ip__network_v4/make_network_v4/
-/doc/asio/reference/ip__network_v4/make_network_v4.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload1.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload2.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload3.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload4.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload5.html
-/doc/asio/reference/ip__network_v4/make_network_v4/overload6.html
-/doc/asio/reference/ip__network_v4/netmask.html
-/doc/asio/reference/ip__network_v4/network.html
-/doc/asio/reference/ip__network_v4/network_v4/
-/doc/asio/reference/ip__network_v4/network_v4.html
-/doc/asio/reference/ip__network_v4/network_v4/overload1.html
-/doc/asio/reference/ip__network_v4/network_v4/overload2.html
-/doc/asio/reference/ip__network_v4/network_v4/overload3.html
-/doc/asio/reference/ip__network_v4/network_v4/overload4.html
-/doc/asio/reference/ip__network_v4/network_v4/overload5.html
-/doc/asio/reference/ip__network_v4/operator_eq_/
-/doc/asio/reference/ip__network_v4/operator_eq__eq_.html
-/doc/asio/reference/ip__network_v4/operator_eq_.html
-/doc/asio/reference/ip__network_v4/operator_eq_/overload1.html
-/doc/asio/reference/ip__network_v4/operator_eq_/overload2.html
-/doc/asio/reference/ip__network_v4/operator_not__eq_.html
-/doc/asio/reference/ip__network_v4/prefix_length.html
-/doc/asio/reference/ip__network_v4/to_string/
-/doc/asio/reference/ip__network_v4/to_string.html
-/doc/asio/reference/ip__network_v4/to_string/overload1.html
-/doc/asio/reference/ip__network_v4/to_string/overload2.html
-/doc/asio/reference/ip__network_v6/
-/doc/asio/reference/ip__network_v6/address.html
-/doc/asio/reference/ip__network_v6/canonical.html
-/doc/asio/reference/ip__network_v6/hosts.html
-/doc/asio/reference/ip__network_v6.html
-/doc/asio/reference/ip__network_v6/is_host.html
-/doc/asio/reference/ip__network_v6/is_subnet_of.html
-/doc/asio/reference/ip__network_v6/make_network_v6/
-/doc/asio/reference/ip__network_v6/make_network_v6.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload1.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload2.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload3.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload4.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload5.html
-/doc/asio/reference/ip__network_v6/make_network_v6/overload6.html
-/doc/asio/reference/ip__network_v6/network.html
-/doc/asio/reference/ip__network_v6/network_v6/
-/doc/asio/reference/ip__network_v6/network_v6.html
-/doc/asio/reference/ip__network_v6/network_v6/overload1.html
-/doc/asio/reference/ip__network_v6/network_v6/overload2.html
-/doc/asio/reference/ip__network_v6/network_v6/overload3.html
-/doc/asio/reference/ip__network_v6/network_v6/overload4.html
-/doc/asio/reference/ip__network_v6/operator_eq_/
-/doc/asio/reference/ip__network_v6/operator_eq__eq_.html
-/doc/asio/reference/ip__network_v6/operator_eq_.html
-/doc/asio/reference/ip__network_v6/operator_eq_/overload1.html
-/doc/asio/reference/ip__network_v6/operator_eq_/overload2.html
-/doc/asio/reference/ip__network_v6/operator_not__eq_.html
-/doc/asio/reference/ip__network_v6/prefix_length.html
-/doc/asio/reference/ip__network_v6/to_string/
-/doc/asio/reference/ip__network_v6/to_string.html
-/doc/asio/reference/ip__network_v6/to_string/overload1.html
-/doc/asio/reference/ip__network_v6/to_string/overload2.html
-/doc/asio/reference/ip__port_type.html
-/doc/asio/reference/ip__resolver_base/
-/doc/asio/reference/ip__resolver_base/address_configured.html
-/doc/asio/reference/ip__resolver_base/all_matching.html
-/doc/asio/reference/ip__resolver_base/canonical_name.html
-/doc/asio/reference/ip__resolver_base/flags.html
-/doc/asio/reference/ip__resolver_base.html
-/doc/asio/reference/ip__resolver_base/numeric_host.html
-/doc/asio/reference/ip__resolver_base/numeric_service.html
-/doc/asio/reference/ip__resolver_base/passive.html
-/doc/asio/reference/ip__resolver_base/_resolver_base.html
-/doc/asio/reference/ip__resolver_base/v4_mapped.html
-/doc/asio/reference/ip__resolver_query_base/
-/doc/asio/reference/ip__resolver_query_base/address_configured.html
-/doc/asio/reference/ip__resolver_query_base/all_matching.html
-/doc/asio/reference/ip__resolver_query_base/canonical_name.html
-/doc/asio/reference/ip__resolver_query_base/flags.html
-/doc/asio/reference/ip__resolver_query_base.html
-/doc/asio/reference/ip__resolver_query_base/numeric_host.html
-/doc/asio/reference/ip__resolver_query_base/numeric_service.html
-/doc/asio/reference/ip__resolver_query_base/passive.html
-/doc/asio/reference/ip__resolver_query_base/_resolver_query_base.html
-/doc/asio/reference/ip__resolver_query_base/v4_mapped.html
-/doc/asio/reference/ip__scope_id_type.html
-/doc/asio/reference/ip__tcp/
-/doc/asio/reference/ip__tcp/acceptor.html
-/doc/asio/reference/ip__tcp/endpoint.html
-/doc/asio/reference/ip__tcp/family.html
-/doc/asio/reference/ip__tcp.html
-/doc/asio/reference/ip__tcp/iostream.html
-/doc/asio/reference/ip__tcp/no_delay.html
-/doc/asio/reference/ip__tcp/operator_eq__eq_.html
-/doc/asio/reference/ip__tcp/operator_not__eq_.html
-/doc/asio/reference/ip__tcp/protocol.html
-/doc/asio/reference/ip__tcp/resolver.html
-/doc/asio/reference/ip__tcp/socket.html
-/doc/asio/reference/ip__tcp/type.html
-/doc/asio/reference/ip__tcp/v4.html
-/doc/asio/reference/ip__tcp/v6.html
-/doc/asio/reference/ip__udp/
-/doc/asio/reference/ip__udp/endpoint.html
-/doc/asio/reference/ip__udp/family.html
-/doc/asio/reference/ip__udp.html
-/doc/asio/reference/ip__udp/operator_eq__eq_.html
-/doc/asio/reference/ip__udp/operator_not__eq_.html
-/doc/asio/reference/ip__udp/protocol.html
-/doc/asio/reference/ip__udp/resolver.html
-/doc/asio/reference/ip__udp/socket.html
-/doc/asio/reference/ip__udp/type.html
-/doc/asio/reference/ip__udp/v4.html
-/doc/asio/reference/ip__udp/v6.html
-/doc/asio/reference/ip__unicast__hops.html
-/doc/asio/reference/ip__v4_mapped_t.html
-/doc/asio/reference/ip__v6_only.html
-/doc/asio/reference/is_applicable_property.html
-/doc/asio/reference/is_async_operation.html
-/doc/asio/reference/is_completion_condition/
-/doc/asio/reference/is_completion_condition.html
-/doc/asio/reference/is_completion_condition/value.html
-/doc/asio/reference/is_connect_condition/
-/doc/asio/reference/is_connect_condition.html
-/doc/asio/reference/is_connect_condition/value.html
-/doc/asio/reference/is_const_buffer_sequence.html
-/doc/asio/reference/is_contiguous_iterator.html
-/doc/asio/reference/is_deferred.html
-/doc/asio/reference/is_dynamic_buffer.html
-/doc/asio/reference/is_dynamic_buffer_v1.html
-/doc/asio/reference/is_dynamic_buffer_v2.html
-/doc/asio/reference/is_endpoint_sequence/
-/doc/asio/reference/is_endpoint_sequence.html
-/doc/asio/reference/is_endpoint_sequence/value.html
-/doc/asio/reference/is_executor.html
-/doc/asio/reference/is_match_condition/
-/doc/asio/reference/is_match_condition.html
-/doc/asio/reference/is_match_condition/value.html
-/doc/asio/reference/is_mutable_buffer_sequence.html
-/doc/asio/reference/is_nothrow_prefer.html
-/doc/asio/reference/is_nothrow_query.html
-/doc/asio/reference/is_nothrow_require_concept.html
-/doc/asio/reference/is_nothrow_require.html
-/doc/asio/reference/is_read_buffered/
-/doc/asio/reference/is_read_buffered.html
-/doc/asio/reference/is_read_buffered/value.html
-/doc/asio/reference/is_write_buffered/
-/doc/asio/reference/is_write_buffered.html
-/doc/asio/reference/is_write_buffered/value.html
-/doc/asio/reference/IteratorConnectHandler.html
-/doc/asio/reference/IteratorConnectToken.html
-/doc/asio/reference/LegacyCompletionHandler.html
-/doc/asio/reference/local__basic_endpoint/
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/
-/doc/asio/reference/local__basic_endpoint/basic_endpoint.html
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/overload1.html
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/overload2.html
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/overload3.html
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/overload4.html
-/doc/asio/reference/local__basic_endpoint/basic_endpoint/overload5.html
-/doc/asio/reference/local__basic_endpoint/capacity.html
-/doc/asio/reference/local__basic_endpoint/data/
-/doc/asio/reference/local__basic_endpoint/data.html
-/doc/asio/reference/local__basic_endpoint/data/overload1.html
-/doc/asio/reference/local__basic_endpoint/data/overload2.html
-/doc/asio/reference/local__basic_endpoint/data_type.html
-/doc/asio/reference/local__basic_endpoint.html
-/doc/asio/reference/local__basic_endpoint/operator_eq_/
-/doc/asio/reference/local__basic_endpoint/operator_eq__eq_.html
-/doc/asio/reference/local__basic_endpoint/operator_eq_.html
-/doc/asio/reference/local__basic_endpoint/operator_eq_/overload1.html
-/doc/asio/reference/local__basic_endpoint/operator_eq_/overload2.html
-/doc/asio/reference/local__basic_endpoint/operator_gt__eq_.html
-/doc/asio/reference/local__basic_endpoint/operator_gt_.html
-/doc/asio/reference/local__basic_endpoint/operator_lt__eq_.html
-/doc/asio/reference/local__basic_endpoint/operator_lt_.html
-/doc/asio/reference/local__basic_endpoint/operator_lt__lt_.html
-/doc/asio/reference/local__basic_endpoint/operator_not__eq_.html
-/doc/asio/reference/local__basic_endpoint/path/
-/doc/asio/reference/local__basic_endpoint/path.html
-/doc/asio/reference/local__basic_endpoint/path/overload1.html
-/doc/asio/reference/local__basic_endpoint/path/overload2.html
-/doc/asio/reference/local__basic_endpoint/path/overload3.html
-/doc/asio/reference/local__basic_endpoint/protocol.html
-/doc/asio/reference/local__basic_endpoint/protocol_type.html
-/doc/asio/reference/local__basic_endpoint/resize.html
-/doc/asio/reference/local__basic_endpoint/size.html
-/doc/asio/reference/local__connect_pair/
-/doc/asio/reference/local__connect_pair.html
-/doc/asio/reference/local__connect_pair/overload1.html
-/doc/asio/reference/local__connect_pair/overload2.html
-/doc/asio/reference/local__datagram_protocol/
-/doc/asio/reference/local__datagram_protocol/endpoint.html
-/doc/asio/reference/local__datagram_protocol/family.html
-/doc/asio/reference/local__datagram_protocol.html
-/doc/asio/reference/local__datagram_protocol/protocol.html
-/doc/asio/reference/local__datagram_protocol/socket.html
-/doc/asio/reference/local__datagram_protocol/type.html
-/doc/asio/reference/local__seq_packet_protocol/
-/doc/asio/reference/local__seq_packet_protocol/acceptor.html
-/doc/asio/reference/local__seq_packet_protocol/endpoint.html
-/doc/asio/reference/local__seq_packet_protocol/family.html
-/doc/asio/reference/local__seq_packet_protocol.html
-/doc/asio/reference/local__seq_packet_protocol/protocol.html
-/doc/asio/reference/local__seq_packet_protocol/socket.html
-/doc/asio/reference/local__seq_packet_protocol/type.html
-/doc/asio/reference/local__stream_protocol/
-/doc/asio/reference/local__stream_protocol/acceptor.html
-/doc/asio/reference/local__stream_protocol/endpoint.html
-/doc/asio/reference/local__stream_protocol/family.html
-/doc/asio/reference/local__stream_protocol.html
-/doc/asio/reference/local__stream_protocol/iostream.html
-/doc/asio/reference/local__stream_protocol/protocol.html
-/doc/asio/reference/local__stream_protocol/socket.html
-/doc/asio/reference/local__stream_protocol/type.html
-/doc/asio/reference/make_strand/
-/doc/asio/reference/make_strand.html
-/doc/asio/reference/make_strand/overload1.html
-/doc/asio/reference/make_strand/overload2.html
-/doc/asio/reference/make_work_guard/
-/doc/asio/reference/make_work_guard.html
-/doc/asio/reference/make_work_guard/overload1.html
-/doc/asio/reference/make_work_guard/overload2.html
-/doc/asio/reference/make_work_guard/overload3.html
-/doc/asio/reference/make_work_guard/overload4.html
-/doc/asio/reference/make_work_guard/overload5.html
-/doc/asio/reference/MoveAcceptHandler.html
-/doc/asio/reference/MoveAcceptToken.html
-/doc/asio/reference/multiple_exceptions/
-/doc/asio/reference/multiple_exceptions/first_exception.html
-/doc/asio/reference/multiple_exceptions.html
-/doc/asio/reference/multiple_exceptions/multiple_exceptions.html
-/doc/asio/reference/multiple_exceptions/what.html
-/doc/asio/reference/mutable_buffer/
-/doc/asio/reference/mutable_buffer/data.html
-/doc/asio/reference/mutable_buffer.html
-/doc/asio/reference/mutable_buffer/mutable_buffer/
-/doc/asio/reference/mutable_buffer/mutable_buffer.html
-/doc/asio/reference/mutable_buffer/mutable_buffer/overload1.html
-/doc/asio/reference/mutable_buffer/mutable_buffer/overload2.html
-/doc/asio/reference/mutable_buffer/operator_plus_/
-/doc/asio/reference/mutable_buffer/operator_plus__eq_.html
-/doc/asio/reference/mutable_buffer/operator_plus_.html
-/doc/asio/reference/mutable_buffer/operator_plus_/overload1.html
-/doc/asio/reference/mutable_buffer/operator_plus_/overload2.html
-/doc/asio/reference/mutable_buffers_1/
-/doc/asio/reference/mutable_buffers_1/begin.html
-/doc/asio/reference/mutable_buffers_1/const_iterator.html
-/doc/asio/reference/mutable_buffers_1/data.html
-/doc/asio/reference/mutable_buffers_1/end.html
-/doc/asio/reference/mutable_buffers_1.html
-/doc/asio/reference/mutable_buffers_1/mutable_buffers_1/
-/doc/asio/reference/mutable_buffers_1/mutable_buffers_1.html
-/doc/asio/reference/mutable_buffers_1/mutable_buffers_1/overload1.html
-/doc/asio/reference/mutable_buffers_1/mutable_buffers_1/overload2.html
-/doc/asio/reference/mutable_buffers_1/operator_plus_/
-/doc/asio/reference/mutable_buffers_1/operator_plus__eq_.html
-/doc/asio/reference/mutable_buffers_1/operator_plus_.html
-/doc/asio/reference/mutable_buffers_1/operator_plus_/overload1.html
-/doc/asio/reference/mutable_buffers_1/operator_plus_/overload2.html
-/doc/asio/reference/mutable_buffers_1/size.html
-/doc/asio/reference/mutable_buffers_1/value_type.html
-/doc/asio/reference/MutableBufferSequence.html
-/doc/asio/reference/mutable_buffer/size.html
-/doc/asio/reference/mutable_registered_buffer/
-/doc/asio/reference/mutable_registered_buffer/buffer.html
-/doc/asio/reference/mutable_registered_buffer/data.html
-/doc/asio/reference/mutable_registered_buffer.html
-/doc/asio/reference/mutable_registered_buffer/id.html
-/doc/asio/reference/mutable_registered_buffer/mutable_registered_buffer.html
-/doc/asio/reference/mutable_registered_buffer/operator_plus_/
-/doc/asio/reference/mutable_registered_buffer/operator_plus__eq_.html
-/doc/asio/reference/mutable_registered_buffer/operator_plus_.html
-/doc/asio/reference/mutable_registered_buffer/operator_plus_/overload1.html
-/doc/asio/reference/mutable_registered_buffer/operator_plus_/overload2.html
-/doc/asio/reference/mutable_registered_buffer/size.html
-/doc/asio/reference/NullaryToken.html
-/doc/asio/reference/null_buffers/
-/doc/asio/reference/null_buffers/begin.html
-/doc/asio/reference/null_buffers/const_iterator.html
-/doc/asio/reference/null_buffers/end.html
-/doc/asio/reference/null_buffers.html
-/doc/asio/reference/null_buffers/value_type.html
-/doc/asio/reference/operator_pipe_.html
-/doc/asio/reference/partial_allocator_binder/
-/doc/asio/reference/partial_allocator_binder/allocator_.html
-/doc/asio/reference/partial_allocator_binder.html
-/doc/asio/reference/partial_allocator_binder/operator_lp__rp_.html
-/doc/asio/reference/partial_allocator_binder/partial_allocator_binder.html
-/doc/asio/reference/partial_as_tuple/
-/doc/asio/reference/partial_as_tuple.html
-/doc/asio/reference/partial_as_tuple/operator_lp__rp_.html
-/doc/asio/reference/partial_as_tuple/partial_as_tuple.html
-/doc/asio/reference/partial_cancel_after/
-/doc/asio/reference/partial_cancel_after/cancel_type_.html
-/doc/asio/reference/partial_cancel_after.html
-/doc/asio/reference/partial_cancel_after/operator_lp__rp_.html
-/doc/asio/reference/partial_cancel_after/partial_cancel_after.html
-/doc/asio/reference/partial_cancel_after/timeout_.html
-/doc/asio/reference/partial_cancel_after_timer/
-/doc/asio/reference/partial_cancel_after_timer/cancel_type_.html
-/doc/asio/reference/partial_cancel_after_timer.html
-/doc/asio/reference/partial_cancel_after_timer/operator_lp__rp_.html
-/doc/asio/reference/partial_cancel_after_timer/partial_cancel_after_timer.html
-/doc/asio/reference/partial_cancel_after_timer/timeout_.html
-/doc/asio/reference/partial_cancel_after_timer/timer_.html
-/doc/asio/reference/partial_cancel_at/
-/doc/asio/reference/partial_cancel_at/cancel_type_.html
-/doc/asio/reference/partial_cancel_at/expiry_.html
-/doc/asio/reference/partial_cancel_at.html
-/doc/asio/reference/partial_cancel_at/operator_lp__rp_.html
-/doc/asio/reference/partial_cancel_at/partial_cancel_at.html
-/doc/asio/reference/partial_cancel_at_timer/
-/doc/asio/reference/partial_cancel_at_timer/cancel_type_.html
-/doc/asio/reference/partial_cancel_at_timer/expiry_.html
-/doc/asio/reference/partial_cancel_at_timer.html
-/doc/asio/reference/partial_cancel_at_timer/operator_lp__rp_.html
-/doc/asio/reference/partial_cancel_at_timer/partial_cancel_at_timer.html
-/doc/asio/reference/partial_cancel_at_timer/timer_.html
-/doc/asio/reference/partial_cancellation_slot_binder/
-/doc/asio/reference/partial_cancellation_slot_binder/cancellation_slot_.html
-/doc/asio/reference/partial_cancellation_slot_binder.html
-/doc/asio/reference/partial_cancellation_slot_binder/operator_lp__rp_.html
-/doc/asio/reference/partial_cancellation_slot_binder/partial_cancellation_slot_binder.html
-/doc/asio/reference/partial_executor_binder/
-/doc/asio/reference/partial_executor_binder/executor_.html
-/doc/asio/reference/partial_executor_binder.html
-/doc/asio/reference/partial_executor_binder/operator_lp__rp_.html
-/doc/asio/reference/partial_executor_binder/partial_executor_binder.html
-/doc/asio/reference/partial_immediate_executor_binder/
-/doc/asio/reference/partial_immediate_executor_binder/executor_.html
-/doc/asio/reference/partial_immediate_executor_binder.html
-/doc/asio/reference/partial_immediate_executor_binder/operator_lp__rp_.html
-/doc/asio/reference/partial_immediate_executor_binder/partial_immediate_executor_binder.html
-/doc/asio/reference/partial_redirect_error/
-/doc/asio/reference/partial_redirect_error/ec_.html
-/doc/asio/reference/partial_redirect_error.html
-/doc/asio/reference/partial_redirect_error/operator_lp__rp_.html
-/doc/asio/reference/partial_redirect_error/partial_redirect_error.html
-/doc/asio/reference/placeholders__bytes_transferred.html
-/doc/asio/reference/placeholders__endpoint.html
-/doc/asio/reference/placeholders__error.html
-/doc/asio/reference/placeholders__iterator.html
-/doc/asio/reference/placeholders__results.html
-/doc/asio/reference/placeholders__signal_number.html
-/doc/asio/reference/posix__basic_descriptor/
-/doc/asio/reference/posix__basic_descriptor/assign/
-/doc/asio/reference/posix__basic_descriptor/assign.html
-/doc/asio/reference/posix__basic_descriptor/assign/overload1.html
-/doc/asio/reference/posix__basic_descriptor/assign/overload2.html
-/doc/asio/reference/posix__basic_descriptor/async_wait.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/
-/doc/asio/reference/posix__basic_descriptor/_basic_descriptor.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload1.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload2.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload3.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload4.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload5.html
-/doc/asio/reference/posix__basic_descriptor/basic_descriptor/overload6.html
-/doc/asio/reference/posix__basic_descriptor/bytes_readable.html
-/doc/asio/reference/posix__basic_descriptor/cancel/
-/doc/asio/reference/posix__basic_descriptor/cancel.html
-/doc/asio/reference/posix__basic_descriptor/cancel/overload1.html
-/doc/asio/reference/posix__basic_descriptor/cancel/overload2.html
-/doc/asio/reference/posix__basic_descriptor/close/
-/doc/asio/reference/posix__basic_descriptor/close.html
-/doc/asio/reference/posix__basic_descriptor/close/overload1.html
-/doc/asio/reference/posix__basic_descriptor/close/overload2.html
-/doc/asio/reference/posix__basic_descriptor/executor_type.html
-/doc/asio/reference/posix__basic_descriptor/get_executor.html
-/doc/asio/reference/posix__basic_descriptor.html
-/doc/asio/reference/posix__basic_descriptor/io_control/
-/doc/asio/reference/posix__basic_descriptor/io_control.html
-/doc/asio/reference/posix__basic_descriptor/io_control/overload1.html
-/doc/asio/reference/posix__basic_descriptor/io_control/overload2.html
-/doc/asio/reference/posix__basic_descriptor/is_open.html
-/doc/asio/reference/posix__basic_descriptor/lowest_layer/
-/doc/asio/reference/posix__basic_descriptor/lowest_layer.html
-/doc/asio/reference/posix__basic_descriptor/lowest_layer/overload1.html
-/doc/asio/reference/posix__basic_descriptor/lowest_layer/overload2.html
-/doc/asio/reference/posix__basic_descriptor/lowest_layer_type.html
-/doc/asio/reference/posix__basic_descriptor/native_handle.html
-/doc/asio/reference/posix__basic_descriptor/native_handle_type.html
-/doc/asio/reference/posix__basic_descriptor/native_non_blocking/
-/doc/asio/reference/posix__basic_descriptor/native_non_blocking.html
-/doc/asio/reference/posix__basic_descriptor/native_non_blocking/overload1.html
-/doc/asio/reference/posix__basic_descriptor/native_non_blocking/overload2.html
-/doc/asio/reference/posix__basic_descriptor/native_non_blocking/overload3.html
-/doc/asio/reference/posix__basic_descriptor/non_blocking/
-/doc/asio/reference/posix__basic_descriptor/non_blocking.html
-/doc/asio/reference/posix__basic_descriptor/non_blocking/overload1.html
-/doc/asio/reference/posix__basic_descriptor/non_blocking/overload2.html
-/doc/asio/reference/posix__basic_descriptor/non_blocking/overload3.html
-/doc/asio/reference/posix__basic_descriptor/operator_eq_/
-/doc/asio/reference/posix__basic_descriptor/operator_eq_.html
-/doc/asio/reference/posix__basic_descriptor/operator_eq_/overload1.html
-/doc/asio/reference/posix__basic_descriptor/operator_eq_/overload2.html
-/doc/asio/reference/posix__basic_descriptor__rebind_executor/
-/doc/asio/reference/posix__basic_descriptor__rebind_executor.html
-/doc/asio/reference/posix__basic_descriptor__rebind_executor/other.html
-/doc/asio/reference/posix__basic_descriptor/release.html
-/doc/asio/reference/posix__basic_descriptor/wait/
-/doc/asio/reference/posix__basic_descriptor/wait.html
-/doc/asio/reference/posix__basic_descriptor/wait/overload1.html
-/doc/asio/reference/posix__basic_descriptor/wait/overload2.html
-/doc/asio/reference/posix__basic_descriptor/wait_type.html
-/doc/asio/reference/posix__basic_stream_descriptor/
-/doc/asio/reference/posix__basic_stream_descriptor/assign/
-/doc/asio/reference/posix__basic_stream_descriptor/assign.html
-/doc/asio/reference/posix__basic_stream_descriptor/assign/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/assign/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/async_read_some.html
-/doc/asio/reference/posix__basic_stream_descriptor/async_wait.html
-/doc/asio/reference/posix__basic_stream_descriptor/async_write_some.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload3.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload4.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload5.html
-/doc/asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload6.html
-/doc/asio/reference/posix__basic_stream_descriptor/bytes_readable.html
-/doc/asio/reference/posix__basic_stream_descriptor/cancel/
-/doc/asio/reference/posix__basic_stream_descriptor/cancel.html
-/doc/asio/reference/posix__basic_stream_descriptor/cancel/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/cancel/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/close/
-/doc/asio/reference/posix__basic_stream_descriptor/close.html
-/doc/asio/reference/posix__basic_stream_descriptor/close/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/close/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/executor_type.html
-/doc/asio/reference/posix__basic_stream_descriptor/get_executor.html
-/doc/asio/reference/posix__basic_stream_descriptor.html
-/doc/asio/reference/posix__basic_stream_descriptor/io_control/
-/doc/asio/reference/posix__basic_stream_descriptor/io_control.html
-/doc/asio/reference/posix__basic_stream_descriptor/io_control/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/io_control/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/is_open.html
-/doc/asio/reference/posix__basic_stream_descriptor/lowest_layer/
-/doc/asio/reference/posix__basic_stream_descriptor/lowest_layer.html
-/doc/asio/reference/posix__basic_stream_descriptor/lowest_layer/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/lowest_layer/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/lowest_layer_type.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_handle.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_handle_type.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_non_blocking/
-/doc/asio/reference/posix__basic_stream_descriptor/native_non_blocking.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload3.html
-/doc/asio/reference/posix__basic_stream_descriptor/non_blocking/
-/doc/asio/reference/posix__basic_stream_descriptor/non_blocking.html
-/doc/asio/reference/posix__basic_stream_descriptor/non_blocking/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/non_blocking/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/non_blocking/overload3.html
-/doc/asio/reference/posix__basic_stream_descriptor/operator_eq_/
-/doc/asio/reference/posix__basic_stream_descriptor/operator_eq_.html
-/doc/asio/reference/posix__basic_stream_descriptor/operator_eq_/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/operator_eq_/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/read_some/
-/doc/asio/reference/posix__basic_stream_descriptor/read_some.html
-/doc/asio/reference/posix__basic_stream_descriptor/read_some/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/read_some/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor__rebind_executor/
-/doc/asio/reference/posix__basic_stream_descriptor__rebind_executor.html
-/doc/asio/reference/posix__basic_stream_descriptor__rebind_executor/other.html
-/doc/asio/reference/posix__basic_stream_descriptor/release.html
-/doc/asio/reference/posix__basic_stream_descriptor/wait/
-/doc/asio/reference/posix__basic_stream_descriptor/wait.html
-/doc/asio/reference/posix__basic_stream_descriptor/wait/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/wait/overload2.html
-/doc/asio/reference/posix__basic_stream_descriptor/wait_type.html
-/doc/asio/reference/posix__basic_stream_descriptor/write_some/
-/doc/asio/reference/posix__basic_stream_descriptor/write_some.html
-/doc/asio/reference/posix__basic_stream_descriptor/write_some/overload1.html
-/doc/asio/reference/posix__basic_stream_descriptor/write_some/overload2.html
-/doc/asio/reference/posix__descriptor_base/
-/doc/asio/reference/posix__descriptor_base/bytes_readable.html
-/doc/asio/reference/posix__descriptor_base/_descriptor_base.html
-/doc/asio/reference/posix__descriptor_base.html
-/doc/asio/reference/posix__descriptor_base/wait_type.html
-/doc/asio/reference/posix__descriptor.html
-/doc/asio/reference/posix__stream_descriptor.html
-/doc/asio/reference/post/
-/doc/asio/reference/post.html
-/doc/asio/reference/post/overload1.html
-/doc/asio/reference/post/overload2.html
-/doc/asio/reference/post/overload3.html
-/doc/asio/reference/prefer.html
-/doc/asio/reference/prefer_result/
-/doc/asio/reference/prefer_result.html
-/doc/asio/reference/prefer_result/type.html
-/doc/asio/reference/prepend.html
-/doc/asio/reference/prepend_t/
-/doc/asio/reference/prepend_t.html
-/doc/asio/reference/prepend_t/prepend_t.html
-/doc/asio/reference/prepend_t/token_.html
-/doc/asio/reference/prepend_t/values_.html
-/doc/asio/reference/ProtoAllocator.html
-/doc/asio/reference/Protocol.html
-/doc/asio/reference/query.html
-/doc/asio/reference/query_result/
-/doc/asio/reference/query_result.html
-/doc/asio/reference/query_result/type.html
-/doc/asio/reference/random_access_file.html
-/doc/asio/reference/RangeConnectHandler.html
-/doc/asio/reference/RangeConnectToken.html
-/doc/asio/reference/read/
-/doc/asio/reference/readable_pipe.html
-/doc/asio/reference/read_at/
-/doc/asio/reference/read_at.html
-/doc/asio/reference/read_at/overload1.html
-/doc/asio/reference/read_at/overload2.html
-/doc/asio/reference/read_at/overload3.html
-/doc/asio/reference/read_at/overload4.html
-/doc/asio/reference/read_at/overload5.html
-/doc/asio/reference/read_at/overload6.html
-/doc/asio/reference/read_at/overload7.html
-/doc/asio/reference/read_at/overload8.html
-/doc/asio/reference/ReadHandler.html
-/doc/asio/reference/read.html
-/doc/asio/reference/read/overload10.html
-/doc/asio/reference/read/overload11.html
-/doc/asio/reference/read/overload12.html
-/doc/asio/reference/read/overload13.html
-/doc/asio/reference/read/overload14.html
-/doc/asio/reference/read/overload15.html
-/doc/asio/reference/read/overload16.html
-/doc/asio/reference/read/overload1.html
-/doc/asio/reference/read/overload2.html
-/doc/asio/reference/read/overload3.html
-/doc/asio/reference/read/overload4.html
-/doc/asio/reference/read/overload5.html
-/doc/asio/reference/read/overload6.html
-/doc/asio/reference/read/overload7.html
-/doc/asio/reference/read/overload8.html
-/doc/asio/reference/read/overload9.html
-/doc/asio/reference/ReadToken.html
-/doc/asio/reference/read_until/
-/doc/asio/reference/read_until.html
-/doc/asio/reference/read_until/overload10.html
-/doc/asio/reference/read_until/overload11.html
-/doc/asio/reference/read_until/overload12.html
-/doc/asio/reference/read_until/overload13.html
-/doc/asio/reference/read_until/overload14.html
-/doc/asio/reference/read_until/overload15.html
-/doc/asio/reference/read_until/overload16.html
-/doc/asio/reference/read_until/overload17.html
-/doc/asio/reference/read_until/overload18.html
-/doc/asio/reference/read_until/overload19.html
-/doc/asio/reference/read_until/overload1.html
-/doc/asio/reference/read_until/overload20.html
-/doc/asio/reference/read_until/overload21.html
-/doc/asio/reference/read_until/overload22.html
-/doc/asio/reference/read_until/overload23.html
-/doc/asio/reference/read_until/overload24.html
-/doc/asio/reference/read_until/overload2.html
-/doc/asio/reference/read_until/overload3.html
-/doc/asio/reference/read_until/overload4.html
-/doc/asio/reference/read_until/overload5.html
-/doc/asio/reference/read_until/overload6.html
-/doc/asio/reference/read_until/overload7.html
-/doc/asio/reference/read_until/overload8.html
-/doc/asio/reference/read_until/overload9.html
-/doc/asio/reference/read_write_operations.html
-/doc/asio/reference/recycling_allocator/
-/doc/asio/reference/recycling_allocator/allocate.html
-/doc/asio/reference/recycling_allocator/deallocate.html
-/doc/asio/reference/recycling_allocator.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/
-/doc/asio/reference/recycling_allocator_lt__void__gt_.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/operator_eq__eq_.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/operator_not__eq_.html
-/doc/asio/reference/recycling_allocator_lt__void__gt___rebind/
-/doc/asio/reference/recycling_allocator_lt__void__gt___rebind.html
-/doc/asio/reference/recycling_allocator_lt__void__gt___rebind/other.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/
-/doc/asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/overload1.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/overload2.html
-/doc/asio/reference/recycling_allocator_lt__void__gt_/value_type.html
-/doc/asio/reference/recycling_allocator/operator_eq__eq_.html
-/doc/asio/reference/recycling_allocator/operator_not__eq_.html
-/doc/asio/reference/recycling_allocator__rebind/
-/doc/asio/reference/recycling_allocator__rebind.html
-/doc/asio/reference/recycling_allocator__rebind/other.html
-/doc/asio/reference/recycling_allocator/recycling_allocator/
-/doc/asio/reference/recycling_allocator/recycling_allocator.html
-/doc/asio/reference/recycling_allocator/recycling_allocator/overload1.html
-/doc/asio/reference/recycling_allocator/recycling_allocator/overload2.html
-/doc/asio/reference/recycling_allocator/value_type.html
-/doc/asio/reference/redirect_error/
-/doc/asio/reference/redirect_error.html
-/doc/asio/reference/redirect_error/overload1.html
-/doc/asio/reference/redirect_error/overload2.html
-/doc/asio/reference/redirect_error_t/
-/doc/asio/reference/redirect_error_t/ec_.html
-/doc/asio/reference/redirect_error_t.html
-/doc/asio/reference/redirect_error_t/redirect_error_t.html
-/doc/asio/reference/redirect_error_t/token_.html
-/doc/asio/reference/register_buffers/
-/doc/asio/reference/register_buffers.html
-/doc/asio/reference/register_buffers/overload1.html
-/doc/asio/reference/register_buffers/overload2.html
-/doc/asio/reference/register_buffers/overload3.html
-/doc/asio/reference/register_buffers/overload4.html
-/doc/asio/reference/registered_buffer_id/
-/doc/asio/reference/registered_buffer_id.html
-/doc/asio/reference/registered_buffer_id/native_handle.html
-/doc/asio/reference/registered_buffer_id/native_handle_type.html
-/doc/asio/reference/registered_buffer_id/operator_eq__eq_.html
-/doc/asio/reference/registered_buffer_id/operator_not__eq_.html
-/doc/asio/reference/registered_buffer_id/registered_buffer_id.html
-/doc/asio/reference/require_concept.html
-/doc/asio/reference/require_concept_result/
-/doc/asio/reference/require_concept_result.html
-/doc/asio/reference/require_concept_result/type.html
-/doc/asio/reference/require.html
-/doc/asio/reference/require_result/
-/doc/asio/reference/require_result.html
-/doc/asio/reference/require_result/type.html
-/doc/asio/reference/ResolveHandler.html
-/doc/asio/reference/resolver_errc__try_again.html
-/doc/asio/reference/ResolveToken.html
-/doc/asio/reference/serial_port_base/
-/doc/asio/reference/serial_port_base__baud_rate/
-/doc/asio/reference/serial_port_base__baud_rate/baud_rate.html
-/doc/asio/reference/serial_port_base__baud_rate.html
-/doc/asio/reference/serial_port_base__baud_rate/load.html
-/doc/asio/reference/serial_port_base__baud_rate/store.html
-/doc/asio/reference/serial_port_base__baud_rate/value.html
-/doc/asio/reference/serial_port_base__character_size/
-/doc/asio/reference/serial_port_base__character_size/character_size.html
-/doc/asio/reference/serial_port_base__character_size.html
-/doc/asio/reference/serial_port_base__character_size/load.html
-/doc/asio/reference/serial_port_base__character_size/store.html
-/doc/asio/reference/serial_port_base__character_size/value.html
-/doc/asio/reference/serial_port_base__flow_control/
-/doc/asio/reference/serial_port_base__flow_control/flow_control.html
-/doc/asio/reference/serial_port_base__flow_control.html
-/doc/asio/reference/serial_port_base__flow_control/load.html
-/doc/asio/reference/serial_port_base__flow_control/store.html
-/doc/asio/reference/serial_port_base__flow_control/type.html
-/doc/asio/reference/serial_port_base__flow_control/value.html
-/doc/asio/reference/serial_port_base.html
-/doc/asio/reference/serial_port_base__parity/
-/doc/asio/reference/serial_port_base__parity.html
-/doc/asio/reference/serial_port_base__parity/load.html
-/doc/asio/reference/serial_port_base__parity/parity.html
-/doc/asio/reference/serial_port_base__parity/store.html
-/doc/asio/reference/serial_port_base__parity/type.html
-/doc/asio/reference/serial_port_base__parity/value.html
-/doc/asio/reference/serial_port_base/_serial_port_base.html
-/doc/asio/reference/serial_port_base__stop_bits/
-/doc/asio/reference/serial_port_base__stop_bits.html
-/doc/asio/reference/serial_port_base__stop_bits/load.html
-/doc/asio/reference/serial_port_base__stop_bits/stop_bits.html
-/doc/asio/reference/serial_port_base__stop_bits/store.html
-/doc/asio/reference/serial_port_base__stop_bits/type.html
-/doc/asio/reference/serial_port_base__stop_bits/value.html
-/doc/asio/reference/serial_port.html
-/doc/asio/reference/service_already_exists/
-/doc/asio/reference/service_already_exists.html
-/doc/asio/reference/service_already_exists/service_already_exists.html
-/doc/asio/reference/Service.html
-/doc/asio/reference/SettableSerialPortOption.html
-/doc/asio/reference/SettableSocketOption.html
-/doc/asio/reference/ShutdownHandler.html
-/doc/asio/reference/ShutdownToken.html
-/doc/asio/reference/SignalHandler.html
-/doc/asio/reference/signal_set_base/
-/doc/asio/reference/signal_set_base/flags.html
-/doc/asio/reference/signal_set_base/flags_t.html
-/doc/asio/reference/signal_set_base.html
-/doc/asio/reference/signal_set_base/_signal_set_base.html
-/doc/asio/reference/signal_set.html
-/doc/asio/reference/SignalToken.html
-/doc/asio/reference/socket_base/
-/doc/asio/reference/socket_base/broadcast.html
-/doc/asio/reference/socket_base/bytes_readable.html
-/doc/asio/reference/socket_base/debug.html
-/doc/asio/reference/socket_base/do_not_route.html
-/doc/asio/reference/socket_base/enable_connection_aborted.html
-/doc/asio/reference/socket_base.html
-/doc/asio/reference/socket_base/keep_alive.html
-/doc/asio/reference/socket_base/linger.html
-/doc/asio/reference/socket_base/max_connections.html
-/doc/asio/reference/socket_base/max_listen_connections.html
-/doc/asio/reference/socket_base/message_do_not_route.html
-/doc/asio/reference/socket_base/message_end_of_record.html
-/doc/asio/reference/socket_base/message_flags.html
-/doc/asio/reference/socket_base/message_out_of_band.html
-/doc/asio/reference/socket_base/message_peek.html
-/doc/asio/reference/socket_base/out_of_band_inline.html
-/doc/asio/reference/socket_base/receive_buffer_size.html
-/doc/asio/reference/socket_base/receive_low_watermark.html
-/doc/asio/reference/socket_base/reuse_address.html
-/doc/asio/reference/socket_base/send_buffer_size.html
-/doc/asio/reference/socket_base/send_low_watermark.html
-/doc/asio/reference/socket_base/shutdown_type.html
-/doc/asio/reference/socket_base/_socket_base.html
-/doc/asio/reference/socket_base/wait_type.html
-/doc/asio/reference/spawn/
-/doc/asio/reference/spawn.html
-/doc/asio/reference/spawn/overload10.html
-/doc/asio/reference/spawn/overload11.html
-/doc/asio/reference/spawn/overload12.html
-/doc/asio/reference/spawn/overload13.html
-/doc/asio/reference/spawn/overload1.html
-/doc/asio/reference/spawn/overload2.html
-/doc/asio/reference/spawn/overload3.html
-/doc/asio/reference/spawn/overload4.html
-/doc/asio/reference/spawn/overload5.html
-/doc/asio/reference/spawn/overload6.html
-/doc/asio/reference/spawn/overload7.html
-/doc/asio/reference/spawn/overload8.html
-/doc/asio/reference/spawn/overload9.html
-/doc/asio/reference/ssl__context/
-/doc/asio/reference/ssl__context/add_certificate_authority/
-/doc/asio/reference/ssl__context/add_certificate_authority.html
-/doc/asio/reference/ssl__context/add_certificate_authority/overload1.html
-/doc/asio/reference/ssl__context/add_certificate_authority/overload2.html
-/doc/asio/reference/ssl__context/add_verify_path/
-/doc/asio/reference/ssl__context/add_verify_path.html
-/doc/asio/reference/ssl__context/add_verify_path/overload1.html
-/doc/asio/reference/ssl__context/add_verify_path/overload2.html
-/doc/asio/reference/ssl__context_base/
-/doc/asio/reference/ssl__context_base/_context_base.html
-/doc/asio/reference/ssl__context_base/default_workarounds.html
-/doc/asio/reference/ssl__context_base/file_format.html
-/doc/asio/reference/ssl__context_base.html
-/doc/asio/reference/ssl__context_base/method.html
-/doc/asio/reference/ssl__context_base/no_compression.html
-/doc/asio/reference/ssl__context_base/no_sslv2.html
-/doc/asio/reference/ssl__context_base/no_sslv3.html
-/doc/asio/reference/ssl__context_base/no_tlsv1_1.html
-/doc/asio/reference/ssl__context_base/no_tlsv1_2.html
-/doc/asio/reference/ssl__context_base/no_tlsv1_3.html
-/doc/asio/reference/ssl__context_base/no_tlsv1.html
-/doc/asio/reference/ssl__context_base/options.html
-/doc/asio/reference/ssl__context_base/password_purpose.html
-/doc/asio/reference/ssl__context_base/single_dh_use.html
-/doc/asio/reference/ssl__context/clear_options/
-/doc/asio/reference/ssl__context/clear_options.html
-/doc/asio/reference/ssl__context/clear_options/overload1.html
-/doc/asio/reference/ssl__context/clear_options/overload2.html
-/doc/asio/reference/ssl__context/context/
-/doc/asio/reference/ssl__context/_context.html
-/doc/asio/reference/ssl__context/context.html
-/doc/asio/reference/ssl__context/context/overload1.html
-/doc/asio/reference/ssl__context/context/overload2.html
-/doc/asio/reference/ssl__context/context/overload3.html
-/doc/asio/reference/ssl__context/default_workarounds.html
-/doc/asio/reference/ssl__context/file_format.html
-/doc/asio/reference/ssl__context.html
-/doc/asio/reference/ssl__context/load_verify_file/
-/doc/asio/reference/ssl__context/load_verify_file.html
-/doc/asio/reference/ssl__context/load_verify_file/overload1.html
-/doc/asio/reference/ssl__context/load_verify_file/overload2.html
-/doc/asio/reference/ssl__context/method.html
-/doc/asio/reference/ssl__context/native_handle.html
-/doc/asio/reference/ssl__context/native_handle_type.html
-/doc/asio/reference/ssl__context/no_compression.html
-/doc/asio/reference/ssl__context/no_sslv2.html
-/doc/asio/reference/ssl__context/no_sslv3.html
-/doc/asio/reference/ssl__context/no_tlsv1_1.html
-/doc/asio/reference/ssl__context/no_tlsv1_2.html
-/doc/asio/reference/ssl__context/no_tlsv1_3.html
-/doc/asio/reference/ssl__context/no_tlsv1.html
-/doc/asio/reference/ssl__context/operator_eq_.html
-/doc/asio/reference/ssl__context/options.html
-/doc/asio/reference/ssl__context/password_purpose.html
-/doc/asio/reference/ssl__context/set_default_verify_paths/
-/doc/asio/reference/ssl__context/set_default_verify_paths.html
-/doc/asio/reference/ssl__context/set_default_verify_paths/overload1.html
-/doc/asio/reference/ssl__context/set_default_verify_paths/overload2.html
-/doc/asio/reference/ssl__context/set_options/
-/doc/asio/reference/ssl__context/set_options.html
-/doc/asio/reference/ssl__context/set_options/overload1.html
-/doc/asio/reference/ssl__context/set_options/overload2.html
-/doc/asio/reference/ssl__context/set_password_callback/
-/doc/asio/reference/ssl__context/set_password_callback.html
-/doc/asio/reference/ssl__context/set_password_callback/overload1.html
-/doc/asio/reference/ssl__context/set_password_callback/overload2.html
-/doc/asio/reference/ssl__context/set_verify_callback/
-/doc/asio/reference/ssl__context/set_verify_callback.html
-/doc/asio/reference/ssl__context/set_verify_callback/overload1.html
-/doc/asio/reference/ssl__context/set_verify_callback/overload2.html
-/doc/asio/reference/ssl__context/set_verify_depth/
-/doc/asio/reference/ssl__context/set_verify_depth.html
-/doc/asio/reference/ssl__context/set_verify_depth/overload1.html
-/doc/asio/reference/ssl__context/set_verify_depth/overload2.html
-/doc/asio/reference/ssl__context/set_verify_mode/
-/doc/asio/reference/ssl__context/set_verify_mode.html
-/doc/asio/reference/ssl__context/set_verify_mode/overload1.html
-/doc/asio/reference/ssl__context/set_verify_mode/overload2.html
-/doc/asio/reference/ssl__context/single_dh_use.html
-/doc/asio/reference/ssl__context/use_certificate/
-/doc/asio/reference/ssl__context/use_certificate_chain/
-/doc/asio/reference/ssl__context/use_certificate_chain_file/
-/doc/asio/reference/ssl__context/use_certificate_chain_file.html
-/doc/asio/reference/ssl__context/use_certificate_chain_file/overload1.html
-/doc/asio/reference/ssl__context/use_certificate_chain_file/overload2.html
-/doc/asio/reference/ssl__context/use_certificate_chain.html
-/doc/asio/reference/ssl__context/use_certificate_chain/overload1.html
-/doc/asio/reference/ssl__context/use_certificate_chain/overload2.html
-/doc/asio/reference/ssl__context/use_certificate_file/
-/doc/asio/reference/ssl__context/use_certificate_file.html
-/doc/asio/reference/ssl__context/use_certificate_file/overload1.html
-/doc/asio/reference/ssl__context/use_certificate_file/overload2.html
-/doc/asio/reference/ssl__context/use_certificate.html
-/doc/asio/reference/ssl__context/use_certificate/overload1.html
-/doc/asio/reference/ssl__context/use_certificate/overload2.html
-/doc/asio/reference/ssl__context/use_private_key/
-/doc/asio/reference/ssl__context/use_private_key_file/
-/doc/asio/reference/ssl__context/use_private_key_file.html
-/doc/asio/reference/ssl__context/use_private_key_file/overload1.html
-/doc/asio/reference/ssl__context/use_private_key_file/overload2.html
-/doc/asio/reference/ssl__context/use_private_key.html
-/doc/asio/reference/ssl__context/use_private_key/overload1.html
-/doc/asio/reference/ssl__context/use_private_key/overload2.html
-/doc/asio/reference/ssl__context/use_rsa_private_key/
-/doc/asio/reference/ssl__context/use_rsa_private_key_file/
-/doc/asio/reference/ssl__context/use_rsa_private_key_file.html
-/doc/asio/reference/ssl__context/use_rsa_private_key_file/overload1.html
-/doc/asio/reference/ssl__context/use_rsa_private_key_file/overload2.html
-/doc/asio/reference/ssl__context/use_rsa_private_key.html
-/doc/asio/reference/ssl__context/use_rsa_private_key/overload1.html
-/doc/asio/reference/ssl__context/use_rsa_private_key/overload2.html
-/doc/asio/reference/ssl__context/use_tmp_dh/
-/doc/asio/reference/ssl__context/use_tmp_dh_file/
-/doc/asio/reference/ssl__context/use_tmp_dh_file.html
-/doc/asio/reference/ssl__context/use_tmp_dh_file/overload1.html
-/doc/asio/reference/ssl__context/use_tmp_dh_file/overload2.html
-/doc/asio/reference/ssl__context/use_tmp_dh.html
-/doc/asio/reference/ssl__context/use_tmp_dh/overload1.html
-/doc/asio/reference/ssl__context/use_tmp_dh/overload2.html
-/doc/asio/reference/ssl__error__get_stream_category.html
-/doc/asio/reference/ssl__error__make_error_code.html
-/doc/asio/reference/ssl__error__stream_category.html
-/doc/asio/reference/ssl__error__stream_errors__gt_/
-/doc/asio/reference/ssl__error__stream_errors__gt_.html
-/doc/asio/reference/ssl__error__stream_errors__gt_/value.html
-/doc/asio/reference/ssl__error__stream_errors.html
-/doc/asio/reference/ssl__host_name_verification/
-/doc/asio/reference/ssl__host_name_verification/host_name_verification.html
-/doc/asio/reference/ssl__host_name_verification.html
-/doc/asio/reference/ssl__host_name_verification/operator_lp__rp_.html
-/doc/asio/reference/ssl__host_name_verification/result_type.html
-/doc/asio/reference/ssl__rfc2818_verification/
-/doc/asio/reference/ssl__rfc2818_verification.html
-/doc/asio/reference/ssl__rfc2818_verification/operator_lp__rp_.html
-/doc/asio/reference/ssl__rfc2818_verification/result_type.html
-/doc/asio/reference/ssl__rfc2818_verification/rfc2818_verification.html
-/doc/asio/reference/ssl__stream/
-/doc/asio/reference/ssl__stream/async_handshake/
-/doc/asio/reference/ssl__stream/async_handshake.html
-/doc/asio/reference/ssl__stream/async_handshake/overload1.html
-/doc/asio/reference/ssl__stream/async_handshake/overload2.html
-/doc/asio/reference/ssl__stream/async_read_some.html
-/doc/asio/reference/ssl__stream/async_shutdown.html
-/doc/asio/reference/ssl__stream/async_write_some.html
-/doc/asio/reference/ssl__stream_base/
-/doc/asio/reference/ssl__stream_base/handshake_type.html
-/doc/asio/reference/ssl__stream_base.html
-/doc/asio/reference/ssl__stream_base/_stream_base.html
-/doc/asio/reference/ssl__stream/executor_type.html
-/doc/asio/reference/ssl__stream/get_executor.html
-/doc/asio/reference/ssl__stream/handshake/
-/doc/asio/reference/ssl__stream/handshake.html
-/doc/asio/reference/ssl__stream/handshake/overload1.html
-/doc/asio/reference/ssl__stream/handshake/overload2.html
-/doc/asio/reference/ssl__stream/handshake/overload3.html
-/doc/asio/reference/ssl__stream/handshake/overload4.html
-/doc/asio/reference/ssl__stream/handshake_type.html
-/doc/asio/reference/ssl__stream.html
-/doc/asio/reference/ssl__stream__impl_struct/
-/doc/asio/reference/ssl__stream__impl_struct.html
-/doc/asio/reference/ssl__stream__impl_struct/ssl.html
-/doc/asio/reference/ssl__stream/lowest_layer/
-/doc/asio/reference/ssl__stream/lowest_layer.html
-/doc/asio/reference/ssl__stream/lowest_layer/overload1.html
-/doc/asio/reference/ssl__stream/lowest_layer/overload2.html
-/doc/asio/reference/ssl__stream/lowest_layer_type.html
-/doc/asio/reference/ssl__stream/native_handle.html
-/doc/asio/reference/ssl__stream/native_handle_type.html
-/doc/asio/reference/ssl__stream/next_layer/
-/doc/asio/reference/ssl__stream/next_layer.html
-/doc/asio/reference/ssl__stream/next_layer/overload1.html
-/doc/asio/reference/ssl__stream/next_layer/overload2.html
-/doc/asio/reference/ssl__stream/next_layer_type.html
-/doc/asio/reference/ssl__stream/operator_eq_.html
-/doc/asio/reference/ssl__stream/read_some/
-/doc/asio/reference/ssl__stream/read_some.html
-/doc/asio/reference/ssl__stream/read_some/overload1.html
-/doc/asio/reference/ssl__stream/read_some/overload2.html
-/doc/asio/reference/ssl__stream/set_verify_callback/
-/doc/asio/reference/ssl__stream/set_verify_callback.html
-/doc/asio/reference/ssl__stream/set_verify_callback/overload1.html
-/doc/asio/reference/ssl__stream/set_verify_callback/overload2.html
-/doc/asio/reference/ssl__stream/set_verify_depth/
-/doc/asio/reference/ssl__stream/set_verify_depth.html
-/doc/asio/reference/ssl__stream/set_verify_depth/overload1.html
-/doc/asio/reference/ssl__stream/set_verify_depth/overload2.html
-/doc/asio/reference/ssl__stream/set_verify_mode/
-/doc/asio/reference/ssl__stream/set_verify_mode.html
-/doc/asio/reference/ssl__stream/set_verify_mode/overload1.html
-/doc/asio/reference/ssl__stream/set_verify_mode/overload2.html
-/doc/asio/reference/ssl__stream/shutdown/
-/doc/asio/reference/ssl__stream/shutdown.html
-/doc/asio/reference/ssl__stream/shutdown/overload1.html
-/doc/asio/reference/ssl__stream/shutdown/overload2.html
-/doc/asio/reference/ssl__stream/stream/
-/doc/asio/reference/ssl__stream/_stream.html
-/doc/asio/reference/ssl__stream/stream.html
-/doc/asio/reference/ssl__stream/stream/overload1.html
-/doc/asio/reference/ssl__stream/stream/overload2.html
-/doc/asio/reference/ssl__stream/stream/overload3.html
-/doc/asio/reference/ssl__stream/write_some/
-/doc/asio/reference/ssl__stream/write_some.html
-/doc/asio/reference/ssl__stream/write_some/overload1.html
-/doc/asio/reference/ssl__stream/write_some/overload2.html
-/doc/asio/reference/ssl__verify_client_once.html
-/doc/asio/reference/ssl__verify_context/
-/doc/asio/reference/ssl__verify_context.html
-/doc/asio/reference/ssl__verify_context/native_handle.html
-/doc/asio/reference/ssl__verify_context/native_handle_type.html
-/doc/asio/reference/ssl__verify_context/verify_context.html
-/doc/asio/reference/ssl__verify_fail_if_no_peer_cert.html
-/doc/asio/reference/ssl__verify_mode.html
-/doc/asio/reference/ssl__verify_none.html
-/doc/asio/reference/ssl__verify_peer.html
-/doc/asio/reference/static_thread_pool.html
-/doc/asio/reference/steady_timer.html
-/doc/asio/reference/strand/
-/doc/asio/reference/strand/context.html
-/doc/asio/reference/strand/defer.html
-/doc/asio/reference/strand/dispatch.html
-/doc/asio/reference/strand/execute.html
-/doc/asio/reference/strand/get_inner_executor.html
-/doc/asio/reference/strand.html
-/doc/asio/reference/strand/inner_executor_type.html
-/doc/asio/reference/strand/on_work_finished.html
-/doc/asio/reference/strand/on_work_started.html
-/doc/asio/reference/strand/operator_eq_/
-/doc/asio/reference/strand/operator_eq__eq_.html
-/doc/asio/reference/strand/operator_eq_.html
-/doc/asio/reference/strand/operator_eq_/overload1.html
-/doc/asio/reference/strand/operator_eq_/overload2.html
-/doc/asio/reference/strand/operator_eq_/overload3.html
-/doc/asio/reference/strand/operator_eq_/overload4.html
-/doc/asio/reference/strand/operator_not__eq_.html
-/doc/asio/reference/strand/post.html
-/doc/asio/reference/strand/prefer.html
-/doc/asio/reference/strand/query.html
-/doc/asio/reference/strand/require.html
-/doc/asio/reference/strand/running_in_this_thread.html
-/doc/asio/reference/strand/strand/
-/doc/asio/reference/strand/_strand.html
-/doc/asio/reference/strand/strand.html
-/doc/asio/reference/strand/strand/overload1.html
-/doc/asio/reference/strand/strand/overload2.html
-/doc/asio/reference/strand/strand/overload3.html
-/doc/asio/reference/strand/strand/overload4.html
-/doc/asio/reference/strand/strand/overload5.html
-/doc/asio/reference/strand/strand/overload6.html
-/doc/asio/reference/streambuf.html
-/doc/asio/reference/stream_file.html
-/doc/asio/reference/synchronous_socket_operations.html
-/doc/asio/reference/SyncRandomAccessReadDevice.html
-/doc/asio/reference/SyncRandomAccessWriteDevice.html
-/doc/asio/reference/SyncReadStream.html
-/doc/asio/reference/SyncWriteStream.html
-/doc/asio/reference/system_category.html
-/doc/asio/reference/system_context/
-/doc/asio/reference/system_context/destroy.html
-/doc/asio/reference/system_context/executor_type.html
-/doc/asio/reference/system_context/fork_event.html
-/doc/asio/reference/system_context/get_executor.html
-/doc/asio/reference/system_context.html
-/doc/asio/reference/system_context/join.html
-/doc/asio/reference/system_context/notify_fork.html
-/doc/asio/reference/system_context/shutdown.html
-/doc/asio/reference/system_context/stop.html
-/doc/asio/reference/system_context/stopped.html
-/doc/asio/reference/system_context/_system_context.html
-/doc/asio/reference/system_error.html
-/doc/asio/reference/system_executor.html
-/doc/asio/reference/system_timer.html
-/doc/asio/reference/this_coro__cancellation_state.html
-/doc/asio/reference/this_coro__cancellation_state_t/
-/doc/asio/reference/this_coro__cancellation_state_t/cancellation_state_t.html
-/doc/asio/reference/this_coro__cancellation_state_t.html
-/doc/asio/reference/this_coro__executor.html
-/doc/asio/reference/this_coro__executor_t/
-/doc/asio/reference/this_coro__executor_t/executor_t.html
-/doc/asio/reference/this_coro__executor_t.html
-/doc/asio/reference/this_coro__reset_cancellation_state/
-/doc/asio/reference/this_coro__reset_cancellation_state.html
-/doc/asio/reference/this_coro__reset_cancellation_state/overload1.html
-/doc/asio/reference/this_coro__reset_cancellation_state/overload2.html
-/doc/asio/reference/this_coro__reset_cancellation_state/overload3.html
-/doc/asio/reference/this_coro__throw_if_cancelled/
-/doc/asio/reference/this_coro__throw_if_cancelled.html
-/doc/asio/reference/this_coro__throw_if_cancelled/overload1.html
-/doc/asio/reference/this_coro__throw_if_cancelled/overload2.html
-/doc/asio/reference/thread/
-/doc/asio/reference/thread.html
-/doc/asio/reference/thread/join.html
-/doc/asio/reference/thread_pool/
-/doc/asio/reference/thread_pool/attach.html
-/doc/asio/reference/thread_pool__basic_executor_type/
-/doc/asio/reference/thread_pool__basic_executor_type/basic_executor_type/
-/doc/asio/reference/thread_pool__basic_executor_type/_basic_executor_type.html
-/doc/asio/reference/thread_pool__basic_executor_type/basic_executor_type.html
-/doc/asio/reference/thread_pool__basic_executor_type/basic_executor_type/overload1.html
-/doc/asio/reference/thread_pool__basic_executor_type/basic_executor_type/overload2.html
-/doc/asio/reference/thread_pool__basic_executor_type/context.html
-/doc/asio/reference/thread_pool__basic_executor_type/defer.html
-/doc/asio/reference/thread_pool__basic_executor_type/dispatch.html
-/doc/asio/reference/thread_pool__basic_executor_type/execute.html
-/doc/asio/reference/thread_pool__basic_executor_type.html
-/doc/asio/reference/thread_pool__basic_executor_type/on_work_finished.html
-/doc/asio/reference/thread_pool__basic_executor_type/on_work_started.html
-/doc/asio/reference/thread_pool__basic_executor_type/operator_eq_/
-/doc/asio/reference/thread_pool__basic_executor_type/operator_eq__eq_.html
-/doc/asio/reference/thread_pool__basic_executor_type/operator_eq_.html
-/doc/asio/reference/thread_pool__basic_executor_type/operator_eq_/overload1.html
-/doc/asio/reference/thread_pool__basic_executor_type/operator_eq_/overload2.html
-/doc/asio/reference/thread_pool__basic_executor_type/operator_not__eq_.html
-/doc/asio/reference/thread_pool__basic_executor_type/post.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/
-/doc/asio/reference/thread_pool__basic_executor_type/query.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload1.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload2.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload3.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload4.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload5.html
-/doc/asio/reference/thread_pool__basic_executor_type/query/overload6.html
-/doc/asio/reference/thread_pool__basic_executor_type/query__static/
-/doc/asio/reference/thread_pool__basic_executor_type/query__static.html
-/doc/asio/reference/thread_pool__basic_executor_type/query__static/overload1.html
-/doc/asio/reference/thread_pool__basic_executor_type/query__static/overload2.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/
-/doc/asio/reference/thread_pool__basic_executor_type/require.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload1.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload2.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload3.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload4.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload5.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload6.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload7.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload8.html
-/doc/asio/reference/thread_pool__basic_executor_type/require/overload9.html
-/doc/asio/reference/thread_pool__basic_executor_type/running_in_this_thread.html
-/doc/asio/reference/thread_pool/destroy.html
-/doc/asio/reference/thread_pool/executor.html
-/doc/asio/reference/thread_pool/executor_type.html
-/doc/asio/reference/thread_pool/fork_event.html
-/doc/asio/reference/thread_pool/get_executor.html
-/doc/asio/reference/thread_pool.html
-/doc/asio/reference/thread_pool/join.html
-/doc/asio/reference/thread_pool/notify_fork.html
-/doc/asio/reference/thread_pool/shutdown.html
-/doc/asio/reference/thread_pool/stop.html
-/doc/asio/reference/thread_pool/thread_pool/
-/doc/asio/reference/thread_pool/_thread_pool.html
-/doc/asio/reference/thread_pool/thread_pool.html
-/doc/asio/reference/thread_pool/thread_pool/overload1.html
-/doc/asio/reference/thread_pool/thread_pool/overload2.html
-/doc/asio/reference/thread_pool/wait.html
-/doc/asio/reference/thread/_thread.html
-/doc/asio/reference/thread/thread.html
-/doc/asio/reference/TimeTraits.html
-/doc/asio/reference/time_traits.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/
-/doc/asio/reference/time_traits_lt__ptime__gt_/add.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/duration_type.html
-/doc/asio/reference/time_traits_lt__ptime__gt_.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/less_than.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/now.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/subtract.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/time_type.html
-/doc/asio/reference/time_traits_lt__ptime__gt_/to_posix_duration.html
-/doc/asio/reference/transfer_all.html
-/doc/asio/reference/transfer_at_least.html
-/doc/asio/reference/transfer_exactly.html
-/doc/asio/reference/use_awaitable.html
-/doc/asio/reference/use_awaitable_t/
-/doc/asio/reference/use_awaitable_t/as_default_on.html
-/doc/asio/reference/use_awaitable_t/as_default_on_t.html
-/doc/asio/reference/use_awaitable_t__executor_with_default/
-/doc/asio/reference/use_awaitable_t__executor_with_default/default_completion_token_type.html
-/doc/asio/reference/use_awaitable_t__executor_with_default/executor_with_default.html
-/doc/asio/reference/use_awaitable_t__executor_with_default.html
-/doc/asio/reference/use_awaitable_t.html
-/doc/asio/reference/use_awaitable_t/use_awaitable_t/
-/doc/asio/reference/use_awaitable_t/use_awaitable_t.html
-/doc/asio/reference/use_awaitable_t/use_awaitable_t/overload1.html
-/doc/asio/reference/use_awaitable_t/use_awaitable_t/overload2.html
-/doc/asio/reference/use_future.html
-/doc/asio/reference/use_future_t/
-/doc/asio/reference/use_future_t/allocator_type.html
-/doc/asio/reference/use_future_t/get_allocator.html
-/doc/asio/reference/use_future_t.html
-/doc/asio/reference/use_future_t/operator_lb__rb_.html
-/doc/asio/reference/use_future_t/operator_lp__rp_/
-/doc/asio/reference/use_future_t/operator_lp__rp_.html
-/doc/asio/reference/use_future_t/operator_lp__rp_/overload1.html
-/doc/asio/reference/use_future_t/operator_lp__rp_/overload2.html
-/doc/asio/reference/use_future_t/rebind.html
-/doc/asio/reference/use_future_t/use_future_t/
-/doc/asio/reference/use_future_t/use_future_t.html
-/doc/asio/reference/use_future_t/use_future_t/overload1.html
-/doc/asio/reference/use_future_t/use_future_t/overload2.html
-/doc/asio/reference/uses_executor.html
-/doc/asio/reference/WaitHandler.html
-/doc/asio/reference/WaitToken.html
-/doc/asio/reference/wait_traits/
-/doc/asio/reference/WaitTraits.html
-/doc/asio/reference/wait_traits.html
-/doc/asio/reference/wait_traits/to_wait_duration/
-/doc/asio/reference/wait_traits/to_wait_duration.html
-/doc/asio/reference/wait_traits/to_wait_duration/overload1.html
-/doc/asio/reference/wait_traits/to_wait_duration/overload2.html
-/doc/asio/reference/windows__basic_object_handle/
-/doc/asio/reference/windows__basic_object_handle/assign/
-/doc/asio/reference/windows__basic_object_handle/assign.html
-/doc/asio/reference/windows__basic_object_handle/assign/overload1.html
-/doc/asio/reference/windows__basic_object_handle/assign/overload2.html
-/doc/asio/reference/windows__basic_object_handle/async_wait.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload1.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload2.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload3.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload4.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload5.html
-/doc/asio/reference/windows__basic_object_handle/basic_object_handle/overload6.html
-/doc/asio/reference/windows__basic_object_handle/cancel/
-/doc/asio/reference/windows__basic_object_handle/cancel.html
-/doc/asio/reference/windows__basic_object_handle/cancel/overload1.html
-/doc/asio/reference/windows__basic_object_handle/cancel/overload2.html
-/doc/asio/reference/windows__basic_object_handle/close/
-/doc/asio/reference/windows__basic_object_handle/close.html
-/doc/asio/reference/windows__basic_object_handle/close/overload1.html
-/doc/asio/reference/windows__basic_object_handle/close/overload2.html
-/doc/asio/reference/windows__basic_object_handle/executor_type.html
-/doc/asio/reference/windows__basic_object_handle/get_executor.html
-/doc/asio/reference/windows__basic_object_handle.html
-/doc/asio/reference/windows__basic_object_handle/is_open.html
-/doc/asio/reference/windows__basic_object_handle/lowest_layer/
-/doc/asio/reference/windows__basic_object_handle/lowest_layer.html
-/doc/asio/reference/windows__basic_object_handle/lowest_layer/overload1.html
-/doc/asio/reference/windows__basic_object_handle/lowest_layer/overload2.html
-/doc/asio/reference/windows__basic_object_handle/lowest_layer_type.html
-/doc/asio/reference/windows__basic_object_handle/native_handle.html
-/doc/asio/reference/windows__basic_object_handle/native_handle_type.html
-/doc/asio/reference/windows__basic_object_handle/operator_eq_/
-/doc/asio/reference/windows__basic_object_handle/operator_eq_.html
-/doc/asio/reference/windows__basic_object_handle/operator_eq_/overload1.html
-/doc/asio/reference/windows__basic_object_handle/operator_eq_/overload2.html
-/doc/asio/reference/windows__basic_object_handle__rebind_executor/
-/doc/asio/reference/windows__basic_object_handle__rebind_executor.html
-/doc/asio/reference/windows__basic_object_handle__rebind_executor/other.html
-/doc/asio/reference/windows__basic_object_handle/wait/
-/doc/asio/reference/windows__basic_object_handle/wait.html
-/doc/asio/reference/windows__basic_object_handle/wait/overload1.html
-/doc/asio/reference/windows__basic_object_handle/wait/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/
-/doc/asio/reference/windows__basic_overlapped_handle/assign/
-/doc/asio/reference/windows__basic_overlapped_handle/assign.html
-/doc/asio/reference/windows__basic_overlapped_handle/assign/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/assign/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/
-/doc/asio/reference/windows__basic_overlapped_handle/_basic_overlapped_handle.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload3.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload4.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload5.html
-/doc/asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload6.html
-/doc/asio/reference/windows__basic_overlapped_handle/cancel/
-/doc/asio/reference/windows__basic_overlapped_handle/cancel.html
-/doc/asio/reference/windows__basic_overlapped_handle/cancel/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/cancel/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/close/
-/doc/asio/reference/windows__basic_overlapped_handle/close.html
-/doc/asio/reference/windows__basic_overlapped_handle/close/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/close/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/executor_type.html
-/doc/asio/reference/windows__basic_overlapped_handle/get_executor.html
-/doc/asio/reference/windows__basic_overlapped_handle.html
-/doc/asio/reference/windows__basic_overlapped_handle/is_open.html
-/doc/asio/reference/windows__basic_overlapped_handle/lowest_layer/
-/doc/asio/reference/windows__basic_overlapped_handle/lowest_layer.html
-/doc/asio/reference/windows__basic_overlapped_handle/lowest_layer/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/lowest_layer/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle/lowest_layer_type.html
-/doc/asio/reference/windows__basic_overlapped_handle/native_handle.html
-/doc/asio/reference/windows__basic_overlapped_handle/native_handle_type.html
-/doc/asio/reference/windows__basic_overlapped_handle/operator_eq_/
-/doc/asio/reference/windows__basic_overlapped_handle/operator_eq_.html
-/doc/asio/reference/windows__basic_overlapped_handle/operator_eq_/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/operator_eq_/overload2.html
-/doc/asio/reference/windows__basic_overlapped_handle__rebind_executor/
-/doc/asio/reference/windows__basic_overlapped_handle__rebind_executor.html
-/doc/asio/reference/windows__basic_overlapped_handle__rebind_executor/other.html
-/doc/asio/reference/windows__basic_overlapped_handle/release/
-/doc/asio/reference/windows__basic_overlapped_handle/release.html
-/doc/asio/reference/windows__basic_overlapped_handle/release/overload1.html
-/doc/asio/reference/windows__basic_overlapped_handle/release/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/
-/doc/asio/reference/windows__basic_random_access_handle/assign/
-/doc/asio/reference/windows__basic_random_access_handle/assign.html
-/doc/asio/reference/windows__basic_random_access_handle/assign/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/assign/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/async_read_some_at.html
-/doc/asio/reference/windows__basic_random_access_handle/async_write_some_at.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload3.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload4.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload5.html
-/doc/asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload6.html
-/doc/asio/reference/windows__basic_random_access_handle/cancel/
-/doc/asio/reference/windows__basic_random_access_handle/cancel.html
-/doc/asio/reference/windows__basic_random_access_handle/cancel/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/cancel/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/close/
-/doc/asio/reference/windows__basic_random_access_handle/close.html
-/doc/asio/reference/windows__basic_random_access_handle/close/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/close/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/executor_type.html
-/doc/asio/reference/windows__basic_random_access_handle/get_executor.html
-/doc/asio/reference/windows__basic_random_access_handle.html
-/doc/asio/reference/windows__basic_random_access_handle/is_open.html
-/doc/asio/reference/windows__basic_random_access_handle/lowest_layer/
-/doc/asio/reference/windows__basic_random_access_handle/lowest_layer.html
-/doc/asio/reference/windows__basic_random_access_handle/lowest_layer/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/lowest_layer/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/lowest_layer_type.html
-/doc/asio/reference/windows__basic_random_access_handle/native_handle.html
-/doc/asio/reference/windows__basic_random_access_handle/native_handle_type.html
-/doc/asio/reference/windows__basic_random_access_handle/operator_eq_/
-/doc/asio/reference/windows__basic_random_access_handle/operator_eq_.html
-/doc/asio/reference/windows__basic_random_access_handle/operator_eq_/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/operator_eq_/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/read_some_at/
-/doc/asio/reference/windows__basic_random_access_handle/read_some_at.html
-/doc/asio/reference/windows__basic_random_access_handle/read_some_at/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/read_some_at/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle__rebind_executor/
-/doc/asio/reference/windows__basic_random_access_handle__rebind_executor.html
-/doc/asio/reference/windows__basic_random_access_handle__rebind_executor/other.html
-/doc/asio/reference/windows__basic_random_access_handle/release/
-/doc/asio/reference/windows__basic_random_access_handle/release.html
-/doc/asio/reference/windows__basic_random_access_handle/release/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/release/overload2.html
-/doc/asio/reference/windows__basic_random_access_handle/write_some_at/
-/doc/asio/reference/windows__basic_random_access_handle/write_some_at.html
-/doc/asio/reference/windows__basic_random_access_handle/write_some_at/overload1.html
-/doc/asio/reference/windows__basic_random_access_handle/write_some_at/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/
-/doc/asio/reference/windows__basic_stream_handle/assign/
-/doc/asio/reference/windows__basic_stream_handle/assign.html
-/doc/asio/reference/windows__basic_stream_handle/assign/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/assign/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/async_read_some.html
-/doc/asio/reference/windows__basic_stream_handle/async_write_some.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload3.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload4.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload5.html
-/doc/asio/reference/windows__basic_stream_handle/basic_stream_handle/overload6.html
-/doc/asio/reference/windows__basic_stream_handle/cancel/
-/doc/asio/reference/windows__basic_stream_handle/cancel.html
-/doc/asio/reference/windows__basic_stream_handle/cancel/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/cancel/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/close/
-/doc/asio/reference/windows__basic_stream_handle/close.html
-/doc/asio/reference/windows__basic_stream_handle/close/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/close/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/executor_type.html
-/doc/asio/reference/windows__basic_stream_handle/get_executor.html
-/doc/asio/reference/windows__basic_stream_handle.html
-/doc/asio/reference/windows__basic_stream_handle/is_open.html
-/doc/asio/reference/windows__basic_stream_handle/lowest_layer/
-/doc/asio/reference/windows__basic_stream_handle/lowest_layer.html
-/doc/asio/reference/windows__basic_stream_handle/lowest_layer/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/lowest_layer/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/lowest_layer_type.html
-/doc/asio/reference/windows__basic_stream_handle/native_handle.html
-/doc/asio/reference/windows__basic_stream_handle/native_handle_type.html
-/doc/asio/reference/windows__basic_stream_handle/operator_eq_/
-/doc/asio/reference/windows__basic_stream_handle/operator_eq_.html
-/doc/asio/reference/windows__basic_stream_handle/operator_eq_/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/operator_eq_/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/read_some/
-/doc/asio/reference/windows__basic_stream_handle/read_some.html
-/doc/asio/reference/windows__basic_stream_handle/read_some/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/read_some/overload2.html
-/doc/asio/reference/windows__basic_stream_handle__rebind_executor/
-/doc/asio/reference/windows__basic_stream_handle__rebind_executor.html
-/doc/asio/reference/windows__basic_stream_handle__rebind_executor/other.html
-/doc/asio/reference/windows__basic_stream_handle/release/
-/doc/asio/reference/windows__basic_stream_handle/release.html
-/doc/asio/reference/windows__basic_stream_handle/release/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/release/overload2.html
-/doc/asio/reference/windows__basic_stream_handle/write_some/
-/doc/asio/reference/windows__basic_stream_handle/write_some.html
-/doc/asio/reference/windows__basic_stream_handle/write_some/overload1.html
-/doc/asio/reference/windows__basic_stream_handle/write_some/overload2.html
-/doc/asio/reference/windows__object_handle.html
-/doc/asio/reference/windows__overlapped_handle.html
-/doc/asio/reference/windows__overlapped_ptr/
-/doc/asio/reference/windows__overlapped_ptr/complete.html
-/doc/asio/reference/windows__overlapped_ptr/get/
-/doc/asio/reference/windows__overlapped_ptr/get.html
-/doc/asio/reference/windows__overlapped_ptr/get/overload1.html
-/doc/asio/reference/windows__overlapped_ptr/get/overload2.html
-/doc/asio/reference/windows__overlapped_ptr.html
-/doc/asio/reference/windows__overlapped_ptr/overlapped_ptr/
-/doc/asio/reference/windows__overlapped_ptr/_overlapped_ptr.html
-/doc/asio/reference/windows__overlapped_ptr/overlapped_ptr.html
-/doc/asio/reference/windows__overlapped_ptr/overlapped_ptr/overload1.html
-/doc/asio/reference/windows__overlapped_ptr/overlapped_ptr/overload2.html
-/doc/asio/reference/windows__overlapped_ptr/overlapped_ptr/overload3.html
-/doc/asio/reference/windows__overlapped_ptr/release.html
-/doc/asio/reference/windows__overlapped_ptr/reset/
-/doc/asio/reference/windows__overlapped_ptr/reset.html
-/doc/asio/reference/windows__overlapped_ptr/reset/overload1.html
-/doc/asio/reference/windows__overlapped_ptr/reset/overload2.html
-/doc/asio/reference/windows__overlapped_ptr/reset/overload3.html
-/doc/asio/reference/windows__random_access_handle.html
-/doc/asio/reference/windows__stream_handle.html
-/doc/asio/reference/writable_pipe.html
-/doc/asio/reference/write/
-/doc/asio/reference/write_at/
-/doc/asio/reference/write_at.html
-/doc/asio/reference/write_at/overload1.html
-/doc/asio/reference/write_at/overload2.html
-/doc/asio/reference/write_at/overload3.html
-/doc/asio/reference/write_at/overload4.html
-/doc/asio/reference/write_at/overload5.html
-/doc/asio/reference/write_at/overload6.html
-/doc/asio/reference/write_at/overload7.html
-/doc/asio/reference/write_at/overload8.html
-/doc/asio/reference/WriteHandler.html
-/doc/asio/reference/write.html
-/doc/asio/reference/write/overload10.html
-/doc/asio/reference/write/overload11.html
-/doc/asio/reference/write/overload12.html
-/doc/asio/reference/write/overload13.html
-/doc/asio/reference/write/overload14.html
-/doc/asio/reference/write/overload15.html
-/doc/asio/reference/write/overload16.html
-/doc/asio/reference/write/overload1.html
-/doc/asio/reference/write/overload2.html
-/doc/asio/reference/write/overload3.html
-/doc/asio/reference/write/overload4.html
-/doc/asio/reference/write/overload5.html
-/doc/asio/reference/write/overload6.html
-/doc/asio/reference/write/overload7.html
-/doc/asio/reference/write/overload8.html
-/doc/asio/reference/write/overload9.html
-/doc/asio/reference/WriteToken.html
-/doc/asio/reference/yield_context.html
-/doc/asio/std_executors.html
-/doc/asio/tutorial/
-/doc/asio/tutorial/boost_bind.html
-/doc/asio/tutorial.html
-/doc/asio/tutorial/tutdaytime1/
-/doc/asio/tutorial/tutdaytime1.html
-/doc/asio/tutorial/tutdaytime1/src.html
-/doc/asio/tutorial/tutdaytime2/
-/doc/asio/tutorial/tutdaytime2.html
-/doc/asio/tutorial/tutdaytime2/src.html
-/doc/asio/tutorial/tutdaytime3/
-/doc/asio/tutorial/tutdaytime3.html
-/doc/asio/tutorial/tutdaytime3/src.html
-/doc/asio/tutorial/tutdaytime4/
-/doc/asio/tutorial/tutdaytime4.html
-/doc/asio/tutorial/tutdaytime4/src.html
-/doc/asio/tutorial/tutdaytime5/
-/doc/asio/tutorial/tutdaytime5.html
-/doc/asio/tutorial/tutdaytime5/src.html
-/doc/asio/tutorial/tutdaytime6/
-/doc/asio/tutorial/tutdaytime6.html
-/doc/asio/tutorial/tutdaytime6/src.html
-/doc/asio/tutorial/tutdaytime7/
-/doc/asio/tutorial/tutdaytime7.html
-/doc/asio/tutorial/tutdaytime7/src.html
-/doc/asio/tutorial/tuttimer1/
-/doc/asio/tutorial/tuttimer1.html
-/doc/asio/tutorial/tuttimer1/src.html
-/doc/asio/tutorial/tuttimer2/
-/doc/asio/tutorial/tuttimer2.html
-/doc/asio/tutorial/tuttimer2/src.html
-/doc/asio/tutorial/tuttimer3/
-/doc/asio/tutorial/tuttimer3.html
-/doc/asio/tutorial/tuttimer3/src.html
-/doc/asio/tutorial/tuttimer4/
-/doc/asio/tutorial/tuttimer4.html
-/doc/asio/tutorial/tuttimer4/src.html
-/doc/asio/tutorial/tuttimer5/
-/doc/asio/tutorial/tuttimer5.html
-/doc/asio/tutorial/tuttimer5/src.html
-/doc/asio/using.html
-/doc/async_agent_chain.png
-/doc/async_agent_model.png
-/doc/async_child_agent_chain.png
-/doc/async_op1.png
-/doc/async_op2.png
-/doc/async_op_init_complete.png
-/doc/async_op_model.png
-/doc/async_op_phases.png
-/doc/async_op_trivial_chain.png
-/doc/blank.png
-/doc/boostbook.css
-/doc/caution.png
-/doc/completion_token_model.png
-/doc/completion_token_transform.png
-/doc/draft.png
-/doc/higher_level_model.png
-/doc/home.png
-/doc/important.png
-/doc/index.html
-/doc/next_disabled.png
-/doc/next.png
-/doc/note.png
-/doc/prev_disabled.png
-/doc/prev.png
-/doc/proactor.png
-/doc/sync_op.png
-/doc/tip.png
-/doc/up_disabled.png
-/doc/up.png
-/doc/warning.png
-/include/
-/include/asio/
-/include/asio/any_completion_executor.hpp
-/include/asio/any_completion_handler.hpp
-/include/asio/any_io_executor.hpp
-/include/asio/append.hpp
-/include/asio/associated_allocator.hpp
-/include/asio/associated_cancellation_slot.hpp
-/include/asio/associated_executor.hpp
-/include/asio/associated_immediate_executor.hpp
-/include/asio/associator.hpp
-/include/asio/as_tuple.hpp
-/include/asio/async_result.hpp
-/include/asio/awaitable.hpp
-/include/asio/basic_datagram_socket.hpp
-/include/asio/basic_deadline_timer.hpp
-/include/asio/basic_file.hpp
-/include/asio/basic_io_object.hpp
-/include/asio/basic_random_access_file.hpp
-/include/asio/basic_raw_socket.hpp
-/include/asio/basic_readable_pipe.hpp
-/include/asio/basic_seq_packet_socket.hpp
-/include/asio/basic_serial_port.hpp
-/include/asio/basic_signal_set.hpp
-/include/asio/basic_socket_acceptor.hpp
-/include/asio/basic_socket.hpp
-/include/asio/basic_socket_iostream.hpp
-/include/asio/basic_socket_streambuf.hpp
-/include/asio/basic_streambuf_fwd.hpp
-/include/asio/basic_streambuf.hpp
-/include/asio/basic_stream_file.hpp
-/include/asio/basic_stream_socket.hpp
-/include/asio/basic_waitable_timer.hpp
-/include/asio/basic_writable_pipe.hpp
-/include/asio/bind_allocator.hpp
-/include/asio/bind_cancellation_slot.hpp
-/include/asio/bind_executor.hpp
-/include/asio/bind_immediate_executor.hpp
-/include/asio/buffered_read_stream_fwd.hpp
-/include/asio/buffered_read_stream.hpp
-/include/asio/buffered_stream_fwd.hpp
-/include/asio/buffered_stream.hpp
-/include/asio/buffered_write_stream_fwd.hpp
-/include/asio/buffered_write_stream.hpp
-/include/asio/buffer.hpp
-/include/asio/buffer_registration.hpp
-/include/asio/buffers_iterator.hpp
-/include/asio/cancel_after.hpp
-/include/asio/cancel_at.hpp
-/include/asio/cancellation_signal.hpp
-/include/asio/cancellation_state.hpp
-/include/asio/cancellation_type.hpp
-/include/asio/co_composed.hpp
-/include/asio/completion_condition.hpp
-/include/asio/composed.hpp
-/include/asio/compose.hpp
-/include/asio/connect.hpp
-/include/asio/connect_pipe.hpp
-/include/asio/consign.hpp
-/include/asio/coroutine.hpp
-/include/asio/co_spawn.hpp
-/include/asio/deadline_timer.hpp
-/include/asio/default_completion_token.hpp
-/include/asio/defer.hpp
-/include/asio/deferred.hpp
-/include/asio/detached.hpp
-/include/asio/detail/
-/include/asio/detail/array_fwd.hpp
-/include/asio/detail/array.hpp
-/include/asio/detail/assert.hpp
-/include/asio/detail/atomic_count.hpp
-/include/asio/detail/base_from_cancellation_state.hpp
-/include/asio/detail/base_from_completion_cond.hpp
-/include/asio/detail/bind_handler.hpp
-/include/asio/detail/blocking_executor_op.hpp
-/include/asio/detail/buffered_stream_storage.hpp
-/include/asio/detail/buffer_resize_guard.hpp
-/include/asio/detail/buffer_sequence_adapter.hpp
-/include/asio/detail/call_stack.hpp
-/include/asio/detail/chrono.hpp
-/include/asio/detail/chrono_time_traits.hpp
-/include/asio/detail/completion_handler.hpp
-/include/asio/detail/completion_message.hpp
-/include/asio/detail/completion_payload_handler.hpp
-/include/asio/detail/completion_payload.hpp
-/include/asio/detail/composed_work.hpp
-/include/asio/detail/concurrency_hint.hpp
-/include/asio/detail/conditionally_enabled_event.hpp
-/include/asio/detail/conditionally_enabled_mutex.hpp
-/include/asio/detail/config.hpp
-/include/asio/detail/consuming_buffers.hpp
-/include/asio/detail/cstddef.hpp
-/include/asio/detail/cstdint.hpp
-/include/asio/detail/date_time_fwd.hpp
-/include/asio/detail/deadline_timer_service.hpp
-/include/asio/detail/dependent_type.hpp
-/include/asio/detail/descriptor_ops.hpp
-/include/asio/detail/descriptor_read_op.hpp
-/include/asio/detail/descriptor_write_op.hpp
-/include/asio/detail/dev_poll_reactor.hpp
-/include/asio/detail/epoll_reactor.hpp
-/include/asio/detail/eventfd_select_interrupter.hpp
-/include/asio/detail/event.hpp
-/include/asio/detail/exception.hpp
-/include/asio/detail/executor_function.hpp
-/include/asio/detail/executor_op.hpp
-/include/asio/detail/fd_set_adapter.hpp
-/include/asio/detail/fenced_block.hpp
-/include/asio/detail/functional.hpp
-/include/asio/detail/future.hpp
-/include/asio/detail/global.hpp
-/include/asio/detail/handler_alloc_helpers.hpp
-/include/asio/detail/handler_cont_helpers.hpp
-/include/asio/detail/handler_tracking.hpp
-/include/asio/detail/handler_type_requirements.hpp
-/include/asio/detail/handler_work.hpp
-/include/asio/detail/hash_map.hpp
-/include/asio/detail/impl/
-/include/asio/detail/impl/buffer_sequence_adapter.ipp
-/include/asio/detail/impl/descriptor_ops.ipp
-/include/asio/detail/impl/dev_poll_reactor.hpp
-/include/asio/detail/impl/dev_poll_reactor.ipp
-/include/asio/detail/impl/epoll_reactor.hpp
-/include/asio/detail/impl/epoll_reactor.ipp
-/include/asio/detail/impl/eventfd_select_interrupter.ipp
-/include/asio/detail/impl/handler_tracking.ipp
-/include/asio/detail/impl/io_uring_descriptor_service.ipp
-/include/asio/detail/impl/io_uring_file_service.ipp
-/include/asio/detail/impl/io_uring_service.hpp
-/include/asio/detail/impl/io_uring_service.ipp
-/include/asio/detail/impl/io_uring_socket_service_base.ipp
-/include/asio/detail/impl/kqueue_reactor.hpp
-/include/asio/detail/impl/kqueue_reactor.ipp
-/include/asio/detail/impl/null_event.ipp
-/include/asio/detail/impl/pipe_select_interrupter.ipp
-/include/asio/detail/impl/posix_event.ipp
-/include/asio/detail/impl/posix_mutex.ipp
-/include/asio/detail/impl/posix_serial_port_service.ipp
-/include/asio/detail/impl/posix_thread.ipp
-/include/asio/detail/impl/posix_tss_ptr.ipp
-/include/asio/detail/impl/reactive_descriptor_service.ipp
-/include/asio/detail/impl/reactive_socket_service_base.ipp
-/include/asio/detail/impl/resolver_service_base.ipp
-/include/asio/detail/impl/scheduler.ipp
-/include/asio/detail/impl/select_reactor.hpp
-/include/asio/detail/impl/select_reactor.ipp
-/include/asio/detail/impl/service_registry.hpp
-/include/asio/detail/impl/service_registry.ipp
-/include/asio/detail/impl/signal_set_service.ipp
-/include/asio/detail/impl/socket_ops.ipp
-/include/asio/detail/impl/socket_select_interrupter.ipp
-/include/asio/detail/impl/strand_executor_service.hpp
-/include/asio/detail/impl/strand_executor_service.ipp
-/include/asio/detail/impl/strand_service.hpp
-/include/asio/detail/impl/strand_service.ipp
-/include/asio/detail/impl/thread_context.ipp
-/include/asio/detail/impl/throw_error.ipp
-/include/asio/detail/impl/timer_queue_ptime.ipp
-/include/asio/detail/impl/timer_queue_set.ipp
-/include/asio/detail/impl/win_event.ipp
-/include/asio/detail/impl/win_iocp_file_service.ipp
-/include/asio/detail/impl/win_iocp_handle_service.ipp
-/include/asio/detail/impl/win_iocp_io_context.hpp
-/include/asio/detail/impl/win_iocp_io_context.ipp
-/include/asio/detail/impl/win_iocp_serial_port_service.ipp
-/include/asio/detail/impl/win_iocp_socket_service_base.ipp
-/include/asio/detail/impl/win_mutex.ipp
-/include/asio/detail/impl/win_object_handle_service.ipp
-/include/asio/detail/impl/winrt_ssocket_service_base.ipp
-/include/asio/detail/impl/winrt_timer_scheduler.hpp
-/include/asio/detail/impl/winrt_timer_scheduler.ipp
-/include/asio/detail/impl/winsock_init.ipp
-/include/asio/detail/impl/win_static_mutex.ipp
-/include/asio/detail/impl/win_thread.ipp
-/include/asio/detail/impl/win_tss_ptr.ipp
-/include/asio/detail/initiate_defer.hpp
-/include/asio/detail/initiate_dispatch.hpp
-/include/asio/detail/initiate_post.hpp
-/include/asio/detail/initiation_base.hpp
-/include/asio/detail/io_control.hpp
-/include/asio/detail/io_object_impl.hpp
-/include/asio/detail/io_uring_descriptor_read_at_op.hpp
-/include/asio/detail/io_uring_descriptor_read_op.hpp
-/include/asio/detail/io_uring_descriptor_service.hpp
-/include/asio/detail/io_uring_descriptor_write_at_op.hpp
-/include/asio/detail/io_uring_descriptor_write_op.hpp
-/include/asio/detail/io_uring_file_service.hpp
-/include/asio/detail/io_uring_null_buffers_op.hpp
-/include/asio/detail/io_uring_operation.hpp
-/include/asio/detail/io_uring_service.hpp
-/include/asio/detail/io_uring_socket_accept_op.hpp
-/include/asio/detail/io_uring_socket_connect_op.hpp
-/include/asio/detail/io_uring_socket_recvfrom_op.hpp
-/include/asio/detail/io_uring_socket_recvmsg_op.hpp
-/include/asio/detail/io_uring_socket_recv_op.hpp
-/include/asio/detail/io_uring_socket_send_op.hpp
-/include/asio/detail/io_uring_socket_sendto_op.hpp
-/include/asio/detail/io_uring_socket_service_base.hpp
-/include/asio/detail/io_uring_socket_service.hpp
-/include/asio/detail/io_uring_wait_op.hpp
-/include/asio/detail/is_buffer_sequence.hpp
-/include/asio/detail/is_executor.hpp
-/include/asio/detail/keyword_tss_ptr.hpp
-/include/asio/detail/kqueue_reactor.hpp
-/include/asio/detail/limits.hpp
-/include/asio/detail/local_free_on_block_exit.hpp
-/include/asio/detail/memory.hpp
-/include/asio/detail/mutex.hpp
-/include/asio/detail/non_const_lvalue.hpp
-/include/asio/detail/noncopyable.hpp
-/include/asio/detail/null_event.hpp
-/include/asio/detail/null_fenced_block.hpp
-/include/asio/detail/null_global.hpp
-/include/asio/detail/null_mutex.hpp
-/include/asio/detail/null_reactor.hpp
-/include/asio/detail/null_signal_blocker.hpp
-/include/asio/detail/null_socket_service.hpp
-/include/asio/detail/null_static_mutex.hpp
-/include/asio/detail/null_thread.hpp
-/include/asio/detail/null_tss_ptr.hpp
-/include/asio/detail/object_pool.hpp
-/include/asio/detail/old_win_sdk_compat.hpp
-/include/asio/detail/operation.hpp
-/include/asio/detail/op_queue.hpp
-/include/asio/detail/pipe_select_interrupter.hpp
-/include/asio/detail/pop_options.hpp
-/include/asio/detail/posix_event.hpp
-/include/asio/detail/posix_fd_set_adapter.hpp
-/include/asio/detail/posix_global.hpp
-/include/asio/detail/posix_mutex.hpp
-/include/asio/detail/posix_serial_port_service.hpp
-/include/asio/detail/posix_signal_blocker.hpp
-/include/asio/detail/posix_static_mutex.hpp
-/include/asio/detail/posix_thread.hpp
-/include/asio/detail/posix_tss_ptr.hpp
-/include/asio/detail/push_options.hpp
-/include/asio/detail/reactive_descriptor_service.hpp
-/include/asio/detail/reactive_null_buffers_op.hpp
-/include/asio/detail/reactive_socket_accept_op.hpp
-/include/asio/detail/reactive_socket_connect_op.hpp
-/include/asio/detail/reactive_socket_recvfrom_op.hpp
-/include/asio/detail/reactive_socket_recvmsg_op.hpp
-/include/asio/detail/reactive_socket_recv_op.hpp
-/include/asio/detail/reactive_socket_send_op.hpp
-/include/asio/detail/reactive_socket_sendto_op.hpp
-/include/asio/detail/reactive_socket_service_base.hpp
-/include/asio/detail/reactive_socket_service.hpp
-/include/asio/detail/reactive_wait_op.hpp
-/include/asio/detail/reactor.hpp
-/include/asio/detail/reactor_op.hpp
-/include/asio/detail/reactor_op_queue.hpp
-/include/asio/detail/recycling_allocator.hpp
-/include/asio/detail/regex_fwd.hpp
-/include/asio/detail/resolve_endpoint_op.hpp
-/include/asio/detail/resolve_op.hpp
-/include/asio/detail/resolve_query_op.hpp
-/include/asio/detail/resolver_service_base.hpp
-/include/asio/detail/resolver_service.hpp
-/include/asio/detail/scheduler.hpp
-/include/asio/detail/scheduler_operation.hpp
-/include/asio/detail/scheduler_task.hpp
-/include/asio/detail/scheduler_thread_info.hpp
-/include/asio/detail/scoped_lock.hpp
-/include/asio/detail/scoped_ptr.hpp
-/include/asio/detail/select_interrupter.hpp
-/include/asio/detail/select_reactor.hpp
-/include/asio/detail/service_registry.hpp
-/include/asio/detail/signal_blocker.hpp
-/include/asio/detail/signal_handler.hpp
-/include/asio/detail/signal_init.hpp
-/include/asio/detail/signal_op.hpp
-/include/asio/detail/signal_set_service.hpp
-/include/asio/detail/socket_holder.hpp
-/include/asio/detail/socket_ops.hpp
-/include/asio/detail/socket_option.hpp
-/include/asio/detail/socket_select_interrupter.hpp
-/include/asio/detail/socket_types.hpp
-/include/asio/detail/source_location.hpp
-/include/asio/detail/static_mutex.hpp
-/include/asio/detail/std_event.hpp
-/include/asio/detail/std_fenced_block.hpp
-/include/asio/detail/std_global.hpp
-/include/asio/detail/std_mutex.hpp
-/include/asio/detail/std_static_mutex.hpp
-/include/asio/detail/std_thread.hpp
-/include/asio/detail/strand_executor_service.hpp
-/include/asio/detail/strand_service.hpp
-/include/asio/detail/string_view.hpp
-/include/asio/detail/thread_context.hpp
-/include/asio/detail/thread_group.hpp
-/include/asio/detail/thread.hpp
-/include/asio/detail/thread_info_base.hpp
-/include/asio/detail/throw_error.hpp
-/include/asio/detail/throw_exception.hpp
-/include/asio/detail/timed_cancel_op.hpp
-/include/asio/detail/timer_queue_base.hpp
-/include/asio/detail/timer_queue.hpp
-/include/asio/detail/timer_queue_ptime.hpp
-/include/asio/detail/timer_queue_set.hpp
-/include/asio/detail/timer_scheduler_fwd.hpp
-/include/asio/detail/timer_scheduler.hpp
-/include/asio/detail/tss_ptr.hpp
-/include/asio/detail/type_traits.hpp
-/include/asio/detail/utility.hpp
-/include/asio/detail/wait_handler.hpp
-/include/asio/detail/wait_op.hpp
-/include/asio/detail/winapp_thread.hpp
-/include/asio/detail/wince_thread.hpp
-/include/asio/detail/win_event.hpp
-/include/asio/detail/win_fd_set_adapter.hpp
-/include/asio/detail/win_global.hpp
-/include/asio/detail/win_iocp_file_service.hpp
-/include/asio/detail/win_iocp_handle_read_op.hpp
-/include/asio/detail/win_iocp_handle_service.hpp
-/include/asio/detail/win_iocp_handle_write_op.hpp
-/include/asio/detail/win_iocp_io_context.hpp
-/include/asio/detail/win_iocp_null_buffers_op.hpp
-/include/asio/detail/win_iocp_operation.hpp
-/include/asio/detail/win_iocp_overlapped_op.hpp
-/include/asio/detail/win_iocp_overlapped_ptr.hpp
-/include/asio/detail/win_iocp_serial_port_service.hpp
-/include/asio/detail/win_iocp_socket_accept_op.hpp
-/include/asio/detail/win_iocp_socket_connect_op.hpp
-/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
-/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
-/include/asio/detail/win_iocp_socket_recv_op.hpp
-/include/asio/detail/win_iocp_socket_send_op.hpp
-/include/asio/detail/win_iocp_socket_service_base.hpp
-/include/asio/detail/win_iocp_socket_service.hpp
-/include/asio/detail/win_iocp_thread_info.hpp
-/include/asio/detail/win_iocp_wait_op.hpp
-/include/asio/detail/win_mutex.hpp
-/include/asio/detail/win_object_handle_service.hpp
-/include/asio/detail/winrt_async_manager.hpp
-/include/asio/detail/winrt_async_op.hpp
-/include/asio/detail/winrt_resolve_op.hpp
-/include/asio/detail/winrt_resolver_service.hpp
-/include/asio/detail/winrt_socket_connect_op.hpp
-/include/asio/detail/winrt_socket_recv_op.hpp
-/include/asio/detail/winrt_socket_send_op.hpp
-/include/asio/detail/winrt_ssocket_service_base.hpp
-/include/asio/detail/winrt_ssocket_service.hpp
-/include/asio/detail/winrt_timer_scheduler.hpp
-/include/asio/detail/winrt_utils.hpp
-/include/asio/detail/winsock_init.hpp
-/include/asio/detail/win_static_mutex.hpp
-/include/asio/detail/win_thread.hpp
-/include/asio/detail/win_tss_ptr.hpp
-/include/asio/detail/work_dispatcher.hpp
-/include/asio/detail/wrapped_handler.hpp
-/include/asio/dispatch.hpp
-/include/asio/error_code.hpp
-/include/asio/error.hpp
-/include/asio/execution/
-/include/asio/execution/allocator.hpp
-/include/asio/execution/any_executor.hpp
-/include/asio/execution/bad_executor.hpp
-/include/asio/execution/blocking_adaptation.hpp
-/include/asio/execution/blocking.hpp
-/include/asio/execution/context_as.hpp
-/include/asio/execution/context.hpp
-/include/asio/execution_context.hpp
-/include/asio/execution/executor.hpp
-/include/asio/execution.hpp
-/include/asio/execution/impl/
-/include/asio/execution/impl/bad_executor.ipp
-/include/asio/execution/invocable_archetype.hpp
-/include/asio/execution/mapping.hpp
-/include/asio/execution/occupancy.hpp
-/include/asio/execution/outstanding_work.hpp
-/include/asio/execution/prefer_only.hpp
-/include/asio/execution/relationship.hpp
-/include/asio/executor.hpp
-/include/asio/executor_work_guard.hpp
-/include/asio/experimental/
-/include/asio/experimental/append.hpp
-/include/asio/experimental/as_single.hpp
-/include/asio/experimental/as_tuple.hpp
-/include/asio/experimental/awaitable_operators.hpp
-/include/asio/experimental/basic_channel.hpp
-/include/asio/experimental/basic_concurrent_channel.hpp
-/include/asio/experimental/cancellation_condition.hpp
-/include/asio/experimental/channel_error.hpp
-/include/asio/experimental/channel.hpp
-/include/asio/experimental/channel_traits.hpp
-/include/asio/experimental/co_composed.hpp
-/include/asio/experimental/concurrent_channel.hpp
-/include/asio/experimental/coro.hpp
-/include/asio/experimental/coro_traits.hpp
-/include/asio/experimental/co_spawn.hpp
-/include/asio/experimental/deferred.hpp
-/include/asio/experimental/detail/
-/include/asio/experimental/detail/channel_operation.hpp
-/include/asio/experimental/detail/channel_receive_op.hpp
-/include/asio/experimental/detail/channel_send_functions.hpp
-/include/asio/experimental/detail/channel_send_op.hpp
-/include/asio/experimental/detail/channel_service.hpp
-/include/asio/experimental/detail/coro_completion_handler.hpp
-/include/asio/experimental/detail/coro_promise_allocator.hpp
-/include/asio/experimental/detail/has_signature.hpp
-/include/asio/experimental/detail/impl/
-/include/asio/experimental/detail/impl/channel_service.hpp
-/include/asio/experimental/detail/partial_promise.hpp
-/include/asio/experimental/impl/
-/include/asio/experimental/impl/as_single.hpp
-/include/asio/experimental/impl/channel_error.ipp
-/include/asio/experimental/impl/coro.hpp
-/include/asio/experimental/impl/parallel_group.hpp
-/include/asio/experimental/impl/promise.hpp
-/include/asio/experimental/impl/use_coro.hpp
-/include/asio/experimental/impl/use_promise.hpp
-/include/asio/experimental/parallel_group.hpp
-/include/asio/experimental/prepend.hpp
-/include/asio/experimental/promise.hpp
-/include/asio/experimental/use_coro.hpp
-/include/asio/experimental/use_promise.hpp
-/include/asio/file_base.hpp
-/include/asio/generic/
-/include/asio/generic/basic_endpoint.hpp
-/include/asio/generic/datagram_protocol.hpp
-/include/asio/generic/detail/
-/include/asio/generic/detail/endpoint.hpp
-/include/asio/generic/detail/impl/
-/include/asio/generic/detail/impl/endpoint.ipp
-/include/asio/generic/raw_protocol.hpp
-/include/asio/generic/seq_packet_protocol.hpp
-/include/asio/generic/stream_protocol.hpp
-/include/asio/handler_continuation_hook.hpp
-/include/asio/high_resolution_timer.hpp
-/include/asio.hpp
-/include/asio/immediate.hpp
-/include/asio/impl/
-/include/asio/impl/any_completion_executor.ipp
-/include/asio/impl/any_io_executor.ipp
-/include/asio/impl/append.hpp
-/include/asio/impl/as_tuple.hpp
-/include/asio/impl/awaitable.hpp
-/include/asio/impl/buffered_read_stream.hpp
-/include/asio/impl/buffered_write_stream.hpp
-/include/asio/impl/cancel_after.hpp
-/include/asio/impl/cancel_at.hpp
-/include/asio/impl/cancellation_signal.ipp
-/include/asio/impl/connect.hpp
-/include/asio/impl/connect_pipe.hpp
-/include/asio/impl/connect_pipe.ipp
-/include/asio/impl/consign.hpp
-/include/asio/impl/co_spawn.hpp
-/include/asio/impl/deferred.hpp
-/include/asio/impl/detached.hpp
-/include/asio/impl/error_code.ipp
-/include/asio/impl/error.ipp
-/include/asio/impl/execution_context.hpp
-/include/asio/impl/execution_context.ipp
-/include/asio/impl/executor.hpp
-/include/asio/impl/executor.ipp
-/include/asio/impl/io_context.hpp
-/include/asio/impl/io_context.ipp
-/include/asio/impl/multiple_exceptions.ipp
-/include/asio/impl/prepend.hpp
-/include/asio/impl/read_at.hpp
-/include/asio/impl/read.hpp
-/include/asio/impl/read_until.hpp
-/include/asio/impl/redirect_error.hpp
-/include/asio/impl/serial_port_base.hpp
-/include/asio/impl/serial_port_base.ipp
-/include/asio/impl/spawn.hpp
-/include/asio/impl/src.hpp
-/include/asio/impl/system_context.hpp
-/include/asio/impl/system_context.ipp
-/include/asio/impl/system_executor.hpp
-/include/asio/impl/thread_pool.hpp
-/include/asio/impl/thread_pool.ipp
-/include/asio/impl/use_awaitable.hpp
-/include/asio/impl/use_future.hpp
-/include/asio/impl/write_at.hpp
-/include/asio/impl/write.hpp
-/include/asio/io_context.hpp
-/include/asio/io_context_strand.hpp
-/include/asio/io_service.hpp
-/include/asio/io_service_strand.hpp
-/include/asio/ip/
-/include/asio/ip/address.hpp
-/include/asio/ip/address_v4.hpp
-/include/asio/ip/address_v4_iterator.hpp
-/include/asio/ip/address_v4_range.hpp
-/include/asio/ip/address_v6.hpp
-/include/asio/ip/address_v6_iterator.hpp
-/include/asio/ip/address_v6_range.hpp
-/include/asio/ip/bad_address_cast.hpp
-/include/asio/ip/basic_endpoint.hpp
-/include/asio/ip/basic_resolver_entry.hpp
-/include/asio/ip/basic_resolver.hpp
-/include/asio/ip/basic_resolver_iterator.hpp
-/include/asio/ip/basic_resolver_query.hpp
-/include/asio/ip/basic_resolver_results.hpp
-/include/asio/ip/detail/
-/include/asio/ip/detail/endpoint.hpp
-/include/asio/ip/detail/impl/
-/include/asio/ip/detail/impl/endpoint.ipp
-/include/asio/ip/detail/socket_option.hpp
-/include/asio/ip/host_name.hpp
-/include/asio/ip/icmp.hpp
-/include/asio/ip/impl/
-/include/asio/ip/impl/address.hpp
-/include/asio/ip/impl/address.ipp
-/include/asio/ip/impl/address_v4.hpp
-/include/asio/ip/impl/address_v4.ipp
-/include/asio/ip/impl/address_v6.hpp
-/include/asio/ip/impl/address_v6.ipp
-/include/asio/ip/impl/basic_endpoint.hpp
-/include/asio/ip/impl/host_name.ipp
-/include/asio/ip/impl/network_v4.hpp
-/include/asio/ip/impl/network_v4.ipp
-/include/asio/ip/impl/network_v6.hpp
-/include/asio/ip/impl/network_v6.ipp
-/include/asio/ip/multicast.hpp
-/include/asio/ip/network_v4.hpp
-/include/asio/ip/network_v6.hpp
-/include/asio/ip/resolver_base.hpp
-/include/asio/ip/resolver_query_base.hpp
-/include/asio/ip/tcp.hpp
-/include/asio/ip/udp.hpp
-/include/asio/ip/unicast.hpp
-/include/asio/ip/v6_only.hpp
-/include/asio/is_applicable_property.hpp
-/include/asio/is_contiguous_iterator.hpp
-/include/asio/is_executor.hpp
-/include/asio/is_read_buffered.hpp
-/include/asio/is_write_buffered.hpp
-/include/asio/local/
-/include/asio/local/basic_endpoint.hpp
-/include/asio/local/connect_pair.hpp
-/include/asio/local/datagram_protocol.hpp
-/include/asio/local/detail/
-/include/asio/local/detail/endpoint.hpp
-/include/asio/local/detail/impl/
-/include/asio/local/detail/impl/endpoint.ipp
-/include/asio/local/seq_packet_protocol.hpp
-/include/asio/local/stream_protocol.hpp
-/include/asio/multiple_exceptions.hpp
-/include/asio/packaged_task.hpp
-/include/asio/placeholders.hpp
-/include/asio/posix/
-/include/asio/posix/basic_descriptor.hpp
-/include/asio/posix/basic_stream_descriptor.hpp
-/include/asio/posix/descriptor_base.hpp
-/include/asio/posix/descriptor.hpp
-/include/asio/posix/stream_descriptor.hpp
-/include/asio/post.hpp
-/include/asio/prefer.hpp
-/include/asio/prepend.hpp
-/include/asio/query.hpp
-/include/asio/random_access_file.hpp
-/include/asio/readable_pipe.hpp
-/include/asio/read_at.hpp
-/include/asio/read.hpp
-/include/asio/read_until.hpp
-/include/asio/recycling_allocator.hpp
-/include/asio/redirect_error.hpp
-/include/asio/registered_buffer.hpp
-/include/asio/require_concept.hpp
-/include/asio/require.hpp
-/include/asio/serial_port_base.hpp
-/include/asio/serial_port.hpp
-/include/asio/signal_set_base.hpp
-/include/asio/signal_set.hpp
-/include/asio/socket_base.hpp
-/include/asio/spawn.hpp
-/include/asio/ssl/
-/include/asio/ssl/context_base.hpp
-/include/asio/ssl/context.hpp
-/include/asio/ssl/detail/
-/include/asio/ssl/detail/buffered_handshake_op.hpp
-/include/asio/ssl/detail/engine.hpp
-/include/asio/ssl/detail/handshake_op.hpp
-/include/asio/ssl/detail/impl/
-/include/asio/ssl/detail/impl/engine.ipp
-/include/asio/ssl/detail/impl/openssl_init.ipp
-/include/asio/ssl/detail/io.hpp
-/include/asio/ssl/detail/openssl_init.hpp
-/include/asio/ssl/detail/openssl_types.hpp
-/include/asio/ssl/detail/password_callback.hpp
-/include/asio/ssl/detail/read_op.hpp
-/include/asio/ssl/detail/shutdown_op.hpp
-/include/asio/ssl/detail/stream_core.hpp
-/include/asio/ssl/detail/verify_callback.hpp
-/include/asio/ssl/detail/write_op.hpp
-/include/asio/ssl/error.hpp
-/include/asio/ssl/host_name_verification.hpp
-/include/asio/ssl.hpp
-/include/asio/ssl/impl/
-/include/asio/ssl/impl/context.hpp
-/include/asio/ssl/impl/context.ipp
-/include/asio/ssl/impl/error.ipp
-/include/asio/ssl/impl/host_name_verification.ipp
-/include/asio/ssl/impl/rfc2818_verification.ipp
-/include/asio/ssl/impl/src.hpp
-/include/asio/ssl/rfc2818_verification.hpp
-/include/asio/ssl/stream_base.hpp
-/include/asio/ssl/stream.hpp
-/include/asio/ssl/verify_context.hpp
-/include/asio/ssl/verify_mode.hpp
-/include/asio/static_thread_pool.hpp
-/include/asio/steady_timer.hpp
-/include/asio/strand.hpp
-/include/asio/streambuf.hpp
-/include/asio/stream_file.hpp
-/include/asio/system_context.hpp
-/include/asio/system_error.hpp
-/include/asio/system_executor.hpp
-/include/asio/system_timer.hpp
-/include/asio/this_coro.hpp
-/include/asio/thread.hpp
-/include/asio/thread_pool.hpp
-/include/asio/time_traits.hpp
-/include/asio/traits/
-/include/asio/traits/equality_comparable.hpp
-/include/asio/traits/execute_member.hpp
-/include/asio/traits/prefer_free.hpp
-/include/asio/traits/prefer_member.hpp
-/include/asio/traits/query_free.hpp
-/include/asio/traits/query_member.hpp
-/include/asio/traits/query_static_constexpr_member.hpp
-/include/asio/traits/require_concept_free.hpp
-/include/asio/traits/require_concept_member.hpp
-/include/asio/traits/require_free.hpp
-/include/asio/traits/require_member.hpp
-/include/asio/traits/static_query.hpp
-/include/asio/traits/static_require_concept.hpp
-/include/asio/traits/static_require.hpp
-/include/asio/ts/
-/include/asio/ts/buffer.hpp
-/include/asio/ts/executor.hpp
-/include/asio/ts/internet.hpp
-/include/asio/ts/io_context.hpp
-/include/asio/ts/netfwd.hpp
-/include/asio/ts/net.hpp
-/include/asio/ts/socket.hpp
-/include/asio/ts/timer.hpp
-/include/asio/unyield.hpp
-/include/asio/use_awaitable.hpp
-/include/asio/use_future.hpp
-/include/asio/uses_executor.hpp
-/include/asio/version.hpp
-/include/asio/wait_traits.hpp
-/include/asio/windows/
-/include/asio/windows/basic_object_handle.hpp
-/include/asio/windows/basic_overlapped_handle.hpp
-/include/asio/windows/basic_random_access_handle.hpp
-/include/asio/windows/basic_stream_handle.hpp
-/include/asio/windows/object_handle.hpp
-/include/asio/windows/overlapped_handle.hpp
-/include/asio/windows/overlapped_ptr.hpp
-/include/asio/windows/random_access_handle.hpp
-/include/asio/windows/stream_handle.hpp
-/include/asio/writable_pipe.hpp
-/include/asio/write_at.hpp
-/include/asio/write.hpp
-/include/asio/yield.hpp
-/include/Makefile.am
-/include/Makefile.in
-/INSTALL
-/install-sh
-/LICENSE_1_0.txt
-/Makefile.am
-/Makefile.in
-/missing
-/README
-/src/
-/src/asio.cpp
-/src/asio_ssl.cpp
-/src/examples/
-/src/examples/cpp11/
-/src/examples/cpp11/allocation/
-/src/examples/cpp11/allocation/server.cpp
-/src/examples/cpp11/buffers/
-/src/examples/cpp11/buffers/reference_counted.cpp
-/src/examples/cpp11/chat/
-/src/examples/cpp11/chat/chat_client.cpp
-/src/examples/cpp11/chat/chat_message.hpp
-/src/examples/cpp11/chat/chat_server.cpp
-/src/examples/cpp11/chat/posix_chat_client.cpp
-/src/examples/cpp11/deferred/
-/src/examples/cpp11/deferred/deferred_1.cpp
-/src/examples/cpp11/deferred/deferred_2.cpp
-/src/examples/cpp11/echo/
-/src/examples/cpp11/echo/async_tcp_echo_server.cpp
-/src/examples/cpp11/echo/async_udp_echo_server.cpp
-/src/examples/cpp11/echo/blocking_tcp_echo_client.cpp
-/src/examples/cpp11/echo/blocking_tcp_echo_server.cpp
-/src/examples/cpp11/echo/blocking_udp_echo_client.cpp
-/src/examples/cpp11/echo/blocking_udp_echo_server.cpp
-/src/examples/cpp11/executors/
-/src/examples/cpp11/executors/actor.cpp
-/src/examples/cpp11/executors/bank_account_1.cpp
-/src/examples/cpp11/executors/bank_account_2.cpp
-/src/examples/cpp11/executors/fork_join.cpp
-/src/examples/cpp11/executors/pipeline.cpp
-/src/examples/cpp11/executors/priority_scheduler.cpp
-/src/examples/cpp11/files/
-/src/examples/cpp11/files/async_file_copy.cpp
-/src/examples/cpp11/files/blocking_file_copy.cpp
-/src/examples/cpp11/fork/
-/src/examples/cpp11/fork/daemon.cpp
-/src/examples/cpp11/fork/process_per_connection.cpp
-/src/examples/cpp11/futures/
-/src/examples/cpp11/futures/daytime_client.cpp
-/src/examples/cpp11/handler_tracking/
-/src/examples/cpp11/handler_tracking/async_tcp_echo_server.cpp
-/src/examples/cpp11/handler_tracking/custom_tracking.hpp
-/src/examples/cpp11/http/
-/src/examples/cpp11/http/client/
-/src/examples/cpp11/http/client/async_client.cpp
-/src/examples/cpp11/http/client/sync_client.cpp
-/src/examples/cpp11/http/server/
-/src/examples/cpp11/http/server2/
-/src/examples/cpp11/http/server2/connection.cpp
-/src/examples/cpp11/http/server2/connection.hpp
-/src/examples/cpp11/http/server2/header.hpp
-/src/examples/cpp11/http/server2/io_context_pool.cpp
-/src/examples/cpp11/http/server2/io_context_pool.hpp
-/src/examples/cpp11/http/server2/main.cpp
-/src/examples/cpp11/http/server2/mime_types.cpp
-/src/examples/cpp11/http/server2/mime_types.hpp
-/src/examples/cpp11/http/server2/reply.cpp
-/src/examples/cpp11/http/server2/reply.hpp
-/src/examples/cpp11/http/server2/request_handler.cpp
-/src/examples/cpp11/http/server2/request_handler.hpp
-/src/examples/cpp11/http/server2/request.hpp
-/src/examples/cpp11/http/server2/request_parser.cpp
-/src/examples/cpp11/http/server2/request_parser.hpp
-/src/examples/cpp11/http/server2/server.cpp
-/src/examples/cpp11/http/server2/server.hpp
-/src/examples/cpp11/http/server3/
-/src/examples/cpp11/http/server3/connection.cpp
-/src/examples/cpp11/http/server3/connection.hpp
-/src/examples/cpp11/http/server3/header.hpp
-/src/examples/cpp11/http/server3/main.cpp
-/src/examples/cpp11/http/server3/mime_types.cpp
-/src/examples/cpp11/http/server3/mime_types.hpp
-/src/examples/cpp11/http/server3/reply.cpp
-/src/examples/cpp11/http/server3/reply.hpp
-/src/examples/cpp11/http/server3/request_handler.cpp
-/src/examples/cpp11/http/server3/request_handler.hpp
-/src/examples/cpp11/http/server3/request.hpp
-/src/examples/cpp11/http/server3/request_parser.cpp
-/src/examples/cpp11/http/server3/request_parser.hpp
-/src/examples/cpp11/http/server3/server.cpp
-/src/examples/cpp11/http/server3/server.hpp
-/src/examples/cpp11/http/server4/
-/src/examples/cpp11/http/server4/file_handler.cpp
-/src/examples/cpp11/http/server4/file_handler.hpp
-/src/examples/cpp11/http/server4/header.hpp
-/src/examples/cpp11/http/server4/main.cpp
-/src/examples/cpp11/http/server4/mime_types.cpp
-/src/examples/cpp11/http/server4/mime_types.hpp
-/src/examples/cpp11/http/server4/reply.cpp
-/src/examples/cpp11/http/server4/reply.hpp
-/src/examples/cpp11/http/server4/request.hpp
-/src/examples/cpp11/http/server4/request_parser.cpp
-/src/examples/cpp11/http/server4/request_parser.hpp
-/src/examples/cpp11/http/server4/server.cpp
-/src/examples/cpp11/http/server4/server.hpp
-/src/examples/cpp11/http/server/connection.cpp
-/src/examples/cpp11/http/server/connection.hpp
-/src/examples/cpp11/http/server/connection_manager.cpp
-/src/examples/cpp11/http/server/connection_manager.hpp
-/src/examples/cpp11/http/server/header.hpp
-/src/examples/cpp11/http/server/main.cpp
-/src/examples/cpp11/http/server/mime_types.cpp
-/src/examples/cpp11/http/server/mime_types.hpp
-/src/examples/cpp11/http/server/reply.cpp
-/src/examples/cpp11/http/server/reply.hpp
-/src/examples/cpp11/http/server/request_handler.cpp
-/src/examples/cpp11/http/server/request_handler.hpp
-/src/examples/cpp11/http/server/request.hpp
-/src/examples/cpp11/http/server/request_parser.cpp
-/src/examples/cpp11/http/server/request_parser.hpp
-/src/examples/cpp11/http/server/server.cpp
-/src/examples/cpp11/http/server/server.hpp
-/src/examples/cpp11/icmp/
-/src/examples/cpp11/icmp/icmp_header.hpp
-/src/examples/cpp11/icmp/ipv4_header.hpp
-/src/examples/cpp11/icmp/ping.cpp
-/src/examples/cpp11/invocation/
-/src/examples/cpp11/invocation/prioritised_handlers.cpp
-/src/examples/cpp11/iostreams/
-/src/examples/cpp11/iostreams/daytime_client.cpp
-/src/examples/cpp11/iostreams/daytime_server.cpp
-/src/examples/cpp11/iostreams/http_client.cpp
-/src/examples/cpp11/local/
-/src/examples/cpp11/local/connect_pair.cpp
-/src/examples/cpp11/local/fd_passing_stream_client.cpp
-/src/examples/cpp11/local/fd_passing_stream_server.cpp
-/src/examples/cpp11/local/iostream_client.cpp
-/src/examples/cpp11/local/stream_client.cpp
-/src/examples/cpp11/local/stream_server.cpp
-/src/examples/cpp11/Makefile.am
-/src/examples/cpp11/Makefile.in
-/src/examples/cpp11/multicast/
-/src/examples/cpp11/multicast/receiver.cpp
-/src/examples/cpp11/multicast/sender.cpp
-/src/examples/cpp11/nonblocking/
-/src/examples/cpp11/nonblocking/third_party_lib.cpp
-/src/examples/cpp11/operations/
-/src/examples/cpp11/operations/composed_1.cpp
-/src/examples/cpp11/operations/composed_2.cpp
-/src/examples/cpp11/operations/composed_3.cpp
-/src/examples/cpp11/operations/composed_4.cpp
-/src/examples/cpp11/operations/composed_5.cpp
-/src/examples/cpp11/operations/composed_6.cpp
-/src/examples/cpp11/operations/composed_7.cpp
-/src/examples/cpp11/operations/composed_8.cpp
-/src/examples/cpp11/parallel_group/
-/src/examples/cpp11/parallel_group/ranged_wait_for_all.cpp
-/src/examples/cpp11/parallel_group/wait_for_all.cpp
-/src/examples/cpp11/parallel_group/wait_for_one.cpp
-/src/examples/cpp11/parallel_group/wait_for_one_error.cpp
-/src/examples/cpp11/parallel_group/wait_for_one_success.cpp
-/src/examples/cpp11/porthopper/
-/src/examples/cpp11/porthopper/client.cpp
-/src/examples/cpp11/porthopper/protocol.hpp
-/src/examples/cpp11/porthopper/server.cpp
-/src/examples/cpp11/serialization/
-/src/examples/cpp11/serialization/client.cpp
-/src/examples/cpp11/serialization/connection.hpp
-/src/examples/cpp11/serialization/server.cpp
-/src/examples/cpp11/serialization/stock.hpp
-/src/examples/cpp11/services/
-/src/examples/cpp11/services/basic_logger.hpp
-/src/examples/cpp11/services/daytime_client.cpp
-/src/examples/cpp11/services/logger.hpp
-/src/examples/cpp11/services/logger_service.cpp
-/src/examples/cpp11/services/logger_service.hpp
-/src/examples/cpp11/socks4/
-/src/examples/cpp11/socks4/socks4.hpp
-/src/examples/cpp11/socks4/sync_client.cpp
-/src/examples/cpp11/spawn/
-/src/examples/cpp11/spawn/echo_server.cpp
-/src/examples/cpp11/spawn/parallel_grep.cpp
-/src/examples/cpp11/ssl/
-/src/examples/cpp11/ssl/ca.pem
-/src/examples/cpp11/ssl/client.cpp
-/src/examples/cpp11/ssl/dh4096.pem
-/src/examples/cpp11/ssl/README
-/src/examples/cpp11/ssl/server.cpp
-/src/examples/cpp11/ssl/server.pem
-/src/examples/cpp11/timeouts/
-/src/examples/cpp11/timeouts/async_tcp_client.cpp
-/src/examples/cpp11/timeouts/blocking_tcp_client.cpp
-/src/examples/cpp11/timeouts/blocking_token_tcp_client.cpp
-/src/examples/cpp11/timeouts/blocking_udp_client.cpp
-/src/examples/cpp11/timeouts/server.cpp
-/src/examples/cpp11/timers/
-/src/examples/cpp11/timers/time_t_timer.cpp
-/src/examples/cpp11/tutorial/
-/src/examples/cpp11/tutorial/daytime1/
-/src/examples/cpp11/tutorial/daytime1/client.cpp
-/src/examples/cpp11/tutorial/daytime2/
-/src/examples/cpp11/tutorial/daytime2/server.cpp
-/src/examples/cpp11/tutorial/daytime3/
-/src/examples/cpp11/tutorial/daytime3/server.cpp
-/src/examples/cpp11/tutorial/daytime4/
-/src/examples/cpp11/tutorial/daytime4/client.cpp
-/src/examples/cpp11/tutorial/daytime5/
-/src/examples/cpp11/tutorial/daytime5/server.cpp
-/src/examples/cpp11/tutorial/daytime6/
-/src/examples/cpp11/tutorial/daytime6/server.cpp
-/src/examples/cpp11/tutorial/daytime7/
-/src/examples/cpp11/tutorial/daytime7/server.cpp
-/src/examples/cpp11/tutorial/timer1/
-/src/examples/cpp11/tutorial/timer1/timer.cpp
-/src/examples/cpp11/tutorial/timer2/
-/src/examples/cpp11/tutorial/timer2/timer.cpp
-/src/examples/cpp11/tutorial/timer3/
-/src/examples/cpp11/tutorial/timer3/timer.cpp
-/src/examples/cpp11/tutorial/timer4/
-/src/examples/cpp11/tutorial/timer4/timer.cpp
-/src/examples/cpp11/tutorial/timer5/
-/src/examples/cpp11/tutorial/timer5/timer.cpp
-/src/examples/cpp11/type_erasure/
-/src/examples/cpp11/type_erasure/line_reader.hpp
-/src/examples/cpp11/type_erasure/main.cpp
-/src/examples/cpp11/type_erasure/sleep.cpp
-/src/examples/cpp11/type_erasure/sleep.hpp
-/src/examples/cpp11/type_erasure/stdin_line_reader.cpp
-/src/examples/cpp11/type_erasure/stdin_line_reader.hpp
-/src/examples/cpp11/windows/
-/src/examples/cpp11/windows/transmit_file.cpp
-/src/examples/cpp14/
-/src/examples/cpp14/deferred/
-/src/examples/cpp14/deferred/deferred_1.cpp
-/src/examples/cpp14/deferred/deferred_2.cpp
-/src/examples/cpp14/deferred/deferred_3.cpp
-/src/examples/cpp14/deferred/deferred_4.cpp
-/src/examples/cpp14/deferred/deferred_5.cpp
-/src/examples/cpp14/deferred/deferred_6.cpp
-/src/examples/cpp14/deferred/deferred_7.cpp
-/src/examples/cpp14/echo/
-/src/examples/cpp14/echo/async_tcp_echo_server.cpp
-/src/examples/cpp14/echo/async_udp_echo_server.cpp
-/src/examples/cpp14/echo/blocking_tcp_echo_client.cpp
-/src/examples/cpp14/echo/blocking_tcp_echo_server.cpp
-/src/examples/cpp14/echo/blocking_udp_echo_client.cpp
-/src/examples/cpp14/echo/blocking_udp_echo_server.cpp
-/src/examples/cpp14/executors/
-/src/examples/cpp14/executors/actor.cpp
-/src/examples/cpp14/executors/async_1.cpp
-/src/examples/cpp14/executors/async_2.cpp
-/src/examples/cpp14/executors/bank_account_1.cpp
-/src/examples/cpp14/executors/bank_account_2.cpp
-/src/examples/cpp14/executors/fork_join.cpp
-/src/examples/cpp14/executors/pipeline.cpp
-/src/examples/cpp14/executors/priority_scheduler.cpp
-/src/examples/cpp14/iostreams/
-/src/examples/cpp14/iostreams/http_client.cpp
-/src/examples/cpp14/Makefile.am
-/src/examples/cpp14/Makefile.in
-/src/examples/cpp14/operations/
-/src/examples/cpp14/operations/callback_wrapper.cpp
-/src/examples/cpp14/operations/c_callback_wrapper.cpp
-/src/examples/cpp14/operations/composed_1.cpp
-/src/examples/cpp14/operations/composed_2.cpp
-/src/examples/cpp14/operations/composed_3.cpp
-/src/examples/cpp14/operations/composed_4.cpp
-/src/examples/cpp14/operations/composed_5.cpp
-/src/examples/cpp14/operations/composed_6.cpp
-/src/examples/cpp14/operations/composed_7.cpp
-/src/examples/cpp14/operations/composed_8.cpp
-/src/examples/cpp14/parallel_group/
-/src/examples/cpp14/parallel_group/parallel_sort.cpp
-/src/examples/cpp14/parallel_group/ranged_wait_for_all.cpp
-/src/examples/cpp14/parallel_group/wait_for_all.cpp
-/src/examples/cpp14/parallel_group/wait_for_one.cpp
-/src/examples/cpp14/parallel_group/wait_for_one_error.cpp
-/src/examples/cpp14/parallel_group/wait_for_one_success.cpp
-/src/examples/cpp17/
-/src/examples/cpp17/coroutines_ts/
-/src/examples/cpp17/coroutines_ts/chat_server.cpp
-/src/examples/cpp17/coroutines_ts/echo_server.cpp
-/src/examples/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp
-/src/examples/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp
-/src/examples/cpp17/coroutines_ts/echo_server_with_default.cpp
-/src/examples/cpp17/coroutines_ts/range_based_for.cpp
-/src/examples/cpp17/coroutines_ts/refactored_echo_server.cpp
-/src/examples/cpp17/Makefile.am
-/src/examples/cpp17/Makefile.in
-/src/examples/cpp20/
-/src/examples/cpp20/channels/
-/src/examples/cpp20/channels/mutual_exclusion_1.cpp
-/src/examples/cpp20/channels/mutual_exclusion_2.cpp
-/src/examples/cpp20/channels/throttling_proxy.cpp
-/src/examples/cpp20/coroutines/
-/src/examples/cpp20/coroutines/chat_server.cpp
-/src/examples/cpp20/coroutines/echo_server.cpp
-/src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp
-/src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp
-/src/examples/cpp20/coroutines/echo_server_with_default.cpp
-/src/examples/cpp20/coroutines/echo_server_with_deferred.cpp
-/src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp
-/src/examples/cpp20/coroutines/refactored_echo_server.cpp
-/src/examples/cpp20/coroutines/timeout.cpp
-/src/examples/cpp20/invocation/
-/src/examples/cpp20/invocation/completion_executor.cpp
-/src/examples/cpp20/Makefile.am
-/src/examples/cpp20/Makefile.in
-/src/examples/cpp20/operations/
-/src/examples/cpp20/operations/callback_wrapper.cpp
-/src/examples/cpp20/operations/c_callback_wrapper.cpp
-/src/examples/cpp20/operations/composed_1.cpp
-/src/examples/cpp20/operations/composed_2.cpp
-/src/examples/cpp20/operations/composed_3.cpp
-/src/examples/cpp20/operations/composed_4.cpp
-/src/examples/cpp20/operations/composed_5.cpp
-/src/examples/cpp20/operations/composed_6.cpp
-/src/examples/cpp20/operations/composed_7.cpp
-/src/examples/cpp20/operations/composed_8.cpp
-/src/examples/cpp20/type_erasure/
-/src/examples/cpp20/type_erasure/line_reader.hpp
-/src/examples/cpp20/type_erasure/main.cpp
-/src/examples/cpp20/type_erasure/sleep.cpp
-/src/examples/cpp20/type_erasure/sleep.hpp
-/src/examples/cpp20/type_erasure/stdin_line_reader.cpp
-/src/examples/cpp20/type_erasure/stdin_line_reader.hpp
-/src/Makefile.am
-/src/Makefile.in
-/src/Makefile.mgw
-/src/Makefile.msc
-/src/tests/
-/src/tests/latency/
-/src/tests/latency/allocator.hpp
-/src/tests/latency/high_res_clock.hpp
-/src/tests/latency/tcp_client.cpp
-/src/tests/latency/tcp_server.cpp
-/src/tests/latency/udp_client.cpp
-/src/tests/latency/udp_server.cpp
-/src/tests/Makefile.am
-/src/tests/Makefile.in
-/src/tests/performance/
-/src/tests/performance/client.cpp
-/src/tests/performance/handler_allocator.hpp
-/src/tests/performance/server.cpp
-/src/tests/properties/
-/src/tests/properties/cpp03/
-/src/tests/properties/cpp03/can_prefer_free_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_free_require.cpp
-/src/tests/properties/cpp03/can_prefer_member_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_member_require.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_free_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_free_require.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_member_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_member_require.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_static.cpp
-/src/tests/properties/cpp03/can_prefer_not_applicable_unsupported.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_free_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_free_require.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_member_prefer.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_member_require.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_static.cpp
-/src/tests/properties/cpp03/can_prefer_not_preferable_unsupported.cpp
-/src/tests/properties/cpp03/can_prefer_static.cpp
-/src/tests/properties/cpp03/can_prefer_unsupported.cpp
-/src/tests/properties/cpp03/can_query_free.cpp
-/src/tests/properties/cpp03/can_query_member.cpp
-/src/tests/properties/cpp03/can_query_not_applicable_free.cpp
-/src/tests/properties/cpp03/can_query_not_applicable_member.cpp
-/src/tests/properties/cpp03/can_query_not_applicable_static.cpp
-/src/tests/properties/cpp03/can_query_not_applicable_unsupported.cpp
-/src/tests/properties/cpp03/can_query_static.cpp
-/src/tests/properties/cpp03/can_query_unsupported.cpp
-/src/tests/properties/cpp03/can_require_concept_free.cpp
-/src/tests/properties/cpp03/can_require_concept_member.cpp
-/src/tests/properties/cpp03/can_require_concept_not_applicable_free.cpp
-/src/tests/properties/cpp03/can_require_concept_not_applicable_member.cpp
-/src/tests/properties/cpp03/can_require_concept_not_applicable_static.cpp
-/src/tests/properties/cpp03/can_require_concept_not_applicable_unsupported.cpp
-/src/tests/properties/cpp03/can_require_concept_static.cpp
-/src/tests/properties/cpp03/can_require_concept_unsupported.cpp
-/src/tests/properties/cpp03/can_require_free.cpp
-/src/tests/properties/cpp03/can_require_member.cpp
-/src/tests/properties/cpp03/can_require_not_applicable_free.cpp
-/src/tests/properties/cpp03/can_require_not_applicable_member.cpp
-/src/tests/properties/cpp03/can_require_not_applicable_static.cpp
-/src/tests/properties/cpp03/can_require_not_applicable_unsupported.cpp
-/src/tests/properties/cpp03/can_require_static.cpp
-/src/tests/properties/cpp03/can_require_unsupported.cpp
-/src/tests/properties/cpp03/prefer_free_prefer.cpp
-/src/tests/properties/cpp03/prefer_free_require.cpp
-/src/tests/properties/cpp03/prefer_member_prefer.cpp
-/src/tests/properties/cpp03/prefer_member_require.cpp
-/src/tests/properties/cpp03/prefer_static.cpp
-/src/tests/properties/cpp03/prefer_unsupported.cpp
-/src/tests/properties/cpp03/query_free.cpp
-/src/tests/properties/cpp03/query_member.cpp
-/src/tests/properties/cpp03/query_static.cpp
-/src/tests/properties/cpp03/require_concept_free.cpp
-/src/tests/properties/cpp03/require_concept_member.cpp
-/src/tests/properties/cpp03/require_concept_static.cpp
-/src/tests/properties/cpp03/require_free.cpp
-/src/tests/properties/cpp03/require_member.cpp
-/src/tests/properties/cpp03/require_static.cpp
-/src/tests/properties/cpp11/
-/src/tests/properties/cpp11/can_prefer_free_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_free_require.cpp
-/src/tests/properties/cpp11/can_prefer_member_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_member_require.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_free_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_free_require.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_member_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_member_require.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_static.cpp
-/src/tests/properties/cpp11/can_prefer_not_applicable_unsupported.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_free_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_free_require.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_member_prefer.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_member_require.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_static.cpp
-/src/tests/properties/cpp11/can_prefer_not_preferable_unsupported.cpp
-/src/tests/properties/cpp11/can_prefer_static.cpp
-/src/tests/properties/cpp11/can_prefer_unsupported.cpp
-/src/tests/properties/cpp11/can_query_free.cpp
-/src/tests/properties/cpp11/can_query_member.cpp
-/src/tests/properties/cpp11/can_query_not_applicable_free.cpp
-/src/tests/properties/cpp11/can_query_not_applicable_member.cpp
-/src/tests/properties/cpp11/can_query_not_applicable_static.cpp
-/src/tests/properties/cpp11/can_query_not_applicable_unsupported.cpp
-/src/tests/properties/cpp11/can_query_static.cpp
-/src/tests/properties/cpp11/can_query_unsupported.cpp
-/src/tests/properties/cpp11/can_require_concept_free.cpp
-/src/tests/properties/cpp11/can_require_concept_member.cpp
-/src/tests/properties/cpp11/can_require_concept_not_applicable_free.cpp
-/src/tests/properties/cpp11/can_require_concept_not_applicable_member.cpp
-/src/tests/properties/cpp11/can_require_concept_not_applicable_static.cpp
-/src/tests/properties/cpp11/can_require_concept_not_applicable_unsupported.cpp
-/src/tests/properties/cpp11/can_require_concept_static.cpp
-/src/tests/properties/cpp11/can_require_concept_unsupported.cpp
-/src/tests/properties/cpp11/can_require_free.cpp
-/src/tests/properties/cpp11/can_require_member.cpp
-/src/tests/properties/cpp11/can_require_not_applicable_free.cpp
-/src/tests/properties/cpp11/can_require_not_applicable_member.cpp
-/src/tests/properties/cpp11/can_require_not_applicable_static.cpp
-/src/tests/properties/cpp11/can_require_not_applicable_unsupported.cpp
-/src/tests/properties/cpp11/can_require_static.cpp
-/src/tests/properties/cpp11/can_require_unsupported.cpp
-/src/tests/properties/cpp11/prefer_free_prefer.cpp
-/src/tests/properties/cpp11/prefer_free_require.cpp
-/src/tests/properties/cpp11/prefer_member_prefer.cpp
-/src/tests/properties/cpp11/prefer_member_require.cpp
-/src/tests/properties/cpp11/prefer_static.cpp
-/src/tests/properties/cpp11/prefer_unsupported.cpp
-/src/tests/properties/cpp11/query_free.cpp
-/src/tests/properties/cpp11/query_member.cpp
-/src/tests/properties/cpp11/query_static.cpp
-/src/tests/properties/cpp11/require_concept_free.cpp
-/src/tests/properties/cpp11/require_concept_member.cpp
-/src/tests/properties/cpp11/require_concept_static.cpp
-/src/tests/properties/cpp11/require_free.cpp
-/src/tests/properties/cpp11/require_member.cpp
-/src/tests/properties/cpp11/require_static.cpp
-/src/tests/properties/cpp14/
-/src/tests/properties/cpp14/can_prefer_free_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_free_require.cpp
-/src/tests/properties/cpp14/can_prefer_member_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_member_require.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_free_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_free_require.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_member_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_member_require.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_static.cpp
-/src/tests/properties/cpp14/can_prefer_not_applicable_unsupported.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_free_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_free_require.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_member_prefer.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_member_require.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_static.cpp
-/src/tests/properties/cpp14/can_prefer_not_preferable_unsupported.cpp
-/src/tests/properties/cpp14/can_prefer_static.cpp
-/src/tests/properties/cpp14/can_prefer_unsupported.cpp
-/src/tests/properties/cpp14/can_query_free.cpp
-/src/tests/properties/cpp14/can_query_member.cpp
-/src/tests/properties/cpp14/can_query_not_applicable_free.cpp
-/src/tests/properties/cpp14/can_query_not_applicable_member.cpp
-/src/tests/properties/cpp14/can_query_not_applicable_static.cpp
-/src/tests/properties/cpp14/can_query_not_applicable_unsupported.cpp
-/src/tests/properties/cpp14/can_query_static.cpp
-/src/tests/properties/cpp14/can_query_unsupported.cpp
-/src/tests/properties/cpp14/can_require_concept_free.cpp
-/src/tests/properties/cpp14/can_require_concept_member.cpp
-/src/tests/properties/cpp14/can_require_concept_not_applicable_free.cpp
-/src/tests/properties/cpp14/can_require_concept_not_applicable_member.cpp
-/src/tests/properties/cpp14/can_require_concept_not_applicable_static.cpp
-/src/tests/properties/cpp14/can_require_concept_not_applicable_unsupported.cpp
-/src/tests/properties/cpp14/can_require_concept_static.cpp
-/src/tests/properties/cpp14/can_require_concept_unsupported.cpp
-/src/tests/properties/cpp14/can_require_free.cpp
-/src/tests/properties/cpp14/can_require_member.cpp
-/src/tests/properties/cpp14/can_require_not_applicable_free.cpp
-/src/tests/properties/cpp14/can_require_not_applicable_member.cpp
-/src/tests/properties/cpp14/can_require_not_applicable_static.cpp
-/src/tests/properties/cpp14/can_require_not_applicable_unsupported.cpp
-/src/tests/properties/cpp14/can_require_static.cpp
-/src/tests/properties/cpp14/can_require_unsupported.cpp
-/src/tests/properties/cpp14/prefer_free_prefer.cpp
-/src/tests/properties/cpp14/prefer_free_require.cpp
-/src/tests/properties/cpp14/prefer_member_prefer.cpp
-/src/tests/properties/cpp14/prefer_member_require.cpp
-/src/tests/properties/cpp14/prefer_static.cpp
-/src/tests/properties/cpp14/prefer_unsupported.cpp
-/src/tests/properties/cpp14/query_free.cpp
-/src/tests/properties/cpp14/query_member.cpp
-/src/tests/properties/cpp14/query_static.cpp
-/src/tests/properties/cpp14/require_concept_free.cpp
-/src/tests/properties/cpp14/require_concept_member.cpp
-/src/tests/properties/cpp14/require_concept_static.cpp
-/src/tests/properties/cpp14/require_free.cpp
-/src/tests/properties/cpp14/require_member.cpp
-/src/tests/properties/cpp14/require_static.cpp
-/src/tests/properties/Makefile.am
-/src/tests/properties/Makefile.in
-/src/tests/unit/
-/src/tests/unit/any_completion_executor.cpp
-/src/tests/unit/any_completion_handler.cpp
-/src/tests/unit/any_io_executor.cpp
-/src/tests/unit/append.cpp
-/src/tests/unit/archetypes/
-/src/tests/unit/archetypes/async_ops.hpp
-/src/tests/unit/archetypes/async_result.hpp
-/src/tests/unit/archetypes/gettable_socket_option.hpp
-/src/tests/unit/archetypes/io_control_command.hpp
-/src/tests/unit/archetypes/settable_socket_option.hpp
-/src/tests/unit/associated_allocator.cpp
-/src/tests/unit/associated_cancellation_slot.cpp
-/src/tests/unit/associated_executor.cpp
-/src/tests/unit/associated_immediate_executor.cpp
-/src/tests/unit/associator.cpp
-/src/tests/unit/as_tuple.cpp
-/src/tests/unit/async_result.cpp
-/src/tests/unit/awaitable.cpp
-/src/tests/unit/basic_datagram_socket.cpp
-/src/tests/unit/basic_deadline_timer.cpp
-/src/tests/unit/basic_file.cpp
-/src/tests/unit/basic_random_access_file.cpp
-/src/tests/unit/basic_raw_socket.cpp
-/src/tests/unit/basic_readable_pipe.cpp
-/src/tests/unit/basic_seq_packet_socket.cpp
-/src/tests/unit/basic_serial_port.cpp
-/src/tests/unit/basic_signal_set.cpp
-/src/tests/unit/basic_socket_acceptor.cpp
-/src/tests/unit/basic_socket.cpp
-/src/tests/unit/basic_streambuf.cpp
-/src/tests/unit/basic_stream_file.cpp
-/src/tests/unit/basic_stream_socket.cpp
-/src/tests/unit/basic_waitable_timer.cpp
-/src/tests/unit/basic_writable_pipe.cpp
-/src/tests/unit/bind_allocator.cpp
-/src/tests/unit/bind_cancellation_slot.cpp
-/src/tests/unit/bind_executor.cpp
-/src/tests/unit/bind_immediate_executor.cpp
-/src/tests/unit/buffer.cpp
-/src/tests/unit/buffered_read_stream.cpp
-/src/tests/unit/buffered_stream.cpp
-/src/tests/unit/buffered_write_stream.cpp
-/src/tests/unit/buffer_registration.cpp
-/src/tests/unit/buffers_iterator.cpp
-/src/tests/unit/cancel_after.cpp
-/src/tests/unit/cancel_at.cpp
-/src/tests/unit/cancellation_signal.cpp
-/src/tests/unit/cancellation_state.cpp
-/src/tests/unit/cancellation_type.cpp
-/src/tests/unit/co_composed.cpp
-/src/tests/unit/completion_condition.cpp
-/src/tests/unit/compose.cpp
-/src/tests/unit/composed.cpp
-/src/tests/unit/connect.cpp
-/src/tests/unit/connect_pipe.cpp
-/src/tests/unit/consign.cpp
-/src/tests/unit/coroutine.cpp
-/src/tests/unit/co_spawn.cpp
-/src/tests/unit/deadline_timer.cpp
-/src/tests/unit/defer.cpp
-/src/tests/unit/deferred.cpp
-/src/tests/unit/detached.cpp
-/src/tests/unit/dispatch.cpp
-/src/tests/unit/error.cpp
-/src/tests/unit/execution/
-/src/tests/unit/execution/any_executor.cpp
-/src/tests/unit/execution/blocking_adaptation.cpp
-/src/tests/unit/execution/blocking.cpp
-/src/tests/unit/execution/context_as.cpp
-/src/tests/unit/execution_context.cpp
-/src/tests/unit/execution/executor.cpp
-/src/tests/unit/execution/invocable_archetype.cpp
-/src/tests/unit/execution/mapping.cpp
-/src/tests/unit/execution/outstanding_work.cpp
-/src/tests/unit/execution/prefer_only.cpp
-/src/tests/unit/execution/relationship.cpp
-/src/tests/unit/executor.cpp
-/src/tests/unit/executor_work_guard.cpp
-/src/tests/unit/experimental/
-/src/tests/unit/experimental/awaitable_operators.cpp
-/src/tests/unit/experimental/basic_channel.cpp
-/src/tests/unit/experimental/basic_concurrent_channel.cpp
-/src/tests/unit/experimental/channel.cpp
-/src/tests/unit/experimental/channel_traits.cpp
-/src/tests/unit/experimental/co_composed.cpp
-/src/tests/unit/experimental/concurrent_channel.cpp
-/src/tests/unit/experimental/coro/
-/src/tests/unit/experimental/coro/allocator.cpp
-/src/tests/unit/experimental/coro/cancel.cpp
-/src/tests/unit/experimental/coro/co_spawn.cpp
-/src/tests/unit/experimental/coro/exception.cpp
-/src/tests/unit/experimental/coro/executor.cpp
-/src/tests/unit/experimental/coro/partial.cpp
-/src/tests/unit/experimental/coro/simple_test.cpp
-/src/tests/unit/experimental/coro/stack_test.cpp
-/src/tests/unit/experimental/coro/use_coro.cpp
-/src/tests/unit/experimental/parallel_group.cpp
-/src/tests/unit/experimental/promise.cpp
-/src/tests/unit/file_base.cpp
-/src/tests/unit/generic/
-/src/tests/unit/generic/basic_endpoint.cpp
-/src/tests/unit/generic/datagram_protocol.cpp
-/src/tests/unit/generic/raw_protocol.cpp
-/src/tests/unit/generic/seq_packet_protocol.cpp
-/src/tests/unit/generic/stream_protocol.cpp
-/src/tests/unit/high_resolution_timer.cpp
-/src/tests/unit/immediate.cpp
-/src/tests/unit/io_context.cpp
-/src/tests/unit/io_context_strand.cpp
-/src/tests/unit/ip/
-/src/tests/unit/ip/address.cpp
-/src/tests/unit/ip/address_v4.cpp
-/src/tests/unit/ip/address_v4_iterator.cpp
-/src/tests/unit/ip/address_v4_range.cpp
-/src/tests/unit/ip/address_v6.cpp
-/src/tests/unit/ip/address_v6_iterator.cpp
-/src/tests/unit/ip/address_v6_range.cpp
-/src/tests/unit/ip/basic_endpoint.cpp
-/src/tests/unit/ip/basic_resolver.cpp
-/src/tests/unit/ip/basic_resolver_entry.cpp
-/src/tests/unit/ip/basic_resolver_iterator.cpp
-/src/tests/unit/ip/basic_resolver_query.cpp
-/src/tests/unit/ip/host_name.cpp
-/src/tests/unit/ip/icmp.cpp
-/src/tests/unit/ip/multicast.cpp
-/src/tests/unit/ip/network_v4.cpp
-/src/tests/unit/ip/network_v6.cpp
-/src/tests/unit/ip/resolver_query_base.cpp
-/src/tests/unit/ip/tcp.cpp
-/src/tests/unit/ip/udp.cpp
-/src/tests/unit/ip/unicast.cpp
-/src/tests/unit/ip/v6_only.cpp
-/src/tests/unit/is_read_buffered.cpp
-/src/tests/unit/is_write_buffered.cpp
-/src/tests/unit/local/
-/src/tests/unit/local/basic_endpoint.cpp
-/src/tests/unit/local/connect_pair.cpp
-/src/tests/unit/local/datagram_protocol.cpp
-/src/tests/unit/local/seq_packet_protocol.cpp
-/src/tests/unit/local/stream_protocol.cpp
-/src/tests/unit/packaged_task.cpp
-/src/tests/unit/placeholders.cpp
-/src/tests/unit/posix/
-/src/tests/unit/posix/basic_descriptor.cpp
-/src/tests/unit/posix/basic_stream_descriptor.cpp
-/src/tests/unit/posix/descriptor_base.cpp
-/src/tests/unit/posix/descriptor.cpp
-/src/tests/unit/posix/stream_descriptor.cpp
-/src/tests/unit/post.cpp
-/src/tests/unit/prepend.cpp
-/src/tests/unit/random_access_file.cpp
-/src/tests/unit/readable_pipe.cpp
-/src/tests/unit/read_at.cpp
-/src/tests/unit/read.cpp
-/src/tests/unit/read_until.cpp
-/src/tests/unit/recycling_allocator.cpp
-/src/tests/unit/redirect_error.cpp
-/src/tests/unit/registered_buffer.cpp
-/src/tests/unit/serial_port_base.cpp
-/src/tests/unit/serial_port.cpp
-/src/tests/unit/signal_set_base.cpp
-/src/tests/unit/signal_set.cpp
-/src/tests/unit/socket_base.cpp
-/src/tests/unit/ssl/
-/src/tests/unit/ssl/context_base.cpp
-/src/tests/unit/ssl/context.cpp
-/src/tests/unit/ssl/error.cpp
-/src/tests/unit/ssl/host_name_verification.cpp
-/src/tests/unit/ssl/rfc2818_verification.cpp
-/src/tests/unit/ssl/stream_base.cpp
-/src/tests/unit/ssl/stream.cpp
-/src/tests/unit/static_thread_pool.cpp
-/src/tests/unit/steady_timer.cpp
-/src/tests/unit/strand.cpp
-/src/tests/unit/streambuf.cpp
-/src/tests/unit/stream_file.cpp
-/src/tests/unit/system_context.cpp
-/src/tests/unit/system_executor.cpp
-/src/tests/unit/system_timer.cpp
-/src/tests/unit/this_coro.cpp
-/src/tests/unit/thread.cpp
-/src/tests/unit/thread_pool.cpp
-/src/tests/unit/time_traits.cpp
-/src/tests/unit/ts/
-/src/tests/unit/ts/buffer.cpp
-/src/tests/unit/ts/executor.cpp
-/src/tests/unit/ts/internet.cpp
-/src/tests/unit/ts/io_context.cpp
-/src/tests/unit/ts/net.cpp
-/src/tests/unit/ts/netfwd.cpp
-/src/tests/unit/ts/socket.cpp
-/src/tests/unit/ts/timer.cpp
-/src/tests/unit/unit_test.hpp
-/src/tests/unit/use_awaitable.cpp
-/src/tests/unit/use_future.cpp
-/src/tests/unit/uses_executor.cpp
-/src/tests/unit/wait_traits.cpp
-/src/tests/unit/windows/
-/src/tests/unit/windows/basic_object_handle.cpp
-/src/tests/unit/windows/basic_overlapped_handle.cpp
-/src/tests/unit/windows/basic_random_access_handle.cpp
-/src/tests/unit/windows/basic_stream_handle.cpp
-/src/tests/unit/windows/object_handle.cpp
-/src/tests/unit/windows/overlapped_handle.cpp
-/src/tests/unit/windows/overlapped_ptr.cpp
-/src/tests/unit/windows/random_access_handle.cpp
-/src/tests/unit/windows/stream_handle.cpp
-/src/tests/unit/writable_pipe.cpp
-/src/tests/unit/write_at.cpp
-/src/tests/unit/write.cpp
-/src/tools/
-/src/tools/handlerlive.pl
-/src/tools/handlertree.pl
-/src/tools/handlerviz.pl
-/test-driver
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/asio.pc.in b/third_party/socket.io-client-cpp/lib/asio/asio/asio.pc.in
deleted file mode 100644
index b93eb67..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/asio.pc.in
+++ /dev/null
@@ -1,11 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-includedir=@includedir@
-
-Name: @PACKAGE_NAME@
-Description: A cross-platform C++ library for network and low-level I/O programming that provides developers with a consistent asynchronous model using a modern C++ approach.
-Version: @PACKAGE_VERSION@
-Cflags: -I${includedir}
-Lflags:
-Requires:
-Requires.private:
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/autogen.sh b/third_party/socket.io-client-cpp/lib/asio/asio/autogen.sh
deleted file mode 100755
index 42075e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/autogen.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/bin/sh
-
-# Helps bootstrapping the application when checked out from CVS.
-# Requires GNU autoconf, GNU automake and GNU which.
-#
-# Copyright (C) 2004, by
-#
-# Carlo Wood, Run on IRC <carlo@alinoe.com>
-# RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
-# Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
-#
-
-# Do sanity checks.
-# Directory check.
-if [ ! -f autogen.sh ]; then
-  echo "Run ./autogen.sh from the directory it exists in."
-  exit 1
-fi
-
-AUTOMAKE=${AUTOMAKE:-automake}
-ACLOCAL=${ACLOCAL:-aclocal}
-AUTOCONF=${AUTOCONF:-autoconf}
-
-($AUTOCONF --version) >/dev/null 2>/dev/null || (echo "You need GNU autoconf to install from CVS (ftp://ftp.gnu.org/gnu/autoconf/)"; exit 1) || exit 1
-($AUTOMAKE --version) >/dev/null 2>/dev/null || (echo "You need GNU automake 1.7 or higher to install from CVS (ftp://ftp.gnu.org/gnu/automake/)"; exit 1) || exit 1
-
-# Determine the version of automake.
-automake_version=`$AUTOMAKE --version | head -n 1 | sed -e 's/[^12]*\([12]\.[0-9][^ ]*\).*/\1/'`
-automake_major=`echo $automake_version | cut -f1 -d.`
-automake_minor=`echo $automake_version | cut -f2 -d.`
-automake_version_number=`expr "$automake_major" \* 1000 \+ "$automake_minor"`
-
-# Require automake 1.7.
-if expr "1007" \> "$automake_version_number" >/dev/null; then
-  $AUTOMAKE --version | head -n 1
-  echo ""
-  echo "Fatal error: automake 1.7 or higher is required.  Please set \$AUTOMAKE"
-  echo "to point to a newer automake, or upgrade."
-  echo ""
-  exit 1
-fi
-
-run()
-{
-  echo "Running $1 ..."
-  $1
-}
-
-# This is needed when someone just upgraded automake and this cache is still generated by an old version.
-rm -rf autom4te.cache config.cache
-
-run "$ACLOCAL"
-run "$AUTOCONF"
-run "$AUTOMAKE --add-missing --foreign"
-
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/boost_asio.manifest b/third_party/socket.io-client-cpp/lib/asio/asio/boost_asio.manifest
deleted file mode 100644
index 3c9bdf9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/boost_asio.manifest
+++ /dev/null
@@ -1,7761 +0,0 @@
-/
-/boost/
-/boost/asio/
-/boost/asio/any_completion_executor.hpp
-/boost/asio/any_completion_handler.hpp
-/boost/asio/any_io_executor.hpp
-/boost/asio/append.hpp
-/boost/asio/associated_allocator.hpp
-/boost/asio/associated_cancellation_slot.hpp
-/boost/asio/associated_executor.hpp
-/boost/asio/associated_immediate_executor.hpp
-/boost/asio/associator.hpp
-/boost/asio/as_tuple.hpp
-/boost/asio/async_result.hpp
-/boost/asio/awaitable.hpp
-/boost/asio/basic_datagram_socket.hpp
-/boost/asio/basic_deadline_timer.hpp
-/boost/asio/basic_file.hpp
-/boost/asio/basic_io_object.hpp
-/boost/asio/basic_random_access_file.hpp
-/boost/asio/basic_raw_socket.hpp
-/boost/asio/basic_readable_pipe.hpp
-/boost/asio/basic_seq_packet_socket.hpp
-/boost/asio/basic_serial_port.hpp
-/boost/asio/basic_signal_set.hpp
-/boost/asio/basic_socket_acceptor.hpp
-/boost/asio/basic_socket.hpp
-/boost/asio/basic_socket_iostream.hpp
-/boost/asio/basic_socket_streambuf.hpp
-/boost/asio/basic_streambuf_fwd.hpp
-/boost/asio/basic_streambuf.hpp
-/boost/asio/basic_stream_file.hpp
-/boost/asio/basic_stream_socket.hpp
-/boost/asio/basic_waitable_timer.hpp
-/boost/asio/basic_writable_pipe.hpp
-/boost/asio/bind_allocator.hpp
-/boost/asio/bind_cancellation_slot.hpp
-/boost/asio/bind_executor.hpp
-/boost/asio/bind_immediate_executor.hpp
-/boost/asio/buffered_read_stream_fwd.hpp
-/boost/asio/buffered_read_stream.hpp
-/boost/asio/buffered_stream_fwd.hpp
-/boost/asio/buffered_stream.hpp
-/boost/asio/buffered_write_stream_fwd.hpp
-/boost/asio/buffered_write_stream.hpp
-/boost/asio/buffer.hpp
-/boost/asio/buffer_registration.hpp
-/boost/asio/buffers_iterator.hpp
-/boost/asio/cancel_after.hpp
-/boost/asio/cancel_at.hpp
-/boost/asio/cancellation_signal.hpp
-/boost/asio/cancellation_state.hpp
-/boost/asio/cancellation_type.hpp
-/boost/asio/co_composed.hpp
-/boost/asio/completion_condition.hpp
-/boost/asio/composed.hpp
-/boost/asio/compose.hpp
-/boost/asio/connect.hpp
-/boost/asio/connect_pipe.hpp
-/boost/asio/consign.hpp
-/boost/asio/coroutine.hpp
-/boost/asio/co_spawn.hpp
-/boost/asio/deadline_timer.hpp
-/boost/asio/default_completion_token.hpp
-/boost/asio/defer.hpp
-/boost/asio/deferred.hpp
-/boost/asio/detached.hpp
-/boost/asio/detail/
-/boost/asio/detail/array_fwd.hpp
-/boost/asio/detail/array.hpp
-/boost/asio/detail/assert.hpp
-/boost/asio/detail/atomic_count.hpp
-/boost/asio/detail/base_from_cancellation_state.hpp
-/boost/asio/detail/base_from_completion_cond.hpp
-/boost/asio/detail/bind_handler.hpp
-/boost/asio/detail/blocking_executor_op.hpp
-/boost/asio/detail/buffered_stream_storage.hpp
-/boost/asio/detail/buffer_resize_guard.hpp
-/boost/asio/detail/buffer_sequence_adapter.hpp
-/boost/asio/detail/call_stack.hpp
-/boost/asio/detail/chrono.hpp
-/boost/asio/detail/chrono_time_traits.hpp
-/boost/asio/detail/completion_handler.hpp
-/boost/asio/detail/completion_message.hpp
-/boost/asio/detail/completion_payload_handler.hpp
-/boost/asio/detail/completion_payload.hpp
-/boost/asio/detail/composed_work.hpp
-/boost/asio/detail/concurrency_hint.hpp
-/boost/asio/detail/conditionally_enabled_event.hpp
-/boost/asio/detail/conditionally_enabled_mutex.hpp
-/boost/asio/detail/config.hpp
-/boost/asio/detail/consuming_buffers.hpp
-/boost/asio/detail/cstddef.hpp
-/boost/asio/detail/cstdint.hpp
-/boost/asio/detail/date_time_fwd.hpp
-/boost/asio/detail/deadline_timer_service.hpp
-/boost/asio/detail/dependent_type.hpp
-/boost/asio/detail/descriptor_ops.hpp
-/boost/asio/detail/descriptor_read_op.hpp
-/boost/asio/detail/descriptor_write_op.hpp
-/boost/asio/detail/dev_poll_reactor.hpp
-/boost/asio/detail/epoll_reactor.hpp
-/boost/asio/detail/eventfd_select_interrupter.hpp
-/boost/asio/detail/event.hpp
-/boost/asio/detail/exception.hpp
-/boost/asio/detail/executor_function.hpp
-/boost/asio/detail/executor_op.hpp
-/boost/asio/detail/fd_set_adapter.hpp
-/boost/asio/detail/fenced_block.hpp
-/boost/asio/detail/functional.hpp
-/boost/asio/detail/future.hpp
-/boost/asio/detail/global.hpp
-/boost/asio/detail/handler_alloc_helpers.hpp
-/boost/asio/detail/handler_cont_helpers.hpp
-/boost/asio/detail/handler_tracking.hpp
-/boost/asio/detail/handler_type_requirements.hpp
-/boost/asio/detail/handler_work.hpp
-/boost/asio/detail/hash_map.hpp
-/boost/asio/detail/impl/
-/boost/asio/detail/impl/buffer_sequence_adapter.ipp
-/boost/asio/detail/impl/descriptor_ops.ipp
-/boost/asio/detail/impl/dev_poll_reactor.hpp
-/boost/asio/detail/impl/dev_poll_reactor.ipp
-/boost/asio/detail/impl/epoll_reactor.hpp
-/boost/asio/detail/impl/epoll_reactor.ipp
-/boost/asio/detail/impl/eventfd_select_interrupter.ipp
-/boost/asio/detail/impl/handler_tracking.ipp
-/boost/asio/detail/impl/io_uring_descriptor_service.ipp
-/boost/asio/detail/impl/io_uring_file_service.ipp
-/boost/asio/detail/impl/io_uring_service.hpp
-/boost/asio/detail/impl/io_uring_service.ipp
-/boost/asio/detail/impl/io_uring_socket_service_base.ipp
-/boost/asio/detail/impl/kqueue_reactor.hpp
-/boost/asio/detail/impl/kqueue_reactor.ipp
-/boost/asio/detail/impl/null_event.ipp
-/boost/asio/detail/impl/pipe_select_interrupter.ipp
-/boost/asio/detail/impl/posix_event.ipp
-/boost/asio/detail/impl/posix_mutex.ipp
-/boost/asio/detail/impl/posix_serial_port_service.ipp
-/boost/asio/detail/impl/posix_thread.ipp
-/boost/asio/detail/impl/posix_tss_ptr.ipp
-/boost/asio/detail/impl/reactive_descriptor_service.ipp
-/boost/asio/detail/impl/reactive_socket_service_base.ipp
-/boost/asio/detail/impl/resolver_service_base.ipp
-/boost/asio/detail/impl/scheduler.ipp
-/boost/asio/detail/impl/select_reactor.hpp
-/boost/asio/detail/impl/select_reactor.ipp
-/boost/asio/detail/impl/service_registry.hpp
-/boost/asio/detail/impl/service_registry.ipp
-/boost/asio/detail/impl/signal_set_service.ipp
-/boost/asio/detail/impl/socket_ops.ipp
-/boost/asio/detail/impl/socket_select_interrupter.ipp
-/boost/asio/detail/impl/strand_executor_service.hpp
-/boost/asio/detail/impl/strand_executor_service.ipp
-/boost/asio/detail/impl/strand_service.hpp
-/boost/asio/detail/impl/strand_service.ipp
-/boost/asio/detail/impl/thread_context.ipp
-/boost/asio/detail/impl/throw_error.ipp
-/boost/asio/detail/impl/timer_queue_ptime.ipp
-/boost/asio/detail/impl/timer_queue_set.ipp
-/boost/asio/detail/impl/win_event.ipp
-/boost/asio/detail/impl/win_iocp_file_service.ipp
-/boost/asio/detail/impl/win_iocp_handle_service.ipp
-/boost/asio/detail/impl/win_iocp_io_context.hpp
-/boost/asio/detail/impl/win_iocp_io_context.ipp
-/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
-/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
-/boost/asio/detail/impl/win_mutex.ipp
-/boost/asio/detail/impl/win_object_handle_service.ipp
-/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
-/boost/asio/detail/impl/winrt_timer_scheduler.hpp
-/boost/asio/detail/impl/winrt_timer_scheduler.ipp
-/boost/asio/detail/impl/winsock_init.ipp
-/boost/asio/detail/impl/win_static_mutex.ipp
-/boost/asio/detail/impl/win_thread.ipp
-/boost/asio/detail/impl/win_tss_ptr.ipp
-/boost/asio/detail/initiate_defer.hpp
-/boost/asio/detail/initiate_dispatch.hpp
-/boost/asio/detail/initiate_post.hpp
-/boost/asio/detail/initiation_base.hpp
-/boost/asio/detail/io_control.hpp
-/boost/asio/detail/io_object_impl.hpp
-/boost/asio/detail/io_uring_descriptor_read_at_op.hpp
-/boost/asio/detail/io_uring_descriptor_read_op.hpp
-/boost/asio/detail/io_uring_descriptor_service.hpp
-/boost/asio/detail/io_uring_descriptor_write_at_op.hpp
-/boost/asio/detail/io_uring_descriptor_write_op.hpp
-/boost/asio/detail/io_uring_file_service.hpp
-/boost/asio/detail/io_uring_null_buffers_op.hpp
-/boost/asio/detail/io_uring_operation.hpp
-/boost/asio/detail/io_uring_service.hpp
-/boost/asio/detail/io_uring_socket_accept_op.hpp
-/boost/asio/detail/io_uring_socket_connect_op.hpp
-/boost/asio/detail/io_uring_socket_recvfrom_op.hpp
-/boost/asio/detail/io_uring_socket_recvmsg_op.hpp
-/boost/asio/detail/io_uring_socket_recv_op.hpp
-/boost/asio/detail/io_uring_socket_send_op.hpp
-/boost/asio/detail/io_uring_socket_sendto_op.hpp
-/boost/asio/detail/io_uring_socket_service_base.hpp
-/boost/asio/detail/io_uring_socket_service.hpp
-/boost/asio/detail/io_uring_wait_op.hpp
-/boost/asio/detail/is_buffer_sequence.hpp
-/boost/asio/detail/is_executor.hpp
-/boost/asio/detail/keyword_tss_ptr.hpp
-/boost/asio/detail/kqueue_reactor.hpp
-/boost/asio/detail/limits.hpp
-/boost/asio/detail/local_free_on_block_exit.hpp
-/boost/asio/detail/memory.hpp
-/boost/asio/detail/mutex.hpp
-/boost/asio/detail/non_const_lvalue.hpp
-/boost/asio/detail/noncopyable.hpp
-/boost/asio/detail/null_event.hpp
-/boost/asio/detail/null_fenced_block.hpp
-/boost/asio/detail/null_global.hpp
-/boost/asio/detail/null_mutex.hpp
-/boost/asio/detail/null_reactor.hpp
-/boost/asio/detail/null_signal_blocker.hpp
-/boost/asio/detail/null_socket_service.hpp
-/boost/asio/detail/null_static_mutex.hpp
-/boost/asio/detail/null_thread.hpp
-/boost/asio/detail/null_tss_ptr.hpp
-/boost/asio/detail/object_pool.hpp
-/boost/asio/detail/old_win_sdk_compat.hpp
-/boost/asio/detail/operation.hpp
-/boost/asio/detail/op_queue.hpp
-/boost/asio/detail/pipe_select_interrupter.hpp
-/boost/asio/detail/pop_options.hpp
-/boost/asio/detail/posix_event.hpp
-/boost/asio/detail/posix_fd_set_adapter.hpp
-/boost/asio/detail/posix_global.hpp
-/boost/asio/detail/posix_mutex.hpp
-/boost/asio/detail/posix_serial_port_service.hpp
-/boost/asio/detail/posix_signal_blocker.hpp
-/boost/asio/detail/posix_static_mutex.hpp
-/boost/asio/detail/posix_thread.hpp
-/boost/asio/detail/posix_tss_ptr.hpp
-/boost/asio/detail/push_options.hpp
-/boost/asio/detail/reactive_descriptor_service.hpp
-/boost/asio/detail/reactive_null_buffers_op.hpp
-/boost/asio/detail/reactive_socket_accept_op.hpp
-/boost/asio/detail/reactive_socket_connect_op.hpp
-/boost/asio/detail/reactive_socket_recvfrom_op.hpp
-/boost/asio/detail/reactive_socket_recvmsg_op.hpp
-/boost/asio/detail/reactive_socket_recv_op.hpp
-/boost/asio/detail/reactive_socket_send_op.hpp
-/boost/asio/detail/reactive_socket_sendto_op.hpp
-/boost/asio/detail/reactive_socket_service_base.hpp
-/boost/asio/detail/reactive_socket_service.hpp
-/boost/asio/detail/reactive_wait_op.hpp
-/boost/asio/detail/reactor.hpp
-/boost/asio/detail/reactor_op.hpp
-/boost/asio/detail/reactor_op_queue.hpp
-/boost/asio/detail/recycling_allocator.hpp
-/boost/asio/detail/regex_fwd.hpp
-/boost/asio/detail/resolve_endpoint_op.hpp
-/boost/asio/detail/resolve_op.hpp
-/boost/asio/detail/resolve_query_op.hpp
-/boost/asio/detail/resolver_service_base.hpp
-/boost/asio/detail/resolver_service.hpp
-/boost/asio/detail/scheduler.hpp
-/boost/asio/detail/scheduler_operation.hpp
-/boost/asio/detail/scheduler_task.hpp
-/boost/asio/detail/scheduler_thread_info.hpp
-/boost/asio/detail/scoped_lock.hpp
-/boost/asio/detail/scoped_ptr.hpp
-/boost/asio/detail/select_interrupter.hpp
-/boost/asio/detail/select_reactor.hpp
-/boost/asio/detail/service_registry.hpp
-/boost/asio/detail/signal_blocker.hpp
-/boost/asio/detail/signal_handler.hpp
-/boost/asio/detail/signal_init.hpp
-/boost/asio/detail/signal_op.hpp
-/boost/asio/detail/signal_set_service.hpp
-/boost/asio/detail/socket_holder.hpp
-/boost/asio/detail/socket_ops.hpp
-/boost/asio/detail/socket_option.hpp
-/boost/asio/detail/socket_select_interrupter.hpp
-/boost/asio/detail/socket_types.hpp
-/boost/asio/detail/source_location.hpp
-/boost/asio/detail/static_mutex.hpp
-/boost/asio/detail/std_event.hpp
-/boost/asio/detail/std_fenced_block.hpp
-/boost/asio/detail/std_global.hpp
-/boost/asio/detail/std_mutex.hpp
-/boost/asio/detail/std_static_mutex.hpp
-/boost/asio/detail/std_thread.hpp
-/boost/asio/detail/strand_executor_service.hpp
-/boost/asio/detail/strand_service.hpp
-/boost/asio/detail/string_view.hpp
-/boost/asio/detail/thread_context.hpp
-/boost/asio/detail/thread_group.hpp
-/boost/asio/detail/thread.hpp
-/boost/asio/detail/thread_info_base.hpp
-/boost/asio/detail/throw_error.hpp
-/boost/asio/detail/throw_exception.hpp
-/boost/asio/detail/timed_cancel_op.hpp
-/boost/asio/detail/timer_queue_base.hpp
-/boost/asio/detail/timer_queue.hpp
-/boost/asio/detail/timer_queue_ptime.hpp
-/boost/asio/detail/timer_queue_set.hpp
-/boost/asio/detail/timer_scheduler_fwd.hpp
-/boost/asio/detail/timer_scheduler.hpp
-/boost/asio/detail/tss_ptr.hpp
-/boost/asio/detail/type_traits.hpp
-/boost/asio/detail/utility.hpp
-/boost/asio/detail/wait_handler.hpp
-/boost/asio/detail/wait_op.hpp
-/boost/asio/detail/winapp_thread.hpp
-/boost/asio/detail/wince_thread.hpp
-/boost/asio/detail/win_event.hpp
-/boost/asio/detail/win_fd_set_adapter.hpp
-/boost/asio/detail/win_global.hpp
-/boost/asio/detail/win_iocp_file_service.hpp
-/boost/asio/detail/win_iocp_handle_read_op.hpp
-/boost/asio/detail/win_iocp_handle_service.hpp
-/boost/asio/detail/win_iocp_handle_write_op.hpp
-/boost/asio/detail/win_iocp_io_context.hpp
-/boost/asio/detail/win_iocp_null_buffers_op.hpp
-/boost/asio/detail/win_iocp_operation.hpp
-/boost/asio/detail/win_iocp_overlapped_op.hpp
-/boost/asio/detail/win_iocp_overlapped_ptr.hpp
-/boost/asio/detail/win_iocp_serial_port_service.hpp
-/boost/asio/detail/win_iocp_socket_accept_op.hpp
-/boost/asio/detail/win_iocp_socket_connect_op.hpp
-/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
-/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
-/boost/asio/detail/win_iocp_socket_recv_op.hpp
-/boost/asio/detail/win_iocp_socket_send_op.hpp
-/boost/asio/detail/win_iocp_socket_service_base.hpp
-/boost/asio/detail/win_iocp_socket_service.hpp
-/boost/asio/detail/win_iocp_thread_info.hpp
-/boost/asio/detail/win_iocp_wait_op.hpp
-/boost/asio/detail/win_mutex.hpp
-/boost/asio/detail/win_object_handle_service.hpp
-/boost/asio/detail/winrt_async_manager.hpp
-/boost/asio/detail/winrt_async_op.hpp
-/boost/asio/detail/winrt_resolve_op.hpp
-/boost/asio/detail/winrt_resolver_service.hpp
-/boost/asio/detail/winrt_socket_connect_op.hpp
-/boost/asio/detail/winrt_socket_recv_op.hpp
-/boost/asio/detail/winrt_socket_send_op.hpp
-/boost/asio/detail/winrt_ssocket_service_base.hpp
-/boost/asio/detail/winrt_ssocket_service.hpp
-/boost/asio/detail/winrt_timer_scheduler.hpp
-/boost/asio/detail/winrt_utils.hpp
-/boost/asio/detail/winsock_init.hpp
-/boost/asio/detail/win_static_mutex.hpp
-/boost/asio/detail/win_thread.hpp
-/boost/asio/detail/win_tss_ptr.hpp
-/boost/asio/detail/work_dispatcher.hpp
-/boost/asio/detail/wrapped_handler.hpp
-/boost/asio/dispatch.hpp
-/boost/asio/error.hpp
-/boost/asio/execution/
-/boost/asio/execution/allocator.hpp
-/boost/asio/execution/any_executor.hpp
-/boost/asio/execution/bad_executor.hpp
-/boost/asio/execution/blocking_adaptation.hpp
-/boost/asio/execution/blocking.hpp
-/boost/asio/execution/context_as.hpp
-/boost/asio/execution/context.hpp
-/boost/asio/execution_context.hpp
-/boost/asio/execution/executor.hpp
-/boost/asio/execution.hpp
-/boost/asio/execution/impl/
-/boost/asio/execution/impl/bad_executor.ipp
-/boost/asio/execution/invocable_archetype.hpp
-/boost/asio/execution/mapping.hpp
-/boost/asio/execution/occupancy.hpp
-/boost/asio/execution/outstanding_work.hpp
-/boost/asio/execution/prefer_only.hpp
-/boost/asio/execution/relationship.hpp
-/boost/asio/executor.hpp
-/boost/asio/executor_work_guard.hpp
-/boost/asio/experimental/
-/boost/asio/experimental/append.hpp
-/boost/asio/experimental/as_single.hpp
-/boost/asio/experimental/as_tuple.hpp
-/boost/asio/experimental/awaitable_operators.hpp
-/boost/asio/experimental/basic_channel.hpp
-/boost/asio/experimental/basic_concurrent_channel.hpp
-/boost/asio/experimental/cancellation_condition.hpp
-/boost/asio/experimental/channel_error.hpp
-/boost/asio/experimental/channel.hpp
-/boost/asio/experimental/channel_traits.hpp
-/boost/asio/experimental/co_composed.hpp
-/boost/asio/experimental/concurrent_channel.hpp
-/boost/asio/experimental/coro.hpp
-/boost/asio/experimental/coro_traits.hpp
-/boost/asio/experimental/co_spawn.hpp
-/boost/asio/experimental/deferred.hpp
-/boost/asio/experimental/detail/
-/boost/asio/experimental/detail/channel_operation.hpp
-/boost/asio/experimental/detail/channel_receive_op.hpp
-/boost/asio/experimental/detail/channel_send_functions.hpp
-/boost/asio/experimental/detail/channel_send_op.hpp
-/boost/asio/experimental/detail/channel_service.hpp
-/boost/asio/experimental/detail/coro_completion_handler.hpp
-/boost/asio/experimental/detail/coro_promise_allocator.hpp
-/boost/asio/experimental/detail/has_signature.hpp
-/boost/asio/experimental/detail/impl/
-/boost/asio/experimental/detail/impl/channel_service.hpp
-/boost/asio/experimental/detail/partial_promise.hpp
-/boost/asio/experimental/impl/
-/boost/asio/experimental/impl/as_single.hpp
-/boost/asio/experimental/impl/channel_error.ipp
-/boost/asio/experimental/impl/coro.hpp
-/boost/asio/experimental/impl/parallel_group.hpp
-/boost/asio/experimental/impl/promise.hpp
-/boost/asio/experimental/impl/use_coro.hpp
-/boost/asio/experimental/impl/use_promise.hpp
-/boost/asio/experimental/parallel_group.hpp
-/boost/asio/experimental/prepend.hpp
-/boost/asio/experimental/promise.hpp
-/boost/asio/experimental/use_coro.hpp
-/boost/asio/experimental/use_promise.hpp
-/boost/asio/file_base.hpp
-/boost/asio/generic/
-/boost/asio/generic/basic_endpoint.hpp
-/boost/asio/generic/datagram_protocol.hpp
-/boost/asio/generic/detail/
-/boost/asio/generic/detail/endpoint.hpp
-/boost/asio/generic/detail/impl/
-/boost/asio/generic/detail/impl/endpoint.ipp
-/boost/asio/generic/raw_protocol.hpp
-/boost/asio/generic/seq_packet_protocol.hpp
-/boost/asio/generic/stream_protocol.hpp
-/boost/asio/handler_continuation_hook.hpp
-/boost/asio/high_resolution_timer.hpp
-/boost/asio.hpp
-/boost/asio/immediate.hpp
-/boost/asio/impl/
-/boost/asio/impl/any_completion_executor.ipp
-/boost/asio/impl/any_io_executor.ipp
-/boost/asio/impl/append.hpp
-/boost/asio/impl/as_tuple.hpp
-/boost/asio/impl/awaitable.hpp
-/boost/asio/impl/buffered_read_stream.hpp
-/boost/asio/impl/buffered_write_stream.hpp
-/boost/asio/impl/cancel_after.hpp
-/boost/asio/impl/cancel_at.hpp
-/boost/asio/impl/cancellation_signal.ipp
-/boost/asio/impl/connect.hpp
-/boost/asio/impl/connect_pipe.hpp
-/boost/asio/impl/connect_pipe.ipp
-/boost/asio/impl/consign.hpp
-/boost/asio/impl/co_spawn.hpp
-/boost/asio/impl/deferred.hpp
-/boost/asio/impl/detached.hpp
-/boost/asio/impl/error.ipp
-/boost/asio/impl/execution_context.hpp
-/boost/asio/impl/execution_context.ipp
-/boost/asio/impl/executor.hpp
-/boost/asio/impl/executor.ipp
-/boost/asio/impl/io_context.hpp
-/boost/asio/impl/io_context.ipp
-/boost/asio/impl/multiple_exceptions.ipp
-/boost/asio/impl/prepend.hpp
-/boost/asio/impl/read_at.hpp
-/boost/asio/impl/read.hpp
-/boost/asio/impl/read_until.hpp
-/boost/asio/impl/redirect_error.hpp
-/boost/asio/impl/serial_port_base.hpp
-/boost/asio/impl/serial_port_base.ipp
-/boost/asio/impl/spawn.hpp
-/boost/asio/impl/src.hpp
-/boost/asio/impl/system_context.hpp
-/boost/asio/impl/system_context.ipp
-/boost/asio/impl/system_executor.hpp
-/boost/asio/impl/thread_pool.hpp
-/boost/asio/impl/thread_pool.ipp
-/boost/asio/impl/use_awaitable.hpp
-/boost/asio/impl/use_future.hpp
-/boost/asio/impl/write_at.hpp
-/boost/asio/impl/write.hpp
-/boost/asio/io_context.hpp
-/boost/asio/io_context_strand.hpp
-/boost/asio/io_service.hpp
-/boost/asio/io_service_strand.hpp
-/boost/asio/ip/
-/boost/asio/ip/address.hpp
-/boost/asio/ip/address_v4.hpp
-/boost/asio/ip/address_v4_iterator.hpp
-/boost/asio/ip/address_v4_range.hpp
-/boost/asio/ip/address_v6.hpp
-/boost/asio/ip/address_v6_iterator.hpp
-/boost/asio/ip/address_v6_range.hpp
-/boost/asio/ip/bad_address_cast.hpp
-/boost/asio/ip/basic_endpoint.hpp
-/boost/asio/ip/basic_resolver_entry.hpp
-/boost/asio/ip/basic_resolver.hpp
-/boost/asio/ip/basic_resolver_iterator.hpp
-/boost/asio/ip/basic_resolver_query.hpp
-/boost/asio/ip/basic_resolver_results.hpp
-/boost/asio/ip/detail/
-/boost/asio/ip/detail/endpoint.hpp
-/boost/asio/ip/detail/impl/
-/boost/asio/ip/detail/impl/endpoint.ipp
-/boost/asio/ip/detail/socket_option.hpp
-/boost/asio/ip/host_name.hpp
-/boost/asio/ip/icmp.hpp
-/boost/asio/ip/impl/
-/boost/asio/ip/impl/address.hpp
-/boost/asio/ip/impl/address.ipp
-/boost/asio/ip/impl/address_v4.hpp
-/boost/asio/ip/impl/address_v4.ipp
-/boost/asio/ip/impl/address_v6.hpp
-/boost/asio/ip/impl/address_v6.ipp
-/boost/asio/ip/impl/basic_endpoint.hpp
-/boost/asio/ip/impl/host_name.ipp
-/boost/asio/ip/impl/network_v4.hpp
-/boost/asio/ip/impl/network_v4.ipp
-/boost/asio/ip/impl/network_v6.hpp
-/boost/asio/ip/impl/network_v6.ipp
-/boost/asio/ip/multicast.hpp
-/boost/asio/ip/network_v4.hpp
-/boost/asio/ip/network_v6.hpp
-/boost/asio/ip/resolver_base.hpp
-/boost/asio/ip/resolver_query_base.hpp
-/boost/asio/ip/tcp.hpp
-/boost/asio/ip/udp.hpp
-/boost/asio/ip/unicast.hpp
-/boost/asio/ip/v6_only.hpp
-/boost/asio/is_applicable_property.hpp
-/boost/asio/is_contiguous_iterator.hpp
-/boost/asio/is_executor.hpp
-/boost/asio/is_read_buffered.hpp
-/boost/asio/is_write_buffered.hpp
-/boost/asio/local/
-/boost/asio/local/basic_endpoint.hpp
-/boost/asio/local/connect_pair.hpp
-/boost/asio/local/datagram_protocol.hpp
-/boost/asio/local/detail/
-/boost/asio/local/detail/endpoint.hpp
-/boost/asio/local/detail/impl/
-/boost/asio/local/detail/impl/endpoint.ipp
-/boost/asio/local/seq_packet_protocol.hpp
-/boost/asio/local/stream_protocol.hpp
-/boost/asio/multiple_exceptions.hpp
-/boost/asio/packaged_task.hpp
-/boost/asio/placeholders.hpp
-/boost/asio/posix/
-/boost/asio/posix/basic_descriptor.hpp
-/boost/asio/posix/basic_stream_descriptor.hpp
-/boost/asio/posix/descriptor_base.hpp
-/boost/asio/posix/descriptor.hpp
-/boost/asio/posix/stream_descriptor.hpp
-/boost/asio/post.hpp
-/boost/asio/prefer.hpp
-/boost/asio/prepend.hpp
-/boost/asio/query.hpp
-/boost/asio/random_access_file.hpp
-/boost/asio/readable_pipe.hpp
-/boost/asio/read_at.hpp
-/boost/asio/read.hpp
-/boost/asio/read_until.hpp
-/boost/asio/recycling_allocator.hpp
-/boost/asio/redirect_error.hpp
-/boost/asio/registered_buffer.hpp
-/boost/asio/require_concept.hpp
-/boost/asio/require.hpp
-/boost/asio/serial_port_base.hpp
-/boost/asio/serial_port.hpp
-/boost/asio/signal_set_base.hpp
-/boost/asio/signal_set.hpp
-/boost/asio/socket_base.hpp
-/boost/asio/spawn.hpp
-/boost/asio/ssl/
-/boost/asio/ssl/context_base.hpp
-/boost/asio/ssl/context.hpp
-/boost/asio/ssl/detail/
-/boost/asio/ssl/detail/buffered_handshake_op.hpp
-/boost/asio/ssl/detail/engine.hpp
-/boost/asio/ssl/detail/handshake_op.hpp
-/boost/asio/ssl/detail/impl/
-/boost/asio/ssl/detail/impl/engine.ipp
-/boost/asio/ssl/detail/impl/openssl_init.ipp
-/boost/asio/ssl/detail/io.hpp
-/boost/asio/ssl/detail/openssl_init.hpp
-/boost/asio/ssl/detail/openssl_types.hpp
-/boost/asio/ssl/detail/password_callback.hpp
-/boost/asio/ssl/detail/read_op.hpp
-/boost/asio/ssl/detail/shutdown_op.hpp
-/boost/asio/ssl/detail/stream_core.hpp
-/boost/asio/ssl/detail/verify_callback.hpp
-/boost/asio/ssl/detail/write_op.hpp
-/boost/asio/ssl/error.hpp
-/boost/asio/ssl/host_name_verification.hpp
-/boost/asio/ssl.hpp
-/boost/asio/ssl/impl/
-/boost/asio/ssl/impl/context.hpp
-/boost/asio/ssl/impl/context.ipp
-/boost/asio/ssl/impl/error.ipp
-/boost/asio/ssl/impl/host_name_verification.ipp
-/boost/asio/ssl/impl/rfc2818_verification.ipp
-/boost/asio/ssl/impl/src.hpp
-/boost/asio/ssl/rfc2818_verification.hpp
-/boost/asio/ssl/stream_base.hpp
-/boost/asio/ssl/stream.hpp
-/boost/asio/ssl/verify_context.hpp
-/boost/asio/ssl/verify_mode.hpp
-/boost/asio/static_thread_pool.hpp
-/boost/asio/steady_timer.hpp
-/boost/asio/strand.hpp
-/boost/asio/streambuf.hpp
-/boost/asio/stream_file.hpp
-/boost/asio/system_context.hpp
-/boost/asio/system_executor.hpp
-/boost/asio/system_timer.hpp
-/boost/asio/this_coro.hpp
-/boost/asio/thread_pool.hpp
-/boost/asio/time_traits.hpp
-/boost/asio/traits/
-/boost/asio/traits/equality_comparable.hpp
-/boost/asio/traits/execute_member.hpp
-/boost/asio/traits/prefer_free.hpp
-/boost/asio/traits/prefer_member.hpp
-/boost/asio/traits/query_free.hpp
-/boost/asio/traits/query_member.hpp
-/boost/asio/traits/query_static_constexpr_member.hpp
-/boost/asio/traits/require_concept_free.hpp
-/boost/asio/traits/require_concept_member.hpp
-/boost/asio/traits/require_free.hpp
-/boost/asio/traits/require_member.hpp
-/boost/asio/traits/static_query.hpp
-/boost/asio/traits/static_require_concept.hpp
-/boost/asio/traits/static_require.hpp
-/boost/asio/ts/
-/boost/asio/ts/buffer.hpp
-/boost/asio/ts/executor.hpp
-/boost/asio/ts/internet.hpp
-/boost/asio/ts/io_context.hpp
-/boost/asio/ts/netfwd.hpp
-/boost/asio/ts/net.hpp
-/boost/asio/ts/socket.hpp
-/boost/asio/ts/timer.hpp
-/boost/asio/unyield.hpp
-/boost/asio/use_awaitable.hpp
-/boost/asio/use_future.hpp
-/boost/asio/uses_executor.hpp
-/boost/asio/version.hpp
-/boost/asio/wait_traits.hpp
-/boost/asio/windows/
-/boost/asio/windows/basic_object_handle.hpp
-/boost/asio/windows/basic_overlapped_handle.hpp
-/boost/asio/windows/basic_random_access_handle.hpp
-/boost/asio/windows/basic_stream_handle.hpp
-/boost/asio/windows/object_handle.hpp
-/boost/asio/windows/overlapped_handle.hpp
-/boost/asio/windows/overlapped_ptr.hpp
-/boost/asio/windows/random_access_handle.hpp
-/boost/asio/windows/stream_handle.hpp
-/boost/asio/writable_pipe.hpp
-/boost/asio/write_at.hpp
-/boost/asio/write.hpp
-/boost/asio/yield.hpp
-/boost/cerrno.hpp
-/boost/config/
-/boost/config/warning_disable.hpp
-/boost/system/
-/boost/system/api_config.hpp
-/boost/system/config.hpp
-/boost/system/detail/
-/boost/system/detail/append_int.hpp
-/boost/system/detail/cerrno.hpp
-/boost/system/detail/config.hpp
-/boost/system/detail/enable_if.hpp
-/boost/system/detail/errc.hpp
-/boost/system/detail/error_category.hpp
-/boost/system/detail/error_category_impl.hpp
-/boost/system/detail/error_code.hpp
-/boost/system/detail/error_condition.hpp
-/boost/system/detail/generic_category.hpp
-/boost/system/detail/generic_category_message.hpp
-/boost/system/detail/interop_category.hpp
-/boost/system/detail/is_same.hpp
-/boost/system/detail/mutex.hpp
-/boost/system/detail/snprintf.hpp
-/boost/system/detail/std_category.hpp
-/boost/system/detail/std_category_impl.hpp
-/boost/system/detail/system_category_condition_win32.hpp
-/boost/system/detail/system_category.hpp
-/boost/system/detail/system_category_impl.hpp
-/boost/system/detail/system_category_message.hpp
-/boost/system/detail/system_category_message_win32.hpp
-/boost/system/detail/throws.hpp
-/boost/system/errc.hpp
-/boost/system/error_category.hpp
-/boost/system/error_code.hpp
-/boost/system/error_condition.hpp
-/boost/system/generic_category.hpp
-/boost/system/is_error_code_enum.hpp
-/boost/system/is_error_condition_enum.hpp
-/boost/system/linux_error.hpp
-/boost/system/result.hpp
-/boost/system/system_category.hpp
-/boost/system/system_error.hpp
-/boost/system/windows_error.hpp
-/doc/
-/doc/html/
-/doc/html/boost_asio/
-/doc/html/boost_asio/async_agent_chain.png
-/doc/html/boost_asio/async_agent_model.png
-/doc/html/boost_asio/async_child_agent_chain.png
-/doc/html/boost_asio/async_op1.png
-/doc/html/boost_asio/async_op2.png
-/doc/html/boost_asio/async_op_init_complete.png
-/doc/html/boost_asio/async_op_model.png
-/doc/html/boost_asio/async_op_phases.png
-/doc/html/boost_asio/async_op_trivial_chain.png
-/doc/html/boost_asio/completion_token_model.png
-/doc/html/boost_asio/completion_token_transform.png
-/doc/html/boost_asio/example/
-/doc/html/boost_asio/example/cpp11/
-/doc/html/boost_asio/example/cpp11/allocation/
-/doc/html/boost_asio/example/cpp11/allocation/server.cpp
-/doc/html/boost_asio/example/cpp11/buffers/
-/doc/html/boost_asio/example/cpp11/buffers/reference_counted.cpp
-/doc/html/boost_asio/example/cpp11/chat/
-/doc/html/boost_asio/example/cpp11/chat/chat_client.cpp
-/doc/html/boost_asio/example/cpp11/chat/chat_message.hpp
-/doc/html/boost_asio/example/cpp11/chat/chat_server.cpp
-/doc/html/boost_asio/example/cpp11/chat/posix_chat_client.cpp
-/doc/html/boost_asio/example/cpp11/deferred/
-/doc/html/boost_asio/example/cpp11/deferred/deferred_1.cpp
-/doc/html/boost_asio/example/cpp11/deferred/deferred_2.cpp
-/doc/html/boost_asio/example/cpp11/echo/
-/doc/html/boost_asio/example/cpp11/echo/async_tcp_echo_server.cpp
-/doc/html/boost_asio/example/cpp11/echo/async_udp_echo_server.cpp
-/doc/html/boost_asio/example/cpp11/echo/blocking_tcp_echo_client.cpp
-/doc/html/boost_asio/example/cpp11/echo/blocking_tcp_echo_server.cpp
-/doc/html/boost_asio/example/cpp11/echo/blocking_udp_echo_client.cpp
-/doc/html/boost_asio/example/cpp11/echo/blocking_udp_echo_server.cpp
-/doc/html/boost_asio/example/cpp11/executors/
-/doc/html/boost_asio/example/cpp11/executors/actor.cpp
-/doc/html/boost_asio/example/cpp11/executors/bank_account_1.cpp
-/doc/html/boost_asio/example/cpp11/executors/bank_account_2.cpp
-/doc/html/boost_asio/example/cpp11/executors/fork_join.cpp
-/doc/html/boost_asio/example/cpp11/executors/pipeline.cpp
-/doc/html/boost_asio/example/cpp11/executors/priority_scheduler.cpp
-/doc/html/boost_asio/example/cpp11/fork/
-/doc/html/boost_asio/example/cpp11/fork/daemon.cpp
-/doc/html/boost_asio/example/cpp11/fork/process_per_connection.cpp
-/doc/html/boost_asio/example/cpp11/futures/
-/doc/html/boost_asio/example/cpp11/futures/daytime_client.cpp
-/doc/html/boost_asio/example/cpp11/handler_tracking/
-/doc/html/boost_asio/example/cpp11/handler_tracking/async_tcp_echo_server.cpp
-/doc/html/boost_asio/example/cpp11/handler_tracking/custom_tracking.hpp
-/doc/html/boost_asio/example/cpp11/http/
-/doc/html/boost_asio/example/cpp11/http/client/
-/doc/html/boost_asio/example/cpp11/http/client/async_client.cpp
-/doc/html/boost_asio/example/cpp11/http/client/sync_client.cpp
-/doc/html/boost_asio/example/cpp11/http/server/
-/doc/html/boost_asio/example/cpp11/http/server2/
-/doc/html/boost_asio/example/cpp11/http/server2/connection.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/connection.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/header.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/io_context_pool.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/io_context_pool.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/main.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/mime_types.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/mime_types.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/reply.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/reply.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/request_handler.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/request_handler.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/request.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/request_parser.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/request_parser.hpp
-/doc/html/boost_asio/example/cpp11/http/server2/server.cpp
-/doc/html/boost_asio/example/cpp11/http/server2/server.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/
-/doc/html/boost_asio/example/cpp11/http/server3/connection.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/connection.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/header.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/main.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/mime_types.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/mime_types.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/reply.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/reply.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/request_handler.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/request_handler.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/request.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/request_parser.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/request_parser.hpp
-/doc/html/boost_asio/example/cpp11/http/server3/server.cpp
-/doc/html/boost_asio/example/cpp11/http/server3/server.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/
-/doc/html/boost_asio/example/cpp11/http/server4/file_handler.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/file_handler.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/header.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/main.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/mime_types.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/mime_types.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/reply.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/reply.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/request_handler.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/request_handler.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/request.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/request_parser.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/request_parser.hpp
-/doc/html/boost_asio/example/cpp11/http/server4/server.cpp
-/doc/html/boost_asio/example/cpp11/http/server4/server.hpp
-/doc/html/boost_asio/example/cpp11/http/server/connection.cpp
-/doc/html/boost_asio/example/cpp11/http/server/connection.hpp
-/doc/html/boost_asio/example/cpp11/http/server/connection_manager.cpp
-/doc/html/boost_asio/example/cpp11/http/server/connection_manager.hpp
-/doc/html/boost_asio/example/cpp11/http/server/header.hpp
-/doc/html/boost_asio/example/cpp11/http/server/main.cpp
-/doc/html/boost_asio/example/cpp11/http/server/mime_types.cpp
-/doc/html/boost_asio/example/cpp11/http/server/mime_types.hpp
-/doc/html/boost_asio/example/cpp11/http/server/reply.cpp
-/doc/html/boost_asio/example/cpp11/http/server/reply.hpp
-/doc/html/boost_asio/example/cpp11/http/server/request_handler.cpp
-/doc/html/boost_asio/example/cpp11/http/server/request_handler.hpp
-/doc/html/boost_asio/example/cpp11/http/server/request.hpp
-/doc/html/boost_asio/example/cpp11/http/server/request_parser.cpp
-/doc/html/boost_asio/example/cpp11/http/server/request_parser.hpp
-/doc/html/boost_asio/example/cpp11/http/server/server.cpp
-/doc/html/boost_asio/example/cpp11/http/server/server.hpp
-/doc/html/boost_asio/example/cpp11/icmp/
-/doc/html/boost_asio/example/cpp11/icmp/icmp_header.hpp
-/doc/html/boost_asio/example/cpp11/icmp/ipv4_header.hpp
-/doc/html/boost_asio/example/cpp11/icmp/ping.cpp
-/doc/html/boost_asio/example/cpp11/invocation/
-/doc/html/boost_asio/example/cpp11/invocation/prioritised_handlers.cpp
-/doc/html/boost_asio/example/cpp11/iostreams/
-/doc/html/boost_asio/example/cpp11/iostreams/daytime_client.cpp
-/doc/html/boost_asio/example/cpp11/iostreams/daytime_server.cpp
-/doc/html/boost_asio/example/cpp11/iostreams/http_client.cpp
-/doc/html/boost_asio/example/cpp11/local/
-/doc/html/boost_asio/example/cpp11/local/connect_pair.cpp
-/doc/html/boost_asio/example/cpp11/local/fd_passing_stream_client.cpp
-/doc/html/boost_asio/example/cpp11/local/fd_passing_stream_server.cpp
-/doc/html/boost_asio/example/cpp11/local/iostream_client.cpp
-/doc/html/boost_asio/example/cpp11/local/stream_client.cpp
-/doc/html/boost_asio/example/cpp11/local/stream_server.cpp
-/doc/html/boost_asio/example/cpp11/multicast/
-/doc/html/boost_asio/example/cpp11/multicast/receiver.cpp
-/doc/html/boost_asio/example/cpp11/multicast/sender.cpp
-/doc/html/boost_asio/example/cpp11/nonblocking/
-/doc/html/boost_asio/example/cpp11/nonblocking/third_party_lib.cpp
-/doc/html/boost_asio/example/cpp11/operations/
-/doc/html/boost_asio/example/cpp11/operations/composed_1.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_2.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_3.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_4.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_5.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_6.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_7.cpp
-/doc/html/boost_asio/example/cpp11/operations/composed_8.cpp
-/doc/html/boost_asio/example/cpp11/parallel_group/
-/doc/html/boost_asio/example/cpp11/parallel_group/ranged_wait_for_all.cpp
-/doc/html/boost_asio/example/cpp11/parallel_group/wait_for_all.cpp
-/doc/html/boost_asio/example/cpp11/parallel_group/wait_for_one.cpp
-/doc/html/boost_asio/example/cpp11/parallel_group/wait_for_one_error.cpp
-/doc/html/boost_asio/example/cpp11/parallel_group/wait_for_one_success.cpp
-/doc/html/boost_asio/example/cpp11/porthopper/
-/doc/html/boost_asio/example/cpp11/porthopper/client.cpp
-/doc/html/boost_asio/example/cpp11/porthopper/protocol.hpp
-/doc/html/boost_asio/example/cpp11/porthopper/server.cpp
-/doc/html/boost_asio/example/cpp11/serialization/
-/doc/html/boost_asio/example/cpp11/serialization/client.cpp
-/doc/html/boost_asio/example/cpp11/serialization/connection.hpp
-/doc/html/boost_asio/example/cpp11/serialization/server.cpp
-/doc/html/boost_asio/example/cpp11/serialization/stock.hpp
-/doc/html/boost_asio/example/cpp11/services/
-/doc/html/boost_asio/example/cpp11/services/basic_logger.hpp
-/doc/html/boost_asio/example/cpp11/services/daytime_client.cpp
-/doc/html/boost_asio/example/cpp11/services/logger.hpp
-/doc/html/boost_asio/example/cpp11/services/logger_service.cpp
-/doc/html/boost_asio/example/cpp11/services/logger_service.hpp
-/doc/html/boost_asio/example/cpp11/socks4/
-/doc/html/boost_asio/example/cpp11/socks4/socks4.hpp
-/doc/html/boost_asio/example/cpp11/socks4/sync_client.cpp
-/doc/html/boost_asio/example/cpp11/spawn/
-/doc/html/boost_asio/example/cpp11/spawn/echo_server.cpp
-/doc/html/boost_asio/example/cpp11/spawn/parallel_grep.cpp
-/doc/html/boost_asio/example/cpp11/ssl/
-/doc/html/boost_asio/example/cpp11/ssl/client.cpp
-/doc/html/boost_asio/example/cpp11/ssl/server.cpp
-/doc/html/boost_asio/example/cpp11/timeouts/
-/doc/html/boost_asio/example/cpp11/timeouts/async_tcp_client.cpp
-/doc/html/boost_asio/example/cpp11/timeouts/blocking_tcp_client.cpp
-/doc/html/boost_asio/example/cpp11/timeouts/blocking_token_tcp_client.cpp
-/doc/html/boost_asio/example/cpp11/timeouts/blocking_udp_client.cpp
-/doc/html/boost_asio/example/cpp11/timeouts/server.cpp
-/doc/html/boost_asio/example/cpp11/timers/
-/doc/html/boost_asio/example/cpp11/timers/time_t_timer.cpp
-/doc/html/boost_asio/example/cpp11/type_erasure/
-/doc/html/boost_asio/example/cpp11/type_erasure/line_reader.hpp
-/doc/html/boost_asio/example/cpp11/type_erasure/main.cpp
-/doc/html/boost_asio/example/cpp11/type_erasure/sleep.cpp
-/doc/html/boost_asio/example/cpp11/type_erasure/sleep.hpp
-/doc/html/boost_asio/example/cpp11/type_erasure/stdin_line_reader.cpp
-/doc/html/boost_asio/example/cpp11/type_erasure/stdin_line_reader.hpp
-/doc/html/boost_asio/example/cpp11/windows/
-/doc/html/boost_asio/example/cpp11/windows/transmit_file.cpp
-/doc/html/boost_asio/example/cpp14/
-/doc/html/boost_asio/example/cpp14/deferred/
-/doc/html/boost_asio/example/cpp14/deferred/deferred_1.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_2.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_3.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_4.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_5.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_6.cpp
-/doc/html/boost_asio/example/cpp14/deferred/deferred_7.cpp
-/doc/html/boost_asio/example/cpp14/echo/
-/doc/html/boost_asio/example/cpp14/echo/async_tcp_echo_server.cpp
-/doc/html/boost_asio/example/cpp14/echo/async_udp_echo_server.cpp
-/doc/html/boost_asio/example/cpp14/echo/blocking_tcp_echo_client.cpp
-/doc/html/boost_asio/example/cpp14/echo/blocking_tcp_echo_server.cpp
-/doc/html/boost_asio/example/cpp14/echo/blocking_udp_echo_client.cpp
-/doc/html/boost_asio/example/cpp14/echo/blocking_udp_echo_server.cpp
-/doc/html/boost_asio/example/cpp14/executors/
-/doc/html/boost_asio/example/cpp14/executors/actor.cpp
-/doc/html/boost_asio/example/cpp14/executors/async_1.cpp
-/doc/html/boost_asio/example/cpp14/executors/async_2.cpp
-/doc/html/boost_asio/example/cpp14/executors/bank_account_1.cpp
-/doc/html/boost_asio/example/cpp14/executors/bank_account_2.cpp
-/doc/html/boost_asio/example/cpp14/executors/fork_join.cpp
-/doc/html/boost_asio/example/cpp14/executors/pipeline.cpp
-/doc/html/boost_asio/example/cpp14/executors/priority_scheduler.cpp
-/doc/html/boost_asio/example/cpp14/iostreams/
-/doc/html/boost_asio/example/cpp14/iostreams/http_client.cpp
-/doc/html/boost_asio/example/cpp14/operations/
-/doc/html/boost_asio/example/cpp14/operations/callback_wrapper.cpp
-/doc/html/boost_asio/example/cpp14/operations/c_callback_wrapper.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_1.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_2.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_3.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_4.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_5.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_6.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_7.cpp
-/doc/html/boost_asio/example/cpp14/operations/composed_8.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/
-/doc/html/boost_asio/example/cpp14/parallel_group/parallel_sort.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/ranged_wait_for_all.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/wait_for_all.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/wait_for_one.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/wait_for_one_error.cpp
-/doc/html/boost_asio/example/cpp14/parallel_group/wait_for_one_success.cpp
-/doc/html/boost_asio/example/cpp17/
-/doc/html/boost_asio/example/cpp17/coroutines_ts/
-/doc/html/boost_asio/example/cpp17/coroutines_ts/chat_server.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/echo_server.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/echo_server_with_default.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/range_based_for.cpp
-/doc/html/boost_asio/example/cpp17/coroutines_ts/refactored_echo_server.cpp
-/doc/html/boost_asio/example/cpp20/
-/doc/html/boost_asio/example/cpp20/channels/
-/doc/html/boost_asio/example/cpp20/channels/mutual_exclusion_1.cpp
-/doc/html/boost_asio/example/cpp20/channels/mutual_exclusion_2.cpp
-/doc/html/boost_asio/example/cpp20/channels/throttling_proxy.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/
-/doc/html/boost_asio/example/cpp20/coroutines/chat_server.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server_with_as_single_default.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server_with_as_tuple_default.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server_with_default.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server_with_deferred.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/echo_server_with_deferred_default.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/refactored_echo_server.cpp
-/doc/html/boost_asio/example/cpp20/coroutines/timeout.cpp
-/doc/html/boost_asio/example/cpp20/invocation/
-/doc/html/boost_asio/example/cpp20/invocation/completion_executor.cpp
-/doc/html/boost_asio/example/cpp20/operations/
-/doc/html/boost_asio/example/cpp20/operations/callback_wrapper.cpp
-/doc/html/boost_asio/example/cpp20/operations/c_callback_wrapper.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_1.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_2.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_3.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_4.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_5.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_6.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_7.cpp
-/doc/html/boost_asio/example/cpp20/operations/composed_8.cpp
-/doc/html/boost_asio/example/cpp20/type_erasure/
-/doc/html/boost_asio/example/cpp20/type_erasure/line_reader.hpp
-/doc/html/boost_asio/example/cpp20/type_erasure/main.cpp
-/doc/html/boost_asio/example/cpp20/type_erasure/sleep.cpp
-/doc/html/boost_asio/example/cpp20/type_erasure/sleep.hpp
-/doc/html/boost_asio/example/cpp20/type_erasure/stdin_line_reader.cpp
-/doc/html/boost_asio/example/cpp20/type_erasure/stdin_line_reader.hpp
-/doc/html/boost_asio/examples/
-/doc/html/boost_asio/examples/cpp11_examples.html
-/doc/html/boost_asio/examples/cpp14_examples.html
-/doc/html/boost_asio/examples/cpp17_examples.html
-/doc/html/boost_asio/examples/cpp20_examples.html
-/doc/html/boost_asio/examples.html
-/doc/html/boost_asio/higher_level_model.png
-/doc/html/boost_asio/history.html
-/doc/html/boost_asio.html
-/doc/html/boost_asio/index.html
-/doc/html/boost_asio/net_ts.html
-/doc/html/boost_asio/overview/
-/doc/html/boost_asio/overview/basics.html
-/doc/html/boost_asio/overview/channels.html
-/doc/html/boost_asio/overview/composition/
-/doc/html/boost_asio/overview/composition/compose.html
-/doc/html/boost_asio/overview/composition/coro.html
-/doc/html/boost_asio/overview/composition/coroutine.html
-/doc/html/boost_asio/overview/composition/cpp20_coroutines.html
-/doc/html/boost_asio/overview/composition/deferred.html
-/doc/html/boost_asio/overview/composition/futures.html
-/doc/html/boost_asio/overview/composition.html
-/doc/html/boost_asio/overview/composition/immediate_completion.html
-/doc/html/boost_asio/overview/composition/parallel_group.html
-/doc/html/boost_asio/overview/composition/promises.html
-/doc/html/boost_asio/overview/composition/spawn.html
-/doc/html/boost_asio/overview/composition/token_adapters.html
-/doc/html/boost_asio/overview/composition/type_erasure.html
-/doc/html/boost_asio/overview/core/
-/doc/html/boost_asio/overview/core/allocation.html
-/doc/html/boost_asio/overview/core/async.html
-/doc/html/boost_asio/overview/core/buffers.html
-/doc/html/boost_asio/overview/core/cancellation.html
-/doc/html/boost_asio/overview/core/concurrency_hint.html
-/doc/html/boost_asio/overview/core/handler_tracking.html
-/doc/html/boost_asio/overview/core.html
-/doc/html/boost_asio/overview/core/line_based.html
-/doc/html/boost_asio/overview/core/reactor.html
-/doc/html/boost_asio/overview/core/strands.html
-/doc/html/boost_asio/overview/core/streams.html
-/doc/html/boost_asio/overview/core/threads.html
-/doc/html/boost_asio/overview/cpp2011/
-/doc/html/boost_asio/overview/cpp2011/array.html
-/doc/html/boost_asio/overview/cpp2011/atomic.html
-/doc/html/boost_asio/overview/cpp2011/chrono.html
-/doc/html/boost_asio/overview/cpp2011.html
-/doc/html/boost_asio/overview/cpp2011/move_handlers.html
-/doc/html/boost_asio/overview/cpp2011/move_objects.html
-/doc/html/boost_asio/overview/cpp2011/shared_ptr.html
-/doc/html/boost_asio/overview/cpp2011/variadic.html
-/doc/html/boost_asio/overview/files.html
-/doc/html/boost_asio/overview.html
-/doc/html/boost_asio/overview/implementation.html
-/doc/html/boost_asio/overview/model/
-/doc/html/boost_asio/overview/model/allocators.html
-/doc/html/boost_asio/overview/model/associators.html
-/doc/html/boost_asio/overview/model/async_agents.html
-/doc/html/boost_asio/overview/model/async_ops.html
-/doc/html/boost_asio/overview/model/cancellation.html
-/doc/html/boost_asio/overview/model/child_agents.html
-/doc/html/boost_asio/overview/model/completion_tokens.html
-/doc/html/boost_asio/overview/model/executors.html
-/doc/html/boost_asio/overview/model/higher_levels.html
-/doc/html/boost_asio/overview/model.html
-/doc/html/boost_asio/overview/model/library_elements.html
-/doc/html/boost_asio/overview/networking/
-/doc/html/boost_asio/overview/networking/bsd_sockets.html
-/doc/html/boost_asio/overview/networking.html
-/doc/html/boost_asio/overview/networking/iostreams.html
-/doc/html/boost_asio/overview/networking/other_protocols.html
-/doc/html/boost_asio/overview/networking/protocols.html
-/doc/html/boost_asio/overview/pipes.html
-/doc/html/boost_asio/overview/posix/
-/doc/html/boost_asio/overview/posix/fork.html
-/doc/html/boost_asio/overview/posix.html
-/doc/html/boost_asio/overview/posix/local.html
-/doc/html/boost_asio/overview/posix/stream_descriptor.html
-/doc/html/boost_asio/overview/rationale.html
-/doc/html/boost_asio/overview/serial_ports.html
-/doc/html/boost_asio/overview/signals.html
-/doc/html/boost_asio/overview/ssl.html
-/doc/html/boost_asio/overview/timers.html
-/doc/html/boost_asio/overview/windows/
-/doc/html/boost_asio/overview/windows.html
-/doc/html/boost_asio/overview/windows/object_handle.html
-/doc/html/boost_asio/overview/windows/random_access_handle.html
-/doc/html/boost_asio/overview/windows/stream_handle.html
-/doc/html/boost_asio/proactor.png
-/doc/html/boost_asio/reference/
-/doc/html/boost_asio/reference/AcceptableProtocol.html
-/doc/html/boost_asio/reference/AcceptHandler.html
-/doc/html/boost_asio/reference/AcceptToken.html
-/doc/html/boost_asio/reference/allocator_binder/
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/
-/doc/html/boost_asio/reference/allocator_binder/_allocator_binder.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload1.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload2.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload3.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload4.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload5.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload6.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload7.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload8.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_binder/overload9.html
-/doc/html/boost_asio/reference/allocator_binder/allocator_type.html
-/doc/html/boost_asio/reference/allocator_binder/argument_type.html
-/doc/html/boost_asio/reference/allocator_binder/first_argument_type.html
-/doc/html/boost_asio/reference/allocator_binder/get/
-/doc/html/boost_asio/reference/allocator_binder/get_allocator.html
-/doc/html/boost_asio/reference/allocator_binder/get.html
-/doc/html/boost_asio/reference/allocator_binder/get/overload1.html
-/doc/html/boost_asio/reference/allocator_binder/get/overload2.html
-/doc/html/boost_asio/reference/allocator_binder.html
-/doc/html/boost_asio/reference/allocator_binder/operator_lp__rp_/
-/doc/html/boost_asio/reference/allocator_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/allocator_binder/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/allocator_binder/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/allocator_binder/result_type.html
-/doc/html/boost_asio/reference/allocator_binder/second_argument_type.html
-/doc/html/boost_asio/reference/allocator_binder/target_type.html
-/doc/html/boost_asio/reference/any_completion_executor/
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/
-/doc/html/boost_asio/reference/any_completion_executor/_any_completion_executor.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload10.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload3.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload4.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload5.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload6.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload7.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload8.html
-/doc/html/boost_asio/reference/any_completion_executor/any_completion_executor/overload9.html
-/doc/html/boost_asio/reference/any_completion_executor/context.html
-/doc/html/boost_asio/reference/any_completion_executor/execute.html
-/doc/html/boost_asio/reference/any_completion_executor.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_bool.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq_/
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq__eq_/
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq__eq_.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq__eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq__eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq__eq_/overload3.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq_.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_not__eq_/
-/doc/html/boost_asio/reference/any_completion_executor/operator_not__eq_.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_not__eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_not__eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/operator_not__eq_/overload3.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/
-/doc/html/boost_asio/reference/any_completion_executor/prefer.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload3.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload4.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload5.html
-/doc/html/boost_asio/reference/any_completion_executor/prefer/overload6.html
-/doc/html/boost_asio/reference/any_completion_executor/query.html
-/doc/html/boost_asio/reference/any_completion_executor/require/
-/doc/html/boost_asio/reference/any_completion_executor/require.html
-/doc/html/boost_asio/reference/any_completion_executor/require/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/require/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/swap/
-/doc/html/boost_asio/reference/any_completion_executor/swap.html
-/doc/html/boost_asio/reference/any_completion_executor/swap/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/swap/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/target/
-/doc/html/boost_asio/reference/any_completion_executor/target.html
-/doc/html/boost_asio/reference/any_completion_executor/target/overload1.html
-/doc/html/boost_asio/reference/any_completion_executor/target/overload2.html
-/doc/html/boost_asio/reference/any_completion_executor/target_type.html
-/doc/html/boost_asio/reference/any_completion_handler/
-/doc/html/boost_asio/reference/any_completion_handler_allocator/
-/doc/html/boost_asio/reference/any_completion_handler_allocator/allocate.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator/any_completion_handler_allocator.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator/deallocate.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/any_completion_handler_allocator.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/operator_eq__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/operator_not__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind/
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind/other.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_/value_type.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator/operator_eq__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator/operator_not__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator__rebind/
-/doc/html/boost_asio/reference/any_completion_handler_allocator__rebind.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator__rebind/other.html
-/doc/html/boost_asio/reference/any_completion_handler/allocator_type.html
-/doc/html/boost_asio/reference/any_completion_handler_allocator/value_type.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler/
-/doc/html/boost_asio/reference/any_completion_handler/_any_completion_handler.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler/overload1.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler/overload2.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler/overload3.html
-/doc/html/boost_asio/reference/any_completion_handler/any_completion_handler/overload4.html
-/doc/html/boost_asio/reference/any_completion_handler/cancellation_slot_type.html
-/doc/html/boost_asio/reference/any_completion_handler/get_allocator.html
-/doc/html/boost_asio/reference/any_completion_handler/get_cancellation_slot.html
-/doc/html/boost_asio/reference/any_completion_handler.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_bool.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq_/
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq__eq_/
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq__eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq__eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq_.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_lp__rp_.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_not__eq_/
-/doc/html/boost_asio/reference/any_completion_handler/operator_not__eq_.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_not__eq_/overload1.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_not__eq_/overload2.html
-/doc/html/boost_asio/reference/any_completion_handler/operator_not_.html
-/doc/html/boost_asio/reference/any_completion_handler/swap.html
-/doc/html/boost_asio/reference/any_io_executor/
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/
-/doc/html/boost_asio/reference/any_io_executor/_any_io_executor.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload10.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload4.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload5.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload6.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload7.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload8.html
-/doc/html/boost_asio/reference/any_io_executor/any_io_executor/overload9.html
-/doc/html/boost_asio/reference/any_io_executor/context.html
-/doc/html/boost_asio/reference/any_io_executor/execute.html
-/doc/html/boost_asio/reference/any_io_executor.html
-/doc/html/boost_asio/reference/any_io_executor/operator_bool.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq_/
-/doc/html/boost_asio/reference/any_io_executor/operator_eq__eq_/
-/doc/html/boost_asio/reference/any_io_executor/operator_eq__eq_.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq__eq_/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq__eq_/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq__eq_/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq_.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/operator_not__eq_/
-/doc/html/boost_asio/reference/any_io_executor/operator_not__eq_.html
-/doc/html/boost_asio/reference/any_io_executor/operator_not__eq_/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/operator_not__eq_/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/operator_not__eq_/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/
-/doc/html/boost_asio/reference/any_io_executor/prefer.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload4.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload5.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload6.html
-/doc/html/boost_asio/reference/any_io_executor/prefer/overload7.html
-/doc/html/boost_asio/reference/any_io_executor/query.html
-/doc/html/boost_asio/reference/any_io_executor/require/
-/doc/html/boost_asio/reference/any_io_executor/require.html
-/doc/html/boost_asio/reference/any_io_executor/require/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/require/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/require/overload3.html
-/doc/html/boost_asio/reference/any_io_executor/swap/
-/doc/html/boost_asio/reference/any_io_executor/swap.html
-/doc/html/boost_asio/reference/any_io_executor/swap/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/swap/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/target/
-/doc/html/boost_asio/reference/any_io_executor/target.html
-/doc/html/boost_asio/reference/any_io_executor/target/overload1.html
-/doc/html/boost_asio/reference/any_io_executor/target/overload2.html
-/doc/html/boost_asio/reference/any_io_executor/target_type.html
-/doc/html/boost_asio/reference/append.html
-/doc/html/boost_asio/reference/append_t/
-/doc/html/boost_asio/reference/append_t/append_t.html
-/doc/html/boost_asio/reference/append_t.html
-/doc/html/boost_asio/reference/append_t/token_.html
-/doc/html/boost_asio/reference/append_t/values_.html
-/doc/html/boost_asio/reference/asio_handler_is_continuation.html
-/doc/html/boost_asio/reference/associated_allocator/
-/doc/html/boost_asio/reference/associated_allocator/get/
-/doc/html/boost_asio/reference/associated_allocator/get.html
-/doc/html/boost_asio/reference/associated_allocator/get/overload1.html
-/doc/html/boost_asio/reference/associated_allocator/get/overload2.html
-/doc/html/boost_asio/reference/associated_allocator.html
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get.html
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/overload1.html
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/get/overload2.html
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.html
-/doc/html/boost_asio/reference/associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_/type.html
-/doc/html/boost_asio/reference/associated_allocator_t.html
-/doc/html/boost_asio/reference/associated_allocator/type.html
-/doc/html/boost_asio/reference/associated_cancellation_slot/
-/doc/html/boost_asio/reference/associated_cancellation_slot/get/
-/doc/html/boost_asio/reference/associated_cancellation_slot/get.html
-/doc/html/boost_asio/reference/associated_cancellation_slot/get/overload1.html
-/doc/html/boost_asio/reference/associated_cancellation_slot/get/overload2.html
-/doc/html/boost_asio/reference/associated_cancellation_slot.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/overload1.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/get/overload2.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_/type.html
-/doc/html/boost_asio/reference/associated_cancellation_slot_t.html
-/doc/html/boost_asio/reference/associated_cancellation_slot/type.html
-/doc/html/boost_asio/reference/associated_executor/
-/doc/html/boost_asio/reference/associated_executor/get/
-/doc/html/boost_asio/reference/associated_executor/get.html
-/doc/html/boost_asio/reference/associated_executor/get/overload1.html
-/doc/html/boost_asio/reference/associated_executor/get/overload2.html
-/doc/html/boost_asio/reference/associated_executor.html
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get.html
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/overload1.html
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get/overload2.html
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.html
-/doc/html/boost_asio/reference/associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/type.html
-/doc/html/boost_asio/reference/associated_executor_t.html
-/doc/html/boost_asio/reference/associated_executor/type.html
-/doc/html/boost_asio/reference/associated_immediate_executor/
-/doc/html/boost_asio/reference/associated_immediate_executor/get.html
-/doc/html/boost_asio/reference/associated_immediate_executor.html
-/doc/html/boost_asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/
-/doc/html/boost_asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/get.html
-/doc/html/boost_asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.html
-/doc/html/boost_asio/reference/associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_/type.html
-/doc/html/boost_asio/reference/associated_immediate_executor_t.html
-/doc/html/boost_asio/reference/associated_immediate_executor/type.html
-/doc/html/boost_asio/reference/associator.html
-/doc/html/boost_asio/reference/as_tuple.html
-/doc/html/boost_asio/reference/as_tuple_t/
-/doc/html/boost_asio/reference/as_tuple_t/as_default_on.html
-/doc/html/boost_asio/reference/as_tuple_t/as_default_on_t.html
-/doc/html/boost_asio/reference/as_tuple_t/as_tuple_t/
-/doc/html/boost_asio/reference/as_tuple_t/as_tuple_t.html
-/doc/html/boost_asio/reference/as_tuple_t/as_tuple_t/overload1.html
-/doc/html/boost_asio/reference/as_tuple_t/as_tuple_t/overload2.html
-/doc/html/boost_asio/reference/as_tuple_t__default_constructor_tag.html
-/doc/html/boost_asio/reference/as_tuple_t__executor_with_default/
-/doc/html/boost_asio/reference/as_tuple_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/as_tuple_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/as_tuple_t__executor_with_default.html
-/doc/html/boost_asio/reference/as_tuple_t.html
-/doc/html/boost_asio/reference/as_tuple_t/token_.html
-/doc/html/boost_asio/reference/async_completion/
-/doc/html/boost_asio/reference/async_completion/async_completion.html
-/doc/html/boost_asio/reference/async_completion/completion_handler.html
-/doc/html/boost_asio/reference/async_completion/completion_handler_type.html
-/doc/html/boost_asio/reference/async_completion.html
-/doc/html/boost_asio/reference/async_completion/result.html
-/doc/html/boost_asio/reference/async_compose.html
-/doc/html/boost_asio/reference/async_connect/
-/doc/html/boost_asio/reference/async_connect.html
-/doc/html/boost_asio/reference/async_connect/overload1.html
-/doc/html/boost_asio/reference/async_connect/overload2.html
-/doc/html/boost_asio/reference/async_connect/overload3.html
-/doc/html/boost_asio/reference/async_connect/overload4.html
-/doc/html/boost_asio/reference/async_connect/overload5.html
-/doc/html/boost_asio/reference/async_connect/overload6.html
-/doc/html/boost_asio/reference/asynchronous_operations.html
-/doc/html/boost_asio/reference/asynchronous_socket_operations.html
-/doc/html/boost_asio/reference/async_immediate/
-/doc/html/boost_asio/reference/async_immediate.html
-/doc/html/boost_asio/reference/async_immediate/overload1.html
-/doc/html/boost_asio/reference/async_immediate/overload2.html
-/doc/html/boost_asio/reference/async_initiate.html
-/doc/html/boost_asio/reference/AsyncRandomAccessReadDevice.html
-/doc/html/boost_asio/reference/AsyncRandomAccessWriteDevice.html
-/doc/html/boost_asio/reference/async_read/
-/doc/html/boost_asio/reference/async_read_at/
-/doc/html/boost_asio/reference/async_read_at.html
-/doc/html/boost_asio/reference/async_read_at/overload1.html
-/doc/html/boost_asio/reference/async_read_at/overload2.html
-/doc/html/boost_asio/reference/async_read_at/overload3.html
-/doc/html/boost_asio/reference/async_read_at/overload4.html
-/doc/html/boost_asio/reference/async_read.html
-/doc/html/boost_asio/reference/async_read/overload1.html
-/doc/html/boost_asio/reference/async_read/overload2.html
-/doc/html/boost_asio/reference/async_read/overload3.html
-/doc/html/boost_asio/reference/async_read/overload4.html
-/doc/html/boost_asio/reference/async_read/overload5.html
-/doc/html/boost_asio/reference/async_read/overload6.html
-/doc/html/boost_asio/reference/async_read/overload7.html
-/doc/html/boost_asio/reference/async_read/overload8.html
-/doc/html/boost_asio/reference/AsyncReadStream.html
-/doc/html/boost_asio/reference/async_read_until/
-/doc/html/boost_asio/reference/async_read_until.html
-/doc/html/boost_asio/reference/async_read_until/overload10.html
-/doc/html/boost_asio/reference/async_read_until/overload11.html
-/doc/html/boost_asio/reference/async_read_until/overload12.html
-/doc/html/boost_asio/reference/async_read_until/overload1.html
-/doc/html/boost_asio/reference/async_read_until/overload2.html
-/doc/html/boost_asio/reference/async_read_until/overload3.html
-/doc/html/boost_asio/reference/async_read_until/overload4.html
-/doc/html/boost_asio/reference/async_read_until/overload5.html
-/doc/html/boost_asio/reference/async_read_until/overload6.html
-/doc/html/boost_asio/reference/async_read_until/overload7.html
-/doc/html/boost_asio/reference/async_read_until/overload8.html
-/doc/html/boost_asio/reference/async_read_until/overload9.html
-/doc/html/boost_asio/reference/async_result/
-/doc/html/boost_asio/reference/async_result/async_result.html
-/doc/html/boost_asio/reference/async_result/completion_handler_type.html
-/doc/html/boost_asio/reference/async_result/get.html
-/doc/html/boost_asio/reference/async_result.html
-/doc/html/boost_asio/reference/async_result/initiate.html
-/doc/html/boost_asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/
-/doc/html/boost_asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/handler_type.html
-/doc/html/boost_asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.html
-/doc/html/boost_asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/initiate.html
-/doc/html/boost_asio/reference/async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_/return_type.html
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/async_result.html
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/completion_handler_type.html
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/get.html
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.html
-/doc/html/boost_asio/reference/async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_/return_type.html
-/doc/html/boost_asio/reference/async_result/return_type.html
-/doc/html/boost_asio/reference/async_write/
-/doc/html/boost_asio/reference/async_write_at/
-/doc/html/boost_asio/reference/async_write_at.html
-/doc/html/boost_asio/reference/async_write_at/overload1.html
-/doc/html/boost_asio/reference/async_write_at/overload2.html
-/doc/html/boost_asio/reference/async_write_at/overload3.html
-/doc/html/boost_asio/reference/async_write_at/overload4.html
-/doc/html/boost_asio/reference/async_write.html
-/doc/html/boost_asio/reference/async_write/overload1.html
-/doc/html/boost_asio/reference/async_write/overload2.html
-/doc/html/boost_asio/reference/async_write/overload3.html
-/doc/html/boost_asio/reference/async_write/overload4.html
-/doc/html/boost_asio/reference/async_write/overload5.html
-/doc/html/boost_asio/reference/async_write/overload6.html
-/doc/html/boost_asio/reference/async_write/overload7.html
-/doc/html/boost_asio/reference/async_write/overload8.html
-/doc/html/boost_asio/reference/AsyncWriteStream.html
-/doc/html/boost_asio/reference/awaitable/
-/doc/html/boost_asio/reference/awaitable/awaitable/
-/doc/html/boost_asio/reference/awaitable/_awaitable.html
-/doc/html/boost_asio/reference/awaitable/awaitable.html
-/doc/html/boost_asio/reference/awaitable/awaitable/overload1.html
-/doc/html/boost_asio/reference/awaitable/awaitable/overload2.html
-/doc/html/boost_asio/reference/awaitable/executor_type.html
-/doc/html/boost_asio/reference/awaitable.html
-/doc/html/boost_asio/reference/awaitable/operator_eq_.html
-/doc/html/boost_asio/reference/awaitable/valid.html
-/doc/html/boost_asio/reference/awaitable/value_type.html
-/doc/html/boost_asio/reference/bad_executor/
-/doc/html/boost_asio/reference/bad_executor/bad_executor.html
-/doc/html/boost_asio/reference/bad_executor.html
-/doc/html/boost_asio/reference/bad_executor/what.html
-/doc/html/boost_asio/reference/basic_datagram_socket/
-/doc/html/boost_asio/reference/basic_datagram_socket/assign/
-/doc/html/boost_asio/reference/basic_datagram_socket/assign.html
-/doc/html/boost_asio/reference/basic_datagram_socket/assign/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/assign/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_connect.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive/
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive_from/
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive_from.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive_from/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive_from/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_receive/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send/
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send_to/
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send_to.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send_to/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_send_to/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/async_wait.html
-/doc/html/boost_asio/reference/basic_datagram_socket/at_mark/
-/doc/html/boost_asio/reference/basic_datagram_socket/at_mark.html
-/doc/html/boost_asio/reference/basic_datagram_socket/at_mark/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/at_mark/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/available/
-/doc/html/boost_asio/reference/basic_datagram_socket/available.html
-/doc/html/boost_asio/reference/basic_datagram_socket/available/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/available/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/
-/doc/html/boost_asio/reference/basic_datagram_socket/_basic_datagram_socket.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload10.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload4.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload5.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload6.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload7.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload8.html
-/doc/html/boost_asio/reference/basic_datagram_socket/basic_datagram_socket/overload9.html
-/doc/html/boost_asio/reference/basic_datagram_socket/bind/
-/doc/html/boost_asio/reference/basic_datagram_socket/bind.html
-/doc/html/boost_asio/reference/basic_datagram_socket/bind/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/bind/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/broadcast.html
-/doc/html/boost_asio/reference/basic_datagram_socket/bytes_readable.html
-/doc/html/boost_asio/reference/basic_datagram_socket/cancel/
-/doc/html/boost_asio/reference/basic_datagram_socket/cancel.html
-/doc/html/boost_asio/reference/basic_datagram_socket/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/close/
-/doc/html/boost_asio/reference/basic_datagram_socket/close.html
-/doc/html/boost_asio/reference/basic_datagram_socket/close/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/close/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/connect/
-/doc/html/boost_asio/reference/basic_datagram_socket/connect.html
-/doc/html/boost_asio/reference/basic_datagram_socket/connect/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/connect/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/debug.html
-/doc/html/boost_asio/reference/basic_datagram_socket/do_not_route.html
-/doc/html/boost_asio/reference/basic_datagram_socket/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_datagram_socket/endpoint_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket/executor_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket/get_executor.html
-/doc/html/boost_asio/reference/basic_datagram_socket/get_option/
-/doc/html/boost_asio/reference/basic_datagram_socket/get_option.html
-/doc/html/boost_asio/reference/basic_datagram_socket/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket.html
-/doc/html/boost_asio/reference/basic_datagram_socket/io_control/
-/doc/html/boost_asio/reference/basic_datagram_socket/io_control.html
-/doc/html/boost_asio/reference/basic_datagram_socket/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/is_open.html
-/doc/html/boost_asio/reference/basic_datagram_socket/keep_alive.html
-/doc/html/boost_asio/reference/basic_datagram_socket/linger.html
-/doc/html/boost_asio/reference/basic_datagram_socket/local_endpoint/
-/doc/html/boost_asio/reference/basic_datagram_socket/local_endpoint.html
-/doc/html/boost_asio/reference/basic_datagram_socket/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/lowest_layer/
-/doc/html/boost_asio/reference/basic_datagram_socket/lowest_layer.html
-/doc/html/boost_asio/reference/basic_datagram_socket/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket/max_connections.html
-/doc/html/boost_asio/reference/basic_datagram_socket/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_datagram_socket/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_datagram_socket/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_datagram_socket/message_flags.html
-/doc/html/boost_asio/reference/basic_datagram_socket/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_datagram_socket/message_peek.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_handle.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_handle_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_non_blocking/
-/doc/html/boost_asio/reference/basic_datagram_socket/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/non_blocking/
-/doc/html/boost_asio/reference/basic_datagram_socket/non_blocking.html
-/doc/html/boost_asio/reference/basic_datagram_socket/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/open/
-/doc/html/boost_asio/reference/basic_datagram_socket/open.html
-/doc/html/boost_asio/reference/basic_datagram_socket/open/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/open/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/operator_eq_/
-/doc/html/boost_asio/reference/basic_datagram_socket/operator_eq_.html
-/doc/html/boost_asio/reference/basic_datagram_socket/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_datagram_socket/protocol_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket__rebind_executor/
-/doc/html/boost_asio/reference/basic_datagram_socket__rebind_executor.html
-/doc/html/boost_asio/reference/basic_datagram_socket__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive/
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_from/
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_from.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_from/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_from/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_from/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/receive/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/release/
-/doc/html/boost_asio/reference/basic_datagram_socket/release.html
-/doc/html/boost_asio/reference/basic_datagram_socket/release/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/release/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/remote_endpoint/
-/doc/html/boost_asio/reference/basic_datagram_socket/remote_endpoint.html
-/doc/html/boost_asio/reference/basic_datagram_socket/remote_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/remote_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/reuse_address.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send/
-/doc/html/boost_asio/reference/basic_datagram_socket/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send_to/
-/doc/html/boost_asio/reference/basic_datagram_socket/send_to.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send_to/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send_to/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/send_to/overload3.html
-/doc/html/boost_asio/reference/basic_datagram_socket/set_option/
-/doc/html/boost_asio/reference/basic_datagram_socket/set_option.html
-/doc/html/boost_asio/reference/basic_datagram_socket/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/shutdown/
-/doc/html/boost_asio/reference/basic_datagram_socket/shutdown.html
-/doc/html/boost_asio/reference/basic_datagram_socket/shutdown/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/shutdown/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/shutdown_type.html
-/doc/html/boost_asio/reference/basic_datagram_socket/wait/
-/doc/html/boost_asio/reference/basic_datagram_socket/wait.html
-/doc/html/boost_asio/reference/basic_datagram_socket/wait/overload1.html
-/doc/html/boost_asio/reference/basic_datagram_socket/wait/overload2.html
-/doc/html/boost_asio/reference/basic_datagram_socket/wait_type.html
-/doc/html/boost_asio/reference/basic_deadline_timer/
-/doc/html/boost_asio/reference/basic_deadline_timer/async_wait.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/
-/doc/html/boost_asio/reference/basic_deadline_timer/_basic_deadline_timer.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload2.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload3.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload4.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload5.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload6.html
-/doc/html/boost_asio/reference/basic_deadline_timer/basic_deadline_timer/overload7.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel/
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel_one/
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel_one.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel_one/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel_one/overload2.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_deadline_timer/duration_type.html
-/doc/html/boost_asio/reference/basic_deadline_timer/executor_type.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_at/
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_at.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_at/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_at/overload2.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_at/overload3.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_from_now/
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_from_now.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_from_now/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_from_now/overload2.html
-/doc/html/boost_asio/reference/basic_deadline_timer/expires_from_now/overload3.html
-/doc/html/boost_asio/reference/basic_deadline_timer/get_executor.html
-/doc/html/boost_asio/reference/basic_deadline_timer.html
-/doc/html/boost_asio/reference/basic_deadline_timer/operator_eq_.html
-/doc/html/boost_asio/reference/basic_deadline_timer__rebind_executor/
-/doc/html/boost_asio/reference/basic_deadline_timer__rebind_executor.html
-/doc/html/boost_asio/reference/basic_deadline_timer__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_deadline_timer/time_type.html
-/doc/html/boost_asio/reference/basic_deadline_timer/traits_type.html
-/doc/html/boost_asio/reference/basic_deadline_timer/wait/
-/doc/html/boost_asio/reference/basic_deadline_timer/wait.html
-/doc/html/boost_asio/reference/basic_deadline_timer/wait/overload1.html
-/doc/html/boost_asio/reference/basic_deadline_timer/wait/overload2.html
-/doc/html/boost_asio/reference/basic_file/
-/doc/html/boost_asio/reference/basic_file/append.html
-/doc/html/boost_asio/reference/basic_file/assign/
-/doc/html/boost_asio/reference/basic_file/assign.html
-/doc/html/boost_asio/reference/basic_file/assign/overload1.html
-/doc/html/boost_asio/reference/basic_file/assign/overload2.html
-/doc/html/boost_asio/reference/basic_file/basic_file/
-/doc/html/boost_asio/reference/basic_file/_basic_file.html
-/doc/html/boost_asio/reference/basic_file/basic_file.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload10.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload1.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload2.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload3.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload4.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload5.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload6.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload7.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload8.html
-/doc/html/boost_asio/reference/basic_file/basic_file/overload9.html
-/doc/html/boost_asio/reference/basic_file/cancel/
-/doc/html/boost_asio/reference/basic_file/cancel.html
-/doc/html/boost_asio/reference/basic_file/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_file/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_file/close/
-/doc/html/boost_asio/reference/basic_file/close.html
-/doc/html/boost_asio/reference/basic_file/close/overload1.html
-/doc/html/boost_asio/reference/basic_file/close/overload2.html
-/doc/html/boost_asio/reference/basic_file/create.html
-/doc/html/boost_asio/reference/basic_file/exclusive.html
-/doc/html/boost_asio/reference/basic_file/executor_type.html
-/doc/html/boost_asio/reference/basic_file/flags.html
-/doc/html/boost_asio/reference/basic_file/get_executor.html
-/doc/html/boost_asio/reference/basic_file.html
-/doc/html/boost_asio/reference/basic_file/is_open.html
-/doc/html/boost_asio/reference/basic_file/native_handle.html
-/doc/html/boost_asio/reference/basic_file/native_handle_type.html
-/doc/html/boost_asio/reference/basic_file/open/
-/doc/html/boost_asio/reference/basic_file/open.html
-/doc/html/boost_asio/reference/basic_file/open/overload1.html
-/doc/html/boost_asio/reference/basic_file/open/overload2.html
-/doc/html/boost_asio/reference/basic_file/open/overload3.html
-/doc/html/boost_asio/reference/basic_file/open/overload4.html
-/doc/html/boost_asio/reference/basic_file/operator_eq_/
-/doc/html/boost_asio/reference/basic_file/operator_eq_.html
-/doc/html/boost_asio/reference/basic_file/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_file/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_file/read_only.html
-/doc/html/boost_asio/reference/basic_file/read_write.html
-/doc/html/boost_asio/reference/basic_file__rebind_executor/
-/doc/html/boost_asio/reference/basic_file__rebind_executor.html
-/doc/html/boost_asio/reference/basic_file__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_file/release/
-/doc/html/boost_asio/reference/basic_file/release.html
-/doc/html/boost_asio/reference/basic_file/release/overload1.html
-/doc/html/boost_asio/reference/basic_file/release/overload2.html
-/doc/html/boost_asio/reference/basic_file/resize/
-/doc/html/boost_asio/reference/basic_file/resize.html
-/doc/html/boost_asio/reference/basic_file/resize/overload1.html
-/doc/html/boost_asio/reference/basic_file/resize/overload2.html
-/doc/html/boost_asio/reference/basic_file/seek_basis.html
-/doc/html/boost_asio/reference/basic_file/size/
-/doc/html/boost_asio/reference/basic_file/size.html
-/doc/html/boost_asio/reference/basic_file/size/overload1.html
-/doc/html/boost_asio/reference/basic_file/size/overload2.html
-/doc/html/boost_asio/reference/basic_file/sync_all/
-/doc/html/boost_asio/reference/basic_file/sync_all.html
-/doc/html/boost_asio/reference/basic_file/sync_all_on_write.html
-/doc/html/boost_asio/reference/basic_file/sync_all/overload1.html
-/doc/html/boost_asio/reference/basic_file/sync_all/overload2.html
-/doc/html/boost_asio/reference/basic_file/sync_data/
-/doc/html/boost_asio/reference/basic_file/sync_data.html
-/doc/html/boost_asio/reference/basic_file/sync_data/overload1.html
-/doc/html/boost_asio/reference/basic_file/sync_data/overload2.html
-/doc/html/boost_asio/reference/basic_file/truncate.html
-/doc/html/boost_asio/reference/basic_file/write_only.html
-/doc/html/boost_asio/reference/basic_io_object/
-/doc/html/boost_asio/reference/basic_io_object/basic_io_object/
-/doc/html/boost_asio/reference/basic_io_object/_basic_io_object.html
-/doc/html/boost_asio/reference/basic_io_object/basic_io_object.html
-/doc/html/boost_asio/reference/basic_io_object/basic_io_object/overload1.html
-/doc/html/boost_asio/reference/basic_io_object/basic_io_object/overload2.html
-/doc/html/boost_asio/reference/basic_io_object/basic_io_object/overload3.html
-/doc/html/boost_asio/reference/basic_io_object/executor_type.html
-/doc/html/boost_asio/reference/basic_io_object/get_executor.html
-/doc/html/boost_asio/reference/basic_io_object/get_implementation/
-/doc/html/boost_asio/reference/basic_io_object/get_implementation.html
-/doc/html/boost_asio/reference/basic_io_object/get_implementation/overload1.html
-/doc/html/boost_asio/reference/basic_io_object/get_implementation/overload2.html
-/doc/html/boost_asio/reference/basic_io_object/get_io_context.html
-/doc/html/boost_asio/reference/basic_io_object/get_io_service.html
-/doc/html/boost_asio/reference/basic_io_object/get_service/
-/doc/html/boost_asio/reference/basic_io_object/get_service.html
-/doc/html/boost_asio/reference/basic_io_object/get_service/overload1.html
-/doc/html/boost_asio/reference/basic_io_object/get_service/overload2.html
-/doc/html/boost_asio/reference/basic_io_object.html
-/doc/html/boost_asio/reference/basic_io_object/implementation_type.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/_basic_io_object.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload1.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload2.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/basic_io_object/overload3.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/executor_type.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_executor.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/overload1.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_implementation/overload2.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_io_context.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_io_service.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/overload1.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/get_service/overload2.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/implementation_type.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/operator_eq_.html
-/doc/html/boost_asio/reference/basic_io_object_lt__IoObjectService_comma__true__gt_/service_type.html
-/doc/html/boost_asio/reference/basic_io_object/operator_eq_.html
-/doc/html/boost_asio/reference/basic_io_object/service_type.html
-/doc/html/boost_asio/reference/basic_random_access_file/
-/doc/html/boost_asio/reference/basic_random_access_file/append.html
-/doc/html/boost_asio/reference/basic_random_access_file/assign/
-/doc/html/boost_asio/reference/basic_random_access_file/assign.html
-/doc/html/boost_asio/reference/basic_random_access_file/assign/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/assign/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/async_read_some_at.html
-/doc/html/boost_asio/reference/basic_random_access_file/async_write_some_at.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/
-/doc/html/boost_asio/reference/basic_random_access_file/_basic_random_access_file.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload10.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload3.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload4.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload5.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload6.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload7.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload8.html
-/doc/html/boost_asio/reference/basic_random_access_file/basic_random_access_file/overload9.html
-/doc/html/boost_asio/reference/basic_random_access_file/cancel/
-/doc/html/boost_asio/reference/basic_random_access_file/cancel.html
-/doc/html/boost_asio/reference/basic_random_access_file/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/close/
-/doc/html/boost_asio/reference/basic_random_access_file/close.html
-/doc/html/boost_asio/reference/basic_random_access_file/close/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/close/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/create.html
-/doc/html/boost_asio/reference/basic_random_access_file/exclusive.html
-/doc/html/boost_asio/reference/basic_random_access_file/executor_type.html
-/doc/html/boost_asio/reference/basic_random_access_file/flags.html
-/doc/html/boost_asio/reference/basic_random_access_file/get_executor.html
-/doc/html/boost_asio/reference/basic_random_access_file.html
-/doc/html/boost_asio/reference/basic_random_access_file/is_open.html
-/doc/html/boost_asio/reference/basic_random_access_file/native_handle.html
-/doc/html/boost_asio/reference/basic_random_access_file/native_handle_type.html
-/doc/html/boost_asio/reference/basic_random_access_file/open/
-/doc/html/boost_asio/reference/basic_random_access_file/open.html
-/doc/html/boost_asio/reference/basic_random_access_file/open/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/open/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/open/overload3.html
-/doc/html/boost_asio/reference/basic_random_access_file/open/overload4.html
-/doc/html/boost_asio/reference/basic_random_access_file/operator_eq_/
-/doc/html/boost_asio/reference/basic_random_access_file/operator_eq_.html
-/doc/html/boost_asio/reference/basic_random_access_file/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/read_only.html
-/doc/html/boost_asio/reference/basic_random_access_file/read_some_at/
-/doc/html/boost_asio/reference/basic_random_access_file/read_some_at.html
-/doc/html/boost_asio/reference/basic_random_access_file/read_some_at/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/read_some_at/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/read_write.html
-/doc/html/boost_asio/reference/basic_random_access_file__rebind_executor/
-/doc/html/boost_asio/reference/basic_random_access_file__rebind_executor.html
-/doc/html/boost_asio/reference/basic_random_access_file__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_random_access_file/release/
-/doc/html/boost_asio/reference/basic_random_access_file/release.html
-/doc/html/boost_asio/reference/basic_random_access_file/release/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/release/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/resize/
-/doc/html/boost_asio/reference/basic_random_access_file/resize.html
-/doc/html/boost_asio/reference/basic_random_access_file/resize/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/resize/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/seek_basis.html
-/doc/html/boost_asio/reference/basic_random_access_file/size/
-/doc/html/boost_asio/reference/basic_random_access_file/size.html
-/doc/html/boost_asio/reference/basic_random_access_file/size/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/size/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_all/
-/doc/html/boost_asio/reference/basic_random_access_file/sync_all.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_all_on_write.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_all/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_all/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_data/
-/doc/html/boost_asio/reference/basic_random_access_file/sync_data.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_data/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/sync_data/overload2.html
-/doc/html/boost_asio/reference/basic_random_access_file/truncate.html
-/doc/html/boost_asio/reference/basic_random_access_file/write_only.html
-/doc/html/boost_asio/reference/basic_random_access_file/write_some_at/
-/doc/html/boost_asio/reference/basic_random_access_file/write_some_at.html
-/doc/html/boost_asio/reference/basic_random_access_file/write_some_at/overload1.html
-/doc/html/boost_asio/reference/basic_random_access_file/write_some_at/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/
-/doc/html/boost_asio/reference/basic_raw_socket/assign/
-/doc/html/boost_asio/reference/basic_raw_socket/assign.html
-/doc/html/boost_asio/reference/basic_raw_socket/assign/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/assign/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_connect.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive/
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive_from/
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive_from.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive_from/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive_from/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_receive/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send/
-/doc/html/boost_asio/reference/basic_raw_socket/async_send.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send_to/
-/doc/html/boost_asio/reference/basic_raw_socket/async_send_to.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send_to/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_send_to/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/async_wait.html
-/doc/html/boost_asio/reference/basic_raw_socket/at_mark/
-/doc/html/boost_asio/reference/basic_raw_socket/at_mark.html
-/doc/html/boost_asio/reference/basic_raw_socket/at_mark/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/at_mark/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/available/
-/doc/html/boost_asio/reference/basic_raw_socket/available.html
-/doc/html/boost_asio/reference/basic_raw_socket/available/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/available/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/
-/doc/html/boost_asio/reference/basic_raw_socket/_basic_raw_socket.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload10.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload4.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload5.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload6.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload7.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload8.html
-/doc/html/boost_asio/reference/basic_raw_socket/basic_raw_socket/overload9.html
-/doc/html/boost_asio/reference/basic_raw_socket/bind/
-/doc/html/boost_asio/reference/basic_raw_socket/bind.html
-/doc/html/boost_asio/reference/basic_raw_socket/bind/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/bind/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/broadcast.html
-/doc/html/boost_asio/reference/basic_raw_socket/bytes_readable.html
-/doc/html/boost_asio/reference/basic_raw_socket/cancel/
-/doc/html/boost_asio/reference/basic_raw_socket/cancel.html
-/doc/html/boost_asio/reference/basic_raw_socket/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/close/
-/doc/html/boost_asio/reference/basic_raw_socket/close.html
-/doc/html/boost_asio/reference/basic_raw_socket/close/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/close/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/connect/
-/doc/html/boost_asio/reference/basic_raw_socket/connect.html
-/doc/html/boost_asio/reference/basic_raw_socket/connect/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/connect/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/debug.html
-/doc/html/boost_asio/reference/basic_raw_socket/do_not_route.html
-/doc/html/boost_asio/reference/basic_raw_socket/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_raw_socket/endpoint_type.html
-/doc/html/boost_asio/reference/basic_raw_socket/executor_type.html
-/doc/html/boost_asio/reference/basic_raw_socket/get_executor.html
-/doc/html/boost_asio/reference/basic_raw_socket/get_option/
-/doc/html/boost_asio/reference/basic_raw_socket/get_option.html
-/doc/html/boost_asio/reference/basic_raw_socket/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket.html
-/doc/html/boost_asio/reference/basic_raw_socket/io_control/
-/doc/html/boost_asio/reference/basic_raw_socket/io_control.html
-/doc/html/boost_asio/reference/basic_raw_socket/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/is_open.html
-/doc/html/boost_asio/reference/basic_raw_socket/keep_alive.html
-/doc/html/boost_asio/reference/basic_raw_socket/linger.html
-/doc/html/boost_asio/reference/basic_raw_socket/local_endpoint/
-/doc/html/boost_asio/reference/basic_raw_socket/local_endpoint.html
-/doc/html/boost_asio/reference/basic_raw_socket/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/lowest_layer/
-/doc/html/boost_asio/reference/basic_raw_socket/lowest_layer.html
-/doc/html/boost_asio/reference/basic_raw_socket/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_raw_socket/max_connections.html
-/doc/html/boost_asio/reference/basic_raw_socket/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_raw_socket/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_raw_socket/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_raw_socket/message_flags.html
-/doc/html/boost_asio/reference/basic_raw_socket/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_raw_socket/message_peek.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_handle.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_handle_type.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_non_blocking/
-/doc/html/boost_asio/reference/basic_raw_socket/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/non_blocking/
-/doc/html/boost_asio/reference/basic_raw_socket/non_blocking.html
-/doc/html/boost_asio/reference/basic_raw_socket/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/open/
-/doc/html/boost_asio/reference/basic_raw_socket/open.html
-/doc/html/boost_asio/reference/basic_raw_socket/open/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/open/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/operator_eq_/
-/doc/html/boost_asio/reference/basic_raw_socket/operator_eq_.html
-/doc/html/boost_asio/reference/basic_raw_socket/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_raw_socket/protocol_type.html
-/doc/html/boost_asio/reference/basic_raw_socket__rebind_executor/
-/doc/html/boost_asio/reference/basic_raw_socket__rebind_executor.html
-/doc/html/boost_asio/reference/basic_raw_socket__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive/
-/doc/html/boost_asio/reference/basic_raw_socket/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive_from/
-/doc/html/boost_asio/reference/basic_raw_socket/receive_from.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive_from/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive_from/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive_from/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/receive/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/release/
-/doc/html/boost_asio/reference/basic_raw_socket/release.html
-/doc/html/boost_asio/reference/basic_raw_socket/release/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/release/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/remote_endpoint/
-/doc/html/boost_asio/reference/basic_raw_socket/remote_endpoint.html
-/doc/html/boost_asio/reference/basic_raw_socket/remote_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/remote_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/reuse_address.html
-/doc/html/boost_asio/reference/basic_raw_socket/send/
-/doc/html/boost_asio/reference/basic_raw_socket/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_raw_socket/send.html
-/doc/html/boost_asio/reference/basic_raw_socket/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_raw_socket/send/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/send/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/send/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/send_to/
-/doc/html/boost_asio/reference/basic_raw_socket/send_to.html
-/doc/html/boost_asio/reference/basic_raw_socket/send_to/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/send_to/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/send_to/overload3.html
-/doc/html/boost_asio/reference/basic_raw_socket/set_option/
-/doc/html/boost_asio/reference/basic_raw_socket/set_option.html
-/doc/html/boost_asio/reference/basic_raw_socket/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/shutdown/
-/doc/html/boost_asio/reference/basic_raw_socket/shutdown.html
-/doc/html/boost_asio/reference/basic_raw_socket/shutdown/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/shutdown/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/shutdown_type.html
-/doc/html/boost_asio/reference/basic_raw_socket/wait/
-/doc/html/boost_asio/reference/basic_raw_socket/wait.html
-/doc/html/boost_asio/reference/basic_raw_socket/wait/overload1.html
-/doc/html/boost_asio/reference/basic_raw_socket/wait/overload2.html
-/doc/html/boost_asio/reference/basic_raw_socket/wait_type.html
-/doc/html/boost_asio/reference/basic_readable_pipe/
-/doc/html/boost_asio/reference/basic_readable_pipe/assign/
-/doc/html/boost_asio/reference/basic_readable_pipe/assign.html
-/doc/html/boost_asio/reference/basic_readable_pipe/assign/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/assign/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/async_read_some.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/
-/doc/html/boost_asio/reference/basic_readable_pipe/_basic_readable_pipe.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload3.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload4.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload5.html
-/doc/html/boost_asio/reference/basic_readable_pipe/basic_readable_pipe/overload6.html
-/doc/html/boost_asio/reference/basic_readable_pipe/cancel/
-/doc/html/boost_asio/reference/basic_readable_pipe/cancel.html
-/doc/html/boost_asio/reference/basic_readable_pipe/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/close/
-/doc/html/boost_asio/reference/basic_readable_pipe/close.html
-/doc/html/boost_asio/reference/basic_readable_pipe/close/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/close/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/executor_type.html
-/doc/html/boost_asio/reference/basic_readable_pipe/get_executor.html
-/doc/html/boost_asio/reference/basic_readable_pipe.html
-/doc/html/boost_asio/reference/basic_readable_pipe/is_open.html
-/doc/html/boost_asio/reference/basic_readable_pipe/lowest_layer/
-/doc/html/boost_asio/reference/basic_readable_pipe/lowest_layer.html
-/doc/html/boost_asio/reference/basic_readable_pipe/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_readable_pipe/native_handle.html
-/doc/html/boost_asio/reference/basic_readable_pipe/native_handle_type.html
-/doc/html/boost_asio/reference/basic_readable_pipe/operator_eq_/
-/doc/html/boost_asio/reference/basic_readable_pipe/operator_eq_.html
-/doc/html/boost_asio/reference/basic_readable_pipe/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe/read_some/
-/doc/html/boost_asio/reference/basic_readable_pipe/read_some.html
-/doc/html/boost_asio/reference/basic_readable_pipe/read_some/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/read_some/overload2.html
-/doc/html/boost_asio/reference/basic_readable_pipe__rebind_executor/
-/doc/html/boost_asio/reference/basic_readable_pipe__rebind_executor.html
-/doc/html/boost_asio/reference/basic_readable_pipe__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_readable_pipe/release/
-/doc/html/boost_asio/reference/basic_readable_pipe/release.html
-/doc/html/boost_asio/reference/basic_readable_pipe/release/overload1.html
-/doc/html/boost_asio/reference/basic_readable_pipe/release/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/assign/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/assign.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/assign/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/assign/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_connect.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_receive/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_receive.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_receive/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_receive/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_send.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/async_wait.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/at_mark/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/at_mark.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/at_mark/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/at_mark/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/available/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/available.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/available/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/available/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/_basic_seq_packet_socket.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload10.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload3.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload4.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload5.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload6.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload7.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload8.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/basic_seq_packet_socket/overload9.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/bind/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/bind.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/bind/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/bind/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/broadcast.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/bytes_readable.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/cancel/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/cancel.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/close/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/close.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/close/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/close/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/connect/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/connect.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/connect/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/connect/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/debug.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/do_not_route.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/endpoint_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/executor_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/get_executor.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/get_option/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/get_option.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/io_control/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/io_control.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/is_open.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/keep_alive.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/linger.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/local_endpoint/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/local_endpoint.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/lowest_layer/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/lowest_layer.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/max_connections.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/message_flags.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/message_peek.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_handle.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_handle_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_non_blocking/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/non_blocking/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/non_blocking.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/open/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/open.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/open/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/open/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/operator_eq_/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/operator_eq_.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/protocol_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket__rebind_executor/
-/doc/html/boost_asio/reference/basic_seq_packet_socket__rebind_executor.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/receive/overload3.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/release/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/release.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/release/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/release/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/remote_endpoint/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/remote_endpoint.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/remote_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/remote_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/reuse_address.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/send/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/set_option/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/set_option.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/shutdown/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/shutdown.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/shutdown/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/shutdown/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/shutdown_type.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/wait/
-/doc/html/boost_asio/reference/basic_seq_packet_socket/wait.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/wait/overload1.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/wait/overload2.html
-/doc/html/boost_asio/reference/basic_seq_packet_socket/wait_type.html
-/doc/html/boost_asio/reference/basic_serial_port/
-/doc/html/boost_asio/reference/basic_serial_port/assign/
-/doc/html/boost_asio/reference/basic_serial_port/assign.html
-/doc/html/boost_asio/reference/basic_serial_port/assign/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/assign/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/async_read_some.html
-/doc/html/boost_asio/reference/basic_serial_port/async_write_some.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/
-/doc/html/boost_asio/reference/basic_serial_port/_basic_serial_port.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload10.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload3.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload4.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload5.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload6.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload7.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload8.html
-/doc/html/boost_asio/reference/basic_serial_port/basic_serial_port/overload9.html
-/doc/html/boost_asio/reference/basic_serial_port/cancel/
-/doc/html/boost_asio/reference/basic_serial_port/cancel.html
-/doc/html/boost_asio/reference/basic_serial_port/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/close/
-/doc/html/boost_asio/reference/basic_serial_port/close.html
-/doc/html/boost_asio/reference/basic_serial_port/close/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/close/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/executor_type.html
-/doc/html/boost_asio/reference/basic_serial_port/get_executor.html
-/doc/html/boost_asio/reference/basic_serial_port/get_option/
-/doc/html/boost_asio/reference/basic_serial_port/get_option.html
-/doc/html/boost_asio/reference/basic_serial_port/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port.html
-/doc/html/boost_asio/reference/basic_serial_port/is_open.html
-/doc/html/boost_asio/reference/basic_serial_port/lowest_layer/
-/doc/html/boost_asio/reference/basic_serial_port/lowest_layer.html
-/doc/html/boost_asio/reference/basic_serial_port/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_serial_port/native_handle.html
-/doc/html/boost_asio/reference/basic_serial_port/native_handle_type.html
-/doc/html/boost_asio/reference/basic_serial_port/open/
-/doc/html/boost_asio/reference/basic_serial_port/open.html
-/doc/html/boost_asio/reference/basic_serial_port/open/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/open/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/operator_eq_/
-/doc/html/boost_asio/reference/basic_serial_port/operator_eq_.html
-/doc/html/boost_asio/reference/basic_serial_port/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/read_some/
-/doc/html/boost_asio/reference/basic_serial_port/read_some.html
-/doc/html/boost_asio/reference/basic_serial_port/read_some/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/read_some/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port__rebind_executor/
-/doc/html/boost_asio/reference/basic_serial_port__rebind_executor.html
-/doc/html/boost_asio/reference/basic_serial_port__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_serial_port/send_break/
-/doc/html/boost_asio/reference/basic_serial_port/send_break.html
-/doc/html/boost_asio/reference/basic_serial_port/send_break/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/send_break/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/set_option/
-/doc/html/boost_asio/reference/basic_serial_port/set_option.html
-/doc/html/boost_asio/reference/basic_serial_port/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_serial_port/write_some/
-/doc/html/boost_asio/reference/basic_serial_port/write_some.html
-/doc/html/boost_asio/reference/basic_serial_port/write_some/overload1.html
-/doc/html/boost_asio/reference/basic_serial_port/write_some/overload2.html
-/doc/html/boost_asio/reference/basic_signal_set/
-/doc/html/boost_asio/reference/basic_signal_set/add/
-/doc/html/boost_asio/reference/basic_signal_set/add.html
-/doc/html/boost_asio/reference/basic_signal_set/add/overload1.html
-/doc/html/boost_asio/reference/basic_signal_set/add/overload2.html
-/doc/html/boost_asio/reference/basic_signal_set/add/overload3.html
-/doc/html/boost_asio/reference/basic_signal_set/add/overload4.html
-/doc/html/boost_asio/reference/basic_signal_set/async_wait.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/
-/doc/html/boost_asio/reference/basic_signal_set/_basic_signal_set.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload1.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload2.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload3.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload4.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload5.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload6.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload7.html
-/doc/html/boost_asio/reference/basic_signal_set/basic_signal_set/overload8.html
-/doc/html/boost_asio/reference/basic_signal_set/cancel/
-/doc/html/boost_asio/reference/basic_signal_set/cancel.html
-/doc/html/boost_asio/reference/basic_signal_set/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_signal_set/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_signal_set/clear/
-/doc/html/boost_asio/reference/basic_signal_set/clear.html
-/doc/html/boost_asio/reference/basic_signal_set/clear/overload1.html
-/doc/html/boost_asio/reference/basic_signal_set/clear/overload2.html
-/doc/html/boost_asio/reference/basic_signal_set/executor_type.html
-/doc/html/boost_asio/reference/basic_signal_set/flags.html
-/doc/html/boost_asio/reference/basic_signal_set/flags_t.html
-/doc/html/boost_asio/reference/basic_signal_set/get_executor.html
-/doc/html/boost_asio/reference/basic_signal_set.html
-/doc/html/boost_asio/reference/basic_signal_set__rebind_executor/
-/doc/html/boost_asio/reference/basic_signal_set__rebind_executor.html
-/doc/html/boost_asio/reference/basic_signal_set__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_signal_set/remove/
-/doc/html/boost_asio/reference/basic_signal_set/remove.html
-/doc/html/boost_asio/reference/basic_signal_set/remove/overload1.html
-/doc/html/boost_asio/reference/basic_signal_set/remove/overload2.html
-/doc/html/boost_asio/reference/basic_socket/
-/doc/html/boost_asio/reference/basic_socket_acceptor/
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload10.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload11.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload12.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload13.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload14.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload15.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload16.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload3.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload4.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload5.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload6.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload7.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload8.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/accept/overload9.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/assign/
-/doc/html/boost_asio/reference/basic_socket_acceptor/assign.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/assign/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/assign/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload3.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload4.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload5.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload6.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload7.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_accept/overload8.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/async_wait.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/
-/doc/html/boost_asio/reference/basic_socket_acceptor/_basic_socket_acceptor.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload10.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload3.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload4.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload5.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload6.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload7.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload8.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/basic_socket_acceptor/overload9.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/bind/
-/doc/html/boost_asio/reference/basic_socket_acceptor/bind.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/bind/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/bind/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/broadcast.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/bytes_readable.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/cancel/
-/doc/html/boost_asio/reference/basic_socket_acceptor/cancel.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/close/
-/doc/html/boost_asio/reference/basic_socket_acceptor/close.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/close/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/close/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/debug.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/do_not_route.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/endpoint_type.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/executor_type.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/get_executor.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/get_option/
-/doc/html/boost_asio/reference/basic_socket_acceptor/get_option.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/io_control/
-/doc/html/boost_asio/reference/basic_socket_acceptor/io_control.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/is_open.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/keep_alive.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/linger.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/listen/
-/doc/html/boost_asio/reference/basic_socket_acceptor/listen.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/listen/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/listen/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/local_endpoint/
-/doc/html/boost_asio/reference/basic_socket_acceptor/local_endpoint.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/max_connections.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/message_flags.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/message_peek.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_handle.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_handle_type.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_non_blocking/
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/non_blocking/
-/doc/html/boost_asio/reference/basic_socket_acceptor/non_blocking.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/open/
-/doc/html/boost_asio/reference/basic_socket_acceptor/open.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/open/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/open/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/operator_eq_/
-/doc/html/boost_asio/reference/basic_socket_acceptor/operator_eq_.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/protocol_type.html
-/doc/html/boost_asio/reference/basic_socket_acceptor__rebind_executor/
-/doc/html/boost_asio/reference/basic_socket_acceptor__rebind_executor.html
-/doc/html/boost_asio/reference/basic_socket_acceptor__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/release/
-/doc/html/boost_asio/reference/basic_socket_acceptor/release.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/release/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/release/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/reuse_address.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/set_option/
-/doc/html/boost_asio/reference/basic_socket_acceptor/set_option.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/shutdown_type.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/wait/
-/doc/html/boost_asio/reference/basic_socket_acceptor/wait.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/wait/overload1.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/wait/overload2.html
-/doc/html/boost_asio/reference/basic_socket_acceptor/wait_type.html
-/doc/html/boost_asio/reference/basic_socket/assign/
-/doc/html/boost_asio/reference/basic_socket/assign.html
-/doc/html/boost_asio/reference/basic_socket/assign/overload1.html
-/doc/html/boost_asio/reference/basic_socket/assign/overload2.html
-/doc/html/boost_asio/reference/basic_socket/async_connect.html
-/doc/html/boost_asio/reference/basic_socket/async_wait.html
-/doc/html/boost_asio/reference/basic_socket/at_mark/
-/doc/html/boost_asio/reference/basic_socket/at_mark.html
-/doc/html/boost_asio/reference/basic_socket/at_mark/overload1.html
-/doc/html/boost_asio/reference/basic_socket/at_mark/overload2.html
-/doc/html/boost_asio/reference/basic_socket/available/
-/doc/html/boost_asio/reference/basic_socket/available.html
-/doc/html/boost_asio/reference/basic_socket/available/overload1.html
-/doc/html/boost_asio/reference/basic_socket/available/overload2.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/
-/doc/html/boost_asio/reference/basic_socket/_basic_socket.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload10.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload1.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload2.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload3.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload4.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload5.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload6.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload7.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload8.html
-/doc/html/boost_asio/reference/basic_socket/basic_socket/overload9.html
-/doc/html/boost_asio/reference/basic_socket/bind/
-/doc/html/boost_asio/reference/basic_socket/bind.html
-/doc/html/boost_asio/reference/basic_socket/bind/overload1.html
-/doc/html/boost_asio/reference/basic_socket/bind/overload2.html
-/doc/html/boost_asio/reference/basic_socket/broadcast.html
-/doc/html/boost_asio/reference/basic_socket/bytes_readable.html
-/doc/html/boost_asio/reference/basic_socket/cancel/
-/doc/html/boost_asio/reference/basic_socket/cancel.html
-/doc/html/boost_asio/reference/basic_socket/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_socket/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_socket/close/
-/doc/html/boost_asio/reference/basic_socket/close.html
-/doc/html/boost_asio/reference/basic_socket/close/overload1.html
-/doc/html/boost_asio/reference/basic_socket/close/overload2.html
-/doc/html/boost_asio/reference/basic_socket/connect/
-/doc/html/boost_asio/reference/basic_socket/connect.html
-/doc/html/boost_asio/reference/basic_socket/connect/overload1.html
-/doc/html/boost_asio/reference/basic_socket/connect/overload2.html
-/doc/html/boost_asio/reference/basic_socket/debug.html
-/doc/html/boost_asio/reference/basic_socket/do_not_route.html
-/doc/html/boost_asio/reference/basic_socket/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_socket/endpoint_type.html
-/doc/html/boost_asio/reference/basic_socket/executor_type.html
-/doc/html/boost_asio/reference/basic_socket/get_executor.html
-/doc/html/boost_asio/reference/basic_socket/get_option/
-/doc/html/boost_asio/reference/basic_socket/get_option.html
-/doc/html/boost_asio/reference/basic_socket/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_socket/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_socket.html
-/doc/html/boost_asio/reference/basic_socket/io_control/
-/doc/html/boost_asio/reference/basic_socket/io_control.html
-/doc/html/boost_asio/reference/basic_socket/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_socket/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_socket_iostream/
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream/
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream.html
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream/overload1.html
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream/overload2.html
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream/overload3.html
-/doc/html/boost_asio/reference/basic_socket_iostream/basic_socket_iostream/overload4.html
-/doc/html/boost_asio/reference/basic_socket_iostream/clock_type.html
-/doc/html/boost_asio/reference/basic_socket_iostream/close.html
-/doc/html/boost_asio/reference/basic_socket_iostream/connect.html
-/doc/html/boost_asio/reference/basic_socket_iostream/duration.html
-/doc/html/boost_asio/reference/basic_socket_iostream/duration_type.html
-/doc/html/boost_asio/reference/basic_socket_iostream/endpoint_type.html
-/doc/html/boost_asio/reference/basic_socket_iostream/error.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_after.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_at/
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_at.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_at/overload1.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_at/overload2.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_from_now/
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_from_now.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_from_now/overload1.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expires_from_now/overload2.html
-/doc/html/boost_asio/reference/basic_socket_iostream/expiry.html
-/doc/html/boost_asio/reference/basic_socket_iostream.html
-/doc/html/boost_asio/reference/basic_socket_iostream/operator_eq_.html
-/doc/html/boost_asio/reference/basic_socket_iostream/protocol_type.html
-/doc/html/boost_asio/reference/basic_socket_iostream/rdbuf.html
-/doc/html/boost_asio/reference/basic_socket_iostream/socket.html
-/doc/html/boost_asio/reference/basic_socket_iostream/time_point.html
-/doc/html/boost_asio/reference/basic_socket_iostream/time_type.html
-/doc/html/boost_asio/reference/basic_socket/is_open.html
-/doc/html/boost_asio/reference/basic_socket/keep_alive.html
-/doc/html/boost_asio/reference/basic_socket/linger.html
-/doc/html/boost_asio/reference/basic_socket/local_endpoint/
-/doc/html/boost_asio/reference/basic_socket/local_endpoint.html
-/doc/html/boost_asio/reference/basic_socket/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_socket/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_socket/lowest_layer/
-/doc/html/boost_asio/reference/basic_socket/lowest_layer.html
-/doc/html/boost_asio/reference/basic_socket/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_socket/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_socket/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_socket/max_connections.html
-/doc/html/boost_asio/reference/basic_socket/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_socket/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_socket/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_socket/message_flags.html
-/doc/html/boost_asio/reference/basic_socket/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_socket/message_peek.html
-/doc/html/boost_asio/reference/basic_socket/native_handle.html
-/doc/html/boost_asio/reference/basic_socket/native_handle_type.html
-/doc/html/boost_asio/reference/basic_socket/native_non_blocking/
-/doc/html/boost_asio/reference/basic_socket/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_socket/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_socket/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_socket/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_socket/non_blocking/
-/doc/html/boost_asio/reference/basic_socket/non_blocking.html
-/doc/html/boost_asio/reference/basic_socket/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_socket/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_socket/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_socket/open/
-/doc/html/boost_asio/reference/basic_socket/open.html
-/doc/html/boost_asio/reference/basic_socket/open/overload1.html
-/doc/html/boost_asio/reference/basic_socket/open/overload2.html
-/doc/html/boost_asio/reference/basic_socket/operator_eq_/
-/doc/html/boost_asio/reference/basic_socket/operator_eq_.html
-/doc/html/boost_asio/reference/basic_socket/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_socket/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_socket/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_socket/protocol_type.html
-/doc/html/boost_asio/reference/basic_socket__rebind_executor/
-/doc/html/boost_asio/reference/basic_socket__rebind_executor.html
-/doc/html/boost_asio/reference/basic_socket__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_socket/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_socket/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_socket/release/
-/doc/html/boost_asio/reference/basic_socket/release.html
-/doc/html/boost_asio/reference/basic_socket/release/overload1.html
-/doc/html/boost_asio/reference/basic_socket/release/overload2.html
-/doc/html/boost_asio/reference/basic_socket/remote_endpoint/
-/doc/html/boost_asio/reference/basic_socket/remote_endpoint.html
-/doc/html/boost_asio/reference/basic_socket/remote_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_socket/remote_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_socket/reuse_address.html
-/doc/html/boost_asio/reference/basic_socket/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_socket/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_socket/set_option/
-/doc/html/boost_asio/reference/basic_socket/set_option.html
-/doc/html/boost_asio/reference/basic_socket/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_socket/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_socket/shutdown/
-/doc/html/boost_asio/reference/basic_socket/shutdown.html
-/doc/html/boost_asio/reference/basic_socket/shutdown/overload1.html
-/doc/html/boost_asio/reference/basic_socket/shutdown/overload2.html
-/doc/html/boost_asio/reference/basic_socket/shutdown_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/
-/doc/html/boost_asio/reference/basic_socket_streambuf/basic_socket_streambuf/
-/doc/html/boost_asio/reference/basic_socket_streambuf/_basic_socket_streambuf.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/basic_socket_streambuf.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload1.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload2.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/basic_socket_streambuf/overload3.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/clock_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/close.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/connect/
-/doc/html/boost_asio/reference/basic_socket_streambuf/connect.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/connect/overload1.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/connect/overload2.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/duration.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/duration_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/endpoint_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/error.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_after.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_at/
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_at.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_at/overload1.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_at/overload2.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_from_now/
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_from_now.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_from_now/overload1.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expires_from_now/overload2.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/expiry.html
-/doc/html/boost_asio/reference/basic_socket_streambuf.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/operator_eq_.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/overflow.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/protocol_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/puberror.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/setbuf.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/socket.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/sync.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/time_point.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/time_type.html
-/doc/html/boost_asio/reference/basic_socket_streambuf/underflow.html
-/doc/html/boost_asio/reference/basic_socket/wait/
-/doc/html/boost_asio/reference/basic_socket/wait.html
-/doc/html/boost_asio/reference/basic_socket/wait/overload1.html
-/doc/html/boost_asio/reference/basic_socket/wait/overload2.html
-/doc/html/boost_asio/reference/basic_socket/wait_type.html
-/doc/html/boost_asio/reference/basic_streambuf/
-/doc/html/boost_asio/reference/basic_streambuf/basic_streambuf.html
-/doc/html/boost_asio/reference/basic_streambuf/capacity.html
-/doc/html/boost_asio/reference/basic_streambuf/commit.html
-/doc/html/boost_asio/reference/basic_streambuf/const_buffers_type.html
-/doc/html/boost_asio/reference/basic_streambuf/consume.html
-/doc/html/boost_asio/reference/basic_streambuf/data.html
-/doc/html/boost_asio/reference/basic_streambuf.html
-/doc/html/boost_asio/reference/basic_streambuf/max_size.html
-/doc/html/boost_asio/reference/basic_streambuf/mutable_buffers_type.html
-/doc/html/boost_asio/reference/basic_streambuf/overflow.html
-/doc/html/boost_asio/reference/basic_streambuf/prepare.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/
-/doc/html/boost_asio/reference/basic_streambuf_ref/basic_streambuf_ref/
-/doc/html/boost_asio/reference/basic_streambuf_ref/basic_streambuf_ref.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload1.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload2.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/basic_streambuf_ref/overload3.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/capacity.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/commit.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/const_buffers_type.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/consume.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/data.html
-/doc/html/boost_asio/reference/basic_streambuf_ref.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/max_size.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/mutable_buffers_type.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/prepare.html
-/doc/html/boost_asio/reference/basic_streambuf_ref/size.html
-/doc/html/boost_asio/reference/basic_streambuf/reserve.html
-/doc/html/boost_asio/reference/basic_streambuf/size.html
-/doc/html/boost_asio/reference/basic_streambuf/underflow.html
-/doc/html/boost_asio/reference/basic_stream_file/
-/doc/html/boost_asio/reference/basic_stream_file/append.html
-/doc/html/boost_asio/reference/basic_stream_file/assign/
-/doc/html/boost_asio/reference/basic_stream_file/assign.html
-/doc/html/boost_asio/reference/basic_stream_file/assign/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/assign/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/async_read_some.html
-/doc/html/boost_asio/reference/basic_stream_file/async_write_some.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/
-/doc/html/boost_asio/reference/basic_stream_file/_basic_stream_file.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload10.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload3.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload4.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload5.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload6.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload7.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload8.html
-/doc/html/boost_asio/reference/basic_stream_file/basic_stream_file/overload9.html
-/doc/html/boost_asio/reference/basic_stream_file/cancel/
-/doc/html/boost_asio/reference/basic_stream_file/cancel.html
-/doc/html/boost_asio/reference/basic_stream_file/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/close/
-/doc/html/boost_asio/reference/basic_stream_file/close.html
-/doc/html/boost_asio/reference/basic_stream_file/close/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/close/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/create.html
-/doc/html/boost_asio/reference/basic_stream_file/exclusive.html
-/doc/html/boost_asio/reference/basic_stream_file/executor_type.html
-/doc/html/boost_asio/reference/basic_stream_file/flags.html
-/doc/html/boost_asio/reference/basic_stream_file/get_executor.html
-/doc/html/boost_asio/reference/basic_stream_file.html
-/doc/html/boost_asio/reference/basic_stream_file/is_open.html
-/doc/html/boost_asio/reference/basic_stream_file/native_handle.html
-/doc/html/boost_asio/reference/basic_stream_file/native_handle_type.html
-/doc/html/boost_asio/reference/basic_stream_file/open/
-/doc/html/boost_asio/reference/basic_stream_file/open.html
-/doc/html/boost_asio/reference/basic_stream_file/open/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/open/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/open/overload3.html
-/doc/html/boost_asio/reference/basic_stream_file/open/overload4.html
-/doc/html/boost_asio/reference/basic_stream_file/operator_eq_/
-/doc/html/boost_asio/reference/basic_stream_file/operator_eq_.html
-/doc/html/boost_asio/reference/basic_stream_file/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/read_only.html
-/doc/html/boost_asio/reference/basic_stream_file/read_some/
-/doc/html/boost_asio/reference/basic_stream_file/read_some.html
-/doc/html/boost_asio/reference/basic_stream_file/read_some/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/read_some/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/read_write.html
-/doc/html/boost_asio/reference/basic_stream_file__rebind_executor/
-/doc/html/boost_asio/reference/basic_stream_file__rebind_executor.html
-/doc/html/boost_asio/reference/basic_stream_file__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_stream_file/release/
-/doc/html/boost_asio/reference/basic_stream_file/release.html
-/doc/html/boost_asio/reference/basic_stream_file/release/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/release/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/resize/
-/doc/html/boost_asio/reference/basic_stream_file/resize.html
-/doc/html/boost_asio/reference/basic_stream_file/resize/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/resize/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/seek/
-/doc/html/boost_asio/reference/basic_stream_file/seek_basis.html
-/doc/html/boost_asio/reference/basic_stream_file/seek.html
-/doc/html/boost_asio/reference/basic_stream_file/seek/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/seek/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/size/
-/doc/html/boost_asio/reference/basic_stream_file/size.html
-/doc/html/boost_asio/reference/basic_stream_file/size/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/size/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_all/
-/doc/html/boost_asio/reference/basic_stream_file/sync_all.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_all_on_write.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_all/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_all/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_data/
-/doc/html/boost_asio/reference/basic_stream_file/sync_data.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_data/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/sync_data/overload2.html
-/doc/html/boost_asio/reference/basic_stream_file/truncate.html
-/doc/html/boost_asio/reference/basic_stream_file/write_only.html
-/doc/html/boost_asio/reference/basic_stream_file/write_some/
-/doc/html/boost_asio/reference/basic_stream_file/write_some.html
-/doc/html/boost_asio/reference/basic_stream_file/write_some/overload1.html
-/doc/html/boost_asio/reference/basic_stream_file/write_some/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/
-/doc/html/boost_asio/reference/basic_stream_socket/assign/
-/doc/html/boost_asio/reference/basic_stream_socket/assign.html
-/doc/html/boost_asio/reference/basic_stream_socket/assign/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/assign/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_connect.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_read_some.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_receive/
-/doc/html/boost_asio/reference/basic_stream_socket/async_receive.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_receive/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_receive/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_send/
-/doc/html/boost_asio/reference/basic_stream_socket/async_send.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_send/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_send/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_wait.html
-/doc/html/boost_asio/reference/basic_stream_socket/async_write_some.html
-/doc/html/boost_asio/reference/basic_stream_socket/at_mark/
-/doc/html/boost_asio/reference/basic_stream_socket/at_mark.html
-/doc/html/boost_asio/reference/basic_stream_socket/at_mark/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/at_mark/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/available/
-/doc/html/boost_asio/reference/basic_stream_socket/available.html
-/doc/html/boost_asio/reference/basic_stream_socket/available/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/available/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/
-/doc/html/boost_asio/reference/basic_stream_socket/_basic_stream_socket.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload10.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload3.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload4.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload5.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload6.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload7.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload8.html
-/doc/html/boost_asio/reference/basic_stream_socket/basic_stream_socket/overload9.html
-/doc/html/boost_asio/reference/basic_stream_socket/bind/
-/doc/html/boost_asio/reference/basic_stream_socket/bind.html
-/doc/html/boost_asio/reference/basic_stream_socket/bind/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/bind/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/broadcast.html
-/doc/html/boost_asio/reference/basic_stream_socket/bytes_readable.html
-/doc/html/boost_asio/reference/basic_stream_socket/cancel/
-/doc/html/boost_asio/reference/basic_stream_socket/cancel.html
-/doc/html/boost_asio/reference/basic_stream_socket/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/close/
-/doc/html/boost_asio/reference/basic_stream_socket/close.html
-/doc/html/boost_asio/reference/basic_stream_socket/close/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/close/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/connect/
-/doc/html/boost_asio/reference/basic_stream_socket/connect.html
-/doc/html/boost_asio/reference/basic_stream_socket/connect/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/connect/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/debug.html
-/doc/html/boost_asio/reference/basic_stream_socket/do_not_route.html
-/doc/html/boost_asio/reference/basic_stream_socket/enable_connection_aborted.html
-/doc/html/boost_asio/reference/basic_stream_socket/endpoint_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/executor_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/get_executor.html
-/doc/html/boost_asio/reference/basic_stream_socket/get_option/
-/doc/html/boost_asio/reference/basic_stream_socket/get_option.html
-/doc/html/boost_asio/reference/basic_stream_socket/get_option/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/get_option/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket.html
-/doc/html/boost_asio/reference/basic_stream_socket/io_control/
-/doc/html/boost_asio/reference/basic_stream_socket/io_control.html
-/doc/html/boost_asio/reference/basic_stream_socket/io_control/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/io_control/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/is_open.html
-/doc/html/boost_asio/reference/basic_stream_socket/keep_alive.html
-/doc/html/boost_asio/reference/basic_stream_socket/linger.html
-/doc/html/boost_asio/reference/basic_stream_socket/local_endpoint/
-/doc/html/boost_asio/reference/basic_stream_socket/local_endpoint.html
-/doc/html/boost_asio/reference/basic_stream_socket/local_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/local_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/lowest_layer/
-/doc/html/boost_asio/reference/basic_stream_socket/lowest_layer.html
-/doc/html/boost_asio/reference/basic_stream_socket/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/max_connections.html
-/doc/html/boost_asio/reference/basic_stream_socket/max_listen_connections.html
-/doc/html/boost_asio/reference/basic_stream_socket/message_do_not_route.html
-/doc/html/boost_asio/reference/basic_stream_socket/message_end_of_record.html
-/doc/html/boost_asio/reference/basic_stream_socket/message_flags.html
-/doc/html/boost_asio/reference/basic_stream_socket/message_out_of_band.html
-/doc/html/boost_asio/reference/basic_stream_socket/message_peek.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_handle.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_handle_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking/
-/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_stream_socket/non_blocking/
-/doc/html/boost_asio/reference/basic_stream_socket/non_blocking.html
-/doc/html/boost_asio/reference/basic_stream_socket/non_blocking/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/non_blocking/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/non_blocking/overload3.html
-/doc/html/boost_asio/reference/basic_stream_socket/open/
-/doc/html/boost_asio/reference/basic_stream_socket/open.html
-/doc/html/boost_asio/reference/basic_stream_socket/open/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/open/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/operator_eq_/
-/doc/html/boost_asio/reference/basic_stream_socket/operator_eq_.html
-/doc/html/boost_asio/reference/basic_stream_socket/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/out_of_band_inline.html
-/doc/html/boost_asio/reference/basic_stream_socket/protocol_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/read_some/
-/doc/html/boost_asio/reference/basic_stream_socket/read_some.html
-/doc/html/boost_asio/reference/basic_stream_socket/read_some/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/read_some/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket__rebind_executor/
-/doc/html/boost_asio/reference/basic_stream_socket__rebind_executor.html
-/doc/html/boost_asio/reference/basic_stream_socket__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive/
-/doc/html/boost_asio/reference/basic_stream_socket/receive_buffer_size.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive_low_watermark.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/receive/overload3.html
-/doc/html/boost_asio/reference/basic_stream_socket/release/
-/doc/html/boost_asio/reference/basic_stream_socket/release.html
-/doc/html/boost_asio/reference/basic_stream_socket/release/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/release/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/remote_endpoint/
-/doc/html/boost_asio/reference/basic_stream_socket/remote_endpoint.html
-/doc/html/boost_asio/reference/basic_stream_socket/remote_endpoint/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/remote_endpoint/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/reuse_address.html
-/doc/html/boost_asio/reference/basic_stream_socket/send/
-/doc/html/boost_asio/reference/basic_stream_socket/send_buffer_size.html
-/doc/html/boost_asio/reference/basic_stream_socket/send.html
-/doc/html/boost_asio/reference/basic_stream_socket/send_low_watermark.html
-/doc/html/boost_asio/reference/basic_stream_socket/send/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/send/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/send/overload3.html
-/doc/html/boost_asio/reference/basic_stream_socket/set_option/
-/doc/html/boost_asio/reference/basic_stream_socket/set_option.html
-/doc/html/boost_asio/reference/basic_stream_socket/set_option/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/set_option/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/shutdown/
-/doc/html/boost_asio/reference/basic_stream_socket/shutdown.html
-/doc/html/boost_asio/reference/basic_stream_socket/shutdown/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/shutdown/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/shutdown_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/wait/
-/doc/html/boost_asio/reference/basic_stream_socket/wait.html
-/doc/html/boost_asio/reference/basic_stream_socket/wait/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/wait/overload2.html
-/doc/html/boost_asio/reference/basic_stream_socket/wait_type.html
-/doc/html/boost_asio/reference/basic_stream_socket/write_some/
-/doc/html/boost_asio/reference/basic_stream_socket/write_some.html
-/doc/html/boost_asio/reference/basic_stream_socket/write_some/overload1.html
-/doc/html/boost_asio/reference/basic_stream_socket/write_some/overload2.html
-/doc/html/boost_asio/reference/basic_system_executor/
-/doc/html/boost_asio/reference/basic_system_executor/basic_system_executor.html
-/doc/html/boost_asio/reference/basic_system_executor/context.html
-/doc/html/boost_asio/reference/basic_system_executor/defer.html
-/doc/html/boost_asio/reference/basic_system_executor/dispatch.html
-/doc/html/boost_asio/reference/basic_system_executor/execute.html
-/doc/html/boost_asio/reference/basic_system_executor.html
-/doc/html/boost_asio/reference/basic_system_executor/on_work_finished.html
-/doc/html/boost_asio/reference/basic_system_executor/on_work_started.html
-/doc/html/boost_asio/reference/basic_system_executor/operator_eq__eq_.html
-/doc/html/boost_asio/reference/basic_system_executor/operator_not__eq_.html
-/doc/html/boost_asio/reference/basic_system_executor/post.html
-/doc/html/boost_asio/reference/basic_system_executor/query/
-/doc/html/boost_asio/reference/basic_system_executor/query.html
-/doc/html/boost_asio/reference/basic_system_executor/query/overload1.html
-/doc/html/boost_asio/reference/basic_system_executor/query/overload2.html
-/doc/html/boost_asio/reference/basic_system_executor/query/overload3.html
-/doc/html/boost_asio/reference/basic_system_executor/query__static/
-/doc/html/boost_asio/reference/basic_system_executor/query__static.html
-/doc/html/boost_asio/reference/basic_system_executor/query__static/overload1.html
-/doc/html/boost_asio/reference/basic_system_executor/query__static/overload2.html
-/doc/html/boost_asio/reference/basic_system_executor/query__static/overload3.html
-/doc/html/boost_asio/reference/basic_system_executor/query__static/overload4.html
-/doc/html/boost_asio/reference/basic_system_executor/require/
-/doc/html/boost_asio/reference/basic_system_executor/require.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload1.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload2.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload3.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload4.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload5.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload6.html
-/doc/html/boost_asio/reference/basic_system_executor/require/overload7.html
-/doc/html/boost_asio/reference/basic_waitable_timer/
-/doc/html/boost_asio/reference/basic_waitable_timer/async_wait.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/
-/doc/html/boost_asio/reference/basic_waitable_timer/_basic_waitable_timer.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload3.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload4.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload5.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload6.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload7.html
-/doc/html/boost_asio/reference/basic_waitable_timer/basic_waitable_timer/overload8.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel/
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel_one/
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel_one.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel_one/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel_one/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer/clock_type.html
-/doc/html/boost_asio/reference/basic_waitable_timer/duration.html
-/doc/html/boost_asio/reference/basic_waitable_timer/executor_type.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_after.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_at/
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_at.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_at/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_at/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_at/overload3.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_from_now/
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_from_now.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_from_now/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_from_now/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expires_from_now/overload3.html
-/doc/html/boost_asio/reference/basic_waitable_timer/expiry.html
-/doc/html/boost_asio/reference/basic_waitable_timer/get_executor.html
-/doc/html/boost_asio/reference/basic_waitable_timer.html
-/doc/html/boost_asio/reference/basic_waitable_timer/operator_eq_/
-/doc/html/boost_asio/reference/basic_waitable_timer/operator_eq_.html
-/doc/html/boost_asio/reference/basic_waitable_timer/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_waitable_timer__rebind_executor/
-/doc/html/boost_asio/reference/basic_waitable_timer__rebind_executor.html
-/doc/html/boost_asio/reference/basic_waitable_timer__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_waitable_timer/time_point.html
-/doc/html/boost_asio/reference/basic_waitable_timer/traits_type.html
-/doc/html/boost_asio/reference/basic_waitable_timer/wait/
-/doc/html/boost_asio/reference/basic_waitable_timer/wait.html
-/doc/html/boost_asio/reference/basic_waitable_timer/wait/overload1.html
-/doc/html/boost_asio/reference/basic_waitable_timer/wait/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/
-/doc/html/boost_asio/reference/basic_writable_pipe/assign/
-/doc/html/boost_asio/reference/basic_writable_pipe/assign.html
-/doc/html/boost_asio/reference/basic_writable_pipe/assign/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/assign/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/async_write_some.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/
-/doc/html/boost_asio/reference/basic_writable_pipe/_basic_writable_pipe.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload3.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload4.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload5.html
-/doc/html/boost_asio/reference/basic_writable_pipe/basic_writable_pipe/overload6.html
-/doc/html/boost_asio/reference/basic_writable_pipe/cancel/
-/doc/html/boost_asio/reference/basic_writable_pipe/cancel.html
-/doc/html/boost_asio/reference/basic_writable_pipe/cancel/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/cancel/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/close/
-/doc/html/boost_asio/reference/basic_writable_pipe/close.html
-/doc/html/boost_asio/reference/basic_writable_pipe/close/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/close/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/executor_type.html
-/doc/html/boost_asio/reference/basic_writable_pipe/get_executor.html
-/doc/html/boost_asio/reference/basic_writable_pipe.html
-/doc/html/boost_asio/reference/basic_writable_pipe/is_open.html
-/doc/html/boost_asio/reference/basic_writable_pipe/lowest_layer/
-/doc/html/boost_asio/reference/basic_writable_pipe/lowest_layer.html
-/doc/html/boost_asio/reference/basic_writable_pipe/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/lowest_layer_type.html
-/doc/html/boost_asio/reference/basic_writable_pipe/native_handle.html
-/doc/html/boost_asio/reference/basic_writable_pipe/native_handle_type.html
-/doc/html/boost_asio/reference/basic_writable_pipe/operator_eq_/
-/doc/html/boost_asio/reference/basic_writable_pipe/operator_eq_.html
-/doc/html/boost_asio/reference/basic_writable_pipe/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe__rebind_executor/
-/doc/html/boost_asio/reference/basic_writable_pipe__rebind_executor.html
-/doc/html/boost_asio/reference/basic_writable_pipe__rebind_executor/other.html
-/doc/html/boost_asio/reference/basic_writable_pipe/release/
-/doc/html/boost_asio/reference/basic_writable_pipe/release.html
-/doc/html/boost_asio/reference/basic_writable_pipe/release/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/release/overload2.html
-/doc/html/boost_asio/reference/basic_writable_pipe/write_some/
-/doc/html/boost_asio/reference/basic_writable_pipe/write_some.html
-/doc/html/boost_asio/reference/basic_writable_pipe/write_some/overload1.html
-/doc/html/boost_asio/reference/basic_writable_pipe/write_some/overload2.html
-/doc/html/boost_asio/reference/basic_yield_context/
-/doc/html/boost_asio/reference/basic_yield_context/basic_yield_context.html
-/doc/html/boost_asio/reference/basic_yield_context/cancellation_slot_type.html
-/doc/html/boost_asio/reference/basic_yield_context/cancelled.html
-/doc/html/boost_asio/reference/basic_yield_context/executor_type.html
-/doc/html/boost_asio/reference/basic_yield_context/get_cancellation_slot.html
-/doc/html/boost_asio/reference/basic_yield_context/get_cancellation_state.html
-/doc/html/boost_asio/reference/basic_yield_context/get_executor.html
-/doc/html/boost_asio/reference/basic_yield_context.html
-/doc/html/boost_asio/reference/basic_yield_context/operator_lb__rb_.html
-/doc/html/boost_asio/reference/basic_yield_context/reset_cancellation_state/
-/doc/html/boost_asio/reference/basic_yield_context/reset_cancellation_state.html
-/doc/html/boost_asio/reference/basic_yield_context/reset_cancellation_state/overload1.html
-/doc/html/boost_asio/reference/basic_yield_context/reset_cancellation_state/overload2.html
-/doc/html/boost_asio/reference/basic_yield_context/reset_cancellation_state/overload3.html
-/doc/html/boost_asio/reference/basic_yield_context/throw_if_cancelled/
-/doc/html/boost_asio/reference/basic_yield_context/throw_if_cancelled.html
-/doc/html/boost_asio/reference/basic_yield_context/throw_if_cancelled/overload1.html
-/doc/html/boost_asio/reference/basic_yield_context/throw_if_cancelled/overload2.html
-/doc/html/boost_asio/reference/bind_allocator/
-/doc/html/boost_asio/reference/bind_allocator.html
-/doc/html/boost_asio/reference/bind_allocator/overload1.html
-/doc/html/boost_asio/reference/bind_allocator/overload2.html
-/doc/html/boost_asio/reference/bind_cancellation_slot/
-/doc/html/boost_asio/reference/bind_cancellation_slot.html
-/doc/html/boost_asio/reference/bind_cancellation_slot/overload1.html
-/doc/html/boost_asio/reference/bind_cancellation_slot/overload2.html
-/doc/html/boost_asio/reference/bind_executor/
-/doc/html/boost_asio/reference/bind_executor.html
-/doc/html/boost_asio/reference/bind_executor/overload1.html
-/doc/html/boost_asio/reference/bind_executor/overload2.html
-/doc/html/boost_asio/reference/bind_executor/overload3.html
-/doc/html/boost_asio/reference/bind_executor/overload4.html
-/doc/html/boost_asio/reference/bind_immediate_executor/
-/doc/html/boost_asio/reference/bind_immediate_executor.html
-/doc/html/boost_asio/reference/bind_immediate_executor/overload1.html
-/doc/html/boost_asio/reference/bind_immediate_executor/overload2.html
-/doc/html/boost_asio/reference/buffer/
-/doc/html/boost_asio/reference/buffer_cast/
-/doc/html/boost_asio/reference/buffer_cast.html
-/doc/html/boost_asio/reference/buffer_cast/overload1.html
-/doc/html/boost_asio/reference/buffer_cast/overload2.html
-/doc/html/boost_asio/reference/buffer_copy/
-/doc/html/boost_asio/reference/buffer_copy.html
-/doc/html/boost_asio/reference/buffer_copy/overload1.html
-/doc/html/boost_asio/reference/buffer_copy/overload2.html
-/doc/html/boost_asio/reference/BufferedHandshakeHandler.html
-/doc/html/boost_asio/reference/BufferedHandshakeToken.html
-/doc/html/boost_asio/reference/buffered_read_stream/
-/doc/html/boost_asio/reference/buffered_read_stream/async_fill.html
-/doc/html/boost_asio/reference/buffered_read_stream/async_read_some.html
-/doc/html/boost_asio/reference/buffered_read_stream/async_write_some.html
-/doc/html/boost_asio/reference/buffered_read_stream/buffered_read_stream/
-/doc/html/boost_asio/reference/buffered_read_stream/buffered_read_stream.html
-/doc/html/boost_asio/reference/buffered_read_stream/buffered_read_stream/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/buffered_read_stream/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/close/
-/doc/html/boost_asio/reference/buffered_read_stream/close.html
-/doc/html/boost_asio/reference/buffered_read_stream/close/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/close/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/default_buffer_size.html
-/doc/html/boost_asio/reference/buffered_read_stream/executor_type.html
-/doc/html/boost_asio/reference/buffered_read_stream/fill/
-/doc/html/boost_asio/reference/buffered_read_stream/fill.html
-/doc/html/boost_asio/reference/buffered_read_stream/fill/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/fill/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/get_executor.html
-/doc/html/boost_asio/reference/buffered_read_stream.html
-/doc/html/boost_asio/reference/buffered_read_stream/in_avail/
-/doc/html/boost_asio/reference/buffered_read_stream/in_avail.html
-/doc/html/boost_asio/reference/buffered_read_stream/in_avail/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/in_avail/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/lowest_layer/
-/doc/html/boost_asio/reference/buffered_read_stream/lowest_layer.html
-/doc/html/boost_asio/reference/buffered_read_stream/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/lowest_layer_type.html
-/doc/html/boost_asio/reference/buffered_read_stream/next_layer.html
-/doc/html/boost_asio/reference/buffered_read_stream/next_layer_type.html
-/doc/html/boost_asio/reference/buffered_read_stream/peek/
-/doc/html/boost_asio/reference/buffered_read_stream/peek.html
-/doc/html/boost_asio/reference/buffered_read_stream/peek/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/peek/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/read_some/
-/doc/html/boost_asio/reference/buffered_read_stream/read_some.html
-/doc/html/boost_asio/reference/buffered_read_stream/read_some/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/read_some/overload2.html
-/doc/html/boost_asio/reference/buffered_read_stream/write_some/
-/doc/html/boost_asio/reference/buffered_read_stream/write_some.html
-/doc/html/boost_asio/reference/buffered_read_stream/write_some/overload1.html
-/doc/html/boost_asio/reference/buffered_read_stream/write_some/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/
-/doc/html/boost_asio/reference/buffered_stream/async_fill.html
-/doc/html/boost_asio/reference/buffered_stream/async_flush.html
-/doc/html/boost_asio/reference/buffered_stream/async_read_some.html
-/doc/html/boost_asio/reference/buffered_stream/async_write_some.html
-/doc/html/boost_asio/reference/buffered_stream/buffered_stream/
-/doc/html/boost_asio/reference/buffered_stream/buffered_stream.html
-/doc/html/boost_asio/reference/buffered_stream/buffered_stream/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/buffered_stream/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/close/
-/doc/html/boost_asio/reference/buffered_stream/close.html
-/doc/html/boost_asio/reference/buffered_stream/close/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/close/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/executor_type.html
-/doc/html/boost_asio/reference/buffered_stream/fill/
-/doc/html/boost_asio/reference/buffered_stream/fill.html
-/doc/html/boost_asio/reference/buffered_stream/fill/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/fill/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/flush/
-/doc/html/boost_asio/reference/buffered_stream/flush.html
-/doc/html/boost_asio/reference/buffered_stream/flush/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/flush/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/get_executor.html
-/doc/html/boost_asio/reference/buffered_stream.html
-/doc/html/boost_asio/reference/buffered_stream/in_avail/
-/doc/html/boost_asio/reference/buffered_stream/in_avail.html
-/doc/html/boost_asio/reference/buffered_stream/in_avail/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/in_avail/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/lowest_layer/
-/doc/html/boost_asio/reference/buffered_stream/lowest_layer.html
-/doc/html/boost_asio/reference/buffered_stream/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/lowest_layer_type.html
-/doc/html/boost_asio/reference/buffered_stream/next_layer.html
-/doc/html/boost_asio/reference/buffered_stream/next_layer_type.html
-/doc/html/boost_asio/reference/buffered_stream/peek/
-/doc/html/boost_asio/reference/buffered_stream/peek.html
-/doc/html/boost_asio/reference/buffered_stream/peek/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/peek/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/read_some/
-/doc/html/boost_asio/reference/buffered_stream/read_some.html
-/doc/html/boost_asio/reference/buffered_stream/read_some/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/read_some/overload2.html
-/doc/html/boost_asio/reference/buffered_stream/write_some/
-/doc/html/boost_asio/reference/buffered_stream/write_some.html
-/doc/html/boost_asio/reference/buffered_stream/write_some/overload1.html
-/doc/html/boost_asio/reference/buffered_stream/write_some/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/
-/doc/html/boost_asio/reference/buffered_write_stream/async_flush.html
-/doc/html/boost_asio/reference/buffered_write_stream/async_read_some.html
-/doc/html/boost_asio/reference/buffered_write_stream/async_write_some.html
-/doc/html/boost_asio/reference/buffered_write_stream/buffered_write_stream/
-/doc/html/boost_asio/reference/buffered_write_stream/buffered_write_stream.html
-/doc/html/boost_asio/reference/buffered_write_stream/buffered_write_stream/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/buffered_write_stream/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/close/
-/doc/html/boost_asio/reference/buffered_write_stream/close.html
-/doc/html/boost_asio/reference/buffered_write_stream/close/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/close/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/default_buffer_size.html
-/doc/html/boost_asio/reference/buffered_write_stream/executor_type.html
-/doc/html/boost_asio/reference/buffered_write_stream/flush/
-/doc/html/boost_asio/reference/buffered_write_stream/flush.html
-/doc/html/boost_asio/reference/buffered_write_stream/flush/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/flush/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/get_executor.html
-/doc/html/boost_asio/reference/buffered_write_stream.html
-/doc/html/boost_asio/reference/buffered_write_stream/in_avail/
-/doc/html/boost_asio/reference/buffered_write_stream/in_avail.html
-/doc/html/boost_asio/reference/buffered_write_stream/in_avail/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/in_avail/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/lowest_layer/
-/doc/html/boost_asio/reference/buffered_write_stream/lowest_layer.html
-/doc/html/boost_asio/reference/buffered_write_stream/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/lowest_layer_type.html
-/doc/html/boost_asio/reference/buffered_write_stream/next_layer.html
-/doc/html/boost_asio/reference/buffered_write_stream/next_layer_type.html
-/doc/html/boost_asio/reference/buffered_write_stream/peek/
-/doc/html/boost_asio/reference/buffered_write_stream/peek.html
-/doc/html/boost_asio/reference/buffered_write_stream/peek/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/peek/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/read_some/
-/doc/html/boost_asio/reference/buffered_write_stream/read_some.html
-/doc/html/boost_asio/reference/buffered_write_stream/read_some/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/read_some/overload2.html
-/doc/html/boost_asio/reference/buffered_write_stream/write_some/
-/doc/html/boost_asio/reference/buffered_write_stream/write_some.html
-/doc/html/boost_asio/reference/buffered_write_stream/write_some/overload1.html
-/doc/html/boost_asio/reference/buffered_write_stream/write_some/overload2.html
-/doc/html/boost_asio/reference/buffer.html
-/doc/html/boost_asio/reference/buffer_literals__operator_quot__quot__buf/
-/doc/html/boost_asio/reference/buffer_literals__operator_quot__quot__buf.html
-/doc/html/boost_asio/reference/buffer_literals__operator_quot__quot__buf/overload1.html
-/doc/html/boost_asio/reference/buffer_literals__operator_quot__quot__buf/overload2.html
-/doc/html/boost_asio/reference/buffer/overload10.html
-/doc/html/boost_asio/reference/buffer/overload11.html
-/doc/html/boost_asio/reference/buffer/overload12.html
-/doc/html/boost_asio/reference/buffer/overload13.html
-/doc/html/boost_asio/reference/buffer/overload14.html
-/doc/html/boost_asio/reference/buffer/overload15.html
-/doc/html/boost_asio/reference/buffer/overload16.html
-/doc/html/boost_asio/reference/buffer/overload17.html
-/doc/html/boost_asio/reference/buffer/overload18.html
-/doc/html/boost_asio/reference/buffer/overload19.html
-/doc/html/boost_asio/reference/buffer/overload1.html
-/doc/html/boost_asio/reference/buffer/overload20.html
-/doc/html/boost_asio/reference/buffer/overload21.html
-/doc/html/boost_asio/reference/buffer/overload22.html
-/doc/html/boost_asio/reference/buffer/overload23.html
-/doc/html/boost_asio/reference/buffer/overload24.html
-/doc/html/boost_asio/reference/buffer/overload25.html
-/doc/html/boost_asio/reference/buffer/overload26.html
-/doc/html/boost_asio/reference/buffer/overload27.html
-/doc/html/boost_asio/reference/buffer/overload28.html
-/doc/html/boost_asio/reference/buffer/overload29.html
-/doc/html/boost_asio/reference/buffer/overload2.html
-/doc/html/boost_asio/reference/buffer/overload30.html
-/doc/html/boost_asio/reference/buffer/overload31.html
-/doc/html/boost_asio/reference/buffer/overload32.html
-/doc/html/boost_asio/reference/buffer/overload33.html
-/doc/html/boost_asio/reference/buffer/overload34.html
-/doc/html/boost_asio/reference/buffer/overload35.html
-/doc/html/boost_asio/reference/buffer/overload36.html
-/doc/html/boost_asio/reference/buffer/overload37.html
-/doc/html/boost_asio/reference/buffer/overload38.html
-/doc/html/boost_asio/reference/buffer/overload3.html
-/doc/html/boost_asio/reference/buffer/overload4.html
-/doc/html/boost_asio/reference/buffer/overload5.html
-/doc/html/boost_asio/reference/buffer/overload6.html
-/doc/html/boost_asio/reference/buffer/overload7.html
-/doc/html/boost_asio/reference/buffer/overload8.html
-/doc/html/boost_asio/reference/buffer/overload9.html
-/doc/html/boost_asio/reference/buffer_registration/
-/doc/html/boost_asio/reference/buffer_registration/allocator_type.html
-/doc/html/boost_asio/reference/buffer_registration/at.html
-/doc/html/boost_asio/reference/buffer_registration/begin.html
-/doc/html/boost_asio/reference/buffer_registration/buffer_registration/
-/doc/html/boost_asio/reference/buffer_registration/_buffer_registration.html
-/doc/html/boost_asio/reference/buffer_registration/buffer_registration.html
-/doc/html/boost_asio/reference/buffer_registration/buffer_registration/overload1.html
-/doc/html/boost_asio/reference/buffer_registration/buffer_registration/overload2.html
-/doc/html/boost_asio/reference/buffer_registration/buffer_registration/overload3.html
-/doc/html/boost_asio/reference/buffer_registration/cbegin.html
-/doc/html/boost_asio/reference/buffer_registration/cend.html
-/doc/html/boost_asio/reference/buffer_registration/const_iterator.html
-/doc/html/boost_asio/reference/buffer_registration/end.html
-/doc/html/boost_asio/reference/buffer_registration.html
-/doc/html/boost_asio/reference/buffer_registration/iterator.html
-/doc/html/boost_asio/reference/buffer_registration/operator_eq_.html
-/doc/html/boost_asio/reference/buffer_registration/operator_lb__rb_.html
-/doc/html/boost_asio/reference/buffer_registration/size.html
-/doc/html/boost_asio/reference/buffers_begin.html
-/doc/html/boost_asio/reference/buffers_end.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/
-/doc/html/boost_asio/reference/buffer_sequence_begin.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload1.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload2.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload3.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload4.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload5.html
-/doc/html/boost_asio/reference/buffer_sequence_begin/overload6.html
-/doc/html/boost_asio/reference/buffer_sequence_end/
-/doc/html/boost_asio/reference/buffer_sequence_end.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload1.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload2.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload3.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload4.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload5.html
-/doc/html/boost_asio/reference/buffer_sequence_end/overload6.html
-/doc/html/boost_asio/reference/buffers_iterator/
-/doc/html/boost_asio/reference/buffers_iterator/begin.html
-/doc/html/boost_asio/reference/buffers_iterator/buffers_iterator.html
-/doc/html/boost_asio/reference/buffers_iterator/difference_type.html
-/doc/html/boost_asio/reference/buffers_iterator/end.html
-/doc/html/boost_asio/reference/buffers_iterator.html
-/doc/html/boost_asio/reference/buffers_iterator/iterator_category.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_arrow_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_eq__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_gt__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_gt_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_lb__rb_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_lt__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_lt_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus_/
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus__minus_/
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus__minus_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus__minus_/overload1.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus__minus_/overload2.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus_/overload1.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_minus_/overload2.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_not__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus_/
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus__eq_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus__plus_/
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus__plus_.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus__plus_/overload1.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_plus__plus_/overload2.html
-/doc/html/boost_asio/reference/buffers_iterator/operator_star_.html
-/doc/html/boost_asio/reference/buffers_iterator/pointer.html
-/doc/html/boost_asio/reference/buffers_iterator/reference.html
-/doc/html/boost_asio/reference/buffers_iterator/value_type.html
-/doc/html/boost_asio/reference/buffer_size.html
-/doc/html/boost_asio/reference/cancel_after/
-/doc/html/boost_asio/reference/cancel_after.html
-/doc/html/boost_asio/reference/cancel_after/overload1.html
-/doc/html/boost_asio/reference/cancel_after/overload2.html
-/doc/html/boost_asio/reference/cancel_after/overload3.html
-/doc/html/boost_asio/reference/cancel_after/overload4.html
-/doc/html/boost_asio/reference/cancel_after/overload5.html
-/doc/html/boost_asio/reference/cancel_after/overload6.html
-/doc/html/boost_asio/reference/cancel_after_t/
-/doc/html/boost_asio/reference/cancel_after_t/cancel_after_t.html
-/doc/html/boost_asio/reference/cancel_after_t/cancel_type_.html
-/doc/html/boost_asio/reference/cancel_after_t.html
-/doc/html/boost_asio/reference/cancel_after_timer/
-/doc/html/boost_asio/reference/cancel_after_timer/cancel_after_timer.html
-/doc/html/boost_asio/reference/cancel_after_timer/cancel_type_.html
-/doc/html/boost_asio/reference/cancel_after_timer.html
-/doc/html/boost_asio/reference/cancel_after_timer/timeout_.html
-/doc/html/boost_asio/reference/cancel_after_timer/timer_.html
-/doc/html/boost_asio/reference/cancel_after_timer/token_.html
-/doc/html/boost_asio/reference/cancel_after_t/timeout_.html
-/doc/html/boost_asio/reference/cancel_after_t/token_.html
-/doc/html/boost_asio/reference/cancel_at/
-/doc/html/boost_asio/reference/cancel_at.html
-/doc/html/boost_asio/reference/cancel_at/overload1.html
-/doc/html/boost_asio/reference/cancel_at/overload2.html
-/doc/html/boost_asio/reference/cancel_at/overload3.html
-/doc/html/boost_asio/reference/cancel_at/overload4.html
-/doc/html/boost_asio/reference/cancel_at/overload5.html
-/doc/html/boost_asio/reference/cancel_at/overload6.html
-/doc/html/boost_asio/reference/cancel_at_t/
-/doc/html/boost_asio/reference/cancel_at_t/cancel_at_t.html
-/doc/html/boost_asio/reference/cancel_at_t/cancel_type_.html
-/doc/html/boost_asio/reference/cancel_at_t/expiry_.html
-/doc/html/boost_asio/reference/cancel_at_t.html
-/doc/html/boost_asio/reference/cancel_at_timer/
-/doc/html/boost_asio/reference/cancel_at_timer/cancel_at_timer.html
-/doc/html/boost_asio/reference/cancel_at_timer/cancel_type_.html
-/doc/html/boost_asio/reference/cancel_at_timer/expiry_.html
-/doc/html/boost_asio/reference/cancel_at_timer.html
-/doc/html/boost_asio/reference/cancel_at_timer/timer_.html
-/doc/html/boost_asio/reference/cancel_at_timer/token_.html
-/doc/html/boost_asio/reference/cancel_at_t/token_.html
-/doc/html/boost_asio/reference/cancellation_filter/
-/doc/html/boost_asio/reference/cancellation_filter.html
-/doc/html/boost_asio/reference/cancellation_filter/operator_lp__rp_.html
-/doc/html/boost_asio/reference/CancellationHandler.html
-/doc/html/boost_asio/reference/cancellation_signal/
-/doc/html/boost_asio/reference/cancellation_signal/_cancellation_signal.html
-/doc/html/boost_asio/reference/cancellation_signal/cancellation_signal.html
-/doc/html/boost_asio/reference/cancellation_signal/emit.html
-/doc/html/boost_asio/reference/cancellation_signal.html
-/doc/html/boost_asio/reference/cancellation_signal/slot.html
-/doc/html/boost_asio/reference/cancellation_slot/
-/doc/html/boost_asio/reference/cancellation_slot/assign.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/
-/doc/html/boost_asio/reference/cancellation_slot_binder/argument_type.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/
-/doc/html/boost_asio/reference/cancellation_slot_binder/_cancellation_slot_binder.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload1.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload2.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload3.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload4.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload5.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload6.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload7.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload8.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_binder/overload9.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/cancellation_slot_type.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/first_argument_type.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/get/
-/doc/html/boost_asio/reference/cancellation_slot_binder/get_cancellation_slot.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/get.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/get/overload1.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/get/overload2.html
-/doc/html/boost_asio/reference/cancellation_slot_binder.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/operator_lp__rp_/
-/doc/html/boost_asio/reference/cancellation_slot_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/result_type.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/second_argument_type.html
-/doc/html/boost_asio/reference/cancellation_slot_binder/target_type.html
-/doc/html/boost_asio/reference/cancellation_slot/cancellation_slot.html
-/doc/html/boost_asio/reference/cancellation_slot/clear.html
-/doc/html/boost_asio/reference/cancellation_slot/emplace.html
-/doc/html/boost_asio/reference/cancellation_slot/has_handler.html
-/doc/html/boost_asio/reference/CancellationSlot.html
-/doc/html/boost_asio/reference/cancellation_slot.html
-/doc/html/boost_asio/reference/cancellation_slot/is_connected.html
-/doc/html/boost_asio/reference/cancellation_slot/operator_eq__eq_.html
-/doc/html/boost_asio/reference/cancellation_slot/operator_not__eq_.html
-/doc/html/boost_asio/reference/cancellation_state/
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state/
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state.html
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state/overload1.html
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state/overload2.html
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state/overload3.html
-/doc/html/boost_asio/reference/cancellation_state/cancellation_state/overload4.html
-/doc/html/boost_asio/reference/cancellation_state/cancelled.html
-/doc/html/boost_asio/reference/cancellation_state/clear.html
-/doc/html/boost_asio/reference/cancellation_state.html
-/doc/html/boost_asio/reference/cancellation_state/slot.html
-/doc/html/boost_asio/reference/cancellation_type.html
-/doc/html/boost_asio/reference/cancellation_type_t.html
-/doc/html/boost_asio/reference/can_prefer.html
-/doc/html/boost_asio/reference/can_query.html
-/doc/html/boost_asio/reference/can_require_concept.html
-/doc/html/boost_asio/reference/can_require.html
-/doc/html/boost_asio/reference/co_composed.html
-/doc/html/boost_asio/reference/CompletionCondition.html
-/doc/html/boost_asio/reference/completion_signature_of/
-/doc/html/boost_asio/reference/completion_signature_of.html
-/doc/html/boost_asio/reference/completion_signature_of_t.html
-/doc/html/boost_asio/reference/completion_signature_of/type.html
-/doc/html/boost_asio/reference/composed.html
-/doc/html/boost_asio/reference/connect/
-/doc/html/boost_asio/reference/ConnectCondition.html
-/doc/html/boost_asio/reference/ConnectHandler.html
-/doc/html/boost_asio/reference/connect.html
-/doc/html/boost_asio/reference/connect/overload10.html
-/doc/html/boost_asio/reference/connect/overload11.html
-/doc/html/boost_asio/reference/connect/overload12.html
-/doc/html/boost_asio/reference/connect/overload1.html
-/doc/html/boost_asio/reference/connect/overload2.html
-/doc/html/boost_asio/reference/connect/overload3.html
-/doc/html/boost_asio/reference/connect/overload4.html
-/doc/html/boost_asio/reference/connect/overload5.html
-/doc/html/boost_asio/reference/connect/overload6.html
-/doc/html/boost_asio/reference/connect/overload7.html
-/doc/html/boost_asio/reference/connect/overload8.html
-/doc/html/boost_asio/reference/connect/overload9.html
-/doc/html/boost_asio/reference/connect_pipe/
-/doc/html/boost_asio/reference/connect_pipe.html
-/doc/html/boost_asio/reference/connect_pipe/overload1.html
-/doc/html/boost_asio/reference/connect_pipe/overload2.html
-/doc/html/boost_asio/reference/ConnectToken.html
-/doc/html/boost_asio/reference/consign.html
-/doc/html/boost_asio/reference/consign_t/
-/doc/html/boost_asio/reference/consign_t/consign_t.html
-/doc/html/boost_asio/reference/consign_t.html
-/doc/html/boost_asio/reference/const_buffer/
-/doc/html/boost_asio/reference/const_buffer/const_buffer/
-/doc/html/boost_asio/reference/const_buffer/const_buffer.html
-/doc/html/boost_asio/reference/const_buffer/const_buffer/overload1.html
-/doc/html/boost_asio/reference/const_buffer/const_buffer/overload2.html
-/doc/html/boost_asio/reference/const_buffer/const_buffer/overload3.html
-/doc/html/boost_asio/reference/const_buffer/data.html
-/doc/html/boost_asio/reference/const_buffer.html
-/doc/html/boost_asio/reference/const_buffer/operator_plus_/
-/doc/html/boost_asio/reference/const_buffer/operator_plus__eq_.html
-/doc/html/boost_asio/reference/const_buffer/operator_plus_.html
-/doc/html/boost_asio/reference/const_buffer/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/const_buffer/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/const_buffers_1/
-/doc/html/boost_asio/reference/const_buffers_1/begin.html
-/doc/html/boost_asio/reference/const_buffers_1/const_buffers_1/
-/doc/html/boost_asio/reference/const_buffers_1/const_buffers_1.html
-/doc/html/boost_asio/reference/const_buffers_1/const_buffers_1/overload1.html
-/doc/html/boost_asio/reference/const_buffers_1/const_buffers_1/overload2.html
-/doc/html/boost_asio/reference/const_buffers_1/const_iterator.html
-/doc/html/boost_asio/reference/const_buffers_1/data.html
-/doc/html/boost_asio/reference/const_buffers_1/end.html
-/doc/html/boost_asio/reference/const_buffers_1.html
-/doc/html/boost_asio/reference/const_buffers_1/operator_plus_/
-/doc/html/boost_asio/reference/const_buffers_1/operator_plus__eq_.html
-/doc/html/boost_asio/reference/const_buffers_1/operator_plus_.html
-/doc/html/boost_asio/reference/const_buffers_1/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/const_buffers_1/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/const_buffers_1/size.html
-/doc/html/boost_asio/reference/const_buffers_1/value_type.html
-/doc/html/boost_asio/reference/ConstBufferSequence.html
-/doc/html/boost_asio/reference/const_buffer/size.html
-/doc/html/boost_asio/reference/const_registered_buffer/
-/doc/html/boost_asio/reference/const_registered_buffer/buffer.html
-/doc/html/boost_asio/reference/const_registered_buffer/const_registered_buffer/
-/doc/html/boost_asio/reference/const_registered_buffer/const_registered_buffer.html
-/doc/html/boost_asio/reference/const_registered_buffer/const_registered_buffer/overload1.html
-/doc/html/boost_asio/reference/const_registered_buffer/const_registered_buffer/overload2.html
-/doc/html/boost_asio/reference/const_registered_buffer/data.html
-/doc/html/boost_asio/reference/const_registered_buffer.html
-/doc/html/boost_asio/reference/const_registered_buffer/id.html
-/doc/html/boost_asio/reference/const_registered_buffer/operator_plus_/
-/doc/html/boost_asio/reference/const_registered_buffer/operator_plus__eq_.html
-/doc/html/boost_asio/reference/const_registered_buffer/operator_plus_.html
-/doc/html/boost_asio/reference/const_registered_buffer/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/const_registered_buffer/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/const_registered_buffer/size.html
-/doc/html/boost_asio/reference/coroutine/
-/doc/html/boost_asio/reference/coroutine/coroutine.html
-/doc/html/boost_asio/reference/coroutine.html
-/doc/html/boost_asio/reference/coroutine/is_child.html
-/doc/html/boost_asio/reference/coroutine/is_complete.html
-/doc/html/boost_asio/reference/coroutine/is_parent.html
-/doc/html/boost_asio/reference/co_spawn/
-/doc/html/boost_asio/reference/co_spawn.html
-/doc/html/boost_asio/reference/co_spawn/overload1.html
-/doc/html/boost_asio/reference/co_spawn/overload2.html
-/doc/html/boost_asio/reference/co_spawn/overload3.html
-/doc/html/boost_asio/reference/co_spawn/overload4.html
-/doc/html/boost_asio/reference/co_spawn/overload5.html
-/doc/html/boost_asio/reference/co_spawn/overload6.html
-/doc/html/boost_asio/reference/deadline_timer.html
-/doc/html/boost_asio/reference/default_completion_token/
-/doc/html/boost_asio/reference/default_completion_token.html
-/doc/html/boost_asio/reference/default_completion_token_t.html
-/doc/html/boost_asio/reference/default_completion_token/type.html
-/doc/html/boost_asio/reference/defer/
-/doc/html/boost_asio/reference/defer.html
-/doc/html/boost_asio/reference/defer/overload1.html
-/doc/html/boost_asio/reference/defer/overload2.html
-/doc/html/boost_asio/reference/defer/overload3.html
-/doc/html/boost_asio/reference/deferred_async_operation/
-/doc/html/boost_asio/reference/deferred_async_operation/deferred_async_operation.html
-/doc/html/boost_asio/reference/deferred_async_operation.html
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/deferred_async_operation.html
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.html
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_async_operation/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_async_operation/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_async_operation/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_async_operation/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_conditional/
-/doc/html/boost_asio/reference/deferred_conditional/deferred_conditional.html
-/doc/html/boost_asio/reference/deferred_conditional.html
-/doc/html/boost_asio/reference/deferred_conditional/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_conditional/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_conditional/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_conditional/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_conditional/otherwise.html
-/doc/html/boost_asio/reference/deferred_conditional/then.html
-/doc/html/boost_asio/reference/deferred_function/
-/doc/html/boost_asio/reference/deferred_function/deferred_function.html
-/doc/html/boost_asio/reference/deferred_function/function_.html
-/doc/html/boost_asio/reference/deferred_function.html
-/doc/html/boost_asio/reference/deferred_function/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_function/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_function/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_function/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred.html
-/doc/html/boost_asio/reference/deferred_init_tag.html
-/doc/html/boost_asio/reference/deferred_noop/
-/doc/html/boost_asio/reference/deferred_noop.html
-/doc/html/boost_asio/reference/deferred_noop/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_noop/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_noop/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_noop/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_sequence/
-/doc/html/boost_asio/reference/deferred_sequence/deferred_sequence.html
-/doc/html/boost_asio/reference/deferred_sequence.html
-/doc/html/boost_asio/reference/deferred_sequence/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_sequence/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_sequence/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_sequence/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_signatures.html
-/doc/html/boost_asio/reference/deferred_t/
-/doc/html/boost_asio/reference/deferred_t/as_default_on.html
-/doc/html/boost_asio/reference/deferred_t/as_default_on_t.html
-/doc/html/boost_asio/reference/deferred_t/deferred_t.html
-/doc/html/boost_asio/reference/deferred_t__executor_with_default/
-/doc/html/boost_asio/reference/deferred_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/deferred_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/deferred_t__executor_with_default.html
-/doc/html/boost_asio/reference/deferred_t.html
-/doc/html/boost_asio/reference/deferred_t/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_t/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_t/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_t/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/deferred_t/values.html
-/doc/html/boost_asio/reference/deferred_t/when.html
-/doc/html/boost_asio/reference/deferred_values/
-/doc/html/boost_asio/reference/deferred_values/deferred_values.html
-/doc/html/boost_asio/reference/deferred_values.html
-/doc/html/boost_asio/reference/deferred_values__initiate/
-/doc/html/boost_asio/reference/deferred_values__initiate.html
-/doc/html/boost_asio/reference/deferred_values__initiate/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_values/operator_lp__rp_/
-/doc/html/boost_asio/reference/deferred_values/operator_lp__rp_.html
-/doc/html/boost_asio/reference/deferred_values/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/deferred_values/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/detached.html
-/doc/html/boost_asio/reference/detached_t/
-/doc/html/boost_asio/reference/detached_t/as_default_on.html
-/doc/html/boost_asio/reference/detached_t/as_default_on_t.html
-/doc/html/boost_asio/reference/detached_t/detached_t.html
-/doc/html/boost_asio/reference/detached_t__executor_with_default/
-/doc/html/boost_asio/reference/detached_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/detached_t__executor_with_default/executor_with_default/
-/doc/html/boost_asio/reference/detached_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/detached_t__executor_with_default/executor_with_default/overload1.html
-/doc/html/boost_asio/reference/detached_t__executor_with_default/executor_with_default/overload2.html
-/doc/html/boost_asio/reference/detached_t__executor_with_default.html
-/doc/html/boost_asio/reference/detached_t.html
-/doc/html/boost_asio/reference/disable_cancellation.html
-/doc/html/boost_asio/reference/dispatch/
-/doc/html/boost_asio/reference/dispatch.html
-/doc/html/boost_asio/reference/dispatch/overload1.html
-/doc/html/boost_asio/reference/dispatch/overload2.html
-/doc/html/boost_asio/reference/dispatch/overload3.html
-/doc/html/boost_asio/reference/dynamic_buffer/
-/doc/html/boost_asio/reference/DynamicBuffer.html
-/doc/html/boost_asio/reference/dynamic_buffer.html
-/doc/html/boost_asio/reference/dynamic_buffer/overload1.html
-/doc/html/boost_asio/reference/dynamic_buffer/overload2.html
-/doc/html/boost_asio/reference/dynamic_buffer/overload3.html
-/doc/html/boost_asio/reference/dynamic_buffer/overload4.html
-/doc/html/boost_asio/reference/DynamicBuffer_v1.html
-/doc/html/boost_asio/reference/DynamicBuffer_v2.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/
-/doc/html/boost_asio/reference/dynamic_string_buffer/capacity.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/commit.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/const_buffers_type.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/consume.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/data/
-/doc/html/boost_asio/reference/dynamic_string_buffer/data.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/data/overload1.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/data/overload2.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/data/overload3.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/dynamic_string_buffer/
-/doc/html/boost_asio/reference/dynamic_string_buffer/dynamic_string_buffer.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload1.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload2.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/dynamic_string_buffer/overload3.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/grow.html
-/doc/html/boost_asio/reference/dynamic_string_buffer.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/max_size.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/mutable_buffers_type.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/prepare.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/shrink.html
-/doc/html/boost_asio/reference/dynamic_string_buffer/size.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/
-/doc/html/boost_asio/reference/dynamic_vector_buffer/capacity.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/commit.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/const_buffers_type.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/consume.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/data/
-/doc/html/boost_asio/reference/dynamic_vector_buffer/data.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/data/overload1.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/data/overload2.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/data/overload3.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/
-/doc/html/boost_asio/reference/dynamic_vector_buffer/dynamic_vector_buffer.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload1.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload2.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/dynamic_vector_buffer/overload3.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/grow.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/max_size.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/mutable_buffers_type.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/prepare.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/shrink.html
-/doc/html/boost_asio/reference/dynamic_vector_buffer/size.html
-/doc/html/boost_asio/reference/enable_partial_cancellation.html
-/doc/html/boost_asio/reference/enable_terminal_cancellation.html
-/doc/html/boost_asio/reference/enable_total_cancellation.html
-/doc/html/boost_asio/reference/Endpoint.html
-/doc/html/boost_asio/reference/EndpointSequence.html
-/doc/html/boost_asio/reference/error__addrinfo_category.html
-/doc/html/boost_asio/reference/error__addrinfo_errors.html
-/doc/html/boost_asio/reference/error__basic_errors.html
-/doc/html/boost_asio/reference/error__clear.html
-/doc/html/boost_asio/reference/error__get_addrinfo_category.html
-/doc/html/boost_asio/reference/error__get_misc_category.html
-/doc/html/boost_asio/reference/error__get_netdb_category.html
-/doc/html/boost_asio/reference/error__get_ssl_category.html
-/doc/html/boost_asio/reference/error__get_system_category.html
-/doc/html/boost_asio/reference/error__make_error_code/
-/doc/html/boost_asio/reference/error__make_error_code.html
-/doc/html/boost_asio/reference/error__make_error_code/overload1.html
-/doc/html/boost_asio/reference/error__make_error_code/overload2.html
-/doc/html/boost_asio/reference/error__make_error_code/overload3.html
-/doc/html/boost_asio/reference/error__make_error_code/overload4.html
-/doc/html/boost_asio/reference/error__make_error_code/overload5.html
-/doc/html/boost_asio/reference/error__misc_category.html
-/doc/html/boost_asio/reference/error__misc_errors.html
-/doc/html/boost_asio/reference/error__netdb_category.html
-/doc/html/boost_asio/reference/error__netdb_errors.html
-/doc/html/boost_asio/reference/error__ssl_category.html
-/doc/html/boost_asio/reference/error__ssl_errors.html
-/doc/html/boost_asio/reference/error__system_category.html
-/doc/html/boost_asio/reference/execution__allocator.html
-/doc/html/boost_asio/reference/execution__allocator_t/
-/doc/html/boost_asio/reference/execution__allocator_t/allocator_t.html
-/doc/html/boost_asio/reference/execution__allocator_t.html
-/doc/html/boost_asio/reference/execution__allocator_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__allocator_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__allocator_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__allocator_t/value.html
-/doc/html/boost_asio/reference/execution__any_executor/
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/
-/doc/html/boost_asio/reference/execution__any_executor/_any_executor.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload10.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload1.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload2.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload3.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload4.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload5.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload6.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload7.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload8.html
-/doc/html/boost_asio/reference/execution__any_executor/any_executor/overload9.html
-/doc/html/boost_asio/reference/execution__any_executor/context.html
-/doc/html/boost_asio/reference/execution__any_executor/execute.html
-/doc/html/boost_asio/reference/execution__any_executor.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_bool.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_/
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq__eq_/
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq__eq_/overload1.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq__eq_/overload2.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq__eq_/overload3.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_eq_/overload4.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_not__eq_/
-/doc/html/boost_asio/reference/execution__any_executor/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_not__eq_/overload1.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_not__eq_/overload2.html
-/doc/html/boost_asio/reference/execution__any_executor/operator_not__eq_/overload3.html
-/doc/html/boost_asio/reference/execution__any_executor/prefer.html
-/doc/html/boost_asio/reference/execution__any_executor/query.html
-/doc/html/boost_asio/reference/execution__any_executor/require.html
-/doc/html/boost_asio/reference/execution__any_executor/swap.html
-/doc/html/boost_asio/reference/execution__any_executor/target/
-/doc/html/boost_asio/reference/execution__any_executor/target.html
-/doc/html/boost_asio/reference/execution__any_executor/target/overload1.html
-/doc/html/boost_asio/reference/execution__any_executor/target/overload2.html
-/doc/html/boost_asio/reference/execution__any_executor/target_type.html
-/doc/html/boost_asio/reference/execution__bad_executor/
-/doc/html/boost_asio/reference/execution__bad_executor/bad_executor.html
-/doc/html/boost_asio/reference/execution__bad_executor.html
-/doc/html/boost_asio/reference/execution__bad_executor/what.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/allowed.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/allowed_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__allowed_t/value.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload1.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload2.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/blocking_adaptation_t/overload3.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/disallowed.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/disallowed_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t__disallowed_t/value.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__blocking_adaptation_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking.html
-/doc/html/boost_asio/reference/execution__blocking_t/
-/doc/html/boost_asio/reference/execution__blocking_t/always.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/always_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_t__always_t/value.html
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t/
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t.html
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t/overload1.html
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t/overload2.html
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t/overload3.html
-/doc/html/boost_asio/reference/execution__blocking_t/blocking_t/overload4.html
-/doc/html/boost_asio/reference/execution__blocking_t.html
-/doc/html/boost_asio/reference/execution__blocking_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_t/never.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/
-/doc/html/boost_asio/reference/execution__blocking_t__never_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/never_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_t__never_t/value.html
-/doc/html/boost_asio/reference/execution__blocking_t/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__blocking_t/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__blocking_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_t/possibly.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/possibly_t.html
-/doc/html/boost_asio/reference/execution__blocking_t__possibly_t/value.html
-/doc/html/boost_asio/reference/execution_context/
-/doc/html/boost_asio/reference/execution_context/add_service.html
-/doc/html/boost_asio/reference/execution__context_as.html
-/doc/html/boost_asio/reference/execution__context_as_t/
-/doc/html/boost_asio/reference/execution__context_as_t.html
-/doc/html/boost_asio/reference/execution__context_as_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__context_as_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__context_as_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__context_as_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution_context/destroy.html
-/doc/html/boost_asio/reference/execution_context/_execution_context.html
-/doc/html/boost_asio/reference/execution_context/execution_context.html
-/doc/html/boost_asio/reference/execution_context/fork_event.html
-/doc/html/boost_asio/reference/execution_context/has_service.html
-/doc/html/boost_asio/reference/ExecutionContext.html
-/doc/html/boost_asio/reference/execution__context.html
-/doc/html/boost_asio/reference/execution_context.html
-/doc/html/boost_asio/reference/execution_context__id/
-/doc/html/boost_asio/reference/execution_context__id.html
-/doc/html/boost_asio/reference/execution_context__id/id.html
-/doc/html/boost_asio/reference/execution_context/make_service.html
-/doc/html/boost_asio/reference/execution_context/notify_fork.html
-/doc/html/boost_asio/reference/execution_context__service/
-/doc/html/boost_asio/reference/execution_context__service/context.html
-/doc/html/boost_asio/reference/execution_context__service.html
-/doc/html/boost_asio/reference/execution_context__service/notify_fork.html
-/doc/html/boost_asio/reference/execution_context__service/_service.html
-/doc/html/boost_asio/reference/execution_context__service/service.html
-/doc/html/boost_asio/reference/execution_context__service/shutdown.html
-/doc/html/boost_asio/reference/execution_context/shutdown.html
-/doc/html/boost_asio/reference/execution__context_t/
-/doc/html/boost_asio/reference/execution__context_t.html
-/doc/html/boost_asio/reference/execution__context_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__context_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__context_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__context_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution_context/use_service/
-/doc/html/boost_asio/reference/execution_context/use_service.html
-/doc/html/boost_asio/reference/execution_context/use_service/overload1.html
-/doc/html/boost_asio/reference/execution_context/use_service/overload2.html
-/doc/html/boost_asio/reference/execution__invocable_archetype/
-/doc/html/boost_asio/reference/execution__invocable_archetype.html
-/doc/html/boost_asio/reference/execution__invocable_archetype/operator_lp__rp_.html
-/doc/html/boost_asio/reference/execution__is_executor.html
-/doc/html/boost_asio/reference/execution__mapping.html
-/doc/html/boost_asio/reference/execution__mapping_t/
-/doc/html/boost_asio/reference/execution__mapping_t.html
-/doc/html/boost_asio/reference/execution__mapping_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__mapping_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__mapping_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t/
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t.html
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t/overload1.html
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t/overload2.html
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t/overload3.html
-/doc/html/boost_asio/reference/execution__mapping_t/mapping_t/overload4.html
-/doc/html/boost_asio/reference/execution__mapping_t/new_thread.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/new_thread_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__mapping_t__new_thread_t/value.html
-/doc/html/boost_asio/reference/execution__mapping_t/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__mapping_t/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__mapping_t/other.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/
-/doc/html/boost_asio/reference/execution__mapping_t__other_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/other_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__mapping_t__other_t/value.html
-/doc/html/boost_asio/reference/execution__mapping_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__mapping_t/thread.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/thread_t.html
-/doc/html/boost_asio/reference/execution__mapping_t__thread_t/value.html
-/doc/html/boost_asio/reference/execution__occupancy.html
-/doc/html/boost_asio/reference/execution__occupancy_t/
-/doc/html/boost_asio/reference/execution__occupancy_t.html
-/doc/html/boost_asio/reference/execution__occupancy_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__occupancy_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__occupancy_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__occupancy_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__outstanding_work.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/
-/doc/html/boost_asio/reference/execution__outstanding_work_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/outstanding_work_t/
-/doc/html/boost_asio/reference/execution__outstanding_work_t/outstanding_work_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/outstanding_work_t/overload1.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/outstanding_work_t/overload2.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/outstanding_work_t/overload3.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/tracked.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/tracked_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__tracked_t/value.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t/untracked.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/untracked_t.html
-/doc/html/boost_asio/reference/execution__outstanding_work_t__untracked_t/value.html
-/doc/html/boost_asio/reference/execution__prefer_only/
-/doc/html/boost_asio/reference/execution__prefer_only.html
-/doc/html/boost_asio/reference/execution__prefer_only/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__prefer_only/is_preferable.html
-/doc/html/boost_asio/reference/execution__prefer_only/is_requirable.html
-/doc/html/boost_asio/reference/execution__prefer_only/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__relationship.html
-/doc/html/boost_asio/reference/execution__relationship_t/
-/doc/html/boost_asio/reference/execution__relationship_t/continuation.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/continuation_t.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__relationship_t__continuation_t/value.html
-/doc/html/boost_asio/reference/execution__relationship_t/fork.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/fork_t.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__relationship_t__fork_t/value.html
-/doc/html/boost_asio/reference/execution__relationship_t.html
-/doc/html/boost_asio/reference/execution__relationship_t/is_applicable_property_v.html
-/doc/html/boost_asio/reference/execution__relationship_t/is_preferable.html
-/doc/html/boost_asio/reference/execution__relationship_t/is_requirable.html
-/doc/html/boost_asio/reference/execution__relationship_t/operator_eq__eq_.html
-/doc/html/boost_asio/reference/execution__relationship_t/operator_not__eq_.html
-/doc/html/boost_asio/reference/execution__relationship_t/polymorphic_query_result_type.html
-/doc/html/boost_asio/reference/execution__relationship_t/relationship_t/
-/doc/html/boost_asio/reference/execution__relationship_t/relationship_t.html
-/doc/html/boost_asio/reference/execution__relationship_t/relationship_t/overload1.html
-/doc/html/boost_asio/reference/execution__relationship_t/relationship_t/overload2.html
-/doc/html/boost_asio/reference/execution__relationship_t/relationship_t/overload3.html
-/doc/html/boost_asio/reference/executor/
-/doc/html/boost_asio/reference/Executor1.html
-/doc/html/boost_asio/reference/executor_arg.html
-/doc/html/boost_asio/reference/executor_arg_t/
-/doc/html/boost_asio/reference/executor_arg_t/executor_arg_t.html
-/doc/html/boost_asio/reference/executor_arg_t.html
-/doc/html/boost_asio/reference/executor_binder/
-/doc/html/boost_asio/reference/executor_binder/argument_type.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/
-/doc/html/boost_asio/reference/executor_binder/_executor_binder.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload1.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload2.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload3.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload4.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload5.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload6.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload7.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload8.html
-/doc/html/boost_asio/reference/executor_binder/executor_binder/overload9.html
-/doc/html/boost_asio/reference/executor_binder/executor_type.html
-/doc/html/boost_asio/reference/executor_binder/first_argument_type.html
-/doc/html/boost_asio/reference/executor_binder/get/
-/doc/html/boost_asio/reference/executor_binder/get_executor.html
-/doc/html/boost_asio/reference/executor_binder/get.html
-/doc/html/boost_asio/reference/executor_binder/get/overload1.html
-/doc/html/boost_asio/reference/executor_binder/get/overload2.html
-/doc/html/boost_asio/reference/executor_binder.html
-/doc/html/boost_asio/reference/executor_binder/operator_lp__rp_/
-/doc/html/boost_asio/reference/executor_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/executor_binder/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/executor_binder/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/executor_binder/result_type.html
-/doc/html/boost_asio/reference/executor_binder/second_argument_type.html
-/doc/html/boost_asio/reference/executor_binder/target_type.html
-/doc/html/boost_asio/reference/executor/context.html
-/doc/html/boost_asio/reference/executor/defer.html
-/doc/html/boost_asio/reference/executor/dispatch.html
-/doc/html/boost_asio/reference/executor/executor/
-/doc/html/boost_asio/reference/executor/_executor.html
-/doc/html/boost_asio/reference/executor/executor.html
-/doc/html/boost_asio/reference/executor/executor/overload1.html
-/doc/html/boost_asio/reference/executor/executor/overload2.html
-/doc/html/boost_asio/reference/executor/executor/overload3.html
-/doc/html/boost_asio/reference/executor/executor/overload4.html
-/doc/html/boost_asio/reference/executor/executor/overload5.html
-/doc/html/boost_asio/reference/executor/executor/overload6.html
-/doc/html/boost_asio/reference/executor/executor/overload7.html
-/doc/html/boost_asio/reference/executor/executor/overload8.html
-/doc/html/boost_asio/reference/executor/executor/overload9.html
-/doc/html/boost_asio/reference/executor.html
-/doc/html/boost_asio/reference/executor/on_work_finished.html
-/doc/html/boost_asio/reference/executor/on_work_started.html
-/doc/html/boost_asio/reference/executor/operator_eq_/
-/doc/html/boost_asio/reference/executor/operator_eq__eq_.html
-/doc/html/boost_asio/reference/executor/operator_eq_.html
-/doc/html/boost_asio/reference/executor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/executor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/executor/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/executor/operator_eq_/overload4.html
-/doc/html/boost_asio/reference/executor/operator_not__eq_.html
-/doc/html/boost_asio/reference/executor/operator_unspecified_bool_type.html
-/doc/html/boost_asio/reference/executor/post.html
-/doc/html/boost_asio/reference/executor/target/
-/doc/html/boost_asio/reference/executor/target.html
-/doc/html/boost_asio/reference/executor/target/overload1.html
-/doc/html/boost_asio/reference/executor/target/overload2.html
-/doc/html/boost_asio/reference/executor/target_type.html
-/doc/html/boost_asio/reference/executor/unspecified_bool_true.html
-/doc/html/boost_asio/reference/executor/unspecified_bool_type.html
-/doc/html/boost_asio/reference/executor__unspecified_bool_type_t.html
-/doc/html/boost_asio/reference/executor_work_guard/
-/doc/html/boost_asio/reference/executor_work_guard/executor_type.html
-/doc/html/boost_asio/reference/executor_work_guard/executor_work_guard/
-/doc/html/boost_asio/reference/executor_work_guard/_executor_work_guard.html
-/doc/html/boost_asio/reference/executor_work_guard/executor_work_guard.html
-/doc/html/boost_asio/reference/executor_work_guard/executor_work_guard/overload1.html
-/doc/html/boost_asio/reference/executor_work_guard/executor_work_guard/overload2.html
-/doc/html/boost_asio/reference/executor_work_guard/executor_work_guard/overload3.html
-/doc/html/boost_asio/reference/executor_work_guard/get_executor.html
-/doc/html/boost_asio/reference/executor_work_guard.html
-/doc/html/boost_asio/reference/executor_work_guard/owns_work.html
-/doc/html/boost_asio/reference/executor_work_guard/reset.html
-/doc/html/boost_asio/reference/experimental__as_single.html
-/doc/html/boost_asio/reference/experimental__as_single_t/
-/doc/html/boost_asio/reference/experimental__as_single_t/as_default_on.html
-/doc/html/boost_asio/reference/experimental__as_single_t/as_default_on_t.html
-/doc/html/boost_asio/reference/experimental__as_single_t/as_single_t/
-/doc/html/boost_asio/reference/experimental__as_single_t/as_single_t.html
-/doc/html/boost_asio/reference/experimental__as_single_t/as_single_t/overload1.html
-/doc/html/boost_asio/reference/experimental__as_single_t/as_single_t/overload2.html
-/doc/html/boost_asio/reference/experimental__as_single_t__default_constructor_tag.html
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/overload1.html
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default/executor_with_default/overload2.html
-/doc/html/boost_asio/reference/experimental__as_single_t__executor_with_default.html
-/doc/html/boost_asio/reference/experimental__as_single_t.html
-/doc/html/boost_asio/reference/experimental__as_single_t/token_.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload1.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload2.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload3.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload4.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload5.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_amp__amp_/overload6.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload1.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload2.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload3.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload4.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload5.html
-/doc/html/boost_asio/reference/experimental__awaitable_operators__operator_pipe__pipe_/overload6.html
-/doc/html/boost_asio/reference/experimental__basic_channel/
-/doc/html/boost_asio/reference/experimental__basic_channel/async_receive.html
-/doc/html/boost_asio/reference/experimental__basic_channel/async_send.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel/
-/doc/html/boost_asio/reference/experimental__basic_channel/_basic_channel.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel/overload1.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel/overload2.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel/overload3.html
-/doc/html/boost_asio/reference/experimental__basic_channel/basic_channel/overload4.html
-/doc/html/boost_asio/reference/experimental__basic_channel/cancel.html
-/doc/html/boost_asio/reference/experimental__basic_channel/capacity.html
-/doc/html/boost_asio/reference/experimental__basic_channel/close.html
-/doc/html/boost_asio/reference/experimental__basic_channel/executor_type.html
-/doc/html/boost_asio/reference/experimental__basic_channel/get_executor.html
-/doc/html/boost_asio/reference/experimental__basic_channel.html
-/doc/html/boost_asio/reference/experimental__basic_channel/is_open.html
-/doc/html/boost_asio/reference/experimental__basic_channel/operator_eq_/
-/doc/html/boost_asio/reference/experimental__basic_channel/operator_eq_.html
-/doc/html/boost_asio/reference/experimental__basic_channel/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/experimental__basic_channel/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/experimental__basic_channel/ready.html
-/doc/html/boost_asio/reference/experimental__basic_channel__rebind_executor/
-/doc/html/boost_asio/reference/experimental__basic_channel__rebind_executor.html
-/doc/html/boost_asio/reference/experimental__basic_channel__rebind_executor/other.html
-/doc/html/boost_asio/reference/experimental__basic_channel/reset.html
-/doc/html/boost_asio/reference/experimental__basic_channel/traits_type.html
-/doc/html/boost_asio/reference/experimental__basic_channel/try_receive.html
-/doc/html/boost_asio/reference/experimental__basic_channel/try_send.html
-/doc/html/boost_asio/reference/experimental__basic_channel/try_send_n.html
-/doc/html/boost_asio/reference/experimental__basic_channel/try_send_n_via_dispatch.html
-/doc/html/boost_asio/reference/experimental__basic_channel/try_send_via_dispatch.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/async_receive.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/async_send.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/_basic_concurrent_channel.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload1.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload2.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload3.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/basic_concurrent_channel/overload4.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/cancel.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/capacity.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/close.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/executor_type.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/get_executor.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/is_open.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/operator_eq_/
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/operator_eq_.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/ready.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel__rebind_executor/
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel__rebind_executor.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel__rebind_executor/other.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/reset.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/traits_type.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/try_receive.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/try_send.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/try_send_n.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/try_send_n_via_dispatch.html
-/doc/html/boost_asio/reference/experimental__basic_concurrent_channel/try_send_via_dispatch.html
-/doc/html/boost_asio/reference/experimental__channel.html
-/doc/html/boost_asio/reference/experimental__channel_traits/
-/doc/html/boost_asio/reference/experimental__channel_traits__container/
-/doc/html/boost_asio/reference/experimental__channel_traits__container.html
-/doc/html/boost_asio/reference/experimental__channel_traits__container/type.html
-/doc/html/boost_asio/reference/experimental__channel_traits.html
-/doc/html/boost_asio/reference/experimental__channel_traits/invoke_receive_cancelled.html
-/doc/html/boost_asio/reference/experimental__channel_traits/invoke_receive_closed.html
-/doc/html/boost_asio/reference/experimental__channel_traits__rebind/
-/doc/html/boost_asio/reference/experimental__channel_traits__rebind.html
-/doc/html/boost_asio/reference/experimental__channel_traits__rebind/other.html
-/doc/html/boost_asio/reference/experimental__channel_traits/receive_cancelled_signature.html
-/doc/html/boost_asio/reference/experimental__channel_traits/receive_closed_signature.html
-/doc/html/boost_asio/reference/experimental__concurrent_channel.html
-/doc/html/boost_asio/reference/experimental__coro/
-/doc/html/boost_asio/reference/experimental__coro/allocator_type.html
-/doc/html/boost_asio/reference/experimental__coro/async_resume/
-/doc/html/boost_asio/reference/experimental__coro/async_resume.html
-/doc/html/boost_asio/reference/experimental__coro/async_resume/overload1.html
-/doc/html/boost_asio/reference/experimental__coro/async_resume/overload2.html
-/doc/html/boost_asio/reference/experimental__coro/completion_handler.html
-/doc/html/boost_asio/reference/experimental__coro/coro/
-/doc/html/boost_asio/reference/experimental__coro/_coro.html
-/doc/html/boost_asio/reference/experimental__coro/coro.html
-/doc/html/boost_asio/reference/experimental__coro/coro/overload1.html
-/doc/html/boost_asio/reference/experimental__coro/coro/overload2.html
-/doc/html/boost_asio/reference/experimental__coro/coro/overload3.html
-/doc/html/boost_asio/reference/experimental__coro/error_type.html
-/doc/html/boost_asio/reference/experimental__coro/executor_type.html
-/doc/html/boost_asio/reference/experimental__coro/get_allocator.html
-/doc/html/boost_asio/reference/experimental__coro/get_executor.html
-/doc/html/boost_asio/reference/experimental__coro.html
-/doc/html/boost_asio/reference/experimental__coro/input_type.html
-/doc/html/boost_asio/reference/experimental__coro/is_noexcept.html
-/doc/html/boost_asio/reference/experimental__coro/is_open.html
-/doc/html/boost_asio/reference/experimental__coro/operator_bool.html
-/doc/html/boost_asio/reference/experimental__coro/operator_co_await.html
-/doc/html/boost_asio/reference/experimental__coro/operator_eq_/
-/doc/html/boost_asio/reference/experimental__coro/operator_eq_.html
-/doc/html/boost_asio/reference/experimental__coro/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/experimental__coro/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/experimental__coro/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__coro/promise_type.html
-/doc/html/boost_asio/reference/experimental__coro/result_type.html
-/doc/html/boost_asio/reference/experimental__coro/return_type.html
-/doc/html/boost_asio/reference/experimental__coro/signature_type.html
-/doc/html/boost_asio/reference/experimental__coro_traits/
-/doc/html/boost_asio/reference/experimental__coro_traits/completion_handler.html
-/doc/html/boost_asio/reference/experimental__coro_traits/error_type.html
-/doc/html/boost_asio/reference/experimental__coro/traits.html
-/doc/html/boost_asio/reference/experimental__coro_traits.html
-/doc/html/boost_asio/reference/experimental__coro_traits/input_type.html
-/doc/html/boost_asio/reference/experimental__coro_traits/is_noexcept.html
-/doc/html/boost_asio/reference/experimental__coro_traits/result_type.html
-/doc/html/boost_asio/reference/experimental__coro_traits/return_type.html
-/doc/html/boost_asio/reference/experimental__coro_traits/signature_type.html
-/doc/html/boost_asio/reference/experimental__coro_traits/yield_type.html
-/doc/html/boost_asio/reference/experimental__coro/yield_type.html
-/doc/html/boost_asio/reference/experimental__co_spawn/
-/doc/html/boost_asio/reference/experimental__co_spawn.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload1.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload2.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload3.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload4.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload5.html
-/doc/html/boost_asio/reference/experimental__co_spawn/overload6.html
-/doc/html/boost_asio/reference/experimental__error__channel_category.html
-/doc/html/boost_asio/reference/experimental__error__channel_errors.html
-/doc/html/boost_asio/reference/experimental__error__get_channel_category.html
-/doc/html/boost_asio/reference/experimental__error__make_error_code.html
-/doc/html/boost_asio/reference/experimental__generator.html
-/doc/html/boost_asio/reference/experimental__is_async_operation_range/
-/doc/html/boost_asio/reference/experimental__is_async_operation_range.html
-/doc/html/boost_asio/reference/experimental__is_async_operation_range/value.html
-/doc/html/boost_asio/reference/experimental__is_promise.html
-/doc/html/boost_asio/reference/experimental__is_promise_lt__promise_lt__Ts_ellipsis___gt___gt_.html
-/doc/html/boost_asio/reference/experimental__is_promise_v.html
-/doc/html/boost_asio/reference/experimental__make_parallel_group/
-/doc/html/boost_asio/reference/experimental__make_parallel_group.html
-/doc/html/boost_asio/reference/experimental__make_parallel_group/overload1.html
-/doc/html/boost_asio/reference/experimental__make_parallel_group/overload2.html
-/doc/html/boost_asio/reference/experimental__make_parallel_group/overload3.html
-/doc/html/boost_asio/reference/experimental__parallel_group/
-/doc/html/boost_asio/reference/experimental__parallel_group/async_wait.html
-/doc/html/boost_asio/reference/experimental__parallel_group.html
-/doc/html/boost_asio/reference/experimental__parallel_group/parallel_group.html
-/doc/html/boost_asio/reference/experimental__parallel_group/signature.html
-/doc/html/boost_asio/reference/experimental__promise/
-/doc/html/boost_asio/reference/experimental__promise/cancel.html
-/doc/html/boost_asio/reference/experimental__promise/completed.html
-/doc/html/boost_asio/reference/experimental__promise.html
-/doc/html/boost_asio/reference/experimental__promise/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__promise/promise/
-/doc/html/boost_asio/reference/experimental__promise/_promise.html
-/doc/html/boost_asio/reference/experimental__promise/promise.html
-/doc/html/boost_asio/reference/experimental__promise/promise/overload1.html
-/doc/html/boost_asio/reference/experimental__promise/promise/overload2.html
-/doc/html/boost_asio/reference/experimental__promise/promise/overload3.html
-/doc/html/boost_asio/reference/experimental__promise_value_type/
-/doc/html/boost_asio/reference/experimental__promise/value_type.html
-/doc/html/boost_asio/reference/experimental__promise_value_type.html
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__gt_/
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__gt_.html
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__gt_/type.html
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__T__gt_/
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__T__gt_.html
-/doc/html/boost_asio/reference/experimental__promise_value_type_lt__T__gt_/type.html
-/doc/html/boost_asio/reference/experimental__promise_value_type/type.html
-/doc/html/boost_asio/reference/experimental__ranged_parallel_group/
-/doc/html/boost_asio/reference/experimental__ranged_parallel_group/async_wait.html
-/doc/html/boost_asio/reference/experimental__ranged_parallel_group.html
-/doc/html/boost_asio/reference/experimental__ranged_parallel_group/ranged_parallel_group.html
-/doc/html/boost_asio/reference/experimental__ranged_parallel_group/signature.html
-/doc/html/boost_asio/reference/experimental__task.html
-/doc/html/boost_asio/reference/experimental__use_coro.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/
-/doc/html/boost_asio/reference/experimental__use_coro_t/allocator_type.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/as_default_on.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/as_default_on_t.html
-/doc/html/boost_asio/reference/experimental__use_coro_t__executor_with_default/
-/doc/html/boost_asio/reference/experimental__use_coro_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/experimental__use_coro_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/experimental__use_coro_t__executor_with_default.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/get_allocator.html
-/doc/html/boost_asio/reference/experimental__use_coro_t.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/rebind.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/use_coro_t/
-/doc/html/boost_asio/reference/experimental__use_coro_t/use_coro_t.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/use_coro_t/overload1.html
-/doc/html/boost_asio/reference/experimental__use_coro_t/use_coro_t/overload2.html
-/doc/html/boost_asio/reference/experimental__use_promise.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/
-/doc/html/boost_asio/reference/experimental__use_promise_t/allocator_type.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/as_default_on.html
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/overload1.html
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default/executor_with_default/overload2.html
-/doc/html/boost_asio/reference/experimental__use_promise_t__executor_with_default.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/get_allocator.html
-/doc/html/boost_asio/reference/experimental__use_promise_t.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/rebind.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/use_promise_t/
-/doc/html/boost_asio/reference/experimental__use_promise_t/use_promise_t.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/use_promise_t/overload1.html
-/doc/html/boost_asio/reference/experimental__use_promise_t/use_promise_t/overload2.html
-/doc/html/boost_asio/reference/experimental__wait_for_all/
-/doc/html/boost_asio/reference/experimental__wait_for_all.html
-/doc/html/boost_asio/reference/experimental__wait_for_all/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__wait_for_one/
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/
-/doc/html/boost_asio/reference/experimental__wait_for_one_error.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/operator_lp__rp_/
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/operator_lp__rp_/overload3.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_error/wait_for_one_error.html
-/doc/html/boost_asio/reference/experimental__wait_for_one.html
-/doc/html/boost_asio/reference/experimental__wait_for_one/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/
-/doc/html/boost_asio/reference/experimental__wait_for_one_success.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/operator_lp__rp_/
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/operator_lp__rp_.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/operator_lp__rp_/overload3.html
-/doc/html/boost_asio/reference/experimental__wait_for_one_success/wait_for_one_success.html
-/doc/html/boost_asio/reference/experimental__wait_for_one/wait_for_one.html
-/doc/html/boost_asio/reference/file_base/
-/doc/html/boost_asio/reference/file_base/append.html
-/doc/html/boost_asio/reference/file_base/create.html
-/doc/html/boost_asio/reference/file_base/exclusive.html
-/doc/html/boost_asio/reference/file_base/_file_base.html
-/doc/html/boost_asio/reference/file_base/flags.html
-/doc/html/boost_asio/reference/file_base.html
-/doc/html/boost_asio/reference/file_base/read_only.html
-/doc/html/boost_asio/reference/file_base/read_write.html
-/doc/html/boost_asio/reference/file_base/seek_basis.html
-/doc/html/boost_asio/reference/file_base/sync_all_on_write.html
-/doc/html/boost_asio/reference/file_base/truncate.html
-/doc/html/boost_asio/reference/file_base/write_only.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/overload1.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/overload2.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/overload3.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/overload4.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/basic_endpoint/overload5.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/capacity.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/data/
-/doc/html/boost_asio/reference/generic__basic_endpoint/data.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/data/overload1.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/data/overload2.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/data_type.html
-/doc/html/boost_asio/reference/generic__basic_endpoint.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_eq_/
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_eq__eq_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_eq_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_gt__eq_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_gt_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_lt__eq_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_lt_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/operator_not__eq_.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/protocol.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/protocol_type.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/resize.html
-/doc/html/boost_asio/reference/generic__basic_endpoint/size.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/
-/doc/html/boost_asio/reference/generic__datagram_protocol/datagram_protocol/
-/doc/html/boost_asio/reference/generic__datagram_protocol/datagram_protocol.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/datagram_protocol/overload1.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/datagram_protocol/overload2.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/endpoint.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/family.html
-/doc/html/boost_asio/reference/generic__datagram_protocol.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/operator_eq__eq_.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/operator_not__eq_.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/protocol.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/socket.html
-/doc/html/boost_asio/reference/generic__datagram_protocol/type.html
-/doc/html/boost_asio/reference/generic__raw_protocol/
-/doc/html/boost_asio/reference/generic__raw_protocol/endpoint.html
-/doc/html/boost_asio/reference/generic__raw_protocol/family.html
-/doc/html/boost_asio/reference/generic__raw_protocol.html
-/doc/html/boost_asio/reference/generic__raw_protocol/operator_eq__eq_.html
-/doc/html/boost_asio/reference/generic__raw_protocol/operator_not__eq_.html
-/doc/html/boost_asio/reference/generic__raw_protocol/protocol.html
-/doc/html/boost_asio/reference/generic__raw_protocol/raw_protocol/
-/doc/html/boost_asio/reference/generic__raw_protocol/raw_protocol.html
-/doc/html/boost_asio/reference/generic__raw_protocol/raw_protocol/overload1.html
-/doc/html/boost_asio/reference/generic__raw_protocol/raw_protocol/overload2.html
-/doc/html/boost_asio/reference/generic__raw_protocol/socket.html
-/doc/html/boost_asio/reference/generic__raw_protocol/type.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/endpoint.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/family.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/operator_eq__eq_.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/operator_not__eq_.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/protocol.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/seq_packet_protocol/
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/seq_packet_protocol.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/seq_packet_protocol/overload1.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/seq_packet_protocol/overload2.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/socket.html
-/doc/html/boost_asio/reference/generic__seq_packet_protocol/type.html
-/doc/html/boost_asio/reference/generic__stream_protocol/
-/doc/html/boost_asio/reference/generic__stream_protocol/endpoint.html
-/doc/html/boost_asio/reference/generic__stream_protocol/family.html
-/doc/html/boost_asio/reference/generic__stream_protocol.html
-/doc/html/boost_asio/reference/generic__stream_protocol/iostream.html
-/doc/html/boost_asio/reference/generic__stream_protocol/operator_eq__eq_.html
-/doc/html/boost_asio/reference/generic__stream_protocol/operator_not__eq_.html
-/doc/html/boost_asio/reference/generic__stream_protocol/protocol.html
-/doc/html/boost_asio/reference/generic__stream_protocol/socket.html
-/doc/html/boost_asio/reference/generic__stream_protocol/stream_protocol/
-/doc/html/boost_asio/reference/generic__stream_protocol/stream_protocol.html
-/doc/html/boost_asio/reference/generic__stream_protocol/stream_protocol/overload1.html
-/doc/html/boost_asio/reference/generic__stream_protocol/stream_protocol/overload2.html
-/doc/html/boost_asio/reference/generic__stream_protocol/type.html
-/doc/html/boost_asio/reference/get_associated_allocator/
-/doc/html/boost_asio/reference/get_associated_allocator.html
-/doc/html/boost_asio/reference/get_associated_allocator/overload1.html
-/doc/html/boost_asio/reference/get_associated_allocator/overload2.html
-/doc/html/boost_asio/reference/get_associated_cancellation_slot/
-/doc/html/boost_asio/reference/get_associated_cancellation_slot.html
-/doc/html/boost_asio/reference/get_associated_cancellation_slot/overload1.html
-/doc/html/boost_asio/reference/get_associated_cancellation_slot/overload2.html
-/doc/html/boost_asio/reference/get_associated_executor/
-/doc/html/boost_asio/reference/get_associated_executor.html
-/doc/html/boost_asio/reference/get_associated_executor/overload1.html
-/doc/html/boost_asio/reference/get_associated_executor/overload2.html
-/doc/html/boost_asio/reference/get_associated_executor/overload3.html
-/doc/html/boost_asio/reference/get_associated_immediate_executor/
-/doc/html/boost_asio/reference/get_associated_immediate_executor.html
-/doc/html/boost_asio/reference/get_associated_immediate_executor/overload1.html
-/doc/html/boost_asio/reference/get_associated_immediate_executor/overload2.html
-/doc/html/boost_asio/reference/GettableSerialPortOption.html
-/doc/html/boost_asio/reference/GettableSocketOption.html
-/doc/html/boost_asio/reference/Handler.html
-/doc/html/boost_asio/reference/HandshakeHandler.html
-/doc/html/boost_asio/reference/HandshakeToken.html
-/doc/html/boost_asio/reference/high_resolution_timer.html
-/doc/html/boost_asio/reference.html
-/doc/html/boost_asio/reference/immediate_executor_binder/
-/doc/html/boost_asio/reference/immediate_executor_binder/argument_type.html
-/doc/html/boost_asio/reference/immediate_executor_binder/first_argument_type.html
-/doc/html/boost_asio/reference/immediate_executor_binder/get/
-/doc/html/boost_asio/reference/immediate_executor_binder/get.html
-/doc/html/boost_asio/reference/immediate_executor_binder/get_immediate_executor.html
-/doc/html/boost_asio/reference/immediate_executor_binder/get/overload1.html
-/doc/html/boost_asio/reference/immediate_executor_binder/get/overload2.html
-/doc/html/boost_asio/reference/immediate_executor_binder.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/
-/doc/html/boost_asio/reference/immediate_executor_binder/_immediate_executor_binder.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload1.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload2.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload3.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload4.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload5.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload6.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload7.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload8.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_binder/overload9.html
-/doc/html/boost_asio/reference/immediate_executor_binder/immediate_executor_type.html
-/doc/html/boost_asio/reference/immediate_executor_binder/operator_lp__rp_/
-/doc/html/boost_asio/reference/immediate_executor_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/immediate_executor_binder/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/immediate_executor_binder/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/immediate_executor_binder/result_type.html
-/doc/html/boost_asio/reference/immediate_executor_binder/second_argument_type.html
-/doc/html/boost_asio/reference/immediate_executor_binder/target_type.html
-/doc/html/boost_asio/reference/InternetProtocol.html
-/doc/html/boost_asio/reference/invalid_service_owner/
-/doc/html/boost_asio/reference/invalid_service_owner.html
-/doc/html/boost_asio/reference/invalid_service_owner/invalid_service_owner.html
-/doc/html/boost_asio/reference/io_context/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/basic_executor_type/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/_basic_executor_type.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/basic_executor_type.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/basic_executor_type/overload1.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/basic_executor_type/overload2.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/context.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/defer.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/dispatch.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/execute.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/on_work_finished.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/on_work_started.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_eq_/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_eq__eq_.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_eq_.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/operator_not__eq_.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/post.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/overload1.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/overload2.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/overload3.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/overload4.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query/overload5.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query__static/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query__static.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query__static/overload1.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/query__static/overload2.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload1.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload2.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload3.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload4.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload5.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload6.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload7.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/require/overload8.html
-/doc/html/boost_asio/reference/io_context__basic_executor_type/running_in_this_thread.html
-/doc/html/boost_asio/reference/io_context/count_type.html
-/doc/html/boost_asio/reference/io_context/destroy.html
-/doc/html/boost_asio/reference/io_context/dispatch.html
-/doc/html/boost_asio/reference/io_context/executor_type.html
-/doc/html/boost_asio/reference/io_context/fork_event.html
-/doc/html/boost_asio/reference/io_context/get_executor.html
-/doc/html/boost_asio/reference/io_context.html
-/doc/html/boost_asio/reference/io_context/io_context/
-/doc/html/boost_asio/reference/io_context/_io_context.html
-/doc/html/boost_asio/reference/io_context/io_context.html
-/doc/html/boost_asio/reference/io_context/io_context/overload1.html
-/doc/html/boost_asio/reference/io_context/io_context/overload2.html
-/doc/html/boost_asio/reference/io_context/notify_fork.html
-/doc/html/boost_asio/reference/io_context/poll/
-/doc/html/boost_asio/reference/io_context/poll.html
-/doc/html/boost_asio/reference/io_context/poll_one/
-/doc/html/boost_asio/reference/io_context/poll_one.html
-/doc/html/boost_asio/reference/io_context/poll_one/overload1.html
-/doc/html/boost_asio/reference/io_context/poll_one/overload2.html
-/doc/html/boost_asio/reference/io_context/poll/overload1.html
-/doc/html/boost_asio/reference/io_context/poll/overload2.html
-/doc/html/boost_asio/reference/io_context/post.html
-/doc/html/boost_asio/reference/io_context/reset.html
-/doc/html/boost_asio/reference/io_context/restart.html
-/doc/html/boost_asio/reference/io_context/run/
-/doc/html/boost_asio/reference/io_context/run_for.html
-/doc/html/boost_asio/reference/io_context/run.html
-/doc/html/boost_asio/reference/io_context/run_one/
-/doc/html/boost_asio/reference/io_context/run_one_for.html
-/doc/html/boost_asio/reference/io_context/run_one.html
-/doc/html/boost_asio/reference/io_context/run_one/overload1.html
-/doc/html/boost_asio/reference/io_context/run_one/overload2.html
-/doc/html/boost_asio/reference/io_context/run_one_until.html
-/doc/html/boost_asio/reference/io_context/run/overload1.html
-/doc/html/boost_asio/reference/io_context/run/overload2.html
-/doc/html/boost_asio/reference/io_context/run_until.html
-/doc/html/boost_asio/reference/io_context__service/
-/doc/html/boost_asio/reference/io_context__service/context.html
-/doc/html/boost_asio/reference/io_context__service/get_io_context.html
-/doc/html/boost_asio/reference/io_context__service.html
-/doc/html/boost_asio/reference/io_context__service/_service.html
-/doc/html/boost_asio/reference/io_context__service/service.html
-/doc/html/boost_asio/reference/io_context/shutdown.html
-/doc/html/boost_asio/reference/io_context/stop.html
-/doc/html/boost_asio/reference/io_context/stopped.html
-/doc/html/boost_asio/reference/io_context__strand/
-/doc/html/boost_asio/reference/io_context__strand/context.html
-/doc/html/boost_asio/reference/io_context__strand/defer.html
-/doc/html/boost_asio/reference/io_context__strand/dispatch/
-/doc/html/boost_asio/reference/io_context__strand/dispatch.html
-/doc/html/boost_asio/reference/io_context__strand/dispatch/overload1.html
-/doc/html/boost_asio/reference/io_context__strand/dispatch/overload2.html
-/doc/html/boost_asio/reference/io_context__strand.html
-/doc/html/boost_asio/reference/io_context__strand/on_work_finished.html
-/doc/html/boost_asio/reference/io_context__strand/on_work_started.html
-/doc/html/boost_asio/reference/io_context__strand/operator_eq__eq_.html
-/doc/html/boost_asio/reference/io_context__strand/operator_not__eq_.html
-/doc/html/boost_asio/reference/io_context__strand/post/
-/doc/html/boost_asio/reference/io_context__strand/post.html
-/doc/html/boost_asio/reference/io_context__strand/post/overload1.html
-/doc/html/boost_asio/reference/io_context__strand/post/overload2.html
-/doc/html/boost_asio/reference/io_context__strand/running_in_this_thread.html
-/doc/html/boost_asio/reference/io_context__strand/strand/
-/doc/html/boost_asio/reference/io_context__strand/_strand.html
-/doc/html/boost_asio/reference/io_context__strand/strand.html
-/doc/html/boost_asio/reference/io_context__strand/strand/overload1.html
-/doc/html/boost_asio/reference/io_context__strand/strand/overload2.html
-/doc/html/boost_asio/reference/io_context__strand/wrap.html
-/doc/html/boost_asio/reference/io_context/use_service.html
-/doc/html/boost_asio/reference/io_context__work/
-/doc/html/boost_asio/reference/io_context__work/get_io_context.html
-/doc/html/boost_asio/reference/io_context__work.html
-/doc/html/boost_asio/reference/io_context__work/work/
-/doc/html/boost_asio/reference/io_context__work/_work.html
-/doc/html/boost_asio/reference/io_context__work/work.html
-/doc/html/boost_asio/reference/io_context__work/work/overload1.html
-/doc/html/boost_asio/reference/io_context__work/work/overload2.html
-/doc/html/boost_asio/reference/io_context/wrap.html
-/doc/html/boost_asio/reference/IoControlCommand.html
-/doc/html/boost_asio/reference/IoObjectService.html
-/doc/html/boost_asio/reference/io_service.html
-/doc/html/boost_asio/reference/ip__address/
-/doc/html/boost_asio/reference/ip__address/address/
-/doc/html/boost_asio/reference/ip__address/address.html
-/doc/html/boost_asio/reference/ip__address/address/overload1.html
-/doc/html/boost_asio/reference/ip__address/address/overload2.html
-/doc/html/boost_asio/reference/ip__address/address/overload3.html
-/doc/html/boost_asio/reference/ip__address/address/overload4.html
-/doc/html/boost_asio/reference/ip__address/address/overload5.html
-/doc/html/boost_asio/reference/ip__address/from_string/
-/doc/html/boost_asio/reference/ip__address/from_string.html
-/doc/html/boost_asio/reference/ip__address/from_string/overload1.html
-/doc/html/boost_asio/reference/ip__address/from_string/overload2.html
-/doc/html/boost_asio/reference/ip__address/from_string/overload3.html
-/doc/html/boost_asio/reference/ip__address/from_string/overload4.html
-/doc/html/boost_asio/reference/ip__address__gt_/
-/doc/html/boost_asio/reference/ip__address__gt_.html
-/doc/html/boost_asio/reference/ip__address__gt_/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ip__address.html
-/doc/html/boost_asio/reference/ip__address/is_loopback.html
-/doc/html/boost_asio/reference/ip__address/is_multicast.html
-/doc/html/boost_asio/reference/ip__address/is_unspecified.html
-/doc/html/boost_asio/reference/ip__address/is_v4.html
-/doc/html/boost_asio/reference/ip__address/is_v6.html
-/doc/html/boost_asio/reference/ip__address/make_address/
-/doc/html/boost_asio/reference/ip__address/make_address.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload1.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload2.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload3.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload4.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload5.html
-/doc/html/boost_asio/reference/ip__address/make_address/overload6.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_/
-/doc/html/boost_asio/reference/ip__address/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/ip__address/operator_eq_/overload4.html
-/doc/html/boost_asio/reference/ip__address/operator_gt__eq_.html
-/doc/html/boost_asio/reference/ip__address/operator_gt_.html
-/doc/html/boost_asio/reference/ip__address/operator_lt__eq_.html
-/doc/html/boost_asio/reference/ip__address/operator_lt_.html
-/doc/html/boost_asio/reference/ip__address/operator_lt__lt_.html
-/doc/html/boost_asio/reference/ip__address/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__address/to_string/
-/doc/html/boost_asio/reference/ip__address/to_string.html
-/doc/html/boost_asio/reference/ip__address/to_string/overload1.html
-/doc/html/boost_asio/reference/ip__address/to_string/overload2.html
-/doc/html/boost_asio/reference/ip__address/to_v4.html
-/doc/html/boost_asio/reference/ip__address/to_v6.html
-/doc/html/boost_asio/reference/ip__address_v4/
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/
-/doc/html/boost_asio/reference/ip__address_v4/address_v4.html
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/overload3.html
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/overload4.html
-/doc/html/boost_asio/reference/ip__address_v4/address_v4/overload5.html
-/doc/html/boost_asio/reference/ip__address_v4/any.html
-/doc/html/boost_asio/reference/ip__address_v4/broadcast/
-/doc/html/boost_asio/reference/ip__address_v4/broadcast.html
-/doc/html/boost_asio/reference/ip__address_v4/broadcast/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/broadcast/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/bytes_type.html
-/doc/html/boost_asio/reference/ip__address_v4/from_string/
-/doc/html/boost_asio/reference/ip__address_v4/from_string.html
-/doc/html/boost_asio/reference/ip__address_v4/from_string/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/from_string/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/from_string/overload3.html
-/doc/html/boost_asio/reference/ip__address_v4/from_string/overload4.html
-/doc/html/boost_asio/reference/ip__address_v4__gt_/
-/doc/html/boost_asio/reference/ip__address_v4__gt_.html
-/doc/html/boost_asio/reference/ip__address_v4__gt_/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ip__address_v4.html
-/doc/html/boost_asio/reference/ip__address_v4/is_class_a.html
-/doc/html/boost_asio/reference/ip__address_v4/is_class_b.html
-/doc/html/boost_asio/reference/ip__address_v4/is_class_c.html
-/doc/html/boost_asio/reference/ip__address_v4/is_loopback.html
-/doc/html/boost_asio/reference/ip__address_v4/is_multicast.html
-/doc/html/boost_asio/reference/ip__address_v4/is_unspecified.html
-/doc/html/boost_asio/reference/ip__address_v4_iterator.html
-/doc/html/boost_asio/reference/ip__address_v4/loopback.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload3.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload4.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload5.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload6.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload7.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload8.html
-/doc/html/boost_asio/reference/ip__address_v4/make_address_v4/overload9.html
-/doc/html/boost_asio/reference/ip__address_v4/make_network_v4/
-/doc/html/boost_asio/reference/ip__address_v4/make_network_v4.html
-/doc/html/boost_asio/reference/ip__address_v4/make_network_v4/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/make_network_v4/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/netmask.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_eq_/
-/doc/html/boost_asio/reference/ip__address_v4/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_eq_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_gt__eq_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_gt_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt__eq_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt__lt_/
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt__lt_.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt__lt_/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_lt__lt_/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__address_v4_range.html
-/doc/html/boost_asio/reference/ip__address_v4/to_bytes.html
-/doc/html/boost_asio/reference/ip__address_v4/to_string/
-/doc/html/boost_asio/reference/ip__address_v4/to_string.html
-/doc/html/boost_asio/reference/ip__address_v4/to_string/overload1.html
-/doc/html/boost_asio/reference/ip__address_v4/to_string/overload2.html
-/doc/html/boost_asio/reference/ip__address_v4/to_uint.html
-/doc/html/boost_asio/reference/ip__address_v4/to_ulong.html
-/doc/html/boost_asio/reference/ip__address_v4/uint_type.html
-/doc/html/boost_asio/reference/ip__address_v6/
-/doc/html/boost_asio/reference/ip__address_v6/address_v6/
-/doc/html/boost_asio/reference/ip__address_v6/address_v6.html
-/doc/html/boost_asio/reference/ip__address_v6/address_v6/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/address_v6/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/address_v6/overload3.html
-/doc/html/boost_asio/reference/ip__address_v6/address_v6/overload4.html
-/doc/html/boost_asio/reference/ip__address_v6/any.html
-/doc/html/boost_asio/reference/ip__address_v6/bytes_type.html
-/doc/html/boost_asio/reference/ip__address_v6/from_string/
-/doc/html/boost_asio/reference/ip__address_v6/from_string.html
-/doc/html/boost_asio/reference/ip__address_v6/from_string/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/from_string/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/from_string/overload3.html
-/doc/html/boost_asio/reference/ip__address_v6/from_string/overload4.html
-/doc/html/boost_asio/reference/ip__address_v6__gt_/
-/doc/html/boost_asio/reference/ip__address_v6__gt_.html
-/doc/html/boost_asio/reference/ip__address_v6__gt_/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ip__address_v6.html
-/doc/html/boost_asio/reference/ip__address_v6/is_link_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_loopback.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast_global.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast_link_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast_node_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast_org_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_multicast_site_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_site_local.html
-/doc/html/boost_asio/reference/ip__address_v6/is_unspecified.html
-/doc/html/boost_asio/reference/ip__address_v6/is_v4_compatible.html
-/doc/html/boost_asio/reference/ip__address_v6/is_v4_mapped.html
-/doc/html/boost_asio/reference/ip__address_v6_iterator.html
-/doc/html/boost_asio/reference/ip__address_v6/loopback.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload3.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload4.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload5.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload6.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload7.html
-/doc/html/boost_asio/reference/ip__address_v6/make_address_v6/overload8.html
-/doc/html/boost_asio/reference/ip__address_v6/make_network_v6.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_eq_/
-/doc/html/boost_asio/reference/ip__address_v6/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_eq_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_gt__eq_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_gt_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt__eq_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt__lt_/
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt__lt_.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt__lt_/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_lt__lt_/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__address_v6_range.html
-/doc/html/boost_asio/reference/ip__address_v6/scope_id/
-/doc/html/boost_asio/reference/ip__address_v6/scope_id.html
-/doc/html/boost_asio/reference/ip__address_v6/scope_id/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/scope_id/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/to_bytes.html
-/doc/html/boost_asio/reference/ip__address_v6/to_string/
-/doc/html/boost_asio/reference/ip__address_v6/to_string.html
-/doc/html/boost_asio/reference/ip__address_v6/to_string/overload1.html
-/doc/html/boost_asio/reference/ip__address_v6/to_string/overload2.html
-/doc/html/boost_asio/reference/ip__address_v6/to_v4.html
-/doc/html/boost_asio/reference/ip__address_v6/v4_compatible.html
-/doc/html/boost_asio/reference/ip__address_v6/v4_mapped.html
-/doc/html/boost_asio/reference/ip__bad_address_cast/
-/doc/html/boost_asio/reference/ip__bad_address_cast/bad_address_cast/
-/doc/html/boost_asio/reference/ip__bad_address_cast/_bad_address_cast.html
-/doc/html/boost_asio/reference/ip__bad_address_cast/bad_address_cast.html
-/doc/html/boost_asio/reference/ip__bad_address_cast/bad_address_cast/overload1.html
-/doc/html/boost_asio/reference/ip__bad_address_cast/bad_address_cast/overload2.html
-/doc/html/boost_asio/reference/ip__bad_address_cast.html
-/doc/html/boost_asio/reference/ip__bad_address_cast/what.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/basic_address_iterator/overload3.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/difference_type.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/iterator_category.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_arrow_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_minus__minus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_plus__plus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/operator_star_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/pointer.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/reference.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v4__gt_/value_type.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/basic_address_iterator/overload3.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/difference_type.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/iterator_category.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_arrow_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_minus__minus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_plus__plus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/operator_star_.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/pointer.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/reference.html
-/doc/html/boost_asio/reference/ip__basic_address_iterator_lt__address_v6__gt_/value_type.html
-/doc/html/boost_asio/reference/ip__basic_address_range.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload3.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/basic_address_range/overload4.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/begin.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/empty.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/end.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/find.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/iterator.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v4__gt_/size.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload2.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload3.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/basic_address_range/overload4.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/begin.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/empty.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/end.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/find.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/iterator.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_address_range_lt__address_v6__gt_/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/
-/doc/html/boost_asio/reference/ip__basic_endpoint/address/
-/doc/html/boost_asio/reference/ip__basic_endpoint/address.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/address/overload1.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/address/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/overload1.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/overload3.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/overload4.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/basic_endpoint/overload5.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/capacity.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/data/
-/doc/html/boost_asio/reference/ip__basic_endpoint/data.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/data/overload1.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/data/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/data_type.html
-/doc/html/boost_asio/reference/ip__basic_endpoint.html
-/doc/html/boost_asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_/
-/doc/html/boost_asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint_lt__InternetProtocol__gt___gt_/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_gt__eq_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_gt_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_lt__eq_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_lt_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_lt__lt_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/port/
-/doc/html/boost_asio/reference/ip__basic_endpoint/port.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/port/overload1.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/port/overload2.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/protocol.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/protocol_type.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/resize.html
-/doc/html/boost_asio/reference/ip__basic_endpoint/size.html
-/doc/html/boost_asio/reference/ip__basic_resolver/
-/doc/html/boost_asio/reference/ip__basic_resolver/address_configured.html
-/doc/html/boost_asio/reference/ip__basic_resolver/all_matching.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload4.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload5.html
-/doc/html/boost_asio/reference/ip__basic_resolver/async_resolve/overload6.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver/
-/doc/html/boost_asio/reference/ip__basic_resolver/_basic_resolver.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver/basic_resolver/overload4.html
-/doc/html/boost_asio/reference/ip__basic_resolver/cancel.html
-/doc/html/boost_asio/reference/ip__basic_resolver/canonical_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver/endpoint_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/basic_resolver_entry/
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/basic_resolver_entry.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/basic_resolver_entry/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/basic_resolver_entry/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/endpoint.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/endpoint_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/host_name/
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/host_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/host_name/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/host_name/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/operator_endpoint_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/protocol_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/service_name/
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/service_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/service_name/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_entry/service_name/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver/executor_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver/flags.html
-/doc/html/boost_asio/reference/ip__basic_resolver/get_executor.html
-/doc/html/boost_asio/reference/ip__basic_resolver.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/basic_resolver_iterator/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/dereference.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/difference_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/equal.html
-/doc/html/boost_asio/reference/ip__basic_resolver/iterator.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/increment.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/index_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/iterator_category.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_arrow_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_plus__plus_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_plus__plus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/operator_star_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/pointer.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/reference.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/values_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_iterator/value_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver/numeric_host.html
-/doc/html/boost_asio/reference/ip__basic_resolver/numeric_service.html
-/doc/html/boost_asio/reference/ip__basic_resolver/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_resolver/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver/passive.html
-/doc/html/boost_asio/reference/ip__basic_resolver/protocol_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/
-/doc/html/boost_asio/reference/ip__basic_resolver_query/address_configured.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/all_matching.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload4.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload5.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/basic_resolver_query/overload6.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/canonical_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/flags.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/hints.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/host_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver/query.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/numeric_host.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/numeric_service.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/passive.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/protocol_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/service_name.html
-/doc/html/boost_asio/reference/ip__basic_resolver_query/v4_mapped.html
-/doc/html/boost_asio/reference/ip__basic_resolver__rebind_executor/
-/doc/html/boost_asio/reference/ip__basic_resolver__rebind_executor.html
-/doc/html/boost_asio/reference/ip__basic_resolver__rebind_executor/other.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload10.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload11.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload12.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload4.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload5.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload6.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload7.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload8.html
-/doc/html/boost_asio/reference/ip__basic_resolver/resolve/overload9.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/
-/doc/html/boost_asio/reference/ip__basic_resolver_results/basic_resolver_results/
-/doc/html/boost_asio/reference/ip__basic_resolver_results/basic_resolver_results.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/basic_resolver_results/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/basic_resolver_results/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/basic_resolver_results/overload3.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/begin.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/cbegin.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/cend.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/const_iterator.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/const_reference.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/dereference.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/difference_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/empty.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/end.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/endpoint_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/equal.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/increment.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/index_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/iterator_category.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/iterator.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/max_size.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_arrow_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_eq_/
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_plus__plus_/
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_plus__plus_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_plus__plus_/overload1.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_plus__plus_/overload2.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/operator_star_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/pointer.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/protocol_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/reference.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/size.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/size_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/swap.html
-/doc/html/boost_asio/reference/ip__basic_resolver/results_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/values_.html
-/doc/html/boost_asio/reference/ip__basic_resolver_results/value_type.html
-/doc/html/boost_asio/reference/ip__basic_resolver/v4_mapped.html
-/doc/html/boost_asio/reference/ip__host_name/
-/doc/html/boost_asio/reference/ip__host_name.html
-/doc/html/boost_asio/reference/ip__host_name/overload1.html
-/doc/html/boost_asio/reference/ip__host_name/overload2.html
-/doc/html/boost_asio/reference/ip__icmp/
-/doc/html/boost_asio/reference/ip__icmp/endpoint.html
-/doc/html/boost_asio/reference/ip__icmp/family.html
-/doc/html/boost_asio/reference/ip__icmp.html
-/doc/html/boost_asio/reference/ip__icmp/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__icmp/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__icmp/protocol.html
-/doc/html/boost_asio/reference/ip__icmp/resolver.html
-/doc/html/boost_asio/reference/ip__icmp/socket.html
-/doc/html/boost_asio/reference/ip__icmp/type.html
-/doc/html/boost_asio/reference/ip__icmp/v4.html
-/doc/html/boost_asio/reference/ip__icmp/v6.html
-/doc/html/boost_asio/reference/ip__multicast__enable_loopback.html
-/doc/html/boost_asio/reference/ip__multicast__hops.html
-/doc/html/boost_asio/reference/ip__multicast__join_group.html
-/doc/html/boost_asio/reference/ip__multicast__leave_group.html
-/doc/html/boost_asio/reference/ip__multicast__outbound_interface.html
-/doc/html/boost_asio/reference/ip__network_v4/
-/doc/html/boost_asio/reference/ip__network_v4/address.html
-/doc/html/boost_asio/reference/ip__network_v4/broadcast.html
-/doc/html/boost_asio/reference/ip__network_v4/canonical.html
-/doc/html/boost_asio/reference/ip__network_v4/hosts.html
-/doc/html/boost_asio/reference/ip__network_v4.html
-/doc/html/boost_asio/reference/ip__network_v4/is_host.html
-/doc/html/boost_asio/reference/ip__network_v4/is_subnet_of.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload1.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload2.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload3.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload4.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload5.html
-/doc/html/boost_asio/reference/ip__network_v4/make_network_v4/overload6.html
-/doc/html/boost_asio/reference/ip__network_v4/netmask.html
-/doc/html/boost_asio/reference/ip__network_v4/network.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/
-/doc/html/boost_asio/reference/ip__network_v4/network_v4.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/overload1.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/overload2.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/overload3.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/overload4.html
-/doc/html/boost_asio/reference/ip__network_v4/network_v4/overload5.html
-/doc/html/boost_asio/reference/ip__network_v4/operator_eq_/
-/doc/html/boost_asio/reference/ip__network_v4/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__network_v4/operator_eq_.html
-/doc/html/boost_asio/reference/ip__network_v4/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__network_v4/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__network_v4/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__network_v4/prefix_length.html
-/doc/html/boost_asio/reference/ip__network_v4/to_string/
-/doc/html/boost_asio/reference/ip__network_v4/to_string.html
-/doc/html/boost_asio/reference/ip__network_v4/to_string/overload1.html
-/doc/html/boost_asio/reference/ip__network_v4/to_string/overload2.html
-/doc/html/boost_asio/reference/ip__network_v6/
-/doc/html/boost_asio/reference/ip__network_v6/address.html
-/doc/html/boost_asio/reference/ip__network_v6/canonical.html
-/doc/html/boost_asio/reference/ip__network_v6/hosts.html
-/doc/html/boost_asio/reference/ip__network_v6.html
-/doc/html/boost_asio/reference/ip__network_v6/is_host.html
-/doc/html/boost_asio/reference/ip__network_v6/is_subnet_of.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload1.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload2.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload3.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload4.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload5.html
-/doc/html/boost_asio/reference/ip__network_v6/make_network_v6/overload6.html
-/doc/html/boost_asio/reference/ip__network_v6/network.html
-/doc/html/boost_asio/reference/ip__network_v6/network_v6/
-/doc/html/boost_asio/reference/ip__network_v6/network_v6.html
-/doc/html/boost_asio/reference/ip__network_v6/network_v6/overload1.html
-/doc/html/boost_asio/reference/ip__network_v6/network_v6/overload2.html
-/doc/html/boost_asio/reference/ip__network_v6/network_v6/overload3.html
-/doc/html/boost_asio/reference/ip__network_v6/network_v6/overload4.html
-/doc/html/boost_asio/reference/ip__network_v6/operator_eq_/
-/doc/html/boost_asio/reference/ip__network_v6/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__network_v6/operator_eq_.html
-/doc/html/boost_asio/reference/ip__network_v6/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/ip__network_v6/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/ip__network_v6/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__network_v6/prefix_length.html
-/doc/html/boost_asio/reference/ip__network_v6/to_string/
-/doc/html/boost_asio/reference/ip__network_v6/to_string.html
-/doc/html/boost_asio/reference/ip__network_v6/to_string/overload1.html
-/doc/html/boost_asio/reference/ip__network_v6/to_string/overload2.html
-/doc/html/boost_asio/reference/ip__port_type.html
-/doc/html/boost_asio/reference/ip__resolver_base/
-/doc/html/boost_asio/reference/ip__resolver_base/address_configured.html
-/doc/html/boost_asio/reference/ip__resolver_base/all_matching.html
-/doc/html/boost_asio/reference/ip__resolver_base/canonical_name.html
-/doc/html/boost_asio/reference/ip__resolver_base/flags.html
-/doc/html/boost_asio/reference/ip__resolver_base.html
-/doc/html/boost_asio/reference/ip__resolver_base/numeric_host.html
-/doc/html/boost_asio/reference/ip__resolver_base/numeric_service.html
-/doc/html/boost_asio/reference/ip__resolver_base/passive.html
-/doc/html/boost_asio/reference/ip__resolver_base/_resolver_base.html
-/doc/html/boost_asio/reference/ip__resolver_base/v4_mapped.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/
-/doc/html/boost_asio/reference/ip__resolver_query_base/address_configured.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/all_matching.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/canonical_name.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/flags.html
-/doc/html/boost_asio/reference/ip__resolver_query_base.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/numeric_host.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/numeric_service.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/passive.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/_resolver_query_base.html
-/doc/html/boost_asio/reference/ip__resolver_query_base/v4_mapped.html
-/doc/html/boost_asio/reference/ip__scope_id_type.html
-/doc/html/boost_asio/reference/ip__tcp/
-/doc/html/boost_asio/reference/ip__tcp/acceptor.html
-/doc/html/boost_asio/reference/ip__tcp/endpoint.html
-/doc/html/boost_asio/reference/ip__tcp/family.html
-/doc/html/boost_asio/reference/ip__tcp.html
-/doc/html/boost_asio/reference/ip__tcp/iostream.html
-/doc/html/boost_asio/reference/ip__tcp/no_delay.html
-/doc/html/boost_asio/reference/ip__tcp/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__tcp/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__tcp/protocol.html
-/doc/html/boost_asio/reference/ip__tcp/resolver.html
-/doc/html/boost_asio/reference/ip__tcp/socket.html
-/doc/html/boost_asio/reference/ip__tcp/type.html
-/doc/html/boost_asio/reference/ip__tcp/v4.html
-/doc/html/boost_asio/reference/ip__tcp/v6.html
-/doc/html/boost_asio/reference/ip__udp/
-/doc/html/boost_asio/reference/ip__udp/endpoint.html
-/doc/html/boost_asio/reference/ip__udp/family.html
-/doc/html/boost_asio/reference/ip__udp.html
-/doc/html/boost_asio/reference/ip__udp/operator_eq__eq_.html
-/doc/html/boost_asio/reference/ip__udp/operator_not__eq_.html
-/doc/html/boost_asio/reference/ip__udp/protocol.html
-/doc/html/boost_asio/reference/ip__udp/resolver.html
-/doc/html/boost_asio/reference/ip__udp/socket.html
-/doc/html/boost_asio/reference/ip__udp/type.html
-/doc/html/boost_asio/reference/ip__udp/v4.html
-/doc/html/boost_asio/reference/ip__udp/v6.html
-/doc/html/boost_asio/reference/ip__unicast__hops.html
-/doc/html/boost_asio/reference/ip__v4_mapped_t.html
-/doc/html/boost_asio/reference/ip__v6_only.html
-/doc/html/boost_asio/reference/is_applicable_property.html
-/doc/html/boost_asio/reference/is_async_operation.html
-/doc/html/boost_asio/reference/is_completion_condition/
-/doc/html/boost_asio/reference/is_completion_condition.html
-/doc/html/boost_asio/reference/is_completion_condition/value.html
-/doc/html/boost_asio/reference/is_connect_condition/
-/doc/html/boost_asio/reference/is_connect_condition.html
-/doc/html/boost_asio/reference/is_connect_condition/value.html
-/doc/html/boost_asio/reference/is_const_buffer_sequence.html
-/doc/html/boost_asio/reference/is_contiguous_iterator.html
-/doc/html/boost_asio/reference/is_deferred.html
-/doc/html/boost_asio/reference/is_dynamic_buffer.html
-/doc/html/boost_asio/reference/is_dynamic_buffer_v1.html
-/doc/html/boost_asio/reference/is_dynamic_buffer_v2.html
-/doc/html/boost_asio/reference/is_endpoint_sequence/
-/doc/html/boost_asio/reference/is_endpoint_sequence.html
-/doc/html/boost_asio/reference/is_endpoint_sequence/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__addrinfo_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__addrinfo_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__addrinfo_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__basic_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__basic_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__basic_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__experimental__error__channel_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__experimental__error__channel_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__experimental__error__channel_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__ssl__error__stream_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__ssl__error__stream_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__boost__asio__ssl__error__stream_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__misc_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__misc_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__misc_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__netdb_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__netdb_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__netdb_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__ssl_errors__gt_/
-/doc/html/boost_asio/reference/is_error_code_enum_lt__ssl_errors__gt_.html
-/doc/html/boost_asio/reference/is_error_code_enum_lt__ssl_errors__gt_/value.html
-/doc/html/boost_asio/reference/is_executor.html
-/doc/html/boost_asio/reference/is_match_condition/
-/doc/html/boost_asio/reference/is_match_condition.html
-/doc/html/boost_asio/reference/is_match_condition/value.html
-/doc/html/boost_asio/reference/is_mutable_buffer_sequence.html
-/doc/html/boost_asio/reference/is_nothrow_prefer.html
-/doc/html/boost_asio/reference/is_nothrow_query.html
-/doc/html/boost_asio/reference/is_nothrow_require_concept.html
-/doc/html/boost_asio/reference/is_nothrow_require.html
-/doc/html/boost_asio/reference/is_read_buffered/
-/doc/html/boost_asio/reference/is_read_buffered.html
-/doc/html/boost_asio/reference/is_read_buffered/value.html
-/doc/html/boost_asio/reference/is_write_buffered/
-/doc/html/boost_asio/reference/is_write_buffered.html
-/doc/html/boost_asio/reference/is_write_buffered/value.html
-/doc/html/boost_asio/reference/IteratorConnectHandler.html
-/doc/html/boost_asio/reference/IteratorConnectToken.html
-/doc/html/boost_asio/reference/LegacyCompletionHandler.html
-/doc/html/boost_asio/reference/local__basic_endpoint/
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint.html
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/overload1.html
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/overload2.html
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/overload3.html
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/overload4.html
-/doc/html/boost_asio/reference/local__basic_endpoint/basic_endpoint/overload5.html
-/doc/html/boost_asio/reference/local__basic_endpoint/capacity.html
-/doc/html/boost_asio/reference/local__basic_endpoint/data/
-/doc/html/boost_asio/reference/local__basic_endpoint/data.html
-/doc/html/boost_asio/reference/local__basic_endpoint/data/overload1.html
-/doc/html/boost_asio/reference/local__basic_endpoint/data/overload2.html
-/doc/html/boost_asio/reference/local__basic_endpoint/data_type.html
-/doc/html/boost_asio/reference/local__basic_endpoint.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_eq_/
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_eq__eq_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_eq_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_gt__eq_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_gt_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_lt__eq_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_lt_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_lt__lt_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/operator_not__eq_.html
-/doc/html/boost_asio/reference/local__basic_endpoint/path/
-/doc/html/boost_asio/reference/local__basic_endpoint/path.html
-/doc/html/boost_asio/reference/local__basic_endpoint/path/overload1.html
-/doc/html/boost_asio/reference/local__basic_endpoint/path/overload2.html
-/doc/html/boost_asio/reference/local__basic_endpoint/path/overload3.html
-/doc/html/boost_asio/reference/local__basic_endpoint/protocol.html
-/doc/html/boost_asio/reference/local__basic_endpoint/protocol_type.html
-/doc/html/boost_asio/reference/local__basic_endpoint/resize.html
-/doc/html/boost_asio/reference/local__basic_endpoint/size.html
-/doc/html/boost_asio/reference/local__connect_pair/
-/doc/html/boost_asio/reference/local__connect_pair.html
-/doc/html/boost_asio/reference/local__connect_pair/overload1.html
-/doc/html/boost_asio/reference/local__connect_pair/overload2.html
-/doc/html/boost_asio/reference/local__datagram_protocol/
-/doc/html/boost_asio/reference/local__datagram_protocol/endpoint.html
-/doc/html/boost_asio/reference/local__datagram_protocol/family.html
-/doc/html/boost_asio/reference/local__datagram_protocol.html
-/doc/html/boost_asio/reference/local__datagram_protocol/protocol.html
-/doc/html/boost_asio/reference/local__datagram_protocol/socket.html
-/doc/html/boost_asio/reference/local__datagram_protocol/type.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/
-/doc/html/boost_asio/reference/local__seq_packet_protocol/acceptor.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/endpoint.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/family.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/protocol.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/socket.html
-/doc/html/boost_asio/reference/local__seq_packet_protocol/type.html
-/doc/html/boost_asio/reference/local__stream_protocol/
-/doc/html/boost_asio/reference/local__stream_protocol/acceptor.html
-/doc/html/boost_asio/reference/local__stream_protocol/endpoint.html
-/doc/html/boost_asio/reference/local__stream_protocol/family.html
-/doc/html/boost_asio/reference/local__stream_protocol.html
-/doc/html/boost_asio/reference/local__stream_protocol/iostream.html
-/doc/html/boost_asio/reference/local__stream_protocol/protocol.html
-/doc/html/boost_asio/reference/local__stream_protocol/socket.html
-/doc/html/boost_asio/reference/local__stream_protocol/type.html
-/doc/html/boost_asio/reference/make_strand/
-/doc/html/boost_asio/reference/make_strand.html
-/doc/html/boost_asio/reference/make_strand/overload1.html
-/doc/html/boost_asio/reference/make_strand/overload2.html
-/doc/html/boost_asio/reference/make_work_guard/
-/doc/html/boost_asio/reference/make_work_guard.html
-/doc/html/boost_asio/reference/make_work_guard/overload1.html
-/doc/html/boost_asio/reference/make_work_guard/overload2.html
-/doc/html/boost_asio/reference/make_work_guard/overload3.html
-/doc/html/boost_asio/reference/make_work_guard/overload4.html
-/doc/html/boost_asio/reference/make_work_guard/overload5.html
-/doc/html/boost_asio/reference/MoveAcceptHandler.html
-/doc/html/boost_asio/reference/MoveAcceptToken.html
-/doc/html/boost_asio/reference/multiple_exceptions/
-/doc/html/boost_asio/reference/multiple_exceptions/first_exception.html
-/doc/html/boost_asio/reference/multiple_exceptions.html
-/doc/html/boost_asio/reference/multiple_exceptions/multiple_exceptions.html
-/doc/html/boost_asio/reference/multiple_exceptions/what.html
-/doc/html/boost_asio/reference/mutable_buffer/
-/doc/html/boost_asio/reference/mutable_buffer/data.html
-/doc/html/boost_asio/reference/mutable_buffer.html
-/doc/html/boost_asio/reference/mutable_buffer/mutable_buffer/
-/doc/html/boost_asio/reference/mutable_buffer/mutable_buffer.html
-/doc/html/boost_asio/reference/mutable_buffer/mutable_buffer/overload1.html
-/doc/html/boost_asio/reference/mutable_buffer/mutable_buffer/overload2.html
-/doc/html/boost_asio/reference/mutable_buffer/operator_plus_/
-/doc/html/boost_asio/reference/mutable_buffer/operator_plus__eq_.html
-/doc/html/boost_asio/reference/mutable_buffer/operator_plus_.html
-/doc/html/boost_asio/reference/mutable_buffer/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/mutable_buffer/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/mutable_buffers_1/
-/doc/html/boost_asio/reference/mutable_buffers_1/begin.html
-/doc/html/boost_asio/reference/mutable_buffers_1/const_iterator.html
-/doc/html/boost_asio/reference/mutable_buffers_1/data.html
-/doc/html/boost_asio/reference/mutable_buffers_1/end.html
-/doc/html/boost_asio/reference/mutable_buffers_1.html
-/doc/html/boost_asio/reference/mutable_buffers_1/mutable_buffers_1/
-/doc/html/boost_asio/reference/mutable_buffers_1/mutable_buffers_1.html
-/doc/html/boost_asio/reference/mutable_buffers_1/mutable_buffers_1/overload1.html
-/doc/html/boost_asio/reference/mutable_buffers_1/mutable_buffers_1/overload2.html
-/doc/html/boost_asio/reference/mutable_buffers_1/operator_plus_/
-/doc/html/boost_asio/reference/mutable_buffers_1/operator_plus__eq_.html
-/doc/html/boost_asio/reference/mutable_buffers_1/operator_plus_.html
-/doc/html/boost_asio/reference/mutable_buffers_1/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/mutable_buffers_1/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/mutable_buffers_1/size.html
-/doc/html/boost_asio/reference/mutable_buffers_1/value_type.html
-/doc/html/boost_asio/reference/MutableBufferSequence.html
-/doc/html/boost_asio/reference/mutable_buffer/size.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/
-/doc/html/boost_asio/reference/mutable_registered_buffer/buffer.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/data.html
-/doc/html/boost_asio/reference/mutable_registered_buffer.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/id.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/mutable_registered_buffer.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/operator_plus_/
-/doc/html/boost_asio/reference/mutable_registered_buffer/operator_plus__eq_.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/operator_plus_.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/operator_plus_/overload1.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/operator_plus_/overload2.html
-/doc/html/boost_asio/reference/mutable_registered_buffer/size.html
-/doc/html/boost_asio/reference/NullaryToken.html
-/doc/html/boost_asio/reference/null_buffers/
-/doc/html/boost_asio/reference/null_buffers/begin.html
-/doc/html/boost_asio/reference/null_buffers/const_iterator.html
-/doc/html/boost_asio/reference/null_buffers/end.html
-/doc/html/boost_asio/reference/null_buffers.html
-/doc/html/boost_asio/reference/null_buffers/value_type.html
-/doc/html/boost_asio/reference/operator_pipe_.html
-/doc/html/boost_asio/reference/partial_allocator_binder/
-/doc/html/boost_asio/reference/partial_allocator_binder/allocator_.html
-/doc/html/boost_asio/reference/partial_allocator_binder.html
-/doc/html/boost_asio/reference/partial_allocator_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_allocator_binder/partial_allocator_binder.html
-/doc/html/boost_asio/reference/partial_as_tuple/
-/doc/html/boost_asio/reference/partial_as_tuple.html
-/doc/html/boost_asio/reference/partial_as_tuple/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_as_tuple/partial_as_tuple.html
-/doc/html/boost_asio/reference/partial_cancel_after/
-/doc/html/boost_asio/reference/partial_cancel_after/cancel_type_.html
-/doc/html/boost_asio/reference/partial_cancel_after.html
-/doc/html/boost_asio/reference/partial_cancel_after/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_cancel_after/partial_cancel_after.html
-/doc/html/boost_asio/reference/partial_cancel_after/timeout_.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer/
-/doc/html/boost_asio/reference/partial_cancel_after_timer/cancel_type_.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer/partial_cancel_after_timer.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer/timeout_.html
-/doc/html/boost_asio/reference/partial_cancel_after_timer/timer_.html
-/doc/html/boost_asio/reference/partial_cancel_at/
-/doc/html/boost_asio/reference/partial_cancel_at/cancel_type_.html
-/doc/html/boost_asio/reference/partial_cancel_at/expiry_.html
-/doc/html/boost_asio/reference/partial_cancel_at.html
-/doc/html/boost_asio/reference/partial_cancel_at/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_cancel_at/partial_cancel_at.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer/
-/doc/html/boost_asio/reference/partial_cancel_at_timer/cancel_type_.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer/expiry_.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer/partial_cancel_at_timer.html
-/doc/html/boost_asio/reference/partial_cancel_at_timer/timer_.html
-/doc/html/boost_asio/reference/partial_cancellation_slot_binder/
-/doc/html/boost_asio/reference/partial_cancellation_slot_binder/cancellation_slot_.html
-/doc/html/boost_asio/reference/partial_cancellation_slot_binder.html
-/doc/html/boost_asio/reference/partial_cancellation_slot_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_cancellation_slot_binder/partial_cancellation_slot_binder.html
-/doc/html/boost_asio/reference/partial_executor_binder/
-/doc/html/boost_asio/reference/partial_executor_binder/executor_.html
-/doc/html/boost_asio/reference/partial_executor_binder.html
-/doc/html/boost_asio/reference/partial_executor_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_executor_binder/partial_executor_binder.html
-/doc/html/boost_asio/reference/partial_immediate_executor_binder/
-/doc/html/boost_asio/reference/partial_immediate_executor_binder/executor_.html
-/doc/html/boost_asio/reference/partial_immediate_executor_binder.html
-/doc/html/boost_asio/reference/partial_immediate_executor_binder/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_immediate_executor_binder/partial_immediate_executor_binder.html
-/doc/html/boost_asio/reference/partial_redirect_error/
-/doc/html/boost_asio/reference/partial_redirect_error/ec_.html
-/doc/html/boost_asio/reference/partial_redirect_error.html
-/doc/html/boost_asio/reference/partial_redirect_error/operator_lp__rp_.html
-/doc/html/boost_asio/reference/partial_redirect_error/partial_redirect_error.html
-/doc/html/boost_asio/reference/placeholders__bytes_transferred.html
-/doc/html/boost_asio/reference/placeholders__endpoint.html
-/doc/html/boost_asio/reference/placeholders__error.html
-/doc/html/boost_asio/reference/placeholders__iterator.html
-/doc/html/boost_asio/reference/placeholders__results.html
-/doc/html/boost_asio/reference/placeholders__signal_number.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/
-/doc/html/boost_asio/reference/posix__basic_descriptor/assign/
-/doc/html/boost_asio/reference/posix__basic_descriptor/assign.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/assign/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/assign/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/async_wait.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/
-/doc/html/boost_asio/reference/posix__basic_descriptor/_basic_descriptor.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload3.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload4.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload5.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/basic_descriptor/overload6.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/bytes_readable.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/cancel/
-/doc/html/boost_asio/reference/posix__basic_descriptor/cancel.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/cancel/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/cancel/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/close/
-/doc/html/boost_asio/reference/posix__basic_descriptor/close.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/close/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/close/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/executor_type.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/get_executor.html
-/doc/html/boost_asio/reference/posix__basic_descriptor.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/io_control/
-/doc/html/boost_asio/reference/posix__basic_descriptor/io_control.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/io_control/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/io_control/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/is_open.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/lowest_layer/
-/doc/html/boost_asio/reference/posix__basic_descriptor/lowest_layer.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/lowest_layer_type.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_handle.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_handle_type.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_non_blocking/
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_non_blocking.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/non_blocking/
-/doc/html/boost_asio/reference/posix__basic_descriptor/non_blocking.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/non_blocking/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/non_blocking/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/non_blocking/overload3.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/operator_eq_/
-/doc/html/boost_asio/reference/posix__basic_descriptor/operator_eq_.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor__rebind_executor/
-/doc/html/boost_asio/reference/posix__basic_descriptor__rebind_executor.html
-/doc/html/boost_asio/reference/posix__basic_descriptor__rebind_executor/other.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/release.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/wait/
-/doc/html/boost_asio/reference/posix__basic_descriptor/wait.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/wait/overload1.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/wait/overload2.html
-/doc/html/boost_asio/reference/posix__basic_descriptor/wait_type.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/assign/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/assign.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/assign/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/assign/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/async_read_some.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/async_wait.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/async_write_some.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload3.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload4.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload5.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/basic_stream_descriptor/overload6.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/bytes_readable.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/cancel/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/cancel.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/cancel/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/cancel/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/close/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/close.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/close/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/close/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/executor_type.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/get_executor.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/io_control/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/io_control.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/io_control/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/io_control/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/is_open.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/lowest_layer/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/lowest_layer.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/lowest_layer_type.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_handle.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_handle_type.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_non_blocking/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_non_blocking.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/native_non_blocking/overload3.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/non_blocking/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/non_blocking.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/non_blocking/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/non_blocking/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/non_blocking/overload3.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/operator_eq_/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/operator_eq_.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/read_some/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/read_some.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/read_some/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/read_some/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor__rebind_executor/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor__rebind_executor.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor__rebind_executor/other.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/release.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/wait/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/wait.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/wait/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/wait/overload2.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/wait_type.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/write_some/
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/write_some.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/write_some/overload1.html
-/doc/html/boost_asio/reference/posix__basic_stream_descriptor/write_some/overload2.html
-/doc/html/boost_asio/reference/posix__descriptor_base/
-/doc/html/boost_asio/reference/posix__descriptor_base/bytes_readable.html
-/doc/html/boost_asio/reference/posix__descriptor_base/_descriptor_base.html
-/doc/html/boost_asio/reference/posix__descriptor_base.html
-/doc/html/boost_asio/reference/posix__descriptor_base/wait_type.html
-/doc/html/boost_asio/reference/posix__descriptor.html
-/doc/html/boost_asio/reference/posix__stream_descriptor.html
-/doc/html/boost_asio/reference/post/
-/doc/html/boost_asio/reference/post.html
-/doc/html/boost_asio/reference/post/overload1.html
-/doc/html/boost_asio/reference/post/overload2.html
-/doc/html/boost_asio/reference/post/overload3.html
-/doc/html/boost_asio/reference/prefer.html
-/doc/html/boost_asio/reference/prefer_result/
-/doc/html/boost_asio/reference/prefer_result.html
-/doc/html/boost_asio/reference/prefer_result/type.html
-/doc/html/boost_asio/reference/prepend.html
-/doc/html/boost_asio/reference/prepend_t/
-/doc/html/boost_asio/reference/prepend_t.html
-/doc/html/boost_asio/reference/prepend_t/prepend_t.html
-/doc/html/boost_asio/reference/prepend_t/token_.html
-/doc/html/boost_asio/reference/prepend_t/values_.html
-/doc/html/boost_asio/reference/ProtoAllocator.html
-/doc/html/boost_asio/reference/Protocol.html
-/doc/html/boost_asio/reference/query.html
-/doc/html/boost_asio/reference/query_result/
-/doc/html/boost_asio/reference/query_result.html
-/doc/html/boost_asio/reference/query_result/type.html
-/doc/html/boost_asio/reference/random_access_file.html
-/doc/html/boost_asio/reference/RangeConnectHandler.html
-/doc/html/boost_asio/reference/RangeConnectToken.html
-/doc/html/boost_asio/reference/read/
-/doc/html/boost_asio/reference/readable_pipe.html
-/doc/html/boost_asio/reference/read_at/
-/doc/html/boost_asio/reference/read_at.html
-/doc/html/boost_asio/reference/read_at/overload1.html
-/doc/html/boost_asio/reference/read_at/overload2.html
-/doc/html/boost_asio/reference/read_at/overload3.html
-/doc/html/boost_asio/reference/read_at/overload4.html
-/doc/html/boost_asio/reference/read_at/overload5.html
-/doc/html/boost_asio/reference/read_at/overload6.html
-/doc/html/boost_asio/reference/read_at/overload7.html
-/doc/html/boost_asio/reference/read_at/overload8.html
-/doc/html/boost_asio/reference/ReadHandler.html
-/doc/html/boost_asio/reference/read.html
-/doc/html/boost_asio/reference/read/overload10.html
-/doc/html/boost_asio/reference/read/overload11.html
-/doc/html/boost_asio/reference/read/overload12.html
-/doc/html/boost_asio/reference/read/overload13.html
-/doc/html/boost_asio/reference/read/overload14.html
-/doc/html/boost_asio/reference/read/overload15.html
-/doc/html/boost_asio/reference/read/overload16.html
-/doc/html/boost_asio/reference/read/overload1.html
-/doc/html/boost_asio/reference/read/overload2.html
-/doc/html/boost_asio/reference/read/overload3.html
-/doc/html/boost_asio/reference/read/overload4.html
-/doc/html/boost_asio/reference/read/overload5.html
-/doc/html/boost_asio/reference/read/overload6.html
-/doc/html/boost_asio/reference/read/overload7.html
-/doc/html/boost_asio/reference/read/overload8.html
-/doc/html/boost_asio/reference/read/overload9.html
-/doc/html/boost_asio/reference/ReadToken.html
-/doc/html/boost_asio/reference/read_until/
-/doc/html/boost_asio/reference/read_until.html
-/doc/html/boost_asio/reference/read_until/overload10.html
-/doc/html/boost_asio/reference/read_until/overload11.html
-/doc/html/boost_asio/reference/read_until/overload12.html
-/doc/html/boost_asio/reference/read_until/overload13.html
-/doc/html/boost_asio/reference/read_until/overload14.html
-/doc/html/boost_asio/reference/read_until/overload15.html
-/doc/html/boost_asio/reference/read_until/overload16.html
-/doc/html/boost_asio/reference/read_until/overload17.html
-/doc/html/boost_asio/reference/read_until/overload18.html
-/doc/html/boost_asio/reference/read_until/overload19.html
-/doc/html/boost_asio/reference/read_until/overload1.html
-/doc/html/boost_asio/reference/read_until/overload20.html
-/doc/html/boost_asio/reference/read_until/overload21.html
-/doc/html/boost_asio/reference/read_until/overload22.html
-/doc/html/boost_asio/reference/read_until/overload23.html
-/doc/html/boost_asio/reference/read_until/overload24.html
-/doc/html/boost_asio/reference/read_until/overload2.html
-/doc/html/boost_asio/reference/read_until/overload3.html
-/doc/html/boost_asio/reference/read_until/overload4.html
-/doc/html/boost_asio/reference/read_until/overload5.html
-/doc/html/boost_asio/reference/read_until/overload6.html
-/doc/html/boost_asio/reference/read_until/overload7.html
-/doc/html/boost_asio/reference/read_until/overload8.html
-/doc/html/boost_asio/reference/read_until/overload9.html
-/doc/html/boost_asio/reference/read_write_operations.html
-/doc/html/boost_asio/reference/recycling_allocator/
-/doc/html/boost_asio/reference/recycling_allocator/allocate.html
-/doc/html/boost_asio/reference/recycling_allocator/deallocate.html
-/doc/html/boost_asio/reference/recycling_allocator.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/operator_eq__eq_.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/operator_not__eq_.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt___rebind/
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt___rebind.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt___rebind/other.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/overload1.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/recycling_allocator/overload2.html
-/doc/html/boost_asio/reference/recycling_allocator_lt__void__gt_/value_type.html
-/doc/html/boost_asio/reference/recycling_allocator/operator_eq__eq_.html
-/doc/html/boost_asio/reference/recycling_allocator/operator_not__eq_.html
-/doc/html/boost_asio/reference/recycling_allocator__rebind/
-/doc/html/boost_asio/reference/recycling_allocator__rebind.html
-/doc/html/boost_asio/reference/recycling_allocator__rebind/other.html
-/doc/html/boost_asio/reference/recycling_allocator/recycling_allocator/
-/doc/html/boost_asio/reference/recycling_allocator/recycling_allocator.html
-/doc/html/boost_asio/reference/recycling_allocator/recycling_allocator/overload1.html
-/doc/html/boost_asio/reference/recycling_allocator/recycling_allocator/overload2.html
-/doc/html/boost_asio/reference/recycling_allocator/value_type.html
-/doc/html/boost_asio/reference/redirect_error/
-/doc/html/boost_asio/reference/redirect_error.html
-/doc/html/boost_asio/reference/redirect_error/overload1.html
-/doc/html/boost_asio/reference/redirect_error/overload2.html
-/doc/html/boost_asio/reference/redirect_error_t/
-/doc/html/boost_asio/reference/redirect_error_t/ec_.html
-/doc/html/boost_asio/reference/redirect_error_t.html
-/doc/html/boost_asio/reference/redirect_error_t/redirect_error_t.html
-/doc/html/boost_asio/reference/redirect_error_t/token_.html
-/doc/html/boost_asio/reference/register_buffers/
-/doc/html/boost_asio/reference/register_buffers.html
-/doc/html/boost_asio/reference/register_buffers/overload1.html
-/doc/html/boost_asio/reference/register_buffers/overload2.html
-/doc/html/boost_asio/reference/register_buffers/overload3.html
-/doc/html/boost_asio/reference/register_buffers/overload4.html
-/doc/html/boost_asio/reference/registered_buffer_id/
-/doc/html/boost_asio/reference/registered_buffer_id.html
-/doc/html/boost_asio/reference/registered_buffer_id/native_handle.html
-/doc/html/boost_asio/reference/registered_buffer_id/native_handle_type.html
-/doc/html/boost_asio/reference/registered_buffer_id/operator_eq__eq_.html
-/doc/html/boost_asio/reference/registered_buffer_id/operator_not__eq_.html
-/doc/html/boost_asio/reference/registered_buffer_id/registered_buffer_id.html
-/doc/html/boost_asio/reference/require_concept.html
-/doc/html/boost_asio/reference/require_concept_result/
-/doc/html/boost_asio/reference/require_concept_result.html
-/doc/html/boost_asio/reference/require_concept_result/type.html
-/doc/html/boost_asio/reference/require.html
-/doc/html/boost_asio/reference/require_result/
-/doc/html/boost_asio/reference/require_result.html
-/doc/html/boost_asio/reference/require_result/type.html
-/doc/html/boost_asio/reference/ResolveHandler.html
-/doc/html/boost_asio/reference/resolver_errc__try_again.html
-/doc/html/boost_asio/reference/ResolveToken.html
-/doc/html/boost_asio/reference/serial_port_base/
-/doc/html/boost_asio/reference/serial_port_base__baud_rate/
-/doc/html/boost_asio/reference/serial_port_base__baud_rate/baud_rate.html
-/doc/html/boost_asio/reference/serial_port_base__baud_rate.html
-/doc/html/boost_asio/reference/serial_port_base__baud_rate/load.html
-/doc/html/boost_asio/reference/serial_port_base__baud_rate/store.html
-/doc/html/boost_asio/reference/serial_port_base__baud_rate/value.html
-/doc/html/boost_asio/reference/serial_port_base__character_size/
-/doc/html/boost_asio/reference/serial_port_base__character_size/character_size.html
-/doc/html/boost_asio/reference/serial_port_base__character_size.html
-/doc/html/boost_asio/reference/serial_port_base__character_size/load.html
-/doc/html/boost_asio/reference/serial_port_base__character_size/store.html
-/doc/html/boost_asio/reference/serial_port_base__character_size/value.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control/
-/doc/html/boost_asio/reference/serial_port_base__flow_control/flow_control.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control/load.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control/store.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control/type.html
-/doc/html/boost_asio/reference/serial_port_base__flow_control/value.html
-/doc/html/boost_asio/reference/serial_port_base.html
-/doc/html/boost_asio/reference/serial_port_base__parity/
-/doc/html/boost_asio/reference/serial_port_base__parity.html
-/doc/html/boost_asio/reference/serial_port_base__parity/load.html
-/doc/html/boost_asio/reference/serial_port_base__parity/parity.html
-/doc/html/boost_asio/reference/serial_port_base__parity/store.html
-/doc/html/boost_asio/reference/serial_port_base__parity/type.html
-/doc/html/boost_asio/reference/serial_port_base__parity/value.html
-/doc/html/boost_asio/reference/serial_port_base/_serial_port_base.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/
-/doc/html/boost_asio/reference/serial_port_base__stop_bits.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/load.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/stop_bits.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/store.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/type.html
-/doc/html/boost_asio/reference/serial_port_base__stop_bits/value.html
-/doc/html/boost_asio/reference/serial_port.html
-/doc/html/boost_asio/reference/service_already_exists/
-/doc/html/boost_asio/reference/service_already_exists.html
-/doc/html/boost_asio/reference/service_already_exists/service_already_exists.html
-/doc/html/boost_asio/reference/Service.html
-/doc/html/boost_asio/reference/SettableSerialPortOption.html
-/doc/html/boost_asio/reference/SettableSocketOption.html
-/doc/html/boost_asio/reference/ShutdownHandler.html
-/doc/html/boost_asio/reference/ShutdownToken.html
-/doc/html/boost_asio/reference/SignalHandler.html
-/doc/html/boost_asio/reference/signal_set_base/
-/doc/html/boost_asio/reference/signal_set_base/flags.html
-/doc/html/boost_asio/reference/signal_set_base/flags_t.html
-/doc/html/boost_asio/reference/signal_set_base.html
-/doc/html/boost_asio/reference/signal_set_base/_signal_set_base.html
-/doc/html/boost_asio/reference/signal_set.html
-/doc/html/boost_asio/reference/SignalToken.html
-/doc/html/boost_asio/reference/socket_base/
-/doc/html/boost_asio/reference/socket_base/broadcast.html
-/doc/html/boost_asio/reference/socket_base/bytes_readable.html
-/doc/html/boost_asio/reference/socket_base/debug.html
-/doc/html/boost_asio/reference/socket_base/do_not_route.html
-/doc/html/boost_asio/reference/socket_base/enable_connection_aborted.html
-/doc/html/boost_asio/reference/socket_base.html
-/doc/html/boost_asio/reference/socket_base/keep_alive.html
-/doc/html/boost_asio/reference/socket_base/linger.html
-/doc/html/boost_asio/reference/socket_base/max_connections.html
-/doc/html/boost_asio/reference/socket_base/max_listen_connections.html
-/doc/html/boost_asio/reference/socket_base/message_do_not_route.html
-/doc/html/boost_asio/reference/socket_base/message_end_of_record.html
-/doc/html/boost_asio/reference/socket_base/message_flags.html
-/doc/html/boost_asio/reference/socket_base/message_out_of_band.html
-/doc/html/boost_asio/reference/socket_base/message_peek.html
-/doc/html/boost_asio/reference/socket_base/out_of_band_inline.html
-/doc/html/boost_asio/reference/socket_base/receive_buffer_size.html
-/doc/html/boost_asio/reference/socket_base/receive_low_watermark.html
-/doc/html/boost_asio/reference/socket_base/reuse_address.html
-/doc/html/boost_asio/reference/socket_base/send_buffer_size.html
-/doc/html/boost_asio/reference/socket_base/send_low_watermark.html
-/doc/html/boost_asio/reference/socket_base/shutdown_type.html
-/doc/html/boost_asio/reference/socket_base/_socket_base.html
-/doc/html/boost_asio/reference/socket_base/wait_type.html
-/doc/html/boost_asio/reference/spawn/
-/doc/html/boost_asio/reference/spawn.html
-/doc/html/boost_asio/reference/spawn/overload10.html
-/doc/html/boost_asio/reference/spawn/overload11.html
-/doc/html/boost_asio/reference/spawn/overload12.html
-/doc/html/boost_asio/reference/spawn/overload13.html
-/doc/html/boost_asio/reference/spawn/overload1.html
-/doc/html/boost_asio/reference/spawn/overload2.html
-/doc/html/boost_asio/reference/spawn/overload3.html
-/doc/html/boost_asio/reference/spawn/overload4.html
-/doc/html/boost_asio/reference/spawn/overload5.html
-/doc/html/boost_asio/reference/spawn/overload6.html
-/doc/html/boost_asio/reference/spawn/overload7.html
-/doc/html/boost_asio/reference/spawn/overload8.html
-/doc/html/boost_asio/reference/spawn/overload9.html
-/doc/html/boost_asio/reference/ssl__context/
-/doc/html/boost_asio/reference/ssl__context/add_certificate_authority/
-/doc/html/boost_asio/reference/ssl__context/add_certificate_authority.html
-/doc/html/boost_asio/reference/ssl__context/add_certificate_authority/overload1.html
-/doc/html/boost_asio/reference/ssl__context/add_certificate_authority/overload2.html
-/doc/html/boost_asio/reference/ssl__context/add_verify_path/
-/doc/html/boost_asio/reference/ssl__context/add_verify_path.html
-/doc/html/boost_asio/reference/ssl__context/add_verify_path/overload1.html
-/doc/html/boost_asio/reference/ssl__context/add_verify_path/overload2.html
-/doc/html/boost_asio/reference/ssl__context_base/
-/doc/html/boost_asio/reference/ssl__context_base/_context_base.html
-/doc/html/boost_asio/reference/ssl__context_base/default_workarounds.html
-/doc/html/boost_asio/reference/ssl__context_base/file_format.html
-/doc/html/boost_asio/reference/ssl__context_base.html
-/doc/html/boost_asio/reference/ssl__context_base/method.html
-/doc/html/boost_asio/reference/ssl__context_base/no_compression.html
-/doc/html/boost_asio/reference/ssl__context_base/no_sslv2.html
-/doc/html/boost_asio/reference/ssl__context_base/no_sslv3.html
-/doc/html/boost_asio/reference/ssl__context_base/no_tlsv1_1.html
-/doc/html/boost_asio/reference/ssl__context_base/no_tlsv1_2.html
-/doc/html/boost_asio/reference/ssl__context_base/no_tlsv1_3.html
-/doc/html/boost_asio/reference/ssl__context_base/no_tlsv1.html
-/doc/html/boost_asio/reference/ssl__context_base/options.html
-/doc/html/boost_asio/reference/ssl__context_base/password_purpose.html
-/doc/html/boost_asio/reference/ssl__context_base/single_dh_use.html
-/doc/html/boost_asio/reference/ssl__context/clear_options/
-/doc/html/boost_asio/reference/ssl__context/clear_options.html
-/doc/html/boost_asio/reference/ssl__context/clear_options/overload1.html
-/doc/html/boost_asio/reference/ssl__context/clear_options/overload2.html
-/doc/html/boost_asio/reference/ssl__context/context/
-/doc/html/boost_asio/reference/ssl__context/_context.html
-/doc/html/boost_asio/reference/ssl__context/context.html
-/doc/html/boost_asio/reference/ssl__context/context/overload1.html
-/doc/html/boost_asio/reference/ssl__context/context/overload2.html
-/doc/html/boost_asio/reference/ssl__context/context/overload3.html
-/doc/html/boost_asio/reference/ssl__context/default_workarounds.html
-/doc/html/boost_asio/reference/ssl__context/file_format.html
-/doc/html/boost_asio/reference/ssl__context.html
-/doc/html/boost_asio/reference/ssl__context/load_verify_file/
-/doc/html/boost_asio/reference/ssl__context/load_verify_file.html
-/doc/html/boost_asio/reference/ssl__context/load_verify_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/load_verify_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/method.html
-/doc/html/boost_asio/reference/ssl__context/native_handle.html
-/doc/html/boost_asio/reference/ssl__context/native_handle_type.html
-/doc/html/boost_asio/reference/ssl__context/no_compression.html
-/doc/html/boost_asio/reference/ssl__context/no_sslv2.html
-/doc/html/boost_asio/reference/ssl__context/no_sslv3.html
-/doc/html/boost_asio/reference/ssl__context/no_tlsv1_1.html
-/doc/html/boost_asio/reference/ssl__context/no_tlsv1_2.html
-/doc/html/boost_asio/reference/ssl__context/no_tlsv1_3.html
-/doc/html/boost_asio/reference/ssl__context/no_tlsv1.html
-/doc/html/boost_asio/reference/ssl__context/operator_eq_.html
-/doc/html/boost_asio/reference/ssl__context/options.html
-/doc/html/boost_asio/reference/ssl__context/password_purpose.html
-/doc/html/boost_asio/reference/ssl__context/set_default_verify_paths/
-/doc/html/boost_asio/reference/ssl__context/set_default_verify_paths.html
-/doc/html/boost_asio/reference/ssl__context/set_default_verify_paths/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_default_verify_paths/overload2.html
-/doc/html/boost_asio/reference/ssl__context/set_options/
-/doc/html/boost_asio/reference/ssl__context/set_options.html
-/doc/html/boost_asio/reference/ssl__context/set_options/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_options/overload2.html
-/doc/html/boost_asio/reference/ssl__context/set_password_callback/
-/doc/html/boost_asio/reference/ssl__context/set_password_callback.html
-/doc/html/boost_asio/reference/ssl__context/set_password_callback/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_password_callback/overload2.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_callback/
-/doc/html/boost_asio/reference/ssl__context/set_verify_callback.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_callback/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_callback/overload2.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_depth/
-/doc/html/boost_asio/reference/ssl__context/set_verify_depth.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_depth/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_depth/overload2.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_mode/
-/doc/html/boost_asio/reference/ssl__context/set_verify_mode.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_mode/overload1.html
-/doc/html/boost_asio/reference/ssl__context/set_verify_mode/overload2.html
-/doc/html/boost_asio/reference/ssl__context/single_dh_use.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate/
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain/
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain_file/
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain_file.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_chain/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_file/
-/doc/html/boost_asio/reference/ssl__context/use_certificate_file.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_certificate/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key/
-/doc/html/boost_asio/reference/ssl__context/use_private_key_file/
-/doc/html/boost_asio/reference/ssl__context/use_private_key_file.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_private_key/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key/
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key_file/
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key_file.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_rsa_private_key/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh/
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh_file/
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh_file.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh_file/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh_file/overload2.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh/overload1.html
-/doc/html/boost_asio/reference/ssl__context/use_tmp_dh/overload2.html
-/doc/html/boost_asio/reference/ssl__error__get_stream_category.html
-/doc/html/boost_asio/reference/ssl__error__make_error_code.html
-/doc/html/boost_asio/reference/ssl__error__stream_category.html
-/doc/html/boost_asio/reference/ssl__error__stream_errors.html
-/doc/html/boost_asio/reference/ssl__host_name_verification/
-/doc/html/boost_asio/reference/ssl__host_name_verification/host_name_verification.html
-/doc/html/boost_asio/reference/ssl__host_name_verification.html
-/doc/html/boost_asio/reference/ssl__host_name_verification/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ssl__host_name_verification/result_type.html
-/doc/html/boost_asio/reference/ssl__rfc2818_verification/
-/doc/html/boost_asio/reference/ssl__rfc2818_verification.html
-/doc/html/boost_asio/reference/ssl__rfc2818_verification/operator_lp__rp_.html
-/doc/html/boost_asio/reference/ssl__rfc2818_verification/result_type.html
-/doc/html/boost_asio/reference/ssl__rfc2818_verification/rfc2818_verification.html
-/doc/html/boost_asio/reference/ssl__stream/
-/doc/html/boost_asio/reference/ssl__stream/async_handshake/
-/doc/html/boost_asio/reference/ssl__stream/async_handshake.html
-/doc/html/boost_asio/reference/ssl__stream/async_handshake/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/async_handshake/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/async_read_some.html
-/doc/html/boost_asio/reference/ssl__stream/async_shutdown.html
-/doc/html/boost_asio/reference/ssl__stream/async_write_some.html
-/doc/html/boost_asio/reference/ssl__stream_base/
-/doc/html/boost_asio/reference/ssl__stream_base/handshake_type.html
-/doc/html/boost_asio/reference/ssl__stream_base.html
-/doc/html/boost_asio/reference/ssl__stream_base/_stream_base.html
-/doc/html/boost_asio/reference/ssl__stream/executor_type.html
-/doc/html/boost_asio/reference/ssl__stream/get_executor.html
-/doc/html/boost_asio/reference/ssl__stream/handshake/
-/doc/html/boost_asio/reference/ssl__stream/handshake.html
-/doc/html/boost_asio/reference/ssl__stream/handshake/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/handshake/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/handshake/overload3.html
-/doc/html/boost_asio/reference/ssl__stream/handshake/overload4.html
-/doc/html/boost_asio/reference/ssl__stream/handshake_type.html
-/doc/html/boost_asio/reference/ssl__stream.html
-/doc/html/boost_asio/reference/ssl__stream__impl_struct/
-/doc/html/boost_asio/reference/ssl__stream__impl_struct.html
-/doc/html/boost_asio/reference/ssl__stream__impl_struct/ssl.html
-/doc/html/boost_asio/reference/ssl__stream/lowest_layer/
-/doc/html/boost_asio/reference/ssl__stream/lowest_layer.html
-/doc/html/boost_asio/reference/ssl__stream/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/lowest_layer_type.html
-/doc/html/boost_asio/reference/ssl__stream/native_handle.html
-/doc/html/boost_asio/reference/ssl__stream/native_handle_type.html
-/doc/html/boost_asio/reference/ssl__stream/next_layer/
-/doc/html/boost_asio/reference/ssl__stream/next_layer.html
-/doc/html/boost_asio/reference/ssl__stream/next_layer/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/next_layer/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/next_layer_type.html
-/doc/html/boost_asio/reference/ssl__stream/operator_eq_.html
-/doc/html/boost_asio/reference/ssl__stream/read_some/
-/doc/html/boost_asio/reference/ssl__stream/read_some.html
-/doc/html/boost_asio/reference/ssl__stream/read_some/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/read_some/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_callback/
-/doc/html/boost_asio/reference/ssl__stream/set_verify_callback.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_callback/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_callback/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_depth/
-/doc/html/boost_asio/reference/ssl__stream/set_verify_depth.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_depth/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_depth/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_mode/
-/doc/html/boost_asio/reference/ssl__stream/set_verify_mode.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_mode/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/set_verify_mode/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/shutdown/
-/doc/html/boost_asio/reference/ssl__stream/shutdown.html
-/doc/html/boost_asio/reference/ssl__stream/shutdown/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/shutdown/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/stream/
-/doc/html/boost_asio/reference/ssl__stream/_stream.html
-/doc/html/boost_asio/reference/ssl__stream/stream.html
-/doc/html/boost_asio/reference/ssl__stream/stream/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/stream/overload2.html
-/doc/html/boost_asio/reference/ssl__stream/stream/overload3.html
-/doc/html/boost_asio/reference/ssl__stream/write_some/
-/doc/html/boost_asio/reference/ssl__stream/write_some.html
-/doc/html/boost_asio/reference/ssl__stream/write_some/overload1.html
-/doc/html/boost_asio/reference/ssl__stream/write_some/overload2.html
-/doc/html/boost_asio/reference/ssl__verify_client_once.html
-/doc/html/boost_asio/reference/ssl__verify_context/
-/doc/html/boost_asio/reference/ssl__verify_context.html
-/doc/html/boost_asio/reference/ssl__verify_context/native_handle.html
-/doc/html/boost_asio/reference/ssl__verify_context/native_handle_type.html
-/doc/html/boost_asio/reference/ssl__verify_context/verify_context.html
-/doc/html/boost_asio/reference/ssl__verify_fail_if_no_peer_cert.html
-/doc/html/boost_asio/reference/ssl__verify_mode.html
-/doc/html/boost_asio/reference/ssl__verify_none.html
-/doc/html/boost_asio/reference/ssl__verify_peer.html
-/doc/html/boost_asio/reference/static_thread_pool.html
-/doc/html/boost_asio/reference/steady_timer.html
-/doc/html/boost_asio/reference/strand/
-/doc/html/boost_asio/reference/strand/context.html
-/doc/html/boost_asio/reference/strand/defer.html
-/doc/html/boost_asio/reference/strand/dispatch.html
-/doc/html/boost_asio/reference/strand/execute.html
-/doc/html/boost_asio/reference/strand/get_inner_executor.html
-/doc/html/boost_asio/reference/strand.html
-/doc/html/boost_asio/reference/strand/inner_executor_type.html
-/doc/html/boost_asio/reference/strand/on_work_finished.html
-/doc/html/boost_asio/reference/strand/on_work_started.html
-/doc/html/boost_asio/reference/strand/operator_eq_/
-/doc/html/boost_asio/reference/strand/operator_eq__eq_.html
-/doc/html/boost_asio/reference/strand/operator_eq_.html
-/doc/html/boost_asio/reference/strand/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/strand/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/strand/operator_eq_/overload3.html
-/doc/html/boost_asio/reference/strand/operator_eq_/overload4.html
-/doc/html/boost_asio/reference/strand/operator_not__eq_.html
-/doc/html/boost_asio/reference/strand/post.html
-/doc/html/boost_asio/reference/strand/prefer.html
-/doc/html/boost_asio/reference/strand/query.html
-/doc/html/boost_asio/reference/strand/require.html
-/doc/html/boost_asio/reference/strand/running_in_this_thread.html
-/doc/html/boost_asio/reference/strand/strand/
-/doc/html/boost_asio/reference/strand/_strand.html
-/doc/html/boost_asio/reference/strand/strand.html
-/doc/html/boost_asio/reference/strand/strand/overload1.html
-/doc/html/boost_asio/reference/strand/strand/overload2.html
-/doc/html/boost_asio/reference/strand/strand/overload3.html
-/doc/html/boost_asio/reference/strand/strand/overload4.html
-/doc/html/boost_asio/reference/strand/strand/overload5.html
-/doc/html/boost_asio/reference/strand/strand/overload6.html
-/doc/html/boost_asio/reference/streambuf.html
-/doc/html/boost_asio/reference/stream_file.html
-/doc/html/boost_asio/reference/synchronous_socket_operations.html
-/doc/html/boost_asio/reference/SyncRandomAccessReadDevice.html
-/doc/html/boost_asio/reference/SyncRandomAccessWriteDevice.html
-/doc/html/boost_asio/reference/SyncReadStream.html
-/doc/html/boost_asio/reference/SyncWriteStream.html
-/doc/html/boost_asio/reference/system_context/
-/doc/html/boost_asio/reference/system_context/destroy.html
-/doc/html/boost_asio/reference/system_context/executor_type.html
-/doc/html/boost_asio/reference/system_context/fork_event.html
-/doc/html/boost_asio/reference/system_context/get_executor.html
-/doc/html/boost_asio/reference/system_context.html
-/doc/html/boost_asio/reference/system_context/join.html
-/doc/html/boost_asio/reference/system_context/notify_fork.html
-/doc/html/boost_asio/reference/system_context/shutdown.html
-/doc/html/boost_asio/reference/system_context/stop.html
-/doc/html/boost_asio/reference/system_context/stopped.html
-/doc/html/boost_asio/reference/system_context/_system_context.html
-/doc/html/boost_asio/reference/system_executor.html
-/doc/html/boost_asio/reference/system_timer.html
-/doc/html/boost_asio/reference/this_coro__cancellation_state.html
-/doc/html/boost_asio/reference/this_coro__cancellation_state_t/
-/doc/html/boost_asio/reference/this_coro__cancellation_state_t/cancellation_state_t.html
-/doc/html/boost_asio/reference/this_coro__cancellation_state_t.html
-/doc/html/boost_asio/reference/this_coro__executor.html
-/doc/html/boost_asio/reference/this_coro__executor_t/
-/doc/html/boost_asio/reference/this_coro__executor_t/executor_t.html
-/doc/html/boost_asio/reference/this_coro__executor_t.html
-/doc/html/boost_asio/reference/this_coro__reset_cancellation_state/
-/doc/html/boost_asio/reference/this_coro__reset_cancellation_state.html
-/doc/html/boost_asio/reference/this_coro__reset_cancellation_state/overload1.html
-/doc/html/boost_asio/reference/this_coro__reset_cancellation_state/overload2.html
-/doc/html/boost_asio/reference/this_coro__reset_cancellation_state/overload3.html
-/doc/html/boost_asio/reference/this_coro__throw_if_cancelled/
-/doc/html/boost_asio/reference/this_coro__throw_if_cancelled.html
-/doc/html/boost_asio/reference/this_coro__throw_if_cancelled/overload1.html
-/doc/html/boost_asio/reference/this_coro__throw_if_cancelled/overload2.html
-/doc/html/boost_asio/reference/thread_pool/
-/doc/html/boost_asio/reference/thread_pool/attach.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/basic_executor_type/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/_basic_executor_type.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/basic_executor_type.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/basic_executor_type/overload1.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/basic_executor_type/overload2.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/context.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/defer.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/dispatch.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/execute.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/on_work_finished.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/on_work_started.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_eq_/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_eq__eq_.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_eq_.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/operator_not__eq_.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/post.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload1.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload2.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload3.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload4.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload5.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query/overload6.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query__static/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query__static.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query__static/overload1.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/query__static/overload2.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload1.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload2.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload3.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload4.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload5.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload6.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload7.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload8.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/require/overload9.html
-/doc/html/boost_asio/reference/thread_pool__basic_executor_type/running_in_this_thread.html
-/doc/html/boost_asio/reference/thread_pool/destroy.html
-/doc/html/boost_asio/reference/thread_pool/executor.html
-/doc/html/boost_asio/reference/thread_pool/executor_type.html
-/doc/html/boost_asio/reference/thread_pool/fork_event.html
-/doc/html/boost_asio/reference/thread_pool/get_executor.html
-/doc/html/boost_asio/reference/thread_pool.html
-/doc/html/boost_asio/reference/thread_pool/join.html
-/doc/html/boost_asio/reference/thread_pool/notify_fork.html
-/doc/html/boost_asio/reference/thread_pool/shutdown.html
-/doc/html/boost_asio/reference/thread_pool/stop.html
-/doc/html/boost_asio/reference/thread_pool/thread_pool/
-/doc/html/boost_asio/reference/thread_pool/_thread_pool.html
-/doc/html/boost_asio/reference/thread_pool/thread_pool.html
-/doc/html/boost_asio/reference/thread_pool/thread_pool/overload1.html
-/doc/html/boost_asio/reference/thread_pool/thread_pool/overload2.html
-/doc/html/boost_asio/reference/thread_pool/wait.html
-/doc/html/boost_asio/reference/TimeTraits.html
-/doc/html/boost_asio/reference/time_traits.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/add.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/duration_type.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/less_than.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/now.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/subtract.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/time_type.html
-/doc/html/boost_asio/reference/time_traits_lt__ptime__gt_/to_posix_duration.html
-/doc/html/boost_asio/reference/transfer_all.html
-/doc/html/boost_asio/reference/transfer_at_least.html
-/doc/html/boost_asio/reference/transfer_exactly.html
-/doc/html/boost_asio/reference/use_awaitable.html
-/doc/html/boost_asio/reference/use_awaitable_t/
-/doc/html/boost_asio/reference/use_awaitable_t/as_default_on.html
-/doc/html/boost_asio/reference/use_awaitable_t/as_default_on_t.html
-/doc/html/boost_asio/reference/use_awaitable_t__executor_with_default/
-/doc/html/boost_asio/reference/use_awaitable_t__executor_with_default/default_completion_token_type.html
-/doc/html/boost_asio/reference/use_awaitable_t__executor_with_default/executor_with_default.html
-/doc/html/boost_asio/reference/use_awaitable_t__executor_with_default.html
-/doc/html/boost_asio/reference/use_awaitable_t.html
-/doc/html/boost_asio/reference/use_awaitable_t/use_awaitable_t/
-/doc/html/boost_asio/reference/use_awaitable_t/use_awaitable_t.html
-/doc/html/boost_asio/reference/use_awaitable_t/use_awaitable_t/overload1.html
-/doc/html/boost_asio/reference/use_awaitable_t/use_awaitable_t/overload2.html
-/doc/html/boost_asio/reference/use_future.html
-/doc/html/boost_asio/reference/use_future_t/
-/doc/html/boost_asio/reference/use_future_t/allocator_type.html
-/doc/html/boost_asio/reference/use_future_t/get_allocator.html
-/doc/html/boost_asio/reference/use_future_t.html
-/doc/html/boost_asio/reference/use_future_t/operator_lb__rb_.html
-/doc/html/boost_asio/reference/use_future_t/operator_lp__rp_/
-/doc/html/boost_asio/reference/use_future_t/operator_lp__rp_.html
-/doc/html/boost_asio/reference/use_future_t/operator_lp__rp_/overload1.html
-/doc/html/boost_asio/reference/use_future_t/operator_lp__rp_/overload2.html
-/doc/html/boost_asio/reference/use_future_t/rebind.html
-/doc/html/boost_asio/reference/use_future_t/use_future_t/
-/doc/html/boost_asio/reference/use_future_t/use_future_t.html
-/doc/html/boost_asio/reference/use_future_t/use_future_t/overload1.html
-/doc/html/boost_asio/reference/use_future_t/use_future_t/overload2.html
-/doc/html/boost_asio/reference/uses_executor.html
-/doc/html/boost_asio/reference/WaitHandler.html
-/doc/html/boost_asio/reference/WaitToken.html
-/doc/html/boost_asio/reference/wait_traits/
-/doc/html/boost_asio/reference/WaitTraits.html
-/doc/html/boost_asio/reference/wait_traits.html
-/doc/html/boost_asio/reference/wait_traits/to_wait_duration/
-/doc/html/boost_asio/reference/wait_traits/to_wait_duration.html
-/doc/html/boost_asio/reference/wait_traits/to_wait_duration/overload1.html
-/doc/html/boost_asio/reference/wait_traits/to_wait_duration/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/
-/doc/html/boost_asio/reference/windows__basic_object_handle/assign/
-/doc/html/boost_asio/reference/windows__basic_object_handle/assign.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/assign/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/assign/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/async_wait.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload3.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload4.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload5.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/basic_object_handle/overload6.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/cancel/
-/doc/html/boost_asio/reference/windows__basic_object_handle/cancel.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/cancel/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/cancel/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/close/
-/doc/html/boost_asio/reference/windows__basic_object_handle/close.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/close/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/close/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/executor_type.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/get_executor.html
-/doc/html/boost_asio/reference/windows__basic_object_handle.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/is_open.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/lowest_layer/
-/doc/html/boost_asio/reference/windows__basic_object_handle/lowest_layer.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/lowest_layer_type.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/native_handle.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/native_handle_type.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/operator_eq_/
-/doc/html/boost_asio/reference/windows__basic_object_handle/operator_eq_.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/windows__basic_object_handle__rebind_executor/
-/doc/html/boost_asio/reference/windows__basic_object_handle__rebind_executor.html
-/doc/html/boost_asio/reference/windows__basic_object_handle__rebind_executor/other.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/wait/
-/doc/html/boost_asio/reference/windows__basic_object_handle/wait.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/wait/overload1.html
-/doc/html/boost_asio/reference/windows__basic_object_handle/wait/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/assign/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/assign.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/assign/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/assign/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/_basic_overlapped_handle.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload3.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload4.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload5.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/basic_overlapped_handle/overload6.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/cancel/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/cancel.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/cancel/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/cancel/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/close/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/close.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/close/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/close/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/executor_type.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/get_executor.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/is_open.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/lowest_layer/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/lowest_layer.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/lowest_layer_type.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/native_handle.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/native_handle_type.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/operator_eq_/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/operator_eq_.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle__rebind_executor/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle__rebind_executor.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle__rebind_executor/other.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/release/
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/release.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/release/overload1.html
-/doc/html/boost_asio/reference/windows__basic_overlapped_handle/release/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/assign/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/assign.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/assign/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/assign/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/async_read_some_at.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/async_write_some_at.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload3.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload4.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload5.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/basic_random_access_handle/overload6.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/cancel/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/cancel.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/cancel/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/cancel/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/close/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/close.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/close/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/close/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/executor_type.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/get_executor.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/is_open.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/lowest_layer/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/lowest_layer.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/lowest_layer_type.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/native_handle.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/native_handle_type.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/operator_eq_/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/operator_eq_.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/read_some_at/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/read_some_at.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/read_some_at/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/read_some_at/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle__rebind_executor/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle__rebind_executor.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle__rebind_executor/other.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/release/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/release.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/release/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/release/overload2.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/write_some_at/
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/write_some_at.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/write_some_at/overload1.html
-/doc/html/boost_asio/reference/windows__basic_random_access_handle/write_some_at/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/assign/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/assign.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/assign/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/assign/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/async_read_some.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/async_write_some.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload3.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload4.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload5.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/basic_stream_handle/overload6.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/cancel/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/cancel.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/cancel/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/cancel/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/close/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/close.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/close/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/close/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/executor_type.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/get_executor.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/is_open.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/lowest_layer/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/lowest_layer.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/lowest_layer/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/lowest_layer/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/lowest_layer_type.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/native_handle.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/native_handle_type.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/operator_eq_/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/operator_eq_.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/operator_eq_/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/operator_eq_/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/read_some/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/read_some.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/read_some/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/read_some/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle__rebind_executor/
-/doc/html/boost_asio/reference/windows__basic_stream_handle__rebind_executor.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle__rebind_executor/other.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/release/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/release.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/release/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/release/overload2.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/write_some/
-/doc/html/boost_asio/reference/windows__basic_stream_handle/write_some.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/write_some/overload1.html
-/doc/html/boost_asio/reference/windows__basic_stream_handle/write_some/overload2.html
-/doc/html/boost_asio/reference/windows__object_handle.html
-/doc/html/boost_asio/reference/windows__overlapped_handle.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/
-/doc/html/boost_asio/reference/windows__overlapped_ptr/complete.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/get/
-/doc/html/boost_asio/reference/windows__overlapped_ptr/get.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/get/overload1.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/get/overload2.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/overlapped_ptr/
-/doc/html/boost_asio/reference/windows__overlapped_ptr/_overlapped_ptr.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/overlapped_ptr.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/overlapped_ptr/overload1.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/overlapped_ptr/overload2.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/overlapped_ptr/overload3.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/release.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/reset/
-/doc/html/boost_asio/reference/windows__overlapped_ptr/reset.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/reset/overload1.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/reset/overload2.html
-/doc/html/boost_asio/reference/windows__overlapped_ptr/reset/overload3.html
-/doc/html/boost_asio/reference/windows__random_access_handle.html
-/doc/html/boost_asio/reference/windows__stream_handle.html
-/doc/html/boost_asio/reference/writable_pipe.html
-/doc/html/boost_asio/reference/write/
-/doc/html/boost_asio/reference/write_at/
-/doc/html/boost_asio/reference/write_at.html
-/doc/html/boost_asio/reference/write_at/overload1.html
-/doc/html/boost_asio/reference/write_at/overload2.html
-/doc/html/boost_asio/reference/write_at/overload3.html
-/doc/html/boost_asio/reference/write_at/overload4.html
-/doc/html/boost_asio/reference/write_at/overload5.html
-/doc/html/boost_asio/reference/write_at/overload6.html
-/doc/html/boost_asio/reference/write_at/overload7.html
-/doc/html/boost_asio/reference/write_at/overload8.html
-/doc/html/boost_asio/reference/WriteHandler.html
-/doc/html/boost_asio/reference/write.html
-/doc/html/boost_asio/reference/write/overload10.html
-/doc/html/boost_asio/reference/write/overload11.html
-/doc/html/boost_asio/reference/write/overload12.html
-/doc/html/boost_asio/reference/write/overload13.html
-/doc/html/boost_asio/reference/write/overload14.html
-/doc/html/boost_asio/reference/write/overload15.html
-/doc/html/boost_asio/reference/write/overload16.html
-/doc/html/boost_asio/reference/write/overload1.html
-/doc/html/boost_asio/reference/write/overload2.html
-/doc/html/boost_asio/reference/write/overload3.html
-/doc/html/boost_asio/reference/write/overload4.html
-/doc/html/boost_asio/reference/write/overload5.html
-/doc/html/boost_asio/reference/write/overload6.html
-/doc/html/boost_asio/reference/write/overload7.html
-/doc/html/boost_asio/reference/write/overload8.html
-/doc/html/boost_asio/reference/write/overload9.html
-/doc/html/boost_asio/reference/WriteToken.html
-/doc/html/boost_asio/reference/yield_context.html
-/doc/html/boost_asio/std_executors.html
-/doc/html/boost_asio/sync_op.png
-/doc/html/boost_asio/tutorial/
-/doc/html/boost_asio/tutorial.html
-/doc/html/boost_asio/tutorial/tutdaytime1/
-/doc/html/boost_asio/tutorial/tutdaytime1.html
-/doc/html/boost_asio/tutorial/tutdaytime1/src.html
-/doc/html/boost_asio/tutorial/tutdaytime2/
-/doc/html/boost_asio/tutorial/tutdaytime2.html
-/doc/html/boost_asio/tutorial/tutdaytime2/src.html
-/doc/html/boost_asio/tutorial/tutdaytime3/
-/doc/html/boost_asio/tutorial/tutdaytime3.html
-/doc/html/boost_asio/tutorial/tutdaytime3/src.html
-/doc/html/boost_asio/tutorial/tutdaytime4/
-/doc/html/boost_asio/tutorial/tutdaytime4.html
-/doc/html/boost_asio/tutorial/tutdaytime4/src.html
-/doc/html/boost_asio/tutorial/tutdaytime5/
-/doc/html/boost_asio/tutorial/tutdaytime5.html
-/doc/html/boost_asio/tutorial/tutdaytime5/src.html
-/doc/html/boost_asio/tutorial/tutdaytime6/
-/doc/html/boost_asio/tutorial/tutdaytime6.html
-/doc/html/boost_asio/tutorial/tutdaytime6/src.html
-/doc/html/boost_asio/tutorial/tutdaytime7/
-/doc/html/boost_asio/tutorial/tutdaytime7.html
-/doc/html/boost_asio/tutorial/tutdaytime7/src.html
-/doc/html/boost_asio/tutorial/tuttimer1/
-/doc/html/boost_asio/tutorial/tuttimer1.html
-/doc/html/boost_asio/tutorial/tuttimer1/src.html
-/doc/html/boost_asio/tutorial/tuttimer2/
-/doc/html/boost_asio/tutorial/tuttimer2.html
-/doc/html/boost_asio/tutorial/tuttimer2/src.html
-/doc/html/boost_asio/tutorial/tuttimer3/
-/doc/html/boost_asio/tutorial/tuttimer3.html
-/doc/html/boost_asio/tutorial/tuttimer3/src.html
-/doc/html/boost_asio/tutorial/tuttimer4/
-/doc/html/boost_asio/tutorial/tuttimer4.html
-/doc/html/boost_asio/tutorial/tuttimer4/src.html
-/doc/html/boost_asio/tutorial/tuttimer5/
-/doc/html/boost_asio/tutorial/tuttimer5.html
-/doc/html/boost_asio/tutorial/tuttimer5/src.html
-/doc/html/boost_asio/using.html
-/libs/
-/libs/asio/
-/libs/asio/CMakeLists.txt
-/libs/asio/doc/
-/libs/asio/doc/asio.qbk
-/libs/asio/doc/doxy2qbk.pl
-/libs/asio/doc/examples.qbk
-/libs/asio/doc/history.qbk
-/libs/asio/doc/index.xml
-/libs/asio/doc/Jamfile.v2
-/libs/asio/doc/model_dox.txt
-/libs/asio/doc/net_ts.qbk
-/libs/asio/doc/noncopyable_dox.txt
-/libs/asio/doc/overview/
-/libs/asio/doc/overview/allocation.qbk
-/libs/asio/doc/overview/async_op1.dot
-/libs/asio/doc/overview/async_op1.png
-/libs/asio/doc/overview/async_op2.dot
-/libs/asio/doc/overview/async_op2.png
-/libs/asio/doc/overview/async.qbk
-/libs/asio/doc/overview/basics.qbk
-/libs/asio/doc/overview/bsd_sockets.qbk
-/libs/asio/doc/overview/buffers.qbk
-/libs/asio/doc/overview/cancellation.qbk
-/libs/asio/doc/overview/channels.qbk
-/libs/asio/doc/overview/compose.qbk
-/libs/asio/doc/overview/concurrency_hint.qbk
-/libs/asio/doc/overview/coro.qbk
-/libs/asio/doc/overview/coroutine.qbk
-/libs/asio/doc/overview/cpp2011.qbk
-/libs/asio/doc/overview/cpp20_coroutines.qbk
-/libs/asio/doc/overview/deferred.qbk
-/libs/asio/doc/overview/files.qbk
-/libs/asio/doc/overview/futures.qbk
-/libs/asio/doc/overview/handler_tracking.qbk
-/libs/asio/doc/overview/immediate_completion.qbk
-/libs/asio/doc/overview/implementation.qbk
-/libs/asio/doc/overview/iostreams.qbk
-/libs/asio/doc/overview/line_based.qbk
-/libs/asio/doc/overview/model/
-/libs/asio/doc/overview/model/allocators.qbk
-/libs/asio/doc/overview/model/associators.qbk
-/libs/asio/doc/overview/model/async_agent_chain.png
-/libs/asio/doc/overview/model/async_agent_model.png
-/libs/asio/doc/overview/model/async_agents.qbk
-/libs/asio/doc/overview/model/async_child_agent_chain.png
-/libs/asio/doc/overview/model/async_op_init_complete.png
-/libs/asio/doc/overview/model/async_op_model.png
-/libs/asio/doc/overview/model/async_op_phases.png
-/libs/asio/doc/overview/model/async_ops.qbk
-/libs/asio/doc/overview/model/async_op_trivial_chain.png
-/libs/asio/doc/overview/model/cancellation.qbk
-/libs/asio/doc/overview/model/child_agents.qbk
-/libs/asio/doc/overview/model/completion_token_model.png
-/libs/asio/doc/overview/model/completion_tokens.qbk
-/libs/asio/doc/overview/model/completion_token_transform.png
-/libs/asio/doc/overview/model/executors.qbk
-/libs/asio/doc/overview/model/higher_level_model.png
-/libs/asio/doc/overview/model/higher_levels.qbk
-/libs/asio/doc/overview/model/library_elements.qbk
-/libs/asio/doc/overview/model.qbk
-/libs/asio/doc/overview/other_protocols.qbk
-/libs/asio/doc/overview/parallel_group.qbk
-/libs/asio/doc/overview/pipes.qbk
-/libs/asio/doc/overview/posix.qbk
-/libs/asio/doc/overview/proactor.dot
-/libs/asio/doc/overview/proactor.png
-/libs/asio/doc/overview/promises.qbk
-/libs/asio/doc/overview/protocols.qbk
-/libs/asio/doc/overview.qbk
-/libs/asio/doc/overview/rationale.qbk
-/libs/asio/doc/overview/reactor.qbk
-/libs/asio/doc/overview/serial_ports.qbk
-/libs/asio/doc/overview/signals.qbk
-/libs/asio/doc/overview/spawn.qbk
-/libs/asio/doc/overview/ssl.qbk
-/libs/asio/doc/overview/strands.qbk
-/libs/asio/doc/overview/streams.qbk
-/libs/asio/doc/overview/sync_op.dot
-/libs/asio/doc/overview/sync_op.png
-/libs/asio/doc/overview/threads.qbk
-/libs/asio/doc/overview/timers.qbk
-/libs/asio/doc/overview/token_adapters.qbk
-/libs/asio/doc/overview/type_erasure.qbk
-/libs/asio/doc/overview/windows.qbk
-/libs/asio/doc/platform_macros.pl
-/libs/asio/doc/platform_macros.qbk
-/libs/asio/doc/quickref.xml
-/libs/asio/doc/reference.dox
-/libs/asio/doc/reference.qbk
-/libs/asio/doc/reference.xsl
-/libs/asio/doc/requirements/
-/libs/asio/doc/requirements/AcceptableProtocol.qbk
-/libs/asio/doc/requirements/AcceptHandler.qbk
-/libs/asio/doc/requirements/AcceptToken.qbk
-/libs/asio/doc/requirements/asynchronous_operations.qbk
-/libs/asio/doc/requirements/asynchronous_socket_operations.qbk
-/libs/asio/doc/requirements/AsyncRandomAccessReadDevice.qbk
-/libs/asio/doc/requirements/AsyncRandomAccessWriteDevice.qbk
-/libs/asio/doc/requirements/AsyncReadStream.qbk
-/libs/asio/doc/requirements/AsyncWriteStream.qbk
-/libs/asio/doc/requirements/BufferedHandshakeHandler.qbk
-/libs/asio/doc/requirements/BufferedHandshakeToken.qbk
-/libs/asio/doc/requirements/CancellationHandler.qbk
-/libs/asio/doc/requirements/CancellationSlot.qbk
-/libs/asio/doc/requirements/CompletionCondition.qbk
-/libs/asio/doc/requirements/ConnectCondition.qbk
-/libs/asio/doc/requirements/ConnectHandler.qbk
-/libs/asio/doc/requirements/ConnectToken.qbk
-/libs/asio/doc/requirements/ConstBufferSequence.qbk
-/libs/asio/doc/requirements/DynamicBuffer.qbk
-/libs/asio/doc/requirements/DynamicBuffer_v1.qbk
-/libs/asio/doc/requirements/DynamicBuffer_v2.qbk
-/libs/asio/doc/requirements/Endpoint.qbk
-/libs/asio/doc/requirements/EndpointSequence.qbk
-/libs/asio/doc/requirements/ExecutionContext.qbk
-/libs/asio/doc/requirements/Executor.qbk
-/libs/asio/doc/requirements/GettableSerialPortOption.qbk
-/libs/asio/doc/requirements/GettableSocketOption.qbk
-/libs/asio/doc/requirements/Handler.qbk
-/libs/asio/doc/requirements/HandshakeHandler.qbk
-/libs/asio/doc/requirements/HandshakeToken.qbk
-/libs/asio/doc/requirements/InternetProtocol.qbk
-/libs/asio/doc/requirements/IoControlCommand.qbk
-/libs/asio/doc/requirements/IoObjectService.qbk
-/libs/asio/doc/requirements/IteratorConnectHandler.qbk
-/libs/asio/doc/requirements/IteratorConnectToken.qbk
-/libs/asio/doc/requirements/LegacyCompletionHandler.qbk
-/libs/asio/doc/requirements/MoveAcceptHandler.qbk
-/libs/asio/doc/requirements/MoveAcceptToken.qbk
-/libs/asio/doc/requirements/MutableBufferSequence.qbk
-/libs/asio/doc/requirements/NullaryToken.qbk
-/libs/asio/doc/requirements/ProtoAllocator.qbk
-/libs/asio/doc/requirements/Protocol.qbk
-/libs/asio/doc/requirements.qbk
-/libs/asio/doc/requirements/RangeConnectHandler.qbk
-/libs/asio/doc/requirements/RangeConnectToken.qbk
-/libs/asio/doc/requirements/ReadHandler.qbk
-/libs/asio/doc/requirements/ReadToken.qbk
-/libs/asio/doc/requirements/read_write_operations.qbk
-/libs/asio/doc/requirements/ResolveHandler.qbk
-/libs/asio/doc/requirements/ResolveToken.qbk
-/libs/asio/doc/requirements/Service.qbk
-/libs/asio/doc/requirements/SettableSerialPortOption.qbk
-/libs/asio/doc/requirements/SettableSocketOption.qbk
-/libs/asio/doc/requirements/ShutdownHandler.qbk
-/libs/asio/doc/requirements/ShutdownToken.qbk
-/libs/asio/doc/requirements/SignalHandler.qbk
-/libs/asio/doc/requirements/SignalToken.qbk
-/libs/asio/doc/requirements/synchronous_socket_operations.qbk
-/libs/asio/doc/requirements/SyncRandomAccessReadDevice.qbk
-/libs/asio/doc/requirements/SyncRandomAccessWriteDevice.qbk
-/libs/asio/doc/requirements/SyncReadStream.qbk
-/libs/asio/doc/requirements/SyncWriteStream.qbk
-/libs/asio/doc/requirements/TimeTraits.qbk
-/libs/asio/doc/requirements/WaitHandler.qbk
-/libs/asio/doc/requirements/WaitToken.qbk
-/libs/asio/doc/requirements/WaitTraits.qbk
-/libs/asio/doc/requirements/WriteHandler.qbk
-/libs/asio/doc/requirements/WriteToken.qbk
-/libs/asio/doc/std_exception_dox.txt
-/libs/asio/doc/std_executors.qbk
-/libs/asio/doc/tutorial.dox
-/libs/asio/doc/tutorial.qbk
-/libs/asio/doc/tutorial.xsl
-/libs/asio/doc/using.qbk
-/libs/asio/example/
-/libs/asio/example/cpp11/
-/libs/asio/example/cpp11/allocation/
-/libs/asio/example/cpp11/allocation/Jamfile.v2
-/libs/asio/example/cpp11/allocation/server.cpp
-/libs/asio/example/cpp11/buffers/
-/libs/asio/example/cpp11/buffers/Jamfile.v2
-/libs/asio/example/cpp11/buffers/reference_counted.cpp
-/libs/asio/example/cpp11/chat/
-/libs/asio/example/cpp11/chat/chat_client.cpp
-/libs/asio/example/cpp11/chat/chat_message.hpp
-/libs/asio/example/cpp11/chat/chat_server.cpp
-/libs/asio/example/cpp11/chat/Jamfile.v2
-/libs/asio/example/cpp11/chat/posix_chat_client.cpp
-/libs/asio/example/cpp11/deferred/
-/libs/asio/example/cpp11/deferred/deferred_1.cpp
-/libs/asio/example/cpp11/deferred/deferred_2.cpp
-/libs/asio/example/cpp11/deferred/Jamfile.v2
-/libs/asio/example/cpp11/echo/
-/libs/asio/example/cpp11/echo/async_tcp_echo_server.cpp
-/libs/asio/example/cpp11/echo/async_udp_echo_server.cpp
-/libs/asio/example/cpp11/echo/blocking_tcp_echo_client.cpp
-/libs/asio/example/cpp11/echo/blocking_tcp_echo_server.cpp
-/libs/asio/example/cpp11/echo/blocking_udp_echo_client.cpp
-/libs/asio/example/cpp11/echo/blocking_udp_echo_server.cpp
-/libs/asio/example/cpp11/echo/Jamfile.v2
-/libs/asio/example/cpp11/executors/
-/libs/asio/example/cpp11/executors/actor.cpp
-/libs/asio/example/cpp11/executors/bank_account_1.cpp
-/libs/asio/example/cpp11/executors/bank_account_2.cpp
-/libs/asio/example/cpp11/executors/fork_join.cpp
-/libs/asio/example/cpp11/executors/Jamfile.v2
-/libs/asio/example/cpp11/executors/pipeline.cpp
-/libs/asio/example/cpp11/executors/priority_scheduler.cpp
-/libs/asio/example/cpp11/files/
-/libs/asio/example/cpp11/files/async_file_copy.cpp
-/libs/asio/example/cpp11/files/blocking_file_copy.cpp
-/libs/asio/example/cpp11/files/Jamfile.v2
-/libs/asio/example/cpp11/fork/
-/libs/asio/example/cpp11/fork/daemon.cpp
-/libs/asio/example/cpp11/fork/Jamfile.v2
-/libs/asio/example/cpp11/fork/process_per_connection.cpp
-/libs/asio/example/cpp11/futures/
-/libs/asio/example/cpp11/futures/daytime_client.cpp
-/libs/asio/example/cpp11/futures/Jamfile.v2
-/libs/asio/example/cpp11/handler_tracking/
-/libs/asio/example/cpp11/handler_tracking/async_tcp_echo_server.cpp
-/libs/asio/example/cpp11/handler_tracking/custom_tracking.hpp
-/libs/asio/example/cpp11/handler_tracking/Jamfile.v2
-/libs/asio/example/cpp11/http/
-/libs/asio/example/cpp11/http/client/
-/libs/asio/example/cpp11/http/client/async_client.cpp
-/libs/asio/example/cpp11/http/client/Jamfile.v2
-/libs/asio/example/cpp11/http/client/sync_client.cpp
-/libs/asio/example/cpp11/http/doc_root/
-/libs/asio/example/cpp11/http/doc_root/data_1K.html
-/libs/asio/example/cpp11/http/doc_root/data_2K.html
-/libs/asio/example/cpp11/http/doc_root/data_4K.html
-/libs/asio/example/cpp11/http/doc_root/data_8K.html
-/libs/asio/example/cpp11/http/server/
-/libs/asio/example/cpp11/http/server2/
-/libs/asio/example/cpp11/http/server2/connection.cpp
-/libs/asio/example/cpp11/http/server2/connection.hpp
-/libs/asio/example/cpp11/http/server2/header.hpp
-/libs/asio/example/cpp11/http/server2/io_context_pool.cpp
-/libs/asio/example/cpp11/http/server2/io_context_pool.hpp
-/libs/asio/example/cpp11/http/server2/Jamfile.v2
-/libs/asio/example/cpp11/http/server2/main.cpp
-/libs/asio/example/cpp11/http/server2/mime_types.cpp
-/libs/asio/example/cpp11/http/server2/mime_types.hpp
-/libs/asio/example/cpp11/http/server2/reply.cpp
-/libs/asio/example/cpp11/http/server2/reply.hpp
-/libs/asio/example/cpp11/http/server2/request_handler.cpp
-/libs/asio/example/cpp11/http/server2/request_handler.hpp
-/libs/asio/example/cpp11/http/server2/request.hpp
-/libs/asio/example/cpp11/http/server2/request_parser.cpp
-/libs/asio/example/cpp11/http/server2/request_parser.hpp
-/libs/asio/example/cpp11/http/server2/server.cpp
-/libs/asio/example/cpp11/http/server2/server.hpp
-/libs/asio/example/cpp11/http/server3/
-/libs/asio/example/cpp11/http/server3/connection.cpp
-/libs/asio/example/cpp11/http/server3/connection.hpp
-/libs/asio/example/cpp11/http/server3/header.hpp
-/libs/asio/example/cpp11/http/server3/Jamfile.v2
-/libs/asio/example/cpp11/http/server3/main.cpp
-/libs/asio/example/cpp11/http/server3/mime_types.cpp
-/libs/asio/example/cpp11/http/server3/mime_types.hpp
-/libs/asio/example/cpp11/http/server3/reply.cpp
-/libs/asio/example/cpp11/http/server3/reply.hpp
-/libs/asio/example/cpp11/http/server3/request_handler.cpp
-/libs/asio/example/cpp11/http/server3/request_handler.hpp
-/libs/asio/example/cpp11/http/server3/request.hpp
-/libs/asio/example/cpp11/http/server3/request_parser.cpp
-/libs/asio/example/cpp11/http/server3/request_parser.hpp
-/libs/asio/example/cpp11/http/server3/server.cpp
-/libs/asio/example/cpp11/http/server3/server.hpp
-/libs/asio/example/cpp11/http/server4/
-/libs/asio/example/cpp11/http/server4/file_handler.cpp
-/libs/asio/example/cpp11/http/server4/file_handler.hpp
-/libs/asio/example/cpp11/http/server4/header.hpp
-/libs/asio/example/cpp11/http/server4/Jamfile.v2
-/libs/asio/example/cpp11/http/server4/main.cpp
-/libs/asio/example/cpp11/http/server4/mime_types.cpp
-/libs/asio/example/cpp11/http/server4/mime_types.hpp
-/libs/asio/example/cpp11/http/server4/reply.cpp
-/libs/asio/example/cpp11/http/server4/reply.hpp
-/libs/asio/example/cpp11/http/server4/request_handler.cpp
-/libs/asio/example/cpp11/http/server4/request_handler.hpp
-/libs/asio/example/cpp11/http/server4/request.hpp
-/libs/asio/example/cpp11/http/server4/request_parser.cpp
-/libs/asio/example/cpp11/http/server4/request_parser.hpp
-/libs/asio/example/cpp11/http/server4/server.cpp
-/libs/asio/example/cpp11/http/server4/server.hpp
-/libs/asio/example/cpp11/http/server/connection.cpp
-/libs/asio/example/cpp11/http/server/connection.hpp
-/libs/asio/example/cpp11/http/server/connection_manager.cpp
-/libs/asio/example/cpp11/http/server/connection_manager.hpp
-/libs/asio/example/cpp11/http/server/header.hpp
-/libs/asio/example/cpp11/http/server/Jamfile.v2
-/libs/asio/example/cpp11/http/server/main.cpp
-/libs/asio/example/cpp11/http/server/mime_types.cpp
-/libs/asio/example/cpp11/http/server/mime_types.hpp
-/libs/asio/example/cpp11/http/server/reply.cpp
-/libs/asio/example/cpp11/http/server/reply.hpp
-/libs/asio/example/cpp11/http/server/request_handler.cpp
-/libs/asio/example/cpp11/http/server/request_handler.hpp
-/libs/asio/example/cpp11/http/server/request.hpp
-/libs/asio/example/cpp11/http/server/request_parser.cpp
-/libs/asio/example/cpp11/http/server/request_parser.hpp
-/libs/asio/example/cpp11/http/server/server.cpp
-/libs/asio/example/cpp11/http/server/server.hpp
-/libs/asio/example/cpp11/icmp/
-/libs/asio/example/cpp11/icmp/icmp_header.hpp
-/libs/asio/example/cpp11/icmp/ipv4_header.hpp
-/libs/asio/example/cpp11/icmp/Jamfile.v2
-/libs/asio/example/cpp11/icmp/ping.cpp
-/libs/asio/example/cpp11/invocation/
-/libs/asio/example/cpp11/invocation/Jamfile.v2
-/libs/asio/example/cpp11/invocation/prioritised_handlers.cpp
-/libs/asio/example/cpp11/iostreams/
-/libs/asio/example/cpp11/iostreams/daytime_client.cpp
-/libs/asio/example/cpp11/iostreams/daytime_server.cpp
-/libs/asio/example/cpp11/iostreams/http_client.cpp
-/libs/asio/example/cpp11/iostreams/Jamfile.v2
-/libs/asio/example/cpp11/local/
-/libs/asio/example/cpp11/local/connect_pair.cpp
-/libs/asio/example/cpp11/local/fd_passing_stream_client.cpp
-/libs/asio/example/cpp11/local/fd_passing_stream_server.cpp
-/libs/asio/example/cpp11/local/iostream_client.cpp
-/libs/asio/example/cpp11/local/Jamfile.v2
-/libs/asio/example/cpp11/local/stream_client.cpp
-/libs/asio/example/cpp11/local/stream_server.cpp
-/libs/asio/example/cpp11/multicast/
-/libs/asio/example/cpp11/multicast/Jamfile.v2
-/libs/asio/example/cpp11/multicast/receiver.cpp
-/libs/asio/example/cpp11/multicast/sender.cpp
-/libs/asio/example/cpp11/nonblocking/
-/libs/asio/example/cpp11/nonblocking/Jamfile.v2
-/libs/asio/example/cpp11/nonblocking/third_party_lib.cpp
-/libs/asio/example/cpp11/operations/
-/libs/asio/example/cpp11/operations/composed_1.cpp
-/libs/asio/example/cpp11/operations/composed_2.cpp
-/libs/asio/example/cpp11/operations/composed_3.cpp
-/libs/asio/example/cpp11/operations/composed_4.cpp
-/libs/asio/example/cpp11/operations/composed_5.cpp
-/libs/asio/example/cpp11/operations/composed_6.cpp
-/libs/asio/example/cpp11/operations/composed_7.cpp
-/libs/asio/example/cpp11/operations/composed_8.cpp
-/libs/asio/example/cpp11/operations/Jamfile.v2
-/libs/asio/example/cpp11/parallel_group/
-/libs/asio/example/cpp11/parallel_group/Jamfile.v2
-/libs/asio/example/cpp11/parallel_group/ranged_wait_for_all.cpp
-/libs/asio/example/cpp11/parallel_group/wait_for_all.cpp
-/libs/asio/example/cpp11/parallel_group/wait_for_one.cpp
-/libs/asio/example/cpp11/parallel_group/wait_for_one_error.cpp
-/libs/asio/example/cpp11/parallel_group/wait_for_one_success.cpp
-/libs/asio/example/cpp11/porthopper/
-/libs/asio/example/cpp11/porthopper/client.cpp
-/libs/asio/example/cpp11/porthopper/Jamfile.v2
-/libs/asio/example/cpp11/porthopper/protocol.hpp
-/libs/asio/example/cpp11/porthopper/server.cpp
-/libs/asio/example/cpp11/serialization/
-/libs/asio/example/cpp11/serialization/client.cpp
-/libs/asio/example/cpp11/serialization/connection.hpp
-/libs/asio/example/cpp11/serialization/Jamfile.v2
-/libs/asio/example/cpp11/serialization/server.cpp
-/libs/asio/example/cpp11/serialization/stock.hpp
-/libs/asio/example/cpp11/services/
-/libs/asio/example/cpp11/services/basic_logger.hpp
-/libs/asio/example/cpp11/services/daytime_client.cpp
-/libs/asio/example/cpp11/services/Jamfile.v2
-/libs/asio/example/cpp11/services/logger.hpp
-/libs/asio/example/cpp11/services/logger_service.cpp
-/libs/asio/example/cpp11/services/logger_service.hpp
-/libs/asio/example/cpp11/socks4/
-/libs/asio/example/cpp11/socks4/Jamfile.v2
-/libs/asio/example/cpp11/socks4/socks4.hpp
-/libs/asio/example/cpp11/socks4/sync_client.cpp
-/libs/asio/example/cpp11/spawn/
-/libs/asio/example/cpp11/spawn/echo_server.cpp
-/libs/asio/example/cpp11/spawn/Jamfile.v2
-/libs/asio/example/cpp11/spawn/parallel_grep.cpp
-/libs/asio/example/cpp11/ssl/
-/libs/asio/example/cpp11/ssl/ca.pem
-/libs/asio/example/cpp11/ssl/client.cpp
-/libs/asio/example/cpp11/ssl/dh4096.pem
-/libs/asio/example/cpp11/ssl/Jamfile.v2
-/libs/asio/example/cpp11/ssl/README
-/libs/asio/example/cpp11/ssl/server.cpp
-/libs/asio/example/cpp11/ssl/server.pem
-/libs/asio/example/cpp11/timeouts/
-/libs/asio/example/cpp11/timeouts/async_tcp_client.cpp
-/libs/asio/example/cpp11/timeouts/blocking_tcp_client.cpp
-/libs/asio/example/cpp11/timeouts/blocking_token_tcp_client.cpp
-/libs/asio/example/cpp11/timeouts/blocking_udp_client.cpp
-/libs/asio/example/cpp11/timeouts/Jamfile.v2
-/libs/asio/example/cpp11/timeouts/server.cpp
-/libs/asio/example/cpp11/timers/
-/libs/asio/example/cpp11/timers/Jamfile.v2
-/libs/asio/example/cpp11/timers/time_t_timer.cpp
-/libs/asio/example/cpp11/tutorial/
-/libs/asio/example/cpp11/tutorial/daytime1/
-/libs/asio/example/cpp11/tutorial/daytime1/client.cpp
-/libs/asio/example/cpp11/tutorial/daytime2/
-/libs/asio/example/cpp11/tutorial/daytime2/server.cpp
-/libs/asio/example/cpp11/tutorial/daytime3/
-/libs/asio/example/cpp11/tutorial/daytime3/server.cpp
-/libs/asio/example/cpp11/tutorial/daytime4/
-/libs/asio/example/cpp11/tutorial/daytime4/client.cpp
-/libs/asio/example/cpp11/tutorial/daytime5/
-/libs/asio/example/cpp11/tutorial/daytime5/server.cpp
-/libs/asio/example/cpp11/tutorial/daytime6/
-/libs/asio/example/cpp11/tutorial/daytime6/server.cpp
-/libs/asio/example/cpp11/tutorial/daytime7/
-/libs/asio/example/cpp11/tutorial/daytime7/server.cpp
-/libs/asio/example/cpp11/tutorial/daytime_dox.txt
-/libs/asio/example/cpp11/tutorial/index_dox.txt
-/libs/asio/example/cpp11/tutorial/Jamfile.v2
-/libs/asio/example/cpp11/tutorial/timer1/
-/libs/asio/example/cpp11/tutorial/timer1/timer.cpp
-/libs/asio/example/cpp11/tutorial/timer2/
-/libs/asio/example/cpp11/tutorial/timer2/timer.cpp
-/libs/asio/example/cpp11/tutorial/timer3/
-/libs/asio/example/cpp11/tutorial/timer3/timer.cpp
-/libs/asio/example/cpp11/tutorial/timer4/
-/libs/asio/example/cpp11/tutorial/timer4/timer.cpp
-/libs/asio/example/cpp11/tutorial/timer5/
-/libs/asio/example/cpp11/tutorial/timer5/timer.cpp
-/libs/asio/example/cpp11/tutorial/timer_dox.txt
-/libs/asio/example/cpp11/type_erasure/
-/libs/asio/example/cpp11/type_erasure/Jamfile.v2
-/libs/asio/example/cpp11/type_erasure/line_reader.hpp
-/libs/asio/example/cpp11/type_erasure/main.cpp
-/libs/asio/example/cpp11/type_erasure/sleep.cpp
-/libs/asio/example/cpp11/type_erasure/sleep.hpp
-/libs/asio/example/cpp11/type_erasure/stdin_line_reader.cpp
-/libs/asio/example/cpp11/type_erasure/stdin_line_reader.hpp
-/libs/asio/example/cpp11/windows/
-/libs/asio/example/cpp11/windows/Jamfile.v2
-/libs/asio/example/cpp11/windows/transmit_file.cpp
-/libs/asio/example/cpp14/
-/libs/asio/example/cpp14/deferred/
-/libs/asio/example/cpp14/deferred/deferred_1.cpp
-/libs/asio/example/cpp14/deferred/deferred_2.cpp
-/libs/asio/example/cpp14/deferred/deferred_3.cpp
-/libs/asio/example/cpp14/deferred/deferred_4.cpp
-/libs/asio/example/cpp14/deferred/deferred_5.cpp
-/libs/asio/example/cpp14/deferred/deferred_6.cpp
-/libs/asio/example/cpp14/deferred/deferred_7.cpp
-/libs/asio/example/cpp14/deferred/Jamfile.v2
-/libs/asio/example/cpp14/echo/
-/libs/asio/example/cpp14/echo/async_tcp_echo_server.cpp
-/libs/asio/example/cpp14/echo/async_udp_echo_server.cpp
-/libs/asio/example/cpp14/echo/blocking_tcp_echo_client.cpp
-/libs/asio/example/cpp14/echo/blocking_tcp_echo_server.cpp
-/libs/asio/example/cpp14/echo/blocking_udp_echo_client.cpp
-/libs/asio/example/cpp14/echo/blocking_udp_echo_server.cpp
-/libs/asio/example/cpp14/echo/Jamfile.v2
-/libs/asio/example/cpp14/executors/
-/libs/asio/example/cpp14/executors/actor.cpp
-/libs/asio/example/cpp14/executors/async_1.cpp
-/libs/asio/example/cpp14/executors/async_2.cpp
-/libs/asio/example/cpp14/executors/bank_account_1.cpp
-/libs/asio/example/cpp14/executors/bank_account_2.cpp
-/libs/asio/example/cpp14/executors/fork_join.cpp
-/libs/asio/example/cpp14/executors/Jamfile.v2
-/libs/asio/example/cpp14/executors/pipeline.cpp
-/libs/asio/example/cpp14/executors/priority_scheduler.cpp
-/libs/asio/example/cpp14/iostreams/
-/libs/asio/example/cpp14/iostreams/http_client.cpp
-/libs/asio/example/cpp14/iostreams/Jamfile.v2
-/libs/asio/example/cpp14/operations/
-/libs/asio/example/cpp14/operations/callback_wrapper.cpp
-/libs/asio/example/cpp14/operations/c_callback_wrapper.cpp
-/libs/asio/example/cpp14/operations/composed_1.cpp
-/libs/asio/example/cpp14/operations/composed_2.cpp
-/libs/asio/example/cpp14/operations/composed_3.cpp
-/libs/asio/example/cpp14/operations/composed_4.cpp
-/libs/asio/example/cpp14/operations/composed_5.cpp
-/libs/asio/example/cpp14/operations/composed_6.cpp
-/libs/asio/example/cpp14/operations/composed_7.cpp
-/libs/asio/example/cpp14/operations/composed_8.cpp
-/libs/asio/example/cpp14/operations/Jamfile.v2
-/libs/asio/example/cpp14/parallel_group/
-/libs/asio/example/cpp14/parallel_group/Jamfile.v2
-/libs/asio/example/cpp14/parallel_group/parallel_sort.cpp
-/libs/asio/example/cpp14/parallel_group/ranged_wait_for_all.cpp
-/libs/asio/example/cpp14/parallel_group/wait_for_all.cpp
-/libs/asio/example/cpp14/parallel_group/wait_for_one.cpp
-/libs/asio/example/cpp14/parallel_group/wait_for_one_error.cpp
-/libs/asio/example/cpp14/parallel_group/wait_for_one_success.cpp
-/libs/asio/example/cpp17/
-/libs/asio/example/cpp17/coroutines_ts/
-/libs/asio/example/cpp17/coroutines_ts/chat_server.cpp
-/libs/asio/example/cpp17/coroutines_ts/echo_server.cpp
-/libs/asio/example/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp
-/libs/asio/example/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp
-/libs/asio/example/cpp17/coroutines_ts/echo_server_with_default.cpp
-/libs/asio/example/cpp17/coroutines_ts/range_based_for.cpp
-/libs/asio/example/cpp17/coroutines_ts/refactored_echo_server.cpp
-/libs/asio/example/cpp20/
-/libs/asio/example/cpp20/channels/
-/libs/asio/example/cpp20/channels/Jamfile.v2
-/libs/asio/example/cpp20/channels/mutual_exclusion_1.cpp
-/libs/asio/example/cpp20/channels/mutual_exclusion_2.cpp
-/libs/asio/example/cpp20/channels/throttling_proxy.cpp
-/libs/asio/example/cpp20/coroutines/
-/libs/asio/example/cpp20/coroutines/chat_server.cpp
-/libs/asio/example/cpp20/coroutines/echo_server.cpp
-/libs/asio/example/cpp20/coroutines/echo_server_with_as_single_default.cpp
-/libs/asio/example/cpp20/coroutines/echo_server_with_as_tuple_default.cpp
-/libs/asio/example/cpp20/coroutines/echo_server_with_default.cpp
-/libs/asio/example/cpp20/coroutines/echo_server_with_deferred.cpp
-/libs/asio/example/cpp20/coroutines/echo_server_with_deferred_default.cpp
-/libs/asio/example/cpp20/coroutines/Jamfile.v2
-/libs/asio/example/cpp20/coroutines/refactored_echo_server.cpp
-/libs/asio/example/cpp20/coroutines/timeout.cpp
-/libs/asio/example/cpp20/invocation/
-/libs/asio/example/cpp20/invocation/completion_executor.cpp
-/libs/asio/example/cpp20/invocation/Jamfile.v2
-/libs/asio/example/cpp20/operations/
-/libs/asio/example/cpp20/operations/callback_wrapper.cpp
-/libs/asio/example/cpp20/operations/c_callback_wrapper.cpp
-/libs/asio/example/cpp20/operations/composed_1.cpp
-/libs/asio/example/cpp20/operations/composed_2.cpp
-/libs/asio/example/cpp20/operations/composed_3.cpp
-/libs/asio/example/cpp20/operations/composed_4.cpp
-/libs/asio/example/cpp20/operations/composed_5.cpp
-/libs/asio/example/cpp20/operations/composed_6.cpp
-/libs/asio/example/cpp20/operations/composed_7.cpp
-/libs/asio/example/cpp20/operations/composed_8.cpp
-/libs/asio/example/cpp20/operations/Jamfile.v2
-/libs/asio/example/cpp20/type_erasure/
-/libs/asio/example/cpp20/type_erasure/Jamfile.v2
-/libs/asio/example/cpp20/type_erasure/line_reader.hpp
-/libs/asio/example/cpp20/type_erasure/main.cpp
-/libs/asio/example/cpp20/type_erasure/sleep.cpp
-/libs/asio/example/cpp20/type_erasure/sleep.hpp
-/libs/asio/example/cpp20/type_erasure/stdin_line_reader.cpp
-/libs/asio/example/cpp20/type_erasure/stdin_line_reader.hpp
-/libs/asio/.github/
-/libs/asio/.github/ISSUE_TEMPLATE/
-/libs/asio/.github/ISSUE_TEMPLATE/config.yml
-/libs/asio/.github/move.yml
-/libs/asio/.github/PULL_REQUEST_TEMPLATE.md
-/libs/asio/index.html
-/libs/asio/meta/
-/libs/asio/meta/libraries.json
-/libs/asio/test/
-/libs/asio/test/any_completion_executor.cpp
-/libs/asio/test/any_completion_handler.cpp
-/libs/asio/test/any_io_executor.cpp
-/libs/asio/test/append.cpp
-/libs/asio/test/archetypes/
-/libs/asio/test/archetypes/async_ops.hpp
-/libs/asio/test/archetypes/async_result.hpp
-/libs/asio/test/archetypes/gettable_socket_option.hpp
-/libs/asio/test/archetypes/io_control_command.hpp
-/libs/asio/test/archetypes/settable_socket_option.hpp
-/libs/asio/test/associated_allocator.cpp
-/libs/asio/test/associated_cancellation_slot.cpp
-/libs/asio/test/associated_executor.cpp
-/libs/asio/test/associated_immediate_executor.cpp
-/libs/asio/test/associator.cpp
-/libs/asio/test/as_tuple.cpp
-/libs/asio/test/async_result.cpp
-/libs/asio/test/awaitable.cpp
-/libs/asio/test/basic_datagram_socket.cpp
-/libs/asio/test/basic_deadline_timer.cpp
-/libs/asio/test/basic_file.cpp
-/libs/asio/test/basic_random_access_file.cpp
-/libs/asio/test/basic_raw_socket.cpp
-/libs/asio/test/basic_readable_pipe.cpp
-/libs/asio/test/basic_seq_packet_socket.cpp
-/libs/asio/test/basic_serial_port.cpp
-/libs/asio/test/basic_signal_set.cpp
-/libs/asio/test/basic_socket_acceptor.cpp
-/libs/asio/test/basic_socket.cpp
-/libs/asio/test/basic_streambuf.cpp
-/libs/asio/test/basic_stream_file.cpp
-/libs/asio/test/basic_stream_socket.cpp
-/libs/asio/test/basic_waitable_timer.cpp
-/libs/asio/test/basic_writable_pipe.cpp
-/libs/asio/test/bind_allocator.cpp
-/libs/asio/test/bind_cancellation_slot.cpp
-/libs/asio/test/bind_executor.cpp
-/libs/asio/test/bind_immediate_executor.cpp
-/libs/asio/test/buffer.cpp
-/libs/asio/test/buffered_read_stream.cpp
-/libs/asio/test/buffered_stream.cpp
-/libs/asio/test/buffered_write_stream.cpp
-/libs/asio/test/buffer_registration.cpp
-/libs/asio/test/buffers_iterator.cpp
-/libs/asio/test/cancel_after.cpp
-/libs/asio/test/cancel_at.cpp
-/libs/asio/test/cancellation_signal.cpp
-/libs/asio/test/cancellation_state.cpp
-/libs/asio/test/cancellation_type.cpp
-/libs/asio/test/co_composed.cpp
-/libs/asio/test/completion_condition.cpp
-/libs/asio/test/compose.cpp
-/libs/asio/test/composed.cpp
-/libs/asio/test/connect.cpp
-/libs/asio/test/connect_pipe.cpp
-/libs/asio/test/consign.cpp
-/libs/asio/test/coroutine.cpp
-/libs/asio/test/co_spawn.cpp
-/libs/asio/test/deadline_timer.cpp
-/libs/asio/test/defer.cpp
-/libs/asio/test/deferred.cpp
-/libs/asio/test/detached.cpp
-/libs/asio/test/dispatch.cpp
-/libs/asio/test/error.cpp
-/libs/asio/test/execution/
-/libs/asio/test/execution/any_executor.cpp
-/libs/asio/test/execution/blocking_adaptation.cpp
-/libs/asio/test/execution/blocking.cpp
-/libs/asio/test/execution/context_as.cpp
-/libs/asio/test/execution_context.cpp
-/libs/asio/test/execution/executor.cpp
-/libs/asio/test/execution/invocable_archetype.cpp
-/libs/asio/test/execution/Jamfile.v2
-/libs/asio/test/execution/mapping.cpp
-/libs/asio/test/execution/outstanding_work.cpp
-/libs/asio/test/execution/prefer_only.cpp
-/libs/asio/test/execution/relationship.cpp
-/libs/asio/test/executor.cpp
-/libs/asio/test/executor_work_guard.cpp
-/libs/asio/test/experimental/
-/libs/asio/test/experimental/awaitable_operators.cpp
-/libs/asio/test/experimental/basic_channel.cpp
-/libs/asio/test/experimental/basic_concurrent_channel.cpp
-/libs/asio/test/experimental/channel.cpp
-/libs/asio/test/experimental/channel_traits.cpp
-/libs/asio/test/experimental/co_composed.cpp
-/libs/asio/test/experimental/concurrent_channel.cpp
-/libs/asio/test/experimental/coro/
-/libs/asio/test/experimental/coro/allocator.cpp
-/libs/asio/test/experimental/coro/cancel.cpp
-/libs/asio/test/experimental/coro/co_spawn.cpp
-/libs/asio/test/experimental/coro/exception.cpp
-/libs/asio/test/experimental/coro/executor.cpp
-/libs/asio/test/experimental/coro/Jamfile.v2
-/libs/asio/test/experimental/coro/partial.cpp
-/libs/asio/test/experimental/coro/simple_test.cpp
-/libs/asio/test/experimental/coro/stack_test.cpp
-/libs/asio/test/experimental/coro/use_coro.cpp
-/libs/asio/test/experimental/Jamfile.v2
-/libs/asio/test/experimental/parallel_group.cpp
-/libs/asio/test/experimental/promise.cpp
-/libs/asio/test/file_base.cpp
-/libs/asio/test/generic/
-/libs/asio/test/generic/basic_endpoint.cpp
-/libs/asio/test/generic/datagram_protocol.cpp
-/libs/asio/test/generic/raw_protocol.cpp
-/libs/asio/test/generic/seq_packet_protocol.cpp
-/libs/asio/test/generic/stream_protocol.cpp
-/libs/asio/test/high_resolution_timer.cpp
-/libs/asio/test/immediate.cpp
-/libs/asio/test/io_context.cpp
-/libs/asio/test/io_context_strand.cpp
-/libs/asio/test/ip/
-/libs/asio/test/ip/address.cpp
-/libs/asio/test/ip/address_v4.cpp
-/libs/asio/test/ip/address_v4_iterator.cpp
-/libs/asio/test/ip/address_v4_range.cpp
-/libs/asio/test/ip/address_v6.cpp
-/libs/asio/test/ip/address_v6_iterator.cpp
-/libs/asio/test/ip/address_v6_range.cpp
-/libs/asio/test/ip/basic_endpoint.cpp
-/libs/asio/test/ip/basic_resolver.cpp
-/libs/asio/test/ip/basic_resolver_entry.cpp
-/libs/asio/test/ip/basic_resolver_iterator.cpp
-/libs/asio/test/ip/basic_resolver_query.cpp
-/libs/asio/test/ip/host_name.cpp
-/libs/asio/test/ip/icmp.cpp
-/libs/asio/test/ip/multicast.cpp
-/libs/asio/test/ip/network_v4.cpp
-/libs/asio/test/ip/network_v6.cpp
-/libs/asio/test/ip/resolver_query_base.cpp
-/libs/asio/test/ip/tcp.cpp
-/libs/asio/test/ip/udp.cpp
-/libs/asio/test/ip/unicast.cpp
-/libs/asio/test/ip/v6_only.cpp
-/libs/asio/test/is_read_buffered.cpp
-/libs/asio/test/is_write_buffered.cpp
-/libs/asio/test/Jamfile.v2
-/libs/asio/test/latency/
-/libs/asio/test/latency/allocator.hpp
-/libs/asio/test/latency/high_res_clock.hpp
-/libs/asio/test/latency/Jamfile.v2
-/libs/asio/test/latency/tcp_client.cpp
-/libs/asio/test/latency/tcp_server.cpp
-/libs/asio/test/latency/udp_client.cpp
-/libs/asio/test/latency/udp_server.cpp
-/libs/asio/test/local/
-/libs/asio/test/local/basic_endpoint.cpp
-/libs/asio/test/local/connect_pair.cpp
-/libs/asio/test/local/datagram_protocol.cpp
-/libs/asio/test/local/seq_packet_protocol.cpp
-/libs/asio/test/local/stream_protocol.cpp
-/libs/asio/test/packaged_task.cpp
-/libs/asio/test/placeholders.cpp
-/libs/asio/test/posix/
-/libs/asio/test/posix/basic_descriptor.cpp
-/libs/asio/test/posix/basic_stream_descriptor.cpp
-/libs/asio/test/posix/descriptor_base.cpp
-/libs/asio/test/posix/descriptor.cpp
-/libs/asio/test/posix/stream_descriptor.cpp
-/libs/asio/test/post.cpp
-/libs/asio/test/prepend.cpp
-/libs/asio/test/properties/
-/libs/asio/test/properties/cpp03/
-/libs/asio/test/properties/cpp03/can_prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_free_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_member_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_free_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_free_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_member_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_member_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_static.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_free_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_free_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_member_prefer.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_member_require.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_static.cpp
-/libs/asio/test/properties/cpp03/can_prefer_not_preferable_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_prefer_static.cpp
-/libs/asio/test/properties/cpp03/can_prefer_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_query_free.cpp
-/libs/asio/test/properties/cpp03/can_query_member.cpp
-/libs/asio/test/properties/cpp03/can_query_not_applicable_free.cpp
-/libs/asio/test/properties/cpp03/can_query_not_applicable_member.cpp
-/libs/asio/test/properties/cpp03/can_query_not_applicable_static.cpp
-/libs/asio/test/properties/cpp03/can_query_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_query_static.cpp
-/libs/asio/test/properties/cpp03/can_query_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_free.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_member.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_not_applicable_free.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_not_applicable_member.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_not_applicable_static.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_static.cpp
-/libs/asio/test/properties/cpp03/can_require_concept_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_require_free.cpp
-/libs/asio/test/properties/cpp03/can_require_member.cpp
-/libs/asio/test/properties/cpp03/can_require_not_applicable_free.cpp
-/libs/asio/test/properties/cpp03/can_require_not_applicable_member.cpp
-/libs/asio/test/properties/cpp03/can_require_not_applicable_static.cpp
-/libs/asio/test/properties/cpp03/can_require_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp03/can_require_static.cpp
-/libs/asio/test/properties/cpp03/can_require_unsupported.cpp
-/libs/asio/test/properties/cpp03/Jamfile.v2
-/libs/asio/test/properties/cpp03/prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp03/prefer_free_require.cpp
-/libs/asio/test/properties/cpp03/prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp03/prefer_member_require.cpp
-/libs/asio/test/properties/cpp03/prefer_static.cpp
-/libs/asio/test/properties/cpp03/prefer_unsupported.cpp
-/libs/asio/test/properties/cpp03/query_free.cpp
-/libs/asio/test/properties/cpp03/query_member.cpp
-/libs/asio/test/properties/cpp03/query_static.cpp
-/libs/asio/test/properties/cpp03/require_concept_free.cpp
-/libs/asio/test/properties/cpp03/require_concept_member.cpp
-/libs/asio/test/properties/cpp03/require_concept_static.cpp
-/libs/asio/test/properties/cpp03/require_free.cpp
-/libs/asio/test/properties/cpp03/require_member.cpp
-/libs/asio/test/properties/cpp03/require_static.cpp
-/libs/asio/test/properties/cpp11/
-/libs/asio/test/properties/cpp11/can_prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_free_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_member_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_free_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_free_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_member_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_member_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_static.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_free_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_free_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_member_prefer.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_member_require.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_static.cpp
-/libs/asio/test/properties/cpp11/can_prefer_not_preferable_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_prefer_static.cpp
-/libs/asio/test/properties/cpp11/can_prefer_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_query_free.cpp
-/libs/asio/test/properties/cpp11/can_query_member.cpp
-/libs/asio/test/properties/cpp11/can_query_not_applicable_free.cpp
-/libs/asio/test/properties/cpp11/can_query_not_applicable_member.cpp
-/libs/asio/test/properties/cpp11/can_query_not_applicable_static.cpp
-/libs/asio/test/properties/cpp11/can_query_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_query_static.cpp
-/libs/asio/test/properties/cpp11/can_query_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_free.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_member.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_not_applicable_free.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_not_applicable_member.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_not_applicable_static.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_static.cpp
-/libs/asio/test/properties/cpp11/can_require_concept_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_require_free.cpp
-/libs/asio/test/properties/cpp11/can_require_member.cpp
-/libs/asio/test/properties/cpp11/can_require_not_applicable_free.cpp
-/libs/asio/test/properties/cpp11/can_require_not_applicable_member.cpp
-/libs/asio/test/properties/cpp11/can_require_not_applicable_static.cpp
-/libs/asio/test/properties/cpp11/can_require_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp11/can_require_static.cpp
-/libs/asio/test/properties/cpp11/can_require_unsupported.cpp
-/libs/asio/test/properties/cpp11/Jamfile.v2
-/libs/asio/test/properties/cpp11/prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp11/prefer_free_require.cpp
-/libs/asio/test/properties/cpp11/prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp11/prefer_member_require.cpp
-/libs/asio/test/properties/cpp11/prefer_static.cpp
-/libs/asio/test/properties/cpp11/prefer_unsupported.cpp
-/libs/asio/test/properties/cpp11/query_free.cpp
-/libs/asio/test/properties/cpp11/query_member.cpp
-/libs/asio/test/properties/cpp11/query_static.cpp
-/libs/asio/test/properties/cpp11/require_concept_free.cpp
-/libs/asio/test/properties/cpp11/require_concept_member.cpp
-/libs/asio/test/properties/cpp11/require_concept_static.cpp
-/libs/asio/test/properties/cpp11/require_free.cpp
-/libs/asio/test/properties/cpp11/require_member.cpp
-/libs/asio/test/properties/cpp11/require_static.cpp
-/libs/asio/test/properties/cpp14/
-/libs/asio/test/properties/cpp14/can_prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_free_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_member_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_free_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_free_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_member_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_member_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_static.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_free_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_free_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_member_prefer.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_member_require.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_static.cpp
-/libs/asio/test/properties/cpp14/can_prefer_not_preferable_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_prefer_static.cpp
-/libs/asio/test/properties/cpp14/can_prefer_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_query_free.cpp
-/libs/asio/test/properties/cpp14/can_query_member.cpp
-/libs/asio/test/properties/cpp14/can_query_not_applicable_free.cpp
-/libs/asio/test/properties/cpp14/can_query_not_applicable_member.cpp
-/libs/asio/test/properties/cpp14/can_query_not_applicable_static.cpp
-/libs/asio/test/properties/cpp14/can_query_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_query_static.cpp
-/libs/asio/test/properties/cpp14/can_query_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_free.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_member.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_not_applicable_free.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_not_applicable_member.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_not_applicable_static.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_static.cpp
-/libs/asio/test/properties/cpp14/can_require_concept_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_require_free.cpp
-/libs/asio/test/properties/cpp14/can_require_member.cpp
-/libs/asio/test/properties/cpp14/can_require_not_applicable_free.cpp
-/libs/asio/test/properties/cpp14/can_require_not_applicable_member.cpp
-/libs/asio/test/properties/cpp14/can_require_not_applicable_static.cpp
-/libs/asio/test/properties/cpp14/can_require_not_applicable_unsupported.cpp
-/libs/asio/test/properties/cpp14/can_require_static.cpp
-/libs/asio/test/properties/cpp14/can_require_unsupported.cpp
-/libs/asio/test/properties/cpp14/Jamfile.v2
-/libs/asio/test/properties/cpp14/prefer_free_prefer.cpp
-/libs/asio/test/properties/cpp14/prefer_free_require.cpp
-/libs/asio/test/properties/cpp14/prefer_member_prefer.cpp
-/libs/asio/test/properties/cpp14/prefer_member_require.cpp
-/libs/asio/test/properties/cpp14/prefer_static.cpp
-/libs/asio/test/properties/cpp14/prefer_unsupported.cpp
-/libs/asio/test/properties/cpp14/query_free.cpp
-/libs/asio/test/properties/cpp14/query_member.cpp
-/libs/asio/test/properties/cpp14/query_static.cpp
-/libs/asio/test/properties/cpp14/require_concept_free.cpp
-/libs/asio/test/properties/cpp14/require_concept_member.cpp
-/libs/asio/test/properties/cpp14/require_concept_static.cpp
-/libs/asio/test/properties/cpp14/require_free.cpp
-/libs/asio/test/properties/cpp14/require_member.cpp
-/libs/asio/test/properties/cpp14/require_static.cpp
-/libs/asio/test/random_access_file.cpp
-/libs/asio/test/readable_pipe.cpp
-/libs/asio/test/read_at.cpp
-/libs/asio/test/read.cpp
-/libs/asio/test/read_until.cpp
-/libs/asio/test/recycling_allocator.cpp
-/libs/asio/test/redirect_error.cpp
-/libs/asio/test/registered_buffer.cpp
-/libs/asio/test/serial_port_base.cpp
-/libs/asio/test/serial_port.cpp
-/libs/asio/test/signal_set_base.cpp
-/libs/asio/test/signal_set.cpp
-/libs/asio/test/socket_base.cpp
-/libs/asio/test/ssl/
-/libs/asio/test/ssl/context_base.cpp
-/libs/asio/test/ssl/context.cpp
-/libs/asio/test/ssl/error.cpp
-/libs/asio/test/ssl/host_name_verification.cpp
-/libs/asio/test/ssl/Jamfile.v2
-/libs/asio/test/ssl/rfc2818_verification.cpp
-/libs/asio/test/ssl/stream_base.cpp
-/libs/asio/test/ssl/stream.cpp
-/libs/asio/test/static_thread_pool.cpp
-/libs/asio/test/steady_timer.cpp
-/libs/asio/test/strand.cpp
-/libs/asio/test/streambuf.cpp
-/libs/asio/test/stream_file.cpp
-/libs/asio/test/system_context.cpp
-/libs/asio/test/system_executor.cpp
-/libs/asio/test/system_timer.cpp
-/libs/asio/test/this_coro.cpp
-/libs/asio/test/thread_pool.cpp
-/libs/asio/test/time_traits.cpp
-/libs/asio/test/ts/
-/libs/asio/test/ts/buffer.cpp
-/libs/asio/test/ts/executor.cpp
-/libs/asio/test/ts/internet.cpp
-/libs/asio/test/ts/io_context.cpp
-/libs/asio/test/ts/net.cpp
-/libs/asio/test/ts/netfwd.cpp
-/libs/asio/test/ts/socket.cpp
-/libs/asio/test/ts/timer.cpp
-/libs/asio/test/unit_test.hpp
-/libs/asio/test/use_awaitable.cpp
-/libs/asio/test/use_future.cpp
-/libs/asio/test/uses_executor.cpp
-/libs/asio/test/wait_traits.cpp
-/libs/asio/test/windows/
-/libs/asio/test/windows/basic_object_handle.cpp
-/libs/asio/test/windows/basic_overlapped_handle.cpp
-/libs/asio/test/windows/basic_random_access_handle.cpp
-/libs/asio/test/windows/basic_stream_handle.cpp
-/libs/asio/test/windows/object_handle.cpp
-/libs/asio/test/windows/overlapped_handle.cpp
-/libs/asio/test/windows/overlapped_ptr.cpp
-/libs/asio/test/windows/random_access_handle.cpp
-/libs/asio/test/windows/stream_handle.cpp
-/libs/asio/test/writable_pipe.cpp
-/libs/asio/test/write_at.cpp
-/libs/asio/test/write.cpp
-/libs/asio/tools/
-/libs/asio/tools/handlerlive.pl
-/libs/asio/tools/handlertree.pl
-/libs/asio/tools/handlerviz.pl
-/libs/system/
-/libs/system/appveyor.yml
-/libs/system/build/
-/libs/system/build/Jamfile
-/libs/system/build/Jamfile.v2
-/libs/system/CMakeLists.txt
-/libs/system/doc/
-/libs/system/doc/Jamfile
-/libs/system/doc/system/
-/libs/system/doc/system/acknowledgements.adoc
-/libs/system/doc/system.adoc
-/libs/system/doc/system/changes.adoc
-/libs/system/doc/system/copyright.adoc
-/libs/system/doc/system-docinfo-footer.html
-/libs/system/doc/system/history.adoc
-/libs/system/doc/system/introduction.adoc
-/libs/system/doc/system/rationale.adoc
-/libs/system/doc/system/reference.adoc
-/libs/system/doc/system/usage.adoc
-/libs/system/.drone/
-/libs/system/.drone/drone.bat
-/libs/system/.drone/drone.sh
-/libs/system/.drone.jsonnet
-/libs/system/extra/
-/libs/system/extra/boost_system.natvis
-/libs/system/.github/
-/libs/system/.github/workflows/
-/libs/system/.github/workflows/ci.yml
-/libs/system/index.html
-/libs/system/meta/
-/libs/system/meta/libraries.json
-/libs/system/README.md
-/libs/system/src/
-/libs/system/src/error_code.cpp
-/libs/system/test/
-/libs/system/test/after_main_test.cpp
-/libs/system/test/before_main_test.cpp
-/libs/system/test/cmake_install_test/
-/libs/system/test/cmake_install_test/CMakeLists.txt
-/libs/system/test/cmake_install_test/main.cpp
-/libs/system/test/CMakeLists.txt
-/libs/system/test/cmake_subdir_test/
-/libs/system/test/cmake_subdir_test/CMakeLists.txt
-/libs/system/test/config_test.cpp
-/libs/system/test/constexpr_test2.cpp
-/libs/system/test/constexpr_test.cpp
-/libs/system/test/dynamic_link_test.cpp
-/libs/system/test/ec_hash_value_test.cpp
-/libs/system/test/ec_location_test2.cpp
-/libs/system/test/ec_location_test3.cpp
-/libs/system/test/ec_location_test4.cpp
-/libs/system/test/ec_location_test.cpp
-/libs/system/test/ec_what_test.cpp
-/libs/system/test/ec_wstream_test.cpp
-/libs/system/test/errc_test2.cpp
-/libs/system/test/errc_test3.cpp
-/libs/system/test/errc_test4.cpp
-/libs/system/test/errc_test.cpp
-/libs/system/test/error_category_test2.cpp
-/libs/system/test/error_category_test.cpp
-/libs/system/test/error_code_test2.cpp
-/libs/system/test/error_code_test3.cpp
-/libs/system/test/error_code_test.cpp
-/libs/system/test/error_code_user_test.cpp
-/libs/system/test/error_condition_test2.cpp
-/libs/system/test/error_condition_test3.cpp
-/libs/system/test/error_condition_test.cpp
-/libs/system/test/failed_constexpr_test.cpp
-/libs/system/test/failed_test.cpp
-/libs/system/test/generic_category_test2.cpp
-/libs/system/test/generic_category_test3.cpp
-/libs/system/test/generic_category_test.cpp
-/libs/system/test/header_only_test.cpp
-/libs/system/test/initialization_test.cpp
-/libs/system/test/is_error_code_enum_test.cpp
-/libs/system/test/is_error_condition_enum_test.cpp
-/libs/system/test/Jamfile.v2
-/libs/system/test/linux_error_test.cpp
-/libs/system/test/msvc/
-/libs/system/test/msvc/common.props
-/libs/system/test/msvc/config_test/
-/libs/system/test/msvc/config_test/config_test.vcxproj
-/libs/system/test/msvc/error_code_test/
-/libs/system/test/msvc/error_code_test/error_code_test.vcxproj
-/libs/system/test/msvc/header_only_error_code_test/
-/libs/system/test/msvc/header_only_error_code_test/header_only_error_code_test.vcxproj
-/libs/system/test/msvc/header_only_test/
-/libs/system/test/msvc/header_only_test/header_only_test.vcxproj
-/libs/system/test/msvc/std_interop_test/
-/libs/system/test/msvc/std_interop_test/std_interop_test.vcxproj
-/libs/system/test/msvc/system-dll/
-/libs/system/test/msvc/system-dll/system-dll.vcxproj
-/libs/system/test/msvc/system.sln
-/libs/system/test/quick.cpp
-/libs/system/test/result_and_eq_fn1r.cpp
-/libs/system/test/result_and_eq_fn1v.cpp
-/libs/system/test/result_and_fn1r.cpp
-/libs/system/test/result_and_fn1v.cpp
-/libs/system/test/result_convert_construct.cpp
-/libs/system/test/result_copy_assign.cpp
-/libs/system/test/result_copy_construct.cpp
-/libs/system/test/result_default_construct.cpp
-/libs/system/test/result_emplace.cpp
-/libs/system/test/result_eq.cpp
-/libs/system/test/result_errc_construct.cpp
-/libs/system/test/result_error_access.cpp
-/libs/system/test/result_error_construct2.cpp
-/libs/system/test/result_error_construct3.cpp
-/libs/system/test/result_error_construct4.cpp
-/libs/system/test/result_error_construct5.cpp
-/libs/system/test/result_error_construct.cpp
-/libs/system/test/result_error_move.cpp
-/libs/system/test/result_in_place_use.cpp
-/libs/system/test/result_move_assign.cpp
-/libs/system/test/result_move_construct.cpp
-/libs/system/test/result_or_eq_fn0r.cpp
-/libs/system/test/result_or_eq_fn0v.cpp
-/libs/system/test/result_or_eq_value.cpp
-/libs/system/test/result_or_fn0r.cpp
-/libs/system/test/result_or_fn0v.cpp
-/libs/system/test/result_or_value.cpp
-/libs/system/test/result_or_value_fail2.cpp
-/libs/system/test/result_or_value_fail.cpp
-/libs/system/test/result_range_for.cpp
-/libs/system/test/result_swap.cpp
-/libs/system/test/result_typedefs.cpp
-/libs/system/test/result_value_access.cpp
-/libs/system/test/result_value_construct2.cpp
-/libs/system/test/result_value_construct3.cpp
-/libs/system/test/result_value_construct4.cpp
-/libs/system/test/result_value_construct5.cpp
-/libs/system/test/result_value_construct6.cpp
-/libs/system/test/result_value_construct7.cpp
-/libs/system/test/result_value_construct.cpp
-/libs/system/test/single_instance_1.cpp
-/libs/system/test/single_instance_2.cpp
-/libs/system/test/single_instance_test.cpp
-/libs/system/test/snprintf_test.cpp
-/libs/system/test/std_interop_test10.cpp
-/libs/system/test/std_interop_test11.cpp
-/libs/system/test/std_interop_test12.cpp
-/libs/system/test/std_interop_test13.cpp
-/libs/system/test/std_interop_test14.cpp
-/libs/system/test/std_interop_test15.cpp
-/libs/system/test/std_interop_test16.cpp
-/libs/system/test/std_interop_test2.cpp
-/libs/system/test/std_interop_test3.cpp
-/libs/system/test/std_interop_test4.cpp
-/libs/system/test/std_interop_test5.cpp
-/libs/system/test/std_interop_test6.cpp
-/libs/system/test/std_interop_test7.cpp
-/libs/system/test/std_interop_test8.cpp
-/libs/system/test/std_interop_test9.cpp
-/libs/system/test/std_interop_test.cpp
-/libs/system/test/std_mismatch_test.cpp
-/libs/system/test/std_single_instance_1.cpp
-/libs/system/test/std_single_instance_2.cpp
-/libs/system/test/std_single_instance_test.cpp
-/libs/system/test/system_category_test2.cpp
-/libs/system/test/system_category_test3.cpp
-/libs/system/test/system_category_test.cpp
-/libs/system/test/system_error_test2.cpp
-/libs/system/test/system_error_test3.cpp
-/libs/system/test/system_error_test.cpp
-/libs/system/test/throws_assign_fail.cpp
-/libs/system/test/throw_test.cpp
-/libs/system/test/warnings_test.cpp
-/libs/system/test/win32_generic_test.cpp
-/libs/system/test/win32_hresult_test.cpp
-/libs/system/test/windows_error_test.cpp
-/libs/system/.travis.yml
-/README.txt
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/boostify.pl b/third_party/socket.io-client-cpp/lib/asio/asio/boostify.pl
deleted file mode 100755
index a52b886..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/boostify.pl
+++ /dev/null
@@ -1,700 +0,0 @@
-#!/usr/bin/perl -w
-
-use strict;
-use File::Path;
-
-our $boost_dir = "boostified";
-our $bad_lines = 0;
-
-sub print_line
-{
-  my ($output, $line, $from, $lineno) = @_;
-
-  # Warn if the resulting line is >80 characters wide.
-  if (length($line) > 80)
-  {
-    if ($from =~ /\.[chi]pp$/)
-    {
-      ++$bad_lines;
-      print("Warning: $from:$lineno: output >80 characters wide.\n");
-    }
-  }
-
-  # Write the output.
-  print($output $line . "\n");
-}
-
-sub source_contains_asio_thread_usage
-{
-  my ($from) = @_;
-
-  # Open the input file.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-
-  # Check file for use of asio::thread.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /asio::thread/)
-    {
-      close($input);
-      return 1;
-    }
-    elsif ($line =~ /^ *thread /)
-    {
-      close($input);
-      return 1;
-    }
-  }
-
-  close($input);
-  return 0;
-}
-
-sub source_contains_asio_include
-{
-  my ($from) = @_;
-
-  # Open the input file.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-
-  # Check file for inclusion of asio.hpp.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /# *include [<"]asio\.hpp[>"]/)
-    {
-      close($input);
-      return 1;
-    }
-  }
-
-  close($input);
-  return 0;
-}
-
-sub copy_source_file
-{
-  my ($from, $to) = @_;
-
-  # Ensure the output directory exists.
-  my $dir = $to;
-  $dir =~ s/[^\/]*$//;
-  mkpath($dir);
-
-  # First determine whether the file makes any use of asio::thread.
-  my $uses_asio_thread = source_contains_asio_thread_usage($from);
-
-  my $includes_asio = source_contains_asio_include($from);
-
-  my $is_asio_hpp = 0;
-  $is_asio_hpp = 1 if ($from =~ /asio\.hpp/);
-
-  my $needs_doc_link = 0;
-  $needs_doc_link = 1 if ($is_asio_hpp);
-
-  my $is_error_hpp = 0;
-  $is_error_hpp = 1 if ($from =~ /asio\/error\.hpp/);
-
-  my $is_qbk = 0;
-  $is_qbk = 1 if ($from =~ /.qbk$/);
-
-  my $is_xsl = 0;
-  $is_xsl = 1 if ($from =~ /.xsl$/);
-
-  my $is_quickref = 0;
-  $is_quickref = 1 if ($from =~ /quickref.xml$/);
-
-  my $is_test = 0;
-  $is_test = 1 if ($from =~ /tests\/unit/);
-
-  my $is_coroutine_related = 0;
-  $is_coroutine_related = 1 if ($from =~ /await/ || $from =~ /partial_promise/ || $from =~ /co_composed/);
-
-  my $is_hash_related = 0;
-  $is_hash_related = 1 if ($from =~ /ip\/address/ || $from =~ /ip\/basic_endpoint/);
-
-  # Open the files.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # Copy the content.
-  my $lineno = 1;
-  while (my $line = <$input>)
-  {
-    chomp($line);
-
-    # Unconditional replacements.
-    $line =~ s/[\\@]ref boost_bind/boost::bind()/g;
-    if ($from =~ /.*\.txt$/)
-    {
-      $line =~ s/[\\@]ref async_read/boost::asio::async_read()/g;
-      $line =~ s/[\\@]ref async_write/boost::asio::async_write()/g;
-    }
-    if ($line =~ /asio_detail_posix_thread_function/)
-    {
-      $line =~ s/asio_detail_posix_thread_function/boost_asio_detail_posix_thread_function/g;
-    }
-    if ($line =~ /asio_signal_handler/)
-    {
-      $line =~ s/asio_signal_handler/boost_asio_signal_handler/g;
-    }
-    if ($line =~ /ASIO_/ && !($line =~ /BOOST_ASIO_/))
-    {
-      $line =~ s/ASIO_/BOOST_ASIO_/g;
-    }
-
-    # Extra replacements for quickbook, XSL and quickref.xml source only.
-    if ($is_qbk || $is_xsl || $is_quickref)
-    {
-      $line =~ s/asio\.examples/boost_asio.examples/g;
-      $line =~ s/asio\.history/boost_asio.history/g;
-      $line =~ s/asio\.index/boost_asio.index/g;
-      $line =~ s/asio\.net_ts/boost_asio.net_ts/g;
-      $line =~ s/asio\.std_executors/boost_asio.std_executors/g;
-      $line =~ s/asio\.overview/boost_asio.overview/g;
-      $line =~ s/asio\.reference/boost_asio.reference/g;
-      $line =~ s/asio\.tutorial/boost_asio.tutorial/g;
-      $line =~ s/asio\.using/boost_asio.using/g;
-      $line =~ s/Asio/Boost.Asio/g;
-      $line =~ s/changes made in each release/changes made in each Boost release/g;
-      $line =~ s/\[\$/[\$boost_asio\//g;
-      $line =~ s/\[@\.\.\/src\/examples/[\@boost_asio\/example/g;
-      $line =~ s/asio\//boost\/asio\//g if $is_xsl;
-      $line =~ s/include\/asio/boost\/asio/g;
-      $line =~ s/\^asio/^boost\/asio/g;
-      $line =~ s/namespaceasio/namespaceboost_1_1asio/g;
-      $line =~ s/ \(\[\@examples\/diffs.*$//;
-      $line =~ s/boost\/tools\/boostbook/tools\/boostbook/g;
-    }
-
-    # Conditional replacements.
-    if ($line =~ /^( *)namespace asio \{/)
-    {
-      if ($is_qbk)
-      {
-        print_line($output, $1 . "namespace boost { namespace asio {", $from, $lineno);
-      }
-      else
-      {
-        print_line($output, $1 . "namespace boost {", $from, $lineno);
-        print_line($output, $line, $from, $lineno);
-      }
-    }
-    elsif ($line =~ /^( *)} \/\/ namespace asio$/)
-    {
-      if ($is_qbk)
-      {
-        print_line($output, $1 . "} } // namespace boost::asio", $from, $lineno);
-      }
-      else
-      {
-        print_line($output, $line, $from, $lineno);
-        print_line($output, $1 . "} // namespace boost", $from, $lineno);
-      }
-    }
-    elsif ($line =~ /^(# *include )[<"](asio\.hpp)[>"]$/)
-    {
-      print_line($output, $1 . "<boost/" . $2 . ">", $from, $lineno);
-      if ($uses_asio_thread)
-      {
-        print_line($output, $1 . "<boost/thread/thread.hpp>", $from, $lineno) if (!$is_test);
-        $uses_asio_thread = 0;
-      }
-    }
-    elsif ($line =~ /^(# *include )[<"]boost\/.*[>"].*$/)
-    {
-      if (!$includes_asio && $uses_asio_thread)
-      {
-        print_line($output, $1 . "<boost/thread/thread.hpp>", $from, $lineno) if (!$is_test);
-        $uses_asio_thread = 0;
-      }
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /^(# *include )[<"]asio\/thread\.hpp[>"]/)
-    {
-      if ($is_test)
-      {
-        print_line($output, $1 . "<boost/asio/detail/thread.hpp>", $from, $lineno);
-      }
-      else
-      {
-        # Line is removed.
-      }
-    }
-    elsif ($line =~ /(# *include )[<"]asio\/error_code\.hpp[>"]/)
-    {
-      if ($is_asio_hpp)
-      {
-        # Line is removed.
-      }
-      else
-      {
-        print_line($output, $1 . "<boost/cerrno.hpp>", $from, $lineno) if ($is_error_hpp);
-        print_line($output, $1 . "<boost/system/error_code.hpp>", $from, $lineno);
-      }
-    }
-    elsif ($line =~ /# *include [<"]asio\/impl\/error_code\.[hi]pp[>"]/)
-    {
-      # Line is removed.
-    }
-    elsif ($line =~ /(# *include )[<"]asio\/system_error\.hpp[>"]/)
-    {
-      if ($is_asio_hpp)
-      {
-        # Line is removed.
-      }
-      else
-      {
-        print_line($output, $1 . "<boost/system/system_error.hpp>", $from, $lineno);
-      }
-    }
-    elsif ($line =~ /(^.*# *include )[<"](asio\/[^>"]*)[>"](.*)$/)
-    {
-      print_line($output, $1 . "<boost/" . $2 . ">" . $3, $from, $lineno);
-    }
-    elsif ($line =~ /#.*defined\(.*ASIO_HAS_STD_SYSTEM_ERROR\)$/)
-    {
-      # Line is removed.
-    }
-    elsif ($line =~ /asio::thread\b/)
-    {
-      if ($is_test)
-      {
-        $line =~ s/asio::thread/asio::detail::thread/g;
-      }
-      else
-      {
-        $line =~ s/asio::thread/boost::thread/g;
-      }
-      if (!($line =~ /boost::asio::/))
-      {
-        $line =~ s/asio::/boost::asio::/g;
-      }
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /^( *)thread( .*)$/ && !$is_qbk)
-    {
-      if ($is_test)
-      {
-        print_line($output, $1 . "boost::asio::detail::thread" . $2, $from, $lineno);
-      }
-      else
-      {
-        print_line($output, $1 . "boost::thread" . $2, $from, $lineno);
-      }
-    }
-    elsif ($line =~ /namespace std \{ *$/ && !$is_coroutine_related && !$is_hash_related)
-    {
-      print_line($output, "namespace boost {", $from, $lineno);
-      print_line($output, "namespace system {", $from, $lineno);
-    }
-    elsif ($line =~ /std::error_code/)
-    {
-      $line =~ s/std::error_code/boost::system::error_code/g;
-      $line =~ s/asio::/boost::asio::/g if !$is_xsl;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /std::system_error/)
-    {
-      $line =~ s/std::system_error/boost::system::system_error/g;
-      $line =~ s/asio::/boost::asio::/g if !$is_xsl;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /ec\.assign\(0, ec\.category\(\)\)/)
-    {
-      $line =~ s/ec\.assign\(0, ec\.category\(\)\)/ec = boost::system::error_code()/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /^} \/\/ namespace std/ && !$is_coroutine_related && !$is_hash_related)
-    {
-      print_line($output, "} // namespace system", $from, $lineno);
-      print_line($output, "} // namespace boost", $from, $lineno);
-    }
-    elsif ($line =~ /asio::/ && !($line =~ /boost::asio::/))
-    {
-      $line =~ s/asio::error_code/boost::system::error_code/g;
-      $line =~ s/asio::error_category/boost::system::error_category/g;
-      $line =~ s/asio::system_category/boost::system::system_category/g;
-      $line =~ s/asio::system_error/boost::system::system_error/g;
-      $line =~ s/asio::/boost::asio::/g if !$is_xsl;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /using namespace asio/)
-    {
-      $line =~ s/using namespace asio/using namespace boost::asio/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /asio_handler_alloc_helpers/)
-    {
-      $line =~ s/asio_handler_alloc_helpers/boost_asio_handler_alloc_helpers/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /asio_handler_cont_helpers/)
-    {
-      $line =~ s/asio_handler_cont_helpers/boost_asio_handler_cont_helpers/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /asio_handler_invoke_helpers/)
-    {
-      $line =~ s/asio_handler_invoke_helpers/boost_asio_handler_invoke_helpers/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /asio_(prefer|query|require|require_concept)_fn/)
-    {
-      $line =~ s/asio_(prefer|query|require|require_concept)_fn/boost_asio_$1_fn/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /asio_execution_/ && !($line =~ /_is_unspecialised/))
-    {
-      $line =~ s/asio_execution_/boost_asio_execution_/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /[\\@]ref boost_bind/)
-    {
-      $line =~ s/[\\@]ref boost_bind/boost::bind()/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /( *)\[category template\]/)
-    {
-      print_line($output, $1 . "[authors [Kohlhoff, Christopher]]", $from, $lineno);
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /boostify: non-boost docs start here/)
-    { 
-      while ($line = <$input>)
-      {
-        last if $line =~ /boostify: non-boost docs end here/;
-      }
-    }
-    elsif ($line =~ /boostify: non-boost code starts here/)
-    { 
-      while ($line = <$input>)
-      {
-        last if $line =~ /boostify: non-boost code ends here/;
-      }
-    }
-    elsif ($line =~ /^$/ && $needs_doc_link)
-    {
-      $needs_doc_link = 0;
-      print_line($output, "//  See www.boost.org/libs/asio for documentation.", $from, $lineno);
-      print_line($output, "//", $from, $lineno);
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($is_quickref)
-    {
-      if ($line =~ /asio\.reference\.error_code">/)
-      {
-        # Line is removed.
-      }
-      elsif ($line =~ /asio\.reference\.system_error">/)
-      {
-        # Line is removed.
-      }
-      elsif ($line =~ /asio\.reference\.thread">/)
-      {
-        # Line is removed.
-      }
-      else
-      {
-        print_line($output, $line, $from, $lineno);
-      }
-    }
-    else
-    {
-      print_line($output, $line, $from, $lineno);
-    }
-    ++$lineno;
-  }
-
-  # Ok, we're done.
-  close($input);
-  close($output);
-}
-
-sub copy_include_files
-{
-  my @dirs = (
-      "include",
-      "include/asio",
-      "include/asio/detail",
-      "include/asio/detail/impl",
-      "include/asio/execution",
-      "include/asio/execution/detail",
-      "include/asio/execution/impl",
-      "include/asio/experimental",
-      "include/asio/experimental/detail",
-      "include/asio/experimental/detail/impl",
-      "include/asio/experimental/impl",
-      "include/asio/generic",
-      "include/asio/generic/detail",
-      "include/asio/generic/detail/impl",
-      "include/asio/impl",
-      "include/asio/ip",
-      "include/asio/ip/impl",
-      "include/asio/ip/detail",
-      "include/asio/ip/detail/impl",
-      "include/asio/local",
-      "include/asio/local/detail",
-      "include/asio/local/detail/impl",
-      "include/asio/posix",
-      "include/asio/ssl",
-      "include/asio/ssl/detail",
-      "include/asio/ssl/detail/impl",
-      "include/asio/ssl/impl",
-      "include/asio/ssl/old",
-      "include/asio/ssl/old/detail",
-      "include/asio/traits",
-      "include/asio/ts",
-      "include/asio/windows");
-
-  foreach my $dir (@dirs)
-  {
-    our $boost_dir;
-    my @files = ( glob("$dir/*.hpp"), glob("$dir/*.ipp") );
-    foreach my $file (@files)
-    {
-      if ($file ne "include/asio/thread.hpp"
-          and $file ne "include/asio/error_code.hpp"
-          and $file ne "include/asio/system_error.hpp"
-          and $file ne "include/asio/impl/error_code.hpp"
-          and $file ne "include/asio/impl/error_code.ipp")
-      {
-        my $from = $file;
-        my $to = $file;
-        $to =~ s/^include\//$boost_dir\/libs\/asio\/include\/boost\//;
-        copy_source_file($from, $to);
-      }
-    }
-  }
-}
-
-sub create_lib_directory
-{
-  my @dirs = (
-      "doc",
-      "example",
-      "test");
-
-  our $boost_dir;
-  foreach my $dir (@dirs)
-  {
-    mkpath("$boost_dir/libs/asio/$dir");
-  }
-}
-
-sub copy_unit_tests
-{
-  my @dirs = (
-      "src/tests/unit",
-      "src/tests/unit/archetypes",
-      "src/tests/unit/execution",
-      "src/tests/unit/experimental",
-      "src/tests/unit/experimental/coro",
-      "src/tests/unit/generic",
-      "src/tests/unit/ip",
-      "src/tests/unit/local",
-      "src/tests/unit/posix",
-      "src/tests/unit/ssl",
-      "src/tests/unit/ts",
-      "src/tests/unit/windows");
-
-  our $boost_dir;
-  foreach my $dir (@dirs)
-  {
-    my @files = ( glob("$dir/*.*pp"), glob("$dir/Jamfile*") );
-    foreach my $file (@files)
-    {
-      if ($file ne "src/tests/unit/thread.cpp"
-          and $file ne "src/tests/unit/error_handler.cpp"
-          and $file ne "src/tests/unit/unit_test.cpp")
-      {
-        my $from = $file;
-        my $to = $file;
-        $to =~ s/^src\/tests\/unit\//$boost_dir\/libs\/asio\/test\//;
-        copy_source_file($from, $to);
-      }
-    }
-  }
-}
-
-sub copy_latency_tests
-{
-  my @dirs = (
-      "src/tests/latency");
-
-  our $boost_dir;
-  foreach my $dir (@dirs)
-  {
-    my @files = ( glob("$dir/*.*pp"), glob("$dir/Jamfile*") );
-    foreach my $file (@files)
-    {
-      my $from = $file;
-      my $to = $file;
-      $to =~ s/^src\/tests\/latency\//$boost_dir\/libs\/asio\/test\/latency\//;
-      copy_source_file($from, $to);
-    }
-  }
-}
-
-sub copy_properties_tests
-{
-  my @dirs = (
-      "src/tests/properties/cpp03",
-      "src/tests/properties/cpp11",
-      "src/tests/properties/cpp14");
-
-  our $boost_dir;
-  foreach my $dir (@dirs)
-  {
-    my @files = ( glob("$dir/*.*pp"), glob("$dir/Jamfile*") );
-    foreach my $file (@files)
-    {
-      my $from = $file;
-      my $to = $file;
-      $to =~ s/^src\/tests\/properties\//$boost_dir\/libs\/asio\/test\/properties\//;
-      copy_source_file($from, $to);
-    }
-  }
-}
-
-sub copy_examples
-{
-  my @dirs = (
-      "src/examples/cpp11/allocation",
-      "src/examples/cpp11/buffers",
-      "src/examples/cpp11/chat",
-      "src/examples/cpp11/deferred",
-      "src/examples/cpp11/echo",
-      "src/examples/cpp11/executors",
-      "src/examples/cpp11/files",
-      "src/examples/cpp11/fork",
-      "src/examples/cpp11/futures",
-      "src/examples/cpp11/handler_tracking",
-      "src/examples/cpp11/http/client",
-      "src/examples/cpp11/http/doc_root",
-      "src/examples/cpp11/http/server",
-      "src/examples/cpp11/http/server2",
-      "src/examples/cpp11/http/server3",
-      "src/examples/cpp11/http/server4",
-      "src/examples/cpp11/icmp",
-      "src/examples/cpp11/invocation",
-      "src/examples/cpp11/iostreams",
-      "src/examples/cpp11/local",
-      "src/examples/cpp11/multicast",
-      "src/examples/cpp11/nonblocking",
-      "src/examples/cpp11/operations",
-      "src/examples/cpp11/parallel_group",
-      "src/examples/cpp11/porthopper",
-      "src/examples/cpp11/serialization",
-      "src/examples/cpp11/services",
-      "src/examples/cpp11/socks4",
-      "src/examples/cpp11/spawn",
-      "src/examples/cpp11/ssl",
-      "src/examples/cpp11/timeouts",
-      "src/examples/cpp11/timers",
-      "src/examples/cpp11/tutorial",
-      "src/examples/cpp11/tutorial/daytime1",
-      "src/examples/cpp11/tutorial/daytime2",
-      "src/examples/cpp11/tutorial/daytime3",
-      "src/examples/cpp11/tutorial/daytime4",
-      "src/examples/cpp11/tutorial/daytime5",
-      "src/examples/cpp11/tutorial/daytime6",
-      "src/examples/cpp11/tutorial/daytime7",
-      "src/examples/cpp11/tutorial/timer1",
-      "src/examples/cpp11/tutorial/timer2",
-      "src/examples/cpp11/tutorial/timer3",
-      "src/examples/cpp11/tutorial/timer4",
-      "src/examples/cpp11/tutorial/timer5",
-      "src/examples/cpp11/type_erasure",
-      "src/examples/cpp11/windows",
-      "src/examples/cpp14/deferred",
-      "src/examples/cpp14/echo",
-      "src/examples/cpp14/executors",
-      "src/examples/cpp14/iostreams",
-      "src/examples/cpp14/operations",
-      "src/examples/cpp14/parallel_group",
-      "src/examples/cpp17/coroutines_ts",
-      "src/examples/cpp20/channels",
-      "src/examples/cpp20/coroutines",
-      "src/examples/cpp20/invocation",
-      "src/examples/cpp20/operations",
-      "src/examples/cpp20/type_erasure");
-
-  our $boost_dir;
-  foreach my $dir (@dirs)
-  {
-    my @files = (
-        glob("$dir/*.*pp"),
-        glob("$dir/*.html"),
-        glob("$dir/Jamfile*"),
-        glob("$dir/*.pem"),
-        glob("$dir/README*"),
-        glob("$dir/*.txt"));
-    foreach my $file (@files)
-    {
-      my $from = $file;
-      my $to = $file;
-      $to =~ s/^src\/examples\//$boost_dir\/libs\/asio\/example\//;
-      copy_source_file($from, $to);
-    }
-  }
-}
-
-sub copy_doc
-{
-  our $boost_dir;
-  my @files = (
-      "src/doc/asio.qbk",
-      "src/doc/examples.qbk",
-      "src/doc/net_ts.qbk",
-      "src/doc/overview.qbk",
-      "src/doc/quickref.xml",
-      "src/doc/reference.xsl",
-      "src/doc/std_executors.qbk",
-      "src/doc/tutorial.xsl",
-      glob("src/doc/overview/*.qbk"),
-      glob("src/doc/overview/model/*.qbk"),
-      glob("src/doc/requirements/*.qbk"));
-  foreach my $file (@files)
-  {
-    my $from = $file;
-    my $to = $file;
-    $to =~ s/^src\/doc\//$boost_dir\/libs\/asio\/doc\//;
-    copy_source_file($from, $to);
-  }
-}
-
-sub copy_tools
-{
-  our $boost_dir;
-  my @files = (
-      glob("src/tools/*.pl"));
-  foreach my $file (@files)
-  {
-    my $from = $file;
-    my $to = $file;
-    $to =~ s/^src\/tools\//$boost_dir\/libs\/asio\/tools\//;
-    copy_source_file($from, $to);
-  }
-}
-
-my $includes_only = 0;
-if (scalar(@ARGV) == 1 && $ARGV[0] eq "--includes-only")
-{
-  $includes_only = 1;
-}
-
-copy_include_files();
-if (not $includes_only)
-{
-  create_lib_directory();
-  copy_unit_tests();
-  copy_latency_tests();
-  copy_properties_tests();
-  copy_examples();
-  copy_doc();
-  copy_tools();
-}
-
-exit($bad_lines > 0 ? 1 : 0);
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/configure.ac b/third_party/socket.io-client-cpp/lib/asio/asio/configure.ac
deleted file mode 100644
index ff009ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/configure.ac
+++ /dev/null
@@ -1,259 +0,0 @@
-AC_INIT([asio],[1.31.0])
-AC_CONFIG_SRCDIR(include/asio.hpp)
-AM_MAINTAINER_MODE
-AM_INIT_AUTOMAKE([tar-pax])
-
-AC_CANONICAL_HOST
-AM_PROG_CC_C_O
-AC_PROG_CXX
-AC_LANG(C++)
-AC_PROG_RANLIB
-PKG_INSTALLDIR
-
-AC_DEFINE(_REENTRANT, [1], [Define this])
-
-AC_ARG_WITH(boost,
-  AS_HELP_STRING([--with-boost=DIR],[location of boost distribution]),
-[
-  if test "${withval}" = no; then
-    STANDALONE="yes"
-  else
-    if test "${withval}" != system; then
-      CPPFLAGS="$CPPFLAGS -I${withval}"
-      LIBS="$LIBS -L${withval}/stage/lib"
-    fi
-    CPPFLAGS="$CPPFLAGS -DASIO_ENABLE_BOOST -DBOOST_CHRONO_HEADER_ONLY -DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING"
-  fi
-],
-[
-  STANDALONE="yes"
-])
-
-AC_ARG_ENABLE(separate-compilation,
-[  --enable-separate-compilation  separate compilation of asio source],
-[
-  SEPARATE_COMPILATION=yes
-])
-
-AC_ARG_ENABLE(boost-coroutine,
-[  --enable-boost-coroutine  use Boost.Coroutine to implement stackful coroutines],
-[
-  HAVE_BOOST_COROUTINE=yes
-])
-
-if test "$STANDALONE" != yes; then
-  AC_CHECK_HEADER([boost/noncopyable.hpp],,
-  [
-    echo "Can't find boost headers. Please check the location of the boost"
-    echo "distribution and rerun configure using the --with-boost=DIR option."
-    echo "Alternatively, run with --without-boost to enable standalone build."
-    exit 1
-  ],[])
-fi
-
-AC_ARG_WITH(openssl,
-  AS_HELP_STRING([--with-openssl=DIR],[location of openssl]),
-[
-  CPPFLAGS="$CPPFLAGS -I${withval}/include"
-  LIBS="$LIBS -L${withval}/lib"
-],[])
-
-AC_CHECK_HEADER([openssl/ssl.h],,
-[
-  OPENSSL_FOUND=no
-],[])
-
-if test x$OPENSSL_FOUND != xno; then
-  LIBS="$LIBS -lssl -lcrypto"
-fi
-
-AM_CONDITIONAL(HAVE_OPENSSL,test x$OPENSSL_FOUND != xno)
-
-WINDOWS=no
-case $host in
-  *-*-linux*)
-    CXXFLAGS="$CXXFLAGS -pthread"
-    LDFLAGS="$LDFLAGS -pthread"
-    LIBS="$LIBS -lrt"
-    ;;
-  *-*-solaris*)
-    if test "$GXX" = yes; then
-      CXXFLAGS="$CXXFLAGS -D_PTHREADS"
-    else
-      # We'll assume Sun's CC.
-      CXXFLAGS="$CXXFLAGS -mt"
-    fi
-    LIBS="$LIBS -lsocket -lnsl -lpthread"
-    ;;
-  *-*-mingw32*)
-    CXXFLAGS="$CXXFLAGS -mthreads"
-    LDFLAGS="$LDFLAGS -mthreads"
-    LIBS="$LIBS -lws2_32 -lmswsock"
-    WINDOWS=yes
-    ;;
-  *-*-mingw64*)
-    CXXFLAGS="$CXXFLAGS -mthreads"
-    LDFLAGS="$LDFLAGS -mthreads"
-    LIBS="$LIBS -lws2_32 -lmswsock"
-    WINDOWS=yes
-    ;;
-  *-pc-cygwin*)
-    CXXFLAGS="$CXXFLAGS -D__USE_W32_SOCKETS -D_WIN32_WINNT=0x0601"
-    LIBS="$LIBS -lws2_32 -lmswsock"
-    WINDOWS=yes
-    ;;
-  *-apple-darwin*)
-    CXXFLAGS="$CXXFLAGS"
-    LDFLAGS="$LDFLAGS"
-    ;;
-  *-*-freebsd*)
-    CXXFLAGS="$CXXFLAGS -pthread"
-    LDFLAGS="$LDFLAGS -pthread"
-    ;;
-  *-*-netbsd*)
-    CXXFLAGS="$CXXFLAGS -pthread"
-    LDFLAGS="$LDFLAGS -pthread"
-    ;;
-  *-*-haiku*)
-    CXXFLAGS="$CXXFLAGS -lnetwork"
-    LDFLAGS="$LDFLAGS -lnetwork"
-
-esac
-
-if test "$GXX" = yes; then
-  CXXFLAGS="$CXXFLAGS -ftemplate-depth-256"
-fi
-
-if test "$STANDALONE" = yes; then
-  CPPFLAGS="$CPPFLAGS -DASIO_STANDALONE"
-fi
-
-if test "$SEPARATE_COMPILATION" = yes; then
-  CPPFLAGS="$CPPFLAGS -DASIO_SEPARATE_COMPILATION"
-fi
-
-AC_MSG_CHECKING([whether C++11 is enabled])
-AC_COMPILE_IFELSE(
-  [AC_LANG_PROGRAM(
-    [[#if __cplusplus < 201103L]]
-    [[#error C++11 not available]]
-    [[#endif]])],
-  [AC_MSG_RESULT([yes])
-    HAVE_CXX11=yes;],
-  [AC_MSG_RESULT([no])
-    HAVE_CXX11=no;])
-
-AC_MSG_CHECKING([whether C++14 is enabled])
-AC_COMPILE_IFELSE(
-  [AC_LANG_PROGRAM(
-    [[#if defined(__GNUC__) && !defined(__clang__)]]
-    [[# if (__GNUC__ <= 6)]]
-    [[#  error C++14 support on this compiler not sufficiently compliant]]
-    [[# endif]]
-    [[#endif]]
-    [[#if __cplusplus < 201402L]]
-    [[#error C++14 not available]]
-    [[#endif]])],
-  [AC_MSG_RESULT([yes])
-    HAVE_CXX14=yes;],
-  [AC_MSG_RESULT([no])
-    HAVE_CXX14=no;])
-
-AC_MSG_CHECKING([whether C++17 is enabled])
-AC_COMPILE_IFELSE(
-  [AC_LANG_PROGRAM(
-    [[#if __cplusplus < 201703L]]
-    [[#error C++17 not available]]
-    [[#endif]])],
-  [AC_MSG_RESULT([yes])
-    HAVE_CXX17=yes;],
-  [AC_MSG_RESULT([no])
-    HAVE_CXX17=no;])
-
-AC_MSG_CHECKING([whether C++20 is enabled])
-AC_COMPILE_IFELSE(
-  [AC_LANG_PROGRAM(
-    [[#if __cplusplus < 202002L]]
-    [[#error C++20 not available]]
-    [[#endif]])],
-  [AC_MSG_RESULT([yes])
-    HAVE_CXX20=yes;],
-  [AC_MSG_RESULT([no])
-    HAVE_CXX20=no;])
-
-AC_MSG_CHECKING([whether coroutines are enabled])
-AC_COMPILE_IFELSE(
-  [AC_LANG_PROGRAM(
-    [[#if defined(__clang__)]]
-    [[# if (__clang_major__ >= 14)]]
-    [[#  if (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)]]
-    [[#   if __has_include(<coroutine>)]]
-    [[#    define ASIO_HAS_CO_AWAIT 1]]
-    [[#   endif]]
-    [[#  elif (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)]]
-    [[#   if __has_include(<experimental/coroutine>)]]
-    [[#    define ASIO_HAS_CO_AWAIT 1]]
-    [[#   endif]]
-    [[#  endif]]
-    [[# else]]
-    [[#  if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)]]
-    [[#   if __has_include(<experimental/coroutine>)]]
-    [[#    define ASIO_HAS_CO_AWAIT 1]]
-    [[#   endif]]
-    [[#  endif]]
-    [[# endif]]
-    [[#elif defined(__GNUC__)]]
-    [[# if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)]]
-    [[#  if __has_include(<coroutine>)]]
-    [[#   define ASIO_HAS_CO_AWAIT 1]]
-    [[#  endif]]
-    [[# endif]]
-    [[#endif]]
-    [[#ifndef ASIO_HAS_CO_AWAIT]]
-    [[# error coroutines not available]]
-    [[#endif]])],
-  [AC_MSG_RESULT([yes])
-    HAVE_COROUTINES=yes;],
-  [AC_MSG_RESULT([no])
-    HAVE_COROUTINES=no;])
-
-if test "$GXX" = yes; then
-  if test "$STANDALONE" = yes; then
-    if test "$HAVE_CXX11" = no; then
-      HAVE_CXX11=yes
-      CPPFLAGS="-std=c++0x $CPPFLAGS"
-    fi
-  fi
-fi
-
-AM_CONDITIONAL(STANDALONE,test x$STANDALONE = xyes)
-
-AM_CONDITIONAL(SEPARATE_COMPILATION,test x$SEPARATE_COMPILATION = xyes)
-
-AM_CONDITIONAL(HAVE_BOOST_COROUTINE,test x$HAVE_BOOST_COROUTINE = xyes)
-
-AM_CONDITIONAL(WINDOWS_TARGET,test x$WINDOWS != xno)
-
-AM_CONDITIONAL(HAVE_CXX11,test x$HAVE_CXX11 = xyes)
-
-AM_CONDITIONAL(HAVE_CXX14,test x$HAVE_CXX14 = xyes)
-
-AM_CONDITIONAL(HAVE_CXX17,test x$HAVE_CXX17 = xyes)
-
-AM_CONDITIONAL(HAVE_CXX20,test x$HAVE_CXX20 = xyes)
-
-AM_CONDITIONAL(HAVE_COROUTINES,test x$HAVE_COROUTINES = xyes)
-
-AC_CONFIG_FILES([asio.pc])
-
-AC_CONFIG_FILES([
-  Makefile
-  include/Makefile
-  src/Makefile
-  src/tests/Makefile
-  src/tests/properties/Makefile
-  src/examples/cpp11/Makefile
-  src/examples/cpp14/Makefile
-  src/examples/cpp17/Makefile
-  src/examples/cpp20/Makefile])
-AC_OUTPUT
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/include/.gitignore
deleted file mode 100644
index 282522d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-Makefile
-Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/include/Makefile.am
deleted file mode 100644
index 6528e9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/Makefile.am
+++ /dev/null
@@ -1,635 +0,0 @@
-# find . -name "*.*pp" | sed -e 's/^\.\///' | sed -e 's/^.*$/  & \\/' | sort
-nobase_include_HEADERS = \
-	asio/any_completion_executor.hpp \
-	asio/any_completion_handler.hpp \
-	asio/any_io_executor.hpp \
-	asio/append.hpp \
-	asio/as_tuple.hpp \
-	asio/associated_allocator.hpp \
-	asio/associated_cancellation_slot.hpp \
-	asio/associated_executor.hpp \
-	asio/associated_immediate_executor.hpp \
-	asio/associator.hpp \
-	asio/async_result.hpp \
-	asio/awaitable.hpp \
-	asio/basic_datagram_socket.hpp \
-	asio/basic_deadline_timer.hpp \
-	asio/basic_file.hpp \
-	asio/basic_io_object.hpp \
-	asio/basic_random_access_file.hpp \
-	asio/basic_raw_socket.hpp \
-	asio/basic_readable_pipe.hpp \
-	asio/basic_seq_packet_socket.hpp \
-	asio/basic_serial_port.hpp \
-	asio/basic_signal_set.hpp \
-	asio/basic_socket_acceptor.hpp \
-	asio/basic_socket.hpp \
-	asio/basic_socket_iostream.hpp \
-	asio/basic_socket_streambuf.hpp \
-	asio/basic_streambuf_fwd.hpp \
-	asio/basic_streambuf.hpp \
-	asio/basic_stream_file.hpp \
-	asio/basic_stream_socket.hpp \
-	asio/basic_waitable_timer.hpp \
-	asio/basic_writable_pipe.hpp \
-	asio/bind_allocator.hpp \
-	asio/bind_cancellation_slot.hpp \
-	asio/bind_executor.hpp \
-	asio/bind_immediate_executor.hpp \
-	asio/buffered_read_stream_fwd.hpp \
-	asio/buffered_read_stream.hpp \
-	asio/buffered_stream_fwd.hpp \
-	asio/buffered_stream.hpp \
-	asio/buffered_write_stream_fwd.hpp \
-	asio/buffered_write_stream.hpp \
-	asio/buffer.hpp \
-	asio/buffer_registration.hpp \
-	asio/buffers_iterator.hpp \
-	asio/cancel_after.hpp \
-	asio/cancel_at.hpp \
-	asio/cancellation_signal.hpp \
-	asio/cancellation_state.hpp \
-	asio/cancellation_type.hpp \
-	asio/co_composed.hpp \
-	asio/co_spawn.hpp \
-	asio/completion_condition.hpp \
-	asio/compose.hpp \
-	asio/composed.hpp \
-	asio/connect.hpp \
-	asio/connect_pipe.hpp \
-	asio/consign.hpp \
-	asio/coroutine.hpp \
-	asio/deadline_timer.hpp \
-	asio/defer.hpp \
-	asio/deferred.hpp \
-	asio/default_completion_token.hpp \
-	asio/detached.hpp \
-	asio/detail/array_fwd.hpp \
-	asio/detail/array.hpp \
-	asio/detail/assert.hpp \
-	asio/detail/atomic_count.hpp \
-	asio/detail/base_from_cancellation_state.hpp \
-	asio/detail/base_from_completion_cond.hpp \
-	asio/detail/bind_handler.hpp \
-	asio/detail/blocking_executor_op.hpp \
-	asio/detail/buffered_stream_storage.hpp \
-	asio/detail/buffer_resize_guard.hpp \
-	asio/detail/buffer_sequence_adapter.hpp \
-	asio/detail/call_stack.hpp \
-	asio/detail/chrono.hpp \
-	asio/detail/chrono_time_traits.hpp \
-	asio/detail/completion_handler.hpp \
-	asio/detail/completion_message.hpp \
-	asio/detail/completion_payload.hpp \
-	asio/detail/completion_payload_handler.hpp \
-	asio/detail/composed_work.hpp \
-	asio/detail/concurrency_hint.hpp \
-	asio/detail/conditionally_enabled_event.hpp \
-	asio/detail/conditionally_enabled_mutex.hpp \
-	asio/detail/config.hpp \
-	asio/detail/consuming_buffers.hpp \
-	asio/detail/cstddef.hpp \
-	asio/detail/cstdint.hpp \
-	asio/detail/date_time_fwd.hpp \
-	asio/detail/deadline_timer_service.hpp \
-	asio/detail/dependent_type.hpp \
-	asio/detail/descriptor_ops.hpp \
-	asio/detail/descriptor_read_op.hpp \
-	asio/detail/descriptor_write_op.hpp \
-	asio/detail/dev_poll_reactor.hpp \
-	asio/detail/epoll_reactor.hpp \
-	asio/detail/eventfd_select_interrupter.hpp \
-	asio/detail/event.hpp \
-	asio/detail/exception.hpp \
-	asio/detail/executor_function.hpp \
-	asio/detail/executor_op.hpp \
-	asio/detail/fd_set_adapter.hpp \
-	asio/detail/fenced_block.hpp \
-	asio/detail/functional.hpp \
-	asio/detail/future.hpp \
-	asio/detail/global.hpp \
-	asio/detail/handler_alloc_helpers.hpp \
-	asio/detail/handler_cont_helpers.hpp \
-	asio/detail/handler_tracking.hpp \
-	asio/detail/handler_type_requirements.hpp \
-	asio/detail/handler_work.hpp \
-	asio/detail/hash_map.hpp \
-	asio/detail/impl/buffer_sequence_adapter.ipp \
-	asio/detail/impl/descriptor_ops.ipp \
-	asio/detail/impl/dev_poll_reactor.hpp \
-	asio/detail/impl/dev_poll_reactor.ipp \
-	asio/detail/impl/epoll_reactor.hpp \
-	asio/detail/impl/epoll_reactor.ipp \
-	asio/detail/impl/eventfd_select_interrupter.ipp \
-	asio/detail/impl/handler_tracking.ipp \
-	asio/detail/impl/io_uring_descriptor_service.ipp \
-	asio/detail/impl/io_uring_file_service.ipp \
-	asio/detail/impl/io_uring_service.hpp \
-	asio/detail/impl/io_uring_service.ipp \
-	asio/detail/impl/io_uring_socket_service_base.ipp \
-	asio/detail/impl/kqueue_reactor.hpp \
-	asio/detail/impl/kqueue_reactor.ipp \
-	asio/detail/impl/null_event.ipp \
-	asio/detail/impl/pipe_select_interrupter.ipp \
-	asio/detail/impl/posix_event.ipp \
-	asio/detail/impl/posix_mutex.ipp \
-	asio/detail/impl/posix_serial_port_service.ipp \
-	asio/detail/impl/posix_thread.ipp \
-	asio/detail/impl/posix_tss_ptr.ipp \
-	asio/detail/impl/reactive_descriptor_service.ipp \
-	asio/detail/impl/reactive_socket_service_base.ipp \
-	asio/detail/impl/resolver_service_base.ipp \
-	asio/detail/impl/scheduler.ipp \
-	asio/detail/impl/select_reactor.hpp \
-	asio/detail/impl/select_reactor.ipp \
-	asio/detail/impl/service_registry.hpp \
-	asio/detail/impl/service_registry.ipp \
-	asio/detail/impl/signal_set_service.ipp \
-	asio/detail/impl/socket_ops.ipp \
-	asio/detail/impl/socket_select_interrupter.ipp \
-	asio/detail/impl/strand_executor_service.hpp \
-	asio/detail/impl/strand_executor_service.ipp \
-	asio/detail/impl/strand_service.hpp \
-	asio/detail/impl/strand_service.ipp \
-	asio/detail/impl/thread_context.ipp \
-	asio/detail/impl/throw_error.ipp \
-	asio/detail/impl/timer_queue_ptime.ipp \
-	asio/detail/impl/timer_queue_set.ipp \
-	asio/detail/impl/win_event.ipp \
-	asio/detail/impl/win_iocp_file_service.ipp \
-	asio/detail/impl/win_iocp_handle_service.ipp \
-	asio/detail/impl/win_iocp_io_context.hpp \
-	asio/detail/impl/win_iocp_io_context.ipp \
-	asio/detail/impl/win_iocp_serial_port_service.ipp \
-	asio/detail/impl/win_iocp_socket_service_base.ipp \
-	asio/detail/impl/win_mutex.ipp \
-	asio/detail/impl/win_object_handle_service.ipp \
-	asio/detail/impl/winrt_ssocket_service_base.ipp \
-	asio/detail/impl/winrt_timer_scheduler.hpp \
-	asio/detail/impl/winrt_timer_scheduler.ipp \
-	asio/detail/impl/winsock_init.ipp \
-	asio/detail/impl/win_static_mutex.ipp \
-	asio/detail/impl/win_thread.ipp \
-	asio/detail/impl/win_tss_ptr.ipp \
-	asio/detail/initiate_defer.hpp \
-	asio/detail/initiate_dispatch.hpp \
-	asio/detail/initiate_post.hpp \
-	asio/detail/initiation_base.hpp \
-	asio/detail/io_control.hpp \
-	asio/detail/io_object_impl.hpp \
-	asio/detail/io_uring_descriptor_read_at_op.hpp \
-	asio/detail/io_uring_descriptor_read_op.hpp \
-	asio/detail/io_uring_descriptor_service.hpp \
-	asio/detail/io_uring_descriptor_write_at_op.hpp \
-	asio/detail/io_uring_descriptor_write_op.hpp \
-	asio/detail/io_uring_file_service.hpp \
-	asio/detail/io_uring_null_buffers_op.hpp \
-	asio/detail/io_uring_operation.hpp \
-	asio/detail/io_uring_service.hpp \
-	asio/detail/io_uring_socket_accept_op.hpp \
-	asio/detail/io_uring_socket_connect_op.hpp \
-	asio/detail/io_uring_socket_recvfrom_op.hpp \
-	asio/detail/io_uring_socket_recvmsg_op.hpp \
-	asio/detail/io_uring_socket_recv_op.hpp \
-	asio/detail/io_uring_socket_send_op.hpp \
-	asio/detail/io_uring_socket_sendto_op.hpp \
-	asio/detail/io_uring_socket_service_base.hpp \
-	asio/detail/io_uring_socket_service.hpp \
-	asio/detail/io_uring_wait_op.hpp \
-	asio/detail/is_buffer_sequence.hpp \
-	asio/detail/is_executor.hpp \
-	asio/detail/keyword_tss_ptr.hpp \
-	asio/detail/kqueue_reactor.hpp \
-	asio/detail/limits.hpp \
-	asio/detail/local_free_on_block_exit.hpp \
-	asio/detail/memory.hpp \
-	asio/detail/mutex.hpp \
-	asio/detail/non_const_lvalue.hpp \
-	asio/detail/noncopyable.hpp \
-	asio/detail/null_event.hpp \
-	asio/detail/null_fenced_block.hpp \
-	asio/detail/null_global.hpp \
-	asio/detail/null_mutex.hpp \
-	asio/detail/null_reactor.hpp \
-	asio/detail/null_signal_blocker.hpp \
-	asio/detail/null_socket_service.hpp \
-	asio/detail/null_static_mutex.hpp \
-	asio/detail/null_thread.hpp \
-	asio/detail/null_tss_ptr.hpp \
-	asio/detail/object_pool.hpp \
-	asio/detail/old_win_sdk_compat.hpp \
-	asio/detail/operation.hpp \
-	asio/detail/op_queue.hpp \
-	asio/detail/pipe_select_interrupter.hpp \
-	asio/detail/pop_options.hpp \
-	asio/detail/posix_event.hpp \
-	asio/detail/posix_fd_set_adapter.hpp \
-	asio/detail/posix_global.hpp \
-	asio/detail/posix_mutex.hpp \
-	asio/detail/posix_serial_port_service.hpp \
-	asio/detail/posix_signal_blocker.hpp \
-	asio/detail/posix_static_mutex.hpp \
-	asio/detail/posix_thread.hpp \
-	asio/detail/posix_tss_ptr.hpp \
-	asio/detail/push_options.hpp \
-	asio/detail/reactive_descriptor_service.hpp \
-	asio/detail/reactive_null_buffers_op.hpp \
-	asio/detail/reactive_socket_accept_op.hpp \
-	asio/detail/reactive_socket_connect_op.hpp \
-	asio/detail/reactive_socket_recvfrom_op.hpp \
-	asio/detail/reactive_socket_recvmsg_op.hpp \
-	asio/detail/reactive_socket_recv_op.hpp \
-	asio/detail/reactive_socket_send_op.hpp \
-	asio/detail/reactive_socket_sendto_op.hpp \
-	asio/detail/reactive_socket_service_base.hpp \
-	asio/detail/reactive_socket_service.hpp \
-	asio/detail/reactive_wait_op.hpp \
-	asio/detail/reactor.hpp \
-	asio/detail/reactor_op.hpp \
-	asio/detail/reactor_op_queue.hpp \
-	asio/detail/recycling_allocator.hpp \
-	asio/detail/regex_fwd.hpp \
-	asio/detail/resolve_endpoint_op.hpp \
-	asio/detail/resolve_op.hpp \
-	asio/detail/resolve_query_op.hpp \
-	asio/detail/resolver_service_base.hpp \
-	asio/detail/resolver_service.hpp \
-	asio/detail/scheduler.hpp \
-	asio/detail/scheduler_operation.hpp \
-	asio/detail/scheduler_task.hpp \
-	asio/detail/scheduler_thread_info.hpp \
-	asio/detail/scoped_lock.hpp \
-	asio/detail/scoped_ptr.hpp \
-	asio/detail/select_interrupter.hpp \
-	asio/detail/select_reactor.hpp \
-	asio/detail/service_registry.hpp \
-	asio/detail/signal_blocker.hpp \
-	asio/detail/signal_handler.hpp \
-	asio/detail/signal_init.hpp \
-	asio/detail/signal_op.hpp \
-	asio/detail/signal_set_service.hpp \
-	asio/detail/socket_holder.hpp \
-	asio/detail/socket_ops.hpp \
-	asio/detail/socket_option.hpp \
-	asio/detail/socket_select_interrupter.hpp \
-	asio/detail/socket_types.hpp \
-	asio/detail/source_location.hpp \
-	asio/detail/static_mutex.hpp \
-	asio/detail/std_event.hpp \
-	asio/detail/std_fenced_block.hpp \
-	asio/detail/std_global.hpp \
-	asio/detail/std_mutex.hpp \
-	asio/detail/std_static_mutex.hpp \
-	asio/detail/std_thread.hpp \
-	asio/detail/strand_executor_service.hpp \
-	asio/detail/strand_service.hpp \
-	asio/detail/string_view.hpp \
-	asio/detail/thread_context.hpp \
-	asio/detail/thread_group.hpp \
-	asio/detail/thread.hpp \
-	asio/detail/thread_info_base.hpp \
-	asio/detail/throw_error.hpp \
-	asio/detail/throw_exception.hpp \
-	asio/detail/timed_cancel_op.hpp \
-	asio/detail/timer_queue_base.hpp \
-	asio/detail/timer_queue.hpp \
-	asio/detail/timer_queue_ptime.hpp \
-	asio/detail/timer_queue_set.hpp \
-	asio/detail/timer_scheduler_fwd.hpp \
-	asio/detail/timer_scheduler.hpp \
-	asio/detail/tss_ptr.hpp \
-	asio/detail/type_traits.hpp \
-	asio/detail/utility.hpp \
-	asio/detail/wait_handler.hpp \
-	asio/detail/wait_op.hpp \
-	asio/detail/winapp_thread.hpp \
-	asio/detail/wince_thread.hpp \
-	asio/detail/win_event.hpp \
-	asio/detail/win_fd_set_adapter.hpp \
-	asio/detail/win_global.hpp \
-	asio/detail/win_iocp_file_service.hpp \
-	asio/detail/win_iocp_handle_read_op.hpp \
-	asio/detail/win_iocp_handle_service.hpp \
-	asio/detail/win_iocp_handle_write_op.hpp \
-	asio/detail/win_iocp_io_context.hpp \
-	asio/detail/win_iocp_null_buffers_op.hpp \
-	asio/detail/win_iocp_operation.hpp \
-	asio/detail/win_iocp_overlapped_op.hpp \
-	asio/detail/win_iocp_overlapped_ptr.hpp \
-	asio/detail/win_iocp_serial_port_service.hpp \
-	asio/detail/win_iocp_socket_accept_op.hpp \
-	asio/detail/win_iocp_socket_connect_op.hpp \
-	asio/detail/win_iocp_socket_recvfrom_op.hpp \
-	asio/detail/win_iocp_socket_recvmsg_op.hpp \
-	asio/detail/win_iocp_socket_recv_op.hpp \
-	asio/detail/win_iocp_socket_send_op.hpp \
-	asio/detail/win_iocp_socket_service_base.hpp \
-	asio/detail/win_iocp_socket_service.hpp \
-	asio/detail/win_iocp_thread_info.hpp \
-	asio/detail/win_iocp_wait_op.hpp \
-	asio/detail/win_mutex.hpp \
-	asio/detail/win_object_handle_service.hpp \
-	asio/detail/winrt_async_manager.hpp \
-	asio/detail/winrt_async_op.hpp \
-	asio/detail/winrt_resolve_op.hpp \
-	asio/detail/winrt_resolver_service.hpp \
-	asio/detail/winrt_socket_connect_op.hpp \
-	asio/detail/winrt_socket_recv_op.hpp \
-	asio/detail/winrt_socket_send_op.hpp \
-	asio/detail/winrt_ssocket_service_base.hpp \
-	asio/detail/winrt_ssocket_service.hpp \
-	asio/detail/winrt_timer_scheduler.hpp \
-	asio/detail/winrt_utils.hpp \
-	asio/detail/winsock_init.hpp \
-	asio/detail/win_static_mutex.hpp \
-	asio/detail/win_thread.hpp \
-	asio/detail/win_tss_ptr.hpp \
-	asio/detail/work_dispatcher.hpp \
-	asio/detail/wrapped_handler.hpp \
-	asio/dispatch.hpp \
-	asio/error_code.hpp \
-	asio/error.hpp \
-	asio/execution.hpp \
-	asio/execution_context.hpp \
-	asio/execution/allocator.hpp \
-	asio/execution/any_executor.hpp \
-	asio/execution/bad_executor.hpp \
-	asio/execution/blocking.hpp \
-	asio/execution/blocking_adaptation.hpp \
-	asio/execution/context.hpp \
-	asio/execution/context_as.hpp \
-	asio/execution/executor.hpp \
-	asio/execution/impl/bad_executor.ipp \
-	asio/execution/invocable_archetype.hpp \
-	asio/execution/mapping.hpp \
-	asio/execution/occupancy.hpp \
-	asio/execution/outstanding_work.hpp \
-	asio/execution/prefer_only.hpp \
-	asio/execution/relationship.hpp \
-	asio/executor.hpp \
-	asio/executor_work_guard.hpp \
-	asio/experimental/append.hpp \
-	asio/experimental/as_single.hpp \
-	asio/experimental/as_tuple.hpp \
-	asio/experimental/awaitable_operators.hpp \
-	asio/experimental/basic_channel.hpp \
-	asio/experimental/basic_concurrent_channel.hpp \
-	asio/experimental/cancellation_condition.hpp \
-	asio/experimental/channel.hpp \
-	asio/experimental/channel_error.hpp \
-	asio/experimental/channel_traits.hpp \
-	asio/experimental/co_composed.hpp \
-	asio/experimental/co_spawn.hpp \
-	asio/experimental/concurrent_channel.hpp \
-	asio/experimental/coro.hpp \
-	asio/experimental/coro_traits.hpp \
-	asio/experimental/deferred.hpp \
-	asio/experimental/detail/channel_operation.hpp \
-	asio/experimental/detail/channel_receive_op.hpp \
-	asio/experimental/detail/channel_send_functions.hpp \
-	asio/experimental/detail/channel_send_op.hpp \
-	asio/experimental/detail/channel_service.hpp \
-	asio/experimental/detail/coro_completion_handler.hpp \
-	asio/experimental/detail/coro_promise_allocator.hpp \
-	asio/experimental/detail/has_signature.hpp \
-	asio/experimental/detail/impl/channel_service.hpp \
-	asio/experimental/detail/partial_promise.hpp \
-	asio/experimental/impl/as_single.hpp \
-	asio/experimental/impl/channel_error.ipp \
-	asio/experimental/impl/coro.hpp \
-	asio/experimental/impl/parallel_group.hpp \
-	asio/experimental/impl/promise.hpp \
-	asio/experimental/impl/use_coro.hpp \
-	asio/experimental/impl/use_promise.hpp \
-	asio/experimental/parallel_group.hpp \
-	asio/experimental/prepend.hpp \
-	asio/experimental/promise.hpp \
-	asio/experimental/use_coro.hpp \
-	asio/experimental/use_promise.hpp \
-	asio/file_base.hpp \
-	asio/generic/basic_endpoint.hpp \
-	asio/generic/datagram_protocol.hpp \
-	asio/generic/detail/endpoint.hpp \
-	asio/generic/detail/impl/endpoint.ipp \
-	asio/generic/raw_protocol.hpp \
-	asio/generic/seq_packet_protocol.hpp \
-	asio/generic/stream_protocol.hpp \
-	asio/handler_continuation_hook.hpp \
-	asio/high_resolution_timer.hpp \
-	asio.hpp \
-	asio/immediate.hpp \
-	asio/impl/any_completion_executor.ipp \
-	asio/impl/any_io_executor.ipp \
-	asio/impl/append.hpp \
-	asio/impl/as_tuple.hpp \
-	asio/impl/awaitable.hpp \
-	asio/impl/buffered_read_stream.hpp \
-	asio/impl/buffered_write_stream.hpp \
-	asio/impl/cancel_after.hpp \
-	asio/impl/cancel_at.hpp \
-	asio/impl/cancellation_signal.ipp \
-	asio/impl/co_spawn.hpp \
-	asio/impl/connect.hpp \
-	asio/impl/connect_pipe.hpp \
-	asio/impl/connect_pipe.ipp \
-	asio/impl/consign.hpp \
-	asio/impl/deferred.hpp \
-	asio/impl/detached.hpp \
-	asio/impl/error_code.ipp \
-	asio/impl/error.ipp \
-	asio/impl/execution_context.hpp \
-	asio/impl/execution_context.ipp \
-	asio/impl/executor.hpp \
-	asio/impl/executor.ipp \
-	asio/impl/io_context.hpp \
-	asio/impl/io_context.ipp \
-	asio/impl/multiple_exceptions.ipp \
-	asio/impl/prepend.hpp \
-	asio/impl/read_at.hpp \
-	asio/impl/read.hpp \
-	asio/impl/read_until.hpp \
-	asio/impl/redirect_error.hpp \
-	asio/impl/serial_port_base.hpp \
-	asio/impl/serial_port_base.ipp \
-	asio/impl/spawn.hpp \
-	asio/impl/src.hpp \
-	asio/impl/system_context.hpp \
-	asio/impl/system_context.ipp \
-	asio/impl/system_executor.hpp \
-	asio/impl/thread_pool.hpp \
-	asio/impl/thread_pool.ipp \
-	asio/impl/use_awaitable.hpp \
-	asio/impl/use_future.hpp \
-	asio/impl/write_at.hpp \
-	asio/impl/write.hpp \
-	asio/io_context.hpp \
-	asio/io_context_strand.hpp \
-	asio/io_service.hpp \
-	asio/io_service_strand.hpp \
-	asio/ip/address.hpp \
-	asio/ip/address_v4.hpp \
-	asio/ip/address_v4_iterator.hpp \
-	asio/ip/address_v4_range.hpp \
-	asio/ip/address_v6.hpp \
-	asio/ip/address_v6_iterator.hpp \
-	asio/ip/address_v6_range.hpp \
-	asio/ip/bad_address_cast.hpp \
-	asio/ip/basic_endpoint.hpp \
-	asio/ip/basic_resolver_entry.hpp \
-	asio/ip/basic_resolver.hpp \
-	asio/ip/basic_resolver_iterator.hpp \
-	asio/ip/basic_resolver_query.hpp \
-	asio/ip/basic_resolver_results.hpp \
-	asio/ip/detail/endpoint.hpp \
-	asio/ip/detail/impl/endpoint.ipp \
-	asio/ip/detail/socket_option.hpp \
-	asio/ip/host_name.hpp \
-	asio/ip/icmp.hpp \
-	asio/ip/impl/address.hpp \
-	asio/ip/impl/address.ipp \
-	asio/ip/impl/address_v4.hpp \
-	asio/ip/impl/address_v4.ipp \
-	asio/ip/impl/address_v6.hpp \
-	asio/ip/impl/address_v6.ipp \
-	asio/ip/impl/basic_endpoint.hpp \
-	asio/ip/impl/host_name.ipp \
-	asio/ip/impl/network_v4.hpp \
-	asio/ip/impl/network_v4.ipp \
-	asio/ip/impl/network_v6.hpp \
-	asio/ip/impl/network_v6.ipp \
-	asio/ip/multicast.hpp \
-	asio/ip/network_v4.hpp \
-	asio/ip/network_v6.hpp \
-	asio/ip/resolver_base.hpp \
-	asio/ip/resolver_query_base.hpp \
-	asio/ip/tcp.hpp \
-	asio/ip/udp.hpp \
-	asio/ip/unicast.hpp \
-	asio/ip/v6_only.hpp \
-	asio/is_applicable_property.hpp \
-	asio/is_contiguous_iterator.hpp \
-	asio/is_executor.hpp \
-	asio/is_read_buffered.hpp \
-	asio/is_write_buffered.hpp \
-	asio/local/basic_endpoint.hpp \
-	asio/local/connect_pair.hpp \
-	asio/local/datagram_protocol.hpp \
-	asio/local/detail/endpoint.hpp \
-	asio/local/detail/impl/endpoint.ipp \
-	asio/local/seq_packet_protocol.hpp \
-	asio/local/stream_protocol.hpp \
-	asio/multiple_exceptions.hpp \
-	asio/packaged_task.hpp \
-	asio/placeholders.hpp \
-	asio/posix/basic_descriptor.hpp \
-	asio/posix/basic_stream_descriptor.hpp \
-	asio/posix/descriptor_base.hpp \
-	asio/posix/descriptor.hpp \
-	asio/posix/stream_descriptor.hpp \
-	asio/post.hpp \
-	asio/prefer.hpp \
-	asio/prepend.hpp \
-	asio/query.hpp \
-	asio/random_access_file.hpp \
-	asio/read_at.hpp \
-	asio/read.hpp \
-	asio/read_until.hpp \
-	asio/readable_pipe.hpp \
-	asio/recycling_allocator.hpp \
-	asio/redirect_error.hpp \
-	asio/registered_buffer.hpp \
-	asio/require.hpp \
-	asio/require_concept.hpp \
-	asio/serial_port_base.hpp \
-	asio/serial_port.hpp \
-	asio/signal_set_base.hpp \
-	asio/signal_set.hpp \
-	asio/socket_base.hpp \
-	asio/spawn.hpp \
-	asio/ssl/context_base.hpp \
-	asio/ssl/context.hpp \
-	asio/ssl/detail/buffered_handshake_op.hpp \
-	asio/ssl/detail/engine.hpp \
-	asio/ssl/detail/handshake_op.hpp \
-	asio/ssl/detail/impl/engine.ipp \
-	asio/ssl/detail/impl/openssl_init.ipp \
-	asio/ssl/detail/io.hpp \
-	asio/ssl/detail/openssl_init.hpp \
-	asio/ssl/detail/openssl_types.hpp \
-	asio/ssl/detail/password_callback.hpp \
-	asio/ssl/detail/read_op.hpp \
-	asio/ssl/detail/shutdown_op.hpp \
-	asio/ssl/detail/stream_core.hpp \
-	asio/ssl/detail/verify_callback.hpp \
-	asio/ssl/detail/write_op.hpp \
-	asio/ssl/error.hpp \
-	asio/ssl.hpp \
-	asio/ssl/host_name_verification.hpp \
-	asio/ssl/impl/context.hpp \
-	asio/ssl/impl/context.ipp \
-	asio/ssl/impl/error.ipp \
-	asio/ssl/impl/host_name_verification.ipp \
-	asio/ssl/impl/rfc2818_verification.ipp \
-	asio/ssl/impl/src.hpp \
-	asio/ssl/rfc2818_verification.hpp \
-	asio/ssl/stream_base.hpp \
-	asio/ssl/stream.hpp \
-	asio/ssl/verify_context.hpp \
-	asio/ssl/verify_mode.hpp \
-	asio/static_thread_pool.hpp \
-	asio/steady_timer.hpp \
-	asio/strand.hpp \
-	asio/streambuf.hpp \
-	asio/stream_file.hpp \
-	asio/system_context.hpp \
-	asio/system_error.hpp \
-	asio/system_executor.hpp \
-	asio/system_timer.hpp \
-	asio/this_coro.hpp \
-	asio/thread.hpp \
-	asio/thread_pool.hpp \
-	asio/time_traits.hpp \
-	asio/traits/equality_comparable.hpp \
-	asio/traits/execute_member.hpp \
-	asio/traits/prefer_free.hpp \
-	asio/traits/prefer_member.hpp \
-	asio/traits/query_free.hpp \
-	asio/traits/query_member.hpp \
-	asio/traits/query_static_constexpr_member.hpp \
-	asio/traits/require_concept_free.hpp \
-	asio/traits/require_concept_member.hpp \
-	asio/traits/require_free.hpp \
-	asio/traits/require_member.hpp \
-	asio/traits/static_query.hpp \
-	asio/traits/static_require.hpp \
-	asio/traits/static_require_concept.hpp \
-	asio/ts/buffer.hpp \
-	asio/ts/executor.hpp \
-	asio/ts/internet.hpp \
-	asio/ts/io_context.hpp \
-	asio/ts/netfwd.hpp \
-	asio/ts/net.hpp \
-	asio/ts/socket.hpp \
-	asio/ts/timer.hpp \
-	asio/unyield.hpp \
-	asio/use_awaitable.hpp \
-	asio/use_future.hpp \
-	asio/uses_executor.hpp \
-	asio/version.hpp \
-	asio/wait_traits.hpp \
-	asio/windows/basic_object_handle.hpp \
-	asio/windows/basic_overlapped_handle.hpp \
-	asio/windows/basic_random_access_handle.hpp \
-	asio/windows/basic_stream_handle.hpp \
-	asio/windows/object_handle.hpp \
-	asio/windows/overlapped_handle.hpp \
-	asio/windows/overlapped_ptr.hpp \
-	asio/windows/random_access_handle.hpp \
-	asio/windows/stream_handle.hpp \
-	asio/writable_pipe.hpp \
-	asio/write_at.hpp \
-	asio/write.hpp \
-	asio/yield.hpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio.hpp
deleted file mode 100644
index 25cee47..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio.hpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-// asio.hpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_HPP
-#define ASIO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/any_completion_executor.hpp"
-#include "asio/any_completion_handler.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/append.hpp"
-#include "asio/as_tuple.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/awaitable.hpp"
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/basic_deadline_timer.hpp"
-#include "asio/basic_file.hpp"
-#include "asio/basic_io_object.hpp"
-#include "asio/basic_random_access_file.hpp"
-#include "asio/basic_raw_socket.hpp"
-#include "asio/basic_readable_pipe.hpp"
-#include "asio/basic_seq_packet_socket.hpp"
-#include "asio/basic_serial_port.hpp"
-#include "asio/basic_signal_set.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/basic_socket_streambuf.hpp"
-#include "asio/basic_stream_file.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/basic_streambuf.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/basic_writable_pipe.hpp"
-#include "asio/bind_allocator.hpp"
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/bind_immediate_executor.hpp"
-#include "asio/buffer.hpp"
-#include "asio/buffer_registration.hpp"
-#include "asio/buffered_read_stream_fwd.hpp"
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-#include "asio/buffered_stream.hpp"
-#include "asio/buffered_write_stream_fwd.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/buffers_iterator.hpp"
-#include "asio/cancel_after.hpp"
-#include "asio/cancel_at.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/co_composed.hpp"
-#include "asio/co_spawn.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/compose.hpp"
-#include "asio/composed.hpp"
-#include "asio/connect.hpp"
-#include "asio/connect_pipe.hpp"
-#include "asio/consign.hpp"
-#include "asio/coroutine.hpp"
-#include "asio/deadline_timer.hpp"
-#include "asio/defer.hpp"
-#include "asio/deferred.hpp"
-#include "asio/default_completion_token.hpp"
-#include "asio/detached.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/error.hpp"
-#include "asio/error_code.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/any_executor.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/blocking_adaptation.hpp"
-#include "asio/execution/context.hpp"
-#include "asio/execution/context_as.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/invocable_archetype.hpp"
-#include "asio/execution/mapping.hpp"
-#include "asio/execution/occupancy.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/execution/prefer_only.hpp"
-#include "asio/execution/relationship.hpp"
-#include "asio/executor.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/file_base.hpp"
-#include "asio/generic/basic_endpoint.hpp"
-#include "asio/generic/datagram_protocol.hpp"
-#include "asio/generic/raw_protocol.hpp"
-#include "asio/generic/seq_packet_protocol.hpp"
-#include "asio/generic/stream_protocol.hpp"
-#include "asio/handler_continuation_hook.hpp"
-#include "asio/high_resolution_timer.hpp"
-#include "asio/immediate.hpp"
-#include "asio/io_context.hpp"
-#include "asio/io_context_strand.hpp"
-#include "asio/io_service.hpp"
-#include "asio/io_service_strand.hpp"
-#include "asio/ip/address.hpp"
-#include "asio/ip/address_v4.hpp"
-#include "asio/ip/address_v4_iterator.hpp"
-#include "asio/ip/address_v4_range.hpp"
-#include "asio/ip/address_v6.hpp"
-#include "asio/ip/address_v6_iterator.hpp"
-#include "asio/ip/address_v6_range.hpp"
-#include "asio/ip/network_v4.hpp"
-#include "asio/ip/network_v6.hpp"
-#include "asio/ip/bad_address_cast.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/basic_resolver_entry.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/host_name.hpp"
-#include "asio/ip/icmp.hpp"
-#include "asio/ip/multicast.hpp"
-#include "asio/ip/resolver_base.hpp"
-#include "asio/ip/resolver_query_base.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "asio/ip/unicast.hpp"
-#include "asio/ip/v6_only.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/is_contiguous_iterator.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/is_read_buffered.hpp"
-#include "asio/is_write_buffered.hpp"
-#include "asio/local/basic_endpoint.hpp"
-#include "asio/local/connect_pair.hpp"
-#include "asio/local/datagram_protocol.hpp"
-#include "asio/local/seq_packet_protocol.hpp"
-#include "asio/local/stream_protocol.hpp"
-#include "asio/multiple_exceptions.hpp"
-#include "asio/packaged_task.hpp"
-#include "asio/placeholders.hpp"
-#include "asio/posix/basic_descriptor.hpp"
-#include "asio/posix/basic_stream_descriptor.hpp"
-#include "asio/posix/descriptor.hpp"
-#include "asio/posix/descriptor_base.hpp"
-#include "asio/posix/stream_descriptor.hpp"
-#include "asio/post.hpp"
-#include "asio/prefer.hpp"
-#include "asio/prepend.hpp"
-#include "asio/query.hpp"
-#include "asio/random_access_file.hpp"
-#include "asio/read.hpp"
-#include "asio/read_at.hpp"
-#include "asio/read_until.hpp"
-#include "asio/readable_pipe.hpp"
-#include "asio/recycling_allocator.hpp"
-#include "asio/redirect_error.hpp"
-#include "asio/registered_buffer.hpp"
-#include "asio/require.hpp"
-#include "asio/require_concept.hpp"
-#include "asio/serial_port.hpp"
-#include "asio/serial_port_base.hpp"
-#include "asio/signal_set.hpp"
-#include "asio/signal_set_base.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/static_thread_pool.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/strand.hpp"
-#include "asio/stream_file.hpp"
-#include "asio/streambuf.hpp"
-#include "asio/system_context.hpp"
-#include "asio/system_error.hpp"
-#include "asio/system_executor.hpp"
-#include "asio/system_timer.hpp"
-#include "asio/this_coro.hpp"
-#include "asio/thread.hpp"
-#include "asio/thread_pool.hpp"
-#include "asio/time_traits.hpp"
-#include "asio/use_awaitable.hpp"
-#include "asio/use_future.hpp"
-#include "asio/uses_executor.hpp"
-#include "asio/version.hpp"
-#include "asio/wait_traits.hpp"
-#include "asio/windows/basic_object_handle.hpp"
-#include "asio/windows/basic_overlapped_handle.hpp"
-#include "asio/windows/basic_random_access_handle.hpp"
-#include "asio/windows/basic_stream_handle.hpp"
-#include "asio/windows/object_handle.hpp"
-#include "asio/windows/overlapped_handle.hpp"
-#include "asio/windows/overlapped_ptr.hpp"
-#include "asio/windows/random_access_handle.hpp"
-#include "asio/windows/stream_handle.hpp"
-#include "asio/writable_pipe.hpp"
-#include "asio/write.hpp"
-#include "asio/write_at.hpp"
-
-#endif // ASIO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_executor.hpp
deleted file mode 100644
index 650ff7b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_executor.hpp
+++ /dev/null
@@ -1,336 +0,0 @@
-//
-// any_completion_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ANY_COMPLETION_EXECUTOR_HPP
-#define ASIO_ANY_COMPLETION_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/executor.hpp"
-#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/execution.hpp"
-#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-typedef executor any_completion_executor;
-
-#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-/// Polymorphic executor type for use with I/O objects.
-/**
- * The @c any_completion_executor type is a polymorphic executor that supports
- * the set of properties required for the execution of completion handlers. It
- * is defined as the execution::any_executor class template parameterised as
- * follows:
- * @code execution::any_executor<
- *   execution::prefer_only<execution::outstanding_work_t::tracked_t>,
- *   execution::prefer_only<execution::outstanding_work_t::untracked_t>
- *   execution::prefer_only<execution::relationship_t::fork_t>,
- *   execution::prefer_only<execution::relationship_t::continuation_t>
- * > @endcode
- */
-class any_completion_executor :
-#if defined(GENERATING_DOCUMENTATION)
-  public execution::any_executor<...>
-#else // defined(GENERATING_DOCUMENTATION)
-  public execution::any_executor<
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    >
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-public:
-#if !defined(GENERATING_DOCUMENTATION)
-  typedef execution::any_executor<
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    > base_type;
-
-  typedef void supportable_properties_type(
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    );
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Default constructor.
-  ASIO_DECL any_completion_executor() noexcept;
-
-  /// Construct in an empty state. Equivalent effects to default constructor.
-  ASIO_DECL any_completion_executor(nullptr_t) noexcept;
-
-  /// Copy constructor.
-  ASIO_DECL any_completion_executor(
-      const any_completion_executor& e) noexcept;
-
-  /// Move constructor.
-  ASIO_DECL any_completion_executor(
-      any_completion_executor&& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <class... OtherSupportableProperties>
-    any_completion_executor(
-        execution::any_executor<OtherSupportableProperties...> e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <typename OtherAnyExecutor>
-  any_completion_executor(OtherAnyExecutor e,
-      constraint_t<
-        conditional<
-          !is_same<OtherAnyExecutor, any_completion_executor>::value
-            && is_base_of<execution::detail::any_executor_base,
-              OtherAnyExecutor>::value,
-          typename execution::detail::supportable_properties<
-            0, supportable_properties_type>::template
-              is_valid_target<OtherAnyExecutor>,
-          false_type
-        >::type::value
-      > = 0)
-    : base_type(static_cast<OtherAnyExecutor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct to point to the same target as another any_executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <class... OtherSupportableProperties>
-    any_completion_executor(std::nothrow_t,
-      execution::any_executor<OtherSupportableProperties...> e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <typename OtherAnyExecutor>
-  any_completion_executor(std::nothrow_t, OtherAnyExecutor e,
-      constraint_t<
-        conditional<
-          !is_same<OtherAnyExecutor, any_completion_executor>::value
-            && is_base_of<execution::detail::any_executor_base,
-              OtherAnyExecutor>::value,
-          typename execution::detail::supportable_properties<
-            0, supportable_properties_type>::template
-              is_valid_target<OtherAnyExecutor>,
-          false_type
-        >::type::value
-      > = 0) noexcept
-    : base_type(std::nothrow, static_cast<OtherAnyExecutor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct to point to the same target as another any_executor.
-  ASIO_DECL any_completion_executor(std::nothrow_t,
-      const any_completion_executor& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-  ASIO_DECL any_completion_executor(std::nothrow_t,
-      any_completion_executor&& e) noexcept;
-
-  /// Construct a polymorphic wrapper for the specified executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_completion_executor(Executor e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_completion_executor(Executor e,
-      constraint_t<
-        conditional<
-          !is_same<Executor, any_completion_executor>::value
-            && !is_base_of<execution::detail::any_executor_base,
-              Executor>::value,
-          execution::detail::is_valid_target_executor<
-            Executor, supportable_properties_type>,
-          false_type
-        >::type::value
-      > = 0)
-    : base_type(static_cast<Executor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct a polymorphic wrapper for the specified executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_completion_executor(std::nothrow_t, Executor e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_completion_executor(std::nothrow_t, Executor e,
-      constraint_t<
-        conditional<
-          !is_same<Executor, any_completion_executor>::value
-            && !is_base_of<execution::detail::any_executor_base,
-              Executor>::value,
-          execution::detail::is_valid_target_executor<
-            Executor, supportable_properties_type>,
-          false_type
-        >::type::value
-      > = 0) noexcept
-    : base_type(std::nothrow, static_cast<Executor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Assignment operator.
-  ASIO_DECL any_completion_executor& operator=(
-      const any_completion_executor& e) noexcept;
-
-  /// Move assignment operator.
-  ASIO_DECL any_completion_executor& operator=(
-      any_completion_executor&& e) noexcept;
-
-  /// Assignment operator that sets the polymorphic wrapper to the empty state.
-  ASIO_DECL any_completion_executor& operator=(nullptr_t);
-
-  /// Destructor.
-  ASIO_DECL ~any_completion_executor();
-
-  /// Swap targets with another polymorphic wrapper.
-  ASIO_DECL void swap(any_completion_executor& other) noexcept;
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require and asio::prefer customisation points.
-   *
-   * For example:
-   * @code any_completion_executor ex = ...;
-   * auto ex2 = asio::require(ex, execution::relationship.fork); @endcode
-   */
-  template <typename Property>
-  any_completion_executor require(const Property& p,
-      constraint_t<
-        traits::require_member<const base_type&, const Property&>::is_valid
-      > = 0) const
-  {
-    return static_cast<const base_type&>(*this).require(p);
-  }
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::prefer customisation point.
-   *
-   * For example:
-   * @code any_completion_executor ex = ...;
-   * auto ex2 = asio::prefer(ex, execution::relationship.fork); @endcode
-   */
-  template <typename Property>
-  any_completion_executor prefer(const Property& p,
-      constraint_t<
-        traits::prefer_member<const base_type&, const Property&>::is_valid
-      > = 0) const
-  {
-    return static_cast<const base_type&>(*this).prefer(p);
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <>
-ASIO_DECL any_completion_executor any_completion_executor::prefer(
-    const execution::outstanding_work_t::tracked_t&, int) const;
-
-template <>
-ASIO_DECL any_completion_executor any_completion_executor::prefer(
-    const execution::outstanding_work_t::untracked_t&, int) const;
-
-template <>
-ASIO_DECL any_completion_executor any_completion_executor::prefer(
-    const execution::relationship_t::fork_t&, int) const;
-
-template <>
-ASIO_DECL any_completion_executor any_completion_executor::prefer(
-    const execution::relationship_t::continuation_t&, int) const;
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<any_completion_executor>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<any_completion_executor, F>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Prop>
-struct query_member<any_completion_executor, Prop> :
-  query_member<any_completion_executor::base_type, Prop>
-{
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Prop>
-struct require_member<any_completion_executor, Prop> :
-  require_member<any_completion_executor::base_type, Prop>
-{
-  typedef any_completion_executor result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename Prop>
-struct prefer_member<any_completion_executor, Prop> :
-  prefer_member<any_completion_executor::base_type, Prop>
-{
-  typedef any_completion_executor result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY) \
-  && !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/impl/any_completion_executor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-       //   && !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#endif // ASIO_ANY_COMPLETION_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_handler.hpp
deleted file mode 100644
index 45b3e75..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_completion_handler.hpp
+++ /dev/null
@@ -1,822 +0,0 @@
-//
-// any_completion_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ANY_COMPLETION_HANDLER_HPP
-#define ASIO_ANY_COMPLETION_HANDLER_HPP
-
-#include "asio/detail/config.hpp"
-#include <cstring>
-#include <functional>
-#include <memory>
-#include <utility>
-#include "asio/any_completion_executor.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/recycling_allocator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class any_completion_handler_impl_base
-{
-public:
-  template <typename S>
-  explicit any_completion_handler_impl_base(S&& slot)
-    : cancel_state_(static_cast<S&&>(slot), enable_total_cancellation())
-  {
-  }
-
-  cancellation_slot get_cancellation_slot() const noexcept
-  {
-    return cancel_state_.slot();
-  }
-
-private:
-  cancellation_state cancel_state_;
-};
-
-template <typename Handler>
-class any_completion_handler_impl :
-  public any_completion_handler_impl_base
-{
-public:
-  template <typename S, typename H>
-  any_completion_handler_impl(S&& slot, H&& h)
-    : any_completion_handler_impl_base(static_cast<S&&>(slot)),
-      handler_(static_cast<H&&>(h))
-  {
-  }
-
-  struct uninit_deleter
-  {
-    typename std::allocator_traits<
-      associated_allocator_t<Handler,
-        asio::recycling_allocator<void>>>::template
-          rebind_alloc<any_completion_handler_impl> alloc;
-
-    void operator()(any_completion_handler_impl* ptr)
-    {
-      std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-    }
-  };
-
-  struct deleter
-  {
-    typename std::allocator_traits<
-      associated_allocator_t<Handler,
-        asio::recycling_allocator<void>>>::template
-          rebind_alloc<any_completion_handler_impl> alloc;
-
-    void operator()(any_completion_handler_impl* ptr)
-    {
-      std::allocator_traits<decltype(alloc)>::destroy(alloc, ptr);
-      std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-    }
-  };
-
-  template <typename S, typename H>
-  static any_completion_handler_impl* create(S&& slot, H&& h)
-  {
-    uninit_deleter d{
-        (get_associated_allocator)(h,
-          asio::recycling_allocator<void>())};
-
-    std::unique_ptr<any_completion_handler_impl, uninit_deleter> uninit_ptr(
-        std::allocator_traits<decltype(d.alloc)>::allocate(d.alloc, 1), d);
-
-    any_completion_handler_impl* ptr =
-      new (uninit_ptr.get()) any_completion_handler_impl(
-        static_cast<S&&>(slot), static_cast<H&&>(h));
-
-    uninit_ptr.release();
-    return ptr;
-  }
-
-  void destroy()
-  {
-    deleter d{
-        (get_associated_allocator)(handler_,
-          asio::recycling_allocator<void>())};
-
-    d(this);
-  }
-
-  any_completion_executor executor(
-      const any_completion_executor& candidate) const noexcept
-  {
-    return any_completion_executor(std::nothrow,
-        (get_associated_executor)(handler_, candidate));
-  }
-
-  any_completion_executor immediate_executor(
-      const any_io_executor& candidate) const noexcept
-  {
-    return any_completion_executor(std::nothrow,
-        (get_associated_immediate_executor)(handler_, candidate));
-  }
-
-  void* allocate(std::size_t size, std::size_t align) const
-  {
-    typename std::allocator_traits<
-      associated_allocator_t<Handler,
-        asio::recycling_allocator<void>>>::template
-          rebind_alloc<unsigned char> alloc(
-            (get_associated_allocator)(handler_,
-              asio::recycling_allocator<void>()));
-
-    std::size_t space = size + align - 1;
-    unsigned char* base =
-      std::allocator_traits<decltype(alloc)>::allocate(
-        alloc, space + sizeof(std::ptrdiff_t));
-
-    void* p = base;
-    if (detail::align(align, size, p, space))
-    {
-      std::ptrdiff_t off = static_cast<unsigned char*>(p) - base;
-      std::memcpy(static_cast<unsigned char*>(p) + size, &off, sizeof(off));
-      return p;
-    }
-
-    std::bad_alloc ex;
-    asio::detail::throw_exception(ex);
-    return nullptr;
-  }
-
-  void deallocate(void* p, std::size_t size, std::size_t align) const
-  {
-    if (p)
-    {
-      typename std::allocator_traits<
-        associated_allocator_t<Handler,
-          asio::recycling_allocator<void>>>::template
-            rebind_alloc<unsigned char> alloc(
-              (get_associated_allocator)(handler_,
-                asio::recycling_allocator<void>()));
-
-      std::ptrdiff_t off;
-      std::memcpy(&off, static_cast<unsigned char*>(p) + size, sizeof(off));
-      unsigned char* base = static_cast<unsigned char*>(p) - off;
-
-      std::allocator_traits<decltype(alloc)>::deallocate(
-          alloc, base, size + align -1 + sizeof(std::ptrdiff_t));
-    }
-  }
-
-  template <typename... Args>
-  void call(Args&&... args)
-  {
-    deleter d{
-        (get_associated_allocator)(handler_,
-          asio::recycling_allocator<void>())};
-
-    std::unique_ptr<any_completion_handler_impl, deleter> ptr(this, d);
-    Handler handler(static_cast<Handler&&>(handler_));
-    ptr.reset();
-
-    static_cast<Handler&&>(handler)(
-        static_cast<Args&&>(args)...);
-  }
-
-private:
-  Handler handler_;
-};
-
-template <typename Signature>
-class any_completion_handler_call_fn;
-
-template <typename R, typename... Args>
-class any_completion_handler_call_fn<R(Args...)>
-{
-public:
-  using type = void(*)(any_completion_handler_impl_base*, Args...);
-
-  constexpr any_completion_handler_call_fn(type fn)
-    : call_fn_(fn)
-  {
-  }
-
-  void call(any_completion_handler_impl_base* impl, Args... args) const
-  {
-    call_fn_(impl, static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler>
-  static void impl(any_completion_handler_impl_base* impl, Args... args)
-  {
-    static_cast<any_completion_handler_impl<Handler>*>(impl)->call(
-        static_cast<Args&&>(args)...);
-  }
-
-private:
-  type call_fn_;
-};
-
-template <typename... Signatures>
-class any_completion_handler_call_fns;
-
-template <typename Signature>
-class any_completion_handler_call_fns<Signature> :
-  public any_completion_handler_call_fn<Signature>
-{
-public:
-  using any_completion_handler_call_fn<
-    Signature>::any_completion_handler_call_fn;
-  using any_completion_handler_call_fn<Signature>::call;
-};
-
-template <typename Signature, typename... Signatures>
-class any_completion_handler_call_fns<Signature, Signatures...> :
-  public any_completion_handler_call_fn<Signature>,
-  public any_completion_handler_call_fns<Signatures...>
-{
-public:
-  template <typename CallFn, typename... CallFns>
-  constexpr any_completion_handler_call_fns(CallFn fn, CallFns... fns)
-    : any_completion_handler_call_fn<Signature>(fn),
-      any_completion_handler_call_fns<Signatures...>(fns...)
-  {
-  }
-
-  using any_completion_handler_call_fn<Signature>::call;
-  using any_completion_handler_call_fns<Signatures...>::call;
-};
-
-class any_completion_handler_destroy_fn
-{
-public:
-  using type = void(*)(any_completion_handler_impl_base*);
-
-  constexpr any_completion_handler_destroy_fn(type fn)
-    : destroy_fn_(fn)
-  {
-  }
-
-  void destroy(any_completion_handler_impl_base* impl) const
-  {
-    destroy_fn_(impl);
-  }
-
-  template <typename Handler>
-  static void impl(any_completion_handler_impl_base* impl)
-  {
-    static_cast<any_completion_handler_impl<Handler>*>(impl)->destroy();
-  }
-
-private:
-  type destroy_fn_;
-};
-
-class any_completion_handler_executor_fn
-{
-public:
-  using type = any_completion_executor(*)(
-      any_completion_handler_impl_base*, const any_completion_executor&);
-
-  constexpr any_completion_handler_executor_fn(type fn)
-    : executor_fn_(fn)
-  {
-  }
-
-  any_completion_executor executor(any_completion_handler_impl_base* impl,
-      const any_completion_executor& candidate) const
-  {
-    return executor_fn_(impl, candidate);
-  }
-
-  template <typename Handler>
-  static any_completion_executor impl(any_completion_handler_impl_base* impl,
-      const any_completion_executor& candidate)
-  {
-    return static_cast<any_completion_handler_impl<Handler>*>(impl)->executor(
-        candidate);
-  }
-
-private:
-  type executor_fn_;
-};
-
-class any_completion_handler_immediate_executor_fn
-{
-public:
-  using type = any_completion_executor(*)(
-      any_completion_handler_impl_base*, const any_io_executor&);
-
-  constexpr any_completion_handler_immediate_executor_fn(type fn)
-    : immediate_executor_fn_(fn)
-  {
-  }
-
-  any_completion_executor immediate_executor(
-      any_completion_handler_impl_base* impl,
-      const any_io_executor& candidate) const
-  {
-    return immediate_executor_fn_(impl, candidate);
-  }
-
-  template <typename Handler>
-  static any_completion_executor impl(any_completion_handler_impl_base* impl,
-      const any_io_executor& candidate)
-  {
-    return static_cast<any_completion_handler_impl<Handler>*>(
-        impl)->immediate_executor(candidate);
-  }
-
-private:
-  type immediate_executor_fn_;
-};
-
-class any_completion_handler_allocate_fn
-{
-public:
-  using type = void*(*)(any_completion_handler_impl_base*,
-      std::size_t, std::size_t);
-
-  constexpr any_completion_handler_allocate_fn(type fn)
-    : allocate_fn_(fn)
-  {
-  }
-
-  void* allocate(any_completion_handler_impl_base* impl,
-      std::size_t size, std::size_t align) const
-  {
-    return allocate_fn_(impl, size, align);
-  }
-
-  template <typename Handler>
-  static void* impl(any_completion_handler_impl_base* impl,
-      std::size_t size, std::size_t align)
-  {
-    return static_cast<any_completion_handler_impl<Handler>*>(impl)->allocate(
-        size, align);
-  }
-
-private:
-  type allocate_fn_;
-};
-
-class any_completion_handler_deallocate_fn
-{
-public:
-  using type = void(*)(any_completion_handler_impl_base*,
-      void*, std::size_t, std::size_t);
-
-  constexpr any_completion_handler_deallocate_fn(type fn)
-    : deallocate_fn_(fn)
-  {
-  }
-
-  void deallocate(any_completion_handler_impl_base* impl,
-      void* p, std::size_t size, std::size_t align) const
-  {
-    deallocate_fn_(impl, p, size, align);
-  }
-
-  template <typename Handler>
-  static void impl(any_completion_handler_impl_base* impl,
-      void* p, std::size_t size, std::size_t align)
-  {
-    static_cast<any_completion_handler_impl<Handler>*>(impl)->deallocate(
-        p, size, align);
-  }
-
-private:
-  type deallocate_fn_;
-};
-
-template <typename... Signatures>
-class any_completion_handler_fn_table
-  : private any_completion_handler_destroy_fn,
-    private any_completion_handler_executor_fn,
-    private any_completion_handler_immediate_executor_fn,
-    private any_completion_handler_allocate_fn,
-    private any_completion_handler_deallocate_fn,
-    private any_completion_handler_call_fns<Signatures...>
-{
-public:
-  template <typename... CallFns>
-  constexpr any_completion_handler_fn_table(
-      any_completion_handler_destroy_fn::type destroy_fn,
-      any_completion_handler_executor_fn::type executor_fn,
-      any_completion_handler_immediate_executor_fn::type immediate_executor_fn,
-      any_completion_handler_allocate_fn::type allocate_fn,
-      any_completion_handler_deallocate_fn::type deallocate_fn,
-      CallFns... call_fns)
-    : any_completion_handler_destroy_fn(destroy_fn),
-      any_completion_handler_executor_fn(executor_fn),
-      any_completion_handler_immediate_executor_fn(immediate_executor_fn),
-      any_completion_handler_allocate_fn(allocate_fn),
-      any_completion_handler_deallocate_fn(deallocate_fn),
-      any_completion_handler_call_fns<Signatures...>(call_fns...)
-  {
-  }
-
-  using any_completion_handler_destroy_fn::destroy;
-  using any_completion_handler_executor_fn::executor;
-  using any_completion_handler_immediate_executor_fn::immediate_executor;
-  using any_completion_handler_allocate_fn::allocate;
-  using any_completion_handler_deallocate_fn::deallocate;
-  using any_completion_handler_call_fns<Signatures...>::call;
-};
-
-template <typename Handler, typename... Signatures>
-struct any_completion_handler_fn_table_instance
-{
-  static constexpr any_completion_handler_fn_table<Signatures...>
-    value = any_completion_handler_fn_table<Signatures...>(
-        &any_completion_handler_destroy_fn::impl<Handler>,
-        &any_completion_handler_executor_fn::impl<Handler>,
-        &any_completion_handler_immediate_executor_fn::impl<Handler>,
-        &any_completion_handler_allocate_fn::impl<Handler>,
-        &any_completion_handler_deallocate_fn::impl<Handler>,
-        &any_completion_handler_call_fn<Signatures>::template impl<Handler>...);
-};
-
-template <typename Handler, typename... Signatures>
-constexpr any_completion_handler_fn_table<Signatures...>
-any_completion_handler_fn_table_instance<Handler, Signatures...>::value;
-
-} // namespace detail
-
-template <typename... Signatures>
-class any_completion_handler;
-
-/// An allocator type that forwards memory allocation operations through an
-/// instance of @c any_completion_handler.
-template <typename T, typename... Signatures>
-class any_completion_handler_allocator
-{
-private:
-  template <typename...>
-  friend class any_completion_handler;
-
-  template <typename, typename...>
-  friend class any_completion_handler_allocator;
-
-  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
-  detail::any_completion_handler_impl_base* impl_;
-
-  constexpr any_completion_handler_allocator(int,
-      const any_completion_handler<Signatures...>& h) noexcept
-    : fn_table_(h.fn_table_),
-      impl_(h.impl_)
-  {
-  }
-
-public:
-  /// The type of objects that may be allocated by the allocator.
-  typedef T value_type;
-
-  /// Rebinds an allocator to another value type.
-  template <typename U>
-  struct rebind
-  {
-    /// Specifies the type of the rebound allocator.
-    typedef any_completion_handler_allocator<U, Signatures...> other;
-  };
-
-  /// Construct from another @c any_completion_handler_allocator.
-  template <typename U>
-  constexpr any_completion_handler_allocator(
-      const any_completion_handler_allocator<U, Signatures...>& a)
-    noexcept
-    : fn_table_(a.fn_table_),
-      impl_(a.impl_)
-  {
-  }
-
-  /// Equality operator.
-  constexpr bool operator==(
-      const any_completion_handler_allocator& other) const noexcept
-  {
-    return fn_table_ == other.fn_table_ && impl_ == other.impl_;
-  }
-
-  /// Inequality operator.
-  constexpr bool operator!=(
-      const any_completion_handler_allocator& other) const noexcept
-  {
-    return fn_table_ != other.fn_table_ || impl_ != other.impl_;
-  }
-
-  /// Allocate space for @c n objects of the allocator's value type.
-  T* allocate(std::size_t n) const
-  {
-    if (fn_table_)
-    {
-      return static_cast<T*>(
-          fn_table_->allocate(
-            impl_, sizeof(T) * n, alignof(T)));
-    }
-    std::bad_alloc ex;
-    asio::detail::throw_exception(ex);
-    return nullptr;
-  }
-
-  /// Deallocate space for @c n objects of the allocator's value type.
-  void deallocate(T* p, std::size_t n) const
-  {
-    fn_table_->deallocate(impl_, p, sizeof(T) * n, alignof(T));
-  }
-};
-
-/// A protoco-allocator type that may be rebound to obtain an allocator that
-/// forwards memory allocation operations through an instance of
-/// @c any_completion_handler.
-template <typename... Signatures>
-class any_completion_handler_allocator<void, Signatures...>
-{
-private:
-  template <typename...>
-  friend class any_completion_handler;
-
-  template <typename, typename...>
-  friend class any_completion_handler_allocator;
-
-  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
-  detail::any_completion_handler_impl_base* impl_;
-
-  constexpr any_completion_handler_allocator(int,
-      const any_completion_handler<Signatures...>& h) noexcept
-    : fn_table_(h.fn_table_),
-      impl_(h.impl_)
-  {
-  }
-
-public:
-  /// @c void as no objects can be allocated through a proto-allocator.
-  typedef void value_type;
-
-  /// Rebinds an allocator to another value type.
-  template <typename U>
-  struct rebind
-  {
-    /// Specifies the type of the rebound allocator.
-    typedef any_completion_handler_allocator<U, Signatures...> other;
-  };
-
-  /// Construct from another @c any_completion_handler_allocator.
-  template <typename U>
-  constexpr any_completion_handler_allocator(
-      const any_completion_handler_allocator<U, Signatures...>& a)
-    noexcept
-    : fn_table_(a.fn_table_),
-      impl_(a.impl_)
-  {
-  }
-
-  /// Equality operator.
-  constexpr bool operator==(
-      const any_completion_handler_allocator& other) const noexcept
-  {
-    return fn_table_ == other.fn_table_ && impl_ == other.impl_;
-  }
-
-  /// Inequality operator.
-  constexpr bool operator!=(
-      const any_completion_handler_allocator& other) const noexcept
-  {
-    return fn_table_ != other.fn_table_ || impl_ != other.impl_;
-  }
-};
-
-/// Polymorphic wrapper for completion handlers.
-/**
- * The @c any_completion_handler class template is a polymorphic wrapper for
- * completion handlers that propagates the associated executor, associated
- * allocator, and associated cancellation slot through a type-erasing interface.
- *
- * When using @c any_completion_handler, specify one or more completion
- * signatures as template parameters. These will dictate the arguments that may
- * be passed to the handler through the polymorphic interface.
- *
- * Typical uses for @c any_completion_handler include:
- *
- * @li Separate compilation of asynchronous operation implementations.
- *
- * @li Enabling interoperability between asynchronous operations and virtual
- *     functions.
- */
-template <typename... Signatures>
-class any_completion_handler
-{
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  template <typename, typename...>
-  friend class any_completion_handler_allocator;
-
-  template <typename, typename>
-  friend struct associated_executor;
-
-  template <typename, typename>
-  friend struct associated_immediate_executor;
-
-  const detail::any_completion_handler_fn_table<Signatures...>* fn_table_;
-  detail::any_completion_handler_impl_base* impl_;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-public:
-  /// The associated allocator type.
-  using allocator_type = any_completion_handler_allocator<void, Signatures...>;
-
-  /// The associated cancellation slot type.
-  using cancellation_slot_type = cancellation_slot;
-
-  /// Construct an @c any_completion_handler in an empty state, without a target
-  /// object.
-  constexpr any_completion_handler()
-    : fn_table_(nullptr),
-      impl_(nullptr)
-  {
-  }
-
-  /// Construct an @c any_completion_handler in an empty state, without a target
-  /// object.
-  constexpr any_completion_handler(nullptr_t)
-    : fn_table_(nullptr),
-      impl_(nullptr)
-  {
-  }
-
-  /// Construct an @c any_completion_handler to contain the specified target.
-  template <typename H, typename Handler = decay_t<H>>
-  any_completion_handler(H&& h,
-      constraint_t<
-        !is_same<decay_t<H>, any_completion_handler>::value
-      > = 0)
-    : fn_table_(
-        &detail::any_completion_handler_fn_table_instance<
-          Handler, Signatures...>::value),
-      impl_(detail::any_completion_handler_impl<Handler>::create(
-            (get_associated_cancellation_slot)(h), static_cast<H&&>(h)))
-  {
-  }
-
-  /// Move-construct an @c any_completion_handler from another.
-  /**
-   * After the operation, the moved-from object @c other has no target.
-   */
-  any_completion_handler(any_completion_handler&& other) noexcept
-    : fn_table_(other.fn_table_),
-      impl_(other.impl_)
-  {
-    other.fn_table_ = nullptr;
-    other.impl_ = nullptr;
-  }
-
-  /// Move-assign an @c any_completion_handler from another.
-  /**
-   * After the operation, the moved-from object @c other has no target.
-   */
-  any_completion_handler& operator=(
-      any_completion_handler&& other) noexcept
-  {
-    any_completion_handler(
-        static_cast<any_completion_handler&&>(other)).swap(*this);
-    return *this;
-  }
-
-  /// Assignment operator that sets the polymorphic wrapper to the empty state.
-  any_completion_handler& operator=(nullptr_t) noexcept
-  {
-    any_completion_handler().swap(*this);
-    return *this;
-  }
-
-  /// Destructor.
-  ~any_completion_handler()
-  {
-    if (impl_)
-      fn_table_->destroy(impl_);
-  }
-
-  /// Test if the polymorphic wrapper is empty.
-  constexpr explicit operator bool() const noexcept
-  {
-    return impl_ != nullptr;
-  }
-
-  /// Test if the polymorphic wrapper is non-empty.
-  constexpr bool operator!() const noexcept
-  {
-    return impl_ == nullptr;
-  }
-
-  /// Swap the content of an @c any_completion_handler with another.
-  void swap(any_completion_handler& other) noexcept
-  {
-    std::swap(fn_table_, other.fn_table_);
-    std::swap(impl_, other.impl_);
-  }
-
-  /// Get the associated allocator.
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_type(0, *this);
-  }
-
-  /// Get the associated cancellation slot.
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return impl_ ? impl_->get_cancellation_slot() : cancellation_slot_type();
-  }
-
-  /// Function call operator.
-  /**
-   * Invokes target completion handler with the supplied arguments.
-   *
-   * This function may only be called once, as the target handler is moved from.
-   * The polymorphic wrapper is left in an empty state.
-   *
-   * Throws @c std::bad_function_call if the polymorphic wrapper is empty.
-   */
-  template <typename... Args>
-  auto operator()(Args&&... args)
-    -> decltype(fn_table_->call(impl_, static_cast<Args&&>(args)...))
-  {
-    if (detail::any_completion_handler_impl_base* impl = impl_)
-    {
-      impl_ = nullptr;
-      return fn_table_->call(impl, static_cast<Args&&>(args)...);
-    }
-    std::bad_function_call ex;
-    asio::detail::throw_exception(ex);
-  }
-
-  /// Equality operator.
-  friend constexpr bool operator==(
-      const any_completion_handler& a, nullptr_t) noexcept
-  {
-    return a.impl_ == nullptr;
-  }
-
-  /// Equality operator.
-  friend constexpr bool operator==(
-      nullptr_t, const any_completion_handler& b) noexcept
-  {
-    return nullptr == b.impl_;
-  }
-
-  /// Inequality operator.
-  friend constexpr bool operator!=(
-      const any_completion_handler& a, nullptr_t) noexcept
-  {
-    return a.impl_ != nullptr;
-  }
-
-  /// Inequality operator.
-  friend constexpr bool operator!=(
-      nullptr_t, const any_completion_handler& b) noexcept
-  {
-    return nullptr != b.impl_;
-  }
-};
-
-template <typename... Signatures, typename Candidate>
-struct associated_executor<any_completion_handler<Signatures...>, Candidate>
-{
-  using type = any_completion_executor;
-
-  static type get(const any_completion_handler<Signatures...>& handler,
-      const Candidate& candidate = Candidate()) noexcept
-  {
-    any_completion_executor any_candidate(std::nothrow, candidate);
-    return handler.fn_table_
-      ? handler.fn_table_->executor(handler.impl_, any_candidate)
-      : any_candidate;
-  }
-};
-
-template <typename... Signatures, typename Candidate>
-struct associated_immediate_executor<
-    any_completion_handler<Signatures...>, Candidate>
-{
-  using type = any_completion_executor;
-
-  static type get(const any_completion_handler<Signatures...>& handler,
-      const Candidate& candidate = Candidate()) noexcept
-  {
-    any_io_executor any_candidate(std::nothrow, candidate);
-    return handler.fn_table_
-      ? handler.fn_table_->immediate_executor(handler.impl_, any_candidate)
-      : any_candidate;
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ANY_COMPLETION_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_io_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_io_executor.hpp
deleted file mode 100644
index d35acf4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/any_io_executor.hpp
+++ /dev/null
@@ -1,351 +0,0 @@
-//
-// any_io_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ANY_IO_EXECUTOR_HPP
-#define ASIO_ANY_IO_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/executor.hpp"
-#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/execution.hpp"
-# include "asio/execution_context.hpp"
-#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-typedef executor any_io_executor;
-
-#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-/// Polymorphic executor type for use with I/O objects.
-/**
- * The @c any_io_executor type is a polymorphic executor that supports the set
- * of properties required by I/O objects. It is defined as the
- * execution::any_executor class template parameterised as follows:
- * @code execution::any_executor<
- *   execution::context_as_t<execution_context&>,
- *   execution::blocking_t::never_t,
- *   execution::prefer_only<execution::blocking_t::possibly_t>,
- *   execution::prefer_only<execution::outstanding_work_t::tracked_t>,
- *   execution::prefer_only<execution::outstanding_work_t::untracked_t>,
- *   execution::prefer_only<execution::relationship_t::fork_t>,
- *   execution::prefer_only<execution::relationship_t::continuation_t>
- * > @endcode
- */
-class any_io_executor :
-#if defined(GENERATING_DOCUMENTATION)
-  public execution::any_executor<...>
-#else // defined(GENERATING_DOCUMENTATION)
-  public execution::any_executor<
-      execution::context_as_t<execution_context&>,
-      execution::blocking_t::never_t,
-      execution::prefer_only<execution::blocking_t::possibly_t>,
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    >
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-public:
-#if !defined(GENERATING_DOCUMENTATION)
-  typedef execution::any_executor<
-      execution::context_as_t<execution_context&>,
-      execution::blocking_t::never_t,
-      execution::prefer_only<execution::blocking_t::possibly_t>,
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    > base_type;
-
-  typedef void supportable_properties_type(
-      execution::context_as_t<execution_context&>,
-      execution::blocking_t::never_t,
-      execution::prefer_only<execution::blocking_t::possibly_t>,
-      execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-      execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-      execution::prefer_only<execution::relationship_t::fork_t>,
-      execution::prefer_only<execution::relationship_t::continuation_t>
-    );
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Default constructor.
-  ASIO_DECL any_io_executor() noexcept;
-
-  /// Construct in an empty state. Equivalent effects to default constructor.
-  ASIO_DECL any_io_executor(nullptr_t) noexcept;
-
-  /// Copy constructor.
-  ASIO_DECL any_io_executor(const any_io_executor& e) noexcept;
-
-  /// Move constructor.
-  ASIO_DECL any_io_executor(any_io_executor&& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <class... OtherSupportableProperties>
-    any_io_executor(execution::any_executor<OtherSupportableProperties...> e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <typename OtherAnyExecutor>
-  any_io_executor(OtherAnyExecutor e,
-      constraint_t<
-        conditional_t<
-          !is_same<OtherAnyExecutor, any_io_executor>::value
-            && is_base_of<execution::detail::any_executor_base,
-              OtherAnyExecutor>::value,
-          typename execution::detail::supportable_properties<
-            0, supportable_properties_type>::template
-              is_valid_target<OtherAnyExecutor>,
-          false_type
-        >::value
-      > = 0)
-    : base_type(static_cast<OtherAnyExecutor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct to point to the same target as another any_executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <class... OtherSupportableProperties>
-    any_io_executor(std::nothrow_t,
-      execution::any_executor<OtherSupportableProperties...> e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <typename OtherAnyExecutor>
-  any_io_executor(std::nothrow_t, OtherAnyExecutor e,
-      constraint_t<
-        conditional_t<
-          !is_same<OtherAnyExecutor, any_io_executor>::value
-            && is_base_of<execution::detail::any_executor_base,
-              OtherAnyExecutor>::value,
-          typename execution::detail::supportable_properties<
-            0, supportable_properties_type>::template
-              is_valid_target<OtherAnyExecutor>,
-          false_type
-        >::value
-      > = 0) noexcept
-    : base_type(std::nothrow, static_cast<OtherAnyExecutor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct to point to the same target as another any_executor.
-  ASIO_DECL any_io_executor(std::nothrow_t,
-      const any_io_executor& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-  ASIO_DECL any_io_executor(std::nothrow_t, any_io_executor&& e) noexcept;
-
-  /// Construct a polymorphic wrapper for the specified executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_io_executor(Executor e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_io_executor(Executor e,
-      constraint_t<
-        conditional_t<
-          !is_same<Executor, any_io_executor>::value
-            && !is_base_of<execution::detail::any_executor_base,
-              Executor>::value,
-          execution::detail::is_valid_target_executor<
-            Executor, supportable_properties_type>,
-          false_type
-        >::value
-      > = 0)
-    : base_type(static_cast<Executor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct a polymorphic wrapper for the specified executor.
-#if defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_io_executor(std::nothrow_t, Executor e);
-#else // defined(GENERATING_DOCUMENTATION)
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_io_executor(std::nothrow_t, Executor e,
-      constraint_t<
-        conditional_t<
-          !is_same<Executor, any_io_executor>::value
-            && !is_base_of<execution::detail::any_executor_base,
-              Executor>::value,
-          execution::detail::is_valid_target_executor<
-            Executor, supportable_properties_type>,
-          false_type
-        >::value
-      > = 0) noexcept
-    : base_type(std::nothrow, static_cast<Executor&&>(e))
-  {
-  }
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Assignment operator.
-  ASIO_DECL any_io_executor& operator=(
-      const any_io_executor& e) noexcept;
-
-  /// Move assignment operator.
-  ASIO_DECL any_io_executor& operator=(any_io_executor&& e) noexcept;
-
-  /// Assignment operator that sets the polymorphic wrapper to the empty state.
-  ASIO_DECL any_io_executor& operator=(nullptr_t);
-
-  /// Destructor.
-  ASIO_DECL ~any_io_executor();
-
-  /// Swap targets with another polymorphic wrapper.
-  ASIO_DECL void swap(any_io_executor& other) noexcept;
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require and asio::prefer customisation points.
-   *
-   * For example:
-   * @code any_io_executor ex = ...;
-   * auto ex2 = asio::require(ex, execution::blocking.possibly); @endcode
-   */
-  template <typename Property>
-  any_io_executor require(const Property& p,
-      constraint_t<
-        traits::require_member<const base_type&, const Property&>::is_valid
-      > = 0) const
-  {
-    return static_cast<const base_type&>(*this).require(p);
-  }
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::prefer customisation point.
-   *
-   * For example:
-   * @code any_io_executor ex = ...;
-   * auto ex2 = asio::prefer(ex, execution::blocking.possibly); @endcode
-   */
-  template <typename Property>
-  any_io_executor prefer(const Property& p,
-      constraint_t<
-        traits::prefer_member<const base_type&, const Property&>::is_valid
-      > = 0) const
-  {
-    return static_cast<const base_type&>(*this).prefer(p);
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::require(
-    const execution::blocking_t::never_t&, int) const;
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::prefer(
-    const execution::blocking_t::possibly_t&, int) const;
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::prefer(
-    const execution::outstanding_work_t::tracked_t&, int) const;
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::prefer(
-    const execution::outstanding_work_t::untracked_t&, int) const;
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::prefer(
-    const execution::relationship_t::fork_t&, int) const;
-
-template <>
-ASIO_DECL any_io_executor any_io_executor::prefer(
-    const execution::relationship_t::continuation_t&, int) const;
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<any_io_executor>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<any_io_executor, F>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Prop>
-struct query_member<any_io_executor, Prop> :
-  query_member<any_io_executor::base_type, Prop>
-{
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Prop>
-struct require_member<any_io_executor, Prop> :
-  require_member<any_io_executor::base_type, Prop>
-{
-  typedef any_io_executor result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename Prop>
-struct prefer_member<any_io_executor, Prop> :
-  prefer_member<any_io_executor::base_type, Prop>
-{
-  typedef any_io_executor result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY) \
-  && !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-# include "asio/impl/any_io_executor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-       //   && !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#endif // ASIO_ANY_IO_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/append.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/append.hpp
deleted file mode 100644
index 0460892..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/append.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// append.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_APPEND_HPP
-#define ASIO_APPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values after the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-class append_t
-{
-public:
-  /// Constructor.
-  template <typename T, typename... V>
-  constexpr explicit append_t(T&& completion_token, V&&... values)
-    : token_(static_cast<T&&>(completion_token)),
-      values_(static_cast<V&&>(values)...)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  std::tuple<Values...> values_;
-};
-
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values after the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-ASIO_NODISCARD inline constexpr
-append_t<decay_t<CompletionToken>, decay_t<Values>...>
-append(CompletionToken&& completion_token, Values&&... values)
-{
-  return append_t<decay_t<CompletionToken>, decay_t<Values>...>(
-      static_cast<CompletionToken&&>(completion_token),
-      static_cast<Values&&>(values)...);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/append.hpp"
-
-#endif // ASIO_APPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/as_tuple.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/as_tuple.hpp
deleted file mode 100644
index 0104288..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/as_tuple.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// as_tuple.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_AS_TUPLE_HPP
-#define ASIO_AS_TUPLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token adapter used to specify that the completion handler
-/// arguments should be combined into a single tuple argument.
-/**
- * The as_tuple_t class is used to indicate that any arguments to the
- * completion handler should be combined and passed as a single tuple argument.
- * The arguments are first moved into a @c std::tuple and that tuple is then
- * passed to the completion handler.
- */
-template <typename CompletionToken>
-class as_tuple_t
-{
-public:
-  /// Tag type used to prevent the "default" constructor from being used for
-  /// conversions.
-  struct default_constructor_tag {};
-
-  /// Default constructor.
-  /**
-   * This constructor is only valid if the underlying completion token is
-   * default constructible and move constructible. The underlying completion
-   * token is itself defaulted as an argument to allow it to capture a source
-   * location.
-   */
-  constexpr as_tuple_t(
-      default_constructor_tag = default_constructor_tag(),
-      CompletionToken token = CompletionToken())
-    : token_(static_cast<CompletionToken&&>(token))
-  {
-  }
-
-  /// Constructor.
-  template <typename T>
-  constexpr explicit as_tuple_t(
-      T&& completion_token)
-    : token_(static_cast<T&&>(completion_token))
-  {
-  }
-
-  /// Adapts an executor to add the @c as_tuple_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c as_tuple_t as the default completion token type.
-    typedef as_tuple_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    template <typename InnerExecutor1>
-    executor_with_default(const InnerExecutor1& ex,
-        constraint_t<
-          conditional_t<
-            !is_same<InnerExecutor1, executor_with_default>::value,
-            is_convertible<InnerExecutor1, InnerExecutor>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c as_tuple_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c as_tuple_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-//private:
-  CompletionToken token_;
-};
-
-/// A function object type that adapts a @ref completion_token to specify that
-/// the completion handler arguments should be combined into a single tuple
-/// argument.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-struct partial_as_tuple
-{
-  /// Default constructor.
-  constexpr partial_as_tuple()
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// arguments should be combined into a single tuple argument.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr as_tuple_t<decay_t<CompletionToken>>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return as_tuple_t<decay_t<CompletionToken>>(
-        static_cast<CompletionToken&&>(completion_token));
-  }
-};
-
-/// A function object that adapts a @ref completion_token to specify that the
-/// completion handler arguments should be combined into a single tuple
-/// argument.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-constexpr partial_as_tuple as_tuple;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/as_tuple.hpp"
-
-#endif // ASIO_AS_TUPLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_allocator.hpp
deleted file mode 100644
index f21ea25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_allocator.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-//
-// associated_allocator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASSOCIATED_ALLOCATOR_HPP
-#define ASIO_ASSOCIATED_ALLOCATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <memory>
-#include "asio/associator.hpp"
-#include "asio/detail/functional.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename T, typename Allocator>
-struct associated_allocator;
-
-namespace detail {
-
-template <typename T, typename = void>
-struct has_allocator_type : false_type
-{
-};
-
-template <typename T>
-struct has_allocator_type<T, void_t<typename T::allocator_type>> : true_type
-{
-};
-
-template <typename T, typename A, typename = void, typename = void>
-struct associated_allocator_impl
-{
-  typedef void asio_associated_allocator_is_unspecialised;
-
-  typedef A type;
-
-  static type get(const T&) noexcept
-  {
-    return type();
-  }
-
-  static const type& get(const T&, const A& a) noexcept
-  {
-    return a;
-  }
-};
-
-template <typename T, typename A>
-struct associated_allocator_impl<T, A, void_t<typename T::allocator_type>>
-{
-  typedef typename T::allocator_type type;
-
-  static auto get(const T& t) noexcept
-    -> decltype(t.get_allocator())
-  {
-    return t.get_allocator();
-  }
-
-  static auto get(const T& t, const A&) noexcept
-    -> decltype(t.get_allocator())
-  {
-    return t.get_allocator();
-  }
-};
-
-template <typename T, typename A>
-struct associated_allocator_impl<T, A,
-  enable_if_t<
-    !has_allocator_type<T>::value
-  >,
-  void_t<
-    typename associator<associated_allocator, T, A>::type
-  >> : associator<associated_allocator, T, A>
-{
-};
-
-} // namespace detail
-
-/// Traits type used to obtain the allocator associated with an object.
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type. The template parameter @c
- * Allocator shall be a type meeting the Allocator requirements.
- *
- * Specialisations shall meet the following requirements, where @c t is a const
- * reference to an object of type @c T, and @c a is an object of type @c
- * Allocator.
- *
- * @li Provide a nested typedef @c type that identifies a type meeting the
- * Allocator requirements.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type or a (possibly const) reference to @c
- * type.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,a) and with return type @c type or a (possibly const) reference to @c
- * type.
- */
-template <typename T, typename Allocator = std::allocator<void>>
-struct associated_allocator
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_allocator_impl<T, Allocator>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// If @c T has a nested type @c allocator_type, <tt>T::allocator_type</tt>.
-  /// Otherwise @c Allocator.
-  typedef see_below type;
-
-  /// If @c T has a nested type @c allocator_type, returns
-  /// <tt>t.get_allocator()</tt>. Otherwise returns @c type().
-  static decltype(auto) get(const T& t) noexcept;
-
-  /// If @c T has a nested type @c allocator_type, returns
-  /// <tt>t.get_allocator()</tt>. Otherwise returns @c a.
-  static decltype(auto) get(const T& t, const Allocator& a) noexcept;
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-/// Helper function to obtain an object's associated allocator.
-/**
- * @returns <tt>associated_allocator<T>::get(t)</tt>
- */
-template <typename T>
-ASIO_NODISCARD inline typename associated_allocator<T>::type
-get_associated_allocator(const T& t) noexcept
-{
-  return associated_allocator<T>::get(t);
-}
-
-/// Helper function to obtain an object's associated allocator.
-/**
- * @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
- */
-template <typename T, typename Allocator>
-ASIO_NODISCARD inline auto get_associated_allocator(
-    const T& t, const Allocator& a) noexcept
-  -> decltype(associated_allocator<T, Allocator>::get(t, a))
-{
-  return associated_allocator<T, Allocator>::get(t, a);
-}
-
-template <typename T, typename Allocator = std::allocator<void>>
-using associated_allocator_t
-  = typename associated_allocator<T, Allocator>::type;
-
-namespace detail {
-
-template <typename T, typename A, typename = void>
-struct associated_allocator_forwarding_base
-{
-};
-
-template <typename T, typename A>
-struct associated_allocator_forwarding_base<T, A,
-    enable_if_t<
-      is_same<
-        typename associated_allocator<T,
-          A>::asio_associated_allocator_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  typedef void asio_associated_allocator_is_unspecialised;
-};
-
-} // namespace detail
-
-/// Specialisation of associated_allocator for @c std::reference_wrapper.
-template <typename T, typename Allocator>
-struct associated_allocator<reference_wrapper<T>, Allocator>
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_allocator_forwarding_base<T, Allocator>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-  /// Forwards @c type to the associator specialisation for the unwrapped type
-  /// @c T.
-  typedef typename associated_allocator<T, Allocator>::type type;
-
-  /// Forwards the request to get the allocator to the associator specialisation
-  /// for the unwrapped type @c T.
-  static type get(reference_wrapper<T> t) noexcept
-  {
-    return associated_allocator<T, Allocator>::get(t.get());
-  }
-
-  /// Forwards the request to get the allocator to the associator specialisation
-  /// for the unwrapped type @c T.
-  static auto get(reference_wrapper<T> t, const Allocator& a) noexcept
-    -> decltype(associated_allocator<T, Allocator>::get(t.get(), a))
-  {
-    return associated_allocator<T, Allocator>::get(t.get(), a);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ASSOCIATED_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_cancellation_slot.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_cancellation_slot.hpp
deleted file mode 100644
index 518bd88..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_cancellation_slot.hpp
+++ /dev/null
@@ -1,221 +0,0 @@
-//
-// associated_cancellation_slot.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
-#define ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/functional.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename T, typename CancellationSlot>
-struct associated_cancellation_slot;
-
-namespace detail {
-
-template <typename T, typename = void>
-struct has_cancellation_slot_type : false_type
-{
-};
-
-template <typename T>
-struct has_cancellation_slot_type<T, void_t<typename T::cancellation_slot_type>>
-  : true_type
-{
-};
-
-template <typename T, typename S, typename = void, typename = void>
-struct associated_cancellation_slot_impl
-{
-  typedef void asio_associated_cancellation_slot_is_unspecialised;
-
-  typedef S type;
-
-  static type get(const T&) noexcept
-  {
-    return type();
-  }
-
-  static const type& get(const T&, const S& s) noexcept
-  {
-    return s;
-  }
-};
-
-template <typename T, typename S>
-struct associated_cancellation_slot_impl<T, S,
-  void_t<typename T::cancellation_slot_type>>
-{
-  typedef typename T::cancellation_slot_type type;
-
-  static auto get(const T& t) noexcept
-    -> decltype(t.get_cancellation_slot())
-  {
-    return t.get_cancellation_slot();
-  }
-
-  static auto get(const T& t, const S&) noexcept
-    -> decltype(t.get_cancellation_slot())
-  {
-    return t.get_cancellation_slot();
-  }
-};
-
-template <typename T, typename S>
-struct associated_cancellation_slot_impl<T, S,
-  enable_if_t<
-    !has_cancellation_slot_type<T>::value
-  >,
-  void_t<
-    typename associator<associated_cancellation_slot, T, S>::type
-  >> : associator<associated_cancellation_slot, T, S>
-{
-};
-
-} // namespace detail
-
-/// Traits type used to obtain the cancellation_slot associated with an object.
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type. The template parameter @c
- * CancellationSlot shall be a type meeting the CancellationSlot requirements.
- *
- * Specialisations shall meet the following requirements, where @c t is a const
- * reference to an object of type @c T, and @c s is an object of type @c
- * CancellationSlot.
- *
- * @li Provide a nested typedef @c type that identifies a type meeting the
- * CancellationSlot requirements.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type or a (possibly const) reference to @c
- * type.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,s) and with return type @c type or a (possibly const) reference to @c
- * type.
- */
-template <typename T, typename CancellationSlot = cancellation_slot>
-struct associated_cancellation_slot
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_cancellation_slot_impl<T, CancellationSlot>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// If @c T has a nested type @c cancellation_slot_type,
-  /// <tt>T::cancellation_slot_type</tt>. Otherwise
-  /// @c CancellationSlot.
-  typedef see_below type;
-
-  /// If @c T has a nested type @c cancellation_slot_type, returns
-  /// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c type().
-  static decltype(auto) get(const T& t) noexcept;
-
-  /// If @c T has a nested type @c cancellation_slot_type, returns
-  /// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c s.
-  static decltype(auto) get(const T& t,
-      const CancellationSlot& s) noexcept;
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-/// Helper function to obtain an object's associated cancellation_slot.
-/**
- * @returns <tt>associated_cancellation_slot<T>::get(t)</tt>
- */
-template <typename T>
-ASIO_NODISCARD inline typename associated_cancellation_slot<T>::type
-get_associated_cancellation_slot(const T& t) noexcept
-{
-  return associated_cancellation_slot<T>::get(t);
-}
-
-/// Helper function to obtain an object's associated cancellation_slot.
-/**
- * @returns <tt>associated_cancellation_slot<T,
- * CancellationSlot>::get(t, st)</tt>
- */
-template <typename T, typename CancellationSlot>
-ASIO_NODISCARD inline auto get_associated_cancellation_slot(
-    const T& t, const CancellationSlot& st) noexcept
-  -> decltype(associated_cancellation_slot<T, CancellationSlot>::get(t, st))
-{
-  return associated_cancellation_slot<T, CancellationSlot>::get(t, st);
-}
-
-template <typename T, typename CancellationSlot = cancellation_slot>
-using associated_cancellation_slot_t =
-  typename associated_cancellation_slot<T, CancellationSlot>::type;
-
-namespace detail {
-
-template <typename T, typename S, typename = void>
-struct associated_cancellation_slot_forwarding_base
-{
-};
-
-template <typename T, typename S>
-struct associated_cancellation_slot_forwarding_base<T, S,
-    enable_if_t<
-      is_same<
-        typename associated_cancellation_slot<T,
-          S>::asio_associated_cancellation_slot_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  typedef void asio_associated_cancellation_slot_is_unspecialised;
-};
-
-} // namespace detail
-
-/// Specialisation of associated_cancellation_slot for @c
-/// std::reference_wrapper.
-template <typename T, typename CancellationSlot>
-struct associated_cancellation_slot<reference_wrapper<T>, CancellationSlot>
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_cancellation_slot_forwarding_base<T, CancellationSlot>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-  /// Forwards @c type to the associator specialisation for the unwrapped type
-  /// @c T.
-  typedef typename associated_cancellation_slot<T, CancellationSlot>::type type;
-
-  /// Forwards the request to get the cancellation slot to the associator
-  /// specialisation for the unwrapped type @c T.
-  static type get(reference_wrapper<T> t) noexcept
-  {
-    return associated_cancellation_slot<T, CancellationSlot>::get(t.get());
-  }
-
-  /// Forwards the request to get the cancellation slot to the associator
-  /// specialisation for the unwrapped type @c T.
-  static auto get(reference_wrapper<T> t, const CancellationSlot& s) noexcept
-    -> decltype(
-      associated_cancellation_slot<T, CancellationSlot>::get(t.get(), s))
-  {
-    return associated_cancellation_slot<T, CancellationSlot>::get(t.get(), s);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_executor.hpp
deleted file mode 100644
index 4ca7ba1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_executor.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-//
-// associated_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASSOCIATED_EXECUTOR_HPP
-#define ASIO_ASSOCIATED_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/detail/functional.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/system_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename T, typename Executor>
-struct associated_executor;
-
-namespace detail {
-
-template <typename T, typename = void>
-struct has_executor_type : false_type
-{
-};
-
-template <typename T>
-struct has_executor_type<T, void_t<typename T::executor_type>>
-    : true_type
-{
-};
-
-template <typename T, typename E, typename = void, typename = void>
-struct associated_executor_impl
-{
-  typedef void asio_associated_executor_is_unspecialised;
-
-  typedef E type;
-
-  static type get(const T&) noexcept
-  {
-    return type();
-  }
-
-  static const type& get(const T&, const E& e) noexcept
-  {
-    return e;
-  }
-};
-
-template <typename T, typename E>
-struct associated_executor_impl<T, E, void_t<typename T::executor_type>>
-{
-  typedef typename T::executor_type type;
-
-  static auto get(const T& t) noexcept
-    -> decltype(t.get_executor())
-  {
-    return t.get_executor();
-  }
-
-  static auto get(const T& t, const E&) noexcept
-    -> decltype(t.get_executor())
-  {
-    return t.get_executor();
-  }
-};
-
-template <typename T, typename E>
-struct associated_executor_impl<T, E,
-  enable_if_t<
-    !has_executor_type<T>::value
-  >,
-  void_t<
-    typename associator<associated_executor, T, E>::type
-  >> : associator<associated_executor, T, E>
-{
-};
-
-} // namespace detail
-
-/// Traits type used to obtain the executor associated with an object.
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type. The template parameter @c
- * Executor shall be a type meeting the Executor requirements.
- *
- * Specialisations shall meet the following requirements, where @c t is a const
- * reference to an object of type @c T, and @c e is an object of type @c
- * Executor.
- *
- * @li Provide a nested typedef @c type that identifies a type meeting the
- * Executor requirements.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type or a (possibly const) reference to @c
- * type.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,e) and with return type @c type or a (possibly const) reference to @c
- * type.
- */
-template <typename T, typename Executor = system_executor>
-struct associated_executor
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_executor_impl<T, Executor>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// If @c T has a nested type @c executor_type, <tt>T::executor_type</tt>.
-  /// Otherwise @c Executor.
-  typedef see_below type;
-
-  /// If @c T has a nested type @c executor_type, returns
-  /// <tt>t.get_executor()</tt>. Otherwise returns @c type().
-  static decltype(auto) get(const T& t) noexcept;
-
-  /// If @c T has a nested type @c executor_type, returns
-  /// <tt>t.get_executor()</tt>. Otherwise returns @c ex.
-  static decltype(auto) get(const T& t, const Executor& ex) noexcept;
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-/// Helper function to obtain an object's associated executor.
-/**
- * @returns <tt>associated_executor<T>::get(t)</tt>
- */
-template <typename T>
-ASIO_NODISCARD inline typename associated_executor<T>::type
-get_associated_executor(const T& t) noexcept
-{
-  return associated_executor<T>::get(t);
-}
-
-/// Helper function to obtain an object's associated executor.
-/**
- * @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
- */
-template <typename T, typename Executor>
-ASIO_NODISCARD inline auto get_associated_executor(
-    const T& t, const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0) noexcept
-  -> decltype(associated_executor<T, Executor>::get(t, ex))
-{
-  return associated_executor<T, Executor>::get(t, ex);
-}
-
-/// Helper function to obtain an object's associated executor.
-/**
- * @returns <tt>associated_executor<T, typename
- * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
- */
-template <typename T, typename ExecutionContext>
-ASIO_NODISCARD inline typename associated_executor<T,
-    typename ExecutionContext::executor_type>::type
-get_associated_executor(const T& t, ExecutionContext& ctx,
-    constraint_t<is_convertible<ExecutionContext&,
-      execution_context&>::value> = 0) noexcept
-{
-  return associated_executor<T,
-    typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
-}
-
-template <typename T, typename Executor = system_executor>
-using associated_executor_t = typename associated_executor<T, Executor>::type;
-
-namespace detail {
-
-template <typename T, typename E, typename = void>
-struct associated_executor_forwarding_base
-{
-};
-
-template <typename T, typename E>
-struct associated_executor_forwarding_base<T, E,
-    enable_if_t<
-      is_same<
-        typename associated_executor<T,
-          E>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  typedef void asio_associated_executor_is_unspecialised;
-};
-
-} // namespace detail
-
-/// Specialisation of associated_executor for @c std::reference_wrapper.
-template <typename T, typename Executor>
-struct associated_executor<reference_wrapper<T>, Executor>
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_executor_forwarding_base<T, Executor>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-  /// Forwards @c type to the associator specialisation for the unwrapped type
-  /// @c T.
-  typedef typename associated_executor<T, Executor>::type type;
-
-  /// Forwards the request to get the executor to the associator specialisation
-  /// for the unwrapped type @c T.
-  static type get(reference_wrapper<T> t) noexcept
-  {
-    return associated_executor<T, Executor>::get(t.get());
-  }
-
-  /// Forwards the request to get the executor to the associator specialisation
-  /// for the unwrapped type @c T.
-  static auto get(reference_wrapper<T> t, const Executor& ex) noexcept
-    -> decltype(associated_executor<T, Executor>::get(t.get(), ex))
-  {
-    return associated_executor<T, Executor>::get(t.get(), ex);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ASSOCIATED_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_immediate_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_immediate_executor.hpp
deleted file mode 100644
index f189f1c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associated_immediate_executor.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-//
-// associated_immediate_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP
-#define ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/detail/functional.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename T, typename Executor>
-struct associated_immediate_executor;
-
-namespace detail {
-
-template <typename T, typename = void>
-struct has_immediate_executor_type : false_type
-{
-};
-
-template <typename T>
-struct has_immediate_executor_type<T,
-  void_t<typename T::immediate_executor_type>>
-    : true_type
-{
-};
-
-template <typename E, typename = void, typename = void>
-struct default_immediate_executor
-{
-  typedef decay_t<require_result_t<E, execution::blocking_t::never_t>> type;
-
-  static auto get(const E& e) noexcept
-    -> decltype(asio::require(e, execution::blocking.never))
-  {
-    return asio::require(e, execution::blocking.never);
-  }
-};
-
-template <typename E>
-struct default_immediate_executor<E,
-  enable_if_t<
-    !execution::is_executor<E>::value
-  >,
-  enable_if_t<
-    is_executor<E>::value
-  >>
-{
-  class type : public E
-  {
-  public:
-    template <typename Executor1>
-    explicit type(const Executor1& e,
-        constraint_t<
-          conditional_t<
-            !is_same<Executor1, type>::value,
-            is_convertible<Executor1, E>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : E(e)
-    {
-    }
-
-    type(const type& other) noexcept
-      : E(static_cast<const E&>(other))
-    {
-    }
-
-    type(type&& other) noexcept
-      : E(static_cast<E&&>(other))
-    {
-    }
-
-    template <typename Function, typename Allocator>
-    void dispatch(Function&& f, const Allocator& a) const
-    {
-      this->post(static_cast<Function&&>(f), a);
-    }
-
-    friend bool operator==(const type& a, const type& b) noexcept
-    {
-      return static_cast<const E&>(a) == static_cast<const E&>(b);
-    }
-
-    friend bool operator!=(const type& a, const type& b) noexcept
-    {
-      return static_cast<const E&>(a) != static_cast<const E&>(b);
-    }
-  };
-
-  static type get(const E& e) noexcept
-  {
-    return type(e);
-  }
-};
-
-template <typename T, typename E, typename = void, typename = void>
-struct associated_immediate_executor_impl
-{
-  typedef void asio_associated_immediate_executor_is_unspecialised;
-
-  typedef typename default_immediate_executor<E>::type type;
-
-  static auto get(const T&, const E& e) noexcept
-    -> decltype(default_immediate_executor<E>::get(e))
-  {
-    return default_immediate_executor<E>::get(e);
-  }
-};
-
-template <typename T, typename E>
-struct associated_immediate_executor_impl<T, E,
-  void_t<typename T::immediate_executor_type>>
-{
-  typedef typename T::immediate_executor_type type;
-
-  static auto get(const T& t, const E&) noexcept
-    -> decltype(t.get_immediate_executor())
-  {
-    return t.get_immediate_executor();
-  }
-};
-
-template <typename T, typename E>
-struct associated_immediate_executor_impl<T, E,
-  enable_if_t<
-    !has_immediate_executor_type<T>::value
-  >,
-  void_t<
-    typename associator<associated_immediate_executor, T, E>::type
-  >> : associator<associated_immediate_executor, T, E>
-{
-};
-
-} // namespace detail
-
-/// Traits type used to obtain the immediate executor associated with an object.
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type. The template parameter @c
- * Executor shall be a type meeting the Executor requirements.
- *
- * Specialisations shall meet the following requirements, where @c t is a const
- * reference to an object of type @c T, and @c e is an object of type @c
- * Executor.
- *
- * @li Provide a nested typedef @c type that identifies a type meeting the
- * Executor requirements.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t) and with return type @c type or a (possibly const) reference to @c
- * type.
- *
- * @li Provide a noexcept static member function named @c get, callable as @c
- * get(t,e) and with return type @c type or a (possibly const) reference to @c
- * type.
- */
-template <typename T, typename Executor>
-struct associated_immediate_executor
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_immediate_executor_impl<T, Executor>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// If @c T has a nested type @c immediate_executor_type,
-  // <tt>T::immediate_executor_type</tt>. Otherwise @c Executor.
-  typedef see_below type;
-
-  /// If @c T has a nested type @c immediate_executor_type, returns
-  /// <tt>t.get_immediate_executor()</tt>. Otherwise returns
-  /// <tt>asio::require(ex, asio::execution::blocking.never)</tt>.
-  static decltype(auto) get(const T& t, const Executor& ex) noexcept;
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-/// Helper function to obtain an object's associated executor.
-/**
- * @returns <tt>associated_immediate_executor<T, Executor>::get(t, ex)</tt>
- */
-template <typename T, typename Executor>
-ASIO_NODISCARD inline auto get_associated_immediate_executor(
-    const T& t, const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0) noexcept
-  -> decltype(associated_immediate_executor<T, Executor>::get(t, ex))
-{
-  return associated_immediate_executor<T, Executor>::get(t, ex);
-}
-
-/// Helper function to obtain an object's associated executor.
-/**
- * @returns <tt>associated_immediate_executor<T, typename
- * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
- */
-template <typename T, typename ExecutionContext>
-ASIO_NODISCARD inline typename associated_immediate_executor<T,
-    typename ExecutionContext::executor_type>::type
-get_associated_immediate_executor(const T& t, ExecutionContext& ctx,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0) noexcept
-{
-  return associated_immediate_executor<T,
-    typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
-}
-
-template <typename T, typename Executor>
-using associated_immediate_executor_t =
-  typename associated_immediate_executor<T, Executor>::type;
-
-namespace detail {
-
-template <typename T, typename E, typename = void>
-struct associated_immediate_executor_forwarding_base
-{
-};
-
-template <typename T, typename E>
-struct associated_immediate_executor_forwarding_base<T, E,
-    enable_if_t<
-      is_same<
-        typename associated_immediate_executor<T,
-          E>::asio_associated_immediate_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  typedef void asio_associated_immediate_executor_is_unspecialised;
-};
-
-} // namespace detail
-
-/// Specialisation of associated_immediate_executor for
-/// @c std::reference_wrapper.
-template <typename T, typename Executor>
-struct associated_immediate_executor<reference_wrapper<T>, Executor>
-#if !defined(GENERATING_DOCUMENTATION)
-  : detail::associated_immediate_executor_forwarding_base<T, Executor>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-  /// Forwards @c type to the associator specialisation for the unwrapped type
-  /// @c T.
-  typedef typename associated_immediate_executor<T, Executor>::type type;
-
-  /// Forwards the request to get the executor to the associator specialisation
-  /// for the unwrapped type @c T.
-  static auto get(reference_wrapper<T> t, const Executor& ex) noexcept
-    -> decltype(associated_immediate_executor<T, Executor>::get(t.get(), ex))
-  {
-    return associated_immediate_executor<T, Executor>::get(t.get(), ex);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ASSOCIATED_IMMEDIATE_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associator.hpp
deleted file mode 100644
index fbc9769..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/associator.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// associator.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASSOCIATOR_HPP
-#define ASIO_ASSOCIATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Used to generically specialise associators for a type.
-template <template <typename, typename> class Associator,
-    typename T, typename DefaultCandidate, typename _ = void>
-struct associator
-{
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_ASSOCIATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/async_result.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/async_result.hpp
deleted file mode 100644
index 5be1a9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/async_result.hpp
+++ /dev/null
@@ -1,948 +0,0 @@
-//
-// async_result.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ASYNC_RESULT_HPP
-#define ASIO_ASYNC_RESULT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct is_completion_signature : false_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...)> : true_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...) &> : true_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...) &&> : true_type
-{
-};
-
-# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...) noexcept> : true_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...) & noexcept> : true_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_completion_signature<R(Args...) && noexcept> : true_type
-{
-};
-
-# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename... T>
-struct are_completion_signatures : false_type
-{
-};
-
-template <>
-struct are_completion_signatures<>
-  : true_type
-{
-};
-
-template <typename T0>
-struct are_completion_signatures<T0>
-  : is_completion_signature<T0>
-{
-};
-
-template <typename T0, typename... TN>
-struct are_completion_signatures<T0, TN...>
-  : integral_constant<bool, (
-      is_completion_signature<T0>::value
-        && are_completion_signatures<TN...>::value)>
-{
-};
-
-} // namespace detail
-
-#if defined(ASIO_HAS_CONCEPTS)
-
-namespace detail {
-
-template <typename T, typename... Args>
-ASIO_CONCEPT callable_with = requires(T&& t, Args&&... args)
-{
-  static_cast<T&&>(t)(static_cast<Args&&>(args)...);
-};
-
-template <typename T, typename... Signatures>
-struct is_completion_handler_for : false_type
-{
-};
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...)>
-  : integral_constant<bool, (callable_with<decay_t<T>, Args...>)>
-{
-};
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...) &>
-  : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
-{
-};
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...) &&>
-  : integral_constant<bool, (callable_with<decay_t<T>&&, Args...>)>
-{
-};
-
-# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...) noexcept>
-  : integral_constant<bool, (callable_with<decay_t<T>, Args...>)>
-{
-};
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...) & noexcept>
-  : integral_constant<bool, (callable_with<decay_t<T>&, Args...>)>
-{
-};
-
-template <typename T, typename R, typename... Args>
-struct is_completion_handler_for<T, R(Args...) && noexcept>
-  : integral_constant<bool, (callable_with<decay_t<T>&&, Args...>)>
-{
-};
-
-# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename T, typename Signature0, typename... SignatureN>
-struct is_completion_handler_for<T, Signature0, SignatureN...>
-  : integral_constant<bool, (
-      is_completion_handler_for<T, Signature0>::value
-        && is_completion_handler_for<T, SignatureN...>::value)>
-{
-};
-
-} // namespace detail
-
-template <typename T>
-ASIO_CONCEPT completion_signature =
-  detail::is_completion_signature<T>::value;
-
-#define ASIO_COMPLETION_SIGNATURE \
-  ::asio::completion_signature
-
-template <typename T, typename... Signatures>
-ASIO_CONCEPT completion_handler_for =
-  detail::are_completion_signatures<Signatures...>::value
-    && detail::is_completion_handler_for<T, Signatures...>::value;
-
-#define ASIO_COMPLETION_HANDLER_FOR(sig) \
-  ::asio::completion_handler_for<sig>
-#define ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) \
-  ::asio::completion_handler_for<sig0, sig1>
-#define ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) \
-  ::asio::completion_handler_for<sig0, sig1, sig2>
-
-#else // defined(ASIO_HAS_CONCEPTS)
-
-#define ASIO_COMPLETION_SIGNATURE typename
-#define ASIO_COMPLETION_HANDLER_FOR(sig) typename
-#define ASIO_COMPLETION_HANDLER_FOR2(sig0, sig1) typename
-#define ASIO_COMPLETION_HANDLER_FOR3(sig0, sig1, sig2) typename
-
-#endif // defined(ASIO_HAS_CONCEPTS)
-
-namespace detail {
-
-template <typename T>
-struct is_lvalue_completion_signature : false_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_lvalue_completion_signature<R(Args...) &> : true_type
-{
-};
-
-# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct is_lvalue_completion_signature<R(Args...) & noexcept> : true_type
-{
-};
-
-# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename... Signatures>
-struct are_any_lvalue_completion_signatures : false_type
-{
-};
-
-template <typename Sig0>
-struct are_any_lvalue_completion_signatures<Sig0>
-  : is_lvalue_completion_signature<Sig0>
-{
-};
-
-template <typename Sig0, typename... SigN>
-struct are_any_lvalue_completion_signatures<Sig0, SigN...>
-  : integral_constant<bool, (
-      is_lvalue_completion_signature<Sig0>::value
-        || are_any_lvalue_completion_signatures<SigN...>::value)>
-{
-};
-
-template <typename T>
-struct is_rvalue_completion_signature : false_type
-{
-};
-
-template <typename R, typename... Args>
-struct is_rvalue_completion_signature<R(Args...) &&> : true_type
-{
-};
-
-# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct is_rvalue_completion_signature<R(Args...) && noexcept> : true_type
-{
-};
-
-# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename... Signatures>
-struct are_any_rvalue_completion_signatures : false_type
-{
-};
-
-template <typename Sig0>
-struct are_any_rvalue_completion_signatures<Sig0>
-  : is_rvalue_completion_signature<Sig0>
-{
-};
-
-template <typename Sig0, typename... SigN>
-struct are_any_rvalue_completion_signatures<Sig0, SigN...>
-  : integral_constant<bool, (
-      is_rvalue_completion_signature<Sig0>::value
-        || are_any_rvalue_completion_signatures<SigN...>::value)>
-{
-};
-
-template <typename T>
-struct simple_completion_signature;
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...)>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) &>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) &&>
-{
-  typedef R type(Args...);
-};
-
-# if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) noexcept>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) & noexcept>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct simple_completion_signature<R(Args...) && noexcept>
-{
-  typedef R type(Args...);
-};
-
-# endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures>
-class completion_handler_async_result
-{
-public:
-  typedef CompletionToken completion_handler_type;
-  typedef void return_type;
-
-  explicit completion_handler_async_result(completion_handler_type&)
-  {
-  }
-
-  return_type get()
-  {
-  }
-
-  template <typename Initiation,
-      ASIO_COMPLETION_HANDLER_FOR(Signatures...) RawCompletionToken,
-      typename... Args>
-  static return_type initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-  {
-    static_cast<Initiation&&>(initiation)(
-        static_cast<RawCompletionToken&&>(token),
-        static_cast<Args&&>(args)...);
-  }
-
-private:
-  completion_handler_async_result(
-      const completion_handler_async_result&) = delete;
-  completion_handler_async_result& operator=(
-      const completion_handler_async_result&) = delete;
-};
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// An interface for customising the behaviour of an initiating function.
-/**
- * The async_result traits class is used for determining:
- *
- * @li the concrete completion handler type to be called at the end of the
- * asynchronous operation;
- *
- * @li the initiating function return type; and
- *
- * @li how the return value of the initiating function is obtained.
- *
- * The trait allows the handler and return types to be determined at the point
- * where the specific completion handler signature is known.
- *
- * This template may be specialised for user-defined completion token types.
- * The primary template assumes that the CompletionToken is the completion
- * handler.
- */
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures>
-class async_result
-{
-public:
-  /// The concrete completion handler type for the specific signature.
-  typedef CompletionToken completion_handler_type;
-
-  /// The return type of the initiating function.
-  typedef void return_type;
-
-  /// Construct an async result from a given handler.
-  /**
-   * When using a specalised async_result, the constructor has an opportunity
-   * to initialise some state associated with the completion handler, which is
-   * then returned from the initiating function.
-   */
-  explicit async_result(completion_handler_type& h);
-
-  /// Obtain the value to be returned from the initiating function.
-  return_type get();
-
-  /// Initiate the asynchronous operation that will produce the result, and
-  /// obtain the value to be returned from the initiating function.
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static return_type initiate(
-      Initiation&& initiation,
-      RawCompletionToken&& token,
-      Args&&... args);
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures>
-class async_result :
-  public conditional_t<
-      detail::are_any_lvalue_completion_signatures<Signatures...>::value
-        || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
-      detail::completion_handler_async_result<CompletionToken, Signatures...>,
-      async_result<CompletionToken,
-        typename detail::simple_completion_signature<Signatures>::type...>
-    >
-{
-public:
-  typedef conditional_t<
-      detail::are_any_lvalue_completion_signatures<Signatures...>::value
-        || !detail::are_any_rvalue_completion_signatures<Signatures...>::value,
-      detail::completion_handler_async_result<CompletionToken, Signatures...>,
-      async_result<CompletionToken,
-        typename detail::simple_completion_signature<Signatures>::type...>
-    > base_type;
-
-  using base_type::base_type;
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-};
-
-template <ASIO_COMPLETION_SIGNATURE... Signatures>
-class async_result<void, Signatures...>
-{
-  // Empty.
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-/// Helper template to deduce the handler type from a CompletionToken, capture
-/// a local copy of the handler, and then create an async_result for the
-/// handler.
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures>
-struct async_completion
-{
-  /// The real handler type to be used for the asynchronous operation.
-  typedef typename asio::async_result<
-    decay_t<CompletionToken>, Signatures...>::completion_handler_type
-      completion_handler_type;
-
-  /// Constructor.
-  /**
-   * The constructor creates the concrete completion handler and makes the link
-   * between the handler and the asynchronous result.
-   */
-  explicit async_completion(CompletionToken& token)
-    : completion_handler(static_cast<conditional_t<
-        is_same<CompletionToken, completion_handler_type>::value,
-        completion_handler_type&, CompletionToken&&>>(token)),
-      result(completion_handler)
-  {
-  }
-
-  /// A copy of, or reference to, a real handler object.
-  conditional_t<
-    is_same<CompletionToken, completion_handler_type>::value,
-    completion_handler_type&, completion_handler_type> completion_handler;
-
-  /// The result of the asynchronous operation's initiating function.
-  async_result<decay_t<CompletionToken>, Signatures...> result;
-};
-
-namespace detail {
-
-struct async_result_memfns_base
-{
-  void initiate();
-};
-
-template <typename T>
-struct async_result_memfns_derived
-  : T, async_result_memfns_base
-{
-};
-
-template <typename T, T>
-struct async_result_memfns_check
-{
-};
-
-template <typename>
-char (&async_result_initiate_memfn_helper(...))[2];
-
-template <typename T>
-char async_result_initiate_memfn_helper(
-    async_result_memfns_check<
-      void (async_result_memfns_base::*)(),
-      &async_result_memfns_derived<T>::initiate>*);
-
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures>
-struct async_result_has_initiate_memfn
-  : integral_constant<bool, sizeof(async_result_initiate_memfn_helper<
-      async_result<decay_t<CompletionToken>, Signatures...>
-    >(0)) != 1>
-{
-};
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
-  void_or_deduced
-# define ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \
-  void_or_deduced
-# define ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  void_or_deduced
-#else
-# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, sig>::return_type
-# define ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, sig0, sig1>::return_type
-# define ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, sig0, sig1, sig2>::return_type
-#define ASIO_HANDLER_TYPE(ct, sig) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, sig>::completion_handler_type
-#define ASIO_HANDLER_TYPE2(ct, sig0, sig1) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, \
-      sig0, sig1>::completion_handler_type
-#define ASIO_HANDLER_TYPE3(ct, sig0, sig1, sig2) \
-  typename ::asio::async_result< \
-    typename ::asio::decay<ct>::type, \
-      sig0, sig1, sig2>::completion_handler_type
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  auto
-#elif defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  auto
-#else
-# define ASIO_INITFN_AUTO_RESULT_TYPE(ct, sig) \
-  ASIO_INITFN_RESULT_TYPE(ct, sig)
-# define ASIO_INITFN_AUTO_RESULT_TYPE2(ct, sig0, sig1) \
-  ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1)
-# define ASIO_INITFN_AUTO_RESULT_TYPE3(ct, sig0, sig1, sig2) \
-  ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
-#elif defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
-#else
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
-  auto
-# define ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr) -> decltype expr
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
-  void_or_deduced
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \
-  void_or_deduced
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
-  void_or_deduced
-#else
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
-  decltype expr
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE2(ct, sig0, sig1, expr) \
-  decltype expr
-# define ASIO_INITFN_DEDUCED_RESULT_TYPE3(ct, sig0, sig1, sig2, expr) \
-  decltype expr
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken,
-    completion_signature... Signatures,
-    typename Initiation, typename... Args>
-void_or_deduced async_initiate(
-    Initiation&& initiation,
-    type_identity_t<CompletionToken>& token,
-    Args&&... args);
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename Initiation, typename... Args>
-inline auto async_initiate(Initiation&& initiation,
-    type_identity_t<CompletionToken>& token, Args&&... args)
-  -> decltype(enable_if_t<
-    enable_if_t<
-      detail::are_completion_signatures<Signatures...>::value,
-      detail::async_result_has_initiate_memfn<
-        CompletionToken, Signatures...>>::value,
-    async_result<decay_t<CompletionToken>, Signatures...>>::initiate(
-      static_cast<Initiation&&>(initiation),
-      static_cast<CompletionToken&&>(token),
-      static_cast<Args&&>(args)...))
-{
-  return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
-      static_cast<Initiation&&>(initiation),
-      static_cast<CompletionToken&&>(token),
-      static_cast<Args&&>(args)...);
-}
-
-template <
-    ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename CompletionToken, typename Initiation, typename... Args>
-inline auto async_initiate(Initiation&& initiation,
-    CompletionToken&& token, Args&&... args)
-  -> decltype(enable_if_t<
-    enable_if_t<
-      detail::are_completion_signatures<Signatures...>::value,
-      detail::async_result_has_initiate_memfn<
-        CompletionToken, Signatures...>>::value,
-    async_result<decay_t<CompletionToken>, Signatures...>>::initiate(
-      static_cast<Initiation&&>(initiation),
-      static_cast<CompletionToken&&>(token),
-      static_cast<Args&&>(args)...))
-{
-  return async_result<decay_t<CompletionToken>, Signatures...>::initiate(
-      static_cast<Initiation&&>(initiation),
-      static_cast<CompletionToken&&>(token),
-      static_cast<Args&&>(args)...);
-}
-
-template <typename CompletionToken,
-    ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename Initiation, typename... Args>
-inline typename enable_if_t<
-    !enable_if_t<
-      detail::are_completion_signatures<Signatures...>::value,
-      detail::async_result_has_initiate_memfn<
-        CompletionToken, Signatures...>>::value,
-    async_result<decay_t<CompletionToken>, Signatures...>
-  >::return_type
-async_initiate(Initiation&& initiation,
-    type_identity_t<CompletionToken>& token, Args&&... args)
-{
-  async_completion<CompletionToken, Signatures...> completion(token);
-
-  static_cast<Initiation&&>(initiation)(
-      static_cast<
-        typename async_result<decay_t<CompletionToken>,
-          Signatures...>::completion_handler_type&&>(
-            completion.completion_handler),
-      static_cast<Args&&>(args)...);
-
-  return completion.result.get();
-}
-
-template <ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename CompletionToken, typename Initiation, typename... Args>
-inline typename enable_if_t<
-    !enable_if_t<
-      detail::are_completion_signatures<Signatures...>::value,
-      detail::async_result_has_initiate_memfn<
-        CompletionToken, Signatures...>>::value,
-    async_result<decay_t<CompletionToken>, Signatures...>
-  >::return_type
-async_initiate(Initiation&& initiation, CompletionToken&& token, Args&&... args)
-{
-  async_completion<CompletionToken, Signatures...> completion(token);
-
-  static_cast<Initiation&&>(initiation)(
-      static_cast<
-        typename async_result<decay_t<CompletionToken>,
-          Signatures...>::completion_handler_type&&>(
-            completion.completion_handler),
-      static_cast<Args&&>(args)...);
-
-  return completion.result.get();
-}
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_CONCEPTS)
-
-namespace detail {
-
-template <typename... Signatures>
-struct initiation_archetype
-{
-  template <completion_handler_for<Signatures...> CompletionHandler>
-  void operator()(CompletionHandler&&) const
-  {
-  }
-};
-
-} // namespace detail
-
-template <typename T, typename... Signatures>
-ASIO_CONCEPT completion_token_for =
-  detail::are_completion_signatures<Signatures...>::value
-  &&
-  requires(T&& t)
-  {
-    async_initiate<T, Signatures...>(
-        detail::initiation_archetype<Signatures...>{}, t);
-  };
-
-#define ASIO_COMPLETION_TOKEN_FOR(sig) \
-  ::asio::completion_token_for<sig>
-#define ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) \
-  ::asio::completion_token_for<sig0, sig1>
-#define ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) \
-  ::asio::completion_token_for<sig0, sig1, sig2>
-
-#else // defined(ASIO_HAS_CONCEPTS)
-
-#define ASIO_COMPLETION_TOKEN_FOR(sig) typename
-#define ASIO_COMPLETION_TOKEN_FOR2(sig0, sig1) typename
-#define ASIO_COMPLETION_TOKEN_FOR3(sig0, sig1, sig2) typename
-
-#endif // defined(ASIO_HAS_CONCEPTS)
-
-namespace detail {
-
-struct async_operation_probe {};
-struct async_operation_probe_result {};
-
-template <typename Call, typename = void>
-struct is_async_operation_call : false_type
-{
-};
-
-template <typename Call>
-struct is_async_operation_call<Call,
-    void_t<
-      enable_if_t<
-        is_same<
-          result_of_t<Call>,
-          async_operation_probe_result
-        >::value
-      >
-    >
-  > : true_type
-{
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename... Signatures>
-class async_result<detail::async_operation_probe, Signatures...>
-{
-public:
-  typedef detail::async_operation_probe_result return_type;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&&,
-      detail::async_operation_probe, InitArgs&&...)
-  {
-    return return_type();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// The is_async_operation trait detects whether a type @c T and arguments
-/// @c Args... may be used to initiate an asynchronous operation.
-/**
- * Class template @c is_async_operation is a trait is derived from @c true_type
- * if the expression <tt>T(Args..., token)</tt> initiates an asynchronous
- * operation, where @c token is an unspecified completion token type. Otherwise,
- * @c is_async_operation is derived from @c false_type.
- */
-template <typename T, typename... Args>
-struct is_async_operation : integral_constant<bool, automatically_determined>
-{
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename T, typename... Args>
-struct is_async_operation :
-  detail::is_async_operation_call<
-    T(Args..., detail::async_operation_probe)>
-{
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_CONCEPTS)
-
-template <typename T, typename... Args>
-ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
-
-#define ASIO_ASYNC_OPERATION(t) \
-  ::asio::async_operation<t>
-#define ASIO_ASYNC_OPERATION1(t, a0) \
-  ::asio::async_operation<t, a0>
-#define ASIO_ASYNC_OPERATION2(t, a0, a1) \
-  ::asio::async_operation<t, a0, a1>
-#define ASIO_ASYNC_OPERATION3(t, a0, a1, a2) \
-  ::asio::async_operation<t, a0, a1, a2>
-
-#else // defined(ASIO_HAS_CONCEPTS)
-
-#define ASIO_ASYNC_OPERATION(t) typename
-#define ASIO_ASYNC_OPERATION1(t, a0) typename
-#define ASIO_ASYNC_OPERATION2(t, a0, a1) typename
-#define ASIO_ASYNC_OPERATION3(t, a0, a1, a2) typename
-
-#endif // defined(ASIO_HAS_CONCEPTS)
-
-namespace detail {
-
-struct completion_signature_probe {};
-
-template <typename... T>
-struct completion_signature_probe_result
-{
-  template <template <typename...> class Op>
-  struct apply
-  {
-    typedef Op<T...> type;
-  };
-};
-
-template <typename T>
-struct completion_signature_probe_result<T>
-{
-  typedef T type;
-
-  template <template <typename...> class Op>
-  struct apply
-  {
-    typedef Op<T> type;
-  };
-};
-
-template <>
-struct completion_signature_probe_result<void>
-{
-  template <template <typename...> class Op>
-  struct apply
-  {
-    typedef Op<> type;
-  };
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename... Signatures>
-class async_result<detail::completion_signature_probe, Signatures...>
-{
-public:
-  typedef detail::completion_signature_probe_result<Signatures...> return_type;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&&,
-      detail::completion_signature_probe, InitArgs&&...)
-  {
-    return return_type();
-  }
-};
-
-template <typename Signature>
-class async_result<detail::completion_signature_probe, Signature>
-{
-public:
-  typedef detail::completion_signature_probe_result<Signature> return_type;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&&,
-      detail::completion_signature_probe, InitArgs&&...)
-  {
-    return return_type();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// The completion_signature_of trait determines the completion signature
-/// of an asynchronous operation.
-/**
- * Class template @c completion_signature_of is a trait with a member type
- * alias @c type that denotes the completion signature of the asynchronous
- * operation initiated by the expression <tt>T(Args..., token)</tt> operation,
- * where @c token is an unspecified completion token type. If the asynchronous
- * operation does not have exactly one completion signature, the instantion of
- * the trait is well-formed but the member type alias @c type is omitted. If
- * the expression <tt>T(Args..., token)</tt> is not an asynchronous operation
- * then use of the trait is ill-formed.
- */
-template <typename T, typename... Args>
-struct completion_signature_of
-{
-  typedef automatically_determined type;
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename T, typename... Args>
-struct completion_signature_of :
-  result_of_t<T(Args..., detail::completion_signature_probe)>
-{
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-template <typename T, typename... Args>
-using completion_signature_of_t =
-  typename completion_signature_of<T, Args...>::type;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/default_completion_token.hpp"
-
-#endif // ASIO_ASYNC_RESULT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/awaitable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/awaitable.hpp
deleted file mode 100644
index 7e4ee7a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/awaitable.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//
-// awaitable.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_AWAITABLE_HPP
-#define ASIO_AWAITABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-# include <coroutine>
-#else // defined(ASIO_HAS_STD_COROUTINE)
-# include <experimental/coroutine>
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-#include <utility>
-#include "asio/any_io_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-using std::coroutine_handle;
-using std::suspend_always;
-#else // defined(ASIO_HAS_STD_COROUTINE)
-using std::experimental::coroutine_handle;
-using std::experimental::suspend_always;
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-template <typename> class awaitable_thread;
-template <typename, typename> class awaitable_frame;
-
-} // namespace detail
-
-/// The return type of a coroutine or asynchronous operation.
-template <typename T, typename Executor = any_io_executor>
-class ASIO_NODISCARD awaitable
-{
-public:
-  /// The type of the awaited value.
-  typedef T value_type;
-
-  /// The executor type that will be used for the coroutine.
-  typedef Executor executor_type;
-
-  /// Default constructor.
-  constexpr awaitable() noexcept
-    : frame_(nullptr)
-  {
-  }
-
-  /// Move constructor.
-  awaitable(awaitable&& other) noexcept
-    : frame_(std::exchange(other.frame_, nullptr))
-  {
-  }
-
-  /// Destructor
-  ~awaitable()
-  {
-    if (frame_)
-      frame_->destroy();
-  }
-
-  /// Move assignment.
-  awaitable& operator=(awaitable&& other) noexcept
-  {
-    if (this != &other)
-      frame_ = std::exchange(other.frame_, nullptr);
-    return *this;
-  }
-
-  /// Checks if the awaitable refers to a future result.
-  bool valid() const noexcept
-  {
-    return !!frame_;
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-  // Support for co_await keyword.
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  // Support for co_await keyword.
-  template <class U>
-  void await_suspend(
-      detail::coroutine_handle<detail::awaitable_frame<U, Executor>> h)
-  {
-    frame_->push_frame(&h.promise());
-  }
-
-  // Support for co_await keyword.
-  T await_resume()
-  {
-    return awaitable(static_cast<awaitable&&>(*this)).frame_->get();
-  }
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-private:
-  template <typename> friend class detail::awaitable_thread;
-  template <typename, typename> friend class detail::awaitable_frame;
-
-  // Not copy constructible or copy assignable.
-  awaitable(const awaitable&) = delete;
-  awaitable& operator=(const awaitable&) = delete;
-
-  // Construct the awaitable from a coroutine's frame object.
-  explicit awaitable(detail::awaitable_frame<T, Executor>* a)
-    : frame_(a)
-  {
-  }
-
-  detail::awaitable_frame<T, Executor>* frame_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/awaitable.hpp"
-
-#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_AWAITABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_datagram_socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_datagram_socket.hpp
deleted file mode 100644
index fb31247..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_datagram_socket.hpp
+++ /dev/null
@@ -1,1362 +0,0 @@
-//
-// basic_datagram_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_DATAGRAM_SOCKET_HPP
-#define ASIO_BASIC_DATAGRAM_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL)
-#define ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_datagram_socket;
-
-#endif // !defined(ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL)
-
-/// Provides datagram-oriented socket functionality.
-/**
- * The basic_datagram_socket class template provides asynchronous and blocking
- * datagram-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c send, @c send_to, @c receive, @c receive_from, @c connect,
- * and @c shutdown operations are thread safe with respect to each other, if
- * the underlying operating system calls are also thread safe. This means that
- * it is permitted to perform concurrent calls to these synchronous operations
- * on a single socket object. Other synchronous operations, such as @c open or
- * @c close, are not thread safe.
- */
-template <typename Protocol, typename Executor>
-class basic_datagram_socket
-  : public basic_socket<Protocol, Executor>
-{
-private:
-  class initiate_async_send;
-  class initiate_async_send_to;
-  class initiate_async_receive;
-  class initiate_async_receive_from;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the socket type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_datagram_socket<Protocol, Executor1> other;
-  };
-
-  /// The native representation of a socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_socket<Protocol,
-    Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_datagram_socket without opening it.
-  /**
-   * This constructor creates a datagram socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_datagram_socket(const executor_type& ex)
-    : basic_socket<Protocol, Executor>(ex)
-  {
-  }
-
-  /// Construct a basic_datagram_socket without opening it.
-  /**
-   * This constructor creates a datagram socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   */
-  template <typename ExecutionContext>
-  explicit basic_datagram_socket(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context)
-  {
-  }
-
-  /// Construct and open a basic_datagram_socket.
-  /**
-   * This constructor creates and opens a datagram socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(const executor_type& ex, const protocol_type& protocol)
-    : basic_socket<Protocol, Executor>(ex, protocol)
-  {
-  }
-
-  /// Construct and open a basic_datagram_socket.
-  /**
-   * This constructor creates and opens a datagram socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_datagram_socket(ExecutionContext& context,
-      const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_socket<Protocol, Executor>(context, protocol)
-  {
-  }
-
-  /// Construct a basic_datagram_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a datagram socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the datagram
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(const executor_type& ex, const endpoint_type& endpoint)
-    : basic_socket<Protocol, Executor>(ex, endpoint)
-  {
-  }
-
-  /// Construct a basic_datagram_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a datagram socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the datagram
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_datagram_socket(ExecutionContext& context,
-      const endpoint_type& endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, endpoint)
-  {
-  }
-
-  /// Construct a basic_datagram_socket on an existing native socket.
-  /**
-   * This constructor creates a datagram socket object to hold an existing
-   * native socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(const executor_type& ex,
-      const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, Executor>(ex, protocol, native_socket)
-  {
-  }
-
-  /// Construct a basic_datagram_socket on an existing native socket.
-  /**
-   * This constructor creates a datagram socket object to hold an existing
-   * native socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_datagram_socket(ExecutionContext& context,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, protocol, native_socket)
-  {
-  }
-
-  /// Move-construct a basic_datagram_socket from another.
-  /**
-   * This constructor moves a datagram socket from one object to another.
-   *
-   * @param other The other basic_datagram_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_datagram_socket(const executor_type&)
-   * constructor.
-   */
-  basic_datagram_socket(basic_datagram_socket&& other) noexcept
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_datagram_socket from another.
-  /**
-   * This assignment operator moves a datagram socket from one object to
-   * another.
-   *
-   * @param other The other basic_datagram_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_datagram_socket(const executor_type&)
-   * constructor.
-   */
-  basic_datagram_socket& operator=(basic_datagram_socket&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_datagram_socket from a socket of another protocol
-  /// type.
-  /**
-   * This constructor moves a datagram socket from one object to another.
-   *
-   * @param other The other basic_datagram_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_datagram_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_datagram_socket(basic_datagram_socket<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_datagram_socket from a socket of another protocol
-  /// type.
-  /**
-   * This assignment operator moves a datagram socket from one object to
-   * another.
-   *
-   * @param other The other basic_datagram_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_datagram_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_datagram_socket&
-  > operator=(basic_datagram_socket<Protocol1, Executor1>&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the socket.
-  /**
-   * This function destroys the socket, cancelling any outstanding asynchronous
-   * operations associated with the socket as if by calling @c cancel.
-   */
-  ~basic_datagram_socket()
-  {
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code socket.send(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to asynchronously send data on the datagram socket.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected datagram
-   * socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to asynchronously send data on the datagram socket.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected datagram
-   * socket.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token, buffers, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token, buffers, flags);
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.send_to(asio::buffer(data, size), destination);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send_to(
-        this->impl_.get_implementation(), buffers, destination, 0, ec);
-    asio::detail::throw_error(ec, "send_to");
-    return s;
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send_to(
-        this->impl_.get_implementation(), buffers, destination, flags, ec);
-    asio::detail::throw_error(ec, "send_to");
-    return s;
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().send_to(this->impl_.get_implementation(),
-        buffers, destination, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.async_send_to(
-   *     asio::buffer(data, size), destination, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send_to>(), token, buffers,
-          destination, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send_to(this), token, buffers,
-        destination, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send_to>(), token,
-          buffers, destination, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send_to(this), token,
-        buffers, destination, flags);
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.receive(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the datagram
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * datagram socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the datagram
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * datagram socket.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token, buffers, flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token, buffers, flags);
-  }
-
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * asio::ip::udp::endpoint sender_endpoint;
-   * socket.receive_from(
-   *     asio::buffer(data, size), sender_endpoint);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, 0, ec);
-    asio::detail::throw_error(ec, "receive_from");
-    return s;
-  }
-
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, flags, ec);
-    asio::detail::throw_error(ec, "receive_from");
-    return s;
-  }
-
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive a datagram. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.async_receive_from(
-   *     asio::buffer(data, size), sender_endpoint, handler); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_from>(), token, buffers,
-          &sender_endpoint, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_from(this), token, buffers,
-        &sender_endpoint, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive a datagram. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_from>(), token,
-          buffers, &sender_endpoint, flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_from(this), token,
-        buffers, &sender_endpoint, flags);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_datagram_socket(const basic_datagram_socket&) = delete;
-  basic_datagram_socket& operator=(
-      const basic_datagram_socket&) = delete;
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_datagram_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_datagram_socket* self_;
-  };
-
-  class initiate_async_send_to
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send_to(basic_datagram_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers, const endpoint_type& destination,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send_to(
-          self_->impl_.get_implementation(), buffers, destination,
-          flags, handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_datagram_socket* self_;
-  };
-
-  class initiate_async_receive
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive(basic_datagram_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_datagram_socket* self_;
-  };
-
-  class initiate_async_receive_from
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive_from(basic_datagram_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers, endpoint_type* sender_endpoint,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive_from(
-          self_->impl_.get_implementation(), buffers, *sender_endpoint,
-          flags, handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_datagram_socket* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_DATAGRAM_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_deadline_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_deadline_timer.hpp
deleted file mode 100644
index b9f5b27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_deadline_timer.hpp
+++ /dev/null
@@ -1,710 +0,0 @@
-//
-// basic_deadline_timer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_DEADLINE_TIMER_HPP
-#define ASIO_BASIC_DEADLINE_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <cstddef>
-#include "asio/any_io_executor.hpp"
-#include "asio/detail/deadline_timer_service.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/time_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides waitable timer functionality.
-/**
- * The basic_deadline_timer class template provides the ability to perform a
- * blocking or asynchronous wait for a timer to expire.
- *
- * A deadline timer is always in one of two states: "expired" or "not expired".
- * If the wait() or async_wait() function is called on an expired timer, the
- * wait operation will complete immediately.
- *
- * Most applications will use the asio::deadline_timer typedef.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Examples
- * Performing a blocking wait:
- * @code
- * // Construct a timer without setting an expiry time.
- * asio::deadline_timer timer(my_context);
- *
- * // Set an expiry time relative to now.
- * timer.expires_from_now(boost::posix_time::seconds(5));
- *
- * // Wait for the timer to expire.
- * timer.wait();
- * @endcode
- *
- * @par
- * Performing an asynchronous wait:
- * @code
- * void handler(const asio::error_code& error)
- * {
- *   if (!error)
- *   {
- *     // Timer expired.
- *   }
- * }
- *
- * ...
- *
- * // Construct a timer with an absolute expiry time.
- * asio::deadline_timer timer(my_context,
- *     boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
- *
- * // Start an asynchronous wait.
- * timer.async_wait(handler);
- * @endcode
- *
- * @par Changing an active deadline_timer's expiry time
- *
- * Changing the expiry time of a timer while there are pending asynchronous
- * waits causes those wait operations to be cancelled. To ensure that the action
- * associated with the timer is performed only once, use something like this:
- * used:
- *
- * @code
- * void on_some_event()
- * {
- *   if (my_timer.expires_from_now(seconds(5)) > 0)
- *   {
- *     // We managed to cancel the timer. Start new asynchronous wait.
- *     my_timer.async_wait(on_timeout);
- *   }
- *   else
- *   {
- *     // Too late, timer has already expired!
- *   }
- * }
- *
- * void on_timeout(const asio::error_code& e)
- * {
- *   if (e != asio::error::operation_aborted)
- *   {
- *     // Timer was not cancelled, take necessary action.
- *   }
- * }
- * @endcode
- *
- * @li The asio::basic_deadline_timer::expires_from_now() function
- * cancels any pending asynchronous waits, and returns the number of
- * asynchronous waits that were cancelled. If it returns 0 then you were too
- * late and the wait handler has already been executed, or will soon be
- * executed. If it returns 1 then the wait handler was successfully cancelled.
- *
- * @li If a wait handler is cancelled, the asio::error_code passed to
- * it contains the value asio::error::operation_aborted.
- */
-template <typename Time,
-    typename TimeTraits = asio::time_traits<Time>,
-    typename Executor = any_io_executor>
-class basic_deadline_timer
-{
-private:
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the timer type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The timer type when rebound to the specified executor.
-    typedef basic_deadline_timer<Time, TimeTraits, Executor1> other;
-  };
-
-  /// The time traits type.
-  typedef TimeTraits traits_type;
-
-  /// The time type.
-  typedef typename traits_type::time_type time_type;
-
-  /// The duration type.
-  typedef typename traits_type::duration_type duration_type;
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_from_now() functions must be called to set an
-   * expiry time before the timer can be waited on.
-   *
-   * @param ex The I/O executor that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   */
-  explicit basic_deadline_timer(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_from_now() functions must be called to set an
-   * expiry time before the timer can be waited on.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   */
-  template <typename ExecutionContext>
-  explicit basic_deadline_timer(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param ex The I/O executor that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  basic_deadline_timer(const executor_type& ex, const time_type& expiry_time)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  template <typename ExecutionContext>
-  basic_deadline_timer(ExecutionContext& context, const time_type& expiry_time,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param ex The I/O executor that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  basic_deadline_timer(const executor_type& ex,
-      const duration_type& expiry_time)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  template <typename ExecutionContext>
-  basic_deadline_timer(ExecutionContext& context,
-      const duration_type& expiry_time,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
-  }
-
-  /// Move-construct a basic_deadline_timer from another.
-  /**
-   * This constructor moves a timer from one object to another.
-   *
-   * @param other The other basic_deadline_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_deadline_timer(const executor_type&)
-   * constructor.
-   */
-  basic_deadline_timer(basic_deadline_timer&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_deadline_timer from another.
-  /**
-   * This assignment operator moves a timer from one object to another. Cancels
-   * any outstanding asynchronous operations associated with the target object.
-   *
-   * @param other The other basic_deadline_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_deadline_timer(const executor_type&)
-   * constructor.
-   */
-  basic_deadline_timer& operator=(basic_deadline_timer&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  /// Destroys the timer.
-  /**
-   * This function destroys the timer, cancelling any outstanding asynchronous
-   * wait operations associated with the timer as if by calling @c cancel.
-   */
-  ~basic_deadline_timer()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel()
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-    return s;
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel(asio::error_code& ec)
-  {
-    return impl_.get_service().cancel(impl_.get_implementation(), ec);
-  }
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one()
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().cancel_one(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel_one");
-    return s;
-  }
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one(asio::error_code& ec)
-  {
-    return impl_.get_service().cancel_one(impl_.get_implementation(), ec);
-  }
-
-  /// Get the timer's expiry time as an absolute time.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  time_type expires_at() const
-  {
-    return impl_.get_service().expires_at(impl_.get_implementation());
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_type& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().expires_at(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-    return s;
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_type& expiry_time,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().expires_at(
-        impl_.get_implementation(), expiry_time, ec);
-  }
-
-  /// Get the timer's expiry time relative to now.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  duration_type expires_from_now() const
-  {
-    return impl_.get_service().expires_from_now(impl_.get_implementation());
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration_type& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
-    return s;
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration_type& expiry_time,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-  }
-
-  /// Start an asynchronous wait on the timer.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * timer. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * For each call to async_wait(), the completion handler will be called
-   * exactly once. The completion handler will be called when:
-   *
-   * @li The timer has expired.
-   *
-   * @li The timer was cancelled, in which case the handler is passed the error
-   * code asio::error::operation_aborted.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the timer expires. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-        declval<initiate_async_wait>(), token))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_deadline_timer(const basic_deadline_timer&) = delete;
-  basic_deadline_timer& operator=(
-      const basic_deadline_timer&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_deadline_timer* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(),
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_deadline_timer* self_;
-  };
-
-  detail::io_object_impl<
-    detail::deadline_timer_service<TimeTraits>, Executor> impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_DEADLINE_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_file.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_file.hpp
deleted file mode 100644
index dbdb6d8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_file.hpp
+++ /dev/null
@@ -1,824 +0,0 @@
-//
-// basic_file.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_FILE_HPP
-#define ASIO_BASIC_FILE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <string>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/post.hpp"
-#include "asio/file_base.hpp"
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_file_service.hpp"
-#elif defined(ASIO_HAS_IO_URING)
-# include "asio/detail/io_uring_file_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_FILE_FWD_DECL)
-#define ASIO_BASIC_FILE_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Executor = any_io_executor>
-class basic_file;
-
-#endif // !defined(ASIO_BASIC_FILE_FWD_DECL)
-
-/// Provides file functionality.
-/**
- * The basic_file class template provides functionality that is common to both
- * stream-oriented and random-access files.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor>
-class basic_file
-  : public file_base
-{
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the file type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The file type when rebound to the specified executor.
-    typedef basic_file<Executor1> other;
-  };
-
-  /// The native representation of a file.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_file_service::native_handle_type native_handle_type;
-#elif defined(ASIO_HAS_IO_URING)
-  typedef detail::io_uring_file_service::native_handle_type native_handle_type;
-#endif
-
-  /// Construct a basic_file without opening it.
-  /**
-   * This constructor initialises a file without opening it.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   */
-  explicit basic_file(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a basic_file without opening it.
-  /**
-   * This constructor initialises a file without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   */
-  template <typename ExecutionContext>
-  explicit basic_file(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct and open a basic_file.
-  /**
-   * This constructor initialises a file and opens it.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   */
-  explicit basic_file(const executor_type& ex,
-      const char* path, file_base::flags open_flags)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_file without opening it.
-  /**
-   * This constructor initialises a file and opens it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   */
-  template <typename ExecutionContext>
-  explicit basic_file(ExecutionContext& context,
-      const char* path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_file.
-  /**
-   * This constructor initialises a file and opens it.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   */
-  explicit basic_file(const executor_type& ex,
-      const std::string& path, file_base::flags open_flags)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_file without opening it.
-  /**
-   * This constructor initialises a file and opens it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   */
-  template <typename ExecutionContext>
-  explicit basic_file(ExecutionContext& context,
-      const std::string& path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_file on an existing native file handle.
-  /**
-   * This constructor initialises a file object to hold an existing native file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param native_file A native file handle.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_file(const executor_type& ex, const native_handle_type& native_file)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(
-        impl_.get_implementation(), native_file, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_file on an existing native file.
-  /**
-   * This constructor initialises a file object to hold an existing native file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param native_file A native file.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_file(ExecutionContext& context, const native_handle_type& native_file,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(
-        impl_.get_implementation(), native_file, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_file from another.
-  /**
-   * This constructor moves a file from one object to another.
-   *
-   * @param other The other basic_file object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_file(const executor_type&) constructor.
-   */
-  basic_file(basic_file&& other) noexcept
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_file from another.
-  /**
-   * This assignment operator moves a file from one object to another.
-   *
-   * @param other The other basic_file object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_file(const executor_type&) constructor.
-   */
-  basic_file& operator=(basic_file&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All files have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_file;
-
-  /// Move-construct a basic_file from a file of another executor type.
-  /**
-   * This constructor moves a file from one object to another.
-   *
-   * @param other The other basic_file object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_file(const executor_type&) constructor.
-   */
-  template <typename Executor1>
-  basic_file(basic_file<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_file from a file of another executor type.
-  /**
-   * This assignment operator moves a file from one object to another.
-   *
-   * @param other The other basic_file object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_file(const executor_type&) constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_file&
-  > operator=(basic_file<Executor1>&& other)
-  {
-    basic_file tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Open the file using the specified path.
-  /**
-   * This function opens the file so that it will use the specified path.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::stream_file file(my_context);
-   * file.open("/path/to/my/file", asio::stream_file::read_only);
-   * @endcode
-   */
-  void open(const char* path, file_base::flags open_flags)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Open the file using the specified path.
-  /**
-   * This function opens the file so that it will use the specified path.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::stream_file file(my_context);
-   * asio::error_code ec;
-   * file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID open(const char* path,
-      file_base::flags open_flags, asio::error_code& ec)
-  {
-    impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Open the file using the specified path.
-  /**
-   * This function opens the file so that it will use the specified path.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::stream_file file(my_context);
-   * file.open("/path/to/my/file", asio::stream_file::read_only);
-   * @endcode
-   */
-  void open(const std::string& path, file_base::flags open_flags)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Open the file using the specified path.
-  /**
-   * This function opens the file so that it will use the specified path.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::stream_file file(my_context);
-   * asio::error_code ec;
-   * file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID open(const std::string& path,
-      file_base::flags open_flags, asio::error_code& ec)
-  {
-    impl_.get_service().open(impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Assign an existing native file to the file.
-  /*
-   * This function opens the file to hold an existing native file.
-   *
-   * @param native_file A native file.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& native_file)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(
-        impl_.get_implementation(), native_file, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native file to the file.
-  /*
-   * This function opens the file to hold an existing native file.
-   *
-   * @param native_file A native file.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_file,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(
-        impl_.get_implementation(), native_file, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the file is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the file.
-  /**
-   * This function is used to close the file. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the file.
-  /**
-   * This function is used to close the file. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   *
-   * @par Example
-   * @code
-   * asio::stream_file file(my_context);
-   * ...
-   * asio::error_code ec;
-   * file.close(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native file.
-  /**
-   * This function causes all outstanding asynchronous read and write
-   * operations to finish immediately, and the handlers for cancelled
-   * operations will be passed the asio::error::operation_aborted error.
-   * Ownership of the native file is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native file.
-  /**
-   * This function causes all outstanding asynchronous read and write
-   * operations to finish immediately, and the handlers for cancelled
-   * operations will be passed the asio::error::operation_aborted error.
-   * Ownership of the native file is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native file representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * file. This is intended to allow access to native file functionality
-   * that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the file.
-  /**
-   * This function causes all outstanding asynchronous read and write
-   * operations to finish immediately, and the handlers for cancelled
-   * operations will be passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls to cancel() will always fail with
-   * asio::error::operation_not_supported when run on Windows XP, Windows
-   * Server 2003, and earlier versions of Windows, unless
-   * ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
-   * two issues that should be considered before enabling its use:
-   *
-   * @li It will only cancel asynchronous operations that were initiated in the
-   * current thread.
-   *
-   * @li It can appear to complete without error, but the request to cancel the
-   * unfinished operations may be silently ignored by the operating system.
-   * Whether it works or not seems to depend on the drivers that are installed.
-   *
-   * For portable cancellation, consider using the close() function to
-   * simultaneously cancel the outstanding operations and close the file.
-   *
-   * When running on Windows Vista, Windows Server 2008, and later, the
-   * CancelIoEx function is always used. This function does not have the
-   * problems described above.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
-  && !defined(ASIO_ENABLE_CANCELIO)
-  __declspec(deprecated("By default, this function always fails with "
-        "operation_not_supported when used on Windows XP, Windows Server 2003, "
-        "or earlier. Consult documentation for details."))
-#endif
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the file.
-  /**
-   * This function causes all outstanding asynchronous read and write
-   * operations to finish immediately, and the handlers for cancelled
-   * operations will be passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls to cancel() will always fail with
-   * asio::error::operation_not_supported when run on Windows XP, Windows
-   * Server 2003, and earlier versions of Windows, unless
-   * ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
-   * two issues that should be considered before enabling its use:
-   *
-   * @li It will only cancel asynchronous operations that were initiated in the
-   * current thread.
-   *
-   * @li It can appear to complete without error, but the request to cancel the
-   * unfinished operations may be silently ignored by the operating system.
-   * Whether it works or not seems to depend on the drivers that are installed.
-   *
-   * For portable cancellation, consider using the close() function to
-   * simultaneously cancel the outstanding operations and close the file.
-   *
-   * When running on Windows Vista, Windows Server 2008, and later, the
-   * CancelIoEx function is always used. This function does not have the
-   * problems described above.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
-  && !defined(ASIO_ENABLE_CANCELIO)
-  __declspec(deprecated("By default, this function always fails with "
-        "operation_not_supported when used on Windows XP, Windows Server 2003, "
-        "or earlier. Consult documentation for details."))
-#endif
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the size of the file.
-  /**
-   * This function determines the size of the file, in bytes.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  uint64_t size() const
-  {
-    asio::error_code ec;
-    uint64_t s = impl_.get_service().size(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "size");
-    return s;
-  }
-
-  /// Get the size of the file.
-  /**
-   * This function determines the size of the file, in bytes.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  uint64_t size(asio::error_code& ec) const
-  {
-    return impl_.get_service().size(impl_.get_implementation(), ec);
-  }
-
-  /// Alter the size of the file.
-  /**
-   * This function resizes the file to the specified size, in bytes. If the
-   * current file size exceeds @c n then any extra data is discarded. If the
-   * current size is less than @c n then the file is extended and filled with
-   * zeroes.
-   *
-   * @param n The new size for the file.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void resize(uint64_t n)
-  {
-    asio::error_code ec;
-    impl_.get_service().resize(impl_.get_implementation(), n, ec);
-    asio::detail::throw_error(ec, "resize");
-  }
-
-  /// Alter the size of the file.
-  /**
-   * This function resizes the file to the specified size, in bytes. If the
-   * current file size exceeds @c n then any extra data is discarded. If the
-   * current size is less than @c n then the file is extended and filled with
-   * zeroes.
-   *
-   * @param n The new size for the file.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID resize(uint64_t n, asio::error_code& ec)
-  {
-    impl_.get_service().resize(impl_.get_implementation(), n, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Synchronise the file to disk.
-  /**
-   * This function synchronises the file data and metadata to disk. Note that
-   * the semantics of this synchronisation vary between operation systems.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void sync_all()
-  {
-    asio::error_code ec;
-    impl_.get_service().sync_all(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "sync_all");
-  }
-
-  /// Synchronise the file to disk.
-  /**
-   * This function synchronises the file data and metadata to disk. Note that
-   * the semantics of this synchronisation vary between operation systems.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID sync_all(asio::error_code& ec)
-  {
-    impl_.get_service().sync_all(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Synchronise the file data to disk.
-  /**
-   * This function synchronises the file data to disk. Note that the semantics
-   * of this synchronisation vary between operation systems.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void sync_data()
-  {
-    asio::error_code ec;
-    impl_.get_service().sync_data(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "sync_data");
-  }
-
-  /// Synchronise the file data to disk.
-  /**
-   * This function synchronises the file data to disk. Note that the semantics
-   * of this synchronisation vary between operation systems.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID sync_data(asio::error_code& ec)
-  {
-    impl_.get_service().sync_data(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * This function destroys the file, cancelling any outstanding asynchronous
-   * operations associated with the file as if by calling @c cancel.
-   */
-  ~basic_file()
-  {
-  }
-
-#if defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<detail::win_iocp_file_service, Executor> impl_;
-#elif defined(ASIO_HAS_IO_URING)
-  detail::io_object_impl<detail::io_uring_file_service, Executor> impl_;
-#endif
-
-private:
-  // Disallow copying and assignment.
-  basic_file(const basic_file&) = delete;
-  basic_file& operator=(const basic_file&) = delete;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_FILE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_io_object.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_io_object.hpp
deleted file mode 100644
index 7e50220..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_io_object.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-//
-// basic_io_object.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_IO_OBJECT_HPP
-#define ASIO_BASIC_IO_OBJECT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  // Type trait used to determine whether a service supports move.
-  template <typename IoObjectService>
-  class service_has_move
-  {
-  private:
-    typedef IoObjectService service_type;
-    typedef typename service_type::implementation_type implementation_type;
-
-    template <typename T, typename U>
-    static auto asio_service_has_move_eval(T* t, U* u)
-      -> decltype(t->move_construct(*u, *u), char());
-    static char (&asio_service_has_move_eval(...))[2];
-
-  public:
-    static const bool value =
-      sizeof(asio_service_has_move_eval(
-        static_cast<service_type*>(0),
-        static_cast<implementation_type*>(0))) == 1;
-  };
-}
-
-/// Base class for all I/O objects.
-/**
- * @note All I/O objects are non-copyable. However, when using C++0x, certain
- * I/O objects do support move construction and move assignment.
- */
-#if defined(GENERATING_DOCUMENTATION)
-template <typename IoObjectService>
-#else
-template <typename IoObjectService,
-    bool Movable = detail::service_has_move<IoObjectService>::value>
-#endif
-class basic_io_object
-{
-public:
-  /// The type of the service that will be used to provide I/O operations.
-  typedef IoObjectService service_type;
-
-  /// The underlying implementation type of I/O object.
-  typedef typename service_type::implementation_type implementation_type;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use get_executor().) Get the io_context associated with the
-  /// object.
-  /**
-   * This function may be used to obtain the io_context object that the I/O
-   * object uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_context object that the I/O object will use
-   * to dispatch handlers. Ownership is not transferred to the caller.
-   */
-  asio::io_context& get_io_context()
-  {
-    return service_.get_io_context();
-  }
-
-  /// (Deprecated: Use get_executor().) Get the io_context associated with the
-  /// object.
-  /**
-   * This function may be used to obtain the io_context object that the I/O
-   * object uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_context object that the I/O object will use
-   * to dispatch handlers. Ownership is not transferred to the caller.
-   */
-  asio::io_context& get_io_service()
-  {
-    return service_.get_io_context();
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// The type of the executor associated with the object.
-  typedef asio::io_context::executor_type executor_type;
-
-  /// Get the executor associated with the object.
-  executor_type get_executor() noexcept
-  {
-    return service_.get_io_context().get_executor();
-  }
-
-protected:
-  /// Construct a basic_io_object.
-  /**
-   * Performs:
-   * @code get_service().construct(get_implementation()); @endcode
-   */
-  explicit basic_io_object(asio::io_context& io_context)
-    : service_(asio::use_service<IoObjectService>(io_context))
-  {
-    service_.construct(implementation_);
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_io_object.
-  /**
-   * Performs:
-   * @code get_service().move_construct(
-   *     get_implementation(), other.get_implementation()); @endcode
-   *
-   * @note Available only for services that support movability,
-   */
-  basic_io_object(basic_io_object&& other);
-
-  /// Move-assign a basic_io_object.
-  /**
-   * Performs:
-   * @code get_service().move_assign(get_implementation(),
-   *     other.get_service(), other.get_implementation()); @endcode
-   *
-   * @note Available only for services that support movability,
-   */
-  basic_io_object& operator=(basic_io_object&& other);
-
-  /// Perform a converting move-construction of a basic_io_object.
-  template <typename IoObjectService1>
-  basic_io_object(IoObjectService1& other_service,
-      typename IoObjectService1::implementation_type& other_implementation);
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * Performs:
-   * @code get_service().destroy(get_implementation()); @endcode
-   */
-  ~basic_io_object()
-  {
-    service_.destroy(implementation_);
-  }
-
-  /// Get the service associated with the I/O object.
-  service_type& get_service()
-  {
-    return service_;
-  }
-
-  /// Get the service associated with the I/O object.
-  const service_type& get_service() const
-  {
-    return service_;
-  }
-
-  /// Get the underlying implementation of the I/O object.
-  implementation_type& get_implementation()
-  {
-    return implementation_;
-  }
-
-  /// Get the underlying implementation of the I/O object.
-  const implementation_type& get_implementation() const
-  {
-    return implementation_;
-  }
-
-private:
-  basic_io_object(const basic_io_object&);
-  basic_io_object& operator=(const basic_io_object&);
-
-  // The service associated with the I/O object.
-  service_type& service_;
-
-  /// The underlying implementation of the I/O object.
-  implementation_type implementation_;
-};
-
-// Specialisation for movable objects.
-template <typename IoObjectService>
-class basic_io_object<IoObjectService, true>
-{
-public:
-  typedef IoObjectService service_type;
-  typedef typename service_type::implementation_type implementation_type;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  asio::io_context& get_io_context()
-  {
-    return service_->get_io_context();
-  }
-
-  asio::io_context& get_io_service()
-  {
-    return service_->get_io_context();
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  typedef asio::io_context::executor_type executor_type;
-
-  executor_type get_executor() noexcept
-  {
-    return service_->get_io_context().get_executor();
-  }
-
-protected:
-  explicit basic_io_object(asio::io_context& io_context)
-    : service_(&asio::use_service<IoObjectService>(io_context))
-  {
-    service_->construct(implementation_);
-  }
-
-  basic_io_object(basic_io_object&& other)
-    : service_(&other.get_service())
-  {
-    service_->move_construct(implementation_, other.implementation_);
-  }
-
-  template <typename IoObjectService1>
-  basic_io_object(IoObjectService1& other_service,
-      typename IoObjectService1::implementation_type& other_implementation)
-    : service_(&asio::use_service<IoObjectService>(
-          other_service.get_io_context()))
-  {
-    service_->converting_move_construct(implementation_,
-        other_service, other_implementation);
-  }
-
-  ~basic_io_object()
-  {
-    service_->destroy(implementation_);
-  }
-
-  basic_io_object& operator=(basic_io_object&& other)
-  {
-    service_->move_assign(implementation_,
-        *other.service_, other.implementation_);
-    service_ = other.service_;
-    return *this;
-  }
-
-  service_type& get_service()
-  {
-    return *service_;
-  }
-
-  const service_type& get_service() const
-  {
-    return *service_;
-  }
-
-  implementation_type& get_implementation()
-  {
-    return implementation_;
-  }
-
-  const implementation_type& get_implementation() const
-  {
-    return implementation_;
-  }
-
-private:
-  basic_io_object(const basic_io_object&);
-  void operator=(const basic_io_object&);
-
-  IoObjectService* service_;
-  implementation_type implementation_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_IO_OBJECT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_random_access_file.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_random_access_file.hpp
deleted file mode 100644
index 44c2cf5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_random_access_file.hpp
+++ /dev/null
@@ -1,689 +0,0 @@
-//
-// basic_random_access_file.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
-#define ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/basic_file.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
-#define ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Executor = any_io_executor>
-class basic_random_access_file;
-
-#endif // !defined(ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
-
-/// Provides random-access file functionality.
-/**
- * The basic_random_access_file class template provides asynchronous and
- * blocking random-access file functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c read_some_at and @c write_some_at operations are thread safe
- * with respect to each other, if the underlying operating system calls are
- * also thread safe. This means that it is permitted to perform concurrent
- * calls to these synchronous operations on a single file object. Other
- * synchronous operations, such as @c open or @c close, are not thread safe.
- */
-template <typename Executor>
-class basic_random_access_file
-  : public basic_file<Executor>
-{
-private:
-  class initiate_async_write_some_at;
-  class initiate_async_read_some_at;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the file type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The file type when rebound to the specified executor.
-    typedef basic_random_access_file<Executor1> other;
-  };
-
-  /// The native representation of a file.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// Construct a basic_random_access_file without opening it.
-  /**
-   * This constructor initialises a file without opening it. The file needs to
-   * be opened before data can be read from or or written to it.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   */
-  explicit basic_random_access_file(const executor_type& ex)
-    : basic_file<Executor>(ex)
-  {
-  }
-
-  /// Construct a basic_random_access_file without opening it.
-  /**
-   * This constructor initialises a file without opening it. The file needs to
-   * be opened before data can be read from or or written to it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   */
-  template <typename ExecutionContext>
-  explicit basic_random_access_file(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context)
-  {
-  }
-
-  /// Construct and open a basic_random_access_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_random_access_file(const executor_type& ex,
-      const char* path, file_base::flags open_flags)
-    : basic_file<Executor>(ex, path, open_flags)
-  {
-  }
-
-  /// Construct and open a basic_random_access_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_random_access_file(ExecutionContext& context,
-      const char* path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context, path, open_flags)
-  {
-  }
-
-  /// Construct and open a basic_random_access_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_random_access_file(const executor_type& ex,
-      const std::string& path, file_base::flags open_flags)
-    : basic_file<Executor>(ex, path, open_flags)
-  {
-  }
-
-  /// Construct and open a basic_random_access_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_random_access_file(ExecutionContext& context,
-      const std::string& path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context, path, open_flags)
-  {
-  }
-
-  /// Construct a basic_random_access_file on an existing native file.
-  /**
-   * This constructor initialises a random-access file object to hold an
-   * existing native file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param native_file The new underlying file implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_random_access_file(const executor_type& ex,
-      const native_handle_type& native_file)
-    : basic_file<Executor>(ex, native_file)
-  {
-  }
-
-  /// Construct a basic_random_access_file on an existing native file.
-  /**
-   * This constructor initialises a random-access file object to hold an
-   * existing native file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param native_file The new underlying file implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_random_access_file(ExecutionContext& context,
-      const native_handle_type& native_file,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context, native_file)
-  {
-  }
-
-  /// Move-construct a basic_random_access_file from another.
-  /**
-   * This constructor moves a random-access file from one object to another.
-   *
-   * @param other The other basic_random_access_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_file(const executor_type&)
-   * constructor.
-   */
-  basic_random_access_file(basic_random_access_file&& other) noexcept
-    : basic_file<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_random_access_file from another.
-  /**
-   * This assignment operator moves a random-access file from one object to
-   * another.
-   *
-   * @param other The other basic_random_access_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_file(const executor_type&)
-   * constructor.
-   */
-  basic_random_access_file& operator=(basic_random_access_file&& other)
-  {
-    basic_file<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_random_access_file from a file of another executor
-  /// type.
-  /**
-   * This constructor moves a random-access file from one object to another.
-   *
-   * @param other The other basic_random_access_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_file(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_random_access_file(basic_random_access_file<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_random_access_file from a file of another executor
-  /// type.
-  /**
-   * This assignment operator moves a random-access file from one object to
-   * another.
-   *
-   * @param other The other basic_random_access_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_file(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_random_access_file&
-  > operator=(basic_random_access_file<Executor1>&& other)
-  {
-    basic_file<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the file.
-  /**
-   * This function destroys the file, cancelling any outstanding asynchronous
-   * operations associated with the file as if by calling @c cancel.
-   */
-  ~basic_random_access_file()
-  {
-  }
-
-  /// Write some data to the handle at the specified offset.
-  /**
-   * This function is used to write data to the random-access handle. The
-   * function call will block until one or more bytes of the data has been
-   * written successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the end of the file was reached.
-   *
-   * @note The write_some_at operation may not write all of the data. Consider
-   * using the @ref write_at function if you need to ensure that all data is
-   * written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.write_some_at(42, asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some_at(uint64_t offset,
-      const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().write_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-    asio::detail::throw_error(ec, "write_some_at");
-    return s;
-  }
-
-  /// Write some data to the handle at the specified offset.
-  /**
-   * This function is used to write data to the random-access handle. The
-   * function call will block until one or more bytes of the data has been
-   * written successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not write all of the data to the
-   * file. Consider using the @ref write_at function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some_at(uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return this->impl_.get_service().write_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-  }
-
-  /// Start an asynchronous write at the specified offset.
-  /**
-   * This function is used to asynchronously write data to the random-access
-   * handle. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not write all of the data to the file.
-   * Consider using the @ref async_write_at function if you need to ensure that
-   * all data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_write_some_at(42, asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some_at(uint64_t offset, const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some_at>(), token, offset, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some_at(this), token, offset, buffers);
-  }
-
-  /// Read some data from the handle at the specified offset.
-  /**
-   * This function is used to read data from the random-access handle. The
-   * function call will block until one or more bytes of data has been read
-   * successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the end of the file was reached.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read_at function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.read_some_at(42, asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some_at(uint64_t offset,
-      const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().read_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-    asio::detail::throw_error(ec, "read_some_at");
-    return s;
-  }
-
-  /// Read some data from the handle at the specified offset.
-  /**
-   * This function is used to read data from the random-access handle. The
-   * function call will block until one or more bytes of data has been read
-   * successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read_at function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some_at(uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return this->impl_.get_service().read_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-  }
-
-  /// Start an asynchronous read at the specified offset.
-  /**
-   * This function is used to asynchronously read data from the random-access
-   * handle. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read_at function if you need to ensure that
-   * the requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_read_some_at(42, asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some_at(uint64_t offset, const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some_at>(), token, offset, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some_at(this), token, offset, buffers);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_random_access_file(const basic_random_access_file&) = delete;
-  basic_random_access_file& operator=(
-      const basic_random_access_file&) = delete;
-
-  class initiate_async_write_some_at
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some_at(basic_random_access_file* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        uint64_t offset, const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some_at(
-          self_->impl_.get_implementation(), offset, buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_random_access_file* self_;
-  };
-
-  class initiate_async_read_some_at
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some_at(basic_random_access_file* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        uint64_t offset, const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some_at(
-          self_->impl_.get_implementation(), offset, buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_random_access_file* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_raw_socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_raw_socket.hpp
deleted file mode 100644
index 171735c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_raw_socket.hpp
+++ /dev/null
@@ -1,1356 +0,0 @@
-//
-// basic_raw_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_RAW_SOCKET_HPP
-#define ASIO_BASIC_RAW_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_RAW_SOCKET_FWD_DECL)
-#define ASIO_BASIC_RAW_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_raw_socket;
-
-#endif // !defined(ASIO_BASIC_RAW_SOCKET_FWD_DECL)
-
-/// Provides raw-oriented socket functionality.
-/**
- * The basic_raw_socket class template provides asynchronous and blocking
- * raw-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c send, @c send_to, @c receive, @c receive_from, @c connect,
- * and @c shutdown operations are thread safe with respect to each other, if
- * the underlying operating system calls are also thread safe. This means that
- * it is permitted to perform concurrent calls to these synchronous operations
- * on a single socket object. Other synchronous operations, such as @c open or
- * @c close, are not thread safe.
- */
-template <typename Protocol, typename Executor>
-class basic_raw_socket
-  : public basic_socket<Protocol, Executor>
-{
-private:
-  class initiate_async_send;
-  class initiate_async_send_to;
-  class initiate_async_receive;
-  class initiate_async_receive_from;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the socket type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_raw_socket<Protocol, Executor1> other;
-  };
-
-  /// The native representation of a socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_socket<Protocol,
-    Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_raw_socket without opening it.
-  /**
-   * This constructor creates a raw socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_raw_socket(const executor_type& ex)
-    : basic_socket<Protocol, Executor>(ex)
-  {
-  }
-
-  /// Construct a basic_raw_socket without opening it.
-  /**
-   * This constructor creates a raw socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   */
-  template <typename ExecutionContext>
-  explicit basic_raw_socket(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context)
-  {
-  }
-
-  /// Construct and open a basic_raw_socket.
-  /**
-   * This constructor creates and opens a raw socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(const executor_type& ex, const protocol_type& protocol)
-    : basic_socket<Protocol, Executor>(ex, protocol)
-  {
-  }
-
-  /// Construct and open a basic_raw_socket.
-  /**
-   * This constructor creates and opens a raw socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_raw_socket(ExecutionContext& context, const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_socket<Protocol, Executor>(context, protocol)
-  {
-  }
-
-  /// Construct a basic_raw_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a raw socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the raw
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(const executor_type& ex, const endpoint_type& endpoint)
-    : basic_socket<Protocol, Executor>(ex, endpoint)
-  {
-  }
-
-  /// Construct a basic_raw_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a raw socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the raw
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_raw_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, endpoint)
-  {
-  }
-
-  /// Construct a basic_raw_socket on an existing native socket.
-  /**
-   * This constructor creates a raw socket object to hold an existing
-   * native socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(const executor_type& ex,
-      const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, Executor>(ex, protocol, native_socket)
-  {
-  }
-
-  /// Construct a basic_raw_socket on an existing native socket.
-  /**
-   * This constructor creates a raw socket object to hold an existing
-   * native socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_raw_socket(ExecutionContext& context,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, protocol, native_socket)
-  {
-  }
-
-  /// Move-construct a basic_raw_socket from another.
-  /**
-   * This constructor moves a raw socket from one object to another.
-   *
-   * @param other The other basic_raw_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_raw_socket(const executor_type&)
-   * constructor.
-   */
-  basic_raw_socket(basic_raw_socket&& other) noexcept
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_raw_socket from another.
-  /**
-   * This assignment operator moves a raw socket from one object to another.
-   *
-   * @param other The other basic_raw_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_raw_socket(const executor_type&)
-   * constructor.
-   */
-  basic_raw_socket& operator=(basic_raw_socket&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_raw_socket from a socket of another protocol
-  /// type.
-  /**
-   * This constructor moves a raw socket from one object to another.
-   *
-   * @param other The other basic_raw_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_raw_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_raw_socket(basic_raw_socket<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_raw_socket from a socket of another protocol type.
-  /**
-   * This assignment operator moves a raw socket from one object to another.
-   *
-   * @param other The other basic_raw_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_raw_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_raw_socket&
-  > operator=(basic_raw_socket<Protocol1, Executor1>&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the socket.
-  /**
-   * This function destroys the socket, cancelling any outstanding asynchronous
-   * operations associated with the socket as if by calling @c cancel.
-   */
-  ~basic_raw_socket()
-  {
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code socket.send(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to asynchronously send data on the raw socket. It is
-   * an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected raw
-   * socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to asynchronously send data on the raw socket. It is
-   * an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected raw
-   * socket.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token, buffers, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token, buffers, flags);
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.send_to(asio::buffer(data, size), destination);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send_to(
-        this->impl_.get_implementation(), buffers, destination, 0, ec);
-    asio::detail::throw_error(ec, "send_to");
-    return s;
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send_to(
-        this->impl_.get_implementation(), buffers, destination, flags, ec);
-    asio::detail::throw_error(ec, "send_to");
-    return s;
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().send_to(this->impl_.get_implementation(),
-        buffers, destination, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.async_send_to(
-   *     asio::buffer(data, size), destination, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send_to>(), token, buffers,
-          destination, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send_to(this), token, buffers,
-        destination, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send_to>(), token,
-          buffers, destination, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send_to(this), token,
-        buffers, destination, flags);
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.receive(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the raw
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * raw socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the raw
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * raw socket.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken
-          = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token, buffers, flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token, buffers, flags);
-  }
-
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * asio::ip::udp::endpoint sender_endpoint;
-   * socket.receive_from(
-   *     asio::buffer(data, size), sender_endpoint);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, 0, ec);
-    asio::detail::throw_error(ec, "receive_from");
-    return s;
-  }
-
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, flags, ec);
-    asio::detail::throw_error(ec, "receive_from");
-    return s;
-  }
-
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive_from(
-        this->impl_.get_implementation(), buffers, sender_endpoint, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive raw data. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.async_receive_from(
-   *     asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint,
-      ReadToken&& token
-        = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_from>(), token, buffers,
-          &sender_endpoint, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_from(this), token, buffers,
-        &sender_endpoint, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive raw data. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken
-          = default_completion_token_t<executor_type>>
-  auto async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_from>(), token,
-          buffers, &sender_endpoint, flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_from(this), token,
-        buffers, &sender_endpoint, flags);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_raw_socket(const basic_raw_socket&) = delete;
-  basic_raw_socket& operator=(const basic_raw_socket&) = delete;
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_raw_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_raw_socket* self_;
-  };
-
-  class initiate_async_send_to
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send_to(basic_raw_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers, const endpoint_type& destination,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send_to(
-          self_->impl_.get_implementation(), buffers, destination,
-          flags, handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_raw_socket* self_;
-  };
-
-  class initiate_async_receive
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive(basic_raw_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_raw_socket* self_;
-  };
-
-  class initiate_async_receive_from
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive_from(basic_raw_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers, endpoint_type* sender_endpoint,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive_from(
-          self_->impl_.get_implementation(), buffers, *sender_endpoint,
-          flags, handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_raw_socket* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_RAW_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_readable_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_readable_pipe.hpp
deleted file mode 100644
index d45f0a7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_readable_pipe.hpp
+++ /dev/null
@@ -1,626 +0,0 @@
-//
-// basic_readable_pipe.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_READABLE_PIPE_HPP
-#define ASIO_BASIC_READABLE_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <string>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_handle_service.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_descriptor_service.hpp"
-#else
-# include "asio/detail/reactive_descriptor_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides pipe functionality.
-/**
- * The basic_readable_pipe class provides a wrapper over pipe
- * functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_readable_pipe
-{
-private:
-  class initiate_async_read_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the pipe type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The pipe type when rebound to the specified executor.
-    typedef basic_readable_pipe<Executor1> other;
-  };
-
-  /// The native representation of a pipe.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_handle_service::native_handle_type
-    native_handle_type;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef detail::io_uring_descriptor_service::native_handle_type
-    native_handle_type;
-#else
-  typedef detail::reactive_descriptor_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// A basic_readable_pipe is always the lowest layer.
-  typedef basic_readable_pipe lowest_layer_type;
-
-  /// Construct a basic_readable_pipe without opening it.
-  /**
-   * This constructor creates a pipe without opening it.
-   *
-   * @param ex The I/O executor that the pipe will use, by default, to dispatch
-   * handlers for any asynchronous operations performed on the pipe.
-   */
-  explicit basic_readable_pipe(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a basic_readable_pipe without opening it.
-  /**
-   * This constructor creates a pipe without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the pipe will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the pipe.
-   */
-  template <typename ExecutionContext>
-  explicit basic_readable_pipe(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct a basic_readable_pipe on an existing native pipe.
-  /**
-   * This constructor creates a pipe object to hold an existing native
-   * pipe.
-   *
-   * @param ex The I/O executor that the pipe will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_readable_pipe(const executor_type& ex,
-      const native_handle_type& native_pipe)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_readable_pipe on an existing native pipe.
-  /**
-   * This constructor creates a pipe object to hold an existing native
-   * pipe.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the pipe will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_readable_pipe(ExecutionContext& context,
-      const native_handle_type& native_pipe,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_readable_pipe from another.
-  /**
-   * This constructor moves a pipe from one object to another.
-   *
-   * @param other The other basic_readable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_readable_pipe(const executor_type&)
-   * constructor.
-   */
-  basic_readable_pipe(basic_readable_pipe&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_readable_pipe from another.
-  /**
-   * This assignment operator moves a pipe from one object to another.
-   *
-   * @param other The other basic_readable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_readable_pipe(const executor_type&)
-   * constructor.
-   */
-  basic_readable_pipe& operator=(basic_readable_pipe&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All pipes have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_readable_pipe;
-
-  /// Move-construct a basic_readable_pipe from a pipe of another executor type.
-  /**
-   * This constructor moves a pipe from one object to another.
-   *
-   * @param other The other basic_readable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_readable_pipe(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_readable_pipe(basic_readable_pipe<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_readable_pipe from a pipe of another executor type.
-  /**
-   * This assignment operator moves a pipe from one object to another.
-   *
-   * @param other The other basic_readable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_readable_pipe(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_readable_pipe&
-  > operator=(basic_readable_pipe<Executor1>&& other)
-  {
-    basic_readable_pipe tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the pipe.
-  /**
-   * This function destroys the pipe, cancelling any outstanding
-   * asynchronous wait operations associated with the pipe as if by
-   * calling @c cancel.
-   */
-  ~basic_readable_pipe()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a basic_readable_pipe cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a basic_readable_pipe cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Assign an existing native pipe to the pipe.
-  /*
-   * This function opens the pipe to hold an existing native pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& native_pipe)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native pipe to the pipe.
-  /*
-   * This function opens the pipe to hold an existing native pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the pipe is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the pipe.
-  /**
-   * This function is used to close the pipe. Any asynchronous read operations
-   * will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the pipe.
-  /**
-   * This function is used to close the pipe. Any asynchronous read operations
-   * will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native pipe.
-  /**
-   * This function causes all outstanding asynchronous read operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native pipe is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native pipe.
-  /**
-   * This function causes all outstanding asynchronous read operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native pipe is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native pipe representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * pipe. This is intended to allow access to native pipe
-   * functionality that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the pipe.
-  /**
-   * This function causes all outstanding asynchronous read operations to finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the pipe.
-  /**
-   * This function causes all outstanding asynchronous read operations to finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Read some data from the pipe.
-  /**
-   * This function is used to read data from the pipe. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_readable_pipe.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().read_some(
-        impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the pipe.
-  /**
-   * This function is used to read data from the pipe. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().read_some(
-        impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the pipe. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_readable_pipe.async_read_some(
-   *     asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_readable_pipe(const basic_readable_pipe&) = delete;
-  basic_readable_pipe& operator=(const basic_readable_pipe&) = delete;
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some(basic_readable_pipe* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_readable_pipe* self_;
-  };
-
-#if defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
-#else
-  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PIPE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_READABLE_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_seq_packet_socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_seq_packet_socket.hpp
deleted file mode 100644
index 86ea534..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_seq_packet_socket.hpp
+++ /dev/null
@@ -1,823 +0,0 @@
-//
-// basic_seq_packet_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
-#define ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL)
-#define ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_seq_packet_socket;
-
-#endif // !defined(ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL)
-
-/// Provides sequenced packet socket functionality.
-/**
- * The basic_seq_packet_socket class template provides asynchronous and blocking
- * sequenced packet socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c send, @c receive, @c connect, and @c shutdown operations are
- * thread safe with respect to each other, if the underlying operating system
- * calls are also thread safe. This means that it is permitted to perform
- * concurrent calls to these synchronous operations on a single socket object.
- * Other synchronous operations, such as @c open or @c close, are not thread
- * safe.
- */
-template <typename Protocol, typename Executor>
-class basic_seq_packet_socket
-  : public basic_socket<Protocol, Executor>
-{
-private:
-  class initiate_async_send;
-  class initiate_async_receive_with_flags;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the socket type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_seq_packet_socket<Protocol, Executor1> other;
-  };
-
-  /// The native representation of a socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_socket<Protocol,
-    Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_seq_packet_socket without opening it.
-  /**
-   * This constructor creates a sequenced packet socket without opening it. The
-   * socket needs to be opened and then connected or accepted before data can
-   * be sent or received on it.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_seq_packet_socket(const executor_type& ex)
-    : basic_socket<Protocol, Executor>(ex)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket without opening it.
-  /**
-   * This constructor creates a sequenced packet socket without opening it. The
-   * socket needs to be opened and then connected or accepted before data can
-   * be sent or received on it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   */
-  template <typename ExecutionContext>
-  explicit basic_seq_packet_socket(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context)
-  {
-  }
-
-  /// Construct and open a basic_seq_packet_socket.
-  /**
-   * This constructor creates and opens a sequenced_packet socket. The socket
-   * needs to be connected or accepted before data can be sent or received on
-   * it.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(const executor_type& ex,
-      const protocol_type& protocol)
-    : basic_socket<Protocol, Executor>(ex, protocol)
-  {
-  }
-
-  /// Construct and open a basic_seq_packet_socket.
-  /**
-   * This constructor creates and opens a sequenced_packet socket. The socket
-   * needs to be connected or accepted before data can be sent or received on
-   * it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_seq_packet_socket(ExecutionContext& context,
-      const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_socket<Protocol, Executor>(context, protocol)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket, opening it and binding it to the
-  /// given local endpoint.
-  /**
-   * This constructor creates a sequenced packet socket and automatically opens
-   * it bound to the specified endpoint on the local machine. The protocol used
-   * is the protocol associated with the given endpoint.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the sequenced
-   * packet socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(const executor_type& ex,
-      const endpoint_type& endpoint)
-    : basic_socket<Protocol, Executor>(ex, endpoint)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket, opening it and binding it to the
-  /// given local endpoint.
-  /**
-   * This constructor creates a sequenced packet socket and automatically opens
-   * it bound to the specified endpoint on the local machine. The protocol used
-   * is the protocol associated with the given endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the sequenced
-   * packet socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_seq_packet_socket(ExecutionContext& context,
-      const endpoint_type& endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, endpoint)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket on an existing native socket.
-  /**
-   * This constructor creates a sequenced packet socket object to hold an
-   * existing native socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(const executor_type& ex,
-      const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, Executor>(ex, protocol, native_socket)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket on an existing native socket.
-  /**
-   * This constructor creates a sequenced packet socket object to hold an
-   * existing native socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_seq_packet_socket(ExecutionContext& context,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, protocol, native_socket)
-  {
-  }
-
-  /// Move-construct a basic_seq_packet_socket from another.
-  /**
-   * This constructor moves a sequenced packet socket from one object to
-   * another.
-   *
-   * @param other The other basic_seq_packet_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_seq_packet_socket(const executor_type&)
-   * constructor.
-   */
-  basic_seq_packet_socket(basic_seq_packet_socket&& other) noexcept
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_seq_packet_socket from another.
-  /**
-   * This assignment operator moves a sequenced packet socket from one object to
-   * another.
-   *
-   * @param other The other basic_seq_packet_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_seq_packet_socket(const executor_type&)
-   * constructor.
-   */
-  basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_seq_packet_socket from a socket of another protocol
-  /// type.
-  /**
-   * This constructor moves a sequenced packet socket from one object to
-   * another.
-   *
-   * @param other The other basic_seq_packet_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_seq_packet_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_seq_packet_socket from a socket of another protocol
-  /// type.
-  /**
-   * This assignment operator moves a sequenced packet socket from one object to
-   * another.
-   *
-   * @param other The other basic_seq_packet_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_seq_packet_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_seq_packet_socket&
-  > operator=(basic_seq_packet_socket<Protocol1, Executor1>&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the socket.
-  /**
-   * This function destroys the socket, cancelling any outstanding asynchronous
-   * operations associated with the socket as if by calling @c cancel.
-   */
-  ~basic_seq_packet_socket()
-  {
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the sequenced packet socket. The
-   * function call will block until the data has been sent successfully, or an
-   * until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(asio::buffer(data, size), 0);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the sequenced packet socket. The
-   * function call will block the data has been sent successfully, or an until
-   * error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent. Returns 0 if an error occurred.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the sequenced packet
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), 0, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken
-          = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags,
-      WriteToken&& token
-        = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token, buffers, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token, buffers, flags);
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the sequenced packet socket. The
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size), out_flags);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags& out_flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_with_flags(
-        this->impl_.get_implementation(), buffers, 0, out_flags, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the sequenced packet socket. The
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size), 0, out_flags);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive_with_flags(
-        this->impl_.get_implementation(), buffers, in_flags, out_flags, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the sequenced packet socket. The
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received. Returns 0 if an error occurred.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive_with_flags(
-        this->impl_.get_implementation(), buffers, in_flags, out_flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the sequenced
-   * packet socket. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param out_flags Once the asynchronous operation completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), out_flags, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags& out_flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_with_flags>(), token,
-          buffers, socket_base::message_flags(0), &out_flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_with_flags(this), token,
-        buffers, socket_base::message_flags(0), &out_flags);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the sequenced
-   * data socket. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags Once the asynchronous operation completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(
-   *     asio::buffer(data, size),
-   *     0, out_flags, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive_with_flags>(),
-          token, buffers, in_flags, &out_flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive_with_flags(this),
-        token, buffers, in_flags, &out_flags);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_seq_packet_socket(const basic_seq_packet_socket&) = delete;
-  basic_seq_packet_socket& operator=(
-      const basic_seq_packet_socket&) = delete;
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_seq_packet_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_seq_packet_socket* self_;
-  };
-
-  class initiate_async_receive_with_flags
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive_with_flags(basic_seq_packet_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers,
-        socket_base::message_flags in_flags,
-        socket_base::message_flags* out_flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive_with_flags(
-          self_->impl_.get_implementation(), buffers, in_flags,
-          *out_flags, handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_seq_packet_socket* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_serial_port.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_serial_port.hpp
deleted file mode 100644
index 437dbcd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_serial_port.hpp
+++ /dev/null
@@ -1,987 +0,0 @@
-//
-// basic_serial_port.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SERIAL_PORT_HPP
-#define ASIO_BASIC_SERIAL_PORT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <string>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/serial_port_base.hpp"
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_serial_port_service.hpp"
-#else
-# include "asio/detail/posix_serial_port_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides serial port functionality.
-/**
- * The basic_serial_port class provides a wrapper over serial port
- * functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_serial_port
-  : public serial_port_base
-{
-private:
-  class initiate_async_write_some;
-  class initiate_async_read_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the serial port type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The serial port type when rebound to the specified executor.
-    typedef basic_serial_port<Executor1> other;
-  };
-
-  /// The native representation of a serial port.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_serial_port_service::native_handle_type
-    native_handle_type;
-#else
-  typedef detail::posix_serial_port_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// A basic_basic_serial_port is always the lowest layer.
-  typedef basic_serial_port lowest_layer_type;
-
-  /// Construct a basic_serial_port without opening it.
-  /**
-   * This constructor creates a serial port without opening it.
-   *
-   * @param ex The I/O executor that the serial port will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * serial port.
-   */
-  explicit basic_serial_port(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a basic_serial_port without opening it.
-  /**
-   * This constructor creates a serial port without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the serial port will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the serial port.
-   */
-  template <typename ExecutionContext>
-  explicit basic_serial_port(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param ex The I/O executor that the serial port will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * serial port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  basic_serial_port(const executor_type& ex, const char* device)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the serial port will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the serial port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  template <typename ExecutionContext>
-  basic_serial_port(ExecutionContext& context, const char* device,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param ex The I/O executor that the serial port will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * serial port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  basic_serial_port(const executor_type& ex, const std::string& device)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the serial port will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the serial port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  template <typename ExecutionContext>
-  basic_serial_port(ExecutionContext& context, const std::string& device,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_serial_port on an existing native serial port.
-  /**
-   * This constructor creates a serial port object to hold an existing native
-   * serial port.
-   *
-   * @param ex The I/O executor that the serial port will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_serial_port(const executor_type& ex,
-      const native_handle_type& native_serial_port)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_serial_port, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_serial_port on an existing native serial port.
-  /**
-   * This constructor creates a serial port object to hold an existing native
-   * serial port.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the serial port will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_serial_port(ExecutionContext& context,
-      const native_handle_type& native_serial_port,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_serial_port, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_serial_port from another.
-  /**
-   * This constructor moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_serial_port(const executor_type&)
-   * constructor.
-   */
-  basic_serial_port(basic_serial_port&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_serial_port from another.
-  /**
-   * This assignment operator moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_serial_port(const executor_type&)
-   * constructor.
-   */
-  basic_serial_port& operator=(basic_serial_port&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All serial ports have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_serial_port;
-
-  /// Move-construct a basic_serial_port from a serial port of another executor
-  /// type.
-  /**
-   * This constructor moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_serial_port(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_serial_port(basic_serial_port<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_serial_port from a serial port of another executor
-  /// type.
-  /**
-   * This assignment operator moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_serial_port(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_serial_port&
-  > operator=(basic_serial_port<Executor1>&& other)
-  {
-    basic_serial_port tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the serial port.
-  /**
-   * This function destroys the serial port, cancelling any outstanding
-   * asynchronous wait operations associated with the serial port as if by
-   * calling @c cancel.
-   */
-  ~basic_serial_port()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a basic_serial_port cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a basic_serial_port cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Open the serial port using the specified device name.
-  /**
-   * This function opens the serial port for the specified device name.
-   *
-   * @param device The platform-specific device name.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void open(const std::string& device)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Open the serial port using the specified device name.
-  /**
-   * This function opens the serial port using the given platform-specific
-   * device name.
-   *
-   * @param device The platform-specific device name.
-   *
-   * @param ec Set the indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID open(const std::string& device,
-      asio::error_code& ec)
-  {
-    impl_.get_service().open(impl_.get_implementation(), device, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Assign an existing native serial port to the serial port.
-  /*
-   * This function opens the serial port to hold an existing native serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& native_serial_port)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_serial_port, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native serial port to the serial port.
-  /*
-   * This function opens the serial port to hold an existing native serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_serial_port,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_serial_port, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the serial port is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the serial port.
-  /**
-   * This function is used to close the serial port. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the serial port.
-  /**
-   * This function is used to close the serial port. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the native serial port representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * serial port. This is intended to allow access to native serial port
-   * functionality that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the serial port.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the serial port.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Send a break sequence to the serial port.
-  /**
-   * This function causes a break sequence of platform-specific duration to be
-   * sent out the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void send_break()
-  {
-    asio::error_code ec;
-    impl_.get_service().send_break(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "send_break");
-  }
-
-  /// Send a break sequence to the serial port.
-  /**
-   * This function causes a break sequence of platform-specific duration to be
-   * sent out the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID send_break(asio::error_code& ec)
-  {
-    impl_.get_service().send_break(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Set an option on the serial port.
-  /**
-   * This function is used to set an option on the serial port.
-   *
-   * @param option The option value to be set on the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa SettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename SettableSerialPortOption>
-  void set_option(const SettableSerialPortOption& option)
-  {
-    asio::error_code ec;
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "set_option");
-  }
-
-  /// Set an option on the serial port.
-  /**
-   * This function is used to set an option on the serial port.
-   *
-   * @param option The option value to be set on the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa SettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename SettableSerialPortOption>
-  ASIO_SYNC_OP_VOID set_option(const SettableSerialPortOption& option,
-      asio::error_code& ec)
-  {
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get an option from the serial port.
-  /**
-   * This function is used to get the current value of an option on the serial
-   * port.
-   *
-   * @param option The option value to be obtained from the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa GettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename GettableSerialPortOption>
-  void get_option(GettableSerialPortOption& option) const
-  {
-    asio::error_code ec;
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "get_option");
-  }
-
-  /// Get an option from the serial port.
-  /**
-   * This function is used to get the current value of an option on the serial
-   * port.
-   *
-   * @param option The option value to be obtained from the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa GettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename GettableSerialPortOption>
-  ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
-      asio::error_code& ec) const
-  {
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Write some data to the serial port.
-  /**
-   * This function is used to write data to the serial port. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_serial_port.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().write_some(
-        impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the serial port.
-  /**
-   * This function is used to write data to the serial port. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().write_some(
-        impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the serial port.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_serial_port.async_write_some(
-   *     asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some>(), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-  /// Read some data from the serial port.
-  /**
-   * This function is used to read data from the serial port. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_serial_port.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().read_some(
-        impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the serial port.
-  /**
-   * This function is used to read data from the serial port. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().read_some(
-        impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the serial port.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * basic_serial_port.async_read_some(
-   *     asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_serial_port(const basic_serial_port&) = delete;
-  basic_serial_port& operator=(const basic_serial_port&) = delete;
-
-  class initiate_async_write_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some(basic_serial_port* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_serial_port* self_;
-  };
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some(basic_serial_port* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_serial_port* self_;
-  };
-
-#if defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<detail::win_iocp_serial_port_service, Executor> impl_;
-#else
-  detail::io_object_impl<detail::posix_serial_port_service, Executor> impl_;
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_SERIAL_PORT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_signal_set.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_signal_set.hpp
deleted file mode 100644
index 1da4d7e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_signal_set.hpp
+++ /dev/null
@@ -1,648 +0,0 @@
-//
-// basic_signal_set.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SIGNAL_SET_HPP
-#define ASIO_BASIC_SIGNAL_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/signal_set_service.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/signal_set_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides signal functionality.
-/**
- * The basic_signal_set class provides the ability to perform an asynchronous
- * wait for one or more signals to occur.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Example
- * Performing an asynchronous wait:
- * @code
- * void handler(
- *     const asio::error_code& error,
- *     int signal_number)
- * {
- *   if (!error)
- *   {
- *     // A signal occurred.
- *   }
- * }
- *
- * ...
- *
- * // Construct a signal set registered for process termination.
- * asio::signal_set signals(my_context, SIGINT, SIGTERM);
- *
- * // Start an asynchronous wait for one of the signals to occur.
- * signals.async_wait(handler);
- * @endcode
- *
- * @par Queueing of signal notifications
- *
- * If a signal is registered with a signal_set, and the signal occurs when
- * there are no waiting handlers, then the signal notification is queued. The
- * next async_wait operation on that signal_set will dequeue the notification.
- * If multiple notifications are queued, subsequent async_wait operations
- * dequeue them one at a time. Signal notifications are dequeued in order of
- * ascending signal number.
- *
- * If a signal number is removed from a signal_set (using the @c remove or @c
- * erase member functions) then any queued notifications for that signal are
- * discarded.
- *
- * @par Multiple registration of signals
- *
- * The same signal number may be registered with different signal_set objects.
- * When the signal occurs, one handler is called for each signal_set object.
- *
- * Note that multiple registration only works for signals that are registered
- * using Asio. The application must not also register a signal handler using
- * functions such as @c signal() or @c sigaction().
- *
- * @par Signal masking on POSIX platforms
- *
- * POSIX allows signals to be blocked using functions such as @c sigprocmask()
- * and @c pthread_sigmask(). For signals to be delivered, programs must ensure
- * that any signals registered using signal_set objects are unblocked in at
- * least one thread.
- */
-template <typename Executor = any_io_executor>
-class basic_signal_set : public signal_set_base
-{
-private:
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the signal set type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The signal set type when rebound to the specified executor.
-    typedef basic_signal_set<Executor1> other;
-  };
-
-  /// Construct a signal set without adding any signals.
-  /**
-   * This constructor creates a signal set without registering for any signals.
-   *
-   * @param ex The I/O executor that the signal set will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * signal set.
-   */
-  explicit basic_signal_set(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a signal set without adding any signals.
-  /**
-   * This constructor creates a signal set without registering for any signals.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the signal set will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the signal set.
-   */
-  template <typename ExecutionContext>
-  explicit basic_signal_set(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct a signal set and add one signal.
-  /**
-   * This constructor creates a signal set and registers for one signal.
-   *
-   * @param ex The I/O executor that the signal set will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * signal set.
-   *
-   * @param signal_number_1 The signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(ex);
-   * signals.add(signal_number_1); @endcode
-   */
-  basic_signal_set(const executor_type& ex, int signal_number_1)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add one signal.
-  /**
-   * This constructor creates a signal set and registers for one signal.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the signal set will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the signal set.
-   *
-   * @param signal_number_1 The signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(context);
-   * signals.add(signal_number_1); @endcode
-   */
-  template <typename ExecutionContext>
-  basic_signal_set(ExecutionContext& context, int signal_number_1,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add two signals.
-  /**
-   * This constructor creates a signal set and registers for two signals.
-   *
-   * @param ex The I/O executor that the signal set will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * signal set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(ex);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2); @endcode
-   */
-  basic_signal_set(const executor_type& ex, int signal_number_1,
-      int signal_number_2)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add two signals.
-  /**
-   * This constructor creates a signal set and registers for two signals.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the signal set will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the signal set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(context);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2); @endcode
-   */
-  template <typename ExecutionContext>
-  basic_signal_set(ExecutionContext& context, int signal_number_1,
-      int signal_number_2,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add three signals.
-  /**
-   * This constructor creates a signal set and registers for three signals.
-   *
-   * @param ex The I/O executor that the signal set will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * signal set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @param signal_number_3 The third signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(ex);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2);
-   * signals.add(signal_number_3); @endcode
-   */
-  basic_signal_set(const executor_type& ex, int signal_number_1,
-      int signal_number_2, int signal_number_3)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_3, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add three signals.
-  /**
-   * This constructor creates a signal set and registers for three signals.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the signal set will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the signal set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @param signal_number_3 The third signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code asio::signal_set signals(context);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2);
-   * signals.add(signal_number_3); @endcode
-   */
-  template <typename ExecutionContext>
-  basic_signal_set(ExecutionContext& context, int signal_number_1,
-      int signal_number_2, int signal_number_3,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
-    asio::detail::throw_error(ec, "add");
-    impl_.get_service().add(impl_.get_implementation(), signal_number_3, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Destroys the signal set.
-  /**
-   * This function destroys the signal set, cancelling any outstanding
-   * asynchronous wait operations associated with the signal set as if by
-   * calling @c cancel.
-   */
-  ~basic_signal_set()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Add a signal to a signal_set.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void add(int signal_number)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Add a signal to a signal_set.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID add(int signal_number,
-      asio::error_code& ec)
-  {
-    impl_.get_service().add(impl_.get_implementation(), signal_number, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Add a signal to a signal_set with the specified flags.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * Flags other than flags::dont_care require OS support for the @c sigaction
-   * call, and this function will fail with @c error::operation_not_supported if
-   * this is unavailable.
-   *
-   * The specified flags will conflict with a prior, active registration of the
-   * same signal, if either specified a flags value other than flags::dont_care.
-   * In this case, the @c add will fail with @c error::invalid_argument.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @param f Flags to modify the behaviour of the specified signal.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void add(int signal_number, flags_t f)
-  {
-    asio::error_code ec;
-    impl_.get_service().add(impl_.get_implementation(), signal_number, f, ec);
-    asio::detail::throw_error(ec, "add");
-  }
-
-  /// Add a signal to a signal_set with the specified flags.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * Flags other than flags::dont_care require OS support for the @c sigaction
-   * call, and this function will fail with @c error::operation_not_supported if
-   * this is unavailable.
-   *
-   * The specified flags will conflict with a prior, active registration of the
-   * same signal, if either specified a flags value other than flags::dont_care.
-   * In this case, the @c add will fail with @c error::invalid_argument.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @param f Flags to modify the behaviour of the specified signal.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID add(int signal_number, flags_t f,
-      asio::error_code& ec)
-  {
-    impl_.get_service().add(impl_.get_implementation(), signal_number, f, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Remove a signal from a signal_set.
-  /**
-   * This function removes the specified signal from the set. It has no effect
-   * if the signal is not in the set.
-   *
-   * @param signal_number The signal to be removed from the set.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Removes any notifications that have been queued for the specified
-   * signal number.
-   */
-  void remove(int signal_number)
-  {
-    asio::error_code ec;
-    impl_.get_service().remove(impl_.get_implementation(), signal_number, ec);
-    asio::detail::throw_error(ec, "remove");
-  }
-
-  /// Remove a signal from a signal_set.
-  /**
-   * This function removes the specified signal from the set. It has no effect
-   * if the signal is not in the set.
-   *
-   * @param signal_number The signal to be removed from the set.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Removes any notifications that have been queued for the specified
-   * signal number.
-   */
-  ASIO_SYNC_OP_VOID remove(int signal_number,
-      asio::error_code& ec)
-  {
-    impl_.get_service().remove(impl_.get_implementation(), signal_number, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Remove all signals from a signal_set.
-  /**
-   * This function removes all signals from the set. It has no effect if the set
-   * is already empty.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Removes all queued notifications.
-   */
-  void clear()
-  {
-    asio::error_code ec;
-    impl_.get_service().clear(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "clear");
-  }
-
-  /// Remove all signals from a signal_set.
-  /**
-   * This function removes all signals from the set. It has no effect if the set
-   * is already empty.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Removes all queued notifications.
-   */
-  ASIO_SYNC_OP_VOID clear(asio::error_code& ec)
-  {
-    impl_.get_service().clear(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Cancel all operations associated with the signal set.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the signal set. The handler for each cancelled
-   * operation will be invoked with the asio::error::operation_aborted
-   * error code.
-   *
-   * Cancellation does not alter the set of registered signals.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If a registered signal occurred before cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all operations associated with the signal set.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the signal set. The handler for each cancelled
-   * operation will be invoked with the asio::error::operation_aborted
-   * error code.
-   *
-   * Cancellation does not alter the set of registered signals.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note If a registered signal occurred before cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Start an asynchronous operation to wait for a signal to be delivered.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * signal set. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * For each call to async_wait(), the completion handler will be called
-   * exactly once. The completion handler will be called when:
-   *
-   * @li One of the registered signals in the signal set occurs; or
-   *
-   * @li The signal set was cancelled, in which case the handler is passed the
-   * error code asio::error::operation_aborted.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the wait completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   int signal_number // Indicates which signal occurred.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, int) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, int))
-      SignalToken = default_completion_token_t<executor_type>>
-  auto async_wait(
-      SignalToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<SignalToken, void (asio::error_code, int)>(
-        declval<initiate_async_wait>(), token))
-  {
-    return async_initiate<SignalToken, void (asio::error_code, int)>(
-        initiate_async_wait(this), token);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_signal_set(const basic_signal_set&) = delete;
-  basic_signal_set& operator=(const basic_signal_set&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_signal_set* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename SignalHandler>
-    void operator()(SignalHandler&& handler) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a SignalHandler.
-      ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
-
-      detail::non_const_lvalue<SignalHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(),
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_signal_set* self_;
-  };
-
-  detail::io_object_impl<detail::signal_set_service, Executor> impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_SIGNAL_SET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket.hpp
deleted file mode 100644
index b999e87..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket.hpp
+++ /dev/null
@@ -1,1936 +0,0 @@
-//
-// basic_socket.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_HPP
-#define ASIO_BASIC_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/post.hpp"
-#include "asio/socket_base.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/null_socket_service.hpp"
-#elif defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_socket_service.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_socket_service.hpp"
-#else
-# include "asio/detail/reactive_socket_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_SOCKET_FWD_DECL)
-#define ASIO_BASIC_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_socket;
-
-#endif // !defined(ASIO_BASIC_SOCKET_FWD_DECL)
-
-/// Provides socket functionality.
-/**
- * The basic_socket class template provides functionality that is common to both
- * stream-oriented and datagram-oriented sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Protocol, typename Executor>
-class basic_socket
-  : public socket_base
-{
-private:
-  class initiate_async_connect;
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the socket type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_socket<Protocol, Executor1> other;
-  };
-
-  /// The native representation of a socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_WINDOWS_RUNTIME)
-  typedef typename detail::null_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef typename detail::win_iocp_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef typename detail::io_uring_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#else
-  typedef typename detail::reactive_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-#if !defined(ASIO_NO_EXTENSIONS)
-  /// A basic_socket is always the lowest layer.
-  typedef basic_socket<Protocol, Executor> lowest_layer_type;
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-  /// Construct a basic_socket without opening it.
-  /**
-   * This constructor creates a socket without opening it.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_socket(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a basic_socket without opening it.
-  /**
-   * This constructor creates a socket without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   */
-  template <typename ExecutionContext>
-  explicit basic_socket(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct and open a basic_socket.
-  /**
-   * This constructor creates and opens a socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket(const executor_type& ex, const protocol_type& protocol)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_socket.
-  /**
-   * This constructor creates and opens a socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_socket(ExecutionContext& context, const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_socket, opening it and binding it to the given local
-  /// endpoint.
-  /**
-   * This constructor creates a socket and automatically opens it bound to the
-   * specified endpoint on the local machine. The protocol used is the protocol
-   * associated with the given endpoint.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket will
-   * be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket(const executor_type& ex, const endpoint_type& endpoint)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-  }
-
-  /// Construct a basic_socket, opening it and binding it to the given local
-  /// endpoint.
-  /**
-   * This constructor creates a socket and automatically opens it bound to the
-   * specified endpoint on the local machine. The protocol used is the protocol
-   * associated with the given endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket will
-   * be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-  }
-
-  /// Construct a basic_socket on an existing native socket.
-  /**
-   * This constructor creates a socket object to hold an existing native socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket A native socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket(const executor_type& ex, const protocol_type& protocol,
-      const native_handle_type& native_socket)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_socket, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_socket on an existing native socket.
-  /**
-   * This constructor creates a socket object to hold an existing native socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket A native socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_socket(ExecutionContext& context, const protocol_type& protocol,
-      const native_handle_type& native_socket,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_socket, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_socket from another.
-  /**
-   * This constructor moves a socket from one object to another.
-   *
-   * @param other The other basic_socket object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket(const executor_type&) constructor.
-   */
-  basic_socket(basic_socket&& other) noexcept
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_socket from another.
-  /**
-   * This assignment operator moves a socket from one object to another.
-   *
-   * @param other The other basic_socket object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket(const executor_type&) constructor.
-   */
-  basic_socket& operator=(basic_socket&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All sockets have access to each other's implementations.
-  template <typename Protocol1, typename Executor1>
-  friend class basic_socket;
-
-  /// Move-construct a basic_socket from a socket of another protocol type.
-  /**
-   * This constructor moves a socket from one object to another.
-   *
-   * @param other The other basic_socket object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket(const executor_type&) constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_socket(basic_socket<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_socket from a socket of another protocol type.
-  /**
-   * This assignment operator moves a socket from one object to another.
-   *
-   * @param other The other basic_socket object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket(const executor_type&) constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_socket&
-  > operator=(basic_socket<Protocol1, Executor1>&& other)
-  {
-    basic_socket tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-#if !defined(ASIO_NO_EXTENSIONS)
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a basic_socket cannot contain any further layers, it simply
-   * returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a basic_socket cannot contain any further layers, it simply
-   * returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-  /// Open the socket using the specified protocol.
-  /**
-   * This function opens the socket so that it will use the specified protocol.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * socket.open(asio::ip::tcp::v4());
-   * @endcode
-   */
-  void open(const protocol_type& protocol = protocol_type())
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Open the socket using the specified protocol.
-  /**
-   * This function opens the socket so that it will use the specified protocol.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::error_code ec;
-   * socket.open(asio::ip::tcp::v4(), ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
-      asio::error_code& ec)
-  {
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Assign an existing native socket to the socket.
-  /*
-   * This function opens the socket to hold an existing native socket.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_socket A native socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const protocol_type& protocol,
-      const native_handle_type& native_socket)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_socket, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native socket to the socket.
-  /*
-   * This function opens the socket to hold an existing native socket.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_socket A native socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
-      const native_handle_type& native_socket, asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_socket, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the socket is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the socket.
-  /**
-   * This function is used to close the socket. Any asynchronous send, receive
-   * or connect operations will be cancelled immediately, and will complete
-   * with the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   *
-   * @note For portable behaviour with respect to graceful closure of a
-   * connected socket, call shutdown() before closing the socket.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the socket.
-  /**
-   * This function is used to close the socket. Any asynchronous send, receive
-   * or connect operations will be cancelled immediately, and will complete
-   * with the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::error_code ec;
-   * socket.close(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   *
-   * @note For portable behaviour with respect to graceful closure of a
-   * connected socket, call shutdown() before closing the socket.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native socket.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error. Ownership
-   * of the native socket is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native socket.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error. Ownership
-   * of the native socket is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native socket representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * socket. This is intended to allow access to native socket functionality
-   * that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the socket.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls to cancel() will always fail with
-   * asio::error::operation_not_supported when run on Windows XP, Windows
-   * Server 2003, and earlier versions of Windows, unless
-   * ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
-   * two issues that should be considered before enabling its use:
-   *
-   * @li It will only cancel asynchronous operations that were initiated in the
-   * current thread.
-   *
-   * @li It can appear to complete without error, but the request to cancel the
-   * unfinished operations may be silently ignored by the operating system.
-   * Whether it works or not seems to depend on the drivers that are installed.
-   *
-   * For portable cancellation, consider using one of the following
-   * alternatives:
-   *
-   * @li Disable asio's I/O completion port backend by defining
-   * ASIO_DISABLE_IOCP.
-   *
-   * @li Use the close() function to simultaneously cancel the outstanding
-   * operations and close the socket.
-   *
-   * When running on Windows Vista, Windows Server 2008, and later, the
-   * CancelIoEx function is always used. This function does not have the
-   * problems described above.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
-  && !defined(ASIO_ENABLE_CANCELIO)
-  __declspec(deprecated("By default, this function always fails with "
-        "operation_not_supported when used on Windows XP, Windows Server 2003, "
-        "or earlier. Consult documentation for details."))
-#endif
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the socket.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls to cancel() will always fail with
-   * asio::error::operation_not_supported when run on Windows XP, Windows
-   * Server 2003, and earlier versions of Windows, unless
-   * ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
-   * two issues that should be considered before enabling its use:
-   *
-   * @li It will only cancel asynchronous operations that were initiated in the
-   * current thread.
-   *
-   * @li It can appear to complete without error, but the request to cancel the
-   * unfinished operations may be silently ignored by the operating system.
-   * Whether it works or not seems to depend on the drivers that are installed.
-   *
-   * For portable cancellation, consider using one of the following
-   * alternatives:
-   *
-   * @li Disable asio's I/O completion port backend by defining
-   * ASIO_DISABLE_IOCP.
-   *
-   * @li Use the close() function to simultaneously cancel the outstanding
-   * operations and close the socket.
-   *
-   * When running on Windows Vista, Windows Server 2008, and later, the
-   * CancelIoEx function is always used. This function does not have the
-   * problems described above.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
-  && !defined(ASIO_ENABLE_CANCELIO)
-  __declspec(deprecated("By default, this function always fails with "
-        "operation_not_supported when used on Windows XP, Windows Server 2003, "
-        "or earlier. Consult documentation for details."))
-#endif
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the socket is at the out-of-band data mark.
-  /**
-   * This function is used to check whether the socket input is currently
-   * positioned at the out-of-band data mark.
-   *
-   * @return A bool indicating whether the socket is at the out-of-band data
-   * mark.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  bool at_mark() const
-  {
-    asio::error_code ec;
-    bool b = impl_.get_service().at_mark(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "at_mark");
-    return b;
-  }
-
-  /// Determine whether the socket is at the out-of-band data mark.
-  /**
-   * This function is used to check whether the socket input is currently
-   * positioned at the out-of-band data mark.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return A bool indicating whether the socket is at the out-of-band data
-   * mark.
-   */
-  bool at_mark(asio::error_code& ec) const
-  {
-    return impl_.get_service().at_mark(impl_.get_implementation(), ec);
-  }
-
-  /// Determine the number of bytes available for reading.
-  /**
-   * This function is used to determine the number of bytes that may be read
-   * without blocking.
-   *
-   * @return The number of bytes that may be read without blocking, or 0 if an
-   * error occurs.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  std::size_t available() const
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().available(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "available");
-    return s;
-  }
-
-  /// Determine the number of bytes available for reading.
-  /**
-   * This function is used to determine the number of bytes that may be read
-   * without blocking.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of bytes that may be read without blocking, or 0 if an
-   * error occurs.
-   */
-  std::size_t available(asio::error_code& ec) const
-  {
-    return impl_.get_service().available(impl_.get_implementation(), ec);
-  }
-
-  /// Bind the socket to the given local endpoint.
-  /**
-   * This function binds the socket to the specified endpoint on the local
-   * machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket will
-   * be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * socket.open(asio::ip::tcp::v4());
-   * socket.bind(asio::ip::tcp::endpoint(
-   *       asio::ip::tcp::v4(), 12345));
-   * @endcode
-   */
-  void bind(const endpoint_type& endpoint)
-  {
-    asio::error_code ec;
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-  }
-
-  /// Bind the socket to the given local endpoint.
-  /**
-   * This function binds the socket to the specified endpoint on the local
-   * machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket will
-   * be bound.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * socket.open(asio::ip::tcp::v4());
-   * asio::error_code ec;
-   * socket.bind(asio::ip::tcp::endpoint(
-   *       asio::ip::tcp::v4(), 12345), ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
-      asio::error_code& ec)
-  {
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Connect the socket to the specified endpoint.
-  /**
-   * This function is used to connect a socket to the specified remote endpoint.
-   * The function call will block until the connection is successfully made or
-   * an error occurs.
-   *
-   * The socket is automatically opened if it is not already open. If the
-   * connect fails, and the socket was automatically opened, the socket is
-   * not returned to the closed state.
-   *
-   * @param peer_endpoint The remote endpoint to which the socket will be
-   * connected.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::ip::tcp::endpoint endpoint(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.connect(endpoint);
-   * @endcode
-   */
-  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);
-      asio::detail::throw_error(ec, "connect");
-    }
-    impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);
-    asio::detail::throw_error(ec, "connect");
-  }
-
-  /// Connect the socket to the specified endpoint.
-  /**
-   * This function is used to connect a socket to the specified remote endpoint.
-   * The function call will block until the connection is successfully made or
-   * an error occurs.
-   *
-   * The socket is automatically opened if it is not already open. If the
-   * connect fails, and the socket was automatically opened, the socket is
-   * not returned to the closed state.
-   *
-   * @param peer_endpoint The remote endpoint to which the socket will be
-   * connected.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::ip::tcp::endpoint endpoint(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * asio::error_code ec;
-   * socket.connect(endpoint, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  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);
-  }
-
-  /// Start an asynchronous connect.
-  /**
-   * This function is used to asynchronously connect a socket to the specified
-   * remote endpoint. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * The socket is automatically opened if it is not already open. If the
-   * connect fails, and the socket was automatically opened, the socket is
-   * not returned to the closed state.
-   *
-   * @param peer_endpoint The remote endpoint to which the socket will be
-   * connected. Copies will be made of the endpoint object as required.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the connect completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Example
-   * @code
-   * void connect_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Connect succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::ip::tcp::endpoint endpoint(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.async_connect(endpoint, connect_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        ConnectToken = default_completion_token_t<executor_type>>
-  auto async_connect(const endpoint_type& peer_endpoint,
-      ConnectToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ConnectToken, void (asio::error_code)>(
-        declval<initiate_async_connect>(), token,
-        peer_endpoint, declval<asio::error_code&>()))
-  {
-    asio::error_code open_ec;
-    if (!is_open())
-    {
-      const protocol_type protocol = peer_endpoint.protocol();
-      impl_.get_service().open(impl_.get_implementation(), protocol, open_ec);
-    }
-
-    return async_initiate<ConnectToken, void (asio::error_code)>(
-        initiate_async_connect(this), token, peer_endpoint, open_ec);
-  }
-
-  /// Set an option on the socket.
-  /**
-   * This function is used to set an option on the socket.
-   *
-   * @param option The new option value to be set on the socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::broadcast @n
-   * asio::socket_base::do_not_route @n
-   * asio::socket_base::keep_alive @n
-   * asio::socket_base::linger @n
-   * asio::socket_base::receive_buffer_size @n
-   * asio::socket_base::receive_low_watermark @n
-   * asio::socket_base::reuse_address @n
-   * asio::socket_base::send_buffer_size @n
-   * asio::socket_base::send_low_watermark @n
-   * asio::ip::multicast::join_group @n
-   * asio::ip::multicast::leave_group @n
-   * asio::ip::multicast::enable_loopback @n
-   * asio::ip::multicast::outbound_interface @n
-   * asio::ip::multicast::hops @n
-   * asio::ip::tcp::no_delay
-   *
-   * @par Example
-   * Setting the IPPROTO_TCP/TCP_NODELAY option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::no_delay option(true);
-   * socket.set_option(option);
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  void set_option(const SettableSocketOption& option)
-  {
-    asio::error_code ec;
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "set_option");
-  }
-
-  /// Set an option on the socket.
-  /**
-   * This function is used to set an option on the socket.
-   *
-   * @param option The new option value to be set on the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::broadcast @n
-   * asio::socket_base::do_not_route @n
-   * asio::socket_base::keep_alive @n
-   * asio::socket_base::linger @n
-   * asio::socket_base::receive_buffer_size @n
-   * asio::socket_base::receive_low_watermark @n
-   * asio::socket_base::reuse_address @n
-   * asio::socket_base::send_buffer_size @n
-   * asio::socket_base::send_low_watermark @n
-   * asio::ip::multicast::join_group @n
-   * asio::ip::multicast::leave_group @n
-   * asio::ip::multicast::enable_loopback @n
-   * asio::ip::multicast::outbound_interface @n
-   * asio::ip::multicast::hops @n
-   * asio::ip::tcp::no_delay
-   *
-   * @par Example
-   * Setting the IPPROTO_TCP/TCP_NODELAY option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::no_delay option(true);
-   * asio::error_code ec;
-   * socket.set_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
-      asio::error_code& ec)
-  {
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get an option from the socket.
-  /**
-   * This function is used to get the current value of an option on the socket.
-   *
-   * @param option The option value to be obtained from the socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::broadcast @n
-   * asio::socket_base::do_not_route @n
-   * asio::socket_base::keep_alive @n
-   * asio::socket_base::linger @n
-   * asio::socket_base::receive_buffer_size @n
-   * asio::socket_base::receive_low_watermark @n
-   * asio::socket_base::reuse_address @n
-   * asio::socket_base::send_buffer_size @n
-   * asio::socket_base::send_low_watermark @n
-   * asio::ip::multicast::join_group @n
-   * asio::ip::multicast::leave_group @n
-   * asio::ip::multicast::enable_loopback @n
-   * asio::ip::multicast::outbound_interface @n
-   * asio::ip::multicast::hops @n
-   * asio::ip::tcp::no_delay
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::socket::keep_alive option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  void get_option(GettableSocketOption& option) const
-  {
-    asio::error_code ec;
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "get_option");
-  }
-
-  /// Get an option from the socket.
-  /**
-   * This function is used to get the current value of an option on the socket.
-   *
-   * @param option The option value to be obtained from the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::broadcast @n
-   * asio::socket_base::do_not_route @n
-   * asio::socket_base::keep_alive @n
-   * asio::socket_base::linger @n
-   * asio::socket_base::receive_buffer_size @n
-   * asio::socket_base::receive_low_watermark @n
-   * asio::socket_base::reuse_address @n
-   * asio::socket_base::send_buffer_size @n
-   * asio::socket_base::send_low_watermark @n
-   * asio::ip::multicast::join_group @n
-   * asio::ip::multicast::leave_group @n
-   * asio::ip::multicast::enable_loopback @n
-   * asio::ip::multicast::outbound_interface @n
-   * asio::ip::multicast::hops @n
-   * asio::ip::tcp::no_delay
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::socket::keep_alive option;
-   * asio::error_code ec;
-   * socket.get_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * bool is_set = option.value();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
-      asio::error_code& ec) const
-  {
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform an IO control command on the socket.
-  /**
-   * This function is used to execute an IO control command on the socket.
-   *
-   * @param command The IO control command to be performed on the socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa IoControlCommand @n
-   * asio::socket_base::bytes_readable @n
-   * asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::socket::bytes_readable command;
-   * socket.io_control(command);
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  void io_control(IoControlCommand& command)
-  {
-    asio::error_code ec;
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    asio::detail::throw_error(ec, "io_control");
-  }
-
-  /// Perform an IO control command on the socket.
-  /**
-   * This function is used to execute an IO control command on the socket.
-   *
-   * @param command The IO control command to be performed on the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa IoControlCommand @n
-   * asio::socket_base::bytes_readable @n
-   * asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::socket::bytes_readable command;
-   * asio::error_code ec;
-   * socket.io_control(command, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
-      asio::error_code& ec)
-  {
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the socket.
-  /**
-   * @returns @c true if the socket's synchronous operations will fail with
-   * asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return impl_.get_service().non_blocking(impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  /**
-   * @param mode If @c true, the socket's synchronous operations will fail with
-   * asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  /**
-   * @param mode If @c true, the socket's synchronous operations will fail with
-   * asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  ASIO_SYNC_OP_VOID non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native socket. This mode has no effect on the behaviour of the socket
-   * object's synchronous operations.
-   *
-   * @returns @c true if the underlying socket is in non-blocking mode and
-   * direct system calls may fail with asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the socket object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native socket.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(asio::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = asio::error_code(n < 0 ? errno : 0,
-   *             asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == asio::error::would_block
-   *             || ec == asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_wait(tcp::socket::wait_write, *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_wait(tcp::socket::wait_write, op);
-   * } @endcode
-   */
-  bool native_non_blocking() const
-  {
-    return impl_.get_service().native_non_blocking(impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native socket. It has no effect on the behaviour of the socket object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying socket is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws asio::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(asio::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = asio::error_code(n < 0 ? errno : 0,
-   *             asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == asio::error::would_block
-   *             || ec == asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_wait(tcp::socket::wait_write, *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_wait(tcp::socket::wait_write, op);
-   * } @endcode
-   */
-  void native_non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native socket. It has no effect on the behaviour of the socket object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying socket is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(asio::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = asio::error_code(n < 0 ? errno : 0,
-   *             asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == asio::error::would_block
-   *             || ec == asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_wait(tcp::socket::wait_write, *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_wait(tcp::socket::wait_write, op);
-   * } @endcode
-   */
-  ASIO_SYNC_OP_VOID native_non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the local endpoint of the socket.
-  /**
-   * This function is used to obtain the locally bound endpoint of the socket.
-   *
-   * @returns An object that represents the local endpoint of the socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-   * @endcode
-   */
-  endpoint_type local_endpoint() const
-  {
-    asio::error_code ec;
-    endpoint_type ep = impl_.get_service().local_endpoint(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "local_endpoint");
-    return ep;
-  }
-
-  /// Get the local endpoint of the socket.
-  /**
-   * This function is used to obtain the locally bound endpoint of the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns An object that represents the local endpoint of the socket.
-   * Returns a default-constructed endpoint object if an error occurred.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::error_code ec;
-   * asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  endpoint_type local_endpoint(asio::error_code& ec) const
-  {
-    return impl_.get_service().local_endpoint(impl_.get_implementation(), ec);
-  }
-
-  /// Get the remote endpoint of the socket.
-  /**
-   * This function is used to obtain the remote endpoint of the socket.
-   *
-   * @returns An object that represents the remote endpoint of the socket.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-   * @endcode
-   */
-  endpoint_type remote_endpoint() const
-  {
-    asio::error_code ec;
-    endpoint_type ep = impl_.get_service().remote_endpoint(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "remote_endpoint");
-    return ep;
-  }
-
-  /// Get the remote endpoint of the socket.
-  /**
-   * This function is used to obtain the remote endpoint of the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns An object that represents the remote endpoint of the socket.
-   * Returns a default-constructed endpoint object if an error occurred.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::error_code ec;
-   * asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  endpoint_type remote_endpoint(asio::error_code& ec) const
-  {
-    return impl_.get_service().remote_endpoint(impl_.get_implementation(), ec);
-  }
-
-  /// Disable sends or receives on the socket.
-  /**
-   * This function is used to disable send operations, receive operations, or
-   * both.
-   *
-   * @param what Determines what types of operation will no longer be allowed.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * Shutting down the send side of the socket:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-   * @endcode
-   */
-  void shutdown(shutdown_type what)
-  {
-    asio::error_code ec;
-    impl_.get_service().shutdown(impl_.get_implementation(), what, ec);
-    asio::detail::throw_error(ec, "shutdown");
-  }
-
-  /// Disable sends or receives on the socket.
-  /**
-   * This function is used to disable send operations, receive operations, or
-   * both.
-   *
-   * @param what Determines what types of operation will no longer be allowed.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * Shutting down the send side of the socket:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::error_code ec;
-   * socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID shutdown(shutdown_type what,
-      asio::error_code& ec)
-  {
-    impl_.get_service().shutdown(impl_.get_implementation(), what, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Wait for the socket to become ready to read, ready to write, or to have
-  /// pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for a socket to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired socket state.
-   *
-   * @par Example
-   * Waiting for a socket to become readable.
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * socket.wait(asio::ip::tcp::socket::wait_read);
-   * @endcode
-   */
-  void wait(wait_type w)
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Wait for the socket to become ready to read, ready to write, or to have
-  /// pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for a socket to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired socket state.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * Waiting for a socket to become readable.
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::error_code ec;
-   * socket.wait(asio::ip::tcp::socket::wait_read, ec);
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Asynchronously wait for the socket to become ready to read, ready to
-  /// write, or to have pending error conditions.
-  /**
-   * This function is used to perform an asynchronous wait for a socket to enter
-   * a ready to read, write or error condition state. It is an initiating
-   * function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param w Specifies the desired socket state.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the wait completes. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Example
-   * @code
-   * void wait_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Wait succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(wait_type w,
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-          declval<initiate_async_wait>(), token, w))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token, w);
-  }
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * This function destroys the socket, cancelling any outstanding asynchronous
-   * operations associated with the socket as if by calling @c cancel.
-   */
-  ~basic_socket()
-  {
-  }
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-  detail::io_object_impl<
-    detail::null_socket_service<Protocol>, Executor> impl_;
-#elif defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<
-    detail::win_iocp_socket_service<Protocol>, Executor> impl_;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<
-    detail::io_uring_socket_service<Protocol>, Executor> impl_;
-#else
-  detail::io_object_impl<
-    detail::reactive_socket_service<Protocol>, Executor> impl_;
-#endif
-
-private:
-  // Disallow copying and assignment.
-  basic_socket(const basic_socket&) = delete;
-  basic_socket& operator=(const basic_socket&) = delete;
-
-  class initiate_async_connect
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_connect(basic_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ConnectHandler>
-    void operator()(ConnectHandler&& handler,
-        const endpoint_type& peer_endpoint,
-        const asio::error_code& open_ec) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ConnectHandler.
-      ASIO_CONNECT_HANDLER_CHECK(ConnectHandler, handler) type_check;
-
-      if (open_ec)
-      {
-          asio::post(self_->impl_.get_executor(),
-              asio::detail::bind_handler(
-                static_cast<ConnectHandler&&>(handler), open_ec));
-      }
-      else
-      {
-        detail::non_const_lvalue<ConnectHandler> handler2(handler);
-        self_->impl_.get_service().async_connect(
-            self_->impl_.get_implementation(), peer_endpoint,
-            handler2.value, self_->impl_.get_executor());
-      }
-    }
-
-  private:
-    basic_socket* self_;
-  };
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler, wait_type w) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(), w,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_socket* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_acceptor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_acceptor.hpp
deleted file mode 100644
index 9099fe7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_acceptor.hpp
+++ /dev/null
@@ -1,2708 +0,0 @@
-//
-// basic_socket_acceptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_ACCEPTOR_HPP
-#define ASIO_BASIC_SOCKET_ACCEPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <utility>
-#include "asio/detail/config.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/null_socket_service.hpp"
-#elif defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_socket_service.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_socket_service.hpp"
-#else
-# include "asio/detail/reactive_socket_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL)
-#define ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_socket_acceptor;
-
-#endif // !defined(ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL)
-
-/// Provides the ability to accept new connections.
-/**
- * The basic_socket_acceptor class template is used for accepting new socket
- * connections.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c accept operations are thread safe, if the underlying
- * operating system calls are also thread safe. This means that it is permitted
- * to perform concurrent calls to synchronous @c accept operations on a single
- * socket object. Other synchronous operations, such as @c open or @c close, are
- * not thread safe.
- *
- * @par Example
- * Opening a socket acceptor with the SO_REUSEADDR option enabled:
- * @code
- * asio::ip::tcp::acceptor acceptor(my_context);
- * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
- * acceptor.open(endpoint.protocol());
- * acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
- * acceptor.bind(endpoint);
- * acceptor.listen();
- * @endcode
- */
-template <typename Protocol, typename Executor>
-class basic_socket_acceptor
-  : public socket_base
-{
-private:
-  class initiate_async_wait;
-  class initiate_async_accept;
-  class initiate_async_move_accept;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the acceptor type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_socket_acceptor<Protocol, Executor1> other;
-  };
-
-  /// The native representation of an acceptor.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_WINDOWS_RUNTIME)
-  typedef typename detail::null_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef typename detail::win_iocp_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef typename detail::io_uring_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#else
-  typedef typename detail::reactive_socket_service<
-    Protocol>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct an acceptor without opening it.
-  /**
-   * This constructor creates an acceptor without opening it to listen for new
-   * connections. The open() function must be called before the acceptor can
-   * accept new socket connections.
-   *
-   * @param ex The I/O executor that the acceptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   */
-  explicit basic_socket_acceptor(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct an acceptor without opening it.
-  /**
-   * This constructor creates an acceptor without opening it to listen for new
-   * connections. The open() function must be called before the acceptor can
-   * accept new socket connections.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the acceptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the acceptor.
-   */
-  template <typename ExecutionContext>
-  explicit basic_socket_acceptor(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct an open acceptor.
-  /**
-   * This constructor creates an acceptor and automatically opens it.
-   *
-   * @param ex The I/O executor that the acceptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket_acceptor(const executor_type& ex, const protocol_type& protocol)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct an open acceptor.
-  /**
-   * This constructor creates an acceptor and automatically opens it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the acceptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_socket_acceptor(ExecutionContext& context,
-      const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct an acceptor opened on the given endpoint.
-  /**
-   * This constructor creates an acceptor and automatically opens it to listen
-   * for new connections on the specified endpoint.
-   *
-   * @param ex The I/O executor that the acceptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param endpoint An endpoint on the local machine on which the acceptor
-   * will listen for new connections.
-   *
-   * @param reuse_addr Whether the constructor should set the socket option
-   * socket_base::reuse_address.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This constructor is equivalent to the following code:
-   * @code
-   * basic_socket_acceptor<Protocol> acceptor(my_context);
-   * acceptor.open(endpoint.protocol());
-   * if (reuse_addr)
-   *   acceptor.set_option(socket_base::reuse_address(true));
-   * acceptor.bind(endpoint);
-   * acceptor.listen();
-   * @endcode
-   */
-  basic_socket_acceptor(const executor_type& ex,
-      const endpoint_type& endpoint, bool reuse_addr = true)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-    if (reuse_addr)
-    {
-      impl_.get_service().set_option(impl_.get_implementation(),
-          socket_base::reuse_address(true), ec);
-      asio::detail::throw_error(ec, "set_option");
-    }
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-    impl_.get_service().listen(impl_.get_implementation(),
-        socket_base::max_listen_connections, ec);
-    asio::detail::throw_error(ec, "listen");
-  }
-
-  /// Construct an acceptor opened on the given endpoint.
-  /**
-   * This constructor creates an acceptor and automatically opens it to listen
-   * for new connections on the specified endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the acceptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the acceptor.
-   *
-   * @param endpoint An endpoint on the local machine on which the acceptor
-   * will listen for new connections.
-   *
-   * @param reuse_addr Whether the constructor should set the socket option
-   * socket_base::reuse_address.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This constructor is equivalent to the following code:
-   * @code
-   * basic_socket_acceptor<Protocol> acceptor(my_context);
-   * acceptor.open(endpoint.protocol());
-   * if (reuse_addr)
-   *   acceptor.set_option(socket_base::reuse_address(true));
-   * acceptor.bind(endpoint);
-   * acceptor.listen();
-   * @endcode
-   */
-  template <typename ExecutionContext>
-  basic_socket_acceptor(ExecutionContext& context,
-      const endpoint_type& endpoint, bool reuse_addr = true,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-    if (reuse_addr)
-    {
-      impl_.get_service().set_option(impl_.get_implementation(),
-          socket_base::reuse_address(true), ec);
-      asio::detail::throw_error(ec, "set_option");
-    }
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-    impl_.get_service().listen(impl_.get_implementation(),
-        socket_base::max_listen_connections, ec);
-    asio::detail::throw_error(ec, "listen");
-  }
-
-  /// Construct a basic_socket_acceptor on an existing native acceptor.
-  /**
-   * This constructor creates an acceptor object to hold an existing native
-   * acceptor.
-   *
-   * @param ex The I/O executor that the acceptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket_acceptor(const executor_type& ex,
-      const protocol_type& protocol, const native_handle_type& native_acceptor)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_acceptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_socket_acceptor on an existing native acceptor.
-  /**
-   * This constructor creates an acceptor object to hold an existing native
-   * acceptor.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the acceptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_socket_acceptor(ExecutionContext& context,
-      const protocol_type& protocol, const native_handle_type& native_acceptor,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_acceptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_socket_acceptor from another.
-  /**
-   * This constructor moves an acceptor from one object to another.
-   *
-   * @param other The other basic_socket_acceptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket_acceptor(const executor_type&)
-   * constructor.
-   */
-  basic_socket_acceptor(basic_socket_acceptor&& other) noexcept
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_socket_acceptor from another.
-  /**
-   * This assignment operator moves an acceptor from one object to another.
-   *
-   * @param other The other basic_socket_acceptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket_acceptor(const executor_type&)
-   * constructor.
-   */
-  basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All socket acceptors have access to each other's implementations.
-  template <typename Protocol1, typename Executor1>
-  friend class basic_socket_acceptor;
-
-  /// Move-construct a basic_socket_acceptor from an acceptor of another
-  /// protocol type.
-  /**
-   * This constructor moves an acceptor from one object to another.
-   *
-   * @param other The other basic_socket_acceptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket_acceptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_socket_acceptor(basic_socket_acceptor<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_socket_acceptor from an acceptor of another protocol
-  /// type.
-  /**
-   * This assignment operator moves an acceptor from one object to another.
-   *
-   * @param other The other basic_socket_acceptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_socket_acceptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_socket_acceptor&
-  > operator=(basic_socket_acceptor<Protocol1, Executor1>&& other)
-  {
-    basic_socket_acceptor tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the acceptor.
-  /**
-   * This function destroys the acceptor, cancelling any outstanding
-   * asynchronous operations associated with the acceptor as if by calling
-   * @c cancel.
-   */
-  ~basic_socket_acceptor()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Open the acceptor using the specified protocol.
-  /**
-   * This function opens the socket acceptor so that it will use the specified
-   * protocol.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * acceptor.open(asio::ip::tcp::v4());
-   * @endcode
-   */
-  void open(const protocol_type& protocol = protocol_type())
-  {
-    asio::error_code ec;
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Open the acceptor using the specified protocol.
-  /**
-   * This function opens the socket acceptor so that it will use the specified
-   * protocol.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * asio::error_code ec;
-   * acceptor.open(asio::ip::tcp::v4(), ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID open(const protocol_type& protocol,
-      asio::error_code& ec)
-  {
-    impl_.get_service().open(impl_.get_implementation(), protocol, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Assigns an existing native acceptor to the acceptor.
-  /*
-   * This function opens the acceptor to hold an existing native acceptor.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const protocol_type& protocol,
-      const native_handle_type& native_acceptor)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_acceptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assigns an existing native acceptor to the acceptor.
-  /*
-   * This function opens the acceptor to hold an existing native acceptor.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,
-      const native_handle_type& native_acceptor, asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(),
-        protocol, native_acceptor, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the acceptor is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Bind the acceptor to the given local endpoint.
-  /**
-   * This function binds the socket acceptor to the specified endpoint on the
-   * local machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket
-   * acceptor will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
-   * acceptor.open(endpoint.protocol());
-   * acceptor.bind(endpoint);
-   * @endcode
-   */
-  void bind(const endpoint_type& endpoint)
-  {
-    asio::error_code ec;
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    asio::detail::throw_error(ec, "bind");
-  }
-
-  /// Bind the acceptor to the given local endpoint.
-  /**
-   * This function binds the socket acceptor to the specified endpoint on the
-   * local machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket
-   * acceptor will be bound.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
-   * acceptor.open(endpoint.protocol());
-   * asio::error_code ec;
-   * acceptor.bind(endpoint, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,
-      asio::error_code& ec)
-  {
-    impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Place the acceptor into the state where it will listen for new
-  /// connections.
-  /**
-   * This function puts the socket acceptor into the state where it may accept
-   * new connections.
-   *
-   * @param backlog The maximum length of the queue of pending connections.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void listen(int backlog = socket_base::max_listen_connections)
-  {
-    asio::error_code ec;
-    impl_.get_service().listen(impl_.get_implementation(), backlog, ec);
-    asio::detail::throw_error(ec, "listen");
-  }
-
-  /// Place the acceptor into the state where it will listen for new
-  /// connections.
-  /**
-   * This function puts the socket acceptor into the state where it may accept
-   * new connections.
-   *
-   * @param backlog The maximum length of the queue of pending connections.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::error_code ec;
-   * acceptor.listen(asio::socket_base::max_listen_connections, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID listen(int backlog, asio::error_code& ec)
-  {
-    impl_.get_service().listen(impl_.get_implementation(), backlog, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Close the acceptor.
-  /**
-   * This function is used to close the acceptor. Any asynchronous accept
-   * operations will be cancelled immediately.
-   *
-   * A subsequent call to open() is required before the acceptor can again be
-   * used to again perform socket accept operations.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the acceptor.
-  /**
-   * This function is used to close the acceptor. Any asynchronous accept
-   * operations will be cancelled immediately.
-   *
-   * A subsequent call to open() is required before the acceptor can again be
-   * used to again perform socket accept operations.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::error_code ec;
-   * acceptor.close(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native acceptor.
-  /**
-   * This function causes all outstanding asynchronous accept operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native acceptor is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native acceptor.
-  /**
-   * This function causes all outstanding asynchronous accept operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native acceptor is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native acceptor representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * acceptor. This is intended to allow access to native acceptor functionality
-   * that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the acceptor.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the acceptor.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Set an option on the acceptor.
-  /**
-   * This function is used to set an option on the acceptor.
-   *
-   * @param option The new option value to be set on the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::reuse_address
-   * asio::socket_base::enable_connection_aborted
-   *
-   * @par Example
-   * Setting the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option(true);
-   * acceptor.set_option(option);
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  void set_option(const SettableSocketOption& option)
-  {
-    asio::error_code ec;
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "set_option");
-  }
-
-  /// Set an option on the acceptor.
-  /**
-   * This function is used to set an option on the acceptor.
-   *
-   * @param option The new option value to be set on the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::reuse_address
-   * asio::socket_base::enable_connection_aborted
-   *
-   * @par Example
-   * Setting the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option(true);
-   * asio::error_code ec;
-   * acceptor.set_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,
-      asio::error_code& ec)
-  {
-    impl_.get_service().set_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get an option from the acceptor.
-  /**
-   * This function is used to get the current value of an option on the
-   * acceptor.
-   *
-   * @param option The option value to be obtained from the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::reuse_address
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option;
-   * acceptor.get_option(option);
-   * bool is_set = option.get();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  void get_option(GettableSocketOption& option) const
-  {
-    asio::error_code ec;
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    asio::detail::throw_error(ec, "get_option");
-  }
-
-  /// Get an option from the acceptor.
-  /**
-   * This function is used to get the current value of an option on the
-   * acceptor.
-   *
-   * @param option The option value to be obtained from the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::reuse_address
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option;
-   * asio::error_code ec;
-   * acceptor.get_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * bool is_set = option.get();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,
-      asio::error_code& ec) const
-  {
-    impl_.get_service().get_option(impl_.get_implementation(), option, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform an IO control command on the acceptor.
-  /**
-   * This function is used to execute an IO control command on the acceptor.
-   *
-   * @param command The IO control command to be performed on the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa IoControlCommand @n
-   * asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::non_blocking_io command(true);
-   * socket.io_control(command);
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  void io_control(IoControlCommand& command)
-  {
-    asio::error_code ec;
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    asio::detail::throw_error(ec, "io_control");
-  }
-
-  /// Perform an IO control command on the acceptor.
-  /**
-   * This function is used to execute an IO control command on the acceptor.
-   *
-   * @param command The IO control command to be performed on the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa IoControlCommand @n
-   * asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::acceptor::non_blocking_io command(true);
-   * asio::error_code ec;
-   * socket.io_control(command, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
-      asio::error_code& ec)
-  {
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the acceptor.
-  /**
-   * @returns @c true if the acceptor's synchronous operations will fail with
-   * asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return impl_.get_service().non_blocking(impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the acceptor.
-  /**
-   * @param mode If @c true, the acceptor's synchronous operations will fail
-   * with asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the acceptor.
-  /**
-   * @param mode If @c true, the acceptor's synchronous operations will fail
-   * with asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  ASIO_SYNC_OP_VOID non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native acceptor. This mode has no effect on the behaviour of the acceptor
-   * object's synchronous operations.
-   *
-   * @returns @c true if the underlying acceptor is in non-blocking mode and
-   * direct system calls may fail with asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the acceptor object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native acceptor.
-   */
-  bool native_non_blocking() const
-  {
-    return impl_.get_service().native_non_blocking(impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native acceptor. It has no effect on the behaviour of the acceptor object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying acceptor is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws asio::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  void native_non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native acceptor. It has no effect on the behaviour of the acceptor object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying acceptor is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  ASIO_SYNC_OP_VOID native_non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the local endpoint of the acceptor.
-  /**
-   * This function is used to obtain the locally bound endpoint of the acceptor.
-   *
-   * @returns An object that represents the local endpoint of the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
-   * @endcode
-   */
-  endpoint_type local_endpoint() const
-  {
-    asio::error_code ec;
-    endpoint_type ep = impl_.get_service().local_endpoint(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "local_endpoint");
-    return ep;
-  }
-
-  /// Get the local endpoint of the acceptor.
-  /**
-   * This function is used to obtain the locally bound endpoint of the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns An object that represents the local endpoint of the acceptor.
-   * Returns a default-constructed endpoint object if an error occurred and the
-   * error handler did not throw an exception.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::error_code ec;
-   * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  endpoint_type local_endpoint(asio::error_code& ec) const
-  {
-    return impl_.get_service().local_endpoint(impl_.get_implementation(), ec);
-  }
-
-  /// Wait for the acceptor to become ready to read, ready to write, or to have
-  /// pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for an acceptor to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired acceptor state.
-   *
-   * @par Example
-   * Waiting for an acceptor to become readable.
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * acceptor.wait(asio::ip::tcp::acceptor::wait_read);
-   * @endcode
-   */
-  void wait(wait_type w)
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Wait for the acceptor to become ready to read, ready to write, or to have
-  /// pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for an acceptor to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired acceptor state.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * Waiting for an acceptor to become readable.
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::error_code ec;
-   * acceptor.wait(asio::ip::tcp::acceptor::wait_read, ec);
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Asynchronously wait for the acceptor to become ready to read, ready to
-  /// write, or to have pending error conditions.
-  /**
-   * This function is used to perform an asynchronous wait for an acceptor to
-   * enter a ready to read, write or error condition state. It is an initiating
-   * function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param w Specifies the desired acceptor state.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the wait completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Example
-   * @code
-   * void wait_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Wait succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * acceptor.async_wait(
-   *     asio::ip::tcp::acceptor::wait_read,
-   *     wait_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(wait_type w,
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-        declval<initiate_async_wait>(), token, w))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token, w);
-  }
-
-#if !defined(ASIO_NO_EXTENSIONS)
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket. The function call will block until a new connection has been
-   * accepted successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(my_context);
-   * acceptor.accept(socket);
-   * @endcode
-   */
-  template <typename Protocol1, typename Executor1>
-  void accept(basic_socket<Protocol1, Executor1>& peer,
-      constraint_t<
-        is_convertible<Protocol, Protocol1>::value
-      > = 0)
-  {
-    asio::error_code ec;
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, static_cast<endpoint_type*>(0), ec);
-    asio::detail::throw_error(ec, "accept");
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket. The function call will block until a new connection has been
-   * accepted successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::error_code ec;
-   * acceptor.accept(socket, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename Protocol1, typename Executor1>
-  ASIO_SYNC_OP_VOID accept(
-      basic_socket<Protocol1, Executor1>& peer, asio::error_code& ec,
-      constraint_t<
-        is_convertible<Protocol, Protocol1>::value
-      > = 0)
-  {
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, static_cast<endpoint_type*>(0), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection into a
-   * socket, and additionally obtain the endpoint of the remote peer. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(my_context);
-   * acceptor.async_accept(socket, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename Protocol1, typename Executor1,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        AcceptToken = default_completion_token_t<executor_type>>
-  auto async_accept(basic_socket<Protocol1, Executor1>& peer,
-      AcceptToken&& token = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_convertible<Protocol, Protocol1>::value
-      > = 0)
-    -> decltype(
-      async_initiate<AcceptToken, void (asio::error_code)>(
-        declval<initiate_async_accept>(), token,
-        &peer, static_cast<endpoint_type*>(0)))
-  {
-    return async_initiate<AcceptToken, void (asio::error_code)>(
-        initiate_async_accept(this), token,
-        &peer, static_cast<endpoint_type*>(0));
-  }
-
-  /// Accept a new connection and obtain the endpoint of the peer
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket, and additionally provide the endpoint of the remote peer.
-   * The function call will block until a new connection has been accepted
-   * successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param peer_endpoint An endpoint object which will receive the endpoint of
-   * the remote peer.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::ip::tcp::endpoint endpoint;
-   * acceptor.accept(socket, endpoint);
-   * @endcode
-   */
-  template <typename Executor1>
-  void accept(basic_socket<protocol_type, Executor1>& peer,
-      endpoint_type& peer_endpoint)
-  {
-    asio::error_code ec;
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    asio::detail::throw_error(ec, "accept");
-  }
-
-  /// Accept a new connection and obtain the endpoint of the peer
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket, and additionally provide the endpoint of the remote peer.
-   * The function call will block until a new connection has been accepted
-   * successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param peer_endpoint An endpoint object which will receive the endpoint of
-   * the remote peer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(my_context);
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::error_code ec;
-   * acceptor.accept(socket, endpoint, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename Executor1>
-  ASIO_SYNC_OP_VOID accept(basic_socket<protocol_type, Executor1>& peer,
-      endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    impl_.get_service().accept(
-        impl_.get_implementation(), peer, &peer_endpoint, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection into a
-   * socket, and additionally obtain the endpoint of the remote peer. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the completion handler is called.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written. Ownership of the peer_endpoint object is
-   * retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename Executor1,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        AcceptToken = default_completion_token_t<executor_type>>
-  auto async_accept(basic_socket<protocol_type, Executor1>& peer,
-      endpoint_type& peer_endpoint,
-      AcceptToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<AcceptToken, void (asio::error_code)>(
-        declval<initiate_async_accept>(), token, &peer, &peer_endpoint))
-  {
-    return async_initiate<AcceptToken, void (asio::error_code)>(
-        initiate_async_accept(this), token, &peer, &peer_endpoint);
-  }
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept());
-   * @endcode
-   */
-  typename Protocol::socket::template rebind_executor<executor_type>::other
-  accept()
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template rebind_executor<
-      executor_type>::other peer(impl_.get_executor());
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept(ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  typename Protocol::socket::template rebind_executor<executor_type>::other
-  accept(asio::error_code& ec)
-  {
-    typename Protocol::socket::template rebind_executor<
-      executor_type>::other peer(impl_.get_executor());
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    return peer;
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template
-   *     rebind_executor<executor_type>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template
-   *      rebind_executor<executor_type>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * acceptor.async_accept(accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          executor_type>::other)) MoveAcceptToken
-            = default_completion_token_t<executor_type>>
-  auto async_accept(
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code, typename Protocol::socket::template
-          rebind_executor<executor_type>::other)>(
-            declval<initiate_async_move_accept>(), token,
-            declval<const executor_type&>(), static_cast<endpoint_type*>(0),
-            static_cast<typename Protocol::socket::template
-              rebind_executor<executor_type>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code, typename Protocol::socket::template
-        rebind_executor<executor_type>::other)>(
-          initiate_async_move_accept(this), token,
-          impl_.get_executor(), static_cast<endpoint_type*>(0),
-          static_cast<typename Protocol::socket::template
-            rebind_executor<executor_type>::other*>(0));
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly
-   * accepted socket.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept());
-   * @endcode
-   */
-  template <typename Executor1>
-  typename Protocol::socket::template rebind_executor<Executor1>::other
-  accept(const Executor1& ex,
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template
-      rebind_executor<Executor1>::other peer(ex);
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept());
-   * @endcode
-   */
-  template <typename ExecutionContext>
-  typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other
-  accept(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template rebind_executor<
-        typename ExecutionContext::executor_type>::other peer(context);
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly accepted
-   * socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept(my_context2, ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename Executor1>
-  typename Protocol::socket::template rebind_executor<Executor1>::other
-  accept(const Executor1& ex, asio::error_code& ec,
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-  {
-    typename Protocol::socket::template
-      rebind_executor<Executor1>::other peer(ex);
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::socket socket(acceptor.accept(my_context2, ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename ExecutionContext>
-  typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other
-  accept(ExecutionContext& context, asio::error_code& ec,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-  {
-    typename Protocol::socket::template rebind_executor<
-        typename ExecutionContext::executor_type>::other peer(context);
-    impl_.get_service().accept(impl_.get_implementation(), peer, 0, ec);
-    return peer;
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly accepted
-   * socket.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template rebind_executor<
-   *     Executor1>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template rebind_executor<
-   *      Executor1>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * acceptor.async_accept(my_context2, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename Executor1,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          constraint_t<is_executor<Executor1>::value
-            || execution::is_executor<Executor1>::value,
-              Executor1>>::other)) MoveAcceptToken
-                = default_completion_token_t<executor_type>>
-  auto async_accept(const Executor1& ex,
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code,
-          typename Protocol::socket::template rebind_executor<
-            Executor1>::other)>(
-              declval<initiate_async_move_accept>(), token,
-              ex, static_cast<endpoint_type*>(0),
-              static_cast<typename Protocol::socket::template
-                rebind_executor<Executor1>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          Executor1>::other)>(
-            initiate_async_move_accept(this), token,
-            ex, static_cast<endpoint_type*>(0),
-            static_cast<typename Protocol::socket::template
-              rebind_executor<Executor1>::other*>(0));
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template rebind_executor<
-   *     typename ExecutionContext::executor_type>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template rebind_executor<
-   *      typename ExecutionContext::executor_type>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * acceptor.async_accept(my_context2, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ExecutionContext,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)) MoveAcceptToken
-            = default_completion_token_t<executor_type>>
-  auto async_accept(ExecutionContext& context,
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code,
-          typename Protocol::socket::template rebind_executor<
-            typename ExecutionContext::executor_type>::other)>(
-              declval<initiate_async_move_accept>(), token,
-              context.get_executor(), static_cast<endpoint_type*>(0),
-              static_cast<typename Protocol::socket::template rebind_executor<
-                typename ExecutionContext::executor_type>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)>(
-            initiate_async_move_accept(this), token,
-            context.get_executor(), static_cast<endpoint_type*>(0),
-            static_cast<typename Protocol::socket::template rebind_executor<
-              typename ExecutionContext::executor_type>::other*>(0));
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(acceptor.accept(endpoint));
-   * @endcode
-   */
-  typename Protocol::socket::template rebind_executor<executor_type>::other
-  accept(endpoint_type& peer_endpoint)
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template rebind_executor<
-      executor_type>::other peer(impl_.get_executor());
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(acceptor.accept(endpoint, ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  typename Protocol::socket::template rebind_executor<executor_type>::other
-  accept(endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    typename Protocol::socket::template rebind_executor<
-      executor_type>::other peer(impl_.get_executor());
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    return peer;
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written. Ownership of the peer_endpoint object is
-   * retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template
-   *     rebind_executor<executor_type>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template
-   *      rebind_executor<executor_type>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * acceptor.async_accept(endpoint, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          executor_type>::other)) MoveAcceptToken
-            = default_completion_token_t<executor_type>>
-  auto async_accept(endpoint_type& peer_endpoint,
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code, typename Protocol::socket::template
-          rebind_executor<executor_type>::other)>(
-            declval<initiate_async_move_accept>(), token,
-            declval<const executor_type&>(), &peer_endpoint,
-            static_cast<typename Protocol::socket::template
-              rebind_executor<executor_type>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code, typename Protocol::socket::template
-        rebind_executor<executor_type>::other)>(
-          initiate_async_move_accept(this), token,
-          impl_.get_executor(), &peer_endpoint,
-          static_cast<typename Protocol::socket::template
-            rebind_executor<executor_type>::other*>(0));
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly accepted
-   * socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(
-   *     acceptor.accept(my_context2, endpoint));
-   * @endcode
-   */
-  template <typename Executor1>
-  typename Protocol::socket::template rebind_executor<Executor1>::other
-  accept(const Executor1& ex, endpoint_type& peer_endpoint,
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template
-        rebind_executor<Executor1>::other peer(ex);
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @returns A socket object representing the newly accepted connection.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(
-   *     acceptor.accept(my_context2, endpoint));
-   * @endcode
-   */
-  template <typename ExecutionContext>
-  typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other
-  accept(ExecutionContext& context, endpoint_type& peer_endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-  {
-    asio::error_code ec;
-    typename Protocol::socket::template rebind_executor<
-        typename ExecutionContext::executor_type>::other peer(context);
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    asio::detail::throw_error(ec, "accept");
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly accepted
-   * socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(
-   *     acceptor.accept(my_context2, endpoint, ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename Executor1>
-  typename Protocol::socket::template rebind_executor<Executor1>::other
-  accept(const executor_type& ex,
-      endpoint_type& peer_endpoint, asio::error_code& ec,
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-  {
-    typename Protocol::socket::template
-      rebind_executor<Executor1>::other peer(ex);
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    return peer;
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer. The function
-   * call will block until a new connection has been accepted successfully or
-   * an error occurs.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns On success, a socket object representing the newly accepted
-   * connection. On error, a socket object where is_open() is false.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::ip::tcp::socket socket(
-   *     acceptor.accept(my_context2, endpoint, ec));
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename ExecutionContext>
-  typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other
-  accept(ExecutionContext& context,
-      endpoint_type& peer_endpoint, asio::error_code& ec,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-  {
-    typename Protocol::socket::template rebind_executor<
-        typename ExecutionContext::executor_type>::other peer(context);
-    impl_.get_service().accept(impl_.get_implementation(),
-        peer, &peer_endpoint, ec);
-    return peer;
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param ex The I/O executor object to be used for the newly accepted
-   * socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written. Ownership of the peer_endpoint object is
-   * retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template rebind_executor<
-   *     Executor1>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template rebind_executor<
-   *      Executor1>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * acceptor.async_accept(my_context2, endpoint, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename Executor1,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          constraint_t<is_executor<Executor1>::value
-            || execution::is_executor<Executor1>::value,
-              Executor1>>::other)) MoveAcceptToken
-                = default_completion_token_t<executor_type>>
-  auto async_accept(const Executor1& ex, endpoint_type& peer_endpoint,
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_executor<Executor1>::value
-          || execution::is_executor<Executor1>::value
-      > = 0)
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code,
-          typename Protocol::socket::template rebind_executor<
-            Executor1>::other)>(
-          declval<initiate_async_move_accept>(), token, ex, &peer_endpoint,
-          static_cast<typename Protocol::socket::template
-            rebind_executor<Executor1>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          Executor1>::other)>(
-            initiate_async_move_accept(this), token, ex, &peer_endpoint,
-            static_cast<typename Protocol::socket::template
-              rebind_executor<Executor1>::other*>(0));
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * This overload requires that the Protocol template parameter satisfy the
-   * AcceptableProtocol type requirements.
-   *
-   * @param context The I/O execution context object to be used for the newly
-   * accepted socket.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written. Ownership of the peer_endpoint object is
-   * retained by the caller, which must guarantee that it is valid until the
-   * completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the accept completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   // Result of operation.
-   *   const asio::error_code& error,
-   *
-   *   // On success, the newly accepted socket.
-   *   typename Protocol::socket::template rebind_executor<
-   *     typename ExecutionContext::executor_type>::other peer
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code,
-   *    typename Protocol::socket::template rebind_executor<
-   *      typename ExecutionContext::executor_type>::other)) @endcode
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error,
-   *     asio::ip::tcp::socket peer)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::ip::tcp::endpoint endpoint;
-   * acceptor.async_accept(my_context2, endpoint, accept_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ExecutionContext,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)) MoveAcceptToken
-            = default_completion_token_t<executor_type>>
-  auto async_accept(ExecutionContext& context, endpoint_type& peer_endpoint,
-      MoveAcceptToken&& token = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    -> decltype(
-      async_initiate<MoveAcceptToken,
-        void (asio::error_code,
-          typename Protocol::socket::template rebind_executor<
-            typename ExecutionContext::executor_type>::other)>(
-              declval<initiate_async_move_accept>(), token,
-              context.get_executor(), &peer_endpoint,
-              static_cast<typename Protocol::socket::template rebind_executor<
-                typename ExecutionContext::executor_type>::other*>(0)))
-  {
-    return async_initiate<MoveAcceptToken,
-      void (asio::error_code,
-        typename Protocol::socket::template rebind_executor<
-          typename ExecutionContext::executor_type>::other)>(
-            initiate_async_move_accept(this), token,
-            context.get_executor(), &peer_endpoint,
-            static_cast<typename Protocol::socket::template rebind_executor<
-              typename ExecutionContext::executor_type>::other*>(0));
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_socket_acceptor(const basic_socket_acceptor&) = delete;
-  basic_socket_acceptor& operator=(
-      const basic_socket_acceptor&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_socket_acceptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler, wait_type w) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(), w,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_socket_acceptor* self_;
-  };
-
-  class initiate_async_accept
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_accept(basic_socket_acceptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename AcceptHandler, typename Protocol1, typename Executor1>
-    void operator()(AcceptHandler&& handler,
-        basic_socket<Protocol1, Executor1>* peer,
-        endpoint_type* peer_endpoint) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a AcceptHandler.
-      ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
-
-      detail::non_const_lvalue<AcceptHandler> handler2(handler);
-      self_->impl_.get_service().async_accept(
-          self_->impl_.get_implementation(), *peer, peer_endpoint,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_socket_acceptor* self_;
-  };
-
-  class initiate_async_move_accept
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_move_accept(basic_socket_acceptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename MoveAcceptHandler, typename Executor1, typename Socket>
-    void operator()(MoveAcceptHandler&& handler,
-        const Executor1& peer_ex, endpoint_type* peer_endpoint, Socket*) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a MoveAcceptHandler.
-      ASIO_MOVE_ACCEPT_HANDLER_CHECK(
-          MoveAcceptHandler, handler, Socket) type_check;
-
-      detail::non_const_lvalue<MoveAcceptHandler> handler2(handler);
-      self_->impl_.get_service().async_move_accept(
-          self_->impl_.get_implementation(), peer_ex, peer_endpoint,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_socket_acceptor* self_;
-  };
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-  detail::io_object_impl<
-    detail::null_socket_service<Protocol>, Executor> impl_;
-#elif defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<
-    detail::win_iocp_socket_service<Protocol>, Executor> impl_;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<
-    detail::io_uring_socket_service<Protocol>, Executor> impl_;
-#else
-  detail::io_object_impl<
-    detail::reactive_socket_service<Protocol>, Executor> impl_;
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_SOCKET_ACCEPTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_iostream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_iostream.hpp
deleted file mode 100644
index 902898d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_iostream.hpp
+++ /dev/null
@@ -1,331 +0,0 @@
-//
-// basic_socket_iostream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_IOSTREAM_HPP
-#define ASIO_BASIC_SOCKET_IOSTREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include <istream>
-#include <ostream>
-#include "asio/basic_socket_streambuf.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// A separate base class is used to ensure that the streambuf is initialised
-// prior to the basic_socket_iostream's basic_iostream base class.
-template <typename Protocol, typename Clock, typename WaitTraits>
-class socket_iostream_base
-{
-protected:
-  socket_iostream_base()
-  {
-  }
-
-  socket_iostream_base(socket_iostream_base&& other)
-    : streambuf_(std::move(other.streambuf_))
-  {
-  }
-
-  socket_iostream_base(basic_stream_socket<Protocol> s)
-    : streambuf_(std::move(s))
-  {
-  }
-
-  socket_iostream_base& operator=(socket_iostream_base&& other)
-  {
-    streambuf_ = std::move(other.streambuf_);
-    return *this;
-  }
-
-  basic_socket_streambuf<Protocol, Clock, WaitTraits> streambuf_;
-};
-
-} // namespace detail
-
-#if !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
-#define ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    typename Clock = boost::posix_time::ptime,
-    typename WaitTraits = time_traits<Clock>>
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-class basic_socket_iostream;
-
-#endif // !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
-
-/// Iostream interface for a socket.
-#if defined(GENERATING_DOCUMENTATION)
-template <typename Protocol,
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#else // defined(GENERATING_DOCUMENTATION)
-template <typename Protocol, typename Clock, typename WaitTraits>
-#endif // defined(GENERATING_DOCUMENTATION)
-class basic_socket_iostream
-  : private detail::socket_iostream_base<Protocol, Clock, WaitTraits>,
-    public std::basic_iostream<char>
-{
-private:
-  // These typedefs are intended keep this class's implementation independent
-  // of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-  typedef WaitTraits traits_helper;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-
-public:
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// The clock type.
-  typedef Clock clock_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// (Deprecated: Use time_point.) The time type.
-  typedef typename WaitTraits::time_type time_type;
-
-  /// The time type.
-  typedef typename WaitTraits::time_point time_point;
-
-  /// (Deprecated: Use duration.) The duration type.
-  typedef typename WaitTraits::duration_type duration_type;
-
-  /// The duration type.
-  typedef typename WaitTraits::duration duration;
-#else
-# if !defined(ASIO_NO_DEPRECATED)
-  typedef typename traits_helper::time_type time_type;
-  typedef typename traits_helper::duration_type duration_type;
-# endif // !defined(ASIO_NO_DEPRECATED)
-  typedef typename traits_helper::time_type time_point;
-  typedef typename traits_helper::duration_type duration;
-#endif
-
-  /// Construct a basic_socket_iostream without establishing a connection.
-  basic_socket_iostream()
-    : std::basic_iostream<char>(
-        &this->detail::socket_iostream_base<
-          Protocol, Clock, WaitTraits>::streambuf_)
-  {
-    this->setf(std::ios_base::unitbuf);
-  }
-
-  /// Construct a basic_socket_iostream from the supplied socket.
-  explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
-    : detail::socket_iostream_base<
-        Protocol, Clock, WaitTraits>(std::move(s)),
-      std::basic_iostream<char>(
-        &this->detail::socket_iostream_base<
-          Protocol, Clock, WaitTraits>::streambuf_)
-  {
-    this->setf(std::ios_base::unitbuf);
-  }
-
-  /// Move-construct a basic_socket_iostream from another.
-  basic_socket_iostream(basic_socket_iostream&& other)
-    : detail::socket_iostream_base<
-        Protocol, Clock, WaitTraits>(std::move(other)),
-      std::basic_iostream<char>(std::move(other))
-  {
-    this->set_rdbuf(&this->detail::socket_iostream_base<
-          Protocol, Clock, WaitTraits>::streambuf_);
-  }
-
-  /// Move-assign a basic_socket_iostream from another.
-  basic_socket_iostream& operator=(basic_socket_iostream&& other)
-  {
-    std::basic_iostream<char>::operator=(std::move(other));
-    detail::socket_iostream_base<
-        Protocol, Clock, WaitTraits>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Establish a connection to an endpoint corresponding to a resolver query.
-  /**
-   * This constructor automatically establishes a connection based on the
-   * supplied resolver query parameters. The arguments are used to construct
-   * a resolver query object.
-   */
-  template <typename... T>
-  explicit basic_socket_iostream(T... x)
-    : std::basic_iostream<char>(
-        &this->detail::socket_iostream_base<
-          Protocol, Clock, WaitTraits>::streambuf_)
-  {
-    this->setf(std::ios_base::unitbuf);
-    if (rdbuf()->connect(x...) == 0)
-      this->setstate(std::ios_base::failbit);
-  }
-
-  /// Establish a connection to an endpoint corresponding to a resolver query.
-  /**
-   * This function automatically establishes a connection based on the supplied
-   * resolver query parameters. The arguments are used to construct a resolver
-   * query object.
-   */
-  template <typename... T>
-  void connect(T... x)
-  {
-    if (rdbuf()->connect(x...) == 0)
-      this->setstate(std::ios_base::failbit);
-  }
-
-  /// Close the connection.
-  void close()
-  {
-    if (rdbuf()->close() == 0)
-      this->setstate(std::ios_base::failbit);
-  }
-
-  /// Return a pointer to the underlying streambuf.
-  basic_socket_streambuf<Protocol, Clock, WaitTraits>* rdbuf() const
-  {
-    return const_cast<basic_socket_streambuf<Protocol, Clock, WaitTraits>*>(
-        &this->detail::socket_iostream_base<
-          Protocol, Clock, WaitTraits>::streambuf_);
-  }
-
-  /// Get a reference to the underlying socket.
-  basic_socket<Protocol>& socket()
-  {
-    return rdbuf()->socket();
-  }
-
-  /// Get the last error associated with the stream.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream.
-   *
-   * @par Example
-   * To print the error associated with a failure to establish a connection:
-   * @code tcp::iostream s("www.boost.org", "http");
-   * if (!s)
-   * {
-   *   std::cout << "Error: " << s.error().message() << std::endl;
-   * } @endcode
-   */
-  const asio::error_code& error() const
-  {
-    return rdbuf()->error();
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use expiry().) Get the stream's expiry time as an absolute
-  /// time.
-  /**
-   * @return An absolute time value representing the stream's expiry time.
-   */
-  time_point expires_at() const
-  {
-    return rdbuf()->expires_at();
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Get the stream's expiry time as an absolute time.
-  /**
-   * @return An absolute time value representing the stream's expiry time.
-   */
-  time_point expiry() const
-  {
-    return rdbuf()->expiry();
-  }
-
-  /// Set the stream's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the stream.
-   */
-  void expires_at(const time_point& expiry_time)
-  {
-    rdbuf()->expires_at(expiry_time);
-  }
-
-  /// Set the stream's expiry time relative to now.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_after(const duration& expiry_time)
-  {
-    rdbuf()->expires_after(expiry_time);
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use expiry().) Get the stream's expiry time relative to now.
-  /**
-   * @return A relative time value representing the stream's expiry time.
-   */
-  duration expires_from_now() const
-  {
-    return rdbuf()->expires_from_now();
-  }
-
-  /// (Deprecated: Use expires_after().) Set the stream's expiry time relative
-  /// to now.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_from_now(const duration& expiry_time)
-  {
-    rdbuf()->expires_from_now(expiry_time);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-private:
-  // Disallow copying and assignment.
-  basic_socket_iostream(const basic_socket_iostream&) = delete;
-  basic_socket_iostream& operator=(
-      const basic_socket_iostream&) = delete;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_SOCKET_IOSTREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_streambuf.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_streambuf.hpp
deleted file mode 100644
index e3a5f83..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_socket_streambuf.hpp
+++ /dev/null
@@ -1,642 +0,0 @@
-//
-// basic_socket_streambuf.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_STREAMBUF_HPP
-#define ASIO_BASIC_SOCKET_STREAMBUF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include <streambuf>
-#include <vector>
-#include "asio/basic_socket.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/io_context.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-# include "asio/detail/deadline_timer_service.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-# include "asio/steady_timer.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// A separate base class is used to ensure that the io_context member is
-// initialised prior to the basic_socket_streambuf's basic_socket base class.
-class socket_streambuf_io_context
-{
-protected:
-  socket_streambuf_io_context(io_context* ctx)
-    : default_io_context_(ctx)
-  {
-  }
-
-  shared_ptr<io_context> default_io_context_;
-};
-
-// A separate base class is used to ensure that the dynamically allocated
-// buffers are constructed prior to the basic_socket_streambuf's basic_socket
-// base class. This makes moving the socket is the last potentially throwing
-// step in the streambuf's move constructor, giving the constructor a strong
-// exception safety guarantee.
-class socket_streambuf_buffers
-{
-protected:
-  socket_streambuf_buffers()
-    : get_buffer_(buffer_size),
-      put_buffer_(buffer_size)
-  {
-  }
-
-  enum { buffer_size = 512 };
-  std::vector<char> get_buffer_;
-  std::vector<char> put_buffer_;
-};
-
-} // namespace detail
-
-#if !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
-#define ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    typename Clock = boost::posix_time::ptime,
-    typename WaitTraits = time_traits<Clock>>
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-class basic_socket_streambuf;
-
-#endif // !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
-
-/// Iostream streambuf for a socket.
-#if defined(GENERATING_DOCUMENTATION)
-template <typename Protocol,
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#else // defined(GENERATING_DOCUMENTATION)
-template <typename Protocol, typename Clock, typename WaitTraits>
-#endif // defined(GENERATING_DOCUMENTATION)
-class basic_socket_streambuf
-  : public std::streambuf,
-    private detail::socket_streambuf_io_context,
-    private detail::socket_streambuf_buffers,
-#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-    private basic_socket<Protocol>
-#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-    public basic_socket<Protocol>
-#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-{
-private:
-  // These typedefs are intended keep this class's implementation independent
-  // of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-  typedef WaitTraits traits_helper;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-
-public:
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// The clock type.
-  typedef Clock clock_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// (Deprecated: Use time_point.) The time type.
-  typedef typename WaitTraits::time_type time_type;
-
-  /// The time type.
-  typedef typename WaitTraits::time_point time_point;
-
-  /// (Deprecated: Use duration.) The duration type.
-  typedef typename WaitTraits::duration_type duration_type;
-
-  /// The duration type.
-  typedef typename WaitTraits::duration duration;
-#else
-# if !defined(ASIO_NO_DEPRECATED)
-  typedef typename traits_helper::time_type time_type;
-  typedef typename traits_helper::duration_type duration_type;
-# endif // !defined(ASIO_NO_DEPRECATED)
-  typedef typename traits_helper::time_type time_point;
-  typedef typename traits_helper::duration_type duration;
-#endif
-
-  /// Construct a basic_socket_streambuf without establishing a connection.
-  basic_socket_streambuf()
-    : detail::socket_streambuf_io_context(new io_context),
-      basic_socket<Protocol>(*default_io_context_),
-      expiry_time_(max_expiry_time())
-  {
-    init_buffers();
-  }
-
-  /// Construct a basic_socket_streambuf from the supplied socket.
-  explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
-    : detail::socket_streambuf_io_context(0),
-      basic_socket<Protocol>(std::move(s)),
-      expiry_time_(max_expiry_time())
-  {
-    init_buffers();
-  }
-
-  /// Move-construct a basic_socket_streambuf from another.
-  basic_socket_streambuf(basic_socket_streambuf&& other)
-    : detail::socket_streambuf_io_context(other),
-      basic_socket<Protocol>(std::move(other.socket())),
-      ec_(other.ec_),
-      expiry_time_(other.expiry_time_)
-  {
-    get_buffer_.swap(other.get_buffer_);
-    put_buffer_.swap(other.put_buffer_);
-    setg(other.eback(), other.gptr(), other.egptr());
-    setp(other.pptr(), other.epptr());
-    other.ec_ = asio::error_code();
-    other.expiry_time_ = max_expiry_time();
-    other.init_buffers();
-  }
-
-  /// Move-assign a basic_socket_streambuf from another.
-  basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
-  {
-    this->close();
-    socket() = std::move(other.socket());
-    detail::socket_streambuf_io_context::operator=(other);
-    ec_ = other.ec_;
-    expiry_time_ = other.expiry_time_;
-    get_buffer_.swap(other.get_buffer_);
-    put_buffer_.swap(other.put_buffer_);
-    setg(other.eback(), other.gptr(), other.egptr());
-    setp(other.pptr(), other.epptr());
-    other.ec_ = asio::error_code();
-    other.expiry_time_ = max_expiry_time();
-    other.put_buffer_.resize(buffer_size);
-    other.init_buffers();
-    return *this;
-  }
-
-  /// Destructor flushes buffered data.
-  virtual ~basic_socket_streambuf()
-  {
-    if (pptr() != pbase())
-      overflow(traits_type::eof());
-  }
-
-  /// Establish a connection.
-  /**
-   * This function establishes a connection to the specified endpoint.
-   *
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  basic_socket_streambuf* connect(const endpoint_type& endpoint)
-  {
-    init_buffers();
-    ec_ = asio::error_code();
-    this->connect_to_endpoints(&endpoint, &endpoint + 1);
-    return !ec_ ? this : 0;
-  }
-
-  /// Establish a connection.
-  /**
-   * This function automatically establishes a connection based on the supplied
-   * resolver query parameters. The arguments are used to construct a resolver
-   * query object.
-   *
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  template <typename... T>
-  basic_socket_streambuf* connect(T... x)
-  {
-    init_buffers();
-    typedef typename Protocol::resolver resolver_type;
-    resolver_type resolver(socket().get_executor());
-    connect_to_endpoints(resolver.resolve(x..., ec_));
-    return !ec_ ? this : 0;
-  }
-
-  /// Close the connection.
-  /**
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  basic_socket_streambuf* close()
-  {
-    sync();
-    socket().close(ec_);
-    if (!ec_)
-      init_buffers();
-    return !ec_ ? this : 0;
-  }
-
-  /// Get a reference to the underlying socket.
-  basic_socket<Protocol>& socket()
-  {
-    return *this;
-  }
-
-  /// Get the last error associated with the stream buffer.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream
-   * buffer.
-   */
-  const asio::error_code& error() const
-  {
-    return ec_;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use error().) Get the last error associated with the stream
-  /// buffer.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream
-   * buffer.
-   */
-  const asio::error_code& puberror() const
-  {
-    return error();
-  }
-
-  /// (Deprecated: Use expiry().) Get the stream buffer's expiry time as an
-  /// absolute time.
-  /**
-   * @return An absolute time value representing the stream buffer's expiry
-   * time.
-   */
-  time_point expires_at() const
-  {
-    return expiry_time_;
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Get the stream buffer's expiry time as an absolute time.
-  /**
-   * @return An absolute time value representing the stream buffer's expiry
-   * time.
-   */
-  time_point expiry() const
-  {
-    return expiry_time_;
-  }
-
-  /// Set the stream buffer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the stream.
-   */
-  void expires_at(const time_point& expiry_time)
-  {
-    expiry_time_ = expiry_time;
-  }
-
-  /// Set the stream buffer's expiry time relative to now.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_after(const duration& expiry_time)
-  {
-    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use expiry().) Get the stream buffer's expiry time relative
-  /// to now.
-  /**
-   * @return A relative time value representing the stream buffer's expiry time.
-   */
-  duration expires_from_now() const
-  {
-    return traits_helper::subtract(expires_at(), traits_helper::now());
-  }
-
-  /// (Deprecated: Use expires_after().) Set the stream buffer's expiry time
-  /// relative to now.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_from_now(const duration& expiry_time)
-  {
-    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-protected:
-  int_type underflow()
-  {
-#if defined(ASIO_WINDOWS_RUNTIME)
-    ec_ = asio::error::operation_not_supported;
-    return traits_type::eof();
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    if (gptr() != egptr())
-      return traits_type::eof();
-
-    for (;;)
-    {
-      // Check if we are past the expiry time.
-      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
-      {
-        ec_ = asio::error::timed_out;
-        return traits_type::eof();
-      }
-
-      // Try to complete the operation without blocking.
-      if (!socket().native_non_blocking())
-        socket().native_non_blocking(true, ec_);
-      detail::buffer_sequence_adapter<mutable_buffer, mutable_buffer>
-        bufs(asio::buffer(get_buffer_) + putback_max);
-      detail::signed_size_type bytes = detail::socket_ops::recv(
-          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
-
-      // Check if operation succeeded.
-      if (bytes > 0)
-      {
-        setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
-            &get_buffer_[0] + putback_max + bytes);
-        return traits_type::to_int_type(*gptr());
-      }
-
-      // Check for EOF.
-      if (bytes == 0)
-      {
-        ec_ = asio::error::eof;
-        return traits_type::eof();
-      }
-
-      // Operation failed.
-      if (ec_ != asio::error::would_block
-          && ec_ != asio::error::try_again)
-        return traits_type::eof();
-
-      // Wait for socket to become ready.
-      if (detail::socket_ops::poll_read(
-            socket().native_handle(), 0, timeout(), ec_) < 0)
-        return traits_type::eof();
-    }
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-  }
-
-  int_type overflow(int_type c)
-  {
-#if defined(ASIO_WINDOWS_RUNTIME)
-    ec_ = asio::error::operation_not_supported;
-    return traits_type::eof();
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    char_type ch = traits_type::to_char_type(c);
-
-    // Determine what needs to be sent.
-    const_buffer output_buffer;
-    if (put_buffer_.empty())
-    {
-      if (traits_type::eq_int_type(c, traits_type::eof()))
-        return traits_type::not_eof(c); // Nothing to do.
-      output_buffer = asio::buffer(&ch, sizeof(char_type));
-    }
-    else
-    {
-      output_buffer = asio::buffer(pbase(),
-          (pptr() - pbase()) * sizeof(char_type));
-    }
-
-    while (output_buffer.size() > 0)
-    {
-      // Check if we are past the expiry time.
-      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
-      {
-        ec_ = asio::error::timed_out;
-        return traits_type::eof();
-      }
-
-      // Try to complete the operation without blocking.
-      if (!socket().native_non_blocking())
-        socket().native_non_blocking(true, ec_);
-      detail::buffer_sequence_adapter<
-        const_buffer, const_buffer> bufs(output_buffer);
-      detail::signed_size_type bytes = detail::socket_ops::send(
-          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
-
-      // Check if operation succeeded.
-      if (bytes > 0)
-      {
-        output_buffer += static_cast<std::size_t>(bytes);
-        continue;
-      }
-
-      // Operation failed.
-      if (ec_ != asio::error::would_block
-          && ec_ != asio::error::try_again)
-        return traits_type::eof();
-
-      // Wait for socket to become ready.
-      if (detail::socket_ops::poll_write(
-            socket().native_handle(), 0, timeout(), ec_) < 0)
-        return traits_type::eof();
-    }
-
-    if (!put_buffer_.empty())
-    {
-      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
-
-      // If the new character is eof then our work here is done.
-      if (traits_type::eq_int_type(c, traits_type::eof()))
-        return traits_type::not_eof(c);
-
-      // Add the new character to the output buffer.
-      *pptr() = ch;
-      pbump(1);
-    }
-
-    return c;
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-  }
-
-  int sync()
-  {
-    return overflow(traits_type::eof());
-  }
-
-  std::streambuf* setbuf(char_type* s, std::streamsize n)
-  {
-    if (pptr() == pbase() && s == 0 && n == 0)
-    {
-      put_buffer_.clear();
-      setp(0, 0);
-      sync();
-      return this;
-    }
-
-    return 0;
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_socket_streambuf(const basic_socket_streambuf&) = delete;
-  basic_socket_streambuf& operator=(
-      const basic_socket_streambuf&) = delete;
-
-  void init_buffers()
-  {
-    setg(&get_buffer_[0],
-        &get_buffer_[0] + putback_max,
-        &get_buffer_[0] + putback_max);
-
-    if (put_buffer_.empty())
-      setp(0, 0);
-    else
-      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
-  }
-
-  int timeout() const
-  {
-    int64_t msec = traits_helper::to_posix_duration(
-        traits_helper::subtract(expiry_time_,
-          traits_helper::now())).total_milliseconds();
-    if (msec > (std::numeric_limits<int>::max)())
-      msec = (std::numeric_limits<int>::max)();
-    else if (msec < 0)
-      msec = 0;
-    return static_cast<int>(msec);
-  }
-
-  template <typename EndpointSequence>
-  void connect_to_endpoints(const EndpointSequence& endpoints)
-  {
-    this->connect_to_endpoints(endpoints.begin(), endpoints.end());
-  }
-
-  template <typename EndpointIterator>
-  void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
-  {
-#if defined(ASIO_WINDOWS_RUNTIME)
-    ec_ = asio::error::operation_not_supported;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    if (ec_)
-      return;
-
-    ec_ = asio::error::not_found;
-    for (EndpointIterator i = begin; i != end; ++i)
-    {
-      // Check if we are past the expiry time.
-      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
-      {
-        ec_ = asio::error::timed_out;
-        return;
-      }
-
-      // Close and reopen the socket.
-      typename Protocol::endpoint ep(*i);
-      socket().close(ec_);
-      socket().open(ep.protocol(), ec_);
-      if (ec_)
-        continue;
-
-      // Try to complete the operation without blocking.
-      if (!socket().native_non_blocking())
-        socket().native_non_blocking(true, ec_);
-      detail::socket_ops::connect(socket().native_handle(),
-          ep.data(), ep.size(), ec_);
-
-      // Check if operation succeeded.
-      if (!ec_)
-        return;
-
-      // Operation failed.
-      if (ec_ != asio::error::in_progress
-          && ec_ != asio::error::would_block)
-        continue;
-
-      // Wait for socket to become ready.
-      if (detail::socket_ops::poll_connect(
-            socket().native_handle(), timeout(), ec_) < 0)
-        continue;
-
-      // Get the error code from the connect operation.
-      int connect_error = 0;
-      size_t connect_error_len = sizeof(connect_error);
-      if (detail::socket_ops::getsockopt(socket().native_handle(), 0,
-            SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec_)
-          == detail::socket_error_retval)
-        return;
-
-      // Check the result of the connect operation.
-      ec_ = asio::error_code(connect_error,
-          asio::error::get_system_category());
-      if (!ec_)
-        return;
-    }
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-  }
-
-  // Helper function to get the maximum expiry time.
-  static time_point max_expiry_time()
-  {
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    return boost::posix_time::pos_infin;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-    return (time_point::max)();
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
-  }
-
-  enum { putback_max = 8 };
-  asio::error_code ec_;
-  time_point expiry_time_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_SOCKET_STREAMBUF_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_file.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_file.hpp
deleted file mode 100644
index 5582e82..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_file.hpp
+++ /dev/null
@@ -1,744 +0,0 @@
-//
-// basic_stream_file.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAM_FILE_HPP
-#define ASIO_BASIC_STREAM_FILE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/basic_file.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_STREAM_FILE_FWD_DECL)
-#define ASIO_BASIC_STREAM_FILE_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Executor = any_io_executor>
-class basic_stream_file;
-
-#endif // !defined(ASIO_BASIC_STREAM_FILE_FWD_DECL)
-
-/// Provides stream-oriented file functionality.
-/**
- * The basic_stream_file class template provides asynchronous and blocking
- * stream-oriented file functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Executor>
-class basic_stream_file
-  : public basic_file<Executor>
-{
-private:
-  class initiate_async_write_some;
-  class initiate_async_read_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the file type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The file type when rebound to the specified executor.
-    typedef basic_stream_file<Executor1> other;
-  };
-
-  /// The native representation of a file.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_file<Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// Construct a basic_stream_file without opening it.
-  /**
-   * This constructor initialises a file without opening it. The file needs to
-   * be opened before data can be read from or or written to it.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   */
-  explicit basic_stream_file(const executor_type& ex)
-    : basic_file<Executor>(ex)
-  {
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-  }
-
-  /// Construct a basic_stream_file without opening it.
-  /**
-   * This constructor initialises a file without opening it. The file needs to
-   * be opened before data can be read from or or written to it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   */
-  template <typename ExecutionContext>
-  explicit basic_stream_file(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context)
-  {
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-  }
-
-  /// Construct and open a basic_stream_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_file(const executor_type& ex,
-      const char* path, file_base::flags open_flags)
-    : basic_file<Executor>(ex)
-  {
-    asio::error_code ec;
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-    this->impl_.get_service().open(
-        this->impl_.get_implementation(),
-        path, open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_stream_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_file(ExecutionContext& context,
-      const char* path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context)
-  {
-    asio::error_code ec;
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-    this->impl_.get_service().open(
-        this->impl_.get_implementation(),
-        path, open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_stream_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_file(const executor_type& ex,
-      const std::string& path, file_base::flags open_flags)
-    : basic_file<Executor>(ex)
-  {
-    asio::error_code ec;
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-    this->impl_.get_service().open(
-        this->impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct and open a basic_stream_file.
-  /**
-   * This constructor initialises and opens a file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param path The path name identifying the file to be opened.
-   *
-   * @param open_flags A set of flags that determine how the file should be
-   * opened.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_file(ExecutionContext& context,
-      const std::string& path, file_base::flags open_flags,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context)
-  {
-    asio::error_code ec;
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-    this->impl_.get_service().open(
-        this->impl_.get_implementation(),
-        path.c_str(), open_flags, ec);
-    asio::detail::throw_error(ec, "open");
-  }
-
-  /// Construct a basic_stream_file on an existing native file.
-  /**
-   * This constructor initialises a stream file object to hold an existing
-   * native file.
-   *
-   * @param ex The I/O executor that the file will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the file.
-   *
-   * @param native_file The new underlying file implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_file(const executor_type& ex,
-      const native_handle_type& native_file)
-    : basic_file<Executor>(ex, native_file)
-  {
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-  }
-
-  /// Construct a basic_stream_file on an existing native file.
-  /**
-   * This constructor initialises a stream file object to hold an existing
-   * native file.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the file will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the file.
-   *
-   * @param native_file The new underlying file implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_file(ExecutionContext& context,
-      const native_handle_type& native_file,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(context, native_file)
-  {
-    this->impl_.get_service().set_is_stream(
-        this->impl_.get_implementation(), true);
-  }
-
-  /// Move-construct a basic_stream_file from another.
-  /**
-   * This constructor moves a stream file from one object to another.
-   *
-   * @param other The other basic_stream_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_file(const executor_type&)
-   * constructor.
-   */
-  basic_stream_file(basic_stream_file&& other) noexcept
-    : basic_file<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_file from another.
-  /**
-   * This assignment operator moves a stream file from one object to another.
-   *
-   * @param other The other basic_stream_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_file(const executor_type&)
-   * constructor.
-   */
-  basic_stream_file& operator=(basic_stream_file&& other)
-  {
-    basic_file<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_stream_file from a file of another executor
-  /// type.
-  /**
-   * This constructor moves a stream file from one object to another.
-   *
-   * @param other The other basic_stream_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_file(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_stream_file(basic_stream_file<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_file<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_file from a file of another executor type.
-  /**
-   * This assignment operator moves a stream file from one object to another.
-   *
-   * @param other The other basic_stream_file object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_file(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_stream_file&
-  > operator=(basic_stream_file<Executor1>&& other)
-  {
-    basic_file<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the file.
-  /**
-   * This function destroys the file, cancelling any outstanding asynchronous
-   * operations associated with the file as if by calling @c cancel.
-   */
-  ~basic_stream_file()
-  {
-  }
-
-  /// Seek to a position in the file.
-  /**
-   * This function updates the current position in the file.
-   *
-   * @param offset The requested position in the file, relative to @c whence.
-   *
-   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
-   *
-   * @returns The new position relative to the beginning of the file.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  uint64_t seek(int64_t offset, file_base::seek_basis whence)
-  {
-    asio::error_code ec;
-    uint64_t n = this->impl_.get_service().seek(
-        this->impl_.get_implementation(), offset, whence, ec);
-    asio::detail::throw_error(ec, "seek");
-    return n;
-  }
-
-  /// Seek to a position in the file.
-  /**
-   * This function updates the current position in the file.
-   *
-   * @param offset The requested position in the file, relative to @c whence.
-   *
-   * @param whence One of @c seek_set, @c seek_cur or @c seek_end.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The new position relative to the beginning of the file.
-   */
-  uint64_t seek(int64_t offset, file_base::seek_basis whence,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().seek(
-        this->impl_.get_implementation(), offset, whence, ec);
-  }
-
-  /// Write some data to the file.
-  /**
-   * This function is used to write data to the stream file. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the file.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the end of the file was reached.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * file.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the file.
-  /**
-   * This function is used to write data to the stream file. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the file.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the stream file.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the file.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * file.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some>(), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-  /// Read some data from the file.
-  /**
-   * This function is used to read data from the stream file. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the end of the file was reached.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * file.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the file.
-  /**
-   * This function is used to read data from the stream file. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the stream file.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * file.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_stream_file(const basic_stream_file&) = delete;
-  basic_stream_file& operator=(const basic_stream_file&) = delete;
-
-  class initiate_async_write_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some(basic_stream_file* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_file* self_;
-  };
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some(basic_stream_file* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_file* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_STREAM_FILE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_socket.hpp
deleted file mode 100644
index 2733855..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_stream_socket.hpp
+++ /dev/null
@@ -1,1163 +0,0 @@
-//
-// basic_stream_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAM_SOCKET_HPP
-#define ASIO_BASIC_STREAM_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_STREAM_SOCKET_FWD_DECL)
-#define ASIO_BASIC_STREAM_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_stream_socket;
-
-#endif // !defined(ASIO_BASIC_STREAM_SOCKET_FWD_DECL)
-
-/// Provides stream-oriented socket functionality.
-/**
- * The basic_stream_socket class template provides asynchronous and blocking
- * stream-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c send, @c receive, @c connect, and @c shutdown operations are
- * thread safe with respect to each other, if the underlying operating system
- * calls are also thread safe. This means that it is permitted to perform
- * concurrent calls to these synchronous operations on a single socket object.
- * Other synchronous operations, such as @c open or @c close, are not thread
- * safe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Protocol, typename Executor>
-class basic_stream_socket
-  : public basic_socket<Protocol, Executor>
-{
-private:
-  class initiate_async_send;
-  class initiate_async_receive;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the socket type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The socket type when rebound to the specified executor.
-    typedef basic_stream_socket<Protocol, Executor1> other;
-  };
-
-  /// The native representation of a socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename basic_socket<Protocol,
-    Executor>::native_handle_type native_handle_type;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_stream_socket without opening it.
-  /**
-   * This constructor creates a stream socket without opening it. The socket
-   * needs to be opened and then connected or accepted before data can be sent
-   * or received on it.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_stream_socket(const executor_type& ex)
-    : basic_socket<Protocol, Executor>(ex)
-  {
-  }
-
-  /// Construct a basic_stream_socket without opening it.
-  /**
-   * This constructor creates a stream socket without opening it. The socket
-   * needs to be opened and then connected or accepted before data can be sent
-   * or received on it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   */
-  template <typename ExecutionContext>
-  explicit basic_stream_socket(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context)
-  {
-  }
-
-  /// Construct and open a basic_stream_socket.
-  /**
-   * This constructor creates and opens a stream socket. The socket needs to be
-   * connected or accepted before data can be sent or received on it.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(const executor_type& ex, const protocol_type& protocol)
-    : basic_socket<Protocol, Executor>(ex, protocol)
-  {
-  }
-
-  /// Construct and open a basic_stream_socket.
-  /**
-   * This constructor creates and opens a stream socket. The socket needs to be
-   * connected or accepted before data can be sent or received on it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_socket(ExecutionContext& context, const protocol_type& protocol,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_socket<Protocol, Executor>(context, protocol)
-  {
-  }
-
-  /// Construct a basic_stream_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a stream socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the stream
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(const executor_type& ex, const endpoint_type& endpoint)
-    : basic_socket<Protocol, Executor>(ex, endpoint)
-  {
-  }
-
-  /// Construct a basic_stream_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a stream socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the stream
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_socket(ExecutionContext& context, const endpoint_type& endpoint,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, endpoint)
-  {
-  }
-
-  /// Construct a basic_stream_socket on an existing native socket.
-  /**
-   * This constructor creates a stream socket object to hold an existing native
-   * socket.
-   *
-   * @param ex The I/O executor that the socket will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(const executor_type& ex,
-      const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, Executor>(ex, protocol, native_socket)
-  {
-  }
-
-  /// Construct a basic_stream_socket on an existing native socket.
-  /**
-   * This constructor creates a stream socket object to hold an existing native
-   * socket.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the socket will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_socket(ExecutionContext& context,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(context, protocol, native_socket)
-  {
-  }
-
-  /// Move-construct a basic_stream_socket from another.
-  /**
-   * This constructor moves a stream socket from one object to another.
-   *
-   * @param other The other basic_stream_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_socket(const executor_type&)
-   * constructor.
-   */
-  basic_stream_socket(basic_stream_socket&& other) noexcept
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_socket from another.
-  /**
-   * This assignment operator moves a stream socket from one object to another.
-   *
-   * @param other The other basic_stream_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_socket(const executor_type&)
-   * constructor.
-   */
-  basic_stream_socket& operator=(basic_stream_socket&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_stream_socket from a socket of another protocol
-  /// type.
-  /**
-   * This constructor moves a stream socket from one object to another.
-   *
-   * @param other The other basic_stream_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  basic_stream_socket(basic_stream_socket<Protocol1, Executor1>&& other,
-      constraint_t<
-        is_convertible<Protocol1, Protocol>::value
-          && is_convertible<Executor1, Executor>::value
-      > = 0)
-    : basic_socket<Protocol, Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_socket from a socket of another protocol type.
-  /**
-   * This assignment operator moves a stream socket from one object to another.
-   *
-   * @param other The other basic_stream_socket object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_socket(const executor_type&)
-   * constructor.
-   */
-  template <typename Protocol1, typename Executor1>
-  constraint_t<
-    is_convertible<Protocol1, Protocol>::value
-      && is_convertible<Executor1, Executor>::value,
-    basic_stream_socket&
-  > operator=(basic_stream_socket<Protocol1, Executor1>&& other)
-  {
-    basic_socket<Protocol, Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Destroys the socket.
-  /**
-   * This function destroys the socket, cancelling any outstanding asynchronous
-   * operations associated with the socket as if by calling @c cancel.
-   */
-  ~basic_stream_socket()
-  {
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(asio::buffer(data, size), 0);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent. Returns 0 if an error occurred.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the stream socket.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the stream socket.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the send completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), 0, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token, buffers, flags))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token, buffers, flags);
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size), 0);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-    asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received. Returns 0 if an error occurred.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the stream
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref async_read function if you need to ensure
-   * that the requested amount of data is received before the asynchronous
-   * operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the stream
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the receive completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref async_read function if you need to ensure
-   * that the requested amount of data is received before the asynchronous
-   * operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), 0, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token, buffers, flags))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token, buffers, flags);
-  }
-
-  /// Write some data to the socket.
-  /**
-   * This function is used to write data to the stream socket. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the socket.
-  /**
-   * This function is used to write data to the stream socket. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().send(
-        this->impl_.get_implementation(), buffers, 0, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the stream socket.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_send>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_send(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-  /// Read some data from the socket.
-  /**
-   * This function is used to read data from the stream socket. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, 0, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the socket.
-  /**
-   * This function is used to read data from the stream socket. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().receive(
-        this->impl_.get_implementation(), buffers, 0, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the stream socket.
-   * socket. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * On POSIX or Windows operating systems, this asynchronous operation supports
-   * cancellation for the following asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_receive>(), token,
-          buffers, socket_base::message_flags(0)))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_receive(this), token,
-        buffers, socket_base::message_flags(0));
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_stream_socket(const basic_stream_socket&) = delete;
-  basic_stream_socket& operator=(const basic_stream_socket&) = delete;
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_stream_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_send(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_socket* self_;
-  };
-
-  class initiate_async_receive
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive(basic_stream_socket* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers,
-        socket_base::message_flags flags) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_receive(
-          self_->impl_.get_implementation(), buffers, flags,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_socket* self_;
-  };
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_STREAM_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf.hpp
deleted file mode 100644
index 0450811..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf.hpp
+++ /dev/null
@@ -1,450 +0,0 @@
-//
-// basic_streambuf.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAMBUF_HPP
-#define ASIO_BASIC_STREAMBUF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include <algorithm>
-#include <cstring>
-#include <stdexcept>
-#include <streambuf>
-#include <vector>
-#include "asio/basic_streambuf_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Automatically resizable buffer class based on std::streambuf.
-/**
- * The @c basic_streambuf class is derived from @c std::streambuf to associate
- * the streambuf's input and output sequences with one or more character
- * arrays. These character arrays are internal to the @c basic_streambuf
- * object, but direct access to the array elements is provided to permit them
- * to be used efficiently with I/O operations. Characters written to the output
- * sequence of a @c basic_streambuf object are appended to the input sequence
- * of the same object.
- *
- * The @c basic_streambuf class's public interface is intended to permit the
- * following implementation strategies:
- *
- * @li A single contiguous character array, which is reallocated as necessary
- * to accommodate changes in the size of the character sequence. This is the
- * implementation approach currently used in Asio.
- *
- * @li A sequence of one or more character arrays, where each array is of the
- * same size. Additional character array objects are appended to the sequence
- * to accommodate changes in the size of the character sequence.
- *
- * @li A sequence of one or more character arrays of varying sizes. Additional
- * character array objects are appended to the sequence to accommodate changes
- * in the size of the character sequence.
- *
- * The constructor for basic_streambuf accepts a @c size_t argument specifying
- * the maximum of the sum of the sizes of the input sequence and output
- * sequence. During the lifetime of the @c basic_streambuf object, the following
- * invariant holds:
- * @code size() <= max_size()@endcode
- * Any member function that would, if successful, cause the invariant to be
- * violated shall throw an exception of class @c std::length_error.
- *
- * The constructor for @c basic_streambuf takes an Allocator argument. A copy
- * of this argument is used for any memory allocation performed, by the
- * constructor and by all member functions, during the lifetime of each @c
- * basic_streambuf object.
- *
- * @par Examples
- * Writing directly from an streambuf to a socket:
- * @code
- * asio::streambuf b;
- * std::ostream os(&b);
- * os << "Hello, World!\n";
- *
- * // try sending some data in input sequence
- * size_t n = sock.send(b.data());
- *
- * b.consume(n); // sent data is removed from input sequence
- * @endcode
- *
- * Reading from a socket directly into a streambuf:
- * @code
- * asio::streambuf b;
- *
- * // reserve 512 bytes in output sequence
- * asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
- *
- * size_t n = sock.receive(bufs);
- *
- * // received data is "committed" from output sequence to input sequence
- * b.commit(n);
- *
- * std::istream is(&b);
- * std::string s;
- * is >> s;
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-template <typename Allocator = std::allocator<char>>
-#else
-template <typename Allocator>
-#endif
-class basic_streambuf
-  : public std::streambuf,
-    private noncopyable
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type used to represent the input sequence as a list of buffers.
-  typedef implementation_defined const_buffers_type;
-
-  /// The type used to represent the output sequence as a list of buffers.
-  typedef implementation_defined mutable_buffers_type;
-#else
-  typedef ASIO_CONST_BUFFER const_buffers_type;
-  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
-#endif
-
-  /// Construct a basic_streambuf object.
-  /**
-   * Constructs a streambuf with the specified maximum size. The initial size
-   * of the streambuf's input sequence is 0.
-   */
-  explicit basic_streambuf(
-      std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
-      const Allocator& allocator = Allocator())
-    : max_size_(maximum_size),
-      buffer_(allocator)
-  {
-    std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
-    buffer_.resize((std::max<std::size_t>)(pend, 1));
-    setg(&buffer_[0], &buffer_[0], &buffer_[0]);
-    setp(&buffer_[0], &buffer_[0] + pend);
-  }
-
-  /// Get the size of the input sequence.
-  /**
-   * @returns The size of the input sequence. The value is equal to that
-   * calculated for @c s in the following code:
-   * @code
-   * size_t s = 0;
-   * const_buffers_type bufs = data();
-   * const_buffers_type::const_iterator i = bufs.begin();
-   * while (i != bufs.end())
-   * {
-   *   const_buffer buf(*i++);
-   *   s += buf.size();
-   * }
-   * @endcode
-   */
-  std::size_t size() const noexcept
-  {
-    return pptr() - gptr();
-  }
-
-  /// Get the maximum size of the basic_streambuf.
-  /**
-   * @returns The allowed maximum of the sum of the sizes of the input sequence
-   * and output sequence.
-   */
-  std::size_t max_size() const noexcept
-  {
-    return max_size_;
-  }
-
-  /// Get the current capacity of the basic_streambuf.
-  /**
-   * @returns The current total capacity of the streambuf, i.e. for both the
-   * input sequence and output sequence.
-   */
-  std::size_t capacity() const noexcept
-  {
-    return buffer_.capacity();
-  }
-
-  /// Get a list of buffers that represents the input sequence.
-  /**
-   * @returns An object of type @c const_buffers_type that satisfies
-   * ConstBufferSequence requirements, representing all character arrays in the
-   * input sequence.
-   *
-   * @note The returned object is invalidated by any @c basic_streambuf member
-   * function that modifies the input sequence or output sequence.
-   */
-  const_buffers_type data() const noexcept
-  {
-    return asio::buffer(asio::const_buffer(gptr(),
-          (pptr() - gptr()) * sizeof(char_type)));
-  }
-
-  /// Get a list of buffers that represents the output sequence, with the given
-  /// size.
-  /**
-   * Ensures that the output sequence can accommodate @c n characters,
-   * reallocating character array objects as necessary.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing character array objects
-   * at the start of the output sequence such that the sum of the buffer sizes
-   * is @c n.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   *
-   * @note The returned object is invalidated by any @c basic_streambuf member
-   * function that modifies the input sequence or output sequence.
-   */
-  mutable_buffers_type prepare(std::size_t n)
-  {
-    reserve(n);
-    return asio::buffer(asio::mutable_buffer(
-          pptr(), n * sizeof(char_type)));
-  }
-
-  /// Move characters from the output sequence to the input sequence.
-  /**
-   * Appends @c n characters from the start of the output sequence to the input
-   * sequence. The beginning of the output sequence is advanced by @c n
-   * characters.
-   *
-   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
-   * no intervening operations that modify the input or output sequence.
-   *
-   * @note If @c n is greater than the size of the output sequence, the entire
-   * output sequence is moved to the input sequence and no error is issued.
-   */
-  void commit(std::size_t n)
-  {
-    n = std::min<std::size_t>(n, epptr() - pptr());
-    pbump(static_cast<int>(n));
-    setg(eback(), gptr(), pptr());
-  }
-
-  /// Remove characters from the input sequence.
-  /**
-   * Removes @c n characters from the beginning of the input sequence.
-   *
-   * @note If @c n is greater than the size of the input sequence, the entire
-   * input sequence is consumed and no error is issued.
-   */
-  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));
-  }
-
-protected:
-  enum { buffer_delta = 128 };
-
-  /// Override std::streambuf behaviour.
-  /**
-   * Behaves according to the specification of @c std::streambuf::underflow().
-   */
-  int_type underflow()
-  {
-    if (gptr() < pptr())
-    {
-      setg(&buffer_[0], gptr(), pptr());
-      return traits_type::to_int_type(*gptr());
-    }
-    else
-    {
-      return traits_type::eof();
-    }
-  }
-
-  /// Override std::streambuf behaviour.
-  /**
-   * Behaves according to the specification of @c std::streambuf::overflow(),
-   * with the specialisation that @c std::length_error is thrown if appending
-   * the character to the input sequence would require the condition
-   * <tt>size() > max_size()</tt> to be true.
-   */
-  int_type overflow(int_type c)
-  {
-    if (!traits_type::eq_int_type(c, traits_type::eof()))
-    {
-      if (pptr() == epptr())
-      {
-        std::size_t buffer_size = pptr() - gptr();
-        if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
-        {
-          reserve(max_size_ - buffer_size);
-        }
-        else
-        {
-          reserve(buffer_delta);
-        }
-      }
-
-      *pptr() = traits_type::to_char_type(c);
-      pbump(1);
-      return c;
-    }
-
-    return traits_type::not_eof(c);
-  }
-
-  void reserve(std::size_t n)
-  {
-    // Get current stream positions as offsets.
-    std::size_t gnext = gptr() - &buffer_[0];
-    std::size_t pnext = pptr() - &buffer_[0];
-    std::size_t pend = epptr() - &buffer_[0];
-
-    // Check if there is already enough space in the put area.
-    if (n <= pend - pnext)
-    {
-      return;
-    }
-
-    // Shift existing contents of get area to start of buffer.
-    if (gnext > 0)
-    {
-      pnext -= gnext;
-      std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
-    }
-
-    // Ensure buffer is large enough to hold at least the specified size.
-    if (n > pend - pnext)
-    {
-      if (n <= max_size_ && pnext <= max_size_ - n)
-      {
-        pend = pnext + n;
-        buffer_.resize((std::max<std::size_t>)(pend, 1));
-      }
-      else
-      {
-        std::length_error ex("asio::streambuf too long");
-        asio::detail::throw_exception(ex);
-      }
-    }
-
-    // Update stream positions.
-    setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
-    setp(&buffer_[0] + pnext, &buffer_[0] + pend);
-  }
-
-private:
-  std::size_t max_size_;
-  std::vector<char_type, Allocator> buffer_;
-
-  // Helper function to get the preferred size for reading data.
-  friend std::size_t read_size_helper(
-      basic_streambuf& sb, std::size_t max_size)
-  {
-    return std::min<std::size_t>(
-        std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
-        std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
-  }
-};
-
-/// Adapts basic_streambuf to the dynamic buffer sequence type requirements.
-#if defined(GENERATING_DOCUMENTATION)
-template <typename Allocator = std::allocator<char>>
-#else
-template <typename Allocator>
-#endif
-class basic_streambuf_ref
-{
-public:
-  /// The type used to represent the input sequence as a list of buffers.
-  typedef typename basic_streambuf<Allocator>::const_buffers_type
-    const_buffers_type;
-
-  /// The type used to represent the output sequence as a list of buffers.
-  typedef typename basic_streambuf<Allocator>::mutable_buffers_type
-    mutable_buffers_type;
-
-  /// Construct a basic_streambuf_ref for the given basic_streambuf object.
-  explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
-    : sb_(sb)
-  {
-  }
-
-  /// Copy construct a basic_streambuf_ref.
-  basic_streambuf_ref(const basic_streambuf_ref& other) noexcept
-    : sb_(other.sb_)
-  {
-  }
-
-  /// Move construct a basic_streambuf_ref.
-  basic_streambuf_ref(basic_streambuf_ref&& other) noexcept
-    : sb_(other.sb_)
-  {
-  }
-
-  /// Get the size of the input sequence.
-  std::size_t size() const noexcept
-  {
-    return sb_.size();
-  }
-
-  /// Get the maximum size of the dynamic buffer.
-  std::size_t max_size() const noexcept
-  {
-    return sb_.max_size();
-  }
-
-  /// Get the current capacity of the dynamic buffer.
-  std::size_t capacity() const noexcept
-  {
-    return sb_.capacity();
-  }
-
-  /// Get a list of buffers that represents the input sequence.
-  const_buffers_type data() const noexcept
-  {
-    return sb_.data();
-  }
-
-  /// Get a list of buffers that represents the output sequence, with the given
-  /// size.
-  mutable_buffers_type prepare(std::size_t n)
-  {
-    return sb_.prepare(n);
-  }
-
-  /// Move bytes from the output sequence to the input sequence.
-  void commit(std::size_t n)
-  {
-    return sb_.commit(n);
-  }
-
-  /// Remove characters from the input sequence.
-  void consume(std::size_t n)
-  {
-    return sb_.consume(n);
-  }
-
-private:
-  basic_streambuf<Allocator>& sb_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_STREAMBUF_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf_fwd.hpp
deleted file mode 100644
index 1ff320d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_streambuf_fwd.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// basic_streambuf_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAMBUF_FWD_HPP
-#define ASIO_BASIC_STREAMBUF_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include <memory>
-
-namespace asio {
-
-template <typename Allocator = std::allocator<char>>
-class basic_streambuf;
-
-template <typename Allocator = std::allocator<char>>
-class basic_streambuf_ref;
-
-} // namespace asio
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_STREAMBUF_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_waitable_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_waitable_timer.hpp
deleted file mode 100644
index 62afb25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_waitable_timer.hpp
+++ /dev/null
@@ -1,824 +0,0 @@
-//
-// basic_waitable_timer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_WAITABLE_TIMER_HPP
-#define ASIO_BASIC_WAITABLE_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/detail/chrono_time_traits.hpp"
-#include "asio/detail/deadline_timer_service.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/wait_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
-#define ASIO_BASIC_WAITABLE_TIMER_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class basic_waitable_timer;
-
-#endif // !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
-
-/// Provides waitable timer functionality.
-/**
- * The basic_waitable_timer class template provides the ability to perform a
- * blocking or asynchronous wait for a timer to expire.
- *
- * A waitable timer is always in one of two states: "expired" or "not expired".
- * If the wait() or async_wait() function is called on an expired timer, the
- * wait operation will complete immediately.
- *
- * Most applications will use one of the asio::steady_timer,
- * asio::system_timer or asio::high_resolution_timer typedefs.
- *
- * @note This waitable timer functionality is for use with the C++11 standard
- * library's @c &lt;chrono&gt; facility, or with the Boost.Chrono library.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Examples
- * Performing a blocking wait (C++11):
- * @code
- * // Construct a timer without setting an expiry time.
- * asio::steady_timer timer(my_context);
- *
- * // Set an expiry time relative to now.
- * timer.expires_after(std::chrono::seconds(5));
- *
- * // Wait for the timer to expire.
- * timer.wait();
- * @endcode
- *
- * @par
- * Performing an asynchronous wait (C++11):
- * @code
- * void handler(const asio::error_code& error)
- * {
- *   if (!error)
- *   {
- *     // Timer expired.
- *   }
- * }
- *
- * ...
- *
- * // Construct a timer with an absolute expiry time.
- * asio::steady_timer timer(my_context,
- *     std::chrono::steady_clock::now() + std::chrono::seconds(60));
- *
- * // Start an asynchronous wait.
- * timer.async_wait(handler);
- * @endcode
- *
- * @par Changing an active waitable timer's expiry time
- *
- * Changing the expiry time of a timer while there are pending asynchronous
- * waits causes those wait operations to be cancelled. To ensure that the action
- * associated with the timer is performed only once, use something like this:
- * used:
- *
- * @code
- * void on_some_event()
- * {
- *   if (my_timer.expires_after(seconds(5)) > 0)
- *   {
- *     // We managed to cancel the timer. Start new asynchronous wait.
- *     my_timer.async_wait(on_timeout);
- *   }
- *   else
- *   {
- *     // Too late, timer has already expired!
- *   }
- * }
- *
- * void on_timeout(const asio::error_code& e)
- * {
- *   if (e != asio::error::operation_aborted)
- *   {
- *     // Timer was not cancelled, take necessary action.
- *   }
- * }
- * @endcode
- *
- * @li The asio::basic_waitable_timer::expires_after() function
- * cancels any pending asynchronous waits, and returns the number of
- * asynchronous waits that were cancelled. If it returns 0 then you were too
- * late and the wait handler has already been executed, or will soon be
- * executed. If it returns 1 then the wait handler was successfully cancelled.
- *
- * @li If a wait handler is cancelled, the asio::error_code passed to
- * it contains the value asio::error::operation_aborted.
- */
-template <typename Clock, typename WaitTraits, typename Executor>
-class basic_waitable_timer
-{
-private:
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the timer type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The timer type when rebound to the specified executor.
-    typedef basic_waitable_timer<Clock, WaitTraits, Executor1> other;
-  };
-
-  /// The clock type.
-  typedef Clock clock_type;
-
-  /// The duration type of the clock.
-  typedef typename clock_type::duration duration;
-
-  /// The time point type of the clock.
-  typedef typename clock_type::time_point time_point;
-
-  /// The wait traits type.
-  typedef WaitTraits traits_type;
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_after() functions must be called to set an expiry
-   * time before the timer can be waited on.
-   *
-   * @param ex The I/O executor that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   */
-  explicit basic_waitable_timer(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_after() functions must be called to set an expiry
-   * time before the timer can be waited on.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   */
-  template <typename ExecutionContext>
-  explicit basic_waitable_timer(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param ex The I/O executor object that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  basic_waitable_timer(const executor_type& ex, const time_point& expiry_time)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  template <typename ExecutionContext>
-  explicit basic_waitable_timer(ExecutionContext& context,
-      const time_point& expiry_time,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param ex The I/O executor that the timer will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  basic_waitable_timer(const executor_type& ex, const duration& expiry_time)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_after(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_after");
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the timer will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  template <typename ExecutionContext>
-  explicit basic_waitable_timer(ExecutionContext& context,
-      const duration& expiry_time,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().expires_after(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_after");
-  }
-
-  /// Move-construct a basic_waitable_timer from another.
-  /**
-   * This constructor moves a timer from one object to another.
-   *
-   * @param other The other basic_waitable_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_waitable_timer(const executor_type&)
-   * constructor.
-   */
-  basic_waitable_timer(basic_waitable_timer&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_waitable_timer from another.
-  /**
-   * This assignment operator moves a timer from one object to another. Cancels
-   * any outstanding asynchronous operations associated with the target object.
-   *
-   * @param other The other basic_waitable_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_waitable_timer(const executor_type&)
-   * constructor.
-   */
-  basic_waitable_timer& operator=(basic_waitable_timer&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All timers have access to each other's implementations.
-  template <typename Clock1, typename WaitTraits1, typename Executor1>
-  friend class basic_waitable_timer;
-
-  /// Move-construct a basic_waitable_timer from another.
-  /**
-   * This constructor moves a timer from one object to another.
-   *
-   * @param other The other basic_waitable_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_waitable_timer(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_waitable_timer(
-      basic_waitable_timer<Clock, WaitTraits, Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value
-      > = 0)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_waitable_timer from another.
-  /**
-   * This assignment operator moves a timer from one object to another. Cancels
-   * any outstanding asynchronous operations associated with the target object.
-   *
-   * @param other The other basic_waitable_timer object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_waitable_timer(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_waitable_timer&
-  > operator=(basic_waitable_timer<Clock, WaitTraits, Executor1>&& other)
-  {
-    basic_waitable_timer tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the timer.
-  /**
-   * This function destroys the timer, cancelling any outstanding asynchronous
-   * wait operations associated with the timer as if by calling @c cancel.
-   */
-  ~basic_waitable_timer()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel()
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-    return s;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Cancel any asynchronous
-  /// operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel(asio::error_code& ec)
-  {
-    return impl_.get_service().cancel(impl_.get_implementation(), ec);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one()
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().cancel_one(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel_one");
-    return s;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Cancels one asynchronous
-  /// operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one(asio::error_code& ec)
-  {
-    return impl_.get_service().cancel_one(impl_.get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use expiry().) Get the timer's expiry time as an absolute
-  /// time.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  time_point expires_at() const
-  {
-    return impl_.get_service().expires_at(impl_.get_implementation());
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Get the timer's expiry time as an absolute time.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  time_point expiry() const
-  {
-    return impl_.get_service().expiry(impl_.get_implementation());
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_point& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().expires_at(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_at");
-    return s;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Set the timer's expiry time as
-  /// an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_point& expiry_time,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().expires_at(
-        impl_.get_implementation(), expiry_time, ec);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_after() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_after(const duration& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().expires_after(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_after");
-    return s;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use expiry().) Get the timer's expiry time relative to now.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  duration expires_from_now() const
-  {
-    return impl_.get_service().expires_from_now(impl_.get_implementation());
-  }
-
-  /// (Deprecated: Use expires_after().) Set the timer's expiry time relative
-  /// to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-    asio::detail::throw_error(ec, "expires_from_now");
-    return s;
-  }
-
-  /// (Deprecated: Use expires_after().) Set the timer's expiry time relative
-  /// to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration& expiry_time,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().expires_from_now(
-        impl_.get_implementation(), expiry_time, ec);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-  }
-
-  /// Start an asynchronous wait on the timer.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * timer. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * For each call to async_wait(), the completion handler will be called
-   * exactly once. The completion handler will be called when:
-   *
-   * @li The timer has expired.
-   *
-   * @li The timer was cancelled, in which case the handler is passed the error
-   * code asio::error::operation_aborted.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the timer expires. Potential
-   * completion tokens include @ref use_future, @ref use_awaitable, @ref
-   * yield_context, or a function object with the correct completion signature.
-   * The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-        declval<initiate_async_wait>(), token))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_waitable_timer(const basic_waitable_timer&) = delete;
-  basic_waitable_timer& operator=(const basic_waitable_timer&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_waitable_timer* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(),
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_waitable_timer* self_;
-  };
-
-  detail::io_object_impl<
-    detail::deadline_timer_service<
-      detail::chrono_time_traits<Clock, WaitTraits>>,
-    executor_type > impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_WAITABLE_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_writable_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_writable_pipe.hpp
deleted file mode 100644
index c95e4d4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/basic_writable_pipe.hpp
+++ /dev/null
@@ -1,622 +0,0 @@
-//
-// basic_writable_pipe.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_WRITABLE_PIPE_HPP
-#define ASIO_BASIC_WRITABLE_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <string>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_handle_service.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_descriptor_service.hpp"
-#else
-# include "asio/detail/reactive_descriptor_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides pipe functionality.
-/**
- * The basic_writable_pipe class provides a wrapper over pipe
- * functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_writable_pipe
-{
-private:
-  class initiate_async_write_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the pipe type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The pipe type when rebound to the specified executor.
-    typedef basic_writable_pipe<Executor1> other;
-  };
-
-  /// The native representation of a pipe.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_handle_service::native_handle_type
-    native_handle_type;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef detail::io_uring_descriptor_service::native_handle_type
-    native_handle_type;
-#else
-  typedef detail::reactive_descriptor_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// A basic_writable_pipe is always the lowest layer.
-  typedef basic_writable_pipe lowest_layer_type;
-
-  /// Construct a basic_writable_pipe without opening it.
-  /**
-   * This constructor creates a pipe without opening it.
-   *
-   * @param ex The I/O executor that the pipe will use, by default, to dispatch
-   * handlers for any asynchronous operations performed on the pipe.
-   */
-  explicit basic_writable_pipe(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a basic_writable_pipe without opening it.
-  /**
-   * This constructor creates a pipe without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the pipe will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the pipe.
-   */
-  template <typename ExecutionContext>
-  explicit basic_writable_pipe(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct a basic_writable_pipe on an existing native pipe.
-  /**
-   * This constructor creates a pipe object to hold an existing native
-   * pipe.
-   *
-   * @param ex The I/O executor that the pipe will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_writable_pipe(const executor_type& ex,
-      const native_handle_type& native_pipe)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a basic_writable_pipe on an existing native pipe.
-  /**
-   * This constructor creates a pipe object to hold an existing native
-   * pipe.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the pipe will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_writable_pipe(ExecutionContext& context,
-      const native_handle_type& native_pipe,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a basic_writable_pipe from another.
-  /**
-   * This constructor moves a pipe from one object to another.
-   *
-   * @param other The other basic_writable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_writable_pipe(const executor_type&)
-   * constructor.
-   */
-  basic_writable_pipe(basic_writable_pipe&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_writable_pipe from another.
-  /**
-   * This assignment operator moves a pipe from one object to another.
-   *
-   * @param other The other basic_writable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_writable_pipe(const executor_type&)
-   * constructor.
-   */
-  basic_writable_pipe& operator=(basic_writable_pipe&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All pipes have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_writable_pipe;
-
-  /// Move-construct a basic_writable_pipe from a pipe of another executor type.
-  /**
-   * This constructor moves a pipe from one object to another.
-   *
-   * @param other The other basic_writable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_writable_pipe(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_writable_pipe(basic_writable_pipe<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_writable_pipe from a pipe of another executor type.
-  /**
-   * This assignment operator moves a pipe from one object to another.
-   *
-   * @param other The other basic_writable_pipe object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_writable_pipe(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_writable_pipe&
-  > operator=(basic_writable_pipe<Executor1>&& other)
-  {
-    basic_writable_pipe tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the pipe.
-  /**
-   * This function destroys the pipe, cancelling any outstanding
-   * asynchronous wait operations associated with the pipe as if by
-   * calling @c cancel.
-   */
-  ~basic_writable_pipe()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a basic_writable_pipe cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a basic_writable_pipe cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Assign an existing native pipe to the pipe.
-  /*
-   * This function opens the pipe to hold an existing native pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& native_pipe)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native pipe to the pipe.
-  /*
-   * This function opens the pipe to hold an existing native pipe.
-   *
-   * @param native_pipe A native pipe.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the pipe is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the pipe.
-  /**
-   * This function is used to close the pipe. Any asynchronous write operations
-   * will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the pipe.
-  /**
-   * This function is used to close the pipe. Any asynchronous write operations
-   * will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native pipe.
-  /**
-   * This function causes all outstanding asynchronous write operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native pipe is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native pipe.
-  /**
-   * This function causes all outstanding asynchronous write operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error. Ownership of the
-   * native pipe is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native pipe representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * pipe. This is intended to allow access to native pipe
-   * functionality that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the pipe.
-  /**
-   * This function causes all outstanding asynchronous write operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the pipe.
-  /**
-   * This function causes all outstanding asynchronous write operations to
-   * finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Write some data to the pipe.
-  /**
-   * This function is used to write data to the pipe. The function call will
-   * block until one or more bytes of the data has been written successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the pipe.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * pipe.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = impl_.get_service().write_some(
-        impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the pipe.
-  /**
-   * This function is used to write data to the pipe. The function call will
-   * block until one or more bytes of the data has been written successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the pipe.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return impl_.get_service().write_some(
-        impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the pipe. It is an
-   * initiating function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param buffers One or more data buffers to be written to the pipe.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * pipe.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some>(), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_writable_pipe(const basic_writable_pipe&) = delete;
-  basic_writable_pipe& operator=(const basic_writable_pipe&) = delete;
-
-  class initiate_async_write_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some(basic_writable_pipe* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_writable_pipe* self_;
-  };
-
-#if defined(ASIO_HAS_IOCP)
-  detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
-#else
-  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PIPE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_WRITABLE_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_allocator.hpp
deleted file mode 100644
index 0c520f0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_allocator.hpp
+++ /dev/null
@@ -1,596 +0,0 @@
-//
-// bind_allocator.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BIND_ALLOCATOR_HPP
-#define ASIO_BIND_ALLOCATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper to automatically define nested typedef result_type.
-
-template <typename T, typename = void>
-struct allocator_binder_result_type
-{
-protected:
-  typedef void result_type_or_void;
-};
-
-template <typename T>
-struct allocator_binder_result_type<T, void_t<typename T::result_type>>
-{
-  typedef typename T::result_type result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct allocator_binder_result_type<R(*)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct allocator_binder_result_type<R(&)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct allocator_binder_result_type<R(*)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct allocator_binder_result_type<R(&)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct allocator_binder_result_type<R(*)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct allocator_binder_result_type<R(&)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-// Helper to automatically define nested typedef argument_type.
-
-template <typename T, typename = void>
-struct allocator_binder_argument_type {};
-
-template <typename T>
-struct allocator_binder_argument_type<T, void_t<typename T::argument_type>>
-{
-  typedef typename T::argument_type argument_type;
-};
-
-template <typename R, typename A1>
-struct allocator_binder_argument_type<R(*)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-template <typename R, typename A1>
-struct allocator_binder_argument_type<R(&)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-// Helper to automatically define nested typedefs first_argument_type and
-// second_argument_type.
-
-template <typename T, typename = void>
-struct allocator_binder_argument_types {};
-
-template <typename T>
-struct allocator_binder_argument_types<T,
-    void_t<typename T::first_argument_type>>
-{
-  typedef typename T::first_argument_type first_argument_type;
-  typedef typename T::second_argument_type second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct allocator_binder_argument_type<R(*)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct allocator_binder_argument_type<R(&)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-} // namespace detail
-
-/// A call wrapper type to bind an allocator of type @c Allocator
-/// to an object of type @c T.
-template <typename T, typename Allocator>
-class allocator_binder
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::allocator_binder_result_type<T>,
-    public detail::allocator_binder_argument_type<T>,
-    public detail::allocator_binder_argument_types<T>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-public:
-  /// The type of the target object.
-  typedef T target_type;
-
-  /// The type of the associated allocator.
-  typedef Allocator allocator_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The return type if a function.
-  /**
-   * The type of @c result_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to function type, @c result_type is a synonym for
-   * the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c result_type, then @c
-   * result_type is a synonym for @c T::result_type;
-   *
-   * @li otherwise @c result_type is not defined.
-   */
-  typedef see_below result_type;
-
-  /// The type of the function's argument.
-  /**
-   * The type of @c argument_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to a function type accepting a single argument,
-   * @c argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c argument_type, then @c
-   * argument_type is a synonym for @c T::argument_type;
-   *
-   * @li otherwise @c argument_type is not defined.
-   */
-  typedef see_below argument_type;
-
-  /// The type of the function's first argument.
-  /**
-   * The type of @c first_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * first_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c first_argument_type is a synonym for @c T::first_argument_type;
-   *
-   * @li otherwise @c first_argument_type is not defined.
-   */
-  typedef see_below first_argument_type;
-
-  /// The type of the function's second argument.
-  /**
-   * The type of @c second_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * second_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c second_argument_type is a synonym for @c T::second_argument_type;
-   *
-   * @li otherwise @c second_argument_type is not defined.
-   */
-  typedef see_below second_argument_type;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct an allocator wrapper for the specified object.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U>
-  allocator_binder(const allocator_type& s, U&& u)
-    : allocator_(s),
-      target_(static_cast<U&&>(u))
-  {
-  }
-
-  /// Copy constructor.
-  allocator_binder(const allocator_binder& other)
-    : allocator_(other.get_allocator()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy, but specify a different allocator.
-  allocator_binder(const allocator_type& s, const allocator_binder& other)
-    : allocator_(s),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different allocator wrapper type.
-  /**
-   * This constructor is only valid if the @c Allocator type is
-   * constructible from type @c OtherAllocator, and the type @c T is
-   * constructible from type @c U.
-   */
-  template <typename U, typename OtherAllocator>
-  allocator_binder(const allocator_binder<U, OtherAllocator>& other,
-      constraint_t<is_constructible<Allocator, OtherAllocator>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : allocator_(other.get_allocator()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different allocator wrapper type, but
-  /// specify a different allocator.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U, typename OtherAllocator>
-  allocator_binder(const allocator_type& s,
-      const allocator_binder<U, OtherAllocator>& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : allocator_(s),
-      target_(other.get())
-  {
-  }
-
-  /// Move constructor.
-  allocator_binder(allocator_binder&& other)
-    : allocator_(static_cast<allocator_type&&>(
-          other.get_allocator())),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct the target object, but specify a different allocator.
-  allocator_binder(const allocator_type& s,
-      allocator_binder&& other)
-    : allocator_(s),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different allocator wrapper type.
-  template <typename U, typename OtherAllocator>
-  allocator_binder(
-      allocator_binder<U, OtherAllocator>&& other,
-      constraint_t<is_constructible<Allocator, OtherAllocator>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : allocator_(static_cast<OtherAllocator&&>(
-          other.get_allocator())),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different allocator wrapper type, but
-  /// specify a different allocator.
-  template <typename U, typename OtherAllocator>
-  allocator_binder(const allocator_type& s,
-      allocator_binder<U, OtherAllocator>&& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : allocator_(s),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Destructor.
-  ~allocator_binder()
-  {
-  }
-
-  /// Obtain a reference to the target object.
-  target_type& get() noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain a reference to the target object.
-  const target_type& get() const noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain the associated allocator.
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args)
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args) const
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-private:
-  Allocator allocator_;
-  T target_;
-};
-
-/// A function object type that adapts a @ref completion_token to specify that
-/// the completion handler should have the supplied allocator as its associated
-/// allocator.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Allocator>
-struct partial_allocator_binder
-{
-  /// Constructor that specifies associated allocator.
-  explicit partial_allocator_binder(const Allocator& ex)
-    : allocator_(ex)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// should have the allocator as its associated allocator.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr allocator_binder<decay_t<CompletionToken>, Allocator>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return allocator_binder<decay_t<CompletionToken>, Allocator>(
-        allocator_, static_cast<CompletionToken&&>(completion_token));
-  }
-
-//private:
-  Allocator allocator_;
-};
-
-/// Create a partial completion token that associates an allocator.
-template <typename Allocator>
-ASIO_NODISCARD inline partial_allocator_binder<Allocator>
-bind_allocator(const Allocator& ex)
-{
-  return partial_allocator_binder<Allocator>(ex);
-}
-
-/// Associate an object of type @c T with an allocator of type
-/// @c Allocator.
-template <typename Allocator, typename T>
-ASIO_NODISCARD inline allocator_binder<decay_t<T>, Allocator>
-bind_allocator(const Allocator& s, T&& t)
-{
-  return allocator_binder<decay_t<T>, Allocator>(s, static_cast<T&&>(t));
-}
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace detail {
-
-template <typename TargetAsyncResult, typename Allocator, typename = void>
-class allocator_binder_completion_handler_async_result
-{
-public:
-  template <typename T>
-  explicit allocator_binder_completion_handler_async_result(T&)
-  {
-  }
-};
-
-template <typename TargetAsyncResult, typename Allocator>
-class allocator_binder_completion_handler_async_result<
-    TargetAsyncResult, Allocator,
-    void_t<typename TargetAsyncResult::completion_handler_type>>
-{
-private:
-  TargetAsyncResult target_;
-
-public:
-  typedef allocator_binder<
-    typename TargetAsyncResult::completion_handler_type, Allocator>
-      completion_handler_type;
-
-  explicit allocator_binder_completion_handler_async_result(
-      typename TargetAsyncResult::completion_handler_type& handler)
-    : target_(handler)
-  {
-  }
-
-  auto get() -> decltype(target_.get())
-  {
-    return target_.get();
-  }
-};
-
-template <typename TargetAsyncResult, typename = void>
-struct allocator_binder_async_result_return_type
-{
-};
-
-template <typename TargetAsyncResult>
-struct allocator_binder_async_result_return_type<
-    TargetAsyncResult, void_type<typename TargetAsyncResult::return_type>>
-{
-  typedef typename TargetAsyncResult::return_type return_type;
-};
-
-} // namespace detail
-
-template <typename T, typename Allocator, typename Signature>
-class async_result<allocator_binder<T, Allocator>, Signature> :
-  public detail::allocator_binder_completion_handler_async_result<
-      async_result<T, Signature>, Allocator>,
-  public detail::allocator_binder_async_result_return_type<
-      async_result<T, Signature>>
-{
-public:
-  explicit async_result(allocator_binder<T, Allocator>& b)
-    : detail::allocator_binder_completion_handler_async_result<
-        async_result<T, Signature>, Allocator>(b.get())
-  {
-  }
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, const Allocator& a, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          allocator_binder<decay_t<Handler>, Allocator>(
-              a, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        const Allocator& a, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          allocator_binder<decay_t<Handler>, Allocator>(
-              a, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-        Signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.get(), token.get_allocator(), static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-      Signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.get(), token.get_allocator(), static_cast<Args&&>(args)...);
-  }
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-
-  async_result<T, Signature> target_;
-};
-
-template <typename Allocator, typename... Signatures>
-struct async_result<partial_allocator_binder<Allocator>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        allocator_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Allocator>(token.allocator_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        allocator_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Allocator>(token.allocator_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename T, typename Allocator, typename DefaultCandidate>
-struct associator<Associator, allocator_binder<T, Allocator>, DefaultCandidate>
-  : Associator<T, DefaultCandidate>
-{
-  static typename Associator<T, DefaultCandidate>::type get(
-      const allocator_binder<T, Allocator>& b) noexcept
-  {
-    return Associator<T, DefaultCandidate>::get(b.get());
-  }
-
-  static auto get(const allocator_binder<T, Allocator>& b,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
-  {
-    return Associator<T, DefaultCandidate>::get(b.get(), c);
-  }
-};
-
-template <typename T, typename Allocator, typename Allocator1>
-struct associated_allocator<allocator_binder<T, Allocator>, Allocator1>
-{
-  typedef Allocator type;
-
-  static auto get(const allocator_binder<T, Allocator>& b,
-      const Allocator1& = Allocator1()) noexcept
-    -> decltype(b.get_allocator())
-  {
-    return b.get_allocator();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BIND_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_cancellation_slot.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_cancellation_slot.hpp
deleted file mode 100644
index 3212379..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_cancellation_slot.hpp
+++ /dev/null
@@ -1,613 +0,0 @@
-//
-// bind_cancellation_slot.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BIND_CANCELLATION_SLOT_HPP
-#define ASIO_BIND_CANCELLATION_SLOT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper to automatically define nested typedef result_type.
-
-template <typename T, typename = void>
-struct cancellation_slot_binder_result_type
-{
-protected:
-  typedef void result_type_or_void;
-};
-
-template <typename T>
-struct cancellation_slot_binder_result_type<T, void_t<typename T::result_type>>
-{
-  typedef typename T::result_type result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct cancellation_slot_binder_result_type<R(*)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct cancellation_slot_binder_result_type<R(&)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct cancellation_slot_binder_result_type<R(*)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct cancellation_slot_binder_result_type<R(&)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct cancellation_slot_binder_result_type<R(*)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct cancellation_slot_binder_result_type<R(&)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-// Helper to automatically define nested typedef argument_type.
-
-template <typename T, typename = void>
-struct cancellation_slot_binder_argument_type {};
-
-template <typename T>
-struct cancellation_slot_binder_argument_type<T,
-    void_t<typename T::argument_type>>
-{
-  typedef typename T::argument_type argument_type;
-};
-
-template <typename R, typename A1>
-struct cancellation_slot_binder_argument_type<R(*)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-template <typename R, typename A1>
-struct cancellation_slot_binder_argument_type<R(&)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-// Helper to automatically define nested typedefs first_argument_type and
-// second_argument_type.
-
-template <typename T, typename = void>
-struct cancellation_slot_binder_argument_types {};
-
-template <typename T>
-struct cancellation_slot_binder_argument_types<T,
-    void_t<typename T::first_argument_type>>
-{
-  typedef typename T::first_argument_type first_argument_type;
-  typedef typename T::second_argument_type second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct cancellation_slot_binder_argument_type<R(*)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct cancellation_slot_binder_argument_type<R(&)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-} // namespace detail
-
-/// A call wrapper type to bind a cancellation slot of type @c CancellationSlot
-/// to an object of type @c T.
-template <typename T, typename CancellationSlot>
-class cancellation_slot_binder
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::cancellation_slot_binder_result_type<T>,
-    public detail::cancellation_slot_binder_argument_type<T>,
-    public detail::cancellation_slot_binder_argument_types<T>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-public:
-  /// The type of the target object.
-  typedef T target_type;
-
-  /// The type of the associated cancellation slot.
-  typedef CancellationSlot cancellation_slot_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The return type if a function.
-  /**
-   * The type of @c result_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to function type, @c result_type is a synonym for
-   * the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c result_type, then @c
-   * result_type is a synonym for @c T::result_type;
-   *
-   * @li otherwise @c result_type is not defined.
-   */
-  typedef see_below result_type;
-
-  /// The type of the function's argument.
-  /**
-   * The type of @c argument_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to a function type accepting a single argument,
-   * @c argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c argument_type, then @c
-   * argument_type is a synonym for @c T::argument_type;
-   *
-   * @li otherwise @c argument_type is not defined.
-   */
-  typedef see_below argument_type;
-
-  /// The type of the function's first argument.
-  /**
-   * The type of @c first_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * first_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c first_argument_type is a synonym for @c T::first_argument_type;
-   *
-   * @li otherwise @c first_argument_type is not defined.
-   */
-  typedef see_below first_argument_type;
-
-  /// The type of the function's second argument.
-  /**
-   * The type of @c second_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * second_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c second_argument_type is a synonym for @c T::second_argument_type;
-   *
-   * @li otherwise @c second_argument_type is not defined.
-   */
-  typedef see_below second_argument_type;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct a cancellation slot wrapper for the specified object.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U>
-  cancellation_slot_binder(const cancellation_slot_type& s, U&& u)
-    : slot_(s),
-      target_(static_cast<U&&>(u))
-  {
-  }
-
-  /// Copy constructor.
-  cancellation_slot_binder(const cancellation_slot_binder& other)
-    : slot_(other.get_cancellation_slot()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy, but specify a different cancellation slot.
-  cancellation_slot_binder(const cancellation_slot_type& s,
-      const cancellation_slot_binder& other)
-    : slot_(s),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different cancellation slot wrapper type.
-  /**
-   * This constructor is only valid if the @c CancellationSlot type is
-   * constructible from type @c OtherCancellationSlot, and the type @c T is
-   * constructible from type @c U.
-   */
-  template <typename U, typename OtherCancellationSlot>
-  cancellation_slot_binder(
-      const cancellation_slot_binder<U, OtherCancellationSlot>& other,
-      constraint_t<is_constructible<CancellationSlot,
-        OtherCancellationSlot>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : slot_(other.get_cancellation_slot()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different cancellation slot wrapper type, but
-  /// specify a different cancellation slot.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U, typename OtherCancellationSlot>
-  cancellation_slot_binder(const cancellation_slot_type& s,
-      const cancellation_slot_binder<U, OtherCancellationSlot>& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : slot_(s),
-      target_(other.get())
-  {
-  }
-
-  /// Move constructor.
-  cancellation_slot_binder(cancellation_slot_binder&& other)
-    : slot_(static_cast<cancellation_slot_type&&>(
-          other.get_cancellation_slot())),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct the target object, but specify a different cancellation
-  /// slot.
-  cancellation_slot_binder(const cancellation_slot_type& s,
-      cancellation_slot_binder&& other)
-    : slot_(s),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different cancellation slot wrapper type.
-  template <typename U, typename OtherCancellationSlot>
-  cancellation_slot_binder(
-      cancellation_slot_binder<U, OtherCancellationSlot>&& other,
-      constraint_t<is_constructible<CancellationSlot,
-        OtherCancellationSlot>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : slot_(static_cast<OtherCancellationSlot&&>(
-          other.get_cancellation_slot())),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different cancellation slot wrapper type, but
-  /// specify a different cancellation slot.
-  template <typename U, typename OtherCancellationSlot>
-  cancellation_slot_binder(const cancellation_slot_type& s,
-      cancellation_slot_binder<U, OtherCancellationSlot>&& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : slot_(s),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Destructor.
-  ~cancellation_slot_binder()
-  {
-  }
-
-  /// Obtain a reference to the target object.
-  target_type& get() noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain a reference to the target object.
-  const target_type& get() const noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain the associated cancellation slot.
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return slot_;
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args)
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args) const
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-private:
-  CancellationSlot slot_;
-  T target_;
-};
-
-/// A function object type that adapts a @ref completion_token to specify that
-/// the completion handler should have the supplied cancellation slot as its
-/// associated cancellation slot.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename CancellationSlot>
-struct partial_cancellation_slot_binder
-{
-  /// Constructor that specifies associated cancellation slot.
-  explicit partial_cancellation_slot_binder(const CancellationSlot& ex)
-    : cancellation_slot_(ex)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// should have the cancellation slot as its associated cancellation slot.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr cancellation_slot_binder<decay_t<CompletionToken>, CancellationSlot>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return cancellation_slot_binder<decay_t<CompletionToken>, CancellationSlot>(
-        static_cast<CompletionToken&&>(completion_token), cancellation_slot_);
-  }
-
-//private:
-  CancellationSlot cancellation_slot_;
-};
-
-/// Create a partial completion token that associates a cancellation slot.
-template <typename CancellationSlot>
-ASIO_NODISCARD inline partial_cancellation_slot_binder<CancellationSlot>
-bind_cancellation_slot(const CancellationSlot& ex)
-{
-  return partial_cancellation_slot_binder<CancellationSlot>(ex);
-}
-
-/// Associate an object of type @c T with a cancellation slot of type
-/// @c CancellationSlot.
-template <typename CancellationSlot, typename T>
-ASIO_NODISCARD inline
-cancellation_slot_binder<decay_t<T>, CancellationSlot>
-bind_cancellation_slot(const CancellationSlot& s, T&& t)
-{
-  return cancellation_slot_binder<decay_t<T>, CancellationSlot>(
-      s, static_cast<T&&>(t));
-}
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace detail {
-
-template <typename TargetAsyncResult,
-    typename CancellationSlot, typename = void>
-class cancellation_slot_binder_completion_handler_async_result
-{
-public:
-  template <typename T>
-  explicit cancellation_slot_binder_completion_handler_async_result(T&)
-  {
-  }
-};
-
-template <typename TargetAsyncResult, typename CancellationSlot>
-class cancellation_slot_binder_completion_handler_async_result<
-    TargetAsyncResult, CancellationSlot,
-    void_t<typename TargetAsyncResult::completion_handler_type>>
-{
-private:
-  TargetAsyncResult target_;
-
-public:
-  typedef cancellation_slot_binder<
-    typename TargetAsyncResult::completion_handler_type, CancellationSlot>
-      completion_handler_type;
-
-  explicit cancellation_slot_binder_completion_handler_async_result(
-      typename TargetAsyncResult::completion_handler_type& handler)
-    : target_(handler)
-  {
-  }
-
-  auto get() -> decltype(target_.get())
-  {
-    return target_.get();
-  }
-};
-
-template <typename TargetAsyncResult, typename = void>
-struct cancellation_slot_binder_async_result_return_type
-{
-};
-
-template <typename TargetAsyncResult>
-struct cancellation_slot_binder_async_result_return_type<
-    TargetAsyncResult, void_t<typename TargetAsyncResult::return_type>>
-{
-  typedef typename TargetAsyncResult::return_type return_type;
-};
-
-} // namespace detail
-
-template <typename T, typename CancellationSlot, typename Signature>
-class async_result<cancellation_slot_binder<T, CancellationSlot>, Signature> :
-  public detail::cancellation_slot_binder_completion_handler_async_result<
-      async_result<T, Signature>, CancellationSlot>,
-  public detail::cancellation_slot_binder_async_result_return_type<
-      async_result<T, Signature>>
-{
-public:
-  explicit async_result(cancellation_slot_binder<T, CancellationSlot>& b)
-    : detail::cancellation_slot_binder_completion_handler_async_result<
-        async_result<T, Signature>, CancellationSlot>(b.get())
-  {
-  }
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        const CancellationSlot& slot, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          cancellation_slot_binder<decay_t<Handler>, CancellationSlot>(
-              slot, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        const CancellationSlot& slot, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          cancellation_slot_binder<decay_t<Handler>, CancellationSlot>(
-              slot, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-        Signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.get(), token.get_cancellation_slot(),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-      Signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.get(), token.get_cancellation_slot(),
-        static_cast<Args&&>(args)...);
-  }
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-
-  async_result<T, Signature> target_;
-};
-
-template <typename CancellationSlot, typename... Signatures>
-struct async_result<partial_cancellation_slot_binder<CancellationSlot>,
-    Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancellation_slot_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          CancellationSlot>(token.cancellation_slot_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancellation_slot_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          CancellationSlot>(token.cancellation_slot_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename T, typename CancellationSlot, typename DefaultCandidate>
-struct associator<Associator,
-    cancellation_slot_binder<T, CancellationSlot>,
-    DefaultCandidate>
-  : Associator<T, DefaultCandidate>
-{
-  static typename Associator<T, DefaultCandidate>::type get(
-      const cancellation_slot_binder<T, CancellationSlot>& b) noexcept
-  {
-    return Associator<T, DefaultCandidate>::get(b.get());
-  }
-
-  static auto get(const cancellation_slot_binder<T, CancellationSlot>& b,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
-  {
-    return Associator<T, DefaultCandidate>::get(b.get(), c);
-  }
-};
-
-template <typename T, typename CancellationSlot, typename CancellationSlot1>
-struct associated_cancellation_slot<
-    cancellation_slot_binder<T, CancellationSlot>,
-    CancellationSlot1>
-{
-  typedef CancellationSlot type;
-
-  static auto get(const cancellation_slot_binder<T, CancellationSlot>& b,
-      const CancellationSlot1& = CancellationSlot1()) noexcept
-    -> decltype(b.get_cancellation_slot())
-  {
-    return b.get_cancellation_slot();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BIND_CANCELLATION_SLOT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_executor.hpp
deleted file mode 100644
index fcfafe2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_executor.hpp
+++ /dev/null
@@ -1,664 +0,0 @@
-//
-// bind_executor.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BIND_EXECUTOR_HPP
-#define ASIO_BIND_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/uses_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper to automatically define nested typedef result_type.
-
-template <typename T, typename = void>
-struct executor_binder_result_type
-{
-protected:
-  typedef void result_type_or_void;
-};
-
-template <typename T>
-struct executor_binder_result_type<T, void_t<typename T::result_type>>
-{
-  typedef typename T::result_type result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct executor_binder_result_type<R(*)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct executor_binder_result_type<R(&)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct executor_binder_result_type<R(*)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct executor_binder_result_type<R(&)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct executor_binder_result_type<R(*)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct executor_binder_result_type<R(&)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-// Helper to automatically define nested typedef argument_type.
-
-template <typename T, typename = void>
-struct executor_binder_argument_type {};
-
-template <typename T>
-struct executor_binder_argument_type<T, void_t<typename T::argument_type>>
-{
-  typedef typename T::argument_type argument_type;
-};
-
-template <typename R, typename A1>
-struct executor_binder_argument_type<R(*)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-template <typename R, typename A1>
-struct executor_binder_argument_type<R(&)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-// Helper to automatically define nested typedefs first_argument_type and
-// second_argument_type.
-
-template <typename T, typename = void>
-struct executor_binder_argument_types {};
-
-template <typename T>
-struct executor_binder_argument_types<T,
-    void_t<typename T::first_argument_type>>
-{
-  typedef typename T::first_argument_type first_argument_type;
-  typedef typename T::second_argument_type second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct executor_binder_argument_type<R(*)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct executor_binder_argument_type<R(&)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-// Helper to perform uses_executor construction of the target type, if
-// required.
-
-template <typename T, typename Executor, bool UsesExecutor>
-class executor_binder_base;
-
-template <typename T, typename Executor>
-class executor_binder_base<T, Executor, true>
-{
-protected:
-  template <typename E, typename U>
-  executor_binder_base(E&& e, U&& u)
-    : executor_(static_cast<E&&>(e)),
-      target_(executor_arg_t(), executor_, static_cast<U&&>(u))
-  {
-  }
-
-  Executor executor_;
-  T target_;
-};
-
-template <typename T, typename Executor>
-class executor_binder_base<T, Executor, false>
-{
-protected:
-  template <typename E, typename U>
-  executor_binder_base(E&& e, U&& u)
-    : executor_(static_cast<E&&>(e)),
-      target_(static_cast<U&&>(u))
-  {
-  }
-
-  Executor executor_;
-  T target_;
-};
-
-} // namespace detail
-
-/// A call wrapper type to bind an executor of type @c Executor to an object of
-/// type @c T.
-template <typename T, typename Executor>
-class executor_binder
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::executor_binder_result_type<T>,
-    public detail::executor_binder_argument_type<T>,
-    public detail::executor_binder_argument_types<T>,
-    private detail::executor_binder_base<
-      T, Executor, uses_executor<T, Executor>::value>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-public:
-  /// The type of the target object.
-  typedef T target_type;
-
-  /// The type of the associated executor.
-  typedef Executor executor_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The return type if a function.
-  /**
-   * The type of @c result_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to function type, @c result_type is a synonym for
-   * the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c result_type, then @c
-   * result_type is a synonym for @c T::result_type;
-   *
-   * @li otherwise @c result_type is not defined.
-   */
-  typedef see_below result_type;
-
-  /// The type of the function's argument.
-  /**
-   * The type of @c argument_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to a function type accepting a single argument,
-   * @c argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c argument_type, then @c
-   * argument_type is a synonym for @c T::argument_type;
-   *
-   * @li otherwise @c argument_type is not defined.
-   */
-  typedef see_below argument_type;
-
-  /// The type of the function's first argument.
-  /**
-   * The type of @c first_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * first_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c first_argument_type is a synonym for @c T::first_argument_type;
-   *
-   * @li otherwise @c first_argument_type is not defined.
-   */
-  typedef see_below first_argument_type;
-
-  /// The type of the function's second argument.
-  /**
-   * The type of @c second_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * second_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c second_argument_type is a synonym for @c T::second_argument_type;
-   *
-   * @li otherwise @c second_argument_type is not defined.
-   */
-  typedef see_below second_argument_type;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct an executor wrapper for the specified object.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U>
-  executor_binder(executor_arg_t, const executor_type& e,
-      U&& u)
-    : base_type(e, static_cast<U&&>(u))
-  {
-  }
-
-  /// Copy constructor.
-  executor_binder(const executor_binder& other)
-    : base_type(other.get_executor(), other.get())
-  {
-  }
-
-  /// Construct a copy, but specify a different executor.
-  executor_binder(executor_arg_t, const executor_type& e,
-      const executor_binder& other)
-    : base_type(e, other.get())
-  {
-  }
-
-  /// Construct a copy of a different executor wrapper type.
-  /**
-   * This constructor is only valid if the @c Executor type is constructible
-   * from type @c OtherExecutor, and the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U, typename OtherExecutor>
-  executor_binder(const executor_binder<U, OtherExecutor>& other,
-      constraint_t<is_constructible<Executor, OtherExecutor>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : base_type(other.get_executor(), other.get())
-  {
-  }
-
-  /// Construct a copy of a different executor wrapper type, but specify a
-  /// different executor.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U, typename OtherExecutor>
-  executor_binder(executor_arg_t, const executor_type& e,
-      const executor_binder<U, OtherExecutor>& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : base_type(e, other.get())
-  {
-  }
-
-  /// Move constructor.
-  executor_binder(executor_binder&& other)
-    : base_type(static_cast<executor_type&&>(other.get_executor()),
-        static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct the target object, but specify a different executor.
-  executor_binder(executor_arg_t, const executor_type& e,
-      executor_binder&& other)
-    : base_type(e, static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different executor wrapper type.
-  template <typename U, typename OtherExecutor>
-  executor_binder(executor_binder<U, OtherExecutor>&& other,
-      constraint_t<is_constructible<Executor, OtherExecutor>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : base_type(static_cast<OtherExecutor&&>(other.get_executor()),
-        static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different executor wrapper type, but specify a
-  /// different executor.
-  template <typename U, typename OtherExecutor>
-  executor_binder(executor_arg_t, const executor_type& e,
-      executor_binder<U, OtherExecutor>&& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : base_type(e, static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Destructor.
-  ~executor_binder()
-  {
-  }
-
-  /// Obtain a reference to the target object.
-  target_type& get() noexcept
-  {
-    return this->target_;
-  }
-
-  /// Obtain a reference to the target object.
-  const target_type& get() const noexcept
-  {
-    return this->target_;
-  }
-
-  /// Obtain the associated executor.
-  executor_type get_executor() const noexcept
-  {
-    return this->executor_;
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args)
-  {
-    return this->target_(static_cast<Args&&>(args)...);
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args) const
-  {
-    return this->target_(static_cast<Args&&>(args)...);
-  }
-
-private:
-  typedef detail::executor_binder_base<T, Executor,
-    uses_executor<T, Executor>::value> base_type;
-};
-
-/// A function object type that adapts a @ref completion_token to specify that
-/// the completion handler should have the supplied executor as its associated
-/// executor.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Executor>
-struct partial_executor_binder
-{
-  /// Constructor that specifies associated executor.
-  explicit partial_executor_binder(const Executor& ex)
-    : executor_(ex)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// should have the executor as its associated executor.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr executor_binder<decay_t<CompletionToken>, Executor>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return executor_binder<decay_t<CompletionToken>, Executor>(executor_arg_t(),
-        static_cast<CompletionToken&&>(completion_token), executor_);
-  }
-
-//private:
-  Executor executor_;
-};
-
-/// Create a partial completion token that associates an executor.
-template <typename Executor>
-ASIO_NODISCARD inline partial_executor_binder<Executor>
-bind_executor(const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return partial_executor_binder<Executor>(ex);
-}
-
-/// Associate an object of type @c T with an executor of type @c Executor.
-template <typename Executor, typename T>
-ASIO_NODISCARD inline executor_binder<decay_t<T>, Executor>
-bind_executor(const Executor& ex, T&& t,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return executor_binder<decay_t<T>, Executor>(
-      executor_arg_t(), ex, static_cast<T&&>(t));
-}
-
-/// Create a partial completion token that associates an execution context's
-/// executor.
-template <typename ExecutionContext>
-ASIO_NODISCARD inline partial_executor_binder<
-    typename ExecutionContext::executor_type>
-bind_executor(ExecutionContext& ctx,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return partial_executor_binder<typename ExecutionContext::executor_type>(
-      ctx.get_executor());
-}
-
-/// Associate an object of type @c T with an execution context's executor.
-template <typename ExecutionContext, typename T>
-ASIO_NODISCARD inline executor_binder<decay_t<T>,
-    typename ExecutionContext::executor_type>
-bind_executor(ExecutionContext& ctx, T&& t,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return executor_binder<decay_t<T>, typename ExecutionContext::executor_type>(
-      executor_arg_t(), ctx.get_executor(), static_cast<T&&>(t));
-}
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename T, typename Executor>
-struct uses_executor<executor_binder<T, Executor>, Executor>
-  : true_type {};
-
-namespace detail {
-
-template <typename TargetAsyncResult, typename Executor, typename = void>
-class executor_binder_completion_handler_async_result
-{
-public:
-  template <typename T>
-  explicit executor_binder_completion_handler_async_result(T&)
-  {
-  }
-};
-
-template <typename TargetAsyncResult, typename Executor>
-class executor_binder_completion_handler_async_result<
-    TargetAsyncResult, Executor,
-    void_t<typename TargetAsyncResult::completion_handler_type >>
-{
-private:
-  TargetAsyncResult target_;
-
-public:
-  typedef executor_binder<
-    typename TargetAsyncResult::completion_handler_type, Executor>
-      completion_handler_type;
-
-  explicit executor_binder_completion_handler_async_result(
-      typename TargetAsyncResult::completion_handler_type& handler)
-    : target_(handler)
-  {
-  }
-
-  auto get() -> decltype(target_.get())
-  {
-    return target_.get();
-  }
-};
-
-template <typename TargetAsyncResult, typename = void>
-struct executor_binder_async_result_return_type
-{
-};
-
-template <typename TargetAsyncResult>
-struct executor_binder_async_result_return_type<TargetAsyncResult,
-    void_t<typename TargetAsyncResult::return_type>>
-{
-  typedef typename TargetAsyncResult::return_type return_type;
-};
-
-} // namespace detail
-
-template <typename T, typename Executor, typename Signature>
-class async_result<executor_binder<T, Executor>, Signature> :
-  public detail::executor_binder_completion_handler_async_result<
-      async_result<T, Signature>, Executor>,
-  public detail::executor_binder_async_result_return_type<
-      async_result<T, Signature>>
-{
-public:
-  explicit async_result(executor_binder<T, Executor>& b)
-    : detail::executor_binder_completion_handler_async_result<
-        async_result<T, Signature>, Executor>(b.get())
-  {
-  }
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, const Executor& e, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          executor_binder<decay_t<Handler>, Executor>(
-            executor_arg_t(), e, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        const Executor& e, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          executor_binder<decay_t<Handler>, Executor>(
-            executor_arg_t(), e, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-        Signature>(
-          declval<init_wrapper<decay_t<Initiation>>>(),
-          token.get(), token.get_executor(), static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-      Signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.get(), token.get_executor(), static_cast<Args&&>(args)...);
-  }
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-};
-
-template <typename Executor, typename... Signatures>
-struct async_result<partial_executor_binder<Executor>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        executor_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Executor>(executor_arg_t(), token.executor_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        executor_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Executor>(executor_arg_t(), token.executor_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename T, typename Executor, typename DefaultCandidate>
-struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate>
-  : Associator<T, DefaultCandidate>
-{
-  static typename Associator<T, DefaultCandidate>::type get(
-      const executor_binder<T, Executor>& b) noexcept
-  {
-    return Associator<T, DefaultCandidate>::get(b.get());
-  }
-
-  static auto get(const executor_binder<T, Executor>& b,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
-  {
-    return Associator<T, DefaultCandidate>::get(b.get(), c);
-  }
-};
-
-template <typename T, typename Executor, typename Executor1>
-struct associated_executor<executor_binder<T, Executor>, Executor1>
-{
-  typedef Executor type;
-
-  static auto get(const executor_binder<T, Executor>& b,
-      const Executor1& = Executor1()) noexcept
-    -> decltype(b.get_executor())
-  {
-    return b.get_executor();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BIND_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_immediate_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_immediate_executor.hpp
deleted file mode 100644
index b419c15..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/bind_immediate_executor.hpp
+++ /dev/null
@@ -1,616 +0,0 @@
-//
-// bind_immediate_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BIND_IMMEDIATE_EXECUTOR_HPP
-#define ASIO_BIND_IMMEDIATE_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper to automatically define nested typedef result_type.
-
-template <typename T, typename = void>
-struct immediate_executor_binder_result_type
-{
-protected:
-  typedef void result_type_or_void;
-};
-
-template <typename T>
-struct immediate_executor_binder_result_type<T, void_t<typename T::result_type>>
-{
-  typedef typename T::result_type result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct immediate_executor_binder_result_type<R(*)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R>
-struct immediate_executor_binder_result_type<R(&)()>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct immediate_executor_binder_result_type<R(*)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1>
-struct immediate_executor_binder_result_type<R(&)(A1)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct immediate_executor_binder_result_type<R(*)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-template <typename R, typename A1, typename A2>
-struct immediate_executor_binder_result_type<R(&)(A1, A2)>
-{
-  typedef R result_type;
-protected:
-  typedef result_type result_type_or_void;
-};
-
-// Helper to automatically define nested typedef argument_type.
-
-template <typename T, typename = void>
-struct immediate_executor_binder_argument_type {};
-
-template <typename T>
-struct immediate_executor_binder_argument_type<T,
-  void_t<typename T::argument_type>>
-{
-  typedef typename T::argument_type argument_type;
-};
-
-template <typename R, typename A1>
-struct immediate_executor_binder_argument_type<R(*)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-template <typename R, typename A1>
-struct immediate_executor_binder_argument_type<R(&)(A1)>
-{
-  typedef A1 argument_type;
-};
-
-// Helper to automatically define nested typedefs first_argument_type and
-// second_argument_type.
-
-template <typename T, typename = void>
-struct immediate_executor_binder_argument_types {};
-
-template <typename T>
-struct immediate_executor_binder_argument_types<T,
-  void_t<typename T::first_argument_type>>
-{
-  typedef typename T::first_argument_type first_argument_type;
-  typedef typename T::second_argument_type second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct immediate_executor_binder_argument_type<R(*)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-template <typename R, typename A1, typename A2>
-struct immediate_executor_binder_argument_type<R(&)(A1, A2)>
-{
-  typedef A1 first_argument_type;
-  typedef A2 second_argument_type;
-};
-
-} // namespace detail
-
-/// A call wrapper type to bind a immediate executor of type @c Executor
-/// to an object of type @c T.
-template <typename T, typename Executor>
-class immediate_executor_binder
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::immediate_executor_binder_result_type<T>,
-    public detail::immediate_executor_binder_argument_type<T>,
-    public detail::immediate_executor_binder_argument_types<T>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-public:
-  /// The type of the target object.
-  typedef T target_type;
-
-  /// The type of the associated immediate executor.
-  typedef Executor immediate_executor_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The return type if a function.
-  /**
-   * The type of @c result_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to function type, @c result_type is a synonym for
-   * the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c result_type, then @c
-   * result_type is a synonym for @c T::result_type;
-   *
-   * @li otherwise @c result_type is not defined.
-   */
-  typedef see_below result_type;
-
-  /// The type of the function's argument.
-  /**
-   * The type of @c argument_type is based on the type @c T of the wrapper's
-   * target object:
-   *
-   * @li if @c T is a pointer to a function type accepting a single argument,
-   * @c argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c argument_type, then @c
-   * argument_type is a synonym for @c T::argument_type;
-   *
-   * @li otherwise @c argument_type is not defined.
-   */
-  typedef see_below argument_type;
-
-  /// The type of the function's first argument.
-  /**
-   * The type of @c first_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * first_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c first_argument_type is a synonym for @c T::first_argument_type;
-   *
-   * @li otherwise @c first_argument_type is not defined.
-   */
-  typedef see_below first_argument_type;
-
-  /// The type of the function's second argument.
-  /**
-   * The type of @c second_argument_type is based on the type @c T of the
-   * wrapper's target object:
-   *
-   * @li if @c T is a pointer to a function type accepting two arguments, @c
-   * second_argument_type is a synonym for the return type of @c T;
-   *
-   * @li if @c T is a class type with a member type @c first_argument_type,
-   * then @c second_argument_type is a synonym for @c T::second_argument_type;
-   *
-   * @li otherwise @c second_argument_type is not defined.
-   */
-  typedef see_below second_argument_type;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Construct a immediate executor wrapper for the specified object.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U>
-  immediate_executor_binder(const immediate_executor_type& e,
-      U&& u)
-    : executor_(e),
-      target_(static_cast<U&&>(u))
-  {
-  }
-
-  /// Copy constructor.
-  immediate_executor_binder(const immediate_executor_binder& other)
-    : executor_(other.get_immediate_executor()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy, but specify a different immediate executor.
-  immediate_executor_binder(const immediate_executor_type& e,
-      const immediate_executor_binder& other)
-    : executor_(e),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different immediate executor wrapper type.
-  /**
-   * This constructor is only valid if the @c Executor type is
-   * constructible from type @c OtherExecutor, and the type @c T is
-   * constructible from type @c U.
-   */
-  template <typename U, typename OtherExecutor>
-  immediate_executor_binder(
-      const immediate_executor_binder<U, OtherExecutor>& other,
-      constraint_t<is_constructible<Executor, OtherExecutor>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : executor_(other.get_immediate_executor()),
-      target_(other.get())
-  {
-  }
-
-  /// Construct a copy of a different immediate executor wrapper type, but
-  /// specify a different immediate executor.
-  /**
-   * This constructor is only valid if the type @c T is constructible from type
-   * @c U.
-   */
-  template <typename U, typename OtherExecutor>
-  immediate_executor_binder(const immediate_executor_type& e,
-      const immediate_executor_binder<U, OtherExecutor>& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : executor_(e),
-      target_(other.get())
-  {
-  }
-
-  /// Move constructor.
-  immediate_executor_binder(immediate_executor_binder&& other)
-    : executor_(static_cast<immediate_executor_type&&>(
-          other.get_immediate_executor())),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct the target object, but specify a different immediate
-  /// executor.
-  immediate_executor_binder(const immediate_executor_type& e,
-      immediate_executor_binder&& other)
-    : executor_(e),
-      target_(static_cast<T&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different immediate executor wrapper type.
-  template <typename U, typename OtherExecutor>
-  immediate_executor_binder(
-      immediate_executor_binder<U, OtherExecutor>&& other,
-      constraint_t<is_constructible<Executor, OtherExecutor>::value> = 0,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : executor_(static_cast<OtherExecutor&&>(
-          other.get_immediate_executor())),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Move construct from a different immediate executor wrapper type, but
-  /// specify a different immediate executor.
-  template <typename U, typename OtherExecutor>
-  immediate_executor_binder(const immediate_executor_type& e,
-      immediate_executor_binder<U, OtherExecutor>&& other,
-      constraint_t<is_constructible<T, U>::value> = 0)
-    : executor_(e),
-      target_(static_cast<U&&>(other.get()))
-  {
-  }
-
-  /// Destructor.
-  ~immediate_executor_binder()
-  {
-  }
-
-  /// Obtain a reference to the target object.
-  target_type& get() noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain a reference to the target object.
-  const target_type& get() const noexcept
-  {
-    return target_;
-  }
-
-  /// Obtain the associated immediate executor.
-  immediate_executor_type get_immediate_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args)
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-  /// Forwarding function call operator.
-  template <typename... Args>
-  result_of_t<T(Args...)> operator()(Args&&... args) const
-  {
-    return target_(static_cast<Args&&>(args)...);
-  }
-
-private:
-  Executor executor_;
-  T target_;
-};
-
-/// A function object type that adapts a @ref completion_token to specify that
-/// the completion handler should have the supplied executor as its associated
-/// immediate executor.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Executor>
-struct partial_immediate_executor_binder
-{
-  /// Constructor that specifies associated executor.
-  explicit partial_immediate_executor_binder(const Executor& ex)
-    : executor_(ex)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// should have the executor as its associated immediate executor.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr immediate_executor_binder<decay_t<CompletionToken>, Executor>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return immediate_executor_binder<decay_t<CompletionToken>, Executor>(
-        static_cast<CompletionToken&&>(completion_token), executor_);
-  }
-
-//private:
-  Executor executor_;
-};
-
-/// Create a partial completion token that associates an executor.
-template <typename Executor>
-ASIO_NODISCARD inline partial_immediate_executor_binder<Executor>
-bind_immediate_executor(const Executor& ex)
-{
-  return partial_immediate_executor_binder<Executor>(ex);
-}
-
-/// Associate an object of type @c T with a immediate executor of type
-/// @c Executor.
-template <typename Executor, typename T>
-ASIO_NODISCARD inline immediate_executor_binder<decay_t<T>, Executor>
-bind_immediate_executor(const Executor& e, T&& t)
-{
-  return immediate_executor_binder<
-    decay_t<T>, Executor>(
-      e, static_cast<T&&>(t));
-}
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace detail {
-
-template <typename TargetAsyncResult, typename Executor, typename = void>
-class immediate_executor_binder_completion_handler_async_result
-{
-public:
-  template <typename T>
-  explicit immediate_executor_binder_completion_handler_async_result(T&)
-  {
-  }
-};
-
-template <typename TargetAsyncResult, typename Executor>
-class immediate_executor_binder_completion_handler_async_result<
-  TargetAsyncResult, Executor,
-  void_t<
-    typename TargetAsyncResult::completion_handler_type
-  >>
-{
-private:
-  TargetAsyncResult target_;
-
-public:
-  typedef immediate_executor_binder<
-    typename TargetAsyncResult::completion_handler_type, Executor>
-      completion_handler_type;
-
-  explicit immediate_executor_binder_completion_handler_async_result(
-      typename TargetAsyncResult::completion_handler_type& handler)
-    : target_(handler)
-  {
-  }
-
-  auto get() -> decltype(target_.get())
-  {
-    return target_.get();
-  }
-};
-
-template <typename TargetAsyncResult, typename = void>
-struct immediate_executor_binder_async_result_return_type
-{
-};
-
-template <typename TargetAsyncResult>
-struct immediate_executor_binder_async_result_return_type<
-  TargetAsyncResult,
-  void_t<
-    typename TargetAsyncResult::return_type
-  >>
-{
-  typedef typename TargetAsyncResult::return_type return_type;
-};
-
-} // namespace detail
-
-template <typename T, typename Executor, typename Signature>
-class async_result<immediate_executor_binder<T, Executor>, Signature> :
-  public detail::immediate_executor_binder_completion_handler_async_result<
-    async_result<T, Signature>, Executor>,
-  public detail::immediate_executor_binder_async_result_return_type<
-    async_result<T, Signature>>
-{
-public:
-  explicit async_result(immediate_executor_binder<T, Executor>& b)
-    : detail::immediate_executor_binder_completion_handler_async_result<
-        async_result<T, Signature>, Executor>(b.get())
-  {
-  }
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, const Executor& e, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          immediate_executor_binder<
-            decay_t<Handler>, Executor>(
-              e, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        const Executor& e, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          immediate_executor_binder<
-            decay_t<Handler>, Executor>(
-              e, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-        Signature>(
-          declval<init_wrapper<decay_t<Initiation>>>(),
-          token.get(), token.get_immediate_executor(),
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value, const T, T>,
-      Signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.get(), token.get_immediate_executor(),
-        static_cast<Args&&>(args)...);
-  }
-
-private:
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-
-  async_result<T, Signature> target_;
-};
-
-template <typename Executor, typename... Signatures>
-struct async_result<partial_immediate_executor_binder<Executor>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        immediate_executor_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Executor>(token.executor_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        immediate_executor_binder<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Executor>(token.executor_,
-            default_completion_token_t<associated_executor_t<Initiation>>{}),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename T, typename Executor, typename DefaultCandidate>
-struct associator<Associator,
-    immediate_executor_binder<T, Executor>,
-    DefaultCandidate>
-  : Associator<T, DefaultCandidate>
-{
-  static typename Associator<T, DefaultCandidate>::type get(
-      const immediate_executor_binder<T, Executor>& b) noexcept
-  {
-    return Associator<T, DefaultCandidate>::get(b.get());
-  }
-
-  static auto get(const immediate_executor_binder<T, Executor>& b,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
-  {
-    return Associator<T, DefaultCandidate>::get(b.get(), c);
-  }
-};
-
-template <typename T, typename Executor, typename Executor1>
-struct associated_immediate_executor<
-    immediate_executor_binder<T, Executor>,
-    Executor1>
-{
-  typedef Executor type;
-
-  static auto get(const immediate_executor_binder<T, Executor>& b,
-      const Executor1& = Executor1()) noexcept
-    -> decltype(b.get_immediate_executor())
-  {
-    return b.get_immediate_executor();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BIND_IMMEDIATE_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer.hpp
deleted file mode 100644
index 351416e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer.hpp
+++ /dev/null
@@ -1,2751 +0,0 @@
-//
-// buffer.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFER_HPP
-#define ASIO_BUFFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include <limits>
-#include <stdexcept>
-#include <string>
-#include <vector>
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_contiguous_iterator.hpp"
-
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)
-# if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
-#  if !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
-#   define ASIO_ENABLE_BUFFER_DEBUGGING
-#  endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
-# endif // defined(_HAS_ITERATOR_DEBUGGING)
-#endif // defined(ASIO_MSVC) && (ASIO_MSVC >= 1700)
-
-#if defined(__GNUC__)
-# if defined(_GLIBCXX_DEBUG)
-#  if !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
-#   define ASIO_ENABLE_BUFFER_DEBUGGING
-#  endif // !defined(ASIO_DISABLE_BUFFER_DEBUGGING)
-# endif // defined(_GLIBCXX_DEBUG)
-#endif // defined(__GNUC__)
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-# include "asio/detail/functional.hpp"
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class mutable_buffer;
-class const_buffer;
-
-/// Holds a buffer that can be modified.
-/**
- * The mutable_buffer class provides a safe representation of a buffer that can
- * be modified. It does not own the underlying data, and so is cheap to copy or
- * assign.
- *
- * @par Accessing Buffer Contents
- *
- * The contents of a buffer may be accessed using the @c data() and @c size()
- * member functions:
- *
- * @code asio::mutable_buffer b1 = ...;
- * std::size_t s1 = b1.size();
- * unsigned char* p1 = static_cast<unsigned char*>(b1.data());
- * @endcode
- *
- * The @c data() member function permits violations of type safety, so uses of
- * it in application code should be carefully considered.
- */
-class mutable_buffer
-{
-public:
-  /// Construct an empty buffer.
-  mutable_buffer() noexcept
-    : data_(0),
-      size_(0)
-  {
-  }
-
-  /// Construct a buffer to represent a given memory range.
-  mutable_buffer(void* data, std::size_t size) noexcept
-    : data_(data),
-      size_(size)
-  {
-  }
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  mutable_buffer(void* data, std::size_t size,
-      asio::detail::function<void()> debug_check)
-    : data_(data),
-      size_(size),
-      debug_check_(debug_check)
-  {
-  }
-
-  const asio::detail::function<void()>& get_debug_check() const
-  {
-    return debug_check_;
-  }
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-  /// Get a pointer to the beginning of the memory range.
-  void* data() const noexcept
-  {
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    if (size_ && debug_check_)
-      debug_check_();
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-    return data_;
-  }
-
-  /// Get the size of the memory range.
-  std::size_t size() const noexcept
-  {
-    return size_;
-  }
-
-  /// Move the start of the buffer by the specified number of bytes.
-  mutable_buffer& operator+=(std::size_t n) noexcept
-  {
-    std::size_t offset = n < size_ ? n : size_;
-    data_ = static_cast<char*>(data_) + offset;
-    size_ -= offset;
-    return *this;
-  }
-
-private:
-  void* data_;
-  std::size_t size_;
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  asio::detail::function<void()> debug_check_;
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-/// (Deprecated: Use mutable_buffer.) Adapts a single modifiable buffer so that
-/// it meets the requirements of the MutableBufferSequence concept.
-class mutable_buffers_1
-  : public mutable_buffer
-{
-public:
-  /// The type for each element in the list of buffers.
-  typedef mutable_buffer value_type;
-
-  /// A random-access iterator type that may be used to read elements.
-  typedef const mutable_buffer* const_iterator;
-
-  /// Construct to represent a given memory range.
-  mutable_buffers_1(void* data, std::size_t size) noexcept
-    : mutable_buffer(data, size)
-  {
-  }
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  mutable_buffers_1(void* data, std::size_t size,
-      asio::detail::function<void()> debug_check)
-    : mutable_buffer(data, size, debug_check)
-  {
-  }
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-  /// Construct to represent a single modifiable buffer.
-  explicit mutable_buffers_1(const mutable_buffer& b) noexcept
-    : mutable_buffer(b)
-  {
-  }
-
-  /// Get a random-access iterator to the first element.
-  const_iterator begin() const noexcept
-  {
-    return this;
-  }
-
-  /// Get a random-access iterator for one past the last element.
-  const_iterator end() const noexcept
-  {
-    return begin() + 1;
-  }
-};
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Holds a buffer that cannot be modified.
-/**
- * The const_buffer class provides a safe representation of a buffer that cannot
- * be modified. It does not own the underlying data, and so is cheap to copy or
- * assign.
- *
- * @par Accessing Buffer Contents
- *
- * The contents of a buffer may be accessed using the @c data() and @c size()
- * member functions:
- *
- * @code asio::const_buffer b1 = ...;
- * std::size_t s1 = b1.size();
- * const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
- * @endcode
- *
- * The @c data() member function permits violations of type safety, so uses of
- * it in application code should be carefully considered.
- */
-class const_buffer
-{
-public:
-  /// Construct an empty buffer.
-  const_buffer() noexcept
-    : data_(0),
-      size_(0)
-  {
-  }
-
-  /// Construct a buffer to represent a given memory range.
-  const_buffer(const void* data, std::size_t size) noexcept
-    : data_(data),
-      size_(size)
-  {
-  }
-
-  /// Construct a non-modifiable buffer from a modifiable one.
-  const_buffer(const mutable_buffer& b) noexcept
-    : data_(b.data()),
-      size_(b.size())
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , debug_check_(b.get_debug_check())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-  {
-  }
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  const_buffer(const void* data, std::size_t size,
-      asio::detail::function<void()> debug_check)
-    : data_(data),
-      size_(size),
-      debug_check_(debug_check)
-  {
-  }
-
-  const asio::detail::function<void()>& get_debug_check() const
-  {
-    return debug_check_;
-  }
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-  /// Get a pointer to the beginning of the memory range.
-  const void* data() const noexcept
-  {
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    if (size_ && debug_check_)
-      debug_check_();
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-    return data_;
-  }
-
-  /// Get the size of the memory range.
-  std::size_t size() const noexcept
-  {
-    return size_;
-  }
-
-  /// Move the start of the buffer by the specified number of bytes.
-  const_buffer& operator+=(std::size_t n) noexcept
-  {
-    std::size_t offset = n < size_ ? n : size_;
-    data_ = static_cast<const char*>(data_) + offset;
-    size_ -= offset;
-    return *this;
-  }
-
-private:
-  const void* data_;
-  std::size_t size_;
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  asio::detail::function<void()> debug_check_;
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-/// (Deprecated: Use const_buffer.) Adapts a single non-modifiable buffer so
-/// that it meets the requirements of the ConstBufferSequence concept.
-class const_buffers_1
-  : public const_buffer
-{
-public:
-  /// The type for each element in the list of buffers.
-  typedef const_buffer value_type;
-
-  /// A random-access iterator type that may be used to read elements.
-  typedef const const_buffer* const_iterator;
-
-  /// Construct to represent a given memory range.
-  const_buffers_1(const void* data, std::size_t size) noexcept
-    : const_buffer(data, size)
-  {
-  }
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-  const_buffers_1(const void* data, std::size_t size,
-      asio::detail::function<void()> debug_check)
-    : const_buffer(data, size, debug_check)
-  {
-  }
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-  /// Construct to represent a single non-modifiable buffer.
-  explicit const_buffers_1(const const_buffer& b) noexcept
-    : const_buffer(b)
-  {
-  }
-
-  /// Get a random-access iterator to the first element.
-  const_iterator begin() const noexcept
-  {
-    return this;
-  }
-
-  /// Get a random-access iterator for one past the last element.
-  const_iterator end() const noexcept
-  {
-    return begin() + 1;
-  }
-};
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// (Deprecated: Use the socket/descriptor wait() and async_wait() member
-/// functions.) An implementation of both the ConstBufferSequence and
-/// MutableBufferSequence concepts to represent a null buffer sequence.
-class null_buffers
-{
-public:
-  /// The type for each element in the list of buffers.
-  typedef mutable_buffer value_type;
-
-  /// A random-access iterator type that may be used to read elements.
-  typedef const mutable_buffer* const_iterator;
-
-  /// Get a random-access iterator to the first element.
-  const_iterator begin() const noexcept
-  {
-    return &buf_;
-  }
-
-  /// Get a random-access iterator for one past the last element.
-  const_iterator end() const noexcept
-  {
-    return &buf_;
-  }
-
-private:
-  mutable_buffer buf_;
-};
-
-/** @defgroup buffer_sequence_begin asio::buffer_sequence_begin
- *
- * @brief The asio::buffer_sequence_begin function returns an iterator
- * pointing to the first element in a buffer sequence.
- */
-/*@{*/
-
-/// Get an iterator to the first element in a buffer sequence.
-template <typename MutableBuffer>
-inline const mutable_buffer* buffer_sequence_begin(const MutableBuffer& b,
-    constraint_t<
-      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
-    > = 0) noexcept
-{
-  return static_cast<const mutable_buffer*>(detail::addressof(b));
-}
-
-/// Get an iterator to the first element in a buffer sequence.
-template <typename ConstBuffer>
-inline const const_buffer* buffer_sequence_begin(const ConstBuffer& b,
-    constraint_t<
-      is_convertible<const ConstBuffer*, const const_buffer*>::value
-    > = 0) noexcept
-{
-  return static_cast<const const_buffer*>(detail::addressof(b));
-}
-
-/// Get an iterator to the first element in a buffer sequence.
-template <typename C>
-inline auto buffer_sequence_begin(C& c,
-    constraint_t<
-      !is_convertible<const C*, const mutable_buffer*>::value
-        && !is_convertible<const C*, const const_buffer*>::value
-    > = 0) noexcept -> decltype(c.begin())
-{
-  return c.begin();
-}
-
-/// Get an iterator to the first element in a buffer sequence.
-template <typename C>
-inline auto buffer_sequence_begin(const C& c,
-    constraint_t<
-      !is_convertible<const C*, const mutable_buffer*>::value
-        && !is_convertible<const C*, const const_buffer*>::value
-    > = 0) noexcept -> decltype(c.begin())
-{
-  return c.begin();
-}
-
-/*@}*/
-
-/** @defgroup buffer_sequence_end asio::buffer_sequence_end
- *
- * @brief The asio::buffer_sequence_end function returns an iterator
- * pointing to one past the end element in a buffer sequence.
- */
-/*@{*/
-
-/// Get an iterator to one past the end element in a buffer sequence.
-template <typename MutableBuffer>
-inline const mutable_buffer* buffer_sequence_end(const MutableBuffer& b,
-    constraint_t<
-      is_convertible<const MutableBuffer*, const mutable_buffer*>::value
-    > = 0) noexcept
-{
-  return static_cast<const mutable_buffer*>(detail::addressof(b)) + 1;
-}
-
-/// Get an iterator to one past the end element in a buffer sequence.
-template <typename ConstBuffer>
-inline const const_buffer* buffer_sequence_end(const ConstBuffer& b,
-    constraint_t<
-      is_convertible<const ConstBuffer*, const const_buffer*>::value
-    > = 0) noexcept
-{
-  return static_cast<const const_buffer*>(detail::addressof(b)) + 1;
-}
-
-/// Get an iterator to one past the end element in a buffer sequence.
-template <typename C>
-inline auto buffer_sequence_end(C& c,
-    constraint_t<
-      !is_convertible<const C*, const mutable_buffer*>::value
-        && !is_convertible<const C*, const const_buffer*>::value
-    > = 0) noexcept -> decltype(c.end())
-{
-  return c.end();
-}
-
-/// Get an iterator to one past the end element in a buffer sequence.
-template <typename C>
-inline auto buffer_sequence_end(const C& c,
-    constraint_t<
-      !is_convertible<const C*, const mutable_buffer*>::value
-        && !is_convertible<const C*, const const_buffer*>::value
-    > = 0) noexcept -> decltype(c.end())
-{
-  return c.end();
-}
-
-/*@}*/
-
-namespace detail {
-
-// Tag types used to select appropriately optimised overloads.
-struct one_buffer {};
-struct multiple_buffers {};
-
-// Helper trait to detect single buffers.
-template <typename BufferSequence>
-struct buffer_sequence_cardinality :
-  conditional_t<
-    is_same<BufferSequence, mutable_buffer>::value
-#if !defined(ASIO_NO_DEPRECATED)
-      || is_same<BufferSequence, mutable_buffers_1>::value
-      || is_same<BufferSequence, const_buffers_1>::value
-#endif // !defined(ASIO_NO_DEPRECATED)
-      || is_same<BufferSequence, const_buffer>::value,
-    one_buffer, multiple_buffers> {};
-
-template <typename Iterator>
-inline std::size_t buffer_size(one_buffer,
-    Iterator begin, Iterator) noexcept
-{
-  return const_buffer(*begin).size();
-}
-
-template <typename Iterator>
-inline std::size_t buffer_size(multiple_buffers,
-    Iterator begin, Iterator end) noexcept
-{
-  std::size_t total_buffer_size = 0;
-
-  Iterator iter = begin;
-  for (; iter != end; ++iter)
-  {
-    const_buffer b(*iter);
-    total_buffer_size += b.size();
-  }
-
-  return total_buffer_size;
-}
-
-} // namespace detail
-
-/// Get the total number of bytes in a buffer sequence.
-/**
- * The @c buffer_size function determines the total size of all buffers in the
- * buffer sequence, as if computed as follows:
- *
- * @code size_t total_size = 0;
- * auto i = asio::buffer_sequence_begin(buffers);
- * auto end = asio::buffer_sequence_end(buffers);
- * for (; i != end; ++i)
- * {
- *   const_buffer b(*i);
- *   total_size += b.size();
- * }
- * return total_size; @endcode
- *
- * The @c BufferSequence template parameter may meet either of the @c
- * ConstBufferSequence or @c MutableBufferSequence type requirements.
- */
-template <typename BufferSequence>
-inline std::size_t buffer_size(const BufferSequence& b) noexcept
-{
-  return detail::buffer_size(
-      detail::buffer_sequence_cardinality<BufferSequence>(),
-      asio::buffer_sequence_begin(b),
-      asio::buffer_sequence_end(b));
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-/** @defgroup buffer_cast asio::buffer_cast
- *
- * @brief (Deprecated: Use the @c data() member function.) The
- * asio::buffer_cast function is used to obtain a pointer to the
- * underlying memory region associated with a buffer.
- *
- * @par Examples:
- *
- * To access the memory of a non-modifiable buffer, use:
- * @code asio::const_buffer b1 = ...;
- * const unsigned char* p1 = asio::buffer_cast<const unsigned char*>(b1);
- * @endcode
- *
- * To access the memory of a modifiable buffer, use:
- * @code asio::mutable_buffer b2 = ...;
- * unsigned char* p2 = asio::buffer_cast<unsigned char*>(b2);
- * @endcode
- *
- * The asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
- */
-/*@{*/
-
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const mutable_buffer& b) noexcept
-{
-  return static_cast<PointerToPodType>(b.data());
-}
-
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const const_buffer& b) noexcept
-{
-  return static_cast<PointerToPodType>(b.data());
-}
-
-/*@}*/
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(const mutable_buffer& b,
-    std::size_t n) noexcept
-{
-  std::size_t offset = n < b.size() ? n : b.size();
-  char* new_data = static_cast<char*>(b.data()) + offset;
-  std::size_t new_size = b.size() - offset;
-  return mutable_buffer(new_data, new_size
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(std::size_t n,
-    const mutable_buffer& b) noexcept
-{
-  return b + n;
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(const const_buffer& b,
-    std::size_t n) 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
-      );
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(std::size_t n,
-    const const_buffer& b) noexcept
-{
-  return b + n;
-}
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-namespace detail {
-
-template <typename Iterator>
-class buffer_debug_check
-{
-public:
-  buffer_debug_check(Iterator iter)
-    : iter_(iter)
-  {
-  }
-
-  ~buffer_debug_check()
-  {
-#if defined(ASIO_MSVC) && (ASIO_MSVC == 1400)
-    // MSVC 8's string iterator checking may crash in a std::string::iterator
-    // object's destructor when the iterator points to an already-destroyed
-    // std::string object, unless the iterator is cleared first.
-    iter_ = Iterator();
-#endif // defined(ASIO_MSVC) && (ASIO_MSVC == 1400)
-  }
-
-  void operator()()
-  {
-    (void)*iter_;
-  }
-
-private:
-  Iterator iter_;
-};
-
-} // namespace detail
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-
-/** @defgroup buffer asio::buffer
- *
- * @brief The asio::buffer function is used to create a buffer object to
- * represent raw memory, an array of POD elements, a vector of POD elements,
- * or a std::string.
- *
- * A buffer object represents a contiguous region of memory as a 2-tuple
- * consisting of a pointer and size in bytes. A tuple of the form <tt>{void*,
- * size_t}</tt> specifies a mutable (modifiable) region of memory. Similarly, a
- * tuple of the form <tt>{const void*, size_t}</tt> specifies a const
- * (non-modifiable) region of memory. These two forms correspond to the classes
- * mutable_buffer and const_buffer, respectively. To mirror C++'s conversion
- * rules, a mutable_buffer is implicitly convertible to a const_buffer, and the
- * opposite conversion is not permitted.
- *
- * The simplest use case involves reading or writing a single buffer of a
- * specified size:
- *
- * @code sock.send(asio::buffer(data, size)); @endcode
- *
- * In the above example, the return value of asio::buffer meets the
- * requirements of the ConstBufferSequence concept so that it may be directly
- * passed to the socket's write function. A buffer created for modifiable
- * memory also meets the requirements of the MutableBufferSequence concept.
- *
- * An individual buffer may be created from a builtin array, std::vector,
- * std::array or boost::array of POD elements. This helps prevent buffer
- * overruns by automatically determining the size of the buffer:
- *
- * @code char d1[128];
- * size_t bytes_transferred = sock.receive(asio::buffer(d1));
- *
- * std::vector<char> d2(128);
- * bytes_transferred = sock.receive(asio::buffer(d2));
- *
- * std::array<char, 128> d3;
- * bytes_transferred = sock.receive(asio::buffer(d3));
- *
- * boost::array<char, 128> d4;
- * bytes_transferred = sock.receive(asio::buffer(d4)); @endcode
- *
- * In all three cases above, the buffers created are exactly 128 bytes long.
- * Note that a vector is @e never automatically resized when creating or using
- * a buffer. The buffer size is determined using the vector's <tt>size()</tt>
- * member function, and not its capacity.
- *
- * @par Accessing Buffer Contents
- *
- * The contents of a buffer may be accessed using the @c data() and @c size()
- * member functions:
- *
- * @code asio::mutable_buffer b1 = ...;
- * std::size_t s1 = b1.size();
- * unsigned char* p1 = static_cast<unsigned char*>(b1.data());
- *
- * asio::const_buffer b2 = ...;
- * std::size_t s2 = b2.size();
- * const void* p2 = b2.data(); @endcode
- *
- * The @c data() member function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
- *
- * For convenience, a @ref buffer_size function is provided that works with
- * both buffers and buffer sequences (that is, types meeting the
- * ConstBufferSequence or MutableBufferSequence type requirements). In this
- * case, the function returns the total size of all buffers in the sequence.
- *
- * @par Buffer Copying
- *
- * The @ref buffer_copy function may be used to copy raw bytes between
- * individual buffers and buffer sequences.
-*
- * In particular, when used with the @ref buffer_size function, the @ref
- * buffer_copy function can be used to linearise a sequence of buffers. For
- * example:
- *
- * @code vector<const_buffer> buffers = ...;
- *
- * vector<unsigned char> data(asio::buffer_size(buffers));
- * asio::buffer_copy(asio::buffer(data), buffers); @endcode
- *
- * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
- * consequently it cannot be used to copy between overlapping memory regions.
- *
- * @par Buffer Invalidation
- *
- * A buffer object does not have any ownership of the memory it refers to. It
- * is the responsibility of the application to ensure the memory region remains
- * valid until it is no longer required for an I/O operation. When the memory
- * is no longer available, the buffer is said to have been invalidated.
- *
- * For the asio::buffer overloads that accept an argument of type
- * std::vector, the buffer objects returned are invalidated by any vector
- * operation that also invalidates all references, pointers and iterators
- * referring to the elements in the sequence (C++ Std, 23.2.4)
- *
- * For the asio::buffer overloads that accept an argument of type
- * std::basic_string, the buffer objects returned are invalidated according to
- * the rules defined for invalidation of references, pointers and iterators
- * referring to elements of the sequence (C++ Std, 21.3).
- *
- * @par Buffer Arithmetic
- *
- * Buffer objects may be manipulated using simple arithmetic in a safe way
- * which helps prevent buffer overruns. Consider an array initialised as
- * follows:
- *
- * @code boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; @endcode
- *
- * A buffer object @c b1 created using:
- *
- * @code b1 = asio::buffer(a); @endcode
- *
- * represents the entire array, <tt>{ 'a', 'b', 'c', 'd', 'e' }</tt>. An
- * optional second argument to the asio::buffer function may be used to
- * limit the size, in bytes, of the buffer:
- *
- * @code b2 = asio::buffer(a, 3); @endcode
- *
- * such that @c b2 represents the data <tt>{ 'a', 'b', 'c' }</tt>. Even if the
- * size argument exceeds the actual size of the array, the size of the buffer
- * object created will be limited to the array size.
- *
- * An offset may be applied to an existing buffer to create a new one:
- *
- * @code b3 = b1 + 2; @endcode
- *
- * where @c b3 will set to represent <tt>{ 'c', 'd', 'e' }</tt>. If the offset
- * exceeds the size of the existing buffer, the newly created buffer will be
- * empty.
- *
- * Both an offset and size may be specified to create a buffer that corresponds
- * to a specific range of bytes within an existing buffer:
- *
- * @code b4 = asio::buffer(b1 + 1, 3); @endcode
- *
- * so that @c b4 will refer to the bytes <tt>{ 'b', 'c', 'd' }</tt>.
- *
- * @par Buffers and Scatter-Gather I/O
- *
- * To read or write using multiple buffers (i.e. scatter-gather I/O), multiple
- * buffer objects may be assigned into a container that supports the
- * MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts:
- *
- * @code
- * char d1[128];
- * std::vector<char> d2(128);
- * boost::array<char, 128> d3;
- *
- * boost::array<mutable_buffer, 3> bufs1 = {
- *   asio::buffer(d1),
- *   asio::buffer(d2),
- *   asio::buffer(d3) };
- * bytes_transferred = sock.receive(bufs1);
- *
- * std::vector<const_buffer> bufs2;
- * bufs2.push_back(asio::buffer(d1));
- * bufs2.push_back(asio::buffer(d2));
- * bufs2.push_back(asio::buffer(d3));
- * bytes_transferred = sock.send(bufs2); @endcode
- *
- * @par Buffer Literals
- *
- * The `_buf` literal suffix, defined in namespace
- * <tt>asio::buffer_literals</tt>, may be used to create @c const_buffer
- * objects from string, binary integer, and hexadecimal integer literals.
- * For example:
- *
- * @code
- * using namespace asio::buffer_literals;
- *
- * asio::const_buffer b1 = "hello"_buf;
- * asio::const_buffer b2 = 0xdeadbeef_buf;
- * asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
- * asio::const_buffer b4 = 0b1010101011001100_buf; @endcode
- *
- * Note that the memory associated with a buffer literal is valid for the
- * lifetime of the program. This means that the buffer can be safely used with
- * asynchronous operations.
- */
-/*@{*/
-
-#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-# define ASIO_MUTABLE_BUFFER mutable_buffer
-# define ASIO_CONST_BUFFER const_buffer
-#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-# define ASIO_MUTABLE_BUFFER mutable_buffers_1
-# define ASIO_CONST_BUFFER const_buffers_1
-#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
-
-/// Create a new modifiable buffer from an existing buffer.
-/**
- * @returns <tt>mutable_buffer(b)</tt>.
- */
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    const mutable_buffer& b) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(b);
-}
-
-/// Create a new modifiable buffer from an existing buffer.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     b.data(),
- *     min(b.size(), max_size_in_bytes)); @endcode
- */
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    const mutable_buffer& b,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(
-      mutable_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
-        ));
-}
-
-/// Create a new non-modifiable buffer from an existing buffer.
-/**
- * @returns <tt>const_buffer(b)</tt>.
- */
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const const_buffer& b) noexcept
-{
-  return ASIO_CONST_BUFFER(b);
-}
-
-/// Create a new non-modifiable buffer from an existing buffer.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     b.data(),
- *     min(b.size(), max_size_in_bytes)); @endcode
- */
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const const_buffer& b,
-    std::size_t max_size_in_bytes) 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
-      );
-}
-
-/// Create a new modifiable buffer that represents the given memory range.
-/**
- * @returns <tt>mutable_buffer(data, size_in_bytes)</tt>.
- */
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    void* data, std::size_t size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data, size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given memory range.
-/**
- * @returns <tt>const_buffer(data, size_in_bytes)</tt>.
- */
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const void* data, std::size_t size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data, size_in_bytes);
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     static_cast<void*>(data),
- *     N * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    PodType (&data)[N]) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data, N * sizeof(PodType));
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     static_cast<void*>(data),
- *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    PodType (&data)[N],
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data,
-      N * sizeof(PodType) < max_size_in_bytes
-      ? N * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     static_cast<const void*>(data),
- *     N * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const PodType (&data)[N]) noexcept
-{
-  return ASIO_CONST_BUFFER(data, N * sizeof(PodType));
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     static_cast<const void*>(data),
- *     min(N * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const PodType (&data)[N],
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data,
-      N * sizeof(PodType) < max_size_in_bytes
-      ? N * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    boost::array<PodType, N>& data) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(
-      data.c_array(), data.size() * sizeof(PodType));
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.c_array(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    boost::array<const PodType, N>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    boost::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const boost::array<PodType, N>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const boost::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::array<PodType, N>& data) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.data(), data.size() * sizeof(PodType));
-}
-
-/// Create a new modifiable buffer that represents the given POD array.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.data(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    std::array<const PodType, N>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    std::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::array<PodType, N>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(PodType));
-}
-
-/// Create a new non-modifiable buffer that represents the given POD array.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(),
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes);
-}
-
-/// Create a new modifiable buffer that represents the given POD vector.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     data.size() * sizeof(PodType)); @endcode
- *
- * @note The buffer is invalidated by any vector operation that would also
- * invalidate iterators.
- */
-template <typename PodType, typename Allocator>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::vector<PodType, Allocator>& data) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(
-      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::vector<PodType, Allocator>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that represents the given POD vector.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- *
- * @note The buffer is invalidated by any vector operation that would also
- * invalidate iterators.
- */
-template <typename PodType, typename Allocator>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::vector<PodType, Allocator>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::vector<PodType, Allocator>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that represents the given POD vector.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     data.size() * sizeof(PodType)); @endcode
- *
- * @note The buffer is invalidated by any vector operation that would also
- * invalidate iterators.
- */
-template <typename PodType, typename Allocator>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::vector<PodType, Allocator>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(
-      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::vector<PodType, Allocator>::const_iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that represents the given POD vector.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- *
- * @note The buffer is invalidated by any vector operation that would also
- * invalidate iterators.
- */
-template <typename PodType, typename Allocator>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::vector<PodType, Allocator>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(PodType) < max_size_in_bytes
-      ? data.size() * sizeof(PodType) : max_size_in_bytes
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::vector<PodType, Allocator>::const_iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that represents the given string.
-/**
- * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
- * data.size() * sizeof(Elem))</tt>.
- *
- * @note The buffer is invalidated by any non-const operation called on the
- * given string object.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::basic_string<Elem, Traits, Allocator>& data) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(Elem)
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::basic_string<Elem, Traits, Allocator>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that represents the given string.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
- *
- * @note The buffer is invalidated by any non-const operation called on the
- * given string object.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(Elem) < max_size_in_bytes
-      ? data.size() * sizeof(Elem) : max_size_in_bytes
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::basic_string<Elem, Traits, Allocator>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that represents the given string.
-/**
- * @returns <tt>const_buffer(data.data(), data.size() * sizeof(Elem))</tt>.
- *
- * @note The buffer is invalidated by any non-const operation called on the
- * given string object.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(), data.size() * sizeof(Elem)
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that represents the given string.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.data(),
- *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
- *
- * @note The buffer is invalidated by any non-const operation called on the
- * given string object.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.data(),
-      data.size() * sizeof(Elem) < max_size_in_bytes
-      ? data.size() * sizeof(Elem) : max_size_in_bytes
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create a new non-modifiable buffer that represents the given string_view.
-/**
- * @returns <tt>mutable_buffer(data.size() ? &data[0] : 0,
- * data.size() * sizeof(Elem))</tt>.
- */
-template <typename Elem, typename Traits>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    basic_string_view<Elem, Traits> data) noexcept
-{
-  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(Elem)
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename basic_string_view<Elem, Traits>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that represents the given string.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
- */
-template <typename Elem, typename Traits>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    basic_string_view<Elem, Traits> data,
-    std::size_t max_size_in_bytes) noexcept
-{
-  return ASIO_CONST_BUFFER(data.size() ? &data[0] : 0,
-      data.size() * sizeof(Elem) < max_size_in_bytes
-      ? data.size() * sizeof(Elem) : max_size_in_bytes
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-      , detail::buffer_debug_check<
-          typename basic_string_view<Elem, Traits>::iterator
-        >(data.begin())
-#endif // ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-/// Create a new modifiable buffer from a contiguous container.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     data.size() * sizeof(typename T::value_type)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    T& data,
-    constraint_t<
-      is_contiguous_iterator<typename T::iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_const<
-        remove_reference_t<
-          typename std::iterator_traits<typename T::iterator>::reference
-        >
-      >::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type));
-}
-
-/// Create a new modifiable buffer from a contiguous container.
-/**
- * @returns A mutable_buffer value equivalent to:
- * @code mutable_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(
- *       data.size() * sizeof(typename T::value_type),
- *       max_size_in_bytes)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_MUTABLE_BUFFER buffer(
-    T& data, std::size_t max_size_in_bytes,
-    constraint_t<
-      is_contiguous_iterator<typename T::iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_const<
-        remove_reference_t<
-          typename std::iterator_traits<typename T::iterator>::reference
-        >
-      >::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_MUTABLE_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
-      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer from a contiguous container.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     data.size() * sizeof(typename T::value_type)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    T& data,
-    constraint_t<
-      is_contiguous_iterator<typename T::iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      is_const<
-        remove_reference_t<
-          typename std::iterator_traits<typename T::iterator>::reference
-        >
-      >::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_CONST_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type));
-}
-
-/// Create a new non-modifiable buffer from a contiguous container.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(
- *       data.size() * sizeof(typename T::value_type),
- *       max_size_in_bytes)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    T& data, std::size_t max_size_in_bytes,
-    constraint_t<
-      is_contiguous_iterator<typename T::iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      is_const<
-        remove_reference_t<
-          typename std::iterator_traits<typename T::iterator>::reference
-        >
-      >::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_CONST_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
-      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
-}
-
-/// Create a new non-modifiable buffer from a contiguous container.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     data.size() * sizeof(typename T::value_type)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const T& data,
-    constraint_t<
-      is_contiguous_iterator<typename T::const_iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_CONST_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type));
-}
-
-/// Create a new non-modifiable buffer from a contiguous container.
-/**
- * @returns A const_buffer value equivalent to:
- * @code const_buffer(
- *     data.size() ? &data[0] : 0,
- *     min(
- *       data.size() * sizeof(typename T::value_type),
- *       max_size_in_bytes)); @endcode
- */
-template <typename T>
-ASIO_NODISCARD inline ASIO_CONST_BUFFER buffer(
-    const T& data, std::size_t max_size_in_bytes,
-    constraint_t<
-      is_contiguous_iterator<typename T::const_iterator>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, const_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint(),
-    constraint_t<
-      !is_convertible<T, mutable_buffer>::value,
-      defaulted_constraint
-    > = defaulted_constraint()) noexcept
-{
-  return ASIO_CONST_BUFFER(
-      data.size() ? detail::to_address(data.begin()) : 0,
-      data.size() * sizeof(typename T::value_type) < max_size_in_bytes
-      ? data.size() * sizeof(typename T::value_type) : max_size_in_bytes);
-}
-
-/*@}*/
-
-/// Adapt a basic_string to the DynamicBuffer requirements.
-/**
- * Requires that <tt>sizeof(Elem) == 1</tt>.
- */
-template <typename Elem, typename Traits, typename Allocator>
-class dynamic_string_buffer
-{
-public:
-  /// The type used to represent a sequence of constant buffers that refers to
-  /// the underlying memory.
-  typedef ASIO_CONST_BUFFER const_buffers_type;
-
-  /// The type used to represent a sequence of mutable buffers that refers to
-  /// the underlying memory.
-  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
-
-  /// Construct a dynamic buffer from a string.
-  /**
-   * @param s The string to be used as backing storage for the dynamic buffer.
-   * The object stores a reference to the string and the user is responsible
-   * for ensuring that the string object remains valid while the
-   * dynamic_string_buffer object, and copies of the object, are in use.
-   *
-   * @b DynamicBuffer_v1: Any existing data in the string is treated as the
-   * dynamic buffer's input sequence.
-   *
-   * @param maximum_size Specifies a maximum size for the buffer, in bytes.
-   */
-  explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
-      std::size_t maximum_size =
-        (std::numeric_limits<std::size_t>::max)()) noexcept
-    : string_(s),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_((std::numeric_limits<std::size_t>::max)()),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(maximum_size)
-  {
-  }
-
-  /// @b DynamicBuffer_v2: Copy construct a dynamic buffer.
-  dynamic_string_buffer(const dynamic_string_buffer& other) noexcept
-    : string_(other.string_),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_(other.size_),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(other.max_size_)
-  {
-  }
-
-  /// Move construct a dynamic buffer.
-  dynamic_string_buffer(dynamic_string_buffer&& other) noexcept
-    : string_(other.string_),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_(other.size_),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(other.max_size_)
-  {
-  }
-
-  /// @b DynamicBuffer_v1: Get the size of the input sequence.
-  /// @b DynamicBuffer_v2: Get the current size of the underlying memory.
-  /**
-   * @returns @b DynamicBuffer_v1 The current size of the input sequence.
-   * @b DynamicBuffer_v2: The current size of the underlying string if less than
-   * max_size(). Otherwise returns max_size().
-   */
-  std::size_t size() const noexcept
-  {
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    if (size_ != (std::numeric_limits<std::size_t>::max)())
-      return size_;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    return (std::min)(string_.size(), max_size());
-  }
-
-  /// Get the maximum size of the dynamic buffer.
-  /**
-   * @returns The allowed maximum size of the underlying memory.
-   */
-  std::size_t max_size() const noexcept
-  {
-    return max_size_;
-  }
-
-  /// Get the maximum size that the buffer may grow to without triggering
-  /// reallocation.
-  /**
-   * @returns The current capacity of the underlying string if less than
-   * max_size(). Otherwise returns max_size().
-   */
-  std::size_t capacity() const noexcept
-  {
-    return (std::min)(string_.capacity(), max_size());
-  }
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  /// @b DynamicBuffer_v1: Get a list of buffers that represents the input
-  /// sequence.
-  /**
-   * @returns An object of type @c const_buffers_type that satisfies
-   * ConstBufferSequence requirements, representing the basic_string memory in
-   * the input sequence.
-   *
-   * @note The returned object is invalidated by any @c dynamic_string_buffer
-   * or @c basic_string member function that resizes or erases the string.
-   */
-  const_buffers_type data() const noexcept
-  {
-    return const_buffers_type(asio::buffer(string_, size_));
-  }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
-  /// underlying memory.
-  /**
-   * @param pos Position of the first byte to represent in the buffer sequence
-   *
-   * @param n The number of bytes to return in the buffer sequence. If the
-   * underlying memory is shorter, the buffer sequence represents as many bytes
-   * as are available.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing the basic_string memory.
-   *
-   * @note The returned object is invalidated by any @c dynamic_string_buffer
-   * or @c basic_string member function that resizes or erases the string.
-   */
-  mutable_buffers_type data(std::size_t pos, std::size_t n) noexcept
-  {
-    return mutable_buffers_type(asio::buffer(
-          asio::buffer(string_, max_size_) + pos, n));
-  }
-
-  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
-  /// underlying memory.
-  /**
-   * @param pos Position of the first byte to represent in the buffer sequence
-   *
-   * @param n The number of bytes to return in the buffer sequence. If the
-   * underlying memory is shorter, the buffer sequence represents as many bytes
-   * as are available.
-   *
-   * @note The returned object is invalidated by any @c dynamic_string_buffer
-   * or @c basic_string member function that resizes or erases the string.
-   */
-  const_buffers_type data(std::size_t pos,
-      std::size_t n) const noexcept
-  {
-    return const_buffers_type(asio::buffer(
-          asio::buffer(string_, max_size_) + pos, n));
-  }
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  /// @b DynamicBuffer_v1: Get a list of buffers that represents the output
-  /// sequence, with the given size.
-  /**
-   * Ensures that the output sequence can accommodate @c n bytes, resizing the
-   * basic_string object as necessary.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing basic_string memory
-   * at the start of the output sequence of size @c n.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   *
-   * @note The returned object is invalidated by any @c dynamic_string_buffer
-   * or @c basic_string member function that modifies the input sequence or
-   * output sequence.
-   */
-  mutable_buffers_type prepare(std::size_t n)
-  {
-    if (size() > max_size() || max_size() - size() < n)
-    {
-      std::length_error ex("dynamic_string_buffer too long");
-      asio::detail::throw_exception(ex);
-    }
-
-    if (size_ == (std::numeric_limits<std::size_t>::max)())
-      size_ = string_.size(); // Enable v1 behaviour.
-
-    string_.resize(size_ + n);
-
-    return asio::buffer(asio::buffer(string_) + size_, n);
-  }
-
-  /// @b DynamicBuffer_v1: Move bytes from the output sequence to the input
-  /// sequence.
-  /**
-   * @param n The number of bytes to append from the start of the output
-   * sequence to the end of the input sequence. The remainder of the output
-   * sequence is discarded.
-   *
-   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
-   * no intervening operations that modify the input or output sequence.
-   *
-   * @note If @c n is greater than the size of the output sequence, the entire
-   * output sequence is moved to the input sequence and no error is issued.
-   */
-  void commit(std::size_t n)
-  {
-    size_ += (std::min)(n, string_.size() - size_);
-    string_.resize(size_);
-  }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-  /// @b DynamicBuffer_v2: Grow the underlying memory by the specified number of
-  /// bytes.
-  /**
-   * Resizes the string to accommodate an additional @c n bytes at the end.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   */
-  void grow(std::size_t n)
-  {
-    if (size() > max_size() || max_size() - size() < n)
-    {
-      std::length_error ex("dynamic_string_buffer too long");
-      asio::detail::throw_exception(ex);
-    }
-
-    string_.resize(size() + n);
-  }
-
-  /// @b DynamicBuffer_v2: Shrink the underlying memory by the specified number
-  /// of bytes.
-  /**
-   * Erases @c n bytes from the end of the string by resizing the basic_string
-   * object. If @c n is greater than the current size of the string, the string
-   * is emptied.
-   */
-  void shrink(std::size_t n)
-  {
-    string_.resize(n > size() ? 0 : size() - n);
-  }
-
-  /// @b DynamicBuffer_v1: Remove characters from the input sequence.
-  /// @b DynamicBuffer_v2: Consume the specified number of bytes from the
-  /// beginning of the underlying memory.
-  /**
-   * @b DynamicBuffer_v1: Removes @c n characters from the beginning of the
-   * input sequence. @note If @c n is greater than the size of the input
-   * sequence, the entire input sequence is consumed and no error is issued.
-   *
-   * @b DynamicBuffer_v2: Erases @c n bytes from the beginning of the string.
-   * If @c n is greater than the current size of the string, the string is
-   * emptied.
-   */
-  void consume(std::size_t n)
-  {
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    if (size_ != (std::numeric_limits<std::size_t>::max)())
-    {
-      std::size_t consume_length = (std::min)(n, size_);
-      string_.erase(0, consume_length);
-      size_ -= consume_length;
-      return;
-    }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    string_.erase(0, n);
-  }
-
-private:
-  std::basic_string<Elem, Traits, Allocator>& string_;
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  std::size_t size_;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  const std::size_t max_size_;
-};
-
-/// Adapt a vector to the DynamicBuffer requirements.
-/**
- * Requires that <tt>sizeof(Elem) == 1</tt>.
- */
-template <typename Elem, typename Allocator>
-class dynamic_vector_buffer
-{
-public:
-  /// The type used to represent a sequence of constant buffers that refers to
-  /// the underlying memory.
-  typedef ASIO_CONST_BUFFER const_buffers_type;
-
-  /// The type used to represent a sequence of mutable buffers that refers to
-  /// the underlying memory.
-  typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
-
-  /// Construct a dynamic buffer from a vector.
-  /**
-   * @param v The vector to be used as backing storage for the dynamic buffer.
-   * The object stores a reference to the vector and the user is responsible
-   * for ensuring that the vector object remains valid while the
-   * dynamic_vector_buffer object, and copies of the object, are in use.
-   *
-   * @param maximum_size Specifies a maximum size for the buffer, in bytes.
-   */
-  explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
-      std::size_t maximum_size =
-        (std::numeric_limits<std::size_t>::max)()) noexcept
-    : vector_(v),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_((std::numeric_limits<std::size_t>::max)()),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(maximum_size)
-  {
-  }
-
-  /// @b DynamicBuffer_v2: Copy construct a dynamic buffer.
-  dynamic_vector_buffer(const dynamic_vector_buffer& other) noexcept
-    : vector_(other.vector_),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_(other.size_),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(other.max_size_)
-  {
-  }
-
-  /// Move construct a dynamic buffer.
-  dynamic_vector_buffer(dynamic_vector_buffer&& other) noexcept
-    : vector_(other.vector_),
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      size_(other.size_),
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-      max_size_(other.max_size_)
-  {
-  }
-
-  /// @b DynamicBuffer_v1: Get the size of the input sequence.
-  /// @b DynamicBuffer_v2: Get the current size of the underlying memory.
-  /**
-   * @returns @b DynamicBuffer_v1 The current size of the input sequence.
-   * @b DynamicBuffer_v2: The current size of the underlying vector if less than
-   * max_size(). Otherwise returns max_size().
-   */
-  std::size_t size() const noexcept
-  {
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    if (size_ != (std::numeric_limits<std::size_t>::max)())
-      return size_;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    return (std::min)(vector_.size(), max_size());
-  }
-
-  /// Get the maximum size of the dynamic buffer.
-  /**
-   * @returns @b DynamicBuffer_v1: The allowed maximum of the sum of the sizes
-   * of the input sequence and output sequence. @b DynamicBuffer_v2: The allowed
-   * maximum size of the underlying memory.
-   */
-  std::size_t max_size() const noexcept
-  {
-    return max_size_;
-  }
-
-  /// Get the maximum size that the buffer may grow to without triggering
-  /// reallocation.
-  /**
-   * @returns @b DynamicBuffer_v1: The current total capacity of the buffer,
-   * i.e. for both the input sequence and output sequence. @b DynamicBuffer_v2:
-   * The current capacity of the underlying vector if less than max_size().
-   * Otherwise returns max_size().
-   */
-  std::size_t capacity() const noexcept
-  {
-    return (std::min)(vector_.capacity(), max_size());
-  }
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  /// @b DynamicBuffer_v1: Get a list of buffers that represents the input
-  /// sequence.
-  /**
-   * @returns An object of type @c const_buffers_type that satisfies
-   * ConstBufferSequence requirements, representing the vector memory in the
-   * input sequence.
-   *
-   * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c vector member function that modifies the input sequence or output
-   * sequence.
-   */
-  const_buffers_type data() const noexcept
-  {
-    return const_buffers_type(asio::buffer(vector_, size_));
-  }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
-  /// underlying memory.
-  /**
-   * @param pos Position of the first byte to represent in the buffer sequence
-   *
-   * @param n The number of bytes to return in the buffer sequence. If the
-   * underlying memory is shorter, the buffer sequence represents as many bytes
-   * as are available.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing the vector memory.
-   *
-   * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c vector member function that resizes or erases the vector.
-   */
-  mutable_buffers_type data(std::size_t pos, std::size_t n) noexcept
-  {
-    return mutable_buffers_type(asio::buffer(
-          asio::buffer(vector_, max_size_) + pos, n));
-  }
-
-  /// @b DynamicBuffer_v2: Get a sequence of buffers that represents the
-  /// underlying memory.
-  /**
-   * @param pos Position of the first byte to represent in the buffer sequence
-   *
-   * @param n The number of bytes to return in the buffer sequence. If the
-   * underlying memory is shorter, the buffer sequence represents as many bytes
-   * as are available.
-   *
-   * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c vector member function that resizes or erases the vector.
-   */
-  const_buffers_type data(std::size_t pos,
-      std::size_t n) const noexcept
-  {
-    return const_buffers_type(asio::buffer(
-          asio::buffer(vector_, max_size_) + pos, n));
-  }
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  /// @b DynamicBuffer_v1: Get a list of buffers that represents the output
-  /// sequence, with the given size.
-  /**
-   * Ensures that the output sequence can accommodate @c n bytes, resizing the
-   * vector object as necessary.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing vector memory at the
-   * start of the output sequence of size @c n.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   *
-   * @note The returned object is invalidated by any @c dynamic_vector_buffer
-   * or @c vector member function that modifies the input sequence or output
-   * sequence.
-   */
-  mutable_buffers_type prepare(std::size_t n)
-  {
-    if (size () > max_size() || max_size() - size() < n)
-    {
-      std::length_error ex("dynamic_vector_buffer too long");
-      asio::detail::throw_exception(ex);
-    }
-
-    if (size_ == (std::numeric_limits<std::size_t>::max)())
-      size_ = vector_.size(); // Enable v1 behaviour.
-
-    vector_.resize(size_ + n);
-
-    return asio::buffer(asio::buffer(vector_) + size_, n);
-  }
-
-  /// @b DynamicBuffer_v1: Move bytes from the output sequence to the input
-  /// sequence.
-  /**
-   * @param n The number of bytes to append from the start of the output
-   * sequence to the end of the input sequence. The remainder of the output
-   * sequence is discarded.
-   *
-   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
-   * no intervening operations that modify the input or output sequence.
-   *
-   * @note If @c n is greater than the size of the output sequence, the entire
-   * output sequence is moved to the input sequence and no error is issued.
-   */
-  void commit(std::size_t n)
-  {
-    size_ += (std::min)(n, vector_.size() - size_);
-    vector_.resize(size_);
-  }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-  /// @b DynamicBuffer_v2: Grow the underlying memory by the specified number of
-  /// bytes.
-  /**
-   * Resizes the vector to accommodate an additional @c n bytes at the end.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   */
-  void grow(std::size_t n)
-  {
-    if (size() > max_size() || max_size() - size() < n)
-    {
-      std::length_error ex("dynamic_vector_buffer too long");
-      asio::detail::throw_exception(ex);
-    }
-
-    vector_.resize(size() + n);
-  }
-
-  /// @b DynamicBuffer_v2: Shrink the underlying memory by the specified number
-  /// of bytes.
-  /**
-   * Erases @c n bytes from the end of the vector by resizing the vector
-   * object. If @c n is greater than the current size of the vector, the vector
-   * is emptied.
-   */
-  void shrink(std::size_t n)
-  {
-    vector_.resize(n > size() ? 0 : size() - n);
-  }
-
-  /// @b DynamicBuffer_v1: Remove characters from the input sequence.
-  /// @b DynamicBuffer_v2: Consume the specified number of bytes from the
-  /// beginning of the underlying memory.
-  /**
-   * @b DynamicBuffer_v1: Removes @c n characters from the beginning of the
-   * input sequence. @note If @c n is greater than the size of the input
-   * sequence, the entire input sequence is consumed and no error is issued.
-   *
-   * @b DynamicBuffer_v2: Erases @c n bytes from the beginning of the vector.
-   * If @c n is greater than the current size of the vector, the vector is
-   * emptied.
-   */
-  void consume(std::size_t n)
-  {
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    if (size_ != (std::numeric_limits<std::size_t>::max)())
-    {
-      std::size_t consume_length = (std::min)(n, size_);
-      vector_.erase(vector_.begin(), vector_.begin() + consume_length);
-      size_ -= consume_length;
-      return;
-    }
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    vector_.erase(vector_.begin(), vector_.begin() + (std::min)(size(), n));
-  }
-
-private:
-  std::vector<Elem, Allocator>& vector_;
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  std::size_t size_;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  const std::size_t max_size_;
-};
-
-/** @defgroup dynamic_buffer asio::dynamic_buffer
- *
- * @brief The asio::dynamic_buffer function is used to create a
- * dynamically resized buffer from a @c std::basic_string or @c std::vector.
- */
-/*@{*/
-
-/// Create a new dynamic buffer that represents the given string.
-/**
- * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data)</tt>.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline
-dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
-    std::basic_string<Elem, Traits, Allocator>& data) noexcept
-{
-  return dynamic_string_buffer<Elem, Traits, Allocator>(data);
-}
-
-/// Create a new dynamic buffer that represents the given string.
-/**
- * @returns <tt>dynamic_string_buffer<Elem, Traits, Allocator>(data,
- * max_size)</tt>.
- */
-template <typename Elem, typename Traits, typename Allocator>
-ASIO_NODISCARD inline
-dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
-    std::basic_string<Elem, Traits, Allocator>& data,
-    std::size_t max_size) noexcept
-{
-  return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
-}
-
-/// Create a new dynamic buffer that represents the given vector.
-/**
- * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data)</tt>.
- */
-template <typename Elem, typename Allocator>
-ASIO_NODISCARD inline
-dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
-    std::vector<Elem, Allocator>& data) noexcept
-{
-  return dynamic_vector_buffer<Elem, Allocator>(data);
-}
-
-/// Create a new dynamic buffer that represents the given vector.
-/**
- * @returns <tt>dynamic_vector_buffer<Elem, Allocator>(data, max_size)</tt>.
- */
-template <typename Elem, typename Allocator>
-ASIO_NODISCARD inline
-dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
-    std::vector<Elem, Allocator>& data,
-    std::size_t max_size) noexcept
-{
-  return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
-}
-
-/*@}*/
-
-/** @defgroup buffer_copy asio::buffer_copy
- *
- * @brief The asio::buffer_copy function is used to copy bytes from a
- * source buffer (or buffer sequence) to a target buffer (or buffer sequence).
- *
- * The @c buffer_copy function is available in two forms:
- *
- * @li A 2-argument form: @c buffer_copy(target, source)
- *
- * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy)
- *
- * Both forms return the number of bytes actually copied. The number of bytes
- * copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c If specified, @c max_bytes_to_copy.
- *
- * This prevents buffer overflow, regardless of the buffer sizes used in the
- * copy operation.
- *
- * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
- * consequently it cannot be used to copy between overlapping memory regions.
- */
-/*@{*/
-
-namespace detail {
-
-inline std::size_t buffer_copy_1(const mutable_buffer& target,
-    const const_buffer& source)
-{
-  using namespace std; // For memcpy.
-  std::size_t target_size = target.size();
-  std::size_t source_size = source.size();
-  std::size_t n = target_size < source_size ? target_size : source_size;
-  if (n > 0)
-    memcpy(target.data(), source.data(), n);
-  return n;
-}
-
-template <typename TargetIterator, typename SourceIterator>
-inline std::size_t buffer_copy(one_buffer, one_buffer,
-    TargetIterator target_begin, TargetIterator,
-    SourceIterator source_begin, SourceIterator) noexcept
-{
-  return (buffer_copy_1)(*target_begin, *source_begin);
-}
-
-template <typename TargetIterator, typename SourceIterator>
-inline std::size_t buffer_copy(one_buffer, one_buffer,
-    TargetIterator target_begin, TargetIterator,
-    SourceIterator source_begin, SourceIterator,
-    std::size_t max_bytes_to_copy) noexcept
-{
-  return (buffer_copy_1)(*target_begin,
-      asio::buffer(*source_begin, max_bytes_to_copy));
-}
-
-template <typename TargetIterator, typename SourceIterator>
-std::size_t buffer_copy(one_buffer, multiple_buffers,
-    TargetIterator target_begin, TargetIterator,
-    SourceIterator source_begin, SourceIterator source_end,
-    std::size_t max_bytes_to_copy
-      = (std::numeric_limits<std::size_t>::max)()) noexcept
-{
-  std::size_t total_bytes_copied = 0;
-  SourceIterator source_iter = source_begin;
-
-  for (mutable_buffer target_buffer(
-        asio::buffer(*target_begin, max_bytes_to_copy));
-      target_buffer.size() && source_iter != source_end; ++source_iter)
-  {
-    const_buffer source_buffer(*source_iter);
-    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-    target_buffer += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-template <typename TargetIterator, typename SourceIterator>
-std::size_t buffer_copy(multiple_buffers, one_buffer,
-    TargetIterator target_begin, TargetIterator target_end,
-    SourceIterator source_begin, SourceIterator,
-    std::size_t max_bytes_to_copy
-      = (std::numeric_limits<std::size_t>::max)()) noexcept
-{
-  std::size_t total_bytes_copied = 0;
-  TargetIterator target_iter = target_begin;
-
-  for (const_buffer source_buffer(
-        asio::buffer(*source_begin, max_bytes_to_copy));
-      source_buffer.size() && target_iter != target_end; ++target_iter)
-  {
-    mutable_buffer target_buffer(*target_iter);
-    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-    source_buffer += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-template <typename TargetIterator, typename SourceIterator>
-std::size_t buffer_copy(multiple_buffers, multiple_buffers,
-    TargetIterator target_begin, TargetIterator target_end,
-    SourceIterator source_begin, SourceIterator source_end) noexcept
-{
-  std::size_t total_bytes_copied = 0;
-
-  TargetIterator target_iter = target_begin;
-  std::size_t target_buffer_offset = 0;
-
-  SourceIterator source_iter = source_begin;
-  std::size_t source_buffer_offset = 0;
-
-  while (target_iter != target_end && source_iter != source_end)
-  {
-    mutable_buffer target_buffer =
-      mutable_buffer(*target_iter) + target_buffer_offset;
-
-    const_buffer source_buffer =
-      const_buffer(*source_iter) + source_buffer_offset;
-
-    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-
-    if (bytes_copied == target_buffer.size())
-    {
-      ++target_iter;
-      target_buffer_offset = 0;
-    }
-    else
-      target_buffer_offset += bytes_copied;
-
-    if (bytes_copied == source_buffer.size())
-    {
-      ++source_iter;
-      source_buffer_offset = 0;
-    }
-    else
-      source_buffer_offset += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-template <typename TargetIterator, typename SourceIterator>
-std::size_t buffer_copy(multiple_buffers, multiple_buffers,
-    TargetIterator target_begin, TargetIterator target_end,
-    SourceIterator source_begin, SourceIterator source_end,
-    std::size_t max_bytes_to_copy) noexcept
-{
-  std::size_t total_bytes_copied = 0;
-
-  TargetIterator target_iter = target_begin;
-  std::size_t target_buffer_offset = 0;
-
-  SourceIterator source_iter = source_begin;
-  std::size_t source_buffer_offset = 0;
-
-  while (total_bytes_copied != max_bytes_to_copy
-      && target_iter != target_end && source_iter != source_end)
-  {
-    mutable_buffer target_buffer =
-      mutable_buffer(*target_iter) + target_buffer_offset;
-
-    const_buffer source_buffer =
-      const_buffer(*source_iter) + source_buffer_offset;
-
-    std::size_t bytes_copied = (buffer_copy_1)(
-        target_buffer, asio::buffer(source_buffer,
-          max_bytes_to_copy - total_bytes_copied));
-    total_bytes_copied += bytes_copied;
-
-    if (bytes_copied == target_buffer.size())
-    {
-      ++target_iter;
-      target_buffer_offset = 0;
-    }
-    else
-      target_buffer_offset += bytes_copied;
-
-    if (bytes_copied == source_buffer.size())
-    {
-      ++source_iter;
-      source_buffer_offset = 0;
-    }
-    else
-      source_buffer_offset += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-} // namespace detail
-
-/// Copies bytes from a source buffer sequence to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence, typename ConstBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const ConstBufferSequence& source) noexcept
-{
-  return detail::buffer_copy(
-      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
-      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
-      asio::buffer_sequence_begin(target),
-      asio::buffer_sequence_end(target),
-      asio::buffer_sequence_begin(source),
-      asio::buffer_sequence_end(source));
-}
-
-/// Copies a limited number of bytes from a source buffer sequence to a target
-/// buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- *
- * This function is implemented in terms of @c memcpy, and consequently it
- * cannot be used to copy between overlapping memory regions.
- */
-template <typename MutableBufferSequence, typename ConstBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const ConstBufferSequence& source,
-    std::size_t max_bytes_to_copy) noexcept
-{
-  return detail::buffer_copy(
-      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
-      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
-      asio::buffer_sequence_begin(target),
-      asio::buffer_sequence_end(target),
-      asio::buffer_sequence_begin(source),
-      asio::buffer_sequence_end(source), max_bytes_to_copy);
-}
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-#include "asio/detail/is_buffer_sequence.hpp"
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Trait to determine whether a type satisfies the MutableBufferSequence
-/// requirements.
-template <typename T>
-struct is_mutable_buffer_sequence
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  : asio::detail::is_buffer_sequence<T, mutable_buffer>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-
-/// Trait to determine whether a type satisfies the ConstBufferSequence
-/// requirements.
-template <typename T>
-struct is_const_buffer_sequence
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  : asio::detail::is_buffer_sequence<T, const_buffer>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-/// Trait to determine whether a type satisfies the DynamicBuffer_v1
-/// requirements.
-template <typename T>
-struct is_dynamic_buffer_v1
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  : asio::detail::is_dynamic_buffer_v1<T>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Trait to determine whether a type satisfies the DynamicBuffer_v2
-/// requirements.
-template <typename T>
-struct is_dynamic_buffer_v2
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  : asio::detail::is_dynamic_buffer_v2<T>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-
-/// Trait to determine whether a type satisfies the DynamicBuffer requirements.
-/**
- * If @c ASIO_NO_DYNAMIC_BUFFER_V1 is not defined, determines whether the
- * type satisfies the DynamicBuffer_v1 requirements. Otherwise, if @c
- * ASIO_NO_DYNAMIC_BUFFER_V1 is defined, determines whether the type
- * satisfies the DynamicBuffer_v2 requirements.
- */
-template <typename T>
-struct is_dynamic_buffer
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#elif defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  : asio::is_dynamic_buffer_v2<T>
-#else // defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  : asio::is_dynamic_buffer_v1<T>
-#endif // defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-{
-};
-
-namespace buffer_literals {
-namespace detail {
-
-template <char... Chars>
-struct chars {};
-
-template <unsigned char... Bytes>
-struct bytes {};
-
-// Literal processor that converts binary literals to an array of bytes.
-
-template <typename Bytes, char... Chars>
-struct bin_literal;
-
-template <unsigned char... Bytes>
-struct bin_literal<bytes<Bytes...>>
-{
-  static const std::size_t size = sizeof...(Bytes);
-  static const unsigned char data[sizeof...(Bytes)];
-};
-
-template <unsigned char... Bytes>
-const unsigned char bin_literal<bytes<Bytes...>>::data[sizeof...(Bytes)]
-  = { Bytes... };
-
-template <unsigned char... Bytes, char Bit7, char Bit6, char Bit5,
-    char Bit4, char Bit3, char Bit2, char Bit1, char Bit0, char... Chars>
-struct bin_literal<bytes<Bytes...>, Bit7, Bit6,
-    Bit5, Bit4, Bit3, Bit2, Bit1, Bit0, Chars...> :
-  bin_literal<
-    bytes<Bytes...,
-      static_cast<unsigned char>(
-      (Bit7 == '1' ? 0x80 : 0) |
-        (Bit6 == '1' ? 0x40 : 0) |
-        (Bit5 == '1' ? 0x20 : 0) |
-        (Bit4 == '1' ? 0x10 : 0) |
-        (Bit3 == '1' ? 0x08 : 0) |
-        (Bit2 == '1' ? 0x04 : 0) |
-        (Bit1 == '1' ? 0x02 : 0) |
-        (Bit0 == '1' ? 0x01 : 0))
-    >, Chars...> {};
-
-template <unsigned char... Bytes, char... Chars>
-struct bin_literal<bytes<Bytes...>, Chars...>
-{
-  static_assert(sizeof...(Chars) == 0,
-      "number of digits in a binary buffer literal must be a multiple of 8");
-
-  static const std::size_t size = 0;
-  static const unsigned char data[1];
-};
-
-template <unsigned char... Bytes, char... Chars>
-const unsigned char bin_literal<bytes<Bytes...>, Chars...>::data[1] = {};
-
-// Literal processor that converts hexadecimal literals to an array of bytes.
-
-template <typename Bytes, char... Chars>
-struct hex_literal;
-
-template <unsigned char... Bytes>
-struct hex_literal<bytes<Bytes...>>
-{
-  static const std::size_t size = sizeof...(Bytes);
-  static const unsigned char data[sizeof...(Bytes)];
-};
-
-template <unsigned char... Bytes>
-const unsigned char hex_literal<bytes<Bytes...>>::data[sizeof...(Bytes)]
-  = { Bytes... };
-
-template <unsigned char... Bytes, char Hi, char Lo, char... Chars>
-struct hex_literal<bytes<Bytes...>, Hi, Lo, Chars...> :
-  hex_literal<
-    bytes<Bytes...,
-      static_cast<unsigned char>(
-        Lo >= 'A' && Lo <= 'F' ? Lo - 'A' + 10 :
-          (Lo >= 'a' && Lo <= 'f' ? Lo - 'a' + 10 : Lo - '0')) |
-      ((static_cast<unsigned char>(
-        Hi >= 'A' && Hi <= 'F' ? Hi - 'A' + 10 :
-          (Hi >= 'a' && Hi <= 'f' ? Hi - 'a' + 10 : Hi - '0'))) << 4)
-    >, Chars...> {};
-
-template <unsigned char... Bytes, char Char>
-struct hex_literal<bytes<Bytes...>, Char>
-{
-  static_assert(!Char,
-      "a hexadecimal buffer literal must have an even number of digits");
-
-  static const std::size_t size = 0;
-  static const unsigned char data[1];
-};
-
-template <unsigned char... Bytes, char Char>
-const unsigned char hex_literal<bytes<Bytes...>, Char>::data[1] = {};
-
-// Helper template that removes digit separators and then passes the cleaned
-// variadic pack of characters to the literal processor.
-
-template <template <typename, char...> class Literal,
-    typename Clean, char... Raw>
-struct remove_separators;
-
-template <template <typename, char...> class Literal,
-    char... Clean, char... Raw>
-struct remove_separators<Literal, chars<Clean...>, '\'', Raw...> :
-  remove_separators<Literal, chars<Clean...>, Raw...> {};
-
-template <template <typename, char...> class Literal,
-    char... Clean, char C, char... Raw>
-struct remove_separators<Literal, chars<Clean...>, C, Raw...> :
-  remove_separators<Literal, chars<Clean..., C>, Raw...> {};
-
-template <template <typename, char...> class Literal, char... Clean>
-struct remove_separators<Literal, chars<Clean...>> :
-  Literal<bytes<>, Clean...> {};
-
-// Helper template to determine the literal type based on the prefix.
-
-template <char... Chars>
-struct literal;
-
-template <char... Chars>
-struct literal<'0', 'b', Chars...> :
-  remove_separators<bin_literal, chars<>, Chars...>{};
-
-template <char... Chars>
-struct literal<'0', 'B', Chars...> :
-  remove_separators<bin_literal, chars<>, Chars...>{};
-
-template <char... Chars>
-struct literal<'0', 'x', Chars...> :
-  remove_separators<hex_literal, chars<>, Chars...>{};
-
-template <char... Chars>
-struct literal<'0', 'X', Chars...> :
-  remove_separators<hex_literal, chars<>, Chars...>{};
-
-} // namespace detail
-
-/// Literal operator for creating const_buffer objects from string literals.
-inline ASIO_CONST_BUFFER operator ""_buf(const char* data, std::size_t n)
-{
-  return ASIO_CONST_BUFFER(data, n);
-}
-
-/// Literal operator for creating const_buffer objects from unbounded binary or
-/// hexadecimal integer literals.
-template <char... Chars>
-inline ASIO_CONST_BUFFER operator ""_buf()
-{
-  return ASIO_CONST_BUFFER(
-      +detail::literal<Chars...>::data,
-      detail::literal<Chars...>::size);
-}
-
-} // namespace buffer_literals
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer_registration.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer_registration.hpp
deleted file mode 100644
index 48d56f8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffer_registration.hpp
+++ /dev/null
@@ -1,318 +0,0 @@
-//
-// buffer_registration.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFER_REGISTRATION_HPP
-#define ASIO_BUFFER_REGISTRATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <iterator>
-#include <utility>
-#include <vector>
-#include "asio/detail/memory.hpp"
-#include "asio/execution/context.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/query.hpp"
-#include "asio/registered_buffer.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-# include "asio/detail/scheduler.hpp"
-# include "asio/detail/io_uring_service.hpp"
-#endif // defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffer_registration_base
-{
-protected:
-  static mutable_registered_buffer make_buffer(const mutable_buffer& b,
-      const void* scope, int index) noexcept
-  {
-    return mutable_registered_buffer(b, registered_buffer_id(scope, index));
-  }
-};
-
-} // namespace detail
-
-/// Automatically registers and unregistered buffers with an execution context.
-/**
- * For portability, applications should assume that only one registration is
- * permitted per execution context.
- */
-template <typename MutableBufferSequence,
-    typename Allocator = std::allocator<void>>
-class buffer_registration
-  : detail::buffer_registration_base
-{
-public:
-  /// The allocator type used for allocating storage for the buffers container.
-  typedef Allocator allocator_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type of an iterator over the registered buffers.
-  typedef unspecified iterator;
-
-  /// The type of a const iterator over the registered buffers.
-  typedef unspecified const_iterator;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef std::vector<mutable_registered_buffer>::const_iterator iterator;
-  typedef std::vector<mutable_registered_buffer>::const_iterator const_iterator;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Register buffers with an executor's execution context.
-  template <typename Executor>
-  buffer_registration(const Executor& ex,
-      const MutableBufferSequence& buffer_sequence,
-      const allocator_type& alloc = allocator_type(),
-      constraint_t<
-        is_executor<Executor>::value || execution::is_executor<Executor>::value
-      > = 0)
-    : buffer_sequence_(buffer_sequence),
-      buffers_(
-          ASIO_REBIND_ALLOC(allocator_type,
-            mutable_registered_buffer)(alloc))
-  {
-    init_buffers(buffer_registration::get_context(ex),
-        asio::buffer_sequence_begin(buffer_sequence_),
-        asio::buffer_sequence_end(buffer_sequence_));
-  }
-
-  /// Register buffers with an execution context.
-  template <typename ExecutionContext>
-  buffer_registration(ExecutionContext& ctx,
-      const MutableBufferSequence& buffer_sequence,
-      const allocator_type& alloc = allocator_type(),
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : buffer_sequence_(buffer_sequence),
-      buffers_(
-          ASIO_REBIND_ALLOC(allocator_type,
-            mutable_registered_buffer)(alloc))
-  {
-    init_buffers(ctx,
-        asio::buffer_sequence_begin(buffer_sequence_),
-        asio::buffer_sequence_end(buffer_sequence_));
-  }
-
-  /// Move constructor.
-  buffer_registration(buffer_registration&& other) noexcept
-    : buffer_sequence_(std::move(other.buffer_sequence_)),
-      buffers_(std::move(other.buffers_))
-  {
-#if defined(ASIO_HAS_IO_URING)
-    service_ = other.service_;
-    other.service_ = 0;
-#endif // defined(ASIO_HAS_IO_URING)
-  }
-
-  /// Unregisters the buffers.
-  ~buffer_registration()
-  {
-#if defined(ASIO_HAS_IO_URING)
-    if (service_)
-      service_->unregister_buffers();
-#endif // defined(ASIO_HAS_IO_URING)
-  }
-
-  /// Move assignment.
-  buffer_registration& operator=(buffer_registration&& other) noexcept
-  {
-    if (this != &other)
-    {
-      buffer_sequence_ = std::move(other.buffer_sequence_);
-      buffers_ = std::move(other.buffers_);
-#if defined(ASIO_HAS_IO_URING)
-      if (service_)
-        service_->unregister_buffers();
-      service_ = other.service_;
-      other.service_ = 0;
-#endif // defined(ASIO_HAS_IO_URING)
-    }
-    return *this;
-  }
-
-  /// Get the number of registered buffers.
-  std::size_t size() const noexcept
-  {
-    return buffers_.size();
-  }
-
-  /// Get the begin iterator for the sequence of registered buffers.
-  const_iterator begin() const noexcept
-  {
-    return buffers_.begin();
-  }
-
-  /// Get the begin iterator for the sequence of registered buffers.
-  const_iterator cbegin() const noexcept
-  {
-    return buffers_.cbegin();
-  }
-
-  /// Get the end iterator for the sequence of registered buffers.
-  const_iterator end() const noexcept
-  {
-    return buffers_.end();
-  }
-
-  /// Get the end iterator for the sequence of registered buffers.
-  const_iterator cend() const noexcept
-  {
-    return buffers_.cend();
-  }
-
-  /// Get the buffer at the specified index.
-  const mutable_registered_buffer& operator[](std::size_t i) noexcept
-  {
-    return buffers_[i];
-  }
-
-  /// Get the buffer at the specified index.
-  const mutable_registered_buffer& at(std::size_t i) noexcept
-  {
-    return buffers_.at(i);
-  }
-
-private:
-  // Disallow copying and assignment.
-  buffer_registration(const buffer_registration&) = delete;
-  buffer_registration& operator=(const buffer_registration&) = delete;
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<execution::is_executor<T>::value>* = 0)
-  {
-    return asio::query(t, execution::context);
-  }
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<!execution::is_executor<T>::value>* = 0)
-  {
-    return t.context();
-  }
-
-  // Helper function to initialise the container of buffers.
-  template <typename Iterator>
-  void init_buffers(execution_context& ctx, Iterator begin, Iterator end)
-  {
-    std::size_t n = std::distance(begin, end);
-    buffers_.resize(n);
-
-#if defined(ASIO_HAS_IO_URING)
-    service_ = &use_service<detail::io_uring_service>(ctx);
-    std::vector<iovec,
-      ASIO_REBIND_ALLOC(allocator_type, iovec)> iovecs(n,
-          ASIO_REBIND_ALLOC(allocator_type, iovec)(
-            buffers_.get_allocator()));
-#endif // defined(ASIO_HAS_IO_URING)
-
-    Iterator iter = begin;
-    for (int index = 0; iter != end; ++index, ++iter)
-    {
-      mutable_buffer b(*iter);
-      std::size_t i = static_cast<std::size_t>(index);
-      buffers_[i] = this->make_buffer(b, &ctx, index);
-
-#if defined(ASIO_HAS_IO_URING)
-      iovecs[i].iov_base = buffers_[i].data();
-      iovecs[i].iov_len = buffers_[i].size();
-#endif // defined(ASIO_HAS_IO_URING)
-    }
-
-#if defined(ASIO_HAS_IO_URING)
-    if (n > 0)
-    {
-      service_->register_buffers(&iovecs[0],
-          static_cast<unsigned>(iovecs.size()));
-    }
-#endif // defined(ASIO_HAS_IO_URING)
-  }
-
-  MutableBufferSequence buffer_sequence_;
-  std::vector<mutable_registered_buffer,
-    ASIO_REBIND_ALLOC(allocator_type,
-      mutable_registered_buffer)> buffers_;
-#if defined(ASIO_HAS_IO_URING)
-  detail::io_uring_service* service_;
-#endif // defined(ASIO_HAS_IO_URING)
-};
-
-/// Register buffers with an execution context.
-template <typename Executor, typename MutableBufferSequence>
-ASIO_NODISCARD inline
-buffer_registration<MutableBufferSequence>
-register_buffers(const Executor& ex,
-    const MutableBufferSequence& buffer_sequence,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return buffer_registration<MutableBufferSequence>(ex, buffer_sequence);
-}
-
-/// Register buffers with an execution context.
-template <typename Executor, typename MutableBufferSequence, typename Allocator>
-ASIO_NODISCARD inline
-buffer_registration<MutableBufferSequence, Allocator>
-register_buffers(const Executor& ex,
-    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return buffer_registration<MutableBufferSequence, Allocator>(
-      ex, buffer_sequence, alloc);
-}
-
-/// Register buffers with an execution context.
-template <typename ExecutionContext, typename MutableBufferSequence>
-ASIO_NODISCARD inline
-buffer_registration<MutableBufferSequence>
-register_buffers(ExecutionContext& ctx,
-    const MutableBufferSequence& buffer_sequence,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return buffer_registration<MutableBufferSequence>(ctx, buffer_sequence);
-}
-
-/// Register buffers with an execution context.
-template <typename ExecutionContext,
-    typename MutableBufferSequence, typename Allocator>
-ASIO_NODISCARD inline
-buffer_registration<MutableBufferSequence, Allocator>
-register_buffers(ExecutionContext& ctx,
-    const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return buffer_registration<MutableBufferSequence, Allocator>(
-      ctx, buffer_sequence, alloc);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFER_REGISTRATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream.hpp
deleted file mode 100644
index 264f66c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream.hpp
+++ /dev/null
@@ -1,273 +0,0 @@
-//
-// buffered_read_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_READ_STREAM_HPP
-#define ASIO_BUFFERED_READ_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/buffered_read_stream_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_resize_guard.hpp"
-#include "asio/detail/buffered_stream_storage.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_buffered_fill;
-template <typename> class initiate_async_buffered_read_some;
-
-} // namespace detail
-
-/// Adds buffering to the read-related operations of a stream.
-/**
- * The buffered_read_stream class template can be used to add buffering to the
- * synchronous and asynchronous read operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_read_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef remove_reference_t<Stream> next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// The type of the executor associated with the object.
-  typedef typename lowest_layer_type::executor_type executor_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The default buffer size.
-  static const std::size_t default_buffer_size = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
-#endif
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_read_stream(Arg&& a)
-    : next_layer_(static_cast<Arg&&>(a)),
-      storage_(default_buffer_size)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  buffered_read_stream(Arg&& a,
-      std::size_t buffer_size)
-    : next_layer_(static_cast<Arg&&>(a)),
-      storage_(buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get the executor associated with the object.
-  executor_type get_executor() noexcept
-  {
-    return next_layer_.lowest_layer().get_executor();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    next_layer_.close();
-  }
-
-  /// Close the stream.
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    next_layer_.close(ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    return next_layer_.write_some(buffers);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.write_some(buffers, ec);
-  }
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<conditional_t<true, Stream&, WriteHandler>>().async_write_some(
-        buffers, static_cast<WriteHandler&&>(handler)))
-  {
-    return next_layer_.async_write_some(buffers,
-        static_cast<WriteHandler&&>(handler));
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation. Throws an exception on failure.
-  std::size_t fill();
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation, or 0 if an error occurred.
-  std::size_t fill(asio::error_code& ec);
-
-  /// Start an asynchronous fill.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
-  auto async_fill(
-      ReadHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadHandler,
-        void (asio::error_code, std::size_t)>(
-          declval<detail::initiate_async_buffered_fill<Stream>>(),
-          handler, declval<detail::buffered_stream_storage*>()));
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers);
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec);
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadHandler,
-        void (asio::error_code, std::size_t)>(
-          declval<detail::initiate_async_buffered_read_some<Stream>>(),
-          handler, declval<detail::buffered_stream_storage*>(), buffers));
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers);
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec);
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return storage_.size();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return storage_.size();
-  }
-
-private:
-  /// Copy data out of the internal buffer to the specified target buffer.
-  /// Returns the number of bytes copied.
-  template <typename MutableBufferSequence>
-  std::size_t copy(const MutableBufferSequence& buffers)
-  {
-    std::size_t bytes_copied = asio::buffer_copy(
-        buffers, storage_.data(), storage_.size());
-    storage_.consume(bytes_copied);
-    return bytes_copied;
-  }
-
-  /// Copy data from the internal buffer to the specified target buffer, without
-  /// removing the data from the internal buffer. Returns the number of bytes
-  /// copied.
-  template <typename MutableBufferSequence>
-  std::size_t peek_copy(const MutableBufferSequence& buffers)
-  {
-    return asio::buffer_copy(buffers, storage_.data(), storage_.size());
-  }
-
-  /// The next layer.
-  Stream next_layer_;
-
-  // The data in the buffer.
-  detail::buffered_stream_storage storage_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/buffered_read_stream.hpp"
-
-#endif // ASIO_BUFFERED_READ_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream_fwd.hpp
deleted file mode 100644
index d98aa70..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_read_stream_fwd.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// buffered_read_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_READ_STREAM_FWD_HPP
-#define ASIO_BUFFERED_READ_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_read_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_READ_STREAM_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream.hpp
deleted file mode 100644
index e0e1b47..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream.hpp
+++ /dev/null
@@ -1,292 +0,0 @@
-//
-// buffered_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_STREAM_HPP
-#define ASIO_BUFFERED_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Adds buffering to the read- and write-related operations of a stream.
-/**
- * The buffered_stream class template can be used to add buffering to the
- * synchronous and asynchronous read and write operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef remove_reference_t<Stream> next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// The type of the executor associated with the object.
-  typedef typename lowest_layer_type::executor_type executor_type;
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_stream(Arg&& a)
-    : inner_stream_impl_(static_cast<Arg&&>(a)),
-      stream_impl_(inner_stream_impl_)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_stream(Arg&& a,
-      std::size_t read_buffer_size, std::size_t write_buffer_size)
-    : inner_stream_impl_(static_cast<Arg&&>(a), write_buffer_size),
-      stream_impl_(inner_stream_impl_, read_buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return stream_impl_.next_layer().next_layer();
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return stream_impl_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return stream_impl_.lowest_layer();
-  }
-
-  /// Get the executor associated with the object.
-  executor_type get_executor() noexcept
-  {
-    return stream_impl_.lowest_layer().get_executor();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    stream_impl_.close();
-  }
-
-  /// Close the stream.
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    stream_impl_.close(ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation. Throws an
-  /// exception on failure.
-  std::size_t flush()
-  {
-    return stream_impl_.next_layer().flush();
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation, or 0 if an
-  /// error occurred.
-  std::size_t flush(asio::error_code& ec)
-  {
-    return stream_impl_.next_layer().flush(ec);
-  }
-
-  /// Start an asynchronous flush.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
-  auto async_flush(
-      WriteHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<buffered_write_stream<Stream>&>().async_flush(
-        static_cast<WriteHandler&&>(handler)))
-  {
-    return stream_impl_.next_layer().async_flush(
-        static_cast<WriteHandler&&>(handler));
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    return stream_impl_.write_some(buffers);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.write_some(buffers, ec);
-  }
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<Stream&>().async_write_some(buffers,
-        static_cast<WriteHandler&&>(handler)))
-  {
-    return stream_impl_.async_write_some(buffers,
-        static_cast<WriteHandler&&>(handler));
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation. Throws an exception on failure.
-  std::size_t fill()
-  {
-    return stream_impl_.fill();
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation, or 0 if an error occurred.
-  std::size_t fill(asio::error_code& ec)
-  {
-    return stream_impl_.fill(ec);
-  }
-
-  /// Start an asynchronous fill.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
-  auto async_fill(
-      ReadHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<buffered_read_stream<
-        buffered_write_stream<Stream>>&>().async_fill(
-          static_cast<ReadHandler&&>(handler)))
-  {
-    return stream_impl_.async_fill(static_cast<ReadHandler&&>(handler));
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    return stream_impl_.read_some(buffers);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.read_some(buffers, ec);
-  }
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<Stream&>().async_read_some(buffers,
-        static_cast<ReadHandler&&>(handler)))
-  {
-    return stream_impl_.async_read_some(buffers,
-        static_cast<ReadHandler&&>(handler));
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    return stream_impl_.peek(buffers);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.peek(buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return stream_impl_.in_avail();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    return stream_impl_.in_avail(ec);
-  }
-
-private:
-  // The buffered write stream.
-  typedef buffered_write_stream<Stream> write_stream_type;
-  write_stream_type inner_stream_impl_;
-
-  // The buffered read stream.
-  typedef buffered_read_stream<write_stream_type&> read_stream_type;
-  read_stream_type stream_impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERED_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream_fwd.hpp
deleted file mode 100644
index 790c762..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_stream_fwd.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// buffered_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_STREAM_FWD_HPP
-#define ASIO_BUFFERED_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_STREAM_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream.hpp
deleted file mode 100644
index f8f0538..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream.hpp
+++ /dev/null
@@ -1,265 +0,0 @@
-//
-// buffered_write_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_WRITE_STREAM_HPP
-#define ASIO_BUFFERED_WRITE_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/buffered_write_stream_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffered_stream_storage.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/write.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_buffered_flush;
-template <typename> class initiate_async_buffered_write_some;
-
-} // namespace detail
-
-/// Adds buffering to the write-related operations of a stream.
-/**
- * The buffered_write_stream class template can be used to add buffering to the
- * synchronous and asynchronous write operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_write_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef remove_reference_t<Stream> next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// The type of the executor associated with the object.
-  typedef typename lowest_layer_type::executor_type executor_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The default buffer size.
-  static const std::size_t default_buffer_size = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
-#endif
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_write_stream(Arg&& a)
-    : next_layer_(static_cast<Arg&&>(a)),
-      storage_(default_buffer_size)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  buffered_write_stream(Arg&& a,
-      std::size_t buffer_size)
-    : next_layer_(static_cast<Arg&&>(a)),
-      storage_(buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get the executor associated with the object.
-  executor_type get_executor() noexcept
-  {
-    return next_layer_.lowest_layer().get_executor();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    next_layer_.close();
-  }
-
-  /// Close the stream.
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    next_layer_.close(ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation. Throws an
-  /// exception on failure.
-  std::size_t flush();
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation, or 0 if an
-  /// error occurred.
-  std::size_t flush(asio::error_code& ec);
-
-  /// Start an asynchronous flush.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
-  auto async_flush(
-      WriteHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteHandler,
-        void (asio::error_code, std::size_t)>(
-          declval<detail::initiate_async_buffered_flush<Stream>>(),
-          handler, declval<detail::buffered_stream_storage*>()));
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers);
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred and the error handler did not throw.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec);
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteHandler = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteHandler,
-        void (asio::error_code, std::size_t)>(
-          declval<detail::initiate_async_buffered_write_some<Stream>>(),
-          handler, declval<detail::buffered_stream_storage*>(), buffers));
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    return next_layer_.read_some(buffers);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.read_some(buffers, ec);
-  }
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadHandler = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler&& handler = default_completion_token_t<executor_type>())
-    -> decltype(
-      declval<conditional_t<true, Stream&, ReadHandler>>().async_read_some(
-        buffers, static_cast<ReadHandler&&>(handler)))
-  {
-    return next_layer_.async_read_some(buffers,
-        static_cast<ReadHandler&&>(handler));
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    return next_layer_.peek(buffers);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.peek(buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return next_layer_.in_avail();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    return next_layer_.in_avail(ec);
-  }
-
-private:
-  /// Copy data into the internal buffer from the specified source buffer.
-  /// Returns the number of bytes copied.
-  template <typename ConstBufferSequence>
-  std::size_t copy(const ConstBufferSequence& buffers);
-
-  /// The next layer.
-  Stream next_layer_;
-
-  // The data in the buffer.
-  detail::buffered_stream_storage storage_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/buffered_write_stream.hpp"
-
-#endif // ASIO_BUFFERED_WRITE_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream_fwd.hpp
deleted file mode 100644
index 809f44a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffered_write_stream_fwd.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// buffered_write_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
-#define ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_write_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffers_iterator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffers_iterator.hpp
deleted file mode 100644
index 2c6d720..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/buffers_iterator.hpp
+++ /dev/null
@@ -1,521 +0,0 @@
-//
-// buffers_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERS_ITERATOR_HPP
-#define ASIO_BUFFERS_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <iterator>
-#include "asio/buffer.hpp"
-#include "asio/detail/assert.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <bool IsMutable>
-  struct buffers_iterator_types_helper;
-
-  template <>
-  struct buffers_iterator_types_helper<false>
-  {
-    typedef const_buffer buffer_type;
-    template <typename ByteType>
-    struct byte_type
-    {
-      typedef add_const_t<ByteType> type;
-    };
-  };
-
-  template <>
-  struct buffers_iterator_types_helper<true>
-  {
-    typedef mutable_buffer buffer_type;
-    template <typename ByteType>
-    struct byte_type
-    {
-      typedef ByteType type;
-    };
-  };
-
-  template <typename BufferSequence, typename ByteType>
-  struct buffers_iterator_types
-  {
-    enum
-    {
-      is_mutable = is_convertible<
-          typename BufferSequence::value_type,
-          mutable_buffer>::value
-    };
-    typedef buffers_iterator_types_helper<is_mutable> helper;
-    typedef typename helper::buffer_type buffer_type;
-    typedef typename helper::template byte_type<ByteType>::type byte_type;
-    typedef typename BufferSequence::const_iterator const_iterator;
-  };
-
-  template <typename ByteType>
-  struct buffers_iterator_types<mutable_buffer, ByteType>
-  {
-    typedef mutable_buffer buffer_type;
-    typedef ByteType byte_type;
-    typedef const mutable_buffer* const_iterator;
-  };
-
-  template <typename ByteType>
-  struct buffers_iterator_types<const_buffer, ByteType>
-  {
-    typedef const_buffer buffer_type;
-    typedef add_const_t<ByteType> byte_type;
-    typedef const const_buffer* const_iterator;
-  };
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-  template <typename ByteType>
-  struct buffers_iterator_types<mutable_buffers_1, ByteType>
-  {
-    typedef mutable_buffer buffer_type;
-    typedef ByteType byte_type;
-    typedef const mutable_buffer* const_iterator;
-  };
-
-  template <typename ByteType>
-  struct buffers_iterator_types<const_buffers_1, ByteType>
-  {
-    typedef const_buffer buffer_type;
-    typedef add_const_t<ByteType> byte_type;
-    typedef const const_buffer* const_iterator;
-  };
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-}
-
-/// A random access iterator over the bytes in a buffer sequence.
-template <typename BufferSequence, typename ByteType = char>
-class buffers_iterator
-{
-private:
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::buffer_type buffer_type;
-
-  typedef typename detail::buffers_iterator_types<BufferSequence,
-          ByteType>::const_iterator buffer_sequence_iterator_type;
-
-public:
-  /// The type used for the distance between two iterators.
-  typedef std::ptrdiff_t difference_type;
-
-  /// The type of the value pointed to by the iterator.
-  typedef ByteType value_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type of the result of applying operator->() to the iterator.
-  /**
-   * If the buffer sequence stores buffer objects that are convertible to
-   * mutable_buffer, this is a pointer to a non-const ByteType. Otherwise, a
-   * pointer to a const ByteType.
-   */
-  typedef const_or_non_const_ByteType* pointer;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type* pointer;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type of the result of applying operator*() to the iterator.
-  /**
-   * If the buffer sequence stores buffer objects that are convertible to
-   * mutable_buffer, this is a reference to a non-const ByteType. Otherwise, a
-   * reference to a const ByteType.
-   */
-  typedef const_or_non_const_ByteType& reference;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type& reference;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// The iterator category.
-  typedef std::random_access_iterator_tag iterator_category;
-
-  /// Default constructor. Creates an iterator in an undefined state.
-  buffers_iterator()
-    : current_buffer_(),
-      current_buffer_position_(0),
-      begin_(),
-      current_(),
-      end_(),
-      position_(0)
-  {
-  }
-
-  /// Construct an iterator representing the beginning of the buffers' data.
-  static buffers_iterator begin(const BufferSequence& buffers)
-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-    __attribute__ ((__noinline__))
-#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-  {
-    buffers_iterator new_iter;
-    new_iter.begin_ = asio::buffer_sequence_begin(buffers);
-    new_iter.current_ = asio::buffer_sequence_begin(buffers);
-    new_iter.end_ = asio::buffer_sequence_end(buffers);
-    while (new_iter.current_ != new_iter.end_)
-    {
-      new_iter.current_buffer_ = *new_iter.current_;
-      if (new_iter.current_buffer_.size() > 0)
-        break;
-      ++new_iter.current_;
-    }
-    return new_iter;
-  }
-
-  /// Construct an iterator representing the end of the buffers' data.
-  static buffers_iterator end(const BufferSequence& buffers)
-#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-    __attribute__ ((__noinline__))
-#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-  {
-    buffers_iterator new_iter;
-    new_iter.begin_ = asio::buffer_sequence_begin(buffers);
-    new_iter.current_ = asio::buffer_sequence_begin(buffers);
-    new_iter.end_ = asio::buffer_sequence_end(buffers);
-    while (new_iter.current_ != new_iter.end_)
-    {
-      buffer_type buffer = *new_iter.current_;
-      new_iter.position_ += buffer.size();
-      ++new_iter.current_;
-    }
-    return new_iter;
-  }
-
-  /// Dereference an iterator.
-  reference operator*() const
-  {
-    return dereference();
-  }
-
-  /// Dereference an iterator.
-  pointer operator->() const
-  {
-    return &dereference();
-  }
-
-  /// Access an individual element.
-  reference operator[](std::ptrdiff_t difference) const
-  {
-    buffers_iterator tmp(*this);
-    tmp.advance(difference);
-    return *tmp;
-  }
-
-  /// Increment operator (prefix).
-  buffers_iterator& operator++()
-  {
-    increment();
-    return *this;
-  }
-
-  /// Increment operator (postfix).
-  buffers_iterator operator++(int)
-  {
-    buffers_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  /// Decrement operator (prefix).
-  buffers_iterator& operator--()
-  {
-    decrement();
-    return *this;
-  }
-
-  /// Decrement operator (postfix).
-  buffers_iterator operator--(int)
-  {
-    buffers_iterator tmp(*this);
-    --*this;
-    return tmp;
-  }
-
-  /// Addition operator.
-  buffers_iterator& operator+=(std::ptrdiff_t difference)
-  {
-    advance(difference);
-    return *this;
-  }
-
-  /// Subtraction operator.
-  buffers_iterator& operator-=(std::ptrdiff_t difference)
-  {
-    advance(-difference);
-    return *this;
-  }
-
-  /// Addition operator.
-  friend buffers_iterator operator+(const buffers_iterator& iter,
-      std::ptrdiff_t difference)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(difference);
-    return tmp;
-  }
-
-  /// Addition operator.
-  friend buffers_iterator operator+(std::ptrdiff_t difference,
-      const buffers_iterator& iter)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(difference);
-    return tmp;
-  }
-
-  /// Subtraction operator.
-  friend buffers_iterator operator-(const buffers_iterator& iter,
-      std::ptrdiff_t difference)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(-difference);
-    return tmp;
-  }
-
-  /// Subtraction operator.
-  friend std::ptrdiff_t operator-(const buffers_iterator& a,
-      const buffers_iterator& b)
-  {
-    return b.distance_to(a);
-  }
-
-  /// Test two iterators for equality.
-  friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return a.equal(b);
-  }
-
-  /// Test two iterators for inequality.
-  friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !a.equal(b);
-  }
-
-  /// Compare two iterators.
-  friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return a.distance_to(b) > 0;
-  }
-
-  /// Compare two iterators.
-  friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !(b < a);
-  }
-
-  /// Compare two iterators.
-  friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return b < a;
-  }
-
-  /// Compare two iterators.
-  friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !(a < b);
-  }
-
-private:
-  // Dereference the iterator.
-  reference dereference() const
-  {
-    return static_cast<pointer>(
-        current_buffer_.data())[current_buffer_position_];
-  }
-
-  // Compare two iterators for equality.
-  bool equal(const buffers_iterator& other) const
-  {
-    return position_ == other.position_;
-  }
-
-  // Increment the iterator.
-  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_;
-    }
-  }
-
-  // Decrement the iterator.
-  void decrement()
-  {
-    ASIO_ASSERT(position_ > 0 && "iterator out of bounds");
-    --position_;
-
-    // Check if the decrement can be satisfied by the current buffer.
-    if (current_buffer_position_ != 0)
-    {
-      --current_buffer_position_;
-      return;
-    }
-
-    // Find the previous non-empty buffer.
-    buffer_sequence_iterator_type iter = current_;
-    while (iter != begin_)
-    {
-      --iter;
-      buffer_type buffer = *iter;
-      std::size_t buffer_size = buffer.size();
-      if (buffer_size > 0)
-      {
-        current_ = iter;
-        current_buffer_ = buffer;
-        current_buffer_position_ = buffer_size - 1;
-        return;
-      }
-    }
-  }
-
-  // Advance the iterator by the specified distance.
-  void advance(std::ptrdiff_t n)
-  {
-    if (n > 0)
-    {
-      ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
-      for (;;)
-      {
-        std::ptrdiff_t current_buffer_balance
-          = current_buffer_.size() - current_buffer_position_;
-
-        // Check if the advance can be satisfied by the current buffer.
-        if (current_buffer_balance > n)
-        {
-          position_ += n;
-          current_buffer_position_ += n;
-          return;
-        }
-
-        // Update position.
-        n -= current_buffer_balance;
-        position_ += current_buffer_balance;
-
-        // Move to next buffer. If it is empty then it will be skipped on the
-        // next iteration of this loop.
-        if (++current_ == end_)
-        {
-          ASIO_ASSERT(n == 0 && "iterator out of bounds");
-          current_buffer_ = buffer_type();
-          current_buffer_position_ = 0;
-          return;
-        }
-        current_buffer_ = *current_;
-        current_buffer_position_ = 0;
-      }
-    }
-    else if (n < 0)
-    {
-      std::size_t abs_n = -n;
-      ASIO_ASSERT(position_ >= abs_n && "iterator out of bounds");
-      for (;;)
-      {
-        // Check if the advance can be satisfied by the current buffer.
-        if (current_buffer_position_ >= abs_n)
-        {
-          position_ -= abs_n;
-          current_buffer_position_ -= abs_n;
-          return;
-        }
-
-        // Update position.
-        abs_n -= current_buffer_position_;
-        position_ -= current_buffer_position_;
-
-        // Check if we've reached the beginning of the buffers.
-        if (current_ == begin_)
-        {
-          ASIO_ASSERT(abs_n == 0 && "iterator out of bounds");
-          current_buffer_position_ = 0;
-          return;
-        }
-
-        // Find the previous non-empty buffer.
-        buffer_sequence_iterator_type iter = current_;
-        while (iter != begin_)
-        {
-          --iter;
-          buffer_type buffer = *iter;
-          std::size_t buffer_size = buffer.size();
-          if (buffer_size > 0)
-          {
-            current_ = iter;
-            current_buffer_ = buffer;
-            current_buffer_position_ = buffer_size;
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  // Determine the distance between two iterators.
-  std::ptrdiff_t distance_to(const buffers_iterator& other) const
-  {
-    return other.position_ - position_;
-  }
-
-  buffer_type current_buffer_;
-  std::size_t current_buffer_position_;
-  buffer_sequence_iterator_type begin_;
-  buffer_sequence_iterator_type current_;
-  buffer_sequence_iterator_type end_;
-  std::size_t position_;
-};
-
-/// Construct an iterator representing the beginning of the buffers' data.
-template <typename BufferSequence>
-inline buffers_iterator<BufferSequence> buffers_begin(
-    const BufferSequence& buffers)
-{
-  return buffers_iterator<BufferSequence>::begin(buffers);
-}
-
-/// Construct an iterator representing the end of the buffers' data.
-template <typename BufferSequence>
-inline buffers_iterator<BufferSequence> buffers_end(
-    const BufferSequence& buffers)
-{
-  return buffers_iterator<BufferSequence>::end(buffers);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERS_ITERATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_after.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_after.hpp
deleted file mode 100644
index 9e79b91..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_after.hpp
+++ /dev/null
@@ -1,301 +0,0 @@
-//
-// cancel_after.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CANCEL_AFTER_HPP
-#define ASIO_CANCEL_AFTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/detail/chrono.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/wait_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token adapter that cancels an operation after a timeout.
-/**
- * The cancel_after_t class is used to indicate that an asynchronous operation
- * should be cancelled if not complete before the specified duration has
- * elapsed.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>>
-class cancel_after_t
-{
-public:
-  /// Constructor.
-  template <typename T>
-  cancel_after_t(T&& completion_token, const typename Clock::duration& timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : token_(static_cast<T&&>(completion_token)),
-      timeout_(timeout),
-      cancel_type_(cancel_type)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  typename Clock::duration timeout_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A @ref completion_token adapter that cancels an operation after a timeout.
-/**
- * The cancel_after_timer class is used to indicate that an asynchronous
- * operation should be cancelled if not complete before the specified duration
- * has elapsed.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class cancel_after_timer
-{
-public:
-  /// Constructor.
-  template <typename T>
-  cancel_after_timer(T&& completion_token,
-      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-      const typename Clock::duration& timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : token_(static_cast<T&&>(completion_token)),
-      timer_(timer),
-      timeout_(timeout),
-      cancel_type_(cancel_type)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
-  typename Clock::duration timeout_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A function object type that adapts a @ref completion_token to cancel an
-/// operation after a timeout.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Clock, typename WaitTraits = asio::wait_traits<Clock>>
-class partial_cancel_after
-{
-public:
-  /// Constructor that specifies the timeout duration and cancellation type.
-  explicit partial_cancel_after(const typename Clock::duration& timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : timeout_(timeout),
-      cancel_type_(cancel_type)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// arguments should be combined into a single tuple argument.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  cancel_after_t<decay_t<CompletionToken>, Clock, WaitTraits>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return cancel_after_t<decay_t<CompletionToken>, Clock, WaitTraits>(
-        static_cast<CompletionToken&&>(completion_token),
-        timeout_, cancel_type_);
-  }
-
-//private:
-  typename Clock::duration timeout_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A function object type that adapts a @ref completion_token to cancel an
-/// operation after a timeout.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Clock, typename WaitTraits = asio::wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class partial_cancel_after_timer
-{
-public:
-  /// Constructor that specifies the timeout duration and cancellation type.
-  explicit partial_cancel_after_timer(
-      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-      const typename Clock::duration& timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : timer_(timer),
-      timeout_(timeout),
-      cancel_type_(cancel_type)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// arguments should be combined into a single tuple argument.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  cancel_after_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return cancel_after_timer<decay_t<CompletionToken>,
-      Clock, WaitTraits, Executor>(
-        static_cast<CompletionToken&&>(completion_token),
-        timeout_, cancel_type_);
-  }
-
-//private:
-  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
-  typename Clock::duration timeout_;
-  cancellation_type_t cancel_type_;
-};
-
-/// Create a partial completion token adapter that cancels an operation if not
-/// complete before the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Rep, typename Period>
-ASIO_NODISCARD inline partial_cancel_after<chrono::steady_clock>
-cancel_after(const chrono::duration<Rep, Period>& timeout,
-    cancellation_type_t cancel_type = cancellation_type::terminal)
-{
-  return partial_cancel_after<chrono::steady_clock>(timeout, cancel_type);
-}
-
-/// Create a partial completion token adapter that cancels an operation if not
-/// complete before the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Clock, typename WaitTraits,
-    typename Executor, typename Rep, typename Period>
-ASIO_NODISCARD inline
-partial_cancel_after_timer<Clock, WaitTraits, Executor>
-cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::duration<Rep, Period>& timeout,
-    cancellation_type_t cancel_type = cancellation_type::terminal)
-{
-  return partial_cancel_after_timer<Clock, WaitTraits, Executor>(
-      timer, timeout, cancel_type);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete before
-/// the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Rep, typename Period, typename CompletionToken>
-ASIO_NODISCARD inline
-cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>
-cancel_after(const chrono::duration<Rep, Period>& timeout,
-    CompletionToken&& completion_token)
-{
-  return cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>(
-      static_cast<CompletionToken&&>(completion_token),
-      timeout, cancellation_type::terminal);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete before
-/// the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Rep, typename Period, typename CompletionToken>
-ASIO_NODISCARD inline
-cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>
-cancel_after(const chrono::duration<Rep, Period>& timeout,
-    cancellation_type_t cancel_type, CompletionToken&& completion_token)
-{
-  return cancel_after_t<decay_t<CompletionToken>, chrono::steady_clock>(
-      static_cast<CompletionToken&&>(completion_token), timeout, cancel_type);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete before
-/// the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Clock, typename WaitTraits, typename Executor,
-    typename Rep, typename Period, typename CompletionToken>
-ASIO_NODISCARD inline
-cancel_after_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
-cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::duration<Rep, Period>& timeout,
-    CompletionToken&& completion_token)
-{
-  return cancel_after_timer<decay_t<CompletionToken>,
-    Clock, WaitTraits, Executor>(
-      static_cast<CompletionToken&&>(completion_token),
-      timer, timeout, cancellation_type::terminal);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete before
-/// the specified relative timeout has elapsed.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_after, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Clock, typename WaitTraits, typename Executor,
-    typename Rep, typename Period, typename CompletionToken>
-ASIO_NODISCARD inline
-cancel_after_timer<decay_t<CompletionToken>, chrono::steady_clock>
-cancel_after(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::duration<Rep, Period>& timeout,
-    cancellation_type_t cancel_type, CompletionToken&& completion_token)
-{
-  return cancel_after_timer<decay_t<CompletionToken>,
-    Clock, WaitTraits, Executor>(
-      static_cast<CompletionToken&&>(completion_token),
-      timer, timeout, cancel_type);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/cancel_after.hpp"
-
-#endif // ASIO_CANCEL_AFTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_at.hpp
deleted file mode 100644
index 0f57122..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancel_at.hpp
+++ /dev/null
@@ -1,294 +0,0 @@
-//
-// cancel_at.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CANCEL_AT_HPP
-#define ASIO_CANCEL_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/detail/chrono.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/wait_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token adapter that cancels an operation at a given time.
-/**
- * The cancel_at_t class is used to indicate that an asynchronous operation
- * should be cancelled if not complete at the specified absolute time.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>>
-class cancel_at_t
-{
-public:
-  /// Constructor.
-  template <typename T>
-  cancel_at_t(T&& completion_token, const typename Clock::time_point& expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : token_(static_cast<T&&>(completion_token)),
-      expiry_(expiry),
-      cancel_type_(cancel_type)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  typename Clock::time_point expiry_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A @ref completion_token adapter that cancels an operation at a given time.
-/**
- * The cancel_at_timer class is used to indicate that an asynchronous operation
- * should be cancelled if not complete at the specified absolute time.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits = asio::wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class cancel_at_timer
-{
-public:
-  /// Constructor.
-  template <typename T>
-  cancel_at_timer(T&& completion_token,
-      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-      const typename Clock::time_point& expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : token_(static_cast<T&&>(completion_token)),
-      timer_(timer),
-      expiry_(expiry),
-      cancel_type_(cancel_type)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
-  typename Clock::time_point expiry_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A function object type that adapts a @ref completion_token to cancel an
-/// operation at a given time.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Clock, typename WaitTraits = asio::wait_traits<Clock>>
-class partial_cancel_at
-{
-public:
-  /// Constructor that specifies the expiry and cancellation type.
-  explicit partial_cancel_at(const typename Clock::time_point& expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : expiry_(expiry),
-      cancel_type_(cancel_type)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// arguments should be combined into a single tuple argument.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr cancel_at_t<decay_t<CompletionToken>, Clock, WaitTraits>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return cancel_at_t<decay_t<CompletionToken>, Clock, WaitTraits>(
-        static_cast<CompletionToken&&>(completion_token),
-        expiry_, cancel_type_);
-  }
-
-//private:
-  typename Clock::time_point expiry_;
-  cancellation_type_t cancel_type_;
-};
-
-/// A function object type that adapts a @ref completion_token to cancel an
-/// operation at a given time.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-template <typename Clock, typename WaitTraits = asio::wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class partial_cancel_at_timer
-{
-public:
-  /// Constructor that specifies the expiry and cancellation type.
-  explicit partial_cancel_at_timer(
-      basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-      const typename Clock::time_point& expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal)
-    : timer_(timer),
-      expiry_(expiry),
-      cancel_type_(cancel_type)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// arguments should be combined into a single tuple argument.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  cancel_at_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return cancel_at_timer<decay_t<CompletionToken>,
-      Clock, WaitTraits, Executor>(
-        static_cast<CompletionToken&&>(completion_token),
-        timer_, expiry_, cancel_type_);
-  }
-
-//private:
-  basic_waitable_timer<Clock, WaitTraits, Executor>& timer_;
-  typename Clock::time_point expiry_;
-  cancellation_type_t cancel_type_;
-};
-
-/// Create a partial completion token adapter that cancels an operation if not
-/// complete by the specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Clock, typename Duration>
-ASIO_NODISCARD inline partial_cancel_at<Clock>
-cancel_at(const chrono::time_point<Clock, Duration>& expiry,
-    cancellation_type_t cancel_type = cancellation_type::terminal)
-{
-  return partial_cancel_at<Clock>(expiry, cancel_type);
-}
-
-/// Create a partial completion token adapter that cancels an operation if not
-/// complete by the specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename Clock, typename WaitTraits,
-    typename Executor, typename Duration>
-ASIO_NODISCARD inline partial_cancel_at_timer<Clock, WaitTraits, Executor>
-cancel_at(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::time_point<Clock, Duration>& expiry,
-    cancellation_type_t cancel_type = cancellation_type::terminal)
-{
-  return partial_cancel_at_timer<Clock, WaitTraits, Executor>(
-      timer, expiry, cancel_type);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete by the
-/// specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename CompletionToken, typename Clock, typename Duration>
-ASIO_NODISCARD inline cancel_at_t<decay_t<CompletionToken>, Clock>
-cancel_at(const chrono::time_point<Clock, Duration>& expiry,
-    CompletionToken&& completion_token)
-{
-  return cancel_at_t<decay_t<CompletionToken>, Clock>(
-      static_cast<CompletionToken&&>(completion_token),
-      expiry, cancellation_type::terminal);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete by the
-/// specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename CompletionToken, typename Clock, typename Duration>
-ASIO_NODISCARD inline cancel_at_t<decay_t<CompletionToken>, Clock>
-cancel_at(const chrono::time_point<Clock, Duration>& expiry,
-    cancellation_type_t cancel_type, CompletionToken&& completion_token)
-{
-  return cancel_at_t<decay_t<CompletionToken>, Clock>(
-      static_cast<CompletionToken&&>(completion_token), expiry, cancel_type);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete by the
-/// specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename Executor, typename Duration>
-ASIO_NODISCARD inline
-cancel_at_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
-cancel_at(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::time_point<Clock, Duration>& expiry,
-    CompletionToken&& completion_token)
-{
-  return cancel_at_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>(
-      static_cast<CompletionToken&&>(completion_token),
-      timer, expiry, cancellation_type::terminal);
-}
-
-/// Adapt a @ref completion_token to cancel an operation if not complete by the
-/// specified absolute time.
-/**
- * @par Thread Safety
- * When an asynchronous operation is used with cancel_at, a timer async_wait
- * operation is performed in parallel to the main operation. If this parallel
- * async_wait completes first, a cancellation request is emitted to cancel the
- * main operation. Consequently, the application must ensure that the
- * asynchronous operation is performed within an implicit or explicit strand.
- */
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename Executor, typename Duration>
-ASIO_NODISCARD inline
-cancel_at_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>
-cancel_at(basic_waitable_timer<Clock, WaitTraits, Executor>& timer,
-    const chrono::time_point<Clock, Duration>& expiry,
-    cancellation_type_t cancel_type, CompletionToken&& completion_token)
-{
-  return cancel_at_timer<decay_t<CompletionToken>, Clock, WaitTraits, Executor>(
-      static_cast<CompletionToken&&>(completion_token),
-      timer, expiry, cancel_type);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/cancel_at.hpp"
-
-#endif // ASIO_CANCEL_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_signal.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_signal.hpp
deleted file mode 100644
index 43540ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_signal.hpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//
-// cancellation_signal.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CANCELLATION_SIGNAL_HPP
-#define ASIO_CANCELLATION_SIGNAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cassert>
-#include <new>
-#include <utility>
-#include "asio/cancellation_type.hpp"
-#include "asio/detail/cstddef.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class cancellation_handler_base
-{
-public:
-  virtual void call(cancellation_type_t) = 0;
-  virtual std::pair<void*, std::size_t> destroy() noexcept = 0;
-
-protected:
-  ~cancellation_handler_base() {}
-};
-
-template <typename Handler>
-class cancellation_handler
-  : public cancellation_handler_base
-{
-public:
-  template <typename... Args>
-  cancellation_handler(std::size_t size, Args&&... args)
-    : handler_(static_cast<Args&&>(args)...),
-      size_(size)
-  {
-  }
-
-  void call(cancellation_type_t type)
-  {
-    handler_(type);
-  }
-
-  std::pair<void*, std::size_t> destroy() noexcept
-  {
-    std::pair<void*, std::size_t> mem(this, size_);
-    this->cancellation_handler::~cancellation_handler();
-    return mem;
-  }
-
-  Handler& handler() noexcept
-  {
-    return handler_;
-  }
-
-private:
-  ~cancellation_handler()
-  {
-  }
-
-  Handler handler_;
-  std::size_t size_;
-};
-
-} // namespace detail
-
-class cancellation_slot;
-
-/// A cancellation signal with a single slot.
-class cancellation_signal
-{
-public:
-  constexpr cancellation_signal()
-    : handler_(0)
-  {
-  }
-
-  ASIO_DECL ~cancellation_signal();
-
-  /// Emits the signal and causes invocation of the slot's handler, if any.
-  void emit(cancellation_type_t type)
-  {
-    if (handler_)
-      handler_->call(type);
-  }
-
-  /// Returns the single slot associated with the signal.
-  /**
-   * The signal object must remain valid for as long the slot may be used.
-   * Destruction of the signal invalidates the slot.
-   */
-  cancellation_slot slot() noexcept;
-
-private:
-  cancellation_signal(const cancellation_signal&) = delete;
-  cancellation_signal& operator=(const cancellation_signal&) = delete;
-
-  detail::cancellation_handler_base* handler_;
-};
-
-/// A slot associated with a cancellation signal.
-class cancellation_slot
-{
-public:
-  /// Creates a slot that is not connected to any cancellation signal.
-  constexpr cancellation_slot()
-    : handler_(0)
-  {
-  }
-
-  /// Installs a handler into the slot, constructing the new object directly.
-  /**
-   * Destroys any existing handler in the slot, then installs the new handler,
-   * constructing it with the supplied @c args.
-   *
-   * The handler is a function object to be called when the signal is emitted.
-   * The signature of the handler must be
-   * @code void handler(asio::cancellation_type_t); @endcode
-   *
-   * @param args Arguments to be passed to the @c CancellationHandler object's
-   * constructor.
-   *
-   * @returns A reference to the newly installed handler.
-   *
-   * @note Handlers installed into the slot via @c emplace are not required to
-   * be copy constructible or move constructible.
-   */
-  template <typename CancellationHandler, typename... Args>
-  CancellationHandler& emplace(Args&&... args)
-  {
-    typedef detail::cancellation_handler<CancellationHandler>
-      cancellation_handler_type;
-    auto_delete_helper del = { prepare_memory(
-        sizeof(cancellation_handler_type),
-        alignof(CancellationHandler)) };
-    cancellation_handler_type* handler_obj =
-      new (del.mem.first) cancellation_handler_type(
-        del.mem.second, static_cast<Args&&>(args)...);
-    del.mem.first = 0;
-    *handler_ = handler_obj;
-    return handler_obj->handler();
-  }
-
-  /// Installs a handler into the slot.
-  /**
-   * Destroys any existing handler in the slot, then installs the new handler,
-   * constructing it as a decay-copy of the supplied handler.
-   *
-   * The handler is a function object to be called when the signal is emitted.
-   * The signature of the handler must be
-   * @code void handler(asio::cancellation_type_t); @endcode
-   *
-   * @param handler The handler to be installed.
-   *
-   * @returns A reference to the newly installed handler.
-   */
-  template <typename CancellationHandler>
-  decay_t<CancellationHandler>& assign(CancellationHandler&& handler)
-  {
-    return this->emplace<decay_t<CancellationHandler>>(
-        static_cast<CancellationHandler&&>(handler));
-  }
-
-  /// Clears the slot.
-  /**
-   * Destroys any existing handler in the slot.
-   */
-  ASIO_DECL void clear();
-
-  /// Returns whether the slot is connected to a signal.
-  constexpr bool is_connected() const noexcept
-  {
-    return handler_ != 0;
-  }
-
-  /// Returns whether the slot is connected and has an installed handler.
-  constexpr bool has_handler() const noexcept
-  {
-    return handler_ != 0 && *handler_ != 0;
-  }
-
-  /// Compare two slots for equality.
-  friend constexpr bool operator==(const cancellation_slot& lhs,
-      const cancellation_slot& rhs) noexcept
-  {
-    return lhs.handler_ == rhs.handler_;
-  }
-
-  /// Compare two slots for inequality.
-  friend constexpr bool operator!=(const cancellation_slot& lhs,
-      const cancellation_slot& rhs) noexcept
-  {
-    return lhs.handler_ != rhs.handler_;
-  }
-
-private:
-  friend class cancellation_signal;
-
-  constexpr cancellation_slot(int,
-      detail::cancellation_handler_base** handler)
-    : handler_(handler)
-  {
-  }
-
-  ASIO_DECL std::pair<void*, std::size_t> prepare_memory(
-      std::size_t size, std::size_t align);
-
-  struct auto_delete_helper
-  {
-    std::pair<void*, std::size_t> mem;
-
-    ASIO_DECL ~auto_delete_helper();
-  };
-
-  detail::cancellation_handler_base** handler_;
-};
-
-inline cancellation_slot cancellation_signal::slot() noexcept
-{
-  return cancellation_slot(0, &handler_);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/cancellation_signal.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_CANCELLATION_SIGNAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_state.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_state.hpp
deleted file mode 100644
index 3c13edc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_state.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-//
-// cancellation_state.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CANCELLATION_STATE_HPP
-#define ASIO_CANCELLATION_STATE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cassert>
-#include <new>
-#include <utility>
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/cstddef.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A simple cancellation signal propagation filter.
-template <cancellation_type_t Mask>
-struct cancellation_filter
-{
-  /// Returns <tt>type & Mask</tt>.
-  cancellation_type_t operator()(
-      cancellation_type_t type) const noexcept
-  {
-    return type & Mask;
-  }
-};
-
-/// A cancellation filter that disables cancellation.
-typedef cancellation_filter<cancellation_type::none>
-  disable_cancellation;
-
-/// A cancellation filter that enables terminal cancellation only.
-typedef cancellation_filter<cancellation_type::terminal>
-  enable_terminal_cancellation;
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// A cancellation filter that enables terminal and partial cancellation.
-typedef cancellation_filter<
-    cancellation_type::terminal | cancellation_type::partial>
-  enable_partial_cancellation;
-
-/// A cancellation filter that enables terminal, partial and total cancellation.
-typedef cancellation_filter<cancellation_type::terminal
-    | cancellation_type::partial | cancellation_type::total>
-  enable_total_cancellation;
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-typedef cancellation_filter<
-    static_cast<cancellation_type_t>(
-      static_cast<unsigned int>(cancellation_type::terminal)
-        | static_cast<unsigned int>(cancellation_type::partial))>
-  enable_partial_cancellation;
-
-typedef cancellation_filter<
-    static_cast<cancellation_type_t>(
-      static_cast<unsigned int>(cancellation_type::terminal)
-        | static_cast<unsigned int>(cancellation_type::partial)
-        | static_cast<unsigned int>(cancellation_type::total))>
-  enable_total_cancellation;
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-/// A cancellation state is used for chaining signals and slots in compositions.
-class cancellation_state
-{
-public:
-  /// Construct a disconnected cancellation state.
-  constexpr cancellation_state() noexcept
-    : impl_(0)
-  {
-  }
-
-  /// Construct and attach to a parent slot to create a new child slot.
-  /**
-   * Initialises the cancellation state so that it allows terminal cancellation
-   * only. Equivalent to <tt>cancellation_state(slot,
-   * enable_terminal_cancellation())</tt>.
-   *
-   * @param slot The parent cancellation slot to which the state will be
-   * attached.
-   */
-  template <typename CancellationSlot>
-  constexpr explicit cancellation_state(CancellationSlot slot)
-    : impl_(slot.is_connected() ? &slot.template emplace<impl<>>() : 0)
-  {
-  }
-
-  /// Construct and attach to a parent slot to create a new child slot.
-  /**
-   * @param slot The parent cancellation slot to which the state will be
-   * attached.
-   *
-   * @param filter A function object that is used to transform incoming
-   * cancellation signals as they are received from the parent slot. This
-   * function object must have the signature:
-   * @code asio::cancellation_type_t filter(
-   *     asio::cancellation_type_t); @endcode
-   *
-   * The library provides the following pre-defined cancellation filters:
-   *
-   * @li asio::disable_cancellation
-   * @li asio::enable_terminal_cancellation
-   * @li asio::enable_partial_cancellation
-   * @li asio::enable_total_cancellation
-   */
-  template <typename CancellationSlot, typename Filter>
-  constexpr cancellation_state(CancellationSlot slot, Filter filter)
-    : impl_(slot.is_connected()
-        ? &slot.template emplace<impl<Filter, Filter>>(filter, filter)
-        : 0)
-  {
-  }
-
-  /// Construct and attach to a parent slot to create a new child slot.
-  /**
-   * @param slot The parent cancellation slot to which the state will be
-   * attached.
-   *
-   * @param in_filter A function object that is used to transform incoming
-   * cancellation signals as they are received from the parent slot. This
-   * function object must have the signature:
-   * @code asio::cancellation_type_t in_filter(
-   *     asio::cancellation_type_t); @endcode
-   *
-   * @param out_filter A function object that is used to transform outcoming
-   * cancellation signals as they are relayed to the child slot. This function
-   * object must have the signature:
-   * @code asio::cancellation_type_t out_filter(
-   *     asio::cancellation_type_t); @endcode
-   *
-   * The library provides the following pre-defined cancellation filters:
-   *
-   * @li asio::disable_cancellation
-   * @li asio::enable_terminal_cancellation
-   * @li asio::enable_partial_cancellation
-   * @li asio::enable_total_cancellation
-   */
-  template <typename CancellationSlot, typename InFilter, typename OutFilter>
-  constexpr cancellation_state(CancellationSlot slot,
-      InFilter in_filter, OutFilter out_filter)
-    : impl_(slot.is_connected()
-        ? &slot.template emplace<impl<InFilter, OutFilter>>(
-            static_cast<InFilter&&>(in_filter),
-            static_cast<OutFilter&&>(out_filter))
-        : 0)
-  {
-  }
-
-  /// Returns the single child slot associated with the state.
-  /**
-   * This sub-slot is used with the operations that are being composed.
-   */
-  constexpr cancellation_slot slot() const noexcept
-  {
-    return impl_ ? impl_->signal_.slot() : cancellation_slot();
-  }
-
-  /// Returns the cancellation types that have been triggered.
-  cancellation_type_t cancelled() const noexcept
-  {
-    return impl_ ? impl_->cancelled_ : cancellation_type_t();
-  }
-
-  /// Clears the specified cancellation types, if they have been triggered.
-  void clear(cancellation_type_t mask = cancellation_type::all)
-    noexcept
-  {
-    if (impl_)
-      impl_->cancelled_ &= ~mask;
-  }
-
-private:
-  struct impl_base
-  {
-    impl_base()
-      : cancelled_()
-    {
-    }
-
-    cancellation_signal signal_;
-    cancellation_type_t cancelled_;
-  };
-
-  template <
-      typename InFilter = enable_terminal_cancellation,
-      typename OutFilter = InFilter>
-  struct impl : impl_base
-  {
-    impl()
-      : in_filter_(),
-        out_filter_()
-    {
-    }
-
-    impl(InFilter in_filter, OutFilter out_filter)
-      : in_filter_(static_cast<InFilter&&>(in_filter)),
-        out_filter_(static_cast<OutFilter&&>(out_filter))
-    {
-    }
-
-    void operator()(cancellation_type_t in)
-    {
-      this->cancelled_ = in_filter_(in);
-      cancellation_type_t out = out_filter_(this->cancelled_);
-      if (out != cancellation_type::none)
-        this->signal_.emit(out);
-    }
-
-    InFilter in_filter_;
-    OutFilter out_filter_;
-  };
-
-  impl_base* impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_CANCELLATION_STATE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_type.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_type.hpp
deleted file mode 100644
index ec4a4d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/cancellation_type.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//
-// cancellation_type.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CANCELLATION_TYPE_HPP
-#define ASIO_CANCELLATION_TYPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-# if defined(GENERATING_DOCUMENTATION)
-
-/// Enumeration representing the different types of cancellation that may
-/// be requested from or implemented by an asynchronous operation.
-enum cancellation_type
-{
-  /// Bitmask representing no types of cancellation.
-  none = 0,
-
-  /// Requests cancellation where, following a successful cancellation, the only
-  /// safe operations on the I/O object are closure or destruction.
-  terminal = 1,
-
-  /// Requests cancellation where a successful cancellation may result in
-  /// partial side effects or no side effects. Following cancellation, the I/O
-  /// object is in a well-known state, and may be used for further operations.
-  partial = 2,
-
-  /// Requests cancellation where a successful cancellation results in no
-  /// apparent side effects. Following cancellation, the I/O object is in the
-  /// same observable state as it was prior to the operation.
-  total = 4,
-
-  /// Bitmask representing all types of cancellation.
-  all = 0xFFFFFFFF
-};
-
-/// Portability typedef.
-typedef cancellation_type cancellation_type_t;
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-enum class cancellation_type : unsigned int
-{
-  none = 0,
-  terminal = 1,
-  partial = 2,
-  total = 4,
-  all = 0xFFFFFFFF
-};
-
-typedef cancellation_type cancellation_type_t;
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-/// Negation operator.
-/**
- * @relates cancellation_type
- */
-inline constexpr bool operator!(cancellation_type_t x)
-{
-  return static_cast<unsigned int>(x) == 0;
-}
-
-/// Bitwise and operator.
-/**
- * @relates cancellation_type
- */
-inline constexpr cancellation_type_t operator&(
-    cancellation_type_t x, cancellation_type_t y)
-{
-  return static_cast<cancellation_type_t>(
-      static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
-}
-
-/// Bitwise or operator.
-/**
- * @relates cancellation_type
- */
-inline constexpr cancellation_type_t operator|(
-    cancellation_type_t x, cancellation_type_t y)
-{
-  return static_cast<cancellation_type_t>(
-      static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
-}
-
-/// Bitwise xor operator.
-/**
- * @relates cancellation_type
- */
-inline constexpr cancellation_type_t operator^(
-    cancellation_type_t x, cancellation_type_t y)
-{
-  return static_cast<cancellation_type_t>(
-      static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
-}
-
-/// Bitwise negation operator.
-/**
- * @relates cancellation_type
- */
-inline constexpr cancellation_type_t operator~(cancellation_type_t x)
-{
-  return static_cast<cancellation_type_t>(~static_cast<unsigned int>(x));
-}
-
-/// Bitwise and-assignment operator.
-/**
- * @relates cancellation_type
- */
-inline cancellation_type_t& operator&=(
-    cancellation_type_t& x, cancellation_type_t y)
-{
-  x = x & y;
-  return x;
-}
-
-/// Bitwise or-assignment operator.
-/**
- * @relates cancellation_type
- */
-inline cancellation_type_t& operator|=(
-    cancellation_type_t& x, cancellation_type_t y)
-{
-  x = x | y;
-  return x;
-}
-
-/// Bitwise xor-assignment operator.
-/**
- * @relates cancellation_type
- */
-inline cancellation_type_t& operator^=(
-    cancellation_type_t& x, cancellation_type_t y)
-{
-  x = x ^ y;
-  return x;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_CANCELLATION_TYPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_composed.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_composed.hpp
deleted file mode 100644
index 71c1404..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_composed.hpp
+++ /dev/null
@@ -1,1319 +0,0 @@
-//
-// co_composed.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CO_COMPOSED_HPP
-#define ASIO_CO_COMPOSED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#include <new>
-#include <tuple>
-#include <variant>
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/detail/composed_work.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-# include <coroutine>
-#else // defined(ASIO_HAS_STD_COROUTINE)
-# include <experimental/coroutine>
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-#  include "asio/detail/source_location.hpp"
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-using std::coroutine_handle;
-using std::suspend_always;
-using std::suspend_never;
-#else // defined(ASIO_HAS_STD_COROUTINE)
-using std::experimental::coroutine_handle;
-using std::experimental::suspend_always;
-using std::experimental::suspend_never;
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-using asio::detail::composed_io_executors;
-using asio::detail::composed_work;
-using asio::detail::composed_work_guard;
-using asio::detail::get_composed_io_executor;
-using asio::detail::make_composed_io_executors;
-using asio::detail::recycling_allocator;
-using asio::detail::throw_error;
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_state;
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_handler_base;
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_promise;
-
-template <ASIO_COMPLETION_SIGNATURE... Signatures>
-class co_composed_returns
-{
-};
-
-struct co_composed_on_suspend
-{
-  void (*fn_)(void*) = nullptr;
-  void* arg_ = nullptr;
-};
-
-template <typename... T>
-struct co_composed_completion : std::tuple<T&&...>
-{
-  template <typename... U>
-  co_composed_completion(U&&... u) noexcept
-    : std::tuple<T&&...>(static_cast<U&&>(u)...)
-  {
-  }
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename Signature>
-class co_composed_state_return_overload;
-
-template <typename Executors, typename Handler,
-    typename Return, typename R, typename... Args>
-class co_composed_state_return_overload<
-    Executors, Handler, Return, R(Args...)>
-{
-public:
-  using derived_type = co_composed_state<Executors, Handler, Return>;
-  using promise_type = co_composed_promise<Executors, Handler, Return>;
-  using return_type = std::tuple<Args...>;
-
-  void on_cancellation_complete_with(Args... args)
-  {
-    derived_type& state = *static_cast<derived_type*>(this);
-    state.return_value_ = std::make_tuple(std::move(args)...);
-    state.cancellation_on_suspend_fn(
-        [](void* p)
-        {
-          auto& promise = *static_cast<promise_type*>(p);
-
-          co_composed_handler_base<Executors, Handler,
-            Return> composed_handler(promise);
-
-          Handler handler(std::move(promise.state().handler_));
-          return_type result(
-              std::move(std::get<return_type>(promise.state().return_value_)));
-
-          co_composed_handler_base<Executors, Handler,
-            Return>(std::move(composed_handler));
-
-          std::apply(std::move(handler), std::move(result));
-        });
-  }
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_state_return;
-
-template <typename Executors, typename Handler, typename... Signatures>
-class co_composed_state_return<
-    Executors, Handler, co_composed_returns<Signatures...>>
-  : public co_composed_state_return_overload<Executors,
-      Handler, co_composed_returns<Signatures...>, Signatures>...
-{
-public:
-  using co_composed_state_return_overload<Executors,
-    Handler, co_composed_returns<Signatures...>,
-      Signatures>::on_cancellation_complete_with...;
-
-private:
-  template <typename, typename, typename, typename>
-    friend class co_composed_promise_return_overload;
-  template <typename, typename, typename, typename>
-    friend class co_composed_state_return_overload;
-
-  std::variant<std::monostate,
-    typename co_composed_state_return_overload<
-      Executors, Handler, co_composed_returns<Signatures...>,
-        Signatures>::return_type...> return_value_;
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename... Signatures>
-struct co_composed_state_default_cancellation_on_suspend_impl;
-
-template <typename Executors, typename Handler, typename Return>
-struct co_composed_state_default_cancellation_on_suspend_impl<
-    Executors, Handler, Return>
-{
-  static constexpr void (*fn())(void*)
-  {
-    return nullptr;
-  }
-};
-
-template <typename Executors, typename Handler, typename Return,
-    typename R, typename... Args, typename... Signatures>
-struct co_composed_state_default_cancellation_on_suspend_impl<
-    Executors, Handler, Return, R(Args...), Signatures...>
-{
-  static constexpr void (*fn())(void*)
-  {
-    return co_composed_state_default_cancellation_on_suspend_impl<
-      Executors, Handler, Return, Signatures...>::fn();
-  }
-};
-
-template <typename Executors, typename Handler, typename Return,
-    typename R, typename... Args, typename... Signatures>
-struct co_composed_state_default_cancellation_on_suspend_impl<Executors,
-    Handler, Return, R(asio::error_code, Args...), Signatures...>
-{
-  using promise_type = co_composed_promise<Executors, Handler, Return>;
-  using return_type = std::tuple<asio::error_code, Args...>;
-
-  static constexpr void (*fn())(void*)
-  {
-    if constexpr ((is_constructible<Args>::value && ...))
-    {
-      return [](void* p)
-      {
-        auto& promise = *static_cast<promise_type*>(p);
-
-        co_composed_handler_base<Executors, Handler,
-          Return> composed_handler(promise);
-
-        Handler handler(std::move(promise.state().handler_));
-
-        co_composed_handler_base<Executors, Handler,
-          Return>(std::move(composed_handler));
-
-        std::move(handler)(
-            asio::error_code(asio::error::operation_aborted),
-            Args{}...);
-      };
-    }
-    else
-    {
-      return co_composed_state_default_cancellation_on_suspend_impl<
-        Executors, Handler, Return, Signatures...>::fn();
-    }
-  }
-};
-
-template <typename Executors, typename Handler, typename Return,
-    typename R, typename... Args, typename... Signatures>
-struct co_composed_state_default_cancellation_on_suspend_impl<Executors,
-    Handler, Return, R(std::exception_ptr, Args...), Signatures...>
-{
-  using promise_type = co_composed_promise<Executors, Handler, Return>;
-  using return_type = std::tuple<std::exception_ptr, Args...>;
-
-  static constexpr void (*fn())(void*)
-  {
-    if constexpr ((is_constructible<Args>::value && ...))
-    {
-      return [](void* p)
-      {
-        auto& promise = *static_cast<promise_type*>(p);
-
-        co_composed_handler_base<Executors, Handler,
-          Return> composed_handler(promise);
-
-        Handler handler(std::move(promise.state().handler_));
-
-        co_composed_handler_base<Executors, Handler,
-          Return>(std::move(composed_handler));
-
-        std::move(handler)(
-            std::make_exception_ptr(
-              asio::system_error(
-                asio::error::operation_aborted, "co_await")),
-            Args{}...);
-      };
-    }
-    else
-    {
-      return co_composed_state_default_cancellation_on_suspend_impl<
-        Executors, Handler, Return, Signatures...>::fn();
-    }
-  }
-};
-
-template <typename Executors, typename Handler, typename Return>
-struct co_composed_state_default_cancellation_on_suspend;
-
-template <typename Executors, typename Handler, typename... Signatures>
-struct co_composed_state_default_cancellation_on_suspend<
-    Executors, Handler, co_composed_returns<Signatures...>>
-  : co_composed_state_default_cancellation_on_suspend_impl<Executors,
-      Handler, co_composed_returns<Signatures...>, Signatures...>
-{
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_state_cancellation
-{
-public:
-  using cancellation_slot_type = cancellation_slot;
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancellation_state_.slot();
-  }
-
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return cancellation_state_;
-  }
-
-  void reset_cancellation_state()
-  {
-    cancellation_state_ = cancellation_state(
-        (get_associated_cancellation_slot)(
-          static_cast<co_composed_state<Executors, Handler, Return>*>(
-            this)->handler()));
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter filter)
-  {
-    cancellation_state_ = cancellation_state(
-        (get_associated_cancellation_slot)(
-          static_cast<co_composed_state<Executors, Handler, Return>*>(
-            this)->handler()), filter, filter);
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter, OutFilter&& out_filter)
-  {
-    cancellation_state_ = cancellation_state(
-        (get_associated_cancellation_slot)(
-          static_cast<co_composed_state<Executors, Handler, Return>*>(
-            this)->handler()),
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return cancellation_state_.cancelled();
-  }
-
-  void clear_cancellation_slot() noexcept
-  {
-    cancellation_state_.slot().clear();
-  }
-
-  [[nodiscard]] bool throw_if_cancelled() const noexcept
-  {
-    return throw_if_cancelled_;
-  }
-
-  void throw_if_cancelled(bool b) noexcept
-  {
-    throw_if_cancelled_ = b;
-  }
-
-  [[nodiscard]] bool complete_if_cancelled() const noexcept
-  {
-    return complete_if_cancelled_;
-  }
-
-  void complete_if_cancelled(bool b) noexcept
-  {
-    complete_if_cancelled_ = b;
-  }
-
-private:
-  template <typename, typename, typename>
-    friend class co_composed_promise;
-  template <typename, typename, typename, typename>
-    friend class co_composed_state_return_overload;
-
-  void cancellation_on_suspend_fn(void (*fn)(void*))
-  {
-    cancellation_on_suspend_fn_ = fn;
-  }
-
-  void check_for_cancellation_on_transform()
-  {
-    if (throw_if_cancelled_ && !!cancelled())
-      throw_error(asio::error::operation_aborted, "co_await");
-  }
-
-  bool check_for_cancellation_on_suspend(
-      co_composed_promise<Executors, Handler, Return>& promise) noexcept
-  {
-    if (complete_if_cancelled_ && !!cancelled() && cancellation_on_suspend_fn_)
-    {
-      promise.state().work_.reset();
-      promise.state().on_suspend_->fn_ = cancellation_on_suspend_fn_;
-      promise.state().on_suspend_->arg_ = &promise;
-      return false;
-    }
-    return true;
-  }
-
-  cancellation_state cancellation_state_;
-  void (*cancellation_on_suspend_fn_)(void*) =
-    co_composed_state_default_cancellation_on_suspend<
-      Executors, Handler, Return>::fn();
-  bool throw_if_cancelled_ = false;
-  bool complete_if_cancelled_ = true;
-};
-
-template <typename Executors, typename Handler, typename Return>
-  requires is_same<
-    typename associated_cancellation_slot<
-      Handler, cancellation_slot
-    >::asio_associated_cancellation_slot_is_unspecialised,
-    void>::value
-class co_composed_state_cancellation<Executors, Handler, Return>
-{
-public:
-  void reset_cancellation_state()
-  {
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter)
-  {
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&&, OutFilter&&)
-  {
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return cancellation_type::none;
-  }
-
-  void clear_cancellation_slot() noexcept
-  {
-  }
-
-  [[nodiscard]] bool throw_if_cancelled() const noexcept
-  {
-    return false;
-  }
-
-  void throw_if_cancelled(bool) noexcept
-  {
-  }
-
-  [[nodiscard]] bool complete_if_cancelled() const noexcept
-  {
-    return false;
-  }
-
-  void complete_if_cancelled(bool) noexcept
-  {
-  }
-
-private:
-  template <typename, typename, typename>
-    friend class co_composed_promise;
-  template <typename, typename, typename, typename>
-    friend class co_composed_state_return_overload;
-
-  void cancellation_on_suspend_fn(void (*)(void*))
-  {
-  }
-
-  void check_for_cancellation_on_transform() noexcept
-  {
-  }
-
-  bool check_for_cancellation_on_suspend(
-      co_composed_promise<Executors, Handler, Return>&) noexcept
-  {
-    return true;
-  }
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_state
-  : public co_composed_state_return<Executors, Handler, Return>,
-    public co_composed_state_cancellation<Executors, Handler, Return>
-{
-public:
-  using io_executor_type = typename composed_work_guard<
-    typename composed_work<Executors>::head_type>::executor_type;
-
-  template <typename H>
-  co_composed_state(composed_io_executors<Executors>&& executors,
-      H&& h, co_composed_on_suspend& on_suspend)
-    : work_(std::move(executors)),
-      handler_(static_cast<H&&>(h)),
-      on_suspend_(&on_suspend)
-  {
-    this->reset_cancellation_state(enable_terminal_cancellation());
-  }
-
-  io_executor_type get_io_executor() const noexcept
-  {
-    return work_.head_.get_executor();
-  }
-
-  template <typename... Args>
-  [[nodiscard]] co_composed_completion<Args...> complete(Args&&... args)
-    requires requires { declval<Handler>()(static_cast<Args&&>(args)...); }
-  {
-    return co_composed_completion<Args...>(static_cast<Args&&>(args)...);
-  }
-
-  const Handler& handler() const noexcept
-  {
-    return handler_;
-  }
-
-private:
-  template <typename, typename, typename>
-    friend class co_composed_handler_base;
-  template <typename, typename, typename>
-    friend class co_composed_promise;
-  template <typename, typename, typename, typename>
-    friend class co_composed_promise_return_overload;
-  template <typename, typename, typename>
-    friend class co_composed_state_cancellation;
-  template <typename, typename, typename, typename>
-    friend class co_composed_state_return_overload;
-  template <typename, typename, typename, typename...>
-    friend struct co_composed_state_default_cancellation_on_suspend_impl;
-
-  composed_work<Executors> work_;
-  Handler handler_;
-  co_composed_on_suspend* on_suspend_;
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_handler_cancellation
-{
-public:
-  using cancellation_slot_type = cancellation_slot;
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return static_cast<
-      const co_composed_handler_base<Executors, Handler, Return>*>(
-        this)->promise().state().get_cancellation_slot();
-  }
-};
-
-template <typename Executors, typename Handler, typename Return>
-  requires is_same<
-    typename associated_cancellation_slot<
-      Handler, cancellation_slot
-    >::asio_associated_cancellation_slot_is_unspecialised,
-    void>::value
-class co_composed_handler_cancellation<Executors, Handler, Return>
-{
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_handler_base :
-  public co_composed_handler_cancellation<Executors, Handler, Return>
-{
-public:
-  co_composed_handler_base(
-      co_composed_promise<Executors, Handler, Return>& p) noexcept
-    : p_(&p)
-  {
-  }
-
-  co_composed_handler_base(co_composed_handler_base&& other) noexcept
-    : p_(std::exchange(other.p_, nullptr))
-  {
-  }
-
-  ~co_composed_handler_base()
-  {
-    if (p_) [[unlikely]]
-      p_->destroy();
-  }
-
-  co_composed_promise<Executors, Handler, Return>& promise() const noexcept
-  {
-    return *p_;
-  }
-
-protected:
-  void resume(void* result)
-  {
-    co_composed_on_suspend on_suspend{};
-    std::exchange(p_, nullptr)->resume(p_, result, on_suspend);
-    if (on_suspend.fn_)
-      on_suspend.fn_(on_suspend.arg_);
-  }
-
-private:
-  co_composed_promise<Executors, Handler, Return>* p_;
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename Signature>
-class co_composed_handler;
-
-template <typename Executors, typename Handler,
-    typename Return, typename R, typename... Args>
-class co_composed_handler<Executors, Handler, Return, R(Args...)>
-  : public co_composed_handler_base<Executors, Handler, Return>
-{
-public:
-  using co_composed_handler_base<Executors,
-    Handler, Return>::co_composed_handler_base;
-
-  using result_type = std::tuple<decay_t<Args>...>;
-
-  template <typename... T>
-  void operator()(T&&... args)
-  {
-    result_type result(static_cast<T&&>(args)...);
-    this->resume(&result);
-  }
-
-  static auto on_resume(void* result)
-  {
-    auto& args = *static_cast<result_type*>(result);
-    if constexpr (sizeof...(Args) == 0)
-      return;
-    else if constexpr (sizeof...(Args) == 1)
-      return std::move(std::get<0>(args));
-    else
-      return std::move(args);
-  }
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename R, typename... Args>
-class co_composed_handler<Executors, Handler,
-    Return, R(asio::error_code, Args...)>
-  : public co_composed_handler_base<Executors, Handler, Return>
-{
-public:
-  using co_composed_handler_base<Executors,
-    Handler, Return>::co_composed_handler_base;
-
-  using args_type = std::tuple<decay_t<Args>...>;
-  using result_type = std::tuple<asio::error_code, args_type>;
-
-  template <typename... T>
-  void operator()(const asio::error_code& ec, T&&... args)
-  {
-    result_type result(ec, args_type(static_cast<T&&>(args)...));
-    this->resume(&result);
-  }
-
-  static auto on_resume(void* result)
-  {
-    auto& [ec, args] = *static_cast<result_type*>(result);
-    throw_error(ec);
-    if constexpr (sizeof...(Args) == 0)
-      return;
-    else if constexpr (sizeof...(Args) == 1)
-      return std::move(std::get<0>(args));
-    else
-      return std::move(args);
-  }
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename R, typename... Args>
-class co_composed_handler<Executors, Handler,
-    Return, R(std::exception_ptr, Args...)>
-  : public co_composed_handler_base<Executors, Handler, Return>
-{
-public:
-  using co_composed_handler_base<Executors,
-    Handler, Return>::co_composed_handler_base;
-
-  using args_type = std::tuple<decay_t<Args>...>;
-  using result_type = std::tuple<std::exception_ptr, args_type>;
-
-  template <typename... T>
-  void operator()(std::exception_ptr ex, T&&... args)
-  {
-    result_type result(std::move(ex), args_type(static_cast<T&&>(args)...));
-    this->resume(&result);
-  }
-
-  static auto on_resume(void* result)
-  {
-    auto& [ex, args] = *static_cast<result_type*>(result);
-    if (ex)
-      std::rethrow_exception(ex);
-    if constexpr (sizeof...(Args) == 0)
-      return;
-    else if constexpr (sizeof...(Args) == 1)
-      return std::move(std::get<0>(args));
-    else
-      return std::move(args);
-  }
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_promise_return;
-
-template <typename Executors, typename Handler>
-class co_composed_promise_return<Executors, Handler, co_composed_returns<>>
-{
-public:
-  auto final_suspend() noexcept
-  {
-    return suspend_never();
-  }
-
-  void return_void() noexcept
-  {
-  }
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename Signature>
-class co_composed_promise_return_overload;
-
-template <typename Executors, typename Handler,
-    typename Return, typename R, typename... Args>
-class co_composed_promise_return_overload<
-    Executors, Handler, Return, R(Args...)>
-{
-public:
-  using derived_type = co_composed_promise<Executors, Handler, Return>;
-  using return_type = std::tuple<Args...>;
-
-  void return_value(std::tuple<Args...>&& value)
-  {
-    derived_type& promise = *static_cast<derived_type*>(this);
-    promise.state().return_value_ = std::move(value);
-    promise.state().work_.reset();
-    promise.state().on_suspend_->arg_ = this;
-    promise.state().on_suspend_->fn_ =
-      [](void* p)
-      {
-        auto& promise = *static_cast<derived_type*>(p);
-
-        co_composed_handler_base<Executors, Handler,
-          Return> composed_handler(promise);
-
-        Handler handler(std::move(promise.state().handler_));
-        return_type result(
-            std::move(std::get<return_type>(promise.state().return_value_)));
-
-        co_composed_handler_base<Executors, Handler,
-          Return>(std::move(composed_handler));
-
-        std::apply(std::move(handler), std::move(result));
-      };
-  }
-};
-
-template <typename Executors, typename Handler, typename... Signatures>
-class co_composed_promise_return<Executors,
-    Handler, co_composed_returns<Signatures...>>
-  : public co_composed_promise_return_overload<Executors,
-      Handler, co_composed_returns<Signatures...>, Signatures>...
-{
-public:
-  auto final_suspend() noexcept
-  {
-    return suspend_always();
-  }
-
-  using co_composed_promise_return_overload<Executors, Handler,
-    co_composed_returns<Signatures...>, Signatures>::return_value...;
-
-private:
-  template <typename, typename, typename, typename>
-    friend class co_composed_promise_return_overload;
-};
-
-template <typename Executors, typename Handler, typename Return>
-class co_composed_promise
-  : public co_composed_promise_return<Executors, Handler, Return>
-{
-public:
-  template <typename... Args>
-  void* operator new(std::size_t size,
-      co_composed_state<Executors, Handler, Return>& state, Args&&...)
-  {
-    block_allocator_type allocator(
-      (get_associated_allocator)(state.handler_,
-        recycling_allocator<void>()));
-
-    block* base_ptr = std::allocator_traits<block_allocator_type>::allocate(
-        allocator, blocks(sizeof(allocator_type)) + blocks(size));
-
-    new (static_cast<void*>(base_ptr)) allocator_type(std::move(allocator));
-
-    return base_ptr + blocks(sizeof(allocator_type));
-  }
-
-  template <typename C, typename... Args>
-  void* operator new(std::size_t size, C&&,
-      co_composed_state<Executors, Handler, Return>& state, Args&&...)
-  {
-    return co_composed_promise::operator new(size, state);
-  }
-
-  void operator delete(void* ptr, std::size_t size)
-  {
-    block* base_ptr = static_cast<block*>(ptr) - blocks(sizeof(allocator_type));
-
-    allocator_type* allocator_ptr = std::launder(
-        static_cast<allocator_type*>(static_cast<void*>(base_ptr)));
-
-    block_allocator_type block_allocator(std::move(*allocator_ptr));
-    allocator_ptr->~allocator_type();
-
-    std::allocator_traits<block_allocator_type>::deallocate(block_allocator,
-        base_ptr, blocks(sizeof(allocator_type)) + blocks(size));
-  }
-
-  template <typename... Args>
-  co_composed_promise(
-      co_composed_state<Executors, Handler, Return>& state, Args&&...)
-    : state_(state)
-  {
-  }
-
-  template <typename C, typename... Args>
-  co_composed_promise(C&&,
-      co_composed_state<Executors, Handler, Return>& state, Args&&...)
-    : state_(state)
-  {
-  }
-
-  void destroy() noexcept
-  {
-    coroutine_handle<co_composed_promise>::from_promise(*this).destroy();
-  }
-
-  void resume(co_composed_promise*& owner, void* result,
-      co_composed_on_suspend& on_suspend)
-  {
-    state_.on_suspend_ = &on_suspend;
-    state_.clear_cancellation_slot();
-    owner_ = &owner;
-    result_ = result;
-    coroutine_handle<co_composed_promise>::from_promise(*this).resume();
-  }
-
-  co_composed_state<Executors, Handler, Return>& state() noexcept
-  {
-    return state_;
-  }
-
-  void get_return_object() noexcept
-  {
-  }
-
-  auto initial_suspend() noexcept
-  {
-    return suspend_never();
-  }
-
-  void unhandled_exception()
-  {
-    if (owner_)
-      *owner_ = this;
-    throw;
-  }
-
-  template <async_operation Op>
-  auto await_transform(Op&& op
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      , asio::detail::source_location location
-        = asio::detail::source_location::current()
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    )
-  {
-    class [[nodiscard]] awaitable
-    {
-    public:
-      awaitable(Op&& op, co_composed_promise& promise
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-          , const asio::detail::source_location& location
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-        )
-        : op_(static_cast<Op&&>(op)),
-          promise_(promise)
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-        , location_(location)
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-      {
-      }
-
-      constexpr bool await_ready() const noexcept
-      {
-        return false;
-      }
-
-      void await_suspend(coroutine_handle<co_composed_promise>)
-      {
-        if (promise_.state_.check_for_cancellation_on_suspend(promise_))
-        {
-          promise_.state_.on_suspend_->arg_ = this;
-          promise_.state_.on_suspend_->fn_ =
-            [](void* p)
-            {
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-              ASIO_HANDLER_LOCATION((
-                  static_cast<awaitable*>(p)->location_.file_name(),
-                  static_cast<awaitable*>(p)->location_.line(),
-                  static_cast<awaitable*>(p)->location_.function_name()));
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-              static_cast<Op&&>(static_cast<awaitable*>(p)->op_)(
-                  co_composed_handler<Executors, Handler,
-                    Return, completion_signature_of_t<Op>>(
-                      static_cast<awaitable*>(p)->promise_));
-            };
-        }
-      }
-
-      auto await_resume()
-      {
-        return co_composed_handler<Executors, Handler, Return,
-          completion_signature_of_t<Op>>::on_resume(promise_.result_);
-      }
-
-    private:
-      Op&& op_;
-      co_composed_promise& promise_;
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      asio::detail::source_location location_;
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    };
-
-    state_.check_for_cancellation_on_transform();
-    return awaitable{static_cast<Op&&>(op), *this
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-        , location
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-      };
-  }
-
-  template <typename... Args>
-  auto yield_value(co_composed_completion<Args...>&& result)
-  {
-    class [[nodiscard]] awaitable
-    {
-    public:
-      awaitable(co_composed_completion<Args...>&& result,
-          co_composed_promise& promise)
-        : result_(std::move(result)),
-          promise_(promise)
-      {
-      }
-
-      constexpr bool await_ready() const noexcept
-      {
-        return false;
-      }
-
-      void await_suspend(coroutine_handle<co_composed_promise>)
-      {
-        promise_.state_.work_.reset();
-        promise_.state_.on_suspend_->arg_ = this;
-        promise_.state_.on_suspend_->fn_ =
-          [](void* p)
-          {
-            awaitable& a = *static_cast<awaitable*>(p);
-
-            co_composed_handler_base<Executors, Handler,
-              Return> composed_handler(a.promise_);
-
-            Handler handler(std::move(a.promise_.state_.handler_));
-            std::tuple<decay_t<Args>...> result(
-                std::move(static_cast<std::tuple<Args&&...>>(a.result_)));
-
-            co_composed_handler_base<Executors, Handler,
-              Return>(std::move(composed_handler));
-
-            std::apply(std::move(handler), std::move(result));
-          };
-      }
-
-      void await_resume() noexcept
-      {
-      }
-
-    private:
-      co_composed_completion<Args...> result_;
-      co_composed_promise& promise_;
-    };
-
-    return awaitable{std::move(result), *this};
-  }
-
-private:
-  using allocator_type =
-    associated_allocator_t<Handler, recycling_allocator<void>>;
-
-  union block
-  {
-    std::max_align_t max_align;
-    alignas(allocator_type) char pad[alignof(allocator_type)];
-  };
-
-  using block_allocator_type =
-    typename std::allocator_traits<allocator_type>
-      ::template rebind_alloc<block>;
-
-  static constexpr std::size_t blocks(std::size_t size)
-  {
-    return (size + sizeof(block) - 1) / sizeof(block);
-  }
-
-  co_composed_state<Executors, Handler, Return>& state_;
-  co_composed_promise** owner_ = nullptr;
-  void* result_ = nullptr;
-};
-
-template <typename Implementation, typename Executors, typename... Signatures>
-class initiate_co_composed
-{
-public:
-  using executor_type = typename composed_io_executors<Executors>::head_type;
-
-  template <typename I>
-  initiate_co_composed(I&& impl, composed_io_executors<Executors>&& executors)
-    : implementation_(static_cast<I&&>(impl)),
-      executors_(std::move(executors))
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executors_.head_;
-  }
-
-  template <typename Handler, typename... InitArgs>
-  void operator()(Handler&& handler, InitArgs&&... init_args) const &
-  {
-    using handler_type = decay_t<Handler>;
-    using returns_type = co_composed_returns<Signatures...>;
-    co_composed_on_suspend on_suspend{};
-    implementation_(
-        co_composed_state<Executors, handler_type, returns_type>(
-          executors_, static_cast<Handler&&>(handler), on_suspend),
-        static_cast<InitArgs&&>(init_args)...);
-    if (on_suspend.fn_)
-      on_suspend.fn_(on_suspend.arg_);
-  }
-
-  template <typename Handler, typename... InitArgs>
-  void operator()(Handler&& handler, InitArgs&&... init_args) &&
-  {
-    using handler_type = decay_t<Handler>;
-    using returns_type = co_composed_returns<Signatures...>;
-    co_composed_on_suspend on_suspend{};
-    std::move(implementation_)(
-        co_composed_state<Executors, handler_type, returns_type>(
-          std::move(executors_), static_cast<Handler&&>(handler), on_suspend),
-        static_cast<InitArgs&&>(init_args)...);
-    if (on_suspend.fn_)
-      on_suspend.fn_(on_suspend.arg_);
-  }
-
-private:
-  Implementation implementation_;
-  composed_io_executors<Executors> executors_;
-};
-
-template <typename Implementation, typename... Signatures>
-class initiate_co_composed<Implementation, void(), Signatures...>
-{
-public:
-  template <typename I>
-  initiate_co_composed(I&& impl, composed_io_executors<void()>&&)
-    : implementation_(static_cast<I&&>(impl))
-  {
-  }
-
-  template <typename Handler, typename... InitArgs>
-  void operator()(Handler&& handler, InitArgs&&... init_args) const &
-  {
-    using handler_type = decay_t<Handler>;
-    using returns_type = co_composed_returns<Signatures...>;
-    co_composed_on_suspend on_suspend{};
-    implementation_(
-        co_composed_state<void(), handler_type, returns_type>(
-          composed_io_executors<void()>(),
-          static_cast<Handler&&>(handler), on_suspend),
-        static_cast<InitArgs&&>(init_args)...);
-    if (on_suspend.fn_)
-      on_suspend.fn_(on_suspend.arg_);
-  }
-
-  template <typename Handler, typename... InitArgs>
-  void operator()(Handler&& handler, InitArgs&&... init_args) &&
-  {
-    using handler_type = decay_t<Handler>;
-    using returns_type = co_composed_returns<Signatures...>;
-    co_composed_on_suspend on_suspend{};
-    std::move(implementation_)(
-        co_composed_state<void(), handler_type, returns_type>(
-          composed_io_executors<void()>(),
-          static_cast<Handler&&>(handler), on_suspend),
-        static_cast<InitArgs&&>(init_args)...);
-    if (on_suspend.fn_)
-      on_suspend.fn_(on_suspend.arg_);
-  }
-
-private:
-  Implementation implementation_;
-};
-
-template <typename... Signatures, typename Implementation, typename Executors>
-inline initiate_co_composed<Implementation, Executors, Signatures...>
-make_initiate_co_composed(Implementation&& implementation,
-    composed_io_executors<Executors>&& executors)
-{
-  return initiate_co_composed<
-    decay_t<Implementation>, Executors, Signatures...>(
-        static_cast<Implementation&&>(implementation), std::move(executors));
-}
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename Executors, typename Handler, typename Return,
-    typename Signature, typename DefaultCandidate>
-struct associator<Associator,
-    detail::co_composed_handler<Executors, Handler, Return, Signature>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::co_composed_handler<
-        Executors, Handler, Return, Signature>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(
-        h.promise().state().handler());
-  }
-
-  static auto get(
-      const detail::co_composed_handler<
-        Executors, Handler, Return, Signature>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(
-      Associator<Handler, DefaultCandidate>::get(
-        h.promise().state().handler(), c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(
-        h.promise().state().handler(), c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#if !defined(GENERATING_DOCUMENTATION)
-# if defined(ASIO_HAS_STD_COROUTINE)
-namespace std {
-# else // defined(ASIO_HAS_STD_COROUTINE)
-namespace std { namespace experimental {
-# endif // defined(ASIO_HAS_STD_COROUTINE)
-
-template <typename C, typename Executors,
-    typename Handler, typename Return, typename... Args>
-struct coroutine_traits<void, C&,
-    asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
-{
-  using promise_type =
-    asio::detail::co_composed_promise<Executors, Handler, Return>;
-};
-
-template <typename C, typename Executors,
-    typename Handler, typename Return, typename... Args>
-struct coroutine_traits<void, C&&,
-    asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
-{
-  using promise_type =
-    asio::detail::co_composed_promise<Executors, Handler, Return>;
-};
-
-template <typename Executors, typename Handler,
-    typename Return, typename... Args>
-struct coroutine_traits<void,
-    asio::detail::co_composed_state<Executors, Handler, Return>, Args...>
-{
-  using promise_type =
-    asio::detail::co_composed_promise<Executors, Handler, Return>;
-};
-
-# if defined(ASIO_HAS_STD_COROUTINE)
-} // namespace std
-# else // defined(ASIO_HAS_STD_COROUTINE)
-}} // namespace std::experimental
-# endif // defined(ASIO_HAS_STD_COROUTINE)
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-namespace asio {
-
-/// Creates an initiation function object that may be used to launch a
-/// coroutine-based composed asynchronous operation.
-/**
- * The co_composed utility simplifies the implementation of composed
- * asynchronous operations by automatically adapting a coroutine to be an
- * initiation function object for use with @c async_initiate. When awaiting
- * asynchronous operations, the coroutine automatically uses a conforming
- * intermediate completion handler.
- *
- * @param implementation A function object that contains the coroutine-based
- * implementation of the composed asynchronous operation. The first argument to
- * the function object represents the state of the operation, and may be used
- * to test for cancellation. The remaining arguments are those passed to @c
- * async_initiate after the completion token.
- *
- * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
- * which outstanding work must be maintained while the operation is incomplete.
- *
- * @par Per-Operation Cancellation
- * By default, terminal per-operation cancellation is enabled for composed
- * operations that use co_composed. To disable cancellation for the composed
- * operation, or to alter its supported cancellation types, call the state's
- * @c reset_cancellation_state function.
- *
- * @par Examples
- * The following example illustrates manual error handling and explicit checks
- * for cancellation. The completion handler is invoked via a @c co_yield to the
- * state's @c complete function, which never returns.
- *
- * @code template <typename CompletionToken>
- * auto async_echo(tcp::socket& socket,
- *     CompletionToken&& token)
- * {
- *   return asio::async_initiate<
- *     CompletionToken, void(std::error_code)>(
- *       asio::co_composed(
- *         [](auto state, tcp::socket& socket) -> void
- *         {
- *           state.reset_cancellation_state(
- *             asio::enable_terminal_cancellation());
- *
- *           while (!state.cancelled())
- *           {
- *             char data[1024];
- *             auto [e1, n1] =
- *               co_await socket.async_read_some(
- *                 asio::buffer(data));
- *
- *             if (e1)
- *               co_yield state.complete(e1);
- *
- *             if (!!state.cancelled())
- *               co_yield state.complete(
- *                 make_error_code(asio::error::operation_aborted));
- *
- *             auto [e2, n2] =
- *               co_await asio::async_write(socket,
- *                 asio::buffer(data, n1));
- *
- *             if (e2)
- *               co_yield state.complete(e2);
- *           }
- *         }, socket),
- *       token, std::ref(socket));
- * } @endcode
- *
- * This next example shows exception-based error handling and implicit checks
- * for cancellation. The completion handler is invoked after returning from the
- * coroutine via @c co_return. Valid @c co_return values are specified using
- * completion signatures passed to the @c co_composed function.
- *
- * @code template <typename CompletionToken>
- * auto async_echo(tcp::socket& socket,
- *     CompletionToken&& token)
- * {
- *   return asio::async_initiate<
- *     CompletionToken, void(std::error_code)>(
- *       asio::co_composed<
- *         void(std::error_code)>(
- *           [](auto state, tcp::socket& socket) -> void
- *           {
- *             try
- *             {
- *               state.throw_if_cancelled(true);
- *               state.reset_cancellation_state(
- *                 asio::enable_terminal_cancellation());
- *
- *               for (;;)
- *               {
- *                 char data[1024];
- *                 std::size_t n = co_await socket.async_read_some(
- *                     asio::buffer(data));
- *
- *                 co_await asio::async_write(socket,
- *                     asio::buffer(data, n));
- *               }
- *             }
- *             catch (const std::system_error& e)
- *             {
- *               co_return {e.code()};
- *             }
- *           }, socket),
- *       token, std::ref(socket));
- * } @endcode
- */
-template <ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename Implementation, typename... IoObjectsOrExecutors>
-inline auto co_composed(Implementation&& implementation,
-    IoObjectsOrExecutors&&... io_objects_or_executors)
-{
-  return detail::make_initiate_co_composed<Signatures...>(
-      static_cast<Implementation&&>(implementation),
-      detail::make_composed_io_executors(
-        detail::get_composed_io_executor(
-          static_cast<IoObjectsOrExecutors&&>(
-            io_objects_or_executors))...));
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_CO_COMPOSED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_spawn.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_spawn.hpp
deleted file mode 100644
index 26988f4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/co_spawn.hpp
+++ /dev/null
@@ -1,523 +0,0 @@
-//
-// co_spawn.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CO_SPAWN_HPP
-#define ASIO_CO_SPAWN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/awaitable.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/is_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct awaitable_signature;
-
-template <typename T, typename Executor>
-struct awaitable_signature<awaitable<T, Executor>>
-{
-  typedef void type(std::exception_ptr, T);
-};
-
-template <typename Executor>
-struct awaitable_signature<awaitable<void, Executor>>
-{
-  typedef void type(std::exception_ptr);
-};
-
-} // namespace detail
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ex The executor that will be used to schedule the new thread of
- * execution.
- *
- * @param a The asio::awaitable object that is the result of calling the
- * coroutine's entry point function.
- *
- * @param token The @ref completion_token that will handle the notification that
- * the thread of execution has completed. The function signature of the
- * completion handler must be:
- * @code void handler(std::exception_ptr, T); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, T) @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<std::size_t> echo(tcp::socket socket)
- * {
- *   std::size_t bytes_transferred = 0;
- *
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *
- *       bytes_transferred += n;
- *     }
- *   }
- *   catch (const std::exception&)
- *   {
- *   }
- *
- *   co_return bytes_transferred;
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_executor,
- *   echo(std::move(my_tcp_socket)),
- *   [](std::exception_ptr e, std::size_t n)
- *   {
- *     std::cout << "transferred " << n << "\n";
- *   });
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename Executor, typename T, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr, T)) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    constraint_t<
-      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
-        && is_convertible<Executor, AwaitableExecutor>::value
-    > = 0);
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ex The executor that will be used to schedule the new thread of
- * execution.
- *
- * @param a The asio::awaitable object that is the result of calling the
- * coroutine's entry point function.
- *
- * @param token The @ref completion_token that will handle the notification that
- * the thread of execution has completed. The function signature of the
- * completion handler must be:
- * @code void handler(std::exception_ptr); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr) @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<void> echo(tcp::socket socket)
- * {
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *     }
- *   }
- *   catch (const std::exception& e)
- *   {
- *     std::cerr << "Exception: " << e.what() << "\n";
- *   }
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_executor,
- *   echo(std::move(my_tcp_socket)),
- *   asio::detached);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename Executor, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr)) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    constraint_t<
-      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
-        && is_convertible<Executor, AwaitableExecutor>::value
-    > = 0);
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ctx An execution context that will provide the executor to be used to
- * schedule the new thread of execution.
- *
- * @param a The asio::awaitable object that is the result of calling the
- * coroutine's entry point function.
- *
- * @param token The @ref completion_token that will handle the notification that
- * the thread of execution has completed. The function signature of the
- * completion handler must be:
- * @code void handler(std::exception_ptr); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, T) @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<std::size_t> echo(tcp::socket socket)
- * {
- *   std::size_t bytes_transferred = 0;
- *
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *
- *       bytes_transferred += n;
- *     }
- *   }
- *   catch (const std::exception&)
- *   {
- *   }
- *
- *   co_return bytes_transferred;
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_io_context,
- *   echo(std::move(my_tcp_socket)),
- *   [](std::exception_ptr e, std::size_t n)
- *   {
- *     std::cout << "transferred " << n << "\n";
- *   });
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename ExecutionContext, typename T, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr, T)) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
-          typename ExecutionContext::executor_type)>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(
-        typename ExecutionContext::executor_type),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-        && is_convertible<typename ExecutionContext::executor_type,
-          AwaitableExecutor>::value
-    > = 0);
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ctx An execution context that will provide the executor to be used to
- * schedule the new thread of execution.
- *
- * @param a The asio::awaitable object that is the result of calling the
- * coroutine's entry point function.
- *
- * @param token The @ref completion_token that will handle the notification that
- * the thread of execution has completed. The function signature of the
- * completion handler must be:
- * @code void handler(std::exception_ptr); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr) @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<void> echo(tcp::socket socket)
- * {
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *     }
- *   }
- *   catch (const std::exception& e)
- *   {
- *     std::cerr << "Exception: " << e.what() << "\n";
- *   }
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_io_context,
- *   echo(std::move(my_tcp_socket)),
- *   asio::detached);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename ExecutionContext, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr)) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
-          typename ExecutionContext::executor_type)>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(
-        typename ExecutionContext::executor_type),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-        && is_convertible<typename ExecutionContext::executor_type,
-          AwaitableExecutor>::value
-    > = 0);
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ex The executor that will be used to schedule the new thread of
- * execution.
- *
- * @param f A nullary function object with a return type of the form
- * @c asio::awaitable<R,E> that will be used as the coroutine's entry
- * point.
- *
- * @param token The @ref completion_token that will handle the notification
- * that the thread of execution has completed. If @c R is @c void, the function
- * signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the first template argument to the @c awaitable returned by the
- * supplied function object @c F:
- * @code asio::awaitable<R, AwaitableExecutor> F() @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<std::size_t> echo(tcp::socket socket)
- * {
- *   std::size_t bytes_transferred = 0;
- *
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *
- *       bytes_transferred += n;
- *     }
- *   }
- *   catch (const std::exception&)
- *   {
- *   }
- *
- *   co_return bytes_transferred;
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_executor,
- *   [socket = std::move(my_tcp_socket)]() mutable
- *     -> asio::awaitable<void>
- *   {
- *     try
- *     {
- *       char data[1024];
- *       for (;;)
- *       {
- *         std::size_t n = co_await socket.async_read_some(
- *             asio::buffer(data), asio::use_awaitable);
- *
- *         co_await asio::async_write(socket,
- *             asio::buffer(data, n), asio::use_awaitable);
- *       }
- *     }
- *     catch (const std::exception& e)
- *     {
- *       std::cerr << "Exception: " << e.what() << "\n";
- *     }
- *   }, asio::detached);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
-      result_of_t<F()>>::type) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<result_of_t<F()>>::type)
-co_spawn(const Executor& ex, F&& f,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0);
-
-/// Spawn a new coroutined-based thread of execution.
-/**
- * @param ctx An execution context that will provide the executor to be used to
- * schedule the new thread of execution.
- *
- * @param f A nullary function object with a return type of the form
- * @c asio::awaitable<R,E> that will be used as the coroutine's entry
- * point.
- *
- * @param token The @ref completion_token that will handle the notification
- * that the thread of execution has completed. If @c R is @c void, the function
- * signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the first template argument to the @c awaitable returned by the
- * supplied function object @c F:
- * @code asio::awaitable<R, AwaitableExecutor> F() @endcode
- *
- * @par Example
- * @code
- * asio::awaitable<std::size_t> echo(tcp::socket socket)
- * {
- *   std::size_t bytes_transferred = 0;
- *
- *   try
- *   {
- *     char data[1024];
- *     for (;;)
- *     {
- *       std::size_t n = co_await socket.async_read_some(
- *           asio::buffer(data), asio::use_awaitable);
- *
- *       co_await asio::async_write(socket,
- *           asio::buffer(data, n), asio::use_awaitable);
- *
- *       bytes_transferred += n;
- *     }
- *   }
- *   catch (const std::exception&)
- *   {
- *   }
- *
- *   co_return bytes_transferred;
- * }
- *
- * // ...
- *
- * asio::co_spawn(my_io_context,
- *   [socket = std::move(my_tcp_socket)]() mutable
- *     -> asio::awaitable<void>
- *   {
- *     try
- *     {
- *       char data[1024];
- *       for (;;)
- *       {
- *         std::size_t n = co_await socket.async_read_some(
- *             asio::buffer(data), asio::use_awaitable);
- *
- *         co_await asio::async_write(socket,
- *             asio::buffer(data, n), asio::use_awaitable);
- *       }
- *     }
- *     catch (const std::exception& e)
- *     {
- *       std::cerr << "Exception: " << e.what() << "\n";
- *     }
- *   }, asio::detached);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call asio::this_coro::reset_cancellation_state.
- */
-template <typename ExecutionContext, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
-      result_of_t<F()>>::type) CompletionToken
-        ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
-          typename ExecutionContext::executor_type)>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<result_of_t<F()>>::type)
-co_spawn(ExecutionContext& ctx, F&& f,
-    CompletionToken&& token
-      ASIO_DEFAULT_COMPLETION_TOKEN(
-        typename ExecutionContext::executor_type),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0);
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/co_spawn.hpp"
-
-#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_CO_SPAWN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/completion_condition.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/completion_condition.hpp
deleted file mode 100644
index da432d3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/completion_condition.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-//
-// completion_condition.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_COMPLETION_CONDITION_HPP
-#define ASIO_COMPLETION_CONDITION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/detail/type_traits.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail {
-
-// The default maximum number of bytes to transfer in a single operation.
-enum default_max_transfer_size_t { default_max_transfer_size = 65536 };
-
-// Adapt result of old-style completion conditions (which had a bool result
-// where true indicated that the operation was complete).
-inline std::size_t adapt_completion_condition_result(bool result)
-{
-  return result ? 0 : default_max_transfer_size;
-}
-
-// Adapt result of current completion conditions (which have a size_t result
-// where 0 means the operation is complete, and otherwise the result is the
-// maximum number of bytes to transfer on the next underlying operation).
-inline std::size_t adapt_completion_condition_result(std::size_t result)
-{
-  return result;
-}
-
-class transfer_all_t
-{
-public:
-  typedef std::size_t result_type;
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t)
-  {
-    return !!err ? 0 : default_max_transfer_size;
-  }
-};
-
-class transfer_at_least_t
-{
-public:
-  typedef std::size_t result_type;
-
-  explicit transfer_at_least_t(std::size_t minimum)
-    : minimum_(minimum)
-  {
-  }
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
-  {
-    return (!!err || bytes_transferred >= minimum_)
-      ? 0 : default_max_transfer_size;
-  }
-
-private:
-  std::size_t minimum_;
-};
-
-class transfer_exactly_t
-{
-public:
-  typedef std::size_t result_type;
-
-  explicit transfer_exactly_t(std::size_t size)
-    : size_(size)
-  {
-  }
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
-  {
-    return (!!err || bytes_transferred >= size_) ? 0 :
-      (size_ - bytes_transferred < default_max_transfer_size
-        ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
-  }
-
-private:
-  std::size_t size_;
-};
-
-template <typename T, typename = void>
-struct is_completion_condition_helper : false_type
-{
-};
-
-template <typename T>
-struct is_completion_condition_helper<T,
-    enable_if_t<
-      is_same<
-        result_of_t<T(asio::error_code, std::size_t)>,
-        bool
-      >::value
-    >
-  > : true_type
-{
-};
-
-template <typename T>
-struct is_completion_condition_helper<T,
-    enable_if_t<
-      is_same<
-        result_of_t<T(asio::error_code, std::size_t)>,
-        std::size_t
-      >::value
-    >
-  > : true_type
-{
-};
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// Trait for determining whether a function object is a completion condition.
-template <typename T>
-struct is_completion_condition
-{
-  static constexpr bool value = automatically_determined;
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename T>
-struct is_completion_condition : detail::is_completion_condition_helper<T>
-{
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-/**
- * @defgroup completion_condition Completion Condition Function Objects
- *
- * Function objects used for determining when a read or write operation should
- * complete.
- */
-/*@{*/
-
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until all of the data has been transferred,
-/// or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full:
- * @code
- * boost::array<char, 128> buf;
- * asio::error_code ec;
- * std::size_t n = asio::read(
- *     sock, asio::buffer(buf),
- *     asio::transfer_all(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n == 128
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_all();
-#else
-inline detail::transfer_all_t transfer_all()
-{
-  return detail::transfer_all_t();
-}
-#endif
-
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until a minimum number of bytes has been
-/// transferred, or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full or contains at least 64 bytes:
- * @code
- * boost::array<char, 128> buf;
- * asio::error_code ec;
- * std::size_t n = asio::read(
- *     sock, asio::buffer(buf),
- *     asio::transfer_at_least(64), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n >= 64 && n <= 128
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_at_least(std::size_t minimum);
-#else
-inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
-{
-  return detail::transfer_at_least_t(minimum);
-}
-#endif
-
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until an exact number of bytes has been
-/// transferred, or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full or contains exactly 64 bytes:
- * @code
- * boost::array<char, 128> buf;
- * asio::error_code ec;
- * std::size_t n = asio::read(
- *     sock, asio::buffer(buf),
- *     asio::transfer_exactly(64), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n == 64
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_exactly(std::size_t size);
-#else
-inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
-{
-  return detail::transfer_exactly_t(size);
-}
-#endif
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_COMPLETION_CONDITION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/compose.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/compose.hpp
deleted file mode 100644
index 7842c18..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/compose.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// compose.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_COMPOSE_HPP
-#define ASIO_COMPOSE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/composed.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Launch an asynchronous operation with a stateful implementation.
-/**
- * The async_compose function simplifies the implementation of composed
- * asynchronous operations automatically wrapping a stateful function object
- * with a conforming intermediate completion handler.
- *
- * @param implementation A function object that contains the implementation of
- * the composed asynchronous operation. The first argument to the function
- * object is a non-const reference to the enclosing intermediate completion
- * handler. The remaining arguments are any arguments that originate from the
- * completion handlers of any asynchronous operations performed by the
- * implementation.
- *
- * @param token The completion token.
- *
- * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
- * which outstanding work must be maintained.
- *
- * @par Per-Operation Cancellation
- * By default, terminal per-operation cancellation is enabled for
- * composed operations that are implemented using @c async_compose. To
- * disable cancellation for the composed operation, or to alter its
- * supported cancellation types, call the @c self object's @c
- * reset_cancellation_state function.
- *
- * @par Example:
- *
- * @code struct async_echo_implementation
- * {
- *   tcp::socket& socket_;
- *   asio::mutable_buffer buffer_;
- *   enum { starting, reading, writing } state_;
- *
- *   template <typename Self>
- *   void operator()(Self& self,
- *       asio::error_code error = {},
- *       std::size_t n = 0)
- *   {
- *     switch (state_)
- *     {
- *     case starting:
- *       state_ = reading;
- *       socket_.async_read_some(
- *           buffer_, std::move(self));
- *       break;
- *     case reading:
- *       if (error)
- *       {
- *         self.complete(error, 0);
- *       }
- *       else
- *       {
- *         state_ = writing;
- *         asio::async_write(socket_, buffer_,
- *             asio::transfer_exactly(n),
- *             std::move(self));
- *       }
- *       break;
- *     case writing:
- *       self.complete(error, n);
- *       break;
- *     }
- *   }
- * };
- *
- * template <typename CompletionToken>
- * auto async_echo(tcp::socket& socket,
- *     asio::mutable_buffer buffer,
- *     CompletionToken&& token)
- *   -> decltype(
- *     asio::async_compose<CompletionToken,
- *       void(asio::error_code, std::size_t)>(
- *         std::declval<async_echo_implementation>(),
- *         token, socket))
- * {
- *   return asio::async_compose<CompletionToken,
- *     void(asio::error_code, std::size_t)>(
- *       async_echo_implementation{socket, buffer,
- *         async_echo_implementation::starting},
- *       token, socket);
- * } @endcode
- */
-template <typename CompletionToken, typename Signature,
-    typename Implementation, typename... IoObjectsOrExecutors>
-inline auto async_compose(Implementation&& implementation,
-    type_identity_t<CompletionToken>& token,
-    IoObjectsOrExecutors&&... io_objects_or_executors)
-  -> decltype(
-    async_initiate<CompletionToken, Signature>(
-      composed<Signature>(static_cast<Implementation&&>(implementation),
-        static_cast<IoObjectsOrExecutors&&>(io_objects_or_executors)...),
-      token))
-{
-  return async_initiate<CompletionToken, Signature>(
-      composed<Signature>(static_cast<Implementation&&>(implementation),
-        static_cast<IoObjectsOrExecutors&&>(io_objects_or_executors)...),
-      token);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_COMPOSE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/composed.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/composed.hpp
deleted file mode 100644
index d5d546f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/composed.hpp
+++ /dev/null
@@ -1,413 +0,0 @@
-//
-// composed.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_COMPOSED_HPP
-#define ASIO_COMPOSED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/composed_work.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Impl, typename Work,
-    typename Handler, typename... Signatures>
-class composed_op;
-
-template <typename Impl, typename Work, typename Handler>
-class composed_op<Impl, Work, Handler>
-  : public base_from_cancellation_state<Handler>
-{
-public:
-  template <typename I, typename W, typename H>
-  composed_op(I&& impl,
-      W&& work,
-      H&& handler)
-    : base_from_cancellation_state<Handler>(
-        handler, enable_terminal_cancellation()),
-      impl_(static_cast<I&&>(impl)),
-      work_(static_cast<W&&>(work)),
-      handler_(static_cast<H&&>(handler)),
-      invocations_(0)
-  {
-  }
-
-  composed_op(composed_op&& other)
-    : base_from_cancellation_state<Handler>(
-        static_cast<base_from_cancellation_state<Handler>&&>(other)),
-      impl_(static_cast<Impl&&>(other.impl_)),
-      work_(static_cast<Work&&>(other.work_)),
-      handler_(static_cast<Handler&&>(other.handler_)),
-      invocations_(other.invocations_)
-  {
-  }
-
-  typedef typename composed_work_guard<
-    typename Work::head_type>::executor_type io_executor_type;
-
-  io_executor_type get_io_executor() const noexcept
-  {
-    return work_.head_.get_executor();
-  }
-
-  typedef associated_executor_t<Handler, io_executor_type> executor_type;
-
-  executor_type get_executor() const noexcept
-  {
-    return (get_associated_executor)(handler_, work_.head_.get_executor());
-  }
-
-  typedef associated_allocator_t<Handler, std::allocator<void>> allocator_type;
-
-  allocator_type get_allocator() const noexcept
-  {
-    return (get_associated_allocator)(handler_, std::allocator<void>());
-  }
-
-  template <typename... T>
-  void operator()(T&&... t)
-  {
-    if (invocations_ < ~0u)
-      ++invocations_;
-    this->get_cancellation_state().slot().clear();
-    impl_(*this, static_cast<T&&>(t)...);
-  }
-
-  template <typename... Args>
-  auto complete(Args&&... args)
-    -> decltype(declval<Handler>()(static_cast<Args&&>(args)...))
-  {
-    return static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
-  }
-
-  void reset_cancellation_state()
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_);
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter&& filter)
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
-        static_cast<Filter&&>(filter));
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter,
-      OutFilter&& out_filter)
-  {
-    base_from_cancellation_state<Handler>::reset_cancellation_state(handler_,
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return base_from_cancellation_state<Handler>::cancelled();
-  }
-
-//private:
-  Impl impl_;
-  Work work_;
-  Handler handler_;
-  unsigned invocations_;
-};
-
-template <typename Impl, typename Work, typename Handler,
-    typename R, typename... Args>
-class composed_op<Impl, Work, Handler, R(Args...)>
-  : public composed_op<Impl, Work, Handler>
-{
-public:
-  using composed_op<Impl, Work, Handler>::composed_op;
-
-  template <typename... T>
-  void operator()(T&&... t)
-  {
-    if (this->invocations_ < ~0u)
-      ++this->invocations_;
-    this->get_cancellation_state().slot().clear();
-    this->impl_(*this, static_cast<T&&>(t)...);
-  }
-
-  void complete(Args... args)
-  {
-    this->work_.reset();
-    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Impl, typename Work, typename Handler,
-    typename R, typename... Args, typename... Signatures>
-class composed_op<Impl, Work, Handler, R(Args...), Signatures...>
-  : public composed_op<Impl, Work, Handler, Signatures...>
-{
-public:
-  using composed_op<Impl, Work, Handler, Signatures...>::composed_op;
-
-  template <typename... T>
-  void operator()(T&&... t)
-  {
-    if (this->invocations_ < ~0u)
-      ++this->invocations_;
-    this->get_cancellation_state().slot().clear();
-    this->impl_(*this, static_cast<T&&>(t)...);
-  }
-
-  using composed_op<Impl, Work, Handler, Signatures...>::complete;
-
-  void complete(Args... args)
-  {
-    this->work_.reset();
-    static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Impl, typename Work, typename Handler, typename Signature>
-inline bool asio_handler_is_continuation(
-    composed_op<Impl, Work, Handler, Signature>* this_handler)
-{
-  return this_handler->invocations_ > 1 ? true
-    : asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Implementation, typename Executors, typename... Signatures>
-class initiate_composed
-{
-public:
-  typedef typename composed_io_executors<Executors>::head_type executor_type;
-
-  template <typename I>
-  initiate_composed(I&& impl, composed_io_executors<Executors>&& executors)
-    : implementation_(std::forward<I>(impl)),
-      executors_(std::move(executors))
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executors_.head_;
-  }
-
-  template <typename Handler, typename... Args>
-  void operator()(Handler&& handler, Args&&... args) const &
-  {
-    composed_op<decay_t<Implementation>, composed_work<Executors>,
-      decay_t<Handler>, Signatures...>(implementation_,
-        composed_work<Executors>(executors_),
-        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename... Args>
-  void operator()(Handler&& handler, Args&&... args) &&
-  {
-    composed_op<decay_t<Implementation>, composed_work<Executors>,
-      decay_t<Handler>, Signatures...>(
-        static_cast<Implementation&&>(implementation_),
-        composed_work<Executors>(executors_),
-        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
-  }
-
-private:
-  Implementation implementation_;
-  composed_io_executors<Executors> executors_;
-};
-
-template <typename Implementation, typename... Signatures>
-class initiate_composed<Implementation, void(), Signatures...>
-{
-public:
-  template <typename I>
-  initiate_composed(I&& impl, composed_io_executors<void()>&&)
-    : implementation_(std::forward<I>(impl))
-  {
-  }
-
-  template <typename Handler, typename... Args>
-  void operator()(Handler&& handler, Args&&... args) const &
-  {
-    composed_op<decay_t<Implementation>, composed_work<void()>,
-      decay_t<Handler>, Signatures...>(implementation_,
-        composed_work<void()>(composed_io_executors<void()>()),
-        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename... Args>
-  void operator()(Handler&& handler, Args&&... args) &&
-  {
-    composed_op<decay_t<Implementation>, composed_work<void()>,
-      decay_t<Handler>, Signatures...>(
-        static_cast<Implementation&&>(implementation_),
-        composed_work<void()>(composed_io_executors<void()>()),
-        static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...);
-  }
-
-private:
-  Implementation implementation_;
-};
-
-template <typename... Signatures, typename Implementation, typename Executors>
-inline initiate_composed<Implementation, Executors, Signatures...>
-make_initiate_composed(Implementation&& implementation,
-    composed_io_executors<Executors>&& executors)
-{
-  return initiate_composed<decay_t<Implementation>, Executors, Signatures...>(
-      static_cast<Implementation&&>(implementation),
-      static_cast<composed_io_executors<Executors>&&>(executors));
-}
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename Impl, typename Work, typename Handler,
-    typename Signature, typename DefaultCandidate>
-struct associator<Associator,
-    detail::composed_op<Impl, Work, Handler, Signature>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::composed_op<Impl, Work, Handler, Signature>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::composed_op<Impl, Work, Handler, Signature>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Creates an initiation function object that may be used to launch an
-/// asynchronous operation with a stateful implementation.
-/**
- * The @c composed function simplifies the implementation of composed
- * asynchronous operations automatically by wrapping a stateful function object
- * for use as an initiation function object.
- *
- * @param implementation A function object that contains the implementation of
- * the composed asynchronous operation. The first argument to the function
- * object is a non-const reference to the enclosing intermediate completion
- * handler. The remaining arguments are any arguments that originate from the
- * completion handlers of any asynchronous operations performed by the
- * implementation.
- *
- * @param io_objects_or_executors Zero or more I/O objects or I/O executors for
- * which outstanding work must be maintained.
- *
- * @par Per-Operation Cancellation
- * By default, terminal per-operation cancellation is enabled for composed
- * operations that are implemented using @c composed. To disable cancellation
- * for the composed operation, or to alter its supported cancellation types,
- * call the @c self object's @c reset_cancellation_state function.
- *
- * @par Example:
- *
- * @code struct async_echo_implementation
- * {
- *   tcp::socket& socket_;
- *   asio::mutable_buffer buffer_;
- *   enum { starting, reading, writing } state_;
- *
- *   template <typename Self>
- *   void operator()(Self& self,
- *       asio::error_code error,
- *       std::size_t n)
- *   {
- *     switch (state_)
- *     {
- *     case starting:
- *       state_ = reading;
- *       socket_.async_read_some(
- *           buffer_, std::move(self));
- *       break;
- *     case reading:
- *       if (error)
- *       {
- *         self.complete(error, 0);
- *       }
- *       else
- *       {
- *         state_ = writing;
- *         asio::async_write(socket_, buffer_,
- *             asio::transfer_exactly(n),
- *             std::move(self));
- *       }
- *       break;
- *     case writing:
- *       self.complete(error, n);
- *       break;
- *     }
- *   }
- * };
- *
- * template <typename CompletionToken>
- * auto async_echo(tcp::socket& socket,
- *     asio::mutable_buffer buffer,
- *     CompletionToken&& token)
- *   -> decltype(
- *     asio::async_initiate<CompletionToken,
- *       void(asio::error_code, std::size_t)>(
- *         asio::composed(
- *           async_echo_implementation{socket, buffer,
- *             async_echo_implementation::starting}, socket),
- *         token))
- * {
- *   return asio::async_initiate<CompletionToken,
- *     void(asio::error_code, std::size_t)>(
- *       asio::composed(
- *         async_echo_implementation{socket, buffer,
- *           async_echo_implementation::starting}, socket),
- *       token, asio::error_code{}, 0);
- * } @endcode
- */
-template <ASIO_COMPLETION_SIGNATURE... Signatures,
-    typename Implementation, typename... IoObjectsOrExecutors>
-inline auto composed(Implementation&& implementation,
-    IoObjectsOrExecutors&&... io_objects_or_executors)
-  -> decltype(
-    detail::make_initiate_composed<Signatures...>(
-      static_cast<Implementation&&>(implementation),
-      detail::make_composed_io_executors(
-        detail::get_composed_io_executor(
-          static_cast<IoObjectsOrExecutors&&>(
-            io_objects_or_executors))...)))
-{
-  return detail::make_initiate_composed<Signatures...>(
-      static_cast<Implementation&&>(implementation),
-      detail::make_composed_io_executors(
-        detail::get_composed_io_executor(
-          static_cast<IoObjectsOrExecutors&&>(
-            io_objects_or_executors))...));
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_COMPOSE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect.hpp
deleted file mode 100644
index ed6658c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect.hpp
+++ /dev/null
@@ -1,1346 +0,0 @@
-//
-// connect.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CONNECT_HPP
-#define ASIO_CONNECT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  struct default_connect_condition;
-  template <typename, typename> class initiate_async_range_connect;
-  template <typename, typename> class initiate_async_iterator_connect;
-
-  template <typename T, typename = void, typename = void>
-  struct is_endpoint_sequence_helper : false_type
-  {
-  };
-
-  template <typename T>
-  struct is_endpoint_sequence_helper<T,
-      void_t<
-        decltype(declval<T>().begin())
-      >,
-      void_t<
-        decltype(declval<T>().end())
-      >
-    > : true_type
-  {
-  };
-
-  template <typename T, typename Iterator, typename = void>
-  struct is_connect_condition_helper : false_type
-  {
-  };
-
-  template <typename T, typename Iterator>
-  struct is_connect_condition_helper<T, Iterator,
-      enable_if_t<
-        is_same<
-          result_of_t<T(asio::error_code, Iterator)>,
-          Iterator
-        >::value
-      >
-    > : true_type
-  {
-  };
-
-  template <typename T, typename Iterator>
-  struct is_connect_condition_helper<T, Iterator,
-      enable_if_t<
-        is_same<
-          result_of_t<T(asio::error_code,
-            decltype(*declval<Iterator>()))>,
-          bool
-        >::value
-      >
-    > : true_type
-  {
-  };
-
-  struct default_connect_condition
-  {
-    template <typename Endpoint>
-    bool operator()(const asio::error_code&, const Endpoint&)
-    {
-      return true;
-    }
-  };
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// Type trait used to determine whether a type is an endpoint sequence that can
-/// be used with with @c connect and @c async_connect.
-template <typename T>
-struct is_endpoint_sequence
-{
-  /// The value member is true if the type may be used as an endpoint sequence.
-  static const bool value = automatically_determined;
-};
-
-/// Trait for determining whether a function object is a connect condition that
-/// can be used with @c connect and @c async_connect.
-template <typename T, typename Iterator>
-struct is_connect_condition
-{
-  /// The value member is true if the type may be used as a connect condition.
-  static constexpr bool value = automatically_determined;
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename T>
-struct is_endpoint_sequence : detail::is_endpoint_sequence_helper<T>
-{
-};
-
-template <typename T, typename Iterator>
-struct is_connect_condition : detail::is_connect_condition_helper<T, Iterator>
-{
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-/**
- * @defgroup connect asio::connect
- *
- * @brief The @c connect function is a composed operation that establishes a
- * socket connection by trying each endpoint in a sequence.
- */
-/*@{*/
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @returns The successfully connected endpoint.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- * asio::connect(s, r.resolve(q)); @endcode
- */
-template <typename Protocol, typename Executor, typename EndpointSequence>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, the successfully connected endpoint. Otherwise, a
- * default-constructed endpoint.
- *
- * @par Example
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- * asio::error_code ec;
- * asio::connect(s, r.resolve(q), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * } @endcode
- */
-template <typename Protocol, typename Executor, typename EndpointSequence>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, asio::error_code& ec,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0);
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// (Deprecated: Use range overload.) Establishes a socket connection by trying
-/// each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- */
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0);
-
-/// (Deprecated: Use range overload.) Establishes a socket connection by trying
-/// each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- */
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, asio::error_code& ec,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @returns An iterator denoting the successfully connected endpoint.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::results_type e = r.resolve(q);
- * tcp::socket s(my_context);
- * asio::connect(s, e.begin(), e.end()); @endcode
- */
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @par Example
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::results_type e = r.resolve(q);
- * tcp::socket s(my_context);
- * asio::error_code ec;
- * asio::connect(s, e.begin(), e.end(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * } @endcode
- */
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end, asio::error_code& ec);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @returns The successfully connected endpoint.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- * tcp::endpoint e = asio::connect(s,
- *     r.resolve(q), my_connect_condition());
- * std::cout << "Connected to: " << e << std::endl; @endcode
- */
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename ConnectCondition>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    > = 0);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, the successfully connected endpoint. Otherwise, a
- * default-constructed endpoint.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- * asio::error_code ec;
- * tcp::endpoint e = asio::connect(s,
- *     r.resolve(q), my_connect_condition(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   std::cout << "Connected to: " << e << std::endl;
- * } @endcode
- */
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename ConnectCondition>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    asio::error_code& ec,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    > = 0);
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// (Deprecated: Use range overload.) Establishes a socket connection by trying
-/// each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, ConnectCondition connect_condition,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0);
-
-/// (Deprecated: Use range overload.) Establishes a socket connection by trying
-/// each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    ConnectCondition connect_condition, asio::error_code& ec,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @returns An iterator denoting the successfully connected endpoint.
- *
- * @throws asio::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::results_type e = r.resolve(q);
- * tcp::socket s(my_context);
- * tcp::resolver::results_type::iterator i = asio::connect(
- *     s, e.begin(), e.end(), my_connect_condition());
- * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    Iterator end, ConnectCondition connect_condition,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::results_type e = r.resolve(q);
- * tcp::socket s(my_context);
- * asio::error_code ec;
- * tcp::resolver::results_type::iterator i = asio::connect(
- *     s, e.begin(), e.end(), my_connect_condition());
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   std::cout << "Connected to: " << i->endpoint() << std::endl;
- * } @endcode
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end, ConnectCondition connect_condition,
-    asio::error_code& ec,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0);
-
-/*@}*/
-
-/**
- * @defgroup async_connect asio::async_connect
- *
- * @brief The @c async_connect function is a composed asynchronous operation
- * that establishes a socket connection by trying each endpoint in a sequence.
- */
-/*@{*/
-
-/// Asynchronously establishes a socket connection by trying each endpoint in a
-/// sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, the successfully connected endpoint.
- *   // Otherwise, a default-constructed endpoint.
- *   const typename Protocol::endpoint& endpoint
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, typename Protocol::endpoint) @endcode
- *
- * @par Example
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const asio::error_code& ec,
- *     tcp::resolver::results_type results)
- * {
- *   if (!ec)
- *   {
- *     asio::async_connect(s, results, connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const asio::error_code& ec,
- *     const tcp::endpoint& endpoint)
- * {
- *   // ...
- * } @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor, typename EndpointSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      typename Protocol::endpoint)) RangeConnectToken
-        = default_completion_token_t<Executor>>
-inline auto async_connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints,
-    RangeConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0,
-    constraint_t<
-      !is_connect_condition<RangeConnectToken,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    > = 0)
-  -> decltype(
-    async_initiate<RangeConnectToken,
-      void (asio::error_code, typename Protocol::endpoint)>(
-        declval<detail::initiate_async_range_connect<Protocol, Executor>>(),
-        token, endpoints, declval<detail::default_connect_condition>()))
-{
-  return async_initiate<RangeConnectToken,
-    void (asio::error_code, typename Protocol::endpoint)>(
-      detail::initiate_async_range_connect<Protocol, Executor>(s),
-      token, endpoints, detail::default_connect_condition());
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// (Deprecated: Use range overload.) Asynchronously establishes a socket
-/// connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, Iterator) @endcode
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor, typename Iterator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-inline auto async_connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0,
-    constraint_t<
-      !is_same<Iterator, decay_t<IteratorConnectToken>>::value
-    > = 0,
-    constraint_t<
-      !is_connect_condition<IteratorConnectToken, Iterator>::value
-    > = 0)
-  -> decltype(
-    async_initiate<IteratorConnectToken,
-      void (asio::error_code, Iterator)>(
-        declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, Iterator(),
-        declval<detail::default_connect_condition>()))
-{
-  return async_initiate<IteratorConnectToken,
-    void (asio::error_code, Iterator)>(
-      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      token, begin, Iterator(), detail::default_connect_condition());
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Asynchronously establishes a socket connection by trying each endpoint in a
-/// sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, Iterator) @endcode
- *
- * @par Example
- * @code std::vector<tcp::endpoint> endpoints = ...;
- * tcp::socket s(my_context);
- * asio::async_connect(s,
- *     endpoints.begin(), endpoints.end(),
- *     connect_handler);
- *
- * // ...
- *
- * void connect_handler(
- *     const asio::error_code& ec,
- *     std::vector<tcp::endpoint>::iterator i)
- * {
- *   // ...
- * } @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor, typename Iterator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-inline auto async_connect(
-    basic_socket<Protocol, Executor>& s, Iterator begin, Iterator end,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      !is_connect_condition<IteratorConnectToken, Iterator>::value
-    > = 0)
-  -> decltype(
-    async_initiate<IteratorConnectToken,
-      void (asio::error_code, Iterator)>(
-        declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, end, declval<detail::default_connect_condition>()))
-{
-  return async_initiate<IteratorConnectToken,
-    void (asio::error_code, Iterator)>(
-      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      token, begin, end, detail::default_connect_condition());
-}
-
-/// Asynchronously establishes a socket connection by trying each endpoint in a
-/// sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param endpoints A sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, typename Protocol::endpoint) @endcode
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const asio::error_code& ec,
- *     tcp::resolver::results_type results)
- * {
- *   if (!ec)
- *   {
- *     asio::async_connect(s, results,
- *         my_connect_condition(),
- *         connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const asio::error_code& ec,
- *     const tcp::endpoint& endpoint)
- * {
- *   if (ec)
- *   {
- *     // An error occurred.
- *   }
- *   else
- *   {
- *     std::cout << "Connected to: " << endpoint << std::endl;
- *   }
- * } @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename ConnectCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      typename Protocol::endpoint)) RangeConnectToken
-        = default_completion_token_t<Executor>>
-inline auto async_connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    RangeConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    > = 0)
-  -> decltype(
-    async_initiate<RangeConnectToken,
-      void (asio::error_code, typename Protocol::endpoint)>(
-        declval<detail::initiate_async_range_connect<Protocol, Executor>>(),
-        token, endpoints, connect_condition))
-{
-  return async_initiate<RangeConnectToken,
-    void (asio::error_code, typename Protocol::endpoint)>(
-      detail::initiate_async_range_connect<Protocol, Executor>(s),
-      token, endpoints, connect_condition);
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// (Deprecated: Use range overload.) Asynchronously establishes a socket
-/// connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, Iterator) @endcode
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c asio::ip::tcp::resolver::iterator.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-inline auto async_connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, ConnectCondition connect_condition,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    > = 0,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0)
-  -> decltype(
-    async_initiate<IteratorConnectToken,
-      void (asio::error_code, Iterator)>(
-        declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, Iterator(), connect_condition))
-{
-  return async_initiate<IteratorConnectToken,
-    void (asio::error_code, Iterator)>(
-      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      token, begin, Iterator(), connect_condition);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Asynchronously establishes a socket connection by trying each endpoint in a
-/// sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code bool connect_condition(
- *     const asio::error_code& ec,
- *     const typename Protocol::endpoint& next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is the next endpoint to be tried.
- * The function object should return true if the next endpoint should be tried,
- * and false if it should be skipped.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the connect completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const asio::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, Iterator) @endcode
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   bool operator()(
- *       const asio::error_code& ec,
- *       const::tcp::endpoint& next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next << std::endl;
- *     return true;
- *   }
- * }; @endcode
- * It would be used with the asio::connect function as follows:
- * @code tcp::resolver r(my_context);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(my_context);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     tcp::resolver::iterator end;
- *     asio::async_connect(s, i, end,
- *         my_connect_condition(),
- *         connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const asio::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (ec)
- *   {
- *     // An error occurred.
- *   }
- *   else
- *   {
- *     std::cout << "Connected to: " << i->endpoint() << std::endl;
- *   }
- * } @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the socket's @c async_connect operation.
- */
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      Iterator)) IteratorConnectToken = default_completion_token_t<Executor>>
-inline auto async_connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end, ConnectCondition connect_condition,
-    IteratorConnectToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    > = 0)
-  -> decltype(
-    async_initiate<IteratorConnectToken,
-      void (asio::error_code, Iterator)>(
-        declval<detail::initiate_async_iterator_connect<Protocol, Executor>>(),
-        token, begin, end, connect_condition))
-{
-  return async_initiate<IteratorConnectToken,
-    void (asio::error_code, Iterator)>(
-      detail::initiate_async_iterator_connect<Protocol, Executor>(s),
-      token, begin, end, connect_condition);
-}
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/connect.hpp"
-
-#endif // ASIO_CONNECT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect_pipe.hpp
deleted file mode 100644
index 1c9eb79..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/connect_pipe.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// connect_pipe.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CONNECT_PIPE_HPP
-#define ASIO_CONNECT_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_readable_pipe.hpp"
-#include "asio/basic_writable_pipe.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_IOCP)
-typedef HANDLE native_pipe_handle;
-#else // defined(ASIO_HAS_IOCP)
-typedef int native_pipe_handle;
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void create_pipe(native_pipe_handle p[2],
-    asio::error_code& ec);
-
-ASIO_DECL void close_pipe(native_pipe_handle p);
-
-} // namespace detail
-
-/// Connect two pipe ends using an anonymous pipe.
-/**
- * @param read_end The read end of the pipe.
- *
- * @param write_end The write end of the pipe.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename Executor1, typename Executor2>
-void connect_pipe(basic_readable_pipe<Executor1>& read_end,
-    basic_writable_pipe<Executor2>& write_end);
-
-/// Connect two pipe ends using an anonymous pipe.
-/**
- * @param read_end The read end of the pipe.
- *
- * @param write_end The write end of the pipe.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @param ec Set to indicate what error occurred, if any.
- */
-template <typename Executor1, typename Executor2>
-ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
-    basic_writable_pipe<Executor2>& write_end, asio::error_code& ec);
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/connect_pipe.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/connect_pipe.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_PIPE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_CONNECT_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/consign.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/consign.hpp
deleted file mode 100644
index 4b0bc43..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/consign.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// consign.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_CONSIGN_HPP
-#define ASIO_CONSIGN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Completion token type used to specify that the completion handler should
-/// carry additional values along with it.
-/**
- * This completion token adapter is typically used to keep at least one copy of
- * an object, such as a smart pointer, alive until the completion handler is
- * called.
- */
-template <typename CompletionToken, typename... Values>
-class consign_t
-{
-public:
-  /// Constructor.
-  template <typename T, typename... V>
-  constexpr explicit consign_t(T&& completion_token, V&&... values)
-    : token_(static_cast<T&&>(completion_token)),
-      values_(static_cast<V&&>(values)...)
-  {
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-private:
-#endif // defined(GENERATING_DOCUMENTATION)
-  CompletionToken token_;
-  std::tuple<Values...> values_;
-};
-
-/// Completion token adapter used to specify that the completion handler should
-/// carry additional values along with it.
-/**
- * This completion token adapter is typically used to keep at least one copy of
- * an object, such as a smart pointer, alive until the completion handler is
- * called.
- */
-template <typename CompletionToken, typename... Values>
-ASIO_NODISCARD inline constexpr
-consign_t<decay_t<CompletionToken>, decay_t<Values>...>
-consign(CompletionToken&& completion_token, Values&&... values)
-{
-  return consign_t<decay_t<CompletionToken>, decay_t<Values>...>(
-      static_cast<CompletionToken&&>(completion_token),
-      static_cast<Values&&>(values)...);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/consign.hpp"
-
-#endif // ASIO_CONSIGN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/coroutine.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/coroutine.hpp
deleted file mode 100644
index 122d76a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/coroutine.hpp
+++ /dev/null
@@ -1,328 +0,0 @@
-//
-// coroutine.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_COROUTINE_HPP
-#define ASIO_COROUTINE_HPP
-
-namespace asio {
-namespace detail {
-
-class coroutine_ref;
-
-} // namespace detail
-
-/// Provides support for implementing stackless coroutines.
-/**
- * The @c coroutine class may be used to implement stackless coroutines. The
- * class itself is used to store the current state of the coroutine.
- *
- * Coroutines are copy-constructible and assignable, and the space overhead is
- * a single int. They can be used as a base class:
- *
- * @code class session : coroutine
- * {
- *   ...
- * }; @endcode
- *
- * or as a data member:
- *
- * @code class session
- * {
- *   ...
- *   coroutine coro_;
- * }; @endcode
- *
- * or even bound in as a function argument using lambdas or @c bind(). The
- * important thing is that as the application maintains a copy of the object
- * for as long as the coroutine must be kept alive.
- *
- * @par Pseudo-keywords
- *
- * A coroutine is used in conjunction with certain "pseudo-keywords", which
- * are implemented as macros. These macros are defined by a header file:
- *
- * @code #include <asio/yield.hpp>@endcode
- *
- * and may conversely be undefined as follows:
- *
- * @code #include <asio/unyield.hpp>@endcode
- *
- * <b>reenter</b>
- *
- * The @c reenter macro is used to define the body of a coroutine. It takes a
- * single argument: a pointer or reference to a coroutine object. For example,
- * if the base class is a coroutine object you may write:
- *
- * @code reenter (this)
- * {
- *   ... coroutine body ...
- * } @endcode
- *
- * and if a data member or other variable you can write:
- *
- * @code reenter (coro_)
- * {
- *   ... coroutine body ...
- * } @endcode
- *
- * When @c reenter is executed at runtime, control jumps to the location of the
- * last @c yield or @c fork.
- *
- * The coroutine body may also be a single statement, such as:
- *
- * @code reenter (this) for (;;)
- * {
- *   ...
- * } @endcode
- *
- * @b Limitation: The @c reenter macro is implemented using a switch. This
- * means that you must take care when using local variables within the
- * coroutine body. The local variable is not allowed in a position where
- * reentering the coroutine could bypass the variable definition.
- *
- * <b>yield <em>statement</em></b>
- *
- * This form of the @c yield keyword is often used with asynchronous operations:
- *
- * @code yield socket_->async_read_some(buffer(*buffer_), *this); @endcode
- *
- * This divides into four logical steps:
- *
- * @li @c yield saves the current state of the coroutine.
- * @li The statement initiates the asynchronous operation.
- * @li The resume point is defined immediately following the statement.
- * @li Control is transferred to the end of the coroutine body.
- *
- * When the asynchronous operation completes, the function object is invoked
- * and @c reenter causes control to transfer to the resume point. It is
- * important to remember to carry the coroutine state forward with the
- * asynchronous operation. In the above snippet, the current class is a
- * function object object with a coroutine object as base class or data member.
- *
- * The statement may also be a compound statement, and this permits us to
- * define local variables with limited scope:
- *
- * @code yield
- * {
- *   mutable_buffers_1 b = buffer(*buffer_);
- *   socket_->async_read_some(b, *this);
- * } @endcode
- *
- * <b>yield return <em>expression</em> ;</b>
- *
- * This form of @c yield is often used in generators or coroutine-based parsers.
- * For example, the function object:
- *
- * @code struct interleave : coroutine
- * {
- *   istream& is1;
- *   istream& is2;
- *   char operator()(char c)
- *   {
- *     reenter (this) for (;;)
- *     {
- *       yield return is1.get();
- *       yield return is2.get();
- *     }
- *   }
- * }; @endcode
- *
- * defines a trivial coroutine that interleaves the characters from two input
- * streams.
- *
- * This type of @c yield divides into three logical steps:
- *
- * @li @c yield saves the current state of the coroutine.
- * @li The resume point is defined immediately following the semicolon.
- * @li The value of the expression is returned from the function.
- *
- * <b>yield ;</b>
- *
- * This form of @c yield is equivalent to the following steps:
- *
- * @li @c yield saves the current state of the coroutine.
- * @li The resume point is defined immediately following the semicolon.
- * @li Control is transferred to the end of the coroutine body.
- *
- * This form might be applied when coroutines are used for cooperative
- * threading and scheduling is explicitly managed. For example:
- *
- * @code struct task : coroutine
- * {
- *   ...
- *   void operator()()
- *   {
- *     reenter (this)
- *     {
- *       while (... not finished ...)
- *       {
- *         ... do something ...
- *         yield;
- *         ... do some more ...
- *         yield;
- *       }
- *     }
- *   }
- *   ...
- * };
- * ...
- * task t1, t2;
- * for (;;)
- * {
- *   t1();
- *   t2();
- * } @endcode
- *
- * <b>yield break ;</b>
- *
- * The final form of @c yield is used to explicitly terminate the coroutine.
- * This form is comprised of two steps:
- *
- * @li @c yield sets the coroutine state to indicate termination.
- * @li Control is transferred to the end of the coroutine body.
- *
- * Once terminated, calls to is_complete() return true and the coroutine cannot
- * be reentered.
- *
- * Note that a coroutine may also be implicitly terminated if the coroutine
- * body is exited without a yield, e.g. by return, throw or by running to the
- * end of the body.
- *
- * <b>fork <em>statement</em></b>
- *
- * The @c fork pseudo-keyword is used when "forking" a coroutine, i.e. splitting
- * it into two (or more) copies. One use of @c fork is in a server, where a new
- * coroutine is created to handle each client connection:
- *
- * @code reenter (this)
- * {
- *   do
- *   {
- *     socket_.reset(new tcp::socket(my_context_));
- *     yield acceptor->async_accept(*socket_, *this);
- *     fork server(*this)();
- *   } while (is_parent());
- *   ... client-specific handling follows ...
- * } @endcode
- *
- * The logical steps involved in a @c fork are:
- *
- * @li @c fork saves the current state of the coroutine.
- * @li The statement creates a copy of the coroutine and either executes it
- *     immediately or schedules it for later execution.
- * @li The resume point is defined immediately following the semicolon.
- * @li For the "parent", control immediately continues from the next line.
- *
- * The functions is_parent() and is_child() can be used to differentiate
- * between parent and child. You would use these functions to alter subsequent
- * control flow.
- *
- * Note that @c fork doesn't do the actual forking by itself. It is the
- * application's responsibility to create a clone of the coroutine and call it.
- * The clone can be called immediately, as above, or scheduled for delayed
- * execution using something like asio::post().
- *
- * @par Alternate macro names
- *
- * If preferred, an application can use macro names that follow a more typical
- * naming convention, rather than the pseudo-keywords. These are:
- *
- * @li @c ASIO_CORO_REENTER instead of @c reenter
- * @li @c ASIO_CORO_YIELD instead of @c yield
- * @li @c ASIO_CORO_FORK instead of @c fork
- */
-class coroutine
-{
-public:
-  /// Constructs a coroutine in its initial state.
-  coroutine() : value_(0) {}
-
-  /// Returns true if the coroutine is the child of a fork.
-  bool is_child() const { return value_ < 0; }
-
-  /// Returns true if the coroutine is the parent of a fork.
-  bool is_parent() const { return !is_child(); }
-
-  /// Returns true if the coroutine has reached its terminal state.
-  bool is_complete() const { return value_ == -1; }
-
-private:
-  friend class detail::coroutine_ref;
-  int value_;
-};
-
-namespace detail {
-
-class coroutine_ref
-{
-public:
-  coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
-  coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
-  coroutine_ref(const coroutine_ref&) = default;
-  ~coroutine_ref() { if (!modified_) value_ = -1; }
-  operator int() const { return value_; }
-  int& operator=(int v) { modified_ = true; return value_ = v; }
-private:
-  void operator=(const coroutine_ref&);
-  int& value_;
-  bool modified_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#define ASIO_CORO_REENTER(c) \
-  switch (::asio::detail::coroutine_ref _coro_value = c) \
-    case -1: if (_coro_value) \
-    { \
-      goto terminate_coroutine; \
-      terminate_coroutine: \
-      _coro_value = -1; \
-      goto bail_out_of_coroutine; \
-      bail_out_of_coroutine: \
-      break; \
-    } \
-    else /* fall-through */ case 0:
-
-#define ASIO_CORO_YIELD_IMPL(n) \
-  for (_coro_value = (n);;) \
-    if (_coro_value == 0) \
-    { \
-      case (n): ; \
-      break; \
-    } \
-    else \
-      switch (_coro_value ? 0 : 1) \
-        for (;;) \
-          /* fall-through */ case -1: if (_coro_value) \
-            goto terminate_coroutine; \
-          else for (;;) \
-            /* fall-through */ case 1: if (_coro_value) \
-              goto bail_out_of_coroutine; \
-            else /* fall-through */ case 0:
-
-#define ASIO_CORO_FORK_IMPL(n) \
-  for (_coro_value = -(n);; _coro_value = (n)) \
-    if (_coro_value == (n)) \
-    { \
-      case -(n): ; \
-      break; \
-    } \
-    else
-
-#if defined(_MSC_VER)
-# define ASIO_CORO_YIELD ASIO_CORO_YIELD_IMPL(__COUNTER__ + 1)
-# define ASIO_CORO_FORK ASIO_CORO_FORK_IMPL(__COUNTER__ + 1)
-#else // defined(_MSC_VER)
-# define ASIO_CORO_YIELD ASIO_CORO_YIELD_IMPL(__LINE__)
-# define ASIO_CORO_FORK ASIO_CORO_FORK_IMPL(__LINE__)
-#endif // defined(_MSC_VER)
-
-#endif // ASIO_COROUTINE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deadline_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deadline_timer.hpp
deleted file mode 100644
index dfa0b9c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deadline_timer.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// deadline_timer.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEADLINE_TIMER_HPP
-#define ASIO_DEADLINE_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/socket_types.hpp" // Must come before posix_time.
-#include "asio/basic_deadline_timer.hpp"
-
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-
-namespace asio {
-
-/// Typedef for the typical usage of timer. Uses a UTC clock.
-typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_DEADLINE_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/default_completion_token.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/default_completion_token.hpp
deleted file mode 100644
index 92d2a17..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/default_completion_token.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// default_completion_token.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEFAULT_COMPLETION_TOKEN_HPP
-#define ASIO_DEFAULT_COMPLETION_TOKEN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class deferred_t;
-
-namespace detail {
-
-template <typename T, typename = void>
-struct default_completion_token_impl
-{
-  typedef deferred_t type;
-};
-
-template <typename T>
-struct default_completion_token_impl<T,
-    void_t<typename T::default_completion_token_type>
-  >
-{
-  typedef typename T::default_completion_token_type type;
-};
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// Traits type used to determine the default completion token type associated
-/// with a type (such as an executor).
-/**
- * A program may specialise this traits type if the @c T template parameter in
- * the specialisation is a user-defined type.
- *
- * Specialisations of this trait may provide a nested typedef @c type, which is
- * a default-constructible completion token type.
- *
- * If not otherwise specialised, the default completion token type is
- * asio::deferred_t.
- */
-template <typename T>
-struct default_completion_token
-{
-  /// If @c T has a nested type @c default_completion_token_type,
-  /// <tt>T::default_completion_token_type</tt>. Otherwise the typedef @c type
-  /// is asio::deferred_t.
-  typedef see_below type;
-};
-#else
-template <typename T>
-struct default_completion_token
-  : detail::default_completion_token_impl<T>
-{
-};
-#endif
-
-template <typename T>
-using default_completion_token_t = typename default_completion_token<T>::type;
-
-#define ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e) \
-  = typename ::asio::default_completion_token<e>::type
-#define ASIO_DEFAULT_COMPLETION_TOKEN(e) \
-  = typename ::asio::default_completion_token<e>::type()
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/deferred.hpp"
-
-#endif // ASIO_DEFAULT_COMPLETION_TOKEN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/defer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/defer.hpp
deleted file mode 100644
index 608debe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/defer.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-//
-// defer.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEFER_HPP
-#define ASIO_DEFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiate_defer.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the object's associated
- * executor. The function object is queued for execution, and is never called
- * from the current thread prior to returning from <tt>defer()</tt>.
- *
- * The use of @c defer(), rather than @ref post(), indicates the caller's
- * preference that the executor defer the queueing of the function object. This
- * may allow the executor to optimise queueing for cases when the function
- * object represents a continuation of the current call context.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
- * as:
- *
- * @code class Init
- * {
- * public:
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex of type @c Ex by
- * performing @code auto ex = get_associated_executor(handler); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(
- *     require(ex, execution::blocking.never),
- *     execution::relationship.continuation,
- *     execution::allocator(alloc)
- *   ).execute(std::forward<CompletionHandler>(completion_handler)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.defer(
- *     std::forward<CompletionHandler>(completion_handler),
- *     alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
-auto defer(NullaryToken&& token)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_defer>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_defer(), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the specified executor.
- * The function object is queued for execution, and is never called from the
- * current thread prior to returning from <tt>defer()</tt>.
- *
- * The use of @c defer(), rather than @ref post(), indicates the caller's
- * preference that the executor defer the queueing of the function object. This
- * may allow the executor to optimise queueing for cases when the function
- * object represents a continuation of the current call context.
- *
- * @param ex The target executor.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
- * defined as:
- *
- * @code class Init
- * {
- * public:
- *   using executor_type = Executor;
- *   explicit Init(const Executor& ex) : ex_(ex) {}
- *   executor_type get_executor() const noexcept { return ex_; }
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * private:
- *   Executor ex_; // exposition only
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
- * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
- * function object @c f with a member @c executor_ that is initialised with
- * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
- * handler_ that is a decay-copy of @c completion_handler, and a function call
- * operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
- * @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
- * function object @c f with a member @c work_ that is initialised with
- * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
- * @c completion_handler, and a function call operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * work_.get_executor().dispatch(std::move(handler_), a);
- * work_.reset(); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(
- *     require(ex, execution::blocking.never),
- *     execution::relationship.continuation,
- *     execution::allocator(alloc)
- *   ).execute(std::move(f)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.defer(std::move(f), alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename Executor,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<Executor>>
-auto defer(const Executor& ex,
-    NullaryToken&& token
-      = default_completion_token_t<Executor>(),
-    constraint_t<
-      (execution::is_executor<Executor>::value
-          && can_require<Executor, execution::blocking_t::never_t>::value)
-        || is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_defer_with_executor<Executor>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_defer_with_executor<Executor>(ex), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * @param ctx An execution context, from which the target executor is obtained.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns <tt>defer(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename ExecutionContext,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<typename ExecutionContext::executor_type>>
-auto defer(ExecutionContext& ctx,
-    NullaryToken&& token
-      = default_completion_token_t<typename ExecutionContext::executor_type>(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_defer_with_executor<
-        typename ExecutionContext::executor_type>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_defer_with_executor<
-        typename ExecutionContext::executor_type>(
-          ctx.get_executor()), token);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DEFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deferred.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deferred.hpp
deleted file mode 100644
index c12a0e8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/deferred.hpp
+++ /dev/null
@@ -1,719 +0,0 @@
-//
-// deferred.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEFERRED_HPP
-#define ASIO_DEFERRED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Trait for detecting objects that are usable as deferred operations.
-template <typename T>
-struct is_deferred : false_type
-{
-};
-
-/// Helper type to wrap multiple completion signatures.
-template <typename... Signatures>
-struct deferred_signatures
-{
-};
-
-namespace detail {
-
-// Helper trait for getting the completion signatures of the tail in a sequence
-// when invoked with the specified arguments.
-
-template <typename Tail, typename... Signatures>
-struct deferred_sequence_signatures;
-
-template <typename Tail, typename R, typename... Args, typename... Signatures>
-struct deferred_sequence_signatures<Tail, R(Args...), Signatures...>
-  : completion_signature_of<decltype(declval<Tail>()(declval<Args>()...))>
-{
-  static_assert(
-      !is_same<decltype(declval<Tail>()(declval<Args>()...)), void>::value,
-      "deferred functions must produce a deferred return type");
-};
-
-// Completion handler for the head component of a deferred sequence.
-template <typename Handler, typename Tail>
-class deferred_sequence_handler
-{
-public:
-  template <typename H, typename T>
-  explicit deferred_sequence_handler(H&& handler, T&& tail)
-    : handler_(static_cast<H&&>(handler)),
-      tail_(static_cast<T&&>(tail))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    static_cast<Tail&&>(tail_)(
-        static_cast<Args&&>(args)...)(
-          static_cast<Handler&&>(handler_));
-  }
-
-//private:
-  Handler handler_;
-  Tail tail_;
-};
-
-template <typename Head, typename Tail, typename... Signatures>
-class deferred_sequence_base
-{
-private:
-  struct initiate
-  {
-    template <typename Handler>
-    void operator()(Handler&& handler, Head head, Tail&& tail)
-    {
-      static_cast<Head&&>(head)(
-          deferred_sequence_handler<decay_t<Handler>, decay_t<Tail>>(
-            static_cast<Handler&&>(handler), static_cast<Tail&&>(tail)));
-    }
-  };
-
-  Head head_;
-  Tail tail_;
-
-public:
-  template <typename H, typename T>
-  constexpr explicit deferred_sequence_base(H&& head, T&& tail)
-    : head_(static_cast<H&&>(head)),
-      tail_(static_cast<T&&>(tail))
-  {
-  }
-
-  template <ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
-  auto operator()(CompletionToken&& token) &&
-    -> decltype(
-      async_initiate<CompletionToken, Signatures...>(
-        initiate(), token, static_cast<Head&&>(this->head_),
-        static_cast<Tail&&>(this->tail_)))
-  {
-    return async_initiate<CompletionToken, Signatures...>(initiate(),
-        token, static_cast<Head&&>(head_), static_cast<Tail&&>(tail_));
-  }
-
-  template <ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
-  auto operator()(CompletionToken&& token) const &
-    -> decltype(
-      async_initiate<CompletionToken, Signatures...>(
-        initiate(), token, this->head_, this->tail_))
-  {
-    return async_initiate<CompletionToken, Signatures...>(
-        initiate(), token, head_, tail_);
-  }
-};
-
-// Two-step application of variadic Signatures to determine correct base type.
-
-template <typename Head, typename Tail>
-struct deferred_sequence_types
-{
-  template <typename... Signatures>
-  struct op1
-  {
-    typedef deferred_sequence_base<Head, Tail, Signatures...> type;
-  };
-
-  template <typename... Signatures>
-  struct op2
-  {
-    typedef typename deferred_sequence_signatures<Tail, Signatures...>::template
-      apply<op1>::type::type type;
-  };
-
-  typedef typename completion_signature_of<Head>::template
-    apply<op2>::type::type base;
-};
-
-} // namespace detail
-
-/// Used to represent an empty deferred action.
-struct deferred_noop
-{
-  /// No effect.
-  template <typename... Args>
-  void operator()(Args&&...) &&
-  {
-  }
-
-  /// No effect.
-  template <typename... Args>
-  void operator()(Args&&...) const &
-  {
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <>
-struct is_deferred<deferred_noop> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Tag type to disambiguate deferred constructors.
-struct deferred_init_tag {};
-
-/// Wraps a function object so that it may be used as an element in a deferred
-/// composition.
-template <typename Function>
-class deferred_function
-{
-public:
-  /// Constructor.
-  template <typename F>
-  constexpr explicit deferred_function(deferred_init_tag, F&& function)
-    : function_(static_cast<F&&>(function))
-  {
-  }
-
-//private:
-  Function function_;
-
-public:
-  template <typename... Args>
-  auto operator()(Args&&... args) &&
-    -> decltype(
-      static_cast<Function&&>(this->function_)(static_cast<Args&&>(args)...))
-  {
-    return static_cast<Function&&>(function_)(static_cast<Args&&>(args)...);
-  }
-
-  template <typename... Args>
-  auto operator()(Args&&... args) const &
-    -> decltype(Function(function_)(static_cast<Args&&>(args)...))
-  {
-    return Function(function_)(static_cast<Args&&>(args)...);
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Function>
-struct is_deferred<deferred_function<Function>> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Encapsulates deferred values.
-template <typename... Values>
-class ASIO_NODISCARD deferred_values
-{
-private:
-  std::tuple<Values...> values_;
-
-  struct initiate
-  {
-    template <typename Handler, typename... V>
-    void operator()(Handler handler, V&&... values)
-    {
-      static_cast<Handler&&>(handler)(static_cast<V&&>(values)...);
-    }
-  };
-
-  template <typename CompletionToken, std::size_t... I>
-  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
-    -> decltype(
-      async_initiate<CompletionToken, void(Values...)>(initiate(), token,
-        std::get<I>(static_cast<std::tuple<Values...>&&>(this->values_))...))
-  {
-    return async_initiate<CompletionToken, void(Values...)>(initiate(), token,
-        std::get<I>(static_cast<std::tuple<Values...>&&>(values_))...);
-  }
-
-  template <typename CompletionToken, std::size_t... I>
-  auto const_invoke_helper(CompletionToken&& token,
-      detail::index_sequence<I...>)
-    -> decltype(
-      async_initiate<CompletionToken, void(Values...)>(
-        initiate(), token, std::get<I>(values_)...))
-  {
-    return async_initiate<CompletionToken, void(Values...)>(
-        initiate(), token, std::get<I>(values_)...);
-  }
-
-public:
-  /// Construct a deferred asynchronous operation from the arguments to an
-  /// initiation function object.
-  template <typename... V>
-  constexpr explicit deferred_values(
-      deferred_init_tag, V&&... values)
-    : values_(static_cast<V&&>(values)...)
-  {
-  }
-
-  /// Initiate the deferred operation using the supplied completion token.
-  template <ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
-  auto operator()(CompletionToken&& token) &&
-    -> decltype(
-      this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<Values...>()))
-  {
-    return this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<Values...>());
-  }
-
-  template <ASIO_COMPLETION_TOKEN_FOR(void(Values...)) CompletionToken>
-  auto operator()(CompletionToken&& token) const &
-    -> decltype(
-      this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<Values...>()))
-  {
-    return this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<Values...>());
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename... Values>
-struct is_deferred<deferred_values<Values...>> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Encapsulates a deferred asynchronous operation.
-template <typename Signature, typename Initiation, typename... InitArgs>
-class ASIO_NODISCARD deferred_async_operation
-{
-private:
-  typedef decay_t<Initiation> initiation_t;
-  initiation_t initiation_;
-  typedef std::tuple<decay_t<InitArgs>...> init_args_t;
-  init_args_t init_args_;
-
-  template <typename CompletionToken, std::size_t... I>
-  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
-    -> decltype(
-      async_initiate<CompletionToken, Signature>(
-        static_cast<initiation_t&&>(initiation_), token,
-        std::get<I>(static_cast<init_args_t&&>(init_args_))...))
-  {
-    return async_initiate<CompletionToken, Signature>(
-        static_cast<initiation_t&&>(initiation_), token,
-        std::get<I>(static_cast<init_args_t&&>(init_args_))...);
-  }
-
-  template <typename CompletionToken, std::size_t... I>
-  auto const_invoke_helper(CompletionToken&& token,
-      detail::index_sequence<I...>) const &
-    -> decltype(
-      async_initiate<CompletionToken, Signature>(
-        conditional_t<true, initiation_t, CompletionToken>(initiation_),
-        token, std::get<I>(init_args_)...))
-  {
-    return async_initiate<CompletionToken, Signature>(
-        initiation_t(initiation_), token, std::get<I>(init_args_)...);
-  }
-
-public:
-  /// Construct a deferred asynchronous operation from the arguments to an
-  /// initiation function object.
-  template <typename I, typename... A>
-  constexpr explicit deferred_async_operation(
-      deferred_init_tag, I&& initiation, A&&... init_args)
-    : initiation_(static_cast<I&&>(initiation)),
-      init_args_(static_cast<A&&>(init_args)...)
-  {
-  }
-
-  /// Initiate the asynchronous operation using the supplied completion token.
-  template <ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
-  auto operator()(CompletionToken&& token) &&
-    -> decltype(
-      this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>()))
-  {
-    return this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>());
-  }
-
-  template <ASIO_COMPLETION_TOKEN_FOR(Signature) CompletionToken>
-  auto operator()(CompletionToken&& token) const &
-    -> decltype(
-      this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>()))
-  {
-    return this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>());
-  }
-};
-
-/// Encapsulates a deferred asynchronous operation thas has multiple completion
-/// signatures.
-template <typename... Signatures, typename Initiation, typename... InitArgs>
-class ASIO_NODISCARD deferred_async_operation<
-    deferred_signatures<Signatures...>, Initiation, InitArgs...>
-{
-private:
-  typedef decay_t<Initiation> initiation_t;
-  initiation_t initiation_;
-  typedef std::tuple<decay_t<InitArgs>...> init_args_t;
-  init_args_t init_args_;
-
-  template <typename CompletionToken, std::size_t... I>
-  auto invoke_helper(CompletionToken&& token, detail::index_sequence<I...>)
-    -> decltype(
-      async_initiate<CompletionToken, Signatures...>(
-        static_cast<initiation_t&&>(initiation_), token,
-        std::get<I>(static_cast<init_args_t&&>(init_args_))...))
-  {
-    return async_initiate<CompletionToken, Signatures...>(
-        static_cast<initiation_t&&>(initiation_), token,
-        std::get<I>(static_cast<init_args_t&&>(init_args_))...);
-  }
-
-  template <typename CompletionToken, std::size_t... I>
-  auto const_invoke_helper(CompletionToken&& token,
-      detail::index_sequence<I...>) const &
-    -> decltype(
-      async_initiate<CompletionToken, Signatures...>(
-        initiation_t(initiation_), token, std::get<I>(init_args_)...))
-  {
-    return async_initiate<CompletionToken, Signatures...>(
-        initiation_t(initiation_), token, std::get<I>(init_args_)...);
-  }
-
-public:
-  /// Construct a deferred asynchronous operation from the arguments to an
-  /// initiation function object.
-  template <typename I, typename... A>
-  constexpr explicit deferred_async_operation(
-      deferred_init_tag, I&& initiation, A&&... init_args)
-    : initiation_(static_cast<I&&>(initiation)),
-      init_args_(static_cast<A&&>(init_args)...)
-  {
-  }
-
-  /// Initiate the asynchronous operation using the supplied completion token.
-  template <ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
-  auto operator()(CompletionToken&& token) &&
-    -> decltype(
-      this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>()))
-  {
-    return this->invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>());
-  }
-
-  template <ASIO_COMPLETION_TOKEN_FOR(Signatures...) CompletionToken>
-  auto operator()(CompletionToken&& token) const &
-    -> decltype(
-      this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>()))
-  {
-    return this->const_invoke_helper(
-        static_cast<CompletionToken&&>(token),
-        detail::index_sequence_for<InitArgs...>());
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Signature, typename Initiation, typename... InitArgs>
-struct is_deferred<
-    deferred_async_operation<Signature, Initiation, InitArgs...>> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Defines a link between two consecutive operations in a sequence.
-template <typename Head, typename Tail>
-class ASIO_NODISCARD deferred_sequence :
-  public detail::deferred_sequence_types<Head, Tail>::base
-{
-public:
-  template <typename H, typename T>
-  constexpr explicit deferred_sequence(deferred_init_tag, H&& head, T&& tail)
-    : detail::deferred_sequence_types<Head, Tail>::base(
-        static_cast<H&&>(head), static_cast<T&&>(tail))
-  {
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-  template <typename CompletionToken>
-  auto operator()(CompletionToken&& token) &&;
-
-  template <typename CompletionToken>
-  auto operator()(CompletionToken&& token) const &;
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Head, typename Tail>
-struct is_deferred<deferred_sequence<Head, Tail>> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Used to represent a deferred conditional branch.
-template <typename OnTrue = deferred_noop, typename OnFalse = deferred_noop>
-class ASIO_NODISCARD deferred_conditional
-{
-private:
-  template <typename T, typename F> friend class deferred_conditional;
-
-  // Helper constructor.
-  template <typename T, typename F>
-  explicit deferred_conditional(bool b, T&& on_true, F&& on_false)
-    : on_true_(static_cast<T&&>(on_true)),
-      on_false_(static_cast<F&&>(on_false)),
-      bool_(b)
-  {
-  }
-
-  OnTrue on_true_;
-  OnFalse on_false_;
-  bool bool_;
-
-public:
-  /// Construct a deferred conditional with the value to determine which branch
-  /// will be executed.
-  constexpr explicit deferred_conditional(bool b)
-    : on_true_(),
-      on_false_(),
-      bool_(b)
-  {
-  }
-
-  /// Invoke the conditional branch bsaed on the stored value.
-  template <typename... Args>
-  auto operator()(Args&&... args) &&
-    -> decltype(static_cast<OnTrue&&>(on_true_)(static_cast<Args&&>(args)...))
-  {
-    if (bool_)
-    {
-      return static_cast<OnTrue&&>(on_true_)(static_cast<Args&&>(args)...);
-    }
-    else
-    {
-      return static_cast<OnFalse&&>(on_false_)(static_cast<Args&&>(args)...);
-    }
-  }
-
-  template <typename... Args>
-  auto operator()(Args&&... args) const &
-    -> decltype(on_true_(static_cast<Args&&>(args)...))
-  {
-    if (bool_)
-    {
-      return on_true_(static_cast<Args&&>(args)...);
-    }
-    else
-    {
-      return on_false_(static_cast<Args&&>(args)...);
-    }
-  }
-
-  /// Set the true branch of the conditional.
-  template <typename T>
-  deferred_conditional<T, OnFalse> then(T on_true,
-      constraint_t<
-        is_deferred<T>::value
-      >* = 0,
-      constraint_t<
-        is_same<
-          conditional_t<true, OnTrue, T>,
-          deferred_noop
-        >::value
-      >* = 0) &&
-  {
-    return deferred_conditional<T, OnFalse>(
-        bool_, static_cast<T&&>(on_true),
-        static_cast<OnFalse&&>(on_false_));
-  }
-
-  /// Set the false branch of the conditional.
-  template <typename T>
-  deferred_conditional<OnTrue, T> otherwise(T on_false,
-      constraint_t<
-        is_deferred<T>::value
-      >* = 0,
-      constraint_t<
-        !is_same<
-          conditional_t<true, OnTrue, T>,
-          deferred_noop
-        >::value
-      >* = 0,
-      constraint_t<
-        is_same<
-          conditional_t<true, OnFalse, T>,
-          deferred_noop
-        >::value
-      >* = 0) &&
-  {
-    return deferred_conditional<OnTrue, T>(
-        bool_, static_cast<OnTrue&&>(on_true_),
-        static_cast<T&&>(on_false));
-  }
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename OnTrue, typename OnFalse>
-struct is_deferred<deferred_conditional<OnTrue, OnFalse>> : true_type
-{
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Class used to specify that an asynchronous operation should return a
-/// function object to lazily launch the operation.
-/**
- * The deferred_t class is used to indicate that an asynchronous operation
- * should return a function object which is itself an initiation function. A
- * deferred_t object may be passed as a completion token to an asynchronous
- * operation, typically as the default completion token:
- *
- * @code auto my_deferred_op = my_socket.async_read_some(my_buffer); @endcode
- *
- * or by explicitly passing the special value @c asio::deferred:
- *
- * @code auto my_deferred_op
- *   = my_socket.async_read_some(my_buffer,
- *       asio::deferred); @endcode
- *
- * The initiating function (async_read_some in the above example) returns a
- * function object that will lazily initiate the operation.
- */
-class deferred_t
-{
-public:
-  /// Default constructor.
-  constexpr deferred_t()
-  {
-  }
-
-  /// Adapts an executor to add the @c deferred_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c deferred_t as the default completion token type.
-    typedef deferred_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    template <typename InnerExecutor1>
-    executor_with_default(const InnerExecutor1& ex,
-        constraint_t<
-          conditional_t<
-            !is_same<InnerExecutor1, executor_with_default>::value,
-            is_convertible<InnerExecutor1, InnerExecutor>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c deferred_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c deferred_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-  /// Creates a new deferred from a function.
-  template <typename Function>
-  constraint_t<
-    !is_deferred<decay_t<Function>>::value,
-    deferred_function<decay_t<Function>>
-  > operator()(Function&& function) const
-  {
-    return deferred_function<decay_t<Function>>(
-        deferred_init_tag{}, static_cast<Function&&>(function));
-  }
-
-  /// Passes through anything that is already deferred.
-  template <typename T>
-  constraint_t<
-    is_deferred<decay_t<T>>::value,
-    decay_t<T>
-  > operator()(T&& t) const
-  {
-    return static_cast<T&&>(t);
-  }
-
-  /// Returns a deferred operation that returns the provided values.
-  template <typename... Args>
-  static constexpr deferred_values<decay_t<Args>...> values(Args&&... args)
-  {
-    return deferred_values<decay_t<Args>...>(
-        deferred_init_tag{}, static_cast<Args&&>(args)...);
-  }
-
-  /// Creates a conditional object for branching deferred operations.
-  static constexpr deferred_conditional<> when(bool b)
-  {
-    return deferred_conditional<>(b);
-  }
-};
-
-/// Pipe operator used to chain deferred operations.
-template <typename Head, typename Tail>
-inline auto operator|(Head head, Tail&& tail)
-  -> constraint_t<
-      is_deferred<Head>::value,
-      decltype(static_cast<Head&&>(head)(static_cast<Tail&&>(tail)))
-    >
-{
-  return static_cast<Head&&>(head)(static_cast<Tail&&>(tail));
-}
-
-/// A @ref completion_token object used to specify that an asynchronous
-/// operation should return a function object to lazily launch the operation.
-/**
- * See the documentation for asio::deferred_t for a usage example.
- */
-constexpr deferred_t deferred;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/deferred.hpp"
-
-#endif // ASIO_DEFERRED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detached.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detached.hpp
deleted file mode 100644
index 0709455..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detached.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//
-// detached.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETACHED_HPP
-#define ASIO_DETACHED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <memory>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token type used to specify that an asynchronous operation
-/// is detached.
-/**
- * The detached_t class is used to indicate that an asynchronous operation is
- * detached. That is, there is no completion handler waiting for the
- * operation's result. A detached_t object may be passed as a handler to an
- * asynchronous operation, typically using the special value
- * @c asio::detached. For example:
- *
- * @code my_socket.async_send(my_buffer, asio::detached);
- * @endcode
- */
-class detached_t
-{
-public:
-  /// Constructor.
-  constexpr detached_t()
-  {
-  }
-
-  /// Adapts an executor to add the @c detached_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c detached_t as the default completion token type.
-    typedef detached_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    executor_with_default(const InnerExecutor& ex) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-
-    /// Convert the specified executor to the inner executor type, then use
-    /// that to construct the adapted executor.
-    template <typename OtherExecutor>
-    executor_with_default(const OtherExecutor& ex,
-        constraint_t<
-          is_convertible<OtherExecutor, InnerExecutor>::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c detached_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c detached_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-};
-
-/// A @ref completion_token object used to specify that an asynchronous
-/// operation is detached.
-/**
- * See the documentation for asio::detached_t for a usage example.
- */
-constexpr detached_t detached;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/detached.hpp"
-
-#endif // ASIO_DETACHED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array.hpp
deleted file mode 100644
index f2015c7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// detail/array.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ARRAY_HPP
-#define ASIO_DETAIL_ARRAY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <array>
-
-namespace asio {
-namespace detail {
-
-using std::array;
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_ARRAY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array_fwd.hpp
deleted file mode 100644
index 7949134..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/array_fwd.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// detail/array_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ARRAY_FWD_HPP
-#define ASIO_DETAIL_ARRAY_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-namespace boost {
-
-template<class T, std::size_t N>
-class array;
-
-} // namespace boost
-
-// Standard library components can't be forward declared, so we'll have to
-// include the array header. Fortunately, it's fairly lightweight and doesn't
-// add significantly to the compile time.
-#include <array>
-
-#endif // ASIO_DETAIL_ARRAY_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/assert.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/assert.hpp
deleted file mode 100644
index b53774d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/assert.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// detail/assert.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ASSERT_HPP
-#define ASIO_DETAIL_ASSERT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_ASSERT)
-# include <boost/assert.hpp>
-#else // defined(ASIO_HAS_BOOST_ASSERT)
-# include <cassert>
-#endif // defined(ASIO_HAS_BOOST_ASSERT)
-
-#if defined(ASIO_HAS_BOOST_ASSERT)
-# define ASIO_ASSERT(expr) BOOST_ASSERT(expr)
-#else // defined(ASIO_HAS_BOOST_ASSERT)
-# define ASIO_ASSERT(expr) assert(expr)
-#endif // defined(ASIO_HAS_BOOST_ASSERT)
-
-#endif // ASIO_DETAIL_ASSERT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/atomic_count.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/atomic_count.hpp
deleted file mode 100644
index 6116279..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/atomic_count.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// detail/atomic_count.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ATOMIC_COUNT_HPP
-#define ASIO_DETAIL_ATOMIC_COUNT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-// Nothing to include.
-#else // !defined(ASIO_HAS_THREADS)
-# include <atomic>
-#endif // !defined(ASIO_HAS_THREADS)
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS)
-typedef long atomic_count;
-inline void increment(atomic_count& a, long b) { a += b; }
-inline void decrement(atomic_count& a, long b) { a -= b; }
-inline void ref_count_up(atomic_count& a) { ++a; }
-inline bool ref_count_down(atomic_count& a) { return --a == 0; }
-#else // !defined(ASIO_HAS_THREADS)
-typedef std::atomic<long> atomic_count;
-inline void increment(atomic_count& a, long b) { a += b; }
-inline void decrement(atomic_count& a, long b) { a -= b; }
-
-inline void ref_count_up(atomic_count& a)
-{
-  a.fetch_add(1, std::memory_order_relaxed);
-}
-
-inline bool ref_count_down(atomic_count& a)
-{
-  if (a.fetch_sub(1, std::memory_order_release) == 1)
-  {
-    std::atomic_thread_fence(std::memory_order_acquire);
-    return true;
-  }
-  return false;
-}
-#endif // !defined(ASIO_HAS_THREADS)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_ATOMIC_COUNT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_cancellation_state.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_cancellation_state.hpp
deleted file mode 100644
index 3ce7dcf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_cancellation_state.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//
-// detail/base_from_cancellation_state.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
-#define ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename = void>
-class base_from_cancellation_state
-{
-public:
-  typedef cancellation_slot cancellation_slot_type;
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancellation_state_.slot();
-  }
-
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return cancellation_state_;
-  }
-
-protected:
-  explicit base_from_cancellation_state(const Handler& handler)
-    : cancellation_state_(
-        asio::get_associated_cancellation_slot(handler))
-  {
-  }
-
-  template <typename Filter>
-  base_from_cancellation_state(const Handler& handler, Filter filter)
-    : cancellation_state_(
-        asio::get_associated_cancellation_slot(handler), filter, filter)
-  {
-  }
-
-  template <typename InFilter, typename OutFilter>
-  base_from_cancellation_state(const Handler& handler,
-      InFilter&& in_filter,
-      OutFilter&& out_filter)
-    : cancellation_state_(
-        asio::get_associated_cancellation_slot(handler),
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter))
-  {
-  }
-
-  void reset_cancellation_state(const Handler& handler)
-  {
-    cancellation_state_ = cancellation_state(
-        asio::get_associated_cancellation_slot(handler));
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(const Handler& handler, Filter filter)
-  {
-    cancellation_state_ = cancellation_state(
-        asio::get_associated_cancellation_slot(handler), filter, filter);
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(const Handler& handler,
-      InFilter&& in_filter,
-      OutFilter&& out_filter)
-  {
-    cancellation_state_ = cancellation_state(
-        asio::get_associated_cancellation_slot(handler),
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return cancellation_state_.cancelled();
-  }
-
-private:
-  cancellation_state cancellation_state_;
-};
-
-template <typename Handler>
-class base_from_cancellation_state<Handler,
-    enable_if_t<
-      is_same<
-        typename associated_cancellation_slot<
-          Handler, cancellation_slot
-        >::asio_associated_cancellation_slot_is_unspecialised,
-        void
-      >::value
-    >
-  >
-{
-public:
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return cancellation_state();
-  }
-
-protected:
-  explicit base_from_cancellation_state(const Handler&)
-  {
-  }
-
-  template <typename Filter>
-  base_from_cancellation_state(const Handler&, Filter)
-  {
-  }
-
-  template <typename InFilter, typename OutFilter>
-  base_from_cancellation_state(const Handler&,
-      InFilter&&,
-      OutFilter&&)
-  {
-  }
-
-  void reset_cancellation_state(const Handler&)
-  {
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(const Handler&, Filter)
-  {
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(const Handler&,
-      InFilter&&,
-      OutFilter&&)
-  {
-  }
-
-  constexpr cancellation_type_t cancelled() const noexcept
-  {
-    return cancellation_type::none;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_completion_cond.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_completion_cond.hpp
deleted file mode 100644
index ba0cc87..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/base_from_completion_cond.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// detail/base_from_completion_cond.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
-#define ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/completion_condition.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename CompletionCondition>
-class base_from_completion_cond
-{
-protected:
-  explicit base_from_completion_cond(CompletionCondition& completion_condition)
-    : completion_condition_(
-        static_cast<CompletionCondition&&>(completion_condition))
-  {
-  }
-
-  std::size_t check_for_completion(
-      const asio::error_code& ec,
-      std::size_t total_transferred)
-  {
-    return detail::adapt_completion_condition_result(
-        completion_condition_(ec, total_transferred));
-  }
-
-private:
-  CompletionCondition completion_condition_;
-};
-
-template <>
-class base_from_completion_cond<transfer_all_t>
-{
-protected:
-  explicit base_from_completion_cond(transfer_all_t)
-  {
-  }
-
-  static std::size_t check_for_completion(
-      const asio::error_code& ec,
-      std::size_t total_transferred)
-  {
-    return transfer_all_t()(ec, total_transferred);
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/bind_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/bind_handler.hpp
deleted file mode 100644
index 3c16b13..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/bind_handler.hpp
+++ /dev/null
@@ -1,711 +0,0 @@
-//
-// detail/bind_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BIND_HANDLER_HPP
-#define ASIO_DETAIL_BIND_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-class binder0
-{
-public:
-  template <typename T>
-  binder0(int, T&& handler)
-    : handler_(static_cast<T&&>(handler))
-  {
-  }
-
-  binder0(Handler& handler)
-    : handler_(static_cast<Handler&&>(handler))
-  {
-  }
-
-  binder0(const binder0& other)
-    : handler_(other.handler_)
-  {
-  }
-
-  binder0(binder0&& other)
-    : handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)();
-  }
-
-  void operator()() const
-  {
-    handler_();
-  }
-
-//private:
-  Handler handler_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    binder0<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler>
-inline binder0<decay_t<Handler>> bind_handler(
-    Handler&& handler)
-{
-  return binder0<decay_t<Handler>>(
-      0, static_cast<Handler&&>(handler));
-}
-
-template <typename Handler, typename Arg1>
-class binder1
-{
-public:
-  template <typename T>
-  binder1(int, T&& handler, const Arg1& arg1)
-    : handler_(static_cast<T&&>(handler)),
-      arg1_(arg1)
-  {
-  }
-
-  binder1(Handler& handler, const Arg1& arg1)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1)
-  {
-  }
-
-  binder1(const binder1& other)
-    : handler_(other.handler_),
-      arg1_(other.arg1_)
-  {
-  }
-
-  binder1(binder1&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-};
-
-template <typename Handler, typename Arg1>
-inline bool asio_handler_is_continuation(
-    binder1<Handler, Arg1>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1>
-inline binder1<decay_t<Handler>, Arg1> bind_handler(
-    Handler&& handler, const Arg1& arg1)
-{
-  return binder1<decay_t<Handler>, Arg1>(0,
-      static_cast<Handler&&>(handler), arg1);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-class binder2
-{
-public:
-  template <typename T>
-  binder2(int, T&& handler,
-      const Arg1& arg1, const Arg2& arg2)
-    : handler_(static_cast<T&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2)
-  {
-  }
-
-  binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2)
-  {
-  }
-
-  binder2(const binder2& other)
-    : handler_(other.handler_),
-      arg1_(other.arg1_),
-      arg2_(other.arg2_)
-  {
-  }
-
-  binder2(binder2&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_)),
-      arg2_(static_cast<Arg2&&>(other.arg2_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline bool asio_handler_is_continuation(
-    binder2<Handler, Arg1, Arg2>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline binder2<decay_t<Handler>, Arg1, Arg2> bind_handler(
-    Handler&& handler, const Arg1& arg1, const Arg2& arg2)
-{
-  return binder2<decay_t<Handler>, Arg1, Arg2>(0,
-      static_cast<Handler&&>(handler), arg1, arg2);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-class binder3
-{
-public:
-  template <typename T>
-  binder3(int, T&& handler, const Arg1& arg1,
-      const Arg2& arg2, const Arg3& arg3)
-    : handler_(static_cast<T&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3)
-  {
-  }
-
-  binder3(Handler& handler, const Arg1& arg1,
-      const Arg2& arg2, const Arg3& arg3)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3)
-  {
-  }
-
-  binder3(const binder3& other)
-    : handler_(other.handler_),
-      arg1_(other.arg1_),
-      arg2_(other.arg2_),
-      arg3_(other.arg3_)
-  {
-  }
-
-  binder3(binder3&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_)),
-      arg2_(static_cast<Arg2&&>(other.arg2_)),
-      arg3_(static_cast<Arg3&&>(other.arg3_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline bool asio_handler_is_continuation(
-    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline binder3<decay_t<Handler>, Arg1, Arg2, Arg3> bind_handler(
-    Handler&& handler, const Arg1& arg1, const Arg2& arg2,
-    const Arg3& arg3)
-{
-  return binder3<decay_t<Handler>, Arg1, Arg2, Arg3>(0,
-      static_cast<Handler&&>(handler), arg1, arg2, arg3);
-}
-
-template <typename Handler, typename Arg1,
-    typename Arg2, typename Arg3, typename Arg4>
-class binder4
-{
-public:
-  template <typename T>
-  binder4(int, T&& handler, const Arg1& arg1,
-      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
-    : handler_(static_cast<T&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4)
-  {
-  }
-
-  binder4(Handler& handler, const Arg1& arg1,
-      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4)
-  {
-  }
-
-  binder4(const binder4& other)
-    : handler_(other.handler_),
-      arg1_(other.arg1_),
-      arg2_(other.arg2_),
-      arg3_(other.arg3_),
-      arg4_(other.arg4_)
-  {
-  }
-
-  binder4(binder4&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_)),
-      arg2_(static_cast<Arg2&&>(other.arg2_)),
-      arg3_(static_cast<Arg3&&>(other.arg3_)),
-      arg4_(static_cast<Arg4&&>(other.arg4_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_, arg4_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-  Arg4 arg4_;
-};
-
-template <typename Handler, typename Arg1,
-    typename Arg2, typename Arg3, typename Arg4>
-inline bool asio_handler_is_continuation(
-    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1,
-    typename Arg2, typename Arg3, typename Arg4>
-inline binder4<decay_t<Handler>, Arg1, Arg2, Arg3, Arg4>
-bind_handler(Handler&& handler, const Arg1& arg1,
-    const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
-{
-  return binder4<decay_t<Handler>, Arg1, Arg2, Arg3, Arg4>(0,
-      static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4);
-}
-
-template <typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
-class binder5
-{
-public:
-  template <typename T>
-  binder5(int, T&& handler, const Arg1& arg1,
-      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-    : handler_(static_cast<T&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4),
-      arg5_(arg5)
-  {
-  }
-
-  binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4),
-      arg5_(arg5)
-  {
-  }
-
-  binder5(const binder5& other)
-    : handler_(other.handler_),
-      arg1_(other.arg1_),
-      arg2_(other.arg2_),
-      arg3_(other.arg3_),
-      arg4_(other.arg4_),
-      arg5_(other.arg5_)
-  {
-  }
-
-  binder5(binder5&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_)),
-      arg2_(static_cast<Arg2&&>(other.arg2_)),
-      arg3_(static_cast<Arg3&&>(other.arg3_)),
-      arg4_(static_cast<Arg4&&>(other.arg4_)),
-      arg5_(static_cast<Arg5&&>(other.arg5_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_),
-        static_cast<const Arg5&>(arg5_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-  Arg4 arg4_;
-  Arg5 arg5_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
-inline bool asio_handler_is_continuation(
-    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
-inline binder5<decay_t<Handler>, Arg1, Arg2, Arg3, Arg4, Arg5>
-bind_handler(Handler&& handler, const Arg1& arg1,
-    const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-{
-  return binder5<decay_t<Handler>, Arg1, Arg2, Arg3, Arg4, Arg5>(0,
-      static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4, arg5);
-}
-
-template <typename Handler, typename Arg1>
-class move_binder1
-{
-public:
-  move_binder1(int, Handler&& handler,
-      Arg1&& arg1)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(static_cast<Arg1&&>(arg1))
-  {
-  }
-
-  move_binder1(move_binder1&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<Arg1&&>(arg1_));
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-};
-
-template <typename Handler, typename Arg1>
-inline bool asio_handler_is_continuation(
-    move_binder1<Handler, Arg1>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-class move_binder2
-{
-public:
-  move_binder2(int, Handler&& handler,
-      const Arg1& arg1, Arg2&& arg2)
-    : handler_(static_cast<Handler&&>(handler)),
-      arg1_(arg1),
-      arg2_(static_cast<Arg2&&>(arg2))
-  {
-  }
-
-  move_binder2(move_binder2&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      arg1_(static_cast<Arg1&&>(other.arg1_)),
-      arg2_(static_cast<Arg2&&>(other.arg2_))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<const Arg1&>(arg1_),
-        static_cast<Arg2&&>(arg2_));
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline bool asio_handler_is_continuation(
-    move_binder2<Handler, Arg1, Arg2>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-} // namespace detail
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder0<Handler>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder0<Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::binder0<Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder1<Handler, Arg1>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder1<Handler, Arg1>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::binder1<Handler, Arg1>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename Arg2,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder2<Handler, Arg1, Arg2>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder2<Handler, Arg1, Arg2>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::binder2<Handler, Arg1, Arg2>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder3<Handler, Arg1, Arg2, Arg3>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder3<Handler, Arg1, Arg2, Arg3>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::binder3<Handler, Arg1, Arg2, Arg3>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::binder4<Handler, Arg1, Arg2, Arg3, Arg4>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5, typename DefaultCandidate>
-struct associator<Associator,
-    detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename DefaultCandidate>
-struct associator<Associator,
-    detail::move_binder1<Handler, Arg1>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::move_binder1<Handler, Arg1>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::move_binder1<Handler, Arg1>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Arg1, typename Arg2, typename DefaultCandidate>
-struct associator<Associator,
-    detail::move_binder2<Handler, Arg1, Arg2>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::move_binder2<Handler, Arg1, Arg2>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BIND_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/blocking_executor_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/blocking_executor_op.hpp
deleted file mode 100644
index c70e562..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/blocking_executor_op.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-//
-// detail/blocking_executor_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
-#define ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/scheduler_operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Operation = scheduler_operation>
-class blocking_executor_op_base : public Operation
-{
-public:
-  blocking_executor_op_base(typename Operation::func_type complete_func)
-    : Operation(complete_func),
-      is_complete_(false)
-  {
-  }
-
-  void wait()
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    while (!is_complete_)
-      event_.wait(lock);
-  }
-
-protected:
-  struct do_complete_cleanup
-  {
-    ~do_complete_cleanup()
-    {
-      asio::detail::mutex::scoped_lock lock(op_->mutex_);
-      op_->is_complete_ = true;
-      op_->event_.unlock_and_signal_one_for_destruction(lock);
-    }
-
-    blocking_executor_op_base* op_;
-  };
-
-private:
-  asio::detail::mutex mutex_;
-  asio::detail::event event_;
-  bool is_complete_;
-};
-
-template <typename Handler, typename Operation = scheduler_operation>
-class blocking_executor_op : public blocking_executor_op_base<Operation>
-{
-public:
-  blocking_executor_op(Handler& h)
-    : blocking_executor_op_base<Operation>(&blocking_executor_op::do_complete),
-      handler_(h)
-  {
-  }
-
-  static void do_complete(void* owner, Operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    ASIO_ASSUME(base != 0);
-    blocking_executor_op* o(static_cast<blocking_executor_op*>(base));
-
-    typename blocking_executor_op_base<Operation>::do_complete_cleanup
-      on_exit = { o };
-    (void)on_exit;
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN(());
-      static_cast<Handler&&>(o->handler_)();
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler& handler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_resize_guard.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_resize_guard.hpp
deleted file mode 100644
index 1a78307..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_resize_guard.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// detail/buffer_resize_guard.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
-#define ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/limits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper class to manage buffer resizing in an exception safe way.
-template <typename Buffer>
-class buffer_resize_guard
-{
-public:
-  // Constructor.
-  buffer_resize_guard(Buffer& buffer)
-    : buffer_(buffer),
-      old_size_(buffer.size())
-  {
-  }
-
-  // Destructor rolls back the buffer resize unless commit was called.
-  ~buffer_resize_guard()
-  {
-    if (old_size_ != (std::numeric_limits<size_t>::max)())
-    {
-      buffer_.resize(old_size_);
-    }
-  }
-
-  // Commit the resize transaction.
-  void commit()
-  {
-    old_size_ = (std::numeric_limits<size_t>::max)();
-  }
-
-private:
-  // The buffer being managed.
-  Buffer& buffer_;
-
-  // The size of the buffer at the time the guard was constructed.
-  size_t old_size_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_sequence_adapter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_sequence_adapter.hpp
deleted file mode 100644
index 8ea904e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffer_sequence_adapter.hpp
+++ /dev/null
@@ -1,837 +0,0 @@
-//
-// detail/buffer_sequence_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
-#define ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/registered_buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffer_sequence_adapter_base
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-public:
-  // The maximum number of buffers to support in a single operation.
-  enum { max_buffers = 1 };
-
-protected:
-  typedef Windows::Storage::Streams::IBuffer^ native_buffer_type;
-
-  ASIO_DECL static void init_native_buffer(
-      native_buffer_type& buf,
-      const asio::mutable_buffer& buffer);
-
-  ASIO_DECL static void init_native_buffer(
-      native_buffer_type& buf,
-      const asio::const_buffer& buffer);
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-public:
-  // The maximum number of buffers to support in a single operation.
-  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
-
-protected:
-  typedef WSABUF native_buffer_type;
-
-  static void init_native_buffer(WSABUF& buf,
-      const asio::mutable_buffer& buffer)
-  {
-    buf.buf = static_cast<char*>(buffer.data());
-    buf.len = static_cast<ULONG>(buffer.size());
-  }
-
-  static void init_native_buffer(WSABUF& buf,
-      const asio::const_buffer& buffer)
-  {
-    buf.buf = const_cast<char*>(static_cast<const char*>(buffer.data()));
-    buf.len = static_cast<ULONG>(buffer.size());
-  }
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-public:
-  // The maximum number of buffers to support in a single operation.
-  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
-
-protected:
-  typedef iovec native_buffer_type;
-
-  static void init_iov_base(void*& base, void* addr)
-  {
-    base = addr;
-  }
-
-  template <typename T>
-  static void init_iov_base(T& base, void* addr)
-  {
-    base = static_cast<T>(addr);
-  }
-
-  static void init_native_buffer(iovec& iov,
-      const asio::mutable_buffer& buffer)
-  {
-    init_iov_base(iov.iov_base, buffer.data());
-    iov.iov_len = buffer.size();
-  }
-
-  static void init_native_buffer(iovec& iov,
-      const asio::const_buffer& buffer)
-  {
-    init_iov_base(iov.iov_base, const_cast<void*>(buffer.data()));
-    iov.iov_len = buffer.size();
-  }
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-};
-
-// Helper class to translate buffers into the native buffer representation.
-template <typename Buffer, typename Buffers>
-class buffer_sequence_adapter
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = false };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
-    : count_(0), total_buffer_size_(0)
-  {
-    buffer_sequence_adapter::init(
-        asio::buffer_sequence_begin(buffer_sequence),
-        asio::buffer_sequence_end(buffer_sequence));
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return count_;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const Buffers& buffer_sequence)
-  {
-    return buffer_sequence_adapter::all_empty(
-        asio::buffer_sequence_begin(buffer_sequence),
-        asio::buffer_sequence_end(buffer_sequence));
-  }
-
-  static void validate(const Buffers& buffer_sequence)
-  {
-    buffer_sequence_adapter::validate(
-        asio::buffer_sequence_begin(buffer_sequence),
-        asio::buffer_sequence_end(buffer_sequence));
-  }
-
-  static Buffer first(const Buffers& buffer_sequence)
-  {
-    return buffer_sequence_adapter::first(
-        asio::buffer_sequence_begin(buffer_sequence),
-        asio::buffer_sequence_end(buffer_sequence));
-  }
-
-  enum { linearisation_storage_size = 8192 };
-
-  static Buffer linearise(const Buffers& buffer_sequence,
-      const asio::mutable_buffer& storage)
-  {
-    return buffer_sequence_adapter::linearise(
-        asio::buffer_sequence_begin(buffer_sequence),
-        asio::buffer_sequence_end(buffer_sequence), storage);
-  }
-
-private:
-  template <typename Iterator>
-  void init(Iterator begin, Iterator end)
-  {
-    Iterator iter = begin;
-    for (; iter != end && count_ < max_buffers; ++iter, ++count_)
-    {
-      Buffer buffer(*iter);
-      init_native_buffer(buffers_[count_], buffer);
-      total_buffer_size_ += buffer.size();
-    }
-  }
-
-  template <typename Iterator>
-  static bool all_empty(Iterator begin, Iterator end)
-  {
-    Iterator iter = begin;
-    std::size_t i = 0;
-    for (; iter != end && i < max_buffers; ++iter, ++i)
-      if (Buffer(*iter).size() > 0)
-        return false;
-    return true;
-  }
-
-  template <typename Iterator>
-  static void validate(Iterator begin, Iterator end)
-  {
-    Iterator iter = begin;
-    for (; iter != end; ++iter)
-    {
-      Buffer buffer(*iter);
-      buffer.data();
-    }
-  }
-
-  template <typename Iterator>
-  static Buffer first(Iterator begin, Iterator end)
-  {
-    Iterator iter = begin;
-    for (; iter != end; ++iter)
-    {
-      Buffer buffer(*iter);
-      if (buffer.size() != 0)
-        return buffer;
-    }
-    return Buffer();
-  }
-
-  template <typename Iterator>
-  static Buffer linearise(Iterator begin, Iterator end,
-      const asio::mutable_buffer& storage)
-  {
-    asio::mutable_buffer unused_storage = storage;
-    Iterator iter = begin;
-    while (iter != end && unused_storage.size() != 0)
-    {
-      Buffer buffer(*iter);
-      ++iter;
-      if (buffer.size() == 0)
-        continue;
-      if (unused_storage.size() == storage.size())
-      {
-        if (iter == end)
-          return buffer;
-        if (buffer.size() >= unused_storage.size())
-          return buffer;
-      }
-      unused_storage += asio::buffer_copy(unused_storage, buffer);
-    }
-    return Buffer(storage.data(), storage.size() - unused_storage.size());
-  }
-
-  native_buffer_type buffers_[max_buffers];
-  std::size_t count_;
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::mutable_buffer>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const asio::mutable_buffer& buffer_sequence)
-  {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = buffer_sequence.size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::mutable_buffer& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(const asio::mutable_buffer& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(const asio::mutable_buffer& buffer_sequence)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(const asio::mutable_buffer& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::const_buffer>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const asio::const_buffer& buffer_sequence)
-  {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = buffer_sequence.size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::const_buffer& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(const asio::const_buffer& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(const asio::const_buffer& buffer_sequence)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(const asio::const_buffer& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const asio::mutable_buffers_1& buffer_sequence)
-  {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = buffer_sequence.size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::mutable_buffers_1& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(const asio::mutable_buffers_1& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(const asio::mutable_buffers_1& buffer_sequence)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(const asio::mutable_buffers_1& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const asio::const_buffers_1& buffer_sequence)
-  {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = buffer_sequence.size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::const_buffers_1& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(const asio::const_buffers_1& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(const asio::const_buffers_1& buffer_sequence)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(const asio::const_buffers_1& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::mutable_registered_buffer>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = true };
-
-  explicit buffer_sequence_adapter(
-      const asio::mutable_registered_buffer& buffer_sequence)
-  {
-    init_native_buffer(buffer_, buffer_sequence.buffer());
-    total_buffer_size_ = buffer_sequence.size();
-    registered_id_ = buffer_sequence.id();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_id_;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(
-      const asio::mutable_registered_buffer& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(
-      const asio::mutable_registered_buffer& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(
-      const asio::mutable_registered_buffer& buffer_sequence)
-  {
-    return Buffer(buffer_sequence.buffer());
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(
-      const asio::mutable_registered_buffer& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence.buffer());
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-  registered_buffer_id registered_id_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::const_registered_buffer>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = true };
-  enum { is_registered_buffer = true };
-
-  explicit buffer_sequence_adapter(
-      const asio::const_registered_buffer& buffer_sequence)
-  {
-    init_native_buffer(buffer_, buffer_sequence.buffer());
-    total_buffer_size_ = buffer_sequence.size();
-    registered_id_ = buffer_sequence.id();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_id_;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(
-      const asio::const_registered_buffer& buffer_sequence)
-  {
-    return buffer_sequence.size() == 0;
-  }
-
-  static void validate(
-      const asio::const_registered_buffer& buffer_sequence)
-  {
-    buffer_sequence.data();
-  }
-
-  static Buffer first(
-      const asio::const_registered_buffer& buffer_sequence)
-  {
-    return Buffer(buffer_sequence.buffer());
-  }
-
-  enum { linearisation_storage_size = 1 };
-
-  static Buffer linearise(
-      const asio::const_registered_buffer& buffer_sequence,
-      const Buffer&)
-  {
-    return Buffer(buffer_sequence.buffer());
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-  registered_buffer_id registered_id_;
-};
-
-template <typename Buffer, typename Elem>
-class buffer_sequence_adapter<Buffer, boost::array<Elem, 2>>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = false };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const boost::array<Elem, 2>& buffer_sequence)
-  {
-    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
-    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return 2;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
-  }
-
-  static void validate(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    buffer_sequence[0].data();
-    buffer_sequence[1].data();
-  }
-
-  static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    return Buffer(buffer_sequence[0].size() != 0
-        ? buffer_sequence[0] : buffer_sequence[1]);
-  }
-
-  enum { linearisation_storage_size = 8192 };
-
-  static Buffer linearise(const boost::array<Elem, 2>& buffer_sequence,
-      const asio::mutable_buffer& storage)
-  {
-    if (buffer_sequence[0].size() == 0)
-      return Buffer(buffer_sequence[1]);
-    if (buffer_sequence[1].size() == 0)
-      return Buffer(buffer_sequence[0]);
-    return Buffer(storage.data(),
-        asio::buffer_copy(storage, buffer_sequence));
-  }
-
-private:
-  native_buffer_type buffers_[2];
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer, typename Elem>
-class buffer_sequence_adapter<Buffer, std::array<Elem, 2>>
-  : buffer_sequence_adapter_base
-{
-public:
-  enum { is_single_buffer = false };
-  enum { is_registered_buffer = false };
-
-  explicit buffer_sequence_adapter(
-      const std::array<Elem, 2>& buffer_sequence)
-  {
-    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
-    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return 2;
-  }
-
-  std::size_t total_size() const
-  {
-    return total_buffer_size_;
-  }
-
-  registered_buffer_id registered_id() const
-  {
-    return registered_buffer_id();
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
-  {
-    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
-  }
-
-  static void validate(const std::array<Elem, 2>& buffer_sequence)
-  {
-    buffer_sequence[0].data();
-    buffer_sequence[1].data();
-  }
-
-  static Buffer first(const std::array<Elem, 2>& buffer_sequence)
-  {
-    return Buffer(buffer_sequence[0].size() != 0
-        ? buffer_sequence[0] : buffer_sequence[1]);
-  }
-
-  enum { linearisation_storage_size = 8192 };
-
-  static Buffer linearise(const std::array<Elem, 2>& buffer_sequence,
-      const asio::mutable_buffer& storage)
-  {
-    if (buffer_sequence[0].size() == 0)
-      return Buffer(buffer_sequence[1]);
-    if (buffer_sequence[1].size() == 0)
-      return Buffer(buffer_sequence[0]);
-    return Buffer(storage.data(),
-        asio::buffer_copy(storage, buffer_sequence));
-  }
-
-private:
-  native_buffer_type buffers_[2];
-  std::size_t total_buffer_size_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/buffer_sequence_adapter.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffered_stream_storage.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffered_stream_storage.hpp
deleted file mode 100644
index 0d776ad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/buffered_stream_storage.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// detail/buffered_stream_storage.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
-#define ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/assert.hpp"
-#include <cstddef>
-#include <cstring>
-#include <vector>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffered_stream_storage
-{
-public:
-  // The type of the bytes stored in the buffer.
-  typedef unsigned char byte_type;
-
-  // The type used for offsets into the buffer.
-  typedef std::size_t size_type;
-
-  // Constructor.
-  explicit buffered_stream_storage(std::size_t buffer_capacity)
-    : begin_offset_(0),
-      end_offset_(0),
-      buffer_(buffer_capacity)
-  {
-  }
-
-  /// Clear the buffer.
-  void clear()
-  {
-    begin_offset_ = 0;
-    end_offset_ = 0;
-  }
-
-  // Return a pointer to the beginning of the unread data.
-  mutable_buffer data()
-  {
-    return asio::buffer(buffer_) + begin_offset_;
-  }
-
-  // Return a pointer to the beginning of the unread data.
-  const_buffer data() const
-  {
-    return asio::buffer(buffer_) + begin_offset_;
-  }
-
-  // Is there no unread data in the buffer.
-  bool empty() const
-  {
-    return begin_offset_ == end_offset_;
-  }
-
-  // Return the amount of unread data the is in the buffer.
-  size_type size() const
-  {
-    return end_offset_ - begin_offset_;
-  }
-
-  // Resize the buffer to the specified length.
-  void resize(size_type length)
-  {
-    ASIO_ASSERT(length <= capacity());
-    if (begin_offset_ + length <= capacity())
-    {
-      end_offset_ = begin_offset_ + length;
-    }
-    else
-    {
-      using namespace std; // For memmove.
-      memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
-      end_offset_ = length;
-      begin_offset_ = 0;
-    }
-  }
-
-  // Return the maximum size for data in the buffer.
-  size_type capacity() const
-  {
-    return buffer_.size();
-  }
-
-  // Consume multiple bytes from the beginning of the buffer.
-  void consume(size_type count)
-  {
-    ASIO_ASSERT(begin_offset_ + count <= end_offset_);
-    begin_offset_ += count;
-    if (empty())
-      clear();
-  }
-
-private:
-  // The offset to the beginning of the unread data.
-  size_type begin_offset_;
-
-  // The offset to the end of the unread data.
-  size_type end_offset_;
-
-  // The data in the buffer.
-  std::vector<byte_type> buffer_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/call_stack.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/call_stack.hpp
deleted file mode 100644
index c287c57..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/call_stack.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-//
-// detail/call_stack.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CALL_STACK_HPP
-#define ASIO_DETAIL_CALL_STACK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/tss_ptr.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper class to determine whether or not the current thread is inside an
-// invocation of io_context::run() for a specified io_context object.
-template <typename Key, typename Value = unsigned char>
-class call_stack
-{
-public:
-  // Context class automatically pushes the key/value pair on to the stack.
-  class context
-    : private noncopyable
-  {
-  public:
-    // Push the key on to the stack.
-    explicit context(Key* k)
-      : key_(k),
-        next_(call_stack<Key, Value>::top_)
-    {
-      value_ = reinterpret_cast<unsigned char*>(this);
-      call_stack<Key, Value>::top_ = this;
-    }
-
-    // Push the key/value pair on to the stack.
-    context(Key* k, Value& v)
-      : key_(k),
-        value_(&v),
-        next_(call_stack<Key, Value>::top_)
-    {
-      call_stack<Key, Value>::top_ = this;
-    }
-
-    // Pop the key/value pair from the stack.
-    ~context()
-    {
-      call_stack<Key, Value>::top_ = next_;
-    }
-
-    // Find the next context with the same key.
-    Value* next_by_key() const
-    {
-      context* elem = next_;
-      while (elem)
-      {
-        if (elem->key_ == key_)
-          return elem->value_;
-        elem = elem->next_;
-      }
-      return 0;
-    }
-
-  private:
-    friend class call_stack<Key, Value>;
-
-    // The key associated with the context.
-    Key* key_;
-
-    // The value associated with the context.
-    Value* value_;
-
-    // The next element in the stack.
-    context* next_;
-  };
-
-  friend class context;
-
-  // Determine whether the specified owner is on the stack. Returns address of
-  // key if present, 0 otherwise.
-  static Value* contains(Key* k)
-  {
-    context* elem = top_;
-    while (elem)
-    {
-      if (elem->key_ == k)
-        return elem->value_;
-      elem = elem->next_;
-    }
-    return 0;
-  }
-
-  // Obtain the value at the top of the stack.
-  static Value* top()
-  {
-    context* elem = top_;
-    return elem ? elem->value_ : 0;
-  }
-
-private:
-  // The top of the stack of calls for the current thread.
-  static tss_ptr<context> top_;
-};
-
-template <typename Key, typename Value>
-tss_ptr<typename call_stack<Key, Value>::context>
-call_stack<Key, Value>::top_;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CALL_STACK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono.hpp
deleted file mode 100644
index 45490dd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// detail/chrono.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CHRONO_HPP
-#define ASIO_DETAIL_CHRONO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <chrono>
-
-namespace asio {
-namespace chrono {
-
-using std::chrono::duration;
-using std::chrono::time_point;
-using std::chrono::duration_cast;
-using std::chrono::nanoseconds;
-using std::chrono::microseconds;
-using std::chrono::milliseconds;
-using std::chrono::seconds;
-using std::chrono::minutes;
-using std::chrono::hours;
-using std::chrono::time_point_cast;
-#if defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-typedef std::chrono::monotonic_clock steady_clock;
-#else // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-using std::chrono::steady_clock;
-#endif // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
-using std::chrono::system_clock;
-using std::chrono::high_resolution_clock;
-
-} // namespace chrono
-} // namespace asio
-
-#endif // ASIO_DETAIL_CHRONO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono_time_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono_time_traits.hpp
deleted file mode 100644
index de7b7d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/chrono_time_traits.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-// detail/chrono_time_traits.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
-#define ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/cstdint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper template to compute the greatest common divisor.
-template <int64_t v1, int64_t v2>
-struct gcd { enum { value = gcd<v2, v1 % v2>::value }; };
-
-template <int64_t v1>
-struct gcd<v1, 0> { enum { value = v1 }; };
-
-// Adapts std::chrono clocks for use with a deadline timer.
-template <typename Clock, typename WaitTraits>
-struct chrono_time_traits
-{
-  // The clock type.
-  typedef Clock clock_type;
-
-  // The duration type of the clock.
-  typedef typename clock_type::duration duration_type;
-
-  // The time point type of the clock.
-  typedef typename clock_type::time_point time_type;
-
-  // The period of the clock.
-  typedef typename duration_type::period period_type;
-
-  // Get the current time.
-  static time_type now()
-  {
-    return clock_type::now();
-  }
-
-  // Add a duration to a time.
-  static time_type add(const time_type& t, const duration_type& d)
-  {
-    const time_type epoch;
-    if (t >= epoch)
-    {
-      if ((time_type::max)() - t < d)
-        return (time_type::max)();
-    }
-    else // t < epoch
-    {
-      if (-(t - (time_type::min)()) > d)
-        return (time_type::min)();
-    }
-
-    return t + d;
-  }
-
-  // Subtract one time from another.
-  static duration_type subtract(const time_type& t1, const time_type& t2)
-  {
-    const time_type epoch;
-    if (t1 >= epoch)
-    {
-      if (t2 >= epoch)
-      {
-        return t1 - t2;
-      }
-      else if (t2 == (time_type::min)())
-      {
-        return (duration_type::max)();
-      }
-      else if ((time_type::max)() - t1 < epoch - t2)
-      {
-        return (duration_type::max)();
-      }
-      else
-      {
-        return t1 - t2;
-      }
-    }
-    else // t1 < epoch
-    {
-      if (t2 < epoch)
-      {
-        return t1 - t2;
-      }
-      else if (t1 == (time_type::min)())
-      {
-        return (duration_type::min)();
-      }
-      else if ((time_type::max)() - t2 < epoch - t1)
-      {
-        return (duration_type::min)();
-      }
-      else
-      {
-        return -(t2 - t1);
-      }
-    }
-  }
-
-  // Test whether one time is less than another.
-  static bool less_than(const time_type& t1, const time_type& t2)
-  {
-    return t1 < t2;
-  }
-
-  // Implement just enough of the posix_time::time_duration interface to supply
-  // what the timer_queue requires.
-  class posix_time_duration
-  {
-  public:
-    explicit posix_time_duration(const duration_type& d)
-      : d_(d)
-    {
-    }
-
-    int64_t ticks() const
-    {
-      return d_.count();
-    }
-
-    int64_t total_seconds() const
-    {
-      return duration_cast<1, 1>();
-    }
-
-    int64_t total_milliseconds() const
-    {
-      return duration_cast<1, 1000>();
-    }
-
-    int64_t total_microseconds() const
-    {
-      return duration_cast<1, 1000000>();
-    }
-
-  private:
-    template <int64_t Num, int64_t Den>
-    int64_t duration_cast() const
-    {
-      const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value;
-      const int64_t num2 = Num / gcd<period_type::num, Num>::value;
-
-      const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value;
-      const int64_t den2 = Den / gcd<period_type::den, Den>::value;
-
-      const int64_t num = num1 * den2;
-      const int64_t den = num2 * den1;
-
-      if (num == 1 && den == 1)
-        return ticks();
-      else if (num != 1 && den == 1)
-        return ticks() * num;
-      else if (num == 1 && period_type::den != 1)
-        return ticks() / den;
-      else
-        return ticks() * num / den;
-    }
-
-    duration_type d_;
-  };
-
-  // Convert to POSIX duration type.
-  static posix_time_duration to_posix_duration(const duration_type& d)
-  {
-    return posix_time_duration(WaitTraits::to_wait_duration(d));
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_handler.hpp
deleted file mode 100644
index c6f98b3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_handler.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//
-// detail/completion_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPLETION_HANDLER_HPP
-#define ASIO_DETAIL_COMPLETION_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class completion_handler : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(completion_handler);
-
-  completion_handler(Handler& h, const IoExecutor& io_ex)
-    : operation(&completion_handler::do_complete),
-      handler_(static_cast<Handler&&>(h)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    completion_handler* h(static_cast<completion_handler*>(base));
-    ptr p = { asio::detail::addressof(h->handler_), h, h };
-
-    ASIO_HANDLER_COMPLETION((*h));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          h->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    Handler handler(static_cast<Handler&&>(h->handler_));
-    p.h = asio::detail::addressof(handler);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN(());
-      w.complete(handler, handler);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPLETION_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_message.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_message.hpp
deleted file mode 100644
index 0bd98ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_message.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// detail/completion_message.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPLETION_MESSAGE_HPP
-#define ASIO_DETAIL_COMPLETION_MESSAGE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Signature>
-class completion_message;
-
-template <typename R>
-class completion_message<R()>
-{
-public:
-  completion_message(int)
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    static_cast<Handler&&>(handler)();
-  }
-};
-
-template <typename R, typename Arg0>
-class completion_message<R(Arg0)>
-{
-public:
-  template <typename T0>
-  completion_message(int, T0&& t0)
-    : arg0_(static_cast<T0&&>(t0))
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    static_cast<Handler&&>(handler)(
-        static_cast<arg0_type&&>(arg0_));
-  }
-
-private:
-  typedef decay_t<Arg0> arg0_type;
-  arg0_type arg0_;
-};
-
-template <typename R, typename Arg0, typename Arg1>
-class completion_message<R(Arg0, Arg1)>
-{
-public:
-  template <typename T0, typename T1>
-  completion_message(int, T0&& t0, T1&& t1)
-    : arg0_(static_cast<T0&&>(t0)),
-      arg1_(static_cast<T1&&>(t1))
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    static_cast<Handler&&>(handler)(
-        static_cast<arg0_type&&>(arg0_),
-        static_cast<arg1_type&&>(arg1_));
-  }
-
-private:
-  typedef decay_t<Arg0> arg0_type;
-  arg0_type arg0_;
-  typedef decay_t<Arg1> arg1_type;
-  arg1_type arg1_;
-};
-
-template <typename R, typename... Args>
-class completion_message<R(Args...)>
-{
-public:
-  template <typename... T>
-  completion_message(int, T&&... t)
-    : args_(static_cast<T&&>(t)...)
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& h)
-  {
-    this->do_receive(h, asio::detail::index_sequence_for<Args...>());
-  }
-
-private:
-  template <typename Handler, std::size_t... I>
-  void do_receive(Handler& h, asio::detail::index_sequence<I...>)
-  {
-    static_cast<Handler&&>(h)(
-        std::get<I>(static_cast<args_type&&>(args_))...);
-  }
-
-  typedef std::tuple<decay_t<Args>...> args_type;
-  args_type args_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPLETION_MESSAGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload.hpp
deleted file mode 100644
index ae336b4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload.hpp
+++ /dev/null
@@ -1,220 +0,0 @@
-//
-// detail/completion_payload.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPLETION_PAYLOAD_HPP
-#define ASIO_DETAIL_COMPLETION_PAYLOAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error_code.hpp"
-#include "asio/detail/completion_message.hpp"
-
-#if defined(ASIO_HAS_STD_VARIANT)
-# include <variant>
-#else // defined(ASIO_HAS_STD_VARIANT)
-# include <new>
-#endif // defined(ASIO_HAS_STD_VARIANT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename... Signatures>
-class completion_payload;
-
-template <typename R>
-class completion_payload<R()>
-{
-public:
-  explicit completion_payload(completion_message<R()>)
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    static_cast<Handler&&>(handler)();
-  }
-};
-
-template <typename Signature>
-class completion_payload<Signature>
-{
-public:
-  completion_payload(completion_message<Signature>&& m)
-    : message_(static_cast<completion_message<Signature>&&>(m))
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    message_.receive(handler);
-  }
-
-private:
-  completion_message<Signature> message_;
-};
-
-#if defined(ASIO_HAS_STD_VARIANT)
-
-template <typename... Signatures>
-class completion_payload
-{
-public:
-  template <typename Signature>
-  completion_payload(completion_message<Signature>&& m)
-    : message_(static_cast<completion_message<Signature>&&>(m))
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    std::visit(
-        [&](auto& message)
-        {
-          message.receive(handler);
-        }, message_);
-  }
-
-private:
-  std::variant<completion_message<Signatures>...> message_;
-};
-
-#else // defined(ASIO_HAS_STD_VARIANT)
-
-template <typename R1, typename R2>
-class completion_payload<R1(), R2(asio::error_code)>
-{
-public:
-  typedef completion_message<R1()> void_message_type;
-  typedef completion_message<R2(asio::error_code)> error_message_type;
-
-  completion_payload(void_message_type&&)
-    : message_(0, asio::error_code()),
-      empty_(true)
-  {
-  }
-
-  completion_payload(error_message_type&& m)
-    : message_(static_cast<error_message_type&&>(m)),
-      empty_(false)
-  {
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    if (empty_)
-      completion_message<R1()>(0).receive(handler);
-    else
-      message_.receive(handler);
-  }
-
-private:
-  error_message_type message_;
-  bool empty_;
-};
-
-template <typename Sig1, typename Sig2>
-class completion_payload<Sig1, Sig2>
-{
-public:
-  typedef completion_message<Sig1> message_1_type;
-  typedef completion_message<Sig2> message_2_type;
-
-  completion_payload(message_1_type&& m)
-    : index_(1)
-  {
-    new (&storage_.message_1_) message_1_type(static_cast<message_1_type&&>(m));
-  }
-
-  completion_payload(message_2_type&& m)
-    : index_(2)
-  {
-    new (&storage_.message_2_) message_2_type(static_cast<message_2_type&&>(m));
-  }
-
-  completion_payload(completion_payload&& other)
-    : index_(other.index_)
-  {
-    switch (index_)
-    {
-    case 1:
-      new (&storage_.message_1_) message_1_type(
-          static_cast<message_1_type&&>(other.storage_.message_1_));
-      break;
-    case 2:
-      new (&storage_.message_2_) message_2_type(
-          static_cast<message_2_type&&>(other.storage_.message_2_));
-      break;
-    default:
-      break;
-    }
-  }
-
-  ~completion_payload()
-  {
-    switch (index_)
-    {
-    case 1:
-      storage_.message_1_.~message_1_type();
-      break;
-    case 2:
-      storage_.message_2_.~message_2_type();
-      break;
-    default:
-      break;
-    }
-  }
-
-  template <typename Handler>
-  void receive(Handler& handler)
-  {
-    switch (index_)
-    {
-    case 1:
-      storage_.message_1_.receive(handler);
-      break;
-    case 2:
-      storage_.message_2_.receive(handler);
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  union storage
-  {
-    storage() {}
-    ~storage() {}
-
-    char dummy_;
-    message_1_type message_1_;
-    message_2_type message_2_;
-  } storage_;
-  unsigned char index_;
-};
-
-#endif // defined(ASIO_HAS_STD_VARIANT)
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPLETION_PAYLOAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload_handler.hpp
deleted file mode 100644
index 8502173..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/completion_payload_handler.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//
-// detail/completion_payload_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPLETION_PAYLOAD_HANDLER_HPP
-#define ASIO_DETAIL_COMPLETION_PAYLOAD_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Payload, typename Handler>
-class completion_payload_handler
-{
-public:
-  completion_payload_handler(Payload&& p, Handler& h)
-    : payload_(static_cast<Payload&&>(p)),
-      handler_(static_cast<Handler&&>(h))
-  {
-  }
-
-  void operator()()
-  {
-    payload_.receive(handler_);
-  }
-
-  Handler& handler()
-  {
-    return handler_;
-  }
-
-//private:
-  Payload payload_;
-  Handler handler_;
-};
-
-} // namespace detail
-
-template <template <typename, typename> class Associator,
-    typename Payload, typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::completion_payload_handler<Payload, Handler>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::completion_payload_handler<Payload, Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::completion_payload_handler<Payload, Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPLETION_PAYLOAD_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/composed_work.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/composed_work.hpp
deleted file mode 100644
index 8076f85..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/composed_work.hpp
+++ /dev/null
@@ -1,252 +0,0 @@
-//
-// detail/composed_work.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPOSED_WORK_HPP
-#define ASIO_DETAIL_COMPOSED_WORK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/system_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Executor, typename = void>
-class composed_work_guard
-{
-public:
-  typedef decay_t<
-      prefer_result_t<Executor, execution::outstanding_work_t::tracked_t>
-    > executor_type;
-
-  composed_work_guard(const Executor& ex)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  void reset()
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-private:
-  executor_type executor_;
-};
-
-template <>
-struct composed_work_guard<system_executor>
-{
-public:
-  typedef system_executor executor_type;
-
-  composed_work_guard(const system_executor&)
-  {
-  }
-
-  void reset()
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return system_executor();
-  }
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-struct composed_work_guard<Executor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-    >
-  > : executor_work_guard<Executor>
-{
-  composed_work_guard(const Executor& ex)
-    : executor_work_guard<Executor>(ex)
-  {
-  }
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename>
-struct composed_io_executors;
-
-template <>
-struct composed_io_executors<void()>
-{
-  composed_io_executors() noexcept
-    : head_(system_executor())
-  {
-  }
-
-  typedef system_executor head_type;
-  system_executor head_;
-};
-
-inline composed_io_executors<void()> make_composed_io_executors()
-{
-  return composed_io_executors<void()>();
-}
-
-template <typename Head>
-struct composed_io_executors<void(Head)>
-{
-  explicit composed_io_executors(const Head& ex) noexcept
-    : head_(ex)
-  {
-  }
-
-  typedef Head head_type;
-  Head head_;
-};
-
-template <typename Head>
-inline composed_io_executors<void(Head)>
-make_composed_io_executors(const Head& head)
-{
-  return composed_io_executors<void(Head)>(head);
-}
-
-template <typename Head, typename... Tail>
-struct composed_io_executors<void(Head, Tail...)>
-{
-  explicit composed_io_executors(const Head& head,
-      const Tail&... tail) noexcept
-    : head_(head),
-      tail_(tail...)
-  {
-  }
-
-  void reset()
-  {
-    head_.reset();
-    tail_.reset();
-  }
-
-  typedef Head head_type;
-  Head head_;
-  composed_io_executors<void(Tail...)> tail_;
-};
-
-template <typename Head, typename... Tail>
-inline composed_io_executors<void(Head, Tail...)>
-make_composed_io_executors(const Head& head, const Tail&... tail)
-{
-  return composed_io_executors<void(Head, Tail...)>(head, tail...);
-}
-
-template <typename>
-struct composed_work;
-
-template <>
-struct composed_work<void()>
-{
-  typedef composed_io_executors<void()> executors_type;
-
-  composed_work(const executors_type&) noexcept
-    : head_(system_executor())
-  {
-  }
-
-  void reset()
-  {
-    head_.reset();
-  }
-
-  typedef system_executor head_type;
-  composed_work_guard<system_executor> head_;
-};
-
-template <typename Head>
-struct composed_work<void(Head)>
-{
-  typedef composed_io_executors<void(Head)> executors_type;
-
-  explicit composed_work(const executors_type& ex) noexcept
-    : head_(ex.head_)
-  {
-  }
-
-  void reset()
-  {
-    head_.reset();
-  }
-
-  typedef Head head_type;
-  composed_work_guard<Head> head_;
-};
-
-template <typename Head, typename... Tail>
-struct composed_work<void(Head, Tail...)>
-{
-  typedef composed_io_executors<void(Head, Tail...)> executors_type;
-
-  explicit composed_work(const executors_type& ex) noexcept
-    : head_(ex.head_),
-      tail_(ex.tail_)
-  {
-  }
-
-  void reset()
-  {
-    head_.reset();
-    tail_.reset();
-  }
-
-  typedef Head head_type;
-  composed_work_guard<Head> head_;
-  composed_work<void(Tail...)> tail_;
-};
-
-template <typename IoObject>
-inline typename IoObject::executor_type
-get_composed_io_executor(IoObject& io_object,
-    enable_if_t<
-      !is_executor<IoObject>::value
-    >* = 0,
-    enable_if_t<
-      !execution::is_executor<IoObject>::value
-    >* = 0)
-{
-  return io_object.get_executor();
-}
-
-template <typename Executor>
-inline const Executor& get_composed_io_executor(const Executor& ex,
-    enable_if_t<
-      is_executor<Executor>::value
-        || execution::is_executor<Executor>::value
-    >* = 0)
-{
-  return ex;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPOSED_WORK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/concurrency_hint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/concurrency_hint.hpp
deleted file mode 100644
index 43e81a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/concurrency_hint.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// detail/concurrency_hint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONCURRENCY_HINT_HPP
-#define ASIO_DETAIL_CONCURRENCY_HINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-// The concurrency hint ID and mask are used to identify when a "well-known"
-// concurrency hint value has been passed to the io_context.
-#define ASIO_CONCURRENCY_HINT_ID 0xA5100000u
-#define ASIO_CONCURRENCY_HINT_ID_MASK 0xFFFF0000u
-
-// If set, this bit indicates that the scheduler should perform locking.
-#define ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER 0x1u
-
-// If set, this bit indicates that the reactor should perform locking when
-// managing descriptor registrations.
-#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION 0x2u
-
-// If set, this bit indicates that the reactor should perform locking for I/O.
-#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO 0x4u
-
-// Helper macro to determine if we have a special concurrency hint.
-#define ASIO_CONCURRENCY_HINT_IS_SPECIAL(hint) \
-  ((static_cast<unsigned>(hint) \
-    & ASIO_CONCURRENCY_HINT_ID_MASK) \
-      == ASIO_CONCURRENCY_HINT_ID)
-
-// Helper macro to determine if locking is enabled for a given facility.
-#define ASIO_CONCURRENCY_HINT_IS_LOCKING(facility, hint) \
-  (((static_cast<unsigned>(hint) \
-    & (ASIO_CONCURRENCY_HINT_ID_MASK \
-      | ASIO_CONCURRENCY_HINT_LOCKING_ ## facility)) \
-        ^ ASIO_CONCURRENCY_HINT_ID) != 0)
-
-// This special concurrency hint disables locking in both the scheduler and
-// reactor I/O. This hint has the following restrictions:
-//
-// - Care must be taken to ensure that all operations on the io_context and any
-//   of its associated I/O objects (such as sockets and timers) occur in only
-//   one thread at a time.
-//
-// - Asynchronous resolve operations fail with operation_not_supported.
-//
-// - If a signal_set is used with the io_context, signal_set objects cannot be
-//   used with any other io_context in the program.
-#define ASIO_CONCURRENCY_HINT_UNSAFE \
-  static_cast<int>(ASIO_CONCURRENCY_HINT_ID)
-
-// This special concurrency hint disables locking in the reactor I/O. This hint
-// has the following restrictions:
-//
-// - Care must be taken to ensure that run functions on the io_context, and all
-//   operations on the io_context's associated I/O objects (such as sockets and
-//   timers), occur in only one thread at a time.
-#define ASIO_CONCURRENCY_HINT_UNSAFE_IO \
-  static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
-      | ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
-      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION)
-
-// The special concurrency hint provides full thread safety.
-#define ASIO_CONCURRENCY_HINT_SAFE \
-  static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
-      | ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
-      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION \
-      | ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO)
-
-// This #define may be overridden at compile time to specify a program-wide
-// default concurrency hint, used by the zero-argument io_context constructor.
-#if !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
-# define ASIO_CONCURRENCY_HINT_DEFAULT -1
-#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
-
-// This #define may be overridden at compile time to specify a program-wide
-// concurrency hint, used by the one-argument io_context constructor when
-// passed a value of 1.
-#if !defined(ASIO_CONCURRENCY_HINT_1)
-# define ASIO_CONCURRENCY_HINT_1 1
-#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
-
-#endif // ASIO_DETAIL_CONCURRENCY_HINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_event.hpp
deleted file mode 100644
index af68dde..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_event.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//
-// detail/conditionally_enabled_event.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
-#define ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/conditionally_enabled_mutex.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/null_event.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Mutex adapter used to conditionally enable or disable locking.
-class conditionally_enabled_event
-  : private noncopyable
-{
-public:
-  // Constructor.
-  conditionally_enabled_event()
-  {
-  }
-
-  // Destructor.
-  ~conditionally_enabled_event()
-  {
-  }
-
-  // Signal the event. (Retained for backward compatibility.)
-  void signal(conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.signal(lock);
-  }
-
-  // Signal all waiters.
-  void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.signal_all(lock);
-  }
-
-  // Unlock the mutex and signal one waiter.
-  void unlock_and_signal_one(
-      conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.unlock_and_signal_one(lock);
-  }
-
-  // Unlock the mutex and signal one waiter who may destroy us.
-  void unlock_and_signal_one_for_destruction(
-      conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.unlock_and_signal_one(lock);
-  }
-
-  // If there's a waiter, unlock the mutex and signal it.
-  bool maybe_unlock_and_signal_one(
-      conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      return event_.maybe_unlock_and_signal_one(lock);
-    else
-      return false;
-  }
-
-  // Reset the event.
-  void clear(conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.clear(lock);
-  }
-
-  // Wait for the event to become signalled.
-  void wait(conditionally_enabled_mutex::scoped_lock& lock)
-  {
-    if (lock.mutex_.enabled_)
-      event_.wait(lock);
-    else
-      null_event().wait(lock);
-  }
-
-  // Timed wait for the event to become signalled.
-  bool wait_for_usec(
-      conditionally_enabled_mutex::scoped_lock& lock, long usec)
-  {
-    if (lock.mutex_.enabled_)
-      return event_.wait_for_usec(lock, usec);
-    else
-      return null_event().wait_for_usec(lock, usec);
-  }
-
-private:
-  asio::detail::event event_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_mutex.hpp
deleted file mode 100644
index 27fc30e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/conditionally_enabled_mutex.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//
-// detail/conditionally_enabled_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
-#define ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Mutex adapter used to conditionally enable or disable locking.
-class conditionally_enabled_mutex
-  : private noncopyable
-{
-public:
-  // Helper class to lock and unlock a mutex automatically.
-  class scoped_lock
-    : private noncopyable
-  {
-  public:
-    // Tag type used to distinguish constructors.
-    enum adopt_lock_t { adopt_lock };
-
-    // Constructor adopts a lock that is already held.
-    scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
-      : mutex_(m),
-        locked_(m.enabled_)
-    {
-    }
-
-    // Constructor acquires the lock.
-    explicit scoped_lock(conditionally_enabled_mutex& m)
-      : mutex_(m)
-    {
-      if (m.enabled_)
-      {
-        mutex_.mutex_.lock();
-        locked_ = true;
-      }
-      else
-        locked_ = false;
-    }
-
-    // Destructor releases the lock.
-    ~scoped_lock()
-    {
-      if (locked_)
-        mutex_.mutex_.unlock();
-    }
-
-    // Explicitly acquire the lock.
-    void lock()
-    {
-      if (mutex_.enabled_ && !locked_)
-      {
-        mutex_.mutex_.lock();
-        locked_ = true;
-      }
-    }
-
-    // Explicitly release the lock.
-    void unlock()
-    {
-      if (locked_)
-      {
-        mutex_.unlock();
-        locked_ = false;
-      }
-    }
-
-    // Test whether the lock is held.
-    bool locked() const
-    {
-      return locked_;
-    }
-
-    // Get the underlying mutex.
-    asio::detail::mutex& mutex()
-    {
-      return mutex_.mutex_;
-    }
-
-  private:
-    friend class conditionally_enabled_event;
-    conditionally_enabled_mutex& mutex_;
-    bool locked_;
-  };
-
-  // Constructor.
-  explicit conditionally_enabled_mutex(bool enabled)
-    : enabled_(enabled)
-  {
-  }
-
-  // Destructor.
-  ~conditionally_enabled_mutex()
-  {
-  }
-
-  // Determine whether locking is enabled.
-  bool enabled() const
-  {
-    return enabled_;
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    if (enabled_)
-      mutex_.lock();
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    if (enabled_)
-      mutex_.unlock();
-  }
-
-private:
-  friend class scoped_lock;
-  friend class conditionally_enabled_event;
-  asio::detail::mutex mutex_;
-  const bool enabled_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/config.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/config.hpp
deleted file mode 100644
index 14cf8cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/config.hpp
+++ /dev/null
@@ -1,1422 +0,0 @@
-//
-// detail/config.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONFIG_HPP
-#define ASIO_DETAIL_CONFIG_HPP
-
-// boostify: non-boost code starts here
-#if !defined(ASIO_STANDALONE)
-# if !defined(ASIO_ENABLE_BOOST)
-#  if (__cplusplus >= 201103)
-#   define ASIO_STANDALONE 1
-#  elif defined(_MSC_VER) && defined(_MSVC_LANG)
-#   if (_MSC_VER >= 1900) && (_MSVC_LANG >= 201103)
-#    define ASIO_STANDALONE 1
-#   endif // (_MSC_VER >= 1900) && (_MSVC_LANG >= 201103)
-#  endif // defined(_MSC_VER) && defined(_MSVC_LANG)
-# endif // !defined(ASIO_ENABLE_BOOST)
-#endif // !defined(ASIO_STANDALONE)
-
-// Make standard library feature macros available.
-#if defined(__has_include)
-# if __has_include(<version>)
-#  include <version>
-# else // __has_include(<version>)
-#  include <cstddef>
-# endif // __has_include(<version>)
-#else // defined(__has_include)
-# include <cstddef>
-#endif // defined(__has_include)
-
-// boostify: non-boost code ends here
-#if defined(ASIO_STANDALONE)
-# define ASIO_DISABLE_BOOST_ALIGN 1
-# define ASIO_DISABLE_BOOST_ARRAY 1
-# define ASIO_DISABLE_BOOST_ASSERT 1
-# define ASIO_DISABLE_BOOST_BIND 1
-# define ASIO_DISABLE_BOOST_CHRONO 1
-# define ASIO_DISABLE_BOOST_DATE_TIME 1
-# define ASIO_DISABLE_BOOST_LIMITS 1
-# define ASIO_DISABLE_BOOST_REGEX 1
-# define ASIO_DISABLE_BOOST_STATIC_CONSTANT 1
-# define ASIO_DISABLE_BOOST_THROW_EXCEPTION 1
-# define ASIO_DISABLE_BOOST_WORKAROUND 1
-#else // defined(ASIO_STANDALONE)
-// Boost.Config library is available.
-# include <boost/config.hpp>
-# include <boost/version.hpp>
-# define ASIO_HAS_BOOST_CONFIG 1
-#endif // defined(ASIO_STANDALONE)
-
-// Default to a header-only implementation. The user must specifically request
-// separate compilation by defining either ASIO_SEPARATE_COMPILATION or
-// ASIO_DYN_LINK (as a DLL/shared library implies separate compilation).
-#if !defined(ASIO_HEADER_ONLY)
-# if !defined(ASIO_SEPARATE_COMPILATION)
-#  if !defined(ASIO_DYN_LINK)
-#   define ASIO_HEADER_ONLY 1
-#  endif // !defined(ASIO_DYN_LINK)
-# endif // !defined(ASIO_SEPARATE_COMPILATION)
-#endif // !defined(ASIO_HEADER_ONLY)
-
-#if defined(ASIO_HEADER_ONLY)
-# define ASIO_DECL inline
-#else // defined(ASIO_HEADER_ONLY)
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
-// We need to import/export our code only if the user has specifically asked
-// for it by defining ASIO_DYN_LINK.
-#  if defined(ASIO_DYN_LINK)
-// Export if this is our own source, otherwise import.
-#   if defined(ASIO_SOURCE)
-#    define ASIO_DECL __declspec(dllexport)
-#   else // defined(ASIO_SOURCE)
-#    define ASIO_DECL __declspec(dllimport)
-#   endif // defined(ASIO_SOURCE)
-#  endif // defined(ASIO_DYN_LINK)
-# endif // defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
-#endif // defined(ASIO_HEADER_ONLY)
-
-// If ASIO_DECL isn't defined yet define it now.
-#if !defined(ASIO_DECL)
-# define ASIO_DECL
-#endif // !defined(ASIO_DECL)
-
-// Helper macro for documentation.
-#define ASIO_UNSPECIFIED(e) e
-
-// Microsoft Visual C++ detection.
-#if !defined(ASIO_MSVC)
-# if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
-#  define ASIO_MSVC BOOST_MSVC
-# elif defined(_MSC_VER) && (defined(__INTELLISENSE__) \
-      || (!defined(__MWERKS__) && !defined(__EDG_VERSION__)))
-#  define ASIO_MSVC _MSC_VER
-# endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
-#endif // !defined(ASIO_MSVC)
-
-// Clang / libc++ detection.
-#if defined(__clang__)
-# if (__cplusplus >= 201103)
-#  if __has_include(<__config>)
-#   include <__config>
-#   if defined(_LIBCPP_VERSION)
-#    define ASIO_HAS_CLANG_LIBCXX 1
-#   endif // defined(_LIBCPP_VERSION)
-#  endif // __has_include(<__config>)
-# endif // (__cplusplus >= 201103)
-#endif // defined(__clang__)
-
-// Android platform detection.
-#if defined(__ANDROID__)
-# include <android/api-level.h>
-#endif // defined(__ANDROID__)
-
-// Always enabled. Retained for backwards compatibility in user code.
-#if !defined(ASIO_DISABLE_CXX11_MACROS)
-# define ASIO_HAS_MOVE 1
-# define ASIO_MOVE_ARG(type) type&&
-# define ASIO_MOVE_ARG2(type1, type2) type1, type2&&
-# define ASIO_NONDEDUCED_MOVE_ARG(type) type&
-# define ASIO_MOVE_CAST(type) static_cast<type&&>
-# define ASIO_MOVE_CAST2(type1, type2) static_cast<type1, type2&&>
-# define ASIO_MOVE_OR_LVALUE(type) static_cast<type&&>
-# define ASIO_MOVE_OR_LVALUE_ARG(type) type&&
-# define ASIO_MOVE_OR_LVALUE_TYPE(type) type
-# define ASIO_DELETED = delete
-# define ASIO_HAS_VARIADIC_TEMPLATES 1
-# define ASIO_HAS_CONSTEXPR 1
-# define ASIO_STATIC_CONSTEXPR(type, assignment) \
-   static constexpr type assignment
-# define ASIO_HAS_NOEXCEPT 1
-# define ASIO_NOEXCEPT noexcept(true)
-# define ASIO_NOEXCEPT_OR_NOTHROW noexcept(true)
-# define ASIO_NOEXCEPT_IF(c) noexcept(c)
-# define ASIO_HAS_DECLTYPE 1
-# define ASIO_AUTO_RETURN_TYPE_PREFIX(t) auto
-# define ASIO_AUTO_RETURN_TYPE_PREFIX2(t0, t1) auto
-# define ASIO_AUTO_RETURN_TYPE_PREFIX3(t0, t1, t2) auto
-# define ASIO_AUTO_RETURN_TYPE_SUFFIX(expr) -> decltype expr
-# define ASIO_HAS_ALIAS_TEMPLATES 1
-# define ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS 1
-# define ASIO_HAS_ENUM_CLASS 1
-# define ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1
-# define ASIO_LVALUE_REF_QUAL &
-# define ASIO_RVALUE_REF_QUAL &&
-# define ASIO_HAS_USER_DEFINED_LITERALS 1
-# define ASIO_HAS_ALIGNOF 1
-# define ASIO_ALIGNOF(T) alignof(T)
-# define ASIO_HAS_STD_ALIGN 1
-# define ASIO_HAS_STD_SYSTEM_ERROR 1
-# define ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true)
-# define ASIO_HAS_STD_ARRAY 1
-# define ASIO_HAS_STD_SHARED_PTR 1
-# define ASIO_HAS_STD_ALLOCATOR_ARG 1
-# define ASIO_HAS_STD_ATOMIC 1
-# define ASIO_HAS_STD_CHRONO 1
-# define ASIO_HAS_STD_ADDRESSOF 1
-# define ASIO_HAS_STD_FUNCTION 1
-# define ASIO_HAS_STD_REFERENCE_WRAPPER 1
-# define ASIO_HAS_STD_TYPE_TRAITS 1
-# define ASIO_HAS_NULLPTR 1
-# define ASIO_HAS_CXX11_ALLOCATORS 1
-# define ASIO_HAS_CSTDINT 1
-# define ASIO_HAS_STD_THREAD 1
-# define ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
-# define ASIO_HAS_STD_CALL_ONCE 1
-# define ASIO_HAS_STD_FUTURE 1
-# define ASIO_HAS_STD_TUPLE 1
-# define ASIO_HAS_STD_IOSTREAM_MOVE 1
-# define ASIO_HAS_STD_EXCEPTION_PTR 1
-# define ASIO_HAS_STD_NESTED_EXCEPTION 1
-# define ASIO_HAS_STD_HASH 1
-#endif // !defined(ASIO_DISABLE_CXX11_MACROS)
-
-// Support for static constexpr with default initialisation.
-#if !defined(ASIO_STATIC_CONSTEXPR_DEFAULT_INIT)
-# if defined(__GNUC__)
-#  if (__GNUC__ >= 8)
-#   define ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \
-     static constexpr const type name{}
-#  else // (__GNUC__ >= 8)
-#   define ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \
-     static const type name
-#  endif // (__GNUC__ >= 8)
-# elif defined(ASIO_MSVC)
-#  define ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \
-    static const type name
-# else // defined(ASIO_MSVC)
-#  define ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \
-    static constexpr const type name{}
-# endif // defined(ASIO_MSVC)
-#endif // !defined(ASIO_STATIC_CONSTEXPR_DEFAULT_INIT)
-
-// Support noexcept on function types on compilers known to allow it.
-#if !defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-# if !defined(ASIO_DISABLE_NOEXCEPT_FUNCTION_TYPE)
-#  if defined(__clang__)
-#   if (__cplusplus >= 202002)
-#    define ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
-#   endif // (__cplusplus >= 202002)
-#  elif defined(__GNUC__)
-#   if (__cplusplus >= 202002)
-#    define ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
-#   endif // (__cplusplus >= 202002)
-#  elif defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1900 && _MSVC_LANG >= 202002)
-#    define ASIO_HAS_NOEXCEPT_FUNCTION_TYPE 1
-#   endif // (_MSC_VER >= 1900 && _MSVC_LANG >= 202002)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_NOEXCEPT_FUNCTION_TYPE)
-#endif // !defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-// Support return type deduction on compilers known to allow it.
-#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-# if !defined(ASIO_DISABLE_RETURN_TYPE_DEDUCTION)
-#  if defined(__clang__)
-#   if __has_feature(__cxx_return_type_deduction__)
-#    define ASIO_HAS_RETURN_TYPE_DEDUCTION 1
-#   endif // __has_feature(__cxx_return_type_deduction__)
-#  elif (__cplusplus >= 201402)
-#   define ASIO_HAS_RETURN_TYPE_DEDUCTION 1
-#  elif defined(__cpp_return_type_deduction)
-#   if (__cpp_return_type_deduction >= 201304)
-#    define ASIO_HAS_RETURN_TYPE_DEDUCTION 1
-#   endif // (__cpp_return_type_deduction >= 201304)
-#  elif defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1900 && _MSVC_LANG >= 201402)
-#    define ASIO_HAS_RETURN_TYPE_DEDUCTION 1
-#   endif // (_MSC_VER >= 1900 && _MSVC_LANG >= 201402)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_RETURN_TYPE_DEDUCTION)
-#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-
-// Support concepts on compilers known to allow them.
-#if !defined(ASIO_HAS_CONCEPTS)
-# if !defined(ASIO_DISABLE_CONCEPTS)
-#  if defined(__cpp_concepts)
-#   define ASIO_HAS_CONCEPTS 1
-#   if (__cpp_concepts >= 201707)
-#    define ASIO_CONCEPT concept
-#   else // (__cpp_concepts >= 201707)
-#    define ASIO_CONCEPT concept bool
-#   endif // (__cpp_concepts >= 201707)
-#  endif // defined(__cpp_concepts)
-# endif // !defined(ASIO_DISABLE_CONCEPTS)
-#endif // !defined(ASIO_HAS_CONCEPTS)
-
-// Support concepts on compilers known to allow them.
-#if !defined(ASIO_HAS_STD_CONCEPTS)
-# if !defined(ASIO_DISABLE_STD_CONCEPTS)
-#  if defined(ASIO_HAS_CONCEPTS)
-#   if (__cpp_lib_concepts >= 202002L)
-#    define ASIO_HAS_STD_CONCEPTS 1
-#   endif // (__cpp_concepts >= 202002L)
-#  endif // defined(ASIO_HAS_CONCEPTS)
-# endif // !defined(ASIO_DISABLE_STD_CONCEPTS)
-#endif // !defined(ASIO_HAS_STD_CONCEPTS)
-
-// Support template variables on compilers known to allow it.
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-# if !defined(ASIO_DISABLE_VARIABLE_TEMPLATES)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201402)
-#    if __has_feature(__cxx_variable_templates__)
-#     define ASIO_HAS_VARIABLE_TEMPLATES 1
-#    endif // __has_feature(__cxx_variable_templates__)
-#   endif // (__cplusplus >= 201402)
-#  elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#   if (__GNUC__ >= 6)
-#    if (__cplusplus >= 201402)
-#     define ASIO_HAS_VARIABLE_TEMPLATES 1
-#    endif // (__cplusplus >= 201402)
-#   endif // (__GNUC__ >= 6)
-#  endif // defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1901)
-#    define ASIO_HAS_VARIABLE_TEMPLATES 1
-#   endif // (_MSC_VER >= 1901)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_VARIABLE_TEMPLATES)
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-// Support SFINAEd template variables on compilers known to allow it.
-#if !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-# if !defined(ASIO_DISABLE_SFINAE_VARIABLE_TEMPLATES)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201703)
-#    if __has_feature(__cxx_variable_templates__)
-#     define ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1
-#    endif // __has_feature(__cxx_variable_templates__)
-#   endif // (__cplusplus >= 201703)
-#  elif defined(__GNUC__)
-#   if ((__GNUC__ == 8) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 8)
-#    if (__cplusplus >= 201402)
-#     define ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1
-#    endif // (__cplusplus >= 201402)
-#   endif // ((__GNUC__ == 8) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 8)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1901)
-#    define ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1
-#   endif // (_MSC_VER >= 1901)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_SFINAE_VARIABLE_TEMPLATES)
-#endif // !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-// Support SFINAE use of constant expressions on compilers known to allow it.
-#if !defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE)
-# if !defined(ASIO_DISABLE_CONSTANT_EXPRESSION_SFINAE)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201402)
-#    define ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1
-#   endif // (__cplusplus >= 201402)
-#  elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#   if (__GNUC__ >= 7)
-#    if (__cplusplus >= 201402)
-#     define ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1
-#    endif // (__cplusplus >= 201402)
-#   endif // (__GNUC__ >= 7)
-#  endif // defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1901)
-#    define ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1
-#   endif // (_MSC_VER >= 1901)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_CONSTANT_EXPRESSION_SFINAE)
-#endif // !defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE)
-
-// Enable workarounds for lack of working expression SFINAE.
-#if !defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# if !defined(ASIO_DISABLE_WORKING_EXPRESSION_SFINAE)
-#  if !defined(ASIO_MSVC) && !defined(__INTEL_COMPILER)
-#   if (__cplusplus >= 201103)
-#    define ASIO_HAS_WORKING_EXPRESSION_SFINAE 1
-#   endif // (__cplusplus >= 201103)
-#  elif defined(ASIO_MSVC) && (_MSC_VER >= 1929)
-#   if (_MSVC_LANG >= 202000)
-#    define ASIO_HAS_WORKING_EXPRESSION_SFINAE 1
-#   endif // (_MSVC_LANG >= 202000)
-#  endif // defined(ASIO_MSVC) && (_MSC_VER >= 1929)
-# endif // !defined(ASIO_DISABLE_WORKING_EXPRESSION_SFINAE)
-#endif // !defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-// Support for capturing parameter packs in lambdas.
-#if !defined(ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-# if !defined(ASIO_DISABLE_VARIADIC_LAMBDA_CAPTURES)
-#  if defined(__GNUC__)
-#   if (__GNUC__ >= 6)
-#    define ASIO_HAS_VARIADIC_LAMBDA_CAPTURES 1
-#   endif // (__GNUC__ >= 6)
-#  elif defined(ASIO_MSVC)
-#   if (_MSVC_LANG >= 201103)
-#    define ASIO_HAS_VARIADIC_LAMBDA_CAPTURES 1
-#   endif // (_MSC_LANG >= 201103)
-#  else // defined(ASIO_MSVC)
-#   if (__cplusplus >= 201103)
-#    define ASIO_HAS_VARIADIC_LAMBDA_CAPTURES 1
-#   endif // (__cplusplus >= 201103)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_VARIADIC_LAMBDA_CAPTURES)
-#endif // !defined(ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-
-// Default alignment.
-#if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
-# define ASIO_DEFAULT_ALIGN __STDCPP_DEFAULT_NEW_ALIGNMENT__
-#elif defined(__GNUC__)
-# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
-#  define ASIO_DEFAULT_ALIGN alignof(std::max_align_t)
-# else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
-#  define ASIO_DEFAULT_ALIGN alignof(max_align_t)
-# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
-#else // defined(__GNUC__)
-# define ASIO_DEFAULT_ALIGN alignof(std::max_align_t)
-#endif // defined(__GNUC__)
-
-// Standard library support for aligned allocation.
-#if !defined(ASIO_HAS_STD_ALIGNED_ALLOC)
-# if !defined(ASIO_DISABLE_STD_ALIGNED_ALLOC)
-#  if (__cplusplus >= 201703)
-#   if defined(__clang__)
-#    if defined(ASIO_HAS_CLANG_LIBCXX)
-#     if (_LIBCPP_STD_VER > 14) && defined(_LIBCPP_HAS_ALIGNED_ALLOC) \
-        && !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__)
-#      if defined(__APPLE__)
-#       if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#        if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-#         define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#        endif // (__MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
-#       elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
-#        if (__IPHONE_OS_VERSION_MIN_REQUIRED >= 130000)
-#         define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#        endif // (__IPHONE_OS_VERSION_MIN_REQUIRED >= 130000)
-#       elif defined(__TV_OS_VERSION_MIN_REQUIRED)
-#        if (__TV_OS_VERSION_MIN_REQUIRED >= 130000)
-#         define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#        endif // (__TV_OS_VERSION_MIN_REQUIRED >= 130000)
-#       elif defined(__WATCH_OS_VERSION_MIN_REQUIRED)
-#        if (__WATCH_OS_VERSION_MIN_REQUIRED >= 60000)
-#         define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#        endif // (__WATCH_OS_VERSION_MIN_REQUIRED >= 60000)
-#       endif // defined(__WATCH_OS_X_VERSION_MIN_REQUIRED)
-#      else // defined(__APPLE__)
-#       define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#      endif // defined(__APPLE__)
-#     endif // (_LIBCPP_STD_VER > 14) && defined(_LIBCPP_HAS_ALIGNED_ALLOC)
-            //   && !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__)
-#    elif defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
-#     define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#    endif // defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
-#   elif defined(__GNUC__)
-#    if ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 7)
-#     if defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
-#      define ASIO_HAS_STD_ALIGNED_ALLOC 1
-#     endif // defined(_GLIBCXX_HAVE_ALIGNED_ALLOC)
-#    endif // ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 7)
-#   endif // defined(__GNUC__)
-#  endif // (__cplusplus >= 201703)
-# endif // !defined(ASIO_DISABLE_STD_ALIGNED_ALLOC)
-#endif // !defined(ASIO_HAS_STD_ALIGNED_ALLOC)
-
-// Boost support for chrono.
-#if !defined(ASIO_HAS_BOOST_CHRONO)
-# if !defined(ASIO_DISABLE_BOOST_CHRONO)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 104700)
-#   define ASIO_HAS_BOOST_CHRONO 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 104700)
-# endif // !defined(ASIO_DISABLE_BOOST_CHRONO)
-#endif // !defined(ASIO_HAS_BOOST_CHRONO)
-
-// Some form of chrono library is available.
-#if !defined(ASIO_HAS_CHRONO)
-# if defined(ASIO_HAS_STD_CHRONO) \
-    || defined(ASIO_HAS_BOOST_CHRONO)
-#  define ASIO_HAS_CHRONO 1
-# endif // defined(ASIO_HAS_STD_CHRONO)
-        // || defined(ASIO_HAS_BOOST_CHRONO)
-#endif // !defined(ASIO_HAS_CHRONO)
-
-// Boost support for the DateTime library.
-#if !defined(ASIO_HAS_BOOST_DATE_TIME)
-# if !defined(ASIO_DISABLE_BOOST_DATE_TIME)
-#  define ASIO_HAS_BOOST_DATE_TIME 1
-# endif // !defined(ASIO_DISABLE_BOOST_DATE_TIME)
-#endif // !defined(ASIO_HAS_BOOST_DATE_TIME)
-
-// Boost support for the Coroutine library.
-#if !defined(ASIO_HAS_BOOST_COROUTINE)
-# if !defined(ASIO_DISABLE_BOOST_COROUTINE)
-#  define ASIO_HAS_BOOST_COROUTINE 1
-# endif // !defined(ASIO_DISABLE_BOOST_COROUTINE)
-#endif // !defined(ASIO_HAS_BOOST_COROUTINE)
-
-// Boost support for the Context library's fibers.
-#if !defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-# if !defined(ASIO_DISABLE_BOOST_CONTEXT_FIBER)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201103)
-#    define ASIO_HAS_BOOST_CONTEXT_FIBER 1
-#   endif // (__cplusplus >= 201103)
-#  elif defined(__GNUC__)
-#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#    if (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#     define ASIO_HAS_BOOST_CONTEXT_FIBER 1
-#    endif // (__cplusplus >= 201103) || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSVC_LANG >= 201103)
-#    define ASIO_HAS_BOOST_CONTEXT_FIBER 1
-#   endif // (_MSC_LANG >= 201103)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_BOOST_CONTEXT_FIBER)
-#endif // !defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-// Standard library support for std::string_view.
-#if !defined(ASIO_HAS_STD_STRING_VIEW)
-# if !defined(ASIO_DISABLE_STD_STRING_VIEW)
-#  if defined(__clang__)
-#   if defined(ASIO_HAS_CLANG_LIBCXX)
-#    if (__cplusplus >= 201402)
-#     if __has_include(<string_view>)
-#      define ASIO_HAS_STD_STRING_VIEW 1
-#     endif // __has_include(<string_view>)
-#    endif // (__cplusplus >= 201402)
-#   else // defined(ASIO_HAS_CLANG_LIBCXX)
-#    if (__cplusplus >= 201703)
-#     if __has_include(<string_view>)
-#      define ASIO_HAS_STD_STRING_VIEW 1
-#     endif // __has_include(<string_view>)
-#    endif // (__cplusplus >= 201703)
-#   endif // defined(ASIO_HAS_CLANG_LIBCXX)
-#  elif defined(__GNUC__)
-#   if (__GNUC__ >= 7)
-#    if (__cplusplus >= 201703)
-#     define ASIO_HAS_STD_STRING_VIEW 1
-#    endif // (__cplusplus >= 201703)
-#   endif // (__GNUC__ >= 7)
-#  elif defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1910 && _MSVC_LANG >= 201703)
-#    define ASIO_HAS_STD_STRING_VIEW 1
-#   endif // (_MSC_VER >= 1910 && _MSVC_LANG >= 201703)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_STRING_VIEW)
-#endif // !defined(ASIO_HAS_STD_STRING_VIEW)
-
-// Standard library support for std::experimental::string_view.
-#if !defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-# if !defined(ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW)
-#  if defined(__clang__)
-#   if defined(ASIO_HAS_CLANG_LIBCXX)
-#    if (_LIBCPP_VERSION < 7000)
-#     if (__cplusplus >= 201402)
-#      if __has_include(<experimental/string_view>)
-#       define ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
-#      endif // __has_include(<experimental/string_view>)
-#     endif // (__cplusplus >= 201402)
-#    endif // (_LIBCPP_VERSION < 7000)
-#   else // defined(ASIO_HAS_CLANG_LIBCXX)
-#    if (__cplusplus >= 201402)
-#     if __has_include(<experimental/string_view>)
-#      define ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
-#     endif // __has_include(<experimental/string_view>)
-#    endif // (__cplusplus >= 201402)
-#   endif // // defined(ASIO_HAS_CLANG_LIBCXX)
-#  elif defined(__GNUC__)
-#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
-#    if (__cplusplus >= 201402)
-#     define ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
-#    endif // (__cplusplus >= 201402)
-#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
-#  endif // defined(__GNUC__)
-# endif // !defined(ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW)
-#endif // !defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-
-// Standard library has a string_view that we can use.
-#if !defined(ASIO_HAS_STRING_VIEW)
-# if !defined(ASIO_DISABLE_STRING_VIEW)
-#  if defined(ASIO_HAS_STD_STRING_VIEW)
-#   define ASIO_HAS_STRING_VIEW 1
-#  elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-#   define ASIO_HAS_STRING_VIEW 1
-#  endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-# endif // !defined(ASIO_DISABLE_STRING_VIEW)
-#endif // !defined(ASIO_HAS_STRING_VIEW)
-
-// Standard library has invoke_result (which supersedes result_of).
-#if !defined(ASIO_HAS_STD_INVOKE_RESULT)
-# if !defined(ASIO_DISABLE_STD_INVOKE_RESULT)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1911 && _MSVC_LANG >= 201703)
-#    define ASIO_HAS_STD_INVOKE_RESULT 1
-#   endif // (_MSC_VER >= 1911 && _MSVC_LANG >= 201703)
-#  else // defined(ASIO_MSVC)
-#   if (__cplusplus >= 201703)
-#    define ASIO_HAS_STD_INVOKE_RESULT 1
-#   endif // (__cplusplus >= 201703)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_INVOKE_RESULT)
-#endif // !defined(ASIO_HAS_STD_INVOKE_RESULT)
-
-// Standard library support for std::any.
-#if !defined(ASIO_HAS_STD_ANY)
-# if !defined(ASIO_DISABLE_STD_ANY)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201703)
-#    if __has_include(<any>)
-#     define ASIO_HAS_STD_ANY 1
-#    endif // __has_include(<any>)
-#   endif // (__cplusplus >= 201703)
-#  elif defined(__GNUC__)
-#   if (__GNUC__ >= 7)
-#    if (__cplusplus >= 201703)
-#     define ASIO_HAS_STD_ANY 1
-#    endif // (__cplusplus >= 201703)
-#   endif // (__GNUC__ >= 7)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703)
-#    define ASIO_HAS_STD_ANY 1
-#   endif // (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_ANY)
-#endif // !defined(ASIO_HAS_STD_ANY)
-
-// Standard library support for std::variant.
-#if !defined(ASIO_HAS_STD_VARIANT)
-# if !defined(ASIO_DISABLE_STD_VARIANT)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201703)
-#    if __has_include(<variant>)
-#     define ASIO_HAS_STD_VARIANT 1
-#    endif // __has_include(<variant>)
-#   endif // (__cplusplus >= 201703)
-#  elif defined(__GNUC__)
-#   if (__GNUC__ >= 7)
-#    if (__cplusplus >= 201703)
-#     define ASIO_HAS_STD_VARIANT 1
-#    endif // (__cplusplus >= 201703)
-#   endif // (__GNUC__ >= 7)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703)
-#    define ASIO_HAS_STD_VARIANT 1
-#   endif // (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_VARIANT)
-#endif // !defined(ASIO_HAS_STD_VARIANT)
-
-// Standard library support for std::source_location.
-#if !defined(ASIO_HAS_STD_SOURCE_LOCATION)
-# if !defined(ASIO_DISABLE_STD_SOURCE_LOCATION)
-// ...
-# endif // !defined(ASIO_DISABLE_STD_SOURCE_LOCATION)
-#endif // !defined(ASIO_HAS_STD_SOURCE_LOCATION)
-
-// Standard library support for std::experimental::source_location.
-#if !defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-# if !defined(ASIO_DISABLE_STD_EXPERIMENTAL_SOURCE_LOCATION)
-#  if defined(__GNUC__)
-#   if (__cplusplus >= 201709)
-#    if __has_include(<experimental/source_location>)
-#     define ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION 1
-#    endif // __has_include(<experimental/source_location>)
-#   endif // (__cplusplus >= 201709)
-#  endif // defined(__GNUC__)
-# endif // !defined(ASIO_DISABLE_STD_EXPERIMENTAL_SOURCE_LOCATION)
-#endif // !defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-
-// Standard library has a source_location that we can use.
-#if !defined(ASIO_HAS_SOURCE_LOCATION)
-# if !defined(ASIO_DISABLE_SOURCE_LOCATION)
-#  if defined(ASIO_HAS_STD_SOURCE_LOCATION)
-#   define ASIO_HAS_SOURCE_LOCATION 1
-#  elif defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-#   define ASIO_HAS_SOURCE_LOCATION 1
-#  endif // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-# endif // !defined(ASIO_DISABLE_SOURCE_LOCATION)
-#endif // !defined(ASIO_HAS_SOURCE_LOCATION)
-
-// Boost support for source_location and system errors.
-#if !defined(ASIO_HAS_BOOST_SOURCE_LOCATION)
-# if !defined(ASIO_DISABLE_BOOST_SOURCE_LOCATION)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 107900)
-#   define ASIO_HAS_BOOST_SOURCE_LOCATION 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 107900)
-# endif // !defined(ASIO_DISABLE_BOOST_SOURCE_LOCATION)
-#endif // !defined(ASIO_HAS_BOOST_SOURCE_LOCATION)
-
-// Helper macros for working with Boost source locations.
-#if defined(ASIO_HAS_BOOST_SOURCE_LOCATION)
-# define ASIO_SOURCE_LOCATION_PARAM \
-  , const boost::source_location& loc
-# define ASIO_SOURCE_LOCATION_DEFAULTED_PARAM \
-  , const boost::source_location& loc = BOOST_CURRENT_LOCATION
-# define ASIO_SOURCE_LOCATION_ARG , loc
-#else // if defined(ASIO_HAS_BOOST_SOURCE_LOCATION)
-# define ASIO_SOURCE_LOCATION_PARAM
-# define ASIO_SOURCE_LOCATION_DEFAULTED_PARAM
-# define ASIO_SOURCE_LOCATION_ARG
-#endif // if defined(ASIO_HAS_BOOST_SOURCE_LOCATION)
-
-// Standard library support for std::index_sequence.
-#if !defined(ASIO_HAS_STD_INDEX_SEQUENCE)
-# if !defined(ASIO_DISABLE_STD_INDEX_SEQUENCE)
-#  if defined(__clang__)
-#   if (__cplusplus >= 201402)
-#    define ASIO_HAS_STD_INDEX_SEQUENCE 1
-#   endif // (__cplusplus >= 201402)
-#  elif defined(__GNUC__)
-#   if (__GNUC__ >= 7)
-#    if (__cplusplus >= 201402)
-#     define ASIO_HAS_STD_INDEX_SEQUENCE 1
-#    endif // (__cplusplus >= 201402)
-#   endif // (__GNUC__ >= 7)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1910) && (_MSVC_LANG >= 201402)
-#    define ASIO_HAS_STD_INDEX_SEQUENCE 1
-#   endif // (_MSC_VER >= 1910) && (_MSVC_LANG >= 201402)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_INDEX_SEQUENCE)
-#endif // !defined(ASIO_HAS_STD_INDEX_SEQUENCE)
-
-// Windows App target. Windows but with a limited API.
-#if !defined(ASIO_WINDOWS_APP)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
-#  include <winapifamily.h>
-#  if (WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
-       || WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)) \
-   && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#   define ASIO_WINDOWS_APP 1
-#  endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-         // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
-#endif // !defined(ASIO_WINDOWS_APP)
-
-// Legacy WinRT target. Windows App is preferred.
-#if !defined(ASIO_WINDOWS_RUNTIME)
-# if !defined(ASIO_WINDOWS_APP)
-#  if defined(__cplusplus_winrt)
-#   include <winapifamily.h>
-#   if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
-    && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#    define ASIO_WINDOWS_RUNTIME 1
-#   endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
-          // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#  endif // defined(__cplusplus_winrt)
-# endif // !defined(ASIO_WINDOWS_APP)
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-// Windows target. Excludes WinRT but includes Windows App targets.
-#if !defined(ASIO_WINDOWS)
-# if !defined(ASIO_WINDOWS_RUNTIME)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
-#   define ASIO_WINDOWS 1
-#  elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-#   define ASIO_WINDOWS 1
-#  elif defined(ASIO_WINDOWS_APP)
-#   define ASIO_WINDOWS 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
-# endif // !defined(ASIO_WINDOWS_RUNTIME)
-#endif // !defined(ASIO_WINDOWS)
-
-// Windows: target OS version.
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
-#  if defined(_MSC_VER) || (defined(__BORLANDC__) && !defined(__clang__))
-#   pragma message( \
-  "Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\
-  "- add -D_WIN32_WINNT=0x0601 to the compiler command line; or\n"\
-  "- add _WIN32_WINNT=0x0601 to your project's Preprocessor Definitions.\n"\
-  "Assuming _WIN32_WINNT=0x0601 (i.e. Windows 7 target).")
-#  else // defined(_MSC_VER) || (defined(__BORLANDC__) && !defined(__clang__))
-#   warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately.
-#   warning For example, add -D_WIN32_WINNT=0x0601 to the compiler command line.
-#   warning Assuming _WIN32_WINNT=0x0601 (i.e. Windows 7 target).
-#  endif // defined(_MSC_VER) || (defined(__BORLANDC__) && !defined(__clang__))
-#  define _WIN32_WINNT 0x0601
-# endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
-# if defined(_MSC_VER)
-#  if defined(_WIN32) && !defined(WIN32)
-#   if !defined(_WINSOCK2API_)
-#    define WIN32 // Needed for correct types in winsock2.h
-#   else // !defined(_WINSOCK2API_)
-#    error Please define the macro WIN32 in your compiler options
-#   endif // !defined(_WINSOCK2API_)
-#  endif // defined(_WIN32) && !defined(WIN32)
-# endif // defined(_MSC_VER)
-# if defined(__BORLANDC__)
-#  if defined(__WIN32__) && !defined(WIN32)
-#   if !defined(_WINSOCK2API_)
-#    define WIN32 // Needed for correct types in winsock2.h
-#   else // !defined(_WINSOCK2API_)
-#    error Please define the macro WIN32 in your compiler options
-#   endif // !defined(_WINSOCK2API_)
-#  endif // defined(__WIN32__) && !defined(WIN32)
-# endif // defined(__BORLANDC__)
-# if defined(__CYGWIN__)
-#  if !defined(__USE_W32_SOCKETS)
-#   error You must add -D__USE_W32_SOCKETS to your compiler options.
-#  endif // !defined(__USE_W32_SOCKETS)
-# endif // defined(__CYGWIN__)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: minimise header inclusion.
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if !defined(ASIO_NO_WIN32_LEAN_AND_MEAN)
-#  if !defined(WIN32_LEAN_AND_MEAN)
-#   define WIN32_LEAN_AND_MEAN
-#  endif // !defined(WIN32_LEAN_AND_MEAN)
-# endif // !defined(ASIO_NO_WIN32_LEAN_AND_MEAN)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: suppress definition of "min" and "max" macros.
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if !defined(ASIO_NO_NOMINMAX)
-#  if !defined(NOMINMAX)
-#   define NOMINMAX 1
-#  endif // !defined(NOMINMAX)
-# endif // !defined(ASIO_NO_NOMINMAX)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: IO Completion Ports.
-#if !defined(ASIO_HAS_IOCP)
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#  if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#   if !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
-#    if !defined(ASIO_DISABLE_IOCP)
-#     define ASIO_HAS_IOCP 1
-#    endif // !defined(ASIO_DISABLE_IOCP)
-#   endif // !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
-#  endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#endif // !defined(ASIO_HAS_IOCP)
-
-// On POSIX (and POSIX-like) platforms we need to include unistd.h in order to
-// get access to the various platform feature macros, e.g. to be able to test
-// for threads support.
-#if !defined(ASIO_HAS_UNISTD_H)
-# if !defined(ASIO_HAS_BOOST_CONFIG)
-#  if defined(unix) \
-   || defined(__unix) \
-   || defined(_XOPEN_SOURCE) \
-   || defined(_POSIX_SOURCE) \
-   || (defined(__MACH__) && defined(__APPLE__)) \
-   || defined(__FreeBSD__) \
-   || defined(__NetBSD__) \
-   || defined(__OpenBSD__) \
-   || defined(__linux__) \
-   || defined(__HAIKU__)
-#   define ASIO_HAS_UNISTD_H 1
-#  endif
-# endif // !defined(ASIO_HAS_BOOST_CONFIG)
-#endif // !defined(ASIO_HAS_UNISTD_H)
-#if defined(ASIO_HAS_UNISTD_H)
-# include <unistd.h>
-#endif // defined(ASIO_HAS_UNISTD_H)
-
-// Linux: epoll, eventfd, timerfd and io_uring.
-#if defined(__linux__)
-# include <linux/version.h>
-# if !defined(ASIO_HAS_EPOLL)
-#  if !defined(ASIO_DISABLE_EPOLL)
-#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-#    define ASIO_HAS_EPOLL 1
-#   endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-#  endif // !defined(ASIO_DISABLE_EPOLL)
-# endif // !defined(ASIO_HAS_EPOLL)
-# if !defined(ASIO_HAS_EVENTFD)
-#  if !defined(ASIO_DISABLE_EVENTFD)
-#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-#    define ASIO_HAS_EVENTFD 1
-#   endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-#  endif // !defined(ASIO_DISABLE_EVENTFD)
-# endif // !defined(ASIO_HAS_EVENTFD)
-# if !defined(ASIO_HAS_TIMERFD)
-#  if defined(ASIO_HAS_EPOLL)
-#   if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-#    define ASIO_HAS_TIMERFD 1
-#   endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-#  endif // defined(ASIO_HAS_EPOLL)
-# endif // !defined(ASIO_HAS_TIMERFD)
-# if defined(ASIO_HAS_IO_URING)
-#  if LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
-#   error Linux kernel 5.10 or later is required to support io_uring
-#  endif // LINUX_VERSION_CODE < KERNEL_VERSION(5,10,0)
-# endif // defined(ASIO_HAS_IO_URING)
-#endif // defined(__linux__)
-
-// Linux: io_uring is used instead of epoll.
-#if !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# if !defined(ASIO_HAS_EPOLL) && defined(ASIO_HAS_IO_URING)
-#  define ASIO_HAS_IO_URING_AS_DEFAULT 1
-# endif // !defined(ASIO_HAS_EPOLL) && defined(ASIO_HAS_IO_URING)
-#endif // !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-// Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
-#if (defined(__MACH__) && defined(__APPLE__)) \
-  || defined(__FreeBSD__) \
-  || defined(__NetBSD__) \
-  || defined(__OpenBSD__)
-# if !defined(ASIO_HAS_KQUEUE)
-#  if !defined(ASIO_DISABLE_KQUEUE)
-#   define ASIO_HAS_KQUEUE 1
-#  endif // !defined(ASIO_DISABLE_KQUEUE)
-# endif // !defined(ASIO_HAS_KQUEUE)
-#endif // (defined(__MACH__) && defined(__APPLE__))
-       //   || defined(__FreeBSD__)
-       //   || defined(__NetBSD__)
-       //   || defined(__OpenBSD__)
-
-// Solaris: /dev/poll.
-#if defined(__sun)
-# if !defined(ASIO_HAS_DEV_POLL)
-#  if !defined(ASIO_DISABLE_DEV_POLL)
-#   define ASIO_HAS_DEV_POLL 1
-#  endif // !defined(ASIO_DISABLE_DEV_POLL)
-# endif // !defined(ASIO_HAS_DEV_POLL)
-#endif // defined(__sun)
-
-// Serial ports.
-#if !defined(ASIO_HAS_SERIAL_PORT)
-# if defined(ASIO_HAS_IOCP) \
-  || !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-#  if !defined(__SYMBIAN32__)
-#   if !defined(ASIO_DISABLE_SERIAL_PORT)
-#    define ASIO_HAS_SERIAL_PORT 1
-#   endif // !defined(ASIO_DISABLE_SERIAL_PORT)
-#  endif // !defined(__SYMBIAN32__)
-# endif // defined(ASIO_HAS_IOCP)
-        //   || !defined(ASIO_WINDOWS)
-        //   && !defined(ASIO_WINDOWS_RUNTIME)
-        //   && !defined(__CYGWIN__)
-#endif // !defined(ASIO_HAS_SERIAL_PORT)
-
-// Windows: stream handles.
-#if !defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-# if !defined(ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
-#  if defined(ASIO_HAS_IOCP)
-#   define ASIO_HAS_WINDOWS_STREAM_HANDLE 1
-#  endif // defined(ASIO_HAS_IOCP)
-# endif // !defined(ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
-#endif // !defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-
-// Windows: random access handles.
-#if !defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-# if !defined(ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
-#  if defined(ASIO_HAS_IOCP)
-#   define ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1
-#  endif // defined(ASIO_HAS_IOCP)
-# endif // !defined(ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
-#endif // !defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-
-// Windows: object handles.
-#if !defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-# if !defined(ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
-#  if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#   if !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
-#    define ASIO_HAS_WINDOWS_OBJECT_HANDLE 1
-#   endif // !defined(UNDER_CE) && !defined(ASIO_WINDOWS_APP)
-#  endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# endif // !defined(ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
-#endif // !defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-// Windows: OVERLAPPED wrapper.
-#if !defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-# if !defined(ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
-#  if defined(ASIO_HAS_IOCP)
-#   define ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1
-#  endif // defined(ASIO_HAS_IOCP)
-# endif // !defined(ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
-#endif // !defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-
-// POSIX: stream-oriented file descriptors.
-#if !defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-# if !defined(ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
-#  if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-#   define ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
-#  endif // !defined(ASIO_WINDOWS)
-         //   && !defined(ASIO_WINDOWS_RUNTIME)
-         //   && !defined(__CYGWIN__)
-# endif // !defined(ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
-#endif // !defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-// UNIX domain sockets.
-#if !defined(ASIO_HAS_LOCAL_SOCKETS)
-# if !defined(ASIO_DISABLE_LOCAL_SOCKETS)
-#  if !defined(ASIO_WINDOWS_RUNTIME)
-#   define ASIO_HAS_LOCAL_SOCKETS 1
-#  endif // !defined(ASIO_WINDOWS_RUNTIME)
-# endif // !defined(ASIO_DISABLE_LOCAL_SOCKETS)
-#endif // !defined(ASIO_HAS_LOCAL_SOCKETS)
-
-// Files.
-#if !defined(ASIO_HAS_FILE)
-# if !defined(ASIO_DISABLE_FILE)
-#  if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-#   define ASIO_HAS_FILE 1
-#  elif defined(ASIO_HAS_IO_URING)
-#   define ASIO_HAS_FILE 1
-#  endif // defined(ASIO_HAS_IO_URING)
-# endif // !defined(ASIO_DISABLE_FILE)
-#endif // !defined(ASIO_HAS_FILE)
-
-// Pipes.
-#if !defined(ASIO_HAS_PIPE)
-# if defined(ASIO_HAS_IOCP) \
-  || !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-#  if !defined(__SYMBIAN32__)
-#   if !defined(ASIO_DISABLE_PIPE)
-#    define ASIO_HAS_PIPE 1
-#   endif // !defined(ASIO_DISABLE_PIPE)
-#  endif // !defined(__SYMBIAN32__)
-# endif // defined(ASIO_HAS_IOCP)
-        //   || !defined(ASIO_WINDOWS)
-        //   && !defined(ASIO_WINDOWS_RUNTIME)
-        //   && !defined(__CYGWIN__)
-#endif // !defined(ASIO_HAS_PIPE)
-
-// Can use sigaction() instead of signal().
-#if !defined(ASIO_HAS_SIGACTION)
-# if !defined(ASIO_DISABLE_SIGACTION)
-#  if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-#   define ASIO_HAS_SIGACTION 1
-#  endif // !defined(ASIO_WINDOWS)
-         //   && !defined(ASIO_WINDOWS_RUNTIME)
-         //   && !defined(__CYGWIN__)
-# endif // !defined(ASIO_DISABLE_SIGACTION)
-#endif // !defined(ASIO_HAS_SIGACTION)
-
-// Can use signal().
-#if !defined(ASIO_HAS_SIGNAL)
-# if !defined(ASIO_DISABLE_SIGNAL)
-#  if !defined(UNDER_CE)
-#   define ASIO_HAS_SIGNAL 1
-#  endif // !defined(UNDER_CE)
-# endif // !defined(ASIO_DISABLE_SIGNAL)
-#endif // !defined(ASIO_HAS_SIGNAL)
-
-// Can use getaddrinfo() and getnameinfo().
-#if !defined(ASIO_HAS_GETADDRINFO)
-# if !defined(ASIO_DISABLE_GETADDRINFO)
-#  if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#   if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
-#    define ASIO_HAS_GETADDRINFO 1
-#   elif defined(UNDER_CE)
-#    define ASIO_HAS_GETADDRINFO 1
-#   endif // defined(UNDER_CE)
-#  elif defined(__MACH__) && defined(__APPLE__)
-#   if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#    if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
-#     define ASIO_HAS_GETADDRINFO 1
-#    endif // (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
-#   else // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#    define ASIO_HAS_GETADDRINFO 1
-#   endif // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#  else // defined(__MACH__) && defined(__APPLE__)
-#   define ASIO_HAS_GETADDRINFO 1
-#  endif // defined(__MACH__) && defined(__APPLE__)
-# endif // !defined(ASIO_DISABLE_GETADDRINFO)
-#endif // !defined(ASIO_HAS_GETADDRINFO)
-
-// Whether standard iostreams are disabled.
-#if !defined(ASIO_NO_IOSTREAM)
-# if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_IOSTREAM)
-#  define ASIO_NO_IOSTREAM 1
-# endif // !defined(BOOST_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-// Whether exception handling is disabled.
-#if !defined(ASIO_NO_EXCEPTIONS)
-# if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_EXCEPTIONS)
-#  define ASIO_NO_EXCEPTIONS 1
-# endif // !defined(BOOST_NO_EXCEPTIONS)
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-
-// Whether the typeid operator is supported.
-#if !defined(ASIO_NO_TYPEID)
-# if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_TYPEID)
-#  define ASIO_NO_TYPEID 1
-# endif // !defined(BOOST_NO_TYPEID)
-#endif // !defined(ASIO_NO_TYPEID)
-
-// Threads.
-#if !defined(ASIO_HAS_THREADS)
-# if !defined(ASIO_DISABLE_THREADS)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(__GNUC__) && !defined(__MINGW32__) \
-     && !defined(linux) && !defined(__linux) && !defined(__linux__)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(_MT) || defined(__MT__)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(_REENTRANT)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(__APPLE__)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(__HAIKU__)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
-#   define ASIO_HAS_THREADS 1
-#  elif defined(_PTHREADS)
-#   define ASIO_HAS_THREADS 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
-# endif // !defined(ASIO_DISABLE_THREADS)
-#endif // !defined(ASIO_HAS_THREADS)
-
-// POSIX threads.
-#if !defined(ASIO_HAS_PTHREADS)
-# if defined(ASIO_HAS_THREADS)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
-#   define ASIO_HAS_PTHREADS 1
-#  elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
-#   define ASIO_HAS_PTHREADS 1
-#  elif defined(__HAIKU__)
-#   define ASIO_HAS_PTHREADS 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
-# endif // defined(ASIO_HAS_THREADS)
-#endif // !defined(ASIO_HAS_PTHREADS)
-
-// Helper to prevent macro expansion.
-#define ASIO_PREVENT_MACRO_SUBSTITUTION
-
-// Helper to define in-class constants.
-#if !defined(ASIO_STATIC_CONSTANT)
-# if !defined(ASIO_DISABLE_BOOST_STATIC_CONSTANT)
-#  define ASIO_STATIC_CONSTANT(type, assignment) \
-    BOOST_STATIC_CONSTANT(type, assignment)
-# else // !defined(ASIO_DISABLE_BOOST_STATIC_CONSTANT)
-#  define ASIO_STATIC_CONSTANT(type, assignment) \
-    static const type assignment
-# endif // !defined(ASIO_DISABLE_BOOST_STATIC_CONSTANT)
-#endif // !defined(ASIO_STATIC_CONSTANT)
-
-// Boost align library.
-#if !defined(ASIO_HAS_BOOST_ALIGN)
-# if !defined(ASIO_DISABLE_BOOST_ALIGN)
-#  if defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105600)
-#   define ASIO_HAS_BOOST_ALIGN 1
-#  endif // defined(ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105600)
-# endif // !defined(ASIO_DISABLE_BOOST_ALIGN)
-#endif // !defined(ASIO_HAS_BOOST_ALIGN)
-
-// Boost array library.
-#if !defined(ASIO_HAS_BOOST_ARRAY)
-# if !defined(ASIO_DISABLE_BOOST_ARRAY)
-#  define ASIO_HAS_BOOST_ARRAY 1
-# endif // !defined(ASIO_DISABLE_BOOST_ARRAY)
-#endif // !defined(ASIO_HAS_BOOST_ARRAY)
-
-// Boost assert macro.
-#if !defined(ASIO_HAS_BOOST_ASSERT)
-# if !defined(ASIO_DISABLE_BOOST_ASSERT)
-#  define ASIO_HAS_BOOST_ASSERT 1
-# endif // !defined(ASIO_DISABLE_BOOST_ASSERT)
-#endif // !defined(ASIO_HAS_BOOST_ASSERT)
-
-// Boost limits header.
-#if !defined(ASIO_HAS_BOOST_LIMITS)
-# if !defined(ASIO_DISABLE_BOOST_LIMITS)
-#  define ASIO_HAS_BOOST_LIMITS 1
-# endif // !defined(ASIO_DISABLE_BOOST_LIMITS)
-#endif // !defined(ASIO_HAS_BOOST_LIMITS)
-
-// Boost throw_exception function.
-#if !defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-# if !defined(ASIO_DISABLE_BOOST_THROW_EXCEPTION)
-#  define ASIO_HAS_BOOST_THROW_EXCEPTION 1
-# endif // !defined(ASIO_DISABLE_BOOST_THROW_EXCEPTION)
-#endif // !defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-
-// Boost regex library.
-#if !defined(ASIO_HAS_BOOST_REGEX)
-# if !defined(ASIO_DISABLE_BOOST_REGEX)
-#  define ASIO_HAS_BOOST_REGEX 1
-# endif // !defined(ASIO_DISABLE_BOOST_REGEX)
-#endif // !defined(ASIO_HAS_BOOST_REGEX)
-
-// Boost bind function.
-#if !defined(ASIO_HAS_BOOST_BIND)
-# if !defined(ASIO_DISABLE_BOOST_BIND)
-#  define ASIO_HAS_BOOST_BIND 1
-# endif // !defined(ASIO_DISABLE_BOOST_BIND)
-#endif // !defined(ASIO_HAS_BOOST_BIND)
-
-// Boost's BOOST_WORKAROUND macro.
-#if !defined(ASIO_HAS_BOOST_WORKAROUND)
-# if !defined(ASIO_DISABLE_BOOST_WORKAROUND)
-#  define ASIO_HAS_BOOST_WORKAROUND 1
-# endif // !defined(ASIO_DISABLE_BOOST_WORKAROUND)
-#endif // !defined(ASIO_HAS_BOOST_WORKAROUND)
-
-// Microsoft Visual C++'s secure C runtime library.
-#if !defined(ASIO_HAS_SECURE_RTL)
-# if !defined(ASIO_DISABLE_SECURE_RTL)
-#  if defined(ASIO_MSVC) \
-    && (ASIO_MSVC >= 1400) \
-    && !defined(UNDER_CE)
-#   define ASIO_HAS_SECURE_RTL 1
-#  endif // defined(ASIO_MSVC)
-         // && (ASIO_MSVC >= 1400)
-         // && !defined(UNDER_CE)
-# endif // !defined(ASIO_DISABLE_SECURE_RTL)
-#endif // !defined(ASIO_HAS_SECURE_RTL)
-
-// Handler hooking. Disabled for ancient Borland C++ and gcc compilers.
-#if !defined(ASIO_HAS_HANDLER_HOOKS)
-# if !defined(ASIO_DISABLE_HANDLER_HOOKS)
-#  if defined(__GNUC__)
-#   if (__GNUC__ >= 3)
-#    define ASIO_HAS_HANDLER_HOOKS 1
-#   endif // (__GNUC__ >= 3)
-#  elif !defined(__BORLANDC__) || defined(__clang__)
-#   define ASIO_HAS_HANDLER_HOOKS 1
-#  endif // !defined(__BORLANDC__) || defined(__clang__)
-# endif // !defined(ASIO_DISABLE_HANDLER_HOOKS)
-#endif // !defined(ASIO_HAS_HANDLER_HOOKS)
-
-// Support for the __thread keyword extension, or equivalent.
-#if !defined(ASIO_DISABLE_THREAD_KEYWORD_EXTENSION)
-# if defined(__linux__)
-#  if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-#   if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
-#    if !defined(__INTEL_COMPILER) && !defined(__ICL) \
-       && !(defined(__clang__) && defined(__ANDROID__))
-#     define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
-#     define ASIO_THREAD_KEYWORD __thread
-#    elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
-#     define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
-#    endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
-           // && !(defined(__clang__) && defined(__ANDROID__))
-#   endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
-#  endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-# endif // defined(__linux__)
-# if defined(ASIO_MSVC) && defined(ASIO_WINDOWS_RUNTIME)
-#  if (_MSC_VER >= 1700)
-#   define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
-#   define ASIO_THREAD_KEYWORD __declspec(thread)
-#  endif // (_MSC_VER >= 1700)
-# endif // defined(ASIO_MSVC) && defined(ASIO_WINDOWS_RUNTIME)
-# if defined(__APPLE__)
-#  if defined(__clang__)
-#   if defined(__apple_build_version__)
-#    define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
-#    define ASIO_THREAD_KEYWORD __thread
-#   endif // defined(__apple_build_version__)
-#  endif // defined(__clang__)
-# endif // defined(__APPLE__)
-# if !defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-#  if defined(ASIO_HAS_BOOST_CONFIG)
-#   if !defined(BOOST_NO_CXX11_THREAD_LOCAL)
-#    define ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
-#    define ASIO_THREAD_KEYWORD thread_local
-#   endif // !defined(BOOST_NO_CXX11_THREAD_LOCAL)
-#  endif // defined(ASIO_HAS_BOOST_CONFIG)
-# endif // !defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-#endif // !defined(ASIO_DISABLE_THREAD_KEYWORD_EXTENSION)
-#if !defined(ASIO_THREAD_KEYWORD)
-# define ASIO_THREAD_KEYWORD __thread
-#endif // !defined(ASIO_THREAD_KEYWORD)
-
-// Support for POSIX ssize_t typedef.
-#if !defined(ASIO_DISABLE_SSIZE_T)
-# if defined(__linux__) \
-   || (defined(__MACH__) && defined(__APPLE__))
-#  define ASIO_HAS_SSIZE_T 1
-# endif // defined(__linux__)
-        //   || (defined(__MACH__) && defined(__APPLE__))
-#endif // !defined(ASIO_DISABLE_SSIZE_T)
-
-// Helper macros to manage transition away from error_code return values.
-#if defined(ASIO_NO_DEPRECATED)
-# define ASIO_SYNC_OP_VOID void
-# define ASIO_SYNC_OP_VOID_RETURN(e) return
-#else // defined(ASIO_NO_DEPRECATED)
-# define ASIO_SYNC_OP_VOID asio::error_code
-# define ASIO_SYNC_OP_VOID_RETURN(e) return e
-#endif // defined(ASIO_NO_DEPRECATED)
-
-// Newer gcc, clang need special treatment to suppress unused typedef warnings.
-#if defined(__clang__)
-# if defined(__apple_build_version__)
-#  if (__clang_major__ >= 7)
-#   define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
-#  endif // (__clang_major__ >= 7)
-# elif ((__clang_major__ == 3) && (__clang_minor__ >= 6)) \
-    || (__clang_major__ > 3)
-#  define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
-# endif // ((__clang_major__ == 3) && (__clang_minor__ >= 6))
-        //   || (__clang_major__ > 3)
-#elif defined(__GNUC__)
-# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#  define ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
-# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
-#endif // defined(__GNUC__)
-#if !defined(ASIO_UNUSED_TYPEDEF)
-# define ASIO_UNUSED_TYPEDEF
-#endif // !defined(ASIO_UNUSED_TYPEDEF)
-
-// Some versions of gcc generate spurious warnings about unused variables.
-#if defined(__GNUC__)
-# if (__GNUC__ >= 4)
-#  define ASIO_UNUSED_VARIABLE __attribute__((__unused__))
-# endif // (__GNUC__ >= 4)
-#endif // defined(__GNUC__)
-#if !defined(ASIO_UNUSED_VARIABLE)
-# define ASIO_UNUSED_VARIABLE
-#endif // !defined(ASIO_UNUSED_VARIABLE)
-
-// Helper macro to tell the optimiser what may be assumed to be true.
-#if defined(ASIO_MSVC)
-# define ASIO_ASSUME(expr) __assume(expr)
-#elif defined(__clang__)
-# if __has_builtin(__builtin_assume)
-#  define ASIO_ASSUME(expr) __builtin_assume(expr)
-# endif // __has_builtin(__builtin_assume)
-#elif defined(__GNUC__)
-# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-#  define ASIO_ASSUME(expr) if (expr) {} else { __builtin_unreachable(); }
-# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-#endif // defined(__GNUC__)
-#if !defined(ASIO_ASSUME)
-# define ASIO_ASSUME(expr) (void)0
-#endif // !defined(ASIO_ASSUME)
-
-// Support the co_await keyword on compilers known to allow it.
-#if !defined(ASIO_HAS_CO_AWAIT)
-# if !defined(ASIO_DISABLE_CO_AWAIT)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705) && !defined(__clang__)
-#    define ASIO_HAS_CO_AWAIT 1
-#   elif (_MSC_FULL_VER >= 190023506)
-#    if defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
-#     define ASIO_HAS_CO_AWAIT 1
-#    endif // defined(_RESUMABLE_FUNCTIONS_SUPPORTED)
-#   endif // (_MSC_FULL_VER >= 190023506)
-#  elif defined(__clang__)
-#   if (__clang_major__ >= 14)
-#    if (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
-#     if __has_include(<coroutine>)
-#      define ASIO_HAS_CO_AWAIT 1
-#     endif // __has_include(<coroutine>)
-#    elif (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
-#     if __has_include(<experimental/coroutine>)
-#      define ASIO_HAS_CO_AWAIT 1
-#     endif // __has_include(<experimental/coroutine>)
-#    endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
-#   else // (__clang_major__ >= 14)
-#    if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
-#     if __has_include(<experimental/coroutine>)
-#      define ASIO_HAS_CO_AWAIT 1
-#     endif // __has_include(<experimental/coroutine>)
-#    endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703)
-#   endif // (__clang_major__ >= 14)
-#  elif defined(__GNUC__)
-#   if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
-#    if __has_include(<coroutine>)
-#     define ASIO_HAS_CO_AWAIT 1
-#    endif // __has_include(<coroutine>)
-#   endif // (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
-#  endif // defined(__GNUC__)
-# endif // !defined(ASIO_DISABLE_CO_AWAIT)
-#endif // !defined(ASIO_HAS_CO_AWAIT)
-
-// Standard library support for coroutines.
-#if !defined(ASIO_HAS_STD_COROUTINE)
-# if !defined(ASIO_DISABLE_STD_COROUTINE)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705)
-#    define ASIO_HAS_STD_COROUTINE 1
-#   endif // (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705)
-#  elif defined(__clang__)
-#   if (__clang_major__ >= 14)
-#    if (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
-#     if __has_include(<coroutine>)
-#      define ASIO_HAS_STD_COROUTINE 1
-#     endif // __has_include(<coroutine>)
-#    endif // (__cplusplus >= 202002) && (__cpp_impl_coroutine >= 201902)
-#   endif // (__clang_major__ >= 14)
-#  elif defined(__GNUC__)
-#   if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
-#    if __has_include(<coroutine>)
-#     define ASIO_HAS_STD_COROUTINE 1
-#    endif // __has_include(<coroutine>)
-#   endif // (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902)
-#  endif // defined(__GNUC__)
-# endif // !defined(ASIO_DISABLE_STD_COROUTINE)
-#endif // !defined(ASIO_HAS_STD_COROUTINE)
-
-// Compiler support for the the [[nodiscard]] attribute.
-#if !defined(ASIO_NODISCARD)
-# if defined(__has_cpp_attribute)
-#  if __has_cpp_attribute(nodiscard)
-#   if (__cplusplus >= 201703)
-#    define ASIO_NODISCARD [[nodiscard]]
-#   endif // (__cplusplus >= 201703)
-#  endif // __has_cpp_attribute(nodiscard)
-# endif // defined(__has_cpp_attribute)
-#endif // !defined(ASIO_NODISCARD)
-#if !defined(ASIO_NODISCARD)
-# define ASIO_NODISCARD
-#endif // !defined(ASIO_NODISCARD)
-
-// Kernel support for MSG_NOSIGNAL.
-#if !defined(ASIO_HAS_MSG_NOSIGNAL)
-# if defined(__linux__)
-#  define ASIO_HAS_MSG_NOSIGNAL 1
-# elif defined(_POSIX_VERSION)
-#  if (_POSIX_VERSION >= 200809L)
-#   define ASIO_HAS_MSG_NOSIGNAL 1
-#  endif // _POSIX_VERSION >= 200809L
-# endif // defined(_POSIX_VERSION)
-#endif // !defined(ASIO_HAS_MSG_NOSIGNAL)
-
-// Standard library support for std::to_address.
-#if !defined(ASIO_HAS_STD_TO_ADDRESS)
-# if !defined(ASIO_DISABLE_STD_TO_ADDRESS)
-#  if defined(__clang__)
-#   if (__cplusplus >= 202002)
-#    define ASIO_HAS_STD_TO_ADDRESS 1
-#   endif // (__cplusplus >= 202002)
-#  elif defined(__GNUC__)
-#   if (__GNUC__ >= 8)
-#    if (__cplusplus >= 202002)
-#     define ASIO_HAS_STD_TO_ADDRESS 1
-#    endif // (__cplusplus >= 202002)
-#   endif // (__GNUC__ >= 8)
-#  endif // defined(__GNUC__)
-#  if defined(ASIO_MSVC)
-#   if (_MSC_VER >= 1922) && (_MSVC_LANG >= 202002)
-#    define ASIO_HAS_STD_TO_ADDRESS 1
-#   endif // (_MSC_VER >= 1922) && (_MSVC_LANG >= 202002)
-#  endif // defined(ASIO_MSVC)
-# endif // !defined(ASIO_DISABLE_STD_TO_ADDRESS)
-#endif // !defined(ASIO_HAS_STD_TO_ADDRESS)
-
-// Standard library support for snprintf.
-#if !defined(ASIO_HAS_SNPRINTF)
-# if !defined(ASIO_DISABLE_SNPRINTF)
-#  if defined(__apple_build_version__)
-#    if (__clang_major__ >= 14)
-#     define ASIO_HAS_SNPRINTF 1
-#    endif // (__clang_major__ >= 14)
-#  endif // defined(__apple_build_version__)
-# endif // !defined(ASIO_DISABLE_SNPRINTF)
-#endif // !defined(ASIO_HAS_SNPRINTF)
-
-#endif // ASIO_DETAIL_CONFIG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/consuming_buffers.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/consuming_buffers.hpp
deleted file mode 100644
index 8af95aa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/consuming_buffers.hpp
+++ /dev/null
@@ -1,443 +0,0 @@
-//
-// detail/consuming_buffers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONSUMING_BUFFERS_HPP
-#define ASIO_DETAIL_CONSUMING_BUFFERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/buffer.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/registered_buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper template to determine the maximum number of prepared buffers.
-template <typename Buffers>
-struct prepared_buffers_max
-{
-  enum { value = buffer_sequence_adapter_base::max_buffers };
-};
-
-template <typename Elem, std::size_t N>
-struct prepared_buffers_max<boost::array<Elem, N>>
-{
-  enum { value = N };
-};
-
-template <typename Elem, std::size_t N>
-struct prepared_buffers_max<std::array<Elem, N>>
-{
-  enum { value = N };
-};
-
-// A buffer sequence used to represent a subsequence of the buffers.
-template <typename Buffer, std::size_t MaxBuffers>
-struct prepared_buffers
-{
-  typedef Buffer value_type;
-  typedef const Buffer* const_iterator;
-
-  enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 };
-
-  prepared_buffers() : count(0) {}
-  const_iterator begin() const { return elems; }
-  const_iterator end() const { return elems + count; }
-
-  Buffer elems[max_buffers];
-  std::size_t count;
-};
-
-// A proxy for a sub-range in a list of buffers.
-template <typename Buffer, typename Buffers, typename Buffer_Iterator>
-class consuming_buffers
-{
-public:
-  typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value>
-    prepared_buffers_type;
-
-  // Construct to represent the entire list of buffers.
-  explicit consuming_buffers(const Buffers& buffers)
-    : buffers_(buffers),
-      total_consumed_(0),
-      next_elem_(0),
-      next_elem_offset_(0)
-  {
-    using asio::buffer_size;
-    total_size_ = buffer_size(buffers);
-  }
-
-  // Determine if we are at the end of the buffers.
-  bool empty() const
-  {
-    return total_consumed_ >= total_size_;
-  }
-
-  // Get the buffer for a single transfer, with a size.
-  prepared_buffers_type prepare(std::size_t max_size)
-  {
-    prepared_buffers_type result;
-
-    Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
-    Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
-
-    std::advance(next, next_elem_);
-    std::size_t elem_offset = next_elem_offset_;
-    while (next != end && max_size > 0 && (result.count) < result.max_buffers)
-    {
-      Buffer next_buf = Buffer(*next) + elem_offset;
-      result.elems[result.count] = asio::buffer(next_buf, max_size);
-      max_size -= result.elems[result.count].size();
-      elem_offset = 0;
-      if (result.elems[result.count].size() > 0)
-        ++result.count;
-      ++next;
-    }
-
-    return result;
-  }
-
-  // Consume the specified number of bytes from the buffers.
-  void consume(std::size_t size)
-  {
-    total_consumed_ += size;
-
-    Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
-    Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
-
-    std::advance(next, next_elem_);
-    while (next != end && size > 0)
-    {
-      Buffer next_buf = Buffer(*next) + next_elem_offset_;
-      if (size < next_buf.size())
-      {
-        next_elem_offset_ += size;
-        size = 0;
-      }
-      else
-      {
-        size -= next_buf.size();
-        next_elem_offset_ = 0;
-        ++next_elem_;
-        ++next;
-      }
-    }
-  }
-
-  // Get the total number of bytes consumed from the buffers.
-  std::size_t total_consumed() const
-  {
-    return total_consumed_;
-  }
-
-private:
-  Buffers buffers_;
-  std::size_t total_size_;
-  std::size_t total_consumed_;
-  std::size_t next_elem_;
-  std::size_t next_elem_offset_;
-};
-
-// Base class of all consuming_buffers specialisations for single buffers.
-template <typename Buffer>
-class consuming_single_buffer
-{
-public:
-  // Construct to represent the entire list of buffers.
-  template <typename Buffer1>
-  explicit consuming_single_buffer(const Buffer1& buffer)
-    : buffer_(buffer),
-      total_consumed_(0)
-  {
-  }
-
-  // Determine if we are at the end of the buffers.
-  bool empty() const
-  {
-    return total_consumed_ >= buffer_.size();
-  }
-
-  // Get the buffer for a single transfer, with a size.
-  Buffer prepare(std::size_t max_size)
-  {
-    return asio::buffer(buffer_ + total_consumed_, max_size);
-  }
-
-  // Consume the specified number of bytes from the buffers.
-  void consume(std::size_t size)
-  {
-    total_consumed_ += size;
-  }
-
-  // Get the total number of bytes consumed from the buffers.
-  std::size_t total_consumed() const
-  {
-    return total_consumed_;
-  }
-
-private:
-  Buffer buffer_;
-  std::size_t total_consumed_;
-};
-
-template <>
-class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*>
-  : public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
-{
-public:
-  explicit consuming_buffers(const mutable_buffer& buffer)
-    : consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*>
-  : public consuming_single_buffer<ASIO_CONST_BUFFER>
-{
-public:
-  explicit consuming_buffers(const mutable_buffer& buffer)
-    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer, const_buffer, const const_buffer*>
-  : public consuming_single_buffer<ASIO_CONST_BUFFER>
-{
-public:
-  explicit consuming_buffers(const const_buffer& buffer)
-    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
-  {
-  }
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-template <>
-class consuming_buffers<mutable_buffer,
-    mutable_buffers_1, const mutable_buffer*>
-  : public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
-{
-public:
-  explicit consuming_buffers(const mutable_buffers_1& buffer)
-    : consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*>
-  : public consuming_single_buffer<ASIO_CONST_BUFFER>
-{
-public:
-  explicit consuming_buffers(const mutable_buffers_1& buffer)
-    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*>
-  : public consuming_single_buffer<ASIO_CONST_BUFFER>
-{
-public:
-  explicit consuming_buffers(const const_buffers_1& buffer)
-    : consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
-  {
-  }
-};
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <>
-class consuming_buffers<mutable_buffer,
-    mutable_registered_buffer, const mutable_buffer*>
-  : public consuming_single_buffer<mutable_registered_buffer>
-{
-public:
-  explicit consuming_buffers(const mutable_registered_buffer& buffer)
-    : consuming_single_buffer<mutable_registered_buffer>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer,
-    mutable_registered_buffer, const mutable_buffer*>
-  : public consuming_single_buffer<mutable_registered_buffer>
-{
-public:
-  explicit consuming_buffers(const mutable_registered_buffer& buffer)
-    : consuming_single_buffer<mutable_registered_buffer>(buffer)
-  {
-  }
-};
-
-template <>
-class consuming_buffers<const_buffer,
-    const_registered_buffer, const const_buffer*>
-  : public consuming_single_buffer<const_registered_buffer>
-{
-public:
-  explicit consuming_buffers(const const_registered_buffer& buffer)
-    : consuming_single_buffer<const_registered_buffer>(buffer)
-  {
-  }
-};
-
-template <typename Buffer, typename Elem>
-class consuming_buffers<Buffer, boost::array<Elem, 2>,
-    typename boost::array<Elem, 2>::const_iterator>
-{
-public:
-  // Construct to represent the entire list of buffers.
-  explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
-    : buffers_(buffers),
-      total_consumed_(0)
-  {
-  }
-
-  // Determine if we are at the end of the buffers.
-  bool empty() const
-  {
-    return total_consumed_ >=
-      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
-  }
-
-  // Get the buffer for a single transfer, with a size.
-  boost::array<Buffer, 2> prepare(std::size_t max_size)
-  {
-    boost::array<Buffer, 2> result = {{
-      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
-    std::size_t buffer0_size = result[0].size();
-    result[0] = asio::buffer(result[0] + total_consumed_, max_size);
-    result[1] = asio::buffer(
-        result[1] + (total_consumed_ < buffer0_size
-          ? 0 : total_consumed_ - buffer0_size),
-        max_size - result[0].size());
-    return result;
-  }
-
-  // Consume the specified number of bytes from the buffers.
-  void consume(std::size_t size)
-  {
-    total_consumed_ += size;
-  }
-
-  // Get the total number of bytes consumed from the buffers.
-  std::size_t total_consumed() const
-  {
-    return total_consumed_;
-  }
-
-private:
-  boost::array<Elem, 2> buffers_;
-  std::size_t total_consumed_;
-};
-
-template <typename Buffer, typename Elem>
-class consuming_buffers<Buffer, std::array<Elem, 2>,
-    typename std::array<Elem, 2>::const_iterator>
-{
-public:
-  // Construct to represent the entire list of buffers.
-  explicit consuming_buffers(const std::array<Elem, 2>& buffers)
-    : buffers_(buffers),
-      total_consumed_(0)
-  {
-  }
-
-  // Determine if we are at the end of the buffers.
-  bool empty() const
-  {
-    return total_consumed_ >=
-      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
-  }
-
-  // Get the buffer for a single transfer, with a size.
-  std::array<Buffer, 2> prepare(std::size_t max_size)
-  {
-    std::array<Buffer, 2> result = {{
-      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
-    std::size_t buffer0_size = result[0].size();
-    result[0] = asio::buffer(result[0] + total_consumed_, max_size);
-    result[1] = asio::buffer(
-        result[1] + (total_consumed_ < buffer0_size
-          ? 0 : total_consumed_ - buffer0_size),
-        max_size - result[0].size());
-    return result;
-  }
-
-  // Consume the specified number of bytes from the buffers.
-  void consume(std::size_t size)
-  {
-    total_consumed_ += size;
-  }
-
-  // Get the total number of bytes consumed from the buffers.
-  std::size_t total_consumed() const
-  {
-    return total_consumed_;
-  }
-
-private:
-  std::array<Elem, 2> buffers_;
-  std::size_t total_consumed_;
-};
-
-// Specialisation for null_buffers to ensure that the null_buffers type is
-// always passed through to the underlying read or write operation.
-template <typename Buffer>
-class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
-  : public asio::null_buffers
-{
-public:
-  consuming_buffers(const null_buffers&)
-  {
-    // No-op.
-  }
-
-  bool empty()
-  {
-    return false;
-  }
-
-  null_buffers prepare(std::size_t)
-  {
-    return null_buffers();
-  }
-
-  void consume(std::size_t)
-  {
-    // No-op.
-  }
-
-  std::size_t total_consumed() const
-  {
-    return 0;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CONSUMING_BUFFERS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstddef.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstddef.hpp
deleted file mode 100644
index 15ec42d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstddef.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// detail/cstddef.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CSTDDEF_HPP
-#define ASIO_DETAIL_CSTDDEF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-
-namespace asio {
-
-using std::nullptr_t;
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_CSTDDEF_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstdint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstdint.hpp
deleted file mode 100644
index a696e34..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/cstdint.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// detail/cstdint.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CSTDINT_HPP
-#define ASIO_DETAIL_CSTDINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstdint>
-
-namespace asio {
-
-using std::int16_t;
-using std::int_least16_t;
-using std::uint16_t;
-using std::uint_least16_t;
-using std::int32_t;
-using std::int_least32_t;
-using std::uint32_t;
-using std::uint_least32_t;
-using std::int64_t;
-using std::int_least64_t;
-using std::uint64_t;
-using std::uint_least64_t;
-using std::uintptr_t;
-using std::uintmax_t;
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_CSTDINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/date_time_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/date_time_fwd.hpp
deleted file mode 100644
index a586fbe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/date_time_fwd.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// detail/date_time_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DATE_TIME_FWD_HPP
-#define ASIO_DETAIL_DATE_TIME_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-namespace boost {
-namespace date_time {
-
-template<class T, class TimeSystem>
-class base_time;
-
-} // namespace date_time
-namespace posix_time {
-
-class ptime;
-
-} // namespace posix_time
-} // namespace boost
-
-#endif // ASIO_DETAIL_DATE_TIME_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/deadline_timer_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/deadline_timer_service.hpp
deleted file mode 100644
index e26e8c5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/deadline_timer_service.hpp
+++ /dev/null
@@ -1,339 +0,0 @@
-//
-// detail/deadline_timer_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
-#define ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_queue.hpp"
-#include "asio/detail/timer_queue_ptime.hpp"
-#include "asio/detail/timer_scheduler.hpp"
-#include "asio/detail/wait_handler.hpp"
-#include "asio/detail/wait_op.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include <chrono>
-# include <thread>
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-class deadline_timer_service
-  : public execution_context_service_base<deadline_timer_service<Time_Traits>>
-{
-public:
-  // The time type.
-  typedef typename Time_Traits::time_type time_type;
-
-  // The duration type.
-  typedef typename Time_Traits::duration_type duration_type;
-
-  // The implementation type of the timer. This type is dependent on the
-  // underlying implementation of the timer service.
-  struct implementation_type
-    : private asio::detail::noncopyable
-  {
-    time_type expiry;
-    bool might_have_pending_waits;
-    typename timer_queue<Time_Traits>::per_timer_data timer_data;
-  };
-
-  // Constructor.
-  deadline_timer_service(execution_context& context)
-    : execution_context_service_base<
-        deadline_timer_service<Time_Traits>>(context),
-      scheduler_(asio::use_service<timer_scheduler>(context))
-  {
-    scheduler_.init_task();
-    scheduler_.add_timer_queue(timer_queue_);
-  }
-
-  // Destructor.
-  ~deadline_timer_service()
-  {
-    scheduler_.remove_timer_queue(timer_queue_);
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-  }
-
-  // Construct a new timer implementation.
-  void construct(implementation_type& impl)
-  {
-    impl.expiry = time_type();
-    impl.might_have_pending_waits = false;
-  }
-
-  // Destroy a timer implementation.
-  void destroy(implementation_type& impl)
-  {
-    asio::error_code ec;
-    cancel(impl, ec);
-  }
-
-  // Move-construct a new timer implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    if (other_impl.might_have_pending_waits)
-    {
-      scheduler_.move_timer(timer_queue_,
-          impl.timer_data, other_impl.timer_data);
-    }
-
-    impl.expiry = other_impl.expiry;
-    other_impl.expiry = time_type();
-
-    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
-    other_impl.might_have_pending_waits = false;
-  }
-
-  // Move-assign from another timer implementation.
-  void move_assign(implementation_type& impl,
-      deadline_timer_service& other_service,
-      implementation_type& other_impl)
-  {
-    if (this != &other_service)
-      if (impl.might_have_pending_waits)
-        scheduler_.cancel_timer(timer_queue_, impl.timer_data);
-
-    other_service.scheduler_.move_timer(other_service.timer_queue_,
-        impl.timer_data, other_impl.timer_data);
-
-    impl.expiry = other_impl.expiry;
-    other_impl.expiry = time_type();
-
-    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
-    other_impl.might_have_pending_waits = false;
-  }
-
-  // Move-construct a new timer implementation.
-  void converting_move_construct(implementation_type& impl,
-      deadline_timer_service&, implementation_type& other_impl)
-  {
-    move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another timer implementation.
-  void converting_move_assign(implementation_type& impl,
-      deadline_timer_service& other_service,
-      implementation_type& other_impl)
-  {
-    move_assign(impl, other_service, other_impl);
-  }
-
-  // Cancel any asynchronous wait operations associated with the timer.
-  std::size_t cancel(implementation_type& impl, asio::error_code& ec)
-  {
-    if (!impl.might_have_pending_waits)
-    {
-      ec = asio::error_code();
-      return 0;
-    }
-
-    ASIO_HANDLER_OPERATION((scheduler_.context(),
-          "deadline_timer", &impl, 0, "cancel"));
-
-    std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
-    impl.might_have_pending_waits = false;
-    ec = asio::error_code();
-    return count;
-  }
-
-  // Cancels one asynchronous wait operation associated with the timer.
-  std::size_t cancel_one(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    if (!impl.might_have_pending_waits)
-    {
-      ec = asio::error_code();
-      return 0;
-    }
-
-    ASIO_HANDLER_OPERATION((scheduler_.context(),
-          "deadline_timer", &impl, 0, "cancel_one"));
-
-    std::size_t count = scheduler_.cancel_timer(
-        timer_queue_, impl.timer_data, 1);
-    if (count == 0)
-      impl.might_have_pending_waits = false;
-    ec = asio::error_code();
-    return count;
-  }
-
-  // Get the expiry time for the timer as an absolute time.
-  time_type expiry(const implementation_type& impl) const
-  {
-    return impl.expiry;
-  }
-
-  // Get the expiry time for the timer as an absolute time.
-  time_type expires_at(const implementation_type& impl) const
-  {
-    return impl.expiry;
-  }
-
-  // Get the expiry time for the timer relative to now.
-  duration_type expires_from_now(const implementation_type& impl) const
-  {
-    return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
-  }
-
-  // Set the expiry time for the timer as an absolute time.
-  std::size_t expires_at(implementation_type& impl,
-      const time_type& expiry_time, asio::error_code& ec)
-  {
-    std::size_t count = cancel(impl, ec);
-    impl.expiry = expiry_time;
-    ec = asio::error_code();
-    return count;
-  }
-
-  // Set the expiry time for the timer relative to now.
-  std::size_t expires_after(implementation_type& impl,
-      const duration_type& expiry_time, asio::error_code& ec)
-  {
-    return expires_at(impl,
-        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
-  }
-
-  // Set the expiry time for the timer relative to now.
-  std::size_t expires_from_now(implementation_type& impl,
-      const duration_type& expiry_time, asio::error_code& ec)
-  {
-    return expires_at(impl,
-        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
-  }
-
-  // Perform a blocking wait on the timer.
-  void wait(implementation_type& impl, asio::error_code& ec)
-  {
-    time_type now = Time_Traits::now();
-    ec = asio::error_code();
-    while (Time_Traits::less_than(now, impl.expiry) && !ec)
-    {
-      this->do_wait(Time_Traits::to_posix_duration(
-            Time_Traits::subtract(impl.expiry, now)), ec);
-      now = Time_Traits::now();
-    }
-  }
-
-  // Start an asynchronous wait on the timer.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(implementation_type& impl,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef wait_handler<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<op_cancellation>(this, &impl.timer_data);
-    }
-
-    impl.might_have_pending_waits = true;
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "deadline_timer", &impl, 0, "async_wait"));
-
-    scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Helper function to wait given a duration type. The duration type should
-  // either be of type boost::posix_time::time_duration, or implement the
-  // required subset of its interface.
-  template <typename Duration>
-  void do_wait(const Duration& timeout, asio::error_code& ec)
-  {
-#if defined(ASIO_WINDOWS_RUNTIME)
-    std::this_thread::sleep_for(
-        std::chrono::seconds(timeout.total_seconds())
-        + std::chrono::microseconds(timeout.total_microseconds()));
-    ec = asio::error_code();
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    ::timeval tv;
-    tv.tv_sec = timeout.total_seconds();
-    tv.tv_usec = timeout.total_microseconds() % 1000000;
-    socket_ops::select(0, 0, 0, 0, &tv, ec);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-  }
-
-  // Helper class used to implement per-operation cancellation.
-  class op_cancellation
-  {
-  public:
-    op_cancellation(deadline_timer_service* s,
-        typename timer_queue<Time_Traits>::per_timer_data* p)
-      : service_(s),
-        timer_data_(p)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        service_->scheduler_.cancel_timer_by_key(
-            service_->timer_queue_, timer_data_, this);
-      }
-    }
-
-  private:
-    deadline_timer_service* service_;
-    typename timer_queue<Time_Traits>::per_timer_data* timer_data_;
-  };
-
-  // The queue of timers.
-  timer_queue<Time_Traits> timer_queue_;
-
-  // The object that schedules and executes timers. Usually a reactor.
-  timer_scheduler& scheduler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dependent_type.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dependent_type.hpp
deleted file mode 100644
index fde0e4a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dependent_type.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// detail/dependent_type.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEPENDENT_TYPE_HPP
-#define ASIO_DETAIL_DEPENDENT_TYPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename DependsOn, typename T>
-struct dependent_type
-{
-  typedef T type;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_DEPENDENT_TYPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_ops.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_ops.hpp
deleted file mode 100644
index c001696..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_ops.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//
-// detail/descriptor_ops.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_OPS_HPP
-#define ASIO_DETAIL_DESCRIPTOR_OPS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-
-#include <cstddef>
-#include "asio/error.hpp"
-#include "asio/error_code.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace descriptor_ops {
-
-// Descriptor state bits.
-enum
-{
-  // The user wants a non-blocking descriptor.
-  user_set_non_blocking = 1,
-
-  // The descriptor has been set non-blocking.
-  internal_non_blocking = 2,
-
-  // Helper "state" used to determine whether the descriptor is non-blocking.
-  non_blocking = user_set_non_blocking | internal_non_blocking,
-
-  // The descriptor may have been dup()-ed.
-  possible_dup = 4
-};
-
-typedef unsigned char state_type;
-
-inline void get_last_error(
-    asio::error_code& ec, bool is_error_condition)
-{
-  if (!is_error_condition)
-  {
-    asio::error::clear(ec);
-  }
-  else
-  {
-    ec = asio::error_code(errno,
-        asio::error::get_system_category());
-  }
-}
-
-ASIO_DECL int open(const char* path, int flags,
-    asio::error_code& ec);
-
-ASIO_DECL int open(const char* path, int flags, unsigned mode,
-    asio::error_code& ec);
-
-ASIO_DECL int close(int d, state_type& state,
-    asio::error_code& ec);
-
-ASIO_DECL bool set_user_non_blocking(int d,
-    state_type& state, bool value, asio::error_code& ec);
-
-ASIO_DECL bool set_internal_non_blocking(int d,
-    state_type& state, bool value, asio::error_code& ec);
-
-typedef iovec buf;
-
-ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec);
-
-ASIO_DECL std::size_t sync_read1(int d, state_type state, void* data,
-    std::size_t size, asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_read1(int d, void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL std::size_t sync_write(int d, state_type state,
-    const buf* bufs, std::size_t count, bool all_empty,
-    asio::error_code& ec);
-
-ASIO_DECL std::size_t sync_write1(int d, state_type state,
-    const void* data, std::size_t size, asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_write(int d,
-    const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_write1(int d,
-    const void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-#if defined(ASIO_HAS_FILE)
-
-ASIO_DECL std::size_t sync_read_at(int d, state_type state,
-    uint64_t offset, buf* bufs, std::size_t count, bool all_empty,
-    asio::error_code& ec);
-
-ASIO_DECL std::size_t sync_read_at1(int d, state_type state,
-    uint64_t offset, void* data, std::size_t size,
-    asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_read_at(int d, uint64_t offset,
-    buf* bufs, std::size_t count, asio::error_code& ec,
-    std::size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_read_at1(int d, uint64_t offset,
-    void* data, std::size_t size, asio::error_code& ec,
-    std::size_t& bytes_transferred);
-
-ASIO_DECL std::size_t sync_write_at(int d, state_type state,
-    uint64_t offset, const buf* bufs, std::size_t count, bool all_empty,
-    asio::error_code& ec);
-
-ASIO_DECL std::size_t sync_write_at1(int d, state_type state,
-    uint64_t offset, const void* data, std::size_t size,
-    asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_write_at(int d,
-    uint64_t offset, const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_write_at1(int d,
-    uint64_t offset, const void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-#endif // defined(ASIO_HAS_FILE)
-
-ASIO_DECL int ioctl(int d, state_type& state, long cmd,
-    ioctl_arg_type* arg, asio::error_code& ec);
-
-ASIO_DECL int fcntl(int d, int cmd, asio::error_code& ec);
-
-ASIO_DECL int fcntl(int d, int cmd,
-    long arg, asio::error_code& ec);
-
-ASIO_DECL int poll_read(int d,
-    state_type state, asio::error_code& ec);
-
-ASIO_DECL int poll_write(int d,
-    state_type state, asio::error_code& ec);
-
-ASIO_DECL int poll_error(int d,
-    state_type state, asio::error_code& ec);
-
-} // namespace descriptor_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/descriptor_ops.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_OPS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_read_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_read_op.hpp
deleted file mode 100644
index 415490c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_read_op.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// detail/descriptor_read_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
-#define ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/dispatch.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class descriptor_read_op_base : public reactor_op
-{
-public:
-  descriptor_read_op_base(const asio::error_code& success_ec,
-      int descriptor, const MutableBufferSequence& buffers,
-      func_type complete_func)
-    : reactor_op(success_ec,
-        &descriptor_read_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      buffers_(buffers)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = descriptor_ops::non_blocking_read1(o->descriptor_,
-          bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(),
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      result = descriptor_ops::non_blocking_read(o->descriptor_,
-          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-        ? done : not_done;
-    }
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_read",
-          o->ec_, o->bytes_transferred_));
-
-    return result;
-  }
-
-private:
-  int descriptor_;
-  MutableBufferSequence buffers_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class descriptor_read_op
-  : public descriptor_read_op_base<MutableBufferSequence>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
-
-  descriptor_read_op(const asio::error_code& success_ec,
-      int descriptor, const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : descriptor_read_op_base<MutableBufferSequence>(success_ec,
-        descriptor, buffers, &descriptor_read_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_write_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_write_op.hpp
deleted file mode 100644
index ed1814e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/descriptor_write_op.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// detail/descriptor_write_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
-#define ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class descriptor_write_op_base : public reactor_op
-{
-public:
-  descriptor_write_op_base(const asio::error_code& success_ec,
-      int descriptor, const ConstBufferSequence& buffers,
-      func_type complete_func)
-    : reactor_op(success_ec,
-        &descriptor_write_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      buffers_(buffers)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = descriptor_ops::non_blocking_write1(o->descriptor_,
-          bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(),
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      result = descriptor_ops::non_blocking_write(o->descriptor_,
-          bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
-        ? done : not_done;
-    }
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_write",
-          o->ec_, o->bytes_transferred_));
-
-    return result;
-  }
-
-private:
-  int descriptor_;
-  ConstBufferSequence buffers_;
-};
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class descriptor_write_op
-  : public descriptor_write_op_base<ConstBufferSequence>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
-
-  descriptor_write_op(const asio::error_code& success_ec,
-      int descriptor, const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : descriptor_write_op_base<ConstBufferSequence>(success_ec,
-        descriptor, buffers, &descriptor_write_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dev_poll_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dev_poll_reactor.hpp
deleted file mode 100644
index 720fd6b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/dev_poll_reactor.hpp
+++ /dev/null
@@ -1,247 +0,0 @@
-//
-// detail/dev_poll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEV_POLL_REACTOR_HPP
-#define ASIO_DETAIL_DEV_POLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include <cstddef>
-#include <vector>
-#include <sys/devpoll.h>
-#include "asio/detail/hash_map.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/reactor_op_queue.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class dev_poll_reactor
-  : public execution_context_service_base<dev_poll_reactor>,
-    public scheduler_task
-{
-public:
-  enum op_types { read_op = 0, write_op = 1,
-    connect_op = 1, except_op = 2, max_ops = 3 };
-
-  // Per-descriptor data.
-  struct per_descriptor_data
-  {
-  };
-
-  // Constructor.
-  ASIO_DECL dev_poll_reactor(asio::execution_context& ctx);
-
-  // Destructor.
-  ASIO_DECL ~dev_poll_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal descriptors following a fork.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
-
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // success, system error code on failure.
-  ASIO_DECL int register_internal_descriptor(
-      int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op);
-
-  // Move descriptor registration from one descriptor_data object to another.
-  ASIO_DECL void move_descriptor(socket_type descriptor,
-      per_descriptor_data& target_descriptor_data,
-      per_descriptor_data& source_descriptor_data);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(operation* op, bool is_continuation) const;
-
-  // Post a reactor operation for immediate completion.
-  ASIO_DECL static void call_post_immediate_completion(
-      operation* op, bool is_continuation, const void* self);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data&, reactor_op* op,
-      bool is_continuation, bool allow_speculative,
-      void (*on_immediate)(operation*, bool, const void*),
-      const void* immediate_arg);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative)
-  {
-    start_op(op_type, descriptor, descriptor_data,
-        op, is_continuation, allow_speculative,
-        &dev_poll_reactor::call_post_immediate_completion, this);
-  }
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
-
-  // Cancel all operations associated with the given descriptor and key. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      int op_type, void* cancellation_key);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor. The reactor resources associated with
-  // the descriptor must be released by calling cleanup_descriptor_data.
-  ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data&, bool closing);
-
-  // Remove the descriptor's registration from the reactor. The reactor
-  // resources associated with the descriptor must be released by calling
-  // cleanup_descriptor_data.
-  ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data&);
-
-  // Perform any post-deregistration cleanup tasks associated with the
-  // descriptor data.
-  ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
-
-  // Run /dev/poll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(long usec, op_queue<operation>& ops);
-
-  // Interrupt the select loop.
-  ASIO_DECL void interrupt();
-
-private:
-  // Create the /dev/poll file descriptor. Throws an exception if the descriptor
-  // cannot be created.
-  ASIO_DECL static int do_dev_poll_create();
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Get the timeout value for the /dev/poll DP_POLL operation. The timeout
-  // value is returned as a number of milliseconds. A return value of -1
-  // indicates that the poll should block indefinitely.
-  ASIO_DECL int get_timeout(int msec);
-
-  // Cancel all operations associated with the given descriptor. The do_cancel
-  // function of the handler objects will be invoked. This function does not
-  // acquire the dev_poll_reactor's mutex.
-  ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
-      const asio::error_code& ec);
-
-  // Add a pending event entry for the given descriptor.
-  ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
-
-  // The scheduler implementation used to post completions.
-  scheduler& scheduler_;
-
-  // Mutex to protect access to internal data.
-  asio::detail::mutex mutex_;
-
-  // The /dev/poll file descriptor.
-  int dev_poll_fd_;
-
-  // Vector of /dev/poll events waiting to be written to the descriptor.
-  std::vector< ::pollfd> pending_event_changes_;
-
-  // Hash map to associate a descriptor with a pending event change index.
-  hash_map<int, std::size_t> pending_event_change_index_;
-
-  // The interrupter is used to break a blocking DP_POLL operation.
-  select_interrupter interrupter_;
-
-  // The queues of read, write and except operations.
-  reactor_op_queue<socket_type> op_queue_[max_ops];
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/dev_poll_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/dev_poll_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_DEV_POLL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/epoll_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/epoll_reactor.hpp
deleted file mode 100644
index 212767a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/epoll_reactor.hpp
+++ /dev/null
@@ -1,295 +0,0 @@
-//
-// detail/epoll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EPOLL_REACTOR_HPP
-#define ASIO_DETAIL_EPOLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/conditionally_enabled_mutex.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/object_pool.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_HAS_TIMERFD)
-# include <sys/timerfd.h>
-#endif // defined(ASIO_HAS_TIMERFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class epoll_reactor
-  : public execution_context_service_base<epoll_reactor>,
-    public scheduler_task
-{
-private:
-  // The mutex type used by this reactor.
-  typedef conditionally_enabled_mutex mutex;
-
-public:
-  enum op_types { read_op = 0, write_op = 1,
-    connect_op = 1, except_op = 2, max_ops = 3 };
-
-  // Per-descriptor queues.
-  class descriptor_state : operation
-  {
-    friend class epoll_reactor;
-    friend class object_pool_access;
-
-    descriptor_state* next_;
-    descriptor_state* prev_;
-
-    mutex mutex_;
-    epoll_reactor* reactor_;
-    int descriptor_;
-    uint32_t registered_events_;
-    op_queue<reactor_op> op_queue_[max_ops];
-    bool try_speculative_[max_ops];
-    bool shutdown_;
-
-    ASIO_DECL descriptor_state(bool locking);
-    void set_ready_events(uint32_t events) { task_result_ = events; }
-    void add_ready_events(uint32_t events) { task_result_ |= events; }
-    ASIO_DECL operation* perform_io(uint32_t events);
-    ASIO_DECL static void do_complete(
-        void* owner, operation* base,
-        const asio::error_code& ec, std::size_t bytes_transferred);
-  };
-
-  // Per-descriptor data.
-  typedef descriptor_state* per_descriptor_data;
-
-  // Constructor.
-  ASIO_DECL epoll_reactor(asio::execution_context& ctx);
-
-  // Destructor.
-  ASIO_DECL ~epoll_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal descriptors following a fork.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // success, system error code on failure.
-  ASIO_DECL int register_internal_descriptor(
-      int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op);
-
-  // Move descriptor registration from one descriptor_data object to another.
-  ASIO_DECL void move_descriptor(socket_type descriptor,
-      per_descriptor_data& target_descriptor_data,
-      per_descriptor_data& source_descriptor_data);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(operation* op, bool is_continuation) const;
-
-  // Post a reactor operation for immediate completion.
-  ASIO_DECL static void call_post_immediate_completion(
-      operation* op, bool is_continuation, const void* self);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative,
-      void (*on_immediate)(operation*, bool, const void*),
-      const void* immediate_arg);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative)
-  {
-    start_op(op_type, descriptor, descriptor_data,
-        op, is_continuation, allow_speculative,
-        &epoll_reactor::call_post_immediate_completion, this);
-  }
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Cancel all operations associated with the given descriptor and key. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      int op_type, void* cancellation_key);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor. The reactor resources associated with
-  // the descriptor must be released by calling cleanup_descriptor_data.
-  ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data, bool closing);
-
-  // Remove the descriptor's registration from the reactor. The reactor
-  // resources associated with the descriptor must be released by calling
-  // cleanup_descriptor_data.
-  ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
-
-  // Perform any post-deregistration cleanup tasks associated with the
-  // descriptor data.
-  ASIO_DECL void cleanup_descriptor_data(
-      per_descriptor_data& descriptor_data);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
-
-  // Run epoll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(long usec, op_queue<operation>& ops);
-
-  // Interrupt the select loop.
-  ASIO_DECL void interrupt();
-
-private:
-  // The hint to pass to epoll_create to size its data structures.
-  enum { epoll_size = 20000 };
-
-  // Create the epoll file descriptor. Throws an exception if the descriptor
-  // cannot be created.
-  ASIO_DECL static int do_epoll_create();
-
-  // Create the timerfd file descriptor. Does not throw.
-  ASIO_DECL static int do_timerfd_create();
-
-  // Allocate a new descriptor state object.
-  ASIO_DECL descriptor_state* allocate_descriptor_state();
-
-  // Free an existing descriptor state object.
-  ASIO_DECL void free_descriptor_state(descriptor_state* s);
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Called to recalculate and update the timeout.
-  ASIO_DECL void update_timeout();
-
-  // Get the timeout value for the epoll_wait call. The timeout value is
-  // returned as a number of milliseconds. A return value of -1 indicates
-  // that epoll_wait should block indefinitely.
-  ASIO_DECL int get_timeout(int msec);
-
-#if defined(ASIO_HAS_TIMERFD)
-  // Get the timeout value for the timer descriptor. The return value is the
-  // flag argument to be used when calling timerfd_settime.
-  ASIO_DECL int get_timeout(itimerspec& ts);
-#endif // defined(ASIO_HAS_TIMERFD)
-
-  // The scheduler implementation used to post completions.
-  scheduler& scheduler_;
-
-  // Mutex to protect access to internal data.
-  mutex mutex_;
-
-  // The interrupter is used to break a blocking epoll_wait call.
-  select_interrupter interrupter_;
-
-  // The epoll file descriptor.
-  int epoll_fd_;
-
-  // The timer file descriptor.
-  int timer_fd_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-
-  // Mutex to protect access to the registered descriptors.
-  mutex registered_descriptors_mutex_;
-
-  // Keep track of all registered descriptors.
-  object_pool<descriptor_state> registered_descriptors_;
-
-  // Helper class to do post-perform_io cleanup.
-  struct perform_io_cleanup_on_block_exit;
-  friend struct perform_io_cleanup_on_block_exit;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/epoll_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/epoll_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_EPOLL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/event.hpp
deleted file mode 100644
index 19e458c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/event.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// detail/event.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EVENT_HPP
-#define ASIO_DETAIL_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_event.hpp"
-#elif defined(ASIO_WINDOWS)
-# include "asio/detail/win_event.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_event.hpp"
-#else
-# include "asio/detail/std_event.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS)
-typedef null_event event;
-#elif defined(ASIO_WINDOWS)
-typedef win_event event;
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_event event;
-#else
-typedef std_event event;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/eventfd_select_interrupter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/eventfd_select_interrupter.hpp
deleted file mode 100644
index 0eb8843..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/eventfd_select_interrupter.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// detail/eventfd_select_interrupter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
-#define ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EVENTFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class eventfd_select_interrupter
-{
-public:
-  // Constructor.
-  ASIO_DECL eventfd_select_interrupter();
-
-  // Destructor.
-  ASIO_DECL ~eventfd_select_interrupter();
-
-  // Recreate the interrupter's descriptors. Used after a fork.
-  ASIO_DECL void recreate();
-
-  // Interrupt the select call.
-  ASIO_DECL void interrupt();
-
-  // Reset the select interrupter. Returns true if the reset was successful.
-  ASIO_DECL bool reset();
-
-  // Get the read descriptor to be passed to select.
-  int read_descriptor() const
-  {
-    return read_descriptor_;
-  }
-
-private:
-  // Open the descriptors. Throws on error.
-  ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  ASIO_DECL void close_descriptors();
-
-  // The read end of a connection used to interrupt the select call. This file
-  // descriptor is passed to select such that when it is time to stop, a single
-  // 64bit value will be written on the other end of the connection and this
-  // descriptor will become readable.
-  int read_descriptor_;
-
-  // The write end of a connection used to interrupt the select call. A single
-  // 64bit non-zero value may be written to this to wake up the select which is
-  // waiting for the other end to become readable. This descriptor will only
-  // differ from the read descriptor when a pipe is used.
-  int write_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/eventfd_select_interrupter.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_EVENTFD)
-
-#endif // ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/exception.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/exception.hpp
deleted file mode 100644
index 28c7cff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/exception.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// detail/exception.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EXCEPTION_HPP
-#define ASIO_DETAIL_EXCEPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-
-namespace asio {
-
-using std::exception_ptr;
-using std::current_exception;
-using std::rethrow_exception;
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_EXCEPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_function.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_function.hpp
deleted file mode 100644
index cccf31b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_function.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// detail/executor_function.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
-#define ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Lightweight, move-only function object wrapper.
-class executor_function
-{
-public:
-  template <typename F, typename Alloc>
-  explicit executor_function(F f, const Alloc& a)
-  {
-    // Allocate and construct an object to wrap the function.
-    typedef impl<F, Alloc> impl_type;
-    typename impl_type::ptr p = {
-      detail::addressof(a), impl_type::ptr::allocate(a), 0 };
-    impl_ = new (p.v) impl_type(static_cast<F&&>(f), a);
-    p.v = 0;
-  }
-
-  executor_function(executor_function&& other) noexcept
-    : impl_(other.impl_)
-  {
-    other.impl_ = 0;
-  }
-
-  ~executor_function()
-  {
-    if (impl_)
-      impl_->complete_(impl_, false);
-  }
-
-  void operator()()
-  {
-    if (impl_)
-    {
-      impl_base* i = impl_;
-      impl_ = 0;
-      i->complete_(i, true);
-    }
-  }
-
-private:
-  // Base class for polymorphic function implementations.
-  struct impl_base
-  {
-    void (*complete_)(impl_base*, bool);
-  };
-
-  // Polymorphic function implementation.
-  template <typename Function, typename Alloc>
-  struct impl : impl_base
-  {
-    ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
-        thread_info_base::executor_function_tag, impl);
-
-    template <typename F>
-    impl(F&& f, const Alloc& a)
-      : function_(static_cast<F&&>(f)),
-        allocator_(a)
-    {
-      complete_ = &executor_function::complete<Function, Alloc>;
-    }
-
-    Function function_;
-    Alloc allocator_;
-  };
-
-  // Helper to complete function invocation.
-  template <typename Function, typename Alloc>
-  static void complete(impl_base* base, bool call)
-  {
-    // Take ownership of the function object.
-    impl<Function, Alloc>* i(static_cast<impl<Function, Alloc>*>(base));
-    Alloc allocator(i->allocator_);
-    typename impl<Function, Alloc>::ptr p = {
-      detail::addressof(allocator), i, i };
-
-    // 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(static_cast<Function&&>(i->function_));
-    p.reset();
-
-    // Make the upcall if required.
-    if (call)
-    {
-      static_cast<Function&&>(function)();
-    }
-  }
-
-  impl_base* impl_;
-};
-
-// Lightweight, non-owning, copyable function object wrapper.
-class executor_function_view
-{
-public:
-  template <typename F>
-  explicit executor_function_view(F& f) noexcept
-    : complete_(&executor_function_view::complete<F>),
-      function_(&f)
-  {
-  }
-
-  void operator()()
-  {
-    complete_(function_);
-  }
-
-private:
-  // Helper to complete function invocation.
-  template <typename F>
-  static void complete(void* f)
-  {
-    (*static_cast<F*>(f))();
-  }
-
-  void (*complete_)(void*);
-  void* function_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_op.hpp
deleted file mode 100644
index 78e781e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/executor_op.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// detail/executor_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EXECUTOR_OP_HPP
-#define ASIO_DETAIL_EXECUTOR_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/scheduler_operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename Alloc,
-    typename Operation = scheduler_operation>
-class executor_op : public Operation
-{
-public:
-  ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(executor_op);
-
-  template <typename H>
-  executor_op(H&& h, const Alloc& allocator)
-    : Operation(&executor_op::do_complete),
-      handler_(static_cast<H&&>(h)),
-      allocator_(allocator)
-  {
-  }
-
-  static void do_complete(void* owner, Operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    executor_op* o(static_cast<executor_op*>(base));
-    Alloc allocator(o->allocator_);
-    ptr p = { detail::addressof(allocator), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    Handler handler(static_cast<Handler&&>(o->handler_));
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN(());
-      static_cast<Handler&&>(handler)();
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  Alloc allocator_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_EXECUTOR_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fd_set_adapter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fd_set_adapter.hpp
deleted file mode 100644
index 80b8974..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fd_set_adapter.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// detail/fd_set_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FD_SET_ADAPTER_HPP
-#define ASIO_DETAIL_FD_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/posix_fd_set_adapter.hpp"
-#include "asio/detail/win_fd_set_adapter.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef win_fd_set_adapter fd_set_adapter;
-#else
-typedef posix_fd_set_adapter fd_set_adapter;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_FD_SET_ADAPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fenced_block.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fenced_block.hpp
deleted file mode 100644
index ff096dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/fenced_block.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// detail/fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS) \
-  || defined(ASIO_DISABLE_FENCED_BLOCK)
-# include "asio/detail/null_fenced_block.hpp"
-#else
-# include "asio/detail/std_fenced_block.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS) \
-  || defined(ASIO_DISABLE_FENCED_BLOCK)
-typedef null_fenced_block fenced_block;
-#else
-typedef std_fenced_block fenced_block;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_FENCED_BLOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/functional.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/functional.hpp
deleted file mode 100644
index 145f9d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/functional.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// detail/functional.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FUNCTIONAL_HPP
-#define ASIO_DETAIL_FUNCTIONAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <functional>
-
-namespace asio {
-namespace detail {
-
-using std::function;
-
-} // namespace detail
-
-using std::ref;
-using std::reference_wrapper;
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_FUNCTIONAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/future.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/future.hpp
deleted file mode 100644
index f33136c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/future.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// detail/future.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FUTURE_HPP
-#define ASIO_DETAIL_FUTURE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <future>
-
-// Even though the future header is available, libstdc++ may not implement the
-// std::future class itself. However, we need to have already included the
-// future header to reliably test for _GLIBCXX_HAS_GTHREADS.
-#if defined(__GNUC__) && !defined(ASIO_HAS_CLANG_LIBCXX)
-# if defined(_GLIBCXX_HAS_GTHREADS)
-#  define ASIO_HAS_STD_FUTURE_CLASS 1
-# endif // defined(_GLIBCXX_HAS_GTHREADS)
-#else // defined(__GNUC__) && !defined(ASIO_HAS_CLANG_LIBCXX)
-# define ASIO_HAS_STD_FUTURE_CLASS 1
-#endif // defined(__GNUC__) && !defined(ASIO_HAS_CLANG_LIBCXX)
-
-#endif // ASIO_DETAIL_FUTURE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/global.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/global.hpp
deleted file mode 100644
index 59de23a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/global.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// detail/global.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GLOBAL_HPP
-#define ASIO_DETAIL_GLOBAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_global.hpp"
-#elif defined(ASIO_WINDOWS)
-# include "asio/detail/win_global.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_global.hpp"
-#else
-# include "asio/detail/std_global.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-inline T& global()
-{
-#if !defined(ASIO_HAS_THREADS)
-  return null_global<T>();
-#elif defined(ASIO_WINDOWS)
-  return win_global<T>();
-#elif defined(ASIO_HAS_PTHREADS)
-  return posix_global<T>();
-#else
-  return std_global<T>();
-#endif
-}
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_GLOBAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_alloc_helpers.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_alloc_helpers.hpp
deleted file mode 100644
index 8f7d181..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_alloc_helpers.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//
-// detail/handler_alloc_helpers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
-#define ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/associated_allocator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#define ASIO_DEFINE_TAGGED_HANDLER_PTR(purpose, op) \
-  struct ptr \
-  { \
-    Handler* h; \
-    op* v; \
-    op* p; \
-    ~ptr() \
-    { \
-      reset(); \
-    } \
-    static op* allocate(Handler& handler) \
-    { \
-      typedef typename ::asio::associated_allocator< \
-        Handler>::type associated_allocator_type; \
-      typedef typename ::asio::detail::get_recycling_allocator< \
-        associated_allocator_type, purpose>::type default_allocator_type; \
-      ASIO_REBIND_ALLOC(default_allocator_type, op) a( \
-            ::asio::detail::get_recycling_allocator< \
-              associated_allocator_type, purpose>::get( \
-                ::asio::get_associated_allocator(handler))); \
-      return a.allocate(1); \
-    } \
-    void reset() \
-    { \
-      if (p) \
-      { \
-        p->~op(); \
-        p = 0; \
-      } \
-      if (v) \
-      { \
-        typedef typename ::asio::associated_allocator< \
-          Handler>::type associated_allocator_type; \
-        typedef typename ::asio::detail::get_recycling_allocator< \
-          associated_allocator_type, purpose>::type default_allocator_type; \
-        ASIO_REBIND_ALLOC(default_allocator_type, op) a( \
-              ::asio::detail::get_recycling_allocator< \
-                associated_allocator_type, purpose>::get( \
-                  ::asio::get_associated_allocator(*h))); \
-        a.deallocate(static_cast<op*>(v), 1); \
-        v = 0; \
-      } \
-    } \
-  } \
-  /**/
-
-#define ASIO_DEFINE_HANDLER_PTR(op) \
-  ASIO_DEFINE_TAGGED_HANDLER_PTR( \
-      ::asio::detail::thread_info_base::default_tag, op ) \
-  /**/
-
-#define ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(purpose, op) \
-  struct ptr \
-  { \
-    const Alloc* a; \
-    void* v; \
-    op* p; \
-    ~ptr() \
-    { \
-      reset(); \
-    } \
-    static op* allocate(const Alloc& a) \
-    { \
-      typedef typename ::asio::detail::get_recycling_allocator< \
-        Alloc, purpose>::type recycling_allocator_type; \
-      ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \
-            ::asio::detail::get_recycling_allocator< \
-              Alloc, purpose>::get(a)); \
-      return a1.allocate(1); \
-    } \
-    void reset() \
-    { \
-      if (p) \
-      { \
-        p->~op(); \
-        p = 0; \
-      } \
-      if (v) \
-      { \
-        typedef typename ::asio::detail::get_recycling_allocator< \
-          Alloc, purpose>::type recycling_allocator_type; \
-        ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \
-              ::asio::detail::get_recycling_allocator< \
-                Alloc, purpose>::get(*a)); \
-        a1.deallocate(static_cast<op*>(v), 1); \
-        v = 0; \
-      } \
-    } \
-  } \
-  /**/
-
-#define ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(op) \
-  ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR( \
-      ::asio::detail::thread_info_base::default_tag, op ) \
-  /**/
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_cont_helpers.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_cont_helpers.hpp
deleted file mode 100644
index 9f8f971..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_cont_helpers.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// detail/handler_cont_helpers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
-#define ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/handler_continuation_hook.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-// Calls to asio_handler_is_continuation must be made from a namespace that
-// does not contain overloads of this function. This namespace is defined here
-// for that purpose.
-namespace asio_handler_cont_helpers {
-
-template <typename Context>
-inline bool is_continuation(Context& context)
-{
-#if !defined(ASIO_HAS_HANDLER_HOOKS)
-  return false;
-#else
-  using asio::asio_handler_is_continuation;
-  return asio_handler_is_continuation(
-      asio::detail::addressof(context));
-#endif
-}
-
-} // namespace asio_handler_cont_helpers
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_tracking.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_tracking.hpp
deleted file mode 100644
index f47c777..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_tracking.hpp
+++ /dev/null
@@ -1,264 +0,0 @@
-//
-// detail/handler_tracking.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_TRACKING_HPP
-#define ASIO_DETAIL_HANDLER_TRACKING_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-namespace asio {
-
-class execution_context;
-
-} // namespace asio
-
-#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
-# include ASIO_CUSTOM_HANDLER_TRACKING
-#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
-# include "asio/error_code.hpp"
-# include "asio/detail/cstdint.hpp"
-# include "asio/detail/static_mutex.hpp"
-# include "asio/detail/tss_ptr.hpp"
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
-
-// The user-specified header must define the following macros:
-// - ASIO_INHERIT_TRACKED_HANDLER
-// - ASIO_ALSO_INHERIT_TRACKED_HANDLER
-// - ASIO_HANDLER_TRACKING_INIT
-// - ASIO_HANDLER_CREATION(args)
-// - ASIO_HANDLER_COMPLETION(args)
-// - ASIO_HANDLER_INVOCATION_BEGIN(args)
-// - ASIO_HANDLER_INVOCATION_END
-// - ASIO_HANDLER_OPERATION(args)
-// - ASIO_HANDLER_REACTOR_REGISTRATION(args)
-// - ASIO_HANDLER_REACTOR_DEREGISTRATION(args)
-// - ASIO_HANDLER_REACTOR_READ_EVENT
-// - ASIO_HANDLER_REACTOR_WRITE_EVENT
-// - ASIO_HANDLER_REACTOR_ERROR_EVENT
-// - ASIO_HANDLER_REACTOR_EVENTS(args)
-// - ASIO_HANDLER_REACTOR_OPERATION(args)
-
-# if !defined(ASIO_ENABLE_HANDLER_TRACKING)
-#  define ASIO_ENABLE_HANDLER_TRACKING 1
-# endif /// !defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-class handler_tracking
-{
-public:
-  class completion;
-
-  // Base class for objects containing tracked handlers.
-  class tracked_handler
-  {
-  private:
-    // Only the handler_tracking class will have access to the id.
-    friend class handler_tracking;
-    friend class completion;
-    uint64_t id_;
-
-  protected:
-    // Constructor initialises with no id.
-    tracked_handler() : id_(0) {}
-
-    // Prevent deletion through this type.
-    ~tracked_handler() {}
-  };
-
-  // Initialise the tracking system.
-  ASIO_DECL static void init();
-
-  class location
-  {
-  public:
-    // Constructor adds a location to the stack.
-    ASIO_DECL explicit location(const char* file,
-        int line, const char* func);
-
-    // Destructor removes a location from the stack.
-    ASIO_DECL ~location();
-
-  private:
-    // Disallow copying and assignment.
-    location(const location&) = delete;
-    location& operator=(const location&) = delete;
-
-    friend class handler_tracking;
-    const char* file_;
-    int line_;
-    const char* func_;
-    location* next_;
-  };
-
-  // Record the creation of a tracked handler.
-  ASIO_DECL static void creation(
-      execution_context& context, tracked_handler& h,
-      const char* object_type, void* object,
-      uintmax_t native_handle, const char* op_name);
-
-  class completion
-  {
-  public:
-    // Constructor records that handler is to be invoked with no arguments.
-    ASIO_DECL explicit completion(const tracked_handler& h);
-
-    // Destructor records only when an exception is thrown from the handler, or
-    // if the memory is being freed without the handler having been invoked.
-    ASIO_DECL ~completion();
-
-    // Records that handler is to be invoked with no arguments.
-    ASIO_DECL void invocation_begin();
-
-    // Records that handler is to be invoked with one arguments.
-    ASIO_DECL void invocation_begin(const asio::error_code& ec);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    ASIO_DECL void invocation_begin(
-        const asio::error_code& ec, std::size_t bytes_transferred);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    ASIO_DECL void invocation_begin(
-        const asio::error_code& ec, int signal_number);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    ASIO_DECL void invocation_begin(
-        const asio::error_code& ec, const char* arg);
-
-    // Record that handler invocation has ended.
-    ASIO_DECL void invocation_end();
-
-  private:
-    friend class handler_tracking;
-    uint64_t id_;
-    bool invoked_;
-    completion* next_;
-  };
-
-  // Record an operation that is not directly associated with a handler.
-  ASIO_DECL static void operation(execution_context& context,
-      const char* object_type, void* object,
-      uintmax_t native_handle, const char* op_name);
-
-  // Record that a descriptor has been registered with the reactor.
-  ASIO_DECL static void reactor_registration(execution_context& context,
-      uintmax_t native_handle, uintmax_t registration);
-
-  // Record that a descriptor has been deregistered from the reactor.
-  ASIO_DECL static void reactor_deregistration(execution_context& context,
-      uintmax_t native_handle, uintmax_t registration);
-
-  // Record a reactor-based operation that is associated with a handler.
-  ASIO_DECL static void reactor_events(execution_context& context,
-      uintmax_t registration, unsigned events);
-
-  // Record a reactor-based operation that is associated with a handler.
-  ASIO_DECL static void reactor_operation(
-      const tracked_handler& h, const char* op_name,
-      const asio::error_code& ec);
-
-  // Record a reactor-based operation that is associated with a handler.
-  ASIO_DECL static void reactor_operation(
-      const tracked_handler& h, const char* op_name,
-      const asio::error_code& ec, std::size_t bytes_transferred);
-
-  // Write a line of output.
-  ASIO_DECL static void write_line(const char* format, ...);
-
-private:
-  struct tracking_state;
-  ASIO_DECL static tracking_state* get_state();
-};
-
-# define ASIO_INHERIT_TRACKED_HANDLER \
-  : public asio::detail::handler_tracking::tracked_handler
-
-# define ASIO_ALSO_INHERIT_TRACKED_HANDLER \
-  , public asio::detail::handler_tracking::tracked_handler
-
-# define ASIO_HANDLER_TRACKING_INIT \
-  asio::detail::handler_tracking::init()
-
-# define ASIO_HANDLER_LOCATION(args) \
-  asio::detail::handler_tracking::location tracked_location args
-
-# define ASIO_HANDLER_CREATION(args) \
-  asio::detail::handler_tracking::creation args
-
-# define ASIO_HANDLER_COMPLETION(args) \
-  asio::detail::handler_tracking::completion tracked_completion args
-
-# define ASIO_HANDLER_INVOCATION_BEGIN(args) \
-  tracked_completion.invocation_begin args
-
-# define ASIO_HANDLER_INVOCATION_END \
-  tracked_completion.invocation_end()
-
-# define ASIO_HANDLER_OPERATION(args) \
-  asio::detail::handler_tracking::operation args
-
-# define ASIO_HANDLER_REACTOR_REGISTRATION(args) \
-  asio::detail::handler_tracking::reactor_registration args
-
-# define ASIO_HANDLER_REACTOR_DEREGISTRATION(args) \
-  asio::detail::handler_tracking::reactor_deregistration args
-
-# define ASIO_HANDLER_REACTOR_READ_EVENT 1
-# define ASIO_HANDLER_REACTOR_WRITE_EVENT 2
-# define ASIO_HANDLER_REACTOR_ERROR_EVENT 4
-
-# define ASIO_HANDLER_REACTOR_EVENTS(args) \
-  asio::detail::handler_tracking::reactor_events args
-
-# define ASIO_HANDLER_REACTOR_OPERATION(args) \
-  asio::detail::handler_tracking::reactor_operation args
-
-#else // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-# define ASIO_INHERIT_TRACKED_HANDLER
-# define ASIO_ALSO_INHERIT_TRACKED_HANDLER
-# define ASIO_HANDLER_TRACKING_INIT (void)0
-# define ASIO_HANDLER_LOCATION(loc) (void)0
-# define ASIO_HANDLER_CREATION(args) (void)0
-# define ASIO_HANDLER_COMPLETION(args) (void)0
-# define ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
-# define ASIO_HANDLER_INVOCATION_END (void)0
-# define ASIO_HANDLER_OPERATION(args) (void)0
-# define ASIO_HANDLER_REACTOR_REGISTRATION(args) (void)0
-# define ASIO_HANDLER_REACTOR_DEREGISTRATION(args) (void)0
-# define ASIO_HANDLER_REACTOR_READ_EVENT 0
-# define ASIO_HANDLER_REACTOR_WRITE_EVENT 0
-# define ASIO_HANDLER_REACTOR_ERROR_EVENT 0
-# define ASIO_HANDLER_REACTOR_EVENTS(args) (void)0
-# define ASIO_HANDLER_REACTOR_OPERATION(args) (void)0
-
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/handler_tracking.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_HANDLER_TRACKING_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_type_requirements.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_type_requirements.hpp
deleted file mode 100644
index 54c53b9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_type_requirements.hpp
+++ /dev/null
@@ -1,553 +0,0 @@
-//
-// detail/handler_type_requirements.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
-#define ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-// Older versions of gcc have difficulty compiling the sizeof expressions where
-// we test the handler type requirements. We'll disable checking of handler type
-// requirements for those compilers, but otherwise enable it by default.
-#if !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-# if !defined(__GNUC__) || (__GNUC__ >= 4)
-#  define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
-# endif // !defined(__GNUC__) || (__GNUC__ >= 4)
-#endif // !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-
-// With C++0x we can use a combination of enhanced SFINAE and static_assert to
-// generate better template error messages. As this technique is not yet widely
-// portable, we'll only enable it for tested compilers.
-#if !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-# if defined(ASIO_MSVC)
-#  if (_MSC_VER >= 1600)
-#   define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
-#  endif // (_MSC_VER >= 1600)
-# endif // defined(ASIO_MSVC)
-# if defined(__clang__)
-#  if __has_feature(__cxx_static_assert__)
-#   define ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
-#  endif // __has_feature(cxx_static_assert)
-# endif // defined(__clang__)
-#endif // !defined(ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-
-#if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-# include "asio/async_result.hpp"
-#endif // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-# if defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-
-template <typename Handler>
-auto zero_arg_copyable_handler_test(Handler h, void*)
-  -> decltype(
-    sizeof(Handler(static_cast<const Handler&>(h))),
-    (static_cast<Handler&&>(h)()),
-    char(0));
-
-template <typename Handler>
-char (&zero_arg_copyable_handler_test(Handler, ...))[2];
-
-template <typename Handler, typename Arg1>
-auto one_arg_handler_test(Handler h, Arg1* a1)
-  -> decltype(
-    sizeof(Handler(static_cast<Handler&&>(h))),
-    (static_cast<Handler&&>(h)(*a1)),
-    char(0));
-
-template <typename Handler>
-char (&one_arg_handler_test(Handler h, ...))[2];
-
-template <typename Handler, typename Arg1, typename Arg2>
-auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
-  -> decltype(
-    sizeof(Handler(static_cast<Handler&&>(h))),
-    (static_cast<Handler&&>(h)(*a1, *a2)),
-    char(0));
-
-template <typename Handler>
-char (&two_arg_handler_test(Handler, ...))[2];
-
-template <typename Handler, typename Arg1, typename Arg2>
-auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
-  -> decltype(
-    sizeof(Handler(static_cast<Handler&&>(h))),
-    (static_cast<Handler&&>(h)(
-      *a1, static_cast<Arg2&&>(*a2))),
-    char(0));
-
-template <typename Handler>
-char (&two_arg_move_handler_test(Handler, ...))[2];
-
-#  define ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
-     static_assert(expr, msg);
-
-# else // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-
-#  define ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
-
-# endif // defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-
-template <typename T> T& lvref();
-template <typename T> T& lvref(T);
-template <typename T> const T& clvref();
-template <typename T> const T& clvref(T);
-template <typename T> T rvref();
-template <typename T> T rvref(T);
-template <typename T> T rorlvref();
-template <typename T> char argbyv(T);
-
-template <int>
-struct handler_type_requirements
-{
-};
-
-#define ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void()) asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::zero_arg_copyable_handler_test( \
-          asio::detail::clvref< \
-            asio_true_handler_type>(), 0)) == 1, \
-      "CompletionHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::clvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()(), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_READ_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, std::size_t)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const std::size_t*>(0))) == 1, \
-      "ReadHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const std::size_t>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_WRITE_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, std::size_t)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const std::size_t*>(0))) == 1, \
-      "WriteHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const std::size_t>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0))) == 1, \
-      "AcceptHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler, socket_type) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, socket_type)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_move_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<socket_type*>(0))) == 1, \
-      "MoveAcceptHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::rvref<socket_type>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_CONNECT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0))) == 1, \
-      "ConnectHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_RANGE_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, endpoint_type) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, endpoint_type)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const endpoint_type*>(0))) == 1, \
-      "RangeConnectHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const endpoint_type>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, iter_type)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const iter_type*>(0))) == 1, \
-      "IteratorConnectHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const iter_type>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_RESOLVE_HANDLER_CHECK( \
-    handler_type, handler, range_type) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, range_type)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const range_type*>(0))) == 1, \
-      "ResolveHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const range_type>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_WAIT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0))) == 1, \
-      "WaitHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_SIGNAL_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, int)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const int*>(0))) == 1, \
-      "SignalHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>(), \
-            asio::detail::lvref<const int>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0))) == 1, \
-      "HandshakeHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code, std::size_t)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::two_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0), \
-          static_cast<const std::size_t*>(0))) == 1, \
-      "BufferedHandshakeHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-          asio::detail::lvref<const asio::error_code>(), \
-          asio::detail::lvref<const std::size_t>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#define ASIO_SHUTDOWN_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  typedef ASIO_HANDLER_TYPE(handler_type, \
-      void(asio::error_code)) \
-    asio_true_handler_type; \
-  \
-  ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(asio::detail::one_arg_handler_test( \
-          asio::detail::rvref< \
-            asio_true_handler_type>(), \
-          static_cast<const asio::error_code*>(0))) == 1, \
-      "ShutdownHandler type requirements not met") \
-  \
-  typedef asio::detail::handler_type_requirements< \
-      sizeof( \
-        asio::detail::argbyv( \
-          asio::detail::rvref< \
-            asio_true_handler_type>())) + \
-      sizeof( \
-        asio::detail::rorlvref< \
-          asio_true_handler_type>()( \
-            asio::detail::lvref<const asio::error_code>()), \
-        char(0))> ASIO_UNUSED_TYPEDEF
-
-#else // !defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-#define ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_READ_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_WRITE_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_MOVE_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler, socket_type) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_CONNECT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_RANGE_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_RESOLVE_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_WAIT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_SIGNAL_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#define ASIO_SHUTDOWN_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int ASIO_UNUSED_TYPEDEF
-
-#endif // !defined(ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_work.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_work.hpp
deleted file mode 100644
index 596d076..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/handler_work.hpp
+++ /dev/null
@@ -1,511 +0,0 @@
-//
-// detail/handler_work.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_WORK_HPP
-#define ASIO_DETAIL_HANDLER_WORK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/detail/initiate_dispatch.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/work_dispatcher.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/prefer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class executor;
-class io_context;
-
-#if !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-class any_completion_executor;
-class any_io_executor;
-
-#endif // !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-namespace execution {
-
-template <typename...> class any_executor;
-
-} // namespace execution
-namespace detail {
-
-template <typename Executor, typename CandidateExecutor = void,
-    typename IoContext = io_context,
-    typename PolymorphicExecutor = executor, typename = void>
-class handler_work_base
-{
-public:
-  explicit handler_work_base(int, int, const Executor& ex) noexcept
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  template <typename OtherExecutor>
-  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
-      const OtherExecutor& /*candidate*/) noexcept
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  handler_work_base(const handler_work_base& other) noexcept
-    : executor_(other.executor_)
-  {
-  }
-
-  handler_work_base(handler_work_base&& other) noexcept
-    : executor_(static_cast<executor_type&&>(other.executor_))
-  {
-  }
-
-  bool owns_work() const noexcept
-  {
-    return true;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    asio::prefer(executor_,
-        execution::allocator((get_associated_allocator)(handler))
-      ).execute(static_cast<Function&&>(function));
-  }
-
-private:
-  typedef decay_t<
-      prefer_result_t<Executor, execution::outstanding_work_t::tracked_t>
-    > executor_type;
-
-  executor_type executor_;
-};
-
-template <typename Executor, typename CandidateExecutor,
-    typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<Executor, CandidateExecutor,
-    IoContext, PolymorphicExecutor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-        && (!is_same<Executor, PolymorphicExecutor>::value
-          || !is_same<CandidateExecutor, void>::value)
-    >
-  >
-{
-public:
-  explicit handler_work_base(int, int, const Executor& ex) noexcept
-    : executor_(ex),
-      owns_work_(true)
-  {
-    executor_.on_work_started();
-  }
-
-  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
-      const Executor& candidate) noexcept
-    : executor_(ex),
-      owns_work_(ex != candidate)
-  {
-    if (owns_work_)
-      executor_.on_work_started();
-  }
-
-  template <typename OtherExecutor>
-  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
-      const OtherExecutor& /*candidate*/) noexcept
-    : executor_(ex),
-      owns_work_(true)
-  {
-    executor_.on_work_started();
-  }
-
-  handler_work_base(const handler_work_base& other) noexcept
-    : executor_(other.executor_),
-      owns_work_(other.owns_work_)
-  {
-    if (owns_work_)
-      executor_.on_work_started();
-  }
-
-  handler_work_base(handler_work_base&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_)),
-      owns_work_(other.owns_work_)
-  {
-    other.owns_work_ = false;
-  }
-
-  ~handler_work_base()
-  {
-    if (owns_work_)
-      executor_.on_work_finished();
-  }
-
-  bool owns_work() const noexcept
-  {
-    return owns_work_;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    executor_.dispatch(static_cast<Function&&>(function),
-        asio::get_associated_allocator(handler));
-  }
-
-private:
-  Executor executor_;
-  bool owns_work_;
-};
-
-template <typename Executor, typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<Executor, void, IoContext, PolymorphicExecutor,
-    enable_if_t<
-      is_same<
-        Executor,
-        typename IoContext::executor_type
-      >::value
-    >
-  >
-{
-public:
-  explicit handler_work_base(int, int, const Executor&)
-  {
-  }
-
-  bool owns_work() const noexcept
-  {
-    return false;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler&)
-  {
-    // When using a native implementation, I/O completion handlers are
-    // already dispatched according to the execution context's executor's
-    // rules. We can call the function directly.
-    static_cast<Function&&>(function)();
-  }
-};
-
-template <typename Executor, typename IoContext>
-class handler_work_base<Executor, void, IoContext, Executor>
-{
-public:
-  explicit handler_work_base(int, int, const Executor& ex) noexcept
-#if !defined(ASIO_NO_TYPEID)
-    : executor_(
-        ex.target_type() == typeid(typename IoContext::executor_type)
-          ? Executor() : ex)
-#else // !defined(ASIO_NO_TYPEID)
-    : executor_(ex)
-#endif // !defined(ASIO_NO_TYPEID)
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-
-  handler_work_base(bool /*base1_owns_work*/, const Executor& ex,
-      const Executor& candidate) noexcept
-    : executor_(ex != candidate ? ex : Executor())
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-
-  template <typename OtherExecutor>
-  handler_work_base(const Executor& ex,
-      const OtherExecutor&) noexcept
-    : executor_(ex)
-  {
-    executor_.on_work_started();
-  }
-
-  handler_work_base(const handler_work_base& other) noexcept
-    : executor_(other.executor_)
-  {
-    if (executor_)
-      executor_.on_work_started();
-  }
-
-  handler_work_base(handler_work_base&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_))
-  {
-  }
-
-  ~handler_work_base()
-  {
-    if (executor_)
-      executor_.on_work_finished();
-  }
-
-  bool owns_work() const noexcept
-  {
-    return !!executor_;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    executor_.dispatch(static_cast<Function&&>(function),
-        asio::get_associated_allocator(handler));
-  }
-
-private:
-  Executor executor_;
-};
-
-template <typename... SupportableProperties, typename CandidateExecutor,
-    typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<execution::any_executor<SupportableProperties...>,
-    CandidateExecutor, IoContext, PolymorphicExecutor>
-{
-public:
-  typedef execution::any_executor<SupportableProperties...> executor_type;
-
-  explicit handler_work_base(int, int, const executor_type& ex) noexcept
-#if !defined(ASIO_NO_TYPEID)
-    : executor_(
-        ex.target_type() == typeid(typename IoContext::executor_type)
-          ? executor_type()
-          : asio::prefer(ex, execution::outstanding_work.tracked))
-#else // !defined(ASIO_NO_TYPEID)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-#endif // !defined(ASIO_NO_TYPEID)
-  {
-  }
-
-  handler_work_base(bool base1_owns_work, const executor_type& ex,
-      const executor_type& candidate) noexcept
-    : executor_(
-        !base1_owns_work && ex == candidate
-          ? executor_type()
-          : asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  template <typename OtherExecutor>
-  handler_work_base(bool /*base1_owns_work*/, const executor_type& ex,
-      const OtherExecutor& /*candidate*/) noexcept
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  handler_work_base(const handler_work_base& other) noexcept
-    : executor_(other.executor_)
-  {
-  }
-
-  handler_work_base(handler_work_base&& other) noexcept
-    : executor_(static_cast<executor_type&&>(other.executor_))
-  {
-  }
-
-  bool owns_work() const noexcept
-  {
-    return !!executor_;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler&)
-  {
-    executor_.execute(static_cast<Function&&>(function));
-  }
-
-private:
-  executor_type executor_;
-};
-
-#if !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-template <typename Executor, typename CandidateExecutor,
-    typename IoContext, typename PolymorphicExecutor>
-class handler_work_base<
-    Executor, CandidateExecutor,
-    IoContext, PolymorphicExecutor,
-    enable_if_t<
-      is_same<Executor, any_completion_executor>::value
-        || is_same<Executor, any_io_executor>::value
-    >
-  >
-{
-public:
-  typedef Executor executor_type;
-
-  explicit handler_work_base(int, int,
-      const executor_type& ex) noexcept
-#if !defined(ASIO_NO_TYPEID)
-    : executor_(
-        ex.target_type() == typeid(typename IoContext::executor_type)
-          ? executor_type()
-          : asio::prefer(ex, execution::outstanding_work.tracked))
-#else // !defined(ASIO_NO_TYPEID)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-#endif // !defined(ASIO_NO_TYPEID)
-  {
-  }
-
-  handler_work_base(bool base1_owns_work, const executor_type& ex,
-      const executor_type& candidate) noexcept
-    : executor_(
-        !base1_owns_work && ex == candidate
-          ? executor_type()
-          : asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  template <typename OtherExecutor>
-  handler_work_base(bool /*base1_owns_work*/, const executor_type& ex,
-      const OtherExecutor& /*candidate*/) noexcept
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  handler_work_base(const handler_work_base& other) noexcept
-    : executor_(other.executor_)
-  {
-  }
-
-  handler_work_base(handler_work_base&& other) noexcept
-    : executor_(static_cast<executor_type&&>(other.executor_))
-  {
-  }
-
-  bool owns_work() const noexcept
-  {
-    return !!executor_;
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler&)
-  {
-    executor_.execute(static_cast<Function&&>(function));
-  }
-
-private:
-  executor_type executor_;
-};
-
-#endif // !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-template <typename Handler, typename IoExecutor, typename = void>
-class handler_work :
-  handler_work_base<IoExecutor>,
-  handler_work_base<associated_executor_t<Handler, IoExecutor>, IoExecutor>
-{
-public:
-  typedef handler_work_base<IoExecutor> base1_type;
-  typedef handler_work_base<associated_executor_t<Handler, IoExecutor>,
-      IoExecutor> base2_type;
-
-  handler_work(Handler& handler, const IoExecutor& io_ex) noexcept
-    : base1_type(0, 0, io_ex),
-      base2_type(base1_type::owns_work(),
-          asio::get_associated_executor(handler, io_ex), io_ex)
-  {
-  }
-
-  template <typename Function>
-  void complete(Function& function, Handler& handler)
-  {
-    if (!base1_type::owns_work() && !base2_type::owns_work())
-    {
-      // When using a native implementation, I/O completion handlers are
-      // already dispatched according to the execution context's executor's
-      // rules. We can call the function directly.
-      static_cast<Function&&>(function)();
-    }
-    else
-    {
-      base2_type::dispatch(function, handler);
-    }
-  }
-};
-
-template <typename Handler, typename IoExecutor>
-class handler_work<
-    Handler, IoExecutor,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          IoExecutor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >
-  > : handler_work_base<IoExecutor>
-{
-public:
-  typedef handler_work_base<IoExecutor> base1_type;
-
-  handler_work(Handler&, const IoExecutor& io_ex) noexcept
-    : base1_type(0, 0, io_ex)
-  {
-  }
-
-  template <typename Function>
-  void complete(Function& function, Handler& handler)
-  {
-    if (!base1_type::owns_work())
-    {
-      // When using a native implementation, I/O completion handlers are
-      // already dispatched according to the execution context's executor's
-      // rules. We can call the function directly.
-      static_cast<Function&&>(function)();
-    }
-    else
-    {
-      base1_type::dispatch(function, handler);
-    }
-  }
-};
-
-template <typename Handler, typename IoExecutor>
-class immediate_handler_work
-{
-public:
-  typedef handler_work<Handler, IoExecutor> handler_work_type;
-
-  explicit immediate_handler_work(handler_work_type&& w)
-    : handler_work_(static_cast<handler_work_type&&>(w))
-  {
-  }
-
-  template <typename Function>
-  void complete(Function& function, Handler& handler, const void* io_ex)
-  {
-    typedef associated_immediate_executor_t<Handler, IoExecutor>
-      immediate_ex_type;
-
-    immediate_ex_type immediate_ex = (get_associated_immediate_executor)(
-        handler, *static_cast<const IoExecutor*>(io_ex));
-
-    (initiate_dispatch_with_executor<immediate_ex_type>(immediate_ex))(
-        static_cast<Function&&>(function));
-  }
-
-private:
-  handler_work_type handler_work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HANDLER_WORK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/hash_map.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/hash_map.hpp
deleted file mode 100644
index e23de91..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/hash_map.hpp
+++ /dev/null
@@ -1,331 +0,0 @@
-//
-// detail/hash_map.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HASH_MAP_HPP
-#define ASIO_DETAIL_HASH_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <list>
-#include <utility>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/socket_types.hpp"
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline std::size_t calculate_hash_value(int i)
-{
-  return static_cast<std::size_t>(i);
-}
-
-inline std::size_t calculate_hash_value(void* p)
-{
-  return reinterpret_cast<std::size_t>(p)
-    + (reinterpret_cast<std::size_t>(p) >> 3);
-}
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-inline std::size_t calculate_hash_value(SOCKET s)
-{
-  return static_cast<std::size_t>(s);
-}
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-// Note: assumes K and V are POD types.
-template <typename K, typename V>
-class hash_map
-  : private noncopyable
-{
-public:
-  // The type of a value in the map.
-  typedef std::pair<K, V> value_type;
-
-  // The type of a non-const iterator over the hash map.
-  typedef typename std::list<value_type>::iterator iterator;
-
-  // The type of a const iterator over the hash map.
-  typedef typename std::list<value_type>::const_iterator const_iterator;
-
-  // Constructor.
-  hash_map()
-    : size_(0),
-      buckets_(0),
-      num_buckets_(0)
-  {
-  }
-
-  // Destructor.
-  ~hash_map()
-  {
-    delete[] buckets_;
-  }
-
-  // Get an iterator for the beginning of the map.
-  iterator begin()
-  {
-    return values_.begin();
-  }
-
-  // Get an iterator for the beginning of the map.
-  const_iterator begin() const
-  {
-    return values_.begin();
-  }
-
-  // Get an iterator for the end of the map.
-  iterator end()
-  {
-    return values_.end();
-  }
-
-  // Get an iterator for the end of the map.
-  const_iterator end() const
-  {
-    return values_.end();
-  }
-
-  // Check whether the map is empty.
-  bool empty() const
-  {
-    return values_.empty();
-  }
-
-  // Find an entry in the map.
-  iterator find(const K& k)
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return values_.end();
-      iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-
-  // Find an entry in the map.
-  const_iterator find(const K& k) const
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      const_iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return it;
-      const_iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-
-  // Insert a new entry into the map.
-  std::pair<iterator, bool> insert(const value_type& v)
-  {
-    if (size_ + 1 >= num_buckets_)
-      rehash(hash_size(size_ + 1));
-    size_t bucket = calculate_hash_value(v.first) % num_buckets_;
-    iterator it = buckets_[bucket].first;
-    if (it == values_.end())
-    {
-      buckets_[bucket].first = buckets_[bucket].last =
-        values_insert(values_.end(), v);
-      ++size_;
-      return std::pair<iterator, bool>(buckets_[bucket].last, true);
-    }
-    iterator end_it = buckets_[bucket].last;
-    ++end_it;
-    while (it != end_it)
-    {
-      if (it->first == v.first)
-        return std::pair<iterator, bool>(it, false);
-      ++it;
-    }
-    buckets_[bucket].last = values_insert(end_it, v);
-    ++size_;
-    return std::pair<iterator, bool>(buckets_[bucket].last, true);
-  }
-
-  // Erase an entry from the map.
-  void erase(iterator it)
-  {
-    ASIO_ASSERT(it != values_.end());
-    ASIO_ASSERT(num_buckets_ != 0);
-
-    size_t bucket = calculate_hash_value(it->first) % num_buckets_;
-    bool is_first = (it == buckets_[bucket].first);
-    bool is_last = (it == buckets_[bucket].last);
-    if (is_first && is_last)
-      buckets_[bucket].first = buckets_[bucket].last = values_.end();
-    else if (is_first)
-      ++buckets_[bucket].first;
-    else if (is_last)
-      --buckets_[bucket].last;
-
-    values_erase(it);
-    --size_;
-  }
-
-  // Erase a key from the map.
-  void erase(const K& k)
-  {
-    iterator it = find(k);
-    if (it != values_.end())
-      erase(it);
-  }
-
-  // Remove all entries from the map.
-  void clear()
-  {
-    // Clear the values.
-    values_.clear();
-    size_ = 0;
-
-    // Initialise all buckets to empty.
-    iterator end_it = values_.end();
-    for (size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_it;
-  }
-
-private:
-  // Calculate the hash size for the specified number of elements.
-  static std::size_t hash_size(std::size_t num_elems)
-  {
-    static std::size_t sizes[] =
-    {
-#if defined(ASIO_HASH_MAP_BUCKETS)
-      ASIO_HASH_MAP_BUCKETS
-#else // ASIO_HASH_MAP_BUCKETS
-      3, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
-      49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
-      12582917, 25165843
-#endif // ASIO_HASH_MAP_BUCKETS
-    };
-    const std::size_t nth_size = sizeof(sizes) / sizeof(std::size_t) - 1;
-    for (std::size_t i = 0; i < nth_size; ++i)
-      if (num_elems < sizes[i])
-        return sizes[i];
-    return sizes[nth_size];
-  }
-
-  // Re-initialise the hash from the values already contained in the list.
-  void rehash(std::size_t num_buckets)
-  {
-    if (num_buckets == num_buckets_)
-      return;
-    ASIO_ASSERT(num_buckets != 0);
-
-    iterator end_iter = values_.end();
-
-    // Update number of buckets and initialise all buckets to empty.
-    bucket_type* tmp = new bucket_type[num_buckets];
-    delete[] buckets_;
-    buckets_ = tmp;
-    num_buckets_ = num_buckets;
-    for (std::size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_iter;
-
-    // Put all values back into the hash.
-    iterator iter = values_.begin();
-    while (iter != end_iter)
-    {
-      std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_;
-      if (buckets_[bucket].last == end_iter)
-      {
-        buckets_[bucket].first = buckets_[bucket].last = iter++;
-      }
-      else if (++buckets_[bucket].last == iter)
-      {
-        ++iter;
-      }
-      else
-      {
-        values_.splice(buckets_[bucket].last, values_, iter++);
-        --buckets_[bucket].last;
-      }
-    }
-  }
-
-  // Insert an element into the values list by splicing from the spares list,
-  // if a spare is available, and otherwise by inserting a new element.
-  iterator values_insert(iterator it, const value_type& v)
-  {
-    if (spares_.empty())
-    {
-      return values_.insert(it, v);
-    }
-    else
-    {
-      spares_.front() = v;
-      values_.splice(it, spares_, spares_.begin());
-      return --it;
-    }
-  }
-
-  // Erase an element from the values list by splicing it to the spares list.
-  void values_erase(iterator it)
-  {
-    *it = value_type();
-    spares_.splice(spares_.begin(), values_, it);
-  }
-
-  // The number of elements in the hash.
-  std::size_t size_;
-
-  // The list of all values in the hash map.
-  std::list<value_type> values_;
-
-  // The list of spare nodes waiting to be recycled. Assumes that POD types only
-  // are stored in the hash map.
-  std::list<value_type> spares_;
-
-  // The type for a bucket in the hash table.
-  struct bucket_type
-  {
-    iterator first;
-    iterator last;
-  };
-
-  // The buckets in the hash.
-  bucket_type* buckets_;
-
-  // The number of buckets in the hash.
-  std::size_t num_buckets_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HASH_MAP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/buffer_sequence_adapter.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/buffer_sequence_adapter.ipp
deleted file mode 100644
index 372ce42..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/buffer_sequence_adapter.ipp
+++ /dev/null
@@ -1,118 +0,0 @@
-//
-// detail/impl/buffer_sequence_adapter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
-#define ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include <robuffer.h>
-#include <windows.storage.streams.h>
-#include <wrl/implements.h>
-#include "asio/detail/buffer_sequence_adapter.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class winrt_buffer_impl :
-  public Microsoft::WRL::RuntimeClass<
-    Microsoft::WRL::RuntimeClassFlags<
-      Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>,
-    ABI::Windows::Storage::Streams::IBuffer,
-    Windows::Storage::Streams::IBufferByteAccess>
-{
-public:
-  explicit winrt_buffer_impl(const asio::const_buffer& b)
-  {
-    bytes_ = const_cast<byte*>(static_cast<const byte*>(b.data()));
-    length_ = b.size();
-    capacity_ = b.size();
-  }
-
-  explicit winrt_buffer_impl(const asio::mutable_buffer& b)
-  {
-    bytes_ = static_cast<byte*>(b.data());
-    length_ = 0;
-    capacity_ = b.size();
-  }
-
-  ~winrt_buffer_impl()
-  {
-  }
-
-  STDMETHODIMP Buffer(byte** value)
-  {
-    *value = bytes_;
-    return S_OK;
-  }
-
-  STDMETHODIMP get_Capacity(UINT32* value)
-  {
-    *value = capacity_;
-    return S_OK;
-  }
-
-  STDMETHODIMP get_Length(UINT32 *value)
-  {
-    *value = length_;
-    return S_OK;
-  }
-
-  STDMETHODIMP put_Length(UINT32 value)
-  {
-    if (value > capacity_)
-      return E_INVALIDARG;
-    length_ = value;
-    return S_OK;
-  }
-
-private:
-  byte* bytes_;
-  UINT32 length_;
-  UINT32 capacity_;
-};
-
-void buffer_sequence_adapter_base::init_native_buffer(
-    buffer_sequence_adapter_base::native_buffer_type& buf,
-    const asio::mutable_buffer& buffer)
-{
-  std::memset(&buf, 0, sizeof(native_buffer_type));
-  Microsoft::WRL::ComPtr<IInspectable> insp
-    = Microsoft::WRL::Make<winrt_buffer_impl>(buffer);
-  buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get());
-}
-
-void buffer_sequence_adapter_base::init_native_buffer(
-    buffer_sequence_adapter_base::native_buffer_type& buf,
-    const asio::const_buffer& buffer)
-{
-  std::memset(&buf, 0, sizeof(native_buffer_type));
-  Microsoft::WRL::ComPtr<IInspectable> insp
-    = Microsoft::WRL::Make<winrt_buffer_impl>(buffer);
-  Platform::Object^ buf_obj = reinterpret_cast<Platform::Object^>(insp.Get());
-  buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get());
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/descriptor_ops.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/descriptor_ops.ipp
deleted file mode 100644
index b23453c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/descriptor_ops.ipp
+++ /dev/null
@@ -1,994 +0,0 @@
-//
-// detail/impl/descriptor_ops.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
-#define ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cerrno>
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace descriptor_ops {
-
-int open(const char* path, int flags, asio::error_code& ec)
-{
-  int result = ::open(path, flags);
-  get_last_error(ec, result < 0);
-  return result;
-}
-
-int open(const char* path, int flags,
-    unsigned mode, asio::error_code& ec)
-{
-  int result = ::open(path, flags, mode);
-  get_last_error(ec, result < 0);
-  return result;
-}
-
-int close(int d, state_type& state, asio::error_code& ec)
-{
-  int result = 0;
-  if (d != -1)
-  {
-    result = ::close(d);
-    get_last_error(ec, result < 0);
-
-    if (result != 0
-        && (ec == asio::error::would_block
-          || ec == asio::error::try_again))
-    {
-      // According to UNIX Network Programming Vol. 1, it is possible for
-      // close() to fail with EWOULDBLOCK under certain circumstances. What
-      // isn't clear is the state of the descriptor after this error. The one
-      // current OS where this behaviour is seen, Windows, says that the socket
-      // remains open. Therefore we'll put the descriptor back into blocking
-      // mode and have another attempt at closing it.
-#if defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-      int flags = ::fcntl(d, F_GETFL, 0);
-      if (flags >= 0)
-        ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
-#else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-      ioctl_arg_type arg = 0;
-      if ((state & possible_dup) == 0)
-      {
-        result = ::ioctl(d, FIONBIO, &arg);
-        get_last_error(ec, result < 0);
-      }
-      if ((state & possible_dup) != 0
-# if defined(ENOTTY)
-          || ec.value() == ENOTTY
-# endif // defined(ENOTTY)
-# if defined(ENOTCAPABLE)
-          || ec.value() == ENOTCAPABLE
-# endif // defined(ENOTCAPABLE)
-        )
-      {
-        int flags = ::fcntl(d, F_GETFL, 0);
-        if (flags >= 0)
-          ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
-      }
-#endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-      state &= ~non_blocking;
-
-      result = ::close(d);
-      get_last_error(ec, result < 0);
-    }
-  }
-
-  return result;
-}
-
-bool set_user_non_blocking(int d, state_type& state,
-    bool value, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-#if defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = ::fcntl(d, F_GETFL, 0);
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-  {
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
-    get_last_error(ec, result < 0);
-  }
-#else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = 0;
-  if ((state & possible_dup) == 0)
-  {
-    result = ::ioctl(d, FIONBIO, &arg);
-    get_last_error(ec, result < 0);
-  }
-  if ((state & possible_dup) != 0
-# if defined(ENOTTY)
-      || ec.value() == ENOTTY
-# endif // defined(ENOTTY)
-# if defined(ENOTCAPABLE)
-      || ec.value() == ENOTCAPABLE
-# endif // defined(ENOTCAPABLE)
-    )
-  {
-    result = ::fcntl(d, F_GETFL, 0);
-    get_last_error(ec, result < 0);
-    if (result >= 0)
-    {
-      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
-      get_last_error(ec, result < 0);
-    }
-  }
-#endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-
-  if (result >= 0)
-  {
-    if (value)
-      state |= user_set_non_blocking;
-    else
-    {
-      // Clearing the user-set non-blocking mode always overrides any
-      // internally-set non-blocking flag. Any subsequent asynchronous
-      // operations will need to re-enable non-blocking I/O.
-      state &= ~(user_set_non_blocking | internal_non_blocking);
-    }
-    return true;
-  }
-
-  return false;
-}
-
-bool set_internal_non_blocking(int d, state_type& state,
-    bool value, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-  if (!value && (state & user_set_non_blocking))
-  {
-    // It does not make sense to clear the internal non-blocking flag if the
-    // user still wants non-blocking behaviour. Return an error and let the
-    // caller figure out whether to update the user-set non-blocking flag.
-    ec = asio::error::invalid_argument;
-    return false;
-  }
-
-#if defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = ::fcntl(d, F_GETFL, 0);
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-  {
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
-    get_last_error(ec, result < 0);
-  }
-#else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = 0;
-  if ((state & possible_dup) == 0)
-  {
-    result = ::ioctl(d, FIONBIO, &arg);
-    get_last_error(ec, result < 0);
-  }
-  if ((state & possible_dup) != 0
-# if defined(ENOTTY)
-      || ec.value() == ENOTTY
-# endif // defined(ENOTTY)
-# if defined(ENOTCAPABLE)
-      || ec.value() == ENOTCAPABLE
-# endif // defined(ENOTCAPABLE)
-    )
-  {
-    result = ::fcntl(d, F_GETFL, 0);
-    get_last_error(ec, result < 0);
-    if (result >= 0)
-    {
-      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = (flag != result) ? ::fcntl(d, F_SETFL, flag) : 0;
-      get_last_error(ec, result < 0);
-    }
-  }
-#endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-
-  if (result >= 0)
-  {
-    if (value)
-      state |= internal_non_blocking;
-    else
-      state &= ~internal_non_blocking;
-    return true;
-  }
-
-  return false;
-}
-
-std::size_t sync_read(int d, state_type state, buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::readv(d, bufs, static_cast<int>(count));
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-std::size_t sync_read1(int d, state_type state, void* data,
-    std::size_t size, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (size == 0)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::read(d, data, size);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-bool non_blocking_read(int d, buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = ::readv(d, bufs, static_cast<int>(count));
-    get_last_error(ec, bytes < 0);
-
-    // Check for end of stream.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_read1(int d, void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = ::read(d, data, size);
-    get_last_error(ec, bytes < 0);
-
-    // Check for end of stream.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-std::size_t sync_write(int d, state_type state, const buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::writev(d, bufs, static_cast<int>(count));
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-std::size_t sync_write1(int d, state_type state, const void* data,
-    std::size_t size, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a stream is a no-op.
-  if (size == 0)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::write(d, data, size);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-bool non_blocking_write(int d, const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = ::writev(d, bufs, static_cast<int>(count));
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_write1(int d, const void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = ::write(d, data, size);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#if defined(ASIO_HAS_FILE)
-
-std::size_t sync_read_at(int d, state_type state, uint64_t offset,
-    buf* bufs, std::size_t count, bool all_empty, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::preadv(d, bufs, static_cast<int>(count), offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-std::size_t sync_read_at1(int d, state_type state, uint64_t offset,
-    void* data, std::size_t size, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (size == 0)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::pread(d, data, size, offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-bool non_blocking_read_at(int d, uint64_t offset, buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = ::preadv(d, bufs, static_cast<int>(count), offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_read_at1(int d, uint64_t offset, void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = ::pread(d, data, size, offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-std::size_t sync_write_at(int d, state_type state, uint64_t offset,
-    const buf* bufs, std::size_t count, bool all_empty,
-    asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::pwritev(d,
-        bufs, static_cast<int>(count), offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-std::size_t sync_write_at1(int d, state_type state, uint64_t offset,
-    const void* data, std::size_t size, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a stream is a no-op.
-  if (size == 0)
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = ::pwrite(d, data, size, offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, 0, ec) < 0)
-      return 0;
-  }
-}
-
-bool non_blocking_write_at(int d, uint64_t offset,
-    const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = ::pwritev(d,
-        bufs, static_cast<int>(count), offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_write_at1(int d, uint64_t offset,
-    const void* data, std::size_t size,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = ::pwrite(d, data, size, offset);
-    get_last_error(ec, bytes < 0);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // defined(ASIO_HAS_FILE)
-
-int ioctl(int d, state_type& state, long cmd,
-    ioctl_arg_type* arg, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  int result = ::ioctl(d, cmd, arg);
-  get_last_error(ec, result < 0);
-
-  if (result >= 0)
-  {
-    // When updating the non-blocking mode we always perform the ioctl syscall,
-    // even if the flags would otherwise indicate that the descriptor is
-    // already in the correct state. This ensures that the underlying
-    // descriptor is put into the state that has been requested by the user. If
-    // the ioctl syscall was successful then we need to update the flags to
-    // match.
-    if (cmd == static_cast<long>(FIONBIO))
-    {
-      if (*arg)
-      {
-        state |= user_set_non_blocking;
-      }
-      else
-      {
-        // Clearing the non-blocking mode always overrides any internally-set
-        // non-blocking flag. Any subsequent asynchronous operations will need
-        // to re-enable non-blocking I/O.
-        state &= ~(user_set_non_blocking | internal_non_blocking);
-      }
-    }
-  }
-
-  return result;
-}
-
-int fcntl(int d, int cmd, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  int result = ::fcntl(d, cmd);
-  get_last_error(ec, result < 0);
-  return result;
-}
-
-int fcntl(int d, int cmd, long arg, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  int result = ::fcntl(d, cmd, arg);
-  get_last_error(ec, result < 0);
-  return result;
-}
-
-int poll_read(int d, state_type state, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  pollfd fds;
-  fds.fd = d;
-  fds.events = POLLIN;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-int poll_write(int d, state_type state, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  pollfd fds;
-  fds.fd = d;
-  fds.events = POLLOUT;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-int poll_error(int d, state_type state, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  pollfd fds;
-  fds.fd = d;
-  fds.events = POLLPRI | POLLERR | POLLHUP;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-} // namespace descriptor_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.hpp
deleted file mode 100644
index b483e44..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//
-// detail/impl/dev_poll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include "asio/detail/scheduler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline void dev_poll_reactor::post_immediate_completion(
-    operation* op, bool is_continuation) const
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    interrupter_.interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.ipp
deleted file mode 100644
index 6b79bf8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/dev_poll_reactor.ipp
+++ /dev/null
@@ -1,469 +0,0 @@
-//
-// detail/impl/dev_poll_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include "asio/detail/dev_poll_reactor.hpp"
-#include "asio/detail/assert.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-dev_poll_reactor::dev_poll_reactor(asio::execution_context& ctx)
-  : asio::detail::execution_context_service_base<dev_poll_reactor>(ctx),
-    scheduler_(use_service<scheduler>(ctx)),
-    mutex_(),
-    dev_poll_fd_(do_dev_poll_create()),
-    interrupter_(),
-    shutdown_(false)
-{
-  // Add the interrupter's descriptor to /dev/poll.
-  ::pollfd ev = { 0, 0, 0 };
-  ev.fd = interrupter_.read_descriptor();
-  ev.events = POLLIN | POLLERR;
-  ev.revents = 0;
-  ::write(dev_poll_fd_, &ev, sizeof(ev));
-}
-
-dev_poll_reactor::~dev_poll_reactor()
-{
-  shutdown();
-  ::close(dev_poll_fd_);
-}
-
-void dev_poll_reactor::shutdown()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].get_all_operations(ops);
-
-  timer_queues_.get_all_timers(ops);
-
-  scheduler_.abandon_operations(ops);
-}
-
-void dev_poll_reactor::notify_fork(
-    asio::execution_context::fork_event fork_ev)
-{
-  if (fork_ev == asio::execution_context::fork_child)
-  {
-    detail::mutex::scoped_lock lock(mutex_);
-
-    if (dev_poll_fd_ != -1)
-      ::close(dev_poll_fd_);
-    dev_poll_fd_ = -1;
-    dev_poll_fd_ = do_dev_poll_create();
-
-    interrupter_.recreate();
-
-    // Add the interrupter's descriptor to /dev/poll.
-    ::pollfd ev = { 0, 0, 0 };
-    ev.fd = interrupter_.read_descriptor();
-    ev.events = POLLIN | POLLERR;
-    ev.revents = 0;
-    ::write(dev_poll_fd_, &ev, sizeof(ev));
-
-    // Re-register all descriptors with /dev/poll. The changes will be written
-    // to the /dev/poll descriptor the next time the reactor is run.
-    for (int i = 0; i < max_ops; ++i)
-    {
-      reactor_op_queue<socket_type>::iterator iter = op_queue_[i].begin();
-      reactor_op_queue<socket_type>::iterator end = op_queue_[i].end();
-      for (; iter != end; ++iter)
-      {
-        ::pollfd& pending_ev = add_pending_event_change(iter->first);
-        pending_ev.events |= POLLERR | POLLHUP;
-        switch (i)
-        {
-        case read_op: pending_ev.events |= POLLIN; break;
-        case write_op: pending_ev.events |= POLLOUT; break;
-        case except_op: pending_ev.events |= POLLPRI; break;
-        default: break;
-        }
-      }
-    }
-    interrupter_.interrupt();
-  }
-}
-
-void dev_poll_reactor::init_task()
-{
-  scheduler_.init_task();
-}
-
-int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&)
-{
-  return 0;
-}
-
-int dev_poll_reactor::register_internal_descriptor(int op_type,
-    socket_type descriptor, per_descriptor_data&, reactor_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  op_queue_[op_type].enqueue_operation(descriptor, op);
-  ::pollfd& ev = add_pending_event_change(descriptor);
-  ev.events = POLLERR | POLLHUP;
-  switch (op_type)
-  {
-  case read_op: ev.events |= POLLIN; break;
-  case write_op: ev.events |= POLLOUT; break;
-  case except_op: ev.events |= POLLPRI; break;
-  default: break;
-  }
-  interrupter_.interrupt();
-
-  return 0;
-}
-
-void dev_poll_reactor::move_descriptor(socket_type,
-    dev_poll_reactor::per_descriptor_data&,
-    dev_poll_reactor::per_descriptor_data&)
-{
-}
-
-void dev_poll_reactor::call_post_immediate_completion(
-    operation* op, bool is_continuation, const void* self)
-{
-  static_cast<const dev_poll_reactor*>(self)->post_immediate_completion(
-      op, is_continuation);
-}
-
-void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&, reactor_op* op,
-    bool is_continuation, bool allow_speculative,
-    void (*on_immediate)(operation*, bool, const void*),
-    const void* immediate_arg)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  if (allow_speculative)
-  {
-    if (op_type != read_op || !op_queue_[except_op].has_operation(descriptor))
-    {
-      if (!op_queue_[op_type].has_operation(descriptor))
-      {
-        if (op->perform())
-        {
-          lock.unlock();
-          on_immediate(op, is_continuation, immediate_arg);
-          return;
-        }
-      }
-    }
-  }
-
-  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  scheduler_.work_started();
-  if (first)
-  {
-    ::pollfd& ev = add_pending_event_change(descriptor);
-    ev.events = POLLERR | POLLHUP;
-    if (op_type == read_op
-        || op_queue_[read_op].has_operation(descriptor))
-      ev.events |= POLLIN;
-    if (op_type == write_op
-        || op_queue_[write_op].has_operation(descriptor))
-      ev.events |= POLLOUT;
-    if (op_type == except_op
-        || op_queue_[except_op].has_operation(descriptor))
-      ev.events |= POLLPRI;
-    interrupter_.interrupt();
-  }
-}
-
-void dev_poll_reactor::cancel_ops(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void dev_poll_reactor::cancel_ops_by_key(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&,
-    int op_type, void* cancellation_key)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
-      descriptor, ops, cancellation_key, asio::error::operation_aborted);
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-void dev_poll_reactor::deregister_descriptor(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&, bool)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Remove the descriptor from /dev/poll.
-  ::pollfd& ev = add_pending_event_change(descriptor);
-  ev.events = POLLREMOVE;
-  interrupter_.interrupt();
-
-  // Cancel any outstanding operations associated with the descriptor.
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void dev_poll_reactor::deregister_internal_descriptor(
-    socket_type descriptor, dev_poll_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Remove the descriptor from /dev/poll. Since this function is only called
-  // during a fork, we can apply the change immediately.
-  ::pollfd ev = { 0, 0, 0 };
-  ev.fd = descriptor;
-  ev.events = POLLREMOVE;
-  ev.revents = 0;
-  ::write(dev_poll_fd_, &ev, sizeof(ev));
-
-  // Destroy all operations associated with the descriptor.
-  op_queue<operation> ops;
-  asio::error_code ec;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].cancel_operations(descriptor, ops, ec);
-}
-
-void dev_poll_reactor::cleanup_descriptor_data(
-    dev_poll_reactor::per_descriptor_data&)
-{
-}
-
-void dev_poll_reactor::run(long usec, op_queue<operation>& ops)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // We can return immediately if there's no work to do and the reactor is
-  // not supposed to block.
-  if (usec == 0 && op_queue_[read_op].empty() && op_queue_[write_op].empty()
-      && op_queue_[except_op].empty() && timer_queues_.all_empty())
-    return;
-
-  // Write the pending event registration changes to the /dev/poll descriptor.
-  std::size_t events_size = sizeof(::pollfd) * pending_event_changes_.size();
-  if (events_size > 0)
-  {
-    errno = 0;
-    int result = ::write(dev_poll_fd_,
-        &pending_event_changes_[0], events_size);
-    if (result != static_cast<int>(events_size))
-    {
-      asio::error_code ec = asio::error_code(
-          errno, asio::error::get_system_category());
-      for (std::size_t i = 0; i < pending_event_changes_.size(); ++i)
-      {
-        int descriptor = pending_event_changes_[i].fd;
-        for (int j = 0; j < max_ops; ++j)
-          op_queue_[j].cancel_operations(descriptor, ops, ec);
-      }
-    }
-    pending_event_changes_.clear();
-    pending_event_change_index_.clear();
-  }
-
-  // Calculate timeout.
-  int timeout;
-  if (usec == 0)
-    timeout = 0;
-  else
-  {
-    timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
-    timeout = get_timeout(timeout);
-  }
-  lock.unlock();
-
-  // Block on the /dev/poll descriptor.
-  ::pollfd events[128] = { { 0, 0, 0 } };
-  ::dvpoll dp = { 0, 0, 0 };
-  dp.dp_fds = events;
-  dp.dp_nfds = 128;
-  dp.dp_timeout = timeout;
-  int num_events = ::ioctl(dev_poll_fd_, DP_POLL, &dp);
-
-  lock.lock();
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    int descriptor = events[i].fd;
-    if (descriptor == interrupter_.read_descriptor())
-    {
-      interrupter_.reset();
-    }
-    else
-    {
-      bool more_reads = false;
-      bool more_writes = false;
-      bool more_except = false;
-
-      // Exception operations must be processed first to ensure that any
-      // out-of-band data is read before normal data.
-      if (events[i].events & (POLLPRI | POLLERR | POLLHUP))
-        more_except =
-          op_queue_[except_op].perform_operations(descriptor, ops);
-      else
-        more_except = op_queue_[except_op].has_operation(descriptor);
-
-      if (events[i].events & (POLLIN | POLLERR | POLLHUP))
-        more_reads = op_queue_[read_op].perform_operations(descriptor, ops);
-      else
-        more_reads = op_queue_[read_op].has_operation(descriptor);
-
-      if (events[i].events & (POLLOUT | POLLERR | POLLHUP))
-        more_writes = op_queue_[write_op].perform_operations(descriptor, ops);
-      else
-        more_writes = op_queue_[write_op].has_operation(descriptor);
-
-      if ((events[i].events & (POLLERR | POLLHUP)) != 0
-            && !more_except && !more_reads && !more_writes)
-      {
-        // If we have an event and no operations associated with the
-        // descriptor then we need to delete the descriptor from /dev/poll.
-        // The poll operation can produce POLLHUP or POLLERR events when there
-        // is no operation pending, so if we do not remove the descriptor we
-        // can end up in a tight polling loop.
-        ::pollfd ev = { 0, 0, 0 };
-        ev.fd = descriptor;
-        ev.events = POLLREMOVE;
-        ev.revents = 0;
-        ::write(dev_poll_fd_, &ev, sizeof(ev));
-      }
-      else
-      {
-        ::pollfd ev = { 0, 0, 0 };
-        ev.fd = descriptor;
-        ev.events = POLLERR | POLLHUP;
-        if (more_reads)
-          ev.events |= POLLIN;
-        if (more_writes)
-          ev.events |= POLLOUT;
-        if (more_except)
-          ev.events |= POLLPRI;
-        ev.revents = 0;
-        int result = ::write(dev_poll_fd_, &ev, sizeof(ev));
-        if (result != sizeof(ev))
-        {
-          asio::error_code ec(errno,
-              asio::error::get_system_category());
-          for (int j = 0; j < max_ops; ++j)
-            op_queue_[j].cancel_operations(descriptor, ops, ec);
-        }
-      }
-    }
-  }
-  timer_queues_.get_ready_timers(ops);
-}
-
-void dev_poll_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-
-int dev_poll_reactor::do_dev_poll_create()
-{
-  int fd = ::open("/dev/poll", O_RDWR);
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "/dev/poll");
-  }
-  return fd;
-}
-
-void dev_poll_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void dev_poll_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-int dev_poll_reactor::get_timeout(int msec)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  const int max_msec = 5 * 60 * 1000;
-  return timer_queues_.wait_duration_msec(
-      (msec < 0 || max_msec < msec) ? max_msec : msec);
-}
-
-void dev_poll_reactor::cancel_ops_unlocked(socket_type descriptor,
-    const asio::error_code& ec)
-{
-  bool need_interrupt = false;
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    need_interrupt = op_queue_[i].cancel_operations(
-        descriptor, ops, ec) || need_interrupt;
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-::pollfd& dev_poll_reactor::add_pending_event_change(int descriptor)
-{
-  hash_map<int, std::size_t>::iterator iter
-    = pending_event_change_index_.find(descriptor);
-  if (iter == pending_event_change_index_.end())
-  {
-    std::size_t index = pending_event_changes_.size();
-    pending_event_changes_.reserve(pending_event_changes_.size() + 1);
-    pending_event_change_index_.insert(std::make_pair(descriptor, index));
-    pending_event_changes_.push_back(::pollfd());
-    pending_event_changes_[index].fd = descriptor;
-    pending_event_changes_[index].revents = 0;
-    return pending_event_changes_[index];
-  }
-  else
-  {
-    return pending_event_changes_[iter->second];
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.hpp
deleted file mode 100644
index 4fffeb7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//
-// detail/impl/epoll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include "asio/detail/scheduler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline void epoll_reactor::post_immediate_completion(
-    operation* op, bool is_continuation) const
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    update_timeout();
-}
-
-template <typename Time_Traits>
-std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void epoll_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.ipp
deleted file mode 100644
index 51795bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/epoll_reactor.ipp
+++ /dev/null
@@ -1,826 +0,0 @@
-//
-// detail/impl/epoll_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include <cstddef>
-#include <sys/epoll.h>
-#include "asio/detail/epoll_reactor.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#if defined(ASIO_HAS_TIMERFD)
-# include <sys/timerfd.h>
-#endif // defined(ASIO_HAS_TIMERFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-epoll_reactor::epoll_reactor(asio::execution_context& ctx)
-  : execution_context_service_base<epoll_reactor>(ctx),
-    scheduler_(use_service<scheduler>(ctx)),
-    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
-    interrupter_(),
-    epoll_fd_(do_epoll_create()),
-    timer_fd_(do_timerfd_create()),
-    shutdown_(false),
-    registered_descriptors_mutex_(mutex_.enabled())
-{
-  // Add the interrupter's descriptor to epoll.
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-  ev.data.ptr = &interrupter_;
-  epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
-  interrupter_.interrupt();
-
-  // Add the timer descriptor to epoll.
-  if (timer_fd_ != -1)
-  {
-    ev.events = EPOLLIN | EPOLLERR;
-    ev.data.ptr = &timer_fd_;
-    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
-  }
-}
-
-epoll_reactor::~epoll_reactor()
-{
-  if (epoll_fd_ != -1)
-    close(epoll_fd_);
-  if (timer_fd_ != -1)
-    close(timer_fd_);
-}
-
-void epoll_reactor::shutdown()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  while (descriptor_state* state = registered_descriptors_.first())
-  {
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(state->op_queue_[i]);
-    state->shutdown_ = true;
-    registered_descriptors_.free(state);
-  }
-
-  timer_queues_.get_all_timers(ops);
-
-  scheduler_.abandon_operations(ops);
-}
-
-void epoll_reactor::notify_fork(
-    asio::execution_context::fork_event fork_ev)
-{
-  if (fork_ev == asio::execution_context::fork_child)
-  {
-    if (epoll_fd_ != -1)
-      ::close(epoll_fd_);
-    epoll_fd_ = -1;
-    epoll_fd_ = do_epoll_create();
-
-    if (timer_fd_ != -1)
-      ::close(timer_fd_);
-    timer_fd_ = -1;
-    timer_fd_ = do_timerfd_create();
-
-    interrupter_.recreate();
-
-    // Add the interrupter's descriptor to epoll.
-    epoll_event ev = { 0, { 0 } };
-    ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-    ev.data.ptr = &interrupter_;
-    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
-    interrupter_.interrupt();
-
-    // Add the timer descriptor to epoll.
-    if (timer_fd_ != -1)
-    {
-      ev.events = EPOLLIN | EPOLLERR;
-      ev.data.ptr = &timer_fd_;
-      epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
-    }
-
-    update_timeout();
-
-    // Re-register all descriptors with epoll.
-    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-    for (descriptor_state* state = registered_descriptors_.first();
-        state != 0; state = state->next_)
-    {
-      ev.events = state->registered_events_;
-      ev.data.ptr = state;
-      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev);
-      if (result != 0)
-      {
-        asio::error_code ec(errno,
-            asio::error::get_system_category());
-        asio::detail::throw_error(ec, "epoll re-registration");
-      }
-    }
-  }
-}
-
-void epoll_reactor::init_task()
-{
-  scheduler_.init_task();
-}
-
-int epoll_reactor::register_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  descriptor_data = allocate_descriptor_state();
-
-  ASIO_HANDLER_REACTOR_REGISTRATION((
-        context(), static_cast<uintmax_t>(descriptor),
-        reinterpret_cast<uintmax_t>(descriptor_data)));
-
-  {
-    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-    descriptor_data->reactor_ = this;
-    descriptor_data->descriptor_ = descriptor;
-    descriptor_data->shutdown_ = false;
-    for (int i = 0; i < max_ops; ++i)
-      descriptor_data->try_speculative_[i] = true;
-  }
-
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
-  descriptor_data->registered_events_ = ev.events;
-  ev.data.ptr = descriptor_data;
-  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
-  if (result != 0)
-  {
-    if (errno == EPERM)
-    {
-      // This file descriptor type is not supported by epoll. However, if it is
-      // a regular file then operations on it will not block. We will allow
-      // this descriptor to be used and fail later if an operation on it would
-      // otherwise require a trip through the reactor.
-      descriptor_data->registered_events_ = 0;
-      return 0;
-    }
-    return errno;
-  }
-
-  return 0;
-}
-
-int epoll_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
-{
-  descriptor_data = allocate_descriptor_state();
-
-  ASIO_HANDLER_REACTOR_REGISTRATION((
-        context(), static_cast<uintmax_t>(descriptor),
-        reinterpret_cast<uintmax_t>(descriptor_data)));
-
-  {
-    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-    descriptor_data->reactor_ = this;
-    descriptor_data->descriptor_ = descriptor;
-    descriptor_data->shutdown_ = false;
-    descriptor_data->op_queue_[op_type].push(op);
-    for (int i = 0; i < max_ops; ++i)
-      descriptor_data->try_speculative_[i] = true;
-  }
-
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
-  descriptor_data->registered_events_ = ev.events;
-  ev.data.ptr = descriptor_data;
-  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
-  if (result != 0)
-    return errno;
-
-  return 0;
-}
-
-void epoll_reactor::move_descriptor(socket_type,
-    epoll_reactor::per_descriptor_data& target_descriptor_data,
-    epoll_reactor::per_descriptor_data& source_descriptor_data)
-{
-  target_descriptor_data = source_descriptor_data;
-  source_descriptor_data = 0;
-}
-
-void epoll_reactor::call_post_immediate_completion(
-    operation* op, bool is_continuation, const void* self)
-{
-  static_cast<const epoll_reactor*>(self)->post_immediate_completion(
-      op, is_continuation);
-}
-
-void epoll_reactor::start_op(int op_type, socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
-    bool is_continuation, bool allow_speculative,
-    void (*on_immediate)(operation*, bool, const void*),
-    const void* immediate_arg)
-{
-  if (!descriptor_data)
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (descriptor_data->shutdown_)
-  {
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  if (descriptor_data->op_queue_[op_type].empty())
-  {
-    if (allow_speculative
-        && (op_type != read_op
-          || descriptor_data->op_queue_[except_op].empty()))
-    {
-      if (descriptor_data->try_speculative_[op_type])
-      {
-        if (reactor_op::status status = op->perform())
-        {
-          if (status == reactor_op::done_and_exhausted)
-            if (descriptor_data->registered_events_ != 0)
-              descriptor_data->try_speculative_[op_type] = false;
-          descriptor_lock.unlock();
-          on_immediate(op, is_continuation, immediate_arg);
-          return;
-        }
-      }
-
-      if (descriptor_data->registered_events_ == 0)
-      {
-        op->ec_ = asio::error::operation_not_supported;
-        on_immediate(op, is_continuation, immediate_arg);
-        return;
-      }
-
-      if (op_type == write_op)
-      {
-        if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
-        {
-          epoll_event ev = { 0, { 0 } };
-          ev.events = descriptor_data->registered_events_ | EPOLLOUT;
-          ev.data.ptr = descriptor_data;
-          if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev) == 0)
-          {
-            descriptor_data->registered_events_ |= ev.events;
-          }
-          else
-          {
-            op->ec_ = asio::error_code(errno,
-                asio::error::get_system_category());
-            on_immediate(op, is_continuation, immediate_arg);
-            return;
-          }
-        }
-      }
-    }
-    else if (descriptor_data->registered_events_ == 0)
-    {
-      op->ec_ = asio::error::operation_not_supported;
-      on_immediate(op, is_continuation, immediate_arg);
-      return;
-    }
-    else
-    {
-      if (op_type == write_op)
-      {
-        descriptor_data->registered_events_ |= EPOLLOUT;
-      }
-
-      epoll_event ev = { 0, { 0 } };
-      ev.events = descriptor_data->registered_events_;
-      ev.data.ptr = descriptor_data;
-      epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
-    }
-  }
-
-  descriptor_data->op_queue_[op_type].push(op);
-  scheduler_.work_started();
-}
-
-void epoll_reactor::cancel_ops(socket_type,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
-    }
-  }
-
-  descriptor_lock.unlock();
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void epoll_reactor::cancel_ops_by_key(socket_type,
-    epoll_reactor::per_descriptor_data& descriptor_data,
-    int op_type, void* cancellation_key)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  op_queue<reactor_op> other_ops;
-  while (reactor_op* op = descriptor_data->op_queue_[op_type].front())
-  {
-    descriptor_data->op_queue_[op_type].pop();
-    if (op->cancellation_key_ == cancellation_key)
-    {
-      op->ec_ = asio::error::operation_aborted;
-      ops.push(op);
-    }
-    else
-      other_ops.push(op);
-  }
-  descriptor_data->op_queue_[op_type].push(other_ops);
-
-  descriptor_lock.unlock();
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void epoll_reactor::deregister_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    if (closing)
-    {
-      // The descriptor will be automatically removed from the epoll set when
-      // it is closed.
-    }
-    else if (descriptor_data->registered_events_ != 0)
-    {
-      epoll_event ev = { 0, { 0 } };
-      epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
-    }
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-    {
-      while (reactor_op* op = descriptor_data->op_queue_[i].front())
-      {
-        op->ec_ = asio::error::operation_aborted;
-        descriptor_data->op_queue_[i].pop();
-        ops.push(op);
-      }
-    }
-
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    ASIO_HANDLER_REACTOR_DEREGISTRATION((
-          context(), static_cast<uintmax_t>(descriptor),
-          reinterpret_cast<uintmax_t>(descriptor_data)));
-
-    scheduler_.post_deferred_completions(ops);
-
-    // Leave descriptor_data set so that it will be freed by the subsequent
-    // call to cleanup_descriptor_data.
-  }
-  else
-  {
-    // We are shutting down, so prevent cleanup_descriptor_data from freeing
-    // the descriptor_data object and let the destructor free it instead.
-    descriptor_data = 0;
-  }
-}
-
-void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    epoll_event ev = { 0, { 0 } };
-    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(descriptor_data->op_queue_[i]);
-
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    ASIO_HANDLER_REACTOR_DEREGISTRATION((
-          context(), static_cast<uintmax_t>(descriptor),
-          reinterpret_cast<uintmax_t>(descriptor_data)));
-
-    // Leave descriptor_data set so that it will be freed by the subsequent
-    // call to cleanup_descriptor_data.
-  }
-  else
-  {
-    // We are shutting down, so prevent cleanup_descriptor_data from freeing
-    // the descriptor_data object and let the destructor free it instead.
-    descriptor_data = 0;
-  }
-}
-
-void epoll_reactor::cleanup_descriptor_data(
-    per_descriptor_data& descriptor_data)
-{
-  if (descriptor_data)
-  {
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
-  }
-}
-
-void epoll_reactor::run(long usec, op_queue<operation>& ops)
-{
-  // This code relies on the fact that the scheduler queues the reactor task
-  // behind all descriptor operations generated by this function. This means,
-  // that by the time we reach this point, any previously returned descriptor
-  // operations have already been dequeued. Therefore it is now safe for us to
-  // reuse and return them for the scheduler to queue again.
-
-  // Calculate timeout. Check the timer queues only if timerfd is not in use.
-  int timeout;
-  if (usec == 0)
-    timeout = 0;
-  else
-  {
-    timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
-    if (timer_fd_ == -1)
-    {
-      mutex::scoped_lock lock(mutex_);
-      timeout = get_timeout(timeout);
-    }
-  }
-
-  // Block on the epoll descriptor.
-  epoll_event events[128];
-  int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-  // Trace the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    void* ptr = events[i].data.ptr;
-    if (ptr == &interrupter_)
-    {
-      // Ignore.
-    }
-# if defined(ASIO_HAS_TIMERFD)
-    else if (ptr == &timer_fd_)
-    {
-      // Ignore.
-    }
-# endif // defined(ASIO_HAS_TIMERFD)
-    else
-    {
-      unsigned event_mask = 0;
-      if ((events[i].events & EPOLLIN) != 0)
-        event_mask |= ASIO_HANDLER_REACTOR_READ_EVENT;
-      if ((events[i].events & EPOLLOUT))
-        event_mask |= ASIO_HANDLER_REACTOR_WRITE_EVENT;
-      if ((events[i].events & (EPOLLERR | EPOLLHUP)) != 0)
-        event_mask |= ASIO_HANDLER_REACTOR_ERROR_EVENT;
-      ASIO_HANDLER_REACTOR_EVENTS((context(),
-            reinterpret_cast<uintmax_t>(ptr), event_mask));
-    }
-  }
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#if defined(ASIO_HAS_TIMERFD)
-  bool check_timers = (timer_fd_ == -1);
-#else // defined(ASIO_HAS_TIMERFD)
-  bool check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    void* ptr = events[i].data.ptr;
-    if (ptr == &interrupter_)
-    {
-      // No need to reset the interrupter since we're leaving the descriptor
-      // in a ready-to-read state and relying on edge-triggered notifications
-      // to make it so that we only get woken up when the descriptor's epoll
-      // registration is updated.
-
-#if defined(ASIO_HAS_TIMERFD)
-      if (timer_fd_ == -1)
-        check_timers = true;
-#else // defined(ASIO_HAS_TIMERFD)
-      check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
-    }
-#if defined(ASIO_HAS_TIMERFD)
-    else if (ptr == &timer_fd_)
-    {
-      check_timers = true;
-    }
-#endif // defined(ASIO_HAS_TIMERFD)
-    else
-    {
-      // The descriptor operation doesn't count as work in and of itself, so we
-      // don't call work_started() here. This still allows the scheduler to
-      // stop if the only remaining operations are descriptor operations.
-      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      if (!ops.is_enqueued(descriptor_data))
-      {
-        descriptor_data->set_ready_events(events[i].events);
-        ops.push(descriptor_data);
-      }
-      else
-      {
-        descriptor_data->add_ready_events(events[i].events);
-      }
-    }
-  }
-
-  if (check_timers)
-  {
-    mutex::scoped_lock common_lock(mutex_);
-    timer_queues_.get_ready_timers(ops);
-
-#if defined(ASIO_HAS_TIMERFD)
-    if (timer_fd_ != -1)
-    {
-      itimerspec new_timeout;
-      itimerspec old_timeout;
-      int flags = get_timeout(new_timeout);
-      timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
-    }
-#endif // defined(ASIO_HAS_TIMERFD)
-  }
-}
-
-void epoll_reactor::interrupt()
-{
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-  ev.data.ptr = &interrupter_;
-  epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev);
-}
-
-int epoll_reactor::do_epoll_create()
-{
-#if defined(EPOLL_CLOEXEC)
-  int fd = epoll_create1(EPOLL_CLOEXEC);
-#else // defined(EPOLL_CLOEXEC)
-  int fd = -1;
-  errno = EINVAL;
-#endif // defined(EPOLL_CLOEXEC)
-
-  if (fd == -1 && (errno == EINVAL || errno == ENOSYS))
-  {
-    fd = epoll_create(epoll_size);
-    if (fd != -1)
-      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
-  }
-
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "epoll");
-  }
-
-  return fd;
-}
-
-int epoll_reactor::do_timerfd_create()
-{
-#if defined(ASIO_HAS_TIMERFD)
-# if defined(TFD_CLOEXEC)
-  int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
-# else // defined(TFD_CLOEXEC)
-  int fd = -1;
-  errno = EINVAL;
-# endif // defined(TFD_CLOEXEC)
-
-  if (fd == -1 && errno == EINVAL)
-  {
-    fd = timerfd_create(CLOCK_MONOTONIC, 0);
-    if (fd != -1)
-      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
-  }
-
-  return fd;
-#else // defined(ASIO_HAS_TIMERFD)
-  return -1;
-#endif // defined(ASIO_HAS_TIMERFD)
-}
-
-epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-        REACTOR_IO, scheduler_.concurrency_hint()));
-}
-
-void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  registered_descriptors_.free(s);
-}
-
-void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-void epoll_reactor::update_timeout()
-{
-#if defined(ASIO_HAS_TIMERFD)
-  if (timer_fd_ != -1)
-  {
-    itimerspec new_timeout;
-    itimerspec old_timeout;
-    int flags = get_timeout(new_timeout);
-    timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
-    return;
-  }
-#endif // defined(ASIO_HAS_TIMERFD)
-  interrupt();
-}
-
-int epoll_reactor::get_timeout(int msec)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  const int max_msec = 5 * 60 * 1000;
-  return timer_queues_.wait_duration_msec(
-      (msec < 0 || max_msec < msec) ? max_msec : msec);
-}
-
-#if defined(ASIO_HAS_TIMERFD)
-int epoll_reactor::get_timeout(itimerspec& ts)
-{
-  ts.it_interval.tv_sec = 0;
-  ts.it_interval.tv_nsec = 0;
-
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
-  ts.it_value.tv_sec = usec / 1000000;
-  ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
-
-  return usec ? 0 : TFD_TIMER_ABSTIME;
-}
-#endif // defined(ASIO_HAS_TIMERFD)
-
-struct epoll_reactor::perform_io_cleanup_on_block_exit
-{
-  explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
-    : reactor_(r), first_op_(0)
-  {
-  }
-
-  ~perform_io_cleanup_on_block_exit()
-  {
-    if (first_op_)
-    {
-      // Post the remaining completed operations for invocation.
-      if (!ops_.empty())
-        reactor_->scheduler_.post_deferred_completions(ops_);
-
-      // A user-initiated operation has completed, but there's no need to
-      // explicitly call work_finished() here. Instead, we'll take advantage of
-      // the fact that the scheduler will call work_finished() once we return.
-    }
-    else
-    {
-      // No user-initiated operations have completed, so we need to compensate
-      // for the work_finished() call that the scheduler will make once this
-      // operation returns.
-      reactor_->scheduler_.compensating_work_started();
-    }
-  }
-
-  epoll_reactor* reactor_;
-  op_queue<operation> ops_;
-  operation* first_op_;
-};
-
-epoll_reactor::descriptor_state::descriptor_state(bool locking)
-  : operation(&epoll_reactor::descriptor_state::do_complete),
-    mutex_(locking)
-{
-}
-
-operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
-{
-  mutex_.lock();
-  perform_io_cleanup_on_block_exit io_cleanup(reactor_);
-  mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
-
-  // Exception operations must be processed first to ensure that any
-  // out-of-band data is read before normal data.
-  static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
-  for (int j = max_ops - 1; j >= 0; --j)
-  {
-    if (events & (flag[j] | EPOLLERR | EPOLLHUP))
-    {
-      try_speculative_[j] = true;
-      while (reactor_op* op = op_queue_[j].front())
-      {
-        if (reactor_op::status status = op->perform())
-        {
-          op_queue_[j].pop();
-          io_cleanup.ops_.push(op);
-          if (status == reactor_op::done_and_exhausted)
-          {
-            try_speculative_[j] = false;
-            break;
-          }
-        }
-        else
-          break;
-      }
-    }
-  }
-
-  // The first operation will be returned for completion now. The others will
-  // be posted for later by the io_cleanup object's destructor.
-  io_cleanup.first_op_ = io_cleanup.ops_.front();
-  io_cleanup.ops_.pop();
-  return io_cleanup.first_op_;
-}
-
-void epoll_reactor::descriptor_state::do_complete(
-    void* owner, operation* base,
-    const asio::error_code& ec, std::size_t bytes_transferred)
-{
-  if (owner)
-  {
-    descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
-    uint32_t events = static_cast<uint32_t>(bytes_transferred);
-    if (operation* op = descriptor_data->perform_io(events))
-    {
-      op->complete(owner, ec, 0);
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/eventfd_select_interrupter.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/eventfd_select_interrupter.ipp
deleted file mode 100644
index 2e970d8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/eventfd_select_interrupter.ipp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// detail/impl/eventfd_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EVENTFD)
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-# include <asm/unistd.h>
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-# include <sys/eventfd.h>
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/eventfd_select_interrupter.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-eventfd_select_interrupter::eventfd_select_interrupter()
-{
-  open_descriptors();
-}
-
-void eventfd_select_interrupter::open_descriptors()
-{
-#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-  write_descriptor_ = read_descriptor_ = syscall(__NR_eventfd, 0);
-  if (read_descriptor_ != -1)
-  {
-    ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-  }
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-# if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  write_descriptor_ = read_descriptor_ =
-    ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-# else // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  errno = EINVAL;
-  write_descriptor_ = read_descriptor_ = -1;
-# endif // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  if (read_descriptor_ == -1 && errno == EINVAL)
-  {
-    write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
-    if (read_descriptor_ != -1)
-    {
-      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-    }
-  }
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__)
-
-  if (read_descriptor_ == -1)
-  {
-    int pipe_fds[2];
-    if (pipe(pipe_fds) == 0)
-    {
-      read_descriptor_ = pipe_fds[0];
-      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-      write_descriptor_ = pipe_fds[1];
-      ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
-    }
-    else
-    {
-      asio::error_code ec(errno,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "eventfd_select_interrupter");
-    }
-  }
-}
-
-eventfd_select_interrupter::~eventfd_select_interrupter()
-{
-  close_descriptors();
-}
-
-void eventfd_select_interrupter::close_descriptors()
-{
-  if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
-    ::close(write_descriptor_);
-  if (read_descriptor_ != -1)
-    ::close(read_descriptor_);
-}
-
-void eventfd_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = -1;
-  read_descriptor_ = -1;
-
-  open_descriptors();
-}
-
-void eventfd_select_interrupter::interrupt()
-{
-  uint64_t counter(1UL);
-  int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
-  (void)result;
-}
-
-bool eventfd_select_interrupter::reset()
-{
-  if (write_descriptor_ == read_descriptor_)
-  {
-    for (;;)
-    {
-      // Only perform one read. The kernel maintains an atomic counter.
-      uint64_t counter(0);
-      errno = 0;
-      int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
-      if (bytes_read < 0 && errno == EINTR)
-        continue;
-      return true;
-    }
-  }
-  else
-  {
-    for (;;)
-    {
-      // Clear all data from the pipe.
-      char data[1024];
-      int bytes_read = ::read(read_descriptor_, data, sizeof(data));
-      if (bytes_read == sizeof(data))
-        continue;
-      if (bytes_read > 0)
-        return true;
-      if (bytes_read == 0)
-        return false;
-      if (errno == EINTR)
-        continue;
-      if (errno == EWOULDBLOCK)
-        return true;
-      if (errno == EAGAIN)
-        return true;
-      return false;
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EVENTFD)
-
-#endif // ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/handler_tracking.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/handler_tracking.ipp
deleted file mode 100644
index f4e3e3b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/handler_tracking.ipp
+++ /dev/null
@@ -1,398 +0,0 @@
-//
-// detail/impl/handler_tracking.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
-#define ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_CUSTOM_HANDLER_TRACKING)
-
-// The handler tracking implementation is provided by the user-specified header.
-
-#elif defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#include <cstdarg>
-#include <cstdio>
-#include "asio/detail/handler_tracking.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/time_traits.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/detail/chrono.hpp"
-# include "asio/detail/chrono_time_traits.hpp"
-# include "asio/wait_traits.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/socket_types.hpp"
-#elif !defined(ASIO_WINDOWS)
-# include <unistd.h>
-#endif // !defined(ASIO_WINDOWS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct handler_tracking_timestamp
-{
-  uint64_t seconds;
-  uint64_t microseconds;
-
-  handler_tracking_timestamp()
-  {
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-    boost::posix_time::time_duration now =
-      boost::posix_time::microsec_clock::universal_time() - epoch;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-    typedef chrono_time_traits<chrono::system_clock,
-        asio::wait_traits<chrono::system_clock>> traits_helper;
-    traits_helper::posix_time_duration now(
-        chrono::system_clock::now().time_since_epoch());
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-    seconds = static_cast<uint64_t>(now.total_seconds());
-    microseconds = static_cast<uint64_t>(now.total_microseconds() % 1000000);
-  }
-};
-
-struct handler_tracking::tracking_state
-{
-  static_mutex mutex_;
-  uint64_t next_id_;
-  tss_ptr<completion>* current_completion_;
-  tss_ptr<location>* current_location_;
-};
-
-handler_tracking::tracking_state* handler_tracking::get_state()
-{
-  static tracking_state state = { ASIO_STATIC_MUTEX_INIT, 1, 0, 0 };
-  return &state;
-}
-
-void handler_tracking::init()
-{
-  static tracking_state* state = get_state();
-
-  state->mutex_.init();
-
-  static_mutex::scoped_lock lock(state->mutex_);
-  if (state->current_completion_ == 0)
-    state->current_completion_ = new tss_ptr<completion>;
-  if (state->current_location_ == 0)
-    state->current_location_ = new tss_ptr<location>;
-}
-
-handler_tracking::location::location(
-    const char* file, int line, const char* func)
-  : file_(file),
-    line_(line),
-    func_(func),
-    next_(*get_state()->current_location_)
-{
-  if (file_)
-    *get_state()->current_location_ = this;
-}
-
-handler_tracking::location::~location()
-{
-  if (file_)
-    *get_state()->current_location_ = next_;
-}
-
-void handler_tracking::creation(execution_context&,
-    handler_tracking::tracked_handler& h,
-    const char* object_type, void* object,
-    uintmax_t /*native_handle*/, const char* op_name)
-{
-  static tracking_state* state = get_state();
-
-  static_mutex::scoped_lock lock(state->mutex_);
-  h.id_ = state->next_id_++;
-  lock.unlock();
-
-  handler_tracking_timestamp timestamp;
-
-  uint64_t current_id = 0;
-  if (completion* current_completion = *state->current_completion_)
-    current_id = current_completion->id_;
-
-  for (location* current_location = *state->current_location_;
-      current_location; current_location = current_location->next_)
-  {
-    write_line(
-#if defined(ASIO_WINDOWS)
-        "@asio|%I64u.%06I64u|%I64u^%I64u|%s%s%.80s%s(%.80s:%d)\n",
-#else // defined(ASIO_WINDOWS)
-        "@asio|%llu.%06llu|%llu^%llu|%s%s%.80s%s(%.80s:%d)\n",
-#endif // defined(ASIO_WINDOWS)
-        timestamp.seconds, timestamp.microseconds,
-        current_id, h.id_,
-        current_location == *state->current_location_ ? "in " : "called from ",
-        current_location->func_ ? "'" : "",
-        current_location->func_ ? current_location->func_ : "",
-        current_location->func_ ? "' " : "",
-        current_location->file_, current_location->line_);
-  }
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|%llu*%llu|%.20s@%p.%.50s\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      current_id, h.id_, object_type, object, op_name);
-}
-
-handler_tracking::completion::completion(
-    const handler_tracking::tracked_handler& h)
-  : id_(h.id_),
-    invoked_(false),
-    next_(*get_state()->current_completion_)
-{
-  *get_state()->current_completion_ = this;
-}
-
-handler_tracking::completion::~completion()
-{
-  if (id_)
-  {
-    handler_tracking_timestamp timestamp;
-
-    write_line(
-#if defined(ASIO_WINDOWS)
-        "@asio|%I64u.%06I64u|%c%I64u|\n",
-#else // defined(ASIO_WINDOWS)
-        "@asio|%llu.%06llu|%c%llu|\n",
-#endif // defined(ASIO_WINDOWS)
-        timestamp.seconds, timestamp.microseconds,
-        invoked_ ? '!' : '~', id_);
-  }
-
-  *get_state()->current_completion_ = next_;
-}
-
-void handler_tracking::completion::invocation_begin()
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|>%llu|\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds, id_);
-
-  invoked_ = true;
-}
-
-void handler_tracking::completion::invocation_begin(
-    const asio::error_code& ec)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      id_, ec.category().name(), ec.value());
-
-  invoked_ = true;
-}
-
-void handler_tracking::completion::invocation_begin(
-    const asio::error_code& ec, std::size_t bytes_transferred)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,bytes_transferred=%I64u\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,bytes_transferred=%llu\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      id_, ec.category().name(), ec.value(),
-      static_cast<uint64_t>(bytes_transferred));
-
-  invoked_ = true;
-}
-
-void handler_tracking::completion::invocation_begin(
-    const asio::error_code& ec, int signal_number)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,signal_number=%d\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,signal_number=%d\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      id_, ec.category().name(), ec.value(), signal_number);
-
-  invoked_ = true;
-}
-
-void handler_tracking::completion::invocation_begin(
-    const asio::error_code& ec, const char* arg)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,%.50s\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,%.50s\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      id_, ec.category().name(), ec.value(), arg);
-
-  invoked_ = true;
-}
-
-void handler_tracking::completion::invocation_end()
-{
-  if (id_)
-  {
-    handler_tracking_timestamp timestamp;
-
-    write_line(
-#if defined(ASIO_WINDOWS)
-        "@asio|%I64u.%06I64u|<%I64u|\n",
-#else // defined(ASIO_WINDOWS)
-        "@asio|%llu.%06llu|<%llu|\n",
-#endif // defined(ASIO_WINDOWS)
-        timestamp.seconds, timestamp.microseconds, id_);
-
-    id_ = 0;
-  }
-}
-
-void handler_tracking::operation(execution_context&,
-    const char* object_type, void* object,
-    uintmax_t /*native_handle*/, const char* op_name)
-{
-  static tracking_state* state = get_state();
-
-  handler_tracking_timestamp timestamp;
-
-  unsigned long long current_id = 0;
-  if (completion* current_completion = *state->current_completion_)
-    current_id = current_completion->id_;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|%I64u|%.20s@%p.%.50s\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|%llu|%.20s@%p.%.50s\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      current_id, object_type, object, op_name);
-}
-
-void handler_tracking::reactor_registration(execution_context& /*context*/,
-    uintmax_t /*native_handle*/, uintmax_t /*registration*/)
-{
-}
-
-void handler_tracking::reactor_deregistration(execution_context& /*context*/,
-    uintmax_t /*native_handle*/, uintmax_t /*registration*/)
-{
-}
-
-void handler_tracking::reactor_events(execution_context& /*context*/,
-    uintmax_t /*native_handle*/, unsigned /*events*/)
-{
-}
-
-void handler_tracking::reactor_operation(
-    const tracked_handler& h, const char* op_name,
-    const asio::error_code& ec)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|.%I64u|%s,ec=%.20s:%d\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|.%llu|%s,ec=%.20s:%d\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      h.id_, op_name, ec.category().name(), ec.value());
-}
-
-void handler_tracking::reactor_operation(
-    const tracked_handler& h, const char* op_name,
-    const asio::error_code& ec, std::size_t bytes_transferred)
-{
-  handler_tracking_timestamp timestamp;
-
-  write_line(
-#if defined(ASIO_WINDOWS)
-      "@asio|%I64u.%06I64u|.%I64u|%s,ec=%.20s:%d,bytes_transferred=%I64u\n",
-#else // defined(ASIO_WINDOWS)
-      "@asio|%llu.%06llu|.%llu|%s,ec=%.20s:%d,bytes_transferred=%llu\n",
-#endif // defined(ASIO_WINDOWS)
-      timestamp.seconds, timestamp.microseconds,
-      h.id_, op_name, ec.category().name(), ec.value(),
-      static_cast<uint64_t>(bytes_transferred));
-}
-
-void handler_tracking::write_line(const char* format, ...)
-{
-  using namespace std; // For sprintf (or equivalent).
-
-  va_list args;
-  va_start(args, format);
-
-  char line[256] = "";
-#if defined(ASIO_HAS_SNPRINTF)
-  int length = vsnprintf(line, sizeof(line), format, args);
-#elif defined(ASIO_HAS_SECURE_RTL)
-  int length = vsprintf_s(line, sizeof(line), format, args);
-#else // defined(ASIO_HAS_SECURE_RTL)
-  int length = vsprintf(line, format, args);
-#endif // defined(ASIO_HAS_SECURE_RTL)
-
-  va_end(args);
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-  wchar_t wline[256] = L"";
-  mbstowcs_s(0, wline, sizeof(wline) / sizeof(wchar_t), line, length);
-  ::OutputDebugStringW(wline);
-#elif defined(ASIO_WINDOWS)
-  HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
-  DWORD bytes_written = 0;
-  ::WriteFile(stderr_handle, line, length, &bytes_written, 0);
-#else // defined(ASIO_WINDOWS)
-  ::write(STDERR_FILENO, line, length);
-#endif // defined(ASIO_WINDOWS)
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#endif // ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_descriptor_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_descriptor_service.ipp
deleted file mode 100644
index 21b9e23..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_descriptor_service.ipp
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-// detail/impl/io_uring_descriptor_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/error.hpp"
-#include "asio/detail/io_uring_descriptor_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-io_uring_descriptor_service::io_uring_descriptor_service(
-    execution_context& context)
-  : execution_context_service_base<io_uring_descriptor_service>(context),
-    io_uring_service_(asio::use_service<io_uring_service>(context))
-{
-  io_uring_service_.init_task();
-}
-
-void io_uring_descriptor_service::shutdown()
-{
-}
-
-void io_uring_descriptor_service::construct(
-    io_uring_descriptor_service::implementation_type& impl)
-{
-  impl.descriptor_ = -1;
-  impl.state_ = 0;
-  impl.io_object_data_ = 0;
-}
-
-void io_uring_descriptor_service::move_construct(
-    io_uring_descriptor_service::implementation_type& impl,
-    io_uring_descriptor_service::implementation_type& other_impl)
-  noexcept
-{
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.io_object_data_ = other_impl.io_object_data_;
-  other_impl.io_object_data_ = 0;
-}
-
-void io_uring_descriptor_service::move_assign(
-    io_uring_descriptor_service::implementation_type& impl,
-    io_uring_descriptor_service& /*other_service*/,
-    io_uring_descriptor_service::implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.io_object_data_ = other_impl.io_object_data_;
-  other_impl.io_object_data_ = 0;
-}
-
-void io_uring_descriptor_service::destroy(
-    io_uring_descriptor_service::implementation_type& impl)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-          "descriptor", &impl, impl.descriptor_, "close"));
-
-    io_uring_service_.deregister_io_object(impl.io_object_data_);
-    asio::error_code ignored_ec;
-    descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
-    io_uring_service_.cleanup_io_object(impl.io_object_data_);
-  }
-}
-
-asio::error_code io_uring_descriptor_service::assign(
-    io_uring_descriptor_service::implementation_type& impl,
-    const native_handle_type& native_descriptor, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  io_uring_service_.register_io_object(impl.io_object_data_);
-
-  impl.descriptor_ = native_descriptor;
-  impl.state_ = descriptor_ops::possible_dup;
-  ec = success_ec_;
-  return ec;
-}
-
-asio::error_code io_uring_descriptor_service::close(
-    io_uring_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-          "descriptor", &impl, impl.descriptor_, "close"));
-
-    io_uring_service_.deregister_io_object(impl.io_object_data_);
-    descriptor_ops::close(impl.descriptor_, impl.state_, ec);
-    io_uring_service_.cleanup_io_object(impl.io_object_data_);
-  }
-  else
-  {
-    ec = success_ec_;
-  }
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  construct(impl);
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-io_uring_descriptor_service::native_handle_type
-io_uring_descriptor_service::release(
-    io_uring_descriptor_service::implementation_type& impl)
-{
-  native_handle_type descriptor = impl.descriptor_;
-
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-          "descriptor", &impl, impl.descriptor_, "release"));
-
-    io_uring_service_.deregister_io_object(impl.io_object_data_);
-    io_uring_service_.cleanup_io_object(impl.io_object_data_);
-    construct(impl);
-  }
-
-  return descriptor;
-}
-
-asio::error_code io_uring_descriptor_service::cancel(
-    io_uring_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-        "descriptor", &impl, impl.descriptor_, "cancel"));
-
-  io_uring_service_.cancel_ops(impl.io_object_data_);
-  ec = success_ec_;
-  return ec;
-}
-
-void io_uring_descriptor_service::start_op(
-    io_uring_descriptor_service::implementation_type& impl,
-    int op_type, io_uring_operation* op, bool is_continuation, bool noop)
-{
-  if (!noop)
-  {
-    io_uring_service_.start_op(op_type,
-        impl.io_object_data_, op, is_continuation);
-  }
-  else
-  {
-    io_uring_service_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IMPL_IO_URING_DESCRIPTOR_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_file_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_file_service.ipp
deleted file mode 100644
index 4742a71..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_file_service.ipp
+++ /dev/null
@@ -1,140 +0,0 @@
-//
-// detail/impl/io_uring_file_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  && defined(ASIO_HAS_IO_URING)
-
-#include <cstring>
-#include <sys/stat.h>
-#include "asio/detail/io_uring_file_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-io_uring_file_service::io_uring_file_service(
-    execution_context& context)
-  : execution_context_service_base<io_uring_file_service>(context),
-    descriptor_service_(context)
-{
-}
-
-void io_uring_file_service::shutdown()
-{
-  descriptor_service_.shutdown();
-}
-
-asio::error_code io_uring_file_service::open(
-    io_uring_file_service::implementation_type& impl,
-    const char* path, file_base::flags open_flags,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  descriptor_ops::state_type state = 0;
-  int fd = descriptor_ops::open(path, static_cast<int>(open_flags), 0777, ec);
-  if (fd < 0)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // We're done. Take ownership of the serial port descriptor.
-  if (descriptor_service_.assign(impl, fd, ec))
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-  }
-
-  (void)::posix_fadvise(native_handle(impl), 0, 0,
-      impl.is_stream_ ? POSIX_FADV_SEQUENTIAL : POSIX_FADV_RANDOM);
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-uint64_t io_uring_file_service::size(
-    const io_uring_file_service::implementation_type& impl,
-    asio::error_code& ec) const
-{
-  struct stat s;
-  int result = ::fstat(native_handle(impl), &s);
-  descriptor_ops::get_last_error(ec, result != 0);
-  ASIO_ERROR_LOCATION(ec);
-  return !ec ? s.st_size : 0;
-}
-
-asio::error_code io_uring_file_service::resize(
-    io_uring_file_service::implementation_type& impl,
-    uint64_t n, asio::error_code& ec)
-{
-  int result = ::ftruncate(native_handle(impl), n);
-  descriptor_ops::get_last_error(ec, result != 0);
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-asio::error_code io_uring_file_service::sync_all(
-    io_uring_file_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  int result = ::fsync(native_handle(impl));
-  descriptor_ops::get_last_error(ec, result != 0);
-  return ec;
-}
-
-asio::error_code io_uring_file_service::sync_data(
-    io_uring_file_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-#if defined(_POSIX_SYNCHRONIZED_IO)
-  int result = ::fdatasync(native_handle(impl));
-#else // defined(_POSIX_SYNCHRONIZED_IO)
-  int result = ::fsync(native_handle(impl));
-#endif // defined(_POSIX_SYNCHRONIZED_IO)
-  descriptor_ops::get_last_error(ec, result != 0);
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-uint64_t io_uring_file_service::seek(
-    io_uring_file_service::implementation_type& impl, int64_t offset,
-    file_base::seek_basis whence, asio::error_code& ec)
-{
-  int64_t result = ::lseek(native_handle(impl), offset, whence);
-  descriptor_ops::get_last_error(ec, result < 0);
-  ASIO_ERROR_LOCATION(ec);
-  return !ec ? static_cast<uint64_t>(result) : 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   && defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IMPL_IO_URING_FILE_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.hpp
deleted file mode 100644
index 8dfab1e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// detail/impl/io_uring_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/scheduler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline void io_uring_service::post_immediate_completion(
-    operation* op, bool is_continuation)
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-
-template <typename Time_Traits>
-void io_uring_service::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void io_uring_service::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void io_uring_service::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-  {
-    update_timeout();
-    post_submit_sqes_op(lock);
-  }
-}
-
-template <typename Time_Traits>
-std::size_t io_uring_service::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void io_uring_service::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void io_uring_service::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IMPL_IO_URING_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.ipp
deleted file mode 100644
index 740010c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_service.ipp
+++ /dev/null
@@ -1,914 +0,0 @@
-//
-// detail/impl/io_uring_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include <cstddef>
-#include <sys/eventfd.h>
-#include "asio/detail/io_uring_service.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-io_uring_service::io_uring_service(asio::execution_context& ctx)
-  : execution_context_service_base<io_uring_service>(ctx),
-    scheduler_(use_service<scheduler>(ctx)),
-    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
-    outstanding_work_(0),
-    submit_sqes_op_(this),
-    pending_sqes_(0),
-    pending_submit_sqes_op_(false),
-    shutdown_(false),
-    timeout_(),
-    registration_mutex_(mutex_.enabled()),
-    reactor_(use_service<reactor>(ctx)),
-    reactor_data_(),
-    event_fd_(-1)
-{
-  reactor_.init_task();
-  init_ring();
-  register_with_reactor();
-}
-
-io_uring_service::~io_uring_service()
-{
-  if (ring_.ring_fd != -1)
-    ::io_uring_queue_exit(&ring_);
-  if (event_fd_ != -1)
-    ::close(event_fd_);
-}
-
-void io_uring_service::shutdown()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  // Cancel all outstanding operations.
-  while (io_object* io_obj = registered_io_objects_.first())
-  {
-    for (int i = 0; i < max_ops; ++i)
-    {
-      if (!io_obj->queues_[i].op_queue_.empty())
-      {
-        ops.push(io_obj->queues_[i].op_queue_);
-        if (::io_uring_sqe* sqe = get_sqe())
-          ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
-      }
-    }
-    io_obj->shutdown_ = true;
-    registered_io_objects_.free(io_obj);
-  }
-
-  // Cancel the timeout operation.
-  if (::io_uring_sqe* sqe = get_sqe())
-    ::io_uring_prep_cancel(sqe, &timeout_, IOSQE_IO_DRAIN);
-  submit_sqes();
-
-  // Wait for all completions to come back.
-  for (; outstanding_work_ > 0; --outstanding_work_)
-  {
-    ::io_uring_cqe* cqe = 0;
-    if (::io_uring_wait_cqe(&ring_, &cqe) != 0)
-      break;
-  }
-
-  timer_queues_.get_all_timers(ops);
-
-  scheduler_.abandon_operations(ops);
-}
-
-void io_uring_service::notify_fork(
-    asio::execution_context::fork_event fork_ev)
-{
-  switch (fork_ev)
-  {
-  case asio::execution_context::fork_prepare:
-    {
-      // Cancel all outstanding operations. They will be restarted
-      // after the fork completes.
-      mutex::scoped_lock registration_lock(registration_mutex_);
-      for (io_object* io_obj = registered_io_objects_.first();
-          io_obj != 0; io_obj = io_obj->next_)
-      {
-        mutex::scoped_lock io_object_lock(io_obj->mutex_);
-        for (int i = 0; i < max_ops; ++i)
-        {
-          if (!io_obj->queues_[i].op_queue_.empty()
-              && !io_obj->queues_[i].cancel_requested_)
-          {
-            mutex::scoped_lock lock(mutex_);
-            if (::io_uring_sqe* sqe = get_sqe())
-              ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
-          }
-        }
-      }
-
-      // Cancel the timeout operation.
-      {
-        mutex::scoped_lock lock(mutex_);
-        if (::io_uring_sqe* sqe = get_sqe())
-          ::io_uring_prep_cancel(sqe, &timeout_, IOSQE_IO_DRAIN);
-        submit_sqes();
-      }
-
-      // Wait for all completions to come back, and post all completed I/O
-      // queues to the scheduler. Note that some operations may have already
-      // completed, or were explicitly cancelled. All others will be
-      // automatically restarted.
-      op_queue<operation> ops;
-      for (; outstanding_work_ > 0; --outstanding_work_)
-      {
-        ::io_uring_cqe* cqe = 0;
-        if (::io_uring_wait_cqe(&ring_, &cqe) != 0)
-          break;
-        if (void* ptr = ::io_uring_cqe_get_data(cqe))
-        {
-          if (ptr != this && ptr != &timer_queues_ && ptr != &timeout_)
-          {
-            io_queue* io_q = static_cast<io_queue*>(ptr);
-            io_q->set_result(cqe->res);
-            ops.push(io_q);
-          }
-        }
-      }
-      scheduler_.post_deferred_completions(ops);
-
-      // Restart and eventfd operation.
-      register_with_reactor();
-    }
-    break;
-
-  case asio::execution_context::fork_parent:
-    // Restart the timeout and eventfd operations.
-    update_timeout();
-    register_with_reactor();
-    break;
-
-  case asio::execution_context::fork_child:
-    {
-      // The child process gets a new io_uring instance.
-      ::io_uring_queue_exit(&ring_);
-      init_ring();
-      register_with_reactor();
-    }
-    break;
-  default:
-    break;
-  }
-}
-
-void io_uring_service::init_task()
-{
-  scheduler_.init_task();
-}
-
-void io_uring_service::register_io_object(
-    io_uring_service::per_io_object_data& io_obj)
-{
-  io_obj = allocate_io_object();
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-
-  io_obj->service_ = this;
-  io_obj->shutdown_ = false;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    io_obj->queues_[i].io_object_ = io_obj;
-    io_obj->queues_[i].cancel_requested_ = false;
-  }
-}
-
-void io_uring_service::register_internal_io_object(
-    io_uring_service::per_io_object_data& io_obj,
-    int op_type, io_uring_operation* op)
-{
-  io_obj = allocate_io_object();
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-
-  io_obj->service_ = this;
-  io_obj->shutdown_ = false;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    io_obj->queues_[i].io_object_ = io_obj;
-    io_obj->queues_[i].cancel_requested_ = false;
-  }
-
-  io_obj->queues_[op_type].op_queue_.push(op);
-  io_object_lock.unlock();
-  mutex::scoped_lock lock(mutex_);
-  if (::io_uring_sqe* sqe = get_sqe())
-  {
-    op->prepare(sqe);
-    ::io_uring_sqe_set_data(sqe, &io_obj->queues_[op_type]);
-    post_submit_sqes_op(lock);
-  }
-  else
-  {
-    asio::error_code ec(ENOBUFS,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "io_uring_get_sqe");
-  }
-}
-
-void io_uring_service::register_buffers(const ::iovec* v, unsigned n)
-{
-  int result = ::io_uring_register_buffers(&ring_, v, n);
-  if (result < 0)
-  {
-    asio::error_code ec(-result,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "io_uring_register_buffers");
-  }
-}
-
-void io_uring_service::unregister_buffers()
-{
-  (void)::io_uring_unregister_buffers(&ring_);
-}
-
-void io_uring_service::start_op(int op_type,
-    io_uring_service::per_io_object_data& io_obj,
-    io_uring_operation* op, bool is_continuation)
-{
-  if (!io_obj)
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-
-  if (io_obj->shutdown_)
-  {
-    io_object_lock.unlock();
-    post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  if (io_obj->queues_[op_type].op_queue_.empty())
-  {
-    if (op->perform(false))
-    {
-      io_object_lock.unlock();
-      scheduler_.post_immediate_completion(op, is_continuation);
-    }
-    else
-    {
-      io_obj->queues_[op_type].op_queue_.push(op);
-      io_object_lock.unlock();
-      mutex::scoped_lock lock(mutex_);
-      if (::io_uring_sqe* sqe = get_sqe())
-      {
-        op->prepare(sqe);
-        ::io_uring_sqe_set_data(sqe, &io_obj->queues_[op_type]);
-        scheduler_.work_started();
-        post_submit_sqes_op(lock);
-      }
-      else
-      {
-        lock.unlock();
-        io_obj->queues_[op_type].set_result(-ENOBUFS);
-        post_immediate_completion(&io_obj->queues_[op_type], is_continuation);
-      }
-    }
-  }
-  else
-  {
-    io_obj->queues_[op_type].op_queue_.push(op);
-    scheduler_.work_started();
-  }
-}
-
-void io_uring_service::cancel_ops(io_uring_service::per_io_object_data& io_obj)
-{
-  if (!io_obj)
-    return;
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-  op_queue<operation> ops;
-  do_cancel_ops(io_obj, ops);
-  io_object_lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-void io_uring_service::cancel_ops_by_key(
-    io_uring_service::per_io_object_data& io_obj,
-    int op_type, void* cancellation_key)
-{
-  if (!io_obj)
-    return;
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-
-  bool first = true;
-  op_queue<operation> ops;
-  op_queue<io_uring_operation> other_ops;
-  while (io_uring_operation* op = io_obj->queues_[op_type].op_queue_.front())
-  {
-    io_obj->queues_[op_type].op_queue_.pop();
-    if (op->cancellation_key_ == cancellation_key)
-    {
-      if (first)
-      {
-        other_ops.push(op);
-        if (!io_obj->queues_[op_type].cancel_requested_)
-        {
-          io_obj->queues_[op_type].cancel_requested_ = true;
-          mutex::scoped_lock lock(mutex_);
-          if (::io_uring_sqe* sqe = get_sqe())
-          {
-            ::io_uring_prep_cancel(sqe, &io_obj->queues_[op_type], 0);
-            submit_sqes();
-          }
-        }
-      }
-      else
-      {
-        op->ec_ = asio::error::operation_aborted;
-        ops.push(op);
-      }
-    }
-    else
-      other_ops.push(op);
-    first = false;
-  }
-  io_obj->queues_[op_type].op_queue_.push(other_ops);
-
-  io_object_lock.unlock();
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void io_uring_service::deregister_io_object(
-    io_uring_service::per_io_object_data& io_obj)
-{
-  if (!io_obj)
-    return;
-
-  mutex::scoped_lock io_object_lock(io_obj->mutex_);
-  if (!io_obj->shutdown_)
-  {
-    op_queue<operation> ops;
-    bool pending_cancelled_ops = do_cancel_ops(io_obj, ops);
-    io_obj->shutdown_ = true;
-    io_object_lock.unlock();
-    scheduler_.post_deferred_completions(ops);
-    if (pending_cancelled_ops)
-    {
-      // There are still pending operations. Prevent cleanup_io_object from
-      // freeing the I/O object and let the last operation to complete free it.
-      io_obj = 0;
-    }
-    else
-    {
-      // Leave io_obj set so that it will be freed by the subsequent call to
-      // cleanup_io_object.
-    }
-  }
-  else
-  {
-    // We are shutting down, so prevent cleanup_io_object from freeing
-    // the I/O object and let the destructor free it instead.
-    io_obj = 0;
-  }
-}
-
-void io_uring_service::cleanup_io_object(
-    io_uring_service::per_io_object_data& io_obj)
-{
-  if (io_obj)
-  {
-    free_io_object(io_obj);
-    io_obj = 0;
-  }
-}
-
-void io_uring_service::run(long usec, op_queue<operation>& ops)
-{
-  __kernel_timespec ts;
-  int local_ops = 0;
-
-  if (usec > 0)
-  {
-    ts.tv_sec = usec / 1000000;
-    ts.tv_nsec = (usec % 1000000) * 1000;
-    mutex::scoped_lock lock(mutex_);
-    if (::io_uring_sqe* sqe = get_sqe())
-    {
-      ++local_ops;
-      ::io_uring_prep_timeout(sqe, &ts, 0, 0);
-      ::io_uring_sqe_set_data(sqe, &ts);
-      submit_sqes();
-    }
-  }
-
-  ::io_uring_cqe* cqe = 0;
-  int result = (usec == 0)
-    ? ::io_uring_peek_cqe(&ring_, &cqe)
-    : ::io_uring_wait_cqe(&ring_, &cqe);
-
-  if (local_ops > 0)
-  {
-    if (result != 0 || ::io_uring_cqe_get_data(cqe) != &ts)
-    {
-      mutex::scoped_lock lock(mutex_);
-      if (::io_uring_sqe* sqe = get_sqe())
-      {
-        ++local_ops;
-        ::io_uring_prep_timeout_remove(sqe, reinterpret_cast<__u64>(&ts), 0);
-        ::io_uring_sqe_set_data(sqe, &ts);
-        submit_sqes();
-      }
-    }
-  }
-
-  bool check_timers = false;
-  int count = 0;
-  while (result == 0 || local_ops > 0)
-  {
-    if (result == 0)
-    {
-      if (void* ptr = ::io_uring_cqe_get_data(cqe))
-      {
-        if (ptr == this)
-        {
-          // The io_uring service was interrupted.
-        }
-        else if (ptr == &timer_queues_)
-        {
-          check_timers = true;
-        }
-        else if (ptr == &timeout_)
-        {
-          check_timers = true;
-          timeout_.tv_sec = 0;
-          timeout_.tv_nsec = 0;
-        }
-        else if (ptr == &ts)
-        {
-          --local_ops;
-        }
-        else
-        {
-          io_queue* io_q = static_cast<io_queue*>(ptr);
-          io_q->set_result(cqe->res);
-          ops.push(io_q);
-        }
-      }
-      ::io_uring_cqe_seen(&ring_, cqe);
-      ++count;
-    }
-    result = (count < complete_batch_size || local_ops > 0)
-      ? ::io_uring_peek_cqe(&ring_, &cqe) : -EAGAIN;
-  }
-
-  decrement(outstanding_work_, count);
-
-  if (check_timers)
-  {
-    mutex::scoped_lock lock(mutex_);
-    timer_queues_.get_ready_timers(ops);
-    if (timeout_.tv_sec == 0 && timeout_.tv_nsec == 0)
-    {
-      timeout_ = get_timeout();
-      if (::io_uring_sqe* sqe = get_sqe())
-      {
-        ::io_uring_prep_timeout(sqe, &timeout_, 0, 0);
-        ::io_uring_sqe_set_data(sqe, &timeout_);
-        push_submit_sqes_op(ops);
-      }
-    }
-  }
-}
-
-void io_uring_service::interrupt()
-{
-  mutex::scoped_lock lock(mutex_);
-  if (::io_uring_sqe* sqe = get_sqe())
-  {
-    ::io_uring_prep_nop(sqe);
-    ::io_uring_sqe_set_data(sqe, this);
-  }
-  submit_sqes();
-}
-
-void io_uring_service::init_ring()
-{
-  int result = ::io_uring_queue_init(ring_size, &ring_, 0);
-  if (result < 0)
-  {
-    ring_.ring_fd = -1;
-    asio::error_code ec(-result,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "io_uring_queue_init");
-  }
-
-#if !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  event_fd_ = ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-  if (event_fd_ < 0)
-  {
-    asio::error_code ec(-result,
-        asio::error::get_system_category());
-    ::io_uring_queue_exit(&ring_);
-    asio::detail::throw_error(ec, "eventfd");
-  }
-
-  result = ::io_uring_register_eventfd(&ring_, event_fd_);
-  if (result < 0)
-  {
-    ::close(event_fd_);
-    ::io_uring_queue_exit(&ring_);
-    asio::error_code ec(-result,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "io_uring_queue_init");
-  }
-#endif // !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-}
-
-#if !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-class io_uring_service::event_fd_read_op :
-  public reactor_op
-{
-public:
-  event_fd_read_op(io_uring_service* s)
-    : reactor_op(asio::error_code(),
-        &event_fd_read_op::do_perform, event_fd_read_op::do_complete),
-      service_(s)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    event_fd_read_op* o(static_cast<event_fd_read_op*>(base));
-
-    for (;;)
-    {
-      // Only perform one read. The kernel maintains an atomic counter.
-      uint64_t counter(0);
-      errno = 0;
-      int bytes_read = ::read(o->service_->event_fd_,
-          &counter, sizeof(uint64_t));
-      if (bytes_read < 0 && errno == EINTR)
-        continue;
-      break;
-    }
-
-    op_queue<operation> ops;
-    o->service_->run(0, ops);
-    o->service_->scheduler_.post_deferred_completions(ops);
-
-    return not_done;
-  }
-
-  static void do_complete(void* /*owner*/, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    event_fd_read_op* o(static_cast<event_fd_read_op*>(base));
-    delete o;
-  }
-
-private:
-  io_uring_service* service_;
-};
-#endif // !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-void io_uring_service::register_with_reactor()
-{
-#if !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  reactor_.register_internal_descriptor(reactor::read_op,
-      event_fd_, reactor_data_, new event_fd_read_op(this));
-#endif // !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-}
-
-io_uring_service::io_object* io_uring_service::allocate_io_object()
-{
-  mutex::scoped_lock registration_lock(registration_mutex_);
-  return registered_io_objects_.alloc(
-      ASIO_CONCURRENCY_HINT_IS_LOCKING(
-        REACTOR_IO, scheduler_.concurrency_hint()));
-}
-
-void io_uring_service::free_io_object(io_uring_service::io_object* io_obj)
-{
-  mutex::scoped_lock registration_lock(registration_mutex_);
-  registered_io_objects_.free(io_obj);
-}
-
-bool io_uring_service::do_cancel_ops(
-    per_io_object_data& io_obj, op_queue<operation>& ops)
-{
-  bool cancel_op = false;
-
-  for (int i = 0; i < max_ops; ++i)
-  {
-    if (io_uring_operation* first_op = io_obj->queues_[i].op_queue_.front())
-    {
-      cancel_op = true;
-      io_obj->queues_[i].op_queue_.pop();
-      while (io_uring_operation* op = io_obj->queues_[i].op_queue_.front())
-      {
-        op->ec_ = asio::error::operation_aborted;
-        io_obj->queues_[i].op_queue_.pop();
-        ops.push(op);
-      }
-      io_obj->queues_[i].op_queue_.push(first_op);
-    }
-  }
-
-  if (cancel_op)
-  {
-    mutex::scoped_lock lock(mutex_);
-    for (int i = 0; i < max_ops; ++i)
-    {
-      if (!io_obj->queues_[i].op_queue_.empty()
-          && !io_obj->queues_[i].cancel_requested_)
-      {
-        io_obj->queues_[i].cancel_requested_ = true;
-        if (::io_uring_sqe* sqe = get_sqe())
-          ::io_uring_prep_cancel(sqe, &io_obj->queues_[i], 0);
-      }
-    }
-    submit_sqes();
-  }
-
-  return cancel_op;
-}
-
-void io_uring_service::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void io_uring_service::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-void io_uring_service::update_timeout()
-{
-  if (::io_uring_sqe* sqe = get_sqe())
-  {
-    ::io_uring_prep_timeout_remove(sqe, reinterpret_cast<__u64>(&timeout_), 0);
-    ::io_uring_sqe_set_data(sqe, &timer_queues_);
-  }
-}
-
-__kernel_timespec io_uring_service::get_timeout() const
-{
-  __kernel_timespec ts;
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
-  ts.tv_sec = usec / 1000000;
-  ts.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
-  return ts;
-}
-
-::io_uring_sqe* io_uring_service::get_sqe()
-{
-  ::io_uring_sqe* sqe = ::io_uring_get_sqe(&ring_);
-  if (!sqe)
-  {
-    submit_sqes();
-    sqe = ::io_uring_get_sqe(&ring_);
-  }
-  if (sqe)
-  {
-    ::io_uring_sqe_set_data(sqe, 0);
-    ++pending_sqes_;
-  }
-  return sqe;
-}
-
-void io_uring_service::submit_sqes()
-{
-  if (pending_sqes_ != 0)
-  {
-    int result = ::io_uring_submit(&ring_);
-    if (result > 0)
-    {
-      pending_sqes_ -= result;
-      increment(outstanding_work_, result);
-    }
-  }
-}
-
-void io_uring_service::post_submit_sqes_op(mutex::scoped_lock& lock)
-{
-  if (pending_sqes_ >= submit_batch_size)
-  {
-    submit_sqes();
-  }
-  else if (pending_sqes_ != 0 && !pending_submit_sqes_op_)
-  {
-    pending_submit_sqes_op_ = true;
-    lock.unlock();
-    scheduler_.post_immediate_completion(&submit_sqes_op_, false);
-  }
-}
-
-void io_uring_service::push_submit_sqes_op(op_queue<operation>& ops)
-{
-  if (pending_sqes_ != 0 && !pending_submit_sqes_op_)
-  {
-    pending_submit_sqes_op_ = true;
-    ops.push(&submit_sqes_op_);
-    scheduler_.compensating_work_started();
-  }
-}
-
-io_uring_service::submit_sqes_op::submit_sqes_op(io_uring_service* s)
-  : operation(&io_uring_service::submit_sqes_op::do_complete),
-    service_(s)
-{
-}
-
-void io_uring_service::submit_sqes_op::do_complete(void* owner, operation* base,
-    const asio::error_code& /*ec*/, std::size_t /*bytes_transferred*/)
-{
-  if (owner)
-  {
-    submit_sqes_op* o = static_cast<submit_sqes_op*>(base);
-    mutex::scoped_lock lock(o->service_->mutex_);
-    o->service_->submit_sqes();
-    if (o->service_->pending_sqes_ != 0)
-      o->service_->scheduler_.post_immediate_completion(o, true);
-    else
-      o->service_->pending_submit_sqes_op_ = false;
-  }
-}
-
-io_uring_service::io_queue::io_queue()
-  : operation(&io_uring_service::io_queue::do_complete)
-{
-}
-
-struct io_uring_service::perform_io_cleanup_on_block_exit
-{
-  explicit perform_io_cleanup_on_block_exit(io_uring_service* s)
-    : service_(s), io_object_to_free_(0), first_op_(0)
-  {
-  }
-
-  ~perform_io_cleanup_on_block_exit()
-  {
-    if (io_object_to_free_)
-    {
-      mutex::scoped_lock lock(service_->mutex_);
-      service_->free_io_object(io_object_to_free_);
-    }
-
-    if (first_op_)
-    {
-      // Post the remaining completed operations for invocation.
-      if (!ops_.empty())
-        service_->scheduler_.post_deferred_completions(ops_);
-
-      // A user-initiated operation has completed, but there's no need to
-      // explicitly call work_finished() here. Instead, we'll take advantage of
-      // the fact that the scheduler will call work_finished() once we return.
-    }
-    else
-    {
-      // No user-initiated operations have completed, so we need to compensate
-      // for the work_finished() call that the scheduler will make once this
-      // operation returns.
-      service_->scheduler_.compensating_work_started();
-    }
-  }
-
-  io_uring_service* service_;
-  io_object* io_object_to_free_;
-  op_queue<operation> ops_;
-  operation* first_op_;
-};
-
-operation* io_uring_service::io_queue::perform_io(int result)
-{
-  perform_io_cleanup_on_block_exit io_cleanup(io_object_->service_);
-  mutex::scoped_lock io_object_lock(io_object_->mutex_);
-
-  if (result != -ECANCELED || cancel_requested_)
-  {
-    if (io_uring_operation* op = op_queue_.front())
-    {
-      if (result < 0)
-      {
-        op->ec_.assign(-result, asio::error::get_system_category());
-        op->bytes_transferred_ = 0;
-      }
-      else
-      {
-        op->ec_.assign(0, op->ec_.category());
-        op->bytes_transferred_ = static_cast<std::size_t>(result);
-      }
-    }
-
-    while (io_uring_operation* op = op_queue_.front())
-    {
-      if (op->perform(io_cleanup.ops_.empty()))
-      {
-        op_queue_.pop();
-        io_cleanup.ops_.push(op);
-      }
-      else
-        break;
-    }
-  }
-
-  cancel_requested_ = false;
-
-  if (!op_queue_.empty())
-  {
-    io_uring_service* service = io_object_->service_;
-    mutex::scoped_lock lock(service->mutex_);
-    if (::io_uring_sqe* sqe = service->get_sqe())
-    {
-      op_queue_.front()->prepare(sqe);
-      ::io_uring_sqe_set_data(sqe, this);
-      service->post_submit_sqes_op(lock);
-    }
-    else
-    {
-      lock.unlock();
-      while (io_uring_operation* op = op_queue_.front())
-      {
-        op->ec_ = asio::error::no_buffer_space;
-        op_queue_.pop();
-        io_cleanup.ops_.push(op);
-      }
-    }
-  }
-
-  // The last operation to complete on a shut down object must free it.
-  if (io_object_->shutdown_)
-  {
-    io_cleanup.io_object_to_free_ = io_object_;
-    for (int i = 0; i < max_ops; ++i)
-      if (!io_object_->queues_[i].op_queue_.empty())
-        io_cleanup.io_object_to_free_ = 0;
-  }
-
-  // The first operation will be returned for completion now. The others will
-  // be posted for later by the io_cleanup object's destructor.
-  io_cleanup.first_op_ = io_cleanup.ops_.front();
-  io_cleanup.ops_.pop();
-  return io_cleanup.first_op_;
-}
-
-void io_uring_service::io_queue::do_complete(void* owner, operation* base,
-    const asio::error_code& ec, std::size_t bytes_transferred)
-{
-  if (owner)
-  {
-    io_queue* io_q = static_cast<io_queue*>(base);
-    int result = static_cast<int>(bytes_transferred);
-    if (operation* op = io_q->perform_io(result))
-    {
-      op->complete(owner, ec, 0);
-    }
-  }
-}
-
-io_uring_service::io_object::io_object(bool locking)
-  : mutex_(locking)
-{
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IMPL_IO_URING_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_socket_service_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_socket_service_base.ipp
deleted file mode 100644
index 79302fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/io_uring_socket_service_base.ipp
+++ /dev/null
@@ -1,249 +0,0 @@
-//
-// detail/io_uring_socket_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/io_uring_socket_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-io_uring_socket_service_base::io_uring_socket_service_base(
-    execution_context& context)
-  : io_uring_service_(asio::use_service<io_uring_service>(context))
-{
-  io_uring_service_.init_task();
-}
-
-void io_uring_socket_service_base::base_shutdown()
-{
-}
-
-void io_uring_socket_service_base::construct(
-    io_uring_socket_service_base::base_implementation_type& impl)
-{
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.io_object_data_ = 0;
-}
-
-void io_uring_socket_service_base::base_move_construct(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    io_uring_socket_service_base::base_implementation_type& other_impl)
-  noexcept
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.io_object_data_ = other_impl.io_object_data_;
-  other_impl.io_object_data_ = 0;
-}
-
-void io_uring_socket_service_base::base_move_assign(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    io_uring_socket_service_base& /*other_service*/,
-    io_uring_socket_service_base::base_implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.io_object_data_ = other_impl.io_object_data_;
-  other_impl.io_object_data_ = 0;
-}
-
-void io_uring_socket_service_base::destroy(
-    io_uring_socket_service_base::base_implementation_type& impl)
-{
-  if (impl.socket_ != invalid_socket)
-  {
-    ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    io_uring_service_.deregister_io_object(impl.io_object_data_);
-    asio::error_code ignored_ec;
-    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
-    io_uring_service_.cleanup_io_object(impl.io_object_data_);
-  }
-}
-
-asio::error_code io_uring_socket_service_base::close(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    io_uring_service_.deregister_io_object(impl.io_object_data_);
-    socket_ops::close(impl.socket_, impl.state_, false, ec);
-    io_uring_service_.cleanup_io_object(impl.io_object_data_);
-  }
-  else
-  {
-    ec = success_ec_;
-  }
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  construct(impl);
-
-  return ec;
-}
-
-socket_type io_uring_socket_service_base::release(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return invalid_socket;
-  }
-
-  ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-        "socket", &impl, impl.socket_, "release"));
-
-  io_uring_service_.deregister_io_object(impl.io_object_data_);
-  io_uring_service_.cleanup_io_object(impl.io_object_data_);
-  socket_type sock = impl.socket_;
-  construct(impl);
-  ec = success_ec_;
-  return sock;
-}
-
-asio::error_code io_uring_socket_service_base::cancel(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((io_uring_service_.context(),
-        "socket", &impl, impl.socket_, "cancel"));
-
-  io_uring_service_.cancel_ops(impl.io_object_data_);
-  ec = success_ec_;
-  return ec;
-}
-
-asio::error_code io_uring_socket_service_base::do_open(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    int af, int type, int protocol, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  socket_holder sock(socket_ops::socket(af, type, protocol, ec));
-  if (sock.get() == invalid_socket)
-    return ec;
-
-  io_uring_service_.register_io_object(impl.io_object_data_);
-
-  impl.socket_ = sock.release();
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  ec = success_ec_;
-  return ec;
-}
-
-asio::error_code io_uring_socket_service_base::do_assign(
-    io_uring_socket_service_base::base_implementation_type& impl, int type,
-    const io_uring_socket_service_base::native_handle_type& native_socket,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  io_uring_service_.register_io_object(impl.io_object_data_);
-
-  impl.socket_ = native_socket;
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  impl.state_ |= socket_ops::possible_dup;
-  ec = success_ec_;
-  return ec;
-}
-
-void io_uring_socket_service_base::start_op(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    int op_type, io_uring_operation* op, bool is_continuation, bool noop)
-{
-  if (!noop)
-  {
-    io_uring_service_.start_op(op_type,
-        impl.io_object_data_, op, is_continuation);
-  }
-  else
-  {
-    io_uring_service_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-void io_uring_socket_service_base::start_accept_op(
-    io_uring_socket_service_base::base_implementation_type& impl,
-    io_uring_operation* op, bool is_continuation, bool peer_is_open)
-{
-  if (!peer_is_open)
-    start_op(impl, io_uring_service::read_op, op, is_continuation, false);
-  else
-  {
-    op->ec_ = asio::error::already_open;
-    io_uring_service_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IMPL_IO_URING_SOCKET_SERVICE_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.hpp
deleted file mode 100644
index 3f79e9f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-// detail/impl/kqueue_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_KQUEUE)
-
-#include "asio/detail/scheduler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline void kqueue_reactor::post_immediate_completion(
-    operation* op, bool is_continuation) const
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-
-template <typename Time_Traits>
-void kqueue_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void kqueue_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void kqueue_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void kqueue_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_KQUEUE)
-
-#endif // ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp
deleted file mode 100644
index 210a89d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/kqueue_reactor.ipp
+++ /dev/null
@@ -1,608 +0,0 @@
-//
-// detail/impl/kqueue_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_KQUEUE)
-
-#include "asio/detail/kqueue_reactor.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#if defined(__NetBSD__)
-# include <sys/param.h>
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(__NetBSD__) && __NetBSD_Version__ < 999001500
-# define ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
-    EV_SET(ev, ident, filt, flags, fflags, data, \
-      reinterpret_cast<intptr_t>(static_cast<void*>(udata)))
-#else
-# define ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
-    EV_SET(ev, ident, filt, flags, fflags, data, udata)
-#endif
-
-namespace asio {
-namespace detail {
-
-kqueue_reactor::kqueue_reactor(asio::execution_context& ctx)
-  : execution_context_service_base<kqueue_reactor>(ctx),
-    scheduler_(use_service<scheduler>(ctx)),
-    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
-    kqueue_fd_(do_kqueue_create()),
-    interrupter_(),
-    shutdown_(false),
-    registered_descriptors_mutex_(mutex_.enabled())
-{
-  struct kevent events[1];
-  ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(),
-      EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
-  if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
-  {
-    asio::error_code error(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(error);
-  }
-}
-
-kqueue_reactor::~kqueue_reactor()
-{
-  close(kqueue_fd_);
-}
-
-void kqueue_reactor::shutdown()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  while (descriptor_state* state = registered_descriptors_.first())
-  {
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(state->op_queue_[i]);
-    state->shutdown_ = true;
-    registered_descriptors_.free(state);
-  }
-
-  timer_queues_.get_all_timers(ops);
-
-  scheduler_.abandon_operations(ops);
-}
-
-void kqueue_reactor::notify_fork(
-    asio::execution_context::fork_event fork_ev)
-{
-  if (fork_ev == asio::execution_context::fork_child)
-  {
-    // The kqueue descriptor is automatically closed in the child.
-    kqueue_fd_ = -1;
-    kqueue_fd_ = do_kqueue_create();
-
-    interrupter_.recreate();
-
-    struct kevent events[2];
-    ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(),
-        EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
-    if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
-    {
-      asio::error_code ec(errno,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "kqueue interrupter registration");
-    }
-
-    // Re-register all descriptors with kqueue.
-    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-    for (descriptor_state* state = registered_descriptors_.first();
-        state != 0; state = state->next_)
-    {
-      if (state->num_kevents_ > 0)
-      {
-        ASIO_KQUEUE_EV_SET(&events[0], state->descriptor_,
-            EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state);
-        ASIO_KQUEUE_EV_SET(&events[1], state->descriptor_,
-            EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state);
-        if (::kevent(kqueue_fd_, events, state->num_kevents_, 0, 0, 0) == -1)
-        {
-          asio::error_code ec(errno,
-              asio::error::get_system_category());
-          asio::detail::throw_error(ec, "kqueue re-registration");
-        }
-      }
-    }
-  }
-}
-
-void kqueue_reactor::init_task()
-{
-  scheduler_.init_task();
-}
-
-int kqueue_reactor::register_descriptor(socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  descriptor_data = allocate_descriptor_state();
-
-  ASIO_HANDLER_REACTOR_REGISTRATION((
-        context(), static_cast<uintmax_t>(descriptor),
-        reinterpret_cast<uintmax_t>(descriptor_data)));
-
-  mutex::scoped_lock lock(descriptor_data->mutex_);
-
-  descriptor_data->descriptor_ = descriptor;
-  descriptor_data->num_kevents_ = 0;
-  descriptor_data->shutdown_ = false;
-
-  return 0;
-}
-
-int kqueue_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
-{
-  descriptor_data = allocate_descriptor_state();
-
-  ASIO_HANDLER_REACTOR_REGISTRATION((
-        context(), static_cast<uintmax_t>(descriptor),
-        reinterpret_cast<uintmax_t>(descriptor_data)));
-
-  mutex::scoped_lock lock(descriptor_data->mutex_);
-
-  descriptor_data->descriptor_ = descriptor;
-  descriptor_data->num_kevents_ = 1;
-  descriptor_data->shutdown_ = false;
-  descriptor_data->op_queue_[op_type].push(op);
-
-  struct kevent events[1];
-  ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
-      EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-  if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
-    return errno;
-
-  return 0;
-}
-
-void kqueue_reactor::move_descriptor(socket_type,
-    kqueue_reactor::per_descriptor_data& target_descriptor_data,
-    kqueue_reactor::per_descriptor_data& source_descriptor_data)
-{
-  target_descriptor_data = source_descriptor_data;
-  source_descriptor_data = 0;
-}
-
-void kqueue_reactor::call_post_immediate_completion(
-    operation* op, bool is_continuation, const void* self)
-{
-  static_cast<const kqueue_reactor*>(self)->post_immediate_completion(
-      op, is_continuation);
-}
-
-void kqueue_reactor::start_op(int op_type, socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
-    bool is_continuation, bool allow_speculative,
-    void (*on_immediate)(operation*, bool, const void*),
-    const void* immediate_arg)
-{
-  if (!descriptor_data)
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (descriptor_data->shutdown_)
-  {
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  if (descriptor_data->op_queue_[op_type].empty())
-  {
-    static const int num_kevents[max_ops] = { 1, 2, 1 };
-
-    if (allow_speculative
-        && (op_type != read_op
-          || descriptor_data->op_queue_[except_op].empty()))
-    {
-      if (op->perform())
-      {
-        descriptor_lock.unlock();
-        on_immediate(op, is_continuation, immediate_arg);
-        return;
-      }
-
-      if (descriptor_data->num_kevents_ < num_kevents[op_type])
-      {
-        struct kevent events[2];
-        ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
-            EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-        ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
-            EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-        if (::kevent(kqueue_fd_, events, num_kevents[op_type], 0, 0, 0) != -1)
-        {
-          descriptor_data->num_kevents_ = num_kevents[op_type];
-        }
-        else
-        {
-          op->ec_ = asio::error_code(errno,
-              asio::error::get_system_category());
-          on_immediate(op, is_continuation, immediate_arg);
-          return;
-        }
-      }
-    }
-    else
-    {
-      if (descriptor_data->num_kevents_ < num_kevents[op_type])
-        descriptor_data->num_kevents_ = num_kevents[op_type];
-
-      struct kevent events[2];
-      ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
-          EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-      ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
-          EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-      ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
-    }
-  }
-
-  descriptor_data->op_queue_[op_type].push(op);
-  scheduler_.work_started();
-}
-
-void kqueue_reactor::cancel_ops(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
-    }
-  }
-
-  descriptor_lock.unlock();
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void kqueue_reactor::cancel_ops_by_key(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data,
-    int op_type, void* cancellation_key)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  op_queue<reactor_op> other_ops;
-  while (reactor_op* op = descriptor_data->op_queue_[op_type].front())
-  {
-    descriptor_data->op_queue_[op_type].pop();
-    if (op->cancellation_key_ == cancellation_key)
-    {
-      op->ec_ = asio::error::operation_aborted;
-      ops.push(op);
-    }
-    else
-      other_ops.push(op);
-  }
-  descriptor_data->op_queue_[op_type].push(other_ops);
-
-  descriptor_lock.unlock();
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void kqueue_reactor::deregister_descriptor(socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data, bool closing)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    if (closing)
-    {
-      // The descriptor will be automatically removed from the kqueue when it
-      // is closed.
-    }
-    else
-    {
-      struct kevent events[2];
-      ASIO_KQUEUE_EV_SET(&events[0], descriptor,
-          EVFILT_READ, EV_DELETE, 0, 0, 0);
-      ASIO_KQUEUE_EV_SET(&events[1], descriptor,
-          EVFILT_WRITE, EV_DELETE, 0, 0, 0);
-      ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
-    }
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-    {
-      while (reactor_op* op = descriptor_data->op_queue_[i].front())
-      {
-        op->ec_ = asio::error::operation_aborted;
-        descriptor_data->op_queue_[i].pop();
-        ops.push(op);
-      }
-    }
-
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    ASIO_HANDLER_REACTOR_DEREGISTRATION((
-          context(), static_cast<uintmax_t>(descriptor),
-          reinterpret_cast<uintmax_t>(descriptor_data)));
-
-    scheduler_.post_deferred_completions(ops);
-
-    // Leave descriptor_data set so that it will be freed by the subsequent
-    // call to cleanup_descriptor_data.
-  }
-  else
-  {
-    // We are shutting down, so prevent cleanup_descriptor_data from freeing
-    // the descriptor_data object and let the destructor free it instead.
-    descriptor_data = 0;
-  }
-}
-
-void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    struct kevent events[2];
-    ASIO_KQUEUE_EV_SET(&events[0], descriptor,
-        EVFILT_READ, EV_DELETE, 0, 0, 0);
-    ASIO_KQUEUE_EV_SET(&events[1], descriptor,
-        EVFILT_WRITE, EV_DELETE, 0, 0, 0);
-    ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(descriptor_data->op_queue_[i]);
-
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    ASIO_HANDLER_REACTOR_DEREGISTRATION((
-          context(), static_cast<uintmax_t>(descriptor),
-          reinterpret_cast<uintmax_t>(descriptor_data)));
-
-    // Leave descriptor_data set so that it will be freed by the subsequent
-    // call to cleanup_descriptor_data.
-  }
-  else
-  {
-    // We are shutting down, so prevent cleanup_descriptor_data from freeing
-    // the descriptor_data object and let the destructor free it instead.
-    descriptor_data = 0;
-  }
-}
-
-void kqueue_reactor::cleanup_descriptor_data(
-    per_descriptor_data& descriptor_data)
-{
-  if (descriptor_data)
-  {
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
-  }
-}
-
-void kqueue_reactor::run(long usec, op_queue<operation>& ops)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Determine how long to block while waiting for events.
-  timespec timeout_buf = { 0, 0 };
-  timespec* timeout = usec ? get_timeout(usec, timeout_buf) : &timeout_buf;
-
-  lock.unlock();
-
-  // Block on the kqueue descriptor.
-  struct kevent events[128];
-  int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-  // Trace the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    void* ptr = reinterpret_cast<void*>(events[i].udata);
-    if (ptr != &interrupter_)
-    {
-      unsigned event_mask = 0;
-      switch (events[i].filter)
-      {
-      case EVFILT_READ:
-        event_mask |= ASIO_HANDLER_REACTOR_READ_EVENT;
-        break;
-      case EVFILT_WRITE:
-        event_mask |= ASIO_HANDLER_REACTOR_WRITE_EVENT;
-        break;
-      }
-      if ((events[i].flags & (EV_ERROR | EV_OOBAND)) != 0)
-        event_mask |= ASIO_HANDLER_REACTOR_ERROR_EVENT;
-      ASIO_HANDLER_REACTOR_EVENTS((context(),
-            reinterpret_cast<uintmax_t>(ptr), event_mask));
-    }
-  }
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    void* ptr = reinterpret_cast<void*>(events[i].udata);
-    if (ptr == &interrupter_)
-    {
-      interrupter_.reset();
-    }
-    else
-    {
-      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-      if (events[i].filter == EVFILT_WRITE
-          && descriptor_data->num_kevents_ == 2
-          && descriptor_data->op_queue_[write_op].empty())
-      {
-        // Some descriptor types, like serial ports, don't seem to support
-        // EV_CLEAR with EVFILT_WRITE. Since we have no pending write
-        // operations we'll remove the EVFILT_WRITE registration here so that
-        // we don't end up in a tight spin.
-        struct kevent delete_events[1];
-        ASIO_KQUEUE_EV_SET(&delete_events[0],
-            descriptor_data->descriptor_, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
-        ::kevent(kqueue_fd_, delete_events, 1, 0, 0, 0);
-        descriptor_data->num_kevents_ = 1;
-      }
-
-      // Exception operations must be processed first to ensure that any
-      // out-of-band data is read before normal data.
-#if defined(__NetBSD__)
-      static const unsigned int filter[max_ops] =
-#else
-      static const int filter[max_ops] =
-#endif
-        { EVFILT_READ, EVFILT_WRITE, EVFILT_READ };
-      for (int j = max_ops - 1; j >= 0; --j)
-      {
-        if (events[i].filter == filter[j])
-        {
-          if (j != except_op || events[i].flags & EV_OOBAND)
-          {
-            while (reactor_op* op = descriptor_data->op_queue_[j].front())
-            {
-              if (events[i].flags & EV_ERROR)
-              {
-                op->ec_ = asio::error_code(
-                    static_cast<int>(events[i].data),
-                    asio::error::get_system_category());
-                descriptor_data->op_queue_[j].pop();
-                ops.push(op);
-              }
-              if (op->perform())
-              {
-                descriptor_data->op_queue_[j].pop();
-                ops.push(op);
-              }
-              else
-                break;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  lock.lock();
-  timer_queues_.get_ready_timers(ops);
-}
-
-void kqueue_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-
-int kqueue_reactor::do_kqueue_create()
-{
-  int fd = ::kqueue();
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "kqueue");
-  }
-  return fd;
-}
-
-kqueue_reactor::descriptor_state* kqueue_reactor::allocate_descriptor_state()
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-        REACTOR_IO, scheduler_.concurrency_hint()));
-}
-
-void kqueue_reactor::free_descriptor_state(kqueue_reactor::descriptor_state* s)
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  registered_descriptors_.free(s);
-}
-
-void kqueue_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-timespec* kqueue_reactor::get_timeout(long usec, timespec& ts)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  const long max_usec = 5 * 60 * 1000 * 1000;
-  usec = timer_queues_.wait_duration_usec(
-      (usec < 0 || max_usec < usec) ? max_usec : usec);
-  ts.tv_sec = usec / 1000000;
-  ts.tv_nsec = (usec % 1000000) * 1000;
-  return &ts;
-}
-
-} // namespace detail
-} // namespace asio
-
-#undef ASIO_KQUEUE_EV_SET
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_KQUEUE)
-
-#endif // ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/null_event.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/null_event.ipp
deleted file mode 100644
index 1c9f568..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/null_event.ipp
+++ /dev/null
@@ -1,74 +0,0 @@
-//
-// detail/impl/null_event.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_NULL_EVENT_IPP
-#define ASIO_DETAIL_IMPL_NULL_EVENT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include <thread>
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/socket_types.hpp"
-#else
-# include <unistd.h>
-# if defined(__hpux)
-#  include <sys/time.h>
-# endif
-# if !defined(__hpux) || defined(__SELECT)
-#  include <sys/select.h>
-# endif
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void null_event::do_wait()
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  std::this_thread::sleep_until((std::chrono::steady_clock::time_point::max)());
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  ::Sleep(INFINITE);
-#else
-  ::pause();
-#endif
-}
-
-void null_event::do_wait_for_usec(long usec)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  std::this_thread::sleep_for(std::chrono::microseconds(usec));
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  ::Sleep(usec / 1000);
-#elif defined(__hpux) && defined(__SELECT)
-  timespec ts;
-  ts.tv_sec = usec / 1000000;
-  ts.tv_nsec = (usec % 1000000) * 1000;
-  ::pselect(0, 0, 0, 0, &ts, 0);
-#else
-  timeval tv;
-  tv.tv_sec = usec / 1000000;
-  tv.tv_usec = usec % 1000000;
-  ::select(0, 0, 0, 0, &tv);
-#endif
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_NULL_EVENT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/pipe_select_interrupter.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/pipe_select_interrupter.ipp
deleted file mode 100644
index 7513831..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/pipe_select_interrupter.ipp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// detail/impl/pipe_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-#if !defined(ASIO_WINDOWS)
-#if !defined(__CYGWIN__)
-#if !defined(__SYMBIAN32__)
-#if !defined(ASIO_HAS_EVENTFD)
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include "asio/detail/pipe_select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-pipe_select_interrupter::pipe_select_interrupter()
-{
-  open_descriptors();
-}
-
-void pipe_select_interrupter::open_descriptors()
-{
-  int pipe_fds[2];
-  if (pipe(pipe_fds) == 0)
-  {
-    read_descriptor_ = pipe_fds[0];
-    ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-    write_descriptor_ = pipe_fds[1];
-    ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-
-#if defined(FD_CLOEXEC)
-    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-    ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
-#endif // defined(FD_CLOEXEC)
-  }
-  else
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "pipe_select_interrupter");
-  }
-}
-
-pipe_select_interrupter::~pipe_select_interrupter()
-{
-  close_descriptors();
-}
-
-void pipe_select_interrupter::close_descriptors()
-{
-  if (read_descriptor_ != -1)
-    ::close(read_descriptor_);
-  if (write_descriptor_ != -1)
-    ::close(write_descriptor_);
-}
-
-void pipe_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = -1;
-  read_descriptor_ = -1;
-
-  open_descriptors();
-}
-
-void pipe_select_interrupter::interrupt()
-{
-  char byte = 0;
-  signed_size_type result = ::write(write_descriptor_, &byte, 1);
-  (void)result;
-}
-
-bool pipe_select_interrupter::reset()
-{
-  for (;;)
-  {
-    char data[1024];
-    signed_size_type bytes_read = ::read(read_descriptor_, data, sizeof(data));
-    if (bytes_read == sizeof(data))
-      continue;
-    if (bytes_read > 0)
-      return true;
-    if (bytes_read == 0)
-      return false;
-    if (errno == EINTR)
-      continue;
-    if (errno == EWOULDBLOCK || errno == EAGAIN)
-      return true;
-    return false;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_EVENTFD)
-#endif // !defined(__SYMBIAN32__)
-#endif // !defined(__CYGWIN__)
-#endif // !defined(ASIO_WINDOWS)
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_event.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_event.ipp
deleted file mode 100644
index 76d5c46..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_event.ipp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// detail/impl/posix_event.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
-#define ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include "asio/detail/posix_event.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_event::posix_event()
-  : state_(0)
-{
-#if (defined(__MACH__) && defined(__APPLE__)) \
-      || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
-  int error = ::pthread_cond_init(&cond_, 0);
-#else // (defined(__MACH__) && defined(__APPLE__))
-      // || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
-  ::pthread_condattr_t attr;
-  int error = ::pthread_condattr_init(&attr);
-  if (error == 0)
-  {
-    error = ::pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
-    if (error == 0)
-      error = ::pthread_cond_init(&cond_, &attr);
-    ::pthread_condattr_destroy(&attr);
-  }
-#endif // (defined(__MACH__) && defined(__APPLE__))
-       // || (defined(__ANDROID__) && (__ANDROID_API__ < 21))
-
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "event");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_mutex.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_mutex.ipp
deleted file mode 100644
index 5fd832f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_mutex.ipp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// detail/impl/posix_mutex.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
-#define ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include "asio/detail/posix_mutex.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_mutex::posix_mutex()
-{
-  int error = ::pthread_mutex_init(&mutex_, 0);
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "mutex");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_serial_port_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_serial_port_service.ipp
deleted file mode 100644
index 98ed582..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_serial_port_service.ipp
+++ /dev/null
@@ -1,168 +0,0 @@
-//
-// detail/impl/posix_serial_port_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT)
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include <cstring>
-#include "asio/detail/posix_serial_port_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_serial_port_service::posix_serial_port_service(
-    execution_context& context)
-  : execution_context_service_base<posix_serial_port_service>(context),
-    descriptor_service_(context)
-{
-}
-
-void posix_serial_port_service::shutdown()
-{
-  descriptor_service_.shutdown();
-}
-
-asio::error_code posix_serial_port_service::open(
-    posix_serial_port_service::implementation_type& impl,
-    const std::string& device, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  descriptor_ops::state_type state = 0;
-  int fd = descriptor_ops::open(device.c_str(),
-      O_RDWR | O_NONBLOCK | O_NOCTTY, ec);
-  if (fd < 0)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  int s = descriptor_ops::fcntl(fd, F_GETFL, ec);
-  if (s >= 0)
-    s = descriptor_ops::fcntl(fd, F_SETFL, s | O_NONBLOCK, ec);
-  if (s < 0)
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set up default serial port options.
-  termios ios;
-  s = ::tcgetattr(fd, &ios);
-  descriptor_ops::get_last_error(ec, s < 0);
-  if (s >= 0)
-  {
-#if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-    ::cfmakeraw(&ios);
-#else
-    ios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK
-        | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
-    ios.c_oflag &= ~OPOST;
-    ios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-    ios.c_cflag &= ~(CSIZE | PARENB);
-    ios.c_cflag |= CS8;
-#endif
-    ios.c_iflag |= IGNPAR;
-    ios.c_cflag |= CREAD | CLOCAL;
-    s = ::tcsetattr(fd, TCSANOW, &ios);
-    descriptor_ops::get_last_error(ec, s < 0);
-  }
-  if (s < 0)
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // We're done. Take ownership of the serial port descriptor.
-  if (descriptor_service_.assign(impl, fd, ec))
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-  }
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-asio::error_code posix_serial_port_service::do_set_option(
-    posix_serial_port_service::implementation_type& impl,
-    posix_serial_port_service::store_function_type store,
-    const void* option, asio::error_code& ec)
-{
-  termios ios;
-  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
-  descriptor_ops::get_last_error(ec, s < 0);
-  if (s < 0)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  if (store(option, ios, ec))
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  s = ::tcsetattr(descriptor_service_.native_handle(impl), TCSANOW, &ios);
-  descriptor_ops::get_last_error(ec, s < 0);
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-asio::error_code posix_serial_port_service::do_get_option(
-    const posix_serial_port_service::implementation_type& impl,
-    posix_serial_port_service::load_function_type load,
-    void* option, asio::error_code& ec) const
-{
-  termios ios;
-  int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios);
-  descriptor_ops::get_last_error(ec, s < 0);
-  if (s < 0)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  load(option, ios, ec);
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_SERIAL_PORT_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_thread.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_thread.ipp
deleted file mode 100644
index 7602377..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_thread.ipp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// detail/impl/posix_thread.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
-#define ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include "asio/detail/posix_thread.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_thread::~posix_thread()
-{
-  if (!joined_)
-    ::pthread_detach(thread_);
-}
-
-void posix_thread::join()
-{
-  if (!joined_)
-  {
-    ::pthread_join(thread_, 0);
-    joined_ = true;
-  }
-}
-
-std::size_t posix_thread::hardware_concurrency()
-{
-#if defined(_SC_NPROCESSORS_ONLN)
-  long result = sysconf(_SC_NPROCESSORS_ONLN);
-  if (result > 0)
-    return result;
-#endif // defined(_SC_NPROCESSORS_ONLN)
-  return 0;
-}
-
-void posix_thread::start_thread(func_base* arg)
-{
-  int error = ::pthread_create(&thread_, 0,
-        asio_detail_posix_thread_function, arg);
-  if (error != 0)
-  {
-    delete arg;
-    asio::error_code ec(error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "thread");
-  }
-}
-
-void* asio_detail_posix_thread_function(void* arg)
-{
-  posix_thread::auto_func_base_ptr func = {
-      static_cast<posix_thread::func_base*>(arg) };
-  func.ptr->run();
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_tss_ptr.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_tss_ptr.ipp
deleted file mode 100644
index 099274b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/posix_tss_ptr.ipp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// detail/impl/posix_tss_ptr.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
-#define ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include "asio/detail/posix_tss_ptr.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void posix_tss_ptr_create(pthread_key_t& key)
-{
-  int error = ::pthread_key_create(&key, 0);
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "tss");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_descriptor_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_descriptor_service.ipp
deleted file mode 100644
index b3a1400..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_descriptor_service.ipp
+++ /dev/null
@@ -1,232 +0,0 @@
-//
-// detail/impl/reactive_descriptor_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__) \
-  && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/error.hpp"
-#include "asio/detail/reactive_descriptor_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-reactive_descriptor_service::reactive_descriptor_service(
-    execution_context& context)
-  : execution_context_service_base<reactive_descriptor_service>(context),
-    reactor_(asio::use_service<reactor>(context))
-{
-  reactor_.init_task();
-}
-
-void reactive_descriptor_service::shutdown()
-{
-}
-
-void reactive_descriptor_service::construct(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  impl.descriptor_ = -1;
-  impl.state_ = 0;
-  impl.reactor_data_ = reactor::per_descriptor_data();
-}
-
-void reactive_descriptor_service::move_construct(
-    reactive_descriptor_service::implementation_type& impl,
-    reactive_descriptor_service::implementation_type& other_impl)
-  noexcept
-{
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  reactor_.move_descriptor(impl.descriptor_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_descriptor_service::move_assign(
-    reactive_descriptor_service::implementation_type& impl,
-    reactive_descriptor_service& other_service,
-    reactive_descriptor_service::implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  other_service.reactor_.move_descriptor(impl.descriptor_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_descriptor_service::destroy(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((reactor_.context(),
-          "descriptor", &impl, impl.descriptor_, "close"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
-        (impl.state_ & descriptor_ops::possible_dup) == 0);
-
-    asio::error_code ignored_ec;
-    descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
-
-    reactor_.cleanup_descriptor_data(impl.reactor_data_);
-  }
-}
-
-asio::error_code reactive_descriptor_service::assign(
-    reactive_descriptor_service::implementation_type& impl,
-    const native_handle_type& native_descriptor, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  if (int err = reactor_.register_descriptor(
-        native_descriptor, impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  impl.descriptor_ = native_descriptor;
-  impl.state_ = descriptor_ops::possible_dup;
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_descriptor_service::close(
-    reactive_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((reactor_.context(),
-          "descriptor", &impl, impl.descriptor_, "close"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
-        (impl.state_ & descriptor_ops::possible_dup) == 0);
-
-    descriptor_ops::close(impl.descriptor_, impl.state_, ec);
-
-    reactor_.cleanup_descriptor_data(impl.reactor_data_);
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  // We'll just have to assume that other OSes follow the same behaviour.)
-  construct(impl);
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-reactive_descriptor_service::native_handle_type
-reactive_descriptor_service::release(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  native_handle_type descriptor = impl.descriptor_;
-
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((reactor_.context(),
-          "descriptor", &impl, impl.descriptor_, "release"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
-    reactor_.cleanup_descriptor_data(impl.reactor_data_);
-    construct(impl);
-  }
-
-  return descriptor;
-}
-
-asio::error_code reactive_descriptor_service::cancel(
-    reactive_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((reactor_.context(),
-        "descriptor", &impl, impl.descriptor_, "cancel"));
-
-  reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
-  ec = asio::error_code();
-  return ec;
-}
-
-void reactive_descriptor_service::do_start_op(implementation_type& impl,
-    int op_type, reactor_op* op, bool is_continuation,
-    bool allow_speculative, bool noop, bool needs_non_blocking,
-    void (*on_immediate)(operation* op, bool, const void*),
-    const void* immediate_arg)
-{
-  if (!noop)
-  {
-    if ((impl.state_ & descriptor_ops::non_blocking)
-        || !needs_non_blocking
-        || descriptor_ops::set_internal_non_blocking(
-          impl.descriptor_, impl.state_, true, op->ec_))
-    {
-      reactor_.start_op(op_type, impl.descriptor_, impl.reactor_data_, op,
-          is_continuation, allow_speculative, on_immediate, immediate_arg);
-      return;
-    }
-  }
-
-  on_immediate(op, is_continuation, immediate_arg);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-       //   && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_socket_service_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_socket_service_base.ipp
deleted file mode 100644
index bbd27e0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/reactive_socket_service_base.ipp
+++ /dev/null
@@ -1,312 +0,0 @@
-//
-// detail/reactive_socket_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_IOCP) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/reactive_socket_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-reactive_socket_service_base::reactive_socket_service_base(
-    execution_context& context)
-  : reactor_(use_service<reactor>(context))
-{
-  reactor_.init_task();
-}
-
-void reactive_socket_service_base::base_shutdown()
-{
-}
-
-void reactive_socket_service_base::construct(
-    reactive_socket_service_base::base_implementation_type& impl)
-{
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.reactor_data_ = reactor::per_descriptor_data();
-}
-
-void reactive_socket_service_base::base_move_construct(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactive_socket_service_base::base_implementation_type& other_impl)
-  noexcept
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  reactor_.move_descriptor(impl.socket_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_socket_service_base::base_move_assign(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactive_socket_service_base& other_service,
-    reactive_socket_service_base::base_implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  other_service.reactor_.move_descriptor(impl.socket_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_socket_service_base::destroy(
-    reactive_socket_service_base::base_implementation_type& impl)
-{
-  if (impl.socket_ != invalid_socket)
-  {
-    ASIO_HANDLER_OPERATION((reactor_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
-        (impl.state_ & socket_ops::possible_dup) == 0);
-
-    asio::error_code ignored_ec;
-    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
-
-    reactor_.cleanup_descriptor_data(impl.reactor_data_);
-  }
-}
-
-asio::error_code reactive_socket_service_base::close(
-    reactive_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((reactor_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
-        (impl.state_ & socket_ops::possible_dup) == 0);
-
-    socket_ops::close(impl.socket_, impl.state_, false, ec);
-
-    reactor_.cleanup_descriptor_data(impl.reactor_data_);
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  // We'll just have to assume that other OSes follow the same behaviour. The
-  // known exception is when Windows's closesocket() function fails with
-  // WSAEWOULDBLOCK, but this case is handled inside socket_ops::close().
-  construct(impl);
-
-  return ec;
-}
-
-socket_type reactive_socket_service_base::release(
-    reactive_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return invalid_socket;
-  }
-
-  ASIO_HANDLER_OPERATION((reactor_.context(),
-        "socket", &impl, impl.socket_, "release"));
-
-  reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, false);
-  reactor_.cleanup_descriptor_data(impl.reactor_data_);
-  socket_type sock = impl.socket_;
-  construct(impl);
-  ec = asio::error_code();
-  return sock;
-}
-
-asio::error_code reactive_socket_service_base::cancel(
-    reactive_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((reactor_.context(),
-        "socket", &impl, impl.socket_, "cancel"));
-
-  reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_socket_service_base::do_open(
-    reactive_socket_service_base::base_implementation_type& impl,
-    int af, int type, int protocol, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  socket_holder sock(socket_ops::socket(af, type, protocol, ec));
-  if (sock.get() == invalid_socket)
-    return ec;
-
-  if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  impl.socket_ = sock.release();
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_socket_service_base::do_assign(
-    reactive_socket_service_base::base_implementation_type& impl, int type,
-    const reactive_socket_service_base::native_handle_type& native_socket,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  if (int err = reactor_.register_descriptor(
-        native_socket, impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  impl.socket_ = native_socket;
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  impl.state_ |= socket_ops::possible_dup;
-  ec = asio::error_code();
-  return ec;
-}
-
-void reactive_socket_service_base::do_start_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    int op_type, reactor_op* op, bool is_continuation,
-    bool allow_speculative, bool noop, bool needs_non_blocking,
-    void (*on_immediate)(operation* op, bool, const void*),
-    const void* immediate_arg)
-{
-  if (!noop)
-  {
-    if ((impl.state_ & socket_ops::non_blocking)
-        || !needs_non_blocking
-        || socket_ops::set_internal_non_blocking(
-          impl.socket_, impl.state_, true, op->ec_))
-    {
-      reactor_.start_op(op_type, impl.socket_, impl.reactor_data_, op,
-          is_continuation, allow_speculative, on_immediate, immediate_arg);
-      return;
-    }
-  }
-
-  on_immediate(op, is_continuation, immediate_arg);
-}
-
-void reactive_socket_service_base::do_start_accept_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, bool is_continuation, bool peer_is_open,
-    void (*on_immediate)(operation* op, bool, const void*),
-    const void* immediate_arg)
-{
-  if (!peer_is_open)
-  {
-    do_start_op(impl, reactor::read_op, op, is_continuation,
-        true, false, true, on_immediate, immediate_arg);
-  }
-  else
-  {
-    op->ec_ = asio::error::already_open;
-    on_immediate(op, is_continuation, immediate_arg);
-  }
-}
-
-void reactive_socket_service_base::do_start_connect_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, bool is_continuation, const void* addr, size_t addrlen,
-    void (*on_immediate)(operation* op, bool, const void*),
-    const void* immediate_arg)
-{
-  if ((impl.state_ & socket_ops::non_blocking)
-      || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, true, op->ec_))
-  {
-    if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
-    {
-      if (op->ec_ == asio::error::in_progress
-          || op->ec_ == asio::error::would_block)
-      {
-        op->ec_ = asio::error_code();
-        reactor_.start_op(reactor::connect_op, impl.socket_, impl.reactor_data_,
-            op, is_continuation, false, on_immediate, immediate_arg);
-        return;
-      }
-    }
-  }
-
-  on_immediate(op, is_continuation, immediate_arg);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_IOCP)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/resolver_service_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/resolver_service_base.ipp
deleted file mode 100644
index 8d9e944..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/resolver_service_base.ipp
+++ /dev/null
@@ -1,158 +0,0 @@
-//
-// detail/impl/resolver_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/resolver_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class resolver_service_base::work_scheduler_runner
-{
-public:
-  work_scheduler_runner(scheduler_impl& work_scheduler)
-    : work_scheduler_(work_scheduler)
-  {
-  }
-
-  void operator()()
-  {
-    asio::error_code ec;
-    work_scheduler_.run(ec);
-  }
-
-private:
-  scheduler_impl& work_scheduler_;
-};
-
-resolver_service_base::resolver_service_base(execution_context& context)
-  : scheduler_(asio::use_service<scheduler_impl>(context)),
-    work_scheduler_(new scheduler_impl(context, -1, false)),
-    work_thread_(0)
-{
-  work_scheduler_->work_started();
-}
-
-resolver_service_base::~resolver_service_base()
-{
-  base_shutdown();
-}
-
-void resolver_service_base::base_shutdown()
-{
-  if (work_scheduler_.get())
-  {
-    work_scheduler_->work_finished();
-    work_scheduler_->stop();
-    if (work_thread_.get())
-    {
-      work_thread_->join();
-      work_thread_.reset();
-    }
-    work_scheduler_.reset();
-  }
-}
-
-void resolver_service_base::base_notify_fork(
-    execution_context::fork_event fork_ev)
-{
-  if (work_thread_.get())
-  {
-    if (fork_ev == execution_context::fork_prepare)
-    {
-      work_scheduler_->stop();
-      work_thread_->join();
-      work_thread_.reset();
-    }
-  }
-  else if (fork_ev != execution_context::fork_prepare)
-  {
-    work_scheduler_->restart();
-  }
-}
-
-void resolver_service_base::construct(
-    resolver_service_base::implementation_type& impl)
-{
-  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-}
-
-void resolver_service_base::destroy(
-    resolver_service_base::implementation_type& impl)
-{
-  ASIO_HANDLER_OPERATION((scheduler_.context(),
-        "resolver", &impl, 0, "cancel"));
-
-  impl.reset();
-}
-
-void resolver_service_base::move_construct(implementation_type& impl,
-    implementation_type& other_impl)
-{
-  impl = static_cast<implementation_type&&>(other_impl);
-}
-
-void resolver_service_base::move_assign(implementation_type& impl,
-    resolver_service_base&, implementation_type& other_impl)
-{
-  destroy(impl);
-  impl = static_cast<implementation_type&&>(other_impl);
-}
-
-void resolver_service_base::cancel(
-    resolver_service_base::implementation_type& impl)
-{
-  ASIO_HANDLER_OPERATION((scheduler_.context(),
-        "resolver", &impl, 0, "cancel"));
-
-  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-}
-
-void resolver_service_base::start_resolve_op(resolve_op* op)
-{
-  if (ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
-        scheduler_.concurrency_hint()))
-  {
-    start_work_thread();
-    scheduler_.work_started();
-    work_scheduler_->post_immediate_completion(op, false);
-  }
-  else
-  {
-    op->ec_ = asio::error::operation_not_supported;
-    scheduler_.post_immediate_completion(op, false);
-  }
-}
-
-void resolver_service_base::start_work_thread()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!work_thread_.get())
-  {
-    work_thread_.reset(new asio::detail::thread(
-          work_scheduler_runner(*work_scheduler_)));
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/scheduler.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/scheduler.ipp
deleted file mode 100644
index eccc803..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/scheduler.ipp
+++ /dev/null
@@ -1,675 +0,0 @@
-//
-// detail/impl/scheduler.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SCHEDULER_IPP
-#define ASIO_DETAIL_IMPL_SCHEDULER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/concurrency_hint.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/scheduler_thread_info.hpp"
-#include "asio/detail/signal_blocker.hpp"
-
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_service.hpp"
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/reactor.hpp"
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class scheduler::thread_function
-{
-public:
-  explicit thread_function(scheduler* s)
-    : this_(s)
-  {
-  }
-
-  void operator()()
-  {
-    asio::error_code ec;
-    this_->run(ec);
-  }
-
-private:
-  scheduler* this_;
-};
-
-struct scheduler::task_cleanup
-{
-  ~task_cleanup()
-  {
-    if (this_thread_->private_outstanding_work > 0)
-    {
-      asio::detail::increment(
-          scheduler_->outstanding_work_,
-          this_thread_->private_outstanding_work);
-    }
-    this_thread_->private_outstanding_work = 0;
-
-    // Enqueue the completed operations and reinsert the task at the end of
-    // the operation queue.
-    lock_->lock();
-    scheduler_->task_interrupted_ = true;
-    scheduler_->op_queue_.push(this_thread_->private_op_queue);
-    scheduler_->op_queue_.push(&scheduler_->task_operation_);
-  }
-
-  scheduler* scheduler_;
-  mutex::scoped_lock* lock_;
-  thread_info* this_thread_;
-};
-
-struct scheduler::work_cleanup
-{
-  ~work_cleanup()
-  {
-    if (this_thread_->private_outstanding_work > 1)
-    {
-      asio::detail::increment(
-          scheduler_->outstanding_work_,
-          this_thread_->private_outstanding_work - 1);
-    }
-    else if (this_thread_->private_outstanding_work < 1)
-    {
-      scheduler_->work_finished();
-    }
-    this_thread_->private_outstanding_work = 0;
-
-#if defined(ASIO_HAS_THREADS)
-    if (!this_thread_->private_op_queue.empty())
-    {
-      lock_->lock();
-      scheduler_->op_queue_.push(this_thread_->private_op_queue);
-    }
-#endif // defined(ASIO_HAS_THREADS)
-  }
-
-  scheduler* scheduler_;
-  mutex::scoped_lock* lock_;
-  thread_info* this_thread_;
-};
-
-scheduler::scheduler(asio::execution_context& ctx,
-    int concurrency_hint, bool own_thread, get_task_func_type get_task)
-  : asio::detail::execution_context_service_base<scheduler>(ctx),
-    one_thread_(concurrency_hint == 1
-        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          SCHEDULER, concurrency_hint)
-        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          REACTOR_IO, concurrency_hint)),
-    mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
-          SCHEDULER, concurrency_hint)),
-    task_(0),
-    get_task_(get_task),
-    task_interrupted_(true),
-    outstanding_work_(0),
-    stopped_(false),
-    shutdown_(false),
-    concurrency_hint_(concurrency_hint),
-    thread_(0)
-{
-  ASIO_HANDLER_TRACKING_INIT;
-
-  if (own_thread)
-  {
-    ++outstanding_work_;
-    asio::detail::signal_blocker sb;
-    thread_ = new asio::detail::thread(thread_function(this));
-  }
-}
-
-scheduler::~scheduler()
-{
-  if (thread_)
-  {
-    mutex::scoped_lock lock(mutex_);
-    shutdown_ = true;
-    stop_all_threads(lock);
-    lock.unlock();
-    thread_->join();
-    delete thread_;
-  }
-}
-
-void scheduler::shutdown()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  if (thread_)
-    stop_all_threads(lock);
-  lock.unlock();
-
-  // Join thread to ensure task operation is returned to queue.
-  if (thread_)
-  {
-    thread_->join();
-    delete thread_;
-    thread_ = 0;
-  }
-
-  // Destroy handler objects.
-  while (!op_queue_.empty())
-  {
-    operation* o = op_queue_.front();
-    op_queue_.pop();
-    if (o != &task_operation_)
-      o->destroy();
-  }
-
-  // Reset to initial state.
-  task_ = 0;
-}
-
-void scheduler::init_task()
-{
-  mutex::scoped_lock lock(mutex_);
-  if (!shutdown_ && !task_)
-  {
-    task_ = get_task_(this->context());
-    op_queue_.push(&task_operation_);
-    wake_one_thread_and_unlock(lock);
-  }
-}
-
-std::size_t scheduler::run(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  thread_info this_thread;
-  this_thread.private_outstanding_work = 0;
-  thread_call_stack::context ctx(this, this_thread);
-
-  mutex::scoped_lock lock(mutex_);
-
-  std::size_t n = 0;
-  for (; do_run_one(lock, this_thread, ec); lock.lock())
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-
-std::size_t scheduler::run_one(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  thread_info this_thread;
-  this_thread.private_outstanding_work = 0;
-  thread_call_stack::context ctx(this, this_thread);
-
-  mutex::scoped_lock lock(mutex_);
-
-  return do_run_one(lock, this_thread, ec);
-}
-
-std::size_t scheduler::wait_one(long usec, asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  thread_info this_thread;
-  this_thread.private_outstanding_work = 0;
-  thread_call_stack::context ctx(this, this_thread);
-
-  mutex::scoped_lock lock(mutex_);
-
-  return do_wait_one(lock, this_thread, usec, ec);
-}
-
-std::size_t scheduler::poll(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  thread_info this_thread;
-  this_thread.private_outstanding_work = 0;
-  thread_call_stack::context ctx(this, this_thread);
-
-  mutex::scoped_lock lock(mutex_);
-
-#if defined(ASIO_HAS_THREADS)
-  // We want to support nested calls to poll() and poll_one(), so any handlers
-  // that are already on a thread-private queue need to be put on to the main
-  // queue now.
-  if (one_thread_)
-    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
-      op_queue_.push(outer_info->private_op_queue);
-#endif // defined(ASIO_HAS_THREADS)
-
-  std::size_t n = 0;
-  for (; do_poll_one(lock, this_thread, ec); lock.lock())
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-
-std::size_t scheduler::poll_one(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  thread_info this_thread;
-  this_thread.private_outstanding_work = 0;
-  thread_call_stack::context ctx(this, this_thread);
-
-  mutex::scoped_lock lock(mutex_);
-
-#if defined(ASIO_HAS_THREADS)
-  // We want to support nested calls to poll() and poll_one(), so any handlers
-  // that are already on a thread-private queue need to be put on to the main
-  // queue now.
-  if (one_thread_)
-    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
-      op_queue_.push(outer_info->private_op_queue);
-#endif // defined(ASIO_HAS_THREADS)
-
-  return do_poll_one(lock, this_thread, ec);
-}
-
-void scheduler::stop()
-{
-  mutex::scoped_lock lock(mutex_);
-  stop_all_threads(lock);
-}
-
-bool scheduler::stopped() const
-{
-  mutex::scoped_lock lock(mutex_);
-  return stopped_;
-}
-
-void scheduler::restart()
-{
-  mutex::scoped_lock lock(mutex_);
-  stopped_ = false;
-}
-
-void scheduler::compensating_work_started()
-{
-  thread_info_base* this_thread = thread_call_stack::contains(this);
-  ASIO_ASSUME(this_thread != 0); // Only called from inside scheduler.
-  ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
-}
-
-bool scheduler::can_dispatch()
-{
-  return thread_call_stack::contains(this) != 0;
-}
-
-void scheduler::capture_current_exception()
-{
-  if (thread_info_base* this_thread = thread_call_stack::contains(this))
-    this_thread->capture_current_exception();
-}
-
-void scheduler::post_immediate_completion(
-    scheduler::operation* op, bool is_continuation)
-{
-#if defined(ASIO_HAS_THREADS)
-  if (one_thread_ || is_continuation)
-  {
-    if (thread_info_base* this_thread = thread_call_stack::contains(this))
-    {
-      ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
-      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
-      return;
-    }
-  }
-#else // defined(ASIO_HAS_THREADS)
-  (void)is_continuation;
-#endif // defined(ASIO_HAS_THREADS)
-
-  work_started();
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
-}
-
-void scheduler::post_immediate_completions(std::size_t n,
-    op_queue<scheduler::operation>& ops, bool is_continuation)
-{
-#if defined(ASIO_HAS_THREADS)
-  if (one_thread_ || is_continuation)
-  {
-    if (thread_info_base* this_thread = thread_call_stack::contains(this))
-    {
-      static_cast<thread_info*>(this_thread)->private_outstanding_work
-        += static_cast<long>(n);
-      static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
-      return;
-    }
-  }
-#else // defined(ASIO_HAS_THREADS)
-  (void)is_continuation;
-#endif // defined(ASIO_HAS_THREADS)
-
-  increment(outstanding_work_, static_cast<long>(n));
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(ops);
-  wake_one_thread_and_unlock(lock);
-}
-
-void scheduler::post_deferred_completion(scheduler::operation* op)
-{
-#if defined(ASIO_HAS_THREADS)
-  if (one_thread_)
-  {
-    if (thread_info_base* this_thread = thread_call_stack::contains(this))
-    {
-      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
-      return;
-    }
-  }
-#endif // defined(ASIO_HAS_THREADS)
-
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
-}
-
-void scheduler::post_deferred_completions(
-    op_queue<scheduler::operation>& ops)
-{
-  if (!ops.empty())
-  {
-#if defined(ASIO_HAS_THREADS)
-    if (one_thread_)
-    {
-      if (thread_info_base* this_thread = thread_call_stack::contains(this))
-      {
-        static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
-        return;
-      }
-    }
-#endif // defined(ASIO_HAS_THREADS)
-
-    mutex::scoped_lock lock(mutex_);
-    op_queue_.push(ops);
-    wake_one_thread_and_unlock(lock);
-  }
-}
-
-void scheduler::do_dispatch(
-    scheduler::operation* op)
-{
-  work_started();
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
-}
-
-void scheduler::abandon_operations(
-    op_queue<scheduler::operation>& ops)
-{
-  op_queue<scheduler::operation> ops2;
-  ops2.push(ops);
-}
-
-std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
-    scheduler::thread_info& this_thread,
-    const asio::error_code& ec)
-{
-  while (!stopped_)
-  {
-    if (!op_queue_.empty())
-    {
-      // Prepare to execute first handler from queue.
-      operation* o = op_queue_.front();
-      op_queue_.pop();
-      bool more_handlers = (!op_queue_.empty());
-
-      if (o == &task_operation_)
-      {
-        task_interrupted_ = more_handlers;
-
-        if (more_handlers && !one_thread_)
-          wakeup_event_.unlock_and_signal_one(lock);
-        else
-          lock.unlock();
-
-        task_cleanup on_exit = { this, &lock, &this_thread };
-        (void)on_exit;
-
-        // Run the task. May throw an exception. Only block if the operation
-        // queue is empty and we're not polling, otherwise we want to return
-        // as soon as possible.
-        task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue);
-      }
-      else
-      {
-        std::size_t task_result = o->task_result_;
-
-        if (more_handlers && !one_thread_)
-          wake_one_thread_and_unlock(lock);
-        else
-          lock.unlock();
-
-        // Ensure the count of outstanding work is decremented on block exit.
-        work_cleanup on_exit = { this, &lock, &this_thread };
-        (void)on_exit;
-
-        // Complete the operation. May throw an exception. Deletes the object.
-        o->complete(this, ec, task_result);
-        this_thread.rethrow_pending_exception();
-
-        return 1;
-      }
-    }
-    else
-    {
-      wakeup_event_.clear(lock);
-      wakeup_event_.wait(lock);
-    }
-  }
-
-  return 0;
-}
-
-std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
-    scheduler::thread_info& this_thread, long usec,
-    const asio::error_code& ec)
-{
-  if (stopped_)
-    return 0;
-
-  operation* o = op_queue_.front();
-  if (o == 0)
-  {
-    wakeup_event_.clear(lock);
-    wakeup_event_.wait_for_usec(lock, usec);
-    usec = 0; // Wait at most once.
-    o = op_queue_.front();
-  }
-
-  if (o == &task_operation_)
-  {
-    op_queue_.pop();
-    bool more_handlers = (!op_queue_.empty());
-
-    task_interrupted_ = more_handlers;
-
-    if (more_handlers && !one_thread_)
-      wakeup_event_.unlock_and_signal_one(lock);
-    else
-      lock.unlock();
-
-    {
-      task_cleanup on_exit = { this, &lock, &this_thread };
-      (void)on_exit;
-
-      // Run the task. May throw an exception. Only block if the operation
-      // queue is empty and we're not polling, otherwise we want to return
-      // as soon as possible.
-      task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue);
-    }
-
-    o = op_queue_.front();
-    if (o == &task_operation_)
-    {
-      if (!one_thread_)
-        wakeup_event_.maybe_unlock_and_signal_one(lock);
-      return 0;
-    }
-  }
-
-  if (o == 0)
-    return 0;
-
-  op_queue_.pop();
-  bool more_handlers = (!op_queue_.empty());
-
-  std::size_t task_result = o->task_result_;
-
-  if (more_handlers && !one_thread_)
-    wake_one_thread_and_unlock(lock);
-  else
-    lock.unlock();
-
-  // Ensure the count of outstanding work is decremented on block exit.
-  work_cleanup on_exit = { this, &lock, &this_thread };
-  (void)on_exit;
-
-  // Complete the operation. May throw an exception. Deletes the object.
-  o->complete(this, ec, task_result);
-  this_thread.rethrow_pending_exception();
-
-  return 1;
-}
-
-std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
-    scheduler::thread_info& this_thread,
-    const asio::error_code& ec)
-{
-  if (stopped_)
-    return 0;
-
-  operation* o = op_queue_.front();
-  if (o == &task_operation_)
-  {
-    op_queue_.pop();
-    lock.unlock();
-
-    {
-      task_cleanup c = { this, &lock, &this_thread };
-      (void)c;
-
-      // Run the task. May throw an exception. Only block if the operation
-      // queue is empty and we're not polling, otherwise we want to return
-      // as soon as possible.
-      task_->run(0, this_thread.private_op_queue);
-    }
-
-    o = op_queue_.front();
-    if (o == &task_operation_)
-    {
-      wakeup_event_.maybe_unlock_and_signal_one(lock);
-      return 0;
-    }
-  }
-
-  if (o == 0)
-    return 0;
-
-  op_queue_.pop();
-  bool more_handlers = (!op_queue_.empty());
-
-  std::size_t task_result = o->task_result_;
-
-  if (more_handlers && !one_thread_)
-    wake_one_thread_and_unlock(lock);
-  else
-    lock.unlock();
-
-  // Ensure the count of outstanding work is decremented on block exit.
-  work_cleanup on_exit = { this, &lock, &this_thread };
-  (void)on_exit;
-
-  // Complete the operation. May throw an exception. Deletes the object.
-  o->complete(this, ec, task_result);
-  this_thread.rethrow_pending_exception();
-
-  return 1;
-}
-
-void scheduler::stop_all_threads(
-    mutex::scoped_lock& lock)
-{
-  stopped_ = true;
-  wakeup_event_.signal_all(lock);
-
-  if (!task_interrupted_ && task_)
-  {
-    task_interrupted_ = true;
-    task_->interrupt();
-  }
-}
-
-void scheduler::wake_one_thread_and_unlock(
-    mutex::scoped_lock& lock)
-{
-  if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
-  {
-    if (!task_interrupted_ && task_)
-    {
-      task_interrupted_ = true;
-      task_->interrupt();
-    }
-    lock.unlock();
-  }
-}
-
-scheduler_task* scheduler::get_default_task(asio::execution_context& ctx)
-{
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  return &use_service<io_uring_service>(ctx);
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  return &use_service<reactor>(ctx);
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SCHEDULER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.hpp
deleted file mode 100644
index 933b02c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// detail/impl/select_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || (!defined(ASIO_HAS_DEV_POLL) \
-      && !defined(ASIO_HAS_EPOLL) \
-      && !defined(ASIO_HAS_KQUEUE) \
-      && !defined(ASIO_WINDOWS_RUNTIME))
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline void select_reactor::post_immediate_completion(
-    operation* op, bool is_continuation) const
-{
-  scheduler_.post_immediate_completion(op, is_continuation);
-}
-
-template <typename Time_Traits>
-void select_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void select_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    interrupter_.interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void select_reactor::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void select_reactor::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& target,
-    typename timer_queue<Time_Traits>::per_timer_data& source)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(target, ops);
-  queue.move_timer(target, source);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || (!defined(ASIO_HAS_DEV_POLL)
-       //       && !defined(ASIO_HAS_EPOLL)
-       //       && !defined(ASIO_HAS_KQUEUE)
-       //       && !defined(ASIO_WINDOWS_RUNTIME))
-
-#endif // ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.ipp
deleted file mode 100644
index 5e5946b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/select_reactor.ipp
+++ /dev/null
@@ -1,400 +0,0 @@
-//
-// detail/impl/select_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || (!defined(ASIO_HAS_DEV_POLL) \
-      && !defined(ASIO_HAS_EPOLL) \
-      && !defined(ASIO_HAS_KQUEUE) \
-      && !defined(ASIO_WINDOWS_RUNTIME))
-
-#include "asio/detail/fd_set_adapter.hpp"
-#include "asio/detail/select_reactor.hpp"
-#include "asio/detail/signal_blocker.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_IOCP)
-class select_reactor::thread_function
-{
-public:
-  explicit thread_function(select_reactor* r)
-    : this_(r)
-  {
-  }
-
-  void operator()()
-  {
-    this_->run_thread();
-  }
-
-private:
-  select_reactor* this_;
-};
-#endif // defined(ASIO_HAS_IOCP)
-
-select_reactor::select_reactor(asio::execution_context& ctx)
-  : execution_context_service_base<select_reactor>(ctx),
-    scheduler_(use_service<scheduler_type>(ctx)),
-    mutex_(),
-    interrupter_(),
-#if defined(ASIO_HAS_IOCP)
-    stop_thread_(false),
-    thread_(0),
-    restart_reactor_(this),
-#endif // defined(ASIO_HAS_IOCP)
-    shutdown_(false)
-{
-#if defined(ASIO_HAS_IOCP)
-  asio::detail::signal_blocker sb;
-  thread_ = new asio::detail::thread(thread_function(this));
-#endif // defined(ASIO_HAS_IOCP)
-}
-
-select_reactor::~select_reactor()
-{
-  shutdown();
-}
-
-void select_reactor::shutdown()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-#if defined(ASIO_HAS_IOCP)
-  stop_thread_ = true;
-  if (thread_)
-    interrupter_.interrupt();
-#endif // defined(ASIO_HAS_IOCP)
-  lock.unlock();
-
-#if defined(ASIO_HAS_IOCP)
-  if (thread_)
-  {
-    thread_->join();
-    delete thread_;
-    thread_ = 0;
-  }
-#endif // defined(ASIO_HAS_IOCP)
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].get_all_operations(ops);
-
-  timer_queues_.get_all_timers(ops);
-
-  scheduler_.abandon_operations(ops);
-}
-
-void select_reactor::notify_fork(
-    asio::execution_context::fork_event fork_ev)
-{
-#if defined(ASIO_HAS_IOCP)
-  (void)fork_ev;
-#else // defined(ASIO_HAS_IOCP)
-  if (fork_ev == asio::execution_context::fork_child)
-    interrupter_.recreate();
-#endif // defined(ASIO_HAS_IOCP)
-}
-
-void select_reactor::init_task()
-{
-  scheduler_.init_task();
-}
-
-int select_reactor::register_descriptor(socket_type,
-    select_reactor::per_descriptor_data&)
-{
-  return 0;
-}
-
-int select_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  op_queue_[op_type].enqueue_operation(descriptor, op);
-  interrupter_.interrupt();
-
-  return 0;
-}
-
-void select_reactor::move_descriptor(socket_type,
-    select_reactor::per_descriptor_data&,
-    select_reactor::per_descriptor_data&)
-{
-}
-
-void select_reactor::call_post_immediate_completion(
-    operation* op, bool is_continuation, const void* self)
-{
-  static_cast<const select_reactor*>(self)->post_immediate_completion(
-      op, is_continuation);
-}
-
-void select_reactor::start_op(int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op, bool is_continuation,
-    bool, void (*on_immediate)(operation*, bool, const void*),
-    const void* immediate_arg)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    on_immediate(op, is_continuation, immediate_arg);
-    return;
-  }
-
-  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  scheduler_.work_started();
-  if (first)
-    interrupter_.interrupt();
-}
-
-void select_reactor::cancel_ops(socket_type descriptor,
-    select_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void select_reactor::cancel_ops_by_key(socket_type descriptor,
-    select_reactor::per_descriptor_data&,
-    int op_type, void* cancellation_key)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
-      descriptor, ops, cancellation_key, asio::error::operation_aborted);
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-void select_reactor::deregister_descriptor(socket_type descriptor,
-    select_reactor::per_descriptor_data&, bool)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void select_reactor::deregister_internal_descriptor(
-    socket_type descriptor, select_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].cancel_operations(descriptor, ops);
-}
-
-void select_reactor::cleanup_descriptor_data(
-    select_reactor::per_descriptor_data&)
-{
-}
-
-void select_reactor::run(long usec, op_queue<operation>& ops)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-#if defined(ASIO_HAS_IOCP)
-  // Check if the thread is supposed to stop.
-  if (stop_thread_)
-    return;
-#endif // defined(ASIO_HAS_IOCP)
-
-  // Set up the descriptor sets.
-  for (int i = 0; i < max_select_ops; ++i)
-    fd_sets_[i].reset();
-  fd_sets_[read_op].set(interrupter_.read_descriptor());
-  socket_type max_fd = 0;
-  bool have_work_to_do = !timer_queues_.all_empty();
-  for (int i = 0; i < max_select_ops; ++i)
-  {
-    have_work_to_do = have_work_to_do || !op_queue_[i].empty();
-    fd_sets_[i].set(op_queue_[i], ops);
-    if (fd_sets_[i].max_descriptor() > max_fd)
-      max_fd = fd_sets_[i].max_descriptor();
-  }
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Connection operations on Windows use both except and write fd_sets.
-  have_work_to_do = have_work_to_do || !op_queue_[connect_op].empty();
-  fd_sets_[write_op].set(op_queue_[connect_op], ops);
-  if (fd_sets_[write_op].max_descriptor() > max_fd)
-    max_fd = fd_sets_[write_op].max_descriptor();
-  fd_sets_[except_op].set(op_queue_[connect_op], ops);
-  if (fd_sets_[except_op].max_descriptor() > max_fd)
-    max_fd = fd_sets_[except_op].max_descriptor();
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-  // We can return immediately if there's no work to do and the reactor is
-  // not supposed to block.
-  if (!usec && !have_work_to_do)
-    return;
-
-  // Determine how long to block while waiting for events.
-  timeval tv_buf = { 0, 0 };
-  timeval* tv = usec ? get_timeout(usec, tv_buf) : &tv_buf;
-
-  lock.unlock();
-
-  // Block on the select call until descriptors become ready.
-  asio::error_code ec;
-  int retval = socket_ops::select(static_cast<int>(max_fd + 1),
-      fd_sets_[read_op], fd_sets_[write_op], fd_sets_[except_op], tv, ec);
-
-  // Reset the interrupter.
-  if (retval > 0 && fd_sets_[read_op].is_set(interrupter_.read_descriptor()))
-  {
-    if (!interrupter_.reset())
-    {
-      lock.lock();
-#if defined(ASIO_HAS_IOCP)
-      stop_thread_ = true;
-      scheduler_.post_immediate_completion(&restart_reactor_, false);
-#else // defined(ASIO_HAS_IOCP)
-      interrupter_.recreate();
-#endif // defined(ASIO_HAS_IOCP)
-    }
-    --retval;
-  }
-
-  lock.lock();
-
-  // Dispatch all ready operations.
-  if (retval > 0)
-  {
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    // Connection operations on Windows use both except and write fd_sets.
-    fd_sets_[except_op].perform(op_queue_[connect_op], ops);
-    fd_sets_[write_op].perform(op_queue_[connect_op], ops);
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-    // Exception operations must be processed first to ensure that any
-    // out-of-band data is read before normal data.
-    for (int i = max_select_ops - 1; i >= 0; --i)
-      fd_sets_[i].perform(op_queue_[i], ops);
-  }
-  timer_queues_.get_ready_timers(ops);
-}
-
-void select_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-
-#if defined(ASIO_HAS_IOCP)
-void select_reactor::run_thread()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  while (!stop_thread_)
-  {
-    lock.unlock();
-    op_queue<operation> ops;
-    run(-1, ops);
-    scheduler_.post_deferred_completions(ops);
-    lock.lock();
-  }
-}
-
-void select_reactor::restart_reactor::do_complete(void* owner, operation* base,
-    const asio::error_code& /*ec*/, std::size_t /*bytes_transferred*/)
-{
-  if (owner)
-  {
-    select_reactor* reactor = static_cast<restart_reactor*>(base)->reactor_;
-
-    if (reactor->thread_)
-    {
-      reactor->thread_->join();
-      delete reactor->thread_;
-      reactor->thread_ = 0;
-    }
-
-    asio::detail::mutex::scoped_lock lock(reactor->mutex_);
-    reactor->interrupter_.recreate();
-    reactor->stop_thread_ = false;
-    lock.unlock();
-
-    asio::detail::signal_blocker sb;
-    reactor->thread_ =
-      new asio::detail::thread(thread_function(reactor));
-  }
-}
-#endif // defined(ASIO_HAS_IOCP)
-
-void select_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void select_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-timeval* select_reactor::get_timeout(long usec, timeval& tv)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  const long max_usec = 5 * 60 * 1000 * 1000;
-  usec = timer_queues_.wait_duration_usec(
-      (usec < 0 || max_usec < usec) ? max_usec : usec);
-  tv.tv_sec = usec / 1000000;
-  tv.tv_usec = usec % 1000000;
-  return &tv;
-}
-
-void select_reactor::cancel_ops_unlocked(socket_type descriptor,
-    const asio::error_code& ec)
-{
-  bool need_interrupt = false;
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    need_interrupt = op_queue_[i].cancel_operations(
-        descriptor, ops, ec) || need_interrupt;
-  scheduler_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || (!defined(ASIO_HAS_DEV_POLL)
-       //       && !defined(ASIO_HAS_EPOLL)
-       //       && !defined(ASIO_HAS_KQUEUE))
-       //       && !defined(ASIO_WINDOWS_RUNTIME))
-
-#endif // ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.hpp
deleted file mode 100644
index 2490636..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//
-// detail/impl/service_registry.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-#define ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Service>
-Service& service_registry::use_service()
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  factory_type factory = &service_registry::create<Service, execution_context>;
-  return *static_cast<Service*>(do_use_service(key, factory, &owner_));
-}
-
-template <typename Service>
-Service& service_registry::use_service(io_context& owner)
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  factory_type factory = &service_registry::create<Service, io_context>;
-  return *static_cast<Service*>(do_use_service(key, factory, &owner));
-}
-
-template <typename Service>
-void service_registry::add_service(Service* new_service)
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  return do_add_service(key, new_service);
-}
-
-template <typename Service>
-bool service_registry::has_service() const
-{
-  execution_context::service::key key;
-  init_key<Service>(key, 0);
-  return do_has_service(key);
-}
-
-template <typename Service>
-inline void service_registry::init_key(
-    execution_context::service::key& key, ...)
-{
-  init_key_from_id(key, Service::id);
-}
-
-#if !defined(ASIO_NO_TYPEID)
-template <typename Service>
-void service_registry::init_key(execution_context::service::key& key,
-    enable_if_t<is_base_of<typename Service::key_type, Service>::value>*)
-{
-  key.type_info_ = &typeid(typeid_wrapper<Service>);
-  key.id_ = 0;
-}
-
-template <typename Service>
-void service_registry::init_key_from_id(execution_context::service::key& key,
-    const service_id<Service>& /*id*/)
-{
-  key.type_info_ = &typeid(typeid_wrapper<Service>);
-  key.id_ = 0;
-}
-#endif // !defined(ASIO_NO_TYPEID)
-
-template <typename Service, typename Owner>
-execution_context::service* service_registry::create(void* owner)
-{
-  return new Service(*static_cast<Owner*>(owner));
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.ipp
deleted file mode 100644
index b013342..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/service_registry.ipp
+++ /dev/null
@@ -1,197 +0,0 @@
-//
-// detail/impl/service_registry.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
-#define ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <vector>
-#include "asio/detail/service_registry.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-service_registry::service_registry(execution_context& owner)
-  : owner_(owner),
-    first_service_(0)
-{
-}
-
-service_registry::~service_registry()
-{
-}
-
-void service_registry::shutdown_services()
-{
-  execution_context::service* service = first_service_;
-  while (service)
-  {
-    service->shutdown();
-    service = service->next_;
-  }
-}
-
-void service_registry::destroy_services()
-{
-  while (first_service_)
-  {
-    execution_context::service* next_service = first_service_->next_;
-    destroy(first_service_);
-    first_service_ = next_service;
-  }
-}
-
-void service_registry::notify_fork(execution_context::fork_event fork_ev)
-{
-  // Make a copy of all of the services while holding the lock. We don't want
-  // to hold the lock while calling into each service, as it may try to call
-  // back into this class.
-  std::vector<execution_context::service*> services;
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    execution_context::service* service = first_service_;
-    while (service)
-    {
-      services.push_back(service);
-      service = service->next_;
-    }
-  }
-
-  // If processing the fork_prepare event, we want to go in reverse order of
-  // service registration, which happens to be the existing order of the
-  // services in the vector. For the other events we want to go in the other
-  // direction.
-  std::size_t num_services = services.size();
-  if (fork_ev == execution_context::fork_prepare)
-    for (std::size_t i = 0; i < num_services; ++i)
-      services[i]->notify_fork(fork_ev);
-  else
-    for (std::size_t i = num_services; i > 0; --i)
-      services[i - 1]->notify_fork(fork_ev);
-}
-
-void service_registry::init_key_from_id(execution_context::service::key& key,
-    const execution_context::id& id)
-{
-  key.type_info_ = 0;
-  key.id_ = &id;
-}
-
-bool service_registry::keys_match(
-    const execution_context::service::key& key1,
-    const execution_context::service::key& key2)
-{
-  if (key1.id_ && key2.id_)
-    if (key1.id_ == key2.id_)
-      return true;
-  if (key1.type_info_ && key2.type_info_)
-    if (*key1.type_info_ == *key2.type_info_)
-      return true;
-  return false;
-}
-
-void service_registry::destroy(execution_context::service* service)
-{
-  delete service;
-}
-
-execution_context::service* service_registry::do_use_service(
-    const execution_context::service::key& key,
-    factory_type factory, void* owner)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // First see if there is an existing service object with the given key.
-  execution_context::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return service;
-    service = service->next_;
-  }
-
-  // Create a new service object. The service registry's mutex is not locked
-  // at this time to allow for nested calls into this function from the new
-  // service's constructor.
-  lock.unlock();
-  auto_service_ptr new_service = { factory(owner) };
-  new_service.ptr_->key_ = key;
-  lock.lock();
-
-  // Check that nobody else created another service object of the same type
-  // while the lock was released.
-  service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return service;
-    service = service->next_;
-  }
-
-  // Service was successfully initialised, pass ownership to registry.
-  new_service.ptr_->next_ = first_service_;
-  first_service_ = new_service.ptr_;
-  new_service.ptr_ = 0;
-  return first_service_;
-}
-
-void service_registry::do_add_service(
-    const execution_context::service::key& key,
-    execution_context::service* new_service)
-{
-  if (&owner_ != &new_service->context())
-    asio::detail::throw_exception(invalid_service_owner());
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Check if there is an existing service object with the given key.
-  execution_context::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      asio::detail::throw_exception(service_already_exists());
-    service = service->next_;
-  }
-
-  // Take ownership of the service object.
-  new_service->key_ = key;
-  new_service->next_ = first_service_;
-  first_service_ = new_service;
-}
-
-bool service_registry::do_has_service(
-    const execution_context::service::key& key) const
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  execution_context::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return true;
-    service = service->next_;
-  }
-
-  return false;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/signal_set_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/signal_set_service.ipp
deleted file mode 100644
index 7f6be8b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/signal_set_service.ipp
+++ /dev/null
@@ -1,826 +0,0 @@
-//
-// detail/impl/signal_set_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstring>
-#include <stdexcept>
-#include "asio/detail/signal_blocker.hpp"
-#include "asio/detail/signal_set_service.hpp"
-#include "asio/detail/static_mutex.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_service.hpp"
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/reactor.hpp"
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct signal_state
-{
-  // Mutex used for protecting global state.
-  static_mutex mutex_;
-
-  // The read end of the pipe used for signal notifications.
-  int read_descriptor_;
-
-  // The write end of the pipe used for signal notifications.
-  int write_descriptor_;
-
-  // Whether the signal state has been prepared for a fork.
-  bool fork_prepared_;
-
-  // The head of a linked list of all signal_set_service instances.
-  class signal_set_service* service_list_;
-
-  // A count of the number of objects that are registered for each signal.
-  std::size_t registration_count_[max_signal_number];
-
-  // The flags used for each registered signal.
-  signal_set_base::flags_t flags_[max_signal_number];
-};
-
-signal_state* get_signal_state()
-{
-  static signal_state state = {
-    ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0,
-    { 0 }, { signal_set_base::flags_t() } };
-  return &state;
-}
-
-void asio_signal_handler(int signal_number)
-{
-#if defined(ASIO_WINDOWS) \
-  || defined(ASIO_WINDOWS_RUNTIME) \
-  || defined(__CYGWIN__)
-  signal_set_service::deliver_signal(signal_number);
-#else // defined(ASIO_WINDOWS)
-      //   || defined(ASIO_WINDOWS_RUNTIME)
-      //   || defined(__CYGWIN__)
-  int saved_errno = errno;
-  signal_state* state = get_signal_state();
-  signed_size_type result = ::write(state->write_descriptor_,
-      &signal_number, sizeof(signal_number));
-  (void)result;
-  errno = saved_errno;
-#endif // defined(ASIO_WINDOWS)
-       //   || defined(ASIO_WINDOWS_RUNTIME)
-       //   || defined(__CYGWIN__)
-
-#if defined(ASIO_HAS_SIGNAL) && !defined(ASIO_HAS_SIGACTION)
-  ::signal(signal_number, asio_signal_handler);
-#endif // defined(ASIO_HAS_SIGNAL) && !defined(ASIO_HAS_SIGACTION)
-}
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-class signal_set_service::pipe_read_op :
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  public io_uring_operation
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  public reactor_op
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-{
-public:
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  pipe_read_op()
-    : io_uring_operation(asio::error_code(), &pipe_read_op::do_prepare,
-        &pipe_read_op::do_perform, pipe_read_op::do_complete)
-  {
-  }
-
-  static void do_prepare(io_uring_operation*, ::io_uring_sqe* sqe)
-  {
-    signal_state* state = get_signal_state();
-
-    int fd = state->read_descriptor_;
-    ::io_uring_prep_poll_add(sqe, fd, POLLIN);
-  }
-
-  static bool do_perform(io_uring_operation*, bool)
-  {
-    signal_state* state = get_signal_state();
-
-    int fd = state->read_descriptor_;
-    int signal_number = 0;
-    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
-      if (signal_number >= 0 && signal_number < max_signal_number)
-        signal_set_service::deliver_signal(signal_number);
-
-    return false;
-  }
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  pipe_read_op()
-    : reactor_op(asio::error_code(),
-        &pipe_read_op::do_perform, pipe_read_op::do_complete)
-  {
-  }
-
-  static status do_perform(reactor_op*)
-  {
-    signal_state* state = get_signal_state();
-
-    int fd = state->read_descriptor_;
-    int signal_number = 0;
-    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
-      if (signal_number >= 0 && signal_number < max_signal_number)
-        signal_set_service::deliver_signal(signal_number);
-
-    return not_done;
-  }
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-  static void do_complete(void* /*owner*/, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    pipe_read_op* o(static_cast<pipe_read_op*>(base));
-    delete o;
-  }
-};
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-signal_set_service::signal_set_service(execution_context& context)
-  : execution_context_service_base<signal_set_service>(context),
-    scheduler_(asio::use_service<scheduler_impl>(context)),
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    io_uring_service_(asio::use_service<io_uring_service>(context)),
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    reactor_(asio::use_service<reactor>(context)),
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-    next_(0),
-    prev_(0)
-{
-  get_signal_state()->mutex_.init();
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  io_uring_service_.init_task();
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  reactor_.init_task();
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-  for (int i = 0; i < max_signal_number; ++i)
-    registrations_[i] = 0;
-
-  add_service(this);
-}
-
-signal_set_service::~signal_set_service()
-{
-  remove_service(this);
-}
-
-void signal_set_service::shutdown()
-{
-  remove_service(this);
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_signal_number; ++i)
-  {
-    registration* reg = registrations_[i];
-    while (reg)
-    {
-      ops.push(*reg->queue_);
-      reg = reg->next_in_table_;
-    }
-  }
-
-  scheduler_.abandon_operations(ops);
-}
-
-void signal_set_service::notify_fork(execution_context::fork_event fork_ev)
-{
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  switch (fork_ev)
-  {
-  case execution_context::fork_prepare:
-    {
-      int read_descriptor = state->read_descriptor_;
-      state->fork_prepared_ = true;
-      lock.unlock();
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      (void)read_descriptor;
-      io_uring_service_.deregister_io_object(io_object_data_);
-      io_uring_service_.cleanup_io_object(io_object_data_);
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
-      reactor_.cleanup_descriptor_data(reactor_data_);
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    }
-    break;
-  case execution_context::fork_parent:
-    if (state->fork_prepared_)
-    {
-      int read_descriptor = state->read_descriptor_;
-      state->fork_prepared_ = false;
-      lock.unlock();
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      (void)read_descriptor;
-      io_uring_service_.register_internal_io_object(io_object_data_,
-          io_uring_service::read_op, new pipe_read_op);
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      reactor_.register_internal_descriptor(reactor::read_op,
-          read_descriptor, reactor_data_, new pipe_read_op);
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    }
-    break;
-  case execution_context::fork_child:
-    if (state->fork_prepared_)
-    {
-      asio::detail::signal_blocker blocker;
-      close_descriptors();
-      open_descriptors();
-      int read_descriptor = state->read_descriptor_;
-      state->fork_prepared_ = false;
-      lock.unlock();
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      (void)read_descriptor;
-      io_uring_service_.register_internal_io_object(io_object_data_,
-          io_uring_service::read_op, new pipe_read_op);
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-      reactor_.register_internal_descriptor(reactor::read_op,
-          read_descriptor, reactor_data_, new pipe_read_op);
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    }
-    break;
-  default:
-    break;
-  }
-#else // !defined(ASIO_WINDOWS)
-      //   && !defined(ASIO_WINDOWS_RUNTIME)
-      //   && !defined(__CYGWIN__)
-  (void)fork_ev;
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-}
-
-void signal_set_service::construct(
-    signal_set_service::implementation_type& impl)
-{
-  impl.signals_ = 0;
-}
-
-void signal_set_service::destroy(
-    signal_set_service::implementation_type& impl)
-{
-  asio::error_code ignored_ec;
-  clear(impl, ignored_ec);
-  cancel(impl, ignored_ec);
-}
-
-asio::error_code signal_set_service::add(
-    signal_set_service::implementation_type& impl, int signal_number,
-    signal_set_base::flags_t f, asio::error_code& ec)
-{
-  // Check that the signal number is valid.
-  if (signal_number < 0 || signal_number >= max_signal_number)
-  {
-    ec = asio::error::invalid_argument;
-    return ec;
-  }
-
-  // Check that the specified flags are supported.
-#if !defined(ASIO_HAS_SIGACTION)
-  if (f != signal_set_base::flags::dont_care)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-#endif // !defined(ASIO_HAS_SIGACTION)
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  // Find the appropriate place to insert the registration.
-  registration** insertion_point = &impl.signals_;
-  registration* next = impl.signals_;
-  while (next && next->signal_number_ < signal_number)
-  {
-    insertion_point = &next->next_in_set_;
-    next = next->next_in_set_;
-  }
-
-  // Only do something if the signal is not already registered.
-  if (next == 0 || next->signal_number_ != signal_number)
-  {
-    registration* new_registration = new registration;
-
-#if defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-    // Register for the signal if we're the first.
-    if (state->registration_count_[signal_number] == 0)
-    {
-# if defined(ASIO_HAS_SIGACTION)
-      using namespace std; // For memset.
-      struct sigaction sa;
-      memset(&sa, 0, sizeof(sa));
-      sa.sa_handler = asio_signal_handler;
-      sigfillset(&sa.sa_mask);
-      if (f != signal_set_base::flags::dont_care)
-        sa.sa_flags = static_cast<int>(f);
-      if (::sigaction(signal_number, &sa, 0) == -1)
-# else // defined(ASIO_HAS_SIGACTION)
-      if (::signal(signal_number, asio_signal_handler) == SIG_ERR)
-# endif // defined(ASIO_HAS_SIGACTION)
-      {
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error::invalid_argument;
-# else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error_code(errno,
-            asio::error::get_system_category());
-# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        delete new_registration;
-        return ec;
-      }
-# if defined(ASIO_HAS_SIGACTION)
-      state->flags_[signal_number] = f;
-# endif // defined(ASIO_HAS_SIGACTION)
-    }
-# if defined(ASIO_HAS_SIGACTION)
-    // Otherwise check to see if the flags have changed.
-    else if (f != signal_set_base::flags::dont_care)
-    {
-      if (f != state->flags_[signal_number])
-      {
-        using namespace std; // For memset.
-        if (state->flags_[signal_number] != signal_set_base::flags::dont_care)
-        {
-          ec = asio::error::invalid_argument;
-          delete new_registration;
-          return ec;
-        }
-        struct sigaction sa;
-        memset(&sa, 0, sizeof(sa));
-        sa.sa_handler = asio_signal_handler;
-        sigfillset(&sa.sa_mask);
-        sa.sa_flags = static_cast<int>(f);
-        if (::sigaction(signal_number, &sa, 0) == -1)
-        {
-          ec = asio::error_code(errno,
-              asio::error::get_system_category());
-          delete new_registration;
-          return ec;
-        }
-        state->flags_[signal_number] = f;
-      }
-    }
-# endif // defined(ASIO_HAS_SIGACTION)
-#endif // defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-
-    // Record the new registration in the set.
-    new_registration->signal_number_ = signal_number;
-    new_registration->queue_ = &impl.queue_;
-    new_registration->next_in_set_ = next;
-    *insertion_point = new_registration;
-
-    // Insert registration into the registration table.
-    new_registration->next_in_table_ = registrations_[signal_number];
-    if (registrations_[signal_number])
-      registrations_[signal_number]->prev_in_table_ = new_registration;
-    registrations_[signal_number] = new_registration;
-
-    ++state->registration_count_[signal_number];
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code signal_set_service::remove(
-    signal_set_service::implementation_type& impl,
-    int signal_number, asio::error_code& ec)
-{
-  // Check that the signal number is valid.
-  if (signal_number < 0 || signal_number >= max_signal_number)
-  {
-    ec = asio::error::invalid_argument;
-    return ec;
-  }
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  // Find the signal number in the list of registrations.
-  registration** deletion_point = &impl.signals_;
-  registration* reg = impl.signals_;
-  while (reg && reg->signal_number_ < signal_number)
-  {
-    deletion_point = &reg->next_in_set_;
-    reg = reg->next_in_set_;
-  }
-
-  if (reg != 0 && reg->signal_number_ == signal_number)
-  {
-#if defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-    // Set signal handler back to the default if we're the last.
-    if (state->registration_count_[signal_number] == 1)
-    {
-# if defined(ASIO_HAS_SIGACTION)
-      using namespace std; // For memset.
-      struct sigaction sa;
-      memset(&sa, 0, sizeof(sa));
-      sa.sa_handler = SIG_DFL;
-      if (::sigaction(signal_number, &sa, 0) == -1)
-# else // defined(ASIO_HAS_SIGACTION)
-      if (::signal(signal_number, SIG_DFL) == SIG_ERR)
-# endif // defined(ASIO_HAS_SIGACTION)
-      {
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error::invalid_argument;
-# else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error_code(errno,
-            asio::error::get_system_category());
-# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        return ec;
-      }
-# if defined(ASIO_HAS_SIGACTION)
-      state->flags_[signal_number] = signal_set_base::flags_t();
-# endif // defined(ASIO_HAS_SIGACTION)
-    }
-#endif // defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-
-    // Remove the registration from the set.
-    *deletion_point = reg->next_in_set_;
-
-    // Remove the registration from the registration table.
-    if (registrations_[signal_number] == reg)
-      registrations_[signal_number] = reg->next_in_table_;
-    if (reg->prev_in_table_)
-      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
-    if (reg->next_in_table_)
-      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
-
-    --state->registration_count_[signal_number];
-
-    delete reg;
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code signal_set_service::clear(
-    signal_set_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  while (registration* reg = impl.signals_)
-  {
-#if defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-    // Set signal handler back to the default if we're the last.
-    if (state->registration_count_[reg->signal_number_] == 1)
-    {
-# if defined(ASIO_HAS_SIGACTION)
-      using namespace std; // For memset.
-      struct sigaction sa;
-      memset(&sa, 0, sizeof(sa));
-      sa.sa_handler = SIG_DFL;
-      if (::sigaction(reg->signal_number_, &sa, 0) == -1)
-# else // defined(ASIO_HAS_SIGACTION)
-      if (::signal(reg->signal_number_, SIG_DFL) == SIG_ERR)
-# endif // defined(ASIO_HAS_SIGACTION)
-      {
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error::invalid_argument;
-# else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        ec = asio::error_code(errno,
-            asio::error::get_system_category());
-# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-        return ec;
-      }
-# if defined(ASIO_HAS_SIGACTION)
-      state->flags_[reg->signal_number_] = signal_set_base::flags_t();
-# endif // defined(ASIO_HAS_SIGACTION)
-    }
-#endif // defined(ASIO_HAS_SIGNAL) || defined(ASIO_HAS_SIGACTION)
-
-    // Remove the registration from the registration table.
-    if (registrations_[reg->signal_number_] == reg)
-      registrations_[reg->signal_number_] = reg->next_in_table_;
-    if (reg->prev_in_table_)
-      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
-    if (reg->next_in_table_)
-      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
-
-    --state->registration_count_[reg->signal_number_];
-
-    impl.signals_ = reg->next_in_set_;
-    delete reg;
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code signal_set_service::cancel(
-    signal_set_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  ASIO_HANDLER_OPERATION((scheduler_.context(),
-        "signal_set", &impl, 0, "cancel"));
-
-  op_queue<operation> ops;
-  {
-    signal_state* state = get_signal_state();
-    static_mutex::scoped_lock lock(state->mutex_);
-
-    while (signal_op* op = impl.queue_.front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      impl.queue_.pop();
-      ops.push(op);
-    }
-  }
-
-  scheduler_.post_deferred_completions(ops);
-
-  ec = asio::error_code();
-  return ec;
-}
-
-void signal_set_service::cancel_ops_by_key(
-    signal_set_service::implementation_type& impl, void* cancellation_key)
-{
-  op_queue<operation> ops;
-  {
-    op_queue<signal_op> other_ops;
-    signal_state* state = get_signal_state();
-    static_mutex::scoped_lock lock(state->mutex_);
-
-    while (signal_op* op = impl.queue_.front())
-    {
-      impl.queue_.pop();
-      if (op->cancellation_key_ == cancellation_key)
-      {
-        op->ec_ = asio::error::operation_aborted;
-        ops.push(op);
-      }
-      else
-        other_ops.push(op);
-    }
-
-    impl.queue_.push(other_ops);
-  }
-
-  scheduler_.post_deferred_completions(ops);
-}
-
-void signal_set_service::deliver_signal(int signal_number)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  signal_set_service* service = state->service_list_;
-  while (service)
-  {
-    op_queue<operation> ops;
-
-    registration* reg = service->registrations_[signal_number];
-    while (reg)
-    {
-      if (reg->queue_->empty())
-      {
-        ++reg->undelivered_;
-      }
-      else
-      {
-        while (signal_op* op = reg->queue_->front())
-        {
-          op->signal_number_ = signal_number;
-          reg->queue_->pop();
-          ops.push(op);
-        }
-      }
-
-      reg = reg->next_in_table_;
-    }
-
-    service->scheduler_.post_deferred_completions(ops);
-
-    service = service->next_;
-  }
-}
-
-void signal_set_service::add_service(signal_set_service* service)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-  // If this is the first service to be created, open a new pipe.
-  if (state->service_list_ == 0)
-    open_descriptors();
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-  // If a scheduler_ object is thread-unsafe then it must be the only
-  // scheduler used to create signal_set objects.
-  if (state->service_list_ != 0)
-  {
-    if (!ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
-          service->scheduler_.concurrency_hint())
-        || !ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
-          state->service_list_->scheduler_.concurrency_hint()))
-    {
-      std::logic_error ex(
-          "Thread-unsafe execution context objects require "
-          "exclusive access to signal handling.");
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  // Insert service into linked list of all services.
-  service->next_ = state->service_list_;
-  service->prev_ = 0;
-  if (state->service_list_)
-    state->service_list_->prev_ = service;
-  state->service_list_ = service;
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-  // Register for pipe readiness notifications.
-  int read_descriptor = state->read_descriptor_;
-  lock.unlock();
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  (void)read_descriptor;
-  service->io_uring_service_.register_internal_io_object(
-      service->io_object_data_, io_uring_service::read_op, new pipe_read_op);
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  service->reactor_.register_internal_descriptor(reactor::read_op,
-      read_descriptor, service->reactor_data_, new pipe_read_op);
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-}
-
-void signal_set_service::remove_service(signal_set_service* service)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  if (service->next_ || service->prev_ || state->service_list_ == service)
-  {
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-    // Disable the pipe readiness notifications.
-    int read_descriptor = state->read_descriptor_;
-    lock.unlock();
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    (void)read_descriptor;
-    service->io_uring_service_.deregister_io_object(service->io_object_data_);
-    service->io_uring_service_.cleanup_io_object(service->io_object_data_);
-    lock.lock();
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-    service->reactor_.deregister_internal_descriptor(
-        read_descriptor, service->reactor_data_);
-    service->reactor_.cleanup_descriptor_data(service->reactor_data_);
-    lock.lock();
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-    // Remove service from linked list of all services.
-    if (state->service_list_ == service)
-      state->service_list_ = service->next_;
-    if (service->prev_)
-      service->prev_->next_ = service->next_;
-    if (service->next_)
-      service->next_->prev_= service->prev_;
-    service->next_ = 0;
-    service->prev_ = 0;
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-    // If this is the last service to be removed, close the pipe.
-    if (state->service_list_ == 0)
-      close_descriptors();
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-  }
-}
-
-void signal_set_service::open_descriptors()
-{
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-  signal_state* state = get_signal_state();
-
-  int pipe_fds[2];
-  if (::pipe(pipe_fds) == 0)
-  {
-    state->read_descriptor_ = pipe_fds[0];
-    ::fcntl(state->read_descriptor_, F_SETFL, O_NONBLOCK);
-
-    state->write_descriptor_ = pipe_fds[1];
-    ::fcntl(state->write_descriptor_, F_SETFL, O_NONBLOCK);
-
-#if defined(FD_CLOEXEC)
-    ::fcntl(state->read_descriptor_, F_SETFD, FD_CLOEXEC);
-    ::fcntl(state->write_descriptor_, F_SETFD, FD_CLOEXEC);
-#endif // defined(FD_CLOEXEC)
-  }
-  else
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "signal_set_service pipe");
-  }
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-}
-
-void signal_set_service::close_descriptors()
-{
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-  signal_state* state = get_signal_state();
-
-  if (state->read_descriptor_ != -1)
-    ::close(state->read_descriptor_);
-  state->read_descriptor_ = -1;
-
-  if (state->write_descriptor_ != -1)
-    ::close(state->write_descriptor_);
-  state->write_descriptor_ = -1;
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-}
-
-void signal_set_service::start_wait_op(
-    signal_set_service::implementation_type& impl, signal_op* op)
-{
-  scheduler_.work_started();
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  registration* reg = impl.signals_;
-  while (reg)
-  {
-    if (reg->undelivered_ > 0)
-    {
-      --reg->undelivered_;
-      op->signal_number_ = reg->signal_number_;
-      scheduler_.post_deferred_completion(op);
-      return;
-    }
-
-    reg = reg->next_in_set_;
-  }
-
-  impl.queue_.push(op);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_ops.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_ops.ipp
deleted file mode 100644
index 9f36942..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_ops.ipp
+++ /dev/null
@@ -1,4038 +0,0 @@
-//
-// detail/impl/socket_ops.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_OPS_IPP
-#define ASIO_DETAIL_SOCKET_OPS_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cctype>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <cerrno>
-#include <new>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include <codecvt>
-# include <locale>
-# include <string>
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__) \
-  || defined(__MACH__) && defined(__APPLE__)
-# if defined(ASIO_HAS_PTHREADS)
-#  include <pthread.h>
-# endif // defined(ASIO_HAS_PTHREADS)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-       // || defined(__MACH__) && defined(__APPLE__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace socket_ops {
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-struct msghdr { int msg_namelen; };
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#if defined(__hpux)
-// HP-UX doesn't declare these functions extern "C", so they are declared again
-// here to avoid linker errors about undefined symbols.
-extern "C" char* if_indextoname(unsigned int, char*);
-extern "C" unsigned int if_nametoindex(const char*);
-#endif // defined(__hpux)
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-inline void clear_last_error()
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  WSASetLastError(0);
-#else
-  errno = 0;
-#endif
-}
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-inline void get_last_error(
-    asio::error_code& ec, bool is_error_condition)
-{
-  if (!is_error_condition)
-  {
-    asio::error::clear(ec);
-  }
-  else
-  {
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    ec = asio::error_code(WSAGetLastError(),
-        asio::error::get_system_category());
-#else
-    ec = asio::error_code(errno,
-        asio::error::get_system_category());
-#endif
-  }
-}
-
-template <typename SockLenType>
-inline socket_type call_accept(SockLenType msghdr::*,
-    socket_type s, void* addr, std::size_t* addrlen)
-{
-  SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
-  socket_type result = ::accept(s,
-      static_cast<socket_addr_type*>(addr),
-      addrlen ? &tmp_addrlen : 0);
-  if (addrlen)
-    *addrlen = (std::size_t)tmp_addrlen;
-  return result;
-}
-
-socket_type accept(socket_type s, void* addr,
-    std::size_t* addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return invalid_socket;
-  }
-
-  socket_type new_s = call_accept(&msghdr::msg_namelen, s, addr, addrlen);
-  get_last_error(ec, new_s == invalid_socket);
-  if (new_s == invalid_socket)
-    return new_s;
-
-#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
-  int optval = 1;
-  int result = ::setsockopt(new_s, SOL_SOCKET,
-      SO_NOSIGPIPE, &optval, sizeof(optval));
-  get_last_error(ec, result != 0);
-  if (result != 0)
-  {
-    ::close(new_s);
-    return invalid_socket;
-  }
-#endif
-
-  asio::error::clear(ec);
-  return new_s;
-}
-
-socket_type sync_accept(socket_type s, state_type state,
-    void* addr, std::size_t* addrlen, asio::error_code& ec)
-{
-  // Accept a socket.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (new_socket != invalid_socket)
-      return new_socket;
-
-    // Operation failed.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-    {
-      if (state & user_set_non_blocking)
-        return invalid_socket;
-      // Fall through to retry operation.
-    }
-    else if (ec == asio::error::connection_aborted)
-    {
-      if (state & enable_connection_aborted)
-        return invalid_socket;
-      // Fall through to retry operation.
-    }
-#if defined(EPROTO)
-    else if (ec.value() == EPROTO)
-    {
-      if (state & enable_connection_aborted)
-        return invalid_socket;
-      // Fall through to retry operation.
-    }
-#endif // defined(EPROTO)
-    else
-      return invalid_socket;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return invalid_socket;
-  }
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_accept(socket_type s, void* output_buffer,
-    DWORD address_length, void* addr, std::size_t* addrlen,
-    socket_type new_socket, asio::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_aborted;
-
-  if (!ec)
-  {
-    // Get the address of the peer.
-    if (addr && addrlen)
-    {
-      LPSOCKADDR local_addr = 0;
-      int local_addr_length = 0;
-      LPSOCKADDR remote_addr = 0;
-      int remote_addr_length = 0;
-      GetAcceptExSockaddrs(output_buffer, 0, address_length,
-          address_length, &local_addr, &local_addr_length,
-          &remote_addr, &remote_addr_length);
-      if (static_cast<std::size_t>(remote_addr_length) > *addrlen)
-      {
-        ec = asio::error::invalid_argument;
-      }
-      else
-      {
-        using namespace std; // For memcpy.
-        memcpy(addr, remote_addr, remote_addr_length);
-        *addrlen = static_cast<std::size_t>(remote_addr_length);
-      }
-    }
-
-    // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname
-    // and getpeername will work on the accepted socket.
-    SOCKET update_ctx_param = s;
-    socket_ops::state_type state = 0;
-    socket_ops::setsockopt(new_socket, state,
-          SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
-          &update_ctx_param, sizeof(SOCKET), ec);
-  }
-}
-
-#else // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_accept(socket_type s,
-    state_type state, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, socket_type& new_socket)
-{
-  for (;;)
-  {
-    // Accept the waiting connection.
-    new_socket = socket_ops::accept(s, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (new_socket != invalid_socket)
-      return true;
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Operation failed.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-    {
-      // Fall through to retry operation.
-    }
-    else if (ec == asio::error::connection_aborted)
-    {
-      if (state & enable_connection_aborted)
-        return true;
-      // Fall through to retry operation.
-    }
-#if defined(EPROTO)
-    else if (ec.value() == EPROTO)
-    {
-      if (state & enable_connection_aborted)
-        return true;
-      // Fall through to retry operation.
-    }
-#endif // defined(EPROTO)
-    else
-      return true;
-
-    return false;
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-template <typename SockLenType>
-inline int call_bind(SockLenType msghdr::*,
-    socket_type s, const void* addr, std::size_t addrlen)
-{
-  return ::bind(s, static_cast<const socket_addr_type*>(addr),
-      (SockLenType)addrlen);
-}
-
-int bind(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  int result = call_bind(&msghdr::msg_namelen, s, addr, addrlen);
-  get_last_error(ec, result != 0);
-  return result;
-}
-
-int close(socket_type s, state_type& state,
-    bool destruction, asio::error_code& ec)
-{
-  int result = 0;
-  if (s != invalid_socket)
-  {
-    // We don't want the destructor to block, so set the socket to linger in
-    // the background. If the user doesn't like this behaviour then they need
-    // to explicitly close the socket.
-    if (destruction && (state & user_set_linger))
-    {
-      ::linger opt;
-      opt.l_onoff = 0;
-      opt.l_linger = 0;
-      asio::error_code ignored_ec;
-      socket_ops::setsockopt(s, state, SOL_SOCKET,
-          SO_LINGER, &opt, sizeof(opt), ignored_ec);
-    }
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    result = ::closesocket(s);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    result = ::close(s);
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    get_last_error(ec, result != 0);
-
-    if (result != 0
-        && (ec == asio::error::would_block
-          || ec == asio::error::try_again))
-    {
-      // According to UNIX Network Programming Vol. 1, it is possible for
-      // close() to fail with EWOULDBLOCK under certain circumstances. What
-      // isn't clear is the state of the descriptor after this error. The one
-      // current OS where this behaviour is seen, Windows, says that the socket
-      // remains open. Therefore we'll put the descriptor back into blocking
-      // mode and have another attempt at closing it.
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      ioctl_arg_type arg = 0;
-      ::ioctlsocket(s, FIONBIO, &arg);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-      int flags = ::fcntl(s, F_GETFL, 0);
-      if (flags >= 0)
-        ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
-# else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-      ioctl_arg_type arg = 0;
-      if ((state & possible_dup) == 0)
-      {
-        result = ::ioctl(s, FIONBIO, &arg);
-        get_last_error(ec, result < 0);
-      }
-      if ((state & possible_dup) != 0
-#  if defined(ENOTTY)
-          || ec.value() == ENOTTY
-#  endif // defined(ENOTTY)
-#  if defined(ENOTCAPABLE)
-          || ec.value() == ENOTCAPABLE
-#  endif // defined(ENOTCAPABLE)
-        )
-      {
-        int flags = ::fcntl(s, F_GETFL, 0);
-        if (flags >= 0)
-          ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
-      }
-# endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      state &= ~non_blocking;
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      result = ::closesocket(s);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      result = ::close(s);
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-      get_last_error(ec, result != 0);
-    }
-  }
-
-  return result;
-}
-
-bool set_user_non_blocking(socket_type s,
-    state_type& state, bool value, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctlsocket(s, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-#elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = ::fcntl(s, F_GETFL, 0);
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-  {
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
-    get_last_error(ec, result < 0);
-  }
-#else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = 0;
-  if ((state & possible_dup) == 0)
-  {
-    result = ::ioctl(s, FIONBIO, &arg);
-    get_last_error(ec, result < 0);
-  }
-  if ((state & possible_dup) != 0
-# if defined(ENOTTY)
-      || ec.value() == ENOTTY
-# endif // defined(ENOTTY)
-# if defined(ENOTCAPABLE)
-      || ec.value() == ENOTCAPABLE
-# endif // defined(ENOTCAPABLE)
-    )
-  {
-    result = ::fcntl(s, F_GETFL, 0);
-    get_last_error(ec, result < 0);
-    if (result >= 0)
-    {
-      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
-      get_last_error(ec, result < 0);
-    }
-  }
-#endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-
-  if (result >= 0)
-  {
-    if (value)
-      state |= user_set_non_blocking;
-    else
-    {
-      // Clearing the user-set non-blocking mode always overrides any
-      // internally-set non-blocking flag. Any subsequent asynchronous
-      // operations will need to re-enable non-blocking I/O.
-      state &= ~(user_set_non_blocking | internal_non_blocking);
-    }
-    return true;
-  }
-
-  return false;
-}
-
-bool set_internal_non_blocking(socket_type s,
-    state_type& state, bool value, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-  if (!value && (state & user_set_non_blocking))
-  {
-    // It does not make sense to clear the internal non-blocking flag if the
-    // user still wants non-blocking behaviour. Return an error and let the
-    // caller figure out whether to update the user-set non-blocking flag.
-    ec = asio::error::invalid_argument;
-    return false;
-  }
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = ::ioctlsocket(s, FIONBIO, &arg);
-  get_last_error(ec, result < 0);
-#elif defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  int result = ::fcntl(s, F_GETFL, 0);
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-  {
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
-    get_last_error(ec, result < 0);
-  }
-#else // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = 0;
-  if ((state & possible_dup) == 0)
-  {
-    result = ::ioctl(s, FIONBIO, &arg);
-    get_last_error(ec, result < 0);
-  }
-  if ((state & possible_dup) != 0
-# if defined(ENOTTY)
-      || ec.value() == ENOTTY
-# endif // defined(ENOTTY)
-# if defined(ENOTCAPABLE)
-      || ec.value() == ENOTCAPABLE
-# endif // defined(ENOTCAPABLE)
-    )
-  {
-    result = ::fcntl(s, F_GETFL, 0);
-    get_last_error(ec, result < 0);
-    if (result >= 0)
-    {
-      int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-      result = (flag != result) ? ::fcntl(s, F_SETFL, flag) : 0;
-      get_last_error(ec, result < 0);
-    }
-  }
-#endif // defined(__SYMBIAN32__) || defined(__EMSCRIPTEN__)
-
-  if (result >= 0)
-  {
-    if (value)
-      state |= internal_non_blocking;
-    else
-      state &= ~internal_non_blocking;
-    return true;
-  }
-
-  return false;
-}
-
-int shutdown(socket_type s, int what, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  int result = ::shutdown(s, what);
-  get_last_error(ec, result != 0);
-  return result;
-}
-
-template <typename SockLenType>
-inline int call_connect(SockLenType msghdr::*,
-    socket_type s, const void* addr, std::size_t addrlen)
-{
-  return ::connect(s, static_cast<const socket_addr_type*>(addr),
-      (SockLenType)addrlen);
-}
-
-int connect(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  int result = call_connect(&msghdr::msg_namelen, s, addr, addrlen);
-  get_last_error(ec, result != 0);
-#if defined(__linux__)
-  if (result != 0 && ec == asio::error::try_again)
-  {
-    if (static_cast<const socket_addr_type*>(addr)->sa_family == AF_UNIX)
-      ec = asio::error::in_progress;
-    else
-      ec = asio::error::no_buffer_space;
-  }
-#endif // defined(__linux__)
-  return result;
-}
-
-void sync_connect(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-  // Perform the connect operation.
-  socket_ops::connect(s, addr, addrlen, ec);
-  if (ec != asio::error::in_progress
-      && ec != asio::error::would_block)
-  {
-    // The connect operation finished immediately.
-    return;
-  }
-
-  // Wait for socket to become ready.
-  if (socket_ops::poll_connect(s, -1, ec) < 0)
-    return;
-
-  // Get the error code from the connect operation.
-  int connect_error = 0;
-  size_t connect_error_len = sizeof(connect_error);
-  if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
-        &connect_error, &connect_error_len, ec) == socket_error_retval)
-    return;
-
-  // Return the result of the connect operation.
-  ec = asio::error_code(connect_error,
-      asio::error::get_system_category());
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_connect(socket_type s, asio::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  switch (ec.value())
-  {
-  case ERROR_CONNECTION_REFUSED:
-    ec = asio::error::connection_refused;
-    break;
-  case ERROR_NETWORK_UNREACHABLE:
-    ec = asio::error::network_unreachable;
-    break;
-  case ERROR_HOST_UNREACHABLE:
-    ec = asio::error::host_unreachable;
-    break;
-  case ERROR_SEM_TIMEOUT:
-    ec = asio::error::timed_out;
-    break;
-  default:
-    break;
-  }
-
-  if (!ec)
-  {
-    // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname
-    // and getpeername will work on the connected socket.
-    socket_ops::state_type state = 0;
-    const int so_update_connect_context = 0x7010;
-    socket_ops::setsockopt(s, state, SOL_SOCKET,
-        so_update_connect_context, 0, 0, ec);
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_connect(socket_type s, asio::error_code& ec)
-{
-  // Check if the connect operation has finished. This is required since we may
-  // get spurious readiness notifications from the reactor.
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-  fd_set write_fds;
-  FD_ZERO(&write_fds);
-  FD_SET(s, &write_fds);
-  fd_set except_fds;
-  FD_ZERO(&except_fds);
-  FD_SET(s, &except_fds);
-  timeval zero_timeout;
-  zero_timeout.tv_sec = 0;
-  zero_timeout.tv_usec = 0;
-  int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout);
-#else // defined(ASIO_WINDOWS)
-      // || defined(__CYGWIN__)
-      // || defined(__SYMBIAN32__)
-  pollfd fds;
-  fds.fd = s;
-  fds.events = POLLOUT;
-  fds.revents = 0;
-  int ready = ::poll(&fds, 1, 0);
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-  if (ready == 0)
-  {
-    // The asynchronous connect operation is still in progress.
-    return false;
-  }
-
-  // Get the error code from the connect operation.
-  int connect_error = 0;
-  size_t connect_error_len = sizeof(connect_error);
-  if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
-        &connect_error, &connect_error_len, ec) == 0)
-  {
-    if (connect_error)
-    {
-      ec = asio::error_code(connect_error,
-          asio::error::get_system_category());
-    }
-    else
-      asio::error::clear(ec);
-  }
-
-  return true;
-}
-
-int socketpair(int af, int type, int protocol,
-    socket_type sv[2], asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  (void)(af);
-  (void)(type);
-  (void)(protocol);
-  (void)(sv);
-  ec = asio::error::operation_not_supported;
-  return socket_error_retval;
-#else
-  int result = ::socketpair(af, type, protocol, sv);
-  get_last_error(ec, result != 0);
-  return result;
-#endif
-}
-
-bool sockatmark(socket_type s, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-#if defined(SIOCATMARK)
-  ioctl_arg_type value = 0;
-# if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = ::ioctlsocket(s, SIOCATMARK, &value);
-# else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = ::ioctl(s, SIOCATMARK, &value);
-# endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  get_last_error(ec, result < 0);
-# if defined(ENOTTY)
-  if (ec.value() == ENOTTY)
-    ec = asio::error::not_socket;
-# endif // defined(ENOTTY)
-#else // defined(SIOCATMARK)
-  int value = ::sockatmark(s);
-  get_last_error(ec, value < 0);
-#endif // defined(SIOCATMARK)
-
-  return ec ? false : value != 0;
-}
-
-size_t available(socket_type s, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  ioctl_arg_type value = 0;
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = ::ioctlsocket(s, FIONREAD, &value);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = ::ioctl(s, FIONREAD, &value);
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  get_last_error(ec, result < 0);
-#if defined(ENOTTY)
-  if (ec.value() == ENOTTY)
-    ec = asio::error::not_socket;
-#endif // defined(ENOTTY)
-
-  return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
-}
-
-int listen(socket_type s, int backlog, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  int result = ::listen(s, backlog);
-  get_last_error(ec, result != 0);
-  return result;
-}
-
-inline void init_buf_iov_base(void*& base, void* addr)
-{
-  base = addr;
-}
-
-template <typename T>
-inline void init_buf_iov_base(T& base, void* addr)
-{
-  base = static_cast<T>(addr);
-}
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef WSABUF buf;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef iovec buf;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-void init_buf(buf& b, void* data, size_t size)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  b.buf = static_cast<char*>(data);
-  b.len = static_cast<u_long>(size);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  init_buf_iov_base(b.iov_base, data);
-  b.iov_len = size;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-void init_buf(buf& b, const void* data, size_t size)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  b.buf = static_cast<char*>(const_cast<void*>(data));
-  b.len = static_cast<u_long>(size);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  init_buf_iov_base(b.iov_base, const_cast<void*>(data));
-  b.iov_len = size;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-inline void init_msghdr_msg_name(void*& name, void* addr)
-{
-  name = static_cast<socket_addr_type*>(addr);
-}
-
-inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
-{
-  name = const_cast<socket_addr_type*>(addr);
-}
-
-template <typename T>
-inline void init_msghdr_msg_name(T& name, void* addr)
-{
-  name = static_cast<T>(addr);
-}
-
-template <typename T>
-inline void init_msghdr_msg_name(T& name, const void* addr)
-{
-  name = static_cast<T>(const_cast<void*>(addr));
-}
-
-signed_size_type recv(socket_type s, buf* bufs, size_t count,
-    int flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Receive some data.
-  DWORD recv_buf_count = static_cast<DWORD>(count);
-  DWORD bytes_transferred = 0;
-  DWORD recv_flags = flags;
-  int result = ::WSARecv(s, bufs, recv_buf_count,
-      &bytes_transferred, &recv_flags, 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-    result = 0;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  msg.msg_iov = bufs;
-  msg.msg_iovlen = static_cast<int>(count);
-  signed_size_type result = ::recvmsg(s, &msg, flags);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-signed_size_type recv1(socket_type s, void* data, size_t size,
-    int flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Receive some data.
-  WSABUF buf;
-  buf.buf = const_cast<char*>(static_cast<const char*>(data));
-  buf.len = static_cast<ULONG>(size);
-  DWORD bytes_transferred = 0;
-  DWORD recv_flags = flags;
-  int result = ::WSARecv(s, &buf, 1,
-      &bytes_transferred, &recv_flags, 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-    result = 0;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  signed_size_type result = ::recv(s, static_cast<char*>(data), size, flags);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-size_t sync_recv(socket_type s, state_type state, buf* bufs,
-    size_t count, int flags, bool all_empty, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (all_empty && (state & stream_oriented))
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
-
-    // Check for EOF.
-    if ((state & stream_oriented) && bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-size_t sync_recv1(socket_type s, state_type state, void* data,
-    size_t size, int flags, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (size == 0 && (state & stream_oriented))
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec);
-
-    // Check for EOF.
-    if ((state & stream_oriented) && bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_recv(state_type state,
-    const weak_cancel_token_type& cancel_token, bool all_empty,
-    asio::error_code& ec, size_t bytes_transferred)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-  {
-    if (cancel_token.expired())
-      ec = asio::error::operation_aborted;
-    else
-      ec = asio::error::connection_reset;
-  }
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-  {
-    ec = asio::error::connection_refused;
-  }
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-  {
-    asio::error::clear(ec);
-  }
-
-  // Check for connection closed.
-  else if (!ec && bytes_transferred == 0
-      && (state & stream_oriented) != 0
-      && !all_empty)
-  {
-    ec = asio::error::eof;
-  }
-}
-
-#else // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_recv(socket_type s,
-    buf* bufs, size_t count, int flags, bool is_stream,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
-
-    // Check for end of stream.
-    if (is_stream && bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_recv1(socket_type s,
-    void* data, size_t size, int flags, bool is_stream,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec);
-
-    // Check for end of stream.
-    if (is_stream && bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
-    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Receive some data.
-  DWORD recv_buf_count = static_cast<DWORD>(count);
-  DWORD bytes_transferred = 0;
-  DWORD recv_flags = flags;
-  int tmp_addrlen = (int)*addrlen;
-  int result = ::WSARecvFrom(s, bufs, recv_buf_count, &bytes_transferred,
-      &recv_flags, static_cast<socket_addr_type*>(addr), &tmp_addrlen, 0, 0);
-  get_last_error(ec, true);
-  *addrlen = (std::size_t)tmp_addrlen;
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-    result = 0;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  init_msghdr_msg_name(msg.msg_name, addr);
-  msg.msg_namelen = static_cast<int>(*addrlen);
-  msg.msg_iov = bufs;
-  msg.msg_iovlen = static_cast<int>(count);
-  signed_size_type result = ::recvmsg(s, &msg, flags);
-  get_last_error(ec, result < 0);
-  *addrlen = msg.msg_namelen;
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-template <typename SockLenType>
-inline signed_size_type call_recvfrom(SockLenType msghdr::*, socket_type s,
-    void* data, size_t size, int flags, void* addr, std::size_t* addrlen)
-{
-  SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
-  signed_size_type result = ::recvfrom(s, static_cast<char*>(data), size,
-      flags, static_cast<socket_addr_type*>(addr), addrlen ? &tmp_addrlen : 0);
-  if (addrlen)
-    *addrlen = (std::size_t)tmp_addrlen;
-  return result;
-}
-
-signed_size_type recvfrom1(socket_type s, void* data, size_t size,
-    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Receive some data.
-  WSABUF buf;
-  buf.buf = static_cast<char*>(data);
-  buf.len = static_cast<ULONG>(size);
-  DWORD bytes_transferred = 0;
-  DWORD recv_flags = flags;
-  int tmp_addrlen = (int)*addrlen;
-  int result = ::WSARecvFrom(s, &buf, 1, &bytes_transferred, &recv_flags,
-      static_cast<socket_addr_type*>(addr), &tmp_addrlen, 0, 0);
-  get_last_error(ec, true);
-  *addrlen = (std::size_t)tmp_addrlen;
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-    result = 0;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  signed_size_type result = call_recvfrom(&msghdr::msg_namelen,
-      s, data, size, flags, addr, addrlen);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count,
-    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::recvfrom(
-        s, bufs, count, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-size_t sync_recvfrom1(socket_type s, state_type state, void* data, size_t size,
-    int flags, void* addr, std::size_t* addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::recvfrom1(
-        s, data, size, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_recvfrom(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-  {
-    if (cancel_token.expired())
-      ec = asio::error::operation_aborted;
-    else
-      ec = asio::error::connection_reset;
-  }
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-  {
-    ec = asio::error::connection_refused;
-  }
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-  {
-    asio::error::clear(ec);
-  }
-}
-
-#else // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_recvfrom(socket_type s, buf* bufs,
-    size_t count, int flags, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = socket_ops::recvfrom(
-        s, bufs, count, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_recvfrom1(socket_type s, void* data,
-    size_t size, int flags, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = socket_ops::recvfrom1(
-        s, data, size, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
-    int in_flags, int& out_flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  out_flags = 0;
-  return socket_ops::recv(s, bufs, count, in_flags, ec);
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  msg.msg_iov = bufs;
-  msg.msg_iovlen = static_cast<int>(count);
-  signed_size_type result = ::recvmsg(s, &msg, in_flags);
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-    out_flags = msg.msg_flags;
-  else
-    out_flags = 0;
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-size_t sync_recvmsg(socket_type s, state_type state,
-    buf* bufs, size_t count, int in_flags, int& out_flags,
-    asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::recvmsg(
-        s, bufs, count, in_flags, out_flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_recvmsg(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-  {
-    if (cancel_token.expired())
-      ec = asio::error::operation_aborted;
-    else
-      ec = asio::error::connection_reset;
-  }
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-  {
-    ec = asio::error::connection_refused;
-  }
-  else if (ec.value() == WSAEMSGSIZE || ec.value() == ERROR_MORE_DATA)
-  {
-    asio::error::clear(ec);
-  }
-}
-
-#else // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_recvmsg(socket_type s,
-    buf* bufs, size_t count, int in_flags, int& out_flags,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    signed_size_type bytes = socket_ops::recvmsg(
-        s, bufs, count, in_flags, out_flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-signed_size_type send(socket_type s, const buf* bufs, size_t count,
-    int flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Send the data.
-  DWORD send_buf_count = static_cast<DWORD>(count);
-  DWORD bytes_transferred = 0;
-  DWORD send_flags = flags;
-  int result = ::WSASend(s, const_cast<buf*>(bufs),
-        send_buf_count, &bytes_transferred, send_flags, 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  msg.msg_iov = const_cast<buf*>(bufs);
-  msg.msg_iovlen = static_cast<int>(count);
-#if defined(ASIO_HAS_MSG_NOSIGNAL)
-  flags |= MSG_NOSIGNAL;
-#endif // defined(ASIO_HAS_MSG_NOSIGNAL)
-  signed_size_type result = ::sendmsg(s, &msg, flags);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-signed_size_type send1(socket_type s, const void* data, size_t size,
-    int flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Send the data.
-  WSABUF buf;
-  buf.buf = const_cast<char*>(static_cast<const char*>(data));
-  buf.len = static_cast<ULONG>(size);
-  DWORD bytes_transferred = 0;
-  DWORD send_flags = flags;
-  int result = ::WSASend(s, &buf, 1,
-        &bytes_transferred, send_flags, 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#if defined(ASIO_HAS_MSG_NOSIGNAL)
-  flags |= MSG_NOSIGNAL;
-#endif // defined(ASIO_HAS_MSG_NOSIGNAL)
-  signed_size_type result = ::send(s,
-      static_cast<const char*>(data), size, flags);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-size_t sync_send(socket_type s, state_type state, const buf* bufs,
-    size_t count, int flags, bool all_empty, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes to a stream is a no-op.
-  if (all_empty && (state & stream_oriented))
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-size_t sync_send1(socket_type s, state_type state, const void* data,
-    size_t size, int flags, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes to a stream is a no-op.
-  if (size == 0 && (state & stream_oriented))
-  {
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-#if defined(ASIO_HAS_IOCP)
-
-void complete_iocp_send(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-  {
-    if (cancel_token.expired())
-      ec = asio::error::operation_aborted;
-    else
-      ec = asio::error::connection_reset;
-  }
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-  {
-    ec = asio::error::connection_refused;
-  }
-}
-
-#else // defined(ASIO_HAS_IOCP)
-
-bool non_blocking_send(socket_type s,
-    const buf* bufs, size_t count, int flags,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_send1(socket_type s,
-    const void* data, size_t size, int flags,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // defined(ASIO_HAS_IOCP)
-
-signed_size_type sendto(socket_type s, const buf* bufs,
-    size_t count, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Send the data.
-  DWORD send_buf_count = static_cast<DWORD>(count);
-  DWORD bytes_transferred = 0;
-  int result = ::WSASendTo(s, const_cast<buf*>(bufs),
-        send_buf_count, &bytes_transferred, flags,
-        static_cast<const socket_addr_type*>(addr),
-        static_cast<int>(addrlen), 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  init_msghdr_msg_name(msg.msg_name, addr);
-  msg.msg_namelen = static_cast<int>(addrlen);
-  msg.msg_iov = const_cast<buf*>(bufs);
-  msg.msg_iovlen = static_cast<int>(count);
-#if defined(ASIO_HAS_MSG_NOSIGNAL)
-  flags |= MSG_NOSIGNAL;
-#endif // defined(ASIO_HAS_MSG_NOSIGNAL)
-  signed_size_type result = ::sendmsg(s, &msg, flags);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-template <typename SockLenType>
-inline signed_size_type call_sendto(SockLenType msghdr::*,
-    socket_type s, const void* data, size_t size, int flags,
-    const void* addr, std::size_t addrlen)
-{
-  return ::sendto(s, static_cast<char*>(const_cast<void*>(data)), size, flags,
-      static_cast<const socket_addr_type*>(addr), (SockLenType)addrlen);
-}
-
-signed_size_type sendto1(socket_type s, const void* data,
-    size_t size, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  // Send the data.
-  WSABUF buf;
-  buf.buf = const_cast<char*>(static_cast<const char*>(data));
-  buf.len = static_cast<ULONG>(size);
-  DWORD bytes_transferred = 0;
-  int result = ::WSASendTo(s, &buf, 1, &bytes_transferred, flags,
-      static_cast<const socket_addr_type*>(addr),
-      static_cast<int>(addrlen), 0, 0);
-  get_last_error(ec, true);
-  if (ec.value() == ERROR_NETNAME_DELETED)
-    ec = asio::error::connection_reset;
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    ec = asio::error::connection_refused;
-  if (result != 0)
-    return socket_error_retval;
-  asio::error::clear(ec);
-  return bytes_transferred;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#if defined(ASIO_HAS_MSG_NOSIGNAL)
-  flags |= MSG_NOSIGNAL;
-#endif // defined(ASIO_HAS_MSG_NOSIGNAL)
-  signed_size_type result = call_sendto(&msghdr::msg_namelen,
-      s, data, size, flags, addr, addrlen);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-size_t sync_sendto(socket_type s, state_type state,
-    const buf* bufs, size_t count, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::sendto(
-        s, bufs, count, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-size_t sync_sendto1(socket_type s, state_type state,
-    const void* data, size_t size, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    signed_size_type bytes = socket_ops::sendto1(
-        s, data, size, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
-      return 0;
-  }
-}
-
-#if !defined(ASIO_HAS_IOCP)
-
-bool non_blocking_sendto(socket_type s,
-    const buf* bufs, size_t count, int flags,
-    const void* addr, std::size_t addrlen,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = socket_ops::sendto(
-        s, bufs, count, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-bool non_blocking_sendto1(socket_type s,
-    const void* data, size_t size, int flags,
-    const void* addr, std::size_t addrlen,
-    asio::error_code& ec, size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    signed_size_type bytes = socket_ops::sendto1(
-        s, data, size, flags, addr, addrlen, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-    {
-      bytes_transferred = bytes;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation failed.
-    bytes_transferred = 0;
-    return true;
-  }
-}
-
-#endif // !defined(ASIO_HAS_IOCP)
-
-socket_type socket(int af, int type, int protocol,
-    asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  socket_type s = ::WSASocketW(af, type, protocol, 0, 0, WSA_FLAG_OVERLAPPED);
-  get_last_error(ec, s == invalid_socket);
-  if (s == invalid_socket)
-    return s;
-
-  if (af == ASIO_OS_DEF(AF_INET6))
-  {
-    // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to
-    // false. This will only succeed on Windows Vista and later versions of
-    // Windows, where a dual-stack IPv4/v6 implementation is available.
-    DWORD optval = 0;
-    ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
-        reinterpret_cast<const char*>(&optval), sizeof(optval));
-  }
-
-  return s;
-#elif defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
-  socket_type s = ::socket(af, type, protocol);
-  get_last_error(ec, s == invalid_socket);
-  if (s == invalid_socket)
-    return s;
-
-  int optval = 1;
-  int result = ::setsockopt(s, SOL_SOCKET,
-      SO_NOSIGPIPE, &optval, sizeof(optval));
-  get_last_error(ec, result != 0);
-  if (result != 0)
-  {
-    ::close(s);
-    return invalid_socket;
-  }
-
-  return s;
-#else
-  int s = ::socket(af, type, protocol);
-  get_last_error(ec, s < 0);
-  return s;
-#endif
-}
-
-template <typename SockLenType>
-inline int call_setsockopt(SockLenType msghdr::*,
-    socket_type s, int level, int optname,
-    const void* optval, std::size_t optlen)
-{
-  return ::setsockopt(s, level, optname,
-      (const char*)optval, (SockLenType)optlen);
-}
-
-int setsockopt(socket_type s, state_type& state, int level, int optname,
-    const void* optval, std::size_t optlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  if (level == custom_socket_option_level && optname == always_fail_option)
-  {
-    ec = asio::error::invalid_argument;
-    return socket_error_retval;
-  }
-
-  if (level == custom_socket_option_level
-      && optname == enable_connection_aborted_option)
-  {
-    if (optlen != sizeof(int))
-    {
-      ec = asio::error::invalid_argument;
-      return socket_error_retval;
-    }
-
-    if (*static_cast<const int*>(optval))
-      state |= enable_connection_aborted;
-    else
-      state &= ~enable_connection_aborted;
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  if (level == SOL_SOCKET && optname == SO_LINGER)
-    state |= user_set_linger;
-
-#if defined(__BORLANDC__)
-  // Mysteriously, using the getsockopt and setsockopt functions directly with
-  // Borland C++ results in incorrect values being set and read. The bug can be
-  // worked around by using function addresses resolved with GetProcAddress.
-  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
-  {
-    typedef int (WSAAPI *sso_t)(SOCKET, int, int, const char*, int);
-    if (sso_t sso = (sso_t)::GetProcAddress(winsock_module, "setsockopt"))
-    {
-      int result = sso(s, level, optname,
-            reinterpret_cast<const char*>(optval),
-            static_cast<int>(optlen));
-      get_last_error(ec, result != 0);
-      return result;
-    }
-  }
-  ec = asio::error::fault;
-  return socket_error_retval;
-#else // defined(__BORLANDC__)
-  int result = call_setsockopt(&msghdr::msg_namelen,
-        s, level, optname, optval, optlen);
-  get_last_error(ec, result != 0);
-  if (result == 0)
-  {
-#if defined(__MACH__) && defined(__APPLE__) \
-  || defined(__NetBSD__) || defined(__FreeBSD__) \
-  || defined(__OpenBSD__) || defined(__QNX__)
-    // To implement portable behaviour for SO_REUSEADDR with UDP sockets we
-    // need to also set SO_REUSEPORT on BSD-based platforms.
-    if ((state & datagram_oriented)
-        && level == SOL_SOCKET && optname == SO_REUSEADDR)
-    {
-      call_setsockopt(&msghdr::msg_namelen, s,
-          SOL_SOCKET, SO_REUSEPORT, optval, optlen);
-    }
-#endif
-  }
-
-  return result;
-#endif // defined(__BORLANDC__)
-}
-
-template <typename SockLenType>
-inline int call_getsockopt(SockLenType msghdr::*,
-    socket_type s, int level, int optname,
-    void* optval, std::size_t* optlen)
-{
-  SockLenType tmp_optlen = (SockLenType)*optlen;
-  int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
-  *optlen = (std::size_t)tmp_optlen;
-  return result;
-}
-
-int getsockopt(socket_type s, state_type state, int level, int optname,
-    void* optval, size_t* optlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  if (level == custom_socket_option_level && optname == always_fail_option)
-  {
-    ec = asio::error::invalid_argument;
-    return socket_error_retval;
-  }
-
-  if (level == custom_socket_option_level
-      && optname == enable_connection_aborted_option)
-  {
-    if (*optlen != sizeof(int))
-    {
-      ec = asio::error::invalid_argument;
-      return socket_error_retval;
-    }
-
-    *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
-    asio::error::clear(ec);
-    return 0;
-  }
-
-#if defined(__BORLANDC__)
-  // Mysteriously, using the getsockopt and setsockopt functions directly with
-  // Borland C++ results in incorrect values being set and read. The bug can be
-  // worked around by using function addresses resolved with GetProcAddress.
-  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
-  {
-    typedef int (WSAAPI *gso_t)(SOCKET, int, int, char*, int*);
-    if (gso_t gso = (gso_t)::GetProcAddress(winsock_module, "getsockopt"))
-    {
-      int tmp_optlen = static_cast<int>(*optlen);
-      int result = gso(s, level, optname,
-            reinterpret_cast<char*>(optval), &tmp_optlen);
-      get_last_error(ec, result != 0);
-      *optlen = static_cast<size_t>(tmp_optlen);
-      if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
-          && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
-      {
-        // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are
-        // only supported on Windows Vista and later. To simplify program logic
-        // we will fake success of getting this option and specify that the
-        // value is non-zero (i.e. true). This corresponds to the behavior of
-        // IPv6 sockets on Windows platforms pre-Vista.
-        *static_cast<DWORD*>(optval) = 1;
-        asio::error::clear(ec);
-      }
-      return result;
-    }
-  }
-  ec = asio::error::fault;
-  return socket_error_retval;
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = call_getsockopt(&msghdr::msg_namelen,
-        s, level, optname, optval, optlen);
-  get_last_error(ec, result != 0);
-  if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
-      && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
-  {
-    // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are only
-    // supported on Windows Vista and later. To simplify program logic we will
-    // fake success of getting this option and specify that the value is
-    // non-zero (i.e. true). This corresponds to the behavior of IPv6 sockets
-    // on Windows platforms pre-Vista.
-    *static_cast<DWORD*>(optval) = 1;
-    asio::error::clear(ec);
-  }
-  return result;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = call_getsockopt(&msghdr::msg_namelen,
-        s, level, optname, optval, optlen);
-  get_last_error(ec, result != 0);
-#if defined(__linux__)
-  if (result == 0 && level == SOL_SOCKET && *optlen == sizeof(int)
-      && (optname == SO_SNDBUF || optname == SO_RCVBUF))
-  {
-    // On Linux, setting SO_SNDBUF or SO_RCVBUF to N actually causes the kernel
-    // to set the buffer size to N*2. Linux puts additional stuff into the
-    // buffers so that only about half is actually available to the application.
-    // The retrieved value is divided by 2 here to make it appear as though the
-    // correct value has been set.
-    *static_cast<int*>(optval) /= 2;
-  }
-#endif // defined(__linux__)
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-template <typename SockLenType>
-inline int call_getpeername(SockLenType msghdr::*,
-    socket_type s, void* addr, std::size_t* addrlen)
-{
-  SockLenType tmp_addrlen = (SockLenType)*addrlen;
-  int result = ::getpeername(s,
-      static_cast<socket_addr_type*>(addr), &tmp_addrlen);
-  *addrlen = (std::size_t)tmp_addrlen;
-  return result;
-}
-
-int getpeername(socket_type s, void* addr, std::size_t* addrlen,
-    bool cached, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP) \
-  || defined(__CYGWIN__)
-  if (cached)
-  {
-    // Check if socket is still connected.
-    DWORD connect_time = 0;
-    size_t connect_time_len = sizeof(connect_time);
-    if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME,
-          &connect_time, &connect_time_len, ec) == socket_error_retval)
-    {
-      return socket_error_retval;
-    }
-    if (connect_time == 0xFFFFFFFF)
-    {
-      ec = asio::error::not_connected;
-      return socket_error_retval;
-    }
-
-    // The cached value is still valid.
-    asio::error::clear(ec);
-    return 0;
-  }
-#else // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
-      // || defined(__CYGWIN__)
-  (void)cached;
-#endif // defined(ASIO_WINDOWS) && !defined(ASIO_WINDOWS_APP)
-       // || defined(__CYGWIN__)
-
-  int result = call_getpeername(&msghdr::msg_namelen, s, addr, addrlen);
-  get_last_error(ec, result != 0);
-  return result;
-}
-
-template <typename SockLenType>
-inline int call_getsockname(SockLenType msghdr::*,
-    socket_type s, void* addr, std::size_t* addrlen)
-{
-  SockLenType tmp_addrlen = (SockLenType)*addrlen;
-  int result = ::getsockname(s,
-      static_cast<socket_addr_type*>(addr), &tmp_addrlen);
-  *addrlen = (std::size_t)tmp_addrlen;
-  return result;
-}
-
-int getsockname(socket_type s, void* addr,
-    std::size_t* addrlen, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-  int result = call_getsockname(&msghdr::msg_namelen, s, addr, addrlen);
-  get_last_error(ec, result != 0);
-  return result;
-}
-
-int ioctl(socket_type s, state_type& state, int cmd,
-    ioctl_arg_type* arg, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  int result = ::ioctlsocket(s, cmd, arg);
-#elif defined(__MACH__) && defined(__APPLE__) \
-  || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
-  int result = ::ioctl(s, static_cast<unsigned int>(cmd), arg);
-#else
-  int result = ::ioctl(s, cmd, arg);
-#endif
-  get_last_error(ec, result < 0);
-  if (result >= 0)
-  {
-    // When updating the non-blocking mode we always perform the ioctl syscall,
-    // even if the flags would otherwise indicate that the socket is already in
-    // the correct state. This ensures that the underlying socket is put into
-    // the state that has been requested by the user. If the ioctl syscall was
-    // successful then we need to update the flags to match.
-    if (cmd == static_cast<int>(FIONBIO))
-    {
-      if (*arg)
-      {
-        state |= user_set_non_blocking;
-      }
-      else
-      {
-        // Clearing the non-blocking mode always overrides any internally-set
-        // non-blocking flag. Any subsequent asynchronous operations will need
-        // to re-enable non-blocking I/O.
-        state &= ~(user_set_non_blocking | internal_non_blocking);
-      }
-    }
-  }
-
-  return result;
-}
-
-int select(int nfds, fd_set* readfds, fd_set* writefds,
-    fd_set* exceptfds, timeval* timeout, asio::error_code& ec)
-{
-#if defined(__EMSCRIPTEN__)
-  exceptfds = 0;
-#endif // defined(__EMSCRIPTEN__)
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (!readfds && !writefds && !exceptfds && timeout)
-  {
-    DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
-    if (milliseconds == 0)
-      milliseconds = 1; // Force context switch.
-    ::Sleep(milliseconds);
-    asio::error::clear(ec);
-    return 0;
-  }
-
-  // The select() call allows timeout values measured in microseconds, but the
-  // system clock (as wrapped by boost::posix_time::microsec_clock) typically
-  // has a resolution of 10 milliseconds. This can lead to a spinning select
-  // reactor, meaning increased CPU usage, when waiting for the earliest
-  // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight
-  // spin we'll use a minimum timeout of 1 millisecond.
-  if (timeout && timeout->tv_sec == 0
-      && timeout->tv_usec > 0 && timeout->tv_usec < 1000)
-    timeout->tv_usec = 1000;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#if defined(__hpux) && defined(__SELECT)
-  timespec ts;
-  ts.tv_sec = timeout ? timeout->tv_sec : 0;
-  ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0;
-  int result = ::pselect(nfds, readfds,
-        writefds, exceptfds, timeout ? &ts : 0, 0);
-#else
-  int result = ::select(nfds, readfds, writefds, exceptfds, timeout);
-#endif
-  get_last_error(ec, result < 0);
-  return result;
-}
-
-int poll_read(socket_type s, state_type state,
-    int msec, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-  fd_set fds;
-  FD_ZERO(&fds);
-  FD_SET(s, &fds);
-  timeval timeout_obj;
-  timeval* timeout;
-  if (state & user_set_non_blocking)
-  {
-    timeout_obj.tv_sec = 0;
-    timeout_obj.tv_usec = 0;
-    timeout = &timeout_obj;
-  }
-  else if (msec >= 0)
-  {
-    timeout_obj.tv_sec = msec / 1000;
-    timeout_obj.tv_usec = (msec % 1000) * 1000;
-    timeout = &timeout_obj;
-  }
-  else
-    timeout = 0;
-  int result = ::select(s + 1, &fds, 0, 0, timeout);
-  get_last_error(ec, result < 0);
-#else // defined(ASIO_WINDOWS)
-      // || defined(__CYGWIN__)
-      // || defined(__SYMBIAN32__)
-  pollfd fds;
-  fds.fd = s;
-  fds.events = POLLIN;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-int poll_write(socket_type s, state_type state,
-    int msec, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-  fd_set fds;
-  FD_ZERO(&fds);
-  FD_SET(s, &fds);
-  timeval timeout_obj;
-  timeval* timeout;
-  if (state & user_set_non_blocking)
-  {
-    timeout_obj.tv_sec = 0;
-    timeout_obj.tv_usec = 0;
-    timeout = &timeout_obj;
-  }
-  else if (msec >= 0)
-  {
-    timeout_obj.tv_sec = msec / 1000;
-    timeout_obj.tv_usec = (msec % 1000) * 1000;
-    timeout = &timeout_obj;
-  }
-  else
-    timeout = 0;
-  int result = ::select(s + 1, 0, &fds, 0, timeout);
-  get_last_error(ec, result < 0);
-#else // defined(ASIO_WINDOWS)
-      // || defined(__CYGWIN__)
-      // || defined(__SYMBIAN32__)
-  pollfd fds;
-  fds.fd = s;
-  fds.events = POLLOUT;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-int poll_error(socket_type s, state_type state,
-    int msec, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-  fd_set fds;
-  FD_ZERO(&fds);
-  FD_SET(s, &fds);
-  timeval timeout_obj;
-  timeval* timeout;
-  if (state & user_set_non_blocking)
-  {
-    timeout_obj.tv_sec = 0;
-    timeout_obj.tv_usec = 0;
-    timeout = &timeout_obj;
-  }
-  else if (msec >= 0)
-  {
-    timeout_obj.tv_sec = msec / 1000;
-    timeout_obj.tv_usec = (msec % 1000) * 1000;
-    timeout = &timeout_obj;
-  }
-  else
-    timeout = 0;
-  int result = ::select(s + 1, 0, 0, &fds, timeout);
-  get_last_error(ec, result < 0);
-#else // defined(ASIO_WINDOWS)
-      // || defined(__CYGWIN__)
-      // || defined(__SYMBIAN32__)
-  pollfd fds;
-  fds.fd = s;
-  fds.events = POLLPRI | POLLERR | POLLHUP;
-  fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : msec;
-  int result = ::poll(&fds, 1, timeout);
-  get_last_error(ec, result < 0);
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-  if (result == 0)
-    if (state & user_set_non_blocking)
-      ec = asio::error::would_block;
-  return result;
-}
-
-int poll_connect(socket_type s, int msec, asio::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = asio::error::bad_descriptor;
-    return socket_error_retval;
-  }
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-  fd_set write_fds;
-  FD_ZERO(&write_fds);
-  FD_SET(s, &write_fds);
-  fd_set except_fds;
-  FD_ZERO(&except_fds);
-  FD_SET(s, &except_fds);
-  timeval timeout_obj;
-  timeval* timeout;
-  if (msec >= 0)
-  {
-    timeout_obj.tv_sec = msec / 1000;
-    timeout_obj.tv_usec = (msec % 1000) * 1000;
-    timeout = &timeout_obj;
-  }
-  else
-    timeout = 0;
-  int result = ::select(s + 1, 0, &write_fds, &except_fds, timeout);
-  get_last_error(ec, result < 0);
-  return result;
-#else // defined(ASIO_WINDOWS)
-      // || defined(__CYGWIN__)
-      // || defined(__SYMBIAN32__)
-  pollfd fds;
-  fds.fd = s;
-  fds.events = POLLOUT;
-  fds.revents = 0;
-  int result = ::poll(&fds, 1, msec);
-  get_last_error(ec, result < 0);
-  return result;
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-}
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-const char* inet_ntop(int af, const void* src, char* dest, size_t length,
-    unsigned long scope_id, asio::error_code& ec)
-{
-  clear_last_error();
-#if defined(ASIO_WINDOWS_RUNTIME)
-  using namespace std; // For sprintf.
-  const unsigned char* bytes = static_cast<const unsigned char*>(src);
-  if (af == ASIO_OS_DEF(AF_INET))
-  {
-    sprintf_s(dest, length, "%u.%u.%u.%u",
-        bytes[0], bytes[1], bytes[2], bytes[3]);
-    return dest;
-  }
-  else if (af == ASIO_OS_DEF(AF_INET6))
-  {
-    size_t n = 0, b = 0, z = 0;
-    while (n < length && b < 16)
-    {
-      if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0)
-      {
-        do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0);
-        n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z;
-      }
-      else
-      {
-        n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "",
-            (static_cast<u_long_type>(bytes[b]) << 8) | bytes[b + 1]);
-        b += 2;
-      }
-    }
-    if (scope_id)
-      n += sprintf_s(dest + n, length - n, "%%%lu", scope_id);
-    return dest;
-  }
-  else
-  {
-    ec = asio::error::address_family_not_supported;
-    return 0;
-  }
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  using namespace std; // For memcpy.
-
-  if (af != ASIO_OS_DEF(AF_INET) && af != ASIO_OS_DEF(AF_INET6))
-  {
-    ec = asio::error::address_family_not_supported;
-    return 0;
-  }
-
-  union
-  {
-    socket_addr_type base;
-    sockaddr_storage_type storage;
-    sockaddr_in4_type v4;
-    sockaddr_in6_type v6;
-  } address;
-  DWORD address_length;
-  if (af == ASIO_OS_DEF(AF_INET))
-  {
-    address_length = sizeof(sockaddr_in4_type);
-    address.v4.sin_family = ASIO_OS_DEF(AF_INET);
-    address.v4.sin_port = 0;
-    memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type));
-  }
-  else // AF_INET6
-  {
-    address_length = sizeof(sockaddr_in6_type);
-    address.v6.sin6_family = ASIO_OS_DEF(AF_INET6);
-    address.v6.sin6_port = 0;
-    address.v6.sin6_flowinfo = 0;
-    address.v6.sin6_scope_id = scope_id;
-    memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type));
-  }
-
-  DWORD string_length = static_cast<DWORD>(length);
-#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
-  LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
-  int result = ::WSAAddressToStringW(&address.base,
-        address_length, 0, string_buffer, &string_length);
-  get_last_error(ec, true);
-  ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1,
-      dest, static_cast<int>(length), 0, 0);
-#else
-  int result = ::WSAAddressToStringA(&address.base,
-      address_length, 0, dest, &string_length);
-  get_last_error(ec, true);
-#endif
-
-  // Windows may set error code on success.
-  if (result != socket_error_retval)
-    asio::error::clear(ec);
-
-  // Windows may not set an error code on failure.
-  else if (result == socket_error_retval && !ec)
-    ec = asio::error::invalid_argument;
-
-  return result == socket_error_retval ? 0 : dest;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  const char* result = ::inet_ntop(af, src, dest, static_cast<int>(length));
-  get_last_error(ec, true);
-  if (result == 0 && !ec)
-    ec = asio::error::invalid_argument;
-  if (result != 0 && af == ASIO_OS_DEF(AF_INET6) && scope_id != 0)
-  {
-    using namespace std; // For strcat and sprintf.
-    char if_name[(IF_NAMESIZE > 21 ? IF_NAMESIZE : 21) + 1] = "%";
-    const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
-    bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
-        && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
-    bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
-        && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
-    if ((!is_link_local && !is_multicast_link_local)
-        || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
-#if defined(ASIO_HAS_SNPRINTF)
-      snprintf(if_name + 1, sizeof(if_name) - 1, "%lu", scope_id);
-#else // defined(ASIO_HAS_SNPRINTF)
-      sprintf(if_name + 1, "%lu", scope_id);
-#endif // defined(ASIO_HAS_SNPRINTF)
-    strcat(dest, if_name);
-  }
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-int inet_pton(int af, const char* src, void* dest,
-    unsigned long* scope_id, asio::error_code& ec)
-{
-  clear_last_error();
-#if defined(ASIO_WINDOWS_RUNTIME)
-  using namespace std; // For sscanf.
-  unsigned char* bytes = static_cast<unsigned char*>(dest);
-  if (af == ASIO_OS_DEF(AF_INET))
-  {
-    unsigned int b0, b1, b2, b3;
-    if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4)
-    {
-      ec = asio::error::invalid_argument;
-      return -1;
-    }
-    if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255)
-    {
-      ec = asio::error::invalid_argument;
-      return -1;
-    }
-    bytes[0] = static_cast<unsigned char>(b0);
-    bytes[1] = static_cast<unsigned char>(b1);
-    bytes[2] = static_cast<unsigned char>(b2);
-    bytes[3] = static_cast<unsigned char>(b3);
-    asio::error::clear(ec);
-    return 1;
-  }
-  else if (af == ASIO_OS_DEF(AF_INET6))
-  {
-    unsigned char* bytes = static_cast<unsigned char*>(dest);
-    std::memset(bytes, 0, 16);
-    unsigned char back_bytes[16] = { 0 };
-    int num_front_bytes = 0, num_back_bytes = 0;
-    const char* p = src;
-
-    enum { fword, fcolon, bword, scope, done } state = fword;
-    unsigned long current_word = 0;
-    while (state != done)
-    {
-      if (current_word > 0xFFFF)
-      {
-        ec = asio::error::invalid_argument;
-        return -1;
-      }
-
-      switch (state)
-      {
-      case fword:
-        if (*p >= '0' && *p <= '9')
-          current_word = current_word * 16 + *p++ - '0';
-        else if (*p >= 'a' && *p <= 'f')
-          current_word = current_word * 16 + *p++ - 'a' + 10;
-        else if (*p >= 'A' && *p <= 'F')
-          current_word = current_word * 16 + *p++ - 'A' + 10;
-        else
-        {
-          if (num_front_bytes == 16)
-          {
-            ec = asio::error::invalid_argument;
-            return -1;
-          }
-
-          bytes[num_front_bytes++] = (current_word >> 8) & 0xFF;
-          bytes[num_front_bytes++] = current_word & 0xFF;
-          current_word = 0;
-
-          if (*p == ':')
-            state = fcolon, ++p;
-          else if (*p == '%')
-            state = scope, ++p;
-          else if (*p == 0)
-            state = done;
-          else
-          {
-            ec = asio::error::invalid_argument;
-            return -1;
-          }
-        }
-        break;
-
-      case fcolon:
-        if (*p == ':')
-          state = bword, ++p;
-        else
-          state = fword;
-        break;
-
-      case bword:
-        if (*p >= '0' && *p <= '9')
-          current_word = current_word * 16 + *p++ - '0';
-        else if (*p >= 'a' && *p <= 'f')
-          current_word = current_word * 16 + *p++ - 'a' + 10;
-        else if (*p >= 'A' && *p <= 'F')
-          current_word = current_word * 16 + *p++ - 'A' + 10;
-        else
-        {
-          if (num_front_bytes + num_back_bytes == 16)
-          {
-            ec = asio::error::invalid_argument;
-            return -1;
-          }
-
-          back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF;
-          back_bytes[num_back_bytes++] = current_word & 0xFF;
-          current_word = 0;
-
-          if (*p == ':')
-            state = bword, ++p;
-          else if (*p == '%')
-            state = scope, ++p;
-          else if (*p == 0)
-            state = done;
-          else
-          {
-            ec = asio::error::invalid_argument;
-            return -1;
-          }
-        }
-        break;
-
-      case scope:
-        if (*p >= '0' && *p <= '9')
-          current_word = current_word * 10 + *p++ - '0';
-        else if (*p == 0)
-          *scope_id = current_word, state = done;
-        else
-        {
-          ec = asio::error::invalid_argument;
-          return -1;
-        }
-        break;
-
-      default:
-        break;
-      }
-    }
-
-    for (int i = 0; i < num_back_bytes; ++i)
-      bytes[16 - num_back_bytes + i] = back_bytes[i];
-
-    asio::error::clear(ec);
-    return 1;
-  }
-  else
-  {
-    ec = asio::error::address_family_not_supported;
-    return -1;
-  }
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  using namespace std; // For memcpy and strcmp.
-
-  if (af != ASIO_OS_DEF(AF_INET) && af != ASIO_OS_DEF(AF_INET6))
-  {
-    ec = asio::error::address_family_not_supported;
-    return -1;
-  }
-
-  union
-  {
-    socket_addr_type base;
-    sockaddr_storage_type storage;
-    sockaddr_in4_type v4;
-    sockaddr_in6_type v6;
-  } address;
-  int address_length = sizeof(sockaddr_storage_type);
-#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
-  int num_wide_chars = static_cast<int>(strlen(src)) + 1;
-  LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR));
-  ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars);
-  int result = ::WSAStringToAddressW(wide_buffer,
-      af, 0, &address.base, &address_length);
-  get_last_error(ec, true);
-#else
-  int result = ::WSAStringToAddressA(const_cast<char*>(src),
-      af, 0, &address.base, &address_length);
-  get_last_error(ec, true);
-#endif
-
-  if (af == ASIO_OS_DEF(AF_INET))
-  {
-    if (result != socket_error_retval)
-    {
-      memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
-      asio::error::clear(ec);
-    }
-    else if (strcmp(src, "255.255.255.255") == 0)
-    {
-      static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
-      asio::error::clear(ec);
-    }
-  }
-  else // AF_INET6
-  {
-    if (result != socket_error_retval)
-    {
-      memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
-      if (scope_id)
-        *scope_id = address.v6.sin6_scope_id;
-      asio::error::clear(ec);
-    }
-  }
-
-  // Windows may not set an error code on failure.
-  if (result == socket_error_retval && !ec)
-    ec = asio::error::invalid_argument;
-
-  if (result != socket_error_retval)
-    asio::error::clear(ec);
-
-  return result == socket_error_retval ? -1 : 1;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  using namespace std; // For strchr, memcpy and atoi.
-
-  // On some platforms, inet_pton fails if an address string contains a scope
-  // id. Detect and remove the scope id before passing the string to inet_pton.
-  const bool is_v6 = (af == ASIO_OS_DEF(AF_INET6));
-  const char* if_name = is_v6 ? strchr(src, '%') : 0;
-  char src_buf[max_addr_v6_str_len + 1];
-  const char* src_ptr = src;
-  if (if_name != 0)
-  {
-    if (if_name - src > max_addr_v6_str_len)
-    {
-      ec = asio::error::invalid_argument;
-      return 0;
-    }
-    memcpy(src_buf, src, if_name - src);
-    src_buf[if_name - src] = 0;
-    src_ptr = src_buf;
-  }
-
-  int result = ::inet_pton(af, src_ptr, dest);
-  get_last_error(ec, true);
-  if (result <= 0 && !ec)
-    ec = asio::error::invalid_argument;
-  if (result > 0 && is_v6 && scope_id)
-  {
-    using namespace std; // For strchr and atoi.
-    *scope_id = 0;
-    if (if_name != 0)
-    {
-      in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
-      bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
-          && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
-      bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
-          && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
-      if (is_link_local || is_multicast_link_local)
-        *scope_id = if_nametoindex(if_name + 1);
-      if (*scope_id == 0)
-        *scope_id = atoi(if_name + 1);
-    }
-  }
-  return result;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-}
-
-int gethostname(char* name, int namelen, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  try
-  {
-    using namespace Windows::Foundation::Collections;
-    using namespace Windows::Networking;
-    using namespace Windows::Networking::Connectivity;
-    IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames();
-    for (unsigned i = 0; i < hostnames->Size; ++i)
-    {
-      HostName^ hostname = hostnames->GetAt(i);
-      if (hostname->Type == HostNameType::DomainName)
-      {
-        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
-        std::string raw_name = converter.to_bytes(hostname->RawName->Data());
-        if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen))
-        {
-          strcpy_s(name, namelen, raw_name.c_str());
-          return 0;
-        }
-      }
-    }
-    return -1;
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-    return -1;
-  }
-#else // defined(ASIO_WINDOWS_RUNTIME)
-  int result = ::gethostname(name, namelen);
-  get_last_error(ec, result != 0);
-  return result;
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-}
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#if !defined(ASIO_HAS_GETADDRINFO)
-
-// The following functions are only needed for emulation of getaddrinfo and
-// getnameinfo.
-
-inline asio::error_code translate_netdb_error(int error)
-{
-  switch (error)
-  {
-  case 0:
-    return asio::error_code();
-  case HOST_NOT_FOUND:
-    return asio::error::host_not_found;
-  case TRY_AGAIN:
-    return asio::error::host_not_found_try_again;
-  case NO_RECOVERY:
-    return asio::error::no_recovery;
-  case NO_DATA:
-    return asio::error::no_data;
-  default:
-    ASIO_ASSERT(false);
-    return asio::error::invalid_argument;
-  }
-}
-
-inline hostent* gethostbyaddr(const char* addr, int length, int af,
-    hostent* result, char* buffer, int buflength, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  (void)(buffer);
-  (void)(buflength);
-  hostent* retval = ::gethostbyaddr(addr, length, af);
-  get_last_error(ec, !retval);
-  if (!retval)
-    return 0;
-  *result = *retval;
-  return retval;
-#elif defined(__sun) || defined(__QNX__)
-  int error = 0;
-  hostent* retval = ::gethostbyaddr_r(addr, length,
-      af, result, buffer, buflength, &error);
-  get_last_error(ec, !retval);
-  if (error)
-    ec = translate_netdb_error(error);
-  return retval;
-#elif defined(__MACH__) && defined(__APPLE__)
-  (void)(buffer);
-  (void)(buflength);
-  int error = 0;
-  hostent* retval = ::getipnodebyaddr(addr, length, af, &error);
-  get_last_error(ec, !retval);
-  if (error)
-    ec = translate_netdb_error(error);
-  if (!retval)
-    return 0;
-  *result = *retval;
-  return retval;
-#else
-  hostent* retval = 0;
-  int error = 0;
-  clear_last_error();
-  ::gethostbyaddr_r(addr, length, af, result,
-      buffer, buflength, &retval, &error);
-  get_last_error(ec, true);
-  if (error)
-    ec = translate_netdb_error(error);
-  return retval;
-#endif
-}
-
-inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
-    char* buffer, int buflength, int ai_flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  (void)(buffer);
-  (void)(buflength);
-  (void)(ai_flags);
-  if (af != ASIO_OS_DEF(AF_INET))
-  {
-    ec = asio::error::address_family_not_supported;
-    return 0;
-  }
-  hostent* retval = ::gethostbyname(name);
-  get_last_error(ec, !retval);
-  if (!retval)
-    return 0;
-  *result = *retval;
-  return result;
-#elif defined(__sun) || defined(__QNX__)
-  (void)(ai_flags);
-  if (af != ASIO_OS_DEF(AF_INET))
-  {
-    ec = asio::error::address_family_not_supported;
-    return 0;
-  }
-  int error = 0;
-  hostent* retval = ::gethostbyname_r(name, result, buffer, buflength, &error);
-  get_last_error(ec, !retval);
-  if (error)
-    ec = translate_netdb_error(error);
-  return retval;
-#elif defined(__MACH__) && defined(__APPLE__)
-  (void)(buffer);
-  (void)(buflength);
-  int error = 0;
-  hostent* retval = ::getipnodebyname(name, af, ai_flags, &error);
-  get_last_error(ec, !retval);
-  if (error)
-    ec = translate_netdb_error(error);
-  if (!retval)
-    return 0;
-  *result = *retval;
-  return retval;
-#else
-  (void)(ai_flags);
-  if (af != ASIO_OS_DEF(AF_INET))
-  {
-    ec = asio::error::address_family_not_supported;
-    return 0;
-  }
-  hostent* retval = 0;
-  int error = 0;
-  clear_last_error();
-  ::gethostbyname_r(name, result, buffer, buflength, &retval, &error);
-  get_last_error(ec, true);
-  if (error)
-    ec = translate_netdb_error(error);
-  return retval;
-#endif
-}
-
-inline void freehostent(hostent* h)
-{
-#if defined(__MACH__) && defined(__APPLE__)
-  if (h)
-    ::freehostent(h);
-#else
-  (void)(h);
-#endif
-}
-
-// Emulation of getaddrinfo based on implementation in:
-// Stevens, W. R., UNIX Network Programming Vol. 1, 2nd Ed., Prentice-Hall 1998.
-
-struct gai_search
-{
-  const char* host;
-  int family;
-};
-
-inline int gai_nsearch(const char* host,
-    const addrinfo_type* hints, gai_search (&search)[2])
-{
-  int search_count = 0;
-  if (host == 0 || host[0] == '\0')
-  {
-    if (hints->ai_flags & AI_PASSIVE)
-    {
-      // No host and AI_PASSIVE implies wildcard bind.
-      switch (hints->ai_family)
-      {
-      case ASIO_OS_DEF(AF_INET):
-        search[search_count].host = "0.0.0.0";
-        search[search_count].family = ASIO_OS_DEF(AF_INET);
-        ++search_count;
-        break;
-      case ASIO_OS_DEF(AF_INET6):
-        search[search_count].host = "0::0";
-        search[search_count].family = ASIO_OS_DEF(AF_INET6);
-        ++search_count;
-        break;
-      case ASIO_OS_DEF(AF_UNSPEC):
-        search[search_count].host = "0::0";
-        search[search_count].family = ASIO_OS_DEF(AF_INET6);
-        ++search_count;
-        search[search_count].host = "0.0.0.0";
-        search[search_count].family = ASIO_OS_DEF(AF_INET);
-        ++search_count;
-        break;
-      default:
-        break;
-      }
-    }
-    else
-    {
-      // No host and not AI_PASSIVE means connect to local host.
-      switch (hints->ai_family)
-      {
-      case ASIO_OS_DEF(AF_INET):
-        search[search_count].host = "localhost";
-        search[search_count].family = ASIO_OS_DEF(AF_INET);
-        ++search_count;
-        break;
-      case ASIO_OS_DEF(AF_INET6):
-        search[search_count].host = "localhost";
-        search[search_count].family = ASIO_OS_DEF(AF_INET6);
-        ++search_count;
-        break;
-      case ASIO_OS_DEF(AF_UNSPEC):
-        search[search_count].host = "localhost";
-        search[search_count].family = ASIO_OS_DEF(AF_INET6);
-        ++search_count;
-        search[search_count].host = "localhost";
-        search[search_count].family = ASIO_OS_DEF(AF_INET);
-        ++search_count;
-        break;
-      default:
-        break;
-      }
-    }
-  }
-  else
-  {
-    // Host is specified.
-    switch (hints->ai_family)
-    {
-    case ASIO_OS_DEF(AF_INET):
-      search[search_count].host = host;
-      search[search_count].family = ASIO_OS_DEF(AF_INET);
-      ++search_count;
-      break;
-    case ASIO_OS_DEF(AF_INET6):
-      search[search_count].host = host;
-      search[search_count].family = ASIO_OS_DEF(AF_INET6);
-      ++search_count;
-      break;
-    case ASIO_OS_DEF(AF_UNSPEC):
-      search[search_count].host = host;
-      search[search_count].family = ASIO_OS_DEF(AF_INET6);
-      ++search_count;
-      search[search_count].host = host;
-      search[search_count].family = ASIO_OS_DEF(AF_INET);
-      ++search_count;
-      break;
-    default:
-      break;
-    }
-  }
-  return search_count;
-}
-
-template <typename T>
-inline T* gai_alloc(std::size_t size = sizeof(T))
-{
-  using namespace std;
-  T* p = static_cast<T*>(::operator new(size, std::nothrow));
-  if (p)
-    memset(p, 0, size);
-  return p;
-}
-
-inline void gai_free(void* p)
-{
-  ::operator delete(p);
-}
-
-inline void gai_strcpy(char* target, const char* source, std::size_t max_size)
-{
-  using namespace std;
-#if defined(ASIO_HAS_SECURE_RTL)
-  strcpy_s(target, max_size, source);
-#else // defined(ASIO_HAS_SECURE_RTL)
-  *target = 0;
-  if (max_size > 0)
-    strncat(target, source, max_size - 1);
-#endif // defined(ASIO_HAS_SECURE_RTL)
-}
-
-enum { gai_clone_flag = 1 << 30 };
-
-inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
-    const void* addr, int family)
-{
-  using namespace std;
-
-  addrinfo_type* ai = gai_alloc<addrinfo_type>();
-  if (ai == 0)
-    return EAI_MEMORY;
-
-  ai->ai_next = 0;
-  **next = ai;
-  *next = &ai->ai_next;
-
-  ai->ai_canonname = 0;
-  ai->ai_socktype = hints->ai_socktype;
-  if (ai->ai_socktype == 0)
-    ai->ai_flags |= gai_clone_flag;
-  ai->ai_protocol = hints->ai_protocol;
-  ai->ai_family = family;
-
-  switch (ai->ai_family)
-  {
-  case ASIO_OS_DEF(AF_INET):
-    {
-      sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
-      if (sinptr == 0)
-        return EAI_MEMORY;
-      sinptr->sin_family = ASIO_OS_DEF(AF_INET);
-      memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type));
-      ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr);
-      ai->ai_addrlen = sizeof(sockaddr_in4_type);
-      break;
-    }
-  case ASIO_OS_DEF(AF_INET6):
-    {
-      sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
-      if (sin6ptr == 0)
-        return EAI_MEMORY;
-      sin6ptr->sin6_family = ASIO_OS_DEF(AF_INET6);
-      memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type));
-      ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr);
-      ai->ai_addrlen = sizeof(sockaddr_in6_type);
-      break;
-    }
-  default:
-    break;
-  }
-
-  return 0;
-}
-
-inline addrinfo_type* gai_clone(addrinfo_type* ai)
-{
-  using namespace std;
-
-  addrinfo_type* new_ai = gai_alloc<addrinfo_type>();
-  if (new_ai == 0)
-    return new_ai;
-
-  new_ai->ai_next = ai->ai_next;
-  ai->ai_next = new_ai;
-
-  new_ai->ai_flags = 0;
-  new_ai->ai_family = ai->ai_family;
-  new_ai->ai_socktype = ai->ai_socktype;
-  new_ai->ai_protocol = ai->ai_protocol;
-  new_ai->ai_canonname = 0;
-  new_ai->ai_addrlen = ai->ai_addrlen;
-  new_ai->ai_addr = gai_alloc<sockaddr>(ai->ai_addrlen);
-  memcpy(new_ai->ai_addr, ai->ai_addr, ai->ai_addrlen);
-
-  return new_ai;
-}
-
-inline int gai_port(addrinfo_type* aihead, int port, int socktype)
-{
-  int num_found = 0;
-
-  for (addrinfo_type* ai = aihead; ai; ai = ai->ai_next)
-  {
-    if (ai->ai_flags & gai_clone_flag)
-    {
-      if (ai->ai_socktype != 0)
-      {
-        ai = gai_clone(ai);
-        if (ai == 0)
-          return -1;
-        // ai now points to newly cloned entry.
-      }
-    }
-    else if (ai->ai_socktype != socktype)
-    {
-      // Ignore if mismatch on socket type.
-      continue;
-    }
-
-    ai->ai_socktype = socktype;
-
-    switch (ai->ai_family)
-    {
-    case ASIO_OS_DEF(AF_INET):
-      {
-        sockaddr_in4_type* sinptr =
-          reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
-        sinptr->sin_port = port;
-        ++num_found;
-        break;
-      }
-    case ASIO_OS_DEF(AF_INET6):
-      {
-        sockaddr_in6_type* sin6ptr =
-          reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
-        sin6ptr->sin6_port = port;
-        ++num_found;
-        break;
-      }
-    default:
-      break;
-    }
-  }
-
-  return num_found;
-}
-
-inline int gai_serv(addrinfo_type* aihead,
-    const addrinfo_type* hints, const char* serv)
-{
-  using namespace std;
-
-  int num_found = 0;
-
-  if (
-#if defined(AI_NUMERICSERV)
-      (hints->ai_flags & AI_NUMERICSERV) ||
-#endif
-      isdigit(static_cast<unsigned char>(serv[0])))
-  {
-    int port = htons(atoi(serv));
-    if (hints->ai_socktype)
-    {
-      // Caller specifies socket type.
-      int rc = gai_port(aihead, port, hints->ai_socktype);
-      if (rc < 0)
-        return EAI_MEMORY;
-      num_found += rc;
-    }
-    else
-    {
-      // Caller does not specify socket type.
-      int rc = gai_port(aihead, port, SOCK_STREAM);
-      if (rc < 0)
-        return EAI_MEMORY;
-      num_found += rc;
-      rc = gai_port(aihead, port, SOCK_DGRAM);
-      if (rc < 0)
-        return EAI_MEMORY;
-      num_found += rc;
-    }
-  }
-  else
-  {
-    // Try service name with TCP first, then UDP.
-    if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_STREAM)
-    {
-      servent* sptr = getservbyname(serv, "tcp");
-      if (sptr != 0)
-      {
-        int rc = gai_port(aihead, sptr->s_port, SOCK_STREAM);
-        if (rc < 0)
-          return EAI_MEMORY;
-        num_found += rc;
-      }
-    }
-    if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_DGRAM)
-    {
-      servent* sptr = getservbyname(serv, "udp");
-      if (sptr != 0)
-      {
-        int rc = gai_port(aihead, sptr->s_port, SOCK_DGRAM);
-        if (rc < 0)
-          return EAI_MEMORY;
-        num_found += rc;
-      }
-    }
-  }
-
-  if (num_found == 0)
-  {
-    if (hints->ai_socktype == 0)
-    {
-      // All calls to getservbyname() failed.
-      return EAI_NONAME;
-    }
-    else
-    {
-      // Service not supported for socket type.
-      return EAI_SERVICE;
-    }
-  }
-
-  return 0;
-}
-
-inline int gai_echeck(const char* host, const char* service,
-    int flags, int family, int socktype, int protocol)
-{
-  (void)(flags);
-  (void)(protocol);
-
-  // Host or service must be specified.
-  if (host == 0 || host[0] == '\0')
-    if (service == 0 || service[0] == '\0')
-      return EAI_NONAME;
-
-  // Check combination of family and socket type.
-  switch (family)
-  {
-  case ASIO_OS_DEF(AF_UNSPEC):
-    break;
-  case ASIO_OS_DEF(AF_INET):
-  case ASIO_OS_DEF(AF_INET6):
-    if (service != 0 && service[0] != '\0')
-      if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
-        return EAI_SOCKTYPE;
-    break;
-  default:
-    return EAI_FAMILY;
-  }
-
-  return 0;
-}
-
-inline void freeaddrinfo_emulation(addrinfo_type* aihead)
-{
-  addrinfo_type* ai = aihead;
-  while (ai)
-  {
-    gai_free(ai->ai_addr);
-    gai_free(ai->ai_canonname);
-    addrinfo_type* ainext = ai->ai_next;
-    gai_free(ai);
-    ai = ainext;
-  }
-}
-
-inline int getaddrinfo_emulation(const char* host, const char* service,
-    const addrinfo_type* hintsp, addrinfo_type** result)
-{
-  // Set up linked list of addrinfo structures.
-  addrinfo_type* aihead = 0;
-  addrinfo_type** ainext = &aihead;
-  char* canon = 0;
-
-  // Supply default hints if not specified by caller.
-  addrinfo_type hints = addrinfo_type();
-  hints.ai_family = ASIO_OS_DEF(AF_UNSPEC);
-  if (hintsp)
-    hints = *hintsp;
-
-  // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED
-  // and AI_ALL flags.
-#if defined(AI_V4MAPPED)
-  if (hints.ai_family != ASIO_OS_DEF(AF_INET6))
-    hints.ai_flags &= ~AI_V4MAPPED;
-#endif
-#if defined(AI_ALL)
-  if (hints.ai_family != ASIO_OS_DEF(AF_INET6))
-    hints.ai_flags &= ~AI_ALL;
-#endif
-
-  // Basic error checking.
-  int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family,
-      hints.ai_socktype, hints.ai_protocol);
-  if (rc != 0)
-  {
-    freeaddrinfo_emulation(aihead);
-    return rc;
-  }
-
-  gai_search search[2];
-  int search_count = gai_nsearch(host, &hints, search);
-  for (gai_search* sptr = search; sptr < search + search_count; ++sptr)
-  {
-    // Check for IPv4 dotted decimal string.
-    in4_addr_type inaddr;
-    asio::error_code ec;
-    if (socket_ops::inet_pton(ASIO_OS_DEF(AF_INET),
-          sptr->host, &inaddr, 0, ec) == 1)
-    {
-      if (hints.ai_family != ASIO_OS_DEF(AF_UNSPEC)
-          && hints.ai_family != ASIO_OS_DEF(AF_INET))
-      {
-        freeaddrinfo_emulation(aihead);
-        gai_free(canon);
-        return EAI_FAMILY;
-      }
-      if (sptr->family == ASIO_OS_DEF(AF_INET))
-      {
-        rc = gai_aistruct(&ainext, &hints, &inaddr, ASIO_OS_DEF(AF_INET));
-        if (rc != 0)
-        {
-          freeaddrinfo_emulation(aihead);
-          gai_free(canon);
-          return rc;
-        }
-      }
-      continue;
-    }
-
-    // Check for IPv6 hex string.
-    in6_addr_type in6addr;
-    if (socket_ops::inet_pton(ASIO_OS_DEF(AF_INET6),
-          sptr->host, &in6addr, 0, ec) == 1)
-    {
-      if (hints.ai_family != ASIO_OS_DEF(AF_UNSPEC)
-          && hints.ai_family != ASIO_OS_DEF(AF_INET6))
-      {
-        freeaddrinfo_emulation(aihead);
-        gai_free(canon);
-        return EAI_FAMILY;
-      }
-      if (sptr->family == ASIO_OS_DEF(AF_INET6))
-      {
-        rc = gai_aistruct(&ainext, &hints, &in6addr,
-            ASIO_OS_DEF(AF_INET6));
-        if (rc != 0)
-        {
-          freeaddrinfo_emulation(aihead);
-          gai_free(canon);
-          return rc;
-        }
-      }
-      continue;
-    }
-
-    // Look up hostname.
-    hostent hent;
-    char hbuf[8192] = "";
-    hostent* hptr = socket_ops::gethostbyname(sptr->host,
-        sptr->family, &hent, hbuf, sizeof(hbuf), hints.ai_flags, ec);
-    if (hptr == 0)
-    {
-      if (search_count == 2)
-      {
-        // Failure is OK if there are multiple searches.
-        continue;
-      }
-      freeaddrinfo_emulation(aihead);
-      gai_free(canon);
-      if (ec == asio::error::host_not_found)
-        return EAI_NONAME;
-      if (ec == asio::error::host_not_found_try_again)
-        return EAI_AGAIN;
-      if (ec == asio::error::no_recovery)
-        return EAI_FAIL;
-      if (ec == asio::error::no_data)
-        return EAI_NONAME;
-      return EAI_NONAME;
-    }
-
-    // Check for address family mismatch if one was specified.
-    if (hints.ai_family != ASIO_OS_DEF(AF_UNSPEC)
-        && hints.ai_family != hptr->h_addrtype)
-    {
-      freeaddrinfo_emulation(aihead);
-      gai_free(canon);
-      socket_ops::freehostent(hptr);
-      return EAI_FAMILY;
-    }
-
-    // Save canonical name first time.
-    if (host != 0 && host[0] != '\0' && hptr->h_name && hptr->h_name[0]
-        && (hints.ai_flags & AI_CANONNAME) && canon == 0)
-    {
-      std::size_t canon_len = strlen(hptr->h_name) + 1;
-      canon = gai_alloc<char>(canon_len);
-      if (canon == 0)
-      {
-        freeaddrinfo_emulation(aihead);
-        socket_ops::freehostent(hptr);
-        return EAI_MEMORY;
-      }
-      gai_strcpy(canon, hptr->h_name, canon_len);
-    }
-
-    // Create an addrinfo structure for each returned address.
-    for (char** ap = hptr->h_addr_list; *ap; ++ap)
-    {
-      rc = gai_aistruct(&ainext, &hints, *ap, hptr->h_addrtype);
-      if (rc != 0)
-      {
-        freeaddrinfo_emulation(aihead);
-        gai_free(canon);
-        socket_ops::freehostent(hptr);
-        return EAI_FAMILY;
-      }
-    }
-
-    socket_ops::freehostent(hptr);
-  }
-
-  // Check if we found anything.
-  if (aihead == 0)
-  {
-    gai_free(canon);
-    return EAI_NONAME;
-  }
-
-  // Return canonical name in first entry.
-  if (host != 0 && host[0] != '\0' && (hints.ai_flags & AI_CANONNAME))
-  {
-    if (canon)
-    {
-      aihead->ai_canonname = canon;
-      canon = 0;
-    }
-    else
-    {
-      std::size_t canonname_len = strlen(search[0].host) + 1;
-      aihead->ai_canonname = gai_alloc<char>(canonname_len);
-      if (aihead->ai_canonname == 0)
-      {
-        freeaddrinfo_emulation(aihead);
-        return EAI_MEMORY;
-      }
-      gai_strcpy(aihead->ai_canonname, search[0].host, canonname_len);
-    }
-  }
-  gai_free(canon);
-
-  // Process the service name.
-  if (service != 0 && service[0] != '\0')
-  {
-    rc = gai_serv(aihead, &hints, service);
-    if (rc != 0)
-    {
-      freeaddrinfo_emulation(aihead);
-      return rc;
-    }
-  }
-
-  // Return result to caller.
-  *result = aihead;
-  return 0;
-}
-
-inline asio::error_code getnameinfo_emulation(
-    const socket_addr_type* sa, std::size_t salen, char* host,
-    std::size_t hostlen, char* serv, std::size_t servlen, int flags,
-    asio::error_code& ec)
-{
-  using namespace std;
-
-  const char* addr;
-  size_t addr_len;
-  unsigned short port;
-  switch (sa->sa_family)
-  {
-  case ASIO_OS_DEF(AF_INET):
-    if (salen != sizeof(sockaddr_in4_type))
-    {
-      return ec = asio::error::invalid_argument;
-    }
-    addr = reinterpret_cast<const char*>(
-        &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr);
-    addr_len = sizeof(in4_addr_type);
-    port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port;
-    break;
-  case ASIO_OS_DEF(AF_INET6):
-    if (salen != sizeof(sockaddr_in6_type))
-    {
-      return ec = asio::error::invalid_argument;
-    }
-    addr = reinterpret_cast<const char*>(
-        &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr);
-    addr_len = sizeof(in6_addr_type);
-    port = reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_port;
-    break;
-  default:
-    return ec = asio::error::address_family_not_supported;
-  }
-
-  if (host && hostlen > 0)
-  {
-    if (flags & NI_NUMERICHOST)
-    {
-      if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen, 0, ec) == 0)
-      {
-        return ec;
-      }
-    }
-    else
-    {
-      hostent hent;
-      char hbuf[8192] = "";
-      hostent* hptr = socket_ops::gethostbyaddr(addr,
-          static_cast<int>(addr_len), sa->sa_family,
-          &hent, hbuf, sizeof(hbuf), ec);
-      if (hptr && hptr->h_name && hptr->h_name[0] != '\0')
-      {
-        if (flags & NI_NOFQDN)
-        {
-          char* dot = strchr(hptr->h_name, '.');
-          if (dot)
-          {
-            *dot = 0;
-          }
-        }
-        gai_strcpy(host, hptr->h_name, hostlen);
-        socket_ops::freehostent(hptr);
-      }
-      else
-      {
-        socket_ops::freehostent(hptr);
-        if (flags & NI_NAMEREQD)
-        {
-          return ec = asio::error::host_not_found;
-        }
-        if (socket_ops::inet_ntop(sa->sa_family,
-              addr, host, hostlen, 0, ec) == 0)
-        {
-          return ec;
-        }
-      }
-    }
-  }
-
-  if (serv && servlen > 0)
-  {
-    if (flags & NI_NUMERICSERV)
-    {
-      if (servlen < 6)
-      {
-        return ec = asio::error::no_buffer_space;
-      }
-#if defined(ASIO_HAS_SNPRINTF)
-      snprintf(serv, servlen, "%u", ntohs(port));
-#elif defined(ASIO_HAS_SECURE_RTL)
-      sprintf_s(serv, servlen, "%u", ntohs(port));
-#else // defined(ASIO_HAS_SECURE_RTL)
-      sprintf(serv, "%u", ntohs(port));
-#endif // defined(ASIO_HAS_SECURE_RTL)
-    }
-    else
-    {
-#if defined(ASIO_HAS_PTHREADS)
-      static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-      ::pthread_mutex_lock(&mutex);
-#endif // defined(ASIO_HAS_PTHREADS)
-      servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
-      if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
-      {
-        gai_strcpy(serv, sptr->s_name, servlen);
-      }
-      else
-      {
-        if (servlen < 6)
-        {
-          return ec = asio::error::no_buffer_space;
-        }
-#if defined(ASIO_HAS_SNPRINTF)
-        snprintf(serv, servlen, "%u", ntohs(port));
-#elif defined(ASIO_HAS_SECURE_RTL)
-        sprintf_s(serv, servlen, "%u", ntohs(port));
-#else // defined(ASIO_HAS_SECURE_RTL)
-        sprintf(serv, "%u", ntohs(port));
-#endif // defined(ASIO_HAS_SECURE_RTL)
-      }
-#if defined(ASIO_HAS_PTHREADS)
-      ::pthread_mutex_unlock(&mutex);
-#endif // defined(ASIO_HAS_PTHREADS)
-    }
-  }
-
-  asio::error::clear(ec);
-  return ec;
-}
-
-#endif // !defined(ASIO_HAS_GETADDRINFO)
-
-inline asio::error_code translate_addrinfo_error(int error)
-{
-  switch (error)
-  {
-  case 0:
-    return asio::error_code();
-  case EAI_AGAIN:
-    return asio::error::host_not_found_try_again;
-  case EAI_BADFLAGS:
-    return asio::error::invalid_argument;
-  case EAI_FAIL:
-    return asio::error::no_recovery;
-  case EAI_FAMILY:
-    return asio::error::address_family_not_supported;
-  case EAI_MEMORY:
-    return asio::error::no_memory;
-  case EAI_NONAME:
-#if defined(EAI_ADDRFAMILY)
-  case EAI_ADDRFAMILY:
-#endif
-#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
-  case EAI_NODATA:
-#endif
-    return asio::error::host_not_found;
-  case EAI_SERVICE:
-    return asio::error::service_not_found;
-  case EAI_SOCKTYPE:
-    return asio::error::socket_type_not_supported;
-  default: // Possibly the non-portable EAI_SYSTEM.
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    return asio::error_code(
-        WSAGetLastError(), asio::error::get_system_category());
-#else
-    return asio::error_code(
-        errno, asio::error::get_system_category());
-#endif
-  }
-}
-
-asio::error_code getaddrinfo(const char* host,
-    const char* service, const addrinfo_type& hints,
-    addrinfo_type** result, asio::error_code& ec)
-{
-  host = (host && *host) ? host : 0;
-  service = (service && *service) ? service : 0;
-  clear_last_error();
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if defined(ASIO_HAS_GETADDRINFO)
-  // Building for Windows XP, Windows Server 2003, or later.
-  int error = ::getaddrinfo(host, service, &hints, result);
-  return ec = translate_addrinfo_error(error);
-# else
-  // Building for Windows 2000 or earlier.
-  typedef int (WSAAPI *gai_t)(const char*,
-      const char*, const addrinfo_type*, addrinfo_type**);
-  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
-  {
-    if (gai_t gai = (gai_t)::GetProcAddress(winsock_module, "getaddrinfo"))
-    {
-      int error = gai(host, service, &hints, result);
-      return ec = translate_addrinfo_error(error);
-    }
-  }
-  int error = getaddrinfo_emulation(host, service, &hints, result);
-  return ec = translate_addrinfo_error(error);
-# endif
-#elif !defined(ASIO_HAS_GETADDRINFO)
-  int error = getaddrinfo_emulation(host, service, &hints, result);
-  return ec = translate_addrinfo_error(error);
-#else
-  int error = ::getaddrinfo(host, service, &hints, result);
-#if defined(__MACH__) && defined(__APPLE__)
-  using namespace std; // For isdigit and atoi.
-  if (error == 0 && service && isdigit(static_cast<unsigned char>(service[0])))
-  {
-    u_short_type port = host_to_network_short(atoi(service));
-    for (addrinfo_type* ai = *result; ai; ai = ai->ai_next)
-    {
-      switch (ai->ai_family)
-      {
-      case ASIO_OS_DEF(AF_INET):
-        {
-          sockaddr_in4_type* sinptr =
-            reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
-          if (sinptr->sin_port == 0)
-            sinptr->sin_port = port;
-          break;
-        }
-      case ASIO_OS_DEF(AF_INET6):
-        {
-          sockaddr_in6_type* sin6ptr =
-            reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
-          if (sin6ptr->sin6_port == 0)
-            sin6ptr->sin6_port = port;
-          break;
-        }
-      default:
-        break;
-      }
-    }
-  }
-#endif
-  return ec = translate_addrinfo_error(error);
-#endif
-}
-
-asio::error_code background_getaddrinfo(
-    const weak_cancel_token_type& cancel_token, const char* host,
-    const char* service, const addrinfo_type& hints,
-    addrinfo_type** result, asio::error_code& ec)
-{
-  if (cancel_token.expired())
-    ec = asio::error::operation_aborted;
-  else
-    socket_ops::getaddrinfo(host, service, hints, result, ec);
-  return ec;
-}
-
-void freeaddrinfo(addrinfo_type* ai)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if defined(ASIO_HAS_GETADDRINFO)
-  // Building for Windows XP, Windows Server 2003, or later.
-  ::freeaddrinfo(ai);
-# else
-  // Building for Windows 2000 or earlier.
-  typedef int (WSAAPI *fai_t)(addrinfo_type*);
-  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
-  {
-    if (fai_t fai = (fai_t)::GetProcAddress(winsock_module, "freeaddrinfo"))
-    {
-      fai(ai);
-      return;
-    }
-  }
-  freeaddrinfo_emulation(ai);
-# endif
-#elif !defined(ASIO_HAS_GETADDRINFO)
-  freeaddrinfo_emulation(ai);
-#else
-  ::freeaddrinfo(ai);
-#endif
-}
-
-asio::error_code getnameinfo(const void* addr,
-    std::size_t addrlen, char* host, std::size_t hostlen,
-    char* serv, std::size_t servlen, int flags, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if defined(ASIO_HAS_GETADDRINFO)
-  // Building for Windows XP, Windows Server 2003, or later.
-  clear_last_error();
-  int error = ::getnameinfo(static_cast<const socket_addr_type*>(addr),
-      static_cast<socklen_t>(addrlen), host, static_cast<DWORD>(hostlen),
-      serv, static_cast<DWORD>(servlen), flags);
-  return ec = translate_addrinfo_error(error);
-# else
-  // Building for Windows 2000 or earlier.
-  typedef int (WSAAPI *gni_t)(const socket_addr_type*,
-      int, char*, DWORD, char*, DWORD, int);
-  if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
-  {
-    if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo"))
-    {
-      clear_last_error();
-      int error = gni(static_cast<const socket_addr_type*>(addr),
-          static_cast<int>(addrlen), host, static_cast<DWORD>(hostlen),
-          serv, static_cast<DWORD>(servlen), flags);
-      return ec = translate_addrinfo_error(error);
-    }
-  }
-  clear_last_error();
-  return getnameinfo_emulation(static_cast<const socket_addr_type*>(addr),
-      addrlen, host, hostlen, serv, servlen, flags, ec);
-# endif
-#elif !defined(ASIO_HAS_GETADDRINFO)
-  using namespace std; // For memcpy.
-  sockaddr_storage_type tmp_addr;
-  memcpy(&tmp_addr, addr, addrlen);
-  addr = &tmp_addr;
-  clear_last_error();
-  return getnameinfo_emulation(static_cast<const socket_addr_type*>(addr),
-      addrlen, host, hostlen, serv, servlen, flags, ec);
-#else
-  clear_last_error();
-  int error = ::getnameinfo(static_cast<const socket_addr_type*>(addr),
-      addrlen, host, hostlen, serv, servlen, flags);
-  return ec = translate_addrinfo_error(error);
-#endif
-}
-
-asio::error_code sync_getnameinfo(const void* addr,
-    std::size_t addrlen, char* host, std::size_t hostlen, char* serv,
-    std::size_t servlen, int sock_type, asio::error_code& ec)
-{
-  // First try resolving with the service name. If that fails try resolving
-  // but allow the service to be returned as a number.
-  int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
-  socket_ops::getnameinfo(addr, addrlen, host,
-      hostlen, serv, servlen, flags, ec);
-  if (ec)
-  {
-    socket_ops::getnameinfo(addr, addrlen, host, hostlen,
-        serv, servlen, flags | NI_NUMERICSERV, ec);
-  }
-
-  return ec;
-}
-
-asio::error_code background_getnameinfo(
-    const weak_cancel_token_type& cancel_token,
-    const void* addr, std::size_t addrlen,
-    char* host, std::size_t hostlen, char* serv,
-    std::size_t servlen, int sock_type, asio::error_code& ec)
-{
-  if (cancel_token.expired())
-  {
-    ec = asio::error::operation_aborted;
-  }
-  else
-  {
-    // First try resolving with the service name. If that fails try resolving
-    // but allow the service to be returned as a number.
-    int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
-    socket_ops::getnameinfo(addr, addrlen, host,
-        hostlen, serv, servlen, flags, ec);
-    if (ec)
-    {
-      socket_ops::getnameinfo(addr, addrlen, host, hostlen,
-          serv, servlen, flags | NI_NUMERICSERV, ec);
-    }
-  }
-
-  return ec;
-}
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-u_long_type network_to_host_long(u_long_type value)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
-  u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24)
-    | (static_cast<u_long_type>(value_p[1]) << 16)
-    | (static_cast<u_long_type>(value_p[2]) << 8)
-    | static_cast<u_long_type>(value_p[3]);
-  return result;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-  return ntohl(value);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-}
-
-u_long_type host_to_network_long(u_long_type value)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  u_long_type result;
-  unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
-  result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF);
-  result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF);
-  result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF);
-  result_p[3] = static_cast<unsigned char>(value & 0xFF);
-  return result;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-  return htonl(value);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-}
-
-u_short_type network_to_host_short(u_short_type value)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
-  u_short_type result = (static_cast<u_short_type>(value_p[0]) << 8)
-    | static_cast<u_short_type>(value_p[1]);
-  return result;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-  return ntohs(value);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-}
-
-u_short_type host_to_network_short(u_short_type value)
-{
-#if defined(ASIO_WINDOWS_RUNTIME)
-  u_short_type result;
-  unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
-  result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF);
-  result_p[1] = static_cast<unsigned char>(value & 0xFF);
-  return result;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-  return htons(value);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-}
-
-} // namespace socket_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SOCKET_OPS_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_select_interrupter.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_select_interrupter.ipp
deleted file mode 100644
index d83d083..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/socket_select_interrupter.ipp
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// detail/impl/socket_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-
-#include <cstdlib>
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_select_interrupter.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-socket_select_interrupter::socket_select_interrupter()
-{
-  open_descriptors();
-}
-
-void socket_select_interrupter::open_descriptors()
-{
-  asio::error_code ec;
-  socket_holder acceptor(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (acceptor.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  int opt = 1;
-  socket_ops::state_type acceptor_state = 0;
-  socket_ops::setsockopt(acceptor.get(), acceptor_state,
-      SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt), ec);
-
-  using namespace std; // For memset.
-  sockaddr_in4_type addr;
-  std::size_t addr_len = sizeof(addr);
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
-  addr.sin_port = 0;
-  if (socket_ops::bind(acceptor.get(), &addr,
-        addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::getsockname(acceptor.get(), &addr,
-        &addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  // Some broken firewalls on Windows will intermittently cause getsockname to
-  // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We
-  // explicitly specify the target address here to work around this problem.
-  if (addr.sin_addr.s_addr == socket_ops::host_to_network_long(INADDR_ANY))
-    addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
-
-  if (socket_ops::listen(acceptor.get(),
-        SOMAXCONN, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  socket_holder client(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (client.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::connect(client.get(), &addr,
-        addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  socket_holder server(socket_ops::accept(acceptor.get(), 0, 0, ec));
-  if (server.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  ioctl_arg_type non_blocking = 1;
-  socket_ops::state_type client_state = 0;
-  if (socket_ops::ioctl(client.get(), client_state,
-        FIONBIO, &non_blocking, ec))
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(client.get(), client_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  non_blocking = 1;
-  socket_ops::state_type server_state = 0;
-  if (socket_ops::ioctl(server.get(), server_state,
-        FIONBIO, &non_blocking, ec))
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(server.get(), server_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  read_descriptor_ = server.release();
-  write_descriptor_ = client.release();
-}
-
-socket_select_interrupter::~socket_select_interrupter()
-{
-  close_descriptors();
-}
-
-void socket_select_interrupter::close_descriptors()
-{
-  asio::error_code ec;
-  socket_ops::state_type state = socket_ops::internal_non_blocking;
-  if (read_descriptor_ != invalid_socket)
-    socket_ops::close(read_descriptor_, state, true, ec);
-  if (write_descriptor_ != invalid_socket)
-    socket_ops::close(write_descriptor_, state, true, ec);
-}
-
-void socket_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = invalid_socket;
-  read_descriptor_ = invalid_socket;
-
-  open_descriptors();
-}
-
-void socket_select_interrupter::interrupt()
-{
-  char byte = 0;
-  socket_ops::buf b;
-  socket_ops::init_buf(b, &byte, 1);
-  asio::error_code ec;
-  socket_ops::send(write_descriptor_, &b, 1, 0, ec);
-}
-
-bool socket_select_interrupter::reset()
-{
-  char data[1024];
-  socket_ops::buf b;
-  socket_ops::init_buf(b, data, sizeof(data));
-  asio::error_code ec;
-  for (;;)
-  {
-    int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
-    if (bytes_read == sizeof(data))
-      continue;
-    if (bytes_read > 0)
-      return true;
-    if (bytes_read == 0)
-      return false;
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return true;
-    return false;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.hpp
deleted file mode 100644
index 3ffb398..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.hpp
+++ /dev/null
@@ -1,346 +0,0 @@
-//
-// detail/impl/strand_executor_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/defer.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename F, typename Allocator>
-class strand_executor_service::allocator_binder
-{
-public:
-  typedef Allocator allocator_type;
-
-  allocator_binder(F&& f, const Allocator& a)
-    : f_(static_cast<F&&>(f)),
-      allocator_(a)
-  {
-  }
-
-  allocator_binder(const allocator_binder& other)
-    : f_(other.f_),
-      allocator_(other.allocator_)
-  {
-  }
-
-  allocator_binder(allocator_binder&& other)
-    : f_(static_cast<F&&>(other.f_)),
-      allocator_(static_cast<allocator_type&&>(other.allocator_))
-  {
-  }
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  void operator()()
-  {
-    f_();
-  }
-
-private:
-  F f_;
-  allocator_type allocator_;
-};
-
-template <typename Executor>
-class strand_executor_service::invoker<Executor,
-    enable_if_t<
-      execution::is_executor<Executor>::value
-    >>
-{
-public:
-  invoker(const implementation_type& impl, Executor& ex)
-    : impl_(impl),
-      executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  invoker(const invoker& other)
-    : impl_(other.impl_),
-      executor_(other.executor_)
-  {
-  }
-
-  invoker(invoker&& other)
-    : impl_(static_cast<implementation_type&&>(other.impl_)),
-      executor_(static_cast<executor_type&&>(other.executor_))
-  {
-  }
-
-  struct on_invoker_exit
-  {
-    invoker* this_;
-
-    ~on_invoker_exit()
-    {
-      if (push_waiting_to_ready(this_->impl_))
-      {
-        recycling_allocator<void> allocator;
-        executor_type ex = this_->executor_;
-        asio::prefer(
-            asio::require(
-              static_cast<executor_type&&>(ex),
-              execution::blocking.never),
-            execution::allocator(allocator)
-          ).execute(static_cast<invoker&&>(*this_));
-      }
-    }
-  };
-
-  void operator()()
-  {
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_invoker_exit on_exit = { this };
-    (void)on_exit;
-
-    run_ready_handlers(impl_);
-  }
-
-private:
-  typedef decay_t<
-      prefer_result_t<
-        Executor,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  implementation_type impl_;
-  executor_type executor_;
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-class strand_executor_service::invoker<Executor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-    >>
-{
-public:
-  invoker(const implementation_type& impl, Executor& ex)
-    : impl_(impl),
-      work_(ex)
-  {
-  }
-
-  invoker(const invoker& other)
-    : impl_(other.impl_),
-      work_(other.work_)
-  {
-  }
-
-  invoker(invoker&& other)
-    : impl_(static_cast<implementation_type&&>(other.impl_)),
-      work_(static_cast<executor_work_guard<Executor>&&>(other.work_))
-  {
-  }
-
-  struct on_invoker_exit
-  {
-    invoker* this_;
-
-    ~on_invoker_exit()
-    {
-      if (push_waiting_to_ready(this_->impl_))
-      {
-        Executor ex(this_->work_.get_executor());
-        recycling_allocator<void> allocator;
-        ex.post(static_cast<invoker&&>(*this_), allocator);
-      }
-    }
-  };
-
-  void operator()()
-  {
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_invoker_exit on_exit = { this };
-    (void)on_exit;
-
-    run_ready_handlers(impl_);
-  }
-
-private:
-  implementation_type impl_;
-  executor_work_guard<Executor> work_;
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor, typename Function>
-inline void strand_executor_service::execute(const implementation_type& impl,
-    Executor& ex, Function&& function,
-    enable_if_t<
-      can_query<Executor, execution::allocator_t<void>>::value
-    >*)
-{
-  return strand_executor_service::do_execute(impl, ex,
-      static_cast<Function&&>(function),
-      asio::query(ex, execution::allocator));
-}
-
-template <typename Executor, typename Function>
-inline void strand_executor_service::execute(const implementation_type& impl,
-    Executor& ex, Function&& function,
-    enable_if_t<
-      !can_query<Executor, execution::allocator_t<void>>::value
-    >*)
-{
-  return strand_executor_service::do_execute(impl, ex,
-      static_cast<Function&&>(function),
-      std::allocator<void>());
-}
-
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::do_execute(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // If the executor is not never-blocking, and we are already in the strand,
-  // then the function can run immediately.
-  if (asio::query(ex, execution::blocking) != execution::blocking.never
-      && running_in_this_thread(impl))
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(function));
-
-    fenced_block b(fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "execute"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    ex.execute(invoker<Executor>(impl, ex));
-  }
-}
-
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::dispatch(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // If we are already in the strand then the function can run immediately.
-  if (running_in_this_thread(impl))
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(function));
-
-    fenced_block b(fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "dispatch"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    asio::dispatch(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-// Request invocation of the given function and return immediately.
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::post(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "post"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    asio::post(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-// Request invocation of the given function and return immediately.
-template <typename Executor, typename Function, typename Allocator>
-void strand_executor_service::defer(const implementation_type& impl,
-    Executor& ex, Function&& function, const Allocator& a)
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(function), a);
-
-  ASIO_HANDLER_CREATION((impl->service_->context(), *p.p,
-        "strand_executor", impl.get(), 0, "defer"));
-
-  // Add the function to the strand and schedule the strand if required.
-  bool first = enqueue(impl, p.p);
-  p.v = p.p = 0;
-  if (first)
-  {
-    asio::defer(ex,
-        allocator_binder<invoker<Executor>, Allocator>(
-          invoker<Executor>(impl, ex), a));
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.ipp
deleted file mode 100644
index a2dff89..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_executor_service.ipp
+++ /dev/null
@@ -1,158 +0,0 @@
-//
-// detail/impl/strand_executor_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/strand_executor_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-strand_executor_service::strand_executor_service(execution_context& ctx)
-  : execution_context_service_base<strand_executor_service>(ctx),
-    mutex_(),
-    salt_(0),
-    impl_list_(0)
-{
-}
-
-void strand_executor_service::shutdown()
-{
-  op_queue<scheduler_operation> ops;
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  strand_impl* impl = impl_list_;
-  while (impl)
-  {
-    impl->mutex_->lock();
-    impl->shutdown_ = true;
-    ops.push(impl->waiting_queue_);
-    ops.push(impl->ready_queue_);
-    impl->mutex_->unlock();
-    impl = impl->next_;
-  }
-}
-
-strand_executor_service::implementation_type
-strand_executor_service::create_implementation()
-{
-  implementation_type new_impl(new strand_impl);
-  new_impl->locked_ = false;
-  new_impl->shutdown_ = false;
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Select a mutex from the pool of shared mutexes.
-  std::size_t salt = salt_++;
-  std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get());
-  mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3);
-  mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2);
-  mutex_index = mutex_index % num_mutexes;
-  if (!mutexes_[mutex_index].get())
-    mutexes_[mutex_index].reset(new mutex);
-  new_impl->mutex_ = mutexes_[mutex_index].get();
-
-  // Insert implementation into linked list of all implementations.
-  new_impl->next_ = impl_list_;
-  new_impl->prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = new_impl.get();
-  impl_list_ = new_impl.get();
-  new_impl->service_ = this;
-
-  return new_impl;
-}
-
-strand_executor_service::strand_impl::~strand_impl()
-{
-  asio::detail::mutex::scoped_lock lock(service_->mutex_);
-
-  // Remove implementation from linked list of all implementations.
-  if (service_->impl_list_ == this)
-    service_->impl_list_ = next_;
-  if (prev_)
-    prev_->next_ = next_;
-  if (next_)
-    next_->prev_= prev_;
-}
-
-bool strand_executor_service::enqueue(const implementation_type& impl,
-    scheduler_operation* op)
-{
-  impl->mutex_->lock();
-  if (impl->shutdown_)
-  {
-    impl->mutex_->unlock();
-    op->destroy();
-    return false;
-  }
-  else if (impl->locked_)
-  {
-    // Some other function already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_->unlock();
-    return false;
-  }
-  else
-  {
-    // The function is acquiring the strand lock and so is responsible for
-    // scheduling the strand.
-    impl->locked_ = true;
-    impl->mutex_->unlock();
-    impl->ready_queue_.push(op);
-    return true;
-  }
-}
-
-bool strand_executor_service::running_in_this_thread(
-    const implementation_type& impl)
-{
-  return !!call_stack<strand_impl>::contains(impl.get());
-}
-
-bool strand_executor_service::push_waiting_to_ready(implementation_type& impl)
-{
-  impl->mutex_->lock();
-  impl->ready_queue_.push(impl->waiting_queue_);
-  bool more_handlers = impl->locked_ = !impl->ready_queue_.empty();
-  impl->mutex_->unlock();
-  return more_handlers;
-}
-
-void strand_executor_service::run_ready_handlers(implementation_type& impl)
-{
-  // Indicate that this strand is executing on the current thread.
-  call_stack<strand_impl>::context ctx(impl.get());
-
-  // Run all ready handlers. No lock is required since the ready queue is
-  // accessed only within the strand.
-  asio::error_code ec;
-  while (scheduler_operation* o = impl->ready_queue_.front())
-  {
-    impl->ready_queue_.pop();
-    o->complete(impl.get(), ec, 0);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.hpp
deleted file mode 100644
index 8249c9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// detail/impl/strand_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline strand_service::strand_impl::strand_impl()
-  : operation(&strand_service::do_complete),
-    locked_(false)
-{
-}
-
-template <typename Handler>
-void strand_service::dispatch(strand_service::implementation_type& impl,
-    Handler& handler)
-{
-  // If we are already in the strand then the handler can run immediately.
-  if (running_in_this_thread(impl))
-  {
-    fenced_block b(fenced_block::full);
-    static_cast<Handler&&>(handler)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler, io_context::executor_type> op;
-  typename op::ptr p = { asio::detail::addressof(handler),
-    op::ptr::allocate(handler), 0 };
-  p.p = new (p.v) op(handler, io_context_.get_executor());
-
-  ASIO_HANDLER_CREATION((this->context(),
-        *p.p, "strand", impl, 0, "dispatch"));
-
-  operation* o = p.p;
-  p.v = p.p = 0;
-  do_dispatch(impl, o);
-}
-
-// Request the io_context to invoke the given handler and return immediately.
-template <typename Handler>
-void strand_service::post(strand_service::implementation_type& impl,
-    Handler& handler)
-{
-  bool is_continuation =
-    asio_handler_cont_helpers::is_continuation(handler);
-
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler, io_context::executor_type> op;
-  typename op::ptr p = { asio::detail::addressof(handler),
-    op::ptr::allocate(handler), 0 };
-  p.p = new (p.v) op(handler, io_context_.get_executor());
-
-  ASIO_HANDLER_CREATION((this->context(),
-        *p.p, "strand", impl, 0, "post"));
-
-  do_post(impl, p.p, is_continuation);
-  p.v = p.p = 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.ipp
deleted file mode 100644
index af8929a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/strand_service.ipp
+++ /dev/null
@@ -1,202 +0,0 @@
-//
-// detail/impl/strand_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/strand_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct strand_service::on_do_complete_exit
-{
-  io_context_impl* owner_;
-  strand_impl* impl_;
-
-  ~on_do_complete_exit()
-  {
-    impl_->mutex_.lock();
-    impl_->ready_queue_.push(impl_->waiting_queue_);
-    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
-    impl_->mutex_.unlock();
-
-    if (more_handlers)
-      owner_->post_immediate_completion(impl_, true);
-  }
-};
-
-strand_service::strand_service(asio::io_context& io_context)
-  : asio::detail::service_base<strand_service>(io_context),
-    io_context_(io_context),
-    io_context_impl_(asio::use_service<io_context_impl>(io_context)),
-    mutex_(),
-    salt_(0)
-{
-}
-
-void strand_service::shutdown()
-{
-  op_queue<operation> ops;
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  for (std::size_t i = 0; i < num_implementations; ++i)
-  {
-    if (strand_impl* impl = implementations_[i].get())
-    {
-      ops.push(impl->waiting_queue_);
-      ops.push(impl->ready_queue_);
-    }
-  }
-}
-
-void strand_service::construct(strand_service::implementation_type& impl)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  std::size_t salt = salt_++;
-#if defined(ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
-  std::size_t index = salt;
-#else // defined(ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
-  std::size_t index = reinterpret_cast<std::size_t>(&impl);
-  index += (reinterpret_cast<std::size_t>(&impl) >> 3);
-  index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);
-#endif // defined(ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
-  index = index % num_implementations;
-
-  if (!implementations_[index].get())
-    implementations_[index].reset(new strand_impl);
-  impl = implementations_[index].get();
-}
-
-bool strand_service::running_in_this_thread(
-    const implementation_type& impl) const
-{
-  return call_stack<strand_impl>::contains(impl) != 0;
-}
-
-struct strand_service::on_dispatch_exit
-{
-  io_context_impl* io_context_impl_;
-  strand_impl* impl_;
-
-  ~on_dispatch_exit()
-  {
-    impl_->mutex_.lock();
-    impl_->ready_queue_.push(impl_->waiting_queue_);
-    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
-    impl_->mutex_.unlock();
-
-    if (more_handlers)
-      io_context_impl_->post_immediate_completion(impl_, false);
-  }
-};
-
-void strand_service::do_dispatch(implementation_type& impl, operation* op)
-{
-  // If we are running inside the io_context, and no other handler already
-  // holds the strand lock, then the handler can run immediately.
-  bool can_dispatch = io_context_impl_.can_dispatch();
-  impl->mutex_.lock();
-  if (can_dispatch && !impl->locked_)
-  {
-    // Immediate invocation is allowed.
-    impl->locked_ = true;
-    impl->mutex_.unlock();
-
-    // Indicate that this strand is executing on the current thread.
-    call_stack<strand_impl>::context ctx(impl);
-
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_dispatch_exit on_exit = { &io_context_impl_, impl };
-    (void)on_exit;
-
-    op->complete(&io_context_impl_, asio::error_code(), 0);
-    return;
-  }
-
-  if (impl->locked_)
-  {
-    // Some other handler already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_.unlock();
-  }
-  else
-  {
-    // The handler is acquiring the strand lock and so is responsible for
-    // scheduling the strand.
-    impl->locked_ = true;
-    impl->mutex_.unlock();
-    impl->ready_queue_.push(op);
-    io_context_impl_.post_immediate_completion(impl, false);
-  }
-}
-
-void strand_service::do_post(implementation_type& impl,
-    operation* op, bool is_continuation)
-{
-  impl->mutex_.lock();
-  if (impl->locked_)
-  {
-    // Some other handler already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_.unlock();
-  }
-  else
-  {
-    // The handler is acquiring the strand lock and so is responsible for
-    // scheduling the strand.
-    impl->locked_ = true;
-    impl->mutex_.unlock();
-    impl->ready_queue_.push(op);
-    io_context_impl_.post_immediate_completion(impl, is_continuation);
-  }
-}
-
-void strand_service::do_complete(void* owner, operation* base,
-    const asio::error_code& ec, std::size_t /*bytes_transferred*/)
-{
-  if (owner)
-  {
-    strand_impl* impl = static_cast<strand_impl*>(base);
-
-    // Indicate that this strand is executing on the current thread.
-    call_stack<strand_impl>::context ctx(impl);
-
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_do_complete_exit on_exit;
-    on_exit.owner_ = static_cast<io_context_impl*>(owner);
-    on_exit.impl_ = impl;
-
-    // Run all ready handlers. No lock is required since the ready queue is
-    // accessed only within the strand.
-    while (operation* o = impl->ready_queue_.front())
-    {
-      impl->ready_queue_.pop();
-      o->complete(owner, ec, 0);
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/thread_context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/thread_context.ipp
deleted file mode 100644
index 8e72977..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/thread_context.ipp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// detail/impl/thread_context.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_THREAD_CONTEXT_IPP
-#define ASIO_DETAIL_IMPL_THREAD_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-thread_info_base* thread_context::top_of_thread_call_stack()
-{
-  return thread_call_stack::top();
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_THREAD_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/throw_error.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/throw_error.ipp
deleted file mode 100644
index 7baf3e7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/throw_error.ipp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// detail/impl/throw_error.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_THROW_ERROR_IPP
-#define ASIO_DETAIL_IMPL_THROW_ERROR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/system_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void do_throw_error(
-    const asio::error_code& err
-    ASIO_SOURCE_LOCATION_PARAM)
-{
-  asio::system_error e(err);
-  asio::detail::throw_exception(e ASIO_SOURCE_LOCATION_ARG);
-}
-
-void do_throw_error(
-    const asio::error_code& err,
-    const char* location
-    ASIO_SOURCE_LOCATION_PARAM)
-{
-  asio::system_error e(err, location);
-  asio::detail::throw_exception(e ASIO_SOURCE_LOCATION_ARG);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_THROW_ERROR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_ptime.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_ptime.ipp
deleted file mode 100644
index bdf994e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_ptime.ipp
+++ /dev/null
@@ -1,97 +0,0 @@
-//
-// detail/impl/timer_queue_ptime.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
-#define ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#include "asio/detail/timer_queue_ptime.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-timer_queue<time_traits<boost::posix_time::ptime>>::timer_queue()
-{
-}
-
-timer_queue<time_traits<boost::posix_time::ptime>>::~timer_queue()
-{
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime>>::enqueue_timer(
-    const time_type& time, per_timer_data& timer, wait_op* op)
-{
-  return impl_.enqueue_timer(time, timer, op);
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime>>::empty() const
-{
-  return impl_.empty();
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime>>::wait_duration_msec(
-    long max_duration) const
-{
-  return impl_.wait_duration_msec(max_duration);
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime>>::wait_duration_usec(
-    long max_duration) const
-{
-  return impl_.wait_duration_usec(max_duration);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime>>::get_ready_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_ready_timers(ops);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime>>::get_all_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_all_timers(ops);
-}
-
-std::size_t timer_queue<time_traits<boost::posix_time::ptime>>::cancel_timer(
-    per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled)
-{
-  return impl_.cancel_timer(timer, ops, max_cancelled);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime>>::cancel_timer_by_key(
-    per_timer_data* timer, op_queue<operation>& ops, void* cancellation_key)
-{
-  impl_.cancel_timer_by_key(timer, ops, cancellation_key);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime>>::move_timer(
-    per_timer_data& target, per_timer_data& source)
-{
-  impl_.move_timer(target, source);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#endif // ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_set.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_set.ipp
deleted file mode 100644
index 66420e9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/timer_queue_set.ipp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// detail/impl/timer_queue_set.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
-#define ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-timer_queue_set::timer_queue_set()
-  : first_(0)
-{
-}
-
-void timer_queue_set::insert(timer_queue_base* q)
-{
-  q->next_ = first_;
-  first_ = q;
-}
-
-void timer_queue_set::erase(timer_queue_base* q)
-{
-  if (first_)
-  {
-    if (q == first_)
-    {
-      first_ = q->next_;
-      q->next_ = 0;
-      return;
-    }
-
-    for (timer_queue_base* p = first_; p->next_; p = p->next_)
-    {
-      if (p->next_ == q)
-      {
-        p->next_ = q->next_;
-        q->next_ = 0;
-        return;
-      }
-    }
-  }
-}
-
-bool timer_queue_set::all_empty() const
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    if (!p->empty())
-      return false;
-  return true;
-}
-
-long timer_queue_set::wait_duration_msec(long max_duration) const
-{
-  long min_duration = max_duration;
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    min_duration = p->wait_duration_msec(min_duration);
-  return min_duration;
-}
-
-long timer_queue_set::wait_duration_usec(long max_duration) const
-{
-  long min_duration = max_duration;
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    min_duration = p->wait_duration_usec(min_duration);
-  return min_duration;
-}
-
-void timer_queue_set::get_ready_timers(op_queue<operation>& ops)
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    p->get_ready_timers(ops);
-}
-
-void timer_queue_set::get_all_timers(op_queue<operation>& ops)
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    p->get_all_timers(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_event.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_event.ipp
deleted file mode 100644
index 9827e33..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_event.ipp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// detail/win_event.ipp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_EVENT_IPP
-#define ASIO_DETAIL_IMPL_WIN_EVENT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_event.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_event::win_event()
-  : state_(0)
-{
-#if defined(ASIO_WINDOWS_APP)
-  events_[0] = ::CreateEventExW(0, 0,
-      CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
-#else // defined(ASIO_WINDOWS_APP)
-  events_[0] = ::CreateEventW(0, true, false, 0);
-#endif // defined(ASIO_WINDOWS_APP)
-  if (!events_[0])
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "event");
-  }
-
-#if defined(ASIO_WINDOWS_APP)
-  events_[1] = ::CreateEventExW(0, 0, 0, EVENT_ALL_ACCESS);
-#else // defined(ASIO_WINDOWS_APP)
-  events_[1] = ::CreateEventW(0, false, false, 0);
-#endif // defined(ASIO_WINDOWS_APP)
-  if (!events_[1])
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(events_[0]);
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "event");
-  }
-}
-
-win_event::~win_event()
-{
-  ::CloseHandle(events_[0]);
-  ::CloseHandle(events_[1]);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_WIN_EVENT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_file_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_file_service.ipp
deleted file mode 100644
index faaab48..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_file_service.ipp
+++ /dev/null
@@ -1,280 +0,0 @@
-//
-// detail/impl/win_iocp_file_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  && defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-
-#include <cstring>
-#include <sys/stat.h>
-#include "asio/detail/win_iocp_file_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_iocp_file_service::win_iocp_file_service(
-    execution_context& context)
-  : execution_context_service_base<win_iocp_file_service>(context),
-    handle_service_(context),
-    nt_flush_buffers_file_ex_(0)
-{
-  if (FARPROC nt_flush_buffers_file_ex_ptr = ::GetProcAddress(
-        ::GetModuleHandleA("NTDLL"), "NtFlushBuffersFileEx"))
-  {
-    nt_flush_buffers_file_ex_ = reinterpret_cast<nt_flush_buffers_file_ex_fn>(
-        reinterpret_cast<void*>(nt_flush_buffers_file_ex_ptr));
-  }
-}
-
-void win_iocp_file_service::shutdown()
-{
-  handle_service_.shutdown();
-}
-
-asio::error_code win_iocp_file_service::open(
-    win_iocp_file_service::implementation_type& impl,
-    const char* path, file_base::flags open_flags,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  DWORD access = 0;
-  if ((open_flags & file_base::read_only) != 0)
-    access = GENERIC_READ;
-  else if ((open_flags & file_base::write_only) != 0)
-    access = GENERIC_WRITE;
-  else if ((open_flags & file_base::read_write) != 0)
-    access = GENERIC_READ | GENERIC_WRITE;
-
-  DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-
-  DWORD disposition = 0;
-  if ((open_flags & file_base::create) != 0)
-  {
-    if ((open_flags & file_base::exclusive) != 0)
-      disposition = CREATE_NEW;
-    else
-      disposition = OPEN_ALWAYS;
-  }
-  else
-  {
-    if ((open_flags & file_base::truncate) != 0)
-      disposition = TRUNCATE_EXISTING;
-    else
-      disposition = OPEN_EXISTING;
-  }
-
-  DWORD flags = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
-  if (impl.is_stream_)
-    flags |= FILE_FLAG_SEQUENTIAL_SCAN;
-  else
-    flags |= FILE_FLAG_RANDOM_ACCESS;
-  if ((open_flags & file_base::sync_all_on_write) != 0)
-    flags |= FILE_FLAG_WRITE_THROUGH;
-
-  HANDLE handle = ::CreateFileA(path, access, share, 0, disposition, flags, 0);
-  if (handle != INVALID_HANDLE_VALUE)
-  {
-    if (disposition == OPEN_ALWAYS)
-    {
-      if ((open_flags & file_base::truncate) != 0)
-      {
-        if (!::SetEndOfFile(handle))
-        {
-          DWORD last_error = ::GetLastError();
-          ::CloseHandle(handle);
-          ec.assign(last_error, asio::error::get_system_category());
-          ASIO_ERROR_LOCATION(ec);
-          return ec;
-        }
-      }
-      else if ((open_flags & file_base::append) != 0)
-      {
-        if (::SetFilePointer(handle, 0, 0, FILE_END)
-            == INVALID_SET_FILE_POINTER)
-        {
-          DWORD last_error = ::GetLastError();
-          ::CloseHandle(handle);
-          ec.assign(last_error, asio::error::get_system_category());
-          ASIO_ERROR_LOCATION(ec);
-          return ec;
-        }
-      }
-    }
-
-    handle_service_.assign(impl, handle, ec);
-    if (ec)
-      ::CloseHandle(handle);
-    impl.offset_ = 0;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-  else
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-}
-
-uint64_t win_iocp_file_service::size(
-    const win_iocp_file_service::implementation_type& impl,
-    asio::error_code& ec) const
-{
-  LARGE_INTEGER result;
-  if (::GetFileSizeEx(native_handle(impl), &result))
-  {
-    asio::error::clear(ec);
-    return static_cast<uint64_t>(result.QuadPart);
-  }
-  else
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-}
-
-asio::error_code win_iocp_file_service::resize(
-    win_iocp_file_service::implementation_type& impl,
-    uint64_t n, asio::error_code& ec)
-{
-  LARGE_INTEGER distance;
-  distance.QuadPart = n;
-  if (::SetFilePointerEx(native_handle(impl), distance, 0, FILE_BEGIN))
-  {
-    BOOL result = ::SetEndOfFile(native_handle(impl));
-    DWORD last_error = ::GetLastError();
-
-    distance.QuadPart = static_cast<LONGLONG>(impl.offset_);
-    if (!::SetFilePointerEx(native_handle(impl), distance, 0, FILE_BEGIN))
-    {
-      result = FALSE;
-      last_error = ::GetLastError();
-    }
-
-    if (result)
-      asio::error::clear(ec);
-    else
-      ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-  else
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-}
-
-asio::error_code win_iocp_file_service::sync_all(
-    win_iocp_file_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  BOOL result = ::FlushFileBuffers(native_handle(impl));
-  if (result)
-  {
-    asio::error::clear(ec);
-    return ec;
-  }
-  else
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-}
-
-asio::error_code win_iocp_file_service::sync_data(
-    win_iocp_file_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (nt_flush_buffers_file_ex_)
-  {
-    io_status_block status = {};
-    if (!nt_flush_buffers_file_ex_(native_handle(impl),
-          flush_flags_file_data_sync_only, 0, 0, &status))
-    {
-      asio::error::clear(ec);
-      return ec;
-    }
-  }
-  return sync_all(impl, ec);
-}
-
-uint64_t win_iocp_file_service::seek(
-    win_iocp_file_service::implementation_type& impl, int64_t offset,
-    file_base::seek_basis whence, asio::error_code& ec)
-{
-  DWORD method;
-  switch (whence)
-  {
-  case file_base::seek_set:
-    method = FILE_BEGIN;
-    break;
-  case file_base::seek_cur:
-    method = FILE_BEGIN;
-    offset = static_cast<int64_t>(impl.offset_) + offset;
-    break;
-  case file_base::seek_end:
-    method = FILE_END;
-    break;
-  default:
-    ec = asio::error::invalid_argument;
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  LARGE_INTEGER distance, new_offset;
-  distance.QuadPart = offset;
-  if (::SetFilePointerEx(native_handle(impl), distance, &new_offset, method))
-  {
-    impl.offset_ = new_offset.QuadPart;
-    asio::error::clear(ec);
-    return impl.offset_;
-  }
-  else
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   && defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_FILE_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_handle_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_handle_service.ipp
deleted file mode 100644
index db8f4a8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_handle_service.ipp
+++ /dev/null
@@ -1,619 +0,0 @@
-//
-// detail/impl/win_iocp_handle_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/win_iocp_handle_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_handle_service::overlapped_wrapper
-  : public OVERLAPPED
-{
-public:
-  explicit overlapped_wrapper(asio::error_code& ec)
-  {
-    Internal = 0;
-    InternalHigh = 0;
-    Offset = 0;
-    OffsetHigh = 0;
-
-    // Create a non-signalled manual-reset event, for GetOverlappedResult.
-    hEvent = ::CreateEventW(0, TRUE, FALSE, 0);
-    if (hEvent)
-    {
-      // As documented in GetQueuedCompletionStatus, setting the low order
-      // bit of this event prevents our synchronous writes from being treated
-      // as completion port events.
-      DWORD_PTR tmp = reinterpret_cast<DWORD_PTR>(hEvent);
-      hEvent = reinterpret_cast<HANDLE>(tmp | 1);
-    }
-    else
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-  }
-
-  ~overlapped_wrapper()
-  {
-    if (hEvent)
-    {
-      ::CloseHandle(hEvent);
-    }
-  }
-};
-
-win_iocp_handle_service::win_iocp_handle_service(execution_context& context)
-  : execution_context_service_base<win_iocp_handle_service>(context),
-    iocp_service_(asio::use_service<win_iocp_io_context>(context)),
-    nt_set_info_(0),
-    mutex_(),
-    impl_list_(0)
-{
-}
-
-void win_iocp_handle_service::shutdown()
-{
-  // Close all implementations, causing all operations to complete.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  implementation_type* impl = impl_list_;
-  while (impl)
-  {
-    close_for_destruction(*impl);
-    impl = impl->next_;
-  }
-}
-
-void win_iocp_handle_service::construct(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.safe_cancellation_thread_id_ = 0;
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void win_iocp_handle_service::move_construct(
-    win_iocp_handle_service::implementation_type& impl,
-    win_iocp_handle_service::implementation_type& other_impl)
-{
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void win_iocp_handle_service::move_assign(
-    win_iocp_handle_service::implementation_type& impl,
-    win_iocp_handle_service& other_service,
-    win_iocp_handle_service::implementation_type& other_impl)
-{
-  close_for_destruction(impl);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    if (impl_list_ == &impl)
-      impl_list_ = impl.next_;
-    if (impl.prev_)
-      impl.prev_->next_ = impl.next_;
-    if (impl.next_)
-      impl.next_->prev_= impl.prev_;
-    impl.next_ = 0;
-    impl.prev_ = 0;
-  }
-
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
-    impl.next_ = other_service.impl_list_;
-    impl.prev_ = 0;
-    if (other_service.impl_list_)
-      other_service.impl_list_->prev_ = &impl;
-    other_service.impl_list_ = &impl;
-  }
-}
-
-void win_iocp_handle_service::destroy(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  close_for_destruction(impl);
-
-  // Remove implementation from linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-}
-
-asio::error_code win_iocp_handle_service::assign(
-    win_iocp_handle_service::implementation_type& impl,
-    const native_handle_type& handle, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  if (iocp_service_.register_handle(handle, ec))
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  impl.handle_ = handle;
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_handle_service::close(
-    win_iocp_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close"));
-
-    if (!::CloseHandle(impl.handle_))
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-
-    impl.handle_ = INVALID_HANDLE_VALUE;
-    impl.safe_cancellation_thread_id_ = 0;
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-win_iocp_handle_service::native_handle_type win_iocp_handle_service::release(
-    win_iocp_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-    return INVALID_HANDLE_VALUE;
-
-  cancel(impl, ec);
-  if (ec)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return INVALID_HANDLE_VALUE;
-  }
-
-  nt_set_info_fn fn = get_nt_set_info();
-  if (fn == 0)
-  {
-    ec = asio::error::operation_not_supported;
-    ASIO_ERROR_LOCATION(ec);
-    return INVALID_HANDLE_VALUE;
-  }
-
-  ULONG_PTR iosb[2] = { 0, 0 };
-  void* info[2] = { 0, 0 };
-  if (fn(impl.handle_, iosb, &info, sizeof(info),
-        61 /* FileReplaceCompletionInformation */))
-  {
-    ec = asio::error::operation_not_supported;
-    ASIO_ERROR_LOCATION(ec);
-    return INVALID_HANDLE_VALUE;
-  }
-
-  native_handle_type tmp = impl.handle_;
-  impl.handle_ = INVALID_HANDLE_VALUE;
-  return tmp;
-}
-
-asio::error_code win_iocp_handle_service::cancel(
-    win_iocp_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
-        &impl, reinterpret_cast<uintmax_t>(impl.handle_), "cancel"));
-
-  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
-        ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
-  {
-    // The version of Windows supports cancellation from any thread.
-    typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
-    cancel_io_ex_t cancel_io_ex = reinterpret_cast<cancel_io_ex_t>(
-        reinterpret_cast<void*>(cancel_io_ex_ptr));
-    if (!cancel_io_ex(impl.handle_, 0))
-    {
-      DWORD last_error = ::GetLastError();
-      if (last_error == ERROR_NOT_FOUND)
-      {
-        // ERROR_NOT_FOUND means that there were no operations to be
-        // cancelled. We swallow this error to match the behaviour on other
-        // platforms.
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-      }
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-  else if (impl.safe_cancellation_thread_id_ == 0)
-  {
-    // No operations have been started, so there's nothing to cancel.
-    ec = asio::error_code();
-  }
-  else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
-  {
-    // Asynchronous operations have been started from the current thread only,
-    // so it is safe to try to cancel them using CancelIo.
-    if (!::CancelIo(impl.handle_))
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-  else
-  {
-    // Asynchronous operations have been started from more than one thread,
-    // so cancellation is not safe.
-    ec = asio::error::operation_not_supported;
-  }
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-size_t win_iocp_handle_service::do_write(
-    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
-    const asio::const_buffer& buffer, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // A request to write 0 bytes on a handle is a no-op.
-  if (buffer.size() == 0)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  overlapped_wrapper overlapped(ec);
-  if (ec)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Write the data.
-  overlapped.Offset = offset & 0xFFFFFFFF;
-  overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::WriteFile(impl.handle_, buffer.data(),
-      static_cast<DWORD>(buffer.size()), 0, &overlapped);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error != ERROR_IO_PENDING)
-    {
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-      ASIO_ERROR_LOCATION(ec);
-      return 0;
-    }
-  }
-
-  // Wait for the operation to complete.
-  DWORD bytes_transferred = 0;
-  ok = ::GetOverlappedResult(impl.handle_,
-      &overlapped, &bytes_transferred, TRUE);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  ec = asio::error_code();
-  return bytes_transferred;
-}
-
-void win_iocp_handle_service::start_write_op(
-    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
-    const asio::const_buffer& buffer, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-  {
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  }
-  else if (buffer.size() == 0)
-  {
-    // A request to write 0 bytes on a handle is a no-op.
-    iocp_service_.on_completion(op);
-  }
-  else
-  {
-    DWORD bytes_transferred = 0;
-    op->Offset = offset & 0xFFFFFFFF;
-    op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::WriteFile(impl.handle_, buffer.data(),
-        static_cast<DWORD>(buffer.size()),
-        &bytes_transferred, op);
-    DWORD last_error = ::GetLastError();
-    if (!ok && last_error != ERROR_IO_PENDING
-        && last_error != ERROR_MORE_DATA)
-    {
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    }
-    else
-    {
-      iocp_service_.on_pending(op);
-    }
-  }
-}
-
-size_t win_iocp_handle_service::do_read(
-    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
-    const asio::mutable_buffer& buffer, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream handle is a no-op.
-  if (buffer.size() == 0)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  overlapped_wrapper overlapped(ec);
-  if (ec)
-  {
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Read some data.
-  overlapped.Offset = offset & 0xFFFFFFFF;
-  overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::ReadFile(impl.handle_, buffer.data(),
-      static_cast<DWORD>(buffer.size()), 0, &overlapped);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA)
-    {
-      if (last_error == ERROR_HANDLE_EOF)
-      {
-        ec = asio::error::eof;
-      }
-      else
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-      }
-      ASIO_ERROR_LOCATION(ec);
-      return 0;
-    }
-  }
-
-  // Wait for the operation to complete.
-  DWORD bytes_transferred = 0;
-  ok = ::GetOverlappedResult(impl.handle_,
-      &overlapped, &bytes_transferred, TRUE);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error == ERROR_HANDLE_EOF)
-    {
-      ec = asio::error::eof;
-    }
-    else
-    {
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    ASIO_ERROR_LOCATION(ec);
-    return (last_error == ERROR_MORE_DATA) ? bytes_transferred : 0;
-  }
-
-  ec = asio::error_code();
-  return bytes_transferred;
-}
-
-void win_iocp_handle_service::start_read_op(
-    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
-    const asio::mutable_buffer& buffer, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-  {
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  }
-  else if (buffer.size() == 0)
-  {
-    // A request to read 0 bytes on a handle is a no-op.
-    iocp_service_.on_completion(op);
-  }
-  else
-  {
-    DWORD bytes_transferred = 0;
-    op->Offset = offset & 0xFFFFFFFF;
-    op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::ReadFile(impl.handle_, buffer.data(),
-        static_cast<DWORD>(buffer.size()),
-        &bytes_transferred, op);
-    DWORD last_error = ::GetLastError();
-    if (!ok && last_error != ERROR_IO_PENDING
-        && last_error != ERROR_MORE_DATA)
-    {
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    }
-    else
-    {
-      iocp_service_.on_pending(op);
-    }
-  }
-}
-
-void win_iocp_handle_service::update_cancellation_thread_id(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  if (impl.safe_cancellation_thread_id_ == 0)
-    impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
-  else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
-    impl.safe_cancellation_thread_id_ = ~DWORD(0);
-}
-
-void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close"));
-
-    ::CloseHandle(impl.handle_);
-    impl.handle_ = INVALID_HANDLE_VALUE;
-    impl.safe_cancellation_thread_id_ = 0;
-  }
-}
-
-win_iocp_handle_service::nt_set_info_fn
-win_iocp_handle_service::get_nt_set_info()
-{
-  void* ptr = interlocked_compare_exchange_pointer(&nt_set_info_, 0, 0);
-  if (!ptr)
-  {
-    if (HMODULE h = ::GetModuleHandleA("NTDLL.DLL"))
-      ptr = reinterpret_cast<void*>(GetProcAddress(h, "NtSetInformationFile"));
-
-    // On failure, set nt_set_info_ to a special value to indicate that the
-    // NtSetInformationFile function is unavailable. That way we won't bother
-    // trying to look it up again.
-    interlocked_exchange_pointer(&nt_set_info_, ptr ? ptr : this);
-  }
-
-  return reinterpret_cast<nt_set_info_fn>(ptr == this ? 0 : ptr);
-}
-
-void* win_iocp_handle_service::interlocked_compare_exchange_pointer(
-    void** dest, void* exch, void* cmp)
-{
-#if defined(_M_IX86)
-  return reinterpret_cast<void*>(InterlockedCompareExchange(
-        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch),
-        reinterpret_cast<LONG>(cmp)));
-#else
-  return InterlockedCompareExchangePointer(dest, exch, cmp);
-#endif
-}
-
-void* win_iocp_handle_service::interlocked_exchange_pointer(
-    void** dest, void* val)
-{
-#if defined(_M_IX86)
-  return reinterpret_cast<void*>(InterlockedExchange(
-        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(val)));
-#else
-  return InterlockedExchangePointer(dest, val);
-#endif
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.hpp
deleted file mode 100644
index 6479500..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// detail/impl/win_iocp_io_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void win_iocp_io_context::add_timer_queue(
-    timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void win_iocp_io_context::remove_timer_queue(
-    timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void win_iocp_io_context::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  // If the service has been shut down we silently discard the timer.
-  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
-  {
-    post_immediate_completion(op, false);
-    return;
-  }
-
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  work_started();
-  if (earliest)
-    update_timeout();
-}
-
-template <typename Time_Traits>
-std::size_t win_iocp_io_context::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  // If the service has been shut down we silently ignore the cancellation.
-  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
-    return 0;
-
-  mutex::scoped_lock lock(dispatch_mutex_);
-  op_queue<win_iocp_operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void win_iocp_io_context::cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data* timer,
-    void* cancellation_key)
-{
-  // If the service has been shut down we silently ignore the cancellation.
-  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
-    return;
-
-  mutex::scoped_lock lock(dispatch_mutex_);
-  op_queue<win_iocp_operation> ops;
-  queue.cancel_timer_by_key(timer, ops, cancellation_key);
-  lock.unlock();
-  post_deferred_completions(ops);
-}
-
-template <typename Time_Traits>
-void win_iocp_io_context::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& to,
-    typename timer_queue<Time_Traits>::per_timer_data& from)
-{
-  asio::detail::mutex::scoped_lock lock(dispatch_mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(to, ops);
-  queue.move_timer(to, from);
-  lock.unlock();
-  post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.ipp
deleted file mode 100644
index 1c7fb28..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_io_context.ipp
+++ /dev/null
@@ -1,614 +0,0 @@
-//
-// detail/impl/win_iocp_io_context.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/error.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/thread.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_iocp_io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct win_iocp_io_context::thread_function
-{
-  explicit thread_function(win_iocp_io_context* s)
-    : this_(s)
-  {
-  }
-
-  void operator()()
-  {
-    asio::error_code ec;
-    this_->run(ec);
-  }
-
-  win_iocp_io_context* this_;
-};
-
-struct win_iocp_io_context::work_finished_on_block_exit
-{
-  ~work_finished_on_block_exit() noexcept(false)
-  {
-    io_context_->work_finished();
-  }
-
-  win_iocp_io_context* io_context_;
-};
-
-struct win_iocp_io_context::timer_thread_function
-{
-  void operator()()
-  {
-    while (::InterlockedExchangeAdd(&io_context_->shutdown_, 0) == 0)
-    {
-      if (::WaitForSingleObject(io_context_->waitable_timer_.handle,
-            INFINITE) == WAIT_OBJECT_0)
-      {
-        ::InterlockedExchange(&io_context_->dispatch_required_, 1);
-        ::PostQueuedCompletionStatus(io_context_->iocp_.handle,
-            0, wake_for_dispatch, 0);
-      }
-    }
-  }
-
-  win_iocp_io_context* io_context_;
-};
-
-win_iocp_io_context::win_iocp_io_context(
-    asio::execution_context& ctx, int concurrency_hint, bool own_thread)
-  : execution_context_service_base<win_iocp_io_context>(ctx),
-    iocp_(),
-    outstanding_work_(0),
-    stopped_(0),
-    stop_event_posted_(0),
-    shutdown_(0),
-    gqcs_timeout_(get_gqcs_timeout()),
-    dispatch_required_(0),
-    concurrency_hint_(concurrency_hint)
-{
-  ASIO_HANDLER_TRACKING_INIT;
-
-  iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0,
-      static_cast<DWORD>(concurrency_hint >= 0 ? concurrency_hint : DWORD(~0)));
-  if (!iocp_.handle)
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "iocp");
-  }
-
-  if (own_thread)
-  {
-    ::InterlockedIncrement(&outstanding_work_);
-    thread_.reset(new asio::detail::thread(thread_function(this)));
-  }
-}
-
-win_iocp_io_context::~win_iocp_io_context()
-{
-  if (thread_.get())
-  {
-    stop();
-    thread_->join();
-    thread_.reset();
-  }
-}
-
-void win_iocp_io_context::shutdown()
-{
-  ::InterlockedExchange(&shutdown_, 1);
-
-  if (timer_thread_.get())
-  {
-    LARGE_INTEGER timeout;
-    timeout.QuadPart = 1;
-    ::SetWaitableTimer(waitable_timer_.handle, &timeout, 1, 0, 0, FALSE);
-  }
-
-  if (thread_.get())
-  {
-    stop();
-    thread_->join();
-    thread_.reset();
-    ::InterlockedDecrement(&outstanding_work_);
-  }
-
-  while (::InterlockedExchangeAdd(&outstanding_work_, 0) > 0)
-  {
-    op_queue<win_iocp_operation> ops;
-    timer_queues_.get_all_timers(ops);
-    ops.push(completed_ops_);
-    if (!ops.empty())
-    {
-      while (win_iocp_operation* op = ops.front())
-      {
-        ops.pop();
-        ::InterlockedDecrement(&outstanding_work_);
-        op->destroy();
-      }
-    }
-    else
-    {
-      DWORD bytes_transferred = 0;
-      dword_ptr_t completion_key = 0;
-      LPOVERLAPPED overlapped = 0;
-      ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-          &completion_key, &overlapped, gqcs_timeout_);
-      if (overlapped)
-      {
-        ::InterlockedDecrement(&outstanding_work_);
-        static_cast<win_iocp_operation*>(overlapped)->destroy();
-      }
-    }
-  }
-
-  if (timer_thread_.get())
-  {
-    timer_thread_->join();
-    timer_thread_.reset();
-  }
-}
-
-asio::error_code win_iocp_io_context::register_handle(
-    HANDLE handle, asio::error_code& ec)
-{
-  if (::CreateIoCompletionPort(handle, iocp_.handle, 0, 0) == 0)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-  return ec;
-}
-
-size_t win_iocp_io_context::run(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  win_iocp_thread_info this_thread;
-  thread_call_stack::context ctx(this, this_thread);
-
-  size_t n = 0;
-  while (do_one(INFINITE, this_thread, ec))
-    if (n != (std::numeric_limits<size_t>::max)())
-      ++n;
-  return n;
-}
-
-size_t win_iocp_io_context::run_one(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  win_iocp_thread_info this_thread;
-  thread_call_stack::context ctx(this, this_thread);
-
-  return do_one(INFINITE, this_thread, ec);
-}
-
-size_t win_iocp_io_context::wait_one(long usec, asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  win_iocp_thread_info this_thread;
-  thread_call_stack::context ctx(this, this_thread);
-
-  return do_one(usec < 0 ? INFINITE : ((usec - 1) / 1000 + 1), this_thread, ec);
-}
-
-size_t win_iocp_io_context::poll(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  win_iocp_thread_info this_thread;
-  thread_call_stack::context ctx(this, this_thread);
-
-  size_t n = 0;
-  while (do_one(0, this_thread, ec))
-    if (n != (std::numeric_limits<size_t>::max)())
-      ++n;
-  return n;
-}
-
-size_t win_iocp_io_context::poll_one(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  win_iocp_thread_info this_thread;
-  thread_call_stack::context ctx(this, this_thread);
-
-  return do_one(0, this_thread, ec);
-}
-
-void win_iocp_io_context::stop()
-{
-  if (::InterlockedExchange(&stopped_, 1) == 0)
-  {
-    if (::InterlockedExchange(&stop_event_posted_, 1) == 0)
-    {
-      if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
-      {
-        DWORD last_error = ::GetLastError();
-        asio::error_code ec(last_error,
-            asio::error::get_system_category());
-        asio::detail::throw_error(ec, "pqcs");
-      }
-    }
-  }
-}
-
-bool win_iocp_io_context::can_dispatch()
-{
-  return thread_call_stack::contains(this) != 0;
-}
-
-void win_iocp_io_context::capture_current_exception()
-{
-  if (thread_info_base* this_thread = thread_call_stack::contains(this))
-    this_thread->capture_current_exception();
-}
-
-void win_iocp_io_context::post_deferred_completion(win_iocp_operation* op)
-{
-  // Flag the operation as ready.
-  op->ready_ = 1;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-void win_iocp_io_context::post_deferred_completions(
-    op_queue<win_iocp_operation>& ops)
-{
-  while (win_iocp_operation* op = ops.front())
-  {
-    ops.pop();
-
-    // Flag the operation as ready.
-    op->ready_ = 1;
-
-    // Enqueue the operation on the I/O completion port.
-    if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op))
-    {
-      // Out of resources. Put on completed queue instead.
-      mutex::scoped_lock lock(dispatch_mutex_);
-      completed_ops_.push(op);
-      completed_ops_.push(ops);
-      ::InterlockedExchange(&dispatch_required_, 1);
-    }
-  }
-}
-
-void win_iocp_io_context::abandon_operations(
-    op_queue<win_iocp_operation>& ops)
-{
-  while (win_iocp_operation* op = ops.front())
-  {
-    ops.pop();
-    ::InterlockedDecrement(&outstanding_work_);
-    op->destroy();
-  }
-}
-
-void win_iocp_io_context::on_pending(win_iocp_operation* op)
-{
-  if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
-  {
-    // Enqueue the operation on the I/O completion port.
-    if (!::PostQueuedCompletionStatus(iocp_.handle,
-          0, overlapped_contains_result, op))
-    {
-      // Out of resources. Put on completed queue instead.
-      mutex::scoped_lock lock(dispatch_mutex_);
-      completed_ops_.push(op);
-      ::InterlockedExchange(&dispatch_required_, 1);
-    }
-  }
-}
-
-void win_iocp_io_context::on_completion(win_iocp_operation* op,
-    DWORD last_error, DWORD bytes_transferred)
-{
-  // Flag that the operation is ready for invocation.
-  op->ready_ = 1;
-
-  // Store results in the OVERLAPPED structure.
-  op->Internal = reinterpret_cast<ulong_ptr_t>(
-      &asio::error::get_system_category());
-  op->Offset = last_error;
-  op->OffsetHigh = bytes_transferred;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-void win_iocp_io_context::on_completion(win_iocp_operation* op,
-    const asio::error_code& ec, DWORD bytes_transferred)
-{
-  // Flag that the operation is ready for invocation.
-  op->ready_ = 1;
-
-  // Store results in the OVERLAPPED structure.
-  op->Internal = reinterpret_cast<ulong_ptr_t>(&ec.category());
-  op->Offset = ec.value();
-  op->OffsetHigh = bytes_transferred;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-size_t win_iocp_io_context::do_one(DWORD msec,
-    win_iocp_thread_info& this_thread, asio::error_code& ec)
-{
-  for (;;)
-  {
-    // Try to acquire responsibility for dispatching timers and completed ops.
-    if (::InterlockedCompareExchange(&dispatch_required_, 0, 1) == 1)
-    {
-      mutex::scoped_lock lock(dispatch_mutex_);
-
-      // Dispatch pending timers and operations.
-      op_queue<win_iocp_operation> ops;
-      ops.push(completed_ops_);
-      timer_queues_.get_ready_timers(ops);
-      post_deferred_completions(ops);
-      update_timeout();
-    }
-
-    // Get the next operation from the queue.
-    DWORD bytes_transferred = 0;
-    dword_ptr_t completion_key = 0;
-    LPOVERLAPPED overlapped = 0;
-    ::SetLastError(0);
-    BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle,
-        &bytes_transferred, &completion_key, &overlapped,
-        msec < gqcs_timeout_ ? msec : gqcs_timeout_);
-    DWORD last_error = ::GetLastError();
-
-    if (overlapped)
-    {
-      win_iocp_operation* op = static_cast<win_iocp_operation*>(overlapped);
-      asio::error_code result_ec(last_error,
-          asio::error::get_system_category());
-
-      // We may have been passed the last_error and bytes_transferred in the
-      // OVERLAPPED structure itself.
-      if (completion_key == overlapped_contains_result)
-      {
-        result_ec = asio::error_code(static_cast<int>(op->Offset),
-            *reinterpret_cast<asio::error_category*>(op->Internal));
-        bytes_transferred = op->OffsetHigh;
-      }
-
-      // Otherwise ensure any result has been saved into the OVERLAPPED
-      // structure.
-      else
-      {
-        op->Internal = reinterpret_cast<ulong_ptr_t>(&result_ec.category());
-        op->Offset = result_ec.value();
-        op->OffsetHigh = bytes_transferred;
-      }
-
-      // Dispatch the operation only if ready. The operation may not be ready
-      // if the initiating function (e.g. a call to WSARecv) has not yet
-      // returned. This is because the initiating function still wants access
-      // to the operation's OVERLAPPED structure.
-      if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
-      {
-        // Ensure the count of outstanding work is decremented on block exit.
-        work_finished_on_block_exit on_exit = { this };
-        (void)on_exit;
-
-        op->complete(this, result_ec, bytes_transferred);
-        this_thread.rethrow_pending_exception();
-        ec = asio::error_code();
-        return 1;
-      }
-    }
-    else if (!ok)
-    {
-      if (last_error != WAIT_TIMEOUT)
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-        return 0;
-      }
-
-      // If we're waiting indefinitely we need to keep going until we get a
-      // real handler.
-      if (msec == INFINITE)
-        continue;
-
-      ec = asio::error_code();
-      return 0;
-    }
-    else if (completion_key == wake_for_dispatch)
-    {
-      // We have been woken up to try to acquire responsibility for dispatching
-      // timers and completed operations.
-    }
-    else
-    {
-      // Indicate that there is no longer an in-flight stop event.
-      ::InterlockedExchange(&stop_event_posted_, 0);
-
-      // The stopped_ flag is always checked to ensure that any leftover
-      // stop events from a previous run invocation are ignored.
-      if (::InterlockedExchangeAdd(&stopped_, 0) != 0)
-      {
-        // Wake up next thread that is blocked on GetQueuedCompletionStatus.
-        if (::InterlockedExchange(&stop_event_posted_, 1) == 0)
-        {
-          if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
-          {
-            last_error = ::GetLastError();
-            ec = asio::error_code(last_error,
-                asio::error::get_system_category());
-            return 0;
-          }
-        }
-
-        ec = asio::error_code();
-        return 0;
-      }
-    }
-  }
-}
-
-DWORD win_iocp_io_context::get_gqcs_timeout()
-{
-#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
-  OSVERSIONINFOEX osvi;
-  ZeroMemory(&osvi, sizeof(osvi));
-  osvi.dwOSVersionInfoSize = sizeof(osvi);
-  osvi.dwMajorVersion = 6ul;
-
-  const uint64_t condition_mask = ::VerSetConditionMask(
-      0, VER_MAJORVERSION, VER_GREATER_EQUAL);
-
-  if (!!::VerifyVersionInfo(&osvi, VER_MAJORVERSION, condition_mask))
-    return INFINITE;
-
-  return default_gqcs_timeout;
-#else // !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
-  return INFINITE;
-#endif // !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
-}
-
-void win_iocp_io_context::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  timer_queues_.insert(&queue);
-
-  if (!waitable_timer_.handle)
-  {
-    waitable_timer_.handle = ::CreateWaitableTimer(0, FALSE, 0);
-    if (waitable_timer_.handle == 0)
-    {
-      DWORD last_error = ::GetLastError();
-      asio::error_code ec(last_error,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "timer");
-    }
-
-    LARGE_INTEGER timeout;
-    timeout.QuadPart = -max_timeout_usec;
-    timeout.QuadPart *= 10;
-    ::SetWaitableTimer(waitable_timer_.handle,
-        &timeout, max_timeout_msec, 0, 0, FALSE);
-  }
-
-  if (!timer_thread_.get())
-  {
-    timer_thread_function thread_function = { this };
-    timer_thread_.reset(new thread(thread_function, 65536));
-  }
-}
-
-void win_iocp_io_context::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  timer_queues_.erase(&queue);
-}
-
-void win_iocp_io_context::update_timeout()
-{
-  if (timer_thread_.get())
-  {
-    // There's no point updating the waitable timer if the new timeout period
-    // exceeds the maximum timeout. In that case, we might as well wait for the
-    // existing period of the timer to expire.
-    long timeout_usec = timer_queues_.wait_duration_usec(max_timeout_usec);
-    if (timeout_usec < max_timeout_usec)
-    {
-      LARGE_INTEGER timeout;
-      timeout.QuadPart = -timeout_usec;
-      timeout.QuadPart *= 10;
-      ::SetWaitableTimer(waitable_timer_.handle,
-          &timeout, max_timeout_msec, 0, 0, FALSE);
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_serial_port_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_serial_port_service.ipp
deleted file mode 100644
index abeb3ce..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_serial_port_service.ipp
+++ /dev/null
@@ -1,200 +0,0 @@
-//
-// detail/impl/win_iocp_serial_port_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#include <cstring>
-#include "asio/detail/win_iocp_serial_port_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_iocp_serial_port_service::win_iocp_serial_port_service(
-    execution_context& context)
-  : execution_context_service_base<win_iocp_serial_port_service>(context),
-    handle_service_(context)
-{
-}
-
-void win_iocp_serial_port_service::shutdown()
-{
-}
-
-asio::error_code win_iocp_serial_port_service::open(
-    win_iocp_serial_port_service::implementation_type& impl,
-    const std::string& device, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // For convenience, add a leading \\.\ sequence if not already present.
-  std::string name = (device[0] == '\\') ? device : "\\\\.\\" + device;
-
-  // Open a handle to the serial port.
-  ::HANDLE handle = ::CreateFileA(name.c_str(),
-      GENERIC_READ | GENERIC_WRITE, 0, 0,
-      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
-  if (handle == INVALID_HANDLE_VALUE)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Determine the initial serial port parameters.
-  using namespace std; // For memset.
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle, &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set some default serial port parameters. This implementation does not
-  // support changing all of these, so they might as well be in a known state.
-  dcb.fBinary = TRUE; // Win32 only supports binary mode.
-  dcb.fNull = FALSE; // Do not ignore NULL characters.
-  dcb.fAbortOnError = FALSE; // Ignore serial framing errors.
-  dcb.BaudRate = CBR_9600; // 9600 baud by default
-  dcb.ByteSize = 8; // 8 bit bytes
-  dcb.fOutxCtsFlow = FALSE; // No flow control
-  dcb.fOutxDsrFlow = FALSE;
-  dcb.fDtrControl = DTR_CONTROL_DISABLE;
-  dcb.fDsrSensitivity = FALSE;
-  dcb.fOutX = FALSE;
-  dcb.fInX = FALSE;
-  dcb.fRtsControl = RTS_CONTROL_DISABLE;
-  dcb.fParity = FALSE; // No parity
-  dcb.Parity = NOPARITY;
-  dcb.StopBits = ONESTOPBIT; // One stop bit
-  if (!::SetCommState(handle, &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set up timeouts so that the serial port will behave similarly to a
-  // network socket. Reads wait for at least one byte, then return with
-  // whatever they have. Writes return once everything is out the door.
-  ::COMMTIMEOUTS timeouts;
-  timeouts.ReadIntervalTimeout = 1;
-  timeouts.ReadTotalTimeoutMultiplier = 0;
-  timeouts.ReadTotalTimeoutConstant = 0;
-  timeouts.WriteTotalTimeoutMultiplier = 0;
-  timeouts.WriteTotalTimeoutConstant = 0;
-  if (!::SetCommTimeouts(handle, &timeouts))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // We're done. Take ownership of the serial port handle.
-  if (handle_service_.assign(impl, handle, ec))
-    ::CloseHandle(handle);
-  return ec;
-}
-
-asio::error_code win_iocp_serial_port_service::do_set_option(
-    win_iocp_serial_port_service::implementation_type& impl,
-    win_iocp_serial_port_service::store_function_type store,
-    const void* option, asio::error_code& ec)
-{
-  using namespace std; // For memcpy.
-
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  if (store(option, dcb, ec))
-    return ec;
-
-  if (!::SetCommState(handle_service_.native_handle(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_serial_port_service::do_get_option(
-    const win_iocp_serial_port_service::implementation_type& impl,
-    win_iocp_serial_port_service::load_function_type load,
-    void* option, asio::error_code& ec) const
-{
-  using namespace std; // For memset.
-
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  return load(option, dcb, ec);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_socket_service_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_socket_service_base.ipp
deleted file mode 100644
index af28718..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_iocp_socket_service_base.ipp
+++ /dev/null
@@ -1,821 +0,0 @@
-//
-// detail/impl/win_iocp_socket_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/win_iocp_socket_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_iocp_socket_service_base::win_iocp_socket_service_base(
-    execution_context& context)
-  : context_(context),
-    iocp_service_(use_service<win_iocp_io_context>(context)),
-    reactor_(0),
-    connect_ex_(0),
-    nt_set_info_(0),
-    mutex_(),
-    impl_list_(0)
-{
-}
-
-void win_iocp_socket_service_base::base_shutdown()
-{
-  // Close all implementations, causing all operations to complete.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  base_implementation_type* impl = impl_list_;
-  while (impl)
-  {
-    close_for_destruction(*impl);
-    impl = impl->next_;
-  }
-}
-
-void win_iocp_socket_service_base::construct(
-    win_iocp_socket_service_base::base_implementation_type& impl)
-{
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.cancel_token_.reset();
-#if defined(ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void win_iocp_socket_service_base::base_move_construct(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    win_iocp_socket_service_base::base_implementation_type& other_impl)
-  noexcept
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.cancel_token_ = other_impl.cancel_token_;
-  other_impl.cancel_token_.reset();
-
-#if defined(ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void win_iocp_socket_service_base::base_move_assign(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    win_iocp_socket_service_base& other_service,
-    win_iocp_socket_service_base::base_implementation_type& other_impl)
-{
-  close_for_destruction(impl);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    if (impl_list_ == &impl)
-      impl_list_ = impl.next_;
-    if (impl.prev_)
-      impl.prev_->next_ = impl.next_;
-    if (impl.next_)
-      impl.next_->prev_= impl.prev_;
-    impl.next_ = 0;
-    impl.prev_ = 0;
-  }
-
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.cancel_token_ = other_impl.cancel_token_;
-  other_impl.cancel_token_.reset();
-
-#if defined(ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
-    impl.next_ = other_service.impl_list_;
-    impl.prev_ = 0;
-    if (other_service.impl_list_)
-      other_service.impl_list_->prev_ = &impl;
-    other_service.impl_list_ = &impl;
-  }
-}
-
-void win_iocp_socket_service_base::destroy(
-    win_iocp_socket_service_base::base_implementation_type& impl)
-{
-  close_for_destruction(impl);
-
-  // Remove implementation from linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-}
-
-asio::error_code win_iocp_socket_service_base::close(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((iocp_service_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    // Check if the reactor was created, in which case we need to close the
-    // socket on the reactor as well to cancel any operations that might be
-    // running there.
-    select_reactor* r = static_cast<select_reactor*>(
-          interlocked_compare_exchange_pointer(
-            reinterpret_cast<void**>(&reactor_), 0, 0));
-    if (r)
-      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
-
-    socket_ops::close(impl.socket_, impl.state_, false, ec);
-
-    if (r)
-      r->cleanup_descriptor_data(impl.reactor_data_);
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.cancel_token_.reset();
-#if defined(ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-  return ec;
-}
-
-socket_type win_iocp_socket_service_base::release(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-    return invalid_socket;
-
-  cancel(impl, ec);
-  if (ec)
-    return invalid_socket;
-
-  nt_set_info_fn fn = get_nt_set_info();
-  if (fn == 0)
-  {
-    ec = asio::error::operation_not_supported;
-    return invalid_socket;
-  }
-
-  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(impl.socket_);
-  ULONG_PTR iosb[2] = { 0, 0 };
-  void* info[2] = { 0, 0 };
-  if (fn(sock_as_handle, iosb, &info, sizeof(info),
-        61 /* FileReplaceCompletionInformation */))
-  {
-    ec = asio::error::operation_not_supported;
-    return invalid_socket;
-  }
-
-  socket_type tmp = impl.socket_;
-  impl.socket_ = invalid_socket;
-  return tmp;
-}
-
-asio::error_code win_iocp_socket_service_base::cancel(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  ASIO_HANDLER_OPERATION((iocp_service_.context(),
-        "socket", &impl, impl.socket_, "cancel"));
-
-  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
-        ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
-  {
-    // The version of Windows supports cancellation from any thread.
-    typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
-    cancel_io_ex_t cancel_io_ex = reinterpret_cast<cancel_io_ex_t>(
-        reinterpret_cast<void*>(cancel_io_ex_ptr));
-    socket_type sock = impl.socket_;
-    HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
-    if (!cancel_io_ex(sock_as_handle, 0))
-    {
-      DWORD last_error = ::GetLastError();
-      if (last_error == ERROR_NOT_FOUND)
-      {
-        // ERROR_NOT_FOUND means that there were no operations to be
-        // cancelled. We swallow this error to match the behaviour on other
-        // platforms.
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-      }
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-#if defined(ASIO_ENABLE_CANCELIO)
-  else if (impl.safe_cancellation_thread_id_ == 0)
-  {
-    // No operations have been started, so there's nothing to cancel.
-    ec = asio::error_code();
-  }
-  else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
-  {
-    // Asynchronous operations have been started from the current thread only,
-    // so it is safe to try to cancel them using CancelIo.
-    socket_type sock = impl.socket_;
-    HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
-    if (!::CancelIo(sock_as_handle))
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-  else
-  {
-    // Asynchronous operations have been started from more than one thread,
-    // so cancellation is not safe.
-    ec = asio::error::operation_not_supported;
-  }
-#else // defined(ASIO_ENABLE_CANCELIO)
-  else
-  {
-    // Cancellation is not supported as CancelIo may not be used.
-    ec = asio::error::operation_not_supported;
-  }
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-  // Cancel any operations started via the reactor.
-  if (!ec)
-  {
-    select_reactor* r = static_cast<select_reactor*>(
-          interlocked_compare_exchange_pointer(
-            reinterpret_cast<void**>(&reactor_), 0, 0));
-    if (r)
-      r->cancel_ops(impl.socket_, impl.reactor_data_);
-  }
-
-  return ec;
-}
-
-asio::error_code win_iocp_socket_service_base::do_open(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    int family, int type, int protocol, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  socket_holder sock(socket_ops::socket(family, type, protocol, ec));
-  if (sock.get() == invalid_socket)
-    return ec;
-
-  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock.get());
-  if (iocp_service_.register_handle(sock_as_handle, ec))
-    return ec;
-
-  impl.socket_ = sock.release();
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  impl.cancel_token_.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_socket_service_base::do_assign(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    int type, socket_type native_socket, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  HANDLE sock_as_handle = reinterpret_cast<HANDLE>(native_socket);
-  if (iocp_service_.register_handle(sock_as_handle, ec))
-    return ec;
-
-  impl.socket_ = native_socket;
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  impl.cancel_token_.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-  ec = asio::error_code();
-  return ec;
-}
-
-void win_iocp_socket_service_base::start_send_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    WSABUF* buffers, std::size_t buffer_count,
-    socket_base::message_flags flags, bool noop, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (noop)
-    iocp_service_.on_completion(op);
-  else if (!is_open(impl))
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  else
-  {
-    DWORD bytes_transferred = 0;
-    int result = ::WSASend(impl.socket_, buffers,
-        static_cast<DWORD>(buffer_count), &bytes_transferred, flags, op, 0);
-    DWORD last_error = ::WSAGetLastError();
-    if (last_error == ERROR_PORT_UNREACHABLE)
-      last_error = WSAECONNREFUSED;
-    if (result != 0 && last_error != WSA_IO_PENDING)
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    else
-      iocp_service_.on_pending(op);
-  }
-}
-
-void win_iocp_socket_service_base::start_send_to_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    WSABUF* buffers, std::size_t buffer_count, const void* addr,
-    int addrlen, socket_base::message_flags flags, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  else
-  {
-    DWORD bytes_transferred = 0;
-    int result = ::WSASendTo(impl.socket_, buffers,
-        static_cast<DWORD>(buffer_count), &bytes_transferred, flags,
-        static_cast<const socket_addr_type*>(addr), addrlen, op, 0);
-    DWORD last_error = ::WSAGetLastError();
-    if (last_error == ERROR_PORT_UNREACHABLE)
-      last_error = WSAECONNREFUSED;
-    if (result != 0 && last_error != WSA_IO_PENDING)
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    else
-      iocp_service_.on_pending(op);
-  }
-}
-
-void win_iocp_socket_service_base::start_receive_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    WSABUF* buffers, std::size_t buffer_count,
-    socket_base::message_flags flags, bool noop, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (noop)
-    iocp_service_.on_completion(op);
-  else if (!is_open(impl))
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  else
-  {
-    DWORD bytes_transferred = 0;
-    DWORD recv_flags = flags;
-    int result = ::WSARecv(impl.socket_, buffers,
-        static_cast<DWORD>(buffer_count),
-        &bytes_transferred, &recv_flags, op, 0);
-    DWORD last_error = ::WSAGetLastError();
-    if (last_error == ERROR_NETNAME_DELETED)
-      last_error = WSAECONNRESET;
-    else if (last_error == ERROR_PORT_UNREACHABLE)
-      last_error = WSAECONNREFUSED;
-    if (result != 0 && last_error != WSA_IO_PENDING)
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    else
-      iocp_service_.on_pending(op);
-  }
-}
-
-int win_iocp_socket_service_base::start_null_buffers_receive_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    socket_base::message_flags flags, reactor_op* op, operation* iocp_op)
-{
-  if ((impl.state_ & socket_ops::stream_oriented) != 0)
-  {
-    // For stream sockets on Windows, we may issue a 0-byte overlapped
-    // WSARecv to wait until there is data available on the socket.
-    ::WSABUF buf = { 0, 0 };
-    start_receive_op(impl, &buf, 1, flags, false, iocp_op);
-    return -1;
-  }
-  else
-  {
-    int op_type = (flags & socket_base::message_out_of_band)
-      ? select_reactor::except_op : select_reactor::read_op;
-    start_reactor_op(impl, op_type, op);
-    return op_type;
-  }
-}
-
-void win_iocp_socket_service_base::start_receive_from_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    WSABUF* buffers, std::size_t buffer_count, void* addr,
-    socket_base::message_flags flags, int* addrlen, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  else
-  {
-    DWORD bytes_transferred = 0;
-    DWORD recv_flags = flags;
-    int result = ::WSARecvFrom(impl.socket_, buffers,
-        static_cast<DWORD>(buffer_count), &bytes_transferred, &recv_flags,
-        static_cast<socket_addr_type*>(addr), addrlen, op, 0);
-    DWORD last_error = ::WSAGetLastError();
-    if (last_error == ERROR_PORT_UNREACHABLE)
-      last_error = WSAECONNREFUSED;
-    if (result != 0 && last_error != WSA_IO_PENDING)
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    else
-      iocp_service_.on_pending(op);
-  }
-}
-
-void win_iocp_socket_service_base::start_accept_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    bool peer_is_open, socket_holder& new_socket, int family, int type,
-    int protocol, void* output_buffer, DWORD address_length, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  else if (peer_is_open)
-    iocp_service_.on_completion(op, asio::error::already_open);
-  else
-  {
-    asio::error_code ec;
-    new_socket.reset(socket_ops::socket(family, type, protocol, ec));
-    if (new_socket.get() == invalid_socket)
-      iocp_service_.on_completion(op, ec);
-    else
-    {
-      DWORD bytes_read = 0;
-      BOOL result = ::AcceptEx(impl.socket_, new_socket.get(), output_buffer,
-          0, address_length, address_length, &bytes_read, op);
-      DWORD last_error = ::WSAGetLastError();
-      if (!result && last_error != WSA_IO_PENDING)
-        iocp_service_.on_completion(op, last_error);
-      else
-        iocp_service_.on_pending(op);
-    }
-  }
-}
-
-void win_iocp_socket_service_base::restart_accept_op(
-    socket_type s, socket_holder& new_socket, int family, int type,
-    int protocol, void* output_buffer, DWORD address_length,
-    long* cancel_requested, operation* op)
-{
-  new_socket.reset();
-  iocp_service_.work_started();
-
-  // Check if we were cancelled after the first AcceptEx completed.
-  if (cancel_requested)
-    if (::InterlockedExchangeAdd(cancel_requested, 0) == 1)
-      iocp_service_.on_completion(op, asio::error::operation_aborted);
-
-  asio::error_code ec;
-  new_socket.reset(socket_ops::socket(family, type, protocol, ec));
-  if (new_socket.get() == invalid_socket)
-    iocp_service_.on_completion(op, ec);
-  else
-  {
-    DWORD bytes_read = 0;
-    BOOL result = ::AcceptEx(s, new_socket.get(), output_buffer,
-        0, address_length, address_length, &bytes_read, op);
-    DWORD last_error = ::WSAGetLastError();
-    if (!result && last_error != WSA_IO_PENDING)
-      iocp_service_.on_completion(op, last_error);
-    else
-    {
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      if (cancel_requested)
-      {
-        if (::InterlockedExchangeAdd(cancel_requested, 0) == 1)
-        {
-          HANDLE sock_as_handle = reinterpret_cast<HANDLE>(s);
-          ::CancelIoEx(sock_as_handle, op);
-        }
-      }
-#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      iocp_service_.on_pending(op);
-    }
-  }
-}
-
-void win_iocp_socket_service_base::start_reactor_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    int op_type, reactor_op* op)
-{
-  select_reactor& r = get_reactor();
-  update_cancellation_thread_id(impl);
-
-  if (is_open(impl))
-  {
-    r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false, false);
-    return;
-  }
-  else
-    op->ec_ = asio::error::bad_descriptor;
-
-  iocp_service_.post_immediate_completion(op, false);
-}
-
-int win_iocp_socket_service_base::start_connect_op(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    int family, int type, const void* addr, std::size_t addrlen,
-    win_iocp_socket_connect_op_base* op, operation* iocp_op)
-{
-  // If ConnectEx is available, use that.
-  if (family == ASIO_OS_DEF(AF_INET)
-      || family == ASIO_OS_DEF(AF_INET6))
-  {
-    if (connect_ex_fn connect_ex = get_connect_ex(impl, type))
-    {
-      union address_union
-      {
-        socket_addr_type base;
-        sockaddr_in4_type v4;
-        sockaddr_in6_type v6;
-      } a;
-
-      using namespace std; // For memset.
-      memset(&a, 0, sizeof(a));
-      a.base.sa_family = family;
-
-      socket_ops::bind(impl.socket_, &a.base,
-          family == ASIO_OS_DEF(AF_INET)
-          ? sizeof(a.v4) : sizeof(a.v6), op->ec_);
-      if (op->ec_ && op->ec_ != asio::error::invalid_argument)
-      {
-        iocp_service_.post_immediate_completion(op, false);
-        return -1;
-      }
-
-      op->connect_ex_ = true;
-      update_cancellation_thread_id(impl);
-      iocp_service_.work_started();
-
-      BOOL result = connect_ex(impl.socket_,
-          static_cast<const socket_addr_type*>(addr),
-          static_cast<int>(addrlen), 0, 0, 0, iocp_op);
-      DWORD last_error = ::WSAGetLastError();
-      if (!result && last_error != WSA_IO_PENDING)
-        iocp_service_.on_completion(iocp_op, last_error);
-      else
-        iocp_service_.on_pending(iocp_op);
-      return -1;
-    }
-  }
-
-  // Otherwise, fall back to a reactor-based implementation.
-  select_reactor& r = get_reactor();
-  update_cancellation_thread_id(impl);
-
-  if ((impl.state_ & socket_ops::non_blocking) != 0
-      || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, true, op->ec_))
-  {
-    if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
-    {
-      if (op->ec_ == asio::error::in_progress
-          || op->ec_ == asio::error::would_block)
-      {
-        op->ec_ = asio::error_code();
-        r.start_op(select_reactor::connect_op, impl.socket_,
-            impl.reactor_data_, op, false, false);
-        return select_reactor::connect_op;
-      }
-    }
-  }
-
-  r.post_immediate_completion(op, false);
-  return -1;
-}
-
-void win_iocp_socket_service_base::close_for_destruction(
-    win_iocp_socket_service_base::base_implementation_type& impl)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((iocp_service_.context(),
-          "socket", &impl, impl.socket_, "close"));
-
-    // Check if the reactor was created, in which case we need to close the
-    // socket on the reactor as well to cancel any operations that might be
-    // running there.
-    select_reactor* r = static_cast<select_reactor*>(
-          interlocked_compare_exchange_pointer(
-            reinterpret_cast<void**>(&reactor_), 0, 0));
-    if (r)
-      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
-
-    asio::error_code ignored_ec;
-    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
-
-    if (r)
-      r->cleanup_descriptor_data(impl.reactor_data_);
-  }
-
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.cancel_token_.reset();
-#if defined(ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-}
-
-void win_iocp_socket_service_base::update_cancellation_thread_id(
-    win_iocp_socket_service_base::base_implementation_type& impl)
-{
-#if defined(ASIO_ENABLE_CANCELIO)
-  if (impl.safe_cancellation_thread_id_ == 0)
-    impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
-  else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
-    impl.safe_cancellation_thread_id_ = ~DWORD(0);
-#else // defined(ASIO_ENABLE_CANCELIO)
-  (void)impl;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-}
-
-select_reactor& win_iocp_socket_service_base::get_reactor()
-{
-  select_reactor* r = static_cast<select_reactor*>(
-        interlocked_compare_exchange_pointer(
-          reinterpret_cast<void**>(&reactor_), 0, 0));
-  if (!r)
-  {
-    r = &(use_service<select_reactor>(context_));
-    interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r);
-  }
-  return *r;
-}
-
-win_iocp_socket_service_base::connect_ex_fn
-win_iocp_socket_service_base::get_connect_ex(
-    win_iocp_socket_service_base::base_implementation_type& impl, int type)
-{
-#if defined(ASIO_DISABLE_CONNECTEX)
-  (void)impl;
-  (void)type;
-  return 0;
-#else // defined(ASIO_DISABLE_CONNECTEX)
-  if (type != ASIO_OS_DEF(SOCK_STREAM)
-      && type != ASIO_OS_DEF(SOCK_SEQPACKET))
-    return 0;
-
-  void* ptr = interlocked_compare_exchange_pointer(&connect_ex_, 0, 0);
-  if (!ptr)
-  {
-    GUID guid = { 0x25a207b9, 0xddf3, 0x4660,
-      { 0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e } };
-
-    DWORD bytes = 0;
-    if (::WSAIoctl(impl.socket_, SIO_GET_EXTENSION_FUNCTION_POINTER,
-          &guid, sizeof(guid), &ptr, sizeof(ptr), &bytes, 0, 0) != 0)
-    {
-      // Set connect_ex_ to a special value to indicate that ConnectEx is
-      // unavailable. That way we won't bother trying to look it up again.
-      ptr = this;
-    }
-
-    interlocked_exchange_pointer(&connect_ex_, ptr);
-  }
-
-  return reinterpret_cast<connect_ex_fn>(ptr == this ? 0 : ptr);
-#endif // defined(ASIO_DISABLE_CONNECTEX)
-}
-
-win_iocp_socket_service_base::nt_set_info_fn
-win_iocp_socket_service_base::get_nt_set_info()
-{
-  void* ptr = interlocked_compare_exchange_pointer(&nt_set_info_, 0, 0);
-  if (!ptr)
-  {
-    if (HMODULE h = ::GetModuleHandleA("NTDLL.DLL"))
-      ptr = reinterpret_cast<void*>(GetProcAddress(h, "NtSetInformationFile"));
-
-    // On failure, set nt_set_info_ to a special value to indicate that the
-    // NtSetInformationFile function is unavailable. That way we won't bother
-    // trying to look it up again.
-    interlocked_exchange_pointer(&nt_set_info_, ptr ? ptr : this);
-  }
-
-  return reinterpret_cast<nt_set_info_fn>(ptr == this ? 0 : ptr);
-}
-
-void* win_iocp_socket_service_base::interlocked_compare_exchange_pointer(
-    void** dest, void* exch, void* cmp)
-{
-#if defined(_M_IX86)
-  return reinterpret_cast<void*>(InterlockedCompareExchange(
-        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch),
-        reinterpret_cast<LONG>(cmp)));
-#else
-  return InterlockedCompareExchangePointer(dest, exch, cmp);
-#endif
-}
-
-void* win_iocp_socket_service_base::interlocked_exchange_pointer(
-    void** dest, void* val)
-{
-#if defined(_M_IX86)
-  return reinterpret_cast<void*>(InterlockedExchange(
-        reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(val)));
-#else
-  return InterlockedExchangePointer(dest, val);
-#endif
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_mutex.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_mutex.ipp
deleted file mode 100644
index 6340b6e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_mutex.ipp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// detail/impl/win_mutex.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
-#define ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_mutex.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_mutex::win_mutex()
-{
-  int error = do_init();
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "mutex");
-}
-
-int win_mutex::do_init()
-{
-#if defined(__MINGW32__)
-  // Not sure if MinGW supports structured exception handling, so for now
-  // we'll just call the Windows API and hope.
-# if defined(UNDER_CE)
-  ::InitializeCriticalSection(&crit_section_);
-# elif defined(ASIO_WINDOWS_APP)
-  if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
-    return ::GetLastError();
-# else
-  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-    return ::GetLastError();
-# endif
-  return 0;
-#else
-  __try
-  {
-# if defined(UNDER_CE)
-    ::InitializeCriticalSection(&crit_section_);
-# elif defined(ASIO_WINDOWS_APP)
-    if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
-      return ::GetLastError();
-# else
-    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-      return ::GetLastError();
-# endif
-  }
-  __except(GetExceptionCode() == STATUS_NO_MEMORY
-      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
-  {
-    return ERROR_OUTOFMEMORY;
-  }
-
-  return 0;
-#endif
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_object_handle_service.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_object_handle_service.ipp
deleted file mode 100644
index d7db3e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_object_handle_service.ipp
+++ /dev/null
@@ -1,452 +0,0 @@
-//
-// detail/impl/win_object_handle_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#include "asio/detail/win_object_handle_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_object_handle_service::win_object_handle_service(execution_context& context)
-  : execution_context_service_base<win_object_handle_service>(context),
-    scheduler_(asio::use_service<scheduler_impl>(context)),
-    mutex_(),
-    impl_list_(0),
-    shutdown_(false)
-{
-}
-
-void win_object_handle_service::shutdown()
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Setting this flag to true prevents new objects from being registered, and
-  // new asynchronous wait operations from being started. We only need to worry
-  // about cleaning up the operations that are currently in progress.
-  shutdown_ = true;
-
-  op_queue<operation> ops;
-  for (implementation_type* impl = impl_list_; impl; impl = impl->next_)
-    ops.push(impl->op_queue_);
-
-  lock.unlock();
-
-  scheduler_.abandon_operations(ops);
-}
-
-void win_object_handle_service::construct(
-    win_object_handle_service::implementation_type& impl)
-{
-  impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.owner_ = this;
-
-  // Insert implementation into linked list of all implementations.
-  mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
-  {
-    impl.next_ = impl_list_;
-    impl.prev_ = 0;
-    if (impl_list_)
-      impl_list_->prev_ = &impl;
-    impl_list_ = &impl;
-  }
-}
-
-void win_object_handle_service::move_construct(
-    win_object_handle_service::implementation_type& impl,
-    win_object_handle_service::implementation_type& other_impl)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Insert implementation into linked list of all implementations.
-  if (!shutdown_)
-  {
-    impl.next_ = impl_list_;
-    impl.prev_ = 0;
-    if (impl_list_)
-      impl_list_->prev_ = &impl;
-    impl_list_ = &impl;
-  }
-
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = other_impl.wait_handle_;
-  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.op_queue_.push(other_impl.op_queue_);
-  impl.owner_ = this;
-
-  // We must not hold the lock while calling UnregisterWaitEx. This is because
-  // the registered callback function might be invoked while we are waiting for
-  // UnregisterWaitEx to complete.
-  lock.unlock();
-
-  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
-    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
-
-  if (!impl.op_queue_.empty())
-    register_wait_callback(impl, lock);
-}
-
-void win_object_handle_service::move_assign(
-    win_object_handle_service::implementation_type& impl,
-    win_object_handle_service& other_service,
-    win_object_handle_service::implementation_type& other_impl)
-{
-  asio::error_code ignored_ec;
-  close(impl, ignored_ec);
-
-  mutex::scoped_lock lock(mutex_);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    if (impl_list_ == &impl)
-      impl_list_ = impl.next_;
-    if (impl.prev_)
-      impl.prev_->next_ = impl.next_;
-    if (impl.next_)
-      impl.next_->prev_= impl.prev_;
-    impl.next_ = 0;
-    impl.prev_ = 0;
-  }
-
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = other_impl.wait_handle_;
-  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.op_queue_.push(other_impl.op_queue_);
-  impl.owner_ = this;
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    impl.next_ = other_service.impl_list_;
-    impl.prev_ = 0;
-    if (other_service.impl_list_)
-      other_service.impl_list_->prev_ = &impl;
-    other_service.impl_list_ = &impl;
-  }
-
-  // We must not hold the lock while calling UnregisterWaitEx. This is because
-  // the registered callback function might be invoked while we are waiting for
-  // UnregisterWaitEx to complete.
-  lock.unlock();
-
-  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
-    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
-
-  if (!impl.op_queue_.empty())
-    register_wait_callback(impl, lock);
-}
-
-void win_object_handle_service::destroy(
-    win_object_handle_service::implementation_type& impl)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Remove implementation from linked list of all implementations.
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close"));
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      impl.op_queue_.pop();
-      ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    ::CloseHandle(impl.handle_);
-    impl.handle_ = INVALID_HANDLE_VALUE;
-
-    scheduler_.post_deferred_completions(ops);
-  }
-}
-
-asio::error_code win_object_handle_service::assign(
-    win_object_handle_service::implementation_type& impl,
-    const native_handle_type& handle, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  impl.handle_ = handle;
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_object_handle_service::close(
-    win_object_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close"));
-
-    mutex::scoped_lock lock(mutex_);
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      impl.op_queue_.pop();
-      op->ec_ = asio::error::operation_aborted;
-      completed_ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    if (::CloseHandle(impl.handle_))
-    {
-      impl.handle_ = INVALID_HANDLE_VALUE;
-      ec = asio::error_code();
-    }
-    else
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-
-    scheduler_.post_deferred_completions(completed_ops);
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-asio::error_code win_object_handle_service::cancel(
-    win_object_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "cancel"));
-
-    mutex::scoped_lock lock(mutex_);
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      impl.op_queue_.pop();
-      completed_ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    ec = asio::error_code();
-
-    scheduler_.post_deferred_completions(completed_ops);
-  }
-  else
-  {
-    ec = asio::error::bad_descriptor;
-  }
-
-  ASIO_ERROR_LOCATION(ec);
-  return ec;
-}
-
-void win_object_handle_service::wait(
-    win_object_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  switch (::WaitForSingleObject(impl.handle_, INFINITE))
-  {
-  case WAIT_FAILED:
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-      ASIO_ERROR_LOCATION(ec);
-      break;
-    }
-  case WAIT_OBJECT_0:
-  case WAIT_ABANDONED:
-  default:
-    ec = asio::error_code();
-    break;
-  }
-}
-
-void win_object_handle_service::start_wait_op(
-    win_object_handle_service::implementation_type& impl, wait_op* op)
-{
-  scheduler_.work_started();
-
-  if (is_open(impl))
-  {
-    mutex::scoped_lock lock(mutex_);
-
-    if (!shutdown_)
-    {
-      impl.op_queue_.push(op);
-
-      // Only the first operation to be queued gets to register a wait callback.
-      // Subsequent operations have to wait for the first to finish.
-      if (impl.op_queue_.front() == op)
-        register_wait_callback(impl, lock);
-    }
-    else
-    {
-      lock.unlock();
-      scheduler_.post_deferred_completion(op);
-    }
-  }
-  else
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    scheduler_.post_deferred_completion(op);
-  }
-}
-
-void win_object_handle_service::register_wait_callback(
-    win_object_handle_service::implementation_type& impl,
-    mutex::scoped_lock& lock)
-{
-  lock.lock();
-
-  if (!RegisterWaitForSingleObject(&impl.wait_handle_,
-        impl.handle_, &win_object_handle_service::wait_callback,
-        &impl, INFINITE, WT_EXECUTEONLYONCE))
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = ec;
-      impl.op_queue_.pop();
-      completed_ops.push(op);
-    }
-
-    lock.unlock();
-    scheduler_.post_deferred_completions(completed_ops);
-  }
-}
-
-void win_object_handle_service::wait_callback(PVOID param, BOOLEAN)
-{
-  implementation_type* impl = static_cast<implementation_type*>(param);
-  mutex::scoped_lock lock(impl->owner_->mutex_);
-
-  if (impl->wait_handle_ != INVALID_HANDLE_VALUE)
-  {
-    ::UnregisterWaitEx(impl->wait_handle_, NULL);
-    impl->wait_handle_ = INVALID_HANDLE_VALUE;
-  }
-
-  if (wait_op* op = impl->op_queue_.front())
-  {
-    op_queue<operation> completed_ops;
-
-    op->ec_ = asio::error_code();
-    impl->op_queue_.pop();
-    completed_ops.push(op);
-
-    if (!impl->op_queue_.empty())
-    {
-      if (!RegisterWaitForSingleObject(&impl->wait_handle_,
-            impl->handle_, &win_object_handle_service::wait_callback,
-            param, INFINITE, WT_EXECUTEONLYONCE))
-      {
-        DWORD last_error = ::GetLastError();
-        asio::error_code ec(last_error,
-            asio::error::get_system_category());
-
-        while ((op = impl->op_queue_.front()) != 0)
-        {
-          op->ec_ = ec;
-          impl->op_queue_.pop();
-          completed_ops.push(op);
-        }
-      }
-    }
-
-    scheduler_impl& sched = impl->owner_->scheduler_;
-    lock.unlock();
-    sched.post_deferred_completions(completed_ops);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#endif // ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_static_mutex.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_static_mutex.ipp
deleted file mode 100644
index 5b45984..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_static_mutex.ipp
+++ /dev/null
@@ -1,136 +0,0 @@
-//
-// detail/impl/win_static_mutex.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
-#define ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include <cstdio>
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_static_mutex.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void win_static_mutex::init()
-{
-  int error = do_init();
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "static_mutex");
-}
-
-int win_static_mutex::do_init()
-{
-  using namespace std; // For sprintf.
-  wchar_t mutex_name[128];
-#if defined(ASIO_HAS_SECURE_RTL)
-  swprintf_s(
-#else // defined(ASIO_HAS_SECURE_RTL)
-  _snwprintf(
-#endif // defined(ASIO_HAS_SECURE_RTL)
-      mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
-      static_cast<unsigned int>(::GetCurrentProcessId()), this);
-
-#if defined(ASIO_WINDOWS_APP)
-  HANDLE mutex = ::CreateMutexExW(0, mutex_name, CREATE_MUTEX_INITIAL_OWNER, 0);
-#else // defined(ASIO_WINDOWS_APP)
-  HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
-#endif // defined(ASIO_WINDOWS_APP)
-  DWORD last_error = ::GetLastError();
-  if (mutex == 0)
-    return ::GetLastError();
-
-  if (last_error == ERROR_ALREADY_EXISTS)
-  {
-#if defined(ASIO_WINDOWS_APP)
-    ::WaitForSingleObjectEx(mutex, INFINITE, false);
-#else // defined(ASIO_WINDOWS_APP)
-    ::WaitForSingleObject(mutex, INFINITE);
-#endif // defined(ASIO_WINDOWS_APP)
-  }
-
-  if (initialised_)
-  {
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return 0;
-  }
-
-#if defined(__MINGW32__)
-  // Not sure if MinGW supports structured exception handling, so for now
-  // we'll just call the Windows API and hope.
-# if defined(UNDER_CE)
-  ::InitializeCriticalSection(&crit_section_);
-# else
-  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-  {
-    last_error = ::GetLastError();
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return last_error;
-  }
-# endif
-#else
-  __try
-  {
-# if defined(UNDER_CE)
-    ::InitializeCriticalSection(&crit_section_);
-# elif defined(ASIO_WINDOWS_APP)
-    if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0))
-    {
-      last_error = ::GetLastError();
-      ::ReleaseMutex(mutex);
-      ::CloseHandle(mutex);
-      return last_error;
-    }
-# else
-    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-    {
-      last_error = ::GetLastError();
-      ::ReleaseMutex(mutex);
-      ::CloseHandle(mutex);
-      return last_error;
-    }
-# endif
-  }
-  __except(GetExceptionCode() == STATUS_NO_MEMORY
-      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
-  {
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return ERROR_OUTOFMEMORY;
-  }
-#endif
-
-  initialised_ = true;
-  ::ReleaseMutex(mutex);
-  ::CloseHandle(mutex);
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_thread.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_thread.ipp
deleted file mode 100644
index 0ebc5db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_thread.ipp
+++ /dev/null
@@ -1,150 +0,0 @@
-//
-// detail/impl/win_thread.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_THREAD_IPP
-#define ASIO_DETAIL_IMPL_WIN_THREAD_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_APP) \
-  && !defined(UNDER_CE)
-
-#include <process.h>
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_thread.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_thread::~win_thread()
-{
-  ::CloseHandle(thread_);
-
-  // The exit_event_ handle is deliberately allowed to leak here since it
-  // is an error for the owner of an internal thread not to join() it.
-}
-
-void win_thread::join()
-{
-  HANDLE handles[2] = { exit_event_, thread_ };
-  ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
-  ::CloseHandle(exit_event_);
-  if (terminate_threads())
-  {
-    ::TerminateThread(thread_, 0);
-  }
-  else
-  {
-    ::QueueUserAPC(apc_function, thread_, 0);
-    ::WaitForSingleObject(thread_, INFINITE);
-  }
-}
-
-std::size_t win_thread::hardware_concurrency()
-{
-  SYSTEM_INFO system_info;
-  ::GetSystemInfo(&system_info);
-  return system_info.dwNumberOfProcessors;
-}
-
-void win_thread::start_thread(func_base* arg, unsigned int stack_size)
-{
-  ::HANDLE entry_event = 0;
-  arg->entry_event_ = entry_event = ::CreateEventW(0, true, false, 0);
-  if (!entry_event)
-  {
-    DWORD last_error = ::GetLastError();
-    delete arg;
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "thread.entry_event");
-  }
-
-  arg->exit_event_ = exit_event_ = ::CreateEventW(0, true, false, 0);
-  if (!exit_event_)
-  {
-    DWORD last_error = ::GetLastError();
-    delete arg;
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "thread.exit_event");
-  }
-
-  unsigned int thread_id = 0;
-  thread_ = reinterpret_cast<HANDLE>(::_beginthreadex(0,
-        stack_size, win_thread_function, arg, 0, &thread_id));
-  if (!thread_)
-  {
-    DWORD last_error = ::GetLastError();
-    delete arg;
-    if (entry_event)
-      ::CloseHandle(entry_event);
-    if (exit_event_)
-      ::CloseHandle(exit_event_);
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "thread");
-  }
-
-  if (entry_event)
-  {
-    ::WaitForSingleObject(entry_event, INFINITE);
-    ::CloseHandle(entry_event);
-  }
-}
-
-unsigned int __stdcall win_thread_function(void* arg)
-{
-  win_thread::auto_func_base_ptr func = {
-      static_cast<win_thread::func_base*>(arg) };
-
-  ::SetEvent(func.ptr->entry_event_);
-
-  func.ptr->run();
-
-  // Signal that the thread has finished its work, but rather than returning go
-  // to sleep to put the thread into a well known state. If the thread is being
-  // joined during global object destruction then it may be killed using
-  // TerminateThread (to avoid a deadlock in DllMain). Otherwise, the SleepEx
-  // call will be interrupted using QueueUserAPC and the thread will shut down
-  // cleanly.
-  HANDLE exit_event = func.ptr->exit_event_;
-  delete func.ptr;
-  func.ptr = 0;
-  ::SetEvent(exit_event);
-  ::SleepEx(INFINITE, TRUE);
-
-  return 0;
-}
-
-#if defined(WINVER) && (WINVER < 0x0500)
-void __stdcall apc_function(ULONG) {}
-#else
-void __stdcall apc_function(ULONG_PTR) {}
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-       // && !defined(ASIO_WINDOWS_APP)
-       // && !defined(UNDER_CE)
-
-#endif // ASIO_DETAIL_IMPL_WIN_THREAD_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_tss_ptr.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_tss_ptr.ipp
deleted file mode 100644
index 5bc9de2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/win_tss_ptr.ipp
+++ /dev/null
@@ -1,57 +0,0 @@
-//
-// detail/impl/win_tss_ptr.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
-#define ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_tss_ptr.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-DWORD win_tss_ptr_create()
-{
-#if defined(UNDER_CE)
-  const DWORD out_of_indexes = 0xFFFFFFFF;
-#else
-  const DWORD out_of_indexes = TLS_OUT_OF_INDEXES;
-#endif
-
-  DWORD tss_key = ::TlsAlloc();
-  if (tss_key == out_of_indexes)
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "tss");
-  }
-  return tss_key;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_ssocket_service_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_ssocket_service_base.ipp
deleted file mode 100644
index 90a0354..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_ssocket_service_base.ipp
+++ /dev/null
@@ -1,626 +0,0 @@
-//
-// detail/impl/winrt_ssocket_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include <cstring>
-#include "asio/detail/winrt_ssocket_service_base.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/detail/winrt_utils.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-winrt_ssocket_service_base::winrt_ssocket_service_base(
-    execution_context& context)
-  : scheduler_(use_service<scheduler_impl>(context)),
-    async_manager_(use_service<winrt_async_manager>(context)),
-    mutex_(),
-    impl_list_(0)
-{
-}
-
-void winrt_ssocket_service_base::base_shutdown()
-{
-  // Close all implementations, causing all operations to complete.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  base_implementation_type* impl = impl_list_;
-  while (impl)
-  {
-    asio::error_code ignored_ec;
-    close(*impl, ignored_ec);
-    impl = impl->next_;
-  }
-}
-
-void winrt_ssocket_service_base::construct(
-    winrt_ssocket_service_base::base_implementation_type& impl)
-{
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void winrt_ssocket_service_base::base_move_construct(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    winrt_ssocket_service_base::base_implementation_type& other_impl)
-  noexcept
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = nullptr;
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void winrt_ssocket_service_base::base_move_assign(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    winrt_ssocket_service_base& other_service,
-    winrt_ssocket_service_base::base_implementation_type& other_impl)
-{
-  asio::error_code ignored_ec;
-  close(impl, ignored_ec);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    if (impl_list_ == &impl)
-      impl_list_ = impl.next_;
-    if (impl.prev_)
-      impl.prev_->next_ = impl.next_;
-    if (impl.next_)
-      impl.next_->prev_= impl.prev_;
-    impl.next_ = 0;
-    impl.prev_ = 0;
-  }
-
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = nullptr;
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
-    impl.next_ = other_service.impl_list_;
-    impl.prev_ = 0;
-    if (other_service.impl_list_)
-      other_service.impl_list_->prev_ = &impl;
-    other_service.impl_list_ = &impl;
-  }
-}
-
-void winrt_ssocket_service_base::destroy(
-    winrt_ssocket_service_base::base_implementation_type& impl)
-{
-  asio::error_code ignored_ec;
-  close(impl, ignored_ec);
-
-  // Remove implementation from linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-}
-
-asio::error_code winrt_ssocket_service_base::close(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  delete impl.socket_;
-  impl.socket_ = nullptr;
-  ec = asio::error_code();
-  return ec;
-}
-
-winrt_ssocket_service_base::native_handle_type
-winrt_ssocket_service_base::release(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-    return nullptr;
-
-  cancel(impl, ec);
-  if (ec)
-    return nullptr;
-
-  native_handle_type tmp = impl.socket_;
-  impl.socket_ = nullptr;
-  return tmp;
-}
-
-std::size_t winrt_ssocket_service_base::do_get_endpoint(
-    const base_implementation_type& impl, bool local,
-    void* addr, std::size_t addr_len, asio::error_code& ec) const
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return addr_len;
-  }
-
-  try
-  {
-    std::string addr_string = winrt_utils::string(local
-        ? impl.socket_->Information->LocalAddress->CanonicalName
-        : impl.socket_->Information->RemoteAddress->CanonicalName);
-    unsigned short port = winrt_utils::integer(local
-        ? impl.socket_->Information->LocalPort
-        : impl.socket_->Information->RemotePort);
-    unsigned long scope = 0;
-
-    switch (static_cast<const socket_addr_type*>(addr)->sa_family)
-    {
-    case ASIO_OS_DEF(AF_INET):
-      if (addr_len < sizeof(sockaddr_in4_type))
-      {
-        ec = asio::error::invalid_argument;
-        return addr_len;
-      }
-      else
-      {
-        socket_ops::inet_pton(ASIO_OS_DEF(AF_INET), addr_string.c_str(),
-            &reinterpret_cast<sockaddr_in4_type*>(addr)->sin_addr, &scope, ec);
-        reinterpret_cast<sockaddr_in4_type*>(addr)->sin_port
-          = socket_ops::host_to_network_short(port);
-        ec = asio::error_code();
-        return sizeof(sockaddr_in4_type);
-      }
-    case ASIO_OS_DEF(AF_INET6):
-      if (addr_len < sizeof(sockaddr_in6_type))
-      {
-        ec = asio::error::invalid_argument;
-        return addr_len;
-      }
-      else
-      {
-        socket_ops::inet_pton(ASIO_OS_DEF(AF_INET6), addr_string.c_str(),
-            &reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_addr, &scope, ec);
-        reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_port
-          = socket_ops::host_to_network_short(port);
-        ec = asio::error_code();
-        return sizeof(sockaddr_in6_type);
-      }
-    default:
-      ec = asio::error::address_family_not_supported;
-      return addr_len;
-    }
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-    return addr_len;
-  }
-}
-
-asio::error_code winrt_ssocket_service_base::do_set_option(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    int level, int optname, const void* optval,
-    std::size_t optlen, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  try
-  {
-    if (level == ASIO_OS_DEF(SOL_SOCKET)
-        && optname == ASIO_OS_DEF(SO_KEEPALIVE))
-    {
-      if (optlen == sizeof(int))
-      {
-        int value = 0;
-        std::memcpy(&value, optval, optlen);
-        impl.socket_->Control->KeepAlive = !!value;
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error::invalid_argument;
-      }
-    }
-    else if (level == ASIO_OS_DEF(IPPROTO_TCP)
-        && optname == ASIO_OS_DEF(TCP_NODELAY))
-    {
-      if (optlen == sizeof(int))
-      {
-        int value = 0;
-        std::memcpy(&value, optval, optlen);
-        impl.socket_->Control->NoDelay = !!value;
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error::invalid_argument;
-      }
-    }
-    else
-    {
-      ec = asio::error::invalid_argument;
-    }
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-  }
-
-  return ec;
-}
-
-void winrt_ssocket_service_base::do_get_option(
-    const winrt_ssocket_service_base::base_implementation_type& impl,
-    int level, int optname, void* optval,
-    std::size_t* optlen, asio::error_code& ec) const
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return;
-  }
-
-  try
-  {
-    if (level == ASIO_OS_DEF(SOL_SOCKET)
-        && optname == ASIO_OS_DEF(SO_KEEPALIVE))
-    {
-      if (*optlen >= sizeof(int))
-      {
-        int value = impl.socket_->Control->KeepAlive ? 1 : 0;
-        std::memcpy(optval, &value, sizeof(int));
-        *optlen = sizeof(int);
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error::invalid_argument;
-      }
-    }
-    else if (level == ASIO_OS_DEF(IPPROTO_TCP)
-        && optname == ASIO_OS_DEF(TCP_NODELAY))
-    {
-      if (*optlen >= sizeof(int))
-      {
-        int value = impl.socket_->Control->NoDelay ? 1 : 0;
-        std::memcpy(optval, &value, sizeof(int));
-        *optlen = sizeof(int);
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error::invalid_argument;
-      }
-    }
-    else
-    {
-      ec = asio::error::invalid_argument;
-    }
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-  }
-}
-
-asio::error_code winrt_ssocket_service_base::do_connect(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    const void* addr, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  char addr_string[max_addr_v6_str_len];
-  unsigned short port;
-  switch (static_cast<const socket_addr_type*>(addr)->sa_family)
-  {
-  case ASIO_OS_DEF(AF_INET):
-    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET),
-        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
-        addr_string, sizeof(addr_string), 0, ec);
-    port = socket_ops::network_to_host_short(
-        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
-    break;
-  case ASIO_OS_DEF(AF_INET6):
-    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET6),
-        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
-        addr_string, sizeof(addr_string), 0, ec);
-    port = socket_ops::network_to_host_short(
-        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
-    break;
-  default:
-    ec = asio::error::address_family_not_supported;
-    return ec;
-  }
-
-  if (!ec) try
-  {
-    async_manager_.sync(impl.socket_->ConnectAsync(
-          ref new Windows::Networking::HostName(
-            winrt_utils::string(addr_string)),
-          winrt_utils::string(port)), ec);
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-  }
-
-  return ec;
-}
-
-void winrt_ssocket_service_base::start_connect_op(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    const void* addr, winrt_async_op<void>* op, bool is_continuation)
-{
-  if (!is_open(impl))
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  char addr_string[max_addr_v6_str_len];
-  unsigned short port = 0;
-  switch (static_cast<const socket_addr_type*>(addr)->sa_family)
-  {
-  case ASIO_OS_DEF(AF_INET):
-    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET),
-        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
-        addr_string, sizeof(addr_string), 0, op->ec_);
-    port = socket_ops::network_to_host_short(
-        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
-    break;
-  case ASIO_OS_DEF(AF_INET6):
-    socket_ops::inet_ntop(ASIO_OS_DEF(AF_INET6),
-        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
-        addr_string, sizeof(addr_string), 0, op->ec_);
-    port = socket_ops::network_to_host_short(
-        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
-    break;
-  default:
-    op->ec_ = asio::error::address_family_not_supported;
-    break;
-  }
-
-  if (op->ec_)
-  {
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  try
-  {
-    async_manager_.async(impl.socket_->ConnectAsync(
-          ref new Windows::Networking::HostName(
-            winrt_utils::string(addr_string)),
-          winrt_utils::string(port)), op);
-  }
-  catch (Platform::Exception^ e)
-  {
-    op->ec_ = asio::error_code(
-        e->HResult, asio::system_category());
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-std::size_t winrt_ssocket_service_base::do_send(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    const asio::const_buffer& data,
-    socket_base::message_flags flags, asio::error_code& ec)
-{
-  if (flags)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  try
-  {
-    buffer_sequence_adapter<asio::const_buffer,
-      asio::const_buffer> bufs(asio::buffer(data));
-
-    if (bufs.all_empty())
-    {
-      ec = asio::error_code();
-      return 0;
-    }
-
-    return async_manager_.sync(
-        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), ec);
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-    return 0;
-  }
-}
-
-void winrt_ssocket_service_base::start_send_op(
-      winrt_ssocket_service_base::base_implementation_type& impl,
-      const asio::const_buffer& data, socket_base::message_flags flags,
-      winrt_async_op<unsigned int>* op, bool is_continuation)
-{
-  if (flags)
-  {
-    op->ec_ = asio::error::operation_not_supported;
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  if (!is_open(impl))
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  try
-  {
-    buffer_sequence_adapter<asio::const_buffer,
-        asio::const_buffer> bufs(asio::buffer(data));
-
-    if (bufs.all_empty())
-    {
-      scheduler_.post_immediate_completion(op, is_continuation);
-      return;
-    }
-
-    async_manager_.async(
-        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), op);
-  }
-  catch (Platform::Exception^ e)
-  {
-    op->ec_ = asio::error_code(e->HResult,
-        asio::system_category());
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-std::size_t winrt_ssocket_service_base::do_receive(
-    winrt_ssocket_service_base::base_implementation_type& impl,
-    const asio::mutable_buffer& data,
-    socket_base::message_flags flags, asio::error_code& ec)
-{
-  if (flags)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  try
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        asio::mutable_buffer> bufs(asio::buffer(data));
-
-    if (bufs.all_empty())
-    {
-      ec = asio::error_code();
-      return 0;
-    }
-
-    async_manager_.sync(
-        impl.socket_->InputStream->ReadAsync(
-          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
-          Windows::Storage::Streams::InputStreamOptions::Partial), ec);
-
-    std::size_t bytes_transferred = bufs.buffers()[0]->Length;
-    if (bytes_transferred == 0 && !ec)
-    {
-      ec = asio::error::eof;
-    }
-
-    return bytes_transferred;
-  }
-  catch (Platform::Exception^ e)
-  {
-    ec = asio::error_code(e->HResult,
-        asio::system_category());
-    return 0;
-  }
-}
-
-void winrt_ssocket_service_base::start_receive_op(
-      winrt_ssocket_service_base::base_implementation_type& impl,
-      const asio::mutable_buffer& data, socket_base::message_flags flags,
-      winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
-      bool is_continuation)
-{
-  if (flags)
-  {
-    op->ec_ = asio::error::operation_not_supported;
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  if (!is_open(impl))
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    scheduler_.post_immediate_completion(op, is_continuation);
-    return;
-  }
-
-  try
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        asio::mutable_buffer> bufs(asio::buffer(data));
-
-    if (bufs.all_empty())
-    {
-      scheduler_.post_immediate_completion(op, is_continuation);
-      return;
-    }
-
-    async_manager_.async(
-        impl.socket_->InputStream->ReadAsync(
-          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
-          Windows::Storage::Streams::InputStreamOptions::Partial), op);
-  }
-  catch (Platform::Exception^ e)
-  {
-    op->ec_ = asio::error_code(e->HResult,
-        asio::system_category());
-    scheduler_.post_immediate_completion(op, is_continuation);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.hpp
deleted file mode 100644
index 9c96750..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//
-// detail/impl/winrt_timer_scheduler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
-#define ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void winrt_timer_scheduler::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void winrt_timer_scheduler::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    scheduler_.post_immediate_completion(op, false);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  scheduler_.work_started();
-  if (earliest)
-    event_.signal(lock);
-}
-
-template <typename Time_Traits>
-std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-  return n;
-}
-
-template <typename Time_Traits>
-void winrt_timer_scheduler::move_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& to,
-    typename timer_queue<Time_Traits>::per_timer_data& from)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  queue.cancel_timer(to, ops);
-  queue.move_timer(to, from);
-  lock.unlock();
-  scheduler_.post_deferred_completions(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.ipp
deleted file mode 100644
index 028b5f9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winrt_timer_scheduler.ipp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// detail/impl/winrt_timer_scheduler.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
-#define ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/winrt_timer_scheduler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-winrt_timer_scheduler::winrt_timer_scheduler(execution_context& context)
-  : execution_context_service_base<winrt_timer_scheduler>(context),
-    scheduler_(use_service<scheduler_impl>(context)),
-    mutex_(),
-    event_(),
-    timer_queues_(),
-    thread_(0),
-    stop_thread_(false),
-    shutdown_(false)
-{
-  thread_ = new asio::detail::thread(
-      bind_handler(&winrt_timer_scheduler::call_run_thread, this));
-}
-
-winrt_timer_scheduler::~winrt_timer_scheduler()
-{
-  shutdown();
-}
-
-void winrt_timer_scheduler::shutdown()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  stop_thread_ = true;
-  event_.signal(lock);
-  lock.unlock();
-
-  if (thread_)
-  {
-    thread_->join();
-    delete thread_;
-    thread_ = 0;
-  }
-
-  op_queue<operation> ops;
-  timer_queues_.get_all_timers(ops);
-  scheduler_.abandon_operations(ops);
-}
-
-void winrt_timer_scheduler::notify_fork(execution_context::fork_event)
-{
-}
-
-void winrt_timer_scheduler::init_task()
-{
-}
-
-void winrt_timer_scheduler::run_thread()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  while (!stop_thread_)
-  {
-    const long max_wait_duration = 5 * 60 * 1000000;
-    long wait_duration = timer_queues_.wait_duration_usec(max_wait_duration);
-    event_.wait_for_usec(lock, wait_duration);
-    event_.clear(lock);
-    op_queue<operation> ops;
-    timer_queues_.get_ready_timers(ops);
-    if (!ops.empty())
-    {
-      lock.unlock();
-      scheduler_.post_deferred_completions(ops);
-      lock.lock();
-    }
-  }
-}
-
-void winrt_timer_scheduler::call_run_thread(winrt_timer_scheduler* scheduler)
-{
-  scheduler->run_thread();
-}
-
-void winrt_timer_scheduler::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void winrt_timer_scheduler::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winsock_init.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winsock_init.ipp
deleted file mode 100644
index 5b5f560..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/impl/winsock_init.ipp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// detail/impl/winsock_init.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
-#define ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/winsock_init.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void winsock_init_base::startup(data& d,
-    unsigned char major, unsigned char minor)
-{
-  if (::InterlockedIncrement(&d.init_count_) == 1)
-  {
-    WSADATA wsa_data;
-    long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data);
-    ::InterlockedExchange(&d.result_, result);
-  }
-}
-
-void winsock_init_base::manual_startup(data& d)
-{
-  if (::InterlockedIncrement(&d.init_count_) == 1)
-  {
-    ::InterlockedExchange(&d.result_, 0);
-  }
-}
-
-void winsock_init_base::cleanup(data& d)
-{
-  if (::InterlockedDecrement(&d.init_count_) == 0)
-  {
-    ::WSACleanup();
-  }
-}
-
-void winsock_init_base::manual_cleanup(data& d)
-{
-  ::InterlockedDecrement(&d.init_count_);
-}
-
-void winsock_init_base::throw_on_error(data& d)
-{
-  long result = ::InterlockedExchangeAdd(&d.result_, 0);
-  if (result != 0)
-  {
-    asio::error_code ec(result,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "winsock");
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_defer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_defer.hpp
deleted file mode 100644
index 92abb0a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_defer.hpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//
-// detail/initiate_defer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_INITIATE_DEFER_HPP
-#define ASIO_DETAIL_INITIATE_DEFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/detail/work_dispatcher.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/relationship.hpp"
-#include "asio/prefer.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class initiate_defer
-{
-public:
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex, execution::blocking.never),
-        execution::relationship.continuation,
-        execution::allocator(alloc)
-      ).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex.defer(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-};
-
-template <typename Executor>
-class initiate_defer_with_executor
-{
-public:
-  typedef Executor executor_type;
-
-  explicit initiate_defer_with_executor(const Executor& ex)
-    : ex_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return ex_;
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex_, execution::blocking.never),
-        execution::relationship.continuation,
-        execution::allocator(alloc)
-      ).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex_, execution::blocking.never),
-        execution::relationship.continuation,
-        execution::allocator(alloc)
-      ).execute(
-        detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.defer(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.defer(detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex), alloc);
-  }
-
-private:
-  Executor ex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_INITIATE_DEFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_dispatch.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_dispatch.hpp
deleted file mode 100644
index ba2f68f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_dispatch.hpp
+++ /dev/null
@@ -1,193 +0,0 @@
-//
-// detail/initiate_dispatch.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_INITIATE_DISPATCH_HPP
-#define ASIO_DETAIL_INITIATE_DISPATCH_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/detail/work_dispatcher.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/prefer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class initiate_dispatch
-{
-public:
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(ex, execution::allocator(alloc)).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex.dispatch(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-};
-
-template <typename Executor>
-class initiate_dispatch_with_executor
-{
-public:
-  typedef Executor executor_type;
-
-  explicit initiate_dispatch_with_executor(const Executor& ex)
-    : ex_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return ex_;
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(ex_, execution::allocator(alloc)).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(ex_, execution::allocator(alloc)).execute(
-        detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.dispatch(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.dispatch(detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex), alloc);
-  }
-
-private:
-  Executor ex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_INITIATE_DISPATCH_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_post.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_post.hpp
deleted file mode 100644
index f73c8ee..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiate_post.hpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//
-// detail/initiate_post.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_INITIATE_POST_HPP
-#define ASIO_DETAIL_INITIATE_POST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/detail/work_dispatcher.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/relationship.hpp"
-#include "asio/prefer.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class initiate_post
-{
-public:
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex, execution::blocking.never),
-        execution::relationship.fork,
-        execution::allocator(alloc)
-      ).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          associated_executor_t<decay_t<CompletionHandler>>
-        >::value
-      >* = 0) const
-  {
-    associated_executor_t<decay_t<CompletionHandler>> ex(
-        (get_associated_executor)(handler));
-
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex.post(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-};
-
-template <typename Executor>
-class initiate_post_with_executor
-{
-public:
-  typedef Executor executor_type;
-
-  explicit initiate_post_with_executor(const Executor& ex)
-    : ex_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return ex_;
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex_, execution::blocking.never),
-        execution::relationship.fork,
-        execution::allocator(alloc)
-      ).execute(
-        asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    asio::prefer(
-        asio::require(ex_, execution::blocking.never),
-        execution::relationship.fork,
-        execution::allocator(alloc)
-      ).execute(
-        detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex));
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        !detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    associated_allocator_t<decay_t<CompletionHandler>> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.post(asio::detail::bind_handler(
-          static_cast<CompletionHandler&&>(handler)), alloc);
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler,
-      enable_if_t<
-        !execution::is_executor<
-          conditional_t<true, executor_type, CompletionHandler>
-        >::value
-      >* = 0,
-      enable_if_t<
-        detail::is_work_dispatcher_required<
-          decay_t<CompletionHandler>,
-          Executor
-        >::value
-      >* = 0) const
-  {
-    typedef decay_t<CompletionHandler> handler_t;
-
-    typedef associated_executor_t<handler_t, Executor> handler_ex_t;
-    handler_ex_t handler_ex((get_associated_executor)(handler, ex_));
-
-    associated_allocator_t<handler_t> alloc(
-        (get_associated_allocator)(handler));
-
-    ex_.post(detail::work_dispatcher<handler_t, handler_ex_t>(
-          static_cast<CompletionHandler&&>(handler), handler_ex), alloc);
-  }
-
-private:
-  Executor ex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_INITIATE_POST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiation_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiation_base.hpp
deleted file mode 100644
index 0888cec..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/initiation_base.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// detail/initiation_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_INITIATION_BASE_HPP
-#define ASIO_DETAIL_INITIATION_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Initiation, typename = void>
-class initiation_base : public Initiation
-{
-public:
-  template <typename I>
-  explicit initiation_base(I&& initiation)
-    : Initiation(static_cast<I&&>(initiation))
-  {
-  }
-};
-
-template <typename Initiation>
-class initiation_base<Initiation, enable_if_t<!is_class<Initiation>::value>>
-{
-public:
-  template <typename I>
-  explicit initiation_base(I&& initiation)
-    : initiation_(static_cast<I&&>(initiation))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args) const
-  {
-    initiation_(static_cast<Args&&>(args)...);
-  }
-
-private:
-  Initiation initiation_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_INITIATION_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_control.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_control.hpp
deleted file mode 100644
index 14daf85..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_control.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// detail/io_control.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_CONTROL_HPP
-#define ASIO_DETAIL_IO_CONTROL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace io_control {
-
-// I/O control command for getting number of bytes available.
-class bytes_readable
-{
-public:
-  // Default constructor.
-  bytes_readable()
-    : value_(0)
-  {
-  }
-
-  // Construct with a specific command value.
-  bytes_readable(std::size_t value)
-    : value_(static_cast<detail::ioctl_arg_type>(value))
-  {
-  }
-
-  // Get the name of the IO control command.
-  int name() const
-  {
-    return static_cast<int>(ASIO_OS_DEF(FIONREAD));
-  }
-
-  // Set the value of the I/O control command.
-  void set(std::size_t value)
-  {
-    value_ = static_cast<detail::ioctl_arg_type>(value);
-  }
-
-  // Get the current value of the I/O control command.
-  std::size_t get() const
-  {
-    return static_cast<std::size_t>(value_);
-  }
-
-  // Get the address of the command data.
-  detail::ioctl_arg_type* data()
-  {
-    return &value_;
-  }
-
-  // Get the address of the command data.
-  const detail::ioctl_arg_type* data() const
-  {
-    return &value_;
-  }
-
-private:
-  detail::ioctl_arg_type value_;
-};
-
-} // namespace io_control
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IO_CONTROL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_object_impl.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_object_impl.hpp
deleted file mode 100644
index bd7312b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_object_impl.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//
-// detail/io_object_impl.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_OBJECT_IMPL_HPP
-#define ASIO_DETAIL_IO_OBJECT_IMPL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <new>
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/context.hpp"
-#include "asio/io_context.hpp"
-#include "asio/query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename IoObjectService,
-    typename Executor = io_context::executor_type>
-class io_object_impl
-{
-public:
-  // The type of the service that will be used to provide I/O operations.
-  typedef IoObjectService service_type;
-
-  // The underlying implementation type of I/O object.
-  typedef typename service_type::implementation_type implementation_type;
-
-  // The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  // Construct an I/O object using an executor.
-  explicit io_object_impl(int, const executor_type& ex)
-    : service_(&asio::use_service<IoObjectService>(
-          io_object_impl::get_context(ex))),
-      executor_(ex)
-  {
-    service_->construct(implementation_);
-  }
-
-  // Construct an I/O object using an execution context.
-  template <typename ExecutionContext>
-  explicit io_object_impl(int, int, ExecutionContext& context)
-    : service_(&asio::use_service<IoObjectService>(context)),
-      executor_(context.get_executor())
-  {
-    service_->construct(implementation_);
-  }
-
-  // Move-construct an I/O object.
-  io_object_impl(io_object_impl&& other)
-    : service_(&other.get_service()),
-      executor_(other.get_executor())
-  {
-    service_->move_construct(implementation_, other.implementation_);
-  }
-
-  // Perform converting move-construction of an I/O object on the same service.
-  template <typename Executor1>
-  io_object_impl(io_object_impl<IoObjectService, Executor1>&& other)
-    : service_(&other.get_service()),
-      executor_(other.get_executor())
-  {
-    service_->move_construct(implementation_, other.get_implementation());
-  }
-
-  // Perform converting move-construction of an I/O object on another service.
-  template <typename IoObjectService1, typename Executor1>
-  io_object_impl(io_object_impl<IoObjectService1, Executor1>&& other)
-    : service_(&asio::use_service<IoObjectService>(
-            io_object_impl::get_context(other.get_executor()))),
-      executor_(other.get_executor())
-  {
-    service_->converting_move_construct(implementation_,
-        other.get_service(), other.get_implementation());
-  }
-
-  // Destructor.
-  ~io_object_impl()
-  {
-    service_->destroy(implementation_);
-  }
-
-  // Move-assign an I/O object.
-  io_object_impl& operator=(io_object_impl&& other)
-  {
-    if (this != &other)
-    {
-      service_->move_assign(implementation_,
-          *other.service_, other.implementation_);
-      executor_.~executor_type();
-      new (&executor_) executor_type(other.executor_);
-      service_ = other.service_;
-    }
-    return *this;
-  }
-
-  // Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return executor_;
-  }
-
-  // Get the service associated with the I/O object.
-  service_type& get_service()
-  {
-    return *service_;
-  }
-
-  // Get the service associated with the I/O object.
-  const service_type& get_service() const
-  {
-    return *service_;
-  }
-
-  // Get the underlying implementation of the I/O object.
-  implementation_type& get_implementation()
-  {
-    return implementation_;
-  }
-
-  // Get the underlying implementation of the I/O object.
-  const implementation_type& get_implementation() const
-  {
-    return implementation_;
-  }
-
-private:
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<execution::is_executor<T>::value>* = 0)
-  {
-    return asio::query(t, execution::context);
-  }
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<!execution::is_executor<T>::value>* = 0)
-  {
-    return t.context();
-  }
-
-  // Disallow copying and copy assignment.
-  io_object_impl(const io_object_impl&);
-  io_object_impl& operator=(const io_object_impl&);
-
-  // The service associated with the I/O object.
-  service_type* service_;
-
-  // The underlying implementation of the I/O object.
-  implementation_type implementation_;
-
-  // The associated executor.
-  executor_type executor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IO_OBJECT_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_at_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_at_op.hpp
deleted file mode 100644
index 114bdb5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_at_op.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-//
-// detail/io_uring_descriptor_read_at_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
-#define ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class io_uring_descriptor_read_at_op_base : public io_uring_operation
-{
-public:
-  io_uring_descriptor_read_at_op_base(
-      const asio::error_code& success_ec, int descriptor,
-      descriptor_ops::state_type state, uint64_t offset,
-      const MutableBufferSequence& buffers, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_descriptor_read_at_op_base::do_prepare,
-        &io_uring_descriptor_read_at_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      state_(state),
-      offset_(offset),
-      buffers_(buffers),
-      bufs_(buffers)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_at_op_base* o(
-        static_cast<io_uring_descriptor_read_at_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLIN);
-    }
-    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
-    {
-      ::io_uring_prep_read_fixed(sqe, o->descriptor_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          o->offset_, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_readv(sqe, o->descriptor_,
-          o->bufs_.buffers(), o->bufs_.count(), o->offset_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_at_op_base* o(
-        static_cast<io_uring_descriptor_read_at_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return descriptor_ops::non_blocking_read_at1(o->descriptor_,
-            o->offset_, o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->ec_,
-            o->bytes_transferred_);
-      }
-      else
-      {
-        return descriptor_ops::non_blocking_read_at(o->descriptor_,
-            o->offset_, o->bufs_.buffers(), o->bufs_.count(),
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-    else if (after_completion)
-    {
-      if (!o->ec_ && o->bytes_transferred_ == 0)
-        o->ec_ = asio::error::eof;
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= descriptor_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  int descriptor_;
-  descriptor_ops::state_type state_;
-  uint64_t offset_;
-  MutableBufferSequence buffers_;
-  buffer_sequence_adapter<asio::mutable_buffer,
-      MutableBufferSequence> bufs_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_descriptor_read_at_op
-  : public io_uring_descriptor_read_at_op_base<MutableBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_read_at_op);
-
-  io_uring_descriptor_read_at_op(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state, uint64_t offset,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_descriptor_read_at_op_base<MutableBufferSequence>(
-        success_ec, descriptor, state, offset, buffers,
-        &io_uring_descriptor_read_at_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_at_op* o
-      (static_cast<io_uring_descriptor_read_at_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_AT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_op.hpp
deleted file mode 100644
index 9f8cf70..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_read_op.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-// detail/io_uring_descriptor_read_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
-#define ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class io_uring_descriptor_read_op_base : public io_uring_operation
-{
-public:
-  io_uring_descriptor_read_op_base(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state,
-      const MutableBufferSequence& buffers, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_descriptor_read_op_base::do_prepare,
-        &io_uring_descriptor_read_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      state_(state),
-      buffers_(buffers),
-      bufs_(buffers)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_op_base* o(
-        static_cast<io_uring_descriptor_read_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLIN);
-    }
-    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
-    {
-      ::io_uring_prep_read_fixed(sqe, o->descriptor_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          0, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_readv(sqe, o->descriptor_,
-          o->bufs_.buffers(), o->bufs_.count(), -1);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_op_base* o(
-        static_cast<io_uring_descriptor_read_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return descriptor_ops::non_blocking_read1(
-            o->descriptor_, o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->ec_,
-            o->bytes_transferred_);
-      }
-      else
-      {
-        return descriptor_ops::non_blocking_read(
-            o->descriptor_, o->bufs_.buffers(), o->bufs_.count(),
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-    else if (after_completion)
-    {
-      if (!o->ec_ && o->bytes_transferred_ == 0)
-        o->ec_ = asio::error::eof;
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= descriptor_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  int descriptor_;
-  descriptor_ops::state_type state_;
-  MutableBufferSequence buffers_;
-  buffer_sequence_adapter<asio::mutable_buffer,
-      MutableBufferSequence> bufs_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_descriptor_read_op
-  : public io_uring_descriptor_read_op_base<MutableBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_read_op);
-
-  io_uring_descriptor_read_op(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_descriptor_read_op_base<MutableBufferSequence>(success_ec,
-        descriptor, state, buffers, &io_uring_descriptor_read_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_read_op* o
-      (static_cast<io_uring_descriptor_read_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_DESCRIPTOR_READ_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_service.hpp
deleted file mode 100644
index 04d1e36..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_service.hpp
+++ /dev/null
@@ -1,687 +0,0 @@
-//
-// detail/io_uring_descriptor_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
-#define ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/buffer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/io_uring_descriptor_read_at_op.hpp"
-#include "asio/detail/io_uring_descriptor_read_op.hpp"
-#include "asio/detail/io_uring_descriptor_write_at_op.hpp"
-#include "asio/detail/io_uring_descriptor_write_op.hpp"
-#include "asio/detail/io_uring_null_buffers_op.hpp"
-#include "asio/detail/io_uring_service.hpp"
-#include "asio/detail/io_uring_wait_op.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/posix/descriptor_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class io_uring_descriptor_service :
-  public execution_context_service_base<io_uring_descriptor_service>
-{
-public:
-  // The native type of a descriptor.
-  typedef int native_handle_type;
-
-  // The implementation type of the descriptor.
-  class implementation_type
-    : private asio::detail::noncopyable
-  {
-  public:
-    // Default constructor.
-    implementation_type()
-      : descriptor_(-1),
-        state_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class io_uring_descriptor_service;
-
-    // The native descriptor representation.
-    int descriptor_;
-
-    // The current state of the descriptor.
-    descriptor_ops::state_type state_;
-
-    // Per I/O object data used by the io_uring_service.
-    io_uring_service::per_io_object_data io_object_data_;
-  };
-
-  // Constructor.
-  ASIO_DECL io_uring_descriptor_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new descriptor implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Move-construct a new descriptor implementation.
-  ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept;
-
-  // Move-assign from another descriptor implementation.
-  ASIO_DECL void move_assign(implementation_type& impl,
-      io_uring_descriptor_service& other_service,
-      implementation_type& other_impl);
-
-  // Destroy a descriptor implementation.
-  ASIO_DECL void destroy(implementation_type& impl);
-
-  // Assign a native descriptor to a descriptor implementation.
-  ASIO_DECL asio::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      asio::error_code& ec);
-
-  // Determine whether the descriptor is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return impl.descriptor_ != -1;
-  }
-
-  // Destroy a descriptor implementation.
-  ASIO_DECL asio::error_code close(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Get the native descriptor representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return impl.descriptor_;
-  }
-
-  // Release ownership of the native descriptor representation.
-  ASIO_DECL native_handle_type release(implementation_type& impl);
-
-  // Release ownership of the native descriptor representation.
-  native_handle_type release(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    ec = success_ec_;
-    return release(impl);
-  }
-
-  // Cancel all operations associated with the descriptor.
-  ASIO_DECL asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Perform an IO control command on the descriptor.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(implementation_type& impl,
-      IO_Control_Command& command, asio::error_code& ec)
-  {
-    descriptor_ops::ioctl(impl.descriptor_, impl.state_,
-        command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the descriptor.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the descriptor.
-  asio::error_code non_blocking(implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    descriptor_ops::set_user_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native descriptor implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native descriptor implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    descriptor_ops::set_internal_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Wait for the descriptor to become ready to read, ready to write, or to have
-  // pending error conditions.
-  asio::error_code wait(implementation_type& impl,
-      posix::descriptor_base::wait_type w, asio::error_code& ec)
-  {
-    switch (w)
-    {
-    case posix::descriptor_base::wait_read:
-      descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
-      break;
-    case posix::descriptor_base::wait_write:
-      descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
-      break;
-    case posix::descriptor_base::wait_error:
-      descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
-      break;
-    default:
-      ec = asio::error::invalid_argument;
-      break;
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Asynchronously wait for the descriptor to become ready to read, ready to
-  // write, or to have pending error conditions.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(implementation_type& impl,
-      posix::descriptor_base::wait_type w,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    int op_type;
-    int poll_flags;
-    switch (w)
-    {
-    case posix::descriptor_base::wait_read:
-      op_type = io_uring_service::read_op;
-      poll_flags = POLLIN;
-      break;
-    case posix::descriptor_base::wait_write:
-      op_type = io_uring_service::write_op;
-      poll_flags = POLLOUT;
-      break;
-    case posix::descriptor_base::wait_error:
-      op_type = io_uring_service::except_op;
-      poll_flags = POLLPRI | POLLERR | POLLHUP;
-      break;
-    default:
-      op_type = -1;
-      poll_flags = -1;
-      return;
-    }
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_wait_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_,
-        poll_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected() && op_type != -1)
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "descriptor", &impl, impl.descriptor_, "async_wait"));
-
-    start_op(impl, op_type, p.p, is_continuation, op_type == -1);
-    p.v = p.p = 0;
-  }
-
-  // Write some data to the descriptor.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = descriptor_ops::sync_write1(impl.descriptor_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      n = descriptor_ops::sync_write(impl.descriptor_, impl.state_,
-          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be written without blocking.
-  size_t write_some(implementation_type& impl,
-      const null_buffers&, asio::error_code& ec)
-  {
-    // Wait for descriptor to become ready.
-    descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous write. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_descriptor_write_op<
-      ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_,
-        impl.state_, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "descriptor", &impl, impl.descriptor_, "async_write_some"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::all_empty(buffers));
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be written without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_, POLLOUT, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(),
-          *p.p, "descriptor", &impl, impl.descriptor_,
-          "async_write_some(null_buffers)"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Write some data to the descriptor at the specified offset.
-  template <typename ConstBufferSequence>
-  size_t write_some_at(implementation_type& impl, uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = descriptor_ops::sync_write_at1(impl.descriptor_,
-          impl.state_, offset, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      n = descriptor_ops::sync_write_at(impl.descriptor_, impl.state_,
-          offset, bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be written without blocking.
-  size_t write_some_at(implementation_type& impl, uint64_t,
-      const null_buffers& buffers, asio::error_code& ec)
-  {
-    return write_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous write at the specified offset. The data being sent
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl, uint64_t offset,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_descriptor_write_at_op<
-      ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_,
-        impl.state_, offset, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "descriptor", &impl, impl.descriptor_, "async_write_some"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::all_empty(buffers));
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be written without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl,
-      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex)
-  {
-    return async_write_some(impl, buffers, handler, io_ex);
-  }
-
-  // Read some data from the stream. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = descriptor_ops::sync_read1(impl.descriptor_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      n = descriptor_ops::sync_read(impl.descriptor_, impl.state_,
-          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be read without blocking.
-  size_t read_some(implementation_type& impl,
-      const null_buffers&, asio::error_code& ec)
-  {
-    // Wait for descriptor to become ready.
-    descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_descriptor_read_op<
-      MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_,
-        impl.state_, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "descriptor", &impl, impl.descriptor_, "async_read_some"));
-
-    start_op(impl, io_uring_service::read_op, p.p, is_continuation,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::all_empty(buffers));
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be read without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_, POLLIN, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(),
-          *p.p, "descriptor", &impl, impl.descriptor_,
-          "async_read_some(null_buffers)"));
-
-    start_op(impl, io_uring_service::read_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Read some data at the specified offset. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some_at(implementation_type& impl, uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    if (bufs_type::is_single_buffer)
-    {
-      return descriptor_ops::sync_read_at1(impl.descriptor_,
-          impl.state_, offset, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      return descriptor_ops::sync_read_at(impl.descriptor_, impl.state_,
-          offset, bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-  }
-
-  // Wait until data can be read without blocking.
-  size_t read_some_at(implementation_type& impl, uint64_t,
-      const null_buffers& buffers, asio::error_code& ec)
-  {
-    return read_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_descriptor_read_at_op<
-      MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_,
-        impl.state_, offset, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "descriptor", &impl, impl.descriptor_, "async_read_some"));
-
-    start_op(impl, io_uring_service::read_op, p.p, is_continuation,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::all_empty(buffers));
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be read without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl, uint64_t,
-      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex)
-  {
-    return async_read_some(impl, buffers, handler, io_ex);
-  }
-
-private:
-  // Start the asynchronous operation.
-  ASIO_DECL void start_op(implementation_type& impl, int op_type,
-      io_uring_operation* op, bool is_continuation, bool noop);
-
-  // Helper class used to implement per-operation cancellation
-  class io_uring_op_cancellation
-  {
-  public:
-    io_uring_op_cancellation(io_uring_service* s,
-        io_uring_service::per_io_object_data* p, int o)
-      : io_uring_service_(s),
-        io_object_data_(p),
-        op_type_(o)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        io_uring_service_->cancel_ops_by_key(*io_object_data_, op_type_, this);
-      }
-    }
-
-  private:
-    io_uring_service* io_uring_service_;
-    io_uring_service::per_io_object_data* io_object_data_;
-    int op_type_;
-  };
-
-  // The io_uring_service that performs event demultiplexing for the service.
-  io_uring_service& io_uring_service_;
-
-  // Cached success value to avoid accessing category singleton.
-  const asio::error_code success_ec_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/io_uring_descriptor_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_DESCRIPTOR_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_at_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_at_op.hpp
deleted file mode 100644
index 10a3f7a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_at_op.hpp
+++ /dev/null
@@ -1,189 +0,0 @@
-//
-// detail/io_uring_descriptor_write_at_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
-#define ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class io_uring_descriptor_write_at_op_base : public io_uring_operation
-{
-public:
-  io_uring_descriptor_write_at_op_base(
-      const asio::error_code& success_ec, int descriptor,
-      descriptor_ops::state_type state, uint64_t offset,
-      const ConstBufferSequence& buffers, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_descriptor_write_at_op_base::do_prepare,
-        &io_uring_descriptor_write_at_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      state_(state),
-      offset_(offset),
-      buffers_(buffers),
-      bufs_(buffers)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_at_op_base* o(
-        static_cast<io_uring_descriptor_write_at_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLOUT);
-    }
-    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
-    {
-      ::io_uring_prep_write_fixed(sqe, o->descriptor_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          o->offset_, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_writev(sqe, o->descriptor_,
-          o->bufs_.buffers(), o->bufs_.count(), o->offset_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_at_op_base* o(
-        static_cast<io_uring_descriptor_write_at_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return descriptor_ops::non_blocking_write_at1(o->descriptor_,
-            o->offset_, o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->ec_,
-            o->bytes_transferred_);
-      }
-      else
-      {
-        return descriptor_ops::non_blocking_write_at(o->descriptor_,
-            o->offset_, o->bufs_.buffers(), o->bufs_.count(),
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= descriptor_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  int descriptor_;
-  descriptor_ops::state_type state_;
-  uint64_t offset_;
-  ConstBufferSequence buffers_;
-  buffer_sequence_adapter<asio::const_buffer,
-      ConstBufferSequence> bufs_;
-};
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_descriptor_write_at_op
-  : public io_uring_descriptor_write_at_op_base<ConstBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_write_at_op);
-
-  io_uring_descriptor_write_at_op(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state, uint64_t offset,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-    : io_uring_descriptor_write_at_op_base<ConstBufferSequence>(
-        success_ec, descriptor, state, offset, buffers,
-        &io_uring_descriptor_write_at_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_at_op* o
-      (static_cast<io_uring_descriptor_write_at_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_AT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_op.hpp
deleted file mode 100644
index 090d644..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_descriptor_write_op.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// detail/io_uring_descriptor_write_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
-#define ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class io_uring_descriptor_write_op_base : public io_uring_operation
-{
-public:
-  io_uring_descriptor_write_op_base(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state,
-      const ConstBufferSequence& buffers, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_descriptor_write_op_base::do_prepare,
-        &io_uring_descriptor_write_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      state_(state),
-      buffers_(buffers),
-      bufs_(buffers)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_op_base* o(
-        static_cast<io_uring_descriptor_write_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->descriptor_, POLLOUT);
-    }
-    else if (o->bufs_.is_single_buffer && o->bufs_.is_registered_buffer)
-    {
-      ::io_uring_prep_write_fixed(sqe, o->descriptor_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          0, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_writev(sqe, o->descriptor_,
-          o->bufs_.buffers(), o->bufs_.count(), -1);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_op_base* o(
-        static_cast<io_uring_descriptor_write_op_base*>(base));
-
-    if ((o->state_ & descriptor_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return descriptor_ops::non_blocking_write1(
-            o->descriptor_, o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->ec_,
-            o->bytes_transferred_);
-      }
-      else
-      {
-        return descriptor_ops::non_blocking_write(
-            o->descriptor_, o->bufs_.buffers(), o->bufs_.count(),
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= descriptor_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  int descriptor_;
-  descriptor_ops::state_type state_;
-  ConstBufferSequence buffers_;
-  buffer_sequence_adapter<asio::const_buffer,
-      ConstBufferSequence> bufs_;
-};
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_descriptor_write_op
-  : public io_uring_descriptor_write_op_base<ConstBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_descriptor_write_op);
-
-  io_uring_descriptor_write_op(const asio::error_code& success_ec,
-      int descriptor, descriptor_ops::state_type state,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-    : io_uring_descriptor_write_op_base<ConstBufferSequence>(success_ec,
-        descriptor, state, buffers, &io_uring_descriptor_write_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_descriptor_write_op* o
-      (static_cast<io_uring_descriptor_write_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_DESCRIPTOR_WRITE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_file_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_file_service.hpp
deleted file mode 100644
index 3a0a453..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_file_service.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//
-// detail/io_uring_file_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
-#define ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  && defined(ASIO_HAS_IO_URING)
-
-#include <string>
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/io_uring_descriptor_service.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/file_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Extend the io_uring_descriptor_service to provide file support.
-class io_uring_file_service :
-  public execution_context_service_base<io_uring_file_service>
-{
-public:
-  typedef io_uring_descriptor_service descriptor_service;
-
-  // The native type of a file.
-  typedef descriptor_service::native_handle_type native_handle_type;
-
-  // The implementation type of the file.
-  class implementation_type : descriptor_service::implementation_type
-  {
-  private:
-    // Only this service will have access to the internal values.
-    friend class io_uring_file_service;
-
-    bool is_stream_;
-  };
-
-  ASIO_DECL io_uring_file_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new file implementation.
-  void construct(implementation_type& impl)
-  {
-    descriptor_service_.construct(impl);
-    impl.is_stream_ = false;
-  }
-
-  // Move-construct a new file implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_construct(impl, other_impl);
-    impl.is_stream_ = other_impl.is_stream_;
-  }
-
-  // Move-assign from another file implementation.
-  void move_assign(implementation_type& impl,
-      io_uring_file_service& other_service,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_assign(impl,
-        other_service.descriptor_service_, other_impl);
-    impl.is_stream_ = other_impl.is_stream_;
-  }
-
-  // Destroy a file implementation.
-  void destroy(implementation_type& impl)
-  {
-    descriptor_service_.destroy(impl);
-  }
-
-  // Open the file using the specified path name.
-  ASIO_DECL asio::error_code open(implementation_type& impl,
-      const char* path, file_base::flags open_flags,
-      asio::error_code& ec);
-
-  // Assign a native descriptor to a file implementation.
-  asio::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.assign(impl, native_descriptor, ec);
-  }
-
-  // Set whether the implementation is stream-oriented.
-  void set_is_stream(implementation_type& impl, bool is_stream)
-  {
-    impl.is_stream_ = is_stream;
-  }
-
-  // Determine whether the file is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return descriptor_service_.is_open(impl);
-  }
-
-  // Destroy a file implementation.
-  asio::error_code close(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.close(impl, ec);
-  }
-
-  // Get the native file representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return descriptor_service_.native_handle(impl);
-  }
-
-  // Release ownership of the native descriptor representation.
-  native_handle_type release(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.release(impl, ec);
-  }
-
-  // Cancel all operations associated with the file.
-  asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.cancel(impl, ec);
-  }
-
-  // Get the size of the file.
-  ASIO_DECL uint64_t size(const implementation_type& impl,
-      asio::error_code& ec) const;
-
-  // Alter the size of the file.
-  ASIO_DECL asio::error_code resize(implementation_type& impl,
-      uint64_t n, asio::error_code& ec);
-
-  // Synchronise the file to disk.
-  ASIO_DECL asio::error_code sync_all(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Synchronise the file data to disk.
-  ASIO_DECL asio::error_code sync_data(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Seek to a position in the file.
-  ASIO_DECL uint64_t seek(implementation_type& impl, int64_t offset,
-      file_base::seek_basis whence, asio::error_code& ec);
-
-  // Write the given data. Returns the number of bytes written.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.write_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous write. The data being written must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_write_some(impl, buffers, handler, io_ex);
-  }
-
-  // Write the given data at the specified location. Returns the number of
-  // bytes written.
-  template <typename ConstBufferSequence>
-  size_t write_some_at(implementation_type& impl, uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.write_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous write at the specified location. The data being
-  // written must be valid for the lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl,
-      uint64_t offset, const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_write_some_at(
-        impl, offset, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.read_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_read_some(impl, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some_at(implementation_type& impl, uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.read_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_read_some_at(
-        impl, offset, buffers, handler, io_ex);
-  }
-
-private:
-  // The implementation used for initiating asynchronous operations.
-  descriptor_service descriptor_service_;
-
-  // Cached success value to avoid accessing category singleton.
-  const asio::error_code success_ec_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/io_uring_file_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_FILE)
-       //   && defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_FILE_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_null_buffers_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_null_buffers_op.hpp
deleted file mode 100644
index 61fe6a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_null_buffers_op.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//
-// detail/io_uring_null_buffers_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
-#define ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class io_uring_null_buffers_op : public io_uring_operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_null_buffers_op);
-
-  io_uring_null_buffers_op(const asio::error_code& success_ec,
-      int descriptor, int poll_flags, Handler& handler, const IoExecutor& io_ex)
-    : io_uring_operation(success_ec,
-        &io_uring_null_buffers_op::do_prepare,
-        &io_uring_null_buffers_op::do_perform,
-        &io_uring_null_buffers_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex),
-      descriptor_(descriptor),
-      poll_flags_(poll_flags)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_null_buffers_op* o(static_cast<io_uring_null_buffers_op*>(base));
-
-    ::io_uring_prep_poll_add(sqe, o->descriptor_, o->poll_flags_);
-  }
-
-  static bool do_perform(io_uring_operation*, bool after_completion)
-  {
-    return after_completion;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_null_buffers_op* o(static_cast<io_uring_null_buffers_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-  int descriptor_;
-  int poll_flags_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IO_URING_NULL_BUFFERS_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_operation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_operation.hpp
deleted file mode 100644
index f2635cc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_operation.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// detail/io_uring_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_OPERATION_HPP
-#define ASIO_DETAIL_IO_URING_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include <liburing.h>
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class io_uring_operation
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-  // The number of bytes transferred, to be passed to the completion handler.
-  std::size_t bytes_transferred_;
-
-  // The operation key used for targeted cancellation.
-  void* cancellation_key_;
-
-  // Prepare the operation.
-  void prepare(::io_uring_sqe* sqe)
-  {
-    return prepare_func_(this, sqe);
-  }
-
-  // Perform actions associated with the operation. Returns true when complete.
-  bool perform(bool after_completion)
-  {
-    return perform_func_(this, after_completion);
-  }
-
-protected:
-  typedef void (*prepare_func_type)(io_uring_operation*, ::io_uring_sqe*);
-  typedef bool (*perform_func_type)(io_uring_operation*, bool);
-
-  io_uring_operation(const asio::error_code& success_ec,
-      prepare_func_type prepare_func, perform_func_type perform_func,
-      func_type complete_func)
-    : operation(complete_func),
-      ec_(success_ec),
-      bytes_transferred_(0),
-      cancellation_key_(0),
-      prepare_func_(prepare_func),
-      perform_func_(perform_func)
-  {
-  }
-
-private:
-  prepare_func_type prepare_func_;
-  perform_func_type perform_func_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_OPERATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_service.hpp
deleted file mode 100644
index 2dd3c0b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_service.hpp
+++ /dev/null
@@ -1,319 +0,0 @@
-//
-// detail/io_uring_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SERVICE_HPP
-#define ASIO_DETAIL_IO_URING_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include <liburing.h>
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/conditionally_enabled_mutex.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/object_pool.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class io_uring_service
-  : public execution_context_service_base<io_uring_service>,
-    public scheduler_task
-{
-private:
-  // The mutex type used by this reactor.
-  typedef conditionally_enabled_mutex mutex;
-
-public:
-  enum op_types { read_op = 0, write_op = 1, except_op = 2, max_ops = 3 };
-
-  class io_object;
-
-  // An I/O queue stores operations that must run serially.
-  class io_queue : operation
-  {
-    friend class io_uring_service;
-
-    io_object* io_object_;
-    op_queue<io_uring_operation> op_queue_;
-    bool cancel_requested_;
-
-    ASIO_DECL io_queue();
-    void set_result(int r) { task_result_ = static_cast<unsigned>(r); }
-    ASIO_DECL operation* perform_io(int result);
-    ASIO_DECL static void do_complete(void* owner, operation* base,
-        const asio::error_code& ec, std::size_t bytes_transferred);
-  };
-
-  // Per I/O object state.
-  class io_object
-  {
-    friend class io_uring_service;
-    friend class object_pool_access;
-
-    io_object* next_;
-    io_object* prev_;
-
-    mutex mutex_;
-    io_uring_service* service_;
-    io_queue queues_[max_ops];
-    bool shutdown_;
-
-    ASIO_DECL io_object(bool locking);
-  };
-
-  // Per I/O object data.
-  typedef io_object* per_io_object_data;
-
-  // Constructor.
-  ASIO_DECL io_uring_service(asio::execution_context& ctx);
-
-  // Destructor.
-  ASIO_DECL ~io_uring_service();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal state following a fork.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register an I/O object with io_uring.
-  ASIO_DECL void register_io_object(io_object*& io_obj);
-
-  // Register an internal I/O object with io_uring.
-  ASIO_DECL void register_internal_io_object(
-      io_object*& io_obj, int op_type, io_uring_operation* op);
-
-  // Register buffers with io_uring.
-  ASIO_DECL void register_buffers(const ::iovec* v, unsigned n);
-
-  // Unregister buffers from io_uring.
-  ASIO_DECL void unregister_buffers();
-
-  // Post an operation for immediate completion.
-  void post_immediate_completion(operation* op, bool is_continuation);
-
-  // Start a new operation. The operation will be prepared and submitted to the
-  // io_uring when it is at the head of its I/O operation queue.
-  ASIO_DECL void start_op(int op_type, per_io_object_data& io_obj,
-      io_uring_operation* op, bool is_continuation);
-
-  // Cancel all operations associated with the given I/O object. The handlers
-  // associated with the I/O object will be invoked with the operation_aborted
-  // error.
-  ASIO_DECL void cancel_ops(per_io_object_data& io_obj);
-
-  // Cancel all operations associated with the given I/O object and key. The
-  // handlers associated with the object and key will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops_by_key(per_io_object_data& io_obj,
-      int op_type, void* cancellation_key);
-
-  // Cancel any operations that are running against the I/O object and remove
-  // its registration from the service. The service resources associated with
-  // the I/O object must be released by calling cleanup_io_object.
-  ASIO_DECL void deregister_io_object(per_io_object_data& io_obj);
-
-  // Perform any post-deregistration cleanup tasks associated with the I/O
-  // object.
-  ASIO_DECL void cleanup_io_object(per_io_object_data& io_obj);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
-
-  // Wait on io_uring once until interrupted or events are ready to be
-  // dispatched.
-  ASIO_DECL void run(long usec, op_queue<operation>& ops);
-
-  // Interrupt the io_uring wait.
-  ASIO_DECL void interrupt();
-
-private:
-  // The hint to pass to io_uring_queue_init to size its data structures.
-  enum { ring_size = 16384 };
-
-  // The number of operations to submit in a batch.
-  enum { submit_batch_size = 128 };
-
-  // The number of operations to complete in a batch.
-  enum { complete_batch_size = 128 };
-
-  // The type used for processing eventfd readiness notifications.
-  class event_fd_read_op;
-
-  // Initialise the ring.
-  ASIO_DECL void init_ring();
-
-  // Register the eventfd descriptor for readiness notifications.
-  ASIO_DECL void register_with_reactor();
-
-  // Allocate a new I/O object.
-  ASIO_DECL io_object* allocate_io_object();
-
-  // Free an existing I/O object.
-  ASIO_DECL void free_io_object(io_object* s);
-
-  // Helper function to cancel all operations associated with the given I/O
-  // object. This function must be called while the I/O object's mutex is held.
-  // Returns true if there are operations for which cancellation is pending.
-  ASIO_DECL bool do_cancel_ops(
-      per_io_object_data& io_obj, op_queue<operation>& ops);
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Called to recalculate and update the timeout.
-  ASIO_DECL void update_timeout();
-
-  // Get the current timeout value.
-  ASIO_DECL __kernel_timespec get_timeout() const;
-
-  // Get a new submission queue entry, flushing the queue if necessary.
-  ASIO_DECL ::io_uring_sqe* get_sqe();
-
-  // Submit pending submission queue entries.
-  ASIO_DECL void submit_sqes();
-
-  // Post an operation to submit the pending submission queue entries.
-  ASIO_DECL void post_submit_sqes_op(mutex::scoped_lock& lock);
-
-  // Push an operation to submit the pending submission queue entries.
-  ASIO_DECL void push_submit_sqes_op(op_queue<operation>& ops);
-
-  // Helper operation to submit pending submission queue entries.
-  class submit_sqes_op : operation
-  {
-    friend class io_uring_service;
-
-    io_uring_service* service_;
-
-    ASIO_DECL submit_sqes_op(io_uring_service* s);
-    ASIO_DECL static void do_complete(void* owner, operation* base,
-        const asio::error_code& ec, std::size_t bytes_transferred);
-  };
-
-  // The scheduler implementation used to post completions.
-  scheduler& scheduler_;
-
-  // Mutex to protect access to internal data.
-  mutex mutex_;
-
-  // The ring.
-  ::io_uring ring_;
-
-  // The count of unfinished work.
-  atomic_count outstanding_work_;
-
-  // The operation used to submit the pending submission queue entries.
-  submit_sqes_op submit_sqes_op_;
-
-  // The number of pending submission queue entries_.
-  int pending_sqes_;
-
-  // Whether there is a pending submission operation.
-  bool pending_submit_sqes_op_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // The timespec for the pending timeout operation. Must remain valid while the
-  // operation is outstanding.
-  __kernel_timespec timeout_;
-
-  // Mutex to protect access to the registered I/O objects.
-  mutex registration_mutex_;
-
-  // Keep track of all registered I/O objects.
-  object_pool<io_object> registered_io_objects_;
-
-  // Helper class to do post-perform_io cleanup.
-  struct perform_io_cleanup_on_block_exit;
-  friend struct perform_io_cleanup_on_block_exit;
-
-  // The reactor used to register for eventfd readiness.
-  reactor& reactor_;
-
-  // The per-descriptor reactor data used for the eventfd.
-  reactor::per_descriptor_data reactor_data_;
-
-  // The eventfd descriptor used to wait for readiness.
-  int event_fd_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/io_uring_service.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/io_uring_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_accept_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_accept_op.hpp
deleted file mode 100644
index dbf1a98..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_accept_op.hpp
+++ /dev/null
@@ -1,280 +0,0 @@
-//
-// detail/io_uring_socket_accept_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Socket, typename Protocol>
-class io_uring_socket_accept_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_accept_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state, Socket& peer,
-      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
-      func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_accept_op_base::do_prepare,
-        &io_uring_socket_accept_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      peer_(peer),
-      protocol_(protocol),
-      peer_endpoint_(peer_endpoint),
-      addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_accept_op_base* o(
-        static_cast<io_uring_socket_accept_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->socket_, POLLIN);
-    }
-    else
-    {
-      ::io_uring_prep_accept(sqe, o->socket_,
-          o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
-          o->peer_endpoint_ ? &o->addrlen_ : 0, 0);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_accept_op_base* o(
-        static_cast<io_uring_socket_accept_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      socket_type new_socket = invalid_socket;
-      std::size_t addrlen = static_cast<std::size_t>(o->addrlen_);
-      bool result = socket_ops::non_blocking_accept(o->socket_,
-          o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
-          o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket);
-      o->new_socket_.reset(new_socket);
-      o->addrlen_ = static_cast<socklen_t>(addrlen);
-      return result;
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    if (after_completion && !o->ec_)
-      o->new_socket_.reset(static_cast<int>(o->bytes_transferred_));
-
-    return after_completion;
-  }
-
-  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();
-    }
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  socket_holder new_socket_;
-  Socket& peer_;
-  Protocol protocol_;
-  typename Protocol::endpoint* peer_endpoint_;
-  socklen_t addrlen_;
-};
-
-template <typename Socket, typename Protocol,
-    typename Handler, typename IoExecutor>
-class io_uring_socket_accept_op :
-  public io_uring_socket_accept_op_base<Socket, Protocol>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_accept_op);
-
-  io_uring_socket_accept_op(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state, Socket& peer,
-      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_accept_op_base<Socket, Protocol>(
-        success_ec, socket, state, peer, protocol, peer_endpoint,
-        &io_uring_socket_accept_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_accept_op* o(static_cast<io_uring_socket_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    if (owner)
-      o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-template <typename Protocol, typename PeerIoExecutor,
-    typename Handler, typename IoExecutor>
-class io_uring_socket_move_accept_op :
-  private Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
-  public io_uring_socket_accept_op_base<
-    typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
-    Protocol>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_move_accept_op);
-
-  io_uring_socket_move_accept_op(const asio::error_code& success_ec,
-      const PeerIoExecutor& peer_io_ex, socket_type socket,
-      socket_ops::state_type state, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, Handler& handler,
-      const IoExecutor& io_ex)
-    : peer_socket_type(peer_io_ex),
-      io_uring_socket_accept_op_base<peer_socket_type, Protocol>(
-        success_ec, socket, state, *this, protocol, peer_endpoint,
-        &io_uring_socket_move_accept_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_move_accept_op* o(
-        static_cast<io_uring_socket_move_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    if (owner)
-      o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::move_binder2<Handler,
-      asio::error_code, peer_socket_type>
-        handler(0, static_cast<Handler&&>(o->handler_), o->ec_,
-          static_cast<peer_socket_type&&>(*o));
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  typedef typename Protocol::socket::template
-    rebind_executor<PeerIoExecutor>::other peer_socket_type;
-
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_ACCEPT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_connect_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_connect_op.hpp
deleted file mode 100644
index 45d30c6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_connect_op.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//
-// detail/io_uring_socket_connect_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class io_uring_socket_connect_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_connect_op_base(const asio::error_code& success_ec,
-      socket_type socket, const typename Protocol::endpoint& endpoint,
-      func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_connect_op_base::do_prepare,
-        &io_uring_socket_connect_op_base::do_perform, complete_func),
-      socket_(socket),
-      endpoint_(endpoint)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_connect_op_base* o(
-        static_cast<io_uring_socket_connect_op_base*>(base));
-
-    ::io_uring_prep_connect(sqe, o->socket_,
-        static_cast<sockaddr*>(o->endpoint_.data()),
-        static_cast<socklen_t>(o->endpoint_.size()));
-  }
-
-  static bool do_perform(io_uring_operation*, bool after_completion)
-  {
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  typename Protocol::endpoint endpoint_;
-};
-
-template <typename Protocol, typename Handler, typename IoExecutor>
-class io_uring_socket_connect_op :
-  public io_uring_socket_connect_op_base<Protocol>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_connect_op);
-
-  io_uring_socket_connect_op(const asio::error_code& success_ec,
-      socket_type socket, const typename Protocol::endpoint& endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_connect_op_base<Protocol>(success_ec, socket,
-        endpoint, &io_uring_socket_connect_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_connect_op* o
-      (static_cast<io_uring_socket_connect_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_CONNECT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recv_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recv_op.hpp
deleted file mode 100644
index b1936c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recv_op.hpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-// detail/io_uring_socket_recv_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class io_uring_socket_recv_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_recv_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_recv_op_base::do_prepare,
-        &io_uring_socket_recv_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      flags_(flags),
-      bufs_(buffers),
-      msghdr_()
-  {
-    msghdr_.msg_iov = bufs_.buffers();
-    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recv_op_base* o(
-        static_cast<io_uring_socket_recv_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
-      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
-    }
-    else if (o->bufs_.is_single_buffer
-        && o->bufs_.is_registered_buffer && o->flags_ == 0)
-    {
-      ::io_uring_prep_read_fixed(sqe, o->socket_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          0, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recv_op_base* o(
-        static_cast<io_uring_socket_recv_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
-      if (after_completion || !except_op)
-      {
-        if (o->bufs_.is_single_buffer)
-        {
-          return socket_ops::non_blocking_recv1(o->socket_,
-              o->bufs_.first(o->buffers_).data(),
-              o->bufs_.first(o->buffers_).size(), o->flags_,
-              (o->state_ & socket_ops::stream_oriented) != 0,
-              o->ec_, o->bytes_transferred_);
-        }
-        else
-        {
-          return socket_ops::non_blocking_recv(o->socket_,
-              o->bufs_.buffers(), o->bufs_.count(), o->flags_,
-              (o->state_ & socket_ops::stream_oriented) != 0,
-              o->ec_, o->bytes_transferred_);
-        }
-      }
-    }
-    else if (after_completion)
-    {
-      if (!o->ec_ && o->bytes_transferred_ == 0)
-        if ((o->state_ & socket_ops::stream_oriented) != 0)
-          o->ec_ = asio::error::eof;
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags flags_;
-  buffer_sequence_adapter<asio::mutable_buffer,
-      MutableBufferSequence> bufs_;
-  msghdr msghdr_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_socket_recv_op
-  : public io_uring_socket_recv_op_base<MutableBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recv_op);
-
-  io_uring_socket_recv_op(const asio::error_code& success_ec,
-      int socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_recv_op_base<MutableBufferSequence>(success_ec,
-        socket, state, buffers, flags, &io_uring_socket_recv_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recv_op* o
-      (static_cast<io_uring_socket_recv_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_RECV_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvfrom_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvfrom_op.hpp
deleted file mode 100644
index dfd30e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvfrom_op.hpp
+++ /dev/null
@@ -1,206 +0,0 @@
-//
-// detail/io_uring_socket_recvfrom_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Endpoint>
-class io_uring_socket_recvfrom_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_recvfrom_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_recvfrom_op_base::do_prepare,
-        &io_uring_socket_recvfrom_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      sender_endpoint_(endpoint),
-      flags_(flags),
-      bufs_(buffers),
-      msghdr_()
-  {
-    msghdr_.msg_iov = bufs_.buffers();
-    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
-    msghdr_.msg_name = static_cast<sockaddr*>(
-        static_cast<void*>(sender_endpoint_.data()));
-    msghdr_.msg_namelen = sender_endpoint_.capacity();
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvfrom_op_base* o(
-        static_cast<io_uring_socket_recvfrom_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
-      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
-    }
-    else
-    {
-      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvfrom_op_base* o(
-        static_cast<io_uring_socket_recvfrom_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->flags_ & socket_base::message_out_of_band) != 0;
-      if (after_completion || !except_op)
-      {
-        std::size_t addr_len = o->sender_endpoint_.capacity();
-        bool result;
-        if (o->bufs_.is_single_buffer)
-        {
-          result = socket_ops::non_blocking_recvfrom1(o->socket_,
-              o->bufs_.first(o->buffers_).data(),
-              o->bufs_.first(o->buffers_).size(), o->flags_,
-              o->sender_endpoint_.data(), &addr_len,
-              o->ec_, o->bytes_transferred_);
-        }
-        else
-        {
-          result = socket_ops::non_blocking_recvfrom(o->socket_,
-              o->bufs_.buffers(), o->bufs_.count(), o->flags_,
-              o->sender_endpoint_.data(), &addr_len,
-              o->ec_, o->bytes_transferred_);
-        }
-        if (result && !o->ec_)
-          o->sender_endpoint_.resize(addr_len);
-      }
-    }
-    else if (after_completion && !o->ec_)
-      o->sender_endpoint_.resize(o->msghdr_.msg_namelen);
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  MutableBufferSequence buffers_;
-  Endpoint& sender_endpoint_;
-  socket_base::message_flags flags_;
-  buffer_sequence_adapter<asio::mutable_buffer,
-      MutableBufferSequence> bufs_;
-  msghdr msghdr_;
-};
-
-template <typename MutableBufferSequence, typename Endpoint,
-    typename Handler, typename IoExecutor>
-class io_uring_socket_recvfrom_op
-  : public io_uring_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recvfrom_op);
-
-  io_uring_socket_recvfrom_op(const asio::error_code& success_ec,
-      int socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
-        success_ec, socket, state, buffers, endpoint, flags,
-        &io_uring_socket_recvfrom_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvfrom_op* o
-      (static_cast<io_uring_socket_recvfrom_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_RECVFROM_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvmsg_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvmsg_op.hpp
deleted file mode 100644
index 778d0fa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_recvmsg_op.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-//
-// detail/io_uring_socket_recvmsg_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class io_uring_socket_recvmsg_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_recvmsg_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_recvmsg_op_base::do_prepare,
-        &io_uring_socket_recvmsg_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      in_flags_(in_flags),
-      out_flags_(out_flags),
-      bufs_(buffers),
-      msghdr_()
-  {
-    msghdr_.msg_iov = bufs_.buffers();
-    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvmsg_op_base* o(
-        static_cast<io_uring_socket_recvmsg_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->in_flags_ & socket_base::message_out_of_band) != 0;
-      ::io_uring_prep_poll_add(sqe, o->socket_, except_op ? POLLPRI : POLLIN);
-    }
-    else
-    {
-      ::io_uring_prep_recvmsg(sqe, o->socket_, &o->msghdr_, o->in_flags_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvmsg_op_base* o(
-        static_cast<io_uring_socket_recvmsg_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      bool except_op = (o->in_flags_ & socket_base::message_out_of_band) != 0;
-      if (after_completion || !except_op)
-      {
-        return socket_ops::non_blocking_recvmsg(o->socket_,
-            o->bufs_.buffers(), o->bufs_.count(), o->in_flags_,
-            o->out_flags_, o->ec_, o->bytes_transferred_);
-      }
-    }
-    else if (after_completion)
-    {
-      if (!o->ec_)
-        o->out_flags_ = o->msghdr_.msg_flags;
-      else
-        o->out_flags_ = 0;
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags in_flags_;
-  socket_base::message_flags& out_flags_;
-  buffer_sequence_adapter<asio::mutable_buffer,
-      MutableBufferSequence> bufs_;
-  msghdr msghdr_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_socket_recvmsg_op
-  : public io_uring_socket_recvmsg_op_base<MutableBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_recvmsg_op);
-
-  io_uring_socket_recvmsg_op(const asio::error_code& success_ec,
-      int socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_recvmsg_op_base<MutableBufferSequence>(success_ec,
-        socket, state, buffers, in_flags, out_flags,
-        &io_uring_socket_recvmsg_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_recvmsg_op* o
-      (static_cast<io_uring_socket_recvmsg_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_RECVMSG_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_send_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_send_op.hpp
deleted file mode 100644
index 2f57dae..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_send_op.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-// detail/io_uring_socket_send_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class io_uring_socket_send_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_send_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_send_op_base::do_prepare,
-        &io_uring_socket_send_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      flags_(flags),
-      bufs_(buffers),
-      msghdr_()
-  {
-    msghdr_.msg_iov = bufs_.buffers();
-    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_send_op_base* o(
-        static_cast<io_uring_socket_send_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->socket_, POLLOUT);
-    }
-    else if (o->bufs_.is_single_buffer
-        && o->bufs_.is_registered_buffer && o->flags_ == 0)
-    {
-      ::io_uring_prep_write_fixed(sqe, o->socket_,
-          o->bufs_.buffers()->iov_base, o->bufs_.buffers()->iov_len,
-          0, o->bufs_.registered_id().native_handle());
-    }
-    else
-    {
-      ::io_uring_prep_sendmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_send_op_base* o(
-        static_cast<io_uring_socket_send_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return socket_ops::non_blocking_send1(o->socket_,
-            o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->flags_,
-            o->ec_, o->bytes_transferred_);
-      }
-      else
-      {
-        return socket_ops::non_blocking_send(o->socket_,
-            o->bufs_.buffers(), o->bufs_.count(), o->flags_,
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  ConstBufferSequence buffers_;
-  socket_base::message_flags flags_;
-  buffer_sequence_adapter<asio::const_buffer, ConstBufferSequence> bufs_;
-  msghdr msghdr_;
-};
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class io_uring_socket_send_op
-  : public io_uring_socket_send_op_base<ConstBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_send_op);
-
-  io_uring_socket_send_op(const asio::error_code& success_ec,
-      int socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_send_op_base<ConstBufferSequence>(success_ec,
-        socket, state, buffers, flags, &io_uring_socket_send_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_send_op* o
-      (static_cast<io_uring_socket_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_SEND_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_sendto_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_sendto_op.hpp
deleted file mode 100644
index 1866938..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_sendto_op.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//
-// detail/io_uring_socket_sendto_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence, typename Endpoint>
-class io_uring_socket_sendto_op_base : public io_uring_operation
-{
-public:
-  io_uring_socket_sendto_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers, const Endpoint& endpoint,
-      socket_base::message_flags flags, func_type complete_func)
-    : io_uring_operation(success_ec,
-        &io_uring_socket_sendto_op_base::do_prepare,
-        &io_uring_socket_sendto_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      destination_(endpoint),
-      flags_(flags),
-      bufs_(buffers),
-      msghdr_()
-  {
-    msghdr_.msg_iov = bufs_.buffers();
-    msghdr_.msg_iovlen = static_cast<int>(bufs_.count());
-    msghdr_.msg_name = static_cast<sockaddr*>(
-        static_cast<void*>(destination_.data()));
-    msghdr_.msg_namelen = destination_.size();
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_sendto_op_base* o(
-        static_cast<io_uring_socket_sendto_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      ::io_uring_prep_poll_add(sqe, o->socket_, POLLOUT);
-    }
-    else
-    {
-      ::io_uring_prep_sendmsg(sqe, o->socket_, &o->msghdr_, o->flags_);
-    }
-  }
-
-  static bool do_perform(io_uring_operation* base, bool after_completion)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_sendto_op_base* o(
-        static_cast<io_uring_socket_sendto_op_base*>(base));
-
-    if ((o->state_ & socket_ops::internal_non_blocking) != 0)
-    {
-      if (o->bufs_.is_single_buffer)
-      {
-        return socket_ops::non_blocking_sendto1(o->socket_,
-            o->bufs_.first(o->buffers_).data(),
-            o->bufs_.first(o->buffers_).size(), o->flags_,
-            o->destination_.data(), o->destination_.size(),
-            o->ec_, o->bytes_transferred_);
-      }
-      else
-      {
-        return socket_ops::non_blocking_sendto(o->socket_,
-            o->bufs_.buffers(), o->bufs_.count(), o->flags_,
-            o->destination_.data(), o->destination_.size(),
-            o->ec_, o->bytes_transferred_);
-      }
-    }
-
-    if (o->ec_ && o->ec_ == asio::error::would_block)
-    {
-      o->state_ |= socket_ops::internal_non_blocking;
-      return false;
-    }
-
-    return after_completion;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  ConstBufferSequence buffers_;
-  Endpoint destination_;
-  socket_base::message_flags flags_;
-  buffer_sequence_adapter<asio::const_buffer, ConstBufferSequence> bufs_;
-  msghdr msghdr_;
-};
-
-template <typename ConstBufferSequence, typename Endpoint,
-    typename Handler, typename IoExecutor>
-class io_uring_socket_sendto_op
-  : public io_uring_socket_sendto_op_base<ConstBufferSequence, Endpoint>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_socket_sendto_op);
-
-  io_uring_socket_sendto_op(const asio::error_code& success_ec,
-      int socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers, const Endpoint& endpoint,
-      socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : io_uring_socket_sendto_op_base<ConstBufferSequence, Endpoint>(
-        success_ec, socket, state, buffers, endpoint, flags,
-        &io_uring_socket_sendto_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_socket_sendto_op* o
-      (static_cast<io_uring_socket_sendto_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_SENDTO_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service.hpp
deleted file mode 100644
index 3daa22e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service.hpp
+++ /dev/null
@@ -1,629 +0,0 @@
-//
-// detail/io_uring_socket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/buffer.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/io_uring_null_buffers_op.hpp"
-#include "asio/detail/io_uring_service.hpp"
-#include "asio/detail/io_uring_socket_accept_op.hpp"
-#include "asio/detail/io_uring_socket_connect_op.hpp"
-#include "asio/detail/io_uring_socket_recvfrom_op.hpp"
-#include "asio/detail/io_uring_socket_sendto_op.hpp"
-#include "asio/detail/io_uring_socket_service_base.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class io_uring_socket_service :
-  public execution_context_service_base<io_uring_socket_service<Protocol>>,
-  public io_uring_socket_service_base
-{
-public:
-  // The protocol type.
-  typedef Protocol protocol_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The native type of a socket.
-  typedef socket_type native_handle_type;
-
-  // The implementation type of the socket.
-  struct implementation_type :
-    io_uring_socket_service_base::base_implementation_type
-  {
-    // Default constructor.
-    implementation_type()
-      : protocol_(endpoint_type().protocol())
-    {
-    }
-
-    // The protocol associated with the socket.
-    protocol_type protocol_;
-  };
-
-  // Constructor.
-  io_uring_socket_service(execution_context& context)
-    : execution_context_service_base<
-        io_uring_socket_service<Protocol>>(context),
-      io_uring_socket_service_base(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    this->base_shutdown();
-  }
-
-  // Move-construct a new socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type& impl,
-      io_uring_socket_service_base& other_service,
-      implementation_type& other_impl)
-  {
-    this->base_move_assign(impl, other_service, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-construct a new socket implementation from another protocol type.
-  template <typename Protocol1>
-  void converting_move_construct(implementation_type& impl,
-      io_uring_socket_service<Protocol1>&,
-      typename io_uring_socket_service<
-        Protocol1>::implementation_type& other_impl)
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = protocol_type(other_impl.protocol_);
-    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
-  }
-
-  // Open a new socket implementation.
-  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;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Assign a native socket to a socket implementation.
-  asio::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      asio::error_code& ec)
-  {
-    if (!do_assign(impl, protocol.type(), native_socket, ec))
-      impl.protocol_ = protocol;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the native socket representation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return impl.socket_;
-  }
-
-  // Bind the socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
-      const endpoint_type& endpoint, asio::error_code& ec)
-  {
-    socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  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);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code get_option(const implementation_type& impl,
-      Option& option, asio::error_code& ec) const
-  {
-    std::size_t size = option.size(impl.protocol_);
-    socket_ops::getsockopt(impl.socket_, impl.state_,
-        option.level(impl.protocol_), option.name(impl.protocol_),
-        option.data(impl.protocol_), &size, ec);
-    if (!ec)
-      option.resize(impl.protocol_, size);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getpeername(impl.socket_,
-          endpoint.data(), &addr_len, false, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(base_implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
-  {
-    socket_ops::shutdown(impl.socket_, what, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Send a datagram to the specified endpoint. Returns the number of bytes
-  // sent.
-  template <typename ConstBufferSequence>
-  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = socket_ops::sync_sendto1(impl.socket_, impl.state_,
-          bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags,
-          destination.data(), destination.size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      n = socket_ops::sync_sendto(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags,
-          destination.data(), destination.size(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_sendto_op<ConstBufferSequence,
-        endpoint_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
-        buffers, destination, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_send_to"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, POLLOUT, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_send_to(null_buffers)"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Receive a datagram with the endpoint of the sender. Returns the number of
-  // bytes received.
-  template <typename MutableBufferSequence>
-  size_t receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    std::size_t addr_len = sender_endpoint.capacity();
-    std::size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = socket_ops::sync_recvfrom1(impl.socket_, impl.state_,
-          bufs_type::first(buffers).data(), bufs_type::first(buffers).size(),
-          flags, sender_endpoint.data(), &addr_len, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      n = socket_ops::sync_recvfrom(impl.socket_, impl.state_, bufs.buffers(),
-          bufs.count(), flags, sender_endpoint.data(), &addr_len, ec);
-    }
-
-    if (!ec)
-      sender_endpoint.resize(addr_len);
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_from(implementation_type& impl, const null_buffers&,
-      endpoint_type& sender_endpoint, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received and
-  // the sender_endpoint object must both be valid for the lifetime of the
-  // asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type = (flags & socket_base::message_out_of_band)
-      ? io_uring_service::except_op : io_uring_service::read_op;
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_recvfrom_op<MutableBufferSequence,
-        endpoint_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
-        buffers, sender_endpoint, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_receive_from"));
-
-    start_op(impl, op_type, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl, const null_buffers&,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type;
-    int poll_flags;
-    if ((flags & socket_base::message_out_of_band) != 0)
-    {
-      op_type = io_uring_service::except_op;
-      poll_flags = POLLPRI;
-    }
-    else
-    {
-      op_type = io_uring_service::read_op;
-      poll_flags = POLLIN;
-    }
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_from(null_buffers)"));
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    start_op(impl, op_type, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Accept a new connection.
-  template <typename Socket>
-  asio::error_code accept(implementation_type& impl,
-      Socket& peer, endpoint_type* peer_endpoint, asio::error_code& ec)
-  {
-    // We cannot accept a socket that is already open.
-    if (peer.is_open())
-    {
-      ec = asio::error::already_open;
-      ASIO_ERROR_LOCATION(ec);
-      return ec;
-    }
-
-    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
-    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
-          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
-          peer_endpoint ? &addr_len : 0, ec));
-
-    // On success, assign new connection to peer socket object.
-    if (new_socket.get() != invalid_socket)
-    {
-      if (peer_endpoint)
-        peer_endpoint->resize(addr_len);
-      peer.assign(impl.protocol_, new_socket.get(), ec);
-      if (!ec)
-        new_socket.release();
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Start an asynchronous accept. The peer and peer_endpoint objects must be
-  // valid until the accept's handler is invoked.
-  template <typename Socket, typename Handler, typename IoExecutor>
-  void async_accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
-        peer, impl.protocol_, peer_endpoint, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected() && !peer.is_open())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_accept"));
-
-    start_accept_op(impl, p.p, is_continuation, peer.is_open());
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous accept. The peer_endpoint object must be valid until
-  // the accept's handler is invoked.
-  template <typename PeerIoExecutor, typename Handler, typename IoExecutor>
-  void async_move_accept(implementation_type& impl,
-      const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_move_accept_op<Protocol,
-        PeerIoExecutor, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, peer_io_ex, impl.socket_,
-        impl.state_, impl.protocol_, peer_endpoint, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_accept"));
-
-    start_accept_op(impl, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Connect the socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    socket_ops::sync_connect(impl.socket_,
-        peer_endpoint.data(), peer_endpoint.size(), ec);
-    return ec;
-  }
-
-  // Start an asynchronous connect.
-  template <typename Handler, typename IoExecutor>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_connect_op<Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        peer_endpoint, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_connect"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service_base.hpp
deleted file mode 100644
index 99b075c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_socket_service_base.hpp
+++ /dev/null
@@ -1,663 +0,0 @@
-//
-// detail/io_uring_socket_service_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
-#define ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IO_URING)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/buffer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/io_uring_null_buffers_op.hpp"
-#include "asio/detail/io_uring_service.hpp"
-#include "asio/detail/io_uring_socket_recv_op.hpp"
-#include "asio/detail/io_uring_socket_recvmsg_op.hpp"
-#include "asio/detail/io_uring_socket_send_op.hpp"
-#include "asio/detail/io_uring_wait_op.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class io_uring_socket_service_base
-{
-public:
-  // The native type of a socket.
-  typedef socket_type native_handle_type;
-
-  // The implementation type of the socket.
-  struct base_implementation_type
-  {
-    // The native socket representation.
-    socket_type socket_;
-
-    // The current state of the socket.
-    socket_ops::state_type state_;
-
-    // Per I/O object data used by the io_uring_service.
-    io_uring_service::per_io_object_data io_object_data_;
-  };
-
-  // Constructor.
-  ASIO_DECL io_uring_socket_service_base(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void base_shutdown();
-
-  // Construct a new socket implementation.
-  ASIO_DECL void construct(base_implementation_type& impl);
-
-  // Move-construct a new socket implementation.
-  ASIO_DECL void base_move_construct(base_implementation_type& impl,
-      base_implementation_type& other_impl) noexcept;
-
-  // Move-assign from another socket implementation.
-  ASIO_DECL void base_move_assign(base_implementation_type& impl,
-      io_uring_socket_service_base& other_service,
-      base_implementation_type& other_impl);
-
-  // Destroy a socket implementation.
-  ASIO_DECL void destroy(base_implementation_type& impl);
-
-  // Determine whether the socket is open.
-  bool is_open(const base_implementation_type& impl) const
-  {
-    return impl.socket_ != invalid_socket;
-  }
-
-  // Destroy a socket implementation.
-  ASIO_DECL asio::error_code close(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Release ownership of the socket.
-  ASIO_DECL socket_type release(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Get the native socket representation.
-  native_handle_type native_handle(base_implementation_type& impl)
-  {
-    return impl.socket_;
-  }
-
-  // Cancel all operations associated with the socket.
-  ASIO_DECL asio::error_code cancel(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::sockatmark(impl.socket_, ec);
-  }
-
-  // Determine the number of bytes available for reading.
-  std::size_t available(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::available(impl.socket_, ec);
-  }
-
-  // Place the socket into the state where it will listen for new connections.
-  asio::error_code listen(base_implementation_type& impl,
-      int backlog, asio::error_code& ec)
-  {
-    socket_ops::listen(impl.socket_, backlog, ec);
-    return ec;
-  }
-
-  // Perform an IO control command on the socket.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(base_implementation_type& impl,
-      IO_Control_Command& command, asio::error_code& ec)
-  {
-    socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
-        static_cast<ioctl_arg_type*>(command.data()), ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Wait for the socket to become ready to read, ready to write, or to have
-  // pending error conditions.
-  asio::error_code wait(base_implementation_type& impl,
-      socket_base::wait_type w, asio::error_code& ec)
-  {
-    switch (w)
-    {
-    case socket_base::wait_read:
-      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_write:
-      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_error:
-      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
-      break;
-    default:
-      ec = asio::error::invalid_argument;
-      break;
-    }
-
-    return ec;
-  }
-
-  // Asynchronously wait for the socket to become ready to read, ready to
-  // write, or to have pending error conditions.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(base_implementation_type& impl,
-      socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    int op_type;
-    int poll_flags;
-    switch (w)
-    {
-    case socket_base::wait_read:
-      op_type = io_uring_service::read_op;
-      poll_flags = POLLIN;
-      break;
-    case socket_base::wait_write:
-      op_type = io_uring_service::write_op;
-      poll_flags = POLLOUT;
-      break;
-    case socket_base::wait_error:
-      op_type = io_uring_service::except_op;
-      poll_flags = POLLPRI | POLLERR | POLLHUP;
-      break;
-    default:
-      op_type = -1;
-      poll_flags = -1;
-      return;
-    }
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_wait_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        poll_flags, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_wait"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    start_op(impl, op_type, p.p, is_continuation, op_type == -1);
-    p.v = p.p = 0;
-  }
-
-  // Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  size_t send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    if (bufs_type::is_single_buffer)
-    {
-      return socket_ops::sync_send1(impl.socket_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      return socket_ops::sync_send(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
-    }
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_send_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        impl.state_, buffers, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_send"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation,
-        ((impl.state_ & socket_ops::stream_oriented)
-          && buffer_sequence_adapter<asio::const_buffer,
-            ConstBufferSequence>::all_empty(buffers)));
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, POLLOUT, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(&io_uring_service_,
-            &impl.io_object_data_, io_uring_service::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_send(null_buffers)"));
-
-    start_op(impl, io_uring_service::write_op, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Receive some data from the peer. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    if (bufs_type::is_single_buffer)
-    {
-      return socket_ops::sync_recv1(impl.socket_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      return socket_ops::sync_recv(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
-    }
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type = (flags & socket_base::message_out_of_band)
-      ? io_uring_service::except_op : io_uring_service::read_op;
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_recv_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        impl.state_, buffers, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_receive"));
-
-    start_op(impl, op_type, p.p, is_continuation,
-        ((impl.state_ & socket_ops::stream_oriented)
-          && buffer_sequence_adapter<asio::mutable_buffer,
-            MutableBufferSequence>::all_empty(buffers)));
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type;
-    int poll_flags;
-    if ((flags & socket_base::message_out_of_band) != 0)
-    {
-      op_type = io_uring_service::except_op;
-      poll_flags = POLLPRI;
-    }
-    else
-    {
-      op_type = io_uring_service::read_op;
-      poll_flags = POLLIN;
-    }
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_receive(null_buffers)"));
-
-    start_op(impl, op_type, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  size_t receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
-        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type = (in_flags & socket_base::message_out_of_band)
-      ? io_uring_service::except_op : io_uring_service::read_op;
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_socket_recvmsg_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
-        buffers, in_flags, out_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p,
-          "socket", &impl, impl.socket_, "async_receive_with_flags"));
-
-    start_op(impl, op_type, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    int op_type;
-    int poll_flags;
-    if ((in_flags & socket_base::message_out_of_band) != 0)
-    {
-      op_type = io_uring_service::except_op;
-      poll_flags = POLLPRI;
-    }
-    else
-    {
-      op_type = io_uring_service::read_op;
-      poll_flags = POLLIN;
-    }
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef io_uring_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, poll_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<io_uring_op_cancellation>(
-            &io_uring_service_, &impl.io_object_data_, op_type);
-    }
-
-    ASIO_HANDLER_CREATION((io_uring_service_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    start_op(impl, op_type, p.p, is_continuation, false);
-    p.v = p.p = 0;
-  }
-
-protected:
-  // Open a new socket implementation.
-  ASIO_DECL asio::error_code do_open(
-      base_implementation_type& impl, int af,
-      int type, int protocol, asio::error_code& ec);
-
-  // Assign a native socket to a socket implementation.
-  ASIO_DECL asio::error_code do_assign(
-      base_implementation_type& impl, int type,
-      const native_handle_type& native_socket, asio::error_code& ec);
-
-  // Start the asynchronous read or write operation.
-  ASIO_DECL void start_op(base_implementation_type& impl, int op_type,
-      io_uring_operation* op, bool is_continuation, bool noop);
-
-  // Start the asynchronous accept operation.
-  ASIO_DECL void start_accept_op(base_implementation_type& impl,
-      io_uring_operation* op, bool is_continuation, bool peer_is_open);
-
-  // Helper class used to implement per-operation cancellation
-  class io_uring_op_cancellation
-  {
-  public:
-    io_uring_op_cancellation(io_uring_service* s,
-        io_uring_service::per_io_object_data* p, int o)
-      : io_uring_service_(s),
-        io_object_data_(p),
-        op_type_(o)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        io_uring_service_->cancel_ops_by_key(*io_object_data_, op_type_, this);
-      }
-    }
-
-  private:
-    io_uring_service* io_uring_service_;
-    io_uring_service::per_io_object_data* io_object_data_;
-    int op_type_;
-  };
-
-  // The io_uring_service that performs event demultiplexing for the service.
-  io_uring_service& io_uring_service_;
-
-  // Cached success value to avoid accessing category singleton.
-  const asio::error_code success_ec_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/io_uring_socket_service_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IO_URING)
-
-#endif // ASIO_DETAIL_IO_URING_SOCKET_SERVICE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_wait_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_wait_op.hpp
deleted file mode 100644
index 4dec72c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/io_uring_wait_op.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// detail/io_uring_wait_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IO_URING_WAIT_OP_HPP
-#define ASIO_DETAIL_IO_URING_WAIT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/io_uring_operation.hpp"
-#include "asio/detail/memory.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class io_uring_wait_op : public io_uring_operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(io_uring_wait_op);
-
-  io_uring_wait_op(const asio::error_code& success_ec, int descriptor,
-      int poll_flags, Handler& handler, const IoExecutor& io_ex)
-    : io_uring_operation(success_ec, &io_uring_wait_op::do_prepare,
-        &io_uring_wait_op::do_perform, &io_uring_wait_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex),
-      descriptor_(descriptor),
-      poll_flags_(poll_flags)
-  {
-  }
-
-  static void do_prepare(io_uring_operation* base, ::io_uring_sqe* sqe)
-  {
-    ASIO_ASSUME(base != 0);
-    io_uring_wait_op* o(static_cast<io_uring_wait_op*>(base));
-
-    ::io_uring_prep_poll_add(sqe, o->descriptor_, o->poll_flags_);
-  }
-
-  static bool do_perform(io_uring_operation*, bool after_completion)
-  {
-    return after_completion;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    io_uring_wait_op* o(static_cast<io_uring_wait_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-  int descriptor_;
-  int poll_flags_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IO_URING_WAIT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_buffer_sequence.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_buffer_sequence.hpp
deleted file mode 100644
index c64e7b1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_buffer_sequence.hpp
+++ /dev/null
@@ -1,296 +0,0 @@
-//
-// detail/is_buffer_sequence.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
-#define ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class mutable_buffer;
-class const_buffer;
-class mutable_registered_buffer;
-class const_registered_buffer;
-
-namespace detail {
-
-struct buffer_sequence_memfns_base
-{
-  void begin();
-  void end();
-  void size();
-  void max_size();
-  void capacity();
-  void data();
-  void prepare();
-  void commit();
-  void consume();
-  void grow();
-  void shrink();
-};
-
-template <typename T>
-struct buffer_sequence_memfns_derived
-  : T, buffer_sequence_memfns_base
-{
-};
-
-template <typename T, T>
-struct buffer_sequence_memfns_check
-{
-};
-
-template <typename>
-char buffer_sequence_begin_helper(...);
-
-template <typename T>
-char (&buffer_sequence_begin_helper(T* t,
-    enable_if_t<!is_same<
-      decltype(asio::buffer_sequence_begin(*t)),
-        void>::value>*))[2];
-
-template <typename>
-char buffer_sequence_end_helper(...);
-
-template <typename T>
-char (&buffer_sequence_end_helper(T* t,
-    enable_if_t<!is_same<
-      decltype(asio::buffer_sequence_end(*t)),
-        void>::value>*))[2];
-
-template <typename>
-char (&size_memfn_helper(...))[2];
-
-template <typename T>
-char size_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::size>*);
-
-template <typename>
-char (&max_size_memfn_helper(...))[2];
-
-template <typename T>
-char max_size_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::max_size>*);
-
-template <typename>
-char (&capacity_memfn_helper(...))[2];
-
-template <typename T>
-char capacity_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::capacity>*);
-
-template <typename>
-char (&data_memfn_helper(...))[2];
-
-template <typename T>
-char data_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::data>*);
-
-template <typename>
-char (&prepare_memfn_helper(...))[2];
-
-template <typename T>
-char prepare_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::prepare>*);
-
-template <typename>
-char (&commit_memfn_helper(...))[2];
-
-template <typename T>
-char commit_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::commit>*);
-
-template <typename>
-char (&consume_memfn_helper(...))[2];
-
-template <typename T>
-char consume_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::consume>*);
-
-template <typename>
-char (&grow_memfn_helper(...))[2];
-
-template <typename T>
-char grow_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::grow>*);
-
-template <typename>
-char (&shrink_memfn_helper(...))[2];
-
-template <typename T>
-char shrink_memfn_helper(
-    buffer_sequence_memfns_check<
-      void (buffer_sequence_memfns_base::*)(),
-      &buffer_sequence_memfns_derived<T>::shrink>*);
-
-template <typename, typename>
-char (&buffer_sequence_element_type_helper(...))[2];
-
-template <typename T, typename Buffer>
-char buffer_sequence_element_type_helper(T* t,
-    enable_if_t<is_convertible<
-      decltype(*asio::buffer_sequence_begin(*t)),
-        Buffer>::value>*);
-
-template <typename>
-char (&const_buffers_type_typedef_helper(...))[2];
-
-template <typename T>
-char const_buffers_type_typedef_helper(
-    typename T::const_buffers_type*);
-
-template <typename>
-char (&mutable_buffers_type_typedef_helper(...))[2];
-
-template <typename T>
-char mutable_buffers_type_typedef_helper(
-    typename T::mutable_buffers_type*);
-
-template <typename T, typename Buffer>
-struct is_buffer_sequence_class
-  : integral_constant<bool,
-      sizeof(buffer_sequence_begin_helper<T>(0, 0)) != 1 &&
-      sizeof(buffer_sequence_end_helper<T>(0, 0)) != 1 &&
-      sizeof(buffer_sequence_element_type_helper<T, Buffer>(0, 0)) == 1>
-{
-};
-
-template <typename T, typename Buffer>
-struct is_buffer_sequence
-  : conditional<is_class<T>::value,
-      is_buffer_sequence_class<T, Buffer>,
-      false_type>::type
-{
-};
-
-template <>
-struct is_buffer_sequence<mutable_buffer, mutable_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<mutable_buffer, const_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<const_buffer, const_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<const_buffer, mutable_buffer>
-  : false_type
-{
-};
-
-template <>
-struct is_buffer_sequence<mutable_registered_buffer, mutable_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<mutable_registered_buffer, const_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<const_registered_buffer, const_buffer>
-  : true_type
-{
-};
-
-template <>
-struct is_buffer_sequence<const_registered_buffer, mutable_buffer>
-  : false_type
-{
-};
-
-template <typename T>
-struct is_dynamic_buffer_class_v1
-  : integral_constant<bool,
-      sizeof(size_memfn_helper<T>(0)) != 1 &&
-      sizeof(max_size_memfn_helper<T>(0)) != 1 &&
-      sizeof(capacity_memfn_helper<T>(0)) != 1 &&
-      sizeof(data_memfn_helper<T>(0)) != 1 &&
-      sizeof(consume_memfn_helper<T>(0)) != 1 &&
-      sizeof(prepare_memfn_helper<T>(0)) != 1 &&
-      sizeof(commit_memfn_helper<T>(0)) != 1 &&
-      sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
-      sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
-{
-};
-
-template <typename T>
-struct is_dynamic_buffer_v1
-  : conditional<is_class<T>::value,
-      is_dynamic_buffer_class_v1<T>,
-      false_type>::type
-{
-};
-
-template <typename T>
-struct is_dynamic_buffer_class_v2
-  : integral_constant<bool,
-      sizeof(size_memfn_helper<T>(0)) != 1 &&
-      sizeof(max_size_memfn_helper<T>(0)) != 1 &&
-      sizeof(capacity_memfn_helper<T>(0)) != 1 &&
-      sizeof(data_memfn_helper<T>(0)) != 1 &&
-      sizeof(consume_memfn_helper<T>(0)) != 1 &&
-      sizeof(grow_memfn_helper<T>(0)) != 1 &&
-      sizeof(shrink_memfn_helper<T>(0)) != 1 &&
-      sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
-      sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
-{
-};
-
-template <typename T>
-struct is_dynamic_buffer_v2
-  : conditional<is_class<T>::value,
-      is_dynamic_buffer_class_v2<T>,
-      false_type>::type
-{
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_executor.hpp
deleted file mode 100644
index 2636f9c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/is_executor.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// detail/is_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IS_EXECUTOR_HPP
-#define ASIO_DETAIL_IS_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct executor_memfns_base
-{
-  void context();
-  void on_work_started();
-  void on_work_finished();
-  void dispatch();
-  void post();
-  void defer();
-};
-
-template <typename T>
-struct executor_memfns_derived
-  : T, executor_memfns_base
-{
-};
-
-template <typename T, T>
-struct executor_memfns_check
-{
-};
-
-template <typename>
-char (&context_memfn_helper(...))[2];
-
-template <typename T>
-char context_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::context>*);
-
-template <typename>
-char (&on_work_started_memfn_helper(...))[2];
-
-template <typename T>
-char on_work_started_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::on_work_started>*);
-
-template <typename>
-char (&on_work_finished_memfn_helper(...))[2];
-
-template <typename T>
-char on_work_finished_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::on_work_finished>*);
-
-template <typename>
-char (&dispatch_memfn_helper(...))[2];
-
-template <typename T>
-char dispatch_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::dispatch>*);
-
-template <typename>
-char (&post_memfn_helper(...))[2];
-
-template <typename T>
-char post_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::post>*);
-
-template <typename>
-char (&defer_memfn_helper(...))[2];
-
-template <typename T>
-char defer_memfn_helper(
-    executor_memfns_check<
-      void (executor_memfns_base::*)(),
-      &executor_memfns_derived<T>::defer>*);
-
-template <typename T>
-struct is_executor_class
-  : integral_constant<bool,
-      sizeof(context_memfn_helper<T>(0)) != 1 &&
-      sizeof(on_work_started_memfn_helper<T>(0)) != 1 &&
-      sizeof(on_work_finished_memfn_helper<T>(0)) != 1 &&
-      sizeof(dispatch_memfn_helper<T>(0)) != 1 &&
-      sizeof(post_memfn_helper<T>(0)) != 1 &&
-      sizeof(defer_memfn_helper<T>(0)) != 1>
-{
-};
-
-template <typename T>
-struct is_executor
-  : conditional<is_class<T>::value,
-      is_executor_class<T>,
-      false_type>::type
-{
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IS_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/keyword_tss_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/keyword_tss_ptr.hpp
deleted file mode 100644
index 2e42df8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/keyword_tss_ptr.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-// detail/keyword_tss_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
-#define ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-class keyword_tss_ptr
-  : private noncopyable
-{
-public:
-  // Constructor.
-  keyword_tss_ptr()
-  {
-  }
-
-  // Destructor.
-  ~keyword_tss_ptr()
-  {
-  }
-
-  // Get the value.
-  operator T*() const
-  {
-    return value_;
-  }
-
-  // Set the value.
-  void operator=(T* value)
-  {
-    value_ = value;
-  }
-
-private:
-  static ASIO_THREAD_KEYWORD T* value_;
-};
-
-template <typename T>
-ASIO_THREAD_KEYWORD T* keyword_tss_ptr<T>::value_;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-
-#endif // ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/kqueue_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/kqueue_reactor.hpp
deleted file mode 100644
index f034410..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/kqueue_reactor.hpp
+++ /dev/null
@@ -1,271 +0,0 @@
-//
-// detail/kqueue_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_KQUEUE_REACTOR_HPP
-#define ASIO_DETAIL_KQUEUE_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_KQUEUE)
-
-#include <cstddef>
-#include <sys/types.h>
-#include <sys/event.h>
-#include <sys/time.h>
-#include "asio/detail/conditionally_enabled_mutex.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/object_pool.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-
-// Older versions of Mac OS X may not define EV_OOBAND.
-#if !defined(EV_OOBAND)
-# define EV_OOBAND EV_FLAG1
-#endif // !defined(EV_OOBAND)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class scheduler;
-
-class kqueue_reactor
-  : public execution_context_service_base<kqueue_reactor>,
-    public scheduler_task
-{
-private:
-  // The mutex type used by this reactor.
-  typedef conditionally_enabled_mutex mutex;
-
-public:
-  enum op_types { read_op = 0, write_op = 1,
-    connect_op = 1, except_op = 2, max_ops = 3 };
-
-  // Per-descriptor queues.
-  struct descriptor_state
-  {
-    descriptor_state(bool locking) : mutex_(locking) {}
-
-    friend class kqueue_reactor;
-    friend class object_pool_access;
-
-    descriptor_state* next_;
-    descriptor_state* prev_;
-
-    mutex mutex_;
-    int descriptor_;
-    int num_kevents_; // 1 == read only, 2 == read and write
-    op_queue<reactor_op> op_queue_[max_ops];
-    bool shutdown_;
-  };
-
-  // Per-descriptor data.
-  typedef descriptor_state* per_descriptor_data;
-
-  // Constructor.
-  ASIO_DECL kqueue_reactor(asio::execution_context& ctx);
-
-  // Destructor.
-  ASIO_DECL ~kqueue_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal descriptors following a fork.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // success, system error code on failure.
-  ASIO_DECL int register_internal_descriptor(
-      int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op);
-
-  // Move descriptor registration from one descriptor_data object to another.
-  ASIO_DECL void move_descriptor(socket_type descriptor,
-      per_descriptor_data& target_descriptor_data,
-      per_descriptor_data& source_descriptor_data);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(operation* op, bool is_continuation) const;
-
-  // Post a reactor operation for immediate completion.
-  ASIO_DECL static void call_post_immediate_completion(
-      operation* op, bool is_continuation, const void* self);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative,
-      void (*on_immediate)(operation*, bool, const void*),
-      const void* immediate_arg);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative)
-  {
-    start_op(op_type, descriptor, descriptor_data,
-        op, is_continuation, allow_speculative,
-        &kqueue_reactor::call_post_immediate_completion, this);
-  }
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Cancel all operations associated with the given descriptor and key. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      int op_type, void* cancellation_key);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor. The reactor resources associated with
-  // the descriptor must be released by calling cleanup_descriptor_data.
-  ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data, bool closing);
-
-  // Remove the descriptor's registration from the reactor. The reactor
-  // resources associated with the descriptor must be released by calling
-  // cleanup_descriptor_data.
-  ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
-
-  // Perform any post-deregistration cleanup tasks associated with the
-  // descriptor data.
-  ASIO_DECL void cleanup_descriptor_data(
-      per_descriptor_data& descriptor_data);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
-
-  // Run the kqueue loop.
-  ASIO_DECL void run(long usec, op_queue<operation>& ops);
-
-  // Interrupt the kqueue loop.
-  ASIO_DECL void interrupt();
-
-private:
-  // Create the kqueue file descriptor. Throws an exception if the descriptor
-  // cannot be created.
-  ASIO_DECL static int do_kqueue_create();
-
-  // Allocate a new descriptor state object.
-  ASIO_DECL descriptor_state* allocate_descriptor_state();
-
-  // Free an existing descriptor state object.
-  ASIO_DECL void free_descriptor_state(descriptor_state* s);
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Get the timeout value for the kevent call.
-  ASIO_DECL timespec* get_timeout(long usec, timespec& ts);
-
-  // The scheduler used to post completions.
-  scheduler& scheduler_;
-
-  // Mutex to protect access to internal data.
-  mutex mutex_;
-
-  // The kqueue file descriptor.
-  int kqueue_fd_;
-
-  // The interrupter is used to break a blocking kevent call.
-  select_interrupter interrupter_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-
-  // Mutex to protect access to the registered descriptors.
-  mutex registered_descriptors_mutex_;
-
-  // Keep track of all registered descriptors.
-  object_pool<descriptor_state> registered_descriptors_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/kqueue_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/kqueue_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_KQUEUE)
-
-#endif // ASIO_DETAIL_KQUEUE_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/limits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/limits.hpp
deleted file mode 100644
index 323af22..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/limits.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//
-// detail/limits.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_LIMITS_HPP
-#define ASIO_DETAIL_LIMITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <limits>
-
-#endif // ASIO_DETAIL_LIMITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/local_free_on_block_exit.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/local_free_on_block_exit.hpp
deleted file mode 100644
index 212f9c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/local_free_on_block_exit.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// detail/local_free_on_block_exit.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP
-#define ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-#if !defined(ASIO_WINDOWS_APP)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class local_free_on_block_exit
-  : private noncopyable
-{
-public:
-  // Constructor blocks all signals for the calling thread.
-  explicit local_free_on_block_exit(void* p)
-    : p_(p)
-  {
-  }
-
-  // Destructor restores the previous signal mask.
-  ~local_free_on_block_exit()
-  {
-    ::LocalFree(p_);
-  }
-
-private:
-  void* p_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS_APP)
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/memory.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/memory.hpp
deleted file mode 100644
index 173e49f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/memory.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// detail/memory.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_MEMORY_HPP
-#define ASIO_DETAIL_MEMORY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <new>
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#if !defined(ASIO_HAS_STD_ALIGNED_ALLOC) \
-  && defined(ASIO_HAS_BOOST_ALIGN)
-# include <boost/align/aligned_alloc.hpp>
-#endif // !defined(ASIO_HAS_STD_ALIGNED_ALLOC)
-       //   && defined(ASIO_HAS_BOOST_ALIGN)
-
-namespace asio {
-namespace detail {
-
-using std::allocate_shared;
-using std::make_shared;
-using std::shared_ptr;
-using std::weak_ptr;
-using std::addressof;
-
-#if defined(ASIO_HAS_STD_TO_ADDRESS)
-using std::to_address;
-#else // defined(ASIO_HAS_STD_TO_ADDRESS)
-template <typename T>
-inline T* to_address(T* p) { return p; }
-template <typename T>
-inline const T* to_address(const T* p) { return p; }
-template <typename T>
-inline volatile T* to_address(volatile T* p) { return p; }
-template <typename T>
-inline const volatile T* to_address(const volatile T* p) { return p; }
-#endif // defined(ASIO_HAS_STD_TO_ADDRESS)
-
-inline void* align(std::size_t alignment,
-    std::size_t size, void*& ptr, std::size_t& space)
-{
-  return std::align(alignment, size, ptr, space);
-}
-
-} // namespace detail
-
-using std::allocator_arg_t;
-# define ASIO_USES_ALLOCATOR(t) \
-  namespace std { \
-    template <typename Allocator> \
-    struct uses_allocator<t, Allocator> : true_type {}; \
-  } \
-  /**/
-# define ASIO_REBIND_ALLOC(alloc, t) \
-  typename std::allocator_traits<alloc>::template rebind_alloc<t>
-  /**/
-
-inline void* aligned_new(std::size_t align, std::size_t size)
-{
-#if defined(ASIO_HAS_STD_ALIGNED_ALLOC)
-  align = (align < ASIO_DEFAULT_ALIGN) ? ASIO_DEFAULT_ALIGN : align;
-  size = (size % align == 0) ? size : size + (align - size % align);
-  void* ptr = std::aligned_alloc(align, size);
-  if (!ptr)
-  {
-    std::bad_alloc ex;
-    asio::detail::throw_exception(ex);
-  }
-  return ptr;
-#elif defined(ASIO_HAS_BOOST_ALIGN)
-  align = (align < ASIO_DEFAULT_ALIGN) ? ASIO_DEFAULT_ALIGN : align;
-  size = (size % align == 0) ? size : size + (align - size % align);
-  void* ptr = boost::alignment::aligned_alloc(align, size);
-  if (!ptr)
-  {
-    std::bad_alloc ex;
-    asio::detail::throw_exception(ex);
-  }
-  return ptr;
-#elif defined(ASIO_MSVC)
-  align = (align < ASIO_DEFAULT_ALIGN) ? ASIO_DEFAULT_ALIGN : align;
-  size = (size % align == 0) ? size : size + (align - size % align);
-  void* ptr = _aligned_malloc(size, align);
-  if (!ptr)
-  {
-    std::bad_alloc ex;
-    asio::detail::throw_exception(ex);
-  }
-  return ptr;
-#else // defined(ASIO_MSVC)
-  (void)align;
-  return ::operator new(size);
-#endif // defined(ASIO_MSVC)
-}
-
-inline void aligned_delete(void* ptr)
-{
-#if defined(ASIO_HAS_STD_ALIGNED_ALLOC)
-  std::free(ptr);
-#elif defined(ASIO_HAS_BOOST_ALIGN)
-  boost::alignment::aligned_free(ptr);
-#elif defined(ASIO_MSVC)
-  _aligned_free(ptr);
-#else // defined(ASIO_MSVC)
-  ::operator delete(ptr);
-#endif // defined(ASIO_MSVC)
-}
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_MEMORY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/mutex.hpp
deleted file mode 100644
index e701c23..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/mutex.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// detail/mutex.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_MUTEX_HPP
-#define ASIO_DETAIL_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_mutex.hpp"
-#elif defined(ASIO_WINDOWS)
-# include "asio/detail/win_mutex.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_mutex.hpp"
-#else
-# include "asio/detail/std_mutex.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS)
-typedef null_mutex mutex;
-#elif defined(ASIO_WINDOWS)
-typedef win_mutex mutex;
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_mutex mutex;
-#else
-typedef std_mutex mutex;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/non_const_lvalue.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/non_const_lvalue.hpp
deleted file mode 100644
index 940bf25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/non_const_lvalue.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// detail/non_const_lvalue.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NON_CONST_LVALUE_HPP
-#define ASIO_DETAIL_NON_CONST_LVALUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct non_const_lvalue
-{
-  explicit non_const_lvalue(T& t)
-    : value(static_cast<conditional_t<
-        is_same<T, decay_t<T>>::value, decay_t<T>&, T&&>>(t))
-  {
-  }
-
-  conditional_t<is_same<T, decay_t<T>>::value, decay_t<T>&, decay_t<T>> value;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_NON_CONST_LVALUE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/noncopyable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/noncopyable.hpp
deleted file mode 100644
index 7b80a89..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/noncopyable.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// detail/noncopyable.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NONCOPYABLE_HPP
-#define ASIO_DETAIL_NONCOPYABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class noncopyable
-{
-protected:
-  noncopyable() {}
-  ~noncopyable() {}
-private:
-  noncopyable(const noncopyable&);
-  const noncopyable& operator=(const noncopyable&);
-};
-
-} // namespace detail
-
-using asio::detail::noncopyable;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_NONCOPYABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_event.hpp
deleted file mode 100644
index d50724c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_event.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-// detail/null_event.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_EVENT_HPP
-#define ASIO_DETAIL_NULL_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_event
-  : private noncopyable
-{
-public:
-  // Constructor.
-  null_event()
-  {
-  }
-
-  // Destructor.
-  ~null_event()
-  {
-  }
-
-  // Signal the event. (Retained for backward compatibility.)
-  template <typename Lock>
-  void signal(Lock&)
-  {
-  }
-
-  // Signal all waiters.
-  template <typename Lock>
-  void signal_all(Lock&)
-  {
-  }
-
-  // Unlock the mutex and signal one waiter.
-  template <typename Lock>
-  void unlock_and_signal_one(Lock&)
-  {
-  }
-
-  // Unlock the mutex and signal one waiter who may destroy us.
-  template <typename Lock>
-  void unlock_and_signal_one_for_destruction(Lock&)
-  {
-  }
-
-  // If there's a waiter, unlock the mutex and signal it.
-  template <typename Lock>
-  bool maybe_unlock_and_signal_one(Lock&)
-  {
-    return false;
-  }
-
-  // Reset the event.
-  template <typename Lock>
-  void clear(Lock&)
-  {
-  }
-
-  // Wait for the event to become signalled.
-  template <typename Lock>
-  void wait(Lock&)
-  {
-    do_wait();
-  }
-
-  // Timed wait for the event to become signalled.
-  template <typename Lock>
-  bool wait_for_usec(Lock&, long usec)
-  {
-    do_wait_for_usec(usec);
-    return true;
-  }
-
-private:
-  ASIO_DECL static void do_wait();
-  ASIO_DECL static void do_wait_for_usec(long usec);
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/null_event.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_NULL_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_fenced_block.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_fenced_block.hpp
deleted file mode 100644
index ccf65c3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_fenced_block.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// detail/null_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_NULL_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_fenced_block
-  : private noncopyable
-{
-public:
-  enum half_or_full_t { half, full };
-
-  // Constructor.
-  explicit null_fenced_block(half_or_full_t)
-  {
-  }
-
-  // Destructor.
-  ~null_fenced_block()
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_NULL_FENCED_BLOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_global.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_global.hpp
deleted file mode 100644
index ab8b9c8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_global.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// detail/null_global.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_GLOBAL_HPP
-#define ASIO_DETAIL_NULL_GLOBAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct null_global_impl
-{
-  null_global_impl()
-    : ptr_(0)
-  {
-  }
-
-  // Destructor automatically cleans up the global.
-  ~null_global_impl()
-  {
-    delete ptr_;
-  }
-
-  static null_global_impl instance_;
-  T* ptr_;
-};
-
-template <typename T>
-null_global_impl<T> null_global_impl<T>::instance_;
-
-template <typename T>
-T& null_global()
-{
-  if (null_global_impl<T>::instance_.ptr_ == 0)
-    null_global_impl<T>::instance_.ptr_ = new T;
-  return *null_global_impl<T>::instance_.ptr_;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_NULL_GLOBAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_mutex.hpp
deleted file mode 100644
index 77e7594..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_mutex.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// detail/null_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_MUTEX_HPP
-#define ASIO_DETAIL_NULL_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_mutex
-  : private noncopyable
-{
-public:
-  typedef asio::detail::scoped_lock<null_mutex> scoped_lock;
-
-  // Constructor.
-  null_mutex()
-  {
-  }
-
-  // Destructor.
-  ~null_mutex()
-  {
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_NULL_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_reactor.hpp
deleted file mode 100644
index 128f2b4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_reactor.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// detail/null_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_REACTOR_HPP
-#define ASIO_DETAIL_NULL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || defined(ASIO_WINDOWS_RUNTIME) \
-  || defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/scheduler_operation.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_reactor
-  : public execution_context_service_base<null_reactor>,
-    public scheduler_task
-{
-public:
-  struct per_descriptor_data
-  {
-  };
-
-  // Constructor.
-  null_reactor(asio::execution_context& ctx)
-    : execution_context_service_base<null_reactor>(ctx)
-  {
-  }
-
-  // Destructor.
-  ~null_reactor()
-  {
-  }
-
-  // Initialise the task.
-  void init_task()
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-  }
-
-  // No-op because should never be called.
-  void run(long /*usec*/, op_queue<scheduler_operation>& /*ops*/)
-  {
-  }
-
-  // No-op.
-  void interrupt()
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || defined(ASIO_WINDOWS_RUNTIME)
-       //   || defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_NULL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_signal_blocker.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_signal_blocker.hpp
deleted file mode 100644
index 1c40307..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_signal_blocker.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// detail/null_signal_blocker.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
-#define ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS) \
-  || defined(ASIO_WINDOWS) \
-  || defined(ASIO_WINDOWS_RUNTIME) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_signal_blocker
-  : private noncopyable
-{
-public:
-  // Constructor blocks all signals for the calling thread.
-  null_signal_blocker()
-  {
-  }
-
-  // Destructor restores the previous signal mask.
-  ~null_signal_blocker()
-  {
-  }
-
-  // Block all signals for the calling thread.
-  void block()
-  {
-  }
-
-  // Restore the previous signal mask.
-  void unblock()
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_THREADS)
-       // || defined(ASIO_WINDOWS)
-       // || defined(ASIO_WINDOWS_RUNTIME)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-
-#endif // ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_socket_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_socket_service.hpp
deleted file mode 100644
index 84e2129..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_socket_service.hpp
+++ /dev/null
@@ -1,519 +0,0 @@
-//
-// detail/null_socket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP
-#define ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/buffer.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/post.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/bind_handler.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class null_socket_service :
-  public execution_context_service_base<null_socket_service<Protocol>>
-{
-public:
-  // The protocol type.
-  typedef Protocol protocol_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The native type of a socket.
-  typedef int native_handle_type;
-
-  // The implementation type of the socket.
-  struct implementation_type
-  {
-  };
-
-  // Constructor.
-  null_socket_service(execution_context& context)
-    : execution_context_service_base<null_socket_service<Protocol>>(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-  }
-
-  // Construct a new socket implementation.
-  void construct(implementation_type&)
-  {
-  }
-
-  // Move-construct a new socket implementation.
-  void move_construct(implementation_type&, implementation_type&)
-  {
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type&,
-      null_socket_service&, implementation_type&)
-  {
-  }
-
-  // Move-construct a new socket implementation from another protocol type.
-  template <typename Protocol1>
-  void converting_move_construct(implementation_type&,
-      null_socket_service<Protocol1>&,
-      typename null_socket_service<Protocol1>::implementation_type&)
-  {
-  }
-
-  // Destroy a socket implementation.
-  void destroy(implementation_type&)
-  {
-  }
-
-  // Open a new socket implementation.
-  asio::error_code open(implementation_type&,
-      const protocol_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Assign a native socket to a socket implementation.
-  asio::error_code assign(implementation_type&, const protocol_type&,
-      const native_handle_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Determine whether the socket is open.
-  bool is_open(const implementation_type&) const
-  {
-    return false;
-  }
-
-  // Destroy a socket implementation.
-  asio::error_code close(implementation_type&,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Release ownership of the socket.
-  native_handle_type release(implementation_type&,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Get the native socket representation.
-  native_handle_type native_handle(implementation_type&)
-  {
-    return 0;
-  }
-
-  // Cancel all operations associated with the socket.
-  asio::error_code cancel(implementation_type&,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return false;
-  }
-
-  // Determine the number of bytes available for reading.
-  std::size_t available(const implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Place the socket into the state where it will listen for new connections.
-  asio::error_code listen(implementation_type&,
-      int, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Perform an IO control command on the socket.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(implementation_type&,
-      IO_Control_Command&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const implementation_type&) const
-  {
-    return false;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(implementation_type&,
-      bool, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const implementation_type&) const
-  {
-    return false;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(implementation_type&,
-      bool, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type&,
-      socket_base::shutdown_type, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Bind the socket to the specified local endpoint.
-  asio::error_code bind(implementation_type&,
-      const endpoint_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code set_option(implementation_type&,
-      const Option&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code get_option(const implementation_type&,
-      Option&, asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return endpoint_type();
-  }
-
-  // Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return endpoint_type();
-  }
-
-  // Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  std::size_t send(implementation_type&, const ConstBufferSequence&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Wait until data can be sent without blocking.
-  std::size_t send(implementation_type&, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send(implementation_type&, const ConstBufferSequence&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send(implementation_type&, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Receive some data from the peer. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  std::size_t receive(implementation_type&, const MutableBufferSequence&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Wait until data can be received without blocking.
-  std::size_t receive(implementation_type&, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive(implementation_type&, const MutableBufferSequence&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive(implementation_type&, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  std::size_t receive_with_flags(implementation_type&,
-      const MutableBufferSequence&, socket_base::message_flags,
-      socket_base::message_flags&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Wait until data can be received without blocking.
-  std::size_t receive_with_flags(implementation_type&,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_with_flags(implementation_type&,
-      const MutableBufferSequence&, socket_base::message_flags,
-      socket_base::message_flags&, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_with_flags(implementation_type&, const null_buffers&,
-      socket_base::message_flags, socket_base::message_flags&,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Send a datagram to the specified endpoint. Returns the number of bytes
-  // sent.
-  template <typename ConstBufferSequence>
-  std::size_t send_to(implementation_type&, const ConstBufferSequence&,
-      const endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Wait until data can be sent without blocking.
-  std::size_t send_to(implementation_type&, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type&, const ConstBufferSequence&,
-      const endpoint_type&, socket_base::message_flags,
-      Handler& handler)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type&, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Receive a datagram with the endpoint of the sender. Returns the number of
-  // bytes received.
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(implementation_type&, const MutableBufferSequence&,
-      endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Wait until data can be received without blocking.
-  std::size_t receive_from(implementation_type&, const null_buffers&,
-      endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received and
-  // the sender_endpoint object must both be valid for the lifetime of the
-  // asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type&, const MutableBufferSequence&,
-      endpoint_type&, socket_base::message_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type&, const null_buffers&,
-      endpoint_type&, socket_base::message_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex, detail::bind_handler(
-          handler, ec, bytes_transferred));
-  }
-
-  // Accept a new connection.
-  template <typename Socket>
-  asio::error_code accept(implementation_type&,
-      Socket&, endpoint_type*, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Start an asynchronous accept. The peer and peer_endpoint objects
-  // must be valid until the accept's handler is invoked.
-  template <typename Socket, typename Handler, typename IoExecutor>
-  void async_accept(implementation_type&, Socket&, endpoint_type*,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    asio::post(io_ex, detail::bind_handler(handler, ec));
-  }
-
-  // Connect the socket to the specified endpoint.
-  asio::error_code connect(implementation_type&,
-      const endpoint_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Start an asynchronous connect.
-  template <typename Handler, typename IoExecutor>
-  void async_connect(implementation_type&, const endpoint_type&,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    asio::post(io_ex, detail::bind_handler(handler, ec));
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_static_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_static_mutex.hpp
deleted file mode 100644
index 15d649b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_static_mutex.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// detail/null_static_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
-#define ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct null_static_mutex
-{
-  typedef asio::detail::scoped_lock<null_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  void init()
-  {
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-  }
-
-  int unused_;
-};
-
-#define ASIO_NULL_STATIC_MUTEX_INIT { 0 }
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_THREADS)
-
-#endif // ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_thread.hpp
deleted file mode 100644
index aca2616..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_thread.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// detail/null_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_THREAD_HPP
-#define ASIO_DETAIL_NULL_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class null_thread
-  : private noncopyable
-{
-public:
-  // Constructor.
-  template <typename Function>
-  null_thread(Function, unsigned int = 0)
-  {
-    asio::detail::throw_error(
-        asio::error::operation_not_supported, "thread");
-  }
-
-  // Destructor.
-  ~null_thread()
-  {
-  }
-
-  // Wait for the thread to exit.
-  void join()
-  {
-  }
-
-  // Get number of CPUs.
-  static std::size_t hardware_concurrency()
-  {
-    return 1;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_THREADS)
-
-#endif // ASIO_DETAIL_NULL_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_tss_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_tss_ptr.hpp
deleted file mode 100644
index cf64a2b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/null_tss_ptr.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// detail/null_tss_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_NULL_TSS_PTR_HPP
-#define ASIO_DETAIL_NULL_TSS_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-class null_tss_ptr
-  : private noncopyable
-{
-public:
-  // Constructor.
-  null_tss_ptr()
-    : value_(0)
-  {
-  }
-
-  // Destructor.
-  ~null_tss_ptr()
-  {
-  }
-
-  // Get the value.
-  operator T*() const
-  {
-    return value_;
-  }
-
-  // Set the value.
-  void operator=(T* value)
-  {
-    value_ = value;
-  }
-
-private:
-  T* value_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_THREADS)
-
-#endif // ASIO_DETAIL_NULL_TSS_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/object_pool.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/object_pool.hpp
deleted file mode 100644
index 41254ce..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/object_pool.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// detail/object_pool.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_OBJECT_POOL_HPP
-#define ASIO_DETAIL_OBJECT_POOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Object>
-class object_pool;
-
-class object_pool_access
-{
-public:
-  template <typename Object>
-  static Object* create()
-  {
-    return new Object;
-  }
-
-  template <typename Object, typename Arg>
-  static Object* create(Arg arg)
-  {
-    return new Object(arg);
-  }
-
-  template <typename Object>
-  static void destroy(Object* o)
-  {
-    delete o;
-  }
-
-  template <typename Object>
-  static Object*& next(Object* o)
-  {
-    return o->next_;
-  }
-
-  template <typename Object>
-  static Object*& prev(Object* o)
-  {
-    return o->prev_;
-  }
-};
-
-template <typename Object>
-class object_pool
-  : private noncopyable
-{
-public:
-  // Constructor.
-  object_pool()
-    : live_list_(0),
-      free_list_(0)
-  {
-  }
-
-  // Destructor destroys all objects.
-  ~object_pool()
-  {
-    destroy_list(live_list_);
-    destroy_list(free_list_);
-  }
-
-  // Get the object at the start of the live list.
-  Object* first()
-  {
-    return live_list_;
-  }
-
-  // Allocate a new object.
-  Object* alloc()
-  {
-    Object* o = free_list_;
-    if (o)
-      free_list_ = object_pool_access::next(free_list_);
-    else
-      o = object_pool_access::create<Object>();
-
-    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;
-  }
-
-  // Allocate a new object with an argument.
-  template <typename Arg>
-  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;
-  }
-
-  // Free an object. Moves it to the free list. No destructors are run.
-  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;
-  }
-
-private:
-  // Helper function to destroy all elements in a list.
-  void destroy_list(Object* list)
-  {
-    while (list)
-    {
-      Object* o = list;
-      list = object_pool_access::next(o);
-      object_pool_access::destroy(o);
-    }
-  }
-
-  // The list of live objects.
-  Object* live_list_;
-
-  // The free list.
-  Object* free_list_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_OBJECT_POOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/old_win_sdk_compat.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/old_win_sdk_compat.hpp
deleted file mode 100644
index 2c43c1d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/old_win_sdk_compat.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-//
-// detail/old_win_sdk_compat.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
-#define ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-// Guess whether we are building against on old Platform SDK.
-#if !defined(IN6ADDR_ANY_INIT)
-#define ASIO_HAS_OLD_WIN_SDK 1
-#endif // !defined(IN6ADDR_ANY_INIT)
-
-#if defined(ASIO_HAS_OLD_WIN_SDK)
-
-// Emulation of types that are missing from old Platform SDKs.
-//
-// N.B. this emulation is also used if building for a Windows 2000 target with
-// a recent (i.e. Vista or later) SDK, as the SDK does not provide IPv6 support
-// in that case.
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-enum
-{
-  sockaddr_storage_maxsize = 128, // Maximum size.
-  sockaddr_storage_alignsize = (sizeof(__int64)), // Desired alignment.
-  sockaddr_storage_pad1size = (sockaddr_storage_alignsize - sizeof(short)),
-  sockaddr_storage_pad2size = (sockaddr_storage_maxsize -
-      (sizeof(short) + sockaddr_storage_pad1size + sockaddr_storage_alignsize))
-};
-
-struct sockaddr_storage_emulation
-{
-  short ss_family;
-  char __ss_pad1[sockaddr_storage_pad1size];
-  __int64 __ss_align;
-  char __ss_pad2[sockaddr_storage_pad2size];
-};
-
-struct in6_addr_emulation
-{
-  union
-  {
-    u_char Byte[16];
-    u_short Word[8];
-  } u;
-};
-
-#if !defined(s6_addr)
-# define _S6_un u
-# define _S6_u8 Byte
-# define s6_addr _S6_un._S6_u8
-#endif // !defined(s6_addr)
-
-struct sockaddr_in6_emulation
-{
-  short sin6_family;
-  u_short sin6_port;
-  u_long sin6_flowinfo;
-  in6_addr_emulation sin6_addr;
-  u_long sin6_scope_id;
-};
-
-struct ipv6_mreq_emulation
-{
-  in6_addr_emulation ipv6mr_multiaddr;
-  unsigned int ipv6mr_interface;
-};
-
-struct addrinfo_emulation
-{
-  int ai_flags;
-  int ai_family;
-  int ai_socktype;
-  int ai_protocol;
-  size_t ai_addrlen;
-  char* ai_canonname;
-  sockaddr* ai_addr;
-  addrinfo_emulation* ai_next;
-};
-
-#if !defined(AI_PASSIVE)
-# define AI_PASSIVE 0x1
-#endif
-
-#if !defined(AI_CANONNAME)
-# define AI_CANONNAME 0x2
-#endif
-
-#if !defined(AI_NUMERICHOST)
-# define AI_NUMERICHOST 0x4
-#endif
-
-#if !defined(EAI_AGAIN)
-# define EAI_AGAIN WSATRY_AGAIN
-#endif
-
-#if !defined(EAI_BADFLAGS)
-# define EAI_BADFLAGS WSAEINVAL
-#endif
-
-#if !defined(EAI_FAIL)
-# define EAI_FAIL WSANO_RECOVERY
-#endif
-
-#if !defined(EAI_FAMILY)
-# define EAI_FAMILY WSAEAFNOSUPPORT
-#endif
-
-#if !defined(EAI_MEMORY)
-# define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY
-#endif
-
-#if !defined(EAI_NODATA)
-# define EAI_NODATA WSANO_DATA
-#endif
-
-#if !defined(EAI_NONAME)
-# define EAI_NONAME WSAHOST_NOT_FOUND
-#endif
-
-#if !defined(EAI_SERVICE)
-# define EAI_SERVICE WSATYPE_NOT_FOUND
-#endif
-
-#if !defined(EAI_SOCKTYPE)
-# define EAI_SOCKTYPE WSAESOCKTNOSUPPORT
-#endif
-
-#if !defined(NI_NOFQDN)
-# define NI_NOFQDN 0x01
-#endif
-
-#if !defined(NI_NUMERICHOST)
-# define NI_NUMERICHOST 0x02
-#endif
-
-#if !defined(NI_NAMEREQD)
-# define NI_NAMEREQD 0x04
-#endif
-
-#if !defined(NI_NUMERICSERV)
-# define NI_NUMERICSERV 0x08
-#endif
-
-#if !defined(NI_DGRAM)
-# define NI_DGRAM 0x10
-#endif
-
-#if !defined(IPPROTO_IPV6)
-# define IPPROTO_IPV6 41
-#endif
-
-#if !defined(IPV6_UNICAST_HOPS)
-# define IPV6_UNICAST_HOPS 4
-#endif
-
-#if !defined(IPV6_MULTICAST_IF)
-# define IPV6_MULTICAST_IF 9
-#endif
-
-#if !defined(IPV6_MULTICAST_HOPS)
-# define IPV6_MULTICAST_HOPS 10
-#endif
-
-#if !defined(IPV6_MULTICAST_LOOP)
-# define IPV6_MULTICAST_LOOP 11
-#endif
-
-#if !defined(IPV6_JOIN_GROUP)
-# define IPV6_JOIN_GROUP 12
-#endif
-
-#if !defined(IPV6_LEAVE_GROUP)
-# define IPV6_LEAVE_GROUP 13
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_OLD_WIN_SDK)
-
-// Even newer Platform SDKs that support IPv6 may not define IPV6_V6ONLY.
-#if !defined(IPV6_V6ONLY)
-# define IPV6_V6ONLY 27
-#endif
-
-// Some SDKs (e.g. Windows CE) don't define IPPROTO_ICMPV6.
-#if !defined(IPPROTO_ICMPV6)
-# define IPPROTO_ICMPV6 58
-#endif
-
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/op_queue.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/op_queue.hpp
deleted file mode 100644
index db6335f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/op_queue.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//
-// detail/op_queue.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_OP_QUEUE_HPP
-#define ASIO_DETAIL_OP_QUEUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Operation>
-class op_queue;
-
-class op_queue_access
-{
-public:
-  template <typename Operation>
-  static Operation* next(Operation* o)
-  {
-    return static_cast<Operation*>(o->next_);
-  }
-
-  template <typename Operation1, typename Operation2>
-  static void next(Operation1*& o1, Operation2* o2)
-  {
-    o1->next_ = o2;
-  }
-
-  template <typename Operation>
-  static void destroy(Operation* o)
-  {
-    o->destroy();
-  }
-
-  template <typename Operation>
-  static Operation*& front(op_queue<Operation>& q)
-  {
-    return q.front_;
-  }
-
-  template <typename Operation>
-  static Operation*& back(op_queue<Operation>& q)
-  {
-    return q.back_;
-  }
-};
-
-template <typename Operation>
-class op_queue
-  : private noncopyable
-{
-public:
-  // Constructor.
-  op_queue()
-    : front_(0),
-      back_(0)
-  {
-  }
-
-  // Destructor destroys all operations.
-  ~op_queue()
-  {
-    while (Operation* op = front_)
-    {
-      pop();
-      op_queue_access::destroy(op);
-    }
-  }
-
-  // Get the operation at the front of the queue.
-  Operation* front()
-  {
-    return front_;
-  }
-
-  // Pop an operation from the front of the queue.
-  void pop()
-  {
-    if (front_)
-    {
-      Operation* tmp = front_;
-      front_ = op_queue_access::next(front_);
-      if (front_ == 0)
-        back_ = 0;
-      op_queue_access::next(tmp, static_cast<Operation*>(0));
-    }
-  }
-
-  // Push an operation on to the back of the queue.
-  void push(Operation* h)
-  {
-    op_queue_access::next(h, static_cast<Operation*>(0));
-    if (back_)
-    {
-      op_queue_access::next(back_, h);
-      back_ = h;
-    }
-    else
-    {
-      front_ = back_ = h;
-    }
-  }
-
-  // Push all operations from another queue on to the back of the queue. The
-  // source queue may contain operations of a derived type.
-  template <typename OtherOperation>
-  void push(op_queue<OtherOperation>& q)
-  {
-    if (Operation* other_front = op_queue_access::front(q))
-    {
-      if (back_)
-        op_queue_access::next(back_, other_front);
-      else
-        front_ = other_front;
-      back_ = op_queue_access::back(q);
-      op_queue_access::front(q) = 0;
-      op_queue_access::back(q) = 0;
-    }
-  }
-
-  // Whether the queue is empty.
-  bool empty() const
-  {
-    return front_ == 0;
-  }
-
-  // Test whether an operation is already enqueued.
-  bool is_enqueued(Operation* o) const
-  {
-    return op_queue_access::next(o) != 0 || back_ == o;
-  }
-
-private:
-  friend class op_queue_access;
-
-  // The front of the queue.
-  Operation* front_;
-
-  // The back of the queue.
-  Operation* back_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_OP_QUEUE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/operation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/operation.hpp
deleted file mode 100644
index 8721f39..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/operation.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// detail/operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_OPERATION_HPP
-#define ASIO_DETAIL_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_operation.hpp"
-#else
-# include "asio/detail/scheduler_operation.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_IOCP)
-typedef win_iocp_operation operation;
-#else
-typedef scheduler_operation operation;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_OPERATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pipe_select_interrupter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pipe_select_interrupter.hpp
deleted file mode 100644
index f7b2196..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pipe_select_interrupter.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// detail/pipe_select_interrupter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
-#define ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS)
-#if !defined(ASIO_WINDOWS_RUNTIME)
-#if !defined(__CYGWIN__)
-#if !defined(__SYMBIAN32__)
-#if !defined(ASIO_HAS_EVENTFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class pipe_select_interrupter
-{
-public:
-  // Constructor.
-  ASIO_DECL pipe_select_interrupter();
-
-  // Destructor.
-  ASIO_DECL ~pipe_select_interrupter();
-
-  // Recreate the interrupter's descriptors. Used after a fork.
-  ASIO_DECL void recreate();
-
-  // Interrupt the select call.
-  ASIO_DECL void interrupt();
-
-  // Reset the select interrupter. Returns true if the reset was successful.
-  ASIO_DECL bool reset();
-
-  // Get the read descriptor to be passed to select.
-  int read_descriptor() const
-  {
-    return read_descriptor_;
-  }
-
-private:
-  // Open the descriptors. Throws on error.
-  ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  ASIO_DECL void close_descriptors();
-
-  // The read end of a connection used to interrupt the select call. This file
-  // descriptor is passed to select such that when it is time to stop, a single
-  // byte will be written on the other end of the connection and this
-  // descriptor will become readable.
-  int read_descriptor_;
-
-  // The write end of a connection used to interrupt the select call. A single
-  // byte may be written to this to wake up the select which is waiting for the
-  // other end to become readable.
-  int write_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/pipe_select_interrupter.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_HAS_EVENTFD)
-#endif // !defined(__SYMBIAN32__)
-#endif // !defined(__CYGWIN__)
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-#endif // !defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pop_options.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pop_options.hpp
deleted file mode 100644
index 93cdb5a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/pop_options.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//
-// detail/pop_options.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// No header guard
-
-#if defined(__COMO__)
-
-// Comeau C++
-
-#elif defined(__DMC__)
-
-// Digital Mars C++
-
-#elif defined(__INTEL_COMPILER) || defined(__ICL) \
-  || defined(__ICC) || defined(__ECC)
-
-// Intel C++
-
-# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility pop
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-
-# pragma pop_macro ("emit")
-# pragma pop_macro ("signal")
-# pragma pop_macro ("slot")
-
-#elif defined(__clang__)
-
-// Clang
-
-# if defined(__OBJC__)
-#  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
-#   if defined(ASIO_OBJC_WORKAROUND)
-#    undef Protocol
-#    undef id
-#    undef ASIO_OBJC_WORKAROUND
-#   endif
-#  endif
-# endif
-
-# if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility pop
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
-
-# pragma GCC diagnostic pop
-
-# pragma pop_macro ("emit")
-# pragma pop_macro ("signal")
-# pragma pop_macro ("slot")
-
-#elif defined(__GNUC__)
-
-// GNU C++
-
-# if defined(__MINGW32__) || defined(__CYGWIN__)
-#  pragma pack (pop)
-# endif
-
-# if defined(__OBJC__)
-#  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
-#   if defined(ASIO_OBJC_WORKAROUND)
-#    undef Protocol
-#    undef id
-#    undef ASIO_OBJC_WORKAROUND
-#   endif
-#  endif
-# endif
-
-# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility pop
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-
-# pragma GCC diagnostic pop
-
-# pragma pop_macro ("emit")
-# pragma pop_macro ("signal")
-# pragma pop_macro ("slot")
-
-#elif defined(__KCC)
-
-// Kai C++
-
-#elif defined(__sgi)
-
-// SGI MIPSpro C++
-
-#elif defined(__DECCXX)
-
-// Compaq Tru64 Unix cxx
-
-#elif defined(__ghs)
-
-// Greenhills C++
-
-#elif defined(__BORLANDC__) && !defined(__clang__)
-
-// Borland C++
-
-# pragma option pop
-# pragma nopushoptwarn
-# pragma nopackwarning
-
-#elif defined(__MWERKS__)
-
-// Metrowerks CodeWarrior
-
-#elif defined(__SUNPRO_CC)
-
-// Sun Workshop Compiler C++
-
-#elif defined(__HP_aCC)
-
-// HP aCC
-
-#elif defined(__MRC__) || defined(__SC__)
-
-// MPW MrCpp or SCpp
-
-#elif defined(__IBMCPP__)
-
-// IBM Visual Age
-
-#elif defined(_MSC_VER)
-
-// Microsoft Visual C++
-//
-// Must remain the last #elif since some other vendors (Metrowerks, for example)
-// also #define _MSC_VER
-
-# pragma warning (pop)
-# pragma pack (pop)
-
-# if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-#  if defined(ASIO_CLR_WORKAROUND)
-#   undef generic
-#   undef ASIO_CLR_WORKAROUND
-#  endif
-# endif
-
-# pragma pop_macro ("emit")
-# pragma pop_macro ("signal")
-# pragma pop_macro ("slot")
-
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_event.hpp
deleted file mode 100644
index 0c83bd3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_event.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//
-// detail/posix_event.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_EVENT_HPP
-#define ASIO_DETAIL_POSIX_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <cstddef>
-#include <pthread.h>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class posix_event
-  : private noncopyable
-{
-public:
-  // Constructor.
-  ASIO_DECL posix_event();
-
-  // Destructor.
-  ~posix_event()
-  {
-    ::pthread_cond_destroy(&cond_);
-  }
-
-  // Signal the event. (Retained for backward compatibility.)
-  template <typename Lock>
-  void signal(Lock& lock)
-  {
-    this->signal_all(lock);
-  }
-
-  // Signal all waiters.
-  template <typename Lock>
-  void signal_all(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    state_ |= 1;
-    ::pthread_cond_broadcast(&cond_); // Ignore EINVAL.
-  }
-
-  // Unlock the mutex and signal one waiter.
-  template <typename Lock>
-  void unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    lock.unlock();
-    if (have_waiters)
-      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
-  }
-
-  // Unlock the mutex and signal one waiter who may destroy us.
-  template <typename Lock>
-  void unlock_and_signal_one_for_destruction(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    if (have_waiters)
-      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
-    lock.unlock();
-  }
-
-  // If there's a waiter, unlock the mutex and signal it.
-  template <typename Lock>
-  bool maybe_unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    if (state_ > 1)
-    {
-      lock.unlock();
-      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
-      return true;
-    }
-    return false;
-  }
-
-  // Reset the event.
-  template <typename Lock>
-  void clear(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    state_ &= ~std::size_t(1);
-  }
-
-  // Wait for the event to become signalled.
-  template <typename Lock>
-  void wait(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    while ((state_ & 1) == 0)
-    {
-      state_ += 2;
-      ::pthread_cond_wait(&cond_, &lock.mutex().mutex_); // Ignore EINVAL.
-      state_ -= 2;
-    }
-  }
-
-  // Timed wait for the event to become signalled.
-  template <typename Lock>
-  bool wait_for_usec(Lock& lock, long usec)
-  {
-    ASIO_ASSERT(lock.locked());
-    if ((state_ & 1) == 0)
-    {
-      state_ += 2;
-      timespec ts;
-#if (defined(__MACH__) && defined(__APPLE__)) \
-      || (defined(__ANDROID__) && (__ANDROID_API__ < 21) \
-          && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
-      ts.tv_sec = usec / 1000000;
-      ts.tv_nsec = (usec % 1000000) * 1000;
-      ::pthread_cond_timedwait_relative_np(
-          &cond_, &lock.mutex().mutex_, &ts); // Ignore EINVAL.
-#else // (defined(__MACH__) && defined(__APPLE__))
-      // || (defined(__ANDROID__) && (__ANDROID_API__ < 21)
-      //     && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
-      if (::clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
-      {
-        ts.tv_sec += usec / 1000000;
-        ts.tv_nsec += (usec % 1000000) * 1000;
-        ts.tv_sec += ts.tv_nsec / 1000000000;
-        ts.tv_nsec = ts.tv_nsec % 1000000000;
-        ::pthread_cond_timedwait(&cond_,
-            &lock.mutex().mutex_, &ts); // Ignore EINVAL.
-      }
-#endif // (defined(__MACH__) && defined(__APPLE__))
-       // || (defined(__ANDROID__) && (__ANDROID_API__ < 21)
-       //     && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE))
-      state_ -= 2;
-    }
-    return (state_ & 1) != 0;
-  }
-
-private:
-  ::pthread_cond_t cond_;
-  std::size_t state_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/posix_event.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_fd_set_adapter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_fd_set_adapter.hpp
deleted file mode 100644
index bd28a13..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_fd_set_adapter.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-//
-// detail/posix_fd_set_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP
-#define ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(__CYGWIN__) \
-  && !defined(ASIO_WINDOWS_RUNTIME)
-
-#include <cstring>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/reactor_op_queue.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
-class posix_fd_set_adapter : noncopyable
-{
-public:
-  posix_fd_set_adapter()
-    : max_descriptor_(invalid_socket)
-  {
-    using namespace std; // Needed for memset on Solaris.
-    FD_ZERO(&fd_set_);
-  }
-
-  void reset()
-  {
-    using namespace std; // Needed for memset on Solaris.
-    FD_ZERO(&fd_set_);
-  }
-
-  bool set(socket_type descriptor)
-  {
-    if (descriptor < (socket_type)FD_SETSIZE)
-    {
-      if (max_descriptor_ == invalid_socket || descriptor > max_descriptor_)
-        max_descriptor_ = descriptor;
-      FD_SET(descriptor, &fd_set_);
-      return true;
-    }
-    return false;
-  }
-
-  void set(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops)
-  {
-    reactor_op_queue<socket_type>::iterator i = operations.begin();
-    while (i != operations.end())
-    {
-      reactor_op_queue<socket_type>::iterator op_iter = i++;
-      if (!set(op_iter->first))
-      {
-        asio::error_code ec(error::fd_set_failure);
-        operations.cancel_operations(op_iter, ops, ec);
-      }
-    }
-  }
-
-  bool is_set(socket_type descriptor) const
-  {
-    return FD_ISSET(descriptor, &fd_set_) != 0;
-  }
-
-  operator fd_set*()
-  {
-    return &fd_set_;
-  }
-
-  socket_type max_descriptor() const
-  {
-    return max_descriptor_;
-  }
-
-  void perform(reactor_op_queue<socket_type>& operations,
-      op_queue<operation>& ops) const
-  {
-    reactor_op_queue<socket_type>::iterator i = operations.begin();
-    while (i != operations.end())
-    {
-      reactor_op_queue<socket_type>::iterator op_iter = i++;
-      if (is_set(op_iter->first))
-        operations.perform_operations(op_iter, ops);
-    }
-  }
-
-private:
-  mutable fd_set fd_set_;
-  socket_type max_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS)
-       // && !defined(__CYGWIN__)
-       // && !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_global.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_global.hpp
deleted file mode 100644
index aea71e1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_global.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// detail/posix_global.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_GLOBAL_HPP
-#define ASIO_DETAIL_POSIX_GLOBAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <exception>
-#include <pthread.h>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct posix_global_impl
-{
-  // Helper function to perform initialisation.
-  static void do_init()
-  {
-    instance_.static_ptr_ = instance_.ptr_ = new T;
-  }
-
-  // Destructor automatically cleans up the global.
-  ~posix_global_impl()
-  {
-    delete static_ptr_;
-  }
-
-  static ::pthread_once_t init_once_;
-  static T* static_ptr_;
-  static posix_global_impl instance_;
-  T* ptr_;
-};
-
-template <typename T>
-::pthread_once_t posix_global_impl<T>::init_once_ = PTHREAD_ONCE_INIT;
-
-template <typename T>
-T* posix_global_impl<T>::static_ptr_ = 0;
-
-template <typename T>
-posix_global_impl<T> posix_global_impl<T>::instance_;
-
-template <typename T>
-T& posix_global()
-{
-  int result = ::pthread_once(
-      &posix_global_impl<T>::init_once_,
-      &posix_global_impl<T>::do_init);
-
-  if (result != 0)
-    std::terminate();
-
-  return *posix_global_impl<T>::instance_.ptr_;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_GLOBAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_mutex.hpp
deleted file mode 100644
index 38ce286..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_mutex.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// detail/posix_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_MUTEX_HPP
-#define ASIO_DETAIL_POSIX_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <pthread.h>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class posix_event;
-
-class posix_mutex
-  : private noncopyable
-{
-public:
-  typedef asio::detail::scoped_lock<posix_mutex> scoped_lock;
-
-  // Constructor.
-  ASIO_DECL posix_mutex();
-
-  // Destructor.
-  ~posix_mutex()
-  {
-    ::pthread_mutex_destroy(&mutex_); // Ignore EBUSY.
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL.
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL.
-  }
-
-private:
-  friend class posix_event;
-  ::pthread_mutex_t mutex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/posix_mutex.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_serial_port_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_serial_port_service.hpp
deleted file mode 100644
index 7930954..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_serial_port_service.hpp
+++ /dev/null
@@ -1,249 +0,0 @@
-//
-// detail/posix_serial_port_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
-#define ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT)
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include <string>
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/serial_port_base.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_descriptor_service.hpp"
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/reactive_descriptor_service.hpp"
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Extend a descriptor_service to provide serial port support.
-class posix_serial_port_service :
-  public execution_context_service_base<posix_serial_port_service>
-{
-public:
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef io_uring_descriptor_service descriptor_service;
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef reactive_descriptor_service descriptor_service;
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-  // The native type of a serial port.
-  typedef descriptor_service::native_handle_type native_handle_type;
-
-  // The implementation type of the serial port.
-  typedef descriptor_service::implementation_type implementation_type;
-
-  ASIO_DECL posix_serial_port_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new serial port implementation.
-  void construct(implementation_type& impl)
-  {
-    descriptor_service_.construct(impl);
-  }
-
-  // Move-construct a new serial port implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another serial port implementation.
-  void move_assign(implementation_type& impl,
-      posix_serial_port_service& other_service,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_assign(impl,
-        other_service.descriptor_service_, other_impl);
-  }
-
-  // Destroy a serial port implementation.
-  void destroy(implementation_type& impl)
-  {
-    descriptor_service_.destroy(impl);
-  }
-
-  // Open the serial port using the specified device name.
-  ASIO_DECL asio::error_code open(implementation_type& impl,
-      const std::string& device, asio::error_code& ec);
-
-  // Assign a native descriptor to a serial port implementation.
-  asio::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.assign(impl, native_descriptor, ec);
-  }
-
-  // Determine whether the serial port is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return descriptor_service_.is_open(impl);
-  }
-
-  // Destroy a serial port implementation.
-  asio::error_code close(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.close(impl, ec);
-  }
-
-  // Get the native serial port representation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return descriptor_service_.native_handle(impl);
-  }
-
-  // Cancel all operations associated with the serial port.
-  asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return descriptor_service_.cancel(impl, ec);
-  }
-
-  // Set an option on the serial port.
-  template <typename SettableSerialPortOption>
-  asio::error_code set_option(implementation_type& impl,
-      const SettableSerialPortOption& option, asio::error_code& ec)
-  {
-    return do_set_option(impl,
-        &posix_serial_port_service::store_option<SettableSerialPortOption>,
-        &option, ec);
-  }
-
-  // Get an option from the serial port.
-  template <typename GettableSerialPortOption>
-  asio::error_code get_option(const implementation_type& impl,
-      GettableSerialPortOption& option, asio::error_code& ec) const
-  {
-    return do_get_option(impl,
-        &posix_serial_port_service::load_option<GettableSerialPortOption>,
-        &option, ec);
-  }
-
-  // Send a break sequence to the serial port.
-  asio::error_code send_break(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    int result = ::tcsendbreak(descriptor_service_.native_handle(impl), 0);
-    descriptor_ops::get_last_error(ec, result < 0);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Write the given data. Returns the number of bytes sent.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.write_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous write. The data being written must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_write_some(impl, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return descriptor_service_.read_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being received must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    descriptor_service_.async_read_some(impl, buffers, handler, io_ex);
-  }
-
-private:
-  // Function pointer type for storing a serial port option.
-  typedef asio::error_code (*store_function_type)(
-      const void*, termios&, asio::error_code&);
-
-  // Helper function template to store a serial port option.
-  template <typename SettableSerialPortOption>
-  static asio::error_code store_option(const void* option,
-      termios& storage, asio::error_code& ec)
-  {
-    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
-    return ec;
-  }
-
-  // Helper function to set a serial port option.
-  ASIO_DECL asio::error_code do_set_option(
-      implementation_type& impl, store_function_type store,
-      const void* option, asio::error_code& ec);
-
-  // Function pointer type for loading a serial port option.
-  typedef asio::error_code (*load_function_type)(
-      void*, const termios&, asio::error_code&);
-
-  // Helper function template to load a serial port option.
-  template <typename GettableSerialPortOption>
-  static asio::error_code load_option(void* option,
-      const termios& storage, asio::error_code& ec)
-  {
-    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
-    return ec;
-  }
-
-  // Helper function to get a serial port option.
-  ASIO_DECL asio::error_code do_get_option(
-      const implementation_type& impl, load_function_type load,
-      void* option, asio::error_code& ec) const;
-
-  // The implementation used for initiating asynchronous operations.
-  descriptor_service descriptor_service_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/posix_serial_port_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_POSIX_SERIAL_PORT_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_signal_blocker.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_signal_blocker.hpp
deleted file mode 100644
index a57c096..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_signal_blocker.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//
-// detail/posix_signal_blocker.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
-#define ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <csignal>
-#include <pthread.h>
-#include <signal.h>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class posix_signal_blocker
-  : private noncopyable
-{
-public:
-  // Constructor blocks all signals for the calling thread.
-  posix_signal_blocker()
-    : blocked_(false)
-  {
-    sigset_t new_mask;
-    sigfillset(&new_mask);
-    blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0);
-  }
-
-  // Destructor restores the previous signal mask.
-  ~posix_signal_blocker()
-  {
-    if (blocked_)
-      pthread_sigmask(SIG_SETMASK, &old_mask_, 0);
-  }
-
-  // Block all signals for the calling thread.
-  void block()
-  {
-    if (!blocked_)
-    {
-      sigset_t new_mask;
-      sigfillset(&new_mask);
-      blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0);
-    }
-  }
-
-  // Restore the previous signal mask.
-  void unblock()
-  {
-    if (blocked_)
-      blocked_ = (pthread_sigmask(SIG_SETMASK, &old_mask_, 0) != 0);
-  }
-
-private:
-  // Have signals been blocked.
-  bool blocked_;
-
-  // The previous signal mask.
-  sigset_t old_mask_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_static_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_static_mutex.hpp
deleted file mode 100644
index 38a44c0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_static_mutex.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// detail/posix_static_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
-#define ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <pthread.h>
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct posix_static_mutex
-{
-  typedef asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  void init()
-  {
-    // Nothing to do.
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL.
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL.
-  }
-
-  ::pthread_mutex_t mutex_;
-};
-
-#define ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_thread.hpp
deleted file mode 100644
index 9085a0b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_thread.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//
-// detail/posix_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_THREAD_HPP
-#define ASIO_DETAIL_POSIX_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <cstddef>
-#include <pthread.h>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-extern "C"
-{
-  ASIO_DECL void* asio_detail_posix_thread_function(void* arg);
-}
-
-class posix_thread
-  : private noncopyable
-{
-public:
-  // Constructor.
-  template <typename Function>
-  posix_thread(Function f, unsigned int = 0)
-    : joined_(false)
-  {
-    start_thread(new func<Function>(f));
-  }
-
-  // Destructor.
-  ASIO_DECL ~posix_thread();
-
-  // Wait for the thread to exit.
-  ASIO_DECL void join();
-
-  // Get number of CPUs.
-  ASIO_DECL static std::size_t hardware_concurrency();
-
-private:
-  friend void* asio_detail_posix_thread_function(void* arg);
-
-  class func_base
-  {
-  public:
-    virtual ~func_base() {}
-    virtual void run() = 0;
-  };
-
-  struct auto_func_base_ptr
-  {
-    func_base* ptr;
-    ~auto_func_base_ptr() { delete ptr; }
-  };
-
-  template <typename Function>
-  class func
-    : public func_base
-  {
-  public:
-    func(Function f)
-      : f_(f)
-    {
-    }
-
-    virtual void run()
-    {
-      f_();
-    }
-
-  private:
-    Function f_;
-  };
-
-  ASIO_DECL void start_thread(func_base* arg);
-
-  ::pthread_t thread_;
-  bool joined_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/posix_thread.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_tss_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_tss_ptr.hpp
deleted file mode 100644
index b0d0653..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/posix_tss_ptr.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//
-// detail/posix_tss_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_POSIX_TSS_PTR_HPP
-#define ASIO_DETAIL_POSIX_TSS_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PTHREADS)
-
-#include <pthread.h>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper function to create thread-specific storage.
-ASIO_DECL void posix_tss_ptr_create(pthread_key_t& key);
-
-template <typename T>
-class posix_tss_ptr
-  : private noncopyable
-{
-public:
-  // Constructor.
-  posix_tss_ptr()
-  {
-    posix_tss_ptr_create(tss_key_);
-  }
-
-  // Destructor.
-  ~posix_tss_ptr()
-  {
-    ::pthread_key_delete(tss_key_);
-  }
-
-  // Get the value.
-  operator T*() const
-  {
-    return static_cast<T*>(::pthread_getspecific(tss_key_));
-  }
-
-  // Set the value.
-  void operator=(T* value)
-  {
-    ::pthread_setspecific(tss_key_, value);
-  }
-
-private:
-  // Thread-specific storage to allow unlocked access to determine whether a
-  // thread is a member of the pool.
-  pthread_key_t tss_key_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/posix_tss_ptr.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_PTHREADS)
-
-#endif // ASIO_DETAIL_POSIX_TSS_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/push_options.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/push_options.hpp
deleted file mode 100644
index d270e9a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/push_options.hpp
+++ /dev/null
@@ -1,228 +0,0 @@
-//
-// detail/push_options.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// No header guard
-
-#if defined(__COMO__)
-
-// Comeau C++
-
-#elif defined(__DMC__)
-
-// Digital Mars C++
-
-#elif defined(__INTEL_COMPILER) || defined(__ICL) \
-  || defined(__ICC) || defined(__ECC)
-
-// Intel C++
-
-# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility push (default)
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-
-# pragma push_macro ("emit")
-# undef emit
-
-# pragma push_macro ("signal")
-# undef signal
-
-# pragma push_macro ("slot")
-# undef slot
-
-#elif defined(__clang__)
-
-// Clang
-
-# if defined(__OBJC__)
-#  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
-#   if !defined(ASIO_DISABLE_OBJC_WORKAROUND)
-#    if !defined(Protocol) && !defined(id)
-#     define Protocol cpp_Protocol
-#     define id cpp_id
-#     define ASIO_OBJC_WORKAROUND
-#    endif
-#   endif
-#  endif
-# endif
-
-# if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility push (default)
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
-
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-# if (__clang_major__ >= 6)
-#  pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
-# endif // (__clang_major__ >= 6)
-
-# pragma push_macro ("emit")
-# undef emit
-
-# pragma push_macro ("signal")
-# undef signal
-
-# pragma push_macro ("slot")
-# undef slot
-
-#elif defined(__GNUC__)
-
-// GNU C++
-
-# if defined(__MINGW32__) || defined(__CYGWIN__)
-#  pragma pack (push, 8)
-# endif
-
-# if defined(__OBJC__)
-#  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
-#   if !defined(ASIO_DISABLE_OBJC_WORKAROUND)
-#    if !defined(Protocol) && !defined(id)
-#     define Protocol cpp_Protocol
-#     define id cpp_id
-#     define ASIO_OBJC_WORKAROUND
-#    endif
-#   endif
-#  endif
-# endif
-
-# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-#  if !defined(ASIO_DISABLE_VISIBILITY)
-#   pragma GCC visibility push (default)
-#  endif // !defined(ASIO_DISABLE_VISIBILITY)
-# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
-
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
-# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || (__GNUC__ > 4)
-#  pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
-# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) || (__GNUC__ > 4)
-# if (__GNUC__ >= 7)
-#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
-# endif // (__GNUC__ >= 7)
-
-# pragma push_macro ("emit")
-# undef emit
-
-# pragma push_macro ("signal")
-# undef signal
-
-# pragma push_macro ("slot")
-# undef slot
-
-#elif defined(__KCC)
-
-// Kai C++
-
-#elif defined(__sgi)
-
-// SGI MIPSpro C++
-
-#elif defined(__DECCXX)
-
-// Compaq Tru64 Unix cxx
-
-#elif defined(__ghs)
-
-// Greenhills C++
-
-#elif defined(__BORLANDC__) && !defined(__clang__)
-
-// Borland C++
-
-# pragma option push -a8 -b -Ve- -Vx- -w-inl -vi-
-# pragma nopushoptwarn
-# pragma nopackwarning
-# if !defined(__MT__)
-#  error Multithreaded RTL must be selected.
-# endif // !defined(__MT__)
-
-#elif defined(__MWERKS__)
-
-// Metrowerks CodeWarrior
-
-#elif defined(__SUNPRO_CC)
-
-// Sun Workshop Compiler C++
-
-#elif defined(__HP_aCC)
-
-// HP aCC
-
-#elif defined(__MRC__) || defined(__SC__)
-
-// MPW MrCpp or SCpp
-
-#elif defined(__IBMCPP__)
-
-// IBM Visual Age
-
-#elif defined(_MSC_VER)
-
-// Microsoft Visual C++
-//
-// Must remain the last #elif since some other vendors (Metrowerks, for example)
-// also #define _MSC_VER
-# pragma warning (disable:4103)
-# pragma warning (push)
-# pragma warning (disable:4619) // suppress 'there is no warning number XXXX'
-# pragma warning (disable:4127)
-# pragma warning (disable:4180)
-# pragma warning (disable:4244)
-# pragma warning (disable:4265)
-# pragma warning (disable:4355)
-# pragma warning (disable:4510)
-# pragma warning (disable:4512)
-# pragma warning (disable:4610)
-# pragma warning (disable:4675)
-# if (_MSC_VER < 1600)
-// Visual Studio 2008 generates spurious warnings about unused parameters.
-#  pragma warning (disable:4100)
-# endif // (_MSC_VER < 1600)
-# if defined(_M_IX86) && defined(_Wp64)
-// The /Wp64 option is broken. If you want to check 64 bit portability, use a
-// 64 bit compiler!
-#  pragma warning (disable:4311)
-#  pragma warning (disable:4312)
-# endif // defined(_M_IX86) && defined(_Wp64)
-# pragma pack (push, 8)
-// Note that if the /Og optimisation flag is enabled with MSVC6, the compiler
-// has a tendency to incorrectly optimise away some calls to member template
-// functions, even though those functions contain code that should not be
-// optimised away! Therefore we will always disable this optimisation option
-// for the MSVC6 compiler.
-# if (_MSC_VER < 1300)
-#  pragma optimize ("g", off)
-# endif
-# if !defined(_MT)
-#  error Multithreaded RTL must be selected.
-# endif // !defined(_MT)
-
-# if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-#  if !defined(ASIO_DISABLE_CLR_WORKAROUND)
-#   if !defined(generic)
-#    define generic cpp_generic
-#    define ASIO_CLR_WORKAROUND
-#   endif
-#  endif
-# endif
-
-# pragma push_macro ("emit")
-# undef emit
-
-# pragma push_macro ("signal")
-# undef signal
-
-# pragma push_macro ("slot")
-# undef slot
-
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_descriptor_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_descriptor_service.hpp
deleted file mode 100644
index 0a03178..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_descriptor_service.hpp
+++ /dev/null
@@ -1,570 +0,0 @@
-//
-// detail/reactive_descriptor_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
-#define ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__) \
-  && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/buffer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/descriptor_read_op.hpp"
-#include "asio/detail/descriptor_write_op.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/reactive_null_buffers_op.hpp"
-#include "asio/detail/reactive_wait_op.hpp"
-#include "asio/detail/reactor.hpp"
-#include "asio/posix/descriptor_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class reactive_descriptor_service :
-  public execution_context_service_base<reactive_descriptor_service>
-{
-public:
-  // The native type of a descriptor.
-  typedef int native_handle_type;
-
-  // The implementation type of the descriptor.
-  class implementation_type
-    : private asio::detail::noncopyable
-  {
-  public:
-    // Default constructor.
-    implementation_type()
-      : descriptor_(-1),
-        state_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class reactive_descriptor_service;
-
-    // The native descriptor representation.
-    int descriptor_;
-
-    // The current state of the descriptor.
-    descriptor_ops::state_type state_;
-
-    // Per-descriptor data used by the reactor.
-    reactor::per_descriptor_data reactor_data_;
-  };
-
-  // Constructor.
-  ASIO_DECL reactive_descriptor_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new descriptor implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Move-construct a new descriptor implementation.
-  ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept;
-
-  // Move-assign from another descriptor implementation.
-  ASIO_DECL void move_assign(implementation_type& impl,
-      reactive_descriptor_service& other_service,
-      implementation_type& other_impl);
-
-  // Destroy a descriptor implementation.
-  ASIO_DECL void destroy(implementation_type& impl);
-
-  // Assign a native descriptor to a descriptor implementation.
-  ASIO_DECL asio::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      asio::error_code& ec);
-
-  // Determine whether the descriptor is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return impl.descriptor_ != -1;
-  }
-
-  // Destroy a descriptor implementation.
-  ASIO_DECL asio::error_code close(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Get the native descriptor representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return impl.descriptor_;
-  }
-
-  // Release ownership of the native descriptor representation.
-  ASIO_DECL native_handle_type release(implementation_type& impl);
-
-  // Release ownership of the native descriptor representation.
-  native_handle_type release(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    ec = success_ec_;
-    return release(impl);
-  }
-
-  // Cancel all operations associated with the descriptor.
-  ASIO_DECL asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Perform an IO control command on the descriptor.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(implementation_type& impl,
-      IO_Control_Command& command, asio::error_code& ec)
-  {
-    descriptor_ops::ioctl(impl.descriptor_, impl.state_,
-        command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the descriptor.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the descriptor.
-  asio::error_code non_blocking(implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    descriptor_ops::set_user_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native descriptor implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native descriptor implementation.
-  asio::error_code native_non_blocking(implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    descriptor_ops::set_internal_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Wait for the descriptor to become ready to read, ready to write, or to have
-  // pending error conditions.
-  asio::error_code wait(implementation_type& impl,
-      posix::descriptor_base::wait_type w, asio::error_code& ec)
-  {
-    switch (w)
-    {
-    case posix::descriptor_base::wait_read:
-      descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
-      break;
-    case posix::descriptor_base::wait_write:
-      descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
-      break;
-    case posix::descriptor_base::wait_error:
-      descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
-      break;
-    default:
-      ec = asio::error::invalid_argument;
-      break;
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Asynchronously wait for the descriptor to become ready to read, ready to
-  // write, or to have pending error conditions.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(implementation_type& impl,
-      posix::descriptor_base::wait_type w,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_wait_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
-          &impl, impl.descriptor_, "async_wait"));
-
-    int op_type;
-    switch (w)
-    {
-    case posix::descriptor_base::wait_read:
-      op_type = reactor::read_op;
-      break;
-    case posix::descriptor_base::wait_write:
-      op_type = reactor::write_op;
-      break;
-    case posix::descriptor_base::wait_error:
-      op_type = reactor::except_op;
-      break;
-    default:
-      p.p->ec_ = asio::error::invalid_argument;
-      start_op(impl, reactor::read_op, p.p,
-          is_continuation, false, true, false, &io_ex, 0);
-      p.v = p.p = 0;
-      return;
-    }
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.descriptor_, op_type);
-    }
-
-    start_op(impl, op_type, p.p, is_continuation,
-        false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Write some data to the descriptor.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = descriptor_ops::sync_write1(impl.descriptor_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      n = descriptor_ops::sync_write(impl.descriptor_, impl.state_,
-          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be written without blocking.
-  size_t write_some(implementation_type& impl,
-      const null_buffers&, asio::error_code& ec)
-  {
-    // Wait for descriptor to become ready.
-    descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous write. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef descriptor_write_op<ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_,
-            impl.descriptor_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
-          &impl, impl.descriptor_, "async_write_some"));
-
-    start_op(impl, reactor::write_op, p.p, is_continuation, true,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::all_empty(buffers), true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be written without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_,
-            impl.descriptor_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
-          &impl, impl.descriptor_, "async_write_some(null_buffers)"));
-
-    start_op(impl, reactor::write_op, p.p,
-        is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Read some data from the stream. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = descriptor_ops::sync_read1(impl.descriptor_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-
-      n = descriptor_ops::sync_read(impl.descriptor_, impl.state_,
-          bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be read without blocking.
-  size_t read_some(implementation_type& impl,
-      const null_buffers&, asio::error_code& ec)
-  {
-    // Wait for descriptor to become ready.
-    descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef descriptor_read_op<MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_,
-            impl.descriptor_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
-          &impl, impl.descriptor_, "async_read_some"));
-
-    start_op(impl, reactor::read_op, p.p, is_continuation, true,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::all_empty(buffers), true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be read without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const null_buffers&, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_,
-            impl.descriptor_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "descriptor",
-          &impl, impl.descriptor_, "async_read_some(null_buffers)"));
-
-    start_op(impl, reactor::read_op, p.p,
-        is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Start the asynchronous operation.
-  ASIO_DECL void do_start_op(implementation_type& impl,
-      int op_type, reactor_op* op, bool is_continuation,
-      bool allow_speculative, bool noop, bool needs_non_blocking,
-      void (*on_immediate)(operation* op, bool, const void*),
-      const void* immediate_arg);
-
-  // Start the asynchronous operation for handlers that are specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_op(implementation_type& impl, int op_type, Op* op,
-      bool is_continuation, bool allow_speculative, bool noop,
-      bool needs_non_blocking, const void* io_ex, ...)
-  {
-    return do_start_op(impl, op_type, op, is_continuation, allow_speculative,
-        noop, needs_non_blocking, &Op::do_immediate, io_ex);
-  }
-
-  // Start the asynchronous operation for handlers that are not specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_op(implementation_type& impl, int op_type,
-      Op* op, bool is_continuation, bool allow_speculative,
-      bool noop, bool needs_non_blocking, const void*,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            typename Op::handler_type,
-            typename Op::io_executor_type
-          >::asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    return do_start_op(impl, op_type, op, is_continuation,
-        allow_speculative, noop, needs_non_blocking,
-        &reactor::call_post_immediate_completion, &reactor_);
-  }
-
-  // Helper class used to implement per-operation cancellation
-  class reactor_op_cancellation
-  {
-  public:
-    reactor_op_cancellation(reactor* r,
-        reactor::per_descriptor_data* p, int d, int o)
-      : reactor_(r),
-        reactor_data_(p),
-        descriptor_(d),
-        op_type_(o)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        reactor_->cancel_ops_by_key(descriptor_,
-            *reactor_data_, op_type_, this);
-      }
-    }
-
-  private:
-    reactor* reactor_;
-    reactor::per_descriptor_data* reactor_data_;
-    int descriptor_;
-    int op_type_;
-  };
-
-  // The selector that performs event demultiplexing for the service.
-  reactor& reactor_;
-
-  // Cached success value to avoid accessing category singleton.
-  const asio::error_code success_ec_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/reactive_descriptor_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-       //   && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_null_buffers_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_null_buffers_op.hpp
deleted file mode 100644
index b9a32a9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_null_buffers_op.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//
-// detail/reactive_null_buffers_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
-#define ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class reactive_null_buffers_op : public reactor_op
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_null_buffers_op);
-
-  reactive_null_buffers_op(const asio::error_code& success_ec,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactor_op(success_ec, &reactive_null_buffers_op::do_perform,
-        &reactive_null_buffers_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static status do_perform(reactor_op*)
-  {
-    return done;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_accept_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_accept_op.hpp
deleted file mode 100644
index 5ae84fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_accept_op.hpp
+++ /dev/null
@@ -1,323 +0,0 @@
-//
-// detail/reactive_socket_accept_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Socket, typename Protocol>
-class reactive_socket_accept_op_base : public reactor_op
-{
-public:
-  reactive_socket_accept_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state, Socket& peer,
-      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
-      func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_accept_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      peer_(peer),
-      protocol_(protocol),
-      peer_endpoint_(peer_endpoint),
-      addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    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;
-  }
-
-  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();
-    }
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  socket_holder new_socket_;
-  Socket& peer_;
-  Protocol protocol_;
-  typename Protocol::endpoint* peer_endpoint_;
-  std::size_t addrlen_;
-};
-
-template <typename Socket, typename Protocol,
-    typename Handler, typename IoExecutor>
-class reactive_socket_accept_op :
-  public reactive_socket_accept_op_base<Socket, Protocol>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_accept_op);
-
-  reactive_socket_accept_op(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state, Socket& peer,
-      const Protocol& protocol, typename Protocol::endpoint* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_accept_op_base<Socket, Protocol>(
-        success_ec, socket, state, peer, protocol, peer_endpoint,
-        &reactive_socket_accept_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    if (owner)
-      o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-template <typename Protocol, typename PeerIoExecutor,
-    typename Handler, typename IoExecutor>
-class reactive_socket_move_accept_op :
-  private Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
-  public reactive_socket_accept_op_base<
-    typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other,
-    Protocol>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_move_accept_op);
-
-  reactive_socket_move_accept_op(const asio::error_code& success_ec,
-      const PeerIoExecutor& peer_io_ex, socket_type socket,
-      socket_ops::state_type state, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, Handler& handler,
-      const IoExecutor& io_ex)
-    : peer_socket_type(peer_io_ex),
-      reactive_socket_accept_op_base<peer_socket_type, Protocol>(
-        success_ec, socket, state, *this, protocol, peer_endpoint,
-        &reactive_socket_move_accept_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_move_accept_op* o(
-        static_cast<reactive_socket_move_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    if (owner)
-      o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::move_binder2<Handler,
-      asio::error_code, peer_socket_type>
-        handler(0, static_cast<Handler&&>(o->handler_), o->ec_,
-          static_cast<peer_socket_type&&>(*o));
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_move_accept_op* o(
-        static_cast<reactive_socket_move_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    // On success, assign new connection to peer socket object.
-    o->do_assign();
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::move_binder2<Handler,
-      asio::error_code, peer_socket_type>
-        handler(0, static_cast<Handler&&>(o->handler_), o->ec_,
-          static_cast<peer_socket_type&&>(*o));
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  typedef typename Protocol::socket::template
-    rebind_executor<PeerIoExecutor>::other peer_socket_type;
-
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_connect_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_connect_op.hpp
deleted file mode 100644
index 03c0db2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_connect_op.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//
-// detail/reactive_socket_connect_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class reactive_socket_connect_op_base : public reactor_op
-{
-public:
-  reactive_socket_connect_op_base(const asio::error_code& success_ec,
-      socket_type socket, func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_connect_op_base::do_perform, complete_func),
-      socket_(socket)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_connect_op_base* o(
-        static_cast<reactive_socket_connect_op_base*>(base));
-
-    status result = socket_ops::non_blocking_connect(
-        o->socket_, o->ec_) ? done : not_done;
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_connect", o->ec_));
-
-    return result;
-  }
-
-private:
-  socket_type socket_;
-};
-
-template <typename Handler, typename IoExecutor>
-class reactive_socket_connect_op : public reactive_socket_connect_op_base
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_connect_op);
-
-  reactive_socket_connect_op(const asio::error_code& success_ec,
-      socket_type socket, Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_connect_op_base(success_ec, socket,
-        &reactive_socket_connect_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_connect_op* o
-      (static_cast<reactive_socket_connect_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_connect_op* o
-      (static_cast<reactive_socket_connect_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recv_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recv_op.hpp
deleted file mode 100644
index b653365..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recv_op.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-//
-// detail/reactive_socket_recv_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class reactive_socket_recv_op_base : public reactor_op
-{
-public:
-  reactive_socket_recv_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_recv_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      flags_(flags)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recv_op_base* o(
-        static_cast<reactive_socket_recv_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = socket_ops::non_blocking_recv1(o->socket_,
-          bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(), o->flags_,
-          (o->state_ & socket_ops::stream_oriented) != 0,
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      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;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags flags_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class reactive_socket_recv_op :
-  public reactive_socket_recv_op_base<MutableBufferSequence>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_recv_op);
-
-  reactive_socket_recv_op(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_recv_op_base<MutableBufferSequence>(success_ec, socket,
-        state, buffers, flags, &reactive_socket_recv_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvfrom_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvfrom_op.hpp
deleted file mode 100644
index b84ea61..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvfrom_op.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-//
-// detail/reactive_socket_recvfrom_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Endpoint>
-class reactive_socket_recvfrom_op_base : public reactor_op
-{
-public:
-  reactive_socket_recvfrom_op_base(const asio::error_code& success_ec,
-      socket_type socket, int protocol_type,
-      const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags, func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_recvfrom_op_base::do_perform, complete_func),
-      socket_(socket),
-      protocol_type_(protocol_type),
-      buffers_(buffers),
-      sender_endpoint_(endpoint),
-      flags_(flags)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvfrom_op_base* o(
-        static_cast<reactive_socket_recvfrom_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    std::size_t addr_len = o->sender_endpoint_.capacity();
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = socket_ops::non_blocking_recvfrom1(
-          o->socket_, bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(), o->flags_,
-          o->sender_endpoint_.data(), &addr_len,
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      result = socket_ops::non_blocking_recvfrom(o->socket_,
-          bufs.buffers(), bufs.count(), o->flags_,
-          o->sender_endpoint_.data(), &addr_len,
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-
-    if (result && !o->ec_)
-      o->sender_endpoint_.resize(addr_len);
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recvfrom",
-          o->ec_, o->bytes_transferred_));
-
-    return result;
-  }
-
-private:
-  socket_type socket_;
-  int protocol_type_;
-  MutableBufferSequence buffers_;
-  Endpoint& sender_endpoint_;
-  socket_base::message_flags flags_;
-};
-
-template <typename MutableBufferSequence, typename Endpoint,
-    typename Handler, typename IoExecutor>
-class reactive_socket_recvfrom_op :
-  public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvfrom_op);
-
-  reactive_socket_recvfrom_op(const asio::error_code& success_ec,
-      socket_type socket, int protocol_type,
-      const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags, Handler& handler,
-      const IoExecutor& io_ex)
-    : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
-        success_ec, socket, protocol_type, buffers, endpoint, flags,
-        &reactive_socket_recvfrom_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvfrom_op* o(
-        static_cast<reactive_socket_recvfrom_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvfrom_op* o(
-        static_cast<reactive_socket_recvfrom_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvmsg_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvmsg_op.hpp
deleted file mode 100644
index e4c8117..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_recvmsg_op.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-//
-// detail/reactive_socket_recvmsg_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/socket_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class reactive_socket_recvmsg_op_base : public reactor_op
-{
-public:
-  reactive_socket_recvmsg_op_base(const asio::error_code& success_ec,
-      socket_type socket, const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_recvmsg_op_base::do_perform, complete_func),
-      socket_(socket),
-      buffers_(buffers),
-      in_flags_(in_flags),
-      out_flags_(out_flags)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvmsg_op_base* o(
-        static_cast<reactive_socket_recvmsg_op_base*>(base));
-
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(o->buffers_);
-
-    status result = socket_ops::non_blocking_recvmsg(o->socket_,
-        bufs.buffers(), bufs.count(),
-        o->in_flags_, o->out_flags_,
-        o->ec_, o->bytes_transferred_) ? done : not_done;
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_recvmsg",
-          o->ec_, o->bytes_transferred_));
-
-    return result;
-  }
-
-private:
-  socket_type socket_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags in_flags_;
-  socket_base::message_flags& out_flags_;
-};
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class reactive_socket_recvmsg_op :
-  public reactive_socket_recvmsg_op_base<MutableBufferSequence>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvmsg_op);
-
-  reactive_socket_recvmsg_op(const asio::error_code& success_ec,
-      socket_type socket, const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-    : reactive_socket_recvmsg_op_base<MutableBufferSequence>(
-        success_ec, socket, buffers, in_flags, out_flags,
-        &reactive_socket_recvmsg_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvmsg_op* o(
-        static_cast<reactive_socket_recvmsg_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_recvmsg_op* o(
-        static_cast<reactive_socket_recvmsg_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_send_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_send_op.hpp
deleted file mode 100644
index 1b83a34..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_send_op.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-//
-// detail/reactive_socket_send_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class reactive_socket_send_op_base : public reactor_op
-{
-public:
-  reactive_socket_send_op_base(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_send_op_base::do_perform, complete_func),
-      socket_(socket),
-      state_(state),
-      buffers_(buffers),
-      flags_(flags)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_send_op_base* o(
-        static_cast<reactive_socket_send_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = socket_ops::non_blocking_send1(o->socket_,
-          bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(), 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_type::first(o->buffers_).size())
-            result = done_and_exhausted;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      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;
-  }
-
-private:
-  socket_type socket_;
-  socket_ops::state_type state_;
-  ConstBufferSequence buffers_;
-  socket_base::message_flags flags_;
-};
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class reactive_socket_send_op :
-  public reactive_socket_send_op_base<ConstBufferSequence>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_send_op);
-
-  reactive_socket_send_op(const asio::error_code& success_ec,
-      socket_type socket, socket_ops::state_type state,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_send_op_base<ConstBufferSequence>(success_ec, socket,
-        state, buffers, flags, &reactive_socket_send_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_sendto_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_sendto_op.hpp
deleted file mode 100644
index e1bbb70..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_sendto_op.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//
-// detail/reactive_socket_sendto_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence, typename Endpoint>
-class reactive_socket_sendto_op_base : public reactor_op
-{
-public:
-  reactive_socket_sendto_op_base(const asio::error_code& success_ec,
-      socket_type socket, const ConstBufferSequence& buffers,
-      const Endpoint& endpoint, socket_base::message_flags flags,
-      func_type complete_func)
-    : reactor_op(success_ec,
-        &reactive_socket_sendto_op_base::do_perform, complete_func),
-      socket_(socket),
-      buffers_(buffers),
-      destination_(endpoint),
-      flags_(flags)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    reactive_socket_sendto_op_base* o(
-        static_cast<reactive_socket_sendto_op_base*>(base));
-
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    status result;
-    if (bufs_type::is_single_buffer)
-    {
-      result = socket_ops::non_blocking_sendto1(o->socket_,
-          bufs_type::first(o->buffers_).data(),
-          bufs_type::first(o->buffers_).size(), o->flags_,
-          o->destination_.data(), o->destination_.size(),
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-    else
-    {
-      bufs_type bufs(o->buffers_);
-      result = socket_ops::non_blocking_sendto(o->socket_,
-          bufs.buffers(), bufs.count(), o->flags_,
-          o->destination_.data(), o->destination_.size(),
-          o->ec_, o->bytes_transferred_) ? done : not_done;
-    }
-
-    ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_sendto",
-          o->ec_, o->bytes_transferred_));
-
-    return result;
-  }
-
-private:
-  socket_type socket_;
-  ConstBufferSequence buffers_;
-  Endpoint destination_;
-  socket_base::message_flags flags_;
-};
-
-template <typename ConstBufferSequence, typename Endpoint,
-    typename Handler, typename IoExecutor>
-class reactive_socket_sendto_op :
-  public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_socket_sendto_op);
-
-  reactive_socket_sendto_op(const asio::error_code& success_ec,
-      socket_type socket, const ConstBufferSequence& buffers,
-      const Endpoint& endpoint, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(
-        success_ec, socket, buffers, endpoint, flags,
-        &reactive_socket_sendto_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(o->ec_);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service.hpp
deleted file mode 100644
index 6b7963e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service.hpp
+++ /dev/null
@@ -1,633 +0,0 @@
-//
-// detail/reactive_socket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_IOCP) \
-  && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/buffer.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/reactive_null_buffers_op.hpp"
-#include "asio/detail/reactive_socket_accept_op.hpp"
-#include "asio/detail/reactive_socket_connect_op.hpp"
-#include "asio/detail/reactive_socket_recvfrom_op.hpp"
-#include "asio/detail/reactive_socket_sendto_op.hpp"
-#include "asio/detail/reactive_socket_service_base.hpp"
-#include "asio/detail/reactor.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class reactive_socket_service :
-  public execution_context_service_base<reactive_socket_service<Protocol>>,
-  public reactive_socket_service_base
-{
-public:
-  // The protocol type.
-  typedef Protocol protocol_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The native type of a socket.
-  typedef socket_type native_handle_type;
-
-  // The implementation type of the socket.
-  struct implementation_type :
-    reactive_socket_service_base::base_implementation_type
-  {
-    // Default constructor.
-    implementation_type()
-      : protocol_(endpoint_type().protocol())
-    {
-    }
-
-    // The protocol associated with the socket.
-    protocol_type protocol_;
-  };
-
-  // Constructor.
-  reactive_socket_service(execution_context& context)
-    : execution_context_service_base<
-        reactive_socket_service<Protocol>>(context),
-      reactive_socket_service_base(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    this->base_shutdown();
-  }
-
-  // Move-construct a new socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type& impl,
-      reactive_socket_service_base& other_service,
-      implementation_type& other_impl)
-  {
-    this->base_move_assign(impl, other_service, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-construct a new socket implementation from another protocol type.
-  template <typename Protocol1>
-  void converting_move_construct(implementation_type& impl,
-      reactive_socket_service<Protocol1>&,
-      typename reactive_socket_service<
-        Protocol1>::implementation_type& other_impl)
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = protocol_type(other_impl.protocol_);
-    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
-  }
-
-  // Open a new socket implementation.
-  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;
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Assign a native socket to a socket implementation.
-  asio::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      asio::error_code& ec)
-  {
-    if (!do_assign(impl, protocol.type(), native_socket, ec))
-      impl.protocol_ = protocol;
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the native socket representation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return impl.socket_;
-  }
-
-  // Bind the socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
-      const endpoint_type& endpoint, asio::error_code& ec)
-  {
-    socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  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);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code get_option(const implementation_type& impl,
-      Option& option, asio::error_code& ec) const
-  {
-    std::size_t size = option.size(impl.protocol_);
-    socket_ops::getsockopt(impl.socket_, impl.state_,
-        option.level(impl.protocol_), option.name(impl.protocol_),
-        option.data(impl.protocol_), &size, ec);
-    if (!ec)
-      option.resize(impl.protocol_, size);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getpeername(impl.socket_,
-          endpoint.data(), &addr_len, false, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(base_implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
-  {
-    socket_ops::shutdown(impl.socket_, what, ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Send a datagram to the specified endpoint. Returns the number of bytes
-  // sent.
-  template <typename ConstBufferSequence>
-  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = socket_ops::sync_sendto1(impl.socket_, impl.state_,
-          bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags,
-          destination.data(), destination.size(), ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      n = socket_ops::sync_sendto(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags,
-          destination.data(), destination.size(), ec);
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_sendto_op<ConstBufferSequence,
-        endpoint_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        buffers, destination, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_send_to"));
-
-    start_op(impl, reactor::write_op, p.p,
-        is_continuation, true, false, true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_send_to(null_buffers)"));
-
-    start_op(impl, reactor::write_op, p.p,
-        is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Receive a datagram with the endpoint of the sender. Returns the number of
-  // bytes received.
-  template <typename MutableBufferSequence>
-  size_t receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    std::size_t addr_len = sender_endpoint.capacity();
-    std::size_t n;
-    if (bufs_type::is_single_buffer)
-    {
-      n = socket_ops::sync_recvfrom1(impl.socket_, impl.state_,
-          bufs_type::first(buffers).data(), bufs_type::first(buffers).size(),
-          flags, sender_endpoint.data(), &addr_len, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      n = socket_ops::sync_recvfrom(impl.socket_, impl.state_, bufs.buffers(),
-          bufs.count(), flags, sender_endpoint.data(), &addr_len, ec);
-    }
-
-    if (!ec)
-      sender_endpoint.resize(addr_len);
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_from(implementation_type& impl, const null_buffers&,
-      endpoint_type& sender_endpoint, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received and
-  // the sender_endpoint object must both be valid for the lifetime of the
-  // asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_recvfrom_op<MutableBufferSequence,
-        endpoint_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    int protocol = impl.protocol_.type();
-    p.p = new (p.v) op(success_ec_, impl.socket_, protocol,
-        buffers, sender_endpoint, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_from"));
-
-    start_op(impl,
-        (flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, true, false, true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl, const null_buffers&,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_from(null_buffers)"));
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    start_op(impl,
-        (flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Accept a new connection.
-  template <typename Socket>
-  asio::error_code accept(implementation_type& impl,
-      Socket& peer, endpoint_type* peer_endpoint, asio::error_code& ec)
-  {
-    // We cannot accept a socket that is already open.
-    if (peer.is_open())
-    {
-      ec = asio::error::already_open;
-      ASIO_ERROR_LOCATION(ec);
-      return ec;
-    }
-
-    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
-    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
-          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
-          peer_endpoint ? &addr_len : 0, ec));
-
-    // On success, assign new connection to peer socket object.
-    if (new_socket.get() != invalid_socket)
-    {
-      if (peer_endpoint)
-        peer_endpoint->resize(addr_len);
-      peer.assign(impl.protocol_, new_socket.get(), ec);
-      if (!ec)
-        new_socket.release();
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Start an asynchronous accept. The peer and peer_endpoint objects must be
-  // valid until the accept's handler is invoked.
-  template <typename Socket, typename Handler, typename IoExecutor>
-  void async_accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_,
-        peer, impl.protocol_, peer_endpoint, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected() && !peer.is_open())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_accept"));
-
-    start_accept_op(impl, p.p, is_continuation, peer.is_open(), &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous accept. The peer_endpoint object must be valid until
-  // the accept's handler is invoked.
-  template <typename PeerIoExecutor, typename Handler, typename IoExecutor>
-  void async_move_accept(implementation_type& impl,
-      const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_move_accept_op<Protocol,
-        PeerIoExecutor, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, peer_io_ex, impl.socket_,
-        impl.state_, impl.protocol_, peer_endpoint, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_accept"));
-
-    start_accept_op(impl, p.p, is_continuation, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Connect the socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    socket_ops::sync_connect(impl.socket_,
-        peer_endpoint.data(), peer_endpoint.size(), ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Start an asynchronous connect.
-  template <typename Handler, typename IoExecutor>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_connect_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::connect_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_connect"));
-
-    start_connect_op(impl, p.p, is_continuation,
-        peer_endpoint.data(), peer_endpoint.size(), &io_ex, 0);
-    p.v = p.p = 0;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_IOCP)
-       //   && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service_base.hpp
deleted file mode 100644
index ab1f5fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_socket_service_base.hpp
+++ /dev/null
@@ -1,755 +0,0 @@
-//
-// detail/reactive_socket_service_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
-#define ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_IOCP) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/buffer.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactive_null_buffers_op.hpp"
-#include "asio/detail/reactive_socket_recv_op.hpp"
-#include "asio/detail/reactive_socket_recvmsg_op.hpp"
-#include "asio/detail/reactive_socket_send_op.hpp"
-#include "asio/detail/reactive_wait_op.hpp"
-#include "asio/detail/reactor.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class reactive_socket_service_base
-{
-public:
-  // The native type of a socket.
-  typedef socket_type native_handle_type;
-
-  // The implementation type of the socket.
-  struct base_implementation_type
-  {
-    // The native socket representation.
-    socket_type socket_;
-
-    // The current state of the socket.
-    socket_ops::state_type state_;
-
-    // Per-descriptor data used by the reactor.
-    reactor::per_descriptor_data reactor_data_;
-  };
-
-  // Constructor.
-  ASIO_DECL reactive_socket_service_base(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void base_shutdown();
-
-  // Construct a new socket implementation.
-  ASIO_DECL void construct(base_implementation_type& impl);
-
-  // Move-construct a new socket implementation.
-  ASIO_DECL void base_move_construct(base_implementation_type& impl,
-      base_implementation_type& other_impl) noexcept;
-
-  // Move-assign from another socket implementation.
-  ASIO_DECL void base_move_assign(base_implementation_type& impl,
-      reactive_socket_service_base& other_service,
-      base_implementation_type& other_impl);
-
-  // Destroy a socket implementation.
-  ASIO_DECL void destroy(base_implementation_type& impl);
-
-  // Determine whether the socket is open.
-  bool is_open(const base_implementation_type& impl) const
-  {
-    return impl.socket_ != invalid_socket;
-  }
-
-  // Destroy a socket implementation.
-  ASIO_DECL asio::error_code close(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Release ownership of the socket.
-  ASIO_DECL socket_type release(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Get the native socket representation.
-  native_handle_type native_handle(base_implementation_type& impl)
-  {
-    return impl.socket_;
-  }
-
-  // Cancel all operations associated with the socket.
-  ASIO_DECL asio::error_code cancel(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::sockatmark(impl.socket_, ec);
-  }
-
-  // Determine the number of bytes available for reading.
-  std::size_t available(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::available(impl.socket_, ec);
-  }
-
-  // Place the socket into the state where it will listen for new connections.
-  asio::error_code listen(base_implementation_type& impl,
-      int backlog, asio::error_code& ec)
-  {
-    socket_ops::listen(impl.socket_, backlog, ec);
-    return ec;
-  }
-
-  // Perform an IO control command on the socket.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(base_implementation_type& impl,
-      IO_Control_Command& command, asio::error_code& ec)
-  {
-    socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
-        static_cast<ioctl_arg_type*>(command.data()), ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Wait for the socket to become ready to read, ready to write, or to have
-  // pending error conditions.
-  asio::error_code wait(base_implementation_type& impl,
-      socket_base::wait_type w, asio::error_code& ec)
-  {
-    switch (w)
-    {
-    case socket_base::wait_read:
-      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_write:
-      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_error:
-      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
-      break;
-    default:
-      ec = asio::error::invalid_argument;
-      break;
-    }
-
-    return ec;
-  }
-
-  // Asynchronously wait for the socket to become ready to read, ready to
-  // write, or to have pending error conditions.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(base_implementation_type& impl,
-      socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_wait_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_wait"));
-
-    int op_type;
-    switch (w)
-    {
-    case socket_base::wait_read:
-      op_type = reactor::read_op;
-      break;
-    case socket_base::wait_write:
-      op_type = reactor::write_op;
-      break;
-    case socket_base::wait_error:
-      op_type = reactor::except_op;
-      break;
-    default:
-      p.p->ec_ = asio::error::invalid_argument;
-      start_op(impl, reactor::read_op, p.p,
-          is_continuation, false, true, false, &io_ex, 0);
-      p.v = p.p = 0;
-      return;
-    }
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, op_type);
-    }
-
-    start_op(impl, op_type, p.p, is_continuation,
-        false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  size_t send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs_type;
-
-    if (bufs_type::is_single_buffer)
-    {
-      return socket_ops::sync_send1(impl.socket_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      return socket_ops::sync_send(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
-    }
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_send_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        impl.state_, buffers, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_send"));
-
-    start_op(impl, reactor::write_op, p.p, is_continuation, true,
-        ((impl.state_ & socket_ops::stream_oriented)
-          && buffer_sequence_adapter<asio::const_buffer,
-            ConstBufferSequence>::all_empty(buffers)), true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::write_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_send(null_buffers)"));
-
-    start_op(impl, reactor::write_op, p.p,
-        is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Receive some data from the peer. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    typedef buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs_type;
-
-    if (bufs_type::is_single_buffer)
-    {
-      return socket_ops::sync_recv1(impl.socket_,
-          impl.state_, bufs_type::first(buffers).data(),
-          bufs_type::first(buffers).size(), flags, ec);
-    }
-    else
-    {
-      bufs_type bufs(buffers);
-      return socket_ops::sync_recv(impl.socket_, impl.state_,
-          bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
-    }
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_recv_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        impl.state_, buffers, flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive"));
-
-    start_op(impl,
-        (flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation,
-        (flags & socket_base::message_out_of_band) == 0,
-        ((impl.state_ & socket_ops::stream_oriented)
-          && buffer_sequence_adapter<asio::mutable_buffer,
-            MutableBufferSequence>::all_empty(buffers)), true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive(null_buffers)"));
-
-    start_op(impl,
-        (flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  size_t receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
-        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_recvmsg_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, impl.socket_,
-        buffers, in_flags, out_flags, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_with_flags"));
-
-    start_op(impl,
-        (in_flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation,
-        (in_flags & socket_base::message_out_of_band) == 0,
-        false, true, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(success_ec_, handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<reactor_op_cancellation>(
-            &reactor_, &impl.reactor_data_, impl.socket_, reactor::read_op);
-    }
-
-    ASIO_HANDLER_CREATION((reactor_.context(), *p.p, "socket",
-          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    start_op(impl,
-        (in_flags & socket_base::message_out_of_band)
-          ? reactor::except_op : reactor::read_op,
-        p.p, is_continuation, false, false, false, &io_ex, 0);
-    p.v = p.p = 0;
-  }
-
-protected:
-  // Open a new socket implementation.
-  ASIO_DECL asio::error_code do_open(
-      base_implementation_type& impl, int af,
-      int type, int protocol, asio::error_code& ec);
-
-  // Assign a native socket to a socket implementation.
-  ASIO_DECL asio::error_code do_assign(
-      base_implementation_type& impl, int type,
-      const native_handle_type& native_socket, asio::error_code& ec);
-
-  // Start the asynchronous read or write operation.
-  ASIO_DECL void do_start_op(base_implementation_type& impl,
-      int op_type, reactor_op* op, bool is_continuation,
-      bool allow_speculative, bool noop, bool needs_non_blocking,
-      void (*on_immediate)(operation* op, bool, const void*),
-      const void* immediate_arg);
-
-  // Start the asynchronous operation for handlers that are specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_op(base_implementation_type& impl, int op_type, Op* op,
-      bool is_continuation, bool allow_speculative, bool noop,
-      bool needs_non_blocking, const void* io_ex, ...)
-  {
-    return do_start_op(impl, op_type, op, is_continuation, allow_speculative,
-        noop, needs_non_blocking, &Op::do_immediate, io_ex);
-  }
-
-  // Start the asynchronous operation for handlers that are not specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_op(base_implementation_type& impl, int op_type,
-      Op* op, bool is_continuation, bool allow_speculative,
-      bool noop, bool needs_non_blocking, const void*,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            typename Op::handler_type,
-            typename Op::io_executor_type
-          >::asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    return do_start_op(impl, op_type, op, is_continuation,
-        allow_speculative, noop, needs_non_blocking,
-        &reactor::call_post_immediate_completion, &reactor_);
-  }
-
-  // Start the asynchronous accept operation.
-  ASIO_DECL void do_start_accept_op(base_implementation_type& impl,
-      reactor_op* op, bool is_continuation, bool peer_is_open,
-      void (*on_immediate)(operation* op, bool, const void*),
-      const void* immediate_arg);
-
-  // Start the asynchronous accept operation for handlers that are specialised
-  // for immediate completion.
-  template <typename Op>
-  void start_accept_op(base_implementation_type& impl, Op* op,
-      bool is_continuation, bool peer_is_open, const void* io_ex, ...)
-  {
-    return do_start_accept_op(impl, op, is_continuation,
-        peer_is_open, &Op::do_immediate, io_ex);
-  }
-
-  // Start the asynchronous operation for handlers that are not specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_accept_op(base_implementation_type& impl, Op* op,
-      bool is_continuation, bool peer_is_open, const void*,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            typename Op::handler_type,
-            typename Op::io_executor_type
-          >::asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    return do_start_accept_op(impl, op, is_continuation, peer_is_open,
-        &reactor::call_post_immediate_completion, &reactor_);
-  }
-
-  // Start the asynchronous connect operation.
-  ASIO_DECL void do_start_connect_op(base_implementation_type& impl,
-      reactor_op* op, bool is_continuation, const void* addr, size_t addrlen,
-      void (*on_immediate)(operation* op, bool, const void*),
-      const void* immediate_arg);
-
-  // Start the asynchronous operation for handlers that are specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_connect_op(base_implementation_type& impl,
-      Op* op, bool is_continuation, const void* addr,
-      size_t addrlen, const void* io_ex, ...)
-  {
-    return do_start_connect_op(impl, op, is_continuation,
-        addr, addrlen, &Op::do_immediate, io_ex);
-  }
-
-  // Start the asynchronous operation for handlers that are not specialised for
-  // immediate completion.
-  template <typename Op>
-  void start_connect_op(base_implementation_type& impl, Op* op,
-      bool is_continuation, const void* addr, size_t addrlen, const void*,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            typename Op::handler_type,
-            typename Op::io_executor_type
-          >::asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    return do_start_connect_op(impl, op, is_continuation, addr,
-        addrlen, &reactor::call_post_immediate_completion, &reactor_);
-  }
-
-  // Helper class used to implement per-operation cancellation
-  class reactor_op_cancellation
-  {
-  public:
-    reactor_op_cancellation(reactor* r,
-        reactor::per_descriptor_data* p, socket_type d, int o)
-      : reactor_(r),
-        reactor_data_(p),
-        descriptor_(d),
-        op_type_(o)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        reactor_->cancel_ops_by_key(descriptor_,
-            *reactor_data_, op_type_, this);
-      }
-    }
-
-  private:
-    reactor* reactor_;
-    reactor::per_descriptor_data* reactor_data_;
-    socket_type descriptor_;
-    int op_type_;
-  };
-
-  // The selector that performs event demultiplexing for the service.
-  reactor& reactor_;
-
-  // Cached success value to avoid accessing category singleton.
-  const asio::error_code success_ec_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/reactive_socket_service_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_HAS_IOCP)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#endif // ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_wait_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_wait_op.hpp
deleted file mode 100644
index 62938e2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactive_wait_op.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//
-// detail/reactive_wait_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
-#define ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class reactive_wait_op : public reactor_op
-{
-public:
-  typedef Handler handler_type;
-  typedef IoExecutor io_executor_type;
-
-  ASIO_DEFINE_HANDLER_PTR(reactive_wait_op);
-
-  reactive_wait_op(const asio::error_code& success_ec,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactor_op(success_ec, &reactive_wait_op::do_perform,
-        &reactive_wait_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static status do_perform(reactor_op*)
-  {
-    return done;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_wait_op* o(static_cast<reactive_wait_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-  static void do_immediate(operation* base, bool, const void* io_ex)
-  {
-    // Take ownership of the handler object.
-    ASIO_ASSUME(base != 0);
-    reactive_wait_op* o(static_cast<reactive_wait_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    immediate_handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-    w.complete(handler, handler.handler_, io_ex);
-    ASIO_HANDLER_INVOCATION_END;
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTIVE_WAIT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor.hpp
deleted file mode 100644
index 054acfd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// detail/reactor.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTOR_HPP
-#define ASIO_DETAIL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/null_reactor.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/null_reactor.hpp"
-#elif defined(ASIO_HAS_EPOLL)
-# include "asio/detail/epoll_reactor.hpp"
-#elif defined(ASIO_HAS_KQUEUE)
-# include "asio/detail/kqueue_reactor.hpp"
-#elif defined(ASIO_HAS_DEV_POLL)
-# include "asio/detail/dev_poll_reactor.hpp"
-#else
-# include "asio/detail/select_reactor.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_IOCP) || defined(ASIO_WINDOWS_RUNTIME)
-typedef null_reactor reactor;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-typedef null_reactor reactor;
-#elif defined(ASIO_HAS_EPOLL)
-typedef epoll_reactor reactor;
-#elif defined(ASIO_HAS_KQUEUE)
-typedef kqueue_reactor reactor;
-#elif defined(ASIO_HAS_DEV_POLL)
-typedef dev_poll_reactor reactor;
-#else
-typedef select_reactor reactor;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op.hpp
deleted file mode 100644
index 54d6cd9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// detail/reactor_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTOR_OP_HPP
-#define ASIO_DETAIL_REACTOR_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class reactor_op
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-  // The operation key used for targeted cancellation.
-  void* cancellation_key_;
-
-  // The number of bytes transferred, to be passed to the completion handler.
-  std::size_t bytes_transferred_;
-
-  // Status returned by perform function. May be used to decide whether it is
-  // worth performing more operations on the descriptor immediately.
-  enum status { not_done, done, done_and_exhausted };
-
-  // Perform the operation. Returns true if it is finished.
-  status perform()
-  {
-    return perform_func_(this);
-  }
-
-protected:
-  typedef status (*perform_func_type)(reactor_op*);
-
-  reactor_op(const asio::error_code& success_ec,
-      perform_func_type perform_func, func_type complete_func)
-    : operation(complete_func),
-      ec_(success_ec),
-      cancellation_key_(0),
-      bytes_transferred_(0),
-      perform_func_(perform_func)
-  {
-  }
-
-private:
-  perform_func_type perform_func_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTOR_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op_queue.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op_queue.hpp
deleted file mode 100644
index fae1a52..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/reactor_op_queue.hpp
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// detail/reactor_op_queue.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
-#define ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/hash_map.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Descriptor>
-class reactor_op_queue
-  : private noncopyable
-{
-public:
-  typedef Descriptor key_type;
-
-  struct mapped_type : op_queue<reactor_op>
-  {
-    mapped_type() {}
-    mapped_type(const mapped_type&) {}
-    void operator=(const mapped_type&) {}
-  };
-
-  typedef typename hash_map<key_type, mapped_type>::value_type value_type;
-  typedef typename hash_map<key_type, mapped_type>::iterator iterator;
-
-  // Constructor.
-  reactor_op_queue()
-    : operations_()
-  {
-  }
-
-  // Obtain iterators to all registered descriptors.
-  iterator begin() { return operations_.begin(); }
-  iterator end() { return operations_.end(); }
-
-  // Add a new operation to the queue. Returns true if this is the only
-  // operation for the given descriptor, in which case the reactor's event
-  // demultiplexing function call may need to be interrupted and restarted.
-  bool enqueue_operation(Descriptor descriptor, reactor_op* op)
-  {
-    std::pair<iterator, bool> entry =
-      operations_.insert(value_type(descriptor, mapped_type()));
-    entry.first->second.push(op);
-    return entry.second;
-  }
-
-  // Cancel all operations associated with the descriptor identified by the
-  // supplied iterator. Any operations pending for the descriptor will be
-  // cancelled. Returns true if any operations were cancelled, in which case
-  // the reactor's event demultiplexing function may need to be interrupted and
-  // restarted.
-  bool cancel_operations(iterator i, op_queue<operation>& ops,
-      const asio::error_code& ec =
-        asio::error::operation_aborted)
-  {
-    if (i != operations_.end())
-    {
-      while (reactor_op* op = i->second.front())
-      {
-        op->ec_ = ec;
-        i->second.pop();
-        ops.push(op);
-      }
-      operations_.erase(i);
-      return true;
-    }
-
-    return false;
-  }
-
-  // Cancel all operations associated with the descriptor. Any operations
-  // pending for the descriptor will be cancelled. Returns true if any
-  // operations were cancelled, in which case the reactor's event
-  // demultiplexing function may need to be interrupted and restarted.
-  bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops,
-      const asio::error_code& ec =
-        asio::error::operation_aborted)
-  {
-    return this->cancel_operations(operations_.find(descriptor), ops, ec);
-  }
-
-  // Cancel operations associated with the descriptor identified by the
-  // supplied iterator, and the specified cancellation key. Any operations
-  // pending for the descriptor with the key will be cancelled. Returns true if
-  // any operations were cancelled, in which case the reactor's event
-  // demultiplexing function may need to be interrupted and restarted.
-  bool cancel_operations_by_key(iterator i, op_queue<operation>& ops,
-      void* cancellation_key, const asio::error_code& ec =
-        asio::error::operation_aborted)
-  {
-    bool result = false;
-    if (i != operations_.end())
-    {
-      op_queue<reactor_op> other_ops;
-      while (reactor_op* op = i->second.front())
-      {
-        i->second.pop();
-        if (op->cancellation_key_ == cancellation_key)
-        {
-          op->ec_ = ec;
-          ops.push(op);
-          result = true;
-        }
-        else
-          other_ops.push(op);
-      }
-      i->second.push(other_ops);
-      if (i->second.empty())
-        operations_.erase(i);
-    }
-    return result;
-  }
-
-  // Cancel all operations associated with the descriptor. Any operations
-  // pending for the descriptor will be cancelled. Returns true if any
-  // operations were cancelled, in which case the reactor's event
-  // demultiplexing function may need to be interrupted and restarted.
-  bool cancel_operations_by_key(Descriptor descriptor, op_queue<operation>& ops,
-      void* cancellation_key, const asio::error_code& ec =
-        asio::error::operation_aborted)
-  {
-    return this->cancel_operations_by_key(
-        operations_.find(descriptor), ops, cancellation_key, ec);
-  }
-
-  // Whether there are no operations in the queue.
-  bool empty() const
-  {
-    return operations_.empty();
-  }
-
-  // Determine whether there are any operations associated with the descriptor.
-  bool has_operation(Descriptor descriptor) const
-  {
-    return operations_.find(descriptor) != operations_.end();
-  }
-
-  // Perform the operations corresponding to the descriptor identified by the
-  // supplied iterator. Returns true if there are still unfinished operations
-  // queued for the descriptor.
-  bool perform_operations(iterator i, op_queue<operation>& ops)
-  {
-    if (i != operations_.end())
-    {
-      while (reactor_op* op = i->second.front())
-      {
-        if (op->perform())
-        {
-          i->second.pop();
-          ops.push(op);
-        }
-        else
-        {
-          return true;
-        }
-      }
-      operations_.erase(i);
-    }
-    return false;
-  }
-
-  // Perform the operations corresponding to the descriptor. Returns true if
-  // there are still unfinished operations queued for the descriptor.
-  bool perform_operations(Descriptor descriptor, op_queue<operation>& ops)
-  {
-    return this->perform_operations(operations_.find(descriptor), ops);
-  }
-
-  // Get all operations owned by the queue.
-  void get_all_operations(op_queue<operation>& ops)
-  {
-    iterator i = operations_.begin();
-    while (i != operations_.end())
-    {
-      iterator op_iter = i++;
-      ops.push(op_iter->second);
-      operations_.erase(op_iter);
-    }
-  }
-
-private:
-  // The operations that are currently executing asynchronously.
-  hash_map<key_type, mapped_type> operations_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/recycling_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/recycling_allocator.hpp
deleted file mode 100644
index 3396625..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/recycling_allocator.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//
-// detail/recycling_allocator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
-#define ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/thread_context.hpp"
-#include "asio/detail/thread_info_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T, typename Purpose = thread_info_base::default_tag>
-class recycling_allocator
-{
-public:
-  typedef T value_type;
-
-  template <typename U>
-  struct rebind
-  {
-    typedef recycling_allocator<U, Purpose> other;
-  };
-
-  recycling_allocator()
-  {
-  }
-
-  template <typename U>
-  recycling_allocator(const recycling_allocator<U, Purpose>&)
-  {
-  }
-
-  T* allocate(std::size_t n)
-  {
-#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-    void* p = thread_info_base::allocate(Purpose(),
-        thread_context::top_of_thread_call_stack(),
-        sizeof(T) * n, alignof(T));
-#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-    void* p = asio::aligned_new(align, s);
-#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-    return static_cast<T*>(p);
-  }
-
-  void deallocate(T* p, std::size_t n)
-  {
-#if !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-    thread_info_base::deallocate(Purpose(),
-        thread_context::top_of_thread_call_stack(), p, sizeof(T) * n);
-#else // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-    (void)n;
-    asio::aligned_delete(p);
-#endif // !defined(ASIO_DISABLE_SMALL_BLOCK_RECYCLING)
-  }
-};
-
-template <typename Purpose>
-class recycling_allocator<void, Purpose>
-{
-public:
-  typedef void value_type;
-
-  template <typename U>
-  struct rebind
-  {
-    typedef recycling_allocator<U, Purpose> other;
-  };
-
-  recycling_allocator()
-  {
-  }
-
-  template <typename U>
-  recycling_allocator(const recycling_allocator<U, Purpose>&)
-  {
-  }
-};
-
-template <typename Allocator, typename Purpose>
-struct get_recycling_allocator
-{
-  typedef Allocator type;
-  static type get(const Allocator& a) { return a; }
-};
-
-template <typename T, typename Purpose>
-struct get_recycling_allocator<std::allocator<T>, Purpose>
-{
-  typedef recycling_allocator<T, Purpose> type;
-  static type get(const std::allocator<T>&) { return type(); }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/regex_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/regex_fwd.hpp
deleted file mode 100644
index a5c6c0a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/regex_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// detail/regex_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_REGEX_FWD_HPP
-#define ASIO_DETAIL_REGEX_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-namespace boost {
-
-template <class BidiIterator>
-struct sub_match;
-
-template <class BidiIterator, class Allocator>
-class match_results;
-
-template <class CharT, class Traits>
-class basic_regex;
-
-} // namespace boost
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-#endif // ASIO_DETAIL_REGEX_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_endpoint_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_endpoint_op.hpp
deleted file mode 100644
index fdde585..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_endpoint_op.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//
-// detail/resolve_endpoint_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
-#define ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/resolve_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol, typename Handler, typename IoExecutor>
-class resolve_endpoint_op : public resolve_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(resolve_endpoint_op);
-
-  typedef typename Protocol::endpoint endpoint_type;
-  typedef asio::ip::basic_resolver_results<Protocol> results_type;
-
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-
-  resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
-      const endpoint_type& endpoint, scheduler_impl& sched,
-      Handler& handler, const IoExecutor& io_ex)
-    : resolve_op(&resolve_endpoint_op::do_complete),
-      cancel_token_(cancel_token),
-      endpoint_(endpoint),
-      scheduler_(sched),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner && owner != &o->scheduler_)
-    {
-      // The operation is being run on the worker io_context. Time to perform
-      // the resolver operation.
-
-      // Perform the blocking endpoint resolution operation.
-      char host_name[NI_MAXHOST] = "";
-      char service_name[NI_MAXSERV] = "";
-      socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
-          o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
-          o->endpoint_.protocol().type(), o->ec_);
-      o->results_ = results_type::create(o->endpoint_, host_name, service_name);
-
-      // Pass operation back to main io_context for completion.
-      o->scheduler_.post_deferred_completion(o);
-      p.v = p.p = 0;
-    }
-    else
-    {
-      // The operation has been returned to the main io_context. The completion
-      // handler is ready to be delivered.
-
-      ASIO_HANDLER_COMPLETION((*o));
-
-      // Take ownership of the operation's outstanding work.
-      handler_work<Handler, IoExecutor> w(
-          static_cast<handler_work<Handler, IoExecutor>&&>(
-            o->work_));
-
-      // Make a copy of the handler so that the memory can be deallocated
-      // before the upcall is made. Even if we're not about to make an upcall,
-      // a sub-object of the handler may be the true owner of the memory
-      // associated with the handler. Consequently, a local copy of the handler
-      // is required to ensure that any owning sub-object remains valid until
-      // after we have deallocated the memory here.
-      detail::binder2<Handler, asio::error_code, results_type>
-        handler(o->handler_, o->ec_, o->results_);
-      p.h = asio::detail::addressof(handler.handler_);
-      p.reset();
-
-      if (owner)
-      {
-        fenced_block b(fenced_block::half);
-        ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-        w.complete(handler, handler.handler_);
-        ASIO_HANDLER_INVOCATION_END;
-      }
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  endpoint_type endpoint_;
-  scheduler_impl& scheduler_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-  results_type results_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_op.hpp
deleted file mode 100644
index 5b41ad2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_op.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// detail/resolve_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RESOLVE_OP_HPP
-#define ASIO_DETAIL_RESOLVE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/error.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class resolve_op : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-protected:
-  resolve_op(func_type complete_func)
-    : operation(complete_func)
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_RESOLVE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_query_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_query_op.hpp
deleted file mode 100644
index fc70a5b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolve_query_op.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//
-// detail/resolve_query_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
-#define ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/resolve_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol, typename Handler, typename IoExecutor>
-class resolve_query_op : public resolve_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(resolve_query_op);
-
-  typedef asio::ip::basic_resolver_query<Protocol> query_type;
-  typedef asio::ip::basic_resolver_results<Protocol> results_type;
-
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-
-  resolve_query_op(socket_ops::weak_cancel_token_type cancel_token,
-      const query_type& qry, scheduler_impl& sched,
-      Handler& handler, const IoExecutor& io_ex)
-    : resolve_op(&resolve_query_op::do_complete),
-      cancel_token_(cancel_token),
-      query_(qry),
-      scheduler_(sched),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex),
-      addrinfo_(0)
-  {
-  }
-
-  ~resolve_query_op()
-  {
-    if (addrinfo_)
-      socket_ops::freeaddrinfo(addrinfo_);
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    resolve_query_op* o(static_cast<resolve_query_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner && owner != &o->scheduler_)
-    {
-      // The operation is being run on the worker io_context. Time to perform
-      // the resolver operation.
-
-      // Perform the blocking host resolution operation.
-      socket_ops::background_getaddrinfo(o->cancel_token_,
-          o->query_.host_name().c_str(), o->query_.service_name().c_str(),
-          o->query_.hints(), &o->addrinfo_, o->ec_);
-
-      // Pass operation back to main io_context for completion.
-      o->scheduler_.post_deferred_completion(o);
-      p.v = p.p = 0;
-    }
-    else
-    {
-      // The operation has been returned to the main io_context. The completion
-      // handler is ready to be delivered.
-
-      ASIO_HANDLER_COMPLETION((*o));
-
-      // Take ownership of the operation's outstanding work.
-      handler_work<Handler, IoExecutor> w(
-          static_cast<handler_work<Handler, IoExecutor>&&>(
-            o->work_));
-
-      // Make a copy of the handler so that the memory can be deallocated
-      // before the upcall is made. Even if we're not about to make an upcall,
-      // a sub-object of the handler may be the true owner of the memory
-      // associated with the handler. Consequently, a local copy of the handler
-      // is required to ensure that any owning sub-object remains valid until
-      // after we have deallocated the memory here.
-      detail::binder2<Handler, asio::error_code, results_type>
-        handler(o->handler_, o->ec_, results_type());
-      p.h = asio::detail::addressof(handler.handler_);
-      if (o->addrinfo_)
-      {
-        handler.arg2_ = results_type::create(o->addrinfo_,
-            o->query_.host_name(), o->query_.service_name());
-      }
-      p.reset();
-
-      if (owner)
-      {
-        fenced_block b(fenced_block::half);
-        ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-        w.complete(handler, handler.handler_);
-        ASIO_HANDLER_INVOCATION_END;
-      }
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  query_type query_;
-  scheduler_impl& scheduler_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-  asio::detail::addrinfo_type* addrinfo_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_RESOLVE_QUERY_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service.hpp
deleted file mode 100644
index 2d1fe22..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// detail/resolver_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RESOLVER_SERVICE_HPP
-#define ASIO_DETAIL_RESOLVER_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-#include "asio/detail/concurrency_hint.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/resolve_endpoint_op.hpp"
-#include "asio/detail/resolve_query_op.hpp"
-#include "asio/detail/resolver_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class resolver_service :
-  public execution_context_service_base<resolver_service<Protocol>>,
-  public resolver_service_base
-{
-public:
-  // The implementation type of the resolver. A cancellation token is used to
-  // indicate to the background thread that the operation has been cancelled.
-  typedef socket_ops::shared_cancel_token_type implementation_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The query type.
-  typedef asio::ip::basic_resolver_query<Protocol> query_type;
-
-  // The results type.
-  typedef asio::ip::basic_resolver_results<Protocol> results_type;
-
-  // Constructor.
-  resolver_service(execution_context& context)
-    : execution_context_service_base<resolver_service<Protocol>>(context),
-      resolver_service_base(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    this->base_shutdown();
-  }
-
-  // Perform any fork-related housekeeping.
-  void notify_fork(execution_context::fork_event fork_ev)
-  {
-    this->base_notify_fork(fork_ev);
-  }
-
-  // Resolve a query to a list of entries.
-  results_type resolve(implementation_type&, const query_type& qry,
-      asio::error_code& ec)
-  {
-    asio::detail::addrinfo_type* address_info = 0;
-
-    socket_ops::getaddrinfo(qry.host_name().c_str(),
-        qry.service_name().c_str(), qry.hints(), &address_info, ec);
-    auto_addrinfo auto_address_info(address_info);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec ? results_type() : results_type::create(
-        address_info, qry.host_name(), qry.service_name());
-  }
-
-  // Asynchronously resolve a query to a list of entries.
-  template <typename Handler, typename IoExecutor>
-  void async_resolve(implementation_type& impl, const query_type& qry,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef resolve_query_op<Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl, qry, scheduler_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "resolver", &impl, 0, "async_resolve"));
-
-    start_resolve_op(p.p);
-    p.v = p.p = 0;
-  }
-
-  // Resolve an endpoint to a list of entries.
-  results_type resolve(implementation_type&,
-      const endpoint_type& endpoint, asio::error_code& ec)
-  {
-    char host_name[NI_MAXHOST];
-    char service_name[NI_MAXSERV];
-    socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
-        host_name, NI_MAXHOST, service_name, NI_MAXSERV,
-        endpoint.protocol().type(), ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec ? results_type() : results_type::create(
-        endpoint, host_name, service_name);
-  }
-
-  // Asynchronously resolve an endpoint to a list of entries.
-  template <typename Handler, typename IoExecutor>
-  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef resolve_endpoint_op<Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl, endpoint, scheduler_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "resolver", &impl, 0, "async_resolve"));
-
-    start_resolve_op(p.p);
-    p.v = p.p = 0;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_RESOLVER_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service_base.hpp
deleted file mode 100644
index 160793c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/resolver_service_base.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//
-// detail/resolver_service_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
-#define ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/resolve_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/thread.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class resolver_service_base
-{
-public:
-  // The implementation type of the resolver. A cancellation token is used to
-  // indicate to the background thread that the operation has been cancelled.
-  typedef socket_ops::shared_cancel_token_type implementation_type;
-
-  // Constructor.
-  ASIO_DECL resolver_service_base(execution_context& context);
-
-  // Destructor.
-  ASIO_DECL ~resolver_service_base();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void base_shutdown();
-
-  // Perform any fork-related housekeeping.
-  ASIO_DECL void base_notify_fork(
-      execution_context::fork_event fork_ev);
-
-  // Construct a new resolver implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Destroy a resolver implementation.
-  ASIO_DECL void destroy(implementation_type&);
-
-  // Move-construct a new resolver implementation.
-  ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another resolver implementation.
-  ASIO_DECL void move_assign(implementation_type& impl,
-      resolver_service_base& other_service,
-      implementation_type& other_impl);
-
-  // Move-construct a new timer implementation.
-  void converting_move_construct(implementation_type& impl,
-      resolver_service_base&, implementation_type& other_impl)
-  {
-    move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another timer implementation.
-  void converting_move_assign(implementation_type& impl,
-      resolver_service_base& other_service,
-      implementation_type& other_impl)
-  {
-    move_assign(impl, other_service, other_impl);
-  }
-
-  // Cancel pending asynchronous operations.
-  ASIO_DECL void cancel(implementation_type& impl);
-
-protected:
-  // Helper function to start an asynchronous resolve operation.
-  ASIO_DECL void start_resolve_op(resolve_op* op);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-  // Helper class to perform exception-safe cleanup of addrinfo objects.
-  class auto_addrinfo
-    : private asio::detail::noncopyable
-  {
-  public:
-    explicit auto_addrinfo(asio::detail::addrinfo_type* ai)
-      : ai_(ai)
-    {
-    }
-
-    ~auto_addrinfo()
-    {
-      if (ai_)
-        socket_ops::freeaddrinfo(ai_);
-    }
-
-    operator asio::detail::addrinfo_type*()
-    {
-      return ai_;
-    }
-
-  private:
-    asio::detail::addrinfo_type* ai_;
-  };
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-  // Helper class to run the work scheduler in a thread.
-  class work_scheduler_runner;
-
-  // Start the work scheduler if it's not already running.
-  ASIO_DECL void start_work_thread();
-
-  // The scheduler implementation used to post completions.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-private:
-  // Mutex to protect access to internal data.
-  asio::detail::mutex mutex_;
-
-  // Private scheduler used for performing asynchronous host resolution.
-  asio::detail::scoped_ptr<scheduler_impl> work_scheduler_;
-
-  // Thread used for running the work io_context's run loop.
-  asio::detail::scoped_ptr<asio::detail::thread> work_thread_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/resolver_service_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler.hpp
deleted file mode 100644
index a73ec14..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler.hpp
+++ /dev/null
@@ -1,241 +0,0 @@
-//
-// detail/scheduler.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCHEDULER_HPP
-#define ASIO_DETAIL_SCHEDULER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/error_code.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/conditionally_enabled_event.hpp"
-#include "asio/detail/conditionally_enabled_mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/scheduler_operation.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/thread.hpp"
-#include "asio/detail/thread_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct scheduler_thread_info;
-
-class scheduler
-  : public execution_context_service_base<scheduler>,
-    public thread_context
-{
-public:
-  typedef scheduler_operation operation;
-
-  // The type of a function used to obtain a task instance.
-  typedef scheduler_task* (*get_task_func_type)(
-      asio::execution_context&);
-
-  // Constructor. Specifies the number of concurrent threads that are likely to
-  // run the scheduler. If set to 1 certain optimisation are performed.
-  ASIO_DECL scheduler(asio::execution_context& ctx,
-      int concurrency_hint = 0, bool own_thread = true,
-      get_task_func_type get_task = &scheduler::get_default_task);
-
-  // Destructor.
-  ASIO_DECL ~scheduler();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Initialise the task, if required.
-  ASIO_DECL void init_task();
-
-  // Run the event loop until interrupted or no more work.
-  ASIO_DECL std::size_t run(asio::error_code& ec);
-
-  // Run until interrupted or one operation is performed.
-  ASIO_DECL std::size_t run_one(asio::error_code& ec);
-
-  // Run until timeout, interrupted, or one operation is performed.
-  ASIO_DECL std::size_t wait_one(
-      long usec, asio::error_code& ec);
-
-  // Poll for operations without blocking.
-  ASIO_DECL std::size_t poll(asio::error_code& ec);
-
-  // Poll for one operation without blocking.
-  ASIO_DECL std::size_t poll_one(asio::error_code& ec);
-
-  // Interrupt the event processing loop.
-  ASIO_DECL void stop();
-
-  // Determine whether the scheduler is stopped.
-  ASIO_DECL bool stopped() const;
-
-  // Restart in preparation for a subsequent run invocation.
-  ASIO_DECL void restart();
-
-  // Notify that some work has started.
-  void work_started()
-  {
-    ++outstanding_work_;
-  }
-
-  // Used to compensate for a forthcoming work_finished call. Must be called
-  // from within a scheduler-owned thread.
-  ASIO_DECL void compensating_work_started();
-
-  // Notify that some work has finished.
-  void work_finished()
-  {
-    if (--outstanding_work_ == 0)
-      stop();
-  }
-
-  // Return whether a handler can be dispatched immediately.
-  ASIO_DECL bool can_dispatch();
-
-  /// Capture the current exception so it can be rethrown from a run function.
-  ASIO_DECL void capture_current_exception();
-
-  // Request invocation of the given operation and return immediately. Assumes
-  // that work_started() has not yet been called for the operation.
-  ASIO_DECL void post_immediate_completion(
-      operation* op, bool is_continuation);
-
-  // Request invocation of the given operations and return immediately. Assumes
-  // that work_started() has not yet been called for the operations.
-  ASIO_DECL void post_immediate_completions(std::size_t n,
-      op_queue<operation>& ops, bool is_continuation);
-
-  // Request invocation of the given operation and return immediately. Assumes
-  // that work_started() was previously called for the operation.
-  ASIO_DECL void post_deferred_completion(operation* op);
-
-  // Request invocation of the given operations and return immediately. Assumes
-  // that work_started() was previously called for each operation.
-  ASIO_DECL void post_deferred_completions(op_queue<operation>& ops);
-
-  // Enqueue the given operation following a failed attempt to dispatch the
-  // operation for immediate invocation.
-  ASIO_DECL void do_dispatch(operation* op);
-
-  // Process unfinished operations as part of a shutdownoperation. Assumes that
-  // work_started() was previously called for the operations.
-  ASIO_DECL void abandon_operations(op_queue<operation>& ops);
-
-  // Get the concurrency hint that was used to initialise the scheduler.
-  int concurrency_hint() const
-  {
-    return concurrency_hint_;
-  }
-
-private:
-  // The mutex type used by this scheduler.
-  typedef conditionally_enabled_mutex mutex;
-
-  // The event type used by this scheduler.
-  typedef conditionally_enabled_event event;
-
-  // Structure containing thread-specific data.
-  typedef scheduler_thread_info thread_info;
-
-  // Run at most one operation. May block.
-  ASIO_DECL std::size_t do_run_one(mutex::scoped_lock& lock,
-      thread_info& this_thread, const asio::error_code& ec);
-
-  // Run at most one operation with a timeout. May block.
-  ASIO_DECL std::size_t do_wait_one(mutex::scoped_lock& lock,
-      thread_info& this_thread, long usec, const asio::error_code& ec);
-
-  // Poll for at most one operation.
-  ASIO_DECL std::size_t do_poll_one(mutex::scoped_lock& lock,
-      thread_info& this_thread, const asio::error_code& ec);
-
-  // Stop the task and all idle threads.
-  ASIO_DECL void stop_all_threads(mutex::scoped_lock& lock);
-
-  // Wake a single idle thread, or the task, and always unlock the mutex.
-  ASIO_DECL void wake_one_thread_and_unlock(
-      mutex::scoped_lock& lock);
-
-  // Get the default task.
-  ASIO_DECL static scheduler_task* get_default_task(
-      asio::execution_context& ctx);
-
-  // Helper class to run the scheduler in its own thread.
-  class thread_function;
-  friend class thread_function;
-
-  // Helper class to perform task-related operations on block exit.
-  struct task_cleanup;
-  friend struct task_cleanup;
-
-  // Helper class to call work-related operations on block exit.
-  struct work_cleanup;
-  friend struct work_cleanup;
-
-  // Whether to optimise for single-threaded use cases.
-  const bool one_thread_;
-
-  // Mutex to protect access to internal data.
-  mutable mutex mutex_;
-
-  // Event to wake up blocked threads.
-  event wakeup_event_;
-
-  // The task to be run by this service.
-  scheduler_task* task_;
-
-  // The function used to get the task.
-  get_task_func_type get_task_;
-
-  // Operation object to represent the position of the task in the queue.
-  struct task_operation : operation
-  {
-    task_operation() : operation(0) {}
-  } task_operation_;
-
-  // Whether the task has been interrupted.
-  bool task_interrupted_;
-
-  // The count of unfinished work.
-  atomic_count outstanding_work_;
-
-  // The queue of handlers that are ready to be delivered.
-  op_queue<operation> op_queue_;
-
-  // Flag to indicate that the dispatcher has been stopped.
-  bool stopped_;
-
-  // Flag to indicate that the dispatcher has been shut down.
-  bool shutdown_;
-
-  // The concurrency hint used to initialise the scheduler.
-  const int concurrency_hint_;
-
-  // The thread that is running the scheduler.
-  asio::detail::thread* thread_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/scheduler.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_SCHEDULER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_operation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_operation.hpp
deleted file mode 100644
index 1b4ceb3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_operation.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//
-// detail/scheduler_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCHEDULER_OPERATION_HPP
-#define ASIO_DETAIL_SCHEDULER_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/error_code.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/op_queue.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class scheduler;
-
-// Base class for all operations. A function pointer is used instead of virtual
-// functions to avoid the associated overhead.
-class scheduler_operation ASIO_INHERIT_TRACKED_HANDLER
-{
-public:
-  typedef scheduler_operation operation_type;
-
-  void complete(void* owner, const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    func_(owner, this, ec, bytes_transferred);
-  }
-
-  void destroy()
-  {
-    func_(0, this, asio::error_code(), 0);
-  }
-
-protected:
-  typedef void (*func_type)(void*,
-      scheduler_operation*,
-      const asio::error_code&, std::size_t);
-
-  scheduler_operation(func_type func)
-    : next_(0),
-      func_(func),
-      task_result_(0)
-  {
-  }
-
-  // Prevents deletion through this type.
-  ~scheduler_operation()
-  {
-  }
-
-private:
-  friend class op_queue_access;
-  scheduler_operation* next_;
-  func_type func_;
-protected:
-  friend class scheduler;
-  unsigned int task_result_; // Passed into bytes transferred.
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SCHEDULER_OPERATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_task.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_task.hpp
deleted file mode 100644
index a1a4ec1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_task.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// detail/scheduler_task.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCHEDULER_TASK_HPP
-#define ASIO_DETAIL_SCHEDULER_TASK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/op_queue.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class scheduler_operation;
-
-// Base class for all tasks that may be run by a scheduler.
-class scheduler_task
-{
-public:
-  // Run the task once until interrupted or events are ready to be dispatched.
-  virtual void run(long usec, op_queue<scheduler_operation>& ops) = 0;
-
-  // Interrupt the task.
-  virtual void interrupt() = 0;
-
-protected:
-  // Prevent deletion through this type.
-  ~scheduler_task()
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SCHEDULER_TASK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_thread_info.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_thread_info.hpp
deleted file mode 100644
index 410d286..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scheduler_thread_info.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// detail/scheduler_thread_info.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
-#define ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/thread_info_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class scheduler;
-class scheduler_operation;
-
-struct scheduler_thread_info : public thread_info_base
-{
-  op_queue<scheduler_operation> private_op_queue;
-  long private_outstanding_work;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_lock.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_lock.hpp
deleted file mode 100644
index 778832d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_lock.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// detail/scoped_lock.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCOPED_LOCK_HPP
-#define ASIO_DETAIL_SCOPED_LOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper class to lock and unlock a mutex automatically.
-template <typename Mutex>
-class scoped_lock
-  : private noncopyable
-{
-public:
-  // Tag type used to distinguish constructors.
-  enum adopt_lock_t { adopt_lock };
-
-  // Constructor adopts a lock that is already held.
-  scoped_lock(Mutex& m, adopt_lock_t)
-    : mutex_(m),
-      locked_(true)
-  {
-  }
-
-  // Constructor acquires the lock.
-  explicit scoped_lock(Mutex& m)
-    : mutex_(m)
-  {
-    mutex_.lock();
-    locked_ = true;
-  }
-
-  // Destructor releases the lock.
-  ~scoped_lock()
-  {
-    if (locked_)
-      mutex_.unlock();
-  }
-
-  // Explicitly acquire the lock.
-  void lock()
-  {
-    if (!locked_)
-    {
-      mutex_.lock();
-      locked_ = true;
-    }
-  }
-
-  // Explicitly release the lock.
-  void unlock()
-  {
-    if (locked_)
-    {
-      mutex_.unlock();
-      locked_ = false;
-    }
-  }
-
-  // Test whether the lock is held.
-  bool locked() const
-  {
-    return locked_;
-  }
-
-  // Get the underlying mutex.
-  Mutex& mutex()
-  {
-    return mutex_;
-  }
-
-private:
-  // The underlying mutex.
-  Mutex& mutex_;
-
-  // Whether the mutex is currently locked or unlocked.
-  bool locked_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SCOPED_LOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_ptr.hpp
deleted file mode 100644
index a517c2b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/scoped_ptr.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//
-// detail/scoped_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SCOPED_PTR_HPP
-#define ASIO_DETAIL_SCOPED_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-class scoped_ptr
-{
-public:
-  // Constructor.
-  explicit scoped_ptr(T* p = 0)
-    : p_(p)
-  {
-  }
-
-  // Destructor.
-  ~scoped_ptr()
-  {
-    delete p_;
-  }
-
-  // Access.
-  T* get()
-  {
-    return p_;
-  }
-
-  // Access.
-  T* operator->()
-  {
-    return p_;
-  }
-
-  // Dereference.
-  T& operator*()
-  {
-    return *p_;
-  }
-
-  // Reset pointer.
-  void reset(T* p = 0)
-  {
-    delete p_;
-    p_ = p;
-  }
-
-  // Release ownership of the pointer.
-  T* release()
-  {
-    T* tmp = p_;
-    p_ = 0;
-    return tmp;
-  }
-
-private:
-  // Disallow copying and assignment.
-  scoped_ptr(const scoped_ptr&);
-  scoped_ptr& operator=(const scoped_ptr&);
-
-  T* p_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SCOPED_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_interrupter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_interrupter.hpp
deleted file mode 100644
index 57cb4ce..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_interrupter.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// detail/select_interrupter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SELECT_INTERRUPTER_HPP
-#define ASIO_DETAIL_SELECT_INTERRUPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
-# include "asio/detail/socket_select_interrupter.hpp"
-#elif defined(ASIO_HAS_EVENTFD)
-# include "asio/detail/eventfd_select_interrupter.hpp"
-#else
-# include "asio/detail/pipe_select_interrupter.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
-typedef socket_select_interrupter select_interrupter;
-#elif defined(ASIO_HAS_EVENTFD)
-typedef eventfd_select_interrupter select_interrupter;
-#else
-typedef pipe_select_interrupter select_interrupter;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_SELECT_INTERRUPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_reactor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_reactor.hpp
deleted file mode 100644
index 7fe647b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/select_reactor.hpp
+++ /dev/null
@@ -1,291 +0,0 @@
-//
-// detail/select_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SELECT_REACTOR_HPP
-#define ASIO_DETAIL_SELECT_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || (!defined(ASIO_HAS_DEV_POLL) \
-      && !defined(ASIO_HAS_EPOLL) \
-      && !defined(ASIO_HAS_KQUEUE) \
-      && !defined(ASIO_WINDOWS_RUNTIME))
-
-#include <cstddef>
-#include "asio/detail/fd_set_adapter.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/reactor_op_queue.hpp"
-#include "asio/detail/scheduler_task.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/thread.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class select_reactor
-  : public execution_context_service_base<select_reactor>
-#if !defined(ASIO_HAS_IOCP)
-    , public scheduler_task
-#endif // !defined(ASIO_HAS_IOCP)
-{
-public:
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  enum op_types { read_op = 0, write_op = 1, except_op = 2,
-    max_select_ops = 3, connect_op = 3, max_ops = 4 };
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  enum op_types { read_op = 0, write_op = 1, except_op = 2,
-    max_select_ops = 3, connect_op = 1, max_ops = 3 };
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-  // Per-descriptor data.
-  struct per_descriptor_data
-  {
-  };
-
-  // Constructor.
-  ASIO_DECL select_reactor(asio::execution_context& ctx);
-
-  // Destructor.
-  ASIO_DECL ~select_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal descriptors following a fork.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Initialise the task, but only if the reactor is not in its own thread.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
-
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // success, system error code on failure.
-  ASIO_DECL int register_internal_descriptor(
-      int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(operation* op, bool is_continuation) const;
-
-  // Post a reactor operation for immediate completion.
-  ASIO_DECL static void call_post_immediate_completion(
-      operation* op, bool is_continuation, const void* self);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data&, reactor_op* op, bool is_continuation, bool,
-      void (*on_immediate)(operation*, bool, const void*),
-      const void* immediate_arg);
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data, reactor_op* op,
-      bool is_continuation, bool allow_speculative)
-  {
-    start_op(op_type, descriptor, descriptor_data,
-        op, is_continuation, allow_speculative,
-        &select_reactor::call_post_immediate_completion, this);
-  }
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
-
-  // Cancel all operations associated with the given descriptor and key. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      int op_type, void* cancellation_key);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor. The reactor resources associated with
-  // the descriptor must be released by calling cleanup_descriptor_data.
-  ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data&, bool closing);
-
-  // Remove the descriptor's registration from the reactor. The reactor
-  // resources associated with the descriptor must be released by calling
-  // cleanup_descriptor_data.
-  ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data&);
-
-  // Perform any post-deregistration cleanup tasks associated with the
-  // descriptor data.
-  ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
-
-  // Move descriptor registration from one descriptor_data object to another.
-  ASIO_DECL void move_descriptor(socket_type descriptor,
-      per_descriptor_data& target_descriptor_data,
-      per_descriptor_data& source_descriptor_data);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& target,
-      typename timer_queue<Time_Traits>::per_timer_data& source);
-
-  // Run select once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(long usec, op_queue<operation>& ops);
-
-  // Interrupt the select loop.
-  ASIO_DECL void interrupt();
-
-private:
-#if defined(ASIO_HAS_IOCP)
-  // Run the select loop in the thread.
-  ASIO_DECL void run_thread();
-#endif // defined(ASIO_HAS_IOCP)
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Get the timeout value for the select call.
-  ASIO_DECL timeval* get_timeout(long usec, timeval& tv);
-
-  // Cancel all operations associated with the given descriptor. This function
-  // does not acquire the select_reactor's mutex.
-  ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
-      const asio::error_code& ec);
-
-  // The scheduler implementation used to post completions.
-# if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_type;
-# else // defined(ASIO_HAS_IOCP)
-  typedef class scheduler scheduler_type;
-# endif // defined(ASIO_HAS_IOCP)
-  scheduler_type& scheduler_;
-
-  // Mutex to protect access to internal data.
-  asio::detail::mutex mutex_;
-
-  // The interrupter is used to break a blocking select call.
-  select_interrupter interrupter_;
-
-  // The queues of read, write and except operations.
-  reactor_op_queue<socket_type> op_queue_[max_ops];
-
-  // The file descriptor sets to be passed to the select system call.
-  fd_set_adapter fd_sets_[max_select_ops];
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-#if defined(ASIO_HAS_IOCP)
-  // Helper class to run the reactor loop in a thread.
-  class thread_function;
-  friend class thread_function;
-
-  // Does the reactor loop thread need to stop.
-  bool stop_thread_;
-
-  // The thread that is running the reactor loop.
-  asio::detail::thread* thread_;
-
-  // Helper class to join and restart the reactor thread.
-  class restart_reactor : public operation
-  {
-  public:
-    restart_reactor(select_reactor* r)
-      : operation(&restart_reactor::do_complete),
-        reactor_(r)
-    {
-    }
-
-    ASIO_DECL static void do_complete(void* owner, operation* base,
-        const asio::error_code& ec, std::size_t bytes_transferred);
-
-  private:
-    select_reactor* reactor_;
-  };
-
-  friend class restart_reactor;
-
-  // Operation used to join and restart the reactor thread.
-  restart_reactor restart_reactor_;
-#endif // defined(ASIO_HAS_IOCP)
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/select_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/select_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || (!defined(ASIO_HAS_DEV_POLL)
-       //       && !defined(ASIO_HAS_EPOLL)
-       //       && !defined(ASIO_HAS_KQUEUE)
-       //       && !defined(ASIO_WINDOWS_RUNTIME))
-
-#endif // ASIO_DETAIL_SELECT_REACTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/service_registry.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/service_registry.hpp
deleted file mode 100644
index 991b32a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/service_registry.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-//
-// detail/service_registry.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SERVICE_REGISTRY_HPP
-#define ASIO_DETAIL_SERVICE_REGISTRY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <typeinfo>
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class io_context;
-
-namespace detail {
-
-template <typename T>
-class typeid_wrapper {};
-
-class service_registry
-  : private noncopyable
-{
-public:
-  // Constructor.
-  ASIO_DECL service_registry(execution_context& owner);
-
-  // Destructor.
-  ASIO_DECL ~service_registry();
-
-  // Shutdown all services.
-  ASIO_DECL void shutdown_services();
-
-  // Destroy all services.
-  ASIO_DECL void destroy_services();
-
-  // Notify all services of a fork event.
-  ASIO_DECL void notify_fork(execution_context::fork_event fork_ev);
-
-  // Get the service object corresponding to the specified service type. Will
-  // create a new service object automatically if no such object already
-  // exists. Ownership of the service object is not transferred to the caller.
-  template <typename Service>
-  Service& use_service();
-
-  // Get the service object corresponding to the specified service type. Will
-  // create a new service object automatically if no such object already
-  // exists. Ownership of the service object is not transferred to the caller.
-  // This overload is used for backwards compatibility with services that
-  // inherit from io_context::service.
-  template <typename Service>
-  Service& use_service(io_context& owner);
-
-  // Add a service object. Throws on error, in which case ownership of the
-  // object is retained by the caller.
-  template <typename Service>
-  void add_service(Service* new_service);
-
-  // Check whether a service object of the specified type already exists.
-  template <typename Service>
-  bool has_service() const;
-
-private:
-  // Initalise a service's key when the key_type typedef is not available.
-  template <typename Service>
-  static void init_key(execution_context::service::key& key, ...);
-
-#if !defined(ASIO_NO_TYPEID)
-  // Initalise a service's key when the key_type typedef is available.
-  template <typename Service>
-  static void init_key(execution_context::service::key& key,
-      enable_if_t<is_base_of<typename Service::key_type, Service>::value>*);
-#endif // !defined(ASIO_NO_TYPEID)
-
-  // Initialise a service's key based on its id.
-  ASIO_DECL static void init_key_from_id(
-      execution_context::service::key& key,
-      const execution_context::id& id);
-
-#if !defined(ASIO_NO_TYPEID)
-  // Initialise a service's key based on its id.
-  template <typename Service>
-  static void init_key_from_id(execution_context::service::key& key,
-      const service_id<Service>& /*id*/);
-#endif // !defined(ASIO_NO_TYPEID)
-
-  // Check if a service matches the given id.
-  ASIO_DECL static bool keys_match(
-      const execution_context::service::key& key1,
-      const execution_context::service::key& key2);
-
-  // The type of a factory function used for creating a service instance.
-  typedef execution_context::service*(*factory_type)(void*);
-
-  // Factory function for creating a service instance.
-  template <typename Service, typename Owner>
-  static execution_context::service* create(void* owner);
-
-  // Destroy a service instance.
-  ASIO_DECL static void destroy(execution_context::service* service);
-
-  // Helper class to manage service pointers.
-  struct auto_service_ptr;
-  friend struct auto_service_ptr;
-  struct auto_service_ptr
-  {
-    execution_context::service* ptr_;
-    ~auto_service_ptr() { destroy(ptr_); }
-  };
-
-  // Get the service object corresponding to the specified service key. Will
-  // create a new service object automatically if no such object already
-  // exists. Ownership of the service object is not transferred to the caller.
-  ASIO_DECL execution_context::service* do_use_service(
-      const execution_context::service::key& key,
-      factory_type factory, void* owner);
-
-  // Add a service object. Throws on error, in which case ownership of the
-  // object is retained by the caller.
-  ASIO_DECL void do_add_service(
-      const execution_context::service::key& key,
-      execution_context::service* new_service);
-
-  // Check whether a service object with the specified key already exists.
-  ASIO_DECL bool do_has_service(
-      const execution_context::service::key& key) const;
-
-  // Mutex to protect access to internal data.
-  mutable asio::detail::mutex mutex_;
-
-  // The owner of this service registry and the services it contains.
-  execution_context& owner_;
-
-  // The first service in the list of contained services.
-  execution_context::service* first_service_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/service_registry.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/service_registry.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_SERVICE_REGISTRY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_blocker.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_blocker.hpp
deleted file mode 100644
index 11d0b0e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_blocker.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// detail/signal_blocker.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SIGNAL_BLOCKER_HPP
-#define ASIO_DETAIL_SIGNAL_BLOCKER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS) || defined(ASIO_WINDOWS) \
-  || defined(ASIO_WINDOWS_RUNTIME) \
-  || defined(__CYGWIN__) || defined(__SYMBIAN32__)
-# include "asio/detail/null_signal_blocker.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_signal_blocker.hpp"
-#else
-# error Only Windows and POSIX are supported!
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS) || defined(ASIO_WINDOWS) \
-  || defined(ASIO_WINDOWS_RUNTIME) \
-  || defined(__CYGWIN__) || defined(__SYMBIAN32__)
-typedef null_signal_blocker signal_blocker;
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_signal_blocker signal_blocker;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_SIGNAL_BLOCKER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_handler.hpp
deleted file mode 100644
index 6d43f57..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_handler.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// detail/signal_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SIGNAL_HANDLER_HPP
-#define ASIO_DETAIL_SIGNAL_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/signal_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class signal_handler : public signal_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(signal_handler);
-
-  signal_handler(Handler& h, const IoExecutor& io_ex)
-    : signal_op(&signal_handler::do_complete),
-      handler_(static_cast<Handler&&>(h)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    signal_handler* h(static_cast<signal_handler*>(base));
-    ptr p = { asio::detail::addressof(h->handler_), h, h };
-
-    ASIO_HANDLER_COMPLETION((*h));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          h->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, int>
-      handler(h->handler_, h->ec_, h->signal_number_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SIGNAL_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_init.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_init.hpp
deleted file mode 100644
index 6f2c7c8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_init.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// detail/signal_init.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SIGNAL_INIT_HPP
-#define ASIO_DETAIL_SIGNAL_INIT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include <csignal>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <int Signal = SIGPIPE>
-class signal_init
-{
-public:
-  // Constructor.
-  signal_init()
-  {
-    std::signal(Signal, SIG_IGN);
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_SIGNAL_INIT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_op.hpp
deleted file mode 100644
index 5e0071a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_op.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// detail/signal_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SIGNAL_OP_HPP
-#define ASIO_DETAIL_SIGNAL_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class signal_op
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-  // The operation key used for targeted cancellation.
-  void* cancellation_key_;
-
-  // The signal number to be passed to the completion handler.
-  int signal_number_;
-
-protected:
-  signal_op(func_type func)
-    : operation(func),
-      cancellation_key_(0),
-      signal_number_(0)
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SIGNAL_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_set_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_set_service.hpp
deleted file mode 100644
index 142ff43..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/signal_set_service.hpp
+++ /dev/null
@@ -1,292 +0,0 @@
-//
-// detail/signal_set_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
-#define ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstddef>
-#include <signal.h>
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/signal_set_base.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/signal_handler.hpp"
-#include "asio/detail/signal_op.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#  include "asio/detail/io_uring_service.hpp"
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#  include "asio/detail/reactor.hpp"
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(NSIG) && (NSIG > 0)
-enum { max_signal_number = NSIG };
-#else
-enum { max_signal_number = 128 };
-#endif
-
-extern ASIO_DECL struct signal_state* get_signal_state();
-
-extern "C" ASIO_DECL void asio_signal_handler(int signal_number);
-
-class signal_set_service :
-  public execution_context_service_base<signal_set_service>
-{
-public:
-  // Type used for tracking an individual signal registration.
-  class registration
-  {
-  public:
-    // Default constructor.
-    registration()
-      : signal_number_(0),
-        queue_(0),
-        undelivered_(0),
-        next_in_table_(0),
-        prev_in_table_(0),
-        next_in_set_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class signal_set_service;
-
-    // The signal number that is registered.
-    int signal_number_;
-
-    // The waiting signal handlers.
-    op_queue<signal_op>* queue_;
-
-    // The number of undelivered signals.
-    std::size_t undelivered_;
-
-    // Pointers to adjacent registrations in the registrations_ table.
-    registration* next_in_table_;
-    registration* prev_in_table_;
-
-    // Link to next registration in the signal set.
-    registration* next_in_set_;
-  };
-
-  // The implementation type of the signal_set.
-  class implementation_type
-  {
-  public:
-    // Default constructor.
-    implementation_type()
-      : signals_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class signal_set_service;
-
-    // The pending signal handlers.
-    op_queue<signal_op> queue_;
-
-    // Linked list of registered signals.
-    registration* signals_;
-  };
-
-  // Constructor.
-  ASIO_DECL signal_set_service(execution_context& context);
-
-  // Destructor.
-  ASIO_DECL ~signal_set_service();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Perform fork-related housekeeping.
-  ASIO_DECL void notify_fork(
-      asio::execution_context::fork_event fork_ev);
-
-  // Construct a new signal_set implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Destroy a signal_set implementation.
-  ASIO_DECL void destroy(implementation_type& impl);
-
-  // Add a signal to a signal_set.
-  asio::error_code add(implementation_type& impl,
-      int signal_number, asio::error_code& ec)
-  {
-    return add(impl, signal_number, signal_set_base::flags::dont_care, ec);
-  }
-
-  // Add a signal to a signal_set with the specified flags.
-  ASIO_DECL asio::error_code add(implementation_type& impl,
-      int signal_number, signal_set_base::flags_t f,
-      asio::error_code& ec);
-
-  // Remove a signal to a signal_set.
-  ASIO_DECL asio::error_code remove(implementation_type& impl,
-      int signal_number, asio::error_code& ec);
-
-  // Remove all signals from a signal_set.
-  ASIO_DECL asio::error_code clear(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Cancel all operations associated with the signal set.
-  ASIO_DECL asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Cancel a specific operation associated with the signal set.
-  ASIO_DECL void cancel_ops_by_key(implementation_type& impl,
-      void* cancellation_key);
-
-  // Start an asynchronous operation to wait for a signal to be delivered.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(implementation_type& impl,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef signal_handler<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<signal_op_cancellation>(this, &impl);
-    }
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "signal_set", &impl, 0, "async_wait"));
-
-    start_wait_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-  // Deliver notification that a particular signal occurred.
-  ASIO_DECL static void deliver_signal(int signal_number);
-
-private:
-  // Helper function to add a service to the global signal state.
-  ASIO_DECL static void add_service(signal_set_service* service);
-
-  // Helper function to remove a service from the global signal state.
-  ASIO_DECL static void remove_service(signal_set_service* service);
-
-  // Helper function to create the pipe descriptors.
-  ASIO_DECL static void open_descriptors();
-
-  // Helper function to close the pipe descriptors.
-  ASIO_DECL static void close_descriptors();
-
-  // Helper function to start a wait operation.
-  ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op);
-
-  // Helper class used to implement per-operation cancellation
-  class signal_op_cancellation
-  {
-  public:
-    signal_op_cancellation(signal_set_service* s, implementation_type* i)
-      : service_(s),
-        implementation_(i)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        service_->cancel_ops_by_key(*implementation_, this);
-      }
-    }
-
-  private:
-    signal_set_service* service_;
-    implementation_type* implementation_;
-  };
-
-  // The scheduler used for dispatching handlers.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-#if !defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_RUNTIME) \
-  && !defined(__CYGWIN__)
-  // The type used for processing pipe readiness notifications.
-  class pipe_read_op;
-
-# if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  // The io_uring service used for waiting for pipe readiness.
-  io_uring_service& io_uring_service_;
-
-  // The per I/O object data used for the pipe.
-  io_uring_service::per_io_object_data io_object_data_;
-# else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  // The reactor used for waiting for pipe readiness.
-  reactor& reactor_;
-
-  // The per-descriptor reactor data used for the pipe.
-  reactor::per_descriptor_data reactor_data_;
-# endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-#endif // !defined(ASIO_WINDOWS)
-       //   && !defined(ASIO_WINDOWS_RUNTIME)
-       //   && !defined(__CYGWIN__)
-
-  // A mapping from signal number to the registered signal sets.
-  registration* registrations_[max_signal_number];
-
-  // Pointers to adjacent services in linked list.
-  signal_set_service* next_;
-  signal_set_service* prev_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/signal_set_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_holder.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_holder.hpp
deleted file mode 100644
index 300e373..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_holder.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// detail/socket_holder.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_HOLDER_HPP
-#define ASIO_DETAIL_SOCKET_HOLDER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Implement the resource acquisition is initialisation idiom for sockets.
-class socket_holder
-  : private noncopyable
-{
-public:
-  // Construct as an uninitialised socket.
-  socket_holder()
-    : socket_(invalid_socket)
-  {
-  }
-
-  // Construct to take ownership of the specified socket.
-  explicit socket_holder(socket_type s)
-    : socket_(s)
-  {
-  }
-
-  // Destructor.
-  ~socket_holder()
-  {
-    if (socket_ != invalid_socket)
-    {
-      asio::error_code ec;
-      socket_ops::state_type state = 0;
-      socket_ops::close(socket_, state, true, ec);
-    }
-  }
-
-  // Get the underlying socket.
-  socket_type get() const
-  {
-    return socket_;
-  }
-
-  // Reset to an uninitialised socket.
-  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;
-    }
-  }
-
-  // Reset to take ownership of the specified socket.
-  void reset(socket_type s)
-  {
-    reset();
-    socket_ = s;
-  }
-
-  // Release ownership of the socket.
-  socket_type release()
-  {
-    socket_type tmp = socket_;
-    socket_ = invalid_socket;
-    return tmp;
-  }
-
-private:
-  // The underlying socket.
-  socket_type socket_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SOCKET_HOLDER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_ops.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_ops.hpp
deleted file mode 100644
index fd2dc09..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_ops.hpp
+++ /dev/null
@@ -1,375 +0,0 @@
-//
-// detail/socket_ops.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_OPS_HPP
-#define ASIO_DETAIL_SOCKET_OPS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/error_code.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace socket_ops {
-
-// Socket state bits.
-enum
-{
-  // The user wants a non-blocking socket.
-  user_set_non_blocking = 1,
-
-  // The socket has been set non-blocking.
-  internal_non_blocking = 2,
-
-  // Helper "state" used to determine whether the socket is non-blocking.
-  non_blocking = user_set_non_blocking | internal_non_blocking,
-
-  // User wants connection_aborted errors, which are disabled by default.
-  enable_connection_aborted = 4,
-
-  // The user set the linger option. Needs to be checked when closing.
-  user_set_linger = 8,
-
-  // The socket is stream-oriented.
-  stream_oriented = 16,
-
-  // The socket is datagram-oriented.
-  datagram_oriented = 32,
-
-  // The socket may have been dup()-ed.
-  possible_dup = 64
-};
-
-typedef unsigned char state_type;
-
-struct noop_deleter { void operator()(void*) {} };
-typedef shared_ptr<void> shared_cancel_token_type;
-typedef weak_ptr<void> weak_cancel_token_type;
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-ASIO_DECL socket_type accept(socket_type s, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-ASIO_DECL socket_type sync_accept(socket_type s, state_type state,
-    void* addr, std::size_t* addrlen, asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_accept(socket_type s, void* output_buffer,
-    DWORD address_length, void* addr, std::size_t* addrlen,
-    socket_type new_socket, asio::error_code& ec);
-
-#else // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_accept(socket_type s,
-    state_type state, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, socket_type& new_socket);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL int bind(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-ASIO_DECL int close(socket_type s, state_type& state,
-    bool destruction, asio::error_code& ec);
-
-ASIO_DECL bool set_user_non_blocking(socket_type s,
-    state_type& state, bool value, asio::error_code& ec);
-
-ASIO_DECL bool set_internal_non_blocking(socket_type s,
-    state_type& state, bool value, asio::error_code& ec);
-
-ASIO_DECL int shutdown(socket_type s,
-    int what, asio::error_code& ec);
-
-ASIO_DECL int connect(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-ASIO_DECL void sync_connect(socket_type s, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_connect(socket_type s,
-    asio::error_code& ec);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_connect(socket_type s,
-    asio::error_code& ec);
-
-ASIO_DECL int socketpair(int af, int type, int protocol,
-    socket_type sv[2], asio::error_code& ec);
-
-ASIO_DECL bool sockatmark(socket_type s, asio::error_code& ec);
-
-ASIO_DECL size_t available(socket_type s, asio::error_code& ec);
-
-ASIO_DECL int listen(socket_type s,
-    int backlog, asio::error_code& ec);
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef WSABUF buf;
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef iovec buf;
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-ASIO_DECL void init_buf(buf& b, void* data, size_t size);
-
-ASIO_DECL void init_buf(buf& b, const void* data, size_t size);
-
-ASIO_DECL signed_size_type recv(socket_type s, buf* bufs,
-    size_t count, int flags, asio::error_code& ec);
-
-ASIO_DECL signed_size_type recv1(socket_type s,
-    void* data, size_t size, int flags, asio::error_code& ec);
-
-ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs,
-    size_t count, int flags, bool all_empty, asio::error_code& ec);
-
-ASIO_DECL size_t sync_recv1(socket_type s, state_type state,
-    void* data, size_t size, int flags, asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_recv(state_type state,
-    const weak_cancel_token_type& cancel_token, bool all_empty,
-    asio::error_code& ec, size_t bytes_transferred);
-
-#else // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_recv(socket_type s,
-    buf* bufs, size_t count, int flags, bool is_stream,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_recv1(socket_type s,
-    void* data, size_t size, int flags, bool is_stream,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL signed_size_type recvfrom(socket_type s,
-    buf* bufs, size_t count, int flags, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-ASIO_DECL signed_size_type recvfrom1(socket_type s,
-    void* data, size_t size, int flags, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-ASIO_DECL size_t sync_recvfrom(socket_type s, state_type state,
-    buf* bufs, size_t count, int flags, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-ASIO_DECL size_t sync_recvfrom1(socket_type s, state_type state,
-    void* data, size_t size, int flags, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_recvfrom(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec);
-
-#else // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_recvfrom(socket_type s, buf* bufs,
-    size_t count, int flags, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_recvfrom1(socket_type s, void* data,
-    size_t size, int flags, void* addr, std::size_t* addrlen,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL signed_size_type recvmsg(socket_type s, buf* bufs,
-    size_t count, int in_flags, int& out_flags,
-    asio::error_code& ec);
-
-ASIO_DECL size_t sync_recvmsg(socket_type s, state_type state,
-    buf* bufs, size_t count, int in_flags, int& out_flags,
-    asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_recvmsg(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec);
-
-#else // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_recvmsg(socket_type s,
-    buf* bufs, size_t count, int in_flags, int& out_flags,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL signed_size_type send(socket_type s, const buf* bufs,
-    size_t count, int flags, asio::error_code& ec);
-
-ASIO_DECL signed_size_type send1(socket_type s,
-    const void* data, size_t size, int flags, asio::error_code& ec);
-
-ASIO_DECL size_t sync_send(socket_type s, state_type state,
-    const buf* bufs, size_t count, int flags,
-    bool all_empty, asio::error_code& ec);
-
-ASIO_DECL size_t sync_send1(socket_type s, state_type state,
-    const void* data, size_t size, int flags, asio::error_code& ec);
-
-#if defined(ASIO_HAS_IOCP)
-
-ASIO_DECL void complete_iocp_send(
-    const weak_cancel_token_type& cancel_token,
-    asio::error_code& ec);
-
-#else // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_send(socket_type s,
-    const buf* bufs, size_t count, int flags,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_send1(socket_type s,
-    const void* data, size_t size, int flags,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-#endif // defined(ASIO_HAS_IOCP)
-
-ASIO_DECL signed_size_type sendto(socket_type s,
-    const buf* bufs, size_t count, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-ASIO_DECL signed_size_type sendto1(socket_type s,
-    const void* data, size_t size, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-ASIO_DECL size_t sync_sendto(socket_type s, state_type state,
-    const buf* bufs, size_t count, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-ASIO_DECL size_t sync_sendto1(socket_type s, state_type state,
-    const void* data, size_t size, int flags, const void* addr,
-    std::size_t addrlen, asio::error_code& ec);
-
-#if !defined(ASIO_HAS_IOCP)
-
-ASIO_DECL bool non_blocking_sendto(socket_type s, const buf* bufs,
-    size_t count, int flags, const void* addr, std::size_t addrlen,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-ASIO_DECL bool non_blocking_sendto1(socket_type s, const void* data,
-    size_t size, int flags, const void* addr, std::size_t addrlen,
-    asio::error_code& ec, size_t& bytes_transferred);
-
-#endif // !defined(ASIO_HAS_IOCP)
-
-ASIO_DECL socket_type socket(int af, int type, int protocol,
-    asio::error_code& ec);
-
-ASIO_DECL int setsockopt(socket_type s, state_type& state,
-    int level, int optname, const void* optval,
-    std::size_t optlen, asio::error_code& ec);
-
-ASIO_DECL int getsockopt(socket_type s, state_type state,
-    int level, int optname, void* optval,
-    size_t* optlen, asio::error_code& ec);
-
-ASIO_DECL int getpeername(socket_type s, void* addr,
-    std::size_t* addrlen, bool cached, asio::error_code& ec);
-
-ASIO_DECL int getsockname(socket_type s, void* addr,
-    std::size_t* addrlen, asio::error_code& ec);
-
-ASIO_DECL int ioctl(socket_type s, state_type& state,
-    int cmd, ioctl_arg_type* arg, asio::error_code& ec);
-
-ASIO_DECL int select(int nfds, fd_set* readfds, fd_set* writefds,
-    fd_set* exceptfds, timeval* timeout, asio::error_code& ec);
-
-ASIO_DECL int poll_read(socket_type s,
-    state_type state, int msec, asio::error_code& ec);
-
-ASIO_DECL int poll_write(socket_type s,
-    state_type state, int msec, asio::error_code& ec);
-
-ASIO_DECL int poll_error(socket_type s,
-    state_type state, int msec, asio::error_code& ec);
-
-ASIO_DECL int poll_connect(socket_type s,
-    int msec, asio::error_code& ec);
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-ASIO_DECL const char* inet_ntop(int af, const void* src, char* dest,
-    size_t length, unsigned long scope_id, asio::error_code& ec);
-
-ASIO_DECL int inet_pton(int af, const char* src, void* dest,
-    unsigned long* scope_id, asio::error_code& ec);
-
-ASIO_DECL int gethostname(char* name,
-    int namelen, asio::error_code& ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-ASIO_DECL asio::error_code getaddrinfo(const char* host,
-    const char* service, const addrinfo_type& hints,
-    addrinfo_type** result, asio::error_code& ec);
-
-ASIO_DECL asio::error_code background_getaddrinfo(
-    const weak_cancel_token_type& cancel_token, const char* host,
-    const char* service, const addrinfo_type& hints,
-    addrinfo_type** result, asio::error_code& ec);
-
-ASIO_DECL void freeaddrinfo(addrinfo_type* ai);
-
-ASIO_DECL asio::error_code getnameinfo(const void* addr,
-    std::size_t addrlen, char* host, std::size_t hostlen, char* serv,
-    std::size_t servlen, int flags, asio::error_code& ec);
-
-ASIO_DECL asio::error_code sync_getnameinfo(const void* addr,
-    std::size_t addrlen, char* host, std::size_t hostlen, char* serv,
-    std::size_t servlen, int sock_type, asio::error_code& ec);
-
-ASIO_DECL asio::error_code background_getnameinfo(
-    const weak_cancel_token_type& cancel_token,
-    const void* addr, std::size_t addrlen,
-    char* host, std::size_t hostlen, char* serv,
-    std::size_t servlen, int sock_type, asio::error_code& ec);
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-ASIO_DECL u_long_type network_to_host_long(u_long_type value);
-
-ASIO_DECL u_long_type host_to_network_long(u_long_type value);
-
-ASIO_DECL u_short_type network_to_host_short(u_short_type value);
-
-ASIO_DECL u_short_type host_to_network_short(u_short_type value);
-
-} // namespace socket_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/socket_ops.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_SOCKET_OPS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_option.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_option.hpp
deleted file mode 100644
index 760713d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_option.hpp
+++ /dev/null
@@ -1,316 +0,0 @@
-//
-// detail/socket_option.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_OPTION_HPP
-#define ASIO_DETAIL_SOCKET_OPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <stdexcept>
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace socket_option {
-
-// Helper template for implementing boolean-based options.
-template <int Level, int Name>
-class boolean
-{
-public:
-  // Default constructor.
-  boolean()
-    : value_(0)
-  {
-  }
-
-  // Construct with a specific option value.
-  explicit boolean(bool v)
-    : value_(v ? 1 : 0)
-  {
-  }
-
-  // Set the current value of the boolean.
-  boolean& operator=(bool v)
-  {
-    value_ = v ? 1 : 0;
-    return *this;
-  }
-
-  // Get the current value of the boolean.
-  bool value() const
-  {
-    return !!value_;
-  }
-
-  // Convert to bool.
-  operator bool() const
-  {
-    return !!value_;
-  }
-
-  // Test for false.
-  bool operator!() const
-  {
-    return !value_;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol&) const
-  {
-    return Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol&) const
-  {
-    return Name;
-  }
-
-  // Get the address of the boolean data.
-  template <typename Protocol>
-  int* data(const Protocol&)
-  {
-    return &value_;
-  }
-
-  // Get the address of the boolean data.
-  template <typename Protocol>
-  const int* data(const Protocol&) const
-  {
-    return &value_;
-  }
-
-  // Get the size of the boolean data.
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return sizeof(value_);
-  }
-
-  // Set the size of the boolean data.
-  template <typename Protocol>
-  void resize(const Protocol&, std::size_t s)
-  {
-    // On some platforms (e.g. Windows Vista), the getsockopt function will
-    // return the size of a boolean socket option as one byte, even though a
-    // four byte integer was passed in.
-    switch (s)
-    {
-    case sizeof(char):
-      value_ = *reinterpret_cast<char*>(&value_) ? 1 : 0;
-      break;
-    case sizeof(value_):
-      break;
-    default:
-      {
-        std::length_error ex("boolean socket option resize");
-        asio::detail::throw_exception(ex);
-      }
-    }
-  }
-
-private:
-  int value_;
-};
-
-// Helper template for implementing integer options.
-template <int Level, int Name>
-class integer
-{
-public:
-  // Default constructor.
-  integer()
-    : value_(0)
-  {
-  }
-
-  // Construct with a specific option value.
-  explicit integer(int v)
-    : value_(v)
-  {
-  }
-
-  // Set the value of the int option.
-  integer& operator=(int v)
-  {
-    value_ = v;
-    return *this;
-  }
-
-  // Get the current value of the int option.
-  int value() const
-  {
-    return value_;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol&) const
-  {
-    return Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol&) const
-  {
-    return Name;
-  }
-
-  // Get the address of the int data.
-  template <typename Protocol>
-  int* data(const Protocol&)
-  {
-    return &value_;
-  }
-
-  // Get the address of the int data.
-  template <typename Protocol>
-  const int* data(const Protocol&) const
-  {
-    return &value_;
-  }
-
-  // Get the size of the int data.
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return sizeof(value_);
-  }
-
-  // Set the size of the int data.
-  template <typename Protocol>
-  void resize(const Protocol&, std::size_t s)
-  {
-    if (s != sizeof(value_))
-    {
-      std::length_error ex("integer socket option resize");
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-private:
-  int value_;
-};
-
-// Helper template for implementing linger options.
-template <int Level, int Name>
-class linger
-{
-public:
-  // Default constructor.
-  linger()
-  {
-    value_.l_onoff = 0;
-    value_.l_linger = 0;
-  }
-
-  // Construct with specific option values.
-  linger(bool e, int t)
-  {
-    enabled(e);
-    timeout ASIO_PREVENT_MACRO_SUBSTITUTION(t);
-  }
-
-  // Set the value for whether linger is enabled.
-  void enabled(bool value)
-  {
-    value_.l_onoff = value ? 1 : 0;
-  }
-
-  // Get the value for whether linger is enabled.
-  bool enabled() const
-  {
-    return value_.l_onoff != 0;
-  }
-
-  // Set the value for the linger timeout.
-  void timeout ASIO_PREVENT_MACRO_SUBSTITUTION(int value)
-  {
-#if defined(WIN32)
-    value_.l_linger = static_cast<u_short>(value);
-#else
-    value_.l_linger = value;
-#endif
-  }
-
-  // Get the value for the linger timeout.
-  int timeout ASIO_PREVENT_MACRO_SUBSTITUTION() const
-  {
-    return static_cast<int>(value_.l_linger);
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol&) const
-  {
-    return Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol&) const
-  {
-    return Name;
-  }
-
-  // Get the address of the linger data.
-  template <typename Protocol>
-  detail::linger_type* data(const Protocol&)
-  {
-    return &value_;
-  }
-
-  // Get the address of the linger data.
-  template <typename Protocol>
-  const detail::linger_type* data(const Protocol&) const
-  {
-    return &value_;
-  }
-
-  // Get the size of the linger data.
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return sizeof(value_);
-  }
-
-  // Set the size of the int data.
-  template <typename Protocol>
-  void resize(const Protocol&, std::size_t s)
-  {
-    if (s != sizeof(value_))
-    {
-      std::length_error ex("linger socket option resize");
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-private:
-  detail::linger_type value_;
-};
-
-} // namespace socket_option
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SOCKET_OPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_select_interrupter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_select_interrupter.hpp
deleted file mode 100644
index e243262..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_select_interrupter.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// detail/socket_select_interrupter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
-#define ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class socket_select_interrupter
-{
-public:
-  // Constructor.
-  ASIO_DECL socket_select_interrupter();
-
-  // Destructor.
-  ASIO_DECL ~socket_select_interrupter();
-
-  // Recreate the interrupter's descriptors. Used after a fork.
-  ASIO_DECL void recreate();
-
-  // Interrupt the select call.
-  ASIO_DECL void interrupt();
-
-  // Reset the select interrupter. Returns true if the reset was successful.
-  ASIO_DECL bool reset();
-
-  // Get the read descriptor to be passed to select.
-  socket_type read_descriptor() const
-  {
-    return read_descriptor_;
-  }
-
-private:
-  // Open the descriptors. Throws on error.
-  ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  ASIO_DECL void close_descriptors();
-
-  // The read end of a connection used to interrupt the select call. This file
-  // descriptor is passed to select such that when it is time to stop, a single
-  // byte will be written on the other end of the connection and this
-  // descriptor will become readable.
-  socket_type read_descriptor_;
-
-  // The write end of a connection used to interrupt the select call. A single
-  // byte may be written to this to wake up the select which is waiting for the
-  // other end to become readable.
-  socket_type write_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/socket_select_interrupter.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_types.hpp
deleted file mode 100644
index cf4f746..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/socket_types.hpp
+++ /dev/null
@@ -1,427 +0,0 @@
-//
-// detail/socket_types.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOCKET_TYPES_HPP
-#define ASIO_DETAIL_SOCKET_TYPES_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-// Empty.
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_)
-#  error WinSock.h has already been included
-# endif // defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_)
-# if defined(__BORLANDC__)
-#  include <stdlib.h> // Needed for __errno
-#  if !defined(_WSPIAPI_H_)
-#   define _WSPIAPI_H_
-#   define ASIO_WSPIAPI_H_DEFINED
-#  endif // !defined(_WSPIAPI_H_)
-# endif // defined(__BORLANDC__)
-# include <winsock2.h>
-# include <ws2tcpip.h>
-# if defined(WINAPI_FAMILY)
-#  if ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
-#   include <windows.h>
-#  endif // ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
-# endif // defined(WINAPI_FAMILY)
-# if !defined(ASIO_WINDOWS_APP)
-#  include <mswsock.h>
-# endif // !defined(ASIO_WINDOWS_APP)
-# if defined(ASIO_WSPIAPI_H_DEFINED)
-#  undef _WSPIAPI_H_
-#  undef ASIO_WSPIAPI_H_DEFINED
-# endif // defined(ASIO_WSPIAPI_H_DEFINED)
-# if !defined(ASIO_NO_DEFAULT_LINKED_LIBS)
-#  if defined(UNDER_CE)
-#   pragma comment(lib, "ws2.lib")
-#  elif defined(_MSC_VER) || defined(__BORLANDC__)
-#   pragma comment(lib, "ws2_32.lib")
-#   if !defined(ASIO_WINDOWS_APP)
-#    pragma comment(lib, "mswsock.lib")
-#   endif // !defined(ASIO_WINDOWS_APP)
-#  endif // defined(_MSC_VER) || defined(__BORLANDC__)
-# endif // !defined(ASIO_NO_DEFAULT_LINKED_LIBS)
-# include "asio/detail/old_win_sdk_compat.hpp"
-#else
-# include <sys/ioctl.h>
-# if (defined(__MACH__) && defined(__APPLE__)) \
-   || defined(__FreeBSD__) || defined(__NetBSD__) \
-   || defined(__OpenBSD__) || defined(__linux__) \
-   || defined(__EMSCRIPTEN__)
-#  include <poll.h>
-# elif !defined(__SYMBIAN32__)
-#  include <sys/poll.h>
-# endif
-# include <sys/types.h>
-# include <sys/stat.h>
-# include <fcntl.h>
-# if defined(__hpux)
-#  include <sys/time.h>
-# endif
-# if !defined(__hpux) || defined(__SELECT)
-#  include <sys/select.h>
-# endif
-# include <sys/socket.h>
-# include <sys/uio.h>
-# include <sys/un.h>
-# include <netinet/in.h>
-# if !defined(__SYMBIAN32__)
-#  include <netinet/tcp.h>
-# endif
-# include <arpa/inet.h>
-# include <netdb.h>
-# include <net/if.h>
-# include <limits.h>
-# if defined(__sun)
-#  include <sys/filio.h>
-#  include <sys/sockio.h>
-# endif
-# include <signal.h>
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-const int max_addr_v4_str_len = 256;
-const int max_addr_v6_str_len = 256;
-typedef unsigned __int32 u_long_type;
-typedef unsigned __int16 u_short_type;
-struct in4_addr_type { u_long_type s_addr; };
-struct in4_mreq_type { in4_addr_type imr_multiaddr, imr_interface; };
-struct in6_addr_type { unsigned char s6_addr[16]; };
-struct in6_mreq_type { in6_addr_type ipv6mr_multiaddr;
-  unsigned long ipv6mr_interface; };
-struct socket_addr_type { int sa_family; };
-struct sockaddr_in4_type { int sin_family;
-  in4_addr_type sin_addr; u_short_type sin_port; };
-struct sockaddr_in6_type { int sin6_family;
-  in6_addr_type sin6_addr; u_short_type sin6_port;
-  u_long_type sin6_flowinfo; u_long_type sin6_scope_id; };
-struct sockaddr_storage_type { int ss_family;
-  unsigned char ss_bytes[128 - sizeof(int)]; };
-struct addrinfo_type { int ai_flags;
-  int ai_family, ai_socktype, ai_protocol;
-  int ai_addrlen; const void* ai_addr;
-  const char* ai_canonname; addrinfo_type* ai_next; };
-struct linger_type { u_short_type l_onoff, l_linger; };
-typedef u_long_type ioctl_arg_type;
-typedef int signed_size_type;
-# define ASIO_OS_DEF(c) ASIO_OS_DEF_##c
-# define ASIO_OS_DEF_AF_UNSPEC 0
-# define ASIO_OS_DEF_AF_INET 2
-# define ASIO_OS_DEF_AF_INET6 23
-# define ASIO_OS_DEF_SOCK_STREAM 1
-# define ASIO_OS_DEF_SOCK_DGRAM 2
-# define ASIO_OS_DEF_SOCK_RAW 3
-# define ASIO_OS_DEF_SOCK_SEQPACKET 5
-# define ASIO_OS_DEF_IPPROTO_IP 0
-# define ASIO_OS_DEF_IPPROTO_IPV6 41
-# define ASIO_OS_DEF_IPPROTO_TCP 6
-# define ASIO_OS_DEF_IPPROTO_UDP 17
-# define ASIO_OS_DEF_IPPROTO_ICMP 1
-# define ASIO_OS_DEF_IPPROTO_ICMPV6 58
-# define ASIO_OS_DEF_FIONBIO 1
-# define ASIO_OS_DEF_FIONREAD 2
-# define ASIO_OS_DEF_INADDR_ANY 0
-# define ASIO_OS_DEF_MSG_OOB 0x1
-# define ASIO_OS_DEF_MSG_PEEK 0x2
-# define ASIO_OS_DEF_MSG_DONTROUTE 0x4
-# define ASIO_OS_DEF_MSG_EOR 0 // Not supported.
-# define ASIO_OS_DEF_SHUT_RD 0x0
-# define ASIO_OS_DEF_SHUT_WR 0x1
-# define ASIO_OS_DEF_SHUT_RDWR 0x2
-# define ASIO_OS_DEF_SOMAXCONN 0x7fffffff
-# define ASIO_OS_DEF_SOL_SOCKET 0xffff
-# define ASIO_OS_DEF_SO_BROADCAST 0x20
-# define ASIO_OS_DEF_SO_DEBUG 0x1
-# define ASIO_OS_DEF_SO_DONTROUTE 0x10
-# define ASIO_OS_DEF_SO_KEEPALIVE 0x8
-# define ASIO_OS_DEF_SO_LINGER 0x80
-# define ASIO_OS_DEF_SO_OOBINLINE 0x100
-# define ASIO_OS_DEF_SO_SNDBUF 0x1001
-# define ASIO_OS_DEF_SO_RCVBUF 0x1002
-# define ASIO_OS_DEF_SO_SNDLOWAT 0x1003
-# define ASIO_OS_DEF_SO_RCVLOWAT 0x1004
-# define ASIO_OS_DEF_SO_REUSEADDR 0x4
-# define ASIO_OS_DEF_TCP_NODELAY 0x1
-# define ASIO_OS_DEF_IP_MULTICAST_IF 2
-# define ASIO_OS_DEF_IP_MULTICAST_TTL 3
-# define ASIO_OS_DEF_IP_MULTICAST_LOOP 4
-# define ASIO_OS_DEF_IP_ADD_MEMBERSHIP 5
-# define ASIO_OS_DEF_IP_DROP_MEMBERSHIP 6
-# define ASIO_OS_DEF_IP_TTL 7
-# define ASIO_OS_DEF_IPV6_UNICAST_HOPS 4
-# define ASIO_OS_DEF_IPV6_MULTICAST_IF 9
-# define ASIO_OS_DEF_IPV6_MULTICAST_HOPS 10
-# define ASIO_OS_DEF_IPV6_MULTICAST_LOOP 11
-# define ASIO_OS_DEF_IPV6_JOIN_GROUP 12
-# define ASIO_OS_DEF_IPV6_LEAVE_GROUP 13
-# define ASIO_OS_DEF_AI_CANONNAME 0x2
-# define ASIO_OS_DEF_AI_PASSIVE 0x1
-# define ASIO_OS_DEF_AI_NUMERICHOST 0x4
-# define ASIO_OS_DEF_AI_NUMERICSERV 0x8
-# define ASIO_OS_DEF_AI_V4MAPPED 0x800
-# define ASIO_OS_DEF_AI_ALL 0x100
-# define ASIO_OS_DEF_AI_ADDRCONFIG 0x400
-# define ASIO_OS_DEF_SA_RESTART 0x1
-# define ASIO_OS_DEF_SA_NOCLDSTOP 0x2
-# define ASIO_OS_DEF_SA_NOCLDWAIT 0x4
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-typedef SOCKET socket_type;
-const SOCKET invalid_socket = INVALID_SOCKET;
-const int socket_error_retval = SOCKET_ERROR;
-const int max_addr_v4_str_len = 256;
-const int max_addr_v6_str_len = 256;
-typedef sockaddr socket_addr_type;
-typedef in_addr in4_addr_type;
-typedef ip_mreq in4_mreq_type;
-typedef sockaddr_in sockaddr_in4_type;
-# if defined(ASIO_HAS_OLD_WIN_SDK)
-typedef in6_addr_emulation in6_addr_type;
-typedef ipv6_mreq_emulation in6_mreq_type;
-typedef sockaddr_in6_emulation sockaddr_in6_type;
-typedef sockaddr_storage_emulation sockaddr_storage_type;
-typedef addrinfo_emulation addrinfo_type;
-# else
-typedef in6_addr in6_addr_type;
-typedef ipv6_mreq in6_mreq_type;
-typedef sockaddr_in6 sockaddr_in6_type;
-typedef sockaddr_storage sockaddr_storage_type;
-typedef addrinfo addrinfo_type;
-# endif
-typedef ::linger linger_type;
-typedef unsigned long ioctl_arg_type;
-typedef u_long u_long_type;
-typedef u_short u_short_type;
-typedef int signed_size_type;
-struct sockaddr_un_type { u_short sun_family; char sun_path[108]; };
-# define ASIO_OS_DEF(c) ASIO_OS_DEF_##c
-# define ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
-# define ASIO_OS_DEF_AF_INET AF_INET
-# define ASIO_OS_DEF_AF_INET6 AF_INET6
-# define ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
-# define ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
-# define ASIO_OS_DEF_SOCK_RAW SOCK_RAW
-# define ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
-# define ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
-# define ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
-# define ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
-# define ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
-# define ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
-# define ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
-# define ASIO_OS_DEF_FIONBIO FIONBIO
-# define ASIO_OS_DEF_FIONREAD FIONREAD
-# define ASIO_OS_DEF_INADDR_ANY INADDR_ANY
-# define ASIO_OS_DEF_MSG_OOB MSG_OOB
-# define ASIO_OS_DEF_MSG_PEEK MSG_PEEK
-# define ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
-# define ASIO_OS_DEF_MSG_EOR 0 // Not supported on Windows.
-# define ASIO_OS_DEF_SHUT_RD SD_RECEIVE
-# define ASIO_OS_DEF_SHUT_WR SD_SEND
-# define ASIO_OS_DEF_SHUT_RDWR SD_BOTH
-# define ASIO_OS_DEF_SOMAXCONN SOMAXCONN
-# define ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
-# define ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
-# define ASIO_OS_DEF_SO_DEBUG SO_DEBUG
-# define ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
-# define ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
-# define ASIO_OS_DEF_SO_LINGER SO_LINGER
-# define ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE
-# define ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
-# define ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
-# define ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
-# define ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
-# define ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
-# define ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
-# define ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
-# define ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
-# define ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
-# define ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
-# define ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
-# define ASIO_OS_DEF_IP_TTL IP_TTL
-# define ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
-# define ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
-# define ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
-# define ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
-# define ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
-# define ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
-# define ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
-# define ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
-# define ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
-# if defined(AI_NUMERICSERV)
-#  define ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
-# else
-#  define ASIO_OS_DEF_AI_NUMERICSERV 0
-# endif
-# if defined(AI_V4MAPPED)
-#  define ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
-# else
-#  define ASIO_OS_DEF_AI_V4MAPPED 0
-# endif
-# if defined(AI_ALL)
-#  define ASIO_OS_DEF_AI_ALL AI_ALL
-# else
-#  define ASIO_OS_DEF_AI_ALL 0
-# endif
-# if defined(AI_ADDRCONFIG)
-#  define ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
-# else
-#  define ASIO_OS_DEF_AI_ADDRCONFIG 0
-# endif
-# if defined (_WIN32_WINNT)
-const int max_iov_len = 64;
-# else
-const int max_iov_len = 16;
-# endif
-# define ASIO_OS_DEF_SA_RESTART 0x1
-# define ASIO_OS_DEF_SA_NOCLDSTOP 0x2
-# define ASIO_OS_DEF_SA_NOCLDWAIT 0x4
-#else
-typedef int socket_type;
-const int invalid_socket = -1;
-const int socket_error_retval = -1;
-const int max_addr_v4_str_len = INET_ADDRSTRLEN;
-#if defined(INET6_ADDRSTRLEN)
-const int max_addr_v6_str_len = INET6_ADDRSTRLEN + 1 + IF_NAMESIZE;
-#else // defined(INET6_ADDRSTRLEN)
-const int max_addr_v6_str_len = 256;
-#endif // defined(INET6_ADDRSTRLEN)
-typedef sockaddr socket_addr_type;
-typedef in_addr in4_addr_type;
-# if defined(__hpux)
-// HP-UX doesn't provide ip_mreq when _XOPEN_SOURCE_EXTENDED is defined.
-struct in4_mreq_type
-{
-  struct in_addr imr_multiaddr;
-  struct in_addr imr_interface;
-};
-# else
-typedef ip_mreq in4_mreq_type;
-# endif
-typedef sockaddr_in sockaddr_in4_type;
-typedef in6_addr in6_addr_type;
-typedef ipv6_mreq in6_mreq_type;
-typedef sockaddr_in6 sockaddr_in6_type;
-typedef sockaddr_storage sockaddr_storage_type;
-typedef sockaddr_un sockaddr_un_type;
-typedef addrinfo addrinfo_type;
-typedef ::linger linger_type;
-typedef int ioctl_arg_type;
-typedef uint32_t u_long_type;
-typedef uint16_t u_short_type;
-#if defined(ASIO_HAS_SSIZE_T)
-typedef ssize_t signed_size_type;
-#else // defined(ASIO_HAS_SSIZE_T)
-typedef int signed_size_type;
-#endif // defined(ASIO_HAS_SSIZE_T)
-# define ASIO_OS_DEF(c) ASIO_OS_DEF_##c
-# define ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
-# define ASIO_OS_DEF_AF_INET AF_INET
-# define ASIO_OS_DEF_AF_INET6 AF_INET6
-# define ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
-# define ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
-# define ASIO_OS_DEF_SOCK_RAW SOCK_RAW
-# define ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
-# define ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
-# define ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
-# define ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
-# define ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
-# define ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
-# define ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
-# define ASIO_OS_DEF_FIONBIO FIONBIO
-# define ASIO_OS_DEF_FIONREAD FIONREAD
-# define ASIO_OS_DEF_INADDR_ANY INADDR_ANY
-# define ASIO_OS_DEF_MSG_OOB MSG_OOB
-# define ASIO_OS_DEF_MSG_PEEK MSG_PEEK
-# define ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
-# define ASIO_OS_DEF_MSG_EOR MSG_EOR
-# define ASIO_OS_DEF_SHUT_RD SHUT_RD
-# define ASIO_OS_DEF_SHUT_WR SHUT_WR
-# define ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR
-# define ASIO_OS_DEF_SOMAXCONN SOMAXCONN
-# define ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
-# define ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
-# define ASIO_OS_DEF_SO_DEBUG SO_DEBUG
-# define ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
-# define ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
-# define ASIO_OS_DEF_SO_LINGER SO_LINGER
-# define ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE
-# define ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
-# define ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
-# define ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
-# define ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
-# define ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
-# define ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
-# define ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
-# define ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
-# define ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
-# define ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
-# define ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
-# define ASIO_OS_DEF_IP_TTL IP_TTL
-# define ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
-# define ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
-# define ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
-# define ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
-# define ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
-# define ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
-# define ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
-# define ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
-# define ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
-# if defined(AI_NUMERICSERV)
-#  define ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
-# else
-#  define ASIO_OS_DEF_AI_NUMERICSERV 0
-# endif
-// Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but
-// does not implement them. Therefore they are specifically excluded here.
-# if defined(AI_V4MAPPED) && !defined(__QNXNTO__)
-#  define ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
-# else
-#  define ASIO_OS_DEF_AI_V4MAPPED 0
-# endif
-# if defined(AI_ALL) && !defined(__QNXNTO__)
-#  define ASIO_OS_DEF_AI_ALL AI_ALL
-# else
-#  define ASIO_OS_DEF_AI_ALL 0
-# endif
-# if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__)
-#  define ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
-# else
-#  define ASIO_OS_DEF_AI_ADDRCONFIG 0
-# endif
-# if defined(IOV_MAX)
-const int max_iov_len = IOV_MAX;
-# else
-// POSIX platforms are not required to define IOV_MAX.
-const int max_iov_len = 16;
-# endif
-# define ASIO_OS_DEF_SA_RESTART SA_RESTART
-# define ASIO_OS_DEF_SA_NOCLDSTOP SA_NOCLDSTOP
-# define ASIO_OS_DEF_SA_NOCLDWAIT SA_NOCLDWAIT
-#endif
-const int custom_socket_option_level = 0xA5100000;
-const int enable_connection_aborted_option = 1;
-const int always_fail_option = 2;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_SOCKET_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/source_location.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/source_location.hpp
deleted file mode 100644
index 14b74f9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/source_location.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// detail/source_location.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_SOURCE_LOCATION_HPP
-#define ASIO_DETAIL_SOURCE_LOCATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SOURCE_LOCATION)
-
-#if defined(ASIO_HAS_STD_SOURCE_LOCATION)
-# include <source_location>
-#elif defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-# include <experimental/source_location>
-#else // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-# error ASIO_HAS_SOURCE_LOCATION is set \
-  but no source_location is available
-#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_SOURCE_LOCATION)
-using std::source_location;
-#elif defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-using std::experimental::source_location;
-#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION)
-
-} // namespace detail
-} // namespace asio
-
-#endif // defined(ASIO_HAS_SOURCE_LOCATION)
-
-#endif // ASIO_DETAIL_SOURCE_LOCATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/static_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/static_mutex.hpp
deleted file mode 100644
index b47d087..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/static_mutex.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// detail/static_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STATIC_MUTEX_HPP
-#define ASIO_DETAIL_STATIC_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_static_mutex.hpp"
-#elif defined(ASIO_WINDOWS)
-# include "asio/detail/win_static_mutex.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_static_mutex.hpp"
-#else
-# include "asio/detail/std_static_mutex.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS)
-typedef null_static_mutex static_mutex;
-# define ASIO_STATIC_MUTEX_INIT ASIO_NULL_STATIC_MUTEX_INIT
-#elif defined(ASIO_WINDOWS)
-typedef win_static_mutex static_mutex;
-# define ASIO_STATIC_MUTEX_INIT ASIO_WIN_STATIC_MUTEX_INIT
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_static_mutex static_mutex;
-# define ASIO_STATIC_MUTEX_INIT ASIO_POSIX_STATIC_MUTEX_INIT
-#else
-typedef std_static_mutex static_mutex;
-# define ASIO_STATIC_MUTEX_INIT ASIO_STD_STATIC_MUTEX_INIT
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_STATIC_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_event.hpp
deleted file mode 100644
index 97a347e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_event.hpp
+++ /dev/null
@@ -1,183 +0,0 @@
-//
-// detail/std_event.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_EVENT_HPP
-#define ASIO_DETAIL_STD_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <chrono>
-#include <condition_variable>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class std_event
-  : private noncopyable
-{
-public:
-  // Constructor.
-  std_event()
-    : state_(0)
-  {
-  }
-
-  // Destructor.
-  ~std_event()
-  {
-  }
-
-  // Signal the event. (Retained for backward compatibility.)
-  template <typename Lock>
-  void signal(Lock& lock)
-  {
-    this->signal_all(lock);
-  }
-
-  // Signal all waiters.
-  template <typename Lock>
-  void signal_all(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    state_ |= 1;
-    cond_.notify_all();
-  }
-
-  // Unlock the mutex and signal one waiter.
-  template <typename Lock>
-  void unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    lock.unlock();
-    if (have_waiters)
-      cond_.notify_one();
-  }
-
-  // Unlock the mutex and signal one waiter who may destroy us.
-  template <typename Lock>
-  void unlock_and_signal_one_for_destruction(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    if (have_waiters)
-      cond_.notify_one();
-    lock.unlock();
-  }
-
-  // If there's a waiter, unlock the mutex and signal it.
-  template <typename Lock>
-  bool maybe_unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    if (state_ > 1)
-    {
-      lock.unlock();
-      cond_.notify_one();
-      return true;
-    }
-    return false;
-  }
-
-  // Reset the event.
-  template <typename Lock>
-  void clear(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    state_ &= ~std::size_t(1);
-  }
-
-  // Wait for the event to become signalled.
-  template <typename Lock>
-  void wait(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    unique_lock_adapter u_lock(lock);
-    while ((state_ & 1) == 0)
-    {
-      waiter w(state_);
-      cond_.wait(u_lock.unique_lock_);
-    }
-  }
-
-  // Timed wait for the event to become signalled.
-  template <typename Lock>
-  bool wait_for_usec(Lock& lock, long usec)
-  {
-    ASIO_ASSERT(lock.locked());
-    unique_lock_adapter u_lock(lock);
-    if ((state_ & 1) == 0)
-    {
-      waiter w(state_);
-      cond_.wait_for(u_lock.unique_lock_, std::chrono::microseconds(usec));
-    }
-    return (state_ & 1) != 0;
-  }
-
-private:
-  // Helper class to temporarily adapt a scoped_lock into a unique_lock so that
-  // it can be passed to std::condition_variable::wait().
-  struct unique_lock_adapter
-  {
-    template <typename Lock>
-    explicit unique_lock_adapter(Lock& lock)
-      : unique_lock_(lock.mutex().mutex_, std::adopt_lock)
-    {
-    }
-
-    ~unique_lock_adapter()
-    {
-      unique_lock_.release();
-    }
-
-    std::unique_lock<std::mutex> unique_lock_;
-  };
-
-  // Helper to increment and decrement the state to track outstanding waiters.
-  class waiter
-  {
-  public:
-    explicit waiter(std::size_t& state)
-      : state_(state)
-    {
-      state_ += 2;
-    }
-
-    ~waiter()
-    {
-      state_ -= 2;
-    }
-
-  private:
-    std::size_t& state_;
-  };
-
-  std::condition_variable cond_;
-  std::size_t state_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_fenced_block.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_fenced_block.hpp
deleted file mode 100644
index d1e0c60..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_fenced_block.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//
-// detail/std_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_STD_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <atomic>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class std_fenced_block
-  : private noncopyable
-{
-public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit std_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit std_fenced_block(full_t)
-  {
-    std::atomic_thread_fence(std::memory_order_acquire);
-  }
-
-  // Destructor.
-  ~std_fenced_block()
-  {
-    std::atomic_thread_fence(std::memory_order_release);
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_FENCED_BLOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_global.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_global.hpp
deleted file mode 100644
index 49ae055..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_global.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// detail/std_global.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_GLOBAL_HPP
-#define ASIO_DETAIL_STD_GLOBAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-#include <mutex>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct std_global_impl
-{
-  // Helper function to perform initialisation.
-  static void do_init()
-  {
-    instance_.ptr_ = new T;
-  }
-
-  // Destructor automatically cleans up the global.
-  ~std_global_impl()
-  {
-    delete ptr_;
-  }
-
-  static std::once_flag init_once_;
-  static std_global_impl instance_;
-  T* ptr_;
-};
-
-template <typename T>
-std::once_flag std_global_impl<T>::init_once_;
-
-template <typename T>
-std_global_impl<T> std_global_impl<T>::instance_;
-
-template <typename T>
-T& std_global()
-{
-  std::call_once(std_global_impl<T>::init_once_, &std_global_impl<T>::do_init);
-  return *std_global_impl<T>::instance_.ptr_;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_GLOBAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_mutex.hpp
deleted file mode 100644
index 06839d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_mutex.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// detail/std_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_MUTEX_HPP
-#define ASIO_DETAIL_STD_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <mutex>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class std_event;
-
-class std_mutex
-  : private noncopyable
-{
-public:
-  typedef asio::detail::scoped_lock<std_mutex> scoped_lock;
-
-  // Constructor.
-  std_mutex()
-  {
-  }
-
-  // Destructor.
-  ~std_mutex()
-  {
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    mutex_.lock();
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    mutex_.unlock();
-  }
-
-private:
-  friend class std_event;
-  std::mutex mutex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_static_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_static_mutex.hpp
deleted file mode 100644
index 302b729..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_static_mutex.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// detail/std_static_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_STATIC_MUTEX_HPP
-#define ASIO_DETAIL_STD_STATIC_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <mutex>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class std_event;
-
-class std_static_mutex
-  : private noncopyable
-{
-public:
-  typedef asio::detail::scoped_lock<std_static_mutex> scoped_lock;
-
-  // Constructor.
-  std_static_mutex(int)
-  {
-  }
-
-  // Destructor.
-  ~std_static_mutex()
-  {
-  }
-
-  // Initialise the mutex.
-  void init()
-  {
-    // Nothing to do.
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    mutex_.lock();
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    mutex_.unlock();
-  }
-
-private:
-  friend class std_event;
-  std::mutex mutex_;
-};
-
-#define ASIO_STD_STATIC_MUTEX_INIT 0
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_STATIC_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_thread.hpp
deleted file mode 100644
index 78bbab9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/std_thread.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// detail/std_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STD_THREAD_HPP
-#define ASIO_DETAIL_STD_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <thread>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class std_thread
-  : private noncopyable
-{
-public:
-  // Constructor.
-  template <typename Function>
-  std_thread(Function f, unsigned int = 0)
-    : thread_(f)
-  {
-  }
-
-  // Destructor.
-  ~std_thread()
-  {
-    join();
-  }
-
-  // Wait for the thread to exit.
-  void join()
-  {
-    if (thread_.joinable())
-      thread_.join();
-  }
-
-  // Get number of CPUs.
-  static std::size_t hardware_concurrency()
-  {
-    return std::thread::hardware_concurrency();
-  }
-
-private:
-  std::thread thread_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_STD_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_executor_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_executor_service.hpp
deleted file mode 100644
index 45536ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_executor_service.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-//
-// detail/strand_executor_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
-#define ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/scheduler_operation.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Default service implementation for a strand.
-class strand_executor_service
-  : public execution_context_service_base<strand_executor_service>
-{
-public:
-  // The underlying implementation of a strand.
-  class strand_impl
-  {
-  public:
-    ASIO_DECL ~strand_impl();
-
-  private:
-    friend class strand_executor_service;
-
-    // Mutex to protect access to internal data.
-    mutex* mutex_;
-
-    // Indicates whether the strand is currently "locked" by a handler. This
-    // means that there is a handler upcall in progress, or that the strand
-    // itself has been scheduled in order to invoke some pending handlers.
-    bool locked_;
-
-    // Indicates that the strand has been shut down and will accept no further
-    // handlers.
-    bool shutdown_;
-
-    // The handlers that are waiting on the strand but should not be run until
-    // after the next time the strand is scheduled. This queue must only be
-    // modified while the mutex is locked.
-    op_queue<scheduler_operation> waiting_queue_;
-
-    // The handlers that are ready to be run. Logically speaking, these are the
-    // handlers that hold the strand's lock. The ready queue is only modified
-    // from within the strand and so may be accessed without locking the mutex.
-    op_queue<scheduler_operation> ready_queue_;
-
-    // Pointers to adjacent handle implementations in linked list.
-    strand_impl* next_;
-    strand_impl* prev_;
-
-    // The strand service in where the implementation is held.
-    strand_executor_service* service_;
-  };
-
-  typedef shared_ptr<strand_impl> implementation_type;
-
-  // Construct a new strand service for the specified context.
-  ASIO_DECL explicit strand_executor_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Create a new strand_executor implementation.
-  ASIO_DECL implementation_type create_implementation();
-
-  // Request invocation of the given function.
-  template <typename Executor, typename Function>
-  static void execute(const implementation_type& impl, Executor& ex,
-      Function&& function,
-      enable_if_t<
-        can_query<Executor, execution::allocator_t<void>>::value
-      >* = 0);
-
-  // Request invocation of the given function.
-  template <typename Executor, typename Function>
-  static void execute(const implementation_type& impl, Executor& ex,
-      Function&& function,
-      enable_if_t<
-        !can_query<Executor, execution::allocator_t<void>>::value
-      >* = 0);
-
-  // Request invocation of the given function.
-  template <typename Executor, typename Function, typename Allocator>
-  static void dispatch(const implementation_type& impl, Executor& ex,
-      Function&& function, const Allocator& a);
-
-  // Request invocation of the given function and return immediately.
-  template <typename Executor, typename Function, typename Allocator>
-  static void post(const implementation_type& impl, Executor& ex,
-      Function&& function, const Allocator& a);
-
-  // Request invocation of the given function and return immediately.
-  template <typename Executor, typename Function, typename Allocator>
-  static void defer(const implementation_type& impl, Executor& ex,
-      Function&& function, const Allocator& a);
-
-  // Determine whether the strand is running in the current thread.
-  ASIO_DECL static bool running_in_this_thread(
-      const implementation_type& impl);
-
-private:
-  friend class strand_impl;
-  template <typename F, typename Allocator> class allocator_binder;
-  template <typename Executor, typename = void> class invoker;
-
-  // Adds a function to the strand. Returns true if it acquires the lock.
-  ASIO_DECL static bool enqueue(const implementation_type& impl,
-      scheduler_operation* op);
-
-  // Transfers waiting handlers to the ready queue. Returns true if one or more
-  // handlers were transferred.
-  ASIO_DECL static bool push_waiting_to_ready(implementation_type& impl);
-
-  // Invokes all ready-to-run handlers.
-  ASIO_DECL static void run_ready_handlers(implementation_type& impl);
-
-  // Helper function to request invocation of the given function.
-  template <typename Executor, typename Function, typename Allocator>
-  static void do_execute(const implementation_type& impl, Executor& ex,
-      Function&& function, const Allocator& a);
-
-  // Mutex to protect access to the service-wide state.
-  mutex mutex_;
-
-  // Number of mutexes shared between all strand objects.
-  enum { num_mutexes = 193 };
-
-  // Pool of mutexes.
-  scoped_ptr<mutex> mutexes_[num_mutexes];
-
-  // Extra value used when hashing to prevent recycled memory locations from
-  // getting the same mutex.
-  std::size_t salt_;
-
-  // The head of a linked list of all implementations.
-  strand_impl* impl_list_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/strand_executor_service.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/strand_executor_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_service.hpp
deleted file mode 100644
index 084eb0b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/strand_service.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-//
-// detail/strand_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STRAND_SERVICE_HPP
-#define ASIO_DETAIL_STRAND_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/io_context.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Default service implementation for a strand.
-class strand_service
-  : public asio::detail::service_base<strand_service>
-{
-private:
-  // Helper class to re-post the strand on exit.
-  struct on_do_complete_exit;
-
-  // Helper class to re-post the strand on exit.
-  struct on_dispatch_exit;
-
-public:
-
-  // The underlying implementation of a strand.
-  class strand_impl
-    : public operation
-  {
-  public:
-    strand_impl();
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class strand_service;
-    friend struct on_do_complete_exit;
-    friend struct on_dispatch_exit;
-
-    // Mutex to protect access to internal data.
-    asio::detail::mutex mutex_;
-
-    // Indicates whether the strand is currently "locked" by a handler. This
-    // means that there is a handler upcall in progress, or that the strand
-    // itself has been scheduled in order to invoke some pending handlers.
-    bool locked_;
-
-    // The handlers that are waiting on the strand but should not be run until
-    // after the next time the strand is scheduled. This queue must only be
-    // modified while the mutex is locked.
-    op_queue<operation> waiting_queue_;
-
-    // The handlers that are ready to be run. Logically speaking, these are the
-    // handlers that hold the strand's lock. The ready queue is only modified
-    // from within the strand and so may be accessed without locking the mutex.
-    op_queue<operation> ready_queue_;
-  };
-
-  typedef strand_impl* implementation_type;
-
-  // Construct a new strand service for the specified io_context.
-  ASIO_DECL explicit strand_service(asio::io_context& io_context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new strand implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Request the io_context to invoke the given handler.
-  template <typename Handler>
-  void dispatch(implementation_type& impl, Handler& handler);
-
-  // Request the io_context to invoke the given handler and return immediately.
-  template <typename Handler>
-  void post(implementation_type& impl, Handler& handler);
-
-  // Determine whether the strand is running in the current thread.
-  ASIO_DECL bool running_in_this_thread(
-      const implementation_type& impl) const;
-
-private:
-  // Helper function to dispatch a handler.
-  ASIO_DECL void do_dispatch(implementation_type& impl, operation* op);
-
-  // Helper function to post a handler.
-  ASIO_DECL void do_post(implementation_type& impl,
-      operation* op, bool is_continuation);
-
-  ASIO_DECL static void do_complete(void* owner,
-      operation* base, const asio::error_code& ec,
-      std::size_t bytes_transferred);
-
-  // The io_context used to obtain an I/O executor.
-  io_context& io_context_;
-
-  // The io_context implementation used to post completions.
-  io_context_impl& io_context_impl_;
-
-  // Mutex to protect access to the array of implementations.
-  asio::detail::mutex mutex_;
-
-  // Number of implementations shared between all strand objects.
-#if defined(ASIO_STRAND_IMPLEMENTATIONS)
-  enum { num_implementations = ASIO_STRAND_IMPLEMENTATIONS };
-#else // defined(ASIO_STRAND_IMPLEMENTATIONS)
-  enum { num_implementations = 193 };
-#endif // defined(ASIO_STRAND_IMPLEMENTATIONS)
-
-  // Pool of implementations.
-  scoped_ptr<strand_impl> implementations_[num_implementations];
-
-  // Extra value used when hashing to prevent recycled memory locations from
-  // getting the same strand implementation.
-  std::size_t salt_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/strand_service.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/strand_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_STRAND_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/string_view.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/string_view.hpp
deleted file mode 100644
index a4470f1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/string_view.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// detail/string_view.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_STRING_VIEW_HPP
-#define ASIO_DETAIL_STRING_VIEW_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-#if defined(ASIO_HAS_STD_STRING_VIEW)
-# include <string_view>
-#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-# include <experimental/string_view>
-#else // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-# error ASIO_HAS_STRING_VIEW is set but no string_view is available
-#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-
-namespace asio {
-
-#if defined(ASIO_HAS_STD_STRING_VIEW)
-using std::basic_string_view;
-using std::string_view;
-#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-using std::experimental::basic_string_view;
-using std::experimental::string_view;
-#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-
-} // namespace asio
-
-# define ASIO_STRING_VIEW_PARAM asio::string_view
-#else // defined(ASIO_HAS_STRING_VIEW)
-# define ASIO_STRING_VIEW_PARAM const std::string&
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-#endif // ASIO_DETAIL_STRING_VIEW_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread.hpp
deleted file mode 100644
index faa7fad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// detail/thread.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THREAD_HPP
-#define ASIO_DETAIL_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_thread.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_thread.hpp"
-#elif defined(ASIO_WINDOWS)
-# if defined(UNDER_CE)
-#  include "asio/detail/wince_thread.hpp"
-# elif defined(ASIO_WINDOWS_APP)
-#  include "asio/detail/winapp_thread.hpp"
-# else
-#  include "asio/detail/win_thread.hpp"
-# endif
-#else
-# include "asio/detail/std_thread.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_HAS_THREADS)
-typedef null_thread thread;
-#elif defined(ASIO_HAS_PTHREADS)
-typedef posix_thread thread;
-#elif defined(ASIO_WINDOWS)
-# if defined(UNDER_CE)
-typedef wince_thread thread;
-# elif defined(ASIO_WINDOWS_APP)
-typedef winapp_thread thread;
-# else
-typedef win_thread thread;
-# endif
-#else
-typedef std_thread thread;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_context.hpp
deleted file mode 100644
index bebfc4a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_context.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// detail/thread_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THREAD_CONTEXT_HPP
-#define ASIO_DETAIL_THREAD_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <climits>
-#include <cstddef>
-#include "asio/detail/call_stack.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class thread_info_base;
-
-// Base class for things that manage threads (scheduler, win_iocp_io_context).
-class thread_context
-{
-public:
-  // Obtain a pointer to the top of the thread call stack. Returns null when
-  // not running inside a thread context.
-  ASIO_DECL static thread_info_base* top_of_thread_call_stack();
-
-protected:
-  // Per-thread call stack to track the state of each thread in the context.
-  typedef call_stack<thread_context, thread_info_base> thread_call_stack;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/thread_context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_THREAD_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_group.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_group.hpp
deleted file mode 100644
index 5ebff5e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_group.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//
-// detail/thread_group.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THREAD_GROUP_HPP
-#define ASIO_DETAIL_THREAD_GROUP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/thread.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class thread_group
-{
-public:
-  // Constructor initialises an empty thread group.
-  thread_group()
-    : first_(0)
-  {
-  }
-
-  // Destructor joins any remaining threads in the group.
-  ~thread_group()
-  {
-    join();
-  }
-
-  // Create a new thread in the group.
-  template <typename Function>
-  void create_thread(Function f)
-  {
-    first_ = new item(f, first_);
-  }
-
-  // Create new threads in the group.
-  template <typename Function>
-  void create_threads(Function f, std::size_t num_threads)
-  {
-    for (std::size_t i = 0; i < num_threads; ++i)
-      create_thread(f);
-  }
-
-  // Wait for all threads in the group to exit.
-  void join()
-  {
-    while (first_)
-    {
-      first_->thread_.join();
-      item* tmp = first_;
-      first_ = first_->next_;
-      delete tmp;
-    }
-  }
-
-  // Test whether the group is empty.
-  bool empty() const
-  {
-    return first_ == 0;
-  }
-
-private:
-  // Structure used to track a single thread in the group.
-  struct item
-  {
-    template <typename Function>
-    explicit item(Function f, item* next)
-      : thread_(f),
-        next_(next)
-    {
-    }
-
-    asio::detail::thread thread_;
-    item* next_;
-  };
-
-  // The first thread in the group.
-  item* first_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_THREAD_GROUP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_info_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_info_base.hpp
deleted file mode 100644
index 66cb1af..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/thread_info_base.hpp
+++ /dev/null
@@ -1,260 +0,0 @@
-//
-// detail/thread_info_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THREAD_INFO_BASE_HPP
-#define ASIO_DETAIL_THREAD_INFO_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <climits>
-#include <cstddef>
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-# include <exception>
-# include "asio/multiple_exceptions.hpp"
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#ifndef ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
-# define ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE 2
-#endif // ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
-
-class thread_info_base
-  : private noncopyable
-{
-public:
-  struct default_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = 0,
-      end_mem_index = cache_size
-    };
-  };
-
-  struct awaitable_frame_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = default_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-
-  struct executor_function_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = awaitable_frame_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-
-  struct cancellation_signal_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = executor_function_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-
-  struct parallel_group_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = cancellation_signal_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-
-  struct timed_cancel_tag
-  {
-    enum
-    {
-      cache_size = ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE,
-      begin_mem_index = parallel_group_tag::end_mem_index,
-      end_mem_index = begin_mem_index + cache_size
-    };
-  };
-
-  enum { max_mem_index = timed_cancel_tag::end_mem_index };
-
-  thread_info_base()
-#if !defined(ASIO_NO_EXCEPTIONS)
-    : has_pending_exception_(0)
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  {
-    for (int i = 0; i < max_mem_index; ++i)
-      reusable_memory_[i] = 0;
-  }
-
-  ~thread_info_base()
-  {
-    for (int i = 0; i < max_mem_index; ++i)
-    {
-      // The following test for non-null pointers is technically redundant, but
-      // it is significantly faster when using a tight io_context::poll() loop
-      // in latency sensitive applications.
-      if (reusable_memory_[i])
-        aligned_delete(reusable_memory_[i]);
-    }
-  }
-
-  static void* allocate(thread_info_base* this_thread,
-      std::size_t size, std::size_t align = ASIO_DEFAULT_ALIGN)
-  {
-    return allocate(default_tag(), this_thread, size, align);
-  }
-
-  static void deallocate(thread_info_base* this_thread,
-      void* pointer, std::size_t size)
-  {
-    deallocate(default_tag(), this_thread, pointer, size);
-  }
-
-  template <typename Purpose>
-  static void* allocate(Purpose, thread_info_base* this_thread,
-      std::size_t size, std::size_t align = ASIO_DEFAULT_ALIGN)
-  {
-    std::size_t chunks = (size + chunk_size - 1) / chunk_size;
-
-    if (this_thread)
-    {
-      for (int mem_index = Purpose::begin_mem_index;
-          mem_index < Purpose::end_mem_index; ++mem_index)
-      {
-        if (this_thread->reusable_memory_[mem_index])
-        {
-          void* const pointer = this_thread->reusable_memory_[mem_index];
-          unsigned char* const mem = static_cast<unsigned char*>(pointer);
-          if (static_cast<std::size_t>(mem[0]) >= chunks
-              && reinterpret_cast<std::size_t>(pointer) % align == 0)
-          {
-            this_thread->reusable_memory_[mem_index] = 0;
-            mem[size] = mem[0];
-            return pointer;
-          }
-        }
-      }
-
-      for (int mem_index = Purpose::begin_mem_index;
-          mem_index < Purpose::end_mem_index; ++mem_index)
-      {
-        if (this_thread->reusable_memory_[mem_index])
-        {
-          void* const pointer = this_thread->reusable_memory_[mem_index];
-          this_thread->reusable_memory_[mem_index] = 0;
-          aligned_delete(pointer);
-          break;
-        }
-      }
-    }
-
-    void* const pointer = aligned_new(align, chunks * chunk_size + 1);
-    unsigned char* const mem = static_cast<unsigned char*>(pointer);
-    mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0;
-    return pointer;
-  }
-
-  template <typename Purpose>
-  static void deallocate(Purpose, thread_info_base* this_thread,
-      void* pointer, std::size_t size)
-  {
-    if (size <= chunk_size * UCHAR_MAX)
-    {
-      if (this_thread)
-      {
-        for (int mem_index = Purpose::begin_mem_index;
-            mem_index < Purpose::end_mem_index; ++mem_index)
-        {
-          if (this_thread->reusable_memory_[mem_index] == 0)
-          {
-            unsigned char* const mem = static_cast<unsigned char*>(pointer);
-            mem[0] = mem[size];
-            this_thread->reusable_memory_[mem_index] = pointer;
-            return;
-          }
-        }
-      }
-    }
-
-    aligned_delete(pointer);
-  }
-
-  void capture_current_exception()
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    switch (has_pending_exception_)
-    {
-    case 0:
-      has_pending_exception_ = 1;
-      pending_exception_ = std::current_exception();
-      break;
-    case 1:
-      has_pending_exception_ = 2;
-      pending_exception_ =
-        std::make_exception_ptr<multiple_exceptions>(
-            multiple_exceptions(pending_exception_));
-      break;
-    default:
-      break;
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  void rethrow_pending_exception()
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    if (has_pending_exception_ > 0)
-    {
-      has_pending_exception_ = 0;
-      std::exception_ptr ex(
-          static_cast<std::exception_ptr&&>(
-            pending_exception_));
-      std::rethrow_exception(ex);
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-private:
-#if defined(ASIO_HAS_IO_URING)
-  enum { chunk_size = 8 };
-#else // defined(ASIO_HAS_IO_URING)
-  enum { chunk_size = 4 };
-#endif // defined(ASIO_HAS_IO_URING)
-  void* reusable_memory_[max_mem_index];
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-  int has_pending_exception_;
-  std::exception_ptr pending_exception_;
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_THREAD_INFO_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_error.hpp
deleted file mode 100644
index 881c312..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_error.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// detail/throw_error.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THROW_ERROR_HPP
-#define ASIO_DETAIL_THROW_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-ASIO_DECL void do_throw_error(
-    const asio::error_code& err
-    ASIO_SOURCE_LOCATION_PARAM);
-
-ASIO_DECL void do_throw_error(
-    const asio::error_code& err,
-    const char* location
-    ASIO_SOURCE_LOCATION_PARAM);
-
-inline void throw_error(
-    const asio::error_code& err
-    ASIO_SOURCE_LOCATION_DEFAULTED_PARAM)
-{
-  if (err)
-    do_throw_error(err ASIO_SOURCE_LOCATION_ARG);
-}
-
-inline void throw_error(
-    const asio::error_code& err,
-    const char* location
-    ASIO_SOURCE_LOCATION_DEFAULTED_PARAM)
-{
-  if (err)
-    do_throw_error(err, location ASIO_SOURCE_LOCATION_ARG);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/throw_error.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_THROW_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_exception.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_exception.hpp
deleted file mode 100644
index e939c10..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/throw_exception.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// detail/throw_exception.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_THROW_EXCEPTION_HPP
-#define ASIO_DETAIL_THROW_EXCEPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-# include <boost/throw_exception.hpp>
-#endif // defined(ASIO_BOOST_THROW_EXCEPTION)
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-using boost::throw_exception;
-#else // defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-
-// Declare the throw_exception function for all targets.
-template <typename Exception>
-void throw_exception(
-    const Exception& e
-    ASIO_SOURCE_LOCATION_DEFAULTED_PARAM);
-
-// Only define the throw_exception function when exceptions are enabled.
-// Otherwise, it is up to the application to provide a definition of this
-// function.
-# if !defined(ASIO_NO_EXCEPTIONS)
-template <typename Exception>
-void throw_exception(
-    const Exception& e
-    ASIO_SOURCE_LOCATION_PARAM)
-{
-  throw e;
-}
-# endif // !defined(ASIO_NO_EXCEPTIONS)
-
-#endif // defined(ASIO_HAS_BOOST_THROW_EXCEPTION)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_THROW_EXCEPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timed_cancel_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timed_cancel_op.hpp
deleted file mode 100644
index 2d170ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timed_cancel_op.hpp
+++ /dev/null
@@ -1,361 +0,0 @@
-//
-// detail/timed_cancel_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMED_CANCEL_OP_HPP
-#define ASIO_DETAIL_TIMED_CANCEL_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associator.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/completion_payload.hpp"
-#include "asio/detail/completion_payload_handler.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Op, typename... Signatures>
-class timed_cancel_op_handler;
-
-template <typename Op>
-class timed_cancel_timer_handler;
-
-template <typename Handler, typename Timer, typename... Signatures>
-class timed_cancel_op
-{
-public:
-  using handler_type = Handler;
-
-  ASIO_DEFINE_TAGGED_HANDLER_PTR(
-      thread_info_base::timed_cancel_tag, timed_cancel_op);
-
-  timed_cancel_op(Handler& handler, Timer timer,
-      cancellation_type_t cancel_type)
-    : ref_count_(2),
-      handler_(static_cast<Handler&&>(handler)),
-      timer_(static_cast<Timer&&>(timer)),
-      cancellation_type_(cancel_type),
-      cancel_proxy_(nullptr),
-      has_payload_(false),
-      has_pending_timer_wait_(true)
-  {
-  }
-
-  ~timed_cancel_op()
-  {
-    if (has_payload_)
-      payload_storage_.payload_.~payload_type();
-  }
-
-  cancellation_slot get_cancellation_slot() noexcept
-  {
-    return cancellation_signal_.slot();
-  }
-
-  template <typename Initiation, typename... Args>
-  void start(Initiation&& initiation, Args&&... args)
-  {
-    using op_handler_type =
-      timed_cancel_op_handler<timed_cancel_op, Signatures...>;
-    op_handler_type op_handler(this);
-
-    using timer_handler_type =
-      timed_cancel_timer_handler<timed_cancel_op>;
-    timer_handler_type timer_handler(this);
-
-    associated_cancellation_slot_t<Handler> slot
-      = (get_associated_cancellation_slot)(handler_);
-    if (slot.is_connected())
-      cancel_proxy_ = &slot.template emplace<cancel_proxy>(this);
-
-    timer_.async_wait(static_cast<timer_handler_type&&>(timer_handler));
-    async_initiate<op_handler_type, Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        static_cast<op_handler_type&>(op_handler),
-        static_cast<Args&&>(args)...);
-  }
-
-  template <typename Message>
-  void handle_op(Message&& message)
-  {
-    if (cancel_proxy_)
-      cancel_proxy_->op_ = nullptr;
-
-    new (&payload_storage_.payload_) payload_type(
-        static_cast<Message&&>(message));
-    has_payload_ = true;
-
-    if (has_pending_timer_wait_)
-    {
-      timer_.cancel();
-      release();
-    }
-    else
-    {
-      complete();
-    }
-  }
-
-  void handle_timer()
-  {
-    has_pending_timer_wait_ = false;
-
-    if (has_payload_)
-    {
-      complete();
-    }
-    else
-    {
-      cancellation_signal_.emit(cancellation_type_);
-      release();
-    }
-  }
-
-  void release()
-  {
-    if (--ref_count_ == 0)
-    {
-      ptr p = { asio::detail::addressof(handler_), this, this };
-      Handler handler(static_cast<Handler&&>(handler_));
-      p.h = asio::detail::addressof(handler);
-      p.reset();
-    }
-  }
-
-  void complete()
-  {
-    if (--ref_count_ == 0)
-    {
-      ptr p = { asio::detail::addressof(handler_), this, this };
-      completion_payload_handler<payload_type, Handler> handler(
-          static_cast<payload_type&&>(payload_storage_.payload_), handler_);
-      p.h = asio::detail::addressof(handler.handler());
-      p.reset();
-      handler();
-    }
-  }
-
-//private:
-  typedef completion_payload<Signatures...> payload_type;
-
-  struct cancel_proxy
-  {
-    cancel_proxy(timed_cancel_op* op)
-      : op_(op)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (op_)
-        op_->cancellation_signal_.emit(type);
-    }
-
-    timed_cancel_op* op_;
-  };
-
-  // The number of handlers that share a reference to the state.
-  atomic_count ref_count_;
-
-  // The handler to be called when the operation completes.
-  Handler handler_;
-
-  // The timer used to determine when to cancel the pending operation.
-  Timer timer_;
-
-  // The cancellation signal and type used to cancel the pending operation.
-  cancellation_signal cancellation_signal_;
-  cancellation_type_t cancellation_type_;
-
-  // A proxy cancel handler used to allow cancellation of the timed operation.
-  cancel_proxy* cancel_proxy_;
-
-  // Arguments to be passed to the completion handler.
-  union payload_storage
-  {
-    payload_storage() {}
-    ~payload_storage() {}
-
-    char dummy_;
-    payload_type payload_;
-  } payload_storage_;
-
-  // Whether the payload storage contains a valid payload.
-  bool has_payload_;
-
-  // Whether the asynchronous wait on the timer is still pending
-  bool has_pending_timer_wait_;
-};
-
-template <typename Op, typename R, typename... Args>
-class timed_cancel_op_handler<Op, R(Args...)>
-{
-public:
-  using cancellation_slot_type = cancellation_slot;
-
-  explicit timed_cancel_op_handler(Op* op)
-    : op_(op)
-  {
-  }
-
-  timed_cancel_op_handler(timed_cancel_op_handler&& other) noexcept
-    : op_(other.op_)
-  {
-    other.op_ = nullptr;
-  }
-
-  ~timed_cancel_op_handler()
-  {
-    if (op_)
-      op_->release();
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return op_->get_cancellation_slot();
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<completion_message<R(Args...)>, int, Args2...>::value
-  > operator()(Args2&&... args)
-  {
-    Op* op = op_;
-    op_ = nullptr;
-    typedef completion_message<R(Args...)> message_type;
-    op->handle_op(message_type(0, static_cast<Args2&&>(args)...));
-  }
-
-//protected:
-  Op* op_;
-};
-
-template <typename Op, typename R, typename... Args, typename... Signatures>
-class timed_cancel_op_handler<Op, R(Args...), Signatures...> :
-  public timed_cancel_op_handler<Op, Signatures...>
-{
-public:
-  using timed_cancel_op_handler<Op, Signatures...>::timed_cancel_op_handler;
-  using timed_cancel_op_handler<Op, Signatures...>::operator();
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<completion_message<R(Args...)>, int, Args2...>::value
-  > operator()(Args2&&... args)
-  {
-    Op* op = this->op_;
-    this->op_ = nullptr;
-    typedef completion_message<R(Args...)> message_type;
-    op->handle_op(message_type(0, static_cast<Args2&&>(args)...));
-  }
-};
-
-template <typename Op>
-class timed_cancel_timer_handler
-{
-public:
-  using cancellation_slot_type = cancellation_slot;
-
-  explicit timed_cancel_timer_handler(Op* op)
-    : op_(op)
-  {
-  }
-
-  timed_cancel_timer_handler(timed_cancel_timer_handler&& other) noexcept
-    : op_(other.op_)
-  {
-    other.op_ = nullptr;
-  }
-
-  ~timed_cancel_timer_handler()
-  {
-    if (op_)
-      op_->release();
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancellation_slot_type();
-  }
-
-  void operator()(const asio::error_code&)
-  {
-    Op* op = op_;
-    op_ = nullptr;
-    op->handle_timer();
-  }
-
-//private:
-  Op* op_;
-};
-
-} // namespace detail
-
-template <template <typename, typename> class Associator,
-    typename Op, typename... Signatures, typename DefaultCandidate>
-struct associator<Associator,
-    detail::timed_cancel_op_handler<Op, Signatures...>, DefaultCandidate>
-  : Associator<typename Op::handler_type, DefaultCandidate>
-{
-  static typename Associator<typename Op::handler_type, DefaultCandidate>::type
-  get(const detail::timed_cancel_op_handler<Op, Signatures...>& h) noexcept
-  {
-    return Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_);
-  }
-
-  static auto get(const detail::timed_cancel_op_handler<Op, Signatures...>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_, c))
-  {
-    return Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Op, typename DefaultCandidate>
-struct associator<Associator,
-    detail::timed_cancel_timer_handler<Op>, DefaultCandidate>
-  : Associator<typename Op::handler_type, DefaultCandidate>
-{
-  static typename Associator<typename Op::handler_type, DefaultCandidate>::type
-  get(const detail::timed_cancel_timer_handler<Op>& h) noexcept
-  {
-    return Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_);
-  }
-
-  static auto get(const detail::timed_cancel_timer_handler<Op>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_, c))
-  {
-    return Associator<typename Op::handler_type, DefaultCandidate>::get(
-        h.op_->handler_, c);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_TIMED_CANCEL_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue.hpp
deleted file mode 100644
index 843f361..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue.hpp
+++ /dev/null
@@ -1,389 +0,0 @@
-//
-// detail/timer_queue.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_QUEUE_HPP
-#define ASIO_DETAIL_TIMER_QUEUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <vector>
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/date_time_fwd.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-class timer_queue
-  : public timer_queue_base
-{
-public:
-  // The time type.
-  typedef typename Time_Traits::time_type time_type;
-
-  // The duration type.
-  typedef typename Time_Traits::duration_type duration_type;
-
-  // Per-timer data.
-  class per_timer_data
-  {
-  public:
-    per_timer_data() :
-      heap_index_((std::numeric_limits<std::size_t>::max)()),
-      next_(0), prev_(0)
-    {
-    }
-
-  private:
-    friend class timer_queue;
-
-    // The operations waiting on the timer.
-    op_queue<wait_op> op_queue_;
-
-    // The index of the timer in the heap.
-    std::size_t heap_index_;
-
-    // Pointers to adjacent timers in a linked list.
-    per_timer_data* next_;
-    per_timer_data* prev_;
-  };
-
-  // Constructor.
-  timer_queue()
-    : timers_(),
-      heap_()
-  {
-  }
-
-  // Add a new timer to the queue. Returns true if this is the timer that is
-  // earliest in the queue, in which case the reactor's event demultiplexing
-  // function call may need to be interrupted and restarted.
-  bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
-  {
-    // Enqueue the timer object.
-    if (timer.prev_ == 0 && &timer != timers_)
-    {
-      if (this->is_positive_infinity(time))
-      {
-        // No heap entry is required for timers that never expire.
-        timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
-      }
-      else
-      {
-        // Put the new timer at the correct position in the heap. This is done
-        // first since push_back() can throw due to allocation failure.
-        timer.heap_index_ = heap_.size();
-        heap_entry entry = { time, &timer };
-        heap_.push_back(entry);
-        up_heap(heap_.size() - 1);
-      }
-
-      // Insert the new timer into the linked list of active timers.
-      timer.next_ = timers_;
-      timer.prev_ = 0;
-      if (timers_)
-        timers_->prev_ = &timer;
-      timers_ = &timer;
-    }
-
-    // Enqueue the individual timer operation.
-    timer.op_queue_.push(op);
-
-    // Interrupt reactor only if newly added timer is first to expire.
-    return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
-  }
-
-  // Whether there are no timers in the queue.
-  virtual bool empty() const
-  {
-    return timers_ == 0;
-  }
-
-  // Get the time for the timer that is earliest in the queue.
-  virtual long wait_duration_msec(long max_duration) const
-  {
-    if (heap_.empty())
-      return max_duration;
-
-    return this->to_msec(
-        Time_Traits::to_posix_duration(
-          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
-        max_duration);
-  }
-
-  // Get the time for the timer that is earliest in the queue.
-  virtual long wait_duration_usec(long max_duration) const
-  {
-    if (heap_.empty())
-      return max_duration;
-
-    return this->to_usec(
-        Time_Traits::to_posix_duration(
-          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
-        max_duration);
-  }
-
-  // Dequeue all timers not later than the current time.
-  virtual void get_ready_timers(op_queue<operation>& ops)
-  {
-    if (!heap_.empty())
-    {
-      const time_type now = Time_Traits::now();
-      while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
-      {
-        per_timer_data* timer = heap_[0].timer_;
-        while (wait_op* op = timer->op_queue_.front())
-        {
-          timer->op_queue_.pop();
-          op->ec_ = asio::error_code();
-          ops.push(op);
-        }
-        remove_timer(*timer);
-      }
-    }
-  }
-
-  // Dequeue all timers.
-  virtual void get_all_timers(op_queue<operation>& ops)
-  {
-    while (timers_)
-    {
-      per_timer_data* timer = timers_;
-      timers_ = timers_->next_;
-      ops.push(timer->op_queue_);
-      timer->next_ = 0;
-      timer->prev_ = 0;
-    }
-
-    heap_.clear();
-  }
-
-  // Cancel and dequeue operations for the given timer.
-  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
-  {
-    std::size_t num_cancelled = 0;
-    if (timer.prev_ != 0 || &timer == timers_)
-    {
-      while (wait_op* op = (num_cancelled != max_cancelled)
-          ? timer.op_queue_.front() : 0)
-      {
-        op->ec_ = asio::error::operation_aborted;
-        timer.op_queue_.pop();
-        ops.push(op);
-        ++num_cancelled;
-      }
-      if (timer.op_queue_.empty())
-        remove_timer(timer);
-    }
-    return num_cancelled;
-  }
-
-  // Cancel and dequeue a specific operation for the given timer.
-  void cancel_timer_by_key(per_timer_data* timer,
-      op_queue<operation>& ops, void* cancellation_key)
-  {
-    if (timer->prev_ != 0 || timer == timers_)
-    {
-      op_queue<wait_op> other_ops;
-      while (wait_op* op = timer->op_queue_.front())
-      {
-        timer->op_queue_.pop();
-        if (op->cancellation_key_ == cancellation_key)
-        {
-          op->ec_ = asio::error::operation_aborted;
-          ops.push(op);
-        }
-        else
-          other_ops.push(op);
-      }
-      timer->op_queue_.push(other_ops);
-      if (timer->op_queue_.empty())
-        remove_timer(*timer);
-    }
-  }
-
-  // Move operations from one timer to another, empty timer.
-  void move_timer(per_timer_data& target, per_timer_data& source)
-  {
-    target.op_queue_.push(source.op_queue_);
-
-    target.heap_index_ = source.heap_index_;
-    source.heap_index_ = (std::numeric_limits<std::size_t>::max)();
-
-    if (target.heap_index_ < heap_.size())
-      heap_[target.heap_index_].timer_ = &target;
-
-    if (timers_ == &source)
-      timers_ = &target;
-    if (source.prev_)
-      source.prev_->next_ = &target;
-    if (source.next_)
-      source.next_->prev_= &target;
-    target.next_ = source.next_;
-    target.prev_ = source.prev_;
-    source.next_ = 0;
-    source.prev_ = 0;
-  }
-
-private:
-  // Move the item at the given index up the heap to its correct position.
-  void up_heap(std::size_t index)
-  {
-    while (index > 0)
-    {
-      std::size_t parent = (index - 1) / 2;
-      if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
-        break;
-      swap_heap(index, parent);
-      index = parent;
-    }
-  }
-
-  // Move the item at the given index down the heap to its correct position.
-  void down_heap(std::size_t index)
-  {
-    std::size_t child = index * 2 + 1;
-    while (child < heap_.size())
-    {
-      std::size_t min_child = (child + 1 == heap_.size()
-          || Time_Traits::less_than(
-            heap_[child].time_, heap_[child + 1].time_))
-        ? child : child + 1;
-      if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
-        break;
-      swap_heap(index, min_child);
-      index = min_child;
-      child = index * 2 + 1;
-    }
-  }
-
-  // Swap two entries in the heap.
-  void swap_heap(std::size_t index1, std::size_t index2)
-  {
-    heap_entry tmp = heap_[index1];
-    heap_[index1] = heap_[index2];
-    heap_[index2] = tmp;
-    heap_[index1].timer_->heap_index_ = index1;
-    heap_[index2].timer_->heap_index_ = index2;
-  }
-
-  // Remove a timer from the heap and list of timers.
-  void remove_timer(per_timer_data& timer)
-  {
-    // Remove the timer from the heap.
-    std::size_t index = timer.heap_index_;
-    if (!heap_.empty() && index < heap_.size())
-    {
-      if (index == heap_.size() - 1)
-      {
-        timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
-        heap_.pop_back();
-      }
-      else
-      {
-        swap_heap(index, heap_.size() - 1);
-        timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
-        heap_.pop_back();
-        if (index > 0 && Time_Traits::less_than(
-              heap_[index].time_, heap_[(index - 1) / 2].time_))
-          up_heap(index);
-        else
-          down_heap(index);
-      }
-    }
-
-    // Remove the timer from the linked list of active timers.
-    if (timers_ == &timer)
-      timers_ = timer.next_;
-    if (timer.prev_)
-      timer.prev_->next_ = timer.next_;
-    if (timer.next_)
-      timer.next_->prev_= timer.prev_;
-    timer.next_ = 0;
-    timer.prev_ = 0;
-  }
-
-  // Determine if the specified absolute time is positive infinity.
-  template <typename Time_Type>
-  static bool is_positive_infinity(const Time_Type&)
-  {
-    return false;
-  }
-
-  // Determine if the specified absolute time is positive infinity.
-  template <typename T, typename TimeSystem>
-  static bool is_positive_infinity(
-      const boost::date_time::base_time<T, TimeSystem>& time)
-  {
-    return time.is_pos_infinity();
-  }
-
-  // Helper function to convert a duration into milliseconds.
-  template <typename Duration>
-  long to_msec(const Duration& d, long max_duration) const
-  {
-    if (d.ticks() <= 0)
-      return 0;
-    int64_t msec = d.total_milliseconds();
-    if (msec == 0)
-      return 1;
-    if (msec > max_duration)
-      return max_duration;
-    return static_cast<long>(msec);
-  }
-
-  // Helper function to convert a duration into microseconds.
-  template <typename Duration>
-  long to_usec(const Duration& d, long max_duration) const
-  {
-    if (d.ticks() <= 0)
-      return 0;
-    int64_t usec = d.total_microseconds();
-    if (usec == 0)
-      return 1;
-    if (usec > max_duration)
-      return max_duration;
-    return static_cast<long>(usec);
-  }
-
-  // The head of a linked list of all active timers.
-  per_timer_data* timers_;
-
-  struct heap_entry
-  {
-    // The time when the timer should fire.
-    time_type time_;
-
-    // The associated timer with enqueued operations.
-    per_timer_data* timer_;
-  };
-
-  // The heap of timers, with the earliest timer at the front.
-  std::vector<heap_entry> heap_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_TIMER_QUEUE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_base.hpp
deleted file mode 100644
index ddcf41c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_base.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// detail/timer_queue_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
-#define ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class timer_queue_base
-  : private noncopyable
-{
-public:
-  // Constructor.
-  timer_queue_base() : next_(0) {}
-
-  // Destructor.
-  virtual ~timer_queue_base() {}
-
-  // Whether there are no timers in the queue.
-  virtual bool empty() const = 0;
-
-  // Get the time to wait until the next timer.
-  virtual long wait_duration_msec(long max_duration) const = 0;
-
-  // Get the time to wait until the next timer.
-  virtual long wait_duration_usec(long max_duration) const = 0;
-
-  // Dequeue all ready timers.
-  virtual void get_ready_timers(op_queue<operation>& ops) = 0;
-
-  // Dequeue all timers.
-  virtual void get_all_timers(op_queue<operation>& ops) = 0;
-
-private:
-  friend class timer_queue_set;
-
-  // Next timer queue in the set.
-  timer_queue_base* next_;
-};
-
-template <typename Time_Traits>
-class timer_queue;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_TIMER_QUEUE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_ptime.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_ptime.hpp
deleted file mode 100644
index 937a4ad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_ptime.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//
-// detail/timer_queue_ptime.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
-#define ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#include "asio/time_traits.hpp"
-#include "asio/detail/timer_queue.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
-
-// Template specialisation for the commonly used instantation.
-template <>
-class timer_queue<time_traits<boost::posix_time::ptime>>
-  : public timer_queue_base
-{
-public:
-  // The time type.
-  typedef boost::posix_time::ptime time_type;
-
-  // The duration type.
-  typedef boost::posix_time::time_duration duration_type;
-
-  // Per-timer data.
-  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
-    per_timer_data;
-
-  // Constructor.
-  ASIO_DECL timer_queue();
-
-  // Destructor.
-  ASIO_DECL virtual ~timer_queue();
-
-  // Add a new timer to the queue. Returns true if this is the timer that is
-  // earliest in the queue, in which case the reactor's event demultiplexing
-  // function call may need to be interrupted and restarted.
-  ASIO_DECL bool enqueue_timer(const time_type& time,
-      per_timer_data& timer, wait_op* op);
-
-  // Whether there are no timers in the queue.
-  ASIO_DECL virtual bool empty() const;
-
-  // Get the time for the timer that is earliest in the queue.
-  ASIO_DECL virtual long wait_duration_msec(long max_duration) const;
-
-  // Get the time for the timer that is earliest in the queue.
-  ASIO_DECL virtual long wait_duration_usec(long max_duration) const;
-
-  // Dequeue all timers not later than the current time.
-  ASIO_DECL virtual void get_ready_timers(op_queue<operation>& ops);
-
-  // Dequeue all timers.
-  ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops);
-
-  // Cancel and dequeue operations for the given timer.
-  ASIO_DECL std::size_t cancel_timer(
-      per_timer_data& timer, op_queue<operation>& ops,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel and dequeue operations for the given timer and key.
-  ASIO_DECL void cancel_timer_by_key(per_timer_data* timer,
-      op_queue<operation>& ops, void* cancellation_key);
-
-  // Move operations from one timer to another, empty timer.
-  ASIO_DECL void move_timer(per_timer_data& target,
-      per_timer_data& source);
-
-private:
-  timer_queue<forwarding_posix_time_traits> impl_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/timer_queue_ptime.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#endif // ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_set.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_set.hpp
deleted file mode 100644
index 7bf5074..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_queue_set.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// detail/timer_queue_set.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_QUEUE_SET_HPP
-#define ASIO_DETAIL_TIMER_QUEUE_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class timer_queue_set
-{
-public:
-  // Constructor.
-  ASIO_DECL timer_queue_set();
-
-  // Add a timer queue to the set.
-  ASIO_DECL void insert(timer_queue_base* q);
-
-  // Remove a timer queue from the set.
-  ASIO_DECL void erase(timer_queue_base* q);
-
-  // Determine whether all queues are empty.
-  ASIO_DECL bool all_empty() const;
-
-  // Get the wait duration in milliseconds.
-  ASIO_DECL long wait_duration_msec(long max_duration) const;
-
-  // Get the wait duration in microseconds.
-  ASIO_DECL long wait_duration_usec(long max_duration) const;
-
-  // Dequeue all ready timers.
-  ASIO_DECL void get_ready_timers(op_queue<operation>& ops);
-
-  // Dequeue all timers.
-  ASIO_DECL void get_all_timers(op_queue<operation>& ops);
-
-private:
-  timer_queue_base* first_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/timer_queue_set.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_TIMER_QUEUE_SET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler.hpp
deleted file mode 100644
index dd34d32..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// detail/timer_scheduler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_SCHEDULER_HPP
-#define ASIO_DETAIL_TIMER_SCHEDULER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/timer_scheduler_fwd.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/winrt_timer_scheduler.hpp"
-#elif defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_service.hpp"
-#elif defined(ASIO_HAS_EPOLL)
-# include "asio/detail/epoll_reactor.hpp"
-#elif defined(ASIO_HAS_KQUEUE)
-# include "asio/detail/kqueue_reactor.hpp"
-#elif defined(ASIO_HAS_DEV_POLL)
-# include "asio/detail/dev_poll_reactor.hpp"
-#else
-# include "asio/detail/select_reactor.hpp"
-#endif
-
-#endif // ASIO_DETAIL_TIMER_SCHEDULER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler_fwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler_fwd.hpp
deleted file mode 100644
index bbb8a4e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/timer_scheduler_fwd.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// detail/timer_scheduler_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
-#define ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-typedef class winrt_timer_scheduler timer_scheduler;
-#elif defined(ASIO_HAS_IOCP)
-typedef class win_iocp_io_context timer_scheduler;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-typedef class io_uring_service timer_scheduler;
-#elif defined(ASIO_HAS_EPOLL)
-typedef class epoll_reactor timer_scheduler;
-#elif defined(ASIO_HAS_KQUEUE)
-typedef class kqueue_reactor timer_scheduler;
-#elif defined(ASIO_HAS_DEV_POLL)
-typedef class dev_poll_reactor timer_scheduler;
-#else
-typedef class select_reactor timer_scheduler;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/tss_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/tss_ptr.hpp
deleted file mode 100644
index f7aaa2e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/tss_ptr.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// detail/tss_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TSS_PTR_HPP
-#define ASIO_DETAIL_TSS_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_THREADS)
-# include "asio/detail/null_tss_ptr.hpp"
-#elif defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-# include "asio/detail/keyword_tss_ptr.hpp"
-#elif defined(ASIO_WINDOWS)
-# include "asio/detail/win_tss_ptr.hpp"
-#elif defined(ASIO_HAS_PTHREADS)
-# include "asio/detail/posix_tss_ptr.hpp"
-#else
-# error Only Windows and POSIX are supported!
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-class tss_ptr
-#if !defined(ASIO_HAS_THREADS)
-  : public null_tss_ptr<T>
-#elif defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-  : public keyword_tss_ptr<T>
-#elif defined(ASIO_WINDOWS)
-  : public win_tss_ptr<T>
-#elif defined(ASIO_HAS_PTHREADS)
-  : public posix_tss_ptr<T>
-#endif
-{
-public:
-  void operator=(T* value)
-  {
-#if !defined(ASIO_HAS_THREADS)
-    null_tss_ptr<T>::operator=(value);
-#elif defined(ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-    keyword_tss_ptr<T>::operator=(value);
-#elif defined(ASIO_WINDOWS)
-    win_tss_ptr<T>::operator=(value);
-#elif defined(ASIO_HAS_PTHREADS)
-    posix_tss_ptr<T>::operator=(value);
-#endif
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_TSS_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/type_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/type_traits.hpp
deleted file mode 100644
index a4706a5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/type_traits.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-//
-// detail/type_traits.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_TYPE_TRAITS_HPP
-#define ASIO_DETAIL_TYPE_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <type_traits>
-
-namespace asio {
-
-using std::add_const;
-
-template <typename T>
-using add_const_t = typename std::add_const<T>::type;
-
-using std::add_lvalue_reference;
-
-template <typename T>
-using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
-
-template <std::size_t N, std::size_t A>
-struct aligned_storage
-{
-  struct type
-  {
-    alignas(A) unsigned char data[N];
-  };
-};
-
-template <std::size_t N, std::size_t A>
-using aligned_storage_t = typename aligned_storage<N, A>::type;
-
-using std::alignment_of;
-
-using std::conditional;
-
-template <bool C, typename T, typename U>
-using conditional_t = typename std::conditional<C, T, U>::type;
-
-using std::decay;
-
-template <typename T>
-using decay_t = typename std::decay<T>::type;
-
-using std::declval;
-
-using std::enable_if;
-
-template <bool C, typename T = void>
-using enable_if_t = typename std::enable_if<C, T>::type;
-
-using std::false_type;
-
-using std::integral_constant;
-
-using std::is_base_of;
-
-using std::is_class;
-
-using std::is_const;
-
-using std::is_constructible;
-
-using std::is_convertible;
-
-using std::is_copy_constructible;
-
-using std::is_destructible;
-
-using std::is_function;
-
-using std::is_move_constructible;
-
-using std::is_nothrow_copy_constructible;
-
-using std::is_nothrow_destructible;
-
-using std::is_object;
-
-using std::is_pointer;
-
-using std::is_reference;
-
-using std::is_same;
-
-using std::is_scalar;
-
-using std::remove_cv;
-
-template <typename T>
-using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-struct remove_cvref :
-  std::remove_cv<typename std::remove_reference<T>::type> {};
-
-template <typename T>
-using remove_cvref_t = typename remove_cvref<T>::type;
-
-using std::remove_pointer;
-
-template <typename T>
-using remove_pointer_t = typename std::remove_pointer<T>::type;
-
-using std::remove_reference;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-#if defined(ASIO_HAS_STD_INVOKE_RESULT)
-
-template <typename> struct result_of;
-
-template <typename F, typename... Args>
-struct result_of<F(Args...)> : std::invoke_result<F, Args...> {};
-
-template <typename T>
-using result_of_t = typename result_of<T>::type;
-
-#else // defined(ASIO_HAS_STD_INVOKE_RESULT)
-
-using std::result_of;
-
-template <typename T>
-using result_of_t = typename std::result_of<T>::type;
-
-#endif // defined(ASIO_HAS_STD_INVOKE_RESULT)
-
-using std::true_type;
-
-template <typename> struct void_type
-{
-  typedef void type;
-};
-
-template <typename T>
-using void_t = typename void_type<T>::type;
-
-template <typename...> struct conjunction : true_type {};
-
-template <typename T> struct conjunction<T> : T {};
-
-template <typename Head, typename... Tail>
-struct conjunction<Head, Tail...> :
-  conditional_t<Head::value, conjunction<Tail...>, Head> {};
-
-struct defaulted_constraint
-{
-  constexpr defaulted_constraint() {}
-};
-
-template <bool Condition, typename Type = int>
-struct constraint : std::enable_if<Condition, Type> {};
-
-template <bool Condition, typename Type = int>
-using constraint_t = typename constraint<Condition, Type>::type;
-
-template <typename T>
-struct type_identity { typedef T type; };
-
-template <typename T>
-using type_identity_t = typename type_identity<T>::type;
-
-} // namespace asio
-
-#endif // ASIO_DETAIL_TYPE_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/utility.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/utility.hpp
deleted file mode 100644
index 72dd4d4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/utility.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// detail/utility.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_UTILITY_HPP
-#define ASIO_DETAIL_UTILITY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <utility>
-
-namespace asio {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_INDEX_SEQUENCE)
-
-using std::index_sequence;
-using std::index_sequence_for;
-using std::make_index_sequence;
-
-#else // defined(ASIO_HAS_STD_INDEX_SEQUENCE)
-
-template <std::size_t...>
-struct index_sequence
-{
-};
-
-template <typename T, typename U>
-struct join_index_sequences;
-
-template <std::size_t... I, std::size_t... J>
-struct join_index_sequences<index_sequence<I...>, index_sequence<J...>>
-{
-  using type = index_sequence<I..., J...>;
-};
-
-template <std::size_t First, std::size_t Last>
-struct index_pack :
-  join_index_sequences<
-    typename index_pack<First, First + (Last - First + 1) / 2 - 1>::type,
-    typename index_pack<First + (Last - First + 1) / 2, Last>::type
-  >
-{
-};
-
-template <std::size_t N>
-struct index_pack<N, N>
-{
-  using type = index_sequence<N>;
-};
-
-template <std::size_t Begin, std::size_t End>
-struct index_range : index_pack<Begin, End - 1>
-{
-};
-
-template <std::size_t N>
-struct index_range<N, N>
-{
-  using type = index_sequence<>;
-};
-
-template <typename... T>
-using index_sequence_for = typename index_range<0, sizeof...(T)>::type;
-
-template <std::size_t N>
-using make_index_sequence = typename index_range<0, N>::type;
-
-#endif // defined(ASIO_HAS_STD_INDEX_SEQUENCE)
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_UTILITY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_handler.hpp
deleted file mode 100644
index 489a968..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_handler.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// detail/wait_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WAIT_HANDLER_HPP
-#define ASIO_DETAIL_WAIT_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/wait_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class wait_handler : public wait_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(wait_handler);
-
-  wait_handler(Handler& h, const IoExecutor& io_ex)
-    : wait_op(&wait_handler::do_complete),
-      handler_(static_cast<Handler&&>(h)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    wait_handler* h(static_cast<wait_handler*>(base));
-    ptr p = { asio::detail::addressof(h->handler_), h, h };
-
-    ASIO_HANDLER_COMPLETION((*h));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          h->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(h->handler_, h->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WAIT_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_op.hpp
deleted file mode 100644
index 548232c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wait_op.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// detail/wait_op.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WAIT_OP_HPP
-#define ASIO_DETAIL_WAIT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class wait_op
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-  // The operation key used for targeted cancellation.
-  void* cancellation_key_;
-
-protected:
-  wait_op(func_type func)
-    : operation(func),
-      cancellation_key_(0)
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WAIT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_event.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_event.hpp
deleted file mode 100644
index e61843e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_event.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//
-// detail/win_event.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_EVENT_HPP
-#define ASIO_DETAIL_WIN_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include <cstddef>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_event
-  : private noncopyable
-{
-public:
-  // Constructor.
-  ASIO_DECL win_event();
-
-  // Destructor.
-  ASIO_DECL ~win_event();
-
-  // Signal the event. (Retained for backward compatibility.)
-  template <typename Lock>
-  void signal(Lock& lock)
-  {
-    this->signal_all(lock);
-  }
-
-  // Signal all waiters.
-  template <typename Lock>
-  void signal_all(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    state_ |= 1;
-    ::SetEvent(events_[0]);
-  }
-
-  // Unlock the mutex and signal one waiter.
-  template <typename Lock>
-  void unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    lock.unlock();
-    if (have_waiters)
-      ::SetEvent(events_[1]);
-  }
-
-  // Unlock the mutex and signal one waiter who may destroy us.
-  template <typename Lock>
-  void unlock_and_signal_one_for_destruction(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    bool have_waiters = (state_ > 1);
-    if (have_waiters)
-      ::SetEvent(events_[1]);
-    lock.unlock();
-  }
-
-  // If there's a waiter, unlock the mutex and signal it.
-  template <typename Lock>
-  bool maybe_unlock_and_signal_one(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    state_ |= 1;
-    if (state_ > 1)
-    {
-      lock.unlock();
-      ::SetEvent(events_[1]);
-      return true;
-    }
-    return false;
-  }
-
-  // Reset the event.
-  template <typename Lock>
-  void clear(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    (void)lock;
-    ::ResetEvent(events_[0]);
-    state_ &= ~std::size_t(1);
-  }
-
-  // Wait for the event to become signalled.
-  template <typename Lock>
-  void wait(Lock& lock)
-  {
-    ASIO_ASSERT(lock.locked());
-    while ((state_ & 1) == 0)
-    {
-      state_ += 2;
-      lock.unlock();
-#if defined(ASIO_WINDOWS_APP)
-      ::WaitForMultipleObjectsEx(2, events_, false, INFINITE, false);
-#else // defined(ASIO_WINDOWS_APP)
-      ::WaitForMultipleObjects(2, events_, false, INFINITE);
-#endif // defined(ASIO_WINDOWS_APP)
-      lock.lock();
-      state_ -= 2;
-    }
-  }
-
-  // Timed wait for the event to become signalled.
-  template <typename Lock>
-  bool wait_for_usec(Lock& lock, long usec)
-  {
-    ASIO_ASSERT(lock.locked());
-    if ((state_ & 1) == 0)
-    {
-      state_ += 2;
-      lock.unlock();
-      DWORD msec = usec > 0 ? (usec < 1000 ? 1 : usec / 1000) : 0;
-#if defined(ASIO_WINDOWS_APP)
-      ::WaitForMultipleObjectsEx(2, events_, false, msec, false);
-#else // defined(ASIO_WINDOWS_APP)
-      ::WaitForMultipleObjects(2, events_, false, msec);
-#endif // defined(ASIO_WINDOWS_APP)
-      lock.lock();
-      state_ -= 2;
-    }
-    return (state_ & 1) != 0;
-  }
-
-private:
-  HANDLE events_[2];
-  std::size_t state_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_event.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_WIN_EVENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_fd_set_adapter.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_fd_set_adapter.hpp
deleted file mode 100644
index 0e3e63f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_fd_set_adapter.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//
-// detail/win_fd_set_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
-#define ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/reactor_op_queue.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
-class win_fd_set_adapter : noncopyable
-{
-public:
-  enum { default_fd_set_size = 1024 };
-
-  win_fd_set_adapter()
-    : capacity_(default_fd_set_size),
-      max_descriptor_(invalid_socket)
-  {
-    fd_set_ = static_cast<win_fd_set*>(::operator new(
-          sizeof(win_fd_set) - sizeof(SOCKET)
-          + sizeof(SOCKET) * (capacity_)));
-    fd_set_->fd_count = 0;
-  }
-
-  ~win_fd_set_adapter()
-  {
-    ::operator delete(fd_set_);
-  }
-
-  void reset()
-  {
-    fd_set_->fd_count = 0;
-    max_descriptor_ = invalid_socket;
-  }
-
-  bool set(socket_type descriptor)
-  {
-    for (u_int i = 0; i < fd_set_->fd_count; ++i)
-      if (fd_set_->fd_array[i] == descriptor)
-        return true;
-
-    reserve(fd_set_->fd_count + 1);
-    fd_set_->fd_array[fd_set_->fd_count++] = descriptor;
-    return true;
-  }
-
-  void set(reactor_op_queue<socket_type>& operations, op_queue<operation>&)
-  {
-    reactor_op_queue<socket_type>::iterator i = operations.begin();
-    while (i != operations.end())
-    {
-      reactor_op_queue<socket_type>::iterator op_iter = i++;
-      reserve(fd_set_->fd_count + 1);
-      fd_set_->fd_array[fd_set_->fd_count++] = op_iter->first;
-    }
-  }
-
-  bool is_set(socket_type descriptor) const
-  {
-    return !!__WSAFDIsSet(descriptor,
-        const_cast<fd_set*>(reinterpret_cast<const fd_set*>(fd_set_)));
-  }
-
-  operator fd_set*()
-  {
-    return reinterpret_cast<fd_set*>(fd_set_);
-  }
-
-  socket_type max_descriptor() const
-  {
-    return max_descriptor_;
-  }
-
-  void perform(reactor_op_queue<socket_type>& operations,
-      op_queue<operation>& ops) const
-  {
-    for (u_int i = 0; i < fd_set_->fd_count; ++i)
-      operations.perform_operations(fd_set_->fd_array[i], ops);
-  }
-
-private:
-  // This structure is defined to be compatible with the Windows API fd_set
-  // structure, but without being dependent on the value of FD_SETSIZE. We use
-  // the "struct hack" to allow the number of descriptors to be varied at
-  // runtime.
-  struct win_fd_set
-  {
-    u_int fd_count;
-    SOCKET fd_array[1];
-  };
-
-  // Increase the fd_set_ capacity to at least the specified number of elements.
-  void reserve(u_int n)
-  {
-    if (n <= capacity_)
-      return;
-
-    u_int new_capacity = capacity_ + capacity_ / 2;
-    if (new_capacity < n)
-      new_capacity = n;
-
-    win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new(
-          sizeof(win_fd_set) - sizeof(SOCKET)
-          + sizeof(SOCKET) * (new_capacity)));
-
-    new_fd_set->fd_count = fd_set_->fd_count;
-    for (u_int i = 0; i < fd_set_->fd_count; ++i)
-      new_fd_set->fd_array[i] = fd_set_->fd_array[i];
-
-    ::operator delete(fd_set_);
-    fd_set_ = new_fd_set;
-    capacity_ = new_capacity;
-  }
-
-  win_fd_set* fd_set_;
-  u_int capacity_;
-  socket_type max_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_global.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_global.hpp
deleted file mode 100644
index 771f3fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_global.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// detail/win_global.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_GLOBAL_HPP
-#define ASIO_DETAIL_WIN_GLOBAL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/static_mutex.hpp"
-#include "asio/detail/tss_ptr.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T>
-struct win_global_impl
-{
-  // Destructor automatically cleans up the global.
-  ~win_global_impl()
-  {
-    delete ptr_;
-  }
-
-  static win_global_impl instance_;
-  static static_mutex mutex_;
-  T* ptr_;
-  static tss_ptr<T> tss_ptr_;
-};
-
-template <typename T>
-win_global_impl<T> win_global_impl<T>::instance_ = { 0 };
-
-template <typename T>
-static_mutex win_global_impl<T>::mutex_ = ASIO_STATIC_MUTEX_INIT;
-
-template <typename T>
-tss_ptr<T> win_global_impl<T>::tss_ptr_;
-
-template <typename T>
-T& win_global()
-{
-  if (static_cast<T*>(win_global_impl<T>::tss_ptr_) == 0)
-  {
-    win_global_impl<T>::mutex_.init();
-    static_mutex::scoped_lock lock(win_global_impl<T>::mutex_);
-    if (win_global_impl<T>::instance_.ptr_ == 0)
-      win_global_impl<T>::instance_.ptr_ = new T;
-    win_global_impl<T>::tss_ptr_ = win_global_impl<T>::instance_.ptr_;
-  }
-
-  return *win_global_impl<T>::tss_ptr_;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WIN_GLOBAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_file_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_file_service.hpp
deleted file mode 100644
index f10a8d3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_file_service.hpp
+++ /dev/null
@@ -1,287 +0,0 @@
-//
-// detail/win_iocp_file_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
-#define ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_FILE)
-
-#include <string>
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/win_iocp_handle_service.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/file_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Extend win_iocp_handle_service to provide file support.
-class win_iocp_file_service :
-  public execution_context_service_base<win_iocp_file_service>
-{
-public:
-  // The native type of a file.
-  typedef win_iocp_handle_service::native_handle_type native_handle_type;
-
-  // The implementation type of the file.
-  class implementation_type : win_iocp_handle_service::implementation_type
-  {
-  private:
-    // Only this service will have access to the internal values.
-    friend class win_iocp_file_service;
-
-    uint64_t offset_;
-    bool is_stream_;
-  };
-
-  // Constructor.
-  ASIO_DECL win_iocp_file_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new file implementation.
-  void construct(implementation_type& impl)
-  {
-    handle_service_.construct(impl);
-    impl.offset_ = 0;
-    impl.is_stream_ = false;
-  }
-
-  // Move-construct a new file implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_construct(impl, other_impl);
-    impl.offset_ = other_impl.offset_;
-    impl.is_stream_ = other_impl.is_stream_;
-    other_impl.offset_ = 0;
-  }
-
-  // Move-assign from another file implementation.
-  void move_assign(implementation_type& impl,
-      win_iocp_file_service& other_service,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_assign(impl,
-        other_service.handle_service_, other_impl);
-    impl.offset_ = other_impl.offset_;
-    impl.is_stream_ = other_impl.is_stream_;
-    other_impl.offset_ = 0;
-  }
-
-  // Destroy a file implementation.
-  void destroy(implementation_type& impl)
-  {
-    handle_service_.destroy(impl);
-  }
-
-  // Set whether the implementation is stream-oriented.
-  void set_is_stream(implementation_type& impl, bool is_stream)
-  {
-    impl.is_stream_ = is_stream;
-  }
-
-  // Open the file using the specified path name.
-  ASIO_DECL asio::error_code open(implementation_type& impl,
-      const char* path, file_base::flags open_flags,
-      asio::error_code& ec);
-
-  // Assign a native handle to a file implementation.
-  asio::error_code assign(implementation_type& impl,
-      const native_handle_type& native_handle,
-      asio::error_code& ec)
-  {
-    return handle_service_.assign(impl, native_handle, ec);
-  }
-
-  // Determine whether the file is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return handle_service_.is_open(impl);
-  }
-
-  // Destroy a file implementation.
-  asio::error_code close(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return handle_service_.close(impl, ec);
-  }
-
-  // Get the native file representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return handle_service_.native_handle(impl);
-  }
-
-  // Release ownership of a file.
-  native_handle_type release(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return handle_service_.release(impl, ec);
-  }
-
-  // Cancel all operations associated with the file.
-  asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return handle_service_.cancel(impl, ec);
-  }
-
-  // Get the size of the file.
-  ASIO_DECL uint64_t size(const implementation_type& impl,
-      asio::error_code& ec) const;
-
-  // Alter the size of the file.
-  ASIO_DECL asio::error_code resize(implementation_type& impl,
-      uint64_t n, asio::error_code& ec);
-
-  // Synchronise the file to disk.
-  ASIO_DECL asio::error_code sync_all(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Synchronise the file data to disk.
-  ASIO_DECL asio::error_code sync_data(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Seek to a position in the file.
-  ASIO_DECL uint64_t seek(implementation_type& impl, int64_t offset,
-      file_base::seek_basis whence, asio::error_code& ec);
-
-  // Write the given data. Returns the number of bytes written.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    uint64_t offset = impl.offset_;
-    impl.offset_ += asio::buffer_size(buffers);
-    return handle_service_.write_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous write. The data being written must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    uint64_t offset = impl.offset_;
-    impl.offset_ += asio::buffer_size(buffers);
-    handle_service_.async_write_some_at(impl, offset, buffers, handler, io_ex);
-  }
-
-  // Write the given data at the specified location. Returns the number of
-  // bytes written.
-  template <typename ConstBufferSequence>
-  size_t write_some_at(implementation_type& impl, uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return handle_service_.write_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous write at the specified location. The data being
-  // written must be valid for the lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl,
-      uint64_t offset, const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    handle_service_.async_write_some_at(impl, offset, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    uint64_t offset = impl.offset_;
-    impl.offset_ += asio::buffer_size(buffers);
-    return handle_service_.read_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    uint64_t offset = impl.offset_;
-    impl.offset_ += asio::buffer_size(buffers);
-    handle_service_.async_read_some_at(impl, offset, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes read.
-  template <typename MutableBufferSequence>
-  size_t read_some_at(implementation_type& impl, uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return handle_service_.read_some_at(impl, offset, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being read must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    handle_service_.async_read_some_at(impl, offset, buffers, handler, io_ex);
-  }
-
-private:
-  // The implementation used for initiating asynchronous operations.
-  win_iocp_handle_service handle_service_;
-
-  // Emulation of Windows IO_STATUS_BLOCK structure.
-  struct io_status_block
-  {
-    union u
-    {
-      LONG Status;
-      void* Pointer;
-    };
-    ULONG_PTR Information;
-  };
-
-  // Emulation of flag passed to NtFlushBuffersFileEx.
-  enum { flush_flags_file_data_sync_only = 4 };
-
-  // The type of a NtFlushBuffersFileEx function pointer.
-  typedef LONG (NTAPI *nt_flush_buffers_file_ex_fn)(
-      HANDLE, ULONG, void*, ULONG, io_status_block*);
-
-  // The NTFlushBuffersFileEx function pointer.
-  nt_flush_buffers_file_ex_fn nt_flush_buffers_file_ex_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_file_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_FILE)
-
-#endif // ASIO_DETAIL_WIN_IOCP_FILE_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_read_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_read_op.hpp
deleted file mode 100644
index 9721bda..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_read_op.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// detail/win_iocp_handle_read_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class win_iocp_handle_read_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_read_op);
-
-  win_iocp_handle_read_op(const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_handle_read_op::do_complete),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    if (owner)
-    {
-      // Check whether buffers are still valid.
-      buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    // Map non-portable errors to their portable counterparts.
-    if (ec.value() == ERROR_HANDLE_EOF)
-      ec = asio::error::eof;
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  MutableBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_service.hpp
deleted file mode 100644
index 9e2486b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_service.hpp
+++ /dev/null
@@ -1,431 +0,0 @@
-//
-// detail/win_iocp_handle_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP
-#define ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/win_iocp_handle_read_op.hpp"
-#include "asio/detail/win_iocp_handle_write_op.hpp"
-#include "asio/detail/win_iocp_io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_handle_service :
-  public execution_context_service_base<win_iocp_handle_service>
-{
-public:
-  // The native type of a stream handle.
-  typedef HANDLE native_handle_type;
-
-  // The implementation type of the stream handle.
-  class implementation_type
-  {
-  public:
-    // Default constructor.
-    implementation_type()
-      : handle_(INVALID_HANDLE_VALUE),
-        safe_cancellation_thread_id_(0),
-        next_(0),
-        prev_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class win_iocp_handle_service;
-
-    // The native stream handle representation.
-    native_handle_type handle_;
-
-    // The ID of the thread from which it is safe to cancel asynchronous
-    // operations. 0 means no asynchronous operations have been started yet.
-    // ~0 means asynchronous operations have been started from more than one
-    // thread, and cancellation is not supported for the handle.
-    DWORD safe_cancellation_thread_id_;
-
-    // Pointers to adjacent handle implementations in linked list.
-    implementation_type* next_;
-    implementation_type* prev_;
-  };
-
-  ASIO_DECL win_iocp_handle_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new handle implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Move-construct a new handle implementation.
-  ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another handle implementation.
-  ASIO_DECL void move_assign(implementation_type& impl,
-      win_iocp_handle_service& other_service,
-      implementation_type& other_impl);
-
-  // Destroy a handle implementation.
-  ASIO_DECL void destroy(implementation_type& impl);
-
-  // Assign a native handle to a handle implementation.
-  ASIO_DECL asio::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, asio::error_code& ec);
-
-  // Determine whether the handle is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return impl.handle_ != INVALID_HANDLE_VALUE;
-  }
-
-  // Destroy a handle implementation.
-  ASIO_DECL asio::error_code close(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Release ownership of a handle.
-  ASIO_DECL native_handle_type release(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Get the native handle representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return impl.handle_;
-  }
-
-  // Cancel all operations associated with the handle.
-  ASIO_DECL asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Write the given data. Returns the number of bytes written.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return write_some_at(impl, 0, buffers, ec);
-  }
-
-  // Write the given data at the specified offset. Returns the number of bytes
-  // written.
-  template <typename ConstBufferSequence>
-  size_t write_some_at(implementation_type& impl, uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    asio::const_buffer buffer =
-      buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence>::first(buffers);
-
-    return do_write(impl, offset, buffer, ec);
-  }
-
-  // Start an asynchronous write. The data being written must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_handle_write_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
-          reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
-
-    start_write_op(impl, 0,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::first(buffers), o);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous write at a specified offset. The data being written
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl,
-      uint64_t offset, const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_handle_write_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
-          reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some_at"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
-
-    start_write_op(impl, offset,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::first(buffers), o);
-    p.v = p.p = 0;
-  }
-
-  // Read some data. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return read_some_at(impl, 0, buffers, ec);
-  }
-
-  // Read some data at a specified offset. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t read_some_at(implementation_type& impl, uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    asio::mutable_buffer buffer =
-      buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence>::first(buffers);
-
-    return do_read(impl, offset, buffer, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being received must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_handle_read_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
-          reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
-
-    start_read_op(impl, 0,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), o);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous read at a specified offset. The buffer for the data
-  // being received must be valid for the lifetime of the asynchronous
-  // operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_handle_read_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((iocp_service_.context(), *p.p, "handle", &impl,
-          reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some_at"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.handle_, o);
-
-    start_read_op(impl, offset,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), o);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Prevent the use of the null_buffers type with this service.
-  size_t write_some(implementation_type& impl,
-      const null_buffers& buffers, asio::error_code& ec);
-  size_t write_some_at(implementation_type& impl, uint64_t offset,
-      const null_buffers& buffers, asio::error_code& ec);
-  template <typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const null_buffers& buffers, Handler& handler,
-      const IoExecutor& io_ex);
-  template <typename Handler, typename IoExecutor>
-  void async_write_some_at(implementation_type& impl, uint64_t offset,
-      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex);
-  size_t read_some(implementation_type& impl,
-      const null_buffers& buffers, asio::error_code& ec);
-  size_t read_some_at(implementation_type& impl, uint64_t offset,
-      const null_buffers& buffers, asio::error_code& ec);
-  template <typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const null_buffers& buffers, Handler& handler,
-      const IoExecutor& io_ex);
-  template <typename Handler, typename IoExecutor>
-  void async_read_some_at(implementation_type& impl, uint64_t offset,
-      const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex);
-
-  // Helper class for waiting for synchronous operations to complete.
-  class overlapped_wrapper;
-
-  // Helper function to perform a synchronous write operation.
-  ASIO_DECL size_t do_write(implementation_type& impl,
-      uint64_t offset, const asio::const_buffer& buffer,
-      asio::error_code& ec);
-
-  // Helper function to start a write operation.
-  ASIO_DECL void start_write_op(implementation_type& impl,
-      uint64_t offset, const asio::const_buffer& buffer,
-      operation* op);
-
-  // Helper function to perform a synchronous write operation.
-  ASIO_DECL size_t do_read(implementation_type& impl,
-      uint64_t offset, const asio::mutable_buffer& buffer,
-      asio::error_code& ec);
-
-  // Helper function to start a read operation.
-  ASIO_DECL void start_read_op(implementation_type& impl,
-      uint64_t offset, const asio::mutable_buffer& buffer,
-      operation* op);
-
-  // Update the ID of the thread from which cancellation is safe.
-  ASIO_DECL void update_cancellation_thread_id(implementation_type& impl);
-
-  // Helper function to close a handle when the associated object is being
-  // destroyed.
-  ASIO_DECL void close_for_destruction(implementation_type& impl);
-
-  // The type of a NtSetInformationFile function pointer.
-  typedef LONG (NTAPI *nt_set_info_fn)(HANDLE, ULONG_PTR*, void*, ULONG, ULONG);
-
-  // Helper function to get the NtSetInformationFile function pointer. If no
-  // NtSetInformationFile pointer has been obtained yet, one is obtained using
-  // GetProcAddress and the pointer is cached. Returns a null pointer if
-  // NtSetInformationFile is not available.
-  ASIO_DECL nt_set_info_fn get_nt_set_info();
-
-  // Helper function to emulate InterlockedCompareExchangePointer functionality
-  // for:
-  // - very old Platform SDKs; and
-  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
-  ASIO_DECL void* interlocked_compare_exchange_pointer(
-      void** dest, void* exch, void* cmp);
-
-  // Helper function to emulate InterlockedExchangePointer functionality for:
-  // - very old Platform SDKs; and
-  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
-  ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val);
-
-  // Helper class used to implement per operation cancellation.
-  class iocp_op_cancellation : public operation
-  {
-  public:
-    iocp_op_cancellation(HANDLE h, operation* target)
-      : operation(&iocp_op_cancellation::do_complete),
-        handle_(h),
-        target_(target)
-    {
-    }
-
-    static void do_complete(void* owner, operation* base,
-        const asio::error_code& result_ec,
-        std::size_t bytes_transferred)
-    {
-      iocp_op_cancellation* o = static_cast<iocp_op_cancellation*>(base);
-      o->target_->complete(owner, result_ec, bytes_transferred);
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        ::CancelIoEx(handle_, this);
-      }
-#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      (void)type;
-#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-    }
-
-  private:
-    HANDLE handle_;
-    operation* target_;
-  };
-
-  // The IOCP service used for running asynchronous operations and dispatching
-  // handlers.
-  win_iocp_io_context& iocp_service_;
-
-  // Pointer to NtSetInformationFile implementation.
-  void* nt_set_info_;
-
-  // Mutex to protect access to the linked list of implementations.
-  mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  implementation_type* impl_list_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_handle_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_write_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_write_op.hpp
deleted file mode 100644
index 6a5b7e7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_handle_write_op.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//
-// detail/win_iocp_handle_write_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class win_iocp_handle_write_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_write_op);
-
-  win_iocp_handle_write_op(const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_handle_write_op::do_complete),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec, std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    if (owner)
-    {
-      // Check whether buffers are still valid.
-      buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  ConstBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_io_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_io_context.hpp
deleted file mode 100644
index 1de94df..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_io_context.hpp
+++ /dev/null
@@ -1,347 +0,0 @@
-//
-// detail/win_iocp_io_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
-#define ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/limits.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/thread.hpp"
-#include "asio/detail/thread_context.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/detail/win_iocp_operation.hpp"
-#include "asio/detail/win_iocp_thread_info.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class wait_op;
-
-class win_iocp_io_context
-  : public execution_context_service_base<win_iocp_io_context>,
-    public thread_context
-{
-public:
-  // Constructor. Specifies a concurrency hint that is passed through to the
-  // underlying I/O completion port.
-  ASIO_DECL win_iocp_io_context(asio::execution_context& ctx,
-      int concurrency_hint = -1, bool own_thread = true);
-
-  // Destructor.
-  ASIO_DECL ~win_iocp_io_context();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Initialise the task. Nothing to do here.
-  void init_task()
-  {
-  }
-
-  // Register a handle with the IO completion port.
-  ASIO_DECL asio::error_code register_handle(
-      HANDLE handle, asio::error_code& ec);
-
-  // Run the event loop until stopped or no more work.
-  ASIO_DECL size_t run(asio::error_code& ec);
-
-  // Run until stopped or one operation is performed.
-  ASIO_DECL size_t run_one(asio::error_code& ec);
-
-  // Run until timeout, interrupted, or one operation is performed.
-  ASIO_DECL size_t wait_one(long usec, asio::error_code& ec);
-
-  // Poll for operations without blocking.
-  ASIO_DECL size_t poll(asio::error_code& ec);
-
-  // Poll for one operation without blocking.
-  ASIO_DECL size_t poll_one(asio::error_code& ec);
-
-  // Stop the event processing loop.
-  ASIO_DECL void stop();
-
-  // Determine whether the io_context is stopped.
-  bool stopped() const
-  {
-    return ::InterlockedExchangeAdd(&stopped_, 0) != 0;
-  }
-
-  // Restart in preparation for a subsequent run invocation.
-  void restart()
-  {
-    ::InterlockedExchange(&stopped_, 0);
-  }
-
-  // Notify that some work has started.
-  void work_started()
-  {
-    ::InterlockedIncrement(&outstanding_work_);
-  }
-
-  // Notify that some work has finished.
-  void work_finished()
-  {
-    if (::InterlockedDecrement(&outstanding_work_) == 0)
-      stop();
-  }
-
-  // Return whether a handler can be dispatched immediately.
-  ASIO_DECL bool can_dispatch();
-
-  /// Capture the current exception so it can be rethrown from a run function.
-  ASIO_DECL void capture_current_exception();
-
-  // Request invocation of the given operation and return immediately. Assumes
-  // that work_started() has not yet been called for the operation.
-  void post_immediate_completion(win_iocp_operation* op, bool)
-  {
-    work_started();
-    post_deferred_completion(op);
-  }
-
-  // Request invocation of the given operation and return immediately. Assumes
-  // that work_started() was previously called for the operation.
-  ASIO_DECL void post_deferred_completion(win_iocp_operation* op);
-
-  // Request invocation of the given operation and return immediately. Assumes
-  // that work_started() was previously called for the operations.
-  ASIO_DECL void post_deferred_completions(
-      op_queue<win_iocp_operation>& ops);
-
-  // Request invocation of the given operation using the thread-private queue
-  // and return immediately. Assumes that work_started() has not yet been
-  // called for the operation.
-  void post_private_immediate_completion(win_iocp_operation* op)
-  {
-    post_immediate_completion(op, false);
-  }
-
-  // Request invocation of the given operation using the thread-private queue
-  // and return immediately. Assumes that work_started() was previously called
-  // for the operation.
-  void post_private_deferred_completion(win_iocp_operation* op)
-  {
-    post_deferred_completion(op);
-  }
-
-  // Enqueue the given operation following a failed attempt to dispatch the
-  // operation for immediate invocation.
-  void do_dispatch(operation* op)
-  {
-    post_immediate_completion(op, false);
-  }
-
-  // Process unfinished operations as part of a shutdown operation. Assumes
-  // that work_started() was previously called for the operations.
-  ASIO_DECL void abandon_operations(op_queue<operation>& ops);
-
-  // Called after starting an overlapped I/O operation that did not complete
-  // immediately. The caller must have already called work_started() prior to
-  // starting the operation.
-  ASIO_DECL void on_pending(win_iocp_operation* op);
-
-  // Called after starting an overlapped I/O operation that completed
-  // immediately. The caller must have already called work_started() prior to
-  // starting the operation.
-  ASIO_DECL void on_completion(win_iocp_operation* op,
-      DWORD last_error = 0, DWORD bytes_transferred = 0);
-
-  // Called after starting an overlapped I/O operation that completed
-  // immediately. The caller must have already called work_started() prior to
-  // starting the operation.
-  ASIO_DECL void on_completion(win_iocp_operation* op,
-      const asio::error_code& ec, DWORD bytes_transferred = 0);
-
-  // Add a new timer queue to the service.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Remove a timer queue from the service.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer associated with the given token. Returns the number of
-  // handlers that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Cancel the timer operations associated with the given key.
-  template <typename Time_Traits>
-  void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data* timer,
-      void* cancellation_key);
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& to,
-      typename timer_queue<Time_Traits>::per_timer_data& from);
-
-  // Get the concurrency hint that was used to initialise the io_context.
-  int concurrency_hint() const
-  {
-    return concurrency_hint_;
-  }
-
-private:
-#if defined(WINVER) && (WINVER < 0x0500)
-  typedef DWORD dword_ptr_t;
-  typedef ULONG ulong_ptr_t;
-#else // defined(WINVER) && (WINVER < 0x0500)
-  typedef DWORD_PTR dword_ptr_t;
-  typedef ULONG_PTR ulong_ptr_t;
-#endif // defined(WINVER) && (WINVER < 0x0500)
-
-  // Dequeues at most one operation from the I/O completion port, and then
-  // executes it. Returns the number of operations that were dequeued (i.e.
-  // either 0 or 1).
-  ASIO_DECL size_t do_one(DWORD msec,
-      win_iocp_thread_info& this_thread, asio::error_code& ec);
-
-  // Helper to calculate the GetQueuedCompletionStatus timeout.
-  ASIO_DECL static DWORD get_gqcs_timeout();
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Called to recalculate and update the timeout.
-  ASIO_DECL void update_timeout();
-
-  // Helper class to call work_finished() on block exit.
-  struct work_finished_on_block_exit;
-
-  // Helper class for managing a HANDLE.
-  struct auto_handle
-  {
-    HANDLE handle;
-    auto_handle() : handle(0) {}
-    ~auto_handle() { if (handle) ::CloseHandle(handle); }
-  };
-
-  // The IO completion port used for queueing operations.
-  auto_handle iocp_;
-
-  // The count of unfinished work.
-  long outstanding_work_;
-
-  // Flag to indicate whether the event loop has been stopped.
-  mutable long stopped_;
-
-  // Flag to indicate whether there is an in-flight stop event. Every event
-  // posted using PostQueuedCompletionStatus consumes non-paged pool, so to
-  // avoid exhausting this resouce we limit the number of outstanding events.
-  long stop_event_posted_;
-
-  // Flag to indicate whether the service has been shut down.
-  long shutdown_;
-
-  enum
-  {
-#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
-    // Timeout to use with GetQueuedCompletionStatus on older versions of
-    // Windows. Some versions of windows have a "bug" where a call to
-    // GetQueuedCompletionStatus can appear stuck even though there are events
-    // waiting on the queue. Using a timeout helps to work around the issue.
-    default_gqcs_timeout = 500,
-#endif // !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600)
-
-    // Maximum waitable timer timeout, in milliseconds.
-    max_timeout_msec = 5 * 60 * 1000,
-
-    // Maximum waitable timer timeout, in microseconds.
-    max_timeout_usec = max_timeout_msec * 1000,
-
-    // Completion key value used to wake up a thread to dispatch timers or
-    // completed operations.
-    wake_for_dispatch = 1,
-
-    // Completion key value to indicate that an operation has posted with the
-    // original last_error and bytes_transferred values stored in the fields of
-    // the OVERLAPPED structure.
-    overlapped_contains_result = 2
-  };
-
-  // Timeout to use with GetQueuedCompletionStatus.
-  const DWORD gqcs_timeout_;
-
-  // Helper class to run the scheduler in its own thread.
-  struct thread_function;
-  friend struct thread_function;
-
-  // Function object for processing timeouts in a background thread.
-  struct timer_thread_function;
-  friend struct timer_thread_function;
-
-  // Background thread used for processing timeouts.
-  scoped_ptr<thread> timer_thread_;
-
-  // A waitable timer object used for waiting for timeouts.
-  auto_handle waitable_timer_;
-
-  // Non-zero if timers or completed operations need to be dispatched.
-  long dispatch_required_;
-
-  // Mutex for protecting access to the timer queues and completed operations.
-  mutex dispatch_mutex_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // The operations that are ready to dispatch.
-  op_queue<win_iocp_operation> completed_ops_;
-
-  // The concurrency hint used to initialise the io_context.
-  const int concurrency_hint_;
-
-  // The thread that is running the io_context.
-  scoped_ptr<thread> thread_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/win_iocp_io_context.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_io_context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_null_buffers_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_null_buffers_op.hpp
deleted file mode 100644
index 07751b9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_null_buffers_op.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// detail/win_iocp_null_buffers_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class win_iocp_null_buffers_op : public reactor_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_null_buffers_op);
-
-  win_iocp_null_buffers_op(socket_ops::weak_cancel_token_type cancel_token,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactor_op(asio::error_code(),
-        &win_iocp_null_buffers_op::do_perform,
-        &win_iocp_null_buffers_op::do_complete),
-      cancel_token_(cancel_token),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static status do_perform(reactor_op*)
-  {
-    return done;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // The reactor may have stored a result in the operation object.
-    if (o->ec_)
-      ec = o->ec_;
-
-    // Map non-portable errors to their portable counterparts.
-    if (ec.value() == ERROR_NETNAME_DELETED)
-    {
-      if (o->cancel_token_.expired())
-        ec = asio::error::operation_aborted;
-      else
-        ec = asio::error::connection_reset;
-    }
-    else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    {
-      ec = asio::error::connection_refused;
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_operation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_operation.hpp
deleted file mode 100644
index a935f87..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_operation.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// detail/win_iocp_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
-#define ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_io_context;
-
-// Base class for all operations. A function pointer is used instead of virtual
-// functions to avoid the associated overhead.
-class win_iocp_operation
-  : public OVERLAPPED
-    ASIO_ALSO_INHERIT_TRACKED_HANDLER
-{
-public:
-  typedef win_iocp_operation operation_type;
-
-  void complete(void* owner, const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    func_(owner, this, ec, bytes_transferred);
-  }
-
-  void destroy()
-  {
-    func_(0, this, asio::error_code(), 0);
-  }
-
-  void reset()
-  {
-    Internal = 0;
-    InternalHigh = 0;
-    Offset = 0;
-    OffsetHigh = 0;
-    hEvent = 0;
-    ready_ = 0;
-  }
-
-protected:
-  typedef void (*func_type)(
-      void*, win_iocp_operation*,
-      const asio::error_code&, std::size_t);
-
-  win_iocp_operation(func_type func)
-    : next_(0),
-      func_(func)
-  {
-    reset();
-  }
-
-  // Prevents deletion through this type.
-  ~win_iocp_operation()
-  {
-  }
-
-private:
-  friend class op_queue_access;
-  friend class win_iocp_io_context;
-  win_iocp_operation* next_;
-  func_type func_;
-  long ready_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_op.hpp
deleted file mode 100644
index dc65ad0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_op.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// detail/win_iocp_overlapped_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class win_iocp_overlapped_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_overlapped_op);
-
-  win_iocp_overlapped_op(Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_overlapped_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec, std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_ptr.hpp
deleted file mode 100644
index 596705a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_overlapped_ptr.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// detail/win_iocp_overlapped_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP
-#define ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/io_context.hpp"
-#include "asio/query.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/win_iocp_overlapped_op.hpp"
-#include "asio/detail/win_iocp_io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
-class win_iocp_overlapped_ptr
-  : private noncopyable
-{
-public:
-  // Construct an empty win_iocp_overlapped_ptr.
-  win_iocp_overlapped_ptr()
-    : ptr_(0),
-      iocp_service_(0)
-  {
-  }
-
-  // Construct an win_iocp_overlapped_ptr to contain the specified handler.
-  template <typename Executor, typename Handler>
-  explicit win_iocp_overlapped_ptr(const Executor& ex,
-      Handler&& handler)
-    : ptr_(0),
-      iocp_service_(0)
-  {
-    this->reset(ex, static_cast<Handler&&>(handler));
-  }
-
-  // Destructor automatically frees the OVERLAPPED object unless released.
-  ~win_iocp_overlapped_ptr()
-  {
-    reset();
-  }
-
-  // Reset to empty.
-  void reset()
-  {
-    if (ptr_)
-    {
-      ptr_->destroy();
-      ptr_ = 0;
-      iocp_service_->work_finished();
-      iocp_service_ = 0;
-    }
-  }
-
-  // Reset to contain the specified handler, freeing any current OVERLAPPED
-  // object.
-  template <typename Executor, typename Handler>
-  void reset(const Executor& ex, Handler handler)
-  {
-    win_iocp_io_context* iocp_service = this->get_iocp_service(ex);
-
-    typedef win_iocp_overlapped_op<Handler, Executor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, ex);
-
-    ASIO_HANDLER_CREATION((ex.context(), *p.p,
-          "iocp_service", iocp_service, 0, "overlapped"));
-
-    iocp_service->work_started();
-    reset();
-    ptr_ = p.p;
-    p.v = p.p = 0;
-    iocp_service_ = iocp_service;
-  }
-
-  // Get the contained OVERLAPPED object.
-  OVERLAPPED* get()
-  {
-    return ptr_;
-  }
-
-  // Get the contained OVERLAPPED object.
-  const OVERLAPPED* get() const
-  {
-    return ptr_;
-  }
-
-  // Release ownership of the OVERLAPPED object.
-  OVERLAPPED* release()
-  {
-    if (ptr_)
-      iocp_service_->on_pending(ptr_);
-
-    OVERLAPPED* tmp = ptr_;
-    ptr_ = 0;
-    iocp_service_ = 0;
-    return tmp;
-  }
-
-  // Post completion notification for overlapped operation. Releases ownership.
-  void complete(const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    if (ptr_)
-    {
-      iocp_service_->on_completion(ptr_, ec,
-          static_cast<DWORD>(bytes_transferred));
-      ptr_ = 0;
-      iocp_service_ = 0;
-    }
-  }
-
-private:
-  template <typename Executor>
-  static win_iocp_io_context* get_iocp_service(const Executor& ex,
-      enable_if_t<
-        can_query<const Executor&, execution::context_t>::value
-      >* = 0)
-  {
-    return &use_service<win_iocp_io_context>(
-        asio::query(ex, execution::context));
-  }
-
-  template <typename Executor>
-  static win_iocp_io_context* get_iocp_service(const Executor& ex,
-      enable_if_t<
-        !can_query<const Executor&, execution::context_t>::value
-      >* = 0)
-  {
-    return &use_service<win_iocp_io_context>(ex.context());
-  }
-
-  static win_iocp_io_context* get_iocp_service(
-      const io_context::executor_type& ex)
-  {
-    return &asio::query(ex, execution::context).impl_;
-  }
-
-  win_iocp_operation* ptr_;
-  win_iocp_io_context* iocp_service_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_serial_port_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_serial_port_service.hpp
deleted file mode 100644
index e0e12e9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_serial_port_service.hpp
+++ /dev/null
@@ -1,233 +0,0 @@
-//
-// detail/win_iocp_serial_port_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
-#define ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#include <string>
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/win_iocp_handle_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Extend win_iocp_handle_service to provide serial port support.
-class win_iocp_serial_port_service :
-  public execution_context_service_base<win_iocp_serial_port_service>
-{
-public:
-  // The native type of a serial port.
-  typedef win_iocp_handle_service::native_handle_type native_handle_type;
-
-  // The implementation type of the serial port.
-  typedef win_iocp_handle_service::implementation_type implementation_type;
-
-  // Constructor.
-  ASIO_DECL win_iocp_serial_port_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new serial port implementation.
-  void construct(implementation_type& impl)
-  {
-    handle_service_.construct(impl);
-  }
-
-  // Move-construct a new serial port implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another serial port implementation.
-  void move_assign(implementation_type& impl,
-      win_iocp_serial_port_service& other_service,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_assign(impl,
-        other_service.handle_service_, other_impl);
-  }
-
-  // Destroy a serial port implementation.
-  void destroy(implementation_type& impl)
-  {
-    handle_service_.destroy(impl);
-  }
-
-  // Open the serial port using the specified device name.
-  ASIO_DECL asio::error_code open(implementation_type& impl,
-      const std::string& device, asio::error_code& ec);
-
-  // Assign a native handle to a serial port implementation.
-  asio::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, asio::error_code& ec)
-  {
-    return handle_service_.assign(impl, handle, ec);
-  }
-
-  // Determine whether the serial port is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return handle_service_.is_open(impl);
-  }
-
-  // Destroy a serial port implementation.
-  asio::error_code close(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return handle_service_.close(impl, ec);
-  }
-
-  // Get the native serial port representation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return handle_service_.native_handle(impl);
-  }
-
-  // Cancel all operations associated with the handle.
-  asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return handle_service_.cancel(impl, ec);
-  }
-
-  // Set an option on the serial port.
-  template <typename SettableSerialPortOption>
-  asio::error_code set_option(implementation_type& impl,
-      const SettableSerialPortOption& option, asio::error_code& ec)
-  {
-    return do_set_option(impl,
-        &win_iocp_serial_port_service::store_option<SettableSerialPortOption>,
-        &option, ec);
-  }
-
-  // Get an option from the serial port.
-  template <typename GettableSerialPortOption>
-  asio::error_code get_option(const implementation_type& impl,
-      GettableSerialPortOption& option, asio::error_code& ec) const
-  {
-    return do_get_option(impl,
-        &win_iocp_serial_port_service::load_option<GettableSerialPortOption>,
-        &option, ec);
-  }
-
-  // Send a break sequence to the serial port.
-  asio::error_code send_break(implementation_type&,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Write the given data. Returns the number of bytes sent.
-  template <typename ConstBufferSequence>
-  size_t write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return handle_service_.write_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous write. The data being written must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    handle_service_.async_write_some(impl, buffers, handler, io_ex);
-  }
-
-  // Read some data. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  size_t read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return handle_service_.read_some(impl, buffers, ec);
-  }
-
-  // Start an asynchronous read. The buffer for the data being received must be
-  // valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    handle_service_.async_read_some(impl, buffers, handler, io_ex);
-  }
-
-private:
-  // Function pointer type for storing a serial port option.
-  typedef asio::error_code (*store_function_type)(
-      const void*, ::DCB&, asio::error_code&);
-
-  // Helper function template to store a serial port option.
-  template <typename SettableSerialPortOption>
-  static asio::error_code store_option(const void* option,
-      ::DCB& storage, asio::error_code& ec)
-  {
-    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
-    return ec;
-  }
-
-  // Helper function to set a serial port option.
-  ASIO_DECL asio::error_code do_set_option(
-      implementation_type& impl, store_function_type store,
-      const void* option, asio::error_code& ec);
-
-  // Function pointer type for loading a serial port option.
-  typedef asio::error_code (*load_function_type)(
-      void*, const ::DCB&, asio::error_code&);
-
-  // Helper function template to load a serial port option.
-  template <typename GettableSerialPortOption>
-  static asio::error_code load_option(void* option,
-      const ::DCB& storage, asio::error_code& ec)
-  {
-    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
-    return ec;
-  }
-
-  // Helper function to get a serial port option.
-  ASIO_DECL asio::error_code do_get_option(
-      const implementation_type& impl, load_function_type load,
-      void* option, asio::error_code& ec) const;
-
-  // The implementation used for initiating asynchronous operations.
-  win_iocp_handle_service handle_service_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_serial_port_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_accept_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_accept_op.hpp
deleted file mode 100644
index f4aa850..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_accept_op.hpp
+++ /dev/null
@@ -1,339 +0,0 @@
-//
-// detail/win_iocp_socket_accept_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/win_iocp_socket_service_base.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Socket, typename Protocol,
-    typename Handler, typename IoExecutor>
-class win_iocp_socket_accept_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_accept_op);
-
-  win_iocp_socket_accept_op(win_iocp_socket_service_base& socket_service,
-      socket_type socket, Socket& peer, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint,
-      bool enable_connection_aborted, Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_accept_op::do_complete),
-      socket_service_(socket_service),
-      socket_(socket),
-      peer_(peer),
-      protocol_(protocol),
-      peer_endpoint_(peer_endpoint),
-      enable_connection_aborted_(enable_connection_aborted),
-      proxy_op_(0),
-      cancel_requested_(0),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  socket_holder& new_socket()
-  {
-    return new_socket_;
-  }
-
-  void* output_buffer()
-  {
-    return output_buffer_;
-  }
-
-  DWORD address_length()
-  {
-    return sizeof(sockaddr_storage_type) + 16;
-  }
-
-  void enable_cancellation(long* cancel_requested, operation* proxy_op)
-  {
-    cancel_requested_ = cancel_requested;
-    proxy_op_ = proxy_op;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t /*bytes_transferred*/)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner)
-    {
-      typename Protocol::endpoint peer_endpoint;
-      std::size_t addr_len = peer_endpoint.capacity();
-      socket_ops::complete_iocp_accept(o->socket_,
-          o->output_buffer(), o->address_length(),
-          peer_endpoint.data(), &addr_len,
-          o->new_socket_.get(), ec);
-
-      // Restart the accept operation if we got the connection_aborted error
-      // and the enable_connection_aborted socket option is not set.
-      if (ec == asio::error::connection_aborted
-          && !o->enable_connection_aborted_)
-      {
-        o->reset();
-        if (o->proxy_op_)
-          o->proxy_op_->reset();
-        o->socket_service_.restart_accept_op(o->socket_,
-            o->new_socket_, o->protocol_.family(),
-            o->protocol_.type(), o->protocol_.protocol(),
-            o->output_buffer(), o->address_length(),
-            o->cancel_requested_, o->proxy_op_ ? o->proxy_op_ : o);
-        p.v = p.p = 0;
-        return;
-      }
-
-      // If the socket was successfully accepted, transfer ownership of the
-      // socket to the peer object.
-      if (!ec)
-      {
-        o->peer_.assign(o->protocol_,
-            typename Socket::native_handle_type(
-              o->new_socket_.get(), peer_endpoint), ec);
-        if (!ec)
-          o->new_socket_.release();
-      }
-
-      // Pass endpoint back to caller.
-      if (o->peer_endpoint_)
-        *o->peer_endpoint_ = peer_endpoint;
-    }
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, ec);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  win_iocp_socket_service_base& socket_service_;
-  socket_type socket_;
-  socket_holder new_socket_;
-  Socket& peer_;
-  Protocol protocol_;
-  typename Protocol::endpoint* peer_endpoint_;
-  unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
-  bool enable_connection_aborted_;
-  operation* proxy_op_;
-  long* cancel_requested_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-template <typename Protocol, typename PeerIoExecutor,
-    typename Handler, typename IoExecutor>
-class win_iocp_socket_move_accept_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_move_accept_op);
-
-  win_iocp_socket_move_accept_op(
-      win_iocp_socket_service_base& socket_service, socket_type socket,
-      const Protocol& protocol, const PeerIoExecutor& peer_io_ex,
-      typename Protocol::endpoint* peer_endpoint,
-      bool enable_connection_aborted, Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_move_accept_op::do_complete),
-      socket_service_(socket_service),
-      socket_(socket),
-      peer_(peer_io_ex),
-      protocol_(protocol),
-      peer_endpoint_(peer_endpoint),
-      enable_connection_aborted_(enable_connection_aborted),
-      cancel_requested_(0),
-      proxy_op_(0),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  socket_holder& new_socket()
-  {
-    return new_socket_;
-  }
-
-  void* output_buffer()
-  {
-    return output_buffer_;
-  }
-
-  DWORD address_length()
-  {
-    return sizeof(sockaddr_storage_type) + 16;
-  }
-
-  void enable_cancellation(long* cancel_requested, operation* proxy_op)
-  {
-    cancel_requested_ = cancel_requested;
-    proxy_op_ = proxy_op;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t /*bytes_transferred*/)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_move_accept_op* o(
-        static_cast<win_iocp_socket_move_accept_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner)
-    {
-      typename Protocol::endpoint peer_endpoint;
-      std::size_t addr_len = peer_endpoint.capacity();
-      socket_ops::complete_iocp_accept(o->socket_,
-          o->output_buffer(), o->address_length(),
-          peer_endpoint.data(), &addr_len,
-          o->new_socket_.get(), ec);
-
-      // Restart the accept operation if we got the connection_aborted error
-      // and the enable_connection_aborted socket option is not set.
-      if (ec == asio::error::connection_aborted
-          && !o->enable_connection_aborted_)
-      {
-        o->reset();
-        if (o->proxy_op_)
-          o->proxy_op_->reset();
-        o->socket_service_.restart_accept_op(o->socket_,
-            o->new_socket_, o->protocol_.family(),
-            o->protocol_.type(), o->protocol_.protocol(),
-            o->output_buffer(), o->address_length(),
-            o->cancel_requested_, o->proxy_op_ ? o->proxy_op_ : o);
-        p.v = p.p = 0;
-        return;
-      }
-
-      // If the socket was successfully accepted, transfer ownership of the
-      // socket to the peer object.
-      if (!ec)
-      {
-        o->peer_.assign(o->protocol_,
-            typename Protocol::socket::native_handle_type(
-              o->new_socket_.get(), peer_endpoint), ec);
-        if (!ec)
-          o->new_socket_.release();
-      }
-
-      // Pass endpoint back to caller.
-      if (o->peer_endpoint_)
-        *o->peer_endpoint_ = peer_endpoint;
-    }
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::move_binder2<Handler,
-      asio::error_code, peer_socket_type>
-        handler(0, static_cast<Handler&&>(o->handler_), ec,
-          static_cast<peer_socket_type&&>(o->peer_));
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  typedef typename Protocol::socket::template
-    rebind_executor<PeerIoExecutor>::other peer_socket_type;
-
-  win_iocp_socket_service_base& socket_service_;
-  socket_type socket_;
-  socket_holder new_socket_;
-  peer_socket_type peer_;
-  Protocol protocol_;
-  typename Protocol::endpoint* peer_endpoint_;
-  unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
-  bool enable_connection_aborted_;
-  long* cancel_requested_;
-  operation* proxy_op_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_connect_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_connect_op.hpp
deleted file mode 100644
index 104ee87..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_connect_op.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//
-// detail/win_iocp_socket_connect_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_socket_connect_op_base : public reactor_op
-{
-public:
-  win_iocp_socket_connect_op_base(socket_type socket, func_type complete_func)
-    : reactor_op(asio::error_code(),
-        &win_iocp_socket_connect_op_base::do_perform, complete_func),
-      socket_(socket),
-      connect_ex_(false)
-  {
-  }
-
-  static status do_perform(reactor_op* base)
-  {
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_connect_op_base* o(
-        static_cast<win_iocp_socket_connect_op_base*>(base));
-
-    return socket_ops::non_blocking_connect(
-        o->socket_, o->ec_) ? done : not_done;
-  }
-
-  socket_type socket_;
-  bool connect_ex_;
-};
-
-template <typename Handler, typename IoExecutor>
-class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_connect_op);
-
-  win_iocp_socket_connect_op(socket_type socket,
-      Handler& handler, const IoExecutor& io_ex)
-    : win_iocp_socket_connect_op_base(socket,
-        &win_iocp_socket_connect_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t /*bytes_transferred*/)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_connect_op* o(
-        static_cast<win_iocp_socket_connect_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    if (owner)
-    {
-      if (o->connect_ex_)
-        socket_ops::complete_iocp_connect(o->socket_, ec);
-      else
-        ec = o->ec_;
-    }
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, ec);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recv_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recv_op.hpp
deleted file mode 100644
index 874a12a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recv_op.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// detail/win_iocp_socket_recv_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class win_iocp_socket_recv_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recv_op);
-
-  win_iocp_socket_recv_op(socket_ops::state_type state,
-      socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_recv_op::do_complete),
-      state_(state),
-      cancel_token_(cancel_token),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    socket_ops::complete_iocp_recv(o->state_, o->cancel_token_,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::all_empty(o->buffers_),
-        ec, bytes_transferred);
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  socket_ops::state_type state_;
-  socket_ops::weak_cancel_token_type cancel_token_;
-  MutableBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvfrom_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
deleted file mode 100644
index b4b98aa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvfrom_op.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//
-// detail/win_iocp_socket_recvfrom_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Endpoint,
-    typename Handler, typename IoExecutor>
-class win_iocp_socket_recvfrom_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvfrom_op);
-
-  win_iocp_socket_recvfrom_op(Endpoint& endpoint,
-      socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_recvfrom_op::do_complete),
-      endpoint_(endpoint),
-      endpoint_size_(static_cast<int>(endpoint.capacity())),
-      cancel_token_(cancel_token),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  int& endpoint_size()
-  {
-    return endpoint_size_;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_recvfrom_op* o(
-        static_cast<win_iocp_socket_recvfrom_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    socket_ops::complete_iocp_recvfrom(o->cancel_token_, ec);
-
-    // Record the size of the endpoint returned by the operation.
-    o->endpoint_.resize(o->endpoint_size_);
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Endpoint& endpoint_;
-  int endpoint_size_;
-  socket_ops::weak_cancel_token_type cancel_token_;
-  MutableBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvmsg_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
deleted file mode 100644
index 85e4b78..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_recvmsg_op.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// detail/win_iocp_socket_recvmsg_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-#include "asio/socket_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class win_iocp_socket_recvmsg_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvmsg_op);
-
-  win_iocp_socket_recvmsg_op(
-      socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags& out_flags,
-      Handler& handler, const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_recvmsg_op::do_complete),
-      cancel_token_(cancel_token),
-      buffers_(buffers),
-      out_flags_(out_flags),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_recvmsg_op* o(
-        static_cast<win_iocp_socket_recvmsg_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    socket_ops::complete_iocp_recvmsg(o->cancel_token_, ec);
-    o->out_flags_ = 0;
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags& out_flags_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_send_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_send_op.hpp
deleted file mode 100644
index c7043c4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_send_op.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//
-// detail/win_iocp_socket_send_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class win_iocp_socket_send_op : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_send_op);
-
-  win_iocp_socket_send_op(socket_ops::weak_cancel_token_type cancel_token,
-      const ConstBufferSequence& buffers, Handler& handler,
-      const IoExecutor& io_ex)
-    : operation(&win_iocp_socket_send_op::do_complete),
-      cancel_token_(cancel_token),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t bytes_transferred)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    socket_ops::complete_iocp_send(o->cancel_token_, ec);
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, ec, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  ConstBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service.hpp
deleted file mode 100644
index faeaffa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service.hpp
+++ /dev/null
@@ -1,680 +0,0 @@
-//
-// detail/win_iocp_socket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include <cstring>
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/select_reactor.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/win_iocp_io_context.hpp"
-#include "asio/detail/win_iocp_null_buffers_op.hpp"
-#include "asio/detail/win_iocp_socket_accept_op.hpp"
-#include "asio/detail/win_iocp_socket_connect_op.hpp"
-#include "asio/detail/win_iocp_socket_recvfrom_op.hpp"
-#include "asio/detail/win_iocp_socket_send_op.hpp"
-#include "asio/detail/win_iocp_socket_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class win_iocp_socket_service :
-  public execution_context_service_base<win_iocp_socket_service<Protocol>>,
-  public win_iocp_socket_service_base
-{
-public:
-  // The protocol type.
-  typedef Protocol protocol_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The native type of a socket.
-  class native_handle_type
-  {
-  public:
-    native_handle_type(socket_type s)
-      : socket_(s),
-        have_remote_endpoint_(false)
-    {
-    }
-
-    native_handle_type(socket_type s, const endpoint_type& ep)
-      : socket_(s),
-        have_remote_endpoint_(true),
-        remote_endpoint_(ep)
-    {
-    }
-
-    void operator=(socket_type s)
-    {
-      socket_ = s;
-      have_remote_endpoint_ = false;
-      remote_endpoint_ = endpoint_type();
-    }
-
-    operator socket_type() const
-    {
-      return socket_;
-    }
-
-    bool have_remote_endpoint() const
-    {
-      return have_remote_endpoint_;
-    }
-
-    endpoint_type remote_endpoint() const
-    {
-      return remote_endpoint_;
-    }
-
-  private:
-    socket_type socket_;
-    bool have_remote_endpoint_;
-    endpoint_type remote_endpoint_;
-  };
-
-  // The implementation type of the socket.
-  struct implementation_type :
-    win_iocp_socket_service_base::base_implementation_type
-  {
-    // Default constructor.
-    implementation_type()
-      : protocol_(endpoint_type().protocol()),
-        have_remote_endpoint_(false),
-        remote_endpoint_()
-    {
-    }
-
-    // The protocol associated with the socket.
-    protocol_type protocol_;
-
-    // Whether we have a cached remote endpoint.
-    bool have_remote_endpoint_;
-
-    // A cached remote endpoint.
-    endpoint_type remote_endpoint_;
-  };
-
-  // Constructor.
-  win_iocp_socket_service(execution_context& context)
-    : execution_context_service_base<
-        win_iocp_socket_service<Protocol>>(context),
-      win_iocp_socket_service_base(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    this->base_shutdown();
-  }
-
-  // Move-construct a new socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-
-    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
-    other_impl.have_remote_endpoint_ = false;
-
-    impl.remote_endpoint_ = other_impl.remote_endpoint_;
-    other_impl.remote_endpoint_ = endpoint_type();
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type& impl,
-      win_iocp_socket_service_base& other_service,
-      implementation_type& other_impl)
-  {
-    this->base_move_assign(impl, other_service, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-
-    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
-    other_impl.have_remote_endpoint_ = false;
-
-    impl.remote_endpoint_ = other_impl.remote_endpoint_;
-    other_impl.remote_endpoint_ = endpoint_type();
-  }
-
-  // Move-construct a new socket implementation from another protocol type.
-  template <typename Protocol1>
-  void converting_move_construct(implementation_type& impl,
-      win_iocp_socket_service<Protocol1>&,
-      typename win_iocp_socket_service<
-        Protocol1>::implementation_type& other_impl)
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = protocol_type(other_impl.protocol_);
-    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
-
-    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
-    other_impl.have_remote_endpoint_ = false;
-
-    impl.remote_endpoint_ = other_impl.remote_endpoint_;
-    other_impl.remote_endpoint_ = typename Protocol1::endpoint();
-  }
-
-  // Open a new socket implementation.
-  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;
-      impl.have_remote_endpoint_ = false;
-      impl.remote_endpoint_ = endpoint_type();
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Assign a native socket to a socket implementation.
-  asio::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      asio::error_code& ec)
-  {
-    if (!do_assign(impl, protocol.type(), native_socket, ec))
-    {
-      impl.protocol_ = protocol;
-      impl.have_remote_endpoint_ = native_socket.have_remote_endpoint();
-      impl.remote_endpoint_ = native_socket.remote_endpoint();
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the native socket representation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    if (impl.have_remote_endpoint_)
-      return native_handle_type(impl.socket_, impl.remote_endpoint_);
-    return native_handle_type(impl.socket_);
-  }
-
-  // Bind the socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
-      const endpoint_type& endpoint, asio::error_code& ec)
-  {
-    socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  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);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code get_option(const implementation_type& impl,
-      Option& option, asio::error_code& ec) const
-  {
-    std::size_t size = option.size(impl.protocol_);
-    socket_ops::getsockopt(impl.socket_, impl.state_,
-        option.level(impl.protocol_), option.name(impl.protocol_),
-        option.data(impl.protocol_), &size, ec);
-    if (!ec)
-      option.resize(impl.protocol_, size);
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint = impl.remote_endpoint_;
-    std::size_t addr_len = endpoint.capacity();
-    if (socket_ops::getpeername(impl.socket_, endpoint.data(),
-          &addr_len, impl.have_remote_endpoint_, ec))
-    {
-      ASIO_ERROR_LOCATION(ec);
-      return endpoint_type();
-    }
-    endpoint.resize(addr_len);
-    return endpoint;
-  }
-
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(base_implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
-  {
-    socket_ops::shutdown(impl.socket_, what, ec);
-    return ec;
-  }
-
-  // Send a datagram to the specified endpoint. Returns the number of bytes
-  // sent.
-  template <typename ConstBufferSequence>
-  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(buffers);
-
-    size_t n = socket_ops::sync_sendto(impl.socket_,
-        impl.state_, bufs.buffers(), bufs.count(), flags,
-        destination.data(), destination.size(), ec);
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags,
-      asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl,
-      const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_send_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(
-        impl.cancel_token_, buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_send_to"));
-
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(buffers);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
-
-    start_send_to_op(impl, bufs.buffers(), bufs.count(),
-        destination.data(), static_cast<int>(destination.size()),
-        flags, o);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    reactor_op* o = p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_send_to(null_buffers)"));
-
-    start_reactor_op(impl, select_reactor::write_op, o);
-    p.v = p.p = 0;
-  }
-
-  // Receive a datagram with the endpoint of the sender. Returns the number of
-  // bytes received.
-  template <typename MutableBufferSequence>
-  size_t receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    std::size_t addr_len = sender_endpoint.capacity();
-    std::size_t n = socket_ops::sync_recvfrom(impl.socket_,
-        impl.state_, bufs.buffers(), bufs.count(), flags,
-        sender_endpoint.data(), &addr_len, ec);
-
-    if (!ec)
-      sender_endpoint.resize(addr_len);
-
-    ASIO_ERROR_LOCATION(ec);
-    return n;
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_from(implementation_type& impl,
-      const null_buffers&, endpoint_type& sender_endpoint,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    ASIO_ERROR_LOCATION(ec);
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received and
-  // the sender_endpoint object must both be valid for the lifetime of the
-  // asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers, endpoint_type& sender_endp,
-      socket_base::message_flags flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_recvfrom_op<MutableBufferSequence,
-        endpoint_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(sender_endp,
-        impl.cancel_token_, buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive_from"));
-
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
-
-    start_receive_from_op(impl, bufs.buffers(), bufs.count(),
-        sender_endp.data(), flags, &p.p->endpoint_size(), o);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_from(implementation_type& impl, const null_buffers&,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive_from(null_buffers)"));
-
-    // Reset endpoint since it can be given no sensible value at this time.
-    sender_endpoint = endpoint_type();
-
-    // Optionally register for per-operation cancellation.
-    operation* iocp_op = p.p;
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ = iocp_op =
-        &slot.template emplace<reactor_op_cancellation>(
-            impl.socket_, iocp_op);
-    }
-
-    int op_type = start_null_buffers_receive_op(impl, flags, p.p, iocp_op);
-    p.v = p.p = 0;
-
-    // Update cancellation method if the reactor was used.
-    if (slot.is_connected() && op_type != -1)
-    {
-      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
-          &get_reactor(), &impl.reactor_data_, op_type);
-    }
-  }
-
-  // Accept a new connection.
-  template <typename Socket>
-  asio::error_code accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, asio::error_code& ec)
-  {
-    // We cannot accept a socket that is already open.
-    if (peer.is_open())
-    {
-      ec = asio::error::already_open;
-      ASIO_ERROR_LOCATION(ec);
-      return ec;
-    }
-
-    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
-    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
-          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
-          peer_endpoint ? &addr_len : 0, ec));
-
-    // On success, assign new connection to peer socket object.
-    if (new_socket.get() != invalid_socket)
-    {
-      if (peer_endpoint)
-        peer_endpoint->resize(addr_len);
-      peer.assign(impl.protocol_, new_socket.get(), ec);
-      if (!ec)
-        new_socket.release();
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Start an asynchronous accept. The peer and peer_endpoint objects
-  // must be valid until the accept's handler is invoked.
-  template <typename Socket, typename Handler, typename IoExecutor>
-  void async_accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_accept_op<Socket,
-        protocol_type, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    bool enable_connection_aborted =
-      (impl.state_ & socket_ops::enable_connection_aborted) != 0;
-    operation* o = p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
-        peer_endpoint, enable_connection_aborted, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_accept"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      accept_op_cancellation* c =
-        &slot.template emplace<accept_op_cancellation>(impl.socket_, o);
-      p.p->enable_cancellation(c->get_cancel_requested(), c);
-      o = c;
-    }
-
-    start_accept_op(impl, peer.is_open(), p.p->new_socket(),
-        impl.protocol_.family(), impl.protocol_.type(),
-        impl.protocol_.protocol(), p.p->output_buffer(),
-        p.p->address_length(), o);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous accept. The peer and peer_endpoint objects
-  // must be valid until the accept's handler is invoked.
-  template <typename PeerIoExecutor, typename Handler, typename IoExecutor>
-  void async_move_accept(implementation_type& impl,
-      const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_move_accept_op<
-        protocol_type, PeerIoExecutor, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    bool enable_connection_aborted =
-      (impl.state_ & socket_ops::enable_connection_aborted) != 0;
-    operation* o = p.p = new (p.v) op(*this, impl.socket_, impl.protocol_,
-        peer_io_ex, peer_endpoint, enable_connection_aborted,
-        handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_accept"));
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      accept_op_cancellation* c =
-        &slot.template emplace<accept_op_cancellation>(impl.socket_, o);
-      p.p->enable_cancellation(c->get_cancel_requested(), c);
-      o = c;
-    }
-
-    start_accept_op(impl, false, p.p->new_socket(),
-        impl.protocol_.family(), impl.protocol_.type(),
-        impl.protocol_.protocol(), p.p->output_buffer(),
-        p.p->address_length(), o);
-    p.v = p.p = 0;
-  }
-
-  // Connect the socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    socket_ops::sync_connect(impl.socket_,
-        peer_endpoint.data(), peer_endpoint.size(), ec);
-    ASIO_ERROR_LOCATION(ec);
-    return ec;
-  }
-
-  // Start an asynchronous connect.
-  template <typename Handler, typename IoExecutor>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_connect_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.socket_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_connect"));
-
-    // Optionally register for per-operation cancellation.
-    operation* iocp_op = p.p;
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ = iocp_op =
-        &slot.template emplace<reactor_op_cancellation>(
-            impl.socket_, iocp_op);
-    }
-
-    int op_type = start_connect_op(impl, impl.protocol_.family(),
-        impl.protocol_.type(), peer_endpoint.data(),
-        static_cast<int>(peer_endpoint.size()), p.p, iocp_op);
-    p.v = p.p = 0;
-
-    // Update cancellation method if the reactor was used.
-    if (slot.is_connected() && op_type != -1)
-    {
-      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
-          &get_reactor(), &impl.reactor_data_, op_type);
-    }
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service_base.hpp
deleted file mode 100644
index 6a983d7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_socket_service_base.hpp
+++ /dev/null
@@ -1,829 +0,0 @@
-//
-// detail/win_iocp_socket_service_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP
-#define ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/operation.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/select_reactor.hpp"
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/win_iocp_io_context.hpp"
-#include "asio/detail/win_iocp_null_buffers_op.hpp"
-#include "asio/detail/win_iocp_socket_connect_op.hpp"
-#include "asio/detail/win_iocp_socket_send_op.hpp"
-#include "asio/detail/win_iocp_socket_recv_op.hpp"
-#include "asio/detail/win_iocp_socket_recvmsg_op.hpp"
-#include "asio/detail/win_iocp_wait_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_socket_service_base
-{
-public:
-  // The implementation type of the socket.
-  struct base_implementation_type
-  {
-    // The native socket representation.
-    socket_type socket_;
-
-    // The current state of the socket.
-    socket_ops::state_type state_;
-
-    // We use a shared pointer as a cancellation token here to work around the
-    // broken Windows support for cancellation. MSDN says that when you call
-    // closesocket any outstanding WSARecv or WSASend operations will complete
-    // with the error ERROR_OPERATION_ABORTED. In practice they complete with
-    // ERROR_NETNAME_DELETED, which means you can't tell the difference between
-    // a local cancellation and the socket being hard-closed by the peer.
-    socket_ops::shared_cancel_token_type cancel_token_;
-
-    // Per-descriptor data used by the reactor.
-    select_reactor::per_descriptor_data reactor_data_;
-
-#if defined(ASIO_ENABLE_CANCELIO)
-    // The ID of the thread from which it is safe to cancel asynchronous
-    // operations. 0 means no asynchronous operations have been started yet.
-    // ~0 means asynchronous operations have been started from more than one
-    // thread, and cancellation is not supported for the socket.
-    DWORD safe_cancellation_thread_id_;
-#endif // defined(ASIO_ENABLE_CANCELIO)
-
-    // Pointers to adjacent socket implementations in linked list.
-    base_implementation_type* next_;
-    base_implementation_type* prev_;
-  };
-
-  // Constructor.
-  ASIO_DECL win_iocp_socket_service_base(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void base_shutdown();
-
-  // Construct a new socket implementation.
-  ASIO_DECL void construct(base_implementation_type& impl);
-
-  // Move-construct a new socket implementation.
-  ASIO_DECL void base_move_construct(base_implementation_type& impl,
-      base_implementation_type& other_impl) noexcept;
-
-  // Move-assign from another socket implementation.
-  ASIO_DECL void base_move_assign(base_implementation_type& impl,
-      win_iocp_socket_service_base& other_service,
-      base_implementation_type& other_impl);
-
-  // Destroy a socket implementation.
-  ASIO_DECL void destroy(base_implementation_type& impl);
-
-  // Determine whether the socket is open.
-  bool is_open(const base_implementation_type& impl) const
-  {
-    return impl.socket_ != invalid_socket;
-  }
-
-  // Destroy a socket implementation.
-  ASIO_DECL asio::error_code close(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Release ownership of the socket.
-  ASIO_DECL socket_type release(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Cancel all operations associated with the socket.
-  ASIO_DECL asio::error_code cancel(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::sockatmark(impl.socket_, ec);
-  }
-
-  // Determine the number of bytes available for reading.
-  std::size_t available(const base_implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return socket_ops::available(impl.socket_, ec);
-  }
-
-  // Place the socket into the state where it will listen for new connections.
-  asio::error_code listen(base_implementation_type& impl,
-      int backlog, asio::error_code& ec)
-  {
-    socket_ops::listen(impl.socket_, backlog, ec);
-    return ec;
-  }
-
-  // Perform an IO control command on the socket.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(base_implementation_type& impl,
-      IO_Control_Command& command, asio::error_code& ec)
-  {
-    socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
-        static_cast<ioctl_arg_type*>(command.data()), ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(base_implementation_type& impl,
-      bool mode, asio::error_code& ec)
-  {
-    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Wait for the socket to become ready to read, ready to write, or to have
-  // pending error conditions.
-  asio::error_code wait(base_implementation_type& impl,
-      socket_base::wait_type w, asio::error_code& ec)
-  {
-    switch (w)
-    {
-    case socket_base::wait_read:
-      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_write:
-      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-      break;
-    case socket_base::wait_error:
-      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
-      break;
-    default:
-      ec = asio::error::invalid_argument;
-      break;
-    }
-
-    return ec;
-  }
-
-  // Asynchronously wait for the socket to become ready to read, ready to
-  // write, or to have pending error conditions.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(base_implementation_type& impl,
-      socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_wait_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_wait"));
-
-    // Optionally register for per-operation cancellation.
-    operation* iocp_op = p.p;
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ = iocp_op =
-        &slot.template emplace<reactor_op_cancellation>(
-            impl.socket_, iocp_op);
-    }
-
-    int op_type = -1;
-    switch (w)
-    {
-      case socket_base::wait_read:
-        op_type = start_null_buffers_receive_op(impl, 0, p.p, iocp_op);
-        break;
-      case socket_base::wait_write:
-        op_type = select_reactor::write_op;
-        start_reactor_op(impl, select_reactor::write_op, p.p);
-        break;
-      case socket_base::wait_error:
-        op_type = select_reactor::read_op;
-        start_reactor_op(impl, select_reactor::except_op, p.p);
-        break;
-      default:
-        p.p->ec_ = asio::error::invalid_argument;
-        iocp_service_.post_immediate_completion(p.p, is_continuation);
-        break;
-    }
-
-    p.v = p.p = 0;
-
-    // Update cancellation method if the reactor was used.
-    if (slot.is_connected() && op_type != -1)
-    {
-      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
-          &get_reactor(), &impl.reactor_data_, op_type);
-    }
-  }
-
-  // Send the given data to the peer. Returns the number of bytes sent.
-  template <typename ConstBufferSequence>
-  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);
-  }
-
-  // Wait until data can be sent without blocking.
-  size_t send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_send_op<
-        ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(
-        impl.cancel_token_, buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_send"));
-
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(buffers);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
-
-    start_send_op(impl, bufs.buffers(), bufs.count(), flags,
-        (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
-        o);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_send(null_buffers)"));
-
-    start_reactor_op(impl, select_reactor::write_op, p.p);
-    p.v = p.p = 0;
-  }
-
-  // Receive some data from the peer. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  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);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_recv_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(impl.state_,
-        impl.cancel_token_, buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive"));
-
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
-
-    start_receive_op(impl, bufs.buffers(), bufs.count(), flags,
-        (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
-        o);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive(null_buffers)"));
-
-    // Optionally register for per-operation cancellation.
-    operation* iocp_op = p.p;
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ = iocp_op =
-        &slot.template emplace<reactor_op_cancellation>(
-            impl.socket_, iocp_op);
-    }
-
-    int op_type = start_null_buffers_receive_op(impl, flags, p.p, iocp_op);
-    p.v = p.p = 0;
-
-    // Update cancellation method if the reactor was used.
-    if (slot.is_connected() && op_type != -1)
-    {
-      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
-          &get_reactor(), &impl.reactor_data_, op_type);
-    }
-  }
-
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  size_t receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
-        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags& out_flags, asio::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_socket_recvmsg_op<
-        MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    operation* o = p.p = new (p.v) op(impl.cancel_token_,
-        buffers, out_flags, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive_with_flags"));
-
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-      o = &slot.template emplace<iocp_op_cancellation>(impl.socket_, o);
-
-    start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, o);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler,
-      const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(impl.cancel_token_, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((context_, *p.p, "socket",
-          &impl, impl.socket_, "async_receive_with_flags(null_buffers)"));
-
-    // Reset out_flags since it can be given no sensible value at this time.
-    out_flags = 0;
-
-    // Optionally register for per-operation cancellation.
-    operation* iocp_op = p.p;
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ = iocp_op =
-        &slot.template emplace<reactor_op_cancellation>(
-            impl.socket_, iocp_op);
-    }
-
-    int op_type = start_null_buffers_receive_op(impl, in_flags, p.p, iocp_op);
-    p.v = p.p = 0;
-
-    // Update cancellation method if the reactor was used.
-    if (slot.is_connected() && op_type != -1)
-    {
-      static_cast<reactor_op_cancellation*>(iocp_op)->use_reactor(
-          &get_reactor(), &impl.reactor_data_, op_type);
-    }
-  }
-
-  // Helper function to restart an asynchronous accept operation.
-  ASIO_DECL void restart_accept_op(socket_type s,
-      socket_holder& new_socket, int family, int type,
-      int protocol, void* output_buffer, DWORD address_length,
-      long* cancel_requested, operation* op);
-
-protected:
-  // Open a new socket implementation.
-  ASIO_DECL asio::error_code do_open(
-      base_implementation_type& impl, int family, int type,
-      int protocol, asio::error_code& ec);
-
-  // Assign a native socket to a socket implementation.
-  ASIO_DECL asio::error_code do_assign(
-      base_implementation_type& impl, int type,
-      socket_type native_socket, asio::error_code& ec);
-
-  // Helper function to start an asynchronous send operation.
-  ASIO_DECL void start_send_op(base_implementation_type& impl,
-      WSABUF* buffers, std::size_t buffer_count,
-      socket_base::message_flags flags, bool noop, operation* op);
-
-  // Helper function to start an asynchronous send_to operation.
-  ASIO_DECL void start_send_to_op(base_implementation_type& impl,
-      WSABUF* buffers, std::size_t buffer_count, const void* addr,
-      int addrlen, socket_base::message_flags flags, operation* op);
-
-  // Helper function to start an asynchronous receive operation.
-  ASIO_DECL void start_receive_op(base_implementation_type& impl,
-      WSABUF* buffers, std::size_t buffer_count,
-      socket_base::message_flags flags, bool noop, operation* op);
-
-  // Helper function to start an asynchronous null_buffers receive operation.
-  ASIO_DECL int start_null_buffers_receive_op(
-      base_implementation_type& impl, socket_base::message_flags flags,
-      reactor_op* op, operation* iocp_op);
-
-  // Helper function to start an asynchronous receive_from operation.
-  ASIO_DECL void start_receive_from_op(base_implementation_type& impl,
-      WSABUF* buffers, std::size_t buffer_count, void* addr,
-      socket_base::message_flags flags, int* addrlen, operation* op);
-
-  // Helper function to start an asynchronous accept operation.
-  ASIO_DECL void start_accept_op(base_implementation_type& impl,
-      bool peer_is_open, socket_holder& new_socket, int family, int type,
-      int protocol, void* output_buffer, DWORD address_length, operation* op);
-
-  // Start an asynchronous read or write operation using the reactor.
-  ASIO_DECL void start_reactor_op(base_implementation_type& impl,
-      int op_type, reactor_op* op);
-
-  // Start the asynchronous connect operation using the reactor.
-  ASIO_DECL int start_connect_op(base_implementation_type& impl,
-      int family, int type, const void* remote_addr, std::size_t remote_addrlen,
-      win_iocp_socket_connect_op_base* op, operation* iocp_op);
-
-  // Helper function to close a socket when the associated object is being
-  // destroyed.
-  ASIO_DECL void close_for_destruction(base_implementation_type& impl);
-
-  // Update the ID of the thread from which cancellation is safe.
-  ASIO_DECL void update_cancellation_thread_id(
-      base_implementation_type& impl);
-
-  // Helper function to get the reactor. If no reactor has been created yet, a
-  // new one is obtained from the execution context and a pointer to it is
-  // cached in this service.
-  ASIO_DECL select_reactor& get_reactor();
-
-  // The type of a ConnectEx function pointer, as old SDKs may not provide it.
-  typedef BOOL (PASCAL *connect_ex_fn)(SOCKET,
-      const socket_addr_type*, int, void*, DWORD, DWORD*, OVERLAPPED*);
-
-  // Helper function to get the ConnectEx pointer. If no ConnectEx pointer has
-  // been obtained yet, one is obtained using WSAIoctl and the pointer is
-  // cached. Returns a null pointer if ConnectEx is not available.
-  ASIO_DECL connect_ex_fn get_connect_ex(
-      base_implementation_type& impl, int type);
-
-  // The type of a NtSetInformationFile function pointer.
-  typedef LONG (NTAPI *nt_set_info_fn)(HANDLE, ULONG_PTR*, void*, ULONG, ULONG);
-
-  // Helper function to get the NtSetInformationFile function pointer. If no
-  // NtSetInformationFile pointer has been obtained yet, one is obtained using
-  // GetProcAddress and the pointer is cached. Returns a null pointer if
-  // NtSetInformationFile is not available.
-  ASIO_DECL nt_set_info_fn get_nt_set_info();
-
-  // Helper function to emulate InterlockedCompareExchangePointer functionality
-  // for:
-  // - very old Platform SDKs; and
-  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
-  ASIO_DECL void* interlocked_compare_exchange_pointer(
-      void** dest, void* exch, void* cmp);
-
-  // Helper function to emulate InterlockedExchangePointer functionality for:
-  // - very old Platform SDKs; and
-  // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
-  ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val);
-
-  // Helper class used to implement per operation cancellation.
-  class iocp_op_cancellation : public operation
-  {
-  public:
-    iocp_op_cancellation(SOCKET s, operation* target)
-      : operation(&iocp_op_cancellation::do_complete),
-        socket_(s),
-        target_(target)
-    {
-    }
-
-    static void do_complete(void* owner, operation* base,
-        const asio::error_code& result_ec,
-        std::size_t bytes_transferred)
-    {
-      iocp_op_cancellation* o = static_cast<iocp_op_cancellation*>(base);
-      o->target_->complete(owner, result_ec, bytes_transferred);
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
-        ::CancelIoEx(sock_as_handle, this);
-      }
-#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      (void)type;
-#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-    }
-
-  private:
-    SOCKET socket_;
-    operation* target_;
-  };
-
-  // Helper class used to implement per operation cancellation.
-  class accept_op_cancellation : public operation
-  {
-  public:
-    accept_op_cancellation(SOCKET s, operation* target)
-      : operation(&iocp_op_cancellation::do_complete),
-        socket_(s),
-        target_(target),
-        cancel_requested_(0)
-    {
-    }
-
-    static void do_complete(void* owner, operation* base,
-        const asio::error_code& result_ec,
-        std::size_t bytes_transferred)
-    {
-      accept_op_cancellation* o = static_cast<accept_op_cancellation*>(base);
-      o->target_->complete(owner, result_ec, bytes_transferred);
-    }
-
-    long* get_cancel_requested()
-    {
-      return &cancel_requested_;
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
-        ::CancelIoEx(sock_as_handle, this);
-      }
-#else // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-      (void)type;
-#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-    }
-
-  private:
-    SOCKET socket_;
-    operation* target_;
-    long cancel_requested_;
-  };
-
-  // Helper class used to implement per operation cancellation.
-  class reactor_op_cancellation : public operation
-  {
-  public:
-    reactor_op_cancellation(SOCKET s, operation* base)
-      : operation(&reactor_op_cancellation::do_complete),
-        socket_(s),
-        target_(base),
-        reactor_(0),
-        reactor_data_(0),
-        op_type_(-1)
-    {
-    }
-
-    void use_reactor(select_reactor* r,
-        select_reactor::per_descriptor_data* p, int o)
-    {
-      reactor_ = r;
-      reactor_data_ = p;
-      op_type_ = o;
-    }
-
-    static void do_complete(void* owner, operation* base,
-        const asio::error_code& result_ec,
-        std::size_t bytes_transferred)
-    {
-      reactor_op_cancellation* o = static_cast<reactor_op_cancellation*>(base);
-      o->target_->complete(owner, result_ec, bytes_transferred);
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        if (reactor_)
-        {
-          reactor_->cancel_ops_by_key(socket_,
-              *reactor_data_, op_type_, this);
-        }
-        else
-        {
-#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-          HANDLE sock_as_handle = reinterpret_cast<HANDLE>(socket_);
-          ::CancelIoEx(sock_as_handle, this);
-#endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
-        }
-      }
-    }
-
-  private:
-    SOCKET socket_;
-    operation* target_;
-    select_reactor* reactor_;
-    select_reactor::per_descriptor_data* reactor_data_;
-    int op_type_;
-  };
-
-  // The execution context used to obtain the reactor, if required.
-  execution_context& context_;
-
-  // The IOCP service used for running asynchronous operations and dispatching
-  // handlers.
-  win_iocp_io_context& iocp_service_;
-
-  // The reactor used for performing connect operations. This object is created
-  // only if needed.
-  select_reactor* reactor_;
-
-  // Pointer to ConnectEx implementation.
-  void* connect_ex_;
-
-  // Pointer to NtSetInformationFile implementation.
-  void* nt_set_info_;
-
-  // Mutex to protect access to the linked list of implementations.
-  asio::detail::mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  base_implementation_type* impl_list_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_iocp_socket_service_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_thread_info.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_thread_info.hpp
deleted file mode 100644
index 3f1e012..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_thread_info.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// detail/win_iocp_thread_info.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP
-#define ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/thread_info_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct win_iocp_thread_info : public thread_info_base
-{
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_wait_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_wait_op.hpp
deleted file mode 100644
index 882f16e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_iocp_wait_op.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//
-// detail/win_iocp_wait_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
-#define ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class win_iocp_wait_op : public reactor_op
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(win_iocp_wait_op);
-
-  win_iocp_wait_op(socket_ops::weak_cancel_token_type cancel_token,
-      Handler& handler, const IoExecutor& io_ex)
-    : reactor_op(asio::error_code(),
-        &win_iocp_wait_op::do_perform,
-        &win_iocp_wait_op::do_complete),
-      cancel_token_(cancel_token),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static status do_perform(reactor_op*)
-  {
-    return done;
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code& result_ec,
-      std::size_t /*bytes_transferred*/)
-  {
-    asio::error_code ec(result_ec);
-
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    win_iocp_wait_op* o(static_cast<win_iocp_wait_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // The reactor may have stored a result in the operation object.
-    if (o->ec_)
-      ec = o->ec_;
-
-    // Map non-portable errors to their portable counterparts.
-    if (ec.value() == ERROR_NETNAME_DELETED)
-    {
-      if (o->cancel_token_.expired())
-        ec = asio::error::operation_aborted;
-      else
-        ec = asio::error::connection_reset;
-    }
-    else if (ec.value() == ERROR_PORT_UNREACHABLE)
-    {
-      ec = asio::error::connection_refused;
-    }
-
-    ASIO_ERROR_LOCATION(ec);
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, ec);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_mutex.hpp
deleted file mode 100644
index 77603ec..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_mutex.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//
-// detail/win_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_MUTEX_HPP
-#define ASIO_DETAIL_WIN_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_lock.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_mutex
-  : private noncopyable
-{
-public:
-  typedef asio::detail::scoped_lock<win_mutex> scoped_lock;
-
-  // Constructor.
-  ASIO_DECL win_mutex();
-
-  // Destructor.
-  ~win_mutex()
-  {
-    ::DeleteCriticalSection(&crit_section_);
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    ::EnterCriticalSection(&crit_section_);
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    ::LeaveCriticalSection(&crit_section_);
-  }
-
-private:
-  // Initialisation must be performed in a separate function to the constructor
-  // since the compiler does not support the use of structured exceptions and
-  // C++ exceptions in the same function.
-  ASIO_DECL int do_init();
-
-  ::CRITICAL_SECTION crit_section_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_mutex.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_WIN_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_object_handle_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_object_handle_service.hpp
deleted file mode 100644
index 8e01b72..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_object_handle_service.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//
-// detail/win_object_handle_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP
-#define ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#include "asio/detail/memory.hpp"
-#include "asio/detail/wait_handler.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_object_handle_service :
-  public execution_context_service_base<win_object_handle_service>
-{
-public:
-  // The native type of an object handle.
-  typedef HANDLE native_handle_type;
-
-  // The implementation type of the object handle.
-  class implementation_type
-  {
-   public:
-    // Default constructor.
-    implementation_type()
-      : handle_(INVALID_HANDLE_VALUE),
-        wait_handle_(INVALID_HANDLE_VALUE),
-        owner_(0),
-        next_(0),
-        prev_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class win_object_handle_service;
-
-    // The native object handle representation. May be accessed or modified
-    // without locking the mutex.
-    native_handle_type handle_;
-
-    // The handle used to unregister the wait operation. The mutex must be
-    // locked when accessing or modifying this member.
-    HANDLE wait_handle_;
-
-    // The operations waiting on the object handle. If there is a registered
-    // wait then the mutex must be locked when accessing or modifying this
-    // member
-    op_queue<wait_op> op_queue_;
-
-    // The service instance that owns the object handle implementation.
-    win_object_handle_service* owner_;
-
-    // Pointers to adjacent handle implementations in linked list. The mutex
-    // must be locked when accessing or modifying these members.
-    implementation_type* next_;
-    implementation_type* prev_;
-  };
-
-  // Constructor.
-  ASIO_DECL win_object_handle_service(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Construct a new handle implementation.
-  ASIO_DECL void construct(implementation_type& impl);
-
-  // Move-construct a new handle implementation.
-  ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another handle implementation.
-  ASIO_DECL void move_assign(implementation_type& impl,
-      win_object_handle_service& other_service,
-      implementation_type& other_impl);
-
-  // Destroy a handle implementation.
-  ASIO_DECL void destroy(implementation_type& impl);
-
-  // Assign a native handle to a handle implementation.
-  ASIO_DECL asio::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, asio::error_code& ec);
-
-  // Determine whether the handle is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return impl.handle_ != INVALID_HANDLE_VALUE && impl.handle_ != 0;
-  }
-
-  // Destroy a handle implementation.
-  ASIO_DECL asio::error_code close(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Get the native handle representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return impl.handle_;
-  }
-
-  // Cancel all operations associated with the handle.
-  ASIO_DECL asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec);
-
-  // Perform a synchronous wait for the object to enter a signalled state.
-  ASIO_DECL void wait(implementation_type& impl,
-      asio::error_code& ec);
-
-  /// Start an asynchronous wait.
-  template <typename Handler, typename IoExecutor>
-  void async_wait(implementation_type& impl,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef wait_handler<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(), *p.p, "object_handle",
-          &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "async_wait"));
-
-    start_wait_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Helper function to start an asynchronous wait operation.
-  ASIO_DECL void start_wait_op(implementation_type& impl, wait_op* op);
-
-  // Helper function to register a wait operation.
-  ASIO_DECL void register_wait_callback(
-      implementation_type& impl, mutex::scoped_lock& lock);
-
-  // Callback function invoked when the registered wait completes.
-  static ASIO_DECL VOID CALLBACK wait_callback(
-      PVOID param, BOOLEAN timeout);
-
-  // The scheduler used to post completions.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-  // Mutex to protect access to internal state.
-  mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  implementation_type* impl_list_;
-
-  // Flag to indicate that the dispatcher has been shut down.
-  bool shutdown_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_object_handle_service.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#endif // ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_static_mutex.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_static_mutex.hpp
deleted file mode 100644
index 736ef0e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_static_mutex.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//
-// detail/win_static_mutex.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
-#define ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/scoped_lock.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct win_static_mutex
-{
-  typedef asio::detail::scoped_lock<win_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  ASIO_DECL void init();
-
-  // Initialisation must be performed in a separate function to the "public"
-  // init() function since the compiler does not support the use of structured
-  // exceptions and C++ exceptions in the same function.
-  ASIO_DECL int do_init();
-
-  // Lock the mutex.
-  void lock()
-  {
-    ::EnterCriticalSection(&crit_section_);
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    ::LeaveCriticalSection(&crit_section_);
-  }
-
-  bool initialised_;
-  ::CRITICAL_SECTION crit_section_;
-};
-
-#if defined(UNDER_CE)
-# define ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0 } }
-#else // defined(UNDER_CE)
-# define ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0, 0 } }
-#endif // defined(UNDER_CE)
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_static_mutex.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_thread.hpp
deleted file mode 100644
index c1e7b8e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_thread.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// detail/win_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_THREAD_HPP
-#define ASIO_DETAIL_WIN_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) \
-  && !defined(ASIO_WINDOWS_APP) \
-  && !defined(UNDER_CE)
-
-#include <cstddef>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-ASIO_DECL unsigned int __stdcall win_thread_function(void* arg);
-
-#if defined(WINVER) && (WINVER < 0x0500)
-ASIO_DECL void __stdcall apc_function(ULONG data);
-#else
-ASIO_DECL void __stdcall apc_function(ULONG_PTR data);
-#endif
-
-template <typename T>
-class win_thread_base
-{
-public:
-  static bool terminate_threads()
-  {
-    return ::InterlockedExchangeAdd(&terminate_threads_, 0) != 0;
-  }
-
-  static void set_terminate_threads(bool b)
-  {
-    ::InterlockedExchange(&terminate_threads_, b ? 1 : 0);
-  }
-
-private:
-  static long terminate_threads_;
-};
-
-template <typename T>
-long win_thread_base<T>::terminate_threads_ = 0;
-
-class win_thread
-  : private noncopyable,
-    public win_thread_base<win_thread>
-{
-public:
-  // Constructor.
-  template <typename Function>
-  win_thread(Function f, unsigned int stack_size = 0)
-    : thread_(0),
-      exit_event_(0)
-  {
-    start_thread(new func<Function>(f), stack_size);
-  }
-
-  // Destructor.
-  ASIO_DECL ~win_thread();
-
-  // Wait for the thread to exit.
-  ASIO_DECL void join();
-
-  // Get number of CPUs.
-  ASIO_DECL static std::size_t hardware_concurrency();
-
-private:
-  friend ASIO_DECL unsigned int __stdcall win_thread_function(void* arg);
-
-#if defined(WINVER) && (WINVER < 0x0500)
-  friend ASIO_DECL void __stdcall apc_function(ULONG);
-#else
-  friend ASIO_DECL void __stdcall apc_function(ULONG_PTR);
-#endif
-
-  class func_base
-  {
-  public:
-    virtual ~func_base() {}
-    virtual void run() = 0;
-    ::HANDLE entry_event_;
-    ::HANDLE exit_event_;
-  };
-
-  struct auto_func_base_ptr
-  {
-    func_base* ptr;
-    ~auto_func_base_ptr() { delete ptr; }
-  };
-
-  template <typename Function>
-  class func
-    : public func_base
-  {
-  public:
-    func(Function f)
-      : f_(f)
-    {
-    }
-
-    virtual void run()
-    {
-      f_();
-    }
-
-  private:
-    Function f_;
-  };
-
-  ASIO_DECL void start_thread(func_base* arg, unsigned int stack_size);
-
-  ::HANDLE thread_;
-  ::HANDLE exit_event_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_thread.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-       // && !defined(ASIO_WINDOWS_APP)
-       // && !defined(UNDER_CE)
-
-#endif // ASIO_DETAIL_WIN_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_tss_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_tss_ptr.hpp
deleted file mode 100644
index 95a8771..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/win_tss_ptr.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//
-// detail/win_tss_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WIN_TSS_PTR_HPP
-#define ASIO_DETAIL_WIN_TSS_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper function to create thread-specific storage.
-ASIO_DECL DWORD win_tss_ptr_create();
-
-template <typename T>
-class win_tss_ptr
-  : private noncopyable
-{
-public:
-  // Constructor.
-  win_tss_ptr()
-    : tss_key_(win_tss_ptr_create())
-  {
-  }
-
-  // Destructor.
-  ~win_tss_ptr()
-  {
-    ::TlsFree(tss_key_);
-  }
-
-  // Get the value.
-  operator T*() const
-  {
-    return static_cast<T*>(::TlsGetValue(tss_key_));
-  }
-
-  // Set the value.
-  void operator=(T* value)
-  {
-    ::TlsSetValue(tss_key_, value);
-  }
-
-private:
-  // Thread-specific storage to allow unlocked access to determine whether a
-  // thread is a member of the pool.
-  DWORD tss_key_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/win_tss_ptr.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS)
-
-#endif // ASIO_DETAIL_WIN_TSS_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winapp_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winapp_thread.hpp
deleted file mode 100644
index efa662d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winapp_thread.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// detail/winapp_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINAPP_THREAD_HPP
-#define ASIO_DETAIL_WINAPP_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) && defined(ASIO_WINDOWS_APP)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-DWORD WINAPI winapp_thread_function(LPVOID arg);
-
-class winapp_thread
-  : private noncopyable
-{
-public:
-  // Constructor.
-  template <typename Function>
-  winapp_thread(Function f, unsigned int = 0)
-  {
-    scoped_ptr<func_base> arg(new func<Function>(f));
-    DWORD thread_id = 0;
-    thread_ = ::CreateThread(0, 0, winapp_thread_function,
-        arg.get(), 0, &thread_id);
-    if (!thread_)
-    {
-      DWORD last_error = ::GetLastError();
-      asio::error_code ec(last_error,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "thread");
-    }
-    arg.release();
-  }
-
-  // Destructor.
-  ~winapp_thread()
-  {
-    ::CloseHandle(thread_);
-  }
-
-  // Wait for the thread to exit.
-  void join()
-  {
-    ::WaitForSingleObjectEx(thread_, INFINITE, false);
-  }
-
-  // Get number of CPUs.
-  static std::size_t hardware_concurrency()
-  {
-    SYSTEM_INFO system_info;
-    ::GetNativeSystemInfo(&system_info);
-    return system_info.dwNumberOfProcessors;
-  }
-
-private:
-  friend DWORD WINAPI winapp_thread_function(LPVOID arg);
-
-  class func_base
-  {
-  public:
-    virtual ~func_base() {}
-    virtual void run() = 0;
-  };
-
-  template <typename Function>
-  class func
-    : public func_base
-  {
-  public:
-    func(Function f)
-      : f_(f)
-    {
-    }
-
-    virtual void run()
-    {
-      f_();
-    }
-
-  private:
-    Function f_;
-  };
-
-  ::HANDLE thread_;
-};
-
-inline DWORD WINAPI winapp_thread_function(LPVOID arg)
-{
-  scoped_ptr<winapp_thread::func_base> func(
-      static_cast<winapp_thread::func_base*>(arg));
-  func->run();
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS) && defined(ASIO_WINDOWS_APP)
-
-#endif // ASIO_DETAIL_WINAPP_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wince_thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wince_thread.hpp
deleted file mode 100644
index 3c6b854..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wince_thread.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// detail/wince_thread.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINCE_THREAD_HPP
-#define ASIO_DETAIL_WINCE_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-DWORD WINAPI wince_thread_function(LPVOID arg);
-
-class wince_thread
-  : private noncopyable
-{
-public:
-  // Constructor.
-  template <typename Function>
-  wince_thread(Function f, unsigned int = 0)
-  {
-    scoped_ptr<func_base> arg(new func<Function>(f));
-    DWORD thread_id = 0;
-    thread_ = ::CreateThread(0, 0, wince_thread_function,
-        arg.get(), 0, &thread_id);
-    if (!thread_)
-    {
-      DWORD last_error = ::GetLastError();
-      asio::error_code ec(last_error,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "thread");
-    }
-    arg.release();
-  }
-
-  // Destructor.
-  ~wince_thread()
-  {
-    ::CloseHandle(thread_);
-  }
-
-  // Wait for the thread to exit.
-  void join()
-  {
-    ::WaitForSingleObject(thread_, INFINITE);
-  }
-
-  // Get number of CPUs.
-  static std::size_t hardware_concurrency()
-  {
-    SYSTEM_INFO system_info;
-    ::GetSystemInfo(&system_info);
-    return system_info.dwNumberOfProcessors;
-  }
-
-private:
-  friend DWORD WINAPI wince_thread_function(LPVOID arg);
-
-  class func_base
-  {
-  public:
-    virtual ~func_base() {}
-    virtual void run() = 0;
-  };
-
-  template <typename Function>
-  class func
-    : public func_base
-  {
-  public:
-    func(Function f)
-      : f_(f)
-    {
-    }
-
-    virtual void run()
-    {
-      f_();
-    }
-
-  private:
-    Function f_;
-  };
-
-  ::HANDLE thread_;
-};
-
-inline DWORD WINAPI wince_thread_function(LPVOID arg)
-{
-  scoped_ptr<wince_thread::func_base> func(
-      static_cast<wince_thread::func_base*>(arg));
-  func->run();
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-#endif // ASIO_DETAIL_WINCE_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_manager.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_manager.hpp
deleted file mode 100644
index 9d0f902..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_manager.hpp
+++ /dev/null
@@ -1,305 +0,0 @@
-//
-// detail/winrt_async_manager.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP
-#define ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include <future>
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class winrt_async_manager
-  : public execution_context_service_base<winrt_async_manager>
-{
-public:
-  // Constructor.
-  winrt_async_manager(execution_context& context)
-    : execution_context_service_base<winrt_async_manager>(context),
-      scheduler_(use_service<scheduler_impl>(context)),
-      outstanding_ops_(1)
-  {
-  }
-
-  // Destructor.
-  ~winrt_async_manager()
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    if (--outstanding_ops_ > 0)
-    {
-      // Block until last operation is complete.
-      std::future<void> f = promise_.get_future();
-      f.wait();
-    }
-  }
-
-  void sync(Windows::Foundation::IAsyncAction^ action,
-      asio::error_code& ec)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto promise = std::make_shared<std::promise<asio::error_code>>();
-    auto future = promise->get_future();
-
-    action->Completed = ref new AsyncActionCompletedHandler(
-      [promise](IAsyncAction^ action, AsyncStatus status)
-      {
-        switch (status)
-        {
-        case AsyncStatus::Canceled:
-          promise->set_value(asio::error::operation_aborted);
-          break;
-        case AsyncStatus::Error:
-        case AsyncStatus::Completed:
-        default:
-          asio::error_code ec(
-              action->ErrorCode.Value,
-              asio::system_category());
-          promise->set_value(ec);
-          break;
-        }
-      });
-
-    ec = future.get();
-  }
-
-  template <typename TResult>
-  TResult sync(Windows::Foundation::IAsyncOperation<TResult>^ operation,
-      asio::error_code& ec)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto promise = std::make_shared<std::promise<asio::error_code>>();
-    auto future = promise->get_future();
-
-    operation->Completed = ref new AsyncOperationCompletedHandler<TResult>(
-      [promise](IAsyncOperation<TResult>^ operation, AsyncStatus status)
-      {
-        switch (status)
-        {
-        case AsyncStatus::Canceled:
-          promise->set_value(asio::error::operation_aborted);
-          break;
-        case AsyncStatus::Error:
-        case AsyncStatus::Completed:
-        default:
-          asio::error_code ec(
-              operation->ErrorCode.Value,
-              asio::system_category());
-          promise->set_value(ec);
-          break;
-        }
-      });
-
-    ec = future.get();
-    return operation->GetResults();
-  }
-
-  template <typename TResult, typename TProgress>
-  TResult sync(
-      Windows::Foundation::IAsyncOperationWithProgress<
-        TResult, TProgress>^ operation,
-      asio::error_code& ec)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto promise = std::make_shared<std::promise<asio::error_code>>();
-    auto future = promise->get_future();
-
-    operation->Completed
-      = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>(
-        [promise](IAsyncOperationWithProgress<TResult, TProgress>^ operation,
-          AsyncStatus status)
-        {
-          switch (status)
-          {
-          case AsyncStatus::Canceled:
-            promise->set_value(asio::error::operation_aborted);
-            break;
-          case AsyncStatus::Started:
-            break;
-          case AsyncStatus::Error:
-          case AsyncStatus::Completed:
-          default:
-            asio::error_code ec(
-                operation->ErrorCode.Value,
-                asio::system_category());
-            promise->set_value(ec);
-            break;
-          }
-        });
-
-    ec = future.get();
-    return operation->GetResults();
-  }
-
-  void async(Windows::Foundation::IAsyncAction^ action,
-      winrt_async_op<void>* handler)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto on_completed = ref new AsyncActionCompletedHandler(
-      [this, handler](IAsyncAction^ action, AsyncStatus status)
-      {
-        switch (status)
-        {
-        case AsyncStatus::Canceled:
-          handler->ec_ = asio::error::operation_aborted;
-          break;
-        case AsyncStatus::Started:
-          return;
-        case AsyncStatus::Completed:
-        case AsyncStatus::Error:
-        default:
-          handler->ec_ = asio::error_code(
-              action->ErrorCode.Value,
-              asio::system_category());
-          break;
-        }
-        scheduler_.post_deferred_completion(handler);
-        if (--outstanding_ops_ == 0)
-          promise_.set_value();
-      });
-
-    scheduler_.work_started();
-    ++outstanding_ops_;
-    action->Completed = on_completed;
-  }
-
-  template <typename TResult>
-  void async(Windows::Foundation::IAsyncOperation<TResult>^ operation,
-      winrt_async_op<TResult>* handler)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto on_completed = ref new AsyncOperationCompletedHandler<TResult>(
-      [this, handler](IAsyncOperation<TResult>^ operation, AsyncStatus status)
-      {
-        switch (status)
-        {
-        case AsyncStatus::Canceled:
-          handler->ec_ = asio::error::operation_aborted;
-          break;
-        case AsyncStatus::Started:
-          return;
-        case AsyncStatus::Completed:
-          handler->result_ = operation->GetResults();
-          // Fall through.
-        case AsyncStatus::Error:
-        default:
-          handler->ec_ = asio::error_code(
-              operation->ErrorCode.Value,
-              asio::system_category());
-          break;
-        }
-        scheduler_.post_deferred_completion(handler);
-        if (--outstanding_ops_ == 0)
-          promise_.set_value();
-      });
-
-    scheduler_.work_started();
-    ++outstanding_ops_;
-    operation->Completed = on_completed;
-  }
-
-  template <typename TResult, typename TProgress>
-  void async(
-      Windows::Foundation::IAsyncOperationWithProgress<
-        TResult, TProgress>^ operation,
-      winrt_async_op<TResult>* handler)
-  {
-    using namespace Windows::Foundation;
-    using Windows::Foundation::AsyncStatus;
-
-    auto on_completed
-      = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>(
-        [this, handler](IAsyncOperationWithProgress<
-          TResult, TProgress>^ operation, AsyncStatus status)
-        {
-          switch (status)
-          {
-          case AsyncStatus::Canceled:
-            handler->ec_ = asio::error::operation_aborted;
-            break;
-          case AsyncStatus::Started:
-            return;
-          case AsyncStatus::Completed:
-            handler->result_ = operation->GetResults();
-            // Fall through.
-          case AsyncStatus::Error:
-          default:
-            handler->ec_ = asio::error_code(
-                operation->ErrorCode.Value,
-                asio::system_category());
-            break;
-          }
-          scheduler_.post_deferred_completion(handler);
-          if (--outstanding_ops_ == 0)
-            promise_.set_value();
-        });
-
-    scheduler_.work_started();
-    ++outstanding_ops_;
-    operation->Completed = on_completed;
-  }
-
-private:
-  // The scheduler implementation used to post completed handlers.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-  // Count of outstanding operations.
-  atomic_count outstanding_ops_;
-
-  // Used to keep wait for outstanding operations to complete.
-  std::promise<void> promise_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_op.hpp
deleted file mode 100644
index a349898..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_async_op.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// detail/winrt_async_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_ASYNC_OP_HPP
-#define ASIO_DETAIL_WINRT_ASYNC_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename TResult>
-class winrt_async_op
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-  // The result of the operation, to be passed to the completion handler.
-  TResult result_;
-
-protected:
-  winrt_async_op(func_type complete_func)
-    : operation(complete_func),
-      result_()
-  {
-  }
-};
-
-template <>
-class winrt_async_op<void>
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  asio::error_code ec_;
-
-protected:
-  winrt_async_op(func_type complete_func)
-    : operation(complete_func)
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WINRT_ASYNC_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolve_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolve_op.hpp
deleted file mode 100644
index 3cbd00e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolve_op.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-//
-// detail/winrt_resolve_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_RESOLVE_OP_HPP
-#define ASIO_DETAIL_WINRT_RESOLVE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol, typename Handler, typename IoExecutor>
-class winrt_resolve_op :
-  public winrt_async_op<
-    Windows::Foundation::Collections::IVectorView<
-      Windows::Networking::EndpointPair^>^>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(winrt_resolve_op);
-
-  typedef typename Protocol::endpoint endpoint_type;
-  typedef asio::ip::basic_resolver_query<Protocol> query_type;
-  typedef asio::ip::basic_resolver_results<Protocol> results_type;
-
-  winrt_resolve_op(const query_type& query,
-      Handler& handler, const IoExecutor& io_ex)
-    : winrt_async_op<
-        Windows::Foundation::Collections::IVectorView<
-          Windows::Networking::EndpointPair^>^>(
-            &winrt_resolve_op::do_complete),
-      query_(query),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code&, std::size_t)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    winrt_resolve_op* o(static_cast<winrt_resolve_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    results_type results = results_type();
-    if (!o->ec_)
-    {
-      try
-      {
-        results = results_type::create(o->result_, o->query_.hints(),
-            o->query_.host_name(), o->query_.service_name());
-      }
-      catch (Platform::Exception^ e)
-      {
-        o->ec_ = asio::error_code(e->HResult,
-            asio::system_category());
-      }
-    }
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, results_type>
-      handler(o->handler_, o->ec_, results);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  query_type query_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> executor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_RESOLVE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolver_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolver_service.hpp
deleted file mode 100644
index 02dddf0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_resolver_service.hpp
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// detail/winrt_resolver_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP
-#define ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-#include "asio/post.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/winrt_async_manager.hpp"
-#include "asio/detail/winrt_resolve_op.hpp"
-#include "asio/detail/winrt_utils.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class winrt_resolver_service :
-  public execution_context_service_base<winrt_resolver_service<Protocol>>
-{
-public:
-  // The implementation type of the resolver. A cancellation token is used to
-  // indicate to the asynchronous operation that the operation has been
-  // cancelled.
-  typedef socket_ops::shared_cancel_token_type implementation_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The query type.
-  typedef asio::ip::basic_resolver_query<Protocol> query_type;
-
-  // The results type.
-  typedef asio::ip::basic_resolver_results<Protocol> results_type;
-
-  // Constructor.
-  winrt_resolver_service(execution_context& context)
-    : execution_context_service_base<
-        winrt_resolver_service<Protocol>>(context),
-      scheduler_(use_service<scheduler_impl>(context)),
-      async_manager_(use_service<winrt_async_manager>(context))
-  {
-  }
-
-  // Destructor.
-  ~winrt_resolver_service()
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-  }
-
-  // Perform any fork-related housekeeping.
-  void notify_fork(execution_context::fork_event)
-  {
-  }
-
-  // Construct a new resolver implementation.
-  void construct(implementation_type&)
-  {
-  }
-
-  // Move-construct a new resolver implementation.
-  void move_construct(implementation_type&,
-      implementation_type&)
-  {
-  }
-
-  // Move-assign from another resolver implementation.
-  void move_assign(implementation_type&,
-      winrt_resolver_service&, implementation_type&)
-  {
-  }
-
-  // Destroy a resolver implementation.
-  void destroy(implementation_type&)
-  {
-  }
-
-  // Cancel pending asynchronous operations.
-  void cancel(implementation_type&)
-  {
-  }
-
-  // Resolve a query to a list of entries.
-  results_type resolve(implementation_type&,
-      const query_type& query, asio::error_code& ec)
-  {
-    try
-    {
-      using namespace Windows::Networking::Sockets;
-      auto endpoint_pairs = async_manager_.sync(
-          DatagramSocket::GetEndpointPairsAsync(
-            winrt_utils::host_name(query.host_name()),
-            winrt_utils::string(query.service_name())), ec);
-
-      if (ec)
-        return results_type();
-
-      return results_type::create(
-          endpoint_pairs, query.hints(),
-          query.host_name(), query.service_name());
-    }
-    catch (Platform::Exception^ e)
-    {
-      ec = asio::error_code(e->HResult,
-          asio::system_category());
-      return results_type();
-    }
-  }
-
-  // Asynchronously resolve a query to a list of entries.
-  template <typename Handler, typename IoExecutor>
-  void async_resolve(implementation_type& impl, const query_type& query,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef winrt_resolve_op<Protocol, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(query, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "resolver", &impl, 0, "async_resolve"));
-    (void)impl;
-
-    try
-    {
-      using namespace Windows::Networking::Sockets;
-      async_manager_.async(DatagramSocket::GetEndpointPairsAsync(
-            winrt_utils::host_name(query.host_name()),
-            winrt_utils::string(query.service_name())), p.p);
-      p.v = p.p = 0;
-    }
-    catch (Platform::Exception^ e)
-    {
-      p.p->ec_ = asio::error_code(
-          e->HResult, asio::system_category());
-      scheduler_.post_immediate_completion(p.p, is_continuation);
-      p.v = p.p = 0;
-    }
-  }
-
-  // Resolve an endpoint to a list of entries.
-  results_type resolve(implementation_type&,
-      const endpoint_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return results_type();
-  }
-
-  // Asynchronously resolve an endpoint to a list of entries.
-  template <typename Handler, typename IoExecutor>
-  void async_resolve(implementation_type&, const endpoint_type&,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const results_type results;
-    asio::post(io_ex, detail::bind_handler(handler, ec, results));
-  }
-
-private:
-  // The scheduler implementation used for delivering completions.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-  winrt_async_manager& async_manager_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_connect_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_connect_op.hpp
deleted file mode 100644
index 008062e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_connect_op.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// detail/winrt_socket_connect_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
-#define ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename IoExecutor>
-class winrt_socket_connect_op :
-  public winrt_async_op<void>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(winrt_socket_connect_op);
-
-  winrt_socket_connect_op(Handler& handler, const IoExecutor& io_ex)
-    : winrt_async_op<void>(&winrt_socket_connect_op::do_complete),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code&, std::size_t)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, o->ec_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  handler_work<Handler, IoExecutor> executor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_recv_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_recv_op.hpp
deleted file mode 100644
index 4b1d9f8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_recv_op.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// detail/winrt_socket_recv_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP
-#define ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
-class winrt_socket_recv_op :
-  public winrt_async_op<Windows::Storage::Streams::IBuffer^>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(winrt_socket_recv_op);
-
-  winrt_socket_recv_op(const MutableBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : winrt_async_op<Windows::Storage::Streams::IBuffer^>(
-          &winrt_socket_recv_op::do_complete),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code&, std::size_t)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    winrt_socket_recv_op* o(static_cast<winrt_socket_recv_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    std::size_t bytes_transferred = o->result_ ? o->result_->Length : 0;
-    if (bytes_transferred == 0 && !o->ec_ &&
-        !buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::all_empty(o->buffers_))
-    {
-      o->ec_ = asio::error::eof;
-    }
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, bytes_transferred);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  MutableBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> executor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_send_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_send_op.hpp
deleted file mode 100644
index eb21ef7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_socket_send_op.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//
-// detail/winrt_socket_send_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP
-#define ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_work.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/winrt_async_op.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-class winrt_socket_send_op :
-  public winrt_async_op<unsigned int>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(winrt_socket_send_op);
-
-  winrt_socket_send_op(const ConstBufferSequence& buffers,
-      Handler& handler, const IoExecutor& io_ex)
-    : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete),
-      buffers_(buffers),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_complete(void* owner, operation* base,
-      const asio::error_code&, std::size_t)
-  {
-    // Take ownership of the operation object.
-    ASIO_ASSUME(base != 0);
-    winrt_socket_send_op* o(static_cast<winrt_socket_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    handler_work<Handler, IoExecutor> w(
-        static_cast<handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-#if defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-    // Check whether buffers are still valid.
-    if (owner)
-    {
-      buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::validate(o->buffers_);
-    }
-#endif // defined(ASIO_ENABLE_BUFFER_DEBUGGING)
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->result_);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      fenced_block b(fenced_block::half);
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
-      w.complete(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  ConstBufferSequence buffers_;
-  Handler handler_;
-  handler_work<Handler, IoExecutor> executor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service.hpp
deleted file mode 100644
index 6b45ed4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service.hpp
+++ /dev/null
@@ -1,250 +0,0 @@
-//
-// detail/winrt_ssocket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP
-#define ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/winrt_socket_connect_op.hpp"
-#include "asio/detail/winrt_ssocket_service_base.hpp"
-#include "asio/detail/winrt_utils.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Protocol>
-class winrt_ssocket_service :
-  public execution_context_service_base<winrt_ssocket_service<Protocol>>,
-  public winrt_ssocket_service_base
-{
-public:
-  // The protocol type.
-  typedef Protocol protocol_type;
-
-  // The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  // The native type of a socket.
-  typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type;
-
-  // The implementation type of the socket.
-  struct implementation_type : base_implementation_type
-  {
-    // Default constructor.
-    implementation_type()
-      : base_implementation_type(),
-        protocol_(endpoint_type().protocol())
-    {
-    }
-
-    // The protocol associated with the socket.
-    protocol_type protocol_;
-  };
-
-  // Constructor.
-  winrt_ssocket_service(execution_context& context)
-    : execution_context_service_base<winrt_ssocket_service<Protocol>>(context),
-      winrt_ssocket_service_base(context)
-  {
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-    this->base_shutdown();
-  }
-
-  // Move-construct a new socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl) noexcept
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type& impl,
-      winrt_ssocket_service& other_service,
-      implementation_type& other_impl)
-  {
-    this->base_move_assign(impl, other_service, other_impl);
-
-    impl.protocol_ = other_impl.protocol_;
-    other_impl.protocol_ = endpoint_type().protocol();
-  }
-
-  // Move-construct a new socket implementation from another protocol type.
-  template <typename Protocol1>
-  void converting_move_construct(implementation_type& impl,
-      winrt_ssocket_service<Protocol1>&,
-      typename winrt_ssocket_service<
-        Protocol1>::implementation_type& other_impl)
-  {
-    this->base_move_construct(impl, other_impl);
-
-    impl.protocol_ = protocol_type(other_impl.protocol_);
-    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
-  }
-
-  // Open a new socket implementation.
-  asio::error_code open(implementation_type& impl,
-      const protocol_type& protocol, asio::error_code& ec)
-  {
-    if (is_open(impl))
-    {
-      ec = asio::error::already_open;
-      return ec;
-    }
-
-    try
-    {
-      impl.socket_ = ref new Windows::Networking::Sockets::StreamSocket;
-      impl.protocol_ = protocol;
-      ec = asio::error_code();
-    }
-    catch (Platform::Exception^ e)
-    {
-      ec = asio::error_code(e->HResult,
-            asio::system_category());
-    }
-
-    return ec;
-  }
-
-  // Assign a native socket to a socket implementation.
-  asio::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      asio::error_code& ec)
-  {
-    if (is_open(impl))
-    {
-      ec = asio::error::already_open;
-      return ec;
-    }
-
-    impl.socket_ = native_socket;
-    impl.protocol_ = protocol;
-    ec = asio::error_code();
-
-    return ec;
-  }
-
-  // Bind the socket to the specified local endpoint.
-  asio::error_code bind(implementation_type&,
-      const endpoint_type&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    endpoint.resize(do_get_endpoint(impl, true,
-          endpoint.data(), endpoint.size(), ec));
-    return endpoint;
-  }
-
-  // Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    endpoint_type endpoint;
-    endpoint.resize(do_get_endpoint(impl, false,
-          endpoint.data(), endpoint.size(), ec));
-    return endpoint;
-  }
-
-  // Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type&,
-      socket_base::shutdown_type, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Set a socket option.
-  template <typename Option>
-  asio::error_code set_option(implementation_type& impl,
-      const Option& option, asio::error_code& ec)
-  {
-    return do_set_option(impl, option.level(impl.protocol_),
-        option.name(impl.protocol_), option.data(impl.protocol_),
-        option.size(impl.protocol_), ec);
-  }
-
-  // Get a socket option.
-  template <typename Option>
-  asio::error_code get_option(const implementation_type& impl,
-      Option& option, asio::error_code& ec) const
-  {
-    std::size_t size = option.size(impl.protocol_);
-    do_get_option(impl, option.level(impl.protocol_),
-        option.name(impl.protocol_),
-        option.data(impl.protocol_), &size, ec);
-    if (!ec)
-      option.resize(impl.protocol_, size);
-    return ec;
-  }
-
-  // Connect the socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    return do_connect(impl, peer_endpoint.data(), ec);
-  }
-
-  // Start an asynchronous connect.
-  template <typename Handler, typename IoExecutor>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef winrt_socket_connect_op<Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "socket", &impl, 0, "async_connect"));
-
-    start_connect_op(impl, peer_endpoint.data(), p.p, is_continuation);
-    p.v = p.p = 0;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service_base.hpp
deleted file mode 100644
index 626b3e6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_ssocket_service_base.hpp
+++ /dev/null
@@ -1,362 +0,0 @@
-//
-// detail/winrt_ssocket_service_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
-#define ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/buffer.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/winrt_async_manager.hpp"
-#include "asio/detail/winrt_socket_recv_op.hpp"
-#include "asio/detail/winrt_socket_send_op.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class winrt_ssocket_service_base
-{
-public:
-  // The native type of a socket.
-  typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type;
-
-  // The implementation type of the socket.
-  struct base_implementation_type
-  {
-    // Default constructor.
-    base_implementation_type()
-      : socket_(nullptr),
-        next_(0),
-        prev_(0)
-    {
-    }
-
-    // The underlying native socket.
-    native_handle_type socket_;
-
-    // Pointers to adjacent socket implementations in linked list.
-    base_implementation_type* next_;
-    base_implementation_type* prev_;
-  };
-
-  // Constructor.
-  ASIO_DECL winrt_ssocket_service_base(execution_context& context);
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void base_shutdown();
-
-  // Construct a new socket implementation.
-  ASIO_DECL void construct(base_implementation_type&);
-
-  // Move-construct a new socket implementation.
-  ASIO_DECL void base_move_construct(base_implementation_type& impl,
-      base_implementation_type& other_impl) noexcept;
-
-  // Move-assign from another socket implementation.
-  ASIO_DECL void base_move_assign(base_implementation_type& impl,
-      winrt_ssocket_service_base& other_service,
-      base_implementation_type& other_impl);
-
-  // Destroy a socket implementation.
-  ASIO_DECL void destroy(base_implementation_type& impl);
-
-  // Determine whether the socket is open.
-  bool is_open(const base_implementation_type& impl) const
-  {
-    return impl.socket_ != nullptr;
-  }
-
-  // Destroy a socket implementation.
-  ASIO_DECL asio::error_code close(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Release ownership of the socket.
-  ASIO_DECL native_handle_type release(
-      base_implementation_type& impl, asio::error_code& ec);
-
-  // Get the native socket representation.
-  native_handle_type native_handle(base_implementation_type& impl)
-  {
-    return impl.socket_;
-  }
-
-  // Cancel all operations associated with the socket.
-  asio::error_code cancel(base_implementation_type&,
-      asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const base_implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return false;
-  }
-
-  // Determine the number of bytes available for reading.
-  std::size_t available(const base_implementation_type&,
-      asio::error_code& ec) const
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Perform an IO control command on the socket.
-  template <typename IO_Control_Command>
-  asio::error_code io_control(base_implementation_type&,
-      IO_Control_Command&, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type&) const
-  {
-    return false;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  asio::error_code non_blocking(base_implementation_type&,
-      bool, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type&) const
-  {
-    return false;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  asio::error_code native_non_blocking(base_implementation_type&,
-      bool, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return ec;
-  }
-
-  // Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  std::size_t send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return do_send(impl,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::first(buffers), flags, ec);
-  }
-
-  // Wait until data can be sent without blocking.
-  std::size_t send(base_implementation_type&, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous send. The data being sent must be valid for the
-  // lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type& impl,
-      const ConstBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef winrt_socket_send_op<ConstBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "socket", &impl, 0, "async_send"));
-
-    start_send_op(impl,
-        buffer_sequence_adapter<asio::const_buffer,
-          ConstBufferSequence>::first(buffers),
-        flags, p.p, is_continuation);
-    p.v = p.p = 0;
-  }
-
-  // Start an asynchronous wait until data can be sent without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_send(base_implementation_type&, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex,
-        detail::bind_handler(handler, ec, bytes_transferred));
-  }
-
-  // Receive some data from the peer. Returns the number of bytes received.
-  template <typename MutableBufferSequence>
-  std::size_t receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return do_receive(impl,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  std::size_t receive(base_implementation_type&, const null_buffers&,
-      socket_base::message_flags, asio::error_code& ec)
-  {
-    ec = asio::error::operation_not_supported;
-    return 0;
-  }
-
-  // Start an asynchronous receive. The buffer for the data being received
-  // must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence,
-      typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags flags,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef winrt_socket_recv_op<MutableBufferSequence, Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(buffers, handler, io_ex);
-
-    ASIO_HANDLER_CREATION((scheduler_.context(),
-          *p.p, "socket", &impl, 0, "async_receive"));
-
-    start_receive_op(impl,
-        buffer_sequence_adapter<asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers),
-        flags, p.p, is_continuation);
-    p.v = p.p = 0;
-  }
-
-  // Wait until data can be received without blocking.
-  template <typename Handler, typename IoExecutor>
-  void async_receive(base_implementation_type&, const null_buffers&,
-      socket_base::message_flags, Handler& handler, const IoExecutor& io_ex)
-  {
-    asio::error_code ec = asio::error::operation_not_supported;
-    const std::size_t bytes_transferred = 0;
-    asio::post(io_ex,
-        detail::bind_handler(handler, ec, bytes_transferred));
-  }
-
-protected:
-  // Helper function to obtain endpoints associated with the connection.
-  ASIO_DECL std::size_t do_get_endpoint(
-      const base_implementation_type& impl, bool local,
-      void* addr, std::size_t addr_len, asio::error_code& ec) const;
-
-  // Helper function to set a socket option.
-  ASIO_DECL asio::error_code do_set_option(
-      base_implementation_type& impl,
-      int level, int optname, const void* optval,
-      std::size_t optlen, asio::error_code& ec);
-
-  // Helper function to get a socket option.
-  ASIO_DECL void do_get_option(
-      const base_implementation_type& impl,
-      int level, int optname, void* optval,
-      std::size_t* optlen, asio::error_code& ec) const;
-
-  // Helper function to perform a synchronous connect.
-  ASIO_DECL asio::error_code do_connect(
-      base_implementation_type& impl,
-      const void* addr, asio::error_code& ec);
-
-  // Helper function to start an asynchronous connect.
-  ASIO_DECL void start_connect_op(
-      base_implementation_type& impl, const void* addr,
-      winrt_async_op<void>* op, bool is_continuation);
-
-  // Helper function to perform a synchronous send.
-  ASIO_DECL std::size_t do_send(
-      base_implementation_type& impl, const asio::const_buffer& data,
-      socket_base::message_flags flags, asio::error_code& ec);
-
-  // Helper function to start an asynchronous send.
-  ASIO_DECL void start_send_op(base_implementation_type& impl,
-      const asio::const_buffer& data, socket_base::message_flags flags,
-      winrt_async_op<unsigned int>* op, bool is_continuation);
-
-  // Helper function to perform a synchronous receive.
-  ASIO_DECL std::size_t do_receive(
-      base_implementation_type& impl, const asio::mutable_buffer& data,
-      socket_base::message_flags flags, asio::error_code& ec);
-
-  // Helper function to start an asynchronous receive.
-  ASIO_DECL void start_receive_op(base_implementation_type& impl,
-      const asio::mutable_buffer& data, socket_base::message_flags flags,
-      winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
-      bool is_continuation);
-
-  // The scheduler implementation used for delivering completions.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-  // The manager that keeps track of outstanding operations.
-  winrt_async_manager& async_manager_;
-
-  // Mutex to protect access to the linked list of implementations.
-  asio::detail::mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  base_implementation_type* impl_list_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/winrt_ssocket_service_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_timer_scheduler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_timer_scheduler.hpp
deleted file mode 100644
index aadd581..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_timer_scheduler.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// detail/winrt_timer_scheduler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP
-#define ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include <cstddef>
-#include "asio/detail/event.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/thread.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/detail/wait_op.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/scheduler.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/thread.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class winrt_timer_scheduler
-  : public execution_context_service_base<winrt_timer_scheduler>
-{
-public:
-  // Constructor.
-  ASIO_DECL winrt_timer_scheduler(execution_context& context);
-
-  // Destructor.
-  ASIO_DECL ~winrt_timer_scheduler();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown();
-
-  // Recreate internal descriptors following a fork.
-  ASIO_DECL void notify_fork(execution_context::fork_event fork_ev);
-
-  // Initialise the task. No effect as this class uses its own thread.
-  ASIO_DECL void init_task();
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-  // Move the timer operations associated with the given timer.
-  template <typename Time_Traits>
-  void move_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& to,
-      typename timer_queue<Time_Traits>::per_timer_data& from);
-
-private:
-  // Run the select loop in the thread.
-  ASIO_DECL void run_thread();
-
-  // Entry point for the select loop thread.
-  ASIO_DECL static void call_run_thread(winrt_timer_scheduler* reactor);
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // The scheduler implementation used to post completions.
-#if defined(ASIO_HAS_IOCP)
-  typedef class win_iocp_io_context scheduler_impl;
-#else
-  typedef class scheduler scheduler_impl;
-#endif
-  scheduler_impl& scheduler_;
-
-  // Mutex used to protect internal variables.
-  asio::detail::mutex mutex_;
-
-  // Event used to wake up background thread.
-  asio::detail::event event_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // The background thread that is waiting for timers to expire.
-  asio::detail::thread* thread_;
-
-  // Does the background thread need to stop.
-  bool stop_thread_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/winrt_timer_scheduler.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/winrt_timer_scheduler.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_utils.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_utils.hpp
deleted file mode 100644
index f33786c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winrt_utils.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-// detail/winrt_utils.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINRT_UTILS_HPP
-#define ASIO_DETAIL_WINRT_UTILS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-
-#include <codecvt>
-#include <cstdlib>
-#include <future>
-#include <locale>
-#include <robuffer.h>
-#include <windows.storage.streams.h>
-#include <wrl/implements.h>
-#include "asio/buffer.hpp"
-#include "asio/error_code.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace winrt_utils {
-
-inline Platform::String^ string(const char* from)
-{
-  std::wstring tmp(from, from + std::strlen(from));
-  return ref new Platform::String(tmp.c_str());
-}
-
-inline Platform::String^ string(const std::string& from)
-{
-  std::wstring tmp(from.begin(), from.end());
-  return ref new Platform::String(tmp.c_str());
-}
-
-inline std::string string(Platform::String^ from)
-{
-  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
-  return converter.to_bytes(from->Data());
-}
-
-inline Platform::String^ string(unsigned short from)
-{
-  return string(std::to_string(from));
-}
-
-template <typename T>
-inline Platform::String^ string(const T& from)
-{
-  return string(from.to_string());
-}
-
-inline int integer(Platform::String^ from)
-{
-  return _wtoi(from->Data());
-}
-
-template <typename T>
-inline Windows::Networking::HostName^ host_name(const T& from)
-{
-  return ref new Windows::Networking::HostName((string)(from));
-}
-
-template <typename ConstBufferSequence>
-inline Windows::Storage::Streams::IBuffer^ buffer_dup(
-    const ConstBufferSequence& buffers)
-{
-  using Microsoft::WRL::ComPtr;
-  using asio::buffer_size;
-  std::size_t size = buffer_size(buffers);
-  auto b = ref new Windows::Storage::Streams::Buffer(size);
-  ComPtr<IInspectable> insp = reinterpret_cast<IInspectable*>(b);
-  ComPtr<Windows::Storage::Streams::IBufferByteAccess> bacc;
-  insp.As(&bacc);
-  byte* bytes = nullptr;
-  bacc->Buffer(&bytes);
-  asio::buffer_copy(asio::buffer(bytes, size), buffers);
-  b->Length = size;
-  return b;
-}
-
-} // namespace winrt_utils
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#endif // ASIO_DETAIL_WINRT_UTILS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winsock_init.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winsock_init.hpp
deleted file mode 100644
index 7914560..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/winsock_init.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// detail/winsock_init.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WINSOCK_INIT_HPP
-#define ASIO_DETAIL_WINSOCK_INIT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class winsock_init_base
-{
-protected:
-  // Structure to track result of initialisation and number of uses. POD is used
-  // to ensure that the values are zero-initialised prior to any code being run.
-  struct data
-  {
-    long init_count_;
-    long result_;
-  };
-
-  ASIO_DECL static void startup(data& d,
-      unsigned char major, unsigned char minor);
-
-  ASIO_DECL static void manual_startup(data& d);
-
-  ASIO_DECL static void cleanup(data& d);
-
-  ASIO_DECL static void manual_cleanup(data& d);
-
-  ASIO_DECL static void throw_on_error(data& d);
-};
-
-template <int Major = 2, int Minor = 2>
-class winsock_init : private winsock_init_base
-{
-public:
-  winsock_init(bool allow_throw = true)
-  {
-    startup(data_, Major, Minor);
-    if (allow_throw)
-      throw_on_error(data_);
-  }
-
-  winsock_init(const winsock_init&)
-  {
-    startup(data_, Major, Minor);
-    throw_on_error(data_);
-  }
-
-  ~winsock_init()
-  {
-    cleanup(data_);
-  }
-
-  // This class may be used to indicate that user code will manage Winsock
-  // initialisation and cleanup. This may be required in the case of a DLL, for
-  // example, where it is not safe to initialise Winsock from global object
-  // constructors.
-  //
-  // To prevent asio from initialising Winsock, the object must be constructed
-  // before any Asio's own global objects. With MSVC, this may be accomplished
-  // by adding the following code to the DLL:
-  //
-  //   #pragma warning(push)
-  //   #pragma warning(disable:4073)
-  //   #pragma init_seg(lib)
-  //   asio::detail::winsock_init<>::manual manual_winsock_init;
-  //   #pragma warning(pop)
-  class manual
-  {
-  public:
-    manual()
-    {
-      manual_startup(data_);
-    }
-
-    manual(const manual&)
-    {
-      manual_startup(data_);
-    }
-
-    ~manual()
-    {
-      manual_cleanup(data_);
-    }
-  };
-
-private:
-  friend class manual;
-  static data data_;
-};
-
-template <int Major, int Minor>
-winsock_init_base::data winsock_init<Major, Minor>::data_;
-
-// Static variable to ensure that winsock is initialised before main, and
-// therefore before any other threads can get started.
-static const winsock_init<>& winsock_init_instance = winsock_init<>(false);
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/winsock_init.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_WINSOCK_INIT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/work_dispatcher.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/work_dispatcher.hpp
deleted file mode 100644
index 2a473e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/work_dispatcher.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-//
-// detail/work_dispatcher.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WORK_DISPATCHER_HPP
-#define ASIO_DETAIL_WORK_DISPATCHER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/prefer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename Executor, typename = void>
-struct is_work_dispatcher_required : true_type
-{
-};
-
-template <typename Handler, typename Executor>
-struct is_work_dispatcher_required<Handler, Executor,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          Executor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >> : false_type
-{
-};
-
-template <typename Handler, typename Executor, typename = void>
-class work_dispatcher
-{
-public:
-  template <typename CompletionHandler>
-  work_dispatcher(CompletionHandler&& handler,
-      const Executor& handler_ex)
-    : handler_(static_cast<CompletionHandler&&>(handler)),
-      executor_(asio::prefer(handler_ex,
-          execution::outstanding_work.tracked))
-  {
-  }
-
-  work_dispatcher(const work_dispatcher& other)
-    : handler_(other.handler_),
-      executor_(other.executor_)
-  {
-  }
-
-  work_dispatcher(work_dispatcher&& other)
-    : handler_(static_cast<Handler&&>(other.handler_)),
-      executor_(static_cast<work_executor_type&&>(other.executor_))
-  {
-  }
-
-  void operator()()
-  {
-    associated_allocator_t<Handler> alloc((get_associated_allocator)(handler_));
-    asio::prefer(executor_, execution::allocator(alloc)).execute(
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler_)));
-  }
-
-private:
-  typedef decay_t<
-      prefer_result_t<const Executor&,
-        execution::outstanding_work_t::tracked_t
-      >
-    > work_executor_type;
-
-  Handler handler_;
-  work_executor_type executor_;
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Handler, typename Executor>
-class work_dispatcher<Handler, Executor,
-    enable_if_t<!execution::is_executor<Executor>::value>>
-{
-public:
-  template <typename CompletionHandler>
-  work_dispatcher(CompletionHandler&& handler, const Executor& handler_ex)
-    : work_(handler_ex),
-      handler_(static_cast<CompletionHandler&&>(handler))
-  {
-  }
-
-  work_dispatcher(const work_dispatcher& other)
-    : work_(other.work_),
-      handler_(other.handler_)
-  {
-  }
-
-  work_dispatcher(work_dispatcher&& other)
-    : work_(static_cast<executor_work_guard<Executor>&&>(other.work_)),
-      handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()()
-  {
-    associated_allocator_t<Handler> alloc((get_associated_allocator)(handler_));
-    work_.get_executor().dispatch(
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler_)), alloc);
-    work_.reset();
-  }
-
-private:
-  executor_work_guard<Executor> work_;
-  Handler handler_;
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WORK_DISPATCHER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wrapped_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wrapped_handler.hpp
deleted file mode 100644
index fce9abf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/detail/wrapped_handler.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//
-// detail/wrapped_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_WRAPPED_HANDLER_HPP
-#define ASIO_DETAIL_WRAPPED_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct is_continuation_delegated
-{
-  template <typename Dispatcher, typename Handler>
-  bool operator()(Dispatcher&, Handler& handler) const
-  {
-    return asio_handler_cont_helpers::is_continuation(handler);
-  }
-};
-
-struct is_continuation_if_running
-{
-  template <typename Dispatcher, typename Handler>
-  bool operator()(Dispatcher& dispatcher, Handler&) const
-  {
-    return dispatcher.running_in_this_thread();
-  }
-};
-
-template <typename Dispatcher, typename Handler,
-    typename IsContinuation = is_continuation_delegated>
-class wrapped_handler
-{
-public:
-  typedef void result_type;
-
-  wrapped_handler(Dispatcher dispatcher, Handler& handler)
-    : dispatcher_(dispatcher),
-      handler_(static_cast<Handler&&>(handler))
-  {
-  }
-
-  wrapped_handler(const wrapped_handler& other)
-    : dispatcher_(other.dispatcher_),
-      handler_(other.handler_)
-  {
-  }
-
-  wrapped_handler(wrapped_handler&& other)
-    : dispatcher_(other.dispatcher_),
-      handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()()
-  {
-    dispatcher_.dispatch(static_cast<Handler&&>(handler_));
-  }
-
-  void operator()() const
-  {
-    dispatcher_.dispatch(handler_);
-  }
-
-  template <typename Arg1>
-  void operator()(const Arg1& arg1)
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
-  }
-
-  template <typename Arg1>
-  void operator()(const Arg1& arg1) const
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
-  }
-
-  template <typename Arg1, typename Arg2>
-  void operator()(const Arg1& arg1, const Arg2& arg2)
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
-  }
-
-  template <typename Arg1, typename Arg2>
-  void operator()(const Arg1& arg1, const Arg2& arg2) const
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
-  {
-    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
-      const Arg4& arg4)
-  {
-    dispatcher_.dispatch(
-        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
-      const Arg4& arg4) const
-  {
-    dispatcher_.dispatch(
-        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
-      typename Arg5>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
-      const Arg4& arg4, const Arg5& arg5)
-  {
-    dispatcher_.dispatch(
-        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
-      typename Arg5>
-  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
-      const Arg4& arg4, const Arg5& arg5) const
-  {
-    dispatcher_.dispatch(
-        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
-  }
-
-//private:
-  Dispatcher dispatcher_;
-  Handler handler_;
-};
-
-template <typename Handler, typename Context>
-class rewrapped_handler
-{
-public:
-  explicit rewrapped_handler(Handler& handler, const Context& context)
-    : context_(context),
-      handler_(static_cast<Handler&&>(handler))
-  {
-  }
-
-  explicit rewrapped_handler(const Handler& handler, const Context& context)
-    : context_(context),
-      handler_(handler)
-  {
-  }
-
-  rewrapped_handler(const rewrapped_handler& other)
-    : context_(other.context_),
-      handler_(other.handler_)
-  {
-  }
-
-  rewrapped_handler(rewrapped_handler&& other)
-    : context_(static_cast<Context&&>(other.context_)),
-      handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()()
-  {
-    handler_();
-  }
-
-  void operator()() const
-  {
-    handler_();
-  }
-
-//private:
-  Context context_;
-  Handler handler_;
-};
-
-template <typename Dispatcher, typename Handler, typename IsContinuation>
-inline bool asio_handler_is_continuation(
-    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
-{
-  return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
-}
-
-template <typename Dispatcher, typename Context>
-inline bool asio_handler_is_continuation(
-    rewrapped_handler<Dispatcher, Context>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->context_);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_WRAPPED_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/dispatch.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/dispatch.hpp
deleted file mode 100644
index 9eb60a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/dispatch.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-//
-// dispatch.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DISPATCH_HPP
-#define ASIO_DISPATCH_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiate_dispatch.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the object's associated
- * executor. The function object may be called from the current thread prior to
- * returning from <tt>dispatch()</tt>. Otherwise, it is queued for execution.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
- * as:
- *
- * @code class Init
- * {
- * public:
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex of type @c Ex by
- * performing @code auto ex = get_associated_executor(handler); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(ex, execution::allocator(alloc)).execute(
- *     std::forward<CompletionHandler>(completion_handler)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.dispatch(
- *     std::forward<CompletionHandler>(completion_handler),
- *     alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
-inline auto dispatch(NullaryToken&& token)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_dispatch>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_dispatch(), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the specified executor.
- * The function object may be called from the current thread prior to returning
- * from <tt>dispatch()</tt>. Otherwise, it is queued for execution.
- *
- * @param ex The target executor.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
- * defined as:
- *
- * @code class Init
- * {
- * public:
- *   using executor_type = Executor;
- *   explicit Init(const Executor& ex) : ex_(ex) {}
- *   executor_type get_executor() const noexcept { return ex_; }
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * private:
- *   Executor ex_; // exposition only
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
- * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
- * function object @c f with a member @c executor_ that is initialised with
- * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
- * handler_ that is a decay-copy of @c completion_handler, and a function call
- * operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
- * @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
- * function object @c f with a member @c work_ that is initialised with
- * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
- * @c completion_handler, and a function call operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * work_.get_executor().dispatch(std::move(handler_), a);
- * work_.reset(); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(ex, execution::allocator(alloc)).execute(std::move(f)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.dispatch(std::move(f), alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename Executor,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<Executor>>
-inline auto dispatch(const Executor& ex,
-    NullaryToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      execution::is_executor<Executor>::value || is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_dispatch_with_executor<Executor>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_dispatch_with_executor<Executor>(ex), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * @param ctx An execution context, from which the target executor is obtained.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns <tt>dispatch(ctx.get_executor(),
- * forward<NullaryToken>(token))</tt>.
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename ExecutionContext,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<typename ExecutionContext::executor_type>>
-inline auto dispatch(ExecutionContext& ctx,
-    NullaryToken&& token = default_completion_token_t<
-      typename ExecutionContext::executor_type>(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_dispatch_with_executor<
-        typename ExecutionContext::executor_type>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_dispatch_with_executor<
-        typename ExecutionContext::executor_type>(
-          ctx.get_executor()), token);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DISPATCH_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error.hpp
deleted file mode 100644
index d676ee8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error.hpp
+++ /dev/null
@@ -1,389 +0,0 @@
-//
-// error.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ERROR_HPP
-#define ASIO_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/error_code.hpp"
-#include "asio/system_error.hpp"
-#if defined(ASIO_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(ASIO_WINDOWS_RUNTIME)
-# include <winerror.h>
-#else
-# include <cerrno>
-# include <netdb.h>
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-/// INTERNAL ONLY.
-# define ASIO_NATIVE_ERROR(e) implementation_defined
-/// INTERNAL ONLY.
-# define ASIO_SOCKET_ERROR(e) implementation_defined
-/// INTERNAL ONLY.
-# define ASIO_NETDB_ERROR(e) implementation_defined
-/// INTERNAL ONLY.
-# define ASIO_GETADDRINFO_ERROR(e) implementation_defined
-/// INTERNAL ONLY.
-# define ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
-#elif defined(ASIO_WINDOWS_RUNTIME)
-# define ASIO_NATIVE_ERROR(e) __HRESULT_FROM_WIN32(e)
-# define ASIO_SOCKET_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
-# define ASIO_NETDB_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
-# define ASIO_GETADDRINFO_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
-# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# define ASIO_NATIVE_ERROR(e) e
-# define ASIO_SOCKET_ERROR(e) WSA ## e
-# define ASIO_NETDB_ERROR(e) WSA ## e
-# define ASIO_GETADDRINFO_ERROR(e) WSA ## e
-# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
-#else
-# define ASIO_NATIVE_ERROR(e) e
-# define ASIO_SOCKET_ERROR(e) e
-# define ASIO_NETDB_ERROR(e) e
-# define ASIO_GETADDRINFO_ERROR(e) e
-# define ASIO_WIN_OR_POSIX(e_win, e_posix) e_posix
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace error {
-
-enum basic_errors
-{
-  /// Permission denied.
-  access_denied = ASIO_SOCKET_ERROR(EACCES),
-
-  /// Address family not supported by protocol.
-  address_family_not_supported = ASIO_SOCKET_ERROR(EAFNOSUPPORT),
-
-  /// Address already in use.
-  address_in_use = ASIO_SOCKET_ERROR(EADDRINUSE),
-
-  /// Transport endpoint is already connected.
-  already_connected = ASIO_SOCKET_ERROR(EISCONN),
-
-  /// Operation already in progress.
-  already_started = ASIO_SOCKET_ERROR(EALREADY),
-
-  /// Broken pipe.
-  broken_pipe = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_BROKEN_PIPE),
-      ASIO_NATIVE_ERROR(EPIPE)),
-
-  /// A connection has been aborted.
-  connection_aborted = ASIO_SOCKET_ERROR(ECONNABORTED),
-
-  /// Connection refused.
-  connection_refused = ASIO_SOCKET_ERROR(ECONNREFUSED),
-
-  /// Connection reset by peer.
-  connection_reset = ASIO_SOCKET_ERROR(ECONNRESET),
-
-  /// Bad file descriptor.
-  bad_descriptor = ASIO_SOCKET_ERROR(EBADF),
-
-  /// Bad address.
-  fault = ASIO_SOCKET_ERROR(EFAULT),
-
-  /// No route to host.
-  host_unreachable = ASIO_SOCKET_ERROR(EHOSTUNREACH),
-
-  /// Operation now in progress.
-  in_progress = ASIO_SOCKET_ERROR(EINPROGRESS),
-
-  /// Interrupted system call.
-  interrupted = ASIO_SOCKET_ERROR(EINTR),
-
-  /// Invalid argument.
-  invalid_argument = ASIO_SOCKET_ERROR(EINVAL),
-
-  /// Message too long.
-  message_size = ASIO_SOCKET_ERROR(EMSGSIZE),
-
-  /// The name was too long.
-  name_too_long = ASIO_SOCKET_ERROR(ENAMETOOLONG),
-
-  /// Network is down.
-  network_down = ASIO_SOCKET_ERROR(ENETDOWN),
-
-  /// Network dropped connection on reset.
-  network_reset = ASIO_SOCKET_ERROR(ENETRESET),
-
-  /// Network is unreachable.
-  network_unreachable = ASIO_SOCKET_ERROR(ENETUNREACH),
-
-  /// Too many open files.
-  no_descriptors = ASIO_SOCKET_ERROR(EMFILE),
-
-  /// No buffer space available.
-  no_buffer_space = ASIO_SOCKET_ERROR(ENOBUFS),
-
-  /// Cannot allocate memory.
-  no_memory = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_OUTOFMEMORY),
-      ASIO_NATIVE_ERROR(ENOMEM)),
-
-  /// Operation not permitted.
-  no_permission = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_ACCESS_DENIED),
-      ASIO_NATIVE_ERROR(EPERM)),
-
-  /// Protocol not available.
-  no_protocol_option = ASIO_SOCKET_ERROR(ENOPROTOOPT),
-
-  /// No such device.
-  no_such_device = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_BAD_UNIT),
-      ASIO_NATIVE_ERROR(ENODEV)),
-
-  /// Transport endpoint is not connected.
-  not_connected = ASIO_SOCKET_ERROR(ENOTCONN),
-
-  /// Socket operation on non-socket.
-  not_socket = ASIO_SOCKET_ERROR(ENOTSOCK),
-
-  /// Operation cancelled.
-  operation_aborted = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_OPERATION_ABORTED),
-      ASIO_NATIVE_ERROR(ECANCELED)),
-
-  /// Operation not supported.
-  operation_not_supported = ASIO_SOCKET_ERROR(EOPNOTSUPP),
-
-  /// Cannot send after transport endpoint shutdown.
-  shut_down = ASIO_SOCKET_ERROR(ESHUTDOWN),
-
-  /// Connection timed out.
-  timed_out = ASIO_SOCKET_ERROR(ETIMEDOUT),
-
-  /// Resource temporarily unavailable.
-  try_again = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(ERROR_RETRY),
-      ASIO_NATIVE_ERROR(EAGAIN)),
-
-  /// The socket is marked non-blocking and the requested operation would block.
-  would_block = ASIO_SOCKET_ERROR(EWOULDBLOCK)
-};
-
-enum netdb_errors
-{
-  /// Host not found (authoritative).
-  host_not_found = ASIO_NETDB_ERROR(HOST_NOT_FOUND),
-
-  /// Host not found (non-authoritative).
-  host_not_found_try_again = ASIO_NETDB_ERROR(TRY_AGAIN),
-
-  /// The query is valid but does not have associated address data.
-  no_data = ASIO_NETDB_ERROR(NO_DATA),
-
-  /// A non-recoverable error occurred.
-  no_recovery = ASIO_NETDB_ERROR(NO_RECOVERY)
-};
-
-enum addrinfo_errors
-{
-  /// The service is not supported for the given socket type.
-  service_not_found = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
-      ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
-
-  /// The socket type is not supported.
-  socket_type_not_supported = ASIO_WIN_OR_POSIX(
-      ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
-      ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
-};
-
-enum misc_errors
-{
-  /// Already open.
-  already_open = 1,
-
-  /// End of file or stream.
-  eof,
-
-  /// Element not found.
-  not_found,
-
-  /// The descriptor cannot fit into the select system call's fd_set.
-  fd_set_failure
-};
-
-// boostify: non-boost code starts here
-#if !defined(ASIO_ERROR_LOCATION)
-# define ASIO_ERROR_LOCATION(e) (void)0
-#endif // !defined(ASIO_ERROR_LOCATION)
-
-// boostify: non-boost code ends here
-#if !defined(ASIO_ERROR_LOCATION) \
-  && !defined(ASIO_DISABLE_ERROR_LOCATION) \
-  && defined(ASIO_HAS_BOOST_CONFIG) \
-  && (BOOST_VERSION >= 107900)
-
-# define ASIO_ERROR_LOCATION(e) \
-  do { \
-    BOOST_STATIC_CONSTEXPR boost::source_location loc \
-      = BOOST_CURRENT_LOCATION; \
-    (e).assign((e), &loc); \
-  } while (false)
-
-#else // !defined(ASIO_ERROR_LOCATION)
-      //   && !defined(ASIO_DISABLE_ERROR_LOCATION)
-      //   && defined(ASIO_HAS_BOOST_CONFIG)
-      //   && (BOOST_VERSION >= 107900)
-
-# define ASIO_ERROR_LOCATION(e) (void)0
-
-#endif // !defined(ASIO_ERROR_LOCATION)
-       //   && !defined(ASIO_DISABLE_ERROR_LOCATION)
-       //   && defined(ASIO_HAS_BOOST_CONFIG)
-       //   && (BOOST_VERSION >= 107900)
-
-inline void clear(asio::error_code& ec)
-{
-  ec.assign(0, ec.category());
-}
-
-inline const asio::error_category& get_system_category()
-{
-  return asio::system_category();
-}
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-extern ASIO_DECL
-const asio::error_category& get_netdb_category();
-
-extern ASIO_DECL
-const asio::error_category& get_addrinfo_category();
-
-#else // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-inline const asio::error_category& get_netdb_category()
-{
-  return get_system_category();
-}
-
-inline const asio::error_category& get_addrinfo_category()
-{
-  return get_system_category();
-}
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-extern ASIO_DECL
-const asio::error_category& get_misc_category();
-
-static const asio::error_category&
-  system_category ASIO_UNUSED_VARIABLE
-  = asio::error::get_system_category();
-static const asio::error_category&
-  netdb_category ASIO_UNUSED_VARIABLE
-  = asio::error::get_netdb_category();
-static const asio::error_category&
-  addrinfo_category ASIO_UNUSED_VARIABLE
-  = asio::error::get_addrinfo_category();
-static const asio::error_category&
-  misc_category ASIO_UNUSED_VARIABLE
-  = asio::error::get_misc_category();
-
-} // namespace error
-} // namespace asio
-
-namespace std {
-
-template<> struct is_error_code_enum<asio::error::basic_errors>
-{
-  static const bool value = true;
-};
-
-template<> struct is_error_code_enum<asio::error::netdb_errors>
-{
-  static const bool value = true;
-};
-
-template<> struct is_error_code_enum<asio::error::addrinfo_errors>
-{
-  static const bool value = true;
-};
-
-template<> struct is_error_code_enum<asio::error::misc_errors>
-{
-  static const bool value = true;
-};
-
-} // namespace std
-
-namespace asio {
-namespace error {
-
-inline asio::error_code make_error_code(basic_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_system_category());
-}
-
-inline asio::error_code make_error_code(netdb_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_netdb_category());
-}
-
-inline asio::error_code make_error_code(addrinfo_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_addrinfo_category());
-}
-
-inline asio::error_code make_error_code(misc_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_misc_category());
-}
-
-} // namespace error
-namespace stream_errc {
-  // Simulates the proposed stream_errc scoped enum.
-  using error::eof;
-  using error::not_found;
-} // namespace stream_errc
-namespace socket_errc {
-  // Simulates the proposed socket_errc scoped enum.
-  using error::already_open;
-  using error::not_found;
-} // namespace socket_errc
-namespace resolver_errc {
-  // Simulates the proposed resolver_errc scoped enum.
-  using error::host_not_found;
-  const error::netdb_errors try_again = error::host_not_found_try_again;
-  using error::service_not_found;
-} // namespace resolver_errc
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#undef ASIO_NATIVE_ERROR
-#undef ASIO_SOCKET_ERROR
-#undef ASIO_NETDB_ERROR
-#undef ASIO_GETADDRINFO_ERROR
-#undef ASIO_WIN_OR_POSIX
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/error.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error_code.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error_code.hpp
deleted file mode 100644
index 5cb07f4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/error_code.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// error_code.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_ERROR_CODE_HPP
-#define ASIO_ERROR_CODE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <system_error>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-typedef std::error_category error_category;
-typedef std::error_code error_code;
-
-/// Returns the error category used for the system errors produced by asio.
-extern ASIO_DECL const error_category& system_category();
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/error_code.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_ERROR_CODE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution.hpp
deleted file mode 100644
index fa77325..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// execution.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_HPP
-#define ASIO_EXECUTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/execution/allocator.hpp"
-#include "asio/execution/any_executor.hpp"
-#include "asio/execution/bad_executor.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/blocking_adaptation.hpp"
-#include "asio/execution/context.hpp"
-#include "asio/execution/context_as.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/invocable_archetype.hpp"
-#include "asio/execution/mapping.hpp"
-#include "asio/execution/occupancy.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/execution/prefer_only.hpp"
-#include "asio/execution/relationship.hpp"
-
-#endif // ASIO_EXECUTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/allocator.hpp
deleted file mode 100644
index cdb6a4a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/allocator.hpp
+++ /dev/null
@@ -1,278 +0,0 @@
-//
-// execution/allocator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_ALLOCATOR_HPP
-#define ASIO_EXECUTION_ALLOCATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe which allocator an executor will use to allocate the
-/// memory required to store a submitted function object.
-template <typename ProtoAllocator>
-struct allocator_t
-{
-  /// The allocator_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The allocator_t property can be required.
-  static constexpr bool is_requirable = true;
-
-  /// The allocator_t property can be preferred.
-  static constexpr bool is_preferable = true;
-
-  /// Default constructor.
-  constexpr allocator_t();
-
-  /// Obtain the allocator stored in the allocator_t property object.
-  /**
-   * Present only if @c ProtoAllocator is non-void.
-   */
-  constexpr ProtoAllocator value() const;
-
-  /// Create an allocator_t object with a different allocator.
-  /**
-   * Present only if @c ProtoAllocator is void.
-   */
-  template <typename OtherAllocator>
-  allocator_t<OtherAllocator operator()(const OtherAllocator& a);
-};
-
-/// A special value used for accessing the allocator_t property.
-constexpr allocator_t<void> allocator;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-template <typename ProtoAllocator>
-struct allocator_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, allocator_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(allocator_t::static_query<E>())>
-  static constexpr const T static_query_v = allocator_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  constexpr ProtoAllocator value() const
-  {
-    return a_;
-  }
-
-private:
-  friend struct allocator_t<void>;
-
-  explicit constexpr allocator_t(const ProtoAllocator& a)
-    : a_(a)
-  {
-  }
-
-  ProtoAllocator a_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <typename ProtoAllocator> template <typename E, typename T>
-const T allocator_t<ProtoAllocator>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <>
-struct allocator_t<void>
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-
-  constexpr allocator_t()
-  {
-  }
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, allocator_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(allocator_t::static_query<E>())>
-  static constexpr const T static_query_v = allocator_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  template <typename OtherProtoAllocator>
-  constexpr allocator_t<OtherProtoAllocator> operator()(
-      const OtherProtoAllocator& a) const
-  {
-    return allocator_t<OtherProtoAllocator>(a);
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <typename E, typename T>
-const T allocator_t<void>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-constexpr allocator_t<void> allocator;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename ProtoAllocator>
-struct is_applicable_property<T, execution::allocator_t<ProtoAllocator>>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T, typename ProtoAllocator>
-struct static_query<T, execution::allocator_t<ProtoAllocator>,
-  enable_if_t<
-    execution::allocator_t<ProtoAllocator>::template
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::allocator_t<ProtoAllocator>::template
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::allocator_t<ProtoAllocator>::template
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/any_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/any_executor.hpp
deleted file mode 100644
index a057543..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/any_executor.hpp
+++ /dev/null
@@ -1,1933 +0,0 @@
-//
-// execution/any_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_ANY_EXECUTOR_HPP
-#define ASIO_EXECUTION_ANY_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <new>
-#include <typeinfo>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/cstddef.hpp"
-#include "asio/detail/executor_function.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/execution/bad_executor.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// Polymorphic executor wrapper.
-template <typename... SupportableProperties>
-class any_executor
-{
-public:
-  /// Default constructor.
-  any_executor() noexcept;
-
-  /// Construct in an empty state. Equivalent effects to default constructor.
-  any_executor(nullptr_t) noexcept;
-
-  /// Copy constructor.
-  any_executor(const any_executor& e) noexcept;
-
-  /// Move constructor.
-  any_executor(any_executor&& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-  template <class... OtherSupportableProperties>
-    any_executor(any_executor<OtherSupportableProperties...> e);
-
-  /// Construct to point to the same target as another any_executor.
-  template <class... OtherSupportableProperties>
-    any_executor(std::nothrow_t,
-      any_executor<OtherSupportableProperties...> e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-  any_executor(std::nothrow_t, const any_executor& e) noexcept;
-
-  /// Construct to point to the same target as another any_executor.
-  any_executor(std::nothrow_t, any_executor&& e) noexcept;
-
-  /// Construct a polymorphic wrapper for the specified executor.
-  template <typename Executor>
-  any_executor(Executor e);
-
-  /// Construct a polymorphic wrapper for the specified executor.
-  template <typename Executor>
-  any_executor(std::nothrow_t, Executor e) noexcept;
-
-  /// Assignment operator.
-  any_executor& operator=(const any_executor& e) noexcept;
-
-  /// Move assignment operator.
-  any_executor& operator=(any_executor&& e) noexcept;
-
-  /// Assignment operator that sets the polymorphic wrapper to the empty state.
-  any_executor& operator=(nullptr_t);
-
-  /// Assignment operator to create a polymorphic wrapper for the specified
-  /// executor.
-  template <typename Executor>
-  any_executor& operator=(Executor e);
-
-  /// Destructor.
-  ~any_executor();
-
-  /// Swap targets with another polymorphic wrapper.
-  void swap(any_executor& other) noexcept;
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require and asio::prefer customisation points.
-   *
-   * For example:
-   * @code execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-   * auto ex2 = asio::requre(ex, execution::blocking.possibly); @endcode
-   */
-  template <typename Property>
-  any_executor require(Property) const;
-
-  /// Obtain a polymorphic wrapper with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::prefer customisation point.
-   *
-   * For example:
-   * @code execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-   * auto ex2 = asio::prefer(ex, execution::blocking.possibly); @endcode
-   */
-  template <typename Property>
-  any_executor prefer(Property) const;
-
-  /// Obtain the value associated with the specified property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code execution::any_executor<execution::occupancy_t> ex = ...;
-   * size_t n = asio::query(ex, execution::occupancy); @endcode
-   */
-  template <typename Property>
-  typename Property::polymorphic_query_result_type query(Property) const;
-
-  /// Execute the function on the target executor.
-  /**
-   * Throws asio::bad_executor if the polymorphic wrapper has no target.
-   */
-  template <typename Function>
-  void execute(Function&& f) const;
-
-  /// Obtain the underlying execution context.
-  /**
-   * This function is provided for backward compatibility. It is automatically
-   * defined when the @c SupportableProperties... list includes a property of
-   * type <tt>execution::context_as<U></tt>, for some type <tt>U</tt>.
-   */
-  automatically_determined context() const;
-
-  /// Determine whether the wrapper has a target executor.
-  /**
-   * @returns @c true if the polymorphic wrapper has a target executor,
-   * otherwise false.
-   */
-  explicit operator bool() const noexcept;
-
-  /// Get the type of the target executor.
-  const type_info& target_type() const noexcept;
-
-  /// Get a pointer to the target executor.
-  template <typename Executor> Executor* target() noexcept;
-
-  /// Get a pointer to the target executor.
-  template <typename Executor> const Executor* target() const noexcept;
-};
-
-/// Equality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator==(const any_executor<SupportableProperties...>& a,
-    const any_executor<SupportableProperties...>& b) noexcept;
-
-/// Equality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator==(const any_executor<SupportableProperties...>& a,
-    nullptr_t) noexcept;
-
-/// Equality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator==(nullptr_t,
-    const any_executor<SupportableProperties...>& b) noexcept;
-
-/// Inequality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator!=(const any_executor<SupportableProperties...>& a,
-    const any_executor<SupportableProperties...>& b) noexcept;
-
-/// Inequality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator!=(const any_executor<SupportableProperties...>& a,
-    nullptr_t) noexcept;
-
-/// Inequality operator.
-/**
- * @relates any_executor
- */
-template <typename... SupportableProperties>
-bool operator!=(nullptr_t,
-    const any_executor<SupportableProperties...>& b) noexcept;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-#if !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
-#define ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL
-
-template <typename... SupportableProperties>
-class any_executor;
-
-#endif // !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
-
-template <typename U>
-struct context_as_t;
-
-namespace detail {
-
-// Traits used to detect whether a property is requirable or preferable, taking
-// into account that T::is_requirable or T::is_preferable may not not be well
-// formed.
-
-template <typename T, typename = void>
-struct is_requirable : false_type {};
-
-template <typename T>
-struct is_requirable<T, enable_if_t<T::is_requirable>> : true_type {};
-
-template <typename T, typename = void>
-struct is_preferable : false_type {};
-
-template <typename T>
-struct is_preferable<T, enable_if_t<T::is_preferable>> : true_type {};
-
-// Trait used to detect context_as property, for backward compatibility.
-
-template <typename T>
-struct is_context_as : false_type {};
-
-template <typename U>
-struct is_context_as<context_as_t<U>> : true_type {};
-
-// Helper template to:
-// - Check if a target can supply the supportable properties.
-// - Find the first convertible-from-T property in the list.
-
-template <std::size_t I, typename Props>
-struct supportable_properties;
-
-template <std::size_t I, typename Prop>
-struct supportable_properties<I, void(Prop)>
-{
-  template <typename T>
-  struct is_valid_target : integral_constant<bool,
-      (
-        is_requirable<Prop>::value
-          ? can_require<T, Prop>::value
-          : true
-      )
-      &&
-      (
-        is_preferable<Prop>::value
-          ? can_prefer<T, Prop>::value
-          : true
-      )
-      &&
-      (
-        !is_requirable<Prop>::value && !is_preferable<Prop>::value
-          ? can_query<T, Prop>::value
-          : true
-      )
-    >
-  {
-  };
-
-  struct found
-  {
-    static constexpr bool value = true;
-    typedef Prop type;
-    typedef typename Prop::polymorphic_query_result_type query_result_type;
-    static constexpr std::size_t index = I;
-  };
-
-  struct not_found
-  {
-    static constexpr bool value = false;
-  };
-
-  template <typename T>
-  struct find_convertible_property :
-      conditional_t<
-        is_same<T, Prop>::value || is_convertible<T, Prop>::value,
-        found,
-        not_found
-      > {};
-
-  template <typename T>
-  struct find_convertible_requirable_property :
-      conditional_t<
-        is_requirable<Prop>::value
-          && (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
-        found,
-        not_found
-      > {};
-
-  template <typename T>
-  struct find_convertible_preferable_property :
-      conditional_t<
-        is_preferable<Prop>::value
-          && (is_same<T, Prop>::value || is_convertible<T, Prop>::value),
-        found,
-        not_found
-      > {};
-
-  struct find_context_as_property :
-      conditional_t<
-        is_context_as<Prop>::value,
-        found,
-        not_found
-      > {};
-};
-
-template <std::size_t I, typename Head, typename... Tail>
-struct supportable_properties<I, void(Head, Tail...)>
-{
-  template <typename T>
-  struct is_valid_target : integral_constant<bool,
-      (
-        supportable_properties<I,
-          void(Head)>::template is_valid_target<T>::value
-        &&
-        supportable_properties<I + 1,
-          void(Tail...)>::template is_valid_target<T>::value
-      )
-    >
-  {
-  };
-
-  template <typename T>
-  struct find_convertible_property :
-      conditional_t<
-        is_convertible<T, Head>::value,
-        typename supportable_properties<I, void(Head)>::found,
-        typename supportable_properties<I + 1,
-            void(Tail...)>::template find_convertible_property<T>
-      > {};
-
-  template <typename T>
-  struct find_convertible_requirable_property :
-      conditional_t<
-        is_requirable<Head>::value
-          && is_convertible<T, Head>::value,
-        typename supportable_properties<I, void(Head)>::found,
-        typename supportable_properties<I + 1,
-            void(Tail...)>::template find_convertible_requirable_property<T>
-      > {};
-
-  template <typename T>
-  struct find_convertible_preferable_property :
-      conditional_t<
-        is_preferable<Head>::value
-          && is_convertible<T, Head>::value,
-        typename supportable_properties<I, void(Head)>::found,
-        typename supportable_properties<I + 1,
-            void(Tail...)>::template find_convertible_preferable_property<T>
-      > {};
-
-  struct find_context_as_property :
-      conditional_t<
-        is_context_as<Head>::value,
-        typename supportable_properties<I, void(Head)>::found,
-        typename supportable_properties<I + 1,
-            void(Tail...)>::find_context_as_property
-      > {};
-};
-
-template <typename T, typename Props>
-struct is_valid_target_executor :
-  conditional_t<
-    is_executor<T>::value,
-    typename supportable_properties<0, Props>::template is_valid_target<T>,
-    false_type
-  >
-{
-};
-
-template <typename Props>
-struct is_valid_target_executor<int, Props> : false_type
-{
-};
-
-class shared_target_executor
-{
-public:
-  template <typename E>
-  shared_target_executor(E&& e, decay_t<E>*& target)
-  {
-    impl<decay_t<E>>* i =
-      new impl<decay_t<E>>(static_cast<E&&>(e));
-    target = &i->ex_;
-    impl_ = i;
-  }
-
-  template <typename E>
-  shared_target_executor(std::nothrow_t, E&& e, decay_t<E>*& target) noexcept
-  {
-    impl<decay_t<E>>* i =
-      new (std::nothrow) impl<decay_t<E>>(static_cast<E&&>(e));
-    target = i ? &i->ex_ : 0;
-    impl_ = i;
-  }
-
-  shared_target_executor(const shared_target_executor& other) noexcept
-    : impl_(other.impl_)
-  {
-    if (impl_)
-      asio::detail::ref_count_up(impl_->ref_count_);
-  }
-
-  shared_target_executor(shared_target_executor&& other) noexcept
-    : impl_(other.impl_)
-  {
-    other.impl_ = 0;
-  }
-
-  ~shared_target_executor()
-  {
-    if (impl_)
-      if (asio::detail::ref_count_down(impl_->ref_count_))
-        delete impl_;
-  }
-
-  void* get() const noexcept
-  {
-    return impl_ ? impl_->get() : 0;
-  }
-
-private:
-  shared_target_executor& operator=(
-      const shared_target_executor& other) = delete;
-
-  shared_target_executor& operator=(
-      shared_target_executor&& other) = delete;
-
-  struct impl_base
-  {
-    impl_base() : ref_count_(1) {}
-    virtual ~impl_base() {}
-    virtual void* get() = 0;
-    asio::detail::atomic_count ref_count_;
-  };
-
-  template <typename Executor>
-  struct impl : impl_base
-  {
-    impl(Executor ex) : ex_(static_cast<Executor&&>(ex)) {}
-    virtual void* get() { return &ex_; }
-    Executor ex_;
-  };
-
-  impl_base* impl_;
-};
-
-class any_executor_base
-{
-public:
-  any_executor_base() noexcept
-    : object_fns_(0),
-      target_(0),
-      target_fns_(0)
-  {
-  }
-
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_executor_base(Executor ex, false_type)
-    : target_fns_(target_fns_table<Executor>(
-          any_executor_base::query_blocking(ex,
-            can_query<const Executor&, const execution::blocking_t&>())
-          == execution::blocking.always))
-  {
-    any_executor_base::construct_object(ex,
-        integral_constant<bool,
-          sizeof(Executor) <= sizeof(object_type)
-            && alignment_of<Executor>::value <= alignment_of<object_type>::value
-        >());
-  }
-
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_executor_base(std::nothrow_t, Executor ex, false_type) noexcept
-    : target_fns_(target_fns_table<Executor>(
-          any_executor_base::query_blocking(ex,
-            can_query<const Executor&, const execution::blocking_t&>())
-          == execution::blocking.always))
-  {
-    any_executor_base::construct_object(std::nothrow, ex,
-        integral_constant<bool,
-          sizeof(Executor) <= sizeof(object_type)
-            && alignment_of<Executor>::value <= alignment_of<object_type>::value
-        >());
-    if (target_ == 0)
-    {
-      object_fns_ = 0;
-      target_fns_ = 0;
-    }
-  }
-
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_executor_base(Executor other, true_type)
-    : object_fns_(object_fns_table<shared_target_executor>()),
-      target_fns_(other.target_fns_)
-  {
-    Executor* p = 0;
-    new (&object_) shared_target_executor(
-        static_cast<Executor&&>(other), p);
-    target_ = p->template target<void>();
-  }
-
-  template <ASIO_EXECUTION_EXECUTOR Executor>
-  any_executor_base(std::nothrow_t,
-      Executor other, true_type) noexcept
-    : object_fns_(object_fns_table<shared_target_executor>()),
-      target_fns_(other.target_fns_)
-  {
-    Executor* p = 0;
-    new (&object_) shared_target_executor(
-        std::nothrow, static_cast<Executor&&>(other), p);
-    if (p)
-      target_ = p->template target<void>();
-    else
-    {
-      target_ = 0;
-      object_fns_ = 0;
-      target_fns_ = 0;
-    }
-  }
-
-  any_executor_base(const any_executor_base& other) noexcept
-  {
-    if (!!other)
-    {
-      object_fns_ = other.object_fns_;
-      target_fns_ = other.target_fns_;
-      object_fns_->copy(*this, other);
-    }
-    else
-    {
-      object_fns_ = 0;
-      target_ = 0;
-      target_fns_ = 0;
-    }
-  }
-
-  ~any_executor_base() noexcept
-  {
-    if (!!*this)
-      object_fns_->destroy(*this);
-  }
-
-  any_executor_base& operator=(
-      const any_executor_base& other) noexcept
-  {
-    if (this != &other)
-    {
-      if (!!*this)
-        object_fns_->destroy(*this);
-      if (!!other)
-      {
-        object_fns_ = other.object_fns_;
-        target_fns_ = other.target_fns_;
-        object_fns_->copy(*this, other);
-      }
-      else
-      {
-        object_fns_ = 0;
-        target_ = 0;
-        target_fns_ = 0;
-      }
-    }
-    return *this;
-  }
-
-  any_executor_base& operator=(nullptr_t) noexcept
-  {
-    if (target_)
-      object_fns_->destroy(*this);
-    target_ = 0;
-    object_fns_ = 0;
-    target_fns_ = 0;
-    return *this;
-  }
-
-  any_executor_base(any_executor_base&& other) noexcept
-  {
-    if (other.target_)
-    {
-      object_fns_ = other.object_fns_;
-      target_fns_ = other.target_fns_;
-      other.object_fns_ = 0;
-      other.target_fns_ = 0;
-      object_fns_->move(*this, other);
-      other.target_ = 0;
-    }
-    else
-    {
-      object_fns_ = 0;
-      target_ = 0;
-      target_fns_ = 0;
-    }
-  }
-
-  any_executor_base& operator=(
-      any_executor_base&& other) noexcept
-  {
-    if (this != &other)
-    {
-      if (!!*this)
-        object_fns_->destroy(*this);
-      if (!!other)
-      {
-        object_fns_ = other.object_fns_;
-        target_fns_ = other.target_fns_;
-        other.object_fns_ = 0;
-        other.target_fns_ = 0;
-        object_fns_->move(*this, other);
-        other.target_ = 0;
-      }
-      else
-      {
-        object_fns_ = 0;
-        target_ = 0;
-        target_fns_ = 0;
-      }
-    }
-    return *this;
-  }
-
-  void swap(any_executor_base& other) noexcept
-  {
-    if (this != &other)
-    {
-      any_executor_base tmp(static_cast<any_executor_base&&>(other));
-      other = static_cast<any_executor_base&&>(*this);
-      *this = static_cast<any_executor_base&&>(tmp);
-    }
-  }
-
-  template <typename F>
-  void execute(F&& f) const
-  {
-    if (target_)
-    {
-      if (target_fns_->blocking_execute != 0)
-      {
-        asio::detail::non_const_lvalue<F> f2(f);
-        target_fns_->blocking_execute(*this, function_view(f2.value));
-      }
-      else
-      {
-        target_fns_->execute(*this,
-            function(static_cast<F&&>(f), std::allocator<void>()));
-      }
-    }
-    else
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  template <typename Executor>
-  Executor* target()
-  {
-    return target_ && (is_same<Executor, void>::value
-        || target_fns_->target_type() == target_type_ex<Executor>())
-      ? static_cast<Executor*>(target_) : 0;
-  }
-
-  template <typename Executor>
-  const Executor* target() const
-  {
-    return target_ && (is_same<Executor, void>::value
-        || target_fns_->target_type() == target_type_ex<Executor>())
-      ? static_cast<const Executor*>(target_) : 0;
-  }
-
-#if !defined(ASIO_NO_TYPEID)
-  const std::type_info& target_type() const
-  {
-    return target_ ? target_fns_->target_type() : typeid(void);
-  }
-#else // !defined(ASIO_NO_TYPEID)
-  const void* target_type() const
-  {
-    return target_ ? target_fns_->target_type() : 0;
-  }
-#endif // !defined(ASIO_NO_TYPEID)
-
-  struct unspecified_bool_type_t {};
-  typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
-  static void unspecified_bool_true(unspecified_bool_type_t) {}
-
-  operator unspecified_bool_type() const noexcept
-  {
-    return target_ ? &any_executor_base::unspecified_bool_true : 0;
-  }
-
-  bool operator!() const noexcept
-  {
-    return target_ == 0;
-  }
-
-protected:
-  bool equality_helper(const any_executor_base& other) const noexcept
-  {
-    if (target_ == other.target_)
-      return true;
-    if (target_ && !other.target_)
-      return false;
-    if (!target_ && other.target_)
-      return false;
-    if (target_fns_ != other.target_fns_)
-      return false;
-    return target_fns_->equal(*this, other);
-  }
-
-  template <typename Ex>
-  Ex& object()
-  {
-    return *static_cast<Ex*>(static_cast<void*>(&object_));
-  }
-
-  template <typename Ex>
-  const Ex& object() const
-  {
-    return *static_cast<const Ex*>(static_cast<const void*>(&object_));
-  }
-
-  struct object_fns
-  {
-    void (*destroy)(any_executor_base&);
-    void (*copy)(any_executor_base&, const any_executor_base&);
-    void (*move)(any_executor_base&, any_executor_base&);
-    const void* (*target)(const any_executor_base&);
-  };
-
-  static void destroy_shared(any_executor_base& ex)
-  {
-    typedef shared_target_executor type;
-    ex.object<type>().~type();
-  }
-
-  static void copy_shared(any_executor_base& ex1, const any_executor_base& ex2)
-  {
-    typedef shared_target_executor type;
-    new (&ex1.object_) type(ex2.object<type>());
-    ex1.target_ = ex2.target_;
-  }
-
-  static void move_shared(any_executor_base& ex1, any_executor_base& ex2)
-  {
-    typedef shared_target_executor type;
-    new (&ex1.object_) type(static_cast<type&&>(ex2.object<type>()));
-    ex1.target_ = ex2.target_;
-    ex2.object<type>().~type();
-  }
-
-  static const void* target_shared(const any_executor_base& ex)
-  {
-    typedef shared_target_executor type;
-    return ex.object<type>().get();
-  }
-
-  template <typename Obj>
-  static const object_fns* object_fns_table(
-      enable_if_t<
-        is_same<Obj, shared_target_executor>::value
-      >* = 0)
-  {
-    static const object_fns fns =
-    {
-      &any_executor_base::destroy_shared,
-      &any_executor_base::copy_shared,
-      &any_executor_base::move_shared,
-      &any_executor_base::target_shared
-    };
-    return &fns;
-  }
-
-  template <typename Obj>
-  static void destroy_object(any_executor_base& ex)
-  {
-    ex.object<Obj>().~Obj();
-  }
-
-  template <typename Obj>
-  static void copy_object(any_executor_base& ex1, const any_executor_base& ex2)
-  {
-    new (&ex1.object_) Obj(ex2.object<Obj>());
-    ex1.target_ = &ex1.object<Obj>();
-  }
-
-  template <typename Obj>
-  static void move_object(any_executor_base& ex1, any_executor_base& ex2)
-  {
-    new (&ex1.object_) Obj(static_cast<Obj&&>(ex2.object<Obj>()));
-    ex1.target_ = &ex1.object<Obj>();
-    ex2.object<Obj>().~Obj();
-  }
-
-  template <typename Obj>
-  static const void* target_object(const any_executor_base& ex)
-  {
-    return &ex.object<Obj>();
-  }
-
-  template <typename Obj>
-  static const object_fns* object_fns_table(
-      enable_if_t<
-        !is_same<Obj, void>::value
-          && !is_same<Obj, shared_target_executor>::value
-      >* = 0)
-  {
-    static const object_fns fns =
-    {
-      &any_executor_base::destroy_object<Obj>,
-      &any_executor_base::copy_object<Obj>,
-      &any_executor_base::move_object<Obj>,
-      &any_executor_base::target_object<Obj>
-    };
-    return &fns;
-  }
-
-  typedef asio::detail::executor_function function;
-  typedef asio::detail::executor_function_view function_view;
-
-  struct target_fns
-  {
-#if !defined(ASIO_NO_TYPEID)
-    const std::type_info& (*target_type)();
-#else // !defined(ASIO_NO_TYPEID)
-    const void* (*target_type)();
-#endif // !defined(ASIO_NO_TYPEID)
-    bool (*equal)(const any_executor_base&, const any_executor_base&);
-    void (*execute)(const any_executor_base&, function&&);
-    void (*blocking_execute)(const any_executor_base&, function_view);
-  };
-
-#if !defined(ASIO_NO_TYPEID)
-  template <typename Ex>
-  static const std::type_info& target_type_ex()
-  {
-    return typeid(Ex);
-  }
-#else // !defined(ASIO_NO_TYPEID)
-  template <typename Ex>
-  static const void* target_type_ex()
-  {
-    static int unique_id;
-    return &unique_id;
-  }
-#endif // !defined(ASIO_NO_TYPEID)
-
-  template <typename Ex>
-  static bool equal_ex(const any_executor_base& ex1,
-      const any_executor_base& ex2)
-  {
-    const Ex* p1 = ex1.target<Ex>();
-    const Ex* p2 = ex2.target<Ex>();
-    ASIO_ASSUME(p1 != 0 && p2 != 0);
-    return *p1 == *p2;
-  }
-
-  template <typename Ex>
-  static void execute_ex(const any_executor_base& ex, function&& f)
-  {
-    const Ex* p = ex.target<Ex>();
-    ASIO_ASSUME(p != 0);
-    p->execute(static_cast<function&&>(f));
-  }
-
-  template <typename Ex>
-  static void blocking_execute_ex(const any_executor_base& ex, function_view f)
-  {
-    const Ex* p = ex.target<Ex>();
-    ASIO_ASSUME(p != 0);
-    p->execute(f);
-  }
-
-  template <typename Ex>
-  static const target_fns* target_fns_table(bool is_always_blocking,
-      enable_if_t<
-        !is_same<Ex, void>::value
-      >* = 0)
-  {
-    static const target_fns fns_with_execute =
-    {
-      &any_executor_base::target_type_ex<Ex>,
-      &any_executor_base::equal_ex<Ex>,
-      &any_executor_base::execute_ex<Ex>,
-      0
-    };
-
-    static const target_fns fns_with_blocking_execute =
-    {
-      &any_executor_base::target_type_ex<Ex>,
-      &any_executor_base::equal_ex<Ex>,
-      0,
-      &any_executor_base::blocking_execute_ex<Ex>
-    };
-
-    return is_always_blocking ? &fns_with_blocking_execute : &fns_with_execute;
-  }
-
-#if defined(ASIO_MSVC)
-# pragma warning (push)
-# pragma warning (disable:4702)
-#endif // defined(ASIO_MSVC)
-
-  static void query_fn_void(void*, const void*, const void*)
-  {
-    bad_executor ex;
-    asio::detail::throw_exception(ex);
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void*, const void* ex, const void* prop,
-      enable_if_t<
-        asio::can_query<const Ex&, const Prop&>::value
-          && is_same<typename Prop::polymorphic_query_result_type, void>::value
-      >*)
-  {
-    asio::query(*static_cast<const Ex*>(ex),
-        *static_cast<const Prop*>(prop));
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void*, const void*, const void*,
-      enable_if_t<
-        !asio::can_query<const Ex&, const Prop&>::value
-          && is_same<typename Prop::polymorphic_query_result_type, void>::value
-      >*)
-  {
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      enable_if_t<
-        asio::can_query<const Ex&, const Prop&>::value
-          && !is_same<typename Prop::polymorphic_query_result_type, void>::value
-          && is_reference<typename Prop::polymorphic_query_result_type>::value
-      >*)
-  {
-    *static_cast<remove_reference_t<
-      typename Prop::polymorphic_query_result_type>**>(result)
-        = &static_cast<typename Prop::polymorphic_query_result_type>(
-            asio::query(*static_cast<const Ex*>(ex),
-              *static_cast<const Prop*>(prop)));
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void*, const void*, const void*,
-      enable_if_t<
-        !asio::can_query<const Ex&, const Prop&>::value
-          && !is_same<typename Prop::polymorphic_query_result_type, void>::value
-          && is_reference<typename Prop::polymorphic_query_result_type>::value
-      >*)
-  {
-    std::terminate(); // Combination should not be possible.
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      enable_if_t<
-        asio::can_query<const Ex&, const Prop&>::value
-          && !is_same<typename Prop::polymorphic_query_result_type, void>::value
-          && is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >*)
-  {
-    *static_cast<typename Prop::polymorphic_query_result_type*>(result)
-      = static_cast<typename Prop::polymorphic_query_result_type>(
-          asio::query(*static_cast<const Ex*>(ex),
-            *static_cast<const Prop*>(prop)));
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void* result, const void*, const void*,
-      enable_if_t<
-        !asio::can_query<const Ex&, const Prop&>::value
-          && !is_same<typename Prop::polymorphic_query_result_type, void>::value
-          && is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >*)
-  {
-    *static_cast<typename Prop::polymorphic_query_result_type*>(result)
-      = typename Prop::polymorphic_query_result_type();
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void* result, const void* ex, const void* prop,
-      enable_if_t<
-        asio::can_query<const Ex&, const Prop&>::value
-          && !is_same<typename Prop::polymorphic_query_result_type, void>::value
-          && !is_reference<typename Prop::polymorphic_query_result_type>::value
-          && !is_scalar<typename Prop::polymorphic_query_result_type>::value
-      >*)
-  {
-    *static_cast<typename Prop::polymorphic_query_result_type**>(result)
-      = new typename Prop::polymorphic_query_result_type(
-          asio::query(*static_cast<const Ex*>(ex),
-            *static_cast<const Prop*>(prop)));
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_non_void(void* result, const void*, const void*, ...)
-  {
-    *static_cast<typename Prop::polymorphic_query_result_type**>(result)
-      = new typename Prop::polymorphic_query_result_type();
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_impl(void* result, const void* ex, const void* prop,
-      enable_if_t<
-        is_same<Ex, void>::value
-      >*)
-  {
-    query_fn_void(result, ex, prop);
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn_impl(void* result, const void* ex, const void* prop,
-      enable_if_t<
-        !is_same<Ex, void>::value
-      >*)
-  {
-    query_fn_non_void<Ex, Prop>(result, ex, prop, 0);
-  }
-
-  template <typename Ex, class Prop>
-  static void query_fn(void* result, const void* ex, const void* prop)
-  {
-    query_fn_impl<Ex, Prop>(result, ex, prop, 0);
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly require_fn_impl(const void*, const void*,
-      enable_if_t<
-        is_same<Ex, void>::value
-      >*)
-  {
-    bad_executor ex;
-    asio::detail::throw_exception(ex);
-    return Poly();
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly require_fn_impl(const void* ex, const void* prop,
-      enable_if_t<
-        !is_same<Ex, void>::value && Prop::is_requirable
-      >*)
-  {
-    return asio::require(*static_cast<const Ex*>(ex),
-        *static_cast<const Prop*>(prop));
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly require_fn_impl(const void*, const void*, ...)
-  {
-    return Poly();
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly require_fn(const void* ex, const void* prop)
-  {
-    return require_fn_impl<Poly, Ex, Prop>(ex, prop, 0);
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly prefer_fn_impl(const void*, const void*,
-      enable_if_t<
-        is_same<Ex, void>::value
-      >*)
-  {
-    bad_executor ex;
-    asio::detail::throw_exception(ex);
-    return Poly();
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly prefer_fn_impl(const void* ex, const void* prop,
-      enable_if_t<
-        !is_same<Ex, void>::value && Prop::is_preferable
-      >*)
-  {
-    return asio::prefer(*static_cast<const Ex*>(ex),
-        *static_cast<const Prop*>(prop));
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly prefer_fn_impl(const void*, const void*, ...)
-  {
-    return Poly();
-  }
-
-  template <typename Poly, typename Ex, class Prop>
-  static Poly prefer_fn(const void* ex, const void* prop)
-  {
-    return prefer_fn_impl<Poly, Ex, Prop>(ex, prop, 0);
-  }
-
-  template <typename Poly>
-  struct prop_fns
-  {
-    void (*query)(void*, const void*, const void*);
-    Poly (*require)(const void*, const void*);
-    Poly (*prefer)(const void*, const void*);
-  };
-
-#if defined(ASIO_MSVC)
-# pragma warning (pop)
-#endif // defined(ASIO_MSVC)
-
-private:
-  template <typename Executor>
-  static execution::blocking_t query_blocking(const Executor& ex, true_type)
-  {
-    return asio::query(ex, execution::blocking);
-  }
-
-  template <typename Executor>
-  static execution::blocking_t query_blocking(const Executor&, false_type)
-  {
-    return execution::blocking_t();
-  }
-
-  template <typename Executor>
-  void construct_object(Executor& ex, true_type)
-  {
-    object_fns_ = object_fns_table<Executor>();
-    target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
-  }
-
-  template <typename Executor>
-  void construct_object(Executor& ex, false_type)
-  {
-    object_fns_ = object_fns_table<shared_target_executor>();
-    Executor* p = 0;
-    new (&object_) shared_target_executor(
-        static_cast<Executor&&>(ex), p);
-    target_ = p;
-  }
-
-  template <typename Executor>
-  void construct_object(std::nothrow_t,
-      Executor& ex, true_type) noexcept
-  {
-    object_fns_ = object_fns_table<Executor>();
-    target_ = new (&object_) Executor(static_cast<Executor&&>(ex));
-  }
-
-  template <typename Executor>
-  void construct_object(std::nothrow_t,
-      Executor& ex, false_type) noexcept
-  {
-    object_fns_ = object_fns_table<shared_target_executor>();
-    Executor* p = 0;
-    new (&object_) shared_target_executor(
-        std::nothrow, static_cast<Executor&&>(ex), p);
-    target_ = p;
-  }
-
-/*private:*/public:
-//  template <typename...> friend class any_executor;
-
-  typedef aligned_storage<
-      sizeof(asio::detail::shared_ptr<void>) + sizeof(void*),
-      alignment_of<asio::detail::shared_ptr<void>>::value
-    >::type object_type;
-
-  object_type object_;
-  const object_fns* object_fns_;
-  void* target_;
-  const target_fns* target_fns_;
-};
-
-template <typename Derived, typename Property, typename = void>
-struct any_executor_context
-{
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Derived, typename Property>
-struct any_executor_context<Derived, Property, enable_if_t<Property::value>>
-{
-  typename Property::query_result_type context() const
-  {
-    return static_cast<const Derived*>(this)->query(typename Property::type());
-  }
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-} // namespace detail
-
-template <>
-class any_executor<> : public detail::any_executor_base
-{
-public:
-  any_executor() noexcept
-    : detail::any_executor_base()
-  {
-  }
-
-  any_executor(nullptr_t) noexcept
-    : detail::any_executor_base()
-  {
-  }
-
-  template <typename Executor>
-  any_executor(Executor ex,
-      enable_if_t<
-        conditional_t<
-          !is_same<Executor, any_executor>::value
-            && !is_base_of<detail::any_executor_base, Executor>::value,
-          is_executor<Executor>,
-          false_type
-        >::value
-      >* = 0)
-    : detail::any_executor_base(
-        static_cast<Executor&&>(ex), false_type())
-  {
-  }
-
-  template <typename Executor>
-  any_executor(std::nothrow_t, Executor ex,
-      enable_if_t<
-        conditional_t<
-          !is_same<Executor, any_executor>::value
-            && !is_base_of<detail::any_executor_base, Executor>::value,
-          is_executor<Executor>,
-          false_type
-        >::value
-      >* = 0) noexcept
-    : detail::any_executor_base(std::nothrow,
-        static_cast<Executor&&>(ex), false_type())
-  {
-  }
-
-  template <typename... OtherSupportableProperties>
-  any_executor(any_executor<OtherSupportableProperties...> other)
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-  template <typename... OtherSupportableProperties>
-  any_executor(std::nothrow_t,
-      any_executor<OtherSupportableProperties...> other) noexcept
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-  any_executor(const any_executor& other) noexcept
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-  any_executor(std::nothrow_t, const any_executor& other) noexcept
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other))
-  {
-  }
-
-  any_executor& operator=(const any_executor& other) noexcept
-  {
-    if (this != &other)
-    {
-      detail::any_executor_base::operator=(
-          static_cast<const detail::any_executor_base&>(other));
-    }
-    return *this;
-  }
-
-  any_executor& operator=(nullptr_t p) noexcept
-  {
-    detail::any_executor_base::operator=(p);
-    return *this;
-  }
-
-  any_executor(any_executor&& other) noexcept
-    : detail::any_executor_base(
-        static_cast<any_executor_base&&>(
-          static_cast<any_executor_base&>(other)))
-  {
-  }
-
-  any_executor(std::nothrow_t, any_executor&& other) noexcept
-    : detail::any_executor_base(
-        static_cast<any_executor_base&&>(
-          static_cast<any_executor_base&>(other)))
-  {
-  }
-
-  any_executor& operator=(any_executor&& other) noexcept
-  {
-    if (this != &other)
-    {
-      detail::any_executor_base::operator=(
-          static_cast<detail::any_executor_base&&>(
-            static_cast<detail::any_executor_base&>(other)));
-    }
-    return *this;
-  }
-
-  void swap(any_executor& other) noexcept
-  {
-    detail::any_executor_base::swap(
-        static_cast<detail::any_executor_base&>(other));
-  }
-
-  using detail::any_executor_base::execute;
-  using detail::any_executor_base::target;
-  using detail::any_executor_base::target_type;
-  using detail::any_executor_base::operator unspecified_bool_type;
-  using detail::any_executor_base::operator!;
-
-  bool equality_helper(const any_executor& other) const noexcept
-  {
-    return any_executor_base::equality_helper(other);
-  }
-
-  template <typename AnyExecutor1, typename AnyExecutor2>
-  friend enable_if_t<
-    is_base_of<any_executor, AnyExecutor1>::value
-      || is_base_of<any_executor, AnyExecutor2>::value,
-    bool
-  > operator==(const AnyExecutor1& a,
-      const AnyExecutor2& b) noexcept
-  {
-    return static_cast<const any_executor&>(a).equality_helper(b);
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator==(const AnyExecutor& a, nullptr_t) noexcept
-  {
-    return !a;
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator==(nullptr_t, const AnyExecutor& b) noexcept
-  {
-    return !b;
-  }
-
-  template <typename AnyExecutor1, typename AnyExecutor2>
-  friend enable_if_t<
-    is_base_of<any_executor, AnyExecutor1>::value
-      || is_base_of<any_executor, AnyExecutor2>::value,
-    bool
-  > operator!=(const AnyExecutor1& a,
-      const AnyExecutor2& b) noexcept
-  {
-    return !static_cast<const any_executor&>(a).equality_helper(b);
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator!=(const AnyExecutor& a, nullptr_t) noexcept
-  {
-    return !!a;
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator!=(nullptr_t, const AnyExecutor& b) noexcept
-  {
-    return !!b;
-  }
-};
-
-inline void swap(any_executor<>& a, any_executor<>& b) noexcept
-{
-  return a.swap(b);
-}
-
-template <typename... SupportableProperties>
-class any_executor :
-  public detail::any_executor_base,
-  public detail::any_executor_context<
-    any_executor<SupportableProperties...>,
-      typename detail::supportable_properties<
-        0, void(SupportableProperties...)>::find_context_as_property>
-{
-public:
-  any_executor() noexcept
-    : detail::any_executor_base(),
-      prop_fns_(prop_fns_table<void>())
-  {
-  }
-
-  any_executor(nullptr_t) noexcept
-    : detail::any_executor_base(),
-      prop_fns_(prop_fns_table<void>())
-  {
-  }
-
-  template <typename Executor>
-  any_executor(Executor ex,
-      enable_if_t<
-        conditional_t<
-          !is_same<Executor, any_executor>::value
-            && !is_base_of<detail::any_executor_base, Executor>::value,
-          detail::is_valid_target_executor<
-            Executor, void(SupportableProperties...)>,
-          false_type
-        >::value
-      >* = 0)
-    : detail::any_executor_base(
-        static_cast<Executor&&>(ex), false_type()),
-      prop_fns_(prop_fns_table<Executor>())
-  {
-  }
-
-  template <typename Executor>
-  any_executor(std::nothrow_t, Executor ex,
-      enable_if_t<
-        conditional_t<
-          !is_same<Executor, any_executor>::value
-            && !is_base_of<detail::any_executor_base, Executor>::value,
-          detail::is_valid_target_executor<
-            Executor, void(SupportableProperties...)>,
-          false_type
-        >::value
-      >* = 0) noexcept
-    : detail::any_executor_base(std::nothrow,
-        static_cast<Executor&&>(ex), false_type()),
-      prop_fns_(prop_fns_table<Executor>())
-  {
-    if (this->template target<void>() == 0)
-      prop_fns_ = prop_fns_table<void>();
-  }
-
-  template <typename... OtherSupportableProperties>
-  any_executor(any_executor<OtherSupportableProperties...> other,
-      enable_if_t<
-        conditional_t<
-          !is_same<
-            any_executor<OtherSupportableProperties...>,
-            any_executor
-          >::value,
-          typename detail::supportable_properties<
-            0, void(SupportableProperties...)>::template is_valid_target<
-              any_executor<OtherSupportableProperties...>>,
-          false_type
-        >::value
-      >* = 0)
-    : detail::any_executor_base(
-        static_cast<any_executor<OtherSupportableProperties...>&&>(other),
-        true_type()),
-      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
-  {
-  }
-
-  template <typename... OtherSupportableProperties>
-  any_executor(std::nothrow_t,
-      any_executor<OtherSupportableProperties...> other,
-      enable_if_t<
-        conditional_t<
-          !is_same<
-            any_executor<OtherSupportableProperties...>,
-            any_executor
-          >::value,
-          typename detail::supportable_properties<
-            0, void(SupportableProperties...)>::template is_valid_target<
-              any_executor<OtherSupportableProperties...>>,
-          false_type
-        >::value
-      >* = 0) noexcept
-    : detail::any_executor_base(std::nothrow,
-        static_cast<any_executor<OtherSupportableProperties...>&&>(other),
-        true_type()),
-      prop_fns_(prop_fns_table<any_executor<OtherSupportableProperties...>>())
-  {
-    if (this->template target<void>() == 0)
-      prop_fns_ = prop_fns_table<void>();
-  }
-
-  any_executor(const any_executor& other) noexcept
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other)),
-      prop_fns_(other.prop_fns_)
-  {
-  }
-
-  any_executor(std::nothrow_t, const any_executor& other) noexcept
-    : detail::any_executor_base(
-        static_cast<const detail::any_executor_base&>(other)),
-      prop_fns_(other.prop_fns_)
-  {
-  }
-
-  any_executor& operator=(const any_executor& other) noexcept
-  {
-    if (this != &other)
-    {
-      prop_fns_ = other.prop_fns_;
-      detail::any_executor_base::operator=(
-          static_cast<const detail::any_executor_base&>(other));
-    }
-    return *this;
-  }
-
-  any_executor& operator=(nullptr_t p) noexcept
-  {
-    prop_fns_ = prop_fns_table<void>();
-    detail::any_executor_base::operator=(p);
-    return *this;
-  }
-
-  any_executor(any_executor&& other) noexcept
-    : detail::any_executor_base(
-        static_cast<any_executor_base&&>(
-          static_cast<any_executor_base&>(other))),
-      prop_fns_(other.prop_fns_)
-  {
-    other.prop_fns_ = prop_fns_table<void>();
-  }
-
-  any_executor(std::nothrow_t, any_executor&& other) noexcept
-    : detail::any_executor_base(
-        static_cast<any_executor_base&&>(
-          static_cast<any_executor_base&>(other))),
-      prop_fns_(other.prop_fns_)
-  {
-    other.prop_fns_ = prop_fns_table<void>();
-  }
-
-  any_executor& operator=(any_executor&& other) noexcept
-  {
-    if (this != &other)
-    {
-      prop_fns_ = other.prop_fns_;
-      detail::any_executor_base::operator=(
-          static_cast<detail::any_executor_base&&>(
-            static_cast<detail::any_executor_base&>(other)));
-    }
-    return *this;
-  }
-
-  void swap(any_executor& other) noexcept
-  {
-    if (this != &other)
-    {
-      detail::any_executor_base::swap(
-          static_cast<detail::any_executor_base&>(other));
-      const prop_fns<any_executor>* tmp_prop_fns = other.prop_fns_;
-      other.prop_fns_ = prop_fns_;
-      prop_fns_ = tmp_prop_fns;
-    }
-  }
-
-  using detail::any_executor_base::execute;
-  using detail::any_executor_base::target;
-  using detail::any_executor_base::target_type;
-  using detail::any_executor_base::operator unspecified_bool_type;
-  using detail::any_executor_base::operator!;
-
-  bool equality_helper(const any_executor& other) const noexcept
-  {
-    return any_executor_base::equality_helper(other);
-  }
-
-  template <typename AnyExecutor1, typename AnyExecutor2>
-  friend enable_if_t<
-    is_base_of<any_executor, AnyExecutor1>::value
-      || is_base_of<any_executor, AnyExecutor2>::value,
-    bool
-  > operator==(const AnyExecutor1& a,
-      const AnyExecutor2& b) noexcept
-  {
-    return static_cast<const any_executor&>(a).equality_helper(b);
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator==(const AnyExecutor& a, nullptr_t) noexcept
-  {
-    return !a;
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator==(nullptr_t, const AnyExecutor& b) noexcept
-  {
-    return !b;
-  }
-
-  template <typename AnyExecutor1, typename AnyExecutor2>
-  friend enable_if_t<
-    is_base_of<any_executor, AnyExecutor1>::value
-      || is_base_of<any_executor, AnyExecutor2>::value,
-    bool
-  > operator!=(const AnyExecutor1& a,
-      const AnyExecutor2& b) noexcept
-  {
-    return !static_cast<const any_executor&>(a).equality_helper(b);
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator!=(const AnyExecutor& a, nullptr_t) noexcept
-  {
-    return !!a;
-  }
-
-  template <typename AnyExecutor>
-  friend enable_if_t<
-    is_same<AnyExecutor, any_executor>::value,
-    bool
-  > operator!=(nullptr_t, const AnyExecutor& b) noexcept
-  {
-    return !!b;
-  }
-
-  template <typename T>
-  struct find_convertible_property :
-      detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_property<T> {};
-
-  template <typename Property>
-  void query(const Property& p,
-      enable_if_t<
-        is_same<
-          typename find_convertible_property<Property>::query_result_type,
-          void
-        >::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_property<Property> found;
-    prop_fns_[found::index].query(0, object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-  }
-
-  template <typename Property>
-  typename find_convertible_property<Property>::query_result_type
-  query(const Property& p,
-      enable_if_t<
-        !is_same<
-          typename find_convertible_property<Property>::query_result_type,
-          void
-        >::value
-        &&
-        is_reference<
-          typename find_convertible_property<Property>::query_result_type
-        >::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_property<Property> found;
-    remove_reference_t<typename found::query_result_type>* result = 0;
-    prop_fns_[found::index].query(&result, object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-    return *result;
-  }
-
-  template <typename Property>
-  typename find_convertible_property<Property>::query_result_type
-  query(const Property& p,
-      enable_if_t<
-        !is_same<
-          typename find_convertible_property<Property>::query_result_type,
-          void
-        >::value
-        &&
-        is_scalar<
-          typename find_convertible_property<Property>::query_result_type
-        >::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_property<Property> found;
-    typename found::query_result_type result;
-    prop_fns_[found::index].query(&result, object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-    return result;
-  }
-
-  template <typename Property>
-  typename find_convertible_property<Property>::query_result_type
-  query(const Property& p,
-      enable_if_t<
-        !is_same<
-          typename find_convertible_property<Property>::query_result_type,
-          void
-        >::value
-        &&
-        !is_reference<
-          typename find_convertible_property<Property>::query_result_type
-        >::value
-        &&
-        !is_scalar<
-          typename find_convertible_property<Property>::query_result_type
-        >::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_property<Property> found;
-    typename found::query_result_type* result;
-    prop_fns_[found::index].query(&result, object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-    return *asio::detail::scoped_ptr<
-      typename found::query_result_type>(result);
-  }
-
-  template <typename T>
-  struct find_convertible_requirable_property :
-      detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_requirable_property<T> {};
-
-  template <typename Property>
-  any_executor require(const Property& p,
-      enable_if_t<
-        find_convertible_requirable_property<Property>::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_requirable_property<Property> found;
-    return prop_fns_[found::index].require(object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-  }
-
-  template <typename T>
-  struct find_convertible_preferable_property :
-      detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_preferable_property<T> {};
-
-  template <typename Property>
-  any_executor prefer(const Property& p,
-      enable_if_t<
-        find_convertible_preferable_property<Property>::value
-      >* = 0) const
-  {
-    if (!target_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    typedef find_convertible_preferable_property<Property> found;
-    return prop_fns_[found::index].prefer(object_fns_->target(*this),
-        &static_cast<const typename found::type&>(p));
-  }
-
-//private:
-  template <typename Ex>
-  static const prop_fns<any_executor>* prop_fns_table()
-  {
-    static const prop_fns<any_executor> fns[] =
-    {
-      {
-        &detail::any_executor_base::query_fn<
-            Ex, SupportableProperties>,
-        &detail::any_executor_base::require_fn<
-            any_executor, Ex, SupportableProperties>,
-        &detail::any_executor_base::prefer_fn<
-            any_executor, Ex, SupportableProperties>
-      }...
-    };
-    return fns;
-  }
-
-  const prop_fns<any_executor>* prop_fns_;
-};
-
-template <typename... SupportableProperties>
-inline void swap(any_executor<SupportableProperties...>& a,
-    any_executor<SupportableProperties...>& b) noexcept
-{
-  return a.swap(b);
-}
-
-} // namespace execution
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename... SupportableProperties>
-struct equality_comparable<execution::any_executor<SupportableProperties...>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F, typename... SupportableProperties>
-struct execute_member<execution::any_executor<SupportableProperties...>, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Prop, typename... SupportableProperties>
-struct query_member<
-    execution::any_executor<SupportableProperties...>, Prop,
-    enable_if_t<
-      execution::detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_property<Prop>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef typename execution::detail::supportable_properties<
-      0, void(SupportableProperties...)>::template
-        find_convertible_property<Prop>::query_result_type result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Prop, typename... SupportableProperties>
-struct require_member<
-    execution::any_executor<SupportableProperties...>, Prop,
-    enable_if_t<
-      execution::detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_requirable_property<Prop>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef execution::any_executor<SupportableProperties...> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename Prop, typename... SupportableProperties>
-struct prefer_member<
-    execution::any_executor<SupportableProperties...>, Prop,
-    enable_if_t<
-      execution::detail::supportable_properties<
-        0, void(SupportableProperties...)>::template
-          find_convertible_preferable_property<Prop>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef execution::any_executor<SupportableProperties...> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_ANY_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/bad_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/bad_executor.hpp
deleted file mode 100644
index 7919516..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/bad_executor.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// execution/bad_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_BAD_EXECUTOR_HPP
-#define ASIO_EXECUTION_BAD_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace execution {
-
-/// Exception thrown when trying to access an empty polymorphic executor.
-class bad_executor
-  : public std::exception
-{
-public:
-  /// Constructor.
-  ASIO_DECL bad_executor() noexcept;
-
-  /// Obtain message associated with exception.
-  ASIO_DECL virtual const char* what() const noexcept;
-};
-
-} // namespace execution
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/execution/impl/bad_executor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_EXECUTION_BAD_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking.hpp
deleted file mode 100644
index e120299..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking.hpp
+++ /dev/null
@@ -1,1360 +0,0 @@
-//
-// execution/blocking.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_BLOCKING_HPP
-#define ASIO_EXECUTION_BLOCKING_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "asio/traits/execute_member.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe what guarantees an executor makes about the blocking
-/// behaviour of their execution functions.
-struct blocking_t
-{
-  /// The blocking_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The top-level blocking_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The top-level blocking_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef blocking_t polymorphic_query_result_type;
-
-  /// A sub-property that indicates that invocation of an executor's execution
-  /// function may block pending completion of one or more invocations of the
-  /// submitted function object.
-  struct possibly_t
-  {
-    /// The blocking_t::possibly_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The blocking_t::possibly_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The blocking_t::possibly_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef blocking_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr possibly_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns possibly_t();
-     */
-    static constexpr blocking_t value();
-  };
-
-  /// A sub-property that indicates that invocation of an executor's execution
-  /// function shall block until completion of all invocations of the submitted
-  /// function object.
-  struct always_t
-  {
-    /// The blocking_t::always_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The blocking_t::always_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The blocking_t::always_t property can be preferred.
-    static constexpr bool is_preferable = false;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef blocking_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr always_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns always_t();
-     */
-    static constexpr blocking_t value();
-  };
-
-  /// A sub-property that indicates that invocation of an executor's execution
-  /// function shall not block pending completion of the invocations of the
-  /// submitted function object.
-  struct never_t
-  {
-    /// The blocking_t::never_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The blocking_t::never_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The blocking_t::never_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef blocking_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr never_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns never_t();
-     */
-    static constexpr blocking_t value();
-  };
-
-  /// A special value used for accessing the blocking_t::possibly_t property.
-  static constexpr possibly_t possibly;
-
-  /// A special value used for accessing the blocking_t::always_t property.
-  static constexpr always_t always;
-
-  /// A special value used for accessing the blocking_t::never_t property.
-  static constexpr never_t never;
-
-  /// Default constructor.
-  constexpr blocking_t();
-
-  /// Construct from a sub-property value.
-  constexpr blocking_t(possibly_t);
-
-  /// Construct from a sub-property value.
-  constexpr blocking_t(always_t);
-
-  /// Construct from a sub-property value.
-  constexpr blocking_t(never_t);
-
-  /// Compare property values for equality.
-  friend constexpr bool operator==(
-      const blocking_t& a, const blocking_t& b) noexcept;
-
-  /// Compare property values for inequality.
-  friend constexpr bool operator!=(
-      const blocking_t& a, const blocking_t& b) noexcept;
-};
-
-/// A special value used for accessing the blocking_t property.
-constexpr blocking_t blocking;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-namespace blocking {
-
-template <int I> struct possibly_t;
-template <int I> struct always_t;
-template <int I> struct never_t;
-
-} // namespace blocking
-namespace blocking_adaptation {
-
-template <int I> struct allowed_t;
-
-template <typename Executor, typename Function>
-void blocking_execute(
-    Executor&& ex,
-    Function&& func);
-
-} // namespace blocking_adaptation
-
-template <int I = 0>
-struct blocking_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef blocking_t polymorphic_query_result_type;
-
-  typedef detail::blocking::possibly_t<I> possibly_t;
-  typedef detail::blocking::always_t<I> always_t;
-  typedef detail::blocking::never_t<I> never_t;
-
-  constexpr blocking_t()
-    : value_(-1)
-  {
-  }
-
-  constexpr blocking_t(possibly_t)
-    : value_(0)
-  {
-  }
-
-  constexpr blocking_t(always_t)
-    : value_(1)
-  {
-  }
-
-  constexpr blocking_t(never_t)
-    : value_(2)
-  {
-  }
-
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p) const
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<typename proxy<T>::type, blocking_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, blocking_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, possibly_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, possibly_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, possibly_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, always_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, possibly_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, always_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, always_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, never_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, possibly_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, always_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, never_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, never_t>::value();
-  }
-
-  template <typename E, typename T = decltype(blocking_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = blocking_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  friend constexpr bool operator==(
-      const blocking_t& a, const blocking_t& b)
-  {
-    return a.value_ == b.value_;
-  }
-
-  friend constexpr bool operator!=(
-      const blocking_t& a, const blocking_t& b)
-  {
-    return a.value_ != b.value_;
-  }
-
-  struct convertible_from_blocking_t
-  {
-    constexpr convertible_from_blocking_t(blocking_t) {}
-  };
-
-  template <typename Executor>
-  friend constexpr blocking_t query(
-      const Executor& ex, convertible_from_blocking_t,
-      enable_if_t<
-        can_query<const Executor&, possibly_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, blocking_t<>::possibly_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, possibly_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, possibly_t());
-  }
-
-  template <typename Executor>
-  friend constexpr blocking_t query(
-      const Executor& ex, convertible_from_blocking_t,
-      enable_if_t<
-        !can_query<const Executor&, possibly_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, always_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, blocking_t<>::always_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, always_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, always_t());
-  }
-
-  template <typename Executor>
-  friend constexpr blocking_t query(
-      const Executor& ex, convertible_from_blocking_t,
-      enable_if_t<
-        !can_query<const Executor&, possibly_t>::value
-      >* = 0,
-      enable_if_t<
-        !can_query<const Executor&, always_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, never_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, blocking_t<>::never_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, never_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, never_t());
-  }
-
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(possibly_t, possibly);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(always_t, always);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(never_t, never);
-
-private:
-  int value_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T blocking_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-const typename blocking_t<I>::possibly_t blocking_t<I>::possibly;
-
-template <int I>
-const typename blocking_t<I>::always_t blocking_t<I>::always;
-
-template <int I>
-const typename blocking_t<I>::never_t blocking_t<I>::never;
-
-namespace blocking {
-
-template <int I = 0>
-struct possibly_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef blocking_t<I> polymorphic_query_result_type;
-
-  constexpr possibly_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename blocking_t<I>::template proxy<T>::type, possibly_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename blocking_t<I>::template static_proxy<T>::type, possibly_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr possibly_t static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::query_free<T, possibly_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !can_query<T, always_t<I>>::value
-      >* = 0,
-      enable_if_t<
-        !can_query<T, never_t<I>>::value
-      >* = 0) noexcept
-  {
-    return possibly_t();
-  }
-
-  template <typename E, typename T = decltype(possibly_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = possibly_t::static_query<E>();
-#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr blocking_t<I> value()
-  {
-    return possibly_t();
-  }
-
-  friend constexpr bool operator==(
-      const possibly_t&, const possibly_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(
-      const possibly_t&, const possibly_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(
-      const possibly_t&, const always_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(
-      const possibly_t&, const always_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(
-      const possibly_t&, const never_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(
-      const possibly_t&, const never_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T possibly_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename Executor>
-class adapter
-{
-public:
-  adapter(int, const Executor& e) noexcept
-    : executor_(e)
-  {
-  }
-
-  adapter(const adapter& other) noexcept
-    : executor_(other.executor_)
-  {
-  }
-
-  adapter(adapter&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_))
-  {
-  }
-
-  template <int I>
-  static constexpr always_t<I> query(blocking_t<I>) noexcept
-  {
-    return always_t<I>();
-  }
-
-  template <int I>
-  static constexpr always_t<I> query(possibly_t<I>) noexcept
-  {
-    return always_t<I>();
-  }
-
-  template <int I>
-  static constexpr always_t<I> query(always_t<I>) noexcept
-  {
-    return always_t<I>();
-  }
-
-  template <int I>
-  static constexpr always_t<I> query(never_t<I>) noexcept
-  {
-    return always_t<I>();
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_query<const Executor&, Property>::value,
-    query_result_t<const Executor&, Property>
-  > query(const Property& p) const
-    noexcept(is_nothrow_query<const Executor&, Property>::value)
-  {
-    return asio::query(executor_, p);
-  }
-
-  template <int I>
-  enable_if_t<
-    can_require<const Executor&, possibly_t<I>>::value,
-    require_result_t<const Executor&, possibly_t<I>>
-  > require(possibly_t<I>) const noexcept
-  {
-    return asio::require(executor_, possibly_t<I>());
-  }
-
-  template <int I>
-  enable_if_t<
-    can_require<const Executor&, never_t<I>>::value,
-    require_result_t<const Executor&, never_t<I>>
-  > require(never_t<I>) const noexcept
-  {
-    return asio::require(executor_, never_t<I>());
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_require<const Executor&, Property>::value,
-    adapter<decay_t<require_result_t<const Executor&, Property>>>
-  > require(const Property& p) const
-    noexcept(is_nothrow_require<const Executor&, Property>::value)
-  {
-    return adapter<decay_t<require_result_t<const Executor&, Property>>>(
-        0, asio::require(executor_, p));
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_prefer<const Executor&, Property>::value,
-    adapter<decay_t<prefer_result_t<const Executor&, Property>>>
-  > prefer(const Property& p) const
-    noexcept(is_nothrow_prefer<const Executor&, Property>::value)
-  {
-    return adapter<decay_t<prefer_result_t<const Executor&, Property>>>(
-        0, asio::prefer(executor_, p));
-  }
-
-  template <typename Function>
-  enable_if_t<
-    traits::execute_member<const Executor&, Function>::is_valid
-  > execute(Function&& f) const
-  {
-    blocking_adaptation::blocking_execute(
-        executor_, static_cast<Function&&>(f));
-  }
-
-  friend bool operator==(const adapter& a, const adapter& b) noexcept
-  {
-    return a.executor_ == b.executor_;
-  }
-
-  friend bool operator!=(const adapter& a, const adapter& b) noexcept
-  {
-    return a.executor_ != b.executor_;
-  }
-
-private:
-  Executor executor_;
-};
-
-template <int I = 0>
-struct always_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = false;
-  typedef blocking_t<I> polymorphic_query_result_type;
-
-  constexpr always_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename blocking_t<I>::template proxy<T>::type, always_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename blocking_t<I>::template static_proxy<T>::type, always_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(always_t::static_query<E>())>
-  static constexpr const T static_query_v = always_t::static_query<E>();
-#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr blocking_t<I> value()
-  {
-    return always_t();
-  }
-
-  friend constexpr bool operator==(
-      const always_t&, const always_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(
-      const always_t&, const always_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(
-      const always_t&, const possibly_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(
-      const always_t&, const possibly_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(
-      const always_t&, const never_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(
-      const always_t&, const never_t<I>&)
-  {
-    return true;
-  }
-
-  template <typename Executor>
-  friend adapter<Executor> require(
-      const Executor& e, const always_t&,
-      enable_if_t<
-        is_executor<Executor>::value
-      >* = 0,
-      enable_if_t<
-        traits::static_require<
-          const Executor&,
-          blocking_adaptation::allowed_t<0>
-        >::is_valid
-      >* = 0)
-  {
-    return adapter<Executor>(0, e);
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T always_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-struct never_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef blocking_t<I> polymorphic_query_result_type;
-
-  constexpr never_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename blocking_t<I>::template proxy<T>::type, never_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename blocking_t<I>::template static_proxy<T>::type, never_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(never_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = never_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr blocking_t<I> value()
-  {
-    return never_t();
-  }
-
-  friend constexpr bool operator==(const never_t&, const never_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const never_t&, const never_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const never_t&, const possibly_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const never_t&, const possibly_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(const never_t&, const always_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const never_t&, const always_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T never_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace blocking
-} // namespace detail
-
-typedef detail::blocking_t<> blocking_t;
-
-constexpr blocking_t blocking;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_t::possibly_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_t::always_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_t::never_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T>
-struct query_free_default<T, execution::blocking_t,
-  enable_if_t<
-    can_query<T, execution::blocking_t::possibly_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::blocking_t::possibly_t>::value;
-
-  typedef execution::blocking_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::blocking_t,
-  enable_if_t<
-    !can_query<T, execution::blocking_t::possibly_t>::value
-      && can_query<T, execution::blocking_t::always_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::blocking_t::always_t>::value;
-
-  typedef execution::blocking_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::blocking_t,
-  enable_if_t<
-    !can_query<T, execution::blocking_t::possibly_t>::value
-      && !can_query<T, execution::blocking_t::always_t>::value
-      && can_query<T, execution::blocking_t::never_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::blocking_t::never_t>::value;
-
-  typedef execution::blocking_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::blocking_t,
-  enable_if_t<
-    execution::detail::blocking_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::blocking_t::query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t,
-  enable_if_t<
-    !execution::detail::blocking_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_t<0>::
-        query_member<T>::is_valid
-      && traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::blocking_t::possibly_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::blocking_t::possibly_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t,
-  enable_if_t<
-    !execution::detail::blocking_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
-      && traits::static_query<T, execution::blocking_t::always_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::blocking_t::always_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::blocking_t::always_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t,
-  enable_if_t<
-    !execution::detail::blocking_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
-      && !traits::static_query<T, execution::blocking_t::always_t>::is_valid
-      && traits::static_query<T, execution::blocking_t::never_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::blocking_t::never_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::blocking_t::never_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t::possibly_t,
-  enable_if_t<
-    execution::detail::blocking::possibly_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking::possibly_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking::possibly_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t::possibly_t,
-  enable_if_t<
-    !execution::detail::blocking::possibly_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking::possibly_t<0>::
-        query_member<T>::is_valid
-      && !traits::query_free<T, execution::blocking_t::possibly_t>::is_valid
-      && !can_query<T, execution::blocking_t::always_t>::value
-      && !can_query<T, execution::blocking_t::never_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::blocking_t::possibly_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t::always_t,
-  enable_if_t<
-    execution::detail::blocking::always_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking::always_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking::always_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_t::never_t,
-  enable_if_t<
-    execution::detail::blocking::never_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking::never_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking::never_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename T>
-struct require_free_default<T, execution::blocking_t::always_t,
-  enable_if_t<
-    is_same<T, decay_t<T>>::value
-      && execution::is_executor<T>::value
-      && traits::static_require<
-          const T&,
-          execution::detail::blocking_adaptation::allowed_t<0>
-        >::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef execution::detail::blocking::adapter<T> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Executor>
-struct equality_comparable<
-  execution::detail::blocking::adapter<Executor>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Executor, typename Function>
-struct execute_member<
-  execution::detail::blocking::adapter<Executor>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_t::always_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking::always_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_t::always_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking::possibly_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_t::always_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking::never_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_t::always_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct query_member<
-  execution::detail::blocking::adapter<Executor>, Property,
-  enable_if_t<
-    can_query<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<Executor, Property>::value;
-  typedef query_result_t<Executor, Property> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Executor, int I>
-struct require_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking::possibly_t<I>,
-  enable_if_t<
-    can_require<
-      const Executor&,
-      execution::detail::blocking::possibly_t<I>
-    >::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_require<const Executor&,
-      execution::detail::blocking::possibly_t<I>>::value;
-  typedef require_result_t<const Executor&,
-    execution::detail::blocking::possibly_t<I>> result_type;
-};
-
-template <typename Executor, int I>
-struct require_member<
-  execution::detail::blocking::adapter<Executor>,
-  execution::detail::blocking::never_t<I>,
-  enable_if_t<
-    can_require<
-      const Executor&,
-      execution::detail::blocking::never_t<I>
-    >::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_require<const Executor&,
-      execution::detail::blocking::never_t<I>>::value;
-  typedef require_result_t<const Executor&,
-    execution::detail::blocking::never_t<I>> result_type;
-};
-
-template <typename Executor, typename Property>
-struct require_member<
-  execution::detail::blocking::adapter<Executor>, Property,
-  enable_if_t<
-    can_require<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_require<Executor, Property>::value;
-  typedef execution::detail::blocking::adapter<
-    decay_t<require_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct prefer_member<
-  execution::detail::blocking::adapter<Executor>, Property,
-  enable_if_t<
-    can_prefer<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_prefer<Executor, Property>::value;
-  typedef execution::detail::blocking::adapter<
-    decay_t<prefer_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_BLOCKING_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking_adaptation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking_adaptation.hpp
deleted file mode 100644
index a2769b2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/blocking_adaptation.hpp
+++ /dev/null
@@ -1,1080 +0,0 @@
-//
-// execution/blocking_adaptation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
-#define ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "asio/traits/prefer_member.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/require_member.hpp"
-#include "asio/traits/static_query.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe whether automatic adaptation of an executor is
-/// allowed in order to apply the blocking_adaptation_t::allowed_t property.
-struct blocking_adaptation_t
-{
-  /// The blocking_adaptation_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The top-level blocking_adaptation_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The top-level blocking_adaptation_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef blocking_adaptation_t polymorphic_query_result_type;
-
-  /// A sub-property that indicates that automatic adaptation is not allowed.
-  struct disallowed_t
-  {
-    /// The blocking_adaptation_t::disallowed_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The blocking_adaptation_t::disallowed_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The blocking_adaptation_t::disallowed_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef blocking_adaptation_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr disallowed_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns disallowed_t();
-     */
-    static constexpr blocking_adaptation_t value();
-  };
-
-  /// A sub-property that indicates that automatic adaptation is allowed.
-  struct allowed_t
-  {
-    /// The blocking_adaptation_t::allowed_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The blocking_adaptation_t::allowed_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The blocking_adaptation_t::allowed_t property can be preferred.
-    static constexpr bool is_preferable = false;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef blocking_adaptation_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr allowed_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns allowed_t();
-     */
-    static constexpr blocking_adaptation_t value();
-  };
-
-  /// A special value used for accessing the blocking_adaptation_t::disallowed_t
-  /// property.
-  static constexpr disallowed_t disallowed;
-
-  /// A special value used for accessing the blocking_adaptation_t::allowed_t
-  /// property.
-  static constexpr allowed_t allowed;
-
-  /// Default constructor.
-  constexpr blocking_adaptation_t();
-
-  /// Construct from a sub-property value.
-  constexpr blocking_adaptation_t(disallowed_t);
-
-  /// Construct from a sub-property value.
-  constexpr blocking_adaptation_t(allowed_t);
-
-  /// Compare property values for equality.
-  friend constexpr bool operator==(
-      const blocking_adaptation_t& a, const blocking_adaptation_t& b) noexcept;
-
-  /// Compare property values for inequality.
-  friend constexpr bool operator!=(
-      const blocking_adaptation_t& a, const blocking_adaptation_t& b) noexcept;
-};
-
-/// A special value used for accessing the blocking_adaptation_t property.
-constexpr blocking_adaptation_t blocking_adaptation;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-namespace blocking_adaptation {
-
-template <int I> struct disallowed_t;
-template <int I> struct allowed_t;
-
-} // namespace blocking_adaptation
-
-template <int I = 0>
-struct blocking_adaptation_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef blocking_adaptation_t polymorphic_query_result_type;
-
-  typedef detail::blocking_adaptation::disallowed_t<I> disallowed_t;
-  typedef detail::blocking_adaptation::allowed_t<I> allowed_t;
-
-  constexpr blocking_adaptation_t()
-    : value_(-1)
-  {
-  }
-
-  constexpr blocking_adaptation_t(disallowed_t)
-    : value_(0)
-  {
-  }
-
-  constexpr blocking_adaptation_t(allowed_t)
-    : value_(1)
-  {
-  }
-
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p) const
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<typename proxy<T>::type, blocking_adaptation_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, blocking_adaptation_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, disallowed_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, disallowed_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, disallowed_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, allowed_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, disallowed_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, allowed_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, allowed_t>::value();
-  }
-
-  template <typename E,
-      typename T = decltype(blocking_adaptation_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = blocking_adaptation_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  friend constexpr bool operator==(
-      const blocking_adaptation_t& a, const blocking_adaptation_t& b)
-  {
-    return a.value_ == b.value_;
-  }
-
-  friend constexpr bool operator!=(
-      const blocking_adaptation_t& a, const blocking_adaptation_t& b)
-  {
-    return a.value_ != b.value_;
-  }
-
-  struct convertible_from_blocking_adaptation_t
-  {
-    constexpr convertible_from_blocking_adaptation_t(
-        blocking_adaptation_t)
-    {
-    }
-  };
-
-  template <typename Executor>
-  friend constexpr blocking_adaptation_t query(
-      const Executor& ex, convertible_from_blocking_adaptation_t,
-      enable_if_t<
-        can_query<const Executor&, disallowed_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&,
-        blocking_adaptation_t<>::disallowed_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, disallowed_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, disallowed_t());
-  }
-
-  template <typename Executor>
-  friend constexpr blocking_adaptation_t query(
-      const Executor& ex, convertible_from_blocking_adaptation_t,
-      enable_if_t<
-        !can_query<const Executor&, disallowed_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, allowed_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&,
-        blocking_adaptation_t<>::allowed_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, allowed_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, allowed_t());
-  }
-
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(disallowed_t, disallowed);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(allowed_t, allowed);
-
-private:
-  int value_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T blocking_adaptation_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-const typename blocking_adaptation_t<I>::disallowed_t
-blocking_adaptation_t<I>::disallowed;
-
-template <int I>
-const typename blocking_adaptation_t<I>::allowed_t
-blocking_adaptation_t<I>::allowed;
-
-namespace blocking_adaptation {
-
-template <int I = 0>
-struct disallowed_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef blocking_adaptation_t<I> polymorphic_query_result_type;
-
-  constexpr disallowed_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename blocking_adaptation_t<I>::template proxy<T>::type,
-        disallowed_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename blocking_adaptation_t<I>::template static_proxy<T>::type,
-        disallowed_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr disallowed_t static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::query_free<T, disallowed_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !can_query<T, allowed_t<I>>::value
-      >* = 0) noexcept
-  {
-    return disallowed_t();
-  }
-
-  template <typename E, typename T = decltype(disallowed_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = disallowed_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr blocking_adaptation_t<I> value()
-  {
-    return disallowed_t();
-  }
-
-  friend constexpr bool operator==(const disallowed_t&, const disallowed_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const disallowed_t&, const disallowed_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const disallowed_t&, const allowed_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const disallowed_t&, const allowed_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T disallowed_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename Executor>
-class adapter
-{
-public:
-  adapter(int, const Executor& e) noexcept
-    : executor_(e)
-  {
-  }
-
-  adapter(const adapter& other) noexcept
-    : executor_(other.executor_)
-  {
-  }
-
-  adapter(adapter&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_))
-  {
-  }
-
-  template <int I>
-  static constexpr allowed_t<I> query(blocking_adaptation_t<I>) noexcept
-  {
-    return allowed_t<I>();
-  }
-
-  template <int I>
-  static constexpr allowed_t<I> query(allowed_t<I>) noexcept
-  {
-    return allowed_t<I>();
-  }
-
-  template <int I>
-  static constexpr allowed_t<I> query(disallowed_t<I>) noexcept
-  {
-    return allowed_t<I>();
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_query<const Executor&, Property>::value,
-    query_result_t<const Executor&, Property>
-  > query(const Property& p) const
-    noexcept(is_nothrow_query<const Executor&, Property>::value)
-  {
-    return asio::query(executor_, p);
-  }
-
-  template <int I>
-  Executor require(disallowed_t<I>) const noexcept
-  {
-    return executor_;
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_require<const Executor&, Property>::value,
-    adapter<decay_t<require_result_t<const Executor&, Property>>>
-  > require(const Property& p) const
-    noexcept(is_nothrow_require<const Executor&, Property>::value)
-  {
-    return adapter<decay_t<require_result_t<const Executor&, Property>>>(
-        0, asio::require(executor_, p));
-  }
-
-  template <typename Property>
-  enable_if_t<
-    can_prefer<const Executor&, Property>::value,
-    adapter<decay_t<prefer_result_t<const Executor&, Property>>>
-  > prefer(const Property& p) const
-    noexcept(is_nothrow_prefer<const Executor&, Property>::value)
-  {
-    return adapter<decay_t<prefer_result_t<const Executor&, Property>>>(
-        0, asio::prefer(executor_, p));
-  }
-
-  template <typename Function>
-  enable_if_t<
-    traits::execute_member<const Executor&, Function>::is_valid
-  > execute(Function&& f) const
-  {
-    executor_.execute(static_cast<Function&&>(f));
-  }
-
-  friend bool operator==(const adapter& a, const adapter& b) noexcept
-  {
-    return a.executor_ == b.executor_;
-  }
-
-  friend bool operator!=(const adapter& a, const adapter& b) noexcept
-  {
-    return a.executor_ != b.executor_;
-  }
-
-private:
-  Executor executor_;
-};
-
-template <int I = 0>
-struct allowed_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = false;
-  typedef blocking_adaptation_t<I> polymorphic_query_result_type;
-
-  constexpr allowed_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename blocking_adaptation_t<I>::template proxy<T>::type,
-        allowed_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename blocking_adaptation_t<I>::template static_proxy<T>::type,
-        allowed_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(allowed_t::static_query<E>())>
-  static constexpr const T static_query_v = allowed_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr blocking_adaptation_t<I> value()
-  {
-    return allowed_t();
-  }
-
-  friend constexpr bool operator==(const allowed_t&, const allowed_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const allowed_t&, const allowed_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const allowed_t&, const disallowed_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const allowed_t&, const disallowed_t<I>&)
-  {
-    return true;
-  }
-
-  template <typename Executor>
-  friend adapter<Executor> require(
-      const Executor& e, const allowed_t&,
-      enable_if_t<
-        is_executor<Executor>::value
-      >* = 0)
-  {
-    return adapter<Executor>(0, e);
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T allowed_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename Function>
-class blocking_execute_state
-{
-public:
-  template <typename F>
-  blocking_execute_state(F&& f)
-    : func_(static_cast<F&&>(f)),
-      is_complete_(false)
-  {
-  }
-
-  template <typename Executor>
-  void execute_and_wait(Executor&& ex)
-  {
-    handler h = { this };
-    ex.execute(h);
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    while (!is_complete_)
-      event_.wait(lock);
-  }
-
-  struct cleanup
-  {
-    ~cleanup()
-    {
-      asio::detail::mutex::scoped_lock lock(state_->mutex_);
-      state_->is_complete_ = true;
-      state_->event_.unlock_and_signal_one_for_destruction(lock);
-    }
-
-    blocking_execute_state* state_;
-  };
-
-  struct handler
-  {
-    void operator()()
-    {
-      cleanup c = { state_ };
-      state_->func_();
-    }
-
-    blocking_execute_state* state_;
-  };
-
-  Function func_;
-  asio::detail::mutex mutex_;
-  asio::detail::event event_;
-  bool is_complete_;
-};
-
-template <typename Executor, typename Function>
-void blocking_execute(
-    Executor&& ex,
-    Function&& func)
-{
-  typedef decay_t<Function> func_t;
-  blocking_execute_state<func_t> state(static_cast<Function&&>(func));
-  state.execute_and_wait(ex);
-}
-
-} // namespace blocking_adaptation
-} // namespace detail
-
-typedef detail::blocking_adaptation_t<> blocking_adaptation_t;
-
-constexpr blocking_adaptation_t blocking_adaptation;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_adaptation_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_adaptation_t::disallowed_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::blocking_adaptation_t::allowed_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T>
-struct query_free_default<T, execution::blocking_adaptation_t,
-  enable_if_t<
-    can_query<T, execution::blocking_adaptation_t::disallowed_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::blocking_adaptation_t::disallowed_t>::value;
-
-  typedef execution::blocking_adaptation_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::blocking_adaptation_t,
-  enable_if_t<
-    !can_query<T, execution::blocking_adaptation_t::disallowed_t>::value
-      && can_query<T, execution::blocking_adaptation_t::allowed_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::blocking_adaptation_t::allowed_t>::value;
-
-  typedef execution::blocking_adaptation_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t,
-  enable_if_t<
-    execution::detail::blocking_adaptation_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking_adaptation_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking_adaptation_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t,
-  enable_if_t<
-    !execution::detail::blocking_adaptation_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_adaptation_t<0>::
-        query_member<T>::is_valid
-      && traits::static_query<T,
-        execution::blocking_adaptation_t::disallowed_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::blocking_adaptation_t::disallowed_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::blocking_adaptation_t::disallowed_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t,
-  enable_if_t<
-    !execution::detail::blocking_adaptation_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_adaptation_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T,
-        execution::blocking_adaptation_t::disallowed_t>::is_valid
-      && traits::static_query<T,
-        execution::blocking_adaptation_t::allowed_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::blocking_adaptation_t::allowed_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::blocking_adaptation_t::allowed_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t::disallowed_t,
-  enable_if_t<
-    execution::detail::blocking_adaptation::disallowed_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking_adaptation::disallowed_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking_adaptation::disallowed_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t::disallowed_t,
-  enable_if_t<
-    !execution::detail::blocking_adaptation::disallowed_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::blocking_adaptation::disallowed_t<0>::
-        query_member<T>::is_valid
-      && !traits::query_free<T,
-        execution::blocking_adaptation_t::disallowed_t>::is_valid
-      && !can_query<T, execution::blocking_adaptation_t::allowed_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::blocking_adaptation_t::disallowed_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::blocking_adaptation_t::allowed_t,
-  enable_if_t<
-    execution::detail::blocking_adaptation::allowed_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::blocking_adaptation::allowed_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::blocking_adaptation::allowed_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename T>
-struct require_free_default<T, execution::blocking_adaptation_t::allowed_t,
-  enable_if_t<
-    is_same<T, decay_t<T>>::value
-      && execution::is_executor<T>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef execution::detail::blocking_adaptation::adapter<T> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Executor>
-struct equality_comparable<
-  execution::detail::blocking_adaptation::adapter<Executor>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Executor, typename Function>
-struct execute_member<
-  execution::detail::blocking_adaptation::adapter<Executor>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking_adaptation::adapter<Executor>,
-  execution::detail::blocking_adaptation_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_adaptation_t::allowed_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking_adaptation::adapter<Executor>,
-  execution::detail::blocking_adaptation::allowed_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_adaptation_t::allowed_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-template <typename Executor, int I>
-struct query_static_constexpr_member<
-  execution::detail::blocking_adaptation::adapter<Executor>,
-  execution::detail::blocking_adaptation::disallowed_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_adaptation_t::allowed_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct query_member<
-  execution::detail::blocking_adaptation::adapter<Executor>, Property,
-  enable_if_t<
-    can_query<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<Executor, Property>::value;
-  typedef query_result_t<Executor, Property> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Executor, int I>
-struct require_member<
-  execution::detail::blocking_adaptation::adapter<Executor>,
-  execution::detail::blocking_adaptation::disallowed_t<I>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Executor result_type;
-};
-
-template <typename Executor, typename Property>
-struct require_member<
-  execution::detail::blocking_adaptation::adapter<Executor>, Property,
-  enable_if_t<
-    can_require<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_require<Executor, Property>::value;
-  typedef execution::detail::blocking_adaptation::adapter<
-    decay_t<require_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct prefer_member<
-  execution::detail::blocking_adaptation::adapter<Executor>, Property,
-  enable_if_t<
-    can_prefer<const Executor&, Property>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_prefer<Executor, Property>::value;
-  typedef execution::detail::blocking_adaptation::adapter<
-    decay_t<prefer_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_BLOCKING_ADAPTATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context.hpp
deleted file mode 100644
index a9df9c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-// execution/context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_CONTEXT2_HPP
-#define ASIO_EXECUTION_CONTEXT2_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-
-#if defined(ASIO_HAS_STD_ANY)
-# include <any>
-#endif // defined(ASIO_HAS_STD_ANY)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property that is used to obtain the execution context that is associated
-/// with an executor.
-struct context_t
-{
-  /// The context_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The context_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The context_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef std::any polymorphic_query_result_type;
-};
-
-/// A special value used for accessing the context_t property.
-constexpr context_t context;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-
-template <int I = 0>
-struct context_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-
-#if defined(ASIO_HAS_STD_ANY)
-  typedef std::any polymorphic_query_result_type;
-#endif // defined(ASIO_HAS_STD_ANY)
-
-  constexpr context_t()
-  {
-  }
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, context_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(context_t::static_query<E>())>
-  static constexpr const T static_query_v = context_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T context_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace detail
-
-typedef detail::context_t<> context_t;
-
-constexpr context_t context;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::context_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::context_t,
-  enable_if_t<
-    execution::detail::context_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::context_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::context_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_CONTEXT2_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context_as.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context_as.hpp
deleted file mode 100644
index f51fb1d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/context_as.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-// execution/context_as.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_CONTEXT_AS_HPP
-#define ASIO_EXECUTION_CONTEXT_AS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/context.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/query.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property that is used to obtain the execution context that is associated
-/// with an executor.
-template <typename U>
-struct context_as_t
-{
-  /// The context_as_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The context_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The context_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef T polymorphic_query_result_type;
-};
-
-/// A special value used for accessing the context_as_t property.
-template <typename U>
-constexpr context_as_t context_as;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-template <typename T>
-struct context_as_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename U>
-  static constexpr bool is_applicable_property_v = is_executor<U>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-
-  typedef T polymorphic_query_result_type;
-
-  constexpr context_as_t()
-  {
-  }
-
-  constexpr context_as_t(context_t)
-  {
-  }
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename E>
-  static constexpr
-  typename context_t::query_static_constexpr_member<E>::result_type
-  static_query()
-    noexcept(context_t::query_static_constexpr_member<E>::is_noexcept)
-  {
-    return context_t::query_static_constexpr_member<E>::value();
-  }
-
-  template <typename E, typename U = decltype(context_as_t::static_query<E>())>
-  static constexpr const U static_query_v
-    = context_as_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  template <typename Executor, typename U>
-  friend constexpr U query(
-      const Executor& ex, const context_as_t<U>&,
-      enable_if_t<
-        is_same<T, U>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, const context_t&>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, const context_t&>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, const context_t&>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, context);
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <typename T> template <typename E, typename U>
-const U context_as_t<T>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES) \
-  || defined(GENERATING_DOCUMENTATION)
-template <typename T>
-constexpr context_as_t<T> context_as{};
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename U>
-struct is_applicable_property<T, execution::context_as_t<U>>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T, typename U>
-struct static_query<T, execution::context_as_t<U>,
-  enable_if_t<
-    static_query<T, execution::context_t>::is_valid
-  >> : static_query<T, execution::context_t>
-{
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T, typename U>
-struct query_free<T, execution::context_as_t<U>,
-  enable_if_t<
-    can_query<const T&, const execution::context_t&>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<const T&, const execution::context_t&>::value;
-
-  typedef U result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_CONTEXT_AS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/executor.hpp
deleted file mode 100644
index 1f34981..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/executor.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// execution/executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_EXECUTOR_HPP
-#define ASIO_EXECUTION_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/invocable_archetype.hpp"
-#include "asio/traits/equality_comparable.hpp"
-#include "asio/traits/execute_member.hpp"
-
-#if defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT) \
-  && defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-# define ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT 1
-#endif // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-       //   && defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace execution {
-namespace detail {
-
-template <typename T, typename F,
-    typename = void, typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void, typename = void>
-struct is_executor_of_impl : false_type
-{
-};
-
-template <typename T, typename F>
-struct is_executor_of_impl<T, F,
-  enable_if_t<
-    traits::execute_member<add_const_t<T>, F>::is_valid
-  >,
-  void_t<
-    result_of_t<decay_t<F>&()>
-  >,
-  enable_if_t<
-    is_constructible<decay_t<F>, F>::value
-  >,
-  enable_if_t<
-    is_move_constructible<decay_t<F>>::value
-  >,
-  enable_if_t<
-    is_nothrow_copy_constructible<T>::value
-  >,
-  enable_if_t<
-    is_nothrow_destructible<T>::value
-  >,
-  enable_if_t<
-    traits::equality_comparable<T>::is_valid
-  >,
-  enable_if_t<
-    traits::equality_comparable<T>::is_noexcept
-  >> : true_type
-{
-};
-
-} // namespace detail
-
-/// The is_executor trait detects whether a type T satisfies the
-/// execution::executor concept.
-/**
- * Class template @c is_executor is a UnaryTypeTrait that is derived from @c
- * true_type if the type @c T meets the concept definition for an executor,
- * otherwise @c false_type.
- */
-template <typename T>
-struct is_executor :
-#if defined(GENERATING_DOCUMENTATION)
-  integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  detail::is_executor_of_impl<T, invocable_archetype>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-constexpr const bool is_executor_v = is_executor<T>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-#if defined(ASIO_HAS_CONCEPTS)
-
-template <typename T>
-ASIO_CONCEPT executor = is_executor<T>::value;
-
-#define ASIO_EXECUTION_EXECUTOR ::asio::execution::executor
-
-#else // defined(ASIO_HAS_CONCEPTS)
-
-#define ASIO_EXECUTION_EXECUTOR typename
-
-#endif // defined(ASIO_HAS_CONCEPTS)
-
-} // namespace execution
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/impl/bad_executor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/impl/bad_executor.ipp
deleted file mode 100644
index 4e185ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/impl/bad_executor.ipp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// exection/impl/bad_executor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
-#define ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/execution/bad_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace execution {
-
-bad_executor::bad_executor() noexcept
-{
-}
-
-const char* bad_executor::what() const noexcept
-{
-  return "bad executor";
-}
-
-} // namespace execution
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_IMPL_BAD_EXECUTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/invocable_archetype.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/invocable_archetype.hpp
deleted file mode 100644
index 5022327..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/invocable_archetype.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// execution/invocable_archetype.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
-#define ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace execution {
-
-/// An archetypal function object used for determining adherence to the
-/// execution::executor concept.
-struct invocable_archetype
-{
-  /// Function call operator.
-  template <typename... Args>
-  void operator()(Args&&...)
-  {
-  }
-};
-
-} // namespace execution
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_INVOCABLE_ARCHETYPE_HPP
-
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/mapping.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/mapping.hpp
deleted file mode 100644
index 4c6e179..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/mapping.hpp
+++ /dev/null
@@ -1,1002 +0,0 @@
-//
-// execution/mapping.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_MAPPING_HPP
-#define ASIO_EXECUTION_MAPPING_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/query.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe what guarantees an executor makes about the mapping
-/// of execution agents on to threads of execution.
-struct mapping_t
-{
-  /// The mapping_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The top-level mapping_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The top-level mapping_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef mapping_t polymorphic_query_result_type;
-
-  /// A sub-property that indicates that execution agents are mapped on to
-  /// threads of execution.
-  struct thread_t
-  {
-    /// The mapping_t::thread_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The mapping_t::thread_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The mapping_t::thread_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef mapping_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr thread_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns thread_t();
-     */
-    static constexpr mapping_t value();
-  };
-
-  /// A sub-property that indicates that execution agents are mapped on to
-  /// new threads of execution.
-  struct new_thread_t
-  {
-    /// The mapping_t::new_thread_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The mapping_t::new_thread_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The mapping_t::new_thread_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef mapping_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr new_thread_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns new_thread_t();
-     */
-    static constexpr mapping_t value();
-  };
-
-  /// A sub-property that indicates that the mapping of execution agents is
-  /// implementation-defined.
-  struct other_t
-  {
-    /// The mapping_t::other_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The mapping_t::other_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The mapping_t::other_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef mapping_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr other_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns other_t();
-     */
-    static constexpr mapping_t value();
-  };
-
-  /// A special value used for accessing the mapping_t::thread_t property.
-  static constexpr thread_t thread;
-
-  /// A special value used for accessing the mapping_t::new_thread_t property.
-  static constexpr new_thread_t new_thread;
-
-  /// A special value used for accessing the mapping_t::other_t property.
-  static constexpr other_t other;
-
-  /// Default constructor.
-  constexpr mapping_t();
-
-  /// Construct from a sub-property value.
-  constexpr mapping_t(thread_t);
-
-  /// Construct from a sub-property value.
-  constexpr mapping_t(new_thread_t);
-
-  /// Construct from a sub-property value.
-  constexpr mapping_t(other_t);
-
-  /// Compare property values for equality.
-  friend constexpr bool operator==(
-      const mapping_t& a, const mapping_t& b) noexcept;
-
-  /// Compare property values for inequality.
-  friend constexpr bool operator!=(
-      const mapping_t& a, const mapping_t& b) noexcept;
-};
-
-/// A special value used for accessing the mapping_t property.
-constexpr mapping_t mapping;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-namespace mapping {
-
-template <int I> struct thread_t;
-template <int I> struct new_thread_t;
-template <int I> struct other_t;
-
-} // namespace mapping
-
-template <int I = 0>
-struct mapping_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef mapping_t polymorphic_query_result_type;
-
-  typedef detail::mapping::thread_t<I> thread_t;
-  typedef detail::mapping::new_thread_t<I> new_thread_t;
-  typedef detail::mapping::other_t<I> other_t;
-
-  constexpr mapping_t()
-    : value_(-1)
-  {
-  }
-
-  constexpr mapping_t(thread_t)
-    : value_(0)
-  {
-  }
-
-  constexpr mapping_t(new_thread_t)
-    : value_(1)
-  {
-  }
-
-  constexpr mapping_t(other_t)
-    : value_(2)
-  {
-  }
-
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p) const
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<typename proxy<T>::type, mapping_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, mapping_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, thread_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, thread_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, thread_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, new_thread_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, thread_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, new_thread_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, new_thread_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, other_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, thread_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, new_thread_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, other_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, other_t>::value();
-  }
-
-  template <typename E, typename T = decltype(mapping_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = mapping_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  friend constexpr bool operator==(
-      const mapping_t& a, const mapping_t& b)
-  {
-    return a.value_ == b.value_;
-  }
-
-  friend constexpr bool operator!=(
-      const mapping_t& a, const mapping_t& b)
-  {
-    return a.value_ != b.value_;
-  }
-
-  struct convertible_from_mapping_t
-  {
-    constexpr convertible_from_mapping_t(mapping_t) {}
-  };
-
-  template <typename Executor>
-  friend constexpr mapping_t query(
-      const Executor& ex, convertible_from_mapping_t,
-      enable_if_t<
-        can_query<const Executor&, thread_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, mapping_t<>::thread_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, thread_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, thread_t());
-  }
-
-  template <typename Executor>
-  friend constexpr mapping_t query(
-      const Executor& ex, convertible_from_mapping_t,
-      enable_if_t<
-        !can_query<const Executor&, thread_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, new_thread_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(
-      is_nothrow_query<const Executor&, mapping_t<>::new_thread_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, new_thread_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, new_thread_t());
-  }
-
-  template <typename Executor>
-  friend constexpr mapping_t query(
-      const Executor& ex, convertible_from_mapping_t,
-      enable_if_t<
-        !can_query<const Executor&, thread_t>::value
-      >* = 0,
-      enable_if_t<
-        !can_query<const Executor&, new_thread_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, other_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, mapping_t<>::other_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, other_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, other_t());
-  }
-
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(thread_t, thread);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(new_thread_t, new_thread);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(other_t, other);
-
-private:
-  int value_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T mapping_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-const typename mapping_t<I>::thread_t mapping_t<I>::thread;
-
-template <int I>
-const typename mapping_t<I>::new_thread_t mapping_t<I>::new_thread;
-
-template <int I>
-const typename mapping_t<I>::other_t mapping_t<I>::other;
-
-namespace mapping {
-
-template <int I = 0>
-struct thread_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef mapping_t<I> polymorphic_query_result_type;
-
-  constexpr thread_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename mapping_t<I>::template proxy<T>::type, thread_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename mapping_t<I>::template static_proxy<T>::type, thread_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr thread_t static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::query_free<T, thread_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !can_query<T, new_thread_t<I>>::value
-      >* = 0,
-      enable_if_t<
-        !can_query<T, other_t<I>>::value
-      >* = 0) noexcept
-  {
-    return thread_t();
-  }
-
-  template <typename E, typename T = decltype(thread_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = thread_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr mapping_t<I> value()
-  {
-    return thread_t();
-  }
-
-  friend constexpr bool operator==(const thread_t&, const thread_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const thread_t&, const thread_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const thread_t&, const new_thread_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const thread_t&, const new_thread_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(const thread_t&, const other_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const thread_t&, const other_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T thread_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I = 0>
-struct new_thread_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef mapping_t<I> polymorphic_query_result_type;
-
-  constexpr new_thread_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename mapping_t<I>::template proxy<T>::type, new_thread_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename mapping_t<I>::template static_proxy<T>::type, new_thread_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(new_thread_t::static_query<E>())>
-  static constexpr const T static_query_v = new_thread_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr mapping_t<I> value()
-  {
-    return new_thread_t();
-  }
-
-  friend constexpr bool operator==(const new_thread_t&, const new_thread_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const new_thread_t&, const new_thread_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const new_thread_t&, const thread_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const new_thread_t&, const thread_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(const new_thread_t&, const other_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const new_thread_t&, const other_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T new_thread_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-struct other_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef mapping_t<I> polymorphic_query_result_type;
-
-  constexpr other_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename mapping_t<I>::template proxy<T>::type, other_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename mapping_t<I>::template static_proxy<T>::type, other_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(other_t::static_query<E>())>
-  static constexpr const T static_query_v = other_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr mapping_t<I> value()
-  {
-    return other_t();
-  }
-
-  friend constexpr bool operator==(const other_t&, const other_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const other_t&, const other_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const other_t&, const thread_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const other_t&, const thread_t<I>&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator==(const other_t&, const new_thread_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const other_t&, const new_thread_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T other_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace mapping
-} // namespace detail
-
-typedef detail::mapping_t<> mapping_t;
-
-constexpr mapping_t mapping;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::mapping_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::mapping_t::thread_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::mapping_t::new_thread_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::mapping_t::other_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T>
-struct query_free_default<T, execution::mapping_t,
-  enable_if_t<
-    can_query<T, execution::mapping_t::thread_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::mapping_t::thread_t>::value;
-
-  typedef execution::mapping_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::mapping_t,
-  enable_if_t<
-    !can_query<T, execution::mapping_t::thread_t>::value
-      && can_query<T, execution::mapping_t::new_thread_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::mapping_t::new_thread_t>::value;
-
-  typedef execution::mapping_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::mapping_t,
-  enable_if_t<
-    !can_query<T, execution::mapping_t::thread_t>::value
-      && !can_query<T, execution::mapping_t::new_thread_t>::value
-      && can_query<T, execution::mapping_t::other_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::mapping_t::other_t>::value;
-
-  typedef execution::mapping_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::mapping_t,
-  enable_if_t<
-    execution::detail::mapping_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::mapping_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::mapping_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t,
-  enable_if_t<
-    !execution::detail::mapping_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::mapping_t<0>::
-        query_member<T>::is_valid
-      && traits::static_query<T, execution::mapping_t::thread_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::mapping_t::thread_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::mapping_t::thread_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t,
-  enable_if_t<
-    !execution::detail::mapping_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::mapping_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T, execution::mapping_t::thread_t>::is_valid
-      && traits::static_query<T, execution::mapping_t::new_thread_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::mapping_t::new_thread_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::mapping_t::new_thread_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t,
-  enable_if_t<
-    !execution::detail::mapping_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::mapping_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T, execution::mapping_t::thread_t>::is_valid
-      && !traits::static_query<T, execution::mapping_t::new_thread_t>::is_valid
-      && traits::static_query<T, execution::mapping_t::other_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::mapping_t::other_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T, execution::mapping_t::other_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t::thread_t,
-  enable_if_t<
-    execution::detail::mapping::thread_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::mapping::thread_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::mapping::thread_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t::thread_t,
-  enable_if_t<
-    !execution::detail::mapping::thread_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::mapping::thread_t<0>::
-        query_member<T>::is_valid
-      && !traits::query_free<T, execution::mapping_t::thread_t>::is_valid
-      && !can_query<T, execution::mapping_t::new_thread_t>::value
-      && !can_query<T, execution::mapping_t::other_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::mapping_t::thread_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t::new_thread_t,
-  enable_if_t<
-    execution::detail::mapping::new_thread_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::mapping::new_thread_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::mapping::new_thread_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::mapping_t::other_t,
-  enable_if_t<
-    execution::detail::mapping::other_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::mapping::other_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::mapping::other_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_MAPPING_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/occupancy.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/occupancy.hpp
deleted file mode 100644
index c986c88..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/occupancy.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-//
-// execution/occupancy.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_OCCUPANCY_HPP
-#define ASIO_EXECUTION_OCCUPANCY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property that gives an estimate of the number of execution agents that
-/// should occupy the associated execution context.
-struct occupancy_t
-{
-  /// The occupancy_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The occupancy_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The occupancy_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef std::size_t polymorphic_query_result_type;
-};
-
-/// A special value used for accessing the occupancy_t property.
-constexpr occupancy_t occupancy;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-
-template <int I = 0>
-struct occupancy_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef std::size_t polymorphic_query_result_type;
-
-  constexpr occupancy_t()
-  {
-  }
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, occupancy_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(occupancy_t::static_query<E>())>
-  static constexpr const T static_query_v = occupancy_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T occupancy_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace detail
-
-typedef detail::occupancy_t<> occupancy_t;
-
-constexpr occupancy_t occupancy;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::occupancy_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::occupancy_t,
-  enable_if_t<
-    execution::detail::occupancy_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::occupancy_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::occupancy_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_OCCUPANCY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/outstanding_work.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/outstanding_work.hpp
deleted file mode 100644
index 600792b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/outstanding_work.hpp
+++ /dev/null
@@ -1,753 +0,0 @@
-//
-// execution/outstanding_work.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_OUTSTANDING_WORK_HPP
-#define ASIO_EXECUTION_OUTSTANDING_WORK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/query.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe whether task submission is likely in the future.
-struct outstanding_work_t
-{
-  /// The outstanding_work_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The top-level outstanding_work_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The top-level outstanding_work_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef outstanding_work_t polymorphic_query_result_type;
-
-  /// A sub-property that indicates that the executor does not represent likely
-  /// future submission of a function object.
-  struct untracked_t
-  {
-    /// The outstanding_work_t::untracked_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The outstanding_work_t::untracked_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The outstanding_work_t::untracked_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef outstanding_work_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr untracked_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns untracked_t();
-     */
-    static constexpr outstanding_work_t value();
-  };
-
-  /// A sub-property that indicates that the executor represents likely
-  /// future submission of a function object.
-  struct tracked_t
-  {
-    /// The outstanding_work_t::untracked_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The outstanding_work_t::tracked_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The outstanding_work_t::tracked_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef outstanding_work_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr tracked_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns tracked_t();
-     */
-    static constexpr outstanding_work_t value();
-  };
-
-  /// A special value used for accessing the outstanding_work_t::untracked_t
-  /// property.
-  static constexpr untracked_t untracked;
-
-  /// A special value used for accessing the outstanding_work_t::tracked_t
-  /// property.
-  static constexpr tracked_t tracked;
-
-  /// Default constructor.
-  constexpr outstanding_work_t();
-
-  /// Construct from a sub-property value.
-  constexpr outstanding_work_t(untracked_t);
-
-  /// Construct from a sub-property value.
-  constexpr outstanding_work_t(tracked_t);
-
-  /// Compare property values for equality.
-  friend constexpr bool operator==(
-      const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
-
-  /// Compare property values for inequality.
-  friend constexpr bool operator!=(
-      const outstanding_work_t& a, const outstanding_work_t& b) noexcept;
-};
-
-/// A special value used for accessing the outstanding_work_t property.
-constexpr outstanding_work_t outstanding_work;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-namespace outstanding_work {
-
-template <int I> struct untracked_t;
-template <int I> struct tracked_t;
-
-} // namespace outstanding_work
-
-template <int I = 0>
-struct outstanding_work_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef outstanding_work_t polymorphic_query_result_type;
-
-  typedef detail::outstanding_work::untracked_t<I> untracked_t;
-  typedef detail::outstanding_work::tracked_t<I> tracked_t;
-
-  constexpr outstanding_work_t()
-    : value_(-1)
-  {
-  }
-
-  constexpr outstanding_work_t(untracked_t)
-    : value_(0)
-  {
-  }
-
-  constexpr outstanding_work_t(tracked_t)
-    : value_(1)
-  {
-  }
-
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p) const
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<typename proxy<T>::type, outstanding_work_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, outstanding_work_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, untracked_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, untracked_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, untracked_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, tracked_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, untracked_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, tracked_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, tracked_t>::value();
-  }
-
-  template <typename E,
-      typename T = decltype(outstanding_work_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = outstanding_work_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  friend constexpr bool operator==(
-      const outstanding_work_t& a, const outstanding_work_t& b)
-  {
-    return a.value_ == b.value_;
-  }
-
-  friend constexpr bool operator!=(
-      const outstanding_work_t& a, const outstanding_work_t& b)
-  {
-    return a.value_ != b.value_;
-  }
-
-  struct convertible_from_outstanding_work_t
-  {
-    constexpr convertible_from_outstanding_work_t(outstanding_work_t)
-    {
-    }
-  };
-
-  template <typename Executor>
-  friend constexpr outstanding_work_t query(
-      const Executor& ex, convertible_from_outstanding_work_t,
-      enable_if_t<
-        can_query<const Executor&, untracked_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&,
-        outstanding_work_t<>::untracked_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, untracked_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, untracked_t());
-  }
-
-  template <typename Executor>
-  friend constexpr outstanding_work_t query(
-      const Executor& ex, convertible_from_outstanding_work_t,
-      enable_if_t<
-        !can_query<const Executor&, untracked_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, tracked_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&,
-        outstanding_work_t<>::tracked_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, tracked_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, tracked_t());
-  }
-
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(untracked_t, untracked);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(tracked_t, tracked);
-
-private:
-  int value_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T outstanding_work_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-const typename outstanding_work_t<I>::untracked_t
-outstanding_work_t<I>::untracked;
-
-template <int I>
-const typename outstanding_work_t<I>::tracked_t
-outstanding_work_t<I>::tracked;
-
-namespace outstanding_work {
-
-template <int I = 0>
-struct untracked_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef outstanding_work_t<I> polymorphic_query_result_type;
-
-  constexpr untracked_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename outstanding_work_t<I>::template proxy<T>::type, untracked_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename outstanding_work_t<I>::template static_proxy<T>::type,
-        untracked_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr untracked_t static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::query_free<T, untracked_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !can_query<T, tracked_t<I>>::value
-      >* = 0) noexcept
-  {
-    return untracked_t();
-  }
-
-  template <typename E, typename T = decltype(untracked_t::static_query<E>())>
-  static constexpr const T static_query_v = untracked_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr outstanding_work_t<I> value()
-  {
-    return untracked_t();
-  }
-
-  friend constexpr bool operator==(const untracked_t&, const untracked_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const untracked_t&, const untracked_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const untracked_t&, const tracked_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const untracked_t&, const tracked_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T untracked_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I = 0>
-struct tracked_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef outstanding_work_t<I> polymorphic_query_result_type;
-
-  constexpr tracked_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename outstanding_work_t<I>::template proxy<T>::type, tracked_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename outstanding_work_t<I>::template static_proxy<T>::type,
-        tracked_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E, typename T = decltype(tracked_t::static_query<E>())>
-  static constexpr const T static_query_v = tracked_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr outstanding_work_t<I> value()
-  {
-    return tracked_t();
-  }
-
-  friend constexpr bool operator==(const tracked_t&, const tracked_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const tracked_t&, const tracked_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const tracked_t&, const untracked_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const tracked_t&, const untracked_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T tracked_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace outstanding_work
-} // namespace detail
-
-typedef detail::outstanding_work_t<> outstanding_work_t;
-
-constexpr outstanding_work_t outstanding_work;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::outstanding_work_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::outstanding_work_t::untracked_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::outstanding_work_t::tracked_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T>
-struct query_free_default<T, execution::outstanding_work_t,
-  enable_if_t<
-    can_query<T, execution::outstanding_work_t::untracked_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::outstanding_work_t::untracked_t>::value;
-
-  typedef execution::outstanding_work_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::outstanding_work_t,
-  enable_if_t<
-    !can_query<T, execution::outstanding_work_t::untracked_t>::value
-      && can_query<T, execution::outstanding_work_t::tracked_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::outstanding_work_t::tracked_t>::value;
-
-  typedef execution::outstanding_work_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t,
-  enable_if_t<
-    execution::detail::outstanding_work_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::outstanding_work_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::outstanding_work_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t,
-  enable_if_t<
-    !execution::detail::outstanding_work_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::outstanding_work_t<0>::
-        query_member<T>::is_valid
-      && traits::static_query<T,
-        execution::outstanding_work_t::untracked_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::outstanding_work_t::untracked_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::outstanding_work_t::untracked_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t,
-  enable_if_t<
-    !execution::detail::outstanding_work_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::outstanding_work_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T,
-        execution::outstanding_work_t::untracked_t>::is_valid
-      && traits::static_query<T,
-        execution::outstanding_work_t::tracked_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::outstanding_work_t::tracked_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::outstanding_work_t::tracked_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t::untracked_t,
-  enable_if_t<
-    execution::detail::outstanding_work::untracked_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::outstanding_work::untracked_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::outstanding_work::untracked_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t::untracked_t,
-  enable_if_t<
-    !execution::detail::outstanding_work::untracked_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::outstanding_work::untracked_t<0>::
-          query_member<T>::is_valid
-      && !traits::query_free<T,
-        execution::outstanding_work_t::untracked_t>::is_valid
-      && !can_query<T, execution::outstanding_work_t::tracked_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::outstanding_work_t::untracked_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::outstanding_work_t::tracked_t,
-  enable_if_t<
-    execution::detail::outstanding_work::tracked_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::outstanding_work::tracked_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::outstanding_work::tracked_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_OUTSTANDING_WORK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/prefer_only.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/prefer_only.hpp
deleted file mode 100644
index 1a990eb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/prefer_only.hpp
+++ /dev/null
@@ -1,328 +0,0 @@
-//
-// execution/prefer_only.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_PREFER_ONLY_HPP
-#define ASIO_EXECUTION_PREFER_ONLY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/traits/static_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property adapter that is used with the polymorphic executor wrapper
-/// to mark properties as preferable, but not requirable.
-template <typename Property>
-struct prefer_only
-{
-  /// The prefer_only adapter applies to the same types as the nested property.
-  template <typename T>
-  static constexpr bool is_applicable_property_v =
-    is_applicable_property<T, Property>::value;
-
-  /// The context_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The context_t property can be preferred, it the underlying property can
-  /// be preferred.
-  /**
-   * @c true if @c Property::is_preferable is @c true, otherwise @c false.
-   */
-  static constexpr bool is_preferable = automatically_determined;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef typename Property::polymorphic_query_result_type
-    polymorphic_query_result_type;
-};
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-
-template <typename InnerProperty, typename = void>
-struct prefer_only_is_preferable
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <typename InnerProperty>
-struct prefer_only_is_preferable<InnerProperty,
-    enable_if_t<
-      InnerProperty::is_preferable
-    >
-  >
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <typename InnerProperty, typename = void>
-struct prefer_only_polymorphic_query_result_type
-{
-};
-
-template <typename InnerProperty>
-struct prefer_only_polymorphic_query_result_type<InnerProperty,
-    void_t<
-      typename InnerProperty::polymorphic_query_result_type
-    >
-  >
-{
-  typedef typename InnerProperty::polymorphic_query_result_type
-    polymorphic_query_result_type;
-};
-
-template <typename InnerProperty, typename = void>
-struct prefer_only_property
-{
-  InnerProperty property;
-
-  prefer_only_property(const InnerProperty& p)
-    : property(p)
-  {
-  }
-};
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-template <typename InnerProperty>
-struct prefer_only_property<InnerProperty,
-    void_t<
-      decltype(asio::declval<const InnerProperty>().value())
-    >
-  >
-{
-  InnerProperty property;
-
-  prefer_only_property(const InnerProperty& p)
-    : property(p)
-  {
-  }
-
-  constexpr auto value() const
-    noexcept(noexcept(asio::declval<const InnerProperty>().value()))
-    -> decltype(asio::declval<const InnerProperty>().value())
-  {
-    return property.value();
-  }
-};
-
-#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-struct prefer_only_memfns_base
-{
-  void value();
-};
-
-template <typename T>
-struct prefer_only_memfns_derived
-  : T, prefer_only_memfns_base
-{
-};
-
-template <typename T, T>
-struct prefer_only_memfns_check
-{
-};
-
-template <typename>
-char (&prefer_only_value_memfn_helper(...))[2];
-
-template <typename T>
-char prefer_only_value_memfn_helper(
-    prefer_only_memfns_check<
-      void (prefer_only_memfns_base::*)(),
-      &prefer_only_memfns_derived<T>::value>*);
-
-template <typename InnerProperty>
-struct prefer_only_property<InnerProperty,
-    enable_if_t<
-      sizeof(prefer_only_value_memfn_helper<InnerProperty>(0)) != 1
-        && !is_same<typename InnerProperty::polymorphic_query_result_type,
-          void>::value
-    >
-  >
-{
-  InnerProperty property;
-
-  prefer_only_property(const InnerProperty& p)
-    : property(p)
-  {
-  }
-
-  constexpr typename InnerProperty::polymorphic_query_result_type
-  value() const
-  {
-    return property.value();
-  }
-};
-
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-} // namespace detail
-
-template <typename InnerProperty>
-struct prefer_only :
-  detail::prefer_only_is_preferable<InnerProperty>,
-  detail::prefer_only_polymorphic_query_result_type<InnerProperty>,
-  detail::prefer_only_property<InnerProperty>
-{
-  static constexpr bool is_requirable = false;
-
-  constexpr prefer_only(const InnerProperty& p)
-    : detail::prefer_only_property<InnerProperty>(p)
-  {
-  }
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, InnerProperty>::result_type
-  static_query()
-    noexcept(traits::static_query<T, InnerProperty>::is_noexcept)
-  {
-    return traits::static_query<T, InnerProperty>::value();
-  }
-
-  template <typename E, typename T = decltype(prefer_only::static_query<E>())>
-  static constexpr const T static_query_v
-    = prefer_only::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  template <typename Executor, typename Property>
-  friend constexpr
-  prefer_result_t<const Executor&, const InnerProperty&>
-  prefer(const Executor& ex, const prefer_only<Property>& p,
-      enable_if_t<
-        is_same<Property, InnerProperty>::value
-      >* = 0,
-      enable_if_t<
-        can_prefer<const Executor&, const InnerProperty&>::value
-      >* = 0)
-#if !defined(ASIO_MSVC) \
-  && !defined(__clang__) // Clang crashes if noexcept is used here.
-    noexcept(is_nothrow_prefer<const Executor&, const InnerProperty&>::value)
-#endif // !defined(ASIO_MSVC)
-       //   && !defined(__clang__)
-  {
-    return asio::prefer(ex, p.property);
-  }
-
-  template <typename Executor, typename Property>
-  friend constexpr
-  query_result_t<const Executor&, const InnerProperty&>
-  query(const Executor& ex, const prefer_only<Property>& p,
-      enable_if_t<
-        is_same<Property, InnerProperty>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, const InnerProperty&>::value
-      >* = 0)
-#if !defined(ASIO_MSVC) \
-  && !defined(__clang__) // Clang crashes if noexcept is used here.
-    noexcept(is_nothrow_query<const Executor&, const InnerProperty&>::value)
-#endif // !defined(ASIO_MSVC)
-       //   && !defined(__clang__)
-  {
-    return asio::query(ex, p.property);
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <typename InnerProperty> template <typename E, typename T>
-const T prefer_only<InnerProperty>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace execution
-
-template <typename T, typename InnerProperty>
-struct is_applicable_property<T, execution::prefer_only<InnerProperty>>
-  : is_applicable_property<T, InnerProperty>
-{
-};
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T, typename InnerProperty>
-struct static_query<T, execution::prefer_only<InnerProperty>> :
-  static_query<T, const InnerProperty&>
-{
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename T, typename InnerProperty>
-struct prefer_free_default<T, execution::prefer_only<InnerProperty>,
-    enable_if_t<
-      can_prefer<const T&, const InnerProperty&>::value
-    >
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_prefer<const T&, const InnerProperty&>::value;
-
-  typedef prefer_result_t<const T&, const InnerProperty&> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T, typename InnerProperty>
-struct query_free<T, execution::prefer_only<InnerProperty>,
-    enable_if_t<
-      can_query<const T&, const InnerProperty&>::value
-    >
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<const T&, const InnerProperty&>::value;
-
-  typedef query_result_t<const T&, const InnerProperty&> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_PREFER_ONLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/relationship.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/relationship.hpp
deleted file mode 100644
index e4f2755..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution/relationship.hpp
+++ /dev/null
@@ -1,751 +0,0 @@
-//
-// execution/relationship.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_RELATIONSHIP_HPP
-#define ASIO_EXECUTION_RELATIONSHIP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/query.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_static_constexpr_member.hpp"
-#include "asio/traits/static_query.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-
-/// A property to describe whether submitted tasks represent continuations of
-/// the calling context.
-struct relationship_t
-{
-  /// The relationship_t property applies to executors.
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-  /// The top-level relationship_t property cannot be required.
-  static constexpr bool is_requirable = false;
-
-  /// The top-level relationship_t property cannot be preferred.
-  static constexpr bool is_preferable = false;
-
-  /// The type returned by queries against an @c any_executor.
-  typedef relationship_t polymorphic_query_result_type;
-
-  /// A sub-property that indicates that the executor does not represent a
-  /// continuation of the calling context.
-  struct fork_t
-  {
-    /// The relationship_t::fork_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The relationship_t::fork_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The relationship_t::fork_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef relationship_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr fork_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns fork_t();
-     */
-    static constexpr relationship_t value();
-  };
-
-  /// A sub-property that indicates that the executor represents a continuation
-  /// of the calling context.
-  struct continuation_t
-  {
-    /// The relationship_t::continuation_t property applies to executors.
-    template <typename T>
-    static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-    /// The relationship_t::continuation_t property can be required.
-    static constexpr bool is_requirable = true;
-
-    /// The relationship_t::continuation_t property can be preferred.
-    static constexpr bool is_preferable = true;
-
-    /// The type returned by queries against an @c any_executor.
-    typedef relationship_t polymorphic_query_result_type;
-
-    /// Default constructor.
-    constexpr continuation_t();
-
-    /// Get the value associated with a property object.
-    /**
-     * @returns continuation_t();
-     */
-    static constexpr relationship_t value();
-  };
-
-  /// A special value used for accessing the relationship_t::fork_t property.
-  static constexpr fork_t fork;
-
-  /// A special value used for accessing the relationship_t::continuation_t
-  /// property.
-  static constexpr continuation_t continuation;
-
-  /// Default constructor.
-  constexpr relationship_t();
-
-  /// Construct from a sub-property value.
-  constexpr relationship_t(fork_t);
-
-  /// Construct from a sub-property value.
-  constexpr relationship_t(continuation_t);
-
-  /// Compare property values for equality.
-  friend constexpr bool operator==(
-      const relationship_t& a, const relationship_t& b) noexcept;
-
-  /// Compare property values for inequality.
-  friend constexpr bool operator!=(
-      const relationship_t& a, const relationship_t& b) noexcept;
-};
-
-/// A special value used for accessing the relationship_t property.
-constexpr relationship_t relationship;
-
-} // namespace execution
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace execution {
-namespace detail {
-namespace relationship {
-
-template <int I> struct fork_t;
-template <int I> struct continuation_t;
-
-} // namespace relationship
-
-template <int I = 0>
-struct relationship_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = false;
-  static constexpr bool is_preferable = false;
-  typedef relationship_t polymorphic_query_result_type;
-
-  typedef detail::relationship::fork_t<I> fork_t;
-  typedef detail::relationship::continuation_t<I> continuation_t;
-
-  constexpr relationship_t()
-    : value_(-1)
-  {
-  }
-
-  constexpr relationship_t(fork_t)
-    : value_(0)
-  {
-  }
-
-  constexpr relationship_t(continuation_t)
-    : value_(1)
-  {
-  }
-
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p) const
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct static_proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      static constexpr auto query(P&& p)
-        noexcept(
-          noexcept(
-            conditional_t<true, T, P>::query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          conditional_t<true, T, P>::query(static_cast<P&&>(p))
-        )
-      {
-        return T::query(static_cast<P&&>(p));
-      }
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-  };
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<typename proxy<T>::type, relationship_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename static_proxy<T>::type, relationship_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr
-  typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, fork_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, fork_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, fork_t>::value();
-  }
-
-  template <typename T>
-  static constexpr
-  typename traits::static_query<T, continuation_t>::result_type
-  static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::static_query<T, fork_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        traits::static_query<T, continuation_t>::is_valid
-      >* = 0) noexcept
-  {
-    return traits::static_query<T, continuation_t>::value();
-  }
-
-  template <typename E,
-      typename T = decltype(relationship_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = relationship_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  friend constexpr bool operator==(
-      const relationship_t& a, const relationship_t& b)
-  {
-    return a.value_ == b.value_;
-  }
-
-  friend constexpr bool operator!=(
-      const relationship_t& a, const relationship_t& b)
-  {
-    return a.value_ != b.value_;
-  }
-
-  struct convertible_from_relationship_t
-  {
-    constexpr convertible_from_relationship_t(relationship_t)
-    {
-    }
-  };
-
-  template <typename Executor>
-  friend constexpr relationship_t query(
-      const Executor& ex, convertible_from_relationship_t,
-      enable_if_t<
-        can_query<const Executor&, fork_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&, relationship_t<>::fork_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, fork_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, fork_t());
-  }
-
-  template <typename Executor>
-  friend constexpr relationship_t query(
-      const Executor& ex, convertible_from_relationship_t,
-      enable_if_t<
-        !can_query<const Executor&, fork_t>::value
-      >* = 0,
-      enable_if_t<
-        can_query<const Executor&, continuation_t>::value
-      >* = 0)
-#if !defined(__clang__) // Clang crashes if noexcept is used here.
-#if defined(ASIO_MSVC) // Visual C++ wants the type to be qualified.
-    noexcept(is_nothrow_query<const Executor&,
-        relationship_t<>::continuation_t>::value)
-#else // defined(ASIO_MSVC)
-    noexcept(is_nothrow_query<const Executor&, continuation_t>::value)
-#endif // defined(ASIO_MSVC)
-#endif // !defined(__clang__)
-  {
-    return asio::query(ex, continuation_t());
-  }
-
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(fork_t, fork);
-  ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(continuation_t, continuation);
-
-private:
-  int value_;
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T relationship_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I>
-const typename relationship_t<I>::fork_t relationship_t<I>::fork;
-
-template <int I>
-const typename relationship_t<I>::continuation_t
-relationship_t<I>::continuation;
-
-namespace relationship {
-
-template <int I = 0>
-struct fork_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef relationship_t<I> polymorphic_query_result_type;
-
-  constexpr fork_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename relationship_t<I>::template proxy<T>::type, fork_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename relationship_t<I>::template static_proxy<T>::type, fork_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename T>
-  static constexpr fork_t static_query(
-      enable_if_t<
-        !query_static_constexpr_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !query_member<T>::is_valid
-      >* = 0,
-      enable_if_t<
-        !traits::query_free<T, fork_t>::is_valid
-      >* = 0,
-      enable_if_t<
-        !can_query<T, continuation_t<I>>::value
-      >* = 0) noexcept
-  {
-    return fork_t();
-  }
-
-  template <typename E, typename T = decltype(fork_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = fork_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr relationship_t<I> value()
-  {
-    return fork_t();
-  }
-
-  friend constexpr bool operator==(const fork_t&, const fork_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const fork_t&, const fork_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const fork_t&, const continuation_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const fork_t&, const continuation_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T fork_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <int I = 0>
-struct continuation_t
-{
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor<T>::value;
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-  static constexpr bool is_requirable = true;
-  static constexpr bool is_preferable = true;
-  typedef relationship_t<I> polymorphic_query_result_type;
-
-  constexpr continuation_t()
-  {
-  }
-
-  template <typename T>
-  struct query_member :
-    traits::query_member<
-      typename relationship_t<I>::template proxy<T>::type, continuation_t> {};
-
-  template <typename T>
-  struct query_static_constexpr_member :
-    traits::query_static_constexpr_member<
-      typename relationship_t<I>::template static_proxy<T>::type,
-        continuation_t> {};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-  template <typename T>
-  static constexpr typename query_static_constexpr_member<T>::result_type
-  static_query()
-    noexcept(query_static_constexpr_member<T>::is_noexcept)
-  {
-    return query_static_constexpr_member<T>::value();
-  }
-
-  template <typename E,
-      typename T = decltype(continuation_t::static_query<E>())>
-  static constexpr const T static_query_v
-    = continuation_t::static_query<E>();
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-  static constexpr relationship_t<I> value()
-  {
-    return continuation_t();
-  }
-
-  friend constexpr bool operator==(const continuation_t&, const continuation_t&)
-  {
-    return true;
-  }
-
-  friend constexpr bool operator!=(const continuation_t&, const continuation_t&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator==(const continuation_t&, const fork_t<I>&)
-  {
-    return false;
-  }
-
-  friend constexpr bool operator!=(const continuation_t&, const fork_t<I>&)
-  {
-    return true;
-  }
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-template <int I> template <typename E, typename T>
-const T continuation_t<I>::static_query_v;
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   && defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace relationship
-} // namespace detail
-
-typedef detail::relationship_t<> relationship_t;
-
-constexpr relationship_t relationship;
-
-} // namespace execution
-
-#if !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct is_applicable_property<T, execution::relationship_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::relationship_t::fork_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-template <typename T>
-struct is_applicable_property<T, execution::relationship_t::continuation_t>
-  : integral_constant<bool, execution::is_executor<T>::value>
-{
-};
-
-#endif // !defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T>
-struct query_free_default<T, execution::relationship_t,
-  enable_if_t<
-    can_query<T, execution::relationship_t::fork_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::relationship_t::fork_t>::value;
-
-  typedef execution::relationship_t result_type;
-};
-
-template <typename T>
-struct query_free_default<T, execution::relationship_t,
-  enable_if_t<
-    !can_query<T, execution::relationship_t::fork_t>::value
-      && can_query<T, execution::relationship_t::continuation_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<T, execution::relationship_t::continuation_t>::value;
-
-  typedef execution::relationship_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
-  || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-template <typename T>
-struct static_query<T, execution::relationship_t,
-  enable_if_t<
-    execution::detail::relationship_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::relationship_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::relationship_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::relationship_t,
-  enable_if_t<
-    !execution::detail::relationship_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::relationship_t<0>::
-        query_member<T>::is_valid
-      && traits::static_query<T,
-        execution::relationship_t::fork_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::relationship_t::fork_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::relationship_t::fork_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::relationship_t,
-  enable_if_t<
-    !execution::detail::relationship_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::relationship_t<0>::
-        query_member<T>::is_valid
-      && !traits::static_query<T,
-        execution::relationship_t::fork_t>::is_valid
-      && traits::static_query<T,
-        execution::relationship_t::continuation_t>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename traits::static_query<T,
-    execution::relationship_t::continuation_t>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return traits::static_query<T,
-        execution::relationship_t::continuation_t>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::relationship_t::fork_t,
-  enable_if_t<
-    execution::detail::relationship::fork_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::relationship::fork_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::relationship::fork_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::relationship_t::fork_t,
-  enable_if_t<
-    !execution::detail::relationship::fork_t<0>::
-        query_static_constexpr_member<T>::is_valid
-      && !execution::detail::relationship::fork_t<0>::
-        query_member<T>::is_valid
-      && !traits::query_free<T,
-        execution::relationship_t::fork_t>::is_valid
-      && !can_query<T, execution::relationship_t::continuation_t>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::relationship_t::fork_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-template <typename T>
-struct static_query<T, execution::relationship_t::continuation_t,
-  enable_if_t<
-    execution::detail::relationship::continuation_t<0>::
-      query_static_constexpr_member<T>::is_valid
-  >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef typename execution::detail::relationship::continuation_t<0>::
-    query_static_constexpr_member<T>::result_type result_type;
-
-  static constexpr result_type value()
-  {
-    return execution::detail::relationship::continuation_t<0>::
-      query_static_constexpr_member<T>::value();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-       //   || !defined(ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
-
-} // namespace traits
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTION_RELATIONSHIP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution_context.hpp
deleted file mode 100644
index bce8d43..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/execution_context.hpp
+++ /dev/null
@@ -1,388 +0,0 @@
-//
-// execution_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTION_CONTEXT_HPP
-#define ASIO_EXECUTION_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <stdexcept>
-#include <typeinfo>
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class execution_context;
-class io_context;
-
-#if !defined(GENERATING_DOCUMENTATION)
-template <typename Service> Service& use_service(execution_context&);
-template <typename Service> Service& use_service(io_context&);
-template <typename Service> void add_service(execution_context&, Service*);
-template <typename Service> bool has_service(execution_context&);
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-namespace detail { class service_registry; }
-
-/// A context for function object execution.
-/**
- * An execution context represents a place where function objects will be
- * executed. An @c io_context is an example of an execution context.
- *
- * @par The execution_context class and services
- *
- * Class execution_context implements an extensible, type-safe, polymorphic set
- * of services, indexed by service type.
- *
- * Services exist to manage the resources that are shared across an execution
- * context. For example, timers may be implemented in terms of a single timer
- * queue, and this queue would be stored in a service.
- *
- * Access to the services of an execution_context is via three function
- * templates, use_service(), add_service() and has_service().
- *
- * In a call to @c use_service<Service>(), the type argument chooses a service,
- * making available all members of the named type. If @c Service is not present
- * in an execution_context, an object of type @c Service is created and added
- * to the execution_context. A C++ program can check if an execution_context
- * implements a particular service with the function template @c
- * has_service<Service>().
- *
- * Service objects may be explicitly added to an execution_context using the
- * function template @c add_service<Service>(). If the @c Service is already
- * present, the service_already_exists exception is thrown. If the owner of the
- * service is not the same object as the execution_context parameter, the
- * invalid_service_owner exception is thrown.
- *
- * Once a service reference is obtained from an execution_context object by
- * calling use_service(), that reference remains usable as long as the owning
- * execution_context object exists.
- *
- * All service implementations have execution_context::service as a public base
- * class. Custom services may be implemented by deriving from this class and
- * then added to an execution_context using the facilities described above.
- *
- * @par The execution_context as a base class
- *
- * Class execution_context may be used only as a base class for concrete
- * execution context types. The @c io_context is an example of such a derived
- * type.
- *
- * On destruction, a class that is derived from execution_context must perform
- * <tt>execution_context::shutdown()</tt> followed by
- * <tt>execution_context::destroy()</tt>.
- *
- * This destruction sequence permits programs to simplify their resource
- * management by using @c shared_ptr<>. Where an object's lifetime is tied to
- * the lifetime of a connection (or some other sequence of asynchronous
- * operations), a @c shared_ptr to the object would be bound into the handlers
- * for all asynchronous operations associated with it. This works as follows:
- *
- * @li When a single connection ends, all associated asynchronous operations
- * complete. The corresponding handler objects are destroyed, and all @c
- * shared_ptr references to the objects are destroyed.
- *
- * @li To shut down the whole program, the io_context function stop() is called
- * to terminate any run() calls as soon as possible. The io_context destructor
- * calls @c shutdown() and @c destroy() to destroy all pending handlers,
- * causing all @c shared_ptr references to all connection objects to be
- * destroyed.
- */
-class execution_context
-  : private noncopyable
-{
-public:
-  class id;
-  class service;
-
-public:
-  /// Constructor.
-  ASIO_DECL execution_context();
-
-  /// Destructor.
-  ASIO_DECL ~execution_context();
-
-protected:
-  /// Shuts down all services in the context.
-  /**
-   * This function is implemented as follows:
-   *
-   * @li For each service object @c svc in the execution_context set, in
-   * reverse order of the beginning of service object lifetime, performs @c
-   * svc->shutdown().
-   */
-  ASIO_DECL void shutdown();
-
-  /// Destroys all services in the context.
-  /**
-   * This function is implemented as follows:
-   *
-   * @li For each service object @c svc in the execution_context set, in
-   * reverse order * of the beginning of service object lifetime, performs
-   * <tt>delete static_cast<execution_context::service*>(svc)</tt>.
-   */
-  ASIO_DECL void destroy();
-
-public:
-  /// Fork-related event notifications.
-  enum fork_event
-  {
-    /// Notify the context that the process is about to fork.
-    fork_prepare,
-
-    /// Notify the context that the process has forked and is the parent.
-    fork_parent,
-
-    /// Notify the context that the process has forked and is the child.
-    fork_child
-  };
-
-  /// Notify the execution_context of a fork-related event.
-  /**
-   * This function is used to inform the execution_context that the process is
-   * about to fork, or has just forked. This allows the execution_context, and
-   * the services it contains, to perform any necessary housekeeping to ensure
-   * correct operation following a fork.
-   *
-   * This function must not be called while any other execution_context
-   * function, or any function associated with the execution_context's derived
-   * class, is being called in another thread. It is, however, safe to call
-   * this function from within a completion handler, provided no other thread
-   * is accessing the execution_context or its derived class.
-   *
-   * @param event A fork-related event.
-   *
-   * @throws asio::system_error Thrown on failure. If the notification
-   * fails the execution_context object should no longer be used and should be
-   * destroyed.
-   *
-   * @par Example
-   * The following code illustrates how to incorporate the notify_fork()
-   * function:
-   * @code my_execution_context.notify_fork(execution_context::fork_prepare);
-   * if (fork() == 0)
-   * {
-   *   // This is the child process.
-   *   my_execution_context.notify_fork(execution_context::fork_child);
-   * }
-   * else
-   * {
-   *   // This is the parent process.
-   *   my_execution_context.notify_fork(execution_context::fork_parent);
-   * } @endcode
-   *
-   * @note For each service object @c svc in the execution_context set,
-   * performs <tt>svc->notify_fork();</tt>. When processing the fork_prepare
-   * event, services are visited in reverse order of the beginning of service
-   * object lifetime. Otherwise, services are visited in order of the beginning
-   * of service object lifetime.
-   */
-  ASIO_DECL void notify_fork(fork_event event);
-
-  /// Obtain the service object corresponding to the given type.
-  /**
-   * This function is used to locate a service object that corresponds to the
-   * given service type. If there is no existing implementation of the service,
-   * then the execution_context will create a new instance of the service.
-   *
-   * @param e The execution_context object that owns the service.
-   *
-   * @return The service interface implementing the specified service type.
-   * Ownership of the service interface is not transferred to the caller.
-   */
-  template <typename Service>
-  friend Service& use_service(execution_context& e);
-
-  /// Obtain the service object corresponding to the given type.
-  /**
-   * This function is used to locate a service object that corresponds to the
-   * given service type. If there is no existing implementation of the service,
-   * then the io_context will create a new instance of the service.
-   *
-   * @param ioc The io_context object that owns the service.
-   *
-   * @return The service interface implementing the specified service type.
-   * Ownership of the service interface is not transferred to the caller.
-   *
-   * @note This overload is preserved for backwards compatibility with services
-   * that inherit from io_context::service.
-   */
-  template <typename Service>
-  friend Service& use_service(io_context& ioc);
-
-  /// Creates a service object and adds it to the execution_context.
-  /**
-   * This function is used to add a service to the execution_context.
-   *
-   * @param e The execution_context object that owns the service.
-   *
-   * @param args Zero or more arguments to be passed to the service
-   * constructor.
-   *
-   * @throws asio::service_already_exists Thrown if a service of the
-   * given type is already present in the execution_context.
-   */
-  template <typename Service, typename... Args>
-  friend Service& make_service(execution_context& e, Args&&... args);
-
-  /// (Deprecated: Use make_service().) Add a service object to the
-  /// execution_context.
-  /**
-   * This function is used to add a service to the execution_context.
-   *
-   * @param e The execution_context object that owns the service.
-   *
-   * @param svc The service object. On success, ownership of the service object
-   * is transferred to the execution_context. When the execution_context object
-   * is destroyed, it will destroy the service object by performing: @code
-   * delete static_cast<execution_context::service*>(svc) @endcode
-   *
-   * @throws asio::service_already_exists Thrown if a service of the
-   * given type is already present in the execution_context.
-   *
-   * @throws asio::invalid_service_owner Thrown if the service's owning
-   * execution_context is not the execution_context object specified by the
-   * @c e parameter.
-   */
-  template <typename Service>
-  friend void add_service(execution_context& e, Service* svc);
-
-  /// Determine if an execution_context contains a specified service type.
-  /**
-   * This function is used to determine whether the execution_context contains a
-   * service object corresponding to the given service type.
-   *
-   * @param e The execution_context object that owns the service.
-   *
-   * @return A boolean indicating whether the execution_context contains the
-   * service.
-   */
-  template <typename Service>
-  friend bool has_service(execution_context& e);
-
-private:
-  // The service registry.
-  asio::detail::service_registry* service_registry_;
-};
-
-/// Class used to uniquely identify a service.
-class execution_context::id
-  : private noncopyable
-{
-public:
-  /// Constructor.
-  id() {}
-};
-
-/// Base class for all io_context services.
-class execution_context::service
-  : private noncopyable
-{
-public:
-  /// Get the context object that owns the service.
-  execution_context& context();
-
-protected:
-  /// Constructor.
-  /**
-   * @param owner The execution_context object that owns the service.
-   */
-  ASIO_DECL service(execution_context& owner);
-
-  /// Destructor.
-  ASIO_DECL virtual ~service();
-
-private:
-  /// Destroy all user-defined handler objects owned by the service.
-  virtual void shutdown() = 0;
-
-  /// Handle notification of a fork-related event to perform any necessary
-  /// housekeeping.
-  /**
-   * This function is not a pure virtual so that services only have to
-   * implement it if necessary. The default implementation does nothing.
-   */
-  ASIO_DECL virtual void notify_fork(
-      execution_context::fork_event event);
-
-  friend class asio::detail::service_registry;
-  struct key
-  {
-    key() : type_info_(0), id_(0) {}
-    const std::type_info* type_info_;
-    const execution_context::id* id_;
-  } key_;
-
-  execution_context& owner_;
-  service* next_;
-};
-
-/// Exception thrown when trying to add a duplicate service to an
-/// execution_context.
-class service_already_exists
-  : public std::logic_error
-{
-public:
-  ASIO_DECL service_already_exists();
-};
-
-/// Exception thrown when trying to add a service object to an
-/// execution_context where the service has a different owner.
-class invalid_service_owner
-  : public std::logic_error
-{
-public:
-  ASIO_DECL invalid_service_owner();
-};
-
-namespace detail {
-
-// Special derived service id type to keep classes header-file only.
-template <typename Type>
-class service_id
-  : public execution_context::id
-{
-};
-
-// Special service base class to keep classes header-file only.
-template <typename Type>
-class execution_context_service_base
-  : public execution_context::service
-{
-public:
-  static service_id<Type> id;
-
-  // Constructor.
-  execution_context_service_base(execution_context& e)
-    : execution_context::service(e)
-  {
-  }
-};
-
-template <typename Type>
-service_id<Type> execution_context_service_base<Type>::id;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/execution_context.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/execution_context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_EXECUTION_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor.hpp
deleted file mode 100644
index c056525..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor.hpp
+++ /dev/null
@@ -1,363 +0,0 @@
-//
-// executor.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTOR_HPP
-#define ASIO_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-#include <new>
-#include <typeinfo>
-#include "asio/detail/cstddef.hpp"
-#include "asio/detail/executor_function.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Exception thrown when trying to access an empty polymorphic executor.
-class bad_executor
-  : public std::exception
-{
-public:
-  /// Constructor.
-  ASIO_DECL bad_executor() noexcept;
-
-  /// Obtain message associated with exception.
-  ASIO_DECL virtual const char* what() const
-    noexcept;
-};
-
-/// Polymorphic wrapper for executors.
-class executor
-{
-public:
-  /// Default constructor.
-  executor() noexcept
-    : impl_(0)
-  {
-  }
-
-  /// Construct from nullptr.
-  executor(nullptr_t) noexcept
-    : impl_(0)
-  {
-  }
-
-  /// Copy constructor.
-  executor(const executor& other) noexcept
-    : impl_(other.clone())
-  {
-  }
-
-  /// Move constructor.
-  executor(executor&& other) noexcept
-    : impl_(other.impl_)
-  {
-    other.impl_ = 0;
-  }
-
-  /// Construct a polymorphic wrapper for the specified executor.
-  template <typename Executor>
-  executor(Executor e);
-
-  /// Construct a polymorphic executor that points to the same target as
-  /// another polymorphic executor.
-  executor(std::nothrow_t, const executor& other) noexcept
-    : impl_(other.clone())
-  {
-  }
-
-  /// Construct a polymorphic executor that moves the target from another
-  /// polymorphic executor.
-  executor(std::nothrow_t, executor&& other) noexcept
-    : impl_(other.impl_)
-  {
-    other.impl_ = 0;
-  }
-
-  /// Construct a polymorphic wrapper for the specified executor.
-  template <typename Executor>
-  executor(std::nothrow_t, Executor e) noexcept;
-
-  /// Allocator-aware constructor to create a polymorphic wrapper for the
-  /// specified executor.
-  template <typename Executor, typename Allocator>
-  executor(allocator_arg_t, const Allocator& a, Executor e);
-
-  /// Destructor.
-  ~executor()
-  {
-    destroy();
-  }
-
-  /// Assignment operator.
-  executor& operator=(const executor& other) noexcept
-  {
-    destroy();
-    impl_ = other.clone();
-    return *this;
-  }
-
-  // Move assignment operator.
-  executor& operator=(executor&& other) noexcept
-  {
-    destroy();
-    impl_ = other.impl_;
-    other.impl_ = 0;
-    return *this;
-  }
-
-  /// Assignment operator for nullptr_t.
-  executor& operator=(nullptr_t) noexcept
-  {
-    destroy();
-    impl_ = 0;
-    return *this;
-  }
-
-  /// Assignment operator to create a polymorphic wrapper for the specified
-  /// executor.
-  template <typename Executor>
-  executor& operator=(Executor&& e) noexcept
-  {
-    executor tmp(static_cast<Executor&&>(e));
-    destroy();
-    impl_ = tmp.impl_;
-    tmp.impl_ = 0;
-    return *this;
-  }
-
-  /// Obtain the underlying execution context.
-  execution_context& context() const noexcept
-  {
-    return get_impl()->context();
-  }
-
-  /// Inform the executor that it has some outstanding work to do.
-  void on_work_started() const noexcept
-  {
-    get_impl()->on_work_started();
-  }
-
-  /// Inform the executor that some work is no longer outstanding.
-  void on_work_finished() const noexcept
-  {
-    get_impl()->on_work_finished();
-  }
-
-  /// Request the executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object is executed according to the rules of the
-   * target executor object.
-   *
-   * @param f The function object to be called. The executor will make a copy
-   * of the handler object as required. The function signature of the function
-   * object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void dispatch(Function&& f, const Allocator& a) const;
-
-  /// Request the executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object is executed according to the rules of the
-   * target executor object.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void post(Function&& f, const Allocator& a) const;
-
-  /// Request the executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object is executed according to the rules of the
-   * target executor object.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void defer(Function&& f, const Allocator& a) const;
-
-  struct unspecified_bool_type_t {};
-  typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
-  static void unspecified_bool_true(unspecified_bool_type_t) {}
-
-  /// Operator to test if the executor contains a valid target.
-  operator unspecified_bool_type() const noexcept
-  {
-    return impl_ ? &executor::unspecified_bool_true : 0;
-  }
-
-  /// Obtain type information for the target executor object.
-  /**
-   * @returns If @c *this has a target type of type @c T, <tt>typeid(T)</tt>;
-   * otherwise, <tt>typeid(void)</tt>.
-   */
-#if !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
-  const std::type_info& target_type() const noexcept
-  {
-    return impl_ ? impl_->target_type() : typeid(void);
-  }
-#else // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
-  const void* target_type() const noexcept
-  {
-    return impl_ ? impl_->target_type() : 0;
-  }
-#endif // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
-
-  /// Obtain a pointer to the target executor object.
-  /**
-   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
-   * executor target; otherwise, a null pointer.
-   */
-  template <typename Executor>
-  Executor* target() noexcept;
-
-  /// Obtain a pointer to the target executor object.
-  /**
-   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
-   * executor target; otherwise, a null pointer.
-   */
-  template <typename Executor>
-  const Executor* target() const noexcept;
-
-  /// Compare two executors for equality.
-  friend bool operator==(const executor& a,
-      const executor& b) noexcept
-  {
-    if (a.impl_ == b.impl_)
-      return true;
-    if (!a.impl_ || !b.impl_)
-      return false;
-    return a.impl_->equals(b.impl_);
-  }
-
-  /// Compare two executors for inequality.
-  friend bool operator!=(const executor& a,
-      const executor& b) noexcept
-  {
-    return !(a == b);
-  }
-
-private:
-#if !defined(GENERATING_DOCUMENTATION)
-  typedef detail::executor_function function;
-  template <typename, typename> class impl;
-
-#if !defined(ASIO_NO_TYPEID)
-  typedef const std::type_info& type_id_result_type;
-#else // !defined(ASIO_NO_TYPEID)
-  typedef const void* type_id_result_type;
-#endif // !defined(ASIO_NO_TYPEID)
-
-  template <typename T>
-  static type_id_result_type type_id()
-  {
-#if !defined(ASIO_NO_TYPEID)
-    return typeid(T);
-#else // !defined(ASIO_NO_TYPEID)
-    static int unique_id;
-    return &unique_id;
-#endif // !defined(ASIO_NO_TYPEID)
-  }
-
-  // Base class for all polymorphic executor implementations.
-  class impl_base
-  {
-  public:
-    virtual impl_base* clone() const noexcept = 0;
-    virtual void destroy() noexcept = 0;
-    virtual execution_context& context() noexcept = 0;
-    virtual void on_work_started() noexcept = 0;
-    virtual void on_work_finished() noexcept = 0;
-    virtual void dispatch(function&&) = 0;
-    virtual void post(function&&) = 0;
-    virtual void defer(function&&) = 0;
-    virtual type_id_result_type target_type() const noexcept = 0;
-    virtual void* target() noexcept = 0;
-    virtual const void* target() const noexcept = 0;
-    virtual bool equals(const impl_base* e) const noexcept = 0;
-
-  protected:
-    impl_base(bool fast_dispatch) : fast_dispatch_(fast_dispatch) {}
-    virtual ~impl_base() {}
-
-  private:
-    friend class executor;
-    const bool fast_dispatch_;
-  };
-
-  // Helper function to check and return the implementation pointer.
-  impl_base* get_impl() const
-  {
-    if (!impl_)
-    {
-      bad_executor ex;
-      asio::detail::throw_exception(ex);
-    }
-    return impl_;
-  }
-
-  // Helper function to clone another implementation.
-  impl_base* clone() const noexcept
-  {
-    return impl_ ? impl_->clone() : 0;
-  }
-
-  // Helper function to destroy an implementation.
-  void destroy() noexcept
-  {
-    if (impl_)
-      impl_->destroy();
-  }
-
-  impl_base* impl_;
-#endif // !defined(GENERATING_DOCUMENTATION)
-};
-
-} // namespace asio
-
-ASIO_USES_ALLOCATOR(asio::executor)
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/executor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/executor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-#endif // ASIO_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor_work_guard.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor_work_guard.hpp
deleted file mode 100644
index 72787cc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/executor_work_guard.hpp
+++ /dev/null
@@ -1,362 +0,0 @@
-//
-// executor_work_guard.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXECUTOR_WORK_GUARD_HPP
-#define ASIO_EXECUTOR_WORK_GUARD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/associated_executor.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution.hpp"
-#include "asio/is_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
-#define ASIO_EXECUTOR_WORK_GUARD_DECL
-
-template <typename Executor, typename = void, typename = void>
-class executor_work_guard;
-
-#endif // !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// An object of type @c executor_work_guard controls ownership of outstanding
-/// executor work within a scope.
-template <typename Executor>
-class executor_work_guard
-{
-public:
-  /// The underlying executor type.
-  typedef Executor executor_type;
-
-  /// Constructs a @c executor_work_guard object for the specified executor.
-  /**
-   * Stores a copy of @c e and calls <tt>on_work_started()</tt> on it.
-   */
-  explicit executor_work_guard(const executor_type& e) noexcept;
-
-  /// Copy constructor.
-  executor_work_guard(const executor_work_guard& other) noexcept;
-
-  /// Move constructor.
-  executor_work_guard(executor_work_guard&& other) noexcept;
-
-  /// Destructor.
-  /**
-   * Unless the object has already been reset, or is in a moved-from state,
-   * calls <tt>on_work_finished()</tt> on the stored executor.
-   */
-  ~executor_work_guard();
-
-  /// Obtain the associated executor.
-  executor_type get_executor() const noexcept;
-
-  /// Whether the executor_work_guard object owns some outstanding work.
-  bool owns_work() const noexcept;
-
-  /// Indicate that the work is no longer outstanding.
-  /**
-   * Unless the object has already been reset, or is in a moved-from state,
-   * calls <tt>on_work_finished()</tt> on the stored executor.
-   */
-  void reset() noexcept;
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-class executor_work_guard<Executor,
-    enable_if_t<
-      is_executor<Executor>::value
-    >>
-{
-public:
-  typedef Executor executor_type;
-
-  explicit executor_work_guard(const executor_type& e) noexcept
-    : executor_(e),
-      owns_(true)
-  {
-    executor_.on_work_started();
-  }
-
-  executor_work_guard(const executor_work_guard& other) noexcept
-    : executor_(other.executor_),
-      owns_(other.owns_)
-  {
-    if (owns_)
-      executor_.on_work_started();
-  }
-
-  executor_work_guard(executor_work_guard&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_)),
-      owns_(other.owns_)
-  {
-    other.owns_ = false;
-  }
-
-  ~executor_work_guard()
-  {
-    if (owns_)
-      executor_.on_work_finished();
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  bool owns_work() const noexcept
-  {
-    return owns_;
-  }
-
-  void reset() noexcept
-  {
-    if (owns_)
-    {
-      executor_.on_work_finished();
-      owns_ = false;
-    }
-  }
-
-private:
-  // Disallow assignment.
-  executor_work_guard& operator=(const executor_work_guard&);
-
-  executor_type executor_;
-  bool owns_;
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-class executor_work_guard<Executor,
-    enable_if_t<
-      !is_executor<Executor>::value
-    >,
-    enable_if_t<
-      execution::is_executor<Executor>::value
-    >>
-{
-public:
-  typedef Executor executor_type;
-
-  explicit executor_work_guard(const executor_type& e) noexcept
-    : executor_(e),
-      owns_(true)
-  {
-    new (&work_) work_type(asio::prefer(executor_,
-          execution::outstanding_work.tracked));
-  }
-
-  executor_work_guard(const executor_work_guard& other) noexcept
-    : executor_(other.executor_),
-      owns_(other.owns_)
-  {
-    if (owns_)
-    {
-      new (&work_) work_type(asio::prefer(executor_,
-            execution::outstanding_work.tracked));
-    }
-  }
-
-  executor_work_guard(executor_work_guard&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_)),
-      owns_(other.owns_)
-  {
-    if (owns_)
-    {
-      new (&work_) work_type(
-          static_cast<work_type&&>(
-            *static_cast<work_type*>(
-              static_cast<void*>(&other.work_))));
-      other.owns_ = false;
-    }
-  }
-
-  ~executor_work_guard()
-  {
-    if (owns_)
-      static_cast<work_type*>(static_cast<void*>(&work_))->~work_type();
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  bool owns_work() const noexcept
-  {
-    return owns_;
-  }
-
-  void reset() noexcept
-  {
-    if (owns_)
-    {
-      static_cast<work_type*>(static_cast<void*>(&work_))->~work_type();
-      owns_ = false;
-    }
-  }
-
-private:
-  // Disallow assignment.
-  executor_work_guard& operator=(const executor_work_guard&);
-
-  typedef decay_t<
-      prefer_result_t<
-        const executor_type&,
-        execution::outstanding_work_t::tracked_t
-      >
-    > work_type;
-
-  executor_type executor_;
-  aligned_storage_t<sizeof(work_type), alignment_of<work_type>::value> work_;
-  bool owns_;
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-/// Create an @ref executor_work_guard object.
-/**
- * @param ex An executor.
- *
- * @returns A work guard constructed with the specified executor.
- */
-template <typename Executor>
-ASIO_NODISCARD inline executor_work_guard<Executor>
-make_work_guard(const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return executor_work_guard<Executor>(ex);
-}
-
-/// Create an @ref executor_work_guard object.
-/**
- * @param ctx An execution context, from which an executor will be obtained.
- *
- * @returns A work guard constructed with the execution context's executor,
- * obtained by performing <tt>ctx.get_executor()</tt>.
- */
-template <typename ExecutionContext>
-ASIO_NODISCARD inline
-executor_work_guard<typename ExecutionContext::executor_type>
-make_work_guard(ExecutionContext& ctx,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return executor_work_guard<typename ExecutionContext::executor_type>(
-      ctx.get_executor());
-}
-
-/// Create an @ref executor_work_guard object.
-/**
- * @param t An arbitrary object, such as a completion handler, for which the
- * associated executor will be obtained.
- *
- * @returns A work guard constructed with the associated executor of the object
- * @c t, which is obtained as if by calling <tt>get_associated_executor(t)</tt>.
- */
-template <typename T>
-ASIO_NODISCARD inline
-executor_work_guard<
-    typename constraint_t<
-      !is_executor<T>::value
-        && !execution::is_executor<T>::value
-        && !is_convertible<T&, execution_context&>::value,
-      associated_executor<T>
-    >::type>
-make_work_guard(const T& t)
-{
-  return executor_work_guard<associated_executor_t<T>>(
-      associated_executor<T>::get(t));
-}
-
-/// Create an @ref executor_work_guard object.
-/**
- * @param t An arbitrary object, such as a completion handler, for which the
- * associated executor will be obtained.
- *
- * @param ex An executor to be used as the candidate object when determining the
- * associated executor.
- *
- * @returns A work guard constructed with the associated executor of the object
- * @c t, which is obtained as if by calling <tt>get_associated_executor(t,
- * ex)</tt>.
- */
-template <typename T, typename Executor>
-ASIO_NODISCARD inline
-executor_work_guard<associated_executor_t<T, Executor>>
-make_work_guard(const T& t, const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return executor_work_guard<associated_executor_t<T, Executor>>(
-      associated_executor<T, Executor>::get(t, ex));
-}
-
-/// Create an @ref executor_work_guard object.
-/**
- * @param t An arbitrary object, such as a completion handler, for which the
- * associated executor will be obtained.
- *
- * @param ctx An execution context, from which an executor is obtained to use as
- * the candidate object for determining the associated executor.
- *
- * @returns A work guard constructed with the associated executor of the object
- * @c t, which is obtained as if by calling <tt>get_associated_executor(t,
- * ctx.get_executor())</tt>.
- */
-template <typename T, typename ExecutionContext>
-ASIO_NODISCARD inline executor_work_guard<
-  associated_executor_t<T, typename ExecutionContext::executor_type>>
-make_work_guard(const T& t, ExecutionContext& ctx,
-    constraint_t<
-      !is_executor<T>::value
-    > = 0,
-    constraint_t<
-      !execution::is_executor<T>::value
-    > = 0,
-    constraint_t<
-      !is_convertible<T&, execution_context&>::value
-    > = 0,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return executor_work_guard<
-    associated_executor_t<T, typename ExecutionContext::executor_type>>(
-      associated_executor<T, typename ExecutionContext::executor_type>::get(
-        t, ctx.get_executor()));
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXECUTOR_WORK_GUARD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/append.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/append.hpp
deleted file mode 100644
index 6a1f280..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/append.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// experimental/append.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_APPEND_HPP
-#define ASIO_EXPERIMENTAL_APPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/append.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-#if !defined(ASIO_NO_DEPRECATED)
-using asio::append_t;
-using asio::append;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_APPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_single.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_single.hpp
deleted file mode 100644
index 6282c14..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_single.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// experimental/as_single.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_AS_SINGLE_HPP
-#define ASIO_EXPERIMENTAL_AS_SINGLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-/// A @ref completion_token adapter used to specify that the completion handler
-/// arguments should be combined into a single argument.
-/**
- * The as_single_t class is used to indicate that any arguments to the
- * completion handler should be combined and passed as a single argument.
- * If there is already one argument, that argument is passed as-is. If
- * there is more than argument, the arguments are first moved into a
- * @c std::tuple and that tuple is then passed to the completion handler.
- */
-template <typename CompletionToken>
-class as_single_t
-{
-public:
-  /// Tag type used to prevent the "default" constructor from being used for
-  /// conversions.
-  struct default_constructor_tag {};
-
-  /// Default constructor.
-  /**
-   * This constructor is only valid if the underlying completion token is
-   * default constructible and move constructible. The underlying completion
-   * token is itself defaulted as an argument to allow it to capture a source
-   * location.
-   */
-  constexpr as_single_t(
-      default_constructor_tag = default_constructor_tag(),
-      CompletionToken token = CompletionToken())
-    : token_(static_cast<CompletionToken&&>(token))
-  {
-  }
-
-  /// Constructor.
-  template <typename T>
-  constexpr explicit as_single_t(
-      T&& completion_token)
-    : token_(static_cast<T&&>(completion_token))
-  {
-  }
-
-  /// Adapts an executor to add the @c as_single_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c as_single_t as the default completion token type.
-    typedef as_single_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    executor_with_default(const InnerExecutor& ex) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-
-    /// Convert the specified executor to the inner executor type, then use
-    /// that to construct the adapted executor.
-    template <typename OtherExecutor>
-    executor_with_default(const OtherExecutor& ex,
-        constraint_t<
-          is_convertible<OtherExecutor, InnerExecutor>::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c as_single_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c as_single_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-//private:
-  CompletionToken token_;
-};
-
-/// Adapt a @ref completion_token to specify that the completion handler
-/// arguments should be combined into a single argument.
-template <typename CompletionToken>
-ASIO_NODISCARD inline
-constexpr as_single_t<decay_t<CompletionToken>>
-as_single(CompletionToken&& completion_token)
-{
-  return as_single_t<decay_t<CompletionToken>>(
-      static_cast<CompletionToken&&>(completion_token));
-}
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/impl/as_single.hpp"
-
-#endif // ASIO_EXPERIMENTAL_AS_SINGLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_tuple.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_tuple.hpp
deleted file mode 100644
index 02f23f2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/as_tuple.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// experimental/as_tuple.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_AS_TUPLE_HPP
-#define ASIO_EXPERIMENTAL_AS_TUPLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/as_tuple.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-#if !defined(ASIO_NO_DEPRECATED)
-using asio::as_tuple_t;
-using asio::as_tuple;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_AS_TUPLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/awaitable_operators.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/awaitable_operators.hpp
deleted file mode 100644
index 45799da..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/awaitable_operators.hpp
+++ /dev/null
@@ -1,536 +0,0 @@
-//
-// experimental/awaitable_operators.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
-#define ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <optional>
-#include <stdexcept>
-#include <tuple>
-#include <variant>
-#include "asio/awaitable.hpp"
-#include "asio/co_spawn.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/experimental/deferred.hpp"
-#include "asio/experimental/parallel_group.hpp"
-#include "asio/multiple_exceptions.hpp"
-#include "asio/this_coro.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace awaitable_operators {
-namespace detail {
-
-template <typename T, typename Executor>
-awaitable<T, Executor> awaitable_wrap(awaitable<T, Executor> a,
-    constraint_t<is_constructible<T>::value>* = 0)
-{
-  return a;
-}
-
-template <typename T, typename Executor>
-awaitable<std::optional<T>, Executor> awaitable_wrap(awaitable<T, Executor> a,
-    constraint_t<!is_constructible<T>::value>* = 0)
-{
-  co_return std::optional<T>(co_await std::move(a));
-}
-
-template <typename T>
-T& awaitable_unwrap(conditional_t<true, T, void>& r,
-    constraint_t<is_constructible<T>::value>* = 0)
-{
-  return r;
-}
-
-template <typename T>
-T& awaitable_unwrap(std::optional<conditional_t<true, T, void>>& r,
-    constraint_t<!is_constructible<T>::value>* = 0)
-{
-  return *r;
-}
-
-} // namespace detail
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename Executor>
-awaitable<void, Executor> operator&&(
-    awaitable<void, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, ex1] =
-    co_await make_parallel_group(
-      co_spawn(ex, std::move(t), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return;
-}
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename U, typename Executor>
-awaitable<U, Executor> operator&&(
-    awaitable<void, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, std::move(t), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return std::move(detail::awaitable_unwrap<U>(r1));
-}
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename T, typename Executor>
-awaitable<T, Executor> operator&&(
-    awaitable<T, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return std::move(detail::awaitable_unwrap<T>(r0));
-}
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename T, typename U, typename Executor>
-awaitable<std::tuple<T, U>, Executor> operator&&(
-    awaitable<T, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return std::make_tuple(
-      std::move(detail::awaitable_unwrap<T>(r0)),
-      std::move(detail::awaitable_unwrap<U>(r1)));
-}
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename... T, typename Executor>
-awaitable<std::tuple<T..., std::monostate>, Executor> operator&&(
-    awaitable<std::tuple<T...>, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return std::move(detail::awaitable_unwrap<std::tuple<T...>>(r0));
-}
-
-/// Wait for both operations to succeed.
-/**
- * If one operations fails, the other is cancelled as the AND-condition can no
- * longer be satisfied.
- */
-template <typename... T, typename U, typename Executor>
-awaitable<std::tuple<T..., U>, Executor> operator&&(
-    awaitable<std::tuple<T...>, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_error(),
-      deferred
-    );
-
-  if (ex0 && ex1)
-    throw multiple_exceptions(ex0);
-  if (ex0)
-    std::rethrow_exception(ex0);
-  if (ex1)
-    std::rethrow_exception(ex1);
-  co_return std::tuple_cat(
-      std::move(detail::awaitable_unwrap<std::tuple<T...>>(r0)),
-      std::make_tuple(std::move(detail::awaitable_unwrap<U>(r1))));
-}
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename Executor>
-awaitable<std::variant<std::monostate, std::monostate>, Executor> operator||(
-    awaitable<void, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, ex1] =
-    co_await make_parallel_group(
-      co_spawn(ex, std::move(t), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return std::variant<std::monostate, std::monostate>{
-          std::in_place_index<0>};
-    if (!ex1)
-      co_return std::variant<std::monostate, std::monostate>{
-          std::in_place_index<1>};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<std::monostate, std::monostate>{
-          std::in_place_index<1>};
-    if (!ex0)
-      co_return std::variant<std::monostate, std::monostate>{
-          std::in_place_index<0>};
-    throw multiple_exceptions(ex1);
-  }
-}
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename U, typename Executor>
-awaitable<std::variant<std::monostate, U>, Executor> operator||(
-    awaitable<void, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, std::move(t), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return std::variant<std::monostate, U>{
-          std::in_place_index<0>};
-    if (!ex1)
-      co_return std::variant<std::monostate, U>{
-          std::in_place_index<1>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<std::monostate, U>{
-          std::in_place_index<1>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    if (!ex0)
-      co_return std::variant<std::monostate, U>{
-          std::in_place_index<0>};
-    throw multiple_exceptions(ex1);
-  }
-}
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename T, typename Executor>
-awaitable<std::variant<T, std::monostate>, Executor> operator||(
-    awaitable<T, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return std::variant<T, std::monostate>{
-          std::in_place_index<0>,
-          std::move(detail::awaitable_unwrap<T>(r0))};
-    if (!ex1)
-      co_return std::variant<T, std::monostate>{
-          std::in_place_index<1>};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<T, std::monostate>{
-          std::in_place_index<1>};
-    if (!ex0)
-      co_return std::variant<T, std::monostate>{
-          std::in_place_index<0>,
-          std::move(detail::awaitable_unwrap<T>(r0))};
-    throw multiple_exceptions(ex1);
-  }
-}
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename T, typename U, typename Executor>
-awaitable<std::variant<T, U>, Executor> operator||(
-    awaitable<T, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return std::variant<T, U>{
-          std::in_place_index<0>,
-          std::move(detail::awaitable_unwrap<T>(r0))};
-    if (!ex1)
-      co_return std::variant<T, U>{
-          std::in_place_index<1>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<T, U>{
-          std::in_place_index<1>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    if (!ex0)
-      co_return std::variant<T, U>{
-          std::in_place_index<0>,
-          std::move(detail::awaitable_unwrap<T>(r0))};
-    throw multiple_exceptions(ex1);
-  }
-}
-
-namespace detail {
-
-template <typename... T>
-struct widen_variant
-{
-  template <std::size_t I, typename SourceVariant>
-  static std::variant<T...> call(SourceVariant& source)
-  {
-    if (source.index() == I)
-      return std::variant<T...>{
-          std::in_place_index<I>, std::move(std::get<I>(source))};
-    else if constexpr (I + 1 < std::variant_size_v<SourceVariant>)
-      return call<I + 1>(source);
-    else
-      throw std::logic_error("empty variant");
-  }
-};
-
-} // namespace detail
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename... T, typename Executor>
-awaitable<std::variant<T..., std::monostate>, Executor> operator||(
-    awaitable<std::variant<T...>, Executor> t, awaitable<void, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, std::move(u), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  using widen = detail::widen_variant<T..., std::monostate>;
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return widen::template call<0>(
-          detail::awaitable_unwrap<std::variant<T...>>(r0));
-    if (!ex1)
-      co_return std::variant<T..., std::monostate>{
-          std::in_place_index<sizeof...(T)>};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<T..., std::monostate>{
-          std::in_place_index<sizeof...(T)>};
-    if (!ex0)
-      co_return widen::template call<0>(
-          detail::awaitable_unwrap<std::variant<T...>>(r0));
-    throw multiple_exceptions(ex1);
-  }
-}
-
-/// Wait for one operation to succeed.
-/**
- * If one operations succeeds, the other is cancelled as the OR-condition is
- * already satisfied.
- */
-template <typename... T, typename U, typename Executor>
-awaitable<std::variant<T..., U>, Executor> operator||(
-    awaitable<std::variant<T...>, Executor> t, awaitable<U, Executor> u)
-{
-  auto ex = co_await this_coro::executor;
-
-  auto [order, ex0, r0, ex1, r1] =
-    co_await make_parallel_group(
-      co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-      co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred)
-    ).async_wait(
-      wait_for_one_success(),
-      deferred
-    );
-
-  using widen = detail::widen_variant<T..., U>;
-  if (order[0] == 0)
-  {
-    if (!ex0)
-      co_return widen::template call<0>(
-          detail::awaitable_unwrap<std::variant<T...>>(r0));
-    if (!ex1)
-      co_return std::variant<T..., U>{
-          std::in_place_index<sizeof...(T)>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    throw multiple_exceptions(ex0);
-  }
-  else
-  {
-    if (!ex1)
-      co_return std::variant<T..., U>{
-          std::in_place_index<sizeof...(T)>,
-          std::move(detail::awaitable_unwrap<U>(r1))};
-    if (!ex0)
-      co_return widen::template call<0>(
-          detail::awaitable_unwrap<std::variant<T...>>(r0));
-    throw multiple_exceptions(ex1);
-  }
-}
-
-} // namespace awaitable_operators
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_AWAITABLE_OPERATORS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_channel.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_channel.hpp
deleted file mode 100644
index 112ab45..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_channel.hpp
+++ /dev/null
@@ -1,514 +0,0 @@
-//
-// experimental/basic_channel.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
-#define ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/null_mutex.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/experimental/detail/channel_send_functions.hpp"
-#include "asio/experimental/detail/channel_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-} // namespace detail
-
-/// A channel for messages.
-/**
- * The basic_channel class template is used for sending messages between
- * different parts of the same application. A <em>message</em> is defined as a
- * collection of arguments to be passed to a completion handler, and the set of
- * messages supported by a channel is specified by its @c Traits and
- * <tt>Signatures...</tt> template parameters. Messages may be sent and received
- * using asynchronous or non-blocking synchronous operations.
- *
- * Unless customising the traits, applications will typically use the @c
- * experimental::channel alias template. For example:
- * @code void send_loop(int i, steady_timer& timer,
- *     channel<void(error_code, int)>& ch)
- * {
- *   if (i < 10)
- *   {
- *     timer.expires_after(chrono::seconds(1));
- *     timer.async_wait(
- *         [i, &timer, &ch](error_code error)
- *         {
- *           if (!error)
- *           {
- *             ch.async_send(error_code(), i,
- *                 [i, &timer, &ch](error_code error)
- *                 {
- *                   if (!error)
- *                   {
- *                     send_loop(i + 1, timer, ch);
- *                   }
- *                 });
- *           }
- *         });
- *   }
- *   else
- *   {
- *     ch.close();
- *   }
- * }
- *
- * void receive_loop(channel<void(error_code, int)>& ch)
- * {
- *   ch.async_receive(
- *       [&ch](error_code error, int i)
- *       {
- *         if (!error)
- *         {
- *           std::cout << "Received " << i << "\n";
- *           receive_loop(ch);
- *         }
- *       });
- * } @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * The basic_channel class template is not thread-safe, and would typically be
- * used for passing messages between application code that runs on the same
- * thread or in the same strand. Consider using @ref basic_concurrent_channel,
- * and its alias template @c experimental::concurrent_channel, to pass messages
- * between code running in different threads.
- */
-template <typename Executor, typename Traits, typename... Signatures>
-class basic_channel
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::channel_send_functions<
-      basic_channel<Executor, Traits, Signatures...>,
-      Executor, Signatures...>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-private:
-  class initiate_async_send;
-  class initiate_async_receive;
-  typedef detail::channel_service<asio::detail::null_mutex> service_type;
-  typedef typename service_type::template implementation_type<
-      Traits, Signatures...>::payload_type payload_type;
-
-  template <typename... PayloadSignatures,
-      ASIO_COMPLETION_TOKEN_FOR(PayloadSignatures...) CompletionToken>
-  auto do_async_receive(
-      asio::detail::completion_payload<PayloadSignatures...>*,
-      CompletionToken&& token)
-    -> decltype(
-        async_initiate<CompletionToken, PayloadSignatures...>(
-          declval<initiate_async_receive>(), token))
-  {
-    return async_initiate<CompletionToken, PayloadSignatures...>(
-        initiate_async_receive(this), token);
-  }
-
-public:
-  /// The type of the executor associated with the channel.
-  typedef Executor executor_type;
-
-  /// Rebinds the channel type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The channel type when rebound to the specified executor.
-    typedef basic_channel<Executor1, Traits, Signatures...> other;
-  };
-
-  /// The traits type associated with the channel.
-  typedef typename Traits::template rebind<Signatures...>::other traits_type;
-
-  /// Construct a basic_channel.
-  /**
-   * This constructor creates and channel.
-   *
-   * @param ex The I/O executor that the channel will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the channel.
-   *
-   * @param max_buffer_size The maximum number of messages that may be buffered
-   * in the channel.
-   */
-  basic_channel(const executor_type& ex, std::size_t max_buffer_size = 0)
-    : service_(&asio::use_service<service_type>(
-            basic_channel::get_context(ex))),
-      impl_(),
-      executor_(ex)
-  {
-    service_->construct(impl_, max_buffer_size);
-  }
-
-  /// Construct and open a basic_channel.
-  /**
-   * This constructor creates and opens a channel.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the channel will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the channel.
-   *
-   * @param max_buffer_size The maximum number of messages that may be buffered
-   * in the channel.
-   */
-  template <typename ExecutionContext>
-  basic_channel(ExecutionContext& context, std::size_t max_buffer_size = 0,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : service_(&asio::use_service<service_type>(context)),
-      impl_(),
-      executor_(context.get_executor())
-  {
-    service_->construct(impl_, max_buffer_size);
-  }
-
-  /// Move-construct a basic_channel from another.
-  /**
-   * This constructor moves a channel from one object to another.
-   *
-   * @param other The other basic_channel object from which the move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_channel(const executor_type&) constructor.
-   */
-  basic_channel(basic_channel&& other)
-    : service_(other.service_),
-      executor_(other.executor_)
-  {
-    service_->move_construct(impl_, other.impl_);
-  }
-
-  /// Move-assign a basic_channel from another.
-  /**
-   * This assignment operator moves a channel from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_channel object from which the move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_channel(const executor_type&)
-   * constructor.
-   */
-  basic_channel& operator=(basic_channel&& other)
-  {
-    if (this != &other)
-    {
-      service_->move_assign(impl_, *other.service_, other.impl_);
-      executor_.~executor_type();
-      new (&executor_) executor_type(other.executor_);
-      service_ = other.service_;
-    }
-    return *this;
-  }
-
-  // All channels have access to each other's implementations.
-  template <typename, typename, typename...>
-  friend class basic_channel;
-
-  /// Move-construct a basic_channel from another.
-  /**
-   * This constructor moves a channel from one object to another.
-   *
-   * @param other The other basic_channel object from which the move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_channel(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_channel(
-      basic_channel<Executor1, Traits, Signatures...>&& other,
-      constraint_t<
-          is_convertible<Executor1, Executor>::value
-      > = 0)
-    : service_(other.service_),
-      executor_(other.executor_)
-  {
-    service_->move_construct(impl_, other.impl_);
-  }
-
-  /// Move-assign a basic_channel from another.
-  /**
-   * This assignment operator moves a channel from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_channel object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_channel(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_channel&
-  > operator=(basic_channel<Executor1, Traits, Signatures...>&& other)
-  {
-    if (this != &other)
-    {
-      service_->move_assign(impl_, *other.service_, other.impl_);
-      executor_.~executor_type();
-      new (&executor_) executor_type(other.executor_);
-      service_ = other.service_;
-    }
-    return *this;
-  }
-
-  /// Destructor.
-  ~basic_channel()
-  {
-    service_->destroy(impl_);
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return executor_;
-  }
-
-  /// Get the capacity of the channel's buffer.
-  std::size_t capacity() noexcept
-  {
-    return service_->capacity(impl_);
-  }
-
-  /// Determine whether the channel is open.
-  bool is_open() const noexcept
-  {
-    return service_->is_open(impl_);
-  }
-
-  /// Reset the channel to its initial state.
-  void reset()
-  {
-    service_->reset(impl_);
-  }
-
-  /// Close the channel.
-  void close()
-  {
-    service_->close(impl_);
-  }
-
-  /// Cancel all asynchronous operations waiting on the channel.
-  /**
-   * All outstanding send operations will complete with the error
-   * @c asio::experimental::error::channel_cancelled. Outstanding receive
-   * operations complete with the result as determined by the channel traits.
-   */
-  void cancel()
-  {
-    service_->cancel(impl_);
-  }
-
-  /// Determine whether a message can be received without blocking.
-  bool ready() const noexcept
-  {
-    return service_->ready(impl_);
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-
-  /// Try to send a message without blocking.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename... Args>
-  bool try_send(Args&&... args);
-
-  /// Try to send a message without blocking, using dispatch semantics to call
-  /// the receive operation's completion handler.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * The receive operation's completion handler may be called from inside this
-   * function.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename... Args>
-  bool try_send_via_dispatch(Args&&... args);
-
-  /// Try to send a number of messages without blocking.
-  /**
-   * @returns The number of messages that were sent.
-   */
-  template <typename... Args>
-  std::size_t try_send_n(std::size_t count, Args&&... args);
-
-  /// Try to send a number of messages without blocking, using dispatch
-  /// semantics to call the receive operations' completion handlers.
-  /**
-   * The receive operations' completion handlers may be called from inside this
-   * function.
-   *
-   * @returns The number of messages that were sent.
-   */
-  template <typename... Args>
-  std::size_t try_send_n_via_dispatch(std::size_t count, Args&&... args);
-
-  /// Asynchronously send a message.
-  /**
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   */
-  template <typename... Args,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        CompletionToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  auto async_send(Args&&... args,
-      CompletionToken&& token);
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Try to receive a message without blocking.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename Handler>
-  bool try_receive(Handler&& handler)
-  {
-    return service_->try_receive(impl_, static_cast<Handler&&>(handler));
-  }
-
-  /// Asynchronously receive a message.
-  /**
-   * @par Completion Signature
-   * As determined by the <tt>Signatures...</tt> template parameter and the
-   * channel traits.
-   */
-  template <typename CompletionToken
-      ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  auto async_receive(
-      CompletionToken&& token
-        ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
-#if !defined(GENERATING_DOCUMENTATION)
-    -> decltype(
-        this->do_async_receive(static_cast<payload_type*>(0),
-          static_cast<CompletionToken&&>(token)))
-#endif // !defined(GENERATING_DOCUMENTATION)
-  {
-    return this->do_async_receive(static_cast<payload_type*>(0),
-        static_cast<CompletionToken&&>(token));
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_channel(const basic_channel&) = delete;
-  basic_channel& operator=(const basic_channel&) = delete;
-
-  template <typename, typename, typename...>
-  friend class detail::channel_send_functions;
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<execution::is_executor<T>::value>* = 0)
-  {
-    return asio::query(t, execution::context);
-  }
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<!execution::is_executor<T>::value>* = 0)
-  {
-    return t.context();
-  }
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_channel* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename SendHandler>
-    void operator()(SendHandler&& handler,
-        payload_type&& payload) const
-    {
-      asio::detail::non_const_lvalue<SendHandler> handler2(handler);
-      self_->service_->async_send(self_->impl_,
-          static_cast<payload_type&&>(payload),
-          handler2.value, self_->get_executor());
-    }
-
-  private:
-    basic_channel* self_;
-  };
-
-  class initiate_async_receive
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive(basic_channel* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReceiveHandler>
-    void operator()(ReceiveHandler&& handler) const
-    {
-      asio::detail::non_const_lvalue<ReceiveHandler> handler2(handler);
-      self_->service_->async_receive(self_->impl_,
-          handler2.value, self_->get_executor());
-    }
-
-  private:
-    basic_channel* self_;
-  };
-
-  // The service associated with the I/O object.
-  service_type* service_;
-
-  // The underlying implementation of the I/O object.
-  typename service_type::template implementation_type<
-      Traits, Signatures...> impl_;
-
-  // The associated executor.
-  Executor executor_;
-};
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_BASIC_CHANNEL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_concurrent_channel.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_concurrent_channel.hpp
deleted file mode 100644
index d2d732d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/basic_concurrent_channel.hpp
+++ /dev/null
@@ -1,514 +0,0 @@
-//
-// experimental/basic_concurrent_channel.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
-#define ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/experimental/detail/channel_send_functions.hpp"
-#include "asio/experimental/detail/channel_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-} // namespace detail
-
-/// A channel for messages.
-/**
- * The basic_concurrent_channel class template is used for sending messages
- * between different parts of the same application. A <em>message</em> is
- * defined as a collection of arguments to be passed to a completion handler,
- * and the set of messages supported by a channel is specified by its @c Traits
- * and <tt>Signatures...</tt> template parameters. Messages may be sent and
- * received using asynchronous or non-blocking synchronous operations.
- *
- * Unless customising the traits, applications will typically use the @c
- * experimental::concurrent_channel alias template. For example:
- * @code void send_loop(int i, steady_timer& timer,
- *     concurrent_channel<void(error_code, int)>& ch)
- * {
- *   if (i < 10)
- *   {
- *     timer.expires_after(chrono::seconds(1));
- *     timer.async_wait(
- *         [i, &timer, &ch](error_code error)
- *         {
- *           if (!error)
- *           {
- *             ch.async_send(error_code(), i,
- *                 [i, &timer, &ch](error_code error)
- *                 {
- *                   if (!error)
- *                   {
- *                     send_loop(i + 1, timer, ch);
- *                   }
- *                 });
- *           }
- *         });
- *   }
- *   else
- *   {
- *     ch.close();
- *   }
- * }
- *
- * void receive_loop(concurent_channel<void(error_code, int)>& ch)
- * {
- *   ch.async_receive(
- *       [&ch](error_code error, int i)
- *       {
- *         if (!error)
- *         {
- *           std::cout << "Received " << i << "\n";
- *           receive_loop(ch);
- *         }
- *       });
- * } @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * The basic_concurrent_channel class template is thread-safe, and would
- * typically be used for passing messages between application code that run on
- * different threads. Consider using @ref basic_channel, and its alias template
- * @c experimental::channel, to pass messages between code running in a single
- * thread or on the same strand.
- */
-template <typename Executor, typename Traits, typename... Signatures>
-class basic_concurrent_channel
-#if !defined(GENERATING_DOCUMENTATION)
-  : public detail::channel_send_functions<
-      basic_concurrent_channel<Executor, Traits, Signatures...>,
-      Executor, Signatures...>
-#endif // !defined(GENERATING_DOCUMENTATION)
-{
-private:
-  class initiate_async_send;
-  class initiate_async_receive;
-  typedef detail::channel_service<asio::detail::mutex> service_type;
-  typedef typename service_type::template implementation_type<
-      Traits, Signatures...>::payload_type payload_type;
-
-  template <typename... PayloadSignatures,
-      ASIO_COMPLETION_TOKEN_FOR(PayloadSignatures...) CompletionToken>
-  auto do_async_receive(
-      asio::detail::completion_payload<PayloadSignatures...>*,
-      CompletionToken&& token)
-    -> decltype(
-        async_initiate<CompletionToken, PayloadSignatures...>(
-          declval<initiate_async_receive>(), token))
-  {
-    return async_initiate<CompletionToken, PayloadSignatures...>(
-        initiate_async_receive(this), token);
-  }
-
-public:
-  /// The type of the executor associated with the channel.
-  typedef Executor executor_type;
-
-  /// Rebinds the channel type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The channel type when rebound to the specified executor.
-    typedef basic_concurrent_channel<Executor1, Traits, Signatures...> other;
-  };
-
-  /// The traits type associated with the channel.
-  typedef typename Traits::template rebind<Signatures...>::other traits_type;
-
-  /// Construct a basic_concurrent_channel.
-  /**
-   * This constructor creates and channel.
-   *
-   * @param ex The I/O executor that the channel will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the channel.
-   *
-   * @param max_buffer_size The maximum number of messages that may be buffered
-   * in the channel.
-   */
-  basic_concurrent_channel(const executor_type& ex,
-      std::size_t max_buffer_size = 0)
-    : service_(&asio::use_service<service_type>(
-            basic_concurrent_channel::get_context(ex))),
-      impl_(),
-      executor_(ex)
-  {
-    service_->construct(impl_, max_buffer_size);
-  }
-
-  /// Construct and open a basic_concurrent_channel.
-  /**
-   * This constructor creates and opens a channel.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the channel will use, by default, to dispatch handlers for any asynchronous
-   * operations performed on the channel.
-   *
-   * @param max_buffer_size The maximum number of messages that may be buffered
-   * in the channel.
-   */
-  template <typename ExecutionContext>
-  basic_concurrent_channel(ExecutionContext& context,
-      std::size_t max_buffer_size = 0,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : service_(&asio::use_service<service_type>(context)),
-      impl_(),
-      executor_(context.get_executor())
-  {
-    service_->construct(impl_, max_buffer_size);
-  }
-
-  /// Move-construct a basic_concurrent_channel from another.
-  /**
-   * This constructor moves a channel from one object to another.
-   *
-   * @param other The other basic_concurrent_channel object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_concurrent_channel(const executor_type&)
-   * constructor.
-   */
-  basic_concurrent_channel(basic_concurrent_channel&& other)
-    : service_(other.service_),
-      executor_(other.executor_)
-  {
-    service_->move_construct(impl_, other.impl_);
-  }
-
-  /// Move-assign a basic_concurrent_channel from another.
-  /**
-   * This assignment operator moves a channel from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_concurrent_channel object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_concurrent_channel(const executor_type&)
-   * constructor.
-   */
-  basic_concurrent_channel& operator=(basic_concurrent_channel&& other)
-  {
-    if (this != &other)
-    {
-      service_->move_assign(impl_, *other.service_, other.impl_);
-      executor_.~executor_type();
-      new (&executor_) executor_type(other.executor_);
-      service_ = other.service_;
-    }
-    return *this;
-  }
-
-  // All channels have access to each other's implementations.
-  template <typename, typename, typename...>
-  friend class basic_concurrent_channel;
-
-  /// Move-construct a basic_concurrent_channel from another.
-  /**
-   * This constructor moves a channel from one object to another.
-   *
-   * @param other The other basic_concurrent_channel object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_concurrent_channel(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_concurrent_channel(
-      basic_concurrent_channel<Executor1, Traits, Signatures...>&& other,
-      constraint_t<
-          is_convertible<Executor1, Executor>::value
-      > = 0)
-    : service_(other.service_),
-      executor_(other.executor_)
-  {
-    service_->move_construct(impl_, other.impl_);
-  }
-
-  /// Move-assign a basic_concurrent_channel from another.
-  /**
-   * This assignment operator moves a channel from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_concurrent_channel object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_concurrent_channel(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_concurrent_channel&
-  > operator=(
-      basic_concurrent_channel<Executor1, Traits, Signatures...>&& other)
-  {
-    if (this != &other)
-    {
-      service_->move_assign(impl_, *other.service_, other.impl_);
-      executor_.~executor_type();
-      new (&executor_) executor_type(other.executor_);
-      service_ = other.service_;
-    }
-    return *this;
-  }
-
-  /// Destructor.
-  ~basic_concurrent_channel()
-  {
-    service_->destroy(impl_);
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return executor_;
-  }
-
-  /// Get the capacity of the channel's buffer.
-  std::size_t capacity() noexcept
-  {
-    return service_->capacity(impl_);
-  }
-
-  /// Determine whether the channel is open.
-  bool is_open() const noexcept
-  {
-    return service_->is_open(impl_);
-  }
-
-  /// Reset the channel to its initial state.
-  void reset()
-  {
-    service_->reset(impl_);
-  }
-
-  /// Close the channel.
-  void close()
-  {
-    service_->close(impl_);
-  }
-
-  /// Cancel all asynchronous operations waiting on the channel.
-  /**
-   * All outstanding send operations will complete with the error
-   * @c asio::experimental::error::channel_cancelled. Outstanding receive
-   * operations complete with the result as determined by the channel traits.
-   */
-  void cancel()
-  {
-    service_->cancel(impl_);
-  }
-
-  /// Determine whether a message can be received without blocking.
-  bool ready() const noexcept
-  {
-    return service_->ready(impl_);
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-
-  /// Try to send a message without blocking.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename... Args>
-  bool try_send(Args&&... args);
-
-  /// Try to send a message without blocking, using dispatch semantics to call
-  /// the receive operation's completion handler.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * The receive operation's completion handler may be called from inside this
-   * function.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename... Args>
-  bool try_send_via_dispatch(Args&&... args);
-
-  /// Try to send a number of messages without blocking.
-  /**
-   * @returns The number of messages that were sent.
-   */
-  template <typename... Args>
-  std::size_t try_send_n(std::size_t count, Args&&... args);
-
-  /// Try to send a number of messages without blocking, using dispatch
-  /// semantics to call the receive operations' completion handlers.
-  /**
-   * The receive operations' completion handlers may be called from inside this
-   * function.
-   *
-   * @returns The number of messages that were sent.
-   */
-  template <typename... Args>
-  std::size_t try_send_n_via_dispatch(std::size_t count, Args&&... args);
-
-  /// Asynchronously send a message.
-  template <typename... Args,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        CompletionToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  auto async_send(Args&&... args,
-      CompletionToken&& token);
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// Try to receive a message without blocking.
-  /**
-   * Fails if the buffer is full and there are no waiting receive operations.
-   *
-   * @returns @c true on success, @c false on failure.
-   */
-  template <typename Handler>
-  bool try_receive(Handler&& handler)
-  {
-    return service_->try_receive(impl_, static_cast<Handler&&>(handler));
-  }
-
-  /// Asynchronously receive a message.
-  template <typename CompletionToken
-      ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  auto async_receive(
-      CompletionToken&& token
-        ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
-#if !defined(GENERATING_DOCUMENTATION)
-    -> decltype(
-        this->do_async_receive(static_cast<payload_type*>(0),
-          static_cast<CompletionToken&&>(token)))
-#endif // !defined(GENERATING_DOCUMENTATION)
-  {
-    return this->do_async_receive(static_cast<payload_type*>(0),
-        static_cast<CompletionToken&&>(token));
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_concurrent_channel(
-      const basic_concurrent_channel&) = delete;
-  basic_concurrent_channel& operator=(
-      const basic_concurrent_channel&) = delete;
-
-  template <typename, typename, typename...>
-  friend class detail::channel_send_functions;
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<execution::is_executor<T>::value>* = 0)
-  {
-    return asio::query(t, execution::context);
-  }
-
-  // Helper function to get an executor's context.
-  template <typename T>
-  static execution_context& get_context(const T& t,
-      enable_if_t<!execution::is_executor<T>::value>* = 0)
-  {
-    return t.context();
-  }
-
-  class initiate_async_send
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_send(basic_concurrent_channel* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename SendHandler>
-    void operator()(SendHandler&& handler,
-        payload_type&& payload) const
-    {
-      asio::detail::non_const_lvalue<SendHandler> handler2(handler);
-      self_->service_->async_send(self_->impl_,
-          static_cast<payload_type&&>(payload),
-          handler2.value, self_->get_executor());
-    }
-
-  private:
-    basic_concurrent_channel* self_;
-  };
-
-  class initiate_async_receive
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_receive(basic_concurrent_channel* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReceiveHandler>
-    void operator()(ReceiveHandler&& handler) const
-    {
-      asio::detail::non_const_lvalue<ReceiveHandler> handler2(handler);
-      self_->service_->async_receive(self_->impl_,
-          handler2.value, self_->get_executor());
-    }
-
-  private:
-    basic_concurrent_channel* self_;
-  };
-
-  // The service associated with the I/O object.
-  service_type* service_;
-
-  // The underlying implementation of the I/O object.
-  typename service_type::template implementation_type<
-      Traits, Signatures...> impl_;
-
-  // The associated executor.
-  Executor executor_;
-};
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_BASIC_CONCURRENT_CHANNEL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/cancellation_condition.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/cancellation_condition.hpp
deleted file mode 100644
index 6b1b46d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/cancellation_condition.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// experimental/cancellation_condition.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
-#define ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-#include "asio/cancellation_type.hpp"
-#include "asio/error_code.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-/// Wait for all operations to complete.
-class wait_for_all
-{
-public:
-  template <typename... Args>
-  constexpr cancellation_type_t operator()(Args&&...) const noexcept
-  {
-    return cancellation_type::none;
-  }
-};
-
-/// Wait until an operation completes, then cancel the others.
-class wait_for_one
-{
-public:
-  constexpr explicit wait_for_one(
-      cancellation_type_t cancel_type = cancellation_type::all)
-    : cancel_type_(cancel_type)
-  {
-  }
-
-  template <typename... Args>
-  constexpr cancellation_type_t operator()(Args&&...) const noexcept
-  {
-    return cancel_type_;
-  }
-
-private:
-  cancellation_type_t cancel_type_;
-};
-
-/// Wait until an operation completes without an error, then cancel the others.
-/**
- * If no operation completes without an error, waits for completion of all
- * operations.
- */
-class wait_for_one_success
-{
-public:
-  constexpr explicit wait_for_one_success(
-      cancellation_type_t cancel_type = cancellation_type::all)
-    : cancel_type_(cancel_type)
-  {
-  }
-
-  constexpr cancellation_type_t
-  operator()() const noexcept
-  {
-    return cancel_type_;
-  }
-
-  template <typename E, typename... Args>
-  constexpr constraint_t<
-    !is_same<decay_t<E>, asio::error_code>::value
-      && !is_same<decay_t<E>, std::exception_ptr>::value,
-    cancellation_type_t
-  > operator()(const E&, Args&&...) const noexcept
-  {
-    return cancel_type_;
-  }
-
-  template <typename E, typename... Args>
-  constexpr constraint_t<
-      is_same<decay_t<E>, asio::error_code>::value
-        || is_same<decay_t<E>, std::exception_ptr>::value,
-      cancellation_type_t
-  > operator()(const E& e, Args&&...) const noexcept
-  {
-    return !!e ? cancellation_type::none : cancel_type_;
-  }
-
-private:
-  cancellation_type_t cancel_type_;
-};
-
-/// Wait until an operation completes with an error, then cancel the others.
-/**
- * If no operation completes with an error, waits for completion of all
- * operations.
- */
-class wait_for_one_error
-{
-public:
-  constexpr explicit wait_for_one_error(
-      cancellation_type_t cancel_type = cancellation_type::all)
-    : cancel_type_(cancel_type)
-  {
-  }
-
-  constexpr cancellation_type_t operator()() const noexcept
-  {
-    return cancellation_type::none;
-  }
-
-  template <typename E, typename... Args>
-  constexpr constraint_t<
-    !is_same<decay_t<E>, asio::error_code>::value
-      && !is_same<decay_t<E>, std::exception_ptr>::value,
-    cancellation_type_t
-  > operator()(const E&, Args&&...) const noexcept
-  {
-    return cancellation_type::none;
-  }
-
-  template <typename E, typename... Args>
-  constexpr constraint_t<
-      is_same<decay_t<E>, asio::error_code>::value
-        || is_same<decay_t<E>, std::exception_ptr>::value,
-      cancellation_type_t
-  > operator()(const E& e, Args&&...) const noexcept
-  {
-    return !!e ? cancel_type_ : cancellation_type::none;
-  }
-
-private:
-  cancellation_type_t cancel_type_;
-};
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CANCELLATION_CONDITION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel.hpp
deleted file mode 100644
index c808bb4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-// experimental/channel.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CHANNEL_HPP
-#define ASIO_EXPERIMENTAL_CHANNEL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/experimental/basic_channel.hpp"
-#include "asio/experimental/channel_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename ExecutorOrSignature, typename = void>
-struct channel_type
-{
-  template <typename... Signatures>
-  struct inner
-  {
-    typedef basic_channel<any_io_executor, channel_traits<>,
-        ExecutorOrSignature, Signatures...> type;
-  };
-};
-
-template <typename ExecutorOrSignature>
-struct channel_type<ExecutorOrSignature,
-    enable_if_t<
-      is_executor<ExecutorOrSignature>::value
-        || execution::is_executor<ExecutorOrSignature>::value
-    >>
-{
-  template <typename... Signatures>
-  struct inner
-  {
-    typedef basic_channel<ExecutorOrSignature,
-        channel_traits<>, Signatures...> type;
-  };
-};
-
-} // namespace detail
-
-/// Template type alias for common use of channel.
-template <typename ExecutorOrSignature, typename... Signatures>
-using channel = typename detail::channel_type<
-    ExecutorOrSignature>::template inner<Signatures...>::type;
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CHANNEL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_error.hpp
deleted file mode 100644
index dd41975..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_error.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// experimental/channel_error.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
-#define ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace error {
-
-enum channel_errors
-{
-  /// The channel was closed.
-  channel_closed = 1,
-
-  /// The channel was cancelled.
-  channel_cancelled = 2
-};
-
-extern ASIO_DECL
-const asio::error_category& get_channel_category();
-
-static const asio::error_category&
-  channel_category ASIO_UNUSED_VARIABLE
-  = asio::experimental::error::get_channel_category();
-
-} // namespace error
-namespace channel_errc {
-  // Simulates a scoped enum.
-  using error::channel_closed;
-  using error::channel_cancelled;
-} // namespace channel_errc
-} // namespace experimental
-} // namespace asio
-
-namespace std {
-
-template<> struct is_error_code_enum<
-    asio::experimental::error::channel_errors>
-{
-  static const bool value = true;
-};
-
-} // namespace std
-
-namespace asio {
-namespace experimental {
-namespace error {
-
-inline asio::error_code make_error_code(channel_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_channel_category());
-}
-
-} // namespace error
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/experimental/impl/channel_error.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_EXPERIMENTAL_CHANNEL_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_traits.hpp
deleted file mode 100644
index bccff98..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/channel_traits.hpp
+++ /dev/null
@@ -1,301 +0,0 @@
-//
-// experimental/channel_traits.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
-#define ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <deque>
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/experimental/channel_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-template <typename... Signatures>
-struct channel_traits
-{
-  /// Rebind the traits to a new set of signatures.
-  /**
-   * This nested structure must have a single nested type @c other that
-   * aliases a traits type with the specified set of signatures.
-   */
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef user_defined other;
-  };
-
-  /// Determine the container for the specified elements.
-  /**
-   * This nested structure must have a single nested type @c other that
-   * aliases a container type for the specified element type.
-   */
-  template <typename Element>
-  struct container
-  {
-    typedef user_defined type;
-  };
-
-  /// The signature of a channel cancellation notification.
-  typedef void receive_cancelled_signature(...);
-
-  /// Invoke the specified handler with a cancellation notification.
-  template <typename F>
-  static void invoke_receive_cancelled(F f);
-
-  /// The signature of a channel closed notification.
-  typedef void receive_closed_signature(...);
-
-  /// Invoke the specified handler with a closed notification.
-  template <typename F>
-  static void invoke_receive_closed(F f);
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-/// Traits used for customising channel behaviour.
-template <typename... Signatures>
-struct channel_traits
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-};
-
-template <typename R>
-struct channel_traits<R(asio::error_code)>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(e);
-  }
-
-  typedef R receive_closed_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(e);
-  }
-};
-
-template <typename R, typename... Args, typename... Signatures>
-struct channel_traits<R(asio::error_code, Args...), Signatures...>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(asio::error_code, Args...);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(e, decay_t<Args>()...);
-  }
-
-  typedef R receive_closed_signature(asio::error_code, Args...);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(e, decay_t<Args>()...);
-  }
-};
-
-template <typename R>
-struct channel_traits<R(std::exception_ptr)>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(std::exception_ptr);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(
-        std::make_exception_ptr(asio::system_error(e)));
-  }
-
-  typedef R receive_closed_signature(std::exception_ptr);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(
-        std::make_exception_ptr(asio::system_error(e)));
-  }
-};
-
-template <typename R, typename... Args, typename... Signatures>
-struct channel_traits<R(std::exception_ptr, Args...), Signatures...>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(std::exception_ptr, Args...);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(
-        std::make_exception_ptr(asio::system_error(e)),
-        decay_t<Args>()...);
-  }
-
-  typedef R receive_closed_signature(std::exception_ptr, Args...);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(
-        std::make_exception_ptr(asio::system_error(e)),
-        decay_t<Args>()...);
-  }
-};
-
-template <typename R>
-struct channel_traits<R()>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(e);
-  }
-
-  typedef R receive_closed_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(e);
-  }
-};
-
-template <typename R, typename T>
-struct channel_traits<R(T)>
-{
-  template <typename... NewSignatures>
-  struct rebind
-  {
-    typedef channel_traits<NewSignatures...> other;
-  };
-
-  template <typename Element>
-  struct container
-  {
-    typedef std::deque<Element> type;
-  };
-
-  typedef R receive_cancelled_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_cancelled(F f)
-  {
-    const asio::error_code e = error::channel_cancelled;
-    static_cast<F&&>(f)(e);
-  }
-
-  typedef R receive_closed_signature(asio::error_code);
-
-  template <typename F>
-  static void invoke_receive_closed(F f)
-  {
-    const asio::error_code e = error::channel_closed;
-    static_cast<F&&>(f)(e);
-  }
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CHANNEL_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_composed.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_composed.hpp
deleted file mode 100644
index 89b84f1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_composed.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// experimental/co_composed.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CO_COMPOSED_HPP
-#define ASIO_EXPERIMENTAL_CO_COMPOSED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/co_composed.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-using asio::co_composed;
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CO_COMPOSED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_spawn.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_spawn.hpp
deleted file mode 100644
index 8ef5928..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/co_spawn.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// experimental/co_spawn.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef ASIO_EXPERIMENTAL_CO_SPAWN_HPP
-#define ASIO_EXPERIMENTAL_CO_SPAWN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <utility>
-#include "asio/compose.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/experimental/coro.hpp"
-#include "asio/experimental/deferred.hpp"
-#include "asio/experimental/prepend.hpp"
-#include "asio/redirect_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename T, typename U, typename Executor>
-struct coro_spawn_op
-{
-  coro<T, U, Executor> c;
-
-  void operator()(auto& self)
-  {
-    auto op = c.async_resume(deferred);
-    std::move(op)((prepend)(std::move(self), 0));
-  }
-
-  void operator()(auto& self, int, auto... res)
-  {
-    self.complete(std::move(res)...);
-  }
-};
-
-} // namespace detail
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename T, typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(coro<void, T, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void(std::exception_ptr, T)>(
-      detail::coro_spawn_op<void, T, Executor>{std::move(c)},
-      token, exec);
-}
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename T, typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(coro<void(), T, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void(std::exception_ptr, T)>(
-      detail::coro_spawn_op<void(), T, Executor>{std::move(c)},
-      token, exec);
-}
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename T, typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void(T))
-co_spawn(coro<void() noexcept, T, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void(T)>(
-      detail::coro_spawn_op<void() noexcept, T, Executor>{std::move(c)},
-      token, exec);
-}
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(coro<void, void, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void(std::exception_ptr)>(
-      detail::coro_spawn_op<void, void, Executor>{std::move(c)},
-      token, exec);
-}
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(coro<void(), void, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void(std::exception_ptr)>(
-      detail::coro_spawn_op<void(), void, Executor>{std::move(c)},
-      token, exec);
-}
-
-/// Spawn a resumable coroutine.
-/**
- * This function spawns the coroutine for execution on its executor. It binds
- * the lifetime of the coroutine to the executor.
- *
- * @param c The coroutine
- *
- * @param token The completion token
- *
- * @returns Implementation defined
- */
-template <typename Executor, typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void())
-co_spawn(coro<void() noexcept, void, Executor> c, CompletionToken&& token)
-{
-  auto exec = c.get_executor();
-  return async_compose<CompletionToken, void()>(
-      detail::coro_spawn_op<void() noexcept, void, Executor>{std::move(c)},
-      token, exec);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif //ASIO_EXPERIMENTAL_CO_SPAWN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/concurrent_channel.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/concurrent_channel.hpp
deleted file mode 100644
index b326be9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/concurrent_channel.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-// experimental/concurrent_channel.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
-#define ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/experimental/basic_concurrent_channel.hpp"
-#include "asio/experimental/channel_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename ExecutorOrSignature, typename = void>
-struct concurrent_channel_type
-{
-  template <typename... Signatures>
-  struct inner
-  {
-    typedef basic_concurrent_channel<any_io_executor, channel_traits<>,
-        ExecutorOrSignature, Signatures...> type;
-  };
-};
-
-template <typename ExecutorOrSignature>
-struct concurrent_channel_type<ExecutorOrSignature,
-    enable_if_t<
-      is_executor<ExecutorOrSignature>::value
-        || execution::is_executor<ExecutorOrSignature>::value
-    >>
-{
-  template <typename... Signatures>
-  struct inner
-  {
-    typedef basic_concurrent_channel<ExecutorOrSignature,
-        channel_traits<>, Signatures...> type;
-  };
-};
-
-} // namespace detail
-
-/// Template type alias for common use of channel.
-template <typename ExecutorOrSignature, typename... Signatures>
-using concurrent_channel = typename detail::concurrent_channel_type<
-    ExecutorOrSignature>::template inner<Signatures...>::type;
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CONCURRENT_CHANNEL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro.hpp
deleted file mode 100644
index de909d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro.hpp
+++ /dev/null
@@ -1,293 +0,0 @@
-//
-// experimental/coro.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_CORO_HPP
-#define ASIO_EXPERIMENTAL_CORO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/error.hpp"
-#include "asio/error_code.hpp"
-#include "asio/experimental/coro_traits.hpp"
-#include "asio/experimental/detail/coro_promise_allocator.hpp"
-#include "asio/experimental/detail/partial_promise.hpp"
-#include "asio/post.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Signature, typename Return,
-    typename Executor, typename Allocator>
-struct coro_promise;
-
-template <typename T, typename Coroutine>
-struct coro_with_arg;
-
-} // namespace detail
-
-/// The main type of a resumable coroutine.
-/**
- * Template parameter @c Yield specifies type or signature used by co_yield,
- * @c Return specifies the type used for co_return, and @c Executor specifies
- * the underlying executor type.
- */
-template <typename Yield = void, typename Return = void,
-    typename Executor = any_io_executor,
-    typename Allocator = std::allocator<void>>
-struct coro
-{
-  /// The traits of the coroutine. See asio::experimental::coro_traits
-  /// for details.
-  using traits = coro_traits<Yield, Return, Executor>;
-
-  /// The value that can be passed into a symmetrical cororoutine. @c void if
-  /// asymmetrical.
-  using input_type = typename traits::input_type;
-
-  /// The type that can be passed out through a co_yield.
-  using yield_type = typename traits::yield_type;
-
-  /// The type that can be passed out through a co_return.
-  using return_type = typename traits::return_type;
-
-  /// The type received by a co_await or async_resume. Its a combination of
-  /// yield and return.
-  using result_type = typename traits::result_type;
-
-  /// The signature used by the async_resume.
-  using signature_type = typename traits::signature_type;
-
-  /// Whether or not the coroutine is noexcept.
-  constexpr static bool is_noexcept = traits::is_noexcept;
-
-  /// The error type of the coroutine. Void for noexcept
-  using error_type = typename traits::error_type;
-
-  /// Completion handler type used by async_resume.
-  using completion_handler = typename traits::completion_handler;
-
-  /// The internal promise-type of the coroutine.
-  using promise_type = detail::coro_promise<Yield, Return, Executor, Allocator>;
-
-#if !defined(GENERATING_DOCUMENTATION)
-  template <typename T, typename Coroutine>
-  friend struct detail::coro_with_arg;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// The executor type.
-  using executor_type = Executor;
-
-  /// The allocator type.
-  using allocator_type = Allocator;
-
-#if !defined(GENERATING_DOCUMENTATION)
-  friend struct detail::coro_promise<Yield, Return, Executor, Allocator>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// The default constructor, gives an invalid coroutine.
-  coro() = default;
-
-  /// Move constructor.
-  coro(coro&& lhs) noexcept
-    : coro_(std::exchange(lhs.coro_, nullptr))
-  {
-  }
-
-  coro(const coro&) = delete;
-
-  /// Move assignment.
-  coro& operator=(coro&& lhs) noexcept
-  {
-    std::swap(coro_, lhs.coro_);
-    return *this;
-  }
-
-  coro& operator=(const coro&) = delete;
-
-  /// Destructor. Destroys the coroutine, if it holds a valid one.
-  /**
-   * @note This does not cancel an active coroutine. Destructing a resumable
-   * coroutine, i.e. one with a call to async_resume that has not completed, is
-   * undefined behaviour.
-   */
-  ~coro()
-  {
-    if (coro_ != nullptr)
-    {
-      struct destroyer
-      {
-        detail::coroutine_handle<promise_type> handle;
-
-        destroyer(const detail::coroutine_handle<promise_type>& handle)
-          : handle(handle)
-        { }
-
-        destroyer(destroyer&& lhs)
-          : handle(std::exchange(lhs.handle, nullptr))
-        {
-        }
-
-        destroyer(const destroyer&) = delete;
-
-        void operator()() {}
-
-        ~destroyer()
-        {
-          if (handle)
-            handle.destroy();
-        }
-      };
-
-      auto handle =
-        detail::coroutine_handle<promise_type>::from_promise(*coro_);
-      if (handle)
-        asio::dispatch(coro_->get_executor(), destroyer{handle});
-    }
-  }
-
-  /// Get the used executor.
-  executor_type get_executor() const
-  {
-    if (coro_)
-      return coro_->get_executor();
-
-    if constexpr (std::is_default_constructible_v<Executor>)
-      return Executor{};
-    else
-      throw std::logic_error("Coroutine has no executor");
-  }
-
-  /// Get the used allocator.
-  allocator_type get_allocator() const
-  {
-    if (coro_)
-      return coro_->get_allocator();
-
-    if constexpr (std::is_default_constructible_v<Allocator>)
-      return Allocator{};
-    else
-      throw std::logic_error(
-          "Coroutine has no available allocator without a constructed promise");
-  }
-
-  /// Resume the coroutine.
-  /**
-   * @param token The completion token of the async resume.
-   *
-   * @attention Calling an invalid coroutine with a noexcept signature is
-   * undefined behaviour.
-   *
-   * @note This overload is only available for coroutines without an input
-   * value.
-   */
-  template <typename CompletionToken>
-    requires std::is_void_v<input_type>
-  auto async_resume(CompletionToken&& token) &
-  {
-    return async_initiate<CompletionToken,
-        typename traits::completion_handler>(
-          initiate_async_resume(this), token);
-  }
-
-  /// Resume the coroutine.
-  /**
-   * @param token The completion token of the async resume.
-   *
-   * @attention Calling an invalid coroutine with a noexcept signature is
-   * undefined behaviour.
-   *
-   * @note This overload is only available for coroutines with an input value.
-   */
-  template <typename CompletionToken, detail::convertible_to<input_type> T>
-  auto async_resume(T&& ip, CompletionToken&& token) &
-  {
-    return async_initiate<CompletionToken,
-        typename traits::completion_handler>(
-          initiate_async_resume(this), token, std::forward<T>(ip));
-  }
-
-  /// Operator used for coroutines without input value.
-  auto operator co_await() requires (std::is_void_v<input_type>)
-  {
-    return awaitable_t{*this};
-  }
-
-  /// Operator used for coroutines with input value.
-  /**
-   * @param ip The input value
-   *
-   * @returns An awaitable handle.
-   *
-   * @code
-   * coro<void> push_values(coro<double(int)> c)
-   * {
-   *    std::optional<double> res = co_await c(42);
-   * }
-   * @endcode
-   */
-  template <detail::convertible_to<input_type> T>
-  auto operator()(T&& ip)
-  {
-    return detail::coro_with_arg<std::decay_t<T>, coro>{
-        std::forward<T>(ip), *this};
-  }
-
-  /// Check whether the coroutine is open, i.e. can be resumed.
-  bool is_open() const
-  {
-    if (coro_)
-    {
-      auto handle =
-        detail::coroutine_handle<promise_type>::from_promise(*coro_);
-      return handle && !handle.done();
-    }
-    else
-      return false;
-  }
-
-  /// Check whether the coroutine is open, i.e. can be resumed.
-  explicit operator bool() const { return is_open(); }
-
-private:
-  struct awaitable_t;
-
-  struct initiate_async_resume;
-
-  explicit coro(promise_type* const cr) : coro_(cr) {}
-
-  promise_type* coro_{nullptr};
-};
-
-/// A generator is a coro that returns void and yields value.
-template<typename T, typename Executor = asio::any_io_executor,
-    typename Allocator = std::allocator<void>>
-using generator = coro<T, void, Executor, Allocator>;
-
-/// A task is a coro that does not yield values
-template<typename T, typename Executor = asio::any_io_executor,
-    typename Allocator = std::allocator<void>>
-using task = coro<void(), T, Executor, Allocator>;
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/impl/coro.hpp"
-
-#endif // ASIO_EXPERIMENTAL_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro_traits.hpp
deleted file mode 100644
index 7da904b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/coro_traits.hpp
+++ /dev/null
@@ -1,228 +0,0 @@
-//
-// experimental/detail/coro_traits.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <optional>
-#include <variant>
-#include "asio/any_io_executor.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <class From, class To>
-concept convertible_to = std::is_convertible_v<From, To>;
-
-template <typename T>
-concept decays_to_executor = execution::executor<std::decay_t<T>>;
-
-template <typename T, typename Executor = any_io_executor>
-concept execution_context = requires (T& t)
-{
-  {t.get_executor()} -> convertible_to<Executor>;
-};
-
-template <typename Yield, typename Return>
-struct coro_result
-{
-  using type = std::variant<Yield, Return>;
-};
-
-template <typename Yield>
-struct coro_result<Yield, void>
-{
-  using type = std::optional<Yield>;
-};
-
-template <typename Return>
-struct coro_result<void, Return>
-{
-  using type = Return;
-};
-
-template <typename YieldReturn>
-struct coro_result<YieldReturn, YieldReturn>
-{
-  using type = YieldReturn;
-};
-
-template <>
-struct coro_result<void, void>
-{
-  using type = void;
-};
-
-template <typename Yield, typename Return>
-using coro_result_t = typename coro_result<Yield, Return>::type;
-
-template <typename Result, bool IsNoexcept>
-struct coro_handler;
-
-template <>
-struct coro_handler<void, false>
-{
-  using type = void(std::exception_ptr);
-};
-
-template <>
-struct coro_handler<void, true>
-{
-  using type = void();
-};
-
-template <typename T>
-struct coro_handler<T, false>
-{
-  using type = void(std::exception_ptr, T);
-};
-
-template <typename T>
-struct coro_handler<T, true>
-{
-  using type = void(T);
-};
-
-template <typename Result, bool IsNoexcept>
-using coro_handler_t = typename coro_handler<Result, IsNoexcept>::type;
-
-} // namespace detail
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// The traits describing the resumable coroutine behaviour.
-/**
- * Template parameter @c Yield specifies type or signature used by co_yield,
- * @c Return specifies the type used for co_return, and @c Executor specifies
- * the underlying executor type.
- */
-template <typename Yield, typename Return, typename Executor>
-struct coro_traits
-{
-  /// The value that can be passed into a symmetrical cororoutine. @c void if
-  /// asymmetrical.
-  using input_type = argument_dependent;
-
-  /// The type that can be passed out through a co_yield.
-  using yield_type = argument_dependent;
-
-  /// The type that can be passed out through a co_return.
-  using return_type = argument_dependent;
-
-  /// The type received by a co_await or async_resume. It's a combination of
-  /// yield and return.
-  using result_type = argument_dependent;
-
-  /// The signature used by the async_resume.
-  using signature_type = argument_dependent;
-
-  /// Whether or not the coroutine is noexcept.
-  constexpr static bool is_noexcept = argument_dependent;
-
-  /// The error type of the coroutine. @c void for noexcept.
-  using error_type = argument_dependent;
-
-  /// Completion handler type used by async_resume.
-  using completion_handler = argument_dependent;
-};
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-template <typename Yield, typename Return, typename Executor>
-struct coro_traits
-{
-  using input_type  = void;
-  using yield_type  = Yield;
-  using return_type = Return;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type();
-  constexpr static bool is_noexcept = false;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-template <typename T, typename Return, typename Executor>
-struct coro_traits<T(), Return, Executor>
-{
-  using input_type = void;
-  using yield_type = T;
-  using return_type = Return;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type();
-  constexpr static bool is_noexcept = false;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-template <typename T, typename Return, typename Executor>
-struct coro_traits<T() noexcept, Return, Executor>
-{
-  using input_type = void;
-  using yield_type = T;
-  using return_type = Return;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type();
-  constexpr static bool is_noexcept = true;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-template <typename T, typename U, typename Return, typename Executor>
-struct coro_traits<T(U), Return, Executor>
-{
-  using input_type = U;
-  using yield_type = T;
-  using return_type = Return;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type(input_type);
-  constexpr static bool is_noexcept = false;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-template <typename T, typename U, typename Return, typename Executor>
-struct coro_traits<T(U) noexcept, Return, Executor>
-{
-  using input_type = U;
-  using yield_type = T;
-  using return_type = Return;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type(input_type);
-  constexpr static bool is_noexcept = true;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-template <typename Executor>
-struct coro_traits<void() noexcept, void, Executor>
-{
-  using input_type = void;
-  using yield_type = void;
-  using return_type = void;
-  using result_type = detail::coro_result_t<yield_type, return_type>;
-  using signature_type = result_type(input_type);
-  constexpr static bool is_noexcept = true;
-  using error_type = std::conditional_t<is_noexcept, void, std::exception_ptr>;
-  using completion_handler = detail::coro_handler_t<result_type, is_noexcept>;
-};
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace experimental
-} // namespace asio
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CORO_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/deferred.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/deferred.hpp
deleted file mode 100644
index c722ad1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/deferred.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// experimental/deferred.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DEFERRED_HPP
-#define ASIO_EXPERIMENTAL_DEFERRED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/deferred.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-#if !defined(ASIO_NO_DEPRECATED)
-using asio::deferred_t;
-using asio::deferred;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DEFERRED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_operation.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_operation.hpp
deleted file mode 100644
index 1231f1f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_operation.hpp
+++ /dev/null
@@ -1,361 +0,0 @@
-//
-// experimental/detail/channel_operation.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/detail/initiate_post.hpp"
-#include "asio/detail/initiate_dispatch.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/prefer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-// Base class for all channel operations. A function pointer is used instead of
-// virtual functions to avoid the associated overhead.
-class channel_operation ASIO_INHERIT_TRACKED_HANDLER
-{
-public:
-  template <typename Executor, typename = void, typename = void>
-  class handler_work_base;
-
-  template <typename Handler, typename IoExecutor, typename = void>
-  class handler_work;
-
-  void destroy()
-  {
-    func_(this, destroy_op, 0);
-  }
-
-protected:
-  enum action
-  {
-    destroy_op = 0,
-    immediate_op = 1,
-    post_op = 2,
-    dispatch_op = 3,
-    cancel_op = 4,
-    close_op = 5
-  };
-
-  typedef void (*func_type)(channel_operation*, action, void*);
-
-  channel_operation(func_type func)
-    : next_(0),
-      func_(func),
-      cancellation_key_(0)
-  {
-  }
-
-  // Prevents deletion through this type.
-  ~channel_operation()
-  {
-  }
-
-  friend class asio::detail::op_queue_access;
-  channel_operation* next_;
-  func_type func_;
-
-public:
-  // The operation key used for targeted cancellation.
-  void* cancellation_key_;
-};
-
-template <typename Executor, typename, typename>
-class channel_operation::handler_work_base
-{
-public:
-  typedef decay_t<
-      prefer_result_t<Executor,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  handler_work_base(int, const Executor& ex)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  const executor_type& get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  template <typename IoExecutor, typename Function, typename Handler>
-  void post(const IoExecutor& io_exec, Function& function, Handler&)
-  {
-    (asio::detail::initiate_post_with_executor<IoExecutor>(io_exec))(
-        static_cast<Function&&>(function));
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    associated_allocator_t<Handler> allocator =
-      (get_associated_allocator)(handler);
-
-    asio::prefer(executor_,
-        execution::allocator(allocator)
-      ).execute(static_cast<Function&&>(function));
-  }
-
-private:
-  executor_type executor_;
-};
-
-template <typename Executor>
-class channel_operation::handler_work_base<Executor,
-    enable_if_t<
-      execution::is_executor<Executor>::value
-    >,
-    enable_if_t<
-      can_require<Executor, execution::blocking_t::never_t>::value
-    >
-  >
-{
-public:
-  typedef decay_t<
-      prefer_result_t<Executor,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  handler_work_base(int, const Executor& ex)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  const executor_type& get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  template <typename IoExecutor, typename Function, typename Handler>
-  void post(const IoExecutor&, Function& function, Handler& handler)
-  {
-    associated_allocator_t<Handler> allocator =
-      (get_associated_allocator)(handler);
-
-    asio::prefer(
-        asio::require(executor_, execution::blocking.never),
-        execution::allocator(allocator)
-      ).execute(static_cast<Function&&>(function));
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    associated_allocator_t<Handler> allocator =
-      (get_associated_allocator)(handler);
-
-    asio::prefer(executor_,
-        execution::allocator(allocator)
-      ).execute(static_cast<Function&&>(function));
-  }
-
-private:
-  executor_type executor_;
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-class channel_operation::handler_work_base<Executor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-    >
-  >
-{
-public:
-  typedef Executor executor_type;
-
-  handler_work_base(int, const Executor& ex)
-    : work_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return work_.get_executor();
-  }
-
-  template <typename IoExecutor, typename Function, typename Handler>
-  void post(const IoExecutor&, Function& function, Handler& handler)
-  {
-    associated_allocator_t<Handler> allocator =
-      (get_associated_allocator)(handler);
-
-    work_.get_executor().post(
-        static_cast<Function&&>(function), allocator);
-  }
-
-  template <typename Function, typename Handler>
-  void dispatch(Function& function, Handler& handler)
-  {
-    associated_allocator_t<Handler> allocator =
-      (get_associated_allocator)(handler);
-
-    work_.get_executor().dispatch(
-        static_cast<Function&&>(function), allocator);
-  }
-
-private:
-  executor_work_guard<Executor> work_;
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Handler, typename IoExecutor, typename>
-class channel_operation::handler_work :
-  channel_operation::handler_work_base<IoExecutor>,
-  channel_operation::handler_work_base<
-      associated_executor_t<Handler, IoExecutor>, IoExecutor>
-{
-public:
-  typedef channel_operation::handler_work_base<IoExecutor> base1_type;
-
-  typedef channel_operation::handler_work_base<
-      associated_executor_t<Handler, IoExecutor>, IoExecutor>
-    base2_type;
-
-  handler_work(Handler& handler, const IoExecutor& io_ex) noexcept
-    : base1_type(0, io_ex),
-      base2_type(0, (get_associated_executor)(handler, io_ex))
-  {
-  }
-
-  template <typename Function>
-  void post(Function& function, Handler& handler)
-  {
-    base2_type::post(base1_type::get_executor(), function, handler);
-  }
-
-  template <typename Function>
-  void dispatch(Function& function, Handler& handler)
-  {
-    base2_type::dispatch(function, handler);
-  }
-
-  template <typename Function>
-  void immediate(Function& function, Handler& handler, ...)
-  {
-    typedef associated_immediate_executor_t<Handler,
-      typename base1_type::executor_type> immediate_ex_type;
-
-    immediate_ex_type immediate_ex = (get_associated_immediate_executor)(
-        handler, base1_type::get_executor());
-
-    (asio::detail::initiate_dispatch_with_executor<immediate_ex_type>(
-          immediate_ex))(static_cast<Function&&>(function));
-  }
-
-  template <typename Function>
-  void immediate(Function& function, Handler&,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            conditional_t<false, Function, Handler>,
-            typename base1_type::executor_type>::
-              asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    (asio::detail::initiate_post_with_executor<
-        typename base1_type::executor_type>(
-          base1_type::get_executor()))(
-        static_cast<Function&&>(function));
-  }
-};
-
-template <typename Handler, typename IoExecutor>
-class channel_operation::handler_work<
-    Handler, IoExecutor,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          IoExecutor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >
-  > : handler_work_base<IoExecutor>
-{
-public:
-  typedef channel_operation::handler_work_base<IoExecutor> base1_type;
-
-  handler_work(Handler&, const IoExecutor& io_ex) noexcept
-    : base1_type(0, io_ex)
-  {
-  }
-
-  template <typename Function>
-  void post(Function& function, Handler& handler)
-  {
-    base1_type::post(base1_type::get_executor(), function, handler);
-  }
-
-  template <typename Function>
-  void dispatch(Function& function, Handler& handler)
-  {
-    base1_type::dispatch(function, handler);
-  }
-
-  template <typename Function>
-  void immediate(Function& function, Handler& handler, ...)
-  {
-    typedef associated_immediate_executor_t<Handler,
-      typename base1_type::executor_type> immediate_ex_type;
-
-    immediate_ex_type immediate_ex = (get_associated_immediate_executor)(
-        handler, base1_type::get_executor());
-
-    (asio::detail::initiate_dispatch_with_executor<immediate_ex_type>(
-          immediate_ex))(static_cast<Function&&>(function));
-  }
-
-  template <typename Function>
-  void immediate(Function& function, Handler& handler,
-      enable_if_t<
-        is_same<
-          typename associated_immediate_executor<
-            conditional_t<false, Function, Handler>,
-            typename base1_type::executor_type>::
-              asio_associated_immediate_executor_is_unspecialised,
-          void
-        >::value
-      >*)
-  {
-    base1_type::post(base1_type::get_executor(), function, handler);
-  }
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CHANNEL_OPERATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_receive_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_receive_op.hpp
deleted file mode 100644
index 2398d2e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_receive_op.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// experimental/detail/channel_receive_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/error.hpp"
-#include "asio/experimental/detail/channel_operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Payload>
-class channel_receive : public channel_operation
-{
-public:
-  void immediate(Payload payload)
-  {
-    func_(this, immediate_op, &payload);
-  }
-
-  void post(Payload payload)
-  {
-    func_(this, post_op, &payload);
-  }
-
-  void dispatch(Payload payload)
-  {
-    func_(this, dispatch_op, &payload);
-  }
-
-protected:
-  channel_receive(func_type func)
-    : channel_operation(func)
-  {
-  }
-};
-
-template <typename Payload, typename Handler, typename IoExecutor>
-class channel_receive_op : public channel_receive<Payload>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(channel_receive_op);
-
-  template <typename... Args>
-  channel_receive_op(Handler& handler, const IoExecutor& io_ex)
-    : channel_receive<Payload>(&channel_receive_op::do_action),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_action(channel_operation* base,
-      channel_operation::action a, void* v)
-  {
-    // Take ownership of the operation object.
-    channel_receive_op* o(static_cast<channel_receive_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    channel_operation::handler_work<Handler, IoExecutor> w(
-        static_cast<channel_operation::handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the handler is posted. Even if we're not about to post the handler, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    if (a != channel_operation::destroy_op)
-    {
-      Payload* payload = static_cast<Payload*>(v);
-      asio::detail::completion_payload_handler<Payload, Handler> handler(
-          static_cast<Payload&&>(*payload), o->handler_);
-      p.h = asio::detail::addressof(handler.handler_);
-      p.reset();
-      ASIO_HANDLER_INVOCATION_BEGIN(());
-      if (a == channel_operation::immediate_op)
-        w.immediate(handler, handler.handler_, 0);
-      else if (a == channel_operation::dispatch_op)
-        w.dispatch(handler, handler.handler_);
-      else
-        w.post(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-    else
-    {
-      asio::detail::binder0<Handler> handler(o->handler_);
-      p.h = asio::detail::addressof(handler.handler_);
-      p.reset();
-    }
-  }
-
-private:
-  Handler handler_;
-  channel_operation::handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CHANNEL_RECEIVE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_functions.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_functions.hpp
deleted file mode 100644
index cff5d58..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_functions.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-//
-// experimental/detail/channel_send_functions.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/completion_message.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Derived, typename Executor, typename... Signatures>
-class channel_send_functions;
-
-template <typename Derived, typename Executor, typename R, typename... Args>
-class channel_send_functions<Derived, Executor, R(Args...)>
-{
-public:
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    bool
-  > try_send(Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send<message_type>(
-        self->impl_, false, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    bool
-  > try_send_via_dispatch(Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send<message_type>(
-        self->impl_, true, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    std::size_t
-  > try_send_n(std::size_t count, Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send_n<message_type>(
-        self->impl_, count, false, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    std::size_t
-  > try_send_n_via_dispatch(std::size_t count, Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send_n<message_type>(
-        self->impl_, count, true, static_cast<Args2&&>(args)...);
-  }
-
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        CompletionToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-  auto async_send(Args... args,
-      CompletionToken&& token
-        ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
-    -> decltype(
-        async_initiate<CompletionToken, void (asio::error_code)>(
-          declval<typename conditional_t<false, CompletionToken,
-            Derived>::initiate_async_send>(), token,
-          declval<typename conditional_t<false, CompletionToken,
-            Derived>::payload_type>()))
-  {
-    typedef typename Derived::payload_type payload_type;
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return async_initiate<CompletionToken, void (asio::error_code)>(
-        typename Derived::initiate_async_send(self), token,
-        payload_type(message_type(0, static_cast<Args&&>(args)...)));
-  }
-};
-
-template <typename Derived, typename Executor,
-    typename R, typename... Args, typename... Signatures>
-class channel_send_functions<Derived, Executor, R(Args...), Signatures...> :
-  public channel_send_functions<Derived, Executor, Signatures...>
-{
-public:
-  using channel_send_functions<Derived, Executor, Signatures...>::try_send;
-  using channel_send_functions<Derived, Executor, Signatures...>::async_send;
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    bool
-  > try_send(Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send<message_type>(
-        self->impl_, false, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    bool
-  > try_send_via_dispatch(Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send<message_type>(
-        self->impl_, true, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    std::size_t
-  > try_send_n(std::size_t count, Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send_n<message_type>(
-        self->impl_, count, false, static_cast<Args2&&>(args)...);
-  }
-
-  template <typename... Args2>
-  enable_if_t<
-    is_constructible<asio::detail::completion_message<R(Args...)>,
-      int, Args2...>::value,
-    std::size_t
-  > try_send_n_via_dispatch(std::size_t count, Args2&&... args)
-  {
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return self->service_->template try_send_n<message_type>(
-        self->impl_, count, true, static_cast<Args2&&>(args)...);
-  }
-
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        CompletionToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
-  auto async_send(Args... args,
-      CompletionToken&& token
-        ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
-    -> decltype(
-        async_initiate<CompletionToken, void (asio::error_code)>(
-          declval<typename conditional_t<false, CompletionToken,
-            Derived>::initiate_async_send>(), token,
-          declval<typename conditional_t<false, CompletionToken,
-            Derived>::payload_type>()))
-  {
-    typedef typename Derived::payload_type payload_type;
-    typedef asio::detail::completion_message<R(Args...)> message_type;
-    Derived* self = static_cast<Derived*>(this);
-    return async_initiate<CompletionToken, void (asio::error_code)>(
-        typename Derived::initiate_async_send(self), token,
-        payload_type(message_type(0, static_cast<Args&&>(args)...)));
-  }
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_FUNCTIONS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_op.hpp
deleted file mode 100644
index 2dd24a7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_send_op.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// experimental/detail/channel_send_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/error.hpp"
-#include "asio/experimental/channel_error.hpp"
-#include "asio/experimental/detail/channel_operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Payload>
-class channel_send : public channel_operation
-{
-public:
-  Payload get_payload()
-  {
-    return static_cast<Payload&&>(payload_);
-  }
-
-  void immediate()
-  {
-    func_(this, immediate_op, 0);
-  }
-
-  void post()
-  {
-    func_(this, post_op, 0);
-  }
-
-  void cancel()
-  {
-    func_(this, cancel_op, 0);
-  }
-
-  void close()
-  {
-    func_(this, close_op, 0);
-  }
-
-protected:
-  channel_send(func_type func, Payload&& payload)
-    : channel_operation(func),
-      payload_(static_cast<Payload&&>(payload))
-  {
-  }
-
-private:
-  Payload payload_;
-};
-
-template <typename Payload, typename Handler, typename IoExecutor>
-class channel_send_op : public channel_send<Payload>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(channel_send_op);
-
-  channel_send_op(Payload&& payload,
-      Handler& handler, const IoExecutor& io_ex)
-    : channel_send<Payload>(&channel_send_op::do_action,
-        static_cast<Payload&&>(payload)),
-      handler_(static_cast<Handler&&>(handler)),
-      work_(handler_, io_ex)
-  {
-  }
-
-  static void do_action(channel_operation* base,
-      channel_operation::action a, void*)
-  {
-    // Take ownership of the operation object.
-    channel_send_op* o(static_cast<channel_send_op*>(base));
-    ptr p = { asio::detail::addressof(o->handler_), o, o };
-
-    ASIO_HANDLER_COMPLETION((*o));
-
-    // Take ownership of the operation's outstanding work.
-    channel_operation::handler_work<Handler, IoExecutor> w(
-        static_cast<channel_operation::handler_work<Handler, IoExecutor>&&>(
-          o->work_));
-
-    asio::error_code ec;
-    switch (a)
-    {
-    case channel_operation::cancel_op:
-      ec = error::channel_cancelled;
-      break;
-    case channel_operation::close_op:
-      ec = error::channel_closed;
-      break;
-    default:
-      break;
-    }
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the handler is posted. Even if we're not about to post the handler, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    asio::detail::binder1<Handler, asio::error_code>
-      handler(o->handler_, ec);
-    p.h = asio::detail::addressof(handler.handler_);
-    p.reset();
-
-    // Post the completion if required.
-    if (a != channel_operation::destroy_op)
-    {
-      ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
-      if (a == channel_operation::immediate_op)
-        w.immediate(handler, handler.handler_, 0);
-      else
-        w.post(handler, handler.handler_);
-      ASIO_HANDLER_INVOCATION_END;
-    }
-  }
-
-private:
-  Handler handler_;
-  channel_operation::handler_work<Handler, IoExecutor> work_;
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SEND_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_service.hpp
deleted file mode 100644
index 47feb03..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/channel_service.hpp
+++ /dev/null
@@ -1,679 +0,0 @@
-//
-// experimental/detail/channel_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/cancellation_type.hpp"
-#include "asio/detail/completion_message.hpp"
-#include "asio/detail/completion_payload.hpp"
-#include "asio/detail/completion_payload_handler.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/experimental/detail/channel_receive_op.hpp"
-#include "asio/experimental/detail/channel_send_op.hpp"
-#include "asio/experimental/detail/has_signature.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Mutex>
-class channel_service
-  : public asio::detail::execution_context_service_base<
-      channel_service<Mutex>>
-{
-public:
-  // Possible states for a channel end.
-  enum state
-  {
-    buffer = 0,
-    waiter = 1,
-    block = 2,
-    closed = 3
-  };
-
-  // The base implementation type of all channels.
-  struct base_implementation_type
-  {
-    // Default constructor.
-    base_implementation_type()
-      : receive_state_(block),
-        send_state_(block),
-        max_buffer_size_(0),
-        next_(0),
-        prev_(0)
-    {
-    }
-
-    // The current state of the channel.
-    state receive_state_ : 16;
-    state send_state_ : 16;
-
-    // The maximum number of elements that may be buffered in the channel.
-    std::size_t max_buffer_size_;
-
-    // The operations that are waiting on the channel.
-    asio::detail::op_queue<channel_operation> waiters_;
-
-    // Pointers to adjacent channel implementations in linked list.
-    base_implementation_type* next_;
-    base_implementation_type* prev_;
-
-    // The mutex type to protect the internal implementation.
-    mutable Mutex mutex_;
-  };
-
-  // The implementation for a specific value type.
-  template <typename Traits, typename... Signatures>
-  struct implementation_type;
-
-  // Constructor.
-  channel_service(asio::execution_context& ctx);
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown();
-
-  // Construct a new channel implementation.
-  void construct(base_implementation_type& impl, std::size_t max_buffer_size);
-
-  // Destroy a channel implementation.
-  template <typename Traits, typename... Signatures>
-  void destroy(implementation_type<Traits, Signatures...>& impl);
-
-  // Move-construct a new channel implementation.
-  template <typename Traits, typename... Signatures>
-  void move_construct(implementation_type<Traits, Signatures...>& impl,
-      implementation_type<Traits, Signatures...>& other_impl);
-
-  // Move-assign from another channel implementation.
-  template <typename Traits, typename... Signatures>
-  void move_assign(implementation_type<Traits, Signatures...>& impl,
-      channel_service& other_service,
-      implementation_type<Traits, Signatures...>& other_impl);
-
-  // Get the capacity of the channel.
-  std::size_t capacity(
-      const base_implementation_type& impl) const noexcept;
-
-  // Determine whether the channel is open.
-  bool is_open(const base_implementation_type& impl) const noexcept;
-
-  // Reset the channel to its initial state.
-  template <typename Traits, typename... Signatures>
-  void reset(implementation_type<Traits, Signatures...>& impl);
-
-  // Close the channel.
-  template <typename Traits, typename... Signatures>
-  void close(implementation_type<Traits, Signatures...>& impl);
-
-  // Cancel all operations associated with the channel.
-  template <typename Traits, typename... Signatures>
-  void cancel(implementation_type<Traits, Signatures...>& impl);
-
-  // Cancel the operation associated with the channel that has the given key.
-  template <typename Traits, typename... Signatures>
-  void cancel_by_key(implementation_type<Traits, Signatures...>& impl,
-      void* cancellation_key);
-
-  // Determine whether a value can be read from the channel without blocking.
-  bool ready(const base_implementation_type& impl) const noexcept;
-
-  // Synchronously send a new value into the channel.
-  template <typename Message, typename Traits,
-      typename... Signatures, typename... Args>
-  bool try_send(implementation_type<Traits, Signatures...>& impl,
-      bool via_dispatch, Args&&... args);
-
-  // Synchronously send a number of new values into the channel.
-  template <typename Message, typename Traits,
-      typename... Signatures, typename... Args>
-  std::size_t try_send_n(implementation_type<Traits, Signatures...>& impl,
-      std::size_t count, bool via_dispatch, Args&&... args);
-
-  // Asynchronously send a new value into the channel.
-  template <typename Traits, typename... Signatures,
-      typename Handler, typename IoExecutor>
-  void async_send(implementation_type<Traits, Signatures...>& impl,
-      typename implementation_type<Traits,
-        Signatures...>::payload_type&& payload,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef channel_send_op<
-      typename implementation_type<Traits, Signatures...>::payload_type,
-        Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(static_cast<typename implementation_type<
-          Traits, Signatures...>::payload_type&&>(payload), handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<op_cancellation<Traits, Signatures...>>(
-            this, &impl);
-    }
-
-    ASIO_HANDLER_CREATION((this->context(), *p.p,
-          "channel", &impl, 0, "async_send"));
-
-    start_send_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-  // Synchronously receive a value from the channel.
-  template <typename Traits, typename... Signatures, typename Handler>
-  bool try_receive(implementation_type<Traits, Signatures...>& impl,
-      Handler&& handler);
-
-  // Asynchronously receive a value from the channel.
-  template <typename Traits, typename... Signatures,
-      typename Handler, typename IoExecutor>
-  void async_receive(implementation_type<Traits, Signatures...>& impl,
-      Handler& handler, const IoExecutor& io_ex)
-  {
-    associated_cancellation_slot_t<Handler> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef channel_receive_op<
-      typename implementation_type<Traits, Signatures...>::payload_type,
-        Handler, IoExecutor> op;
-    typename op::ptr p = { asio::detail::addressof(handler),
-      op::ptr::allocate(handler), 0 };
-    p.p = new (p.v) op(handler, io_ex);
-
-    // Optionally register for per-operation cancellation.
-    if (slot.is_connected())
-    {
-      p.p->cancellation_key_ =
-        &slot.template emplace<op_cancellation<Traits, Signatures...>>(
-            this, &impl);
-    }
-
-    ASIO_HANDLER_CREATION((this->context(), *p.p,
-          "channel", &impl, 0, "async_receive"));
-
-    start_receive_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Helper function object to handle a closed notification.
-  template <typename Payload, typename Signature>
-  struct post_receive
-  {
-    explicit post_receive(channel_receive<Payload>* op)
-      : op_(op)
-    {
-    }
-
-    template <typename... Args>
-    void operator()(Args&&... args)
-    {
-      op_->post(
-          asio::detail::completion_message<Signature>(0,
-            static_cast<Args&&>(args)...));
-    }
-
-    channel_receive<Payload>* op_;
-  };
-
-  // Destroy a base channel implementation.
-  void base_destroy(base_implementation_type& impl);
-
-  // Helper function to start an asynchronous put operation.
-  template <typename Traits, typename... Signatures>
-  void start_send_op(implementation_type<Traits, Signatures...>& impl,
-      channel_send<typename implementation_type<
-        Traits, Signatures...>::payload_type>* send_op);
-
-  // Helper function to start an asynchronous get operation.
-  template <typename Traits, typename... Signatures>
-  void start_receive_op(implementation_type<Traits, Signatures...>& impl,
-      channel_receive<typename implementation_type<
-        Traits, Signatures...>::payload_type>* receive_op);
-
-  // Helper class used to implement per-operation cancellation.
-  template <typename Traits, typename... Signatures>
-  class op_cancellation
-  {
-  public:
-    op_cancellation(channel_service* s,
-        implementation_type<Traits, Signatures...>* impl)
-      : service_(s),
-        impl_(impl)
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (!!(type &
-            (cancellation_type::terminal
-              | cancellation_type::partial
-              | cancellation_type::total)))
-      {
-        service_->cancel_by_key(*impl_, this);
-      }
-    }
-
-  private:
-    channel_service* service_;
-    implementation_type<Traits, Signatures...>* impl_;
-  };
-
-  // Mutex to protect access to the linked list of implementations.
-  asio::detail::mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  base_implementation_type* impl_list_;
-};
-
-// The implementation for a specific value type.
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-struct channel_service<Mutex>::implementation_type : base_implementation_type
-{
-  // The traits type associated with the channel.
-  typedef typename Traits::template rebind<Signatures...>::other traits_type;
-
-  // Type of an element stored in the buffer.
-  typedef conditional_t<
-      has_signature<
-        typename traits_type::receive_cancelled_signature,
-        Signatures...
-      >::value,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          Signatures...
-        >::value,
-        asio::detail::completion_payload<Signatures...>,
-        asio::detail::completion_payload<
-          Signatures...,
-          typename traits_type::receive_closed_signature
-        >
-      >,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          Signatures...,
-          typename traits_type::receive_cancelled_signature
-        >::value,
-        asio::detail::completion_payload<
-          Signatures...,
-          typename traits_type::receive_cancelled_signature
-        >,
-        asio::detail::completion_payload<
-          Signatures...,
-          typename traits_type::receive_cancelled_signature,
-          typename traits_type::receive_closed_signature
-        >
-      >
-    > payload_type;
-
-  // Move from another buffer.
-  void buffer_move_from(implementation_type& other)
-  {
-    buffer_ = static_cast<
-        typename traits_type::template container<payload_type>::type&&>(
-          other.buffer_);
-    other.buffer_clear();
-  }
-
-  // Get number of buffered elements.
-  std::size_t buffer_size() const
-  {
-    return buffer_.size();
-  }
-
-  // Push a new value to the back of the buffer.
-  void buffer_push(payload_type payload)
-  {
-    buffer_.push_back(static_cast<payload_type&&>(payload));
-  }
-
-  // Push new values to the back of the buffer.
-  std::size_t buffer_push_n(std::size_t count, payload_type payload)
-  {
-    std::size_t i = 0;
-    for (; i < count && buffer_.size() < this->max_buffer_size_; ++i)
-      buffer_.push_back(payload);
-    return i;
-  }
-
-  // Get the element at the front of the buffer.
-  payload_type buffer_front()
-  {
-    return static_cast<payload_type&&>(buffer_.front());
-  }
-
-  // Pop a value from the front of the buffer.
-  void buffer_pop()
-  {
-    buffer_.pop_front();
-  }
-
-  // Clear all buffered values.
-  void buffer_clear()
-  {
-    buffer_.clear();
-  }
-
-private:
-  // Buffered values.
-  typename traits_type::template container<payload_type>::type buffer_;
-};
-
-// The implementation for a void value type.
-template <typename Mutex>
-template <typename Traits, typename R>
-struct channel_service<Mutex>::implementation_type<Traits, R()>
-  : channel_service::base_implementation_type
-{
-  // The traits type associated with the channel.
-  typedef typename Traits::template rebind<R()>::other traits_type;
-
-  // Type of an element stored in the buffer.
-  typedef conditional_t<
-      has_signature<
-        typename traits_type::receive_cancelled_signature,
-        R()
-      >::value,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          R()
-        >::value,
-        asio::detail::completion_payload<R()>,
-        asio::detail::completion_payload<
-          R(),
-          typename traits_type::receive_closed_signature
-        >
-      >,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          R(),
-          typename traits_type::receive_cancelled_signature
-        >::value,
-        asio::detail::completion_payload<
-          R(),
-          typename traits_type::receive_cancelled_signature
-        >,
-        asio::detail::completion_payload<
-          R(),
-          typename traits_type::receive_cancelled_signature,
-          typename traits_type::receive_closed_signature
-        >
-      >
-    > payload_type;
-
-  // Construct with empty buffer.
-  implementation_type()
-    : buffer_(0)
-  {
-  }
-
-  // Move from another buffer.
-  void buffer_move_from(implementation_type& other)
-  {
-    buffer_ = other.buffer_;
-    other.buffer_ = 0;
-  }
-
-  // Get number of buffered elements.
-  std::size_t buffer_size() const
-  {
-    return buffer_;
-  }
-
-  // Push a new value to the back of the buffer.
-  void buffer_push(payload_type)
-  {
-    ++buffer_;
-  }
-
-  // Push new values to the back of the buffer.
-  std::size_t buffer_push_n(std::size_t count, payload_type)
-  {
-    std::size_t available = this->max_buffer_size_ - buffer_;
-    count = (count < available) ? count : available;
-    buffer_ += count;
-    return count;
-  }
-
-  // Get the element at the front of the buffer.
-  payload_type buffer_front()
-  {
-    return payload_type(asio::detail::completion_message<R()>(0));
-  }
-
-  // Pop a value from the front of the buffer.
-  void buffer_pop()
-  {
-    --buffer_;
-  }
-
-  // Clear all values from the buffer.
-  void buffer_clear()
-  {
-    buffer_ = 0;
-  }
-
-private:
-  // Number of buffered "values".
-  std::size_t buffer_;
-};
-
-// The implementation for an error_code signature.
-template <typename Mutex>
-template <typename Traits, typename R>
-struct channel_service<Mutex>::implementation_type<
-    Traits, R(asio::error_code)>
-  : channel_service::base_implementation_type
-{
-  // The traits type associated with the channel.
-  typedef typename Traits::template rebind<R(asio::error_code)>::other
-    traits_type;
-
-  // Type of an element stored in the buffer.
-  typedef conditional_t<
-      has_signature<
-        typename traits_type::receive_cancelled_signature,
-        R(asio::error_code)
-      >::value,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          R(asio::error_code)
-        >::value,
-        asio::detail::completion_payload<R(asio::error_code)>,
-        asio::detail::completion_payload<
-          R(asio::error_code),
-          typename traits_type::receive_closed_signature
-        >
-      >,
-      conditional_t<
-        has_signature<
-          typename traits_type::receive_closed_signature,
-          R(asio::error_code),
-          typename traits_type::receive_cancelled_signature
-        >::value,
-        asio::detail::completion_payload<
-          R(asio::error_code),
-          typename traits_type::receive_cancelled_signature
-        >,
-        asio::detail::completion_payload<
-          R(asio::error_code),
-          typename traits_type::receive_cancelled_signature,
-          typename traits_type::receive_closed_signature
-        >
-      >
-    > payload_type;
-
-  // Construct with empty buffer.
-  implementation_type()
-    : size_(0)
-  {
-    first_.count_ = 0;
-  }
-
-  // Move from another buffer.
-  void buffer_move_from(implementation_type& other)
-  {
-    size_ = other.buffer_;
-    other.size_ = 0;
-    first_ = other.first_;
-    other.first.count_ = 0;
-    rest_ = static_cast<
-        typename traits_type::template container<buffered_value>::type&&>(
-          other.rest_);
-    other.buffer_clear();
-  }
-
-  // Get number of buffered elements.
-  std::size_t buffer_size() const
-  {
-    return size_;
-  }
-
-  // Push a new value to the back of the buffer.
-  void buffer_push(payload_type payload)
-  {
-    buffered_value& last = rest_.empty() ? first_ : rest_.back();
-    if (last.count_ == 0)
-    {
-      value_handler handler{last.value_};
-      payload.receive(handler);
-      last.count_ = 1;
-    }
-    else
-    {
-      asio::error_code value{last.value_};
-      value_handler handler{value};
-      payload.receive(handler);
-      if (last.value_ == value)
-        ++last.count_;
-      else
-        rest_.push_back({value, 1});
-    }
-    ++size_;
-  }
-
-  // Push new values to the back of the buffer.
-  std::size_t buffer_push_n(std::size_t count, payload_type payload)
-  {
-    std::size_t available = this->max_buffer_size_ - size_;
-    count = (count < available) ? count : available;
-    if (count > 0)
-    {
-      buffered_value& last = rest_.empty() ? first_ : rest_.back();
-      if (last.count_ == 0)
-      {
-        payload.receive(value_handler{last.value_});
-        last.count_ = count;
-      }
-      else
-      {
-        asio::error_code value{last.value_};
-        payload.receive(value_handler{value});
-        if (last.value_ == value)
-          last.count_ += count;
-        else
-          rest_.push_back({value, count});
-      }
-      size_ += count;
-    }
-    return count;
-  }
-
-  // Get the element at the front of the buffer.
-  payload_type buffer_front()
-  {
-    return payload_type({0, first_.value_});
-  }
-
-  // Pop a value from the front of the buffer.
-  void buffer_pop()
-  {
-    --size_;
-    if (--first_.count_ == 0 && !rest_.empty())
-    {
-      first_ = rest_.front();
-      rest_.pop_front();
-    }
-  }
-
-  // Clear all values from the buffer.
-  void buffer_clear()
-  {
-    size_ = 0;
-    first_.count_ == 0;
-    rest_.clear();
-  }
-
-private:
-  struct buffered_value
-  {
-    asio::error_code value_;
-    std::size_t count_;
-  };
-
-  struct value_handler
-  {
-    asio::error_code& target_;
-
-    template <typename... Args>
-    void operator()(const asio::error_code& value, Args&&...)
-    {
-      target_ = value;
-    }
-  };
-
-  buffered_value& last_value()
-  {
-    return rest_.empty() ? first_ : rest_.back();
-  }
-
-  // Total number of buffered values.
-  std::size_t size_;
-
-  // The first buffered value is maintained as a separate data member to avoid
-  // allocating space in the container in the common case.
-  buffered_value first_;
-
-  // The rest of the buffered values.
-  typename traits_type::template container<buffered_value>::type rest_;
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/detail/impl/channel_service.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CHANNEL_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_completion_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_completion_handler.hpp
deleted file mode 100644
index 5280913..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_completion_handler.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// experimental/detail/coro_completion_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/deferred.hpp"
-#include "asio/experimental/coro.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Promise, typename... Args>
-struct coro_completion_handler
-{
-  coro_completion_handler(coroutine_handle<Promise> h,
-      std::optional<std::tuple<Args...>>& result)
-    : self(h),
-      result(result)
-  {
-  }
-
-  coro_completion_handler(coro_completion_handler&&) = default;
-
-  coroutine_handle<Promise> self;
-
-  std::optional<std::tuple<Args...>>& result;
-
-  using promise_type = Promise;
-
-  void operator()(Args... args)
-  {
-    result.emplace(std::move(args)...);
-    self.resume();
-  }
-
-  using allocator_type = typename promise_type::allocator_type;
-  allocator_type get_allocator() const noexcept
-  {
-    return self.promise().get_allocator();
-  }
-
-  using executor_type = typename promise_type::executor_type;
-  executor_type get_executor() const noexcept
-  {
-    return self.promise().get_executor();
-  }
-
-  using cancellation_slot_type = typename promise_type::cancellation_slot_type;
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return self.promise().get_cancellation_slot();
-  }
-};
-
-template <typename Signature>
-struct coro_completion_handler_type;
-
-template <typename... Args>
-struct coro_completion_handler_type<void(Args...)>
-{
-  using type = std::tuple<Args...>;
-
-  template <typename Promise>
-  using completion_handler = coro_completion_handler<Promise, Args...>;
-};
-
-template <typename Signature>
-using coro_completion_handler_type_t =
-  typename coro_completion_handler_type<Signature>::type;
-
-inline void coro_interpret_result(std::tuple<>&&)
-{
-}
-
-template <typename... Args>
-inline auto coro_interpret_result(std::tuple<Args...>&& args)
-{
-  return std::move(args);
-}
-
-template <typename... Args>
-auto coro_interpret_result(std::tuple<std::exception_ptr, Args...>&& args)
-{
-  if (std::get<0>(args))
-    std::rethrow_exception(std::get<0>(args));
-
-  return std::apply(
-      [](auto, auto&&... rest)
-      {
-        return std::make_tuple(std::move(rest)...);
-      }, std::move(args));
-}
-
-template <typename... Args>
-auto coro_interpret_result(
-    std::tuple<asio::error_code, Args...>&& args)
-{
-  if (std::get<0>(args))
-    asio::detail::throw_exception(
-        asio::system_error(std::get<0>(args)));
-
-  return std::apply(
-      [](auto, auto&&... rest)
-      {
-        return std::make_tuple(std::move(rest)...);
-      }, std::move(args));
-}
-
-template <typename  Arg>
-inline auto coro_interpret_result(std::tuple<Arg>&& args)
-{
-  return std::get<0>(std::move(args));
-}
-
-template <typename Arg>
-auto coro_interpret_result(std::tuple<std::exception_ptr, Arg>&& args)
-{
-  if (std::get<0>(args))
-    std::rethrow_exception(std::get<0>(args));
-  return std::get<1>(std::move(args));
-}
-
-inline auto coro_interpret_result(
-    std::tuple<asio::error_code>&& args)
-{
-  if (std::get<0>(args))
-    asio::detail::throw_exception(
-        asio::system_error(std::get<0>(args)));
-}
-
-inline auto coro_interpret_result(std::tuple<std::exception_ptr>&& args)
-{
-  if (std::get<0>(args))
-    std::rethrow_exception(std::get<0>(args));
-}
-
-template <typename Arg>
-auto coro_interpret_result(std::tuple<asio::error_code, Arg>&& args)
-{
-  if (std::get<0>(args))
-    asio::detail::throw_exception(
-        asio::system_error(std::get<0>(args)));
-  return std::get<1>(std::move(args));
-}
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_promise_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_promise_allocator.hpp
deleted file mode 100644
index f740a1c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/coro_promise_allocator.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//
-// experimental/detail/coro_promise_allocator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
-
-#include "asio/detail/config.hpp"
-#include "asio/experimental/coro_traits.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-/// Allocate the memory and put the allocator behind the coro memory
-template <typename AllocatorType>
-void* allocate_coroutine(const std::size_t size, AllocatorType alloc_)
-{
-  using alloc_type = typename std::allocator_traits<AllocatorType>::template
-    rebind_alloc<unsigned char>;
-  alloc_type alloc{alloc_};
-
-  const auto align_needed = size % alignof(alloc_type);
-  const auto align_offset = align_needed != 0
-    ? alignof(alloc_type) - align_needed : 0ull;
-  const auto alloc_size = size + sizeof(alloc_type) + align_offset;
-  const auto raw =
-    std::allocator_traits<alloc_type>::allocate(alloc, alloc_size);
-  new(raw + size + align_offset) alloc_type(std::move(alloc));
-
-  return raw;
-}
-
-/// Deallocate the memory and destroy the allocator in the coro memory.
-template <typename AllocatorType>
-void deallocate_coroutine(void* raw_, const std::size_t size)
-{
-  using alloc_type = typename std::allocator_traits<AllocatorType>::template
-    rebind_alloc<unsigned char>;
-
-  const auto raw = static_cast<unsigned char *>(raw_);
-
-  const auto align_needed = size % alignof(alloc_type);
-  const auto align_offset = align_needed != 0
-    ? alignof(alloc_type) - align_needed : 0ull;
-  const auto alloc_size = size + sizeof(alloc_type) + align_offset;
-
-  auto alloc_p = reinterpret_cast<alloc_type *>(raw + size + align_offset);
-  auto alloc = std::move(*alloc_p);
-  alloc_p->~alloc_type();
-  std::allocator_traits<alloc_type>::deallocate(alloc, raw, alloc_size);
-}
-
-template <typename T>
-constexpr std::size_t variadic_first(std::size_t = 0u)
-{
-  return std::numeric_limits<std::size_t>::max();
-}
-
-template <typename T, typename First, typename... Args>
-constexpr std::size_t variadic_first(std::size_t pos = 0u)
-{
-  if constexpr (std::is_same_v<std::decay_t<First>, T>)
-    return pos;
-  else
-    return variadic_first<T, Args...>(pos+1);
-}
-
-template <std::size_t Idx, typename First, typename... Args>
-  requires (Idx <= sizeof...(Args))
-constexpr decltype(auto) get_variadic(First&& first, Args&&... args)
-{
-  if constexpr (Idx == 0u)
-    return static_cast<First>(first);
-  else
-    return get_variadic<Idx-1u>(static_cast<Args>(args)...);
-}
-
-template <std::size_t Idx>
-constexpr decltype(auto) get_variadic();
-
-template <typename Allocator>
-struct coro_promise_allocator
-{
-  using allocator_type = Allocator;
-  allocator_type get_allocator() const {return alloc_;}
-
-  template <typename... Args>
-  void* operator new(std::size_t size, Args & ... args)
-  {
-    return allocate_coroutine(size,
-        get_variadic<variadic_first<std::allocator_arg_t,
-          std::decay_t<Args>...>() + 1u>(args...));
-  }
-
-  void operator delete(void* raw, std::size_t size)
-  {
-    deallocate_coroutine<allocator_type>(raw, size);
-  }
-
-  template <typename... Args>
-  coro_promise_allocator(Args&& ... args)
-    : alloc_(
-        get_variadic<variadic_first<std::allocator_arg_t,
-          std::decay_t<Args>...>() + 1u>(args...))
-  {
-  }
-
-private:
-  allocator_type alloc_;
-};
-
-template <>
-struct coro_promise_allocator<std::allocator<void>>
-{
-  using allocator_type = std::allocator<void>;
-
-  template <typename... Args>
-  coro_promise_allocator(Args&&...)
-  {
-  }
-
-  allocator_type get_allocator() const
-  {
-    return {};
-  }
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_CORO_PROMISE_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/has_signature.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/has_signature.hpp
deleted file mode 100644
index ea5dac8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/has_signature.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// experimental/detail/has_signature.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename S, typename... Signatures>
-struct has_signature;
-
-template <typename S, typename... Signatures>
-struct has_signature;
-
-template <typename S>
-struct has_signature<S> : false_type
-{
-};
-
-template <typename S, typename... Signatures>
-struct has_signature<S, S, Signatures...> : true_type
-{
-};
-
-template <typename S, typename Head, typename... Tail>
-struct has_signature<S, Head, Tail...> : has_signature<S, Tail...>
-{
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_HAS_SIGNATURE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/impl/channel_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/impl/channel_service.hpp
deleted file mode 100644
index 93720f4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/impl/channel_service.hpp
+++ /dev/null
@@ -1,623 +0,0 @@
-//
-// experimental/detail/impl/channel_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <typename Mutex>
-inline channel_service<Mutex>::channel_service(
-    asio::execution_context& ctx)
-  : asio::detail::execution_context_service_base<channel_service>(ctx),
-    mutex_(),
-    impl_list_(0)
-{
-}
-
-template <typename Mutex>
-inline void channel_service<Mutex>::shutdown()
-{
-  // Abandon all pending operations.
-  asio::detail::op_queue<channel_operation> ops;
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  base_implementation_type* impl = impl_list_;
-  while (impl)
-  {
-    ops.push(impl->waiters_);
-    impl = impl->next_;
-  }
-}
-
-template <typename Mutex>
-inline void channel_service<Mutex>::construct(
-    channel_service<Mutex>::base_implementation_type& impl,
-    std::size_t max_buffer_size)
-{
-  impl.max_buffer_size_ = max_buffer_size;
-  impl.receive_state_ = block;
-  impl.send_state_ = max_buffer_size ? buffer : block;
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::destroy(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
-{
-  cancel(impl);
-  base_destroy(impl);
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::move_construct(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-    channel_service<Mutex>::implementation_type<
-      Traits, Signatures...>& other_impl)
-{
-  impl.max_buffer_size_ = other_impl.max_buffer_size_;
-  impl.receive_state_ = other_impl.receive_state_;
-  other_impl.receive_state_ = block;
-  impl.send_state_ = other_impl.send_state_;
-  other_impl.send_state_ = other_impl.max_buffer_size_ ? buffer : block;
-  impl.buffer_move_from(other_impl);
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::move_assign(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-    channel_service& other_service,
-    channel_service<Mutex>::implementation_type<
-      Traits, Signatures...>& other_impl)
-{
-  cancel(impl);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    if (impl_list_ == &impl)
-      impl_list_ = impl.next_;
-    if (impl.prev_)
-      impl.prev_->next_ = impl.next_;
-    if (impl.next_)
-      impl.next_->prev_= impl.prev_;
-    impl.next_ = 0;
-    impl.prev_ = 0;
-  }
-
-  impl.max_buffer_size_ = other_impl.max_buffer_size_;
-  impl.receive_state_ = other_impl.receive_state_;
-  other_impl.receive_state_ = block;
-  impl.send_state_ = other_impl.send_state_;
-  other_impl.send_state_ = other_impl.max_buffer_size_ ? buffer : block;
-  impl.buffer_move_from(other_impl);
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    asio::detail::mutex::scoped_lock lock(other_service.mutex_);
-    impl.next_ = other_service.impl_list_;
-    impl.prev_ = 0;
-    if (other_service.impl_list_)
-      other_service.impl_list_->prev_ = &impl;
-    other_service.impl_list_ = &impl;
-  }
-}
-
-template <typename Mutex>
-inline void channel_service<Mutex>::base_destroy(
-    channel_service<Mutex>::base_implementation_type& impl)
-{
-  // Remove implementation from linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-}
-
-template <typename Mutex>
-inline std::size_t channel_service<Mutex>::capacity(
-    const channel_service<Mutex>::base_implementation_type& impl)
-  const noexcept
-{
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  return impl.max_buffer_size_;
-}
-
-template <typename Mutex>
-inline bool channel_service<Mutex>::is_open(
-    const channel_service<Mutex>::base_implementation_type& impl)
-  const noexcept
-{
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  return impl.send_state_ != closed;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::reset(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
-{
-  cancel(impl);
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  impl.receive_state_ = block;
-  impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-  impl.buffer_clear();
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::close(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::traits_type traits_type;
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  if (impl.receive_state_ == block)
-  {
-    while (channel_operation* op = impl.waiters_.front())
-    {
-      impl.waiters_.pop();
-      traits_type::invoke_receive_closed(
-          post_receive<payload_type,
-            typename traits_type::receive_closed_signature>(
-              static_cast<channel_receive<payload_type>*>(op)));
-    }
-  }
-
-  impl.send_state_ = closed;
-  if (impl.receive_state_ != buffer)
-    impl.receive_state_ = closed;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::cancel(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::traits_type traits_type;
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  while (channel_operation* op = impl.waiters_.front())
-  {
-    if (impl.send_state_ == block)
-    {
-      impl.waiters_.pop();
-      static_cast<channel_send<payload_type>*>(op)->cancel();
-    }
-    else
-    {
-      impl.waiters_.pop();
-      traits_type::invoke_receive_cancelled(
-          post_receive<payload_type,
-            typename traits_type::receive_cancelled_signature>(
-              static_cast<channel_receive<payload_type>*>(op)));
-    }
-  }
-
-  if (impl.receive_state_ == waiter)
-    impl.receive_state_ = block;
-  if (impl.send_state_ == waiter)
-    impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::cancel_by_key(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-    void* cancellation_key)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::traits_type traits_type;
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  asio::detail::op_queue<channel_operation> other_ops;
-  while (channel_operation* op = impl.waiters_.front())
-  {
-    if (op->cancellation_key_ == cancellation_key)
-    {
-      if (impl.send_state_ == block)
-      {
-        impl.waiters_.pop();
-        static_cast<channel_send<payload_type>*>(op)->cancel();
-      }
-      else
-      {
-        impl.waiters_.pop();
-        traits_type::invoke_receive_cancelled(
-            post_receive<payload_type,
-              typename traits_type::receive_cancelled_signature>(
-                static_cast<channel_receive<payload_type>*>(op)));
-      }
-    }
-    else
-    {
-      impl.waiters_.pop();
-      other_ops.push(op);
-    }
-  }
-  impl.waiters_.push(other_ops);
-
-  if (impl.waiters_.empty())
-  {
-    if (impl.receive_state_ == waiter)
-      impl.receive_state_ = block;
-    if (impl.send_state_ == waiter)
-      impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-  }
-}
-
-template <typename Mutex>
-inline bool channel_service<Mutex>::ready(
-    const channel_service<Mutex>::base_implementation_type& impl)
-  const noexcept
-{
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  return impl.receive_state_ != block;
-}
-
-template <typename Mutex>
-template <typename Message, typename Traits,
-    typename... Signatures, typename... Args>
-bool channel_service<Mutex>::try_send(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-    bool via_dispatch, Args&&... args)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  switch (impl.send_state_)
-  {
-  case block:
-    {
-      return false;
-    }
-  case buffer:
-    {
-      impl.buffer_push(Message(0, static_cast<Args&&>(args)...));
-      impl.receive_state_ = buffer;
-      if (impl.buffer_size() == impl.max_buffer_size_)
-        impl.send_state_ = block;
-      return true;
-    }
-  case waiter:
-    {
-      payload_type payload(Message(0, static_cast<Args&&>(args)...));
-      channel_receive<payload_type>* receive_op =
-        static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
-      impl.waiters_.pop();
-      if (impl.waiters_.empty())
-        impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-      lock.unlock();
-      if (via_dispatch)
-        receive_op->dispatch(static_cast<payload_type&&>(payload));
-      else
-        receive_op->post(static_cast<payload_type&&>(payload));
-      return true;
-    }
-  case closed:
-  default:
-    {
-      return false;
-    }
-  }
-}
-
-template <typename Mutex>
-template <typename Message, typename Traits,
-    typename... Signatures, typename... Args>
-std::size_t channel_service<Mutex>::try_send_n(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		std::size_t count, bool via_dispatch, Args&&... args)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  if (count == 0)
-    return 0;
-
-  switch (impl.send_state_)
-  {
-  case block:
-    return 0;
-  case buffer:
-  case waiter:
-    break;
-  case closed:
-  default:
-    return 0;
-  }
-
-  payload_type payload(Message(0, static_cast<Args&&>(args)...));
-
-  for (std::size_t i = 0; i < count; ++i)
-  {
-    switch (impl.send_state_)
-    {
-    case block:
-      {
-        return i;
-      }
-    case buffer:
-      {
-        i += impl.buffer_push_n(count - i,
-            static_cast<payload_type&&>(payload));
-        impl.receive_state_ = buffer;
-        if (impl.buffer_size() == impl.max_buffer_size_)
-          impl.send_state_ = block;
-        return i;
-      }
-    case waiter:
-      {
-        channel_receive<payload_type>* receive_op =
-          static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
-        impl.waiters_.pop();
-        if (impl.waiters_.empty())
-          impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-        lock.unlock();
-        if (via_dispatch)
-          receive_op->dispatch(payload);
-        else
-          receive_op->post(payload);
-        break;
-      }
-    case closed:
-    default:
-      {
-        return i;
-      }
-    }
-  }
-
-  return count;
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::start_send_op(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		channel_send<typename implementation_type<
-			Traits, Signatures...>::payload_type>* send_op)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  switch (impl.send_state_)
-  {
-  case block:
-    {
-      impl.waiters_.push(send_op);
-      if (impl.receive_state_ == block)
-        impl.receive_state_ = waiter;
-      return;
-    }
-  case buffer:
-    {
-      impl.buffer_push(send_op->get_payload());
-      impl.receive_state_ = buffer;
-      if (impl.buffer_size() == impl.max_buffer_size_)
-        impl.send_state_ = block;
-      send_op->immediate();
-      break;
-    }
-  case waiter:
-    {
-      channel_receive<payload_type>* receive_op =
-        static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
-      impl.waiters_.pop();
-      if (impl.waiters_.empty())
-        impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
-      receive_op->post(send_op->get_payload());
-      send_op->immediate();
-      break;
-    }
-  case closed:
-  default:
-    {
-      send_op->close();
-      break;
-    }
-  }
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures, typename Handler>
-bool channel_service<Mutex>::try_receive(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		Handler&& handler)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  switch (impl.receive_state_)
-  {
-  case block:
-    {
-      return false;
-    }
-  case buffer:
-    {
-      payload_type payload(impl.buffer_front());
-      if (channel_send<payload_type>* send_op =
-          static_cast<channel_send<payload_type>*>(impl.waiters_.front()))
-      {
-        impl.buffer_pop();
-        impl.buffer_push(send_op->get_payload());
-        impl.waiters_.pop();
-        send_op->post();
-      }
-      else
-      {
-        impl.buffer_pop();
-        if (impl.buffer_size() == 0)
-          impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
-        impl.send_state_ = (impl.send_state_ == closed) ? closed : buffer;
-      }
-      lock.unlock();
-      asio::detail::non_const_lvalue<Handler> handler2(handler);
-      asio::detail::completion_payload_handler<
-        payload_type, decay_t<Handler>>(
-          static_cast<payload_type&&>(payload), handler2.value)();
-      return true;
-    }
-  case waiter:
-    {
-      channel_send<payload_type>* send_op =
-        static_cast<channel_send<payload_type>*>(impl.waiters_.front());
-      payload_type payload = send_op->get_payload();
-      impl.waiters_.pop();
-      if (impl.waiters_.front() == 0)
-        impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
-      send_op->post();
-      lock.unlock();
-      asio::detail::non_const_lvalue<Handler> handler2(handler);
-      asio::detail::completion_payload_handler<
-        payload_type, decay_t<Handler>>(
-          static_cast<payload_type&&>(payload), handler2.value)();
-      return true;
-    }
-  case closed:
-  default:
-    {
-      return false;
-    }
-  }
-}
-
-template <typename Mutex>
-template <typename Traits, typename... Signatures>
-void channel_service<Mutex>::start_receive_op(
-    channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		channel_receive<typename implementation_type<
-			Traits, Signatures...>::payload_type>* receive_op)
-{
-  typedef typename implementation_type<Traits,
-      Signatures...>::traits_type traits_type;
-  typedef typename implementation_type<Traits,
-      Signatures...>::payload_type payload_type;
-
-  typename Mutex::scoped_lock lock(impl.mutex_);
-
-  switch (impl.receive_state_)
-  {
-  case block:
-    {
-      impl.waiters_.push(receive_op);
-      if (impl.send_state_ != closed)
-        impl.send_state_ = waiter;
-      return;
-    }
-  case buffer:
-    {
-      payload_type payload(
-          static_cast<payload_type&&>(impl.buffer_front()));
-      if (channel_send<payload_type>* send_op =
-          static_cast<channel_send<payload_type>*>(impl.waiters_.front()))
-      {
-        impl.buffer_pop();
-        impl.buffer_push(send_op->get_payload());
-        impl.waiters_.pop();
-        send_op->post();
-      }
-      else
-      {
-        impl.buffer_pop();
-        if (impl.buffer_size() == 0)
-          impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
-        impl.send_state_ = (impl.send_state_ == closed) ? closed : buffer;
-      }
-      receive_op->immediate(static_cast<payload_type&&>(payload));
-      break;
-    }
-  case waiter:
-    {
-      channel_send<payload_type>* send_op =
-        static_cast<channel_send<payload_type>*>(impl.waiters_.front());
-      payload_type payload = send_op->get_payload();
-      impl.waiters_.pop();
-      if (impl.waiters_.front() == 0)
-        impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
-      send_op->post();
-      receive_op->immediate(static_cast<payload_type&&>(payload));
-      break;
-    }
-  case closed:
-  default:
-    {
-      traits_type::invoke_receive_closed(
-          post_receive<payload_type,
-            typename traits_type::receive_closed_signature>(receive_op));
-      break;
-    }
-  }
-}
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_IMPL_CHANNEL_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/partial_promise.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/partial_promise.hpp
deleted file mode 100644
index 5ca2931..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/detail/partial_promise.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-//
-// experimental/detail/partial_promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
-#define ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
-
-#include "asio/detail/config.hpp"
-#include "asio/append.hpp"
-#include "asio/awaitable.hpp"
-#include "asio/experimental/coro_traits.hpp"
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-# include <coroutine>
-#else // defined(ASIO_HAS_STD_COROUTINE)
-# include <experimental/coroutine>
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-
-using std::coroutine_handle;
-using std::coroutine_traits;
-using std::suspend_never;
-using std::suspend_always;
-using std::noop_coroutine;
-
-#else // defined(ASIO_HAS_STD_COROUTINE)
-
-using std::experimental::coroutine_handle;
-using std::experimental::coroutine_traits;
-using std::experimental::suspend_never;
-using std::experimental::suspend_always;
-using std::experimental::noop_coroutine;
-
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-struct partial_coro
-{
-  coroutine_handle<void> handle{nullptr};
-};
-
-template <typename Allocator>
-struct partial_promise_base
-{
-  template <typename Executor, typename Token, typename... Args>
-  void* operator new(std::size_t size, Executor&, Token& tk, Args&...)
-  {
-    return allocate_coroutine<Allocator>(size, get_associated_allocator(tk));
-  }
-
-  void operator delete(void* raw, std::size_t size)
-  {
-    deallocate_coroutine<Allocator>(raw, size);
-  }
-};
-
-template <>
-struct partial_promise_base<std::allocator<void>>
-{
-};
-
-template <typename Allocator>
-struct partial_promise : partial_promise_base<Allocator>
-{
-  auto initial_suspend() noexcept
-  {
-    return asio::detail::suspend_always{};
-  }
-
-  auto final_suspend() noexcept
-  {
-    struct awaitable_t
-    {
-      partial_promise *p;
-
-      constexpr bool await_ready() noexcept { return true; }
-
-      auto await_suspend(asio::detail::coroutine_handle<>) noexcept
-      {
-        p->get_return_object().handle.destroy();
-      }
-
-      constexpr void await_resume() noexcept {}
-    };
-
-    return awaitable_t{this};
-  }
-
-  void return_void() {}
-
-  partial_coro get_return_object()
-  {
-    return partial_coro{coroutine_handle<partial_promise>::from_promise(*this)};
-  }
-
-  void unhandled_exception()
-  {
-    assert(false);
-  }
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#if defined(ASIO_HAS_STD_COROUTINE)
-
-namespace std {
-
-template <typename Executor, typename Completion, typename... Args>
-struct coroutine_traits<
-    asio::experimental::detail::partial_coro,
-    Executor, Completion, Args...>
-{
-  using promise_type =
-    asio::experimental::detail::partial_promise<
-      asio::associated_allocator_t<Completion>>;
-};
-
-} // namespace std
-
-#else // defined(ASIO_HAS_STD_COROUTINE)
-
-namespace std { namespace experimental {
-
-template <typename Executor, typename Completion, typename... Args>
-struct coroutine_traits<
-    asio::experimental::detail::partial_coro,
-    Executor, Completion, Args...>
-{
-  using promise_type =
-    asio::experimental::detail::partial_promise<
-      asio::associated_allocator_t<Completion>>;
-};
-
-}} // namespace std::experimental
-
-#endif // defined(ASIO_HAS_STD_COROUTINE)
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-template <execution::executor Executor,
-    typename CompletionToken, typename... Args>
-partial_coro post_coroutine(Executor exec,
-    CompletionToken token, Args&&... args) noexcept
-{
-  post(exec, asio::append(std::move(token), std::move(args)...));
-  co_return;
-}
-
-template <detail::execution_context Context,
-    typename CompletionToken, typename... Args>
-partial_coro post_coroutine(Context& ctx,
-    CompletionToken token, Args&&... args) noexcept
-{
-  post(ctx, asio::append(std::move(token), std::move(args)...));
-  co_return;
-}
-
-template <execution::executor Executor,
-    typename CompletionToken, typename... Args>
-partial_coro dispatch_coroutine(Executor exec,
-    CompletionToken token, Args&&... args) noexcept
-{
-  dispatch(exec, asio::append(std::move(token), std::move(args)...));
-  co_return;
-}
-
-template <detail::execution_context Context,
-    typename CompletionToken, typename... Args>
-partial_coro dispatch_coroutine(Context& ctx,
-    CompletionToken token, Args &&... args) noexcept
-{
-  dispatch(ctx, asio::append(std::move(token), std::move(args)...));
-  co_return;
-}
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#endif // ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/as_single.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/as_single.hpp
deleted file mode 100644
index 84e6f13..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/as_single.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-//
-// experimental/impl/as_single.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXPERIMENTAL_AS_SINGLE_HPP
-#define ASIO_IMPL_EXPERIMENTAL_AS_SINGLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-// Class to adapt a as_single_t as a completion handler.
-template <typename Handler>
-class as_single_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename CompletionToken>
-  as_single_handler(as_single_t<CompletionToken> e)
-    : handler_(static_cast<CompletionToken&&>(e.token_))
-  {
-  }
-
-  template <typename RedirectedHandler>
-  as_single_handler(RedirectedHandler&& h)
-    : handler_(static_cast<RedirectedHandler&&>(h))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)();
-  }
-
-  template <typename Arg>
-  void operator()(Arg&& arg)
-  {
-    static_cast<Handler&&>(handler_)(static_cast<Arg&&>(arg));
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(
-        std::make_tuple(static_cast<Args&&>(args)...));
-  }
-
-//private:
-  Handler handler_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    as_single_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Signature>
-struct as_single_signature
-{
-  typedef Signature type;
-};
-
-template <typename R>
-struct as_single_signature<R()>
-{
-  typedef R type();
-};
-
-template <typename R, typename Arg>
-struct as_single_signature<R(Arg)>
-{
-  typedef R type(Arg);
-};
-
-template <typename R, typename... Args>
-struct as_single_signature<R(Args...)>
-{
-  typedef R type(std::tuple<decay_t<Args>...>);
-};
-
-} // namespace detail
-} // namespace experimental
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename Signature>
-struct async_result<experimental::as_single_t<CompletionToken>, Signature>
-{
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          experimental::detail::as_single_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          experimental::detail::as_single_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<CompletionToken,
-        typename experimental::detail::as_single_signature<Signature>::type>(
-          init_wrapper<decay_t<Initiation>>(
-            static_cast<Initiation&&>(initiation)),
-          token.token_, static_cast<Args&&>(args)...))
-  {
-    return async_initiate<CompletionToken,
-      typename experimental::detail::as_single_signature<Signature>::type>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    experimental::detail::as_single_handler<Handler>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::as_single_handler<Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const experimental::detail::as_single_handler<Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_EXPERIMENTAL_AS_SINGLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/channel_error.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/channel_error.ipp
deleted file mode 100644
index 3f4b982..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/channel_error.ipp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// experimental/impl/channel_error.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
-#define ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/experimental/channel_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace error {
-namespace detail {
-
-class channel_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.channel";
-  }
-
-  std::string message(int value) const
-  {
-    switch (value)
-    {
-    case channel_closed: return "Channel closed";
-    case channel_cancelled: return "Channel cancelled";
-    default: return "asio.channel error";
-    }
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_channel_category()
-{
-  static detail::channel_category instance;
-  return instance;
-}
-
-} // namespace error
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_IMPL_CHANNEL_ERROR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/coro.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/coro.hpp
deleted file mode 100644
index 872d1a0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/coro.hpp
+++ /dev/null
@@ -1,1222 +0,0 @@
-//
-// experimental/impl/coro.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//
-#ifndef ASIO_EXPERIMENTAL_IMPL_CORO_HPP
-#define ASIO_EXPERIMENTAL_IMPL_CORO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/append.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/bind_allocator.hpp"
-#include "asio/deferred.hpp"
-#include "asio/experimental/detail/coro_completion_handler.hpp"
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-template <typename Yield, typename Return,
-    typename Executor, typename Allocator>
-struct coro;
-
-namespace detail {
-
-struct coro_cancellation_source
-{
-  cancellation_slot slot;
-  cancellation_state state;
-  bool throw_if_cancelled_ = true;
-
-  void reset_cancellation_state()
-  {
-    state = cancellation_state(slot);
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter&& filter)
-  {
-    state = cancellation_state(slot, static_cast<Filter&&>(filter));
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter,
-      OutFilter&& out_filter)
-  {
-    state = cancellation_state(slot,
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  bool throw_if_cancelled() const
-  {
-    return throw_if_cancelled_;
-  }
-
-  void throw_if_cancelled(bool value)
-  {
-    throw_if_cancelled_ = value;
-  }
-};
-
-template <typename Signature, typename Return,
-    typename Executor, typename Allocator>
-struct coro_promise;
-
-template <typename T>
-struct is_noexcept : std::false_type
-{
-};
-
-template <typename Return, typename... Args>
-struct is_noexcept<Return(Args...)> : std::false_type
-{
-};
-
-template <typename Return, typename... Args>
-struct is_noexcept<Return(Args...) noexcept> : std::true_type
-{
-};
-
-template <typename T>
-constexpr bool is_noexcept_v = is_noexcept<T>::value;
-
-template <typename T>
-struct coro_error;
-
-template <>
-struct coro_error<asio::error_code>
-{
-  static asio::error_code invalid()
-  {
-    return asio::error::fault;
-  }
-
-  static asio::error_code cancelled()
-  {
-    return asio::error::operation_aborted;
-  }
-
-  static asio::error_code interrupted()
-  {
-    return asio::error::interrupted;
-  }
-
-  static asio::error_code done()
-  {
-    return asio::error::broken_pipe;
-  }
-};
-
-template <>
-struct coro_error<std::exception_ptr>
-{
-  static std::exception_ptr invalid()
-  {
-    return std::make_exception_ptr(
-        asio::system_error(
-          coro_error<asio::error_code>::invalid()));
-  }
-
-  static std::exception_ptr cancelled()
-  {
-    return std::make_exception_ptr(
-        asio::system_error(
-          coro_error<asio::error_code>::cancelled()));
-  }
-
-  static std::exception_ptr interrupted()
-  {
-    return std::make_exception_ptr(
-        asio::system_error(
-          coro_error<asio::error_code>::interrupted()));
-  }
-
-  static std::exception_ptr done()
-  {
-    return std::make_exception_ptr(
-        asio::system_error(
-          coro_error<asio::error_code>::done()));
-  }
-};
-
-template <typename T, typename Coroutine >
-struct coro_with_arg
-{
-  using coro_t = Coroutine;
-  T value;
-  coro_t& coro;
-
-  struct awaitable_t
-  {
-    T value;
-    coro_t& coro;
-
-    constexpr static bool await_ready() { return false; }
-
-    template <typename Y, typename R, typename E, typename A>
-    auto await_suspend(coroutine_handle<coro_promise<Y, R, E, A>> h)
-      -> coroutine_handle<>
-    {
-      auto& hp = h.promise();
-
-      if constexpr (!coro_promise<Y, R, E, A>::is_noexcept)
-      {
-        if ((hp.cancel->state.cancelled() != cancellation_type::none)
-            && hp.cancel->throw_if_cancelled_)
-        {
-          asio::detail::throw_error(
-              asio::error::operation_aborted, "coro-cancelled");
-        }
-      }
-
-      if (hp.get_executor() == coro.get_executor())
-      {
-        coro.coro_->awaited_from = h;
-        coro.coro_->reset_error();
-        coro.coro_->input_ = std::move(value);
-        coro.coro_->cancel = hp.cancel;
-        return coro.coro_->get_handle();
-      }
-      else
-      {
-        coro.coro_->awaited_from =
-          dispatch_coroutine(
-              asio::prefer(hp.get_executor(),
-                execution::outstanding_work.tracked),
-                [h]() mutable { h.resume(); }).handle;
-
-        coro.coro_->reset_error();
-        coro.coro_->input_ = std::move(value);
-
-        struct cancel_handler
-        {
-          using src = std::pair<cancellation_signal,
-                detail::coro_cancellation_source>;
-
-          std::shared_ptr<src> st = std::make_shared<src>();
-
-          cancel_handler(E e, coro_t& coro) : e(e), coro_(coro.coro_)
-          {
-            st->second.state =
-              cancellation_state(st->second.slot = st->first.slot());
-          }
-
-          E e;
-          typename coro_t::promise_type* coro_;
-
-          void operator()(cancellation_type ct)
-          {
-            asio::dispatch(e, [ct, st = st]() mutable
-            {
-              auto & [sig, state] = *st;
-              sig.emit(ct);
-            });
-          }
-        };
-
-        if (hp.cancel->state.slot().is_connected())
-        {
-          hp.cancel->state.slot().template emplace<cancel_handler>(
-              coro.get_executor(), coro);
-        }
-
-        auto hh = detail::coroutine_handle<
-          typename coro_t::promise_type>::from_promise(*coro.coro_);
-
-        return dispatch_coroutine(
-            coro.coro_->get_executor(), [hh]() mutable { hh.resume(); }).handle;
-      }
-    }
-
-    auto await_resume() -> typename coro_t::result_type
-    {
-      coro.coro_->cancel = nullptr;
-      coro.coro_->rethrow_if();
-      return std::move(coro.coro_->result_);
-    }
-  };
-
-  template <typename CompletionToken>
-  auto async_resume(CompletionToken&& token) &&
-  {
-    return coro.async_resume(std::move(value),
-        std::forward<CompletionToken>(token));
-  }
-
-  auto operator co_await() &&
-  {
-    return awaitable_t{std::move(value), coro};
-  }
-};
-
-template <bool IsNoexcept>
-struct coro_promise_error;
-
-template <>
-struct coro_promise_error<false>
-{
-  std::exception_ptr error_;
-
-  void reset_error()
-  {
-    error_ = std::exception_ptr{};
-  }
-
-  void unhandled_exception()
-  {
-    error_ = std::current_exception();
-  }
-
-  void rethrow_if()
-  {
-    if (error_)
-      std::rethrow_exception(error_);
-  }
-};
-
-#if defined(__GNUC__)
-# pragma GCC diagnostic push
-# if defined(__clang__)
-#  pragma GCC diagnostic ignored "-Wexceptions"
-# else
-#  pragma GCC diagnostic ignored "-Wterminate"
-# endif
-#elif defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning (disable:4297)
-#endif
-
-template <>
-struct coro_promise_error<true>
-{
-  void reset_error()
-  {
-  }
-
-  void unhandled_exception() noexcept
-  {
-    throw;
-  }
-
-  void rethrow_if()
-  {
-  }
-};
-
-#if defined(__GNUC__)
-# pragma GCC diagnostic pop
-#elif defined(_MSC_VER)
-# pragma warning(pop)
-#endif
-
-template <typename T = void>
-struct yield_input
-{
-  T& value;
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  template <typename U>
-  coroutine_handle<> await_suspend(coroutine_handle<U>) noexcept
-  {
-    return std::exchange(awaited_from, noop_coroutine());
-  }
-
-  T await_resume() const noexcept
-  {
-    return std::move(value);
-  }
-};
-
-template <>
-struct yield_input<void>
-{
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  auto await_suspend(coroutine_handle<>) noexcept
-  {
-    return std::exchange(awaited_from, noop_coroutine());
-  }
-
-  constexpr void await_resume() const noexcept
-  {
-  }
-};
-
-struct coro_awaited_from
-{
-  coroutine_handle<> awaited_from{noop_coroutine()};
-
-  auto final_suspend() noexcept
-  {
-    struct suspendor
-    {
-      coroutine_handle<> awaited_from;
-
-      constexpr static bool await_ready() noexcept
-      {
-        return false;
-      }
-
-      auto await_suspend(coroutine_handle<>) noexcept
-      {
-        return std::exchange(awaited_from, noop_coroutine());
-      }
-
-      constexpr static void await_resume() noexcept
-      {
-      }
-    };
-
-    return suspendor{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  ~coro_awaited_from()
-  {
-    awaited_from.resume();
-  }//must be on the right executor
-};
-
-template <typename Yield, typename Input, typename Return>
-struct coro_promise_exchange : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, Return>;
-
-  result_type result_;
-  Input input_;
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<Input>{std::move(input_),
-        std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<Input>{std::move(input_),
-        std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const Return& r)
-  {
-    result_ = r;
-  }
-
-  void return_value(Return&& r)
-  {
-    result_ = std::move(r);
-  }
-};
-
-template <typename YieldReturn>
-struct coro_promise_exchange<YieldReturn, void, YieldReturn> : coro_awaited_from
-{
-  using result_type = coro_result_t<YieldReturn, YieldReturn>;
-
-  result_type result_;
-
-  auto yield_value(const YieldReturn& y)
-  {
-    result_ = y;
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(YieldReturn&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const YieldReturn& r)
-  {
-    result_ = r;
-  }
-
-  void return_value(YieldReturn&& r)
-  {
-    result_ = std::move(r);
-  }
-};
-
-template <typename Yield, typename Return>
-struct coro_promise_exchange<Yield, void, Return> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, Return>;
-
-  result_type result_;
-
-  auto yield_value(const Yield& y)
-  {
-    result_.template emplace<0>(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(Yield&& y)
-  {
-    result_.template emplace<0>(std::move(y));
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_value(const Return& r)
-  {
-    result_.template emplace<1>(r);
-  }
-
-  void return_value(Return&& r)
-  {
-    result_.template emplace<1>(std::move(r));
-  }
-};
-
-template <typename Yield, typename Input>
-struct coro_promise_exchange<Yield, Input, void> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, void>;
-
-  result_type result_;
-  Input input_;
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<Input>{input_,
-                              std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<Input>{input_,
-                              std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_void()
-  {
-    result_.reset();
-  }
-};
-
-template <typename Return>
-struct coro_promise_exchange<void, void, Return> : coro_awaited_from
-{
-  using result_type = coro_result_t<void, Return>;
-
-  result_type result_;
-
-  void yield_value();
-
-  void return_value(const Return& r)
-  {
-    result_ = r;
-  }
-
-  void return_value(Return&& r)
-  {
-    result_ = std::move(r);
-  }
-};
-
-template <>
-struct coro_promise_exchange<void, void, void> : coro_awaited_from
-{
-  void return_void() {}
-
-  void yield_value();
-};
-
-template <typename Yield>
-struct coro_promise_exchange<Yield, void, void> : coro_awaited_from
-{
-  using result_type = coro_result_t<Yield, void>;
-
-  result_type result_;
-
-  auto yield_value(const Yield& y)
-  {
-    result_ = y;
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  auto yield_value(Yield&& y)
-  {
-    result_ = std::move(y);
-    return yield_input<void>{std::exchange(awaited_from, noop_coroutine())};
-  }
-
-  void return_void()
-  {
-    result_.reset();
-  }
-};
-
-template <typename Yield, typename Return,
-    typename Executor, typename Allocator>
-struct coro_promise final :
-  coro_promise_allocator<Allocator>,
-  coro_promise_error<coro_traits<Yield, Return, Executor>::is_noexcept>,
-  coro_promise_exchange<
-      typename coro_traits<Yield, Return, Executor>::yield_type,
-      typename coro_traits<Yield, Return, Executor>::input_type,
-      typename coro_traits<Yield, Return, Executor>::return_type>
-{
-  using coro_type = coro<Yield, Return, Executor, Allocator>;
-
-  auto handle()
-  {
-    return coroutine_handle<coro_promise>::from_promise(this);
-  }
-
-  using executor_type = Executor;
-
-  executor_type executor_;
-
-  std::optional<coro_cancellation_source> cancel_source;
-  coro_cancellation_source * cancel;
-
-  using cancellation_slot_type = asio::cancellation_slot;
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancel ? cancel->slot : cancellation_slot_type{};
-  }
-
-  using allocator_type =
-    typename std::allocator_traits<associated_allocator_t<Executor>>::
-      template rebind_alloc<std::byte>;
-  using traits = coro_traits<Yield, Return, Executor>;
-
-  using input_type = typename traits::input_type;
-  using yield_type = typename traits::yield_type;
-  using return_type = typename traits::return_type;
-  using error_type = typename traits::error_type;
-  using result_type = typename traits::result_type;
-  constexpr static bool is_noexcept = traits::is_noexcept;
-
-  auto get_executor() const -> Executor
-  {
-    return executor_;
-  }
-
-  auto get_handle()
-  {
-    return coroutine_handle<coro_promise>::from_promise(*this);
-  }
-
-  template <typename... Args>
-  coro_promise(Executor executor, Args&&... args) noexcept
-    : coro_promise_allocator<Allocator>(
-        executor, std::forward<Args>(args)...),
-      executor_(std::move(executor))
-  {
-  }
-
-  template <typename First, typename... Args>
-  coro_promise(First&& f, Executor executor, Args&&... args) noexcept
-    : coro_promise_allocator<Allocator>(
-        f, executor, std::forward<Args>(args)...),
-      executor_(std::move(executor))
-  {
-  }
-
-  template <typename First, detail::execution_context Context, typename... Args>
-  coro_promise(First&& f, Context&& ctx, Args&&... args) noexcept
-    : coro_promise_allocator<Allocator>(
-        f, ctx, std::forward<Args>(args)...),
-      executor_(ctx.get_executor())
-  {
-  }
-
-  template <detail::execution_context Context, typename... Args>
-  coro_promise(Context&& ctx, Args&&... args) noexcept
-    : coro_promise_allocator<Allocator>(
-        ctx, std::forward<Args>(args)...),
-      executor_(ctx.get_executor())
-  {
-  }
-
-  auto get_return_object()
-  {
-    return coro<Yield, Return, Executor, Allocator>{this};
-  }
-
-  auto initial_suspend() noexcept
-  {
-    return suspend_always{};
-  }
-
-  using coro_promise_exchange<
-      typename coro_traits<Yield, Return, Executor>::yield_type,
-      typename coro_traits<Yield, Return, Executor>::input_type,
-      typename coro_traits<Yield, Return, Executor>::return_type>::yield_value;
-
-  auto await_transform(this_coro::executor_t) const
-  {
-    struct exec_helper
-    {
-      const executor_type& value;
-
-      constexpr static bool await_ready() noexcept
-      {
-        return true;
-      }
-
-      constexpr static void await_suspend(coroutine_handle<>) noexcept
-      {
-      }
-
-      executor_type await_resume() const noexcept
-      {
-        return value;
-      }
-    };
-
-    return exec_helper{executor_};
-  }
-
-  auto await_transform(this_coro::cancellation_state_t) const
-  {
-    struct exec_helper
-    {
-      const asio::cancellation_state& value;
-
-      constexpr static bool await_ready() noexcept
-      {
-        return true;
-      }
-
-      constexpr static void await_suspend(coroutine_handle<>) noexcept
-      {
-      }
-
-      asio::cancellation_state await_resume() const noexcept
-      {
-        return value;
-      }
-    };
-    assert(cancel);
-    return exec_helper{cancel->state};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  auto await_transform(this_coro::reset_cancellation_state_0_t) noexcept
-  {
-    struct result
-    {
-      detail::coro_cancellation_source * src_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume() const
-      {
-        return src_->reset_cancellation_state();
-      }
-    };
-
-    return result{cancel};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  template <typename Filter>
-  auto await_transform(
-      this_coro::reset_cancellation_state_1_t<Filter> reset) noexcept
-  {
-    struct result
-    {
-      detail::coro_cancellation_source* src_;
-      Filter filter_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return src_->reset_cancellation_state(
-            static_cast<Filter&&>(filter_));
-      }
-    };
-
-    return result{cancel, static_cast<Filter&&>(reset.filter)};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  template <typename InFilter, typename OutFilter>
-  auto await_transform(
-      this_coro::reset_cancellation_state_2_t<InFilter, OutFilter> reset)
-  noexcept
-  {
-    struct result
-    {
-      detail::coro_cancellation_source* src_;
-      InFilter in_filter_;
-      OutFilter out_filter_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return src_->reset_cancellation_state(
-            static_cast<InFilter&&>(in_filter_),
-            static_cast<OutFilter&&>(out_filter_));
-      }
-    };
-
-    return result{cancel,
-        static_cast<InFilter&&>(reset.in_filter),
-        static_cast<OutFilter&&>(reset.out_filter)};
-  }
-
-  // This await transformation determines whether cancellation is propagated as
-  // an exception.
-  auto await_transform(this_coro::throw_if_cancelled_0_t) noexcept
-    requires (!is_noexcept)
-  {
-    struct result
-    {
-      detail::coro_cancellation_source* src_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return src_->throw_if_cancelled();
-      }
-    };
-
-    return result{cancel};
-  }
-
-  // This await transformation sets whether cancellation is propagated as an
-  // exception.
-  auto await_transform(
-      this_coro::throw_if_cancelled_1_t throw_if_cancelled) noexcept
-    requires (!is_noexcept)
-  {
-    struct result
-    {
-      detail::coro_cancellation_source* src_;
-      bool value_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        src_->throw_if_cancelled(value_);
-      }
-    };
-
-    return result{cancel, throw_if_cancelled.value};
-  }
-
-  template <typename Yield_, typename Return_,
-      typename Executor_, typename Allocator_>
-  auto await_transform(coro<Yield_, Return_, Executor_, Allocator_>& kr)
-    -> decltype(auto)
-  {
-    return kr;
-  }
-
-  template <typename Yield_, typename Return_,
-      typename Executor_, typename Allocator_>
-  auto await_transform(coro<Yield_, Return_, Executor_, Allocator_>&& kr)
-  {
-    return std::move(kr);
-  }
-
-  template <typename T_, typename Coroutine >
-  auto await_transform(coro_with_arg<T_, Coroutine>&& kr) -> decltype(auto)
-  {
-    return std::move(kr);
-  }
-
-  template <typename T_>
-    requires requires(T_ t) {{ t.async_wait(deferred) }; }
-  auto await_transform(T_& t) -> decltype(auto)
-  {
-    return await_transform(t.async_wait(deferred));
-  }
-
-  template <typename Op>
-  auto await_transform(Op&& op,
-      constraint_t<is_async_operation<Op>::value> = 0)
-  {
-    if ((cancel->state.cancelled() != cancellation_type::none)
-        && cancel->throw_if_cancelled_)
-    {
-      asio::detail::throw_error(
-          asio::error::operation_aborted, "coro-cancelled");
-    }
-    using signature = completion_signature_of_t<Op>;
-    using result_type = detail::coro_completion_handler_type_t<signature>;
-    using handler_type =
-      typename detail::coro_completion_handler_type<signature>::template
-        completion_handler<coro_promise>;
-
-    struct aw_t
-    {
-      Op op;
-      std::optional<result_type> result;
-
-      constexpr static bool await_ready()
-      {
-        return false;
-      }
-
-      void await_suspend(coroutine_handle<coro_promise> h)
-      {
-        std::move(op)(handler_type{h, result});
-      }
-
-      auto await_resume()
-      {
-        if constexpr (is_noexcept)
-        {
-          if constexpr (std::tuple_size_v<result_type> == 0u)
-            return;
-          else if constexpr (std::tuple_size_v<result_type> == 1u)
-            return std::get<0>(std::move(result).value());
-          else
-            return std::move(result).value();
-        }
-        else
-          return detail::coro_interpret_result(std::move(result).value());
-      }
-    };
-
-    return aw_t{std::move(op), {}};
-  }
-};
-
-} // namespace detail
-
-template <typename Yield, typename Return,
-    typename Executor, typename Allocator>
-struct coro<Yield, Return, Executor, Allocator>::awaitable_t
-{
-  coro& coro_;
-
-  constexpr static bool await_ready() { return false; }
-
-  template <typename Y, typename R, typename E, typename A>
-  auto await_suspend(
-      detail::coroutine_handle<detail::coro_promise<Y, R, E, A>> h)
-    -> detail::coroutine_handle<>
-  {
-    auto& hp = h.promise();
-
-    if constexpr (!detail::coro_promise<Y, R, E, A>::is_noexcept)
-    {
-      if ((hp.cancel->state.cancelled() != cancellation_type::none)
-          && hp.cancel->throw_if_cancelled_)
-      {
-        asio::detail::throw_error(
-            asio::error::operation_aborted, "coro-cancelled");
-      }
-    }
-
-    if (hp.get_executor() == coro_.get_executor())
-    {
-      coro_.coro_->awaited_from  = h;
-      coro_.coro_->cancel = hp.cancel;
-      coro_.coro_->reset_error();
-
-      return coro_.coro_->get_handle();
-    }
-    else
-    {
-      coro_.coro_->awaited_from = detail::dispatch_coroutine(
-          asio::prefer(hp.get_executor(),
-            execution::outstanding_work.tracked),
-          [h]() mutable
-          {
-            h.resume();
-          }).handle;
-
-      coro_.coro_->reset_error();
-
-      struct cancel_handler
-      {
-        std::shared_ptr<std::pair<cancellation_signal,
-          detail::coro_cancellation_source>> st = std::make_shared<
-            std::pair<cancellation_signal, detail::coro_cancellation_source>>();
-
-        cancel_handler(E e, coro& coro) : e(e), coro_(coro.coro_)
-        {
-          st->second.state = cancellation_state(
-              st->second.slot = st->first.slot());
-        }
-
-        E e;
-        typename coro::promise_type* coro_;
-
-        void operator()(cancellation_type ct)
-        {
-          asio::dispatch(e,
-              [ct, st = st]() mutable
-              {
-                auto & [sig, state] = *st;
-                sig.emit(ct);
-              });
-        }
-      };
-
-      if (hp.cancel->state.slot().is_connected())
-      {
-        hp.cancel->state.slot().template emplace<cancel_handler>(
-            coro_.get_executor(), coro_);
-      }
-
-      auto hh = detail::coroutine_handle<
-        detail::coro_promise<Yield, Return, Executor, Allocator>>::from_promise(
-            *coro_.coro_);
-
-      return detail::dispatch_coroutine(
-          coro_.coro_->get_executor(),
-          [hh]() mutable { hh.resume(); }).handle;
-    }
-  }
-
-  auto await_resume() -> result_type
-  {
-    coro_.coro_->cancel = nullptr;
-    coro_.coro_->rethrow_if();
-    if constexpr (!std::is_void_v<result_type>)
-      return std::move(coro_.coro_->result_);
-  }
-};
-
-template <typename Yield, typename Return,
-    typename Executor, typename Allocator>
-struct coro<Yield, Return, Executor, Allocator>::initiate_async_resume
-{
-  typedef Executor executor_type;
-  typedef Allocator allocator_type;
-  typedef asio::cancellation_slot cancellation_slot_type;
-
-  explicit initiate_async_resume(coro* self)
-    : coro_(self->coro_)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return coro_->get_executor();
-  }
-
-  allocator_type get_allocator() const noexcept
-  {
-    return coro_->get_allocator();
-  }
-
-  template <typename E, typename WaitHandler>
-  auto handle(E exec, WaitHandler&& handler,
-      std::true_type /* error is noexcept */,
-      std::true_type /* result is void */)  //noexcept
-  {
-    return [this, the_coro = coro_,
-        h = std::forward<WaitHandler>(handler),
-        exec = std::move(exec)]() mutable
-    {
-      assert(the_coro);
-
-      auto ch = detail::coroutine_handle<promise_type>::from_promise(*the_coro);
-      assert(ch && !ch.done());
-
-      the_coro->awaited_from = post_coroutine(std::move(exec), std::move(h));
-      the_coro->reset_error();
-      ch.resume();
-    };
-  }
-
-  template <typename E, typename WaitHandler>
-  requires (!std::is_void_v<result_type>)
-  auto handle(E exec, WaitHandler&& handler,
-      std::true_type /* error is noexcept */,
-      std::false_type  /* result is void */)  //noexcept
-  {
-    return [the_coro = coro_,
-        h = std::forward<WaitHandler>(handler),
-        exec = std::move(exec)]() mutable
-    {
-      assert(the_coro);
-
-      auto ch = detail::coroutine_handle<promise_type>::from_promise(*the_coro);
-      assert(ch && !ch.done());
-
-      the_coro->awaited_from = detail::post_coroutine(
-          exec, std::move(h), the_coro->result_).handle;
-      the_coro->reset_error();
-      ch.resume();
-    };
-  }
-
-  template <typename E, typename WaitHandler>
-  auto handle(E exec, WaitHandler&& handler,
-      std::false_type /* error is noexcept */,
-      std::true_type /* result is void */)
-  {
-    return [the_coro = coro_,
-        h = std::forward<WaitHandler>(handler),
-        exec = std::move(exec)]() mutable
-    {
-      if (!the_coro)
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::invalid()));
-
-      auto ch = detail::coroutine_handle<promise_type>::from_promise(*the_coro);
-      if (!ch)
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::invalid()));
-      else if (ch.done())
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::done()));
-      else
-      {
-        the_coro->awaited_from = detail::post_coroutine(
-            exec, std::move(h), the_coro->error_).handle;
-        the_coro->reset_error();
-        ch.resume();
-      }
-    };
-  }
-
-  template <typename E, typename WaitHandler>
-  auto handle(E exec, WaitHandler&& handler,
-      std::false_type /* error is noexcept */,
-      std::false_type  /* result is void */)
-  {
-    return [the_coro = coro_,
-        h = std::forward<WaitHandler>(handler),
-        exec = std::move(exec)]() mutable
-    {
-      if (!the_coro)
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::invalid(), result_type{}));
-
-      auto ch =
-        detail::coroutine_handle<promise_type>::from_promise(*the_coro);
-      if (!ch)
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::invalid(), result_type{}));
-      else if (ch.done())
-        return asio::post(exec,
-            asio::append(std::move(h),
-              detail::coro_error<error_type>::done(), result_type{}));
-      else
-      {
-        the_coro->awaited_from = detail::post_coroutine(
-            exec, std::move(h), the_coro->error_, the_coro->result_).handle;
-        the_coro->reset_error();
-        ch.resume();
-      }
-    };
-  }
-
-  template <typename WaitHandler>
-  void operator()(WaitHandler&& handler)
-  {
-    const auto exec = asio::prefer(
-        get_associated_executor(handler, get_executor()),
-        execution::outstanding_work.tracked);
-
-    coro_->cancel = &coro_->cancel_source.emplace();
-    coro_->cancel->state = cancellation_state(
-        coro_->cancel->slot = get_associated_cancellation_slot(handler));
-    asio::dispatch(get_executor(),
-        handle(exec, std::forward<WaitHandler>(handler),
-          std::integral_constant<bool, is_noexcept>{},
-          std::is_void<result_type>{}));
-  }
-
-  template <typename WaitHandler, typename Input>
-  void operator()(WaitHandler&& handler, Input&& input)
-  {
-    const auto exec = asio::prefer(
-        get_associated_executor(handler, get_executor()),
-        execution::outstanding_work.tracked);
-
-    coro_->cancel = &coro_->cancel_source.emplace();
-    coro_->cancel->state = cancellation_state(
-        coro_->cancel->slot = get_associated_cancellation_slot(handler));
-    asio::dispatch(get_executor(),
-        [h = handle(exec, std::forward<WaitHandler>(handler),
-            std::integral_constant<bool, is_noexcept>{},
-            std::is_void<result_type>{}),
-            in = std::forward<Input>(input), the_coro = coro_]() mutable
-        {
-          the_coro->input_ = std::move(in);
-          std::move(h)();
-        });
-  }
-
-private:
-  typename coro::promise_type* coro_;
-};
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_IMPL_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/parallel_group.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/parallel_group.hpp
deleted file mode 100644
index 75e8a15..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/parallel_group.hpp
+++ /dev/null
@@ -1,788 +0,0 @@
-//
-// experimental/impl/parallel_group.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
-#define ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <atomic>
-#include <deque>
-#include <memory>
-#include <new>
-#include <tuple>
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/dispatch.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-// Stores the result from an individual asynchronous operation.
-template <typename T, typename = void>
-struct parallel_group_op_result
-{
-public:
-  parallel_group_op_result()
-    : has_value_(false)
-  {
-  }
-
-  parallel_group_op_result(parallel_group_op_result&& other)
-    : has_value_(other.has_value_)
-  {
-    if (has_value_)
-      new (&u_.value_) T(std::move(other.get()));
-  }
-
-  ~parallel_group_op_result()
-  {
-    if (has_value_)
-      u_.value_.~T();
-  }
-
-  T& get() noexcept
-  {
-    return u_.value_;
-  }
-
-  template <typename... Args>
-  void emplace(Args&&... args)
-  {
-    new (&u_.value_) T(std::forward<Args>(args)...);
-    has_value_ = true;
-  }
-
-private:
-  union u
-  {
-    u() {}
-    ~u() {}
-    char c_;
-    T value_;
-  } u_;
-  bool has_value_;
-};
-
-// Proxy completion handler for the group of parallel operatations. Unpacks and
-// concatenates the individual operations' results, and invokes the user's
-// completion handler.
-template <typename Handler, typename... Ops>
-struct parallel_group_completion_handler
-{
-  typedef decay_t<
-      prefer_result_t<
-        associated_executor_t<Handler>,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  parallel_group_completion_handler(Handler&& h)
-    : handler_(std::move(h)),
-      executor_(
-          asio::prefer(
-            asio::get_associated_executor(handler_),
-            execution::outstanding_work.tracked))
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  void operator()()
-  {
-    this->invoke(asio::detail::make_index_sequence<sizeof...(Ops)>());
-  }
-
-  template <std::size_t... I>
-  void invoke(asio::detail::index_sequence<I...>)
-  {
-    this->invoke(std::tuple_cat(std::move(std::get<I>(args_).get())...));
-  }
-
-  template <typename... Args>
-  void invoke(std::tuple<Args...>&& args)
-  {
-    this->invoke(std::move(args),
-        asio::detail::index_sequence_for<Args...>());
-  }
-
-  template <typename... Args, std::size_t... I>
-  void invoke(std::tuple<Args...>&& args,
-      asio::detail::index_sequence<I...>)
-  {
-    std::move(handler_)(completion_order_, std::move(std::get<I>(args))...);
-  }
-
-  Handler handler_;
-  executor_type executor_;
-  std::array<std::size_t, sizeof...(Ops)> completion_order_{};
-  std::tuple<
-      parallel_group_op_result<
-        typename parallel_op_signature_as_tuple<
-          completion_signature_of_t<Ops>
-        >::type
-      >...
-    > args_{};
-};
-
-// Shared state for the parallel group.
-template <typename Condition, typename Handler, typename... Ops>
-struct parallel_group_state
-{
-  parallel_group_state(Condition&& c, Handler&& h)
-    : cancellation_condition_(std::move(c)),
-      handler_(std::move(h))
-  {
-  }
-
-  // The number of operations that have completed so far. Used to determine the
-  // order of completion.
-  std::atomic<unsigned int> completed_{0};
-
-  // The non-none cancellation type that resulted from a cancellation condition.
-  // Stored here for use by the group's initiating function.
-  std::atomic<cancellation_type_t> cancel_type_{cancellation_type::none};
-
-  // The number of cancellations that have been requested, either on completion
-  // of the operations within the group, or via the cancellation slot for the
-  // group operation. Initially set to the number of operations to prevent
-  // cancellation signals from being emitted until after all of the group's
-  // operations' initiating functions have completed.
-  std::atomic<unsigned int> cancellations_requested_{sizeof...(Ops)};
-
-  // The number of operations that are yet to complete. Used to determine when
-  // it is safe to invoke the user's completion handler.
-  std::atomic<unsigned int> outstanding_{sizeof...(Ops)};
-
-  // The cancellation signals for each operation in the group.
-  asio::cancellation_signal cancellation_signals_[sizeof...(Ops)];
-
-  // The cancellation condition is used to determine whether the results from an
-  // individual operation warrant a cancellation request for the whole group.
-  Condition cancellation_condition_;
-
-  // The proxy handler to be invoked once all operations in the group complete.
-  parallel_group_completion_handler<Handler, Ops...> handler_;
-};
-
-// Handler for an individual operation within the parallel group.
-template <std::size_t I, typename Condition, typename Handler, typename... Ops>
-struct parallel_group_op_handler
-{
-  typedef asio::cancellation_slot cancellation_slot_type;
-
-  parallel_group_op_handler(
-    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state)
-    : state_(std::move(state))
-  {
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return state_->cancellation_signals_[I].slot();
-  }
-
-  template <typename... Args>
-  void operator()(Args... args)
-  {
-    // Capture this operation into the completion order.
-    state_->handler_.completion_order_[state_->completed_++] = I;
-
-    // Determine whether the results of this operation require cancellation of
-    // the whole group.
-    cancellation_type_t cancel_type = state_->cancellation_condition_(args...);
-
-    // Capture the result of the operation into the proxy completion handler.
-    std::get<I>(state_->handler_.args_).emplace(std::move(args)...);
-
-    if (cancel_type != cancellation_type::none)
-    {
-      // Save the type for potential use by the group's initiating function.
-      state_->cancel_type_ = cancel_type;
-
-      // If we are the first operation to request cancellation, emit a signal
-      // for each operation in the group.
-      if (state_->cancellations_requested_++ == 0)
-        for (std::size_t i = 0; i < sizeof...(Ops); ++i)
-          if (i != I)
-            state_->cancellation_signals_[i].emit(cancel_type);
-    }
-
-    // If this is the last outstanding operation, invoke the user's handler.
-    if (--state_->outstanding_ == 0)
-      asio::dispatch(std::move(state_->handler_));
-  }
-
-  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
-};
-
-// Handler for an individual operation within the parallel group that has an
-// explicitly specified executor.
-template <typename Executor, std::size_t I,
-    typename Condition, typename Handler, typename... Ops>
-struct parallel_group_op_handler_with_executor :
-  parallel_group_op_handler<I, Condition, Handler, Ops...>
-{
-  typedef parallel_group_op_handler<I, Condition, Handler, Ops...> base_type;
-  typedef asio::cancellation_slot cancellation_slot_type;
-  typedef Executor executor_type;
-
-  parallel_group_op_handler_with_executor(
-      std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state,
-      executor_type ex)
-    : parallel_group_op_handler<I, Condition, Handler, Ops...>(std::move(state))
-  {
-    cancel_proxy_ =
-      &this->state_->cancellation_signals_[I].slot().template
-        emplace<cancel_proxy>(this->state_, std::move(ex));
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancel_proxy_->signal_.slot();
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return cancel_proxy_->executor_;
-  }
-
-  // Proxy handler that forwards the emitted signal to the correct executor.
-  struct cancel_proxy
-  {
-    cancel_proxy(
-        std::shared_ptr<parallel_group_state<
-          Condition, Handler, Ops...>> state,
-        executor_type ex)
-      : state_(std::move(state)),
-        executor_(std::move(ex))
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (auto state = state_.lock())
-      {
-        asio::cancellation_signal* sig = &signal_;
-        asio::dispatch(executor_,
-            [state, sig, type]{ sig->emit(type); });
-      }
-    }
-
-    std::weak_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
-    asio::cancellation_signal signal_;
-    executor_type executor_;
-  };
-
-  cancel_proxy* cancel_proxy_;
-};
-
-// Helper to launch an operation using the correct executor, if any.
-template <std::size_t I, typename Op, typename = void>
-struct parallel_group_op_launcher
-{
-  template <typename Condition, typename Handler, typename... Ops>
-  static void launch(Op& op,
-    const std::shared_ptr<parallel_group_state<
-      Condition, Handler, Ops...>>& state)
-  {
-    typedef associated_executor_t<Op> ex_type;
-    ex_type ex = asio::get_associated_executor(op);
-    std::move(op)(
-        parallel_group_op_handler_with_executor<ex_type, I,
-          Condition, Handler, Ops...>(state, std::move(ex)));
-  }
-};
-
-// Specialised launcher for operations that specify no executor.
-template <std::size_t I, typename Op>
-struct parallel_group_op_launcher<I, Op,
-    enable_if_t<
-      is_same<
-        typename associated_executor<
-          Op>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  template <typename Condition, typename Handler, typename... Ops>
-  static void launch(Op& op,
-    const std::shared_ptr<parallel_group_state<
-      Condition, Handler, Ops...>>& state)
-  {
-    std::move(op)(
-        parallel_group_op_handler<I, Condition, Handler, Ops...>(state));
-  }
-};
-
-template <typename Condition, typename Handler, typename... Ops>
-struct parallel_group_cancellation_handler
-{
-  parallel_group_cancellation_handler(
-    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state)
-    : state_(std::move(state))
-  {
-  }
-
-  void operator()(cancellation_type_t cancel_type)
-  {
-    // If we are the first place to request cancellation, i.e. no operation has
-    // yet completed and requested cancellation, emit a signal for each
-    // operation in the group.
-    if (cancel_type != cancellation_type::none)
-      if (auto state = state_.lock())
-        if (state->cancellations_requested_++ == 0)
-          for (std::size_t i = 0; i < sizeof...(Ops); ++i)
-            state->cancellation_signals_[i].emit(cancel_type);
-  }
-
-  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
-};
-
-template <typename Condition, typename Handler,
-    typename... Ops, std::size_t... I>
-void parallel_group_launch(Condition cancellation_condition, Handler handler,
-    std::tuple<Ops...>& ops, asio::detail::index_sequence<I...>)
-{
-  // Get the user's completion handler's cancellation slot, so that we can allow
-  // cancellation of the entire group.
-  associated_cancellation_slot_t<Handler> slot
-    = asio::get_associated_cancellation_slot(handler);
-
-  // Create the shared state for the operation.
-  typedef parallel_group_state<Condition, Handler, Ops...> state_type;
-  std::shared_ptr<state_type> state = std::allocate_shared<state_type>(
-      asio::detail::recycling_allocator<state_type,
-        asio::detail::thread_info_base::parallel_group_tag>(),
-      std::move(cancellation_condition), std::move(handler));
-
-  // Initiate each individual operation in the group.
-  int fold[] = { 0,
-    ( parallel_group_op_launcher<I, Ops>::launch(std::get<I>(ops), state),
-      0 )...
-  };
-  (void)fold;
-
-  // Check if any of the operations has already requested cancellation, and if
-  // so, emit a signal for each operation in the group.
-  if ((state->cancellations_requested_ -= sizeof...(Ops)) > 0)
-    for (auto& signal : state->cancellation_signals_)
-      signal.emit(state->cancel_type_);
-
-  // Register a handler with the user's completion handler's cancellation slot.
-  if (slot.is_connected())
-    slot.template emplace<
-      parallel_group_cancellation_handler<
-        Condition, Handler, Ops...>>(state);
-}
-
-// Proxy completion handler for the ranged group of parallel operatations.
-// Unpacks and recombines the individual operations' results, and invokes the
-// user's completion handler.
-template <typename Handler, typename Op, typename Allocator>
-struct ranged_parallel_group_completion_handler
-{
-  typedef decay_t<
-      prefer_result_t<
-        associated_executor_t<Handler>,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  typedef typename parallel_op_signature_as_tuple<
-      completion_signature_of_t<Op>
-    >::type op_tuple_type;
-
-  typedef parallel_group_op_result<op_tuple_type> op_result_type;
-
-  ranged_parallel_group_completion_handler(Handler&& h,
-      std::size_t size, const Allocator& allocator)
-    : handler_(std::move(h)),
-      executor_(
-          asio::prefer(
-            asio::get_associated_executor(handler_),
-            execution::outstanding_work.tracked)),
-      allocator_(allocator),
-      completion_order_(size, 0,
-          ASIO_REBIND_ALLOC(Allocator, std::size_t)(allocator)),
-      args_(ASIO_REBIND_ALLOC(Allocator, op_result_type)(allocator))
-  {
-    for (std::size_t i = 0; i < size; ++i)
-      args_.emplace_back();
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  void operator()()
-  {
-    this->invoke(
-        asio::detail::make_index_sequence<
-          std::tuple_size<op_tuple_type>::value>());
-  }
-
-  template <std::size_t... I>
-  void invoke(asio::detail::index_sequence<I...>)
-  {
-    typedef typename parallel_op_signature_as_tuple<
-        typename ranged_parallel_group_signature<
-          completion_signature_of_t<Op>,
-          Allocator
-        >::raw_type
-      >::type vectors_type;
-
-    // Construct all result vectors using the supplied allocator.
-    vectors_type vectors{
-        typename std::tuple_element<I, vectors_type>::type(
-          ASIO_REBIND_ALLOC(Allocator, int)(allocator_))...};
-
-    // Reserve sufficient space in each of the result vectors.
-    int reserve_fold[] = { 0,
-      ( std::get<I>(vectors).reserve(completion_order_.size()),
-        0 )...
-    };
-    (void)reserve_fold;
-
-    // Copy the results from all operations into the result vectors.
-    for (std::size_t idx = 0; idx < completion_order_.size(); ++idx)
-    {
-      int pushback_fold[] = { 0,
-        ( std::get<I>(vectors).push_back(
-            std::move(std::get<I>(args_[idx].get()))),
-          0 )...
-      };
-      (void)pushback_fold;
-    }
-
-    std::move(handler_)(std::move(completion_order_),
-        std::move(std::get<I>(vectors))...);
-  }
-
-  Handler handler_;
-  executor_type executor_;
-  Allocator allocator_;
-  std::vector<std::size_t,
-    ASIO_REBIND_ALLOC(Allocator, std::size_t)> completion_order_;
-  std::deque<op_result_type,
-    ASIO_REBIND_ALLOC(Allocator, op_result_type)> args_;
-};
-
-// Shared state for the parallel group.
-template <typename Condition, typename Handler, typename Op, typename Allocator>
-struct ranged_parallel_group_state
-{
-  ranged_parallel_group_state(Condition&& c, Handler&& h,
-      std::size_t size, const Allocator& allocator)
-    : cancellations_requested_(size),
-      outstanding_(size),
-      cancellation_signals_(
-          ASIO_REBIND_ALLOC(Allocator,
-            asio::cancellation_signal)(allocator)),
-      cancellation_condition_(std::move(c)),
-      handler_(std::move(h), size, allocator)
-  {
-    for (std::size_t i = 0; i < size; ++i)
-      cancellation_signals_.emplace_back();
-  }
-
-  // The number of operations that have completed so far. Used to determine the
-  // order of completion.
-  std::atomic<unsigned int> completed_{0};
-
-  // The non-none cancellation type that resulted from a cancellation condition.
-  // Stored here for use by the group's initiating function.
-  std::atomic<cancellation_type_t> cancel_type_{cancellation_type::none};
-
-  // The number of cancellations that have been requested, either on completion
-  // of the operations within the group, or via the cancellation slot for the
-  // group operation. Initially set to the number of operations to prevent
-  // cancellation signals from being emitted until after all of the group's
-  // operations' initiating functions have completed.
-  std::atomic<unsigned int> cancellations_requested_;
-
-  // The number of operations that are yet to complete. Used to determine when
-  // it is safe to invoke the user's completion handler.
-  std::atomic<unsigned int> outstanding_;
-
-  // The cancellation signals for each operation in the group.
-  std::deque<asio::cancellation_signal,
-    ASIO_REBIND_ALLOC(Allocator, asio::cancellation_signal)>
-      cancellation_signals_;
-
-  // The cancellation condition is used to determine whether the results from an
-  // individual operation warrant a cancellation request for the whole group.
-  Condition cancellation_condition_;
-
-  // The proxy handler to be invoked once all operations in the group complete.
-  ranged_parallel_group_completion_handler<Handler, Op, Allocator> handler_;
-};
-
-// Handler for an individual operation within the parallel group.
-template <typename Condition, typename Handler, typename Op, typename Allocator>
-struct ranged_parallel_group_op_handler
-{
-  typedef asio::cancellation_slot cancellation_slot_type;
-
-  ranged_parallel_group_op_handler(
-      std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator>> state,
-      std::size_t idx)
-    : state_(std::move(state)),
-      idx_(idx)
-  {
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return state_->cancellation_signals_[idx_].slot();
-  }
-
-  template <typename... Args>
-  void operator()(Args... args)
-  {
-    // Capture this operation into the completion order.
-    state_->handler_.completion_order_[state_->completed_++] = idx_;
-
-    // Determine whether the results of this operation require cancellation of
-    // the whole group.
-    cancellation_type_t cancel_type = state_->cancellation_condition_(args...);
-
-    // Capture the result of the operation into the proxy completion handler.
-    state_->handler_.args_[idx_].emplace(std::move(args)...);
-
-    if (cancel_type != cancellation_type::none)
-    {
-      // Save the type for potential use by the group's initiating function.
-      state_->cancel_type_ = cancel_type;
-
-      // If we are the first operation to request cancellation, emit a signal
-      // for each operation in the group.
-      if (state_->cancellations_requested_++ == 0)
-        for (std::size_t i = 0; i < state_->cancellation_signals_.size(); ++i)
-          if (i != idx_)
-            state_->cancellation_signals_[i].emit(cancel_type);
-    }
-
-    // If this is the last outstanding operation, invoke the user's handler.
-    if (--state_->outstanding_ == 0)
-      asio::dispatch(std::move(state_->handler_));
-  }
-
-  std::shared_ptr<ranged_parallel_group_state<
-    Condition, Handler, Op, Allocator>> state_;
-  std::size_t idx_;
-};
-
-// Handler for an individual operation within the parallel group that has an
-// explicitly specified executor.
-template <typename Executor, typename Condition,
-    typename Handler, typename Op, typename Allocator>
-struct ranged_parallel_group_op_handler_with_executor :
-  ranged_parallel_group_op_handler<Condition, Handler, Op, Allocator>
-{
-  typedef ranged_parallel_group_op_handler<
-    Condition, Handler, Op, Allocator> base_type;
-  typedef asio::cancellation_slot cancellation_slot_type;
-  typedef Executor executor_type;
-
-  ranged_parallel_group_op_handler_with_executor(
-      std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator>> state,
-      executor_type ex, std::size_t idx)
-    : ranged_parallel_group_op_handler<Condition, Handler, Op, Allocator>(
-        std::move(state), idx)
-  {
-    cancel_proxy_ =
-      &this->state_->cancellation_signals_[idx].slot().template
-        emplace<cancel_proxy>(this->state_, std::move(ex));
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return cancel_proxy_->signal_.slot();
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return cancel_proxy_->executor_;
-  }
-
-  // Proxy handler that forwards the emitted signal to the correct executor.
-  struct cancel_proxy
-  {
-    cancel_proxy(
-        std::shared_ptr<ranged_parallel_group_state<
-          Condition, Handler, Op, Allocator>> state,
-        executor_type ex)
-      : state_(std::move(state)),
-        executor_(std::move(ex))
-    {
-    }
-
-    void operator()(cancellation_type_t type)
-    {
-      if (auto state = state_.lock())
-      {
-        asio::cancellation_signal* sig = &signal_;
-        asio::dispatch(executor_,
-            [state, sig, type]{ sig->emit(type); });
-      }
-    }
-
-    std::weak_ptr<ranged_parallel_group_state<
-      Condition, Handler, Op, Allocator>> state_;
-    asio::cancellation_signal signal_;
-    executor_type executor_;
-  };
-
-  cancel_proxy* cancel_proxy_;
-};
-
-template <typename Condition, typename Handler, typename Op, typename Allocator>
-struct ranged_parallel_group_cancellation_handler
-{
-  ranged_parallel_group_cancellation_handler(
-      std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator>> state)
-    : state_(std::move(state))
-  {
-  }
-
-  void operator()(cancellation_type_t cancel_type)
-  {
-    // If we are the first place to request cancellation, i.e. no operation has
-    // yet completed and requested cancellation, emit a signal for each
-    // operation in the group.
-    if (cancel_type != cancellation_type::none)
-      if (auto state = state_.lock())
-        if (state->cancellations_requested_++ == 0)
-          for (std::size_t i = 0; i < state->cancellation_signals_.size(); ++i)
-            state->cancellation_signals_[i].emit(cancel_type);
-  }
-
-  std::weak_ptr<ranged_parallel_group_state<
-    Condition, Handler, Op, Allocator>> state_;
-};
-
-template <typename Condition, typename Handler,
-    typename Range, typename Allocator>
-void ranged_parallel_group_launch(Condition cancellation_condition,
-    Handler handler, Range&& range, const Allocator& allocator)
-{
-  // Get the user's completion handler's cancellation slot, so that we can allow
-  // cancellation of the entire group.
-  associated_cancellation_slot_t<Handler> slot
-    = asio::get_associated_cancellation_slot(handler);
-
-  // The type of the asynchronous operation.
-  typedef decay_t<decltype(*declval<typename Range::iterator>())> op_type;
-
-  // Create the shared state for the operation.
-  typedef ranged_parallel_group_state<Condition,
-    Handler, op_type, Allocator> state_type;
-  std::shared_ptr<state_type> state = std::allocate_shared<state_type>(
-      asio::detail::recycling_allocator<state_type,
-        asio::detail::thread_info_base::parallel_group_tag>(),
-      std::move(cancellation_condition),
-      std::move(handler), range.size(), allocator);
-
-  std::size_t idx = 0;
-  for (auto&& op : std::forward<Range>(range))
-  {
-    typedef associated_executor_t<op_type> ex_type;
-    ex_type ex = asio::get_associated_executor(op);
-    std::move(op)(
-        ranged_parallel_group_op_handler_with_executor<
-          ex_type, Condition, Handler, op_type, Allocator>(
-            state, std::move(ex), idx++));
-  }
-
-  // Check if any of the operations has already requested cancellation, and if
-  // so, emit a signal for each operation in the group.
-  if ((state->cancellations_requested_ -= range.size()) > 0)
-    for (auto& signal : state->cancellation_signals_)
-      signal.emit(state->cancel_type_);
-
-  // Register a handler with the user's completion handler's cancellation slot.
-  if (slot.is_connected())
-    slot.template emplace<
-      ranged_parallel_group_cancellation_handler<
-        Condition, Handler, op_type, Allocator>>(state);
-}
-
-} // namespace detail
-} // namespace experimental
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename... Ops, typename DefaultCandidate>
-struct associator<Associator,
-    experimental::detail::parallel_group_completion_handler<Handler, Ops...>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::parallel_group_completion_handler<
-        Handler, Ops...>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const experimental::detail::parallel_group_completion_handler<
-        Handler, Ops...>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator, typename Handler,
-    typename Op, typename Allocator, typename DefaultCandidate>
-struct associator<Associator,
-    experimental::detail::ranged_parallel_group_completion_handler<
-      Handler, Op, Allocator>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::ranged_parallel_group_completion_handler<
-        Handler, Op, Allocator>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const experimental::detail::ranged_parallel_group_completion_handler<
-        Handler, Op, Allocator>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_EXPERIMENTAL_PARALLEL_GROUP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/promise.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/promise.hpp
deleted file mode 100644
index a80cf11..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/promise.hpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// experimental/impl/promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
-#define ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/utility.hpp"
-#include "asio/error.hpp"
-#include "asio/system_error.hpp"
-#include <tuple>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-template<typename Signature = void(),
-    typename Executor = asio::any_io_executor,
-    typename Allocator = std::allocator<void>>
-struct promise;
-
-namespace detail {
-
-template<typename Signature, typename Executor, typename Allocator>
-struct promise_impl;
-
-template<typename... Ts, typename Executor, typename Allocator>
-struct promise_impl<void(Ts...), Executor, Allocator>
-{
-  using result_type = std::tuple<Ts...>;
-
-  promise_impl(Allocator allocator, Executor executor)
-    : allocator(std::move(allocator)), executor(std::move(executor))
-  {
-  }
-
-  promise_impl(const promise_impl&) = delete;
-
-  ~promise_impl()
-  {
-    if (completion)
-      this->cancel_();
-
-    if (done)
-      reinterpret_cast<result_type*>(&result)->~result_type();
-  }
-
-  aligned_storage_t<sizeof(result_type), alignof(result_type)> result;
-  std::atomic<bool> done{false};
-  cancellation_signal cancel;
-  Allocator allocator;
-  Executor executor;
-
-  template<typename Func, std::size_t... Idx>
-  void apply_impl(Func f, asio::detail::index_sequence<Idx...>)
-  {
-    auto& result_type = *reinterpret_cast<promise_impl::result_type*>(&result);
-    f(std::get<Idx>(std::move(result_type))...);
-  }
-
-  using allocator_type = Allocator;
-  allocator_type get_allocator() {return allocator;}
-
-  using executor_type = Executor;
-  executor_type get_executor() {return executor;}
-
-  template<typename Func>
-  void apply(Func f)
-  {
-    apply_impl(std::forward<Func>(f),
-        asio::detail::make_index_sequence<sizeof...(Ts)>{});
-  }
-
-  struct completion_base
-  {
-    virtual void invoke(Ts&&...ts) = 0;
-  };
-
-  template<typename Alloc, typename WaitHandler_>
-  struct completion_impl final : completion_base
-  {
-    WaitHandler_ handler;
-    Alloc allocator;
-    void invoke(Ts&&... ts)
-    {
-      auto h = std::move(handler);
-
-      using alloc_t = typename std::allocator_traits<
-        typename asio::decay<Alloc>::type>::template
-          rebind_alloc<completion_impl>;
-
-      alloc_t alloc_{allocator};
-      this->~completion_impl();
-      std::allocator_traits<alloc_t>::deallocate(alloc_, this, 1u);
-      std::move(h)(std::forward<Ts>(ts)...);
-    }
-
-    template<typename Alloc_, typename Handler_>
-    completion_impl(Alloc_&& alloc, Handler_&& wh)
-      : handler(std::forward<Handler_>(wh)),
-        allocator(std::forward<Alloc_>(alloc))
-    {
-    }
-  };
-
-  completion_base* completion = nullptr;
-  typename asio::aligned_storage<sizeof(void*) * 4,
-    alignof(completion_base)>::type completion_opt;
-
-  template<typename Alloc, typename Handler>
-  void set_completion(Alloc&& alloc, Handler&& handler)
-  {
-    if (completion)
-      cancel_();
-
-    using impl_t = completion_impl<
-      typename asio::decay<Alloc>::type, Handler>;
-    using alloc_t = typename std::allocator_traits<
-      typename asio::decay<Alloc>::type>::template rebind_alloc<impl_t>;
-
-    alloc_t alloc_{alloc};
-    auto p = std::allocator_traits<alloc_t>::allocate(alloc_, 1u);
-    completion = new (p) impl_t(std::forward<Alloc>(alloc),
-        std::forward<Handler>(handler));
-  }
-
-  template<typename... T_>
-  void complete(T_&&... ts)
-  {
-    assert(completion);
-    std::exchange(completion, nullptr)->invoke(std::forward<T_>(ts)...);
-  }
-
-  template<std::size_t... Idx>
-  void complete_with_result_impl(asio::detail::index_sequence<Idx...>)
-  {
-    auto& result_type = *reinterpret_cast<promise_impl::result_type*>(&result);
-    this->complete(std::get<Idx>(std::move(result_type))...);
-  }
-
-  void complete_with_result()
-  {
-    complete_with_result_impl(
-        asio::detail::make_index_sequence<sizeof...(Ts)>{});
-  }
-
-  template<typename... T_>
-  void cancel_impl_(std::exception_ptr*, T_*...)
-  {
-    complete(
-        std::make_exception_ptr(
-          asio::system_error(
-            asio::error::operation_aborted)),
-        T_{}...);
-  }
-
-  template<typename... T_>
-  void cancel_impl_(asio::error_code*, T_*...)
-  {
-    complete(asio::error::operation_aborted, T_{}...);
-  }
-
-  template<typename... T_>
-  void cancel_impl_(T_*...)
-  {
-    complete(T_{}...);
-  }
-
-  void cancel_()
-  {
-    cancel_impl_(static_cast<Ts*>(nullptr)...);
-  }
-};
-
-template<typename Signature = void(),
-    typename Executor = asio::any_io_executor,
-    typename Allocator = any_io_executor>
-struct promise_handler;
-
-template<typename... Ts,  typename Executor, typename Allocator>
-struct promise_handler<void(Ts...), Executor, Allocator>
-{
-  using promise_type = promise<void(Ts...), Executor, Allocator>;
-
-  promise_handler(
-      Allocator allocator, Executor executor) // get_associated_allocator(exec)
-    : impl_(
-        std::allocate_shared<promise_impl<void(Ts...), Executor, Allocator>>(
-          allocator, allocator, executor))
-  {
-  }
-
-  std::shared_ptr<promise_impl<void(Ts...), Executor, Allocator>> impl_;
-
-  using cancellation_slot_type = cancellation_slot;
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return impl_->cancel.slot();
-  }
-
-  using allocator_type = Allocator;
-
-  allocator_type get_allocator() const noexcept
-  {
-    return impl_->get_allocator();
-  }
-
-  using executor_type = Executor;
-
-  Executor get_executor() const noexcept
-  {
-    return impl_->get_executor();
-  }
-
-  auto make_promise() -> promise<void(Ts...), executor_type, allocator_type>
-  {
-    return promise<void(Ts...), executor_type, allocator_type>{impl_};
-  }
-
-  void operator()(std::remove_reference_t<Ts>... ts)
-  {
-    assert(impl_);
-
-    using result_type = typename promise_impl<
-      void(Ts...), allocator_type, executor_type>::result_type ;
-
-    new (&impl_->result) result_type(std::move(ts)...);
-    impl_->done = true;
-
-    if (impl_->completion)
-      impl_->complete_with_result();
-  }
-};
-
-} // namespace detail
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_IMPL_PROMISE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_coro.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_coro.hpp
deleted file mode 100644
index ab5a2e6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_coro.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-//
-// experimental/impl/use_coro.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
-#define ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/deferred.hpp"
-#include "asio/experimental/coro.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Allocator, typename R>
-struct async_result<experimental::use_coro_t<Allocator>, R()>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void() noexcept, void,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_await deferred_async_operation<R(), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(asio::detail::initiation_archetype<R()>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), void,
-      asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-template <typename Allocator, typename R>
-struct async_result<
-    experimental::use_coro_t<Allocator>, R(asio::error_code)>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void() noexcept, void,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_await deferred_async_operation<
-      R(asio::error_code), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(
-      asio::detail::initiation_archetype<R(asio::error_code)>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), void,
-      asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-template <typename Allocator, typename R>
-struct async_result<
-    experimental::use_coro_t<Allocator>, R(std::exception_ptr)>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), void,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_await deferred_async_operation<
-      R(std::exception_ptr), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(
-      asio::detail::initiation_archetype<R(std::exception_ptr)>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), void,
-      asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-template <typename Allocator, typename R, typename T>
-struct async_result<experimental::use_coro_t<Allocator>, R(T)>
-{
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void() noexcept, T,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_return co_await deferred_async_operation<R(T), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(asio::detail::initiation_archetype<R(T)>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void() noexcept, T,
-      asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-template <typename Allocator, typename R, typename T>
-struct async_result<
-    experimental::use_coro_t<Allocator>, R(asio::error_code, T)>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), T,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_return co_await deferred_async_operation<
-      R(asio::error_code, T), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(
-      asio::detail::initiation_archetype<
-        R(asio::error_code, T)>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), T, asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-template <typename Allocator, typename R, typename T>
-struct async_result<
-    experimental::use_coro_t<Allocator>, R(std::exception_ptr, T)>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate_impl(Initiation initiation,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), T,
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    co_return co_await deferred_async_operation<
-      R(std::exception_ptr, T), Initiation, InitArgs...>(
-        deferred_init_tag{}, std::move(initiation), std::move(args)...);
-  }
-
-  template <typename... InitArgs>
-  static auto initiate_impl(
-      asio::detail::initiation_archetype<R(std::exception_ptr, T)>,
-      std::allocator_arg_t, Allocator, InitArgs... args)
-    -> experimental::coro<void(), T, asio::any_io_executor, Allocator>;
-
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_coro_t<Allocator> tk, InitArgs&&... args)
-  {
-    return initiate_impl(std::move(initiation), std::allocator_arg,
-        tk.get_allocator(), std::forward<InitArgs>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_IMPL_USE_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_promise.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_promise.hpp
deleted file mode 100644
index 259edb3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/impl/use_promise.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// experimental/impl/use_promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_IMPL_USE_PROMISE_HPP
-#define ASIO_EXPERIMENTAL_IMPL_USE_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <memory>
-#include "asio/async_result.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-template <typename Allocator>
-struct use_promise_t;
-
-namespace detail {
-
-template<typename Signature, typename Executor, typename Allocator>
-struct promise_handler;
-
-} // namespace detail
-} // namespace experimental
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Allocator, typename R, typename... Args>
-struct async_result<experimental::use_promise_t<Allocator>, R(Args...)>
-{
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation initiation,
-      experimental::use_promise_t<Allocator> up, InitArgs... args)
-    -> experimental::promise<void(decay_t<Args>...),
-      asio::associated_executor_t<Initiation>, Allocator>
-  {
-    using handler_type = experimental::detail::promise_handler<
-      void(decay_t<Args>...),
-      asio::associated_executor_t<Initiation>, Allocator>;
-
-    handler_type ht{up.get_allocator(), get_associated_executor(initiation)};
-    std::move(initiation)(ht, std::move(args)...);
-    return ht.make_promise();
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_IMPL_USE_PROMISE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/parallel_group.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/parallel_group.hpp
deleted file mode 100644
index 3e43ba2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/parallel_group.hpp
+++ /dev/null
@@ -1,455 +0,0 @@
-//
-// experimental/parallel_group.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
-#define ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <vector>
-#include "asio/async_result.hpp"
-#include "asio/detail/array.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-#include "asio/experimental/cancellation_condition.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-namespace detail {
-
-// Helper trait for getting a tuple from a completion signature.
-
-template <typename Signature>
-struct parallel_op_signature_as_tuple;
-
-template <typename R, typename... Args>
-struct parallel_op_signature_as_tuple<R(Args...)>
-{
-  typedef std::tuple<decay_t<Args>...> type;
-};
-
-// Helper trait for concatenating completion signatures.
-
-template <std::size_t N, typename Offsets, typename... Signatures>
-struct parallel_group_signature;
-
-template <std::size_t N, typename R0, typename... Args0>
-struct parallel_group_signature<N, R0(Args0...)>
-{
-  typedef asio::detail::array<std::size_t, N> order_type;
-  typedef R0 raw_type(Args0...);
-  typedef R0 type(order_type, Args0...);
-};
-
-template <std::size_t N,
-    typename R0, typename... Args0,
-    typename R1, typename... Args1>
-struct parallel_group_signature<N, R0(Args0...), R1(Args1...)>
-{
-  typedef asio::detail::array<std::size_t, N> order_type;
-  typedef R0 raw_type(Args0..., Args1...);
-  typedef R0 type(order_type, Args0..., Args1...);
-};
-
-template <std::size_t N, typename Sig0,
-    typename Sig1, typename... SigN>
-struct parallel_group_signature<N, Sig0, Sig1, SigN...>
-{
-  typedef asio::detail::array<std::size_t, N> order_type;
-  typedef typename parallel_group_signature<N,
-    typename parallel_group_signature<N, Sig0, Sig1>::raw_type,
-      SigN...>::raw_type raw_type;
-  typedef typename parallel_group_signature<N,
-    typename parallel_group_signature<N, Sig0, Sig1>::raw_type,
-      SigN...>::type type;
-};
-
-template <typename Condition, typename Handler,
-    typename... Ops, std::size_t... I>
-void parallel_group_launch(Condition cancellation_condition, Handler handler,
-    std::tuple<Ops...>& ops, asio::detail::index_sequence<I...>);
-
-// Helper trait for determining ranged parallel group completion signatures.
-
-template <typename Signature, typename Allocator>
-struct ranged_parallel_group_signature;
-
-template <typename R, typename... Args, typename Allocator>
-struct ranged_parallel_group_signature<R(Args...), Allocator>
-{
-  typedef std::vector<std::size_t,
-    ASIO_REBIND_ALLOC(Allocator, std::size_t)> order_type;
-  typedef R raw_type(
-      std::vector<Args, ASIO_REBIND_ALLOC(Allocator, Args)>...);
-  typedef R type(order_type,
-      std::vector<Args, ASIO_REBIND_ALLOC(Allocator, Args)>...);
-};
-
-template <typename Condition, typename Handler,
-    typename Range, typename Allocator>
-void ranged_parallel_group_launch(Condition cancellation_condition,
-    Handler handler, Range&& range, const Allocator& allocator);
-
-char (&parallel_group_has_iterator_helper(...))[2];
-
-template <typename T>
-char parallel_group_has_iterator_helper(T*, typename T::iterator* = 0);
-
-template <typename T>
-struct parallel_group_has_iterator_typedef
-{
-  enum { value = (sizeof((parallel_group_has_iterator_helper)((T*)(0))) == 1) };
-};
-
-} // namespace detail
-
-/// Type trait used to determine whether a type is a range of asynchronous
-/// operations that can be used with with @c make_parallel_group.
-template <typename T>
-struct is_async_operation_range
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// The value member is true if the type may be used as a range of
-  /// asynchronous operations.
-  static const bool value;
-#else
-  enum
-  {
-    value = detail::parallel_group_has_iterator_typedef<T>::value
-  };
-#endif
-};
-
-/// A group of asynchronous operations that may be launched in parallel.
-/**
- * See the documentation for asio::experimental::make_parallel_group for
- * a usage example.
- */
-template <typename... Ops>
-class parallel_group
-{
-private:
-  struct initiate_async_wait
-  {
-    template <typename Handler, typename Condition>
-    void operator()(Handler&& h, Condition&& c, std::tuple<Ops...>&& ops) const
-    {
-      detail::parallel_group_launch(
-          std::forward<Condition>(c), std::forward<Handler>(h),
-          ops, asio::detail::index_sequence_for<Ops...>());
-    }
-  };
-
-  std::tuple<Ops...> ops_;
-
-public:
-  /// Constructor.
-  explicit parallel_group(Ops... ops)
-    : ops_(std::move(ops)...)
-  {
-  }
-
-  /// The completion signature for the group of operations.
-  typedef typename detail::parallel_group_signature<sizeof...(Ops),
-      completion_signature_of_t<Ops>...>::type signature;
-
-  /// Initiate an asynchronous wait for the group of operations.
-  /**
-   * Launches the group and asynchronously waits for completion.
-   *
-   * @param cancellation_condition A function object, called on completion of
-   * an operation within the group, that is used to determine whether to cancel
-   * the remaining operations. The function object is passed the arguments of
-   * the completed operation's handler. To trigger cancellation of the remaining
-   * operations, it must return a asio::cancellation_type value other
-   * than <tt>asio::cancellation_type::none</tt>.
-   *
-   * @param token A @ref completion_token whose signature is comprised of
-   * a @c std::array<std::size_t, N> indicating the completion order of the
-   * operations, followed by all operations' completion handler arguments.
-   *
-   * The library provides the following @c cancellation_condition types:
-   *
-   * @li asio::experimental::wait_for_all
-   * @li asio::experimental::wait_for_one
-   * @li asio::experimental::wait_for_one_error
-   * @li asio::experimental::wait_for_one_success
-   */
-  template <typename CancellationCondition,
-      ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  auto async_wait(CancellationCondition cancellation_condition,
-      CompletionToken&& token)
-    -> decltype(
-      asio::async_initiate<CompletionToken, signature>(
-        declval<initiate_async_wait>(), token,
-        std::move(cancellation_condition), std::move(ops_)))
-  {
-    return asio::async_initiate<CompletionToken, signature>(
-        initiate_async_wait(), token,
-        std::move(cancellation_condition), std::move(ops_));
-  }
-};
-
-/// Create a group of operations that may be launched in parallel.
-/**
- * For example:
- * @code asio::experimental::make_parallel_group(
- *    in.async_read_some(asio::buffer(data)),
- *    timer.async_wait()
- *  ).async_wait(
- *    asio::experimental::wait_for_all(),
- *    [](
- *        std::array<std::size_t, 2> completion_order,
- *        std::error_code ec1, std::size_t n1,
- *        std::error_code ec2
- *    )
- *    {
- *      switch (completion_order[0])
- *      {
- *      case 0:
- *        {
- *          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
- *        }
- *        break;
- *      case 1:
- *        {
- *          std::cout << "timer finished: " << ec2 << "\n";
- *        }
- *        break;
- *      }
- *    }
- *  );
- * @endcode
- *
- * If preferred, the asynchronous operations may be explicitly packaged as
- * function objects:
- * @code asio::experimental::make_parallel_group(
- *    [&](auto token)
- *    {
- *      return in.async_read_some(asio::buffer(data), token);
- *    },
- *    [&](auto token)
- *    {
- *      return timer.async_wait(token);
- *    }
- *  ).async_wait(
- *    asio::experimental::wait_for_all(),
- *    [](
- *        std::array<std::size_t, 2> completion_order,
- *        std::error_code ec1, std::size_t n1,
- *        std::error_code ec2
- *    )
- *    {
- *      switch (completion_order[0])
- *      {
- *      case 0:
- *        {
- *          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
- *        }
- *        break;
- *      case 1:
- *        {
- *          std::cout << "timer finished: " << ec2 << "\n";
- *        }
- *        break;
- *      }
- *    }
- *  );
- * @endcode
- */
-template <typename... Ops>
-ASIO_NODISCARD inline parallel_group<Ops...>
-make_parallel_group(Ops... ops)
-{
-  return parallel_group<Ops...>(std::move(ops)...);
-}
-
-/// A range-based group of asynchronous operations that may be launched in
-/// parallel.
-/**
- * See the documentation for asio::experimental::make_parallel_group for
- * a usage example.
- */
-template <typename Range, typename Allocator = std::allocator<void>>
-class ranged_parallel_group
-{
-private:
-  struct initiate_async_wait
-  {
-    template <typename Handler, typename Condition>
-    void operator()(Handler&& h, Condition&& c,
-        Range&& range, const Allocator& allocator) const
-    {
-      detail::ranged_parallel_group_launch(std::move(c),
-          std::move(h), std::forward<Range>(range), allocator);
-    }
-  };
-
-  Range range_;
-  Allocator allocator_;
-
-public:
-  /// Constructor.
-  explicit ranged_parallel_group(Range range,
-      const Allocator& allocator = Allocator())
-    : range_(std::move(range)),
-      allocator_(allocator)
-  {
-  }
-
-  /// The completion signature for the group of operations.
-  typedef typename detail::ranged_parallel_group_signature<
-      completion_signature_of_t<
-        decay_t<decltype(*std::declval<typename Range::iterator>())>>,
-      Allocator>::type signature;
-
-  /// Initiate an asynchronous wait for the group of operations.
-  /**
-   * Launches the group and asynchronously waits for completion.
-   *
-   * @param cancellation_condition A function object, called on completion of
-   * an operation within the group, that is used to determine whether to cancel
-   * the remaining operations. The function object is passed the arguments of
-   * the completed operation's handler. To trigger cancellation of the remaining
-   * operations, it must return a asio::cancellation_type value other
-   * than <tt>asio::cancellation_type::none</tt>.
-   *
-   * @param token A @ref completion_token whose signature is comprised of
-   * a @c std::vector<std::size_t, Allocator> indicating the completion order of
-   * the operations, followed by a vector for each of the completion signature's
-   * arguments.
-   *
-   * The library provides the following @c cancellation_condition types:
-   *
-   * @li asio::experimental::wait_for_all
-   * @li asio::experimental::wait_for_one
-   * @li asio::experimental::wait_for_one_error
-   * @li asio::experimental::wait_for_one_success
-   */
-  template <typename CancellationCondition,
-      ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  auto async_wait(CancellationCondition cancellation_condition,
-      CompletionToken&& token)
-    -> decltype(
-      asio::async_initiate<CompletionToken, signature>(
-        declval<initiate_async_wait>(), token,
-        std::move(cancellation_condition),
-        std::move(range_), allocator_))
-  {
-    return asio::async_initiate<CompletionToken, signature>(
-        initiate_async_wait(), token,
-        std::move(cancellation_condition),
-        std::move(range_), allocator_);
-  }
-};
-
-/// Create a group of operations that may be launched in parallel.
-/**
- * @param range A range containing the operations to be launched.
- *
- * For example:
- * @code
- * using op_type =
- *   decltype(socket1.async_read_some(asio::buffer(data1)));
- *
- * std::vector<op_type> ops;
- * ops.push_back(socket1.async_read_some(asio::buffer(data1)));
- * ops.push_back(socket2.async_read_some(asio::buffer(data2)));
- *
- * asio::experimental::make_parallel_group(ops).async_wait(
- *     asio::experimental::wait_for_all(),
- *     [](
- *         std::vector<std::size_t> completion_order,
- *         std::vector<std::error_code> e,
- *         std::vector<std::size_t> n
- *       )
- *     {
- *       for (std::size_t i = 0; i < completion_order.size(); ++i)
- *       {
- *         std::size_t idx = completion_order[i];
- *         std::cout << "socket " << idx << " finished: ";
- *         std::cout << e[idx] << ", " << n[idx] << "\n";
- *       }
- *     }
- *   );
- * @endcode
- */
-template <typename Range>
-ASIO_NODISCARD inline ranged_parallel_group<decay_t<Range>>
-make_parallel_group(Range&& range,
-    constraint_t<
-      is_async_operation_range<decay_t<Range>>::value
-    > = 0)
-{
-  return ranged_parallel_group<decay_t<Range>>(std::forward<Range>(range));
-}
-
-/// Create a group of operations that may be launched in parallel.
-/**
- * @param allocator Specifies the allocator to be used with the result vectors.
- *
- * @param range A range containing the operations to be launched.
- *
- * For example:
- * @code
- * using op_type =
- *   decltype(socket1.async_read_some(asio::buffer(data1)));
- *
- * std::vector<op_type> ops;
- * ops.push_back(socket1.async_read_some(asio::buffer(data1)));
- * ops.push_back(socket2.async_read_some(asio::buffer(data2)));
- *
- * asio::experimental::make_parallel_group(
- *     std::allocator_arg_t,
- *     my_allocator,
- *     ops
- *   ).async_wait(
- *     asio::experimental::wait_for_all(),
- *     [](
- *         std::vector<std::size_t> completion_order,
- *         std::vector<std::error_code> e,
- *         std::vector<std::size_t> n
- *       )
- *     {
- *       for (std::size_t i = 0; i < completion_order.size(); ++i)
- *       {
- *         std::size_t idx = completion_order[i];
- *         std::cout << "socket " << idx << " finished: ";
- *         std::cout << e[idx] << ", " << n[idx] << "\n";
- *       }
- *     }
- *   );
- * @endcode
- */
-template <typename Allocator, typename Range>
-ASIO_NODISCARD inline ranged_parallel_group<decay_t<Range>, Allocator>
-make_parallel_group(allocator_arg_t, const Allocator& allocator, Range&& range,
-    constraint_t<
-      is_async_operation_range<decay_t<Range>>::value
-    > = 0)
-{
-  return ranged_parallel_group<decay_t<Range>, Allocator>(
-      std::forward<Range>(range), allocator);
-}
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/impl/parallel_group.hpp"
-
-#endif // ASIO_EXPERIMENTAL_PARALLEL_GROUP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/prepend.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/prepend.hpp
deleted file mode 100644
index 503981f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/prepend.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// experimental/prepend.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_PREPEND_HPP
-#define ASIO_EXPERIMENTAL_PREPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/prepend.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-#if !defined(ASIO_NO_DEPRECATED)
-using asio::prepend_t;
-using asio::prepend;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_PREPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/promise.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/promise.hpp
deleted file mode 100644
index 3cb788e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/promise.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-//
-// experimental/promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_PROMISE_HPP
-#define ASIO_EXPERIMENTAL_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/experimental/impl/promise.hpp"
-#include "asio/post.hpp"
-
-#include <algorithm>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-template <typename T>
-struct is_promise : std::false_type {};
-
-template <typename ... Ts>
-struct is_promise<promise<Ts...>> : std::true_type {};
-
-template <typename T>
-constexpr bool is_promise_v = is_promise<T>::value;
-
-template <typename ... Ts>
-struct promise_value_type
-{
-  using type = std::tuple<Ts...>;
-};
-
-template <typename T>
-struct promise_value_type<T>
-{
-  using type = T;
-};
-
-template <>
-struct promise_value_type<>
-{
-  using type = std::tuple<>;
-};
-
-#if defined(GENERATING_DOCUMENTATION)
-/// A disposable handle for an eager operation.
-/**
- * @tparam Signature The signature of the operation.
- *
- * @tparam Executor The executor to be used by the promise (taken from the
- * operation).
- *
- * @tparam Allocator The allocator used for the promise. Can be set through
- * use_allocator.
- *
- * A promise can be used to initiate an asynchronous option that can be
- * completed later. If the promise gets destroyed before completion, the
- * operation gets a cancel signal and the result is ignored.
- *
- * A promise fulfills the requirements of async_operation.
- *
- * @par Examples
- * Reading and writing from one coroutine.
- * @code
- * awaitable<void> read_write_some(asio::ip::tcp::socket & sock,
- *     asio::mutable_buffer read_buf, asio::const_buffer to_write)
- * {
- *   auto p = asio::async_read(read_buf,
- *       asio::experimental::use_promise);
- *   co_await asio::async_write_some(to_write);
- *   co_await p;
- * }
- * @endcode
- */
-template<typename Signature = void(),
-    typename Executor = asio::any_io_executor,
-    typename Allocator = std::allocator<void>>
-struct promise
-#else
-template <typename ... Ts, typename Executor, typename Allocator>
-struct promise<void(Ts...), Executor,  Allocator>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-  /// The value that's returned by the promise.
-  using value_type = typename promise_value_type<Ts...>::type;
-
-  /// Cancel the promise. Usually done through the destructor.
-  void cancel(cancellation_type level = cancellation_type::all)
-  {
-    if (impl_ && !impl_->done)
-    {
-      asio::dispatch(impl_->executor,
-          [level, impl = impl_]{ impl->cancel.emit(level); });
-    }
-  }
-
-  /// Check if the promise is completed already.
-  bool completed() const noexcept
-  {
-    return impl_ && impl_->done;
-  }
-
-  /// Wait for the promise to become ready.
-  template <ASIO_COMPLETION_TOKEN_FOR(void(Ts...)) CompletionToken>
-  inline ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void(Ts...))
-  operator()(CompletionToken&& token)
-  {
-    assert(impl_);
-
-    return async_initiate<CompletionToken, void(Ts...)>(
-        initiate_async_wait{impl_}, token);
-  }
-
-  promise() = delete;
-  promise(const promise& ) = delete;
-  promise(promise&& ) noexcept = default;
-
-  /// Destruct the promise and cancel the operation.
-  /**
-   * It is safe to destruct a promise of a promise that didn't complete.
-   */
-  ~promise() { cancel(); }
-
-private:
-#if !defined(GENERATING_DOCUMENTATION)
-  template <typename, typename, typename> friend struct promise;
-  friend struct detail::promise_handler<void(Ts...), Executor, Allocator>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  std::shared_ptr<detail::promise_impl<
-    void(Ts...), Executor, Allocator>> impl_;
-
-  promise(
-      std::shared_ptr<detail::promise_impl<
-        void(Ts...), Executor, Allocator>> impl)
-    : impl_(impl)
-  {
-  }
-
-  struct initiate_async_wait
-  {
-    std::shared_ptr<detail::promise_impl<
-      void(Ts...), Executor, Allocator>> self_;
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      const auto alloc = get_associated_allocator(
-          handler, self_->get_allocator());
-
-      auto cancel = get_associated_cancellation_slot(handler);
-
-      if (self_->done)
-      {
-        auto exec = asio::get_associated_executor(
-            handler, self_->get_executor());
-
-        asio::post(exec,
-            [self = std::move(self_),
-              handler = std::forward<WaitHandler>(handler)]() mutable
-            {
-              self->apply(std::move(handler));
-            });
-      }
-      else
-      {
-        if (cancel.is_connected())
-        {
-          struct cancel_handler
-          {
-            std::weak_ptr<detail::promise_impl<
-              void(Ts...), Executor, Allocator>> self;
-
-            cancel_handler(
-                std::weak_ptr<detail::promise_impl<
-                  void(Ts...), Executor, Allocator>> self)
-              : self(std::move(self))
-            {
-            }
-
-            void operator()(cancellation_type level) const
-            {
-              if (auto p = self.lock())
-              {
-                p->cancel.emit(level);
-                p->cancel_();
-              }
-            }
-          };
-          cancel.template emplace<cancel_handler>(self_);
-        }
-
-        self_->set_completion(alloc, std::forward<WaitHandler>(handler));
-      }
-    }
-  };
-};
-
-} // namespace experimental
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_EXPERIMENTAL_PROMISE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_coro.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_coro.hpp
deleted file mode 100644
index 57bc382..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_coro.hpp
+++ /dev/null
@@ -1,189 +0,0 @@
-//
-// experimental/use_coro.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_USE_CORO_HPP
-#define ASIO_EXPERIMENTAL_USE_CORO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <memory>
-#include "asio/deferred.hpp"
-#include "asio/detail/source_location.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class any_io_executor;
-
-namespace experimental {
-
-/// A @ref completion_token that creates another coro for the task completion.
-/**
- * The @c use_coro_t class, with its value @c use_coro, is used to represent an
- * operation that can be awaited by the current resumable coroutine. This
- * completion token may be passed as a handler to an asynchronous operation.
- * For example:
- *
- * @code coro<void> my_coroutine(tcp::socket my_socket)
- * {
- *   std::size_t n = co_await my_socket.async_read_some(buffer, use_coro);
- *   ...
- * } @endcode
- *
- * When used with co_await, the initiating function (@c async_read_some in the
- * above example) suspends the current coroutine. The coroutine is resumed when
- * the asynchronous operation completes, and the result of the operation is
- * returned.
- *
- * Note that this token is not the most efficient (use the default completion
- * token @c asio::deferred for that) but does provide type erasure, as it
- * will always return a @c coro.
- */
-template <typename Allocator = std::allocator<void>>
-struct use_coro_t
-{
-
-  /// The allocator type. The allocator is used when constructing the
-  /// @c std::promise object for a given asynchronous operation.
-  typedef Allocator allocator_type;
-
-  /// Default constructor.
-  constexpr use_coro_t(
-      allocator_type allocator = allocator_type{}
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      , asio::detail::source_location location =
-        asio::detail::source_location::current()
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    )
-    : allocator_(allocator)
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-    , file_name_(location.file_name()),
-      line_(location.line()),
-      function_name_(location.function_name())
-# else // defined(ASIO_HAS_SOURCE_LOCATION)
-    , file_name_(0),
-      line_(0),
-      function_name_(0)
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-  {
-  }
-
-  /// Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_coro_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
-  {
-    return use_future_t<OtherAllocator>(allocator);
-  }
-
-  /// Obtain allocator.
-  allocator_type get_allocator() const
-  {
-    return allocator_;
-  }
-
-  /// Constructor used to specify file name, line, and function name.
-  constexpr use_coro_t(const char* file_name,
-      int line, const char* function_name,
-      allocator_type allocator = allocator_type{}) :
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-      file_name_(file_name),
-      line_(line),
-      function_name_(function_name),
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-      allocator_(allocator)
-  {
-#if !defined(ASIO_ENABLE_HANDLER_TRACKING)
-    (void)file_name;
-    (void)line;
-    (void)function_name;
-#endif // !defined(ASIO_ENABLE_HANDLER_TRACKING)
-  }
-
-  /// Adapts an executor to add the @c use_coro_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c use_coro_t as the default completion token type.
-    typedef use_coro_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    template <typename InnerExecutor1>
-    executor_with_default(const InnerExecutor1& ex,
-        constraint_t<
-          conditional_t<
-            !is_same<InnerExecutor1, executor_with_default>::value,
-            is_convertible<InnerExecutor1, InnerExecutor>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c use_coro_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c use_coro_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-  const char* file_name_;
-  int line_;
-  const char* function_name_;
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-private:
-  Allocator allocator_;
-};
-
-/// A @ref completion_token object that represents the currently executing
-/// resumable coroutine.
-/**
- * See the documentation for asio::use_coro_t for a usage example.
- */
-#if defined(GENERATING_DOCUMENTATION)
-constexpr use_coro_t<> use_coro;
-#else
-constexpr use_coro_t<> use_coro(0, 0, 0);
-#endif
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/impl/use_coro.hpp"
-#include "asio/experimental/coro.hpp"
-
-#endif // ASIO_EXPERIMENTAL_USE_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_promise.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_promise.hpp
deleted file mode 100644
index cf19aca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/experimental/use_promise.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//
-// experimental/use_promise.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_EXPERIMENTAL_USE_PROMISE_HPP
-#define ASIO_EXPERIMENTAL_USE_PROMISE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <memory>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace experimental {
-
-template <typename Allocator = std::allocator<void>>
-struct use_promise_t
-{
-  /// The allocator type. The allocator is used when constructing the
-  /// @c promise object for a given asynchronous operation.
-  typedef Allocator allocator_type;
-
-  /// Construct using default-constructed allocator.
-  constexpr use_promise_t()
-  {
-  }
-
-  /// Construct using specified allocator.
-  explicit use_promise_t(const Allocator& allocator)
-    : allocator_(allocator)
-  {
-  }
-
-  /// Obtain allocator.
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Adapts an executor to add the @c use_promise_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c use_promise_t as the default completion token type.
-    typedef use_promise_t<Allocator> default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    executor_with_default(const InnerExecutor& ex) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-
-    /// Convert the specified executor to the inner executor type, then use
-    /// that to construct the adapted executor.
-    template <typename OtherExecutor>
-    executor_with_default(const OtherExecutor& ex,
-        constraint_t<
-          is_convertible<OtherExecutor, InnerExecutor>::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Function helper to adapt an I/O object to use @c use_promise_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-  /// Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_promise_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
-  {
-    return use_promise_t<OtherAllocator>(allocator);
-  }
-
-private:
-  Allocator allocator_;
-};
-
-constexpr use_promise_t<> use_promise;
-
-} // namespace experimental
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/experimental/impl/use_promise.hpp"
-
-#endif // ASIO_EXPERIMENTAL_USE_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/file_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/file_base.hpp
deleted file mode 100644
index 5e8ac4f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/file_base.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-//
-// file_base.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_FILE_BASE_HPP
-#define ASIO_FILE_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_WINDOWS)
-# include <fcntl.h>
-#endif // !defined(ASIO_WINDOWS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The file_base class is used as a base for the basic_stream_file and
-/// basic_random_access_file class templates so that we have a common place to
-/// define flags.
-class file_base
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// A bitmask type (C++ Std [lib.bitmask.types]).
-  typedef unspecified flags;
-
-  /// Open the file for reading.
-  static const flags read_only = implementation_defined;
-
-  /// Open the file for writing.
-  static const flags write_only = implementation_defined;
-
-  /// Open the file for reading and writing.
-  static const flags read_write = implementation_defined;
-
-  /// Open the file in append mode.
-  static const flags append = implementation_defined;
-
-  /// Create the file if it does not exist.
-  static const flags create = implementation_defined;
-
-  /// Ensure a new file is created. Must be combined with @c create.
-  static const flags exclusive = implementation_defined;
-
-  /// Open the file with any existing contents truncated.
-  static const flags truncate = implementation_defined;
-
-  /// Open the file so that write operations automatically synchronise the file
-  /// data and metadata to disk.
-  static const flags sync_all_on_write = implementation_defined;
-#else
-  enum flags
-  {
-#if defined(ASIO_WINDOWS)
-    read_only = 1,
-    write_only = 2,
-    read_write = 4,
-    append = 8,
-    create = 16,
-    exclusive = 32,
-    truncate = 64,
-    sync_all_on_write = 128
-#else // defined(ASIO_WINDOWS)
-    read_only = O_RDONLY,
-    write_only = O_WRONLY,
-    read_write = O_RDWR,
-    append = O_APPEND,
-    create = O_CREAT,
-    exclusive = O_EXCL,
-    truncate = O_TRUNC,
-    sync_all_on_write = O_SYNC
-#endif // defined(ASIO_WINDOWS)
-  };
-
-  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
-
-  friend flags operator&(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
-  }
-
-  friend flags operator|(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
-  }
-
-  friend flags operator^(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
-  }
-
-  friend flags operator~(flags x)
-  {
-    return static_cast<flags>(~static_cast<unsigned int>(x));
-  }
-
-  friend flags& operator&=(flags& x, flags y)
-  {
-    x = x & y;
-    return x;
-  }
-
-  friend flags& operator|=(flags& x, flags y)
-  {
-    x = x | y;
-    return x;
-  }
-
-  friend flags& operator^=(flags& x, flags y)
-  {
-    x = x ^ y;
-    return x;
-  }
-#endif
-
-  /// Basis for seeking in a file.
-  enum seek_basis
-  {
-#if defined(GENERATING_DOCUMENTATION)
-    /// Seek to an absolute position.
-    seek_set = implementation_defined,
-
-    /// Seek to an offset relative to the current file position.
-    seek_cur = implementation_defined,
-
-    /// Seek to an offset relative to the end of the file.
-    seek_end = implementation_defined
-#else
-    seek_set = SEEK_SET,
-    seek_cur = SEEK_CUR,
-    seek_end = SEEK_END
-#endif
-  };
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~file_base()
-  {
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_FILE_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/basic_endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/basic_endpoint.hpp
deleted file mode 100644
index e7e1f6d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/basic_endpoint.hpp
+++ /dev/null
@@ -1,189 +0,0 @@
-//
-// generic/basic_endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_BASIC_ENDPOINT_HPP
-#define ASIO_GENERIC_BASIC_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/generic/detail/endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-
-/// Describes an endpoint for any socket type.
-/**
- * The asio::generic::basic_endpoint class template describes an endpoint
- * that may be associated with any socket type.
- *
- * @note The socket types sockaddr type must be able to fit into a
- * @c sockaddr_storage structure.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * Endpoint.
- */
-template <typename Protocol>
-class basic_endpoint
-{
-public:
-  /// The protocol type associated with the endpoint.
-  typedef Protocol protocol_type;
-
-  /// The type of the endpoint structure. This type is dependent on the
-  /// underlying implementation of the socket layer.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined data_type;
-#else
-  typedef asio::detail::socket_addr_type data_type;
-#endif
-
-  /// Default constructor.
-  basic_endpoint() noexcept
-  {
-  }
-
-  /// Construct an endpoint from the specified socket address.
-  basic_endpoint(const void* socket_address,
-      std::size_t socket_address_size, int socket_protocol = 0)
-    : impl_(socket_address, socket_address_size, socket_protocol)
-  {
-  }
-
-  /// Construct an endpoint from the specific endpoint type.
-  template <typename Endpoint>
-  basic_endpoint(const Endpoint& endpoint)
-    : impl_(endpoint.data(), endpoint.size(), endpoint.protocol().protocol())
-  {
-  }
-
-  /// Copy constructor.
-  basic_endpoint(const basic_endpoint& other)
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Move constructor.
-  basic_endpoint(basic_endpoint&& other)
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Assign from another endpoint.
-  basic_endpoint& operator=(const basic_endpoint& other)
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// Move-assign from another endpoint.
-  basic_endpoint& operator=(basic_endpoint&& other)
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// The protocol associated with the endpoint.
-  protocol_type protocol() const
-  {
-    return protocol_type(impl_.family(), impl_.protocol());
-  }
-
-  /// Get the underlying endpoint in the native type.
-  data_type* data()
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying endpoint in the native type.
-  const data_type* data() const
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying size of the endpoint in the native type.
-  std::size_t size() const
-  {
-    return impl_.size();
-  }
-
-  /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t new_size)
-  {
-    impl_.resize(new_size);
-  }
-
-  /// Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const
-  {
-    return impl_.capacity();
-  }
-
-  /// Compare two endpoints for equality.
-  friend bool operator==(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e1.impl_ == e2.impl_;
-  }
-
-  /// Compare two endpoints for inequality.
-  friend bool operator!=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e1.impl_ == e2.impl_);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e1.impl_ < e2.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e2.impl_ < e1.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e2 < e1);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e1 < e2);
-  }
-
-private:
-  // The underlying generic endpoint.
-  asio::generic::detail::endpoint impl_;
-};
-
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_BASIC_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/datagram_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/datagram_protocol.hpp
deleted file mode 100644
index 6e81cd6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/datagram_protocol.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//
-// generic/datagram_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
-#define ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <typeinfo>
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/generic/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-
-/// Encapsulates the flags needed for a generic datagram-oriented socket.
-/**
- * The asio::generic::datagram_protocol class contains flags necessary
- * for datagram-oriented sockets of any address family and protocol.
- *
- * @par Examples
- * Constructing using a native address family and socket protocol:
- * @code datagram_protocol p(AF_INET, IPPROTO_UDP); @endcode
- * Constructing from a specific protocol type:
- * @code datagram_protocol p(asio::ip::udp::v4()); @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class datagram_protocol
-{
-public:
-  /// Construct a protocol object for a specific address family and protocol.
-  datagram_protocol(int address_family, int socket_protocol)
-    : family_(address_family),
-      protocol_(socket_protocol)
-  {
-  }
-
-  /// Construct a generic protocol object from a specific protocol.
-  /**
-   * @throws @c bad_cast Thrown if the source protocol is not datagram-oriented.
-   */
-  template <typename Protocol>
-  datagram_protocol(const Protocol& source_protocol)
-    : family_(source_protocol.family()),
-      protocol_(source_protocol.protocol())
-  {
-    if (source_protocol.type() != type())
-    {
-      std::bad_cast ex;
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_DGRAM);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return protocol_;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const datagram_protocol& p1,
-      const datagram_protocol& p2)
-  {
-    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const datagram_protocol& p1,
-      const datagram_protocol& p2)
-  {
-    return !(p1 == p2);
-  }
-
-  /// The type of an endpoint.
-  typedef basic_endpoint<datagram_protocol> endpoint;
-
-  /// The generic socket type.
-  typedef basic_datagram_socket<datagram_protocol> socket;
-
-private:
-  int family_;
-  int protocol_;
-};
-
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/endpoint.hpp
deleted file mode 100644
index fdbcde9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/endpoint.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-//
-// generic/detail/endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_DETAIL_ENDPOINT_HPP
-#define ASIO_GENERIC_DETAIL_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstddef>
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-namespace detail {
-
-// Helper class for implementing a generic socket endpoint.
-class endpoint
-{
-public:
-  // Default constructor.
-  ASIO_DECL endpoint();
-
-  // Construct an endpoint from the specified raw bytes.
-  ASIO_DECL endpoint(const void* sock_addr,
-      std::size_t sock_addr_size, int sock_protocol);
-
-  // Copy constructor.
-  endpoint(const endpoint& other)
-    : data_(other.data_),
-      size_(other.size_),
-      protocol_(other.protocol_)
-  {
-  }
-
-  // Assign from another endpoint.
-  endpoint& operator=(const endpoint& other)
-  {
-    data_ = other.data_;
-    size_ = other.size_;
-    protocol_ = other.protocol_;
-    return *this;
-  }
-
-  // Get the address family associated with the endpoint.
-  int family() const
-  {
-    return data_.base.sa_family;
-  }
-
-  // Get the socket protocol associated with the endpoint.
-  int protocol() const
-  {
-    return protocol_;
-  }
-
-  // Get the underlying endpoint in the native type.
-  asio::detail::socket_addr_type* data()
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying endpoint in the native type.
-  const asio::detail::socket_addr_type* data() const
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying size of the endpoint in the native type.
-  std::size_t size() const
-  {
-    return size_;
-  }
-
-  // Set the underlying size of the endpoint in the native type.
-  ASIO_DECL void resize(std::size_t size);
-
-  // Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const
-  {
-    return sizeof(asio::detail::sockaddr_storage_type);
-  }
-
-  // Compare two endpoints for equality.
-  ASIO_DECL friend bool operator==(
-      const endpoint& e1, const endpoint& e2);
-
-  // Compare endpoints for ordering.
-  ASIO_DECL friend bool operator<(
-      const endpoint& e1, const endpoint& e2);
-
-private:
-  // The underlying socket address.
-  union data_union
-  {
-    asio::detail::socket_addr_type base;
-    asio::detail::sockaddr_storage_type generic;
-  } data_;
-
-  // The length of the socket address stored in the endpoint.
-  std::size_t size_;
-
-  // The socket protocol associated with the endpoint.
-  int protocol_;
-
-  // Initialise with a specified memory.
-  ASIO_DECL void init(const void* sock_addr,
-      std::size_t sock_addr_size, int sock_protocol);
-};
-
-} // namespace detail
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/generic/detail/impl/endpoint.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_GENERIC_DETAIL_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/impl/endpoint.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/impl/endpoint.ipp
deleted file mode 100644
index 3e88c21..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/detail/impl/endpoint.ipp
+++ /dev/null
@@ -1,110 +0,0 @@
-//
-// generic/detail/impl/endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
-#define ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstring>
-#include <typeinfo>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/error.hpp"
-#include "asio/generic/detail/endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-namespace detail {
-
-endpoint::endpoint()
-{
-  init(0, 0, 0);
-}
-
-endpoint::endpoint(const void* sock_addr,
-    std::size_t sock_addr_size, int sock_protocol)
-{
-  init(sock_addr, sock_addr_size, sock_protocol);
-}
-
-void endpoint::resize(std::size_t new_size)
-{
-  if (new_size > sizeof(asio::detail::sockaddr_storage_type))
-  {
-    asio::error_code ec(asio::error::invalid_argument);
-    asio::detail::throw_error(ec);
-  }
-  else
-  {
-    size_ = new_size;
-    protocol_ = 0;
-  }
-}
-
-bool operator==(const endpoint& e1, const endpoint& e2)
-{
-  using namespace std; // For memcmp.
-  return e1.size() == e2.size() && memcmp(e1.data(), e2.data(), e1.size()) == 0;
-}
-
-bool operator<(const endpoint& e1, const endpoint& e2)
-{
-  if (e1.protocol() < e2.protocol())
-    return true;
-
-  if (e1.protocol() > e2.protocol())
-    return false;
-
-  using namespace std; // For memcmp.
-  std::size_t compare_size = e1.size() < e2.size() ? e1.size() : e2.size();
-  int compare_result = memcmp(e1.data(), e2.data(), compare_size);
-
-  if (compare_result < 0)
-    return true;
-
-  if (compare_result > 0)
-    return false;
-
-  return e1.size() < e2.size();
-}
-
-void endpoint::init(const void* sock_addr,
-    std::size_t sock_addr_size, int sock_protocol)
-{
-  if (sock_addr_size > sizeof(asio::detail::sockaddr_storage_type))
-  {
-    asio::error_code ec(asio::error::invalid_argument);
-    asio::detail::throw_error(ec);
-  }
-
-  using namespace std; // For memset and memcpy.
-  memset(&data_.generic, 0, sizeof(asio::detail::sockaddr_storage_type));
-  if (sock_addr_size > 0)
-    memcpy(&data_.generic, sock_addr, sock_addr_size);
-
-  size_ = sock_addr_size;
-  protocol_ = sock_protocol;
-}
-
-} // namespace detail
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/raw_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/raw_protocol.hpp
deleted file mode 100644
index fc81cdd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/raw_protocol.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// generic/raw_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_RAW_PROTOCOL_HPP
-#define ASIO_GENERIC_RAW_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <typeinfo>
-#include "asio/basic_raw_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/generic/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-
-/// Encapsulates the flags needed for a generic raw socket.
-/**
- * The asio::generic::raw_protocol class contains flags necessary for
- * raw sockets of any address family and protocol.
- *
- * @par Examples
- * Constructing using a native address family and socket protocol:
- * @code raw_protocol p(AF_INET, IPPROTO_ICMP); @endcode
- * Constructing from a specific protocol type:
- * @code raw_protocol p(asio::ip::icmp::v4()); @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class raw_protocol
-{
-public:
-  /// Construct a protocol object for a specific address family and protocol.
-  raw_protocol(int address_family, int socket_protocol)
-    : family_(address_family),
-      protocol_(socket_protocol)
-  {
-  }
-
-  /// Construct a generic protocol object from a specific protocol.
-  /**
-   * @throws @c bad_cast Thrown if the source protocol is not raw-oriented.
-   */
-  template <typename Protocol>
-  raw_protocol(const Protocol& source_protocol)
-    : family_(source_protocol.family()),
-      protocol_(source_protocol.protocol())
-  {
-    if (source_protocol.type() != type())
-    {
-      std::bad_cast ex;
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_RAW);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return protocol_;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
-  {
-    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
-  {
-    return !(p1 == p2);
-  }
-
-  /// The type of an endpoint.
-  typedef basic_endpoint<raw_protocol> endpoint;
-
-  /// The generic socket type.
-  typedef basic_raw_socket<raw_protocol> socket;
-
-private:
-  int family_;
-  int protocol_;
-};
-
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_RAW_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/seq_packet_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/seq_packet_protocol.hpp
deleted file mode 100644
index e0342a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/seq_packet_protocol.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-// generic/seq_packet_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
-#define ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <typeinfo>
-#include "asio/basic_seq_packet_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/generic/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-
-/// Encapsulates the flags needed for a generic sequenced packet socket.
-/**
- * The asio::generic::seq_packet_protocol class contains flags necessary
- * for seq_packet-oriented sockets of any address family and protocol.
- *
- * @par Examples
- * Constructing using a native address family and socket protocol:
- * @code seq_packet_protocol p(AF_INET, IPPROTO_SCTP); @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class seq_packet_protocol
-{
-public:
-  /// Construct a protocol object for a specific address family and protocol.
-  seq_packet_protocol(int address_family, int socket_protocol)
-    : family_(address_family),
-      protocol_(socket_protocol)
-  {
-  }
-
-  /// Construct a generic protocol object from a specific protocol.
-  /**
-   * @throws @c bad_cast Thrown if the source protocol is not based around
-   * sequenced packets.
-   */
-  template <typename Protocol>
-  seq_packet_protocol(const Protocol& source_protocol)
-    : family_(source_protocol.family()),
-      protocol_(source_protocol.protocol())
-  {
-    if (source_protocol.type() != type())
-    {
-      std::bad_cast ex;
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_SEQPACKET);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return protocol_;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const seq_packet_protocol& p1,
-      const seq_packet_protocol& p2)
-  {
-    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const seq_packet_protocol& p1,
-      const seq_packet_protocol& p2)
-  {
-    return !(p1 == p2);
-  }
-
-  /// The type of an endpoint.
-  typedef basic_endpoint<seq_packet_protocol> endpoint;
-
-  /// The generic socket type.
-  typedef basic_seq_packet_socket<seq_packet_protocol> socket;
-
-private:
-  int family_;
-  int protocol_;
-};
-
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/stream_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/stream_protocol.hpp
deleted file mode 100644
index 270006e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/generic/stream_protocol.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// generic/stream_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_GENERIC_STREAM_PROTOCOL_HPP
-#define ASIO_GENERIC_STREAM_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <typeinfo>
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/generic/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace generic {
-
-/// Encapsulates the flags needed for a generic stream-oriented socket.
-/**
- * The asio::generic::stream_protocol class contains flags necessary for
- * stream-oriented sockets of any address family and protocol.
- *
- * @par Examples
- * Constructing using a native address family and socket protocol:
- * @code stream_protocol p(AF_INET, IPPROTO_TCP); @endcode
- * Constructing from a specific protocol type:
- * @code stream_protocol p(asio::ip::tcp::v4()); @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class stream_protocol
-{
-public:
-  /// Construct a protocol object for a specific address family and protocol.
-  stream_protocol(int address_family, int socket_protocol)
-    : family_(address_family),
-      protocol_(socket_protocol)
-  {
-  }
-
-  /// Construct a generic protocol object from a specific protocol.
-  /**
-   * @throws @c bad_cast Thrown if the source protocol is not stream-oriented.
-   */
-  template <typename Protocol>
-  stream_protocol(const Protocol& source_protocol)
-    : family_(source_protocol.family()),
-      protocol_(source_protocol.protocol())
-  {
-    if (source_protocol.type() != type())
-    {
-      std::bad_cast ex;
-      asio::detail::throw_exception(ex);
-    }
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_STREAM);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return protocol_;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
-  {
-    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
-  {
-    return !(p1 == p2);
-  }
-
-  /// The type of an endpoint.
-  typedef basic_endpoint<stream_protocol> endpoint;
-
-  /// The generic socket type.
-  typedef basic_stream_socket<stream_protocol> socket;
-
-#if !defined(ASIO_NO_IOSTREAM)
-  /// The generic socket iostream type.
-  typedef basic_socket_iostream<stream_protocol> iostream;
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-private:
-  int family_;
-  int protocol_;
-};
-
-} // namespace generic
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_GENERIC_STREAM_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/handler_continuation_hook.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/handler_continuation_hook.hpp
deleted file mode 100644
index 8c5c652..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/handler_continuation_hook.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// handler_continuation_hook.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_HANDLER_CONTINUATION_HOOK_HPP
-#define ASIO_HANDLER_CONTINUATION_HOOK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Default continuation function for handlers.
-/**
- * Asynchronous operations may represent a continuation of the asynchronous
- * control flow associated with the current handler. The implementation can use
- * this knowledge to optimise scheduling of the handler.
- *
- * Implement asio_handler_is_continuation for your own handlers to indicate
- * when a handler represents a continuation.
- *
- * The default implementation of the continuation hook returns <tt>false</tt>.
- *
- * @par Example
- * @code
- * class my_handler;
- *
- * bool asio_handler_is_continuation(my_handler* context)
- * {
- *   return true;
- * }
- * @endcode
- */
-inline bool asio_handler_is_continuation(...)
-{
-  return false;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_HANDLER_CONTINUATION_HOOK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/high_resolution_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/high_resolution_timer.hpp
deleted file mode 100644
index 50e8030..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/high_resolution_timer.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// high_resolution_timer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_HIGH_RESOLUTION_TIMER_HPP
-#define ASIO_HIGH_RESOLUTION_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/detail/chrono.hpp"
-
-namespace asio {
-
-/// Typedef for a timer based on the high resolution clock.
-/**
- * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
- * available. Otherwise, it may use the Boost.Chrono library. To explicitly
- * utilise Boost.Chrono, use the basic_waitable_timer template directly:
- * @code
- * typedef basic_waitable_timer<boost::chrono::high_resolution_clock> timer;
- * @endcode
- */
-typedef basic_waitable_timer<
-    chrono::high_resolution_clock>
-  high_resolution_timer;
-
-} // namespace asio
-
-#endif // ASIO_HIGH_RESOLUTION_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/immediate.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/immediate.hpp
deleted file mode 100644
index 4035ba5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/immediate.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-//
-// immediate.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMMEDIATE_HPP
-#define ASIO_IMMEDIATE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_immediate_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/dispatch.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Executor>
-class initiate_immediate
-{
-public:
-  typedef Executor executor_type;
-
-  explicit initiate_immediate(const Executor& ex)
-    : ex_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return ex_;
-  }
-
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& handler) const
-  {
-    typename associated_immediate_executor<
-      CompletionHandler, executor_type>::type ex =
-        (get_associated_immediate_executor)(handler, ex_);
-    (dispatch)(ex, static_cast<CompletionHandler&&>(handler));
-  }
-
-private:
-  Executor ex_;
-};
-
-} // namespace detail
-
-/// Launch a trivial asynchronous operation that completes immediately.
-/**
- * The async_immediate function is intended for use by composed operations,
- * which can delegate to this operation in order to implement the correct
- * semantics for immediate completion.
- *
- * @param ex The asynchronous operation's I/O executor.
- *
- * @param token The completion token.
- *
- * The completion handler is immediately submitted for execution by calling
- * asio::dispatch() on the handler's associated immediate executor.
- *
- * If the completion handler does not have a customised associated immediate
- * executor, then the handler is submitted as if by calling asio::post()
- * on the supplied I/O executor.
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename Executor,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<Executor>>
-inline auto async_immediate(const Executor& ex,
-    NullaryToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      (execution::is_executor<Executor>::value
-          && can_require<Executor, execution::blocking_t::never_t>::value)
-        || is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_immediate<Executor>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_immediate<Executor>(ex), token);
-}
-
-/// Launch a trivial asynchronous operation that completes immediately.
-/**
- * The async_immediate function is intended for use by composed operations,
- * which can delegate to this operation in order to implement the correct
- * semantics for immediate completion.
- *
- * @param ex The execution context used to obtain the asynchronous operation's
- * I/O executor.
- *
- * @param token The completion token.
- *
- * The completion handler is immediately submitted for execution by calling
- * asio::dispatch() on the handler's associated immediate executor.
- *
- * If the completion handler does not have a customised associated immediate
- * executor, then the handler is submitted as if by calling asio::post()
- * on the I/O executor obtained from the supplied execution context.
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename ExecutionContext,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<typename ExecutionContext::executor_type>>
-inline auto async_immediate(ExecutionContext& ctx,
-    NullaryToken&& token = default_completion_token_t<
-      typename ExecutionContext::executor_type>(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_immediate<
-        typename ExecutionContext::executor_type>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_immediate<
-        typename ExecutionContext::executor_type>(
-          ctx.get_executor()), token);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMMEDIATE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_completion_executor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_completion_executor.ipp
deleted file mode 100644
index fdad007..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_completion_executor.ipp
+++ /dev/null
@@ -1,126 +0,0 @@
-//
-// impl/any_completion_executor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_ANY_COMPLETION_EXECUTOR_IPP
-#define ASIO_IMPL_ANY_COMPLETION_EXECUTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#include "asio/any_completion_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-any_completion_executor::any_completion_executor() noexcept
-  : base_type()
-{
-}
-
-any_completion_executor::any_completion_executor(nullptr_t) noexcept
-  : base_type(nullptr_t())
-{
-}
-
-any_completion_executor::any_completion_executor(
-    const any_completion_executor& e) noexcept
-  : base_type(static_cast<const base_type&>(e))
-{
-}
-
-any_completion_executor::any_completion_executor(std::nothrow_t,
-    const any_completion_executor& e) noexcept
-  : base_type(static_cast<const base_type&>(e))
-{
-}
-
-any_completion_executor::any_completion_executor(
-    any_completion_executor&& e) noexcept
-  : base_type(static_cast<base_type&&>(e))
-{
-}
-
-any_completion_executor::any_completion_executor(std::nothrow_t,
-    any_completion_executor&& e) noexcept
-  : base_type(static_cast<base_type&&>(e))
-{
-}
-
-any_completion_executor& any_completion_executor::operator=(
-    const any_completion_executor& e) noexcept
-{
-  base_type::operator=(static_cast<const base_type&>(e));
-  return *this;
-}
-
-any_completion_executor& any_completion_executor::operator=(
-    any_completion_executor&& e) noexcept
-{
-  base_type::operator=(static_cast<base_type&&>(e));
-  return *this;
-}
-
-any_completion_executor& any_completion_executor::operator=(nullptr_t)
-{
-  base_type::operator=(nullptr_t());
-  return *this;
-}
-
-any_completion_executor::~any_completion_executor()
-{
-}
-
-void any_completion_executor::swap(
-    any_completion_executor& other) noexcept
-{
-  static_cast<base_type&>(*this).swap(static_cast<base_type&>(other));
-}
-
-template <>
-any_completion_executor any_completion_executor::prefer(
-    const execution::outstanding_work_t::tracked_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_completion_executor any_completion_executor::prefer(
-    const execution::outstanding_work_t::untracked_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_completion_executor any_completion_executor::prefer(
-    const execution::relationship_t::fork_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_completion_executor any_completion_executor::prefer(
-    const execution::relationship_t::continuation_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#endif // ASIO_IMPL_ANY_COMPLETION_EXECUTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_io_executor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_io_executor.ipp
deleted file mode 100644
index 338ad4d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/any_io_executor.ipp
+++ /dev/null
@@ -1,134 +0,0 @@
-//
-// impl/any_io_executor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_ANY_IO_EXECUTOR_IPP
-#define ASIO_IMPL_ANY_IO_EXECUTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#include "asio/any_io_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-any_io_executor::any_io_executor() noexcept
-  : base_type()
-{
-}
-
-any_io_executor::any_io_executor(nullptr_t) noexcept
-  : base_type(nullptr_t())
-{
-}
-
-any_io_executor::any_io_executor(const any_io_executor& e) noexcept
-  : base_type(static_cast<const base_type&>(e))
-{
-}
-
-any_io_executor::any_io_executor(std::nothrow_t,
-    const any_io_executor& e) noexcept
-  : base_type(static_cast<const base_type&>(e))
-{
-}
-
-any_io_executor::any_io_executor(any_io_executor&& e) noexcept
-  : base_type(static_cast<base_type&&>(e))
-{
-}
-
-any_io_executor::any_io_executor(std::nothrow_t, any_io_executor&& e) noexcept
-  : base_type(static_cast<base_type&&>(e))
-{
-}
-
-any_io_executor& any_io_executor::operator=(const any_io_executor& e) noexcept
-{
-  base_type::operator=(static_cast<const base_type&>(e));
-  return *this;
-}
-
-any_io_executor& any_io_executor::operator=(any_io_executor&& e) noexcept
-{
-  base_type::operator=(static_cast<base_type&&>(e));
-  return *this;
-}
-
-any_io_executor& any_io_executor::operator=(nullptr_t)
-{
-  base_type::operator=(nullptr_t());
-  return *this;
-}
-
-any_io_executor::~any_io_executor()
-{
-}
-
-void any_io_executor::swap(any_io_executor& other) noexcept
-{
-  static_cast<base_type&>(*this).swap(static_cast<base_type&>(other));
-}
-
-template <>
-any_io_executor any_io_executor::require(
-    const execution::blocking_t::never_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).require(p);
-}
-
-template <>
-any_io_executor any_io_executor::prefer(
-    const execution::blocking_t::possibly_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_io_executor any_io_executor::prefer(
-    const execution::outstanding_work_t::tracked_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_io_executor any_io_executor::prefer(
-    const execution::outstanding_work_t::untracked_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_io_executor any_io_executor::prefer(
-    const execution::relationship_t::fork_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-template <>
-any_io_executor any_io_executor::prefer(
-    const execution::relationship_t::continuation_t& p, int) const
-{
-  return static_cast<const base_type&>(*this).prefer(p);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#endif // ASIO_IMPL_ANY_IO_EXECUTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/append.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/append.hpp
deleted file mode 100644
index cea7242..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/append.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// impl/append.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_APPEND_HPP
-#define ASIO_IMPL_APPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Class to adapt an append_t as a completion handler.
-template <typename Handler, typename... Values>
-class append_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename H>
-  append_handler(H&& handler, std::tuple<Values...> values)
-    : handler_(static_cast<H&&>(handler)),
-      values_(static_cast<std::tuple<Values...>&&>(values))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    this->invoke(
-        index_sequence_for<Values...>{},
-        static_cast<Args&&>(args)...);
-  }
-
-  template <std::size_t... I, typename... Args>
-  void invoke(index_sequence<I...>, Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<Args&&>(args)...,
-        static_cast<Values&&>(std::get<I>(values_))...);
-  }
-
-//private:
-  Handler handler_;
-  std::tuple<Values...> values_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    append_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-template <typename Signature, typename... Values>
-struct append_signature;
-
-template <typename R, typename... Args, typename... Values>
-struct append_signature<R(Args...), Values...>
-{
-  typedef R type(decay_t<Args>..., Values...);
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename... Values, typename Signature>
-struct async_result<append_t<CompletionToken, Values...>, Signature>
-  : async_result<CompletionToken,
-      typename detail::append_signature<
-        Signature, Values...>::type>
-{
-  typedef typename detail::append_signature<
-      Signature, Values...>::type signature;
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::append_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::append_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<CompletionToken, signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.token_,
-        static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<CompletionToken, signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_,
-        static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename... Values, typename DefaultCandidate>
-struct associator<Associator,
-    detail::append_handler<Handler, Values...>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::append_handler<Handler, Values...>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::append_handler<Handler, Values...>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_APPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/as_tuple.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/as_tuple.hpp
deleted file mode 100644
index 0b3d664..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/as_tuple.hpp
+++ /dev/null
@@ -1,276 +0,0 @@
-//
-// impl/as_tuple.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_AS_TUPLE_HPP
-#define ASIO_IMPL_AS_TUPLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/associated_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Class to adapt a as_tuple_t as a completion handler.
-template <typename Handler>
-class as_tuple_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename CompletionToken>
-  as_tuple_handler(as_tuple_t<CompletionToken> e)
-    : handler_(static_cast<CompletionToken&&>(e.token_))
-  {
-  }
-
-  template <typename RedirectedHandler>
-  as_tuple_handler(RedirectedHandler&& h)
-    : handler_(static_cast<RedirectedHandler&&>(h))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(
-        std::make_tuple(static_cast<Args&&>(args)...));
-  }
-
-//private:
-  Handler handler_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    as_tuple_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Signature>
-struct as_tuple_signature;
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...)>
-{
-  typedef R type(std::tuple<decay_t<Args>...>);
-};
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...) &>
-{
-  typedef R type(std::tuple<decay_t<Args>...>) &;
-};
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...) &&>
-{
-  typedef R type(std::tuple<decay_t<Args>...>) &&;
-};
-
-#if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...) noexcept>
-{
-  typedef R type(std::tuple<decay_t<Args>...>) noexcept;
-};
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...) & noexcept>
-{
-  typedef R type(std::tuple<decay_t<Args>...>) & noexcept;
-};
-
-template <typename R, typename... Args>
-struct as_tuple_signature<R(Args...) && noexcept>
-{
-  typedef R type(std::tuple<decay_t<Args>...>) && noexcept;
-};
-
-#endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename... Signatures>
-struct async_result<as_tuple_t<CompletionToken>, Signatures...>
-  : async_result<CompletionToken,
-      typename detail::as_tuple_signature<Signatures>::type...>
-{
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::as_tuple_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::as_tuple_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        typename detail::as_tuple_signature<Signatures>::type...>(
-          init_wrapper<decay_t<Initiation>>(
-            static_cast<Initiation&&>(initiation)),
-          token.token_, static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      typename detail::as_tuple_signature<Signatures>::type...>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, static_cast<Args&&>(args)...);
-  }
-};
-
-#if defined(ASIO_MSVC)
-
-// Workaround for MSVC internal compiler error.
-
-template <typename CompletionToken, typename Signature>
-struct async_result<as_tuple_t<CompletionToken>, Signature>
-  : async_result<CompletionToken,
-      typename detail::as_tuple_signature<Signature>::type>
-{
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::as_tuple_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::as_tuple_handler<decay_t<Handler>>(
-            static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        typename detail::as_tuple_signature<Signature>::type>(
-          init_wrapper<decay_t<Initiation>>(
-            static_cast<Initiation&&>(initiation)),
-          token.token_, static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      typename detail::as_tuple_signature<Signature>::type>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // defined(ASIO_MSVC)
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::as_tuple_handler<Handler>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::as_tuple_handler<Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::as_tuple_handler<Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <typename... Signatures>
-struct async_result<partial_as_tuple, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&&, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        as_tuple_t<
-          default_completion_token_t<associated_executor_t<Initiation>>>{},
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        as_tuple_t<
-          default_completion_token_t<associated_executor_t<Initiation>>>{},
-        static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_AS_TUPLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/awaitable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/awaitable.hpp
deleted file mode 100644
index c5ea264..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/awaitable.hpp
+++ /dev/null
@@ -1,1196 +0,0 @@
-//
-// impl/awaitable.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_AWAITABLE_HPP
-#define ASIO_IMPL_AWAITABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-#include <new>
-#include <tuple>
-#include "asio/cancellation_signal.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/detail/thread_context.hpp"
-#include "asio/detail/thread_info_base.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/post.hpp"
-#include "asio/system_error.hpp"
-#include "asio/this_coro.hpp"
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-#  include "asio/detail/source_location.hpp"
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct awaitable_thread_has_context_switched {};
-template <typename, typename> class awaitable_async_op_handler;
-template <typename, typename, typename> class awaitable_async_op;
-
-// An awaitable_thread represents a thread-of-execution that is composed of one
-// or more "stack frames", with each frame represented by an awaitable_frame.
-// All execution occurs in the context of the awaitable_thread's executor. An
-// awaitable_thread continues to "pump" the stack frames by repeatedly resuming
-// the top stack frame until the stack is empty, or until ownership of the
-// stack is transferred to another awaitable_thread object.
-//
-//                +------------------------------------+
-//                | top_of_stack_                      |
-//                |                                    V
-// +--------------+---+                            +-----------------+
-// |                  |                            |                 |
-// | awaitable_thread |<---------------------------+ awaitable_frame |
-// |                  |           attached_thread_ |                 |
-// +--------------+---+           (Set only when   +---+-------------+
-//                |               frames are being     |
-//                |               actively pumped      | caller_
-//                |               by a thread, and     |
-//                |               then only for        V
-//                |               the top frame.)  +-----------------+
-//                |                                |                 |
-//                |                                | awaitable_frame |
-//                |                                |                 |
-//                |                                +---+-------------+
-//                |                                    |
-//                |                                    | caller_
-//                |                                    :
-//                |                                    :
-//                |                                    |
-//                |                                    V
-//                |                                +-----------------+
-//                | bottom_of_stack_               |                 |
-//                +------------------------------->| awaitable_frame |
-//                                                 |                 |
-//                                                 +-----------------+
-
-template <typename Executor>
-class awaitable_frame_base
-{
-public:
-#if !defined(ASIO_DISABLE_AWAITABLE_FRAME_RECYCLING)
-  void* operator new(std::size_t size)
-  {
-    return asio::detail::thread_info_base::allocate(
-        asio::detail::thread_info_base::awaitable_frame_tag(),
-        asio::detail::thread_context::top_of_thread_call_stack(),
-        size);
-  }
-
-  void operator delete(void* pointer, std::size_t size)
-  {
-    asio::detail::thread_info_base::deallocate(
-        asio::detail::thread_info_base::awaitable_frame_tag(),
-        asio::detail::thread_context::top_of_thread_call_stack(),
-        pointer, size);
-  }
-#endif // !defined(ASIO_DISABLE_AWAITABLE_FRAME_RECYCLING)
-
-  // The frame starts in a suspended state until the awaitable_thread object
-  // pumps the stack.
-  auto initial_suspend() noexcept
-  {
-    return suspend_always();
-  }
-
-  // On final suspension the frame is popped from the top of the stack.
-  auto final_suspend() noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return false;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-        this->this_->pop_frame();
-      }
-
-      void await_resume() const noexcept
-      {
-      }
-    };
-
-    return result{this};
-  }
-
-  void set_except(std::exception_ptr e) noexcept
-  {
-    pending_exception_ = e;
-  }
-
-  void set_error(const asio::error_code& ec)
-  {
-    this->set_except(std::make_exception_ptr(asio::system_error(ec)));
-  }
-
-  void unhandled_exception()
-  {
-    set_except(std::current_exception());
-  }
-
-  void rethrow_exception()
-  {
-    if (pending_exception_)
-    {
-      std::exception_ptr ex = std::exchange(pending_exception_, nullptr);
-      std::rethrow_exception(ex);
-    }
-  }
-
-  void clear_cancellation_slot()
-  {
-    this->attached_thread_->entry_point()->cancellation_state_.slot().clear();
-  }
-
-  template <typename T>
-  auto await_transform(awaitable<T, Executor> a) const
-  {
-    if (attached_thread_->entry_point()->throw_if_cancelled_)
-      if (!!attached_thread_->get_cancellation_state().cancelled())
-        throw_error(asio::error::operation_aborted, "co_await");
-    return a;
-  }
-
-  template <typename Op>
-  auto await_transform(Op&& op,
-      constraint_t<is_async_operation<Op>::value> = 0
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      , detail::source_location location = detail::source_location::current()
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    )
-  {
-    if (attached_thread_->entry_point()->throw_if_cancelled_)
-      if (!!attached_thread_->get_cancellation_state().cancelled())
-        throw_error(asio::error::operation_aborted, "co_await");
-
-    return awaitable_async_op<
-      completion_signature_of_t<Op>, decay_t<Op>, Executor>{
-        std::forward<Op>(op), this
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-        , location
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-      };
-  }
-
-  // This await transformation obtains the associated executor of the thread of
-  // execution.
-  auto await_transform(this_coro::executor_t) noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume() const noexcept
-      {
-        return this_->attached_thread_->get_executor();
-      }
-    };
-
-    return result{this};
-  }
-
-  // This await transformation obtains the associated cancellation state of the
-  // thread of execution.
-  auto await_transform(this_coro::cancellation_state_t) noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume() const noexcept
-      {
-        return this_->attached_thread_->get_cancellation_state();
-      }
-    };
-
-    return result{this};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  auto await_transform(this_coro::reset_cancellation_state_0_t) noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume() const
-      {
-        return this_->attached_thread_->reset_cancellation_state();
-      }
-    };
-
-    return result{this};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  template <typename Filter>
-  auto await_transform(
-      this_coro::reset_cancellation_state_1_t<Filter> reset) noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-      Filter filter_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return this_->attached_thread_->reset_cancellation_state(
-            static_cast<Filter&&>(filter_));
-      }
-    };
-
-    return result{this, static_cast<Filter&&>(reset.filter)};
-  }
-
-  // This await transformation resets the associated cancellation state.
-  template <typename InFilter, typename OutFilter>
-  auto await_transform(
-      this_coro::reset_cancellation_state_2_t<InFilter, OutFilter> reset)
-    noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-      InFilter in_filter_;
-      OutFilter out_filter_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return this_->attached_thread_->reset_cancellation_state(
-            static_cast<InFilter&&>(in_filter_),
-            static_cast<OutFilter&&>(out_filter_));
-      }
-    };
-
-    return result{this,
-        static_cast<InFilter&&>(reset.in_filter),
-        static_cast<OutFilter&&>(reset.out_filter)};
-  }
-
-  // This await transformation determines whether cancellation is propagated as
-  // an exception.
-  auto await_transform(this_coro::throw_if_cancelled_0_t)
-    noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        return this_->attached_thread_->throw_if_cancelled();
-      }
-    };
-
-    return result{this};
-  }
-
-  // This await transformation sets whether cancellation is propagated as an
-  // exception.
-  auto await_transform(this_coro::throw_if_cancelled_1_t throw_if_cancelled)
-    noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-      bool value_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        this_->attached_thread_->throw_if_cancelled(value_);
-      }
-    };
-
-    return result{this, throw_if_cancelled.value};
-  }
-
-  // This await transformation is used to run an async operation's initiation
-  // function object after the coroutine has been suspended. This ensures that
-  // immediate resumption of the coroutine in another thread does not cause a
-  // race condition.
-  template <typename Function>
-  auto await_transform(Function f,
-      enable_if_t<
-        is_convertible<
-          result_of_t<Function(awaitable_frame_base*)>,
-          awaitable_thread<Executor>*
-        >::value
-      >* = nullptr)
-  {
-    struct result
-    {
-      Function function_;
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return false;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-        this_->after_suspend(
-            [](void* arg)
-            {
-              result* r = static_cast<result*>(arg);
-              r->function_(r->this_);
-            }, this);
-      }
-
-      void await_resume() const noexcept
-      {
-      }
-    };
-
-    return result{std::move(f), this};
-  }
-
-  // Access the awaitable thread's has_context_switched_ flag.
-  auto await_transform(detail::awaitable_thread_has_context_switched) noexcept
-  {
-    struct result
-    {
-      awaitable_frame_base* this_;
-
-      bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(coroutine_handle<void>) noexcept
-      {
-      }
-
-      bool& await_resume() const noexcept
-      {
-        return this_->attached_thread_->entry_point()->has_context_switched_;
-      }
-    };
-
-    return result{this};
-  }
-
-  void attach_thread(awaitable_thread<Executor>* handler) noexcept
-  {
-    attached_thread_ = handler;
-  }
-
-  awaitable_thread<Executor>* detach_thread() noexcept
-  {
-    attached_thread_->entry_point()->has_context_switched_ = true;
-    return std::exchange(attached_thread_, nullptr);
-  }
-
-  void push_frame(awaitable_frame_base<Executor>* caller) noexcept
-  {
-    caller_ = caller;
-    attached_thread_ = caller_->attached_thread_;
-    attached_thread_->entry_point()->top_of_stack_ = this;
-    caller_->attached_thread_ = nullptr;
-  }
-
-  void pop_frame() noexcept
-  {
-    if (caller_)
-      caller_->attached_thread_ = attached_thread_;
-    attached_thread_->entry_point()->top_of_stack_ = caller_;
-    attached_thread_ = nullptr;
-    caller_ = nullptr;
-  }
-
-  struct resume_context
-  {
-    void (*after_suspend_fn_)(void*) = nullptr;
-    void *after_suspend_arg_ = nullptr;
-  };
-
-  void resume()
-  {
-    resume_context context;
-    resume_context_ = &context;
-    coro_.resume();
-    if (context.after_suspend_fn_)
-      context.after_suspend_fn_(context.after_suspend_arg_);
-  }
-
-  void after_suspend(void (*fn)(void*), void* arg)
-  {
-    resume_context_->after_suspend_fn_ = fn;
-    resume_context_->after_suspend_arg_ = arg;
-  }
-
-  void destroy()
-  {
-    coro_.destroy();
-  }
-
-protected:
-  coroutine_handle<void> coro_ = nullptr;
-  awaitable_thread<Executor>* attached_thread_ = nullptr;
-  awaitable_frame_base<Executor>* caller_ = nullptr;
-  std::exception_ptr pending_exception_ = nullptr;
-  resume_context* resume_context_ = nullptr;
-};
-
-template <typename T, typename Executor>
-class awaitable_frame
-  : public awaitable_frame_base<Executor>
-{
-public:
-  awaitable_frame() noexcept
-  {
-  }
-
-  awaitable_frame(awaitable_frame&& other) noexcept
-    : awaitable_frame_base<Executor>(std::move(other))
-  {
-  }
-
-  ~awaitable_frame()
-  {
-    if (has_result_)
-      std::launder(static_cast<T*>(static_cast<void*>(result_)))->~T();
-  }
-
-  awaitable<T, Executor> get_return_object() noexcept
-  {
-    this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
-    return awaitable<T, Executor>(this);
-  };
-
-  template <typename U>
-  void return_value(U&& u)
-  {
-    new (&result_) T(std::forward<U>(u));
-    has_result_ = true;
-  }
-
-  template <typename... Us>
-  void return_values(Us&&... us)
-  {
-    this->return_value(std::forward_as_tuple(std::forward<Us>(us)...));
-  }
-
-  T get()
-  {
-    this->caller_ = nullptr;
-    this->rethrow_exception();
-    return std::move(*std::launder(
-          static_cast<T*>(static_cast<void*>(result_))));
-  }
-
-private:
-  alignas(T) unsigned char result_[sizeof(T)];
-  bool has_result_ = false;
-};
-
-template <typename Executor>
-class awaitable_frame<void, Executor>
-  : public awaitable_frame_base<Executor>
-{
-public:
-  awaitable<void, Executor> get_return_object()
-  {
-    this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
-    return awaitable<void, Executor>(this);
-  };
-
-  void return_void()
-  {
-  }
-
-  void get()
-  {
-    this->caller_ = nullptr;
-    this->rethrow_exception();
-  }
-};
-
-struct awaitable_thread_entry_point {};
-
-template <typename Executor>
-class awaitable_frame<awaitable_thread_entry_point, Executor>
-  : public awaitable_frame_base<Executor>
-{
-public:
-  awaitable_frame()
-    : top_of_stack_(0),
-      has_executor_(false),
-      has_context_switched_(false),
-      throw_if_cancelled_(true)
-  {
-  }
-
-  ~awaitable_frame()
-  {
-    if (has_executor_)
-      u_.executor_.~Executor();
-  }
-
-  awaitable<awaitable_thread_entry_point, Executor> get_return_object()
-  {
-    this->coro_ = coroutine_handle<awaitable_frame>::from_promise(*this);
-    return awaitable<awaitable_thread_entry_point, Executor>(this);
-  };
-
-  void return_void()
-  {
-  }
-
-  void get()
-  {
-    this->caller_ = nullptr;
-    this->rethrow_exception();
-  }
-
-private:
-  template <typename> friend class awaitable_frame_base;
-  template <typename, typename> friend class awaitable_async_op_handler;
-  template <typename, typename> friend class awaitable_handler_base;
-  template <typename> friend class awaitable_thread;
-
-  union u
-  {
-    u() {}
-    ~u() {}
-    char c_;
-    Executor executor_;
-  } u_;
-
-  awaitable_frame_base<Executor>* top_of_stack_;
-  asio::cancellation_slot parent_cancellation_slot_;
-  asio::cancellation_state cancellation_state_;
-  bool has_executor_;
-  bool has_context_switched_;
-  bool throw_if_cancelled_;
-};
-
-template <typename Executor>
-class awaitable_thread
-{
-public:
-  typedef Executor executor_type;
-  typedef cancellation_slot cancellation_slot_type;
-
-  // Construct from the entry point of a new thread of execution.
-  awaitable_thread(awaitable<awaitable_thread_entry_point, Executor> p,
-      const Executor& ex, cancellation_slot parent_cancel_slot,
-      cancellation_state cancel_state)
-    : bottom_of_stack_(std::move(p))
-  {
-    bottom_of_stack_.frame_->top_of_stack_ = bottom_of_stack_.frame_;
-    new (&bottom_of_stack_.frame_->u_.executor_) Executor(ex);
-    bottom_of_stack_.frame_->has_executor_ = true;
-    bottom_of_stack_.frame_->parent_cancellation_slot_ = parent_cancel_slot;
-    bottom_of_stack_.frame_->cancellation_state_ = cancel_state;
-  }
-
-  // Transfer ownership from another awaitable_thread.
-  awaitable_thread(awaitable_thread&& other) noexcept
-    : bottom_of_stack_(std::move(other.bottom_of_stack_))
-  {
-  }
-
-  // Clean up with a last ditch effort to ensure the thread is unwound within
-  // the context of the executor.
-  ~awaitable_thread()
-  {
-    if (bottom_of_stack_.valid())
-    {
-      // Coroutine "stack unwinding" must be performed through the executor.
-      auto* bottom_frame = bottom_of_stack_.frame_;
-      (post)(bottom_frame->u_.executor_,
-          [a = std::move(bottom_of_stack_)]() mutable
-          {
-            (void)awaitable<awaitable_thread_entry_point, Executor>(
-                std::move(a));
-          });
-    }
-  }
-
-  awaitable_frame<awaitable_thread_entry_point, Executor>* entry_point()
-  {
-    return bottom_of_stack_.frame_;
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return bottom_of_stack_.frame_->u_.executor_;
-  }
-
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return bottom_of_stack_.frame_->cancellation_state_;
-  }
-
-  void reset_cancellation_state()
-  {
-    bottom_of_stack_.frame_->cancellation_state_ =
-      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_);
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter&& filter)
-  {
-    bottom_of_stack_.frame_->cancellation_state_ =
-      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_,
-        static_cast<Filter&&>(filter));
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter,
-      OutFilter&& out_filter)
-  {
-    bottom_of_stack_.frame_->cancellation_state_ =
-      cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_,
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  bool throw_if_cancelled() const
-  {
-    return bottom_of_stack_.frame_->throw_if_cancelled_;
-  }
-
-  void throw_if_cancelled(bool value)
-  {
-    bottom_of_stack_.frame_->throw_if_cancelled_ = value;
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return bottom_of_stack_.frame_->cancellation_state_.slot();
-  }
-
-  // Launch a new thread of execution.
-  void launch()
-  {
-    bottom_of_stack_.frame_->top_of_stack_->attach_thread(this);
-    pump();
-  }
-
-protected:
-  template <typename> friend class awaitable_frame_base;
-
-  // Repeatedly resume the top stack frame until the stack is empty or until it
-  // has been transferred to another resumable_thread object.
-  void pump()
-  {
-    do
-      bottom_of_stack_.frame_->top_of_stack_->resume();
-    while (bottom_of_stack_.frame_ && bottom_of_stack_.frame_->top_of_stack_);
-
-    if (bottom_of_stack_.frame_)
-    {
-      awaitable<awaitable_thread_entry_point, Executor> a(
-          std::move(bottom_of_stack_));
-      a.frame_->rethrow_exception();
-    }
-  }
-
-  awaitable<awaitable_thread_entry_point, Executor> bottom_of_stack_;
-};
-
-template <typename Signature, typename Executor>
-class awaitable_async_op_handler;
-
-template <typename R, typename Executor>
-class awaitable_async_op_handler<R(), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  struct result_type {};
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type&)
-    : awaitable_thread<Executor>(std::move(*h))
-  {
-  }
-
-  void operator()()
-  {
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static void resume(result_type&)
-  {
-  }
-};
-
-template <typename R, typename Executor>
-class awaitable_async_op_handler<R(asio::error_code), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef asio::error_code* result_type;
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  void operator()(asio::error_code ec)
-  {
-    result_ = &ec;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static void resume(result_type& result)
-  {
-    throw_error(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename Executor>
-class awaitable_async_op_handler<R(std::exception_ptr), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef std::exception_ptr* result_type;
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  void operator()(std::exception_ptr ex)
-  {
-    result_ = &ex;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static void resume(result_type& result)
-  {
-    if (*result)
-    {
-      std::exception_ptr ex = std::exchange(*result, nullptr);
-      std::rethrow_exception(ex);
-    }
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename T, typename Executor>
-class awaitable_async_op_handler<R(T), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef T* result_type;
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  void operator()(T result)
-  {
-    result_ = &result;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static T resume(result_type& result)
-  {
-    return std::move(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename T, typename Executor>
-class awaitable_async_op_handler<R(asio::error_code, T), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  struct result_type
-  {
-    asio::error_code* ec_;
-    T* value_;
-  };
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  void operator()(asio::error_code ec, T value)
-  {
-    result_.ec_ = &ec;
-    result_.value_ = &value;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static T resume(result_type& result)
-  {
-    throw_error(*result.ec_);
-    return std::move(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename T, typename Executor>
-class awaitable_async_op_handler<R(std::exception_ptr, T), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  struct result_type
-  {
-    std::exception_ptr* ex_;
-    T* value_;
-  };
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  void operator()(std::exception_ptr ex, T value)
-  {
-    result_.ex_ = &ex;
-    result_.value_ = &value;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static T resume(result_type& result)
-  {
-    if (*result.ex_)
-    {
-      std::exception_ptr ex = std::exchange(*result.ex_, nullptr);
-      std::rethrow_exception(ex);
-    }
-    return std::move(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename... Ts, typename Executor>
-class awaitable_async_op_handler<R(Ts...), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef std::tuple<Ts...>* result_type;
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    std::tuple<Ts...> result(std::forward<Args>(args)...);
-    result_ = &result;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static std::tuple<Ts...> resume(result_type& result)
-  {
-    return std::move(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename... Ts, typename Executor>
-class awaitable_async_op_handler<R(asio::error_code, Ts...), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  struct result_type
-  {
-    asio::error_code* ec_;
-    std::tuple<Ts...>* value_;
-  };
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(asio::error_code ec, Args&&... args)
-  {
-    result_.ec_ = &ec;
-    std::tuple<Ts...> value(std::forward<Args>(args)...);
-    result_.value_ = &value;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static std::tuple<Ts...> resume(result_type& result)
-  {
-    throw_error(*result.ec_);
-    return std::move(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename R, typename... Ts, typename Executor>
-class awaitable_async_op_handler<R(std::exception_ptr, Ts...), Executor>
-  : public awaitable_thread<Executor>
-{
-public:
-  struct result_type
-  {
-    std::exception_ptr* ex_;
-    std::tuple<Ts...>* value_;
-  };
-
-  awaitable_async_op_handler(
-      awaitable_thread<Executor>* h, result_type& result)
-    : awaitable_thread<Executor>(std::move(*h)),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(std::exception_ptr ex, Args&&... args)
-  {
-    result_.ex_ = &ex;
-    std::tuple<Ts...> value(std::forward<Args>(args)...);
-    result_.value_ = &value;
-    this->entry_point()->top_of_stack_->attach_thread(this);
-    this->entry_point()->top_of_stack_->clear_cancellation_slot();
-    this->pump();
-  }
-
-  static std::tuple<Ts...> resume(result_type& result)
-  {
-    if (*result.ex_)
-    {
-      std::exception_ptr ex = std::exchange(*result.ex_, nullptr);
-      std::rethrow_exception(ex);
-    }
-    return std::move(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Signature, typename Op, typename Executor>
-class awaitable_async_op
-{
-public:
-  typedef awaitable_async_op_handler<Signature, Executor> handler_type;
-
-  awaitable_async_op(Op&& o, awaitable_frame_base<Executor>* frame
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      , const detail::source_location& location
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    )
-    : op_(std::forward<Op>(o)),
-      frame_(frame),
-      result_()
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-    , location_(location)
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-  {
-  }
-
-  bool await_ready() const noexcept
-  {
-    return false;
-  }
-
-  void await_suspend(coroutine_handle<void>)
-  {
-    frame_->after_suspend(
-        [](void* arg)
-        {
-          awaitable_async_op* self = static_cast<awaitable_async_op*>(arg);
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-          ASIO_HANDLER_LOCATION((self->location_.file_name(),
-              self->location_.line(), self->location_.function_name()));
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-          std::forward<Op&&>(self->op_)(
-              handler_type(self->frame_->detach_thread(), self->result_));
-        }, this);
-  }
-
-  auto await_resume()
-  {
-    return handler_type::resume(result_);
-  }
-
-private:
-  Op&& op_;
-  awaitable_frame_base<Executor>* frame_;
-  typename handler_type::result_type result_;
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-  detail::source_location location_;
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-};
-
-} // namespace detail
-} // namespace asio
-
-#if !defined(GENERATING_DOCUMENTATION)
-# if defined(ASIO_HAS_STD_COROUTINE)
-
-namespace std {
-
-template <typename T, typename Executor, typename... Args>
-struct coroutine_traits<asio::awaitable<T, Executor>, Args...>
-{
-  typedef asio::detail::awaitable_frame<T, Executor> promise_type;
-};
-
-} // namespace std
-
-# else // defined(ASIO_HAS_STD_COROUTINE)
-
-namespace std { namespace experimental {
-
-template <typename T, typename Executor, typename... Args>
-struct coroutine_traits<asio::awaitable<T, Executor>, Args...>
-{
-  typedef asio::detail::awaitable_frame<T, Executor> promise_type;
-};
-
-}} // namespace std::experimental
-
-# endif // defined(ASIO_HAS_STD_COROUTINE)
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_AWAITABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_read_stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_read_stream.hpp
deleted file mode 100644
index 9a1d78b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_read_stream.hpp
+++ /dev/null
@@ -1,404 +0,0 @@
-//
-// impl/buffered_read_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_BUFFERED_READ_STREAM_HPP
-#define ASIO_IMPL_BUFFERED_READ_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/associator.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Stream>
-std::size_t buffered_read_stream<Stream>::fill()
-{
-  detail::buffer_resize_guard<detail::buffered_stream_storage>
-    resize_guard(storage_);
-  std::size_t previous_size = storage_.size();
-  storage_.resize(storage_.capacity());
-  storage_.resize(previous_size + next_layer_.read_some(buffer(
-          storage_.data() + previous_size,
-          storage_.size() - previous_size)));
-  resize_guard.commit();
-  return storage_.size() - previous_size;
-}
-
-template <typename Stream>
-std::size_t buffered_read_stream<Stream>::fill(asio::error_code& ec)
-{
-  detail::buffer_resize_guard<detail::buffered_stream_storage>
-    resize_guard(storage_);
-  std::size_t previous_size = storage_.size();
-  storage_.resize(storage_.capacity());
-  storage_.resize(previous_size + next_layer_.read_some(buffer(
-          storage_.data() + previous_size,
-          storage_.size() - previous_size),
-        ec));
-  resize_guard.commit();
-  return storage_.size() - previous_size;
-}
-
-namespace detail
-{
-  template <typename ReadHandler>
-  class buffered_fill_handler
-  {
-  public:
-    buffered_fill_handler(detail::buffered_stream_storage& storage,
-        std::size_t previous_size, ReadHandler& handler)
-      : storage_(storage),
-        previous_size_(previous_size),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    buffered_fill_handler(const buffered_fill_handler& other)
-      : storage_(other.storage_),
-        previous_size_(other.previous_size_),
-        handler_(other.handler_)
-    {
-    }
-
-    buffered_fill_handler(buffered_fill_handler&& other)
-      : storage_(other.storage_),
-        previous_size_(other.previous_size_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        const std::size_t bytes_transferred)
-    {
-      storage_.resize(previous_size_ + bytes_transferred);
-      static_cast<ReadHandler&&>(handler_)(ec, bytes_transferred);
-    }
-
-  //private:
-    detail::buffered_stream_storage& storage_;
-    std::size_t previous_size_;
-    ReadHandler handler_;
-  };
-
-  template <typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      buffered_fill_handler<ReadHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename Stream>
-  class initiate_async_buffered_fill
-  {
-  public:
-    typedef typename remove_reference_t<
-      Stream>::lowest_layer_type::executor_type executor_type;
-
-    explicit initiate_async_buffered_fill(
-        remove_reference_t<Stream>& next_layer)
-      : next_layer_(next_layer)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return next_layer_.lowest_layer().get_executor();
-    }
-
-    template <typename ReadHandler>
-    void operator()(ReadHandler&& handler,
-        buffered_stream_storage* storage) 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);
-      std::size_t previous_size = storage->size();
-      storage->resize(storage->capacity());
-      next_layer_.async_read_some(
-          buffer(
-            storage->data() + previous_size,
-            storage->size() - previous_size),
-          buffered_fill_handler<decay_t<ReadHandler>>(
-            *storage, previous_size, handler2.value));
-    }
-
-  private:
-    remove_reference_t<Stream>& next_layer_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::buffered_fill_handler<ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::buffered_fill_handler<ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::buffered_fill_handler<ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-template <typename Stream>
-template <
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline auto buffered_read_stream<Stream>::async_fill(ReadHandler&& handler)
-  -> decltype(
-    async_initiate<ReadHandler,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_buffered_fill<Stream>>(),
-        handler, declval<detail::buffered_stream_storage*>()))
-{
-  return async_initiate<ReadHandler,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_buffered_fill<Stream>(next_layer_),
-      handler, &storage_);
-}
-
-template <typename Stream>
-template <typename MutableBufferSequence>
-std::size_t buffered_read_stream<Stream>::read_some(
-    const MutableBufferSequence& buffers)
-{
-  using asio::buffer_size;
-  if (buffer_size(buffers) == 0)
-    return 0;
-
-  if (storage_.empty())
-    this->fill();
-
-  return this->copy(buffers);
-}
-
-template <typename Stream>
-template <typename MutableBufferSequence>
-std::size_t buffered_read_stream<Stream>::read_some(
-    const MutableBufferSequence& buffers, asio::error_code& ec)
-{
-  ec = asio::error_code();
-
-  using asio::buffer_size;
-  if (buffer_size(buffers) == 0)
-    return 0;
-
-  if (storage_.empty() && !this->fill(ec))
-    return 0;
-
-  return this->copy(buffers);
-}
-
-namespace detail
-{
-  template <typename MutableBufferSequence, typename ReadHandler>
-  class buffered_read_some_handler
-  {
-  public:
-    buffered_read_some_handler(detail::buffered_stream_storage& storage,
-        const MutableBufferSequence& buffers, ReadHandler& handler)
-      : storage_(storage),
-        buffers_(buffers),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    buffered_read_some_handler(const buffered_read_some_handler& other)
-      : storage_(other.storage_),
-        buffers_(other.buffers_),
-        handler_(other.handler_)
-    {
-    }
-
-    buffered_read_some_handler(buffered_read_some_handler&& other)
-      : storage_(other.storage_),
-        buffers_(other.buffers_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec, std::size_t)
-    {
-      if (ec || storage_.empty())
-      {
-        const std::size_t length = 0;
-        static_cast<ReadHandler&&>(handler_)(ec, length);
-      }
-      else
-      {
-        const std::size_t bytes_copied = asio::buffer_copy(
-            buffers_, storage_.data(), storage_.size());
-        storage_.consume(bytes_copied);
-        static_cast<ReadHandler&&>(handler_)(ec, bytes_copied);
-      }
-    }
-
-  //private:
-    detail::buffered_stream_storage& storage_;
-    MutableBufferSequence buffers_;
-    ReadHandler handler_;
-  };
-
-  template <typename MutableBufferSequence, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      buffered_read_some_handler<
-        MutableBufferSequence, ReadHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename Stream>
-  class initiate_async_buffered_read_some
-  {
-  public:
-    typedef typename remove_reference_t<
-      Stream>::lowest_layer_type::executor_type executor_type;
-
-    explicit initiate_async_buffered_read_some(
-        remove_reference_t<Stream>& next_layer)
-      : next_layer_(next_layer)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return next_layer_.lowest_layer().get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        buffered_stream_storage* storage,
-        const MutableBufferSequence& buffers) 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;
-
-      using asio::buffer_size;
-      non_const_lvalue<ReadHandler> handler2(handler);
-      if (buffer_size(buffers) == 0 || !storage->empty())
-      {
-        next_layer_.async_read_some(ASIO_MUTABLE_BUFFER(0, 0),
-            buffered_read_some_handler<MutableBufferSequence,
-              decay_t<ReadHandler>>(
-                *storage, buffers, handler2.value));
-      }
-      else
-      {
-        initiate_async_buffered_fill<Stream>(this->next_layer_)(
-            buffered_read_some_handler<MutableBufferSequence,
-              decay_t<ReadHandler>>(
-                *storage, buffers, handler2.value),
-            storage);
-      }
-    }
-
-  private:
-    remove_reference_t<Stream>& next_layer_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename MutableBufferSequence, typename ReadHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::buffered_read_some_handler<
-        MutableBufferSequence, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::buffered_read_some_handler<
-        MutableBufferSequence, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-template <typename Stream>
-template <typename MutableBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadHandler>
-inline auto buffered_read_stream<Stream>::async_read_some(
-    const MutableBufferSequence& buffers, ReadHandler&& handler)
-  -> decltype(
-    async_initiate<ReadHandler,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_buffered_read_some<Stream>>(),
-        handler, declval<detail::buffered_stream_storage*>(), buffers))
-{
-  return async_initiate<ReadHandler,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_buffered_read_some<Stream>(next_layer_),
-      handler, &storage_, buffers);
-}
-
-template <typename Stream>
-template <typename MutableBufferSequence>
-std::size_t buffered_read_stream<Stream>::peek(
-    const MutableBufferSequence& buffers)
-{
-  if (storage_.empty())
-    this->fill();
-  return this->peek_copy(buffers);
-}
-
-template <typename Stream>
-template <typename MutableBufferSequence>
-std::size_t buffered_read_stream<Stream>::peek(
-    const MutableBufferSequence& buffers, asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (storage_.empty() && !this->fill(ec))
-    return 0;
-  return this->peek_copy(buffers);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_BUFFERED_READ_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_write_stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_write_stream.hpp
deleted file mode 100644
index 5bf5827..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/buffered_write_stream.hpp
+++ /dev/null
@@ -1,384 +0,0 @@
-//
-// impl/buffered_write_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
-#define ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/associator.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Stream>
-std::size_t buffered_write_stream<Stream>::flush()
-{
-  std::size_t bytes_written = write(next_layer_,
-      buffer(storage_.data(), storage_.size()));
-  storage_.consume(bytes_written);
-  return bytes_written;
-}
-
-template <typename Stream>
-std::size_t buffered_write_stream<Stream>::flush(asio::error_code& ec)
-{
-  std::size_t bytes_written = write(next_layer_,
-      buffer(storage_.data(), storage_.size()),
-      transfer_all(), ec);
-  storage_.consume(bytes_written);
-  return bytes_written;
-}
-
-namespace detail
-{
-  template <typename WriteHandler>
-  class buffered_flush_handler
-  {
-  public:
-    buffered_flush_handler(detail::buffered_stream_storage& storage,
-        WriteHandler& handler)
-      : storage_(storage),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    buffered_flush_handler(const buffered_flush_handler& other)
-      : storage_(other.storage_),
-        handler_(other.handler_)
-    {
-    }
-
-    buffered_flush_handler(buffered_flush_handler&& other)
-      : storage_(other.storage_),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        const std::size_t bytes_written)
-    {
-      storage_.consume(bytes_written);
-      static_cast<WriteHandler&&>(handler_)(ec, bytes_written);
-    }
-
-  //private:
-    detail::buffered_stream_storage& storage_;
-    WriteHandler handler_;
-  };
-
-  template <typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      buffered_flush_handler<WriteHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename Stream>
-  class initiate_async_buffered_flush
-  {
-  public:
-    typedef typename remove_reference_t<
-      Stream>::lowest_layer_type::executor_type executor_type;
-
-    explicit initiate_async_buffered_flush(
-        remove_reference_t<Stream>& next_layer)
-      : next_layer_(next_layer)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return next_layer_.lowest_layer().get_executor();
-    }
-
-    template <typename WriteHandler>
-    void operator()(WriteHandler&& handler,
-        buffered_stream_storage* storage) 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);
-      async_write(next_layer_, buffer(storage->data(), storage->size()),
-          buffered_flush_handler<decay_t<WriteHandler>>(
-            *storage, handler2.value));
-    }
-
-  private:
-    remove_reference_t<Stream>& next_layer_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename WriteHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::buffered_flush_handler<WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::buffered_flush_handler<WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::buffered_flush_handler<WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-template <typename Stream>
-template <
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteHandler>
-inline auto buffered_write_stream<Stream>::async_flush(WriteHandler&& handler)
-  -> decltype(
-    async_initiate<WriteHandler,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_buffered_flush<Stream>>(),
-        handler, declval<detail::buffered_stream_storage*>()))
-{
-  return async_initiate<WriteHandler,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_buffered_flush<Stream>(next_layer_),
-      handler, &storage_);
-}
-
-template <typename Stream>
-template <typename ConstBufferSequence>
-std::size_t buffered_write_stream<Stream>::write_some(
-    const ConstBufferSequence& buffers)
-{
-  using asio::buffer_size;
-  if (buffer_size(buffers) == 0)
-    return 0;
-
-  if (storage_.size() == storage_.capacity())
-    this->flush();
-
-  return this->copy(buffers);
-}
-
-template <typename Stream>
-template <typename ConstBufferSequence>
-std::size_t buffered_write_stream<Stream>::write_some(
-    const ConstBufferSequence& buffers, asio::error_code& ec)
-{
-  ec = asio::error_code();
-
-  using asio::buffer_size;
-  if (buffer_size(buffers) == 0)
-    return 0;
-
-  if (storage_.size() == storage_.capacity() && !flush(ec))
-    return 0;
-
-  return this->copy(buffers);
-}
-
-namespace detail
-{
-  template <typename ConstBufferSequence, typename WriteHandler>
-  class buffered_write_some_handler
-  {
-  public:
-    buffered_write_some_handler(detail::buffered_stream_storage& storage,
-        const ConstBufferSequence& buffers, WriteHandler& handler)
-      : storage_(storage),
-        buffers_(buffers),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    buffered_write_some_handler(const buffered_write_some_handler& other)
-      : storage_(other.storage_),
-        buffers_(other.buffers_),
-        handler_(other.handler_)
-    {
-    }
-
-    buffered_write_some_handler(buffered_write_some_handler&& other)
-      : storage_(other.storage_),
-        buffers_(other.buffers_),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec, std::size_t)
-    {
-      if (ec)
-      {
-        const std::size_t length = 0;
-        static_cast<WriteHandler&&>(handler_)(ec, length);
-      }
-      else
-      {
-        using asio::buffer_size;
-        std::size_t orig_size = storage_.size();
-        std::size_t space_avail = storage_.capacity() - orig_size;
-        std::size_t bytes_avail = buffer_size(buffers_);
-        std::size_t length = bytes_avail < space_avail
-          ? bytes_avail : space_avail;
-        storage_.resize(orig_size + length);
-        const std::size_t bytes_copied = asio::buffer_copy(
-            storage_.data() + orig_size, buffers_, length);
-        static_cast<WriteHandler&&>(handler_)(ec, bytes_copied);
-      }
-    }
-
-  //private:
-    detail::buffered_stream_storage& storage_;
-    ConstBufferSequence buffers_;
-    WriteHandler handler_;
-  };
-
-  template <typename ConstBufferSequence, typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      buffered_write_some_handler<
-        ConstBufferSequence, WriteHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename Stream>
-  class initiate_async_buffered_write_some
-  {
-  public:
-    typedef typename remove_reference_t<
-      Stream>::lowest_layer_type::executor_type executor_type;
-
-    explicit initiate_async_buffered_write_some(
-        remove_reference_t<Stream>& next_layer)
-      : next_layer_(next_layer)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return next_layer_.lowest_layer().get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        buffered_stream_storage* storage,
-        const ConstBufferSequence& buffers) 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;
-
-      using asio::buffer_size;
-      non_const_lvalue<WriteHandler> handler2(handler);
-      if (buffer_size(buffers) == 0 || storage->size() < storage->capacity())
-      {
-        next_layer_.async_write_some(ASIO_CONST_BUFFER(0, 0),
-            buffered_write_some_handler<ConstBufferSequence,
-              decay_t<WriteHandler>>(
-                *storage, buffers, handler2.value));
-      }
-      else
-      {
-        initiate_async_buffered_flush<Stream>(this->next_layer_)(
-            buffered_write_some_handler<ConstBufferSequence,
-              decay_t<WriteHandler>>(
-                *storage, buffers, handler2.value),
-            storage);
-      }
-    }
-
-  private:
-    remove_reference_t<Stream>& next_layer_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename ConstBufferSequence, typename WriteHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::buffered_write_some_handler<
-        ConstBufferSequence, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::buffered_write_some_handler<
-        ConstBufferSequence, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-template <typename Stream>
-template <typename ConstBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteHandler>
-inline auto buffered_write_stream<Stream>::async_write_some(
-    const ConstBufferSequence& buffers, WriteHandler&& handler)
-  -> decltype(
-    async_initiate<WriteHandler,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_buffered_write_some<Stream>>(),
-        handler, declval<detail::buffered_stream_storage*>(), buffers))
-{
-  return async_initiate<WriteHandler,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_buffered_write_some<Stream>(next_layer_),
-      handler, &storage_, buffers);
-}
-
-template <typename Stream>
-template <typename ConstBufferSequence>
-std::size_t buffered_write_stream<Stream>::copy(
-    const ConstBufferSequence& buffers)
-{
-  using asio::buffer_size;
-  std::size_t orig_size = storage_.size();
-  std::size_t space_avail = storage_.capacity() - orig_size;
-  std::size_t bytes_avail = buffer_size(buffers);
-  std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
-  storage_.resize(orig_size + length);
-  return asio::buffer_copy(
-      storage_.data() + orig_size, buffers, length);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_BUFFERED_WRITE_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_after.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_after.hpp
deleted file mode 100644
index 9374376..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_after.hpp
+++ /dev/null
@@ -1,268 +0,0 @@
-//
-// impl/cancel_after.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CANCEL_AFTER_HPP
-#define ASIO_IMPL_CANCEL_AFTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/timed_cancel_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Initiation, typename Clock,
-    typename WaitTraits, typename... Signatures>
-struct initiate_cancel_after : initiation_base<Initiation>
-{
-  using initiation_base<Initiation>::initiation_base;
-
-  template <typename Handler, typename Rep, typename Period, typename... Args>
-  void operator()(Handler&& handler,
-      const chrono::duration<Rep, Period>& timeout,
-      cancellation_type_t cancel_type, Args&&... args) &&
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value,
-        basic_waitable_timer<Clock, WaitTraits,
-          typename Initiation::executor_type>(this->get_executor(), timeout),
-        cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename Rep, typename Period, typename... Args>
-  void operator()(Handler&& handler,
-      const chrono::duration<Rep, Period>& timeout,
-      cancellation_type_t cancel_type, Args&&... args) const &
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value,
-        basic_waitable_timer<Clock, WaitTraits,
-          typename Initiation::executor_type>(this->get_executor(), timeout),
-        cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<const Initiation&>(*this),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Initiation, typename Clock,
-    typename WaitTraits, typename Executor, typename... Signatures>
-struct initiate_cancel_after_timer : initiation_base<Initiation>
-{
-  using initiation_base<Initiation>::initiation_base;
-
-  template <typename Handler, typename Rep, typename Period, typename... Args>
-  void operator()(Handler&& handler,
-      basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
-      const chrono::duration<Rep, Period>& timeout,
-      cancellation_type_t cancel_type, Args&&... args) &&
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    timer->expires_after(timeout);
-    p.p = new (p.v) op(handler2.value, *timer, cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename Rep, typename Period, typename... Args>
-  void operator()(Handler&& handler,
-      basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
-      const chrono::duration<Rep, Period>& timeout,
-      cancellation_type_t cancel_type, Args&&... args) const &
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    timer->expires_after(timeout);
-    p.p = new (p.v) op(handler2.value, *timer, cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<const Initiation&>(*this),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename... Signatures>
-struct async_result<
-    cancel_after_t<CompletionToken, Clock, WaitTraits>, Signatures...>
-  : async_result<CompletionToken, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        Signatures...>(
-          declval<detail::initiate_cancel_after<
-            decay_t<Initiation>, Clock, WaitTraits, Signatures...>>(),
-          token.token_, token.timeout_, token.cancel_type_,
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      Signatures...>(
-        detail::initiate_cancel_after<
-          decay_t<Initiation>, Clock, WaitTraits, Signatures...>(
-            static_cast<Initiation&&>(initiation)),
-        token.token_, token.timeout_, token.cancel_type_,
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename Executor, typename... Signatures>
-struct async_result<
-    cancel_after_timer<CompletionToken, Clock, WaitTraits, Executor>,
-    Signatures...>
-  : async_result<CompletionToken, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        Signatures...>(
-          declval<detail::initiate_cancel_after_timer<
-            decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>>(),
-          token.token_, &token.timer_, token.timeout_,
-          token.cancel_type_, static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      Signatures...>(
-        detail::initiate_cancel_after_timer<
-          decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>(
-            static_cast<Initiation&&>(initiation)),
-        token.token_, &token.timer_, token.timeout_,
-        token.cancel_type_, static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Clock, typename WaitTraits, typename... Signatures>
-struct async_result<partial_cancel_after<Clock, WaitTraits>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        const cancel_after_t<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits>&,
-        Signatures...>(
-          static_cast<Initiation&&>(initiation),
-          cancel_after_t<
-            default_completion_token_t<associated_executor_t<Initiation>>,
-            Clock, WaitTraits>(
-              default_completion_token_t<associated_executor_t<Initiation>>{},
-              token.timeout_, token.cancel_type_),
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      const cancel_after_t<
-        default_completion_token_t<associated_executor_t<Initiation>>,
-        Clock, WaitTraits>&,
-      Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_after_t<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.timeout_, token.cancel_type_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Clock, typename WaitTraits,
-    typename Executor, typename... Signatures>
-struct async_result<
-    partial_cancel_after_timer<Clock, WaitTraits, Executor>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_after_timer<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits, Executor>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.timer_, token.timeout_, token.cancel_type_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_after_timer<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits, Executor>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.timer_, token.timeout_, token.cancel_type_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CANCEL_AFTER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_at.hpp
deleted file mode 100644
index 662e70b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancel_at.hpp
+++ /dev/null
@@ -1,268 +0,0 @@
-//
-// impl/cancel_at.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CANCEL_AT_HPP
-#define ASIO_IMPL_CANCEL_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/timed_cancel_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Initiation, typename Clock,
-    typename WaitTraits, typename... Signatures>
-struct initiate_cancel_at : initiation_base<Initiation>
-{
-  using initiation_base<Initiation>::initiation_base;
-
-  template <typename Handler, typename Duration, typename... Args>
-  void operator()(Handler&& handler,
-      const chrono::time_point<Clock, Duration>& expiry,
-      cancellation_type_t cancel_type, Args&&... args) &&
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value,
-        basic_waitable_timer<Clock, WaitTraits,
-          typename Initiation::executor_type>(this->get_executor(), expiry),
-        cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename Duration, typename... Args>
-  void operator()(Handler&& handler,
-      const chrono::time_point<Clock, Duration>& expiry,
-      cancellation_type_t cancel_type, Args&&... args) const &
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits>, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value,
-        basic_waitable_timer<Clock, WaitTraits,
-          typename Initiation::executor_type>(this->get_executor(), expiry),
-        cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<const Initiation&>(*this),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Initiation, typename Clock,
-    typename WaitTraits, typename Executor, typename... Signatures>
-struct initiate_cancel_at_timer : initiation_base<Initiation>
-{
-  using initiation_base<Initiation>::initiation_base;
-
-  template <typename Handler, typename Duration, typename... Args>
-  void operator()(Handler&& handler,
-      basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
-      const chrono::time_point<Clock, Duration>& expiry,
-      cancellation_type_t cancel_type, Args&&... args) &&
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    timer->expires_at(expiry);
-    p.p = new (p.v) op(handler2.value, *timer, cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<Initiation&&>(*this), static_cast<Args&&>(args)...);
-  }
-
-  template <typename Handler, typename Duration, typename... Args>
-  void operator()(Handler&& handler,
-      basic_waitable_timer<Clock, WaitTraits, Executor>* timer,
-      const chrono::time_point<Clock, Duration>& expiry,
-      cancellation_type_t cancel_type, Args&&... args) const &
-  {
-    using op = detail::timed_cancel_op<decay_t<Handler>,
-        basic_waitable_timer<Clock, WaitTraits, Executor>&, Signatures...>;
-
-    non_const_lvalue<Handler> handler2(handler);
-    typename op::ptr p = { asio::detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    timer->expires_at(expiry);
-    p.p = new (p.v) op(handler2.value, *timer, cancel_type);
-
-    op* o = p.p;
-    p.v = p.p = 0;
-    o->start(static_cast<const Initiation&>(*this),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename... Signatures>
-struct async_result<
-    cancel_at_t<CompletionToken, Clock, WaitTraits>, Signatures...>
-  : async_result<CompletionToken, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        Signatures...>(
-          declval<detail::initiate_cancel_at<
-            decay_t<Initiation>, Clock, WaitTraits, Signatures...>>(),
-          token.token_, token.expiry_, token.cancel_type_,
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      Signatures...>(
-        detail::initiate_cancel_at<
-          decay_t<Initiation>, Clock, WaitTraits, Signatures...>(
-            static_cast<Initiation&&>(initiation)),
-        token.token_, token.expiry_, token.cancel_type_,
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename CompletionToken, typename Clock,
-    typename WaitTraits, typename Executor, typename... Signatures>
-struct async_result<
-    cancel_at_timer<CompletionToken, Clock, WaitTraits, Executor>,
-    Signatures...>
-  : async_result<CompletionToken, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        Signatures...>(
-          declval<detail::initiate_cancel_at_timer<
-            decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>>(),
-          token.token_, &token.timer_, token.expiry_, token.cancel_type_,
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      Signatures...>(
-        detail::initiate_cancel_at_timer<
-          decay_t<Initiation>, Clock, WaitTraits, Executor, Signatures...>(
-            static_cast<Initiation&&>(initiation)),
-        token.token_, &token.timer_, token.expiry_, token.cancel_type_,
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Clock, typename WaitTraits, typename... Signatures>
-struct async_result<partial_cancel_at<Clock, WaitTraits>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        const cancel_at_t<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits>&,
-        Signatures...>(
-          static_cast<Initiation&&>(initiation),
-          cancel_at_t<
-            default_completion_token_t<associated_executor_t<Initiation>>,
-            Clock, WaitTraits>(
-              default_completion_token_t<associated_executor_t<Initiation>>{},
-              token.expiry_, token.cancel_type_),
-          static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      const cancel_at_t<
-        default_completion_token_t<associated_executor_t<Initiation>>,
-        Clock, WaitTraits>&,
-      Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_at_t<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.expiry_, token.cancel_type_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <typename Clock, typename WaitTraits,
-    typename Executor, typename... Signatures>
-struct async_result<
-    partial_cancel_at_timer<Clock, WaitTraits, Executor>, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_at_timer<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits, Executor>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.timer_, token.expiry_, token.cancel_type_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        cancel_at_timer<
-          default_completion_token_t<associated_executor_t<Initiation>>,
-          Clock, WaitTraits, Executor>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.timer_, token.expiry_, token.cancel_type_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CANCEL_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancellation_signal.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancellation_signal.ipp
deleted file mode 100644
index f63ab8d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/cancellation_signal.ipp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// impl/cancellation_signal.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CANCELLATION_SIGNAL_IPP
-#define ASIO_IMPL_CANCELLATION_SIGNAL_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/thread_context.hpp"
-#include "asio/detail/thread_info_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-cancellation_signal::~cancellation_signal()
-{
-  if (handler_)
-  {
-    std::pair<void*, std::size_t> mem = handler_->destroy();
-    detail::thread_info_base::deallocate(
-        detail::thread_info_base::cancellation_signal_tag(),
-        detail::thread_context::top_of_thread_call_stack(),
-        mem.first, mem.second);
-  }
-}
-
-void cancellation_slot::clear()
-{
-  if (handler_ != 0 && *handler_ != 0)
-  {
-    std::pair<void*, std::size_t> mem = (*handler_)->destroy();
-    detail::thread_info_base::deallocate(
-        detail::thread_info_base::cancellation_signal_tag(),
-        detail::thread_context::top_of_thread_call_stack(),
-        mem.first, mem.second);
-    *handler_ = 0;
-  }
-}
-
-std::pair<void*, std::size_t> cancellation_slot::prepare_memory(
-    std::size_t size, std::size_t align)
-{
-  assert(handler_);
-  std::pair<void*, std::size_t> mem;
-  if (*handler_)
-  {
-    mem = (*handler_)->destroy();
-    *handler_ = 0;
-  }
-  if (size > mem.second
-      || reinterpret_cast<std::size_t>(mem.first) % align != 0)
-  {
-    if (mem.first)
-    {
-      detail::thread_info_base::deallocate(
-          detail::thread_info_base::cancellation_signal_tag(),
-          detail::thread_context::top_of_thread_call_stack(),
-          mem.first, mem.second);
-    }
-    mem.first = detail::thread_info_base::allocate(
-        detail::thread_info_base::cancellation_signal_tag(),
-        detail::thread_context::top_of_thread_call_stack(),
-        size, align);
-    mem.second = size;
-  }
-  return mem;
-}
-
-cancellation_slot::auto_delete_helper::~auto_delete_helper()
-{
-  if (mem.first)
-  {
-    detail::thread_info_base::deallocate(
-        detail::thread_info_base::cancellation_signal_tag(),
-        detail::thread_context::top_of_thread_call_stack(),
-        mem.first, mem.second);
-  }
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CANCELLATION_SIGNAL_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/co_spawn.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/co_spawn.hpp
deleted file mode 100644
index 3eba7d8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/co_spawn.hpp
+++ /dev/null
@@ -1,449 +0,0 @@
-//
-// impl/co_spawn.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CO_SPAWN_HPP
-#define ASIO_IMPL_CO_SPAWN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/awaitable.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/post.hpp"
-#include "asio/prefer.hpp"
-#include "asio/use_awaitable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Executor, typename = void>
-class co_spawn_work_guard
-{
-public:
-  typedef decay_t<
-      prefer_result_t<Executor,
-        execution::outstanding_work_t::tracked_t
-      >
-    > executor_type;
-
-  co_spawn_work_guard(const Executor& ex)
-    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-private:
-  executor_type executor_;
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Executor>
-struct co_spawn_work_guard<Executor,
-    enable_if_t<
-      !execution::is_executor<Executor>::value
-    >> : executor_work_guard<Executor>
-{
-  co_spawn_work_guard(const Executor& ex)
-    : executor_work_guard<Executor>(ex)
-  {
-  }
-};
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Handler, typename Executor,
-    typename Function, typename = void>
-struct co_spawn_state
-{
-  template <typename H, typename F>
-  co_spawn_state(H&& h, const Executor& ex, F&& f)
-    : handler(std::forward<H>(h)),
-      spawn_work(ex),
-      handler_work(asio::get_associated_executor(handler, ex)),
-      function(std::forward<F>(f))
-  {
-  }
-
-  Handler handler;
-  co_spawn_work_guard<Executor> spawn_work;
-  co_spawn_work_guard<associated_executor_t<Handler, Executor>> handler_work;
-  Function function;
-};
-
-template <typename Handler, typename Executor, typename Function>
-struct co_spawn_state<Handler, Executor, Function,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          Executor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-  template <typename H, typename F>
-  co_spawn_state(H&& h, const Executor& ex, F&& f)
-    : handler(std::forward<H>(h)),
-      handler_work(ex),
-      function(std::forward<F>(f))
-  {
-  }
-
-  Handler handler;
-  co_spawn_work_guard<Executor> handler_work;
-  Function function;
-};
-
-struct co_spawn_dispatch
-{
-  template <typename CompletionToken>
-  auto operator()(CompletionToken&& token) const
-    -> decltype(asio::dispatch(std::forward<CompletionToken>(token)))
-  {
-    return asio::dispatch(std::forward<CompletionToken>(token));
-  }
-};
-
-struct co_spawn_post
-{
-  template <typename CompletionToken>
-  auto operator()(CompletionToken&& token) const
-    -> decltype(asio::post(std::forward<CompletionToken>(token)))
-  {
-    return asio::post(std::forward<CompletionToken>(token));
-  }
-};
-
-template <typename T, typename Handler, typename Executor, typename Function>
-awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
-    awaitable<T, Executor>*, co_spawn_state<Handler, Executor, Function> s)
-{
-  (void) co_await co_spawn_dispatch{};
-
-  (co_await awaitable_thread_has_context_switched{}) = false;
-  std::exception_ptr e = nullptr;
-  bool done = false;
-  try
-  {
-    T t = co_await s.function();
-
-    done = true;
-
-    bool switched = (co_await awaitable_thread_has_context_switched{});
-    if (!switched)
-    {
-      co_await this_coro::throw_if_cancelled(false);
-      (void) co_await co_spawn_post();
-    }
-
-    (dispatch)(s.handler_work.get_executor(),
-        [handler = std::move(s.handler), t = std::move(t)]() mutable
-        {
-          std::move(handler)(std::exception_ptr(), std::move(t));
-        });
-
-    co_return;
-  }
-  catch (...)
-  {
-    if (done)
-      throw;
-
-    e = std::current_exception();
-  }
-
-  bool switched = (co_await awaitable_thread_has_context_switched{});
-  if (!switched)
-  {
-    co_await this_coro::throw_if_cancelled(false);
-    (void) co_await co_spawn_post();
-  }
-
-  (dispatch)(s.handler_work.get_executor(),
-      [handler = std::move(s.handler), e]() mutable
-      {
-        std::move(handler)(e, T());
-      });
-}
-
-template <typename Handler, typename Executor, typename Function>
-awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
-    awaitable<void, Executor>*, co_spawn_state<Handler, Executor, Function> s)
-{
-  (void) co_await co_spawn_dispatch{};
-
-  (co_await awaitable_thread_has_context_switched{}) = false;
-  std::exception_ptr e = nullptr;
-  try
-  {
-    co_await s.function();
-  }
-  catch (...)
-  {
-    e = std::current_exception();
-  }
-
-  bool switched = (co_await awaitable_thread_has_context_switched{});
-  if (!switched)
-  {
-    co_await this_coro::throw_if_cancelled(false);
-    (void) co_await co_spawn_post();
-  }
-
-  (dispatch)(s.handler_work.get_executor(),
-      [handler = std::move(s.handler), e]() mutable
-      {
-        std::move(handler)(e);
-      });
-}
-
-template <typename T, typename Executor>
-class awaitable_as_function
-{
-public:
-  explicit awaitable_as_function(awaitable<T, Executor>&& a)
-    : awaitable_(std::move(a))
-  {
-  }
-
-  awaitable<T, Executor> operator()()
-  {
-    return std::move(awaitable_);
-  }
-
-private:
-  awaitable<T, Executor> awaitable_;
-};
-
-template <typename Handler, typename Executor, typename = void>
-class co_spawn_cancellation_handler
-{
-public:
-  co_spawn_cancellation_handler(const Handler&, const Executor& ex)
-    : signal_(detail::allocate_shared<cancellation_signal>(
-          detail::recycling_allocator<cancellation_signal,
-            detail::thread_info_base::cancellation_signal_tag>())),
-      ex_(ex)
-  {
-  }
-
-  cancellation_slot slot()
-  {
-    return signal_->slot();
-  }
-
-  void operator()(cancellation_type_t type)
-  {
-    shared_ptr<cancellation_signal> sig = signal_;
-    asio::dispatch(ex_, [sig, type]{ sig->emit(type); });
-  }
-
-private:
-  shared_ptr<cancellation_signal> signal_;
-  Executor ex_;
-};
-
-template <typename Handler, typename Executor>
-class co_spawn_cancellation_handler<Handler, Executor,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          Executor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-public:
-  co_spawn_cancellation_handler(const Handler&, const Executor&)
-  {
-  }
-
-  cancellation_slot slot()
-  {
-    return signal_.slot();
-  }
-
-  void operator()(cancellation_type_t type)
-  {
-    signal_.emit(type);
-  }
-
-private:
-  cancellation_signal signal_;
-};
-
-template <typename Executor>
-class initiate_co_spawn
-{
-public:
-  typedef Executor executor_type;
-
-  template <typename OtherExecutor>
-  explicit initiate_co_spawn(const OtherExecutor& ex)
-    : ex_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return ex_;
-  }
-
-  template <typename Handler, typename F>
-  void operator()(Handler&& handler, F&& f) const
-  {
-    typedef result_of_t<F()> awaitable_type;
-    typedef decay_t<Handler> handler_type;
-    typedef decay_t<F> function_type;
-    typedef co_spawn_cancellation_handler<
-      handler_type, Executor> cancel_handler_type;
-
-    auto slot = asio::get_associated_cancellation_slot(handler);
-    cancel_handler_type* cancel_handler = slot.is_connected()
-      ? &slot.template emplace<cancel_handler_type>(handler, ex_)
-      : nullptr;
-
-    cancellation_slot proxy_slot(
-        cancel_handler
-          ? cancel_handler->slot()
-          : cancellation_slot());
-
-    cancellation_state cancel_state(proxy_slot);
-
-    auto a = (co_spawn_entry_point)(static_cast<awaitable_type*>(nullptr),
-        co_spawn_state<handler_type, Executor, function_type>(
-          std::forward<Handler>(handler), ex_, std::forward<F>(f)));
-    awaitable_handler<executor_type, void>(std::move(a),
-        ex_, proxy_slot, cancel_state).launch();
-  }
-
-private:
-  Executor ex_;
-};
-
-} // namespace detail
-
-template <typename Executor, typename T, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr, T)) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(const Executor& ex,
-    awaitable<T, AwaitableExecutor> a, CompletionToken&& token,
-    constraint_t<
-      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
-        && is_convertible<Executor, AwaitableExecutor>::value
-    >)
-{
-  return async_initiate<CompletionToken, void(std::exception_ptr, T)>(
-      detail::initiate_co_spawn<AwaitableExecutor>(AwaitableExecutor(ex)),
-      token, detail::awaitable_as_function<T, AwaitableExecutor>(std::move(a)));
-}
-
-template <typename Executor, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr)) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(const Executor& ex,
-    awaitable<void, AwaitableExecutor> a, CompletionToken&& token,
-    constraint_t<
-      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
-        && is_convertible<Executor, AwaitableExecutor>::value
-    >)
-{
-  return async_initiate<CompletionToken, void(std::exception_ptr)>(
-      detail::initiate_co_spawn<AwaitableExecutor>(AwaitableExecutor(ex)),
-      token, detail::awaitable_as_function<
-        void, AwaitableExecutor>(std::move(a)));
-}
-
-template <typename ExecutionContext, typename T, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr, T)) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr, T))
-co_spawn(ExecutionContext& ctx,
-    awaitable<T, AwaitableExecutor> a, CompletionToken&& token,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-        && is_convertible<typename ExecutionContext::executor_type,
-          AwaitableExecutor>::value
-    >)
-{
-  return (co_spawn)(ctx.get_executor(), std::move(a),
-      std::forward<CompletionToken>(token));
-}
-
-template <typename ExecutionContext, typename AwaitableExecutor,
-    ASIO_COMPLETION_TOKEN_FOR(
-      void(std::exception_ptr)) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(std::exception_ptr))
-co_spawn(ExecutionContext& ctx,
-    awaitable<void, AwaitableExecutor> a, CompletionToken&& token,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-        && is_convertible<typename ExecutionContext::executor_type,
-          AwaitableExecutor>::value
-    >)
-{
-  return (co_spawn)(ctx.get_executor(), std::move(a),
-      std::forward<CompletionToken>(token));
-}
-
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
-      result_of_t<F()>>::type) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<result_of_t<F()>>::type)
-co_spawn(const Executor& ex, F&& f, CompletionToken&& token,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-{
-  return async_initiate<CompletionToken,
-    typename detail::awaitable_signature<result_of_t<F()>>::type>(
-      detail::initiate_co_spawn<
-        typename result_of_t<F()>::executor_type>(ex),
-      token, std::forward<F>(f));
-}
-
-template <typename ExecutionContext, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
-      result_of_t<F()>>::type) CompletionToken>
-inline ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
-    typename detail::awaitable_signature<result_of_t<F()>>::type)
-co_spawn(ExecutionContext& ctx, F&& f, CompletionToken&& token,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    >)
-{
-  return (co_spawn)(ctx.get_executor(), std::forward<F>(f),
-      std::forward<CompletionToken>(token));
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CO_SPAWN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect.hpp
deleted file mode 100644
index b107e5f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect.hpp
+++ /dev/null
@@ -1,703 +0,0 @@
-//
-// impl/connect.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CONNECT_HPP
-#define ASIO_IMPL_CONNECT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <algorithm>
-#include "asio/associator.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-#include "asio/post.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <typename Protocol, typename Iterator>
-  inline typename Protocol::endpoint deref_connect_result(
-      Iterator iter, asio::error_code& ec)
-  {
-    return ec ? typename Protocol::endpoint() : *iter;
-  }
-
-  template <typename ConnectCondition, typename Iterator>
-  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
-      const asio::error_code& ec, Iterator next, Iterator end,
-      constraint_t<
-        is_same<
-          result_of_t<ConnectCondition(asio::error_code, Iterator)>,
-          Iterator
-        >::value
-      > = 0)
-  {
-    if (next != end)
-      return connect_condition(ec, next);
-    return end;
-  }
-
-  template <typename ConnectCondition, typename Iterator>
-  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
-      const asio::error_code& ec, Iterator next, Iterator end,
-      constraint_t<
-        is_same<
-          result_of_t<ConnectCondition(asio::error_code,
-            decltype(*declval<Iterator>()))>,
-          bool
-        >::value
-      > = 0)
-  {
-    for (;next != end; ++next)
-      if (connect_condition(ec, *next))
-        return next;
-    return end;
-  }
-} // namespace detail
-
-template <typename Protocol, typename Executor, typename EndpointSequence>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    >)
-{
-  asio::error_code ec;
-  typename Protocol::endpoint result = connect(s, endpoints, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor, typename EndpointSequence>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, asio::error_code& ec,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    >)
-{
-  return detail::deref_connect_result<Protocol>(
-      connect(s, endpoints.begin(), endpoints.end(),
-        detail::default_connect_condition(), ec), ec);
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    >)
-{
-  asio::error_code ec;
-  Iterator result = connect(s, begin, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, asio::error_code& ec,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    >)
-{
-  return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Protocol, typename Executor, typename Iterator>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end)
-{
-  asio::error_code ec;
-  Iterator result = connect(s, begin, end, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, Iterator end, asio::error_code& ec)
-{
-  return connect(s, begin, end, detail::default_connect_condition(), ec);
-}
-
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename ConnectCondition>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    >,
-    constraint_t<
-      is_connect_condition<ConnectCondition,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    >)
-{
-  asio::error_code ec;
-  typename Protocol::endpoint result = connect(
-      s, endpoints, connect_condition, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor,
-    typename EndpointSequence, typename ConnectCondition>
-typename Protocol::endpoint connect(basic_socket<Protocol, Executor>& s,
-    const EndpointSequence& endpoints, ConnectCondition connect_condition,
-    asio::error_code& ec,
-    constraint_t<
-      is_endpoint_sequence<EndpointSequence>::value
-    >,
-    constraint_t<
-      is_connect_condition<ConnectCondition,
-        decltype(declval<const EndpointSequence&>().begin())>::value
-    >)
-{
-  return detail::deref_connect_result<Protocol>(
-      connect(s, endpoints.begin(), endpoints.end(),
-        connect_condition, ec), ec);
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, ConnectCondition connect_condition,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    >,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    >)
-{
-  asio::error_code ec;
-  Iterator result = connect(s, begin, connect_condition, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-inline Iterator connect(basic_socket<Protocol, Executor>& s,
-    Iterator begin, ConnectCondition connect_condition,
-    asio::error_code& ec,
-    constraint_t<
-      !is_endpoint_sequence<Iterator>::value
-    >,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    >)
-{
-  return connect(s, begin, Iterator(), connect_condition, ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    Iterator end, ConnectCondition connect_condition,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    >)
-{
-  asio::error_code ec;
-  Iterator result = connect(s, begin, end, connect_condition, ec);
-  asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename Executor,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, Executor>& s, Iterator begin,
-    Iterator end, ConnectCondition connect_condition,
-    asio::error_code& ec,
-    constraint_t<
-      is_connect_condition<ConnectCondition, Iterator>::value
-    >)
-{
-  ec = asio::error_code();
-
-  for (Iterator iter = begin; iter != end; ++iter)
-  {
-    iter = (detail::call_connect_condition(connect_condition, ec, iter, end));
-    if (iter != end)
-    {
-      s.close(ec);
-      s.connect(*iter, ec);
-      if (!ec)
-        return iter;
-    }
-    else
-      break;
-  }
-
-  if (!ec)
-    ec = asio::error::not_found;
-
-  return end;
-}
-
-namespace detail
-{
-  // Enable the empty base class optimisation for the connect condition.
-  template <typename ConnectCondition>
-  class base_from_connect_condition
-  {
-  protected:
-    explicit base_from_connect_condition(
-        const ConnectCondition& connect_condition)
-      : connect_condition_(connect_condition)
-    {
-    }
-
-    template <typename Iterator>
-    void check_condition(const asio::error_code& ec,
-        Iterator& iter, Iterator& end)
-    {
-      iter = detail::call_connect_condition(connect_condition_, ec, iter, end);
-    }
-
-  private:
-    ConnectCondition connect_condition_;
-  };
-
-  // The default_connect_condition implementation is essentially a no-op. This
-  // template specialisation lets us eliminate all costs associated with it.
-  template <>
-  class base_from_connect_condition<default_connect_condition>
-  {
-  protected:
-    explicit base_from_connect_condition(const default_connect_condition&)
-    {
-    }
-
-    template <typename Iterator>
-    void check_condition(const asio::error_code&, Iterator&, Iterator&)
-    {
-    }
-  };
-
-  template <typename Protocol, typename Executor, typename EndpointSequence,
-      typename ConnectCondition, typename RangeConnectHandler>
-  class range_connect_op
-    : public base_from_cancellation_state<RangeConnectHandler>,
-      base_from_connect_condition<ConnectCondition>
-  {
-  public:
-    range_connect_op(basic_socket<Protocol, Executor>& sock,
-        const EndpointSequence& endpoints,
-        const ConnectCondition& connect_condition,
-        RangeConnectHandler& handler)
-      : base_from_cancellation_state<RangeConnectHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_connect_condition<ConnectCondition>(connect_condition),
-        socket_(sock),
-        endpoints_(endpoints),
-        index_(0),
-        start_(0),
-        handler_(static_cast<RangeConnectHandler&&>(handler))
-    {
-    }
-
-    range_connect_op(const range_connect_op& other)
-      : base_from_cancellation_state<RangeConnectHandler>(other),
-        base_from_connect_condition<ConnectCondition>(other),
-        socket_(other.socket_),
-        endpoints_(other.endpoints_),
-        index_(other.index_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    range_connect_op(range_connect_op&& other)
-      : base_from_cancellation_state<RangeConnectHandler>(
-          static_cast<base_from_cancellation_state<RangeConnectHandler>&&>(
-            other)),
-        base_from_connect_condition<ConnectCondition>(other),
-        socket_(other.socket_),
-        endpoints_(other.endpoints_),
-        index_(other.index_),
-        start_(other.start_),
-        handler_(static_cast<RangeConnectHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec, int start = 0)
-    {
-      this->process(ec, start,
-          const_cast<const EndpointSequence&>(endpoints_).begin(),
-          const_cast<const EndpointSequence&>(endpoints_).end());
-    }
-
-  //private:
-    template <typename Iterator>
-    void process(asio::error_code ec,
-        int start, Iterator begin, Iterator end)
-    {
-      Iterator iter = begin;
-      std::advance(iter, index_);
-
-      switch (start_ = start)
-      {
-        case 1:
-        for (;;)
-        {
-          this->check_condition(ec, iter, end);
-          index_ = std::distance(begin, iter);
-
-          if (iter != end)
-          {
-            socket_.close(ec);
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_connect"));
-            socket_.async_connect(*iter,
-                static_cast<range_connect_op&&>(*this));
-            return;
-          }
-
-          if (start)
-          {
-            ec = asio::error::not_found;
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_connect"));
-            asio::post(socket_.get_executor(),
-                detail::bind_handler(
-                  static_cast<range_connect_op&&>(*this), ec));
-            return;
-          }
-
-          /* fall-through */ default:
-
-          if (iter == end)
-            break;
-
-          if (!socket_.is_open())
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-
-          if (!ec)
-            break;
-
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-
-          ++iter;
-          ++index_;
-        }
-
-        static_cast<RangeConnectHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const typename Protocol::endpoint&>(
-              ec || iter == end ? typename Protocol::endpoint() : *iter));
-      }
-    }
-
-    basic_socket<Protocol, Executor>& socket_;
-    EndpointSequence endpoints_;
-    std::size_t index_;
-    int start_;
-    RangeConnectHandler handler_;
-  };
-
-  template <typename Protocol, typename Executor, typename EndpointSequence,
-      typename ConnectCondition, typename RangeConnectHandler>
-  inline bool asio_handler_is_continuation(
-      range_connect_op<Protocol, Executor, EndpointSequence,
-        ConnectCondition, RangeConnectHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-  }
-
-  template <typename Protocol, typename Executor>
-  class initiate_async_range_connect
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_range_connect(basic_socket<Protocol, Executor>& s)
-      : socket_(s)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return socket_.get_executor();
-    }
-
-    template <typename RangeConnectHandler,
-        typename EndpointSequence, typename ConnectCondition>
-    void operator()(RangeConnectHandler&& handler,
-        const EndpointSequence& endpoints,
-        const ConnectCondition& connect_condition) const
-    {
-      // If you get an error on the following line it means that your
-      // handler does not meet the documented type requirements for an
-      // RangeConnectHandler.
-      ASIO_RANGE_CONNECT_HANDLER_CHECK(RangeConnectHandler,
-          handler, typename Protocol::endpoint) type_check;
-
-      non_const_lvalue<RangeConnectHandler> handler2(handler);
-      range_connect_op<Protocol, Executor, EndpointSequence, ConnectCondition,
-        decay_t<RangeConnectHandler>>(socket_, endpoints,
-          connect_condition, handler2.value)(asio::error_code(), 1);
-    }
-
-  private:
-    basic_socket<Protocol, Executor>& socket_;
-  };
-
-  template <typename Protocol, typename Executor, typename Iterator,
-      typename ConnectCondition, typename IteratorConnectHandler>
-  class iterator_connect_op
-    : public base_from_cancellation_state<IteratorConnectHandler>,
-      base_from_connect_condition<ConnectCondition>
-  {
-  public:
-    iterator_connect_op(basic_socket<Protocol, Executor>& sock,
-        const Iterator& begin, const Iterator& end,
-        const ConnectCondition& connect_condition,
-        IteratorConnectHandler& handler)
-      : base_from_cancellation_state<IteratorConnectHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_connect_condition<ConnectCondition>(connect_condition),
-        socket_(sock),
-        iter_(begin),
-        end_(end),
-        start_(0),
-        handler_(static_cast<IteratorConnectHandler&&>(handler))
-    {
-    }
-
-    iterator_connect_op(const iterator_connect_op& other)
-      : base_from_cancellation_state<IteratorConnectHandler>(other),
-        base_from_connect_condition<ConnectCondition>(other),
-        socket_(other.socket_),
-        iter_(other.iter_),
-        end_(other.end_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    iterator_connect_op(iterator_connect_op&& other)
-      : base_from_cancellation_state<IteratorConnectHandler>(
-          static_cast<base_from_cancellation_state<IteratorConnectHandler>&&>(
-            other)),
-        base_from_connect_condition<ConnectCondition>(other),
-        socket_(other.socket_),
-        iter_(other.iter_),
-        end_(other.end_),
-        start_(other.start_),
-        handler_(static_cast<IteratorConnectHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec, int start = 0)
-    {
-      switch (start_ = start)
-      {
-        case 1:
-        for (;;)
-        {
-          this->check_condition(ec, iter_, end_);
-
-          if (iter_ != end_)
-          {
-            socket_.close(ec);
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_connect"));
-            socket_.async_connect(*iter_,
-                static_cast<iterator_connect_op&&>(*this));
-            return;
-          }
-
-          if (start)
-          {
-            ec = asio::error::not_found;
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_connect"));
-            asio::post(socket_.get_executor(),
-                detail::bind_handler(
-                  static_cast<iterator_connect_op&&>(*this), ec));
-            return;
-          }
-
-          /* fall-through */ default:
-
-          if (iter_ == end_)
-            break;
-
-          if (!socket_.is_open())
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-
-          if (!ec)
-            break;
-
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-
-          ++iter_;
-        }
-
-        static_cast<IteratorConnectHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const Iterator&>(iter_));
-      }
-    }
-
-  //private:
-    basic_socket<Protocol, Executor>& socket_;
-    Iterator iter_;
-    Iterator end_;
-    int start_;
-    IteratorConnectHandler handler_;
-  };
-
-  template <typename Protocol, typename Executor, typename Iterator,
-      typename ConnectCondition, typename IteratorConnectHandler>
-  inline bool asio_handler_is_continuation(
-      iterator_connect_op<Protocol, Executor, Iterator,
-        ConnectCondition, IteratorConnectHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-  }
-
-  template <typename Protocol, typename Executor>
-  class initiate_async_iterator_connect
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_iterator_connect(
-        basic_socket<Protocol, Executor>& s)
-      : socket_(s)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return socket_.get_executor();
-    }
-
-    template <typename IteratorConnectHandler,
-        typename Iterator, typename ConnectCondition>
-    void operator()(IteratorConnectHandler&& handler,
-        Iterator begin, Iterator end,
-        const ConnectCondition& connect_condition) const
-    {
-      // If you get an error on the following line it means that your
-      // handler does not meet the documented type requirements for an
-      // IteratorConnectHandler.
-      ASIO_ITERATOR_CONNECT_HANDLER_CHECK(
-          IteratorConnectHandler, handler, Iterator) type_check;
-
-      non_const_lvalue<IteratorConnectHandler> handler2(handler);
-      iterator_connect_op<Protocol, Executor, Iterator, ConnectCondition,
-        decay_t<IteratorConnectHandler>>(socket_, begin, end,
-          connect_condition, handler2.value)(asio::error_code(), 1);
-    }
-
-  private:
-    basic_socket<Protocol, Executor>& socket_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename Protocol, typename Executor, typename EndpointSequence,
-    typename ConnectCondition, typename RangeConnectHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::range_connect_op<Protocol, Executor,
-      EndpointSequence, ConnectCondition, RangeConnectHandler>,
-    DefaultCandidate>
-  : Associator<RangeConnectHandler, DefaultCandidate>
-{
-  static typename Associator<RangeConnectHandler, DefaultCandidate>::type get(
-      const detail::range_connect_op<Protocol, Executor, EndpointSequence,
-        ConnectCondition, RangeConnectHandler>& h) noexcept
-  {
-    return Associator<RangeConnectHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::range_connect_op<Protocol, Executor,
-        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(
-      Associator<RangeConnectHandler, DefaultCandidate>::get(
-        h.handler_, c))
-  {
-    return Associator<RangeConnectHandler, DefaultCandidate>::get(
-        h.handler_, c);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Protocol, typename Executor, typename Iterator,
-    typename ConnectCondition, typename IteratorConnectHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::iterator_connect_op<Protocol, Executor,
-      Iterator, ConnectCondition, IteratorConnectHandler>,
-    DefaultCandidate>
-  : Associator<IteratorConnectHandler, DefaultCandidate>
-{
-  static typename Associator<IteratorConnectHandler, DefaultCandidate>::type
-  get(const detail::iterator_connect_op<Protocol, Executor, Iterator,
-        ConnectCondition, IteratorConnectHandler>& h) noexcept
-  {
-    return Associator<IteratorConnectHandler, DefaultCandidate>::get(
-        h.handler_);
-  }
-
-  static auto get(
-      const detail::iterator_connect_op<Protocol, Executor,
-        Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(
-      Associator<IteratorConnectHandler, DefaultCandidate>::get(
-        h.handler_, c))
-  {
-    return Associator<IteratorConnectHandler, DefaultCandidate>::get(
-        h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CONNECT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.hpp
deleted file mode 100644
index e40b3c9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// impl/connect_pipe.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CONNECT_PIPE_HPP
-#define ASIO_IMPL_CONNECT_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE)
-
-#include "asio/connect_pipe.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Executor1, typename Executor2>
-void connect_pipe(basic_readable_pipe<Executor1>& read_end,
-    basic_writable_pipe<Executor2>& write_end)
-{
-  asio::error_code ec;
-  asio::connect_pipe(read_end, write_end, ec);
-  asio::detail::throw_error(ec, "connect_pipe");
-}
-
-template <typename Executor1, typename Executor2>
-ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
-    basic_writable_pipe<Executor2>& write_end, asio::error_code& ec)
-{
-  detail::native_pipe_handle p[2];
-  detail::create_pipe(p, ec);
-  if (ec)
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-
-  read_end.assign(p[0], ec);
-  if (ec)
-  {
-    detail::close_pipe(p[0]);
-    detail::close_pipe(p[1]);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  write_end.assign(p[1], ec);
-  if (ec)
-  {
-    asio::error_code temp_ec;
-    read_end.close(temp_ec);
-    detail::close_pipe(p[1]);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PIPE)
-
-#endif // ASIO_IMPL_CONNECT_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.ipp
deleted file mode 100644
index 6efe790..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/connect_pipe.ipp
+++ /dev/null
@@ -1,149 +0,0 @@
-//
-// impl/connect_pipe.ipp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CONNECT_PIPE_IPP
-#define ASIO_IMPL_CONNECT_PIPE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE)
-
-#include "asio/connect_pipe.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include <cstdio>
-# if _WIN32_WINNT >= 0x601
-#  include <bcrypt.h>
-#  if !defined(ASIO_NO_DEFAULT_LINKED_LIBS)
-#   if defined(_MSC_VER)
-#    pragma comment(lib, "bcrypt.lib")
-#   endif // defined(_MSC_VER)
-#  endif // !defined(ASIO_NO_DEFAULT_LINKED_LIBS)
-# endif // _WIN32_WINNT >= 0x601
-#else // defined(ASIO_HAS_IOCP)
-# include "asio/detail/descriptor_ops.hpp"
-#endif // defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void create_pipe(native_pipe_handle p[2], asio::error_code& ec)
-{
-#if defined(ASIO_HAS_IOCP)
-  using namespace std; // For sprintf and memcmp.
-
-  static long counter1 = 0;
-  static long counter2 = 0;
-
-  long n1 = ::InterlockedIncrement(&counter1);
-  long n2 = (static_cast<unsigned long>(n1) % 0x10000000) == 0
-    ? ::InterlockedIncrement(&counter2)
-    : ::InterlockedExchangeAdd(&counter2, 0);
-
-  wchar_t pipe_name[128];
-#if defined(ASIO_HAS_SECURE_RTL)
-  swprintf_s(
-#else // defined(ASIO_HAS_SECURE_RTL)
-  _snwprintf(
-#endif // defined(ASIO_HAS_SECURE_RTL)
-      pipe_name, 128,
-      L"\\\\.\\pipe\\asio-A0812896-741A-484D-AF23-BE51BF620E22-%u-%ld-%ld",
-      static_cast<unsigned int>(::GetCurrentProcessId()), n1, n2);
-
-  p[0] = ::CreateNamedPipeW(pipe_name,
-      PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
-      0, 1, 8192, 8192, 0, 0);
-
-  if (p[0] == INVALID_HANDLE_VALUE)
-  {
-    DWORD last_error = ::GetLastError();
-    ec.assign(last_error, asio::error::get_system_category());
-    return;
-  }
-
-  p[1] = ::CreateFileW(pipe_name, GENERIC_WRITE, 0,
-    0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
-
-  if (p[1] == INVALID_HANDLE_VALUE)
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(p[0]);
-    ec.assign(last_error, asio::error::get_system_category());
-    return;
-  }
-
-# if _WIN32_WINNT >= 0x601
-  unsigned char nonce[16];
-  if (::BCryptGenRandom(0, nonce, sizeof(nonce),
-        BCRYPT_USE_SYSTEM_PREFERRED_RNG) != 0)
-  {
-    ec = asio::error::connection_aborted;
-    ::CloseHandle(p[0]);
-    ::CloseHandle(p[1]);
-    return;
-  }
-
-  DWORD bytes_written = 0;
-  BOOL ok = ::WriteFile(p[1], nonce, sizeof(nonce), &bytes_written, 0);
-  if (!ok || bytes_written != sizeof(nonce))
-  {
-    ec = asio::error::connection_aborted;
-    ::CloseHandle(p[0]);
-    ::CloseHandle(p[1]);
-    return;
-  }
-
-  unsigned char nonce_check[sizeof(nonce)];
-  DWORD bytes_read = 0;
-  ok = ::ReadFile(p[0], nonce_check, sizeof(nonce), &bytes_read, 0);
-  if (!ok || bytes_read != sizeof(nonce)
-      || memcmp(nonce, nonce_check, sizeof(nonce)) != 0)
-  {
-    ec = asio::error::connection_aborted;
-    ::CloseHandle(p[0]);
-    ::CloseHandle(p[1]);
-    return;
-  }
-#endif // _WIN32_WINNT >= 0x601
-
-  asio::error::clear(ec);
-#else // defined(ASIO_HAS_IOCP)
-  int result = ::pipe(p);
-  detail::descriptor_ops::get_last_error(ec, result != 0);
-#endif // defined(ASIO_HAS_IOCP)
-}
-
-void close_pipe(native_pipe_handle p)
-{
-#if defined(ASIO_HAS_IOCP)
-  ::CloseHandle(p);
-#else // defined(ASIO_HAS_IOCP)
-  asio::error_code ignored_ec;
-  detail::descriptor_ops::state_type state = 0;
-  detail::descriptor_ops::close(p, state, ignored_ec);
-#endif // defined(ASIO_HAS_IOCP)
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_PIPE)
-
-#endif // ASIO_IMPL_CONNECT_PIPE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/consign.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/consign.hpp
deleted file mode 100644
index d025863..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/consign.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-//
-// impl/consign.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_CONSIGN_HPP
-#define ASIO_IMPL_CONSIGN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Class to adapt a consign_t as a completion handler.
-template <typename Handler, typename... Values>
-class consign_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename H>
-  consign_handler(H&& handler, std::tuple<Values...> values)
-    : handler_(static_cast<H&&>(handler)),
-      values_(static_cast<std::tuple<Values...>&&>(values))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(static_cast<Args&&>(args)...);
-  }
-
-//private:
-  Handler handler_;
-  std::tuple<Values...> values_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    consign_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-      this_handler->handler_);
-}
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename... Values, typename... Signatures>
-struct async_result<consign_t<CompletionToken, Values...>, Signatures...>
-  : async_result<CompletionToken, Signatures...>
-{
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::consign_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::consign_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<CompletionToken, Signatures...>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<CompletionToken, Signatures...>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename... Values, typename DefaultCandidate>
-struct associator<Associator,
-    detail::consign_handler<Handler, Values...>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::consign_handler<Handler, Values...>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::consign_handler<Handler, Values...>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_CONSIGN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/deferred.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/deferred.hpp
deleted file mode 100644
index defc34f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/deferred.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// impl/deferred.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_DEFERRED_HPP
-#define ASIO_IMPL_DEFERRED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Signature>
-class async_result<deferred_t, Signature>
-{
-public:
-  template <typename Initiation, typename... InitArgs>
-  static deferred_async_operation<Signature, Initiation, InitArgs...>
-  initiate(Initiation&& initiation, deferred_t, InitArgs&&... args)
-  {
-    return deferred_async_operation<Signature, Initiation, InitArgs...>(
-        deferred_init_tag{},
-        static_cast<Initiation&&>(initiation),
-        static_cast<InitArgs&&>(args)...);
-  }
-};
-
-template <typename... Signatures>
-class async_result<deferred_t, Signatures...>
-{
-public:
-  template <typename Initiation, typename... InitArgs>
-  static deferred_async_operation<
-      deferred_signatures<Signatures...>, Initiation, InitArgs...>
-  initiate(Initiation&& initiation, deferred_t, InitArgs&&... args)
-  {
-    return deferred_async_operation<
-        deferred_signatures<Signatures...>, Initiation, InitArgs...>(
-          deferred_init_tag{},
-          static_cast<Initiation&&>(initiation),
-          static_cast<InitArgs&&>(args)...);
-  }
-};
-
-template <typename Function, typename Signature>
-class async_result<deferred_function<Function>, Signature>
-{
-public:
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation&& initiation,
-      deferred_function<Function> token, InitArgs&&... init_args)
-    -> decltype(
-        deferred_sequence<
-          deferred_async_operation<
-            Signature, Initiation, InitArgs...>,
-          Function>(deferred_init_tag{},
-            deferred_async_operation<
-              Signature, Initiation, InitArgs...>(
-                deferred_init_tag{},
-                static_cast<Initiation&&>(initiation),
-                static_cast<InitArgs&&>(init_args)...),
-            static_cast<Function&&>(token.function_)))
-  {
-    return deferred_sequence<
-        deferred_async_operation<
-          Signature, Initiation, InitArgs...>,
-        Function>(deferred_init_tag{},
-          deferred_async_operation<
-            Signature, Initiation, InitArgs...>(
-              deferred_init_tag{},
-              static_cast<Initiation&&>(initiation),
-              static_cast<InitArgs&&>(init_args)...),
-          static_cast<Function&&>(token.function_));
-  }
-};
-
-template <typename Function, typename... Signatures>
-class async_result<deferred_function<Function>, Signatures...>
-{
-public:
-  template <typename Initiation, typename... InitArgs>
-  static auto initiate(Initiation&& initiation,
-      deferred_function<Function> token, InitArgs&&... init_args)
-    -> decltype(
-        deferred_sequence<
-          deferred_async_operation<
-            deferred_signatures<Signatures...>, Initiation, InitArgs...>,
-          Function>(deferred_init_tag{},
-            deferred_async_operation<
-              deferred_signatures<Signatures...>, Initiation, InitArgs...>(
-                deferred_init_tag{},
-                static_cast<Initiation&&>(initiation),
-                static_cast<InitArgs&&>(init_args)...),
-            static_cast<Function&&>(token.function_)))
-  {
-    return deferred_sequence<
-        deferred_async_operation<
-          deferred_signatures<Signatures...>, Initiation, InitArgs...>,
-        Function>(deferred_init_tag{},
-          deferred_async_operation<
-            deferred_signatures<Signatures...>, Initiation, InitArgs...>(
-              deferred_init_tag{},
-              static_cast<Initiation&&>(initiation),
-              static_cast<InitArgs&&>(init_args)...),
-          static_cast<Function&&>(token.function_));
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename Tail, typename DefaultCandidate>
-struct associator<Associator,
-    detail::deferred_sequence_handler<Handler, Tail>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::deferred_sequence_handler<Handler, Tail>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::deferred_sequence_handler<Handler, Tail>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_DEFERRED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/detached.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/detached.hpp
deleted file mode 100644
index 1269bc6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/detached.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// impl/detached.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_DETACHED_HPP
-#define ASIO_IMPL_DETACHED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-  // Class to adapt a detached_t as a completion handler.
-  class detached_handler
-  {
-  public:
-    typedef void result_type;
-
-    detached_handler(detached_t)
-    {
-    }
-
-    template <typename... Args>
-    void operator()(Args...)
-    {
-    }
-  };
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename... Signatures>
-struct async_result<detached_t, Signatures...>
-{
-  typedef asio::detail::detached_handler completion_handler_type;
-
-  typedef void return_type;
-
-  explicit async_result(completion_handler_type&)
-  {
-  }
-
-  void get()
-  {
-  }
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static return_type initiate(Initiation&& initiation,
-      RawCompletionToken&&, Args&&... args)
-  {
-    static_cast<Initiation&&>(initiation)(
-        detail::detached_handler(detached_t()),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_DETACHED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error.ipp
deleted file mode 100644
index b564a8c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error.ipp
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// impl/error.ipp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_ERROR_IPP
-#define ASIO_IMPL_ERROR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace error {
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-namespace detail {
-
-class netdb_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.netdb";
-  }
-
-  std::string message(int value) const
-  {
-    if (value == error::host_not_found)
-      return "Host not found (authoritative)";
-    if (value == error::host_not_found_try_again)
-      return "Host not found (non-authoritative), try again later";
-    if (value == error::no_data)
-      return "The query is valid, but it does not have associated data";
-    if (value == error::no_recovery)
-      return "A non-recoverable error occurred during database lookup";
-    return "asio.netdb error";
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_netdb_category()
-{
-  static detail::netdb_category instance;
-  return instance;
-}
-
-namespace detail {
-
-class addrinfo_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.addrinfo";
-  }
-
-  std::string message(int value) const
-  {
-    if (value == error::service_not_found)
-      return "Service not found";
-    if (value == error::socket_type_not_supported)
-      return "Socket type not supported";
-    return "asio.addrinfo error";
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_addrinfo_category()
-{
-  static detail::addrinfo_category instance;
-  return instance;
-}
-
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-namespace detail {
-
-class misc_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.misc";
-  }
-
-  std::string message(int value) const
-  {
-    if (value == error::already_open)
-      return "Already open";
-    if (value == error::eof)
-      return "End of file";
-    if (value == error::not_found)
-      return "Element not found";
-    if (value == error::fd_set_failure)
-      return "The descriptor does not fit into the select call's fd_set";
-    return "asio.misc error";
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_misc_category()
-{
-  static detail::misc_category instance;
-  return instance;
-}
-
-} // namespace error
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_ERROR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error_code.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error_code.ipp
deleted file mode 100644
index caeb196..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/error_code.ipp
+++ /dev/null
@@ -1,206 +0,0 @@
-//
-// impl/error_code.ipp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_ERROR_CODE_IPP
-#define ASIO_IMPL_ERROR_CODE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include <winerror.h>
-#elif defined(ASIO_WINDOWS_RUNTIME)
-# include <windows.h>
-#else
-# include <cerrno>
-# include <cstring>
-# include <string>
-#endif
-#include "asio/detail/local_free_on_block_exit.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class system_category : public error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.system";
-  }
-
-  std::string message(int value) const
-  {
-#if defined(ASIO_WINDOWS_RUNTIME) || defined(ASIO_WINDOWS_APP)
-    std::wstring wmsg(128, wchar_t());
-    for (;;)
-    {
-      DWORD wlength = ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM
-          | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value,
-          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-          &wmsg[0], static_cast<DWORD>(wmsg.size()), 0);
-      if (wlength == 0 && ::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
-      {
-        wmsg.resize(wmsg.size() + wmsg.size() / 2);
-        continue;
-      }
-      if (wlength && wmsg[wlength - 1] == '\n')
-        --wlength;
-      if (wlength && wmsg[wlength - 1] == '\r')
-        --wlength;
-      if (wlength)
-      {
-        std::string msg(wlength * 2, char());
-        int length = ::WideCharToMultiByte(CP_ACP, 0,
-            wmsg.c_str(), static_cast<int>(wlength),
-            &msg[0], static_cast<int>(wlength * 2), 0, 0);
-        if (length <= 0)
-          return "asio.system error";
-        msg.resize(static_cast<std::size_t>(length));
-        return msg;
-      }
-      else
-        return "asio.system error";
-    }
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    char* msg = 0;
-    DWORD length = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
-        | FORMAT_MESSAGE_FROM_SYSTEM
-        | FORMAT_MESSAGE_IGNORE_INSERTS, 0, value,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, 0);
-    detail::local_free_on_block_exit local_free_obj(msg);
-    if (length && msg[length - 1] == '\n')
-      msg[--length] = '\0';
-    if (length && msg[length - 1] == '\r')
-      msg[--length] = '\0';
-    if (length)
-      return msg;
-    else
-      return "asio.system error";
-#else // defined(ASIO_WINDOWS_DESKTOP) || defined(__CYGWIN__)
-#if !defined(__sun)
-    if (value == ECANCELED)
-      return "Operation aborted.";
-#endif // !defined(__sun)
-#if defined(__sun) || defined(__QNX__) || defined(__SYMBIAN32__)
-    using namespace std;
-    return strerror(value);
-#else
-    char buf[256] = "";
-    using namespace std;
-    return strerror_result(strerror_r(value, buf, sizeof(buf)), buf);
-#endif
-#endif // defined(ASIO_WINDOWS_DESKTOP) || defined(__CYGWIN__)
-  }
-
-#if defined(ASIO_HAS_STD_ERROR_CODE)
-  std::error_condition default_error_condition(
-      int ev) const noexcept
-  {
-    switch (ev)
-    {
-    case access_denied:
-      return std::errc::permission_denied;
-    case address_family_not_supported:
-      return std::errc::address_family_not_supported;
-    case address_in_use:
-      return std::errc::address_in_use;
-    case already_connected:
-      return std::errc::already_connected;
-    case already_started:
-      return std::errc::connection_already_in_progress;
-    case broken_pipe:
-      return std::errc::broken_pipe;
-    case connection_aborted:
-      return std::errc::connection_aborted;
-    case connection_refused:
-      return std::errc::connection_refused;
-    case connection_reset:
-      return std::errc::connection_reset;
-    case bad_descriptor:
-      return std::errc::bad_file_descriptor;
-    case fault:
-      return std::errc::bad_address;
-    case host_unreachable:
-      return std::errc::host_unreachable;
-    case in_progress:
-      return std::errc::operation_in_progress;
-    case interrupted:
-      return std::errc::interrupted;
-    case invalid_argument:
-      return std::errc::invalid_argument;
-    case message_size:
-      return std::errc::message_size;
-    case name_too_long:
-      return std::errc::filename_too_long;
-    case network_down:
-      return std::errc::network_down;
-    case network_reset:
-      return std::errc::network_reset;
-    case network_unreachable:
-      return std::errc::network_unreachable;
-    case no_descriptors:
-      return std::errc::too_many_files_open;
-    case no_buffer_space:
-      return std::errc::no_buffer_space;
-    case no_memory:
-      return std::errc::not_enough_memory;
-    case no_permission:
-      return std::errc::operation_not_permitted;
-    case no_protocol_option:
-      return std::errc::no_protocol_option;
-    case no_such_device:
-      return std::errc::no_such_device;
-    case not_connected:
-      return std::errc::not_connected;
-    case not_socket:
-      return std::errc::not_a_socket;
-    case operation_aborted:
-      return std::errc::operation_canceled;
-    case operation_not_supported:
-      return std::errc::operation_not_supported;
-    case shut_down:
-      return std::make_error_condition(ev, *this);
-    case timed_out:
-      return std::errc::timed_out;
-    case try_again:
-      return std::errc::resource_unavailable_try_again;
-    case would_block:
-      return std::errc::operation_would_block;
-    default:
-      return std::make_error_condition(ev, *this);
-  }
-#endif // defined(ASIO_HAS_STD_ERROR_CODE)
-
-private:
-  // Helper function to adapt the result from glibc's variant of strerror_r.
-  static const char* strerror_result(int, const char* s) { return s; }
-  static const char* strerror_result(const char* s, const char*) { return s; }
-};
-
-} // namespace detail
-
-const error_category& system_category()
-{
-  static detail::system_category instance;
-  return instance;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_ERROR_CODE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.hpp
deleted file mode 100644
index 35dda80..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// impl/execution_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXECUTION_CONTEXT_HPP
-#define ASIO_IMPL_EXECUTION_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/service_registry.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Service>
-inline Service& use_service(execution_context& e)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
-
-  return e.service_registry_->template use_service<Service>();
-}
-
-template <typename Service, typename... Args>
-Service& make_service(execution_context& e, Args&&... args)
-{
-  detail::scoped_ptr<Service> svc(
-      new Service(e, static_cast<Args&&>(args)...));
-  e.service_registry_->template add_service<Service>(svc.get());
-  Service& result = *svc;
-  svc.release();
-  return result;
-}
-
-template <typename Service>
-inline void add_service(execution_context& e, Service* svc)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
-
-  e.service_registry_->template add_service<Service>(svc);
-}
-
-template <typename Service>
-inline bool has_service(execution_context& e)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
-
-  return e.service_registry_->template has_service<Service>();
-}
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-inline execution_context& execution_context::service::context()
-{
-  return owner_;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_EXECUTION_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.ipp
deleted file mode 100644
index ed2603c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/execution_context.ipp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// impl/execution_context.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXECUTION_CONTEXT_IPP
-#define ASIO_IMPL_EXECUTION_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/service_registry.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-execution_context::execution_context()
-  : service_registry_(new asio::detail::service_registry(*this))
-{
-}
-
-execution_context::~execution_context()
-{
-  shutdown();
-  destroy();
-  delete service_registry_;
-}
-
-void execution_context::shutdown()
-{
-  service_registry_->shutdown_services();
-}
-
-void execution_context::destroy()
-{
-  service_registry_->destroy_services();
-}
-
-void execution_context::notify_fork(
-    asio::execution_context::fork_event event)
-{
-  service_registry_->notify_fork(event);
-}
-
-execution_context::service::service(execution_context& owner)
-  : owner_(owner),
-    next_(0)
-{
-}
-
-execution_context::service::~service()
-{
-}
-
-void execution_context::service::notify_fork(execution_context::fork_event)
-{
-}
-
-service_already_exists::service_already_exists()
-  : std::logic_error("Service already exists.")
-{
-}
-
-invalid_service_owner::invalid_service_owner()
-  : std::logic_error("Invalid service owner.")
-{
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_EXECUTION_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.hpp
deleted file mode 100644
index 8bf76cc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.hpp
+++ /dev/null
@@ -1,317 +0,0 @@
-//
-// impl/executor.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXECUTOR_HPP
-#define ASIO_IMPL_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-#include <new>
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/global.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/executor.hpp"
-#include "asio/system_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-// Default polymorphic executor implementation.
-template <typename Executor, typename Allocator>
-class executor::impl
-  : public executor::impl_base
-{
-public:
-  typedef ASIO_REBIND_ALLOC(Allocator, impl) allocator_type;
-
-  static impl_base* create(const Executor& e, Allocator a = Allocator())
-  {
-    raw_mem mem(a);
-    impl* p = new (mem.ptr_) impl(e, a);
-    mem.ptr_ = 0;
-    return p;
-  }
-
-  static impl_base* create(std::nothrow_t, const Executor& e) noexcept
-  {
-    return new (std::nothrow) impl(e, std::allocator<void>());
-  }
-
-  impl(const Executor& e, const Allocator& a) noexcept
-    : impl_base(false),
-      ref_count_(1),
-      executor_(e),
-      allocator_(a)
-  {
-  }
-
-  impl_base* clone() const noexcept
-  {
-    detail::ref_count_up(ref_count_);
-    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
-  }
-
-  void destroy() noexcept
-  {
-    if (detail::ref_count_down(ref_count_))
-    {
-      allocator_type alloc(allocator_);
-      impl* p = this;
-      p->~impl();
-      alloc.deallocate(p, 1);
-    }
-  }
-
-  void on_work_started() noexcept
-  {
-    executor_.on_work_started();
-  }
-
-  void on_work_finished() noexcept
-  {
-    executor_.on_work_finished();
-  }
-
-  execution_context& context() noexcept
-  {
-    return executor_.context();
-  }
-
-  void dispatch(function&& f)
-  {
-    executor_.dispatch(static_cast<function&&>(f), allocator_);
-  }
-
-  void post(function&& f)
-  {
-    executor_.post(static_cast<function&&>(f), allocator_);
-  }
-
-  void defer(function&& f)
-  {
-    executor_.defer(static_cast<function&&>(f), allocator_);
-  }
-
-  type_id_result_type target_type() const noexcept
-  {
-    return type_id<Executor>();
-  }
-
-  void* target() noexcept
-  {
-    return &executor_;
-  }
-
-  const void* target() const noexcept
-  {
-    return &executor_;
-  }
-
-  bool equals(const impl_base* e) const noexcept
-  {
-    if (this == e)
-      return true;
-    if (target_type() != e->target_type())
-      return false;
-    return executor_ == *static_cast<const Executor*>(e->target());
-  }
-
-private:
-  mutable detail::atomic_count ref_count_;
-  Executor executor_;
-  Allocator allocator_;
-
-  struct raw_mem
-  {
-    allocator_type allocator_;
-    impl* ptr_;
-
-    explicit raw_mem(const Allocator& a)
-      : allocator_(a),
-        ptr_(allocator_.allocate(1))
-    {
-    }
-
-    ~raw_mem()
-    {
-      if (ptr_)
-        allocator_.deallocate(ptr_, 1);
-    }
-
-  private:
-    // Disallow copying and assignment.
-    raw_mem(const raw_mem&);
-    raw_mem operator=(const raw_mem&);
-  };
-};
-
-// Polymorphic executor specialisation for system_executor.
-template <typename Allocator>
-class executor::impl<system_executor, Allocator>
-  : public executor::impl_base
-{
-public:
-  static impl_base* create(const system_executor&,
-      const Allocator& = Allocator())
-  {
-    return &detail::global<impl<system_executor, std::allocator<void>> >();
-  }
-
-  static impl_base* create(std::nothrow_t, const system_executor&) noexcept
-  {
-    return &detail::global<impl<system_executor, std::allocator<void>> >();
-  }
-
-  impl()
-    : impl_base(true)
-  {
-  }
-
-  impl_base* clone() const noexcept
-  {
-    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
-  }
-
-  void destroy() noexcept
-  {
-  }
-
-  void on_work_started() noexcept
-  {
-    executor_.on_work_started();
-  }
-
-  void on_work_finished() noexcept
-  {
-    executor_.on_work_finished();
-  }
-
-  execution_context& context() noexcept
-  {
-    return executor_.context();
-  }
-
-  void dispatch(function&& f)
-  {
-    executor_.dispatch(static_cast<function&&>(f),
-        std::allocator<void>());
-  }
-
-  void post(function&& f)
-  {
-    executor_.post(static_cast<function&&>(f),
-        std::allocator<void>());
-  }
-
-  void defer(function&& f)
-  {
-    executor_.defer(static_cast<function&&>(f),
-        std::allocator<void>());
-  }
-
-  type_id_result_type target_type() const noexcept
-  {
-    return type_id<system_executor>();
-  }
-
-  void* target() noexcept
-  {
-    return &executor_;
-  }
-
-  const void* target() const noexcept
-  {
-    return &executor_;
-  }
-
-  bool equals(const impl_base* e) const noexcept
-  {
-    return this == e;
-  }
-
-private:
-  system_executor executor_;
-};
-
-template <typename Executor>
-executor::executor(Executor e)
-  : impl_(impl<Executor, std::allocator<void>>::create(e))
-{
-}
-
-template <typename Executor>
-executor::executor(std::nothrow_t, Executor e) noexcept
-  : impl_(impl<Executor, std::allocator<void>>::create(std::nothrow, e))
-{
-}
-
-template <typename Executor, typename Allocator>
-executor::executor(allocator_arg_t, const Allocator& a, Executor e)
-  : impl_(impl<Executor, Allocator>::create(e, a))
-{
-}
-
-template <typename Function, typename Allocator>
-void executor::dispatch(Function&& f,
-    const Allocator& a) const
-{
-  impl_base* i = get_impl();
-  if (i->fast_dispatch_)
-    system_executor().dispatch(static_cast<Function&&>(f), a);
-  else
-    i->dispatch(function(static_cast<Function&&>(f), a));
-}
-
-template <typename Function, typename Allocator>
-void executor::post(Function&& f,
-    const Allocator& a) const
-{
-  get_impl()->post(function(static_cast<Function&&>(f), a));
-}
-
-template <typename Function, typename Allocator>
-void executor::defer(Function&& f,
-    const Allocator& a) const
-{
-  get_impl()->defer(function(static_cast<Function&&>(f), a));
-}
-
-template <typename Executor>
-Executor* executor::target() noexcept
-{
-  return impl_ && impl_->target_type() == type_id<Executor>()
-    ? static_cast<Executor*>(impl_->target()) : 0;
-}
-
-template <typename Executor>
-const Executor* executor::target() const noexcept
-{
-  return impl_ && impl_->target_type() == type_id<Executor>()
-    ? static_cast<Executor*>(impl_->target()) : 0;
-}
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-#endif // ASIO_IMPL_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.ipp
deleted file mode 100644
index 4153a17..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/executor.ipp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// impl/executor.ipp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_EXECUTOR_IPP
-#define ASIO_IMPL_EXECUTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-#include "asio/executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-bad_executor::bad_executor() noexcept
-{
-}
-
-const char* bad_executor::what() const noexcept
-{
-  return "bad executor";
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-#endif // ASIO_IMPL_EXECUTOR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.hpp
deleted file mode 100644
index 002b585..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.hpp
+++ /dev/null
@@ -1,433 +0,0 @@
-//
-// impl/io_context.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_IO_CONTEXT_HPP
-#define ASIO_IMPL_IO_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/service_registry.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Service>
-inline Service& use_service(io_context& ioc)
-{
-  // Check that Service meets the necessary type requirements.
-  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
-  (void)static_cast<const execution_context::id*>(&Service::id);
-
-  return ioc.service_registry_->template use_service<Service>(ioc);
-}
-
-template <>
-inline detail::io_context_impl& use_service<detail::io_context_impl>(
-    io_context& ioc)
-{
-  return ioc.impl_;
-}
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-inline io_context::executor_type
-io_context::get_executor() noexcept
-{
-  return executor_type(*this);
-}
-
-template <typename Rep, typename Period>
-std::size_t io_context::run_for(
-    const chrono::duration<Rep, Period>& rel_time)
-{
-  return this->run_until(chrono::steady_clock::now() + rel_time);
-}
-
-template <typename Clock, typename Duration>
-std::size_t io_context::run_until(
-    const chrono::time_point<Clock, Duration>& abs_time)
-{
-  std::size_t n = 0;
-  while (this->run_one_until(abs_time))
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-
-template <typename Rep, typename Period>
-std::size_t io_context::run_one_for(
-    const chrono::duration<Rep, Period>& rel_time)
-{
-  return this->run_one_until(chrono::steady_clock::now() + rel_time);
-}
-
-template <typename Clock, typename Duration>
-std::size_t io_context::run_one_until(
-    const chrono::time_point<Clock, Duration>& abs_time)
-{
-  typename Clock::time_point now = Clock::now();
-  while (now < abs_time)
-  {
-    typename Clock::duration rel_time = abs_time - now;
-    if (rel_time > chrono::seconds(1))
-      rel_time = chrono::seconds(1);
-
-    asio::error_code ec;
-    std::size_t s = impl_.wait_one(
-        static_cast<long>(chrono::duration_cast<
-          chrono::microseconds>(rel_time).count()), ec);
-    asio::detail::throw_error(ec);
-
-    if (s || impl_.stopped())
-      return s;
-
-    now = Clock::now();
-  }
-
-  return 0;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-inline void io_context::reset()
-{
-  restart();
-}
-
-struct io_context::initiate_dispatch
-{
-  template <typename LegacyCompletionHandler>
-  void operator()(LegacyCompletionHandler&& handler,
-      io_context* self) const
-  {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a LegacyCompletionHandler.
-    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-        LegacyCompletionHandler, handler) type_check;
-
-    detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-    if (self->impl_.can_dispatch())
-    {
-      detail::fenced_block b(detail::fenced_block::full);
-      static_cast<decay_t<LegacyCompletionHandler>&&>(handler2.value)();
-    }
-    else
-    {
-      // Allocate and construct an operation to wrap the handler.
-      typedef detail::completion_handler<
-        decay_t<LegacyCompletionHandler>, executor_type> op;
-      typename op::ptr p = { detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-      p.p = new (p.v) op(handler2.value, self->get_executor());
-
-      ASIO_HANDLER_CREATION((*self, *p.p,
-            "io_context", self, 0, "dispatch"));
-
-      self->impl_.do_dispatch(p.p);
-      p.v = p.p = 0;
-    }
-  }
-};
-
-template <typename LegacyCompletionHandler>
-auto io_context::dispatch(LegacyCompletionHandler&& handler)
-  -> decltype(
-    async_initiate<LegacyCompletionHandler, void ()>(
-      declval<initiate_dispatch>(), handler, this))
-{
-  return async_initiate<LegacyCompletionHandler, void ()>(
-      initiate_dispatch(), handler, this);
-}
-
-struct io_context::initiate_post
-{
-  template <typename LegacyCompletionHandler>
-  void operator()(LegacyCompletionHandler&& handler,
-      io_context* self) const
-  {
-    // If you get an error on the following line it means that your handler does
-    // not meet the documented type requirements for a LegacyCompletionHandler.
-    ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-        LegacyCompletionHandler, handler) type_check;
-
-    detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-
-    bool is_continuation =
-      asio_handler_cont_helpers::is_continuation(handler2.value);
-
-    // Allocate and construct an operation to wrap the handler.
-    typedef detail::completion_handler<
-      decay_t<LegacyCompletionHandler>, executor_type> op;
-    typename op::ptr p = { detail::addressof(handler2.value),
-        op::ptr::allocate(handler2.value), 0 };
-    p.p = new (p.v) op(handler2.value, self->get_executor());
-
-    ASIO_HANDLER_CREATION((*self, *p.p,
-          "io_context", self, 0, "post"));
-
-    self->impl_.post_immediate_completion(p.p, is_continuation);
-    p.v = p.p = 0;
-  }
-};
-
-template <typename LegacyCompletionHandler>
-auto io_context::post(LegacyCompletionHandler&& handler)
-  -> decltype(
-    async_initiate<LegacyCompletionHandler, void ()>(
-      declval<initiate_post>(), handler, this))
-{
-  return async_initiate<LegacyCompletionHandler, void ()>(
-      initiate_post(), handler, this);
-}
-
-template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-unspecified
-#else
-inline detail::wrapped_handler<io_context&, Handler>
-#endif
-io_context::wrap(Handler handler)
-{
-  return detail::wrapped_handler<io_context&, Handler>(*this, handler);
-}
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Allocator, uintptr_t Bits>
-io_context::basic_executor_type<Allocator, Bits>&
-io_context::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) noexcept
-{
-  if (this != &other)
-  {
-    static_cast<Allocator&>(*this) = static_cast<const Allocator&>(other);
-    io_context* old_io_context = context_ptr();
-    target_ = other.target_;
-    if (Bits & outstanding_work_tracked)
-    {
-      if (context_ptr())
-        context_ptr()->impl_.work_started();
-      if (old_io_context)
-        old_io_context->impl_.work_finished();
-    }
-  }
-  return *this;
-}
-
-template <typename Allocator, uintptr_t Bits>
-io_context::basic_executor_type<Allocator, Bits>&
-io_context::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) noexcept
-{
-  if (this != &other)
-  {
-    static_cast<Allocator&>(*this) = static_cast<Allocator&&>(other);
-    io_context* old_io_context = context_ptr();
-    target_ = other.target_;
-    if (Bits & outstanding_work_tracked)
-    {
-      other.target_ = 0;
-      if (old_io_context)
-        old_io_context->impl_.work_finished();
-    }
-  }
-  return *this;
-}
-
-template <typename Allocator, uintptr_t Bits>
-inline bool io_context::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const noexcept
-{
-  return context_ptr()->impl_.can_dispatch();
-}
-
-template <typename Allocator, uintptr_t Bits>
-template <typename Function>
-void io_context::basic_executor_type<Allocator, Bits>::execute(
-    Function&& f) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Invoke immediately if the blocking.possibly property is enabled and we are
-  // already inside the thread pool.
-  if ((bits() & blocking_never) == 0 && context_ptr()->impl_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(f));
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      static_cast<function_type&&>(tmp)();
-      return;
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      context_ptr()->impl_.capture_current_exception();
-      return;
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
-  typename op::ptr p = {
-      detail::addressof(static_cast<const Allocator&>(*this)),
-      op::ptr::allocate(static_cast<const Allocator&>(*this)), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f),
-      static_cast<const Allocator&>(*this));
-
-  ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
-        "io_context", context_ptr(), 0, "execute"));
-
-  context_ptr()->impl_.post_immediate_completion(p.p,
-      (bits() & relationship_continuation) != 0);
-  p.v = p.p = 0;
-}
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-template <typename Allocator, uintptr_t Bits>
-inline io_context& io_context::basic_executor_type<
-    Allocator, Bits>::context() const noexcept
-{
-  return *context_ptr();
-}
-
-template <typename Allocator, uintptr_t Bits>
-inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_started() const noexcept
-{
-  context_ptr()->impl_.work_started();
-}
-
-template <typename Allocator, uintptr_t Bits>
-inline void io_context::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const noexcept
-{
-  context_ptr()->impl_.work_finished();
-}
-
-template <typename Allocator, uintptr_t Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::dispatch(
-    Function&& f, const OtherAllocator& a) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Invoke immediately if we are already inside the thread pool.
-  if (context_ptr()->impl_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(f));
-
-    detail::fenced_block b(detail::fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
-        "io_context", context_ptr(), 0, "dispatch"));
-
-  context_ptr()->impl_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
-template <typename Allocator, uintptr_t Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::post(
-    Function&& f, const OtherAllocator& a) const
-{
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<decay_t<Function>,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
-        "io_context", context_ptr(), 0, "post"));
-
-  context_ptr()->impl_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
-template <typename Allocator, uintptr_t Bits>
-template <typename Function, typename OtherAllocator>
-void io_context::basic_executor_type<Allocator, Bits>::defer(
-    Function&& f, const OtherAllocator& a) const
-{
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<decay_t<Function>,
-      OtherAllocator, detail::operation> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*context_ptr(), *p.p,
-        "io_context", context_ptr(), 0, "defer"));
-
-  context_ptr()->impl_.post_immediate_completion(p.p, true);
-  p.v = p.p = 0;
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-#if !defined(ASIO_NO_DEPRECATED)
-inline io_context::work::work(asio::io_context& io_context)
-  : io_context_impl_(io_context.impl_)
-{
-  io_context_impl_.work_started();
-}
-
-inline io_context::work::work(const work& other)
-  : io_context_impl_(other.io_context_impl_)
-{
-  io_context_impl_.work_started();
-}
-
-inline io_context::work::~work()
-{
-  io_context_impl_.work_finished();
-}
-
-inline asio::io_context& io_context::work::get_io_context()
-{
-  return static_cast<asio::io_context&>(io_context_impl_.context());
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-inline asio::io_context& io_context::service::get_io_context()
-{
-  return static_cast<asio::io_context&>(context());
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_IO_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.ipp
deleted file mode 100644
index 14c8736..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/io_context.ipp
+++ /dev/null
@@ -1,176 +0,0 @@
-//
-// impl/io_context.ipp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_IO_CONTEXT_IPP
-#define ASIO_IMPL_IO_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/io_context.hpp"
-#include "asio/detail/concurrency_hint.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/scoped_ptr.hpp"
-#include "asio/detail/service_registry.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else
-# include "asio/detail/scheduler.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-io_context::io_context()
-  : impl_(add_impl(new impl_type(*this,
-          ASIO_CONCURRENCY_HINT_DEFAULT, false)))
-{
-}
-
-io_context::io_context(int concurrency_hint)
-  : impl_(add_impl(new impl_type(*this, concurrency_hint == 1
-          ? ASIO_CONCURRENCY_HINT_1 : concurrency_hint, false)))
-{
-}
-
-io_context::impl_type& io_context::add_impl(io_context::impl_type* impl)
-{
-  asio::detail::scoped_ptr<impl_type> scoped_impl(impl);
-  asio::add_service<impl_type>(*this, scoped_impl.get());
-  return *scoped_impl.release();
-}
-
-io_context::~io_context()
-{
-  shutdown();
-}
-
-io_context::count_type io_context::run()
-{
-  asio::error_code ec;
-  count_type s = impl_.run(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-io_context::count_type io_context::run(asio::error_code& ec)
-{
-  return impl_.run(ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-io_context::count_type io_context::run_one()
-{
-  asio::error_code ec;
-  count_type s = impl_.run_one(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-io_context::count_type io_context::run_one(asio::error_code& ec)
-{
-  return impl_.run_one(ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-io_context::count_type io_context::poll()
-{
-  asio::error_code ec;
-  count_type s = impl_.poll(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-io_context::count_type io_context::poll(asio::error_code& ec)
-{
-  return impl_.poll(ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-io_context::count_type io_context::poll_one()
-{
-  asio::error_code ec;
-  count_type s = impl_.poll_one(ec);
-  asio::detail::throw_error(ec);
-  return s;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-io_context::count_type io_context::poll_one(asio::error_code& ec)
-{
-  return impl_.poll_one(ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-void io_context::stop()
-{
-  impl_.stop();
-}
-
-bool io_context::stopped() const
-{
-  return impl_.stopped();
-}
-
-void io_context::restart()
-{
-  impl_.restart();
-}
-
-io_context::service::service(asio::io_context& owner)
-  : execution_context::service(owner)
-{
-}
-
-io_context::service::~service()
-{
-}
-
-void io_context::service::shutdown()
-{
-#if !defined(ASIO_NO_DEPRECATED)
-  shutdown_service();
-#endif // !defined(ASIO_NO_DEPRECATED)
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-void io_context::service::shutdown_service()
-{
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-void io_context::service::notify_fork(io_context::fork_event ev)
-{
-#if !defined(ASIO_NO_DEPRECATED)
-  fork_service(ev);
-#else // !defined(ASIO_NO_DEPRECATED)
-  (void)ev;
-#endif // !defined(ASIO_NO_DEPRECATED)
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-void io_context::service::fork_service(io_context::fork_event)
-{
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_IO_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/multiple_exceptions.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/multiple_exceptions.ipp
deleted file mode 100644
index c922c27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/multiple_exceptions.ipp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// impl/multiple_exceptions.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_MULTIPLE_EXCEPTIONS_IPP
-#define ASIO_IMPL_MULTIPLE_EXCEPTIONS_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/multiple_exceptions.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-multiple_exceptions::multiple_exceptions(
-    std::exception_ptr first) noexcept
-  : first_(static_cast<std::exception_ptr&&>(first))
-{
-}
-
-const char* multiple_exceptions::what() const noexcept
-{
-  return "multiple exceptions";
-}
-
-std::exception_ptr multiple_exceptions::first_exception() const
-{
-  return first_;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_MULTIPLE_EXCEPTIONS_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/prepend.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/prepend.hpp
deleted file mode 100644
index 4a6f5bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/prepend.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-//
-// impl/prepend.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_PREPEND_HPP
-#define ASIO_IMPL_PREPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Class to adapt a prepend_t as a completion handler.
-template <typename Handler, typename... Values>
-class prepend_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename H>
-  prepend_handler(H&& handler, std::tuple<Values...> values)
-    : handler_(static_cast<H&&>(handler)),
-      values_(static_cast<std::tuple<Values...>&&>(values))
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    this->invoke(
-        index_sequence_for<Values...>{},
-        static_cast<Args&&>(args)...);
-  }
-
-  template <std::size_t... I, typename... Args>
-  void invoke(index_sequence<I...>, Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<Values&&>(std::get<I>(values_))...,
-        static_cast<Args&&>(args)...);
-  }
-
-//private:
-  Handler handler_;
-  std::tuple<Values...> values_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    prepend_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Signature, typename... Values>
-struct prepend_signature;
-
-template <typename R, typename... Args, typename... Values>
-struct prepend_signature<R(Args...), Values...>
-{
-  typedef R type(Values..., decay_t<Args>...);
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename... Values, typename Signature>
-struct async_result<
-    prepend_t<CompletionToken, Values...>, Signature>
-  : async_result<CompletionToken,
-      typename detail::prepend_signature<
-        Signature, Values...>::type>
-{
-  typedef typename detail::prepend_signature<
-      Signature, Values...>::type signature;
-
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::prepend_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        std::tuple<Values...> values, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::prepend_handler<decay_t<Handler>, Values...>(
-            static_cast<Handler&&>(handler),
-            static_cast<std::tuple<Values...>&&>(values)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<CompletionToken, signature>(
-        declval<init_wrapper<decay_t<Initiation>>>(),
-        token.token_,
-        static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<CompletionToken, signature>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_,
-        static_cast<std::tuple<Values...>&&>(token.values_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename... Values, typename DefaultCandidate>
-struct associator<Associator,
-    detail::prepend_handler<Handler, Values...>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::prepend_handler<Handler, Values...>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::prepend_handler<Handler, Values...>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_PREPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read.hpp
deleted file mode 100644
index f77a152..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read.hpp
+++ /dev/null
@@ -1,902 +0,0 @@
-//
-// impl/read.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_READ_HPP
-#define ASIO_IMPL_READ_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <algorithm>
-#include "asio/associator.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/base_from_completion_cond.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/consuming_buffers.hpp"
-#include "asio/detail/dependent_type.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <typename SyncReadStream, typename MutableBufferSequence,
-      typename MutableBufferIterator, typename CompletionCondition>
-  std::size_t read_buffer_seq(SyncReadStream& s,
-      const MutableBufferSequence& buffers, const MutableBufferIterator&,
-      CompletionCondition completion_condition, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    asio::detail::consuming_buffers<mutable_buffer,
-        MutableBufferSequence, MutableBufferIterator> 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.read_some(tmp.prepare(max_size), ec));
-      else
-        break;
-    }
-    return tmp.total_consumed();
-  }
-} // namespace detail
-
-template <typename SyncReadStream, typename MutableBufferSequence,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return detail::read_buffer_seq(s, buffers,
-      asio::buffer_sequence_begin(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncReadStream, typename MutableBufferSequence>
-inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename MutableBufferSequence>
-inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    >)
-{
-  return read(s, buffers, transfer_all(), ec);
-}
-
-template <typename SyncReadStream, typename MutableBufferSequence,
-    typename CompletionCondition>
-inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s, buffers,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  ec = asio::error_code();
-  std::size_t total_transferred = 0;
-  std::size_t max_size = detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred));
-  std::size_t bytes_available = std::min<std::size_t>(
-        std::max<std::size_t>(512, b.capacity() - b.size()),
-        std::min<std::size_t>(max_size, b.max_size() - b.size()));
-  while (bytes_available > 0)
-  {
-    std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
-    b.commit(bytes_transferred);
-    total_transferred += bytes_transferred;
-    max_size = detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred));
-    bytes_available = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(max_size, b.max_size() - b.size()));
-  }
-  return total_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-inline std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s,
-      static_cast<DynamicBuffer_v1&&>(buffers), transfer_all(), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-inline std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  return read(s, static_cast<DynamicBuffer_v1&&>(buffers),
-      transfer_all(), ec);
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-inline std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s,
-      static_cast<DynamicBuffer_v1&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncReadStream, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return read(s, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b)
-{
-  return read(s, basic_streambuf_ref<Allocator>(b));
-}
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    asio::error_code& ec)
-{
-  return read(s, basic_streambuf_ref<Allocator>(b), ec);
-}
-
-template <typename SyncReadStream, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t read(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return read(s, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  DynamicBuffer_v2& b = buffers;
-
-  ec = asio::error_code();
-  std::size_t total_transferred = 0;
-  std::size_t max_size = detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred));
-  std::size_t bytes_available = std::min<std::size_t>(
-        std::max<std::size_t>(512, b.capacity() - b.size()),
-        std::min<std::size_t>(max_size, b.max_size() - b.size()));
-  while (bytes_available > 0)
-  {
-    std::size_t pos = b.size();
-    b.grow(bytes_available);
-    std::size_t bytes_transferred = s.read_some(
-        b.data(pos, bytes_available), ec);
-    b.shrink(bytes_available - bytes_transferred);
-    total_transferred += bytes_transferred;
-    max_size = detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred));
-    bytes_available = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(max_size, b.max_size() - b.size()));
-  }
-  return total_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s,
-      static_cast<DynamicBuffer_v2&&>(buffers), transfer_all(), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  return read(s, static_cast<DynamicBuffer_v2&&>(buffers),
-      transfer_all(), ec);
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-inline std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read(s,
-      static_cast<DynamicBuffer_v2&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "read");
-  return bytes_transferred;
-}
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename MutableBufferIterator, typename CompletionCondition,
-      typename ReadHandler>
-  class read_op
-    : public base_from_cancellation_state<ReadHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
-        CompletionCondition& completion_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_op(const read_op& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_op(read_op&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<buffers_type&&>(other.buffers_)),
-        start_(other.start_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(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());
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read"));
-            stream_.async_read_some(buffers_.prepare(max_size),
-                static_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());
-          if (max_size == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<ReadHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(buffers_.total_consumed()));
-      }
-    }
-
-  //private:
-    typedef asio::detail::consuming_buffers<mutable_buffer,
-        MutableBufferSequence, MutableBufferIterator> buffers_type;
-
-    AsyncReadStream& stream_;
-    buffers_type buffers_;
-    int start_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename MutableBufferIterator, typename CompletionCondition,
-      typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
-        CompletionCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream, typename MutableBufferSequence,
-      typename MutableBufferIterator, typename CompletionCondition,
-      typename ReadHandler>
-  inline void start_read_op(AsyncReadStream& stream,
-      const MutableBufferSequence& buffers, const MutableBufferIterator&,
-      CompletionCondition& completion_condition, ReadHandler& handler)
-  {
-    read_op<AsyncReadStream, MutableBufferSequence,
-      MutableBufferIterator, CompletionCondition, ReadHandler>(
-        stream, buffers, completion_condition, handler)(
-          asio::error_code(), 0, 1);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence,
-        typename CompletionCondition>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers,
-        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_op(stream_, buffers,
-          asio::buffer_sequence_begin(buffers),
-          completion_cond2.value, handler2.value);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename MutableBufferSequence,
-    typename MutableBufferIterator, typename CompletionCondition,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_op<AsyncReadStream, MutableBufferSequence,
-      MutableBufferIterator, CompletionCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_op<AsyncReadStream, MutableBufferSequence,
-        MutableBufferIterator, CompletionCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_op<AsyncReadStream, MutableBufferSequence,
-        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename CompletionCondition, typename ReadHandler>
-  class read_dynbuf_v1_op
-    : public base_from_cancellation_state<ReadHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    template <typename BufferSequence>
-    read_dynbuf_v1_op(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        CompletionCondition& completion_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        start_(0),
-        total_transferred_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_dynbuf_v1_op(const read_dynbuf_v1_op& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_dynbuf_v1_op(read_dynbuf_v1_op&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t max_size, bytes_available;
-      switch (start_ = start)
-      {
-        case 1:
-        max_size = this->check_for_completion(ec, total_transferred_);
-        bytes_available = std::min<std::size_t>(
-              std::max<std::size_t>(512,
-                buffers_.capacity() - buffers_.size()),
-              std::min<std::size_t>(max_size,
-                buffers_.max_size() - buffers_.size()));
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read"));
-            stream_.async_read_some(buffers_.prepare(bytes_available),
-                static_cast<read_dynbuf_v1_op&&>(*this));
-          }
-          return; default:
-          total_transferred_ += bytes_transferred;
-          buffers_.commit(bytes_transferred);
-          max_size = this->check_for_completion(ec, total_transferred_);
-          bytes_available = std::min<std::size_t>(
-                std::max<std::size_t>(512,
-                  buffers_.capacity() - buffers_.size()),
-                std::min<std::size_t>(max_size,
-                  buffers_.max_size() - buffers_.size()));
-          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<ReadHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename CompletionCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,
-        CompletionCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_dynbuf_v1
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_dynbuf_v1(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v1,
-        typename CompletionCondition>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v1&& buffers,
-        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);
-      read_dynbuf_v1_op<AsyncReadStream, decay_t<DynamicBuffer_v1>,
-        CompletionCondition, decay_t<ReadHandler>>(
-          stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-            completion_cond2.value, handler2.value)(
-              asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename ReadHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_dynbuf_v1_op<AsyncReadStream,
-      DynamicBuffer_v1, CompletionCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_dynbuf_v1_op<AsyncReadStream, DynamicBuffer_v1,
-        CompletionCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_dynbuf_v1_op<AsyncReadStream,
-        DynamicBuffer_v1, CompletionCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename CompletionCondition, typename ReadHandler>
-  class read_dynbuf_v2_op
-    : public base_from_cancellation_state<ReadHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    template <typename BufferSequence>
-    read_dynbuf_v2_op(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        CompletionCondition& completion_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        start_(0),
-        total_transferred_(0),
-        bytes_available_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_dynbuf_v2_op(const read_dynbuf_v2_op& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        bytes_available_(other.bytes_available_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_dynbuf_v2_op(read_dynbuf_v2_op&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        bytes_available_(other.bytes_available_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t max_size, pos;
-      switch (start_ = start)
-      {
-        case 1:
-        max_size = this->check_for_completion(ec, total_transferred_);
-        bytes_available_ = std::min<std::size_t>(
-              std::max<std::size_t>(512,
-                buffers_.capacity() - buffers_.size()),
-              std::min<std::size_t>(max_size,
-                buffers_.max_size() - buffers_.size()));
-        for (;;)
-        {
-          pos = buffers_.size();
-          buffers_.grow(bytes_available_);
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read"));
-            stream_.async_read_some(buffers_.data(pos, bytes_available_),
-                static_cast<read_dynbuf_v2_op&&>(*this));
-          }
-          return; default:
-          total_transferred_ += bytes_transferred;
-          buffers_.shrink(bytes_available_ - bytes_transferred);
-          max_size = this->check_for_completion(ec, total_transferred_);
-          bytes_available_ = std::min<std::size_t>(
-                std::max<std::size_t>(512,
-                  buffers_.capacity() - buffers_.size()),
-                std::min<std::size_t>(max_size,
-                  buffers_.max_size() - buffers_.size()));
-          if ((!ec && bytes_transferred == 0) || bytes_available_ == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<ReadHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    int start_;
-    std::size_t total_transferred_;
-    std::size_t bytes_available_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename CompletionCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,
-        CompletionCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_dynbuf_v2
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_dynbuf_v2(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v2,
-        typename CompletionCondition>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v2&& buffers,
-        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);
-      read_dynbuf_v2_op<AsyncReadStream, decay_t<DynamicBuffer_v2>,
-        CompletionCondition, decay_t<ReadHandler>>(
-          stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-            completion_cond2.value, handler2.value)(
-              asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename ReadHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_dynbuf_v2_op<AsyncReadStream,
-      DynamicBuffer_v2, CompletionCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_dynbuf_v2_op<AsyncReadStream, DynamicBuffer_v2,
-        CompletionCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_dynbuf_v2_op<AsyncReadStream,
-        DynamicBuffer_v2, CompletionCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_READ_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_at.hpp
deleted file mode 100644
index 98db819..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_at.hpp
+++ /dev/null
@@ -1,562 +0,0 @@
-//
-// impl/read_at.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_READ_AT_HPP
-#define ASIO_IMPL_READ_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <algorithm>
-#include "asio/associator.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/base_from_completion_cond.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/consuming_buffers.hpp"
-#include "asio/detail/dependent_type.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
-      typename MutableBufferIterator, typename CompletionCondition>
-  std::size_t read_at_buffer_sequence(SyncRandomAccessReadDevice& d,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      const MutableBufferIterator&, CompletionCondition completion_condition,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    asio::detail::consuming_buffers<mutable_buffer,
-        MutableBufferSequence, MutableBufferIterator> tmp(buffers);
-    while (!tmp.empty())
-    {
-      if (std::size_t max_size = detail::adapt_completion_condition_result(
-            completion_condition(ec, tmp.total_consumed())))
-      {
-        tmp.consume(d.read_some_at(offset + tmp.total_consumed(),
-              tmp.prepare(max_size), ec));
-      }
-      else
-        break;
-    }
-    return tmp.total_consumed();
-  }
-} // namespace detail
-
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return detail::read_at_buffer_sequence(d, offset, buffers,
-      asio::buffer_sequence_begin(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_at(
-      d, offset, buffers, transfer_all(), ec);
-  asio::detail::throw_error(ec, "read_at");
-  return bytes_transferred;
-}
-
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    asio::error_code& ec)
-{
-  return read_at(d, offset, buffers, transfer_all(), ec);
-}
-
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
-    typename CompletionCondition>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_at(d, offset, buffers,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "read_at");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncRandomAccessReadDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  ec = asio::error_code();
-  std::size_t total_transferred = 0;
-  std::size_t max_size = detail::adapt_completion_condition_result(
-        completion_condition(ec, total_transferred));
-  std::size_t bytes_available = read_size_helper(b, max_size);
-  while (bytes_available > 0)
-  {
-    std::size_t bytes_transferred = d.read_some_at(
-        offset + total_transferred, b.prepare(bytes_available), ec);
-    b.commit(bytes_transferred);
-    total_transferred += bytes_transferred;
-    max_size = detail::adapt_completion_condition_result(
-          completion_condition(ec, total_transferred));
-    bytes_available = read_size_helper(b, max_size);
-  }
-  return total_transferred;
-}
-
-template <typename SyncRandomAccessReadDevice, typename Allocator>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_at(
-      d, offset, b, transfer_all(), ec);
-  asio::detail::throw_error(ec, "read_at");
-  return bytes_transferred;
-}
-
-template <typename SyncRandomAccessReadDevice, typename Allocator>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    asio::error_code& ec)
-{
-  return read_at(d, offset, b, transfer_all(), ec);
-}
-
-template <typename SyncRandomAccessReadDevice, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_at(d, offset, b,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "read_at");
-  return bytes_transferred;
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-namespace detail
-{
-  template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename MutableBufferIterator,
-      typename CompletionCondition, typename ReadHandler>
-  class read_at_op
-    : public base_from_cancellation_state<ReadHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_at_op(AsyncRandomAccessReadDevice& device,
-        uint64_t offset, const MutableBufferSequence& buffers,
-        CompletionCondition& completion_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_at_op(const read_at_op& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_at_op(read_at_op&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffers_(static_cast<buffers_type&&>(other.buffers_)),
-        start_(other.start_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(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());
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read_at"));
-            device_.async_read_some_at(
-                offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
-                static_cast<read_at_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());
-          if (max_size == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<ReadHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(buffers_.total_consumed()));
-      }
-    }
-
-  //private:
-    typedef asio::detail::consuming_buffers<mutable_buffer,
-        MutableBufferSequence, MutableBufferIterator> buffers_type;
-
-    AsyncRandomAccessReadDevice& device_;
-    uint64_t offset_;
-    buffers_type buffers_;
-    int start_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename MutableBufferIterator,
-      typename CompletionCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename MutableBufferIterator,
-      typename CompletionCondition, typename ReadHandler>
-  inline void start_read_at_op(AsyncRandomAccessReadDevice& d,
-      uint64_t offset, const MutableBufferSequence& buffers,
-      const MutableBufferIterator&, CompletionCondition& completion_condition,
-      ReadHandler& handler)
-  {
-    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-      MutableBufferIterator, CompletionCondition, ReadHandler>(
-        d, offset, buffers, completion_condition, handler)(
-          asio::error_code(), 0, 1);
-  }
-
-  template <typename AsyncRandomAccessReadDevice>
-  class initiate_async_read_at
-  {
-  public:
-    typedef typename AsyncRandomAccessReadDevice::executor_type executor_type;
-
-    explicit initiate_async_read_at(AsyncRandomAccessReadDevice& device)
-      : device_(device)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return device_.get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence,
-        typename CompletionCondition>
-    void operator()(ReadHandler&& handler,
-        uint64_t offset, const MutableBufferSequence& buffers,
-        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_at_op(device_, offset, buffers,
-          asio::buffer_sequence_begin(buffers),
-          completion_cond2.value, handler2.value);
-    }
-
-  private:
-    AsyncRandomAccessReadDevice& device_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
-    typename MutableBufferIterator, typename CompletionCondition,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
-      MutableBufferIterator, CompletionCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_at_op<AsyncRandomAccessReadDevice,
-        MutableBufferSequence, MutableBufferIterator,
-        CompletionCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_at_op<AsyncRandomAccessReadDevice,
-        MutableBufferSequence, MutableBufferIterator,
-        CompletionCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-namespace detail
-{
-  template <typename AsyncRandomAccessReadDevice, typename Allocator,
-      typename CompletionCondition, typename ReadHandler>
-  class read_at_streambuf_op
-    : public base_from_cancellation_state<ReadHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
-        uint64_t offset, basic_streambuf<Allocator>& streambuf,
-        CompletionCondition& completion_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        streambuf_(streambuf),
-        start_(0),
-        total_transferred_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_at_streambuf_op(const read_at_streambuf_op& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        device_(other.device_),
-        offset_(other.offset_),
-        streambuf_(other.streambuf_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_at_streambuf_op(read_at_streambuf_op&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        device_(other.device_),
-        offset_(other.offset_),
-        streambuf_(other.streambuf_),
-        start_(other.start_),
-        total_transferred_(other.total_transferred_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      std::size_t max_size, bytes_available;
-      switch (start_ = start)
-      {
-        case 1:
-        max_size = this->check_for_completion(ec, total_transferred_);
-        bytes_available = read_size_helper(streambuf_, max_size);
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read_at"));
-            device_.async_read_some_at(offset_ + total_transferred_,
-                streambuf_.prepare(bytes_available),
-                static_cast<read_at_streambuf_op&&>(*this));
-          }
-          return; default:
-          total_transferred_ += bytes_transferred;
-          streambuf_.commit(bytes_transferred);
-          max_size = this->check_for_completion(ec, total_transferred_);
-          bytes_available = read_size_helper(streambuf_, max_size);
-          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<ReadHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    uint64_t offset_;
-    asio::basic_streambuf<Allocator>& streambuf_;
-    int start_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessReadDevice, typename Allocator,
-      typename CompletionCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
-        CompletionCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncRandomAccessReadDevice>
-  class initiate_async_read_at_streambuf
-  {
-  public:
-    typedef typename AsyncRandomAccessReadDevice::executor_type executor_type;
-
-    explicit initiate_async_read_at_streambuf(
-        AsyncRandomAccessReadDevice& device)
-      : device_(device)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return device_.get_executor();
-    }
-
-    template <typename ReadHandler,
-        typename Allocator, typename CompletionCondition>
-    void operator()(ReadHandler&& handler,
-        uint64_t offset, basic_streambuf<Allocator>* b,
-        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);
-      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
-        CompletionCondition, decay_t<ReadHandler>>(
-          device_, offset, *b, completion_cond2.value, handler2.value)(
-            asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncRandomAccessReadDevice& device_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncRandomAccessReadDevice, typename Executor,
-    typename CompletionCondition, typename ReadHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-      Executor, CompletionCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-        Executor, CompletionCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
-        Executor, CompletionCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_READ_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_until.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_until.hpp
deleted file mode 100644
index 354a2d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/read_until.hpp
+++ /dev/null
@@ -1,2668 +0,0 @@
-//
-// impl/read_until.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_READ_UNTIL_HPP
-#define ASIO_IMPL_READ_UNTIL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <utility>
-#include "asio/associator.hpp"
-#include "asio/buffer.hpp"
-#include "asio/buffers_iterator.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/limits.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  // Algorithm that finds a subsequence of equal values in a sequence. Returns
-  // (iterator,true) if a full match was found, in which case the iterator
-  // points to the beginning of the match. Returns (iterator,false) if a
-  // partial match was found at the end of the first sequence, in which case
-  // the iterator points to the beginning of the partial match. Returns
-  // (last1,false) if no full or partial match was found.
-  template <typename Iterator1, typename Iterator2>
-  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);
-  }
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX)
-  struct regex_match_flags
-  {
-    template <typename T>
-    operator T() const
-    {
-      return T::match_default | T::match_partial;
-    }
-  };
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-} // namespace detail
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers, char delim,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v1&&>(buffers), delim, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    char delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v1::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers = b.data();
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    iterator iter = std::find(start_pos, end, delim);
-    if (iter != end)
-    {
-      // Found a match. We're done.
-      ec = asio::error_code();
-      return iter - begin + 1;
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
-    if (ec)
-      return 0;
-  }
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v1&&>(buffers), delim, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v1::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers = b.data();
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    std::pair<iterator, bool> result = detail::partial_search(
-        start_pos, end, delim.begin(), delim.end());
-    if (result.first != end)
-    {
-      if (result.second)
-      {
-        // Full match. We're done.
-        ec = asio::error_code();
-        return result.first - begin + delim.length();
-      }
-      else
-      {
-        // Partial match. Next search needs to start from beginning of match.
-        search_position = result.first - begin;
-      }
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
-    if (ec)
-      return 0;
-  }
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream, typename DynamicBuffer_v1, typename Traits>
-inline std::size_t read_until(SyncReadStream& s, DynamicBuffer_v1&& buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v1&&>(buffers), expr, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v1, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v1&& buffers,
-    const boost::basic_regex<char, Traits>& expr, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v1::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers = b.data();
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    boost::match_results<iterator,
-      typename std::vector<boost::sub_match<iterator>>::allocator_type>
-        match_results;
-    if (regex_search(start_pos, end, match_results,
-          expr, detail::regex_match_flags()))
-    {
-      if (match_results[0].matched)
-      {
-        // Full match. We're done.
-        ec = asio::error_code();
-        return match_results[0].second - begin;
-      }
-      else
-      {
-        // Partial match. Next search needs to start from beginning of match.
-        search_position = match_results[0].first - begin;
-      }
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
-    if (ec)
-      return 0;
-  }
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream,
-    typename DynamicBuffer_v1, typename MatchCondition>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    MatchCondition match_condition,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    >,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v1&&>(buffers),
-      match_condition, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream,
-    typename DynamicBuffer_v1, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    >,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v1::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers = b.data();
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    std::pair<iterator, bool> result = match_condition(start_pos, end);
-    if (result.second)
-    {
-      // Full match. We're done.
-      ec = asio::error_code();
-      return result.first - begin;
-    }
-    else if (result.first != end)
-    {
-      // Partial match. Next search needs to start from beginning of match.
-      search_position = result.first - begin;
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
-    if (ec)
-      return 0;
-  }
-}
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
-}
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    asio::error_code& ec)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
-}
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    ASIO_STRING_VIEW_PARAM delim)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
-}
-
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
-}
-
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream, typename Allocator, typename Traits>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    const boost::basic_regex<char, Traits>& expr)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), expr);
-}
-
-template <typename SyncReadStream, typename Allocator, typename Traits>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    const boost::basic_regex<char, Traits>& expr,
-    asio::error_code& ec)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), expr, ec);
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
-    constraint_t<is_match_condition<MatchCondition>::value>)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition);
-}
-
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-inline std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<is_match_condition<MatchCondition>::value>)
-{
-  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition, ec);
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v2 buffers, char delim,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v2&&>(buffers), delim, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    char delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  DynamicBuffer_v2& b = buffers;
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v2::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers =
-      const_cast<const DynamicBuffer_v2&>(b).data(0, b.size());
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    iterator iter = std::find(start_pos, end, delim);
-    if (iter != end)
-    {
-      // Found a match. We're done.
-      ec = asio::error_code();
-      return iter - begin + 1;
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    std::size_t pos = b.size();
-    b.grow(bytes_to_read);
-    std::size_t bytes_transferred = s.read_some(b.data(pos, bytes_to_read), ec);
-    b.shrink(bytes_to_read - bytes_transferred);
-    if (ec)
-      return 0;
-  }
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v2 buffers, ASIO_STRING_VIEW_PARAM delim,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v2&&>(buffers), delim, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  DynamicBuffer_v2& b = buffers;
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v2::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers =
-      const_cast<const DynamicBuffer_v2&>(b).data(0, b.size());
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    std::pair<iterator, bool> result = detail::partial_search(
-        start_pos, end, delim.begin(), delim.end());
-    if (result.first != end)
-    {
-      if (result.second)
-      {
-        // Full match. We're done.
-        ec = asio::error_code();
-        return result.first - begin + delim.length();
-      }
-      else
-      {
-        // Partial match. Next search needs to start from beginning of match.
-        search_position = result.first - begin;
-      }
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    std::size_t pos = b.size();
-    b.grow(bytes_to_read);
-    std::size_t bytes_transferred = s.read_some(b.data(pos, bytes_to_read), ec);
-    b.shrink(bytes_to_read - bytes_transferred);
-    if (ec)
-      return 0;
-  }
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream, typename DynamicBuffer_v2, typename Traits>
-inline std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v2&&>(buffers), expr, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream, typename DynamicBuffer_v2, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::basic_regex<char, Traits>& expr, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  DynamicBuffer_v2& b = buffers;
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v2::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers =
-      const_cast<const DynamicBuffer_v2&>(b).data(0, b.size());
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    boost::match_results<iterator,
-      typename std::vector<boost::sub_match<iterator>>::allocator_type>
-        match_results;
-    if (regex_search(start_pos, end, match_results,
-          expr, detail::regex_match_flags()))
-    {
-      if (match_results[0].matched)
-      {
-        // Full match. We're done.
-        ec = asio::error_code();
-        return match_results[0].second - begin;
-      }
-      else
-      {
-        // Partial match. Next search needs to start from beginning of match.
-        search_position = match_results[0].first - begin;
-      }
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    std::size_t pos = b.size();
-    b.grow(bytes_to_read);
-    std::size_t bytes_transferred = s.read_some(b.data(pos, bytes_to_read), ec);
-    b.shrink(bytes_to_read - bytes_transferred);
-    if (ec)
-      return 0;
-  }
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-template <typename SyncReadStream,
-    typename DynamicBuffer_v2, typename MatchCondition>
-inline std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v2 buffers, MatchCondition match_condition,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    >,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = read_until(s,
-      static_cast<DynamicBuffer_v2&&>(buffers),
-      match_condition, ec);
-  asio::detail::throw_error(ec, "read_until");
-  return bytes_transferred;
-}
-
-template <typename SyncReadStream,
-    typename DynamicBuffer_v2, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    >,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  DynamicBuffer_v2& b = buffers;
-
-  std::size_t search_position = 0;
-  for (;;)
-  {
-    // Determine the range of the data to be searched.
-    typedef typename DynamicBuffer_v2::const_buffers_type buffers_type;
-    typedef buffers_iterator<buffers_type> iterator;
-    buffers_type data_buffers =
-      const_cast<const DynamicBuffer_v2&>(b).data(0, b.size());
-    iterator begin = iterator::begin(data_buffers);
-    iterator start_pos = begin + search_position;
-    iterator end = iterator::end(data_buffers);
-
-    // Look for a match.
-    std::pair<iterator, bool> result = match_condition(start_pos, end);
-    if (result.second)
-    {
-      // Full match. We're done.
-      ec = asio::error_code();
-      return result.first - begin;
-    }
-    else if (result.first != end)
-    {
-      // Partial match. Next search needs to start from beginning of match.
-      search_position = result.first - begin;
-    }
-    else
-    {
-      // No match. Next search can start with the new data.
-      search_position = end - begin;
-    }
-
-    // Check if buffer is full.
-    if (b.size() == b.max_size())
-    {
-      ec = error::not_found;
-      return 0;
-    }
-
-    // Need more data.
-    std::size_t bytes_to_read = std::min<std::size_t>(
-          std::max<std::size_t>(512, b.capacity() - b.size()),
-          std::min<std::size_t>(65536, b.max_size() - b.size()));
-    std::size_t pos = b.size();
-    b.grow(bytes_to_read);
-    std::size_t bytes_transferred = s.read_some(b.data(pos, bytes_to_read), ec);
-    b.shrink(bytes_to_read - bytes_transferred);
-    if (ec)
-      return 0;
-  }
-}
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v1, typename ReadHandler>
-  class read_until_delim_op_v1
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_delim_op_v1(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        char delim, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        delim_(delim),
-        start_(0),
-        search_position_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_delim_op_v1(const read_until_delim_op_v1& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_delim_op_v1(read_until_delim_op_v1&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t bytes_to_read;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v1::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers = buffers_.data();
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            iterator iter = std::find(start_pos, end, delim_);
-            if (iter != end)
-            {
-              // Found a match. We're done.
-              search_position_ = iter - begin + 1;
-              bytes_to_read = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              // Next search can start with the new data.
-              search_position_ = end - begin;
-              bytes_to_read = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.prepare(bytes_to_read),
-                static_cast<read_until_delim_op_v1&&>(*this));
-          }
-          return; default:
-          buffers_.commit(bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    char delim_;
-    int start_;
-    std::size_t search_position_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v1, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_delim_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_delim_v1
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_delim_v1(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v1>
-    void operator()(ReadHandler&& handler,
-        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,
-        decay_t<DynamicBuffer_v1>,
-          decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-            delim, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_delim_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_delim_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_delim_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-namespace detail
-{
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v1, typename ReadHandler>
-  class read_until_delim_string_op_v1
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_delim_string_op_v1(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        const std::string& delim, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        delim_(delim),
-        start_(0),
-        search_position_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_delim_string_op_v1(const read_until_delim_string_op_v1& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_delim_string_op_v1(read_until_delim_string_op_v1&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        delim_(static_cast<std::string&&>(other.delim_)),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t bytes_to_read;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v1::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers = buffers_.data();
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            std::pair<iterator, bool> result = detail::partial_search(
-                start_pos, end, delim_.begin(), delim_.end());
-            if (result.first != end && result.second)
-            {
-              // Full match. We're done.
-              search_position_ = result.first - begin + delim_.length();
-              bytes_to_read = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (result.first != end)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = result.first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.prepare(bytes_to_read),
-                static_cast<read_until_delim_string_op_v1&&>(*this));
-          }
-          return; default:
-          buffers_.commit(bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    std::string delim_;
-    int start_;
-    std::size_t search_position_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v1, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_delim_string_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_delim_string_v1
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_delim_string_v1(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v1>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v1&& buffers,
-        const std::string& 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_string_op_v1<AsyncReadStream,
-        decay_t<DynamicBuffer_v1>,
-          decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-            delim, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_delim_string_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_delim_string_op_v1<
-        AsyncReadStream, DynamicBuffer_v1, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_delim_string_op_v1<
-        AsyncReadStream, DynamicBuffer_v1, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename RegEx, typename ReadHandler>
-  class read_until_expr_op_v1
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence, typename Traits>
-    read_until_expr_op_v1(AsyncReadStream& stream, BufferSequence&& buffers,
-        const boost::basic_regex<char, Traits>& expr, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        expr_(expr),
-        start_(0),
-        search_position_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_expr_op_v1(const read_until_expr_op_v1& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        expr_(other.expr_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_expr_op_v1(read_until_expr_op_v1&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        expr_(other.expr_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t bytes_to_read;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v1::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers = buffers_.data();
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            boost::match_results<iterator,
-              typename std::vector<boost::sub_match<iterator>>::allocator_type>
-                match_results;
-            bool match = regex_search(start_pos, end,
-                match_results, expr_, regex_match_flags());
-            if (match && match_results[0].matched)
-            {
-              // Full match. We're done.
-              search_position_ = match_results[0].second - begin;
-              bytes_to_read = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (match)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = match_results[0].first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.prepare(bytes_to_read),
-                static_cast<read_until_expr_op_v1&&>(*this));
-          }
-          return; default:
-          buffers_.commit(bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    RegEx expr_;
-    int start_;
-    std::size_t search_position_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename RegEx, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_expr_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, RegEx, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_expr_v1
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_expr_v1(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v1, typename RegEx>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v1&& buffers, const RegEx& expr) 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_expr_op_v1<AsyncReadStream,
-        decay_t<DynamicBuffer_v1>,
-          RegEx, decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-            expr, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename RegEx, typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_expr_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, RegEx, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_expr_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, RegEx, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_expr_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, RegEx, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename MatchCondition, typename ReadHandler>
-  class read_until_match_op_v1
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_match_op_v1(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        MatchCondition match_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        match_condition_(match_condition),
-        start_(0),
-        search_position_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_match_op_v1(const read_until_match_op_v1& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        match_condition_(other.match_condition_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_match_op_v1(read_until_match_op_v1&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        match_condition_(other.match_condition_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t bytes_to_read;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v1::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers = buffers_.data();
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            std::pair<iterator, bool> result = match_condition_(start_pos, end);
-            if (result.second)
-            {
-              // Full match. We're done.
-              search_position_ = result.first - begin;
-              bytes_to_read = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (result.first != end)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = result.first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.prepare(bytes_to_read),
-                static_cast<read_until_match_op_v1&&>(*this));
-          }
-          return; default:
-          buffers_.commit(bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    MatchCondition match_condition_;
-    int start_;
-    std::size_t search_position_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v1,
-      typename MatchCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_match_op_v1<AsyncReadStream, DynamicBuffer_v1,
-        MatchCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_match_v1
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_match_v1(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler,
-        typename DynamicBuffer_v1, typename MatchCondition>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v1&& buffers,
-        MatchCondition match_condition) 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_match_op_v1<AsyncReadStream,
-        decay_t<DynamicBuffer_v1>,
-          MatchCondition, decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-            match_condition, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v1,
-    typename MatchCondition, typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_match_op_v1<AsyncReadStream,
-      DynamicBuffer_v1, MatchCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_match_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, MatchCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_match_op_v1<AsyncReadStream,
-        DynamicBuffer_v1, MatchCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v2, typename ReadHandler>
-  class read_until_delim_op_v2
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_delim_op_v2(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        char delim, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        delim_(delim),
-        start_(0),
-        search_position_(0),
-        bytes_to_read_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_delim_op_v2(const read_until_delim_op_v2& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_delim_op_v2(read_until_delim_op_v2&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t pos;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v2::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers =
-              const_cast<const DynamicBuffer_v2&>(buffers_).data(
-                  0, buffers_.size());
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            iterator iter = std::find(start_pos, end, delim_);
-            if (iter != end)
-            {
-              // Found a match. We're done.
-              search_position_ = iter - begin + 1;
-              bytes_to_read_ = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read_ = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              // Next search can start with the new data.
-              search_position_ = end - begin;
-              bytes_to_read_ = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read_ == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          pos = buffers_.size();
-          buffers_.grow(bytes_to_read_);
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.data(pos, bytes_to_read_),
-                static_cast<read_until_delim_op_v2&&>(*this));
-          }
-          return; default:
-          buffers_.shrink(bytes_to_read_ - bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    char delim_;
-    int start_;
-    std::size_t search_position_;
-    std::size_t bytes_to_read_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v2, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_delim_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_delim_v2
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_delim_v2(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v2>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v2&& 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_v2<AsyncReadStream,
-        decay_t<DynamicBuffer_v2>,
-          decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-            delim, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_delim_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_delim_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_delim_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-namespace detail
-{
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v2, typename ReadHandler>
-  class read_until_delim_string_op_v2
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_delim_string_op_v2(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        const std::string& delim, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        delim_(delim),
-        start_(0),
-        search_position_(0),
-        bytes_to_read_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_delim_string_op_v2(const read_until_delim_string_op_v2& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        delim_(other.delim_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_delim_string_op_v2(read_until_delim_string_op_v2&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        delim_(static_cast<std::string&&>(other.delim_)),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t pos;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v2::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers =
-              const_cast<const DynamicBuffer_v2&>(buffers_).data(
-                  0, buffers_.size());
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            std::pair<iterator, bool> result = detail::partial_search(
-                start_pos, end, delim_.begin(), delim_.end());
-            if (result.first != end && result.second)
-            {
-              // Full match. We're done.
-              search_position_ = result.first - begin + delim_.length();
-              bytes_to_read_ = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read_ = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (result.first != end)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = result.first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read_ = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read_ == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          pos = buffers_.size();
-          buffers_.grow(bytes_to_read_);
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.data(pos, bytes_to_read_),
-                static_cast<read_until_delim_string_op_v2&&>(*this));
-          }
-          return; default:
-          buffers_.shrink(bytes_to_read_ - bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    std::string delim_;
-    int start_;
-    std::size_t search_position_;
-    std::size_t bytes_to_read_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream,
-      typename DynamicBuffer_v2, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_delim_string_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_delim_string_v2
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_delim_string_v2(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v2>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v2&& buffers,
-        const std::string& 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_string_op_v2<AsyncReadStream,
-        decay_t<DynamicBuffer_v2>,
-          decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-            delim, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_delim_string_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_delim_string_op_v2<
-        AsyncReadStream, DynamicBuffer_v2, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_delim_string_op_v2<
-        AsyncReadStream, DynamicBuffer_v2, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename RegEx, typename ReadHandler>
-  class read_until_expr_op_v2
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence, typename Traits>
-    read_until_expr_op_v2(AsyncReadStream& stream, BufferSequence&& buffers,
-        const boost::basic_regex<char, Traits>& expr, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        expr_(expr),
-        start_(0),
-        search_position_(0),
-        bytes_to_read_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_expr_op_v2(const read_until_expr_op_v2& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        expr_(other.expr_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_expr_op_v2(read_until_expr_op_v2&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        expr_(other.expr_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t pos;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v2::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers =
-              const_cast<const DynamicBuffer_v2&>(buffers_).data(
-                  0, buffers_.size());
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            boost::match_results<iterator,
-              typename std::vector<boost::sub_match<iterator>>::allocator_type>
-                match_results;
-            bool match = regex_search(start_pos, end,
-                match_results, expr_, regex_match_flags());
-            if (match && match_results[0].matched)
-            {
-              // Full match. We're done.
-              search_position_ = match_results[0].second - begin;
-              bytes_to_read_ = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read_ = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (match)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = match_results[0].first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read_ = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read_ == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          pos = buffers_.size();
-          buffers_.grow(bytes_to_read_);
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.data(pos, bytes_to_read_),
-                static_cast<read_until_expr_op_v2&&>(*this));
-          }
-          return; default:
-          buffers_.shrink(bytes_to_read_ - bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    RegEx expr_;
-    int start_;
-    std::size_t search_position_;
-    std::size_t bytes_to_read_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename RegEx, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_expr_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, RegEx, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_expr_v2
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_expr_v2(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler, typename DynamicBuffer_v2, typename RegEx>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v2&& buffers,
-        const RegEx& expr) 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_expr_op_v2<AsyncReadStream,
-        decay_t<DynamicBuffer_v2>,
-          RegEx, decay_t<ReadHandler>>(
-            stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-            expr, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename RegEx, typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_expr_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, RegEx, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_expr_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, RegEx, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_expr_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, RegEx, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-
-namespace detail
-{
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename MatchCondition, typename ReadHandler>
-  class read_until_match_op_v2
-    : public base_from_cancellation_state<ReadHandler>
-  {
-  public:
-    template <typename BufferSequence>
-    read_until_match_op_v2(AsyncReadStream& stream,
-        BufferSequence&& buffers,
-        MatchCondition match_condition, ReadHandler& handler)
-      : base_from_cancellation_state<ReadHandler>(
-          handler, enable_partial_cancellation()),
-        stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        match_condition_(match_condition),
-        start_(0),
-        search_position_(0),
-        bytes_to_read_(0),
-        handler_(static_cast<ReadHandler&&>(handler))
-    {
-    }
-
-    read_until_match_op_v2(const read_until_match_op_v2& other)
-      : base_from_cancellation_state<ReadHandler>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        match_condition_(other.match_condition_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(other.handler_)
-    {
-    }
-
-    read_until_match_op_v2(read_until_match_op_v2&& other)
-      : base_from_cancellation_state<ReadHandler>(
-          static_cast<base_from_cancellation_state<ReadHandler>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        match_condition_(other.match_condition_),
-        start_(other.start_),
-        search_position_(other.search_position_),
-        bytes_to_read_(other.bytes_to_read_),
-        handler_(static_cast<ReadHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(asio::error_code ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
-      std::size_t pos;
-      switch (start_ = start)
-      {
-      case 1:
-        for (;;)
-        {
-          {
-            // Determine the range of the data to be searched.
-            typedef typename DynamicBuffer_v2::const_buffers_type
-              buffers_type;
-            typedef buffers_iterator<buffers_type> iterator;
-            buffers_type data_buffers =
-              const_cast<const DynamicBuffer_v2&>(buffers_).data(
-                  0, buffers_.size());
-            iterator begin = iterator::begin(data_buffers);
-            iterator start_pos = begin + search_position_;
-            iterator end = iterator::end(data_buffers);
-
-            // Look for a match.
-            std::pair<iterator, bool> result = match_condition_(start_pos, end);
-            if (result.second)
-            {
-              // Full match. We're done.
-              search_position_ = result.first - begin;
-              bytes_to_read_ = 0;
-            }
-
-            // No match yet. Check if buffer is full.
-            else if (buffers_.size() == buffers_.max_size())
-            {
-              search_position_ = not_found;
-              bytes_to_read_ = 0;
-            }
-
-            // Need to read some more data.
-            else
-            {
-              if (result.first != end)
-              {
-                // Partial match. Next search needs to start from beginning of
-                // match.
-                search_position_ = result.first - begin;
-              }
-              else
-              {
-                // Next search can start with the new data.
-                search_position_ = end - begin;
-              }
-
-              bytes_to_read_ = std::min<std::size_t>(
-                    std::max<std::size_t>(512,
-                      buffers_.capacity() - buffers_.size()),
-                    std::min<std::size_t>(65536,
-                      buffers_.max_size() - buffers_.size()));
-            }
-          }
-
-          // Check if we're done.
-          if (!start && bytes_to_read_ == 0)
-            break;
-
-          // Start a new asynchronous read operation to obtain more data.
-          pos = buffers_.size();
-          buffers_.grow(bytes_to_read_);
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, "async_read_until"));
-            stream_.async_read_some(buffers_.data(pos, bytes_to_read_),
-                static_cast<read_until_match_op_v2&&>(*this));
-          }
-          return; default:
-          buffers_.shrink(bytes_to_read_ - bytes_transferred);
-          if (ec || bytes_transferred == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        const asio::error_code result_ec =
-          (search_position_ == not_found)
-          ? error::not_found : ec;
-
-        const std::size_t result_n =
-          (ec || search_position_ == not_found)
-          ? 0 : search_position_;
-
-        static_cast<ReadHandler&&>(handler_)(result_ec, result_n);
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    MatchCondition match_condition_;
-    int start_;
-    std::size_t search_position_;
-    std::size_t bytes_to_read_;
-    ReadHandler handler_;
-  };
-
-  template <typename AsyncReadStream, typename DynamicBuffer_v2,
-      typename MatchCondition, typename ReadHandler>
-  inline bool asio_handler_is_continuation(
-      read_until_match_op_v2<AsyncReadStream, DynamicBuffer_v2,
-        MatchCondition, ReadHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncReadStream>
-  class initiate_async_read_until_match_v2
-  {
-  public:
-    typedef typename AsyncReadStream::executor_type executor_type;
-
-    explicit initiate_async_read_until_match_v2(AsyncReadStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename ReadHandler,
-        typename DynamicBuffer_v2, typename MatchCondition>
-    void operator()(ReadHandler&& handler,
-        DynamicBuffer_v2&& buffers,
-        MatchCondition match_condition) 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_match_op_v2<AsyncReadStream, decay_t<DynamicBuffer_v2>,
-        MatchCondition, decay_t<ReadHandler>>(
-          stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-          match_condition, handler2.value)(asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncReadStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncReadStream, typename DynamicBuffer_v2,
-    typename MatchCondition, typename ReadHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::read_until_match_op_v2<AsyncReadStream,
-      DynamicBuffer_v2, MatchCondition, ReadHandler>,
-    DefaultCandidate>
-  : Associator<ReadHandler, DefaultCandidate>
-{
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::read_until_match_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, MatchCondition, ReadHandler>& h) noexcept
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::read_until_match_op_v2<AsyncReadStream,
-        DynamicBuffer_v2, MatchCondition, ReadHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_READ_UNTIL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/redirect_error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/redirect_error.hpp
deleted file mode 100644
index f30a9aa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/redirect_error.hpp
+++ /dev/null
@@ -1,287 +0,0 @@
-
-// impl/redirect_error.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_REDIRECT_ERROR_HPP
-#define ASIO_IMPL_REDIRECT_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/associator.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/initiation_base.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/system_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Class to adapt a redirect_error_t as a completion handler.
-template <typename Handler>
-class redirect_error_handler
-{
-public:
-  typedef void result_type;
-
-  template <typename CompletionToken>
-  redirect_error_handler(redirect_error_t<CompletionToken> e)
-    : ec_(e.ec_),
-      handler_(static_cast<CompletionToken&&>(e.token_))
-  {
-  }
-
-  template <typename RedirectedHandler>
-  redirect_error_handler(asio::error_code& ec,
-      RedirectedHandler&& h)
-    : ec_(ec),
-      handler_(static_cast<RedirectedHandler&&>(h))
-  {
-  }
-
-  void operator()()
-  {
-    static_cast<Handler&&>(handler_)();
-  }
-
-  template <typename Arg, typename... Args>
-  enable_if_t<
-    !is_same<decay_t<Arg>, asio::error_code>::value
-  >
-  operator()(Arg&& arg, Args&&... args)
-  {
-    static_cast<Handler&&>(handler_)(
-        static_cast<Arg&&>(arg),
-        static_cast<Args&&>(args)...);
-  }
-
-  template <typename... Args>
-  void operator()(const asio::error_code& ec, Args&&... args)
-  {
-    ec_ = ec;
-    static_cast<Handler&&>(handler_)(static_cast<Args&&>(args)...);
-  }
-
-//private:
-  asio::error_code& ec_;
-  Handler handler_;
-};
-
-template <typename Handler>
-inline bool asio_handler_is_continuation(
-    redirect_error_handler<Handler>* this_handler)
-{
-  return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-}
-
-template <typename Signature>
-struct redirect_error_signature
-{
-  typedef Signature type;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(asio::error_code, Args...)>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(const asio::error_code&, Args...)>
-{
-  typedef R type(Args...);
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(asio::error_code, Args...) &>
-{
-  typedef R type(Args...) &;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(const asio::error_code&, Args...) &>
-{
-  typedef R type(Args...) &;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(asio::error_code, Args...) &&>
-{
-  typedef R type(Args...) &&;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<R(const asio::error_code&, Args...) &&>
-{
-  typedef R type(Args...) &&;
-};
-
-#if defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(asio::error_code, Args...) noexcept>
-{
-  typedef R type(Args...) & noexcept;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(const asio::error_code&, Args...) noexcept>
-{
-  typedef R type(Args...) & noexcept;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(asio::error_code, Args...) & noexcept>
-{
-  typedef R type(Args...) & noexcept;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(const asio::error_code&, Args...) & noexcept>
-{
-  typedef R type(Args...) & noexcept;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(asio::error_code, Args...) && noexcept>
-{
-  typedef R type(Args...) && noexcept;
-};
-
-template <typename R, typename... Args>
-struct redirect_error_signature<
-  R(const asio::error_code&, Args...) && noexcept>
-{
-  typedef R type(Args...) && noexcept;
-};
-
-#endif // defined(ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename CompletionToken, typename Signature>
-struct async_result<redirect_error_t<CompletionToken>, Signature>
-  : async_result<CompletionToken,
-      typename detail::redirect_error_signature<Signature>::type>
-{
-  template <typename Initiation>
-  struct init_wrapper : detail::initiation_base<Initiation>
-  {
-    using detail::initiation_base<Initiation>::initiation_base;
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        asio::error_code* ec, Args&&... args) &&
-    {
-      static_cast<Initiation&&>(*this)(
-          detail::redirect_error_handler<decay_t<Handler>>(
-            *ec, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-
-    template <typename Handler, typename... Args>
-    void operator()(Handler&& handler,
-        asio::error_code* ec, Args&&... args) const &
-    {
-      static_cast<const Initiation&>(*this)(
-          detail::redirect_error_handler<decay_t<Handler>>(
-            *ec, static_cast<Handler&&>(handler)),
-          static_cast<Args&&>(args)...);
-    }
-  };
-
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<
-        conditional_t<
-          is_const<remove_reference_t<RawCompletionToken>>::value,
-            const CompletionToken, CompletionToken>,
-        typename detail::redirect_error_signature<Signature>::type>(
-          declval<init_wrapper<decay_t<Initiation>>>(),
-          token.token_, &token.ec_, static_cast<Args&&>(args)...))
-  {
-    return async_initiate<
-      conditional_t<
-        is_const<remove_reference_t<RawCompletionToken>>::value,
-          const CompletionToken, CompletionToken>,
-      typename detail::redirect_error_signature<Signature>::type>(
-        init_wrapper<decay_t<Initiation>>(
-          static_cast<Initiation&&>(initiation)),
-        token.token_, &token.ec_, static_cast<Args&&>(args)...);
-  }
-};
-
-template <template <typename, typename> class Associator,
-    typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::redirect_error_handler<Handler>, DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::redirect_error_handler<Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const detail::redirect_error_handler<Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-template <typename... Signatures>
-struct async_result<partial_redirect_error, Signatures...>
-{
-  template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static auto initiate(Initiation&& initiation,
-      RawCompletionToken&& token, Args&&... args)
-    -> decltype(
-      async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        redirect_error_t<
-          default_completion_token_t<associated_executor_t<Initiation>>>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.ec_),
-        static_cast<Args&&>(args)...))
-  {
-    return async_initiate<Signatures...>(
-        static_cast<Initiation&&>(initiation),
-        redirect_error_t<
-          default_completion_token_t<associated_executor_t<Initiation>>>(
-            default_completion_token_t<associated_executor_t<Initiation>>{},
-            token.ec_),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_REDIRECT_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.hpp
deleted file mode 100644
index 1fa2af6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// impl/serial_port_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SERIAL_PORT_BASE_HPP
-#define ASIO_IMPL_SERIAL_PORT_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
-  : value_(rate)
-{
-}
-
-inline unsigned int serial_port_base::baud_rate::value() const
-{
-  return value_;
-}
-
-inline serial_port_base::flow_control::type
-serial_port_base::flow_control::value() const
-{
-  return value_;
-}
-
-inline serial_port_base::parity::type serial_port_base::parity::value() const
-{
-  return value_;
-}
-
-inline serial_port_base::stop_bits::type
-serial_port_base::stop_bits::value() const
-{
-  return value_;
-}
-
-inline unsigned int serial_port_base::character_size::value() const
-{
-  return value_;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_SERIAL_PORT_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.ipp
deleted file mode 100644
index 646af34..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/serial_port_base.ipp
+++ /dev/null
@@ -1,554 +0,0 @@
-//
-// impl/serial_port_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SERIAL_PORT_BASE_IPP
-#define ASIO_IMPL_SERIAL_PORT_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT)
-
-#include <stdexcept>
-#include "asio/error.hpp"
-#include "asio/serial_port_base.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_OPTION_STORAGE implementation_defined
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# define ASIO_OPTION_STORAGE DCB
-#else
-# define ASIO_OPTION_STORAGE termios
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-ASIO_SYNC_OP_VOID serial_port_base::baud_rate::store(
-    ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  storage.BaudRate = value_;
-#else
-  speed_t baud;
-  switch (value_)
-  {
-  // Do POSIX-specified rates first.
-  case 0: baud = B0; break;
-  case 50: baud = B50; break;
-  case 75: baud = B75; break;
-  case 110: baud = B110; break;
-  case 134: baud = B134; break;
-  case 150: baud = B150; break;
-  case 200: baud = B200; break;
-  case 300: baud = B300; break;
-  case 600: baud = B600; break;
-  case 1200: baud = B1200; break;
-  case 1800: baud = B1800; break;
-  case 2400: baud = B2400; break;
-  case 4800: baud = B4800; break;
-  case 9600: baud = B9600; break;
-  case 19200: baud = B19200; break;
-  case 38400: baud = B38400; break;
-  // And now the extended ones conditionally.
-# ifdef B7200
-  case 7200: baud = B7200; break;
-# endif
-# ifdef B14400
-  case 14400: baud = B14400; break;
-# endif
-# ifdef B57600
-  case 57600: baud = B57600; break;
-# endif
-# ifdef B115200
-  case 115200: baud = B115200; break;
-# endif
-# ifdef B230400
-  case 230400: baud = B230400; break;
-# endif
-# ifdef B460800
-  case 460800: baud = B460800; break;
-# endif
-# ifdef B500000
-  case 500000: baud = B500000; break;
-# endif
-# ifdef B576000
-  case 576000: baud = B576000; break;
-# endif
-# ifdef B921600
-  case 921600: baud = B921600; break;
-# endif
-# ifdef B1000000
-  case 1000000: baud = B1000000; break;
-# endif
-# ifdef B1152000
-  case 1152000: baud = B1152000; break;
-# endif
-# ifdef B2000000
-  case 2000000: baud = B2000000; break;
-# endif
-# ifdef B3000000
-  case 3000000: baud = B3000000; break;
-# endif
-# ifdef B3500000
-  case 3500000: baud = B3500000; break;
-# endif
-# ifdef B4000000
-  case 4000000: baud = B4000000; break;
-# endif
-  default:
-    ec = asio::error::invalid_argument;
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-  ::cfsetspeed(&storage, baud);
-# else
-  ::cfsetispeed(&storage, baud);
-  ::cfsetospeed(&storage, baud);
-# endif
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::baud_rate::load(
-    const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  value_ = storage.BaudRate;
-#else
-  speed_t baud = ::cfgetospeed(&storage);
-  switch (baud)
-  {
-  // First do those specified by POSIX.
-  case B0: value_ = 0; break;
-  case B50: value_ = 50; break;
-  case B75: value_ = 75; break;
-  case B110: value_ = 110; break;
-  case B134: value_ = 134; break;
-  case B150: value_ = 150; break;
-  case B200: value_ = 200; break;
-  case B300: value_ = 300; break;
-  case B600: value_ = 600; break;
-  case B1200: value_ = 1200; break;
-  case B1800: value_ = 1800; break;
-  case B2400: value_ = 2400; break;
-  case B4800: value_ = 4800; break;
-  case B9600: value_ = 9600; break;
-  case B19200: value_ = 19200; break;
-  case B38400: value_ = 38400; break;
-  // Now conditionally handle a bunch of extended rates.
-# ifdef B7200
-  case B7200: value_ = 7200; break;
-# endif
-# ifdef B14400
-  case B14400: value_ = 14400; break;
-# endif
-# ifdef B57600
-  case B57600: value_ = 57600; break;
-# endif
-# ifdef B115200
-  case B115200: value_ = 115200; break;
-# endif
-# ifdef B230400
-  case B230400: value_ = 230400; break;
-# endif
-# ifdef B460800
-  case B460800: value_ = 460800; break;
-# endif
-# ifdef B500000
-  case B500000: value_ = 500000; break;
-# endif
-# ifdef B576000
-  case B576000: value_ = 576000; break;
-# endif
-# ifdef B921600
-  case B921600: value_ = 921600; break;
-# endif
-# ifdef B1000000
-  case B1000000: value_ = 1000000; break;
-# endif
-# ifdef B1152000
-  case B1152000: value_ = 1152000; break;
-# endif
-# ifdef B2000000
-  case B2000000: value_ = 2000000; break;
-# endif
-# ifdef B3000000
-  case B3000000: value_ = 3000000; break;
-# endif
-# ifdef B3500000
-  case B3500000: value_ = 3500000; break;
-# endif
-# ifdef B4000000
-  case B4000000: value_ = 4000000; break;
-# endif
-  default:
-    value_ = 0;
-    ec = asio::error::invalid_argument;
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-serial_port_base::flow_control::flow_control(
-    serial_port_base::flow_control::type t)
-  : value_(t)
-{
-  if (t != none && t != software && t != hardware)
-  {
-    std::out_of_range ex("invalid flow_control value");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::flow_control::store(
-    ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  storage.fOutxCtsFlow = FALSE;
-  storage.fOutxDsrFlow = FALSE;
-  storage.fTXContinueOnXoff = TRUE;
-  storage.fDtrControl = DTR_CONTROL_ENABLE;
-  storage.fDsrSensitivity = FALSE;
-  storage.fOutX = FALSE;
-  storage.fInX = FALSE;
-  storage.fRtsControl = RTS_CONTROL_ENABLE;
-  switch (value_)
-  {
-  case none:
-    break;
-  case software:
-    storage.fOutX = TRUE;
-    storage.fInX = TRUE;
-    break;
-  case hardware:
-    storage.fOutxCtsFlow = TRUE;
-    storage.fRtsControl = RTS_CONTROL_HANDSHAKE;
-    break;
-  default:
-    break;
-  }
-#else
-  switch (value_)
-  {
-  case none:
-    storage.c_iflag &= ~(IXOFF | IXON);
-# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-    storage.c_cflag &= ~CRTSCTS;
-# elif defined(__QNXNTO__)
-    storage.c_cflag &= ~(IHFLOW | OHFLOW);
-# endif
-    break;
-  case software:
-    storage.c_iflag |= IXOFF | IXON;
-# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-    storage.c_cflag &= ~CRTSCTS;
-# elif defined(__QNXNTO__)
-    storage.c_cflag &= ~(IHFLOW | OHFLOW);
-# endif
-    break;
-  case hardware:
-# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-    storage.c_iflag &= ~(IXOFF | IXON);
-    storage.c_cflag |= CRTSCTS;
-    break;
-# elif defined(__QNXNTO__)
-    storage.c_iflag &= ~(IXOFF | IXON);
-    storage.c_cflag |= (IHFLOW | OHFLOW);
-    break;
-# else
-    ec = asio::error::operation_not_supported;
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-# endif
-  default:
-    break;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::flow_control::load(
-    const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (storage.fOutX && storage.fInX)
-  {
-    value_ = software;
-  }
-  else if (storage.fOutxCtsFlow && storage.fRtsControl == RTS_CONTROL_HANDSHAKE)
-  {
-    value_ = hardware;
-  }
-  else
-  {
-    value_ = none;
-  }
-#else
-  if (storage.c_iflag & (IXOFF | IXON))
-  {
-    value_ = software;
-  }
-# if defined(_BSD_SOURCE) || defined(_DEFAULT_SOURCE)
-  else if (storage.c_cflag & CRTSCTS)
-  {
-    value_ = hardware;
-  }
-# elif defined(__QNXNTO__)
-  else if (storage.c_cflag & IHFLOW && storage.c_cflag & OHFLOW)
-  {
-    value_ = hardware;
-  }
-# endif
-  else
-  {
-    value_ = none;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-serial_port_base::parity::parity(serial_port_base::parity::type t)
-  : value_(t)
-{
-  if (t != none && t != odd && t != even)
-  {
-    std::out_of_range ex("invalid parity value");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::parity::store(
-    ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  switch (value_)
-  {
-  case none:
-    storage.fParity = FALSE;
-    storage.Parity = NOPARITY;
-    break;
-  case odd:
-    storage.fParity = TRUE;
-    storage.Parity = ODDPARITY;
-    break;
-  case even:
-    storage.fParity = TRUE;
-    storage.Parity = EVENPARITY;
-    break;
-  default:
-    break;
-  }
-#else
-  switch (value_)
-  {
-  case none:
-    storage.c_iflag |= IGNPAR;
-    storage.c_cflag &= ~(PARENB | PARODD);
-    break;
-  case even:
-    storage.c_iflag &= ~(IGNPAR | PARMRK);
-    storage.c_iflag |= INPCK;
-    storage.c_cflag |= PARENB;
-    storage.c_cflag &= ~PARODD;
-    break;
-  case odd:
-    storage.c_iflag &= ~(IGNPAR | PARMRK);
-    storage.c_iflag |= INPCK;
-    storage.c_cflag |= (PARENB | PARODD);
-    break;
-  default:
-    break;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::parity::load(
-    const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (storage.Parity == EVENPARITY)
-  {
-    value_ = even;
-  }
-  else if (storage.Parity == ODDPARITY)
-  {
-    value_ = odd;
-  }
-  else
-  {
-    value_ = none;
-  }
-#else
-  if (storage.c_cflag & PARENB)
-  {
-    if (storage.c_cflag & PARODD)
-    {
-      value_ = odd;
-    }
-    else
-    {
-      value_ = even;
-    }
-  }
-  else
-  {
-    value_ = none;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-serial_port_base::stop_bits::stop_bits(
-    serial_port_base::stop_bits::type t)
-  : value_(t)
-{
-  if (t != one && t != onepointfive && t != two)
-  {
-    std::out_of_range ex("invalid stop_bits value");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::stop_bits::store(
-    ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  switch (value_)
-  {
-  case one:
-    storage.StopBits = ONESTOPBIT;
-    break;
-  case onepointfive:
-    storage.StopBits = ONE5STOPBITS;
-    break;
-  case two:
-    storage.StopBits = TWOSTOPBITS;
-    break;
-  default:
-    break;
-  }
-#else
-  switch (value_)
-  {
-  case one:
-    storage.c_cflag &= ~CSTOPB;
-    break;
-  case two:
-    storage.c_cflag |= CSTOPB;
-    break;
-  default:
-    ec = asio::error::operation_not_supported;
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::stop_bits::load(
-    const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  if (storage.StopBits == ONESTOPBIT)
-  {
-    value_ = one;
-  }
-  else if (storage.StopBits == ONE5STOPBITS)
-  {
-    value_ = onepointfive;
-  }
-  else if (storage.StopBits == TWOSTOPBITS)
-  {
-    value_ = two;
-  }
-  else
-  {
-    value_ = one;
-  }
-#else
-  value_ = (storage.c_cflag & CSTOPB) ? two : one;
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-serial_port_base::character_size::character_size(unsigned int t)
-  : value_(t)
-{
-  if (t < 5 || t > 8)
-  {
-    std::out_of_range ex("invalid character_size value");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::character_size::store(
-    ASIO_OPTION_STORAGE& storage, asio::error_code& ec) const
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  storage.ByteSize = value_;
-#else
-  storage.c_cflag &= ~CSIZE;
-  switch (value_)
-  {
-  case 5: storage.c_cflag |= CS5; break;
-  case 6: storage.c_cflag |= CS6; break;
-  case 7: storage.c_cflag |= CS7; break;
-  case 8: storage.c_cflag |= CS8; break;
-  default: break;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID serial_port_base::character_size::load(
-    const ASIO_OPTION_STORAGE& storage, asio::error_code& ec)
-{
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  value_ = storage.ByteSize;
-#else
-  if ((storage.c_cflag & CSIZE) == CS5) { value_ = 5; }
-  else if ((storage.c_cflag & CSIZE) == CS6) { value_ = 6; }
-  else if ((storage.c_cflag & CSIZE) == CS7) { value_ = 7; }
-  else if ((storage.c_cflag & CSIZE) == CS8) { value_ = 8; }
-  else
-  {
-    // Hmmm, use 8 for now.
-    value_ = 8;
-  }
-#endif
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#undef ASIO_OPTION_STORAGE
-
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_IMPL_SERIAL_PORT_BASE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/spawn.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/spawn.hpp
deleted file mode 100644
index 51012f2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/spawn.hpp
+++ /dev/null
@@ -1,1399 +0,0 @@
-//
-// impl/spawn.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SPAWN_HPP
-#define ASIO_IMPL_SPAWN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_cancellation_slot.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/detail/utility.hpp"
-#include "asio/system_error.hpp"
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-# include <boost/context/fiber.hpp>
-#endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-inline void spawned_thread_rethrow(void* ex)
-{
-  if (*static_cast<exception_ptr*>(ex))
-    rethrow_exception(*static_cast<exception_ptr*>(ex));
-}
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-
-// Spawned thread implementation using Boost.Coroutine.
-class spawned_coroutine_thread : public spawned_thread_base
-{
-public:
-#if defined(BOOST_COROUTINES_UNIDIRECT) || defined(BOOST_COROUTINES_V2)
-  typedef boost::coroutines::pull_coroutine<void> callee_type;
-  typedef boost::coroutines::push_coroutine<void> caller_type;
-#else
-  typedef boost::coroutines::coroutine<void()> callee_type;
-  typedef boost::coroutines::coroutine<void()> caller_type;
-#endif
-
-  spawned_coroutine_thread(caller_type& caller)
-    : caller_(caller),
-      on_suspend_fn_(0),
-      on_suspend_arg_(0)
-  {
-  }
-
-  template <typename F>
-  static spawned_thread_base* spawn(F&& f,
-      const boost::coroutines::attributes& attributes,
-      cancellation_slot parent_cancel_slot = cancellation_slot(),
-      cancellation_state cancel_state = cancellation_state())
-  {
-    spawned_coroutine_thread* spawned_thread = 0;
-    callee_type callee(entry_point<decay_t<F>>(
-          static_cast<F&&>(f), &spawned_thread), attributes);
-    spawned_thread->callee_.swap(callee);
-    spawned_thread->parent_cancellation_slot_ = parent_cancel_slot;
-    spawned_thread->cancellation_state_ = cancel_state;
-    return spawned_thread;
-  }
-
-  template <typename F>
-  static spawned_thread_base* spawn(F&& f,
-      cancellation_slot parent_cancel_slot = cancellation_slot(),
-      cancellation_state cancel_state = cancellation_state())
-  {
-    return spawn(static_cast<F&&>(f), boost::coroutines::attributes(),
-        parent_cancel_slot, cancel_state);
-  }
-
-  void resume()
-  {
-    callee_();
-    if (on_suspend_fn_)
-    {
-      void (*fn)(void*) = on_suspend_fn_;
-      void* arg = on_suspend_arg_;
-      on_suspend_fn_ = 0;
-      fn(arg);
-    }
-  }
-
-  void suspend_with(void (*fn)(void*), void* arg)
-  {
-    if (throw_if_cancelled_)
-      if (!!cancellation_state_.cancelled())
-        throw_error(asio::error::operation_aborted, "yield");
-    has_context_switched_ = true;
-    on_suspend_fn_ = fn;
-    on_suspend_arg_ = arg;
-    caller_();
-  }
-
-  void destroy()
-  {
-    callee_type callee;
-    callee.swap(callee_);
-    if (terminal_)
-      callee();
-  }
-
-private:
-  template <typename Function>
-  class entry_point
-  {
-  public:
-    template <typename F>
-    entry_point(F&& f,
-        spawned_coroutine_thread** spawned_thread_out)
-      : function_(static_cast<F&&>(f)),
-        spawned_thread_out_(spawned_thread_out)
-    {
-    }
-
-    void operator()(caller_type& caller)
-    {
-      Function function(static_cast<Function&&>(function_));
-      spawned_coroutine_thread spawned_thread(caller);
-      *spawned_thread_out_ = &spawned_thread;
-      spawned_thread_out_ = 0;
-      spawned_thread.suspend();
-#if !defined(ASIO_NO_EXCEPTIONS)
-      try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      {
-        function(&spawned_thread);
-        spawned_thread.terminal_ = true;
-        spawned_thread.suspend();
-      }
-#if !defined(ASIO_NO_EXCEPTIONS)
-      catch (const boost::coroutines::detail::forced_unwind&)
-      {
-        throw;
-      }
-      catch (...)
-      {
-        exception_ptr ex = current_exception();
-        spawned_thread.terminal_ = true;
-        spawned_thread.suspend_with(spawned_thread_rethrow, &ex);
-      }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-    }
-
-  private:
-    Function function_;
-    spawned_coroutine_thread** spawned_thread_out_;
-  };
-
-  caller_type& caller_;
-  callee_type callee_;
-  void (*on_suspend_fn_)(void*);
-  void* on_suspend_arg_;
-};
-
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-// Spawned thread implementation using Boost.Context's fiber.
-class spawned_fiber_thread : public spawned_thread_base
-{
-public:
-  typedef boost::context::fiber fiber_type;
-
-  spawned_fiber_thread(fiber_type&& caller)
-    : caller_(static_cast<fiber_type&&>(caller)),
-      on_suspend_fn_(0),
-      on_suspend_arg_(0)
-  {
-  }
-
-  template <typename StackAllocator, typename F>
-  static spawned_thread_base* spawn(allocator_arg_t,
-      StackAllocator&& stack_allocator,
-      F&& f,
-      cancellation_slot parent_cancel_slot = cancellation_slot(),
-      cancellation_state cancel_state = cancellation_state())
-  {
-    spawned_fiber_thread* spawned_thread = 0;
-    fiber_type callee(allocator_arg_t(),
-        static_cast<StackAllocator&&>(stack_allocator),
-        entry_point<decay_t<F>>(
-          static_cast<F&&>(f), &spawned_thread));
-    callee = fiber_type(static_cast<fiber_type&&>(callee)).resume();
-    spawned_thread->callee_ = static_cast<fiber_type&&>(callee);
-    spawned_thread->parent_cancellation_slot_ = parent_cancel_slot;
-    spawned_thread->cancellation_state_ = cancel_state;
-    return spawned_thread;
-  }
-
-  template <typename F>
-  static spawned_thread_base* spawn(F&& f,
-      cancellation_slot parent_cancel_slot = cancellation_slot(),
-      cancellation_state cancel_state = cancellation_state())
-  {
-    return spawn(allocator_arg_t(), boost::context::fixedsize_stack(),
-        static_cast<F&&>(f), parent_cancel_slot, cancel_state);
-  }
-
-  void resume()
-  {
-    callee_ = fiber_type(static_cast<fiber_type&&>(callee_)).resume();
-    if (on_suspend_fn_)
-    {
-      void (*fn)(void*) = on_suspend_fn_;
-      void* arg = on_suspend_arg_;
-      on_suspend_fn_ = 0;
-      fn(arg);
-    }
-  }
-
-  void suspend_with(void (*fn)(void*), void* arg)
-  {
-    if (throw_if_cancelled_)
-      if (!!cancellation_state_.cancelled())
-        throw_error(asio::error::operation_aborted, "yield");
-    has_context_switched_ = true;
-    on_suspend_fn_ = fn;
-    on_suspend_arg_ = arg;
-    caller_ = fiber_type(static_cast<fiber_type&&>(caller_)).resume();
-  }
-
-  void destroy()
-  {
-    fiber_type callee = static_cast<fiber_type&&>(callee_);
-    if (terminal_)
-      fiber_type(static_cast<fiber_type&&>(callee)).resume();
-  }
-
-private:
-  template <typename Function>
-  class entry_point
-  {
-  public:
-    template <typename F>
-    entry_point(F&& f,
-        spawned_fiber_thread** spawned_thread_out)
-      : function_(static_cast<F&&>(f)),
-        spawned_thread_out_(spawned_thread_out)
-    {
-    }
-
-    fiber_type operator()(fiber_type&& caller)
-    {
-      Function function(static_cast<Function&&>(function_));
-      spawned_fiber_thread spawned_thread(
-          static_cast<fiber_type&&>(caller));
-      *spawned_thread_out_ = &spawned_thread;
-      spawned_thread_out_ = 0;
-      spawned_thread.suspend();
-#if !defined(ASIO_NO_EXCEPTIONS)
-      try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      {
-        function(&spawned_thread);
-        spawned_thread.terminal_ = true;
-        spawned_thread.suspend();
-      }
-#if !defined(ASIO_NO_EXCEPTIONS)
-      catch (const boost::context::detail::forced_unwind&)
-      {
-        throw;
-      }
-      catch (...)
-      {
-        exception_ptr ex = current_exception();
-        spawned_thread.terminal_ = true;
-        spawned_thread.suspend_with(spawned_thread_rethrow, &ex);
-      }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      return static_cast<fiber_type&&>(spawned_thread.caller_);
-    }
-
-  private:
-    Function function_;
-    spawned_fiber_thread** spawned_thread_out_;
-  };
-
-  fiber_type caller_;
-  fiber_type callee_;
-  void (*on_suspend_fn_)(void*);
-  void* on_suspend_arg_;
-};
-
-#endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-typedef spawned_fiber_thread default_spawned_thread_type;
-#elif defined(ASIO_HAS_BOOST_COROUTINE)
-typedef spawned_coroutine_thread default_spawned_thread_type;
-#else
-# error No spawn() implementation available
-#endif
-
-// Helper class to perform the initial resume on the correct executor.
-class spawned_thread_resumer
-{
-public:
-  explicit spawned_thread_resumer(spawned_thread_base* spawned_thread)
-    : spawned_thread_(spawned_thread)
-  {
-  }
-
-  spawned_thread_resumer(spawned_thread_resumer&& other) noexcept
-    : spawned_thread_(other.spawned_thread_)
-  {
-    other.spawned_thread_ = 0;
-  }
-
-  ~spawned_thread_resumer()
-  {
-    if (spawned_thread_)
-      spawned_thread_->destroy();
-  }
-
-  void operator()()
-  {
-    spawned_thread_->attach(&spawned_thread_);
-    spawned_thread_->resume();
-  }
-
-private:
-  spawned_thread_base* spawned_thread_;
-};
-
-// Helper class to ensure spawned threads are destroyed on the correct executor.
-class spawned_thread_destroyer
-{
-public:
-  explicit spawned_thread_destroyer(spawned_thread_base* spawned_thread)
-    : spawned_thread_(spawned_thread)
-  {
-    spawned_thread->detach();
-  }
-
-  spawned_thread_destroyer(spawned_thread_destroyer&& other) noexcept
-    : spawned_thread_(other.spawned_thread_)
-  {
-    other.spawned_thread_ = 0;
-  }
-
-  ~spawned_thread_destroyer()
-  {
-    if (spawned_thread_)
-      spawned_thread_->destroy();
-  }
-
-  void operator()()
-  {
-    if (spawned_thread_)
-    {
-      spawned_thread_->destroy();
-      spawned_thread_ = 0;
-    }
-  }
-
-private:
-  spawned_thread_base* spawned_thread_;
-};
-
-// Base class for all completion handlers associated with a spawned thread.
-template <typename Executor>
-class spawn_handler_base
-{
-public:
-  typedef Executor executor_type;
-  typedef cancellation_slot cancellation_slot_type;
-
-  spawn_handler_base(const basic_yield_context<Executor>& yield)
-    : yield_(yield),
-      spawned_thread_(yield.spawned_thread_)
-  {
-    spawned_thread_->detach();
-  }
-
-  spawn_handler_base(spawn_handler_base&& other) noexcept
-    : yield_(other.yield_),
-      spawned_thread_(other.spawned_thread_)
-
-  {
-    other.spawned_thread_ = 0;
-  }
-
-  ~spawn_handler_base()
-  {
-    if (spawned_thread_)
-      (post)(yield_.executor_, spawned_thread_destroyer(spawned_thread_));
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return yield_.executor_;
-  }
-
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return spawned_thread_->get_cancellation_slot();
-  }
-
-  void resume()
-  {
-    spawned_thread_resumer resumer(spawned_thread_);
-    spawned_thread_ = 0;
-    resumer();
-  }
-
-protected:
-  const basic_yield_context<Executor>& yield_;
-  spawned_thread_base* spawned_thread_;
-};
-
-// Completion handlers for when basic_yield_context is used as a token.
-template <typename Executor, typename Signature>
-class spawn_handler;
-
-template <typename Executor, typename R>
-class spawn_handler<Executor, R()>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef void return_type;
-
-  struct result_type {};
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type&)
-    : spawn_handler_base<Executor>(yield)
-  {
-  }
-
-  void operator()()
-  {
-    this->resume();
-  }
-
-  static return_type on_resume(result_type&)
-  {
-  }
-};
-
-template <typename Executor, typename R>
-class spawn_handler<Executor, R(asio::error_code)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef void return_type;
-  typedef asio::error_code* result_type;
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  void operator()(asio::error_code ec)
-  {
-    if (this->yield_.ec_)
-    {
-      *this->yield_.ec_ = ec;
-      result_ = 0;
-    }
-    else
-      result_ = &ec;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (result)
-      throw_error(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R>
-class spawn_handler<Executor, R(exception_ptr)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef void return_type;
-  typedef exception_ptr* result_type;
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  void operator()(exception_ptr ex)
-  {
-    result_ = &ex;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (*result)
-      rethrow_exception(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename T>
-class spawn_handler<Executor, R(T)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef T return_type;
-  typedef return_type* result_type;
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  void operator()(T value)
-  {
-    result_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    return static_cast<return_type&&>(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename T>
-class spawn_handler<Executor, R(asio::error_code, T)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef T return_type;
-
-  struct result_type
-  {
-    asio::error_code* ec_;
-    return_type* value_;
-  };
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  void operator()(asio::error_code ec, T value)
-  {
-    if (this->yield_.ec_)
-    {
-      *this->yield_.ec_ = ec;
-      result_.ec_ = 0;
-    }
-    else
-      result_.ec_ = &ec;
-    result_.value_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (result.ec_)
-      throw_error(*result.ec_);
-    return static_cast<return_type&&>(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename T>
-class spawn_handler<Executor, R(exception_ptr, T)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef T return_type;
-
-  struct result_type
-  {
-    exception_ptr* ex_;
-    return_type* value_;
-  };
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  void operator()(exception_ptr ex, T value)
-  {
-    result_.ex_ = &ex;
-    result_.value_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (*result.ex_)
-      rethrow_exception(*result.ex_);
-    return static_cast<return_type&&>(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename... Ts>
-class spawn_handler<Executor, R(Ts...)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef std::tuple<Ts...> return_type;
-
-  typedef return_type* result_type;
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    return_type value(static_cast<Args&&>(args)...);
-    result_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    return static_cast<return_type&&>(*result);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename... Ts>
-class spawn_handler<Executor, R(asio::error_code, Ts...)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef std::tuple<Ts...> return_type;
-
-  struct result_type
-  {
-    asio::error_code* ec_;
-    return_type* value_;
-  };
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(asio::error_code ec,
-      Args&&... args)
-  {
-    return_type value(static_cast<Args&&>(args)...);
-    if (this->yield_.ec_)
-    {
-      *this->yield_.ec_ = ec;
-      result_.ec_ = 0;
-    }
-    else
-      result_.ec_ = &ec;
-    result_.value_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (result.ec_)
-      throw_error(*result.ec_);
-    return static_cast<return_type&&>(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename R, typename... Ts>
-class spawn_handler<Executor, R(exception_ptr, Ts...)>
-  : public spawn_handler_base<Executor>
-{
-public:
-  typedef std::tuple<Ts...> return_type;
-
-  struct result_type
-  {
-    exception_ptr* ex_;
-    return_type* value_;
-  };
-
-  spawn_handler(const basic_yield_context<Executor>& yield, result_type& result)
-    : spawn_handler_base<Executor>(yield),
-      result_(result)
-  {
-  }
-
-  template <typename... Args>
-  void operator()(exception_ptr ex, Args&&... args)
-  {
-    return_type value(static_cast<Args&&>(args)...);
-    result_.ex_ = &ex;
-    result_.value_ = &value;
-    this->resume();
-  }
-
-  static return_type on_resume(result_type& result)
-  {
-    if (*result.ex_)
-      rethrow_exception(*result.ex_);
-    return static_cast<return_type&&>(*result.value_);
-  }
-
-private:
-  result_type& result_;
-};
-
-template <typename Executor, typename Signature>
-inline bool asio_handler_is_continuation(spawn_handler<Executor, Signature>*)
-{
-  return true;
-}
-
-} // namespace detail
-
-template <typename Executor, typename Signature>
-class async_result<basic_yield_context<Executor>, Signature>
-{
-public:
-  typedef typename detail::spawn_handler<Executor, Signature> handler_type;
-  typedef typename handler_type::return_type return_type;
-
-#if defined(ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&& init,
-      const basic_yield_context<Executor>& yield,
-      InitArgs&&... init_args)
-  {
-    typename handler_type::result_type result
-      = typename handler_type::result_type();
-
-    yield.spawned_thread_->suspend_with(
-        [&]()
-        {
-          static_cast<Initiation&&>(init)(
-              handler_type(yield, result),
-              static_cast<InitArgs&&>(init_args)...);
-        });
-
-    return handler_type::on_resume(result);
-  }
-
-#else // defined(ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-
-  template <typename Initiation, typename... InitArgs>
-  struct suspend_with_helper
-  {
-    typename handler_type::result_type& result_;
-    Initiation&& init_;
-    const basic_yield_context<Executor>& yield_;
-    std::tuple<InitArgs&&...> init_args_;
-
-    template <std::size_t... I>
-    void do_invoke(detail::index_sequence<I...>)
-    {
-      static_cast<Initiation&&>(init_)(
-          handler_type(yield_, result_),
-          static_cast<InitArgs&&>(std::get<I>(init_args_))...);
-    }
-
-    void operator()()
-    {
-      this->do_invoke(detail::make_index_sequence<sizeof...(InitArgs)>());
-    }
-  };
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&& init,
-      const basic_yield_context<Executor>& yield,
-      InitArgs&&... init_args)
-  {
-    typename handler_type::result_type result
-      = typename handler_type::result_type();
-
-    yield.spawned_thread_->suspend_with(
-      suspend_with_helper<Initiation, InitArgs...>{
-          result, static_cast<Initiation&&>(init), yield,
-          std::tuple<InitArgs&&...>(
-            static_cast<InitArgs&&>(init_args)...)});
-
-    return handler_type::on_resume(result);
-  }
-
-#endif // defined(ASIO_HAS_VARIADIC_LAMBDA_CAPTURES)
-};
-
-namespace detail {
-
-template <typename Executor, typename Function, typename Handler>
-class spawn_entry_point
-{
-public:
-  template <typename F, typename H>
-  spawn_entry_point(const Executor& ex,
-      F&& f, H&& h)
-    : executor_(ex),
-      function_(static_cast<F&&>(f)),
-      handler_(static_cast<H&&>(h)),
-      work_(handler_, executor_)
-  {
-  }
-
-  void operator()(spawned_thread_base* spawned_thread)
-  {
-    const basic_yield_context<Executor> yield(spawned_thread, executor_);
-    this->call(yield,
-        void_type<result_of_t<Function(basic_yield_context<Executor>)>>());
-  }
-
-private:
-  void call(const basic_yield_context<Executor>& yield, void_type<void>)
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-    {
-      function_(yield);
-      if (!yield.spawned_thread_->has_context_switched())
-        (post)(yield);
-      detail::binder1<Handler, exception_ptr>
-        handler(handler_, exception_ptr());
-      work_.complete(handler, handler.handler_);
-    }
-#if !defined(ASIO_NO_EXCEPTIONS)
-# if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-    catch (const boost::context::detail::forced_unwind&)
-    {
-      throw;
-    }
-# endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-# if defined(ASIO_HAS_BOOST_COROUTINE)
-    catch (const boost::coroutines::detail::forced_unwind&)
-    {
-      throw;
-    }
-# endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    catch (...)
-    {
-      exception_ptr ex = current_exception();
-      if (!yield.spawned_thread_->has_context_switched())
-        (post)(yield);
-      detail::binder1<Handler, exception_ptr> handler(handler_, ex);
-      work_.complete(handler, handler.handler_);
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  template <typename T>
-  void call(const basic_yield_context<Executor>& yield, void_type<T>)
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-    {
-      T result(function_(yield));
-      if (!yield.spawned_thread_->has_context_switched())
-        (post)(yield);
-      detail::binder2<Handler, exception_ptr, T>
-        handler(handler_, exception_ptr(), static_cast<T&&>(result));
-      work_.complete(handler, handler.handler_);
-    }
-#if !defined(ASIO_NO_EXCEPTIONS)
-# if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-    catch (const boost::context::detail::forced_unwind&)
-    {
-      throw;
-    }
-# endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-# if defined(ASIO_HAS_BOOST_COROUTINE)
-    catch (const boost::coroutines::detail::forced_unwind&)
-    {
-      throw;
-    }
-# endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    catch (...)
-    {
-      exception_ptr ex = current_exception();
-      if (!yield.spawned_thread_->has_context_switched())
-        (post)(yield);
-      detail::binder2<Handler, exception_ptr, T> handler(handler_, ex, T());
-      work_.complete(handler, handler.handler_);
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  Executor executor_;
-  Function function_;
-  Handler handler_;
-  handler_work<Handler, Executor> work_;
-};
-
-struct spawn_cancellation_signal_emitter
-{
-  cancellation_signal* signal_;
-  cancellation_type_t type_;
-
-  void operator()()
-  {
-    signal_->emit(type_);
-  }
-};
-
-template <typename Handler, typename Executor, typename = void>
-class spawn_cancellation_handler
-{
-public:
-  spawn_cancellation_handler(const Handler&, const Executor& ex)
-    : ex_(ex)
-  {
-  }
-
-  cancellation_slot slot()
-  {
-    return signal_.slot();
-  }
-
-  void operator()(cancellation_type_t type)
-  {
-    spawn_cancellation_signal_emitter emitter = { &signal_, type };
-    (dispatch)(ex_, emitter);
-  }
-
-private:
-  cancellation_signal signal_;
-  Executor ex_;
-};
-
-template <typename Handler, typename Executor>
-class spawn_cancellation_handler<Handler, Executor,
-    enable_if_t<
-      is_same<
-        typename associated_executor<Handler,
-          Executor>::asio_associated_executor_is_unspecialised,
-        void
-      >::value
-    >>
-{
-public:
-  spawn_cancellation_handler(const Handler&, const Executor&)
-  {
-  }
-
-  cancellation_slot slot()
-  {
-    return signal_.slot();
-  }
-
-  void operator()(cancellation_type_t type)
-  {
-    signal_.emit(type);
-  }
-
-private:
-  cancellation_signal signal_;
-};
-
-template <typename Executor>
-class initiate_spawn
-{
-public:
-  typedef Executor executor_type;
-
-  explicit initiate_spawn(const executor_type& ex)
-    : executor_(ex)
-  {
-  }
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  template <typename Handler, typename F>
-  void operator()(Handler&& handler,
-      F&& f) const
-  {
-    typedef decay_t<Handler> handler_type;
-    typedef decay_t<F> function_type;
-    typedef spawn_cancellation_handler<
-      handler_type, Executor> cancel_handler_type;
-
-    associated_cancellation_slot_t<handler_type> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    cancel_handler_type* cancel_handler = slot.is_connected()
-      ? &slot.template emplace<cancel_handler_type>(handler, executor_)
-      : 0;
-
-    cancellation_slot proxy_slot(
-        cancel_handler
-          ? cancel_handler->slot()
-          : cancellation_slot());
-
-    cancellation_state cancel_state(proxy_slot);
-
-    (dispatch)(executor_,
-        spawned_thread_resumer(
-          default_spawned_thread_type::spawn(
-            spawn_entry_point<Executor, function_type, handler_type>(
-              executor_, static_cast<F&&>(f),
-              static_cast<Handler&&>(handler)),
-            proxy_slot, cancel_state)));
-  }
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-  template <typename Handler, typename StackAllocator, typename F>
-  void operator()(Handler&& handler, allocator_arg_t,
-      StackAllocator&& stack_allocator,
-      F&& f) const
-  {
-    typedef decay_t<Handler> handler_type;
-    typedef decay_t<F> function_type;
-    typedef spawn_cancellation_handler<
-      handler_type, Executor> cancel_handler_type;
-
-    associated_cancellation_slot_t<handler_type> slot
-      = asio::get_associated_cancellation_slot(handler);
-
-    cancel_handler_type* cancel_handler = slot.is_connected()
-      ? &slot.template emplace<cancel_handler_type>(handler, executor_)
-      : 0;
-
-    cancellation_slot proxy_slot(
-        cancel_handler
-          ? cancel_handler->slot()
-          : cancellation_slot());
-
-    cancellation_state cancel_state(proxy_slot);
-
-    (dispatch)(executor_,
-        spawned_thread_resumer(
-          spawned_fiber_thread::spawn(allocator_arg_t(),
-            static_cast<StackAllocator&&>(stack_allocator),
-            spawn_entry_point<Executor, function_type, handler_type>(
-              executor_, static_cast<F&&>(f),
-              static_cast<Handler&&>(handler)),
-            proxy_slot, cancel_state)));
-  }
-
-#endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-private:
-  executor_type executor_;
-};
-
-} // namespace detail
-
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type) CompletionToken>
-inline auto spawn(const Executor& ex, F&& function, CompletionToken&& token,
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    >,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, static_cast<F&&>(function)))
-{
-  return async_initiate<CompletionToken,
-    typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type>(
-        detail::initiate_spawn<Executor>(ex),
-        token, static_cast<F&&>(function));
-}
-
-template <typename ExecutionContext, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>>::type) CompletionToken>
-inline auto spawn(ExecutionContext& ctx, F&& function, CompletionToken&& token,
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    >,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>>::type>(
-            declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type>>(),
-            token, static_cast<F&&>(function)))
-{
-  return (spawn)(ctx.get_executor(), static_cast<F&&>(function),
-      static_cast<CompletionToken&&>(token));
-}
-
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken>
-inline auto spawn(const basic_yield_context<Executor>& ctx,
-    F&& function, CompletionToken&& token,
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    >,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, static_cast<F&&>(function)))
-{
-  return (spawn)(ctx.get_executor(), static_cast<F&&>(function),
-      static_cast<CompletionToken&&>(token));
-}
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-template <typename Executor, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken>
-inline auto spawn(const Executor& ex, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, allocator_arg_t(),
-          static_cast<StackAllocator&&>(stack_allocator),
-          static_cast<F&&>(function)))
-{
-  return async_initiate<CompletionToken,
-    typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type>(
-        detail::initiate_spawn<Executor>(ex), token, allocator_arg_t(),
-        static_cast<StackAllocator&&>(stack_allocator),
-        static_cast<F&&>(function));
-}
-
-template <typename ExecutionContext, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>>::type) CompletionToken>
-inline auto spawn(ExecutionContext& ctx, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>>::type>(
-            declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type>>(),
-            token, allocator_arg_t(),
-            static_cast<StackAllocator&&>(stack_allocator),
-            static_cast<F&&>(function)))
-{
-  return (spawn)(ctx.get_executor(), allocator_arg_t(),
-      static_cast<StackAllocator&&>(stack_allocator),
-      static_cast<F&&>(function), static_cast<CompletionToken&&>(token));
-}
-
-template <typename Executor, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type) CompletionToken>
-inline auto spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function, CompletionToken&& token,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(), token,
-          allocator_arg_t(), static_cast<StackAllocator&&>(stack_allocator),
-          static_cast<F&&>(function)))
-{
-  return (spawn)(ctx.get_executor(), allocator_arg_t(),
-      static_cast<StackAllocator&&>(stack_allocator),
-      static_cast<F&&>(function), static_cast<CompletionToken&&>(token));
-}
-
-#endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-
-namespace detail {
-
-template <typename Executor, typename Function, typename Handler>
-class old_spawn_entry_point
-{
-public:
-  template <typename F, typename H>
-  old_spawn_entry_point(const Executor& ex, F&& f, H&& h)
-    : executor_(ex),
-      function_(static_cast<F&&>(f)),
-      handler_(static_cast<H&&>(h))
-  {
-  }
-
-  void operator()(spawned_thread_base* spawned_thread)
-  {
-    const basic_yield_context<Executor> yield(spawned_thread, executor_);
-    this->call(yield,
-        void_type<result_of_t<Function(basic_yield_context<Executor>)>>());
-  }
-
-private:
-  void call(const basic_yield_context<Executor>& yield, void_type<void>)
-  {
-    function_(yield);
-    static_cast<Handler&&>(handler_)();
-  }
-
-  template <typename T>
-  void call(const basic_yield_context<Executor>& yield, void_type<T>)
-  {
-    static_cast<Handler&&>(handler_)(function_(yield));
-  }
-
-  Executor executor_;
-  Function function_;
-  Handler handler_;
-};
-
-inline void default_spawn_handler() {}
-
-} // namespace detail
-
-template <typename Function>
-inline void spawn(Function&& function,
-    const boost::coroutines::attributes& attributes)
-{
-  associated_executor_t<decay_t<Function>> ex(
-      (get_associated_executor)(function));
-
-  asio::spawn(ex, static_cast<Function&&>(function), attributes);
-}
-
-template <typename Handler, typename Function>
-void spawn(Handler&& handler, Function&& function,
-    const boost::coroutines::attributes& attributes,
-    constraint_t<
-      !is_executor<decay_t<Handler>>::value &&
-      !execution::is_executor<decay_t<Handler>>::value &&
-      !is_convertible<Handler&, execution_context&>::value>)
-{
-  typedef associated_executor_t<decay_t<Handler>> executor_type;
-  executor_type ex((get_associated_executor)(handler));
-
-  (dispatch)(ex,
-      detail::spawned_thread_resumer(
-        detail::spawned_coroutine_thread::spawn(
-          detail::old_spawn_entry_point<executor_type,
-            decay_t<Function>, void (*)()>(
-              ex, static_cast<Function&&>(function),
-              &detail::default_spawn_handler), attributes)));
-}
-
-template <typename Executor, typename Function>
-void spawn(basic_yield_context<Executor> ctx, Function&& function,
-    const boost::coroutines::attributes& attributes)
-{
-  (dispatch)(ctx.get_executor(),
-      detail::spawned_thread_resumer(
-        detail::spawned_coroutine_thread::spawn(
-          detail::old_spawn_entry_point<Executor,
-            decay_t<Function>, void (*)()>(
-              ctx.get_executor(), static_cast<Function&&>(function),
-              &detail::default_spawn_handler), attributes)));
-}
-
-template <typename Function, typename Executor>
-inline void spawn(const Executor& ex, Function&& function,
-    const boost::coroutines::attributes& attributes,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    >)
-{
-  asio::spawn(asio::strand<Executor>(ex),
-      static_cast<Function&&>(function), attributes);
-}
-
-template <typename Function, typename Executor>
-inline void spawn(const strand<Executor>& ex, Function&& function,
-    const boost::coroutines::attributes& attributes)
-{
-  asio::spawn(asio::bind_executor(
-        ex, &detail::default_spawn_handler),
-      static_cast<Function&&>(function), attributes);
-}
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Function>
-inline void spawn(const asio::io_context::strand& s, Function&& function,
-    const boost::coroutines::attributes& attributes)
-{
-  asio::spawn(asio::bind_executor(
-        s, &detail::default_spawn_handler),
-      static_cast<Function&&>(function), attributes);
-}
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-template <typename Function, typename ExecutionContext>
-inline void spawn(ExecutionContext& ctx, Function&& function,
-    const boost::coroutines::attributes& attributes,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    >)
-{
-  asio::spawn(ctx.get_executor(),
-      static_cast<Function&&>(function), attributes);
-}
-
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_SPAWN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/src.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/src.hpp
deleted file mode 100644
index 2839619..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/src.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// impl/src.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SRC_HPP
-#define ASIO_IMPL_SRC_HPP
-
-#define ASIO_SOURCE
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# error Do not compile Asio library source with ASIO_HEADER_ONLY defined
-#endif
-
-#include "asio/impl/any_completion_executor.ipp"
-#include "asio/impl/any_io_executor.ipp"
-#include "asio/impl/cancellation_signal.ipp"
-#include "asio/impl/connect_pipe.ipp"
-#include "asio/impl/error.ipp"
-#include "asio/impl/error_code.ipp"
-#include "asio/impl/execution_context.ipp"
-#include "asio/impl/executor.ipp"
-#include "asio/impl/io_context.ipp"
-#include "asio/impl/multiple_exceptions.ipp"
-#include "asio/impl/serial_port_base.ipp"
-#include "asio/impl/system_context.ipp"
-#include "asio/impl/thread_pool.ipp"
-#include "asio/detail/impl/buffer_sequence_adapter.ipp"
-#include "asio/detail/impl/descriptor_ops.ipp"
-#include "asio/detail/impl/dev_poll_reactor.ipp"
-#include "asio/detail/impl/epoll_reactor.ipp"
-#include "asio/detail/impl/eventfd_select_interrupter.ipp"
-#include "asio/detail/impl/handler_tracking.ipp"
-#include "asio/detail/impl/io_uring_descriptor_service.ipp"
-#include "asio/detail/impl/io_uring_file_service.ipp"
-#include "asio/detail/impl/io_uring_socket_service_base.ipp"
-#include "asio/detail/impl/io_uring_service.ipp"
-#include "asio/detail/impl/kqueue_reactor.ipp"
-#include "asio/detail/impl/null_event.ipp"
-#include "asio/detail/impl/pipe_select_interrupter.ipp"
-#include "asio/detail/impl/posix_event.ipp"
-#include "asio/detail/impl/posix_mutex.ipp"
-#include "asio/detail/impl/posix_serial_port_service.ipp"
-#include "asio/detail/impl/posix_thread.ipp"
-#include "asio/detail/impl/posix_tss_ptr.ipp"
-#include "asio/detail/impl/reactive_descriptor_service.ipp"
-#include "asio/detail/impl/reactive_socket_service_base.ipp"
-#include "asio/detail/impl/resolver_service_base.ipp"
-#include "asio/detail/impl/scheduler.ipp"
-#include "asio/detail/impl/select_reactor.ipp"
-#include "asio/detail/impl/service_registry.ipp"
-#include "asio/detail/impl/signal_set_service.ipp"
-#include "asio/detail/impl/socket_ops.ipp"
-#include "asio/detail/impl/socket_select_interrupter.ipp"
-#include "asio/detail/impl/strand_executor_service.ipp"
-#include "asio/detail/impl/strand_service.ipp"
-#include "asio/detail/impl/thread_context.ipp"
-#include "asio/detail/impl/throw_error.ipp"
-#include "asio/detail/impl/timer_queue_ptime.ipp"
-#include "asio/detail/impl/timer_queue_set.ipp"
-#include "asio/detail/impl/win_iocp_file_service.ipp"
-#include "asio/detail/impl/win_iocp_handle_service.ipp"
-#include "asio/detail/impl/win_iocp_io_context.ipp"
-#include "asio/detail/impl/win_iocp_serial_port_service.ipp"
-#include "asio/detail/impl/win_iocp_socket_service_base.ipp"
-#include "asio/detail/impl/win_event.ipp"
-#include "asio/detail/impl/win_mutex.ipp"
-#include "asio/detail/impl/win_object_handle_service.ipp"
-#include "asio/detail/impl/win_static_mutex.ipp"
-#include "asio/detail/impl/win_thread.ipp"
-#include "asio/detail/impl/win_tss_ptr.ipp"
-#include "asio/detail/impl/winrt_ssocket_service_base.ipp"
-#include "asio/detail/impl/winrt_timer_scheduler.ipp"
-#include "asio/detail/impl/winsock_init.ipp"
-#include "asio/execution/impl/bad_executor.ipp"
-#include "asio/experimental/impl/channel_error.ipp"
-#include "asio/generic/detail/impl/endpoint.ipp"
-#include "asio/ip/impl/address.ipp"
-#include "asio/ip/impl/address_v4.ipp"
-#include "asio/ip/impl/address_v6.ipp"
-#include "asio/ip/impl/host_name.ipp"
-#include "asio/ip/impl/network_v4.ipp"
-#include "asio/ip/impl/network_v6.ipp"
-#include "asio/ip/detail/impl/endpoint.ipp"
-#include "asio/local/detail/impl/endpoint.ipp"
-
-#endif // ASIO_IMPL_SRC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.hpp
deleted file mode 100644
index 34b5a3a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// impl/system_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SYSTEM_CONTEXT_HPP
-#define ASIO_IMPL_SYSTEM_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/system_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-inline system_context::executor_type
-system_context::get_executor() noexcept
-{
-  return system_executor();
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_SYSTEM_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.ipp
deleted file mode 100644
index 95fda48..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_context.ipp
+++ /dev/null
@@ -1,92 +0,0 @@
-//
-// impl/system_context.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SYSTEM_CONTEXT_IPP
-#define ASIO_IMPL_SYSTEM_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/system_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-struct system_context::thread_function
-{
-  detail::scheduler* scheduler_;
-
-  void operator()()
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-      asio::error_code ec;
-      scheduler_->run(ec);
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      std::terminate();
-    }
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-  }
-};
-
-system_context::system_context()
-  : scheduler_(add_scheduler(new detail::scheduler(*this, 0, false)))
-{
-  scheduler_.work_started();
-
-  thread_function f = { &scheduler_ };
-  num_threads_ = detail::thread::hardware_concurrency() * 2;
-  num_threads_ = num_threads_ ? num_threads_ : 2;
-  threads_.create_threads(f, num_threads_);
-}
-
-system_context::~system_context()
-{
-  scheduler_.work_finished();
-  scheduler_.stop();
-  threads_.join();
-}
-
-void system_context::stop()
-{
-  scheduler_.stop();
-}
-
-bool system_context::stopped() const noexcept
-{
-  return scheduler_.stopped();
-}
-
-void system_context::join()
-{
-  scheduler_.work_finished();
-  threads_.join();
-}
-
-detail::scheduler& system_context::add_scheduler(detail::scheduler* s)
-{
-  detail::scoped_ptr<detail::scheduler> scoped_impl(s);
-  asio::add_service<detail::scheduler>(*this, scoped_impl.get());
-  return *scoped_impl.release();
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_SYSTEM_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_executor.hpp
deleted file mode 100644
index 099b2d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/system_executor.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-//
-// impl/system_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_SYSTEM_EXECUTOR_HPP
-#define ASIO_IMPL_SYSTEM_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/global.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/system_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Blocking, typename Relationship, typename Allocator>
-inline system_context&
-basic_system_executor<Blocking, Relationship, Allocator>::query(
-    execution::context_t) noexcept
-{
-  return detail::global<system_context>();
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-inline std::size_t
-basic_system_executor<Blocking, Relationship, Allocator>::query(
-    execution::occupancy_t) const noexcept
-{
-  return detail::global<system_context>().num_threads_;
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function>
-inline void
-basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    Function&& f, execution::blocking_t::possibly_t) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-  try
-  {
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-    detail::fenced_block b(detail::fenced_block::full);
-    static_cast<decay_t<Function>&&>(f2.value)();
-#if !defined(ASIO_NO_EXCEPTIONS)
-  }
-  catch (...)
-  {
-    std::terminate();
-  }
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function>
-inline void
-basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    Function&& f, execution::blocking_t::always_t) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-  try
-  {
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-    detail::fenced_block b(detail::fenced_block::full);
-    static_cast<decay_t<Function>&&>(f2.value)();
-#if !defined(ASIO_NO_EXCEPTIONS)
-  }
-  catch (...)
-  {
-    std::terminate();
-  }
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function>
-void basic_system_executor<Blocking, Relationship, Allocator>::do_execute(
-    Function&& f, execution::blocking_t::never_t) const
-{
-  system_context& ctx = detail::global<system_context>();
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<decay_t<Function>, Allocator> op;
-  typename op::ptr p = { detail::addressof(allocator_),
-      op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), allocator_);
-
-  if (is_same<Relationship, execution::relationship_t::continuation_t>::value)
-  {
-    ASIO_HANDLER_CREATION((ctx, *p.p,
-          "system_executor", &ctx, 0, "execute(blk=never,rel=cont)"));
-  }
-  else
-  {
-    ASIO_HANDLER_CREATION((ctx, *p.p,
-          "system_executor", &ctx, 0, "execute(blk=never,rel=fork)"));
-  }
-
-  ctx.scheduler_.post_immediate_completion(p.p,
-      is_same<Relationship, execution::relationship_t::continuation_t>::value);
-  p.v = p.p = 0;
-}
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-template <typename Blocking, typename Relationship, typename Allocator>
-inline system_context& basic_system_executor<
-    Blocking, Relationship, Allocator>::context() const noexcept
-{
-  return detail::global<system_context>();
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function, typename OtherAllocator>
-void basic_system_executor<Blocking, Relationship, Allocator>::dispatch(
-    Function&& f, const OtherAllocator&) const
-{
-  decay_t<Function>(static_cast<Function&&>(f))();
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function, typename OtherAllocator>
-void basic_system_executor<Blocking, Relationship, Allocator>::post(
-    Function&& f, const OtherAllocator& a) const
-{
-  system_context& ctx = detail::global<system_context>();
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<decay_t<Function>, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((ctx, *p.p,
-        "system_executor", &this->context(), 0, "post"));
-
-  ctx.scheduler_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
-template <typename Blocking, typename Relationship, typename Allocator>
-template <typename Function, typename OtherAllocator>
-void basic_system_executor<Blocking, Relationship, Allocator>::defer(
-    Function&& f, const OtherAllocator& a) const
-{
-  system_context& ctx = detail::global<system_context>();
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<decay_t<Function>, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((ctx, *p.p,
-        "system_executor", &this->context(), 0, "defer"));
-
-  ctx.scheduler_.post_immediate_completion(p.p, true);
-  p.v = p.p = 0;
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_SYSTEM_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.hpp
deleted file mode 100644
index 3aed249..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.hpp
+++ /dev/null
@@ -1,277 +0,0 @@
-//
-// impl/thread_pool.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_THREAD_POOL_HPP
-#define ASIO_IMPL_THREAD_POOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/blocking_executor_op.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-inline thread_pool::executor_type
-thread_pool::get_executor() noexcept
-{
-  return executor_type(*this);
-}
-
-inline thread_pool::executor_type
-thread_pool::executor() noexcept
-{
-  return executor_type(*this);
-}
-
-template <typename Allocator, unsigned int Bits>
-thread_pool::basic_executor_type<Allocator, Bits>&
-thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) noexcept
-{
-  if (this != &other)
-  {
-    thread_pool* old_thread_pool = pool_;
-    pool_ = other.pool_;
-    allocator_ = other.allocator_;
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-    {
-      if (pool_)
-        pool_->scheduler_.work_started();
-      if (old_thread_pool)
-        old_thread_pool->scheduler_.work_finished();
-    }
-  }
-  return *this;
-}
-
-template <typename Allocator, unsigned int Bits>
-thread_pool::basic_executor_type<Allocator, Bits>&
-thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) noexcept
-{
-  if (this != &other)
-  {
-    thread_pool* old_thread_pool = pool_;
-    pool_ = other.pool_;
-    allocator_ = std::move(other.allocator_);
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-    {
-      other.pool_ = 0;
-      if (old_thread_pool)
-        old_thread_pool->scheduler_.work_finished();
-    }
-  }
-  return *this;
-}
-
-template <typename Allocator, unsigned int Bits>
-inline bool thread_pool::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const noexcept
-{
-  return pool_->scheduler_.can_dispatch();
-}
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(Function&& f, false_type) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Invoke immediately if the blocking.possibly property is enabled and we are
-  // already inside the thread pool.
-  if ((bits_ & blocking_never) == 0 && pool_->scheduler_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(f));
-
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      static_cast<function_type&&>(tmp)();
-      return;
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      pool_->scheduler_.capture_current_exception();
-      return;
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(allocator_),
-      op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), allocator_);
-
-  if ((bits_ & relationship_continuation) != 0)
-  {
-    ASIO_HANDLER_CREATION((*pool_, *p.p,
-          "thread_pool", pool_, 0, "execute(blk=never,rel=cont)"));
-  }
-  else
-  {
-    ASIO_HANDLER_CREATION((*pool_, *p.p,
-          "thread_pool", pool_, 0, "execute(blk=never,rel=fork)"));
-  }
-
-  pool_->scheduler_.post_immediate_completion(p.p,
-      (bits_ & relationship_continuation) != 0);
-  p.v = p.p = 0;
-}
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(Function&& f, true_type) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-
-  // Invoke immediately if we are already inside the thread pool.
-  if (pool_->scheduler_.can_dispatch())
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      static_cast<decay_t<Function>&&>(f2.value)();
-      return;
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      std::terminate();
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-  // Construct an operation to wrap the function.
-  typedef decay_t<Function> function_type;
-  detail::blocking_executor_op<function_type> op(f2.value);
-
-  ASIO_HANDLER_CREATION((*pool_, op,
-        "thread_pool", pool_, 0, "execute(blk=always)"));
-
-  pool_->scheduler_.post_immediate_completion(&op, false);
-  op.wait();
-}
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-template <typename Allocator, unsigned int Bits>
-inline thread_pool& thread_pool::basic_executor_type<
-    Allocator, Bits>::context() const noexcept
-{
-  return *pool_;
-}
-
-template <typename Allocator, unsigned int Bits>
-inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_started() const noexcept
-{
-  pool_->scheduler_.work_started();
-}
-
-template <typename Allocator, unsigned int Bits>
-inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const noexcept
-{
-  pool_->scheduler_.work_finished();
-}
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
-    Function&& f, const OtherAllocator& a) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Invoke immediately if we are already inside the thread pool.
-  if (pool_->scheduler_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(static_cast<Function&&>(f));
-
-    detail::fenced_block b(detail::fenced_block::full);
-    static_cast<function_type&&>(tmp)();
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "dispatch"));
-
-  pool_->scheduler_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::post(
-    Function&& f, const OtherAllocator& a) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "post"));
-
-  pool_->scheduler_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::defer(
-    Function&& f, const OtherAllocator& a) const
-{
-  typedef decay_t<Function> function_type;
-
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(static_cast<Function&&>(f), a);
-
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "defer"));
-
-  pool_->scheduler_.post_immediate_completion(p.p, true);
-  p.v = p.p = 0;
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_THREAD_POOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.ipp
deleted file mode 100644
index 3f327e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/thread_pool.ipp
+++ /dev/null
@@ -1,142 +0,0 @@
-//
-// impl/thread_pool.ipp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_THREAD_POOL_IPP
-#define ASIO_IMPL_THREAD_POOL_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <stdexcept>
-#include "asio/thread_pool.hpp"
-#include "asio/detail/throw_exception.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-struct thread_pool::thread_function
-{
-  detail::scheduler* scheduler_;
-
-  void operator()()
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-      asio::error_code ec;
-      scheduler_->run(ec);
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      std::terminate();
-    }
-#endif// !defined(ASIO_NO_EXCEPTIONS)
-  }
-};
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-namespace detail {
-
-inline long default_thread_pool_size()
-{
-  std::size_t num_threads = thread::hardware_concurrency() * 2;
-  num_threads = num_threads == 0 ? 2 : num_threads;
-  return static_cast<long>(num_threads);
-}
-
-} // namespace detail
-
-thread_pool::thread_pool()
-  : scheduler_(add_scheduler(new detail::scheduler(*this, 0, false))),
-    num_threads_(detail::default_thread_pool_size())
-{
-  scheduler_.work_started();
-
-  thread_function f = { &scheduler_ };
-  threads_.create_threads(f, static_cast<std::size_t>(num_threads_));
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-namespace detail {
-
-inline long clamp_thread_pool_size(std::size_t n)
-{
-  if (n > 0x7FFFFFFF)
-  {
-    std::out_of_range ex("thread pool size");
-    asio::detail::throw_exception(ex);
-  }
-  return static_cast<long>(n & 0x7FFFFFFF);
-}
-
-} // namespace detail
-
-thread_pool::thread_pool(std::size_t num_threads)
-  : scheduler_(add_scheduler(new detail::scheduler(
-          *this, num_threads == 1 ? 1 : 0, false))),
-    num_threads_(detail::clamp_thread_pool_size(num_threads))
-{
-  scheduler_.work_started();
-
-  thread_function f = { &scheduler_ };
-  threads_.create_threads(f, static_cast<std::size_t>(num_threads_));
-}
-
-thread_pool::~thread_pool()
-{
-  stop();
-  join();
-  shutdown();
-}
-
-void thread_pool::stop()
-{
-  scheduler_.stop();
-}
-
-void thread_pool::attach()
-{
-  ++num_threads_;
-  thread_function f = { &scheduler_ };
-  f();
-}
-
-void thread_pool::join()
-{
-  if (num_threads_)
-    scheduler_.work_finished();
-
-  if (!threads_.empty())
-    threads_.join();
-}
-
-detail::scheduler& thread_pool::add_scheduler(detail::scheduler* s)
-{
-  detail::scoped_ptr<detail::scheduler> scoped_impl(s);
-  asio::add_service<detail::scheduler>(*this, scoped_impl.get());
-  return *scoped_impl.release();
-}
-
-void thread_pool::wait()
-{
-  scheduler_.work_finished();
-  threads_.join();
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_THREAD_POOL_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_awaitable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_awaitable.hpp
deleted file mode 100644
index 3cd9516..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_awaitable.hpp
+++ /dev/null
@@ -1,301 +0,0 @@
-//
-// impl/use_awaitable.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_USE_AWAITABLE_HPP
-#define ASIO_IMPL_USE_AWAITABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/cancellation_signal.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Executor, typename T>
-class awaitable_handler_base
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef void result_type;
-  typedef awaitable<T, Executor> awaitable_type;
-
-  // Construct from the entry point of a new thread of execution.
-  awaitable_handler_base(awaitable<awaitable_thread_entry_point, Executor> a,
-      const Executor& ex, cancellation_slot pcs, cancellation_state cs)
-    : awaitable_thread<Executor>(std::move(a), ex, pcs, cs)
-  {
-  }
-
-  // Transfer ownership from another awaitable_thread.
-  explicit awaitable_handler_base(awaitable_thread<Executor>* h)
-    : awaitable_thread<Executor>(std::move(*h))
-  {
-  }
-
-protected:
-  awaitable_frame<T, Executor>* frame() noexcept
-  {
-    return static_cast<awaitable_frame<T, Executor>*>(
-        this->entry_point()->top_of_stack_);
-  }
-};
-
-template <typename, typename...>
-class awaitable_handler;
-
-template <typename Executor>
-class awaitable_handler<Executor>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-
-  void operator()()
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor>
-class awaitable_handler<Executor, asio::error_code>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-
-  void operator()(const asio::error_code& ec)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor>
-class awaitable_handler<Executor, std::exception_ptr>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-
-  void operator()(std::exception_ptr ex)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename T>
-class awaitable_handler<Executor, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-
-  template <typename Arg>
-  void operator()(Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename T>
-class awaitable_handler<Executor, asio::error_code, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-
-  template <typename Arg>
-  void operator()(const asio::error_code& ec, Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename T>
-class awaitable_handler<Executor, std::exception_ptr, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-
-  template <typename Arg>
-  void operator()(std::exception_ptr ex, Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename... Ts>
-class awaitable_handler
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename... Ts>
-class awaitable_handler<Executor, asio::error_code, Ts...>
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-
-  template <typename... Args>
-  void operator()(const asio::error_code& ec, Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-template <typename Executor, typename... Ts>
-class awaitable_handler<Executor, std::exception_ptr, Ts...>
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-
-  template <typename... Args>
-  void operator()(std::exception_ptr ex, Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-#if defined(_MSC_VER)
-template <typename T>
-T dummy_return()
-{
-  return std::move(*static_cast<T*>(nullptr));
-}
-
-template <>
-inline void dummy_return()
-{
-}
-#endif // defined(_MSC_VER)
-
-template <typename Executor, typename R, typename... Args>
-class async_result<use_awaitable_t<Executor>, R(Args...)>
-{
-public:
-  typedef typename detail::awaitable_handler<
-      Executor, decay_t<Args>...> handler_type;
-  typedef typename handler_type::awaitable_type return_type;
-
-  template <typename Initiation, typename... InitArgs>
-#if defined(__APPLE_CC__) && (__clang_major__ == 13)
-  __attribute__((noinline))
-#endif // defined(__APPLE_CC__) && (__clang_major__ == 13)
-  static handler_type* do_init(
-      detail::awaitable_frame_base<Executor>* frame, Initiation& initiation,
-      use_awaitable_t<Executor> u, InitArgs&... args)
-  {
-    (void)u;
-    ASIO_HANDLER_LOCATION((u.file_name_, u.line_, u.function_name_));
-    handler_type handler(frame->detach_thread());
-    std::move(initiation)(std::move(handler), std::move(args)...);
-    return nullptr;
-  }
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation initiation,
-      use_awaitable_t<Executor> u, InitArgs... args)
-  {
-    co_await [&] (auto* frame)
-      {
-        return do_init(frame, initiation, u, args...);
-      };
-
-    for (;;) {} // Never reached.
-#if defined(_MSC_VER)
-    co_return dummy_return<typename return_type::value_type>();
-#endif // defined(_MSC_VER)
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_USE_AWAITABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_future.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_future.hpp
deleted file mode 100644
index 579b93f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/use_future.hpp
+++ /dev/null
@@ -1,707 +0,0 @@
-//
-// impl/use_future.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_USE_FUTURE_HPP
-#define ASIO_IMPL_USE_FUTURE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/async_result.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/error_code.hpp"
-#include "asio/execution.hpp"
-#include "asio/packaged_task.hpp"
-#include "asio/system_error.hpp"
-#include "asio/system_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T, typename F, typename... Args>
-inline void promise_invoke_and_set(std::promise<T>& p,
-    F& f, Args&&... args)
-{
-#if !defined(ASIO_NO_EXCEPTIONS)
-  try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  {
-    p.set_value(f(static_cast<Args&&>(args)...));
-  }
-#if !defined(ASIO_NO_EXCEPTIONS)
-  catch (...)
-  {
-    p.set_exception(std::current_exception());
-  }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-}
-
-template <typename F, typename... Args>
-inline void promise_invoke_and_set(std::promise<void>& p,
-    F& f, Args&&... args)
-{
-#if !defined(ASIO_NO_EXCEPTIONS)
-  try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  {
-    f(static_cast<Args&&>(args)...);
-    p.set_value();
-  }
-#if !defined(ASIO_NO_EXCEPTIONS)
-  catch (...)
-  {
-    p.set_exception(std::current_exception());
-  }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-}
-
-// A function object adapter to invoke a nullary function object and capture
-// any exception thrown into a promise.
-template <typename T, typename F>
-class promise_invoker
-{
-public:
-  promise_invoker(const shared_ptr<std::promise<T>>& p,
-      F&& f)
-    : p_(p), f_(static_cast<F&&>(f))
-  {
-  }
-
-  void operator()()
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-    {
-      f_();
-    }
-#if !defined(ASIO_NO_EXCEPTIONS)
-    catch (...)
-    {
-      p_->set_exception(std::current_exception());
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-
-private:
-  shared_ptr<std::promise<T>> p_;
-  decay_t<F> f_;
-};
-
-// An executor that adapts the system_executor to capture any exeption thrown
-// by a submitted function object and save it into a promise.
-template <typename T, typename Blocking = execution::blocking_t::possibly_t>
-class promise_executor
-{
-public:
-  explicit promise_executor(const shared_ptr<std::promise<T>>& p)
-    : p_(p)
-  {
-  }
-
-  execution_context& query(execution::context_t) const noexcept
-  {
-    return asio::query(system_executor(), execution::context);
-  }
-
-  static constexpr Blocking query(execution::blocking_t)
-  {
-    return Blocking();
-  }
-
-  promise_executor<T, execution::blocking_t::possibly_t>
-  require(execution::blocking_t::possibly_t) const
-  {
-    return promise_executor<T, execution::blocking_t::possibly_t>(p_);
-  }
-
-  promise_executor<T, execution::blocking_t::never_t>
-  require(execution::blocking_t::never_t) const
-  {
-    return promise_executor<T, execution::blocking_t::never_t>(p_);
-  }
-
-  template <typename F>
-  void execute(F&& f) const
-  {
-    asio::require(system_executor(), Blocking()).execute(
-        promise_invoker<T, F>(p_, static_cast<F&&>(f)));
-  }
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-  execution_context& context() const noexcept
-  {
-    return system_executor().context();
-  }
-
-  void on_work_started() const noexcept {}
-  void on_work_finished() const noexcept {}
-
-  template <typename F, typename A>
-  void dispatch(F&& f, const A&) const
-  {
-    promise_invoker<T, F>(p_, static_cast<F&&>(f))();
-  }
-
-  template <typename F, typename A>
-  void post(F&& f, const A& a) const
-  {
-    system_executor().post(
-        promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
-  }
-
-  template <typename F, typename A>
-  void defer(F&& f, const A& a) const
-  {
-    system_executor().defer(
-        promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
-  }
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-  friend bool operator==(const promise_executor& a,
-      const promise_executor& b) noexcept
-  {
-    return a.p_ == b.p_;
-  }
-
-  friend bool operator!=(const promise_executor& a,
-      const promise_executor& b) noexcept
-  {
-    return a.p_ != b.p_;
-  }
-
-private:
-  shared_ptr<std::promise<T>> p_;
-};
-
-// The base class for all completion handlers that create promises.
-template <typename T>
-class promise_creator
-{
-public:
-  typedef promise_executor<T> executor_type;
-
-  executor_type get_executor() const noexcept
-  {
-    return executor_type(p_);
-  }
-
-  typedef std::future<T> future_type;
-
-  future_type get_future()
-  {
-    return p_->get_future();
-  }
-
-protected:
-  template <typename Allocator>
-  void create_promise(const Allocator& a)
-  {
-    ASIO_REBIND_ALLOC(Allocator, char) b(a);
-    p_ = std::allocate_shared<std::promise<T>>(b, std::allocator_arg, b);
-  }
-
-  shared_ptr<std::promise<T>> p_;
-};
-
-// For completion signature void().
-class promise_handler_0
-  : public promise_creator<void>
-{
-public:
-  void operator()()
-  {
-    this->p_->set_value();
-  }
-};
-
-// For completion signature void(error_code).
-class promise_handler_ec_0
-  : public promise_creator<void>
-{
-public:
-  void operator()(const asio::error_code& ec)
-  {
-    if (ec)
-    {
-      this->p_->set_exception(
-          std::make_exception_ptr(
-            asio::system_error(ec)));
-    }
-    else
-    {
-      this->p_->set_value();
-    }
-  }
-};
-
-// For completion signature void(exception_ptr).
-class promise_handler_ex_0
-  : public promise_creator<void>
-{
-public:
-  void operator()(const std::exception_ptr& ex)
-  {
-    if (ex)
-    {
-      this->p_->set_exception(ex);
-    }
-    else
-    {
-      this->p_->set_value();
-    }
-  }
-};
-
-// For completion signature void(T).
-template <typename T>
-class promise_handler_1
-  : public promise_creator<T>
-{
-public:
-  template <typename Arg>
-  void operator()(Arg&& arg)
-  {
-    this->p_->set_value(static_cast<Arg&&>(arg));
-  }
-};
-
-// For completion signature void(error_code, T).
-template <typename T>
-class promise_handler_ec_1
-  : public promise_creator<T>
-{
-public:
-  template <typename Arg>
-  void operator()(const asio::error_code& ec,
-      Arg&& arg)
-  {
-    if (ec)
-    {
-      this->p_->set_exception(
-          std::make_exception_ptr(
-            asio::system_error(ec)));
-    }
-    else
-      this->p_->set_value(static_cast<Arg&&>(arg));
-  }
-};
-
-// For completion signature void(exception_ptr, T).
-template <typename T>
-class promise_handler_ex_1
-  : public promise_creator<T>
-{
-public:
-  template <typename Arg>
-  void operator()(const std::exception_ptr& ex,
-      Arg&& arg)
-  {
-    if (ex)
-      this->p_->set_exception(ex);
-    else
-      this->p_->set_value(static_cast<Arg&&>(arg));
-  }
-};
-
-// For completion signature void(T1, ..., Tn);
-template <typename T>
-class promise_handler_n
-  : public promise_creator<T>
-{
-public:
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    this->p_->set_value(
-        std::forward_as_tuple(
-          static_cast<Args&&>(args)...));
-  }
-};
-
-// For completion signature void(error_code, T1, ..., Tn);
-template <typename T>
-class promise_handler_ec_n
-  : public promise_creator<T>
-{
-public:
-  template <typename... Args>
-  void operator()(const asio::error_code& ec, Args&&... args)
-  {
-    if (ec)
-    {
-      this->p_->set_exception(
-          std::make_exception_ptr(
-            asio::system_error(ec)));
-    }
-    else
-    {
-      this->p_->set_value(
-          std::forward_as_tuple(
-            static_cast<Args&&>(args)...));
-    }
-  }
-};
-
-// For completion signature void(exception_ptr, T1, ..., Tn);
-template <typename T>
-class promise_handler_ex_n
-  : public promise_creator<T>
-{
-public:
-  template <typename... Args>
-  void operator()(const std::exception_ptr& ex,
-      Args&&... args)
-  {
-    if (ex)
-      this->p_->set_exception(ex);
-    else
-    {
-      this->p_->set_value(
-          std::forward_as_tuple(
-            static_cast<Args&&>(args)...));
-    }
-  }
-};
-
-// Helper template to choose the appropriate concrete promise handler
-// implementation based on the supplied completion signature.
-template <typename> class promise_handler_selector;
-
-template <>
-class promise_handler_selector<void()>
-  : public promise_handler_0 {};
-
-template <>
-class promise_handler_selector<void(asio::error_code)>
-  : public promise_handler_ec_0 {};
-
-template <>
-class promise_handler_selector<void(std::exception_ptr)>
-  : public promise_handler_ex_0 {};
-
-template <typename Arg>
-class promise_handler_selector<void(Arg)>
-  : public promise_handler_1<Arg> {};
-
-template <typename Arg>
-class promise_handler_selector<void(asio::error_code, Arg)>
-  : public promise_handler_ec_1<Arg> {};
-
-template <typename Arg>
-class promise_handler_selector<void(std::exception_ptr, Arg)>
-  : public promise_handler_ex_1<Arg> {};
-
-template <typename... Arg>
-class promise_handler_selector<void(Arg...)>
-  : public promise_handler_n<std::tuple<Arg...>> {};
-
-template <typename... Arg>
-class promise_handler_selector<void(asio::error_code, Arg...)>
-  : public promise_handler_ec_n<std::tuple<Arg...>> {};
-
-template <typename... Arg>
-class promise_handler_selector<void(std::exception_ptr, Arg...)>
-  : public promise_handler_ex_n<std::tuple<Arg...>> {};
-
-// Completion handlers produced from the use_future completion token, when not
-// using use_future::operator().
-template <typename Signature, typename Allocator>
-class promise_handler
-  : public promise_handler_selector<Signature>
-{
-public:
-  typedef Allocator allocator_type;
-  typedef void result_type;
-
-  promise_handler(use_future_t<Allocator> u)
-    : allocator_(u.get_allocator())
-  {
-    this->create_promise(allocator_);
-  }
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-private:
-  Allocator allocator_;
-};
-
-template <typename Function>
-struct promise_function_wrapper
-{
-  explicit promise_function_wrapper(Function& f)
-    : function_(static_cast<Function&&>(f))
-  {
-  }
-
-  explicit promise_function_wrapper(const Function& f)
-    : function_(f)
-  {
-  }
-
-  void operator()()
-  {
-    function_();
-  }
-
-  Function function_;
-};
-
-// Helper base class for async_result specialisation.
-template <typename Signature, typename Allocator>
-class promise_async_result
-{
-public:
-  typedef promise_handler<Signature, Allocator> completion_handler_type;
-  typedef typename completion_handler_type::future_type return_type;
-
-  explicit promise_async_result(completion_handler_type& h)
-    : future_(h.get_future())
-  {
-  }
-
-  return_type get()
-  {
-    return static_cast<return_type&&>(future_);
-  }
-
-private:
-  return_type future_;
-};
-
-// Return value from use_future::operator().
-template <typename Function, typename Allocator>
-class packaged_token
-{
-public:
-  packaged_token(Function f, const Allocator& a)
-    : function_(static_cast<Function&&>(f)),
-      allocator_(a)
-  {
-  }
-
-//private:
-  Function function_;
-  Allocator allocator_;
-};
-
-// Completion handlers produced from the use_future completion token, when
-// using use_future::operator().
-template <typename Function, typename Allocator, typename Result>
-class packaged_handler
-  : public promise_creator<Result>
-{
-public:
-  typedef Allocator allocator_type;
-  typedef void result_type;
-
-  packaged_handler(packaged_token<Function, Allocator> t)
-    : function_(static_cast<Function&&>(t.function_)),
-      allocator_(t.allocator_)
-  {
-    this->create_promise(allocator_);
-  }
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_;
-  }
-
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    (promise_invoke_and_set)(*this->p_,
-        function_, static_cast<Args&&>(args)...);
-  }
-
-private:
-  Function function_;
-  Allocator allocator_;
-};
-
-// Helper base class for async_result specialisation.
-template <typename Function, typename Allocator, typename Result>
-class packaged_async_result
-{
-public:
-  typedef packaged_handler<Function, Allocator, Result> completion_handler_type;
-  typedef typename completion_handler_type::future_type return_type;
-
-  explicit packaged_async_result(completion_handler_type& h)
-    : future_(h.get_future())
-  {
-  }
-
-  return_type get()
-  {
-    return static_cast<return_type&&>(future_);
-  }
-
-private:
-  return_type future_;
-};
-
-} // namespace detail
-
-template <typename Allocator> template <typename Function>
-inline detail::packaged_token<decay_t<Function>, Allocator>
-use_future_t<Allocator>::operator()(Function&& f) const
-{
-  return detail::packaged_token<decay_t<Function>, Allocator>(
-      static_cast<Function&&>(f), allocator_);
-}
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <typename Allocator, typename Result, typename... Args>
-class async_result<use_future_t<Allocator>, Result(Args...)>
-  : public detail::promise_async_result<
-      void(decay_t<Args>...), Allocator>
-{
-public:
-  explicit async_result(
-    typename detail::promise_async_result<void(decay_t<Args>...),
-      Allocator>::completion_handler_type& h)
-    : detail::promise_async_result<
-        void(decay_t<Args>...), Allocator>(h)
-  {
-  }
-};
-
-template <typename Function, typename Allocator,
-    typename Result, typename... Args>
-class async_result<detail::packaged_token<Function, Allocator>, Result(Args...)>
-  : public detail::packaged_async_result<Function, Allocator,
-      result_of_t<Function(Args...)>>
-{
-public:
-  explicit async_result(
-    typename detail::packaged_async_result<Function, Allocator,
-      result_of_t<Function(Args...)>>::completion_handler_type& h)
-    : detail::packaged_async_result<Function, Allocator,
-        result_of_t<Function(Args...)>>(h)
-  {
-  }
-};
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename T, typename Blocking>
-struct equality_comparable<
-    asio::detail::promise_executor<T, Blocking>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename T, typename Blocking, typename Function>
-struct execute_member<
-    asio::detail::promise_executor<T, Blocking>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename T, typename Blocking, typename Property>
-struct query_static_constexpr_member<
-    asio::detail::promise_executor<T, Blocking>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::blocking_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Blocking result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return Blocking();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename T, typename Blocking>
-struct query_member<
-    asio::detail::promise_executor<T, Blocking>,
-    execution::context_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::system_context& result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename T, typename Blocking>
-struct require_member<
-    asio::detail::promise_executor<T, Blocking>,
-    execution::blocking_t::possibly_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::detail::promise_executor<T,
-      execution::blocking_t::possibly_t> result_type;
-};
-
-template <typename T, typename Blocking>
-struct require_member<
-    asio::detail::promise_executor<T, Blocking>,
-    execution::blocking_t::never_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::detail::promise_executor<T,
-      execution::blocking_t::never_t> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_USE_FUTURE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write.hpp
deleted file mode 100644
index 173e7d0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write.hpp
+++ /dev/null
@@ -1,780 +0,0 @@
-//
-// impl/write.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_WRITE_HPP
-#define ASIO_IMPL_WRITE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/associator.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/base_from_completion_cond.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/consuming_buffers.hpp"
-#include "asio/detail/dependent_type.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <typename SyncWriteStream, typename ConstBufferSequence,
-      typename ConstBufferIterator, typename CompletionCondition>
-  std::size_t write(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();
-  }
-} // namespace detail
-
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return detail::write(s, buffers,
-      asio::buffer_sequence_begin(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncWriteStream, typename ConstBufferSequence>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-template <typename SyncWriteStream, typename ConstBufferSequence>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    >)
-{
-  return write(s, buffers, transfer_all(), ec);
-}
-
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s, buffers,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  decay_t<DynamicBuffer_v1> b(
-      static_cast<DynamicBuffer_v1&&>(buffers));
-
-  std::size_t bytes_transferred = write(s, b.data(),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  b.consume(bytes_transferred);
-  return bytes_transferred;
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v1>
-inline std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s,
-      static_cast<DynamicBuffer_v1&&>(buffers),
-      transfer_all(), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v1>
-inline std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >)
-{
-  return write(s, static_cast<DynamicBuffer_v1&&>(buffers),
-      transfer_all(), ec);
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s,
-      static_cast<DynamicBuffer_v1&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncWriteStream, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return write(s, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncWriteStream, typename Allocator>
-inline std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b)
-{
-  return write(s, basic_streambuf_ref<Allocator>(b));
-}
-
-template <typename SyncWriteStream, typename Allocator>
-inline std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    asio::error_code& ec)
-{
-  return write(s, basic_streambuf_ref<Allocator>(b), ec);
-}
-
-template <typename SyncWriteStream, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return write(s, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-template <typename SyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  std::size_t bytes_transferred = write(s, buffers.data(0, buffers.size()),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  buffers.consume(bytes_transferred);
-  return bytes_transferred;
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v2>
-inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s,
-      static_cast<DynamicBuffer_v2&&>(buffers),
-      transfer_all(), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v2>
-inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >)
-{
-  return write(s, static_cast<DynamicBuffer_v2&&>(buffers),
-      transfer_all(), ec);
-}
-
-template <typename SyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    >,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write(s,
-      static_cast<DynamicBuffer_v2&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "write");
-  return bytes_transferred;
-}
-
-namespace detail
-{
-  template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename ConstBufferIterator, typename CompletionCondition,
-      typename WriteHandler>
-  class write_op
-    : public base_from_cancellation_state<WriteHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
-        CompletionCondition& completion_condition, WriteHandler& handler)
-      : base_from_cancellation_state<WriteHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        stream_(stream),
-        buffers_(buffers),
-        start_(0),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    write_op(const write_op& other)
-      : base_from_cancellation_state<WriteHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_op(write_op&& other)
-      : base_from_cancellation_state<WriteHandler>(
-          static_cast<base_from_cancellation_state<WriteHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        stream_(other.stream_),
-        buffers_(static_cast<buffers_type&&>(other.buffers_)),
-        start_(other.start_),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(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());
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write"));
-            stream_.async_write_some(buffers_.prepare(max_size),
-                static_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());
-          if (max_size == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<WriteHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(buffers_.total_consumed()));
-      }
-    }
-
-  //private:
-    typedef asio::detail::consuming_buffers<const_buffer,
-        ConstBufferSequence, ConstBufferIterator> buffers_type;
-
-    AsyncWriteStream& stream_;
-    buffers_type buffers_;
-    int start_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename ConstBufferIterator, typename CompletionCondition,
-      typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
-        CompletionCondition, WriteHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncWriteStream, typename ConstBufferSequence,
-      typename ConstBufferIterator, typename CompletionCondition,
-      typename WriteHandler>
-  inline void start_write_op(AsyncWriteStream& stream,
-      const ConstBufferSequence& buffers, const ConstBufferIterator&,
-      CompletionCondition& completion_condition, WriteHandler& handler)
-  {
-    detail::write_op<AsyncWriteStream, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>(
-        stream, buffers, completion_condition, handler)(
-          asio::error_code(), 0, 1);
-  }
-
-  template <typename AsyncWriteStream>
-  class initiate_async_write
-  {
-  public:
-    typedef typename AsyncWriteStream::executor_type executor_type;
-
-    explicit initiate_async_write(AsyncWriteStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence,
-        typename CompletionCondition>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers,
-        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_op(stream_, buffers,
-          asio::buffer_sequence_begin(buffers),
-          completion_cond2.value, handler2.value);
-    }
-
-  private:
-    AsyncWriteStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncWriteStream, typename ConstBufferSequence,
-    typename ConstBufferIterator, typename CompletionCondition,
-    typename WriteHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::write_op<AsyncWriteStream, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
-        ConstBufferIterator, CompletionCondition, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
-        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncWriteStream, typename DynamicBuffer_v1,
-      typename CompletionCondition, typename WriteHandler>
-  class write_dynbuf_v1_op
-  {
-  public:
-    template <typename BufferSequence>
-    write_dynbuf_v1_op(AsyncWriteStream& stream,
-        BufferSequence&& buffers,
-        CompletionCondition& completion_condition, WriteHandler& handler)
-      : stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        completion_condition_(
-          static_cast<CompletionCondition&&>(completion_condition)),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    write_dynbuf_v1_op(const write_dynbuf_v1_op& other)
-      : stream_(other.stream_),
-        buffers_(other.buffers_),
-        completion_condition_(other.completion_condition_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_dynbuf_v1_op(write_dynbuf_v1_op&& other)
-      : stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)),
-        completion_condition_(
-          static_cast<CompletionCondition&&>(
-            other.completion_condition_)),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      switch (start)
-      {
-        case 1:
-        async_write(stream_, buffers_.data(),
-            static_cast<CompletionCondition&&>(completion_condition_),
-            static_cast<write_dynbuf_v1_op&&>(*this));
-        return; default:
-        buffers_.consume(bytes_transferred);
-        static_cast<WriteHandler&&>(handler_)(ec,
-            static_cast<const std::size_t&>(bytes_transferred));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    DynamicBuffer_v1 buffers_;
-    CompletionCondition completion_condition_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream, typename DynamicBuffer_v1,
-      typename CompletionCondition, typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,
-        CompletionCondition, WriteHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-  }
-
-  template <typename AsyncWriteStream>
-  class initiate_async_write_dynbuf_v1
-  {
-  public:
-    typedef typename AsyncWriteStream::executor_type executor_type;
-
-    explicit initiate_async_write_dynbuf_v1(AsyncWriteStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename WriteHandler, typename DynamicBuffer_v1,
-        typename CompletionCondition>
-    void operator()(WriteHandler&& handler,
-        DynamicBuffer_v1&& buffers,
-        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);
-      write_dynbuf_v1_op<AsyncWriteStream,
-        decay_t<DynamicBuffer_v1>,
-          CompletionCondition, decay_t<WriteHandler>>(
-            stream_, static_cast<DynamicBuffer_v1&&>(buffers),
-              completion_cond2.value, handler2.value)(
-                asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncWriteStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition, typename WriteHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::write_dynbuf_v1_op<AsyncWriteStream,
-      DynamicBuffer_v1, CompletionCondition, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1,
-        CompletionCondition, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::write_dynbuf_v1_op<AsyncWriteStream,
-        DynamicBuffer_v1, CompletionCondition, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-namespace detail
-{
-  template <typename AsyncWriteStream, typename DynamicBuffer_v2,
-      typename CompletionCondition, typename WriteHandler>
-  class write_dynbuf_v2_op
-  {
-  public:
-    template <typename BufferSequence>
-    write_dynbuf_v2_op(AsyncWriteStream& stream,
-        BufferSequence&& buffers,
-        CompletionCondition& completion_condition, WriteHandler& handler)
-      : stream_(stream),
-        buffers_(static_cast<BufferSequence&&>(buffers)),
-        completion_condition_(
-          static_cast<CompletionCondition&&>(completion_condition)),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    write_dynbuf_v2_op(const write_dynbuf_v2_op& other)
-      : stream_(other.stream_),
-        buffers_(other.buffers_),
-        completion_condition_(other.completion_condition_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_dynbuf_v2_op(write_dynbuf_v2_op&& other)
-      : stream_(other.stream_),
-        buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)),
-        completion_condition_(
-          static_cast<CompletionCondition&&>(
-            other.completion_condition_)),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred, int start = 0)
-    {
-      switch (start)
-      {
-        case 1:
-        async_write(stream_, buffers_.data(0, buffers_.size()),
-            static_cast<CompletionCondition&&>(completion_condition_),
-            static_cast<write_dynbuf_v2_op&&>(*this));
-        return; default:
-        buffers_.consume(bytes_transferred);
-        static_cast<WriteHandler&&>(handler_)(ec,
-            static_cast<const std::size_t&>(bytes_transferred));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    DynamicBuffer_v2 buffers_;
-    CompletionCondition completion_condition_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncWriteStream, typename DynamicBuffer_v2,
-      typename CompletionCondition, typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,
-        CompletionCondition, WriteHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-  }
-
-  template <typename AsyncWriteStream>
-  class initiate_async_write_dynbuf_v2
-  {
-  public:
-    typedef typename AsyncWriteStream::executor_type executor_type;
-
-    explicit initiate_async_write_dynbuf_v2(AsyncWriteStream& stream)
-      : stream_(stream)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return stream_.get_executor();
-    }
-
-    template <typename WriteHandler, typename DynamicBuffer_v2,
-        typename CompletionCondition>
-    void operator()(WriteHandler&& handler,
-        DynamicBuffer_v2&& buffers,
-        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);
-      write_dynbuf_v2_op<AsyncWriteStream, decay_t<DynamicBuffer_v2>,
-        CompletionCondition, decay_t<WriteHandler>>(
-          stream_, static_cast<DynamicBuffer_v2&&>(buffers),
-            completion_cond2.value, handler2.value)(
-              asio::error_code(), 0, 1);
-    }
-
-  private:
-    AsyncWriteStream& stream_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition, typename WriteHandler,
-    typename DefaultCandidate>
-struct associator<Associator,
-    detail::write_dynbuf_v2_op<AsyncWriteStream,
-      DynamicBuffer_v2, CompletionCondition, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2,
-        CompletionCondition, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::write_dynbuf_v2_op<AsyncWriteStream,
-        DynamicBuffer_v2, CompletionCondition, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_WRITE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write_at.hpp
deleted file mode 100644
index a87d3d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/impl/write_at.hpp
+++ /dev/null
@@ -1,480 +0,0 @@
-//
-// impl/write_at.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IMPL_WRITE_AT_HPP
-#define ASIO_IMPL_WRITE_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/associator.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/array_fwd.hpp"
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/base_from_completion_cond.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/consuming_buffers.hpp"
-#include "asio/detail/dependent_type.hpp"
-#include "asio/detail/handler_cont_helpers.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
-      typename ConstBufferIterator, typename CompletionCondition>
-  std::size_t write_at_buffer_sequence(SyncRandomAccessWriteDevice& d,
-      uint64_t offset, 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(d.write_some_at(offset + tmp.total_consumed(),
-              tmp.prepare(max_size), ec));
-      }
-      else
-        break;
-    }
-    return tmp.total_consumed();
-  }
-} // namespace detail
-
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  return detail::write_at_buffer_sequence(d, offset, buffers,
-      asio::buffer_sequence_begin(buffers),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-}
-
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write_at(
-      d, offset, buffers, transfer_all(), ec);
-  asio::detail::throw_error(ec, "write_at");
-  return bytes_transferred;
-}
-
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    asio::error_code& ec)
-{
-  return write_at(d, offset, buffers, transfer_all(), ec);
-}
-
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    typename CompletionCondition>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write_at(d, offset, buffers,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "write_at");
-  return bytes_transferred;
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-template <typename SyncRandomAccessWriteDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  std::size_t bytes_transferred = write_at(d, offset, b.data(),
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  b.consume(bytes_transferred);
-  return bytes_transferred;
-}
-
-template <typename SyncRandomAccessWriteDevice, typename Allocator>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
-  asio::detail::throw_error(ec, "write_at");
-  return bytes_transferred;
-}
-
-template <typename SyncRandomAccessWriteDevice, typename Allocator>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    asio::error_code& ec)
-{
-  return write_at(d, offset, b, transfer_all(), ec);
-}
-
-template <typename SyncRandomAccessWriteDevice, typename Allocator,
-    typename CompletionCondition>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    >)
-{
-  asio::error_code ec;
-  std::size_t bytes_transferred = write_at(d, offset, b,
-      static_cast<CompletionCondition&&>(completion_condition), ec);
-  asio::detail::throw_error(ec, "write_at");
-  return bytes_transferred;
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-namespace detail
-{
-  template <typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename ConstBufferIterator,
-      typename CompletionCondition, typename WriteHandler>
-  class write_at_op
-    : public base_from_cancellation_state<WriteHandler>,
-      base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    write_at_op(AsyncRandomAccessWriteDevice& device,
-        uint64_t offset, const ConstBufferSequence& buffers,
-        CompletionCondition& completion_condition, WriteHandler& handler)
-      : base_from_cancellation_state<WriteHandler>(
-          handler, enable_partial_cancellation()),
-        base_from_completion_cond<CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        start_(0),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    write_at_op(const write_at_op& other)
-      : base_from_cancellation_state<WriteHandler>(other),
-        base_from_completion_cond<CompletionCondition>(other),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffers_(other.buffers_),
-        start_(other.start_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_at_op(write_at_op&& other)
-      : base_from_cancellation_state<WriteHandler>(
-          static_cast<base_from_cancellation_state<WriteHandler>&&>(other)),
-        base_from_completion_cond<CompletionCondition>(
-          static_cast<base_from_completion_cond<CompletionCondition>&&>(other)),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffers_(static_cast<buffers_type&&>(other.buffers_)),
-        start_(other.start_),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(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());
-        for (;;)
-        {
-          {
-            ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write_at"));
-            device_.async_write_some_at(
-                offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
-                static_cast<write_at_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());
-          if (max_size == 0)
-            break;
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec = asio::error::operation_aborted;
-            break;
-          }
-        }
-
-        static_cast<WriteHandler&&>(handler_)(
-            static_cast<const asio::error_code&>(ec),
-            static_cast<const std::size_t&>(buffers_.total_consumed()));
-      }
-    }
-
-  //private:
-    typedef asio::detail::consuming_buffers<const_buffer,
-        ConstBufferSequence, ConstBufferIterator> buffers_type;
-
-    AsyncRandomAccessWriteDevice& device_;
-    uint64_t offset_;
-    buffers_type buffers_;
-    int start_;
-    WriteHandler handler_;
-  };
-
-  template <typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename ConstBufferIterator,
-      typename CompletionCondition, typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
-  {
-    return this_handler->start_ == 0 ? true
-      : asio_handler_cont_helpers::is_continuation(
-          this_handler->handler_);
-  }
-
-  template <typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename ConstBufferIterator,
-      typename CompletionCondition, typename WriteHandler>
-  inline void start_write_at_op(AsyncRandomAccessWriteDevice& d,
-      uint64_t offset, const ConstBufferSequence& buffers,
-      const ConstBufferIterator&, CompletionCondition& completion_condition,
-      WriteHandler& handler)
-  {
-    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>(
-        d, offset, buffers, completion_condition, handler)(
-          asio::error_code(), 0, 1);
-  }
-
-  template <typename AsyncRandomAccessWriteDevice>
-  class initiate_async_write_at
-  {
-  public:
-    typedef typename AsyncRandomAccessWriteDevice::executor_type executor_type;
-
-    explicit initiate_async_write_at(AsyncRandomAccessWriteDevice& device)
-      : device_(device)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return device_.get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence,
-        typename CompletionCondition>
-    void operator()(WriteHandler&& handler,
-        uint64_t offset, const ConstBufferSequence& buffers,
-        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_at_op(device_, offset, buffers,
-          asio::buffer_sequence_begin(buffers),
-          completion_cond2.value, handler2.value);
-    }
-
-  private:
-    AsyncRandomAccessWriteDevice& device_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    typename ConstBufferIterator, typename CompletionCondition,
-    typename WriteHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
-      ConstBufferIterator, CompletionCondition, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::write_at_op<AsyncRandomAccessWriteDevice,
-        ConstBufferSequence, ConstBufferIterator,
-        CompletionCondition, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::write_at_op<AsyncRandomAccessWriteDevice,
-        ConstBufferSequence, ConstBufferIterator,
-        CompletionCondition, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-namespace detail
-{
-  template <typename Allocator, typename WriteHandler>
-  class write_at_streambuf_op
-  {
-  public:
-    write_at_streambuf_op(
-        asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler& handler)
-      : streambuf_(streambuf),
-        handler_(static_cast<WriteHandler&&>(handler))
-    {
-    }
-
-    write_at_streambuf_op(const write_at_streambuf_op& other)
-      : streambuf_(other.streambuf_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_at_streambuf_op(write_at_streambuf_op&& other)
-      : streambuf_(other.streambuf_),
-        handler_(static_cast<WriteHandler&&>(other.handler_))
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        const std::size_t bytes_transferred)
-    {
-      streambuf_.consume(bytes_transferred);
-      static_cast<WriteHandler&&>(handler_)(ec, bytes_transferred);
-    }
-
-  //private:
-    asio::basic_streambuf<Allocator>& streambuf_;
-    WriteHandler handler_;
-  };
-
-  template <typename Allocator, typename WriteHandler>
-  inline bool asio_handler_is_continuation(
-      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
-  {
-    return asio_handler_cont_helpers::is_continuation(
-        this_handler->handler_);
-  }
-
-  template <typename AsyncRandomAccessWriteDevice>
-  class initiate_async_write_at_streambuf
-  {
-  public:
-    typedef typename AsyncRandomAccessWriteDevice::executor_type executor_type;
-
-    explicit initiate_async_write_at_streambuf(
-        AsyncRandomAccessWriteDevice& device)
-      : device_(device)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return device_.get_executor();
-    }
-
-    template <typename WriteHandler,
-        typename Allocator, typename CompletionCondition>
-    void operator()(WriteHandler&& handler,
-        uint64_t offset, basic_streambuf<Allocator>* b,
-        CompletionCondition&& completion_condition) 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);
-      async_write_at(device_, offset, b->data(),
-          static_cast<CompletionCondition&&>(completion_condition),
-          write_at_streambuf_op<Allocator, decay_t<WriteHandler>>(
-            *b, handler2.value));
-    }
-
-  private:
-    AsyncRandomAccessWriteDevice& device_;
-  };
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-template <template <typename, typename> class Associator,
-    typename Executor, typename WriteHandler, typename DefaultCandidate>
-struct associator<Associator,
-    detail::write_at_streambuf_op<Executor, WriteHandler>,
-    DefaultCandidate>
-  : Associator<WriteHandler, DefaultCandidate>
-{
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::write_at_streambuf_op<Executor, WriteHandler>& h) noexcept
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(
-      const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IMPL_WRITE_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context.hpp
deleted file mode 100644
index 5de1256..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context.hpp
+++ /dev/null
@@ -1,1505 +0,0 @@
-//
-// io_context.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IO_CONTEXT_HPP
-#define ASIO_IO_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <stdexcept>
-#include <typeinfo>
-#include "asio/async_result.hpp"
-#include "asio/detail/chrono.hpp"
-#include "asio/detail/concurrency_hint.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/wrapped_handler.hpp"
-#include "asio/error_code.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution_context.hpp"
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/winsock_init.hpp"
-#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
-  || defined(__osf__)
-# include "asio/detail/signal_init.hpp"
-#endif
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_io_context.hpp"
-#else
-# include "asio/detail/scheduler.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail {
-#if defined(ASIO_HAS_IOCP)
-  typedef win_iocp_io_context io_context_impl;
-  class win_iocp_overlapped_ptr;
-#else
-  typedef scheduler io_context_impl;
-#endif
-
-  struct io_context_bits
-  {
-    static constexpr uintptr_t blocking_never = 1;
-    static constexpr uintptr_t relationship_continuation = 2;
-    static constexpr uintptr_t outstanding_work_tracked = 4;
-    static constexpr uintptr_t runtime_bits = 3;
-  };
-} // namespace detail
-
-/// Provides core I/O functionality.
-/**
- * The io_context class provides the core I/O functionality for users of the
- * asynchronous I/O objects, including:
- *
- * @li asio::ip::tcp::socket
- * @li asio::ip::tcp::acceptor
- * @li asio::ip::udp::socket
- * @li asio::deadline_timer.
- *
- * The io_context class also includes facilities intended for developers of
- * custom asynchronous services.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe, with the specific exceptions of the restart()
- * and notify_fork() functions. Calling restart() while there are unfinished
- * run(), run_one(), run_for(), run_until(), poll() or poll_one() calls results
- * in undefined behaviour. The notify_fork() function should not be called
- * while any io_context function, or any function on an I/O object that is
- * associated with the io_context, is being called in another thread.
- *
- * @par Concepts:
- * Dispatcher.
- *
- * @par Synchronous and asynchronous operations
- *
- * Synchronous operations on I/O objects implicitly run the io_context object
- * for an individual operation. The io_context functions run(), run_one(),
- * run_for(), run_until(), poll() or poll_one() must be called for the
- * io_context to perform asynchronous operations on behalf of a C++ program.
- * Notification that an asynchronous operation has completed is delivered by
- * invocation of the associated handler. Handlers are invoked only by a thread
- * that is currently calling any overload of run(), run_one(), run_for(),
- * run_until(), poll() or poll_one() for the io_context.
- *
- * @par Effect of exceptions thrown from handlers
- *
- * If an exception is thrown from a handler, the exception is allowed to
- * propagate through the throwing thread's invocation of run(), run_one(),
- * run_for(), run_until(), poll() or poll_one(). No other threads that are
- * calling any of these functions are affected. It is then the responsibility
- * of the application to catch the exception.
- *
- * After the exception has been caught, the run(), run_one(), run_for(),
- * run_until(), poll() or poll_one() call may be restarted @em without the need
- * for an intervening call to restart(). This allows the thread to rejoin the
- * io_context object's thread pool without impacting any other threads in the
- * pool.
- *
- * For example:
- *
- * @code
- * asio::io_context io_context;
- * ...
- * for (;;)
- * {
- *   try
- *   {
- *     io_context.run();
- *     break; // run() exited normally
- *   }
- *   catch (my_exception& e)
- *   {
- *     // Deal with exception as appropriate.
- *   }
- * }
- * @endcode
- *
- * @par Submitting arbitrary tasks to the io_context
- *
- * To submit functions to the io_context, use the @ref asio::dispatch,
- * @ref asio::post or @ref asio::defer free functions.
- *
- * For example:
- *
- * @code void my_task()
- * {
- *   ...
- * }
- *
- * ...
- *
- * asio::io_context io_context;
- *
- * // Submit a function to the io_context.
- * asio::post(io_context, my_task);
- *
- * // Submit a lambda object to the io_context.
- * asio::post(io_context,
- *     []()
- *     {
- *       ...
- *     });
- *
- * // Run the io_context until it runs out of work.
- * io_context.run(); @endcode
- *
- * @par Stopping the io_context from running out of work
- *
- * Some applications may need to prevent an io_context object's run() call from
- * returning when there is no more work to do. For example, the io_context may
- * be being run in a background thread that is launched prior to the
- * application's asynchronous operations. The run() call may be kept running by
- * using the @ref make_work_guard function to create an object of type
- * asio::executor_work_guard<io_context::executor_type>:
- *
- * @code asio::io_context io_context;
- * asio::executor_work_guard<asio::io_context::executor_type>
- *   = asio::make_work_guard(io_context);
- * ... @endcode
- *
- * To effect a shutdown, the application will then need to call the io_context
- * object's stop() member function. This will cause the io_context run() call
- * to return as soon as possible, abandoning unfinished operations and without
- * permitting ready handlers to be dispatched.
- *
- * Alternatively, if the application requires that all operations and handlers
- * be allowed to finish normally, the work object may be explicitly reset.
- *
- * @code asio::io_context io_context;
- * asio::executor_work_guard<asio::io_context::executor_type>
- *   = asio::make_work_guard(io_context);
- * ...
- * work.reset(); // Allow run() to exit. @endcode
- */
-class io_context
-  : public execution_context
-{
-private:
-  typedef detail::io_context_impl impl_type;
-#if defined(ASIO_HAS_IOCP)
-  friend class detail::win_iocp_overlapped_ptr;
-#endif
-
-#if !defined(ASIO_NO_DEPRECATED)
-  struct initiate_dispatch;
-  struct initiate_post;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-public:
-  template <typename Allocator, uintptr_t Bits>
-  class basic_executor_type;
-
-  template <typename Allocator, uintptr_t Bits>
-  friend class basic_executor_type;
-
-  /// Executor used to submit functions to an io_context.
-  typedef basic_executor_type<std::allocator<void>, 0> executor_type;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  class work;
-  friend class work;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  class service;
-
-#if !defined(ASIO_NO_EXTENSIONS) \
-  && !defined(ASIO_NO_TS_EXECUTORS)
-  class strand;
-#endif // !defined(ASIO_NO_EXTENSIONS)
-       //   && !defined(ASIO_NO_TS_EXECUTORS)
-
-  /// The type used to count the number of handlers executed by the context.
-  typedef std::size_t count_type;
-
-  /// Constructor.
-  ASIO_DECL io_context();
-
-  /// Constructor.
-  /**
-   * Construct with a hint about the required level of concurrency.
-   *
-   * @param concurrency_hint A suggestion to the implementation on how many
-   * threads it should allow to run simultaneously.
-   */
-  ASIO_DECL explicit io_context(int concurrency_hint);
-
-  /// Destructor.
-  /**
-   * On destruction, the io_context performs the following sequence of
-   * operations:
-   *
-   * @li For each service object @c svc in the io_context set, in reverse order
-   * of the beginning of service object lifetime, performs
-   * @c svc->shutdown().
-   *
-   * @li Uninvoked handler objects that were scheduled for deferred invocation
-   * on the io_context, or any associated strand, are destroyed.
-   *
-   * @li For each service object @c svc in the io_context set, in reverse order
-   * of the beginning of service object lifetime, performs
-   * <tt>delete static_cast<io_context::service*>(svc)</tt>.
-   *
-   * @note The destruction sequence described above permits programs to
-   * simplify their resource management by using @c shared_ptr<>. Where an
-   * object's lifetime is tied to the lifetime of a connection (or some other
-   * sequence of asynchronous operations), a @c shared_ptr to the object would
-   * be bound into the handlers for all asynchronous operations associated with
-   * it. This works as follows:
-   *
-   * @li When a single connection ends, all associated asynchronous operations
-   * complete. The corresponding handler objects are destroyed, and all
-   * @c shared_ptr references to the objects are destroyed.
-   *
-   * @li To shut down the whole program, the io_context function stop() is
-   * called to terminate any run() calls as soon as possible. The io_context
-   * destructor defined above destroys all handlers, causing all @c shared_ptr
-   * references to all connection objects to be destroyed.
-   */
-  ASIO_DECL ~io_context();
-
-  /// Obtains the executor associated with the io_context.
-  executor_type get_executor() noexcept;
-
-  /// Run the io_context object's event processing loop.
-  /**
-   * The run() function blocks until all work has finished and there are no
-   * more handlers to be dispatched, or until the io_context has been stopped.
-   *
-   * Multiple threads may call the run() function to set up a pool of threads
-   * from which the io_context may execute handlers. All threads that are
-   * waiting in the pool are equivalent and the io_context may choose any one
-   * of them to invoke a handler.
-   *
-   * A normal exit from the run() function implies that the io_context object
-   * is stopped (the stopped() function returns @c true). Subsequent calls to
-   * run(), run_one(), poll() or poll_one() will return immediately unless there
-   * is a prior call to restart().
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @note Calling the run() function from a thread that is currently calling
-   * one of run(), run_one(), run_for(), run_until(), poll() or poll_one() on
-   * the same io_context object may introduce the potential for deadlock. It is
-   * the caller's reponsibility to avoid this.
-   *
-   * The poll() function may also be used to dispatch ready handlers, but
-   * without blocking.
-   */
-  ASIO_DECL count_type run();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
-  /// event processing loop.
-  /**
-   * The run() function blocks until all work has finished and there are no
-   * more handlers to be dispatched, or until the io_context has been stopped.
-   *
-   * Multiple threads may call the run() function to set up a pool of threads
-   * from which the io_context may execute handlers. All threads that are
-   * waiting in the pool are equivalent and the io_context may choose any one
-   * of them to invoke a handler.
-   *
-   * A normal exit from the run() function implies that the io_context object
-   * is stopped (the stopped() function returns @c true). Subsequent calls to
-   * run(), run_one(), poll() or poll_one() will return immediately unless there
-   * is a prior call to restart().
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @note Calling the run() function from a thread that is currently calling
-   * one of run(), run_one(), run_for(), run_until(), poll() or poll_one() on
-   * the same io_context object may introduce the potential for deadlock. It is
-   * the caller's reponsibility to avoid this.
-   *
-   * The poll() function may also be used to dispatch ready handlers, but
-   * without blocking.
-   */
-  ASIO_DECL count_type run(asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Run the io_context object's event processing loop for a specified
-  /// duration.
-  /**
-   * The run_for() function blocks until all work has finished and there are no
-   * more handlers to be dispatched, until the io_context has been stopped, or
-   * until the specified duration has elapsed.
-   *
-   * @param rel_time The duration for which the call may block.
-   *
-   * @return The number of handlers that were executed.
-   */
-  template <typename Rep, typename Period>
-  std::size_t run_for(const chrono::duration<Rep, Period>& rel_time);
-
-  /// Run the io_context object's event processing loop until a specified time.
-  /**
-   * The run_until() function blocks until all work has finished and there are
-   * no more handlers to be dispatched, until the io_context has been stopped,
-   * or until the specified time has been reached.
-   *
-   * @param abs_time The time point until which the call may block.
-   *
-   * @return The number of handlers that were executed.
-   */
-  template <typename Clock, typename Duration>
-  std::size_t run_until(const chrono::time_point<Clock, Duration>& abs_time);
-
-  /// Run the io_context object's event processing loop to execute at most one
-  /// handler.
-  /**
-   * The run_one() function blocks until one handler has been dispatched, or
-   * until the io_context has been stopped.
-   *
-   * @return The number of handlers that were executed. A zero return value
-   * implies that the io_context object is stopped (the stopped() function
-   * returns @c true). Subsequent calls to run(), run_one(), poll() or
-   * poll_one() will return immediately unless there is a prior call to
-   * restart().
-   *
-   * @note Calling the run_one() function from a thread that is currently
-   * calling one of run(), run_one(), run_for(), run_until(), poll() or
-   * poll_one() on the same io_context object may introduce the potential for
-   * deadlock. It is the caller's reponsibility to avoid this.
-   */
-  ASIO_DECL count_type run_one();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
-  /// event processing loop to execute at most one handler.
-  /**
-   * The run_one() function blocks until one handler has been dispatched, or
-   * until the io_context has been stopped.
-   *
-   * @return The number of handlers that were executed. A zero return value
-   * implies that the io_context object is stopped (the stopped() function
-   * returns @c true). Subsequent calls to run(), run_one(), poll() or
-   * poll_one() will return immediately unless there is a prior call to
-   * restart().
-   *
-   * @return The number of handlers that were executed.
-   *
-   * @note Calling the run_one() function from a thread that is currently
-   * calling one of run(), run_one(), run_for(), run_until(), poll() or
-   * poll_one() on the same io_context object may introduce the potential for
-   * deadlock. It is the caller's reponsibility to avoid this.
-   */
-  ASIO_DECL count_type run_one(asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Run the io_context object's event processing loop for a specified duration
-  /// to execute at most one handler.
-  /**
-   * The run_one_for() function blocks until one handler has been dispatched,
-   * until the io_context has been stopped, or until the specified duration has
-   * elapsed.
-   *
-   * @param rel_time The duration for which the call may block.
-   *
-   * @return The number of handlers that were executed.
-   */
-  template <typename Rep, typename Period>
-  std::size_t run_one_for(const chrono::duration<Rep, Period>& rel_time);
-
-  /// Run the io_context object's event processing loop until a specified time
-  /// to execute at most one handler.
-  /**
-   * The run_one_until() function blocks until one handler has been dispatched,
-   * until the io_context has been stopped, or until the specified time has
-   * been reached.
-   *
-   * @param abs_time The time point until which the call may block.
-   *
-   * @return The number of handlers that were executed.
-   */
-  template <typename Clock, typename Duration>
-  std::size_t run_one_until(
-      const chrono::time_point<Clock, Duration>& abs_time);
-
-  /// Run the io_context object's event processing loop to execute ready
-  /// handlers.
-  /**
-   * The poll() function runs handlers that are ready to run, without blocking,
-   * until the io_context has been stopped or there are no more ready handlers.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL count_type poll();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
-  /// event processing loop to execute ready handlers.
-  /**
-   * The poll() function runs handlers that are ready to run, without blocking,
-   * until the io_context has been stopped or there are no more ready handlers.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL count_type poll(asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Run the io_context object's event processing loop to execute one ready
-  /// handler.
-  /**
-   * The poll_one() function runs at most one handler that is ready to run,
-   * without blocking.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL count_type poll_one();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use non-error_code overload.) Run the io_context object's
-  /// event processing loop to execute one ready handler.
-  /**
-   * The poll_one() function runs at most one handler that is ready to run,
-   * without blocking.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of handlers that were executed.
-   */
-  ASIO_DECL count_type poll_one(asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Stop the io_context object's event processing loop.
-  /**
-   * This function does not block, but instead simply signals the io_context to
-   * stop. All invocations of its run() or run_one() member functions should
-   * return as soon as possible. Subsequent calls to run(), run_one(), poll()
-   * or poll_one() will return immediately until restart() is called.
-   */
-  ASIO_DECL void stop();
-
-  /// Determine whether the io_context object has been stopped.
-  /**
-   * This function is used to determine whether an io_context object has been
-   * stopped, either through an explicit call to stop(), or due to running out
-   * of work. When an io_context object is stopped, calls to run(), run_one(),
-   * poll() or poll_one() will return immediately without invoking any
-   * handlers.
-   *
-   * @return @c true if the io_context object is stopped, otherwise @c false.
-   */
-  ASIO_DECL bool stopped() const;
-
-  /// Restart the io_context in preparation for a subsequent run() invocation.
-  /**
-   * This function must be called prior to any second or later set of
-   * invocations of the run(), run_one(), poll() or poll_one() functions when a
-   * previous invocation of these functions returned due to the io_context
-   * being stopped or running out of work. After a call to restart(), the
-   * io_context object's stopped() function will return @c false.
-   *
-   * This function must not be called while there are any unfinished calls to
-   * the run(), run_one(), poll() or poll_one() functions.
-   */
-  ASIO_DECL void restart();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use restart().) Reset the io_context in preparation for a
-  /// subsequent run() invocation.
-  /**
-   * This function must be called prior to any second or later set of
-   * invocations of the run(), run_one(), poll() or poll_one() functions when a
-   * previous invocation of these functions returned due to the io_context
-   * being stopped or running out of work. After a call to restart(), the
-   * io_context object's stopped() function will return @c false.
-   *
-   * This function must not be called while there are any unfinished calls to
-   * the run(), run_one(), poll() or poll_one() functions.
-   */
-  void reset();
-
-  /// (Deprecated: Use asio::dispatch().) Request the io_context to
-  /// invoke the given handler.
-  /**
-   * This function is used to ask the io_context to execute the given handler.
-   *
-   * The io_context guarantees that the handler will only be called in a thread
-   * in which the run(), run_one(), poll() or poll_one() member functions is
-   * currently being invoked. The handler may be executed inside this function
-   * if the guarantee can be met.
-   *
-   * @param handler The handler to be called. The io_context will make
-   * a copy of the handler object as required. The function signature of the
-   * handler must be: @code void handler(); @endcode
-   *
-   * @note This function throws an exception only if:
-   *
-   * @li the handler's associated allocator; or
-   *
-   * @li the handler's copy constructor
-   *
-   * throws an exception.
-   */
-  template <typename LegacyCompletionHandler>
-  auto dispatch(LegacyCompletionHandler&& handler)
-    -> decltype(
-      async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_dispatch>(), handler, this));
-
-  /// (Deprecated: Use asio::post().) Request the io_context to invoke
-  /// the given handler and return immediately.
-  /**
-   * This function is used to ask the io_context to execute the given handler,
-   * but without allowing the io_context to call the handler from inside this
-   * function.
-   *
-   * The io_context guarantees that the handler will only be called in a thread
-   * in which the run(), run_one(), poll() or poll_one() member functions is
-   * currently being invoked.
-   *
-   * @param handler The handler to be called. The io_context will make
-   * a copy of the handler object as required. The function signature of the
-   * handler must be: @code void handler(); @endcode
-   *
-   * @note This function throws an exception only if:
-   *
-   * @li the handler's associated allocator; or
-   *
-   * @li the handler's copy constructor
-   *
-   * throws an exception.
-   */
-  template <typename LegacyCompletionHandler>
-  auto post(LegacyCompletionHandler&& handler)
-    -> decltype(
-      async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_post>(), handler, this));
-
-  /// (Deprecated: Use asio::bind_executor().) Create a new handler that
-  /// automatically dispatches the wrapped handler on the io_context.
-  /**
-   * This function is used to create a new handler function object that, when
-   * invoked, will automatically pass the wrapped handler to the io_context
-   * object's dispatch function.
-   *
-   * @param handler The handler to be wrapped. The io_context will make a copy
-   * of the handler object as required. The function signature of the handler
-   * must be: @code void handler(A1 a1, ... An an); @endcode
-   *
-   * @return A function object that, when invoked, passes the wrapped handler to
-   * the io_context object's dispatch function. Given a function object with the
-   * signature:
-   * @code R f(A1 a1, ... An an); @endcode
-   * If this function object is passed to the wrap function like so:
-   * @code io_context.wrap(f); @endcode
-   * then the return value is a function object with the signature
-   * @code void g(A1 a1, ... An an); @endcode
-   * that, when invoked, executes code equivalent to:
-   * @code io_context.dispatch(boost::bind(f, a1, ... an)); @endcode
-   */
-  template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-  unspecified
-#else
-  detail::wrapped_handler<io_context&, Handler>
-#endif
-  wrap(Handler handler);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-private:
-  io_context(const io_context&) = delete;
-  io_context& operator=(const io_context&) = delete;
-
-  // Helper function to add the implementation.
-  ASIO_DECL impl_type& add_impl(impl_type* impl);
-
-  // Backwards compatible overload for use with services derived from
-  // io_context::service.
-  template <typename Service>
-  friend Service& use_service(io_context& ioc);
-
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  detail::winsock_init<> init_;
-#elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
-  || defined(__osf__)
-  detail::signal_init<> init_;
-#endif
-
-  // The implementation.
-  impl_type& impl_;
-};
-
-/// Executor implementation type used to submit functions to an io_context.
-template <typename Allocator, uintptr_t Bits>
-class io_context::basic_executor_type :
-  detail::io_context_bits, Allocator
-{
-public:
-  /// Copy constructor.
-  basic_executor_type(const basic_executor_type& other) noexcept
-    : Allocator(static_cast<const Allocator&>(other)),
-      target_(other.target_)
-  {
-    if (Bits & outstanding_work_tracked)
-      if (context_ptr())
-        context_ptr()->impl_.work_started();
-  }
-
-  /// Move constructor.
-  basic_executor_type(basic_executor_type&& other) noexcept
-    : Allocator(static_cast<Allocator&&>(other)),
-      target_(other.target_)
-  {
-    if (Bits & outstanding_work_tracked)
-      other.target_ = 0;
-  }
-
-  /// Destructor.
-  ~basic_executor_type() noexcept
-  {
-    if (Bits & outstanding_work_tracked)
-      if (context_ptr())
-        context_ptr()->impl_.work_finished();
-  }
-
-  /// Assignment operator.
-  basic_executor_type& operator=(const basic_executor_type& other) noexcept;
-
-  /// Move assignment operator.
-  basic_executor_type& operator=(basic_executor_type&& other) noexcept;
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Obtain an executor with the @c blocking.possibly property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.possibly); @endcode
-   */
-  constexpr basic_executor_type require(execution::blocking_t::possibly_t) const
-  {
-    return basic_executor_type(context_ptr(),
-        *this, bits() & ~blocking_never);
-  }
-
-  /// Obtain an executor with the @c blocking.never property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.never); @endcode
-   */
-  constexpr basic_executor_type require(execution::blocking_t::never_t) const
-  {
-    return basic_executor_type(context_ptr(),
-        *this, bits() | blocking_never);
-  }
-
-  /// Obtain an executor with the @c relationship.fork property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.fork); @endcode
-   */
-  constexpr basic_executor_type require(execution::relationship_t::fork_t) const
-  {
-    return basic_executor_type(context_ptr(),
-        *this, bits() & ~relationship_continuation);
-  }
-
-  /// Obtain an executor with the @c relationship.continuation property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.continuation); @endcode
-   */
-  constexpr basic_executor_type require(
-      execution::relationship_t::continuation_t) const
-  {
-    return basic_executor_type(context_ptr(),
-        *this, bits() | relationship_continuation);
-  }
-
-  /// Obtain an executor with the @c outstanding_work.tracked property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::outstanding_work.tracked); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits | outstanding_work_tracked)>
-  require(execution::outstanding_work_t::tracked_t) const
-  {
-    return basic_executor_type<Allocator, Bits | outstanding_work_tracked>(
-        context_ptr(), *this, bits());
-  }
-
-  /// Obtain an executor with the @c outstanding_work.untracked property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::outstanding_work.untracked); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits & ~outstanding_work_tracked)>
-  require(execution::outstanding_work_t::untracked_t) const
-  {
-    return basic_executor_type<Allocator, Bits & ~outstanding_work_tracked>(
-        context_ptr(), *this, bits());
-  }
-
-  /// Obtain an executor with the specified @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator(my_allocator)); @endcode
-   */
-  template <typename OtherAllocator>
-  constexpr basic_executor_type<OtherAllocator, Bits>
-  require(execution::allocator_t<OtherAllocator> a) const
-  {
-    return basic_executor_type<OtherAllocator, Bits>(
-        context_ptr(), a.value(), bits());
-  }
-
-  /// Obtain an executor with the default @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_io_context.get_executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator); @endcode
-   */
-  constexpr basic_executor_type<std::allocator<void>, Bits>
-  require(execution::allocator_t<void>) const
-  {
-    return basic_executor_type<std::allocator<void>, Bits>(
-        context_ptr(), std::allocator<void>(), bits());
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_query_fn::impl;
-  friend struct asio::execution::detail::mapping_t<0>;
-  friend struct asio::execution::detail::outstanding_work_t<0>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Query the current value of the @c mapping property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * if (asio::query(ex, asio::execution::mapping)
-   *       == asio::execution::mapping.thread)
-   *   ... @endcode
-   */
-  static constexpr execution::mapping_t query(execution::mapping_t) noexcept
-  {
-    return execution::mapping.thread;
-  }
-
-  /// Query the current value of the @c context property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * asio::io_context& ctx = asio::query(
-   *     ex, asio::execution::context); @endcode
-   */
-  io_context& query(execution::context_t) const noexcept
-  {
-    return *context_ptr();
-  }
-
-  /// Query the current value of the @c blocking property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * if (asio::query(ex, asio::execution::blocking)
-   *       == asio::execution::blocking.always)
-   *   ... @endcode
-   */
-  constexpr execution::blocking_t query(execution::blocking_t) const noexcept
-  {
-    return (bits() & blocking_never)
-      ? execution::blocking_t(execution::blocking.never)
-      : execution::blocking_t(execution::blocking.possibly);
-  }
-
-  /// Query the current value of the @c relationship property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * if (asio::query(ex, asio::execution::relationship)
-   *       == asio::execution::relationship.continuation)
-   *   ... @endcode
-   */
-  constexpr execution::relationship_t query(
-      execution::relationship_t) const noexcept
-  {
-    return (bits() & relationship_continuation)
-      ? execution::relationship_t(execution::relationship.continuation)
-      : execution::relationship_t(execution::relationship.fork);
-  }
-
-  /// Query the current value of the @c outstanding_work property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * if (asio::query(ex, asio::execution::outstanding_work)
-   *       == asio::execution::outstanding_work.tracked)
-   *   ... @endcode
-   */
-  static constexpr execution::outstanding_work_t query(
-      execution::outstanding_work_t) noexcept
-  {
-    return (Bits & outstanding_work_tracked)
-      ? execution::outstanding_work_t(execution::outstanding_work.tracked)
-      : execution::outstanding_work_t(execution::outstanding_work.untracked);
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  template <typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t<OtherAllocator>) const noexcept
-  {
-    return static_cast<const Allocator&>(*this);
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_io_context.get_executor();
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  constexpr Allocator query(execution::allocator_t<void>) const noexcept
-  {
-    return static_cast<const Allocator&>(*this);
-  }
-
-public:
-  /// Determine whether the io_context is running in the current thread.
-  /**
-   * @return @c true if the current thread is running the io_context. Otherwise
-   * returns @c false.
-   */
-  bool running_in_this_thread() const noexcept;
-
-  /// Compare two executors for equality.
-  /**
-   * Two executors are equal if they refer to the same underlying io_context.
-   */
-  friend bool operator==(const basic_executor_type& a,
-      const basic_executor_type& b) noexcept
-  {
-    return a.target_ == b.target_
-      && static_cast<const Allocator&>(a) == static_cast<const Allocator&>(b);
-  }
-
-  /// Compare two executors for inequality.
-  /**
-   * Two executors are equal if they refer to the same underlying io_context.
-   */
-  friend bool operator!=(const basic_executor_type& a,
-      const basic_executor_type& b) noexcept
-  {
-    return a.target_ != b.target_
-      || static_cast<const Allocator&>(a) != static_cast<const Allocator&>(b);
-  }
-
-  /// Execution function.
-  template <typename Function>
-  void execute(Function&& f) const;
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-public:
-  /// Obtain the underlying execution context.
-  io_context& context() const noexcept;
-
-  /// Inform the io_context that it has some outstanding work to do.
-  /**
-   * This function is used to inform the io_context that some work has begun.
-   * This ensures that the io_context's run() and run_one() functions do not
-   * exit while the work is underway.
-   */
-  void on_work_started() const noexcept;
-
-  /// Inform the io_context that some work is no longer outstanding.
-  /**
-   * This function is used to inform the io_context that some work has
-   * finished. Once the count of unfinished work reaches zero, the io_context
-   * is stopped and the run() and run_one() functions may exit.
-   */
-  void on_work_finished() const noexcept;
-
-  /// Request the io_context to invoke the given function object.
-  /**
-   * This function is used to ask the io_context to execute the given function
-   * object. If the current thread is running the io_context, @c dispatch()
-   * executes the function before returning. Otherwise, the function will be
-   * scheduled to run on the io_context.
-   *
-   * @param f The function object to be called. The executor will make a copy
-   * of the handler object as required. The function signature of the function
-   * object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void dispatch(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the io_context to invoke the given function object.
-  /**
-   * This function is used to ask the io_context to execute the given function
-   * object. The function object will never be executed inside @c post().
-   * Instead, it will be scheduled to run on the io_context.
-   *
-   * @param f The function object to be called. The executor will make a copy
-   * of the handler object as required. The function signature of the function
-   * object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void post(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the io_context to invoke the given function object.
-  /**
-   * This function is used to ask the io_context to execute the given function
-   * object. The function object will never be executed inside @c defer().
-   * Instead, it will be scheduled to run on the io_context.
-   *
-   * If the current thread belongs to the io_context, @c defer() will delay
-   * scheduling the function object until the current thread returns control to
-   * the pool.
-   *
-   * @param f The function object to be called. The executor will make a copy
-   * of the handler object as required. The function signature of the function
-   * object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void defer(Function&& f, const OtherAllocator& a) const;
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-private:
-  friend class io_context;
-  template <typename, uintptr_t> friend class basic_executor_type;
-
-  // Constructor used by io_context::get_executor().
-  explicit basic_executor_type(io_context& i) noexcept
-    : Allocator(),
-      target_(reinterpret_cast<uintptr_t>(&i))
-  {
-    if (Bits & outstanding_work_tracked)
-      context_ptr()->impl_.work_started();
-  }
-
-  // Constructor used by require().
-  basic_executor_type(io_context* i,
-      const Allocator& a, uintptr_t bits) noexcept
-    : Allocator(a),
-      target_(reinterpret_cast<uintptr_t>(i) | bits)
-  {
-    if (Bits & outstanding_work_tracked)
-      if (context_ptr())
-        context_ptr()->impl_.work_started();
-  }
-
-  io_context* context_ptr() const noexcept
-  {
-    return reinterpret_cast<io_context*>(target_ & ~runtime_bits);
-  }
-
-  uintptr_t bits() const noexcept
-  {
-    return target_ & runtime_bits;
-  }
-
-  // The underlying io_context and runtime bits.
-  uintptr_t target_;
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// (Deprecated: Use executor_work_guard.) Class to inform the io_context when
-/// it has work to do.
-/**
- * The work class is used to inform the io_context when work starts and
- * finishes. This ensures that the io_context object's run() function will not
- * exit while work is underway, and that it does exit when there is no
- * unfinished work remaining.
- *
- * The work class is copy-constructible so that it may be used as a data member
- * in a handler class. It is not assignable.
- */
-class io_context::work
-{
-public:
-  /// Constructor notifies the io_context that work is starting.
-  /**
-   * The constructor is used to inform the io_context that some work has begun.
-   * This ensures that the io_context object's run() function will not exit
-   * while the work is underway.
-   */
-  explicit work(asio::io_context& io_context);
-
-  /// Copy constructor notifies the io_context that work is starting.
-  /**
-   * The constructor is used to inform the io_context that some work has begun.
-   * This ensures that the io_context object's run() function will not exit
-   * while the work is underway.
-   */
-  work(const work& other);
-
-  /// Destructor notifies the io_context that the work is complete.
-  /**
-   * The destructor is used to inform the io_context that some work has
-   * finished. Once the count of unfinished work reaches zero, the io_context
-   * object's run() function is permitted to exit.
-   */
-  ~work();
-
-  /// Get the io_context associated with the work.
-  asio::io_context& get_io_context();
-
-private:
-  // Prevent assignment.
-  void operator=(const work& other);
-
-  // The io_context implementation.
-  detail::io_context_impl& io_context_impl_;
-};
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-/// Base class for all io_context services.
-class io_context::service
-  : public execution_context::service
-{
-public:
-  /// Get the io_context object that owns the service.
-  asio::io_context& get_io_context();
-
-private:
-  /// Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL virtual void shutdown();
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use shutdown().) Destroy all user-defined handler objects
-  /// owned by the service.
-  ASIO_DECL virtual void shutdown_service();
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Handle notification of a fork-related event to perform any necessary
-  /// housekeeping.
-  /**
-   * This function is not a pure virtual so that services only have to
-   * implement it if necessary. The default implementation does nothing.
-   */
-  ASIO_DECL virtual void notify_fork(
-      execution_context::fork_event event);
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use notify_fork().) Handle notification of a fork-related
-  /// event to perform any necessary housekeeping.
-  /**
-   * This function is not a pure virtual so that services only have to
-   * implement it if necessary. The default implementation does nothing.
-   */
-  ASIO_DECL virtual void fork_service(
-      execution_context::fork_event event);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-protected:
-  /// Constructor.
-  /**
-   * @param owner The io_context object that owns the service.
-   */
-  ASIO_DECL service(asio::io_context& owner);
-
-  /// Destructor.
-  ASIO_DECL virtual ~service();
-};
-
-namespace detail {
-
-// Special service base class to keep classes header-file only.
-template <typename Type>
-class service_base
-  : public asio::io_context::service
-{
-public:
-  static asio::detail::service_id<Type> id;
-
-  // Constructor.
-  service_base(asio::io_context& io_context)
-    : asio::io_context::service(io_context)
-  {
-  }
-};
-
-template <typename Type>
-asio::detail::service_id<Type> service_base<Type>::id;
-
-} // namespace detail
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Allocator, uintptr_t Bits>
-struct equality_comparable<
-    asio::io_context::basic_executor_type<Allocator, Bits>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Allocator, uintptr_t Bits, typename Function>
-struct execute_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    Function
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::blocking_t::possibly_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::blocking_t::never_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::relationship_t::fork_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::relationship_t::continuation_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::outstanding_work_t::tracked_t
-  > : asio::detail::io_context_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits | outstanding_work_tracked> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::outstanding_work_t::untracked_t
-  > : asio::detail::io_context_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      Allocator, Bits & ~outstanding_work_tracked> result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      std::allocator<void>, Bits> result_type;
-};
-
-template <uintptr_t Bits,
-    typename Allocator, typename OtherAllocator>
-struct require_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<OtherAllocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::io_context::basic_executor_type<
-      OtherAllocator, Bits> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Allocator, uintptr_t Bits, typename Property>
-struct query_static_constexpr_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::outstanding_work_t
-      >::value
-    >::type
-  > : asio::detail::io_context_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::outstanding_work_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return (Bits & outstanding_work_tracked)
-      ? execution::outstanding_work_t(execution::outstanding_work.tracked)
-      : execution::outstanding_work_t(execution::outstanding_work.untracked);
-  }
-};
-
-template <typename Allocator, uintptr_t Bits, typename Property>
-struct query_static_constexpr_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::mapping_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::mapping_t::thread_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Allocator, uintptr_t Bits, typename Property>
-struct query_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::blocking_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::blocking_t result_type;
-};
-
-template <typename Allocator, uintptr_t Bits, typename Property>
-struct query_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::relationship_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::relationship_t result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct query_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::context_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::io_context& result_type;
-};
-
-template <typename Allocator, uintptr_t Bits>
-struct query_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-template <typename Allocator, uintptr_t Bits, typename OtherAllocator>
-struct query_member<
-    asio::io_context::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<OtherAllocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-
-namespace execution {
-
-template <>
-struct is_executor<io_context> : false_type
-{
-};
-
-} // namespace execution
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/io_context.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/io_context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-// If both io_context.hpp and strand.hpp have been included, automatically
-// include the header file needed for the io_context::strand class.
-#if !defined(ASIO_NO_EXTENSIONS)
-# if defined(ASIO_STRAND_HPP)
-#  include "asio/io_context_strand.hpp"
-# endif // defined(ASIO_STRAND_HPP)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#endif // ASIO_IO_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context_strand.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context_strand.hpp
deleted file mode 100644
index 98b01d4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_context_strand.hpp
+++ /dev/null
@@ -1,396 +0,0 @@
-//
-// io_context_strand.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IO_CONTEXT_STRAND_HPP
-#define ASIO_IO_CONTEXT_STRAND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS) \
-  && !defined(ASIO_NO_TS_EXECUTORS)
-
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/strand_service.hpp"
-#include "asio/detail/wrapped_handler.hpp"
-#include "asio/io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides serialised handler execution.
-/**
- * The io_context::strand class provides the ability to post and dispatch
- * handlers with the guarantee that none of those handlers will execute
- * concurrently.
- *
- * @par Order of handler invocation
- * Given:
- *
- * @li a strand object @c s
- *
- * @li an object @c a meeting completion handler requirements
- *
- * @li an object @c a1 which is an arbitrary copy of @c a made by the
- * implementation
- *
- * @li an object @c b meeting completion handler requirements
- *
- * @li an object @c b1 which is an arbitrary copy of @c b made by the
- * implementation
- *
- * if any of the following conditions are true:
- *
- * @li @c s.post(a) happens-before @c s.post(b)
- *
- * @li @c s.post(a) happens-before @c s.dispatch(b), where the latter is
- * performed outside the strand
- *
- * @li @c s.dispatch(a) happens-before @c s.post(b), where the former is
- * performed outside the strand
- *
- * @li @c s.dispatch(a) happens-before @c s.dispatch(b), where both are
- * performed outside the strand
- *
- * then @c a() happens-before @c b()
- *
- * Note that in the following case:
- * @code async_op_1(..., s.wrap(a));
- * async_op_2(..., s.wrap(b)); @endcode
- * the completion of the first async operation will perform @c s.dispatch(a),
- * and the second will perform @c s.dispatch(b), but the order in which those
- * are performed is unspecified. That is, you cannot state whether one
- * happens-before the other. Therefore none of the above conditions are met and
- * no ordering guarantee is made.
- *
- * @note The implementation makes no guarantee that handlers posted or
- * dispatched through different @c strand objects will be invoked concurrently.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Dispatcher.
- */
-class io_context::strand
-{
-private:
-#if !defined(ASIO_NO_DEPRECATED)
-  struct initiate_dispatch;
-  struct initiate_post;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-public:
-  /// Constructor.
-  /**
-   * Constructs the strand.
-   *
-   * @param io_context The io_context object that the strand will use to
-   * dispatch handlers that are ready to be run.
-   */
-  explicit strand(asio::io_context& io_context)
-    : service_(asio::use_service<
-        asio::detail::strand_service>(io_context))
-  {
-    service_.construct(impl_);
-  }
-
-  /// Copy constructor.
-  /**
-   * Creates a copy such that both strand objects share the same underlying
-   * state.
-   */
-  strand(const strand& other) noexcept
-    : service_(other.service_),
-      impl_(other.impl_)
-  {
-  }
-
-  /// Destructor.
-  /**
-   * Destroys a strand.
-   *
-   * Handlers posted through the strand that have not yet been invoked will
-   * still be dispatched in a way that meets the guarantee of non-concurrency.
-   */
-  ~strand()
-  {
-  }
-
-  /// Obtain the underlying execution context.
-  asio::io_context& context() const noexcept
-  {
-    return service_.get_io_context();
-  }
-
-  /// Inform the strand that it has some outstanding work to do.
-  /**
-   * The strand delegates this call to its underlying io_context.
-   */
-  void on_work_started() const noexcept
-  {
-    context().get_executor().on_work_started();
-  }
-
-  /// Inform the strand that some work is no longer outstanding.
-  /**
-   * The strand delegates this call to its underlying io_context.
-   */
-  void on_work_finished() const noexcept
-  {
-    context().get_executor().on_work_finished();
-  }
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the strand to execute the given function
-   * object on its underlying io_context. The function object will be executed
-   * inside this function if the strand is not otherwise busy and if the
-   * underlying io_context's executor's @c dispatch() function is also able to
-   * execute the function before returning.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void dispatch(Function&& f, const Allocator& a) const
-  {
-    decay_t<Function> tmp(static_cast<Function&&>(f));
-    service_.dispatch(impl_, tmp);
-    (void)a;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use asio::dispatch().) Request the strand to invoke
-  /// the given handler.
-  /**
-   * This function is used to ask the strand to execute the given handler.
-   *
-   * The strand object guarantees that handlers posted or dispatched through
-   * the strand will not be executed concurrently. The handler may be executed
-   * inside this function if the guarantee can be met. If this function is
-   * called from within a handler that was posted or dispatched through the same
-   * strand, then the new handler will be executed immediately.
-   *
-   * The strand's guarantee is in addition to the guarantee provided by the
-   * underlying io_context. The io_context guarantees that the handler will only
-   * be called in a thread in which the io_context's run member function is
-   * currently being invoked.
-   *
-   * @param handler The handler to be called. The strand will make a copy of the
-   * handler object as required. The function signature of the handler must be:
-   * @code void handler(); @endcode
-   */
-  template <typename LegacyCompletionHandler>
-  auto dispatch(LegacyCompletionHandler&& handler)
-    -> decltype(
-      async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_dispatch>(), handler, this))
-  {
-    return async_initiate<LegacyCompletionHandler, void ()>(
-        initiate_dispatch(), handler, this);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled to run by the underlying io_context.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void post(Function&& f, const Allocator& a) const
-  {
-    decay_t<Function> tmp(static_cast<Function&&>(f));
-    service_.post(impl_, tmp);
-    (void)a;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use asio::post().) Request the strand to invoke the
-  /// given handler and return immediately.
-  /**
-   * This function is used to ask the strand to execute the given handler, but
-   * without allowing the strand to call the handler from inside this function.
-   *
-   * The strand object guarantees that handlers posted or dispatched through
-   * the strand will not be executed concurrently. The strand's guarantee is in
-   * addition to the guarantee provided by the underlying io_context. The
-   * io_context guarantees that the handler will only be called in a thread in
-   * which the io_context's run member function is currently being invoked.
-   *
-   * @param handler The handler to be called. The strand will make a copy of the
-   * handler object as required. The function signature of the handler must be:
-   * @code void handler(); @endcode
-   */
-  template <typename LegacyCompletionHandler>
-  auto post(LegacyCompletionHandler&& handler)
-    -> decltype(
-      async_initiate<LegacyCompletionHandler, void ()>(
-        declval<initiate_post>(), handler, this))
-  {
-    return async_initiate<LegacyCompletionHandler, void ()>(
-        initiate_post(), handler, this);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled to run by the underlying io_context.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void defer(Function&& f, const Allocator& a) const
-  {
-    decay_t<Function> tmp(static_cast<Function&&>(f));
-    service_.post(impl_, tmp);
-    (void)a;
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use asio::bind_executor().) Create a new handler that
-  /// automatically dispatches the wrapped handler on the strand.
-  /**
-   * This function is used to create a new handler function object that, when
-   * invoked, will automatically pass the wrapped handler to the strand's
-   * dispatch function.
-   *
-   * @param handler The handler to be wrapped. The strand will make a copy of
-   * the handler object as required. The function signature of the handler must
-   * be: @code void handler(A1 a1, ... An an); @endcode
-   *
-   * @return A function object that, when invoked, passes the wrapped handler to
-   * the strand's dispatch function. Given a function object with the signature:
-   * @code R f(A1 a1, ... An an); @endcode
-   * If this function object is passed to the wrap function like so:
-   * @code strand.wrap(f); @endcode
-   * then the return value is a function object with the signature
-   * @code void g(A1 a1, ... An an); @endcode
-   * that, when invoked, executes code equivalent to:
-   * @code strand.dispatch(boost::bind(f, a1, ... an)); @endcode
-   */
-  template <typename Handler>
-#if defined(GENERATING_DOCUMENTATION)
-  unspecified
-#else
-  detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
-#endif
-  wrap(Handler handler)
-  {
-    return detail::wrapped_handler<io_context::strand, Handler,
-        detail::is_continuation_if_running>(*this, handler);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the strand is running in the current thread.
-  /**
-   * @return @c true if the current thread is executing a handler that was
-   * submitted to the strand using post(), dispatch() or wrap(). Otherwise
-   * returns @c false.
-   */
-  bool running_in_this_thread() const noexcept
-  {
-    return service_.running_in_this_thread(impl_);
-  }
-
-  /// Compare two strands for equality.
-  /**
-   * Two strands are equal if they refer to the same ordered, non-concurrent
-   * state.
-   */
-  friend bool operator==(const strand& a, const strand& b) noexcept
-  {
-    return a.impl_ == b.impl_;
-  }
-
-  /// Compare two strands for inequality.
-  /**
-   * Two strands are equal if they refer to the same ordered, non-concurrent
-   * state.
-   */
-  friend bool operator!=(const strand& a, const strand& b) noexcept
-  {
-    return a.impl_ != b.impl_;
-  }
-
-private:
-#if !defined(ASIO_NO_DEPRECATED)
-  struct initiate_dispatch
-  {
-    template <typename LegacyCompletionHandler>
-    void operator()(LegacyCompletionHandler&& handler,
-        strand* self) const
-    {
-      // If you get an error on the following line it means that your
-      // handler does not meet the documented type requirements for a
-      // LegacyCompletionHandler.
-      ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-          LegacyCompletionHandler, handler) type_check;
-
-      detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-      self->service_.dispatch(self->impl_, handler2.value);
-    }
-  };
-
-  struct initiate_post
-  {
-    template <typename LegacyCompletionHandler>
-    void operator()(LegacyCompletionHandler&& handler,
-        strand* self) const
-    {
-      // If you get an error on the following line it means that your
-      // handler does not meet the documented type requirements for a
-      // LegacyCompletionHandler.
-      ASIO_LEGACY_COMPLETION_HANDLER_CHECK(
-          LegacyCompletionHandler, handler) type_check;
-
-      detail::non_const_lvalue<LegacyCompletionHandler> handler2(handler);
-      self->service_.post(self->impl_, handler2.value);
-    }
-  };
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  asio::detail::strand_service& service_;
-  mutable asio::detail::strand_service::implementation_type impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-       //   && !defined(ASIO_NO_TS_EXECUTORS)
-
-#endif // ASIO_IO_CONTEXT_STRAND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service.hpp
deleted file mode 100644
index 748d8a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// io_service.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IO_SERVICE_HPP
-#define ASIO_IO_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-#if !defined(ASIO_NO_DEPRECATED)
-/// Typedef for backwards compatibility.
-typedef io_context io_service;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IO_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service_strand.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service_strand.hpp
deleted file mode 100644
index 65bb8db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/io_service_strand.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//
-// io_service_strand.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IO_SERVICE_STRAND_HPP
-#define ASIO_IO_SERVICE_STRAND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/io_context_strand.hpp"
-
-#endif // ASIO_IO_SERVICE_STRAND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address.hpp
deleted file mode 100644
index 337abe7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-//
-// ip/address.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_HPP
-#define ASIO_IP_ADDRESS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <functional>
-#include <string>
-#include "asio/detail/throw_exception.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ip/address_v4.hpp"
-#include "asio/ip/address_v6.hpp"
-#include "asio/ip/bad_address_cast.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-# include <iosfwd>
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Implements version-independent IP addresses.
-/**
- * The asio::ip::address class provides the ability to use either IP
- * version 4 or version 6 addresses.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class address
-{
-public:
-  /// Default constructor.
-  ASIO_DECL address() noexcept;
-
-  /// Construct an address from an IPv4 address.
-  ASIO_DECL address(
-      const asio::ip::address_v4& ipv4_address) noexcept;
-
-  /// Construct an address from an IPv6 address.
-  ASIO_DECL address(
-      const asio::ip::address_v6& ipv6_address) noexcept;
-
-  /// Copy constructor.
-  ASIO_DECL address(const address& other) noexcept;
-
-  /// Move constructor.
-  ASIO_DECL address(address&& other) noexcept;
-
-  /// Assign from another address.
-  ASIO_DECL address& operator=(const address& other) noexcept;
-
-  /// Move-assign from another address.
-  ASIO_DECL address& operator=(address&& other) noexcept;
-
-  /// Assign from an IPv4 address.
-  ASIO_DECL address& operator=(
-      const asio::ip::address_v4& ipv4_address) noexcept;
-
-  /// Assign from an IPv6 address.
-  ASIO_DECL address& operator=(
-      const asio::ip::address_v6& ipv6_address) noexcept;
-
-  /// Get whether the address is an IP version 4 address.
-  bool is_v4() const noexcept
-  {
-    return type_ == ipv4;
-  }
-
-  /// Get whether the address is an IP version 6 address.
-  bool is_v6() const noexcept
-  {
-    return type_ == ipv6;
-  }
-
-  /// Get the address as an IP version 4 address.
-  ASIO_DECL asio::ip::address_v4 to_v4() const;
-
-  /// Get the address as an IP version 6 address.
-  ASIO_DECL asio::ip::address_v6 to_v6() const;
-
-  /// Get the address as a string.
-  ASIO_DECL std::string to_string() const;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use other overload.) Get the address as a string.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
-
-  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
-  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
-  /// notation.
-  static address from_string(const char* str);
-
-  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
-  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
-  /// notation.
-  static address from_string(const char* str, asio::error_code& ec);
-
-  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
-  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
-  /// notation.
-  static address from_string(const std::string& str);
-
-  /// (Deprecated: Use make_address().) Create an address from an IPv4 address
-  /// string in dotted decimal form, or from an IPv6 address in hexadecimal
-  /// notation.
-  static address from_string(
-      const std::string& str, asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the address is a loopback address.
-  ASIO_DECL bool is_loopback() const noexcept;
-
-  /// Determine whether the address is unspecified.
-  ASIO_DECL bool is_unspecified() const noexcept;
-
-  /// Determine whether the address is a multicast address.
-  ASIO_DECL bool is_multicast() const noexcept;
-
-  /// Compare two addresses for equality.
-  ASIO_DECL friend bool operator==(const address& a1,
-      const address& a2) noexcept;
-
-  /// Compare two addresses for inequality.
-  friend bool operator!=(const address& a1,
-      const address& a2) noexcept
-  {
-    return !(a1 == a2);
-  }
-
-  /// Compare addresses for ordering.
-  ASIO_DECL friend bool operator<(const address& a1,
-      const address& a2) noexcept;
-
-  /// Compare addresses for ordering.
-  friend bool operator>(const address& a1,
-      const address& a2) noexcept
-  {
-    return a2 < a1;
-  }
-
-  /// Compare addresses for ordering.
-  friend bool operator<=(const address& a1,
-      const address& a2) noexcept
-  {
-    return !(a2 < a1);
-  }
-
-  /// Compare addresses for ordering.
-  friend bool operator>=(const address& a1,
-      const address& a2) noexcept
-  {
-    return !(a1 < a2);
-  }
-
-private:
-  // The type of the address.
-  enum { ipv4, ipv6 } type_;
-
-  // The underlying IPv4 address.
-  asio::ip::address_v4 ipv4_address_;
-
-  // The underlying IPv6 address.
-  asio::ip::address_v6 ipv6_address_;
-};
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(const char* str);
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(const char* str,
-    asio::error_code& ec) noexcept;
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(const std::string& str);
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(const std::string& str,
-    asio::error_code& ec) noexcept;
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(string_view str);
-
-/// Create an address from an IPv4 address string in dotted decimal form,
-/// or from an IPv6 address in hexadecimal notation.
-/**
- * @relates address
- */
-ASIO_DECL address make_address(string_view str,
-    asio::error_code& ec) noexcept;
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output an address as a string.
-/**
- * Used to output a human-readable string for a specified address.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param addr The address to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::address
- */
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address& addr);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-namespace std {
-
-template <>
-struct hash<asio::ip::address>
-{
-  std::size_t operator()(const asio::ip::address& addr)
-    const noexcept
-  {
-    return addr.is_v4()
-      ? std::hash<asio::ip::address_v4>()(addr.to_v4())
-      : std::hash<asio::ip::address_v6>()(addr.to_v6());
-  }
-};
-
-} // namespace std
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/address.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/address.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_ADDRESS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4.hpp
deleted file mode 100644
index ccef6c8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4.hpp
+++ /dev/null
@@ -1,421 +0,0 @@
-//
-// ip/address_v4.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V4_HPP
-#define ASIO_IP_ADDRESS_V4_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <functional>
-#include <string>
-#include "asio/detail/array.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/winsock_init.hpp"
-#include "asio/error_code.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-# include <iosfwd>
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Implements IP version 4 style addresses.
-/**
- * The asio::ip::address_v4 class provides the ability to use and
- * manipulate IP version 4 addresses.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class address_v4
-{
-public:
-  /// The type used to represent an address as an unsigned integer.
-  typedef uint_least32_t uint_type;
-
-  /// The type used to represent an address as an array of bytes.
-  /**
-   * @note This type is defined in terms of the C++0x template @c std::array
-   * when it is available. Otherwise, it uses @c boost:array.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef array<unsigned char, 4> bytes_type;
-#else
-  typedef asio::detail::array<unsigned char, 4> bytes_type;
-#endif
-
-  /// Default constructor.
-  /**
-   * Initialises the @c address_v4 object such that:
-   * @li <tt>to_bytes()</tt> yields <tt>{0, 0, 0, 0}</tt>; and
-   * @li <tt>to_uint() == 0</tt>.
-   */
-  address_v4() noexcept
-  {
-    addr_.s_addr = 0;
-  }
-
-  /// Construct an address from raw bytes.
-  /**
-   * Initialises the @c address_v4 object such that <tt>to_bytes() ==
-   * bytes</tt>.
-   *
-   * @throws out_of_range Thrown if any element in @c bytes is not in the range
-   * <tt>0 - 0xFF</tt>. Note that no range checking is required for platforms
-   * where <tt>std::numeric_limits<unsigned char>::max()</tt> is <tt>0xFF</tt>.
-   */
-  ASIO_DECL explicit address_v4(const bytes_type& bytes);
-
-  /// Construct an address from an unsigned integer in host byte order.
-  /**
-   * Initialises the @c address_v4 object such that <tt>to_uint() == addr</tt>.
-   */
-  ASIO_DECL explicit address_v4(uint_type addr);
-
-  /// Copy constructor.
-  address_v4(const address_v4& other) noexcept
-    : addr_(other.addr_)
-  {
-  }
-
-  /// Move constructor.
-  address_v4(address_v4&& other) noexcept
-    : addr_(other.addr_)
-  {
-  }
-
-  /// Assign from another address.
-  address_v4& operator=(const address_v4& other) noexcept
-  {
-    addr_ = other.addr_;
-    return *this;
-  }
-
-  /// Move-assign from another address.
-  address_v4& operator=(address_v4&& other) noexcept
-  {
-    addr_ = other.addr_;
-    return *this;
-  }
-
-  /// Get the address in bytes, in network byte order.
-  ASIO_DECL bytes_type to_bytes() const noexcept;
-
-  /// Get the address as an unsigned integer in host byte order.
-  ASIO_DECL uint_type to_uint() const noexcept;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use to_uint().) Get the address as an unsigned long in host
-  /// byte order.
-  ASIO_DECL unsigned long to_ulong() const;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Get the address as a string in dotted decimal format.
-  ASIO_DECL std::string to_string() const;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use other overload.) Get the address as a string in dotted
-  /// decimal format.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
-
-  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
-  /// string in dotted decimal form.
-  static address_v4 from_string(const char* str);
-
-  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
-  /// string in dotted decimal form.
-  static address_v4 from_string(
-      const char* str, asio::error_code& ec);
-
-  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
-  /// string in dotted decimal form.
-  static address_v4 from_string(const std::string& str);
-
-  /// (Deprecated: Use make_address_v4().) Create an address from an IP address
-  /// string in dotted decimal form.
-  static address_v4 from_string(
-      const std::string& str, asio::error_code& ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the address is a loopback address.
-  /**
-   * This function tests whether the address is in the address block
-   * <tt>127.0.0.0/8</tt>, which corresponds to the address range
-   * <tt>127.0.0.0 - 127.255.255.255</tt>.
-   *
-   * @returns <tt>(to_uint() & 0xFF000000) == 0x7F000000</tt>.
-   */
-  ASIO_DECL bool is_loopback() const noexcept;
-
-  /// Determine whether the address is unspecified.
-  /**
-   * This function tests whether the address is the unspecified address
-   * <tt>0.0.0.0</tt>.
-   *
-   * @returns <tt>to_uint() == 0</tt>.
-   */
-  ASIO_DECL bool is_unspecified() const noexcept;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
-  /// class A address.
-  ASIO_DECL bool is_class_a() const;
-
-  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
-  /// class B address.
-  ASIO_DECL bool is_class_b() const;
-
-  /// (Deprecated: Use network_v4 class.) Determine whether the address is a
-  /// class C address.
-  ASIO_DECL bool is_class_c() const;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the address is a multicast address.
-  /**
-   * This function tests whether the address is in the multicast address block
-   * <tt>224.0.0.0/4</tt>, which corresponds to the address range
-   * <tt>224.0.0.0 - 239.255.255.255</tt>.
-   *
-   * @returns <tt>(to_uint() & 0xF0000000) == 0xE0000000</tt>.
-   */
-  ASIO_DECL bool is_multicast() const noexcept;
-
-  /// Compare two addresses for equality.
-  friend bool operator==(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.addr_.s_addr == a2.addr_.s_addr;
-  }
-
-  /// Compare two addresses for inequality.
-  friend bool operator!=(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.addr_.s_addr != a2.addr_.s_addr;
-  }
-
-  /// Compare addresses for ordering.
-  /**
-   * Compares two addresses in host byte order.
-   *
-   * @returns <tt>a1.to_uint() < a2.to_uint()</tt>.
-   */
-  friend bool operator<(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.to_uint() < a2.to_uint();
-  }
-
-  /// Compare addresses for ordering.
-  /**
-   * Compares two addresses in host byte order.
-   *
-   * @returns <tt>a1.to_uint() > a2.to_uint()</tt>.
-   */
-  friend bool operator>(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.to_uint() > a2.to_uint();
-  }
-
-  /// Compare addresses for ordering.
-  /**
-   * Compares two addresses in host byte order.
-   *
-   * @returns <tt>a1.to_uint() <= a2.to_uint()</tt>.
-   */
-  friend bool operator<=(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.to_uint() <= a2.to_uint();
-  }
-
-  /// Compare addresses for ordering.
-  /**
-   * Compares two addresses in host byte order.
-   *
-   * @returns <tt>a1.to_uint() >= a2.to_uint()</tt>.
-   */
-  friend bool operator>=(const address_v4& a1,
-      const address_v4& a2) noexcept
-  {
-    return a1.to_uint() >= a2.to_uint();
-  }
-
-  /// Obtain an address object that represents any address.
-  /**
-   * This functions returns an address that represents the "any" address
-   * <tt>0.0.0.0</tt>.
-   *
-   * @returns A default-constructed @c address_v4 object.
-   */
-  static address_v4 any() noexcept
-  {
-    return address_v4();
-  }
-
-  /// Obtain an address object that represents the loopback address.
-  /**
-   * This function returns an address that represents the well-known loopback
-   * address <tt>127.0.0.1</tt>.
-   *
-   * @returns <tt>address_v4(0x7F000001)</tt>.
-   */
-  static address_v4 loopback() noexcept
-  {
-    return address_v4(0x7F000001);
-  }
-
-  /// Obtain an address object that represents the broadcast address.
-  /**
-   * This function returns an address that represents the broadcast address
-   * <tt>255.255.255.255</tt>.
-   *
-   * @returns <tt>address_v4(0xFFFFFFFF)</tt>.
-   */
-  static address_v4 broadcast() noexcept
-  {
-    return address_v4(0xFFFFFFFF);
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use network_v4 class.) Obtain an address object that
-  /// represents the broadcast address that corresponds to the specified
-  /// address and netmask.
-  ASIO_DECL static address_v4 broadcast(
-      const address_v4& addr, const address_v4& mask);
-
-  /// (Deprecated: Use network_v4 class.) Obtain the netmask that corresponds
-  /// to the address, based on its address class.
-  ASIO_DECL static address_v4 netmask(const address_v4& addr);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-private:
-  // The underlying IPv4 address.
-  asio::detail::in4_addr_type addr_;
-};
-
-/// Create an IPv4 address from raw bytes in network order.
-/**
- * @relates address_v4
- */
-inline address_v4 make_address_v4(const address_v4::bytes_type& bytes)
-{
-  return address_v4(bytes);
-}
-
-/// Create an IPv4 address from an unsigned integer in host byte order.
-/**
- * @relates address_v4
- */
-inline address_v4 make_address_v4(address_v4::uint_type addr)
-{
-  return address_v4(addr);
-}
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(const char* str);
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(const char* str,
-    asio::error_code& ec) noexcept;
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(const std::string& str);
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(const std::string& str,
-    asio::error_code& ec) noexcept;
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(string_view str);
-
-/// Create an IPv4 address from an IP address string in dotted decimal form.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(string_view str,
-    asio::error_code& ec) noexcept;
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output an address as a string.
-/**
- * Used to output a human-readable string for a specified address.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param addr The address to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::address_v4
- */
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-namespace std {
-
-template <>
-struct hash<asio::ip::address_v4>
-{
-  std::size_t operator()(const asio::ip::address_v4& addr)
-    const noexcept
-  {
-    return std::hash<unsigned int>()(addr.to_uint());
-  }
-};
-
-} // namespace std
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/address_v4.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/address_v4.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_ADDRESS_V4_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_iterator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_iterator.hpp
deleted file mode 100644
index 5b91f40..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_iterator.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-//
-// ip/address_v4_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V4_ITERATOR_HPP
-#define ASIO_IP_ADDRESS_V4_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ip/address_v4.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename> class basic_address_iterator;
-
-/// An input iterator that can be used for traversing IPv4 addresses.
-/**
- * In addition to satisfying the input iterator requirements, this iterator
- * also supports decrement.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <> class basic_address_iterator<address_v4>
-{
-public:
-  /// The type of the elements pointed to by the iterator.
-  typedef address_v4 value_type;
-
-  /// Distance between two iterators.
-  typedef std::ptrdiff_t difference_type;
-
-  /// The type of a pointer to an element pointed to by the iterator.
-  typedef const address_v4* pointer;
-
-  /// The type of a reference to an element pointed to by the iterator.
-  typedef const address_v4& reference;
-
-  /// Denotes that the iterator satisfies the input iterator requirements.
-  typedef std::input_iterator_tag iterator_category;
-
-  /// Construct an iterator that points to the specified address.
-  basic_address_iterator(const address_v4& addr) noexcept
-    : address_(addr)
-  {
-  }
-
-  /// Copy constructor.
-  basic_address_iterator(const basic_address_iterator& other) noexcept
-    : address_(other.address_)
-  {
-  }
-
-  /// Move constructor.
-  basic_address_iterator(basic_address_iterator&& other) noexcept
-    : address_(static_cast<address_v4&&>(other.address_))
-  {
-  }
-
-  /// Assignment operator.
-  basic_address_iterator& operator=(
-      const basic_address_iterator& other) noexcept
-  {
-    address_ = other.address_;
-    return *this;
-  }
-
-  /// Move assignment operator.
-  basic_address_iterator& operator=(basic_address_iterator&& other) noexcept
-  {
-    address_ = static_cast<address_v4&&>(other.address_);
-    return *this;
-  }
-
-  /// Dereference the iterator.
-  const address_v4& operator*() const noexcept
-  {
-    return address_;
-  }
-
-  /// Dereference the iterator.
-  const address_v4* operator->() const noexcept
-  {
-    return &address_;
-  }
-
-  /// Pre-increment operator.
-  basic_address_iterator& operator++() noexcept
-  {
-    address_ = address_v4((address_.to_uint() + 1) & 0xFFFFFFFF);
-    return *this;
-  }
-
-  /// Post-increment operator.
-  basic_address_iterator operator++(int) noexcept
-  {
-    basic_address_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  /// Pre-decrement operator.
-  basic_address_iterator& operator--() noexcept
-  {
-    address_ = address_v4((address_.to_uint() - 1) & 0xFFFFFFFF);
-    return *this;
-  }
-
-  /// Post-decrement operator.
-  basic_address_iterator operator--(int)
-  {
-    basic_address_iterator tmp(*this);
-    --*this;
-    return tmp;
-  }
-
-  /// Compare two addresses for equality.
-  friend bool operator==(const basic_address_iterator& a,
-      const basic_address_iterator& b)
-  {
-    return a.address_ == b.address_;
-  }
-
-  /// Compare two addresses for inequality.
-  friend bool operator!=(const basic_address_iterator& a,
-      const basic_address_iterator& b)
-  {
-    return a.address_ != b.address_;
-  }
-
-private:
-  address_v4 address_;
-};
-
-/// An input iterator that can be used for traversing IPv4 addresses.
-typedef basic_address_iterator<address_v4> address_v4_iterator;
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ADDRESS_V4_ITERATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_range.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_range.hpp
deleted file mode 100644
index 5fb5e65..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v4_range.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// ip/address_v4_range.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V4_RANGE_HPP
-#define ASIO_IP_ADDRESS_V4_RANGE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ip/address_v4_iterator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename> class basic_address_range;
-
-/// Represents a range of IPv4 addresses.
-/**
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <> class basic_address_range<address_v4>
-{
-public:
-  /// The type of an iterator that points into the range.
-  typedef basic_address_iterator<address_v4> iterator;
-
-  /// Construct an empty range.
-  basic_address_range() noexcept
-    : begin_(address_v4()),
-      end_(address_v4())
-  {
-  }
-
-  /// Construct an range that represents the given range of addresses.
-  explicit basic_address_range(const iterator& first,
-      const iterator& last) noexcept
-    : begin_(first),
-      end_(last)
-  {
-  }
-
-  /// Copy constructor.
-  basic_address_range(const basic_address_range& other) noexcept
-    : begin_(other.begin_),
-      end_(other.end_)
-  {
-  }
-
-  /// Move constructor.
-  basic_address_range(basic_address_range&& other) noexcept
-    : begin_(static_cast<iterator&&>(other.begin_)),
-      end_(static_cast<iterator&&>(other.end_))
-  {
-  }
-
-  /// Assignment operator.
-  basic_address_range& operator=(const basic_address_range& other) noexcept
-  {
-    begin_ = other.begin_;
-    end_ = other.end_;
-    return *this;
-  }
-
-  /// Move assignment operator.
-  basic_address_range& operator=(basic_address_range&& other) noexcept
-  {
-    begin_ = static_cast<iterator&&>(other.begin_);
-    end_ = static_cast<iterator&&>(other.end_);
-    return *this;
-  }
-
-  /// Obtain an iterator that points to the start of the range.
-  iterator begin() const noexcept
-  {
-    return begin_;
-  }
-
-  /// Obtain an iterator that points to the end of the range.
-  iterator end() const noexcept
-  {
-    return end_;
-  }
-
-  /// Determine whether the range is empty.
-  bool empty() const noexcept
-  {
-    return size() == 0;
-  }
-
-  /// Return the size of the range.
-  std::size_t size() const noexcept
-  {
-    return end_->to_uint() - begin_->to_uint();
-  }
-
-  /// Find an address in the range.
-  iterator find(const address_v4& addr) const noexcept
-  {
-    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
-  }
-
-private:
-  iterator begin_;
-  iterator end_;
-};
-
-/// Represents a range of IPv4 addresses.
-typedef basic_address_range<address_v4> address_v4_range;
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ADDRESS_V4_RANGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6.hpp
deleted file mode 100644
index aa65082..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6.hpp
+++ /dev/null
@@ -1,407 +0,0 @@
-//
-// ip/address_v6.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V6_HPP
-#define ASIO_IP_ADDRESS_V6_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <functional>
-#include <string>
-#include "asio/detail/array.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/winsock_init.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ip/address_v4.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-# include <iosfwd>
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename> class basic_address_iterator;
-
-/// Type used for storing IPv6 scope IDs.
-typedef uint_least32_t scope_id_type;
-
-/// Implements IP version 6 style addresses.
-/**
- * The asio::ip::address_v6 class provides the ability to use and
- * manipulate IP version 6 addresses.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class address_v6
-{
-public:
-  /// The type used to represent an address as an array of bytes.
-  /**
-   * @note This type is defined in terms of the C++0x template @c std::array
-   * when it is available. Otherwise, it uses @c boost:array.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef array<unsigned char, 16> bytes_type;
-#else
-  typedef asio::detail::array<unsigned char, 16> bytes_type;
-#endif
-
-  /// Default constructor.
-  /**
-   * Initialises the @c address_v6 object such that:
-   * @li <tt>to_bytes()</tt> yields <tt>{0, 0, ..., 0}</tt>; and
-   * @li <tt>scope_id() == 0</tt>.
-   */
-  ASIO_DECL address_v6() noexcept;
-
-  /// Construct an address from raw bytes and scope ID.
-  /**
-   * Initialises the @c address_v6 object such that:
-   * @li <tt>to_bytes() == bytes</tt>; and
-   * @li <tt>this->scope_id() == scope_id</tt>.
-   *
-   * @throws out_of_range Thrown if any element in @c bytes is not in the range
-   * <tt>0 - 0xFF</tt>. Note that no range checking is required for platforms
-   * where <tt>std::numeric_limits<unsigned char>::max()</tt> is <tt>0xFF</tt>.
-   */
-  ASIO_DECL explicit address_v6(const bytes_type& bytes,
-      scope_id_type scope_id = 0);
-
-  /// Copy constructor.
-  ASIO_DECL address_v6(const address_v6& other) noexcept;
-
-  /// Move constructor.
-  ASIO_DECL address_v6(address_v6&& other) noexcept;
-
-  /// Assign from another address.
-  ASIO_DECL address_v6& operator=(
-      const address_v6& other) noexcept;
-
-  /// Move-assign from another address.
-  ASIO_DECL address_v6& operator=(address_v6&& other) noexcept;
-
-  /// The scope ID of the address.
-  /**
-   * Returns the scope ID associated with the IPv6 address.
-   */
-  scope_id_type scope_id() const noexcept
-  {
-    return scope_id_;
-  }
-
-  /// The scope ID of the address.
-  /**
-   * Modifies the scope ID associated with the IPv6 address.
-   *
-   * @param id The new scope ID.
-   */
-  void scope_id(scope_id_type id) noexcept
-  {
-    scope_id_ = id;
-  }
-
-  /// Get the address in bytes, in network byte order.
-  ASIO_DECL bytes_type to_bytes() const noexcept;
-
-  /// Get the address as a string.
-  ASIO_DECL std::string to_string() const;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use other overload.) Get the address as a string.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
-
-  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
-  /// address string.
-  static address_v6 from_string(const char* str);
-
-  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
-  /// address string.
-  static address_v6 from_string(
-      const char* str, asio::error_code& ec);
-
-  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
-  /// address string.
-  static address_v6 from_string(const std::string& str);
-
-  /// (Deprecated: Use make_address_v6().) Create an IPv6 address from an IP
-  /// address string.
-  static address_v6 from_string(
-      const std::string& str, asio::error_code& ec);
-
-  /// (Deprecated: Use make_address_v4().) Converts an IPv4-mapped or
-  /// IPv4-compatible address to an IPv4 address.
-  ASIO_DECL address_v4 to_v4() const;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the address is a loopback address.
-  /**
-   * This function tests whether the address is the loopback address
-   * <tt>::1</tt>.
-   */
-  ASIO_DECL bool is_loopback() const noexcept;
-
-  /// Determine whether the address is unspecified.
-  /**
-   * This function tests whether the address is the loopback address
-   * <tt>::</tt>.
-   */
-  ASIO_DECL bool is_unspecified() const noexcept;
-
-  /// Determine whether the address is link local.
-  ASIO_DECL bool is_link_local() const noexcept;
-
-  /// Determine whether the address is site local.
-  ASIO_DECL bool is_site_local() const noexcept;
-
-  /// Determine whether the address is a mapped IPv4 address.
-  ASIO_DECL bool is_v4_mapped() const noexcept;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: No replacement.) Determine whether the address is an
-  /// IPv4-compatible address.
-  ASIO_DECL bool is_v4_compatible() const;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Determine whether the address is a multicast address.
-  ASIO_DECL bool is_multicast() const noexcept;
-
-  /// Determine whether the address is a global multicast address.
-  ASIO_DECL bool is_multicast_global() const noexcept;
-
-  /// Determine whether the address is a link-local multicast address.
-  ASIO_DECL bool is_multicast_link_local() const noexcept;
-
-  /// Determine whether the address is a node-local multicast address.
-  ASIO_DECL bool is_multicast_node_local() const noexcept;
-
-  /// Determine whether the address is a org-local multicast address.
-  ASIO_DECL bool is_multicast_org_local() const noexcept;
-
-  /// Determine whether the address is a site-local multicast address.
-  ASIO_DECL bool is_multicast_site_local() const noexcept;
-
-  /// Compare two addresses for equality.
-  ASIO_DECL friend bool operator==(const address_v6& a1,
-      const address_v6& a2) noexcept;
-
-  /// Compare two addresses for inequality.
-  friend bool operator!=(const address_v6& a1,
-      const address_v6& a2) noexcept
-  {
-    return !(a1 == a2);
-  }
-
-  /// Compare addresses for ordering.
-  ASIO_DECL friend bool operator<(const address_v6& a1,
-      const address_v6& a2) noexcept;
-
-  /// Compare addresses for ordering.
-  friend bool operator>(const address_v6& a1,
-      const address_v6& a2) noexcept
-  {
-    return a2 < a1;
-  }
-
-  /// Compare addresses for ordering.
-  friend bool operator<=(const address_v6& a1,
-      const address_v6& a2) noexcept
-  {
-    return !(a2 < a1);
-  }
-
-  /// Compare addresses for ordering.
-  friend bool operator>=(const address_v6& a1,
-      const address_v6& a2) noexcept
-  {
-    return !(a1 < a2);
-  }
-
-  /// Obtain an address object that represents any address.
-  /**
-   * This functions returns an address that represents the "any" address
-   * <tt>::</tt>.
-   *
-   * @returns A default-constructed @c address_v6 object.
-   */
-  static address_v6 any() noexcept
-  {
-    return address_v6();
-  }
-
-  /// Obtain an address object that represents the loopback address.
-  /**
-   * This function returns an address that represents the well-known loopback
-   * address <tt>::1</tt>.
-   */
-  ASIO_DECL static address_v6 loopback() noexcept;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address.
-  ASIO_DECL static address_v6 v4_mapped(const address_v4& addr);
-
-  /// (Deprecated: No replacement.) Create an IPv4-compatible IPv6 address.
-  ASIO_DECL static address_v6 v4_compatible(const address_v4& addr);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-private:
-  friend class basic_address_iterator<address_v6>;
-
-  // The underlying IPv6 address.
-  asio::detail::in6_addr_type addr_;
-
-  // The scope ID associated with the address.
-  scope_id_type scope_id_;
-};
-
-/// Create an IPv6 address from raw bytes and scope ID.
-/**
- * @relates address_v6
- */
-inline address_v6 make_address_v6(const address_v6::bytes_type& bytes,
-    scope_id_type scope_id = 0)
-{
-  return address_v6(bytes, scope_id);
-}
-
-/// Create an IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(const char* str);
-
-/// Create an IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(const char* str,
-    asio::error_code& ec) noexcept;
-
-/// Createan IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(const std::string& str);
-
-/// Create an IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(const std::string& str,
-    asio::error_code& ec) noexcept;
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create an IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(string_view str);
-
-/// Create an IPv6 address from an IP address string.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(string_view str,
-    asio::error_code& ec) noexcept;
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-/// Tag type used for distinguishing overloads that deal in IPv4-mapped IPv6
-/// addresses.
-enum v4_mapped_t { v4_mapped };
-
-/// Create an IPv4 address from a IPv4-mapped IPv6 address.
-/**
- * @relates address_v4
- */
-ASIO_DECL address_v4 make_address_v4(
-    v4_mapped_t, const address_v6& v6_addr);
-
-/// Create an IPv4-mapped IPv6 address from an IPv4 address.
-/**
- * @relates address_v6
- */
-ASIO_DECL address_v6 make_address_v6(
-    v4_mapped_t, const address_v4& v4_addr);
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output an address as a string.
-/**
- * Used to output a human-readable string for a specified address.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param addr The address to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::address_v6
- */
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-namespace std {
-
-template <>
-struct hash<asio::ip::address_v6>
-{
-  std::size_t operator()(const asio::ip::address_v6& addr)
-    const noexcept
-  {
-    const asio::ip::address_v6::bytes_type bytes = addr.to_bytes();
-    std::size_t result = static_cast<std::size_t>(addr.scope_id());
-    combine_4_bytes(result, &bytes[0]);
-    combine_4_bytes(result, &bytes[4]);
-    combine_4_bytes(result, &bytes[8]);
-    combine_4_bytes(result, &bytes[12]);
-    return result;
-  }
-
-private:
-  static void combine_4_bytes(std::size_t& seed, const unsigned char* bytes)
-  {
-    const std::size_t bytes_hash =
-      (static_cast<std::size_t>(bytes[0]) << 24) |
-      (static_cast<std::size_t>(bytes[1]) << 16) |
-      (static_cast<std::size_t>(bytes[2]) << 8) |
-      (static_cast<std::size_t>(bytes[3]));
-    seed ^= bytes_hash + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-  }
-};
-
-} // namespace std
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/address_v6.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/address_v6.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_ADDRESS_V6_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_iterator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_iterator.hpp
deleted file mode 100644
index 5116f61..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_iterator.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-//
-// ip/address_v6_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V6_ITERATOR_HPP
-#define ASIO_IP_ADDRESS_V6_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ip/address_v6.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename> class basic_address_iterator;
-
-/// An input iterator that can be used for traversing IPv6 addresses.
-/**
- * In addition to satisfying the input iterator requirements, this iterator
- * also supports decrement.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <> class basic_address_iterator<address_v6>
-{
-public:
-  /// The type of the elements pointed to by the iterator.
-  typedef address_v6 value_type;
-
-  /// Distance between two iterators.
-  typedef std::ptrdiff_t difference_type;
-
-  /// The type of a pointer to an element pointed to by the iterator.
-  typedef const address_v6* pointer;
-
-  /// The type of a reference to an element pointed to by the iterator.
-  typedef const address_v6& reference;
-
-  /// Denotes that the iterator satisfies the input iterator requirements.
-  typedef std::input_iterator_tag iterator_category;
-
-  /// Construct an iterator that points to the specified address.
-  basic_address_iterator(const address_v6& addr) noexcept
-    : address_(addr)
-  {
-  }
-
-  /// Copy constructor.
-  basic_address_iterator(
-      const basic_address_iterator& other) noexcept
-    : address_(other.address_)
-  {
-  }
-
-  /// Move constructor.
-  basic_address_iterator(basic_address_iterator&& other) noexcept
-    : address_(static_cast<address_v6&&>(other.address_))
-  {
-  }
-
-  /// Assignment operator.
-  basic_address_iterator& operator=(
-      const basic_address_iterator& other) noexcept
-  {
-    address_ = other.address_;
-    return *this;
-  }
-
-  /// Move assignment operator.
-  basic_address_iterator& operator=(basic_address_iterator&& other) noexcept
-  {
-    address_ = static_cast<address_v6&&>(other.address_);
-    return *this;
-  }
-
-  /// Dereference the iterator.
-  const address_v6& operator*() const noexcept
-  {
-    return address_;
-  }
-
-  /// Dereference the iterator.
-  const address_v6* operator->() const noexcept
-  {
-    return &address_;
-  }
-
-  /// Pre-increment operator.
-  basic_address_iterator& operator++() noexcept
-  {
-    for (int i = 15; i >= 0; --i)
-    {
-      if (address_.addr_.s6_addr[i] < 0xFF)
-      {
-        ++address_.addr_.s6_addr[i];
-        break;
-      }
-
-      address_.addr_.s6_addr[i] = 0;
-    }
-
-    return *this;
-  }
-
-  /// Post-increment operator.
-  basic_address_iterator operator++(int) noexcept
-  {
-    basic_address_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  /// Pre-decrement operator.
-  basic_address_iterator& operator--() noexcept
-  {
-    for (int i = 15; i >= 0; --i)
-    {
-      if (address_.addr_.s6_addr[i] > 0)
-      {
-        --address_.addr_.s6_addr[i];
-        break;
-      }
-
-      address_.addr_.s6_addr[i] = 0xFF;
-    }
-
-    return *this;
-  }
-
-  /// Post-decrement operator.
-  basic_address_iterator operator--(int)
-  {
-    basic_address_iterator tmp(*this);
-    --*this;
-    return tmp;
-  }
-
-  /// Compare two addresses for equality.
-  friend bool operator==(const basic_address_iterator& a,
-      const basic_address_iterator& b)
-  {
-    return a.address_ == b.address_;
-  }
-
-  /// Compare two addresses for inequality.
-  friend bool operator!=(const basic_address_iterator& a,
-      const basic_address_iterator& b)
-  {
-    return a.address_ != b.address_;
-  }
-
-private:
-  address_v6 address_;
-};
-
-/// An input iterator that can be used for traversing IPv6 addresses.
-typedef basic_address_iterator<address_v6> address_v6_iterator;
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ADDRESS_V6_ITERATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_range.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_range.hpp
deleted file mode 100644
index 7f89773..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/address_v6_range.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// ip/address_v6_range.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//                         Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ADDRESS_V6_RANGE_HPP
-#define ASIO_IP_ADDRESS_V6_RANGE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ip/address_v6_iterator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename> class basic_address_range;
-
-/// Represents a range of IPv6 addresses.
-/**
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <> class basic_address_range<address_v6>
-{
-public:
-  /// The type of an iterator that points into the range.
-  typedef basic_address_iterator<address_v6> iterator;
-
-  /// Construct an empty range.
-  basic_address_range() noexcept
-    : begin_(address_v6()),
-      end_(address_v6())
-  {
-  }
-
-  /// Construct an range that represents the given range of addresses.
-  explicit basic_address_range(const iterator& first,
-      const iterator& last) noexcept
-    : begin_(first),
-      end_(last)
-  {
-  }
-
-  /// Copy constructor.
-  basic_address_range(const basic_address_range& other) noexcept
-    : begin_(other.begin_),
-      end_(other.end_)
-  {
-  }
-
-  /// Move constructor.
-  basic_address_range(basic_address_range&& other) noexcept
-    : begin_(static_cast<iterator&&>(other.begin_)),
-      end_(static_cast<iterator&&>(other.end_))
-  {
-  }
-
-  /// Assignment operator.
-  basic_address_range& operator=(
-      const basic_address_range& other) noexcept
-  {
-    begin_ = other.begin_;
-    end_ = other.end_;
-    return *this;
-  }
-
-  /// Move assignment operator.
-  basic_address_range& operator=(basic_address_range&& other) noexcept
-  {
-    begin_ = static_cast<iterator&&>(other.begin_);
-    end_ = static_cast<iterator&&>(other.end_);
-    return *this;
-  }
-
-  /// Obtain an iterator that points to the start of the range.
-  iterator begin() const noexcept
-  {
-    return begin_;
-  }
-
-  /// Obtain an iterator that points to the end of the range.
-  iterator end() const noexcept
-  {
-    return end_;
-  }
-
-  /// Determine whether the range is empty.
-  bool empty() const noexcept
-  {
-    return begin_ == end_;
-  }
-
-  /// Find an address in the range.
-  iterator find(const address_v6& addr) const noexcept
-  {
-    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
-  }
-
-private:
-  iterator begin_;
-  iterator end_;
-};
-
-/// Represents a range of IPv6 addresses.
-typedef basic_address_range<address_v6> address_v6_range;
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ADDRESS_V6_RANGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/bad_address_cast.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/bad_address_cast.hpp
deleted file mode 100644
index 3d242f0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/bad_address_cast.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// ip/bad_address_cast.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BAD_ADDRESS_CAST_HPP
-#define ASIO_IP_BAD_ADDRESS_CAST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <typeinfo>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Thrown to indicate a failed address conversion.
-class bad_address_cast :
-#if defined(ASIO_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
-  public std::exception
-#else
-  public std::bad_cast
-#endif
-{
-public:
-  /// Default constructor.
-  bad_address_cast() {}
-
-  /// Copy constructor.
-  bad_address_cast(const bad_address_cast& other) noexcept
-#if defined(ASIO_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
-    : std::exception(static_cast<const std::exception&>(other))
-#else
-    : std::bad_cast(static_cast<const std::bad_cast&>(other))
-#endif
-  {
-  }
-
-  /// Destructor.
-  virtual ~bad_address_cast() noexcept {}
-
-  /// Get the message associated with the exception.
-  virtual const char* what() const noexcept
-  {
-    return "bad address cast";
-  }
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ADDRESS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_endpoint.hpp
deleted file mode 100644
index 3dfb124..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_endpoint.hpp
+++ /dev/null
@@ -1,282 +0,0 @@
-//
-// ip/basic_endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_ENDPOINT_HPP
-#define ASIO_IP_BASIC_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <functional>
-#include "asio/detail/cstdint.hpp"
-#include "asio/ip/address.hpp"
-#include "asio/ip/detail/endpoint.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-# include <iosfwd>
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Type used for storing port numbers.
-typedef uint_least16_t port_type;
-
-/// Describes an endpoint for a version-independent IP socket.
-/**
- * The asio::ip::basic_endpoint class template describes an endpoint that
- * may be associated with a particular socket.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * Endpoint.
- */
-template <typename InternetProtocol>
-class basic_endpoint
-{
-public:
-  /// The protocol type associated with the endpoint.
-  typedef InternetProtocol protocol_type;
-
-  /// The type of the endpoint structure. This type is dependent on the
-  /// underlying implementation of the socket layer.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined data_type;
-#else
-  typedef asio::detail::socket_addr_type data_type;
-#endif
-
-  /// Default constructor.
-  basic_endpoint() noexcept
-    : impl_()
-  {
-  }
-
-  /// Construct an endpoint using a port number, specified in the host's byte
-  /// order. The IP address will be the any address (i.e. INADDR_ANY or
-  /// in6addr_any). This constructor would typically be used for accepting new
-  /// connections.
-  /**
-   * @par Examples
-   * To initialise an IPv4 TCP endpoint for port 1234, use:
-   * @code
-   * asio::ip::tcp::endpoint ep(asio::ip::tcp::v4(), 1234);
-   * @endcode
-   *
-   * To specify an IPv6 UDP endpoint for port 9876, use:
-   * @code
-   * asio::ip::udp::endpoint ep(asio::ip::udp::v6(), 9876);
-   * @endcode
-   */
-  basic_endpoint(const InternetProtocol& internet_protocol,
-      port_type port_num) noexcept
-    : impl_(internet_protocol.family(), port_num)
-  {
-  }
-
-  /// Construct an endpoint using a port number and an IP address. This
-  /// constructor may be used for accepting connections on a specific interface
-  /// or for making a connection to a remote endpoint.
-  basic_endpoint(const asio::ip::address& addr,
-      port_type port_num) noexcept
-    : impl_(addr, port_num)
-  {
-  }
-
-  /// Copy constructor.
-  basic_endpoint(const basic_endpoint& other) noexcept
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Move constructor.
-  basic_endpoint(basic_endpoint&& other) noexcept
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Assign from another endpoint.
-  basic_endpoint& operator=(const basic_endpoint& other) noexcept
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// Move-assign from another endpoint.
-  basic_endpoint& operator=(basic_endpoint&& other) noexcept
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// The protocol associated with the endpoint.
-  protocol_type protocol() const noexcept
-  {
-    if (impl_.is_v4())
-      return InternetProtocol::v4();
-    return InternetProtocol::v6();
-  }
-
-  /// Get the underlying endpoint in the native type.
-  data_type* data() noexcept
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying endpoint in the native type.
-  const data_type* data() const noexcept
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying size of the endpoint in the native type.
-  std::size_t size() const noexcept
-  {
-    return impl_.size();
-  }
-
-  /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t new_size)
-  {
-    impl_.resize(new_size);
-  }
-
-  /// Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const noexcept
-  {
-    return impl_.capacity();
-  }
-
-  /// Get the port associated with the endpoint. The port number is always in
-  /// the host's byte order.
-  port_type port() const noexcept
-  {
-    return impl_.port();
-  }
-
-  /// Set the port associated with the endpoint. The port number is always in
-  /// the host's byte order.
-  void port(port_type port_num) noexcept
-  {
-    impl_.port(port_num);
-  }
-
-  /// Get the IP address associated with the endpoint.
-  asio::ip::address address() const noexcept
-  {
-    return impl_.address();
-  }
-
-  /// Set the IP address associated with the endpoint.
-  void address(const asio::ip::address& addr) noexcept
-  {
-    impl_.address(addr);
-  }
-
-  /// Compare two endpoints for equality.
-  friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return e1.impl_ == e2.impl_;
-  }
-
-  /// Compare two endpoints for inequality.
-  friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return !(e1 == e2);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return e1.impl_ < e2.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return e2.impl_ < e1.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return !(e2 < e1);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
-      const basic_endpoint<InternetProtocol>& e2) noexcept
-  {
-    return !(e1 < e2);
-  }
-
-private:
-  // The underlying IP endpoint.
-  asio::ip::detail::endpoint impl_;
-};
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output an endpoint as a string.
-/**
- * Used to output a human-readable string for a specified endpoint.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param endpoint The endpoint to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::basic_endpoint
- */
-template <typename Elem, typename Traits, typename InternetProtocol>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os,
-    const basic_endpoint<InternetProtocol>& endpoint);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-namespace std {
-
-template <typename InternetProtocol>
-struct hash<asio::ip::basic_endpoint<InternetProtocol>>
-{
-  std::size_t operator()(
-      const asio::ip::basic_endpoint<InternetProtocol>& ep)
-    const noexcept
-  {
-    std::size_t hash1 = std::hash<asio::ip::address>()(ep.address());
-    std::size_t hash2 = std::hash<unsigned short>()(ep.port());
-    return hash1 ^ (hash2 + 0x9e3779b9 + (hash1 << 6) + (hash1 >> 2));
-  }
-};
-
-} // namespace std
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/basic_endpoint.hpp"
-
-#endif // ASIO_IP_BASIC_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver.hpp
deleted file mode 100644
index 915cb3c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver.hpp
+++ /dev/null
@@ -1,1112 +0,0 @@
-//
-// ip/basic_resolver.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_RESOLVER_HPP
-#define ASIO_IP_BASIC_RESOLVER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/basic_resolver_results.hpp"
-#include "asio/ip/resolver_base.hpp"
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/winrt_resolver_service.hpp"
-#else
-# include "asio/detail/resolver_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-#if !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
-#define ASIO_IP_BASIC_RESOLVER_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename InternetProtocol, typename Executor = any_io_executor>
-class basic_resolver;
-
-#endif // !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
-
-/// Provides endpoint resolution functionality.
-/**
- * The basic_resolver class template provides the ability to resolve a query
- * to a list of endpoints.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename InternetProtocol, typename Executor>
-class basic_resolver
-  : public resolver_base
-{
-private:
-  class initiate_async_resolve;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the resolver type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The resolver type when rebound to the specified executor.
-    typedef basic_resolver<InternetProtocol, Executor1> other;
-  };
-
-  /// The protocol type.
-  typedef InternetProtocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename InternetProtocol::endpoint endpoint_type;
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated.) The query type.
-  typedef basic_resolver_query<InternetProtocol> query;
-
-  /// (Deprecated.) The iterator type.
-  typedef basic_resolver_iterator<InternetProtocol> iterator;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// The results type.
-  typedef basic_resolver_results<InternetProtocol> results_type;
-
-  /// Construct with executor.
-  /**
-   * This constructor creates a basic_resolver.
-   *
-   * @param ex The I/O executor that the resolver will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * resolver.
-   */
-  explicit basic_resolver(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct with execution context.
-  /**
-   * This constructor creates a basic_resolver.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the resolver will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the resolver.
-   */
-  template <typename ExecutionContext>
-  explicit basic_resolver(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Move-construct a basic_resolver from another.
-  /**
-   * This constructor moves a resolver from one object to another.
-   *
-   * @param other The other basic_resolver object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_resolver(const executor_type&) constructor.
-   */
-  basic_resolver(basic_resolver&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  // All resolvers have access to each other's implementations.
-  template <typename InternetProtocol1, typename Executor1>
-  friend class basic_resolver;
-
-  /// Move-construct a basic_resolver from another.
-  /**
-   * This constructor moves a resolver from one object to another.
-   *
-   * @param other The other basic_resolver object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_resolver(const executor_type&) constructor.
-   */
-  template <typename Executor1>
-  basic_resolver(basic_resolver<InternetProtocol, Executor1>&& other,
-      constraint_t<
-          is_convertible<Executor1, Executor>::value
-      > = 0)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_resolver from another.
-  /**
-   * This assignment operator moves a resolver from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_resolver object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_resolver(const executor_type&) constructor.
-   */
-  basic_resolver& operator=(basic_resolver&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  /// Move-assign a basic_resolver from another.
-  /**
-   * This assignment operator moves a resolver from one object to another.
-   * Cancels any outstanding asynchronous operations associated with the target
-   * object.
-   *
-   * @param other The other basic_resolver object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_resolver(const executor_type&) constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_resolver&
-  > operator=(basic_resolver<InternetProtocol, Executor1>&& other)
-  {
-    basic_resolver tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Destroys the resolver.
-  /**
-   * This function destroys the resolver, cancelling any outstanding
-   * asynchronous wait operations associated with the resolver as if by calling
-   * @c cancel.
-   */
-  ~basic_resolver()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  executor_type get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the resolver.
-  /**
-   * This function forces the completion of any pending asynchronous
-   * operations on the host resolver. The handler for each cancelled operation
-   * will be invoked with the asio::error::operation_aborted error code.
-   */
-  void cancel()
-  {
-    return impl_.get_service().cancel(impl_.get_implementation());
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use overload with separate host and service parameters.)
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve a query into a list of endpoint entries.
-   *
-   * @param q A query object that determines what endpoints will be returned.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  results_type resolve(const query& q)
-  {
-    asio::error_code ec;
-    results_type r = impl_.get_service().resolve(
-        impl_.get_implementation(), q, ec);
-    asio::detail::throw_error(ec, "resolve");
-    return r;
-  }
-
-  /// (Deprecated: Use overload with separate host and service parameters.)
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve a query into a list of endpoint entries.
-   *
-   * @param q A query object that determines what endpoints will be returned.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   */
-  results_type resolve(const query& q, asio::error_code& ec)
-  {
-    return impl_.get_service().resolve(impl_.get_implementation(), q, ec);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service)
-  {
-    return resolve(host, service, resolver_base::flags());
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service, asio::error_code& ec)
-  {
-    return resolve(host, service, resolver_base::flags(), ec);
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags)
-  {
-    asio::error_code ec;
-    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-    results_type r = impl_.get_service().resolve(
-        impl_.get_implementation(), q, ec);
-    asio::detail::throw_error(ec, "resolve");
-    return r;
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags,
-      asio::error_code& ec)
-  {
-    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-    return impl_.get_service().resolve(impl_.get_implementation(), q, ec);
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service)
-  {
-    return resolve(protocol, host, service, resolver_base::flags());
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
-      asio::error_code& ec)
-  {
-    return resolve(protocol, host, service, resolver_base::flags(), ec);
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
-      resolver_base::flags resolve_flags)
-  {
-    asio::error_code ec;
-    basic_resolver_query<protocol_type> q(
-        protocol, static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-    results_type r = impl_.get_service().resolve(
-        impl_.get_implementation(), q, ec);
-    asio::detail::throw_error(ec, "resolve");
-    return r;
-  }
-
-  /// Perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  results_type resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
-      resolver_base::flags resolve_flags, asio::error_code& ec)
-  {
-    basic_resolver_query<protocol_type> q(
-        protocol, static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-    return impl_.get_service().resolve(impl_.get_implementation(), q, ec);
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use overload with separate host and service parameters.)
-  /// Asynchronously perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to asynchronously resolve a query into a list of
-   * endpoint entries. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param q A query object that determines what endpoints will be returned.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(const query& q,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token, q))
-  {
-    return asio::async_initiate<ResolveToken,
-      void (asio::error_code, results_type)>(
-        initiate_async_resolve(this), token, q);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Asynchronously perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token,
-          declval<basic_resolver_query<protocol_type>&>()))
-  {
-    return async_resolve(host, service, resolver_base::flags(),
-        static_cast<ResolveToken&&>(token));
-  }
-
-  /// Asynchronously perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(ASIO_STRING_VIEW_PARAM host,
-      ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token,
-          declval<basic_resolver_query<protocol_type>&>()))
-  {
-    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-
-    return asio::async_initiate<ResolveToken,
-      void (asio::error_code, results_type)>(
-        initiate_async_resolve(this), token, q);
-  }
-
-  /// Asynchronously perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token,
-          declval<basic_resolver_query<protocol_type>&>()))
-  {
-    return async_resolve(protocol, host, service, resolver_base::flags(),
-        static_cast<ResolveToken&&>(token));
-  }
-
-  /// Asynchronously perform forward resolution of a query to a list of entries.
-  /**
-   * This function is used to resolve host and service names into a list of
-   * endpoint entries. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts. See the @ref resolver_base documentation for the set of
-   * available flags.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(const protocol_type& protocol,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
-      resolver_base::flags resolve_flags,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token,
-          declval<basic_resolver_query<protocol_type>&>()))
-  {
-    basic_resolver_query<protocol_type> q(
-        protocol, static_cast<std::string>(host),
-        static_cast<std::string>(service), resolve_flags);
-
-    return asio::async_initiate<ResolveToken,
-      void (asio::error_code, results_type)>(
-        initiate_async_resolve(this), token, q);
-  }
-
-  /// Perform reverse resolution of an endpoint to a list of entries.
-  /**
-   * This function is used to resolve an endpoint into a list of endpoint
-   * entries.
-   *
-   * @param e An endpoint object that determines what endpoints will be
-   * returned.
-   *
-   * @returns A range object representing the list of endpoint entries. A
-   * successful call to this function is guaranteed to return a non-empty
-   * range.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  results_type resolve(const endpoint_type& e)
-  {
-    asio::error_code ec;
-    results_type i = impl_.get_service().resolve(
-        impl_.get_implementation(), e, ec);
-    asio::detail::throw_error(ec, "resolve");
-    return i;
-  }
-
-  /// Perform reverse resolution of an endpoint to a list of entries.
-  /**
-   * This function is used to resolve an endpoint into a list of endpoint
-   * entries.
-   *
-   * @param e An endpoint object that determines what endpoints will be
-   * returned.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns A range object representing the list of endpoint entries. An
-   * empty range is returned if an error occurs. A successful call to this
-   * function is guaranteed to return a non-empty range.
-   */
-  results_type resolve(const endpoint_type& e, asio::error_code& ec)
-  {
-    return impl_.get_service().resolve(impl_.get_implementation(), e, ec);
-  }
-
-  /// Asynchronously perform reverse resolution of an endpoint to a list of
-  /// entries.
-  /**
-   * This function is used to asynchronously resolve an endpoint into a list of
-   * endpoint entries. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param e An endpoint object that determines what endpoints will be
-   * returned.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the resolve completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   resolver::results_type results // Resolved endpoints as a range.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * A successful resolve operation is guaranteed to pass a non-empty range to
-   * the handler.
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, results_type) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        results_type)) ResolveToken = default_completion_token_t<executor_type>>
-  auto async_resolve(const endpoint_type& e,
-      ResolveToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      asio::async_initiate<ResolveToken,
-        void (asio::error_code, results_type)>(
-          declval<initiate_async_resolve>(), token, e))
-  {
-    return asio::async_initiate<ResolveToken,
-      void (asio::error_code, results_type)>(
-        initiate_async_resolve(this), token, e);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_resolver(const basic_resolver&) = delete;
-  basic_resolver& operator=(const basic_resolver&) = delete;
-
-  class initiate_async_resolve
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_resolve(basic_resolver* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ResolveHandler, typename Query>
-    void operator()(ResolveHandler&& handler,
-        const Query& q) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ResolveHandler.
-      ASIO_RESOLVE_HANDLER_CHECK(
-          ResolveHandler, handler, results_type) type_check;
-
-      asio::detail::non_const_lvalue<ResolveHandler> handler2(handler);
-      self_->impl_.get_service().async_resolve(
-          self_->impl_.get_implementation(), q,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_resolver* self_;
-  };
-
-# if defined(ASIO_WINDOWS_RUNTIME)
-  asio::detail::io_object_impl<
-    asio::detail::winrt_resolver_service<InternetProtocol>,
-    Executor> impl_;
-# else
-  asio::detail::io_object_impl<
-    asio::detail::resolver_service<InternetProtocol>,
-    Executor> impl_;
-# endif
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_BASIC_RESOLVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_entry.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_entry.hpp
deleted file mode 100644
index a65af27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_entry.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-//
-// ip/basic_resolver_entry.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
-#define ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/detail/string_view.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// An entry produced by a resolver.
-/**
- * The asio::ip::basic_resolver_entry class template describes an entry
- * as returned by a resolver.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename InternetProtocol>
-class basic_resolver_entry
-{
-public:
-  /// The protocol type associated with the endpoint entry.
-  typedef InternetProtocol protocol_type;
-
-  /// The endpoint type associated with the endpoint entry.
-  typedef typename InternetProtocol::endpoint endpoint_type;
-
-  /// Default constructor.
-  basic_resolver_entry()
-  {
-  }
-
-  /// Construct with specified endpoint, host name and service name.
-  basic_resolver_entry(const endpoint_type& ep,
-      ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service)
-    : endpoint_(ep),
-      host_name_(static_cast<std::string>(host)),
-      service_name_(static_cast<std::string>(service))
-  {
-  }
-
-  /// Get the endpoint associated with the entry.
-  endpoint_type endpoint() const
-  {
-    return endpoint_;
-  }
-
-  /// Convert to the endpoint associated with the entry.
-  operator endpoint_type() const
-  {
-    return endpoint_;
-  }
-
-  /// Get the host name associated with the entry.
-  std::string host_name() const
-  {
-    return host_name_;
-  }
-
-  /// Get the host name associated with the entry.
-  template <class Allocator>
-  std::basic_string<char, std::char_traits<char>, Allocator> host_name(
-      const Allocator& alloc = Allocator()) const
-  {
-    return std::basic_string<char, std::char_traits<char>, Allocator>(
-        host_name_.c_str(), alloc);
-  }
-
-  /// Get the service name associated with the entry.
-  std::string service_name() const
-  {
-    return service_name_;
-  }
-
-  /// Get the service name associated with the entry.
-  template <class Allocator>
-  std::basic_string<char, std::char_traits<char>, Allocator> service_name(
-      const Allocator& alloc = Allocator()) const
-  {
-    return std::basic_string<char, std::char_traits<char>, Allocator>(
-        service_name_.c_str(), alloc);
-  }
-
-private:
-  endpoint_type endpoint_;
-  std::string host_name_;
-  std::string service_name_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_iterator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_iterator.hpp
deleted file mode 100644
index b494f7a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_iterator.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// ip/basic_resolver_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
-#define ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include <iterator>
-#include <string>
-#include <vector>
-#include "asio/detail/memory.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/ip/basic_resolver_entry.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/winrt_utils.hpp"
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// An iterator over the entries produced by a resolver.
-/**
- * The asio::ip::basic_resolver_iterator class template is used to define
- * iterators over the results returned by a resolver.
- *
- * The iterator's value_type, obtained when the iterator is dereferenced, is:
- * @code const basic_resolver_entry<InternetProtocol> @endcode
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename InternetProtocol>
-class basic_resolver_iterator
-{
-public:
-  /// The type used for the distance between two iterators.
-  typedef std::ptrdiff_t difference_type;
-
-  /// The type of the value pointed to by the iterator.
-  typedef basic_resolver_entry<InternetProtocol> value_type;
-
-  /// The type of the result of applying operator->() to the iterator.
-  typedef const basic_resolver_entry<InternetProtocol>* pointer;
-
-  /// The type of the result of applying operator*() to the iterator.
-  typedef const basic_resolver_entry<InternetProtocol>& reference;
-
-  /// The iterator category.
-  typedef std::forward_iterator_tag iterator_category;
-
-  /// Default constructor creates an end iterator.
-  basic_resolver_iterator()
-    : index_(0)
-  {
-  }
-
-  /// Copy constructor.
-  basic_resolver_iterator(const basic_resolver_iterator& other)
-    : values_(other.values_),
-      index_(other.index_)
-  {
-  }
-
-  /// Move constructor.
-  basic_resolver_iterator(basic_resolver_iterator&& other)
-    : values_(static_cast<values_ptr_type&&>(other.values_)),
-      index_(other.index_)
-  {
-    other.index_ = 0;
-  }
-
-  /// Assignment operator.
-  basic_resolver_iterator& operator=(const basic_resolver_iterator& other)
-  {
-    values_ = other.values_;
-    index_ = other.index_;
-    return *this;
-  }
-
-  /// Move-assignment operator.
-  basic_resolver_iterator& operator=(basic_resolver_iterator&& other)
-  {
-    if (this != &other)
-    {
-      values_ = static_cast<values_ptr_type&&>(other.values_);
-      index_ = other.index_;
-      other.index_ = 0;
-    }
-
-    return *this;
-  }
-
-  /// Dereference an iterator.
-  const basic_resolver_entry<InternetProtocol>& operator*() const
-  {
-    return dereference();
-  }
-
-  /// Dereference an iterator.
-  const basic_resolver_entry<InternetProtocol>* operator->() const
-  {
-    return &dereference();
-  }
-
-  /// Increment operator (prefix).
-  basic_resolver_iterator& operator++()
-  {
-    increment();
-    return *this;
-  }
-
-  /// Increment operator (postfix).
-  basic_resolver_iterator operator++(int)
-  {
-    basic_resolver_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  /// Test two iterators for equality.
-  friend bool operator==(const basic_resolver_iterator& a,
-      const basic_resolver_iterator& b)
-  {
-    return a.equal(b);
-  }
-
-  /// Test two iterators for inequality.
-  friend bool operator!=(const basic_resolver_iterator& a,
-      const basic_resolver_iterator& b)
-  {
-    return !a.equal(b);
-  }
-
-protected:
-  void increment()
-  {
-    if (++index_ == values_->size())
-    {
-      // Reset state to match a default constructed end iterator.
-      values_.reset();
-      index_ = 0;
-    }
-  }
-
-  bool equal(const basic_resolver_iterator& other) const
-  {
-    if (!values_ && !other.values_)
-      return true;
-    if (values_ != other.values_)
-      return false;
-    return index_ == other.index_;
-  }
-
-  const basic_resolver_entry<InternetProtocol>& dereference() const
-  {
-    return (*values_)[index_];
-  }
-
-  typedef std::vector<basic_resolver_entry<InternetProtocol>> values_type;
-  typedef asio::detail::shared_ptr<values_type> values_ptr_type;
-  values_ptr_type values_;
-  std::size_t index_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_query.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_query.hpp
deleted file mode 100644
index ada5a4f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_query.hpp
+++ /dev/null
@@ -1,260 +0,0 @@
-//
-// ip/basic_resolver_query.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_RESOLVER_QUERY_HPP
-#define ASIO_IP_BASIC_RESOLVER_QUERY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/ip/resolver_query_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// An query to be passed to a resolver.
-/**
- * The asio::ip::basic_resolver_query class template describes a query
- * that can be passed to a resolver.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename InternetProtocol>
-class basic_resolver_query
-  : public resolver_query_base
-{
-public:
-  /// The protocol type associated with the endpoint query.
-  typedef InternetProtocol protocol_type;
-
-  /// Construct with specified service name for any protocol.
-  /**
-   * This constructor is typically used to perform name resolution for local
-   * service binding.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for local service
-   * binding.
-   *
-   * @note On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  basic_resolver_query(const std::string& service,
-      resolver_query_base::flags resolve_flags = passive | address_configured)
-    : hints_(),
-      host_name_(),
-      service_name_(service)
-  {
-    typename InternetProtocol::endpoint endpoint;
-    hints_.ai_flags = static_cast<int>(resolve_flags);
-    hints_.ai_family = PF_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;
-  }
-
-  /// Construct with specified service name for a given protocol.
-  /**
-   * This constructor is typically used to perform name resolution for local
-   * service binding with a specific protocol version.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for local service
-   * binding.
-   *
-   * @note On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  basic_resolver_query(const protocol_type& protocol,
-      const std::string& service,
-      resolver_query_base::flags resolve_flags = passive | address_configured)
-    : hints_(),
-      host_name_(),
-      service_name_(service)
-  {
-    hints_.ai_flags = static_cast<int>(resolve_flags);
-    hints_.ai_family = protocol.family();
-    hints_.ai_socktype = protocol.type();
-    hints_.ai_protocol = protocol.protocol();
-    hints_.ai_addrlen = 0;
-    hints_.ai_canonname = 0;
-    hints_.ai_addr = 0;
-    hints_.ai_next = 0;
-  }
-
-  /// Construct with specified host name and service name for any protocol.
-  /**
-   * This constructor is typically used to perform name resolution for
-   * communication with remote hosts.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  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;
-  }
-
-  /// Construct with specified host name and service name for a given protocol.
-  /**
-   * This constructor is typically used to perform name resolution for
-   * communication with remote hosts.
-   *
-   * @param protocol A protocol object, normally representing either the IPv4 or
-   * IPv6 version of an internet protocol.
-   *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
-   *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
-   *
-   * @param resolve_flags A set of flags that determine how name resolution
-   * should be performed. The default flags are suitable for communication with
-   * remote hosts.
-   *
-   * @note On POSIX systems, host names may be locally defined in the file
-   * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
-   * resolution is performed using DNS. Operating systems may use additional
-   * locations when resolving host names (such as NETBIOS names on Windows).
-   *
-   * On POSIX systems, service names are typically defined in the file
-   * <tt>/etc/services</tt>. On Windows, service names may be found in the file
-   * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
-   * may use additional locations when resolving service names.
-   */
-  basic_resolver_query(const protocol_type& protocol,
-      const std::string& host, const std::string& service,
-      resolver_query_base::flags resolve_flags = address_configured)
-    : hints_(),
-      host_name_(host),
-      service_name_(service)
-  {
-    hints_.ai_flags = static_cast<int>(resolve_flags);
-    hints_.ai_family = protocol.family();
-    hints_.ai_socktype = protocol.type();
-    hints_.ai_protocol = protocol.protocol();
-    hints_.ai_addrlen = 0;
-    hints_.ai_canonname = 0;
-    hints_.ai_addr = 0;
-    hints_.ai_next = 0;
-  }
-
-  /// Copy construct a @c basic_resolver_query from another.
-  basic_resolver_query(const basic_resolver_query& other)
-    : hints_(other.hints_),
-      host_name_(other.host_name_),
-      service_name_(other.service_name_)
-  {
-  }
-
-  /// Move construct a @c basic_resolver_query from another.
-  basic_resolver_query(basic_resolver_query&& other)
-    : hints_(other.hints_),
-      host_name_(static_cast<std::string&&>(other.host_name_)),
-      service_name_(static_cast<std::string&&>(other.service_name_))
-  {
-  }
-
-  /// Get the hints associated with the query.
-  const asio::detail::addrinfo_type& hints() const
-  {
-    return hints_;
-  }
-
-  /// Get the host name associated with the query.
-  std::string host_name() const
-  {
-    return host_name_;
-  }
-
-  /// Get the service name associated with the query.
-  std::string service_name() const
-  {
-    return service_name_;
-  }
-
-private:
-  asio::detail::addrinfo_type hints_;
-  std::string host_name_;
-  std::string service_name_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_BASIC_RESOLVER_QUERY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_results.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_results.hpp
deleted file mode 100644
index 7a461f1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/basic_resolver_results.hpp
+++ /dev/null
@@ -1,307 +0,0 @@
-//
-// ip/basic_resolver_results.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
-#define ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-# include "asio/detail/winrt_utils.hpp"
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// A range of entries produced by a resolver.
-/**
- * The asio::ip::basic_resolver_results class template is used to define
- * a range over the results returned by a resolver.
- *
- * The iterator's value_type, obtained when a results iterator is dereferenced,
- * is: @code const basic_resolver_entry<InternetProtocol> @endcode
- *
- * @note For backward compatibility, basic_resolver_results is derived from
- * basic_resolver_iterator. This derivation is deprecated.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename InternetProtocol>
-class basic_resolver_results
-#if !defined(ASIO_NO_DEPRECATED)
-  : public basic_resolver_iterator<InternetProtocol>
-#else // !defined(ASIO_NO_DEPRECATED)
-  : private basic_resolver_iterator<InternetProtocol>
-#endif // !defined(ASIO_NO_DEPRECATED)
-{
-public:
-  /// The protocol type associated with the results.
-  typedef InternetProtocol protocol_type;
-
-  /// The endpoint type associated with the results.
-  typedef typename protocol_type::endpoint endpoint_type;
-
-  /// The type of a value in the results range.
-  typedef basic_resolver_entry<protocol_type> value_type;
-
-  /// The type of a const reference to a value in the range.
-  typedef const value_type& const_reference;
-
-  /// The type of a non-const reference to a value in the range.
-  typedef value_type& reference;
-
-  /// The type of an iterator into the range.
-  typedef basic_resolver_iterator<protocol_type> const_iterator;
-
-  /// The type of an iterator into the range.
-  typedef const_iterator iterator;
-
-  /// Type used to represent the distance between two iterators in the range.
-  typedef std::ptrdiff_t difference_type;
-
-  /// Type used to represent a count of the elements in the range.
-  typedef std::size_t size_type;
-
-  /// Default constructor creates an empty range.
-  basic_resolver_results()
-  {
-  }
-
-  /// Copy constructor.
-  basic_resolver_results(const basic_resolver_results& other)
-    : basic_resolver_iterator<InternetProtocol>(other)
-  {
-  }
-
-  /// Move constructor.
-  basic_resolver_results(basic_resolver_results&& other)
-    : basic_resolver_iterator<InternetProtocol>(
-        static_cast<basic_resolver_results&&>(other))
-  {
-  }
-
-  /// Assignment operator.
-  basic_resolver_results& operator=(const basic_resolver_results& other)
-  {
-    basic_resolver_iterator<InternetProtocol>::operator=(other);
-    return *this;
-  }
-
-  /// Move-assignment operator.
-  basic_resolver_results& operator=(basic_resolver_results&& other)
-  {
-    basic_resolver_iterator<InternetProtocol>::operator=(
-        static_cast<basic_resolver_results&&>(other));
-    return *this;
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-  // Create results from an addrinfo list returned by getaddrinfo.
-  static basic_resolver_results create(
-      asio::detail::addrinfo_type* address_info,
-      const std::string& host_name, const std::string& service_name)
-  {
-    basic_resolver_results results;
-    if (!address_info)
-      return results;
-
-    std::string actual_host_name = host_name;
-    if (address_info->ai_canonname)
-      actual_host_name = address_info->ai_canonname;
-
-    results.values_.reset(new values_type);
-
-    while (address_info)
-    {
-      if (address_info->ai_family == ASIO_OS_DEF(AF_INET)
-          || address_info->ai_family == ASIO_OS_DEF(AF_INET6))
-      {
-        using namespace std; // For memcpy.
-        typename InternetProtocol::endpoint endpoint;
-        endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
-        memcpy(endpoint.data(), address_info->ai_addr,
-            address_info->ai_addrlen);
-        results.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(endpoint,
-              actual_host_name, service_name));
-      }
-      address_info = address_info->ai_next;
-    }
-
-    return results;
-  }
-
-  // Create results from an endpoint, host name and service name.
-  static basic_resolver_results create(const endpoint_type& endpoint,
-      const std::string& host_name, const std::string& service_name)
-  {
-    basic_resolver_results results;
-    results.values_.reset(new values_type);
-    results.values_->push_back(
-        basic_resolver_entry<InternetProtocol>(
-          endpoint, host_name, service_name));
-    return results;
-  }
-
-  // Create results from a sequence of endpoints, host and service name.
-  template <typename EndpointIterator>
-  static basic_resolver_results create(
-      EndpointIterator begin, EndpointIterator end,
-      const std::string& host_name, const std::string& service_name)
-  {
-    basic_resolver_results results;
-    if (begin != end)
-    {
-      results.values_.reset(new values_type);
-      for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
-      {
-        results.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(
-              *ep_iter, host_name, service_name));
-      }
-    }
-    return results;
-  }
-
-# if defined(ASIO_WINDOWS_RUNTIME)
-  // Create results from a Windows Runtime list of EndpointPair objects.
-  static basic_resolver_results create(
-      Windows::Foundation::Collections::IVectorView<
-        Windows::Networking::EndpointPair^>^ endpoints,
-      const asio::detail::addrinfo_type& hints,
-      const std::string& host_name, const std::string& service_name)
-  {
-    basic_resolver_results results;
-    if (endpoints->Size)
-    {
-      results.values_.reset(new values_type);
-      for (unsigned int i = 0; i < endpoints->Size; ++i)
-      {
-        auto pair = endpoints->GetAt(i);
-
-        if (hints.ai_family == ASIO_OS_DEF(AF_INET)
-            && pair->RemoteHostName->Type
-              != Windows::Networking::HostNameType::Ipv4)
-          continue;
-
-        if (hints.ai_family == ASIO_OS_DEF(AF_INET6)
-            && pair->RemoteHostName->Type
-              != Windows::Networking::HostNameType::Ipv6)
-          continue;
-
-        results.values_->push_back(
-            basic_resolver_entry<InternetProtocol>(
-              typename InternetProtocol::endpoint(
-                ip::make_address(
-                  asio::detail::winrt_utils::string(
-                    pair->RemoteHostName->CanonicalName)),
-                asio::detail::winrt_utils::integer(
-                  pair->RemoteServiceName)),
-              host_name, service_name));
-      }
-    }
-    return results;
-  }
-# endif // defined(ASIO_WINDOWS_RUNTIME)
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Get the number of entries in the results range.
-  size_type size() const noexcept
-  {
-    return this->values_ ? this->values_->size() : 0;
-  }
-
-  /// Get the maximum number of entries permitted in a results range.
-  size_type max_size() const noexcept
-  {
-    return this->values_ ? this->values_->max_size() : values_type().max_size();
-  }
-
-  /// Determine whether the results range is empty.
-  bool empty() const noexcept
-  {
-    return this->values_ ? this->values_->empty() : true;
-  }
-
-  /// Obtain a begin iterator for the results range.
-  const_iterator begin() const
-  {
-    basic_resolver_results tmp(*this);
-    tmp.index_ = 0;
-    return static_cast<basic_resolver_results&&>(tmp);
-  }
-
-  /// Obtain an end iterator for the results range.
-  const_iterator end() const
-  {
-    return const_iterator();
-  }
-
-  /// Obtain a begin iterator for the results range.
-  const_iterator cbegin() const
-  {
-    return begin();
-  }
-
-  /// Obtain an end iterator for the results range.
-  const_iterator cend() const
-  {
-    return end();
-  }
-
-  /// Swap the results range with another.
-  void swap(basic_resolver_results& that) noexcept
-  {
-    if (this != &that)
-    {
-      this->values_.swap(that.values_);
-      std::size_t index = this->index_;
-      this->index_ = that.index_;
-      that.index_ = index;
-    }
-  }
-
-  /// Test two iterators for equality.
-  friend bool operator==(const basic_resolver_results& a,
-      const basic_resolver_results& b)
-  {
-    return a.equal(b);
-  }
-
-  /// Test two iterators for inequality.
-  friend bool operator!=(const basic_resolver_results& a,
-      const basic_resolver_results& b)
-  {
-    return !a.equal(b);
-  }
-
-private:
-  typedef std::vector<basic_resolver_entry<InternetProtocol>> values_type;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_BASIC_RESOLVER_RESULTS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/endpoint.hpp
deleted file mode 100644
index 2c4e3cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/endpoint.hpp
+++ /dev/null
@@ -1,141 +0,0 @@
-//
-// ip/detail/endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_DETAIL_ENDPOINT_HPP
-#define ASIO_IP_DETAIL_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/winsock_init.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ip/address.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-namespace detail {
-
-// Helper class for implementating an IP endpoint.
-class endpoint
-{
-public:
-  // Default constructor.
-  ASIO_DECL endpoint() noexcept;
-
-  // Construct an endpoint using a family and port number.
-  ASIO_DECL endpoint(int family,
-      unsigned short port_num) noexcept;
-
-  // Construct an endpoint using an address and port number.
-  ASIO_DECL endpoint(const asio::ip::address& addr,
-      unsigned short port_num) noexcept;
-
-  // Copy constructor.
-  endpoint(const endpoint& other) noexcept
-    : data_(other.data_)
-  {
-  }
-
-  // Assign from another endpoint.
-  endpoint& operator=(const endpoint& other) noexcept
-  {
-    data_ = other.data_;
-    return *this;
-  }
-
-  // Get the underlying endpoint in the native type.
-  asio::detail::socket_addr_type* data() noexcept
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying endpoint in the native type.
-  const asio::detail::socket_addr_type* data() const noexcept
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying size of the endpoint in the native type.
-  std::size_t size() const noexcept
-  {
-    if (is_v4())
-      return sizeof(asio::detail::sockaddr_in4_type);
-    else
-      return sizeof(asio::detail::sockaddr_in6_type);
-  }
-
-  // Set the underlying size of the endpoint in the native type.
-  ASIO_DECL void resize(std::size_t new_size);
-
-  // Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const noexcept
-  {
-    return sizeof(data_);
-  }
-
-  // Get the port associated with the endpoint.
-  ASIO_DECL unsigned short port() const noexcept;
-
-  // Set the port associated with the endpoint.
-  ASIO_DECL void port(unsigned short port_num) noexcept;
-
-  // Get the IP address associated with the endpoint.
-  ASIO_DECL asio::ip::address address() const noexcept;
-
-  // Set the IP address associated with the endpoint.
-  ASIO_DECL void address(
-      const asio::ip::address& addr) noexcept;
-
-  // Compare two endpoints for equality.
-  ASIO_DECL friend bool operator==(const endpoint& e1,
-      const endpoint& e2) noexcept;
-
-  // Compare endpoints for ordering.
-  ASIO_DECL friend bool operator<(const endpoint& e1,
-      const endpoint& e2) noexcept;
-
-  // Determine whether the endpoint is IPv4.
-  bool is_v4() const noexcept
-  {
-    return data_.base.sa_family == ASIO_OS_DEF(AF_INET);
-  }
-
-#if !defined(ASIO_NO_IOSTREAM)
-  // Convert to a string.
-  ASIO_DECL std::string to_string() const;
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-private:
-  // The underlying IP socket address.
-  union data_union
-  {
-    asio::detail::socket_addr_type base;
-    asio::detail::sockaddr_in4_type v4;
-    asio::detail::sockaddr_in6_type v6;
-  } data_;
-};
-
-} // namespace detail
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/detail/impl/endpoint.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_DETAIL_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/impl/endpoint.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/impl/endpoint.ipp
deleted file mode 100644
index ef61208..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/impl/endpoint.ipp
+++ /dev/null
@@ -1,195 +0,0 @@
-//
-// ip/detail/impl/endpoint.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
-#define ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstring>
-#if !defined(ASIO_NO_IOSTREAM)
-# include <sstream>
-#endif // !defined(ASIO_NO_IOSTREAM)
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/ip/detail/endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-namespace detail {
-
-endpoint::endpoint() noexcept
-  : data_()
-{
-  data_.v4.sin_family = ASIO_OS_DEF(AF_INET);
-  data_.v4.sin_port = 0;
-  data_.v4.sin_addr.s_addr = ASIO_OS_DEF(INADDR_ANY);
-}
-
-endpoint::endpoint(int family, unsigned short port_num) noexcept
-  : data_()
-{
-  using namespace std; // For memcpy.
-  if (family == ASIO_OS_DEF(AF_INET))
-  {
-    data_.v4.sin_family = ASIO_OS_DEF(AF_INET);
-    data_.v4.sin_port =
-      asio::detail::socket_ops::host_to_network_short(port_num);
-    data_.v4.sin_addr.s_addr = ASIO_OS_DEF(INADDR_ANY);
-  }
-  else
-  {
-    data_.v6.sin6_family = ASIO_OS_DEF(AF_INET6);
-    data_.v6.sin6_port =
-      asio::detail::socket_ops::host_to_network_short(port_num);
-    data_.v6.sin6_flowinfo = 0;
-    data_.v6.sin6_addr.s6_addr[0] = 0; data_.v6.sin6_addr.s6_addr[1] = 0;
-    data_.v6.sin6_addr.s6_addr[2] = 0; data_.v6.sin6_addr.s6_addr[3] = 0;
-    data_.v6.sin6_addr.s6_addr[4] = 0; data_.v6.sin6_addr.s6_addr[5] = 0;
-    data_.v6.sin6_addr.s6_addr[6] = 0; data_.v6.sin6_addr.s6_addr[7] = 0;
-    data_.v6.sin6_addr.s6_addr[8] = 0; data_.v6.sin6_addr.s6_addr[9] = 0;
-    data_.v6.sin6_addr.s6_addr[10] = 0; data_.v6.sin6_addr.s6_addr[11] = 0;
-    data_.v6.sin6_addr.s6_addr[12] = 0; data_.v6.sin6_addr.s6_addr[13] = 0;
-    data_.v6.sin6_addr.s6_addr[14] = 0; data_.v6.sin6_addr.s6_addr[15] = 0;
-    data_.v6.sin6_scope_id = 0;
-  }
-}
-
-endpoint::endpoint(const asio::ip::address& addr,
-    unsigned short port_num) noexcept
-  : data_()
-{
-  using namespace std; // For memcpy.
-  if (addr.is_v4())
-  {
-    data_.v4.sin_family = ASIO_OS_DEF(AF_INET);
-    data_.v4.sin_port =
-      asio::detail::socket_ops::host_to_network_short(port_num);
-    data_.v4.sin_addr.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-        addr.to_v4().to_uint());
-  }
-  else
-  {
-    data_.v6.sin6_family = ASIO_OS_DEF(AF_INET6);
-    data_.v6.sin6_port =
-      asio::detail::socket_ops::host_to_network_short(port_num);
-    data_.v6.sin6_flowinfo = 0;
-    asio::ip::address_v6 v6_addr = addr.to_v6();
-    asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
-    memcpy(data_.v6.sin6_addr.s6_addr, bytes.data(), 16);
-    data_.v6.sin6_scope_id =
-      static_cast<asio::detail::u_long_type>(
-        v6_addr.scope_id());
-  }
-}
-
-void endpoint::resize(std::size_t new_size)
-{
-  if (new_size > sizeof(asio::detail::sockaddr_storage_type))
-  {
-    asio::error_code ec(asio::error::invalid_argument);
-    asio::detail::throw_error(ec);
-  }
-}
-
-unsigned short endpoint::port() const noexcept
-{
-  if (is_v4())
-  {
-    return asio::detail::socket_ops::network_to_host_short(
-        data_.v4.sin_port);
-  }
-  else
-  {
-    return asio::detail::socket_ops::network_to_host_short(
-        data_.v6.sin6_port);
-  }
-}
-
-void endpoint::port(unsigned short port_num) noexcept
-{
-  if (is_v4())
-  {
-    data_.v4.sin_port
-      = asio::detail::socket_ops::host_to_network_short(port_num);
-  }
-  else
-  {
-    data_.v6.sin6_port
-      = asio::detail::socket_ops::host_to_network_short(port_num);
-  }
-}
-
-asio::ip::address endpoint::address() const noexcept
-{
-  using namespace std; // For memcpy.
-  if (is_v4())
-  {
-    return asio::ip::address_v4(
-        asio::detail::socket_ops::network_to_host_long(
-          data_.v4.sin_addr.s_addr));
-  }
-  else
-  {
-    asio::ip::address_v6::bytes_type bytes;
-    memcpy(bytes.data(), data_.v6.sin6_addr.s6_addr, 16);
-    return asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
-  }
-}
-
-void endpoint::address(const asio::ip::address& addr) noexcept
-{
-  endpoint tmp_endpoint(addr, port());
-  data_ = tmp_endpoint.data_;
-}
-
-bool operator==(const endpoint& e1, const endpoint& e2) noexcept
-{
-  return e1.address() == e2.address() && e1.port() == e2.port();
-}
-
-bool operator<(const endpoint& e1, const endpoint& e2) noexcept
-{
-  if (e1.address() < e2.address())
-    return true;
-  if (e1.address() != e2.address())
-    return false;
-  return e1.port() < e2.port();
-}
-
-#if !defined(ASIO_NO_IOSTREAM)
-std::string endpoint::to_string() const
-{
-  std::ostringstream tmp_os;
-  tmp_os.imbue(std::locale::classic());
-  if (is_v4())
-    tmp_os << address();
-  else
-    tmp_os << '[' << address() << ']';
-  tmp_os << ':' << port();
-
-  return tmp_os.str();
-}
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace detail
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/socket_option.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/socket_option.hpp
deleted file mode 100644
index 2af564d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/detail/socket_option.hpp
+++ /dev/null
@@ -1,566 +0,0 @@
-//
-// detail/socket_option.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_DETAIL_SOCKET_OPTION_HPP
-#define ASIO_IP_DETAIL_SOCKET_OPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include <stdexcept>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/ip/address.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-namespace detail {
-namespace socket_option {
-
-// Helper template for implementing multicast enable loopback options.
-template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
-class multicast_enable_loopback
-{
-public:
-#if defined(__sun) || defined(__osf__)
-  typedef unsigned char ipv4_value_type;
-  typedef unsigned char ipv6_value_type;
-#elif defined(_AIX) || defined(__hpux) || defined(__QNXNTO__)
-  typedef unsigned char ipv4_value_type;
-  typedef unsigned int ipv6_value_type;
-#else
-  typedef int ipv4_value_type;
-  typedef int ipv6_value_type;
-#endif
-
-  // Default constructor.
-  multicast_enable_loopback()
-    : ipv4_value_(0),
-      ipv6_value_(0)
-  {
-  }
-
-  // Construct with a specific option value.
-  explicit multicast_enable_loopback(bool v)
-    : ipv4_value_(v ? 1 : 0),
-      ipv6_value_(v ? 1 : 0)
-  {
-  }
-
-  // Set the value of the boolean.
-  multicast_enable_loopback& operator=(bool v)
-  {
-    ipv4_value_ = v ? 1 : 0;
-    ipv6_value_ = v ? 1 : 0;
-    return *this;
-  }
-
-  // Get the current value of the boolean.
-  bool value() const
-  {
-    return !!ipv4_value_;
-  }
-
-  // Convert to bool.
-  operator bool() const
-  {
-    return !!ipv4_value_;
-  }
-
-  // Test for false.
-  bool operator!() const
-  {
-    return !ipv4_value_;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Level;
-    return IPv4_Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Name;
-    return IPv4_Name;
-  }
-
-  // Get the address of the boolean data.
-  template <typename Protocol>
-  void* data(const Protocol& protocol)
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the address of the boolean data.
-  template <typename Protocol>
-  const void* data(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the size of the boolean data.
-  template <typename Protocol>
-  std::size_t size(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return sizeof(ipv6_value_);
-    return sizeof(ipv4_value_);
-  }
-
-  // Set the size of the boolean data.
-  template <typename Protocol>
-  void resize(const Protocol& protocol, std::size_t s)
-  {
-    if (protocol.family() == PF_INET6)
-    {
-      if (s != sizeof(ipv6_value_))
-      {
-        std::length_error ex("multicast_enable_loopback socket option resize");
-        asio::detail::throw_exception(ex);
-      }
-      ipv4_value_ = ipv6_value_ ? 1 : 0;
-    }
-    else
-    {
-      if (s != sizeof(ipv4_value_))
-      {
-        std::length_error ex("multicast_enable_loopback socket option resize");
-        asio::detail::throw_exception(ex);
-      }
-      ipv6_value_ = ipv4_value_ ? 1 : 0;
-    }
-  }
-
-private:
-  ipv4_value_type ipv4_value_;
-  ipv6_value_type ipv6_value_;
-};
-
-// Helper template for implementing unicast hops options.
-template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
-class unicast_hops
-{
-public:
-  // Default constructor.
-  unicast_hops()
-    : value_(0)
-  {
-  }
-
-  // Construct with a specific option value.
-  explicit unicast_hops(int v)
-    : value_(v)
-  {
-  }
-
-  // Set the value of the option.
-  unicast_hops& operator=(int v)
-  {
-    value_ = v;
-    return *this;
-  }
-
-  // Get the current value of the option.
-  int value() const
-  {
-    return value_;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Level;
-    return IPv4_Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Name;
-    return IPv4_Name;
-  }
-
-  // Get the address of the data.
-  template <typename Protocol>
-  int* data(const Protocol&)
-  {
-    return &value_;
-  }
-
-  // Get the address of the data.
-  template <typename Protocol>
-  const int* data(const Protocol&) const
-  {
-    return &value_;
-  }
-
-  // Get the size of the data.
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return sizeof(value_);
-  }
-
-  // Set the size of the data.
-  template <typename Protocol>
-  void resize(const Protocol&, std::size_t s)
-  {
-    if (s != sizeof(value_))
-    {
-      std::length_error ex("unicast hops socket option resize");
-      asio::detail::throw_exception(ex);
-    }
-#if defined(__hpux)
-    if (value_ < 0)
-      value_ = value_ & 0xFF;
-#endif
-  }
-
-private:
-  int value_;
-};
-
-// Helper template for implementing multicast hops options.
-template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
-class multicast_hops
-{
-public:
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  typedef int ipv4_value_type;
-#else
-  typedef unsigned char ipv4_value_type;
-#endif
-  typedef int ipv6_value_type;
-
-  // Default constructor.
-  multicast_hops()
-    : ipv4_value_(0),
-      ipv6_value_(0)
-  {
-  }
-
-  // Construct with a specific option value.
-  explicit multicast_hops(int v)
-  {
-    if (v < 0 || v > 255)
-    {
-      std::out_of_range ex("multicast hops value out of range");
-      asio::detail::throw_exception(ex);
-    }
-    ipv4_value_ = (ipv4_value_type)v;
-    ipv6_value_ = v;
-  }
-
-  // Set the value of the option.
-  multicast_hops& operator=(int v)
-  {
-    if (v < 0 || v > 255)
-    {
-      std::out_of_range ex("multicast hops value out of range");
-      asio::detail::throw_exception(ex);
-    }
-    ipv4_value_ = (ipv4_value_type)v;
-    ipv6_value_ = v;
-    return *this;
-  }
-
-  // Get the current value of the option.
-  int value() const
-  {
-    return ipv6_value_;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Level;
-    return IPv4_Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Name;
-    return IPv4_Name;
-  }
-
-  // Get the address of the data.
-  template <typename Protocol>
-  void* data(const Protocol& protocol)
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the address of the data.
-  template <typename Protocol>
-  const void* data(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the size of the data.
-  template <typename Protocol>
-  std::size_t size(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return sizeof(ipv6_value_);
-    return sizeof(ipv4_value_);
-  }
-
-  // Set the size of the data.
-  template <typename Protocol>
-  void resize(const Protocol& protocol, std::size_t s)
-  {
-    if (protocol.family() == PF_INET6)
-    {
-      if (s != sizeof(ipv6_value_))
-      {
-        std::length_error ex("multicast hops socket option resize");
-        asio::detail::throw_exception(ex);
-      }
-      if (ipv6_value_ < 0)
-        ipv4_value_ = 0;
-      else if (ipv6_value_ > 255)
-        ipv4_value_ = 255;
-      else
-        ipv4_value_ = (ipv4_value_type)ipv6_value_;
-    }
-    else
-    {
-      if (s != sizeof(ipv4_value_))
-      {
-        std::length_error ex("multicast hops socket option resize");
-        asio::detail::throw_exception(ex);
-      }
-      ipv6_value_ = ipv4_value_;
-    }
-  }
-
-private:
-  ipv4_value_type ipv4_value_;
-  ipv6_value_type ipv6_value_;
-};
-
-// Helper template for implementing ip_mreq-based options.
-template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
-class multicast_request
-{
-public:
-  // Default constructor.
-  multicast_request()
-    : ipv4_value_(), // Zero-initialisation gives the "any" address.
-      ipv6_value_() // Zero-initialisation gives the "any" address.
-  {
-  }
-
-  // Construct with multicast address only.
-  explicit multicast_request(const address& multicast_address)
-    : ipv4_value_(), // Zero-initialisation gives the "any" address.
-      ipv6_value_() // Zero-initialisation gives the "any" address.
-  {
-    if (multicast_address.is_v6())
-    {
-      using namespace std; // For memcpy.
-      address_v6 ipv6_address = multicast_address.to_v6();
-      address_v6::bytes_type bytes = ipv6_address.to_bytes();
-      memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
-      ipv6_value_.ipv6mr_interface = ipv6_address.scope_id();
-    }
-    else
-    {
-      ipv4_value_.imr_multiaddr.s_addr =
-        asio::detail::socket_ops::host_to_network_long(
-            multicast_address.to_v4().to_uint());
-      ipv4_value_.imr_interface.s_addr =
-        asio::detail::socket_ops::host_to_network_long(
-            address_v4::any().to_uint());
-    }
-  }
-
-  // Construct with multicast address and IPv4 address specifying an interface.
-  explicit multicast_request(const address_v4& multicast_address,
-      const address_v4& network_interface = address_v4::any())
-    : ipv6_value_() // Zero-initialisation gives the "any" address.
-  {
-    ipv4_value_.imr_multiaddr.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-          multicast_address.to_uint());
-    ipv4_value_.imr_interface.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-          network_interface.to_uint());
-  }
-
-  // Construct with multicast address and IPv6 network interface index.
-  explicit multicast_request(
-      const address_v6& multicast_address,
-      unsigned long network_interface = 0)
-    : ipv4_value_() // Zero-initialisation gives the "any" address.
-  {
-    using namespace std; // For memcpy.
-    address_v6::bytes_type bytes = multicast_address.to_bytes();
-    memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
-    if (network_interface)
-      ipv6_value_.ipv6mr_interface = network_interface;
-    else
-      ipv6_value_.ipv6mr_interface = multicast_address.scope_id();
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Level;
-    return IPv4_Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Name;
-    return IPv4_Name;
-  }
-
-  // Get the address of the option data.
-  template <typename Protocol>
-  const void* data(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the size of the option data.
-  template <typename Protocol>
-  std::size_t size(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return sizeof(ipv6_value_);
-    return sizeof(ipv4_value_);
-  }
-
-private:
-  asio::detail::in4_mreq_type ipv4_value_;
-  asio::detail::in6_mreq_type ipv6_value_;
-};
-
-// Helper template for implementing options that specify a network interface.
-template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
-class network_interface
-{
-public:
-  // Default constructor.
-  network_interface()
-  {
-    ipv4_value_.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-          address_v4::any().to_uint());
-    ipv6_value_ = 0;
-  }
-
-  // Construct with IPv4 interface.
-  explicit network_interface(const address_v4& ipv4_interface)
-  {
-    ipv4_value_.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-          ipv4_interface.to_uint());
-    ipv6_value_ = 0;
-  }
-
-  // Construct with IPv6 interface.
-  explicit network_interface(unsigned int ipv6_interface)
-  {
-    ipv4_value_.s_addr =
-      asio::detail::socket_ops::host_to_network_long(
-          address_v4::any().to_uint());
-    ipv6_value_ = ipv6_interface;
-  }
-
-  // Get the level of the socket option.
-  template <typename Protocol>
-  int level(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Level;
-    return IPv4_Level;
-  }
-
-  // Get the name of the socket option.
-  template <typename Protocol>
-  int name(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return IPv6_Name;
-    return IPv4_Name;
-  }
-
-  // Get the address of the option data.
-  template <typename Protocol>
-  const void* data(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return &ipv6_value_;
-    return &ipv4_value_;
-  }
-
-  // Get the size of the option data.
-  template <typename Protocol>
-  std::size_t size(const Protocol& protocol) const
-  {
-    if (protocol.family() == PF_INET6)
-      return sizeof(ipv6_value_);
-    return sizeof(ipv4_value_);
-  }
-
-private:
-  asio::detail::in4_addr_type ipv4_value_;
-  unsigned int ipv6_value_;
-};
-
-} // namespace socket_option
-} // namespace detail
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_DETAIL_SOCKET_OPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/host_name.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/host_name.hpp
deleted file mode 100644
index f9cb185..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/host_name.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// ip/host_name.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_HOST_NAME_HPP
-#define ASIO_IP_HOST_NAME_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Get the current host name.
-ASIO_DECL std::string host_name();
-
-/// Get the current host name.
-ASIO_DECL std::string host_name(asio::error_code& ec);
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/host_name.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_HOST_NAME_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/icmp.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/icmp.hpp
deleted file mode 100644
index 9e4e8e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/icmp.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//
-// ip/icmp.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_ICMP_HPP
-#define ASIO_IP_ICMP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/basic_raw_socket.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Encapsulates the flags needed for ICMP.
-/**
- * The asio::ip::icmp class contains flags necessary for ICMP sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol, InternetProtocol.
- */
-class icmp
-{
-public:
-  /// The type of a ICMP endpoint.
-  typedef basic_endpoint<icmp> endpoint;
-
-  /// Construct to represent the IPv4 ICMP protocol.
-  static icmp v4() noexcept
-  {
-    return icmp(ASIO_OS_DEF(IPPROTO_ICMP),
-        ASIO_OS_DEF(AF_INET));
-  }
-
-  /// Construct to represent the IPv6 ICMP protocol.
-  static icmp v6() noexcept
-  {
-    return icmp(ASIO_OS_DEF(IPPROTO_ICMPV6),
-        ASIO_OS_DEF(AF_INET6));
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_RAW);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return protocol_;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// The ICMP socket type.
-  typedef basic_raw_socket<icmp> socket;
-
-  /// The ICMP resolver type.
-  typedef basic_resolver<icmp> resolver;
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const icmp& p1, const icmp& p2)
-  {
-    return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const icmp& p1, const icmp& p2)
-  {
-    return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
-  }
-
-private:
-  // Construct with a specific family.
-  explicit icmp(int protocol_id, int protocol_family) noexcept
-    : protocol_(protocol_id),
-      family_(protocol_family)
-  {
-  }
-
-  int protocol_;
-  int family_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_ICMP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.hpp
deleted file mode 100644
index 5780f32..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ip/impl/address.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_HPP
-#define ASIO_IP_IMPL_ADDRESS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-inline address address::from_string(const char* str)
-{
-  return asio::ip::make_address(str);
-}
-
-inline address address::from_string(
-    const char* str, asio::error_code& ec)
-{
-  return asio::ip::make_address(str, ec);
-}
-
-inline address address::from_string(const std::string& str)
-{
-  return asio::ip::make_address(str);
-}
-
-inline address address::from_string(
-    const std::string& str, asio::error_code& ec)
-{
-  return asio::ip::make_address(str, ec);
-}
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address& addr)
-{
-  return os << addr.to_string().c_str();
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_ADDRESS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.ipp
deleted file mode 100644
index 9893b4c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address.ipp
+++ /dev/null
@@ -1,235 +0,0 @@
-//
-// ip/impl/address.ipp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_IPP
-#define ASIO_IP_IMPL_ADDRESS_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <typeinfo>
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/error.hpp"
-#include "asio/ip/address.hpp"
-#include "asio/ip/bad_address_cast.hpp"
-#include "asio/system_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-address::address() noexcept
-  : type_(ipv4),
-    ipv4_address_(),
-    ipv6_address_()
-{
-}
-
-address::address(
-    const asio::ip::address_v4& ipv4_address) noexcept
-  : type_(ipv4),
-    ipv4_address_(ipv4_address),
-    ipv6_address_()
-{
-}
-
-address::address(
-    const asio::ip::address_v6& ipv6_address) noexcept
-  : type_(ipv6),
-    ipv4_address_(),
-    ipv6_address_(ipv6_address)
-{
-}
-
-address::address(const address& other) noexcept
-  : type_(other.type_),
-    ipv4_address_(other.ipv4_address_),
-    ipv6_address_(other.ipv6_address_)
-{
-}
-
-address::address(address&& other) noexcept
-  : type_(other.type_),
-    ipv4_address_(other.ipv4_address_),
-    ipv6_address_(other.ipv6_address_)
-{
-}
-
-address& address::operator=(const address& other) noexcept
-{
-  type_ = other.type_;
-  ipv4_address_ = other.ipv4_address_;
-  ipv6_address_ = other.ipv6_address_;
-  return *this;
-}
-
-address& address::operator=(address&& other) noexcept
-{
-  type_ = other.type_;
-  ipv4_address_ = other.ipv4_address_;
-  ipv6_address_ = other.ipv6_address_;
-  return *this;
-}
-
-address& address::operator=(
-    const asio::ip::address_v4& ipv4_address) noexcept
-{
-  type_ = ipv4;
-  ipv4_address_ = ipv4_address;
-  ipv6_address_ = asio::ip::address_v6();
-  return *this;
-}
-
-address& address::operator=(
-    const asio::ip::address_v6& ipv6_address) noexcept
-{
-  type_ = ipv6;
-  ipv4_address_ = asio::ip::address_v4();
-  ipv6_address_ = ipv6_address;
-  return *this;
-}
-
-address make_address(const char* str)
-{
-  asio::error_code ec;
-  address addr = make_address(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address make_address(const char* str,
-    asio::error_code& ec) noexcept
-{
-  asio::ip::address_v6 ipv6_address =
-    asio::ip::make_address_v6(str, ec);
-  if (!ec)
-    return address(ipv6_address);
-
-  asio::ip::address_v4 ipv4_address =
-    asio::ip::make_address_v4(str, ec);
-  if (!ec)
-    return address(ipv4_address);
-
-  return address();
-}
-
-address make_address(const std::string& str)
-{
-  return make_address(str.c_str());
-}
-
-address make_address(const std::string& str,
-    asio::error_code& ec) noexcept
-{
-  return make_address(str.c_str(), ec);
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-address make_address(string_view str)
-{
-  return make_address(static_cast<std::string>(str));
-}
-
-address make_address(string_view str,
-    asio::error_code& ec) noexcept
-{
-  return make_address(static_cast<std::string>(str), ec);
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-asio::ip::address_v4 address::to_v4() const
-{
-  if (type_ != ipv4)
-  {
-    bad_address_cast ex;
-    asio::detail::throw_exception(ex);
-  }
-  return ipv4_address_;
-}
-
-asio::ip::address_v6 address::to_v6() const
-{
-  if (type_ != ipv6)
-  {
-    bad_address_cast ex;
-    asio::detail::throw_exception(ex);
-  }
-  return ipv6_address_;
-}
-
-std::string address::to_string() const
-{
-  if (type_ == ipv6)
-    return ipv6_address_.to_string();
-  return ipv4_address_.to_string();
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-std::string address::to_string(asio::error_code& ec) const
-{
-  if (type_ == ipv6)
-    return ipv6_address_.to_string(ec);
-  return ipv4_address_.to_string(ec);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-bool address::is_loopback() const noexcept
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_loopback()
-    : ipv6_address_.is_loopback();
-}
-
-bool address::is_unspecified() const noexcept
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_unspecified()
-    : ipv6_address_.is_unspecified();
-}
-
-bool address::is_multicast() const noexcept
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_multicast()
-    : ipv6_address_.is_multicast();
-}
-
-bool operator==(const address& a1, const address& a2) noexcept
-{
-  if (a1.type_ != a2.type_)
-    return false;
-  if (a1.type_ == address::ipv6)
-    return a1.ipv6_address_ == a2.ipv6_address_;
-  return a1.ipv4_address_ == a2.ipv4_address_;
-}
-
-bool operator<(const address& a1, const address& a2) noexcept
-{
-  if (a1.type_ < a2.type_)
-    return true;
-  if (a1.type_ > a2.type_)
-    return false;
-  if (a1.type_ == address::ipv6)
-    return a1.ipv6_address_ < a2.ipv6_address_;
-  return a1.ipv4_address_ < a2.ipv4_address_;
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_ADDRESS_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.hpp
deleted file mode 100644
index 5e29a24..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ip/impl/address_v4.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_V4_HPP
-#define ASIO_IP_IMPL_ADDRESS_V4_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-inline address_v4 address_v4::from_string(const char* str)
-{
-  return asio::ip::make_address_v4(str);
-}
-
-inline address_v4 address_v4::from_string(
-    const char* str, asio::error_code& ec)
-{
-  return asio::ip::make_address_v4(str, ec);
-}
-
-inline address_v4 address_v4::from_string(const std::string& str)
-{
-  return asio::ip::make_address_v4(str);
-}
-
-inline address_v4 address_v4::from_string(
-    const std::string& str, asio::error_code& ec)
-{
-  return asio::ip::make_address_v4(str, ec);
-}
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
-{
-  return os << addr.to_string().c_str();
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_ADDRESS_V4_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.ipp
deleted file mode 100644
index d780327..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v4.ipp
+++ /dev/null
@@ -1,206 +0,0 @@
-//
-// ip/impl/address_v4.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_V4_IPP
-#define ASIO_IP_IMPL_ADDRESS_V4_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <climits>
-#include <limits>
-#include <stdexcept>
-#include "asio/error.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/ip/address_v4.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-address_v4::address_v4(const address_v4::bytes_type& bytes)
-{
-#if UCHAR_MAX > 0xFF
-  if (bytes[0] > 0xFF || bytes[1] > 0xFF
-      || bytes[2] > 0xFF || bytes[3] > 0xFF)
-  {
-    std::out_of_range ex("address_v4 from bytes_type");
-    asio::detail::throw_exception(ex);
-  }
-#endif // UCHAR_MAX > 0xFF
-
-  using namespace std; // For memcpy.
-  memcpy(&addr_.s_addr, bytes.data(), 4);
-}
-
-address_v4::address_v4(address_v4::uint_type addr)
-{
-  if ((std::numeric_limits<uint_type>::max)() > 0xFFFFFFFF)
-  {
-    std::out_of_range ex("address_v4 from unsigned integer");
-    asio::detail::throw_exception(ex);
-  }
-
-  addr_.s_addr = asio::detail::socket_ops::host_to_network_long(
-      static_cast<asio::detail::u_long_type>(addr));
-}
-
-address_v4::bytes_type address_v4::to_bytes() const noexcept
-{
-  using namespace std; // For memcpy.
-  bytes_type bytes;
-  memcpy(bytes.data(), &addr_.s_addr, 4);
-  return bytes;
-}
-
-address_v4::uint_type address_v4::to_uint() const noexcept
-{
-  return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-unsigned long address_v4::to_ulong() const
-{
-  return asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-std::string address_v4::to_string() const
-{
-  asio::error_code ec;
-  char addr_str[asio::detail::max_addr_v4_str_len];
-  const char* addr =
-    asio::detail::socket_ops::inet_ntop(
-        ASIO_OS_DEF(AF_INET), &addr_, addr_str,
-        asio::detail::max_addr_v4_str_len, 0, ec);
-  if (addr == 0)
-    asio::detail::throw_error(ec);
-  return addr;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-std::string address_v4::to_string(asio::error_code& ec) const
-{
-  char addr_str[asio::detail::max_addr_v4_str_len];
-  const char* addr =
-    asio::detail::socket_ops::inet_ntop(
-        ASIO_OS_DEF(AF_INET), &addr_, addr_str,
-        asio::detail::max_addr_v4_str_len, 0, ec);
-  if (addr == 0)
-    return std::string();
-  return addr;
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-bool address_v4::is_loopback() const noexcept
-{
-  return (to_uint() & 0xFF000000) == 0x7F000000;
-}
-
-bool address_v4::is_unspecified() const noexcept
-{
-  return to_uint() == 0;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-bool address_v4::is_class_a() const
-{
-  return (to_uint() & 0x80000000) == 0;
-}
-
-bool address_v4::is_class_b() const
-{
-  return (to_uint() & 0xC0000000) == 0x80000000;
-}
-
-bool address_v4::is_class_c() const
-{
-  return (to_uint() & 0xE0000000) == 0xC0000000;
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-bool address_v4::is_multicast() const noexcept
-{
-  return (to_uint() & 0xF0000000) == 0xE0000000;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
-{
-  return address_v4(addr.to_uint() | (mask.to_uint() ^ 0xFFFFFFFF));
-}
-
-address_v4 address_v4::netmask(const address_v4& addr)
-{
-  if (addr.is_class_a())
-    return address_v4(0xFF000000);
-  if (addr.is_class_b())
-    return address_v4(0xFFFF0000);
-  if (addr.is_class_c())
-    return address_v4(0xFFFFFF00);
-  return address_v4(0xFFFFFFFF);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-address_v4 make_address_v4(const char* str)
-{
-  asio::error_code ec;
-  address_v4 addr = make_address_v4(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address_v4 make_address_v4(const char* str,
-    asio::error_code& ec) noexcept
-{
-  address_v4::bytes_type bytes;
-  if (asio::detail::socket_ops::inet_pton(
-        ASIO_OS_DEF(AF_INET), str, &bytes, 0, ec) <= 0)
-    return address_v4();
-  return address_v4(bytes);
-}
-
-address_v4 make_address_v4(const std::string& str)
-{
-  return make_address_v4(str.c_str());
-}
-
-address_v4 make_address_v4(const std::string& str,
-    asio::error_code& ec) noexcept
-{
-  return make_address_v4(str.c_str(), ec);
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-address_v4 make_address_v4(string_view str)
-{
-  return make_address_v4(static_cast<std::string>(str));
-}
-
-address_v4 make_address_v4(string_view str,
-    asio::error_code& ec) noexcept
-{
-  return make_address_v4(static_cast<std::string>(str), ec);
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_ADDRESS_V4_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.hpp
deleted file mode 100644
index b4b53ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ip/impl/address_v6.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_V6_HPP
-#define ASIO_IP_IMPL_ADDRESS_V6_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-inline address_v6 address_v6::from_string(const char* str)
-{
-  return asio::ip::make_address_v6(str);
-}
-
-inline address_v6 address_v6::from_string(
-    const char* str, asio::error_code& ec)
-{
-  return asio::ip::make_address_v6(str, ec);
-}
-
-inline address_v6 address_v6::from_string(const std::string& str)
-{
-  return asio::ip::make_address_v6(str);
-}
-
-inline address_v6 address_v6::from_string(
-    const std::string& str, asio::error_code& ec)
-{
-  return asio::ip::make_address_v6(str, ec);
-}
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
-{
-  return os << addr.to_string().c_str();
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_ADDRESS_V6_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.ipp
deleted file mode 100644
index 8d5b7d1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/address_v6.ipp
+++ /dev/null
@@ -1,342 +0,0 @@
-//
-// ip/impl/address_v6.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_ADDRESS_V6_IPP
-#define ASIO_IP_IMPL_ADDRESS_V6_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstring>
-#include <stdexcept>
-#include <typeinfo>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/error.hpp"
-#include "asio/ip/address_v6.hpp"
-#include "asio/ip/bad_address_cast.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-address_v6::address_v6() noexcept
-  : addr_(),
-    scope_id_(0)
-{
-}
-
-address_v6::address_v6(const address_v6::bytes_type& bytes,
-    scope_id_type scope)
-  : scope_id_(scope)
-{
-#if UCHAR_MAX > 0xFF
-  for (std::size_t i = 0; i < bytes.size(); ++i)
-  {
-    if (bytes[i] > 0xFF)
-    {
-      std::out_of_range ex("address_v6 from bytes_type");
-      asio::detail::throw_exception(ex);
-    }
-  }
-#endif // UCHAR_MAX > 0xFF
-
-  using namespace std; // For memcpy.
-  memcpy(addr_.s6_addr, bytes.data(), 16);
-}
-
-address_v6::address_v6(const address_v6& other) noexcept
-  : addr_(other.addr_),
-    scope_id_(other.scope_id_)
-{
-}
-
-address_v6::address_v6(address_v6&& other) noexcept
-  : addr_(other.addr_),
-    scope_id_(other.scope_id_)
-{
-}
-
-address_v6& address_v6::operator=(const address_v6& other) noexcept
-{
-  addr_ = other.addr_;
-  scope_id_ = other.scope_id_;
-  return *this;
-}
-
-address_v6& address_v6::operator=(address_v6&& other) noexcept
-{
-  addr_ = other.addr_;
-  scope_id_ = other.scope_id_;
-  return *this;
-}
-
-address_v6::bytes_type address_v6::to_bytes() const noexcept
-{
-  using namespace std; // For memcpy.
-  bytes_type bytes;
-  memcpy(bytes.data(), addr_.s6_addr, 16);
-  return bytes;
-}
-
-std::string address_v6::to_string() const
-{
-  asio::error_code ec;
-  char addr_str[asio::detail::max_addr_v6_str_len];
-  const char* addr =
-    asio::detail::socket_ops::inet_ntop(
-        ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
-        asio::detail::max_addr_v6_str_len, scope_id_, ec);
-  if (addr == 0)
-    asio::detail::throw_error(ec);
-  return addr;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-std::string address_v6::to_string(asio::error_code& ec) const
-{
-  char addr_str[asio::detail::max_addr_v6_str_len];
-  const char* addr =
-    asio::detail::socket_ops::inet_ntop(
-        ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
-        asio::detail::max_addr_v6_str_len, scope_id_, ec);
-  if (addr == 0)
-    return std::string();
-  return addr;
-}
-
-address_v4 address_v6::to_v4() const
-{
-  if (!is_v4_mapped() && !is_v4_compatible())
-  {
-    bad_address_cast ex;
-    asio::detail::throw_exception(ex);
-  }
-
-  address_v4::bytes_type v4_bytes = { { addr_.s6_addr[12],
-    addr_.s6_addr[13], addr_.s6_addr[14], addr_.s6_addr[15] } };
-  return address_v4(v4_bytes);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-bool address_v6::is_loopback() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
-      && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
-      && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 1));
-}
-
-bool address_v6::is_unspecified() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
-      && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
-      && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 0));
-}
-
-bool address_v6::is_link_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0x80));
-}
-
-bool address_v6::is_site_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0xc0));
-}
-
-bool address_v6::is_v4_mapped() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0xff) && (addr_.s6_addr[11] == 0xff));
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-bool address_v6::is_v4_compatible() const
-{
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
-      && !((addr_.s6_addr[12] == 0)
-        && (addr_.s6_addr[13] == 0)
-        && (addr_.s6_addr[14] == 0)
-        && ((addr_.s6_addr[15] == 0) || (addr_.s6_addr[15] == 1))));
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-bool address_v6::is_multicast() const noexcept
-{
-  return (addr_.s6_addr[0] == 0xff);
-}
-
-bool address_v6::is_multicast_global() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x0e));
-}
-
-bool address_v6::is_multicast_link_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x02));
-}
-
-bool address_v6::is_multicast_node_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x01));
-}
-
-bool address_v6::is_multicast_org_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x08));
-}
-
-bool address_v6::is_multicast_site_local() const noexcept
-{
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x05));
-}
-
-bool operator==(const address_v6& a1, const address_v6& a2) noexcept
-{
-  using namespace std; // For memcmp.
-  return memcmp(&a1.addr_, &a2.addr_,
-      sizeof(asio::detail::in6_addr_type)) == 0
-    && a1.scope_id_ == a2.scope_id_;
-}
-
-bool operator<(const address_v6& a1, const address_v6& a2) noexcept
-{
-  using namespace std; // For memcmp.
-  int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
-      sizeof(asio::detail::in6_addr_type));
-  if (memcmp_result < 0)
-    return true;
-  if (memcmp_result > 0)
-    return false;
-  return a1.scope_id_ < a2.scope_id_;
-}
-
-address_v6 address_v6::loopback() noexcept
-{
-  address_v6 tmp;
-  tmp.addr_.s6_addr[15] = 1;
-  return tmp;
-}
-
-#if !defined(ASIO_NO_DEPRECATED)
-address_v6 address_v6::v4_mapped(const address_v4& addr)
-{
-  address_v4::bytes_type v4_bytes = addr.to_bytes();
-  bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
-    v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
-  return address_v6(v6_bytes);
-}
-
-address_v6 address_v6::v4_compatible(const address_v4& addr)
-{
-  address_v4::bytes_type v4_bytes = addr.to_bytes();
-  bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
-  return address_v6(v6_bytes);
-}
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-address_v6 make_address_v6(const char* str)
-{
-  asio::error_code ec;
-  address_v6 addr = make_address_v6(str, ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-address_v6 make_address_v6(const char* str,
-    asio::error_code& ec) noexcept
-{
-  address_v6::bytes_type bytes;
-  unsigned long scope_id = 0;
-  if (asio::detail::socket_ops::inet_pton(
-        ASIO_OS_DEF(AF_INET6), str, &bytes[0], &scope_id, ec) <= 0)
-    return address_v6();
-  return address_v6(bytes, scope_id);
-}
-
-address_v6 make_address_v6(const std::string& str)
-{
-  return make_address_v6(str.c_str());
-}
-
-address_v6 make_address_v6(const std::string& str,
-    asio::error_code& ec) noexcept
-{
-  return make_address_v6(str.c_str(), ec);
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-address_v6 make_address_v6(string_view str)
-{
-  return make_address_v6(static_cast<std::string>(str));
-}
-
-address_v6 make_address_v6(string_view str,
-    asio::error_code& ec) noexcept
-{
-  return make_address_v6(static_cast<std::string>(str), ec);
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-address_v4 make_address_v4(
-    v4_mapped_t, const address_v6& v6_addr)
-{
-  if (!v6_addr.is_v4_mapped())
-  {
-    bad_address_cast ex;
-    asio::detail::throw_exception(ex);
-  }
-
-  address_v6::bytes_type v6_bytes = v6_addr.to_bytes();
-  address_v4::bytes_type v4_bytes = { { v6_bytes[12],
-    v6_bytes[13], v6_bytes[14], v6_bytes[15] } };
-  return address_v4(v4_bytes);
-}
-
-address_v6 make_address_v6(
-    v4_mapped_t, const address_v4& v4_addr)
-{
-  address_v4::bytes_type v4_bytes = v4_addr.to_bytes();
-  address_v6::bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0xFF, 0xFF, v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
-  return address_v6(v6_bytes);
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_ADDRESS_V6_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/basic_endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/basic_endpoint.hpp
deleted file mode 100644
index 2da96c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/basic_endpoint.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// ip/impl/basic_endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
-#define ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename Elem, typename Traits, typename InternetProtocol>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os,
-    const basic_endpoint<InternetProtocol>& endpoint)
-{
-  asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
-  return os << tmp_ep.to_string().c_str();
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/host_name.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/host_name.ipp
deleted file mode 100644
index eb27829..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/host_name.ipp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// ip/impl/host_name.ipp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_HOST_NAME_IPP
-#define ASIO_IP_IMPL_HOST_NAME_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/winsock_init.hpp"
-#include "asio/ip/host_name.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-std::string host_name()
-{
-  char name[1024];
-  asio::error_code ec;
-  if (asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
-  {
-    asio::detail::throw_error(ec);
-    return std::string();
-  }
-  return std::string(name);
-}
-
-std::string host_name(asio::error_code& ec)
-{
-  char name[1024];
-  if (asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
-    return std::string();
-  return std::string(name);
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_HOST_NAME_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.hpp
deleted file mode 100644
index 2199c7d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// ip/impl/network_v4.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_NETWORK_V4_HPP
-#define ASIO_IP_IMPL_NETWORK_V4_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const network_v4& addr)
-{
-  asio::error_code ec;
-  std::string s = addr.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_NETWORK_V4_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.ipp
deleted file mode 100644
index e7e68ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v4.ipp
+++ /dev/null
@@ -1,218 +0,0 @@
-//
-// ip/impl/network_v4.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_NETWORK_V4_IPP
-#define ASIO_IP_IMPL_NETWORK_V4_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <climits>
-#include <cstdio>
-#include <cstdlib>
-#include <stdexcept>
-#include "asio/error.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/ip/network_v4.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-network_v4::network_v4(const address_v4& addr, unsigned short prefix_len)
-  : address_(addr),
-    prefix_length_(prefix_len)
-{
-  if (prefix_len > 32)
-  {
-    std::out_of_range ex("prefix length too large");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-network_v4::network_v4(const address_v4& addr, const address_v4& mask)
-  : address_(addr),
-    prefix_length_(0)
-{
-  address_v4::bytes_type mask_bytes = mask.to_bytes();
-  bool finished = false;
-  for (std::size_t i = 0; i < mask_bytes.size(); ++i)
-  {
-    if (finished)
-    {
-      if (mask_bytes[i])
-      {
-        std::invalid_argument ex("non-contiguous netmask");
-        asio::detail::throw_exception(ex);
-      }
-      continue;
-    }
-    else
-    {
-      switch (mask_bytes[i])
-      {
-      case 255:
-        prefix_length_ += 8;
-        break;
-      case 254: // prefix_length_ += 7
-        prefix_length_ += 1;
-      case 252: // prefix_length_ += 6
-        prefix_length_ += 1;
-      case 248: // prefix_length_ += 5
-        prefix_length_ += 1;
-      case 240: // prefix_length_ += 4
-        prefix_length_ += 1;
-      case 224: // prefix_length_ += 3
-        prefix_length_ += 1;
-      case 192: // prefix_length_ += 2
-        prefix_length_ += 1;
-      case 128: // prefix_length_ += 1
-        prefix_length_ += 1;
-      case 0:   // nbits += 0
-        finished = true;
-        break;
-      default:
-        std::out_of_range ex("non-contiguous netmask");
-        asio::detail::throw_exception(ex);
-      }
-    }
-  }
-}
-
-address_v4 network_v4::netmask() const noexcept
-{
-  uint32_t nmbits = 0xffffffff;
-  if (prefix_length_ == 0)
-    nmbits = 0;
-  else
-    nmbits = nmbits << (32 - prefix_length_);
-  return address_v4(nmbits);
-}
-
-address_v4_range network_v4::hosts() const noexcept
-{
-  return is_host()
-    ? address_v4_range(address_, address_v4(address_.to_uint() + 1))
-    : address_v4_range(address_v4(network().to_uint() + 1), broadcast());
-}
-
-bool network_v4::is_subnet_of(const network_v4& other) const
-{
-  if (other.prefix_length_ >= prefix_length_)
-    return false; // Only real subsets are allowed.
-  const network_v4 me(address_, other.prefix_length_);
-  return other.canonical() == me.canonical();
-}
-
-std::string network_v4::to_string() const
-{
-  asio::error_code ec;
-  std::string addr = to_string(ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-std::string network_v4::to_string(asio::error_code& ec) const
-{
-  using namespace std; // For sprintf.
-  ec = asio::error_code();
-  char prefix_len[16];
-#if defined(ASIO_HAS_SNPRINTF)
-  snprintf(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
-#elif defined(ASIO_HAS_SECURE_RTL)
-  sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
-#else // defined(ASIO_HAS_SECURE_RTL)
-  sprintf(prefix_len, "/%u", prefix_length_);
-#endif // defined(ASIO_HAS_SECURE_RTL)
-  return address_.to_string() + prefix_len;
-}
-
-network_v4 make_network_v4(const char* str)
-{
-  return make_network_v4(std::string(str));
-}
-
-network_v4 make_network_v4(const char* str, asio::error_code& ec)
-{
-  return make_network_v4(std::string(str), ec);
-}
-
-network_v4 make_network_v4(const std::string& str)
-{
-  asio::error_code ec;
-  network_v4 net = make_network_v4(str, ec);
-  asio::detail::throw_error(ec);
-  return net;
-}
-
-network_v4 make_network_v4(const std::string& str,
-    asio::error_code& ec)
-{
-  std::string::size_type pos = str.find_first_of("/");
-
-  if (pos == std::string::npos)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v4();
-  }
-
-  if (pos == str.size() - 1)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v4();
-  }
-
-  std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
-  if (end != std::string::npos)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v4();
-  }
-
-  const address_v4 addr = make_address_v4(str.substr(0, pos), ec);
-  if (ec)
-    return network_v4();
-
-  const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
-  if (prefix_len < 0 || prefix_len > 32)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v4();
-  }
-
-  return network_v4(addr, static_cast<unsigned short>(prefix_len));
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-network_v4 make_network_v4(string_view str)
-{
-  return make_network_v4(static_cast<std::string>(str));
-}
-
-network_v4 make_network_v4(string_view str,
-    asio::error_code& ec)
-{
-  return make_network_v4(static_cast<std::string>(str), ec);
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_NETWORK_V4_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.hpp
deleted file mode 100644
index 69c1218..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// ip/impl/network_v6.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_NETWORK_V6_HPP
-#define ASIO_IP_IMPL_NETWORK_V6_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const network_v6& addr)
-{
-  asio::error_code ec;
-  std::string s = addr.to_string(ec);
-  if (ec)
-  {
-    if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
-      asio::detail::throw_error(ec);
-    else
-      os.setstate(std::basic_ostream<Elem, Traits>::failbit);
-  }
-  else
-    for (std::string::iterator i = s.begin(); i != s.end(); ++i)
-      os << os.widen(*i);
-  return os;
-}
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_IP_IMPL_NETWORK_V6_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.ipp
deleted file mode 100644
index d85cd64..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/impl/network_v6.ipp
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// ip/impl/network_v6.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_IMPL_NETWORK_V6_IPP
-#define ASIO_IP_IMPL_NETWORK_V6_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <climits>
-#include <cstdio>
-#include <cstdlib>
-#include <stdexcept>
-#include "asio/error.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/throw_exception.hpp"
-#include "asio/ip/network_v6.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-network_v6::network_v6(const address_v6& addr, unsigned short prefix_len)
-  : address_(addr),
-    prefix_length_(prefix_len)
-{
-  if (prefix_len > 128)
-  {
-    std::out_of_range ex("prefix length too large");
-    asio::detail::throw_exception(ex);
-  }
-}
-
-ASIO_DECL address_v6 network_v6::network() const noexcept
-{
-  address_v6::bytes_type bytes(address_.to_bytes());
-  for (std::size_t i = 0; i < 16; ++i)
-  {
-    if (prefix_length_ <= i * 8)
-      bytes[i] = 0;
-    else if (prefix_length_ < (i + 1) * 8)
-      bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
-  }
-  return address_v6(bytes, address_.scope_id());
-}
-
-address_v6_range network_v6::hosts() const noexcept
-{
-  address_v6::bytes_type begin_bytes(address_.to_bytes());
-  address_v6::bytes_type end_bytes(address_.to_bytes());
-  for (std::size_t i = 0; i < 16; ++i)
-  {
-    if (prefix_length_ <= i * 8)
-    {
-      begin_bytes[i] = 0;
-      end_bytes[i] = 0xFF;
-    }
-    else if (prefix_length_ < (i + 1) * 8)
-    {
-      begin_bytes[i] &= 0xFF00 >> (prefix_length_ % 8);
-      end_bytes[i] |= 0xFF >> (prefix_length_ % 8);
-    }
-  }
-  return address_v6_range(
-      address_v6_iterator(address_v6(begin_bytes, address_.scope_id())),
-      ++address_v6_iterator(address_v6(end_bytes, address_.scope_id())));
-}
-
-bool network_v6::is_subnet_of(const network_v6& other) const
-{
-  if (other.prefix_length_ >= prefix_length_)
-    return false; // Only real subsets are allowed.
-  const network_v6 me(address_, other.prefix_length_);
-  return other.canonical() == me.canonical();
-}
-
-std::string network_v6::to_string() const
-{
-  asio::error_code ec;
-  std::string addr = to_string(ec);
-  asio::detail::throw_error(ec);
-  return addr;
-}
-
-std::string network_v6::to_string(asio::error_code& ec) const
-{
-  using namespace std; // For sprintf.
-  ec = asio::error_code();
-  char prefix_len[16];
-#if defined(ASIO_HAS_SNPRINTF)
-  snprintf(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
-#elif defined(ASIO_HAS_SECURE_RTL)
-  sprintf_s(prefix_len, sizeof(prefix_len), "/%u", prefix_length_);
-#else // defined(ASIO_HAS_SECURE_RTL)
-  sprintf(prefix_len, "/%u", prefix_length_);
-#endif // defined(ASIO_HAS_SECURE_RTL)
-  return address_.to_string() + prefix_len;
-}
-
-network_v6 make_network_v6(const char* str)
-{
-  return make_network_v6(std::string(str));
-}
-
-network_v6 make_network_v6(const char* str, asio::error_code& ec)
-{
-  return make_network_v6(std::string(str), ec);
-}
-
-network_v6 make_network_v6(const std::string& str)
-{
-  asio::error_code ec;
-  network_v6 net = make_network_v6(str, ec);
-  asio::detail::throw_error(ec);
-  return net;
-}
-
-network_v6 make_network_v6(const std::string& str,
-    asio::error_code& ec)
-{
-  std::string::size_type pos = str.find_first_of("/");
-
-  if (pos == std::string::npos)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v6();
-  }
-
-  if (pos == str.size() - 1)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v6();
-  }
-
-  std::string::size_type end = str.find_first_not_of("0123456789", pos + 1);
-  if (end != std::string::npos)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v6();
-  }
-
-  const address_v6 addr = make_address_v6(str.substr(0, pos), ec);
-  if (ec)
-    return network_v6();
-
-  const int prefix_len = std::atoi(str.substr(pos + 1).c_str());
-  if (prefix_len < 0 || prefix_len > 128)
-  {
-    ec = asio::error::invalid_argument;
-    return network_v6();
-  }
-
-  return network_v6(addr, static_cast<unsigned short>(prefix_len));
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-
-network_v6 make_network_v6(string_view str)
-{
-  return make_network_v6(static_cast<std::string>(str));
-}
-
-network_v6 make_network_v6(string_view str,
-    asio::error_code& ec)
-{
-  return make_network_v6(static_cast<std::string>(str), ec);
-}
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_IMPL_NETWORK_V6_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/multicast.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/multicast.hpp
deleted file mode 100644
index 363f5ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/multicast.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-// ip/multicast.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_MULTICAST_HPP
-#define ASIO_IP_MULTICAST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/ip/detail/socket_option.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-namespace multicast {
-
-/// Socket option to join a multicast group on a specified interface.
-/**
- * Implements the IPPROTO_IP/IP_ADD_MEMBERSHIP socket option.
- *
- * @par Examples
- * Setting the option to join a multicast group:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::address multicast_address =
- *   asio::ip::address::from_string("225.0.0.1");
- * asio::ip::multicast::join_group option(multicast_address);
- * socket.set_option(option);
- * @endcode
- *
- * @par Concepts:
- * SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined join_group;
-#else
-typedef asio::ip::detail::socket_option::multicast_request<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_ADD_MEMBERSHIP),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_JOIN_GROUP)> join_group;
-#endif
-
-/// Socket option to leave a multicast group on a specified interface.
-/**
- * Implements the IPPROTO_IP/IP_DROP_MEMBERSHIP socket option.
- *
- * @par Examples
- * Setting the option to leave a multicast group:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::address multicast_address =
- *   asio::ip::address::from_string("225.0.0.1");
- * asio::ip::multicast::leave_group option(multicast_address);
- * socket.set_option(option);
- * @endcode
- *
- * @par Concepts:
- * SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined leave_group;
-#else
-typedef asio::ip::detail::socket_option::multicast_request<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_DROP_MEMBERSHIP),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_LEAVE_GROUP)> leave_group;
-#endif
-
-/// Socket option for local interface to use for outgoing multicast packets.
-/**
- * Implements the IPPROTO_IP/IP_MULTICAST_IF socket option.
- *
- * @par Examples
- * Setting the option:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::address_v4 local_interface =
- *   asio::ip::address_v4::from_string("1.2.3.4");
- * asio::ip::multicast::outbound_interface option(local_interface);
- * socket.set_option(option);
- * @endcode
- *
- * @par Concepts:
- * SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined outbound_interface;
-#else
-typedef asio::ip::detail::socket_option::network_interface<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_MULTICAST_IF),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_MULTICAST_IF)> outbound_interface;
-#endif
-
-/// Socket option for time-to-live associated with outgoing multicast packets.
-/**
- * Implements the IPPROTO_IP/IP_MULTICAST_TTL socket option.
- *
- * @par Examples
- * Setting the option:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::multicast::hops option(4);
- * socket.set_option(option);
- * @endcode
- *
- * @par
- * Getting the current option value:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::multicast::hops option;
- * socket.get_option(option);
- * int ttl = option.value();
- * @endcode
- *
- * @par Concepts:
- * GettableSocketOption, SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined hops;
-#else
-typedef asio::ip::detail::socket_option::multicast_hops<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_MULTICAST_TTL),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_MULTICAST_HOPS)> hops;
-#endif
-
-/// Socket option determining whether outgoing multicast packets will be
-/// received on the same socket if it is a member of the multicast group.
-/**
- * Implements the IPPROTO_IP/IP_MULTICAST_LOOP socket option.
- *
- * @par Examples
- * Setting the option:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::multicast::enable_loopback option(true);
- * socket.set_option(option);
- * @endcode
- *
- * @par
- * Getting the current option value:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::multicast::enable_loopback option;
- * socket.get_option(option);
- * bool is_set = option.value();
- * @endcode
- *
- * @par Concepts:
- * GettableSocketOption, SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined enable_loopback;
-#else
-typedef asio::ip::detail::socket_option::multicast_enable_loopback<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_MULTICAST_LOOP),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_MULTICAST_LOOP)> enable_loopback;
-#endif
-
-} // namespace multicast
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_MULTICAST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v4.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v4.hpp
deleted file mode 100644
index 1c29ebe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v4.hpp
+++ /dev/null
@@ -1,257 +0,0 @@
-//
-// ip/network_v4.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_NETWORK_V4_HPP
-#define ASIO_IP_NETWORK_V4_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/detail/string_view.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ip/address_v4_range.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Represents an IPv4 network.
-/**
- * The asio::ip::network_v4 class provides the ability to use and
- * manipulate IP version 4 networks.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class network_v4
-{
-public:
-  /// Default constructor.
-  network_v4() noexcept
-    : address_(),
-      prefix_length_(0)
-  {
-  }
-
-  /// Construct a network based on the specified address and prefix length.
-  ASIO_DECL network_v4(const address_v4& addr,
-      unsigned short prefix_len);
-
-  /// Construct network based on the specified address and netmask.
-  ASIO_DECL network_v4(const address_v4& addr,
-      const address_v4& mask);
-
-  /// Copy constructor.
-  network_v4(const network_v4& other) noexcept
-    : address_(other.address_),
-      prefix_length_(other.prefix_length_)
-  {
-  }
-
-  /// Move constructor.
-  network_v4(network_v4&& other) noexcept
-    : address_(static_cast<address_v4&&>(other.address_)),
-      prefix_length_(other.prefix_length_)
-  {
-  }
-
-  /// Assign from another network.
-  network_v4& operator=(const network_v4& other) noexcept
-  {
-    address_ = other.address_;
-    prefix_length_ = other.prefix_length_;
-    return *this;
-  }
-
-  /// Move-assign from another network.
-  network_v4& operator=(network_v4&& other) noexcept
-  {
-    address_ = static_cast<address_v4&&>(other.address_);
-    prefix_length_ = other.prefix_length_;
-    return *this;
-  }
-
-  /// Obtain the address object specified when the network object was created.
-  address_v4 address() const noexcept
-  {
-    return address_;
-  }
-
-  /// Obtain the prefix length that was specified when the network object was
-  /// created.
-  unsigned short prefix_length() const noexcept
-  {
-    return prefix_length_;
-  }
-
-  /// Obtain the netmask that was specified when the network object was created.
-  ASIO_DECL address_v4 netmask() const noexcept;
-
-  /// Obtain an address object that represents the network address.
-  address_v4 network() const noexcept
-  {
-    return address_v4(address_.to_uint() & netmask().to_uint());
-  }
-
-  /// Obtain an address object that represents the network's broadcast address.
-  address_v4 broadcast() const noexcept
-  {
-    return address_v4(network().to_uint() | (netmask().to_uint() ^ 0xFFFFFFFF));
-  }
-
-  /// Obtain an address range corresponding to the hosts in the network.
-  ASIO_DECL address_v4_range hosts() const noexcept;
-
-  /// Obtain the true network address, omitting any host bits.
-  network_v4 canonical() const noexcept
-  {
-    return network_v4(network(), prefix_length());
-  }
-
-  /// Test if network is a valid host address.
-  bool is_host() const noexcept
-  {
-    return prefix_length_ == 32;
-  }
-
-  /// Test if a network is a real subnet of another network.
-  ASIO_DECL bool is_subnet_of(const network_v4& other) const;
-
-  /// Get the network as an address in dotted decimal format.
-  ASIO_DECL std::string to_string() const;
-
-  /// Get the network as an address in dotted decimal format.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
-
-  /// Compare two networks for equality.
-  friend bool operator==(const network_v4& a, const network_v4& b)
-  {
-    return a.address_ == b.address_ && a.prefix_length_ == b.prefix_length_;
-  }
-
-  /// Compare two networks for inequality.
-  friend bool operator!=(const network_v4& a, const network_v4& b)
-  {
-    return !(a == b);
-  }
-
-private:
-  address_v4 address_;
-  unsigned short prefix_length_;
-};
-
-/// Create an IPv4 network from an address and prefix length.
-/**
- * @relates address_v4
- */
-inline network_v4 make_network_v4(
-    const address_v4& addr, unsigned short prefix_len)
-{
-  return network_v4(addr, prefix_len);
-}
-
-/// Create an IPv4 network from an address and netmask.
-/**
- * @relates address_v4
- */
-inline network_v4 make_network_v4(
-    const address_v4& addr, const address_v4& mask)
-{
-  return network_v4(addr, mask);
-}
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(const char* str);
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(
-    const char* str, asio::error_code& ec);
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(const std::string& str);
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(
-    const std::string& str, asio::error_code& ec);
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(string_view str);
-
-/// Create an IPv4 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v4
- */
-ASIO_DECL network_v4 make_network_v4(
-    string_view str, asio::error_code& ec);
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output a network as a string.
-/**
- * Used to output a human-readable string for a specified network.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param net The network to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::address_v4
- */
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const network_v4& net);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/network_v4.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/network_v4.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_NETWORK_V4_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v6.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v6.hpp
deleted file mode 100644
index 942ed9d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/network_v6.hpp
+++ /dev/null
@@ -1,231 +0,0 @@
-//
-// ip/network_v6.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_NETWORK_V6_HPP
-#define ASIO_IP_NETWORK_V6_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <string>
-#include "asio/detail/string_view.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ip/address_v6_range.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Represents an IPv6 network.
-/**
- * The asio::ip::network_v6 class provides the ability to use and
- * manipulate IP version 6 networks.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class network_v6
-{
-public:
-  /// Default constructor.
-  network_v6() noexcept
-    : address_(),
-      prefix_length_(0)
-  {
-  }
-
-  /// Construct a network based on the specified address and prefix length.
-  ASIO_DECL network_v6(const address_v6& addr,
-      unsigned short prefix_len);
-
-  /// Copy constructor.
-  network_v6(const network_v6& other) noexcept
-    : address_(other.address_),
-      prefix_length_(other.prefix_length_)
-  {
-  }
-
-  /// Move constructor.
-  network_v6(network_v6&& other) noexcept
-    : address_(static_cast<address_v6&&>(other.address_)),
-      prefix_length_(other.prefix_length_)
-  {
-  }
-
-  /// Assign from another network.
-  network_v6& operator=(const network_v6& other) noexcept
-  {
-    address_ = other.address_;
-    prefix_length_ = other.prefix_length_;
-    return *this;
-  }
-
-  /// Move-assign from another network.
-  network_v6& operator=(network_v6&& other) noexcept
-  {
-    address_ = static_cast<address_v6&&>(other.address_);
-    prefix_length_ = other.prefix_length_;
-    return *this;
-  }
-
-  /// Obtain the address object specified when the network object was created.
-  address_v6 address() const noexcept
-  {
-    return address_;
-  }
-
-  /// Obtain the prefix length that was specified when the network object was
-  /// created.
-  unsigned short prefix_length() const noexcept
-  {
-    return prefix_length_;
-  }
-
-  /// Obtain an address object that represents the network address.
-  ASIO_DECL address_v6 network() const noexcept;
-
-  /// Obtain an address range corresponding to the hosts in the network.
-  ASIO_DECL address_v6_range hosts() const noexcept;
-
-  /// Obtain the true network address, omitting any host bits.
-  network_v6 canonical() const noexcept
-  {
-    return network_v6(network(), prefix_length());
-  }
-
-  /// Test if network is a valid host address.
-  bool is_host() const noexcept
-  {
-    return prefix_length_ == 128;
-  }
-
-  /// Test if a network is a real subnet of another network.
-  ASIO_DECL bool is_subnet_of(const network_v6& other) const;
-
-  /// Get the network as an address in dotted decimal format.
-  ASIO_DECL std::string to_string() const;
-
-  /// Get the network as an address in dotted decimal format.
-  ASIO_DECL std::string to_string(asio::error_code& ec) const;
-
-  /// Compare two networks for equality.
-  friend bool operator==(const network_v6& a, const network_v6& b)
-  {
-    return a.address_ == b.address_ && a.prefix_length_ == b.prefix_length_;
-  }
-
-  /// Compare two networks for inequality.
-  friend bool operator!=(const network_v6& a, const network_v6& b)
-  {
-    return !(a == b);
-  }
-
-private:
-  address_v6 address_;
-  unsigned short prefix_length_;
-};
-
-/// Create an IPv6 network from an address and prefix length.
-/**
- * @relates address_v6
- */
-inline network_v6 make_network_v6(
-    const address_v6& addr, unsigned short prefix_len)
-{
-  return network_v6(addr, prefix_len);
-}
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(const char* str);
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(
-    const char* str, asio::error_code& ec);
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(const std::string& str);
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(
-    const std::string& str, asio::error_code& ec);
-
-#if defined(ASIO_HAS_STRING_VIEW) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(string_view str);
-
-/// Create an IPv6 network from a string containing IP address and prefix
-/// length.
-/**
- * @relates network_v6
- */
-ASIO_DECL network_v6 make_network_v6(
-    string_view str, asio::error_code& ec);
-
-#endif // defined(ASIO_HAS_STRING_VIEW)
-       //  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Output a network as a string.
-/**
- * Used to output a human-readable string for a specified network.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param net The network to be written.
- *
- * @return The output stream.
- *
- * @relates asio::ip::address_v6
- */
-template <typename Elem, typename Traits>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os, const network_v6& net);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ip/impl/network_v6.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ip/impl/network_v6.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_IP_NETWORK_V6_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_base.hpp
deleted file mode 100644
index 9fa01ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_base.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// ip/resolver_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_RESOLVER_BASE_HPP
-#define ASIO_IP_RESOLVER_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// The resolver_base class is used as a base for the basic_resolver class
-/// templates to provide a common place to define the flag constants.
-class resolver_base
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// A bitmask type (C++ Std [lib.bitmask.types]).
-  typedef unspecified flags;
-
-  /// Determine the canonical name of the host specified in the query.
-  static const flags canonical_name = implementation_defined;
-
-  /// Indicate that returned endpoint is intended for use as a locally bound
-  /// socket endpoint.
-  static const flags passive = implementation_defined;
-
-  /// Host name should be treated as a numeric string defining an IPv4 or IPv6
-  /// address and no name resolution should be attempted.
-  static const flags numeric_host = implementation_defined;
-
-  /// Service name should be treated as a numeric string defining a port number
-  /// and no name resolution should be attempted.
-  static const flags numeric_service = implementation_defined;
-
-  /// If the query protocol family is specified as IPv6, return IPv4-mapped
-  /// IPv6 addresses on finding no IPv6 addresses.
-  static const flags v4_mapped = implementation_defined;
-
-  /// If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
-  static const flags all_matching = implementation_defined;
-
-  /// Only return IPv4 addresses if a non-loopback IPv4 address is configured
-  /// for the system. Only return IPv6 addresses if a non-loopback IPv6 address
-  /// is configured for the system.
-  static const flags address_configured = implementation_defined;
-#else
-  enum flags
-  {
-    canonical_name = ASIO_OS_DEF(AI_CANONNAME),
-    passive = ASIO_OS_DEF(AI_PASSIVE),
-    numeric_host = ASIO_OS_DEF(AI_NUMERICHOST),
-    numeric_service = ASIO_OS_DEF(AI_NUMERICSERV),
-    v4_mapped = ASIO_OS_DEF(AI_V4MAPPED),
-    all_matching = ASIO_OS_DEF(AI_ALL),
-    address_configured = ASIO_OS_DEF(AI_ADDRCONFIG)
-  };
-
-  // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
-
-  friend flags operator&(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
-  }
-
-  friend flags operator|(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
-  }
-
-  friend flags operator^(flags x, flags y)
-  {
-    return static_cast<flags>(
-        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
-  }
-
-  friend flags operator~(flags x)
-  {
-    return static_cast<flags>(~static_cast<unsigned int>(x));
-  }
-
-  friend flags& operator&=(flags& x, flags y)
-  {
-    x = x & y;
-    return x;
-  }
-
-  friend flags& operator|=(flags& x, flags y)
-  {
-    x = x | y;
-    return x;
-  }
-
-  friend flags& operator^=(flags& x, flags y)
-  {
-    x = x ^ y;
-    return x;
-  }
-#endif
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~resolver_base()
-  {
-  }
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_RESOLVER_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_query_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_query_base.hpp
deleted file mode 100644
index 892bc28..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/resolver_query_base.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// ip/resolver_query_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_RESOLVER_QUERY_BASE_HPP
-#define ASIO_IP_RESOLVER_QUERY_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ip/resolver_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// The resolver_query_base class is used as a base for the
-/// basic_resolver_query class templates to provide a common place to define
-/// the flag constants.
-class resolver_query_base : public resolver_base
-{
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~resolver_query_base()
-  {
-  }
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_RESOLVER_QUERY_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/tcp.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/tcp.hpp
deleted file mode 100644
index b831960..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/tcp.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// ip/tcp.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_TCP_HPP
-#define ASIO_IP_TCP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/detail/socket_option.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Encapsulates the flags needed for TCP.
-/**
- * The asio::ip::tcp class contains flags necessary for TCP sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol, InternetProtocol.
- */
-class tcp
-{
-public:
-  /// The type of a TCP endpoint.
-  typedef basic_endpoint<tcp> endpoint;
-
-  /// Construct to represent the IPv4 TCP protocol.
-  static tcp v4() noexcept
-  {
-    return tcp(ASIO_OS_DEF(AF_INET));
-  }
-
-  /// Construct to represent the IPv6 TCP protocol.
-  static tcp v6() noexcept
-  {
-    return tcp(ASIO_OS_DEF(AF_INET6));
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_STREAM);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return ASIO_OS_DEF(IPPROTO_TCP);
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// The TCP socket type.
-  typedef basic_stream_socket<tcp> socket;
-
-  /// The TCP acceptor type.
-  typedef basic_socket_acceptor<tcp> acceptor;
-
-  /// The TCP resolver type.
-  typedef basic_resolver<tcp> resolver;
-
-#if !defined(ASIO_NO_IOSTREAM)
-  /// The TCP iostream type.
-  typedef basic_socket_iostream<tcp> iostream;
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-  /// Socket option for disabling the Nagle algorithm.
-  /**
-   * Implements the IPPROTO_TCP/TCP_NODELAY socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::no_delay option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::ip::tcp::no_delay option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined no_delay;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(IPPROTO_TCP), ASIO_OS_DEF(TCP_NODELAY)> no_delay;
-#endif
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const tcp& p1, const tcp& p2)
-  {
-    return p1.family_ == p2.family_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const tcp& p1, const tcp& p2)
-  {
-    return p1.family_ != p2.family_;
-  }
-
-private:
-  // Construct with a specific family.
-  explicit tcp(int protocol_family) noexcept
-    : family_(protocol_family)
-  {
-  }
-
-  int family_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_TCP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/udp.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/udp.hpp
deleted file mode 100644
index 50c667a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/udp.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//
-// ip/udp.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_UDP_HPP
-#define ASIO_IP_UDP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Encapsulates the flags needed for UDP.
-/**
- * The asio::ip::udp class contains flags necessary for UDP sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol, InternetProtocol.
- */
-class udp
-{
-public:
-  /// The type of a UDP endpoint.
-  typedef basic_endpoint<udp> endpoint;
-
-  /// Construct to represent the IPv4 UDP protocol.
-  static udp v4() noexcept
-  {
-    return udp(ASIO_OS_DEF(AF_INET));
-  }
-
-  /// Construct to represent the IPv6 UDP protocol.
-  static udp v6() noexcept
-  {
-    return udp(ASIO_OS_DEF(AF_INET6));
-  }
-
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return ASIO_OS_DEF(SOCK_DGRAM);
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return ASIO_OS_DEF(IPPROTO_UDP);
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return family_;
-  }
-
-  /// The UDP socket type.
-  typedef basic_datagram_socket<udp> socket;
-
-  /// The UDP resolver type.
-  typedef basic_resolver<udp> resolver;
-
-  /// Compare two protocols for equality.
-  friend bool operator==(const udp& p1, const udp& p2)
-  {
-    return p1.family_ == p2.family_;
-  }
-
-  /// Compare two protocols for inequality.
-  friend bool operator!=(const udp& p1, const udp& p2)
-  {
-    return p1.family_ != p2.family_;
-  }
-
-private:
-  // Construct with a specific family.
-  explicit udp(int protocol_family) noexcept
-    : family_(protocol_family)
-  {
-  }
-
-  int family_;
-};
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_UDP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/unicast.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/unicast.hpp
deleted file mode 100644
index 4d68af8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/unicast.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-// ip/unicast.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_UNICAST_HPP
-#define ASIO_IP_UNICAST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/ip/detail/socket_option.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-namespace unicast {
-
-/// Socket option for time-to-live associated with outgoing unicast packets.
-/**
- * Implements the IPPROTO_IP/IP_UNICAST_TTL socket option.
- *
- * @par Examples
- * Setting the option:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::unicast::hops option(4);
- * socket.set_option(option);
- * @endcode
- *
- * @par
- * Getting the current option value:
- * @code
- * asio::ip::udp::socket socket(my_context);
- * ...
- * asio::ip::unicast::hops option;
- * socket.get_option(option);
- * int ttl = option.value();
- * @endcode
- *
- * @par Concepts:
- * GettableSocketOption, SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined hops;
-#else
-typedef asio::ip::detail::socket_option::unicast_hops<
-  ASIO_OS_DEF(IPPROTO_IP),
-  ASIO_OS_DEF(IP_TTL),
-  ASIO_OS_DEF(IPPROTO_IPV6),
-  ASIO_OS_DEF(IPV6_UNICAST_HOPS)> hops;
-#endif
-
-} // namespace unicast
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_UNICAST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/v6_only.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/v6_only.hpp
deleted file mode 100644
index 0fc6121..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ip/v6_only.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// ip/v6_only.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IP_V6_ONLY_HPP
-#define ASIO_IP_V6_ONLY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_option.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ip {
-
-/// Socket option for determining whether an IPv6 socket supports IPv6
-/// communication only.
-/**
- * Implements the IPPROTO_IPV6/IPV6_V6ONLY socket option.
- *
- * @par Examples
- * Setting the option:
- * @code
- * asio::ip::tcp::socket socket(my_context);
- * ...
- * asio::ip::v6_only option(true);
- * socket.set_option(option);
- * @endcode
- *
- * @par
- * Getting the current option value:
- * @code
- * asio::ip::tcp::socket socket(my_context);
- * ...
- * asio::ip::v6_only option;
- * socket.get_option(option);
- * bool v6_only = option.value();
- * @endcode
- *
- * @par Concepts:
- * GettableSocketOption, SettableSocketOption.
- */
-#if defined(GENERATING_DOCUMENTATION)
-typedef implementation_defined v6_only;
-#elif defined(IPV6_V6ONLY)
-typedef asio::detail::socket_option::boolean<
-    IPPROTO_IPV6, IPV6_V6ONLY> v6_only;
-#else
-typedef asio::detail::socket_option::boolean<
-    asio::detail::custom_socket_option_level,
-    asio::detail::always_fail_option> v6_only;
-#endif
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IP_V6_ONLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_applicable_property.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_applicable_property.hpp
deleted file mode 100644
index 20ca981..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_applicable_property.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// is_applicable_property.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IS_APPLICABLE_PROPERTY_HPP
-#define ASIO_IS_APPLICABLE_PROPERTY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename T, typename Property, typename = void>
-struct is_applicable_property_trait : false_type
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-struct is_applicable_property_trait<T, Property,
-  void_t<
-    enable_if_t<
-      !!Property::template is_applicable_property_v<T>
-    >
-  >> : true_type
-{
-};
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-} // namespace detail
-
-template <typename T, typename Property, typename = void>
-struct is_applicable_property :
-  detail::is_applicable_property_trait<T, Property>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-constexpr const bool is_applicable_property_v
-  = is_applicable_property<T, Property>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-} // namespace asio
-
-#endif // ASIO_IS_APPLICABLE_PROPERTY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_contiguous_iterator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_contiguous_iterator.hpp
deleted file mode 100644
index a120d4d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_contiguous_iterator.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// is_contiguous_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IS_CONTIGUOUS_ITERATOR_HPP
-#define ASIO_IS_CONTIGUOUS_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <iterator>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The is_contiguous_iterator class is a traits class that may be used to
-/// determine whether a type is a contiguous iterator.
-template <typename T>
-struct is_contiguous_iterator :
-#if defined(ASIO_HAS_STD_CONCEPTS) \
-  || defined(GENERATING_DOCUMENTATION)
-  integral_constant<bool, std::contiguous_iterator<T>>
-#else // defined(ASIO_HAS_STD_CONCEPTS)
-      //   || defined(GENERATING_DOCUMENTATION)
-  is_pointer<T>
-#endif // defined(ASIO_HAS_STD_CONCEPTS)
-       //   || defined(GENERATING_DOCUMENTATION)
-{
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IS_CONTIGUOUS_ITERATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_executor.hpp
deleted file mode 100644
index 2c933a3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_executor.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// is_executor.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IS_EXECUTOR_HPP
-#define ASIO_IS_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/is_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The is_executor trait detects whether a type T meets the Executor type
-/// requirements.
-/**
- * Class template @c is_executor is a UnaryTypeTrait that is derived from @c
- * true_type if the type @c T meets the syntactic requirements for Executor,
- * otherwise @c false_type.
- */
-template <typename T>
-struct is_executor
-#if defined(GENERATING_DOCUMENTATION)
-  : integral_constant<bool, automatically_determined>
-#else // defined(GENERATING_DOCUMENTATION)
-  : asio::detail::is_executor<T>
-#endif // defined(GENERATING_DOCUMENTATION)
-{
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IS_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_read_buffered.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_read_buffered.hpp
deleted file mode 100644
index 768f70f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_read_buffered.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// is_read_buffered.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IS_READ_BUFFERED_HPP
-#define ASIO_IS_READ_BUFFERED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffered_read_stream_fwd.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail {
-
-template <typename Stream>
-char is_read_buffered_helper(buffered_stream<Stream>* s);
-
-template <typename Stream>
-char is_read_buffered_helper(buffered_read_stream<Stream>* s);
-
-struct is_read_buffered_big_type { char data[10]; };
-is_read_buffered_big_type is_read_buffered_helper(...);
-
-} // namespace detail
-
-/// The is_read_buffered class is a traits class that may be used to determine
-/// whether a stream type supports buffering of read data.
-template <typename Stream>
-class is_read_buffered
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The value member is true only if the Stream type supports buffering of
-  /// read data.
-  static const bool value;
-#else
-  ASIO_STATIC_CONSTANT(bool,
-      value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1);
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IS_READ_BUFFERED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_write_buffered.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_write_buffered.hpp
deleted file mode 100644
index 1818fd4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/is_write_buffered.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// is_write_buffered.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_IS_WRITE_BUFFERED_HPP
-#define ASIO_IS_WRITE_BUFFERED_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-#include "asio/buffered_write_stream_fwd.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail {
-
-template <typename Stream>
-char is_write_buffered_helper(buffered_stream<Stream>* s);
-
-template <typename Stream>
-char is_write_buffered_helper(buffered_write_stream<Stream>* s);
-
-struct is_write_buffered_big_type { char data[10]; };
-is_write_buffered_big_type is_write_buffered_helper(...);
-
-} // namespace detail
-
-/// The is_write_buffered class is a traits class that may be used to determine
-/// whether a stream type supports buffering of written data.
-template <typename Stream>
-class is_write_buffered
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The value member is true only if the Stream type supports buffering of
-  /// written data.
-  static const bool value;
-#else
-  ASIO_STATIC_CONSTANT(bool,
-      value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1);
-#endif
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_IS_WRITE_BUFFERED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/basic_endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/basic_endpoint.hpp
deleted file mode 100644
index d363f35..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/basic_endpoint.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-//
-// local/basic_endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Derived from a public domain implementation written by Daniel Casimiro.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_BASIC_ENDPOINT_HPP
-#define ASIO_LOCAL_BASIC_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/local/detail/endpoint.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-# include <iosfwd>
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-
-/// Describes an endpoint for a UNIX socket.
-/**
- * The asio::local::basic_endpoint class template describes an endpoint
- * that may be associated with a particular UNIX socket.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * Endpoint.
- */
-template <typename Protocol>
-class basic_endpoint
-{
-public:
-  /// The protocol type associated with the endpoint.
-  typedef Protocol protocol_type;
-
-  /// The type of the endpoint structure. This type is dependent on the
-  /// underlying implementation of the socket layer.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined data_type;
-#else
-  typedef asio::detail::socket_addr_type data_type;
-#endif
-
-  /// Default constructor.
-  basic_endpoint() noexcept
-  {
-  }
-
-  /// Construct an endpoint using the specified path name.
-  basic_endpoint(const char* path_name)
-    : impl_(path_name)
-  {
-  }
-
-  /// Construct an endpoint using the specified path name.
-  basic_endpoint(const std::string& path_name)
-    : impl_(path_name)
-  {
-  }
-
-  #if defined(ASIO_HAS_STRING_VIEW)
-  /// Construct an endpoint using the specified path name.
-  basic_endpoint(string_view path_name)
-    : impl_(path_name)
-  {
-  }
-  #endif // defined(ASIO_HAS_STRING_VIEW)
-
-  /// Copy constructor.
-  basic_endpoint(const basic_endpoint& other)
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Move constructor.
-  basic_endpoint(basic_endpoint&& other)
-    : impl_(other.impl_)
-  {
-  }
-
-  /// Assign from another endpoint.
-  basic_endpoint& operator=(const basic_endpoint& other)
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// Move-assign from another endpoint.
-  basic_endpoint& operator=(basic_endpoint&& other)
-  {
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// The protocol associated with the endpoint.
-  protocol_type protocol() const
-  {
-    return protocol_type();
-  }
-
-  /// Get the underlying endpoint in the native type.
-  data_type* data()
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying endpoint in the native type.
-  const data_type* data() const
-  {
-    return impl_.data();
-  }
-
-  /// Get the underlying size of the endpoint in the native type.
-  std::size_t size() const
-  {
-    return impl_.size();
-  }
-
-  /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t new_size)
-  {
-    impl_.resize(new_size);
-  }
-
-  /// Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const
-  {
-    return impl_.capacity();
-  }
-
-  /// Get the path associated with the endpoint.
-  std::string path() const
-  {
-    return impl_.path();
-  }
-
-  /// Set the path associated with the endpoint.
-  void path(const char* p)
-  {
-    impl_.path(p);
-  }
-
-  /// Set the path associated with the endpoint.
-  void path(const std::string& p)
-  {
-    impl_.path(p);
-  }
-
-  /// Compare two endpoints for equality.
-  friend bool operator==(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e1.impl_ == e2.impl_;
-  }
-
-  /// Compare two endpoints for inequality.
-  friend bool operator!=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e1.impl_ == e2.impl_);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e1.impl_ < e2.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return e2.impl_ < e1.impl_;
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator<=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e2 < e1);
-  }
-
-  /// Compare endpoints for ordering.
-  friend bool operator>=(const basic_endpoint<Protocol>& e1,
-      const basic_endpoint<Protocol>& e2)
-  {
-    return !(e1 < e2);
-  }
-
-private:
-  // The underlying UNIX domain endpoint.
-  asio::local::detail::endpoint impl_;
-};
-
-/// Output an endpoint as a string.
-/**
- * Used to output a human-readable string for a specified endpoint.
- *
- * @param os The output stream to which the string will be written.
- *
- * @param endpoint The endpoint to be written.
- *
- * @return The output stream.
- *
- * @relates asio::local::basic_endpoint
- */
-template <typename Elem, typename Traits, typename Protocol>
-std::basic_ostream<Elem, Traits>& operator<<(
-    std::basic_ostream<Elem, Traits>& os,
-    const basic_endpoint<Protocol>& endpoint)
-{
-  os << endpoint.path();
-  return os;
-}
-
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_LOCAL_BASIC_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/connect_pair.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/connect_pair.hpp
deleted file mode 100644
index b8608e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/connect_pair.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// local/connect_pair.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_CONNECT_PAIR_HPP
-#define ASIO_LOCAL_CONNECT_PAIR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_socket.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/local/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-
-/// Create a pair of connected sockets.
-template <typename Protocol, typename Executor1, typename Executor2>
-void connect_pair(basic_socket<Protocol, Executor1>& socket1,
-    basic_socket<Protocol, Executor2>& socket2);
-
-/// Create a pair of connected sockets.
-template <typename Protocol, typename Executor1, typename Executor2>
-ASIO_SYNC_OP_VOID connect_pair(basic_socket<Protocol, Executor1>& socket1,
-    basic_socket<Protocol, Executor2>& socket2, asio::error_code& ec);
-
-template <typename Protocol, typename Executor1, typename Executor2>
-inline void connect_pair(basic_socket<Protocol, Executor1>& socket1,
-    basic_socket<Protocol, Executor2>& socket2)
-{
-  asio::error_code ec;
-  connect_pair(socket1, socket2, ec);
-  asio::detail::throw_error(ec, "connect_pair");
-}
-
-template <typename Protocol, typename Executor1, typename Executor2>
-inline ASIO_SYNC_OP_VOID connect_pair(
-    basic_socket<Protocol, Executor1>& socket1,
-    basic_socket<Protocol, Executor2>& socket2, asio::error_code& ec)
-{
-  // Check that this function is only being used with a UNIX domain socket.
-  asio::local::basic_endpoint<Protocol>* tmp
-    = static_cast<typename Protocol::endpoint*>(0);
-  (void)tmp;
-
-  Protocol protocol;
-  asio::detail::socket_type sv[2];
-  if (asio::detail::socket_ops::socketpair(protocol.family(),
-        protocol.type(), protocol.protocol(), sv, ec)
-      == asio::detail::socket_error_retval)
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-
-  socket1.assign(protocol, sv[0], ec);
-  if (ec)
-  {
-    asio::error_code temp_ec;
-    asio::detail::socket_ops::state_type state[2] = { 0, 0 };
-    asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
-    asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  socket2.assign(protocol, sv[1], ec);
-  if (ec)
-  {
-    asio::error_code temp_ec;
-    socket1.close(temp_ec);
-    asio::detail::socket_ops::state_type state = 0;
-    asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_LOCAL_CONNECT_PAIR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/datagram_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/datagram_protocol.hpp
deleted file mode 100644
index 6bf18a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/datagram_protocol.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// local/datagram_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
-#define ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/local/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-
-/// Encapsulates the flags needed for datagram-oriented UNIX sockets.
-/**
- * The asio::local::datagram_protocol class contains flags necessary for
- * datagram-oriented UNIX domain sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class datagram_protocol
-{
-public:
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return SOCK_DGRAM;
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return 0;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return AF_UNIX;
-  }
-
-  /// The type of a UNIX domain endpoint.
-  typedef basic_endpoint<datagram_protocol> endpoint;
-
-  /// The UNIX domain socket type.
-  typedef basic_datagram_socket<datagram_protocol> socket;
-};
-
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/endpoint.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/endpoint.hpp
deleted file mode 100644
index 5e94c3d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/endpoint.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-//
-// local/detail/endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Derived from a public domain implementation written by Daniel Casimiro.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_DETAIL_ENDPOINT_HPP
-#define ASIO_LOCAL_DETAIL_ENDPOINT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-#include <cstddef>
-#include <string>
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/string_view.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-namespace detail {
-
-// Helper class for implementing a UNIX domain endpoint.
-class endpoint
-{
-public:
-  // Default constructor.
-  ASIO_DECL endpoint();
-
-  // Construct an endpoint using the specified path name.
-  ASIO_DECL endpoint(const char* path_name);
-
-  // Construct an endpoint using the specified path name.
-  ASIO_DECL endpoint(const std::string& path_name);
-
-  #if defined(ASIO_HAS_STRING_VIEW)
-  // Construct an endpoint using the specified path name.
-  ASIO_DECL endpoint(string_view path_name);
-  #endif // defined(ASIO_HAS_STRING_VIEW)
-
-  // Copy constructor.
-  endpoint(const endpoint& other)
-    : data_(other.data_),
-      path_length_(other.path_length_)
-  {
-  }
-
-  // Assign from another endpoint.
-  endpoint& operator=(const endpoint& other)
-  {
-    data_ = other.data_;
-    path_length_ = other.path_length_;
-    return *this;
-  }
-
-  // Get the underlying endpoint in the native type.
-  asio::detail::socket_addr_type* data()
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying endpoint in the native type.
-  const asio::detail::socket_addr_type* data() const
-  {
-    return &data_.base;
-  }
-
-  // Get the underlying size of the endpoint in the native type.
-  std::size_t size() const
-  {
-    return path_length_
-      + offsetof(asio::detail::sockaddr_un_type, sun_path);
-  }
-
-  // Set the underlying size of the endpoint in the native type.
-  ASIO_DECL void resize(std::size_t size);
-
-  // Get the capacity of the endpoint in the native type.
-  std::size_t capacity() const
-  {
-    return sizeof(asio::detail::sockaddr_un_type);
-  }
-
-  // Get the path associated with the endpoint.
-  ASIO_DECL std::string path() const;
-
-  // Set the path associated with the endpoint.
-  ASIO_DECL void path(const char* p);
-
-  // Set the path associated with the endpoint.
-  ASIO_DECL void path(const std::string& p);
-
-  // Compare two endpoints for equality.
-  ASIO_DECL friend bool operator==(
-      const endpoint& e1, const endpoint& e2);
-
-  // Compare endpoints for ordering.
-  ASIO_DECL friend bool operator<(
-      const endpoint& e1, const endpoint& e2);
-
-private:
-  // The underlying UNIX socket address.
-  union data_union
-  {
-    asio::detail::socket_addr_type base;
-    asio::detail::sockaddr_un_type local;
-  } data_;
-
-  // The length of the path associated with the endpoint.
-  std::size_t path_length_;
-
-  // Initialise with a specified path.
-  ASIO_DECL void init(const char* path, std::size_t path_length);
-};
-
-} // namespace detail
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/local/detail/impl/endpoint.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-
-#endif // ASIO_LOCAL_DETAIL_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/impl/endpoint.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/impl/endpoint.ipp
deleted file mode 100644
index 55b403e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/detail/impl/endpoint.ipp
+++ /dev/null
@@ -1,131 +0,0 @@
-//
-// local/detail/impl/endpoint.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Derived from a public domain implementation written by Daniel Casimiro.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
-#define ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-#include <cstring>
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/local/detail/endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-namespace detail {
-
-endpoint::endpoint()
-{
-  init("", 0);
-}
-
-endpoint::endpoint(const char* path_name)
-{
-  using namespace std; // For strlen.
-  init(path_name, strlen(path_name));
-}
-
-endpoint::endpoint(const std::string& path_name)
-{
-  init(path_name.data(), path_name.length());
-}
-
-#if defined(ASIO_HAS_STRING_VIEW)
-endpoint::endpoint(string_view path_name)
-{
-  init(path_name.data(), path_name.length());
-}
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-void endpoint::resize(std::size_t new_size)
-{
-  if (new_size > sizeof(asio::detail::sockaddr_un_type))
-  {
-    asio::error_code ec(asio::error::invalid_argument);
-    asio::detail::throw_error(ec);
-  }
-  else if (new_size == 0)
-  {
-    path_length_ = 0;
-  }
-  else
-  {
-    path_length_ = new_size
-      - offsetof(asio::detail::sockaddr_un_type, sun_path);
-
-    // The path returned by the operating system may be NUL-terminated.
-    if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
-      --path_length_;
-  }
-}
-
-std::string endpoint::path() const
-{
-  return std::string(data_.local.sun_path, path_length_);
-}
-
-void endpoint::path(const char* p)
-{
-  using namespace std; // For strlen.
-  init(p, strlen(p));
-}
-
-void endpoint::path(const std::string& p)
-{
-  init(p.data(), p.length());
-}
-
-bool operator==(const endpoint& e1, const endpoint& e2)
-{
-  return e1.path() == e2.path();
-}
-
-bool operator<(const endpoint& e1, const endpoint& e2)
-{
-  return e1.path() < e2.path();
-}
-
-void endpoint::init(const char* path_name, std::size_t path_length)
-{
-  if (path_length > sizeof(data_.local.sun_path) - 1)
-  {
-    // The buffer is not large enough to store this address.
-    asio::error_code ec(asio::error::name_too_long);
-    asio::detail::throw_error(ec);
-  }
-
-  using namespace std; // For memset and memcpy.
-  memset(&data_.local, 0, sizeof(asio::detail::sockaddr_un_type));
-  data_.local.sun_family = AF_UNIX;
-  if (path_length > 0)
-    memcpy(data_.local.sun_path, path_name, path_length);
-  path_length_ = path_length;
-}
-
-} // namespace detail
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-
-#endif // ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/seq_packet_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/seq_packet_protocol.hpp
deleted file mode 100644
index c5a231f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/seq_packet_protocol.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// local/seq_packet_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_SEQ_PACKET_PROTOCOL_HPP
-#define ASIO_LOCAL_SEQ_PACKET_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_seq_packet_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/local/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-
-/// Encapsulates the flags needed for seq_packet UNIX sockets.
-/**
- * The asio::local::seq_packet_protocol class contains flags necessary
- * for sequenced packet UNIX domain sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class seq_packet_protocol
-{
-public:
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return SOCK_SEQPACKET;
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return 0;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return AF_UNIX;
-  }
-
-  /// The type of a UNIX domain endpoint.
-  typedef basic_endpoint<seq_packet_protocol> endpoint;
-
-  /// The UNIX domain socket type.
-  typedef basic_seq_packet_socket<seq_packet_protocol> socket;
-
-  /// The UNIX domain acceptor type.
-  typedef basic_socket_acceptor<seq_packet_protocol> acceptor;
-};
-
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_LOCAL_SEQ_PACKET_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/stream_protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/stream_protocol.hpp
deleted file mode 100644
index 4cbad45..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/local/stream_protocol.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// local/stream_protocol.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_LOCAL_STREAM_PROTOCOL_HPP
-#define ASIO_LOCAL_STREAM_PROTOCOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/local/basic_endpoint.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace local {
-
-/// Encapsulates the flags needed for stream-oriented UNIX sockets.
-/**
- * The asio::local::stream_protocol class contains flags necessary for
- * stream-oriented UNIX domain sockets.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe.
- *
- * @par Concepts:
- * Protocol.
- */
-class stream_protocol
-{
-public:
-  /// Obtain an identifier for the type of the protocol.
-  int type() const noexcept
-  {
-    return SOCK_STREAM;
-  }
-
-  /// Obtain an identifier for the protocol.
-  int protocol() const noexcept
-  {
-    return 0;
-  }
-
-  /// Obtain an identifier for the protocol family.
-  int family() const noexcept
-  {
-    return AF_UNIX;
-  }
-
-  /// The type of a UNIX domain endpoint.
-  typedef basic_endpoint<stream_protocol> endpoint;
-
-  /// The UNIX domain socket type.
-  typedef basic_stream_socket<stream_protocol> socket;
-
-  /// The UNIX domain acceptor type.
-  typedef basic_socket_acceptor<stream_protocol> acceptor;
-
-#if !defined(ASIO_NO_IOSTREAM)
-  /// The UNIX domain iostream type.
-  typedef basic_socket_iostream<stream_protocol> iostream;
-#endif // !defined(ASIO_NO_IOSTREAM)
-};
-
-} // namespace local
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_LOCAL_STREAM_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/multiple_exceptions.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/multiple_exceptions.hpp
deleted file mode 100644
index 2fd0455..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/multiple_exceptions.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// multiple_exceptions.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_MULTIPLE_EXCEPTIONS_HPP
-#define ASIO_MULTIPLE_EXCEPTIONS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <exception>
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Exception thrown when there are multiple pending exceptions to rethrow.
-class multiple_exceptions
-  : public std::exception
-{
-public:
-  /// Constructor.
-  ASIO_DECL multiple_exceptions(
-      std::exception_ptr first) noexcept;
-
-  /// Obtain message associated with exception.
-  ASIO_DECL virtual const char* what() const
-    noexcept;
-
-  /// Obtain a pointer to the first exception.
-  ASIO_DECL std::exception_ptr first_exception() const;
-
-private:
-  std::exception_ptr first_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/multiple_exceptions.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_MULTIPLE_EXCEPTIONS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/packaged_task.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/packaged_task.hpp
deleted file mode 100644
index 68e5b9b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/packaged_task.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// packaged_task.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_PACKAGED_TASK_HPP
-#define ASIO_PACKAGED_TASK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/future.hpp"
-
-#if defined(ASIO_HAS_STD_FUTURE_CLASS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/async_result.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Partial specialisation of @c async_result for @c std::packaged_task.
-template <typename Result, typename... Args, typename Signature>
-class async_result<std::packaged_task<Result(Args...)>, Signature>
-{
-public:
-  /// The packaged task is the concrete completion handler type.
-  typedef std::packaged_task<Result(Args...)> completion_handler_type;
-
-  /// The return type of the initiating function is the future obtained from
-  /// the packaged task.
-  typedef std::future<Result> return_type;
-
-  /// The constructor extracts the future from the packaged task.
-  explicit async_result(completion_handler_type& h)
-    : future_(h.get_future())
-  {
-  }
-
-  /// Returns the packaged task's future.
-  return_type get()
-  {
-    return std::move(future_);
-  }
-
-private:
-  return_type future_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_PACKAGED_TASK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/placeholders.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/placeholders.hpp
deleted file mode 100644
index 21da545..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/placeholders.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// placeholders.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_PLACEHOLDERS_HPP
-#define ASIO_PLACEHOLDERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/functional.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace placeholders {
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the error argument of a handler for any of the asynchronous
-/// functions.
-unspecified error;
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the bytes_transferred argument of a handler for asynchronous
-/// functions such as asio::basic_stream_socket::async_write_some or
-/// asio::async_write.
-unspecified bytes_transferred;
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the iterator argument of a handler for asynchronous functions
-/// such as asio::async_connect.
-unspecified iterator;
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the results argument of a handler for asynchronous functions
-/// such as asio::basic_resolver::async_resolve.
-unspecified results;
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the results argument of a handler for asynchronous functions
-/// such as asio::async_connect.
-unspecified endpoint;
-
-/// An argument placeholder, for use with std::bind() or boost::bind(), that
-/// corresponds to the signal_number argument of a handler for asynchronous
-/// functions such as asio::signal_set::async_wait.
-unspecified signal_number;
-
-#else
-
-static constexpr auto& error = std::placeholders::_1;
-static constexpr auto& bytes_transferred = std::placeholders::_2;
-static constexpr auto& iterator = std::placeholders::_2;
-static constexpr auto& results = std::placeholders::_2;
-static constexpr auto& endpoint = std::placeholders::_2;
-static constexpr auto& signal_number = std::placeholders::_2;
-
-#endif
-
-} // namespace placeholders
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_PLACEHOLDERS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_descriptor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_descriptor.hpp
deleted file mode 100644
index dca398d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_descriptor.hpp
+++ /dev/null
@@ -1,773 +0,0 @@
-//
-// posix/basic_descriptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POSIX_BASIC_DESCRIPTOR_HPP
-#define ASIO_POSIX_BASIC_DESCRIPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/posix/descriptor_base.hpp"
-
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/io_uring_descriptor_service.hpp"
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-# include "asio/detail/reactive_descriptor_service.hpp"
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace posix {
-
-/// Provides POSIX descriptor functionality.
-/**
- * The posix::basic_descriptor class template provides the ability to wrap a
- * POSIX descriptor.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_descriptor
-  : public descriptor_base
-{
-private:
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the descriptor type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The descriptor type when rebound to the specified executor.
-    typedef basic_descriptor<Executor1> other;
-  };
-
-  /// The native representation of a descriptor.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef detail::io_uring_descriptor_service::native_handle_type
-    native_handle_type;
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  typedef detail::reactive_descriptor_service::native_handle_type
-    native_handle_type;
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-  /// A descriptor is always the lowest layer.
-  typedef basic_descriptor lowest_layer_type;
-
-  /// Construct a descriptor without opening it.
-  /**
-   * This constructor creates a descriptor without opening it.
-   *
-   * @param ex The I/O executor that the descriptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * descriptor.
-   */
-  explicit basic_descriptor(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct a descriptor without opening it.
-  /**
-   * This constructor creates a descriptor without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the descriptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the descriptor.
-   */
-  template <typename ExecutionContext>
-  explicit basic_descriptor(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct a descriptor on an existing native descriptor.
-  /**
-   * This constructor creates a descriptor object to hold an existing native
-   * descriptor.
-   *
-   * @param ex The I/O executor that the descriptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * descriptor.
-   *
-   * @param native_descriptor A native descriptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_descriptor(const executor_type& ex,
-      const native_handle_type& native_descriptor)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_descriptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct a descriptor on an existing native descriptor.
-  /**
-   * This constructor creates a descriptor object to hold an existing native
-   * descriptor.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the descriptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the descriptor.
-   *
-   * @param native_descriptor A native descriptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_descriptor(ExecutionContext& context,
-      const native_handle_type& native_descriptor,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_descriptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct a descriptor from another.
-  /**
-   * This constructor moves a descriptor from one object to another.
-   *
-   * @param other The other descriptor object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_descriptor(const executor_type&)
-   * constructor.
-   */
-  basic_descriptor(basic_descriptor&& other) noexcept
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a descriptor from another.
-  /**
-   * This assignment operator moves a descriptor from one object to another.
-   *
-   * @param other The other descriptor object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_descriptor(const executor_type&)
-   * constructor.
-   */
-  basic_descriptor& operator=(basic_descriptor&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All descriptors have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_descriptor;
-
-  /// Move-construct a basic_descriptor from a descriptor of another executor
-  /// type.
-  /**
-   * This constructor moves a descriptor from one object to another.
-   *
-   * @param other The other basic_descriptor object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_descriptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_descriptor(basic_descriptor<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign a basic_descriptor from a descriptor of another executor type.
-  /**
-   * This assignment operator moves a descriptor from one object to another.
-   *
-   * @param other The other basic_descriptor object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_descriptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_descriptor&
-  > operator=(basic_descriptor<Executor1> && other)
-  {
-    basic_descriptor tmp(std::move(other));
-    impl_ = std::move(tmp.impl_);
-    return *this;
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a descriptor cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a descriptor cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Assign an existing native descriptor to the descriptor.
-  /*
-   * This function opens the descriptor to hold an existing native descriptor.
-   *
-   * @param native_descriptor A native descriptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& native_descriptor)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(),
-        native_descriptor, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native descriptor to the descriptor.
-  /*
-   * This function opens the descriptor to hold an existing native descriptor.
-   *
-   * @param native_descriptor A native descriptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& native_descriptor,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(
-        impl_.get_implementation(), native_descriptor, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the descriptor is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the descriptor.
-  /**
-   * This function is used to close the descriptor. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the descriptor.
-  /**
-   * This function is used to close the descriptor. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the native descriptor representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * descriptor. This is intended to allow access to native descriptor
-   * functionality that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Release ownership of the native descriptor implementation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * descriptor. After calling this function, @c is_open() returns false. The
-   * caller is responsible for closing the descriptor.
-   *
-   * All outstanding asynchronous read or write operations will finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * asio::error::operation_aborted error.
-   */
-  native_handle_type release()
-  {
-    return impl_.get_service().release(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the descriptor.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the descriptor.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform an IO control command on the descriptor.
-  /**
-   * This function is used to execute an IO control command on the descriptor.
-   *
-   * @param command The IO control command to be performed on the descriptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa IoControlCommand @n
-   * asio::posix::descriptor_base::bytes_readable @n
-   * asio::posix::descriptor_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * asio::posix::stream_descriptor::bytes_readable command;
-   * descriptor.io_control(command);
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  void io_control(IoControlCommand& command)
-  {
-    asio::error_code ec;
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    asio::detail::throw_error(ec, "io_control");
-  }
-
-  /// Perform an IO control command on the descriptor.
-  /**
-   * This function is used to execute an IO control command on the descriptor.
-   *
-   * @param command The IO control command to be performed on the descriptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa IoControlCommand @n
-   * asio::posix::descriptor_base::bytes_readable @n
-   * asio::posix::descriptor_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * asio::posix::stream_descriptor::bytes_readable command;
-   * asio::error_code ec;
-   * descriptor.io_control(command, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,
-      asio::error_code& ec)
-  {
-    impl_.get_service().io_control(impl_.get_implementation(), command, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the descriptor.
-  /**
-   * @returns @c true if the descriptor's synchronous operations will fail with
-   * asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return impl_.get_service().non_blocking(impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the descriptor.
-  /**
-   * @param mode If @c true, the descriptor's synchronous operations will fail
-   * with asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the descriptor.
-  /**
-   * @param mode If @c true, the descriptor's synchronous operations will fail
-   * with asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * asio::error::would_block.
-   */
-  ASIO_SYNC_OP_VOID non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().non_blocking(impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Gets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native descriptor. This mode has no effect on the behaviour of the
-   * descriptor object's synchronous operations.
-   *
-   * @returns @c true if the underlying descriptor is in non-blocking mode and
-   * direct system calls may fail with asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the descriptor object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native descriptor.
-   */
-  bool native_non_blocking() const
-  {
-    return impl_.get_service().native_non_blocking(
-        impl_.get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native descriptor. It has no effect on the behaviour of the descriptor
-   * object's synchronous operations.
-   *
-   * @param mode If @c true, the underlying descriptor is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws asio::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  void native_non_blocking(bool mode)
-  {
-    asio::error_code ec;
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native descriptor. It has no effect on the behaviour of the descriptor
-   * object's synchronous operations.
-   *
-   * @param mode If @c true, the underlying descriptor is put into non-blocking
-   * mode and direct system calls may fail with asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  ASIO_SYNC_OP_VOID native_non_blocking(
-      bool mode, asio::error_code& ec)
-  {
-    impl_.get_service().native_non_blocking(
-        impl_.get_implementation(), mode, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Wait for the descriptor to become ready to read, ready to write, or to
-  /// have pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for a descriptor to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired descriptor state.
-   *
-   * @par Example
-   * Waiting for a descriptor to become readable.
-   * @code
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * descriptor.wait(asio::posix::stream_descriptor::wait_read);
-   * @endcode
-   */
-  void wait(wait_type w)
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Wait for the descriptor to become ready to read, ready to write, or to
-  /// have pending error conditions.
-  /**
-   * This function is used to perform a blocking wait for a descriptor to enter
-   * a ready to read, write or error condition state.
-   *
-   * @param w Specifies the desired descriptor state.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * Waiting for a descriptor to become readable.
-   * @code
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * asio::error_code ec;
-   * descriptor.wait(asio::posix::stream_descriptor::wait_read, ec);
-   * @endcode
-   */
-  ASIO_SYNC_OP_VOID wait(wait_type w, asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), w, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Asynchronously wait for the descriptor to become ready to read, ready to
-  /// write, or to have pending error conditions.
-  /**
-   * This function is used to perform an asynchronous wait for a descriptor to
-   * enter a ready to read, write or error condition state. It is an initiating
-   * function for an @ref asynchronous_operation, and always returns
-   * immediately.
-   *
-   * @param w Specifies the desired descriptor state.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the wait completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Example
-   * @code
-   * void wait_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Wait succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * descriptor.async_wait(
-   *     asio::posix::stream_descriptor::wait_read,
-   *     wait_handler);
-   * @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(wait_type w,
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-        declval<initiate_async_wait>(), token, w))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token, w);
-  }
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * This function destroys the descriptor, cancelling any outstanding
-   * asynchronous wait operations associated with the descriptor as if by
-   * calling @c cancel.
-   */
-  ~basic_descriptor()
-  {
-  }
-
-#if defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
-#else // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-  detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
-#endif // defined(ASIO_HAS_IO_URING_AS_DEFAULT)
-
-private:
-  // Disallow copying and assignment.
-  basic_descriptor(const basic_descriptor&) = delete;
-  basic_descriptor& operator=(const basic_descriptor&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_descriptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler, wait_type w) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(), w,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_descriptor* self_;
-  };
-};
-
-} // namespace posix
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_POSIX_BASIC_DESCRIPTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_stream_descriptor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_stream_descriptor.hpp
deleted file mode 100644
index a5cea45..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/basic_stream_descriptor.hpp
+++ /dev/null
@@ -1,559 +0,0 @@
-//
-// posix/basic_stream_descriptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
-#define ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/posix/basic_descriptor.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace posix {
-
-/// Provides stream-oriented descriptor functionality.
-/**
- * The posix::basic_stream_descriptor class template provides asynchronous and
- * blocking stream-oriented descriptor functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * Synchronous @c read_some and @c write_some operations are thread safe with
- * respect to each other, if the underlying operating system calls are also
- * thread safe. This means that it is permitted to perform concurrent calls to
- * these synchronous operations on a single descriptor object. Other synchronous
- * operations, such as @c close, are not thread safe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Executor = any_io_executor>
-class basic_stream_descriptor
-  : public basic_descriptor<Executor>
-{
-private:
-  class initiate_async_write_some;
-  class initiate_async_read_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the descriptor type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The descriptor type when rebound to the specified executor.
-    typedef basic_stream_descriptor<Executor1> other;
-  };
-
-  /// The native representation of a descriptor.
-  typedef typename basic_descriptor<Executor>::native_handle_type
-    native_handle_type;
-
-  /// Construct a stream descriptor without opening it.
-  /**
-   * This constructor creates a stream descriptor without opening it. The
-   * descriptor needs to be opened and then connected or accepted before data
-   * can be sent or received on it.
-   *
-   * @param ex The I/O executor that the descriptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * descriptor.
-   */
-  explicit basic_stream_descriptor(const executor_type& ex)
-    : basic_descriptor<Executor>(ex)
-  {
-  }
-
-  /// Construct a stream descriptor without opening it.
-  /**
-   * This constructor creates a stream descriptor without opening it. The
-   * descriptor needs to be opened and then connected or accepted before data
-   * can be sent or received on it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the descriptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the descriptor.
-   */
-  template <typename ExecutionContext>
-  explicit basic_stream_descriptor(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_descriptor<Executor>(context)
-  {
-  }
-
-  /// Construct a stream descriptor on an existing native descriptor.
-  /**
-   * This constructor creates a stream descriptor object to hold an existing
-   * native descriptor.
-   *
-   * @param ex The I/O executor that the descriptor will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * descriptor.
-   *
-   * @param native_descriptor The new underlying descriptor implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_descriptor(const executor_type& ex,
-      const native_handle_type& native_descriptor)
-    : basic_descriptor<Executor>(ex, native_descriptor)
-  {
-  }
-
-  /// Construct a stream descriptor on an existing native descriptor.
-  /**
-   * This constructor creates a stream descriptor object to hold an existing
-   * native descriptor.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the descriptor will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the descriptor.
-   *
-   * @param native_descriptor The new underlying descriptor implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_descriptor(ExecutionContext& context,
-      const native_handle_type& native_descriptor,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_descriptor<Executor>(context, native_descriptor)
-  {
-  }
-
-  /// Move-construct a stream descriptor from another.
-  /**
-   * This constructor moves a stream descriptor from one object to another.
-   *
-   * @param other The other stream descriptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_descriptor(const executor_type&)
-   * constructor.
-   */
-  basic_stream_descriptor(basic_stream_descriptor&& other) noexcept
-    : basic_descriptor<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a stream descriptor from another.
-  /**
-   * This assignment operator moves a stream descriptor from one object to
-   * another.
-   *
-   * @param other The other stream descriptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_descriptor(const executor_type&)
-   * constructor.
-   */
-  basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
-  {
-    basic_descriptor<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a basic_stream_descriptor from a descriptor of another
-  /// executor type.
-  /**
-   * This constructor moves a descriptor from one object to another.
-   *
-   * @param other The other basic_stream_descriptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_descriptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  basic_stream_descriptor(basic_stream_descriptor<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_descriptor<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_descriptor from a descriptor of another
-  /// executor type.
-  /**
-   * This assignment operator moves a descriptor from one object to another.
-   *
-   * @param other The other basic_stream_descriptor object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_descriptor(const executor_type&)
-   * constructor.
-   */
-  template <typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_stream_descriptor&
-  > operator=(basic_stream_descriptor<Executor1> && other)
-  {
-    basic_descriptor<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Write some data to the descriptor.
-  /**
-   * This function is used to write data to the stream descriptor. The function
-   * call will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the descriptor.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * descriptor.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the descriptor.
-  /**
-   * This function is used to write data to the stream descriptor. The function
-   * call will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the descriptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the stream
-   * descriptor. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the descriptor.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * descriptor.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          initiate_async_write_some(this), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-  /// Read some data from the descriptor.
-  /**
-   * This function is used to read data from the stream descriptor. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * descriptor.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the descriptor.
-  /**
-   * This function is used to read data from the stream descriptor. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the stream
-   * descriptor. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * descriptor.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  class initiate_async_write_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some(basic_stream_descriptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_descriptor* self_;
-  };
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some(basic_stream_descriptor* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_descriptor* self_;
-  };
-};
-
-} // namespace posix
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor.hpp
deleted file mode 100644
index 57b5b25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// posix/descriptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POSIX_DESCRIPTOR_HPP
-#define ASIO_POSIX_DESCRIPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/posix/basic_descriptor.hpp"
-
-namespace asio {
-namespace posix {
-
-/// Typedef for the typical usage of basic_descriptor.
-typedef basic_descriptor<> descriptor;
-
-} // namespace posix
-} // namespace asio
-
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-       // || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_POSIX_DESCRIPTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor_base.hpp
deleted file mode 100644
index 7bc3bc1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/descriptor_base.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// posix/descriptor_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POSIX_DESCRIPTOR_BASE_HPP
-#define ASIO_POSIX_DESCRIPTOR_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/io_control.hpp"
-#include "asio/detail/socket_option.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace posix {
-
-/// The descriptor_base class is used as a base for the descriptor class as a
-/// place to define the associated IO control commands.
-class descriptor_base
-{
-public:
-  /// Wait types.
-  /**
-   * For use with descriptor::wait() and descriptor::async_wait().
-   */
-  enum wait_type
-  {
-    /// Wait for a descriptor to become ready to read.
-    wait_read,
-
-    /// Wait for a descriptor to become ready to write.
-    wait_write,
-
-    /// Wait for a descriptor to have error conditions pending.
-    wait_error
-  };
-
-  /// IO control command to get the amount of data that can be read without
-  /// blocking.
-  /**
-   * Implements the FIONREAD IO control command.
-   *
-   * @par Example
-   * @code
-   * asio::posix::stream_descriptor descriptor(my_context);
-   * ...
-   * asio::descriptor_base::bytes_readable command(true);
-   * descriptor.io_control(command);
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   *
-   * @par Concepts:
-   * IoControlCommand.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined bytes_readable;
-#else
-  typedef asio::detail::io_control::bytes_readable bytes_readable;
-#endif
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~descriptor_base()
-  {
-  }
-};
-
-} // namespace posix
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_POSIX_DESCRIPTOR_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/stream_descriptor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/stream_descriptor.hpp
deleted file mode 100644
index 4855f10..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/posix/stream_descriptor.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// posix/stream_descriptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POSIX_STREAM_DESCRIPTOR_HPP
-#define ASIO_POSIX_STREAM_DESCRIPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/posix/basic_stream_descriptor.hpp"
-
-namespace asio {
-namespace posix {
-
-/// Typedef for the typical usage of a stream-oriented descriptor.
-typedef basic_stream_descriptor<> stream_descriptor;
-
-} // namespace posix
-} // namespace asio
-
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_POSIX_STREAM_DESCRIPTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/post.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/post.hpp
deleted file mode 100644
index 6b534df..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/post.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//
-// post.hpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_POST_HPP
-#define ASIO_POST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/initiate_post.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the object's associated
- * executor. The function object is queued for execution, and is never called
- * from the current thread prior to returning from <tt>post()</tt>.
- *
- * The use of @c post(), rather than @ref defer(), indicates the caller's
- * preference that the function object be eagerly queued for execution.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{}, token)</tt>, where @c Init is a function object type defined
- * as:
- *
- * @code class Init
- * {
- * public:
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex of type @c Ex by
- * performing @code auto ex = get_associated_executor(handler); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(
- *     require(ex, execution::blocking.never),
- *     execution::relationship.fork,
- *     execution::allocator(alloc)
- *   ).execute(std::forward<CompletionHandler>(completion_handler)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.post(
- *     std::forward<CompletionHandler>(completion_handler),
- *     alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
-inline auto post(NullaryToken&& token)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_post>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_post(), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * This function submits an object for execution using the specified executor.
- * The function object is queued for execution, and is never called from the
- * current thread prior to returning from <tt>post()</tt>.
- *
- * The use of @c post(), rather than @ref defer(), indicates the caller's
- * preference that the function object be eagerly queued for execution.
- *
- * @param ex The target executor.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns This function returns <tt>async_initiate<NullaryToken,
- * void()>(Init{ex}, token)</tt>, where @c Init is a function object type
- * defined as:
- *
- * @code class Init
- * {
- * public:
- *   using executor_type = Executor;
- *   explicit Init(const Executor& ex) : ex_(ex) {}
- *   executor_type get_executor() const noexcept { return ex_; }
- *   template <typename CompletionHandler>
- *     void operator()(CompletionHandler&& completion_handler) const;
- * private:
- *   Executor ex_; // exposition only
- * }; @endcode
- *
- * The function call operator of @c Init:
- *
- * @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
- * performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
- *
- * @li Obtains the handler's associated allocator object @c alloc by performing
- * @code auto alloc = get_associated_allocator(handler); @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
- * function object @c f with a member @c executor_ that is initialised with
- * <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
- * handler_ that is a decay-copy of @c completion_handler, and a function call
- * operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
- * @endcode
- *
- * @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
- * function object @c f with a member @c work_ that is initialised with
- * <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
- * @c completion_handler, and a function call operator that performs:
- * @code auto a = get_associated_allocator(handler_);
- * work_.get_executor().dispatch(std::move(handler_), a);
- * work_.reset(); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
- * @code prefer(
- *     require(ex, execution::blocking.never),
- *     execution::relationship.fork,
- *     execution::allocator(alloc)
- *   ).execute(std::move(f)); @endcode
- *
- * @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
- * @code ex.post(std::move(f), alloc); @endcode
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename Executor,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<Executor>>
-inline auto post(const Executor& ex,
-    NullaryToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      (execution::is_executor<Executor>::value
-          && can_require<Executor, execution::blocking_t::never_t>::value)
-        || is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_post_with_executor<Executor>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_post_with_executor<Executor>(ex), token);
-}
-
-/// Submits a completion token or function object for execution.
-/**
- * @param ctx An execution context, from which the target executor is obtained.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler. The function signature of the completion handler must be:
- * @code void handler(); @endcode
- *
- * @returns <tt>post(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
- *
- * @par Completion Signature
- * @code void() @endcode
- */
-template <typename ExecutionContext,
-    ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
-      = default_completion_token_t<typename ExecutionContext::executor_type>>
-inline auto post(ExecutionContext& ctx,
-    NullaryToken&& token = default_completion_token_t<
-      typename ExecutionContext::executor_type>(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<NullaryToken, void()>(
-      declval<detail::initiate_post_with_executor<
-        typename ExecutionContext::executor_type>>(), token))
-{
-  return async_initiate<NullaryToken, void()>(
-      detail::initiate_post_with_executor<
-        typename ExecutionContext::executor_type>(
-          ctx.get_executor()), token);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_POST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prefer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prefer.hpp
deleted file mode 100644
index 3b13d41..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prefer.hpp
+++ /dev/null
@@ -1,577 +0,0 @@
-//
-// prefer.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_PREFER_HPP
-#define ASIO_PREFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/prefer_free.hpp"
-#include "asio/traits/prefer_member.hpp"
-#include "asio/traits/require_free.hpp"
-#include "asio/traits/require_member.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace asio {
-
-/// A customisation point that attempts to apply a property to an object.
-/**
- * The name <tt>prefer</tt> denotes a customisation point object. The
- * expression <tt>asio::prefer(E, P0, Pn...)</tt> for some subexpressions
- * <tt>E</tt> and <tt>P0</tt>, and where <tt>Pn...</tt> represents <tt>N</tt>
- * subexpressions (where <tt>N</tt> is 0 or more, and with types <tt>T =
- * decay_t<decltype(E)></tt> and <tt>Prop0 = decay_t<decltype(P0)></tt>) is
- * expression-equivalent to:
- *
- * @li If <tt>is_applicable_property_v<T, Prop0> && Prop0::is_preferable</tt> is
- *   not a well-formed constant expression with value <tt>true</tt>,
- *   <tt>asio::prefer(E, P0, Pn...)</tt> is ill-formed.
- *
- * @li Otherwise, <tt>E</tt> if <tt>N == 0</tt> and the expression
- *   <tt>Prop0::template static_query_v<T> == Prop0::value()</tt> is a
- *   well-formed constant expression with value <tt>true</tt>.
- *
- * @li Otherwise, <tt>(E).require(P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>(E).require(P0)</tt> is a valid expression.
- *
- * @li Otherwise, <tt>require(E, P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>require(E, P0)</tt> is a valid expression with overload resolution
- *   performed in a context that does not include the declaration of the
- *   <tt>require</tt> customization point object.
- *
- * @li Otherwise, <tt>(E).prefer(P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>(E).prefer(P0)</tt> is a valid expression.
- *
- * @li Otherwise, <tt>prefer(E, P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>prefer(E, P0)</tt> is a valid expression with overload resolution
- *   performed in a context that does not include the declaration of the
- *   <tt>prefer</tt> customization point object.
- *
- * @li Otherwise, <tt>E</tt> if <tt>N == 0</tt>.
- *
- * @li Otherwise,
- *   <tt>asio::prefer(asio::prefer(E, P0), Pn...)</tt>
- *   if <tt>N > 0</tt> and the expression
- *   <tt>asio::prefer(asio::prefer(E, P0), Pn...)</tt>
- *   is a valid expression.
- *
- * @li Otherwise, <tt>asio::prefer(E, P0, Pn...)</tt> is ill-formed.
- */
-inline constexpr unspecified prefer = unspecified;
-
-/// A type trait that determines whether a @c prefer expression is well-formed.
-/**
- * Class template @c can_prefer is a trait that is derived from
- * @c true_type if the expression <tt>asio::prefer(std::declval<T>(),
- * std::declval<Properties>()...)</tt> is well formed; otherwise @c false_type.
- */
-template <typename T, typename... Properties>
-struct can_prefer :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines whether a @c prefer expression will not throw.
-/**
- * Class template @c is_nothrow_prefer is a trait that is derived from
- * @c true_type if the expression <tt>asio::prefer(std::declval<T>(),
- * std::declval<Properties>()...)</tt> is @c noexcept; otherwise @c false_type.
- */
-template <typename T, typename... Properties>
-struct is_nothrow_prefer :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines the result type of a @c prefer expression.
-/**
- * Class template @c prefer_result is a trait that determines the result
- * type of the expression <tt>asio::prefer(std::declval<T>(),
- * std::declval<Properties>()...)</tt>.
- */
-template <typename T, typename... Properties>
-struct prefer_result
-{
-  /// The result of the @c prefer expression.
-  typedef automatically_determined type;
-};
-
-} // namespace asio
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace asio_prefer_fn {
-
-using asio::conditional_t;
-using asio::decay_t;
-using asio::declval;
-using asio::enable_if_t;
-using asio::is_applicable_property;
-using asio::traits::prefer_free;
-using asio::traits::prefer_member;
-using asio::traits::require_free;
-using asio::traits::require_member;
-using asio::traits::static_require;
-
-void prefer();
-void require();
-
-enum overload_type
-{
-  identity,
-  call_require_member,
-  call_require_free,
-  call_prefer_member,
-  call_prefer_free,
-  two_props,
-  n_props,
-  ill_formed
-};
-
-template <typename Impl, typename T, typename Properties,
-    typename = void, typename = void, typename = void, typename = void,
-    typename = void, typename = void, typename = void>
-struct call_traits
-{
-  static constexpr overload_type overload = ill_formed;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    static_require<T, Property>::is_valid
-  >>
-{
-  static constexpr overload_type overload = identity;
-  static constexpr bool is_noexcept = true;
-
-  typedef T&& result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >> :
-  require_member<typename Impl::template proxy<T>::type, Property>
-{
-  static constexpr overload_type overload = call_require_member;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    require_free<T, Property>::is_valid
-  >> :
-  require_free<T, Property>
-{
-  static constexpr overload_type overload = call_require_free;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_free<T, Property>::is_valid
-  >,
-  enable_if_t<
-    prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >> :
-  prefer_member<typename Impl::template proxy<T>::type, Property>
-{
-  static constexpr overload_type overload = call_prefer_member;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_free<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    prefer_free<T, Property>::is_valid
-  >> :
-  prefer_free<T, Property>
-{
-  static constexpr overload_type overload = call_prefer_free;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_preferable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_free<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    !prefer_free<T, Property>::is_valid
-  >>
-{
-  static constexpr overload_type overload = identity;
-  static constexpr bool is_noexcept = true;
-
-  typedef T&& result_type;
-};
-
-template <typename Impl, typename T, typename P0, typename P1>
-struct call_traits<Impl, T, void(P0, P1),
-  enable_if_t<
-    call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >,
-  enable_if_t<
-    call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1)
-    >::overload != ill_formed
-  >>
-{
-  static constexpr overload_type overload = two_props;
-
-  static constexpr bool is_noexcept =
-    (
-      call_traits<Impl, T, void(P0)>::is_noexcept
-      &&
-      call_traits<
-        Impl,
-        typename call_traits<Impl, T, void(P0)>::result_type,
-        void(P1)
-      >::is_noexcept
-    );
-
-  typedef decay_t<
-    typename call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1)
-    >::result_type
-  > result_type;
-};
-
-template <typename Impl, typename T, typename P0,
-    typename P1, typename... PN>
-struct call_traits<Impl, T, void(P0, P1, PN...),
-  enable_if_t<
-    call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >,
-  enable_if_t<
-    call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN...)
-    >::overload != ill_formed
-  >>
-{
-  static constexpr overload_type overload = n_props;
-
-  static constexpr bool is_noexcept =
-    (
-      call_traits<Impl, T, void(P0)>::is_noexcept
-      &&
-      call_traits<
-        Impl,
-        typename call_traits<Impl, T, void(P0)>::result_type,
-        void(P1, PN...)
-      >::is_noexcept
-    );
-
-  typedef decay_t<
-    typename call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN...)
-    >::result_type
-  > result_type;
-};
-
-struct impl
-{
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) \
-  && defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto require(P&& p)
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
-        );
-
-      template <typename P>
-      auto prefer(P&& p)
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().prefer(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().prefer(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-      //   && defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-       //   && defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-  };
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == identity,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&&) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t);
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_require_member,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t).require(static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_require_free,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return require(static_cast<T&&>(t), static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_prefer_member,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t).prefer(static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_prefer_free,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return prefer(static_cast<T&&>(t), static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename P0, typename P1>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(P0, P1)>::overload == two_props,
-    typename call_traits<impl, T, void(P0, P1)>::result_type
-  >
-  operator()(T&& t, P0&& p0, P1&& p1) const
-    noexcept(call_traits<impl, T, void(P0, P1)>::is_noexcept)
-  {
-    return (*this)(
-        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
-        static_cast<P1&&>(p1));
-  }
-
-  template <typename T, typename P0, typename P1,
-    typename... PN>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(P0, P1, PN...)>::overload == n_props,
-    typename call_traits<impl, T, void(P0, P1, PN...)>::result_type
-  >
-  operator()(T&& t, P0&& p0, P1&& p1, PN&&... pn) const
-    noexcept(call_traits<impl, T, void(P0, P1, PN...)>::is_noexcept)
-  {
-    return (*this)(
-        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
-        static_cast<P1&&>(p1), static_cast<PN&&>(pn)...);
-  }
-};
-
-template <typename T = impl>
-struct static_instance
-{
-  static const T instance;
-};
-
-template <typename T>
-const T static_instance<T>::instance = {};
-
-} // namespace asio_prefer_fn
-namespace asio {
-namespace {
-
-static constexpr const asio_prefer_fn::impl&
-  prefer = asio_prefer_fn::static_instance<>::instance;
-
-} // namespace
-
-typedef asio_prefer_fn::impl prefer_t;
-
-template <typename T, typename... Properties>
-struct can_prefer :
-  integral_constant<bool,
-    asio_prefer_fn::call_traits<
-      prefer_t, T, void(Properties...)>::overload
-        != asio_prefer_fn::ill_formed>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-constexpr bool can_prefer_v
-  = can_prefer<T, Properties...>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-struct is_nothrow_prefer :
-  integral_constant<bool,
-    asio_prefer_fn::call_traits<
-      prefer_t, T, void(Properties...)>::is_noexcept>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-constexpr bool is_nothrow_prefer_v = is_nothrow_prefer<T, Properties...>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-struct prefer_result
-{
-  typedef typename asio_prefer_fn::call_traits<
-      prefer_t, T, void(Properties...)>::result_type type;
-};
-
-template <typename T, typename... Properties>
-using prefer_result_t = typename prefer_result<T, Properties...>::type;
-
-} // namespace asio
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_PREFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prepend.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prepend.hpp
deleted file mode 100644
index 972b47f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/prepend.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// prepend.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_PREPEND_HPP
-#define ASIO_PREPEND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <tuple>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values before the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-class prepend_t
-{
-public:
-  /// Constructor.
-  template <typename T, typename... V>
-  constexpr explicit prepend_t(T&& completion_token, V&&... values)
-    : token_(static_cast<T&&>(completion_token)),
-      values_(static_cast<V&&>(values)...)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  std::tuple<Values...> values_;
-};
-
-/// Completion token type used to specify that the completion handler
-/// arguments should be passed additional values before the results of the
-/// operation.
-template <typename CompletionToken, typename... Values>
-ASIO_NODISCARD inline constexpr
-prepend_t<decay_t<CompletionToken>, decay_t<Values>...>
-prepend(CompletionToken&& completion_token,
-    Values&&... values)
-{
-  return prepend_t<decay_t<CompletionToken>, decay_t<Values>...>(
-      static_cast<CompletionToken&&>(completion_token),
-      static_cast<Values&&>(values)...);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/prepend.hpp"
-
-#endif // ASIO_PREPEND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/query.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/query.hpp
deleted file mode 100644
index c27d26a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/query.hpp
+++ /dev/null
@@ -1,311 +0,0 @@
-//
-// query.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_QUERY_HPP
-#define ASIO_QUERY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/query_member.hpp"
-#include "asio/traits/query_free.hpp"
-#include "asio/traits/static_query.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace asio {
-
-/// A customisation point that queries the value of a property.
-/**
- * The name <tt>query</tt> denotes a customization point object. The
- * expression <tt>asio::query(E, P)</tt> for some
- * subexpressions <tt>E</tt> and <tt>P</tt> (with types <tt>T =
- * decay_t<decltype(E)></tt> and <tt>Prop = decay_t<decltype(P)></tt>) is
- * expression-equivalent to:
- *
- * @li If <tt>is_applicable_property_v<T, Prop></tt> is not a well-formed
- *   constant expression with value <tt>true</tt>, <tt>asio::query(E,
- *   P)</tt> is ill-formed.
- *
- * @li Otherwise, <tt>Prop::template static_query_v<T></tt> if the expression
- *   <tt>Prop::template static_query_v<T></tt> is a well-formed constant
- *   expression.
- *
- * @li Otherwise, <tt>(E).query(P)</tt> if the expression
- *   <tt>(E).query(P)</tt> is well-formed.
- *
- * @li Otherwise, <tt>query(E, P)</tt> if the expression
- *   <tt>query(E, P)</tt> is a valid expression with overload
- *   resolution performed in a context that does not include the declaration
- *   of the <tt>query</tt> customization point object.
- *
- * @li Otherwise, <tt>asio::query(E, P)</tt> is ill-formed.
- */
-inline constexpr unspecified query = unspecified;
-
-/// A type trait that determines whether a @c query expression is well-formed.
-/**
- * Class template @c can_query is a trait that is derived from
- * @c true_type if the expression <tt>asio::query(std::declval<T>(),
- * std::declval<Property>())</tt> is well formed; otherwise @c false_type.
- */
-template <typename T, typename Property>
-struct can_query :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines whether a @c query expression will
-/// not throw.
-/**
- * Class template @c is_nothrow_query is a trait that is derived from
- * @c true_type if the expression <tt>asio::query(std::declval<T>(),
- * std::declval<Property>())</tt> is @c noexcept; otherwise @c false_type.
- */
-template <typename T, typename Property>
-struct is_nothrow_query :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines the result type of a @c query expression.
-/**
- * Class template @c query_result is a trait that determines the result
- * type of the expression <tt>asio::query(std::declval<T>(),
- * std::declval<Property>())</tt>.
- */
-template <typename T, typename Property>
-struct query_result
-{
-  /// The result of the @c query expression.
-  typedef automatically_determined type;
-};
-
-} // namespace asio
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace asio_query_fn {
-
-using asio::conditional_t;
-using asio::decay_t;
-using asio::declval;
-using asio::enable_if_t;
-using asio::is_applicable_property;
-using asio::traits::query_free;
-using asio::traits::query_member;
-using asio::traits::static_query;
-
-void query();
-
-enum overload_type
-{
-  static_value,
-  call_member,
-  call_free,
-  ill_formed
-};
-
-template <typename Impl, typename T, typename Properties,
-    typename = void, typename = void, typename = void, typename = void>
-struct call_traits
-{
-  static constexpr overload_type overload = ill_formed;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    static_query<T, Property>::is_valid
-  >> :
-  static_query<T, Property>
-{
-  static constexpr overload_type overload = static_value;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    !static_query<T, Property>::is_valid
-  >,
-  enable_if_t<
-    query_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >> :
-  query_member<typename Impl::template proxy<T>::type, Property>
-{
-  static constexpr overload_type overload = call_member;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    !static_query<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !query_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    query_free<T, Property>::is_valid
-  >> :
-  query_free<T, Property>
-{
-  static constexpr overload_type overload = call_free;
-};
-
-struct impl
-{
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto query(P&& p)
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().query(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-  };
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == static_value,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&&, Property&&) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_query<decay_t<T>, decay_t<Property>>::value();
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_member,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t).query(static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_free,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return query(static_cast<T&&>(t), static_cast<Property&&>(p));
-  }
-};
-
-template <typename T = impl>
-struct static_instance
-{
-  static const T instance;
-};
-
-template <typename T>
-const T static_instance<T>::instance = {};
-
-} // namespace asio_query_fn
-namespace asio {
-namespace {
-
-static constexpr const asio_query_fn::impl&
-  query = asio_query_fn::static_instance<>::instance;
-
-} // namespace
-
-typedef asio_query_fn::impl query_t;
-
-template <typename T, typename Property>
-struct can_query :
-  integral_constant<bool,
-    asio_query_fn::call_traits<query_t, T, void(Property)>::overload !=
-      asio_query_fn::ill_formed>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-constexpr bool can_query_v = can_query<T, Property>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-struct is_nothrow_query :
-  integral_constant<bool,
-    asio_query_fn::call_traits<query_t, T, void(Property)>::is_noexcept>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-constexpr bool is_nothrow_query_v = is_nothrow_query<T, Property>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-struct query_result
-{
-  typedef typename asio_query_fn::call_traits<
-      query_t, T, void(Property)>::result_type type;
-};
-
-template <typename T, typename Property>
-using query_result_t = typename query_result<T, Property>::type;
-
-} // namespace asio
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_QUERY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/random_access_file.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/random_access_file.hpp
deleted file mode 100644
index c638e33..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/random_access_file.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// random_access_file.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_RANDOM_ACCESS_FILE_HPP
-#define ASIO_RANDOM_ACCESS_FILE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_random_access_file.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a random-access file.
-typedef basic_random_access_file<> random_access_file;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_RANDOM_ACCESS_FILE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read.hpp
deleted file mode 100644
index cf9141b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read.hpp
+++ /dev/null
@@ -1,1547 +0,0 @@
-//
-// read.hpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_READ_HPP
-#define ASIO_READ_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS)
-# include "asio/basic_streambuf_fwd.hpp"
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_read;
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_read_dynbuf_v1;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_read_dynbuf_v2;
-
-} // namespace detail
-
-/**
- * @defgroup read asio::read
- *
- * @brief The @c read function is a composed operation that reads a certain
- * amount of data from a stream before returning.
- */
-/*@{*/
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read(s, asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncReadStream, typename MutableBufferSequence>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read(s, asio::buffer(data, size), ec); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename MutableBufferSequence>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read(s, asio::buffer(data, size),
- *     asio::transfer_at_least(32)); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
-template <typename SyncReadStream, typename MutableBufferSequence,
-  typename CompletionCondition>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncReadStream, typename MutableBufferSequence,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, b,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, b,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    asio::error_code& ec);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncReadStream, typename Allocator,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncReadStream, typename Allocator,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data from a stream before returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * stream. The call will block until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's read_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t read(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/*@}*/
-/**
- * @defgroup async_read asio::async_read
- *
- * @brief The @c async_read function is a composed asynchronous operation that
- * reads a certain amount of data from a stream before completion.
- */
-/*@{*/
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream. Although the buffers object may be copied as necessary, ownership of
- * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::async_read(s, asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read(
- *     s, buffers,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename MutableBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read<AsyncReadStream>>(),
-        token, buffers, transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read<AsyncReadStream>(s),
-      token, buffers, transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream. Although the buffers object may be copied as necessary, ownership of
- * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's async_read_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::async_read(s,
- *     asio::buffer(data, size),
- *     asio::transfer_at_least(32),
- *     handler); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename MutableBufferSequence, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_mutable_buffer_sequence<MutableBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read<AsyncReadStream>>(),
-        token, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read<AsyncReadStream>(s), token, buffers,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read(
- *     s, buffers,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's async_read_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename DynamicBuffer_v1, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A basic_streambuf object into which the data will be read. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read(
- *     s, b,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b), transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A basic_streambuf object into which the data will be read. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's async_read_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename Allocator, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read(
- *     s, buffers,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers), transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers), transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data from a
-/// stream.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The specified dynamic buffer sequence is full (that is, it has reached
- * maximum size).
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other read operations (such
- * as async_read, the stream's async_read_some function, or any other composed
- * operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the stream's async_read_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename DynamicBuffer_v2, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_dynbuf_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_dynbuf_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/read.hpp"
-
-#endif // ASIO_READ_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_at.hpp
deleted file mode 100644
index fd96b1a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_at.hpp
+++ /dev/null
@@ -1,828 +0,0 @@
-//
-// read_at.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_READ_AT_HPP
-#define ASIO_READ_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS)
-# include "asio/basic_streambuf_fwd.hpp"
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_read_at;
-#if !defined(ASIO_NO_IOSTREAM)
-template <typename> class initiate_async_read_at_streambuf;
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace detail
-
-/**
- * @defgroup read_at asio::read_at
- *
- * @brief The @c read_at function is a composed operation that reads a certain
- * amount of data at the specified offset before returning.
- */
-/*@{*/
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read_at(d, 42, asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read_at(
- *     d, 42, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read_at(d, 42,
- *     asio::buffer(data, size), ec); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read_at(
- *     d, 42, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    asio::error_code& ec);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's read_some_at function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::read_at(d, 42, asio::buffer(data, size),
- *     asio::transfer_at_least(32)); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's read_some_at function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read_at(
- *     d, 42, b,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncRandomAccessReadDevice, typename Allocator>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::read_at(
- *     d, 42, b,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncRandomAccessReadDevice, typename Allocator>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    asio::error_code& ec);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's read_some_at function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncRandomAccessReadDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Attempt to read a certain amount of data at the specified offset before
-/// returning.
-/**
- * This function is used to read a certain number of bytes of data from a
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's read_some_at function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes read. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncRandomAccessReadDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t read_at(SyncRandomAccessReadDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-/**
- * @defgroup async_read_at asio::async_read_at
- *
- * @brief The @c async_read_at function is a composed asynchronous operation
- * that reads a certain amount of data at the specified offset.
- */
-/*@{*/
-
-/// Start an asynchronous operation to read a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. It is an
- * initiating function for an @ref asynchronous_operation, and always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the AsyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device. Although the buffers object may be copied as necessary, ownership of
- * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::async_read_at(d, 42, asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read_at(
- *     d, 42, buffers,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessReadDevice type's
- * async_read_some_at operation.
- */
-template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncRandomAccessReadDevice::executor_type>>
-inline auto async_read_at(AsyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>(),
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice>>(),
-        token, offset, buffers, transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
-      token, offset, buffers, transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. It is an
- * initiating function for an @ref asynchronous_operation, and always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
- *
- * @li The supplied buffers are full. That is, the bytes transferred is equal to
- * the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * @param d The device from which the data is to be read. The type must support
- * the AsyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device. Although the buffers object may be copied as necessary, ownership of
- * the underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's async_read_some_at function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code asio::async_read_at(d, 42,
- *     asio::buffer(data, size),
- *     asio::transfer_at_least(32),
- *     handler); @endcode
- * See the @ref buffer documentation for information on reading into multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessReadDevice type's
- * async_read_some_at operation.
- */
-template <typename AsyncRandomAccessReadDevice,
-    typename MutableBufferSequence, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncRandomAccessReadDevice::executor_type>>
-inline auto async_read_at(AsyncRandomAccessReadDevice& d,
-    uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_at<AsyncRandomAccessReadDevice>>(),
-        token, offset, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at<AsyncRandomAccessReadDevice>(d),
-      token, offset, buffers,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Start an asynchronous operation to read a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. It is an
- * initiating function for an @ref asynchronous_operation, and always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the AsyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b A basic_streambuf object into which the data will be read. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note This overload is equivalent to calling:
- * @code asio::async_read_at(
- *     d, 42, b,
- *     asio::transfer_all(),
- *     handler); @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessReadDevice type's
- * async_read_some_at operation.
- */
-template <typename AsyncRandomAccessReadDevice, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncRandomAccessReadDevice::executor_type>>
-inline auto async_read_at(AsyncRandomAccessReadDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>(),
-    constraint_t<
-      !is_completion_condition<ReadToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_at_streambuf<
-          AsyncRandomAccessReadDevice>>(),
-        token, offset, &b, transfer_all()))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      token, offset, &b, transfer_all());
-}
-
-/// Start an asynchronous operation to read a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously read a certain number of bytes of
- * data from a random access device at the specified offset. It is an
- * initiating function for an @ref asynchronous_operation, and always returns
- * immediately. The asynchronous operation will continue until one of the
- * following conditions is true:
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the AsyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b A basic_streambuf object into which the data will be read. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the read operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_read_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the read operation is complete. A non-zero
- * return value indicates the maximum number of bytes to be read on the next
- * call to the device's async_read_some_at function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes copied into the buffers. If an error
- *   // occurred, this will be the number of bytes successfully
- *   // transferred prior to the error.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessReadDevice type's
- * async_read_some_at operation.
- */
-template <typename AsyncRandomAccessReadDevice,
-    typename Allocator, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncRandomAccessReadDevice::executor_type>>
-inline auto async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
-    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessReadDevice::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_at_streambuf<
-          AsyncRandomAccessReadDevice>>(),
-        token, offset, &b,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d),
-      token, offset, &b,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/read_at.hpp"
-
-#endif // ASIO_READ_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_until.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_until.hpp
deleted file mode 100644
index bb2ca9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/read_until.hpp
+++ /dev/null
@@ -1,3202 +0,0 @@
-//
-// read_until.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_READ_UNTIL_HPP
-#define ASIO_READ_UNTIL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <string>
-#include "asio/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/regex_fwd.hpp"
-#include "asio/detail/string_view.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS)
-# include "asio/basic_streambuf_fwd.hpp"
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-char (&has_result_type_helper(...))[2];
-
-template <typename T>
-char has_result_type_helper(T*, typename T::result_type* = 0);
-
-template <typename T>
-struct has_result_type
-{
-  enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
-};
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_read_until_delim_v1;
-template <typename> class initiate_async_read_until_delim_string_v1;
-#if defined(ASIO_HAS_BOOST_REGEX)
-template <typename> class initiate_async_read_until_expr_v1;
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-template <typename> class initiate_async_read_until_match_v1;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_read_until_delim_v2;
-template <typename> class initiate_async_read_until_delim_string_v2;
-#if defined(ASIO_HAS_BOOST_REGEX)
-template <typename> class initiate_async_read_until_expr_v2;
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-template <typename> class initiate_async_read_until_match_v2;
-
-} // namespace detail
-
-/// Type trait used to determine whether a type can be used as a match condition
-/// function with read_until and async_read_until.
-template <typename T>
-struct is_match_condition
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// The value member is true if the type may be used as a match condition.
-  static const bool value;
-#else
-  enum
-  {
-    value = asio::is_function<remove_pointer_t<T>>::value
-      || detail::has_result_type<T>::value
-  };
-#endif
-};
-
-/**
- * @defgroup read_until asio::read_until
- *
- * @brief The @c read_until function is a composed operation that reads data
- * into a dynamic buffer sequence, or into a streambuf, until it contains a
- * delimiter, matches a regular expression, or a function object indicates a
- * match.
- */
-/*@{*/
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a newline is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), '\n');
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers, char delim,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    char delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a CR-LF sequence is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), "\r\n");
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a dynamic buffer sequence until some part of the data it
-/// contains matches a regular expression.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains some data
- * that matches a regular expression. The call will block until one of the
- * following conditions is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the
- * regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains data that matches the regular expression, the function returns
- * immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the substring that matches the regular expression.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a CR-LF sequence is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), boost::regex("\r\n"));
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v1&& buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until some part of the data it
-/// contains matches a regular expression.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains some data
- * that matches a regular expression. The call will block until one of the
- * following conditions is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the
- * regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains data that matches the regular expression, the function returns
- * immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the substring that matches the regular expression. Returns 0
- * if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v1, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v1&& buffers,
-    const boost::basic_regex<char, Traits>& expr, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a dynamic buffer sequence until a function object indicates a
-/// match.
-
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until a user-defined match condition function object, when applied
- * to the data contained in the dynamic buffer sequence, indicates a successful
- * match. The call will block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<typename DynamicBuffer_v1::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @returns The number of bytes in the dynamic_buffer's get area that
- * have been fully consumed by the match function.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the function object.
- * An application will typically leave that data in the dynamic buffer sequence
- * for a subsequent read_until operation to examine.
-
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To read data into a dynamic buffer sequence until whitespace is encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::const_buffers_1> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * std::string data;
- * asio::read_until(s, data, match_whitespace);
- * @endcode
- *
- * To read data into a @c std::string until a matching character is found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * std::string data;
- * asio::read_until(s, data, match_char('a'));
- * @endcode
- */
-template <typename SyncReadStream,
-    typename DynamicBuffer_v1, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    MatchCondition match_condition,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until a function object indicates a
-/// match.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until a user-defined match condition function object, when applied
- * to the data contained in the dynamic buffer sequence, indicates a successful
- * match. The call will block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<DynamicBuffer_v1::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area that
- * have been fully consumed by the match function. Returns 0 if an error
- * occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the function object.
- * An application will typically leave that data in the dynamic buffer sequence
- * for a subsequent read_until operation to examine.
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- */
-template <typename SyncReadStream,
-    typename DynamicBuffer_v1, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Read data into a streambuf until it contains a specified delimiter.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
- *
- * @par Example
- * To read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, '\n');
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim);
-
-/// Read data into a streambuf until it contains a specified delimiter.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    asio::error_code& ec);
-
-/// Read data into a streambuf until it contains a specified delimiter.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
- *
- * @par Example
- * To read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, "\r\n");
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    ASIO_STRING_VIEW_PARAM delim);
-
-/// Read data into a streambuf until it contains a specified delimiter.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains the specified delimiter. The call will block
- * until one of the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains the
- * delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond the delimiter. An application will typically leave
- * that data in the streambuf for a subsequent read_until operation to examine.
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec);
-
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a streambuf until some part of the data it contains matches
-/// a regular expression.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains some data that matches a regular expression.
- * The call will block until one of the following conditions is true:
- *
- * @li A substring of the streambuf's get area matches the regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains data that
- * matches the regular expression, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the substring that matches the regular expression.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the regular expression. An
- * application will typically leave that data in the streambuf for a subsequent
- * read_until operation to examine.
- *
- * @par Example
- * To read data into a streambuf until a CR-LF sequence is encountered:
- * @code asio::streambuf b;
- * asio::read_until(s, b, boost::regex("\r\n"));
- * std::istream is(&b);
- * std::string line;
- * std::getline(is, line); @endcode
- * After the @c read_until operation completes successfully, the buffer @c b
- * contains the data which matched the regular expression:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename Allocator, typename Traits>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    const boost::basic_regex<char, Traits>& expr);
-
-/// Read data into a streambuf until some part of the data it contains matches
-/// a regular expression.
-/**
- * This function is used to read data into the specified streambuf until the
- * streambuf's get area contains some data that matches a regular expression.
- * The call will block until one of the following conditions is true:
- *
- * @li A substring of the streambuf's get area matches the regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the streambuf's get area already contains data that
- * matches the regular expression, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the streambuf's get area up to and including
- * the substring that matches the regular expression. Returns 0 if an error
- * occurred.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the regular expression. An
- * application will typically leave that data in the streambuf for a subsequent
- * read_until operation to examine.
- */
-template <typename SyncReadStream, typename Allocator, typename Traits>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    const boost::basic_regex<char, Traits>& expr,
-    asio::error_code& ec);
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a streambuf until a function object indicates a match.
-/**
- * This function is used to read data into the specified streambuf until a
- * user-defined match condition function object, when applied to the data
- * contained in the streambuf, indicates a successful match. The call will
- * block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @returns The number of bytes in the streambuf's get area that have been fully
- * consumed by the match function.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the function object. An application
- * will typically leave that data in the streambuf for a subsequent read_until
- * operation to examine.
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To read data into a streambuf until whitespace is encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::streambuf::const_buffers_type> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * asio::streambuf b;
- * asio::read_until(s, b, match_whitespace);
- * @endcode
- *
- * To read data into a streambuf until a matching character is found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * asio::streambuf b;
- * asio::read_until(s, b, match_char('a'));
- * @endcode
- */
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
-    constraint_t<is_match_condition<MatchCondition>::value> = 0);
-
-/// Read data into a streambuf until a function object indicates a match.
-/**
- * This function is used to read data into the specified streambuf until a
- * user-defined match condition function object, when applied to the data
- * contained in the streambuf, indicates a successful match. The call will
- * block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the streambuf's get area that have been fully
- * consumed by the match function. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the streambuf may contain
- * additional data beyond that which matched the function object. An application
- * will typically leave that data in the streambuf for a subsequent read_until
- * operation to examine.
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- */
-template <typename SyncReadStream, typename Allocator, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<is_match_condition<MatchCondition>::value> = 0);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a newline is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), '\n');
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers, char delim,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter character.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    char delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a CR-LF sequence is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), "\r\n");
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until it contains a specified
-/// delimiter.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains the specified
- * delimiter. The call will block until one of the following conditions is
- * true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains the delimiter, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- *
- * @param delim The delimiter string.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the delimiter. Returns 0 if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond the delimiter. An application will
- * typically leave that data in the dynamic buffer sequence for a subsequent
- * read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    ASIO_STRING_VIEW_PARAM delim, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a dynamic buffer sequence until some part of the data it
-/// contains matches a regular expression.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains some data
- * that matches a regular expression. The call will block until one of the
- * following conditions is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the
- * regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains data that matches the regular expression, the function returns
- * immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the substring that matches the regular expression.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent read_until operation to examine.
- *
- * @par Example
- * To read data into a @c std::string until a CR-LF sequence is encountered:
- * @code std::string data;
- * std::size_t n = asio::read_until(s,
- *     asio::dynamic_buffer(data), boost::regex("\r\n"));
- * std::string line = data.substr(0, n);
- * data.erase(0, n); @endcode
- * After the @c read_until operation completes successfully, the string @c data
- * contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c b as
- * follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c read_until operation.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until some part of the data it
-/// contains matches a regular expression.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until the dynamic buffer sequence's get area contains some data
- * that matches a regular expression. The call will block until one of the
- * following conditions is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the
- * regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the dynamic buffer sequence's get area already
- * contains data that matches the regular expression, the function returns
- * immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param expr The regular expression.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area up to
- * and including the substring that matches the regular expression. Returns 0
- * if an error occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent read_until operation to examine.
- */
-template <typename SyncReadStream, typename DynamicBuffer_v2, typename Traits>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::basic_regex<char, Traits>& expr, asio::error_code& ec,
-    constraint_t<
-        is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Read data into a dynamic buffer sequence until a function object indicates a
-/// match.
-
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until a user-defined match condition function object, when applied
- * to the data contained in the dynamic buffer sequence, indicates a successful
- * match. The call will block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<typename DynamicBuffer_v2::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @returns The number of bytes in the dynamic_buffer's get area that
- * have been fully consumed by the match function.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the function object.
- * An application will typically leave that data in the dynamic buffer sequence
- * for a subsequent read_until operation to examine.
-
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To read data into a dynamic buffer sequence until whitespace is encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::const_buffers_1> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * std::string data;
- * asio::read_until(s, data, match_whitespace);
- * @endcode
- *
- * To read data into a @c std::string until a matching character is found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * std::string data;
- * asio::read_until(s, data, match_char('a'));
- * @endcode
- */
-template <typename SyncReadStream,
-    typename DynamicBuffer_v2, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    MatchCondition match_condition,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Read data into a dynamic buffer sequence until a function object indicates a
-/// match.
-/**
- * This function is used to read data into the specified dynamic buffer
- * sequence until a user-defined match condition function object, when applied
- * to the data contained in the dynamic buffer sequence, indicates a successful
- * match. The call will block until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function. If the match condition function object already indicates
- * a match, the function returns immediately.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers A dynamic buffer sequence into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<DynamicBuffer_v2::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes in the dynamic buffer sequence's get area that
- * have been fully consumed by the match function. Returns 0 if an error
- * occurred.
- *
- * @note After a successful read_until operation, the dynamic buffer sequence
- * may contain additional data beyond that which matched the function object.
- * An application will typically leave that data in the dynamic buffer sequence
- * for a subsequent read_until operation to examine.
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- */
-template <typename SyncReadStream,
-    typename DynamicBuffer_v2, typename MatchCondition>
-std::size_t read_until(SyncReadStream& s, DynamicBuffer_v2 buffers,
-    MatchCondition match_condition, asio::error_code& ec,
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-/**
- * @defgroup async_read_until asio::async_read_until
- *
- * @brief The @c async_read_until function is a composed asynchronous operation
- * that reads data into a dynamic buffer sequence, or into a streambuf, until
- * it contains a delimiter, matches a regular expression, or a function object
- * indicates a match.
- */
-/*@{*/
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until it contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains the delimiter, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param delim The delimiter character.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area up to and including the delimiter.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond the delimiter. An application
- * will typically leave that data in the dynamic buffer sequence for a
- * subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a newline is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data, '\n', handler); @endcode
- * After the @c async_read_until operation completes successfully, the buffer
- * @c data contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    DynamicBuffer_v1&& buffers, char delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers), delim))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers), delim);
-}
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until it contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains the delimiter, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param delim The delimiter string.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area up to and including the delimiter.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond the delimiter. An application
- * will typically leave that data in the dynamic buffer sequence for a
- * subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a CR-LF sequence is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data, "\r\n", handler); @endcode
- * After the @c async_read_until operation completes successfully, the string
- * @c data contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the string @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v1,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    DynamicBuffer_v1&& buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_string_v1<
-          AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers),
-        static_cast<std::string>(delim)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_string_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers),
-      static_cast<std::string>(delim));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until some part of its data matches a regular expression.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains some
- * data that matches a regular expression. It is an initiating function for an
- * @ref asynchronous_operation, and always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the regular
- * expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains data that matches
- * the regular expression, this asynchronous operation completes immediately.
- * The program must ensure that the stream performs no other read operations
- * (such as async_read, async_read_until, the stream's async_read_some
- * function, or any other composed operations that perform reads) until this
- * operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param expr The regular expression.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer
- *   // sequence's get area up to and including the
- *   // substring that matches the regular expression.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a CR-LF sequence is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data,
- *     boost::regex("\r\n"), handler); @endcode
- * After the @c async_read_until operation completes successfully, the string
- * @c data contains the data which matched the regular expression:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the match,
- * so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the string @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v1, typename Traits,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s, DynamicBuffer_v1&& buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_expr_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers), expr))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_expr_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers), expr);
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until a function object indicates a match.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until a user-defined match condition function object, when
- * applied to the data contained in the dynamic buffer sequence, indicates a
- * successful match. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the match condition function object already indicates a match, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<typename DynamicBuffer_v1::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area that have been fully consumed by the match
- *   // function. O if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond that which matched the function
- * object. An application will typically leave that data in the dynamic buffer
- * sequence for a subsequent async_read_until operation to examine.
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To asynchronously read data into a @c std::string until whitespace is
- * encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::const_buffers_1> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * std::string data;
- * asio::async_read_until(s, data, match_whitespace, handler);
- * @endcode
- *
- * To asynchronously read data into a @c std::string until a matching character
- * is found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * std::string data;
- * asio::async_read_until(s, data, match_char('a'), handler);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename DynamicBuffer_v1, typename MatchCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    DynamicBuffer_v1&& buffers, MatchCondition match_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_match_v1<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers),
-        match_condition))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_match_v1<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers),
-      match_condition);
-}
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Start an asynchronous operation to read data into a streambuf until it
-/// contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified
- * streambuf until the streambuf's get area contains the specified delimiter.
- * It is an initiating function for an @ref asynchronous_operation, and always
- * returns immediately. The asynchronous operation will continue until one of
- * the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the streambuf's get area already contains the delimiter, this asynchronous
- * operation completes immediately. The program must ensure that the stream
- * performs no other read operations (such as async_read, async_read_until, the
- * stream's async_read_some function, or any other composed operations that
- * perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read. Ownership of
- * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the completion handler is called.
- *
- * @param delim The delimiter character.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the streambuf's get
- *   // area up to and including the delimiter.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the streambuf may
- * contain additional data beyond the delimiter. An application will typically
- * leave that data in the streambuf for a subsequent async_read_until operation
- * to examine.
- *
- * @par Example
- * To asynchronously read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::istream is(&b);
- *     std::string line;
- *     std::getline(is, line);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, b, '\n', handler); @endcode
- * After the @c async_read_until operation completes successfully, the buffer
- * @c b contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, char delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>())
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), delim))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b), delim);
-}
-
-/// Start an asynchronous operation to read data into a streambuf until it
-/// contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified
- * streambuf until the streambuf's get area contains the specified delimiter.
- * It is an initiating function for an @ref asynchronous_operation, and always
- * returns immediately. The asynchronous operation will continue until one of
- * the following conditions is true:
- *
- * @li The get area of the streambuf contains the specified delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the streambuf's get area already contains the delimiter, this asynchronous
- * operation completes immediately. The program must ensure that the stream
- * performs no other read operations (such as async_read, async_read_until, the
- * stream's async_read_some function, or any other composed operations that
- * perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read. Ownership of
- * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the completion handler is called.
- *
- * @param delim The delimiter string.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the streambuf's get
- *   // area up to and including the delimiter.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the streambuf may
- * contain additional data beyond the delimiter. An application will typically
- * leave that data in the streambuf for a subsequent async_read_until operation
- * to examine.
- *
- * @par Example
- * To asynchronously read data into a streambuf until a newline is encountered:
- * @code asio::streambuf b;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::istream is(&b);
- *     std::string line;
- *     std::getline(is, line);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, b, "\r\n", handler); @endcode
- * After the @c async_read_until operation completes successfully, the buffer
- * @c b contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    ASIO_STRING_VIEW_PARAM delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>())
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_string_v1<
-          AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b),
-        static_cast<std::string>(delim)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_string_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b),
-      static_cast<std::string>(delim));
-}
-
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a streambuf until some
-/// part of its data matches a regular expression.
-/**
- * This function is used to asynchronously read data into the specified
- * streambuf until the streambuf's get area contains some data that matches a
- * regular expression. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li A substring of the streambuf's get area matches the regular expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the streambuf's get area already contains data that matches the regular
- * expression, this asynchronous operation completes immediately. The program
- * must ensure that the stream performs no other read operations (such as
- * async_read, async_read_until, the stream's async_read_some function, or any
- * other composed operations that perform reads) until this operation
- * completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read. Ownership of
- * the streambuf is retained by the caller, which must guarantee that it remains
- * valid until the completion handler is called.
- *
- * @param expr The regular expression.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the streambuf's get
- *   // area up to and including the substring
- *   // that matches the regular. expression.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the streambuf may
- * contain additional data beyond that which matched the regular expression. An
- * application will typically leave that data in the streambuf for a subsequent
- * async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a streambuf until a CR-LF sequence is
- * encountered:
- * @code asio::streambuf b;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::istream is(&b);
- *     std::string line;
- *     std::getline(is, line);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, b, boost::regex("\r\n"), handler); @endcode
- * After the @c async_read_until operation completes successfully, the buffer
- * @c b contains the data which matched the regular expression:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c std::getline then extracts the data up to and including the
- * newline (which is discarded), so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r' } @endcode
- * The remaining data is left in the buffer @c b as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename Allocator, typename Traits,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b,
-    const boost::basic_regex<char, Traits>& expr,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>())
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_expr_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), expr))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_expr_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b), expr);
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a streambuf until a
-/// function object indicates a match.
-/**
- * This function is used to asynchronously read data into the specified
- * streambuf until a user-defined match condition function object, when applied
- * to the data contained in the streambuf, indicates a successful match. It is
- * an initiating function for an @ref asynchronous_operation, and always
- * returns immediately. The asynchronous operation will continue until one of
- * the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the match condition function object already indicates a match, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param b A streambuf object into which the data will be read.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the streambuf's get
- *   // area that have been fully consumed by the
- *   // match function. O if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @note After a successful async_read_until operation, the streambuf may
- * contain additional data beyond that which matched the function object. An
- * application will typically leave that data in the streambuf for a subsequent
- * async_read_until operation to examine.
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To asynchronously read data into a streambuf until whitespace is encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::streambuf::const_buffers_type> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * asio::streambuf b;
- * asio::async_read_until(s, b, match_whitespace, handler);
- * @endcode
- *
- * To asynchronously read data into a streambuf until a matching character is
- * found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * asio::streambuf b;
- * asio::async_read_until(s, b, match_char('a'), handler);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename Allocator, typename MatchCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<is_match_condition<MatchCondition>::value> = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_match_v1<AsyncReadStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), match_condition))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_match_v1<AsyncReadStream>(s),
-      token, basic_streambuf_ref<Allocator>(b), match_condition);
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until it contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains the delimiter, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param delim The delimiter character.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area up to and including the delimiter.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond the delimiter. An application
- * will typically leave that data in the dynamic buffer sequence for a
- * subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a newline is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data, '\n', handler); @endcode
- * After the @c async_read_until operation completes successfully, the buffer
- * @c data contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the buffer @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    DynamicBuffer_v2 buffers, char delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers), delim))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers), delim);
-}
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until it contains a specified delimiter.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains the
- * specified delimiter. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The get area of the dynamic buffer sequence contains the specified
- * delimiter.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains the delimiter, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param delim The delimiter string.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area up to and including the delimiter.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond the delimiter. An application
- * will typically leave that data in the dynamic buffer sequence for a
- * subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a CR-LF sequence is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data, "\r\n", handler); @endcode
- * After the @c async_read_until operation completes successfully, the string
- * @c data contains the delimiter:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the
- * delimiter, so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the string @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v2,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    ASIO_STRING_VIEW_PARAM delim,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_delim_string_v2<
-          AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers),
-        static_cast<std::string>(delim)))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_delim_string_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers),
-      static_cast<std::string>(delim));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if defined(ASIO_HAS_BOOST_REGEX) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until some part of its data matches a regular expression.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until the dynamic buffer sequence's get area contains some
- * data that matches a regular expression. It is an initiating function for an
- * @ref asynchronous_operation, and always returns immediately. The
- * asynchronous operation will continue until one of the following conditions
- * is true:
- *
- * @li A substring of the dynamic buffer sequence's get area matches the regular
- * expression.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the dynamic buffer sequence's get area already contains data that matches
- * the regular expression, this asynchronous operation completes immediately.
- * The program must ensure that the stream performs no other read operations
- * (such as async_read, async_read_until, the stream's async_read_some
- * function, or any other composed operations that perform reads) until this
- * operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param expr The regular expression.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer
- *   // sequence's get area up to and including the
- *   // substring that matches the regular expression.
- *   // 0 if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond that which matched the regular
- * expression. An application will typically leave that data in the dynamic
- * buffer sequence for a subsequent async_read_until operation to examine.
- *
- * @par Example
- * To asynchronously read data into a @c std::string until a CR-LF sequence is
- * encountered:
- * @code std::string data;
- * ...
- * void handler(const asio::error_code& e, std::size_t size)
- * {
- *   if (!e)
- *   {
- *     std::string line = data.substr(0, n);
- *     data.erase(0, n);
- *     ...
- *   }
- * }
- * ...
- * asio::async_read_until(s, data,
- *     boost::regex("\r\n"), handler); @endcode
- * After the @c async_read_until operation completes successfully, the string
- * @c data contains the data which matched the regular expression:
- * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
- * The call to @c substr then extracts the data up to and including the match,
- * so that the string @c line contains:
- * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
- * After the call to @c erase, the remaining data is left in the string @c data
- * as follows:
- * @code { 'd', 'e', ... } @endcode
- * This data may be the start of a new line, to be extracted by a subsequent
- * @c async_read_until operation.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream, typename DynamicBuffer_v2, typename Traits,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s, DynamicBuffer_v2 buffers,
-    const boost::basic_regex<char, Traits>& expr,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_expr_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers), expr))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_expr_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers), expr);
-}
-
-#endif // defined(ASIO_HAS_BOOST_REGEX)
-       // || defined(GENERATING_DOCUMENTATION)
-
-/// Start an asynchronous operation to read data into a dynamic buffer sequence
-/// until a function object indicates a match.
-/**
- * This function is used to asynchronously read data into the specified dynamic
- * buffer sequence until a user-defined match condition function object, when
- * applied to the data contained in the dynamic buffer sequence, indicates a
- * successful match. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li The match condition function object returns a std::pair where the second
- * element evaluates to true.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_read_some function, and is known as a <em>composed operation</em>. If
- * the match condition function object already indicates a match, this
- * asynchronous operation completes immediately. The program must ensure that
- * the stream performs no other read operations (such as async_read,
- * async_read_until, the stream's async_read_some function, or any other
- * composed operations that perform reads) until this operation completes.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the AsyncReadStream concept.
- *
- * @param buffers The dynamic buffer sequence into which the data will be read.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param match_condition The function object to be called to determine whether
- * a match exists. The signature of the function object must be:
- * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
- * @endcode
- * where @c iterator represents the type:
- * @code buffers_iterator<typename DynamicBuffer_v2::const_buffers_type>
- * @endcode
- * The iterator parameters @c begin and @c end define the range of bytes to be
- * scanned to determine whether there is a match. The @c first member of the
- * return value is an iterator marking one-past-the-end of the bytes that have
- * been consumed by the match function. This iterator is used to calculate the
- * @c begin parameter for any subsequent invocation of the match condition. The
- * @c second member of the return value is true if a match has been found, false
- * otherwise.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the read completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // The number of bytes in the dynamic buffer sequence's
- *   // get area that have been fully consumed by the match
- *   // function. O if an error occurred.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @note After a successful async_read_until operation, the dynamic buffer
- * sequence may contain additional data beyond that which matched the function
- * object. An application will typically leave that data in the dynamic buffer
- * sequence for a subsequent async_read_until operation to examine.
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @note The default implementation of the @c is_match_condition type trait
- * evaluates to true for function pointers and function objects with a
- * @c result_type typedef. It must be specialised for other user-defined
- * function objects.
- *
- * @par Examples
- * To asynchronously read data into a @c std::string until whitespace is
- * encountered:
- * @code typedef asio::buffers_iterator<
- *     asio::const_buffers_1> iterator;
- *
- * std::pair<iterator, bool>
- * match_whitespace(iterator begin, iterator end)
- * {
- *   iterator i = begin;
- *   while (i != end)
- *     if (std::isspace(*i++))
- *       return std::make_pair(i, true);
- *   return std::make_pair(i, false);
- * }
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * std::string data;
- * asio::async_read_until(s, data, match_whitespace, handler);
- * @endcode
- *
- * To asynchronously read data into a @c std::string until a matching character
- * is found:
- * @code class match_char
- * {
- * public:
- *   explicit match_char(char c) : c_(c) {}
- *
- *   template <typename Iterator>
- *   std::pair<Iterator, bool> operator()(
- *       Iterator begin, Iterator end) const
- *   {
- *     Iterator i = begin;
- *     while (i != end)
- *       if (c_ == *i++)
- *         return std::make_pair(i, true);
- *     return std::make_pair(i, false);
- *   }
- *
- * private:
- *   char c_;
- * };
- *
- * namespace asio {
- *   template <> struct is_match_condition<match_char>
- *     : public boost::true_type {};
- * } // namespace asio
- * ...
- * void handler(const asio::error_code& e, std::size_t size);
- * ...
- * std::string data;
- * asio::async_read_until(s, data, match_char('a'), handler);
- * @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncReadStream type's
- * @c async_read_some operation.
- */
-template <typename AsyncReadStream,
-    typename DynamicBuffer_v2, typename MatchCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) ReadToken = default_completion_token_t<
-        typename AsyncReadStream::executor_type>>
-inline auto async_read_until(AsyncReadStream& s,
-    DynamicBuffer_v2 buffers, MatchCondition match_condition,
-    ReadToken&& token = default_completion_token_t<
-      typename AsyncReadStream::executor_type>(),
-    constraint_t<
-      is_match_condition<MatchCondition>::value
-    > = 0,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0)
-  -> decltype(
-    async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_read_until_match_v2<AsyncReadStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers), match_condition))
-{
-  return async_initiate<ReadToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_read_until_match_v2<AsyncReadStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers),
-      match_condition);
-}
-
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/read_until.hpp"
-
-#endif // ASIO_READ_UNTIL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/readable_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/readable_pipe.hpp
deleted file mode 100644
index 19101c2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/readable_pipe.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// readable_pipe.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_READABLE_PIPE_HPP
-#define ASIO_READABLE_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_readable_pipe.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a readable pipe.
-typedef basic_readable_pipe<> readable_pipe;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_PIPE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_READABLE_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/recycling_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/recycling_allocator.hpp
deleted file mode 100644
index b3986c0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/recycling_allocator.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//
-// recycling_allocator.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_RECYCLING_ALLOCATOR_HPP
-#define ASIO_RECYCLING_ALLOCATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/recycling_allocator.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// An allocator that caches memory blocks in thread-local storage for reuse.
-/**
- * The @recycling_allocator uses a simple strategy where a limited number of
- * small memory blocks are cached in thread-local storage, if the current
- * thread is running an @c io_context or is part of a @c thread_pool.
- */
-template <typename T>
-class recycling_allocator
-{
-public:
-  /// The type of object allocated by the recycling allocator.
-  typedef T value_type;
-
-  /// Rebind the allocator to another value_type.
-  template <typename U>
-  struct rebind
-  {
-    /// The rebound @c allocator type.
-    typedef recycling_allocator<U> other;
-  };
-
-  /// Default constructor.
-  constexpr recycling_allocator() noexcept
-  {
-  }
-
-  /// Converting constructor.
-  template <typename U>
-  constexpr recycling_allocator(
-      const recycling_allocator<U>&) noexcept
-  {
-  }
-
-  /// Equality operator. Always returns true.
-  constexpr bool operator==(
-      const recycling_allocator&) const noexcept
-  {
-    return true;
-  }
-
-  /// Inequality operator. Always returns false.
-  constexpr bool operator!=(
-      const recycling_allocator&) const noexcept
-  {
-    return false;
-  }
-
-  /// Allocate memory for the specified number of values.
-  T* allocate(std::size_t n)
-  {
-    return detail::recycling_allocator<T>().allocate(n);
-  }
-
-  /// Deallocate memory for the specified number of values.
-  void deallocate(T* p, std::size_t n)
-  {
-    detail::recycling_allocator<T>().deallocate(p, n);
-  }
-};
-
-/// A proto-allocator that caches memory blocks in thread-local storage for
-/// reuse.
-/**
- * The @recycling_allocator uses a simple strategy where a limited number of
- * small memory blocks are cached in thread-local storage, if the current
- * thread is running an @c io_context or is part of a @c thread_pool.
- */
-template <>
-class recycling_allocator<void>
-{
-public:
-  /// No values are allocated by a proto-allocator.
-  typedef void value_type;
-
-  /// Rebind the allocator to another value_type.
-  template <typename U>
-  struct rebind
-  {
-    /// The rebound @c allocator type.
-    typedef recycling_allocator<U> other;
-  };
-
-  /// Default constructor.
-  constexpr recycling_allocator() noexcept
-  {
-  }
-
-  /// Converting constructor.
-  template <typename U>
-  constexpr recycling_allocator(
-      const recycling_allocator<U>&) noexcept
-  {
-  }
-
-  /// Equality operator. Always returns true.
-  constexpr bool operator==(
-      const recycling_allocator&) const noexcept
-  {
-    return true;
-  }
-
-  /// Inequality operator. Always returns false.
-  constexpr bool operator!=(
-      const recycling_allocator&) const noexcept
-  {
-    return false;
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_RECYCLING_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/redirect_error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/redirect_error.hpp
deleted file mode 100644
index 8b7b446..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/redirect_error.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// redirect_error.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_REDIRECT_ERROR_HPP
-#define ASIO_REDIRECT_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/error_code.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token adapter used to specify that an error produced by an
-/// asynchronous operation is captured to an error_code variable.
-/**
- * The redirect_error_t class is used to indicate that any error_code produced
- * by an asynchronous operation is captured to a specified variable.
- */
-template <typename CompletionToken>
-class redirect_error_t
-{
-public:
-  /// Constructor.
-  template <typename T>
-  redirect_error_t(T&& completion_token, asio::error_code& ec)
-    : token_(static_cast<T&&>(completion_token)),
-      ec_(ec)
-  {
-  }
-
-//private:
-  CompletionToken token_;
-  asio::error_code& ec_;
-};
-
-/// A function object type that adapts a @ref completion_token to capture
-/// error_code values to a variable.
-/**
- * May also be used directly as a completion token, in which case it adapts the
- * asynchronous operation's default completion token (or asio::deferred
- * if no default is available).
- */
-class partial_redirect_error
-{
-public:
-  /// Constructor that specifies the variable used to capture error_code values.
-  explicit partial_redirect_error(asio::error_code& ec)
-    : ec_(ec)
-  {
-  }
-
-  /// Adapt a @ref completion_token to specify that the completion handler
-  /// should capture error_code values to a variable.
-  template <typename CompletionToken>
-  ASIO_NODISCARD inline
-  constexpr redirect_error_t<decay_t<CompletionToken>>
-  operator()(CompletionToken&& completion_token) const
-  {
-    return redirect_error_t<decay_t<CompletionToken>>(
-        static_cast<CompletionToken&&>(completion_token), ec_);
-  }
-
-//private:
-  asio::error_code& ec_;
-};
-
-/// Create a partial completion token adapter that captures error_code values
-/// to a variable.
-ASIO_NODISCARD inline partial_redirect_error
-redirect_error(asio::error_code& ec)
-{
-  return partial_redirect_error(ec);
-}
-
-/// Adapt a @ref completion_token to capture error_code values to a variable.
-template <typename CompletionToken>
-ASIO_NODISCARD inline redirect_error_t<decay_t<CompletionToken>>
-redirect_error(CompletionToken&& completion_token,
-    asio::error_code& ec)
-{
-  return redirect_error_t<decay_t<CompletionToken>>(
-      static_cast<CompletionToken&&>(completion_token), ec);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/redirect_error.hpp"
-
-#endif // ASIO_REDIRECT_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/registered_buffer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/registered_buffer.hpp
deleted file mode 100644
index e298bf6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/registered_buffer.hpp
+++ /dev/null
@@ -1,344 +0,0 @@
-//
-// registered_buffer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_REGISTERED_BUFFER_HPP
-#define ASIO_REGISTERED_BUFFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffer_registration_base;
-
-} // namespace detail
-
-class const_registered_buffer;
-
-/// Type used to identify a registered buffer.
-class registered_buffer_id
-{
-public:
-  /// The native buffer identifier type.
-  typedef int native_handle_type;
-
-  /// Default constructor creates an invalid registered buffer identifier.
-  registered_buffer_id() noexcept
-    : scope_(0),
-      index_(-1)
-  {
-  }
-
-  /// Get the native buffer identifier type.
-  native_handle_type native_handle() const noexcept
-  {
-    return index_;
-  }
-
-  /// Compare two IDs for equality.
-  friend bool operator==(const registered_buffer_id& lhs,
-      const registered_buffer_id& rhs) noexcept
-  {
-    return lhs.scope_ == rhs.scope_ && lhs.index_ == rhs.index_;
-  }
-
-  /// Compare two IDs for equality.
-  friend bool operator!=(const registered_buffer_id& lhs,
-      const registered_buffer_id& rhs) noexcept
-  {
-    return lhs.scope_ != rhs.scope_ || lhs.index_ != rhs.index_;
-  }
-
-private:
-  friend class detail::buffer_registration_base;
-
-  // Hidden constructor used by buffer registration.
-  registered_buffer_id(const void* scope, int index) noexcept
-    : scope_(scope),
-      index_(index)
-  {
-  }
-
-  const void* scope_;
-  int index_;
-};
-
-/// Holds a registered buffer over modifiable data.
-/**
- * Satisfies the @c MutableBufferSequence type requirements.
- */
-class mutable_registered_buffer
-{
-public:
-  /// Default constructor creates an invalid registered buffer.
-  mutable_registered_buffer() noexcept
-    : buffer_(),
-      id_()
-  {
-  }
-
-  /// Get the underlying mutable buffer.
-  const mutable_buffer& buffer() const noexcept
-  {
-    return buffer_;
-  }
-
-  /// Get a pointer to the beginning of the memory range.
-  /**
-   * @returns <tt>buffer().data()</tt>.
-   */
-  void* data() const noexcept
-  {
-    return buffer_.data();
-  }
-
-  /// Get the size of the memory range.
-  /**
-   * @returns <tt>buffer().size()</tt>.
-   */
-  std::size_t size() const noexcept
-  {
-    return buffer_.size();
-  }
-
-  /// Get the registered buffer identifier.
-  const registered_buffer_id& id() const noexcept
-  {
-    return id_;
-  }
-
-  /// Move the start of the buffer by the specified number of bytes.
-  mutable_registered_buffer& operator+=(std::size_t n) noexcept
-  {
-    buffer_ += n;
-    return *this;
-  }
-
-private:
-  friend class detail::buffer_registration_base;
-
-  // Hidden constructor used by buffer registration and operators.
-  mutable_registered_buffer(const mutable_buffer& b,
-      const registered_buffer_id& i) noexcept
-    : buffer_(b),
-      id_(i)
-  {
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-  friend mutable_registered_buffer buffer(
-      const mutable_registered_buffer& b, std::size_t n) noexcept;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  mutable_buffer buffer_;
-  registered_buffer_id id_;
-};
-
-/// Holds a registered buffer over non-modifiable data.
-/**
- * Satisfies the @c ConstBufferSequence type requirements.
- */
-class const_registered_buffer
-{
-public:
-  /// Default constructor creates an invalid registered buffer.
-  const_registered_buffer() noexcept
-    : buffer_(),
-      id_()
-  {
-  }
-
-  /// Construct a non-modifiable buffer from a modifiable one.
-  const_registered_buffer(
-      const mutable_registered_buffer& b) noexcept
-    : buffer_(b.buffer()),
-      id_(b.id())
-  {
-  }
-
-  /// Get the underlying constant buffer.
-  const const_buffer& buffer() const noexcept
-  {
-    return buffer_;
-  }
-
-  /// Get a pointer to the beginning of the memory range.
-  /**
-   * @returns <tt>buffer().data()</tt>.
-   */
-  const void* data() const noexcept
-  {
-    return buffer_.data();
-  }
-
-  /// Get the size of the memory range.
-  /**
-   * @returns <tt>buffer().size()</tt>.
-   */
-  std::size_t size() const noexcept
-  {
-    return buffer_.size();
-  }
-
-  /// Get the registered buffer identifier.
-  const registered_buffer_id& id() const noexcept
-  {
-    return id_;
-  }
-
-  /// Move the start of the buffer by the specified number of bytes.
-  const_registered_buffer& operator+=(std::size_t n) noexcept
-  {
-    buffer_ += n;
-    return *this;
-  }
-
-private:
-  // Hidden constructor used by operators.
-  const_registered_buffer(const const_buffer& b,
-      const registered_buffer_id& i) noexcept
-    : buffer_(b),
-      id_(i)
-  {
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-  friend const_registered_buffer buffer(
-      const const_registered_buffer& b, std::size_t n) noexcept;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  const_buffer buffer_;
-  registered_buffer_id id_;
-};
-
-/** @addtogroup buffer_sequence_begin */
-
-/// Get an iterator to the first element in a buffer sequence.
-inline const mutable_buffer* buffer_sequence_begin(
-    const mutable_registered_buffer& b) noexcept
-{
-  return &b.buffer();
-}
-
-/// Get an iterator to the first element in a buffer sequence.
-inline const const_buffer* buffer_sequence_begin(
-    const const_registered_buffer& b) noexcept
-{
-  return &b.buffer();
-}
-
-/** @} */
-/** @addtogroup buffer_sequence_end */
-
-/// Get an iterator to one past the end element in a buffer sequence.
-inline const mutable_buffer* buffer_sequence_end(
-    const mutable_registered_buffer& b) noexcept
-{
-  return &b.buffer() + 1;
-}
-
-/// Get an iterator to one past the end element in a buffer sequence.
-inline const const_buffer* buffer_sequence_end(
-    const const_registered_buffer& b) noexcept
-{
-  return &b.buffer() + 1;
-}
-
-/** @} */
-/** @addtogroup buffer */
-
-/// Obtain a buffer representing the entire registered buffer.
-inline mutable_registered_buffer buffer(
-    const mutable_registered_buffer& b) noexcept
-{
-  return b;
-}
-
-/// Obtain a buffer representing the entire registered buffer.
-inline const_registered_buffer buffer(
-    const const_registered_buffer& b) noexcept
-{
-  return b;
-}
-
-/// Obtain a buffer representing part of a registered buffer.
-inline mutable_registered_buffer buffer(
-    const mutable_registered_buffer& b, std::size_t n) noexcept
-{
-  return mutable_registered_buffer(buffer(b.buffer_, n), b.id_);
-}
-
-/// Obtain a buffer representing part of a registered buffer.
-inline const_registered_buffer buffer(
-    const const_registered_buffer& b, std::size_t n) noexcept
-{
-  return const_registered_buffer(buffer(b.buffer_, n), b.id_);
-}
-
-/** @} */
-
-/// Create a new modifiable registered buffer that is offset from the start of
-/// another.
-/**
- * @relates mutable_registered_buffer
- */
-inline mutable_registered_buffer operator+(
-    const mutable_registered_buffer& b, std::size_t n) noexcept
-{
-  mutable_registered_buffer tmp(b);
-  tmp += n;
-  return tmp;
-}
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_registered_buffer
- */
-inline mutable_registered_buffer operator+(std::size_t n,
-    const mutable_registered_buffer& b) noexcept
-{
-  return b + n;
-}
-
-/// Create a new non-modifiable registered buffer that is offset from the start
-/// of another.
-/**
- * @relates const_registered_buffer
- */
-inline const_registered_buffer operator+(const const_registered_buffer& b,
-    std::size_t n) noexcept
-{
-  const_registered_buffer tmp(b);
-  tmp += n;
-  return tmp;
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_registered_buffer
- */
-inline const_registered_buffer operator+(std::size_t n,
-    const const_registered_buffer& b) noexcept
-{
-  return b + n;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_REGISTERED_BUFFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require.hpp
deleted file mode 100644
index 609e54f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require.hpp
+++ /dev/null
@@ -1,433 +0,0 @@
-//
-// require.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_REQUIRE_HPP
-#define ASIO_REQUIRE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/require_member.hpp"
-#include "asio/traits/require_free.hpp"
-#include "asio/traits/static_require.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace asio {
-
-/// A customisation point that applies a concept-preserving property to an
-/// object.
-/**
- * The name <tt>require</tt> denotes a customisation point object. The
- * expression <tt>asio::require(E, P0, Pn...)</tt> for some
- * subexpressions <tt>E</tt> and <tt>P0</tt>, and where <tt>Pn...</tt>
- * represents <tt>N</tt> subexpressions (where <tt>N</tt> is 0 or more, and with
- * types <tt>T = decay_t<decltype(E)></tt> and <tt>Prop0 =
- * decay_t<decltype(P0)></tt>) is expression-equivalent to:
- *
- * @li If <tt>is_applicable_property_v<T, Prop0> && Prop0::is_requirable</tt> is
- *   not a well-formed constant expression with value <tt>true</tt>,
- *   <tt>asio::require(E, P0, Pn...)</tt> is ill-formed.
- *
- * @li Otherwise, <tt>E</tt> if <tt>N == 0</tt> and the expression
- *   <tt>Prop0::template static_query_v<T> == Prop0::value()</tt> is a
- *   well-formed constant expression with value <tt>true</tt>.
- *
- * @li Otherwise, <tt>(E).require(P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>(E).require(P0)</tt> is a valid expression.
- *
- * @li Otherwise, <tt>require(E, P0)</tt> if <tt>N == 0</tt> and the expression
- *   <tt>require(E, P0)</tt> is a valid expression with overload resolution
- *   performed in a context that does not include the declaration of the
- *   <tt>require</tt> customization point object.
- *
- * @li Otherwise,
- *   <tt>asio::require(asio::require(E, P0), Pn...)</tt>
- *   if <tt>N > 0</tt> and the expression
- *   <tt>asio::require(asio::require(E, P0), Pn...)</tt>
- *   is a valid expression.
- *
- * @li Otherwise, <tt>asio::require(E, P0, Pn...)</tt> is ill-formed.
- */
-inline constexpr unspecified require = unspecified;
-
-/// A type trait that determines whether a @c require expression is well-formed.
-/**
- * Class template @c can_require is a trait that is derived from
- * @c true_type if the expression <tt>asio::require(std::declval<T>(),
- * std::declval<Properties>()...)</tt> is well formed; otherwise @c false_type.
- */
-template <typename T, typename... Properties>
-struct can_require :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines whether a @c require expression will not throw.
-/**
- * Class template @c is_nothrow_require is a trait that is derived from
- * @c true_type if the expression <tt>asio::require(std::declval<T>(),
- * std::declval<Properties>()...)</tt> is @c noexcept; otherwise @c false_type.
- */
-template <typename T, typename... Properties>
-struct is_nothrow_require :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines the result type of a @c require expression.
-/**
- * Class template @c require_result is a trait that determines the result
- * type of the expression <tt>asio::require(std::declval<T>(),
- * std::declval<Properties>()...)</tt>.
- */
-template <typename T, typename... Properties>
-struct require_result
-{
-  /// The result of the @c require expression.
-  typedef automatically_determined type;
-};
-
-} // namespace asio
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace asio_require_fn {
-
-using asio::conditional_t;
-using asio::decay_t;
-using asio::declval;
-using asio::enable_if_t;
-using asio::is_applicable_property;
-using asio::traits::require_free;
-using asio::traits::require_member;
-using asio::traits::static_require;
-
-void require();
-
-enum overload_type
-{
-  identity,
-  call_member,
-  call_free,
-  two_props,
-  n_props,
-  ill_formed
-};
-
-template <typename Impl, typename T, typename Properties, typename = void,
-    typename = void, typename = void, typename = void, typename = void>
-struct call_traits
-{
-  static constexpr overload_type overload = ill_formed;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable
-  >,
-  enable_if_t<
-    static_require<T, Property>::is_valid
-  >>
-{
-  static constexpr overload_type overload = identity;
-  static constexpr bool is_noexcept = true;
-
-  typedef T&& result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >> :
-  require_member<typename Impl::template proxy<T>::type, Property>
-{
-  static constexpr overload_type overload = call_member;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable
-  >,
-  enable_if_t<
-    !static_require<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
-  >,
-  enable_if_t<
-    require_free<T, Property>::is_valid
-  >> :
-  require_free<T, Property>
-{
-  static constexpr overload_type overload = call_free;
-};
-
-template <typename Impl, typename T, typename P0, typename P1>
-struct call_traits<Impl, T, void(P0, P1),
-  enable_if_t<
-    call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >,
-  enable_if_t<
-    call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1)
-    >::overload != ill_formed
-  >>
-{
-  static constexpr overload_type overload = two_props;
-
-  static constexpr bool is_noexcept =
-    (
-      call_traits<Impl, T, void(P0)>::is_noexcept
-      &&
-      call_traits<
-        Impl,
-        typename call_traits<Impl, T, void(P0)>::result_type,
-        void(P1)
-      >::is_noexcept
-    );
-
-  typedef decay_t<
-    typename call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1)
-    >::result_type
-  > result_type;
-};
-
-template <typename Impl, typename T, typename P0,
-    typename P1, typename... PN>
-struct call_traits<Impl, T, void(P0, P1, PN...),
-  enable_if_t<
-    call_traits<Impl, T, void(P0)>::overload != ill_formed
-  >,
-  enable_if_t<
-    call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN...)
-    >::overload != ill_formed
-  >>
-{
-  static constexpr overload_type overload = n_props;
-
-  static constexpr bool is_noexcept =
-    (
-      call_traits<Impl, T, void(P0)>::is_noexcept
-      &&
-      call_traits<
-        Impl,
-        typename call_traits<Impl, T, void(P0)>::result_type,
-        void(P1, PN...)
-      >::is_noexcept
-    );
-
-  typedef decay_t<
-    typename call_traits<
-      Impl,
-      typename call_traits<Impl, T, void(P0)>::result_type,
-      void(P1, PN...)
-    >::result_type
-  > result_type;
-};
-
-struct impl
-{
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto require(P&& p)
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().require(static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-  };
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == identity,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&&) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t);
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_member,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t).require(static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_free,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return require(static_cast<T&&>(t), static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename P0, typename P1>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(P0, P1)>::overload == two_props,
-    typename call_traits<impl, T, void(P0, P1)>::result_type
-  >
-  operator()(T&& t, P0&& p0, P1&& p1) const
-    noexcept(call_traits<impl, T, void(P0, P1)>::is_noexcept)
-  {
-    return (*this)(
-        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
-        static_cast<P1&&>(p1));
-  }
-
-  template <typename T, typename P0, typename P1,
-    typename... PN>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(P0, P1, PN...)>::overload == n_props,
-    typename call_traits<impl, T, void(P0, P1, PN...)>::result_type
-  >
-  operator()(T&& t, P0&& p0, P1&& p1, PN&&... pn) const
-    noexcept(call_traits<impl, T, void(P0, P1, PN...)>::is_noexcept)
-  {
-    return (*this)(
-        (*this)(static_cast<T&&>(t), static_cast<P0&&>(p0)),
-        static_cast<P1&&>(p1), static_cast<PN&&>(pn)...);
-  }
-};
-
-template <typename T = impl>
-struct static_instance
-{
-  static const T instance;
-};
-
-template <typename T>
-const T static_instance<T>::instance = {};
-
-} // namespace asio_require_fn
-namespace asio {
-namespace {
-
-static constexpr const asio_require_fn::impl&
-  require = asio_require_fn::static_instance<>::instance;
-
-} // namespace
-
-typedef asio_require_fn::impl require_t;
-
-template <typename T, typename... Properties>
-struct can_require :
-  integral_constant<bool,
-    asio_require_fn::call_traits<
-      require_t, T, void(Properties...)>::overload
-        != asio_require_fn::ill_formed>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-constexpr bool can_require_v
-  = can_require<T, Properties...>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-struct is_nothrow_require :
-  integral_constant<bool,
-    asio_require_fn::call_traits<
-      require_t, T, void(Properties...)>::is_noexcept>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-constexpr bool is_nothrow_require_v
-  = is_nothrow_require<T, Properties...>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename... Properties>
-struct require_result
-{
-  typedef typename asio_require_fn::call_traits<
-      require_t, T, void(Properties...)>::result_type type;
-};
-
-template <typename T, typename... Properties>
-using require_result_t = typename require_result<T, Properties...>::type;
-
-} // namespace asio
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_REQUIRE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require_concept.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require_concept.hpp
deleted file mode 100644
index b735b66..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/require_concept.hpp
+++ /dev/null
@@ -1,343 +0,0 @@
-//
-// require_concept.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_REQUIRE_CONCEPT_HPP
-#define ASIO_REQUIRE_CONCEPT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/is_applicable_property.hpp"
-#include "asio/traits/require_concept_member.hpp"
-#include "asio/traits/require_concept_free.hpp"
-#include "asio/traits/static_require_concept.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-
-namespace asio {
-
-/// A customisation point that applies a concept-enforcing property to an
-/// object.
-/**
- * The name <tt>require_concept</tt> denotes a customization point object. The
- * expression <tt>asio::require_concept(E, P)</tt> for some
- * subexpressions <tt>E</tt> and <tt>P</tt> (with types <tt>T =
- * decay_t<decltype(E)></tt> and <tt>Prop = decay_t<decltype(P)></tt>) is
- * expression-equivalent to:
- *
- * @li If <tt>is_applicable_property_v<T, Prop> &&
- *   Prop::is_requirable_concept</tt> is not a well-formed constant expression
- *   with value <tt>true</tt>, <tt>asio::require_concept(E, P)</tt> is
- *   ill-formed.
- *
- * @li Otherwise, <tt>E</tt> if the expression <tt>Prop::template
- *   static_query_v<T> == Prop::value()</tt> is a well-formed constant
- *   expression with value <tt>true</tt>.
- *
- * @li Otherwise, <tt>(E).require_concept(P)</tt> if the expression
- *   <tt>(E).require_concept(P)</tt> is well-formed.
- *
- * @li Otherwise, <tt>require_concept(E, P)</tt> if the expression
- *   <tt>require_concept(E, P)</tt> is a valid expression with overload
- *   resolution performed in a context that does not include the declaration
- *   of the <tt>require_concept</tt> customization point object.
- *
- * @li Otherwise, <tt>asio::require_concept(E, P)</tt> is ill-formed.
- */
-inline constexpr unspecified require_concept = unspecified;
-
-/// A type trait that determines whether a @c require_concept expression is
-/// well-formed.
-/**
- * Class template @c can_require_concept is a trait that is derived from
- * @c true_type if the expression
- * <tt>asio::require_concept(std::declval<T>(),
- * std::declval<Property>())</tt> is well formed; otherwise @c false_type.
- */
-template <typename T, typename Property>
-struct can_require_concept :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines whether a @c require_concept expression will
-/// not throw.
-/**
- * Class template @c is_nothrow_require_concept is a trait that is derived from
- * @c true_type if the expression
- * <tt>asio::require_concept(std::declval<T>(),
- * std::declval<Property>())</tt> is @c noexcept; otherwise @c false_type.
- */
-template <typename T, typename Property>
-struct is_nothrow_require_concept :
-  integral_constant<bool, automatically_determined>
-{
-};
-
-/// A type trait that determines the result type of a @c require_concept
-/// expression.
-/**
- * Class template @c require_concept_result is a trait that determines the
- * result type of the expression
- * <tt>asio::require_concept(std::declval<T>(),
- * std::declval<Property>())</tt>.
- */
-template <typename T, typename Property>
-struct require_concept_result
-{
-  /// The result of the @c require_concept expression.
-  typedef automatically_determined type;
-};
-
-} // namespace asio
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-namespace asio_require_concept_fn {
-
-using asio::conditional_t;
-using asio::decay_t;
-using asio::declval;
-using asio::enable_if_t;
-using asio::is_applicable_property;
-using asio::traits::require_concept_free;
-using asio::traits::require_concept_member;
-using asio::traits::static_require_concept;
-
-void require_concept();
-
-enum overload_type
-{
-  identity,
-  call_member,
-  call_free,
-  ill_formed
-};
-
-template <typename Impl, typename T, typename Properties, typename = void,
-    typename = void, typename = void, typename = void, typename = void>
-struct call_traits
-{
-  static constexpr overload_type overload = ill_formed;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable_concept
-  >,
-  enable_if_t<
-    static_require_concept<T, Property>::is_valid
-  >>
-{
-  static constexpr overload_type overload = identity;
-  static constexpr bool is_noexcept = true;
-  typedef T&& result_type;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable_concept
-  >,
-  enable_if_t<
-    !static_require_concept<T, Property>::is_valid
-  >,
-  enable_if_t<
-    require_concept_member<
-      typename Impl::template proxy<T>::type,
-      Property
-    >::is_valid
-  >> :
-  require_concept_member<
-    typename Impl::template proxy<T>::type,
-    Property
-  >
-{
-  static constexpr overload_type overload = call_member;
-};
-
-template <typename Impl, typename T, typename Property>
-struct call_traits<Impl, T, void(Property),
-  enable_if_t<
-    is_applicable_property<
-      decay_t<T>,
-      decay_t<Property>
-    >::value
-  >,
-  enable_if_t<
-    decay_t<Property>::is_requirable_concept
-  >,
-  enable_if_t<
-    !static_require_concept<T, Property>::is_valid
-  >,
-  enable_if_t<
-    !require_concept_member<
-      typename Impl::template proxy<T>::type,
-      Property
-    >::is_valid
-  >,
-  enable_if_t<
-    require_concept_free<T, Property>::is_valid
-  >> :
-  require_concept_free<T, Property>
-{
-  static constexpr overload_type overload = call_free;
-};
-
-struct impl
-{
-  template <typename T>
-  struct proxy
-  {
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-    struct type
-    {
-      template <typename P>
-      auto require_concept(P&& p)
-        noexcept(
-          noexcept(
-            declval<conditional_t<true, T, P>>().require_concept(
-              static_cast<P&&>(p))
-          )
-        )
-        -> decltype(
-          declval<conditional_t<true, T, P>>().require_concept(
-            static_cast<P&&>(p))
-        );
-    };
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-    typedef T type;
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-  };
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == identity,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&&) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t);
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_member,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return static_cast<T&&>(t).require_concept(static_cast<Property&&>(p));
-  }
-
-  template <typename T, typename Property>
-  ASIO_NODISCARD constexpr enable_if_t<
-    call_traits<impl, T, void(Property)>::overload == call_free,
-    typename call_traits<impl, T, void(Property)>::result_type
-  >
-  operator()(T&& t, Property&& p) const
-    noexcept(call_traits<impl, T, void(Property)>::is_noexcept)
-  {
-    return require_concept(static_cast<T&&>(t), static_cast<Property&&>(p));
-  }
-};
-
-template <typename T = impl>
-struct static_instance
-{
-  static const T instance;
-};
-
-template <typename T>
-const T static_instance<T>::instance = {};
-
-} // namespace asio_require_concept_fn
-namespace asio {
-namespace {
-
-static constexpr const asio_require_concept_fn::impl&
-  require_concept = asio_require_concept_fn::static_instance<>::instance;
-
-} // namespace
-
-typedef asio_require_concept_fn::impl require_concept_t;
-
-template <typename T, typename Property>
-struct can_require_concept :
-  integral_constant<bool,
-    asio_require_concept_fn::call_traits<
-      require_concept_t, T, void(Property)>::overload !=
-        asio_require_concept_fn::ill_formed>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-constexpr bool can_require_concept_v = can_require_concept<T, Property>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-struct is_nothrow_require_concept :
-  integral_constant<bool,
-    asio_require_concept_fn::call_traits<
-      require_concept_t, T, void(Property)>::is_noexcept>
-{
-};
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-constexpr bool is_nothrow_require_concept_v
-  = is_nothrow_require_concept<T, Property>::value;
-
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-
-template <typename T, typename Property>
-struct require_concept_result
-{
-  typedef typename asio_require_concept_fn::call_traits<
-      require_concept_t, T, void(Property)>::result_type type;
-};
-
-template <typename T, typename Property>
-using require_concept_result_t =
-  typename require_concept_result<T, Property>::type;
-
-} // namespace asio
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_REQUIRE_CONCEPT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port.hpp
deleted file mode 100644
index 61e8937..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// serial_port.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SERIAL_PORT_HPP
-#define ASIO_SERIAL_PORT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_serial_port.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a serial port.
-typedef basic_serial_port<> serial_port;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_SERIAL_PORT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port_base.hpp
deleted file mode 100644
index 479d697..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/serial_port_base.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//
-// serial_port_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SERIAL_PORT_BASE_HPP
-#define ASIO_SERIAL_PORT_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-# include <termios.h>
-#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/detail/socket_types.hpp"
-#include "asio/error_code.hpp"
-
-#if defined(GENERATING_DOCUMENTATION)
-# define ASIO_OPTION_STORAGE implementation_defined
-#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-# define ASIO_OPTION_STORAGE DCB
-#else
-# define ASIO_OPTION_STORAGE termios
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The serial_port_base class is used as a base for the basic_serial_port class
-/// template so that we have a common place to define the serial port options.
-class serial_port_base
-{
-public:
-  /// Serial port option to permit changing the baud rate.
-  /**
-   * Implements changing the baud rate for a given serial port.
-   */
-  class baud_rate
-  {
-  public:
-    explicit baud_rate(unsigned int rate = 0);
-    unsigned int value() const;
-    ASIO_DECL ASIO_SYNC_OP_VOID store(
-        ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec) const;
-    ASIO_DECL ASIO_SYNC_OP_VOID load(
-        const ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec);
-  private:
-    unsigned int value_;
-  };
-
-  /// Serial port option to permit changing the flow control.
-  /**
-   * Implements changing the flow control for a given serial port.
-   */
-  class flow_control
-  {
-  public:
-    enum type { none, software, hardware };
-    ASIO_DECL explicit flow_control(type t = none);
-    type value() const;
-    ASIO_DECL ASIO_SYNC_OP_VOID store(
-        ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec) const;
-    ASIO_DECL ASIO_SYNC_OP_VOID load(
-        const ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec);
-  private:
-    type value_;
-  };
-
-  /// Serial port option to permit changing the parity.
-  /**
-   * Implements changing the parity for a given serial port.
-   */
-  class parity
-  {
-  public:
-    enum type { none, odd, even };
-    ASIO_DECL explicit parity(type t = none);
-    type value() const;
-    ASIO_DECL ASIO_SYNC_OP_VOID store(
-        ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec) const;
-    ASIO_DECL ASIO_SYNC_OP_VOID load(
-        const ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec);
-  private:
-    type value_;
-  };
-
-  /// Serial port option to permit changing the number of stop bits.
-  /**
-   * Implements changing the number of stop bits for a given serial port.
-   */
-  class stop_bits
-  {
-  public:
-    enum type { one, onepointfive, two };
-    ASIO_DECL explicit stop_bits(type t = one);
-    type value() const;
-    ASIO_DECL ASIO_SYNC_OP_VOID store(
-        ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec) const;
-    ASIO_DECL ASIO_SYNC_OP_VOID load(
-        const ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec);
-  private:
-    type value_;
-  };
-
-  /// Serial port option to permit changing the character size.
-  /**
-   * Implements changing the character size for a given serial port.
-   */
-  class character_size
-  {
-  public:
-    ASIO_DECL explicit character_size(unsigned int t = 8);
-    unsigned int value() const;
-    ASIO_DECL ASIO_SYNC_OP_VOID store(
-        ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec) const;
-    ASIO_DECL ASIO_SYNC_OP_VOID load(
-        const ASIO_OPTION_STORAGE& storage,
-        asio::error_code& ec);
-  private:
-    unsigned int value_;
-  };
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~serial_port_base()
-  {
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#undef ASIO_OPTION_STORAGE
-
-#include "asio/impl/serial_port_base.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/serial_port_base.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_SERIAL_PORT_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set.hpp
deleted file mode 100644
index b2e189d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// signal_set.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SIGNAL_SET_HPP
-#define ASIO_SIGNAL_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_signal_set.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a signal set.
-typedef basic_signal_set<> signal_set;
-
-} // namespace asio
-
-#endif // ASIO_SIGNAL_SET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set_base.hpp
deleted file mode 100644
index 9863a15..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/signal_set_base.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// signal_set_base.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SIGNAL_SET_BASE_HPP
-#define ASIO_SIGNAL_SET_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The signal_set_base class is used as a base for the basic_signal_set class
-/// templates so that we have a common place to define the flags enum.
-class signal_set_base
-{
-public:
-# if defined(GENERATING_DOCUMENTATION)
-  /// Enumeration representing the different types of flags that may specified
-  /// when adding a signal to a set.
-  enum flags
-  {
-    /// Bitmask representing no flags.
-    none = 0,
-
-    /// Affects the behaviour of interruptible functions such that, if the
-    /// function would have failed with error::interrupted when interrupted by
-    /// the specified signal, the function shall instead be restarted and not
-    /// fail with error::interrupted.
-    restart = implementation_defined,
-
-    /// Do not generate SIGCHLD when child processes stop or stopped child
-    /// processes continue.
-    no_child_stop = implementation_defined,
-
-    /// Do not transform child processes into zombies when they terminate.
-    no_child_wait = implementation_defined,
-
-    /// Special value to indicate that the signal registration does not care
-    /// which flags are set, and so will not conflict with any prior
-    /// registrations of the same signal.
-    dont_care = -1
-  };
-
-  /// Portability typedef.
-  typedef flags flags_t;
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-  enum class flags : int
-  {
-    none = 0,
-    restart = ASIO_OS_DEF(SA_RESTART),
-    no_child_stop = ASIO_OS_DEF(SA_NOCLDSTOP),
-    no_child_wait = ASIO_OS_DEF(SA_NOCLDWAIT),
-    dont_care = -1
-  };
-
-  typedef flags flags_t;
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~signal_set_base()
-  {
-  }
-};
-
-/// Negation operator.
-/**
- * @relates signal_set_base::flags
- */
-inline constexpr bool operator!(signal_set_base::flags_t x)
-{
-  return static_cast<int>(x) == 0;
-}
-
-/// Bitwise and operator.
-/**
- * @relates signal_set_base::flags
- */
-inline constexpr signal_set_base::flags_t operator&(
-    signal_set_base::flags_t x, signal_set_base::flags_t y)
-{
-  return static_cast<signal_set_base::flags_t>(
-      static_cast<int>(x) & static_cast<int>(y));
-}
-
-/// Bitwise or operator.
-/**
- * @relates signal_set_base::flags
- */
-inline constexpr signal_set_base::flags_t operator|(
-    signal_set_base::flags_t x, signal_set_base::flags_t y)
-{
-  return static_cast<signal_set_base::flags_t>(
-      static_cast<int>(x) | static_cast<int>(y));
-}
-
-/// Bitwise xor operator.
-/**
- * @relates signal_set_base::flags
- */
-inline constexpr signal_set_base::flags_t operator^(
-    signal_set_base::flags_t x, signal_set_base::flags_t y)
-{
-  return static_cast<signal_set_base::flags_t>(
-      static_cast<int>(x) ^ static_cast<int>(y));
-}
-
-/// Bitwise negation operator.
-/**
- * @relates signal_set_base::flags
- */
-inline constexpr signal_set_base::flags_t operator~(
-    signal_set_base::flags_t x)
-{
-  return static_cast<signal_set_base::flags_t>(~static_cast<int>(x));
-}
-
-/// Bitwise and-assignment operator.
-/**
- * @relates signal_set_base::flags
- */
-inline signal_set_base::flags_t& operator&=(
-    signal_set_base::flags_t& x, signal_set_base::flags_t y)
-{
-  x = x & y;
-  return x;
-}
-
-/// Bitwise or-assignment operator.
-/**
- * @relates signal_set_base::flags
- */
-inline signal_set_base::flags_t& operator|=(
-    signal_set_base::flags_t& x, signal_set_base::flags_t y)
-{
-  x = x | y;
-  return x;
-}
-
-/// Bitwise xor-assignment operator.
-/**
- * @relates signal_set_base::flags
- */
-inline signal_set_base::flags_t& operator^=(
-    signal_set_base::flags_t& x, signal_set_base::flags_t y)
-{
-  x = x ^ y;
-  return x;
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SIGNAL_SET_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/socket_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/socket_base.hpp
deleted file mode 100644
index 5d50979..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/socket_base.hpp
+++ /dev/null
@@ -1,559 +0,0 @@
-//
-// socket_base.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SOCKET_BASE_HPP
-#define ASIO_SOCKET_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/io_control.hpp"
-#include "asio/detail/socket_option.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// The socket_base class is used as a base for the basic_stream_socket and
-/// basic_datagram_socket class templates so that we have a common place to
-/// define the shutdown_type and enum.
-class socket_base
-{
-public:
-  /// Different ways a socket may be shutdown.
-  enum shutdown_type
-  {
-#if defined(GENERATING_DOCUMENTATION)
-    /// Shutdown the receive side of the socket.
-    shutdown_receive = implementation_defined,
-
-    /// Shutdown the send side of the socket.
-    shutdown_send = implementation_defined,
-
-    /// Shutdown both send and receive on the socket.
-    shutdown_both = implementation_defined
-#else
-    shutdown_receive = ASIO_OS_DEF(SHUT_RD),
-    shutdown_send = ASIO_OS_DEF(SHUT_WR),
-    shutdown_both = ASIO_OS_DEF(SHUT_RDWR)
-#endif
-  };
-
-  /// Bitmask type for flags that can be passed to send and receive operations.
-  typedef int message_flags;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Peek at incoming data without removing it from the input queue.
-  static const int message_peek = implementation_defined;
-
-  /// Process out-of-band data.
-  static const int message_out_of_band = implementation_defined;
-
-  /// Specify that the data should not be subject to routing.
-  static const int message_do_not_route = implementation_defined;
-
-  /// Specifies that the data marks the end of a record.
-  static const int message_end_of_record = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(int,
-      message_peek = ASIO_OS_DEF(MSG_PEEK));
-  ASIO_STATIC_CONSTANT(int,
-      message_out_of_band = ASIO_OS_DEF(MSG_OOB));
-  ASIO_STATIC_CONSTANT(int,
-      message_do_not_route = ASIO_OS_DEF(MSG_DONTROUTE));
-  ASIO_STATIC_CONSTANT(int,
-      message_end_of_record = ASIO_OS_DEF(MSG_EOR));
-#endif
-
-  /// Wait types.
-  /**
-   * For use with basic_socket::wait() and basic_socket::async_wait().
-   */
-  enum wait_type
-  {
-    /// Wait for a socket to become ready to read.
-    wait_read,
-
-    /// Wait for a socket to become ready to write.
-    wait_write,
-
-    /// Wait for a socket to have error conditions pending.
-    wait_error
-  };
-
-  /// Socket option to permit sending of broadcast messages.
-  /**
-   * Implements the SOL_SOCKET/SO_BROADCAST socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::udp::socket socket(my_context);
-   * ...
-   * asio::socket_base::broadcast option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::udp::socket socket(my_context);
-   * ...
-   * asio::socket_base::broadcast option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined broadcast;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_BROADCAST)>
-      broadcast;
-#endif
-
-  /// Socket option to enable socket-level debugging.
-  /**
-   * Implements the SOL_SOCKET/SO_DEBUG socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::debug option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::debug option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined debug;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_DEBUG)> debug;
-#endif
-
-  /// Socket option to prevent routing, use local interfaces only.
-  /**
-   * Implements the SOL_SOCKET/SO_DONTROUTE socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::udp::socket socket(my_context);
-   * ...
-   * asio::socket_base::do_not_route option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::udp::socket socket(my_context);
-   * ...
-   * asio::socket_base::do_not_route option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined do_not_route;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_DONTROUTE)>
-      do_not_route;
-#endif
-
-  /// Socket option to send keep-alives.
-  /**
-   * Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::keep_alive option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::keep_alive option;
-   * socket.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined keep_alive;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_KEEPALIVE)> keep_alive;
-#endif
-
-  /// Socket option for the send buffer size of a socket.
-  /**
-   * Implements the SOL_SOCKET/SO_SNDBUF socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::send_buffer_size option(8192);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::send_buffer_size option;
-   * socket.get_option(option);
-   * int size = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Integer_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined send_buffer_size;
-#else
-  typedef asio::detail::socket_option::integer<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_SNDBUF)>
-      send_buffer_size;
-#endif
-
-  /// Socket option for the send low watermark.
-  /**
-   * Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::send_low_watermark option(1024);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::send_low_watermark option;
-   * socket.get_option(option);
-   * int size = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Integer_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined send_low_watermark;
-#else
-  typedef asio::detail::socket_option::integer<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_SNDLOWAT)>
-      send_low_watermark;
-#endif
-
-  /// Socket option for the receive buffer size of a socket.
-  /**
-   * Implements the SOL_SOCKET/SO_RCVBUF socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::receive_buffer_size option(8192);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::receive_buffer_size option;
-   * socket.get_option(option);
-   * int size = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Integer_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined receive_buffer_size;
-#else
-  typedef asio::detail::socket_option::integer<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_RCVBUF)>
-      receive_buffer_size;
-#endif
-
-  /// Socket option for the receive low watermark.
-  /**
-   * Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::receive_low_watermark option(1024);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::receive_low_watermark option;
-   * socket.get_option(option);
-   * int size = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Integer_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined receive_low_watermark;
-#else
-  typedef asio::detail::socket_option::integer<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_RCVLOWAT)>
-      receive_low_watermark;
-#endif
-
-  /// Socket option to allow the socket to be bound to an address that is
-  /// already in use.
-  /**
-   * Implements the SOL_SOCKET/SO_REUSEADDR socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::socket_base::reuse_address option(true);
-   * acceptor.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::socket_base::reuse_address option;
-   * acceptor.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined reuse_address;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_REUSEADDR)>
-      reuse_address;
-#endif
-
-  /// Socket option to specify whether the socket lingers on close if unsent
-  /// data is present.
-  /**
-   * Implements the SOL_SOCKET/SO_LINGER socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::linger option(true, 30);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::linger option;
-   * socket.get_option(option);
-   * bool is_set = option.enabled();
-   * unsigned short timeout = option.timeout();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Linger_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined linger;
-#else
-  typedef asio::detail::socket_option::linger<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_LINGER)>
-      linger;
-#endif
-
-  /// Socket option for putting received out-of-band data inline.
-  /**
-   * Implements the SOL_SOCKET/SO_OOBINLINE socket option.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::out_of_band_inline option(true);
-   * socket.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::out_of_band_inline option;
-   * socket.get_option(option);
-   * bool value = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined out_of_band_inline;
-#else
-  typedef asio::detail::socket_option::boolean<
-    ASIO_OS_DEF(SOL_SOCKET), ASIO_OS_DEF(SO_OOBINLINE)>
-      out_of_band_inline;
-#endif
-
-  /// Socket option to report aborted connections on accept.
-  /**
-   * Implements a custom socket option that determines whether or not an accept
-   * operation is permitted to fail with asio::error::connection_aborted.
-   * By default the option is false.
-   *
-   * @par Examples
-   * Setting the option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::socket_base::enable_connection_aborted option(true);
-   * acceptor.set_option(option);
-   * @endcode
-   *
-   * @par
-   * Getting the current option value:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(my_context);
-   * ...
-   * asio::socket_base::enable_connection_aborted option;
-   * acceptor.get_option(option);
-   * bool is_set = option.value();
-   * @endcode
-   *
-   * @par Concepts:
-   * Socket_Option, Boolean_Socket_Option.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined enable_connection_aborted;
-#else
-  typedef asio::detail::socket_option::boolean<
-    asio::detail::custom_socket_option_level,
-    asio::detail::enable_connection_aborted_option>
-    enable_connection_aborted;
-#endif
-
-  /// IO control command to get the amount of data that can be read without
-  /// blocking.
-  /**
-   * Implements the FIONREAD IO control command.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::socket socket(my_context);
-   * ...
-   * asio::socket_base::bytes_readable command(true);
-   * socket.io_control(command);
-   * std::size_t bytes_readable = command.get();
-   * @endcode
-   *
-   * @par Concepts:
-   * IO_Control_Command, Size_IO_Control_Command.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined bytes_readable;
-#else
-  typedef asio::detail::io_control::bytes_readable bytes_readable;
-#endif
-
-  /// The maximum length of the queue of pending incoming connections.
-#if defined(GENERATING_DOCUMENTATION)
-  static const int max_listen_connections = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(int, max_listen_connections
-      = ASIO_OS_DEF(SOMAXCONN));
-#endif
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use max_listen_connections.) The maximum length of the queue
-  /// of pending incoming connections.
-#if defined(GENERATING_DOCUMENTATION)
-  static const int max_connections = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(int, max_connections
-      = ASIO_OS_DEF(SOMAXCONN));
-#endif
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~socket_base()
-  {
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SOCKET_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/spawn.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/spawn.hpp
deleted file mode 100644
index 9276029..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/spawn.hpp
+++ /dev/null
@@ -1,871 +0,0 @@
-//
-// spawn.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SPAWN_HPP
-#define ASIO_SPAWN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/cancellation_state.hpp"
-#include "asio/detail/exception.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/io_context.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/strand.hpp"
-
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-# include <boost/coroutine/all.hpp>
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Base class for all spawn()-ed thread implementations.
-class spawned_thread_base
-{
-public:
-  spawned_thread_base()
-    : owner_(0),
-      has_context_switched_(false),
-      throw_if_cancelled_(false),
-      terminal_(false)
-  {
-  }
-
-  virtual ~spawned_thread_base() {}
-  virtual void resume() = 0;
-  virtual void suspend_with(void (*fn)(void*), void* arg) = 0;
-  virtual void destroy() = 0;
-
-  void attach(spawned_thread_base** owner)
-  {
-    owner_ = owner;
-    *owner_ = this;
-  }
-
-  void detach()
-  {
-    if (owner_)
-      *owner_ = 0;
-    owner_ = 0;
-  }
-
-  void suspend()
-  {
-    suspend_with(0, 0);
-  }
-
-  template <typename F>
-  void suspend_with(F f)
-  {
-    suspend_with(&spawned_thread_base::call<F>, &f);
-  }
-
-  cancellation_slot get_cancellation_slot() const noexcept
-  {
-    return cancellation_state_.slot();
-  }
-
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return cancellation_state_;
-  }
-
-  void reset_cancellation_state()
-  {
-    cancellation_state_ = cancellation_state(parent_cancellation_slot_);
-  }
-
-  template <typename Filter>
-  void reset_cancellation_state(Filter filter)
-  {
-    cancellation_state_ = cancellation_state(
-        parent_cancellation_slot_, filter, filter);
-  }
-
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter in_filter, OutFilter out_filter)
-  {
-    cancellation_state_ = cancellation_state(
-        parent_cancellation_slot_, in_filter, out_filter);
-  }
-
-  cancellation_type_t cancelled() const noexcept
-  {
-    return cancellation_state_.cancelled();
-  }
-
-  bool has_context_switched() const noexcept
-  {
-    return has_context_switched_;
-  }
-
-  bool throw_if_cancelled() const noexcept
-  {
-    return throw_if_cancelled_;
-  }
-
-  void throw_if_cancelled(bool value) noexcept
-  {
-    throw_if_cancelled_ = value;
-  }
-
-protected:
-  spawned_thread_base** owner_; // Points to data member in active handler.
-  asio::cancellation_slot parent_cancellation_slot_;
-  asio::cancellation_state cancellation_state_;
-  bool has_context_switched_;
-  bool throw_if_cancelled_;
-  bool terminal_;
-
-private:
-  // Disallow copying and assignment.
-  spawned_thread_base(const spawned_thread_base&) = delete;
-  spawned_thread_base& operator=(const spawned_thread_base&) = delete;
-
-  template <typename F>
-  static void call(void* f)
-  {
-    (*static_cast<F*>(f))();
-  }
-};
-
-template <typename T>
-struct spawn_signature
-{
-  typedef void type(exception_ptr, T);
-};
-
-template <>
-struct spawn_signature<void>
-{
-  typedef void type(exception_ptr);
-};
-
-template <typename Executor>
-class initiate_spawn;
-
-} // namespace detail
-
-/// A @ref completion_token that represents the currently executing coroutine.
-/**
- * The basic_yield_context class is a completion token type that is used to
- * represent the currently executing stackful coroutine. A basic_yield_context
- * object may be passed as a completion token to an asynchronous operation. For
- * example:
- *
- * @code template <typename Executor>
- * void my_coroutine(basic_yield_context<Executor> yield)
- * {
- *   ...
- *   std::size_t n = my_socket.async_read_some(buffer, yield);
- *   ...
- * } @endcode
- *
- * The initiating function (async_read_some in the above example) suspends the
- * current coroutine. The coroutine is resumed when the asynchronous operation
- * completes, and the result of the operation is returned.
- */
-template <typename Executor>
-class basic_yield_context
-{
-public:
-  /// The executor type associated with the yield context.
-  typedef Executor executor_type;
-
-  /// The cancellation slot type associated with the yield context.
-  typedef cancellation_slot cancellation_slot_type;
-
-  /// Construct a yield context from another yield context type.
-  /**
-   * Requires that OtherExecutor be convertible to Executor.
-   */
-  template <typename OtherExecutor>
-  basic_yield_context(const basic_yield_context<OtherExecutor>& other,
-      constraint_t<
-        is_convertible<OtherExecutor, Executor>::value
-      > = 0)
-    : spawned_thread_(other.spawned_thread_),
-      executor_(other.executor_),
-      ec_(other.ec_)
-  {
-  }
-
-  /// Get the executor associated with the yield context.
-  executor_type get_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  /// Get the cancellation slot associated with the coroutine.
-  cancellation_slot_type get_cancellation_slot() const noexcept
-  {
-    return spawned_thread_->get_cancellation_slot();
-  }
-
-  /// Get the cancellation state associated with the coroutine.
-  cancellation_state get_cancellation_state() const noexcept
-  {
-    return spawned_thread_->get_cancellation_state();
-  }
-
-  /// Reset the cancellation state associated with the coroutine.
-  /**
-   * Let <tt>P</tt> be the cancellation slot associated with the current
-   * coroutine's @ref spawn completion handler. Assigns a new
-   * asio::cancellation_state object <tt>S</tt>, constructed as
-   * <tt>S(P)</tt>, into the current coroutine's cancellation state object.
-   */
-  void reset_cancellation_state() const
-  {
-    spawned_thread_->reset_cancellation_state();
-  }
-
-  /// Reset the cancellation state associated with the coroutine.
-  /**
-   * Let <tt>P</tt> be the cancellation slot associated with the current
-   * coroutine's @ref spawn completion handler. Assigns a new
-   * asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
-   * std::forward<Filter>(filter))</tt>, into the current coroutine's
-   * cancellation state object.
-   */
-  template <typename Filter>
-  void reset_cancellation_state(Filter&& filter) const
-  {
-    spawned_thread_->reset_cancellation_state(
-        static_cast<Filter&&>(filter));
-  }
-
-  /// Reset the cancellation state associated with the coroutine.
-  /**
-   * Let <tt>P</tt> be the cancellation slot associated with the current
-   * coroutine's @ref spawn completion handler. Assigns a new
-   * asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
-   * std::forward<InFilter>(in_filter),
-   * std::forward<OutFilter>(out_filter))</tt>, into the current coroutine's
-   * cancellation state object.
-   */
-  template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(InFilter&& in_filter,
-      OutFilter&& out_filter) const
-  {
-    spawned_thread_->reset_cancellation_state(
-        static_cast<InFilter&&>(in_filter),
-        static_cast<OutFilter&&>(out_filter));
-  }
-
-  /// Determine whether the current coroutine has been cancelled.
-  cancellation_type_t cancelled() const noexcept
-  {
-    return spawned_thread_->cancelled();
-  }
-
-  /// Determine whether the coroutine throws if trying to suspend when it has
-  /// been cancelled.
-  bool throw_if_cancelled() const noexcept
-  {
-    return spawned_thread_->throw_if_cancelled();
-  }
-
-  /// Set whether the coroutine throws if trying to suspend when it has been
-  /// cancelled.
-  void throw_if_cancelled(bool value) const noexcept
-  {
-    spawned_thread_->throw_if_cancelled(value);
-  }
-
-  /// Return a yield context that sets the specified error_code.
-  /**
-   * By default, when a yield context is used with an asynchronous operation, a
-   * non-success error_code is converted to system_error and thrown. This
-   * operator may be used to specify an error_code object that should instead be
-   * set with the asynchronous operation's result. For example:
-   *
-   * @code template <typename Executor>
-   * void my_coroutine(basic_yield_context<Executor> yield)
-   * {
-   *   ...
-   *   std::size_t n = my_socket.async_read_some(buffer, yield[ec]);
-   *   if (ec)
-   *   {
-   *     // An error occurred.
-   *   }
-   *   ...
-   * } @endcode
-   */
-  basic_yield_context operator[](asio::error_code& ec) const
-  {
-    basic_yield_context tmp(*this);
-    tmp.ec_ = &ec;
-    return tmp;
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-//private:
-  basic_yield_context(detail::spawned_thread_base* spawned_thread,
-      const Executor& ex)
-    : spawned_thread_(spawned_thread),
-      executor_(ex),
-      ec_(0)
-  {
-  }
-
-  detail::spawned_thread_base* spawned_thread_;
-  Executor executor_;
-  asio::error_code* ec_;
-#endif // !defined(GENERATING_DOCUMENTATION)
-};
-
-/// A @ref completion_token object that represents the currently executing
-/// coroutine.
-typedef basic_yield_context<any_io_executor> yield_context;
-
-/**
- * @defgroup spawn asio::spawn
- *
- * @brief Start a new stackful coroutine.
- *
- * The spawn() function is a high-level wrapper over the Boost.Coroutine
- * library. This function enables programs to implement asynchronous logic in a
- * synchronous manner, as illustrated by the following example:
- *
- * @code asio::spawn(my_strand, do_echo, asio::detached);
- *
- * // ...
- *
- * void do_echo(asio::yield_context yield)
- * {
- *   try
- *   {
- *     char data[128];
- *     for (;;)
- *     {
- *       std::size_t length =
- *         my_socket.async_read_some(
- *           asio::buffer(data), yield);
- *
- *       asio::async_write(my_socket,
- *           asio::buffer(data, length), yield);
- *     }
- *   }
- *   catch (std::exception& e)
- *   {
- *     // ...
- *   }
- * } @endcode
- */
-/*@{*/
-
-/// Start a new stackful coroutine that executes on a given executor.
-/**
- * This function is used to launch a new stackful coroutine.
- *
- * @param ex Identifies the executor that will run the stackful coroutine.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken = default_completion_token_t<Executor>>
-auto spawn(const Executor& ex, F&& function,
-    CompletionToken&& token = default_completion_token_t<Executor>(),
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    > = 0,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, static_cast<F&&>(function)));
-
-/// Start a new stackful coroutine that executes on a given execution context.
-/**
- * This function is used to launch a new stackful coroutine.
- *
- * @param ctx Identifies the execution context that will run the stackful
- * coroutine.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename ExecutionContext, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>>::type)
-          CompletionToken = default_completion_token_t<
-            typename ExecutionContext::executor_type>>
-auto spawn(ExecutionContext& ctx, F&& function,
-    CompletionToken&& token
-      = default_completion_token_t<typename ExecutionContext::executor_type>(),
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    > = 0,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>>::type>(
-            declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type>>(),
-            token, static_cast<F&&>(function)));
-
-/// Start a new stackful coroutine, inheriting the executor of another.
-/**
- * This function is used to launch a new stackful coroutine.
- *
- * @param ctx Identifies the current coroutine as a parent of the new
- * coroutine. This specifies that the new coroutine should inherit the executor
- * of the parent. For example, if the parent coroutine is executing in a
- * particular strand, then the new coroutine will execute in the same strand.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename Executor, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken = default_completion_token_t<Executor>>
-auto spawn(const basic_yield_context<Executor>& ctx, F&& function,
-    CompletionToken&& token = default_completion_token_t<Executor>(),
-#if defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      !is_same<
-        decay_t<CompletionToken>,
-        boost::coroutines::attributes
-      >::value
-    > = 0,
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, static_cast<F&&>(function)));
-
-#if defined(ASIO_HAS_BOOST_CONTEXT_FIBER) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// Start a new stackful coroutine that executes on a given executor.
-/**
- * This function is used to launch a new stackful coroutine using the
- * specified stack allocator.
- *
- * @param ex Identifies the executor that will run the stackful coroutine.
- *
- * @param stack_allocator Denotes the allocator to be used to allocate the
- * underlying coroutine's stack. The type must satisfy the stack-allocator
- * concept defined by the Boost.Context library.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename Executor, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken = default_completion_token_t<Executor>>
-auto spawn(const Executor& ex, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function,
-    CompletionToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, allocator_arg_t(),
-          static_cast<StackAllocator&&>(stack_allocator),
-          static_cast<F&&>(function)));
-
-/// Start a new stackful coroutine that executes on a given execution context.
-/**
- * This function is used to launch a new stackful coroutine.
- *
- * @param ctx Identifies the execution context that will run the stackful
- * coroutine.
- *
- * @param stack_allocator Denotes the allocator to be used to allocate the
- * underlying coroutine's stack. The type must satisfy the stack-allocator
- * concept defined by the Boost.Context library.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename ExecutionContext, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<
-        typename ExecutionContext::executor_type>)>>::type)
-          CompletionToken = default_completion_token_t<
-            typename ExecutionContext::executor_type>>
-auto spawn(ExecutionContext& ctx, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function,
-    CompletionToken&& token
-      = default_completion_token_t<typename ExecutionContext::executor_type>(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<
-          typename ExecutionContext::executor_type>)>>::type>(
-            declval<detail::initiate_spawn<
-              typename ExecutionContext::executor_type>>(),
-            token, allocator_arg_t(),
-            static_cast<StackAllocator&&>(stack_allocator),
-            static_cast<F&&>(function)));
-
-/// Start a new stackful coroutine, inheriting the executor of another.
-/**
- * This function is used to launch a new stackful coroutine using the
- * specified stack allocator.
- *
- * @param ctx Identifies the current coroutine as a parent of the new
- * coroutine. This specifies that the new coroutine should inherit the
- * executor of the parent. For example, if the parent coroutine is executing
- * in a particular strand, then the new coroutine will execute in the same
- * strand.
- *
- * @param stack_allocator Denotes the allocator to be used to allocate the
- * underlying coroutine's stack. The type must satisfy the stack-allocator
- * concept defined by the Boost.Context library.
- *
- * @param function The coroutine function. The function must be callable the
- * signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param token The @ref completion_token that will handle the notification
- * that the coroutine has completed. If the return type @c R of @c function is
- * @c void, the function signature of the completion handler must be:
- *
- * @code void handler(std::exception_ptr); @endcode
- * Otherwise, the function signature of the completion handler must be:
- * @code void handler(std::exception_ptr, R); @endcode
- *
- * @par Completion Signature
- * @code void(std::exception_ptr, R) @endcode
- * where @c R is the return type of the function object.
- *
- * @par Per-Operation Cancellation
- * The new thread of execution is created with a cancellation state that
- * supports @c cancellation_type::terminal values only. To change the
- * cancellation state, call the basic_yield_context member function
- * @c reset_cancellation_state.
- */
-template <typename Executor, typename StackAllocator, typename F,
-    ASIO_COMPLETION_TOKEN_FOR(typename detail::spawn_signature<
-      result_of_t<F(basic_yield_context<Executor>)>>::type)
-        CompletionToken = default_completion_token_t<Executor>>
-auto spawn(const basic_yield_context<Executor>& ctx, allocator_arg_t,
-    StackAllocator&& stack_allocator, F&& function,
-    CompletionToken&& token = default_completion_token_t<Executor>(),
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-  -> decltype(
-    async_initiate<CompletionToken,
-      typename detail::spawn_signature<
-        result_of_t<F(basic_yield_context<Executor>)>>::type>(
-          declval<detail::initiate_spawn<Executor>>(),
-          token, allocator_arg_t(),
-          static_cast<StackAllocator&&>(stack_allocator),
-          static_cast<F&&>(function)));
-
-#endif // defined(ASIO_HAS_BOOST_CONTEXT_FIBER)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#if defined(ASIO_HAS_BOOST_COROUTINE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine, calling the specified handler when it completes.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- * where Executor is the associated executor type of @c Function.
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Function>
-void spawn(Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes());
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine, calling the specified handler when it completes.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param handler A handler to be called when the coroutine exits. More
- * importantly, the handler provides an execution context (via the the handler
- * invocation hook) for the coroutine. The handler must have the signature:
- * @code void handler(); @endcode
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- * where Executor is the associated executor type of @c Handler.
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Handler, typename Function>
-void spawn(Handler&& handler, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes(),
-    constraint_t<
-      !is_executor<decay_t<Handler>>::value &&
-      !execution::is_executor<decay_t<Handler>>::value &&
-      !is_convertible<Handler&, execution_context&>::value
-    > = 0);
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine, inheriting the execution context of another.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param ctx Identifies the current coroutine as a parent of the new
- * coroutine. This specifies that the new coroutine should inherit the
- * execution context of the parent. For example, if the parent coroutine is
- * executing in a particular strand, then the new coroutine will execute in the
- * same strand.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(basic_yield_context<Executor> yield); @endcode
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Executor, typename Function>
-void spawn(basic_yield_context<Executor> ctx, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes());
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine that executes on a given executor.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param ex Identifies the executor that will run the coroutine. The new
- * coroutine is automatically given its own explicit strand within this
- * executor.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(yield_context yield); @endcode
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Function, typename Executor>
-void spawn(const Executor& ex, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes(),
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0);
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine that executes on a given strand.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param ex Identifies the strand that will run the coroutine.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(yield_context yield); @endcode
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Function, typename Executor>
-void spawn(const strand<Executor>& ex, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes());
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine that executes in the context of a strand.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param s Identifies a strand. By starting multiple coroutines on the same
- * strand, the implementation ensures that none of those coroutines can execute
- * simultaneously.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(yield_context yield); @endcode
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Function>
-void spawn(const asio::io_context::strand& s, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes());
-
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-/// (Deprecated: Use overloads with a completion token.) Start a new stackful
-/// coroutine that executes on a given execution context.
-/**
- * This function is used to launch a new coroutine.
- *
- * @param ctx Identifies the execution context that will run the coroutine. The
- * new coroutine is implicitly given its own strand within this execution
- * context.
- *
- * @param function The coroutine function. The function must have the signature:
- * @code void function(yield_context yield); @endcode
- *
- * @param attributes Boost.Coroutine attributes used to customise the coroutine.
- */
-template <typename Function, typename ExecutionContext>
-void spawn(ExecutionContext& ctx, Function&& function,
-    const boost::coroutines::attributes& attributes
-      = boost::coroutines::attributes(),
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0);
-
-#endif // defined(ASIO_HAS_BOOST_COROUTINE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/spawn.hpp"
-
-#endif // ASIO_SPAWN_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl.hpp
deleted file mode 100644
index 4180dab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// ssl.hpp
-// ~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_HPP
-#define ASIO_SSL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/ssl/context.hpp"
-#include "asio/ssl/context_base.hpp"
-#include "asio/ssl/error.hpp"
-#include "asio/ssl/rfc2818_verification.hpp"
-#include "asio/ssl/host_name_verification.hpp"
-#include "asio/ssl/stream.hpp"
-#include "asio/ssl/stream_base.hpp"
-#include "asio/ssl/verify_context.hpp"
-#include "asio/ssl/verify_mode.hpp"
-
-#endif // ASIO_SSL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context.hpp
deleted file mode 100644
index a41904a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context.hpp
+++ /dev/null
@@ -1,762 +0,0 @@
-//
-// ssl/context.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_CONTEXT_HPP
-#define ASIO_SSL_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <string>
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ssl/context_base.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/ssl/detail/openssl_init.hpp"
-#include "asio/ssl/detail/password_callback.hpp"
-#include "asio/ssl/detail/verify_callback.hpp"
-#include "asio/ssl/verify_mode.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-class context
-  : public context_base,
-    private noncopyable
-{
-public:
-  /// The native handle type of the SSL context.
-  typedef SSL_CTX* native_handle_type;
-
-  /// Constructor.
-  ASIO_DECL explicit context(method m);
-
-  /// Construct to take ownership of a native handle.
-  ASIO_DECL explicit context(native_handle_type native_handle);
-
-  /// Move-construct a context from another.
-  /**
-   * This constructor moves an SSL context from one object to another.
-   *
-   * @param other The other context object from which the move will occur.
-   *
-   * @note Following the move, the following operations only are valid for the
-   * moved-from object:
-   * @li Destruction.
-   * @li As a target for move-assignment.
-   */
-  ASIO_DECL context(context&& other);
-
-  /// Move-assign a context from another.
-  /**
-   * This assignment operator moves an SSL context from one object to another.
-   *
-   * @param other The other context object from which the move will occur.
-   *
-   * @note Following the move, the following operations only are valid for the
-   * moved-from object:
-   * @li Destruction.
-   * @li As a target for move-assignment.
-   */
-  ASIO_DECL context& operator=(context&& other);
-
-  /// Destructor.
-  ASIO_DECL ~context();
-
-  /// Get the underlying implementation in the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to context functionality that is
-   * not otherwise provided.
-   */
-  ASIO_DECL native_handle_type native_handle();
-
-  /// Clear options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The specified options, if currently enabled on the
-   * context, are cleared.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_clear_options.
-   */
-  ASIO_DECL void clear_options(options o);
-
-  /// Clear options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The specified options, if currently enabled on the
-   * context, are cleared.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_clear_options.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID clear_options(options o,
-      asio::error_code& ec);
-
-  /// Set options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The options are bitwise-ored with any existing
-   * value for the options.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_options.
-   */
-  ASIO_DECL void set_options(options o);
-
-  /// Set options on the context.
-  /**
-   * This function may be used to configure the SSL options used by the context.
-   *
-   * @param o A bitmask of options. The available option values are defined in
-   * the context_base class. The options are bitwise-ored with any existing
-   * value for the options.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_options.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID set_options(options o,
-      asio::error_code& ec);
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the context.
-   *
-   * @param v A bitmask of peer verification modes. See @ref verify_mode for
-   * available values.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_verify.
-   */
-  ASIO_DECL void set_verify_mode(verify_mode v);
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the context.
-   *
-   * @param v A bitmask of peer verification modes. See @ref verify_mode for
-   * available values.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_verify.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID set_verify_mode(
-      verify_mode v, asio::error_code& ec);
-
-  /// Set the peer verification depth.
-  /**
-   * This function may be used to configure the maximum verification depth
-   * allowed by the context.
-   *
-   * @param depth Maximum depth for the certificate chain verification that
-   * shall be allowed.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_verify_depth.
-   */
-  ASIO_DECL void set_verify_depth(int depth);
-
-  /// Set the peer verification depth.
-  /**
-   * This function may be used to configure the maximum verification depth
-   * allowed by the context.
-   *
-   * @param depth Maximum depth for the certificate chain verification that
-   * shall be allowed.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_verify_depth.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID set_verify_depth(
-      int depth, asio::error_code& ec);
-
-  /// Set the callback used to verify peer certificates.
-  /**
-   * This function is used to specify a callback function that will be called
-   * by the implementation when it needs to verify a peer certificate.
-   *
-   * @param callback The function object to be used for verifying a certificate.
-   * The function signature of the handler must be:
-   * @code bool verify_callback(
-   *   bool preverified, // True if the certificate passed pre-verification.
-   *   verify_context& ctx // The peer certificate and other context.
-   * ); @endcode
-   * The return value of the callback is true if the certificate has passed
-   * verification, false otherwise.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_verify.
-   */
-  template <typename VerifyCallback>
-  void set_verify_callback(VerifyCallback callback);
-
-  /// Set the callback used to verify peer certificates.
-  /**
-   * This function is used to specify a callback function that will be called
-   * by the implementation when it needs to verify a peer certificate.
-   *
-   * @param callback The function object to be used for verifying a certificate.
-   * The function signature of the handler must be:
-   * @code bool verify_callback(
-   *   bool preverified, // True if the certificate passed pre-verification.
-   *   verify_context& ctx // The peer certificate and other context.
-   * ); @endcode
-   * The return value of the callback is true if the certificate has passed
-   * verification, false otherwise.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_verify.
-   */
-  template <typename VerifyCallback>
-  ASIO_SYNC_OP_VOID set_verify_callback(VerifyCallback callback,
-      asio::error_code& ec);
-
-  /// Load a certification authority file for performing verification.
-  /**
-   * This function is used to load one or more trusted certification authorities
-   * from a file.
-   *
-   * @param filename The name of a file containing certification authority
-   * certificates in PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_load_verify_locations.
-   */
-  ASIO_DECL void load_verify_file(const std::string& filename);
-
-  /// Load a certification authority file for performing verification.
-  /**
-   * This function is used to load the certificates for one or more trusted
-   * certification authorities from a file.
-   *
-   * @param filename The name of a file containing certification authority
-   * certificates in PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_load_verify_locations.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID load_verify_file(
-      const std::string& filename, asio::error_code& ec);
-
-  /// Add certification authority for performing verification.
-  /**
-   * This function is used to add one trusted certification authority
-   * from a memory buffer.
-   *
-   * @param ca The buffer containing the certification authority certificate.
-   * The certificate must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_get_cert_store and @c X509_STORE_add_cert.
-   */
-  ASIO_DECL void add_certificate_authority(const const_buffer& ca);
-
-  /// Add certification authority for performing verification.
-  /**
-   * This function is used to add one trusted certification authority
-   * from a memory buffer.
-   *
-   * @param ca The buffer containing the certification authority certificate.
-   * The certificate must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_get_cert_store and @c X509_STORE_add_cert.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID add_certificate_authority(
-      const const_buffer& ca, asio::error_code& ec);
-
-  /// Configures the context to use the default directories for finding
-  /// certification authority certificates.
-  /**
-   * This function specifies that the context should use the default,
-   * system-dependent directories for locating certification authority
-   * certificates.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_default_verify_paths.
-   */
-  ASIO_DECL void set_default_verify_paths();
-
-  /// Configures the context to use the default directories for finding
-  /// certification authority certificates.
-  /**
-   * This function specifies that the context should use the default,
-   * system-dependent directories for locating certification authority
-   * certificates.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_default_verify_paths.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID set_default_verify_paths(
-      asio::error_code& ec);
-
-  /// Add a directory containing certificate authority files to be used for
-  /// performing verification.
-  /**
-   * This function is used to specify the name of a directory containing
-   * certification authority certificates. Each file in the directory must
-   * contain a single certificate. The files must be named using the subject
-   * name's hash and an extension of ".0".
-   *
-   * @param path The name of a directory containing the certificates.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_load_verify_locations.
-   */
-  ASIO_DECL void add_verify_path(const std::string& path);
-
-  /// Add a directory containing certificate authority files to be used for
-  /// performing verification.
-  /**
-   * This function is used to specify the name of a directory containing
-   * certification authority certificates. Each file in the directory must
-   * contain a single certificate. The files must be named using the subject
-   * name's hash and an extension of ".0".
-   *
-   * @param path The name of a directory containing the certificates.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_load_verify_locations.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID add_verify_path(
-      const std::string& path, asio::error_code& ec);
-
-  /// Use a certificate from a memory buffer.
-  /**
-   * This function is used to load a certificate into the context from a buffer.
-   *
-   * @param certificate The buffer containing the certificate.
-   *
-   * @param format The certificate format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_certificate or SSL_CTX_use_certificate_ASN1.
-   */
-  ASIO_DECL void use_certificate(
-      const const_buffer& certificate, file_format format);
-
-  /// Use a certificate from a memory buffer.
-  /**
-   * This function is used to load a certificate into the context from a buffer.
-   *
-   * @param certificate The buffer containing the certificate.
-   *
-   * @param format The certificate format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_certificate or SSL_CTX_use_certificate_ASN1.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate(
-      const const_buffer& certificate, file_format format,
-      asio::error_code& ec);
-
-  /// Use a certificate from a file.
-  /**
-   * This function is used to load a certificate into the context from a file.
-   *
-   * @param filename The name of the file containing the certificate.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_certificate_file.
-   */
-  ASIO_DECL void use_certificate_file(
-      const std::string& filename, file_format format);
-
-  /// Use a certificate from a file.
-  /**
-   * This function is used to load a certificate into the context from a file.
-   *
-   * @param filename The name of the file containing the certificate.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_certificate_file.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_file(
-      const std::string& filename, file_format format,
-      asio::error_code& ec);
-
-  /// Use a certificate chain from a memory buffer.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * buffer.
-   *
-   * @param chain The buffer containing the certificate chain. The certificate
-   * chain must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_certificate and SSL_CTX_add_extra_chain_cert.
-   */
-  ASIO_DECL void use_certificate_chain(const const_buffer& chain);
-
-  /// Use a certificate chain from a memory buffer.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * buffer.
-   *
-   * @param chain The buffer containing the certificate chain. The certificate
-   * chain must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_certificate and SSL_CTX_add_extra_chain_cert.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_chain(
-      const const_buffer& chain, asio::error_code& ec);
-
-  /// Use a certificate chain from a file.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the certificate. The file
-   * must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_certificate_chain_file.
-   */
-  ASIO_DECL void use_certificate_chain_file(const std::string& filename);
-
-  /// Use a certificate chain from a file.
-  /**
-   * This function is used to load a certificate chain into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the certificate. The file
-   * must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_certificate_chain_file.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_certificate_chain_file(
-      const std::string& filename, asio::error_code& ec);
-
-  /// Use a private key from a memory buffer.
-  /**
-   * This function is used to load a private key into the context from a buffer.
-   *
-   * @param private_key The buffer containing the private key.
-   *
-   * @param format The private key format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_PrivateKey or SSL_CTX_use_PrivateKey_ASN1.
-   */
-  ASIO_DECL void use_private_key(
-      const const_buffer& private_key, file_format format);
-
-  /// Use a private key from a memory buffer.
-  /**
-   * This function is used to load a private key into the context from a buffer.
-   *
-   * @param private_key The buffer containing the private key.
-   *
-   * @param format The private key format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_PrivateKey or SSL_CTX_use_PrivateKey_ASN1.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_private_key(
-      const const_buffer& private_key, file_format format,
-      asio::error_code& ec);
-
-  /// Use a private key from a file.
-  /**
-   * This function is used to load a private key into the context from a file.
-   *
-   * @param filename The name of the file containing the private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_PrivateKey_file.
-   */
-  ASIO_DECL void use_private_key_file(
-      const std::string& filename, file_format format);
-
-  /// Use a private key from a file.
-  /**
-   * This function is used to load a private key into the context from a file.
-   *
-   * @param filename The name of the file containing the private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_PrivateKey_file.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_private_key_file(
-      const std::string& filename, file_format format,
-      asio::error_code& ec);
-
-  /// Use an RSA private key from a memory buffer.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * buffer.
-   *
-   * @param private_key The buffer containing the RSA private key.
-   *
-   * @param format The private key format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_RSAPrivateKey or SSL_CTX_use_RSAPrivateKey_ASN1.
-   */
-  ASIO_DECL void use_rsa_private_key(
-      const const_buffer& private_key, file_format format);
-
-  /// Use an RSA private key from a memory buffer.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * buffer.
-   *
-   * @param private_key The buffer containing the RSA private key.
-   *
-   * @param format The private key format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_RSAPrivateKey or SSL_CTX_use_RSAPrivateKey_ASN1.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_rsa_private_key(
-      const const_buffer& private_key, file_format format,
-      asio::error_code& ec);
-
-  /// Use an RSA private key from a file.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the RSA private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_use_RSAPrivateKey_file.
-   */
-  ASIO_DECL void use_rsa_private_key_file(
-      const std::string& filename, file_format format);
-
-  /// Use an RSA private key from a file.
-  /**
-   * This function is used to load an RSA private key into the context from a
-   * file.
-   *
-   * @param filename The name of the file containing the RSA private key.
-   *
-   * @param format The file format (ASN.1 or PEM).
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_use_RSAPrivateKey_file.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_rsa_private_key_file(
-      const std::string& filename, file_format format,
-      asio::error_code& ec);
-
-  /// Use the specified memory buffer to obtain the temporary Diffie-Hellman
-  /// parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a buffer.
-   *
-   * @param dh The memory buffer containing the Diffie-Hellman parameters. The
-   * buffer must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_tmp_dh.
-   */
-  ASIO_DECL void use_tmp_dh(const const_buffer& dh);
-
-  /// Use the specified memory buffer to obtain the temporary Diffie-Hellman
-  /// parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a buffer.
-   *
-   * @param dh The memory buffer containing the Diffie-Hellman parameters. The
-   * buffer must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_tmp_dh.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_tmp_dh(
-      const const_buffer& dh, asio::error_code& ec);
-
-  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a file.
-   *
-   * @param filename The name of the file containing the Diffie-Hellman
-   * parameters. The file must use the PEM format.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_tmp_dh.
-   */
-  ASIO_DECL void use_tmp_dh_file(const std::string& filename);
-
-  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
-  /**
-   * This function is used to load Diffie-Hellman parameters into the context
-   * from a file.
-   *
-   * @param filename The name of the file containing the Diffie-Hellman
-   * parameters. The file must use the PEM format.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_tmp_dh.
-   */
-  ASIO_DECL ASIO_SYNC_OP_VOID use_tmp_dh_file(
-      const std::string& filename, asio::error_code& ec);
-
-  /// Set the password callback.
-  /**
-   * This function is used to specify a callback function to obtain password
-   * information about an encrypted key in PEM format.
-   *
-   * @param callback The function object to be used for obtaining the password.
-   * The function signature of the handler must be:
-   * @code std::string password_callback(
-   *   std::size_t max_length,  // The maximum size for a password.
-   *   password_purpose purpose // Whether password is for reading or writing.
-   * ); @endcode
-   * The return value of the callback is a string containing the password.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_CTX_set_default_passwd_cb.
-   */
-  template <typename PasswordCallback>
-  void set_password_callback(PasswordCallback callback);
-
-  /// Set the password callback.
-  /**
-   * This function is used to specify a callback function to obtain password
-   * information about an encrypted key in PEM format.
-   *
-   * @param callback The function object to be used for obtaining the password.
-   * The function signature of the handler must be:
-   * @code std::string password_callback(
-   *   std::size_t max_length,  // The maximum size for a password.
-   *   password_purpose purpose // Whether password is for reading or writing.
-   * ); @endcode
-   * The return value of the callback is a string containing the password.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_CTX_set_default_passwd_cb.
-   */
-  template <typename PasswordCallback>
-  ASIO_SYNC_OP_VOID set_password_callback(PasswordCallback callback,
-      asio::error_code& ec);
-
-private:
-  struct bio_cleanup;
-  struct x509_cleanup;
-  struct evp_pkey_cleanup;
-  struct rsa_cleanup;
-  struct dh_cleanup;
-
-  // Helper function used to set a peer certificate verification callback.
-  ASIO_DECL ASIO_SYNC_OP_VOID do_set_verify_callback(
-      detail::verify_callback_base* callback, asio::error_code& ec);
-
-  // Callback used when the SSL implementation wants to verify a certificate.
-  ASIO_DECL static int verify_callback_function(
-      int preverified, X509_STORE_CTX* ctx);
-
-  // Helper function used to set a password callback.
-  ASIO_DECL ASIO_SYNC_OP_VOID do_set_password_callback(
-      detail::password_callback_base* callback, asio::error_code& ec);
-
-  // Callback used when the SSL implementation wants a password.
-  ASIO_DECL static int password_callback_function(
-      char* buf, int size, int purpose, void* data);
-
-  // Helper function to set the temporary Diffie-Hellman parameters from a BIO.
-  ASIO_DECL ASIO_SYNC_OP_VOID do_use_tmp_dh(
-      BIO* bio, asio::error_code& ec);
-
-  // Helper function to make a BIO from a memory buffer.
-  ASIO_DECL BIO* make_buffer_bio(const const_buffer& b);
-
-  // Translate an SSL error into an error code.
-  ASIO_DECL static asio::error_code translate_error(long error);
-
-  // The underlying native implementation.
-  native_handle_type handle_;
-
-  // Ensure openssl is initialised.
-  asio::ssl::detail::openssl_init<> init_;
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/ssl/impl/context.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/impl/context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SSL_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context_base.hpp
deleted file mode 100644
index 3627101..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/context_base.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-//
-// ssl/context_base.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_CONTEXT_BASE_HPP
-#define ASIO_SSL_CONTEXT_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// The context_base class is used as a base for the basic_context class
-/// template so that we have a common place to define various enums.
-class context_base
-{
-public:
-  /// Different methods supported by a context.
-  enum method
-  {
-    /// Generic SSL version 2.
-    sslv2,
-
-    /// SSL version 2 client.
-    sslv2_client,
-
-    /// SSL version 2 server.
-    sslv2_server,
-
-    /// Generic SSL version 3.
-    sslv3,
-
-    /// SSL version 3 client.
-    sslv3_client,
-
-    /// SSL version 3 server.
-    sslv3_server,
-
-    /// Generic TLS version 1.
-    tlsv1,
-
-    /// TLS version 1 client.
-    tlsv1_client,
-
-    /// TLS version 1 server.
-    tlsv1_server,
-
-    /// Generic SSL/TLS.
-    sslv23,
-
-    /// SSL/TLS client.
-    sslv23_client,
-
-    /// SSL/TLS server.
-    sslv23_server,
-
-    /// Generic TLS version 1.1.
-    tlsv11,
-
-    /// TLS version 1.1 client.
-    tlsv11_client,
-
-    /// TLS version 1.1 server.
-    tlsv11_server,
-
-    /// Generic TLS version 1.2.
-    tlsv12,
-
-    /// TLS version 1.2 client.
-    tlsv12_client,
-
-    /// TLS version 1.2 server.
-    tlsv12_server,
-
-    /// Generic TLS version 1.3.
-    tlsv13,
-
-    /// TLS version 1.3 client.
-    tlsv13_client,
-
-    /// TLS version 1.3 server.
-    tlsv13_server,
-
-    /// Generic TLS.
-    tls,
-
-    /// TLS client.
-    tls_client,
-
-    /// TLS server.
-    tls_server
-  };
-
-  /// Bitmask type for SSL options.
-  typedef uint64_t options;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Implement various bug workarounds.
-  static const uint64_t default_workarounds = implementation_defined;
-
-  /// Always create a new key when using tmp_dh parameters.
-  static const uint64_t single_dh_use = implementation_defined;
-
-  /// Disable SSL v2.
-  static const uint64_t no_sslv2 = implementation_defined;
-
-  /// Disable SSL v3.
-  static const uint64_t no_sslv3 = implementation_defined;
-
-  /// Disable TLS v1.
-  static const uint64_t no_tlsv1 = implementation_defined;
-
-  /// Disable TLS v1.1.
-  static const uint64_t no_tlsv1_1 = implementation_defined;
-
-  /// Disable TLS v1.2.
-  static const uint64_t no_tlsv1_2 = implementation_defined;
-
-  /// Disable TLS v1.3.
-  static const uint64_t no_tlsv1_3 = implementation_defined;
-
-  /// Disable compression. Compression is disabled by default.
-  static const uint64_t no_compression = implementation_defined;
-#else
-  ASIO_STATIC_CONSTANT(uint64_t, default_workarounds = SSL_OP_ALL);
-  ASIO_STATIC_CONSTANT(uint64_t, single_dh_use = SSL_OP_SINGLE_DH_USE);
-  ASIO_STATIC_CONSTANT(uint64_t, no_sslv2 = SSL_OP_NO_SSLv2);
-  ASIO_STATIC_CONSTANT(uint64_t, no_sslv3 = SSL_OP_NO_SSLv3);
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1 = SSL_OP_NO_TLSv1);
-# if defined(SSL_OP_NO_TLSv1_1)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_1 = SSL_OP_NO_TLSv1_1);
-# else // defined(SSL_OP_NO_TLSv1_1)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_1 = 0x10000000L);
-# endif // defined(SSL_OP_NO_TLSv1_1)
-# if defined(SSL_OP_NO_TLSv1_2)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_2 = SSL_OP_NO_TLSv1_2);
-# else // defined(SSL_OP_NO_TLSv1_2)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_2 = 0x08000000L);
-# endif // defined(SSL_OP_NO_TLSv1_2)
-# if defined(SSL_OP_NO_TLSv1_3)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_3 = SSL_OP_NO_TLSv1_3);
-# else // defined(SSL_OP_NO_TLSv1_3)
-  ASIO_STATIC_CONSTANT(uint64_t, no_tlsv1_3 = 0x20000000L);
-# endif // defined(SSL_OP_NO_TLSv1_3)
-# if defined(SSL_OP_NO_COMPRESSION)
-  ASIO_STATIC_CONSTANT(uint64_t, no_compression = SSL_OP_NO_COMPRESSION);
-# else // defined(SSL_OP_NO_COMPRESSION)
-  ASIO_STATIC_CONSTANT(uint64_t, no_compression = 0x20000L);
-# endif // defined(SSL_OP_NO_COMPRESSION)
-#endif
-
-  /// File format types.
-  enum file_format
-  {
-    /// ASN.1 file.
-    asn1,
-
-    /// PEM file.
-    pem
-  };
-
-#if !defined(GENERATING_DOCUMENTATION)
-  // The following types and constants are preserved for backward compatibility.
-  // New programs should use the equivalents of the same names that are defined
-  // in the asio::ssl namespace.
-  typedef int verify_mode;
-  ASIO_STATIC_CONSTANT(int, verify_none = SSL_VERIFY_NONE);
-  ASIO_STATIC_CONSTANT(int, verify_peer = SSL_VERIFY_PEER);
-  ASIO_STATIC_CONSTANT(int,
-      verify_fail_if_no_peer_cert = SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
-  ASIO_STATIC_CONSTANT(int, verify_client_once = SSL_VERIFY_CLIENT_ONCE);
-#endif
-
-  /// Purpose of PEM password.
-  enum password_purpose
-  {
-    /// The password is needed for reading/decryption.
-    for_reading,
-
-    /// The password is needed for writing/encryption.
-    for_writing
-  };
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~context_base()
-  {
-  }
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_CONTEXT_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/buffered_handshake_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/buffered_handshake_op.hpp
deleted file mode 100644
index 4dba712..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/buffered_handshake_op.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// ssl/detail/buffered_handshake_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
-#define ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/ssl/detail/engine.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class buffered_handshake_op
-{
-public:
-  static constexpr const char* tracking_name()
-  {
-    return "ssl::stream<>::async_buffered_handshake";
-  }
-
-  buffered_handshake_op(stream_base::handshake_type type,
-      const ConstBufferSequence& buffers)
-    : type_(type),
-      buffers_(buffers),
-      total_buffer_size_(asio::buffer_size(buffers_))
-  {
-  }
-
-  engine::want operator()(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred) const
-  {
-    return this->process(eng, ec, bytes_transferred,
-        asio::buffer_sequence_begin(buffers_),
-        asio::buffer_sequence_end(buffers_));
-  }
-
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t& bytes_transferred) const
-  {
-    static_cast<Handler&&>(handler)(ec, bytes_transferred);
-  }
-
-private:
-  template <typename Iterator>
-  engine::want process(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred,
-      Iterator begin, Iterator end) const
-  {
-    Iterator iter = begin;
-    std::size_t accumulated_size = 0;
-
-    for (;;)
-    {
-      engine::want want = eng.handshake(type_, ec);
-      if (want != engine::want_input_and_retry
-          || bytes_transferred == total_buffer_size_)
-        return want;
-
-      // Find the next buffer piece to be fed to the engine.
-      while (iter != end)
-      {
-        const_buffer buffer(*iter);
-
-        // Skip over any buffers which have already been consumed by the engine.
-        if (bytes_transferred >= accumulated_size + buffer.size())
-        {
-          accumulated_size += buffer.size();
-          ++iter;
-          continue;
-        }
-
-        // The current buffer may have been partially consumed by the engine on
-        // a previous iteration. If so, adjust the buffer to point to the
-        // unused portion.
-        if (bytes_transferred > accumulated_size)
-          buffer = buffer + (bytes_transferred - accumulated_size);
-
-        // Pass the buffer to the engine, and update the bytes transferred to
-        // reflect the total number of bytes consumed so far.
-        bytes_transferred += buffer.size();
-        buffer = eng.put_input(buffer);
-        bytes_transferred -= buffer.size();
-        break;
-      }
-    }
-  }
-
-  stream_base::handshake_type type_;
-  ConstBufferSequence buffers_;
-  std::size_t total_buffer_size_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/engine.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/engine.hpp
deleted file mode 100644
index e500ca5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/engine.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// ssl/detail/engine.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_ENGINE_HPP
-#define ASIO_SSL_DETAIL_ENGINE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/buffer.hpp"
-#include "asio/detail/static_mutex.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/ssl/detail/verify_callback.hpp"
-#include "asio/ssl/stream_base.hpp"
-#include "asio/ssl/verify_mode.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class engine
-{
-public:
-  enum want
-  {
-    // Returned by functions to indicate that the engine wants input. The input
-    // buffer should be updated to point to the data. The engine then needs to
-    // be called again to retry the operation.
-    want_input_and_retry = -2,
-
-    // Returned by functions to indicate that the engine wants to write output.
-    // The output buffer points to the data to be written. The engine then
-    // needs to be called again to retry the operation.
-    want_output_and_retry = -1,
-
-    // Returned by functions to indicate that the engine doesn't need input or
-    // output.
-    want_nothing = 0,
-
-    // Returned by functions to indicate that the engine wants to write output.
-    // The output buffer points to the data to be written. After that the
-    // operation is complete, and the engine does not need to be called again.
-    want_output = 1
-  };
-
-  // Construct a new engine for the specified context.
-  ASIO_DECL explicit engine(SSL_CTX* context);
-
-  // Construct a new engine for an existing native SSL implementation.
-  ASIO_DECL explicit engine(SSL* ssl_impl);
-
-  // Move construct from another engine.
-  ASIO_DECL engine(engine&& other) noexcept;
-
-  // Destructor.
-  ASIO_DECL ~engine();
-
-  // Move assign from another engine.
-  ASIO_DECL engine& operator=(engine&& other) noexcept;
-
-  // Get the underlying implementation in the native type.
-  ASIO_DECL SSL* native_handle();
-
-  // Set the peer verification mode.
-  ASIO_DECL asio::error_code set_verify_mode(
-      verify_mode v, asio::error_code& ec);
-
-  // Set the peer verification depth.
-  ASIO_DECL asio::error_code set_verify_depth(
-      int depth, asio::error_code& ec);
-
-  // Set a peer certificate verification callback.
-  ASIO_DECL asio::error_code set_verify_callback(
-      verify_callback_base* callback, asio::error_code& ec);
-
-  // Perform an SSL handshake using either SSL_connect (client-side) or
-  // SSL_accept (server-side).
-  ASIO_DECL want handshake(
-      stream_base::handshake_type type, asio::error_code& ec);
-
-  // Perform a graceful shutdown of the SSL session.
-  ASIO_DECL want shutdown(asio::error_code& ec);
-
-  // Write bytes to the SSL session.
-  ASIO_DECL want write(const asio::const_buffer& data,
-      asio::error_code& ec, std::size_t& bytes_transferred);
-
-  // Read bytes from the SSL session.
-  ASIO_DECL want read(const asio::mutable_buffer& data,
-      asio::error_code& ec, std::size_t& bytes_transferred);
-
-  // Get output data to be written to the transport.
-  ASIO_DECL asio::mutable_buffer get_output(
-      const asio::mutable_buffer& data);
-
-  // Put input data that was read from the transport.
-  ASIO_DECL asio::const_buffer put_input(
-      const asio::const_buffer& data);
-
-  // Map an error::eof code returned by the underlying transport according to
-  // the type and state of the SSL session. Returns a const reference to the
-  // error code object, suitable for passing to a completion handler.
-  ASIO_DECL const asio::error_code& map_error_code(
-      asio::error_code& ec) const;
-
-private:
-  // Disallow copying and assignment.
-  engine(const engine&);
-  engine& operator=(const engine&);
-
-  // Callback used when the SSL implementation wants to verify a certificate.
-  ASIO_DECL static int verify_callback_function(
-      int preverified, X509_STORE_CTX* ctx);
-
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  // The SSL_accept function may not be thread safe. This mutex is used to
-  // protect all calls to the SSL_accept function.
-  ASIO_DECL static asio::detail::static_mutex& accept_mutex();
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-  // Perform one operation. Returns >= 0 on success or error, want_read if the
-  // operation needs more input, or want_write if it needs to write some output
-  // before the operation can complete.
-  ASIO_DECL want perform(int (engine::* op)(void*, std::size_t),
-      void* data, std::size_t length, asio::error_code& ec,
-      std::size_t* bytes_transferred);
-
-  // Adapt the SSL_accept function to the signature needed for perform().
-  ASIO_DECL int do_accept(void*, std::size_t);
-
-  // Adapt the SSL_connect function to the signature needed for perform().
-  ASIO_DECL int do_connect(void*, std::size_t);
-
-  // Adapt the SSL_shutdown function to the signature needed for perform().
-  ASIO_DECL int do_shutdown(void*, std::size_t);
-
-  // Adapt the SSL_read function to the signature needed for perform().
-  ASIO_DECL int do_read(void* data, std::size_t length);
-
-  // Adapt the SSL_write function to the signature needed for perform().
-  ASIO_DECL int do_write(void* data, std::size_t length);
-
-  SSL* ssl_;
-  BIO* ext_bio_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/detail/impl/engine.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SSL_DETAIL_ENGINE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/handshake_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/handshake_op.hpp
deleted file mode 100644
index 53533eb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/handshake_op.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ssl/detail/handshake_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
-#define ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/ssl/detail/engine.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class handshake_op
-{
-public:
-  static constexpr const char* tracking_name()
-  {
-    return "ssl::stream<>::async_handshake";
-  }
-
-  handshake_op(stream_base::handshake_type type)
-    : type_(type)
-  {
-  }
-
-  engine::want operator()(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred) const
-  {
-    bytes_transferred = 0;
-    return eng.handshake(type_, ec);
-  }
-
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t&) const
-  {
-    static_cast<Handler&&>(handler)(ec);
-  }
-
-private:
-  stream_base::handshake_type type_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/engine.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/engine.ipp
deleted file mode 100644
index 91588cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/engine.ipp
+++ /dev/null
@@ -1,377 +0,0 @@
-//
-// ssl/detail/impl/engine.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
-#define ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/ssl/detail/engine.hpp"
-#include "asio/ssl/error.hpp"
-#include "asio/ssl/verify_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-engine::engine(SSL_CTX* context)
-  : ssl_(::SSL_new(context))
-{
-  if (!ssl_)
-  {
-    asio::error_code ec(
-        static_cast<int>(::ERR_get_error()),
-        asio::error::get_ssl_category());
-    asio::detail::throw_error(ec, "engine");
-  }
-
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  accept_mutex().init();
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-  ::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
-  ::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
-#if defined(SSL_MODE_RELEASE_BUFFERS)
-  ::SSL_set_mode(ssl_, SSL_MODE_RELEASE_BUFFERS);
-#endif // defined(SSL_MODE_RELEASE_BUFFERS)
-
-  ::BIO* int_bio = 0;
-  ::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
-  ::SSL_set_bio(ssl_, int_bio, int_bio);
-}
-
-engine::engine(SSL* ssl_impl)
-  : ssl_(ssl_impl)
-{
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  accept_mutex().init();
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-  ::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
-  ::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
-#if defined(SSL_MODE_RELEASE_BUFFERS)
-  ::SSL_set_mode(ssl_, SSL_MODE_RELEASE_BUFFERS);
-#endif // defined(SSL_MODE_RELEASE_BUFFERS)
-
-  ::BIO* int_bio = 0;
-  ::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
-  ::SSL_set_bio(ssl_, int_bio, int_bio);
-}
-
-engine::engine(engine&& other) noexcept
-  : ssl_(other.ssl_),
-    ext_bio_(other.ext_bio_)
-{
-  other.ssl_ = 0;
-  other.ext_bio_ = 0;
-}
-
-engine::~engine()
-{
-  if (ssl_ && SSL_get_app_data(ssl_))
-  {
-    delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
-    SSL_set_app_data(ssl_, 0);
-  }
-
-  if (ext_bio_)
-    ::BIO_free(ext_bio_);
-
-  if (ssl_)
-    ::SSL_free(ssl_);
-}
-
-engine& engine::operator=(engine&& other) noexcept
-{
-  if (this != &other)
-  {
-    ssl_ = other.ssl_;
-    ext_bio_ = other.ext_bio_;
-    other.ssl_ = 0;
-    other.ext_bio_ = 0;
-  }
-  return *this;
-}
-
-SSL* engine::native_handle()
-{
-  return ssl_;
-}
-
-asio::error_code engine::set_verify_mode(
-    verify_mode v, asio::error_code& ec)
-{
-  ::SSL_set_verify(ssl_, v, ::SSL_get_verify_callback(ssl_));
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code engine::set_verify_depth(
-    int depth, asio::error_code& ec)
-{
-  ::SSL_set_verify_depth(ssl_, depth);
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code engine::set_verify_callback(
-    verify_callback_base* callback, asio::error_code& ec)
-{
-  if (SSL_get_app_data(ssl_))
-    delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
-
-  SSL_set_app_data(ssl_, callback);
-
-  ::SSL_set_verify(ssl_, ::SSL_get_verify_mode(ssl_),
-      &engine::verify_callback_function);
-
-  ec = asio::error_code();
-  return ec;
-}
-
-int engine::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
-{
-  if (ctx)
-  {
-    if (SSL* ssl = static_cast<SSL*>(
-          ::X509_STORE_CTX_get_ex_data(
-            ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
-    {
-      if (SSL_get_app_data(ssl))
-      {
-        verify_callback_base* callback =
-          static_cast<verify_callback_base*>(
-              SSL_get_app_data(ssl));
-
-        verify_context verify_ctx(ctx);
-        return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
-      }
-    }
-  }
-
-  return 0;
-}
-
-engine::want engine::handshake(
-    stream_base::handshake_type type, asio::error_code& ec)
-{
-  return perform((type == asio::ssl::stream_base::client)
-      ? &engine::do_connect : &engine::do_accept, 0, 0, ec, 0);
-}
-
-engine::want engine::shutdown(asio::error_code& ec)
-{
-  return perform(&engine::do_shutdown, 0, 0, ec, 0);
-}
-
-engine::want engine::write(const asio::const_buffer& data,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  if (data.size() == 0)
-  {
-    ec = asio::error_code();
-    return engine::want_nothing;
-  }
-
-  return perform(&engine::do_write,
-      const_cast<void*>(data.data()),
-      data.size(), ec, &bytes_transferred);
-}
-
-engine::want engine::read(const asio::mutable_buffer& data,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  if (data.size() == 0)
-  {
-    ec = asio::error_code();
-    return engine::want_nothing;
-  }
-
-  return perform(&engine::do_read, data.data(),
-      data.size(), ec, &bytes_transferred);
-}
-
-asio::mutable_buffer engine::get_output(
-    const asio::mutable_buffer& data)
-{
-  int length = ::BIO_read(ext_bio_,
-      data.data(), static_cast<int>(data.size()));
-
-  return asio::buffer(data,
-      length > 0 ? static_cast<std::size_t>(length) : 0);
-}
-
-asio::const_buffer engine::put_input(
-    const asio::const_buffer& data)
-{
-  int length = ::BIO_write(ext_bio_,
-      data.data(), static_cast<int>(data.size()));
-
-  return asio::buffer(data +
-      (length > 0 ? static_cast<std::size_t>(length) : 0));
-}
-
-const asio::error_code& engine::map_error_code(
-    asio::error_code& ec) const
-{
-  // We only want to map the error::eof code.
-  if (ec != asio::error::eof)
-    return ec;
-
-  // If there's data yet to be read, it's an error.
-  if (BIO_wpending(ext_bio_))
-  {
-    ec = asio::ssl::error::stream_truncated;
-    return ec;
-  }
-
-  // SSL v2 doesn't provide a protocol-level shutdown, so an eof on the
-  // underlying transport is passed through.
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-  if (SSL_version(ssl_) == SSL2_VERSION)
-    return ec;
-#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
-
-  // Otherwise, the peer should have negotiated a proper shutdown.
-  if ((::SSL_get_shutdown(ssl_) & SSL_RECEIVED_SHUTDOWN) == 0)
-  {
-    ec = asio::ssl::error::stream_truncated;
-  }
-
-  return ec;
-}
-
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-asio::detail::static_mutex& engine::accept_mutex()
-{
-  static asio::detail::static_mutex mutex = ASIO_STATIC_MUTEX_INIT;
-  return mutex;
-}
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-engine::want engine::perform(int (engine::* op)(void*, std::size_t),
-    void* data, std::size_t length, asio::error_code& ec,
-    std::size_t* bytes_transferred)
-{
-  std::size_t pending_output_before = ::BIO_ctrl_pending(ext_bio_);
-  ::ERR_clear_error();
-  int result = (this->*op)(data, length);
-  int ssl_error = ::SSL_get_error(ssl_, result);
-  int sys_error = static_cast<int>(::ERR_get_error());
-  std::size_t pending_output_after = ::BIO_ctrl_pending(ext_bio_);
-
-  if (ssl_error == SSL_ERROR_SSL)
-  {
-    ec = asio::error_code(sys_error,
-        asio::error::get_ssl_category());
-    return pending_output_after > pending_output_before
-      ? want_output : want_nothing;
-  }
-
-  if (ssl_error == SSL_ERROR_SYSCALL)
-  {
-    if (sys_error == 0)
-    {
-      ec = asio::ssl::error::unspecified_system_error;
-    }
-    else
-    {
-      ec = asio::error_code(sys_error,
-          asio::error::get_ssl_category());
-    }
-    return pending_output_after > pending_output_before
-      ? want_output : want_nothing;
-  }
-
-  if (result > 0 && bytes_transferred)
-    *bytes_transferred = static_cast<std::size_t>(result);
-
-  if (ssl_error == SSL_ERROR_WANT_WRITE)
-  {
-    ec = asio::error_code();
-    return want_output_and_retry;
-  }
-  else if (pending_output_after > pending_output_before)
-  {
-    ec = asio::error_code();
-    return result > 0 ? want_output : want_output_and_retry;
-  }
-  else if (ssl_error == SSL_ERROR_WANT_READ)
-  {
-    ec = asio::error_code();
-    return want_input_and_retry;
-  }
-  else if (ssl_error == SSL_ERROR_ZERO_RETURN)
-  {
-    ec = asio::error::eof;
-    return want_nothing;
-  }
-  else if (ssl_error == SSL_ERROR_NONE)
-  {
-    ec = asio::error_code();
-    return want_nothing;
-  }
-  else
-  {
-    ec = asio::ssl::error::unexpected_result;
-    return want_nothing;
-  }
-}
-
-int engine::do_accept(void*, std::size_t)
-{
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  asio::detail::static_mutex::scoped_lock lock(accept_mutex());
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  return ::SSL_accept(ssl_);
-}
-
-int engine::do_connect(void*, std::size_t)
-{
-  return ::SSL_connect(ssl_);
-}
-
-int engine::do_shutdown(void*, std::size_t)
-{
-  int result = ::SSL_shutdown(ssl_);
-  if (result == 0)
-    result = ::SSL_shutdown(ssl_);
-  return result;
-}
-
-int engine::do_read(void* data, std::size_t length)
-{
-  return ::SSL_read(ssl_, data,
-      length < INT_MAX ? static_cast<int>(length) : INT_MAX);
-}
-
-int engine::do_write(void* data, std::size_t length)
-{
-  return ::SSL_write(ssl_, data,
-      length < INT_MAX ? static_cast<int>(length) : INT_MAX);
-}
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/openssl_init.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/openssl_init.ipp
deleted file mode 100644
index 511809e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/impl/openssl_init.ipp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// ssl/detail/impl/openssl_init.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
-#define ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <vector>
-#include "asio/detail/assert.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/tss_ptr.hpp"
-#include "asio/ssl/detail/openssl_init.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class openssl_init_base::do_init
-{
-public:
-  do_init()
-  {
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ::SSL_library_init();
-    ::SSL_load_error_strings();
-    ::OpenSSL_add_all_algorithms();
-
-    mutexes_.resize(::CRYPTO_num_locks());
-    for (size_t i = 0; i < mutexes_.size(); ++i)
-      mutexes_[i].reset(new asio::detail::mutex);
-    ::CRYPTO_set_locking_callback(&do_init::openssl_locking_func);
-#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-    ::CRYPTO_set_id_callback(&do_init::openssl_id_func);
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    null_compression_methods_ = sk_SSL_COMP_new_null();
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-  }
-
-  ~do_init()
-  {
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    sk_SSL_COMP_free(null_compression_methods_);
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-    ::CRYPTO_set_id_callback(0);
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ::CRYPTO_set_locking_callback(0);
-    ::ERR_free_strings();
-    ::EVP_cleanup();
-    ::CRYPTO_cleanup_all_ex_data();
-#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-    ::ERR_remove_state(0);
-#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ::ERR_remove_thread_state(NULL);
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) \
-    && (OPENSSL_VERSION_NUMBER < 0x10100000L) \
-    && !defined(SSL_OP_NO_COMPRESSION)
-    ::SSL_COMP_free_compression_methods();
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)
-       // && (OPENSSL_VERSION_NUMBER < 0x10100000L)
-       // && !defined(SSL_OP_NO_COMPRESSION)
-#if !defined(OPENSSL_IS_BORINGSSL) \
-    && !defined(ASIO_USE_WOLFSSL) \
-    && (OPENSSL_VERSION_NUMBER < 0x30000000L)
-    ::CONF_modules_unload(1);
-#endif // !defined(OPENSSL_IS_BORINGSSL)
-       //   && !defined(ASIO_USE_WOLFSSL)
-       //   && (OPENSSL_VERSION_NUMBER < 0x30000000L)
-#if !defined(OPENSSL_NO_ENGINE) \
-  && (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ::ENGINE_cleanup();
-#endif // !defined(OPENSSL_NO_ENGINE)
-       // && (OPENSSL_VERSION_NUMBER < 0x10100000L)
-  }
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-  STACK_OF(SSL_COMP)* get_null_compression_methods() const
-  {
-    return null_compression_methods_;
-  }
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-
-private:
-#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
-  static unsigned long openssl_id_func()
-  {
-#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    return ::GetCurrentThreadId();
-#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-    void* id = &errno;
-    ASIO_ASSERT(sizeof(unsigned long) >= sizeof(void*));
-    return reinterpret_cast<unsigned long>(id);
-#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
-  }
-#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
-
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
-  static void openssl_locking_func(int mode, int n,
-    const char* /*file*/, int /*line*/)
-  {
-    if (mode & CRYPTO_LOCK)
-      instance()->mutexes_[n]->lock();
-    else
-      instance()->mutexes_[n]->unlock();
-  }
-
-  // Mutexes to be used in locking callbacks.
-  std::vector<asio::detail::shared_ptr<
-        asio::detail::mutex>> mutexes_;
-#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-  STACK_OF(SSL_COMP)* null_compression_methods_;
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-};
-
-asio::detail::shared_ptr<openssl_init_base::do_init>
-openssl_init_base::instance()
-{
-  static asio::detail::shared_ptr<do_init> init(new do_init);
-  return init;
-}
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-STACK_OF(SSL_COMP)* openssl_init_base::get_null_compression_methods()
-{
-  return instance()->get_null_compression_methods();
-}
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/io.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/io.hpp
deleted file mode 100644
index d951db5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/io.hpp
+++ /dev/null
@@ -1,376 +0,0 @@
-//
-// ssl/detail/io.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_IO_HPP
-#define ASIO_SSL_DETAIL_IO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/base_from_cancellation_state.hpp"
-#include "asio/detail/handler_tracking.hpp"
-#include "asio/ssl/detail/engine.hpp"
-#include "asio/ssl/detail/stream_core.hpp"
-#include "asio/write.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-template <typename Stream, typename Operation>
-std::size_t io(Stream& next_layer, stream_core& core,
-    const Operation& op, asio::error_code& ec)
-{
-  asio::error_code io_ec;
-  std::size_t bytes_transferred = 0;
-  do switch (op(core.engine_, ec, bytes_transferred))
-  {
-  case engine::want_input_and_retry:
-
-    // If the input buffer is empty then we need to read some more data from
-    // the underlying transport.
-    if (core.input_.size() == 0)
-    {
-      core.input_ = asio::buffer(core.input_buffer_,
-          next_layer.read_some(core.input_buffer_, io_ec));
-      if (!ec)
-        ec = io_ec;
-    }
-
-    // Pass the new input data to the engine.
-    core.input_ = core.engine_.put_input(core.input_);
-
-    // Try the operation again.
-    continue;
-
-  case engine::want_output_and_retry:
-
-    // Get output data from the engine and write it to the underlying
-    // transport.
-    asio::write(next_layer,
-        core.engine_.get_output(core.output_buffer_), io_ec);
-    if (!ec)
-      ec = io_ec;
-
-    // Try the operation again.
-    continue;
-
-  case engine::want_output:
-
-    // Get output data from the engine and write it to the underlying
-    // transport.
-    asio::write(next_layer,
-        core.engine_.get_output(core.output_buffer_), io_ec);
-    if (!ec)
-      ec = io_ec;
-
-    // Operation is complete. Return result to caller.
-    core.engine_.map_error_code(ec);
-    return bytes_transferred;
-
-  default:
-
-    // Operation is complete. Return result to caller.
-    core.engine_.map_error_code(ec);
-    return bytes_transferred;
-
-  } while (!ec);
-
-  // Operation failed. Return result to caller.
-  core.engine_.map_error_code(ec);
-  return 0;
-}
-
-template <typename Stream, typename Operation, typename Handler>
-class io_op
-  : public asio::detail::base_from_cancellation_state<Handler>
-{
-public:
-  io_op(Stream& next_layer, stream_core& core,
-      const Operation& op, Handler& handler)
-    : asio::detail::base_from_cancellation_state<Handler>(handler),
-      next_layer_(next_layer),
-      core_(core),
-      op_(op),
-      start_(0),
-      want_(engine::want_nothing),
-      bytes_transferred_(0),
-      handler_(static_cast<Handler&&>(handler))
-  {
-  }
-
-  io_op(const io_op& other)
-    : asio::detail::base_from_cancellation_state<Handler>(other),
-      next_layer_(other.next_layer_),
-      core_(other.core_),
-      op_(other.op_),
-      start_(other.start_),
-      want_(other.want_),
-      ec_(other.ec_),
-      bytes_transferred_(other.bytes_transferred_),
-      handler_(other.handler_)
-  {
-  }
-
-  io_op(io_op&& other)
-    : asio::detail::base_from_cancellation_state<Handler>(
-        static_cast<
-          asio::detail::base_from_cancellation_state<Handler>&&>(other)),
-      next_layer_(other.next_layer_),
-      core_(other.core_),
-      op_(static_cast<Operation&&>(other.op_)),
-      start_(other.start_),
-      want_(other.want_),
-      ec_(other.ec_),
-      bytes_transferred_(other.bytes_transferred_),
-      handler_(static_cast<Handler&&>(other.handler_))
-  {
-  }
-
-  void operator()(asio::error_code ec,
-      std::size_t bytes_transferred = ~std::size_t(0), int start = 0)
-  {
-    switch (start_ = start)
-    {
-    case 1: // Called after at least one async operation.
-      do
-      {
-        switch (want_ = op_(core_.engine_, ec_, bytes_transferred_))
-        {
-        case engine::want_input_and_retry:
-
-          // If the input buffer already has data in it we can pass it to the
-          // engine and then retry the operation immediately.
-          if (core_.input_.size() != 0)
-          {
-            core_.input_ = core_.engine_.put_input(core_.input_);
-            continue;
-          }
-
-          // The engine wants more data to be read from input. However, we
-          // cannot allow more than one read operation at a time on the
-          // underlying transport. The pending_read_ timer's expiry is set to
-          // pos_infin if a read is in progress, and neg_infin otherwise.
-          if (core_.expiry(core_.pending_read_) == core_.neg_infin())
-          {
-            // Prevent other read operations from being started.
-            core_.pending_read_.expires_at(core_.pos_infin());
-
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, Operation::tracking_name()));
-
-            // Start reading some data from the underlying transport.
-            next_layer_.async_read_some(
-                asio::buffer(core_.input_buffer_),
-                static_cast<io_op&&>(*this));
-          }
-          else
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, Operation::tracking_name()));
-
-            // Wait until the current read operation completes.
-            core_.pending_read_.async_wait(static_cast<io_op&&>(*this));
-          }
-
-          // Yield control until asynchronous operation completes. Control
-          // resumes at the "default:" label below.
-          return;
-
-        case engine::want_output_and_retry:
-        case engine::want_output:
-
-          // The engine wants some data to be written to the output. However, we
-          // cannot allow more than one write operation at a time on the
-          // underlying transport. The pending_write_ timer's expiry is set to
-          // pos_infin if a write is in progress, and neg_infin otherwise.
-          if (core_.expiry(core_.pending_write_) == core_.neg_infin())
-          {
-            // Prevent other write operations from being started.
-            core_.pending_write_.expires_at(core_.pos_infin());
-
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, Operation::tracking_name()));
-
-            // Start writing all the data to the underlying transport.
-            asio::async_write(next_layer_,
-                core_.engine_.get_output(core_.output_buffer_),
-                static_cast<io_op&&>(*this));
-          }
-          else
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, Operation::tracking_name()));
-
-            // Wait until the current write operation completes.
-            core_.pending_write_.async_wait(static_cast<io_op&&>(*this));
-          }
-
-          // Yield control until asynchronous operation completes. Control
-          // resumes at the "default:" label below.
-          return;
-
-        default:
-
-          // The SSL operation is done and we can invoke the handler, but we
-          // have to keep in mind that this function might be being called from
-          // the async operation's initiating function. In this case we're not
-          // allowed to call the handler directly. Instead, issue a zero-sized
-          // read so the handler runs "as-if" posted using io_context::post().
-          if (start)
-          {
-            ASIO_HANDLER_LOCATION((
-                  __FILE__, __LINE__, Operation::tracking_name()));
-
-            next_layer_.async_read_some(
-                asio::buffer(core_.input_buffer_, 0),
-                static_cast<io_op&&>(*this));
-
-            // Yield control until asynchronous operation completes. Control
-            // resumes at the "default:" label below.
-            return;
-          }
-          else
-          {
-            // Continue on to run handler directly.
-            break;
-          }
-        }
-
-        default:
-        if (bytes_transferred == ~std::size_t(0))
-          bytes_transferred = 0; // Timer cancellation, no data transferred.
-        else if (!ec_)
-          ec_ = ec;
-
-        switch (want_)
-        {
-        case engine::want_input_and_retry:
-
-          // Add received data to the engine's input.
-          core_.input_ = asio::buffer(
-              core_.input_buffer_, bytes_transferred);
-          core_.input_ = core_.engine_.put_input(core_.input_);
-
-          // Release any waiting read operations.
-          core_.pending_read_.expires_at(core_.neg_infin());
-
-          // Check for cancellation before continuing.
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec_ = asio::error::operation_aborted;
-            break;
-          }
-
-          // Try the operation again.
-          continue;
-
-        case engine::want_output_and_retry:
-
-          // Release any waiting write operations.
-          core_.pending_write_.expires_at(core_.neg_infin());
-
-          // Check for cancellation before continuing.
-          if (this->cancelled() != cancellation_type::none)
-          {
-            ec_ = asio::error::operation_aborted;
-            break;
-          }
-
-          // Try the operation again.
-          continue;
-
-        case engine::want_output:
-
-          // Release any waiting write operations.
-          core_.pending_write_.expires_at(core_.neg_infin());
-
-          // Fall through to call handler.
-
-        default:
-
-          // Pass the result to the handler.
-          op_.call_handler(handler_,
-              core_.engine_.map_error_code(ec_),
-              ec_ ? 0 : bytes_transferred_);
-
-          // Our work here is done.
-          return;
-        }
-      } while (!ec_);
-
-      // Operation failed. Pass the result to the handler.
-      op_.call_handler(handler_, core_.engine_.map_error_code(ec_), 0);
-    }
-  }
-
-//private:
-  Stream& next_layer_;
-  stream_core& core_;
-  Operation op_;
-  int start_;
-  engine::want want_;
-  asio::error_code ec_;
-  std::size_t bytes_transferred_;
-  Handler handler_;
-};
-
-template <typename Stream, typename Operation, typename Handler>
-inline bool asio_handler_is_continuation(
-    io_op<Stream, Operation, Handler>* this_handler)
-{
-  return this_handler->start_ == 0 ? true
-    : asio_handler_cont_helpers::is_continuation(this_handler->handler_);
-}
-
-template <typename Stream, typename Operation, typename Handler>
-inline void async_io(Stream& next_layer, stream_core& core,
-    const Operation& op, Handler& handler)
-{
-  io_op<Stream, Operation, Handler>(
-    next_layer, core, op, handler)(
-      asio::error_code(), 0, 1);
-}
-
-} // namespace detail
-} // namespace ssl
-
-template <template <typename, typename> class Associator,
-    typename Stream, typename Operation,
-    typename Handler, typename DefaultCandidate>
-struct associator<Associator,
-    ssl::detail::io_op<Stream, Operation, Handler>,
-    DefaultCandidate>
-  : Associator<Handler, DefaultCandidate>
-{
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const ssl::detail::io_op<Stream, Operation, Handler>& h) noexcept
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_);
-  }
-
-  static auto get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
-      const DefaultCandidate& c) noexcept
-    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
-  {
-    return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_IO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_init.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_init.hpp
deleted file mode 100644
index c66d9d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_init.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// ssl/detail/openssl_init.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
-#define ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstring>
-#include "asio/detail/memory.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class openssl_init_base
-  : private noncopyable
-{
-protected:
-  // Class that performs the actual initialisation.
-  class do_init;
-
-  // Helper function to manage a do_init singleton. The static instance of the
-  // openssl_init object ensures that this function is always called before
-  // main, and therefore before any other threads can get started. The do_init
-  // instance must be static in this function to ensure that it gets
-  // initialised before any other global objects try to use it.
-  ASIO_DECL static asio::detail::shared_ptr<do_init> instance();
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-  // Get an empty stack of compression methods, to be used when disabling
-  // compression.
-  ASIO_DECL static STACK_OF(SSL_COMP)* get_null_compression_methods();
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-};
-
-template <bool Do_Init = true>
-class openssl_init : private openssl_init_base
-{
-public:
-  // Constructor.
-  openssl_init()
-    : ref_(instance())
-  {
-    using namespace std; // For memmove.
-
-    // Ensure openssl_init::instance_ is linked in.
-    openssl_init* tmp = &instance_;
-    memmove(&tmp, &tmp, sizeof(openssl_init*));
-  }
-
-  // Destructor.
-  ~openssl_init()
-  {
-  }
-
-#if !defined(SSL_OP_NO_COMPRESSION) \
-  && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-  using openssl_init_base::get_null_compression_methods;
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-       // && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-
-private:
-  // Instance to force initialisation of openssl at global scope.
-  static openssl_init instance_;
-
-  // Reference to singleton do_init object to ensure that openssl does not get
-  // cleaned up until the last user has finished with it.
-  asio::detail::shared_ptr<do_init> ref_;
-};
-
-template <bool Do_Init>
-openssl_init<Do_Init> openssl_init<Do_Init>::instance_;
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/detail/impl/openssl_init.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_types.hpp
deleted file mode 100644
index 25f080f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/openssl_types.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// ssl/detail/openssl_types.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
-#define ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp"
-#if defined(ASIO_USE_WOLFSSL)
-# include <wolfssl/options.h>
-#endif // defined(ASIO_USE_WOLFSSL)
-#include <openssl/conf.h>
-#include <openssl/ssl.h>
-#if !defined(OPENSSL_NO_ENGINE)
-# include <openssl/engine.h>
-#endif // !defined(OPENSSL_NO_ENGINE)
-#include <openssl/dh.h>
-#include <openssl/err.h>
-#include <openssl/rsa.h>
-#include <openssl/x509.h>
-#include <openssl/x509v3.h>
-
-#endif // ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/password_callback.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/password_callback.hpp
deleted file mode 100644
index 03ac7db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/password_callback.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// ssl/detail/password_callback.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
-#define ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstddef>
-#include <string>
-#include "asio/ssl/context_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class password_callback_base
-{
-public:
-  virtual ~password_callback_base()
-  {
-  }
-
-  virtual std::string call(std::size_t size,
-      context_base::password_purpose purpose) = 0;
-};
-
-template <typename PasswordCallback>
-class password_callback : public password_callback_base
-{
-public:
-  explicit password_callback(PasswordCallback callback)
-    : callback_(callback)
-  {
-  }
-
-  virtual std::string call(std::size_t size,
-      context_base::password_purpose purpose)
-  {
-    return callback_(size, purpose);
-  }
-
-private:
-  PasswordCallback callback_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/read_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/read_op.hpp
deleted file mode 100644
index 5cb4249..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/read_op.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// ssl/detail/read_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_READ_OP_HPP
-#define ASIO_SSL_DETAIL_READ_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/ssl/detail/engine.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class read_op
-{
-public:
-  static constexpr const char* tracking_name()
-  {
-    return "ssl::stream<>::async_read_some";
-  }
-
-  read_op(const MutableBufferSequence& buffers)
-    : buffers_(buffers)
-  {
-  }
-
-  engine::want operator()(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred) const
-  {
-    asio::mutable_buffer buffer =
-      asio::detail::buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence>::first(buffers_);
-
-    return eng.read(buffer, ec, bytes_transferred);
-  }
-
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t& bytes_transferred) const
-  {
-    static_cast<Handler&&>(handler)(ec, bytes_transferred);
-  }
-
-private:
-  MutableBufferSequence buffers_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_READ_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/shutdown_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/shutdown_op.hpp
deleted file mode 100644
index 1f6b91e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/shutdown_op.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// ssl/detail/shutdown_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
-#define ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/ssl/detail/engine.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class shutdown_op
-{
-public:
-  static constexpr const char* tracking_name()
-  {
-    return "ssl::stream<>::async_shutdown";
-  }
-
-  engine::want operator()(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred) const
-  {
-    bytes_transferred = 0;
-    return eng.shutdown(ec);
-  }
-
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t&) const
-  {
-    if (ec == asio::error::eof)
-    {
-      // The engine only generates an eof when the shutdown notification has
-      // been received from the peer. This indicates that the shutdown has
-      // completed successfully, and thus need not be passed on to the handler.
-      static_cast<Handler&&>(handler)(asio::error_code());
-    }
-    else
-    {
-      static_cast<Handler&&>(handler)(ec);
-    }
-  }
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/stream_core.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/stream_core.hpp
deleted file mode 100644
index 0ec763d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/stream_core.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//
-// ssl/detail/stream_core.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_STREAM_CORE_HPP
-#define ASIO_SSL_DETAIL_STREAM_CORE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/deadline_timer.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/steady_timer.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-#include "asio/ssl/detail/engine.hpp"
-#include "asio/buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-struct stream_core
-{
-  // According to the OpenSSL documentation, this is the buffer size that is
-  // sufficient to hold the largest possible TLS record.
-  enum { max_tls_record_size = 17 * 1024 };
-
-  template <typename Executor>
-  stream_core(SSL_CTX* context, const Executor& ex)
-    : engine_(context),
-      pending_read_(ex),
-      pending_write_(ex),
-      output_buffer_space_(max_tls_record_size),
-      output_buffer_(asio::buffer(output_buffer_space_)),
-      input_buffer_space_(max_tls_record_size),
-      input_buffer_(asio::buffer(input_buffer_space_))
-  {
-    pending_read_.expires_at(neg_infin());
-    pending_write_.expires_at(neg_infin());
-  }
-
-  template <typename Executor>
-  stream_core(SSL* ssl_impl, const Executor& ex)
-    : engine_(ssl_impl),
-      pending_read_(ex),
-      pending_write_(ex),
-      output_buffer_space_(max_tls_record_size),
-      output_buffer_(asio::buffer(output_buffer_space_)),
-      input_buffer_space_(max_tls_record_size),
-      input_buffer_(asio::buffer(input_buffer_space_))
-  {
-    pending_read_.expires_at(neg_infin());
-    pending_write_.expires_at(neg_infin());
-  }
-
-  stream_core(stream_core&& other)
-    : engine_(static_cast<engine&&>(other.engine_)),
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-      pending_read_(
-         static_cast<asio::deadline_timer&&>(
-           other.pending_read_)),
-      pending_write_(
-         static_cast<asio::deadline_timer&&>(
-           other.pending_write_)),
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      pending_read_(
-         static_cast<asio::steady_timer&&>(
-           other.pending_read_)),
-      pending_write_(
-         static_cast<asio::steady_timer&&>(
-           other.pending_write_)),
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-      output_buffer_space_(
-          static_cast<std::vector<unsigned char>&&>(
-            other.output_buffer_space_)),
-      output_buffer_(other.output_buffer_),
-      input_buffer_space_(
-          static_cast<std::vector<unsigned char>&&>(
-            other.input_buffer_space_)),
-      input_buffer_(other.input_buffer_),
-      input_(other.input_)
-  {
-    other.output_buffer_ = asio::mutable_buffer(0, 0);
-    other.input_buffer_ = asio::mutable_buffer(0, 0);
-    other.input_ = asio::const_buffer(0, 0);
-  }
-
-  ~stream_core()
-  {
-  }
-
-  stream_core& operator=(stream_core&& other)
-  {
-    if (this != &other)
-    {
-      engine_ = static_cast<engine&&>(other.engine_);
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-      pending_read_ =
-        static_cast<asio::deadline_timer&&>(
-          other.pending_read_);
-      pending_write_ =
-        static_cast<asio::deadline_timer&&>(
-          other.pending_write_);
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-      pending_read_ =
-        static_cast<asio::steady_timer&&>(
-          other.pending_read_);
-      pending_write_ =
-        static_cast<asio::steady_timer&&>(
-          other.pending_write_);
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-      output_buffer_space_ =
-        static_cast<std::vector<unsigned char>&&>(
-          other.output_buffer_space_);
-      output_buffer_ = other.output_buffer_;
-      input_buffer_space_ =
-        static_cast<std::vector<unsigned char>&&>(
-          other.input_buffer_space_);
-      input_buffer_ = other.input_buffer_;
-      input_ = other.input_;
-      other.output_buffer_ = asio::mutable_buffer(0, 0);
-      other.input_buffer_ = asio::mutable_buffer(0, 0);
-      other.input_ = asio::const_buffer(0, 0);
-    }
-    return *this;
-  }
-
-  // The SSL engine.
-  engine engine_;
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  // Timer used for storing queued read operations.
-  asio::deadline_timer pending_read_;
-
-  // Timer used for storing queued write operations.
-  asio::deadline_timer pending_write_;
-
-  // Helper function for obtaining a time value that always fires.
-  static asio::deadline_timer::time_type neg_infin()
-  {
-    return boost::posix_time::neg_infin;
-  }
-
-  // Helper function for obtaining a time value that never fires.
-  static asio::deadline_timer::time_type pos_infin()
-  {
-    return boost::posix_time::pos_infin;
-  }
-
-  // Helper function to get a timer's expiry time.
-  static asio::deadline_timer::time_type expiry(
-      const asio::deadline_timer& timer)
-  {
-    return timer.expires_at();
-  }
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-  // Timer used for storing queued read operations.
-  asio::steady_timer pending_read_;
-
-  // Timer used for storing queued write operations.
-  asio::steady_timer pending_write_;
-
-  // Helper function for obtaining a time value that always fires.
-  static asio::steady_timer::time_point neg_infin()
-  {
-    return (asio::steady_timer::time_point::min)();
-  }
-
-  // Helper function for obtaining a time value that never fires.
-  static asio::steady_timer::time_point pos_infin()
-  {
-    return (asio::steady_timer::time_point::max)();
-  }
-
-  // Helper function to get a timer's expiry time.
-  static asio::steady_timer::time_point expiry(
-      const asio::steady_timer& timer)
-  {
-    return timer.expiry();
-  }
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-  // Buffer space used to prepare output intended for the transport.
-  std::vector<unsigned char> output_buffer_space_;
-
-  // A buffer that may be used to prepare output intended for the transport.
-  asio::mutable_buffer output_buffer_;
-
-  // Buffer space used to read input intended for the engine.
-  std::vector<unsigned char> input_buffer_space_;
-
-  // A buffer that may be used to read input intended for the engine.
-  asio::mutable_buffer input_buffer_;
-
-  // The buffer pointing to the engine's unconsumed input.
-  asio::const_buffer input_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_STREAM_CORE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/verify_callback.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/verify_callback.hpp
deleted file mode 100644
index 54169c9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/verify_callback.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// ssl/detail/verify_callback.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
-#define ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/ssl/verify_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-class verify_callback_base
-{
-public:
-  virtual ~verify_callback_base()
-  {
-  }
-
-  virtual bool call(bool preverified, verify_context& ctx) = 0;
-};
-
-template <typename VerifyCallback>
-class verify_callback : public verify_callback_base
-{
-public:
-  explicit verify_callback(VerifyCallback callback)
-    : callback_(callback)
-  {
-  }
-
-  virtual bool call(bool preverified, verify_context& ctx)
-  {
-    return callback_(preverified, ctx);
-  }
-
-private:
-  VerifyCallback callback_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/write_op.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/write_op.hpp
deleted file mode 100644
index edcbcad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/detail/write_op.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// ssl/detail/write_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_DETAIL_WRITE_OP_HPP
-#define ASIO_SSL_DETAIL_WRITE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/ssl/detail/engine.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class write_op
-{
-public:
-  static constexpr const char* tracking_name()
-  {
-    return "ssl::stream<>::async_write_some";
-  }
-
-  write_op(const ConstBufferSequence& buffers)
-    : buffers_(buffers)
-  {
-  }
-
-  engine::want operator()(engine& eng,
-      asio::error_code& ec,
-      std::size_t& bytes_transferred) const
-  {
-    unsigned char storage[
-      asio::detail::buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence>::linearisation_storage_size];
-
-    asio::const_buffer buffer =
-      asio::detail::buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence>::linearise(buffers_, asio::buffer(storage));
-
-    return eng.write(buffer, ec, bytes_transferred);
-  }
-
-  template <typename Handler>
-  void call_handler(Handler& handler,
-      const asio::error_code& ec,
-      const std::size_t& bytes_transferred) const
-  {
-    static_cast<Handler&&>(handler)(ec, bytes_transferred);
-  }
-
-private:
-  ConstBufferSequence buffers_;
-};
-
-} // namespace detail
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_DETAIL_WRITE_OP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/error.hpp
deleted file mode 100644
index e126f52..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/error.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//
-// ssl/error.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_ERROR_HPP
-#define ASIO_SSL_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/error_code.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace error {
-
-enum ssl_errors
-{
-  // Error numbers are those produced by openssl.
-};
-
-extern ASIO_DECL
-const asio::error_category& get_ssl_category();
-
-static const asio::error_category&
-  ssl_category ASIO_UNUSED_VARIABLE
-  = asio::error::get_ssl_category();
-
-} // namespace error
-namespace ssl {
-namespace error {
-
-enum stream_errors
-{
-#if defined(GENERATING_DOCUMENTATION)
-  /// The underlying stream closed before the ssl stream gracefully shut down.
-  stream_truncated,
-
-  /// The underlying SSL library returned a system error without providing
-  /// further information.
-  unspecified_system_error,
-
-  /// The underlying SSL library generated an unexpected result from a function
-  /// call.
-  unexpected_result
-#else // defined(GENERATING_DOCUMENTATION)
-# if (OPENSSL_VERSION_NUMBER < 0x10100000L) \
-    && !defined(OPENSSL_IS_BORINGSSL) \
-    && !defined(ASIO_USE_WOLFSSL)
-  stream_truncated = ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ),
-# else
-  stream_truncated = 1,
-# endif
-  unspecified_system_error = 2,
-  unexpected_result = 3
-#endif // defined(GENERATING_DOCUMENTATION)
-};
-
-extern ASIO_DECL
-const asio::error_category& get_stream_category();
-
-static const asio::error_category&
-  stream_category ASIO_UNUSED_VARIABLE
-  = asio::ssl::error::get_stream_category();
-
-} // namespace error
-} // namespace ssl
-} // namespace asio
-
-namespace std {
-
-template<> struct is_error_code_enum<asio::error::ssl_errors>
-{
-  static const bool value = true;
-};
-
-template<> struct is_error_code_enum<asio::ssl::error::stream_errors>
-{
-  static const bool value = true;
-};
-
-} // namespace std
-
-namespace asio {
-namespace error {
-
-inline asio::error_code make_error_code(ssl_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_ssl_category());
-}
-
-} // namespace error
-namespace ssl {
-namespace error {
-
-inline asio::error_code make_error_code(stream_errors e)
-{
-  return asio::error_code(
-      static_cast<int>(e), get_stream_category());
-}
-
-} // namespace error
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/impl/error.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SSL_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/host_name_verification.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/host_name_verification.hpp
deleted file mode 100644
index adb6ac8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/host_name_verification.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// ssl/host_name_verification.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_HOST_NAME_VERIFICATION_HPP
-#define ASIO_SSL_HOST_NAME_VERIFICATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <string>
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/ssl/verify_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// Verifies a certificate against a host_name according to the rules described
-/// in RFC 6125.
-/**
- * @par Example
- * The following example shows how to synchronously open a secure connection to
- * a given host name:
- * @code
- * using asio::ip::tcp;
- * namespace ssl = asio::ssl;
- * typedef ssl::stream<tcp::socket> ssl_socket;
- *
- * // Create a context that uses the default paths for finding CA certificates.
- * ssl::context ctx(ssl::context::sslv23);
- * ctx.set_default_verify_paths();
- *
- * // Open a socket and connect it to the remote host.
- * asio::io_context io_context;
- * ssl_socket sock(io_context, ctx);
- * tcp::resolver resolver(io_context);
- * tcp::resolver::query query("host.name", "https");
- * asio::connect(sock.lowest_layer(), resolver.resolve(query));
- * sock.lowest_layer().set_option(tcp::no_delay(true));
- *
- * // Perform SSL handshake and verify the remote host's certificate.
- * sock.set_verify_mode(ssl::verify_peer);
- * sock.set_verify_callback(ssl::host_name_verification("host.name"));
- * sock.handshake(ssl_socket::client);
- *
- * // ... read and write as normal ...
- * @endcode
- */
-class host_name_verification
-{
-public:
-  /// The type of the function object's result.
-  typedef bool result_type;
-
-  /// Constructor.
-  explicit host_name_verification(const std::string& host)
-    : host_(host)
-  {
-  }
-
-  /// Perform certificate verification.
-  ASIO_DECL bool operator()(bool preverified, verify_context& ctx) const;
-
-private:
-  // Helper function to check a host name against an IPv4 address
-  // The host name to be checked.
-  std::string host_;
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/impl/host_name_verification.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SSL_HOST_NAME_VERIFICATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.hpp
deleted file mode 100644
index 2324a98..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ssl/impl/context.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_CONTEXT_HPP
-#define ASIO_SSL_IMPL_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-template <typename VerifyCallback>
-void context::set_verify_callback(VerifyCallback callback)
-{
-  asio::error_code ec;
-  this->set_verify_callback(callback, ec);
-  asio::detail::throw_error(ec, "set_verify_callback");
-}
-
-template <typename VerifyCallback>
-ASIO_SYNC_OP_VOID context::set_verify_callback(
-    VerifyCallback callback, asio::error_code& ec)
-{
-  do_set_verify_callback(
-      new detail::verify_callback<VerifyCallback>(callback), ec);
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-template <typename PasswordCallback>
-void context::set_password_callback(PasswordCallback callback)
-{
-  asio::error_code ec;
-  this->set_password_callback(callback, ec);
-  asio::detail::throw_error(ec, "set_password_callback");
-}
-
-template <typename PasswordCallback>
-ASIO_SYNC_OP_VOID context::set_password_callback(
-    PasswordCallback callback, asio::error_code& ec)
-{
-  do_set_password_callback(
-      new detail::password_callback<PasswordCallback>(callback), ec);
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_IMPL_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.ipp
deleted file mode 100644
index fcc1ba5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/context.ipp
+++ /dev/null
@@ -1,1319 +0,0 @@
-//
-// ssl/impl/context.ipp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
-// Copyright (c) 2005-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_CONTEXT_IPP
-#define ASIO_SSL_IMPL_CONTEXT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cstring>
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/ssl/context.hpp"
-#include "asio/ssl/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-struct context::bio_cleanup
-{
-  BIO* p;
-  ~bio_cleanup() { if (p) ::BIO_free(p); }
-};
-
-struct context::x509_cleanup
-{
-  X509* p;
-  ~x509_cleanup() { if (p) ::X509_free(p); }
-};
-
-struct context::evp_pkey_cleanup
-{
-  EVP_PKEY* p;
-  ~evp_pkey_cleanup() { if (p) ::EVP_PKEY_free(p); }
-};
-
-#if (OPENSSL_VERSION_NUMBER < 0x30000000L)
-struct context::rsa_cleanup
-{
-  RSA* p;
-  ~rsa_cleanup() { if (p) ::RSA_free(p); }
-};
-
-struct context::dh_cleanup
-{
-  DH* p;
-  ~dh_cleanup() { if (p) ::DH_free(p); }
-};
-#endif // (OPENSSL_VERSION_NUMBER < 0x30000000L)
-
-context::context(context::method m)
-  : handle_(0)
-{
-  ::ERR_clear_error();
-
-  switch (m)
-  {
-    // SSL v2.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
-  case context::sslv2:
-  case context::sslv2_client:
-  case context::sslv2_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
-  case context::sslv2:
-    handle_ = ::SSL_CTX_new(::SSLv2_method());
-    break;
-  case context::sslv2_client:
-    handle_ = ::SSL_CTX_new(::SSLv2_client_method());
-    break;
-  case context::sslv2_server:
-    handle_ = ::SSL_CTX_new(::SSLv2_server_method());
-    break;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L) || defined(OPENSSL_NO_SSL2)
-
-    // SSL v3.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::sslv3:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
-    }
-    break;
-  case context::sslv3_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
-    }
-    break;
-  case context::sslv3_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, SSL3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, SSL3_VERSION);
-    }
-    break;
-#elif defined(OPENSSL_NO_SSL3)
-  case context::sslv3:
-  case context::sslv3_client:
-  case context::sslv3_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#else // defined(OPENSSL_NO_SSL3)
-  case context::sslv3:
-    handle_ = ::SSL_CTX_new(::SSLv3_method());
-    break;
-  case context::sslv3_client:
-    handle_ = ::SSL_CTX_new(::SSLv3_client_method());
-    break;
-  case context::sslv3_server:
-    handle_ = ::SSL_CTX_new(::SSLv3_server_method());
-    break;
-#endif // defined(OPENSSL_NO_SSL3)
-
-    // TLS v1.0.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tlsv1:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
-    }
-    break;
-  case context::tlsv1_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
-    }
-    break;
-  case context::tlsv1_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
-    }
-    break;
-#elif defined(SSL_TXT_TLSV1)
-  case context::tlsv1:
-    handle_ = ::SSL_CTX_new(::TLSv1_method());
-    break;
-  case context::tlsv1_client:
-    handle_ = ::SSL_CTX_new(::TLSv1_client_method());
-    break;
-  case context::tlsv1_server:
-    handle_ = ::SSL_CTX_new(::TLSv1_server_method());
-    break;
-#else // defined(SSL_TXT_TLSV1)
-  case context::tlsv1:
-  case context::tlsv1_client:
-  case context::tlsv1_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#endif // defined(SSL_TXT_TLSV1)
-
-    // TLS v1.1.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tlsv11:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
-    }
-    break;
-  case context::tlsv11_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
-    }
-    break;
-  case context::tlsv11_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_1_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_1_VERSION);
-    }
-    break;
-#elif defined(SSL_TXT_TLSV1_1)
-  case context::tlsv11:
-    handle_ = ::SSL_CTX_new(::TLSv1_1_method());
-    break;
-  case context::tlsv11_client:
-    handle_ = ::SSL_CTX_new(::TLSv1_1_client_method());
-    break;
-  case context::tlsv11_server:
-    handle_ = ::SSL_CTX_new(::TLSv1_1_server_method());
-    break;
-#else // defined(SSL_TXT_TLSV1_1)
-  case context::tlsv11:
-  case context::tlsv11_client:
-  case context::tlsv11_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#endif // defined(SSL_TXT_TLSV1_1)
-
-    // TLS v1.2.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tlsv12:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
-    }
-    break;
-  case context::tlsv12_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
-    }
-    break;
-  case context::tlsv12_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_2_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
-    }
-    break;
-#elif defined(SSL_TXT_TLSV1_2)
-  case context::tlsv12:
-    handle_ = ::SSL_CTX_new(::TLSv1_2_method());
-    break;
-  case context::tlsv12_client:
-    handle_ = ::SSL_CTX_new(::TLSv1_2_client_method());
-    break;
-  case context::tlsv12_server:
-    handle_ = ::SSL_CTX_new(::TLSv1_2_server_method());
-    break;
-#else // defined(SSL_TXT_TLSV1_2)
-  case context::tlsv12:
-  case context::tlsv12_client:
-  case context::tlsv12_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#endif // defined(SSL_TXT_TLSV1_2)
-
-    // TLS v1.3.
-#if (OPENSSL_VERSION_NUMBER >= 0x10101000L) \
-    && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tlsv13:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
-    }
-    break;
-  case context::tlsv13_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
-    }
-    break;
-  case context::tlsv13_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-    {
-      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
-      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
-    }
-    break;
-#else // (OPENSSL_VERSION_NUMBER >= 0x10101000L)
-      //   && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tlsv13:
-  case context::tlsv13_client:
-  case context::tlsv13_server:
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-    break;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10101000L)
-       //   && !defined(LIBRESSL_VERSION_NUMBER)
-
-    // Any supported SSL/TLS version.
-  case context::sslv23:
-    handle_ = ::SSL_CTX_new(::SSLv23_method());
-    break;
-  case context::sslv23_client:
-    handle_ = ::SSL_CTX_new(::SSLv23_client_method());
-    break;
-  case context::sslv23_server:
-    handle_ = ::SSL_CTX_new(::SSLv23_server_method());
-    break;
-
-    // Any supported TLS version.
-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
-  case context::tls:
-    handle_ = ::SSL_CTX_new(::TLS_method());
-    if (handle_)
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-    break;
-  case context::tls_client:
-    handle_ = ::SSL_CTX_new(::TLS_client_method());
-    if (handle_)
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-    break;
-  case context::tls_server:
-    handle_ = ::SSL_CTX_new(::TLS_server_method());
-    if (handle_)
-      SSL_CTX_set_min_proto_version(handle_, TLS1_VERSION);
-    break;
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-  case context::tls:
-    handle_ = ::SSL_CTX_new(::SSLv23_method());
-    if (handle_)
-      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
-    break;
-  case context::tls_client:
-    handle_ = ::SSL_CTX_new(::SSLv23_client_method());
-    if (handle_)
-      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
-    break;
-  case context::tls_server:
-    handle_ = ::SSL_CTX_new(::SSLv23_server_method());
-    if (handle_)
-      SSL_CTX_set_options(handle_, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
-    break;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-
-  default:
-    handle_ = ::SSL_CTX_new(0);
-    break;
-  }
-
-  if (handle_ == 0)
-  {
-    asio::error_code ec = translate_error(::ERR_get_error());
-    asio::detail::throw_error(ec, "context");
-  }
-
-  set_options(no_compression);
-}
-
-context::context(context::native_handle_type native_handle)
-  : handle_(native_handle)
-{
-  if (!handle_)
-  {
-    asio::detail::throw_error(
-        asio::error::invalid_argument, "context");
-  }
-}
-
-context::context(context&& other)
-{
-  handle_ = other.handle_;
-  other.handle_ = 0;
-}
-
-context& context::operator=(context&& other)
-{
-  context tmp(static_cast<context&&>(*this));
-  handle_ = other.handle_;
-  other.handle_ = 0;
-  return *this;
-}
-
-context::~context()
-{
-  if (handle_)
-  {
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    void* cb_userdata = handle_->default_passwd_callback_userdata;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    if (cb_userdata)
-    {
-      detail::password_callback_base* callback =
-        static_cast<detail::password_callback_base*>(
-            cb_userdata);
-      delete callback;
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-      ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-      handle_->default_passwd_callback_userdata = 0;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    }
-
-    if (SSL_CTX_get_app_data(handle_))
-    {
-      detail::verify_callback_base* callback =
-        static_cast<detail::verify_callback_base*>(
-            SSL_CTX_get_app_data(handle_));
-      delete callback;
-      SSL_CTX_set_app_data(handle_, 0);
-    }
-
-    ::SSL_CTX_free(handle_);
-  }
-}
-
-context::native_handle_type context::native_handle()
-{
-  return handle_;
-}
-
-void context::clear_options(context::options o)
-{
-  asio::error_code ec;
-  clear_options(o, ec);
-  asio::detail::throw_error(ec, "clear_options");
-}
-
-ASIO_SYNC_OP_VOID context::clear_options(
-    context::options o, asio::error_code& ec)
-{
-#if (OPENSSL_VERSION_NUMBER >= 0x009080DFL) \
-  && (OPENSSL_VERSION_NUMBER != 0x00909000L)
-# if !defined(SSL_OP_NO_COMPRESSION)
-  if ((o & context::no_compression) != 0)
-  {
-# if (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    handle_->comp_methods = SSL_COMP_get_compression_methods();
-# endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    o ^= context::no_compression;
-  }
-# endif // !defined(SSL_OP_NO_COMPRESSION)
-
-  ::SSL_CTX_clear_options(handle_, o);
-
-  ec = asio::error_code();
-#else // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)
-      //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)
-  (void)o;
-  ec = asio::error::operation_not_supported;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x009080DFL)
-       //   && (OPENSSL_VERSION_NUMBER != 0x00909000L)
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::set_options(context::options o)
-{
-  asio::error_code ec;
-  set_options(o, ec);
-  asio::detail::throw_error(ec, "set_options");
-}
-
-ASIO_SYNC_OP_VOID context::set_options(
-    context::options o, asio::error_code& ec)
-{
-#if !defined(SSL_OP_NO_COMPRESSION)
-  if ((o & context::no_compression) != 0)
-  {
-#if (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    handle_->comp_methods =
-      asio::ssl::detail::openssl_init<>::get_null_compression_methods();
-#endif // (OPENSSL_VERSION_NUMBER >= 0x00908000L)
-    o ^= context::no_compression;
-  }
-#endif // !defined(SSL_OP_NO_COMPRESSION)
-
-  ::SSL_CTX_set_options(handle_, o);
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::set_verify_mode(verify_mode v)
-{
-  asio::error_code ec;
-  set_verify_mode(v, ec);
-  asio::detail::throw_error(ec, "set_verify_mode");
-}
-
-ASIO_SYNC_OP_VOID context::set_verify_mode(
-    verify_mode v, asio::error_code& ec)
-{
-  ::SSL_CTX_set_verify(handle_, v, ::SSL_CTX_get_verify_callback(handle_));
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::set_verify_depth(int depth)
-{
-  asio::error_code ec;
-  set_verify_depth(depth, ec);
-  asio::detail::throw_error(ec, "set_verify_depth");
-}
-
-ASIO_SYNC_OP_VOID context::set_verify_depth(
-    int depth, asio::error_code& ec)
-{
-  ::SSL_CTX_set_verify_depth(handle_, depth);
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::load_verify_file(const std::string& filename)
-{
-  asio::error_code ec;
-  load_verify_file(filename, ec);
-  asio::detail::throw_error(ec, "load_verify_file");
-}
-
-ASIO_SYNC_OP_VOID context::load_verify_file(
-    const std::string& filename, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_load_verify_locations(handle_, filename.c_str(), 0) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::add_certificate_authority(const const_buffer& ca)
-{
-  asio::error_code ec;
-  add_certificate_authority(ca, ec);
-  asio::detail::throw_error(ec, "add_certificate_authority");
-}
-
-ASIO_SYNC_OP_VOID context::add_certificate_authority(
-    const const_buffer& ca, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  bio_cleanup bio = { make_buffer_bio(ca) };
-  if (bio.p)
-  {
-    if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))
-    {
-      for (bool added = false;; added = true)
-      {
-        x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
-        if (!cert.p)
-        {
-          unsigned long err = ::ERR_get_error();
-          if (added && ERR_GET_LIB(err) == ERR_LIB_PEM
-              && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
-            break;
-
-          ec = translate_error(err);
-          ASIO_SYNC_OP_VOID_RETURN(ec);
-        }
-
-        if (::X509_STORE_add_cert(store, cert.p) != 1)
-        {
-          ec = translate_error(::ERR_get_error());
-          ASIO_SYNC_OP_VOID_RETURN(ec);
-        }
-      }
-    }
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::set_default_verify_paths()
-{
-  asio::error_code ec;
-  set_default_verify_paths(ec);
-  asio::detail::throw_error(ec, "set_default_verify_paths");
-}
-
-ASIO_SYNC_OP_VOID context::set_default_verify_paths(
-    asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_set_default_verify_paths(handle_) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::add_verify_path(const std::string& path)
-{
-  asio::error_code ec;
-  add_verify_path(path, ec);
-  asio::detail::throw_error(ec, "add_verify_path");
-}
-
-ASIO_SYNC_OP_VOID context::add_verify_path(
-    const std::string& path, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_load_verify_locations(handle_, 0, path.c_str()) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_certificate(
-    const const_buffer& certificate, file_format format)
-{
-  asio::error_code ec;
-  use_certificate(certificate, format, ec);
-  asio::detail::throw_error(ec, "use_certificate");
-}
-
-ASIO_SYNC_OP_VOID context::use_certificate(
-    const const_buffer& certificate, file_format format,
-    asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  if (format == context_base::asn1)
-  {
-    if (::SSL_CTX_use_certificate_ASN1(handle_,
-          static_cast<int>(certificate.size()),
-          static_cast<const unsigned char*>(certificate.data())) == 1)
-    {
-      ec = asio::error_code();
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-  else if (format == context_base::pem)
-  {
-    bio_cleanup bio = { make_buffer_bio(certificate) };
-    if (bio.p)
-    {
-      x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
-      if (cert.p)
-      {
-        if (::SSL_CTX_use_certificate(handle_, cert.p) == 1)
-        {
-          ec = asio::error_code();
-          ASIO_SYNC_OP_VOID_RETURN(ec);
-        }
-      }
-    }
-  }
-  else
-  {
-    ec = asio::error::invalid_argument;
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_certificate_file(
-    const std::string& filename, file_format format)
-{
-  asio::error_code ec;
-  use_certificate_file(filename, format, ec);
-  asio::detail::throw_error(ec, "use_certificate_file");
-}
-
-ASIO_SYNC_OP_VOID context::use_certificate_file(
-    const std::string& filename, file_format format,
-    asio::error_code& ec)
-{
-  int file_type;
-  switch (format)
-  {
-  case context_base::asn1:
-    file_type = SSL_FILETYPE_ASN1;
-    break;
-  case context_base::pem:
-    file_type = SSL_FILETYPE_PEM;
-    break;
-  default:
-    {
-      ec = asio::error::invalid_argument;
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_use_certificate_file(handle_, filename.c_str(), file_type) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_certificate_chain(const const_buffer& chain)
-{
-  asio::error_code ec;
-  use_certificate_chain(chain, ec);
-  asio::detail::throw_error(ec, "use_certificate_chain");
-}
-
-ASIO_SYNC_OP_VOID context::use_certificate_chain(
-    const const_buffer& chain, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  bio_cleanup bio = { make_buffer_bio(chain) };
-  if (bio.p)
-  {
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
-    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    pem_password_cb* callback = handle_->default_passwd_callback;
-    void* cb_userdata = handle_->default_passwd_callback_userdata;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    x509_cleanup cert = {
-      ::PEM_read_bio_X509_AUX(bio.p, 0,
-          callback,
-          cb_userdata) };
-    if (!cert.p)
-    {
-      ec = translate_error(ERR_R_PEM_LIB);
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-
-    int result = ::SSL_CTX_use_certificate(handle_, cert.p);
-    if (result == 0 || ::ERR_peek_error() != 0)
-    {
-      ec = translate_error(::ERR_get_error());
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-
-#if ((OPENSSL_VERSION_NUMBER >= 0x10002000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2090100fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-    ::SSL_CTX_clear_chain_certs(handle_);
-#else
-    if (handle_->extra_certs)
-    {
-      ::sk_X509_pop_free(handle_->extra_certs, X509_free);
-      handle_->extra_certs = 0;
-    }
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)
-
-    while (X509* cacert = ::PEM_read_bio_X509(bio.p, 0,
-          callback,
-          cb_userdata))
-    {
-      if (!::SSL_CTX_add_extra_chain_cert(handle_, cacert))
-      {
-        ec = translate_error(::ERR_get_error());
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-
-    result = ::ERR_peek_last_error();
-    if ((ERR_GET_LIB(result) == ERR_LIB_PEM)
-        && (ERR_GET_REASON(result) == PEM_R_NO_START_LINE))
-    {
-      ::ERR_clear_error();
-      ec = asio::error_code();
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_certificate_chain_file(const std::string& filename)
-{
-  asio::error_code ec;
-  use_certificate_chain_file(filename, ec);
-  asio::detail::throw_error(ec, "use_certificate_chain_file");
-}
-
-ASIO_SYNC_OP_VOID context::use_certificate_chain_file(
-    const std::string& filename, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_use_certificate_chain_file(handle_, filename.c_str()) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_private_key(
-    const const_buffer& private_key, context::file_format format)
-{
-  asio::error_code ec;
-  use_private_key(private_key, format, ec);
-  asio::detail::throw_error(ec, "use_private_key");
-}
-
-ASIO_SYNC_OP_VOID context::use_private_key(
-    const const_buffer& private_key, context::file_format format,
-    asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-    pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
-    void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    pem_password_cb* callback = handle_->default_passwd_callback;
-    void* cb_userdata = handle_->default_passwd_callback_userdata;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-
-  bio_cleanup bio = { make_buffer_bio(private_key) };
-  if (bio.p)
-  {
-    evp_pkey_cleanup evp_private_key = { 0 };
-    switch (format)
-    {
-    case context_base::asn1:
-      evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
-      break;
-    case context_base::pem:
-      evp_private_key.p = ::PEM_read_bio_PrivateKey(
-          bio.p, 0, callback,
-          cb_userdata);
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-
-    if (evp_private_key.p)
-    {
-      if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
-      {
-        ec = asio::error_code();
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_private_key_file(
-    const std::string& filename, context::file_format format)
-{
-  asio::error_code ec;
-  use_private_key_file(filename, format, ec);
-  asio::detail::throw_error(ec, "use_private_key_file");
-}
-
-void context::use_rsa_private_key(
-    const const_buffer& private_key, context::file_format format)
-{
-  asio::error_code ec;
-  use_rsa_private_key(private_key, format, ec);
-  asio::detail::throw_error(ec, "use_rsa_private_key");
-}
-
-ASIO_SYNC_OP_VOID context::use_rsa_private_key(
-    const const_buffer& private_key, context::file_format format,
-    asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-  pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
-  void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-  pem_password_cb* callback = handle_->default_passwd_callback;
-  void* cb_userdata = handle_->default_passwd_callback_userdata;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-
-  bio_cleanup bio = { make_buffer_bio(private_key) };
-  if (bio.p)
-  {
-#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-    evp_pkey_cleanup evp_private_key = { 0 };
-    switch (format)
-    {
-    case context_base::asn1:
-      evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
-      break;
-    case context_base::pem:
-      evp_private_key.p = ::PEM_read_bio_PrivateKey(
-          bio.p, 0, callback,
-          cb_userdata);
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-
-    if (evp_private_key.p)
-    {
-      if (::EVP_PKEY_is_a(evp_private_key.p, "RSA") == 0)
-      {
-        ec = translate_error(
-            ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_RSA_KEY));
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-
-      if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
-      {
-        ec = asio::error_code();
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-    rsa_cleanup rsa_private_key = { 0 };
-    switch (format)
-    {
-    case context_base::asn1:
-      rsa_private_key.p = ::d2i_RSAPrivateKey_bio(bio.p, 0);
-      break;
-    case context_base::pem:
-      rsa_private_key.p = ::PEM_read_bio_RSAPrivateKey(
-          bio.p, 0, callback,
-          cb_userdata);
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-
-    if (rsa_private_key.p)
-    {
-      if (::SSL_CTX_use_RSAPrivateKey(handle_, rsa_private_key.p) == 1)
-      {
-        ec = asio::error_code();
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID context::use_private_key_file(
-    const std::string& filename, context::file_format format,
-    asio::error_code& ec)
-{
-  int file_type;
-  switch (format)
-  {
-  case context_base::asn1:
-    file_type = SSL_FILETYPE_ASN1;
-    break;
-  case context_base::pem:
-    file_type = SSL_FILETYPE_PEM;
-    break;
-  default:
-    {
-      ec = asio::error::invalid_argument;
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_use_PrivateKey_file(handle_, filename.c_str(), file_type) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_rsa_private_key_file(
-    const std::string& filename, context::file_format format)
-{
-  asio::error_code ec;
-  use_rsa_private_key_file(filename, format, ec);
-  asio::detail::throw_error(ec, "use_rsa_private_key_file");
-}
-
-ASIO_SYNC_OP_VOID context::use_rsa_private_key_file(
-    const std::string& filename, context::file_format format,
-    asio::error_code& ec)
-{
-#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  ::ERR_clear_error();
-
-  pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
-  void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-
-  bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };
-  if (bio.p)
-  {
-    evp_pkey_cleanup evp_private_key = { 0 };
-    switch (format)
-    {
-    case context_base::asn1:
-      evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
-      break;
-    case context_base::pem:
-      evp_private_key.p = ::PEM_read_bio_PrivateKey(
-          bio.p, 0, callback,
-          cb_userdata);
-      break;
-    default:
-      {
-        ec = asio::error::invalid_argument;
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-
-    if (evp_private_key.p)
-    {
-      if (::EVP_PKEY_is_a(evp_private_key.p, "RSA") == 0)
-      {
-        ec = translate_error(
-            ERR_PACK(ERR_LIB_EVP, 0, EVP_R_EXPECTING_AN_RSA_KEY));
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-
-      if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
-      {
-        ec = asio::error_code();
-        ASIO_SYNC_OP_VOID_RETURN(ec);
-      }
-    }
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  int file_type;
-  switch (format)
-  {
-  case context_base::asn1:
-    file_type = SSL_FILETYPE_ASN1;
-    break;
-  case context_base::pem:
-    file_type = SSL_FILETYPE_PEM;
-    break;
-  default:
-    {
-      ec = asio::error::invalid_argument;
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-
-  ::ERR_clear_error();
-
-  if (::SSL_CTX_use_RSAPrivateKey_file(
-        handle_, filename.c_str(), file_type) != 1)
-  {
-    ec = translate_error(::ERR_get_error());
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-}
-
-void context::use_tmp_dh(const const_buffer& dh)
-{
-  asio::error_code ec;
-  use_tmp_dh(dh, ec);
-  asio::detail::throw_error(ec, "use_tmp_dh");
-}
-
-ASIO_SYNC_OP_VOID context::use_tmp_dh(
-    const const_buffer& dh, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  bio_cleanup bio = { make_buffer_bio(dh) };
-  if (bio.p)
-  {
-    return do_use_tmp_dh(bio.p, ec);
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-void context::use_tmp_dh_file(const std::string& filename)
-{
-  asio::error_code ec;
-  use_tmp_dh_file(filename, ec);
-  asio::detail::throw_error(ec, "use_tmp_dh_file");
-}
-
-ASIO_SYNC_OP_VOID context::use_tmp_dh_file(
-    const std::string& filename, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-  bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };
-  if (bio.p)
-  {
-    return do_use_tmp_dh(bio.p, ec);
-  }
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID context::do_use_tmp_dh(
-    BIO* bio, asio::error_code& ec)
-{
-  ::ERR_clear_error();
-
-#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  EVP_PKEY* p = ::PEM_read_bio_Parameters(bio, 0);
-  if (p)
-  {
-    if (::SSL_CTX_set0_tmp_dh_pkey(handle_, p) == 1)
-    {
-      ec = asio::error_code();
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-    else
-      ::EVP_PKEY_free(p);
-  }
-#else // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  dh_cleanup dh = { ::PEM_read_bio_DHparams(bio, 0, 0, 0) };
-  if (dh.p)
-  {
-    if (::SSL_CTX_set_tmp_dh(handle_, dh.p) == 1)
-    {
-      ec = asio::error_code();
-      ASIO_SYNC_OP_VOID_RETURN(ec);
-    }
-  }
-#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-
-  ec = translate_error(::ERR_get_error());
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-ASIO_SYNC_OP_VOID context::do_set_verify_callback(
-    detail::verify_callback_base* callback, asio::error_code& ec)
-{
-  if (SSL_CTX_get_app_data(handle_))
-  {
-    delete static_cast<detail::verify_callback_base*>(
-        SSL_CTX_get_app_data(handle_));
-  }
-
-  SSL_CTX_set_app_data(handle_, callback);
-
-  ::SSL_CTX_set_verify(handle_,
-      ::SSL_CTX_get_verify_mode(handle_),
-      &context::verify_callback_function);
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
-{
-  if (ctx)
-  {
-    if (SSL* ssl = static_cast<SSL*>(
-          ::X509_STORE_CTX_get_ex_data(
-            ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
-    {
-      if (SSL_CTX* handle = ::SSL_get_SSL_CTX(ssl))
-      {
-        if (SSL_CTX_get_app_data(handle))
-        {
-          detail::verify_callback_base* callback =
-            static_cast<detail::verify_callback_base*>(
-                SSL_CTX_get_app_data(handle));
-
-          verify_context verify_ctx(ctx);
-          return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
-        }
-      }
-    }
-  }
-
-  return 0;
-}
-
-ASIO_SYNC_OP_VOID context::do_set_password_callback(
-    detail::password_callback_base* callback, asio::error_code& ec)
-{
-#if ((OPENSSL_VERSION_NUMBER >= 0x10100000L) \
-      && (!defined(LIBRESSL_VERSION_NUMBER) \
-        || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)) \
-    || defined(ASIO_USE_WOLFSSL)
-  void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
-  ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-  void* old_callback = handle_->default_passwd_callback_userdata;
-  handle_->default_passwd_callback_userdata = callback;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-
-  if (old_callback)
-    delete static_cast<detail::password_callback_base*>(
-        old_callback);
-
-  SSL_CTX_set_default_passwd_cb(handle_, &context::password_callback_function);
-
-  ec = asio::error_code();
-  ASIO_SYNC_OP_VOID_RETURN(ec);
-}
-
-int context::password_callback_function(
-    char* buf, int size, int purpose, void* data)
-{
-  using namespace std; // For strncat and strlen.
-
-  if (data)
-  {
-    detail::password_callback_base* callback =
-      static_cast<detail::password_callback_base*>(data);
-
-    std::string passwd = callback->call(static_cast<std::size_t>(size),
-        purpose ? context_base::for_writing : context_base::for_reading);
-
-#if defined(ASIO_HAS_SECURE_RTL)
-    strcpy_s(buf, size, passwd.c_str());
-#else // defined(ASIO_HAS_SECURE_RTL)
-    *buf = '\0';
-    if (size > 0)
-      strncat(buf, passwd.c_str(), size - 1);
-#endif // defined(ASIO_HAS_SECURE_RTL)
-
-    return static_cast<int>(strlen(buf));
-  }
-
-  return 0;
-}
-
-BIO* context::make_buffer_bio(const const_buffer& b)
-{
-  return ::BIO_new_mem_buf(
-      const_cast<void*>(b.data()),
-      static_cast<int>(b.size()));
-}
-
-asio::error_code context::translate_error(long error)
-{
-#if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-  if (ERR_SYSTEM_ERROR(error))
-  {
-    return asio::error_code(
-        static_cast<int>(ERR_GET_REASON(error)),
-        asio::error::get_system_category());
-  }
-#endif // (OPENSSL_VERSION_NUMBER >= 0x30000000L)
-
-  return asio::error_code(static_cast<int>(error),
-      asio::error::get_ssl_category());
-}
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_IMPL_CONTEXT_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/error.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/error.ipp
deleted file mode 100644
index 7ff6e8a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/error.ipp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// ssl/impl/error.ipp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_ERROR_IPP
-#define ASIO_SSL_IMPL_ERROR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ssl/error.hpp"
-#include "asio/ssl/detail/openssl_init.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace error {
-namespace detail {
-
-class ssl_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.ssl";
-  }
-
-  std::string message(int value) const
-  {
-    const char* reason = ::ERR_reason_error_string(value);
-    if (reason)
-    {
-      const char* lib = ::ERR_lib_error_string(value);
-#if (OPENSSL_VERSION_NUMBER < 0x30000000L)
-      const char* func = ::ERR_func_error_string(value);
-#else // (OPENSSL_VERSION_NUMBER < 0x30000000L)
-      const char* func = 0;
-#endif // (OPENSSL_VERSION_NUMBER < 0x30000000L)
-      std::string result(reason);
-      if (lib || func)
-      {
-        result += " (";
-        if (lib)
-          result += lib;
-        if (lib && func)
-          result += ", ";
-        if (func)
-          result += func;
-        result += ")";
-      }
-      return result;
-    }
-    return "asio.ssl error";
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_ssl_category()
-{
-  static detail::ssl_category instance;
-  return instance;
-}
-
-} // namespace error
-namespace ssl {
-namespace error {
-
-#if (OPENSSL_VERSION_NUMBER < 0x10100000L) && !defined(OPENSSL_IS_BORINGSSL)
-
-const asio::error_category& get_stream_category()
-{
-  return asio::error::get_ssl_category();
-}
-
-#else
-
-namespace detail {
-
-class stream_category : public asio::error_category
-{
-public:
-  const char* name() const noexcept
-  {
-    return "asio.ssl.stream";
-  }
-
-  std::string message(int value) const
-  {
-    switch (value)
-    {
-    case stream_truncated: return "stream truncated";
-    case unspecified_system_error: return "unspecified system error";
-    case unexpected_result: return "unexpected result";
-    default: return "asio.ssl.stream error";
-    }
-  }
-};
-
-} // namespace detail
-
-const asio::error_category& get_stream_category()
-{
-  static detail::stream_category instance;
-  return instance;
-}
-
-#endif
-
-} // namespace error
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_IMPL_ERROR_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/host_name_verification.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/host_name_verification.ipp
deleted file mode 100644
index 198d1f3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/host_name_verification.ipp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// ssl/impl/host_name_verification.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_HOST_NAME_VERIFICATION_IPP
-#define ASIO_SSL_IMPL_HOST_NAME_VERIFICATION_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include <cctype>
-#include <cstring>
-#include "asio/ip/address.hpp"
-#include "asio/ssl/host_name_verification.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-bool host_name_verification::operator()(
-    bool preverified, verify_context& ctx) const
-{
-  using namespace std; // For memcmp.
-
-  // Don't bother looking at certificates that have failed pre-verification.
-  if (!preverified)
-    return false;
-
-  // We're only interested in checking the certificate at the end of the chain.
-  int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle());
-  if (depth > 0)
-    return true;
-
-  // Try converting the host name to an address. If it is an address then we
-  // need to look for an IP address in the certificate rather than a host name.
-  asio::error_code ec;
-  ip::address address = ip::make_address(host_, ec);
-  const bool is_address = !ec;
-  (void)address;
-
-  X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
-
-  if (is_address)
-  {
-    return X509_check_ip_asc(cert, host_.c_str(), 0) == 1;
-  }
-  else
-  {
-    char* peername = 0;
-    const int result = X509_check_host(cert,
-        host_.c_str(), host_.size(), 0, &peername);
-    OPENSSL_free(peername);
-    return result == 1;
-  }
-}
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_IMPL_HOST_NAME_VERIFICATION_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/rfc2818_verification.ipp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/rfc2818_verification.ipp
deleted file mode 100644
index 93e161d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/rfc2818_verification.ipp
+++ /dev/null
@@ -1,164 +0,0 @@
-//
-// ssl/impl/rfc2818_verification.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP
-#define ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-#include <cctype>
-#include <cstring>
-#include "asio/ip/address.hpp"
-#include "asio/ssl/rfc2818_verification.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-bool rfc2818_verification::operator()(
-    bool preverified, verify_context& ctx) const
-{
-  using namespace std; // For memcmp.
-
-  // Don't bother looking at certificates that have failed pre-verification.
-  if (!preverified)
-    return false;
-
-  // We're only interested in checking the certificate at the end of the chain.
-  int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle());
-  if (depth > 0)
-    return true;
-
-  // Try converting the host name to an address. If it is an address then we
-  // need to look for an IP address in the certificate rather than a host name.
-  asio::error_code ec;
-  ip::address address = ip::make_address(host_, ec);
-  bool is_address = !ec;
-
-  X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
-
-  // Go through the alternate names in the certificate looking for matching DNS
-  // or IP address entries.
-  GENERAL_NAMES* gens = static_cast<GENERAL_NAMES*>(
-      X509_get_ext_d2i(cert, NID_subject_alt_name, 0, 0));
-  for (int i = 0; i < sk_GENERAL_NAME_num(gens); ++i)
-  {
-    GENERAL_NAME* gen = sk_GENERAL_NAME_value(gens, i);
-    if (gen->type == GEN_DNS && !is_address)
-    {
-      ASN1_IA5STRING* domain = gen->d.dNSName;
-      if (domain->type == V_ASN1_IA5STRING && domain->data && domain->length)
-      {
-        const char* pattern = reinterpret_cast<const char*>(domain->data);
-        std::size_t pattern_length = domain->length;
-        if (match_pattern(pattern, pattern_length, host_.c_str()))
-        {
-          GENERAL_NAMES_free(gens);
-          return true;
-        }
-      }
-    }
-    else if (gen->type == GEN_IPADD && is_address)
-    {
-      ASN1_OCTET_STRING* ip_address = gen->d.iPAddress;
-      if (ip_address->type == V_ASN1_OCTET_STRING && ip_address->data)
-      {
-        if (address.is_v4() && ip_address->length == 4)
-        {
-          ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
-          if (memcmp(bytes.data(), ip_address->data, 4) == 0)
-          {
-            GENERAL_NAMES_free(gens);
-            return true;
-          }
-        }
-        else if (address.is_v6() && ip_address->length == 16)
-        {
-          ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
-          if (memcmp(bytes.data(), ip_address->data, 16) == 0)
-          {
-            GENERAL_NAMES_free(gens);
-            return true;
-          }
-        }
-      }
-    }
-  }
-  GENERAL_NAMES_free(gens);
-
-  // No match in the alternate names, so try the common names. We should only
-  // use the "most specific" common name, which is the last one in the list.
-  X509_NAME* name = X509_get_subject_name(cert);
-  int i = -1;
-  ASN1_STRING* common_name = 0;
-  while ((i = X509_NAME_get_index_by_NID(name, NID_commonName, i)) >= 0)
-  {
-    X509_NAME_ENTRY* name_entry = X509_NAME_get_entry(name, i);
-    common_name = X509_NAME_ENTRY_get_data(name_entry);
-  }
-  if (common_name && common_name->data && common_name->length)
-  {
-    const char* pattern = reinterpret_cast<const char*>(common_name->data);
-    std::size_t pattern_length = common_name->length;
-    if (match_pattern(pattern, pattern_length, host_.c_str()))
-      return true;
-  }
-
-  return false;
-}
-
-bool rfc2818_verification::match_pattern(const char* pattern,
-    std::size_t pattern_length, const char* host)
-{
-  using namespace std; // For tolower.
-
-  const char* p = pattern;
-  const char* p_end = p + pattern_length;
-  const char* h = host;
-
-  while (p != p_end && *h)
-  {
-    if (*p == '*')
-    {
-      ++p;
-      while (*h && *h != '.')
-        if (match_pattern(p, p_end - p, h++))
-          return true;
-    }
-    else if (tolower(*p) == tolower(*h))
-    {
-      ++p;
-      ++h;
-    }
-    else
-    {
-      return false;
-    }
-  }
-
-  return p == p_end && !*h;
-}
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-#endif // ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/src.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/src.hpp
deleted file mode 100644
index 5ffb95f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/impl/src.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// impl/ssl/src.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_IMPL_SRC_HPP
-#define ASIO_SSL_IMPL_SRC_HPP
-
-#define ASIO_SOURCE
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# error Do not compile Asio library source with ASIO_HEADER_ONLY defined
-#endif
-
-#include "asio/ssl/impl/context.ipp"
-#include "asio/ssl/impl/error.ipp"
-#include "asio/ssl/detail/impl/engine.ipp"
-#include "asio/ssl/detail/impl/openssl_init.ipp"
-#include "asio/ssl/impl/host_name_verification.ipp"
-#include "asio/ssl/impl/rfc2818_verification.ipp"
-
-#endif // ASIO_SSL_IMPL_SRC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/rfc2818_verification.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/rfc2818_verification.hpp
deleted file mode 100644
index db28310..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/rfc2818_verification.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// ssl/rfc2818_verification.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_RFC2818_VERIFICATION_HPP
-#define ASIO_SSL_RFC2818_VERIFICATION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-#include <string>
-#include "asio/ssl/detail/openssl_types.hpp"
-#include "asio/ssl/verify_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// (Deprecated. Use ssl::host_name_verification.) Verifies a certificate
-/// against a hostname according to the rules described in RFC 2818.
-/**
- * @par Example
- * The following example shows how to synchronously open a secure connection to
- * a given host name:
- * @code
- * using asio::ip::tcp;
- * namespace ssl = asio::ssl;
- * typedef ssl::stream<tcp::socket> ssl_socket;
- *
- * // Create a context that uses the default paths for finding CA certificates.
- * ssl::context ctx(ssl::context::sslv23);
- * ctx.set_default_verify_paths();
- *
- * // Open a socket and connect it to the remote host.
- * asio::io_context io_context;
- * ssl_socket sock(io_context, ctx);
- * tcp::resolver resolver(io_context);
- * tcp::resolver::query query("host.name", "https");
- * asio::connect(sock.lowest_layer(), resolver.resolve(query));
- * sock.lowest_layer().set_option(tcp::no_delay(true));
- *
- * // Perform SSL handshake and verify the remote host's certificate.
- * sock.set_verify_mode(ssl::verify_peer);
- * sock.set_verify_callback(ssl::rfc2818_verification("host.name"));
- * sock.handshake(ssl_socket::client);
- *
- * // ... read and write as normal ...
- * @endcode
- */
-class rfc2818_verification
-{
-public:
-  /// The type of the function object's result.
-  typedef bool result_type;
-
-  /// Constructor.
-  explicit rfc2818_verification(const std::string& host)
-    : host_(host)
-  {
-  }
-
-  /// Perform certificate verification.
-  ASIO_DECL bool operator()(bool preverified, verify_context& ctx) const;
-
-private:
-  // Helper function to check a host name against a pattern.
-  ASIO_DECL static bool match_pattern(const char* pattern,
-      std::size_t pattern_length, const char* host);
-
-  // Helper function to check a host name against an IPv4 address
-  // The host name to be checked.
-  std::string host_;
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/ssl/impl/rfc2818_verification.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-#endif // ASIO_SSL_RFC2818_VERIFICATION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream.hpp
deleted file mode 100644
index 9cf83e0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream.hpp
+++ /dev/null
@@ -1,1042 +0,0 @@
-//
-// ssl/stream.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_STREAM_HPP
-#define ASIO_SSL_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/handler_type_requirements.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/ssl/context.hpp"
-#include "asio/ssl/detail/buffered_handshake_op.hpp"
-#include "asio/ssl/detail/handshake_op.hpp"
-#include "asio/ssl/detail/io.hpp"
-#include "asio/ssl/detail/read_op.hpp"
-#include "asio/ssl/detail/shutdown_op.hpp"
-#include "asio/ssl/detail/stream_core.hpp"
-#include "asio/ssl/detail/write_op.hpp"
-#include "asio/ssl/stream_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// Provides stream-oriented functionality using SSL.
-/**
- * The stream class template provides asynchronous and blocking stream-oriented
- * functionality using SSL.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe. The application must also ensure that all
- * asynchronous operations are performed within the same implicit or explicit
- * strand.
- *
- * @par Example
- * To use the SSL stream template with an ip::tcp::socket, you would write:
- * @code
- * asio::io_context my_context;
- * asio::ssl::context ctx(asio::ssl::context::sslv23);
- * asio::ssl::stream<asio::ip::tcp::socket> sock(my_context, ctx);
- * @endcode
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class stream :
-  public stream_base,
-  private noncopyable
-{
-private:
-  class initiate_async_handshake;
-  class initiate_async_buffered_handshake;
-  class initiate_async_shutdown;
-  class initiate_async_write_some;
-  class initiate_async_read_some;
-
-public:
-  /// The native handle type of the SSL stream.
-  typedef SSL* native_handle_type;
-
-  /// Structure for use with deprecated impl_type.
-  struct impl_struct
-  {
-    SSL* ssl;
-  };
-
-  /// The type of the next layer.
-  typedef remove_reference_t<Stream> next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// The type of the executor associated with the object.
-  typedef typename lowest_layer_type::executor_type executor_type;
-
-  /// Construct a stream.
-  /**
-   * This constructor creates a stream and initialises the underlying stream
-   * object.
-   *
-   * @param arg The argument to be passed to initialise the underlying stream.
-   *
-   * @param ctx The SSL context to be used for the stream.
-   */
-  template <typename Arg>
-  stream(Arg&& arg, context& ctx)
-    : next_layer_(static_cast<Arg&&>(arg)),
-      core_(ctx.native_handle(), next_layer_.lowest_layer().get_executor())
-  {
-  }
-
-  /// Construct a stream from an existing native implementation.
-  /**
-   * This constructor creates a stream and initialises the underlying stream
-   * object. On success, ownership of the native implementation is transferred
-   * to the stream, and it will be cleaned up when the stream is destroyed.
-   *
-   * @param arg The argument to be passed to initialise the underlying stream.
-   *
-   * @param handle An existing native SSL implementation.
-   */
-  template <typename Arg>
-  stream(Arg&& arg, native_handle_type handle)
-    : next_layer_(static_cast<Arg&&>(arg)),
-      core_(handle, next_layer_.lowest_layer().get_executor())
-  {
-  }
-
-  /// Move-construct a stream from another.
-  /**
-   * @param other The other stream object from which the move will occur. Must
-   * have no outstanding asynchronous operations associated with it. Following
-   * the move, @c other has a valid but unspecified state where the only safe
-   * operation is destruction, or use as the target of a move assignment.
-   */
-  stream(stream&& other)
-    : next_layer_(static_cast<Stream&&>(other.next_layer_)),
-      core_(static_cast<detail::stream_core&&>(other.core_))
-  {
-  }
-
-  /// Move-assign a stream from another.
-  /**
-   * @param other The other stream object from which the move will occur. Must
-   * have no outstanding asynchronous operations associated with it. Following
-   * the move, @c other has a valid but unspecified state where the only safe
-   * operation is destruction, or use as the target of a move assignment.
-   */
-  stream& operator=(stream&& other)
-  {
-    if (this != &other)
-    {
-      next_layer_ = static_cast<Stream&&>(other.next_layer_);
-      core_ = static_cast<detail::stream_core&&>(other.core_);
-    }
-    return *this;
-  }
-
-  /// Destructor.
-  /**
-   * @note A @c stream object must not be destroyed while there are pending
-   * asynchronous operations associated with it.
-   */
-  ~stream()
-  {
-  }
-
-  /// Get the executor associated with the object.
-  /**
-   * This function may be used to obtain the executor object that the stream
-   * uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A copy of the executor that stream will use to dispatch handlers.
-   */
-  executor_type get_executor() noexcept
-  {
-    return next_layer_.lowest_layer().get_executor();
-  }
-
-  /// Get the underlying implementation in the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to context functionality that is
-   * not otherwise provided.
-   *
-   * @par Example
-   * The native_handle() function returns a pointer of type @c SSL* that is
-   * suitable for passing to functions such as @c SSL_get_verify_result and
-   * @c SSL_get_peer_certificate:
-   * @code
-   * asio::ssl::stream<asio::ip::tcp::socket> sock(io_ctx, ctx);
-   *
-   * // ... establish connection and perform handshake ...
-   *
-   * if (X509* cert = SSL_get_peer_certificate(sock.native_handle()))
-   * {
-   *   if (SSL_get_verify_result(sock.native_handle()) == X509_V_OK)
-   *   {
-   *     // ...
-   *   }
-   * }
-   * @endcode
-   */
-  native_handle_type native_handle()
-  {
-    return core_.engine_.native_handle();
-  }
-
-  /// Get a reference to the next layer.
-  /**
-   * This function returns a reference to the next layer in a stack of stream
-   * layers.
-   *
-   * @return A reference to the next layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  const next_layer_type& next_layer() const
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the next layer.
-  /**
-   * This function returns a reference to the next layer in a stack of stream
-   * layers.
-   *
-   * @return A reference to the next layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * stream layers.
-   *
-   * @return A reference to the lowest layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * stream layers.
-   *
-   * @return A reference to the lowest layer in the stack of stream layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the stream. The new mode will override the mode inherited from the context.
-   *
-   * @param v A bitmask of peer verification modes. See @ref verify_mode for
-   * available values.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_set_verify.
-   */
-  void set_verify_mode(verify_mode v)
-  {
-    asio::error_code ec;
-    set_verify_mode(v, ec);
-    asio::detail::throw_error(ec, "set_verify_mode");
-  }
-
-  /// Set the peer verification mode.
-  /**
-   * This function may be used to configure the peer verification mode used by
-   * the stream. The new mode will override the mode inherited from the context.
-   *
-   * @param v A bitmask of peer verification modes. See @ref verify_mode for
-   * available values.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_set_verify.
-   */
-  ASIO_SYNC_OP_VOID set_verify_mode(
-      verify_mode v, asio::error_code& ec)
-  {
-    core_.engine_.set_verify_mode(v, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Set the peer verification depth.
-  /**
-   * This function may be used to configure the maximum verification depth
-   * allowed by the stream.
-   *
-   * @param depth Maximum depth for the certificate chain verification that
-   * shall be allowed.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_set_verify_depth.
-   */
-  void set_verify_depth(int depth)
-  {
-    asio::error_code ec;
-    set_verify_depth(depth, ec);
-    asio::detail::throw_error(ec, "set_verify_depth");
-  }
-
-  /// Set the peer verification depth.
-  /**
-   * This function may be used to configure the maximum verification depth
-   * allowed by the stream.
-   *
-   * @param depth Maximum depth for the certificate chain verification that
-   * shall be allowed.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_set_verify_depth.
-   */
-  ASIO_SYNC_OP_VOID set_verify_depth(
-      int depth, asio::error_code& ec)
-  {
-    core_.engine_.set_verify_depth(depth, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Set the callback used to verify peer certificates.
-  /**
-   * This function is used to specify a callback function that will be called
-   * by the implementation when it needs to verify a peer certificate.
-   *
-   * @param callback The function object to be used for verifying a certificate.
-   * The function signature of the handler must be:
-   * @code bool verify_callback(
-   *   bool preverified, // True if the certificate passed pre-verification.
-   *   verify_context& ctx // The peer certificate and other context.
-   * ); @endcode
-   * The return value of the callback is true if the certificate has passed
-   * verification, false otherwise.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note Calls @c SSL_set_verify.
-   */
-  template <typename VerifyCallback>
-  void set_verify_callback(VerifyCallback callback)
-  {
-    asio::error_code ec;
-    this->set_verify_callback(callback, ec);
-    asio::detail::throw_error(ec, "set_verify_callback");
-  }
-
-  /// Set the callback used to verify peer certificates.
-  /**
-   * This function is used to specify a callback function that will be called
-   * by the implementation when it needs to verify a peer certificate.
-   *
-   * @param callback The function object to be used for verifying a certificate.
-   * The function signature of the handler must be:
-   * @code bool verify_callback(
-   *   bool preverified, // True if the certificate passed pre-verification.
-   *   verify_context& ctx // The peer certificate and other context.
-   * ); @endcode
-   * The return value of the callback is true if the certificate has passed
-   * verification, false otherwise.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Calls @c SSL_set_verify.
-   */
-  template <typename VerifyCallback>
-  ASIO_SYNC_OP_VOID set_verify_callback(VerifyCallback callback,
-      asio::error_code& ec)
-  {
-    core_.engine_.set_verify_callback(
-        new detail::verify_callback<VerifyCallback>(callback), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void handshake(handshake_type type)
-  {
-    asio::error_code ec;
-    handshake(type, ec);
-    asio::detail::throw_error(ec, "handshake");
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID handshake(handshake_type type,
-      asio::error_code& ec)
-  {
-    detail::io(next_layer_, core_, detail::handshake_op(type), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param buffers The buffered data to be reused for the handshake.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ConstBufferSequence>
-  void handshake(handshake_type type, const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    handshake(type, buffers, ec);
-    asio::detail::throw_error(ec, "handshake");
-  }
-
-  /// Perform SSL handshaking.
-  /**
-   * This function is used to perform SSL handshaking on the stream. The
-   * function call will block until handshaking is complete or an error occurs.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param buffers The buffered data to be reused for the handshake.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  template <typename ConstBufferSequence>
-  ASIO_SYNC_OP_VOID handshake(handshake_type type,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    detail::io(next_layer_, core_,
-        detail::buffered_handshake_op<ConstBufferSequence>(type, buffers), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Start an asynchronous SSL handshake.
-  /**
-   * This function is used to asynchronously perform an SSL handshake on the
-   * stream. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the handshake completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * if they are also supported by the @c Stream type's @c async_read_some and
-   * @c async_write_some operations.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        HandshakeToken = default_completion_token_t<executor_type>>
-  auto async_handshake(handshake_type type,
-      HandshakeToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<HandshakeToken,
-        void (asio::error_code)>(
-          declval<initiate_async_handshake>(), token, type))
-  {
-    return async_initiate<HandshakeToken,
-      void (asio::error_code)>(
-        initiate_async_handshake(this), token, type);
-  }
-
-  /// Start an asynchronous SSL handshake.
-  /**
-   * This function is used to asynchronously perform an SSL handshake on the
-   * stream. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param type The type of handshaking to be performed, i.e. as a client or as
-   * a server.
-   *
-   * @param buffers The buffered data to be reused for the handshake. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * buffers is retained by the caller, which must guarantee that they remain
-   * valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the handshake completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Amount of buffers used in handshake.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * if they are also supported by the @c Stream type's @c async_read_some and
-   * @c async_write_some operations.
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) BufferedHandshakeToken
-          = default_completion_token_t<executor_type>>
-  auto async_handshake(handshake_type type, const ConstBufferSequence& buffers,
-      BufferedHandshakeToken&& token
-        = default_completion_token_t<executor_type>(),
-      constraint_t<
-        is_const_buffer_sequence<ConstBufferSequence>::value
-      > = 0)
-    -> decltype(
-      async_initiate<BufferedHandshakeToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_buffered_handshake>(), token, type, buffers))
-  {
-    return async_initiate<BufferedHandshakeToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_buffered_handshake(this), token, type, buffers);
-  }
-
-  /// Shut down SSL on the stream.
-  /**
-   * This function is used to shut down SSL on the stream. The function call
-   * will block until SSL has been shut down or an error occurs.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void shutdown()
-  {
-    asio::error_code ec;
-    shutdown(ec);
-    asio::detail::throw_error(ec, "shutdown");
-  }
-
-  /// Shut down SSL on the stream.
-  /**
-   * This function is used to shut down SSL on the stream. The function call
-   * will block until SSL has been shut down or an error occurs.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID shutdown(asio::error_code& ec)
-  {
-    detail::io(next_layer_, core_, detail::shutdown_op(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Asynchronously shut down SSL on the stream.
-  /**
-   * This function is used to asynchronously shut down SSL on the stream. It is
-   * an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the shutdown completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * if they are also supported by the @c Stream type's @c async_read_some and
-   * @c async_write_some operations.
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        ShutdownToken
-          = default_completion_token_t<executor_type>>
-  auto async_shutdown(
-      ShutdownToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ShutdownToken,
-        void (asio::error_code)>(
-          declval<initiate_async_shutdown>(), token))
-  {
-    return async_initiate<ShutdownToken,
-      void (asio::error_code)>(
-        initiate_async_shutdown(this), token);
-  }
-
-  /// Write some data to the stream.
-  /**
-   * This function is used to write data on the stream. The function call will
-   * block until one or more bytes of data has been written successfully, or
-   * until an error occurs.
-   *
-   * @param buffers The data to be written.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that all
-   * data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t n = write_some(buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return n;
-  }
-
-  /// Write some data to the stream.
-  /**
-   * This function is used to write data on the stream. The function call will
-   * block until one or more bytes of data has been written successfully, or
-   * until an error occurs.
-   *
-   * @param buffers The data to be written to the stream.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that all
-   * data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return detail::io(next_layer_, core_,
-        detail::write_op<ConstBufferSequence>(buffers), ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write one or more bytes of data to
-   * the stream. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers The data to be written to the stream. Although the buffers
-   * object may be copied as necessary, ownership of the underlying buffers is
-   * retained by the caller, which must guarantee that they remain valid until
-   * the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_write_some operation may not transmit all of the data to
-   * the peer. Consider using the @ref async_write function if you need to
-   * ensure that all data is written before the asynchronous operation
-   * completes.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * if they are also supported by the @c Stream type's @c async_read_some and
-   * @c async_write_some operations.
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some>(), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-  /// Read some data from the stream.
-  /**
-   * This function is used to read data from the stream. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t n = read_some(buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return n;
-  }
-
-  /// Read some data from the stream.
-  /**
-   * This function is used to read data from the stream. The function call will
-   * block until one or more bytes of data has been read successfully, or until
-   * an error occurs.
-   *
-   * @param buffers The buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return detail::io(next_layer_, core_,
-        detail::read_op<MutableBufferSequence>(buffers), ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read one or more bytes of data from
-   * the stream. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param buffers The buffers into which the data will be read. Although the
-   * buffers object may be copied as necessary, ownership of the underlying
-   * buffers is retained by the caller, which must guarantee that they remain
-   * valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The async_read_some operation may not read all of the requested
-   * number of bytes. Consider using the @ref async_read function if you need to
-   * ensure that the requested amount of data is read before the asynchronous
-   * operation completes.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * if they are also supported by the @c Stream type's @c async_read_some and
-   * @c async_write_some operations.
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  class initiate_async_handshake
-  {
-  public:
-    typedef typename stream::executor_type executor_type;
-
-    explicit initiate_async_handshake(stream* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename HandshakeHandler>
-    void operator()(HandshakeHandler&& handler,
-        handshake_type type) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a HandshakeHandler.
-      ASIO_HANDSHAKE_HANDLER_CHECK(HandshakeHandler, handler) type_check;
-
-      asio::detail::non_const_lvalue<HandshakeHandler> handler2(handler);
-      detail::async_io(self_->next_layer_, self_->core_,
-          detail::handshake_op(type), handler2.value);
-    }
-
-  private:
-    stream* self_;
-  };
-
-  class initiate_async_buffered_handshake
-  {
-  public:
-    typedef typename stream::executor_type executor_type;
-
-    explicit initiate_async_buffered_handshake(stream* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename BufferedHandshakeHandler, typename ConstBufferSequence>
-    void operator()(BufferedHandshakeHandler&& handler,
-        handshake_type type, const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your
-      // handler does not meet the documented type requirements for a
-      // BufferedHandshakeHandler.
-      ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK(
-          BufferedHandshakeHandler, handler) type_check;
-
-      asio::detail::non_const_lvalue<
-          BufferedHandshakeHandler> handler2(handler);
-      detail::async_io(self_->next_layer_, self_->core_,
-          detail::buffered_handshake_op<ConstBufferSequence>(type, buffers),
-          handler2.value);
-    }
-
-  private:
-    stream* self_;
-  };
-
-  class initiate_async_shutdown
-  {
-  public:
-    typedef typename stream::executor_type executor_type;
-
-    explicit initiate_async_shutdown(stream* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ShutdownHandler>
-    void operator()(ShutdownHandler&& handler) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ShutdownHandler.
-      ASIO_HANDSHAKE_HANDLER_CHECK(ShutdownHandler, handler) type_check;
-
-      asio::detail::non_const_lvalue<ShutdownHandler> handler2(handler);
-      detail::async_io(self_->next_layer_, self_->core_,
-          detail::shutdown_op(), handler2.value);
-    }
-
-  private:
-    stream* self_;
-  };
-
-  class initiate_async_write_some
-  {
-  public:
-    typedef typename stream::executor_type executor_type;
-
-    explicit initiate_async_write_some(stream* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) 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;
-
-      asio::detail::non_const_lvalue<WriteHandler> handler2(handler);
-      detail::async_io(self_->next_layer_, self_->core_,
-          detail::write_op<ConstBufferSequence>(buffers), handler2.value);
-    }
-
-  private:
-    stream* self_;
-  };
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef typename stream::executor_type executor_type;
-
-    explicit initiate_async_read_some(stream* self)
-      : self_(self)
-    {
-    }
-
-    executor_type get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) 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;
-
-      asio::detail::non_const_lvalue<ReadHandler> handler2(handler);
-      detail::async_io(self_->next_layer_, self_->core_,
-          detail::read_op<MutableBufferSequence>(buffers), handler2.value);
-    }
-
-  private:
-    stream* self_;
-  };
-
-  Stream next_layer_;
-  detail::stream_core core_;
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_STREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream_base.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream_base.hpp
deleted file mode 100644
index 2728ec8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/stream_base.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// ssl/stream_base.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_STREAM_BASE_HPP
-#define ASIO_SSL_STREAM_BASE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// The stream_base class is used as a base for the asio::ssl::stream
-/// class template so that we have a common place to define various enums.
-class stream_base
-{
-public:
-  /// Different handshake types.
-  enum handshake_type
-  {
-    /// Perform handshaking as a client.
-    client,
-
-    /// Perform handshaking as a server.
-    server
-  };
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  ~stream_base()
-  {
-  }
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_STREAM_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_context.hpp
deleted file mode 100644
index 7251856..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_context.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// ssl/verify_context.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_VERIFY_CONTEXT_HPP
-#define ASIO_SSL_VERIFY_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// A simple wrapper around the X509_STORE_CTX type, used during verification of
-/// a peer certificate.
-/**
- * @note The verify_context does not own the underlying X509_STORE_CTX object.
- */
-class verify_context
-  : private noncopyable
-{
-public:
-  /// The native handle type of the verification context.
-  typedef X509_STORE_CTX* native_handle_type;
-
-  /// Constructor.
-  explicit verify_context(native_handle_type handle)
-    : handle_(handle)
-  {
-  }
-
-  /// Get the underlying implementation in the native type.
-  /**
-   * This function may be used to obtain the underlying implementation of the
-   * context. This is intended to allow access to context functionality that is
-   * not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return handle_;
-  }
-
-private:
-  // The underlying native implementation.
-  native_handle_type handle_;
-};
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_VERIFY_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_mode.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_mode.hpp
deleted file mode 100644
index 919e308..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ssl/verify_mode.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// ssl/verify_mode.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SSL_VERIFY_MODE_HPP
-#define ASIO_SSL_VERIFY_MODE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/ssl/detail/openssl_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace ssl {
-
-/// Bitmask type for peer verification.
-/**
- * Possible values are:
- *
- * @li @ref verify_none
- * @li @ref verify_peer
- * @li @ref verify_fail_if_no_peer_cert
- * @li @ref verify_client_once
- */
-typedef int verify_mode;
-
-#if defined(GENERATING_DOCUMENTATION)
-/// No verification.
-const int verify_none = implementation_defined;
-
-/// Verify the peer.
-const int verify_peer = implementation_defined;
-
-/// Fail verification if the peer has no certificate. Ignored unless
-/// @ref verify_peer is set.
-const int verify_fail_if_no_peer_cert = implementation_defined;
-
-/// Do not request client certificate on renegotiation. Ignored unless
-/// @ref verify_peer is set.
-const int verify_client_once = implementation_defined;
-#else
-const int verify_none = SSL_VERIFY_NONE;
-const int verify_peer = SSL_VERIFY_PEER;
-const int verify_fail_if_no_peer_cert = SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
-const int verify_client_once = SSL_VERIFY_CLIENT_ONCE;
-#endif
-
-} // namespace ssl
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SSL_VERIFY_MODE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/static_thread_pool.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/static_thread_pool.hpp
deleted file mode 100644
index 636afe1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/static_thread_pool.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// static_thread_pool.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_STATIC_THREAD_POOL_HPP
-#define ASIO_STATIC_THREAD_POOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/thread_pool.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-typedef thread_pool static_thread_pool;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_STATIC_THREAD_POOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/steady_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/steady_timer.hpp
deleted file mode 100644
index 5db0025..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/steady_timer.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// steady_timer.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_STEADY_TIMER_HPP
-#define ASIO_STEADY_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/detail/chrono.hpp"
-
-namespace asio {
-
-/// Typedef for a timer based on the steady clock.
-/**
- * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
- * available. Otherwise, it may use the Boost.Chrono library. To explicitly
- * utilise Boost.Chrono, use the basic_waitable_timer template directly:
- * @code
- * typedef basic_waitable_timer<boost::chrono::steady_clock> timer;
- * @endcode
- */
-typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
-
-} // namespace asio
-
-#endif // ASIO_STEADY_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/strand.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/strand.hpp
deleted file mode 100644
index c63592b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/strand.hpp
+++ /dev/null
@@ -1,557 +0,0 @@
-//
-// strand.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_STRAND_HPP
-#define ASIO_STRAND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/strand_executor_service.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/executor.hpp"
-#include "asio/is_executor.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides serialised function invocation for any executor type.
-template <typename Executor>
-class strand
-{
-public:
-  /// The type of the underlying executor.
-  typedef Executor inner_executor_type;
-
-  /// Default constructor.
-  /**
-   * This constructor is only valid if the underlying executor type is default
-   * constructible.
-   */
-  strand()
-    : executor_(),
-      impl_(strand::create_implementation(executor_))
-  {
-  }
-
-  /// Construct a strand for the specified executor.
-  template <typename Executor1>
-  explicit strand(const Executor1& e,
-      constraint_t<
-        conditional_t<
-          !is_same<Executor1, strand>::value,
-          is_convertible<Executor1, Executor>,
-          false_type
-        >::value
-      > = 0)
-    : executor_(e),
-      impl_(strand::create_implementation(executor_))
-  {
-  }
-
-  /// Copy constructor.
-  strand(const strand& other) noexcept
-    : executor_(other.executor_),
-      impl_(other.impl_)
-  {
-  }
-
-  /// Converting constructor.
-  /**
-   * This constructor is only valid if the @c OtherExecutor type is convertible
-   * to @c Executor.
-   */
-  template <class OtherExecutor>
-  strand(
-      const strand<OtherExecutor>& other) noexcept
-    : executor_(other.executor_),
-      impl_(other.impl_)
-  {
-  }
-
-  /// Assignment operator.
-  strand& operator=(const strand& other) noexcept
-  {
-    executor_ = other.executor_;
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// Converting assignment operator.
-  /**
-   * This assignment operator is only valid if the @c OtherExecutor type is
-   * convertible to @c Executor.
-   */
-  template <class OtherExecutor>
-  strand& operator=(
-      const strand<OtherExecutor>& other) noexcept
-  {
-    executor_ = other.executor_;
-    impl_ = other.impl_;
-    return *this;
-  }
-
-  /// Move constructor.
-  strand(strand&& other) noexcept
-    : executor_(static_cast<Executor&&>(other.executor_)),
-      impl_(static_cast<implementation_type&&>(other.impl_))
-  {
-  }
-
-  /// Converting move constructor.
-  /**
-   * This constructor is only valid if the @c OtherExecutor type is convertible
-   * to @c Executor.
-   */
-  template <class OtherExecutor>
-  strand(strand<OtherExecutor>&& other) noexcept
-    : executor_(static_cast<OtherExecutor&&>(other.executor_)),
-      impl_(static_cast<implementation_type&&>(other.impl_))
-  {
-  }
-
-  /// Move assignment operator.
-  strand& operator=(strand&& other) noexcept
-  {
-    executor_ = static_cast<Executor&&>(other.executor_);
-    impl_ = static_cast<implementation_type&&>(other.impl_);
-    return *this;
-  }
-
-  /// Converting move assignment operator.
-  /**
-   * This assignment operator is only valid if the @c OtherExecutor type is
-   * convertible to @c Executor.
-   */
-  template <class OtherExecutor>
-  strand& operator=(strand<OtherExecutor>&& other) noexcept
-  {
-    executor_ = static_cast<OtherExecutor&&>(other.executor_);
-    impl_ = static_cast<implementation_type&&>(other.impl_);
-    return *this;
-  }
-
-  /// Destructor.
-  ~strand() noexcept
-  {
-  }
-
-  /// Obtain the underlying executor.
-  inner_executor_type get_inner_executor() const noexcept
-  {
-    return executor_;
-  }
-
-  /// Forward a query to the underlying executor.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::strand<my_executor_type> ex = ...;
-   * if (asio::query(ex, asio::execution::blocking)
-   *       == asio::execution::blocking.never)
-   *   ... @endcode
-   */
-  template <typename Property>
-  constraint_t<
-    can_query<const Executor&, Property>::value,
-    conditional_t<
-      is_convertible<Property, execution::blocking_t>::value,
-      execution::blocking_t,
-      query_result_t<const Executor&, Property>
-    >
-  > query(const Property& p) const
-    noexcept(is_nothrow_query<const Executor&, Property>::value)
-  {
-    return this->query_helper(
-        is_convertible<Property, execution::blocking_t>(), p);
-  }
-
-  /// Forward a requirement to the underlying executor.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::strand<my_executor_type> ex1 = ...;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.never); @endcode
-   */
-  template <typename Property>
-  constraint_t<
-    can_require<const Executor&, Property>::value
-      && !is_convertible<Property, execution::blocking_t::always_t>::value,
-    strand<decay_t<require_result_t<const Executor&, Property>>>
-  > require(const Property& p) const
-    noexcept(is_nothrow_require<const Executor&, Property>::value)
-  {
-    return strand<decay_t<require_result_t<const Executor&, Property>>>(
-        asio::require(executor_, p), impl_);
-  }
-
-  /// Forward a preference to the underlying executor.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::prefer customisation point.
-   *
-   * For example:
-   * @code asio::strand<my_executor_type> ex1 = ...;
-   * auto ex2 = asio::prefer(ex1,
-   *     asio::execution::blocking.never); @endcode
-   */
-  template <typename Property>
-  constraint_t<
-    can_prefer<const Executor&, Property>::value
-      && !is_convertible<Property, execution::blocking_t::always_t>::value,
-    strand<decay_t<prefer_result_t<const Executor&, Property>>>
-  > prefer(const Property& p) const
-    noexcept(is_nothrow_prefer<const Executor&, Property>::value)
-  {
-    return strand<decay_t<prefer_result_t<const Executor&, Property>>>(
-        asio::prefer(executor_, p), impl_);
-  }
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-  /// Obtain the underlying execution context.
-  execution_context& context() const noexcept
-  {
-    return executor_.context();
-  }
-
-  /// Inform the strand that it has some outstanding work to do.
-  /**
-   * The strand delegates this call to its underlying executor.
-   */
-  void on_work_started() const noexcept
-  {
-    executor_.on_work_started();
-  }
-
-  /// Inform the strand that some work is no longer outstanding.
-  /**
-   * The strand delegates this call to its underlying executor.
-   */
-  void on_work_finished() const noexcept
-  {
-    executor_.on_work_finished();
-  }
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the strand to execute the given function
-   * object on its underlying executor. The function object will be executed
-   * according to the properties of the underlying executor.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   */
-  template <typename Function>
-  constraint_t<
-    traits::execute_member<const Executor&, Function>::is_valid,
-    void
-  > execute(Function&& f) const
-  {
-    detail::strand_executor_service::execute(impl_,
-        executor_, static_cast<Function&&>(f));
-  }
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the strand to execute the given function
-   * object on its underlying executor. The function object will be executed
-   * inside this function if the strand is not otherwise busy and if the
-   * underlying executor's @c dispatch() function is also able to execute the
-   * function before returning.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void dispatch(Function&& f, const Allocator& a) const
-  {
-    detail::strand_executor_service::dispatch(impl_,
-        executor_, static_cast<Function&&>(f), a);
-  }
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled by the underlying executor's defer function.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void post(Function&& f, const Allocator& a) const
-  {
-    detail::strand_executor_service::post(impl_,
-        executor_, static_cast<Function&&>(f), a);
-  }
-
-  /// Request the strand to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled by the underlying executor's defer function.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename Allocator>
-  void defer(Function&& f, const Allocator& a) const
-  {
-    detail::strand_executor_service::defer(impl_,
-        executor_, static_cast<Function&&>(f), a);
-  }
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-  /// Determine whether the strand is running in the current thread.
-  /**
-   * @return @c true if the current thread is executing a function that was
-   * submitted to the strand using post(), dispatch() or defer(). Otherwise
-   * returns @c false.
-   */
-  bool running_in_this_thread() const noexcept
-  {
-    return detail::strand_executor_service::running_in_this_thread(impl_);
-  }
-
-  /// Compare two strands for equality.
-  /**
-   * Two strands are equal if they refer to the same ordered, non-concurrent
-   * state.
-   */
-  friend bool operator==(const strand& a, const strand& b) noexcept
-  {
-    return a.impl_ == b.impl_;
-  }
-
-  /// Compare two strands for inequality.
-  /**
-   * Two strands are equal if they refer to the same ordered, non-concurrent
-   * state.
-   */
-  friend bool operator!=(const strand& a, const strand& b) noexcept
-  {
-    return a.impl_ != b.impl_;
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-private:
-#endif // defined(GENERATING_DOCUMENTATION)
-  typedef detail::strand_executor_service::implementation_type
-    implementation_type;
-
-  template <typename InnerExecutor>
-  static implementation_type create_implementation(const InnerExecutor& ex,
-      constraint_t<
-        can_query<InnerExecutor, execution::context_t>::value
-      > = 0)
-  {
-    return use_service<detail::strand_executor_service>(
-        asio::query(ex, execution::context)).create_implementation();
-  }
-
-  template <typename InnerExecutor>
-  static implementation_type create_implementation(const InnerExecutor& ex,
-      constraint_t<
-        !can_query<InnerExecutor, execution::context_t>::value
-      > = 0)
-  {
-    return use_service<detail::strand_executor_service>(
-        ex.context()).create_implementation();
-  }
-
-  strand(const Executor& ex, const implementation_type& impl)
-    : executor_(ex),
-      impl_(impl)
-  {
-  }
-
-  template <typename Property>
-  query_result_t<const Executor&, Property> query_helper(
-      false_type, const Property& property) const
-  {
-    return asio::query(executor_, property);
-  }
-
-  template <typename Property>
-  execution::blocking_t query_helper(true_type, const Property& property) const
-  {
-    execution::blocking_t result = asio::query(executor_, property);
-    return result == execution::blocking.always
-      ? execution::blocking.possibly : result;
-  }
-
-  Executor executor_;
-  implementation_type impl_;
-};
-
-/** @defgroup make_strand asio::make_strand
- *
- * @brief The asio::make_strand function creates a @ref strand object for
- * an executor or execution context.
- */
-/*@{*/
-
-/// Create a @ref strand object for an executor.
-/**
- * @param ex An executor.
- *
- * @returns A strand constructed with the specified executor.
- */
-template <typename Executor>
-inline strand<Executor> make_strand(const Executor& ex,
-    constraint_t<
-      is_executor<Executor>::value || execution::is_executor<Executor>::value
-    > = 0)
-{
-  return strand<Executor>(ex);
-}
-
-/// Create a @ref strand object for an execution context.
-/**
- * @param ctx An execution context, from which an executor will be obtained.
- *
- * @returns A strand constructed with the execution context's executor, obtained
- * by performing <tt>ctx.get_executor()</tt>.
- */
-template <typename ExecutionContext>
-inline strand<typename ExecutionContext::executor_type>
-make_strand(ExecutionContext& ctx,
-    constraint_t<
-      is_convertible<ExecutionContext&, execution_context&>::value
-    > = 0)
-{
-  return strand<typename ExecutionContext::executor_type>(ctx.get_executor());
-}
-
-/*@}*/
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Executor>
-struct equality_comparable<strand<Executor>>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Executor, typename Function>
-struct execute_member<strand<Executor>, Function,
-    enable_if_t<
-      traits::execute_member<const Executor&, Function>::is_valid
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct query_member<strand<Executor>, Property,
-    enable_if_t<
-      can_query<const Executor&, Property>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_query<Executor, Property>::value;
-  typedef conditional_t<
-    is_convertible<Property, execution::blocking_t>::value,
-      execution::blocking_t, query_result_t<Executor, Property>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct require_member<strand<Executor>, Property,
-    enable_if_t<
-      can_require<const Executor&, Property>::value
-        && !is_convertible<Property, execution::blocking_t::always_t>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_require<Executor, Property>::value;
-  typedef strand<decay_t<require_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename Executor, typename Property>
-struct prefer_member<strand<Executor>, Property,
-    enable_if_t<
-      can_prefer<const Executor&, Property>::value
-        && !is_convertible<Property, execution::blocking_t::always_t>::value
-    >>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept =
-    is_nothrow_prefer<Executor, Property>::value;
-  typedef strand<decay_t<prefer_result_t<Executor, Property>>> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-// If both io_context.hpp and strand.hpp have been included, automatically
-// include the header file needed for the io_context::strand class.
-#if !defined(ASIO_NO_EXTENSIONS)
-# if defined(ASIO_IO_CONTEXT_HPP)
-#  include "asio/io_context_strand.hpp"
-# endif // defined(ASIO_IO_CONTEXT_HPP)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#endif // ASIO_STRAND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/stream_file.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/stream_file.hpp
deleted file mode 100644
index ef059a9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/stream_file.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// stream_file.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_STREAM_FILE_HPP
-#define ASIO_STREAM_FILE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_FILE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_stream_file.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a stream-oriented file.
-typedef basic_stream_file<> stream_file;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_FILE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_STREAM_FILE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/streambuf.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/streambuf.hpp
deleted file mode 100644
index d774524..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/streambuf.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// streambuf.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_STREAMBUF_HPP
-#define ASIO_STREAMBUF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_NO_IOSTREAM)
-
-#include "asio/basic_streambuf.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of basic_streambuf.
-typedef basic_streambuf<> streambuf;
-
-} // namespace asio
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-#endif // ASIO_STREAMBUF_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_context.hpp
deleted file mode 100644
index 132ce61..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_context.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// system_context.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SYSTEM_CONTEXT_HPP
-#define ASIO_SYSTEM_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/thread_group.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-template <typename Blocking, typename Relationship, typename Allocator>
-class basic_system_executor;
-
-/// The executor context for the system executor.
-class system_context : public execution_context
-{
-public:
-  /// The executor type associated with the context.
-  typedef basic_system_executor<
-      execution::blocking_t::possibly_t,
-      execution::relationship_t::fork_t,
-      std::allocator<void>
-    > executor_type;
-
-  /// Destructor shuts down all threads in the system thread pool.
-  ASIO_DECL ~system_context();
-
-  /// Obtain an executor for the context.
-  executor_type get_executor() noexcept;
-
-  /// Signal all threads in the system thread pool to stop.
-  ASIO_DECL void stop();
-
-  /// Determine whether the system thread pool has been stopped.
-  ASIO_DECL bool stopped() const noexcept;
-
-  /// Join all threads in the system thread pool.
-  ASIO_DECL void join();
-
-#if defined(GENERATING_DOCUMENTATION)
-private:
-#endif // defined(GENERATING_DOCUMENTATION)
-  // Constructor creates all threads in the system thread pool.
-  ASIO_DECL system_context();
-
-private:
-  template <typename, typename, typename> friend class basic_system_executor;
-
-  struct thread_function;
-
-  // Helper function to create the underlying scheduler.
-  ASIO_DECL detail::scheduler& add_scheduler(detail::scheduler* s);
-
-  // The underlying scheduler.
-  detail::scheduler& scheduler_;
-
-  // The threads in the system thread pool.
-  detail::thread_group threads_;
-
-  // The number of threads in the pool.
-  std::size_t num_threads_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/system_context.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/system_context.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_SYSTEM_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_error.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_error.hpp
deleted file mode 100644
index d7f9326..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_error.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// system_error.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SYSTEM_ERROR_HPP
-#define ASIO_SYSTEM_ERROR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <system_error>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-typedef std::system_error system_error;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_SYSTEM_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_executor.hpp
deleted file mode 100644
index 19b6d30..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_executor.hpp
+++ /dev/null
@@ -1,671 +0,0 @@
-//
-// system_executor.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SYSTEM_EXECUTOR_HPP
-#define ASIO_SYSTEM_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/memory.hpp"
-#include "asio/execution.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class system_context;
-
-/// An executor that uses arbitrary threads.
-/**
- * The system executor represents an execution context where functions are
- * permitted to run on arbitrary threads. When the blocking.never property is
- * established, the system executor will schedule the function to run on an
- * unspecified system thread pool. When either blocking.possibly or
- * blocking.always is established, the executor invokes the function
- * immediately.
- */
-template <typename Blocking, typename Relationship, typename Allocator>
-class basic_system_executor
-{
-public:
-  /// Default constructor.
-  basic_system_executor() noexcept
-    : allocator_(Allocator())
-  {
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Obtain an executor with the @c blocking.possibly property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.possibly); @endcode
-   */
-  basic_system_executor<execution::blocking_t::possibly_t,
-      Relationship, Allocator>
-  require(execution::blocking_t::possibly_t) const
-  {
-    return basic_system_executor<execution::blocking_t::possibly_t,
-        Relationship, Allocator>(allocator_);
-  }
-
-  /// Obtain an executor with the @c blocking.always property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.always); @endcode
-   */
-  basic_system_executor<execution::blocking_t::always_t,
-      Relationship, Allocator>
-  require(execution::blocking_t::always_t) const
-  {
-    return basic_system_executor<execution::blocking_t::always_t,
-        Relationship, Allocator>(allocator_);
-  }
-
-  /// Obtain an executor with the @c blocking.never property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.never); @endcode
-   */
-  basic_system_executor<execution::blocking_t::never_t,
-      Relationship, Allocator>
-  require(execution::blocking_t::never_t) const
-  {
-    return basic_system_executor<execution::blocking_t::never_t,
-        Relationship, Allocator>(allocator_);
-  }
-
-  /// Obtain an executor with the @c relationship.continuation property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.continuation); @endcode
-   */
-  basic_system_executor<Blocking,
-      execution::relationship_t::continuation_t, Allocator>
-  require(execution::relationship_t::continuation_t) const
-  {
-    return basic_system_executor<Blocking,
-        execution::relationship_t::continuation_t, Allocator>(allocator_);
-  }
-
-  /// Obtain an executor with the @c relationship.fork property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.fork); @endcode
-   */
-  basic_system_executor<Blocking,
-      execution::relationship_t::fork_t, Allocator>
-  require(execution::relationship_t::fork_t) const
-  {
-    return basic_system_executor<Blocking,
-        execution::relationship_t::fork_t, Allocator>(allocator_);
-  }
-
-  /// Obtain an executor with the specified @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator(my_allocator)); @endcode
-   */
-  template <typename OtherAllocator>
-  basic_system_executor<Blocking, Relationship, OtherAllocator>
-  require(execution::allocator_t<OtherAllocator> a) const
-  {
-    return basic_system_executor<Blocking,
-        Relationship, OtherAllocator>(a.value());
-  }
-
-  /// Obtain an executor with the default @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex1;
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator); @endcode
-   */
-  basic_system_executor<Blocking, Relationship, std::allocator<void>>
-  require(execution::allocator_t<void>) const
-  {
-    return basic_system_executor<Blocking,
-        Relationship, std::allocator<void>>();
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_query_fn::impl;
-  friend struct asio::execution::detail::blocking_t<0>;
-  friend struct asio::execution::detail::mapping_t<0>;
-  friend struct asio::execution::detail::outstanding_work_t<0>;
-  friend struct asio::execution::detail::relationship_t<0>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Query the current value of the @c mapping property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * if (asio::query(ex, asio::execution::mapping)
-   *       == asio::execution::mapping.thread)
-   *   ... @endcode
-   */
-  static constexpr execution::mapping_t query(
-      execution::mapping_t) noexcept
-  {
-    return execution::mapping.thread;
-  }
-
-  /// Query the current value of the @c context property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * asio::system_context& pool = asio::query(
-   *     ex, asio::execution::context); @endcode
-   */
-  static system_context& query(execution::context_t) noexcept;
-
-  /// Query the current value of the @c blocking property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * if (asio::query(ex, asio::execution::blocking)
-   *       == asio::execution::blocking.always)
-   *   ... @endcode
-   */
-  static constexpr execution::blocking_t query(
-      execution::blocking_t) noexcept
-  {
-    return Blocking();
-  }
-
-  /// Query the current value of the @c relationship property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * if (asio::query(ex, asio::execution::relationship)
-   *       == asio::execution::relationship.continuation)
-   *   ... @endcode
-   */
-  static constexpr execution::relationship_t query(
-      execution::relationship_t) noexcept
-  {
-    return Relationship();
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  template <typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t<OtherAllocator>) const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  constexpr Allocator query(
-      execution::allocator_t<void>) const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Query the occupancy (recommended number of work items) for the system
-  /// context.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code asio::system_executor ex;
-   * std::size_t occupancy = asio::query(
-   *     ex, asio::execution::occupancy); @endcode
-   */
-  std::size_t query(execution::occupancy_t) const noexcept;
-
-public:
-  /// Compare two executors for equality.
-  /**
-   * Two executors are equal if they refer to the same underlying io_context.
-   */
-  friend bool operator==(const basic_system_executor&,
-      const basic_system_executor&) noexcept
-  {
-    return true;
-  }
-
-  /// Compare two executors for inequality.
-  /**
-   * Two executors are equal if they refer to the same underlying io_context.
-   */
-  friend bool operator!=(const basic_system_executor&,
-      const basic_system_executor&) noexcept
-  {
-    return false;
-  }
-
-  /// Execution function.
-  template <typename Function>
-  void execute(Function&& f) const
-  {
-    this->do_execute(static_cast<Function&&>(f), Blocking());
-  }
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-public:
-  /// Obtain the underlying execution context.
-  system_context& context() const noexcept;
-
-  /// Inform the executor that it has some outstanding work to do.
-  /**
-   * For the system executor, this is a no-op.
-   */
-  void on_work_started() const noexcept
-  {
-  }
-
-  /// Inform the executor that some work is no longer outstanding.
-  /**
-   * For the system executor, this is a no-op.
-   */
-  void on_work_finished() const noexcept
-  {
-  }
-
-  /// Request the system executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will always be executed inside this function.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void dispatch(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the system executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled to run on an unspecified system thread pool.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void post(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the system executor to invoke the given function object.
-  /**
-   * This function is used to ask the executor to execute the given function
-   * object. The function object will never be executed inside this function.
-   * Instead, it will be scheduled to run on an unspecified system thread pool.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void defer(Function&& f, const OtherAllocator& a) const;
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-private:
-  template <typename, typename, typename> friend class basic_system_executor;
-
-  // Constructor used by require().
-  basic_system_executor(const Allocator& a)
-    : allocator_(a)
-  {
-  }
-
-  /// Execution helper implementation for the possibly blocking property.
-  template <typename Function>
-  void do_execute(Function&& f,
-      execution::blocking_t::possibly_t) const;
-
-  /// Execution helper implementation for the always blocking property.
-  template <typename Function>
-  void do_execute(Function&& f,
-      execution::blocking_t::always_t) const;
-
-  /// Execution helper implementation for the never blocking property.
-  template <typename Function>
-  void do_execute(Function&& f,
-      execution::blocking_t::never_t) const;
-
-  // The allocator used for execution functions.
-  Allocator allocator_;
-};
-
-/// An executor that uses arbitrary threads.
-/**
- * The system executor represents an execution context where functions are
- * permitted to run on arbitrary threads. When the blocking.never property is
- * established, the system executor will schedule the function to run on an
- * unspecified system thread pool. When either blocking.possibly or
- * blocking.always is established, the executor invokes the function
- * immediately.
- */
-typedef basic_system_executor<execution::blocking_t::possibly_t,
-    execution::relationship_t::fork_t, std::allocator<void>>
-  system_executor;
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct equality_comparable<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Blocking, typename Relationship,
-    typename Allocator, typename Function>
-struct execute_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    Function
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::blocking_t::possibly_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<
-      asio::execution::blocking_t::possibly_t,
-      Relationship, Allocator> result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::blocking_t::always_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<
-      asio::execution::blocking_t::always_t,
-      Relationship, Allocator> result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::blocking_t::never_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<
-      asio::execution::blocking_t::never_t,
-      Relationship, Allocator> result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::relationship_t::fork_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<Blocking,
-      asio::execution::relationship_t::fork_t,
-      Allocator> result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::relationship_t::continuation_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<Blocking,
-      asio::execution::relationship_t::continuation_t,
-      Allocator> result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<Blocking,
-      Relationship, std::allocator<void>> result_type;
-};
-
-template <typename Blocking, typename Relationship,
-    typename Allocator, typename OtherAllocator>
-struct require_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::allocator_t<OtherAllocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::basic_system_executor<Blocking,
-      Relationship, OtherAllocator> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Blocking, typename Relationship,
-    typename Allocator, typename Property>
-struct query_static_constexpr_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::mapping_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::mapping_t::thread_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Blocking, typename Relationship,
-    typename Allocator, typename Property>
-struct query_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::blocking_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::blocking_t result_type;
-};
-
-template <typename Blocking, typename Relationship,
-    typename Allocator, typename Property>
-struct query_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::relationship_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::relationship_t result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct query_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::context_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::system_context& result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct query_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-template <typename Blocking, typename Relationship, typename Allocator>
-struct query_member<
-    asio::basic_system_executor<Blocking, Relationship, Allocator>,
-    asio::execution::allocator_t<Allocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/system_executor.hpp"
-
-#endif // ASIO_SYSTEM_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_timer.hpp
deleted file mode 100644
index 7b5e768..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/system_timer.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// system_timer.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_SYSTEM_TIMER_HPP
-#define ASIO_SYSTEM_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/detail/chrono.hpp"
-
-namespace asio {
-
-/// Typedef for a timer based on the system clock.
-/**
- * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
- * available. Otherwise, it may use the Boost.Chrono library. To explicitly
- * utilise Boost.Chrono, use the basic_waitable_timer template directly:
- * @code
- * typedef basic_waitable_timer<boost::chrono::system_clock> timer;
- * @endcode
- */
-typedef basic_waitable_timer<chrono::system_clock> system_timer;
-
-} // namespace asio
-
-#endif // ASIO_SYSTEM_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/this_coro.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/this_coro.hpp
deleted file mode 100644
index 37381b9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/this_coro.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-//
-// this_coro.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_THIS_CORO_HPP
-#define ASIO_THIS_CORO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace this_coro {
-
-/// Awaitable type that returns the executor of the current coroutine.
-struct executor_t
-{
-  constexpr executor_t()
-  {
-  }
-};
-
-/// Awaitable object that returns the executor of the current coroutine.
-constexpr executor_t executor;
-
-/// Awaitable type that returns the cancellation state of the current coroutine.
-struct cancellation_state_t
-{
-  constexpr cancellation_state_t()
-  {
-  }
-};
-
-/// Awaitable object that returns the cancellation state of the current
-/// coroutine.
-/**
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   asio::cancellation_state cs
- *     = co_await asio::this_coro::cancellation_state;
- *
- *   // ...
- *
- *   if (cs.cancelled() != asio::cancellation_type::none)
- *     // ...
- * } @endcode
- */
-constexpr cancellation_state_t cancellation_state;
-
-#if defined(GENERATING_DOCUMENTATION)
-
-/// Returns an awaitable object that may be used to reset the cancellation state
-/// of the current coroutine.
-/**
- * Let <tt>P</tt> be the cancellation slot associated with the current
- * coroutine's @ref co_spawn completion handler. Assigns a new
- * asio::cancellation_state object <tt>S</tt>, constructed as
- * <tt>S(P)</tt>, into the current coroutine's cancellation state object.
- *
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   co_await asio::this_coro::reset_cancellation_state();
- *
- *   // ...
- * } @endcode
- *
- * @note The cancellation state is shared by all coroutines in the same "thread
- * of execution" that was created using asio::co_spawn.
- */
-ASIO_NODISCARD constexpr unspecified
-reset_cancellation_state();
-
-/// Returns an awaitable object that may be used to reset the cancellation state
-/// of the current coroutine.
-/**
- * Let <tt>P</tt> be the cancellation slot associated with the current
- * coroutine's @ref co_spawn completion handler. Assigns a new
- * asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
- * std::forward<Filter>(filter))</tt>, into the current coroutine's
- * cancellation state object.
- *
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   co_await asio::this_coro::reset_cancellation_state(
- *       asio::enable_partial_cancellation());
- *
- *   // ...
- * } @endcode
- *
- * @note The cancellation state is shared by all coroutines in the same "thread
- * of execution" that was created using asio::co_spawn.
- */
-template <typename Filter>
-ASIO_NODISCARD constexpr unspecified
-reset_cancellation_state(Filter&& filter);
-
-/// Returns an awaitable object that may be used to reset the cancellation state
-/// of the current coroutine.
-/**
- * Let <tt>P</tt> be the cancellation slot associated with the current
- * coroutine's @ref co_spawn completion handler. Assigns a new
- * asio::cancellation_state object <tt>S</tt>, constructed as <tt>S(P,
- * std::forward<InFilter>(in_filter),
- * std::forward<OutFilter>(out_filter))</tt>, into the current coroutine's
- * cancellation state object.
- *
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   co_await asio::this_coro::reset_cancellation_state(
- *       asio::enable_partial_cancellation(),
- *       asio::disable_cancellation());
- *
- *   // ...
- * } @endcode
- *
- * @note The cancellation state is shared by all coroutines in the same "thread
- * of execution" that was created using asio::co_spawn.
- */
-template <typename InFilter, typename OutFilter>
-ASIO_NODISCARD constexpr unspecified
-reset_cancellation_state(
-    InFilter&& in_filter,
-    OutFilter&& out_filter);
-
-/// Returns an awaitable object that may be used to determine whether the
-/// coroutine throws if trying to suspend when it has been cancelled.
-/**
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   if (co_await asio::this_coro::throw_if_cancelled)
- *     // ...
- *
- *   // ...
- * } @endcode
- */
-ASIO_NODISCARD constexpr unspecified
-throw_if_cancelled();
-
-/// Returns an awaitable object that may be used to specify whether the
-/// coroutine throws if trying to suspend when it has been cancelled.
-/**
- * @par Example
- * @code asio::awaitable<void> my_coroutine()
- * {
- *   co_await asio::this_coro::throw_if_cancelled(false);
- *
- *   // ...
- * } @endcode
- */
-ASIO_NODISCARD constexpr unspecified
-throw_if_cancelled(bool value);
-
-#else // defined(GENERATING_DOCUMENTATION)
-
-struct reset_cancellation_state_0_t
-{
-  constexpr reset_cancellation_state_0_t()
-  {
-  }
-};
-
-ASIO_NODISCARD inline constexpr reset_cancellation_state_0_t
-reset_cancellation_state()
-{
-  return reset_cancellation_state_0_t();
-}
-
-template <typename Filter>
-struct reset_cancellation_state_1_t
-{
-  template <typename F>
-  explicit constexpr reset_cancellation_state_1_t(
-      F&& filt)
-    : filter(static_cast<F&&>(filt))
-  {
-  }
-
-  Filter filter;
-};
-
-template <typename Filter>
-ASIO_NODISCARD inline constexpr reset_cancellation_state_1_t<
-    decay_t<Filter>>
-reset_cancellation_state(Filter&& filter)
-{
-  return reset_cancellation_state_1_t<decay_t<Filter>>(
-      static_cast<Filter&&>(filter));
-}
-
-template <typename InFilter, typename OutFilter>
-struct reset_cancellation_state_2_t
-{
-  template <typename F1, typename F2>
-  constexpr reset_cancellation_state_2_t(
-      F1&& in_filt, F2&& out_filt)
-    : in_filter(static_cast<F1&&>(in_filt)),
-      out_filter(static_cast<F2&&>(out_filt))
-  {
-  }
-
-  InFilter in_filter;
-  OutFilter out_filter;
-};
-
-template <typename InFilter, typename OutFilter>
-ASIO_NODISCARD inline constexpr
-reset_cancellation_state_2_t<decay_t<InFilter>, decay_t<OutFilter>>
-reset_cancellation_state(InFilter&& in_filter, OutFilter&& out_filter)
-{
-  return reset_cancellation_state_2_t<decay_t<InFilter>, decay_t<OutFilter>>(
-      static_cast<InFilter&&>(in_filter),
-      static_cast<OutFilter&&>(out_filter));
-}
-
-struct throw_if_cancelled_0_t
-{
-  constexpr throw_if_cancelled_0_t()
-  {
-  }
-};
-
-ASIO_NODISCARD inline constexpr throw_if_cancelled_0_t
-throw_if_cancelled()
-{
-  return throw_if_cancelled_0_t();
-}
-
-struct throw_if_cancelled_1_t
-{
-  explicit constexpr throw_if_cancelled_1_t(bool val)
-    : value(val)
-  {
-  }
-
-  bool value;
-};
-
-ASIO_NODISCARD inline constexpr throw_if_cancelled_1_t
-throw_if_cancelled(bool value)
-{
-  return throw_if_cancelled_1_t(value);
-}
-
-#endif // defined(GENERATING_DOCUMENTATION)
-
-} // namespace this_coro
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_THIS_CORO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread.hpp
deleted file mode 100644
index fc57bff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread.hpp
+++ /dev/null
@@ -1,92 +0,0 @@
-//
-// thread.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_THREAD_HPP
-#define ASIO_THREAD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/thread.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A simple abstraction for starting threads.
-/**
- * The asio::thread class implements the smallest possible subset of the
- * functionality of boost::thread. It is intended to be used only for starting
- * a thread and waiting for it to exit. If more extensive threading
- * capabilities are required, you are strongly advised to use something else.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Example
- * A typical use of asio::thread would be to launch a thread to run an
- * io_context's event processing loop:
- *
- * @par
- * @code asio::io_context io_context;
- * // ...
- * asio::thread t(boost::bind(&asio::io_context::run, &io_context));
- * // ...
- * t.join(); @endcode
- */
-class thread
-  : private noncopyable
-{
-public:
-  /// Start a new thread that executes the supplied function.
-  /**
-   * This constructor creates a new thread that will execute the given function
-   * or function object.
-   *
-   * @param f The function or function object to be run in the thread. The
-   * function signature must be: @code void f(); @endcode
-   */
-  template <typename Function>
-  explicit thread(Function f)
-    : impl_(f)
-  {
-  }
-
-  /// Destructor.
-  ~thread()
-  {
-  }
-
-  /// Wait for the thread to exit.
-  /**
-   * This function will block until the thread has exited.
-   *
-   * If this function is not called before the thread object is destroyed, the
-   * thread itself will continue to run until completion. You will, however,
-   * no longer have the ability to wait for it to exit.
-   */
-  void join()
-  {
-    impl_.join();
-  }
-
-private:
-  detail::thread impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread_pool.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread_pool.hpp
deleted file mode 100644
index f9095d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/thread_pool.hpp
+++ /dev/null
@@ -1,963 +0,0 @@
-//
-// thread_pool.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_THREAD_POOL_HPP
-#define ASIO_THREAD_POOL_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/atomic_count.hpp"
-#include "asio/detail/scheduler.hpp"
-#include "asio/detail/thread_group.hpp"
-#include "asio/execution.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-  struct thread_pool_bits
-  {
-    static constexpr unsigned int blocking_never = 1;
-    static constexpr unsigned int blocking_always = 2;
-    static constexpr unsigned int blocking_mask = 3;
-    static constexpr unsigned int relationship_continuation = 4;
-    static constexpr unsigned int outstanding_work_tracked = 8;
-  };
-} // namespace detail
-
-/// A simple fixed-size thread pool.
-/**
- * The thread pool class is an execution context where functions are permitted
- * to run on one of a fixed number of threads.
- *
- * @par Submitting tasks to the pool
- *
- * To submit functions to the thread pool, use the @ref asio::dispatch,
- * @ref asio::post or @ref asio::defer free functions.
- *
- * For example:
- *
- * @code void my_task()
- * {
- *   ...
- * }
- *
- * ...
- *
- * // Launch the pool with four threads.
- * asio::thread_pool pool(4);
- *
- * // Submit a function to the pool.
- * asio::post(pool, my_task);
- *
- * // Submit a lambda object to the pool.
- * asio::post(pool,
- *     []()
- *     {
- *       ...
- *     });
- *
- * // Wait for all tasks in the pool to complete.
- * pool.join(); @endcode
- */
-class thread_pool
-  : public execution_context
-{
-public:
-  template <typename Allocator, unsigned int Bits>
-  class basic_executor_type;
-
-  template <typename Allocator, unsigned int Bits>
-  friend class basic_executor_type;
-
-  /// Executor used to submit functions to a thread pool.
-  typedef basic_executor_type<std::allocator<void>, 0> executor_type;
-
-#if !defined(ASIO_NO_TS_EXECUTORS)
-  /// Constructs a pool with an automatically determined number of threads.
-  ASIO_DECL thread_pool();
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-  /// Constructs a pool with a specified number of threads.
-  ASIO_DECL thread_pool(std::size_t num_threads);
-
-  /// Destructor.
-  /**
-   * Automatically stops and joins the pool, if not explicitly done beforehand.
-   */
-  ASIO_DECL ~thread_pool();
-
-  /// Obtains the executor associated with the pool.
-  executor_type get_executor() noexcept;
-
-  /// Obtains the executor associated with the pool.
-  executor_type executor() noexcept;
-
-  /// Stops the threads.
-  /**
-   * This function stops the threads as soon as possible. As a result of calling
-   * @c stop(), pending function objects may be never be invoked.
-   */
-  ASIO_DECL void stop();
-
-  /// Attaches the current thread to the pool.
-  /**
-   * This function attaches the current thread to the pool so that it may be
-   * used for executing submitted function objects. Blocks the calling thread
-   * until the pool is stopped or joined and has no outstanding work.
-   */
-  ASIO_DECL void attach();
-
-  /// Joins the threads.
-  /**
-   * This function blocks until the threads in the pool have completed. If @c
-   * stop() is not called prior to @c join(), the @c join() call will wait
-   * until the pool has no more outstanding work.
-   */
-  ASIO_DECL void join();
-
-  /// Waits for threads to complete.
-  /**
-   * This function blocks until the threads in the pool have completed. If @c
-   * stop() is not called prior to @c wait(), the @c wait() call will wait
-   * until the pool has no more outstanding work.
-   */
-  ASIO_DECL void wait();
-
-private:
-  thread_pool(const thread_pool&) = delete;
-  thread_pool& operator=(const thread_pool&) = delete;
-
-  struct thread_function;
-
-  // Helper function to create the underlying scheduler.
-  ASIO_DECL detail::scheduler& add_scheduler(detail::scheduler* s);
-
-  // The underlying scheduler.
-  detail::scheduler& scheduler_;
-
-  // The threads in the pool.
-  detail::thread_group threads_;
-
-  // The current number of threads in the pool.
-  detail::atomic_count num_threads_;
-};
-
-/// Executor implementation type used to submit functions to a thread pool.
-template <typename Allocator, unsigned int Bits>
-class thread_pool::basic_executor_type : detail::thread_pool_bits
-{
-public:
-  /// Copy constructor.
-  basic_executor_type(const basic_executor_type& other) noexcept
-    : pool_(other.pool_),
-      allocator_(other.allocator_),
-      bits_(other.bits_)
-  {
-    if (Bits & outstanding_work_tracked)
-      if (pool_)
-        pool_->scheduler_.work_started();
-  }
-
-  /// Move constructor.
-  basic_executor_type(basic_executor_type&& other) noexcept
-    : pool_(other.pool_),
-      allocator_(static_cast<Allocator&&>(other.allocator_)),
-      bits_(other.bits_)
-  {
-    if (Bits & outstanding_work_tracked)
-      other.pool_ = 0;
-  }
-
-  /// Destructor.
-  ~basic_executor_type() noexcept
-  {
-    if (Bits & outstanding_work_tracked)
-      if (pool_)
-        pool_->scheduler_.work_finished();
-  }
-
-  /// Assignment operator.
-  basic_executor_type& operator=(const basic_executor_type& other) noexcept;
-
-  /// Move assignment operator.
-  basic_executor_type& operator=(basic_executor_type&& other) noexcept;
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_require_fn::impl;
-  friend struct asio_prefer_fn::impl;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Obtain an executor with the @c blocking.possibly property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.possibly); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits & ~blocking_mask)>
-  require(execution::blocking_t::possibly_t) const
-  {
-    return basic_executor_type<Allocator, Bits & ~blocking_mask>(
-        pool_, allocator_, bits_ & ~blocking_mask);
-  }
-
-  /// Obtain an executor with the @c blocking.always property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.always); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED((Bits & ~blocking_mask) | blocking_always)>
-  require(execution::blocking_t::always_t) const
-  {
-    return basic_executor_type<Allocator,
-        ASIO_UNSPECIFIED((Bits & ~blocking_mask) | blocking_always)>(
-          pool_, allocator_, bits_ & ~blocking_mask);
-  }
-
-  /// Obtain an executor with the @c blocking.never property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::blocking.never); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits & ~blocking_mask)>
-  require(execution::blocking_t::never_t) const
-  {
-    return basic_executor_type<Allocator, Bits & ~blocking_mask>(
-        pool_, allocator_, (bits_ & ~blocking_mask) | blocking_never);
-  }
-
-  /// Obtain an executor with the @c relationship.fork property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.fork); @endcode
-   */
-  constexpr basic_executor_type require(execution::relationship_t::fork_t) const
-  {
-    return basic_executor_type(pool_,
-        allocator_, bits_ & ~relationship_continuation);
-  }
-
-  /// Obtain an executor with the @c relationship.continuation property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::relationship.continuation); @endcode
-   */
-  constexpr basic_executor_type require(
-      execution::relationship_t::continuation_t) const
-  {
-    return basic_executor_type(pool_,
-        allocator_, bits_ | relationship_continuation);
-  }
-
-  /// Obtain an executor with the @c outstanding_work.tracked property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::outstanding_work.tracked); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits | outstanding_work_tracked)>
-  require(execution::outstanding_work_t::tracked_t) const
-  {
-    return basic_executor_type<Allocator, Bits | outstanding_work_tracked>(
-        pool_, allocator_, bits_);
-  }
-
-  /// Obtain an executor with the @c outstanding_work.untracked property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::outstanding_work.untracked); @endcode
-   */
-  constexpr basic_executor_type<Allocator,
-      ASIO_UNSPECIFIED(Bits & ~outstanding_work_tracked)>
-  require(execution::outstanding_work_t::untracked_t) const
-  {
-    return basic_executor_type<Allocator, Bits & ~outstanding_work_tracked>(
-        pool_, allocator_, bits_);
-  }
-
-  /// Obtain an executor with the specified @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator(my_allocator)); @endcode
-   */
-  template <typename OtherAllocator>
-  constexpr basic_executor_type<OtherAllocator, Bits>
-  require(execution::allocator_t<OtherAllocator> a) const
-  {
-    return basic_executor_type<OtherAllocator, Bits>(
-        pool_, a.value(), bits_);
-  }
-
-  /// Obtain an executor with the default @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::require customisation point.
-   *
-   * For example:
-   * @code auto ex1 = my_thread_pool.executor();
-   * auto ex2 = asio::require(ex1,
-   *     asio::execution::allocator); @endcode
-   */
-  constexpr basic_executor_type<std::allocator<void>, Bits>
-  require(execution::allocator_t<void>) const
-  {
-    return basic_executor_type<std::allocator<void>, Bits>(
-        pool_, std::allocator<void>(), bits_);
-  }
-
-#if !defined(GENERATING_DOCUMENTATION)
-private:
-  friend struct asio_query_fn::impl;
-  friend struct asio::execution::detail::mapping_t<0>;
-  friend struct asio::execution::detail::outstanding_work_t<0>;
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-  /// Query the current value of the @c mapping property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * if (asio::query(ex, asio::execution::mapping)
-   *       == asio::execution::mapping.thread)
-   *   ... @endcode
-   */
-  static constexpr execution::mapping_t query(execution::mapping_t) noexcept
-  {
-    return execution::mapping.thread;
-  }
-
-  /// Query the current value of the @c context property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * asio::thread_pool& pool = asio::query(
-   *     ex, asio::execution::context); @endcode
-   */
-  thread_pool& query(execution::context_t) const noexcept
-  {
-    return *pool_;
-  }
-
-  /// Query the current value of the @c blocking property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * if (asio::query(ex, asio::execution::blocking)
-   *       == asio::execution::blocking.always)
-   *   ... @endcode
-   */
-  constexpr execution::blocking_t query(execution::blocking_t) const noexcept
-  {
-    return (bits_ & blocking_never)
-      ? execution::blocking_t(execution::blocking.never)
-      : ((Bits & blocking_always)
-          ? execution::blocking_t(execution::blocking.always)
-          : execution::blocking_t(execution::blocking.possibly));
-  }
-
-  /// Query the current value of the @c relationship property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * if (asio::query(ex, asio::execution::relationship)
-   *       == asio::execution::relationship.continuation)
-   *   ... @endcode
-   */
-  constexpr execution::relationship_t query(
-      execution::relationship_t) const noexcept
-  {
-    return (bits_ & relationship_continuation)
-      ? execution::relationship_t(execution::relationship.continuation)
-      : execution::relationship_t(execution::relationship.fork);
-  }
-
-  /// Query the current value of the @c outstanding_work property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * if (asio::query(ex, asio::execution::outstanding_work)
-   *       == asio::execution::outstanding_work.tracked)
-   *   ... @endcode
-   */
-  static constexpr execution::outstanding_work_t query(
-      execution::outstanding_work_t) noexcept
-  {
-    return (Bits & outstanding_work_tracked)
-      ? execution::outstanding_work_t(execution::outstanding_work.tracked)
-      : execution::outstanding_work_t(execution::outstanding_work.untracked);
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  template <typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t<OtherAllocator>) const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Query the current value of the @c allocator property.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * auto alloc = asio::query(ex,
-   *     asio::execution::allocator); @endcode
-   */
-  constexpr Allocator query(execution::allocator_t<void>) const noexcept
-  {
-    return allocator_;
-  }
-
-  /// Query the occupancy (recommended number of work items) for the pool.
-  /**
-   * Do not call this function directly. It is intended for use with the
-   * asio::query customisation point.
-   *
-   * For example:
-   * @code auto ex = my_thread_pool.executor();
-   * std::size_t occupancy = asio::query(
-   *     ex, asio::execution::occupancy); @endcode
-   */
-  std::size_t query(execution::occupancy_t) const noexcept
-  {
-    return static_cast<std::size_t>(pool_->num_threads_);
-  }
-
-public:
-  /// Determine whether the thread pool is running in the current thread.
-  /**
-   * @return @c true if the current thread is running the thread pool. Otherwise
-   * returns @c false.
-   */
-  bool running_in_this_thread() const noexcept;
-
-  /// Compare two executors for equality.
-  /**
-   * Two executors are equal if they refer to the same underlying thread pool.
-   */
-  friend bool operator==(const basic_executor_type& a,
-      const basic_executor_type& b) noexcept
-  {
-    return a.pool_ == b.pool_
-      && a.allocator_ == b.allocator_
-      && a.bits_ == b.bits_;
-  }
-
-  /// Compare two executors for inequality.
-  /**
-   * Two executors are equal if they refer to the same underlying thread pool.
-   */
-  friend bool operator!=(const basic_executor_type& a,
-      const basic_executor_type& b) noexcept
-  {
-    return a.pool_ != b.pool_
-      || a.allocator_ != b.allocator_
-      || a.bits_ != b.bits_;
-  }
-
-  /// Execution function.
-  template <typename Function>
-  void execute(Function&& f) const
-  {
-    this->do_execute(static_cast<Function&&>(f),
-        integral_constant<bool, (Bits & blocking_always) != 0>());
-  }
-
-public:
-#if !defined(ASIO_NO_TS_EXECUTORS)
-  /// Obtain the underlying execution context.
-  thread_pool& context() const noexcept;
-
-  /// Inform the thread pool that it has some outstanding work to do.
-  /**
-   * This function is used to inform the thread pool that some work has begun.
-   * This ensures that the thread pool's join() function will not return while
-   * the work is underway.
-   */
-  void on_work_started() const noexcept;
-
-  /// Inform the thread pool that some work is no longer outstanding.
-  /**
-   * This function is used to inform the thread pool that some work has
-   * finished. Once the count of unfinished work reaches zero, the thread
-   * pool's join() function is permitted to exit.
-   */
-  void on_work_finished() const noexcept;
-
-  /// Request the thread pool to invoke the given function object.
-  /**
-   * This function is used to ask the thread pool to execute the given function
-   * object. If the current thread belongs to the pool, @c dispatch() executes
-   * the function before returning. Otherwise, the function will be scheduled
-   * to run on the thread pool.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void dispatch(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the thread pool to invoke the given function object.
-  /**
-   * This function is used to ask the thread pool to execute the given function
-   * object. The function object will never be executed inside @c post().
-   * Instead, it will be scheduled to run on the thread pool.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void post(Function&& f, const OtherAllocator& a) const;
-
-  /// Request the thread pool to invoke the given function object.
-  /**
-   * This function is used to ask the thread pool to execute the given function
-   * object. The function object will never be executed inside @c defer().
-   * Instead, it will be scheduled to run on the thread pool.
-   *
-   * If the current thread belongs to the thread pool, @c defer() will delay
-   * scheduling the function object until the current thread returns control to
-   * the pool.
-   *
-   * @param f The function object to be called. The executor will make
-   * a copy of the handler object as required. The function signature of the
-   * function object must be: @code void function(); @endcode
-   *
-   * @param a An allocator that may be used by the executor to allocate the
-   * internal storage needed for function invocation.
-   */
-  template <typename Function, typename OtherAllocator>
-  void defer(Function&& f, const OtherAllocator& a) const;
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-private:
-  friend class thread_pool;
-  template <typename, unsigned int> friend class basic_executor_type;
-
-  // Constructor used by thread_pool::get_executor().
-  explicit basic_executor_type(thread_pool& p) noexcept
-    : pool_(&p),
-      allocator_(),
-      bits_(0)
-  {
-    if (Bits & outstanding_work_tracked)
-      pool_->scheduler_.work_started();
-  }
-
-  // Constructor used by require().
-  basic_executor_type(thread_pool* p,
-      const Allocator& a, unsigned int bits) noexcept
-    : pool_(p),
-      allocator_(a),
-      bits_(bits)
-  {
-    if (Bits & outstanding_work_tracked)
-      if (pool_)
-        pool_->scheduler_.work_started();
-  }
-
-  /// Execution helper implementation for possibly and never blocking.
-  template <typename Function>
-  void do_execute(Function&& f, false_type) const;
-
-  /// Execution helper implementation for always blocking.
-  template <typename Function>
-  void do_execute(Function&& f, true_type) const;
-
-  // The underlying thread pool.
-  thread_pool* pool_;
-
-  // The allocator used for execution functions.
-  Allocator allocator_;
-
-  // The runtime-switched properties of the thread pool executor.
-  unsigned int bits_;
-};
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename Allocator, unsigned int Bits>
-struct equality_comparable<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Allocator, unsigned int Bits, typename Function>
-struct execute_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    Function
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::blocking_t::possibly_t
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits & ~blocking_mask> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::blocking_t::always_t
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<Allocator,
-      (Bits & ~blocking_mask) | blocking_always> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::blocking_t::never_t
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits & ~blocking_mask> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::relationship_t::fork_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::relationship_t::continuation_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::outstanding_work_t::tracked_t
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits | outstanding_work_tracked> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::outstanding_work_t::untracked_t
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      Allocator, Bits & ~outstanding_work_tracked> result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      std::allocator<void>, Bits> result_type;
-};
-
-template <unsigned int Bits,
-    typename Allocator, typename OtherAllocator>
-struct require_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<OtherAllocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef asio::thread_pool::basic_executor_type<
-      OtherAllocator, Bits> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Allocator, unsigned int Bits, typename Property>
-struct query_static_constexpr_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::outstanding_work_t
-      >::value
-    >::type
-  > : asio::detail::thread_pool_bits
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::outstanding_work_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return (Bits & outstanding_work_tracked)
-      ? execution::outstanding_work_t(execution::outstanding_work.tracked)
-      : execution::outstanding_work_t(execution::outstanding_work.untracked);
-  }
-};
-
-template <typename Allocator, unsigned int Bits, typename Property>
-struct query_static_constexpr_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::mapping_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::mapping_t::thread_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Allocator, unsigned int Bits, typename Property>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::blocking_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::blocking_t result_type;
-};
-
-template <typename Allocator, unsigned int Bits, typename Property>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::relationship_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::relationship_t result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::occupancy_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef std::size_t result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::context_t
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::thread_pool& result_type;
-};
-
-template <typename Allocator, unsigned int Bits>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<void>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-template <typename Allocator, unsigned int Bits, typename OtherAllocator>
-struct query_member<
-    asio::thread_pool::basic_executor_type<Allocator, Bits>,
-    asio::execution::allocator_t<OtherAllocator>
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef Allocator result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-
-namespace execution {
-
-template <>
-struct is_executor<thread_pool> : false_type
-{
-};
-
-} // namespace execution
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/thread_pool.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/impl/thread_pool.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_THREAD_POOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/time_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/time_traits.hpp
deleted file mode 100644
index f398023..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/time_traits.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// time_traits.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TIME_TRAITS_HPP
-#define ASIO_TIME_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/socket_types.hpp" // Must come before posix_time.
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Time traits suitable for use with the deadline timer.
-template <typename Time>
-struct time_traits;
-
-/// Time traits specialised for posix_time.
-template <>
-struct time_traits<boost::posix_time::ptime>
-{
-  /// The time type.
-  typedef boost::posix_time::ptime time_type;
-
-  /// The duration type.
-  typedef boost::posix_time::time_duration duration_type;
-
-  /// Get the current time.
-  static time_type now()
-  {
-#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-    return boost::posix_time::microsec_clock::universal_time();
-#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-    return boost::posix_time::second_clock::universal_time();
-#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-  }
-
-  /// Add a duration to a time.
-  static time_type add(const time_type& t, const duration_type& d)
-  {
-    return t + d;
-  }
-
-  /// Subtract one time from another.
-  static duration_type subtract(const time_type& t1, const time_type& t2)
-  {
-    return t1 - t2;
-  }
-
-  /// Test whether one time is less than another.
-  static bool less_than(const time_type& t1, const time_type& t2)
-  {
-    return t1 < t2;
-  }
-
-  /// Convert to POSIX duration type.
-  static boost::posix_time::time_duration to_posix_duration(
-      const duration_type& d)
-  {
-    return d;
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-       // || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_TIME_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/equality_comparable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/equality_comparable.hpp
deleted file mode 100644
index 0a6decf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/equality_comparable.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// traits/equality_comparable.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
-#define ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename = void>
-struct equality_comparable_default;
-
-template <typename T, typename = void>
-struct equality_comparable;
-
-} // namespace traits
-namespace detail {
-
-struct no_equality_comparable
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename T, typename = void>
-struct equality_comparable_trait : no_equality_comparable
-{
-};
-
-template <typename T>
-struct equality_comparable_trait<T,
-  void_t<
-    decltype(
-      static_cast<void>(
-        static_cast<bool>(declval<const T>() == declval<const T>())
-      ),
-      static_cast<void>(
-        static_cast<bool>(declval<const T>() != declval<const T>())
-      )
-    )
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<const T>() == declval<const T>())
-      && noexcept(declval<const T>() != declval<const T>());
-};
-
-#else // defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename T, typename = void>
-struct equality_comparable_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value,
-    no_equality_comparable,
-    traits::equality_comparable<decay_t<T>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename>
-struct equality_comparable_default : detail::equality_comparable_trait<T>
-{
-};
-
-template <typename T, typename>
-struct equality_comparable : equality_comparable_default<T>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#endif // ASIO_TRAITS_EQUALITY_COMPARABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/execute_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/execute_member.hpp
deleted file mode 100644
index fc0760b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/execute_member.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/execute_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_EXECUTE_MEMBER_HPP
-#define ASIO_TRAITS_EXECUTE_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename F, typename = void>
-struct execute_member_default;
-
-template <typename T, typename F, typename = void>
-struct execute_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_execute_member
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename T, typename F, typename = void>
-struct execute_member_trait : no_execute_member
-{
-};
-
-template <typename T, typename F>
-struct execute_member_trait<T, F,
-  void_t<
-    decltype(declval<T>().execute(declval<F>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    declval<T>().execute(declval<F>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<T>().execute(declval<F>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename T, typename F, typename = void>
-struct execute_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<F, decay_t<F>>::value,
-    no_execute_member,
-    traits::execute_member<
-      decay_t<T>,
-      decay_t<F>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename F, typename>
-struct execute_member_default :
-  detail::execute_member_trait<T, F>
-{
-};
-
-template <typename T, typename F, typename>
-struct execute_member :
-  execute_member_default<T, F>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_EXECUTE_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_free.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_free.hpp
deleted file mode 100644
index c6104d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_free.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/prefer_free.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_PREFER_FREE_HPP
-#define ASIO_TRAITS_PREFER_FREE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct prefer_free_default;
-
-template <typename T, typename Property, typename = void>
-struct prefer_free;
-
-} // namespace traits
-namespace detail {
-
-struct no_prefer_free
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct prefer_free_trait : no_prefer_free
-{
-};
-
-template <typename T, typename Property>
-struct prefer_free_trait<T, Property,
-  void_t<
-    decltype(prefer(declval<T>(), declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    prefer(declval<T>(), declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(prefer(declval<T>(), declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct prefer_free_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_prefer_free,
-    traits::prefer_free<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct prefer_free_default :
-  detail::prefer_free_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct prefer_free :
-  prefer_free_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_PREFER_FREE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_member.hpp
deleted file mode 100644
index 278c25c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/prefer_member.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/prefer_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_PREFER_MEMBER_HPP
-#define ASIO_TRAITS_PREFER_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct prefer_member_default;
-
-template <typename T, typename Property, typename = void>
-struct prefer_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_prefer_member
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct prefer_member_trait : no_prefer_member
-{
-};
-
-template <typename T, typename Property>
-struct prefer_member_trait<T, Property,
-  void_t<
-    decltype(declval<T>().prefer(declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    declval<T>().prefer(declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<T>().prefer(declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct prefer_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_prefer_member,
-    traits::prefer_member<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct prefer_member_default :
-  detail::prefer_member_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct prefer_member :
-  prefer_member_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_PREFER_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_free.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_free.hpp
deleted file mode 100644
index a54016a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_free.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/query_free.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_QUERY_FREE_HPP
-#define ASIO_TRAITS_QUERY_FREE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct query_free_default;
-
-template <typename T, typename Property, typename = void>
-struct query_free;
-
-} // namespace traits
-namespace detail {
-
-struct no_query_free
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct query_free_trait : no_query_free
-{
-};
-
-template <typename T, typename Property>
-struct query_free_trait<T, Property,
-  void_t<
-    decltype(query(declval<T>(), declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    query(declval<T>(), declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(query(declval<T>(), declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct query_free_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_query_free,
-    traits::query_free<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct query_free_default :
-  detail::query_free_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct query_free :
-  query_free_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_QUERY_FREE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_member.hpp
deleted file mode 100644
index 2202c9d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_member.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/query_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_QUERY_MEMBER_HPP
-#define ASIO_TRAITS_QUERY_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct query_member_default;
-
-template <typename T, typename Property, typename = void>
-struct query_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_query_member
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct query_member_trait : no_query_member
-{
-};
-
-template <typename T, typename Property>
-struct query_member_trait<T, Property,
-  void_t<
-    decltype(declval<T>().query(declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    declval<T>().query(declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<T>().query(declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct query_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_query_member,
-    traits::query_member<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct query_member_default :
-  detail::query_member_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct query_member :
-  query_member_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_QUERY_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_static_constexpr_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_static_constexpr_member.hpp
deleted file mode 100644
index 95bdb7d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/query_static_constexpr_member.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// traits/query_static_constexpr_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
-#define ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE) \
-  && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_CONSTANT_EXPRESSION_SFINAE)
-       //   && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct query_static_constexpr_member_default;
-
-template <typename T, typename Property, typename = void>
-struct query_static_constexpr_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_query_static_constexpr_member
-{
-  static constexpr bool is_valid = false;
-};
-
-template <typename T, typename Property, typename = void>
-struct query_static_constexpr_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_query_static_constexpr_member,
-    traits::query_static_constexpr_member<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#if defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename T, typename Property>
-struct query_static_constexpr_member_trait<T, Property,
-  enable_if_t<
-    (static_cast<void>(T::query(Property{})), true)
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(T::query(Property{}));
-
-  static constexpr bool is_noexcept = noexcept(T::query(Property{}));
-
-  static constexpr result_type value() noexcept(is_noexcept)
-  {
-    return T::query(Property{});
-  }
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct query_static_constexpr_member_default :
-  detail::query_static_constexpr_member_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct query_static_constexpr_member :
-  query_static_constexpr_member_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_QUERY_STATIC_CONSTEXPR_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_free.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_free.hpp
deleted file mode 100644
index 1ae2ad7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_free.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/require_concept_free.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
-#define ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct require_concept_free_default;
-
-template <typename T, typename Property, typename = void>
-struct require_concept_free;
-
-} // namespace traits
-namespace detail {
-
-struct no_require_concept_free
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_concept_free_trait : no_require_concept_free
-{
-};
-
-template <typename T, typename Property>
-struct require_concept_free_trait<T, Property,
-  void_t<
-    decltype(require_concept(declval<T>(), declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    require_concept(declval<T>(), declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(require_concept(declval<T>(), declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_concept_free_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_require_concept_free,
-    traits::require_concept_free<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_FREE_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct require_concept_free_default :
-  detail::require_concept_free_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct require_concept_free :
-  require_concept_free_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_REQUIRE_CONCEPT_FREE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_member.hpp
deleted file mode 100644
index f6b6535..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_concept_member.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/require_concept_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
-#define ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct require_concept_member_default;
-
-template <typename T, typename Property, typename = void>
-struct require_concept_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_require_concept_member
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_concept_member_trait : no_require_concept_member
-{
-};
-
-template <typename T, typename Property>
-struct require_concept_member_trait<T, Property,
-  void_t<
-    decltype(declval<T>().require_concept(declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    declval<T>().require_concept(declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<T>().require_concept(declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_concept_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_require_concept_member,
-    traits::require_concept_member<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_CONCEPT_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct require_concept_member_default :
-  detail::require_concept_member_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct require_concept_member :
-  require_concept_member_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_REQUIRE_CONCEPT_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_free.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_free.hpp
deleted file mode 100644
index 02b5586..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_free.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/require_free.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_REQUIRE_FREE_HPP
-#define ASIO_TRAITS_REQUIRE_FREE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct require_free_default;
-
-template <typename T, typename Property, typename = void>
-struct require_free;
-
-} // namespace traits
-namespace detail {
-
-struct no_require_free
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_free_trait : no_require_free
-{
-};
-
-template <typename T, typename Property>
-struct require_free_trait<T, Property,
-  void_t<
-    decltype(require(declval<T>(), declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    require(declval<T>(), declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(require(declval<T>(), declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_free_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_require_free,
-    traits::require_free<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct require_free_default :
-  detail::require_free_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct require_free :
-  require_free_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_REQUIRE_FREE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_member.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_member.hpp
deleted file mode 100644
index af733e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/require_member.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// traits/require_member.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_REQUIRE_MEMBER_HPP
-#define ASIO_TRAITS_REQUIRE_MEMBER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT 1
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct require_member_default;
-
-template <typename T, typename Property, typename = void>
-struct require_member;
-
-} // namespace traits
-namespace detail {
-
-struct no_require_member
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-#if defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_member_trait : no_require_member
-{
-};
-
-template <typename T, typename Property>
-struct require_member_trait<T, Property,
-  void_t<
-    decltype(declval<T>().require(declval<Property>()))
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-    declval<T>().require(declval<Property>()));
-
-  static constexpr bool is_noexcept =
-    noexcept(declval<T>().require(declval<Property>()));
-};
-
-#else // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename T, typename Property, typename = void>
-struct require_member_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_require_member,
-    traits::require_member<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct require_member_default :
-  detail::require_member_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct require_member :
-  require_member_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_REQUIRE_MEMBER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_query.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_query.hpp
deleted file mode 100644
index b177a9d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_query.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//
-// traits/static_query.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_STATIC_QUERY_HPP
-#define ASIO_TRAITS_STATIC_QUERY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#if defined(ASIO_HAS_VARIABLE_TEMPLATES) \
-  && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-# define ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT 1
-#endif // defined(ASIO_HAS_VARIABLE_TEMPLATES)
-       //   && defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct static_query_default;
-
-template <typename T, typename Property, typename = void>
-struct static_query;
-
-} // namespace traits
-namespace detail {
-
-struct no_static_query
-{
-  static constexpr bool is_valid = false;
-  static constexpr bool is_noexcept = false;
-};
-
-template <typename T, typename Property, typename = void>
-struct static_query_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_static_query,
-    traits::static_query<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#if defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-
-template <typename T, typename Property>
-struct static_query_trait<T, Property,
-  void_t<
-    decltype(decay_t<Property>::template static_query_v<T>)
-  >>
-{
-  static constexpr bool is_valid = true;
-
-  using result_type = decltype(
-      decay_t<Property>::template static_query_v<T>);
-
-  static constexpr bool is_noexcept =
-    noexcept(decay_t<Property>::template static_query_v<T>);
-
-  static constexpr result_type value() noexcept(is_noexcept)
-  {
-    return decay_t<Property>::template static_query_v<T>;
-  }
-};
-
-#endif // defined(ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct static_query_default : detail::static_query_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct static_query : static_query_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_STATIC_QUERY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require.hpp
deleted file mode 100644
index 4ef4a61..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//
-// traits/static_require.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_STATIC_REQUIRE_HPP
-#define ASIO_TRAITS_STATIC_REQUIRE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/traits/static_query.hpp"
-
-#define ASIO_HAS_DEDUCED_STATIC_REQUIRE_TRAIT 1
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct static_require_default;
-
-template <typename T, typename Property, typename = void>
-struct static_require;
-
-} // namespace traits
-namespace detail {
-
-struct no_static_require
-{
-  static constexpr bool is_valid = false;
-};
-
-template <typename T, typename Property, typename = void>
-struct static_require_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_static_require,
-    traits::static_require<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-template <typename T, typename Property>
-struct static_require_trait<T, Property,
-  enable_if_t<
-    decay_t<Property>::value() == traits::static_query<T, Property>::value()
-  >>
-{
-  static constexpr bool is_valid = true;
-};
-
-#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-false_type static_require_test(...);
-
-template <typename T, typename Property>
-true_type static_require_test(T*, Property*,
-    enable_if_t<
-      Property::value() == traits::static_query<T, Property>::value()
-    >* = 0);
-
-template <typename T, typename Property>
-struct has_static_require
-{
-  static constexpr bool value =
-    decltype((static_require_test)(
-      static_cast<T*>(0), static_cast<Property*>(0)))::value;
-};
-
-template <typename T, typename Property>
-struct static_require_trait<T, Property,
-  enable_if_t<
-    has_static_require<decay_t<T>,
-      decay_t<Property>>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-};
-
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct static_require_default : detail::static_require_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct static_require : static_require_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_STATIC_REQUIRE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require_concept.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require_concept.hpp
deleted file mode 100644
index 6861f46..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/traits/static_require_concept.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// traits/static_require_concept.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
-#define ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/traits/static_query.hpp"
-
-#define ASIO_HAS_DEDUCED_STATIC_REQUIRE_CONCEPT_TRAIT 1
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace traits {
-
-template <typename T, typename Property, typename = void>
-struct static_require_concept_default;
-
-template <typename T, typename Property, typename = void>
-struct static_require_concept;
-
-} // namespace traits
-namespace detail {
-
-struct no_static_require_concept
-{
-  static constexpr bool is_valid = false;
-};
-
-template <typename T, typename Property, typename = void>
-struct static_require_concept_trait :
-  conditional_t<
-    is_same<T, decay_t<T>>::value
-      && is_same<Property, decay_t<Property>>::value,
-    no_static_require_concept,
-    traits::static_require_concept<
-      decay_t<T>,
-      decay_t<Property>>
-  >
-{
-};
-
-#if defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-template <typename T, typename Property>
-struct static_require_concept_trait<T, Property,
-  enable_if_t<
-    decay_t<Property>::value() == traits::static_query<T, Property>::value()
-  >>
-{
-  static constexpr bool is_valid = true;
-};
-
-#else // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-false_type static_require_concept_test(...);
-
-template <typename T, typename Property>
-true_type static_require_concept_test(T*, Property*,
-    enable_if_t<
-      Property::value() == traits::static_query<T, Property>::value()
-    >* = 0);
-
-template <typename T, typename Property>
-struct has_static_require_concept
-{
-  static constexpr bool value =
-    decltype((static_require_concept_test)(
-      static_cast<T*>(0), static_cast<Property*>(0)))::value;
-};
-
-template <typename T, typename Property>
-struct static_require_concept_trait<T, Property,
-  enable_if_t<
-    has_static_require_concept<decay_t<T>,
-      decay_t<Property>>::value
-  >>
-{
-  static constexpr bool is_valid = true;
-};
-
-#endif // defined(ASIO_HAS_WORKING_EXPRESSION_SFINAE)
-
-} // namespace detail
-namespace traits {
-
-template <typename T, typename Property, typename>
-struct static_require_concept_default :
-  detail::static_require_concept_trait<T, Property>
-{
-};
-
-template <typename T, typename Property, typename>
-struct static_require_concept : static_require_concept_default<T, Property>
-{
-};
-
-} // namespace traits
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_TRAITS_STATIC_REQUIRE_CONCEPT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/buffer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/buffer.hpp
deleted file mode 100644
index 6c74a50..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/buffer.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// ts/buffer.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_BUFFER_HPP
-#define ASIO_TS_BUFFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/read.hpp"
-#include "asio/write.hpp"
-#include "asio/read_until.hpp"
-
-#endif // ASIO_TS_BUFFER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/executor.hpp
deleted file mode 100644
index df28bbf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/executor.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// ts/executor.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_EXECUTOR_HPP
-#define ASIO_TS_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/async_result.hpp"
-#include "asio/associated_allocator.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/is_executor.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/system_executor.hpp"
-#include "asio/executor.hpp"
-#include "asio/any_io_executor.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "asio/defer.hpp"
-#include "asio/strand.hpp"
-#include "asio/packaged_task.hpp"
-#include "asio/use_future.hpp"
-
-#endif // ASIO_TS_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/internet.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/internet.hpp
deleted file mode 100644
index eb2c35c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/internet.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// ts/internet.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_INTERNET_HPP
-#define ASIO_TS_INTERNET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/ip/address.hpp"
-#include "asio/ip/address_v4.hpp"
-#include "asio/ip/address_v4_iterator.hpp"
-#include "asio/ip/address_v4_range.hpp"
-#include "asio/ip/address_v6.hpp"
-#include "asio/ip/address_v6_iterator.hpp"
-#include "asio/ip/address_v6_range.hpp"
-#include "asio/ip/bad_address_cast.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/basic_resolver_entry.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/host_name.hpp"
-#include "asio/ip/network_v4.hpp"
-#include "asio/ip/network_v6.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "asio/ip/v6_only.hpp"
-#include "asio/ip/unicast.hpp"
-#include "asio/ip/multicast.hpp"
-
-#endif // ASIO_TS_INTERNET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/io_context.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/io_context.hpp
deleted file mode 100644
index c688f16..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/io_context.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//
-// ts/io_context.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_IO_CONTEXT_HPP
-#define ASIO_TS_IO_CONTEXT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/io_context.hpp"
-
-#endif // ASIO_TS_IO_CONTEXT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/net.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/net.hpp
deleted file mode 100644
index f82113b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/net.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// ts/net.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_NET_HPP
-#define ASIO_TS_NET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/ts/netfwd.hpp"
-#include "asio/ts/executor.hpp"
-#include "asio/ts/io_context.hpp"
-#include "asio/ts/timer.hpp"
-#include "asio/ts/buffer.hpp"
-#include "asio/ts/socket.hpp"
-#include "asio/ts/internet.hpp"
-
-#endif // ASIO_TS_NET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/netfwd.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/netfwd.hpp
deleted file mode 100644
index a575b6e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/netfwd.hpp
+++ /dev/null
@@ -1,236 +0,0 @@
-//
-// ts/netfwd.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_NETFWD_HPP
-#define ASIO_TS_NETFWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/chrono.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/detail/date_time_fwd.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#if !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-#include "asio/execution/blocking.hpp"
-#include "asio/execution/outstanding_work.hpp"
-#include "asio/execution/relationship.hpp"
-#endif // !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-#if !defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-class execution_context;
-
-template <typename T, typename Executor>
-class executor_binder;
-
-#if !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
-#define ASIO_EXECUTOR_WORK_GUARD_DECL
-
-template <typename Executor, typename = void, typename = void>
-class executor_work_guard;
-
-#endif // !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
-
-template <typename Blocking, typename Relationship, typename Allocator>
-class basic_system_executor;
-
-#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-class executor;
-
-typedef executor any_io_executor;
-
-#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-namespace execution {
-
-#if !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
-#define ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL
-
-template <typename... SupportableProperties>
-class any_executor;
-
-#endif // !defined(ASIO_EXECUTION_ANY_EXECUTOR_FWD_DECL)
-
-template <typename U>
-struct context_as_t;
-
-template <typename Property>
-struct prefer_only;
-
-} // namespace execution
-
-class any_io_executor;
-
-#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
-
-template <typename Executor>
-class strand;
-
-class io_context;
-
-template <typename Clock>
-struct wait_traits;
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
-template <typename Time>
-struct time_traits;
-
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#if !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
-#define ASIO_BASIC_WAITABLE_TIMER_FWD_DECL
-
-template <typename Clock,
-    typename WaitTraits = wait_traits<Clock>,
-    typename Executor = any_io_executor>
-class basic_waitable_timer;
-
-#endif // !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
-
-typedef basic_waitable_timer<chrono::system_clock> system_timer;
-
-typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
-
-typedef basic_waitable_timer<chrono::high_resolution_clock>
-  high_resolution_timer;
-
-#if !defined(ASIO_BASIC_SOCKET_FWD_DECL)
-#define ASIO_BASIC_SOCKET_FWD_DECL
-
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_socket;
-
-#endif // !defined(ASIO_BASIC_SOCKET_FWD_DECL)
-
-#if !defined(ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL)
-#define ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL
-
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_datagram_socket;
-
-#endif // !defined(ASIO_BASIC_DATAGRAM_SOCKET_FWD_DECL)
-
-#if !defined(ASIO_BASIC_STREAM_SOCKET_FWD_DECL)
-#define ASIO_BASIC_STREAM_SOCKET_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_stream_socket;
-
-#endif // !defined(ASIO_BASIC_STREAM_SOCKET_FWD_DECL)
-
-#if !defined(ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL)
-#define ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL
-
-template <typename Protocol, typename Executor = any_io_executor>
-class basic_socket_acceptor;
-
-#endif // !defined(ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL)
-
-#if !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
-#define ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-    typename Clock = boost::posix_time::ptime,
-    typename WaitTraits = time_traits<Clock>>
-#else
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#endif
-class basic_socket_streambuf;
-
-#endif // !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
-
-#if !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
-#define ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL
-
-// Forward declaration with defaulted arguments.
-template <typename Protocol,
-#if defined(ASIO_HAS_BOOST_DATE_TIME) \
-  || defined(GENERATING_DOCUMENTATION)
-    typename Clock = boost::posix_time::ptime,
-    typename WaitTraits = time_traits<Clock>>
-#else
-    typename Clock = chrono::steady_clock,
-    typename WaitTraits = wait_traits<Clock>>
-#endif
-class basic_socket_iostream;
-
-#endif // !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
-
-namespace ip {
-
-class address;
-
-class address_v4;
-
-class address_v6;
-
-template <typename Address>
-class basic_address_iterator;
-
-typedef basic_address_iterator<address_v4> address_v4_iterator;
-
-typedef basic_address_iterator<address_v6> address_v6_iterator;
-
-template <typename Address>
-class basic_address_range;
-
-typedef basic_address_range<address_v4> address_v4_range;
-
-typedef basic_address_range<address_v6> address_v6_range;
-
-class network_v4;
-
-class network_v6;
-
-template <typename InternetProtocol>
-class basic_endpoint;
-
-template <typename InternetProtocol>
-class basic_resolver_entry;
-
-template <typename InternetProtocol>
-class basic_resolver_results;
-
-#if !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
-#define ASIO_IP_BASIC_RESOLVER_FWD_DECL
-
-template <typename InternetProtocol, typename Executor = any_io_executor>
-class basic_resolver;
-
-#endif // !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
-
-class tcp;
-
-class udp;
-
-} // namespace ip
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_TS_NETFWD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/socket.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/socket.hpp
deleted file mode 100644
index d54e077..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/socket.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// ts/socket.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_SOCKET_HPP
-#define ASIO_TS_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/socket_base.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_socket_streambuf.hpp"
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/connect.hpp"
-
-#endif // ASIO_TS_SOCKET_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/timer.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/timer.hpp
deleted file mode 100644
index 3b3d6fa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/ts/timer.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// ts/timer.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_TS_TIMER_HPP
-#define ASIO_TS_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/chrono.hpp"
-
-#include "asio/wait_traits.hpp"
-#include "asio/basic_waitable_timer.hpp"
-#include "asio/system_timer.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/high_resolution_timer.hpp"
-
-#endif // ASIO_TS_TIMER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/unyield.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/unyield.hpp
deleted file mode 100644
index f843d61..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/unyield.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//
-// unyield.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifdef reenter
-# undef reenter
-#endif
-
-#ifdef yield
-# undef yield
-#endif
-
-#ifdef fork
-# undef fork
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_awaitable.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_awaitable.hpp
deleted file mode 100644
index 6dd42f3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_awaitable.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-// use_awaitable.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_USE_AWAITABLE_HPP
-#define ASIO_USE_AWAITABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/awaitable.hpp"
-#include "asio/detail/handler_tracking.hpp"
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-#  include "asio/detail/source_location.hpp"
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A @ref completion_token that represents the currently executing coroutine.
-/**
- * The @c use_awaitable_t class, with its value @c use_awaitable, is used to
- * represent the currently executing coroutine. This completion token may be
- * passed as a handler to an asynchronous operation. For example:
- *
- * @code awaitable<void> my_coroutine()
- * {
- *   std::size_t n = co_await my_socket.async_read_some(buffer, use_awaitable);
- *   ...
- * } @endcode
- *
- * When used with co_await, the initiating function (@c async_read_some in the
- * above example) suspends the current coroutine. The coroutine is resumed when
- * the asynchronous operation completes, and the result of the operation is
- * returned.
- */
-template <typename Executor = any_io_executor>
-struct use_awaitable_t
-{
-  /// Default constructor.
-  constexpr use_awaitable_t(
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-      detail::source_location location = detail::source_location::current()
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-    )
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# if defined(ASIO_HAS_SOURCE_LOCATION)
-    : file_name_(location.file_name()),
-      line_(location.line()),
-      function_name_(location.function_name())
-# else // defined(ASIO_HAS_SOURCE_LOCATION)
-    : file_name_(0),
-      line_(0),
-      function_name_(0)
-# endif // defined(ASIO_HAS_SOURCE_LOCATION)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-  {
-  }
-
-  /// Constructor used to specify file name, line, and function name.
-  constexpr use_awaitable_t(const char* file_name,
-      int line, const char* function_name)
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-    : file_name_(file_name),
-      line_(line),
-      function_name_(function_name)
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-  {
-#if !defined(ASIO_ENABLE_HANDLER_TRACKING)
-    (void)file_name;
-    (void)line;
-    (void)function_name;
-#endif // !defined(ASIO_ENABLE_HANDLER_TRACKING)
-  }
-
-  /// Adapts an executor to add the @c use_awaitable_t completion token as the
-  /// default.
-  template <typename InnerExecutor>
-  struct executor_with_default : InnerExecutor
-  {
-    /// Specify @c use_awaitable_t as the default completion token type.
-    typedef use_awaitable_t default_completion_token_type;
-
-    /// Construct the adapted executor from the inner executor type.
-    template <typename InnerExecutor1>
-    executor_with_default(const InnerExecutor1& ex,
-        constraint_t<
-          conditional_t<
-            !is_same<InnerExecutor1, executor_with_default>::value,
-            is_convertible<InnerExecutor1, InnerExecutor>,
-            false_type
-          >::value
-        > = 0) noexcept
-      : InnerExecutor(ex)
-    {
-    }
-  };
-
-  /// Type alias to adapt an I/O object to use @c use_awaitable_t as its
-  /// default completion token type.
-  template <typename T>
-  using as_default_on_t = typename T::template rebind_executor<
-      executor_with_default<typename T::executor_type>>::other;
-
-  /// Function helper to adapt an I/O object to use @c use_awaitable_t as its
-  /// default completion token type.
-  template <typename T>
-  static typename decay_t<T>::template rebind_executor<
-      executor_with_default<typename decay_t<T>::executor_type>
-    >::other
-  as_default_on(T&& object)
-  {
-    return typename decay_t<T>::template rebind_executor<
-        executor_with_default<typename decay_t<T>::executor_type>
-      >::other(static_cast<T&&>(object));
-  }
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-  const char* file_name_;
-  int line_;
-  const char* function_name_;
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-};
-
-/// A @ref completion_token object that represents the currently executing
-/// coroutine.
-/**
- * See the documentation for asio::use_awaitable_t for a usage example.
- */
-#if defined(GENERATING_DOCUMENTATION)
-constexpr use_awaitable_t<> use_awaitable;
-#else
-constexpr use_awaitable_t<> use_awaitable(0, 0, 0);
-#endif
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/use_awaitable.hpp"
-
-#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_USE_AWAITABLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_future.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_future.hpp
deleted file mode 100644
index 26f5ae1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/use_future.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//
-// use_future.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_USE_FUTURE_HPP
-#define ASIO_USE_FUTURE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/future.hpp"
-
-#if defined(ASIO_HAS_STD_FUTURE_CLASS) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <memory>
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Function, typename Allocator>
-class packaged_token;
-
-template <typename Function, typename Allocator, typename Result>
-class packaged_handler;
-
-} // namespace detail
-
-/// A @ref completion_token type that causes an asynchronous operation to return
-/// a future.
-/**
- * The use_future_t class is a completion token type that is used to indicate
- * that an asynchronous operation should return a std::future object. A
- * use_future_t object may be passed as a completion token to an asynchronous
- * operation, typically using the special value @c asio::use_future. For
- * example:
- *
- * @code std::future<std::size_t> my_future
- *   = my_socket.async_read_some(my_buffer, asio::use_future); @endcode
- *
- * The initiating function (async_read_some in the above example) returns a
- * future that will receive the result of the operation. If the operation
- * completes with an error_code indicating failure, it is converted into a
- * system_error and passed back to the caller via the future.
- */
-template <typename Allocator = std::allocator<void>>
-class use_future_t
-{
-public:
-  /// The allocator type. The allocator is used when constructing the
-  /// @c std::promise object for a given asynchronous operation.
-  typedef Allocator allocator_type;
-
-  /// Construct using default-constructed allocator.
-  constexpr use_future_t()
-  {
-  }
-
-  /// Construct using specified allocator.
-  explicit use_future_t(const Allocator& allocator)
-    : allocator_(allocator)
-  {
-  }
-
-#if !defined(ASIO_NO_DEPRECATED)
-  /// (Deprecated: Use rebind().) Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_future_t<OtherAllocator> operator[](const OtherAllocator& allocator) const
-  {
-    return use_future_t<OtherAllocator>(allocator);
-  }
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  /// Specify an alternate allocator.
-  template <typename OtherAllocator>
-  use_future_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
-  {
-    return use_future_t<OtherAllocator>(allocator);
-  }
-
-  /// Obtain allocator.
-  allocator_type get_allocator() const
-  {
-    return allocator_;
-  }
-
-  /// Wrap a function object in a packaged task.
-  /**
-   * The @c package function is used to adapt a function object as a packaged
-   * task. When this adapter is passed as a completion token to an asynchronous
-   * operation, the result of the function object is retuned via a std::future.
-   *
-   * @par Example
-   *
-   * @code std::future<std::size_t> fut =
-   *   my_socket.async_read_some(buffer,
-   *     use_future([](asio::error_code ec, std::size_t n)
-   *       {
-   *         return ec ? 0 : n;
-   *       }));
-   * ...
-   * std::size_t n = fut.get(); @endcode
-   */
-  template <typename Function>
-#if defined(GENERATING_DOCUMENTATION)
-  unspecified
-#else // defined(GENERATING_DOCUMENTATION)
-  detail::packaged_token<decay_t<Function>, Allocator>
-#endif // defined(GENERATING_DOCUMENTATION)
-  operator()(Function&& f) const;
-
-private:
-  // Helper type to ensure that use_future can be constexpr default-constructed
-  // even when std::allocator<void> can't be.
-  struct std_allocator_void
-  {
-    constexpr std_allocator_void()
-    {
-    }
-
-    operator std::allocator<void>() const
-    {
-      return std::allocator<void>();
-    }
-  };
-
-  conditional_t<
-    is_same<std::allocator<void>, Allocator>::value,
-    std_allocator_void, Allocator> allocator_;
-};
-
-/// A @ref completion_token object that causes an asynchronous operation to
-/// return a future.
-/**
- * See the documentation for asio::use_future_t for a usage example.
- */
-constexpr use_future_t<> use_future;
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/use_future.hpp"
-
-#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_USE_FUTURE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/uses_executor.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/uses_executor.hpp
deleted file mode 100644
index ff475ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/uses_executor.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// uses_executor.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_USES_EXECUTOR_HPP
-#define ASIO_USES_EXECUTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/type_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// A special type, similar to std::nothrow_t, used to disambiguate
-/// constructors that accept executor arguments.
-/**
- * The executor_arg_t struct is an empty structure type used as a unique type
- * to disambiguate constructor and function overloading. Specifically, some
- * types have constructors with executor_arg_t as the first argument,
- * immediately followed by an argument of a type that satisfies the Executor
- * type requirements.
- */
-struct executor_arg_t
-{
-  /// Constructor.
-  constexpr executor_arg_t() noexcept
-  {
-  }
-};
-
-/// A special value, similar to std::nothrow, used to disambiguate constructors
-/// that accept executor arguments.
-/**
- * See asio::executor_arg_t and asio::uses_executor
- * for more information.
- */
-constexpr executor_arg_t executor_arg;
-
-/// The uses_executor trait detects whether a type T has an associated executor
-/// that is convertible from type Executor.
-/**
- * Meets the BinaryTypeTrait requirements. The Asio library provides a
- * definition that is derived from false_type. A program may specialize this
- * template to derive from true_type for a user-defined type T that can be
- * constructed with an executor, where the first argument of a constructor has
- * type executor_arg_t and the second argument is convertible from type
- * Executor.
- */
-template <typename T, typename Executor>
-struct uses_executor : false_type {};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_USES_EXECUTOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/version.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/version.hpp
deleted file mode 100644
index e005200..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/version.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//
-// version.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_VERSION_HPP
-#define ASIO_VERSION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-// ASIO_VERSION % 100 is the sub-minor version
-// ASIO_VERSION / 100 % 1000 is the minor version
-// ASIO_VERSION / 100000 is the major version
-#define ASIO_VERSION 103100 // 1.31.0
-
-#endif // ASIO_VERSION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/wait_traits.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/wait_traits.hpp
deleted file mode 100644
index 5f5e876..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/wait_traits.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//
-// wait_traits.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WAIT_TRAITS_HPP
-#define ASIO_WAIT_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Wait traits suitable for use with the basic_waitable_timer class template.
-template <typename Clock>
-struct wait_traits
-{
-  /// Convert a clock duration into a duration used for waiting.
-  /**
-   * @returns @c d.
-   */
-  static typename Clock::duration to_wait_duration(
-      const typename Clock::duration& d)
-  {
-    return d;
-  }
-
-  /// Convert a clock duration into a duration used for waiting.
-  /**
-   * @returns @c d.
-   */
-  static typename Clock::duration to_wait_duration(
-      const typename Clock::time_point& t)
-  {
-    typename Clock::time_point now = Clock::now();
-    if (now + (Clock::duration::max)() < t)
-      return (Clock::duration::max)();
-    if (now + (Clock::duration::min)() > t)
-      return (Clock::duration::min)();
-    return t - now;
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_WAIT_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_object_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_object_handle.hpp
deleted file mode 100644
index e0d0343..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_object_handle.hpp
+++ /dev/null
@@ -1,485 +0,0 @@
-//
-// windows/basic_object_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
-#define ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_object_handle_service.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Provides object-oriented handle functionality.
-/**
- * The windows::basic_object_handle class provides asynchronous and blocking
- * object-oriented handle functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_object_handle
-{
-private:
-  class initiate_async_wait;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the handle type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The handle type when rebound to the specified executor.
-    typedef basic_object_handle<Executor1> other;
-  };
-
-  /// The native representation of a handle.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef asio::detail::win_object_handle_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// An object handle is always the lowest layer.
-  typedef basic_object_handle lowest_layer_type;
-
-  /// Construct an object handle without opening it.
-  /**
-   * This constructor creates an object handle without opening it.
-   *
-   * @param ex The I/O executor that the object handle will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * object handle.
-   */
-  explicit basic_object_handle(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct an object handle without opening it.
-  /**
-   * This constructor creates an object handle without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the object handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the object handle.
-   */
-  template <typename ExecutionContext>
-  explicit basic_object_handle(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct an object handle on an existing native handle.
-  /**
-   * This constructor creates an object handle object to hold an existing native
-   * handle.
-   *
-   * @param ex The I/O executor that the object handle will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the
-   * object handle.
-   *
-   * @param native_handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_object_handle(const executor_type& ex,
-      const native_handle_type& native_handle)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct an object handle on an existing native handle.
-  /**
-   * This constructor creates an object handle object to hold an existing native
-   * handle.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the object handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the object handle.
-   *
-   * @param native_handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_object_handle(ExecutionContext& context,
-      const native_handle_type& native_handle,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct an object handle from another.
-  /**
-   * This constructor moves an object handle from one object to another.
-   *
-   * @param other The other object handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(const executor_type&)
-   * constructor.
-   */
-  basic_object_handle(basic_object_handle&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign an object handle from another.
-  /**
-   * This assignment operator moves an object handle from one object to another.
-   *
-   * @param other The other object handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(const executor_type&)
-   * constructor.
-   */
-  basic_object_handle& operator=(basic_object_handle&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All handles have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_object_handle;
-
-  /// Move-construct an object handle from a handle of another executor type.
-  /**
-   * This constructor moves an object handle from one object to another.
-   *
-   * @param other The other object handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  basic_object_handle(basic_object_handle<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign an object handle from a handle of another executor type.
-  /**
-   * This assignment operator moves an object handle from one object to another.
-   *
-   * @param other The other object handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_object_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_object_handle&
-  > operator=(basic_object_handle<Executor1>&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since an object handle cannot contain any further layers, it simply
-   * returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since an object handle cannot contain any further layers, it simply
-   * returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Assign an existing native handle to the handle.
-  /*
-   * This function opens the handle to hold an existing native handle.
-   *
-   * @param handle A native handle.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& handle)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native handle to the handle.
-  /*
-   * This function opens the handle to hold an existing native handle.
-   *
-   * @param handle A native handle.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& handle,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(), handle, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the handle is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the handle.
-  /**
-   * This function is used to close the handle. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the handle.
-  /**
-   * This function is used to close the handle. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Get the native handle representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * handle. This is intended to allow access to native handle functionality
-   * that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the handle.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the handle.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Perform a blocking wait on the object handle.
-  /**
-   * This function is used to wait for the object handle to be set to the
-   * signalled state. This function blocks and does not return until the object
-   * handle has been set to the signalled state.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    asio::error_code ec;
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Perform a blocking wait on the object handle.
-  /**
-   * This function is used to wait for the object handle to be set to the
-   * signalled state. This function blocks and does not return until the object
-   * handle has been set to the signalled state.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(asio::error_code& ec)
-  {
-    impl_.get_service().wait(impl_.get_implementation(), ec);
-  }
-
-  /// Start an asynchronous wait on the object handle.
-  /**
-   * This function is be used to initiate an asynchronous wait against the
-   * object handle. It is an initiating function for an @ref
-   * asynchronous_operation, and always returns immediately.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the wait completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code) @endcode
-   */
-  template <
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
-        WaitToken = default_completion_token_t<executor_type>>
-  auto async_wait(
-      WaitToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WaitToken, void (asio::error_code)>(
-        declval<initiate_async_wait>(), token))
-  {
-    return async_initiate<WaitToken, void (asio::error_code)>(
-        initiate_async_wait(this), token);
-  }
-
-private:
-  // Disallow copying and assignment.
-  basic_object_handle(const basic_object_handle&) = delete;
-  basic_object_handle& operator=(const basic_object_handle&) = delete;
-
-  class initiate_async_wait
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_wait(basic_object_handle* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WaitHandler>
-    void operator()(WaitHandler&& handler) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WaitHandler.
-      ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
-
-      detail::non_const_lvalue<WaitHandler> handler2(handler);
-      self_->impl_.get_service().async_wait(
-          self_->impl_.get_implementation(),
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_object_handle* self_;
-  };
-
-  asio::detail::io_object_impl<
-    asio::detail::win_object_handle_service, Executor> impl_;
-};
-
-} // namespace windows
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_overlapped_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_overlapped_handle.hpp
deleted file mode 100644
index 8b8475b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_overlapped_handle.hpp
+++ /dev/null
@@ -1,455 +0,0 @@
-//
-// windows/basic_overlapped_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_BASIC_OVERLAPPED_HANDLE_HPP
-#define ASIO_WINDOWS_BASIC_OVERLAPPED_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
-  || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <cstddef>
-#include <utility>
-#include "asio/any_io_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/detail/io_object_impl.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_iocp_handle_service.hpp"
-#include "asio/error.hpp"
-#include "asio/execution_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Provides Windows handle functionality for objects that support
-/// overlapped I/O.
-/**
- * The windows::overlapped_handle class provides the ability to wrap a Windows
- * handle. The underlying object referred to by the handle must support
- * overlapped I/O.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_overlapped_handle
-{
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the handle type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The handle type when rebound to the specified executor.
-    typedef basic_overlapped_handle<Executor1> other;
-  };
-
-  /// The native representation of a handle.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef asio::detail::win_iocp_handle_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// An overlapped_handle is always the lowest layer.
-  typedef basic_overlapped_handle lowest_layer_type;
-
-  /// Construct an overlapped handle without opening it.
-  /**
-   * This constructor creates an overlapped handle without opening it.
-   *
-   * @param ex The I/O executor that the overlapped handle will use, by default,
-   * to dispatch handlers for any asynchronous operations performed on the
-   * overlapped handle.
-   */
-  explicit basic_overlapped_handle(const executor_type& ex)
-    : impl_(0, ex)
-  {
-  }
-
-  /// Construct an overlapped handle without opening it.
-  /**
-   * This constructor creates an overlapped handle without opening it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the overlapped handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the overlapped handle.
-   */
-  template <typename ExecutionContext>
-  explicit basic_overlapped_handle(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(0, 0, context)
-  {
-  }
-
-  /// Construct an overlapped handle on an existing native handle.
-  /**
-   * This constructor creates an overlapped handle object to hold an existing
-   * native handle.
-   *
-   * @param ex The I/O executor that the overlapped handle will use, by default,
-   * to dispatch handlers for any asynchronous operations performed on the
-   * overlapped handle.
-   *
-   * @param native_handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_overlapped_handle(const executor_type& ex,
-      const native_handle_type& native_handle)
-    : impl_(0, ex)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Construct an overlapped handle on an existing native handle.
-  /**
-   * This constructor creates an overlapped handle object to hold an existing
-   * native handle.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the overlapped handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the overlapped handle.
-   *
-   * @param native_handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_overlapped_handle(ExecutionContext& context,
-      const native_handle_type& native_handle,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(0, 0, context)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), native_handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Move-construct an overlapped handle from another.
-  /**
-   * This constructor moves a handle from one object to another.
-   *
-   * @param other The other overlapped handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c overlapped_handle(const executor_type&)
-   * constructor.
-   */
-  basic_overlapped_handle(basic_overlapped_handle&& other)
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign an overlapped handle from another.
-  /**
-   * This assignment operator moves a handle from one object to another.
-   *
-   * @param other The other overlapped handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c overlapped_handle(const executor_type&)
-   * constructor.
-   */
-  basic_overlapped_handle& operator=(basic_overlapped_handle&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  // All overlapped handles have access to each other's implementations.
-  template <typename Executor1>
-  friend class basic_overlapped_handle;
-
-  /// Move-construct an overlapped handle from a handle of another executor
-  /// type.
-  /**
-   * This constructor moves a handle from one object to another.
-   *
-   * @param other The other overlapped handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c overlapped_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  basic_overlapped_handle(basic_overlapped_handle<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : impl_(std::move(other.impl_))
-  {
-  }
-
-  /// Move-assign an overlapped handle from a handle of another executor type.
-  /**
-   * This assignment operator moves a handle from one object to another.
-   *
-   * @param other The other overlapped handle object from which the move will
-   * occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c overlapped_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_overlapped_handle&
-  > operator=(basic_overlapped_handle<Executor1>&& other)
-  {
-    impl_ = std::move(other.impl_);
-    return *this;
-  }
-
-  /// Get the executor associated with the object.
-  const executor_type& get_executor() noexcept
-  {
-    return impl_.get_executor();
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since an overlapped_handle cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since an overlapped_handle cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Assign an existing native handle to the handle.
-  /*
-   * This function opens the handle to hold an existing native handle.
-   *
-   * @param handle A native handle.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_handle_type& handle)
-  {
-    asio::error_code ec;
-    impl_.get_service().assign(impl_.get_implementation(), handle, ec);
-    asio::detail::throw_error(ec, "assign");
-  }
-
-  /// Assign an existing native handle to the handle.
-  /*
-   * This function opens the handle to hold an existing native handle.
-   *
-   * @param handle A native handle.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID assign(const native_handle_type& handle,
-      asio::error_code& ec)
-  {
-    impl_.get_service().assign(impl_.get_implementation(), handle, ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Determine whether the handle is open.
-  bool is_open() const
-  {
-    return impl_.get_service().is_open(impl_.get_implementation());
-  }
-
-  /// Close the handle.
-  /**
-   * This function is used to close the handle. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "close");
-  }
-
-  /// Close the handle.
-  /**
-   * This function is used to close the handle. Any asynchronous read or write
-   * operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID close(asio::error_code& ec)
-  {
-    impl_.get_service().close(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-  /// Release ownership of the underlying native handle.
-  /**
-   * This function causes all outstanding asynchronous operations to finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * asio::error::operation_aborted error. Ownership of the native handle
-   * is then transferred to the caller.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release()
-  {
-    asio::error_code ec;
-    native_handle_type s = impl_.get_service().release(
-        impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "release");
-    return s;
-  }
-
-  /// Release ownership of the underlying native handle.
-  /**
-   * This function causes all outstanding asynchronous operations to finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * asio::error::operation_aborted error. Ownership of the native handle
-   * is then transferred to the caller.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note This function is unsupported on Windows versions prior to Windows
-   * 8.1, and will fail with asio::error::operation_not_supported on
-   * these platforms.
-   */
-#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
-  && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
-  __declspec(deprecated("This function always fails with "
-        "operation_not_supported when used on Windows versions "
-        "prior to Windows 8.1."))
-#endif
-  native_handle_type release(asio::error_code& ec)
-  {
-    return impl_.get_service().release(impl_.get_implementation(), ec);
-  }
-
-  /// Get the native handle representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * handle. This is intended to allow access to native handle functionality
-   * that is not otherwise provided.
-   */
-  native_handle_type native_handle()
-  {
-    return impl_.get_service().native_handle(impl_.get_implementation());
-  }
-
-  /// Cancel all asynchronous operations associated with the handle.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all asynchronous operations associated with the handle.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
-  {
-    impl_.get_service().cancel(impl_.get_implementation(), ec);
-    ASIO_SYNC_OP_VOID_RETURN(ec);
-  }
-
-protected:
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * This function destroys the handle, cancelling any outstanding asynchronous
-   * wait operations associated with the handle as if by calling @c cancel.
-   */
-  ~basic_overlapped_handle()
-  {
-  }
-
-  asio::detail::io_object_impl<
-    asio::detail::win_iocp_handle_service, Executor> impl_;
-
-private:
-  // Disallow copying and assignment.
-  basic_overlapped_handle(const basic_overlapped_handle&) = delete;
-  basic_overlapped_handle& operator=(
-      const basic_overlapped_handle&) = delete;
-};
-
-} // namespace windows
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-       //   || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_BASIC_OVERLAPPED_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_random_access_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_random_access_handle.hpp
deleted file mode 100644
index d22541a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_random_access_handle.hpp
+++ /dev/null
@@ -1,567 +0,0 @@
-//
-// windows/basic_random_access_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
-#define ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/windows/basic_overlapped_handle.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Provides random-access handle functionality.
-/**
- * The windows::basic_random_access_handle class provides asynchronous and
- * blocking random-access handle functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Executor = any_io_executor>
-class basic_random_access_handle
-  : public basic_overlapped_handle<Executor>
-{
-private:
-  class initiate_async_write_some_at;
-  class initiate_async_read_some_at;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the handle type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The handle type when rebound to the specified executor.
-    typedef basic_random_access_handle<Executor1> other;
-  };
-
-  /// The native representation of a handle.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef asio::detail::win_iocp_handle_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// Construct a random-access handle without opening it.
-  /**
-   * This constructor creates a random-access handle without opening it.
-   *
-   * @param ex The I/O executor that the random-access handle will use, by
-   * default, to dispatch handlers for any asynchronous operations performed on
-   * the random-access handle.
-   */
-  explicit basic_random_access_handle(const executor_type& ex)
-    : basic_overlapped_handle<Executor>(ex)
-  {
-  }
-
-  /// Construct a random-access handle without opening it.
-  /**
-   * This constructor creates a random-access handle without opening it. The
-   * handle needs to be opened or assigned before data can be written to or read
-   * from it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the random-access handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the random-access handle.
-   */
-  template <typename ExecutionContext>
-  explicit basic_random_access_handle(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_overlapped_handle<Executor>(context)
-  {
-  }
-
-  /// Construct a random-access handle on an existing native handle.
-  /**
-   * This constructor creates a random-access handle object to hold an existing
-   * native handle.
-   *
-   * @param ex The I/O executor that the random-access handle will use, by
-   * default, to dispatch handlers for any asynchronous operations performed on
-   * the random-access handle.
-   *
-   * @param handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_random_access_handle(const executor_type& ex,
-      const native_handle_type& handle)
-    : basic_overlapped_handle<Executor>(ex, handle)
-  {
-  }
-
-  /// Construct a random-access handle on an existing native handle.
-  /**
-   * This constructor creates a random-access handle object to hold an existing
-   * native handle.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the random-access handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the random-access handle.
-   *
-   * @param handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_random_access_handle(ExecutionContext& context,
-      const native_handle_type& handle,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_overlapped_handle<Executor>(context, handle)
-  {
-  }
-
-  /// Move-construct a random-access handle from another.
-  /**
-   * This constructor moves a random-access handle from one object to another.
-   *
-   * @param other The other random-access handle object from which the
-   * move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_handle(const executor_type&)
-   * constructor.
-   */
-  basic_random_access_handle(basic_random_access_handle&& other)
-    : basic_overlapped_handle<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a random-access handle from another.
-  /**
-   * This assignment operator moves a random-access handle from one object to
-   * another.
-   *
-   * @param other The other random-access handle object from which the
-   * move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_handle(const executor_type&)
-   * constructor.
-   */
-  basic_random_access_handle& operator=(basic_random_access_handle&& other)
-  {
-    basic_overlapped_handle<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a random-access handle from a handle of another executor
-  /// type.
-  /**
-   * This constructor moves a random-access handle from one object to another.
-   *
-   * @param other The other random-access handle object from which the
-   * move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  basic_random_access_handle(basic_random_access_handle<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_overlapped_handle<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a random-access handle from a handle of another executor
-  /// type.
-  /**
-   * This assignment operator moves a random-access handle from one object to
-   * another.
-   *
-   * @param other The other random-access handle object from which the
-   * move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_random_access_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_random_access_handle&
-  > operator=(basic_random_access_handle<Executor1>&& other)
-  {
-    basic_overlapped_handle<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Write some data to the handle at the specified offset.
-  /**
-   * This function is used to write data to the random-access handle. The
-   * function call will block until one or more bytes of the data has been
-   * written successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some_at operation may not write all of the data. Consider
-   * using the @ref write_at function if you need to ensure that all data is
-   * written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.write_some_at(42, asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some_at(uint64_t offset,
-      const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().write_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-    asio::detail::throw_error(ec, "write_some_at");
-    return s;
-  }
-
-  /// Write some data to the handle at the specified offset.
-  /**
-   * This function is used to write data to the random-access handle. The
-   * function call will block until one or more bytes of the data has been
-   * written successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write_at function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some_at(uint64_t offset,
-      const ConstBufferSequence& buffers, asio::error_code& ec)
-  {
-    return this->impl_.get_service().write_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-  }
-
-  /// Start an asynchronous write at the specified offset.
-  /**
-   * This function is used to asynchronously write data to the random-access
-   * handle. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param offset The offset at which the data will be written.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write_at function if you need to ensure that
-   * all data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_write_some_at(42, asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some_at(uint64_t offset, const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some_at>(), token, offset, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some_at(this), token, offset, buffers);
-  }
-
-  /// Read some data from the handle at the specified offset.
-  /**
-   * This function is used to read data from the random-access handle. The
-   * function call will block until one or more bytes of data has been read
-   * successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read_at function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.read_some_at(42, asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some_at(uint64_t offset,
-      const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().read_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-    asio::detail::throw_error(ec, "read_some_at");
-    return s;
-  }
-
-  /// Read some data from the handle at the specified offset.
-  /**
-   * This function is used to read data from the random-access handle. The
-   * function call will block until one or more bytes of data has been read
-   * successfully, or until an error occurs.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read_at function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some_at(uint64_t offset,
-      const MutableBufferSequence& buffers, asio::error_code& ec)
-  {
-    return this->impl_.get_service().read_some_at(
-        this->impl_.get_implementation(), offset, buffers, ec);
-  }
-
-  /// Start an asynchronous read at the specified offset.
-  /**
-   * This function is used to asynchronously read data from the random-access
-   * handle. It is an initiating function for an @ref asynchronous_operation,
-   * and always returns immediately.
-   *
-   * @param offset The offset at which the data will be read.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read_at function if you need to ensure that
-   * the requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_read_some_at(42, asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some_at(uint64_t offset, const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some_at>(), token, offset, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some_at(this), token, offset, buffers);
-  }
-
-private:
-  class initiate_async_write_some_at
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some_at(basic_random_access_handle* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        uint64_t offset, const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some_at(
-          self_->impl_.get_implementation(), offset, buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_random_access_handle* self_;
-  };
-
-  class initiate_async_read_some_at
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some_at(basic_random_access_handle* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        uint64_t offset, const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some_at(
-          self_->impl_.get_implementation(), offset, buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_random_access_handle* self_;
-  };
-};
-
-} // namespace windows
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_stream_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_stream_handle.hpp
deleted file mode 100644
index 44f5932..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/basic_stream_handle.hpp
+++ /dev/null
@@ -1,551 +0,0 @@
-//
-// windows/basic_stream_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
-#define ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/windows/basic_overlapped_handle.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Provides stream-oriented handle functionality.
-/**
- * The windows::basic_stream_handle class provides asynchronous and blocking
- * stream-oriented handle functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Executor = any_io_executor>
-class basic_stream_handle
-  : public basic_overlapped_handle<Executor>
-{
-private:
-  class initiate_async_write_some;
-  class initiate_async_read_some;
-
-public:
-  /// The type of the executor associated with the object.
-  typedef Executor executor_type;
-
-  /// Rebinds the handle type to another executor.
-  template <typename Executor1>
-  struct rebind_executor
-  {
-    /// The handle type when rebound to the specified executor.
-    typedef basic_stream_handle<Executor1> other;
-  };
-
-  /// The native representation of a handle.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef asio::detail::win_iocp_handle_service::native_handle_type
-    native_handle_type;
-#endif
-
-  /// Construct a stream handle without opening it.
-  /**
-   * This constructor creates a stream handle without opening it.
-   *
-   * @param ex The I/O executor that the stream handle will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the stream
-   * handle.
-   */
-  explicit basic_stream_handle(const executor_type& ex)
-    : basic_overlapped_handle<Executor>(ex)
-  {
-  }
-
-  /// Construct a stream handle without opening it.
-  /**
-   * This constructor creates a stream handle without opening it. The handle
-   * needs to be opened or assigned before data can be written to or read from
-   * it.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the stream handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the stream handle.
-   */
-  template <typename ExecutionContext>
-  explicit basic_stream_handle(ExecutionContext& context,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_overlapped_handle<Executor>(context)
-  {
-  }
-
-  /// Construct a stream handle on an existing native handle.
-  /**
-   * This constructor creates a stream handle object to hold an existing native
-   * handle.
-   *
-   * @param ex The I/O executor that the stream handle will use, by default, to
-   * dispatch handlers for any asynchronous operations performed on the stream
-   * handle.
-   *
-   * @param handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_handle(const executor_type& ex, const native_handle_type& handle)
-    : basic_overlapped_handle<Executor>(ex, handle)
-  {
-  }
-
-  /// Construct a stream handle on an existing native handle.
-  /**
-   * This constructor creates a stream handle object to hold an existing native
-   * handle.
-   *
-   * @param context An execution context which provides the I/O executor that
-   * the stream handle will use, by default, to dispatch handlers for any
-   * asynchronous operations performed on the stream handle.
-   *
-   * @param handle The new underlying handle implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ExecutionContext>
-  basic_stream_handle(ExecutionContext& context,
-      const native_handle_type& handle,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : basic_overlapped_handle<Executor>(context, handle)
-  {
-  }
-
-  /// Move-construct a stream handle from another.
-  /**
-   * This constructor moves a stream handle from one object to another.
-   *
-   * @param other The other stream handle object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_handle(const executor_type&)
-   * constructor.
-   */
-  basic_stream_handle(basic_stream_handle&& other)
-    : basic_overlapped_handle<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a stream handle from another.
-  /**
-   * This assignment operator moves a stream handle from one object to
-   * another.
-   *
-   * @param other The other stream handle object from which the move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_handle(const executor_type&)
-   * constructor.
-   */
-  basic_stream_handle& operator=(basic_stream_handle&& other)
-  {
-    basic_overlapped_handle<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Move-construct a stream handle from a handle of another executor type.
-  /**
-   * This constructor moves a stream handle from one object to another.
-   *
-   * @param other The other stream handle object from which the move
-   * will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  basic_stream_handle(basic_stream_handle<Executor1>&& other,
-      constraint_t<
-        is_convertible<Executor1, Executor>::value,
-        defaulted_constraint
-      > = defaulted_constraint())
-    : basic_overlapped_handle<Executor>(std::move(other))
-  {
-  }
-
-  /// Move-assign a stream handle from a handle of another executor type.
-  /**
-   * This assignment operator moves a stream handle from one object to
-   * another.
-   *
-   * @param other The other stream handle object from which the move will occur.
-   *
-   * @note Following the move, the moved-from object is in the same state as if
-   * constructed using the @c basic_stream_handle(const executor_type&)
-   * constructor.
-   */
-  template<typename Executor1>
-  constraint_t<
-    is_convertible<Executor1, Executor>::value,
-    basic_stream_handle&
-  > operator=(basic_stream_handle<Executor1>&& other)
-  {
-    basic_overlapped_handle<Executor>::operator=(std::move(other));
-    return *this;
-  }
-
-  /// Write some data to the handle.
-  /**
-   * This function is used to write data to the stream handle. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "write_some");
-    return s;
-  }
-
-  /// Write some data to the handle.
-  /**
-   * This function is used to write data to the stream handle. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().write_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the stream handle.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the handle.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the write completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename ConstBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) WriteToken = default_completion_token_t<executor_type>>
-  auto async_write_some(const ConstBufferSequence& buffers,
-      WriteToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<WriteToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_write_some>(), token, buffers))
-  {
-    return async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_write_some(this), token, buffers);
-  }
-
-  /// Read some data from the handle.
-  /**
-   * This function is used to read data from the stream handle. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-    asio::detail::throw_error(ec, "read_some");
-    return s;
-  }
-
-  /// Read some data from the handle.
-  /**
-   * This function is used to read data from the stream handle. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->impl_.get_service().read_some(
-        this->impl_.get_implementation(), buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the stream handle.
-   * It is an initiating function for an @ref asynchronous_operation, and always
-   * returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the completion handler is called.
-   *
-   * @param token The @ref completion_token that will be used to produce a
-   * completion handler, which will be called when the read completes.
-   * Potential completion tokens include @ref use_future, @ref use_awaitable,
-   * @ref yield_context, or a function object with the correct completion
-   * signature. The function signature of the completion handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the completion handler will not be invoked from within this function.
-   * On immediate completion, invocation of the handler will be performed in a
-   * manner equivalent to using asio::async_immediate().
-   *
-   * @par Completion Signature
-   * @code void(asio::error_code, std::size_t) @endcode
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * handle.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   *
-   * @par Per-Operation Cancellation
-   * This asynchronous operation supports cancellation for the following
-   * asio::cancellation_type values:
-   *
-   * @li @c cancellation_type::terminal
-   *
-   * @li @c cancellation_type::partial
-   *
-   * @li @c cancellation_type::total
-   */
-  template <typename MutableBufferSequence,
-      ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-        std::size_t)) ReadToken = default_completion_token_t<executor_type>>
-  auto async_read_some(const MutableBufferSequence& buffers,
-      ReadToken&& token = default_completion_token_t<executor_type>())
-    -> decltype(
-      async_initiate<ReadToken,
-        void (asio::error_code, std::size_t)>(
-          declval<initiate_async_read_some>(), token, buffers))
-  {
-    return async_initiate<ReadToken,
-      void (asio::error_code, std::size_t)>(
-        initiate_async_read_some(this), token, buffers);
-  }
-
-private:
-  class initiate_async_write_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_write_some(basic_stream_handle* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename WriteHandler, typename ConstBufferSequence>
-    void operator()(WriteHandler&& handler,
-        const ConstBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a WriteHandler.
-      ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
-
-      detail::non_const_lvalue<WriteHandler> handler2(handler);
-      self_->impl_.get_service().async_write_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_handle* self_;
-  };
-
-  class initiate_async_read_some
-  {
-  public:
-    typedef Executor executor_type;
-
-    explicit initiate_async_read_some(basic_stream_handle* self)
-      : self_(self)
-    {
-    }
-
-    const executor_type& get_executor() const noexcept
-    {
-      return self_->get_executor();
-    }
-
-    template <typename ReadHandler, typename MutableBufferSequence>
-    void operator()(ReadHandler&& handler,
-        const MutableBufferSequence& buffers) const
-    {
-      // If you get an error on the following line it means that your handler
-      // does not meet the documented type requirements for a ReadHandler.
-      ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
-
-      detail::non_const_lvalue<ReadHandler> handler2(handler);
-      self_->impl_.get_service().async_read_some(
-          self_->impl_.get_implementation(), buffers,
-          handler2.value, self_->impl_.get_executor());
-    }
-
-  private:
-    basic_stream_handle* self_;
-  };
-};
-
-} // namespace windows
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/object_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/object_handle.hpp
deleted file mode 100644
index 243d945..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/object_handle.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// windows/object_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_OBJECT_HANDLE_HPP
-#define ASIO_WINDOWS_OBJECT_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/windows/basic_object_handle.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of an object handle.
-typedef basic_object_handle<> object_handle;
-
-} // namespace windows
-} // namespace asio
-
-#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_OBJECT_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_handle.hpp
deleted file mode 100644
index fc12865..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_handle.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// windows/overlapped_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
-#define ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
-  || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/windows/basic_overlapped_handle.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of an overlapped handle.
-typedef basic_overlapped_handle<> overlapped_handle;
-
-} // namespace windows
-} // namespace asio
-
-#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-       //   || defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_OVERLAPPED_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_ptr.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_ptr.hpp
deleted file mode 100644
index e1e6f8c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/overlapped_ptr.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//
-// windows/overlapped_ptr.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_OVERLAPPED_PTR_HPP
-#define ASIO_WINDOWS_OVERLAPPED_PTR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/win_iocp_overlapped_ptr.hpp"
-#include "asio/io_context.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
-/**
- * A special-purpose smart pointer used to wrap an application handler so that
- * it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-class overlapped_ptr
-  : private noncopyable
-{
-public:
-  /// Construct an empty overlapped_ptr.
-  overlapped_ptr()
-    : impl_()
-  {
-  }
-
-  /// Construct an overlapped_ptr to contain the specified handler.
-  template <typename ExecutionContext, typename Handler>
-  explicit overlapped_ptr(ExecutionContext& context,
-      Handler&& handler,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-    : impl_(context.get_executor(), static_cast<Handler&&>(handler))
-  {
-  }
-
-  /// Construct an overlapped_ptr to contain the specified handler.
-  template <typename Executor, typename Handler>
-  explicit overlapped_ptr(const Executor& ex,
-      Handler&& handler,
-      constraint_t<
-        execution::is_executor<Executor>::value
-          || is_executor<Executor>::value
-      > = 0)
-    : impl_(ex, static_cast<Handler&&>(handler))
-  {
-  }
-
-  /// Destructor automatically frees the OVERLAPPED object unless released.
-  ~overlapped_ptr()
-  {
-  }
-
-  /// Reset to empty.
-  void reset()
-  {
-    impl_.reset();
-  }
-
-  /// Reset to contain the specified handler, freeing any current OVERLAPPED
-  /// object.
-  template <typename ExecutionContext, typename Handler>
-  void reset(ExecutionContext& context, Handler&& handler,
-      constraint_t<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      > = 0)
-  {
-    impl_.reset(context.get_executor(), static_cast<Handler&&>(handler));
-  }
-
-  /// Reset to contain the specified handler, freeing any current OVERLAPPED
-  /// object.
-  template <typename Executor, typename Handler>
-  void reset(const Executor& ex, Handler&& handler,
-      constraint_t<
-        execution::is_executor<Executor>::value
-          || is_executor<Executor>::value
-      > = 0)
-  {
-    impl_.reset(ex, static_cast<Handler&&>(handler));
-  }
-
-  /// Get the contained OVERLAPPED object.
-  OVERLAPPED* get()
-  {
-    return impl_.get();
-  }
-
-  /// Get the contained OVERLAPPED object.
-  const OVERLAPPED* get() const
-  {
-    return impl_.get();
-  }
-
-  /// Release ownership of the OVERLAPPED object.
-  OVERLAPPED* release()
-  {
-    return impl_.release();
-  }
-
-  /// Post completion notification for overlapped operation. Releases ownership.
-  void complete(const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    impl_.complete(ec, bytes_transferred);
-  }
-
-private:
-  detail::win_iocp_overlapped_ptr impl_;
-};
-
-} // namespace windows
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_OVERLAPPED_PTR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/random_access_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/random_access_handle.hpp
deleted file mode 100644
index 88dfa36..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/random_access_handle.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// windows/random_access_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
-#define ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/windows/basic_random_access_handle.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of a random-access handle.
-typedef basic_random_access_handle<> random_access_handle;
-
-} // namespace windows
-} // namespace asio
-
-#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/stream_handle.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/stream_handle.hpp
deleted file mode 100644
index 4b88b8c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/windows/stream_handle.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// windows/stream_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WINDOWS_STREAM_HANDLE_HPP
-#define ASIO_WINDOWS_STREAM_HANDLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/windows/basic_stream_handle.hpp"
-
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of a stream-oriented handle.
-typedef basic_stream_handle<> stream_handle;
-
-} // namespace windows
-} // namespace asio
-
-#endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WINDOWS_STREAM_HANDLE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/writable_pipe.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/writable_pipe.hpp
deleted file mode 100644
index 27f408a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/writable_pipe.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// writable_pipe.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WRITABLE_PIPE_HPP
-#define ASIO_WRITABLE_PIPE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_PIPE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include "asio/basic_writable_pipe.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of a writable pipe.
-typedef basic_writable_pipe<> writable_pipe;
-
-} // namespace asio
-
-#endif // defined(ASIO_HAS_PIPE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_WRITABLE_PIPE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write.hpp
deleted file mode 100644
index 90bdabe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write.hpp
+++ /dev/null
@@ -1,1526 +0,0 @@
-//
-// write.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WRITE_HPP
-#define ASIO_WRITE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS)
-# include "asio/basic_streambuf_fwd.hpp"
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_write;
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_write_dynbuf_v1;
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-template <typename> class initiate_async_write_dynbuf_v2;
-
-} // namespace detail
-
-/**
- * @defgroup write asio::write
- *
- * @brief The @c write function is a composed operation that writes a certain
- * amount of data to a stream before returning.
- */
-/*@{*/
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * stream.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write(s, asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncWriteStream, typename ConstBufferSequence>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0);
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * stream.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write(s, asio::buffer(data, size), ec); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename ConstBufferSequence>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * stream.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write(s, asio::buffer(data, size),
- *     asio::transfer_at_least(32)); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * stream.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncWriteStream, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v1>
-std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v1>
-std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v1,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s,
-    DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, b,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncWriteStream, typename Allocator>
-std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, b,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename Allocator>
-std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    asio::error_code& ec);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncWriteStream, typename Allocator,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncWriteStream, typename Allocator,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v2>
-std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Write all of the supplied data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write(
- *     s, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v2>
-std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data to a stream before returning.
-/**
- * This function is used to write a certain number of bytes of data to a stream.
- * The call will block until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Successfully written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's write_some function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncWriteStream, typename DynamicBuffer_v2,
-    typename CompletionCondition>
-std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/*@}*/
-/**
- * @defgroup async_write asio::async_write
- *
- * @brief The @c async_write function is a composed asynchronous operation that
- * writes a certain amount of data to a stream before completion.
- */
-/*@{*/
-
-/// Start an asynchronous operation to write all of the supplied data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::async_write(s, asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream, typename ConstBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<decay_t<WriteToken>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write<AsyncWriteStream>>(),
-        token, buffers, transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write<AsyncWriteStream>(s),
-      token, buffers, transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's async_write_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::async_write(s,
- *     asio::buffer(data, size),
- *     asio::transfer_at_least(32),
- *     handler); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
-   *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream,
-    typename ConstBufferSequence, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_const_buffer_sequence<ConstBufferSequence>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write<AsyncWriteStream>>(),
-        token, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write<AsyncWriteStream>(s),
-      token, buffers,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to write all of the supplied data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called. Successfully
- * written data is automatically consumed from the buffers.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream, typename DynamicBuffer_v1,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<decay_t<WriteToken>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers),
-        transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers),
-      transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called. Successfully
- * written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's async_write_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream,
-    typename DynamicBuffer_v1, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers,
-    CompletionCondition completion_condition,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
-        token, static_cast<DynamicBuffer_v1&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
-      token, static_cast<DynamicBuffer_v1&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Start an asynchronous operation to write all of the supplied data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param b A basic_streambuf object from which data will be written. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      !is_completion_condition<decay_t<WriteToken>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
-        token, basic_streambuf_ref<Allocator>(b), transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
-      token, basic_streambuf_ref<Allocator>(b), transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param b A basic_streambuf object from which data will be written. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's async_write_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream,
-    typename Allocator, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(),
-        token, basic_streambuf_ref<Allocator>(b),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s),
-      token, basic_streambuf_ref<Allocator>(b),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-/// Start an asynchronous operation to write all of the supplied data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called. Successfully
- * written data is automatically consumed from the buffers.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream, typename DynamicBuffer_v2,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      !is_completion_condition<decay_t<WriteToken>>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers),
-        transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers),
-      transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data to a
-/// stream.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a stream. It is an initiating function for an @ref
- * asynchronous_operation, and always returns immediately. The asynchronous
- * operation will continue until one of the following conditions is true:
- *
- * @li All of the data in the supplied dynamic buffer sequence has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * async_write_some function, and is known as a <em>composed operation</em>. The
- * program must ensure that the stream performs no other write operations (such
- * as async_write, the stream's async_write_some function, or any other composed
- * operations that perform writes) until this operation completes.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the AsyncWriteStream concept.
- *
- * @param buffers The dynamic buffer sequence from which data will be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called. Successfully
- * written data is automatically consumed from the buffers.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the stream's async_write_some function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncWriteStream type's
- * @c async_write_some operation.
- */
-template <typename AsyncWriteStream,
-    typename DynamicBuffer_v2, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken
-        = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers,
-    CompletionCondition completion_condition,
-    WriteToken&& token
-      = default_completion_token_t<typename AsyncWriteStream::executor_type>(),
-    constraint_t<
-      is_dynamic_buffer_v2<DynamicBuffer_v2>::value
-    > = 0,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(),
-        token, static_cast<DynamicBuffer_v2&&>(buffers),
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s),
-      token, static_cast<DynamicBuffer_v2&&>(buffers),
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/write.hpp"
-
-#endif // ASIO_WRITE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write_at.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write_at.hpp
deleted file mode 100644
index ee52aa1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/write_at.hpp
+++ /dev/null
@@ -1,841 +0,0 @@
-//
-// write_at.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_WRITE_AT_HPP
-#define ASIO_WRITE_AT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/async_result.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/detail/cstdint.hpp"
-#include "asio/error.hpp"
-
-#if !defined(ASIO_NO_EXTENSIONS)
-# include "asio/basic_streambuf_fwd.hpp"
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename> class initiate_async_write_at;
-#if !defined(ASIO_NO_IOSTREAM)
-template <typename> class initiate_async_write_at_streambuf;
-#endif // !defined(ASIO_NO_IOSTREAM)
-
-} // namespace detail
-
-/**
- * @defgroup write_at asio::write_at
- *
- * @brief The @c write_at function is a composed operation that writes a
- * certain amount of data at a specified offset before returning.
- */
-/*@{*/
-
-/// Write all of the supplied data at the specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * device.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write_at(d, 42, asio::buffer(data, size)); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write_at(
- *     d, offset, buffers,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers);
-
-/// Write all of the supplied data at the specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * device.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write_at(d, 42,
- *     asio::buffer(data, size), ec); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write_at(
- *     d, offset, buffers,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    asio::error_code& ec);
-
-/// Write a certain amount of data at a specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * device.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's write_some_at function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::write_at(d, 42, asio::buffer(data, size),
- *     asio::transfer_at_least(32)); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- */
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data at a specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * device.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's write_some_at function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Write all of the supplied data at the specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write_at(
- *     d, 42, b,
- *     asio::transfer_all()); @endcode
- */
-template <typename SyncRandomAccessWriteDevice, typename Allocator>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b);
-
-/// Write all of the supplied data at the specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code asio::write_at(
- *     d, 42, b,
- *     asio::transfer_all(), ec); @endcode
- */
-template <typename SyncRandomAccessWriteDevice, typename Allocator>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    asio::error_code& ec);
-
-/// Write a certain amount of data at a specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's write_some_at function.
- *
- * @returns The number of bytes transferred.
- *
- * @throws asio::system_error Thrown on failure.
- */
-template <typename SyncRandomAccessWriteDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
-    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-/// Write a certain amount of data at a specified offset before returning.
-/**
- * This function is used to write a certain number of bytes of data to a random
- * access device at a specified offset. The call will block until one of the
- * following conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's write_some_at function.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes written. If an error occurs, returns the total
- * number of bytes successfully transferred prior to the error.
- */
-template <typename SyncRandomAccessWriteDevice, typename Allocator,
-    typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition, asio::error_code& ec,
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0);
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-/**
- * @defgroup async_write_at asio::async_write_at
- *
- * @brief The @c async_write_at function is a composed asynchronous operation
- * that writes a certain amount of data at the specified offset before
- * completion.
- */
-/*@{*/
-
-/// Start an asynchronous operation to write all of the supplied data at the
-/// specified offset.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. It is an initiating
- * function for an @ref asynchronous_operation, and always returns immediately.
- * The asynchronous operation will continue until one of the following
- * conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function, and is known as a <em>composed operation</em>.
- * The program must ensure that the device performs no <em>overlapping</em>
- * write operations (such as async_write_at, the device's async_write_some_at
- * function, or any other composed operations that perform writes) until this
- * operation completes. Operations are overlapping if the regions defined by
- * their offsets, and the numbers of bytes to write, intersect.
- *
- * @param d The device to which the data is to be written. The type must support
- * the AsyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code
- * asio::async_write_at(d, 42, asio::buffer(data, size), handler);
- * @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
- * async_write_some_at operation.
- */
-template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken = default_completion_token_t<
-        typename AsyncRandomAccessWriteDevice::executor_type>>
-inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>(),
-    constraint_t<
-      !is_completion_condition<WriteToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_at<
-          AsyncRandomAccessWriteDevice>>(),
-        token, offset, buffers, transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_at<AsyncRandomAccessWriteDevice>(d),
-      token, offset, buffers, transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. It is an initiating
- * function for an @ref asynchronous_operation, and always returns immediately.
- * The asynchronous operation will continue until one of the following
- * conditions is true:
- *
- * @li All of the data in the supplied buffers has been written. That is, the
- * bytes transferred is equal to the sum of the buffer sizes.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function, and is known as a <em>composed operation</em>.
- * The program must ensure that the device performs no <em>overlapping</em>
- * write operations (such as async_write_at, the device's async_write_some_at
- * function, or any other composed operations that perform writes) until this
- * operation completes. Operations are overlapping if the regions defined by
- * their offsets, and the numbers of bytes to write, intersect.
- *
- * @param d The device to which the data is to be written. The type must support
- * the AsyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written.
- * Although the buffers object may be copied as necessary, ownership of the
- * underlying memory blocks is retained by the caller, which must guarantee
- * that they remain valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's async_write_some_at function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code asio::async_write_at(d, 42,
- *     asio::buffer(data, size),
- *     asio::transfer_at_least(32),
- *     handler); @endcode
- * See the @ref buffer documentation for information on writing multiple
- * buffers in one go, and how to use it with arrays, boost::array or
- * std::vector.
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
- * async_write_some_at operation.
- */
-template <typename AsyncRandomAccessWriteDevice,
-    typename ConstBufferSequence, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken = default_completion_token_t<
-        typename AsyncRandomAccessWriteDevice::executor_type>>
-inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
-    uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_at<
-          AsyncRandomAccessWriteDevice>>(),
-        token, offset, buffers,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_at<AsyncRandomAccessWriteDevice>(d),
-      token, offset, buffers,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#if !defined(ASIO_NO_EXTENSIONS)
-#if !defined(ASIO_NO_IOSTREAM)
-
-/// Start an asynchronous operation to write all of the supplied data at the
-/// specified offset.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. It is an initiating
- * function for an @ref asynchronous_operation, and always returns immediately.
- * The asynchronous operation will continue until one of the following
- * conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function, and is known as a <em>composed operation</em>.
- * The program must ensure that the device performs no <em>overlapping</em>
- * write operations (such as async_write_at, the device's async_write_some_at
- * function, or any other composed operations that perform writes) until this
- * operation completes. Operations are overlapping if the regions defined by
- * their offsets, and the numbers of bytes to write, intersect.
- *
- * @param d The device to which the data is to be written. The type must support
- * the AsyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b A basic_streambuf object from which data will be written. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
- * async_write_some_at operation.
- */
-template <typename AsyncRandomAccessWriteDevice, typename Allocator,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken = default_completion_token_t<
-        typename AsyncRandomAccessWriteDevice::executor_type>>
-inline auto async_write_at(AsyncRandomAccessWriteDevice& d,
-    uint64_t offset, basic_streambuf<Allocator>& b,
-    WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>(),
-    constraint_t<
-      !is_completion_condition<WriteToken>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_at_streambuf<
-          AsyncRandomAccessWriteDevice>>(),
-        token, offset, &b, transfer_all()))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_at_streambuf<
-        AsyncRandomAccessWriteDevice>(d),
-      token, offset, &b, transfer_all());
-}
-
-/// Start an asynchronous operation to write a certain amount of data at the
-/// specified offset.
-/**
- * This function is used to asynchronously write a certain number of bytes of
- * data to a random access device at a specified offset. It is an initiating
- * function for an @ref asynchronous_operation, and always returns immediately.
- * The asynchronous operation will continue until one of the following
- * conditions is true:
- *
- * @li All of the data in the supplied basic_streambuf has been written.
- *
- * @li The completion_condition function object returns 0.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function, and is known as a <em>composed operation</em>.
- * The program must ensure that the device performs no <em>overlapping</em>
- * write operations (such as async_write_at, the device's async_write_some_at
- * function, or any other composed operations that perform writes) until this
- * operation completes. Operations are overlapping if the regions defined by
- * their offsets, and the numbers of bytes to write, intersect.
- *
- * @param d The device to which the data is to be written. The type must support
- * the AsyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b A basic_streambuf object from which data will be written. Ownership
- * of the streambuf is retained by the caller, which must guarantee that it
- * remains valid until the completion handler is called.
- *
- * @param completion_condition The function object to be called to determine
- * whether the write operation is complete. The signature of the function object
- * must be:
- * @code std::size_t completion_condition(
- *   // Result of latest async_write_some_at operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes transferred so far.
- *   std::size_t bytes_transferred
- * ); @endcode
- * A return value of 0 indicates that the write operation is complete. A
- * non-zero return value indicates the maximum number of bytes to be written on
- * the next call to the device's async_write_some_at function.
- *
- * @param token The @ref completion_token that will be used to produce a
- * completion handler, which will be called when the write completes.
- * Potential completion tokens include @ref use_future, @ref use_awaitable,
- * @ref yield_context, or a function object with the correct completion
- * signature. The function signature of the completion handler must be:
- * @code void handler(
- *   // Result of operation.
- *   const asio::error_code& error,
- *
- *   // Number of bytes written from the buffers. If an error
- *   // occurred, this will be less than the sum of the buffer sizes.
- *   std::size_t bytes_transferred
- * ); @endcode
- * Regardless of whether the asynchronous operation completes immediately or
- * not, the completion handler will not be invoked from within this function.
- * On immediate completion, invocation of the handler will be performed in a
- * manner equivalent to using asio::async_immediate().
- *
- * @par Completion Signature
- * @code void(asio::error_code, std::size_t) @endcode
- *
- * @par Per-Operation Cancellation
- * This asynchronous operation supports cancellation for the following
- * asio::cancellation_type values:
- *
- * @li @c cancellation_type::terminal
- *
- * @li @c cancellation_type::partial
- *
- * if they are also supported by the @c AsyncRandomAccessWriteDevice type's
- * async_write_some_at operation.
- */
-template <typename AsyncRandomAccessWriteDevice,
-    typename Allocator, typename CompletionCondition,
-    ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
-      std::size_t)) WriteToken = default_completion_token_t<
-        typename AsyncRandomAccessWriteDevice::executor_type>>
-inline auto async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
-    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    WriteToken&& token = default_completion_token_t<
-      typename AsyncRandomAccessWriteDevice::executor_type>(),
-    constraint_t<
-      is_completion_condition<CompletionCondition>::value
-    > = 0)
-  -> decltype(
-    async_initiate<WriteToken,
-      void (asio::error_code, std::size_t)>(
-        declval<detail::initiate_async_write_at_streambuf<
-          AsyncRandomAccessWriteDevice>>(),
-        token, offset, &b,
-        static_cast<CompletionCondition&&>(completion_condition)))
-{
-  return async_initiate<WriteToken,
-    void (asio::error_code, std::size_t)>(
-      detail::initiate_async_write_at_streambuf<
-        AsyncRandomAccessWriteDevice>(d),
-      token, offset, &b,
-      static_cast<CompletionCondition&&>(completion_condition));
-}
-
-#endif // !defined(ASIO_NO_IOSTREAM)
-#endif // !defined(ASIO_NO_EXTENSIONS)
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/impl/write_at.hpp"
-
-#endif // ASIO_WRITE_AT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/yield.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/yield.hpp
deleted file mode 100644
index c180503..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/include/asio/yield.hpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//
-// yield.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "coroutine.hpp"
-
-#ifndef reenter
-# define reenter(c) ASIO_CORO_REENTER(c)
-#endif
-
-#ifndef yield
-# define yield ASIO_CORO_YIELD
-#endif
-
-#ifndef fork
-# define fork ASIO_CORO_FORK
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/release.pl b/third_party/socket.io-client-cpp/lib/asio/asio/release.pl
deleted file mode 100755
index 2ac3d01..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/release.pl
+++ /dev/null
@@ -1,418 +0,0 @@
-#!/usr/bin/perl -w
-
-use strict;
-use Cwd qw(abs_path getcwd);
-use Date::Format;
-use File::Path;
-use File::Copy;
-use File::Basename;
-
-our $version_major;
-our $version_minor;
-our $version_sub_minor;
-our $asio_name;
-our $boost_asio_name;
-
-sub print_usage_and_exit
-{
-  print("usage: ./release.pl <version>\n");
-  print("   or: ./release.pl --package-asio\n");
-  print("\n");
-  print("examples:\n");
-  print("  create new version and build packages for asio and boost.asio:\n");
-  print("    ./release.pl 1.2.0\n");
-  print("  create packages for asio only:\n");
-  print("    ./release.pl --package-asio\n");
-  exit(1);
-}
-
-sub determine_version($)
-{
-  my $version_string = shift;
-  if ($version_string =~ /^([0-9]+)\.([0-9]+)\.([0-9]+)$/)
-  {
-    our $version_major = $1;
-    our $version_minor = $2;
-    our $version_sub_minor = $3;
-
-    our $asio_name = "asio";
-    $asio_name .= "-$version_major";
-    $asio_name .= ".$version_minor";
-    $asio_name .= ".$version_sub_minor";
-
-    our $boost_asio_name = "boost_asio";
-    $boost_asio_name .= "_$version_major";
-    $boost_asio_name .= "_$version_minor";
-    $boost_asio_name .= "_$version_sub_minor";
-  }
-  else
-  {
-    print_usage_and_exit();
-  }
-}
-
-sub determine_version_from_configure()
-{
-  my $from = "configure.ac";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /^AC_INIT\(\[asio\],\[(.*)\]\)$/)
-    {
-      our $asio_name = "asio-$1";
-      our $boost_asio_name = "boost_asio_$1";
-      last;
-    }
-  }
-}
-
-sub update_configure_ac
-{
-  # Open the files.
-  my $from = "configure.ac";
-  my $to = $from . ".tmp";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # Copy the content.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /^AC_INIT\(\[asio\].*\)$/)
-    {
-      $line = "AC_INIT([asio],[";
-      $line .= "$version_major.$version_minor.$version_sub_minor";
-      $line .= "])";
-    }
-    print($output "$line\n");
-  }
-
-  # Close the files and move the temporary output into position.
-  close($input);
-  close($output);
-  move($to, $from);
-  unlink($to);
-}
-
-sub update_readme
-{
-  # Open the files.
-  my $from = "README";
-  my $to = $from . ".tmp";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # Copy the content.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /^asio version/)
-    {
-      $line = "asio version ";
-      $line .= "$version_major.$version_minor.$version_sub_minor";
-    }
-    elsif ($line =~ /^Released/)
-    {
-      my @time = localtime;
-      $line = "Released " . strftime("%A, %d %B %Y", @time) . ".";
-    }
-    print($output "$line\n");
-  }
-
-  # Close the files and move the temporary output into position.
-  close($input);
-  close($output);
-  move($to, $from);
-  unlink($to);
-}
-
-sub update_asio_version_hpp
-{
-  # Open the files.
-  my $from = "include/asio/version.hpp";
-  my $to = $from . ".tmp";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # Copy the content.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /^#define ASIO_VERSION /)
-    {
-      my $version = $version_major * 100000;
-      $version += $version_minor * 100;
-      $version += $version_sub_minor + 0;
-      $line = "#define ASIO_VERSION " . $version;
-      $line .= " // $version_major.$version_minor.$version_sub_minor";
-    }
-    print($output "$line\n");
-  }
-
-  # Close the files and move the temporary output into position.
-  close($input);
-  close($output);
-  move($to, $from);
-  unlink($to);
-}
-
-sub update_boost_asio_version_hpp
-{
-  # Open the files.
-  my $from = "../boost/boost/asio/version.hpp";
-  my $to = $from . ".tmp";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # Copy the content.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /^#define BOOST_ASIO_VERSION /)
-    {
-      my $version = $version_major * 100000;
-      $version += $version_minor * 100;
-      $version += $version_sub_minor + 0;
-      $line = "#define BOOST_ASIO_VERSION " . $version;
-      $line .= " // $version_major.$version_minor.$version_sub_minor";
-    }
-    print($output "$line\n");
-  }
-
-  # Close the files and move the temporary output into position.
-  close($input);
-  close($output);
-  move($to, $from);
-  unlink($to);
-}
-
-sub build_asio_doc
-{
-  $ENV{BOOST_ROOT} = abs_path("../boost");
-  system("rm -rf doc");
-  my $bjam = abs_path(glob("../boost/bjam"));
-  chdir("src/doc");
-  system("$bjam clean");
-  system("rm -rf html");
-  system("$bjam");
-  chdir("../..");
-  mkdir("doc");
-  system("cp -vR src/doc/html/* doc");
-}
-
-sub make_asio_packages
-{
-  our $asio_name;
-  system("./autogen.sh");
-  system("./configure");
-  system("make dist");
-  system("tar tfz $asio_name.tar.gz | sed -e 's/^[^\\/]*//' | sort -df > asio.manifest");
-}
-
-sub build_boost_asio_doc
-{
-  my $cwd = getcwd();
-  my $bjam = abs_path(glob("../boost/bjam"));
-  chdir("../boost/doc");
-  system("rm -rf html/boost_asio");
-  chdir("../libs/asio/doc");
-  system("$bjam clean");
-  system("$bjam asio");
-  chdir($cwd);
-}
-
-our $boost_asio_readme = <<"EOF";
-Copy the `boost', `doc' and `libs' directories into an existing boost 1.33.0,
-1.33.1, 1.34, 1.34.1, 1.35 or 1.36 distribution.
-
-Before using Boost.Asio, the Boost.System library needs to be built. This can
-be done by running bjam in the libs/system/build directory. Consult the Boost
-Getting Started page (http://www.boost.org/more/getting_started.html) for more
-information on how to build the Boost libraries.
-EOF
-
-our $boost_system_jamfile = <<"EOF";
-# Boost System Library Build Jamfile
-
-# (C) Copyright Beman Dawes 2002, 2006
-
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or www.boost.org/LICENSE_1_0.txt)
-
-# See library home page at http://www.boost.org/libs/system
-
-subproject libs/system/build ;
-
-SOURCES = error_code ;
-
-lib boost_system
-     : ../src/$(SOURCES).cpp
-     : # build requirements
-      <define>BOOST_SYSTEM_STATIC_LINK
-      <sysinclude>$(BOOST_AUX_ROOT) <sysinclude>$(BOOST_ROOT)
-      # common-variant-tag ensures that the library will
-      # be named according to the rules used by the install
-      # and auto-link features:
-      common-variant-tag 
-     : debug release  # build variants
-     ;
-
-dll boost_system
-     : ../src/$(SOURCES).cpp
-     : # build requirements
-       <define>BOOST_SYSTEM_DYN_LINK=1  # tell source we're building dll's
-       <runtime-link>dynamic  # build only for dynamic runtimes
-       <sysinclude>$(BOOST_AUX_ROOT) <sysinclude>$(BOOST_ROOT)
-      # common-variant-tag ensures that the library will
-      # be named according to the rules used by the install
-      # and auto-link features:
-      common-variant-tag 
-     : debug release  # build variants
-     ;
-
-install system lib
-     : <lib>boost_system <dll>boost_system
-     ;
-
-stage stage/lib : <lib>boost_system <dll>boost_system
-    :
-        # copy to a path rooted at BOOST_ROOT:
-        <locate>$(BOOST_ROOT)
-        # make sure the names of the libraries are correctly named:
-        common-variant-tag
-        # add this target to the "stage" and "all" psuedo-targets:
-        <target>stage
-        <target>all
-    :
-        debug release
-    ;
-
-# end
-EOF
-
-sub create_boost_asio_content
-{
-  # Create directory structure.
-  system("rm -rf $boost_asio_name");
-  mkdir("$boost_asio_name");
-  mkdir("$boost_asio_name/doc");
-  mkdir("$boost_asio_name/doc/html");
-  mkdir("$boost_asio_name/boost");
-  mkdir("$boost_asio_name/boost/config");
-  mkdir("$boost_asio_name/libs");
-
-  # Copy files.
-  system("cp -vLR ../boost/doc/html/boost_asio.html $boost_asio_name/doc/html");
-  system("cp -vLR ../boost/doc/html/boost_asio $boost_asio_name/doc/html");
-  system("cp -vLR ../boost/boost/asio.hpp $boost_asio_name/boost");
-  system("cp -vLR ../boost/boost/asio $boost_asio_name/boost");
-  system("cp -vLR ../boost/boost/cerrno.hpp $boost_asio_name/boost");
-  system("cp -vLR ../boost/boost/config/warning_disable.hpp $boost_asio_name/boost/config");
-  system("cp -vLR ../boost/boost/system $boost_asio_name/boost");
-  system("cp -vLR ../boost/libs/asio $boost_asio_name/libs");
-  system("cp -vLR ../boost/libs/system $boost_asio_name/libs");
-
-  # Remove modular boost include directories.
-  system("rm -rf $boost_asio_name/libs/asio/include");
-  system("rm -rf $boost_asio_name/libs/system/include");
-
-  # Add dummy definitions of BOOST_SYMBOL* to boost/system/config.hpp.
-  my $from = "$boost_asio_name/boost/system/config.hpp";
-  my $to = "$boost_asio_name/boost/system/config.hpp.new";
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-  while (my $line = <$input>)
-  {
-    print($output $line);
-    if ($line =~ /<boost\/config\.hpp>/)
-    {
-      print($output "\n// These #defines added by the separate Boost.Asio package.\n");
-      print($output "#if !defined(BOOST_SYMBOL_IMPORT)\n");
-      print($output "# if defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#  define BOOST_SYMBOL_IMPORT __declspec(dllimport)\n");
-      print($output "# else // defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#  define BOOST_SYMBOL_IMPORT\n");
-      print($output "# endif // defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#endif // !defined(BOOST_SYMBOL_IMPORT)\n");
-      print($output "#if !defined(BOOST_SYMBOL_EXPORT)\n");
-      print($output "# if defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#  define BOOST_SYMBOL_EXPORT __declspec(dllexport)\n");
-      print($output "# else // defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#  define BOOST_SYMBOL_EXPORT\n");
-      print($output "# endif // defined(BOOST_HAS_DECLSPEC)\n");
-      print($output "#endif // !defined(BOOST_SYMBOL_EXPORT)\n");
-      print($output "#if !defined(BOOST_SYMBOL_VISIBLE)\n");
-      print($output "# define BOOST_SYMBOL_VISIBLE\n");
-      print($output "#endif // !defined(BOOST_SYMBOL_VISIBLE)\n\n");
-    }
-  }
-  close($input);
-  close($output);
-  system("mv $to $from");
-
-  # Create readme.
-  $to = "$boost_asio_name/README.txt";
-  open($output, ">$to") or die("Can't open $to for writing");
-  print($output $boost_asio_readme);
-  close($output);
-
-  # Create Boost.System Jamfile.
-  $to = "$boost_asio_name/libs/system/build/Jamfile";
-  open($output, ">$to") or die("Can't open $to for writing");
-  print($output $boost_system_jamfile);
-  close($output);
-
-  # Remove SVN and git files.
-  system("find $boost_asio_name -name .svn -exec rm -rf {} \\;");
-  system("find $boost_asio_name -name .git -exec rm -rf {} \\;");
-  system("find $boost_asio_name -name .gitignore -exec rm -rf {} \\;");
-  system("find $boost_asio_name -name .gitattributes -exec rm -rf {} \\;");
-}
-
-sub make_boost_asio_packages
-{
-  our $boost_asio_name;
-  system("tar --format=pax -chf - $boost_asio_name | gzip -c >$boost_asio_name.tar.gz");
-  system("tar --format=pax -chf - $boost_asio_name | bzip2 -9 -c >$boost_asio_name.tar.bz2");
-  system("rm -f $boost_asio_name.zip");
-  system("zip -rq $boost_asio_name.zip $boost_asio_name");
-  system("rm -rf $boost_asio_name");
-  system("tar tfz $boost_asio_name.tar.gz | sed -e 's/^[^\\/]*//' | sort -df > boost_asio.manifest");
-}
-
-(scalar(@ARGV) == 1) or print_usage_and_exit();
-my $new_version = 1;
-my $package_asio = 1;
-my $package_boost = 1;
-if ($ARGV[0] eq "--package-asio")
-{
-  $new_version = 0;
-  $package_boost = 0;
-}
-
-if ($new_version)
-{
-  determine_version($ARGV[0]);
-  update_configure_ac();
-  update_readme();
-  update_asio_version_hpp();
-  update_boost_asio_version_hpp();
-}
-else
-{
-  determine_version_from_configure();
-}
-
-if ($package_asio)
-{
-#build_asio_doc();
-  make_asio_packages();
-}
-
-if ($package_boost)
-{
-  build_boost_asio_doc();
-  create_boost_asio_content();
-  make_boost_asio_packages();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/.gitignore
deleted file mode 100644
index 8a91ad8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-Makefile
-Makefile.in
-.deps
-*.a
-*.o
-*.obj
-*.lib
-*.pdb
-*.log
-*.trs
-*.dirstamp
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.am
deleted file mode 100644
index 587bb49..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.am
+++ /dev/null
@@ -1,39 +0,0 @@
-if HAVE_CXX11
-EXAMPLES_CPP11 = examples/cpp11
-endif
-
-if HAVE_CXX14
-EXAMPLES_CPP14 = examples/cpp14
-endif
-
-if HAVE_CXX17
-EXAMPLES_CPP17 = examples/cpp17
-endif
-
-if HAVE_CXX20
-EXAMPLES_CPP20 = examples/cpp20
-endif
-
-SUBDIRS = \
-	$(EXAMPLES_CPP11) \
-	$(EXAMPLES_CPP14) \
-	$(EXAMPLES_CPP17) \
-	$(EXAMPLES_CPP20) \
-	tests
-
-DIST_SUBDIRS = \
-	examples/cpp11 \
-	examples/cpp14 \
-	examples/cpp17 \
-	examples/cpp20 \
-	tests
-
-EXTRA_DIST = \
-	Makefile.mgw \
-	Makefile.msc \
-	tools/handlerlive.pl \
-	tools/handlertree.pl \
-	tools/handlerviz.pl
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.mgw b/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.mgw
deleted file mode 100644
index 05d9e84..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.mgw
+++ /dev/null
@@ -1,298 +0,0 @@
-SHELL=cmd
-
-ifndef BOOSTDIR
-BOOSTDIR = ../../boost_1_73_0
-endif
-
-ifdef OPTIMISED
-OPTIM_CXXFLAGS = -O2
-OPTIM_LDFLAGS = -O2
-else
-OPTIM_CXXFLAGS = -fno-inline
-OPTIM_LDFLAGS =
-endif
-
-ifndef STANDALONE
-BOOST_CXXFLAGS = -I$(BOOSTDIR) -DASIO_ENABLE_BOOST
-endif
-
-ifdef SEPARATE_COMPILATION
-SEPARATE_COMPILATION_LIB = libasio.a
-SEPARATE_COMPILATION_CXXFLAGS = \
-	-DASIO_SEPARATE_COMPILATION \
-	-DASIO_ENABLE_CANCELIO
-endif
-
-CXXFLAGS = -g -Wall -Wextra -mthreads -I../include \
-	$(OPTIM_CXXFLAGS) \
-	$(BOOST_CXXFLAGS) \
-	$(SEPARATE_COMPILATION_CXXFLAGS)
-LDFLAGS = -g -mthreads $(OPTIM_LDFLAGS)
-LIBS = $(SEPARATE_COMPILATION_LIB) -lws2_32 -lmswsock
-DEFINES = -D_WIN32_WINNT=0x0501
-
-PERFORMANCE_TEST_EXES = \
-	tests/performance/client.exe \
-	tests/performance/server.exe
-
-UNIT_TEST_EXES = \
-	tests/unit/any_completion_executor.exe \
-	tests/unit/any_completion_handler.exe \
-	tests/unit/any_io_executor.exe \
-	tests/unit/associated_allocator.exe \
-	tests/unit/associated_executor.exe \
-	tests/unit/async_result.exe \
-	tests/unit/awaitable.exe \
-	tests/unit/basic_datagram_socket.exe \
-	tests/unit/basic_deadline_timer.exe \
-	tests/unit/basic_raw_socket.exe \
-	tests/unit/basic_seq_packet_socket.exe \
-	tests/unit/basic_serial_port.exe \
-	tests/unit/basic_signal_set.exe \
-	tests/unit/basic_socket.exe \
-	tests/unit/basic_socket_acceptor.exe \
-	tests/unit/basic_stream_socket.exe \
-	tests/unit/basic_streambuf.exe \
-	tests/unit/basic_waitable_timer.exe \
-	tests/unit/bind_cancellation_slot.exe \
-	tests/unit/bind_executor.exe \
-	tests/unit/buffered_read_stream.exe \
-	tests/unit/buffered_stream.exe \
-	tests/unit/buffered_write_stream.exe \
-	tests/unit/buffer.exe \
-	tests/unit/buffers_iterator.exe \
-	tests/unit/cancel_after.exe \
-	tests/unit/cancel_at.exe \
-	tests/unit/cancellation_signal.exe \
-	tests/unit/cancellation_state.exe \
-	tests/unit/cancellation_type.exe \
-	tests/unit/co_spawn.exe \
-	tests/unit/completion_condition.exe \
-	tests/unit/compose.exe \
-	tests/unit/composed.exe \
-	tests/unit/connect.exe \
-	tests/unit/coroutine.exe \
-	tests/unit/deadline_timer.exe \
-	tests/unit/defer.exe \
-	tests/unit/detached.exe \
-	tests/unit/dispatch.exe \
-	tests/unit/error.exe \
-	tests/unit/execution_context.exe \
-	tests/unit/execution/any_executor.exe \
-	tests/unit/execution/blocking.exe \
-	tests/unit/execution/blocking_adaptation.exe \
-	tests/unit/execution/context_as.exe \
-	tests/unit/execution/executor.exe \
-	tests/unit/execution/invocable_archetype.exe \
-	tests/unit/execution/mapping.exe \
-	tests/unit/execution/outstanding_work.exe \
-	tests/unit/execution/prefer_only.exe \
-	tests/unit/execution/relationship.exe \
-	tests/unit/executor.exe \
-	tests/unit/executor_work_guard.exe \
-	tests/unit/generic/basic_endpoint.exe \
-	tests/unit/generic/datagram_protocol.exe \
-	tests/unit/generic/raw_protocol.exe \
-	tests/unit/generic/seq_packet_protocol.exe \
-	tests/unit/generic/stream_protocol.exe \
-	tests/unit/high_resolution_timer.exe \
-	tests/unit/immediate.exe \
-	tests/unit/io_context.exe \
-	tests/unit/io_context_strand.exe \
-	tests/unit/ip/address.exe \
-	tests/unit/ip/address_v4.exe \
-	tests/unit/ip/address_v4_iterator.exe \
-	tests/unit/ip/address_v4_range.exe \
-	tests/unit/ip/address_v6.exe \
-	tests/unit/ip/address_v6_iterator.exe \
-	tests/unit/ip/address_v6_range.exe \
-	tests/unit/ip/basic_endpoint.exe \
-	tests/unit/ip/basic_resolver.exe \
-	tests/unit/ip/basic_resolver_entry.exe \
-	tests/unit/ip/basic_resolver_iterator.exe \
-	tests/unit/ip/basic_resolver_query.exe \
-	tests/unit/ip/host_name.exe \
-	tests/unit/ip/icmp.exe \
-	tests/unit/ip/multicast.exe \
-	tests/unit/ip/network_v4.exe \
-	tests/unit/ip/network_v6.exe \
-	tests/unit/ip/resolver_query_base.exe \
-	tests/unit/ip/tcp.exe \
-	tests/unit/ip/udp.exe \
-	tests/unit/ip/unicast.exe \
-	tests/unit/ip/v6_only.exe \
-	tests/unit/is_read_buffered.exe \
-	tests/unit/is_write_buffered.exe \
-	tests/unit/packaged_task.exe \
-	tests/unit/placeholders.exe \
-	tests/unit/post.exe \
-	tests/unit/read.exe \
-	tests/unit/read_at.exe \
-	tests/unit/read_until.exe \
-	tests/unit/redirect_error.exe \
-	tests/unit/serial_port.exe \
-	tests/unit/serial_port_base.exe \
-	tests/unit/signal_set.exe \
-	tests/unit/socket_base.exe \
-	tests/unit/static_thread_pool.exe \
-	tests/unit/steady_timer.exe \
-	tests/unit/strand.exe \
-	tests/unit/streambuf.exe \
-	tests/unit/system_context.exe \
-	tests/unit/system_executor.exe \
-	tests/unit/system_timer.exe \
-	tests/unit/this_coro.exe \
-	tests/unit/thread.exe \
-	tests/unit/thread_pool.exe \
-	tests/unit/time_traits.exe \
-	tests/unit/ts/buffer.exe \
-	tests/unit/ts/executor.exe \
-	tests/unit/ts/internet.exe \
-	tests/unit/ts/io_context.exe \
-	tests/unit/ts/net.exe \
-	tests/unit/ts/netfwd.exe \
-	tests/unit/ts/socket.exe \
-	tests/unit/ts/timer.exe \
-	tests/unit/use_awaitable.exe \
-	tests/unit/use_future.exe \
-	tests/unit/uses_executor.exe \
-	tests/unit/wait_traits.exe \
-	tests/unit/windows/basic_object_handle.exe \
-	tests/unit/windows/basic_overlapped_handle.exe \
-	tests/unit/windows/basic_random_access_handle.exe \
-	tests/unit/windows/basic_stream_handle.exe \
-	tests/unit/windows/object_handle.exe \
-	tests/unit/windows/overlapped_handle.exe \
-	tests/unit/windows/overlapped_ptr.exe \
-	tests/unit/windows/random_access_handle.exe \
-	tests/unit/windows/stream_handle.exe \
-	tests/unit/write.exe \
-	tests/unit/write_at.exe
-
-CPP11_EXAMPLE_EXES = \
-	examples/cpp11/allocation/server.exe \
-	examples/cpp11/buffers/reference_counted.exe \
-	examples/cpp11/chat/chat_client.exe \
-	examples/cpp11/chat/chat_server.exe \
-	examples/cpp11/echo/async_tcp_echo_server.exe \
-	examples/cpp11/echo/async_udp_echo_server.exe \
-	examples/cpp11/echo/blocking_tcp_echo_client.exe \
-	examples/cpp11/echo/blocking_tcp_echo_server.exe \
-	examples/cpp11/echo/blocking_udp_echo_client.exe \
-	examples/cpp11/echo/blocking_udp_echo_server.exe \
-	examples/cpp11/http/client/async_client.exe \
-	examples/cpp11/http/client/sync_client.exe \
-	examples/cpp11/http/server/http_server.exe \
-	examples/cpp11/http/server2/http_server.exe \
-	examples/cpp11/http/server3/http_server.exe \
-	examples/cpp11/http/server4/http_server.exe \
-	examples/cpp11/icmp/ping.exe \
-	examples/cpp11/invocation/prioritised_handlers.exe \
-	examples/cpp11/iostreams/daytime_client.exe \
-	examples/cpp11/iostreams/daytime_server.exe \
-	examples/cpp11/iostreams/http_client.exe \
-	examples/cpp11/multicast/receiver.exe \
-	examples/cpp11/multicast/sender.exe \
-	examples/cpp11/nonblocking/third_party_lib.exe \
-	examples/cpp11/porthopper/client.exe \
-	examples/cpp11/porthopper/server.exe \
-	examples/cpp11/services/daytime_client.exe \
-	examples/cpp11/socks4/sync_client.exe \
-	examples/cpp11/timeouts/async_tcp_client.exe \
-	examples/cpp11/timeouts/blocking_tcp_client.exe \
-	examples/cpp11/timeouts/blocking_token_tcp_client.exe \
-	examples/cpp11/timeouts/blocking_udp_client.exe \
-	examples/cpp11/timeouts/server.exe \
-	examples/cpp11/timers/time_t_timer.exe \
-	examples/cpp11/tutorial/timer1/timer.exe \
-	examples/cpp11/tutorial/timer2/timer.exe \
-	examples/cpp11/tutorial/timer3/timer.exe \
-	examples/cpp11/tutorial/timer4/timer.exe \
-	examples/cpp11/tutorial/timer5/timer.exe \
-	examples/cpp11/tutorial/daytime1/client.exe \
-	examples/cpp11/tutorial/daytime2/server.exe \
-	examples/cpp11/tutorial/daytime3/server.exe \
-	examples/cpp11/tutorial/daytime4/client.exe \
-	examples/cpp11/tutorial/daytime5/server.exe \
-	examples/cpp11/tutorial/daytime6/server.exe \
-	examples/cpp11/tutorial/daytime7/server.exe \
-	examples/cpp11/windows/transmit_file.exe
-
-ifdef STANDALONE
-all: \
-	$(SEPARATE_COMPILATION_LIB) \
-	$(EXAMPLE_EXES) \
-	$(UNIT_TEST_EXES)
-else
-all: \
-	$(SEPARATE_COMPILATION_LIB) \
-	$(PERFORMANCE_TEST_EXES) \
-	$(EXAMPLE_EXES) \
-	$(OTHER_EXAMPLE_EXES) \
-	$(UNIT_TEST_EXES)
-endif
-
-ifdef SEPARATE_COMPILATION
-libasio.a: asio.o
-	ar ru libasio.a asio.o
-endif
-
-check: $(UNIT_TEST_EXES) $(addprefix run.,$(UNIT_TEST_EXES))
-
-$(addprefix run.,$(UNIT_TEST_EXES))::
-	@echo === Running $(@:run.%=%) ===
-	@$(@:run.%=%)
-	@echo.
-
-clean:
-	-del libasio.a asio.o
-	-del /q /s tests\*.exe
-	-del /q /s tests\*.o
-	-del /q /s examples\*.exe
-	-del /q /s examples\*.o
-
-$(UNIT_TEST_EXES): %.exe: %.o
-	g++ -o$@ $(LDFLAGS) $< $(LIBS)
-
-$(PERFORMANCE_TEST_EXES) $(EXAMPLE_EXES): %.exe: %.o
-	g++ -o$@ $(LDFLAGS) $< $(LIBS)
-
-examples/cpp11/http/server/http_server.exe: \
-		examples/cpp11/http/server/connection.o \
-		examples/cpp11/http/server/connection_manager.o \
-		examples/cpp11/http/server/main.o \
-		examples/cpp11/http/server/mime_types.o \
-		examples/cpp11/http/server/reply.o \
-		examples/cpp11/http/server/request_handler.o \
-		examples/cpp11/http/server/request_parser.o \
-		examples/cpp11/http/server/server.o
-	g++ -o$@ $(LDFLAGS) $^ $(LIBS)
-
-examples/cpp11/http/server2/http_server.exe: \
-		examples/cpp11/http/server2/connection.o \
-		examples/cpp11/http/server2/io_context_pool.o \
-		examples/cpp11/http/server2/main.o \
-		examples/cpp11/http/server2/mime_types.o \
-		examples/cpp11/http/server2/reply.o \
-		examples/cpp11/http/server2/request_handler.o \
-		examples/cpp11/http/server2/request_parser.o \
-		examples/cpp11/http/server2/server.o
-	g++ -o$@ $(LDFLAGS) $^ $(LIBS)
-
-examples/cpp11/http/server3/http_server.exe: \
-		examples/cpp11/http/server3/connection.o \
-		examples/cpp11/http/server3/main.o \
-		examples/cpp11/http/server3/mime_types.o \
-		examples/cpp11/http/server3/reply.o \
-		examples/cpp11/http/server3/request_handler.o \
-		examples/cpp11/http/server3/request_parser.o \
-		examples/cpp11/http/server3/server.o
-	g++ -o$@ $(LDFLAGS) $^ $(LIBS)
-
-examples/cpp11/services/daytime_client.exe: \
-		examples/cpp11/services/daytime_client.o \
-		examples/cpp11/services/logger_service.o
-	g++ -o$@ $(LDFLAGS) $^ $(LIBS)
-
-.cpp.o:
-	g++ -o$@ -c $(CXXFLAGS) $(DEFINES) $<
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.msc b/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.msc
deleted file mode 100644
index 51c1dd1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/Makefile.msc
+++ /dev/null
@@ -1,554 +0,0 @@
-!ifndef BOOSTDIR
-BOOSTDIR = ../../boost_1_34_1
-!endif
-
-COMMON_CXXFLAGS = -nologo -EHac -GR -I. -I../include
-
-!ifdef CXXLATEST
-STD_CXXFLAGS = -std:c++latest -permissive-
-!endif
-
-!ifdef WARNINGS
-WARNINGS_CXXFLAGS = -W4 -wd4512 -wd4447
-!endif
-
-!ifdef STATICRTL
-! ifdef DEBUG
-DEBUG_CXXFLAGS = -Zi -MTd
-! else
-DEBUG_CXXFLAGS = -O2 -MT
-! endif
-!else
-! ifdef DEBUG
-DEBUG_CXXFLAGS = -Zi -MDd
-! else
-DEBUG_CXXFLAGS = -O2 -MD
-! endif
-!endif
-
-!ifdef UNICODE
-UNICODE_CXXFLAGS = -DUNICODE -D_UNICODE
-!endif
-
-!ifdef TRACKING
-TRACKING_CXXFLAGS = -DASIO_ENABLE_HANDLER_TRACKING
-!endif
-
-!ifndef _WIN32_WINNT
-! ifdef STORE
-_WIN32_WINNT=0x0603
-! else
-_WIN32_WINNT=0x0601
-! endif
-!endif
-
-!ifdef WIN9X
-DEFINES = \
-	-DASIO_DISABLE_IOCP \
-	-D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!else
-! ifdef STORE
-DEFINES = \
-	-DWINAPI_FAMILY=WINAPI_FAMILY_PC_APP \
-	-DBOOST_ALL_NO_LIB -D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DUNICODE -D_UNICODE \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-! else
-!  ifdef WINRT
-DEFINES = \
-	-ZW -FI SDKDDKVer.h -FI winapifamily.h -DWINAPI_FAMILY=WINAPI_PARTITION_APP \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!  else
-DEFINES = \
-	-D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!  endif
-! endif
-!endif
-
-!ifdef SEPARATE_COMPILATION
-LIBS = asio.lib
-SEPARATE_COMPILATION_CXXFLAGS = \
-	-DASIO_SEPARATE_COMPILATION \
-	-DASIO_ENABLE_CANCELIO
-!endif
-
-!ifdef STANDALONE
-STANDALONE_CXXFLAGS = -DASIO_STANDALONE
-!else
-STANDALONE_CXXFLAGS = -I$(BOOSTDIR) -DASIO_ENABLE_BOOST
-!endif
-
-CXXFLAGS = \
-	$(COMMON_CXXFLAGS) \
-	$(STD_CXXFLAGS) \
-	$(WARNINGS_CXXFLAGS) \
-	$(DEBUG_CXXFLAGS) \
-	$(UNICODE_CXXFLAGS) \
-	$(TRACKING_CXXFLAGS) \
-	$(SEPARATE_COMPILATION_CXXFLAGS) \
-	$(STANDALONE_CXXFLAGS)
-
-!ifndef SSLDIR
-SSLDIR = ../../openssl-0.9.8g
-!endif
-
-SSL_CXXFLAGS = -I$(SSLDIR)/inc32
-
-SSL_LIBS = \
-	$(SSLDIR)/out32/libeay32.lib \
-	$(SSLDIR)/out32/ssleay32.lib \
-	user32.lib advapi32.lib gdi32.lib
-
-LATENCY_TEST_EXES = \
-	tests\latency\tcp_client.exe \
-	tests\latency\tcp_server.exe \
-	tests\latency\udp_client.exe \
-	tests\latency\udp_server.exe
-
-PERFORMANCE_TEST_EXES = \
-	tests\performance\client.exe \
-	tests\performance\server.exe
-
-UNIT_TEST_EXES = \
-	tests\unit\any_completion_executor.exe \
-	tests\unit\any_completion_handler.exe \
-	tests\unit\any_io_executor.exe \
-	tests\unit\append.exe \
-	tests\unit\as_tuple.exe \
-	tests\unit\associated_allocator.exe \
-	tests\unit\associated_cancellation_slot.exe \
-	tests\unit\associated_executor.exe \
-	tests\unit\associator.exe \
-	tests\unit\async_result.exe \
-	tests\unit\awaitable.exe \
-	tests\unit\basic_datagram_socket.exe \
-	tests\unit\basic_deadline_timer.exe \
-	tests\unit\basic_file.exe \
-	tests\unit\basic_random_access_file.exe \
-	tests\unit\basic_raw_socket.exe \
-	tests\unit\basic_readable_pipe.exe \
-	tests\unit\basic_seq_packet_socket.exe \
-	tests\unit\basic_serial_port.exe \
-	tests\unit\basic_signal_set.exe \
-	tests\unit\basic_socket.exe \
-	tests\unit\basic_socket_acceptor.exe \
-	tests\unit\basic_stream_file.exe \
-	tests\unit\basic_stream_socket.exe \
-	tests\unit\basic_streambuf.exe \
-	tests\unit\basic_waitable_timer.exe \
-	tests\unit\basic_writable_pipe.exe \
-	tests\unit\bind_allocator.exe \
-	tests\unit\bind_cancellation_slot.exe \
-	tests\unit\bind_executor.exe \
-	tests\unit\bind_immediate_executor.exe \
-	tests\unit\buffered_read_stream.exe \
-	tests\unit\buffered_stream.exe \
-	tests\unit\buffered_write_stream.exe \
-	tests\unit\buffer.exe \
-	tests\unit\buffer_registration.exe \
-	tests\unit\buffers_iterator.exe \
-	tests\unit\cancel_after.exe \
-	tests\unit\cancel_at.exe \
-	tests\unit\cancellation_signal.exe \
-	tests\unit\cancellation_state.exe \
-	tests\unit\cancellation_type.exe \
-	tests\unit\co_spawn.exe \
-	tests\unit\completion_condition.exe \
-	tests\unit\compose.exe \
-	tests\unit\composed.exe \
-	tests\unit\connect.exe \
-	tests\unit\connect_pipe.exe \
-	tests\unit\coroutine.exe \
-	tests\unit\deadline_timer.exe \
-	tests\unit\defer.exe \
-	tests\unit\deferred.exe \
-	tests\unit\detached.exe \
-	tests\unit\dispatch.exe \
-	tests\unit\error.exe \
-	tests\unit\execution_context.exe \
-	tests\unit\execution\any_executor.exe \
-	tests\unit\execution\blocking.exe \
-	tests\unit\execution\blocking_adaptation.exe \
-	tests\unit\execution\context_as.exe \
-	tests\unit\execution\executor.exe \
-	tests\unit\execution\invocable_archetype.exe \
-	tests\unit\execution\mapping.exe \
-	tests\unit\execution\outstanding_work.exe \
-	tests\unit\execution\prefer_only.exe \
-	tests\unit\execution\relationship.exe \
-	tests\unit\executor.exe \
-	tests\unit\executor_work_guard.exe \
-	tests\unit\file_base.exe \
-	tests\unit\generic\basic_endpoint.exe \
-	tests\unit\generic\datagram_protocol.exe \
-	tests\unit\generic\raw_protocol.exe \
-	tests\unit\generic\seq_packet_protocol.exe \
-	tests\unit\generic\stream_protocol.exe \
-	tests\unit\high_resolution_timer.exe \
-	tests\unit\immediate.exe \
-	tests\unit\io_context.exe \
-	tests\unit\io_context_strand.exe \
-	tests\unit\ip\address.exe \
-	tests\unit\ip\address_v4.exe \
-	tests\unit\ip\address_v4_iterator.exe \
-	tests\unit\ip\address_v4_range.exe \
-	tests\unit\ip\address_v6.exe \
-	tests\unit\ip\address_v6_iterator.exe \
-	tests\unit\ip\address_v6_range.exe \
-	tests\unit\ip\basic_endpoint.exe \
-	tests\unit\ip\basic_resolver.exe \
-	tests\unit\ip\basic_resolver_entry.exe \
-	tests\unit\ip\basic_resolver_iterator.exe \
-	tests\unit\ip\basic_resolver_query.exe \
-	tests\unit\ip\host_name.exe \
-	tests\unit\ip\icmp.exe \
-	tests\unit\ip\multicast.exe \
-	tests\unit\ip\network_v4.exe \
-	tests\unit\ip\network_v6.exe \
-	tests\unit\ip\resolver_query_base.exe \
-	tests\unit\ip\tcp.exe \
-	tests\unit\ip\udp.exe \
-	tests\unit\ip\unicast.exe \
-	tests\unit\ip\v6_only.exe \
-	tests\unit\local\basic_endpoint.exe \
-	tests\unit\local\connect_pair.exe \
-	tests\unit\local\datagram_protocol.exe \
-	tests\unit\local\stream_protocol.exe \
-	tests\unit\is_read_buffered.exe \
-	tests\unit\is_write_buffered.exe \
-	tests\unit\packaged_task.exe \
-	tests\unit\placeholders.exe \
-	tests\unit\post.exe \
-	tests\unit\prepend.exe \
-	tests\unit\random_access_file.exe \
-	tests\unit\read.exe \
-	tests\unit\read_at.exe \
-	tests\unit\read_until.exe \
-	tests\unit\readable_pipe.exe \
-	tests\unit\recycling_allocator.exe \
-	tests\unit\redirect_error.exe \
-	tests\unit\registered_buffer.exe \
-	tests\unit\serial_port.exe \
-	tests\unit\serial_port_base.exe \
-	tests\unit\signal_set.exe \
-	tests\unit\signal_set_base.exe \
-	tests\unit\socket_base.exe \
-	tests\unit\static_thread_pool.exe \
-	tests\unit\steady_timer.exe \
-	tests\unit\strand.exe \
-	tests\unit\stream_file.exe \
-	tests\unit\streambuf.exe \
-	tests\unit\system_context.exe \
-	tests\unit\system_executor.exe \
-	tests\unit\system_timer.exe \
-	tests\unit\this_coro.exe \
-	tests\unit\thread.exe \
-	tests\unit\thread_pool.exe \
-	tests\unit\time_traits.exe \
-	tests\unit\ts\buffer.exe \
-	tests\unit\ts\executor.exe \
-	tests\unit\ts\internet.exe \
-	tests\unit\ts\io_context.exe \
-	tests\unit\ts\net.exe \
-	tests\unit\ts\netfwd.exe \
-	tests\unit\ts\socket.exe \
-	tests\unit\ts\timer.exe \
-	tests\unit\use_awaitable.exe \
-	tests\unit\use_future.exe \
-	tests\unit\uses_executor.exe \
-	tests\unit\wait_traits.exe \
-	tests\unit\windows\basic_object_handle.exe \
-	tests\unit\windows\basic_overlapped_handle.exe \
-	tests\unit\windows\basic_random_access_handle.exe \
-	tests\unit\windows\basic_stream_handle.exe \
-	tests\unit\windows\object_handle.exe \
-	tests\unit\windows\overlapped_handle.exe \
-	tests\unit\windows\overlapped_ptr.exe \
-	tests\unit\windows\random_access_handle.exe \
-	tests\unit\windows\stream_handle.exe \
-	tests\unit\writable_pipe.exe \
-	tests\unit\write.exe \
-	tests\unit\write_at.exe
-
-CPP11_EXAMPLE_EXES = \
-	examples\cpp11\allocation\server.exe \
-	examples\cpp11\buffers\reference_counted.exe \
-	examples\cpp11\chat\chat_client.exe \
-	examples\cpp11\chat\chat_server.exe \
-	examples\cpp11\echo\async_tcp_echo_server.exe \
-	examples\cpp11\echo\async_udp_echo_server.exe \
-	examples\cpp11\echo\blocking_tcp_echo_client.exe \
-	examples\cpp11\echo\blocking_tcp_echo_server.exe \
-	examples\cpp11\echo\blocking_udp_echo_client.exe \
-	examples\cpp11\echo\blocking_udp_echo_server.exe \
-	examples\cpp11\http\client\async_client.exe \
-	examples\cpp11\http\client\sync_client.exe \
-	examples\cpp11\http\server\http_server.exe \
-	examples\cpp11\http\server2\http_server.exe \
-	examples\cpp11\http\server3\http_server.exe \
-	examples\cpp11\http\server4\http_server.exe \
-	examples\cpp11\icmp\ping.exe \
-	examples\cpp11\invocation\prioritised_handlers.exe \
-	examples\cpp11\iostreams\daytime_client.exe \
-	examples\cpp11\iostreams\daytime_server.exe \
-	examples\cpp11\iostreams\http_client.exe \
-	examples\cpp11\multicast\receiver.exe \
-	examples\cpp11\multicast\sender.exe \
-	examples\cpp11\nonblocking\third_party_lib.exe \
-	examples\cpp11\porthopper\client.exe \
-	examples\cpp11\porthopper\server.exe \
-	examples\cpp11\services\daytime_client.exe \
-	examples\cpp11\socks4\sync_client.exe \
-	examples\cpp11\timeouts\async_tcp_client.exe \
-	examples\cpp11\timeouts\blocking_tcp_client.exe \
-	examples\cpp11\timeouts\blocking_token_tcp_client.exe \
-	examples\cpp11\timeouts\blocking_udp_client.exe \
-	examples\cpp11\timeouts\server.exe \
-	examples\cpp11\timers\time_t_timer.exe \
-	examples\cpp11\tutorial\timer1\timer.exe \
-	examples\cpp11\tutorial\timer2\timer.exe \
-	examples\cpp11\tutorial\timer3\timer.exe \
-	examples\cpp11\tutorial\timer4\timer.exe \
-	examples\cpp11\tutorial\timer5\timer.exe \
-	examples\cpp11\tutorial\daytime1\client.exe \
-	examples\cpp11\tutorial\daytime2\server.exe \
-	examples\cpp11\tutorial\daytime3\server.exe \
-	examples\cpp11\tutorial\daytime4\client.exe \
-	examples\cpp11\tutorial\daytime5\server.exe \
-	examples\cpp11\tutorial\daytime6\server.exe \
-	examples\cpp11\tutorial\daytime7\server.exe \
-	examples\cpp11\windows\transmit_file.exe
-
-SSL_UNIT_TEST_EXES = \
-	tests\unit\ssl\basic_context.exe \
-	tests\unit\ssl\context.exe \
-	tests\unit\ssl\context_base.exe \
-	tests\unit\ssl\context_service.exe \
-	tests\unit\ssl\rfc2818_verification.exe \
-	tests\unit\ssl\stream.exe \
-	tests\unit\ssl\stream_base.exe \
-	tests\unit\ssl\stream_service.exe
-
-SSL_EXAMPLE_EXES = \
-	examples\cpp11\ssl\client.exe \
-	examples\cpp11\ssl\server.exe
-
-!ifdef SEPARATE_COMPILATION
-all: asio.lib
-asio.lib: asio.cpp
-	cl -Fe$@ -Foasio.obj $(CXXFLAGS) $(DEFINES) -c asio.cpp
-	lib -name:asio.lib asio.obj
-!endif
-
-!ifdef STANDALONE
-all: \
-	$(CPP11_EXAMPLE_EXES) \
-	$(UNIT_TEST_EXES)
-!else
-all: \
-	$(LATENCY_TEST_EXES) \
-	$(PERFORMANCE_TEST_EXES) \
-	$(CPP11_EXAMPLE_EXES) \
-	$(UNIT_TEST_EXES)
-!endif
-
-ssl: \
-	$(SSL_UNIT_TEST_EXES) \
-	$(SSL_EXAMPLE_EXES)
-
-check: $(UNIT_TEST_EXES)
-	!@echo === Running $** === && $** && echo.
-
-{tests\latency}.cpp{tests\latency}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\performance}.cpp{tests\performance}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-tests\unit\unit_test.obj: tests\unit\unit_test.cpp
-	cl -Fe$@ -Fotests\unit\unit_test.obj $(CXXFLAGS) $(DEFINES) -c tests\unit\unit_test.cpp
-
-{tests\unit}.cpp{tests\unit}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\execution}.cpp{tests\unit\execution}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\generic}.cpp{tests\unit\generic}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\ip}.cpp{tests\unit\ip}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\local}.cpp{tests\unit\local}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\ssl}.cpp{tests\unit\ssl}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(SSL_CXXFLAGS) $(DEFINES) $< $(SSL_LIBS) $(LIBS) -link -opt:ref
-
-{tests\unit\ts}.cpp{tests\unit\ts}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{tests\unit\windows}.cpp{tests\unit\windows}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\allocation}.cpp{examples\cpp11\allocation}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\buffers}.cpp{examples\cpp11\buffers}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\chat}.cpp{examples\cpp11\chat}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\echo}.cpp{examples\cpp11\echo}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\http\client}.cpp{examples\cpp11\http\client}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\icmp}.cpp{examples\cpp11\icmp}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\invocation}.cpp{examples\cpp11\invocation}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\iostreams}.cpp{examples\cpp11\iostreams}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\multicast}.cpp{examples\cpp11\multicast}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\nonblocking}.cpp{examples\cpp11\nonblocking}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\porthopper}.cpp{examples\cpp11\porthopper}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\socks4}.cpp{examples\cpp11\socks4}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\ssl}.cpp{examples\cpp11\ssl}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(SSL_CXXFLAGS) $(DEFINES) $< $(SSL_LIBS) $(LIBS) -link -opt:ref
-
-{examples\cpp11\timeouts}.cpp{examples\cpp11\timeouts}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\timers}.cpp{examples\cpp11\timers}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\timer1}.cpp{examples\cpp11\tutorial\timer1}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\timer2}.cpp{examples\cpp11\tutorial\timer2}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\timer3}.cpp{examples\cpp11\tutorial\timer3}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\timer4}.cpp{examples\cpp11\tutorial\timer4}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\timer5}.cpp{examples\cpp11\tutorial\timer5}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime1}.cpp{examples\cpp11\tutorial\daytime1}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime2}.cpp{examples\cpp11\tutorial\daytime2}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime3}.cpp{examples\cpp11\tutorial\daytime3}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime4}.cpp{examples\cpp11\tutorial\daytime4}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime5}.cpp{examples\cpp11\tutorial\daytime5}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime6}.cpp{examples\cpp11\tutorial\daytime6}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\tutorial\daytime7}.cpp{examples\cpp11\tutorial\daytime7}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\windows}.cpp{examples\cpp11\windows}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\executors}.cpp{examples\cpp11\executors}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp11\operations}.cpp{examples\cpp11\operations}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{examples\cpp14\operations}.cpp{examples\cpp14\operations}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-examples\cpp11\http\server\http_server.exe: \
-		examples\cpp11\http\server\connection.cpp \
-		examples\cpp11\http\server\connection_manager.cpp \
-		examples\cpp11\http\server\main.cpp \
-		examples\cpp11\http\server\mime_types.cpp \
-		examples\cpp11\http\server\reply.cpp \
-		examples\cpp11\http\server\request_handler.cpp \
-		examples\cpp11\http\server\request_parser.cpp \
-		examples\cpp11\http\server\server.cpp
-	cl -Fe$@ -Foexamples\cpp11\http\server\ $(CXXFLAGS) $(DEFINES) $** $(LIBS) -link -opt:ref
-
-examples\cpp11\http\server2\http_server.exe: \
-		examples\cpp11\http\server2\connection.cpp \
-		examples\cpp11\http\server2\io_context_pool.cpp \
-		examples\cpp11\http\server2\main.cpp \
-		examples\cpp11\http\server2\mime_types.cpp \
-		examples\cpp11\http\server2\reply.cpp \
-		examples\cpp11\http\server2\request_handler.cpp \
-		examples\cpp11\http\server2\request_parser.cpp \
-		examples\cpp11\http\server2\server.cpp
-	cl -Fe$@ -Foexamples\cpp11\http\server2\ $(CXXFLAGS) $(DEFINES) $** $(LIBS) -link -opt:ref
-
-examples\cpp11\http\server3\http_server.exe: \
-		examples\cpp11\http\server3\connection.cpp \
-		examples\cpp11\http\server3\main.cpp \
-		examples\cpp11\http\server3\mime_types.cpp \
-		examples\cpp11\http\server3\reply.cpp \
-		examples\cpp11\http\server3\request_handler.cpp \
-		examples\cpp11\http\server3\request_parser.cpp \
-		examples\cpp11\http\server3\server.cpp
-	cl -Fe$@ -Foexamples\cpp11\http\server3\ $(CXXFLAGS) $(DEFINES) $** $(LIBS) -link -opt:ref
-
-examples\cpp11\http\server4\http_server.exe: \
-		examples\cpp11\http\server4\file_handler.cpp \
-		examples\cpp11\http\server4\main.cpp \
-		examples\cpp11\http\server4\mime_types.cpp \
-		examples\cpp11\http\server4\reply.cpp \
-		examples\cpp11\http\server4\request_parser.cpp \
-		examples\cpp11\http\server4\server.cpp
-	cl -Fe$@ -Foexamples\cpp11\http\server4\ $(CXXFLAGS) $(DEFINES) $** $(LIBS) -link -opt:ref
-
-examples\cpp11\services\daytime_client.exe: \
-		examples\cpp11\services\daytime_client.cpp \
-		examples\cpp11\services\logger_service.cpp
-	cl -Fe$@ -Foexamples\cpp11\services\ $(CXXFLAGS) $(DEFINES) $** $(LIBS) -link -opt:ref
-
-clean:
-	-del /q /s asio.lib
-	-del /q /s asio.obj
-	-del /q /s tests\*.exe
-	-del /q /s tests\*.exe.manifest
-	-del /q /s tests\*.exp
-	-del /q /s tests\*.ilk
-	-del /q /s tests\*.pdb
-	-del /q /s tests\*.obj
-	-del /q /s examples\*.exe
-	-del /q /s examples\*.exe.manifest
-	-del /q /s examples\*.exp
-	-del /q /s examples\*.ilk
-	-del /q /s examples\*.pdb
-	-del /q /s examples\*.obj
-	-del /q /s *.pdb
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/asio.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/asio.cpp
deleted file mode 100644
index bd919af..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/asio.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-// asio.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/impl/src.hpp"
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/asio_ssl.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/asio_ssl.cpp
deleted file mode 100644
index 6a5a626..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/asio_ssl.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-// asio_ssl.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/ssl/impl/src.hpp"
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/.gitignore
deleted file mode 100644
index 32e513a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-bin
-html
-reference.tags
-asio.docbook
-*.pdf
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/Jamfile.v2 b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/Jamfile.v2
deleted file mode 100644
index d9ec1fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/Jamfile.v2
+++ /dev/null
@@ -1,81 +0,0 @@
-#
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-project asio-doc ;
-
-import os ;
-local boost = [ os.environ BOOST_ROOT ] ;
-
-using quickbook ;
-
-xml asio : asio.qbk ;
-
-boostbook standalone
-  :
-    asio
-  :
-    <xsl:param>boost.image.src=asio.png
-    <xsl:param>boost.image.alt="asio C++ library"
-    <xsl:param>boost.image.w=250
-    <xsl:param>boost.image.h=60
-    <xsl:param>nav.layout=none
-    <xsl:param>navig.graphics.path=""
-    <xsl:param>admon.graphics.path=""
-    <xsl:param>callout.graphics.path=""
-    <xsl:param>chapter.autolabel=0
-    <xsl:param>chunk.section.depth=8
-    <xsl:param>chunk.first.sections=1
-    <xsl:param>toc.section.depth=2
-    <xsl:param>toc.max.depth=1
-    <xsl:param>generate.section.toc.level=1
-    <xsl:param>generate.toc="chapter nop section nop"
-  ;
-
-install html
-  :
-    $(boost)/doc/src/boostbook.css
-    $(boost)/doc/src/images/blank.png
-    $(boost)/doc/src/images/caution.png
-    $(boost)/doc/src/images/draft.png
-    $(boost)/doc/src/images/home.png
-    $(boost)/doc/src/images/important.png
-    $(boost)/doc/src/images/next_disabled.png
-    $(boost)/doc/src/images/next.png
-    $(boost)/doc/src/images/note.png
-    $(boost)/doc/src/images/prev_disabled.png
-    $(boost)/doc/src/images/prev.png
-    $(boost)/doc/src/images/tip.png
-    $(boost)/doc/src/images/up_disabled.png
-    $(boost)/doc/src/images/up.png
-    $(boost)/doc/src/images/warning.png
-    $(boost)/doc/src/images/callouts/1.png
-    $(boost)/doc/src/images/callouts/2.png
-    $(boost)/doc/src/images/callouts/3.png
-    $(boost)/doc/src/images/callouts/4.png
-    $(boost)/doc/src/images/callouts/5.png
-    $(boost)/doc/src/images/callouts/6.png
-    $(boost)/doc/src/images/callouts/7.png
-    $(boost)/doc/src/images/callouts/8.png
-    overview/proactor.png
-    overview/sync_op.png
-    overview/async_op1.png
-    overview/async_op2.png
-    overview/model/async_agent_chain.png
-    overview/model/async_agent_model.png
-    overview/model/async_child_agent_chain.png
-    overview/model/async_op_init_complete.png
-    overview/model/async_op_model.png
-    overview/model/async_op_phases.png
-    overview/model/async_op_trivial_chain.png
-    overview/model/completion_token_model.png
-    overview/model/completion_token_transform.png
-    overview/model/higher_level_model.png
-    asio.png
-  ;
-
-install asioref : standalone : <location>. <format>docbook ;
-explicit asioref ;
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.png
deleted file mode 100644
index c05fd3a..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.qbk
deleted file mode 100644
index 9c294a3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asio.qbk
+++ /dev/null
@@ -1,142 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[library Asio
-    [quickbook 1.7]
-    [compatibility-mode 1.4]
-    [copyright 2003 - 2024 Christopher M. Kohlhoff]
-    [purpose Networking library]
-    [license
-        Distributed under the Boost Software License, Version 1.0.
-        (See accompanying file LICENSE_1_0.txt or copy at
-        [@http://www.boost.org/LICENSE_1_0.txt])
-    ]
-    [category template]
-    [category generic]
-]
-
-[template mdash[] '''&mdash; ''']
-[template hr[] [br]'''<phrase role="silver">'''[mdash]'''</phrase>'''[br]]
-[template half_open_range[text] '''&#91;'''[text])]
-[template sub[x]'''<subscript>'''[x]'''</subscript>''']
-[template indexterm1[id term1] '''<indexterm id="'''[id]'''"><primary>'''[term1]'''</primary></indexterm>''']
-[template indexterm2[id term1 term2] '''<indexterm id="'''[id]'''"><primary>'''[term1]'''</primary><secondary>'''[term2]'''</secondary></indexterm>''']
-[template inline_note[text] \[['Note:] [text] '''&mdash;'''['end note]\] ]
-[template ticket[number]'''<ulink url="https://svn.boost.org/trac/boost/ticket/'''[number]'''">'''#[number]'''</ulink>''']
-[template static[] '''<phrase role="silver">'''\[static\]'''</phrase>''']
-[template constructor[] '''<phrase role="silver">'''\[constructor\]'''</phrase>''']
-[template destructor[] '''<phrase role="silver">'''\[destructor\]'''</phrase>''']
-[def __POSIX__ /POSIX/]
-[def __Windows__ /Windows/]
-[def __accept__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/accept.html `accept()`]]
-[def __connect__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/connect.html `connect()`]]
-[def __getpeername__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/getpeername.html `getpeername()`]]
-[def __getsockname__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/getsockname.html `getsockname()`]]
-[def __getsockopt__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/getsockopt.html `getsockopt()`]]
-[def __ioctl__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/ioctl.html `ioctl()`]]
-[def __poll__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/poll.html `poll()`]]
-[def __recvfrom__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html `recvfrom()`]]
-[def __sendto__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/sendto.html `sendto()`]]
-[def __setsockopt__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/setsockopt.html `setsockopt()`]]
-[def __shutdown__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/shutdown.html `shutdown()`]]
-[def __socket__ [@http://www.opengroup.org/onlinepubs/9699919799/functions/socket.html `socket()`]]
-
-[/=============================================================================]
-
-Asio is a cross-platform C++ library for network and low-level I/O programming
-that provides developers with a consistent asynchronous model using a modern
-C++ approach.
-
-[variablelist
-  [
-    [
-      [link asio.overview Overview]
-    ]
-    [
-      An overview of the features included in Asio, plus rationale and design information.
-    ]
-  ]
-  [
-    [
-      [link asio.using Using, Building, and Configuring Asio]
-    ]
-    [
-      How to use Asio in your applications. Includes information on
-      library dependencies and supported platforms.
-    ]
-  ]
-  [
-    [
-      [link asio.tutorial Tutorial]
-    ]
-    [
-      A tutorial that introduces the fundamental concepts required to use
-      Asio, and shows how to use Asio to develop simple client and
-      server programs.
-    ]
-  ]
-  [
-    [
-      [link asio.examples Examples]
-    ]
-    [
-      Examples that illustrate the use of Asio in more complex applications.
-    ]
-  ]
-  [
-    [
-      [link asio.reference Reference]
-    ]
-    [
-      Detailed class and function reference.
-    ]
-  ]
-  [
-    [
-      [link asio.net_ts Networking TS Compatibility]
-    ]
-    [
-      Description of changes to provide compatibility with the "C++ Extensions
-      for Networking" Technical Specification.
-    ]
-  ]
-  [
-    [
-      [link asio.std_executors Proposed Standard Executors]
-    ]
-    [
-      Description of Asio's support for the proposed standard executors
-      library.
-    ]
-  ]
-  [
-    [
-      [link asio.history Revision History]
-    ]
-    [
-      Log of Asio changes made in each release.
-    ]
-  ]
-  [
-    [
-      [link asio.index Index]
-    ]
-    [
-      Book-style text index of Asio documentation.
-    ]
-  ]
-]
-
-[include overview.qbk]
-[include using.qbk]
-[include tutorial.qbk]
-[include examples.qbk]
-[include reference.qbk]
-[include net_ts.qbk]
-[include std_executors.qbk]
-[include history.qbk]
-[xinclude index.xml]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.sty b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.sty
deleted file mode 100644
index 2bf5a8d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.sty
+++ /dev/null
@@ -1,90 +0,0 @@
-%%
-%% This is a DocBook LaTeX style for Asio
-%%
-\NeedsTeXFormat{LaTeX2e}
-\ProvidesPackage{mybook}[2008/11/11 Asio DocBook Style]
-
-% The defined options
-\DeclareOption{hyperlink}{ \def\DBKhyperlink{yes} }
-\DeclareOption{nohyperlink}{ \def\DBKhyperlink{no} }
-
-% Default values
-\ExecuteOptions{nohyperlink}
-
-% If defined, process the options
-\ProcessOptions\relax
-
-% Needed packages
-\usepackage[top=2cm,bottom=2cm,left=1.5cm,right=1.5cm]{geometry}
-\usepackage{float}
-\usepackage{dbk_core}
-\usepackage{dbk_admonition}
-\usepackage{fancyvrb}
-
-% Text layout
-\setlength\parskip{\medskipamount}
-\setlength\parindent{0pt}
-\raggedbottom
-
-% Stuff we don't need
-\def\DBKinditem#1#2{}
-\newenvironment{DBKindtable}{}{}
-\newenvironment{DBKrevtable}{}{}
-\newenvironment{DBKlegalnotice}{}{}
-
-% Admonitions
-\floatstyle{boxed}
-\newfloat{DBKadmonition}{h}{lop}
-\newfloat{sidebar}{h}{lop}
-
-% Page break before sections
-\let\orig@section\section
-\renewcommand\section{
-  \clearpage\orig@section
-}
-
-% Ensure line break after paragraph heading
-\renewcommand\paragraph{%
-  \@startsection{paragraph}{4}{\z@}%
-  {-2.25ex\@plus -1ex \@minus -.2ex}%
-  {0.5ex \@plus .2ex}%
-  {\normalfont\normalsize\bfseries}%
-}
-
-% Add page numbers to hyperlinks
-%\let\orig@hyperlink\hyperlink
-%\renewcommand{\hyperlink}[2]{
-%  \orig@hyperlink{#1}{#2} (page \pageref{#1})
-%}
-
-% Extra indent on TOC section numbers
-\renewcommand*\l@subsection{\@dottedtocline{2}{1.5em}{3.3em}}
-\renewcommand*\l@subsubsection{\@dottedtocline{3}{3.8em}{4.2em}}
-\renewcommand*\l@paragraph{\@dottedtocline{4}{7.0em}{5.1em}}
-
-% Title page
-\renewcommand\maketitle{
-  \null
-  \thispagestyle{empty}
-  \begin{center}
-  \null\vskip 7cm
-  \begin{LARGE}
-  asio C++ library
-  \end{LARGE}
-  \null\vskip 1cm
-  \begin{large}
-  \DBKsubtitle{}
-  \end{large}
-  \null\vskip 1cm
-  \begin{Large}
-  Reference Manual
-  \end{Large}
-  \null\vskip 5cm
-  \begin{small}
-  \DBKcopyright{}
-  \end{small}
-  \end{center}
-  \vfill
-  \null
-  \cleardoublepage
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.xsl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.xsl
deleted file mode 100644
index 24f737a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/asioref.xsl
+++ /dev/null
@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-
-<!--
-  Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-  Distributed under the Boost Software License, Version 1.0. (See accompanying
-  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<xsl:output method="xml"/>
-<xsl:strip-space elements="title"/>
-
-<xsl:param name="asio.version">X.Y.Z</xsl:param>
-
-<xsl:template match="@*|node()">
-  <xsl:copy>
-    <xsl:apply-templates select="@*|node()"/>
-  </xsl:copy>
-</xsl:template>
-
-<xsl:template match="blockquote/para">
-  <xsl:apply-templates select="para"/>
-</xsl:template>
-
-<xsl:template match="title/link">
-  <xsl:value-of select="normalize-space(.)"/>
-</xsl:template>
-
-<xsl:template match="bridgehead[count(link) &gt; 0]">
-  <xsl:element name="bridgehead">
-    <xsl:attribute name="renderas">
-      <xsl:value-of select="@renderas"/>
-    </xsl:attribute>
-    <xsl:value-of select="normalize-space(link)"/>
-  </xsl:element>
-</xsl:template>
-
-<xsl:template match="chapter">
-  <article id="asio" name="Asio Reference Manual" dirname="asio">
-    <xsl:apply-templates select="chapterinfo"/>
-    <title>Asio Reference Manual</title>
-    <xsl:apply-templates select="section"/>
-  </article>
-</xsl:template>
-
-<xsl:template match="chapterinfo">
-  <articleinfo>
-    <xsl:apply-templates select="*"/>
-    <subtitle><xsl:value-of select="$asio.version"/></subtitle>
-  </articleinfo>
-</xsl:template>
-
-<xsl:template match="section[@id='asio.reference']/informaltable">
-  <xsl:element name="informaltable">
-    <xsl:attribute name="role">scriptsize</xsl:attribute>
-    <xsl:apply-templates select="*"/>
-  </xsl:element>
-</xsl:template>
-
-<xsl:template match="section[@id='asio.examples']/*/listitem">
-  <xsl:element name="listitem">
-    <xsl:value-of select="substring-after(normalize-space(ulink), '../')"/>
-  </xsl:element>
-</xsl:template>
-
-<xsl:template match="imagedata">
-  <xsl:element name="imagedata">
-    <xsl:attribute name="fileref">
-      <xsl:value-of select="@fileref"/>
-    </xsl:attribute>
-    <xsl:attribute name="scale">75</xsl:attribute>
-    <xsl:attribute name="align">center</xsl:attribute>
-  </xsl:element>
-</xsl:template>
-
-<xsl:template match="programlisting/phrase">
-  <xsl:apply-templates/>
-</xsl:template>
-
-<xsl:template match="programlisting/link">
-  <xsl:apply-templates/>
-</xsl:template>
-
-<xsl:template match="programlisting/emphasis">
-  <xsl:if test="not(contains(., 'more...'))">
-    <emphasis><xsl:apply-templates/></emphasis>
-  </xsl:if>
-</xsl:template>
-
-<xsl:template match="section[@id='asio.index']"></xsl:template>
-
-</xsl:stylesheet>
-
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/boost_bind_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/boost_bind_dox.txt
deleted file mode 100644
index 19c635d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/boost_bind_dox.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-/**
-\page boost_bind boost::bind
-See the <a href="http://www.boost.org/libs/bind/bind.html">Boost: bind.hpp
-documentation</a> for more information on how to use <tt>boost::bind</tt>.
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/doxy2qbk.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/doxy2qbk.pl
deleted file mode 100644
index dde83e0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/doxy2qbk.pl
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/perl -w
-
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-use strict;
-
-system("doxygen reference.dox");
-chdir("xml");
-system("xsltproc combine.xslt index.xml > all.xml");
-chdir("..");
-system("xsltproc reference.xsl xml/all.xml > reference.qbk");
-system("rm -rf xml");
-
-system("doxygen tutorial.dox");
-chdir("xml");
-system("xsltproc combine.xslt index.xml > all.xml");
-chdir("..");
-system("xsltproc tutorial.xsl xml/all.xml > tutorial.qbk");
-system("rm -rf xml reference.tags");
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/examples.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/examples.qbk
deleted file mode 100644
index 8c512cb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/examples.qbk
+++ /dev/null
@@ -1,582 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:examples Examples]
-
-
-* [link asio.examples.cpp11_examples C++11 Examples]: Illustrates the use of
-Asio using only C++11 language and library features. Where necessary, the
-examples make use of selected Boost C++ libraries.
-
-* [link asio.examples.cpp14_examples C++14 Examples]: Contains a limited set of
-the C++03 Asio examples, updated to use only C++14 library and language
-facilities. These examples do not make direct use of Boost C++ libraries.
-
-* [link asio.examples.cpp17_examples C++17 Examples]: Selected examples
-illustrating C++17 usage in conjunction with Technical Specifications.
-
-* [link asio.examples.cpp20_examples C++20 Examples]: Selected examples
-using C++20 language features.
-
-
-[section:cpp11_examples C++11 Examples]
-
-
-[heading Allocation]
-
-This example shows how to customise the allocation of memory associated with
-asynchronous operations.
-
-* [@../src/examples/cpp11/allocation/server.cpp]
-
-
-[heading Buffers]
-
-This example demonstrates how to create reference counted buffers that can be
-used with socket read and write operations.
-
-* [@../src/examples/cpp11/buffers/reference_counted.cpp]
-
-
-[heading Chat]
-
-This example implements a chat server and client. The programs use a custom
-protocol with a fixed length message header and variable length message body.
-
-* [@../src/examples/cpp11/chat/chat_message.hpp]
-* [@../src/examples/cpp11/chat/chat_client.cpp]
-* [@../src/examples/cpp11/chat/chat_server.cpp]
-
-The following POSIX-specific chat client demonstrates how to use the
-[link asio.reference.posix__stream_descriptor posix::stream_descriptor] class to
-perform console input and output.
-
-* [@../src/examples/cpp11/chat/posix_chat_client.cpp]
-
-
-[heading Deferred]
-
-Examples showing how to use the [link asio.reference.deferred `deferred`]
-completion token.
-
-* [@../src/examples/cpp11/deferred/deferred_1.cpp]
-* [@../src/examples/cpp11/deferred/deferred_2.cpp]
-
-
-[heading Echo]
-
-A collection of simple clients and servers, showing the use of both synchronous
-and asynchronous operations.
-
-* [@../src/examples/cpp11/echo/async_tcp_echo_server.cpp]
-* [@../src/examples/cpp11/echo/async_udp_echo_server.cpp]
-* [@../src/examples/cpp11/echo/blocking_tcp_echo_client.cpp]
-* [@../src/examples/cpp11/echo/blocking_tcp_echo_server.cpp]
-* [@../src/examples/cpp11/echo/blocking_udp_echo_client.cpp]
-* [@../src/examples/cpp11/echo/blocking_udp_echo_server.cpp]
-
-
-[heading Fork]
-
-These POSIX-specific examples show how to use Asio in conjunction with the
-`fork()` system call. The first example illustrates the steps required to start
-a daemon process:
-
-* [@../src/examples/cpp11/fork/daemon.cpp]
-
-The second example demonstrates how it is possible to fork a process from
-within a completion handler.
-
-* [@../src/examples/cpp11/fork/process_per_connection.cpp]
-
-
-[heading Futures]
-
-This example demonstrates how to use std::future in conjunction with
-Asio's asynchronous operations.
-
-* [@../src/examples/cpp11/futures/daytime_client.cpp]
-
-
-[heading Handler Tracking]
-
-This example header file shows how to implement custom handler tracking.
-
-* [@../src/examples/cpp11/handler_tracking/custom_tracking.hpp]
-
-This example program shows how to include source location information in
-the handler tracking output.
-
-* [@../src/examples/cpp11/handler_tracking/async_tcp_echo_server.cpp]
-
-
-[heading HTTP Client]
-
-Example programs implementing simple HTTP 1.0 clients. These examples show how
-to use the [link asio.reference.read_until read_until] and [link
-asio.reference.async_read_until async_read_until] functions.
-
-* [@../src/examples/cpp11/http/client/sync_client.cpp]
-* [@../src/examples/cpp11/http/client/async_client.cpp]
-
-
-[heading HTTP Server]
-
-This example illustrates the use of asio in a simple single-threaded server
-implementation of HTTP 1.0. It demonstrates how to perform a clean shutdown by
-cancelling all outstanding asynchronous operations.
-
-* [@../src/examples/cpp11/http/server/connection.cpp]
-* [@../src/examples/cpp11/http/server/connection.hpp]
-* [@../src/examples/cpp11/http/server/connection_manager.cpp]
-* [@../src/examples/cpp11/http/server/connection_manager.hpp]
-* [@../src/examples/cpp11/http/server/header.hpp]
-* [@../src/examples/cpp11/http/server/main.cpp]
-* [@../src/examples/cpp11/http/server/mime_types.cpp]
-* [@../src/examples/cpp11/http/server/mime_types.hpp]
-* [@../src/examples/cpp11/http/server/reply.cpp]
-* [@../src/examples/cpp11/http/server/reply.hpp]
-* [@../src/examples/cpp11/http/server/request.hpp]
-* [@../src/examples/cpp11/http/server/request_handler.cpp]
-* [@../src/examples/cpp11/http/server/request_handler.hpp]
-* [@../src/examples/cpp11/http/server/request_parser.cpp]
-* [@../src/examples/cpp11/http/server/request_parser.hpp]
-* [@../src/examples/cpp11/http/server/server.cpp]
-* [@../src/examples/cpp11/http/server/server.hpp]
-
-
-[heading HTTP Server 2]
-
-An HTTP server using an io_context-per-CPU design.
-
-* [@../src/examples/cpp11/http/server2/connection.cpp]
-* [@../src/examples/cpp11/http/server2/connection.hpp]
-* [@../src/examples/cpp11/http/server2/header.hpp]
-* [@../src/examples/cpp11/http/server2/io_context_pool.cpp]
-* [@../src/examples/cpp11/http/server2/io_context_pool.hpp]
-* [@../src/examples/cpp11/http/server2/main.cpp]
-* [@../src/examples/cpp11/http/server2/mime_types.cpp]
-* [@../src/examples/cpp11/http/server2/mime_types.hpp]
-* [@../src/examples/cpp11/http/server2/reply.cpp]
-* [@../src/examples/cpp11/http/server2/reply.hpp]
-* [@../src/examples/cpp11/http/server2/request.hpp]
-* [@../src/examples/cpp11/http/server2/request_handler.cpp]
-* [@../src/examples/cpp11/http/server2/request_handler.hpp]
-* [@../src/examples/cpp11/http/server2/request_parser.cpp]
-* [@../src/examples/cpp11/http/server2/request_parser.hpp]
-* [@../src/examples/cpp11/http/server2/server.cpp]
-* [@../src/examples/cpp11/http/server2/server.hpp]
-
-
-[heading HTTP Server 3]
-
-An HTTP server using a single io_context and a thread pool calling `io_context::run()`.
-
-* [@../src/examples/cpp11/http/server3/connection.cpp]
-* [@../src/examples/cpp11/http/server3/connection.hpp]
-* [@../src/examples/cpp11/http/server3/header.hpp]
-* [@../src/examples/cpp11/http/server3/main.cpp]
-* [@../src/examples/cpp11/http/server3/mime_types.cpp]
-* [@../src/examples/cpp11/http/server3/mime_types.hpp]
-* [@../src/examples/cpp11/http/server3/reply.cpp]
-* [@../src/examples/cpp11/http/server3/reply.hpp]
-* [@../src/examples/cpp11/http/server3/request.hpp]
-* [@../src/examples/cpp11/http/server3/request_handler.cpp]
-* [@../src/examples/cpp11/http/server3/request_handler.hpp]
-* [@../src/examples/cpp11/http/server3/request_parser.cpp]
-* [@../src/examples/cpp11/http/server3/request_parser.hpp]
-* [@../src/examples/cpp11/http/server3/server.cpp]
-* [@../src/examples/cpp11/http/server3/server.hpp]
-
-
-[heading HTTP Server 4]
-
-A single-threaded HTTP server implemented using stackless coroutines.
-
-* [@../src/examples/cpp11/http/server4/file_handler.cpp]
-* [@../src/examples/cpp11/http/server4/file_handler.hpp]
-* [@../src/examples/cpp11/http/server4/header.hpp]
-* [@../src/examples/cpp11/http/server4/main.cpp]
-* [@../src/examples/cpp11/http/server4/mime_types.cpp]
-* [@../src/examples/cpp11/http/server4/mime_types.hpp]
-* [@../src/examples/cpp11/http/server4/reply.cpp]
-* [@../src/examples/cpp11/http/server4/reply.hpp]
-* [@../src/examples/cpp11/http/server4/request.hpp]
-* [@../src/examples/cpp11/http/server4/request_parser.cpp]
-* [@../src/examples/cpp11/http/server4/request_parser.hpp]
-* [@../src/examples/cpp11/http/server4/server.cpp]
-* [@../src/examples/cpp11/http/server4/server.hpp]
-
-
-[heading ICMP]
-
-This example shows how to use raw sockets with ICMP to ping a remote host.
-
-* [@../src/examples/cpp11/icmp/ping.cpp]
-* [@../src/examples/cpp11/icmp/ipv4_header.hpp]
-* [@../src/examples/cpp11/icmp/icmp_header.hpp]
-
-
-[heading Invocation]
-
-This example shows how to customise handler invocation. Completion handlers are
-added to a priority queue rather than executed immediately.
-
-* [@../src/examples/cpp11/invocation/prioritised_handlers.cpp]
-
-
-[heading Iostreams]
-
-Two examples showing how to use [link asio.reference.ip__tcp.iostream
-ip::tcp::iostream].
-
-* [@../src/examples/cpp11/iostreams/daytime_client.cpp]
-* [@../src/examples/cpp11/iostreams/daytime_server.cpp]
-* [@../src/examples/cpp11/iostreams/http_client.cpp]
-
-
-[heading Multicast]
-
-An example showing the use of multicast to transmit packets to a group of
-subscribers.
-
-* [@../src/examples/cpp11/multicast/receiver.cpp]
-* [@../src/examples/cpp11/multicast/sender.cpp]
-
-
-[heading Nonblocking]
-
-Example demonstrating reactor-style operations for integrating a third-party
-library that wants to perform the I/O operations itself.
-
-* [@../src/examples/cpp11/nonblocking/third_party_lib.cpp]
-
-
-[heading Operations]
-
-Examples showing how to implement composed asynchronous operations as reusable library functions.
-
-* [@../src/examples/cpp11/operations/composed_1.cpp]
-* [@../src/examples/cpp11/operations/composed_2.cpp]
-* [@../src/examples/cpp11/operations/composed_3.cpp]
-* [@../src/examples/cpp11/operations/composed_4.cpp]
-* [@../src/examples/cpp11/operations/composed_5.cpp]
-* [@../src/examples/cpp11/operations/composed_6.cpp]
-* [@../src/examples/cpp11/operations/composed_7.cpp]
-* [@../src/examples/cpp11/operations/composed_8.cpp]
-
-
-[heading Parallel Groups]
-
-Examples showing how to use the [link
-asio.reference.experimental__make_parallel_group
-`experimental::make_parallel_group`] operation.
-
-* [@../src/examples/cpp11/parallel_group/wait_for_all.cpp]
-* [@../src/examples/cpp11/parallel_group/wait_for_one.cpp]
-* [@../src/examples/cpp11/parallel_group/wait_for_one_error.cpp]
-* [@../src/examples/cpp11/parallel_group/wait_for_one_success.cpp]
-* [@../src/examples/cpp11/parallel_group/ranged_wait_for_all.cpp]
-
-
-[heading Porthopper]
-
-Example illustrating mixed synchronous and asynchronous operations.
-
-* [@../src/examples/cpp11/porthopper/protocol.hpp]
-* [@../src/examples/cpp11/porthopper/client.cpp]
-* [@../src/examples/cpp11/porthopper/server.cpp]
-
-
-[heading Serialization]
-
-This example shows how Boost.Serialization can be used with asio to encode and
-decode structures for transmission over a socket.
-
-* [@../src/examples/cpp11/serialization/client.cpp]
-* [@../src/examples/cpp11/serialization/connection.hpp]
-* [@../src/examples/cpp11/serialization/server.cpp]
-* [@../src/examples/cpp11/serialization/stock.hpp]
-
-
-[heading Services]
-
-This example demonstrates how to integrate custom functionality (in this case,
-for logging) into asio's [link asio.reference.io_context io_context], and
-how to use a custom service with [link
-asio.reference.basic_stream_socket basic_stream_socket<>].
-
-* [@../src/examples/cpp11/services/basic_logger.hpp]
-* [@../src/examples/cpp11/services/daytime_client.cpp]
-* [@../src/examples/cpp11/services/logger.hpp]
-* [@../src/examples/cpp11/services/logger_service.cpp]
-* [@../src/examples/cpp11/services/logger_service.hpp]
-* [@../src/examples/cpp11/services/stream_socket_service.hpp]
-
-
-[heading SOCKS 4]
-
-Example client program implementing the SOCKS 4 protocol for communication via
-a proxy.
-
-* [@../src/examples/cpp11/socks4/sync_client.cpp]
-* [@../src/examples/cpp11/socks4/socks4.hpp]
-
-
-[heading Spawn]
-
-Example of using the asio::spawn() function, a wrapper around the
-[@http://www.boost.org/doc/libs/release/libs/context/index.html Boost.Context]
-library, to implement a chain of asynchronous operations using stackful
-coroutines.
-
-* [@../src/examples/cpp11/spawn/echo_server.cpp]
-
-
-[heading SSL]
-
-Example client and server programs showing the use of the [link
-asio.reference.ssl__stream ssl::stream<>] template with asynchronous operations.
-
-* [@../src/examples/cpp11/ssl/client.cpp]
-* [@../src/examples/cpp11/ssl/server.cpp]
-
-
-[heading Timeouts]
-
-A collection of examples showing how to cancel long running asynchronous
-operations after a period of time.
-
-* [@../src/examples/cpp11/timeouts/async_tcp_client.cpp]
-* [@../src/examples/cpp11/timeouts/blocking_tcp_client.cpp]
-* [@../src/examples/cpp11/timeouts/blocking_token_tcp_client.cpp]
-* [@../src/examples/cpp11/timeouts/blocking_udp_client.cpp]
-* [@../src/examples/cpp11/timeouts/server.cpp]
-
-
-[heading Timers]
-
-Example showing how to customise basic_waitable_timer using a different clock type.
-
-* [@../src/examples/cpp11/timers/time_t_timer.cpp]
-
-
-[heading Type Erasure]
-
-Example showing how to use [link asio.reference.any_completion_handler
-`any_completion_handler`] to enable separate compilation of asynchronous
-operations.
-
-* [@../src/examples/cpp11/type_erasure/main.cpp]
-* [@../src/examples/cpp11/type_erasure/line_reader.hpp]
-* [@../src/examples/cpp11/type_erasure/stdin_line_reader.hpp]
-* [@../src/examples/cpp11/type_erasure/stdin_line_reader.cpp]
-* [@../src/examples/cpp11/type_erasure/sleep.hpp]
-* [@../src/examples/cpp11/type_erasure/sleep.cpp]
-
-
-[heading UNIX Domain Sockets]
-
-Examples showing how to use UNIX domain (local) sockets.
-
-* [@../src/examples/cpp11/local/connect_pair.cpp]
-* [@../src/examples/cpp11/local/iostream_client.cpp]
-* [@../src/examples/cpp11/local/stream_server.cpp]
-* [@../src/examples/cpp11/local/stream_client.cpp]
-* [@../src/examples/cpp11/local/fd_passing_stream_server.cpp]
-* [@../src/examples/cpp11/local/fd_passing_stream_client.cpp]
-
-
-[heading Windows]
-
-An example showing how to use the Windows-specific function `TransmitFile`
-with Asio.
-
-* [@../src/examples/cpp11/windows/transmit_file.cpp]
-
-
-[endsect]
-
-
-[section:cpp14_examples C++14 Examples]
-
-
-[heading Deferred]
-
-Examples showing how to use the [link asio.reference.deferred `deferred`]
-completion token.
-
-* [@../src/examples/cpp14/deferred/deferred_1.cpp]
-* [@../src/examples/cpp14/deferred/deferred_2.cpp]
-* [@../src/examples/cpp14/deferred/deferred_3.cpp]
-* [@../src/examples/cpp14/deferred/deferred_4.cpp]
-* [@../src/examples/cpp14/deferred/deferred_5.cpp]
-* [@../src/examples/cpp14/deferred/deferred_6.cpp]
-* [@../src/examples/cpp14/deferred/deferred_7.cpp]
-
-
-[heading Echo]
-
-A collection of simple clients and servers, showing the use of both synchronous
-and asynchronous operations.
-
-* [@../src/examples/cpp14/echo/async_tcp_echo_server.cpp]
-* [@../src/examples/cpp14/echo/async_udp_echo_server.cpp]
-* [@../src/examples/cpp14/echo/blocking_tcp_echo_client.cpp]
-* [@../src/examples/cpp14/echo/blocking_tcp_echo_server.cpp]
-* [@../src/examples/cpp14/echo/blocking_udp_echo_client.cpp]
-* [@../src/examples/cpp14/echo/blocking_udp_echo_server.cpp]
-
-
-[heading Executors]
-
-Examples showing how to use the executor-related facilities.
-
-* [@../src/examples/cpp14/executors/actor.cpp]
-* [@../src/examples/cpp14/executors/async_1.cpp]
-* [@../src/examples/cpp14/executors/async_2.cpp]
-* [@../src/examples/cpp14/executors/bank_account_1.cpp]
-* [@../src/examples/cpp14/executors/bank_account_2.cpp]
-* [@../src/examples/cpp14/executors/fork_join.cpp]
-* [@../src/examples/cpp14/executors/pipeline.cpp]
-* [@../src/examples/cpp14/executors/priority_scheduler.cpp]
-
-
-[heading Iostreams]
-
-Two examples showing how to use [link asio.reference.ip__tcp.iostream
-ip::tcp::iostream].
-
-* [@../src/examples/cpp14/iostreams/http_client.cpp]
-
-
-[heading Operations]
-
-Examples showing how to implement composed asynchronous operations as reusable library functions.
-
-* [@../src/examples/cpp14/operations/composed_1.cpp]
-* [@../src/examples/cpp14/operations/composed_2.cpp]
-* [@../src/examples/cpp14/operations/composed_3.cpp]
-* [@../src/examples/cpp14/operations/composed_4.cpp]
-* [@../src/examples/cpp14/operations/composed_5.cpp]
-* [@../src/examples/cpp14/operations/composed_6.cpp]
-* [@../src/examples/cpp14/operations/composed_7.cpp]
-* [@../src/examples/cpp14/operations/composed_8.cpp]
-
-Examples showing how to expose callback-based APIs as asynchronous operations.
-
-* [@../src/examples/cpp14/operations/callback_wrapper.cpp]
-* [@../src/examples/cpp14/operations/c_callback_wrapper.cpp]
-
-
-[heading Parallel Groups]
-
-Examples showing how to use the [link
-asio.reference.experimental__make_parallel_group
-`experimental::make_parallel_group`] operation.
-
-* [@../src/examples/cpp14/parallel_group/parallel_sort.cpp]
-* [@../src/examples/cpp14/parallel_group/wait_for_all.cpp]
-* [@../src/examples/cpp14/parallel_group/wait_for_one.cpp]
-* [@../src/examples/cpp14/parallel_group/wait_for_one_error.cpp]
-* [@../src/examples/cpp14/parallel_group/wait_for_one_success.cpp]
-* [@../src/examples/cpp14/parallel_group/ranged_wait_for_all.cpp]
-
-
-[endsect]
-
-
-[section:cpp17_examples C++17 Examples]
-
-
-[heading Coroutines TS Support]
-
-Examples showing how to implement a chain of asynchronous operations using the
-Coroutines TS.
-
-* [@../src/examples/cpp17/coroutines_ts/echo_server.cpp]
-* [@../src/examples/cpp17/coroutines_ts/refactored_echo_server.cpp]
-* [@../src/examples/cpp17/coroutines_ts/chat_server.cpp]
-* [@../src/examples/cpp17/coroutines_ts/range_based_for.cpp]
-
-
-[endsect]
-
-
-[section:cpp20_examples C++20 Examples]
-
-
-[heading Channels]
-
-Example showing how to use a channel in conjunction with C++20 coroutines.
-
-* [@../src/examples/cpp20/channels/mutual_exclusion_1.cpp]
-* [@../src/examples/cpp20/channels/mutual_exclusion_2.cpp]
-* [@../src/examples/cpp20/channels/throttling_proxy.cpp]
-
-
-[heading Coroutines]
-
-Examples showing how to implement a chain of asynchronous operations using C++20
-Coroutines.
-
-* [@../src/examples/cpp20/coroutines/echo_server.cpp]
-* [@../src/examples/cpp20/coroutines/echo_server_with_default.cpp]
-* [@../src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp]
-* [@../src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp]
-* [@../src/examples/cpp20/coroutines/echo_server_with_deferred.cpp]
-* [@../src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp]
-* [@../src/examples/cpp20/coroutines/refactored_echo_server.cpp]
-* [@../src/examples/cpp20/coroutines/chat_server.cpp]
-* [@../src/examples/cpp20/coroutines/timeout.cpp]
-
-
-[heading Invocation]
-
-This example shows how to customise handler invocation using a user-defined
-completion executor.
-
-* [@../src/examples/cpp20/invocation/completion_executor.cpp]
-
-
-[heading Operations]
-
-Examples showing how to implement composed asynchronous operations as reusable library functions.
-
-* [@../src/examples/cpp20/operations/composed_1.cpp]
-* [@../src/examples/cpp20/operations/composed_2.cpp]
-* [@../src/examples/cpp20/operations/composed_3.cpp]
-* [@../src/examples/cpp20/operations/composed_4.cpp]
-* [@../src/examples/cpp20/operations/composed_5.cpp]
-* [@../src/examples/cpp20/operations/composed_6.cpp]
-* [@../src/examples/cpp20/operations/composed_7.cpp]
-* [@../src/examples/cpp20/operations/composed_8.cpp]
-
-Examples showing how to expose callback-based APIs as asynchronous operations.
-
-* [@../src/examples/cpp20/operations/callback_wrapper.cpp]
-* [@../src/examples/cpp20/operations/c_callback_wrapper.cpp]
-
-
-[heading Type Erasure]
-
-Example showing how to use [link asio.reference.any_completion_handler
-`any_completion_handler`] to enable separate compilation of asynchronous
-operations.
-
-* [@../src/examples/cpp20/type_erasure/main.cpp]
-* [@../src/examples/cpp20/type_erasure/line_reader.hpp]
-* [@../src/examples/cpp20/type_erasure/stdin_line_reader.hpp]
-* [@../src/examples/cpp20/type_erasure/stdin_line_reader.cpp]
-* [@../src/examples/cpp20/type_erasure/sleep.hpp]
-* [@../src/examples/cpp20/type_erasure/sleep.cpp]
-
-
-[endsect]
-
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/history.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/history.qbk
deleted file mode 100644
index b3cf118..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/history.qbk
+++ /dev/null
@@ -1,3943 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:history Revision History]
-
-[heading Asio 1.30.1]
-
-* Changed the `default_completion_token` trait's primary template to select
-  `deferred` as the default completion token. As a result, most asynchronous
-  operations' initiating functions will return a deferred asynchronous operation
-  by default. For example, the completion token can be omitted when calling
-  asynchronous operations from an `awaitable` coroutine:[br]
-  ``
-  awaitable<void> echo(ip::tcp::socket& my_socket)
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await my_socket.async_read_some(buffer(data));
-      co_await async_write(my_socket, buffer(data, n));
-    }
-  }
-  ``
-  or when using an operation that accepts asynchronous operations as function
-  objects, such as `experimental::make_parallel_group`:[br]
-  ``
-  experimental::make_parallel_group(
-      my_socket.async_read_some(buffer(data)),
-      my_timer.async_wait()
-    ).async_wait(/* ... */);
-  ``
-
-* Added the `is_completion_condition` trait and used it to add the missing
-  default completion tokens to overloads of `async_read`, `async_read_at`,
-  `async_write`, and `async_write_at`.
-
-* Added the `is_connect_condition` trait and used it disambiguate overloads of
-  `async_connect` when the completion token is defaulted.
-
-* Extended the completion token adapters `as_tuple`, `bind_allocator`,
-  `bind_cancellation_slot`, `bind_executor`, `bind_immediate_executor`, and
-  `redirect_error` to allow them to be used as ['partial completion token
-  adapters]. This means that they can be created without explicitly supplying a
-  completion token. Instead, when the adapter is passed to an asynchronous
-  operation, it will automatically determine the operation's default completion
-  token and adapt it. For example, the expression:[br]
-  ``
-  my_socket.async_read_some(my_buffer, as_tuple)
-  ``
-  will return a deferred asynchronous operation with the completion arguments
-  packaged in a tuple. They may also be applied using the `deferred` operations'
-  pipe operator:[br]
-  ``
-  error_code e;
-  co_await (async_write(my_socket, my_buffer) | redirect_error(e));
-  ``
-
-* Added the `cancel_after` and `cancel_at` completion token adapters. These
-  may be used to adapt any asynchronous operation to emit a cancellation signal
-  after a specified duration or at an absolute time point. For example:[br]
-  ``
-  my_socket.async_read_some(my_buffer,
-      cancel_after(std::chrono::seconds(10),
-        [](error_code e, std::size_t n)
-        {
-          // ...
-        }));
-  ``
-  This cancellation is implemented internally using a `basic_waitable_timer`.
-  By default, this timer is created using the asynchronous operation's I/O
-  executor. If the operation does specify its I/O executor, a timer may be
-  explicitly supplied:[br]
-  ``
-  my_socket.async_read_some(my_buffer,
-      cancel_after(my_timer, std::chrono::seconds(10),
-        [](error_code e, std::size_t n)
-        {
-          // ...
-        }));
-  ``
-  These adapters may also be used as partial completion token adapters, as
-  in:[br]
-  ``
-  co_await my_socket.async_read_some(my_buffer, cancel_after(5s));
-  ``
-  or:[br]
-  ``
-  co_await (
-      async_write(my_socket, my_buffer) | as_tuple
-        | cancel_after(std::chronos::seconds(10)
-    );
-  ``
-  or to adapt other partial completion token adapters:[br]
-  ``
-  co_await my_socket.async_read_some(my_buffer, cancel_after(5s, as_tuple));
-  ``
-  Note that, since the implementation in terms of a timer introduces a parallel
-  `async_wait` operation, it is the responsibility of the caller to ensure that
-  the asynchronous operation is performed in an implicit or explicit strand.
-
-* Changed all completion token adapters to ensure they correctly propagate the
-  asynchronous operation's I/O executor during adaptation.
-
-* Fixed `async_compose` and `co_composed` to correctly indicate if they have
-  an I/O executor.
-
-* Moved `co_composed` out of the `experimental` namespace.
-
-* Added `composed`, which creates an initiation function object from a stateful
-  implementation. It is similar to `co_composed`, but for regular function
-  objects rather than C++20 coroutines. For example:
-  ``
-  struct async_echo_implementation
-  {
-    tcp::socket& socket_;
-    mutable_buffer buffer_;
-    enum { starting, reading, writing } state_;
-
-    template <typename Self>
-    void operator()(Self& self,
-        error_code error,
-        std::size_t n)
-    {
-      switch (state_)
-      {
-        // ...
-      }
-    }
-  };
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      mutable_buffer buffer,
-      CompletionToken&& token)
-  {
-    return async_initiate<CompletionToken,
-      void(error_code, std::size_t)>(
-        composed(
-          async_echo_implementation{socket, buffer,
-            async_echo_implementation::starting}, socket),
-        token, error_code{}, 0);
-  }
-  ``
-  The `async_compose` function has been changed to be a thin wrapper around
-  `composed`. However, unlike `async_compose`, `composed` allows arguments to be
-  passed to the stateful implementation when the operation is initiated.
-
-* Changed the `detached` completion token to work with asynchronous operations
-  that have multiple completion signatures.
-
-* Changed `async_initiate` to allow an empty variadic list of completion
-  signatures, which would indicate that an asynchronous operation never
-  completes.
-
-* Added overloads of `async_initiate` that automatically deduce the type of
-  the completion token. For example:[br]
-  ``
-  async_initiate(co_composed(/* ... */), detached, arg_1, arg_2);
-  ``
-  will deduce the token type from the argument `detached`.
-
-* Added `async_immediate` which implements a trivial asynchronous operation that
-  completes immediately, using an associated immediate executor if available.
-  It is intended for use within asynchronous compositions to make it easier to
-  provide optimised immediate completion.
-
-* Updated the documentation for various asynchronous operations to specify
-  immediate completion in terms of `async_immediate`.
-
-* Enabled SFINAE-based partial specialisation of the `associator` trait.
-
-* Changed to use the recycling allocator as the fallback for all operations,
-  rather than calling the underlying recycling allocation helper functions
-  directly.
-
-* Fixed the `deferred` implementation to ensure that the wrapped initiation
-  function object's copyability is correctly propagated.
-
-* Fixed `experimental::coro` compatibility with clang 15.
-
-* Fixed deduction of a completion handler's default immediate executor type.
-
-* Don't use `ioctl` to modify the non-blocking mode on socket or descriptors
-  that have been assigned, as they may originate from an external source.
-
-* Don't call `fcntl` with `F_SETFL` if the flags aren't changing.
-
-* Don't enable non-blocking mode when performing an `async_wait` operation on
-  sockets or descriptors.
-
-* Update some composed operation examples to destroy the timer object before
-  calling the completion handler.
-
-* Fix `read_until` regex support when `BOOST_ASIO_NO_DYNAMIC_BUFFER_V1` is
-  defined.
-
-[heading Asio 1.30.2]
-
-* Fixed `co_spawn` to correctly propagate exceptions resulting from cancellation
-  to the completion handler.
-
-* Added calls to `std::launder` to fix undefined behaviour in `awaitable<>`
-  internal storage.
-
-* Added missing handling of the `file_base::append` flag in the Windows
-  implementation of file support.
-
-* Updated the socket and descriptor implementations to add more cases where they
-  will fall back to `fcntl` if a call to `ioctl` fails.
-
-* Fixed a compile error that occurred when channels and `experimental::coro`
-  were both used in the same translation unit.
-
-* Added missing CancellationSlot type requirements to documentation.
-
-* Minor documentation updates.
-
-[heading Asio 1.30.1]
-
-* Fixed the `async_result` primary template's concept checking to correctly
-  handle lvalue-qualified completion signatures.
-
-* Fixed some compile errors that could arise when using the `bind_allocator`,
-  `bind_executor`, `bind_immediate_executor` and `bind_cancellation_slot`
-  completion token adapters to adapt each other.
-
-* Changed the `experimental::ranged_parallel_group` operation so that it moves
-  the `completion_order` vector when invoking the completion handler.
-
-* Fixed the [^asio/experimental/parallel_group.hpp] header so that it is
-  self-contained.
-
-* Fixed some warnings about deprecated implicit copy constructors on
-  `ip::basic_resolver_query`, `io_context::strand`, and `coroutine`.
-
-* Updated the version specification used to initialise Winsock.
-
-* Fixed the documentation hyperlinks for the deduced return types of
-  asynchronous operations' initiating functions.
-
-[heading Asio 1.30.0]
-
-* Fixed compatibility between `any_completion_handler` and compilation using
-  `ASIO_USE_TS_EXECUTOR_AS_DEFAULT`.
-
-* Fixed a crash that may occur when attempting to access a default-constructed
-  `any_completion_handler` object's associators.
-
-* Fixed `ssl::stream<>` class's `async_handshake` operation so that it works
-  with a defaulted completion token.
-
-* Updated all examples to use C++11 as the minimum language standard.
-
-[heading Asio 1.29.0]
-
-* Changed to require C++11 as the minimum language standard.
-
-* Removed deprecated functionality from the `asio::execution` namespace.
-
-* Removed deprecated invocation and allocation hooks.
-
-* Added compatibility between Asio's placeholders and `std::bind`.
-
-* Added `try_send_via_dispatch` and `try_send_n_via_dispatch` functions to
-  channels.
-
-* Improved C++11 support for multi-signature channels.
-
-* Fixed compatibility between channel asynchronous operations and
-  `any_completion_handler`.
-
-* Added missing equality operators for mixed property types belonging to the
-  same category.
-
-* Fixed an issue where `spawn`-based stackful coroutines would terminate the
-  program when used with asynchronous operations that have a completion
-  signature starting with `std::exception_ptr`.
-
-[heading Asio 1.28.2]
-
-* Fixed the completion token adapters `bind_allocator`, `bind_cancellation_slot`
-  and `bind_immediate_executor` to not require a `return_type` type alias in
-  the adapted `async_result` specialisation.
-
-* Fixed a potental crash due to an object lifetime issue in the `co_spawn`
-  operation's cancellation support.
-
-* Enabled compiler-supported thread locals on more target platforms, using the
-  `thread_local` keyword if available.
-
-* Fixed the documentation of the per-operation cancellation behaviour for
-  `experimental::co_composed` to correctly state that terminal cancellation is
-  enabled by default.
-
-* Documented the per-operation cancellation behaviour of `async_compose`.
-
-* Added `bind_immediate_executor` to the `Completion Token Adapters` overview.
-
-* Added an example illustrating how to use an `experimental channel` for
-  mutual exclusion between cooperating asynchronous actors.
-
-* Added an example showing how to write a minimal completion executor.
-
-[heading Asio 1.28.1]
-
-* Added missing compatibility with `associated_immediate_executor` to
-  `any_completion_handler`.
-
-* Fixed a null pointer dereference that occurs when using `query`, `require` or
-  `prefer` with an empty `any_executor`.
-
-* Added a workaround in `experimental::coro` for a spurious syntax error when
-  compiling with MSVC.
-
-* Fixed an integer truncation issue in per-operation cancellation, when using
-  the reactor backend on 64-bit Windows.
-
-* Added a compile-time check for a minimum Linux kernel version of 5.10, when
-  [^io_uring] support is enabled.
-
-* Fixed a compile error in the converting move constructors for
-  `experimental::basic_channel` and `experimental::basic_concurrent_channel`.
-
-* Fixed a memory leak on some `signal_set` error handling code paths.
-
-* Fixed `bad_address_cast` to not use a deprecated implicit copy constructor.
-
-* Fixed a copy/paste error in the `dev_poll_reactor` backend.
-
-* Fixed the [^io_uring] backend to ensure the internal timeout operations, used
-  to implement `io_context::run_for` and `io_context::run_until`, are
-  cleaned up correctly.
-
-* Eliminated some duplicated state in the `co_spawn` implementation's entry
-  point, reducing memory consumption.
-
-* Added c++14 echo examples to boostify script.
-
-[heading Asio 1.28.0]
-
-* Added missing handler tracking source location support to `awaitable<>`-based
-  coroutine's ability to `co_await` asynchronous operations packaged as function
-  objects.
-
-* Add missing handler tracking source location support to `co_composed`.
-
-* Fixed suppression of spurious 'potential null dereference' warnings, to work
-  with older compilers.
-
-* Fixed a bug where passing the deprecated `const_buffers_1` and
-  `mutable_buffers_1` types to `asio::buffer()` would result in the contiguous
-  iterator overloads being incorrectly chosen.
-
-* Disabled the runtime Windows version test unless targeting older Windows
-  versions.
-
-* Fixed compatibility between buffered stream wrappers and move-constructible
-  streams, such as `ssl::stream<>`.
-
-* Marked `ip::address_v4::to_ulong` as deprecated in the documentation.
-
-* Fixed shadowed variable warnings.
-
-* Fixed `basic_socket_acceptor::async_accept` concept requirement checking to
-  be compatible with lambdas that have a deduced return type.
-
-* Fixed a feature detection macro used in `use_future`'s compatibility traits.
-
-* Fixed `as_tuple` compatibility with legacy completion tokens.
-
-* Fixed `redirect_error` compatibility with new completion tokens.
-
-* Fixed a potential, Windows-specific program termination due to exceptions that
-  should have been allowed to escape from a destructor.
-
-* Fixed `this_coro` to prevent inadvertent `co_await` of boolean expressions.
-
-* Fixed result handling in `experimental::use_coro` implementation.
-
-* Fixed variadic template emulation for `is_async_operation` and
-  `completion_signature_of`.
-
-* Fixed incorrect reuse of a moved-from result in `experimental::promise`.
-
-* Fixed `experimental::coro` use with custom allocators.
-
-* Fixed clean up of internal I/O object structures when using [^io_uring].
-
-* Use cached offset when seeking a file with seek_cur on Windows.
-
-* Added immediate completion to asynchronous operation requirements.
-
-* Added `any_completion_handler<>`, `co_composed`, and immediate completion
-  support to the documentation overview.
-
-* Added buffer literals to the documentation.
-
-* Added a link to the
-  [@https://github.com/chriskohlhoff/asio-debugger-extensions Asio debugger
-  extensions] repository.
-
-[heading Asio 1.27.0]
-
-* Added the ability to customise the execution of a completion handler when an
-  operation completes immediately. This change adds the
-  `associated_immediate_executor` associator trait, `bind_immediate_executor`
-  function, and `immediate_executor_binder` adapter. When a supported operation
-  completes immediately (that is, within the initiating function) the
-  associated immmediate executor is obtained, and the completion handler is
-  delivered through that executor as if by using `asio::dispatch` on that
-  executor. By default, the immediate executor delivers the completion handler
-  as if using `asio::post` via the operation's I/O executor. For example, to
-  allow a recursive call to the completion handler of an `async_read_some`
-  operation, we may specify that immediate completion is delivered via a
-  `system_executor`:[br]
-  ``
-  my_socket.async_read_some(my_buffer,
-      bind_immediate_executor(
-        system_executor(),
-        [](error_code e, size_t n)
-        {
-          // ...
-        }
-      )
-    );
-  ``[br]
-  Immediate execution is currently supported for asynchronous operations on
-  reactor-based sockets and descriptors, and for asynchronous operations on
-  channels.
-
-* Added user-defined literals for buffer types. The `_buf` literal suffix,
-  defined in namespace `asio::buffer_literals`, may be used to create
-  const_buffer objects from string, binary integer, and hexadecimal integer
-  literals. These buffer literals may be arbitrarily long. For example:[br]
-  [pre
-  using namespace asio::buffer_literals;
-
-  asio::const_buffer b1 = "hello"_buf;
-  asio::const_buffer b2 = 0xdeadbeef_buf;
-  asio::const_buffer b3 = 0x01234567'89abcdef'01234567'89abcdef_buf;
-  asio::const_buffer b4 = 0b1010101011001100_buf;
-  ][br]
-  The memory associated with a buffer literal is valid for the lifetime of the
-  program. This means that the buffer can be safely used with asynchronous
-  operations:[br]
-  ``
-  async_write(my_socket, "hello"_buf, my_handler);
-  ``[br]
-
-* Added a new protocol type `local::seq_packet_protocol` to represent `AF_UNIX`
-  with `SOCK_SEQPACKET`.
-
-* Exposed `sigaction()` flags via optional argument to `signal_set::add`. When
-  registering a signal, it is now possible to pass flags that specify the
-  behaviour associated with the signal. These flags are specified as an enum
-  type in a new class, signal_set_base, and are passed to the underlying
-  `sigaction()` call. For example:[br]
-  ``
-  asio::signal_set sigs(my_io_context);
-  sigs.add(SIGINT, asio::signal_set::flags::restart);
-  ``[br]
-  Specifying flags other than `flags::dont_care` will fail unless `sigaction()`
-  is supported by the target operating system. Since signal registration is
-  global, conflicting flags (multiple registrations that pass differing flags
-  other than `flags::dont_care`) will also result in an error.
-
-* Change `allocator_binder`, `executor_binder`, and `cancellation_slot_binder`
-  to support detection of unspecialised associators.
-
-* Fixed ambiguity in `associated_cancellation_slot<reference_wrapper>::get()`.
-
-* Fixed `awaitable` handling for completion signatures containing
-  `std::exception_ptr`.
-
-* Fixed `experimental::channel` `try_send` failure after a `cancel`.
-
-* Fixed `thread_pool::join()` deadlock when the pool has no internal threads.
-
-* Fixed pipe `release()` when using [^io_uring].
-
-* Fixed a data initialisation issue in the [^io_uring] backend.
-
-* Fixed a dangling reference issue in the execution context overload of
-  `get_associated_executor`.
-
-* Ensured buffered messages can still be received when an
-  `experimental::channel` is closed.
-
-* Fixed the `any_completion_handler` assignment operator to work correctly.
-
-* Constrained the constructor of the move-only class template
-  `any_completion_handler` to prevent accidental copying
-
-* Suppressed spurious 'potential null dereference' warnings.
-
-* Changed to use `uint64_t` for OpenSSL options, to match OpenSSL 3.
-
-* Fixed `deferred` interoperability with multiple completion signatures.
-
-* Fixed channels to support C++11 and later. Note that for C++11 and C++14,
-  support is limited to channels with a single completion signature, or
-  channels with a void() signature (plus the error signature added by the
-  channel traits).
-
-* Added `any_completion_handler` to the documentation.
-
-[heading Asio 1.26.0]
-
-* Fixed `spawn` and `co_spawn` implementations to dispatch cancellation
-  handlers on the correct executor. When a completion handler uses a specified
-  (i.e. non-default) associated executor, cancellation handlers are dispatched
-  to the executor that was passed to `spawn()` or `co_spawn()`.
-
-* Fixed `spawn` to ensure the completion handler is dispatched through the
-  correct executor.
-
-* Changed to use `snprintf` rather than `sprintf` on latest Xcode, to address
-  deprecation warnings.
-
-* Fixed compatibility between `co_spawn` and `any_completion_handler`.
-
-* Fixed the arguments passed to `select_reactor::run` when it is run on an
-  internal thread.
-
-* Fixed compilation errors when `(BOOST_)ASIO_DISABLE_SMALL_BLOCK_RECYCLING` is
-  defined.
-
-* Updated detection of C++20 coroutine support on clang 14 and later.
-  This includes the ability to use coroutines with libstdc++.
-
-* Changed standard library feature detection to always enable
-  `std::invoke_result` when targeting C++17 or later.
-
-* Fixed detection of return type deduction with MSVC.
-
-* Added a missing include in `experimental::coro` implementation.
-
-* Updated the asynchronous operation requirements to relax the requirements on
-  the associated executor.
-
-* Added [^io_uring] to the implementation notes.
-
-[heading Asio 1.25.0]
-
-* Added the `consign` completion token adapter, which can be used to attach
-  additional values to a completion handler. This is typically used to keep at
-  least one copy of an object, such as a smart pointer, alive until the
-  completion handler is called. For example:[br]
-  ``
-  auto timer1 = std::make_shared<asio::steady_timer>(my_io_context);
-  timer1->expires_after(std::chrono::seconds(1));
-  timer1->async_wait(
-      asio::consign(
-        [](asio::error_code ec)
-        {
-          // ...
-        },
-        timer1
-      )
-    );
-  ``[br]
-
-* Added `any_completion_handler<>`, which can be used to type-erase completion
-  handlers. A typical use case is to enable separate compilation of
-  asynchronous operation implementations. For example:[br]
-  ``
-  // Header file:
-
-  void async_sleep_impl(
-      asio::any_completion_handler<void(asio::error_code)> handler,
-      asio::any_io_executor ex, std::chrono::nanoseconds duration);
-
-  template <typename CompletionToken>
-  inline auto async_sleep(asio::any_io_executor ex,
-      std::chrono::nanoseconds duration, CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(asio::error_code)>(
-        async_sleep_impl, token, std::move(ex), duration);
-  }
-
-  // Separately compiled source file:
-
-  void async_sleep_impl(
-      asio::any_completion_handler<void(asio::error_code)> handler,
-      asio::any_io_executor ex, std::chrono::nanoseconds duration)
-  {
-    auto timer = std::make_shared<asio::steady_timer>(ex, duration);
-    timer->async_wait(asio::consign(std::move(handler), timer));
-  }
-  ``[br]
-
-* Added `experimental::co_composed` which facilitates a lightweight
-  implementation of user-defined asynchronous operations using C++20
-  coroutines. The following example illustrates a simple asynchronous operation
-  that implements an echo protocol in terms of a coroutine:[br]
-  ``
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(asio::error_code)>(
-        asio::experimental::co_composed<
-          void(asio::error_code)>(
-            [](auto state, tcp::socket& socket) -> void
-            {
-              try
-              {
-                state.throw_if_cancelled(true);
-                state.reset_cancellation_state(
-                  asio::enable_terminal_cancellation());
-
-                for (;;)
-                {
-                  char data[1024];
-                  std::size_t n = co_await socket.async_read_some(
-                      asio::buffer(data), asio::deferred);
-
-                  co_await asio::async_write(socket,
-                      asio::buffer(data, n), asio::deferred);
-                }
-              }
-              catch (const asio::system_error& e)
-              {
-                co_return {e.code()};
-              }
-            }, socket),
-        token, std::ref(socket));
-  }
-  ``[br]
-
-* Add range-based experimental::make_parallel_group() overloads that may be used
-  to launch a dynamically-sized set of asynchronous operations, where all
-  operations are the same type. For example:[br]
-  ``
-  using op_type = decltype(
-      socket1.async_read_some(
-        asio::buffer(data1),
-        asio::deferred
-      )
-    );
-
-  std::vector<op_type> ops;
-  ops.push_back(
-      socket1.async_read_some(
-        asio::buffer(data1),
-        asio::deferred
-      )
-    );
-  ops.push_back(
-      socket2.async_read_some(
-        asio::buffer(data2),
-        asio::deferred
-      )
-    );
-
-  asio::experimental::make_parallel_group(ops).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::vector<std::size_t> completion_order,
-          std::vector<asio::error_code> e,
-          std::vector<std::size_t> n
-        )
-      {
-        for (std::size_t i = 0; i < completion_order.size(); ++i)
-        {
-          std::size_t idx = completion_order[i];
-          std::cout << "socket " << idx << " finished: ";
-          std::cout << e[idx] << ", " << n[idx] << "\n";
-        }
-      }
-    );
-  ``[br]
-  Thanks go to Klemens Morgenstern for supplying part of this implementation.
-
-* Added `any_completion_executor`, a type-erased wrappers for executors that
-  are associated with completion handlers.
-
-* Added missing `context` query to use_future's executor.
-
-* Added nothrow constructor overloads to `execution::any_executor<>` and
-  `any_io_executor`.
-
-* Optimised representation of empty `execution::any_executor` objects to improve
-  the performance of copy and move operations.
-
-* Added an `associated_cancellation_slot` specialisation for
-  `std::reference_wrapper`.
-
-* Changed I/O objects to return their executors by const reference.
-
-* Changed associated to use deduced return types for all two-argument `get`
-  functions.
-
-* Fixed `spawn` implementation to catch unhandled exceptions and rethrow them
-  outside of the spawned "thread".
-
-* Fixed cleanup of of terminal-state `spawn` "thread" objects.
-
-* Changed semantics of `dispatch` to mean the executor is used as-is. An
-  execution context's default executor is imbued with the possibly-blocking
-  property.
-
-* Deprecated the `execution::execute` customisation point. Use `execute` as a
-  member function.
-
-* Deprecated the concepts, traits, functions and customisation points related to
-  senders and receivers.
-
-* Added a C++11 `parallel_group` example.
-
-* Fixed example code to not use the deprecated conversion of a resolve result to
-  an endpoint.
-
-* Fixed an ambiguity in `experimental::channel_traits` specialisations.
-
-* Added a specialised channel implementation for the  for `R(error_code)`
-  signature.
-
-* Made `cancelled()` public on the `async_compose` 'self' object.
-
-* Added io_executor_type and get_io_executor to the `async_compose` 'self'
-  object.
-
-* Fixed implementation of `release()` for Windows overlapped handles.
-
-* Enabled deferred awaiting for `experimental::coro`, regularised
-  `experimental::use_coro`, and fixed allocator handling. This means that
-  `use_coro` does not return a coro object, just like use_awaitable does, i.e.
-  it's an overhead that buys us type erasure. Allocators can now be set for
-  `coro` by including `allocator_arg` in the coro signature.
-
-* Cleaned up `experimental::promise` and made it an asynchronous operation
-  object.
-
-* Constrained `post`/`defer` overloads on ability to require `blocking.never`.
-
-* Changed descriptor implementation to fall back to `fcntl` if `ioctl` fails
-  with `ENOTTY` when setting non-blocking mode.
-
-[heading Asio 1.24.0]
-
-* Improved the performance of `awaitable<>`-based coroutines when they directly
-  `co_await` an asynchronous operation, by eliminating the copy of the operation
-  object in `await_transform`.
-
-* Improved the performance of `spawn()`-based stackful coroutines by storing a
-  reference to the yield context in the completion handler, rather than storing
-  a copy of the executor.
-
-* Fixed a C++03 build error by disabling `index_sequence` emulation when
-  variadic templates are unavailable.
-
-* Fixed detection of `std::aligned_alloc` for older Apple platforms.
-
-* Removed faulty assertions from `experimental::coro` implementation.
-
-* Added defence against Qt-defined macros when building with Intel C++.
-
-* Ensured that a `spawn()`-based stackful coroutine is cleaned up immediately
-  after it completes.
-
-* Changed the implementation of the `select_reactor`, on Windows, to ensure that
-  any exception resulting from failure to recreate its interrupter's sockets
-  will be allowed to propagate out through `io_context::run()`.
-
-* Changed the MSVC version used for the `system_error` workaround, as more
-  recent runtime redistributables appear to have fixed the issue.
-
-* Changed the `async_compose` example to use a return type compatible with the
-  new `async_result` form.
-
-[heading Asio 1.23.0]
-
-* Added a deduced trailing return type, using `decltype`, to all asynchronous
-  operations' initiating functions when using C++11. This change enables the
-  new form of `async_result`, where the return type can vary per operation,
-  for C++11.
-
-* Moved `append`, `prepend`, `as_tuple`, and `deferred` to the `asio`
-  namespace, and made them compatible with C++11. These are no longer
-  experimental facilities, although the names have temporarily been retained
-  under the `asio::experimental` namespace for backwards compatibility.
-
-* Added `buffer()` overloads for contiguous containers, such as `std::span`.
-
-* Added the ability for `awaitable<>`-based coroutines to directly `co_await`
-  operations that are packaged as function objects. For example, using
-  `deferred`:[br]
-  ``
-  asio::awaitable<void> my_coro()
-  {
-    asio::steady_timer timer(co_await asio::this_coro::executor);
-    timer.expires_after(std::chrono::seconds(5));
-
-    co_await timer.async_wait(asio::deferred);
-  }
-  ``
-  or with a handcrafted function object:[br]
-  ``
-  asio::awaitable<void> my_coro()
-  {
-    asio::steady_timer timer(co_await asio::this_coro::executor);
-    timer.expires_after(std::chrono::seconds(5));
-
-    co_await [&](auto&& token)
-    {
-      return timer.async_wait(std::forward<decltype(token)>(token));
-    };
-  }
-  ``[br]
-
-* Changed `spawn()` to be a completion token-based asynchronous operation. This
-  introduces new `spawn()` overloads that conform to the requirements for
-  asynchronous operations. For example:[br]
-  ``
-  std::string do_read(asio::yield_context yield)
-  {
-    char data[1024];
-    size_t n = my_socket.async_read_some(asio::buffer(data), yield);
-    return std::string(data, n);
-  }
-
-  asio::spawn(my_executor, do_read,
-      [](std::exception_ptr ex, std::string result)
-      {
-        // ...
-      });
-  ``
-  These new `spawn()` overloads support cancellation, and the
-  `basic_yield_context` completion token has also been enhanced to support
-  move-only and variadic result types. When targeting C++11 and later, these
-  functions are implemented in terms of Boost.Context directly. The existing
-  overloads have been retained but are deprecated.
-
-* Added the `is_async_operation` trait and `async_operation` concept. The
-  `is_async_operation` trait may be used to determine if a function object, and
-  optional arguments, may be called to initiate an asynchronous operation. For
-  example, when using `deferred`:[br]
-  ``
-  auto d = my_timer.async_wait(asio::deferred);
-  static_assert(asio::is_async_operation<decltype(d)>::value);
-  ``[br]
-  or with a handcrafted asynchronous operation:[br]
-  ``
-  struct my_async_op
-  {
-    asio::ip::tcp::socket& socket_ = ...;
-
-    template <typename Token>
-    auto operator()(asio::const_buffer data, Token&& token)
-    {
-      return asio::async_write(socket_, data,
-          std::forward<Token>(token));
-    }
-  };
-
-  static_assert(
-      asio::is_async_operation<
-        my_async_op, asio::const_buffer>::value);
-  ``[br]
-
-* Added the `completion_signature_of` trait. The `completion_signature_of`
-  trait (and corresponding type alias `completion_signature_of_t`) may be used
-  to determine the completion signature of an asynchronous operation. For
-  example:[br]
-  ``
-  auto d = my_timer.async_wait(asio::deferred);
-  using sig = asio::completion_signature_of<decltype(d)>::type;
-  // sig is void(error_code)
-  ``[br]
-  or with a handcrafted asynchronous operation:[br]
-  ``
-  struct my_async_op
-  {
-    asio::ip::tcp::socket& socket_ = ...;
-
-    template <typename Token>
-    auto operator()(asio::const_buffer data, Token&& token)
-    {
-      return asio::async_write(socket_, data,
-          std::forward<Token>(token));
-    }
-  };
-
-  using sig =
-    asio::completion_signature_of<
-      my_async_op, asio::const_buffer>::type;
-  // sig is void(error_code, size_t)
-  ``[br]
-
-* Added converting move construction/assignment to posix descriptors, serial
-  ports, pipes, Windows `object_handle`, Windows stream handles, and Windows
-  random-access handles.
-
-* Added `release()` member functions to pipes, Windows stream handles, and
-  Windows random-access handles.
-
-* Enabled support for `Endpoint` implementations that return `void` pointers
-  from their `data()` member functions, as per the documented `Endpoint` type
-  requirements.
-
-* Removed `all()` and `race()` from `experimental::promise`, as
-  `experimental::parallel_group` covers this functionality.
-
-* Added source locations to exceptions and error codes produced by the
-  synchronous and asynchronous operations.
-
-* Fixed compatibility with OpenSSL 3.0.4 and later.
-
-* Fixed compatibility with with [^-masm=intel].
-
-* Explicitly stated that socket `shutdown()` calls are thread-safe with respect
-  to certain other synchronous operations on the same socket.
-
-* Optimised the move construction of I/O objects where only the executor type
-  differs.
-
-* Fixed the detection of `std::invoke_result` for clang/libc++.
-
-* Fixed an issue where `experimental::parallel_group` initiation incorrectly
-  moved arguments instead of forwarding them.
-
-* Fixed a sequencing issue in the implementation of `post()`, `dispatch()`,
-  and `defer()`, where the the associated allocator may be obtained from an
-  already moved-from completion handler.
-
-* Fixed the `awaitable<>` implementation to propagate exceptions from awaited
-  initiation functions through the current completion handler.
-
-* Fixed detection of `std::aligned_alloc` with [^gcc].
-
-* Changed to avoid using the soon-to-be-deprecated `std::aligned_storage` on
-  newer compilers.
-
-* Fixed various compiler warnings.
-
-* Updated all composed operations examples, and the C++11 timeouts example, to
-  use the new `async_result` form.
-
-* Added composed operation and coroutine examples for C++20.
-
-* Added pkg-config support.
-
-[heading Asio 1.22.2]
-
-* On Windows, changed the file support to open files using the same sharing mode
-  as `fopen()`.
-
-* On Linux, fixed the UNIX domain sockets implementation to correctly handle
-  `EAGAIN` as an indication of an in-progress connect operation.
-
-* Fixed `experimental::basic_channel::reset()` and
-  `experimental::basic_concurrent_channel::reset()` so that they work correctly
-  for an unclosed channel.
-
-* Fixed potential undefined behaviour in the `experimental::promise` operations
-  `race()` and `all()`.
-
-* Changed the `co_spawn` implementation to explicitly dispatch cancellation
-  signals through the specified executor, if the the completion handler has an
-  associated executor of its own.
-
-* Added more detailed reference documentation to `make_strand()`,
-  `make_work_guard()`, `ip::address_v4`, `ip::address_v6`,
-  `experimental::basic_channel`, and `experimental::basic_concurrent_channel`.
-
-* Re-arranged and extended the Overview documentation to cover files, pipes,
-  `async_compose`, `experimental::deferred`, `experimental::parallel_group`,
-  `experimental::promise`, channels, and completion token adapters.
-
-* Reverted the `io_context` reference documentation to use `executor_work_guard`
-  when preventing the `io_context` from running out of work.
-
-* Removed references to `deadline_timer` from the Overview documentation.
-
-* Added reference documentation cross-references to asynchronous model elements.
-
-[heading Asio 1.22.1]
-
-* Added `bind_allocator`, to simplify associating a custom allocator with a
-  completion token or handler.
-
-* Added the `file_base::sync_all_on_write` flag, which maps to `O_SYNC` on POSIX
-  and `FILE_FLAG_WRITE_THROUGH` on Windows.
-
-* Added missing implementation of `basic_file::release()`.
-
-* Added per-operation cancellation support to signal sets.
-
-* Exposed `recycling_allocator` as part of the public interface.
-
-* Added the `nodiscard` attribute to the following functions:
-  * `bind_allocator()`
-  * `bind_cancellation_slot()`
-  * `bind_executor()`
-  * `buffer()`
-  * `dynamic_buffer()`
-  * `experimental::append()`
-  * `experimental::as_single()`
-  * `experimental::as_tuple()`
-  * `experimental::make_parallel_group()`
-  * `experimental::prepend()`
-  * `get_associated_allocator()`
-  * `get_associated_cancellation_slot()`
-  * `get_associated_executor()`
-  * `make_work_guard()`
-
-* Added compatibility with OpenSSL 3.0, particularly when deprecated
-  functionality is disabled.
-
-* Added support for adopting an existing `SSL*` into an `ssl::stream<>`.
-
-* Enabled `executor_work_guard<>` even when `ASIO_NO_TS_EXECUTORS` is defined.
-
-* Enabled movable socket iostreams when using clang.
-
-* Fixed `bind_cancellation_slot` compatibility with legacy completion tokens.
-
-* Fixed `bind_executor` compatibility with legacy completion tokens.
-
-* Fixed `associator` specialisations for `experimental::append` and
-  `experimental::prepend`, to correctly propagate the associated allocator,
-  executor, and cancellation slot.
-
-* Fixed 'zero as null pointer constant' warning in C++20 coroutines
-  implementation of `awaitable`.
-
-* Ensured concurrency hint preprocessor macros are made available when
-  [^asio/io_context.hpp] is included.
-
-* Fixed issue where the primary `associated_allocator` template was not
-  correctly detecting the nested `T::allocator_type`.
-
-* Fixed [^io_uring] implementation of `async_receive_from` operation for
-  sockets.
-
-* Fixed [^io_uring] implementation of `write_some_at` operation for files.
-
-* Changed [^io_uring] implementation to correctly check that it is not the
-  default before registering with reactor.
-
-* Fixed a circular inclusion issue when using [^io_uring] in some build
-  configurations.
-
-* Fixed `experimental::coro`'s per-operation cancellation to clear the slot at
-  completion of each operation.
-
-* Fixed memory management in `experimental::promise`'s type-erased completion
-  handlers.
-
-* Fixed move `operator=` implementation for `ssl::stream`.
-
-* Fixed `any_io_executor` implementation to work when both
-  `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` and `ASIO_SEPARATE_COMPILATION` are
-  defined.
-
-* Fixed implementation of `basic_socket::at_mark()` when using the
-  `sockatmark()` system call.
-
-* Changed the recycling allocator to use the default alignment as the minimum
-  alignment for allocations.
-
-* Added additional standard header file includes, as required by newer
-  compilers.
-
-* Added a workaround for apparent coroutine codegen bug with Apple's clang.
-
-* Fixed various warnings in the examples and unit tests.
-
-* Added a C++11 example showing file descriptor passing over local sockets.
-  Thanks to Heiko Hund for providing this example.
-
-* Added C++14 examples of wrapping callback-based APIs in asynchronous
-  operations.
-
-* Added an overview of Asio's asynchronous model to the documentation.
-
-* Reworked reference documentation in terms of completion tokens.
-
-* Updated documentation of asynchronous operation requirements to use new
-  completion token form.
-
-* Updated documentation for `dispatch()`, `post()`, and `defer()` to cover both
-  the old and new executor forms.
-
-* Documented per-operation cancellation for serial ports.
-
-* Clarified the non-concurrency guarantees made for allocators.
-
-[heading Asio 1.22.0]
-
-* Improved error messages emitted by `ssl` facilities.
-
-* Fixed `bind_executor` compatibility with completion tokens.
-
-* Fixed build errors when `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` is defined.
-
-* Fixed corruption, cleanup issues in channel implementation.
-
-* Added missing move assignment operator to `awaitable<>`.
-
-* Fixed an access violation when using coroutines with MSVC, due to incorrect
-  alignment of allocated memory.
-
-* Fixed a cleanup issue in `experimental::parallel_group` that occured when the
-  execution context was shut down with parallel operations still pending.
-
-* Fixed header inclusion order problem when io_uring is enabled.
-
-* Eliminated `shared_ptr` use from `experimental::coro` `co_spawn()`
-  implementation.
-
-* Prevented `async_resume` from being called on `experimental::coro`
-  temporaries.
-
-* Made `awaitable_operators.hpp` header self-contained.
-
-* Added clarifications to the documentation on concurrency hints.
-
-* Added documentation on error handling techniques for C++20 coroutines.
-
-* Added channel-based proxy example.
-
-* Regenerated `ssl` certificates used in examples.
-
-[heading Asio 1.21.0]
-
-* Added an io_uring backend. This backend may be used for all I/O objects,
-  including sockets, timers, and posix descriptors.[br]
-  [br]
-  The backend is disabled by default, and must be enabled by defining both
-  `ASIO_HAS_IO_URING` and `ASIO_DISABLE_EPOLL`.[br]
-  [br]
-  Simply defining `ASIO_HAS_IO_URING` alone will enable the backend without
-  using it for the existing I/O objects. This allows it to be used for I/O
-  objects that require io_uring support, such as files.[br]
-  [br]
-  This support depends on the [^liburing] library at both compile and link
-  time. Add `-luring` to your list of libraries for linking.
-
-* Added support for files. This introduces new classes for stream-oriented and
-  random-access files. For example, to write to a newly created stream-oriented
-  file:[br]
-  ``
-  asio::stream_file file(
-      my_io_context, "/path/to/file",
-      asio::stream_file::write_only
-        | asio::stream_file::create
-        | asio::stream_file::truncate);
-
-  file.async_write_some(my_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-  ``[br]
-  or to read from a random-access file:[br]
-  ``
-  asio::random_access_file file(
-      my_io_context, "/path/to/file",
-      asio::random_access_file::read_only);
-
-  file.async_read_some_at(1234, my_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-  ``[br]
-  This feature currently supports I/O completion ports on Windows, and io_uring
-  on Linux (define `ASIO_HAS_IO_URING` to enable).
-
-* Added support for portable pipes. This change add supports for pipes on POSIX
-  and Windows (when I/O completion ports are available). For example, to create
-  and use a connected pair of pipe objects:[br]
-  ``
-  asio::readable_pipe read_end;
-  asio::writable_pipe write_end;
-  asio::connect_pipe(read_end, write_end);
-
-  write_end.async_write_some(my_write_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-
-  read_end.async_read_some(my_read_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-  ``[br]
-
-* Added support for registered buffers. The `mutable_registered_buffer` and
-  `const_registered_buffer` classes are buffer sequence types that represent
-  registered buffers. These buffers are obtained by first performing a buffer
-  registration:[br]
-  ``
-    auto my_registration =
-      asio::register_buffers(
-          my_execution_context,
-          my_buffer_sequence);
-  ``[br]
-  The registration object must be maintained for as long as the buffer
-  registration is required. The supplied buffer sequence represents the
-  memory location or locations that will be registered, and the caller
-  must ensure they remain valid for as long as they are registered. The
-  registration is automatically removed when the registration object is
-  destroyed. There can be at most one active registration per execution
-  context.[br]
-  [br]
-  The registration object is a container of registered buffers. Buffers
-  may be obtained from it by iterating over the container, or via direct
-  index access:[br]
-  ``
-    asio::mutable_registered_buffer my_buffer
-      = my_registration[i];
-  ``[br]
-  The registered buffers may then be passed directly to operations:[br]
-  ``
-  asio::async_read(my_socket, my_buffer,
-      [](error_code ec, size_t n)
-      {
-        // ...
-      });
-  ``[br]
-  Buffer registration supports the io_uring backend when used with read and
-  write operations on descriptors, files, pipes, and sockets. For portability,
-  the facility may be used on other platforms, but the registered buffers will
-  behave as normal buffers.
-
-* Added experimental support for channels. This adds templates
-  `experimental::basic_channel` and `experimental::basic_concurrent_channel`,
-  with aliases `experimental::channel` and `experimental::concurrent_channel`.
-  Channels may be used to send completions as messages. For example:[br]
-  ``
-  // Create a channel with no buffer space.
-  channel<void(error_code, size_t)> ch(ctx);
-
-  // The call to try_send fails as there is no buffer
-  // space and no waiting receive operations.
-  bool ok = ch.try_send(asio::error::eof, 123);
-  assert(!ok);
-
-  // The async_send operation is outstanding until
-  // a receive operation consumes the message.
-  ch.async_send(asio::error::eof, 123,
-      [](error_code ec)
-      {
-        // ...
-      });
-
-  // The async_receive consumes the message. Both the
-  // async_send and async_receive operations complete
-  // immediately.
-  ch.async_receive(
-      [](error_code ec, size_t n)
-      {
-        // ...
-      });
-  ``[br]
-
-* Implemented improvements to `experimental::coro`.
-  * Added overload so member functions can provide an explicit executor.
-  * Added `co_spawn` for `coro` tasks.
-  * Added reference and overview documentation.
-  * Adopted awaitable cancellation model.
-  * Refactored implementation.
-
-* Disabled `aligned_alloc` on [^clang] when using an MSVC runtime.
-
-* Changed to use a faster implementation for `ip::network_v4::canonical()`.
-
-* Added template specialisations for common uses to improve compile time.
-
-* Reduced the size of `io_context` executors to a single pointer.
-
-* Increased the small object buffer size for `execution::any_executor` and
-  `any_io_executor`.
-
-* Fixed multi-signature handling when variadic templates are disabled.
-
-* Fixed compatibility with new versions of [^gcc] and [^clang].
-
-* Fixed compilation on Solaris.
-
-* Fix defence against Qt-defined macros when building with MSVC.
-
-* Fixed various warnings.
-
-[heading Asio 1.20.0]
-
-* Fixed `experimental::coro` compatibility with [^gcc].
-
-* Fixed `experimental::promise` compatibility with [^gcc].
-
-* Added documentation for per-operation cancellation.
-
-* Added documentation for `parallel_group`.
-
-* Added overview documentation for `experimental::coro`.
-
-* Added some missing C++14 examples.
-
-* Updated C++20 coroutines overview documentation.
-
-[heading Asio 1.19.2]
-
-* Cleaned up memory recycling to ensure the cache size is used consistently.
-
-* Changed `parallel_group` to use the recycling allocator for shared state.
-
-* Changed `awaitable` memory recycling to use the configurable cache size.
-
-* Ensured `parallel_group` respects operations' associated executors.
-
-* Added defence against macros defined by Qt.
-
-* Added missing `boost_` prefix to namespaces during boostification.
-
-* Added missing lvalue-qualified overloads for `deferred` operator().
-
-* Added a tag to disambiguate `deferred` constructors.
-
-* Added missing `push`/`pop_options` includes.
-
-* Fixed argument evaluation order issue with a potentially moved-from variable
-  in `awaitable` implementation.
-
-* Enabled "expression SFINAE" for recent MSVC using `/std:c++latest`.
-
-* Fixed compilation errors when `dev_poll_reactor` backend is used.
-
-* Fixed handler type requirements checking to reflect rvalue completion handler
-  invocation.
-
-* Fixed `posix::basic_stream_descriptor` move operations to work with
-  non-defaulted executors.
-
-* Added missing move of executor in strand implementation.
-
-[heading Asio 1.19.1]
-
-* Fixed handling of move-only results with awaitable operators `&&` and `||`.
-
-* Fixed `strand<>` to avoid using a potentially moved-from executor.
-
-* Fixed order of `_aligned_malloc` arguments for MSVC.
-
-* Ensured handler alignment requirements are respected by `cancellation_signal`.
-
-* Ensured [^gcc] tests are not used for [^clang] when detecting compiler
-  features.
-
-* Disabled coroutines support for the [^clang] shipped with MSVC.
-
-* Fixed compatibility with recent LibreSSL when `OPENSSL_NO_SSL_INTERN` is
-  defined.
-
-* Documented supported cancellation types for individual asynchronous
-  operations.
-
-* Ensured un-cancelled ops are correctly placed back in the queue.
-
-[heading Asio 1.19.0]
-
-* Added support for cancellation of individual asynchronous operations.
-  Cancellation is implemented by having each completion handler carry an
-  associated `CancellationSlot`, a lightweight cancellation channel that is
-  specified through the new `associated_cancellation_slot` associator. A
-  concrete `CancellationSlot` implementation is provided in the form of the
-  `cancellation_signal` and `cancellation_slot` classes. In conjunction with
-  the `bind_cancellation_slot` helper function, these may be used to hook
-  cancellation into asynchronous operations. However, it should be noted that
-  these classes are the low-level building blocks of cancellation, and most use
-  cases should use a higher level abstraction for cancellation, such as
-  `experimental::parallel_group` or the new logical operators for `awaitable`
-  (see below). The ability to cancel individual operations, or composed
-  operations, is currently supported by:
-  * timers
-  * sockets on POSIX and Windows
-  * POSIX descriptors
-  * Windows HANDLEs
-  * SSL streams
-  * all Asio-provided composed operations such as `async_read` and `async_write`
-  * compositions based on `async_compose`
-  * C++20 coroutines that use `awaitable`
-  * C++20 coroutines that use the new `experimental::coro` (see below)
-  * the new `experimental::parallel_group` operation (see below)
-  * the new `experimental::promise` class (see below)
-
-* Added the `associator` trait. The `associator` trait is used to generically
-  forward associators, such as `associated_executor` and `associated_allocator`,
-  through intermediate completion handlers. For example:[br]
-  ``
-  template <typename Handler>
-  struct intermediate_handler
-  {
-    Handler handler_;
-
-    template <typename... Args>
-    void operator()(Args&... args)
-    {
-      // ...
-    }
-  };
-
-  namespace asio {
-    template <
-        template <typename, typename> class Associator,
-        typename Handler,
-        typename DefaultCandidate>
-    struct associator<
-        Associator,
-        intermediate_handler<Handler>,
-        DefaultCandidate>
-    {
-      using type =
-        typename Associator<Handler, DefaultCandidate>::type;
-
-      static type get(
-          const intermediate_handler<Handler>& h,
-          const DefaultCandidate& c = DefaultCandidate()) noexcept
-      {
-        return Associator<Handler, DefaultCandidate>::get(
-            h.handler_, c);
-      }
-    };
-  } // namespace asio
-  ``[br]
-
-* Changed all asynchronous operations implemented in Asio to invoke their
-  completion handlers as rvalue references. This allows an rvalue reference
-  qualifier to be added to the function call operator.
-
-* Added support for asynchronous operations with multiple completion signatures.
-  Completion signatures may also specify that they are `noexcept`, and whether
-  they are lvalue-invocable (and thus do not "consume" the completion handler)
-  or rvalue-invocable (and thus do "consume" the handler, indicating an end to
-  the asynchronous operation). For example:[br]
-  ``
-  auto my_async_operation(...,
-      asio::completion_token_for<
-        void(intermediate_result_type) & noexcept,
-        void(final_result_type) &&
-      > auto&& token)
-  {
-    // ...
-  }
-  ``[br]
-
-* Added `operator&&` and `operator||` for `awaitable<>`. The logical operators
-  `||` and `&&` have been overloaded for `awaitable<>`, to allow coroutines to
-  be trivially awaited in parallel.[br]
-  [br]
-  When awaited using `&&`, the `co_await` expression waits until both operations
-  have completed successfully. As a "short-circuit" evaluation, if one
-  operation fails with an exception, the other is immediately cancelled.
-  For example:[br]
-  ``
-  std::tuple<std::size_t, std::size_t> results =
-    co_await (
-      async_read(socket, input_buffer, use_awaitable)
-        && async_write(socket, output_buffer, use_awaitable)
-    );
-  ``[br]
-  When awaited using `||`, the `co_await` expression waits until either
-  operation succeeds. As a "short-circuit" evaluation, if one operation
-  succeeds without throwing an exception, the other is immediately cancelled.
-  For example:[br]
-  ``
-  std::variant<std::size_t, std::monostate> results =
-    co_await (
-      async_read(socket, input_buffer, use_awaitable)
-        || timer.async_wait(use_awaitable)
-    );
-  ``[br]
-  The operators may be enabled by adding the `#include`:[br]
-  ``
-  #include <asio/experimental/awaitable_operators.hpp>
-  ``[br]
-  and then bringing the contents of the `experimental::awaitable_operators`
-  namespace into scope:[br]
-  ``
-  using namespace asio::experimental::awaitable_operators;
-  ``[br]
-
-* Added the `experimental::as_tuple` completion token adapter. The `as_tuple`
-  completion token adapter can be used to specify that the completion handler
-  arguments should be combined into a single tuple argument. The `as_tuple`
-  adapter may be used in conjunction with `use_awaitable` and structured
-  bindings as follows:[br]
-  ``
-  auto [e, n] = co_await socket.async_read_some(
-      asio::buffer(data), as_tuple(use_awaitable));
-  ``[br]
-  Alternatively, it may be used as a default completion token like so:[br]
-  ``
-  using default_token = as_tuple_t<use_awaitable_t<>>;
-  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-  // ...
-  awaitable<void> do_read(tcp_socket socket)
-  {
-    // ...
-    auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
-    // ...
-  }
-  ``[br]
-
-* Added the `experimental::append` completion token adapter. The `append`
-  completion token adapter can be used to pass additional completion handler
-  arguments at the end of the completion signature. For example:[br]
-  ``
-  timer.async_wait(
-      asio::experimental::append(
-        [](std::error_code ec, int i)
-        {
-          // ...
-        },
-      42)
-    );
-
-  std::future<int> f = timer.async_wait(
-      asio::experimental::append(
-        asio::use_future,
-        42
-      )
-    );
-  ``[br]
-
-* Added the `experimental::prepend` completion token adapter. The `prepend`
-  completion token adapter can be used to pass additional arguments before the
-  existing completion handler arguments. For example:[br]
-  ``
-  timer.async_wait(
-      asio::experimental::prepend(
-        [](int i, std::error_code ec)
-        {
-          // ...
-        },
-      42)
-    );
-
-  std::future<std::tuple<int, std::error_code>> f = timer.async_wait(
-      asio::experimental::prepend(
-        asio::use_future,
-        42
-      )
-    );
-  ``[br]
-
-* Added the `experimental::deferred` completion token. The `deferred`
-  completion token takes a call to an asynchronous operation's initiating
-  function and turns it into a function object that accepts a completion token.
-  For example:[br]
-  ``
-  auto deferred_op =
-    timer.async_wait(
-      asio::experimental::deferred);
-  ...
-  std::move(deferred_op)(
-      [](std::error_code ec){ ... });
-  ``[br]
-  or:[br]
-  ``
-  auto deferred_op =
-    timer.async_wait(
-      asio::experimental::deferred);
-  ...
-  std::future<void> =
-    std::move(deferred_op)(
-      asio::use_future);
-  ``[br]
-  The deferred token also supports chaining, to create simple compositions:[br]
-  ``
-  auto deferred_op =
-    timer.async_wait(
-      asio::experimental::deferred(
-        [&](std::error_code ec)
-        {
-          timer.expires_after(
-              std::chrono::seconds(1));
-
-          return timer.async_wait(
-              asio::experimental::deferred);
-        });
-  ...
-  std::future<void> = std::move(deferred_op)(asio::use_future);
-  ``[br]
-
-* Added the `experimental::parallel_group` class and
-  `experimental::make_parallel_group` function. This utility may be used to
-  launch work that is performed in parallel, and wait for one or all of the
-  operations to complete. A `parallel_group` implements automatic cancellation
-  of incomplete operations. For example:[br]
-  ``
-  experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return stream.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      experimental::wait_for_one(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        // ...
-      }
-    );
-  ``[br]
-  The conditions for completion of the group may be specified using one of the
-  four provided function objects `wait_for_all`, `wait_for_one`,
-  `wait_for_one_success`, and `wait_for_one_error`, or with a custom function.
-  The `parallel_group` class can also be combined with `deferred` as
-  follows:[br]
-  ``
-  experimental::make_parallel_group(
-      stream.async_read_some(asio::buffer(data), experimental::deferred),
-      timer.async_wait(experimental::deferred)
-    ).async_wait(
-      // ...
-    );
-  ``[br]
-  Note: for maximum flexibility, `parallel_group` does not propagate the
-  executor automatically to the operations within the group.
-
-* Added `experimental::promise`. The `promise` type allows eager execution and
-  synchronisation of async operations. For example:[br]
-  ``
-  auto promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  ... do other stuff while the read is going on ...
-
-  promise.async_wait( // completion the operation
-      [](error_code ec, std::size_t bytes_read)
-      {
-        ...
-      });
-  ``[br]
-  Promises can be safely disregarded if the result is no longer required.
-  Different operations can be combined to either wait for all to complete
-  or for one to complete (and cancel the rest). For example, to wait for
-  one to complete:[br]
-  ``
-  auto timeout_promise =
-    timer.async_wait(
-      asio::experimental::use_promise);
-
-  auto read_promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  auto promise =
-    asio::experimental::promise<>::race(
-      timeout_promise, read_promise);
-
-  promise.async_wait(
-      [](std::variant<error_code, std::tuple<error_code, std::size_t>> v)
-      {
-        if (v.index() == 0) {} //timed out
-        else if (v.index() == 1) // completed in time
-      });
-  ``[br]
-  or to wait for all to complete:[br]
-  ``
-  auto write_promise = async_write(
-      stream, asio::buffer(my_write_buffer),
-      asio::experimental::use_promise);
-
-  auto read_promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  auto promise =
-    asio::experimental::promise<>::all(
-      write_promise, read_promise);
-
-  promise.async_wait(
-      [](std::tuple<error_code, std::size_t> write_result,
-        std::tuple<error_code, std::size_t> read_result)
-      {
-      });
-  ``[br]
-  Thanks go to Klemens Morgenstern for contributing this feature.
-
-* Added the `experimental::coro` class template. The `coro` type is a C++20
-  coroutine primitive for resumable functions, with the ability to combine both
-  asynchronous waiting (`co_await`) and yielding (`co_yield`) into a single,
-  stateful control flow. For example:[br]
-  ``
-  #include <asio.hpp>
-  #include <asio/experimental/coro.hpp>
-
-  using asio::ip::tcp;
-
-  asio::experimental::coro<std::string> reader(tcp::socket& sock)
-  {
-    std::string buf;
-    while (sock.is_open())
-    {
-      std::size_t n = co_await asio::async_read_until(
-          sock, asio::dynamic_buffer(buf), '\n',
-          asio::experimental::use_coro);
-      co_yield buf.substr(0, n);
-      buf.erase(0, n);
-    }
-  }
-
-  asio::awaitable<void> consumer(tcp::socket sock)
-  {
-    auto r = reader(sock);
-    auto msg1 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 1: " << msg1.value_or("\n");
-    auto msg2 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 2: " << msg2.value_or("\n");
-  }
-
-  asio::awaitable<void> listen(tcp::acceptor& acceptor)
-  {
-    for (;;)
-    {
-      co_spawn(
-          acceptor.get_executor(),
-          consumer(co_await acceptor.async_accept(asio::use_awaitable)),
-          asio::detached);
-    }
-  }
-
-  int main()
-  {
-    asio::io_context ctx;
-    tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
-    co_spawn(ctx, listen(acceptor), asio::detached);
-    ctx.run();
-  }
-  ``[br]
-  Thanks go to Klemens Morgenstern for contributing this feature.
-
-* Added move assignment to `ssl::stream<>`.
-
-* Changed `co_spawn` to `dispatch` the coroutine's initial step to the executor,
-  and to only `post` the completion handler if the coroutine did not otherwise
-  perform a context switch (i.e. a `co_await` on an asynchronous operation).
-
-* Enabled additional optimisations for `any_executor` and `any_io_executor`
-  when used with asynchronous operations.
-
-* Added the `nodiscard` attribute to `awaitable<>`.
-
-* Increased the number of cached slots in the default recycling allocator.
-  This number defaults to 2, but may also be specified by defining the
-  `ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE` macro.
-
-* Disabled the `std::system_error` message workaround for recent MSVC.
-
-* Changed the default allocator behaviour to respect alignment requirements,
-  to support over-aligned types. Requires C++17 or later, or Boost.
-
-* Ensured the result strings are always initialised in reverse name resolution.
-
-* Fixed recursive template instantiation issues in
-  `use_awaitable_t::executor_with_default`.
-
-* Fixed the `any_io_executor` equality operators to correctly return a result
-  based on the target executor.
-
-[heading Asio 1.18.2]
-
-* Added `ip::scope_id_type` type alias.
-
-* Added `ip::port_type` type alias.
-
-* Added `std::hash` specialisations for IP addresses.
-
-* Added `std::hash` specialisations for `ip::basic_endpoint<>`.
-
-* Refactored SFINAE usage to improve compile times.
-
-* Added friendship support to customisation points, and made most
-  customisations private.
-
-* Changed `any_io_executor` to a "strong typedef"-style class.
-
-* Fixed `experimental::as_single` to work with handler hook deprecation.
-
-* Ensured pthread condition variable attributes are cleaned up on all
-  platforms.
-
-* Clarified thread safety notes on sockets and descriptors.
-
-* Ensured `errno` is not overwritten if `socket()` fails on macOS/FreeBSD.
-
-* Fixed work tracking for `io_context` and `thread_pool` executors when
-  move-assigned.
-
-* Ensured internal `call_stack` objects are accessed only from implementation
-  files.
-
-* Fixed I/O object move-assignment to ensure the executor is left in a valid
-  state.
-
-* Fixed detection of compiler support for defaulted template argument on
-  functions with MSVC.
-
-* Prevented the `blocking.always` property from being used with `strand<>`, as
-  it did not produce the correct semantics.
-
-* Removed deprecated file [^asio/impl/src.cpp].
-
-[heading Asio 1.18.1]
-
-* Enabled support for UNIX domain sockets on Windows. From Windows 10, UNIX
-  domain sockets (a.k.a "local" sockets) are supported on Windows, with the
-  exception of the `connect_pair` function (which will fail with an
-  operation_not_supported error).
-
-* Added executor-converting construction and assignment to `ip::basic_resolver`.
-
-* Added compatibility between polymorphic executors and the (deprecated) handler
-  invocation hook.
-
-* Added the `experimental::as_single` completion token adapter. The `as_single`
-  completion token adapter can be used to specify that the completion handler
-  arguments should be combined into a single argument. For completion signatures
-  with a single parameter, the argument is passed through as-is. For signatures
-  with two or more parameters, the arguments are combined into a tuple. The
-  `as_single` adapter may be used in conjunction with `use_awaitable` and
-  structured bindings as follows:[br]
-  ``
-  auto [e, n] = co_await socket.async_read_some(
-      asio::buffer(data), as_single(use_awaitable));
-  ``[br]
-  Alternatively, it may be used as a default completion token like so:[br]
-  ``
-  using default_token = as_single_t<use_awaitable_t<>>;
-  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-  // ...
-  awaitable<void> do_read(tcp_socket socket)
-  {
-    // ...
-    auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
-    // ...
-  }
-  ``[br]
-
-* Added support for `MSG_NOSIGNAL` on more platforms by using  `_POSIX_VERSION`
-  to detect whether it is supported.
-
-* Added the ability to compile using libpthread on Windows.
-
-* Added workarounds for the Intel C++ compiler.
-
-* Added more support for detecting and optimising for handlers that have no
-  custom executor.
-
-* Reduced lock contention for timer cancellation on Windows.
-
-* Reinstated a previously removed null-pointer check, as it had a measurable
-  impact on performance.
-
-* Fixed the `executor` concept to test for a const-qualified `execute()`.
-
-* Fixed `any_executor` support for builds without RTTI support.
-
-* Fixed the `thread_pool` unit test to work without RTTI support.
-
-* Fixed C++20 coroutines compatibility with clang on Windows.
-
-* Fixed some compatibility issues with Windows Runtime.
-
-* Fixed shadow name warnings caused by addition of `asio::query`.
-
-* Fixed a "logical ‘or’ of equal expressions" warning on linux.
-
-* Fixed a benign switch fallthrough warning.
-
-* Added missing `push/pop_options.hpp` includes.
-
-* Suppressed zero-as-null-pointer-constant warnings.
-
-* Fixed a comma-operator warning.
-
-* Updated the documentation to clarify when the [^select] reactor is used on
-  Windows.
-
-* Fixed potential ambiguity caused by `any_executor` comparisons and conversion.
-
-* Added detection of non-experimental C++20 coroutines on MSVC 19.8.
-
-* Fixed compatibility with uClibc.
-
-* Fixed `strand<>` adaptation of Networking TS executors when targeting older
-  C++ versions or less conformant compilers.
-
-[heading Asio 1.18.0]
-
-* Marked the `basic_socket_acceptor` move constructor as `noexcept`.
-
-* Added workarounds for various issues in [^gcc] 10's coroutine support.
-
-* Added standard executor support to `windows::overlapped_ptr`.
-
-* Added missing compatibility macros for the `execution::receiver_of` concept.
-
-* Added short-circuited evaluation to `execution::executor`,
-  `execution::operation_state`,`execution::sender`, `execution::receiver`,
-  `execution::receiver_of`, and `execution::scheduler` concepts and the
-  corresponding traits. These now test first for well-formed CPO expressions
-  (or, in the case of senders, a specialised `sender_traits` template) and, if
-  not valid, short-circuit the remainder of the evaluation. This helps prevent
-  recursive template instantiations that can occur in some contexts.
-
-* Added constraints to the `strand` template's constructor, to prevent template
-  instantiation recursion.
-
-* Changed Asio's internal executor adapters to prevent template instantiation
-  recursion.
-
-* Added constraints to the `execution::any_executor` template's converting
-  constructors, as per the specification.
-
-* Added missing `execution::sender_traits` specialisation and `connect()`
-  member function to the `thread_pool` executor, as per the specification.
-
-* Changed `execution::blocking_t::always_t::is_preferable` to be false as per
-  the specification.
-
-* Added `shape_type` and `index_type` to `thread_pool` executors, as per the
-  specification.
-
-* Ensured that the standard executor concept-related traits (such as
-  `execution::is_executor`) work with `void`.
-
-* Fixed `async_compose` support for standard executors.
-
-* Fixed the forward declaration of `any_io_executor` in [^asio/ts/netfwd.hpp].
-
-* Fixed `use_future` compatibility with older compilers.
-
-* Fixed compatibility with MinGW.
-
-* Improved compatibility with older versions of [^gcc].
-
-* Added compatiblity with [^clang-cl] on Windows.
-
-* Fixed various compiler warnings.
-
-* Added basic overview documentation for the standard executors support.
-
-* Added detailed descriptions to the standard executor-related member functions
-  of `io_context` executors, `thread_pool` executors, `system_executor`, and
-  `strand<>`.
-
-* Changed introductory documentation to reflect that there our now multiple
-  types of I/O execution context.
-
-* Marked constructors, destructors, and static data members in class synopses
-  in the reference documentation.
-
-* Fixed various minor documentation errors.
-
-[heading Asio 1.17.0]
-
-* Added an implementation of the proposed standard executors
-  ([@http://wg21.link/P0443r13 P0443r13], [@http://wg21.link/P1348r0 P1348r0],
-  and [@http://wg21.link/P1393r0 P1393r0]).
-
-* Added support for the proposed standard executors to Asio's I/O facilities:
-
-  * The `io_context::executor_type`, `thread_pool::executor_type`,
-    `system_executor`, and `strand` executors now meet the requirements for the
-    proposed standard executors. These classes also continue to meet the
-    existing requirements for the Networking TS model of executors.
-
-  * All I/O objects, asynchronous operations, and utilities including
-    `dispatch`, `post`, `defer`, `get_associated_executor`, `bind_executor`,
-    `make_work_guard`, `spawn`, `co_spawn`, `async_compose`, `use_future`,
-    etc., can interoperate with both new proposed standard executors, and with
-    existing Networking TS executors. The implementation determines at compile
-    time which model a particular executor meets; the proposed standard
-    executor model is used in preference if both are detected.
-
-  * The `any_io_executor` type alias has been introduced as the new default
-    runtime-polymorphic executor for all I/O objects. This type alias points to
-    the `execution::any_executor<>` template with a set of supportable
-    properties specified for use with I/O. This change may break existing code
-    that directly uses the old polymorphic wrapper, `executor`. If required for
-    backward compatibility, `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` can be defined,
-    which changes the `any_io_executor` type alias to instead point to the
-    `executor` polymorphic wrapper.
-
-  * Support for the existing Networking TS model of executors can be disabled
-    by defining `ASIO_NO_TS_EXECUTORS`.
-
-* Added converting move construction and assignment to `basic_waitable_timer`.
-  This enables move construction and assignment between different timer
-  types, provided the executor types are convertible. For example:[br]
-  ``
-  basic_waitable_timer<
-      clock_type,
-      traits_type,
-      io_context::executor_type
-    > timer1(my_io_context);
-
-  basic_waitable_timer<
-      clock_type,
-      traits_type,
-      any_io_executor // polymorphic wrapper
-    > timer2(std::move(timer1));
-  ``[br]
-
-* Enabled C++20 coroutine support when using [^gcc] 10.
-
-* Added overloads of `co_spawn` that launch an awaitable. This change allows us
-  to write:[br]
-  ``
-  co_spawn(executor,
-      echo(std::move(socket)),
-      detached);
-  ``[br]
-  instead of:[br]
-  ``
-  co_spawn(executor,
-      [socket = std::move(socket)]() mutable
-      {
-        return echo(std::move(socket));
-      },
-      detached);
-  ``[br]
-
-* Added a new constructor overload to `use_awaitable_t`'s default executor
-  adapter, to enable conversion between executor types.
-
-* Added support for using `detached_t` as a default completion token, by
-  adding members `as_default_on()` and `as_default_on_t<>`.
-
-* Added a move constructor to `ssl::stream<>`.
-
-* Changed `ssl::stream<>` write operations to linearise gather-write buffer
-  sequences.
-
-* Added compile-time detection of the deprecated `asio_handler_invoke` hook.
-  This hook was deprecated with the introduction of the Networking TS trait
-  `associated_executor` and function `get_associated_executor()`. Compiling
-  an application with `ASIO_NO_DEPRECATED` will now trigger a compile error if
-  any handler implements the `asio_handler_invoke` hook.
-
-* Added compile-time detection of the deprecated `asio_handler_allocate`
-  and `asio_handle_deallocate` hooks. These hooks were deprecated with the
-  introduction of the Networking TS trait `associated_allocator` and function
-  `get_associated_allocator()`. Compiling an application with
-  `ASIO_NO_DEPRECATED` will now trigger a compile error if any handler
-  implements the `asio_handler_allocate` or `asio_handler_deallocate` hooks.
-
-* Implemented a number of performance optimisations, including:
-
-  * Specialising single-buffer operations to use `recv` rather than `recvmsg`,
-    `send` rather than `sendmsg`, `read` rather than `readv`, and `write`
-    rather than `writev`.
-
-  * Lightening the reference counting overhead of the polymorphic wrapper
-    `executor`.
-
-  * Returning from system call operation wrappers as early as possible, and
-    only accessing `errno` and error codes when on an error path.
-
-  * Applying additional optimisations if a "native" I/O executor (such as
-    `io_context::exeutor_type`) is detected.
-
-* Added source location support to handler tracking. The new
-  `ASIO_HANDLER_LOCATION((file_name, line, function_name))` macro may be used
-  to inform the handler tracking mechanism of a source location. This macro
-  declares an object that is placed on the stack. Then, when an asynchronous
-  operation is launched with location information, it outputs lines using the
-  [*<action>] [^n^m], prior to the [^n*m] line that signifies the beginning
-  of the asynchronous operation. For example:
-  [pre
-  @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
-  @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
-  @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
-  @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
-  @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
-  @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
-  @asio|1589423304.861980|<7|][br]
-  If `std::source_location` or `std::experimental::source_location` are
-  available, the `use_awaitable_t` token (when default-constructed or used as a
-  default completion token) will also cause handler tracking to output a source
-  location for each newly created asynchronous operation. A `use_awaitable_t`
-  object may also be explicitly constructed with location information.
-
-* Implemented various improvements to the [^handlerviz.pl] tool.
-
-  * Add nodes for pending handlers at bottom of graph, outlined in red.
-
-  * Display source location in a tooltip on the edge label (for SVG).
-
-  * Use invisible nodes to enforce order to keep related control flow vertical.
-
-* Added the [^handlerlive.pl] tool, which processes handler tracking output to
-  produce a list of "live" handlers. Live handlers are those that are
-  associated with pending asynchronous operations, as well as handlers that are
-  currently executing. For example:
-  ``
-  cat output.txt | perl handlerlive.pl
-  ``
-  or:
-  ``
-  perl handerlive.pl < output.txt
-  ``
-  or:
-  ``
-  perl handlerlive.pl output.txt
-  ``[br]
-
-* Added the [^handlertree.pl] tool, which filters handler tracking output to
-  include only those events in the tree that produced the nominated handlers.
-  For example, to filter the output to include only the events associated with
-  handlers `123`, `456`, and their predecessors:
-  [pre
-  cat output.txt | perl handlertree.pl 123 456]
-  or:
-  [pre
-  perl handlertree.pl 123 456 < output.txt][br]
-  This script may be combined with handerlive.pl and handlerviz.pl to produce a
-  graph of the "live" asynchronous operation chains. For example:
-  [pre
-  cat output.txt | \
-    perl handlertree.pl `perl handlerlive.pl output.txt` | \
-    perl handlerviz.pl | \
-    dot -Tsvg > output.svg][br]
-
-* Added changes for clang-based Embarcadero C++ compilers.
-
-* Fixed a deadlock that can occur when multiple threads concurrently initialise
-  the Windows I/O completion port backend.
-
-* Fixed `async_compose` to work with copyable handlers when passed by lvalue.
-
-* Fixed completion signature deduction in `co_spawn`.
-
-* Removed a spurious `Executor` base class from the `executor_binder`
-  implementation.
-
-* Various fixes and improvements in the documentation and examples.
-
-[heading Asio 1.16.1]
-
-* Fixed compatibility with C++20 concept syntax.
-
-* Marked the POSIX descriptor classes' move constructors as `noexcept`.
-
-* Added the `ssl::host_name_verification` class, which is a drop-in replacement
-  for `ssl::rfc2818_verification`. The `ssl::rfc2818_verification` class has
-  been marked as deprecated. As a consequence of this change, SSL support now
-  depends on functions that were introduced in OpenSSL 1.0.2.
-
-* Added an `ssl::context` constructor to take ownership of a native handle.
-
-* Changed C++ language version detection with [^gcc] to use `__cplusplus` macro.
-
-* Fixed a work counting issue in the asynchronous resolve operation for
-  endpoints.
-
-* Fixed the `strand<>` converting constructors and assignment operators.
-
-* Ensured that resolvers are restarted correctly after a fork.
-
-* Fixed compatibility with the current NetBSD release.
-
-* Removed spurious handler requirement checks in some `async_read` overloads.
-
-* Changed the `ssl::context` class to propagate non-EOF errors from the
-  `add_certificate_authority` function.
-
-* Fixed a Windows-specific `thread_pool` destructor hang that occurred when the
-  pool had an associated I/O object.
-
-* Changed the [^select] reactor to recreate the "self pipe trick" sockets on
-  error. This addresses an issue on some versions of Windows, where these
-  sockets are discconected after a system sleep.
-
-* Fixed a compile error in the buffered streams due to the lack of reference
-  collapsing in C++98.
-
-* Changed the `priority_scheduler` example to demonstrate calls to `shutdown()`
-  and `destroy()`.
-
-* Removed some unnecessary null pointer checks.
-
-* Changed Windows platform detection to recognise TV titles as Windows apps.
-
-* Added some emscripten compatibility patches.
-
-* Fixed a compile error in the `use_awaitable_t::as_default_on` function.
-
-* Changed all uses of the boost.bind placeholders to use the
-  `boost::placeholders` namespace.
-
-* Fixed a potential compile error in the `async_compose` implementation due to
-  incorrect overload selection.
-
-* Suppressed some non-virtual destructor warnings.
-
-* Various documentation fixes and improvements.
-
-[heading Asio 1.16.0]
-
-* Changed the `async_initiate` helper function to automatically deduce its
-  return type. This is enabled for C++11 or later.
-
-* Changed all asynchronous operations to use automatically deduced return
-  types. This allows completion token implementations to incorporate the
-  asynchronous operation initiation into the initiating function's return type,
-  without type erasure. Note that C++14 or later is required to support
-  completion tokens that use per-operation return type deduction. For C++11 or
-  earlier, a completion token's async_result specialisation must still provide
-  the nested typedef `return_type`.
-
-* Introduced three new concepts to support `async_initiate`.
-  * `completion_signature<T>`: Checks if `T` is a signature of the form
-    `R(Args...)`.
-  * `completion_handler_for<T, Signature>`: Checks if `T` is usable as a
-    completion handler with the specified signature.
-  * `completion_token_for<T, Signature>`: Checks if `T` is a completion token
-    that can be used with async_initiate and the specified signature.
-  * For backward compatibility with pre-concepts C++, the macros
-    `(BOOST_)ASIO_COMPLETION_SIGNATURE`, `(BOOST_)ASIO_COMPLETION_HANDLER_FOR`, and
-    `(BOOST_)ASIO_COMPLETION_TOKEN_FOR` are provided. These macros expand to
-    `typename` when concepts are unsupported.
-
-* Added the nested template type `rebind_executor` to all I/O object types, as
-  a way to generically rebind them to use alternative I/O executors. For
-  example:
-  ``
-  using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other;
-  ``[br]
-
-* Changed the asynchronous operations' initiation function objects to report
-  their associated I/O executor via the nested type `executor_type` and member
-  function `get_executor()`. Note that the presence of `executor_type` and
-  `get_executor()` should be treated as optional, and consequently it may be
-  preferable to access them via the `associated_executor` trait and the
-  `get_associated_executor()` helper function.
-
-* Added the `default_completion_token` trait, so that every I/O executor type
-  now has an associated default completion token type. This trait may be used
-  in asynchronous operation declarations as follows:
-  ``
-  template <
-      typename IoObject,
-      typename CompletionToken =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type
-    >
-  auto async_xyz(
-      IoObject& io_object,
-      CompletionToken&& token =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type{}
-    );
-  ``[br]
-  If not specialised, this trait type is `void`, meaning no default completion
-  token type is available for the given I/O executor.
-
-* Specialised the `default_completion_token` trait for the `use_awaitable`
-  completion token, so that it may be used as shown in the following example:
-  ``
-  auto socket = use_awaitable.as_default_on(tcp::socket(my_context));
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-  ``[br]
-  In this example, the type of the `socket` object is transformed from
-  `tcp::socket` to have an I/O executor with the default completion token set
-  to `use_awaitable`. Alternatively, the socket type may be computed directly:
-  ``
-  using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
-  tcp_socket socket(my_context);
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-  ``[br]
-
-* Added missing `async_initiate` to the Windows-specific I/O objects'
-  asynchronous operations.
-
-* Ensured that the executor type is propagated to newly accepted sockets.
-  When synchronously or asynchronously accepting a new connection, but
-  without specifying an executor or execution context, the accept
-  operation will now correctly propagate the executor type from the
-  acceptor to the socket. For example, if your acceptor type is:
-  ``
-  basic_socket_acceptor<ip::tcp, my_executor_type>
-  ``[br]
-  then your accepted socket type will be:
-  ``
-  basic_stream_socket<ip::tcp, my_executor_type>
-  ``[br]
-
-* Changed to require that `Protocol` copy and move operations never throw.
-
-* Changed to require that `Endpoint` default constructor and move operations
-  never throw.
-
-* Added the `noexcept` qualifier to protocol accessors.
-
-* Added the `noexcept` qualifier to socket move constructors.
-
-* Fixed issues associated with opening serial ports on Windows:
-  * Use the correct constant to initialise the RTS control flag.
-  * Specify a default baud rate (9600).
-
-* Fixed a lost "outstanding work count" that can occur when an asynchronous
-  accept operation is automatically restarted.
-
-[heading Asio 1.14.1]
-
-* Improved performance slightly by eliminating a redundant move construction
-  when completed handlers are dispatched.
-
-* Eliminated a compiler warning by annotating a `case` fall-through in
-  the free function `connect()` implementation.
-
-* Fixed the `is_*_buffer_sequence` detection traits for user-defined sequence
-  types.
-
-* Fixed some Windows-specific warnings about an incompatible pointer cast when
-  obtaining the `CancelIoEx` entry point.
-
-* Changed to automatically set the defaults when opening a serial port on
-  Windows.
-
-* Changed the serial port `get_option()` member function to be const.
-
-* Fixed a name hiding issue with the WinRT stream-oriented socket backend's
-  `shutdown` function.
-
-* Applied a minor fix to the documentation for `is_dynamic_buffer`.
-
-* Added some support for Haiku OS.
-
-* Added wolfSSL compatability.
-
-* Changed to require C++17 or later for coroutines TS support with clang.
-
-* Fixed a doxygen generation problem in the tutorial.
-
-[heading Asio 1.14.0]
-
-* Improved I/O object performance by adding runtime detection of native I/O
-  executors when using the polymorphic executor wrapper.
-
-* Changed I/O object move constructors so that the executor is copied, not
-  moved. This ensures that the moved-from I/O object is left in the same state
-  as if constructed with a valid executor but without a resource.
-
-* On Windows, fixed an issue where global object destructors were not being
-  run.
-
-* Fixed move-based `async_accept` between sockets with different executor
-  types.
-
-[heading Asio 1.13.0]
-
-* Added custom I/O executor support to I/O objects.
-
-  * All I/O objects now have an additional `Executor` template parameter. This
-    template parameter defaults to the `asio::executor` type (the polymorphic
-    executor wrapper) but can be used to specify a user-defined executor
-    type.
-
-  * I/O objects' constructors and functions that previously took an
-    `asio::io_context&` now accept either an `Executor` or a reference to a
-    concrete `ExecutionContext` (such as `asio::io_context` or
-    `asio::thread_pool`).
-
-  * Note: One potential source of breakage in existing user code is when reusing an
-    I/O object's `io_context` for constructing another I/O object, as in:
-    ``
-    asio::steady_timer my_timer(my_socket.get_executor().context());
-    ``[br]
-    To fix this, either construct the second I/O object using the first I/O
-    object's executor:[br]
-    ``
-    asio::steady_timer my_timer(my_socket.get_executor());
-    ``[br]
-    or otherwise explicitly pass the `io_context`:[br]
-    ``
-    asio::steady_timer my_timer(my_io_context);
-    ``[br]
-
-  * The previously deprecated `get_io_context` and `get_io_service`
-    member functions have now been removed.
-
-  * The previously deprecated service template parameters, and the
-    corresponding classes, have now been removed.
-
-* Added a new `async_result` form with an `initiate` static member function.
-
-  * The `async_result` template now supports a new form:
-    ``
-    template <typename CompletionToken, typename Signature>
-    struct async_result
-    {
-      typedef /* ... */ return_type;
-
-      template <typename Initiation,
-          typename RawCompletionToken,
-          typename... Args>
-      static return_type initiate(
-          Initiation&& initiation,
-          RawCompletionToken&& token,
-          Args&&... args);
-    };
-    ``[br]
-
-  * The `initiate` member function must: (a) transform the token into a
-    completion handler object `handler`; (b) cause the invocation of the
-    function object `initiation` as if by calling
-    `std::forward<Initiation>(initiation)(std::move(handler),
-    std::forward<Args>(args)...)`. Note that the invocation of `initiation`
-    may be deferred (e.g. lazily evaluated), in which case `initiation` and
-    `args` must be decay-copied and moved as required.
-
-  * A helper function template `async_initiate` has also been added as a
-    wrapper for the invocation of `async_result<>::initiate`. For backward
-    compatibility, this function supports both the old and new `async_result`
-    forms.
-
-  * The composed operations examples have been updated to use `async_initiate`.
-
-  * The previously deprecated `handler_type` trait and single-argument form of
-    `async_result` have now been removed.
-
-* Updated the Coroutines TS support and promoted it to the `asio` namespace.
-
-  * The `awaitable<>`, `co_spawn`, `this_coro`, `detached`, and
-    `redirect_error` facilities have been moved from the `asio::experimental`
-    namespace to namespace `asio`. As part of this change, the
-    `this_coro::token()` awaitable has been superseded by the
-    `asio::use_awaitable` completion token.
-
-  * Please note that the `use_awaitable` and `redirect_error` completion tokens
-    work only with asynchronous operations that use the new form of
-    `async_result` with member function `initiate`. Furthermore, when using
-    `use_awaitable`, please be aware that the asynchronous operation is not
-    initiated until `co_await` is applied to the `awaitable<>`.
-
-* Added a new `DynamicBuffer_v2` concept which is CopyConstructible.
-
-  * This change adds a new set of type requirements for dynamic buffers,
-    `DynamicBuffer_v2`, which supports copy construction. These new type
-    requirements enable dynamic buffers to be used as arguments to
-    user-defined composed operations, where the same dynamic buffer object
-    is used repeatedly for multiple underlying operations. For example:[br]
-    ``
-      template <typename DynamicBuffer>
-      void echo_line(tcp::socket& sock, DynamicBuffer buf)
-      {
-        n = asio::read_until(sock, buf, '\n');
-        asio::write(sock, buf, asio::transfer_exactly(n));
-      }
-    ``[br]
-
-  * The original `DynamicBuffer` type requirements have been renamed to
-    `DynamicBuffer_v1`. These requirements continue to be compatible with the
-    Networking TS.
-
-  * New type traits `is_dynamic_buffer_v1` and `is_dynamic_buffer_v2` have been
-    added to test for conformance to `DynamicBuffer_v1` and `DynamicBuffer_v2`
-    respectively. The existing `is_dynamic_buffer` trait has been retained and
-    delegates to `is_dynamic_buffer_v1` (unless `ASIO_NO_DYNAMIC_BUFFER_V1` is
-    explicitly defined, in which case it delegates to `is_dynamic_buffer_v2`).
-
-  * For convenience, the `dynamic_string_buffer` and `dynamic_vector_buffer`
-    classes conform to both `DynamicBuffer_v1` and `DynamicBuffer_v2`
-    requirements.
-
-  * When `ASIO_NO_DYNAMIC_BUFFER_V1` is defined, all support for
-    `DynamicBuffer_v1` types and functions is #ifdef-ed out. Support for using
-    `basic_streambuf` with the `read`, `async_read`, `read_until`,
-    `async_read_until`, `write`, and `async_write` functions is also disabled
-    as a consequence.
-
-  * Note: This change should have no impact on existing source code that simply
-    uses dynamic buffers in conjunction with Asio's composed operations.
-
-* Added a new `async_compose` function that simplifies the implementation of
-  user-defined asynchronous operations.
-
-* Added a `make_strand` function, which creates a `strand` with a deduced
-  `Executor` template argument.
-
-* Relaxed the completion condition type requirements to only require
-  move-constructibility rather than copy-constructibility.
-
-* Added a constructor for `local::basic_endpoint` that takes a `string_view`.
-
-* Added the noexcept qualifier to various member functions of the
-  `ip::address`, `ip::address_v4`, `ip::address_v6`, `ip::basic_endpoint`, and
-  `executor_work_guard` classes.
-
-* Added the noexcept qualifier to the `buffer_sequence_begin` and
-  `buffer_sequence_end` functions.
-
-* Added a new `ASIO_DISABLE_VISIBILITY` configuration `#define` that allows
-  visibility pragmas to be disabled. (Note: If symbols are hidden, extra care
-  must be taken to ensure that Asio types are not passed across shared
-  library API boundaries.)
-
-* Changed compile-time feature detection to define `ASIO_STANDALONE`
-  automatically if C++11 or later is detected.
-
-  * Users should define `ASIO_ENABLE_BOOST` to explicitly disable standalone
-    mode when compiling with C++11 or later.
-
-  * The `configure` script now defaults to a standalone build unless Boost is
-    specified or detected.
-
-* Enabled recycling of the memory used to type-erase a function object with the
-  polymorphic executor.
-
-* Changed receive operations to return the correct number of bytes transferred
-  when truncation (`error::message_size`) occurs on a datagram-oriented socket.
-
-* Fixed multicast behaviour on QNX by automatically applying `SO_REUSEPORT`
-  when the `reuse_address` option is set.
-
-* Added inclusion of `unistd.h` when targeting Haiku OS, to fix feature detection.
-
-* Added the `network_v[46].hpp` headers to the top-level convenience header.
-
-* Fixed calculation of absolute timeout when the backend uses
-  `pthread_cond_timedwait`.
-
-* Changed the range-based asynchronous connect operation to deduce the
-  `EndpointSequence` iterator type rather than assume the presence of a
-  `const_iterator` typedef.
-
-* Fixed `buffer_sequence_begin` and `buffer_sequence_end` to prevent implicit
-  conversion. This change addresses an issue where a call to
-  `buffer_sequence_begin` or `buffer_sequence_end` could trigger an implicit
-  conversion to `const_buffer` or `mutable_buffer`. Whenever this implicit
-  conversion occurred, the return value of `buffer_sequence_begin` or
-  `buffer_sequence_end` would point to a temporary object.
-
-* Ensured SSL handshake errors are propagated to the peer before the local
-  operation completes.
-
-* Suppressed the `eof` error on SSL shutdown as it actually indicates success.
-
-* Added a fallback error code for when we OpenSSL produces an
-  `SSL_ERROR_SYSCALL` result without an associated error.
-
-* Changed composed asynchronous read and write operations to move, rather than
-  copy, the buffer sequence objects when the composed operation implementation
-  is moved.
-
-* Changed to use `<atomic>` when targeting apple/clang/libc++ with recent Xcode
-  versions, even for C++03. This fixes a warning about the deprecation of
-  `OSMemoryBarrier`.
-
-* Fixed compile errors that occur when using the composed read and write
-  operations with MSVC 11.0, by disabling `decltype` support for that compiler.
-
-* Increased the default value of `_WIN32_WINNT` to `0x0601` (Windows 7).
-
-* Fixed `dispatch` documentation to note that it may call the supplied function
-  object in the current thread.
-
-* Updated `post` and `defer` documentation to clarify the the distinction
-  between them.
-
-[heading Asio 1.12.2]
-
-* Fixed a problem with the detection of `std::future` availability with
-  libstdc++.
-
-* Fixed compile error in regex overload of `read_until`.
-
-* Fixed a timer heap corruption issue that can occur when moving a cancelled
-  timer.
-
-* Fixed detection of `std::experimental::string_view` and `std::string_view`
-  with newer clang/libc++.
-
-* Fixed MSVC version detection for availability of `std::invoke_result`.
-
-* Fixed the buffer sequence traits to test the new requirements, if `decltype`
-  is available.
-
-* Fixed an MSVC issue when building with exceptions disabled.
-
-* Added SSL context options for TLS v1.3.
-
-* Added a compile-time test for TLS v1 support.
-
-* Fixed the macro used to test for TLS v1.2 support.
-
-* Prevented global objects from being created once per thread on Windows.
-
-* Fixed a crash when using `size()`, `max_size()` or `empty()` on
-  default-constructed resolver results.
-
-* Changed to move the return value in basic_resolver_results::begin() to avoid
-  copying.
-
-* Enabled move support for the Intel Compiler.
-
-* Fixed `std::string_view` detection issue when using clang-cl.
-
-* Fixed the handler tracking operation name for
-  `io_context::executor_type::dispatch`.
-
-* Fixed a buffer overflow that could occur when parsing an address string with
-  a 64-bit scope id.
-
-* Added examples showing how to write composed operations.
-
-* Added C++11 versions of the Timeouts, Timers, SOCKS4 and SSL examples.
-
-* Fixed minor issues in documentation and examples.
-
-[heading Asio 1.12.1]
-
-* Added missing const qualifier to `basic_socket_acceptor::get_option`.
-
-* Worked around a parsing error that occurs with some versions of gcc.
-
-* Fixed broken code samples in tutorial.
-
-* Added new experimental features. (Note that "experimental" features may be
-  changed without notice in subsequent releases.)
-
-  * Added `experimental::detached` completion token.
-
-  * Added `experimental::redirect_error` completion token.
-
-  * Added `experimental::co_spawn` facility for integration with the coroutines
-    technical specification.
-
-* Updated timeout examples to use latest features.
-
-  * Used `asio::steady_timer` rather than `asio::deadline_timer`.
-
-  * Used `asio::dynamic_buffer` rather than `asio::streambuf`.
-
-  * Used timed `asio::io_context::run_for()` function for blocking clients.
-
-  * Added example showing a custom completion token for blocking with timeouts.
-
-* Fixed unit tests to compile when `(BOOST_)ASIO_NO_DEPRECATED` is defined.
-
-* Changed socket iostreams to use chrono by default, to fix compatibility with
-  the Networking TS. Define `(BOOST_)ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM`
-  to enable the old Boost.Date_Time interface in `basic_socket_streambuf` and
-  `basic_socket_iostream`.
-
-* Updated examples to use chrono rather than Boost.Date_Time.
-
-* Fixed an incorrect member function detector in the `is_dynamic_buffer` trait.
-
-* Fixed an `async_result` incompatibility with deprecated `handler_type`.
-
-* Added a missing move optimisation in the SSL stream implementation.
-
-* Fixed incorrect `basic_resolver_results::value_type` typedef.
-
-* Fixed a compile error with some OpenSSL versions when `SSL_OP_NO_COMPRESSION`
-  is defined.
-
-* Changed `add_certificate_authority` to process multiple certificates in a bundle.
-
-* Eliminated deprecation warning with MSVC by using `std::invoke_result` rather
-  than `std::result_of`.
-
-* Changed to use `std::string_view` for C++17 or later, and
-  `std::experimental::string_view` for C++14. Define the preprocessor macro
-  `(BOOST_)ASIO_DISABLE_STD_STRING_VIEW` to force the use of
-  std::experimental::string_view (assuming it is available) when compiling in
-  C++17 mode.
-
-* Ensured `DynamicBuffer` template arguments are decayed before using in
-  `enable_if` tests.
-
-* Changed documentation to distinguish legacy completion handlers (which are
-  still required to be CopyConstructible) from new MoveConstructible handlers.
-
-* Suppressed a discarded return value warning in the buffer debugging support.
-
-* Fixed `basic_yield_context` to work with completion signatures containing
-  reference parameters.
-
-* Ensured that stackful coroutines launched using `spawn()` correctly store
-  decayed copies of their function and handler arguments.
-
-* Fixed some compatibility issues with Android.
-
-* Fixed some minor portability issues in examples.
-
-[heading Asio 1.12.0]
-
-* Completed the interface changes to reflect the Networking TS
-  ([@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf N4656]).
-
-  * See the [link asio.net_ts list] of new interfaces and, where
-    applicable, the corresponding old interfaces that have been superseded.
-
-  * The service template parameters, and the corresponding classes, are disabled
-    by default. For example, instead of `basic_socket<Protocol, SocketService>` we
-    now have simply `basic_socket<Protocol>`. The old interface can be enabled by
-    defining the `(BOOST_)ASIO_ENABLE_OLD_SERVICES` macro.
-
-* Added support for customised handler tracking.
-
-* Added reactor-related (i.e. descriptor readiness) events to handler tracking.
-
-* Added special [link asio.overview.core.concurrency_hint concurrency
-  hint] values that may be used to disable locking on a per `io_context` basis.
-
-* Enabled perfect forwarding for the first `ssl::stream<>` constructor argument.
-
-* Added ability to release ownership of the underlying native socket. (Requires
-  Windows 8.1 or later when using the I/O completion port backend.)
-
-[heading Asio 1.11.0]
-
-* Implemented changes to substantially reflect the Networking Library Proposal
-  ([@www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4370.html N4370]).
-
-  * New `Executor` type requirements and classes to support an executor
-    framework, including the `execution_context` base class, the
-    `executor_work` class for tracking outstanding work, and the `executor`
-    polymorphic wrapper. Free functions `dispatch()`, `post()` and `defer()`
-    have been added and are used to submit function objects to executors.
-
-  * Completion handlers now have an associated executor and associated
-    allocator. The free function `wrap()` is used to associate an executor with
-    a handler or other object. The handler hooks for allocation, invocation and
-    continuation have been deprecated.
-
-  * A `system_executor` class has been added as a default executor.
-
-  * The `io_service` class is now derived from `execution_context` and
-    implements the executor type requirements in its nested `executor_type`
-    class. The member functions `dispatch()`, `post()`, `defer()` and `wrap()`
-    have been deprecated. The `io_service::work` class has been deprecated.
-
-  * The `io_service` member function `reset()` has been renamed to `restart()`.
-    The old name is retained for backward compatibility but has been
-    deprecated.
-
-  * The `make_service<>()` function is now used to add a new service to an
-    execution context such as an `io_service`. The `add_service()` function has
-    been deprecated.
-
-  * A new `strand<>` template has been added to allow strand functionality to
-    be used with generic executor types.
-
-  * I/O objects (such as sockets and timers) now provide access to their
-    associated `io_service` via a `context()` member function. The
-    `get_io_service()` member function is deprecated.
-
-  * All asynchronous operations and executor operations now support move-only
-    handlers. However, the deprecated `io_service::post()`,
-    `io_service::dispatch()`, `io_service::strand::post()` and
-    `io_service::strand::dispatch()` functions still require copyable handlers.
-
-  * Waitable timer objects are now movable.
-
-  * Waitable timers, socket iostreams and socket streambufs now provide an
-    `expiry()` member function for obtaining the expiry time. The accessors
-    `expires_at()` and `expires_after()` have been deprecated, though those
-    names are retained for the mutating members.
-
-  * The `std::packaged_task` class template is now supported as a completion
-    handler. The initiating operation automatically returns the future
-    associated with the task. The `package()` function has been added as a
-    convenient factory for packaged tasks.
-
-  * Sockets, socket acceptors and descriptors now provide `wait()` and
-    `async_wait()` operations that may be used to wait for readiness. The
-    `null_buffers` type has been deprecated.
-
-  * The proposed error code enum classes are simulated using namespaces.
-    Existing asio error codes now have a correspondence with the standard error
-    conditions.
-
-  * Conversion between IP address types, and conversion from string to address,
-    is now supported via the `address_cast<>()`, `make_address()`,
-    `make_address_v4()` and `make_address_v6()` free functions. The
-    `from_string()`, `to_v4()`, `to_v6()` and `v4_mapped()` member functions
-    have been deprecated.
-
-  * A default-constructed `ip::address` now represents an invalid address value
-    that is neither IPv4 nor IPv6.
-
-  * New `buffer()` overloads that generate mutable buffers for non-const
-    `string` objects.
-
-  * Support for dynamic buffer sequences that automatically grow and shrink to
-    accomodate data as it is read or written. This is a generic facility
-    similar to the existing `asio::streambuf` class. This support includes:
-
-    * New `dynamic_string_buffer` and `dynamic_vector_buffer` adapter classes
-      that meet the `DynamicBufferSequence` type requirements.
-
-    * New `dynamic_buffer()` factory functions for creating a dynamic buffer
-      adapter for a `vector` or `string`.
-
-    * New overloads for the `read()`, `async_read()`, `write()` and
-      `async_write()`, `read_until()` and `async_read_until()` free functions
-      that directly support dynamic buffer sequences.
-
-  * Support for networks and address ranges. Thanks go to Oliver Kowalke for
-    contributing to the design and providing the implementation on which this
-    facility is based. The following new classes have been added:
-
-    * `address_iterator_v4` for iterating across IPv4 addresses
-    * `address_iterator_v6` for iterating across IPv6 addresses
-    * `address_range_v4` to represent a range of IPv4 addresses
-    * `address_range_v6` to represent a range of IPv6 addresses
-    * `network_v4` for manipulating IPv4 CIDR addresses, e.g. 1.2.3.0/24
-    * `network_v6` for manipulating IPv6 CIDR addresses, e.g. ffe0:/120
-
-  * New convenience headers in [^<asio/ts/*.hpp>] that correspond to the headers
-    in the proposal.
-
-* Added a new, executor-aware `thread_pool` class.
-
-* Changed `spawn()` to be executor-aware.
-
-* Added a new `spawn()` overload that takes only a function object.
-
-* Changed `spawn()` and `yield_context` to permit nested calls to the
-  completion handler.
-
-* Removed previously deprecated functions.
-
-* Added options for disabling TLS v1.1 and v1.2.
-
-* Changed the SSL wrapper to call the password callback when loading an
-  in-memory key.
-
-* Changed the tutorial to use `std::endl` to ensure output is flushed.
-
-* Fixed false SSL error reports by ensuring that the SSL error queue is cleared
-  prior to each operation.
-
-* Fixed an `ssl::stream<>` bug that may result in spurious 'short read' errors.
-
-* Enabled perfect forwarding for the first `ssl::stream<>` constructor argument.
-
-* Added standalone Asio support for Clang when used with libstdc++ and C++11.
-
-* Fixed an unsigned integer overflow reported by Clang's integer sanitizer.
-
-* Added support for move-only return types when using a `yield_context` object
-  with asynchronous operations.
-
-* Ensured errors generated by Windows' `ConnectEx` function are mapped to their
-  portable equivalents.
-
-* Changed multicast test to treat certain `join_group` failures as non-fatal.
-
-[heading Asio 1.10.5]
-
-* Fixed the [^kqueue] reactor so that it works on FreeBSD.
-
-* Fixed an issue in the [^kqueue] reactor which resulted in spinning when using
-  serial ports on Mac OS.
-
-* Fixed [^kqueue] reactor support for read-only file descriptors.
-
-* Fixed a compile error when using the [^/dev/poll] reactor.
-
-* Changed the Windows backend to use `WSASocketW`, as `WSASocketA` has been
-  deprecated.
-
-* Fixed some warnings reported by Visual C++ 2013.
-
-* Fixed integer type used in the WinRT version of the byte-order conversion
-  functions.
-
-* Changed documentation to indicate that `use_future` and `spawn()` are not
-  made available when including the `asio.hpp` convenience header.
-
-* Explicitly marked `asio::strand` as deprecated. Use
-  `asio::io_service::strand` instead.
-
-[heading Asio 1.10.4]
-
-* Stopped using certain Winsock functions that are marked as deprecated in the
-  latest Visual C++ and Windows SDK.
-
-* Fixed a shadow variable warning on Windows.
-
-* Fixed a regression in the [^kqueue] backend that was introduced in Asio
-  1.10.2.
-
-* Added a workaround for building the unit tests with [^gcc] on AIX.
-
-[heading Asio 1.10.3]
-
-* Worked around a [^gcc] problem to do with anonymous enums.
-
-* Reverted the Windows `HANDLE` backend change to ignore `ERROR_MORE_DATA`.
-  Instead, the error will be propagated as with any other (i.e. in an
-  `error_code` or thrown as a `system_error`), and the number of bytes
-  transferred will be returned. For code that needs to handle partial messages,
-  the `error_code` overload should be used.
-
-* Fixed an off-by-one error in the `signal_set` implementation's signal
-  number check.
-
-* Changed the Windows IOCP backend to not assume that
-  `SO_UPDATE_CONNECT_CONTEXT` is defined.
-
-* Fixed a Windows-specific issue, introduced in Asio 1.10.2, by using
-  `VerifyVersionInfo` rather than `GetVersionEx`, as `GetVersionEx` has been
-  deprecated.
-
-* Changed to use SSE2 intrinsics rather than inline assembly, to allow the
-  Cray compiler to work.
-
-[heading Asio 1.10.2]
-
-* Fixed `asio::spawn()` to work correctly with new Boost.Coroutine interface.
-
-* Ensured that incomplete `asio::spawn()` coroutines are correctly unwound when
-  cleaned up by the `io_service` destructor.
-
-* Fixed delegation of continuation hook for handlers produced by
-  `io_service::wrap()` and `strand::wrap()`.
-
-* Changed the Windows I/O completion port backend to use `ConnectEx`, if
-  available, for connection-oriented IP sockets.
-
-* Changed the `io_service` backend for non-Windows (and non-IOCP Windows)
-  platforms to use a single condition variable per `io_service` instance.
-  This addresses a potential race condition when `run_one()` is used from
-  multiple threads.
-
-* Prevented integer overflow when computing timeouts based on some
-  `boost::chrono` and `std::chrono` clocks.
-
-* Made further changes to `EV_CLEAR` handling in the kqueue backend, to address
-  other cases where the `close()` system call may hang on Mac OS X.
-
-* Fixed infinite recursion in implementation of
-  `resolver_query_base::flags::operator~`.
-
-* Made the `select` reactor more efficient on Windows for large numbers of
-  sockets.
-
-* Fixed a Windows-specific type-aliasing issue reported by [^gcc].
-
-* Prevented execution of compile-time-only buffer test to avoid triggering an
-  address sanitiser warning.
-
-* Disabled the `GetQueuedCompletionStatus` timeout workaround on recent
-  versions of Windows.
-
-* Changed implementation for Windows Runtime to use `FormatMessageW` rather
-  than `FormatMessageA`, as the Windows store does not permit the latter.
-
-* Added support for string-based scope IDs when using link-local multicast
-  addresses.
-
-* Changed IPv6 multicast group join to use the address's scope ID as the
-  interface, if an interface is not explicitly specified.
-
-* Fixed multicast test failure on Mac OS X and the BSDs by using a link-local
-  multicast address.
-
-* Various minor documentation improvements.
-
-[heading Asio 1.10.1]
-
-* Implemented a limited port to Windows Runtime. This support requires that the
-  language extensions be enabled. Due to the restricted facilities exposed by
-  the Windows Runtime API, the port also comes with the following caveats:
-
-  * The core facilities such as the `io_service`, `strand`, buffers, composed
-    operations, timers, etc., should all work as normal.
-
-  * For sockets, only client-side TCP is supported.
-
-  * Explicit binding of a client-side TCP socket is not supported.
-
-  * The `cancel()` function is not supported for sockets. Asynchronous
-    operations may only be cancelled by closing the socket.
-
-  * Operations that use `null_buffers` are not supported.
-
-  * Only `tcp::no_delay` and `socket_base::keep_alive` options are supported.
-
-  * Resolvers do not support service names, only numbers. I.e. you must
-    use "80" rather than "http".
-
-  * Most resolver query flags have no effect.
-
-* Extended the ability to use Asio without Boost to include Microsoft Visual
-  Studio 2012. When using a C++11 compiler, most of Asio may now be used
-  without a dependency on Boost header files or libraries. To use Asio in this
-  way, define `ASIO_STANDALONE` on your compiler command line or as part of the
-  project options. This standalone configuration has been tested for the
-  following platforms and compilers:
-
-  * Microsoft Visual Studio 2012
-
-  * Linux with g++ 4.7 or 4.8 (requires [^-std=c++11])
-
-  * Mac OS X with clang++ / Xcode 4.6 (requires [^-std=c++11 -stdlib=libc++])
-
-* Fixed a regression (introduced in 1.10.0) where, on some platforms, errors
-  from `async_connect` were not correctly propagated through to the completion
-  handler.
-
-* Fixed a Windows-specific regression (introduced in 1.10.0) that occurs when
-  multiple threads are running an `io_service`. When the bug occurs, the result
-  of an asynchronous operation (error and bytes tranferred) is incorrectly
-  discarded and zero values used instead. For TCP sockets this results in
-  spurious end-of-file notifications.
-
-* Fixed a bug in handler tracking, where it was not correctly printing out some
-  handler IDs.
-
-* Fixed the comparison used to test for successful synchronous accept
-  operations so that it works correctly with unsigned socket descriptors.
-
-* Ensured the signal number is correctly passed to the completion handler when
-  starting an `async_wait` on a signal that is already raised.
-
-* Suppressed a g++ 4.8+ warning about unused typedefs.
-
-* Enabled the move optimisation for handlers that use the default invocation
-  hook.
-
-* Clarified that programs must not issue overlapping `async_write_at`
-  operations.
-
-* Changed the Windows `HANDLE` backend to treat `ERROR_MORE_DATA` as a
-  non-fatal error when returned by `GetOverlappedResult` for a synchronous
-  read.
-
-* Visual C++ language extensions use `generic` as a keyword. Added a
-  workaround that renames the namespace to `cpp_generic` when those language
-  extensions are in effect.
-
-* Fixed some asynchronous operations that missed out on getting `async_result`
-  support in 1.10.0. In particular, the buffered stream templates have been
-  updated so that they adhere to current handler patterns.
-
-* Enabled move support for Microsoft Visual Studio 2012.
-
-* Added `use_future` support for Microsoft Visual Studio 2012.
-
-* Removed a use of `std::min` in the Windows IOCP backend to avoid a
-  dependency on the `<algorithm>` header.
-
-* Eliminated some unnecessary handler copies.
-
-* Fixed support for older versions of OpenSSL that do not provide the
-  `SSL_CTX_clear_options` function.
-
-* Fixed various minor and cosmetic issues in code and documentation.
-
-[heading Asio 1.10.0]
-
-* Added new traits classes, `handler_type` and `async_result`, that allow the
-  customisation of the return type of an initiating function.
-
-* Added the `asio::spawn()` function, a high-level wrapper for running
-  stackful coroutines, based on the Boost.Coroutine library. The `spawn()`
-  function enables programs to implement asynchronous logic in a synchronous
-  manner. For example: `size_t n = my_socket.async_read_some(my_buffer, yield);`.
-  For further information, see [link asio.overview.composition.spawn Stackful
-  Coroutines].
-
-* Added the `asio::use_future` special value, which provides first-class
-  support for returning a C++11 `std::future` from an asynchronous
-  operation's initiating function. For example:
-  `future<size_t> = my_socket.async_read_some(my_buffer, asio::use_future);`.
-  For further information, see [link asio.overview.composition.futures Futures].
-
-* Promoted the stackless coroutine class and macros to be part of Asio's
-  documented interface, rather than part of the HTTP server 4 example.
-  For further information, see [link asio.overview.composition.coroutine
-  Stackless Coroutines].
-
-* Added a new handler hook called `asio_handler_is_continuation`.
-  Asynchronous operations may represent a continuation of the asynchronous
-  control flow associated with the current executing handler. The
-  `asio_handler_is_continuation` hook can be customised to return `true` if
-  this is the case, and Asio's implementation can use this knowledge to
-  optimise scheduling of the new handler. To cover common cases, Asio
-  customises the hook for strands, `spawn()` and composed asynchronous
-  operations.
-
-* Added four new generic protocol classes, `generic::datagram_protocol`,
-  `generic::raw_protocol`, `generic::seq_packet_protocol` and
-  `generic::stream_protocol`, which implement the `Protocol` type
-  requirements, but allow the user to specify the address family (e.g.
-  `AF_INET`) and protocol type (e.g. `IPPROTO_TCP`) at runtime.
-  For further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-
-* Added C++11 move constructors that allow the conversion of a socket (or
-  acceptor) into a more generic type. For example, an `ip::tcp::socket` can
-  be converted into a `generic::stream_protocol::socket` via move
-  construction.
-  For further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-
-* Extended the `basic_socket_acceptor<>`'s `accept()` and `async_accept()`
-  functions to allow a new connection to be accepted directly into a socket
-  of a more generic type. For example, an `ip::tcp::acceptor` can be used to
-  accept into a `generic::stream_protocol::socket` object.
-  For further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-
-* Moved existing examples into a C++03-specific directory, and added a new
-  directory for C++11-specific examples. A limited subset of the C++03
-  examples have been converted to their C++11 equivalents.
-
-* Add the ability to use Asio without Boost, for a limited set of platforms.
-  When using a C++11 compiler, most of Asio may now be used without a
-  dependency on Boost header files or libraries. To use Asio in this way,
-  define `ASIO_STANDALONE` on your compiler command line or as part of the
-  project options. This standalone configuration has currently been tested for
-  the following platforms and compilers:
-
-  * Linux with g++ 4.7 (requires [^-std=c++11])
-
-  * Mac OS X with clang++ / Xcode 4.6 (requires [^-std=c++11 -stdlib=libc++])
-
-* Various SSL enhancements. Thanks go to Nick Jones, on whose work these changes
-  are based.
-
-  * Added support for SSL handshakes with re-use of data already read from
-    the wire. New overloads of the `ssl::stream<>` class's `handshake()` and
-    `async_handshake()` functions have been added. These accept a
-    `ConstBufferSequence` to be used as initial input to the ssl engine for
-    the handshake procedure.
-
-  * Added support for creation of TLSv1.1 and TLSv1.2 `ssl::context` objects.
-
-  * Added a `set_verify_depth()` function to the `ssl::context` and
-    `ssl::stream<>` classes.
-
-  * Added the ability to load SSL certificate and key data from memory
-    buffers. New functions, `add_certificate_authority()`,
-    `use_certificate()`, `use_certificate_chain()`, `use_private_key()`,
-    `use_rsa_private_key()` and `use_tmp_dh()`, have been added to the
-    `ssl::context` class.
-
-  * Changed `ssl::context` to automatically disable SSL compression by
-    default. To enable, use the new `ssl::context::clear_options()` function,
-    as in `my_context.clear_options(ssl::context::no_compression)`.
-
-* Fixed a potential deadlock in `signal_set` implementation.
-
-* Fixed an error in acceptor example in documentation.
-
-* Fixed copy-paste errors in waitable timer documentation.
-
-* Added assertions to satisfy some code analysis tools.
-
-* Fixed a malformed `#warning` directive.
-
-* Fixed a potential data race in the Linux `epoll` implementation.
-
-* Fixed a Windows-specific bug, where certain operations might generate an
-  `error_code` with an invalid (i.e. `NULL`) `error_category`.
-
-* Fixed `basic_waitable_timer`'s underlying implementation so that it can
-  handle any `time_point` value without overflowing the intermediate duration
-  objects.
-
-* Fixed a problem with lost thread wakeups that can occur when making
-  concurrent calls to `run()` and `poll()` on the same `io_service` object.
-
-* Fixed implementation of asynchronous connect operation so that it can cope
-  with spurious readiness notifications from the reactor.
-
-* Fixed a memory leak in the `ssl::rfc2818_verification` class.
-
-* Added a mechanism for disabling automatic Winsock initialisation. See the
-  header file [^asio/detail/winsock_init.hpp] for details.
-
-[heading Asio 1.8.3]
-
-* Fixed some 64-to-32-bit conversion warnings.
-
-* Fixed various small errors in documentation and comments.
-
-* Fixed an error in the example embedded in `basic_socket::get_option`'s
-  documentation.
-
-* Changed to use `long` rather than `int` for SSL_CTX options, to match OpenSSL.
-
-* Changed to use `_snwprintf` to address a compile error due to the changed
-  `swprintf` signature in recent versions of MinGW.
-
-* Fixed a deadlock that can occur on Windows when shutting down a pool of
-  `io_service` threads due to running out of work.
-
-* Changed UNIX domain socket example to treat errors from `accept` as non-fatal.
-
-* Added a small block recycling optimisation to improve default memory
-  allocation behaviour.
-
-[heading Asio 1.8.2]
-
-* Fixed an incompatibility between `ip::tcp::iostream` and C++11.
-
-* Decorated GCC attribute names with underscores to prevent interaction
-  with user-defined macros.
-
-* Added missing `#include <cctype>`, needed for some versions of MinGW.
-
-* Changed to use [^gcc]'s atomic builtins on ARM CPUs, when available.
-
-* Changed strand destruction to be a no-op, to allow strand objects to be
-  destroyed after their associated `io_service` has been destroyed.
-
-* Added support for some newer versions of glibc which provide the
-  `epoll_create1()` function but always fail with ENOSYS.
-
-* Changed the SSL implementation to throw an exception if SSL engine
-  initialisation fails.
-
-* Fixed another regression in `buffered_write_stream`.
-
-* Implemented various minor performance improvements, primarily targeted at
-  Linux x86 and x86-64 platforms.
-
-[heading Asio 1.8.1]
-
-* Changed the `epoll_reactor` backend to do lazy registration for `EPOLLOUT`
-  events.
-
-* Fixed the `epoll_reactor` handling of out-of-band data, which was broken by
-  an incomplete fix in the last release.
-
-* Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL_NO_ENGINE` feature
-  test `#define`.
-
-* Fixed `windows::object_handle` so that it works with Windows compilers that
-  support C++11 move semantics (such as [^g++]).
-
-* Improved the performance of strand rescheduling.
-
-* Added support for [^g++] 4.7 when compiling in C++11 mode.
-
-* Fixed a problem where `signal_set` handlers were not being delivered when
-  the `io_service` was constructed with a `concurrency_hint` of 1.
-
-[heading Asio 1.8.0]
-
-* Added a new class template `basic_waitable_timer` based around the C++11 clock
-  type requirements. It may be used with the clocks from the C++11 `<chrono>`
-  library facility or, if those are not available, Boost.Chrono. The typedefs
-  `high_resolution_timer`, `steady_timer` and `system_timer` may be used to
-  create timer objects for the standard clock types.
-
-* Added a new `windows::object_handle` class for performing waits on Windows
-  kernel objects. Thanks go to Boris Schaeling for contributing substantially
-  to the development of this feature.
-
-* On Linux, `connect()` can return EAGAIN in certain circumstances. Remapped
-  this to another error so that it doesn't look like a non-blocking operation.
-
-* Fixed a compile error on NetBSD.
-
-* Fixed deadlock on Mac OS X.
-
-* Fixed a regression in `buffered_write_stream`.
-
-* Fixed a non-paged pool "leak" on Windows when an `io_service` is repeatedly
-  run without anything to do.
-
-* Reverted earlier change to allow some speculative operations to be performed
-  without holding the lock, as it introduced a race condition in some
-  multithreaded scenarios.
-
-* Fixed a bug where the second buffer in an array of two buffers may be ignored
-  if the first buffer is empty.
-
-[heading Asio 1.6.1]
-
-* Implemented various performance improvements, including:
-
-  * Using thread-local operation queues in single-threaded use cases (i.e. when
-    `concurrency_hint` is 1) to eliminate a lock/unlock pair.
-
-  * Allowing some `epoll_reactor` speculative operations to be performed
-    without holding the lock.
-
-  * Improving locality of reference by performing an `epoll_reactor`'s I/O
-    operation immediately before the corresponding handler is called. This also
-    improves scalability across CPUs when multiple threads are running the
-    `io_service`.
-
-  * Specialising asynchronous read and write operations for buffer sequences
-    that are arrays (`boost::array` or `std::array`) of exactly two buffers.
-
-* Fixed a compile error in the regex overload of `async_read_until`.
-
-* Fixed a Windows-specific compile error by explicitly specifying the
-  `signal()` function from the global namespace.
-
-* Changed the `deadline_timer` implementation so that it does not read the
-  clock unless the timer heap is non-empty.
-
-* Changed the SSL stream's buffers' sizes so that they are large enough to hold
-  a complete TLS record.
-
-* Fixed the behaviour of the synchronous `null_buffers` operations so that they
-  obey the user's non-blocking setting.
-
-* Changed to set the size of the select `fd_set` at runtime when using Windows.
-
-* Disabled an MSVC warning due to const qualifier being applied to function type.
-
-* Fixed a crash that occurs when using the Intel C++ compiler.
-
-* Changed the initialisation of the OpenSSL library so that it supports all
-  available algorithms.
-
-* Fixed the SSL error mapping used when the session is gracefully shut down.
-
-* Added some latency test programs.
-
-* Clarified that a read operation ends when the buffer is full.
-
-* Fixed an exception safety issue in `epoll_reactor` initialisation.
-
-* Made the number of strand implementations configurable by defining
-  `(BOOST_)ASIO_STRAND_IMPLEMENTATIONS` to the desired number.
-
-* Added support for a new `(BOOST_)ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION` flag
-  which switches the allocation of strand implementations to use a round-robin
-  approach rather than hashing.
-
-* Fixed potential strand starvation issue that can occur when `strand.post()`
-  is used.
-
-[heading Asio 1.6.0]
-
-* Improved support for C++0x move construction to further reduce copying of
-  handler objects. In certain designs it is possible to eliminate virtually all
-  copies. Move support is now enabled when compiling in [^-std=c++0x] mode on
-  g++ 4.5 or higher.
-
-* Added build support for platforms that don't provide either of `signal()` or
-  `sigaction()`.
-
-* Changed to use C++0x variadic templates when they are available, rather than
-  generating function overloads using the Boost.Preprocessor library.
-
-* Ensured the value of `errno` is preserved across the implementation's signal
-  handler.
-
-* On Windows, ensured the count of outstanding work is decremented for
-  abandoned operations (i.e. operations that are being cleaned up within the
-  `io_service` destructor).
-
-* Fixed behaviour of zero-length reads and writes in the new SSL implementation.
-
-* Added support for building with OpenSSL 1.0 when `OPENSSL_NO_SSL2` is defined.
-
-* Changed most examples to treat a failure by an accept operation as non-fatal.
-
-* Fixed an error in the [^tick_count_timer] example by making the duration type
-  signed. Previously, a wait on an already-passed deadline would not return for
-  a very long time.
-
-[heading Asio 1.5.3]
-
-* Added a new, completely rewritten SSL implementation. The new implementation
-  compiles faster, shows substantially improved performance, and supports
-  custom memory allocation and handler invocation. It includes new API features
-  such as certificate verification callbacks and has improved error reporting.
-  The new implementation is source-compatible with the old for most uses.
-  However, if necessary, the old implementation may still be used by defining
-  `(BOOST_)ASIO_ENABLE_OLD_SSL`.
-
-* Added new `asio::buffer()` overloads for `std::array`, when available. The
-  support is automatically enabled when compiling in [^-std=c++0x] mode on g++
-  4.3 or higher, or when using MSVC 10. The support may be explicitly enabled
-  by defining `(BOOST_)ASIO_HAS_STD_ARRAY`, or disabled by defining
-  `(BOOST_)ASIO_DISABLE_STD_ARRAY`.
-
-* Changed to use the C++0x standard library templates `array`, `shared_ptr`,
-  `weak_ptr` and `atomic` when they are available, rather than the Boost
-  equivalents.
-
-* Support for `std::error_code` and `std::system_error` is no longer enabled by
-  default for g++ 4.5, as that compiler's standard library does not implement
-  `std::system_error::what()` correctly.
-
-[heading Asio 1.5.2]
-
-* Added support for C++0x move construction and assignment to sockets, serial
-  ports, POSIX descriptors and Windows handles.
-
-* Added support for the `fork()` system call. Programs that use `fork()` must
-  call `io_service.notify_fork()` at the appropriate times. Two new examples
-  have been added showing how to use this feature.
-
-* Cleaned up the handling of errors reported by the `close()` system call. In
-  particular, assume that most operating systems won't have `close()` fail with
-  `EWOULDBLOCK`, but if it does then set the blocking mode and restart the call.
-  If any other error occurs, assume the descriptor is closed.
-
-* The kqueue flag `EV_ONESHOT` seems to cause problems on some versions of Mac
-  OS X, with the `io_service` destructor getting stuck inside the `close()`
-  system call. Changed the kqueue backend to use `EV_CLEAR` instead.
-
-* Changed exception reporting to include the function name in exception `what()`
-  messages.
-
-* Fixed an insufficient initialisers warning with MinGW.
-
-* Changed the `shutdown_service()` member functions to be private.
-
-* Added archetypes for testing socket option functions.
-
-* Added a missing lock in `signal_set_service::cancel()`.
-
-* Fixed a copy/paste error in `SignalHandler` example.
-
-* Added the inclusion of the signal header to `signal_set_service.hpp` so that
-  constants like `NSIG` may be used.
-
-* Changed the `signal_set_service` implementation so that it doesn't assume
-  that `SIGRTMAX` is a compile-time constant.
-
-* Changed the Boost.Asio examples so that they don't use Boost.Thread's
-  convenience header. Use the header file that is specifically for the
-  boost::thread class instead.
-
-[heading Asio 1.5.1]
-
-* Added support for signal handling, using a new class called `signal_set`.
-  Programs may add one or more signals to the set, and then perform an
-  `async_wait()` operation. The specified handler will be called when one of
-  the signals occurs. The same signal number may registered with multiple
-  `signal_set` objects, however the signal number must be used only with Asio.
-
-* Added handler tracking, a new debugging aid. When enabled by defining
-  `(BOOST_)ASIO_ENABLE_HANDLER_TRACKING`, Asio writes debugging output to the
-  standard error stream. The output records asynchronous operations and the
-  relationships between their handlers. It may be post-processed using the
-  included [^handlerviz.pl] tool to create a visual representation of the
-  handlers (requires GraphViz).
-
-* Fixed a bug in `asio::streambuf` where the `consume()` function did not
-  always update the internal buffer pointers correctly. The problem may occur
-  when the `asio::streambuf` is filled with data using the standard C++ member
-  functions such as `sputn()`. (Note: the problem does not manifest when the
-  streambuf is populated by the Asio free functions `read()`,
-  `async_read()`, `read_until()` or `async_read_until()`.)
-
-* Fixed a bug on kqueue-based platforms, where reactor read operations that
-  return false from their `perform()` function are not correctly re-registered
-  with kqueue.
-
-* Support for `std::error_code` and `std::system_error` is no longer enabled by
-  default for MSVC10, as that compiler's standard library does not implement
-  `std::system_error::what()` correctly.
-
-* Modified the `buffers_iterator<>` and `ip::basic_resolver_iterator` classes
-  so that the value_type typedefs are non-const byte types.
-
-[heading Asio 1.5.0]
-
-* Added support for timeouts on socket iostreams, such as `ip::tcp::iostream`.
-  A timeout is set by calling `expires_at()` or `expires_from_now()` to
-  establish a deadline. Any socket operations which occur past the deadline
-  will put the iostream into a bad state.
-
-* Added a new `error()` member function to socket iostreams, for retrieving the
-  error code from the most recent system call.
-
-* Added a new `basic_deadline_timer::cancel_one()` function. This function lets
-  you cancel a single waiting handler on a timer. Handlers are cancelled in
-  FIFO order.
-
-* Added a new `transfer_exactly()` completion condition. This can be used to
-  send or receive a specified number of bytes even if the total size of the
-  buffer (or buffer sequence) is larger.
-
-* Added new free functions `connect()` and `async_connect()`. These operations
-  try each endpoint in a list until the socket is successfully connected.
-
-* Extended the `buffer_size()` function so that it works for buffer sequences
-  in addition to individual buffers.
-
-* Added a new `buffer_copy()` function that can be used to copy the raw bytes
-  between individual buffers and buffer sequences.
-
-* Added new non-throwing overloads of `read()`, `read_at()`, `write()` and
-  `write_at()` that do not require a completion condition.
-
-* Added friendlier compiler errors for when a completion handler does not meet
-  the necessary type requirements. When C++0x is available (currently supported
-  for g++ 4.5 or later, and MSVC 10), `static_assert` is also used to generate
-  an informative error message. This checking may be disabled by defining
-  `(BOOST_)ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS`.
-
-* Added support for using `std::error_code` and `std::system_error`, when
-  available. The support is automatically enabled when compiling in
-  [^-std=c++0x] mode on g++ 4.5 or higher, or when using MSVC 10. The support
-  may be explicitly enabled by defining `ASIO_HAS_STD_SYSTEM_ERROR`, or
-  disabled by defining `ASIO_DISABLE_STD_SYSTEM_ERROR`. (Available in non-Boost
-  version of Asio only.)
-
-* Made the `is_loopback()`, `is_unspecified()` and `is_multicast()` functions
-  consistently available across the `ip::address`, `ip::address_v4` and
-  `ip::address_v6` classes.
-
-* Added new `non_blocking()` functions for managing the non-blocking behaviour
-  of a socket or descriptor. The `io_control()` commands named `non_blocking_io`
-  are now deprecated in favour of these new functions.
-
-* Added new `native_non_blocking()` functions for managing the non-blocking
-  mode of the underlying socket or descriptor. These functions are intended to
-  allow the encapsulation of arbitrary non-blocking system calls as
-  asynchronous operations, in a way that is transparent to the user of the
-  socket object. The functions have no effect on the behaviour of the
-  synchronous operations of the socket or descriptor.
-
-* Added the `io_control()` member function for socket acceptors.
-
-* For consistency with the C++0x standard library, deprecated the `native_type`
-  typedefs in favour of `native_handle_type`, and the `native()` member
-  functions in favour of `native_handle()`.
-
-* Added a `release()` member function to posix descriptors. This function
-  releases ownership of the underlying native descriptor to the caller.
-
-* Added support for sequenced packet sockets (`SOCK_SEQPACKET`).
-
-* Added a new `io_service::stopped()` function that can be used to determine
-  whether the `io_service` has stopped (i.e. a `reset()` call is needed prior
-  to any further calls to `run()`, `run_one()`, `poll()` or `poll_one()`).
-
-* Reduced the copying of handler function objects.
-
-* Added support for C++0x move construction to further reduce copying of
-  handler objects. Move support is enabled when compiling in [^-std=c++0x] mode
-  on g++ 4.5 or higher, or when using MSVC10.
-
-* Removed the dependency on OS-provided macros for the well-known IPv4 and IPv6
-  addresses. This should eliminate the annoying "missing braces around
-  initializer" warnings.
-
-* Reduced the size of `ip::basic_endpoint<>` objects (such as
-  `ip::tcp::endpoint` and `ip::udp::endpoint`).
-
-* Changed the reactor backends to assume that any descriptors or sockets added
-  using `assign()` may have been `dup()`-ed, and so require explicit
-  deregistration from the reactor.
-
-* Changed the SSL error category to return error strings from the OpenSSL
-  library.
-
-* Changed the separate compilation support such that, to use Asio's SSL
-  capabilities, you should also include 'asio/ssl/impl/src.hpp` in one source
-  file in your program.
-
-* Removed the deprecated member functions named `io_service()`. The
-  `get_io_service()` member functions should be used instead.
-
-* Removed the deprecated typedefs `resolver_query` and `resolver_iterator` from
-  the `ip::tcp`, `ip::udp` and `ip::icmp` classes.
-
-* Fixed a compile error on some versions of g++ due to anonymous enums.
-
-* Added an explicit cast to the `FIONBIO` constant to int to suppress a compiler
-  warning on some platforms.
-
-* Fixed warnings reported by g++'s [^-Wshadow] compiler option.
-
-[heading Asio 1.4.8]
-
-* Fixed an integer overflow problem that occurs when
-  `ip::address_v4::broadcast()` is used on 64-bit platforms.
-
-* Fixed a problem on older Linux kernels (where epoll is used without `timerfd`
-  support) that prevents timely delivery of `deadline_timer` handlers, after the
-  program has been running for some time.
-
-[heading Asio 1.4.7]
-
-* Fixed a problem on kqueue-based platforms where a `deadline_timer` may
-  never fire if the `io_service` is running in a background thread.
-
-* Fixed a const-correctness issue that prevented valid uses of
-  `has_service<>` from compiling.
-
-* Fixed MinGW cross-compilation.
-
-* Removed dependency on deprecated Boost.System functions (Boost.Asio only).
-
-* Ensured `close()`/`closesocket()` failures are correctly propagated.
-
-* Added a check for errors returned by `InitializeCriticalSectionAndSpinCount`.
-
-* Added support for hardware flow control on QNX.
-
-* Always use `pselect()` on HP-UX, if it is available.
-
-* Ensured handler arguments are passed as lvalues.
-
-* Fixed Windows build when thread support is disabled.
-
-* Fixed a Windows-specific problem where `deadline_timer` objects with expiry
-  times set more than 5 minutes in the future may never expire.
-
-* Fixed the resolver backend on BSD platforms so that an empty service name
-  resolves to port number `0`, as per the documentation.
-
-* Fixed read operations so that they do not accept buffer sequences of type
-  `const_buffers_1`.
-
-* Redefined `Protocol` and `id` to avoid clashing with Objective-C++ keywords.
-
-* Fixed a `vector` reallocation performance issue that can occur when there are
-  many active `deadline_timer` objects.
-
-* Fixed the kqueue backend so that it compiles on NetBSD.
-
-* Fixed the socket `io_control()` implementation on 64-bit Mac OS X and BSD
-  platforms.
-
-* Fixed a Windows-specific problem where failures from `accept()` are
-  incorrectly treated as successes.
-
-* Deprecated the separate compilation header `asio/impl/src.cpp` in
-  favour of `asio/impl/src.hpp`.
-
-[heading Asio 1.4.6]
-
-* Reduced compile times. (Note that some programs may need to add additional
-  `#include`s, e.g. if the program uses boost::array but does not explicitly
-  include `<boost/array.hpp>`.)
-
-* Reduced the size of generated code.
-
-* Refactored `deadline_timer` implementation to improve performance.
-
-* Improved multiprocessor scalability on Windows by using a dedicated hidden
-  thread to wait for timers.
-
-* Improved performance of `asio::streambuf` with `async_read()` and
-  `async_read_until()`. These read operations now use the existing capacity of
-  the `streambuf` when reading, rather than limiting the read to 512 bytes.
-
-* Added optional separate compilation. To enable, include
-  `asio/impl/src.cpp` in one source file in a program, then
-  build the program with `(BOOST_)ASIO_SEPARATE_COMPILATION` defined in the
-  project\/compiler settings. Alternatively, `(BOOST_)ASIO_DYN_LINK` may be
-  defined to build a separately-compiled Asio as part of a shared library.
-
-* Added new macro `(BOOST_)ASIO_DISABLE_FENCED_BLOCK` to permit the disabling of
-  memory fences around completion handlers, even if thread support is enabled.
-
-* Reworked timeout examples to better illustrate typical use cases.
-
-* Ensured that handler arguments are passed as const types.
-
-* Fixed incorrect parameter order in `null_buffers` variant of `async_send_to`.
-
-* Ensured unsigned char is used with `isdigit` in `getaddrinfo` emulation.
-
-* Fixed handling of very small but non-zero timeouts.
-
-* Fixed crash that occurred when an empty buffer sequence was passed to a
-  composed read or write operation.
-
-* Added missing operator+ overload in `buffers_iterator`.
-
-* Implemented cancellation of `null_buffers` operations on Windows.
-
-[heading Asio 1.4.5]
-
-* Improved performance.
-
-* Reduced compile times.
-
-* Reduced the size of generated code.
-
-* Extended the guarantee that background threads don't call user code to
-  all asynchronous operations.
-
-* Changed to use edge-triggered epoll on Linux.
-
-* Changed to use `timerfd` for dispatching timers on Linux, when
-  available.
-
-* Changed to use one-shot notifications with kqueue on Mac OS X and BSD
-  platforms.
-
-* Added a bitmask type `ip::resolver_query_base::flags` as per the TR2
-  proposal. This type prevents implicit conversion from `int` to
-  `flags`, allowing the compiler to catch cases where users incorrectly
-  pass a numeric port number as the service name.
-
-* Added `#define NOMINMAX` for all Windows compilers. Users can define
-  `(BOOST_)ASIO_NO_NOMINMAX` to suppress this definition.
-
-* Fixed a bug where 0-byte asynchronous reads were incorrectly passing
-  an `error::eof` result to the completion handler.
-
-* Changed the `io_control()` member functions to always call `ioctl` on
-  the underlying descriptor when modifying blocking mode.
-
-* Changed the resolver implementation so that it no longer requires the
-  typedefs `InternetProtocol::resolver_query` and
-  `InternetProtocol::resolver_iterator`, as neither typedef is part of
-  the documented `InternetProtocol` requirements. The corresponding
-  typedefs in the `ip::tcp`, `ip::udp` and `ip::icmp` classes have been
-  deprecated.
-
-* Fixed out-of-band handling for reactors not based on `select()`.
-
-* Added new `(BOOST_)ASIO_DISABLE_THREADS` macro that allows Asio's
-  threading support to be independently disabled.
-
-* Minor documentation improvements.
-
-[heading Asio 1.4.4]
-
-* Added a new HTTP Server 4 example illustrating the use of stackless
-  coroutines with Asio.
-
-* Changed handler allocation and invocation to use `boost::addressof` to
-  get the address of handler objects, rather than applying `operator&`
-  directly.
-
-* Restricted MSVC buffer debugging workaround to 2008, as it causes a
-  crash with 2010 beta 2.
-
-* Fixed a problem with the lifetime of handler memory, where Windows
-  needs the `OVERLAPPED` structure to be valid until both the initiating
-  function call has returned and the completion packet has been
-  delivered.
-
-* Don't block signals while performing system calls, but instead restart
-  the calls if they are interrupted.
-
-* Documented the guarantee made by strand objects with respect to order
-  of handler invocation.
-
-* Changed strands to use a pool of implementations, to make copying of
-  strands cheaper.
-
-* Ensured that kqueue support is enabled for BSD platforms.
-
-* Added a `boost_` prefix to the `extern "C"` thread entry point
-  function.
-
-* In `getaddrinfo` emulation, only check the socket type (`SOCK_STREAM`
-  or `SOCK_DGRAM`) if a service name has been specified. This should
-  allow the emulation to work with raw sockets.
-
-* Added a workaround for some broken Windows firewalls that make a
-  socket appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1.
-
-* Applied a fix for reported excessive CPU usage under Solaris.
-
-* Added some support for platforms that use older compilers such as g++
-  2.95.
-
-[heading Asio 1.4.3]
-
-* Added a new ping example to illustrate the use of ICMP sockets.
-
-* Changed the `buffered*_stream<>` templates to treat 0-byte reads and
-  writes as no-ops, to comply with the documented type requirements for
-  `SyncReadStream`, `AsyncReadStream`, `SyncWriteStream` and
-  `AsyncWriteStream`.
-
-* Changed some instances of the `throw` keyword to
-  `boost::throw_exception()` to allow Asio to be used when exception
-  support is disabled. Note that the SSL wrappers still require
-  exception support.
-
-* Made Asio compatible with the OpenSSL 1.0 beta.
-
-* Eliminated a redundant system call in the Solaris /dev/poll backend.
-
-* Fixed a bug in resizing of the bucket array in the internal hash maps.
-
-* Ensured correct propagation of the error code when a synchronous
-  accept fails.
-
-* Ensured correct propagation of the error code when a synchronous read
-  or write on a Windows `HANDLE` fails.
-
-* Fixed failures reported when `_GLIBCXX_DEBUG` is defined.
-
-* Fixed custom memory allocation support for timers.
-
-* Tidied up various warnings reported by g++.
-
-* Various documentation improvements, including more obvious hyperlinks
-  to function overloads, header file information, examples for the
-  handler type requirements, and adding enum values to the index.
-
-[heading Asio 1.4.2]
-
-* Implement automatic resizing of the bucket array in the internal hash
-  maps. This is to improve performance for very large numbers of
-  asynchronous operations and also to reduce memory usage for very small
-  numbers. A new macro `(BOOST_)ASIO_HASH_MAP_BUCKETS` may be used to
-  tweak the sizes used for the bucket arrays. (N.B. this feature
-  introduced a bug which was fixed in Asio 1.4.3 / Boost 1.40.)
-
-* Add performance optimisation for the Windows IOCP backend for when no
-  timers are used.
-
-* Prevent locale settings from affecting formatting of TCP and UDP
-  endpoints.
-
-* Fix a memory leak that occurred when an asynchronous SSL operation's
-  completion handler threw an exception.
-
-* Fix the implementation of `io_control()` so that it adheres to the
-  documented type requirements for IoControlCommand.
-
-* Fix incompatibility between Asio and ncurses.h.
-
-* On Windows, specifically handle the case when an overlapped `ReadFile`
-  call fails with `ERROR_MORE_DATA`. This enables a hack where a
-  `windows::stream_handle` can be used with a message-oriented named
-  pipe.
-
-* Fix system call wrappers to always clear the error on success, as
-  POSIX allows successful system calls to modify errno.
-
-* Don't include termios.h if `(BOOST_)ASIO_DISABLE_SERIAL_PORT` is
-  defined.
-
-* Cleaned up some more MSVC level 4 warnings.
-
-* Various documentation fixes.
-
-[heading Asio 1.4.1]
-
-* Improved compatibility with some Windows firewall software.
-
-* Ensured arguments to `windows::overlapped_ptr::complete()` are correctly
-  passed to the completion handler.
-
-* Fixed a link problem and multicast failure on QNX.
-
-* Fixed a compile error in SSL support on MinGW / g++ 3.4.5.
-
-* Drop back to using a pipe for notification if eventfd is not available
-  at runtime on Linux.
-
-* Various minor bug and documentation fixes.
-
-[heading Asio 1.4.0]
-
-* Enhanced CompletionCondition concept with the signature
-  `size_t CompletionCondition(error_code ec, size_t total)`, where the return
-  value indicates the maximum number of bytes to be transferred on the next
-  read or write operation. (The old CompletionCondition signature is still
-  supported for backwards compatibility).
-
-* New `windows::overlapped_ptr` class to allow arbitrary overlapped I/O
-  functions (such as `TransmitFile`) to be used with Asio.
-
-* On recent versions of Linux, an `eventfd` descriptor is now used (rather than
-  a pipe) to interrupt a blocked select/epoll reactor.
-
-* Added const overloads of `lowest_layer()`.
-
-* Synchronous read, write, accept and connect operations are now thread safe
-  (meaning that it is now permitted to perform concurrent synchronous
-  operations on an individual socket, if supported by the OS).
-
-* Reactor-based `io_service` implementations now use lazy initialisation to
-  reduce the memory usage of an `io_service` object used only as a message
-  queue.
-
-[heading Asio 1.2.0]
-
-* Added support for serial ports.
-
-* Added support for UNIX domain sockets.
-
-* Added support for raw sockets and ICMP.
-
-* Added wrappers for POSIX stream-oriented file descriptors (excluding regular
-  files).
-
-* Added wrappers for Windows stream-oriented `HANDLE`s such as named pipes
-  (requires `HANDLE`s that work with I/O completion ports).
-
-* Added wrappers for Windows random-access `HANDLE`s such as files (requires
-  `HANDLE`s that work with I/O completion ports).
-
-* Added support for reactor-style operations (i.e. they report readiness but
-  perform no I/O) using a new `null_buffers` type.
-
-* Added an iterator type for bytewise traversal of buffer sequences.
-
-* Added new `read_until()` and `async_read_until()` overloads that take a
-  user-defined function object for locating message boundaries.
-
-* Added an experimental two-lock queue (enabled by defining
-  `(BOOST_)ASIO_ENABLE_TWO_LOCK_QUEUE`) that may provide better `io_service`
-  scalability across many processors.
-
-* Various fixes, performance improvements, and more complete coverage of the
-  custom memory allocation support.
-
-[heading Asio 1.0.0]
-
-First stable release of Asio.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/index.xml b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/index.xml
deleted file mode 100644
index e3dabbf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/index.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../boost/tools/boostbook/dtd/boostbook.dtd">
-
-<!--
-  Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-  Distributed under the Boost Software License, Version 1.0. (See accompanying
-  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<section id="asio.index">
-  <index id="asio.index.index"/>
-</section>
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/makepdf.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/makepdf.pl
deleted file mode 100755
index dfcecad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/makepdf.pl
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/perl -w
-
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-use strict;
-
-# Determine version number
-my $version = "X.Y.Z";
-open(VERSION, "../../include/asio/version.hpp") or die("Can't open version.hpp");
-while (my $line = <VERSION>)
-{
-  if ($line =~ /^#define ASIO_VERSION .* \/\/ (.*)$/)
-  {
-    $version = $1;
-  }
-}
-close(VERSION);
-
-# Generate PDF output
-system("bjam asioref");
-system("xsltproc --stringparam asio.version $version asioref.xsl asio.docbook > asioref.docbook");
-system("dblatex -I overview -s asioref.sty -P table.in.float=0 -o asioref-$version.pdf asioref.docbook");
-system("rm asioref.docbook");
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/model_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/model_dox.txt
deleted file mode 100644
index f5a678c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/model_dox.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-/**
-\page asynchronous_operation asynchronous operation
-*/
-
-/**
-\page completion_token completion token
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/net_ts.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/net_ts.qbk
deleted file mode 100644
index 85809fe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/net_ts.qbk
+++ /dev/null
@@ -1,479 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:net_ts Networking TS compatibility]
-
-Asio now provides the interfaces and functionality specified by the "C++
-Extensions for Networking" Technical Specification. In addition to access via
-the usual Asio header files, this functionality may be accessed through special
-headers that correspond to the header files defined in the TS. These are listed
-in the table below:
-
-[table
-  [[Networking TS header][Asio header]]
-  [[`#include <buffer>`][`#include <asio/ts/buffer.hpp>`]]
-  [[`#include <executor>`][`#include <asio/ts/executor.hpp>`]]
-  [[`#include <internet>`][`#include <asio/ts/internet.hpp>`]]
-  [[`#include <io_context>`][`#include <asio/ts/io_context.hpp>`]]
-  [[`#include <net>`][`#include <asio/ts/net.hpp>`]]
-  [[`#include <netfwd>`][`#include <asio/ts/netfwd.hpp>`]]
-  [[`#include <socket>`][`#include <asio/ts/socket.hpp>`]]
-  [[`#include <timer>`][`#include <asio/ts/timer.hpp>`]]
-]
-
-In some cases the new Networking TS compatible interfaces supersede older Asio
-facilities. In these cases the older interfaces have been deprecated. The table
-below shows the new Networking TS interfaces and the facilities they replace:
-
-[table
-  [[New interface][Old interface][Notes]]
-  [
-    [[link asio.reference.io_context `io_context`]]
-    [[link asio.reference.io_service `io_service`]]
-    [The name `io_service` is retained as a typedef.]
-  ]
-  [
-    [[link asio.reference.dispatch `dispatch`]]
-    [[link asio.reference.io_context.dispatch `io_service::dispatch`]]
-    [The `dispatch` free function can be used to submit functions to any [link
-    asio.reference.Executor1 Executor] or [link asio.reference.ExecutionContext
-    ExecutionContext].]
-  ]
-  [
-    [[link asio.reference.post `post`]]
-    [[link asio.reference.io_context.post `io_service::post`]]
-    [The `post` free function can be used to submit functions to any [link
-    asio.reference.Executor1 Executor] or [link asio.reference.ExecutionContext
-    ExecutionContext].]
-  ]
-  [
-    [[link asio.reference.defer `defer`]]
-    [[link asio.reference.io_context.post `io_service::post`] when the [link
-    asio.reference.asio_handler_is_continuation `asio_handler_is_continuation`]
-    hook returns true]
-    [The `defer` free function can be used to submit functions to any [link
-    asio.reference.Executor1 Executor] or [link asio.reference.ExecutionContext
-    ExecutionContext].]
-  ]
-  [
-    [[link asio.reference.io_context.poll `io_context::poll`]]
-    [[link asio.reference.io_context.poll `io_service::poll`] overload that
-    takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.io_context.poll_one `io_context::poll_one`]]
-    [[link asio.reference.io_context.poll_one `io_service::poll_one`] overload
-    that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.io_context.run `io_context::run`]]
-    [[link asio.reference.io_context.run `io_service::run`] overload that takes
-    `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.io_context.run_one `io_context::run_one`]]
-    [[link asio.reference.io_context.run_one `io_service::run_one`] overload
-    that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.io_context.run_for `io_context::run_for`],
-    [link asio.reference.io_context.run_until `io_context::run_until`],
-    [link asio.reference.io_context.run_one_for `io_context::run_one_for`], and
-    [link asio.reference.io_context.run_one_until `io_context::run_one_until`]]
-    []
-    [These functions add the ability to run an `io_context` for a limited time.]
-  ]
-  [
-    [[link asio.reference.io_context.restart `io_context::restart`]]
-    [[link asio.reference.io_context.reset `io_service::reset`]]
-    []
-  ]
-  [
-    [[link asio.reference.io_context.io_context `io_context`] constructor
-    `concurrency_hint` parameter is type `int`]
-    [[link asio.reference.io_context.io_context `io_context`] constructor
-    `concurrency_hint` parameter is type `std::size_t`]
-    [The old constructor has not been retained as a deprecated overload.]
-  ]
-  [
-    [[link asio.reference.execution_context `execution_context`], [link
-    asio.reference.execution_context__service `execution_context::service`],
-    and [link asio.reference.execution_context__id `execution_context::id`]]
-    [[link asio.reference.io_context `io_service`], [link
-    asio.reference.io_context__service `io_service::service`], and [link
-    asio.reference.execution_context__id `io_service::id`]]
-    [The service-related functionality has been moved to the
-    `execution_context` base class. This may also be used as a base for
-    creating custom execution contexts.]
-  ]
-  [
-    [[link asio.reference.execution_context.make_service `make_service`]]
-    [[link asio.reference.execution_context.add_service `add_service`]]
-    []
-  ]
-  [
-    [[link asio.reference.strand `strand`]]
-    [[link asio.reference.io_context__strand `io_service::strand`]]
-    [This template works with any valid executor, and is itself a valid
-    executor.]
-  ]
-  [
-    [[link asio.reference.executor_work_guard `executor_work_guard`] and [link
-    asio.reference.make_work_guard `make_work_guard`]]
-    [[link asio.reference.io_context__work `io_service::work`]]
-    [Work tracking is now covered by the [link asio.reference.Executor1
-    Executor] requirements. These templates work with any valid executor.]
-  ]
-  [
-    [[link asio.reference.executor_binder `executor_binder`] and [link
-    asio.reference.bind_executor `bind_executor`]]
-    [[link asio.reference.io_context.wrap `io_service::wrap`] and
-    [link asio.reference.io_context__strand.wrap `io_service::strand::wrap`]]
-    [These templates work with any valid executor.]
-  ]
-  [
-    [[link asio.reference.async_result `async_result`] with `CompletionToken`
-    and `Signature` template parameters]
-    [`handler_type` and single parameter `async_result`]
-    [The `async_result` trait is now the single point of customisation for
-    asynchronous operation completion handlers and return type.]
-  ]
-  [
-    [[link asio.reference.associated_executor `associated_executor`] and [link
-    asio.reference.get_associated_executor `get_associated_executor`]]
-    [[link asio.reference.asio_handler_invoke `asio_handler_invoke`]]
-    [The handler invocation hook has been replaced by the new [link
-    asio.reference.Executor1 Executor] requirements and the associated executor
-    traits.]
-  ]
-  [
-    [[link asio.reference.associated_allocator `associated_allocator`] and
-    [link asio.reference.get_associated_allocator `get_associated_allocator`]]
-    [[link asio.reference.asio_handler_allocate `asio_handler_allocate`] and
-    [link asio.reference.asio_handler_deallocate `asio_handler_deallocate`]]
-    [The handler allocation hooks have been replaced by the standard Allocator
-    requirements and the associated allocator traits.]
-  ]
-  [
-    [[link asio.reference.const_buffer.data `const_buffer::data`] and [link
-    asio.reference.mutable_buffer.data `mutable_buffer::data`]]
-    [[link asio.reference.buffer_cast `buffer_cast`]]
-    []
-  ]
-  [
-    [[link asio.reference.const_buffer.size `const_buffer::size`] and [link
-    asio.reference.mutable_buffer.size `mutable_buffer::size`]]
-    [[link asio.reference.buffer_size `buffer_size`] for single buffers]
-    [`buffer_size` is not deprecated for single buffers as `const_buffer` and
-    `mutable_buffer` now satisfy the buffer sequence requirements]
-  ]
-  [
-    [[link asio.reference.const_buffer `const_buffer`]]
-    [[link asio.reference.const_buffers_1 `const_buffers_1`]]
-    [The [link asio.reference.ConstBufferSequence ConstBufferSequence]
-    requirements have been modified such that `const_buffer` now satisfies
-    them.]
-  ]
-  [
-    [[link asio.reference.mutable_buffer `mutable_buffer`]]
-    [[link asio.reference.mutable_buffers_1 `mutable_buffers_1`]]
-    [The [link asio.reference.MutableBufferSequence MutableBufferSequence]
-    requirements have been modified such that `mutable_buffer` now satisfies
-    them.]
-  ]
-  [
-    [[link asio.reference.basic_socket.get_executor
-    `basic_socket::get_executor`] (and corresponding member for I/O objects
-    such as timers, serial ports, etc.)]
-    [[link asio.reference.basic_io_object.get_io_service
-    `basic_io_object::get_io_service`]]
-    [Use `get_executor().context()` to obtain the associated `io_context`.]
-  ]
-  [
-    [[link asio.reference.socket_base.max_listen_connections
-    `socket_base::max_listen_connections`]]
-    [[link asio.reference.socket_base.max_connections
-    `socket_base::max_connections`]]
-    []
-  ]
-  [
-    [[link asio.reference.socket_base.wait_type `socket_base::wait_type`],
-    [link asio.reference.basic_socket.wait `basic_socket::wait`], [link
-    asio.reference.basic_socket.async_wait `basic_socket::async_wait`], [link
-    asio.reference.basic_socket_acceptor.wait `basic_socket_acceptor::wait`],
-    and [link asio.reference.basic_socket_acceptor.async_wait
-    `basic_socket_acceptor::async_wait`]]
-    [[link asio.reference.null_buffers `null_buffers`]]
-    [Operations for reactive I/O.]
-  ]
-  [
-    [[link asio.reference.basic_socket_acceptor.accept
-    `basic_socket_acceptor::accept`] returns a socket]
-    [[link asio.reference.basic_socket_acceptor.accept
-    `basic_socket_acceptor::accept`] takes a socket by reference]
-    [Uses move support so requires C++11 or later. To accept a connection into
-    a socket object on a different `io_context`, pass the destination context
-    to `accept`.]
-  ]
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept
-    `basic_socket_acceptor::async_accept`] passes socket to handler]
-    [[link asio.reference.basic_socket_acceptor.async_accept
-    `basic_socket_acceptor::async_accept`] takes a socket by reference]
-    [Uses move support so requires C++11 or later. To accept a connection into
-    a socket object on a different `io_context`, pass the destination context
-    to `async_accept`.]
-  ]
-  [
-    [[link asio.reference.connect `connect`] overloads that take a range]
-    [[link asio.reference.connect `connect`] overloads that take a single
-    iterator]
-    [The [link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] function now returns a range. When the
-    `resolve` function's result is passed directly to `connect`, the range
-    overload will be selected.]
-  ]
-  [
-    [[link asio.reference.async_connect `async_connect`] overloads that take a
-    range]
-    [[link asio.reference.async_connect `async_connect`] overloads that take a
-    single iterator]
-    [The [link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] function now returns a range. When the
-    `resolve` function's result is passed directly to `async_connect`, the
-    range overload will be selected.]
-  ]
-  [
-    [[link asio.reference.basic_socket_streambuf.duration
-    `basic_socket_streambuf::duration`]]
-    [[link asio.reference.basic_socket_streambuf.duration_type
-    `basic_socket_streambuf::duration_type`]]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_streambuf.time_point
-    `basic_socket_streambuf::time_point`]]
-    [[link asio.reference.basic_socket_streambuf.time_type
-    `basic_socket_streambuf::time_type`]]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_streambuf.expiry
-    `basic_socket_streambuf::expiry`]]
-    [[link asio.reference.basic_socket_streambuf.expires_at
-    `basic_socket_streambuf::expires_at`] and [link
-    asio.reference.basic_socket_streambuf.expires_from_now
-    `basic_socket_streambuf::expires_from_now`] getters]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_streambuf.expires_after
-    `basic_socket_streambuf::expires_after`]]
-    [[link asio.reference.basic_socket_streambuf.expires_from_now
-    `basic_socket_streambuf::expires_from_now`] setter]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_streambuf.error
-    `basic_socket_streambuf::error`]]
-    [[link asio.reference.basic_socket_streambuf.puberror
-    `basic_socket_streambuf::puberror`]]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_iostream.duration
-    `basic_socket_iostream::duration`]]
-    [[link asio.reference.basic_socket_iostream.duration_type
-    `basic_socket_iostream::duration_type`]]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_iostream.time_point
-    `basic_socket_iostream::time_point`]]
-    [[link asio.reference.basic_socket_iostream.time_type
-    `basic_socket_iostream::time_type`]]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_iostream.expiry
-    `basic_socket_iostream::expiry`]]
-    [[link asio.reference.basic_socket_iostream.expires_at
-    `basic_socket_iostream::expires_at`] and [link
-    asio.reference.basic_socket_iostream.expires_from_now
-    `basic_socket_iostream::expires_from_now`] getters]
-    []
-  ]
-  [
-    [[link asio.reference.basic_socket_iostream.expires_after
-    `basic_socket_iostream::expires_after`]]
-    [[link asio.reference.basic_socket_iostream.expires_from_now
-    `basic_socket_iostream::expires_from_now`] setter]
-    []
-  ]
-  [
-    [[link asio.reference.basic_waitable_timer.cancel
-    `basic_waitable_timer::cancel`]]
-    [[link asio.reference.basic_waitable_timer.cancel
-    `basic_waitable_timer::cancel`] overload that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one
-    `basic_waitable_timer::cancel_one`]]
-    [[link asio.reference.basic_waitable_timer.cancel_one
-    `basic_waitable_timer::cancel_one`] overload that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at
-    `basic_waitable_timer::expires_at`] setter]
-    [[link asio.reference.basic_waitable_timer.expires_at
-    `basic_waitable_timer::expires_at`] setter that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.basic_waitable_timer.expiry
-    `basic_waitable_timer::expiry`]]
-    [[link asio.reference.basic_waitable_timer.expires_at
-    `basic_waitable_timer::expires_at`] and [link
-    asio.reference.basic_waitable_timer.expires_from_now
-    `basic_waitable_timer::expires_from_now`] getters]
-    []
-  ]
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after
-    `basic_waitable_timer::expires_after`]]
-    [[link asio.reference.basic_waitable_timer.expires_from_now
-    `basic_waitable_timer::expires_from_now`] setter]
-    []
-  ]
-  [
-    [[link asio.reference.ip__address.make_address `ip::make_address`]]
-    [[link asio.reference.ip__address.from_string `ip::address::from_string`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__address_v4.make_address_v4 `ip::make_address_v4`]]
-    [[link asio.reference.ip__address_v4.from_string
-    `ip::address_v4::from_string`] and [link
-    asio.reference.ip__address_v6.to_v4 `ip::address_v6::to_v4`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__address_v6.make_address_v6 `ip::make_address_v6`]]
-    [[link asio.reference.ip__address_v6.from_string
-    `ip::address_v6::from_string`] and [link
-    asio.reference.ip__address_v6.v4_mapped `ip::address_v6::v4_mapped`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__address.to_string `ip::address::to_string`]]
-    [[link asio.reference.ip__address.to_string `ip::address::to_string`] that
-    takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.ip__address_v4.to_string `ip::address_v4::to_string`]]
-    [[link asio.reference.ip__address_v4.to_string `ip::address_v4::to_string`]
-    that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [[link asio.reference.ip__address_v6.to_string `ip::address_v6::to_string`]]
-    [[link asio.reference.ip__address_v6.to_string `ip::address_v6::to_string`]
-    that takes `error_code&`]
-    [The `error_code` overload is not required.]
-  ]
-  [
-    [No replacement]
-    [[link asio.reference.ip__address_v6.is_v4_compatible
-    `ip::address_v6::is_v4_compatible`] and [link
-    asio.reference.ip__address_v6.v4_compatible
-    `ip::address_v6::v4_compatible`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__network_v4 `ip::network_v4`]]
-    [[link asio.reference.ip__address_v4.broadcast `ip::address_v4::broadcast`],
-    [link asio.reference.ip__address_v4.is_class_a `ip::address_v4::is_class_a`],
-    [link asio.reference.ip__address_v4.is_class_b `ip::address_v4::is_class_b`],
-    [link asio.reference.ip__address_v4.is_class_c `ip::address_v4::is_class_c`],
-    and [link asio.reference.ip__address_v4.netmask `ip::address_v4::netmask`]]
-    [The `network_v4` class adds the ability to manipulate IPv4 network
-    addresses using CIDR notation.]
-  ]
-  [
-    [[link asio.reference.ip__network_v6 `ip::network_v6`]]
-    []
-    [The `network_v6` class adds the ability to manipulate IPv6 network
-    addresses using CIDR notation.]
-  ]
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_
-    `ip::address_v4_iterator`] and [link
-    asio.reference.ip__basic_address_range_lt__address_v4__gt_
-    `ip::address_v4_range`]]
-    []
-    [The `ip::address_v4_iterator` and `address_v4_range` classes add the
-    ability to iterate over all, or a subset of, IPv4 addresses.]
-  ]
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_
-    `ip::address_v6_iterator`] and [link
-    asio.reference.ip__basic_address_range_lt__address_v6__gt_
-    `ip::address_v6_range`]]
-    []
-    [The `ip::address_v6_iterator` and `address_v6_range` classes add the
-    ability to iterate over all, or a subset of, IPv6 addresses.]
-  ]
-  [
-    [[link asio.reference.ip__basic_resolver.results_type
-    `ip::basic_resolver::results_type`]]
-    [[link asio.reference.ip__basic_resolver.iterator
-    `ip::basic_resolver::iterator`]]
-    [Resolvers now produce ranges rather than single iterators.]
-  ]
-  [
-    [[link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] overloads taking hostname and service as
-    arguments]
-    [[link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] overloads taking a [link
-    asio.reference.ip__basic_resolver.query `ip::basic_resolver::query`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] returns a range]
-    [[link asio.reference.ip__basic_resolver.resolve
-    `ip::basic_resolver::resolve`] returns a single iterator]
-    []
-  ]
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve
-    `ip::basic_resolver::async_resolve`] overloads taking hostname and service
-    as arguments]
-    [[link asio.reference.ip__basic_resolver.async_resolve
-    `ip::basic_resolver::async_resolve`] overloads taking a [link
-    asio.reference.ip__basic_resolver.query `ip::basic_resolver::query`]]
-    []
-  ]
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve
-    `ip::basic_resolver::async_resolve`] calls the handler with a range]
-    [[link asio.reference.ip__basic_resolver.async_resolve
-    `ip::basic_resolver::async_resolve`] calls the handler with a single
-    iterator]
-    []
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/noncopyable_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/noncopyable_dox.txt
deleted file mode 100644
index 949dabf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/noncopyable_dox.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-/**
-\class noncopyable
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview.qbk
deleted file mode 100644
index 241022d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview.qbk
+++ /dev/null
@@ -1,166 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:overview Overview]
-
-* [link asio.overview.rationale Rationale]
-* [link asio.overview.basics Basic Asio Anatomy]
-* [link asio.overview.model Asynchronous Model]
-  * [link asio.overview.model.async_ops Asynchronous Operations]
-  * [link asio.overview.model.async_agents Asynchronous Agents]
-  * [link asio.overview.model.associators Associated Characteristics and Associators]
-  * [link asio.overview.model.child_agents Child Agents]
-  * [link asio.overview.model.executors Executors]
-  * [link asio.overview.model.allocators Allocators]
-  * [link asio.overview.model.cancellation Cancellation]
-  * [link asio.overview.model.completion_tokens Completion Tokens]
-  * [link asio.overview.model.library_elements Supporting Library Elements]
-  * [link asio.overview.model.higher_levels Higher Level Abstractions]
-* [link asio.overview.core Core Concepts and Functionality]
-  * [link asio.overview.core.async The Proactor Design Pattern: Concurrency Without Threads]
-  * [link asio.overview.core.threads Threads and Asio]
-  * [link asio.overview.core.strands Strands: Use Threads Without Explicit Locking]
-  * [link asio.overview.core.buffers Buffers]
-  * [link asio.overview.core.streams Streams, Short Reads and Short Writes]
-  * [link asio.overview.core.reactor Reactor-Style Operations]
-  * [link asio.overview.core.line_based Line-Based Operations]
-  * [link asio.overview.core.allocation Custom Memory Allocation]
-  * [link asio.overview.core.cancellation Per-Operation Cancellation]
-  * [link asio.overview.core.handler_tracking Handler Tracking]
-  * [link asio.overview.core.concurrency_hint Concurrency Hints]
-* [link asio.overview.composition Composition and Completion Tokens]
-  * [link asio.overview.composition.coroutine Stackless Coroutines]
-  * [link asio.overview.composition.spawn Stackful Coroutines]
-  * [link asio.overview.composition.futures Futures]
-  * [link asio.overview.composition.cpp20_coroutines C++20 Coroutines Support]
-  * [link asio.overview.composition.coro Resumable C++20 Coroutines (experimental)]
-  * [link asio.overview.composition.deferred Deferred Operations (experimental)]
-  * [link asio.overview.composition.promises Promises (experimental)]
-  * [link asio.overview.composition.parallel_group Co-ordinating Parallel Operations (experimental)]
-  * [link asio.overview.composition.compose Compositions as Asynchronous Operations]
-  * [link asio.overview.composition.token_adapters Completion Token Adapters]
-  * [link asio.overview.composition.type_erasure Type Erasure, Separate Compilation and Virtual Functions]
-  * [link asio.overview.composition.immediate_completion Customising Immediate Completion]
-* [link asio.overview.networking Networking]
-  * [link asio.overview.networking.protocols TCP, UDP and ICMP]
-  * [link asio.overview.networking.other_protocols Support for Other Protocols]
-  * [link asio.overview.networking.iostreams Socket Iostreams]
-  * [link asio.overview.networking.bsd_sockets The BSD Socket API and Asio]
-* [link asio.overview.timers Timers]
-* [link asio.overview.files Files]
-* [link asio.overview.pipes Pipes]
-* [link asio.overview.serial_ports Serial Ports]
-* [link asio.overview.signals Signal Handling]
-* [link asio.overview.channels Channels (experimental)]
-* [link asio.overview.posix POSIX-Specific Functionality]
-  * [link asio.overview.posix.local UNIX Domain Sockets]
-  * [link asio.overview.posix.stream_descriptor Stream-Oriented File Descriptors]
-  * [link asio.overview.posix.fork Fork]
-* [link asio.overview.windows Windows-Specific Functionality]
-  * [link asio.overview.windows.stream_handle Stream-Oriented HANDLEs]
-  * [link asio.overview.windows.random_access_handle Random-Access HANDLEs]
-  * [link asio.overview.windows.object_handle Object HANDLEs]
-* [link asio.overview.ssl SSL]
-* [link asio.overview.cpp2011 C++ 2011 Support]
-  * [link asio.overview.cpp2011.move_objects Movable I/O Objects]
-  * [link asio.overview.cpp2011.move_handlers Movable Handlers]
-  * [link asio.overview.cpp2011.variadic Variadic Templates]
-  * [link asio.overview.cpp2011.array Array Container]
-  * [link asio.overview.cpp2011.atomic Atomics]
-  * [link asio.overview.cpp2011.shared_ptr Shared Pointers]
-  * [link asio.overview.cpp2011.chrono Chrono]
-* [link asio.overview.implementation Platform-Specific Implementation Notes]
-
-[include overview/rationale.qbk]
-[include overview/basics.qbk]
-[include overview/model.qbk]
-
-[section:core Core Concepts and Functionality]
-
-* [link asio.overview.core.async The Proactor Design Pattern: Concurrency Without Threads]
-* [link asio.overview.core.threads Threads and Asio]
-* [link asio.overview.core.strands Strands: Use Threads Without Explicit Locking]
-* [link asio.overview.core.buffers Buffers]
-* [link asio.overview.core.streams Streams, Short Reads and Short Writes]
-* [link asio.overview.core.reactor Reactor-Style Operations]
-* [link asio.overview.core.line_based Line-Based Operations]
-* [link asio.overview.core.allocation Custom Memory Allocation]
-* [link asio.overview.core.cancellation Per-Operation Cancellation]
-* [link asio.overview.core.handler_tracking Handler Tracking]
-* [link asio.overview.core.concurrency_hint Concurrency Hints]
-
-[include overview/async.qbk]
-[include overview/threads.qbk]
-[include overview/strands.qbk]
-[include overview/buffers.qbk]
-[include overview/streams.qbk]
-[include overview/reactor.qbk]
-[include overview/line_based.qbk]
-[include overview/allocation.qbk]
-[include overview/cancellation.qbk]
-[include overview/handler_tracking.qbk]
-[include overview/concurrency_hint.qbk]
-
-[endsect]
-
-[section:composition Composition and Completion Tokens]
-
-* [link asio.overview.composition.coroutine Stackless Coroutines]
-* [link asio.overview.composition.spawn Stackful Coroutines]
-* [link asio.overview.composition.futures Futures]
-* [link asio.overview.composition.cpp20_coroutines C++20 Coroutines Support]
-* [link asio.overview.composition.coro Resumable C++20 Coroutines (experimental)]
-* [link asio.overview.composition.deferred Deferred Operations (experimental)]
-* [link asio.overview.composition.promises Promises (experimental)]
-* [link asio.overview.composition.parallel_group Co-ordinating Parallel Operations (experimental)]
-* [link asio.overview.composition.compose Compositions as Asynchronous Operations]
-* [link asio.overview.composition.token_adapters Completion Token Adapters]
-* [link asio.overview.composition.type_erasure Type Erasure, Separate Compilation and Virtual Functions]
-* [link asio.overview.composition.immediate_completion Customising Immediate Completion]
-
-[include overview/coroutine.qbk]
-[include overview/spawn.qbk]
-[include overview/futures.qbk]
-[include overview/cpp20_coroutines.qbk]
-[include overview/coro.qbk]
-[include overview/deferred.qbk]
-[include overview/promises.qbk]
-[include overview/parallel_group.qbk]
-[include overview/compose.qbk]
-[include overview/token_adapters.qbk]
-[include overview/type_erasure.qbk]
-[include overview/immediate_completion.qbk]
-
-[endsect]
-
-[section:networking Networking]
-
-* [link asio.overview.networking.protocols TCP, UDP and ICMP]
-* [link asio.overview.networking.other_protocols Support for Other Protocols]
-* [link asio.overview.networking.iostreams Socket Iostreams]
-* [link asio.overview.networking.bsd_sockets The BSD Socket API and Asio]
-
-[include overview/protocols.qbk]
-[include overview/other_protocols.qbk]
-[include overview/iostreams.qbk]
-[include overview/bsd_sockets.qbk]
-
-[endsect]
-
-[include overview/timers.qbk]
-[include overview/files.qbk]
-[include overview/pipes.qbk]
-[include overview/serial_ports.qbk]
-[include overview/signals.qbk]
-[include overview/channels.qbk]
-[include overview/posix.qbk]
-[include overview/windows.qbk]
-[include overview/ssl.qbk]
-[include overview/cpp2011.qbk]
-[include overview/implementation.qbk]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/allocation.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/allocation.qbk
deleted file mode 100644
index 60a5698..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/allocation.qbk
+++ /dev/null
@@ -1,94 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:allocation Custom Memory Allocation]
-
-Many asynchronous operations need to allocate an object to store state
-associated with the operation. For example, a Win32 implementation needs
-`OVERLAPPED`-derived objects to pass to Win32 API functions.
-
-Furthermore, programs typically contain easily identifiable chains of
-asynchronous operations. A half duplex protocol implementation (e.g. an HTTP
-server) would have a single chain of operations per client (receives followed
-by sends). A full duplex protocol implementation would have two chains
-executing in parallel. Programs should be able to leverage this knowledge to
-reuse memory for all asynchronous operations in a chain.
-
-Given a copy of a user-defined `Handler` object `h`, if the implementation
-needs to allocate memory associated with that handler it will obtain an
-allocator using the `get_associated_allocator` function. For example:
-
-  asio::associated_allocator_t<Handler> a = asio::get_associated_allocator(h);
-
-The associated allocator must satisfy the standard Allocator requirements.
-
-By default, handlers use the standard allocator (which is implemented in terms
-of `::operator new()` and `::operator delete()`). The allocator may be
-customised for a particular handler type by specifying a nested type
-`allocator_type` and member function `get_allocator()`:
-
-  class my_handler
-  {
-  public:
-    // Custom implementation of Allocator type requirements.
-    typedef my_allocator allocator_type;
-
-    // Return a custom allocator implementation.
-    allocator_type get_allocator() const noexcept
-    {
-      return my_allocator();
-    }
-
-    void operator()() { ... }
-  };
-
-In more complex cases, the `associated_allocator` template may be partially
-specialised directly:
-
-  namespace asio {
-
-    template <typename Allocator>
-    struct associated_allocator<my_handler, Allocator>
-    {
-      // Custom implementation of Allocator type requirements.
-      typedef my_allocator type;
-
-      // Return a custom allocator implementation.
-      static type get(const my_handler&,
-          const Allocator& a = Allocator()) noexcept
-      {
-        return my_allocator();
-      }
-    };
-
-  } // namespace asio
-
-The implementation guarantees that the deallocation will occur before the
-associated handler is invoked, which means the memory is ready to be reused for
-any new asynchronous operations started by the handler.
-
-The custom memory allocation functions may be called from any user-created
-thread that is calling an Asio library function. The implementation guarantees,
-for the asynchronous operations included with the library, that within the
-context of an individual operation the implementation will not make concurrent
-calls to the memory allocation functions for that handler. The implementation
-will insert appropriate memory barriers to ensure correct memory visibility
-should an asynchronous operation need to call the allocation functions from
-different threads. (Note: If the same allocator is shared across multiple
-concurrent asynchronous operations, this can result in concurrent calls to the
-memory allocation functions. Use of a [link asio.overview.core.strands strand]
-does not prevent these concurrent calls, as an operation may need to allocate
-memory from outside the strand. In this case, the shared allocator is
-responsible for providing the necessary thread safety guarantees.)
-
-[heading See Also]
-
-[link asio.reference.associated_allocator associated_allocator],
-[link asio.reference.get_associated_allocator get_associated_allocator],
-[link asio.examples.cpp11_examples.allocation custom memory allocation example (C++11)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async.qbk
deleted file mode 100644
index 7d30554..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async.qbk
+++ /dev/null
@@ -1,186 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:async The Proactor Design Pattern: Concurrency Without Threads]
-
-The Asio library offers side-by-side support for synchronous and asynchronous
-operations. The asynchronous support is based on the Proactor design pattern
-[link asio.overview.core.async.references \[POSA2\]]. The advantages and
-disadvantages of this approach, when compared to a synchronous-only or Reactor
-approach, are outlined below.
-
-[heading Proactor and Asio]
-
-Let us examine how the Proactor design pattern is implemented in Asio,
-without reference to platform-specific details.
-
-[$proactor.png]
-
-[*Proactor design pattern (adapted from \[POSA2\])]
-
-[mdash] Asynchronous Operation
-
-[:Defines an operation that is executed asynchronously, such as an asynchronous
-read or write on a socket.]
-
-[mdash] Asynchronous Operation Processor
-
-[:Executes asynchronous operations and queues events on a completion event
-queue when operations complete. From a high-level point of view, internal
-services like `reactive_socket_service` are asynchronous operation processors.]
-
-[mdash] Completion Event Queue
-
-[:Buffers completion events until they are dequeued by an asynchronous event
-demultiplexer.]
-
-[mdash] Completion Handler
-
-[:Processes the result of an asynchronous operation. These are function
-objects, often created using `boost::bind`.]
-
-[mdash] Asynchronous Event Demultiplexer
-
-[:Blocks waiting for events to occur on the completion event queue, and returns
-a completed event to its caller.]
-
-[mdash] Proactor
-
-[:Calls the asynchronous event demultiplexer to dequeue events, and dispatches
-the completion handler (i.e. invokes the function object) associated with the
-event. This abstraction is represented by the `io_context` class.]
-
-[mdash] Initiator
-
-[:Application-specific code that starts asynchronous operations. The initiator
-interacts with an asynchronous operation processor via a high-level interface
-such as `basic_stream_socket`, which in turn delegates to a service like
-`reactive_socket_service`.]
-
-[heading Implementation Using Reactor]
-
-On many platforms, Asio implements the Proactor design pattern in terms
-of a Reactor, such as `select`, `epoll` or `kqueue`. This implementation
-approach corresponds to the Proactor design pattern as follows:
-
-[mdash] Asynchronous Operation Processor
-
-[:A reactor implemented using `select`, `epoll` or `kqueue`. When the reactor
-indicates that the resource is ready to perform the operation, the processor
-executes the asynchronous operation and enqueues the associated completion
-handler on the completion event queue.]
-
-[mdash] Completion Event Queue
-
-[:A linked list of completion handlers (i.e. function objects).]
-
-[mdash] Asynchronous Event Demultiplexer
-
-[:This is implemented by waiting on an event or condition variable until a
-completion handler is available in the completion event queue.]
-
-[heading Implementation Using Windows Overlapped I/O]
-
-On Windows NT, 2000 and XP, Vista, 7 and later, Asio takes advantage of
-overlapped I/O to provide an efficient implementation of the Proactor design
-pattern. This implementation approach corresponds to the Proactor design
-pattern as follows:
-
-[mdash] Asynchronous Operation Processor
-
-[:This is implemented by the operating system. Operations are initiated by
-calling an overlapped function such as `AcceptEx`.]
-
-[mdash] Completion Event Queue
-
-[:This is implemented by the operating system, and is associated with an I/O
-completion port. There is one I/O completion port for each `io_context`
-instance.]
-
-[mdash] Asynchronous Event Demultiplexer
-
-[:Called by Asio to dequeue events and their associated completion
-handlers.]
-
-[heading Advantages] 
-
-[mdash] Portability.
-
-[:Many operating systems offer a native asynchronous I/O API (such as
-overlapped I/O on __Windows__) as the preferred option for developing high
-performance network applications. The library may be implemented in terms of
-native asynchronous I/O. However, if native support is not available, the
-library may also be implemented using synchronous event demultiplexors that
-typify the Reactor pattern, such as __POSIX__ `select()`.]
-
-[mdash] Decoupling threading from concurrency.
-
-[:Long-duration operations are performed asynchronously by the implementation
-on behalf of the application. Consequently applications do not need to spawn
-many threads in order to increase concurrency.]
-
-[mdash] Performance and scalability.
-
-[:Implementation strategies such as thread-per-connection (which a
-synchronous-only approach would require) can degrade system performance, due to
-increased context switching, synchronisation and data movement among CPUs. With
-asynchronous operations it is possible to avoid the cost of context switching
-by minimising the number of operating system threads [mdash] typically a
-limited resource [mdash] and only activating the logical threads of control
-that have events to process.]
-
-[mdash] Simplified application synchronisation.
-
-[:Asynchronous operation completion handlers can be written as though they
-exist in a single-threaded environment, and so application logic can be
-developed with little or no concern for synchronisation issues.]
-
-[mdash] Function composition.
-
-[:Function composition refers to the implementation of functions to provide a
-higher-level operation, such as sending a message in a particular format. Each
-function is implemented in terms of multiple calls to lower-level read or write
-operations.]
-
-[:For example, consider a protocol where each message consists of a
-fixed-length header followed by a variable length body, where the length of the
-body is specified in the header. A hypothetical read_message operation could be
-implemented using two lower-level reads, the first to receive the header and,
-once the length is known, the second to receive the body.]
-
-[:To compose functions in an asynchronous model, asynchronous operations can be
-chained together. That is, a completion handler for one operation can initiate
-the next. Starting the first call in the chain can be encapsulated so that the
-caller need not be aware that the higher-level operation is implemented as a
-chain of asynchronous operations.]
-
-[:The ability to compose new operations in this way simplifies the development
-of higher levels of abstraction above a networking library, such as functions
-to support a specific protocol.]
-
-[heading Disadvantages] 
-
-[mdash] Program complexity.
-
-[:It is more difficult to develop applications using asynchronous mechanisms
-due to the separation in time and space between operation initiation and
-completion. Applications may also be harder to debug due to the inverted flow
-of control.]
-
-[mdash] Memory usage.
-
-[:Buffer space must be committed for the duration of a read or write operation,
-which may continue indefinitely, and a separate buffer is required for each
-concurrent operation. The Reactor pattern, on the other hand, does not require
-buffer space until a socket is ready for reading or writing.]
-
-[heading References]
-
-\[POSA2\] D. Schmidt et al, ['Pattern Oriented Software Architecture, Volume
-2]. Wiley, 2000.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.dot b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.dot
deleted file mode 100644
index 9bbdf34..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.dot
+++ /dev/null
@@ -1,78 +0,0 @@
-digraph g
-{
-  graph
-    [
-      nodesep="0.2"
-    ];
-
-  edge
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      labelfontname="Helvetica",
-      labelfontsize=10
-    ];
-
-  node
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      shape=box
-    ];
-
-  edge
-    [
-      arrowhead="open"
-    ]
-
-  // Program elements.
-  {
-    operating_system [ label="Operating System", shape=ellipse ];
-    io_context [ label="I/O Execution Context\ne.g. io_context" ];
-    io_object [ label="I/O Object\ne.g. socket" ];
-    your_program [ label="Your Program" ];
-    your_completion_handler [ label="Your Completion Handler" ];
-  }
-
-  // Owning relationships.
-  {
-    edge [ arrowtail="diamond" ];
-    your_program:e -> your_completion_handler:n;
-    your_program:w -> io_object:nw;
-    your_program:se -> io_context:ne;
-  }
-
-  // Non-owning relationships;
-  {
-    io_object:sw -> io_context:w;
-  }
-
-  // Visible actions.
-  {
-    edge [ style="dashed", color="#808080" ];
-
-    // Forward actions.
-    {
-      your_program:sw -> io_object:n [ label="1" ];
-      io_object:s -> io_context:nw [ label="2" ];
-      io_context:s -> operating_system:n [ label="3" ];
-    }
-  }
-
-  // Invisible actions.
-  {
-    edge [ style="invis" ];
-
-    // Forward actions.
-    {
-      your_program:s -> io_context:n [ label="5" ];
-    }
-
-    // Reverse actions.
-    {
-      edge [ arrowhead="none", arrowtail="open" ];
-      //io_context:s -> operating_system:n [ label="4" ];
-      your_completion_handler:s -> io_context:e [ label="6" ];
-    }
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.png
deleted file mode 100644
index 1151be6..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op1.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.dot b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.dot
deleted file mode 100644
index 52823ba..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.dot
+++ /dev/null
@@ -1,78 +0,0 @@
-digraph g
-{
-  graph
-    [
-      nodesep="0.2"
-    ];
-
-  edge
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      labelfontname="Helvetica",
-      labelfontsize=10
-    ];
-
-  node
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      shape=box
-    ];
-
-  edge
-    [
-      arrowhead="open"
-    ]
-
-  // Program elements.
-  {
-    operating_system [ label="Operating System", shape=ellipse ];
-    io_context [ label="I/O Execution Context\ne.g. io_context" ];
-    io_object [ label="I/O Object\ne.g. socket" ];
-    your_program [ label="Your Program" ];
-    your_completion_handler [ label="Your Completion Handler" ];
-  }
-
-  // Owning relationships.
-  {
-    edge [ arrowtail="diamond" ];
-    your_program:e -> your_completion_handler:n;
-    your_program:w -> io_object:nw;
-    your_program:se -> io_context:ne;
-  }
-
-  // Non-owning relationships;
-  {
-    io_object:sw -> io_context:w;
-  }
-
-  // Visible actions.
-  {
-    edge [ style="dashed", color="#808080" ];
-
-    // Forward actions.
-    {
-      your_program:s -> io_context:n [ label="5" ];
-    }
-
-    // Reverse actions.
-    {
-      edge [ arrowhead="none", arrowtail="open" ];
-      io_context:s -> operating_system:n [ label="4" ];
-      your_completion_handler:s -> io_context:e [ label="6" ];
-    }
-  }
-
-  // Invisible actions.
-  {
-    edge [ style="invis" ];
-
-    // Forward actions.
-    {
-      your_program:sw -> io_object:n [ label="1" ];
-      io_object:s -> io_context:nw [ label="2" ];
-      //io_context:s -> operating_system:n [ label="3" ];
-    }
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.png
deleted file mode 100644
index cf7cb43..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/async_op2.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/basics.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/basics.qbk
deleted file mode 100644
index bd2af33..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/basics.qbk
+++ /dev/null
@@ -1,111 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:basics Basic Asio Anatomy]
-
-Asio may be used to perform both synchronous and asynchronous operations on I/O
-objects such as sockets. Before using Asio it may be useful to get a conceptual
-picture of the various parts of Asio, your program, and how they work together.
-
-As an introductory example, let's consider what happens when you perform a
-connect operation on a socket. We shall start by examining synchronous
-operations.
-
-[$sync_op.png]
-
-[*Your program] will have at least one [*I/O execution context], such as an
-`asio::io_context` object, `asio::thread_pool` object, or
-`asio::system_context`. This [*I/O execution context] represents [*your
-program]'s link to the [*operating system]'s I/O services.
-
-  asio::io_context io_context;
-
-To perform I/O operations [*your program] will need an [*I/O object] such as a
-TCP socket:
-
-  asio::ip::tcp::socket socket(io_context);
-
-When a synchronous connect operation is performed, the following sequence of
-events occurs:
-
-1. [*Your program] initiates the connect operation by calling the [*I/O
-object]:
-
-  socket.connect(server_endpoint);
-
-2. The [*I/O object] forwards the request to the [*I/O execution context].
-
-3. The [*I/O execution context] calls on the [*operating system] to perform the
-connect operation.
-
-4. The [*operating system] returns the result of the operation to the
-[*I/O execution context].
-
-5. The [*I/O execution context] translates any error resulting from the
-operation into an object of type `asio::error_code`. An `error_code` may be
-compared with specific values, or tested as a boolean (where a `false` result
-means that no error occurred). The result is then forwarded back up to the
-[*I/O object].
-
-6. The [*I/O object] throws an exception of type `asio::system_error` if the
-operation failed. If the code to initiate the operation had instead been
-written as:
-
-  asio::error_code ec;
-  socket.connect(server_endpoint, ec);
-
-then the `error_code` variable `ec` would be set to the result of the
-operation, and no exception would be thrown.
-
-When an asynchronous operation is used, a different sequence of events occurs.
-
-[$async_op1.png]
-
-1. [*Your program] initiates the connect operation by calling the [*I/O
-object]:
-
-  socket.async_connect(server_endpoint, your_completion_handler);
-
-where `your_completion_handler` is a function or function object with the
-signature:
-
-  void your_completion_handler(const asio::error_code& ec);
-
-The exact signature required depends on the asynchronous operation being
-performed. The reference documentation indicates the appropriate form for each
-operation.
-
-2. The [*I/O object] forwards the request to the [*I/O execution context].
-
-3. The [*I/O execution context] signals to the [*operating system] that it
-should start an asynchronous connect.
-
-Time passes. (In the synchronous case this wait would have been contained
-entirely within the duration of the connect operation.)
-
-[$async_op2.png]
-
-4. The [*operating system] indicates that the connect operation has completed
-by placing the result on a queue, ready to be picked up by the [*I/O execution
-context].
-
-5. When using an `io_context` as the [*I/O execution context], [*your program]
-must make a call to `io_context::run()` (or to one of the similar `io_context`
-member functions) in order for the result to be retrieved. A call to
-`io_context::run()` blocks while there are unfinished asynchronous operations,
-so you would typically call it as soon as you have started your first
-asynchronous operation.
-
-6. While inside the call to `io_context::run()`, the [*I/O execution context]
-dequeues the result of the operation, translates it into an `error_code`, and
-then passes it to [*your completion handler].
-
-This is a simplified picture of how Asio operates. You will want to delve
-further into the documentation if your needs are more advanced, such as
-extending Asio to perform other types of asynchronous operations.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/bsd_sockets.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/bsd_sockets.qbk
deleted file mode 100644
index 91e88da..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/bsd_sockets.qbk
+++ /dev/null
@@ -1,270 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:bsd_sockets The BSD Socket API and Asio]
-
-The Asio library includes a low-level socket interface based on the BSD socket
-API, which is widely implemented and supported by extensive literature. It is
-also used as the basis for networking APIs in other languages, like Java. This
-low-level interface is designed to support the development of efficient and
-scalable applications. For example, it permits programmers to exert finer
-control over the number of system calls, avoid redundant data copying, minimise
-the use of resources like threads, and so on.
-
-Unsafe and error prone aspects of the BSD socket API are not included. For
-example, the use of `int` to represent all sockets lacks type safety. The
-socket representation in Asio uses a distinct type for each protocol, e.g. for
-TCP one would use `ip::tcp::socket`, and for UDP one uses `ip::udp::socket`.
-
-The following table shows the mapping between the BSD socket API and Asio:
-
-[table
-  [
-    [BSD Socket API Elements]
-    [Equivalents in Asio]
-  ]
-  [
-    [socket descriptor - `int` (POSIX) or `SOCKET` (Windows)]
-    [ For TCP: [link asio.reference.ip__tcp.socket ip::tcp::socket],
-               [link asio.reference.ip__tcp.acceptor ip::tcp::acceptor]
-
-      For UDP: [link asio.reference.ip__udp.socket ip::udp::socket]
-
-               [link asio.reference.basic_socket basic_socket],
-               [link asio.reference.basic_stream_socket basic_stream_socket],
-               [link asio.reference.basic_datagram_socket basic_datagram_socket],
-               [link asio.reference.basic_raw_socket basic_raw_socket] ]
-  ]
-  [
-    [`in_addr`,
-     `in6_addr`]
-    [          [link asio.reference.ip__address ip::address],
-               [link asio.reference.ip__address ip::address_v4],
-               [link asio.reference.ip__address ip::address_v6] ]
-  ]
-  [
-    [`sockaddr_in`,
-     `sockaddr_in6`]
-    [ For TCP: [link asio.reference.ip__tcp.endpoint ip::tcp::endpoint]
-    
-      For UDP: [link asio.reference.ip__udp.endpoint ip::udp::endpoint]
-
-               [link asio.reference.ip__basic_endpoint ip::basic_endpoint] ]
-  ]
-  [
-    [`accept()`]
-    [ For TCP: [link asio.reference.basic_socket_acceptor.accept ip::tcp::acceptor::accept()]
-
-               [link asio.reference.basic_socket_acceptor.accept basic_socket_acceptor::accept()] ]
-  ]
-  [
-    [`bind()`]
-    [ For TCP: [link asio.reference.basic_socket.bind ip::tcp::acceptor::bind()],
-               [link asio.reference.basic_socket.bind ip::tcp::socket::bind()]
-
-      For UDP: [link asio.reference.basic_socket.bind ip::udp::socket::bind()]
-
-               [link asio.reference.basic_socket.bind basic_socket::bind()] ]
-  ]
-  [
-    [`close()`]
-    [ For TCP: [link asio.reference.basic_socket.close ip::tcp::acceptor::close()],
-               [link asio.reference.basic_socket.close ip::tcp::socket::close()]
-
-      For UDP: [link asio.reference.basic_socket.close ip::udp::socket::close()]
-
-               [link asio.reference.basic_socket.close basic_socket::close()] ]
-  ]
-  [
-    [`connect()`]
-    [ For TCP: [link asio.reference.basic_socket.connect ip::tcp::socket::connect()]
-
-      For UDP: [link asio.reference.basic_socket.connect ip::udp::socket::connect()]
-
-               [link asio.reference.basic_socket.connect basic_socket::connect()] ]
-  ]
-  [
-    [`getaddrinfo()`,
-     `gethostbyaddr()`,
-     `gethostbyname()`,
-     `getnameinfo()`,
-     `getservbyname()`,
-     `getservbyport()`]
-    [ For TCP: [link asio.reference.ip__basic_resolver.resolve ip::tcp::resolver::resolve()],
-               [link asio.reference.ip__basic_resolver.async_resolve ip::tcp::resolver::async_resolve()]
-
-      For UDP: [link asio.reference.ip__basic_resolver.resolve ip::udp::resolver::resolve()],
-               [link asio.reference.ip__basic_resolver.async_resolve ip::udp::resolver::async_resolve()]
-
-               [link asio.reference.ip__basic_resolver.resolve ip::basic_resolver::resolve()],
-               [link asio.reference.ip__basic_resolver.async_resolve ip::basic_resolver::async_resolve()] ]
-  ]
-  [
-    [`gethostname()`]
-    [          [link asio.reference.ip__host_name ip::host_name()] ]
-  ]
-  [
-    [`getpeername()`]
-    [ For TCP: [link asio.reference.basic_socket.remote_endpoint ip::tcp::socket::remote_endpoint()]
-
-      For UDP: [link asio.reference.basic_socket.remote_endpoint ip::udp::socket::remote_endpoint()]
-
-               [link asio.reference.basic_socket.remote_endpoint basic_socket::remote_endpoint()] ]
-  ]
-  [
-    [`getsockname()`]
-    [ For TCP: [link asio.reference.basic_socket.local_endpoint ip::tcp::acceptor::local_endpoint()],
-               [link asio.reference.basic_socket.local_endpoint ip::tcp::socket::local_endpoint()]
-
-      For UDP: [link asio.reference.basic_socket.local_endpoint ip::udp::socket::local_endpoint()]
-
-               [link asio.reference.basic_socket.local_endpoint basic_socket::local_endpoint()] ]
-  ]
-  [
-    [`getsockopt()`]
-    [ For TCP: [link asio.reference.basic_socket.get_option ip::tcp::acceptor::get_option()],
-               [link asio.reference.basic_socket.get_option ip::tcp::socket::get_option()]
-
-      For UDP: [link asio.reference.basic_socket.get_option ip::udp::socket::get_option()]
-
-               [link asio.reference.basic_socket.get_option basic_socket::get_option()] ]
-  ]
-  [
-    [`inet_addr()`,
-     `inet_aton()`,
-     `inet_pton()`]
-    [          [link asio.reference.ip__address.from_string ip::address::from_string()],
-               [link asio.reference.ip__address.from_string ip::address_v4::from_string()],
-               [link asio.reference.ip__address.from_string ip_address_v6::from_string()] ]
-  ]
-  [
-    [`inet_ntoa()`,
-     `inet_ntop()`]
-    [          [link asio.reference.ip__address.to_string ip::address::to_string()],
-               [link asio.reference.ip__address.to_string ip::address_v4::to_string()],
-               [link asio.reference.ip__address.to_string ip_address_v6::to_string()] ]
-  ]
-  [
-    [`ioctl()`]
-    [ For TCP: [link asio.reference.basic_socket.io_control ip::tcp::socket::io_control()]
-
-      For UDP: [link asio.reference.basic_socket.io_control ip::udp::socket::io_control()]
-
-               [link asio.reference.basic_socket.io_control basic_socket::io_control()] ]
-  ]
-  [
-    [`listen()`]
-    [ For TCP: [link asio.reference.basic_socket_acceptor.listen ip::tcp::acceptor::listen()]
-
-               [link asio.reference.basic_socket_acceptor.listen basic_socket_acceptor::listen()] ]
-  ]
-  [
-    [`poll()`,
-     `select()`,
-     `pselect()`]
-    [          [link asio.reference.io_context.run io_context::run()],
-               [link asio.reference.io_context.run_one io_context::run_one()],
-               [link asio.reference.io_context.poll io_context::poll()],
-               [link asio.reference.io_context.poll_one io_context::poll_one()]
-
-      Note: in conjunction with asynchronous operations. ]
-  ]
-  [
-    [`readv()`,
-     `recv()`,
-     `read()`]
-    [ For TCP: [link asio.reference.basic_stream_socket.read_some ip::tcp::socket::read_some()],
-               [link asio.reference.basic_stream_socket.async_read_some ip::tcp::socket::async_read_some()],
-               [link asio.reference.basic_stream_socket.receive ip::tcp::socket::receive()],
-               [link asio.reference.basic_stream_socket.async_receive ip::tcp::socket::async_receive()]
-
-      For UDP: [link asio.reference.basic_datagram_socket.receive ip::udp::socket::receive()],
-               [link asio.reference.basic_datagram_socket.async_receive ip::udp::socket::async_receive()]
-
-               [link asio.reference.basic_stream_socket.read_some basic_stream_socket::read_some()],
-               [link asio.reference.basic_stream_socket.async_read_some basic_stream_socket::async_read_some()],
-               [link asio.reference.basic_stream_socket.receive basic_stream_socket::receive()],
-               [link asio.reference.basic_stream_socket.async_receive basic_stream_socket::async_receive()],
-               [link asio.reference.basic_datagram_socket.receive basic_datagram_socket::receive()],
-               [link asio.reference.basic_datagram_socket.async_receive basic_datagram_socket::async_receive()] ]
-  ]
-  [
-    [`recvfrom()`]
-    [ For UDP: [link asio.reference.basic_datagram_socket.receive_from ip::udp::socket::receive_from()],
-               [link asio.reference.basic_datagram_socket.async_receive_from ip::udp::socket::async_receive_from()]
-
-               [link asio.reference.basic_datagram_socket.receive_from basic_datagram_socket::receive_from()],
-               [link asio.reference.basic_datagram_socket.async_receive_from basic_datagram_socket::async_receive_from()] ]
-  ]
-  [
-    [`send()`,
-     `write()`,
-     `writev()`]
-    [ For TCP: [link asio.reference.basic_stream_socket.write_some ip::tcp::socket::write_some()],
-               [link asio.reference.basic_stream_socket.async_write_some ip::tcp::socket::async_write_some()],
-               [link asio.reference.basic_stream_socket.send ip::tcp::socket::send()],
-               [link asio.reference.basic_stream_socket.async_send ip::tcp::socket::async_send()]
-
-      For UDP: [link asio.reference.basic_datagram_socket.send ip::udp::socket::send()],
-               [link asio.reference.basic_datagram_socket.async_send ip::udp::socket::async_send()]
-
-               [link asio.reference.basic_stream_socket.write_some basic_stream_socket::write_some()],
-               [link asio.reference.basic_stream_socket.async_write_some basic_stream_socket::async_write_some()],
-               [link asio.reference.basic_stream_socket.send basic_stream_socket::send()],
-               [link asio.reference.basic_stream_socket.async_send basic_stream_socket::async_send()],
-               [link asio.reference.basic_datagram_socket.send basic_datagram_socket::send()],
-               [link asio.reference.basic_datagram_socket.async_send basic_datagram_socket::async_send()] ]
-  ]
-  [
-    [`sendto()`]
-    [ For UDP: [link asio.reference.basic_datagram_socket.send_to ip::udp::socket::send_to()],
-               [link asio.reference.basic_datagram_socket.async_send_to ip::udp::socket::async_send_to()]
-
-               [link asio.reference.basic_datagram_socket.send_to basic_datagram_socket::send_to()],
-               [link asio.reference.basic_datagram_socket.async_send_to basic_datagram_socket::async_send_to()] ]
-  ]
-  [
-    [`setsockopt()`]
-    [ For TCP: [link asio.reference.basic_socket.set_option ip::tcp::acceptor::set_option()],
-               [link asio.reference.basic_socket.set_option ip::tcp::socket::set_option()]
-
-      For UDP: [link asio.reference.basic_socket.set_option ip::udp::socket::set_option()]
-
-               [link asio.reference.basic_socket.set_option basic_socket::set_option()] ]
-  ]
-  [
-    [`shutdown()`]
-    [ For TCP: [link asio.reference.basic_socket.shutdown ip::tcp::socket::shutdown()]
-
-      For UDP: [link asio.reference.basic_socket.shutdown ip::udp::socket::shutdown()]
-
-               [link asio.reference.basic_socket.shutdown basic_socket::shutdown()] ]
-  ]
-  [
-    [`sockatmark()`]
-    [ For TCP: [link asio.reference.basic_socket.at_mark ip::tcp::socket::at_mark()]
-
-               [link asio.reference.basic_socket.at_mark basic_socket::at_mark()] ]
-  ]
-  [
-    [`socket()`]
-    [ For TCP: [link asio.reference.basic_socket.open ip::tcp::acceptor::open()],
-               [link asio.reference.basic_socket.open ip::tcp::socket::open()]
-
-      For UDP: [link asio.reference.basic_socket.open ip::udp::socket::open()]
-
-               [link asio.reference.basic_socket.open basic_socket::open()] ]
-  ]
-  [
-    [`socketpair()`]
-    [          [link asio.reference.local__connect_pair local::connect_pair()]
-
-      Note: POSIX operating systems only. ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/buffers.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/buffers.qbk
deleted file mode 100644
index 1451639..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/buffers.qbk
+++ /dev/null
@@ -1,184 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:buffers Buffers]
-
-Fundamentally, I/O involves the transfer of data to and from contiguous regions
-of memory, called buffers. These buffers can be simply expressed as a tuple
-consisting of a pointer and a size in bytes. However, to allow the development
-of efficient network applications, Asio includes support for scatter-gather
-operations. These operations involve one or more buffers:
-
-* A scatter-read receives data into multiple buffers.
-* A gather-write transmits multiple buffers.
-
-Therefore we require an abstraction to represent a collection of buffers. The
-approach used in Asio is to define a type (actually two types) to
-represent a single buffer. These can be stored in a container, which may be
-passed to the scatter-gather operations.
-
-In addition to specifying buffers as a pointer and size in bytes, Asio makes a
-distinction between modifiable memory (called mutable) and non-modifiable
-memory (where the latter is created from the storage for a const-qualified
-variable). These two types could therefore be defined as follows:
-
-  typedef std::pair<void*, std::size_t> mutable_buffer;
-  typedef std::pair<const void*, std::size_t> const_buffer;
-
-Here, a mutable_buffer would be convertible to a const_buffer, but conversion
-in the opposite direction is not valid.
-
-However, Asio does not use the above definitions as-is, but instead defines two
-classes: `mutable_buffer` and `const_buffer`. The goal of these is to provide
-an opaque representation of contiguous memory, where:
-
-* Types behave as std::pair would in conversions. That is, a `mutable_buffer` is
-  convertible to a `const_buffer`, but the opposite conversion is disallowed.
-
-* There is protection against buffer overruns. Given a buffer instance, a user
-  can only create another buffer representing the same range of memory or a
-  sub-range of it. To provide further safety, the library also includes
-  mechanisms for automatically determining the size of a buffer from an array,
-  `boost::array` or `std::vector` of POD elements, or from a `std::string`.
-
-* The underlying memory is explicitly accessed using the `data()` member
-  function. In general an application should never need to do this, but it is
-  required by the library implementation to pass the raw memory to the
-  underlying operating system functions.
-
-Finally, multiple buffers can be passed to scatter-gather operations (such as
-[link asio.reference.read read()] or [link asio.reference.write write()]) by
-putting the buffer objects into a container. The `MutableBufferSequence` and
-`ConstBufferSequence` concepts have been defined so that containers such as
-`std::vector`, `std::list`, `std::array` or `boost::array` can be used.
-
-[heading Streambuf for Integration with Iostreams]
-
-The class `asio::basic_streambuf` is derived from `std::basic_streambuf` to
-associate the input sequence and output sequence with one or more objects of
-some character array type, whose elements store arbitrary values. These
-character array objects are internal to the streambuf object, but direct access
-to the array elements is provided to permit them to be used with I/O
-operations, such as the send or receive operations of a socket:
-
-* The input sequence of the streambuf is accessible via the [link
-  asio.reference.basic_streambuf.data data()] member function. The return type
-  of this function meets the `ConstBufferSequence` requirements.
-
-* The output sequence of the streambuf is accessible via the [link
-  asio.reference.basic_streambuf.prepare prepare()] member function. The return
-  type of this function meets the `MutableBufferSequence` requirements.
-
-* Data is transferred from the front of the output sequence to the back of the
-  input sequence by calling the [link asio.reference.basic_streambuf.commit
-  commit()] member function.
-
-* Data is removed from the front of the input sequence by calling the [link
-  asio.reference.basic_streambuf.consume consume()] member function.
-
-The streambuf constructor accepts a `size_t` argument specifying the maximum of
-the sum of the sizes of the input sequence and output sequence. Any operation
-that would, if successful, grow the internal data beyond this limit will throw
-a `std::length_error` exception.
-
-[heading Bytewise Traversal of Buffer Sequences]
-
-The `buffers_iterator<>` class template allows buffer sequences (i.e. types
-meeting `MutableBufferSequence` or `ConstBufferSequence` requirements) to be
-traversed as though they were a contiguous sequence of bytes. Helper functions
-called buffers_begin() and buffers_end() are also provided, where the
-buffers_iterator<> template parameter is automatically deduced.
-
-As an example, to read a single line from a socket and into a `std::string`,
-you may write:
-
-  asio::streambuf sb;
-  ...
-  std::size_t n = asio::read_until(sock, sb, '\n');
-  asio::streambuf::const_buffers_type bufs = sb.data();
-  std::string line(
-      asio::buffers_begin(bufs),
-      asio::buffers_begin(bufs) + n);
-
-[heading Buffer Literals]
-
-The `_buf` literal suffix, defined in namespace `asio::buffer_literals`, may be
-used to create `const_buffer` objects from string, binary integer, and
-hexadecimal integer literals. These buffer literals may be arbitrarily long.
-For example:
-
-[pre
-using namespace asio::buffer_literals;
-
-asio::const_buffer b1 = "hello"_buf;
-asio::const_buffer b2 = 0xdeadbeef_buf;
-asio::const_buffer b3 = 0x01234567'89abcdef'01234567'89abcdef_buf;
-asio::const_buffer b4 = 0b1010101011001100_buf;
-]
-
-The memory associated with a buffer literal is valid for the lifetime of the
-program. This means that the buffer can be safely used with asynchronous
-operations:
-
-  async_write(my_socket, "hello"_buf, my_handler);
-
-[heading Buffer Debugging]
-
-Some standard library implementations, such as the one that ships with
-Microsoft Visual C++ 8.0 and later, provide a feature called iterator
-debugging. What this means is that the validity of iterators is checked at
-runtime. If a program tries to use an iterator that has been invalidated, an
-assertion will be triggered. For example:
-
-  std::vector<int> v(1)
-  std::vector<int>::iterator i = v.begin();
-  v.clear(); // invalidates iterators
-  *i = 0; // assertion!
-
-Asio takes advantage of this feature to add buffer debugging. Consider the
-following code:
-
-  void dont_do_this()
-  {
-   std::string msg = "Hello, world!";
-   asio::async_write(sock, asio::buffer(msg), my_handler);
-  }
-
-When you call an asynchronous read or write you need to ensure that the buffers
-for the operation are valid until the completion handler is called. In the
-above example, the buffer is the `std::string` variable `msg`. This variable is
-on the stack, and so it goes out of scope before the asynchronous operation
-completes. If you're lucky then the application will crash, but random failures
-are more likely.
-
-When buffer debugging is enabled, Asio stores an iterator into the string until
-the asynchronous operation completes, and then dereferences it to check its
-validity. In the above example you would observe an assertion failure just
-before Asio tries to call the completion handler.
-
-This feature is automatically made available for Microsoft Visual Studio 8.0 or
-later and for GCC when `_GLIBCXX_DEBUG` is defined. There is a performance cost
-to this checking, so buffer debugging is only enabled in debug builds. For
-other compilers it may be enabled by defining `ASIO_ENABLE_BUFFER_DEBUGGING`.
-It can also be explicitly disabled by defining `ASIO_DISABLE_BUFFER_DEBUGGING`.
-
-[heading See Also]
-
-[link asio.reference.buffer buffer],
-[link asio.reference.buffers_begin buffers_begin],
-[link asio.reference.buffers_end buffers_end],
-[link asio.reference.buffers_iterator buffers_iterator],
-[link asio.reference.const_buffer const_buffer],
-[link asio.reference.const_buffers_1 const_buffers_1],
-[link asio.reference.mutable_buffer mutable_buffer],
-[link asio.reference.mutable_buffers_1 mutable_buffers_1],
-[link asio.reference.streambuf streambuf],
-[link asio.reference.ConstBufferSequence ConstBufferSequence],
-[link asio.reference.MutableBufferSequence MutableBufferSequence],
-[link asio.examples.cpp11_examples.buffers buffers example (c++11)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cancellation.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cancellation.qbk
deleted file mode 100644
index 65766b5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cancellation.qbk
+++ /dev/null
@@ -1,255 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:cancellation Per-Operation Cancellation]
-
-[note These type requirements and classes are the low level building blocks of
-cancellation. For most use cases, consider using a higher level abstraction,
-such as [link asio.reference.experimental__make_parallel_group
-experimental::make_parallel_group] or the [link
-asio.overview.composition.cpp20_coroutines.co_ordinating_parallel_coroutines
-logical operators] for `awaitable`.]
-
-I/O objects, such as sockets and timers, support object-wide cancellation of
-outstanding asynchronous operations via their `close` or `cancel` member
-functions. However, certain asynchronous operations also support individual,
-targeted cancellation. This per-operation cancellation is enabled by
-specifying that a completion handler has an [link
-asio.reference.associated_cancellation_slot associated cancellation slot]
-which satisfies the [link asio.reference.CancellationSlot CancellationSlot]
-type requirements. A cancellation slot is a lightweight channel used for
-delivering a cancellation request.
-
-Given a copy of a user-defined `Handler` object `h`, if an asynchronous
-operation supports cancellation it will obtain a cancellation slot using the
-`get_associated_cancellation_slot` function. For example:
-
-  asio::associated_cancellation_slot_t<Handler> s
-    = asio::get_associated_cancellation_slot(h);
-
-The associated cancellation slot must satisfy the CancellationSlot type
-requirements.
-
-By default, handlers use a default-constructed [link
-asio.reference.cancellation_slot `cancellation_slot`], which means that
-per-operation cancellation is disabled. The cancellation slot may be customised
-for a particular handler type by specifying a nested type
-`cancellation_slot_type` and member function `get_cancellation_slot()`:
-
-  class my_handler
-  {
-  public:
-    // Custom implementation of CancellationSlot type requirements.
-    typedef my_cancellation_slot cancellation_slot_type;
-
-    // Return a custom cancellation slot implementation.
-    cancellation_slot_type get_cancellation_slot() const noexcept
-    {
-      return my_cancellation_slot(...);
-    }
-
-    void operator()() { ... }
-  };
-
-In more complex cases, the `associated_cancellation_slot` template may be
-partially specialised directly:
-
-  namespace asio {
-
-    template <typename CancellationSlot>
-    struct associated_cancellation_slot<my_handler, CancellationSlot>
-    {
-      // Custom implementation of CancellationSlot type requirements.
-      typedef my_cancellation_slot type;
-
-      // Return a custom cancellation_slot implementation.
-      static type get(const my_handler&,
-          const CancellationSlot& a = CancellationSlot()) noexcept
-      {
-        return my_cancellation_slot(...);
-      }
-    };
-
-  } // namespace asio
-
-For convenience, a cancellation slot may be associated with a handler by using
-the [link asio.reference.bind_cancellation_slot `bind_cancellation_slot`]
-function. This is particularly useful when associating a cancellation slot with
-a lambda:
-
-  asio::async_read(my_socket, my_buffer,
-      asio::bind_cancellation_slot(
-        my_cancellation_slot,
-        [](asio::error_code e, std::size_t n)
-        {
-          ...
-        }
-      )
-    );
-
-Asio provides a ready-to-use cancellation slot in the form of [link
-asio.reference.cancellation_slot `cancellation_slot`] and its counterpart [link
-asio.reference.cancellation_signal `cancellation_signal`]. These two classes
-implement a one-to-one pairing of producer (signal) and consumer (slot)
-interfaces. The following example shows its use:
-
-  class session
-    : public std::enable_shared_from_this<proxy>
-  {
-    ...
-
-    void do_read()
-    {
-      auto self = shared_from_this();
-      socket_.async_read_some(
-          buffer(data_),
-          asio::bind_cancellation_slot(
-            cancel_signal_.slot(),
-            [self](std::error_code error, std::size_t n)
-            {
-              ...
-            }
-          )
-        );
-    }
-
-    ...
-
-    void request_cancel()
-    {
-      cancel_signal_.emit(asio::cancellation_type::total);
-    }
-
-    ...
-
-    asio::cancellation_signal cancel_signal_;
-  };
-
-A `cancellation_signal` contains a single slot, and consequently a cancellation
-signal/slot pair may be used with at most one operation at a time. However,
-the same slot may be reused for subsequent operations.
-
-To support cancellation, an asynchronous operation installs a cancellation
-handler into the slot by calling the slot's `assign` or `emplace` functions.
-This handler will be invoked when a cancellation signal is emitted. A slot
-holds exactly one handler at a time, and installing a new handler will overwrite
-any previously installed handler.
-
-When emitting a cancellation signal, the caller must specify a [link
-asio.reference.cancellation_type cancellation type]. This value is a bitmask
-that dictates what guarantees the cancellation target must make if
-successful cancellation occurs. The possible bit values are, from weakest
-to strongest guarantee, are:
-
-[table cancellation types
-  [
-    [Bit]
-    [Guarantee if cancellation is successful]
-    [Examples where this is the strongest supported guarantee]
-  ]
-  [
-    [`terminal`]
-    [
-      The operation had unspecified side effects, and it is only safe to close
-      or destroy the I/O object.
-    ]
-    [
-      A stateful implementation of a message framing protocol, where an
-      asynchronous operation sends or receives a complete message. If
-      cancellation occurs part-way through the message body, it is not possible
-      to report a sensible state to the completion handler.
-    ]
-  ]
-  [
-    [`partial`]
-    [
-      The operation had well-defined side effects, and the completion
-      handler for the operation indicates what these side effects were. 
-    ]
-    [
-      Composed operations such as `async_read` and `async_write`. If cancellation
-      occurs before all bytes are transferred, the completion handler is passed
-      the total bytes transferred so far. The caller may use this information
-      to start another operation to transfer the remaining bytes.
-    ]
-  ]
-  [
-    [`total`]
-    [
-      The operation had no side effects that are observable through the API.
-    ]
-    [
-      Low level system calls that transfer either zero or non-zero bytes.[br]
-      [br]
-      Wait-for-readiness operations that have no side effects, even when
-      successful.[br]
-      [br]
-      A fully buffered message framing protocol implementation, where partial
-      messages are stored so that they may be reused on the next operation.
-    ]
-  ]
-]
-
-For example, if application logic requires that an operation complete with
-all-or-nothing side effects, it should emit only the `total` cancellation type.
-If this type is unsupported by the target operation, no cancellation will
-occur.
-
-Furthermore, a stronger guarantee always satisfies the requirements of a weaker
-guarantee. The `partial` guarantee still satisfies the `terminal` guarantee.
-The `total` guarantee satisfies both `partial` and `total`. This means that
-when an operation supports a given cancellation type as its strongest
-guarantee, it should honour cancellation requests for any of the weaker
-guarantees.
-
-Cancellation requests should not be emitted during an asynchronous operation's
-initiating function. Cancellation requests that are emitted before an operation
-starts have no effect. Similarly, cancellation requests made after completion
-have no effect.
-
-When emitting a cancellation signal, the thread safety rules apply as if
-calling a member function on the target operation's I/O object. For
-non-composed operations, this means that it is safe to emit the cancellation
-signal from any thread provided there are no other concurrent calls to the I/O
-object, and no other concurrent cancellation signal requests. For composed
-operations, care must be taken to ensure the cancellation request does not
-occur concurrently with the operation's intermediate completion handlers.
-
-[heading Supported Operations]
-
-Consult the documentation for individual asynchronous operations for their
-supported cancellation types, if any. The ability to cancel individual
-operations, or composed operations, is currently supported by:
-
-* timers
-* sockets on POSIX and Windows
-* POSIX descriptors
-* Windows HANDLEs
-* signal sets
-* serial ports
-* SSL streams
-* all Asio-provided composed operations such as `async_read` and `async_write`
-* compositions based on `async_compose`
-* C++20 coroutines that use `awaitable`
-* C++20 coroutines that use `experimental::coro`
-* the `experimental::parallel_group` operation
-* the `experimental::promise` class
-
-[heading See Also]
-
-[link asio.reference.CancellationSlot CancellationSlot],
-[link asio.reference.associated_cancellation_slot associated_cancellation_slot],
-[link asio.reference.bind_cancellation_slot bind_cancellation_slot],
-[link asio.reference.cancellation_signal cancellation_signal],
-[link asio.reference.cancellation_slot cancellation_slot],
-[link asio.reference.cancellation_state cancellation_state],
-[link asio.reference.cancellation_type cancellation_type],
-[link asio.reference.get_associated_cancellation_slot get_associated_cancellation_slot],
-[link asio.reference.experimental__parallel_group experimental::parallel_group],
-[link asio.reference.experimental__make_parallel_group experimental::make_parallel_group]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/channels.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/channels.qbk
deleted file mode 100644
index 53253e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/channels.qbk
+++ /dev/null
@@ -1,56 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:channels Channels]
-
-[note This is an experimental feature.]
-
-The templates
-[link asio.reference.experimental__basic_channel experimental::basic_channel]
-and [link asio.reference.experimental__basic_concurrent_channel
-experimental::basic_concurrent_channel], with aliases `experimental::channel`
-and `experimental::concurrent_channel`, may be used to send messages between
-different parts of the same application. A ['message] is defined as a
-collection of arguments to be passed to a completion handler, and the set of
-messages supported by a channel is specified by its template parameters.
-Messages may be sent and received using asynchronous or non-blocking
-synchronous operations.
-
-For example:
-
-  // Create a channel with no buffer space.
-  channel<void(error_code, size_t)> ch(ctx);
-
-  // The call to try_send fails as there is no buffer
-  // space and no waiting receive operations.
-  bool ok = ch.try_send(asio::error::eof, 123);
-  assert(!ok);
-
-  // The async_send operation is outstanding until
-  // a receive operation consumes the message.
-  ch.async_send(asio::error::eof, 123,
-      [](error_code ec)
-      {
-        // ...
-      });
-
-  // The async_receive consumes the message. Both the
-  // async_send and async_receive operations complete
-  // immediately.
-  ch.async_receive(
-      [](error_code ec, size_t n)
-      {
-        // ...
-      });
-
-[heading See Also]
-
-[link asio.reference.experimental__basic_channel experimental::basic_channel],
-[link asio.reference.experimental__basic_concurrent_channel experimental::basic_concurrent_channel],
-[link asio.examples.cpp20_examples.channels Channels examples (C++20)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/compose.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/compose.qbk
deleted file mode 100644
index 28e0b21..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/compose.qbk
+++ /dev/null
@@ -1,101 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:compose Compositions as Asynchronous Operations]
-
-Application developers may wish to package their own compositions as conforming
-[link asio.overview.model.async_ops asynchronous operations] within the [link
-asio.overview.model asynchronous model]. Doing so facilitates seamless
-composition of these operations together with the operations already provided
-by Asio.
-
-While these operations may be written from scratch to conform with the [link
-asio.reference.asynchronous_operations requirements on asynchronous
-operations], Asio includes the [link asio.reference.async_compose
-`async_compose`] function to simplify this process. The `async_compose`
-implementation automatically provides an intermediate completion handler that
-correctly propagates the [link asio.overview.model.associators associated
-characteristics] and tracks outstanding work against the I/O executor and
-completion executor.
-
-The following example illustrates an asynchronous echo loop (i.e. read,
-followed by write, and so on), expressed as a simple state machine.
-
-  struct async_echo_implementation
-  {
-    tcp::socket& socket_;
-    asio::mutable_buffer buffer_;
-    enum { starting, reading, writing } state_;
-
-    template <typename Self>
-    void operator()(Self& self,
-        asio::error_code error = {},
-        std::size_t n = 0)
-    {
-      switch (state_)
-      {
-      case starting:
-        state_ = reading;
-        socket_.async_read_some(
-            buffer_, std::move(self));
-        break;
-      case reading:
-        if (error)
-        {
-          self.complete(error, 0);
-        }
-        else
-        {
-          state_ = writing;
-          asio::async_write(socket_, buffer_,
-              asio::transfer_exactly(n),
-              std::move(self));
-        }
-        break;
-      case writing:
-        self.complete(error, n);
-        break;
-      }
-    }
-  };
-
-This implementation is then used in an initiating function, which trivially
-wraps `async_compose`:
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      asio::mutable_buffer buffer,
-      CompletionToken&& token) ->
-    typename asio::async_result<
-      typename std::decay<CompletionToken>::type,
-        void(asio::error_code, std::size_t)>::return_type
-  {
-    return asio::async_compose<CompletionToken,
-      void(asio::error_code, std::size_t)>(
-        async_echo_implementation{socket, buffer,
-          async_echo_implementation::starting},
-        token, socket);
-  }
-
-Here, `async_compose` is first passed the function object that contains the
-implementation of the composed asynchronous operation. The first argument to
-the function object is a non-const reference to the enclosing intermediate
-completion handler. The remaining arguments are any arguments that originate
-from the completion handlers of any asynchronous operations performed by the
-implementation.
-
-The `async_compose` function is also passed the completion token, and zero or
-more I/O objects or I/O executors for which outstanding work must be
-maintained.
-
-[heading See Also]
-
-[link asio.reference.async_compose async_compose],
-[link asio.examples.cpp11_examples.operations Operations examples (C++11)],
-[link asio.examples.cpp14_examples.operations Operations examples (C++14)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/concurrency_hint.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/concurrency_hint.qbk
deleted file mode 100644
index 5a98fb3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/concurrency_hint.qbk
+++ /dev/null
@@ -1,93 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:concurrency_hint Concurrency Hints]
-
-The [link asio.reference.io_context.io_context `io_context` constructor]
-allows programs to specify a concurrency hint. This is a suggestion to the
-`io_context` implementation as to the number of active threads that should be
-used for running completion handlers.
-
-When the Windows I/O completion port backend is in use, this value is passed
-to [^CreateIoCompletionPort].
-
-When a reactor-based backend is used, the implementation recognises the
-following special concurrency hint values:
-
-[table
-  [[Value][Description]]
-  [
-    [`1`]
-    [
-      The implementation assumes that the `io_context` will be run from a
-      single thread, and applies several optimisations based on this
-      assumption.
-    
-      For example, when a handler is posted from within another handler, the
-      new handler is added to a fast thread-local queue (with the consequence
-      that the new handler is held back until the currently executing handler
-      finishes).
-
-      The `io_context` still provides full thread safety, and distinct I/O
-      objects may be used from any thread.
-    ]
-  ]
-  [
-    [`ASIO_CONCURRENCY_HINT_UNSAFE`]
-    [
-      This special concurrency hint disables locking in both the scheduler and
-      reactor I/O. This hint has the following restrictions:
-
-      [mdash] Care must be taken to ensure that all operations on the
-      `io_context` and any of its associated I/O objects (such as sockets and
-      timers) occur in only one thread at a time.
-
-      [mdash] Asynchronous resolve operations fail with `operation_not_supported`.
-
-      [mdash] If a `signal_set` is used with the `io_context`, `signal_set`
-      objects cannot be used with any other io_context in the program.
-    ]
-  ]
-  [
-    [`ASIO_CONCURRENCY_HINT_UNSAFE_IO`]
-    [
-      This special concurrency hint disables locking in the reactor I/O. This
-      hint has the following restrictions:
-
-      [mdash] Care must be taken to ensure that the ['run functions] on the
-      `io_context` (i.e. `run`, `run_for`, `run_until`, `run_one`,
-      `run_one_for`, `run_one_until`, `poll`, and `poll_one`), and all
-      operations on the context's associated I/O objects (such as sockets and
-      timers), occur in only one thread at a time.
-    ]
-  ]
-  [
-    [`ASIO_CONCURRENCY_HINT_SAFE`]
-    [
-      The default. The `io_context` provides full thread safety, and distinct
-      I/O objects may be used from any thread.
-    ]
-  ]
-]
-
-[teletype]
-The concurrency hint used by default-constructed `io_context` objects can be
-overridden at compile time by defining the `ASIO_CONCURRENCY_HINT_DEFAULT`
-macro. For example, specifying
-
-  -DASIO_CONCURRENCY_HINT_DEFAULT=1
-
-on the compiler command line means that a concurrency hint of `1` is used for
-all default-constructed `io_context` objects in the program. Similarly, the
-concurrency hint used by `io_context` objects constructed with `1` can be
-overridden by defining `ASIO_CONCURRENCY_HINT_1`. For example, passing
-
-  -DASIO_CONCURRENCY_HINT_1=ASIO_CONCURRENCY_HINT_UNSAFE
-  
-to the compiler will disable thread safety for all of these objects.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coro.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coro.qbk
deleted file mode 100644
index cdcaea3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coro.qbk
+++ /dev/null
@@ -1,260 +0,0 @@
-[/
- / Copyright (c) 2021-2023 Klemens D. Morgenstern
- /                         (klemens dot morgenstern at gmx dot net)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:coro Resumable C++ 20 Coroutines]
-
-[note This is an experimental feature.]
-
-The [link asio.reference.experimental__coro `experimental::coro`] class provides
-support for a universal C++20 coroutine. These coroutines can be used as tasks,
-generators and transfomers, depending on their signature.
-
-  coro<std::string_view> line_reader(tcp::socket stream)
-  {
-     while (stream.is_open())
-     {
-       std::array<char, 4096> buf;
-
-       auto read = co_await stream.async_read_some(
-           asio::buffer(buf), deferred);
-
-       if (read == 0u)
-         continue;
-
-       co_yield std::string_view { buf.data(), read };
-     }
-  }
-
-  coro<void, std::size_t> line_logger(tcp::socket stream)
-  {
-    std::size_t lines_read = 0u;
-    auto reader = line_reader(std::move(stream));
-    while (auto l = co_await reader)
-    {
-      std::cout << "Read: '" << *l << "'" << std::endl;
-      lines_read++;
-    }
-    co_return lines_read;
-  }
-
-  void read_lines(tcp::socket sock)
-  {
-    co_spawn(line_logger(std::move(sock),
-        [](std::exception_ptr, std::size_t lines)
-        {
-          std::clog << "Read " << lines << " lines" << std::endl;
-        }));
-  }
-
-A [link asio.reference.experimental__coro `coro`] is highly configurable, so
-that it can cover a set of different use cases.
-
-  template<
-      typename Yield,
-      typename Return = void,
-      typename Executor = any_io_executor>
-  struct coro;
-
-[heading Yield]
-
-The `Yield` parameter designates how a `co_yield` statement behaves. It can
-either be a type, like `int` or a signature with zero or one types:
-
-  coro<void> // A coroutine with no yield
-  coro<int> // A coroutine that can yield int
-
-  coro<void()> // A coroutine with no yield
-  coro<int()> // A coroutine that can yield int
-
-  coro<int(double)> // A coroutine that can yield int and receive double
-
-Receiving a value means that the `co_yield` statement returns a value.
-
-  coro<int(int)> my_sum(any_io_executor)
-  {
-    int value = 0;
-    while (true)
-      value += co_yield value; //sum up all values
-  }
-
-
-Putting values into a coroutine can be done it two ways: either by direct
-resumption (from another coro) or through async_resume. The first value gets
-ignored because the coroutines are lazy.
-
-  coro<void> c(any_io_executor exec)
-  {
-    auto sum = my_sum(exec);
-    assert(0  == co_await sum(-1));
-    assert(0  == co_await sum(10));
-    assert(10 == co_await sum(15));
-    assert(25 == co_await sum(0));
-  }
-
-  awaitable<void> a()
-  {
-    auto sum = my_sum(co_await this_coro::executor);
-    assert(0  == co_await sum.async_resume(-1, use_awaitable));
-    assert(0  == co_await sum.async_resume(10, use_awaitable));
-    assert(10 == co_await sum.async_resume(15, use_awaitable));
-    assert(25 == co_await sum.async_resume(0, use_awaitable));
-  }
-
-[heading `noexcept`]
-
-A coro may be noexcept:
-
-  coro<void() noexcept> c;
-  coro<int() noexcept> c;
-  coro<int(double) noexcept> c;
-
-This will change its @c async_resume signature, from `void(std::exception_ptr)`
-to `void()` or `void(std::exception_ptr, T)` to `void(T)`. A noexcept coro that
-ends with an exception will cause `std::terminate` to be called.
-
-Furthermore, calls of `async_resume` and `co_await` of an expired noexcept coro
-will cause undefined behaviour.
-
-[heading Return]
-
-A coro can also define a type that can be used with `co_return`:
-
-  coro<void() noexcept, int> c(any_io_executor)
-  {
-    co_return 42;
-  }
-
-A coro can have both a `Yield` and `Return` that are non void at the same time.
-
-[heading Result]
-
-The result type of a coroutine is dermined by both `Yield` and `Return`. Note
-that in the follwing table only the yield output value is considered, i.e.
-`T(U)` means `T`.
-
-[table:result_type Result type deduction
-    [[Yield] [Return] [`noexcept`] [`result_type`] [`completion_signature`]]
-    [[`T`] [`U`] [`false`] [`variant<T, U>`] [`void(std::exception_ptr, variant<T, U>)`]]
-    [[`T`] [`U`] [`true`]  [`variant<T, U>`] [`void(variant<T, U>)`]]
-    [[`T`] [`void`] [`false`] [`optional<T>`] [`void(std::exception_ptr, optional<T>)`]]
-    [[`T`] [`void`] [`true`]  [`optional<T>`] [`void(optional<T>)`]]
-    [[`void`] [`void`] [`false`] [`optional<T>`] [`void(std::exception_ptr)`]]
-    [[`void`] [`void`] [`true`]  [`optional<T>`] [`void()`]]
-    [[`void`] [`T`] [`false`] [`optional<T>`] [`void(std::exception_ptr, T)`]]
-    [[`void`] [`T`] [`true`]  [`optional<T>`] [`void(T)`]]
-]
-
-[heading Executor]
-
-Every coroutine needs to have its own executor. Since the coroutine gets called
-multiple times, it cannot take the executor from the caller like an
-`awaitable`. Therefore a `coro` requires to get an executor or an
-execution_context passed in as the first parameter.
-
-  coro<int> with_executor(any_io_executor);
-  coro<int> with_context(io_context &);
-
-It is to note, that an execution_context is defined as loosely as possible. An
-execution context is any object that has a `get_executor()` function, which
-returns an executor that can be transformed into the executor_type of the
-coroutine. This allows most io_objects to be used as the source of the
-executor:
-
-  coro<int> with_socket(tcp::socket);
-
-Additionally, a `coro` that is a member function will check the `this` pointer
-as well, either if it's an executor or an execution context:
-
-  struct my_io_object
-  {
-    any_io_executor get_executor();
-
-    coro<int> my_coro();
-  };
-
-Finally, a member coro can be given an explicit executor or execution
-context, to override the one of the object:
-
-  struct my_io_object
-  {
-    any_io_executor get_executor();
-
-    coro<int> my_coro(any_io_executor exec); // it will use exec
-  };
-
-[heading `co_await`]
-
-The @c co_await within a `coro` is not the same as `async_resume(deferred)`,
-unless both coros use different executors. If they use the same, the `coro`
-will direclty suspend and resume the executor, without any usage of the
-executor.
-
-`co_await this_coro::` behaves the same as coroutines that use
-@c asio::awaitable.
-
-[heading Integrating with awaitable]
-
-As the `coro` member function `async_resume` is an asynchronous operation, it
-may also be used in conjunction with `awaitable` coroutines in a single control
-flow. For example:
-
-  #include <asio.hpp>
-  #include <asio/experimental/coro.hpp>
-
-  using asio::ip::tcp;
-
-  asio::experimental::coro<std::string> reader(tcp::socket& sock)
-  {
-    std::string buf;
-    while (sock.is_open())
-    {
-      std::size_t n = co_await asio::async_read_until(
-          sock, asio::dynamic_buffer(buf), '\n',
-          asio::deferred);
-      co_yield buf.substr(0, n);
-      buf.erase(0, n);
-    }
-  }
-
-  asio::awaitable<void> consumer(tcp::socket sock)
-  {
-    auto r = reader(sock);
-    auto msg1 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 1: " << msg1.value_or("\n");
-    auto msg2 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 2: " << msg2.value_or("\n");
-  }
-
-  asio::awaitable<void> listen(tcp::acceptor& acceptor)
-  {
-    for (;;)
-    {
-      co_spawn(
-          acceptor.get_executor(),
-          consumer(co_await acceptor.async_accept(asio::use_awaitable)),
-          asio::detached);
-    }
-  }
-
-  int main()
-  {
-    asio::io_context ctx;
-    tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
-    co_spawn(ctx, listen(acceptor), asio::detached);
-    ctx.run();
-  }
-
-[heading See Also]
-
-[link asio.reference.co_spawn co_spawn],
-[link asio.reference.experimental__coro experimental::coro],
-[link asio.overview.composition.cpp20_coroutines C++20 Coroutines],
-[link asio.overview.composition.spawn Stackful Coroutines],
-[link asio.overview.composition.coroutine Stackless Coroutines].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coroutine.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coroutine.qbk
deleted file mode 100644
index ae4df48..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/coroutine.qbk
+++ /dev/null
@@ -1,51 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:coroutine Stackless Coroutines]
-
-The [link asio.reference.coroutine `coroutine`] class provides support for
-stackless coroutines. Stackless coroutines enable programs to implement
-asynchronous logic in a synchronous manner, with minimal overhead, as shown in
-the following example:
-
-  struct session : asio::coroutine
-  {
-    boost::shared_ptr<tcp::socket> socket_;
-    boost::shared_ptr<std::vector<char> > buffer_;
-
-    session(boost::shared_ptr<tcp::socket> socket)
-      : socket_(socket),
-        buffer_(new std::vector<char>(1024))
-    {
-    }
-
-    void operator()(asio::error_code ec = asio::error_code(), std::size_t n = 0)
-    {
-      if (!ec) reenter (this)
-      {
-        for (;;)
-        {
-          yield socket_->async_read_some(asio::buffer(*buffer_), *this);
-          yield asio::async_write(*socket_, asio::buffer(*buffer_, n), *this);
-        }
-      }
-    }
-  };
-
-The `coroutine` class is used in conjunction with the pseudo-keywords
-`reenter`, `yield` and `fork`. These are preprocessor macros, and are
-implemented in terms of a `switch` statement using a technique similar to
-Duff's Device. The [link asio.reference.coroutine `coroutine`] class's
-documentation provides a complete description of these pseudo-keywords.
-
-[heading See Also]
-
-[link asio.reference.coroutine coroutine],
-[link asio.examples.cpp11_examples.http_server_4 HTTP Server 4 example],
-[link asio.overview.composition.spawn Stackful Coroutines].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp2011.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp2011.qbk
deleted file mode 100644
index 68a37b5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp2011.qbk
+++ /dev/null
@@ -1,236 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:cpp2011 C++ 2011 Support]
-
-[/boostify: non-boost docs start here]
-
-[link asio.overview.cpp2011.system_error System Errors and Error Codes]
-
-[/boostify: non-boost docs end here]
-
-[link asio.overview.cpp2011.move_objects Movable I/O Objects]
-
-[link asio.overview.cpp2011.move_handlers Movable Handlers]
-
-[link asio.overview.cpp2011.variadic Variadic Templates]
-
-[link asio.overview.cpp2011.array Array Container]
-
-[link asio.overview.cpp2011.atomic Atomics]
-
-[link asio.overview.cpp2011.shared_ptr Shared Pointers]
-
-[link asio.overview.cpp2011.chrono Chrono]
-
-[/boostify: non-boost docs start here]
-
-[section:system_error System Errors and Error Codes]
-
-When available, Asio can use the `std::error_code` and `std::system_error`
-classes for reporting errors. In this case, the names `asio::error_code` and
-`asio::system_error` will be typedefs for these standard classes.
-
-System error support is automatically enabled for [^g++] 4.6 and later, when
-the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be
-disabled by defining `ASIO_DISABLE_STD_SYSTEM_ERROR`, or explicitly enabled for
-other compilers by defining `ASIO_HAS_STD_SYSTEM_ERROR`.
-
-[endsect]
-
-[/boostify: non-boost docs end here]
-
-[section:move_objects Movable I/O Objects]
-
-When move support is available (via rvalue references), Asio allows move
-construction and assignment of sockets, serial ports, POSIX descriptors and
-Windows handles.
-
-Move support allows you to write code like:
-
-  tcp::socket make_socket(io_context& i)
-  {
-    tcp::socket s(i);
-    ...
-    std::move(s);
-  }
-
-or:
-
-  class connection : public enable_shared_from_this<connection>
-  {
-  private:
-    tcp::socket socket_;
-    ...
-  public:
-    connection(tcp::socket&& s) : socket_(std::move(s)) {}
-    ...
-  };
-
-  ...
-
-  class server
-  {
-  private:
-    tcp::acceptor acceptor_;
-    ...
-    void handle_accept(error_code ec, tcp::socket socket)
-    {
-      if (!ec)
-        std::make_shared<connection>(std::move(socket))->go();
-      acceptor_.async_accept(...);
-    }
-    ...
-  };
-
-as well as:
-
-  std::vector<tcp::socket> sockets;
-  sockets.push_back(tcp::socket(...));
-
-A word of warning: There is nothing stopping you from moving these objects
-while there are pending asynchronous operations, but it is unlikely to be a
-good idea to do so. In particular, composed operations like [link
-asio.reference.async_read async_read()] store a reference to the stream object.
-Moving during the composed operation means that the composed operation may
-attempt to access a moved-from object.
-
-Move support is automatically enabled for [^g++] 4.5 and later, when the
-[^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be disabled
-by defining `ASIO_DISABLE_MOVE`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_MOVE`. Note that these macros also affect the availability
-of [link asio.overview.cpp2011.move_handlers movable handlers].
-
-[endsect]
-
-[section:move_handlers Movable Handlers]
-
-With C++11 and later, user-defined completion handlers are only required to be
-move constructible, and are not required to be copy constructible.
-
-When move support is enabled, asynchronous that are documented as follows:
-
-  template <typename Handler>
-  void async_XYZ(..., Handler handler);
-
-are actually declared as:
-
-  template <typename Handler>
-  void async_XYZ(..., Handler&& handler);
-
-The handler argument is perfectly forwarded and the move construction occurs
-within the body of `async_XYZ()`. This ensures that all other function
-arguments are evaluated prior to the move. This is critical when the other
-arguments to `async_XYZ()` are members of the handler. For example:
-
-  struct my_operation
-  {
-    unique_ptr<tcp::socket> socket;
-    unique_ptr<vector<char>> buffer;
-    ...
-    void operator(error_code ec, size_t length)
-    {
-      ...
-      socket->async_read_some(asio::buffer(*buffer), std::move(*this));
-      ...
-    }
-  };
-
-Move support is automatically enabled for [^g++] 4.5 and later, when the
-[^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be disabled
-by defining `ASIO_DISABLE_MOVE`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_MOVE`. Note that these macros also affect the availability
-of [link asio.overview.cpp2011.move_objects movable I/O objects].
-
-[endsect]
-
-[section:variadic Variadic Templates]
-
-When supported by a compiler, Asio can use variadic templates to implement the
-[link asio.reference.basic_socket_streambuf.connect
-basic_socket_streambuf::connect()] and [link
-asio.reference.basic_socket_iostream.connect basic_socket_iostream::connect()]
-functions.
-
-Support for variadic templates is automatically enabled for [^g++] 4.3 and
-later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It
-may be disabled by defining `ASIO_DISABLE_VARIADIC_TEMPLATES`, or explicitly
-enabled for other compilers by defining `ASIO_HAS_VARIADIC_TEMPLATES`.
-
-[endsect]
-
-[section:array Array Container]
-
-Where the standard library provides `std::array<>`, Asio:
-
-* Provides overloads for the [link asio.reference.buffer buffer()] function.
-
-* Uses it in preference to `boost::array<>` for the
-  [link asio.reference.ip__address_v4.bytes_type ip::address_v4::bytes_type] and
-  [link asio.reference.ip__address_v6.bytes_type ip::address_v6::bytes_type]
-  types.
-
-* Uses it in preference to `boost::array<>` where a fixed size array type is
-  needed in the implementation.
-
-Support for `std::array<>` is automatically enabled for [^g++] 4.3 and later,
-when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used, as well as
-for Microsoft Visual C++ 10. It may be disabled by defining
-`ASIO_DISABLE_STD_ARRAY`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_ARRAY`.
-
-[endsect]
-
-[section:atomic Atomics]
-
-Asio's implementation can use `std::atomic<>` in preference to
-`boost::detail::atomic_count`.
-
-Support for the standard atomic integer template is automatically enabled for
-[^g++] 4.5 and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler
-options are used. It may be disabled by defining `ASIO_DISABLE_STD_ATOMIC`, or
-explicitly enabled for other compilers by defining `ASIO_HAS_STD_ATOMIC`.
-
-[endsect]
-
-[section:shared_ptr Shared Pointers]
-
-Asio's implementation can use `std::shared_ptr<>` and `std::weak_ptr<>` in
-preference to the Boost equivalents.
-
-Support for the standard smart pointers is automatically enabled for [^g++] 4.3
-and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used,
-as well as for Microsoft Visual C++ 10. It may be disabled by defining
-`ASIO_DISABLE_STD_SHARED_PTR`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_SHARED_PTR`.
-
-[endsect]
-
-[section:chrono Chrono]
-
-Asio provides timers based on the `std::chrono` facilities via the [link
-asio.reference.basic_waitable_timer basic_waitable_timer] class template.
-The typedefs [link asio.reference.system_timer system_timer], [link
-asio.reference.steady_timer steady_timer] and [link
-asio.reference.high_resolution_timer high_resolution_timer] utilise the
-standard clocks `system_clock`, `steady_clock` and `high_resolution_clock`
-respectively.
-
-Support for the `std::chrono` facilities is automatically enabled for [^g++]
-4.6 and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are
-used. (Note that, for [^g++], the draft-standard `monotonic_clock` is used in
-place of `steady_clock`.) Support may be disabled by defining
-`ASIO_DISABLE_STD_CHRONO`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_CHRONO`.
-
-When standard `chrono` is unavailable, Asio will otherwise use the Boost.Chrono
-library. The [link asio.reference.basic_waitable_timer basic_waitable_timer]
-class template may be used with either.
-
-[endsect]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp20_coroutines.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp20_coroutines.qbk
deleted file mode 100644
index bfa10be..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/cpp20_coroutines.qbk
+++ /dev/null
@@ -1,280 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:cpp20_coroutines C++20 Coroutines Support]
-
-Support for C++20 Coroutines is provided via the [link asio.reference.awaitable
-`awaitable`] class template, the [link asio.reference.use_awaitable_t
-`use_awaitable`] completion token, and the [link asio.reference.co_spawn
-`co_spawn()`] function. These facilities allow programs to implement
-asynchronous logic in a synchronous manner, in conjunction with the `co_await`
-keyword, as shown in the following example:
-
-  asio::co_spawn(executor, echo(std::move(socket)), asio::detached);
-
-  // ...
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(asio::buffer(data), asio::use_awaitable);
-        co_await async_write(socket, asio::buffer(data, n), asio::use_awaitable);
-      }
-    }
-    catch (std::exception& e)
-    {
-      std::printf("echo Exception: %s\n", e.what());
-    }
-  }
-
-The first argument to `co_spawn()` is an [link asio.reference.Executor1
-executor] that determines the context in which the coroutine is permitted to
-execute. For example, a server's per-client object may consist of multiple
-coroutines; they should all run on the same `strand` so that no explicit
-synchronisation is required.
-
-The second argument is an [link asio.reference.awaitable `awaitable<R>`],
-that is the result of the coroutine's entry point function, and in the above
-example is the result of the call to `echo`. (Alternatively, this argument can
-be a function object that returns the [link asio.reference.awaitable
-`awaitable<R>`].) The template parameter `R` is the type of return value
-produced by the coroutine. In the above example, the coroutine returns `void`.
-
-The third argument is a completion token, and this is used by `co_spawn()` to
-produce a completion handler with signature `void(std::exception_ptr, R)`. This
-completion handler is invoked with the result of the coroutine once it has
-finished. In the above example we pass a completion token type, [link
-asio.reference.detached `asio::detached`], which is used to explicitly ignore
-the result of an asynchronous operation.
-
-In this example the body of the coroutine is implemented in the `echo`
-function. When the `use_awaitable` completion token is passed to an
-asynchronous operation, the operation's initiating function returns an
-`awaitable` that may be used with the `co_await` keyword:
-
-  std::size_t n = co_await socket.async_read_some(asio::buffer(data), asio::use_awaitable);
-
-Where an asynchronous operation's handler signature has the form:
-
-  void handler(asio::error_code ec, result_type result);
-
-the resulting type of the `co_await` expression is `result_type`. In the
-`async_read_some` example above, this is `size_t`. If the asynchronous
-operation fails, the `error_code` is converted into a `system_error` exception
-and thrown.
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec);
-
-the `co_await` expression produces a `void` result. As above, an error is
-passed back to the coroutine as a `system_error` exception.
-
-[heading Error Handling]
-
-To perform explicit error handling, rather than the default exception-throwing
-behaviour, use the [link asio.reference.as_tuple `as_tuple`] or
-[link asio.reference.redirect_error `redirect_error`] completion token adapters.
-
-The `as_tuple` completion token adapter packages the completion
-handler arguments into a single tuple, which is then returned as the result of
-the awaited operation. For example:
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::tuple<asio::error_code, std::size_t> result =
-        co_await socket.async_read_some(asio::buffer(data),
-          asio::as_tuple(asio::use_awaitable));
-      if (!std::get<0>(result))
-      {
-        // success
-      }
-
-      // ...
-    }
-  }
-
-The result can also be captured directly into a structured binding:
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    char data[1024];
-    for (;;)
-    {
-      auto [ec, n] = co_await socket.async_read_some(
-          asio::buffer(data), asio::as_tuple(asio::use_awaitable));
-      if (!ec)
-      {
-        // success
-      }
-
-      // ...
-    }
-  }
-
-Alternatively, the `redirect_error` completion token adapter may be used to
-capture the error into a supplied `error_code` variable:
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    char data[1024];
-    for (;;)
-    {
-      asio::error_code ec;
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data),
-          asio::redirect_error(asio::use_awaitable, ec));
-      if (!ec)
-      {
-        // success
-      }
-
-      // ...
-    }
-  }
-
-[heading Coroutines and Per-Operation Cancellation]
-
-All threads of execution created by `co_spawn` have a cancellation state that
-records the current state of any cancellation requests made to the coroutine.
-To access this state, use [link asio.reference.this_coro__cancellation_state
-`this_coro::cancellation_state`] as follows:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    asio::cancellation_state cs
-      = co_await asio::this_coro::cancellation_state;
-
-    // ...
-
-    if (cs.cancelled() != asio::cancellation_type::none)
-      // ...
-  }
-
-When first created by `co_spawn`, the thread of execution has a cancellation
-state that supports `cancellation_type::terminal` values only. To change the
-cancellation state, call [link
-asio.reference.this_coro__reset_cancellation_state
-`this_coro::reset_cancellation_state`].
-
-By default, continued execution of a cancelled coroutine will trigger an
-exception from any subsequent `co_await` of an `awaitable<>` object. This
-behaviour can be changed by using [link
-asio.reference.this_coro__throw_if_cancelled `this_coro::throw_if_cancelled`].
-
-[heading Co-ordinating Parallel Coroutines]
-
-[note This is an experimental feature.]
-
-The logical operators `||` and `&&` have been overloaded for `awaitable<>`, to
-allow coroutines to be trivially awaited in parallel.
-
-When awaited using `&&`, the `co_await` expression waits until both operations
-have completed successfully. As a "short-circuit" evaluation, if one
-operation fails with an exception, the other is immediately cancelled.
-For example:
-
-  std::tuple<std::size_t, std::size_t> results =
-    co_await (
-      async_read(socket, input_buffer, use_awaitable)
-        && async_write(socket, output_buffer, use_awaitable)
-    );
-
-Following completion of a `&&` operation, the results of all operations are
-concatenated into a tuple. In the above example, the first `size_t` represents
-the non-exceptional component of the `async_read` result, and the second
-`size_t` is the result of the `async_write`.
-
-When awaited using `||`, the `co_await` expression waits until either
-operation succeeds. As a "short-circuit" evaluation, if one operation
-succeeds without throwing an exception, the other is immediately cancelled.
-For example:
-
-  std::variant<std::size_t, std::monostate> results =
-    co_await (
-      async_read(socket, input_buffer, use_awaitable)
-        || timer.async_wait(use_awaitable)
-    );
-
-Following completion of a `||` operation, the result of the first operation to
-complete non-exceptionally is placed into a `std::variant`. The active index
-of the variant reflects which of the operations completed first.
-In the above example, index `0` corresponds to the `async_read` operation.
-
-These operators may be enabled by adding the `#include`:
-
-  #include <asio/experimental/awaitable_operators.hpp>
-
-and then bringing the contents of the `experimental::awaitable_operators`
-namespace into scope:
-
-  using namespace asio::experimental::awaitable_operators;
-
-[heading Lightweight Coroutines Implementing Asynchonous Operations]
-
-The `co_composed` template facilitates a lightweight implementation of
-user-defined asynchronous operations using C++20 coroutines. The following
-example illustrates a simple asynchronous operation that implements an echo
-protocol in terms of a coroutine:
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(asio::error_code)>(
-        asio::co_composed<
-          void(asio::error_code)>(
-            [](auto state, tcp::socket& socket) -> void
-            {
-              try
-              {
-                state.throw_if_cancelled(true);
-                state.reset_cancellation_state(
-                  asio::enable_terminal_cancellation());
-
-                for (;;)
-                {
-                  char data[1024];
-                  std::size_t n = co_await socket.async_read_some(
-                      asio::buffer(data), asio::deferred);
-
-                  co_await asio::async_write(socket,
-                      asio::buffer(data, n), asio::deferred);
-                }
-              }
-              catch (const asio::system_error& e)
-              {
-                co_return {e.code()};
-              }
-            }, socket),
-        token, std::ref(socket));
-  }
-
-[heading See Also]
-
-[link asio.reference.co_spawn co_spawn],
-[link asio.reference.detached detached],
-[link asio.reference.as_tuple as_tuple],
-[link asio.reference.redirect_error redirect_error],
-[link asio.reference.awaitable awaitable],
-[link asio.reference.use_awaitable_t use_awaitable_t],
-[link asio.reference.use_awaitable use_awaitable],
-[link asio.reference.this_coro__executor this_coro::executor],
-[link asio.reference.co_composed co_composed],
-[link asio.examples.cpp17_examples.coroutines_ts_support Coroutines examples],
-[link asio.overview.composition.coro Resumable C++20 Coroutines],
-[link asio.overview.composition.spawn Stackful Coroutines],
-[link asio.overview.composition.coroutine Stackless Coroutines].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/deferred.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/deferred.qbk
deleted file mode 100644
index 04afc8b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/deferred.qbk
+++ /dev/null
@@ -1,54 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:deferred Deferred Operations]
-
-The [link asio.reference.deferred `deferred`], completion token takes a call to
-an asynchronous operation's initiating function and turns it into a function
-object that accepts a completion token. For example:
-
-  auto deferred_op =
-    timer.async_wait(
-      asio::deferred);
-  ...
-  std::move(deferred_op)(
-      [](asio::error_code ec){ ... });
-
-or:
-
-  auto deferred_op =
-    timer.async_wait(
-      asio::deferred);
-  ...
-  std::future<void> =
-    std::move(deferred_op)(
-      asio::use_future);
-
-The deferred token also supports chaining, to create simple compositions:
-
-  auto deferred_op =
-    timer.async_wait(
-      asio::deferred(
-        [&](asio::error_code ec)
-        {
-          timer.expires_after(
-              std::chrono::seconds(1));
-
-          return timer.async_wait(
-              asio::deferred);
-        });
-  ...
-  std::future<void> = std::move(deferred_op)(asio::use_future);
-
-[heading See Also]
-
-[link asio.reference.deferred deferred],
-[link asio.reference.deferred_t deferred_t],
-[link asio.examples.cpp14_examples.deferred Deferred examples (C++11)],
-[link asio.examples.cpp14_examples.deferred Deferred examples (C++14)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/files.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/files.qbk
deleted file mode 100644
index cbd3b37..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/files.qbk
+++ /dev/null
@@ -1,49 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:files Files]
-
-[note This feature requires I/O completion ports on Windows, and io_uring on
-Linux (define `ASIO_HAS_IO_URING` to enable).]
-
-Asio provides support for manipulating stream-oriented and random-access files.
-For example, to write to a newly created stream-oriented file:
-
-  asio::stream_file file(
-      my_io_context, "/path/to/file",
-      asio::stream_file::write_only
-        | asio::stream_file::create
-        | asio::stream_file::truncate);
-
-  file.async_write_some(my_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-
-or to read from a random-access file:
-
-  asio::random_access_file file(
-      my_io_context, "/path/to/file",
-      asio::random_access_file::read_only);
-
-  file.async_read_some_at(1234, my_buffer,
-      [](error_code e, size_t n)
-      {
-        // ...
-      });
-
-[heading See Also]
-
-[link asio.reference.basic_file basic_file],
-[link asio.reference.basic_random_access_file basic_random_access_file],
-[link asio.reference.basic_stream_file basic_stream_file],
-[link asio.reference.file_base file_base],
-[link asio.reference.random_access_file random_access_file],
-[link asio.reference.stream_file stream_file].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/futures.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/futures.qbk
deleted file mode 100644
index 5bb9e37..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/futures.qbk
+++ /dev/null
@@ -1,41 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:futures Futures]
-
-The `asio::use_future` completion token provides first-class support for
-returning a `std::future` from an asynchronous operation's initiating function.
-
-To use `asio::use_future`, pass it to an asynchronous operation instead of
-a completion handler. For example:
-
-  std::future<std::size_t> length =
-    my_socket.async_read_some(my_buffer, asio::use_future);
-
-Where a completion signature has the form:
-
-  void handler(asio::error_code ec, result_type result);
-
-the initiating function returns a `std::future` templated on `result_type`.
-In the above example, this is `std::size_t`. If the asynchronous operation
-fails, the `error_code` is converted into a `system_error` exception and
-passed back to the caller through the future.
-
-Where a completion signature has the form:
-
-  void handler(asio::error_code ec);
-
-the initiating function returns `std::future<void>`. As above, an error
-is passed back in the future as a `system_error` exception.
-
-[heading See Also]
-
-[link asio.reference.use_future use_future],
-[link asio.reference.use_future_t use_future_t],
-[link asio.examples.cpp11_examples.futures Futures example (C++11)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/handler_tracking.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/handler_tracking.qbk
deleted file mode 100644
index eb55f3a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/handler_tracking.qbk
+++ /dev/null
@@ -1,281 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:handler_tracking Handler Tracking]
-
-To aid in debugging asynchronous programs, Asio provides support for handler
-tracking. When enabled by defining `ASIO_ENABLE_HANDLER_TRACKING`, Asio
-writes debugging output to the standard error stream. The output records
-asynchronous operations and the relationships between their handlers.
-
-[teletype]
-This feature is useful when debugging and you need to know how your
-asynchronous operations are chained together, or what the pending asynchronous
-operations are. As an illustration, here is the output when you run the HTTP
-Server example, handle a single request, then shut down via Ctrl+C:
-
-  @asio|1589424178.741850|0*1|signal_set@0x7ffee977d878.async_wait
-  @asio|1589424178.742593|0*2|socket@0x7ffee977d8a8.async_accept
-  @asio|1589424178.742619|.2|non_blocking_accept,ec=asio.system:11
-  @asio|1589424178.742625|0|resolver@0x7ffee977d760.cancel
-  @asio|1589424195.830382|.2|non_blocking_accept,ec=system:0
-  @asio|1589424195.830413|>2|ec=system:0
-  @asio|1589424195.830473|2*3|socket@0x7fa71d808230.async_receive
-  @asio|1589424195.830496|.3|non_blocking_recv,ec=system:0,bytes_transferred=151
-  @asio|1589424195.830503|2*4|socket@0x7ffee977d8a8.async_accept
-  @asio|1589424195.830507|.4|non_blocking_accept,ec=asio.system:11
-  @asio|1589424195.830510|<2|
-  @asio|1589424195.830529|>3|ec=system:0,bytes_transferred=151
-  @asio|1589424195.831143|3^5|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
-  @asio|1589424195.831143|3*5|socket@0x7fa71d808230.async_send
-  @asio|1589424195.831186|.5|non_blocking_send,ec=system:0,bytes_transferred=1090
-  @asio|1589424195.831194|<3|
-  @asio|1589424195.831218|>5|ec=system:0,bytes_transferred=1090
-  @asio|1589424195.831263|5|socket@0x7fa71d808230.close
-  @asio|1589424195.831298|<5|
-  @asio|1589424199.793770|>1|ec=system:0,signal_number=2
-  @asio|1589424199.793781|1|socket@0x7ffee977d8a8.close
-  @asio|1589424199.793809|<1|
-  @asio|1589424199.793840|>4|ec=asio.system:125
-  @asio|1589424199.793854|<4|
-  @asio|1589424199.793883|0|signal_set@0x7ffee977d878.cancel
-
-Each line is of the form:
-
-  <tag>|<timestamp>|<action>|<description>
-
-The `<tag>` is always `@asio`, and is used to identify and extract the handler
-tracking messages from the program output.
-
-The `<timestamp>` is seconds and microseconds from 1 Jan 1970 UTC.
-
-The `<action>` takes one of the following forms:
-
-[variablelist
-  [
-    [>n]
-    [The program entered the handler number `n`. The `<description>` shows the
-    arguments to the handler.]
-  ]
-  [
-    [<n]
-    [The program left handler number `n`.]
-  ]
-  [
-    [!n]
-    [The program left handler number n due to an exception.]
-  ]
-  [
-    [~n]
-    [The handler number `n` was destroyed without having been invoked. This is
-    usually the case for any unfinished asynchronous operations when the
-    `io_context` is destroyed.]
-  ]
-  [
-    [n^m]
-    [The handler number `n` is about to create a new asynchronous operation with
-    completion handler number `m`. The `<description>` contains source location
-    information to help identify where in the program the asynchronous operation
-    is being started.]
-  ]
-  [
-    [n*m]
-    [The handler number `n` created a new asynchronous operation with completion
-    handler number `m`. The `<description>` shows what asynchronous operation
-    was started.]
-  ]
-  [
-    [n]
-    [The handler number `n` performed some other operation. The `<description>`
-    shows what function was called. Currently only `close()` and `cancel()`
-    operations are logged, as these may affect the state of pending
-    asynchronous operations.]
-  ]
-  [
-    [.n]
-    [The implementation performed a system call as part of the asynchronous
-    operation for which handler number `n` is the completion handler. The
-    `<description>` shows what function was called and its results. These
-    tracking events are only emitted when using a reactor-based
-    implementation.]
-  ]
-]
-
-Where the `<description>` shows a synchronous or asynchronous operation, the
-format is `<object-type>@<pointer>.<operation>`. For handler entry, it shows a
-comma-separated list of arguments and their values.
-
-As shown above, Each handler is assigned a numeric identifier. Where the
-handler tracking output shows a handler number of 0, it means that the action
-was performed outside of any handler.
-
-[heading Adding Location Information]
-
-[c++]
-Programs may augment the handler tracking output's location information by
-using the macro `ASIO_HANDLER_LOCATION` in the source code. For example:
-
-  #define HANDLER_LOCATION \
-    ASIO_HANDLER_LOCATION((__FILE__, __LINE__, __func__))
-
-  // ...
-
-  void do_read()
-  {
-    HANDLER_LOCATION;
-
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_, max_length),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          HANDLER_LOCATION;
-
-          if (!ec)
-          {
-            do_write(length);
-          }
-        });
-  }
-
-[teletype]
-With the additional location information available, the handler tracking output
-may include a call stack of source locations:
-
-  @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
-  @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
-  @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
-  @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
-  @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
-  @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
-  @asio|1589423304.861980|<7|
-
-Furthermore, if `std::source_location` or `std::experimental::source_location`
-are available, the [link asio.reference.use_awaitable_t `use_awaitable_t`]
-token (when default-constructed or used as a default completion token) will
-also cause handler tracking to output a source location for each newly created
-asynchronous operation. A `use_awaitable_t` object may also be explicitly
-constructed with location information.
-
-[heading Visual Representations]
-
-The handler tracking output may be post-processed using the included
-[^handlerviz.pl] tool to create a visual representation of the handlers
-(requires the GraphViz tool [^dot]).
-[c++]
-
-[heading Custom Tracking]
-
-Handling tracking may be customised by defining the
-`ASIO_CUSTOM_HANDLER_TRACKING` macro to the name of a header file
-(enclosed in `""` or `<>`). This header file must implement the following
-preprocessor macros:
-
-[table
-  [[Macro] [Description]]
-  [
-    [`ASIO_INHERIT_TRACKED_HANDLER`]
-    [Specifies a base class for classes that implement asynchronous operations.
-    When used, the macro immediately follows the class name, so it must have
-    the form `: public my_class`.]
-  ]
-  [
-    [`ASIO_ALSO_INHERIT_TRACKED_HANDLER`]
-    [Specifies a base class for classes that implement asynchronous operations.
-    When used, the macro follows other base classes, so it must have the form
-    `, public my_class`.]
-  ]
-  [
-    [`ASIO_HANDLER_TRACKING_INIT(args)`]
-    [An expression that is used to initialise the tracking mechanism.]
-  ]
-  [
-    [`ASIO_HANDLER_LOCATION(args)`]
-    [A variable declaration that is used to define a source code location.
-    `args` is a parenthesised function argument list containing the file
-    name, line number, and function name.]
-  ]
-  [
-    [`ASIO_HANDLER_CREATION(args)`]
-    [An expression that is called on creation of an asynchronous operation.
-    `args` is a parenthesised function argument list containing the owning
-    execution context, the tracked handler, the name of the object type, a
-    pointer to the object, the object's native handle, and the operation name.]
-  ]
-  [
-    [`ASIO_HANDLER_COMPLETION(args)`]
-    [An expression that is called on completion of an asynchronous operation.
-    `args` is a parenthesised function argument list containing the tracked
-    handler.]
-  ]
-  [
-    [`ASIO_HANDLER_INVOCATION_BEGIN(args)`]
-    [An expression that is called immediately before a completion handler is
-    invoked. `args` is a parenthesised function argument list containing the
-    arguments to the completion handler.]
-  ]
-  [
-    [`ASIO_HANDLER_INVOCATION_END`]
-    [An expression that is called immediately after a completion handler is
-    invoked.]
-  ]
-  [
-    [`ASIO_HANDLER_OPERATION(args)`]
-    [An expression that is called when some synchronous object operation is
-    called (such as `close()` or `cancel()`). `args` is a parenthesised
-    function argument list containing the owning execution context, the name
-    of the object type, a pointer to the object, the object's native handle,
-    and the operation name.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_REGISTRATION(args)`]
-    [An expression that is called when an object is registered with the
-    reactor. `args` is a parenthesised function argument list containing the
-    owning execution context, the object's native handle, and a unique
-    registration key.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_DEREGISTRATION(args)`]
-    [An expression that is called when an object is deregistered from the
-    reactor. `args` is a parenthesised function argument list containing the
-    owning execution context, the object's native handle, and a unique
-    registration key.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_READ_EVENT`]
-    [A bitmask constant used to identify reactor read readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_WRITE_EVENT`]
-    [A bitmask constant used to identify reactor write readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_ERROR_EVENT`]
-    [A bitmask constant used to identify reactor error readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_EVENTS(args)`]
-    [An expression that is called when an object registered with the reactor
-    becomes ready. `args` is a parenthesised function argument list containing
-    the owning execution context, the unique registration key, and a bitmask of
-    the ready events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_OPERATION(args)`]
-    [An expression that is called when the implementation performs a system
-    call as part of a reactor-based asynchronous operation. `args` is a
-    parenthesised function argument list containing the tracked handler, the
-    operation name, the error code produced by the operation, and (optionally)
-    the number of bytes transferred.]
-  ]
-]
-
-[heading See Also]
-
-[link asio.examples.cpp11_examples.handler_tracking Handler tracking
-examples].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/immediate_completion.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/immediate_completion.qbk
deleted file mode 100644
index 237adc9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/immediate_completion.qbk
+++ /dev/null
@@ -1,51 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:immediate_completion Customising Immediate Completion]
-
-The `associated_immediate_executor` associator trait, along with the
-`bind_immediate_executor` function, provide the ability to customise the
-execution of a completion handler when an asynchronous operation completes
-immediately.
-
-When a supported operation completes immediately (that is, within the
-initiating function) the associated immmediate executor is obtained, and the
-completion handler is delivered through that executor as if by using
-`asio::dispatch` on that executor. By default, the immediate executor delivers
-the completion handler as if using `asio::post` via the operation's I/O
-executor.
-
-For example, to allow a recursive call to the completion handler of an
-`async_read_some` operation, we may specify that immediate completion is
-delivered via a `system_executor`:
-
-  my_socket.async_read_some(my_buffer,
-      bind_immediate_executor(
-        system_executor(),
-        [](error_code e, size_t n)
-        {
-          // ...
-        }
-      )
-    );
-
-Immediate execution is currently supported for asynchronous operations on
-reactor-based sockets and descriptors, and for asynchronous operations on
-channels.
-
-[*Note:] When enabling the immediate execution of completion handlers, care
-must be taken to ensure that unbounded recursion and stack overflow do not
-occur. Furthermore, use of immediate completion may impact the fairness of
-completion handler scheduling, with a potential for starvation for other
-pending work.
-
-[heading See Also]
-
-[link asio.reference.associated_immediate_executor associated_immediate_executor],
-[link asio.reference.bind_immediate_executor bind_immediate_executor].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/implementation.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/implementation.qbk
deleted file mode 100644
index aaf1fd3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/implementation.qbk
+++ /dev/null
@@ -1,342 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:implementation Platform-Specific Implementation Notes]
-
-This section lists platform-specific implementation details, such as the
-default demultiplexing mechanism, the number of threads created internally, and
-when threads are created.
-
-
-[heading Linux Kernel 2.4]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Linux Kernel 2.6]
-
-Demultiplexing mechanism:
-
-* Uses `epoll` for demultiplexing.
-
-Threads:
-
-* Demultiplexing using `epoll` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Linux Kernel 5.10]
-
-Demultiplexing mechanism:
-
-* If `ASIO_HAS_IO_URING` is defined, uses `io_uring` for file-related
-asynchonous operations.
-
-* Uses `epoll` for demultiplexing other event sources.
-
-* Optionally uses `io_uring` for all asynchronous operations if, in addition
-to `ASIO_HAS_IO_URING`, `ASIO_DISABLE_EPOLL` is defined to disable `epoll`.
-
-Threads:
-
-* Demultiplexing using `epoll` and `io_uring` is performed in one of the threads
-that calls `io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Solaris]
-
-Demultiplexing mechanism:
-
-* Uses [^/dev/poll] for demultiplexing.
-
-Threads:
-
-* Demultiplexing using [^/dev/poll] is performed in one of the threads that
-calls `io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading QNX Neutrino]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Mac OS X]
-
-Demultiplexing mechanism:
-
-* Uses `kqueue` for demultiplexing.
-
-Threads:
-
-* Demultiplexing using `kqueue` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading FreeBSD]
-
-Demultiplexing mechanism:
-
-* Uses `kqueue` for demultiplexing.
-
-Threads:
-
-* Demultiplexing using `kqueue` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading AIX]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading HP-UX]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Tru64]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-
-
-[heading Windows 95, 98 and Me]
-
-Demultiplexing mechanism:
-
-* Uses `select` for demultiplexing.
-
-Threads:
-
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* For sockets, at most 16 buffers may be transferred in a single operation.
-
-
-[heading Windows NT, 2000, XP, 2003, Vista, 7, 8, 10 and 11]
-
-Demultiplexing mechanism:
-
-* Uses overlapped I/O and I/O completion ports for all asynchronous socket
-operations except for asynchronous connect.
-
-* Uses `select` for emulating asynchronous connect.
-
-Threads:
-
-* Demultiplexing using I/O completion ports is performed in all threads that call
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-
-* An additional thread per `io_context` is used to trigger timers. This thread
-is created on construction of the first `basic_deadline_timer` or
-`basic_waitable_timer` objects.
-
-* An additional thread per `io_context` may be used for `select`
-  demultiplexing. This thread is created on the first call to:
-
-  * A socket `async_wait()` function, except when using `wait_read` on
-    a stream-oriented socket. (For `wait_read` on a stream-oriented socket,
-    the overlapped I/O operation `WSARecv` is used and no additional thread
-    is required.)
-
-  * A socket `async_connect()` operation, if the overlapped I/O
-    operation `ConnectEx` is unavailable. (On recent versions of Windows,
-    `ConnectEx` is used and no additional thread is required.)
-
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-
-Scatter-Gather:
-
-* For sockets, at most 64 buffers may be transferred in a single operation.
-
-* For stream-oriented handles, only one buffer may be transferred in a single
-operation.
-
-[heading Windows Runtime]
-
-Asio provides limited support for the Windows Runtime. It requires that the
-language extensions be enabled. Due to the restricted facilities exposed by the
-Windows Runtime API, the support comes with the following caveats:
-
-* The core facilities such as the `io_context`, `strand`, buffers, composed
-  operations, timers, etc., should all work as normal.
-
-* For sockets, only client-side TCP is supported.
-
-* Explicit binding of a client-side TCP socket is not supported.
-
-* The `cancel()` function is not supported for sockets. Asynchronous
-  operations may only be cancelled by closing the socket.
-
-* Operations that use `null_buffers` are not supported.
-
-* Only `tcp::no_delay` and `socket_base::keep_alive` options are supported.
-
-* Resolvers do not support service names, only numbers. I.e. you must
-  use "80" rather than "http".
-
-* Most resolver query flags have no effect.
-
-Demultiplexing mechanism:
-
-* Uses the `Windows::Networking::Sockets::StreamSocket` class to implement
-  asynchronous TCP socket operations.
-
-Threads:
-
-* Event completions are delivered to the Windows thread pool and posted to the
-  `io_context` for the handler to be executed.
-
-* An additional thread per `io_context` is used to trigger timers. This thread
-  is created on construction of the first timer objects.
-
-Scatter-Gather:
-
-* For sockets, at most one buffer may be transferred in a single operation.
-
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/iostreams.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/iostreams.qbk
deleted file mode 100644
index 4f76cd9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/iostreams.qbk
+++ /dev/null
@@ -1,72 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:iostreams Socket Iostreams]
-
-Asio includes classes that implement iostreams on top of sockets. These hide
-away the complexities associated with endpoint resolution, protocol
-independence, etc. To create a connection one might simply write:
-
-  ip::tcp::iostream stream("www.boost.org", "http");
-  if (!stream)
-  {
-    // Can't connect.
-  }
-
-The iostream class can also be used in conjunction with an acceptor to create
-simple servers. For example:
-
-  io_context ioc;
-
-  ip::tcp::endpoint endpoint(tcp::v4(), 80);
-  ip::tcp::acceptor acceptor(ios, endpoint);
-
-  for (;;)
-  {
-    ip::tcp::iostream stream;
-    acceptor.accept(stream.socket());
-    ...
-  }
-
-Timeouts may be set by calling `expires_at()` or `expires_from_now()` to
-establish a deadline. Any socket operations that occur past the deadline will
-put the iostream into a "bad" state.
-
-For example, a simple client program like this:
-
-  ip::tcp::iostream stream;
-  stream.expires_from_now(boost::posix_time::seconds(60));
-  stream.connect("www.boost.org", "http");
-  stream << "GET /LICENSE_1_0.txt HTTP/1.0\r\n";
-  stream << "Host: www.boost.org\r\n";
-  stream << "Accept: */*\r\n";
-  stream << "Connection: close\r\n\r\n";
-  stream.flush();
-  std::cout << stream.rdbuf();
-
-will fail if all the socket operations combined take longer than 60 seconds.
-
-If an error does occur, the iostream's `error()` member function may be used to
-retrieve the error code from the most recent system call:
-
-  if (!stream)
-  {
-    std::cout << "Error: " << stream.error().message() << "\n";
-  }
-
-[heading See Also]
-
-[link asio.reference.ip__tcp.iostream ip::tcp::iostream],
-[link asio.reference.basic_socket_iostream basic_socket_iostream],
-[link asio.examples.cpp11_examples.iostreams iostreams examples].
-
-[heading Notes]
-
-These iostream templates only support `char`, not `wchar_t`, and do not perform
-any code conversion.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/line_based.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/line_based.qbk
deleted file mode 100644
index d4cd852..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/line_based.qbk
+++ /dev/null
@@ -1,118 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:line_based Line-Based Operations]
-
-Many commonly-used internet protocols are line-based, which means that they
-have protocol elements that are delimited by the character sequence `"\r\n"`.
-Examples include HTTP, SMTP and FTP. To more easily permit the implementation
-of line-based protocols, as well as other protocols that use delimiters, Asio
-includes the functions `read_until()` and `async_read_until()`.
-
-The following example illustrates the use of `async_read_until()` in an HTTP
-server, to receive the first line of an HTTP request from a client:
-
-  class http_connection
-  {
-    ...
-
-    void start()
-    {
-      asio::async_read_until(socket_, data_, "\r\n",
-          boost::bind(&http_connection::handle_request_line, this, _1));
-    }
-
-    void handle_request_line(asio::error_code ec)
-    {
-      if (!ec)
-      {
-        std::string method, uri, version;
-        char sp1, sp2, cr, lf;
-        std::istream is(&data_);
-        is.unsetf(std::ios_base::skipws);
-        is >> method >> sp1 >> uri >> sp2 >> version >> cr >> lf;
-        ...
-      }
-    }
-
-    ...
-
-    asio::ip::tcp::socket socket_;
-    asio::streambuf data_;
-  };
-
-The `streambuf` data member serves as a place to store the data that has been
-read from the socket before it is searched for the delimiter. It is important
-to remember that there may be additional data ['after] the delimiter. This
-surplus data should be left in the `streambuf` so that it may be inspected by a
-subsequent call to `read_until()` or `async_read_until()`.
-
-The delimiters may be specified as a single `char`, a `std::string` or a
-`boost::regex`. The `read_until()` and `async_read_until()` functions also
-include overloads that accept a user-defined function object called a match
-condition. For example, to read data into a streambuf until whitespace is
-encountered:
-
-  typedef asio::buffers_iterator<
-      asio::streambuf::const_buffers_type> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_whitespace);
-
-To read data into a streambuf until a matching character is found:
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_char('a'));
-
-The `is_match_condition<>` type trait automatically evaluates to true for
-functions, and for function objects with a nested `result_type` typedef. For
-other types the trait must be explicitly specialised, as shown above.
-
-[heading See Also]
-
-[link asio.reference.async_read_until async_read_until()],
-[link asio.reference.is_match_condition is_match_condition],
-[link asio.reference.read_until read_until()],
-[link asio.reference.streambuf streambuf],
-[link asio.examples.cpp11_examples.http_client HTTP client example].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model.qbk
deleted file mode 100644
index 37531e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model.qbk
+++ /dev/null
@@ -1,40 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:model Asynchronous Model]
-
-This section presents a high-level overview of the asynchronous model at the
-core of the Asio library. This model enshrines asynchronous operations as the
-fundamental building block of asynchronous composition, but in a way that
-decouples them from the composition mechanism. The asynchronous operations in
-Asio support callbacks, futures (both eager and lazy), fibers, coroutines, and
-approaches yet to be imagined. This allows the application programmer to select
-an approach based on appropriate trade-offs.
-
-* [link asio.overview.model.async_ops Asynchronous Operations]
-* [link asio.overview.model.async_agents Asynchronous Agents]
-* [link asio.overview.model.associators Associated Characteristics and Associators]
-* [link asio.overview.model.child_agents Child Agents]
-* [link asio.overview.model.executors Executors]
-* [link asio.overview.model.allocators Allocators]
-* [link asio.overview.model.cancellation Cancellation]
-* [link asio.overview.model.completion_tokens Completion Tokens]
-* [link asio.overview.model.library_elements Supporting Library Elements]
-* [link asio.overview.model.higher_levels Higher Level Abstractions]
-
-[include model/async_ops.qbk]
-[include model/async_agents.qbk]
-[include model/associators.qbk]
-[include model/child_agents.qbk]
-[include model/executors.qbk]
-[include model/allocators.qbk]
-[include model/cancellation.qbk]
-[include model/completion_tokens.qbk]
-[include model/library_elements.qbk]
-[include model/higher_levels.qbk]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/allocators.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/allocators.qbk
deleted file mode 100644
index b203ff9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/allocators.qbk
+++ /dev/null
@@ -1,65 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:allocators Allocators]
-
-Every asynchronous agent has an associated ['allocator]. An agent's allocator
-is an interface used by the agent's asynchronous operations to obtain
-['per-operation stable memory] resources (POSMs). This name reflects the fact
-that the memory is per-operation because the memory is only retained for the
-lifetime of that operation, and stable, because the memory is guaranteed to be
-available at that location throughout the operation.
-
-Asynchronous operations may utilise POSMs in a number of different ways:
-
-* The operation doesn't require any POSMs. For example, the operation wraps an
-  existing API that performs its own memory management, or is copying the long
-  lived state into existing memory like a circular buffer.
-
-* The operation uses a single, fixed-size POSM for as long as the operation is
-  outstanding. For example, the operation stores some state in a linked list.
-
-* The operation uses a single, runtime-sized POSM. For example, the operation
-  stores a copy of a user-supplied buffer, or a runtime-sized array of iovec
-  structures.
-
-* The operation uses multiple POSMs concurrently. For example, a fixed size
-  POSM for a linked list plus a runtime-sized POSM for a buffer.
-
-* The operation uses multiple POSMs serially, which may vary in size.
-
-Associated allocators allow users to treat POSM optimisation as a cross-cutting
-concern to the composition of asynchronous operations. Furthermore, using
-allocators as the interface to obtain POSMs grant substantial flexibility to
-both the implementers and users of asynchronous operations:
-
-* Users can ignore the allocator and accept whatever default strategy is
-  employed by the application.
-
-* Implementers can ignore the allocator, especially if the operation is not
-  considered performance-sensitive.
-
-* Users can co-locate POSMs for related asynchronous operations, for better
-  locality of reference. 
-
-* For compositions that involve serial POSMs of different sizes, memory usage
-  need only be as great as the currently extant POSM. For example, consider a
-  composition that contains a short-lived operation that uses large POSMs
-  (connection establishment and handshake) followed by a long-lived operation
-  that uses small POSMs (transferring data to and from the peer).
-
-As noted previously, all resources must be released prior to calling the
-completion handler. This enables memory to be recycled for subsequent
-asynchronous operations within an agent. This allows applications with
-long-lived asynchronous agents to have no hot-path memory allocations, even
-though the user code is unaware of associated allocators.
-
-[heading See Also]
-
-[link asio.overview.core.allocation Custom Memory Allocation].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/associators.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/associators.qbk
deleted file mode 100644
index 79cde47..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/associators.qbk
+++ /dev/null
@@ -1,78 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:associators Associated Characteristics and Associators]
-
-An asynchronous agent has ['associated characteristics] that specify how
-asynchronous operations should behave when composed as part of that agent, such
-as:
-
-* An allocator, which determines how the agent's asynchronous operations obtain
-  memory resources.
-
-* A cancellation slot, which determines how the agent's asynchronous operations
-  support cancellation.
-
-* An executor, which determines how the agent's completion handlers will be
-  queued and run.
-
-When an asynchronous operation is run within an asynchronous agent, its
-implementation may query these associated characteristics and use them to
-satisfy the requirements or preferences they represent. The asynchronous
-operation performs these queries by applying ['associator] traits to the
-completion handler. Each characteristic has a corresponding associator trait.
-
-An associator trait may be specialised for concrete completion handler types to:
-
-* accept the default characteristic supplied by the asynchronous operation,
-  returning this default as-is
-
-* return an unrelated implementation of the characteristic, or
-
-* adapt the supplied default to introduce additional behaviour required by the
-  completion handler.
-
-[heading Specification of an Associator]
-
-Given an associator trait named[footnote The associator traits are named
-[link asio.reference.associated_allocator `associated_allocator`],
-[link asio.reference.associated_executor `associated_executor`], and
-[link asio.reference.associated_cancellation_slot
-`associated_cancellation_slot`].] `associated_R`, having:
-
-* a source value `s` of type `S`, in this case the completion handler and its
-  type,
-
-* a set of type requirements (or a concept) `R` that define the syntactic and
-  semantic requirements of the associated characteristic, and
-
-* a candidate value `c` of type `C` that meets the type requirements `R`, which
-  represents a default implementation of the associated characteristic,
-  supplied by the asynchronous operation
-
-the asynchronous operation uses the associator trait to compute:
-
-* the type `associated_R<S, C>::type`, and
-
-* the value `associated_R<S, C>::get(s, c)`
-
-that meet the requirements defined in `R`. For convenience, these are also
-accessible via type alias `associated_R_t<S, C>` and free function
-`get_associated_R(s, c)`, respectively.
-
-The trait's primary template is specified such that:
-
-* if `S::R_type` is well-formed, defines a nested type alias type as
-  `S::R_type`, and a static member function get that returns `s.get_R()`
-
-* otherwise, if `associator<associated_R, S, C>::type` is well-formed and
-  denotes a type, inherits from `associator<associated_R, S, C>`
-
-* otherwise, defines a nested type alias type as `C`, and a static member
-  function get that returns `c`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_chain.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_chain.png
deleted file mode 100644
index 639d227..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_chain.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_model.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_model.png
deleted file mode 100644
index befb8e4..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agent_model.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agents.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agents.qbk
deleted file mode 100644
index 6a0fcb8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_agents.qbk
+++ /dev/null
@@ -1,35 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:async_agents Asynchronous Agents]
-
-[$async_agent_model.png [width 931px]]
-
-An ['asynchronous agent] is a sequential composition of asynchronous
-operations. Every asynchronous operation is considered to run as a part of an
-asynchronous agent, even if that agent contains only that single operation. An
-asynchronous agent is an entity that may perform work concurrently with other
-agents. Asynchronous agents are to asynchronous operations as threads are to
-synchronous operations.
-
-However, an asynchronous agent is a purely notional construct that allows us to
-reason about the context for, and composition of, asynchronous operations in a
-program. The name “asynchronous agent” does not appear in the library, nor is
-it important which concrete mechanism[footnote Such as chains of lambdas,
-coroutines, fibers, state machines, etc.] is used to compose the asynchronous
-operations in an agent.
-
-We can visualise an asynchronous agent as follows:
- 
-[$async_agent_chain.png [width 738px]]
-
-Asynchronous agents alternately wait for an asynchronous operation to complete,
-and then run a completion handler for that operation. Within the context of an
-agent, these completion handlers represent indivisible units of schedulable
-work.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_child_agent_chain.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_child_agent_chain.png
deleted file mode 100644
index 4ffebf4..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_child_agent_chain.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_init_complete.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_init_complete.png
deleted file mode 100644
index 516009a..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_init_complete.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_model.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_model.png
deleted file mode 100644
index 408bd84..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_model.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_phases.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_phases.png
deleted file mode 100644
index 6680bdc..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_phases.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_trivial_chain.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_trivial_chain.png
deleted file mode 100644
index a69cc86..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_op_trivial_chain.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_ops.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_ops.qbk
deleted file mode 100644
index 7de6704..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/async_ops.qbk
+++ /dev/null
@@ -1,81 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:async_ops Asynchronous Operations]
-
-[$async_op_model.png [width 421px]]
-
-An ['asynchronous operation] is the basic unit of composition in the Asio
-asynchronous model. Asynchronous operations represent work that is launched and
-performed in the background, while the user's code that initiated the work can
-continue with other things.
-
-Conceptually, the lifecycle of an asynchronous operation can be described in
-terms of the following events and phases:
-
-[$async_op_phases.png [width 861px]]
-
-An ['initiating function] is a function which may be called by the user to
-start an asynchronous operation.
-
-A ['completion handler] is a user-provided, move-only function object that will
-be invoked, at most once, with the result of the asynchronous operation. The
-invocation of the completion handler tells the user about something that has
-already happened: the operation completed, and the side effects of the
-operation were established.
-
-The initiating function and completion handler are incorporated into the user's
-code as follows:
-
-[$async_op_init_complete.png [width 496px]]
-
-Synchronous operations, being embodied as single functions, have several
-inherent semantic properties as a consequence. Asynchronous operations adopt
-some of these semantic properties from their synchronous counterparts, in order
-to facilitate flexible and efficient composition.
-
-[table
-  [
-    [Property of synchronous operations]
-    [Equivalent property of asynchronous operations]
-  ]
-  [
-    [
-      When a synchronous operation is generic (i.e. a template) the return type
-      is deterministically derived from the function and its arguments.
-    ]
-    [
-      When an asynchronous operation is generic, the completion handler's
-      arguments' types and order are deterministically derived from the
-      initiating function and its arguments.
-    ]
-  ]
-  [
-    [
-      If a synchronous operation requires a temporary resource (such as memory,
-      a file descriptor, or a thread), this resource is released before
-      returning from the function.
-    ]
-    [
-      If an asynchronous operation requires a temporary resource (such as
-      memory, a file descriptor, or a thread), this resource is released before
-      calling the completion handler.
-    ]
-  ]
-]
-
-The latter is an important property of asynchronous operations, in that it
-allows a completion handler to initiate further asynchronous operations without
-overlapping resource usage. Consider the trivial (and relatively common) case
-of the same operation being repeated over and over in a chain:
-
-[$async_op_trivial_chain.png [width 375px]]
-
-By ensuring that resources are released before the completion handler runs, we
-avoid doubling the peak resource usage of the chain of operations.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/cancellation.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/cancellation.qbk
deleted file mode 100644
index 1eab439..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/cancellation.qbk
+++ /dev/null
@@ -1,33 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:cancellation Cancellation]
-
-In Asio, many objects, such as sockets and timers, support object-wide
-cancellation of outstanding asynchronous operations via their close or cancel
-member functions. However, certain asynchronous operations also support
-individual, targeted cancellation. This per-operation cancellation is enabled
-by specifying that every asynchronous agent has an associated ['cancellation
-slot].
-
-To support cancellation, an asynchronous operation installs a cancellation
-handler into the agent's slot. The cancellation handler is a function object
-that will be invoked when a cancellation signal is emitted by the user into the
-slot. Since a cancellation slot is associated with a single agent, the slot
-holds at most one handler at a time, and installing a new handler will
-overwrite any previously installed handler. Thus, the same slot is reused for
-subsequent asynchronous operations within the agent.
-
-Cancellation is particularly useful when an asynchronous operation contains
-multiple child agents. For example, one child agent may be complete and the
-other is then cancelled, as its side effects are no longer required.
-
-[heading See Also]
-
-[link asio.overview.core.cancellation Per-Operation Cancellation].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/child_agents.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/child_agents.qbk
deleted file mode 100644
index b2f073f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/child_agents.qbk
+++ /dev/null
@@ -1,56 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:child_agents Child Agents]
-
-The asynchronous operations within an agent may themselves be implemented in
-terms of child agents.[footnote In Asio these asynchronous operations are
-referred to as ['composed operations].] As far as the parent agent is
-concerned, it is waiting for the completion of a single asynchronous operation.
-The asynchronous operations that constitute the child agent run in sequence,
-and when the final completion handler runs the parent agent is resumed.
-
-[$async_child_agent_chain.png [width 802px]]
-
-As with individual asynchronous operations, the asynchronous operations built
-on child agents must release their temporary resources prior to calling the
-completion handler. We may also think of these child agents as resources that
-end their lifetimes before the completion handler is invoked.
-
-When an asynchronous operation creates a child agent, it may propagate[footnote
-Typically, by specialising the associator trait and forwarding to the outer
-completion handler.] the associated characteristics of the parent agent to the
-child agent. These associated characteristics may then be recursively
-propagated through further layers of asynchronous operations and child agents.
-This stacking of asynchronous operations replicates another property of
-synchronous operations.
-
-[table
-  [
-    [Property of synchronous operations]
-    [Equivalent property of asynchronous operations]
-  ]
-  [
-    [
-      Compositions of synchronous operations may be refactored to use child
-      functions that run on the same thread (i.e. are simply called) without
-      altering functionality.
-    ]
-    [
-      Asynchronous agents may be refactored to use asynchronous operations and
-      child agents that share the associated characteristics of the parent
-      agent, without altering functionality.
-    ]
-  ]
-]
-
-Finally, some asynchronous operations may be implemented in terms of multiple
-child agents that run concurrently. In this case, the asynchronous operation
-may choose to selectively propagate the associated characteristics of the
-parent agent.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_model.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_model.png
deleted file mode 100644
index a7728d1..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_model.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_transform.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_transform.png
deleted file mode 100644
index b90b2a5..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_token_transform.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_tokens.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_tokens.qbk
deleted file mode 100644
index 5f4f4bf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/completion_tokens.qbk
+++ /dev/null
@@ -1,239 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:completion_tokens Completion Tokens]
-
-[$completion_token_model.png [width 436px]]
-
-A key goal of Asio's asynchronous model is to support multiple composition
-mechanisms. This is achieved via a ['completion token], which the user passes
-to an asynchronous operation's initiating function to customise the API surface
-of the library. By convention, the completion token is the final argument to an
-asynchronous operation's initiating function.
-
-For example, if the user passes a lambda (or other function object) as the
-completion token, the asynchronous operation behaves as previously described:
-the operation begins, and when the operation completes the result is passed to
-the lambda.
-
-  socket.async_read_some(buffer,
-      [](error_code e, size_t)
-      {
-        // ...
-      }
-    );
-
-When the user passes the [link asio.reference.use_future use_future] completion
-token, the operation behaves as though implemented in terms of a `promise` and
-`future` pair. The initiating function does not just launch the operation, but
-also returns a future that may be used to await the result.
-
-  future<size_t> f =
-    socket.async_read_some(
-        buffer, use_future
-      );
-  // ...
-  size_t n = f.get();
-
-Similarly, when the user passes the [link asio.reference.use_awaitable
-use_awaitable] completion token, the initiating function behaves as though it
-is an `awaitable`-based coroutine [footnote The [link asio.reference.awaitable
-awaitable] class template is included with the Asio library as a return type
-for C++20 coroutines. These coroutines can be trivially implemented in terms of
-other `awaitable`-based coroutines.]. However, in this case the initiating
-function does not launch the asynchronous operation directly. It only returns
-the `awaitable`, which in turn launches the operation when it is co_await-ed.
-
-  awaitable<void> foo()
-  {
-    size_t n =
-      co_await socket.async_read_some(
-          buffer, use_awaitable
-        );
-
-    // ...
-  }
-
-Finally, the [link asio.reference.yield_context yield_context] completion token
-causes the initiating function to behave as a synchronous operation within the
-context of a stackful coroutine. It not only begins the asynchronous operation,
-but blocks the stackful coroutine until it is complete. From the point of the
-stackful coroutine, it is a synchronous operation.
-
-  void foo(asio::yield_context yield)
-  {
-    size_t n = socket.async_read_some(buffer, yield);
-
-    // ...
-  }
-
-All of these uses are supported by a single implementation of the
-`async_read_some` initiating function.
-
-To achieve this, an asynchronous operation must first specify a ['completion
-signature] (or, possibly, signatures) that describes the arguments that will be
-passed to its completion handler.
-
-Then, the operation's initiating function takes the completion signature,
-completion token, and its internal implementation and passes them to the
-['async_result] trait. The `async_result` trait is a customisation point that
-combines these to first produce a concrete completion handler, and then launch
-the operation.
-
-[$completion_token_transform.png [width 856px]]
- 
-To see this in practice, let's use a detached thread to adapt a synchronous
-operation into an asynchronous one:[footnote For illustrative purposes only.
-Not recommended for real world use!]
-
-  template <
-      completion_token_for<void(error_code, size_t)> /*< The `completion_token_for`
-                                                         concept checks whether
-                                                         the user-supplied
-                                                         completion token will
-                                                         satisfy the specified
-                                                         completion signature.
-                                                         For older versions of
-                                                         C++, simply use `typename`
-                                                         here instead. >*/
-        CompletionToken>
-  auto async_read_some(
-      tcp::socket& s,
-      const mutable_buffer& b,
-      CompletionToken&& token)
-  {
-    auto init = []( /*< Define a function object that contains the code to
-                        launch the asynchronous operation. This is passed the
-                        concrete completion handler, followed by any additional
-                        arguments that were passed through the `async_result`
-                        trait. >*/
-        auto completion_handler,
-        tcp::socket* s,
-        const mutable_buffer& b)
-    {
-      std::thread( /*< The body of the function object spawns a new thread to
-                       perform the operation. >*/
-          [](
-              auto completion_handler,
-              tcp::socket* s,
-              const mutable_buffer& b
-            )
-          {
-            error_code ec;
-            size_t n = s->read_some(b, ec);
-            std::move(completion_handler)(ec, n); /*< Once the operation
-                                                      completes, the completion
-                                                      handler is passed the
-                                                      result. >*/
-          },
-          std::move(completion_handler),
-          s,
-          b
-        ).detach();
-    };
-
-    return async_result< /*< The `async_result` trait is passed the (decayed)
-                             completion token type, and the completion
-                             signatures of the asynchronous operation. >*/
-        decay_t<CompletionToken>,
-        void(error_code, size_t)
-      >::initiate(
-          init, /*< Call the trait’s `initiate` member function, first passing
-                    the function object that launches the operation. >*/
-          std::forward<CompletionToken>(token), /*< Next comes the forwarded
-                                                    completion token. The trait
-                                                    implementation will convert
-                                                    this into a concrete
-                                                    completion handler. >*/
-          &s, /*< Finally, pass any additional arguments for the function
-                  object. Assume that these may be decay-copied and moved by the
-                  trait implementation. >*/
-          b
-        );
-  }
-
-In practice we should call the [link asio.reference.async_initiate
-async_initiate] helper function, rather than use the `async_result` trait
-directly. The `async_initiate` function automatically performs the necessary
-decay and forward of the completion token, and also enables backwards
-compatibility with legacy completion token implementations.
-
-  template <
-      completion_token_for<void(error_code, size_t)>
-        CompletionToken>
-  auto async_read_some(
-      tcp::socket& s,
-      const mutable_buffer& b,
-      CompletionToken&& token)
-  {
-    auto init = /* ... as above ... */;
-
-    return async_initiate<
-        CompletionToken,
-        void(error_code, size_t)
-      >(init, token, &s, b);
-  }
-
-We can think of the completion token as a kind of proto completion handler. In
-the case where we pass a function object (like a lambda) as the completion
-token, it already satisfies the completion handler requirements. The
-async_result primary template handles this case by trivially forwarding the
-arguments through:
-
-  template <class CompletionToken, completion_signature... Signatures>
-  struct async_result
-  {
-    template <
-        class Initiation,
-        completion_handler_for<Signatures...> CompletionHandler,
-        class... Args>
-    static void initiate(
-        Initiation&& initiation,
-        CompletionHandler&& completion_handler,
-        Args&&... args)
-    {
-      std::forward<Initiation>(initiation)(
-          std::forward<CompletionHandler>(completion_handler),
-          std::forward<Args>(args)...);
-    }
-  };
-
-We can see here that this default implementation avoids copies of all
-arguments, thus ensuring that eager initiation is as efficient as possible.
-
-On the other hand, a lazy completion token (such as `use_awaitable` above) may
-capture these arguments for deferred launching of the operation. For example, a
-specialisation for a trivial [link asio.reference.deferred deferred] token
-(that simply packages the operation for later) might look something like this:
-
-  template <completion_signature... Signatures>
-  struct async_result<deferred_t, Signatures...>
-  {
-    template <class Initiation, class... Args>
-    static auto initiate(Initiation initiation, deferred_t, Args... args)
-    {
-      return [
-          initiation = std::move(initiation),
-          arg_pack = std::make_tuple(std::move(args)...)
-        ](auto&& token) mutable
-      {
-        return std::apply(
-            [&](auto&&... args)
-            {
-              return async_result<decay_t<decltype(token)>, Signatures...>::initiate(
-                  std::move(initiation),
-                  std::forward<decltype(token)>(token),
-                  std::forward<decltype(args)>(args)...
-                );
-            },
-            std::move(arg_pack)
-          );
-      };
-    }
-  };
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/executors.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/executors.qbk
deleted file mode 100644
index a7b3848..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/executors.qbk
+++ /dev/null
@@ -1,55 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:executors Executors]
-
-Every asynchronous agent has an associated ['executor]. An agent's executor
-determines how the agent's completion handlers are queued and ultimately run.
-
-Example uses of executors include:
-
-* Coordinating a group of asynchronous agents that operate on shared data
-  structures, ensuring that the agents' completion handlers never run
-  concurrently[footnote In Asio, this kind of executor is called a [link
-  asio.overview.core.strands strand].].
-
-* Ensuring that agents are run on specified execution resource (e.g. a CPU)
-  that is proximal to data or an event source (e.g. a NIC).
-
-* Denoting a group of related agents, and so enabling dynamic thread pools to
-  make smarter scheduling decisions (such as moving the agents between
-  execution resources as a unit).
-
-* Queuing all completion handlers to run on a GUI application thread, so that
-  they may safely update user interface elements.
-
-* Returning an asynchronous operation's default executor as-is, to run
-  completion handlers as close as possible to the event that triggered the
-  operation's completion.
-
-* Adapting an asynchronous operation's default executor, to run code before and
-  after every completion handler, such as logging, user authorisation, or
-  exception handling.
-
-* Specifying a priority for an asynchronous agent and its completion handlers.
-
-The asynchronous operations within an asynchronous agent use the agent's
-associated executor to:
-
-* Track the existence of the work that the asynchronous operation represents,
-  while the operation is outstanding.
-
-* Enqueue the completion handler for execution on completion of an operation.
-
-* Ensure that completion handlers do not run re-entrantly, if doing so might
-  lead to inadvertent recursion and stack overflow.
-
-Thus, an asynchronous agent's associated executor represents a policy of how,
-where, and when the agent should run, specified as a cross-cutting concern to
-the code that makes up the agent.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_level_model.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_level_model.png
deleted file mode 100644
index e74d16b..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_level_model.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_levels.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_levels.qbk
deleted file mode 100644
index a55d1fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/higher_levels.qbk
+++ /dev/null
@@ -1,40 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:higher_levels Higher Level Abstractions]
-
-[$higher_level_model.png [width 940px]]
-
-The asynchronous model presented in this section provides a basis for defining
-higher level abstractions. Asio builds on this core model to provide additional
-facilities, such as:
-
-* I/O objects such as [link asio.overview.networking sockets] and [link
-  asio.overview.timers timers] that expose asynchronous operations on top of
-  this model.
-
-* Concrete executors, such as the [link asio.reference.io_context io_context]
-  executor, [link asio.reference.thread_pool thread_pool] executor, and the
-  [link asio.reference.strand strand] adapter which guarantees non-concurrent
-  execution of completion handlers.
-
-* Completion tokens that facilitate different composition mechanisms, such as
-  [link asio.overview.composition.cpp20_coroutines C++ coroutines], [link
-  asio.overview.composition.spawn stackful coroutines], [link
-  asio.overview.composition.futures futures], and [link
-  asio.reference.deferred deferred operations].
-
-* High level support for C++ coroutines that combines support executors and
-  cancellation slots to allow for [link
-  asio.overview.composition.cpp20_coroutines.co_ordinating_parallel_coroutines
-  easy coordination of concurrent asynchronous agents].
-
-To allow users to more easily write their own asynchronous operations that
-adhere to this model, Asio also provides the helper function [link
-asio.reference.async_compose async_compose].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/library_elements.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/library_elements.qbk
deleted file mode 100644
index cf17ac1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/model/library_elements.qbk
+++ /dev/null
@@ -1,102 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:library_elements Supporting Library Elements]
-
-The Asio asynchronous model is enabled by the library elements listed in the
-table below.
-
-[table
-  [
-    [Library Element]
-    [Description]
-  ]
-  [
-    [
-      `completion_signature` concept
-    ]
-    [
-      Defines valid completion signature forms.
-    ]
-  ]
-  [
-    [
-      `completion_handler_for` concept
-    ]
-    [
-      Determines whether a completion handler is callable with a given set of
-      completion signatures.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.async_result async_result] trait
-    ]
-    [
-      Converts a completion signature and completion token into a concrete
-      completion handler, and launches the operation.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.async_initiate async_initiate] function
-    ]
-    [
-      Helper function to simplify use of the `async_result` trait.
-    ]
-  ]
-  [
-    [
-      `completion_token_for` concept
-    ]
-    [
-      Determines whether a completion token produces a completion handler for a
-      given set of completion signatures.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.associator associator] trait
-    ]
-    [
-      Automatically propagates all associators through layers of abstraction.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.associated_executor associated_executor] trait,
-      `associated_executor_t` type alias, and [link
-      asio.reference.get_associated_executor get_associated_executor] function
-    ]
-    [
-      Defines an asynchronous agent’s associated executor.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.associated_allocator associated_allocator] trait,
-      `associated_allocator_t` type alias, and [link
-      asio.reference.get_associated_allocator get_associated_allocator] function
-    ]
-    [
-      Defines an asynchronous agent’s associated allocator.
-    ]
-  ]
-  [
-    [
-      [link asio.reference.associated_cancellation_slot
-      associated_cancellation_slot] trait, `associated_cancellation_slot_t`
-      type alias, and [link asio.reference.get_associated_cancellation_slot
-      get_associated_cancellation_slot] function
-    ]
-    [
-      Defines an asynchronous agent’s associated cancellation slot.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/other_protocols.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/other_protocols.qbk
deleted file mode 100644
index 784554d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/other_protocols.qbk
+++ /dev/null
@@ -1,94 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:other_protocols Support for Other Protocols]
-
-Support for other socket protocols (such as Bluetooth or IRCOMM sockets) can be
-added by implementing the [link asio.reference.Protocol protocol type
-requirements]. However, in many cases these protocols may also be used with
-Asio's generic protocol support. For this, Asio provides the following four
-classes:
-    
-* [link asio.reference.generic__datagram_protocol `generic::datagram_protocol`]
-* [link asio.reference.generic__raw_protocol `generic::raw_protocol`]
-* [link asio.reference.generic__seq_packet_protocol `generic::seq_packet_protocol`]
-* [link asio.reference.generic__stream_protocol `generic::stream_protocol`]
-    
-These classes implement the [link asio.reference.Protocol protocol type
-requirements], but allow the user to specify the address family (e.g. `AF_INET`)
-and protocol type (e.g. `IPPROTO_TCP`) at runtime. For example:
-
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  my_socket.open(asio::generic::stream_protocol(AF_INET, IPPROTO_TCP));
-  ...
-
-An endpoint class template, [link asio.reference.generic__basic_endpoint
-`asio::generic::basic_endpoint`], is included to support these protocol
-classes. This endpoint can hold any other endpoint type, provided its native
-representation fits into a `sockaddr_storage` object. This class will also
-convert from other types that implement the [link asio.reference.Endpoint
-endpoint] type requirements:
-
-  asio::ip::tcp::endpoint my_endpoint1 = ...;
-  asio::generic::stream_protocol::endpoint my_endpoint2(my_endpoint1);
-
-The conversion is implicit, so as to support the following use cases:
-
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  asio::ip::tcp::endpoint my_endpoint = ...;
-  my_socket.connect(my_endpoint);
-
-[heading C++11 Move Construction]
-    
-When using C++11, it is possible to perform move construction from a socket (or
-acceptor) object to convert to the more generic protocol's socket (or acceptor)
-type. If the protocol conversion is valid:
-
-  Protocol1 p1 = ...;
-  Protocol2 p2(p1);
-
-then the corresponding socket conversion is allowed:
-
-  Protocol1::socket my_socket1(my_io_context);
-  ...
-  Protocol2::socket my_socket2(std::move(my_socket1));
-
-For example, one possible conversion is from a TCP socket to a generic
-stream-oriented socket:
-
-  asio::ip::tcp::socket my_socket1(my_io_context);
-  ...
-  asio::generic::stream_protocol::socket my_socket2(std::move(my_socket1));
-
-These conversions are also available for move-assignment.
-
-These conversions are not limited to the above generic protocol classes.
-User-defined protocols may take advantage of this feature by similarly ensuring
-the conversion from `Protocol1` to `Protocol2` is valid, as above.
-
-[heading Accepting Generic Sockets]
-
-As a convenience, a socket acceptor's `accept()` and `async_accept()` functions
-can directly accept into a different protocol's socket type, provided the
-corresponding protocol conversion is valid. For example, the following is
-supported because the protocol `asio::ip::tcp` is convertible to
-`asio::generic::stream_protocol`:
-
-  asio::ip::tcp::acceptor my_acceptor(my_io_context);
-  ...
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  my_acceptor.accept(my_socket);
-
-[heading See Also]
-
-[link asio.reference.generic__datagram_protocol `generic::datagram_protocol`],
-[link asio.reference.generic__raw_protocol `generic::raw_protocol`],
-[link asio.reference.generic__seq_packet_protocol `generic::seq_packet_protocol`],
-[link asio.reference.generic__stream_protocol `generic::stream_protocol`],
-[link asio.reference.Protocol protocol type requirements].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/parallel_group.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/parallel_group.qbk
deleted file mode 100644
index 0591a71..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/parallel_group.qbk
+++ /dev/null
@@ -1,66 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:parallel_group Co-ordinating Parallel Operations]
-
-[note This is an experimental feature.]
-
-The [link asio.reference.experimental__make_parallel_group
-`experimental::make_parallel_group`] function may be used to launch work that
-is performed in parallel, and wait for one or all of the operations to
-complete. A `parallel_group` implements automatic cancellation of incomplete
-operations. For example:
-
-  experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return stream.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      experimental::wait_for_one(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          asio::error_code ec1, std::size_t n1,
-          asio::error_code ec2
-      )
-      {
-        // ...
-      }
-    );
-
-The conditions for completion of the group may be specified using one of the
-four provided function objects [link asio.reference.experimental__wait_for_all
-`wait_for_all`], [link asio.reference.experimental__wait_for_one
-`wait_for_one`], [link asio.reference.experimental__wait_for_one_success
-`wait_for_one_success`], [link asio.reference.experimental__wait_for_one_error
-`wait_for_one_error`], or with a custom function.
-
-The `parallel_group` facility can also be combined with [link
-asio.reference.deferred `deferred`] as follows:
-
-  experimental::make_parallel_group(
-      stream.async_read_some(asio::buffer(data), deferred),
-      timer.async_wait(experimental::deferred)
-    ).async_wait(
-      // ...
-    );
-
-Note: for maximum flexibility, `parallel_group` does not propagate the
-executor automatically to the operations within the group.
-
-[heading See Also]
-
-[link asio.reference.experimental__make_parallel_group experimental::make_parallel_group],
-[link asio.reference.experimental__parallel_group experimental::parallel_group],
-[link asio.examples.cpp11_examples.parallel_groups Parallel Groups examples (C++11)],
-[link asio.examples.cpp14_examples.parallel_groups Parallel Groups examples (C++14)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/pipes.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/pipes.qbk
deleted file mode 100644
index 3328c35..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/pipes.qbk
+++ /dev/null
@@ -1,38 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:pipes Pipes]
-
-Asio provides support for portable anonymous pipes on POSIX and Windows (when
-I/O completion ports are available). For example, to create and use a
-connected pair of pipe objects:
-
-  asio::readable_pipe read_end(my_io_context);
-  asio::writable_pipe write_end(my_io_context);
-  asio::connect_pipe(read_end, write_end);
-
-  write_end.async_write_some(my_write_buffer,
-      [](asio::error_code e, size_t n)
-      {
-        // ...
-      });
-
-  read_end.async_read_some(my_read_buffer,
-      [](asio::error_code e, size_t n)
-      {
-        // ...
-      });
-
-[heading See Also]
-
-[link asio.reference.basic_readable_pipe basic_readable_pipe],
-[link asio.reference.basic_writable_pipe basic_writable_pipe],
-[link asio.reference.connect_pipe connect_pipe],
-[link asio.reference.readable_pipe readable_pipe],
-[link asio.reference.writable_pipe writable_pipe].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/posix.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/posix.qbk
deleted file mode 100644
index d8dd3b8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/posix.qbk
+++ /dev/null
@@ -1,151 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:posix POSIX-Specific Functionality]
-
-[link asio.overview.posix.local UNIX Domain Sockets]
-
-[link asio.overview.posix.stream_descriptor Stream-Oriented File Descriptors]
-
-[link asio.overview.posix.fork Fork]
-
-[section:local UNIX Domain Sockets]
-
-Asio provides basic support for UNIX domain sockets (also known as local
-sockets). The simplest use involves creating a pair of connected sockets.
-The following code:
-
-  local::stream_protocol::socket socket1(my_io_context);
-  local::stream_protocol::socket socket2(my_io_context);
-  local::connect_pair(socket1, socket2);
-
-will create a pair of stream-oriented sockets. To do the same for
-datagram-oriented sockets, use:
-
-  local::datagram_protocol::socket socket1(my_io_context);
-  local::datagram_protocol::socket socket2(my_io_context);
-  local::connect_pair(socket1, socket2);
-
-A UNIX domain socket server may be created by binding an acceptor to an
-endpoint, in much the same way as one does for a TCP server:
-
-  ::unlink("/tmp/foobar"); // Remove previous binding.
-  local::stream_protocol::endpoint ep("/tmp/foobar");
-  local::stream_protocol::acceptor acceptor(my_io_context, ep);
-  local::stream_protocol::socket socket(my_io_context);
-  acceptor.accept(socket);
-
-A client that connects to this server might look like:
-
-  local::stream_protocol::endpoint ep("/tmp/foobar");
-  local::stream_protocol::socket socket(my_io_context);
-  socket.connect(ep);
-
-Transmission of file descriptors or credentials across UNIX domain sockets is
-not directly supported within Asio, but may be achieved by accessing the
-socket's underlying descriptor using the [link
-asio.reference.basic_socket.native_handle native_handle()] member function.
-
-[heading See Also]
-
-[link asio.reference.local__connect_pair local::connect_pair],
-[link asio.reference.local__datagram_protocol local::datagram_protocol],
-[link asio.reference.local__datagram_protocol.endpoint local::datagram_protocol::endpoint],
-[link asio.reference.local__datagram_protocol.socket local::datagram_protocol::socket],
-[link asio.reference.local__stream_protocol local::stream_protocol],
-[link asio.reference.local__stream_protocol.acceptor local::stream_protocol::acceptor],
-[link asio.reference.local__stream_protocol.endpoint local::stream_protocol::endpoint],
-[link asio.reference.local__stream_protocol.iostream local::stream_protocol::iostream],
-[link asio.reference.local__stream_protocol.socket local::stream_protocol::socket],
-[link asio.examples.cpp11_examples.unix_domain_sockets UNIX domain sockets examples].
-
-[heading Notes]
-
-UNIX domain sockets are only available at compile time if supported by the
-target operating system. A program may test for the macro
-`ASIO_HAS_LOCAL_SOCKETS` to determine whether they are supported.
-
-[endsect]
-
-[section:stream_descriptor Stream-Oriented File Descriptors]
-
-Asio includes classes added to permit synchronous and asynchronous read and
-write operations to be performed on POSIX file descriptors, such as pipes,
-standard input and output, and various devices.
-
-These classes also provide limited support for regular files. This support
-assumes that the underlying read and write operations provided by the operating
-system never fail with `EAGAIN` or `EWOULDBLOCK`. (This assumption normally
-holds for buffered file I/O.)  Synchronous and asynchronous read and write
-operations on file descriptors will succeed but the I/O will always be
-performed immediately. Wait operations, and operations involving
-`asio::null_buffers`, are not portably supported.
-
-For example, to perform read and write operations on standard input
-and output, the following objects may be created:
-
-  posix::stream_descriptor in(my_io_context, ::dup(STDIN_FILENO));
-  posix::stream_descriptor out(my_io_context, ::dup(STDOUT_FILENO));
-
-These are then used as synchronous or asynchronous read and write streams. This
-means the objects can be used with any of the [link asio.reference.read
-read()], [link asio.reference.async_read async_read()], [link
-asio.reference.write write()], [link asio.reference.async_write async_write()],
-[link asio.reference.read_until read_until()] or [link
-asio.reference.async_read_until async_read_until()] free functions.
-
-[heading See Also]
-
-[link asio.reference.posix__stream_descriptor posix::stream_descriptor],
-[link asio.examples.cpp11_examples.chat Chat example (C++11)].
-
-[heading Notes]
-
-POSIX stream descriptors are only available at compile time if supported by the
-target operating system. A program may test for the macro
-`ASIO_HAS_POSIX_STREAM_DESCRIPTOR` to determine whether they are supported.
-
-[endsect]
-
-[section:fork Fork]
-
-Asio supports programs that utilise the `fork()` system call. Provided the
-program calls `io_context.notify_fork()` at the appropriate times, Asio will
-recreate any internal file descriptors (such as the "self-pipe trick"
-descriptor used for waking up a reactor). The notification is usually performed
-as follows:
-
-  io_context_.notify_fork(asio::io_context::fork_prepare);
-  if (fork() == 0)
-  {
-    io_context_.notify_fork(asio::io_context::fork_child);
-    ...
-  }
-  else
-  {
-    io_context_.notify_fork(asio::io_context::fork_parent);
-    ...
-  }
-
-User-defined services can also be made fork-aware by overriding the
-`io_context::service::notify_fork()` virtual function.
-
-Note that any file descriptors accessible via Asio's public API (e.g. the
-descriptors underlying `basic_socket<>`, `posix::stream_descriptor`, etc.) are
-not altered during a fork. It is the program's responsibility to manage these
-as required.
-
-[heading See Also]
-
-[link asio.reference.io_context.notify_fork io_context::notify_fork()],
-[link asio.reference.io_context.fork_event io_context::fork_event],
-[link asio.reference.execution_context__service.notify_fork io_context::service::notify_fork()],
-[link asio.examples.cpp11_examples.fork Fork examples].
-
-[endsect]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.dot b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.dot
deleted file mode 100644
index 8717234..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.dot
+++ /dev/null
@@ -1,100 +0,0 @@
-digraph g
-{
-  edge
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      labelfontname="Helvetica",
-      labelfontsize=10
-    ];
-
-  node
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      shape=record
-    ];
-
-  initiator
-    [
-      label="Initiator"
-    ];
-
-  async_processor
-    [
-      label="Asynchronous\nOperation Processor"
-    ];
-
-  async_op
-    [
-      label="Asynchronous\nOperation"
-    ];
-
-  completion_queue
-    [
-      label="Completion\nEvent Queue"
-    ];
-
-  async_event_demuxer
-    [
-      label="Asynchronous\nEvent Demultiplexer"
-    ];
-
-  proactor
-    [
-      label="Proactor"
-    ];
-
-  handler
-    [
-      label="Completion\nHandler"
-    ];
-
-  initiator -> async_processor
-    [
-      label="uses",
-      style="dashed"
-    ];
-
-  initiator -> async_op
-    [
-      label="starts",
-      style="dashed"
-    ];
-
-  initiator -> handler
-    [
-      label="creates",
-      style="dashed"
-    ];
-
-  async_processor -> async_op
-    [
-      label="executes",
-      style="dashed"
-    ];
-
-  async_processor -> completion_queue
-    [
-      label="enqueues",
-      style="dashed"
-    ];
-
-  async_op -> handler;
-
-  async_event_demuxer -> completion_queue
-    [
-      label="dequeues",
-      style="dashed"
-    ];
-
-  proactor -> async_event_demuxer
-    [
-    ];
-
-  proactor -> handler
-    [
-      label="demultiplexes\n& dispatches"
-      style="dashed"
-    ];
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.png
deleted file mode 100644
index a0653b0..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/proactor.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/promises.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/promises.qbk
deleted file mode 100644
index a263718..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/promises.qbk
+++ /dev/null
@@ -1,96 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:promises Promises]
-
-[note This is an experimental feature.]
-
-The [link asio.reference.experimental__promise `experimental::promise`] type
-and [link asio.reference.experimental__use_promise `experimental::use_promise`]
-completion token allow eager execution and synchronisation of asynchronous
-operations. For example:
-
-  auto promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  ... do other stuff while the read is going on ...
-
-  promise.async_wait( // completion the operation
-      [](error_code ec, std::size_t bytes_read)
-      {
-        ...
-      });
-
-Promises can be safely disregarded if the result is no longer required.
-Different operations can be combined to either wait for all to complete or for
-one to complete (and cancel the rest). For example, to wait for one to
-complete:
-
-  auto timeout_promise =
-    timer.async_wait(
-      asio::experimental::use_promise);
-
-  auto read_promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  auto promise =
-    asio::experimental::make_parallel_group(
-      timeout_promise.async_wait(asio::deferred),
-      read_promise.async_wait(asio::deferred)
-    ).async_wait(
-      asio::experimental::wait_for_one(),
-      asio::experimental::use_promise);
-
-  promise.async_wait(
-      [](std::array<std::size_t, 2> order,
-         error_code timer_ec,
-         error_code read_ec, std::size_t read_size)
-      {
-        if (order[0] == 0)
-        {
-          // timed out
-        }
-        else
-        {
-          // completed in time
-        }
-      });
-
-or to wait for all to complete:
-
-  auto write_promise = async_write(
-      stream, asio::buffer(my_write_buffer),
-      asio::experimental::use_promise);
-
-  auto read_promise = async_read(
-      stream, asio::buffer(my_buffer),
-      asio::experimental::use_promise);
-
-  auto promise =
-    asio::experimental::make_parallel_group(
-      timeout_promise.async_wait(asio::deferred),
-      read_promise.async_wait(asio::deferred)
-    ).async_wait(
-      asio::experimental::wait_for_all(),
-      asio::experimental::use_promise);
-
-  promise.async_wait(
-      [](std::array<std::size_t, 2> order,
-         error_code timer_ec,
-         error_code read_ec, std::size_t read_size)
-      {
-        // ...
-      });
-
-[heading See Also]
-
-[link asio.reference.experimental__promise promise],
-[link asio.reference.experimental__use_promise use_promise].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/protocols.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/protocols.qbk
deleted file mode 100644
index 0199080..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/protocols.qbk
+++ /dev/null
@@ -1,149 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:protocols TCP, UDP and ICMP]
-
-Asio provides off-the-shelf support for the internet protocols TCP, UDP and
-ICMP.
-
-[heading TCP Clients]
-
-Hostname resolution is performed using a resolver, where host and service names
-are looked up and converted into one or more endpoints:
-
-  ip::tcp::resolver resolver(my_io_context);
-  ip::tcp::resolver::query query("www.boost.org", "http");
-  ip::tcp::resolver::iterator iter = resolver.resolve(query);
-  ip::tcp::resolver::iterator end; // End marker.
-  while (iter != end)
-  {
-    ip::tcp::endpoint endpoint = *iter++;
-    std::cout << endpoint << std::endl;
-  }
-
-The list of endpoints obtained above could contain both IPv4 and IPv6 endpoints,
-so a program should try each of them until it finds one that works. This keeps the
-client program independent of a specific IP version.
-
-To simplify the development of protocol-independent programs, TCP clients may
-establish connections using the free functions [link asio.reference.connect
-connect()] and [link asio.reference.async_connect async_connect()]. These
-operations try each endpoint in a list until the socket is successfully
-connected. For example, a single call:
-
-  ip::tcp::socket socket(my_io_context);
-  asio::connect(socket, resolver.resolve(query));
-
-will synchronously try all endpoints until one is successfully connected.
-Similarly, an asynchronous connect may be performed by writing:
-
-  asio::async_connect(socket_, iter,
-      boost::bind(&client::handle_connect, this,
-        asio::placeholders::error));
-
-  // ...
-
-  void handle_connect(const error_code& error)
-  {
-    if (!error)
-    {
-      // Start read or write operations.
-    }
-    else
-    {
-      // Handle error.
-    }
-  }
-
-When a specific endpoint is available, a socket can be created and connected:
-
-  ip::tcp::socket socket(my_io_context);
-  socket.connect(endpoint);
-
-Data may be read from or written to a connected TCP socket using the [link
-asio.reference.basic_stream_socket.receive receive()], [link
-asio.reference.basic_stream_socket.async_receive async_receive()], [link
-asio.reference.basic_stream_socket.send send()] or [link
-asio.reference.basic_stream_socket.async_send async_send()] member functions.
-However, as these could result in [link asio.overview.core.streams short writes
-or reads], an application will typically use the following operations instead:
-[link asio.reference.read read()], [link asio.reference.async_read
-async_read()], [link asio.reference.write write()] and [link
-asio.reference.async_write async_write()].
-
-[heading TCP Servers]
-
-A program uses an acceptor to accept incoming TCP connections:
-
-  ip::tcp::acceptor acceptor(my_io_context, my_endpoint);
-  ...
-  ip::tcp::socket socket(my_io_context);
-  acceptor.accept(socket);
-
-After a socket has been successfully accepted, it may be read from or written
-to as illustrated for TCP clients above.
-
-[heading UDP]
-
-UDP hostname resolution is also performed using a resolver:
-
-  ip::udp::resolver resolver(my_io_context);
-  ip::udp::resolver::query query("localhost", "daytime");
-  ip::udp::resolver::iterator iter = resolver.resolve(query);
-  ...
-
-A UDP socket is typically bound to a local endpoint. The following code will
-create an IP version 4 UDP socket and bind it to the "any" address on port
-`12345`:
-
-  ip::udp::endpoint endpoint(ip::udp::v4(), 12345);
-  ip::udp::socket socket(my_io_context, endpoint);
-
-Data may be read from or written to an unconnected UDP socket using the [link
-asio.reference.basic_datagram_socket.receive_from receive_from()], [link
-asio.reference.basic_datagram_socket.async_receive_from async_receive_from()],
-[link asio.reference.basic_datagram_socket.send_to send_to()] or [link
-asio.reference.basic_datagram_socket.async_send_to async_send_to()] member
-functions. For a connected UDP socket, use the [link
-asio.reference.basic_datagram_socket.receive receive()], [link
-asio.reference.basic_datagram_socket.async_receive async_receive()], [link
-asio.reference.basic_datagram_socket.send send()] or [link
-asio.reference.basic_datagram_socket.async_send async_send()] member functions.
-
-[heading ICMP]
-
-As with TCP and UDP, ICMP hostname resolution is performed using a resolver:
-
-  ip::icmp::resolver resolver(my_io_context);
-  ip::icmp::resolver::query query("localhost", "");
-  ip::icmp::resolver::iterator iter = resolver.resolve(query);
-  ...
-
-An ICMP socket may be bound to a local endpoint. The following code will create
-an IP version 6 ICMP socket and bind it to the "any" address:
-
-  ip::icmp::endpoint endpoint(ip::icmp::v6(), 0);
-  ip::icmp::socket socket(my_io_context, endpoint);
-
-The port number is not used for ICMP.
-
-Data may be read from or written to an unconnected ICMP socket using the [link
-asio.reference.basic_raw_socket.receive_from receive_from()], [link
-asio.reference.basic_raw_socket.async_receive_from async_receive_from()],
-[link asio.reference.basic_raw_socket.send_to send_to()] or [link
-asio.reference.basic_raw_socket.async_send_to async_send_to()] member
-functions.
-
-[heading See Also]
-
-[link asio.reference.ip__tcp ip::tcp],
-[link asio.reference.ip__udp ip::udp],
-[link asio.reference.ip__icmp ip::icmp],
-[link asio.tutorial.tutdaytime1 daytime protocol tutorials],
-[link asio.examples.cpp11_examples.icmp ICMP ping example].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/rationale.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/rationale.qbk
deleted file mode 100644
index e0d4d3f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/rationale.qbk
+++ /dev/null
@@ -1,54 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:rationale Rationale]
-
-Most programs interact with the outside world in some way, whether it be via a
-file, a network, a serial cable, or the console. Sometimes, as is the case with
-networking, individual I/O operations can take a long time to complete. This
-poses particular challenges to application development.
-
-Asio provides the tools to manage these long running operations, without
-requiring programs to use concurrency models based on threads and explicit
-locking.
-
-The Asio library is intended for programmers using C++ for systems programming,
-where access to operating system functionality such as networking is often
-required. In particular, Asio addresses the following goals:
-
-* [*Portability.] The library should support a range of commonly used operating
-systems, and provide consistent behaviour across these operating systems.
-
-* [*Scalability.] The library should facilitate the development of network
-applications that scale to thousands of concurrent connections. The library
-implementation for each operating system should use the mechanism that best
-enables this scalability.
-
-* [*Efficiency.] The library should support techniques such as scatter-gather
-I/O, and allow programs to minimise data copying.
-
-* [*Model concepts from established APIs, such as BSD sockets.] The
-BSD socket API is widely implemented and understood, and is covered in much
-literature. Other programming languages often use a similar interface for
-networking APIs. As far as is reasonable, Asio should leverage existing
-practice.
-
-* [*Ease of use.] The library should provide a lower entry barrier for new
-users by taking a toolkit, rather than framework, approach. That is, it should
-try to minimise the up-front investment in time to just learning a few basic
-rules and guidelines. After that, a library user should only need to understand
-the specific functions that are being used.
-
-* [*Basis for further abstraction.] The library should permit the development
-of other libraries that provide higher levels of abstraction. For example,
-implementations of commonly used protocols such as HTTP.
-
-Although Asio started life focused primarily on networking, its concepts of
-asynchronous I/O have been extended to include other operating system resources
-such as serial ports, file descriptors, and so on.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/reactor.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/reactor.qbk
deleted file mode 100644
index b7fdfd4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/reactor.qbk
+++ /dev/null
@@ -1,44 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:reactor Reactor-Style Operations]
-
-Sometimes a program must be integrated with a third-party library that wants to
-perform the I/O operations itself. To facilitate this, Asio includes
-synchronous and asynchronous operations that may be used to wait for a socket
-to become ready to read, ready to write, or to have a pending error condition.
-
-As an example, to perform a non-blocking read something like the following may
-be used:
-
-  ip::tcp::socket socket(my_io_context);
-  ...
-  socket.non_blocking(true);
-  ...
-  socket.async_wait(ip::tcp::socket::wait_read, read_handler);
-  ...
-  void read_handler(asio::error_code ec)
-  {
-    if (!ec)
-    {
-      std::vector<char> buf(socket.available());
-      socket.read_some(buffer(buf));
-    }
-  }
-  
-These operations are supported for sockets on all platforms, and for the POSIX
-stream-oriented descriptor classes.
-
-[heading See Also]
-
-[link asio.reference.basic_socket.wait basic_socket::wait()],
-[link asio.reference.basic_socket.async_wait basic_socket::async_wait()],
-[link asio.reference.basic_socket.non_blocking basic_socket::non_blocking()],
-[link asio.reference.basic_socket.native_non_blocking basic_socket::native_non_blocking()],
-[link asio.examples.cpp11_examples.nonblocking nonblocking example].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/serial_ports.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/serial_ports.qbk
deleted file mode 100644
index afee551..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/serial_ports.qbk
+++ /dev/null
@@ -1,45 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:serial_ports Serial Ports]
-
-Asio includes classes for creating and manipulating serial ports in a portable
-manner. For example, a serial port may be opened using:
-
-  serial_port port(my_io_context, name);
-
-where name is something like `"COM1"` on Windows, and `"/dev/ttyS0"` on POSIX
-platforms.
-
-Once opened, the serial port may be used as a [link asio.overview.core.streams
-stream]. This means the objects can be used with any of the [link
-asio.reference.read read()], [link asio.reference.async_read async_read()],
-[link asio.reference.write write()], [link asio.reference.async_write
-async_write()], [link asio.reference.read_until read_until()] or [link
-asio.reference.async_read_until async_read_until()] free functions.
-
-The serial port implementation also includes option classes for configuring the
-port's baud rate, flow control type, parity, stop bits and character size.
-
-[heading See Also]
-
-[link asio.reference.serial_port serial_port],
-[link asio.reference.serial_port_base serial_port_base],
-[link asio.reference.serial_port_base__baud_rate serial_port_base::baud_rate],
-[link asio.reference.serial_port_base__flow_control serial_port_base::flow_control],
-[link asio.reference.serial_port_base__parity serial_port_base::parity],
-[link asio.reference.serial_port_base__stop_bits serial_port_base::stop_bits],
-[link asio.reference.serial_port_base__character_size serial_port_base::character_size].
-
-[heading Notes]
-
-Serial ports are available on all POSIX platforms. For Windows, serial ports
-are only available at compile time when the I/O completion port backend is used
-(which is the default). A program may test for the macro
-`ASIO_HAS_SERIAL_PORT` to determine whether they are supported.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/signals.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/signals.qbk
deleted file mode 100644
index 1a37a14..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/signals.qbk
+++ /dev/null
@@ -1,43 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:signals Signal Handling]
-
-Asio supports signal handling using a class called [link
-asio.reference.signal_set signal_set]. Programs may add one or more signals to
-the set, and then perform an `async_wait()` operation. The specified handler
-will be called when one of the signals occurs. The same signal number may be
-registered with multiple [link asio.reference.signal_set signal_set] objects,
-however the signal number must be used only with Asio.
-
-  void handler(
-      const asio::error_code& error,
-      int signal_number)
-  {
-    if (!error)
-    {
-      // A signal occurred.
-    }
-  }
-
-  ...
-
-  // Construct a signal set registered for process termination.
-  asio::signal_set signals(io_context, SIGINT, SIGTERM);
-
-  // Start an asynchronous wait for one of the signals to occur.
-  signals.async_wait(handler);
-
-Signal handling also works on Windows, as the Microsoft Visual C++ runtime
-library maps console events like Ctrl+C to the equivalent signal.
-
-[heading See Also]
-
-[link asio.reference.signal_set signal_set],
-[link asio.examples.cpp11_examples.http_server HTTP server example (C++11)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/spawn.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/spawn.qbk
deleted file mode 100644
index 4a76155..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/spawn.qbk
+++ /dev/null
@@ -1,98 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:spawn Stackful Coroutines]
-
-The [link asio.reference.spawn `spawn()`] function is a high-level wrapper for
-running stackful coroutines. It is based on the Boost.Coroutine library. The
-`spawn()` function enables programs to implement asynchronous logic in a
-synchronous manner, as shown in the following example:
-
-  asio::spawn(my_strand, do_echo, asio::detached);
-
-  // ...
-
-  void do_echo(asio::yield_context yield)
-  {
-    try
-    {
-      char data[128];
-      for (;;)
-      {
-        std::size_t length =
-          my_socket.async_read_some(
-            asio::buffer(data), yield);
-
-        asio::async_write(my_socket,
-            asio::buffer(data, length), yield);
-      }
-    }
-    catch (std::exception& e)
-    {
-      // ...
-    }
-  }
-
-The first argument to `spawn()` may be an executor or execution context.
-This argument determines the context in which the coroutine is permitted to
-execute. For example, a server's per-client object may consist of multiple
-coroutines; they should all run on the same `strand` so that no explicit
-synchronisation is required.
-
-The second argument is a function object with signature:
-
-  void coroutine(asio::yield_context yield);
-
-that specifies the code to be run as part of the coroutine. The parameter
-`yield` may be passed to an asynchronous operation in place of the completion
-handler, as in:
-
-  std::size_t length =
-    my_socket.async_read_some(
-      asio::buffer(data), yield);
-
-This starts the asynchronous operation and suspends the coroutine. The
-coroutine will be resumed automatically when the asynchronous operation
-completes.
-
-Where an asynchronous operation's handler signature has the form:
-
-  void handler(asio::error_code ec, result_type result);
-
-the initiating function returns the result_type. In the `async_read_some`
-example above, this is `size_t`. If the asynchronous operation fails, the
-`error_code` is converted into a `system_error` exception and thrown.
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec);
-
-the initiating function returns `void`. As above, an error is passed back to
-the coroutine as a `system_error` exception.
-
-To collect the `error_code` from an operation, rather than have it throw an
-exception, associate the output variable with the `yield_context` as follows:
-
-  asio::error_code ec;
-  std::size_t length =
-    my_socket.async_read_some(
-      asio::buffer(data), yield[ec]);
-  
-[*Note:] if `spawn()` is used with a specified executor of type `Executor`, the
-function object signature is actually:
-  
-  void coroutine(asio::basic_yield_context<Executor> yield);
-
-[heading See Also]
-
-[link asio.reference.spawn spawn],
-[link asio.reference.yield_context yield_context],
-[link asio.reference.basic_yield_context basic_yield_context],
-[link asio.examples.cpp11_examples.spawn Spawn example (C++11)],
-[link asio.overview.composition.coroutine Stackless Coroutines].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/ssl.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/ssl.qbk
deleted file mode 100644
index 29542a7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/ssl.qbk
+++ /dev/null
@@ -1,123 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ssl SSL]
-
-Asio contains classes and class templates for basic SSL support. These classes
-allow encrypted communication to be layered on top of an existing stream, such
-as a TCP socket.
-
-Before creating an encrypted stream, an application must construct an SSL
-context object. This object is used to set SSL options such as verification
-mode, certificate files, and so on. As an illustration, client-side
-initialisation may look something like:
-
-  ssl::context ctx(ssl::context::sslv23);
-  ctx.set_verify_mode(ssl::verify_peer);
-  ctx.load_verify_file("ca.pem");
-
-To use SSL with a TCP socket, one may write:
-
-  ssl::stream<ip::tcp::socket> ssl_sock(my_io_context, ctx);
-
-To perform socket-specific operations, such as establishing an outbound
-connection or accepting an incoming one, the underlying socket must first be
-obtained using the `ssl::stream` template's [link
-asio.reference.ssl__stream.lowest_layer `lowest_layer()`] member function:
-
-  ip::tcp::socket::lowest_layer_type& sock = ssl_sock.lowest_layer();
-  sock.connect(my_endpoint);
-
-In some use cases the underlying stream object will need to have a longer
-lifetime than the SSL stream, in which case the template parameter should be a
-reference to the stream type:
-
-  ip::tcp::socket sock(my_io_context);
-  ssl::stream<ip::tcp::socket&> ssl_sock(sock, ctx);
-
-SSL handshaking must be performed prior to transmitting or receiving data over
-an encrypted connection. This is accomplished using the `ssl::stream`
-template's [link asio.reference.ssl__stream.handshake handshake()] or [link
-asio.reference.ssl__stream.async_handshake async_handshake()] member functions.
-
-Once connected, SSL stream objects are used as synchronous or asynchronous read
-and write streams. This means the objects can be used with any of the [link
-asio.reference.read read()], [link asio.reference.async_read async_read()],
-[link asio.reference.write write()], [link asio.reference.async_write
-async_write()], [link asio.reference.read_until read_until()] or [link
-asio.reference.async_read_until async_read_until()] free functions.
-
-[heading Certificate Verification]
-
-Asio provides various methods for configuring the way SSL certificates are
-verified:
-
-* [link asio.reference.ssl__context.set_default_verify_paths ssl::context::set_default_verify_paths()]
-* [link asio.reference.ssl__context.set_verify_mode ssl::context::set_verify_mode()]
-* [link asio.reference.ssl__context.set_verify_callback ssl::context::set_verify_callback()]
-* [link asio.reference.ssl__context.load_verify_file ssl::context::load_verify_file()]
-* [link asio.reference.ssl__stream.set_verify_mode ssl::stream::set_verify_mode()]
-* [link asio.reference.ssl__stream.set_verify_callback ssl::stream::set_verify_callback()]
-
-To simplify use cases where certificates are verified according to the rules in
-RFC 6125 (identity verification in the context of Transport Layer Security),
-Asio provides a reusable verification callback as a function object:
-
-* [link asio.reference.ssl__host_name_verification ssl::host_name_verification]
-
-The following example shows verification of a remote host's certificate
-according to the rules used by HTTPS:
-
-  using asio::ip::tcp;
-  namespace ssl = asio::ssl;
-  typedef ssl::stream<tcp::socket> ssl_socket;
-
-  // Create a context that uses the default paths for
-  // finding CA certificates.
-  ssl::context ctx(ssl::context::sslv23);
-  ctx.set_default_verify_paths();
-
-  // Open a socket and connect it to the remote host.
-  asio::io_context io_context;
-  ssl_socket sock(io_context, ctx);
-  tcp::resolver resolver(io_context);
-  tcp::resolver::query query("host.name", "https");
-  asio::connect(sock.lowest_layer(), resolver.resolve(query));
-  sock.lowest_layer().set_option(tcp::no_delay(true));
-
-  // Perform SSL handshake and verify the remote host's
-  // certificate.
-  sock.set_verify_mode(ssl::verify_peer);
-  sock.set_verify_callback(ssl::host_name_verification("host.name"));
-  sock.handshake(ssl_socket::client);
-
-  // ... read and write as normal ...
-
-[heading SSL and Threads]
-
-SSL stream objects perform no locking of their own. Therefore, it is essential
-that all asynchronous SSL operations are performed in an implicit or explicit
-[link asio.overview.core.strands strand]. Note that this means that no
-synchronisation is required (and so no locking overhead is incurred) in single
-threaded programs.
- 
-[heading See Also]
-
-[link asio.reference.ssl__context ssl::context],
-[link asio.reference.ssl__host_name_verification ssl::host_name_verification],
-[link asio.reference.ssl__stream ssl::stream],
-[link asio.examples.cpp11_examples.ssl SSL example (C++11)].
-
-[heading Notes]
-
-[@http://www.openssl.org OpenSSL] is required to make use of Asio's SSL
-support. When an application needs to use OpenSSL functionality that is not
-wrapped by Asio, the underlying OpenSSL types may be obtained by calling [link
-asio.reference.ssl__context.native_handle `ssl::context::native_handle()`] or
-[link asio.reference.ssl__stream.native_handle `ssl::stream::native_handle()`].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/strands.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/strands.qbk
deleted file mode 100644
index 06d94ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/strands.qbk
+++ /dev/null
@@ -1,114 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:strands Strands: Use Threads Without Explicit Locking]
-
-A strand is defined as a strictly sequential invocation of event handlers (i.e.
-no concurrent invocation). Use of strands allows execution of code in a
-multithreaded program without the need for explicit locking (e.g. using
-mutexes).
-
-Strands may be either implicit or explicit, as illustrated by the following
-alternative approaches:
-
-* Calling io_context::run() from only one thread means all event handlers
-  execute in an implicit strand, due to the io_context's guarantee that handlers
-  are only invoked from inside run().
-
-* Where there is a single chain of asynchronous operations associated with a
-  connection (e.g. in a half duplex protocol implementation like HTTP) there is
-  no possibility of concurrent execution of the handlers. This is an implicit
-  strand.
-
-* An explicit strand is an instance of `strand<>` or `io_context::strand`. All
-  event handler function objects need to be bound to the strand using
-  `asio::bind_executor()` or otherwise posted/dispatched through the strand
-  object.
-
-In the case of composed asynchronous operations, such as `async_read()` or
-`async_read_until()`, if a completion handler goes through a strand, then all
-intermediate handlers should also go through the same strand. This is needed to
-ensure thread safe access for any objects that are shared between the caller
-and the composed operation (in the case of `async_read()` it's the socket,
-which the caller can `close()` to cancel the operation).
-
-To achieve this, all asynchronous operations obtain the handler's associated
-executor by using the `get_associated_executor` function. For example:
-
-  asio::associated_executor_t<Handler> a = asio::get_associated_executor(h);
-
-The associated executor must satisfy the Executor requirements. It will be used
-by the asynchronous operation to submit both intermediate and final handlers
-for execution.
-
-The executor may be customised for a particular handler type by specifying a
-nested type `executor_type` and member function `get_executor()`:
-
-  class my_handler
-  {
-  public:
-    // Custom implementation of Executor type requirements.
-    typedef my_executor executor_type;
-
-    // Return a custom executor implementation.
-    executor_type get_executor() const noexcept
-    {
-      return my_executor();
-    }
-
-    void operator()() { ... }
-  };
-
-In more complex cases, the `associated_executor` template may be partially
-specialised directly:
-
-  struct my_handler
-  {
-    void operator()() { ... }
-  };
-
-  namespace asio {
-
-    template <class Executor>
-    struct associated_executor<my_handler, Executor>
-    {
-      // Custom implementation of Executor type requirements.
-      typedef my_executor type;
-
-      // Return a custom executor implementation.
-      static type get(const my_handler&,
-          const Executor& = Executor()) noexcept
-      {
-        return my_executor();
-      }
-    };
-
-  } // namespace asio
-
-The `asio::bind_executor()` function is a helper to bind a specific executor
-object, such as a strand, to a completion handler. This binding automatically
-associates an executor as shown above. For example, to bind a strand to a
-completion handler we would simply write:
-
-  my_socket.async_read_some(my_buffer,
-      asio::bind_executor(my_strand,
-        [](error_code ec, size_t length)
-        {
-          // ...
-        }));
-
-[heading See Also]
-
-[link asio.reference.associated_executor associated_executor],
-[link asio.reference.get_associated_executor get_associated_executor],
-[link asio.reference.bind_executor bind_executor],
-[link asio.reference.strand strand],
-[link asio.reference.io_context__strand io_context::strand],
-[link asio.tutorial.tuttimer5 tutorial Timer.5],
-[link asio.examples.cpp11_examples.http_server_3 HTTP server 3 example].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/streams.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/streams.qbk
deleted file mode 100644
index 928c770..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/streams.qbk
+++ /dev/null
@@ -1,62 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:streams Streams, Short Reads and Short Writes]
-
-Many I/O objects in Asio are stream-oriented. This means that:
-
-* There are no message boundaries. The data being transferred is a continuous
-  sequence of bytes.
-
-* Read or write operations may transfer fewer bytes than requested. This is
-  referred to as a short read or short write.
-
-Objects that provide stream-oriented I/O model one or more of the following
-type requirements:
-
-* `SyncReadStream`, where synchronous read operations are performed using a
-  member function called `read_some()`.
-
-* `AsyncReadStream`, where asynchronous read operations are performed using a
-  member function called `async_read_some()`.
-
-* `SyncWriteStream`, where synchronous write operations are performed using a
-  member function called `write_some()`.
-
-* `AsyncWriteStream`, where asynchronous write operations are performed using a
-  member function called `async_write_some()`.
-
-Examples of stream-oriented I/O objects include `ip::tcp::socket`,
-`ssl::stream<>`, `posix::stream_descriptor`, `windows::stream_handle`, etc.
-
-Programs typically want to transfer an exact number of bytes. When a short read
-or short write occurs the program must restart the operation, and continue to
-do so until the required number of bytes has been transferred. Asio provides
-generic functions that do this automatically: `read()`, `async_read()`,
-`write()` and `async_write()`.
-
-[heading Why EOF is an Error]
-
-* The end of a stream can cause `read`, `async_read`, `read_until` or
-  `async_read_until` functions to violate their contract. E.g.
-  a read of N bytes may finish early due to EOF.
-
-* An EOF error may be used to distinguish the end of a stream from a successful
-  read of size 0.
-
-[heading See Also]
-
-[link asio.reference.async_read async_read()],
-[link asio.reference.async_write async_write()],
-[link asio.reference.read read()],
-[link asio.reference.write write()],
-[link asio.reference.AsyncReadStream AsyncReadStream],
-[link asio.reference.AsyncWriteStream AsyncWriteStream],
-[link asio.reference.SyncReadStream SyncReadStream],
-[link asio.reference.SyncWriteStream SyncWriteStream].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.dot b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.dot
deleted file mode 100644
index 3de57b5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.dot
+++ /dev/null
@@ -1,67 +0,0 @@
-digraph g
-{
-  graph
-    [
-      nodesep="0.6"
-    ];
-
-  edge
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      labelfontname="Helvetica",
-      labelfontsize=10
-    ];
-
-  node
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      shape=box
-    ];
-
-  edge
-    [
-      arrowhead="open"
-    ]
-
-  // Program elements.
-  {
-    operating_system [ label="Operating System", shape=ellipse ];
-    io_context [ label="I/O Execution Context\ne.g. io_context" ];
-    io_object [ label="I/O Object\ne.g. socket" ];
-    your_program [ label="Your Program" ];
-  }
-
-  // Owning relationships.
-  {
-    edge [ arrowtail="diamond" ];
-    your_program:w -> io_object:nw;
-    your_program:se -> io_context:ne;
-  }
-
-  // Non-owning relationships;
-  {
-    io_object:sw -> io_context:w;
-  }
-
-  // Actions.
-  {
-    edge [ style="dashed", color="#808080" ];
-
-    // Forward actions.
-    {
-      your_program:sw -> io_object:n [ label="1" ];
-      io_object:s -> io_context:nw [ label="2" ];
-      io_context:sw -> operating_system:nw [ label="3" ];
-    }
-
-    // Reverse actions.
-    {
-      edge [ arrowhead="none", arrowtail="open" ];
-      io_context:se -> operating_system:ne [ label="4" ];
-      io_object:se -> io_context:n [ label="5" ];
-      your_program:s -> io_object:ne [ label="6" ];
-    }
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.png b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.png
deleted file mode 100644
index baa5a56..0000000
Binary files a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/sync_op.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/threads.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/threads.qbk
deleted file mode 100644
index 3f62c08..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/threads.qbk
+++ /dev/null
@@ -1,67 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:threads Threads and Asio]
-
-[heading Thread Safety]
-
-In general, it is safe to make concurrent use of distinct objects, but unsafe
-to make concurrent use of a single object. However, types such as `io_context`
-provide a stronger guarantee that it is safe to use a single object
-concurrently.
-
-[heading Thread Pools]
-
-Multiple threads may call `io_context::run()` to set up a pool of threads from
-which completion handlers may be invoked. This approach may also be used with
-`post()` as a means to perform arbitrary computational tasks across a thread
-pool.
-
-Note that all threads that have joined an `io_context`'s pool are considered
-equivalent, and the `io_context` may distribute work across them in an
-arbitrary fashion.
-
-[heading Internal Threads]
-
-The implementation of this library for a particular platform may make use of
-one or more internal threads to emulate asynchronicity. As far as possible,
-these threads must be invisible to the library user. In particular, the threads:
-
-* must not call the user's code directly; and
-
-* must block all signals.
-
-This approach is complemented by the following guarantee:
-
-* Asynchronous completion handlers will only be called from threads that are
-  currently calling `io_context::run()`.
-
-Consequently, it is the library user's responsibility to create and manage all
-threads to which the notifications will be delivered.
-
-The reasons for this approach include:
-
-* By only calling `io_context::run()` from a single thread, the user's code can
-  avoid the development complexity associated with synchronisation. For
-  example, a library user can implement scalable servers that are
-  single-threaded (from the user's point of view).
-
-* A library user may need to perform initialisation in a thread shortly after
-  the thread starts and before any other application code is executed. For
-  example, users of Microsoft's COM must call `CoInitializeEx` before any other
-  COM operations can be called from that thread.
-
-* The library interface is decoupled from interfaces for thread creation and
-  management, and permits implementations on platforms where threads are not
-  available.
-
-[heading See Also]
-
-[link asio.reference.io_context io_context],
-[link asio.reference.post post].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/timers.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/timers.qbk
deleted file mode 100644
index d7657a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/timers.qbk
+++ /dev/null
@@ -1,53 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:timers Timers]
-
-Long running I/O operations will often have a deadline by which they must have
-completed. These deadlines may be expressed as absolute times, but are often
-calculated relative to the current time.
-
-As a simple example, to perform a synchronous wait operation on a timer using a
-relative time one may write:
-
-  io_context i;
-  ...
-  steady_timer t(i);
-  t.expires_after(chrono::seconds(5));
-  t.wait();
-
-More commonly, a program will perform an asynchronous wait operation on a
-timer:
-
-  void handler(asio::error_code ec) { ... }
-  ...
-  io_context i;
-  ...
-  steady_timer t(i);
-  t.expires_after(chrono::milliseconds(400));
-  t.async_wait(handler);
-  ...
-  i.run();
-
-The deadline associated with a timer may also be obtained as an absolute time:
-
-  steady_timer::time_point time_of_expiry = t.expiry();
-
-which allows composition of timers:
-
-  steady_timer t2(i);
-  t2.expires_at(t.expiry() + chrono::seconds(30));
-
-[heading See Also]
-
-[link asio.reference.basic_waitable_timer basic_waitable_timer],
-[link asio.reference.steady_timer steady_timer],
-[link asio.reference.system_timer system_timer],
-[link asio.reference.high_resolution_timer high_resolution_timer],
-[link asio.tutorial.tuttimer1 timer tutorials].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/token_adapters.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/token_adapters.qbk
deleted file mode 100644
index 56a1b28..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/token_adapters.qbk
+++ /dev/null
@@ -1,245 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:token_adapters Completion Token Adapters]
-
-A ['completion token adapter] is a utility that can be generically applied to a
-[link asio.overview.model.completion_tokens completion token], to produce a new
-completion token with modified behaviour. Common uses of completion token
-adapters include:
-
-* Automatically wrapping the completion handler to add [link
-  asio.overview.model.associators associated characteristics].
-
-* Transforming the completion signature and arguments passed to the completion
-  handler.
-
-Asio includes a number of completion token adapters as described below.
-
-[heading bind_executor, bind_allocator, bind_cancellation_slot, and bind_immediate_executor]
-
-The [link asio.reference.bind_executor `bind_executor`] function adapts a
-completion token to imbue the completion handler with an [link
-asio.overview.model.executors associated executor].
-
-This example shows the `bind_executor` adapter applied to a lambda, to specify
-that the handler should execute in the specified strand. The arguments to the
-completion handler are passed through as-is.
-
-  my_socket.async_read_some(my_buffer,
-      asio::bind_executor(my_strand,
-        [](asio::error_code error, std::size_t bytes_transferred)
-        {
-          // ...
-        }));
-
-When applied to completion tokens that cause the initiating function to produce
-a result, such as [link asio.reference.use_awaitable `use_awaitable`], the
-result is returned unmodified.
-
-  asio::awaitable<void> my_coroutine()
-  {
-    // ...
-    std::size_t bytes_transferred =
-      co_await my_socket.async_read_some(my_buffer,
-        asio::bind_executor(my_strand, asio::use_awaitable));
-    // ...
-  }
-
-The [link asio.reference.bind_allocator `bind_allocator`], [link
-asio.reference.bind_cancellation_slot `bind_cancellation_slot`], and [link
-asio.reference.bind_immediate_executor `bind_immediate_executor`] adapters
-work similarly, to imbue the completion handler with an [link
-asio.overview.model.allocators associated allocator], [link
-asio.overview.model.cancellation associated cancellation slot], and
-associated immediate executor respectively.
-
-[heading redirect_error]
-
-The [link asio.reference.redirect_error `redirect_error`] function adapts a
-completion token to capture the `error_code` produced by an operation into a
-specified variable. In doing so, it modifies the completion signature to remove
-the initial `error_code` parameter.
-
-This example shows the `redirect_error` adapter applied to a lambda, to specify
-that the error should be captured into `my_error`. The `error_code` is no
-longer passed to the completion handler, but the remaining arguments are passed
-through as-is.
-
-  asio::error_code my_error; // N.B. must be valid until operation completes
-  // ...
-  my_socket.async_read_some(my_buffer,
-      asio::redirect_error(
-        [](std::size_t bytes_transferred)
-        {
-          // ...
-        }, my_error));
-
-When applied to completion tokens that cause the initiating function to produce
-a result, such as [link asio.reference.use_awaitable `use_awaitable`], the
-result is returned unmodified. However, if the operation fails, the `co_await`
-expression will no longer throw an exception on resumption.
-
-  asio::awaitable<void> my_coroutine()
-  {
-    // ...
-    asio::error_code my_error;
-    std::size_t bytes_transferred =
-      co_await my_socket.async_read_some(my_buffer,
-        asio::redirect_error(asio::use_awaitable, my_error));
-    // ...
-  }
-
-[heading as_tuple]
-
-The [link asio.reference.as_tuple `as_tuple`] adapter can be used to specify
-that the completion handler arguments should be combined into a single tuple
-argument.
-
-For example, the `as_tuple` adapter may be used in conjunction with [link
-asio.reference.use_awaitable `use_awaitable`] and structured bindings as
-follows:
-
-  auto [e, n] =
-    co_await my_socket.async_read_some(my_buffer,
-      asio::as_tuple(asio::use_awaitable));
-
-This adapter may also be used as a default completion token:
-
-  using default_token = asio::as_tuple_t<asio::use_awaitable_t<>>;
-  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-  // ...
-  asio::awaitable<void> do_read(tcp_socket my_socket)
-  {
-    // ...
-    auto [e, n] = co_await my_socket.async_read_some(my_buffer);
-    // ...
-  }
-
-[heading as_single]
-
-[note This is an experimental feature.]
-
-The [link asio.reference.experimental__as_single `experimental::as_single`]
-adapter can be used to specify that the completion handler
-arguments should be combined into a single argument. For completion signatures
-with a single parameter, the argument is passed through as-is. For signatures
-with two or more parameters, the arguments are combined into a tuple.
-
-For example, when applied to a timer wait operation, the single `error_code`
-argument is passed directly to the completion handler:
-
-  my_timer.async_wait(
-      asio::experimental::as_single(
-        [](asio::error_code error)
-        {
-          // ...
-        }));
-
-When applied to a socket read operation, where the completion signature
-specifies two parameters, the handler is passed the result as a tuple:
-
-  my_socket.async_read_some(my_buffer,
-      asio::experimental::as_single,
-        [](std::tuple<asio::error_code, std::size_t> result)
-        {
-          // ...
-        }));
-
-[heading append]
-
-The [link asio.reference.append `append`] completion token adapter can be
-used to pass additional completion handler arguments at the end of the
-completion signature.
-
-For example:
-
-  timer.async_wait(
-      asio::append(
-        [](std::error_code ec, int i)
-        {
-          // ...
-        },
-        42
-      )
-    );
-
-  std::future<int> f = timer.async_wait(
-      asio::append(
-        asio::use_future,
-        42
-      )
-    );
-
-[heading prepend]
-
-The [link asio.reference.prepend `prepend`] completion token adapter can be
-used to pass additional completion handler arguments before the existing
-completion handler arguments.
-
-For example:
-
-  timer.async_wait(
-      asio::prepend(
-        [](int i, std::error_code ec)
-        {
-          // ...
-        },
-        42
-      )
-    );
-
-  std::future<std::tuple<int, std::error_code>> f = timer.async_wait(
-      asio::prepend(
-        asio::use_future,
-        42
-      )
-    );
-
-[heading consign]
-
-The [link asio.reference.consign `consign`] completion token adapter can be
-used to attach additional values to a completion handler. This is typically used
-to keep at least one copy of an object, such as a smart pointer, alive until the
-completion handler is called.
-
-For example:
-
-  auto timer1 = std::make_shared<asio::steady_timer>(my_io_context);
-  timer1->expires_after(std::chrono::seconds(1));
-  timer1->async_wait(
-      asio::consign(
-        [](std::error_code ec)
-        {
-          // ...
-        },
-        timer1
-      )
-    );
-
-  auto timer2 = std::make_shared<asio::steady_timer>(my_io_context);
-  timer2->expires_after(std::chrono::seconds(30));
-  std::future<void> f =
-    timer2->async_wait(
-      asio::consign(
-        asio::use_future,
-        timer2
-      )
-    );
-
-[heading See Also]
-
-[link asio.reference.bind_executor bind_executor],
-[link asio.reference.bind_allocator bind_allocator],
-[link asio.reference.bind_cancellation_slot bind_cancellation_slot],
-[link asio.reference.redirect_error redirect_error],
-[link asio.reference.as_tuple as_tuple],
-[link asio.reference.experimental__as_single experimental::as_single],
-[link asio.reference.append append],
-[link asio.reference.prepend prepend].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/type_erasure.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/type_erasure.qbk
deleted file mode 100644
index 3d040bc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/type_erasure.qbk
+++ /dev/null
@@ -1,91 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:type_erasure Type Erasure, Separate Compilation and Virtual Functions]
-
-The `any_completion_handler<>` class template can be used to type-erase
-completion handlers. This template stores a completion handler in a
-runtime-polymorphic wrapper, and forwards the function call operator,
-associated executor, associated allocator, and associated cancellation slot to
-the target handler.
-
-One use case is to enable separate compilation of asynchronous operation
-implementations. For example, we can declare our implementation function in a
-header file, and provide a thin asynchronous operation wrapper:
-
-  void async_sleep_impl(
-      asio::any_completion_handler<void(asio::error_code)> handler,
-      asio::any_io_executor ex, std::chrono::nanoseconds duration);
-
-  template <typename CompletionToken>
-  inline auto async_sleep(asio::any_io_executor ex,
-      std::chrono::nanoseconds duration, CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(asio::error_code)>(
-        async_sleep_impl, token, std::move(ex), duration);
-  }
-
-By wrapping a call to `async_initiate`, the `async_sleep` template function
-adds full support for completion tokens. The definition of `async_sleep_impl`
-is then put into a separately compiled source file:
-
-  void async_sleep_impl(
-      asio::any_completion_handler<void(asio::error_code)> handler,
-      asio::any_io_executor ex, std::chrono::nanoseconds duration)
-  {
-    auto timer = std::make_shared<asio::steady_timer>(ex, duration);
-    timer->async_wait(asio::consign(std::move(handler), timer));
-  }
-
-Another use for `any_completion_handler<>` is to vary the implementation behind
-an asynchronous operation at runtime, by using virtual functions:
-
-  class line_reader
-  {
-  public:
-    // ...
-
-    template <typename CompletionToken>
-    auto async_read_line(std::string prompt, CompletionToken&& token)
-    {
-      return asio::async_initiate<
-        CompletionToken, void(asio::error_code, std::string)>(
-          [](auto handler, line_reader* self, std::string prompt)
-          {
-            self->async_read_line_impl(std::move(prompt), std::move(handler));
-          }, token, this, prompt);
-    }
-
-  private:
-    virtual void async_read_line_impl(std::string prompt,
-        asio::any_completion_handler<
-          void(asio::error_code, std::string)> handler) = 0;
-  };
-
-A derived class provides the implementation of the operation:
-
-  class stdin_line_reader : public line_reader
-  {
-  private:
-    // ...
-
-    void async_read_line_impl(std::string prompt,
-        asio::any_completion_handler<
-          void(asio::error_code, std::string)> handler) override
-    {
-      // ...
-    }
-  };
-
-[heading See Also]
-
-[link asio.reference.any_completion_handler any_completion_handler],
-[link asio.examples.cpp11_examples.type_erasure type erasure examples (C++11)],
-[link asio.examples.cpp20_examples.type_erasure type erasure examples (C++20)].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/windows.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/windows.qbk
deleted file mode 100644
index 0a9c9d7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/overview/windows.qbk
+++ /dev/null
@@ -1,126 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:windows Windows-Specific Functionality]
-
-[link asio.overview.windows.stream_handle Stream-Oriented HANDLEs]
-
-[link asio.overview.windows.random_access_handle Random-Access HANDLEs]
-
-[link asio.overview.windows.object_handle Object HANDLEs]
-
-[section:stream_handle Stream-Oriented HANDLEs]
-
-Asio contains classes to allow asynchronous read and write operations to be
-performed on Windows `HANDLE`s, such as named pipes.
-
-For example, to perform asynchronous operations on a named pipe, the following
-object may be created:
-
-  HANDLE handle = ::CreateFile(...);
-  windows::stream_handle pipe(my_io_context, handle);
-
-These are then used as synchronous or asynchronous read and write streams. This
-means the objects can be used with any of the [link asio.reference.read
-read()], [link asio.reference.async_read async_read()], [link
-asio.reference.write write()], [link asio.reference.async_write
-async_write()], [link asio.reference.read_until read_until()] or [link
-asio.reference.async_read_until async_read_until()] free functions.
-
-The kernel object referred to by the `HANDLE` must support use with I/O
-completion ports (which means that named pipes are supported, but anonymous
-pipes and console streams are not).
-
-[heading See Also]
-
-[link asio.reference.windows__stream_handle windows::stream_handle].
-
-[heading Notes]
-
-Windows stream `HANDLE`s are only available at compile time when targeting
-Windows and only when the I/O completion port backend is used (which is the
-default). A program may test for the macro `ASIO_HAS_WINDOWS_STREAM_HANDLE` to
-determine whether they are supported.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section:random_access_handle Random-Access HANDLEs]
-
-Asio provides Windows-specific classes that permit asynchronous read and write
-operations to be performed on HANDLEs that refer to regular files.
-
-For example, to perform asynchronous operations on a file the following object
-may be created:
-
-  HANDLE handle = ::CreateFile(...);
-  windows::random_access_handle file(my_io_context, handle);
-
-Data may be read from or written to the handle using one of the
-`read_some_at()`, `async_read_some_at()`, `write_some_at()` or
-`async_write_some_at()` member functions. However, like the equivalent
-functions (`read_some()`, etc.) on streams, these functions are only required
-to transfer one or more bytes in a single operation. Therefore free functions
-called [link asio.reference.read_at read_at()], [link
-asio.reference.async_read_at async_read_at()], [link asio.reference.write_at
-write_at()] and [link asio.reference.async_write_at async_write_at()] have been
-created to repeatedly call the corresponding [^[**]_some_at()] function until
-all data has been transferred.
-
-[heading See Also]
-
-[link asio.reference.windows__random_access_handle windows::random_access_handle].
-
-[heading Notes]
-
-Windows random-access `HANDLE`s are only available at compile time when
-targeting Windows and only when the I/O completion port backend is used (which
-is the default). A program may test for the macro
-`ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE` to determine whether they are
-supported.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section:object_handle Object HANDLEs]
-
-Asio provides Windows-specific classes that permit asynchronous wait operations
-to be performed on HANDLEs to kernel objects of the following types:
-
-* Change notification
-* Console input
-* Event
-* Memory resource notification
-* Process
-* Semaphore
-* Thread
-* Waitable timer
-
-For example, to perform asynchronous operations on an event, the following
-object may be created:
-
-  HANDLE handle = ::CreateEvent(...);
-  windows::object_handle file(my_io_context, handle);
-
-The `wait()` and `async_wait()` member functions may then be used to wait until
-the kernel object is signalled.
-
-[heading See Also]
-
-[link asio.reference.windows__object_handle windows::object_handle].
-
-[heading Notes]
-
-Windows object `HANDLE`s are only available at compile time when targeting
-Windows. Programs may test for the macro `ASIO_HAS_WINDOWS_OBJECT_HANDLE` to
-determine whether they are supported.
-
-[endsect]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.pl
deleted file mode 100755
index c7901d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.pl
+++ /dev/null
@@ -1,91 +0,0 @@
-#!/usr/bin/perl -w
-
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-use strict;
-
-open(my $fh, "<../../include/asio/detail/config.hpp") or die("can't open config.hpp");
-
-my $current_comment = "";
-my %has_macros = ();
-my %disable_macros = ();
-
-while (my $line = <$fh>)
-{
-  chomp($line);
-  if ($line =~ /^$/)
-  {
-    $current_comment = "";
-  }
-  elsif ($line =~ /^\/\/ (.*)$/)
-  {
-    if (!($line =~ /boostify/))
-    {
-      $current_comment = $current_comment . $1 . "\n";
-    }
-  }
-  elsif ($line =~ /^# *define *ASIO_HAS_([A-Z-0-9_]*) 1/)
-  {
-    if (not defined($has_macros{$1}))
-    {
-      $has_macros{$1} = $current_comment;
-    }
-  }
-  elsif ($line =~ /ASIO_DISABLE_([A-Z-0-9_]*)/)
-  {
-    $disable_macros{$1} = 1;
-  }
-}
-
-my $intro = <<EOF;
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[heading Compiler/platform feature detection macros]
-
-Asio automatically defines preprocessor macros corresponding to the detected
-available features on a particular compiler and target platform. These macros
-are named with the prefix `ASIO_HAS_`, and are listed in the table below.
-
-Many of these macros also have a corresponding `ASIO_DISABLE_` macro that may
-be used to explicitly disable the feature.
-
-In general, `ASIO_HAS_` macros should not be explicitly defined by the user,
-except when absolutely required as a workaround for the latest version of a
-compiler or platform. For older compiler/platform combinations where a specific
-`ASIO_HAS_` macro is not automatically defined, testing may have shown that a
-claimed feature isn't sufficiently conformant to be compatible with Asio's
-needs.
-EOF
-
-print("$intro\n");
-print("[table\n");
-print("  [[Macro][Description][Macro to disable feature]]\n");
-for my $macro (sort keys %has_macros)
-{
-  print("  [\n");
-  print("    [`ASIO_HAS_$macro`]\n");
-  print("    [\n");
-  my $description = $has_macros{$macro};
-  chomp($description);
-  $description =~ s/\n/\n      /g;
-  print("      $description\n");
-  print("    ]\n");
-  if (defined $disable_macros{$macro})
-  {
-    print("    [`ASIO_DISABLE_$macro`]\n");
-  }
-  else
-  {
-    print("    []\n");
-  }
-  print("  ]\n");
-}
-print("]\n");
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.qbk
deleted file mode 100644
index 9aac63d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/platform_macros.qbk
+++ /dev/null
@@ -1,728 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[heading Compiler/platform feature detection macros]
-
-Asio automatically defines preprocessor macros corresponding to the detected
-available features on a particular compiler and target platform. These macros
-are named with the prefix `ASIO_HAS_`, and are listed in the table below.
-
-Many of these macros also have a corresponding `ASIO_DISABLE_` macro that may
-be used to explicitly disable the feature.
-
-In general, `ASIO_HAS_` macros should not be explicitly defined by the user,
-except when absolutely required as a workaround for the latest version of a
-compiler or platform. For older compiler/platform combinations where a specific
-`ASIO_HAS_` macro is not automatically defined, testing may have shown that a
-claimed feature isn't sufficiently conformant to be compatible with Asio's
-needs.
-
-[table
-  [[Macro][Description][Macro to disable feature]]
-  [
-    [`ASIO_HAS_ALIAS_TEMPLATES`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_ALIGNOF`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_BOOST_ALIGN`]
-    [
-      Boost align library.
-    ]
-    [`ASIO_DISABLE_BOOST_ALIGN`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_ARRAY`]
-    [
-      Boost array library.
-    ]
-    [`ASIO_DISABLE_BOOST_ARRAY`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_ASSERT`]
-    [
-      Boost assert macro.
-    ]
-    [`ASIO_DISABLE_BOOST_ASSERT`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_BIND`]
-    [
-      Boost bind function.
-    ]
-    [`ASIO_DISABLE_BOOST_BIND`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_CHRONO`]
-    [
-      Boost support for chrono.
-    ]
-    [`ASIO_DISABLE_BOOST_CHRONO`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_CONFIG`]
-    [
-      Boost.Config library is available.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_BOOST_CONTEXT_FIBER`]
-    [
-      Boost support for the Context library's fibers.
-    ]
-    [`ASIO_DISABLE_BOOST_CONTEXT_FIBER`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_COROUTINE`]
-    [
-      Boost support for the Coroutine library.
-    ]
-    [`ASIO_DISABLE_BOOST_COROUTINE`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_DATE_TIME`]
-    [
-      Boost support for the DateTime library.
-    ]
-    [`ASIO_DISABLE_BOOST_DATE_TIME`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_LIMITS`]
-    [
-      Boost limits header.
-    ]
-    [`ASIO_DISABLE_BOOST_LIMITS`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_REGEX`]
-    [
-      Boost regex library.
-    ]
-    [`ASIO_DISABLE_BOOST_REGEX`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_SOURCE_LOCATION`]
-    [
-      Boost support for source_location and system errors.
-    ]
-    [`ASIO_DISABLE_BOOST_SOURCE_LOCATION`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_THROW_EXCEPTION`]
-    [
-      Boost throw_exception function.
-    ]
-    [`ASIO_DISABLE_BOOST_THROW_EXCEPTION`]
-  ]
-  [
-    [`ASIO_HAS_BOOST_WORKAROUND`]
-    [
-      Boost's BOOST_WORKAROUND macro.
-    ]
-    [`ASIO_DISABLE_BOOST_WORKAROUND`]
-  ]
-  [
-    [`ASIO_HAS_CHRONO`]
-    [
-      Some form of chrono library is available.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_CLANG_LIBCXX`]
-    [
-      Clang / libc++ detection.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_CONCEPTS`]
-    [
-      Support concepts on compilers known to allow them.
-    ]
-    [`ASIO_DISABLE_CONCEPTS`]
-  ]
-  [
-    [`ASIO_HAS_CONSTANT_EXPRESSION_SFINAE`]
-    [
-      Support SFINAE use of constant expressions on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_CONSTANT_EXPRESSION_SFINAE`]
-  ]
-  [
-    [`ASIO_HAS_CONSTEXPR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_CO_AWAIT`]
-    [
-      Support the co_await keyword on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_CO_AWAIT`]
-  ]
-  [
-    [`ASIO_HAS_CSTDINT`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_CXX11_ALLOCATORS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_DECLTYPE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_DEV_POLL`]
-    [
-      Solaris: /dev/poll.
-    ]
-    [`ASIO_DISABLE_DEV_POLL`]
-  ]
-  [
-    [`ASIO_HAS_ENUM_CLASS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_EPOLL`]
-    [
-      Linux: epoll, eventfd, timerfd and io_uring.
-    ]
-    [`ASIO_DISABLE_EPOLL`]
-  ]
-  [
-    [`ASIO_HAS_EVENTFD`]
-    [
-      Linux: epoll, eventfd, timerfd and io_uring.
-    ]
-    [`ASIO_DISABLE_EVENTFD`]
-  ]
-  [
-    [`ASIO_HAS_FILE`]
-    [
-      Files.
-    ]
-    [`ASIO_DISABLE_FILE`]
-  ]
-  [
-    [`ASIO_HAS_GETADDRINFO`]
-    [
-      Can use getaddrinfo() and getnameinfo().
-    ]
-    [`ASIO_DISABLE_GETADDRINFO`]
-  ]
-  [
-    [`ASIO_HAS_HANDLER_HOOKS`]
-    [
-      Handler hooking. Disabled for ancient Borland C++ and gcc compilers.
-    ]
-    [`ASIO_DISABLE_HANDLER_HOOKS`]
-  ]
-  [
-    [`ASIO_HAS_IOCP`]
-    [
-      Windows: IO Completion Ports.
-    ]
-    [`ASIO_DISABLE_IOCP`]
-  ]
-  [
-    [`ASIO_HAS_IO_URING_AS_DEFAULT`]
-    [
-      Linux: io_uring is used instead of epoll.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_KQUEUE`]
-    [
-      Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
-    ]
-    [`ASIO_DISABLE_KQUEUE`]
-  ]
-  [
-    [`ASIO_HAS_LOCAL_SOCKETS`]
-    [
-      UNIX domain sockets.
-    ]
-    [`ASIO_DISABLE_LOCAL_SOCKETS`]
-  ]
-  [
-    [`ASIO_HAS_MOVE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_MSG_NOSIGNAL`]
-    [
-      Kernel support for MSG_NOSIGNAL.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_NOEXCEPT`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_NOEXCEPT_FUNCTION_TYPE`]
-    [
-      Support noexcept on function types on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_NOEXCEPT_FUNCTION_TYPE`]
-  ]
-  [
-    [`ASIO_HAS_NULLPTR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_PIPE`]
-    [
-      Pipes.
-    ]
-    [`ASIO_DISABLE_PIPE`]
-  ]
-  [
-    [`ASIO_HAS_POSIX_STREAM_DESCRIPTOR`]
-    [
-      POSIX: stream-oriented file descriptors.
-    ]
-    [`ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR`]
-  ]
-  [
-    [`ASIO_HAS_PTHREADS`]
-    [
-      POSIX threads.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_REF_QUALIFIED_FUNCTIONS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_RETURN_TYPE_DEDUCTION`]
-    [
-      Support return type deduction on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_RETURN_TYPE_DEDUCTION`]
-  ]
-  [
-    [`ASIO_HAS_SECURE_RTL`]
-    [
-      Microsoft Visual C++'s secure C runtime library.
-    ]
-    [`ASIO_DISABLE_SECURE_RTL`]
-  ]
-  [
-    [`ASIO_HAS_SERIAL_PORT`]
-    [
-      Serial ports.
-    ]
-    [`ASIO_DISABLE_SERIAL_PORT`]
-  ]
-  [
-    [`ASIO_HAS_SFINAE_VARIABLE_TEMPLATES`]
-    [
-      Support SFINAEd template variables on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_SFINAE_VARIABLE_TEMPLATES`]
-  ]
-  [
-    [`ASIO_HAS_SIGACTION`]
-    [
-      Can use sigaction() instead of signal().
-    ]
-    [`ASIO_DISABLE_SIGACTION`]
-  ]
-  [
-    [`ASIO_HAS_SIGNAL`]
-    [
-      Can use signal().
-    ]
-    [`ASIO_DISABLE_SIGNAL`]
-  ]
-  [
-    [`ASIO_HAS_SNPRINTF`]
-    [
-      Standard library support for snprintf.
-    ]
-    [`ASIO_DISABLE_SNPRINTF`]
-  ]
-  [
-    [`ASIO_HAS_SOURCE_LOCATION`]
-    [
-      Standard library has a source_location that we can use.
-    ]
-    [`ASIO_DISABLE_SOURCE_LOCATION`]
-  ]
-  [
-    [`ASIO_HAS_SSIZE_T`]
-    [
-      Support for POSIX ssize_t typedef.
-    ]
-    [`ASIO_DISABLE_SSIZE_T`]
-  ]
-  [
-    [`ASIO_HAS_STD_ADDRESSOF`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_ALIGN`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_ALIGNED_ALLOC`]
-    [
-      Standard library support for aligned allocation.
-    ]
-    [`ASIO_DISABLE_STD_ALIGNED_ALLOC`]
-  ]
-  [
-    [`ASIO_HAS_STD_ALLOCATOR_ARG`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_ANY`]
-    [
-      Standard library support for std::any.
-    ]
-    [`ASIO_DISABLE_STD_ANY`]
-  ]
-  [
-    [`ASIO_HAS_STD_ARRAY`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_ATOMIC`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_CALL_ONCE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_CHRONO`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_CONCEPTS`]
-    [
-      Support concepts on compilers known to allow them.
-    ]
-    [`ASIO_DISABLE_STD_CONCEPTS`]
-  ]
-  [
-    [`ASIO_HAS_STD_COROUTINE`]
-    [
-      Standard library support for coroutines.
-    ]
-    [`ASIO_DISABLE_STD_COROUTINE`]
-  ]
-  [
-    [`ASIO_HAS_STD_EXCEPTION_PTR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION`]
-    [
-      Standard library support for std::experimental::source_location.
-    ]
-    [`ASIO_DISABLE_STD_EXPERIMENTAL_SOURCE_LOCATION`]
-  ]
-  [
-    [`ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW`]
-    [
-      Standard library support for std::experimental::string_view.
-    ]
-    [`ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW`]
-  ]
-  [
-    [`ASIO_HAS_STD_FUNCTION`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_FUTURE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_HASH`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_INDEX_SEQUENCE`]
-    [
-      Standard library support for std::index_sequence.
-    ]
-    [`ASIO_DISABLE_STD_INDEX_SEQUENCE`]
-  ]
-  [
-    [`ASIO_HAS_STD_INVOKE_RESULT`]
-    [
-      Standard library has invoke_result (which supersedes result_of).
-    ]
-    [`ASIO_DISABLE_STD_INVOKE_RESULT`]
-  ]
-  [
-    [`ASIO_HAS_STD_IOSTREAM_MOVE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_MUTEX_AND_CONDVAR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_NESTED_EXCEPTION`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_REFERENCE_WRAPPER`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_SHARED_PTR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_STRING_VIEW`]
-    [
-      Standard library support for std::string_view.
-    ]
-    [`ASIO_DISABLE_STD_STRING_VIEW`]
-  ]
-  [
-    [`ASIO_HAS_STD_SYSTEM_ERROR`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_THREAD`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_TO_ADDRESS`]
-    [
-      Standard library support for std::to_address.
-    ]
-    [`ASIO_DISABLE_STD_TO_ADDRESS`]
-  ]
-  [
-    [`ASIO_HAS_STD_TUPLE`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_TYPE_TRAITS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_STD_VARIANT`]
-    [
-      Standard library support for std::variant.
-    ]
-    [`ASIO_DISABLE_STD_VARIANT`]
-  ]
-  [
-    [`ASIO_HAS_STRING_VIEW`]
-    [
-      Standard library has a string_view that we can use.
-    ]
-    [`ASIO_DISABLE_STRING_VIEW`]
-  ]
-  [
-    [`ASIO_HAS_THREADS`]
-    [
-      Threads.
-    ]
-    [`ASIO_DISABLE_THREADS`]
-  ]
-  [
-    [`ASIO_HAS_THREAD_KEYWORD_EXTENSION`]
-    [
-      Support for the __thread keyword extension, or equivalent.
-    ]
-    [`ASIO_DISABLE_THREAD_KEYWORD_EXTENSION`]
-  ]
-  [
-    [`ASIO_HAS_TIMERFD`]
-    [
-      Linux: epoll, eventfd, timerfd and io_uring.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_UNISTD_H`]
-    [
-      On POSIX (and POSIX-like) platforms we need to include unistd.h in order to
-      get access to the various platform feature macros, e.g. to be able to test
-      for threads support.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_USER_DEFINED_LITERALS`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_VARIABLE_TEMPLATES`]
-    [
-      Support template variables on compilers known to allow it.
-    ]
-    [`ASIO_DISABLE_VARIABLE_TEMPLATES`]
-  ]
-  [
-    [`ASIO_HAS_VARIADIC_LAMBDA_CAPTURES`]
-    [
-      Support for capturing parameter packs in lambdas.
-    ]
-    [`ASIO_DISABLE_VARIADIC_LAMBDA_CAPTURES`]
-  ]
-  [
-    [`ASIO_HAS_VARIADIC_TEMPLATES`]
-    [
-      Always enabled. Retained for backwards compatibility in user code.
-    ]
-    []
-  ]
-  [
-    [`ASIO_HAS_WINDOWS_OBJECT_HANDLE`]
-    [
-      Windows: object handles.
-    ]
-    [`ASIO_DISABLE_WINDOWS_OBJECT_HANDLE`]
-  ]
-  [
-    [`ASIO_HAS_WINDOWS_OVERLAPPED_PTR`]
-    [
-      Windows: OVERLAPPED wrapper.
-    ]
-    [`ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR`]
-  ]
-  [
-    [`ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE`]
-    [
-      Windows: random access handles.
-    ]
-    [`ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE`]
-  ]
-  [
-    [`ASIO_HAS_WINDOWS_STREAM_HANDLE`]
-    [
-      Windows: stream handles.
-    ]
-    [`ASIO_DISABLE_WINDOWS_STREAM_HANDLE`]
-  ]
-  [
-    [`ASIO_HAS_WORKING_EXPRESSION_SFINAE`]
-    [
-      Enable workarounds for lack of working expression SFINAE.
-    ]
-    [`ASIO_DISABLE_WORKING_EXPRESSION_SFINAE`]
-  ]
-]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/project-root.jam b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/project-root.jam
deleted file mode 100644
index 218d892..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/project-root.jam
+++ /dev/null
@@ -1 +0,0 @@
-# This file intentionally left blank.
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/quickref.xml b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/quickref.xml
deleted file mode 100644
index d4acdc7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/quickref.xml
+++ /dev/null
@@ -1,800 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../boost/tools/boostbook/dtd/boostbook.dtd">
-
-<!--
-  Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-  Distributed under the Boost Software License, Version 1.0. (See accompanying
-  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<informaltable frame="all">
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="a">
-          <bridgehead renderas="sect2">Properties</bridgehead>
-        </entry>
-        <entry valign="center" namest="b" nameend="d">
-          <bridgehead renderas="sect2">Execution</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Customisation Points</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.prefer">prefer</link></member>
-            <member><link linkend="asio.reference.query">query</link></member>
-            <member><link linkend="asio.reference.require">require</link></member>
-            <member><link linkend="asio.reference.require_concept">require_concept</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Traits</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.can_prefer">can_prefer</link></member>
-            <member><link linkend="asio.reference.can_query">can_query</link></member>
-            <member><link linkend="asio.reference.can_require">can_require</link></member>
-            <member><link linkend="asio.reference.can_require_concept">can_require_concept</link></member>
-            <member><link linkend="asio.reference.is_nothrow_prefer">is_nothrow_prefer</link></member>
-            <member><link linkend="asio.reference.is_nothrow_query">is_nothrow_query</link></member>
-            <member><link linkend="asio.reference.is_nothrow_require">is_nothrow_require</link></member>
-            <member><link linkend="asio.reference.is_nothrow_require_concept">is_nothrow_require_concept</link></member>
-            <member><link linkend="asio.reference.prefer_result">prefer_result</link></member>
-            <member><link linkend="asio.reference.query_result">query_result</link></member>
-            <member><link linkend="asio.reference.require_result">require_result</link></member>
-            <member><link linkend="asio.reference.require_concept_result">require_concept_result</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution__any_executor">execution::any_executor</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution__bad_executor">execution::bad_executor</link></member>
-            <member><link linkend="asio.reference.execution__invocable_archetype">execution::invocable_archetype</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Traits</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution__is_executor">execution::is_executor</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Concepts</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.Executor1.standard_executors">executor</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Properties</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution__allocator_t">execution::allocator_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t">execution::blocking_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t__possibly_t">execution::blocking_t::possibly_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t__always_t">execution::blocking_t::always_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t__never_t">execution::blocking_t::never_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation_t">execution::blocking_adaptation_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation_t__disallowed_t">execution::blocking_adaptation_t::disallowed_t</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation_t__allowed_t">execution::blocking_adaptation_t::allowed_t</link></member>
-            <member><link linkend="asio.reference.execution__context_t">execution::context_t</link></member>
-            <member><link linkend="asio.reference.execution__context_as_t">execution::context_as_t</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t">execution::mapping_t</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t__thread_t">execution::mapping_t::thread_t</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t__new_thread_t">execution::mapping_t::new_thread_t</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t__other_t">execution::mapping_t::other_t</link></member>
-            <member><link linkend="asio.reference.execution__occupancy_t">execution::occupancy_t</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work_t">execution::outstanding_work_t</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work_t__untracked_t">execution::outstanding_work_t::untracked_t</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work_t__tracked_t">execution::outstanding_work_t::tracked_t</link></member>
-            <member><link linkend="asio.reference.execution__prefer_only">execution::prefer_only</link></member>
-            <member><link linkend="asio.reference.execution__relationship_t">execution::relationship_t</link></member>
-            <member><link linkend="asio.reference.execution__relationship_t__fork_t">execution::relationship_t::fork_t</link></member>
-            <member><link linkend="asio.reference.execution__relationship_t__continuation_t">execution::relationship_t::continuation_t</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Property Objects</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution__allocator">execution::allocator</link></member>
-            <member><link linkend="asio.reference.execution__blocking">execution::blocking</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t.possibly">execution::blocking.possibly</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t.always">execution::blocking.always</link></member>
-            <member><link linkend="asio.reference.execution__blocking_t.never">execution::blocking.never</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation">execution::blocking_adaptation</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation_t.disallowed">execution::blocking_adaptation.disallowed</link></member>
-            <member><link linkend="asio.reference.execution__blocking_adaptation_t.allowed">execution::blocking_adaptation.allowed</link></member>
-            <member><link linkend="asio.reference.execution__context">execution::context</link></member>
-            <member><link linkend="asio.reference.execution__context_as">execution::context_as</link></member>
-            <member><link linkend="asio.reference.execution__mapping">execution::mapping</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t.thread">execution::mapping.thread</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t.new_thread">execution::mapping.new_thread</link></member>
-            <member><link linkend="asio.reference.execution__mapping_t.other">execution::mapping.other</link></member>
-            <member><link linkend="asio.reference.execution__occupancy">execution::occupancy</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work">execution::outstanding_work</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work_t.untracked">execution::outstanding_work.untracked</link></member>
-            <member><link linkend="asio.reference.execution__outstanding_work_t.tracked">execution::outstanding_work.tracked</link></member>
-            <member><link linkend="asio.reference.execution__relationship">execution::relationship</link></member>
-            <member><link linkend="asio.reference.execution__relationship_t.fork">execution::relationship.fork</link></member>
-            <member><link linkend="asio.reference.execution__relationship_t.continuation">execution::relationship.continuation</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="d">
-          <bridgehead renderas="sect2">Core</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.any_completion_executor">any_completion_executor</link></member>
-            <member><link linkend="asio.reference.any_io_executor">any_io_executor</link></member>
-            <member><link linkend="asio.reference.bad_executor">bad_executor</link></member>
-            <member><link linkend="asio.reference.cancellation_signal">cancellation_signal</link></member>
-            <member><link linkend="asio.reference.cancellation_slot">cancellation_slot</link></member>
-            <member><link linkend="asio.reference.cancellation_state">cancellation_state</link></member>
-            <member><link linkend="asio.reference.cancellation_type">cancellation_type</link></member>
-            <member><link linkend="asio.reference.coroutine">coroutine</link></member>
-            <member><link linkend="asio.reference.detached_t">detached_t</link></member>
-            <member><link linkend="asio.reference.error_code">error_code</link></member>
-            <member><link linkend="asio.reference.execution_context">execution_context</link></member>
-            <member><link linkend="asio.reference.execution_context__id">execution_context::id</link></member>
-            <member><link linkend="asio.reference.execution_context__service">execution_context::service</link></member>
-            <member><link linkend="asio.reference.executor">executor</link></member>
-            <member><link linkend="asio.reference.executor_arg_t">executor_arg_t</link></member>
-            <member><link linkend="asio.reference.invalid_service_owner">invalid_service_owner</link></member>
-            <member><link linkend="asio.reference.io_context">io_context</link></member>
-            <member><link linkend="asio.reference.io_context.executor_type">io_context::executor_type</link></member>
-            <member><link linkend="asio.reference.io_context__service">io_context::service</link></member>
-            <member><link linkend="asio.reference.io_context__strand">io_context::strand</link></member>
-            <member><link linkend="asio.reference.io_context__work">io_context::work</link> (deprecated)</member>
-            <member><link linkend="asio.reference.multiple_exceptions">multiple_exceptions</link></member>
-            <member><link linkend="asio.reference.partial_as_tuple">partial_as_tuple</link></member>
-            <member><link linkend="asio.reference.partial_redirect_error">partial_redirect_error</link></member>
-            <member><link linkend="asio.reference.service_already_exists">service_already_exists</link></member>
-            <member><link linkend="asio.reference.static_thread_pool">static_thread_pool</link></member>
-            <member><link linkend="asio.reference.system_context">system_context</link></member>
-            <member><link linkend="asio.reference.system_error">system_error</link></member>
-            <member><link linkend="asio.reference.system_executor">system_executor</link></member>
-            <member><link linkend="asio.reference.this_coro__cancellation_state_t">this_coro::cancellation_state_t</link></member>
-            <member><link linkend="asio.reference.this_coro__executor_t">this_coro::executor_t</link></member>
-            <member><link linkend="asio.reference.thread">thread</link></member>
-            <member><link linkend="asio.reference.thread_pool">thread_pool</link></member>
-            <member><link linkend="asio.reference.thread_pool.executor_type">thread_pool::executor_type</link></member>
-            <member><link linkend="asio.reference.yield_context">yield_context</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.any_completion_handler">any_completion_handler</link></member>
-            <member><link linkend="asio.reference.any_completion_handler_allocator">any_completion_handler_allocator</link></member>
-            <member><link linkend="asio.reference.append_t">append_t</link></member>
-            <member><link linkend="asio.reference.as_tuple_t">as_tuple_t</link></member>
-            <member><link linkend="asio.reference.async_completion">async_completion</link></member>
-            <member><link linkend="asio.reference.awaitable">awaitable</link></member>
-            <member><link linkend="asio.reference.basic_io_object">basic_io_object</link></member>
-            <member><link linkend="asio.reference.basic_system_executor">basic_system_executor</link></member>
-            <member><link linkend="asio.reference.basic_yield_context">basic_yield_context</link></member>
-            <member><link linkend="asio.reference.cancel_after_t">cancel_after_t</link></member>
-            <member><link linkend="asio.reference.cancel_at_t">cancel_at_t</link></member>
-            <member><link linkend="asio.reference.cancellation_filter">cancellation_filter</link></member>
-            <member><link linkend="asio.reference.cancellation_slot_binder">cancellation_slot_binder</link></member>
-            <member><link linkend="asio.reference.consign_t">consign_t</link></member>
-            <member><link linkend="asio.reference.deferred_t">deferred_t</link></member>
-            <member><link linkend="asio.reference.executor_binder">executor_binder</link></member>
-            <member><link linkend="asio.reference.executor_work_guard">executor_work_guard</link></member>
-            <member><link linkend="asio.reference.experimental__as_single_t">experimental::as_single_t</link></member>
-            <member><link linkend="asio.reference.experimental__basic_channel">experimental::basic_channel</link></member>
-            <member><link linkend="asio.reference.experimental__basic_concurrent_channel">experimental::basic_concurrent_channel</link></member>
-            <member><link linkend="asio.reference.experimental__channel_traits">experimental::channel_traits</link></member>
-            <member><link linkend="asio.reference.experimental__coro">experimental::coro</link></member>
-            <member><link linkend="asio.reference.experimental__parallel_group">experimental::parallel_group</link></member>
-            <member><link linkend="asio.reference.experimental__promise">experimental::promise</link></member>
-            <member><link linkend="asio.reference.experimental__ranged_parallel_group">experimental::ranged_parallel_group</link></member>
-            <member><link linkend="asio.reference.experimental__use_coro_t">experimental::use_coro_t</link></member>
-            <member><link linkend="asio.reference.experimental__use_promise_t">experimental::use_promise_t</link></member>
-            <member><link linkend="asio.reference.experimental__wait_for_all">experimental::wait_for_all</link></member>
-            <member><link linkend="asio.reference.experimental__wait_for_one">experimental::wait_for_one</link></member>
-            <member><link linkend="asio.reference.experimental__wait_for_one_error">experimental::wait_for_one_error</link></member>
-            <member><link linkend="asio.reference.experimental__wait_for_one_success">experimental::wait_for_one_success</link></member>
-            <member><link linkend="asio.reference.io_context__basic_executor_type">io_context::basic_executor_type</link></member>
-            <member><link linkend="asio.reference.partial_allocator_binder">partial_allocator_binder</link></member>
-            <member><link linkend="asio.reference.partial_cancel_after">partial_cancel_after</link></member>
-            <member><link linkend="asio.reference.partial_cancel_after_timer">partial_cancel_after_timer</link></member>
-            <member><link linkend="asio.reference.partial_cancel_at">partial_cancel_at</link></member>
-            <member><link linkend="asio.reference.partial_cancel_at_timer">partial_cancel_at_timer</link></member>
-            <member><link linkend="asio.reference.partial_cancellation_slot_binder">partial_cancellation_slot_binder</link></member>
-            <member><link linkend="asio.reference.partial_executor_binder">partial_executor_binder</link></member>
-            <member><link linkend="asio.reference.partial_immediate_executor_binder">partial_immediate_executor_binder</link></member>
-            <member><link linkend="asio.reference.prepend_t">prepend_t</link></member>
-            <member><link linkend="asio.reference.recycling_allocator">recycling_allocator</link></member>
-            <member><link linkend="asio.reference.redirect_error_t">redirect_error_t</link></member>
-            <member><link linkend="asio.reference.strand">strand</link></member>
-            <member><link linkend="asio.reference.thread_pool__basic_executor_type">thread_pool::basic_executor_type</link></member>
-            <member><link linkend="asio.reference.use_awaitable_t">use_awaitable_t</link></member>
-            <member><link linkend="asio.reference.use_future_t">use_future_t</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Free Functions</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.execution_context.add_service">add_service</link> (deprecated)</member>
-            <member><link linkend="asio.reference.append">append</link></member>
-            <member><link linkend="asio.reference.asio_handler_is_continuation">asio_handler_is_continuation</link></member>
-            <member><link linkend="asio.reference.async_compose">async_compose</link></member>
-            <member><link linkend="asio.reference.async_immediate">async_immediate</link></member>
-            <member><link linkend="asio.reference.async_initiate">async_initiate</link></member>
-            <member><link linkend="asio.reference.bind_allocator">bind_allocator</link></member>
-            <member><link linkend="asio.reference.bind_cancellation_slot">bind_cancellation_slot</link></member>
-            <member><link linkend="asio.reference.bind_executor">bind_executor</link></member>
-            <member><link linkend="asio.reference.bind_immediate_executor">bind_immediate_executor</link></member>
-            <member><link linkend="asio.reference.cancel_after">cancel_after</link></member>
-            <member><link linkend="asio.reference.cancel_at">cancel_at</link></member>
-            <member><link linkend="asio.reference.co_composed">co_composed</link></member>
-            <member><link linkend="asio.reference.co_spawn">co_spawn</link></member>
-            <member><link linkend="asio.reference.composed">composed</link></member>
-            <member><link linkend="asio.reference.consign">consign</link></member>
-            <member><link linkend="asio.reference.defer">defer</link></member>
-            <member><link linkend="asio.reference.dispatch">dispatch</link></member>
-            <member><link linkend="asio.reference.experimental__as_single">experimental::as_single</link></member>
-            <member><link linkend="asio.reference.experimental__make_parallel_group">experimental::make_parallel_group</link></member>
-            <member><link linkend="asio.reference.get_associated_allocator">get_associated_allocator</link></member>
-            <member><link linkend="asio.reference.get_associated_cancellation_slot">get_associated_cancellation_slot</link></member>
-            <member><link linkend="asio.reference.get_associated_executor">get_associated_executor</link></member>
-            <member><link linkend="asio.reference.get_associated_immediate_executor">get_associated_immediate_executor</link></member>
-            <member><link linkend="asio.reference.execution_context.has_service">has_service</link></member>
-            <member><link linkend="asio.reference.execution_context.make_service">make_service</link></member>
-            <member><link linkend="asio.reference.make_strand">make_strand</link></member>
-            <member><link linkend="asio.reference.make_work_guard">make_work_guard</link></member>
-            <member><link linkend="asio.reference.post">post</link></member>
-            <member><link linkend="asio.reference.prepend">prepend</link></member>
-            <member><link linkend="asio.reference.redirect_error">redirect_error</link></member>
-            <member><link linkend="asio.reference.spawn">spawn</link></member>
-            <member><link linkend="asio.reference.this_coro__reset_cancellation_state">this_coro::reset_cancellation_state</link></member>
-            <member><link linkend="asio.reference.this_coro__throw_if_cancelled">this_coro::throw_if_cancelled</link></member>
-            <member><link linkend="asio.reference.execution_context.use_service">use_service</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Special Values</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.as_tuple">as_tuple</link></member>
-            <member><link linkend="asio.reference.deferred">deferred</link></member>
-            <member><link linkend="asio.reference.detached">detached</link></member>
-            <member><link linkend="asio.reference.executor_arg">executor_arg</link></member>
-            <member><link linkend="asio.reference.experimental__use_coro">experimental::use_coro</link></member>
-            <member><link linkend="asio.reference.experimental__use_promise">experimental::use_promise</link></member>
-            <member><link linkend="asio.reference.this_coro__cancellation_state">this_coro::cancellation_state</link></member>
-            <member><link linkend="asio.reference.this_coro__executor">this_coro::executor</link></member>
-            <member><link linkend="asio.reference.use_awaitable">use_awaitable</link></member>
-            <member><link linkend="asio.reference.use_future">use_future</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Error Codes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.error__basic_errors">error::basic_errors</link></member>
-            <member><link linkend="asio.reference.error__netdb_errors">error::netdb_errors</link></member>
-            <member><link linkend="asio.reference.error__addrinfo_errors">error::addrinfo_errors</link></member>
-            <member><link linkend="asio.reference.error__misc_errors">error::misc_errors</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Bind Placeholders</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.placeholders__bytes_transferred">placeholders::bytes_transferred</link></member>
-            <member><link linkend="asio.reference.placeholders__endpoint">placeholders::endpoint</link></member>
-            <member><link linkend="asio.reference.placeholders__error">placeholders::error</link></member>
-            <member><link linkend="asio.reference.placeholders__iterator">placeholders::iterator</link></member>
-            <member><link linkend="asio.reference.placeholders__results">placeholders::results</link></member>
-            <member><link linkend="asio.reference.placeholders__signal_number">placeholders::signal_number</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Traits</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.associated_allocator">associated_allocator</link></member>
-            <member><link linkend="asio.reference.associated_cancellation_slot">associated_cancellation_slot</link></member>
-            <member><link linkend="asio.reference.associated_executor">associated_executor</link></member>
-            <member><link linkend="asio.reference.associated_immediate_executor">associated_immediate_executor</link></member>
-            <member><link linkend="asio.reference.associator">associator</link></member>
-            <member><link linkend="asio.reference.async_result">async_result</link></member>
-            <member><link linkend="asio.reference.completion_signature_of">completion_signature_of</link></member>
-            <member><link linkend="asio.reference.default_completion_token">default_completion_token</link></member>
-            <member><link linkend="asio.reference.is_async_operation">is_async_operation</link></member>
-            <member><link linkend="asio.reference.is_executor">is_executor</link></member>
-            <member><link linkend="asio.reference.uses_executor">uses_executor</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.asynchronous_operations">Asynchronous operations</link></member>
-            <member><link linkend="asio.reference.CancellationHandler">CancellationHandler</link></member>
-            <member><link linkend="asio.reference.CancellationSlot">CancellationSlot</link></member>
-            <member><link linkend="asio.reference.ExecutionContext">ExecutionContext</link></member>
-            <member><link linkend="asio.reference.Executor1">Executor</link></member>
-            <member><link linkend="asio.reference.Handler">Handler</link></member>
-            <member><link linkend="asio.reference.NullaryToken">NullaryToken</link></member>
-            <member><link linkend="asio.reference.Service">Service</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="d">
-          <bridgehead renderas="sect2">Buffers and Buffer-Oriented Operations</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.const_buffer">const_buffer</link></member>
-            <member><link linkend="asio.reference.mutable_buffer">mutable_buffer</link></member>
-            <member><link linkend="asio.reference.const_buffers_1">const_buffers_1 </link> (deprecated)</member>
-            <member><link linkend="asio.reference.mutable_buffers_1">mutable_buffers_1 </link> (deprecated)</member>
-            <member><link linkend="asio.reference.const_registered_buffer">const_registered_buffer</link></member>
-            <member><link linkend="asio.reference.mutable_registered_buffer">mutable_registered_buffer</link></member>
-            <member><link linkend="asio.reference.null_buffers">null_buffers</link> (deprecated)</member>
-            <member><link linkend="asio.reference.streambuf">streambuf</link></member>
-            <member><link linkend="asio.reference.registered_buffer_id">registered_buffer_id</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_streambuf">basic_streambuf</link></member>
-            <member><link linkend="asio.reference.buffer_registration">buffer_registration</link></member>
-            <member><link linkend="asio.reference.buffered_read_stream">buffered_read_stream</link></member>
-            <member><link linkend="asio.reference.buffered_stream">buffered_stream</link></member>
-            <member><link linkend="asio.reference.buffered_write_stream">buffered_write_stream</link></member>
-            <member><link linkend="asio.reference.buffers_iterator">buffers_iterator</link></member>
-            <member><link linkend="asio.reference.dynamic_string_buffer">dynamic_string_buffer</link></member>
-            <member><link linkend="asio.reference.dynamic_vector_buffer">dynamic_vector_buffer</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Free Functions</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.async_read">async_read</link></member>
-            <member><link linkend="asio.reference.async_read_at">async_read_at</link></member>
-            <member><link linkend="asio.reference.async_read_until">async_read_until</link></member>
-            <member><link linkend="asio.reference.async_write">async_write</link></member>
-            <member><link linkend="asio.reference.async_write_at">async_write_at</link></member>
-            <member><link linkend="asio.reference.buffer">buffer</link></member>
-            <member><link linkend="asio.reference.buffer_cast">buffer_cast </link> (deprecated)</member>
-            <member><link linkend="asio.reference.buffer_copy">buffer_copy</link></member>
-            <member><link linkend="asio.reference.buffer_size">buffer_size</link></member>
-            <member><link linkend="asio.reference.buffer_sequence_begin">buffer_sequence_begin</link></member>
-            <member><link linkend="asio.reference.buffer_sequence_end">buffer_sequence_end</link></member>
-            <member><link linkend="asio.reference.buffers_begin">buffers_begin</link></member>
-            <member><link linkend="asio.reference.buffers_end">buffers_end</link></member>
-            <member><link linkend="asio.reference.dynamic_buffer">dynamic_buffer</link></member>
-            <member><link linkend="asio.reference.read">read</link></member>
-            <member><link linkend="asio.reference.read_at">read_at</link></member>
-            <member><link linkend="asio.reference.read_until">read_until</link></member>
-            <member><link linkend="asio.reference.register_buffers">register_buffers</link></member>
-            <member><link linkend="asio.reference.transfer_all">transfer_all</link></member>
-            <member><link linkend="asio.reference.transfer_at_least">transfer_at_least</link></member>
-            <member><link linkend="asio.reference.transfer_exactly">transfer_exactly</link></member>
-            <member><link linkend="asio.reference.write">write</link></member>
-            <member><link linkend="asio.reference.write_at">write_at</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Type Traits</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.is_const_buffer_sequence">is_const_buffer_sequence</link></member>
-            <member><link linkend="asio.reference.is_dynamic_buffer">is_dynamic_buffer</link></member>
-            <member><link linkend="asio.reference.is_dynamic_buffer_v1">is_dynamic_buffer_v1</link></member>
-            <member><link linkend="asio.reference.is_dynamic_buffer_v2">is_dynamic_buffer_v2</link></member>
-            <member><link linkend="asio.reference.is_match_condition">is_match_condition</link></member>
-            <member><link linkend="asio.reference.is_mutable_buffer_sequence">is_mutable_buffer_sequence</link></member>
-            <member><link linkend="asio.reference.is_read_buffered">is_read_buffered</link></member>
-            <member><link linkend="asio.reference.is_write_buffered">is_write_buffered</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.read_write_operations">Read and write operations</link></member>
-            <member><link linkend="asio.reference.AsyncRandomAccessReadDevice">AsyncRandomAccessReadDevice</link></member>
-            <member><link linkend="asio.reference.AsyncRandomAccessWriteDevice">AsyncRandomAccessWriteDevice</link></member>
-            <member><link linkend="asio.reference.AsyncReadStream">AsyncReadStream</link></member>
-            <member><link linkend="asio.reference.AsyncWriteStream">AsyncWriteStream</link></member>
-            <member><link linkend="asio.reference.CompletionCondition">CompletionCondition</link></member>
-            <member><link linkend="asio.reference.ConstBufferSequence">ConstBufferSequence</link></member>
-            <member><link linkend="asio.reference.DynamicBuffer">DynamicBuffer</link></member>
-            <member><link linkend="asio.reference.DynamicBuffer_v1">DynamicBuffer_v1</link></member>
-            <member><link linkend="asio.reference.DynamicBuffer_v2">DynamicBuffer_v2</link></member>
-            <member><link linkend="asio.reference.MutableBufferSequence">MutableBufferSequence</link></member>
-            <member><link linkend="asio.reference.ReadHandler">ReadHandler</link></member>
-            <member><link linkend="asio.reference.ReadToken">ReadToken</link></member>
-            <member><link linkend="asio.reference.SyncRandomAccessReadDevice">SyncRandomAccessReadDevice</link></member>
-            <member><link linkend="asio.reference.SyncRandomAccessWriteDevice">SyncRandomAccessWriteDevice</link></member>
-            <member><link linkend="asio.reference.SyncReadStream">SyncReadStream</link></member>
-            <member><link linkend="asio.reference.SyncWriteStream">SyncWriteStream</link></member>
-            <member><link linkend="asio.reference.WriteHandler">WriteHandler</link></member>
-            <member><link linkend="asio.reference.WriteToken">WriteToken</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="d">
-          <bridgehead renderas="sect2">Networking</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.generic__datagram_protocol">generic::datagram_protocol</link></member>
-            <member><link linkend="asio.reference.generic__datagram_protocol.endpoint">generic::datagram_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.generic__datagram_protocol.socket">generic::datagram_protocol::socket</link></member>
-            <member><link linkend="asio.reference.generic__raw_protocol">generic::raw_protocol</link></member>
-            <member><link linkend="asio.reference.generic__raw_protocol.endpoint">generic::raw_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.generic__raw_protocol.socket">generic::raw_protocol::socket</link></member>
-            <member><link linkend="asio.reference.generic__seq_packet_protocol">generic::seq_packet_protocol</link></member>
-            <member><link linkend="asio.reference.generic__seq_packet_protocol.endpoint">generic::seq_packet_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.generic__seq_packet_protocol.socket">generic::seq_packet_protocol::socket</link></member>
-            <member><link linkend="asio.reference.generic__stream_protocol">generic::stream_protocol</link></member>
-            <member><link linkend="asio.reference.generic__stream_protocol.endpoint">generic::stream_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.generic__stream_protocol.iostream">generic::stream_protocol::iostream</link></member>
-            <member><link linkend="asio.reference.generic__stream_protocol.socket">generic::stream_protocol::socket</link></member>
-            <member><link linkend="asio.reference.ip__address">ip::address</link></member>
-            <member><link linkend="asio.reference.ip__address_v4">ip::address_v4</link></member>
-            <member><link linkend="asio.reference.ip__address_v4_iterator">ip::address_v4_iterator</link></member>
-            <member><link linkend="asio.reference.ip__address_v4_range">ip::address_v4_range</link></member>
-            <member><link linkend="asio.reference.ip__address_v6">ip::address_v6</link></member>
-            <member><link linkend="asio.reference.ip__address_v6_iterator">ip::address_v6_iterator</link></member>
-            <member><link linkend="asio.reference.ip__address_v6_range">ip::address_v6_range</link></member>
-            <member><link linkend="asio.reference.ip__bad_address_cast">ip::bad_address_cast</link></member>
-            <member><link linkend="asio.reference.ip__icmp">ip::icmp</link></member>
-            <member><link linkend="asio.reference.ip__icmp.endpoint">ip::icmp::endpoint</link></member>
-            <member><link linkend="asio.reference.ip__icmp.resolver">ip::icmp::resolver</link></member>
-            <member><link linkend="asio.reference.ip__icmp.socket">ip::icmp::socket</link></member>
-            <member><link linkend="asio.reference.ip__network_v4">ip::network_v4</link></member>
-            <member><link linkend="asio.reference.ip__network_v6">ip::network_v6</link></member>
-            <member><link linkend="asio.reference.ip__resolver_base">ip::resolver_base</link></member>
-            <member><link linkend="asio.reference.ip__resolver_query_base">ip::resolver_query_base</link></member>
-            <member><link linkend="asio.reference.ip__tcp">ip::tcp</link></member>
-            <member><link linkend="asio.reference.ip__tcp.acceptor">ip::tcp::acceptor</link></member>
-            <member><link linkend="asio.reference.ip__tcp.endpoint">ip::tcp::endpoint</link></member>
-            <member><link linkend="asio.reference.ip__tcp.iostream">ip::tcp::iostream</link></member>
-            <member><link linkend="asio.reference.ip__tcp.resolver">ip::tcp::resolver</link></member>
-            <member><link linkend="asio.reference.ip__tcp.socket">ip::tcp::socket</link></member>
-            <member><link linkend="asio.reference.ip__udp">ip::udp</link></member>
-            <member><link linkend="asio.reference.ip__udp.endpoint">ip::udp::endpoint</link></member>
-            <member><link linkend="asio.reference.ip__udp.resolver">ip::udp::resolver</link></member>
-            <member><link linkend="asio.reference.ip__udp.socket">ip::udp::socket</link></member>
-            <member><link linkend="asio.reference.ip__v4_mapped_t">ip::v4_mapped_t</link></member>
-            <member><link linkend="asio.reference.socket_base">socket_base</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Free Functions</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.async_connect">async_connect</link></member>
-            <member><link linkend="asio.reference.connect">connect</link></member>
-            <member><link linkend="asio.reference.ip__host_name">ip::host_name</link></member>
-            <member><link linkend="asio.reference.ip__address.make_address">ip::make_address</link></member>
-            <member><link linkend="asio.reference.ip__address_v4.make_address_v4">ip::make_address_v4</link></member>
-            <member><link linkend="asio.reference.ip__address_v6.make_address_v6">ip::make_address_v6</link></member>
-            <member><link linkend="asio.reference.ip__network_v4.make_network_v4">ip::make_network_v4</link></member>
-            <member><link linkend="asio.reference.ip__network_v6.make_network_v6">ip::make_network_v6</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_datagram_socket">basic_datagram_socket</link></member>
-            <member><link linkend="asio.reference.basic_raw_socket">basic_raw_socket</link></member>
-            <member><link linkend="asio.reference.basic_seq_packet_socket">basic_seq_packet_socket</link></member>
-            <member><link linkend="asio.reference.basic_socket">basic_socket</link></member>
-            <member><link linkend="asio.reference.basic_socket_acceptor">basic_socket_acceptor</link></member>
-            <member><link linkend="asio.reference.basic_socket_iostream">basic_socket_iostream</link></member>
-            <member><link linkend="asio.reference.basic_socket_streambuf">basic_socket_streambuf</link></member>
-            <member><link linkend="asio.reference.basic_stream_socket">basic_stream_socket</link></member>
-            <member><link linkend="asio.reference.generic__basic_endpoint">generic::basic_endpoint</link></member>
-            <member><link linkend="asio.reference.ip__basic_endpoint">ip::basic_endpoint</link></member>
-            <member><link linkend="asio.reference.ip__basic_resolver">ip::basic_resolver</link></member>
-            <member><link linkend="asio.reference.ip__basic_resolver_entry">ip::basic_resolver_entry</link></member>
-            <member><link linkend="asio.reference.ip__basic_resolver_iterator">ip::basic_resolver_iterator</link></member>
-            <member><link linkend="asio.reference.ip__basic_resolver_results">ip::basic_resolver_results</link></member>
-            <member><link linkend="asio.reference.ip__basic_resolver_query">ip::basic_resolver_query</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Socket Options</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.ip__multicast__enable_loopback">ip::multicast::enable_loopback</link></member>
-            <member><link linkend="asio.reference.ip__multicast__hops">ip::multicast::hops</link></member>
-            <member><link linkend="asio.reference.ip__multicast__join_group">ip::multicast::join_group</link></member>
-            <member><link linkend="asio.reference.ip__multicast__leave_group">ip::multicast::leave_group</link></member>
-            <member><link linkend="asio.reference.ip__multicast__outbound_interface">ip::multicast::outbound_interface</link></member>
-            <member><link linkend="asio.reference.ip__tcp.no_delay">ip::tcp::no_delay</link></member>
-            <member><link linkend="asio.reference.ip__unicast__hops">ip::unicast::hops</link></member>
-            <member><link linkend="asio.reference.ip__v6_only">ip::v6_only</link></member>
-            <member><link linkend="asio.reference.socket_base.broadcast">socket_base::broadcast</link></member>
-            <member><link linkend="asio.reference.socket_base.debug">socket_base::debug</link></member>
-            <member><link linkend="asio.reference.socket_base.do_not_route">socket_base::do_not_route</link></member>
-            <member><link linkend="asio.reference.socket_base.enable_connection_aborted">socket_base::enable_connection_aborted</link></member>
-            <member><link linkend="asio.reference.socket_base.keep_alive">socket_base::keep_alive</link></member>
-            <member><link linkend="asio.reference.socket_base.linger">socket_base::linger</link></member>
-            <member><link linkend="asio.reference.socket_base.receive_buffer_size">socket_base::receive_buffer_size</link></member>
-            <member><link linkend="asio.reference.socket_base.receive_low_watermark">socket_base::receive_low_watermark</link></member>
-            <member><link linkend="asio.reference.socket_base.reuse_address">socket_base::reuse_address</link></member>
-            <member><link linkend="asio.reference.socket_base.send_buffer_size">socket_base::send_buffer_size</link></member>
-            <member><link linkend="asio.reference.socket_base.send_low_watermark">socket_base::send_low_watermark</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">I/O Control Commands</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.socket_base.bytes_readable">socket_base::bytes_readable</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.synchronous_socket_operations">Synchronous socket operations</link></member>
-            <member><link linkend="asio.reference.asynchronous_socket_operations">Asynchronous socket operations</link></member>
-            <member><link linkend="asio.reference.AcceptableProtocol">AcceptableProtocol</link></member>
-            <member><link linkend="asio.reference.AcceptHandler">AcceptHandler</link></member>
-            <member><link linkend="asio.reference.AcceptToken">AcceptToken</link></member>
-            <member><link linkend="asio.reference.ConnectCondition">ConnectCondition</link></member>
-            <member><link linkend="asio.reference.ConnectHandler">ConnectHandler</link></member>
-            <member><link linkend="asio.reference.ConnectToken">ConnectToken</link></member>
-            <member><link linkend="asio.reference.Endpoint">Endpoint</link></member>
-            <member><link linkend="asio.reference.EndpointSequence">EndpointSequence</link></member>
-            <member><link linkend="asio.reference.GettableSocketOption">GettableSocketOption</link></member>
-            <member><link linkend="asio.reference.InternetProtocol">InternetProtocol</link></member>
-            <member><link linkend="asio.reference.IoControlCommand">IoControlCommand</link></member>
-            <member><link linkend="asio.reference.IteratorConnectHandler">IteratorConnectHandler</link></member>
-            <member><link linkend="asio.reference.IteratorConnectToken">IteratorConnectToken</link></member>
-            <member><link linkend="asio.reference.MoveAcceptHandler">MoveAcceptHandler</link></member>
-            <member><link linkend="asio.reference.MoveAcceptToken">MoveAcceptToken</link></member>
-            <member><link linkend="asio.reference.Protocol">Protocol</link></member>
-            <member><link linkend="asio.reference.RangeConnectHandler">RangeConnectHandler</link></member>
-            <member><link linkend="asio.reference.RangeConnectToken">RangeConnectToken</link></member>
-            <member><link linkend="asio.reference.ResolveHandler">ResolveHandler</link></member>
-            <member><link linkend="asio.reference.ResolveToken">ResolveToken</link></member>
-            <member><link linkend="asio.reference.SettableSocketOption">SettableSocketOption</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="a">
-          <bridgehead renderas="sect2">Timers</bridgehead>
-        </entry>
-        <entry valign="center" namest="b" nameend="b">
-          <bridgehead renderas="sect2">SSL</bridgehead>
-        </entry>
-        <entry valign="center" namest="c" nameend="c">
-          <bridgehead renderas="sect2">Serial Ports</bridgehead>
-        </entry>
-        <entry valign="center" namest="d" nameend="d">
-          <bridgehead renderas="sect2">Signal Handling</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.deadline_timer">deadline_timer</link></member>
-            <member><link linkend="asio.reference.high_resolution_timer">high_resolution_timer</link></member>
-            <member><link linkend="asio.reference.steady_timer">steady_timer</link></member>
-            <member><link linkend="asio.reference.system_timer">system_timer</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_deadline_timer">basic_deadline_timer</link></member>
-            <member><link linkend="asio.reference.basic_waitable_timer">basic_waitable_timer</link></member>
-            <member><link linkend="asio.reference.time_traits_lt__ptime__gt_">time_traits</link></member>
-            <member><link linkend="asio.reference.wait_traits">wait_traits</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.TimeTraits">TimeTraits</link></member>
-            <member><link linkend="asio.reference.WaitHandler">WaitHandler</link></member>
-            <member><link linkend="asio.reference.WaitToken">WaitToken</link></member>
-            <member><link linkend="asio.reference.WaitTraits">WaitTraits</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.ssl__context">ssl::context</link></member>
-            <member><link linkend="asio.reference.ssl__context_base">ssl::context_base</link></member>
-            <member><link linkend="asio.reference.ssl__host_name_verification">ssl::host_name_verification</link></member>
-            <member><link linkend="asio.reference.ssl__rfc2818_verification">ssl::rfc2818_verification</link> (deprecated)</member>
-            <member><link linkend="asio.reference.ssl__stream_base">ssl::stream_base</link></member>
-            <member><link linkend="asio.reference.ssl__verify_context">ssl::verify_context</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.ssl__stream">ssl::stream</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Error Codes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.ssl__error__stream_errors">ssl::error::stream_errors</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.BufferedHandshakeHandler">BufferedHandshakeHandler</link></member>
-            <member><link linkend="asio.reference.BufferedHandshakeToken">BufferedHandshakeToken</link></member>
-            <member><link linkend="asio.reference.HandshakeHandler">HandshakeHandler</link></member>
-            <member><link linkend="asio.reference.HandshakeToken">HandshakeToken</link></member>
-            <member><link linkend="asio.reference.ShutdownHandler">ShutdownHandler</link></member>
-            <member><link linkend="asio.reference.ShutdownToken">ShutdownToken</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.serial_port">serial_port</link></member>
-            <member><link linkend="asio.reference.serial_port_base">serial_port_base</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_serial_port">basic_serial_port</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Serial Port Options</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.serial_port_base__baud_rate">serial_port_base::baud_rate</link></member>
-            <member><link linkend="asio.reference.serial_port_base__flow_control">serial_port_base::flow_control</link></member>
-            <member><link linkend="asio.reference.serial_port_base__parity">serial_port_base::parity</link></member>
-            <member><link linkend="asio.reference.serial_port_base__stop_bits">serial_port_base::stop_bits</link></member>
-            <member><link linkend="asio.reference.serial_port_base__character_size">serial_port_base::character_size</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.GettableSerialPortOption">GettableSerialPortOption</link></member>
-            <member><link linkend="asio.reference.SettableSerialPortOption">SettableSerialPortOption</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.signal_set">signal_set</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_signal_set">basic_signal_set</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Type Requirements</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.SignalHandler">SignalHandler</link></member>
-            <member><link linkend="asio.reference.SignalToken">SignalToken</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-  <tgroup cols="4">
-    <colspec colname="a"/>
-    <colspec colname="b"/>
-    <colspec colname="c"/>
-    <colspec colname="d"/>
-    <thead>
-      <row>
-        <entry valign="center" namest="a" nameend="a">
-          <bridgehead renderas="sect2">Files and Pipes</bridgehead>
-        </entry>
-        <entry valign="center" namest="b" nameend="c">
-          <bridgehead renderas="sect2">POSIX-specific</bridgehead>
-        </entry>
-        <entry valign="center" namest="d" nameend="d">
-          <bridgehead renderas="sect2">Windows-specific</bridgehead>
-        </entry>
-      </row>
-    </thead>
-    <tbody>
-      <row>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.basic_file">basic_file</link></member>
-            <member><link linkend="asio.reference.basic_random_access_file">basic_random_access_file</link></member>
-            <member><link linkend="asio.reference.basic_readable_pipe">basic_readable_pipe</link></member>
-            <member><link linkend="asio.reference.basic_stream_file">basic_stream_file</link></member>
-            <member><link linkend="asio.reference.basic_writable_pipe">basic_writable_pipe</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.file_base">file_base</link></member>
-            <member><link linkend="asio.reference.random_access_file">random_access_file</link></member>
-            <member><link linkend="asio.reference.readable_pipe">readable_pipe</link></member>
-            <member><link linkend="asio.reference.stream_file">stream_file</link></member>
-            <member><link linkend="asio.reference.writable_pipe">writable_pipe</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Free Functions</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.connect_pipe">connect_pipe</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.local__seq_packet_protocol">local::seq_packet_protocol</link></member>
-            <member><link linkend="asio.reference.local__seq_packet_protocol.acceptor">local::seq_packet_protocol::acceptor</link></member>
-            <member><link linkend="asio.reference.local__seq_packet_protocol.endpoint">local::seq_packet_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.local__seq_packet_protocol.socket">local::seq_packet_protocol::socket</link></member>
-            <member><link linkend="asio.reference.local__stream_protocol">local::stream_protocol</link></member>
-            <member><link linkend="asio.reference.local__stream_protocol.acceptor">local::stream_protocol::acceptor</link></member>
-            <member><link linkend="asio.reference.local__stream_protocol.endpoint">local::stream_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.local__stream_protocol.iostream">local::stream_protocol::iostream</link></member>
-            <member><link linkend="asio.reference.local__stream_protocol.socket">local::stream_protocol::socket</link></member>
-            <member><link linkend="asio.reference.local__datagram_protocol">local::datagram_protocol</link></member>
-            <member><link linkend="asio.reference.local__datagram_protocol.endpoint">local::datagram_protocol::endpoint</link></member>
-            <member><link linkend="asio.reference.local__datagram_protocol.socket">local::datagram_protocol::socket</link></member>
-            <member><link linkend="asio.reference.posix__descriptor">posix::descriptor</link></member>
-            <member><link linkend="asio.reference.posix__descriptor_base">posix::descriptor_base</link></member>
-            <member><link linkend="asio.reference.posix__stream_descriptor">posix::stream_descriptor</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Free Functions</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.local__connect_pair">local::connect_pair</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.local__basic_endpoint">local::basic_endpoint</link></member>
-            <member><link linkend="asio.reference.posix__basic_descriptor">posix::basic_descriptor</link></member>
-            <member><link linkend="asio.reference.posix__basic_stream_descriptor">posix::basic_stream_descriptor</link></member>
-          </simplelist>
-        </entry>
-        <entry valign="top">
-          <bridgehead renderas="sect3">Classes</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.windows__object_handle">windows::object_handle</link></member>
-            <member><link linkend="asio.reference.windows__overlapped_handle">windows::overlapped_handle</link></member>
-            <member><link linkend="asio.reference.windows__overlapped_ptr">windows::overlapped_ptr</link></member>
-            <member><link linkend="asio.reference.windows__random_access_handle">windows::random_access_handle</link></member>
-            <member><link linkend="asio.reference.windows__stream_handle">windows::stream_handle</link></member>
-          </simplelist>
-          <bridgehead renderas="sect3">Class Templates</bridgehead>
-          <simplelist type="vert" columns="1">
-            <member><link linkend="asio.reference.windows__basic_object_handle">windows::basic_object_handle</link></member>
-            <member><link linkend="asio.reference.windows__basic_overlapped_handle">windows::basic_overlapped_handle</link></member>
-            <member><link linkend="asio.reference.windows__basic_random_access_handle">windows::basic_random_access_handle</link></member>
-            <member><link linkend="asio.reference.windows__basic_stream_handle">windows::basic_stream_handle</link></member>
-          </simplelist>
-        </entry>
-      </row>
-    </tbody>
-  </tgroup>
-</informaltable>
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.dox b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.dox
deleted file mode 100644
index d56207d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.dox
+++ /dev/null
@@ -1,405 +0,0 @@
-# Doxyfile 1.9.8
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = "Asio Reference"
-PROJECT_NUMBER         =
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
-OUTPUT_DIRECTORY       = .
-CREATE_SUBDIRS         = NO
-CREATE_SUBDIRS_LEVEL   = 8
-ALLOW_UNICODE_NAMES    = NO
-OUTPUT_LANGUAGE        = English
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ABBREVIATE_BRIEF       =
-ALWAYS_DETAILED_SEC    = YES
-INLINE_INHERITED_MEMB  = YES
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        = ./../../include/
-STRIP_FROM_INC_PATH    =
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-JAVADOC_BANNER         = NO
-QT_AUTOBRIEF           = NO
-MULTILINE_CPP_IS_BRIEF = YES
-PYTHON_DOCSTRING       = YES
-INHERIT_DOCS           = NO
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 2
-ALIASES                =
-OPTIMIZE_OUTPUT_FOR_C  = NO
-OPTIMIZE_OUTPUT_JAVA   = NO
-OPTIMIZE_FOR_FORTRAN   = NO
-OPTIMIZE_OUTPUT_VHDL   = NO
-OPTIMIZE_OUTPUT_SLICE  = NO
-EXTENSION_MAPPING      =
-MARKDOWN_SUPPORT       = YES
-TOC_INCLUDE_HEADINGS   = 5
-MARKDOWN_ID_STYLE      = DOXYGEN
-AUTOLINK_SUPPORT       = YES
-BUILTIN_STL_SUPPORT    = NO
-CPP_CLI_SUPPORT        = NO
-SIP_SUPPORT            = NO
-IDL_PROPERTY_SUPPORT   = YES
-DISTRIBUTE_GROUP_DOC   = NO
-GROUP_NESTED_COMPOUNDS = NO
-SUBGROUPING            = YES
-INLINE_GROUPED_CLASSES = NO
-INLINE_SIMPLE_STRUCTS  = NO
-TYPEDEF_HIDES_STRUCT   = NO
-LOOKUP_CACHE_SIZE      = 0
-NUM_PROC_THREADS       = 1
-TIMESTAMP              = NO
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = YES
-EXTRACT_PRIVATE        = YES
-EXTRACT_PRIV_VIRTUAL   = NO
-EXTRACT_PACKAGE        = NO
-EXTRACT_STATIC         = YES
-EXTRACT_LOCAL_CLASSES  = NO
-EXTRACT_LOCAL_METHODS  = NO
-EXTRACT_ANON_NSPACES   = NO
-RESOLVE_UNNAMED_PARAMS = YES
-HIDE_UNDOC_MEMBERS     = YES
-HIDE_UNDOC_CLASSES     = YES
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-HIDE_COMPOUND_REFERENCE= NO
-SHOW_HEADERFILE        = YES
-SHOW_INCLUDE_FILES     = NO
-SHOW_GROUPED_MEMB_INC  = NO
-FORCE_LOCAL_INCLUDES   = NO
-INLINE_INFO            = NO
-SORT_MEMBER_DOCS       = NO
-SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
-SORT_GROUP_NAMES       = NO
-SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
-GENERATE_TODOLIST      = NO
-GENERATE_TESTLIST      = NO
-GENERATE_BUGLIST       = NO
-GENERATE_DEPRECATEDLIST= NO
-ENABLED_SECTIONS       =
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = NO
-SHOW_FILES             = YES
-SHOW_NAMESPACES        = YES
-FILE_VERSION_FILTER    =
-LAYOUT_FILE            =
-CITE_BIB_FILES         =
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_IF_INCOMPLETE_DOC = YES
-WARN_NO_PARAMDOC       = NO
-WARN_IF_UNDOC_ENUM_VAL = NO
-WARN_AS_ERROR          = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LINE_FORMAT       = "at line $line of file $file"
-WARN_LOGFILE           =
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  = ./../../include/asio.hpp \
-                         ./../../include/asio \
-                         ./../../include/asio/generic \
-                         ./../../include/asio/impl \
-                         ./../../include/asio/ip \
-                         ./../../include/asio/local \
-                         ./../../include/asio/posix \
-                         ./../../include/asio/ssl \
-                         ./../../include/asio/windows \
-                         ./../../include/asio/execution \
-                         ./../../include/asio/experimental \
-                         ./model_dox.txt \
-                         ./noncopyable_dox.txt \
-                         ./std_exception_dox.txt
-INPUT_ENCODING         = UTF-8
-INPUT_FILE_ENCODING    =
-FILE_PATTERNS          =
-RECURSIVE              = NO
-EXCLUDE                =
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       =
-EXCLUDE_SYMBOLS        =
-EXAMPLE_PATH           =
-EXAMPLE_PATTERNS       =
-EXAMPLE_RECURSIVE      = YES
-IMAGE_PATH             =
-INPUT_FILTER           =
-FILTER_PATTERNS        =
-FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
-USE_MDFILE_AS_MAINPAGE =
-FORTRAN_COMMENT_AFTER  = 72
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = NO
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-REFERENCES_LINK_SOURCE = YES
-SOURCE_TOOLTIPS        = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-IGNORE_PREFIX          =
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = NO
-HTML_OUTPUT            = .
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            =
-HTML_FOOTER            =
-HTML_STYLESHEET        =
-HTML_EXTRA_STYLESHEET  =
-HTML_EXTRA_FILES       =
-HTML_COLORSTYLE        = AUTO_LIGHT
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_DYNAMIC_MENUS     = YES
-HTML_DYNAMIC_SECTIONS  = NO
-HTML_CODE_FOLDING      = YES
-HTML_INDEX_NUM_ENTRIES = 100
-GENERATE_DOCSET        = NO
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-DOCSET_FEEDURL         =
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
-GENERATE_HTMLHELP      = NO
-CHM_FILE               =
-HHC_LOCATION           =
-GENERATE_CHI           = NO
-CHM_INDEX_ENCODING     =
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-SITEMAP_URL            =
-GENERATE_QHP           = NO
-QCH_FILE               =
-QHP_NAMESPACE          = org.doxygen.Project
-QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
-QHG_LOCATION           =
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
-DISABLE_INDEX          = YES
-GENERATE_TREEVIEW      = NO
-FULL_SIDEBAR           = NO
-ENUM_VALUES_PER_LINE   = 1
-TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
-OBFUSCATE_EMAILS       = YES
-HTML_FORMULA_FORMAT    = png
-FORMULA_FONTSIZE       = 10
-FORMULA_MACROFILE      =
-USE_MATHJAX            = NO
-MATHJAX_VERSION        = MathJax_2
-MATHJAX_FORMAT         = HTML-CSS
-MATHJAX_RELPATH        =
-MATHJAX_EXTENSIONS     =
-MATHJAX_CODEFILE       =
-SEARCHENGINE           = NO
-SERVER_BASED_SEARCH    = NO
-EXTERNAL_SEARCH        = NO
-SEARCHENGINE_URL       =
-SEARCHDATA_FILE        = searchdata.xml
-EXTERNAL_SEARCH_ID     =
-EXTRA_SEARCH_MAPPINGS  =
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-LATEX_MAKEINDEX_CMD    = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         =
-LATEX_HEADER           =
-LATEX_FOOTER           =
-LATEX_EXTRA_STYLESHEET =
-LATEX_EXTRA_FILES      =
-PDF_HYPERLINKS         = NO
-USE_PDFLATEX           = NO
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-LATEX_BIB_STYLE        = plain
-LATEX_EMOJI_DIRECTORY  =
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    =
-RTF_EXTENSIONS_FILE    =
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_SUBDIR             =
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = YES
-XML_OUTPUT             = xml
-XML_PROGRAMLISTING     = NO
-XML_NS_MEMB_FILE_SCOPE = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-GENERATE_DOCBOOK       = NO
-DOCBOOK_OUTPUT         = docbook
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# Configuration options related to Sqlite3 output
-#---------------------------------------------------------------------------
-GENERATE_SQLITE3       = NO
-SQLITE3_OUTPUT         = sqlite3
-SQLITE3_RECREATE_DB    = YES
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX =
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = YES
-EXPAND_ONLY_PREDEF     = YES
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           =
-INCLUDE_FILE_PATTERNS  =
-PREDEFINED             = GENERATING_DOCUMENTATION \
-                         ASIO_SOCKET_ERROR(e)=implementation_defined \
-                         ASIO_NETDB_ERROR(e)=implementation_defined \
-                         ASIO_EOF_ERROR(e)=implementation_defined \
-                         "ASIO_OS_ERROR(e1,e2)=implementation_defined" \
-                         ASIO_MOVE_ARG(a)=a&& \
-                         ASIO_MOVE_OR_LVALUE_ARG(a)=a&& \
-                         ASIO_NONDEDUCED_MOVE_ARG(a)=a& \
-                         ASIO_DECL= \
-                         ASIO_CONSTEXPR=constexpr \
-                         ASIO_NOEXCEPT=noexcept \
-                         ASIO_NODISCARD= \
-                         ASIO_COMPLETION_SIGNATURE=typename \
-                         ASIO_COMPLETION_HANDLER_FOR(s)=typename \
-                         ASIO_COMPLETION_TOKEN_FOR(s)=typename \
-                         "ASIO_COMPLETION_SIGNATURES_TPARAMS=typename... Signatures" \
-                         ASIO_COMPLETION_SIGNATURES_TARGS=Signatures... \
-                         "ASIO_INITFN_RESULT_TYPE(t,a)=void_or_deduced" \
-                         "ASIO_INITFN_AUTO_RESULT_TYPE(t,a)=void_or_deduced" \
-                         "ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(t,a)=void_or_deduced" \
-                         ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(e)= \
-                         ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(e)==default_token \
-                         ASIO_DEFAULT_COMPLETION_TOKEN(e)==default_token \
-                         ASIO_SVC_TPARAM= \
-                         ASIO_SVC_TPARAM_DEF1()= \
-                         ASIO_SVC_TPARAM_DEF2()= \
-                         ASIO_SVC_TARG= \
-                         ASIO_SVC_TPARAM1= \
-                         ASIO_SVC_TPARAM1_DEF1()= \
-                         ASIO_SVC_TPARAM1_DEF2()= \
-                         ASIO_SVC_TARG1= \
-                         ASIO_SVC_T=asio::detail::service \
-                         ASIO_SVC_T1=asio::detail::service \
-                         ASIO_CONST_BUFFER=const_buffer \
-                         ASIO_MUTABLE_BUFFER=mutable_buffer \
-                         ASIO_SYNC_OP_VOID=void \
-                         ASIO_STRING_VIEW_PARAM=string_view \
-                         ASIO_UNUSED_VARIABLE= \
-                         ASIO_UNSPECIFIED(e)=unspecified \
-                         ASIO_EXECUTION_EXECUTOR=typename \
-                         ASIO_EXECUTION_RECEIVER_ERROR_DEFAULT==std::exception_ptr \
-                         ASIO_EXECUTION_RECEIVER_OF_0=typename \
-                         ASIO_NOEXCEPT_IF(c)= \
-                         ASIO_AUTO_RETURN_TYPE_PREFIX(t)=auto \
-                         "ASIO_AUTO_RETURN_TYPE_PREFIX2(t0,t1)=auto" \
-                         "ASIO_AUTO_RETURN_TYPE_PREFIX3(t0,t1,t2)=auto" \
-                         ASIO_AUTO_RETURN_TYPE_SUFFIX(t)=
-EXPAND_AS_DEFINED      =
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-TAGFILES               =
-GENERATE_TAGFILE       = reference.tags
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-EXTERNAL_PAGES         = YES
-#---------------------------------------------------------------------------
-# Configuration options related to diagram generator tools
-#---------------------------------------------------------------------------
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = YES
-DOT_NUM_THREADS        = 0
-DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
-DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
-DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
-DOT_FONTPATH           =
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = NO
-GROUP_GRAPHS           = NO
-UML_LOOK               = NO
-UML_LIMIT_NUM_FIELDS   = 10
-DOT_UML_DETAILS        = NO
-DOT_WRAP_THRESHOLD     = 17
-TEMPLATE_RELATIONS     = YES
-INCLUDE_GRAPH          = NO
-INCLUDED_BY_GRAPH      = NO
-CALL_GRAPH             = NO
-CALLER_GRAPH           = NO
-GRAPHICAL_HIERARCHY    = NO
-DIRECTORY_GRAPH        = NO
-DIR_GRAPH_MAX_DEPTH    = 1
-DOT_IMAGE_FORMAT       = png
-INTERACTIVE_SVG        = NO
-DOT_PATH               =
-DOTFILE_DIRS           =
-DIA_PATH               =
-DIAFILE_DIRS           =
-PLANTUML_JAR_PATH      =
-PLANTUML_CFG_FILE      =
-PLANTUML_INCLUDE_PATH  =
-DOT_GRAPH_MAX_NODES    = 50
-MAX_DOT_GRAPH_DEPTH    = 0
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = NO
-DOT_CLEANUP            = YES
-MSCGEN_TOOL            =
-MSCFILE_DIRS           =
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.qbk
deleted file mode 100644
index 0d52f6d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.qbk
+++ /dev/null
@@ -1,177530 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:reference Reference]
-
-[xinclude quickref.xml]
-
-[include requirements/asynchronous_operations.qbk]
-[include requirements/read_write_operations.qbk]
-[include requirements/synchronous_socket_operations.qbk]
-[include requirements/asynchronous_socket_operations.qbk]
-[include requirements/AcceptableProtocol.qbk]
-[include requirements/AcceptHandler.qbk]
-[include requirements/AcceptToken.qbk]
-[include requirements/AsyncRandomAccessReadDevice.qbk]
-[include requirements/AsyncRandomAccessWriteDevice.qbk]
-[include requirements/AsyncReadStream.qbk]
-[include requirements/AsyncWriteStream.qbk]
-[include requirements/BufferedHandshakeHandler.qbk]
-[include requirements/BufferedHandshakeToken.qbk]
-[include requirements/CancellationHandler.qbk]
-[include requirements/CancellationSlot.qbk]
-[include requirements/CompletionCondition.qbk]
-[include requirements/ConnectCondition.qbk]
-[include requirements/ConnectHandler.qbk]
-[include requirements/ConnectToken.qbk]
-[include requirements/ConstBufferSequence.qbk]
-[include requirements/DynamicBuffer.qbk]
-[include requirements/DynamicBuffer_v1.qbk]
-[include requirements/DynamicBuffer_v2.qbk]
-[include requirements/Endpoint.qbk]
-[include requirements/EndpointSequence.qbk]
-[include requirements/ExecutionContext.qbk]
-[include requirements/Executor.qbk]
-[include requirements/GettableSerialPortOption.qbk]
-[include requirements/GettableSocketOption.qbk]
-[include requirements/Handler.qbk]
-[include requirements/HandshakeHandler.qbk]
-[include requirements/HandshakeToken.qbk]
-[include requirements/InternetProtocol.qbk]
-[include requirements/IoControlCommand.qbk]
-[include requirements/IoObjectService.qbk]
-[include requirements/IteratorConnectHandler.qbk]
-[include requirements/IteratorConnectToken.qbk]
-[include requirements/LegacyCompletionHandler.qbk]
-[include requirements/MoveAcceptHandler.qbk]
-[include requirements/MoveAcceptToken.qbk]
-[include requirements/MutableBufferSequence.qbk]
-[include requirements/NullaryToken.qbk]
-[include requirements/ProtoAllocator.qbk]
-[include requirements/Protocol.qbk]
-[include requirements/RangeConnectHandler.qbk]
-[include requirements/RangeConnectToken.qbk]
-[include requirements/ReadHandler.qbk]
-[include requirements/ReadToken.qbk]
-[include requirements/ResolveHandler.qbk]
-[include requirements/ResolveToken.qbk]
-[include requirements/Service.qbk]
-[include requirements/SettableSerialPortOption.qbk]
-[include requirements/SettableSocketOption.qbk]
-[include requirements/ShutdownHandler.qbk]
-[include requirements/ShutdownToken.qbk]
-[include requirements/SignalHandler.qbk]
-[include requirements/SignalToken.qbk]
-[include requirements/SyncRandomAccessReadDevice.qbk]
-[include requirements/SyncRandomAccessWriteDevice.qbk]
-[include requirements/SyncReadStream.qbk]
-[include requirements/SyncWriteStream.qbk]
-[include requirements/TimeTraits.qbk]
-[include requirements/WaitHandler.qbk]
-[include requirements/WaitToken.qbk]
-[include requirements/WaitTraits.qbk]
-[include requirements/WriteHandler.qbk]
-[include requirements/WriteToken.qbk]
-
-
-[section:allocator_binder allocator_binder]
-
-[indexterm1 asio.indexterm.allocator_binder..allocator_binder]
-
-
-A call wrapper type to bind an allocator of type `Allocator` to an object of type `T`. 
-
-
-  template<
-      typename T,
-      typename Allocator>
-  class allocator_binder
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.allocator_binder.allocator_type [*allocator_type]]]
-    [The type of the associated allocator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.allocator_binder.argument_type [*argument_type]]]
-    [The type of the function's argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.allocator_binder.first_argument_type [*first_argument_type]]]
-    [The type of the function's first argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.allocator_binder.result_type [*result_type]]]
-    [The return type if a function. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.allocator_binder.second_argument_type [*second_argument_type]]]
-    [The type of the function's second argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.allocator_binder.target_type [*target_type]]]
-    [The type of the target object. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.allocator_binder.allocator_binder [*allocator_binder]] [constructor]]
-    [Construct an allocator wrapper for the specified object. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Construct a copy, but specify a different allocator. 
-     [hr]
-     Construct a copy of a different allocator wrapper type. 
-     [hr]
-     Construct a copy of a different allocator wrapper type, but specify a different allocator. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Move construct the target object, but specify a different allocator. 
-     [hr]
-     Move construct from a different allocator wrapper type. 
-     [hr]
-     Move construct from a different allocator wrapper type, but specify a different allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.allocator_binder.get [*get]]]
-    [Obtain a reference to the target object. ]
-  ]
-  
-  [
-    [[link asio.reference.allocator_binder.get_allocator [*get_allocator]]]
-    [Obtain the associated allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.allocator_binder.operator_lp__rp_ [*operator()]]]
-    [Forwarding function call operator. ]
-  ]
-  
-  [
-    [[link asio.reference.allocator_binder._allocator_binder [*~allocator_binder]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:allocator_binder allocator_binder::allocator_binder]
-
-[indexterm2 asio.indexterm.allocator_binder.allocator_binder..allocator_binder..allocator_binder] 
-Construct an allocator wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  ``[link asio.reference.allocator_binder.allocator_binder.overload1 allocator_binder]``(
-      const allocator_type & s,
-      U && u);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.allocator_binder.allocator_binder.overload2 allocator_binder]``(
-      const allocator_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload2 more...]]``
-
-
-Construct a copy, but specify a different allocator. 
-
-
-  ``[link asio.reference.allocator_binder.allocator_binder.overload3 allocator_binder]``(
-      const allocator_type & s,
-      const allocator_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload3 more...]]``
-
-
-Construct a copy of a different allocator wrapper type. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  ``[link asio.reference.allocator_binder.allocator_binder.overload4 allocator_binder]``(
-      const allocator_binder< U, OtherAllocator > & other,
-      constraint_t< is_constructible< Allocator, OtherAllocator >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload4 more...]]``
-
-
-Construct a copy of a different allocator wrapper type, but specify a different allocator. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  ``[link asio.reference.allocator_binder.allocator_binder.overload5 allocator_binder]``(
-      const allocator_type & s,
-      const allocator_binder< U, OtherAllocator > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload5 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.allocator_binder.allocator_binder.overload6 allocator_binder]``(
-      allocator_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload6 more...]]``
-
-
-Move construct the target object, but specify a different allocator. 
-
-
-  ``[link asio.reference.allocator_binder.allocator_binder.overload7 allocator_binder]``(
-      const allocator_type & s,
-      allocator_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload7 more...]]``
-
-
-Move construct from a different allocator wrapper type. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  ``[link asio.reference.allocator_binder.allocator_binder.overload8 allocator_binder]``(
-      allocator_binder< U, OtherAllocator > && other,
-      constraint_t< is_constructible< Allocator, OtherAllocator >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload8 more...]]``
-
-
-Move construct from a different allocator wrapper type, but specify a different allocator. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  ``[link asio.reference.allocator_binder.allocator_binder.overload9 allocator_binder]``(
-      const allocator_type & s,
-      allocator_binder< U, OtherAllocator > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.allocator_binder.overload9 more...]]``
-
-
-[section:overload1 allocator_binder::allocator_binder (1 of 9 overloads)]
-
-
-Construct an allocator wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  allocator_binder(
-      const allocator_type & s,
-      U && u);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload2 allocator_binder::allocator_binder (2 of 9 overloads)]
-
-
-Copy constructor. 
-
-
-  allocator_binder(
-      const allocator_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 allocator_binder::allocator_binder (3 of 9 overloads)]
-
-
-Construct a copy, but specify a different allocator. 
-
-
-  allocator_binder(
-      const allocator_type & s,
-      const allocator_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 allocator_binder::allocator_binder (4 of 9 overloads)]
-
-
-Construct a copy of a different allocator wrapper type. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  allocator_binder(
-      const allocator_binder< U, OtherAllocator > & other,
-      constraint_t< is_constructible< Allocator, OtherAllocator >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the `Allocator` type is constructible from type `OtherAllocator`, and the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload5 allocator_binder::allocator_binder (5 of 9 overloads)]
-
-
-Construct a copy of a different allocator wrapper type, but specify a different allocator. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  allocator_binder(
-      const allocator_type & s,
-      const allocator_binder< U, OtherAllocator > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload6 allocator_binder::allocator_binder (6 of 9 overloads)]
-
-
-Move constructor. 
-
-
-  allocator_binder(
-      allocator_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload7 allocator_binder::allocator_binder (7 of 9 overloads)]
-
-
-Move construct the target object, but specify a different allocator. 
-
-
-  allocator_binder(
-      const allocator_type & s,
-      allocator_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload8 allocator_binder::allocator_binder (8 of 9 overloads)]
-
-
-Move construct from a different allocator wrapper type. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  allocator_binder(
-      allocator_binder< U, OtherAllocator > && other,
-      constraint_t< is_constructible< Allocator, OtherAllocator >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload9 allocator_binder::allocator_binder (9 of 9 overloads)]
-
-
-Move construct from a different allocator wrapper type, but specify a different allocator. 
-
-
-  template<
-      typename U,
-      typename OtherAllocator>
-  allocator_binder(
-      const allocator_type & s,
-      allocator_binder< U, OtherAllocator > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:allocator_type allocator_binder::allocator_type]
-
-[indexterm2 asio.indexterm.allocator_binder.allocator_type..allocator_type..allocator_binder] 
-The type of the associated allocator. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:argument_type allocator_binder::argument_type]
-
-[indexterm2 asio.indexterm.allocator_binder.argument_type..argument_type..allocator_binder] 
-The type of the function's argument. 
-
-
-  typedef see_below argument_type;
-
-
-
-The type of `argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting a single argument, `argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `argument_type`, then `argument_type` is a synonym for `T::argument_type`;
-
-
-* otherwise `argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:first_argument_type allocator_binder::first_argument_type]
-
-[indexterm2 asio.indexterm.allocator_binder.first_argument_type..first_argument_type..allocator_binder] 
-The type of the function's first argument. 
-
-
-  typedef see_below first_argument_type;
-
-
-
-The type of `first_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `first_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `first_argument_type` is a synonym for `T::first_argument_type`;
-
-
-* otherwise `first_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:get allocator_binder::get]
-
-[indexterm2 asio.indexterm.allocator_binder.get..get..allocator_binder] 
-Obtain a reference to the target object. 
-
-
-  target_type & ``[link asio.reference.allocator_binder.get.overload1 get]``();
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.get.overload1 more...]]``
-
-  const target_type & ``[link asio.reference.allocator_binder.get.overload2 get]``() const;
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.get.overload2 more...]]``
-
-
-[section:overload1 allocator_binder::get (1 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  target_type & get();
-
-
-
-[endsect]
-
-
-
-[section:overload2 allocator_binder::get (2 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  const target_type & get() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_allocator allocator_binder::get_allocator]
-
-[indexterm2 asio.indexterm.allocator_binder.get_allocator..get_allocator..allocator_binder] 
-Obtain the associated allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ allocator_binder::operator()]
-
-[indexterm2 asio.indexterm.allocator_binder.operator_lp__rp_..operator()..allocator_binder] 
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.allocator_binder.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.allocator_binder.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.allocator_binder.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 allocator_binder::operator() (1 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 allocator_binder::operator() (2 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:result_type allocator_binder::result_type]
-
-[indexterm2 asio.indexterm.allocator_binder.result_type..result_type..allocator_binder] 
-The return type if a function. 
-
-
-  typedef see_below result_type;
-
-
-
-The type of `result_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to function type, `result_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `result_type`, then `result_type` is a synonym for `T::result_type`;
-
-
-* otherwise `result_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:second_argument_type allocator_binder::second_argument_type]
-
-[indexterm2 asio.indexterm.allocator_binder.second_argument_type..second_argument_type..allocator_binder] 
-The type of the function's second argument. 
-
-
-  typedef see_below second_argument_type;
-
-
-
-The type of `second_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `second_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `second_argument_type` is a synonym for `T::second_argument_type`;
-
-
-* otherwise `second_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:target_type allocator_binder::target_type]
-
-[indexterm2 asio.indexterm.allocator_binder.target_type..target_type..allocator_binder] 
-The type of the target object. 
-
-
-  typedef T target_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_allocator_binder allocator_binder::~allocator_binder]
-
-[indexterm2 asio.indexterm.allocator_binder._allocator_binder..~allocator_binder..allocator_binder] 
-Destructor. 
-
-
-  ~allocator_binder();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_executor any_completion_executor]
-
-[indexterm1 asio.indexterm.any_completion_executor..any_completion_executor]
-
-
-Polymorphic executor type for use with I/O objects. 
-
-
-  class any_completion_executor :
-    public execution::any_executor<... >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_executor.any_completion_executor [*any_completion_executor]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct in an empty state. Equivalent effects to default constructor. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Construct to point to the same target as another any_executor. 
-     [hr]
-     Construct a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.execute [*execute]]]
-    [Execute the function on the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.operator_bool [*operator bool]]]
-    [Determine whether the wrapper has a target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. 
-     [hr]
-     Assignment operator that sets the polymorphic wrapper to the empty state. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.prefer [*prefer]]]
-    [Obtain a polymorphic wrapper with the specified property. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.query [*query]]]
-    [Obtain the value associated with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.require [*require]]]
-    [Obtain a polymorphic wrapper with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.swap [*swap]]]
-    [Swap targets with another polymorphic wrapper. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.target [*target]]]
-    [Get a pointer to the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.target_type [*target_type]]]
-    [Get the type of the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor._any_completion_executor [*~any_completion_executor]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_executor.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_executor.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-The `any_completion_executor` type is a polymorphic executor that supports the set of properties required for the execution of completion handlers. It is defined as the [link asio.reference.execution__any_executor `execution::any_executor`] class template parameterised as follows: 
-
-  execution::any_executor<
-    execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-    execution::prefer_only<execution::outstanding_work_t::untracked_t>
-    execution::prefer_only<execution::relationship_t::fork_t>,
-    execution::prefer_only<execution::relationship_t::continuation_t>
-  > 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:any_completion_executor any_completion_executor::any_completion_executor]
-
-[indexterm2 asio.indexterm.any_completion_executor.any_completion_executor..any_completion_executor..any_completion_executor] 
-Default constructor. 
-
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload1 any_completion_executor]``();
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload1 more...]]``
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload2 any_completion_executor]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload3 any_completion_executor]``(
-      const any_completion_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload4 any_completion_executor]``(
-      any_completion_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload4 more...]]``
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload5 any_completion_executor]``(
-      execution::any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload5 more...]]``
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload6 any_completion_executor]``(
-      std::nothrow_t ,
-      execution::any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload6 more...]]``
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload7 any_completion_executor]``(
-      std::nothrow_t ,
-      const any_completion_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload7 more...]]``
-
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload8 any_completion_executor]``(
-      std::nothrow_t ,
-      any_completion_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload8 more...]]``
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload9 any_completion_executor]``(
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.any_completion_executor.any_completion_executor.overload10 any_completion_executor]``(
-      std::nothrow_t ,
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.any_completion_executor.overload10 more...]]``
-
-
-[section:overload1 any_completion_executor::any_completion_executor (1 of 10 overloads)]
-
-
-Default constructor. 
-
-
-  any_completion_executor();
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::any_completion_executor (2 of 10 overloads)]
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  any_completion_executor(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_executor::any_completion_executor (3 of 10 overloads)]
-
-
-Copy constructor. 
-
-
-  any_completion_executor(
-      const any_completion_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload4 any_completion_executor::any_completion_executor (4 of 10 overloads)]
-
-
-Move constructor. 
-
-
-  any_completion_executor(
-      any_completion_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload5 any_completion_executor::any_completion_executor (5 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_completion_executor(
-      execution::any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload6 any_completion_executor::any_completion_executor (6 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_completion_executor(
-      std::nothrow_t ,
-      execution::any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload7 any_completion_executor::any_completion_executor (7 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  any_completion_executor(
-      std::nothrow_t ,
-      const any_completion_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload8 any_completion_executor::any_completion_executor (8 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  any_completion_executor(
-      std::nothrow_t ,
-      any_completion_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload9 any_completion_executor::any_completion_executor (9 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_completion_executor(
-      Executor e);
-
-
-
-[endsect]
-
-
-
-[section:overload10 any_completion_executor::any_completion_executor (10 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_completion_executor(
-      std::nothrow_t ,
-      Executor e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:context any_completion_executor::context]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_completion_executor.context..context..any_completion_executor] 
-Obtain the underlying execution context. 
-
-
-  automatically_determined context() const;
-
-
-This function is provided for backward compatibility. It is automatically defined when the `SupportableProperties`... list includes a property of type `execution::context_as<U>`, for some type `U`. 
-
-
-[endsect]
-
-
-
-[section:execute any_completion_executor::execute]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_completion_executor.execute..execute..any_completion_executor] 
-Execute the function on the target executor. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-Throws [link asio.reference.bad_executor `bad_executor`] if the polymorphic wrapper has no target. 
-
-
-[endsect]
-
-
-
-[section:operator_bool any_completion_executor::operator bool]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_completion_executor.operator_bool..operator bool..any_completion_executor] 
-Determine whether the wrapper has a target executor. 
-
-
-  operator bool() const;
-
-
-
-[heading Return Value]
-      
-`true` if the polymorphic wrapper has a target executor, otherwise false. 
-
-
-
-
-[endsect]
-
-
-[section:operator_not__eq_ any_completion_executor::operator!=]
-
-[indexterm2 asio.indexterm.any_completion_executor.operator_not__eq_..operator!=..any_completion_executor] 
-Inequality operator. 
-
-
-  bool ``[link asio.reference.any_completion_executor.operator_not__eq_.overload1 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_not__eq_.overload1 more...]]``
-
-  bool ``[link asio.reference.any_completion_executor.operator_not__eq_.overload2 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_not__eq_.overload2 more...]]``
-
-  bool ``[link asio.reference.any_completion_executor.operator_not__eq_.overload3 operator!=]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_not__eq_.overload3 more...]]``
-
-
-[section:overload1 any_completion_executor::operator!= (1 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::operator!= (2 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_executor::operator!= (3 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ any_completion_executor::operator=]
-
-[indexterm2 asio.indexterm.any_completion_executor.operator_eq_..operator=..any_completion_executor] 
-Assignment operator. 
-
-
-  any_completion_executor & ``[link asio.reference.any_completion_executor.operator_eq_.overload1 operator=]``(
-      const any_completion_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  any_completion_executor & ``[link asio.reference.any_completion_executor.operator_eq_.overload2 operator=]``(
-      any_completion_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq_.overload2 more...]]``
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_completion_executor & ``[link asio.reference.any_completion_executor.operator_eq_.overload3 operator=]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq_.overload3 more...]]``
-
-
-[section:overload1 any_completion_executor::operator= (1 of 3 overloads)]
-
-
-Assignment operator. 
-
-
-  any_completion_executor & operator=(
-      const any_completion_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::operator= (2 of 3 overloads)]
-
-
-Move assignment operator. 
-
-
-  any_completion_executor & operator=(
-      any_completion_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_executor::operator= (3 of 3 overloads)]
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_completion_executor & operator=(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq__eq_ any_completion_executor::operator==]
-
-[indexterm2 asio.indexterm.any_completion_executor.operator_eq__eq_..operator==..any_completion_executor] 
-Equality operator. 
-
-
-  bool ``[link asio.reference.any_completion_executor.operator_eq__eq_.overload1 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq__eq_.overload1 more...]]``
-
-  bool ``[link asio.reference.any_completion_executor.operator_eq__eq_.overload2 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq__eq_.overload2 more...]]``
-
-  bool ``[link asio.reference.any_completion_executor.operator_eq__eq_.overload3 operator==]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.operator_eq__eq_.overload3 more...]]``
-
-
-[section:overload1 any_completion_executor::operator== (1 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::operator== (2 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_executor::operator== (3 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:prefer any_completion_executor::prefer]
-
-[indexterm2 asio.indexterm.any_completion_executor.prefer..prefer..any_completion_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_completion_executor ``[link asio.reference.any_completion_executor.prefer.overload1 prefer]``(
-      const Property & p,
-      constraint_t< traits::prefer_member< const base_type &, const Property & >::is_valid >  = 0) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload1 more...]]``
-
-
-
-  template<>
-  any_completion_executor ``[link asio.reference.any_completion_executor.prefer.overload2 prefer]``(
-      const execution::outstanding_work_t::tracked_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload2 more...]]``
-
-  template<>
-  any_completion_executor ``[link asio.reference.any_completion_executor.prefer.overload3 prefer]``(
-      const execution::outstanding_work_t::untracked_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload3 more...]]``
-
-  template<>
-  any_completion_executor ``[link asio.reference.any_completion_executor.prefer.overload4 prefer]``(
-      const execution::relationship_t::fork_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload4 more...]]``
-
-  template<>
-  any_completion_executor ``[link asio.reference.any_completion_executor.prefer.overload5 prefer]``(
-      const execution::relationship_t::continuation_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload5 more...]]``
-
-  any_executor ``[link asio.reference.any_completion_executor.prefer.overload6 prefer]``(
-      Property ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.prefer.overload6 more...]]``
-
-
-[section:overload1 any_completion_executor::prefer (1 of 6 overloads)]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_completion_executor prefer(
-      const Property & p,
-      constraint_t< traits::prefer_member< const base_type &, const Property & >::is_valid >  = 0) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  any_completion_executor ex = ...;
-  auto ex2 = asio::prefer(ex, execution::relationship.fork); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::prefer (2 of 6 overloads)]
-
-
-
-  template<>
-  any_completion_executor prefer(
-      const execution::outstanding_work_t::tracked_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_executor::prefer (3 of 6 overloads)]
-
-
-
-  template<>
-  any_completion_executor prefer(
-      const execution::outstanding_work_t::untracked_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload4 any_completion_executor::prefer (4 of 6 overloads)]
-
-
-
-  template<>
-  any_completion_executor prefer(
-      const execution::relationship_t::fork_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload5 any_completion_executor::prefer (5 of 6 overloads)]
-
-
-
-  template<>
-  any_completion_executor prefer(
-      const execution::relationship_t::continuation_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload6 any_completion_executor::prefer (6 of 6 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor prefer(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::prefer(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:query any_completion_executor::query]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_completion_executor.query..query..any_completion_executor] 
-Obtain the value associated with the specified property. 
-
-
-  template<
-      typename Property>
-  Property::polymorphic_query_result_type query(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::occupancy_t> ex = ...;
-  size_t n = asio::query(ex, execution::occupancy); 
-
-
-
-
-
-[endsect]
-
-
-[section:require any_completion_executor::require]
-
-[indexterm2 asio.indexterm.any_completion_executor.require..require..any_completion_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_completion_executor ``[link asio.reference.any_completion_executor.require.overload1 require]``(
-      const Property & p,
-      constraint_t< traits::require_member< const base_type &, const Property & >::is_valid >  = 0) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.require.overload1 more...]]``
-
-  any_executor ``[link asio.reference.any_completion_executor.require.overload2 require]``(
-      Property ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.require.overload2 more...]]``
-
-
-[section:overload1 any_completion_executor::require (1 of 2 overloads)]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_completion_executor require(
-      const Property & p,
-      constraint_t< traits::require_member< const base_type &, const Property & >::is_valid >  = 0) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
-
-For example: 
-
-  any_completion_executor ex = ...;
-  auto ex2 = asio::require(ex, execution::relationship.fork); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::require (2 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor require(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::requre(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:swap any_completion_executor::swap]
-
-[indexterm2 asio.indexterm.any_completion_executor.swap..swap..any_completion_executor] 
-Swap targets with another polymorphic wrapper. 
-
-
-  void ``[link asio.reference.any_completion_executor.swap.overload1 swap]``(
-      any_completion_executor & other);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.swap.overload1 more...]]``
-
-  void ``[link asio.reference.any_completion_executor.swap.overload2 swap]``(
-      any_executor & other);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.swap.overload2 more...]]``
-
-
-[section:overload1 any_completion_executor::swap (1 of 2 overloads)]
-
-
-Swap targets with another polymorphic wrapper. 
-
-
-  void swap(
-      any_completion_executor & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::swap (2 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Swap targets with another polymorphic wrapper. 
-
-
-  void swap(
-      any_executor & other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:target any_completion_executor::target]
-
-[indexterm2 asio.indexterm.any_completion_executor.target..target..any_completion_executor] 
-Get a pointer to the target executor. 
-
-
-  Executor * ``[link asio.reference.any_completion_executor.target.overload1 target]``();
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.target.overload1 more...]]``
-
-  const Executor * ``[link asio.reference.any_completion_executor.target.overload2 target]``() const;
-  ``  [''''&raquo;''' [link asio.reference.any_completion_executor.target.overload2 more...]]``
-
-
-[section:overload1 any_completion_executor::target (1 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * target();
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_executor::target (2 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * target() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:target_type any_completion_executor::target_type]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_completion_executor.target_type..target_type..any_completion_executor] 
-Get the type of the target executor. 
-
-
-  const type_info & target_type() const;
-
-
-
-[endsect]
-
-
-
-[section:_any_completion_executor any_completion_executor::~any_completion_executor]
-
-[indexterm2 asio.indexterm.any_completion_executor._any_completion_executor..~any_completion_executor..any_completion_executor] 
-Destructor. 
-
-
-  ~any_completion_executor();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_handler any_completion_handler]
-
-[indexterm1 asio.indexterm.any_completion_handler..any_completion_handler]
-
-
-Polymorphic wrapper for completion handlers. 
-
-
-  template<
-      typename... Signatures>
-  class any_completion_handler
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler.allocator_type [*allocator_type]]]
-    [The associated allocator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.any_completion_handler.cancellation_slot_type [*cancellation_slot_type]]]
-    [The associated cancellation slot type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler.any_completion_handler [*any_completion_handler]] [constructor]]
-    [Construct an any_completion_handler in an empty state, without a target object. 
-     [hr]
-     Construct an any_completion_handler to contain the specified target. 
-     [hr]
-     Move-construct an any_completion_handler from another. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.get_allocator [*get_allocator]]]
-    [Get the associated allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.get_cancellation_slot [*get_cancellation_slot]]]
-    [Get the associated cancellation slot. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.operator_bool [*operator bool]]]
-    [Test if the polymorphic wrapper is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.operator_not_ [*operator!]]]
-    [Test if the polymorphic wrapper is non-empty. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.operator_lp__rp_ [*operator()]]]
-    [Function call operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.operator_eq_ [*operator=]]]
-    [Move-assign an any_completion_handler from another. 
-     [hr]
-     Assignment operator that sets the polymorphic wrapper to the empty state. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.swap [*swap]]]
-    [Swap the content of an any_completion_handler with another. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler._any_completion_handler [*~any_completion_handler]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-The `any_completion_handler` class template is a polymorphic wrapper for completion handlers that propagates the associated executor, associated allocator, and associated cancellation slot through a type-erasing interface.
-
-When using `any_completion_handler`, specify one or more completion signatures as template parameters. These will dictate the arguments that may be passed to the handler through the polymorphic interface.
-
-Typical uses for `any_completion_handler` include:
-
-
-* Separate compilation of asynchronous operation implementations.
-
-
-* Enabling interoperability between asynchronous operations and virtual functions. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocator_type any_completion_handler::allocator_type]
-
-[indexterm2 asio.indexterm.any_completion_handler.allocator_type..allocator_type..any_completion_handler] 
-The associated allocator type. 
-
-
-  typedef any_completion_handler_allocator< void, Signatures... > allocator_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator.value_type [*value_type]]]
-    [The type of objects that may be allocated by the allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler_allocator.allocate [*allocate]]]
-    [Allocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.any_completion_handler_allocator [*any_completion_handler_allocator]] [constructor]]
-    [Construct from another any_completion_handler_allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.deallocate [*deallocate]]]
-    [Deallocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:any_completion_handler any_completion_handler::any_completion_handler]
-
-[indexterm2 asio.indexterm.any_completion_handler.any_completion_handler..any_completion_handler..any_completion_handler] 
-Construct an `any_completion_handler` in an empty state, without a target object. 
-
-
-  constexpr ``[link asio.reference.any_completion_handler.any_completion_handler.overload1 any_completion_handler]``();
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.any_completion_handler.overload1 more...]]``
-
-  constexpr ``[link asio.reference.any_completion_handler.any_completion_handler.overload2 any_completion_handler]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.any_completion_handler.overload2 more...]]``
-
-
-Construct an `any_completion_handler` to contain the specified target. 
-
-
-  template<
-      typename H,
-      typename ``[link asio.reference.Handler Handler]`` = decay_t<H>>
-  ``[link asio.reference.any_completion_handler.any_completion_handler.overload3 any_completion_handler]``(
-      H && h,
-      constraint_t< !is_same< decay_t< H >, any_completion_handler >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.any_completion_handler.overload3 more...]]``
-
-
-Move-construct an `any_completion_handler` from another. 
-
-
-  ``[link asio.reference.any_completion_handler.any_completion_handler.overload4 any_completion_handler]``(
-      any_completion_handler && other);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.any_completion_handler.overload4 more...]]``
-
-
-[section:overload1 any_completion_handler::any_completion_handler (1 of 4 overloads)]
-
-
-Construct an `any_completion_handler` in an empty state, without a target object. 
-
-
-  constexpr any_completion_handler();
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_handler::any_completion_handler (2 of 4 overloads)]
-
-
-Construct an `any_completion_handler` in an empty state, without a target object. 
-
-
-  constexpr any_completion_handler(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_completion_handler::any_completion_handler (3 of 4 overloads)]
-
-
-Construct an `any_completion_handler` to contain the specified target. 
-
-
-  template<
-      typename H,
-      typename ``[link asio.reference.Handler Handler]`` = decay_t<H>>
-  any_completion_handler(
-      H && h,
-      constraint_t< !is_same< decay_t< H >, any_completion_handler >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload4 any_completion_handler::any_completion_handler (4 of 4 overloads)]
-
-
-Move-construct an `any_completion_handler` from another. 
-
-
-  any_completion_handler(
-      any_completion_handler && other);
-
-
-After the operation, the moved-from object `other` has no target. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancellation_slot_type any_completion_handler::cancellation_slot_type]
-
-[indexterm2 asio.indexterm.any_completion_handler.cancellation_slot_type..cancellation_slot_type..any_completion_handler] 
-The associated cancellation slot type. 
-
-
-  typedef cancellation_slot cancellation_slot_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.assign [*assign]]]
-    [Installs a handler into the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.cancellation_slot [*cancellation_slot]] [constructor]]
-    [Creates a slot that is not connected to any cancellation signal. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.clear [*clear]]]
-    [Clears the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.emplace [*emplace]]]
-    [Installs a handler into the slot, constructing the new object directly. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.has_handler [*has_handler]]]
-    [Returns whether the slot is connected and has an installed handler. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.is_connected [*is_connected]]]
-    [Returns whether the slot is connected to a signal. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.operator_not__eq_ [*operator!=]]]
-    [Compare two slots for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.operator_eq__eq_ [*operator==]]]
-    [Compare two slots for equality. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_allocator any_completion_handler::get_allocator]
-
-[indexterm2 asio.indexterm.any_completion_handler.get_allocator..get_allocator..any_completion_handler] 
-Get the associated allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-
-[section:get_cancellation_slot any_completion_handler::get_cancellation_slot]
-
-[indexterm2 asio.indexterm.any_completion_handler.get_cancellation_slot..get_cancellation_slot..any_completion_handler] 
-Get the associated cancellation slot. 
-
-
-  cancellation_slot_type get_cancellation_slot() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_bool any_completion_handler::operator bool]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_bool..operator bool..any_completion_handler] 
-Test if the polymorphic wrapper is empty. 
-
-
-  constexpr operator bool() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not_ any_completion_handler::operator!]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_not_..operator!..any_completion_handler] 
-Test if the polymorphic wrapper is non-empty. 
-
-
-  constexpr bool operator!() const;
-
-
-
-[endsect]
-
-
-[section:operator_not__eq_ any_completion_handler::operator!=]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_not__eq_..operator!=..any_completion_handler] 
-Inequality operator. 
-
-
-  constexpr bool ``[link asio.reference.any_completion_handler.operator_not__eq_.overload1 operator!=]``(
-      const any_completion_handler & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_not__eq_.overload1 more...]]``
-
-  constexpr bool ``[link asio.reference.any_completion_handler.operator_not__eq_.overload2 operator!=]``(
-      nullptr_t ,
-      const any_completion_handler & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_not__eq_.overload2 more...]]``
-
-
-[section:overload1 any_completion_handler::operator!= (1 of 2 overloads)]
-
-
-Inequality operator. 
-
-
-  constexpr bool operator!=(
-      const any_completion_handler & a,
-      nullptr_t );
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_handler::operator!= (2 of 2 overloads)]
-
-
-Inequality operator. 
-
-
-  constexpr bool operator!=(
-      nullptr_t ,
-      const any_completion_handler & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ any_completion_handler::operator()]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_lp__rp_..operator()..any_completion_handler] 
-Function call operator. 
-
-
-  template<
-      typename... Args>
-  auto operator()(
-      Args &&... args);
-
-
-Invokes target completion handler with the supplied arguments.
-
-This function may only be called once, as the target handler is moved from. The polymorphic wrapper is left in an empty state.
-
-Throws `std::bad_function_call` if the polymorphic wrapper is empty. 
-
-
-[endsect]
-
-
-[section:operator_eq_ any_completion_handler::operator=]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_eq_..operator=..any_completion_handler] 
-Move-assign an `any_completion_handler` from another. 
-
-
-  any_completion_handler & ``[link asio.reference.any_completion_handler.operator_eq_.overload1 operator=]``(
-      any_completion_handler && other);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_eq_.overload1 more...]]``
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_completion_handler & ``[link asio.reference.any_completion_handler.operator_eq_.overload2 operator=]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 any_completion_handler::operator= (1 of 2 overloads)]
-
-
-Move-assign an `any_completion_handler` from another. 
-
-
-  any_completion_handler & operator=(
-      any_completion_handler && other);
-
-
-After the operation, the moved-from object `other` has no target. 
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_handler::operator= (2 of 2 overloads)]
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_completion_handler & operator=(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq__eq_ any_completion_handler::operator==]
-
-[indexterm2 asio.indexterm.any_completion_handler.operator_eq__eq_..operator==..any_completion_handler] 
-Equality operator. 
-
-
-  constexpr bool ``[link asio.reference.any_completion_handler.operator_eq__eq_.overload1 operator==]``(
-      const any_completion_handler & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_eq__eq_.overload1 more...]]``
-
-  constexpr bool ``[link asio.reference.any_completion_handler.operator_eq__eq_.overload2 operator==]``(
-      nullptr_t ,
-      const any_completion_handler & b);
-  ``  [''''&raquo;''' [link asio.reference.any_completion_handler.operator_eq__eq_.overload2 more...]]``
-
-
-[section:overload1 any_completion_handler::operator== (1 of 2 overloads)]
-
-
-Equality operator. 
-
-
-  constexpr bool operator==(
-      const any_completion_handler & a,
-      nullptr_t );
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:overload2 any_completion_handler::operator== (2 of 2 overloads)]
-
-
-Equality operator. 
-
-
-  constexpr bool operator==(
-      nullptr_t ,
-      const any_completion_handler & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:swap any_completion_handler::swap]
-
-[indexterm2 asio.indexterm.any_completion_handler.swap..swap..any_completion_handler] 
-Swap the content of an `any_completion_handler` with another. 
-
-
-  void swap(
-      any_completion_handler & other);
-
-
-
-[endsect]
-
-
-
-[section:_any_completion_handler any_completion_handler::~any_completion_handler]
-
-[indexterm2 asio.indexterm.any_completion_handler._any_completion_handler..~any_completion_handler..any_completion_handler] 
-Destructor. 
-
-
-  ~any_completion_handler();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_handler_allocator any_completion_handler_allocator]
-
-[indexterm1 asio.indexterm.any_completion_handler_allocator..any_completion_handler_allocator]
-
-
-An allocator type that forwards memory allocation operations through an instance of `any_completion_handler`. 
-
-
-  template<
-      typename T,
-      typename... Signatures>
-  class any_completion_handler_allocator
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator.value_type [*value_type]]]
-    [The type of objects that may be allocated by the allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler_allocator.allocate [*allocate]]]
-    [Allocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.any_completion_handler_allocator [*any_completion_handler_allocator]] [constructor]]
-    [Construct from another any_completion_handler_allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.deallocate [*deallocate]]]
-    [Deallocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocate any_completion_handler_allocator::allocate]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.allocate..allocate..any_completion_handler_allocator] 
-Allocate space for `n` objects of the allocator's value type. 
-
-
-  T * allocate(
-      std::size_t n) const;
-
-
-
-[endsect]
-
-
-
-[section:any_completion_handler_allocator any_completion_handler_allocator::any_completion_handler_allocator]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.any_completion_handler_allocator..any_completion_handler_allocator..any_completion_handler_allocator] 
-Construct from another `any_completion_handler_allocator`. 
-
-
-  template<
-      typename U>
-  constexpr any_completion_handler_allocator(
-      const any_completion_handler_allocator< U, Signatures... > & a);
-
-
-
-[endsect]
-
-
-
-[section:deallocate any_completion_handler_allocator::deallocate]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.deallocate..deallocate..any_completion_handler_allocator] 
-Deallocate space for `n` objects of the allocator's value type. 
-
-
-  void deallocate(
-      T * p,
-      std::size_t n) const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ any_completion_handler_allocator::operator!=]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.operator_not__eq_..operator!=..any_completion_handler_allocator] 
-Inequality operator. 
-
-
-  constexpr bool operator!=(
-      const any_completion_handler_allocator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ any_completion_handler_allocator::operator==]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.operator_eq__eq_..operator==..any_completion_handler_allocator] 
-Equality operator. 
-
-
-  constexpr bool operator==(
-      const any_completion_handler_allocator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:value_type any_completion_handler_allocator::value_type]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator.value_type..value_type..any_completion_handler_allocator] 
-The type of objects that may be allocated by the allocator. 
-
-
-  typedef T value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_handler_allocator__rebind any_completion_handler_allocator::rebind]
-
-[indexterm1 asio.indexterm.any_completion_handler_allocator__rebind..any_completion_handler_allocator::rebind]
-
-
-Rebinds an allocator to another value type. 
-
-
-  template<
-      typename U>
-  struct rebind
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator__rebind.other [*other]]]
-    [Specifies the type of the rebound allocator. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other any_completion_handler_allocator::rebind::other]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator__rebind.other..other..any_completion_handler_allocator::rebind] 
-Specifies the type of the rebound allocator. 
-
-
-  typedef any_completion_handler_allocator< U, Signatures... > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator.value_type [*value_type]]]
-    [The type of objects that may be allocated by the allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler_allocator.allocate [*allocate]]]
-    [Allocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.any_completion_handler_allocator [*any_completion_handler_allocator]] [constructor]]
-    [Construct from another any_completion_handler_allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.deallocate [*deallocate]]]
-    [Deallocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_ any_completion_handler_allocator< void, Signatures... >]
-
-[indexterm1 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_..any_completion_handler_allocator< void, Signatures\.\.\. >]
-
-
-A protoco-allocator type that may be rebound to obtain an allocator that forwards memory allocation operations through an instance of `any_completion_handler`. 
-
-
-  template<
-      typename... Signatures>
-  class any_completion_handler_allocator< void, Signatures... >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.value_type [*value_type]]]
-    [void as no objects can be allocated through a proto-allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.any_completion_handler_allocator [*any_completion_handler_allocator]]]
-    [Construct from another any_completion_handler_allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:any_completion_handler_allocator any_completion_handler_allocator< void, Signatures... >::any_completion_handler_allocator]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.any_completion_handler_allocator..any_completion_handler_allocator..any_completion_handler_allocator< void, Signatures\.\.\. >] 
-Construct from another `any_completion_handler_allocator`. 
-
-
-  template<
-      typename U>
-  constexpr any_completion_handler_allocator(
-      const any_completion_handler_allocator< U, Signatures... > & a);
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ any_completion_handler_allocator< void, Signatures... >::operator!=]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.operator_not__eq_..operator!=..any_completion_handler_allocator< void, Signatures\.\.\. >] 
-Inequality operator. 
-
-
-  constexpr bool operator!=(
-      const any_completion_handler_allocator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ any_completion_handler_allocator< void, Signatures... >::operator==]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.operator_eq__eq_..operator==..any_completion_handler_allocator< void, Signatures\.\.\. >] 
-Equality operator. 
-
-
-  constexpr bool operator==(
-      const any_completion_handler_allocator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:value_type any_completion_handler_allocator< void, Signatures... >::value_type]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt_.value_type..value_type..any_completion_handler_allocator< void, Signatures\.\.\. >] 
-`void` as no objects can be allocated through a proto-allocator. 
-
-
-  typedef void value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind any_completion_handler_allocator< void, Signatures... >::rebind]
-
-[indexterm1 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind..any_completion_handler_allocator< void, Signatures\.\.\. >::rebind]
-
-
-Rebinds an allocator to another value type. 
-
-
-  template<
-      typename U>
-  struct any_completion_handler_allocator< void, Signatures... >::rebind
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind.other [*other]]]
-    [Specifies the type of the rebound allocator. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other any_completion_handler_allocator< void, Signatures... >::rebind::other]
-
-[indexterm2 asio.indexterm.any_completion_handler_allocator_lt__void_comma__Signatures_ellipsis___gt___rebind.other..other..any_completion_handler_allocator< void, Signatures\.\.\. >::rebind] 
-Specifies the type of the rebound allocator. 
-
-
-  typedef any_completion_handler_allocator< U, Signatures... > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.any_completion_handler_allocator.value_type [*value_type]]]
-    [The type of objects that may be allocated by the allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_completion_handler_allocator.allocate [*allocate]]]
-    [Allocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.any_completion_handler_allocator [*any_completion_handler_allocator]] [constructor]]
-    [Construct from another any_completion_handler_allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.deallocate [*deallocate]]]
-    [Deallocate space for n objects of the allocator's value type. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_completion_handler_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_completion_handler.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:any_io_executor any_io_executor]
-
-[indexterm1 asio.indexterm.any_io_executor..any_io_executor]
-
-
-Polymorphic executor type for use with I/O objects. 
-
-
-  class any_io_executor :
-    public execution::any_executor<... >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_io_executor.any_io_executor [*any_io_executor]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct in an empty state. Equivalent effects to default constructor. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Construct to point to the same target as another any_executor. 
-     [hr]
-     Construct a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.execute [*execute]]]
-    [Execute the function on the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.operator_bool [*operator bool]]]
-    [Determine whether the wrapper has a target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. 
-     [hr]
-     Assignment operator that sets the polymorphic wrapper to the empty state. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.prefer [*prefer]]]
-    [Obtain a polymorphic wrapper with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.query [*query]]]
-    [Obtain the value associated with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.require [*require]]]
-    [Obtain a polymorphic wrapper with the specified property. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.swap [*swap]]]
-    [Swap targets with another polymorphic wrapper. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.target [*target]]]
-    [Get a pointer to the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.target_type [*target_type]]]
-    [Get the type of the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor._any_io_executor [*~any_io_executor]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.any_io_executor.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.any_io_executor.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-The `any_io_executor` type is a polymorphic executor that supports the set of properties required by I/O objects. It is defined as the [link asio.reference.execution__any_executor `execution::any_executor`] class template parameterised as follows: 
-
-  execution::any_executor<
-    execution::context_as_t<execution_context&>,
-    execution::blocking_t::never_t,
-    execution::prefer_only<execution::blocking_t::possibly_t>,
-    execution::prefer_only<execution::outstanding_work_t::tracked_t>,
-    execution::prefer_only<execution::outstanding_work_t::untracked_t>,
-    execution::prefer_only<execution::relationship_t::fork_t>,
-    execution::prefer_only<execution::relationship_t::continuation_t>
-  > 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/any_io_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:any_io_executor any_io_executor::any_io_executor]
-
-[indexterm2 asio.indexterm.any_io_executor.any_io_executor..any_io_executor..any_io_executor] 
-Default constructor. 
-
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload1 any_io_executor]``();
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload1 more...]]``
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload2 any_io_executor]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload3 any_io_executor]``(
-      const any_io_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload4 any_io_executor]``(
-      any_io_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload4 more...]]``
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.any_io_executor.any_io_executor.overload5 any_io_executor]``(
-      execution::any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload5 more...]]``
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.any_io_executor.any_io_executor.overload6 any_io_executor]``(
-      std::nothrow_t ,
-      execution::any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload6 more...]]``
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload7 any_io_executor]``(
-      std::nothrow_t ,
-      const any_io_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload7 more...]]``
-
-  ``[link asio.reference.any_io_executor.any_io_executor.overload8 any_io_executor]``(
-      std::nothrow_t ,
-      any_io_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload8 more...]]``
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.any_io_executor.any_io_executor.overload9 any_io_executor]``(
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.any_io_executor.any_io_executor.overload10 any_io_executor]``(
-      std::nothrow_t ,
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.any_io_executor.overload10 more...]]``
-
-
-[section:overload1 any_io_executor::any_io_executor (1 of 10 overloads)]
-
-
-Default constructor. 
-
-
-  any_io_executor();
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::any_io_executor (2 of 10 overloads)]
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  any_io_executor(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::any_io_executor (3 of 10 overloads)]
-
-
-Copy constructor. 
-
-
-  any_io_executor(
-      const any_io_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload4 any_io_executor::any_io_executor (4 of 10 overloads)]
-
-
-Move constructor. 
-
-
-  any_io_executor(
-      any_io_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload5 any_io_executor::any_io_executor (5 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_io_executor(
-      execution::any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload6 any_io_executor::any_io_executor (6 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_io_executor(
-      std::nothrow_t ,
-      execution::any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload7 any_io_executor::any_io_executor (7 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  any_io_executor(
-      std::nothrow_t ,
-      const any_io_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload8 any_io_executor::any_io_executor (8 of 10 overloads)]
-
-
-Construct to point to the same target as another any\_executor. 
-
-
-  any_io_executor(
-      std::nothrow_t ,
-      any_io_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload9 any_io_executor::any_io_executor (9 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_io_executor(
-      Executor e);
-
-
-
-[endsect]
-
-
-
-[section:overload10 any_io_executor::any_io_executor (10 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_io_executor(
-      std::nothrow_t ,
-      Executor e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:context any_io_executor::context]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_io_executor.context..context..any_io_executor] 
-Obtain the underlying execution context. 
-
-
-  automatically_determined context() const;
-
-
-This function is provided for backward compatibility. It is automatically defined when the `SupportableProperties`... list includes a property of type `execution::context_as<U>`, for some type `U`. 
-
-
-[endsect]
-
-
-
-[section:execute any_io_executor::execute]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_io_executor.execute..execute..any_io_executor] 
-Execute the function on the target executor. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-Throws [link asio.reference.bad_executor `bad_executor`] if the polymorphic wrapper has no target. 
-
-
-[endsect]
-
-
-
-[section:operator_bool any_io_executor::operator bool]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_io_executor.operator_bool..operator bool..any_io_executor] 
-Determine whether the wrapper has a target executor. 
-
-
-  operator bool() const;
-
-
-
-[heading Return Value]
-      
-`true` if the polymorphic wrapper has a target executor, otherwise false. 
-
-
-
-
-[endsect]
-
-
-[section:operator_not__eq_ any_io_executor::operator!=]
-
-[indexterm2 asio.indexterm.any_io_executor.operator_not__eq_..operator!=..any_io_executor] 
-Inequality operator. 
-
-
-  bool ``[link asio.reference.any_io_executor.operator_not__eq_.overload1 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_not__eq_.overload1 more...]]``
-
-  bool ``[link asio.reference.any_io_executor.operator_not__eq_.overload2 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_not__eq_.overload2 more...]]``
-
-  bool ``[link asio.reference.any_io_executor.operator_not__eq_.overload3 operator!=]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_not__eq_.overload3 more...]]``
-
-
-[section:overload1 any_io_executor::operator!= (1 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::operator!= (2 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::operator!= (3 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ any_io_executor::operator=]
-
-[indexterm2 asio.indexterm.any_io_executor.operator_eq_..operator=..any_io_executor] 
-Assignment operator. 
-
-
-  any_io_executor & ``[link asio.reference.any_io_executor.operator_eq_.overload1 operator=]``(
-      const any_io_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  any_io_executor & ``[link asio.reference.any_io_executor.operator_eq_.overload2 operator=]``(
-      any_io_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq_.overload2 more...]]``
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_io_executor & ``[link asio.reference.any_io_executor.operator_eq_.overload3 operator=]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq_.overload3 more...]]``
-
-
-[section:overload1 any_io_executor::operator= (1 of 3 overloads)]
-
-
-Assignment operator. 
-
-
-  any_io_executor & operator=(
-      const any_io_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::operator= (2 of 3 overloads)]
-
-
-Move assignment operator. 
-
-
-  any_io_executor & operator=(
-      any_io_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::operator= (3 of 3 overloads)]
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_io_executor & operator=(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq__eq_ any_io_executor::operator==]
-
-[indexterm2 asio.indexterm.any_io_executor.operator_eq__eq_..operator==..any_io_executor] 
-Equality operator. 
-
-
-  bool ``[link asio.reference.any_io_executor.operator_eq__eq_.overload1 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq__eq_.overload1 more...]]``
-
-  bool ``[link asio.reference.any_io_executor.operator_eq__eq_.overload2 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq__eq_.overload2 more...]]``
-
-  bool ``[link asio.reference.any_io_executor.operator_eq__eq_.overload3 operator==]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.operator_eq__eq_.overload3 more...]]``
-
-
-[section:overload1 any_io_executor::operator== (1 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::operator== (2 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::operator== (3 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:prefer any_io_executor::prefer]
-
-[indexterm2 asio.indexterm.any_io_executor.prefer..prefer..any_io_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload1 prefer]``(
-      const Property & p,
-      constraint_t< traits::prefer_member< const base_type &, const Property & >::is_valid >  = 0) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload1 more...]]``
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload2 prefer]``(
-      const execution::blocking_t::possibly_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload2 more...]]``
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload3 prefer]``(
-      const execution::outstanding_work_t::tracked_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload3 more...]]``
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload4 prefer]``(
-      const execution::outstanding_work_t::untracked_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload4 more...]]``
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload5 prefer]``(
-      const execution::relationship_t::fork_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload5 more...]]``
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.prefer.overload6 prefer]``(
-      const execution::relationship_t::continuation_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload6 more...]]``
-
-  any_executor ``[link asio.reference.any_io_executor.prefer.overload7 prefer]``(
-      Property ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.prefer.overload7 more...]]``
-
-
-[section:overload1 any_io_executor::prefer (1 of 7 overloads)]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_io_executor prefer(
-      const Property & p,
-      constraint_t< traits::prefer_member< const base_type &, const Property & >::is_valid >  = 0) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  any_io_executor ex = ...;
-  auto ex2 = asio::prefer(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::prefer (2 of 7 overloads)]
-
-
-
-  template<>
-  any_io_executor prefer(
-      const execution::blocking_t::possibly_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::prefer (3 of 7 overloads)]
-
-
-
-  template<>
-  any_io_executor prefer(
-      const execution::outstanding_work_t::tracked_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload4 any_io_executor::prefer (4 of 7 overloads)]
-
-
-
-  template<>
-  any_io_executor prefer(
-      const execution::outstanding_work_t::untracked_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload5 any_io_executor::prefer (5 of 7 overloads)]
-
-
-
-  template<>
-  any_io_executor prefer(
-      const execution::relationship_t::fork_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload6 any_io_executor::prefer (6 of 7 overloads)]
-
-
-
-  template<>
-  any_io_executor prefer(
-      const execution::relationship_t::continuation_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload7 any_io_executor::prefer (7 of 7 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor prefer(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::prefer(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:query any_io_executor::query]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_io_executor.query..query..any_io_executor] 
-Obtain the value associated with the specified property. 
-
-
-  template<
-      typename Property>
-  Property::polymorphic_query_result_type query(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::occupancy_t> ex = ...;
-  size_t n = asio::query(ex, execution::occupancy); 
-
-
-
-
-
-[endsect]
-
-
-[section:require any_io_executor::require]
-
-[indexterm2 asio.indexterm.any_io_executor.require..require..any_io_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_io_executor ``[link asio.reference.any_io_executor.require.overload1 require]``(
-      const Property & p,
-      constraint_t< traits::require_member< const base_type &, const Property & >::is_valid >  = 0) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.require.overload1 more...]]``
-
-
-
-  template<>
-  any_io_executor ``[link asio.reference.any_io_executor.require.overload2 require]``(
-      const execution::blocking_t::never_t & p,
-      int ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.require.overload2 more...]]``
-
-  any_executor ``[link asio.reference.any_io_executor.require.overload3 require]``(
-      Property ) const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.require.overload3 more...]]``
-
-
-[section:overload1 any_io_executor::require (1 of 3 overloads)]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_io_executor require(
-      const Property & p,
-      constraint_t< traits::require_member< const base_type &, const Property & >::is_valid >  = 0) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
-
-For example: 
-
-  any_io_executor ex = ...;
-  auto ex2 = asio::require(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::require (2 of 3 overloads)]
-
-
-
-  template<>
-  any_io_executor require(
-      const execution::blocking_t::never_t & p,
-      int ) const;
-
-
-
-[endsect]
-
-
-
-[section:overload3 any_io_executor::require (3 of 3 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor require(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::requre(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:swap any_io_executor::swap]
-
-[indexterm2 asio.indexterm.any_io_executor.swap..swap..any_io_executor] 
-Swap targets with another polymorphic wrapper. 
-
-
-  void ``[link asio.reference.any_io_executor.swap.overload1 swap]``(
-      any_io_executor & other);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.swap.overload1 more...]]``
-
-  void ``[link asio.reference.any_io_executor.swap.overload2 swap]``(
-      any_executor & other);
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.swap.overload2 more...]]``
-
-
-[section:overload1 any_io_executor::swap (1 of 2 overloads)]
-
-
-Swap targets with another polymorphic wrapper. 
-
-
-  void swap(
-      any_io_executor & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::swap (2 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Swap targets with another polymorphic wrapper. 
-
-
-  void swap(
-      any_executor & other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:target any_io_executor::target]
-
-[indexterm2 asio.indexterm.any_io_executor.target..target..any_io_executor] 
-Get a pointer to the target executor. 
-
-
-  Executor * ``[link asio.reference.any_io_executor.target.overload1 target]``();
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.target.overload1 more...]]``
-
-  const Executor * ``[link asio.reference.any_io_executor.target.overload2 target]``() const;
-  ``  [''''&raquo;''' [link asio.reference.any_io_executor.target.overload2 more...]]``
-
-
-[section:overload1 any_io_executor::target (1 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * target();
-
-
-
-[endsect]
-
-
-
-[section:overload2 any_io_executor::target (2 of 2 overloads)]
-
-
-['Inherited from execution::any_executor.]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * target() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:target_type any_io_executor::target_type]
-
-
-['Inherited from execution::any_executor.]
-
-[indexterm2 asio.indexterm.any_io_executor.target_type..target_type..any_io_executor] 
-Get the type of the target executor. 
-
-
-  const type_info & target_type() const;
-
-
-
-[endsect]
-
-
-
-[section:_any_io_executor any_io_executor::~any_io_executor]
-
-[indexterm2 asio.indexterm.any_io_executor._any_io_executor..~any_io_executor..any_io_executor] 
-Destructor. 
-
-
-  ~any_io_executor();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:append append]
-
-[indexterm1 asio.indexterm.append..append]
-
-Completion token type used to specify that the completion handler arguments should be passed additional values after the results of the operation. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  constexpr append_t< decay_t< CompletionToken >, decay_t< Values >... > append(
-      CompletionToken && completion_token,
-      Values &&... values);
-
-
-[heading Requirements]
-
-['Header: ][^asio/append.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:append_t append_t]
-
-[indexterm1 asio.indexterm.append_t..append_t]
-
-
-Completion token type used to specify that the completion handler arguments should be passed additional values after the results of the operation. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  class append_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.append_t.append_t [*append_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.append_t.token_ [*token_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.append_t.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/append.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:append_t append_t::append_t]
-
-[indexterm2 asio.indexterm.append_t.append_t..append_t..append_t] 
-Constructor. 
-
-
-  template<
-      typename T,
-      typename... V>
-  constexpr append_t(
-      T && completion_token,
-      V &&... values);
-
-
-
-[endsect]
-
-
-
-[section:token_ append_t::token_]
-
-[indexterm2 asio.indexterm.append_t.token_..token_..append_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[section:values_ append_t::values_]
-
-[indexterm2 asio.indexterm.append_t.values_..values_..append_t] 
-
-  std::tuple< Values... > values_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:as_tuple as_tuple]
-
-[indexterm1 asio.indexterm.as_tuple..as_tuple]
-
-A function object that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  constexpr partial_as_tuple as_tuple;
-
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:as_tuple_t as_tuple_t]
-
-[indexterm1 asio.indexterm.as_tuple_t..as_tuple_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter used to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  class as_tuple_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.as_tuple_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use as_tuple_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.as_tuple_t__default_constructor_tag [*default_constructor_tag]]]
-    [Tag type used to prevent the "default" constructor from being used for conversions. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.as_tuple_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the as_tuple_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use as_tuple_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.as_tuple_t.as_tuple_t [*as_tuple_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.as_tuple_t `as_tuple_t`] class is used to indicate that any arguments to the completion handler should be combined and passed as a single tuple argument. The arguments are first moved into a `std::tuple` and that tuple is then passed to the completion handler. 
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:as_default_on as_tuple_t::as_default_on]
-
-[indexterm2 asio.indexterm.as_tuple_t.as_default_on..as_default_on..as_tuple_t] 
-Function helper to adapt an I/O object to use `as_tuple_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t as_tuple_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.as_tuple_t.as_default_on_t..as_default_on_t..as_tuple_t] 
-Type alias to adapt an I/O object to use `as_tuple_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.as_tuple_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify as_tuple_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:as_tuple_t as_tuple_t::as_tuple_t]
-
-[indexterm2 asio.indexterm.as_tuple_t.as_tuple_t..as_tuple_t..as_tuple_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.as_tuple_t.as_tuple_t.overload1 as_tuple_t]``(
-      default_constructor_tag  = default_constructor_tag(),
-      CompletionToken token = CompletionToken());
-  ``  [''''&raquo;''' [link asio.reference.as_tuple_t.as_tuple_t.overload1 more...]]``
-
-
-Constructor. 
-
-
-  template<
-      typename T>
-  explicit constexpr ``[link asio.reference.as_tuple_t.as_tuple_t.overload2 as_tuple_t]``(
-      T && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.as_tuple_t.as_tuple_t.overload2 more...]]``
-
-
-[section:overload1 as_tuple_t::as_tuple_t (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr as_tuple_t(
-      default_constructor_tag  = default_constructor_tag(),
-      CompletionToken token = CompletionToken());
-
-
-This constructor is only valid if the underlying completion token is default constructible and move constructible. The underlying completion token is itself defaulted as an argument to allow it to capture a source location. 
-
-
-[endsect]
-
-
-
-[section:overload2 as_tuple_t::as_tuple_t (2 of 2 overloads)]
-
-
-Constructor. 
-
-
-  template<
-      typename T>
-  constexpr as_tuple_t(
-      T && completion_token);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:token_ as_tuple_t::token_]
-
-[indexterm2 asio.indexterm.as_tuple_t.token_..token_..as_tuple_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:as_tuple_t__default_constructor_tag as_tuple_t::default_constructor_tag]
-
-[indexterm1 asio.indexterm.as_tuple_t__default_constructor_tag..as_tuple_t::default_constructor_tag]
-
-
-Tag type used to prevent the "default" constructor from being used for conversions. 
-
-
-  struct default_constructor_tag
-
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:as_tuple_t__executor_with_default as_tuple_t::executor_with_default]
-
-[indexterm1 asio.indexterm.as_tuple_t__executor_with_default..as_tuple_t::executor_with_default]
-
-
-Adapts an executor to add the `as_tuple_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.as_tuple_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify as_tuple_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:default_completion_token_type as_tuple_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.as_tuple_t__executor_with_default.default_completion_token_type..default_completion_token_type..as_tuple_t::executor_with_default] 
-Specify `as_tuple_t` as the default completion token type. 
-
-
-  typedef as_tuple_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.as_tuple_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use as_tuple_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.as_tuple_t__default_constructor_tag [*default_constructor_tag]]]
-    [Tag type used to prevent the "default" constructor from being used for conversions. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.as_tuple_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the as_tuple_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use as_tuple_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.as_tuple_t.as_tuple_t [*as_tuple_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.as_tuple_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.as_tuple_t `as_tuple_t`] class is used to indicate that any arguments to the completion handler should be combined and passed as a single tuple argument. The arguments are first moved into a `std::tuple` and that tuple is then passed to the completion handler. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_with_default as_tuple_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.as_tuple_t__executor_with_default.executor_with_default..executor_with_default..as_tuple_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor1]``>
-  executor_with_default(
-      const InnerExecutor1 & ex,
-      constraint_t< conditional_t< !is_same< InnerExecutor1, executor_with_default >::value, is_convertible< InnerExecutor1, InnerExecutor >, false_type >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:asio_handler_is_continuation asio_handler_is_continuation]
-
-[indexterm1 asio.indexterm.asio_handler_is_continuation..asio_handler_is_continuation]
-
-Default continuation function for handlers. 
-
-
-  bool asio_handler_is_continuation(
-      ... );
-
-
-Asynchronous operations may represent a continuation of the asynchronous control flow associated with the current handler. The implementation can use this knowledge to optimise scheduling of the handler.
-
-Implement asio\_handler\_is\_continuation for your own handlers to indicate when a handler represents a continuation.
-
-The default implementation of the continuation hook returns `false`.
-
-
-[heading Example]
-  
-
-
-  class my_handler;
-
-  bool asio_handler_is_continuation(my_handler* context)
-  {
-    return true;
-  }
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/handler_continuation_hook.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:associated_allocator associated_allocator]
-
-[indexterm1 asio.indexterm.associated_allocator..associated_allocator]
-
-
-Traits type used to obtain the allocator associated with an object. 
-
-
-  template<
-      typename T,
-      typename Allocator = std::allocator<void>>
-  struct associated_allocator
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_allocator.type [*type]]]
-    [If T has a nested type allocator_type, T::allocator_type. Otherwise Allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_allocator.get [*get]] [static]]
-    [If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns a. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Allocator` shall be a type meeting the Allocator requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `a` is an object of type `Allocator`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Allocator requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,a)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_allocator::get]
-
-[indexterm2 asio.indexterm.associated_allocator.get..get..associated_allocator] 
-If `T` has a nested type `allocator_type`, returns `t.get_allocator()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_allocator.get.overload1 get]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.associated_allocator.get.overload1 more...]]``
-
-
-If `T` has a nested type `allocator_type`, returns `t.get_allocator()`. Otherwise returns `a`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_allocator.get.overload2 get]``(
-      const T & t,
-      const Allocator & a);
-  ``  [''''&raquo;''' [link asio.reference.associated_allocator.get.overload2 more...]]``
-
-
-[section:overload1 associated_allocator::get (1 of 2 overloads)]
-
-
-If `T` has a nested type `allocator_type`, returns `t.get_allocator()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) get(
-      const T & t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_allocator::get (2 of 2 overloads)]
-
-
-If `T` has a nested type `allocator_type`, returns `t.get_allocator()`. Otherwise returns `a`. 
-
-
-  static decltype(auto) get(
-      const T & t,
-      const Allocator & a);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_allocator::type]
-
-[indexterm2 asio.indexterm.associated_allocator.type..type..associated_allocator] 
-If `T` has a nested type `allocator_type`, `T::allocator_type`. Otherwise `Allocator`. 
-
-
-  typedef see_below type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_ associated_allocator< reference_wrapper< T >, Allocator >]
-
-[indexterm1 asio.indexterm.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_..associated_allocator< reference_wrapper< T >, Allocator >]
-
-
-Specialisation of [link asio.reference.associated_allocator `associated_allocator`] for `std::reference_wrapper`. 
-
-
-  template<
-      typename T,
-      typename Allocator>
-  struct associated_allocator< reference_wrapper< T >, Allocator >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.type [*type]]]
-    [Forwards type to the associator specialisation for the unwrapped type T. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get [*get]] [static]]
-    [Forwards the request to get the allocator to the associator specialisation for the unwrapped type T. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_allocator< reference_wrapper< T >, Allocator >::get]
-
-[indexterm2 asio.indexterm.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get..get..associated_allocator< reference_wrapper< T >, Allocator >] 
-Forwards the request to get the allocator to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type ``[link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get.overload1 get]``(
-      reference_wrapper< T > t);
-  ``  [''''&raquo;''' [link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get.overload1 more...]]``
-
-  static auto ``[link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get.overload2 get]``(
-      reference_wrapper< T > t,
-      const Allocator & a);
-  ``  [''''&raquo;''' [link asio.reference.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.get.overload2 more...]]``
-
-
-[section:overload1 associated_allocator< reference_wrapper< T >, Allocator >::get (1 of 2 overloads)]
-
-
-Forwards the request to get the allocator to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type get(
-      reference_wrapper< T > t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_allocator< reference_wrapper< T >, Allocator >::get (2 of 2 overloads)]
-
-
-Forwards the request to get the allocator to the associator specialisation for the unwrapped type `T`. 
-
-
-  static auto get(
-      reference_wrapper< T > t,
-      const Allocator & a);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_allocator< reference_wrapper< T >, Allocator >::type]
-
-[indexterm2 asio.indexterm.associated_allocator_lt__reference_wrapper_lt__T__gt__comma__Allocator__gt_.type..type..associated_allocator< reference_wrapper< T >, Allocator >] 
-Forwards `type` to the associator specialisation for the unwrapped type `T`. 
-
-
-  typedef associated_allocator< T, Allocator >::type type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_allocator.type [*type]]]
-    [If T has a nested type allocator_type, T::allocator_type. Otherwise Allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_allocator.get [*get]] [static]]
-    [If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns a. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Allocator` shall be a type meeting the Allocator requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `a` is an object of type `Allocator`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Allocator requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,a)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:associated_allocator_t associated_allocator_t]
-
-[indexterm1 asio.indexterm.associated_allocator_t..associated_allocator_t]
-
-
-  typedef typename associated_allocator< T, Allocator >::type associated_allocator_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_allocator.type [*type]]]
-    [If T has a nested type allocator_type, T::allocator_type. Otherwise Allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_allocator.get [*get]] [static]]
-    [If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type allocator_type, returns t.get_allocator(). Otherwise returns a. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Allocator` shall be a type meeting the Allocator requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `a` is an object of type `Allocator`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Allocator requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,a)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:associated_cancellation_slot associated_cancellation_slot]
-
-[indexterm1 asio.indexterm.associated_cancellation_slot..associated_cancellation_slot]
-
-
-Traits type used to obtain the [link asio.reference.cancellation_slot `cancellation_slot`] associated with an object. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]`` = cancellation_slot>
-  struct associated_cancellation_slot
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_cancellation_slot.type [*type]]]
-    [If T has a nested type cancellation_slot_type, T::cancellation_slot_type. Otherwise CancellationSlot. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_cancellation_slot.get [*get]] [static]]
-    [If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns s. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `CancellationSlot` shall be a type meeting the CancellationSlot requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `s` is an object of type `CancellationSlot`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the CancellationSlot requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,s)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_cancellation_slot::get]
-
-[indexterm2 asio.indexterm.associated_cancellation_slot.get..get..associated_cancellation_slot] 
-If `T` has a nested type `cancellation_slot_type`, returns `t.get_cancellation_slot()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_cancellation_slot.get.overload1 get]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.associated_cancellation_slot.get.overload1 more...]]``
-
-
-If `T` has a nested type `cancellation_slot_type`, returns `t.get_cancellation_slot()`. Otherwise returns `s`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_cancellation_slot.get.overload2 get]``(
-      const T & t,
-      const CancellationSlot & s);
-  ``  [''''&raquo;''' [link asio.reference.associated_cancellation_slot.get.overload2 more...]]``
-
-
-[section:overload1 associated_cancellation_slot::get (1 of 2 overloads)]
-
-
-If `T` has a nested type `cancellation_slot_type`, returns `t.get_cancellation_slot()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) get(
-      const T & t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_cancellation_slot::get (2 of 2 overloads)]
-
-
-If `T` has a nested type `cancellation_slot_type`, returns `t.get_cancellation_slot()`. Otherwise returns `s`. 
-
-
-  static decltype(auto) get(
-      const T & t,
-      const CancellationSlot & s);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_cancellation_slot::type]
-
-[indexterm2 asio.indexterm.associated_cancellation_slot.type..type..associated_cancellation_slot] 
-If `T` has a nested type `cancellation_slot_type`, `T::cancellation_slot_type`. Otherwise `CancellationSlot`. 
-
-
-  typedef see_below type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_ associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >]
-
-[indexterm1 asio.indexterm.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_..associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >]
-
-
-Specialisation of [link asio.reference.associated_cancellation_slot `associated_cancellation_slot`] for `std::reference_wrapper`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  struct associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.type [*type]]]
-    [Forwards type to the associator specialisation for the unwrapped type T. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get [*get]] [static]]
-    [Forwards the request to get the cancellation slot to the associator specialisation for the unwrapped type T. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >::get]
-
-[indexterm2 asio.indexterm.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get..get..associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >] 
-Forwards the request to get the cancellation slot to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type ``[link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get.overload1 get]``(
-      reference_wrapper< T > t);
-  ``  [''''&raquo;''' [link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get.overload1 more...]]``
-
-  static auto ``[link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get.overload2 get]``(
-      reference_wrapper< T > t,
-      const CancellationSlot & s);
-  ``  [''''&raquo;''' [link asio.reference.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.get.overload2 more...]]``
-
-
-[section:overload1 associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >::get (1 of 2 overloads)]
-
-
-Forwards the request to get the cancellation slot to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type get(
-      reference_wrapper< T > t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >::get (2 of 2 overloads)]
-
-
-Forwards the request to get the cancellation slot to the associator specialisation for the unwrapped type `T`. 
-
-
-  static auto get(
-      reference_wrapper< T > t,
-      const CancellationSlot & s);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >::type]
-
-[indexterm2 asio.indexterm.associated_cancellation_slot_lt__reference_wrapper_lt__T__gt__comma__CancellationSlot__gt_.type..type..associated_cancellation_slot< reference_wrapper< T >, CancellationSlot >] 
-Forwards `type` to the associator specialisation for the unwrapped type `T`. 
-
-
-  typedef associated_cancellation_slot< T, CancellationSlot >::type type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_cancellation_slot.type [*type]]]
-    [If T has a nested type cancellation_slot_type, T::cancellation_slot_type. Otherwise CancellationSlot. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_cancellation_slot.get [*get]] [static]]
-    [If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns s. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `CancellationSlot` shall be a type meeting the CancellationSlot requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `s` is an object of type `CancellationSlot`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the CancellationSlot requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,s)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:associated_cancellation_slot_t associated_cancellation_slot_t]
-
-[indexterm1 asio.indexterm.associated_cancellation_slot_t..associated_cancellation_slot_t]
-
-
-  typedef typename associated_cancellation_slot< T, CancellationSlot >::type associated_cancellation_slot_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_cancellation_slot.type [*type]]]
-    [If T has a nested type cancellation_slot_type, T::cancellation_slot_type. Otherwise CancellationSlot. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_cancellation_slot.get [*get]] [static]]
-    [If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type cancellation_slot_type, returns t.get_cancellation_slot(). Otherwise returns s. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `CancellationSlot` shall be a type meeting the CancellationSlot requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `s` is an object of type `CancellationSlot`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the CancellationSlot requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,s)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:associated_executor associated_executor]
-
-[indexterm1 asio.indexterm.associated_executor..associated_executor]
-
-
-Traits type used to obtain the executor associated with an object. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]`` = system_executor>
-  struct associated_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_executor.type [*type]]]
-    [If T has a nested type executor_type, T::executor_type. Otherwise Executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_executor.get [*get]] [static]]
-    [If T has a nested type executor_type, returns t.get_executor(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type executor_type, returns t.get_executor(). Otherwise returns ex. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_executor::get]
-
-[indexterm2 asio.indexterm.associated_executor.get..get..associated_executor] 
-If `T` has a nested type `executor_type`, returns `t.get_executor()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_executor.get.overload1 get]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.associated_executor.get.overload1 more...]]``
-
-
-If `T` has a nested type `executor_type`, returns `t.get_executor()`. Otherwise returns `ex`. 
-
-
-  static decltype(auto) ``[link asio.reference.associated_executor.get.overload2 get]``(
-      const T & t,
-      const Executor & ex);
-  ``  [''''&raquo;''' [link asio.reference.associated_executor.get.overload2 more...]]``
-
-
-[section:overload1 associated_executor::get (1 of 2 overloads)]
-
-
-If `T` has a nested type `executor_type`, returns `t.get_executor()`. Otherwise returns `type()`. 
-
-
-  static decltype(auto) get(
-      const T & t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_executor::get (2 of 2 overloads)]
-
-
-If `T` has a nested type `executor_type`, returns `t.get_executor()`. Otherwise returns `ex`. 
-
-
-  static decltype(auto) get(
-      const T & t,
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_executor::type]
-
-[indexterm2 asio.indexterm.associated_executor.type..type..associated_executor] 
-If `T` has a nested type `executor_type`, `T::executor_type`. Otherwise `Executor`. 
-
-
-  typedef see_below type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_ associated_executor< reference_wrapper< T >, Executor >]
-
-[indexterm1 asio.indexterm.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_..associated_executor< reference_wrapper< T >, Executor >]
-
-
-Specialisation of [link asio.reference.associated_executor `associated_executor`] for `std::reference_wrapper`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct associated_executor< reference_wrapper< T >, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.type [*type]]]
-    [Forwards type to the associator specialisation for the unwrapped type T. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get [*get]] [static]]
-    [Forwards the request to get the executor to the associator specialisation for the unwrapped type T. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:get associated_executor< reference_wrapper< T >, Executor >::get]
-
-[indexterm2 asio.indexterm.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get..get..associated_executor< reference_wrapper< T >, Executor >] 
-Forwards the request to get the executor to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type ``[link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get.overload1 get]``(
-      reference_wrapper< T > t);
-  ``  [''''&raquo;''' [link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get.overload1 more...]]``
-
-  static auto ``[link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get.overload2 get]``(
-      reference_wrapper< T > t,
-      const Executor & ex);
-  ``  [''''&raquo;''' [link asio.reference.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get.overload2 more...]]``
-
-
-[section:overload1 associated_executor< reference_wrapper< T >, Executor >::get (1 of 2 overloads)]
-
-
-Forwards the request to get the executor to the associator specialisation for the unwrapped type `T`. 
-
-
-  static type get(
-      reference_wrapper< T > t);
-
-
-
-[endsect]
-
-
-
-[section:overload2 associated_executor< reference_wrapper< T >, Executor >::get (2 of 2 overloads)]
-
-
-Forwards the request to get the executor to the associator specialisation for the unwrapped type `T`. 
-
-
-  static auto get(
-      reference_wrapper< T > t,
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type associated_executor< reference_wrapper< T >, Executor >::type]
-
-[indexterm2 asio.indexterm.associated_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.type..type..associated_executor< reference_wrapper< T >, Executor >] 
-Forwards `type` to the associator specialisation for the unwrapped type `T`. 
-
-
-  typedef associated_executor< T, Executor >::type type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_executor.type [*type]]]
-    [If T has a nested type executor_type, T::executor_type. Otherwise Executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_executor.get [*get]] [static]]
-    [If T has a nested type executor_type, returns t.get_executor(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type executor_type, returns t.get_executor(). Otherwise returns ex. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:associated_executor_t associated_executor_t]
-
-[indexterm1 asio.indexterm.associated_executor_t..associated_executor_t]
-
-
-  typedef typename associated_executor< T, Executor >::type associated_executor_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_executor.type [*type]]]
-    [If T has a nested type executor_type, T::executor_type. Otherwise Executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_executor.get [*get]] [static]]
-    [If T has a nested type executor_type, returns t.get_executor(). Otherwise returns type(). 
-     [hr]
-     If T has a nested type executor_type, returns t.get_executor(). Otherwise returns ex. ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:associated_immediate_executor associated_immediate_executor]
-
-[indexterm1 asio.indexterm.associated_immediate_executor..associated_immediate_executor]
-
-
-Traits type used to obtain the immediate executor associated with an object. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct associated_immediate_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_immediate_executor.type [*type]]]
-    [If T has a nested type immediate_executor_type,. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_immediate_executor.get [*get]] [static]]
-    [If T has a nested type immediate_executor_type, returns t.get_immediate_executor(). Otherwise returns asio::require(ex, asio::execution::blocking.never). ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:get associated_immediate_executor::get]
-
-[indexterm2 asio.indexterm.associated_immediate_executor.get..get..associated_immediate_executor] 
-If `T` has a nested type `immediate_executor_type`, returns `t.get_immediate_executor()`. Otherwise returns `asio::require(ex, asio::execution::blocking.never)`. 
-
-
-  static decltype(auto) get(
-      const T & t,
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-
-[section:type associated_immediate_executor::type]
-
-[indexterm2 asio.indexterm.associated_immediate_executor.type..type..associated_immediate_executor] 
-If `T` has a nested type `immediate_executor_type`,. 
-
-
-  typedef see_below type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_ associated_immediate_executor< reference_wrapper< T >, Executor >]
-
-[indexterm1 asio.indexterm.associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_..associated_immediate_executor< reference_wrapper< T >, Executor >]
-
-
-Specialisation of [link asio.reference.associated_immediate_executor `associated_immediate_executor`] for `std::reference_wrapper`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct associated_immediate_executor< reference_wrapper< T >, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.type [*type]]]
-    [Forwards type to the associator specialisation for the unwrapped type T. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get [*get]] [static]]
-    [Forwards the request to get the executor to the associator specialisation for the unwrapped type T. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:get associated_immediate_executor< reference_wrapper< T >, Executor >::get]
-
-[indexterm2 asio.indexterm.associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.get..get..associated_immediate_executor< reference_wrapper< T >, Executor >] 
-Forwards the request to get the executor to the associator specialisation for the unwrapped type `T`. 
-
-
-  static auto get(
-      reference_wrapper< T > t,
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-
-[section:type associated_immediate_executor< reference_wrapper< T >, Executor >::type]
-
-[indexterm2 asio.indexterm.associated_immediate_executor_lt__reference_wrapper_lt__T__gt__comma__Executor__gt_.type..type..associated_immediate_executor< reference_wrapper< T >, Executor >] 
-Forwards `type` to the associator specialisation for the unwrapped type `T`. 
-
-
-  typedef associated_immediate_executor< T, Executor >::type type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_immediate_executor.type [*type]]]
-    [If T has a nested type immediate_executor_type,. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_immediate_executor.get [*get]] [static]]
-    [If T has a nested type immediate_executor_type, returns t.get_immediate_executor(). Otherwise returns asio::require(ex, asio::execution::blocking.never). ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:associated_immediate_executor_t associated_immediate_executor_t]
-
-[indexterm1 asio.indexterm.associated_immediate_executor_t..associated_immediate_executor_t]
-
-
-  typedef typename associated_immediate_executor< T, Executor >::type associated_immediate_executor_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.associated_immediate_executor.type [*type]]]
-    [If T has a nested type immediate_executor_type,. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.associated_immediate_executor.get [*get]] [static]]
-    [If T has a nested type immediate_executor_type, returns t.get_immediate_executor(). Otherwise returns asio::require(ex, asio::execution::blocking.never). ]
-  ]
-  
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type. The template parameter `Executor` shall be a type meeting the Executor requirements.
-
-Specialisations shall meet the following requirements, where `t` is a const reference to an object of type `T`, and `e` is an object of type `Executor`.
-
-
-* Provide a nested typedef `type` that identifies a type meeting the Executor requirements.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t)` and with return type `type` or a (possibly const) reference to `type`.
-
-
-* Provide a noexcept static member function named `get`, callable as `get(t,e)` and with return type `type` or a (possibly const) reference to `type`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:associator associator]
-
-[indexterm1 asio.indexterm.associator..associator]
-
-
-Used to generically specialise associators for a type. 
-
-
-  template<
-      template< typename, typename > class Associator,
-      typename T,
-      typename DefaultCandidate,
-      typename _ = void>
-  struct associator
-
-
-[heading Requirements]
-
-['Header: ][^asio/associator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:async_completion async_completion]
-
-[indexterm1 asio.indexterm.async_completion..async_completion]
-
-
-Helper template to deduce the handler type from a CompletionToken, capture a local copy of the handler, and then create an [link asio.reference.async_result `async_result`] for the handler. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Signatures>
-  struct async_completion
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.async_completion.completion_handler_type [*completion_handler_type]]]
-    [The real handler type to be used for the asynchronous operation. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_completion.async_completion [*async_completion]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_completion.completion_handler [*completion_handler]]]
-    [A copy of, or reference to, a real handler object. ]
-  ]
-
-  [
-    [[link asio.reference.async_completion.result [*result]]]
-    [The result of the asynchronous operation's initiating function. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_completion async_completion::async_completion]
-
-[indexterm2 asio.indexterm.async_completion.async_completion..async_completion..async_completion] 
-Constructor. 
-
-
-  async_completion(
-      CompletionToken & token);
-
-
-The constructor creates the concrete completion handler and makes the link between the handler and the asynchronous result. 
-
-
-[endsect]
-
-
-
-[section:completion_handler async_completion::completion_handler]
-
-[indexterm2 asio.indexterm.async_completion.completion_handler..completion_handler..async_completion] 
-A copy of, or reference to, a real handler object. 
-
-
-  conditional_t< is_same< CompletionToken, completion_handler_type >::value, completion_handler_type &, completion_handler_type > completion_handler;
-
-
-
-[endsect]
-
-
-
-[section:completion_handler_type async_completion::completion_handler_type]
-
-[indexterm2 asio.indexterm.async_completion.completion_handler_type..completion_handler_type..async_completion] 
-The real handler type to be used for the asynchronous operation. 
-
-
-  typedef asio::async_result< decay_t< CompletionToken >, Signatures... >::completion_handler_type completion_handler_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.async_result.completion_handler_type [*completion_handler_type]]]
-    [The concrete completion handler type for the specific signature. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.async_result.return_type [*return_type]]]
-    [The return type of the initiating function. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_result.async_result [*async_result]] [constructor]]
-    [Construct an async result from a given handler. ]
-  ]
-  
-  [
-    [[link asio.reference.async_result.get [*get]]]
-    [Obtain the value to be returned from the initiating function. ]
-  ]
-  
-  [
-    [[link asio.reference.async_result.initiate [*initiate]] [static]]
-    [Initiate the asynchronous operation that will produce the result, and obtain the value to be returned from the initiating function. ]
-  ]
-  
-]
-
-The [link asio.reference.async_result `async_result`] traits class is used for determining:
-
-
-* the concrete completion handler type to be called at the end of the asynchronous operation;
-
-
-* the initiating function return type; and
-
-
-* how the return value of the initiating function is obtained.
-
-The trait allows the handler and return types to be determined at the point where the specific completion handler signature is known.
-
-This template may be specialised for user-defined completion token types. The primary template assumes that the CompletionToken is the completion handler. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:result async_completion::result]
-
-[indexterm2 asio.indexterm.async_completion.result..result..async_completion] 
-The result of the asynchronous operation's initiating function. 
-
-
-  async_result< decay_t< CompletionToken >, Signatures... > result;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:async_compose async_compose]
-
-[indexterm1 asio.indexterm.async_compose..async_compose]
-
-Launch an asynchronous operation with a stateful implementation. 
-
-
-  template<
-      typename CompletionToken,
-      typename Signature,
-      typename Implementation,
-      typename... IoObjectsOrExecutors>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_compose(
-      Implementation && implementation,
-      type_identity_t< CompletionToken > & token,
-      IoObjectsOrExecutors &&... io_objects_or_executors);
-
-
-The async\_compose function simplifies the implementation of composed asynchronous operations automatically wrapping a stateful function object with a conforming intermediate completion handler.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[implementation][A function object that contains the implementation of the composed asynchronous operation. The first argument to the function object is a non-const reference to the enclosing intermediate completion handler. The remaining arguments are any arguments that originate from the completion handlers of any asynchronous operations performed by the implementation.]]
-
-[[token][The completion token.]]
-
-[[io_objects_or_executors][Zero or more I/O objects or I/O executors for which outstanding work must be maintained.]]
-
-]
-
-
-[heading Per-Operation Cancellation]
-  
-By default, terminal per-operation cancellation is enabled for composed operations that are implemented using `async_compose`. To disable cancellation for the composed operation, or to alter its supported cancellation types, call the `self` object's `reset_cancellation_state` function.
-
-
-[heading Example:]
-  
-
-
-
-
-  struct async_echo_implementation
-  {
-    tcp::socket& socket_;
-    asio::mutable_buffer buffer_;
-    enum { starting, reading, writing } state_;
-
-    template <typename Self>
-    void operator()(Self& self,
-        asio::error_code error = {},
-        std::size_t n = 0)
-    {
-      switch (state_)
-      {
-      case starting:
-        state_ = reading;
-        socket_.async_read_some(
-            buffer_, std::move(self));
-        break;
-      case reading:
-        if (error)
-        {
-          self.complete(error, 0);
-        }
-        else
-        {
-          state_ = writing;
-          asio::async_write(socket_, buffer_,
-              asio::transfer_exactly(n),
-              std::move(self));
-        }
-        break;
-      case writing:
-        self.complete(error, n);
-        break;
-      }
-    }
-  };
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      asio::mutable_buffer buffer,
-      CompletionToken&& token)
-    -> decltype(
-      asio::async_compose<CompletionToken,
-        void(asio::error_code, std::size_t)>(
-          std::declval<async_echo_implementation>(),
-          token, socket))
-  {
-    return asio::async_compose<CompletionToken,
-      void(asio::error_code, std::size_t)>(
-        async_echo_implementation{socket, buffer,
-          async_echo_implementation::starting},
-        token, socket);
-  } 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/compose.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:async_connect async_connect]
-
-[indexterm1 asio.indexterm.async_connect..async_connect]
-
-The `async_connect` function is a composed asynchronous operation that establishes a socket connection by trying each endpoint in a sequence. 
-
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.RangeConnectToken RangeConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload1 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      RangeConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< !is_connect_condition< RangeConnectToken, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload1 more...]]``
-
-(Deprecated: Use range overload.) Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload2 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< !is_same< Iterator, decay_t< IteratorConnectToken > >::value >  = 0,
-      constraint_t< !is_connect_condition< IteratorConnectToken, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload2 more...]]``
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload3 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_connect_condition< IteratorConnectToken, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.RangeConnectToken RangeConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload4 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      RangeConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload4 more...]]``
-
-(Deprecated: Use range overload.) Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload5 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload5 more...]]``
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_connect.overload6 async_connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_connect.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/connect.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_connect (1 of 6 overloads)]
-
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.RangeConnectToken RangeConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      RangeConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< !is_connect_condition< RangeConnectToken, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, the successfully connected endpoint.
-    // Otherwise, a default-constructed endpoint.
-    const typename Protocol::endpoint& endpoint
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, typename Protocol::endpoint) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-
-  // ...
-
-  r.async_resolve(q, resolve_handler);
-
-  // ...
-
-  void resolve_handler(
-      const asio::error_code& ec,
-      tcp::resolver::results_type results)
-  {
-    if (!ec)
-    {
-      asio::async_connect(s, results, connect_handler);
-    }
-  }
-
-  // ...
-
-  void connect_handler(
-      const asio::error_code& ec,
-      const tcp::endpoint& endpoint)
-  {
-    // ...
-  } 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_connect (2 of 6 overloads)]
-
-
-(Deprecated: Use range overload.) Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< !is_same< Iterator, decay_t< IteratorConnectToken > >::value >  = 0,
-      constraint_t< !is_connect_condition< IteratorConnectToken, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, an iterator denoting the successfully
-    // connected endpoint. Otherwise, the end iterator.
-    Iterator iterator
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, Iterator) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_connect (3 of 6 overloads)]
-
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_connect_condition< IteratorConnectToken, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, an iterator denoting the successfully
-    // connected endpoint. Otherwise, the end iterator.
-    Iterator iterator
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, Iterator) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  std::vector<tcp::endpoint> endpoints = ...;
-  tcp::socket s(my_context);
-  asio::async_connect(s,
-      endpoints.begin(), endpoints.end(),
-      connect_handler);
-
-  // ...
-
-  void connect_handler(
-      const asio::error_code& ec,
-      std::vector<tcp::endpoint>::iterator i)
-  {
-    // ...
-  } 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_connect (4 of 6 overloads)]
-
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.RangeConnectToken RangeConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      RangeConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, an iterator denoting the successfully
-    // connected endpoint. Otherwise, the end iterator.
-    Iterator iterator
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, typename Protocol::endpoint) 
-
-
-
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-
-  // ...
-
-  r.async_resolve(q, resolve_handler);
-
-  // ...
-
-  void resolve_handler(
-      const asio::error_code& ec,
-      tcp::resolver::results_type results)
-  {
-    if (!ec)
-    {
-      asio::async_connect(s, results,
-          my_connect_condition(),
-          connect_handler);
-    }
-  }
-
-  // ...
-
-  void connect_handler(
-      const asio::error_code& ec,
-      const tcp::endpoint& endpoint)
-  {
-    if (ec)
-    {
-      // An error occurred.
-    }
-    else
-    {
-      std::cout << "Connected to: " << endpoint << std::endl;
-    }
-  } 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-
-[section:overload5 async_connect (5 of 6 overloads)]
-
-
-(Deprecated: Use range overload.) Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, an iterator denoting the successfully
-    // connected endpoint. Otherwise, the end iterator.
-    Iterator iterator
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, Iterator) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-
-[section:overload6 async_connect (6 of 6 overloads)]
-
-
-Asynchronously establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``,
-      typename ``[link asio.reference.IteratorConnectToken IteratorConnectToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      IteratorConnectToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `async_connect` member function, once for each endpoint in the sequence, until a connection is successfully established. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation. if the sequence is empty, set to
-    // asio::error::not_found. Otherwise, contains the
-    // error from the last connection attempt.
-    const asio::error_code& error,
-
-    // On success, an iterator denoting the successfully
-    // connected endpoint. Otherwise, the end iterator.
-    Iterator iterator
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, Iterator) 
-
-
-
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-
-  // ...
-
-  r.async_resolve(q, resolve_handler);
-
-  // ...
-
-  void resolve_handler(
-      const asio::error_code& ec,
-      tcp::resolver::iterator i)
-  {
-    if (!ec)
-    {
-      tcp::resolver::iterator end;
-      asio::async_connect(s, i, end,
-          my_connect_condition(),
-          connect_handler);
-    }
-  }
-
-  // ...
-
-  void connect_handler(
-      const asio::error_code& ec,
-      tcp::resolver::iterator i)
-  {
-    if (ec)
-    {
-      // An error occurred.
-    }
-    else
-    {
-      std::cout << "Connected to: " << i->endpoint() << std::endl;
-    }
-  } 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the socket's `async_connect` operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_immediate async_immediate]
-
-[indexterm1 asio.indexterm.async_immediate..async_immediate]
-
-Launch a trivial asynchronous operation that completes immediately. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_immediate.overload1 async_immediate]``(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_immediate.overload1 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_immediate.overload2 async_immediate]``(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_immediate.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/immediate.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_immediate (1 of 2 overloads)]
-
-
-Launch a trivial asynchronous operation that completes immediately. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_immediate(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-
-
-The async\_immediate function is intended for use by composed operations, which can delegate to this operation in order to implement the correct semantics for immediate completion.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The asynchronous operation's I/O executor.]]
-
-[[token][The completion token.]]
-
-]
-
-The completion handler is immediately submitted for execution by calling [link asio.reference.dispatch `dispatch`] on the handler's associated immediate executor.
-
-If the completion handler does not have a customised associated immediate executor, then the handler is submitted as if by calling [link asio.reference.post `post`] on the supplied I/O executor.
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 async_immediate (2 of 2 overloads)]
-
-
-Launch a trivial asynchronous operation that completes immediately. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_immediate(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-The async\_immediate function is intended for use by composed operations, which can delegate to this operation in order to implement the correct semantics for immediate completion.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The execution context used to obtain the asynchronous operation's I/O executor.]]
-
-[[token][The completion token.]]
-
-]
-
-The completion handler is immediately submitted for execution by calling [link asio.reference.dispatch `dispatch`] on the handler's associated immediate executor.
-
-If the completion handler does not have a customised associated immediate executor, then the handler is submitted as if by calling [link asio.reference.post `post`] on the I/O executor obtained from the supplied execution context.
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_initiate async_initiate]
-
-[indexterm1 asio.indexterm.async_initiate..async_initiate]
-
-
-  template<
-      typename CompletionToken,
-      completion_signature... Signatures,
-      typename Initiation,
-      typename... Args>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_initiate(
-      Initiation && initiation,
-      type_identity_t< CompletionToken > & token,
-      Args &&... args);
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:async_read async_read]
-
-[indexterm1 asio.indexterm.async_read..async_read]
-
-The `async_read` function is a composed asynchronous operation that reads a certain amount of data from a stream before completion. 
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload1 async_read]``(
-      AsyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload2 async_read]``(
-      AsyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload3 async_read]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload4 async_read]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload5 async_read]``(
-      AsyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload6 async_read]``(
-      AsyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload7 async_read]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read.overload8 async_read]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read.overload8 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/read.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_read (1 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_read(s, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read(
-     s, buffers,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_read (2 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_read(s,
-     asio::buffer(data, size),
-     asio::transfer_at_least(32),
-     handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_read (3 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read(
-     s, buffers,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_read (4 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload5 async_read (5 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read(
-     s, b,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload6 async_read (6 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload7 async_read (7 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read(
-     s, buffers,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload8 async_read (8 of 8 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data from a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other read operations (such as async\_read, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async\_read\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_read_at async_read_at]
-
-[indexterm1 asio.indexterm.async_read_at..async_read_at]
-
-The `async_read_at` function is a composed asynchronous operation that reads a certain amount of data at the specified offset. 
-
-
-Start an asynchronous operation to read a certain amount of data at the specified offset. 
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_at.overload1 async_read_at]``(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_at.overload2 async_read_at]``(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_at.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_at.overload3 async_read_at]``(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_at.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_at.overload4 async_read_at]``(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_at.overload4 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/read_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_read_at (1 of 4 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_read_at(d, 42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read_at(
-     d, 42, buffers,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessReadDevice` type's async\_read\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_read_at (2 of 4 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async\_read\_some\_at function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_read_at(d, 42,
-     asio::buffer(data, size),
-     asio::transfer_at_least(32),
-     handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessReadDevice` type's async\_read\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_read_at (3 of 4 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< !is_completion_condition< ReadToken >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::async_read_at(
-     d, 42, b,
-     asio::transfer_all(),
-     handler); 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessReadDevice` type's async\_read\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_read_at (4 of 4 overloads)]
-
-
-Start an asynchronous operation to read a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessReadDevice AsyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncRandomAccessReadDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_at(
-      AsyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncRandomAccessReadDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's async\_read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async\_read\_some\_at function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes copied into the buffers. If an error
-    // occurred, this will be the number of bytes successfully
-    // transferred prior to the error.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessReadDevice` type's async\_read\_some\_at operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_read_until async_read_until]
-
-[indexterm1 asio.indexterm.async_read_until..async_read_until]
-
-The `async_read_until` function is a composed asynchronous operation that reads data into a dynamic buffer sequence, or into a streambuf, until it contains a delimiter, matches a regular expression, or a function object indicates a match. 
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload1 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload2 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload2 more...]]``
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until some part of its data matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload3 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload3 more...]]``
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload4 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload4 more...]]``
-
-Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload5 async_read_until]``(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload6 async_read_until]``(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload6 more...]]``
-
-Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload7 async_read_until]``(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload7 more...]]``
-
-Start an asynchronous operation to read data into a streambuf until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload8 async_read_until]``(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload8 more...]]``
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload9 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload10 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload10 more...]]``
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until some part of its data matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload11 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload11 more...]]``
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_read_until.overload12 async_read_until]``(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_read_until.overload12 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/read_until.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_read_until (1 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[delim][The delimiter character.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area up to and including the delimiter.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a newline is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data, '\n', handler); 
-
-
-After the `async_read_until` operation completes successfully, the buffer `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_read_until (2 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[delim][The delimiter string.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area up to and including the delimiter.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data, "\r\n", handler); 
-
-
-After the `async_read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the string `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_read_until (3 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until some part of its data matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains data that matches the regular expression, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[expr][The regular expression.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer
-    // sequence's get area up to and including the
-    // substring that matches the regular expression.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data,
-      boost::regex("\r\n"), handler); 
-
-
-After the `async_read_until` operation completes successfully, the string `data` contains the data which matched the regular expression: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the match, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the string `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_read_until (4 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the match condition function object already indicates a match, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<typename DynamicBuffer_v1::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area that have been fully consumed by the match
-    // function. O if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To asynchronously read data into a `std::string` until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::const_buffers_1> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  std::string data;
-  asio::async_read_until(s, data, match_whitespace, handler);
-
-
-
-
-To asynchronously read data into a `std::string` until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  std::string data;
-  asio::async_read_until(s, data, match_char('a'), handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload5 async_read_until (5 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-
-
-This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the streambuf's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[delim][The delimiter character.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the streambuf's get
-    // area up to and including the delimiter.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a streambuf until a newline is encountered: 
-
-  asio::streambuf b;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::istream is(&b);
-      std::string line;
-      std::getline(is, line);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, b, '\n', handler); 
-
-
-After the `async_read_until` operation completes successfully, the buffer `b` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload6 async_read_until (6 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-
-
-This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the streambuf's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[delim][The delimiter string.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the streambuf's get
-    // area up to and including the delimiter.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a streambuf until a newline is encountered: 
-
-  asio::streambuf b;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::istream is(&b);
-      std::string line;
-      std::getline(is, line);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, b, "\r\n", handler); 
-
-
-After the `async_read_until` operation completes successfully, the buffer `b` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload7 async_read_until (7 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >());
-
-
-This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* A substring of the streambuf's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the streambuf's get area already contains data that matches the regular expression, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[expr][The regular expression.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the streambuf's get
-    // area up to and including the substring
-    // that matches the regular. expression.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a streambuf until a CR-LF sequence is encountered: 
-
-  asio::streambuf b;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::istream is(&b);
-      std::string line;
-      std::getline(is, line);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, b, boost::regex("\r\n"), handler); 
-
-
-After the `async_read_until` operation completes successfully, the buffer `b` contains the data which matched the regular expression: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload8 async_read_until (8 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a streambuf until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the match condition function object already indicates a match, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the streambuf's get
-    // area that have been fully consumed by the
-    // match function. O if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent async\_read\_until operation to examine.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To asynchronously read data into a streambuf until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::streambuf::const_buffers_type> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  asio::streambuf b;
-  asio::async_read_until(s, b, match_whitespace, handler);
-
-
-
-
-To asynchronously read data into a streambuf until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  asio::streambuf b;
-  asio::async_read_until(s, b, match_char('a'), handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload9 async_read_until (9 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[delim][The delimiter character.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area up to and including the delimiter.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a newline is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data, '\n', handler); 
-
-
-After the `async_read_until` operation completes successfully, the buffer `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload10 async_read_until (10 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[delim][The delimiter string.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area up to and including the delimiter.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data, "\r\n", handler); 
-
-
-After the `async_read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the string `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload11 async_read_until (11 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until some part of its data matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the dynamic buffer sequence's get area already contains data that matches the regular expression, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[expr][The regular expression.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer
-    // sequence's get area up to and including the
-    // substring that matches the regular expression.
-    // 0 if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Example]
-  
-To asynchronously read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  ...
-  void handler(const asio::error_code& e, std::size_t size)
-  {
-    if (!e)
-    {
-      std::string line = data.substr(0, n);
-      data.erase(0, n);
-      ...
-    }
-  }
-  ...
-  asio::async_read_until(s, data,
-      boost::regex("\r\n"), handler); 
-
-
-After the `async_read_until` operation completes successfully, the string `data` contains the data which matched the regular expression: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the match, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the string `data` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `async_read_until` operation.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload12 async_read_until (12 of 12 overloads)]
-
-
-Start an asynchronous operation to read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncReadStream AsyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<        typename AsyncReadStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_until(
-      AsyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      ReadToken && token = default_completion_token_t< typename AsyncReadStream::executor_type >(),
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to asynchronously read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_read\_some function, and is known as a ['composed operation]. If the match condition function object already indicates a match, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async\_read, async\_read\_until, the stream's async\_read\_some function, or any other composed operations that perform reads) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the AsyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<typename DynamicBuffer_v2::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // The number of bytes in the dynamic buffer sequence's
-    // get area that have been fully consumed by the match
-    // function. O if an error occurred.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful async\_read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent async\_read\_until operation to examine.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To asynchronously read data into a `std::string` until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::const_buffers_1> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  std::string data;
-  asio::async_read_until(s, data, match_whitespace, handler);
-
-
-
-
-To asynchronously read data into a `std::string` until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  void handler(const asio::error_code& e, std::size_t size);
-  ...
-  std::string data;
-  asio::async_read_until(s, data, match_char('a'), handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncReadStream` type's `async_read_some` operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_result async_result]
-
-[indexterm1 asio.indexterm.async_result..async_result]
-
-
-An interface for customising the behaviour of an initiating function. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Signatures>
-  class async_result
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.async_result.completion_handler_type [*completion_handler_type]]]
-    [The concrete completion handler type for the specific signature. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.async_result.return_type [*return_type]]]
-    [The return type of the initiating function. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_result.async_result [*async_result]] [constructor]]
-    [Construct an async result from a given handler. ]
-  ]
-  
-  [
-    [[link asio.reference.async_result.get [*get]]]
-    [Obtain the value to be returned from the initiating function. ]
-  ]
-  
-  [
-    [[link asio.reference.async_result.initiate [*initiate]] [static]]
-    [Initiate the asynchronous operation that will produce the result, and obtain the value to be returned from the initiating function. ]
-  ]
-  
-]
-
-The [link asio.reference.async_result `async_result`] traits class is used for determining:
-
-
-* the concrete completion handler type to be called at the end of the asynchronous operation;
-
-
-* the initiating function return type; and
-
-
-* how the return value of the initiating function is obtained.
-
-The trait allows the handler and return types to be determined at the point where the specific completion handler signature is known.
-
-This template may be specialised for user-defined completion token types. The primary template assumes that the CompletionToken is the completion handler. 
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_result async_result::async_result]
-
-[indexterm2 asio.indexterm.async_result.async_result..async_result..async_result] 
-Construct an async result from a given handler. 
-
-
-  async_result(
-      completion_handler_type & h);
-
-
-When using a specalised [link asio.reference.async_result `async_result`], the constructor has an opportunity to initialise some state associated with the completion handler, which is then returned from the initiating function. 
-
-
-[endsect]
-
-
-
-[section:completion_handler_type async_result::completion_handler_type]
-
-[indexterm2 asio.indexterm.async_result.completion_handler_type..completion_handler_type..async_result] 
-The concrete completion handler type for the specific signature. 
-
-
-  typedef CompletionToken completion_handler_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get async_result::get]
-
-[indexterm2 asio.indexterm.async_result.get..get..async_result] 
-Obtain the value to be returned from the initiating function. 
-
-
-  return_type get();
-
-
-
-[endsect]
-
-
-
-[section:initiate async_result::initiate]
-
-[indexterm2 asio.indexterm.async_result.initiate..initiate..async_result] 
-Initiate the asynchronous operation that will produce the result, and obtain the value to be returned from the initiating function. 
-
-
-  template<
-      typename Initiation,
-      typename RawCompletionToken,
-      typename... Args>
-  static return_type initiate(
-      Initiation && initiation,
-      RawCompletionToken && token,
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:return_type async_result::return_type]
-
-[indexterm2 asio.indexterm.async_result.return_type..return_type..async_result] 
-The return type of the initiating function. 
-
-
-  typedef void return_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_ async_result< basic_yield_context< Executor >, Signature >]
-
-[indexterm1 asio.indexterm.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_..async_result< basic_yield_context< Executor >, Signature >]
-
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Signature>
-  class async_result< basic_yield_context< Executor >, Signature >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt___suspend_with_helper [*async_result< basic_yield_context< Executor >, Signature >::suspend_with_helper]]]
-    []
-  
-  ]
-
-  [
-
-    [[link asio.reference.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.handler_type [*handler_type]]]
-    []
-  
-  ]
-
-  [
-
-    [[link asio.reference.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.return_type [*return_type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.initiate [*initiate]] [static]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/impl/spawn.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:handler_type async_result< basic_yield_context< Executor >, Signature >::handler_type]
-
-[indexterm2 asio.indexterm.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.handler_type..handler_type..async_result< basic_yield_context< Executor >, Signature >] 
-
-  typedef detail::spawn_handler< Executor, Signature > handler_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/spawn.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:initiate async_result< basic_yield_context< Executor >, Signature >::initiate]
-
-[indexterm2 asio.indexterm.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.initiate..initiate..async_result< basic_yield_context< Executor >, Signature >] 
-
-  template<
-      typename Initiation,
-      typename... InitArgs>
-  static return_type initiate(
-      Initiation && init,
-      const basic_yield_context< Executor > & yield,
-      InitArgs &&... init_args);
-
-
-
-[endsect]
-
-
-
-[section:return_type async_result< basic_yield_context< Executor >, Signature >::return_type]
-
-[indexterm2 asio.indexterm.async_result_lt__basic_yield_context_lt__Executor__gt__comma__Signature__gt_.return_type..return_type..async_result< basic_yield_context< Executor >, Signature >] 
-
-  typedef handler_type::return_type return_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/spawn.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_ async_result< std::packaged_task< Result(Args...)>, Signature >]
-
-[indexterm1 asio.indexterm.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_..async_result< std::packaged_task< Result(Args\.\.\.)>, Signature >]
-
-
-Partial specialisation of `async_result` for `std::packaged_task`. 
-
-
-  template<
-      typename Result,
-      typename... Args,
-      typename Signature>
-  class async_result< std::packaged_task< Result(Args...)>, Signature >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.completion_handler_type [*completion_handler_type]]]
-    [The packaged task is the concrete completion handler type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.return_type [*return_type]]]
-    [The return type of the initiating function is the future obtained from the packaged task. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.async_result [*async_result]]]
-    [The constructor extracts the future from the packaged task. ]
-  ]
-  
-  [
-    [[link asio.reference.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.get [*get]]]
-    [Returns the packaged task's future. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/packaged_task.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_result async_result< std::packaged_task< Result(Args...)>, Signature >::async_result]
-
-[indexterm2 asio.indexterm.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.async_result..async_result..async_result< std::packaged_task< Result(Args\.\.\.)>, Signature >] 
-The constructor extracts the future from the packaged task. 
-
-
-  async_result(
-      completion_handler_type & h);
-
-
-
-[endsect]
-
-
-
-[section:completion_handler_type async_result< std::packaged_task< Result(Args...)>, Signature >::completion_handler_type]
-
-[indexterm2 asio.indexterm.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.completion_handler_type..completion_handler_type..async_result< std::packaged_task< Result(Args\.\.\.)>, Signature >] 
-The packaged task is the concrete completion handler type. 
-
-
-  typedef std::packaged_task< Result(Args...)> completion_handler_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/packaged_task.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get async_result< std::packaged_task< Result(Args...)>, Signature >::get]
-
-[indexterm2 asio.indexterm.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.get..get..async_result< std::packaged_task< Result(Args\.\.\.)>, Signature >] 
-Returns the packaged task's future. 
-
-
-  return_type get();
-
-
-
-[endsect]
-
-
-
-[section:return_type async_result< std::packaged_task< Result(Args...)>, Signature >::return_type]
-
-[indexterm2 asio.indexterm.async_result_lt__std__packaged_task_lt__Result_lp_Args_ellipsis__rp__gt__comma__Signature__gt_.return_type..return_type..async_result< std::packaged_task< Result(Args\.\.\.)>, Signature >] 
-The return type of the initiating function is the future obtained from the packaged task. 
-
-
-  typedef std::future< Result > return_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/packaged_task.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:async_write async_write]
-
-[indexterm1 asio.indexterm.async_write..async_write]
-
-The `async_write` function is a composed asynchronous operation that writes a certain amount of data to a stream before completion. 
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload1 async_write]``(
-      AsyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload1 more...]]``
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload2 async_write]``(
-      AsyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload2 more...]]``
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload3 async_write]``(
-      AsyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload3 more...]]``
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload4 async_write]``(
-      AsyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload4 more...]]``
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload5 async_write]``(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload5 more...]]``
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload6 async_write]``(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload6 more...]]``
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload7 async_write]``(
-      AsyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload7 more...]]``
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write.overload8 async_write]``(
-      AsyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write.overload8 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/write.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_write (1 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_write(s, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_write (2 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_write(s,
-     asio::buffer(data, size),
-     asio::transfer_at_least(32),
-     handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_write (3 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called. Successfully written data is automatically consumed from the buffers.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_write (4 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload5 async_write (5 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload6 async_write (6 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload7 async_write (7 of 8 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< !is_completion_condition< decay_t< WriteToken > >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called. Successfully written data is automatically consumed from the buffers.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-
-[section:overload8 async_write (8 of 8 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data to a stream. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncWriteStream AsyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<typename AsyncWriteStream::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write(
-      AsyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncWriteStream::executor_type >(),
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's async\_write\_some function, and is known as a ['composed operation]. The program must ensure that the stream performs no other write operations (such as async\_write, the stream's async\_write\_some function, or any other composed operations that perform writes) until this operation completes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the AsyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async\_write\_some function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncWriteStream` type's `async_write_some` operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_write_at async_write_at]
-
-[indexterm1 asio.indexterm.async_write_at..async_write_at]
-
-The `async_write_at` function is a composed asynchronous operation that writes a certain amount of data at the specified offset before completion. 
-
-
-Start an asynchronous operation to write all of the supplied data at the specified offset. 
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write_at.overload1 async_write_at]``(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< !is_completion_condition< WriteToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write_at.overload1 more...]]``
-
-Start an asynchronous operation to write a certain amount of data at the specified offset. 
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write_at.overload2 async_write_at]``(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write_at.overload2 more...]]``
-
-Start an asynchronous operation to write all of the supplied data at the specified offset. 
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write_at.overload3 async_write_at]``(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< !is_completion_condition< WriteToken >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write_at.overload3 more...]]``
-
-Start an asynchronous operation to write a certain amount of data at the specified offset. 
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.async_write_at.overload4 async_write_at]``(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.async_write_at.overload4 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/write_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 async_write_at (1 of 4 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< !is_completion_condition< WriteToken >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function, and is known as a ['composed operation]. The program must ensure that the device performs no ['overlapping] write operations (such as async\_write\_at, the device's async\_write\_some\_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_write_at(d, 42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessWriteDevice` type's async\_write\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 async_write_at (2 of 4 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function, and is known as a ['composed operation]. The program must ensure that the device performs no ['overlapping] write operations (such as async\_write\_at, the device's async\_write\_some\_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async\_write\_some\_at function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::async_write_at(d, 42,
-     asio::buffer(data, size),
-     asio::transfer_at_least(32),
-     handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessWriteDevice` type's async\_write\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 async_write_at (3 of 4 overloads)]
-
-
-Start an asynchronous operation to write all of the supplied data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< !is_completion_condition< WriteToken >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function, and is known as a ['composed operation]. The program must ensure that the device performs no ['overlapping] write operations (such as async\_write\_at, the device's async\_write\_some\_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessWriteDevice` type's async\_write\_some\_at operation. 
-
-
-[endsect]
-
-
-
-[section:overload4 async_write_at (4 of 4 overloads)]
-
-
-Start an asynchronous operation to write a certain amount of data at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.AsyncRandomAccessWriteDevice AsyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<        typename AsyncRandomAccessWriteDevice::executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_at(
-      AsyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      WriteToken && token = default_completion_token_t< typename AsyncRandomAccessWriteDevice::executor_type >(),
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's async\_write\_some\_at function, and is known as a ['composed operation]. The program must ensure that the device performs no ['overlapping] write operations (such as async\_write\_at, the device's async\_write\_some\_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][A [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the completion handler is called.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest async_write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async\_write\_some\_at function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // Number of bytes written from the buffers. If an error
-    // occurred, this will be less than the sum of the buffer sizes.
-    std::size_t bytes_transferred
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `AsyncRandomAccessWriteDevice` type's async\_write\_some\_at operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:awaitable awaitable]
-
-[indexterm1 asio.indexterm.awaitable..awaitable]
-
-
-The return type of a coroutine or asynchronous operation. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class awaitable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.awaitable.executor_type [*executor_type]]]
-    [The executor type that will be used for the coroutine. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.awaitable.value_type [*value_type]]]
-    [The type of the awaited value. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.awaitable.awaitable [*awaitable]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.awaitable.operator_eq_ [*operator=]]]
-    [Move assignment. ]
-  ]
-  
-  [
-    [[link asio.reference.awaitable.valid [*valid]]]
-    [Checks if the awaitable refers to a future result. ]
-  ]
-  
-  [
-    [[link asio.reference.awaitable._awaitable [*~awaitable]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:awaitable awaitable::awaitable]
-
-[indexterm2 asio.indexterm.awaitable.awaitable..awaitable..awaitable] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.awaitable.awaitable.overload1 awaitable]``();
-  ``  [''''&raquo;''' [link asio.reference.awaitable.awaitable.overload1 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.awaitable.awaitable.overload2 awaitable]``(
-      awaitable && other);
-  ``  [''''&raquo;''' [link asio.reference.awaitable.awaitable.overload2 more...]]``
-
-
-[section:overload1 awaitable::awaitable (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr awaitable();
-
-
-
-[endsect]
-
-
-
-[section:overload2 awaitable::awaitable (2 of 2 overloads)]
-
-
-Move constructor. 
-
-
-  awaitable(
-      awaitable && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type awaitable::executor_type]
-
-[indexterm2 asio.indexterm.awaitable.executor_type..executor_type..awaitable] 
-The executor type that will be used for the coroutine. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ awaitable::operator=]
-
-[indexterm2 asio.indexterm.awaitable.operator_eq_..operator=..awaitable] 
-Move assignment. 
-
-
-  awaitable & operator=(
-      awaitable && other);
-
-
-
-[endsect]
-
-
-
-[section:valid awaitable::valid]
-
-[indexterm2 asio.indexterm.awaitable.valid..valid..awaitable] 
-Checks if the awaitable refers to a future result. 
-
-
-  bool valid() const;
-
-
-
-[endsect]
-
-
-
-[section:value_type awaitable::value_type]
-
-[indexterm2 asio.indexterm.awaitable.value_type..value_type..awaitable] 
-The type of the awaited value. 
-
-
-  typedef T value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_awaitable awaitable::~awaitable]
-
-[indexterm2 asio.indexterm.awaitable._awaitable..~awaitable..awaitable] 
-Destructor. 
-
-
-  ~awaitable();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:bad_executor bad_executor]
-
-[indexterm1 asio.indexterm.bad_executor..bad_executor]
-
-
-Exception thrown when trying to access an empty polymorphic executor. 
-
-
-  class bad_executor :
-    public exception
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.bad_executor.bad_executor [*bad_executor]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.bad_executor.what [*what]]]
-    [Obtain message associated with exception. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:bad_executor bad_executor::bad_executor]
-
-[indexterm2 asio.indexterm.bad_executor.bad_executor..bad_executor..bad_executor] 
-Constructor. 
-
-
-  bad_executor();
-
-
-
-[endsect]
-
-
-
-[section:what bad_executor::what]
-
-[indexterm2 asio.indexterm.bad_executor.what..what..bad_executor] 
-Obtain message associated with exception. 
-
-
-  virtual const char * what() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_datagram_socket basic_datagram_socket]
-
-[indexterm1 asio.indexterm.basic_datagram_socket..basic_datagram_socket]
-
-
-Provides datagram-oriented socket functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_datagram_socket :
-    public basic_socket< Protocol, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]] [constructor]]
-    [Construct a basic_datagram_socket without opening it. 
-     [hr]
-     Construct and open a basic_datagram_socket. 
-     [hr]
-     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_datagram_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_datagram_socket from another. 
-     [hr]
-     Move-construct a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_datagram_socket from another. 
-     [hr]
-     Move-assign a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
-    [Receive a datagram with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send_to [*send_to]]]
-    [Send a datagram to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket._basic_datagram_socket [*~basic_datagram_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class template provides asynchronous and blocking datagram-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_datagram_socket::assign]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.assign..assign..basic_datagram_socket] 
-Assign an existing native socket to the socket. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.assign.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_connect basic_datagram_socket::async_connect]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_connect..async_connect..basic_datagram_socket] 
-Start an asynchronous connect. 
-
-
-  template<
-      typename ``[link asio.reference.ConnectToken ConnectToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      const endpoint_type & peer_endpoint,
-      ConnectToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously connect a socket to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void connect_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Connect succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_connect(endpoint, connect_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:async_receive basic_datagram_socket::async_receive]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_receive..async_receive..basic_datagram_socket] 
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_receive.overload1 async_receive]``(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_receive.overload2 async_receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_receive.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::async_receive (1 of 2 overloads)]
-
-
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the datagram socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected datagram socket.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::async_receive (2 of 2 overloads)]
-
-
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the datagram socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected datagram socket.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_receive_from basic_datagram_socket::async_receive_from]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_receive_from..async_receive_from..basic_datagram_socket] 
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_receive_from.overload1 async_receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_receive_from.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_receive_from.overload2 async_receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_receive_from.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::async_receive_from (1 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive a datagram. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive_from(
-     asio::buffer(data, size), sender_endpoint, handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::async_receive_from (2 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive a datagram. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_send basic_datagram_socket::async_send]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_send..async_send..basic_datagram_socket] 
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_send.overload1 async_send]``(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_send.overload2 async_send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_send.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::async_send (1 of 2 overloads)]
-
-
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the datagram socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected datagram socket.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_send(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::async_send (2 of 2 overloads)]
-
-
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the datagram socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected datagram socket.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_send_to basic_datagram_socket::async_send_to]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_send_to..async_send_to..basic_datagram_socket] 
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_send_to.overload1 async_send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_send_to.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_datagram_socket.async_send_to.overload2 async_send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.async_send_to.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::async_send_to (1 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send a datagram to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint destination(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_send_to(
-      asio::buffer(data, size), destination, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::async_send_to (2 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send a datagram to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait basic_datagram_socket::async_wait]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.async_wait..async_wait..basic_datagram_socket] 
-Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:at_mark basic_datagram_socket::at_mark]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.at_mark..at_mark..basic_datagram_socket] 
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool ``[link asio.reference.basic_datagram_socket.at_mark.overload1 at_mark]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.at_mark.overload1 more...]]``
-
-  bool ``[link asio.reference.basic_datagram_socket.at_mark.overload2 at_mark]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.at_mark.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::at_mark (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark() const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::at_mark (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark(
-      asio::error_code & ec) const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:available basic_datagram_socket::available]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.available..available..basic_datagram_socket] 
-Determine the number of bytes available for reading. 
-
-
-  std::size_t ``[link asio.reference.basic_datagram_socket.available.overload1 available]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.available.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_datagram_socket.available.overload2 available]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.available.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::available (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available() const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::available (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available(
-      asio::error_code & ec) const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_datagram_socket basic_datagram_socket::basic_datagram_socket]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.basic_datagram_socket..basic_datagram_socket..basic_datagram_socket] 
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload1 basic_datagram_socket]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload2 basic_datagram_socket]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_datagram_socket `basic_datagram_socket`]. 
-
-
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload3 basic_datagram_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload4 basic_datagram_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload4 more...]]``
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`], opening it and binding it to the given local endpoint. 
-
-
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload5 basic_datagram_socket]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload6 basic_datagram_socket]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] on an existing native socket. 
-
-
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload7 basic_datagram_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload8 basic_datagram_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from another. 
-
-
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload9 basic_datagram_socket]``(
-      basic_datagram_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_datagram_socket.basic_datagram_socket.overload10 basic_datagram_socket]``(
-      basic_datagram_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.basic_datagram_socket.overload10 more...]]``
-
-
-[section:overload1 basic_datagram_socket::basic_datagram_socket (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] without opening it. 
-
-
-  basic_datagram_socket(
-      const executor_type & ex);
-
-
-This constructor creates a datagram socket without opening it. The `open()` function must be called before data can be sent or received on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::basic_datagram_socket (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_datagram_socket(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a datagram socket without opening it. The `open()` function must be called before data can be sent or received on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::basic_datagram_socket (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_datagram_socket `basic_datagram_socket`]. 
-
-
-  basic_datagram_socket(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates and opens a datagram socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_datagram_socket::basic_datagram_socket (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_datagram_socket `basic_datagram_socket`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_datagram_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a datagram socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_datagram_socket::basic_datagram_socket (5 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`], opening it and binding it to the given local endpoint. 
-
-
-  basic_datagram_socket(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-
-
-This constructor creates a datagram socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the datagram socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_datagram_socket::basic_datagram_socket (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`], opening it and binding it to the given local endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_datagram_socket(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a datagram socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the datagram socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_datagram_socket::basic_datagram_socket (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] on an existing native socket. 
-
-
-  basic_datagram_socket(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-This constructor creates a datagram socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_datagram_socket::basic_datagram_socket (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] on an existing native socket. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_datagram_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a datagram socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_datagram_socket::basic_datagram_socket (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from another. 
-
-
-  basic_datagram_socket(
-      basic_datagram_socket && other);
-
-
-This constructor moves a datagram socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_datagram_socket `basic_datagram_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_datagram_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_datagram_socket::basic_datagram_socket (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_datagram_socket(
-      basic_datagram_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a datagram socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_datagram_socket `basic_datagram_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_datagram_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_datagram_socket::bind]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.bind..bind..basic_datagram_socket] 
-Bind the socket to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.bind.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::bind (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::bind (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  asio::error_code ec;
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_datagram_socket::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.broadcast..broadcast..basic_datagram_socket] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_datagram_socket::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.bytes_readable..bytes_readable..basic_datagram_socket] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_datagram_socket::cancel]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.cancel..cancel..basic_datagram_socket] 
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_datagram_socket::close]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.close..close..basic_datagram_socket] 
-Close the socket. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.close.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::close (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close();
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::close (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect basic_datagram_socket::connect]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.connect..connect..basic_datagram_socket] 
-Connect the socket to the specified endpoint. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.connect.overload1 connect]``(
-      const endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.connect.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.connect.overload2 connect]``(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.connect.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::connect (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.connect(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::connect (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  asio::error_code ec;
-  socket.connect(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_datagram_socket::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.debug..debug..basic_datagram_socket] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_datagram_socket::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.do_not_route..do_not_route..basic_datagram_socket] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_datagram_socket::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.enable_connection_aborted..enable_connection_aborted..basic_datagram_socket] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_datagram_socket::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.endpoint_type..endpoint_type..basic_datagram_socket] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_datagram_socket::executor_type]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.executor_type..executor_type..basic_datagram_socket] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_datagram_socket::get_executor]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.get_executor..get_executor..basic_datagram_socket] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_datagram_socket::get_option]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.get_option..get_option..basic_datagram_socket] 
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_datagram_socket.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_datagram_socket.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::get_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::get_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  asio::error_code ec;
-  socket.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_datagram_socket::io_control]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.io_control..io_control..basic_datagram_socket] 
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_datagram_socket.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_datagram_socket.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::io_control (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::io_control (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_datagram_socket::is_open]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.is_open..is_open..basic_datagram_socket] 
-Determine whether the socket is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_datagram_socket::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.keep_alive..keep_alive..basic_datagram_socket] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_datagram_socket::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.linger..linger..basic_datagram_socket] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:local_endpoint basic_datagram_socket::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.local_endpoint..local_endpoint..basic_datagram_socket] 
-Get the local endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_datagram_socket.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_datagram_socket.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::local_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::local_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer basic_datagram_socket::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.lowest_layer..lowest_layer..basic_datagram_socket] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_datagram_socket.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_datagram_socket.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_datagram_socket::lowest_layer_type]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.lowest_layer_type..lowest_layer_type..basic_datagram_socket] 
-A [link asio.reference.basic_socket `basic_socket`] is always the lowest layer. 
-
-
-  typedef basic_socket< Protocol, Executor > lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections basic_datagram_socket::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.max_connections..max_connections..basic_datagram_socket] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_datagram_socket::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.max_listen_connections..max_listen_connections..basic_datagram_socket] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_datagram_socket::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.message_do_not_route..message_do_not_route..basic_datagram_socket] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_datagram_socket::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.message_end_of_record..message_end_of_record..basic_datagram_socket] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_datagram_socket::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.message_flags..message_flags..basic_datagram_socket] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_datagram_socket::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.message_out_of_band..message_out_of_band..basic_datagram_socket] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_datagram_socket::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.message_peek..message_peek..basic_datagram_socket] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_datagram_socket::native_handle]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.native_handle..native_handle..basic_datagram_socket] 
-Get the native socket representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_datagram_socket::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.native_handle_type..native_handle_type..basic_datagram_socket] 
-The native representation of a socket. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_datagram_socket::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.native_non_blocking..native_non_blocking..basic_datagram_socket] 
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool ``[link asio.reference.basic_datagram_socket.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::native_non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying socket is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::native_non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::native_non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_datagram_socket::non_blocking]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.non_blocking..non_blocking..basic_datagram_socket] 
-Gets the non-blocking mode of the socket. 
-
-
-  bool ``[link asio.reference.basic_datagram_socket.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the socket. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_datagram_socket::open]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.open..open..basic_datagram_socket] 
-Open the socket using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.open.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::open (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::open (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  socket.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_datagram_socket::operator=]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.operator_eq_..operator=..basic_datagram_socket] 
-Move-assign a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from another. 
-
-
-  basic_datagram_socket & ``[link asio.reference.basic_datagram_socket.operator_eq_.overload1 operator=]``(
-      basic_datagram_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_datagram_socket & > ``[link asio.reference.basic_datagram_socket.operator_eq_.overload2 operator=]``(
-      basic_datagram_socket< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from another. 
-
-
-  basic_datagram_socket & operator=(
-      basic_datagram_socket && other);
-
-
-This assignment operator moves a datagram socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_datagram_socket `basic_datagram_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_datagram_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_datagram_socket `basic_datagram_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_datagram_socket & > operator=(
-      basic_datagram_socket< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves a datagram socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_datagram_socket `basic_datagram_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_datagram_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_datagram_socket::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.out_of_band_inline..out_of_band_inline..basic_datagram_socket] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_datagram_socket::protocol_type]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.protocol_type..protocol_type..basic_datagram_socket] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:receive basic_datagram_socket::receive]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.receive..receive..basic_datagram_socket] 
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive.overload1 receive]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive.overload2 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive.overload3 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::receive (1 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::receive (2 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::receive (3 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected datagram socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_buffer_size basic_datagram_socket::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.receive_buffer_size..receive_buffer_size..basic_datagram_socket] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:receive_from basic_datagram_socket::receive_from]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.receive_from..receive_from..basic_datagram_socket] 
-Receive a datagram with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive_from.overload1 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive_from.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive_from.overload2 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive_from.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.receive_from.overload3 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.receive_from.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::receive_from (1 of 3 overloads)]
-
-
-Receive a datagram with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint);
-
-
-This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint sender_endpoint;
-  socket.receive_from(
-      asio::buffer(data, size), sender_endpoint);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::receive_from (2 of 3 overloads)]
-
-
-Receive a datagram with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags);
-
-
-This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::receive_from (3 of 3 overloads)]
-
-
-Receive a datagram with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the datagram.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_low_watermark basic_datagram_socket::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.receive_low_watermark..receive_low_watermark..basic_datagram_socket] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_datagram_socket::release]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.release..release..basic_datagram_socket] 
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type ``[link asio.reference.basic_datagram_socket.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_datagram_socket.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.release.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::release (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::release (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:remote_endpoint basic_datagram_socket::remote_endpoint]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.remote_endpoint..remote_endpoint..basic_datagram_socket] 
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_datagram_socket.remote_endpoint.overload1 remote_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.remote_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_datagram_socket.remote_endpoint.overload2 remote_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.remote_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::remote_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint() const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::remote_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_datagram_socket::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.reuse_address..reuse_address..basic_datagram_socket] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send basic_datagram_socket::send]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.send..send..basic_datagram_socket] 
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send.overload1 send]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send.overload2 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send.overload3 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::send (1 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One ore more data buffers to be sent on the socket.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.send(asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::send (2 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One ore more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::send (3 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected datagram socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:send_buffer_size basic_datagram_socket::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.send_buffer_size..send_buffer_size..basic_datagram_socket] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_datagram_socket::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.send_low_watermark..send_low_watermark..basic_datagram_socket] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send_to basic_datagram_socket::send_to]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.send_to..send_to..basic_datagram_socket] 
-Send a datagram to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send_to.overload1 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send_to.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send_to.overload2 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send_to.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_datagram_socket.send_to.overload3 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.send_to.overload3 more...]]``
-
-
-[section:overload1 basic_datagram_socket::send_to (1 of 3 overloads)]
-
-
-Send a datagram to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination);
-
-
-This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint destination(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.send_to(asio::buffer(data, size), destination);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::send_to (2 of 3 overloads)]
-
-
-Send a datagram to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags);
-
-
-This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_datagram_socket::send_to (3 of 3 overloads)]
-
-
-Send a datagram to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_option basic_datagram_socket::set_option]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.set_option..set_option..basic_datagram_socket] 
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_datagram_socket.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_datagram_socket.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::set_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::set_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  asio::error_code ec;
-  socket.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown basic_datagram_socket::shutdown]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.shutdown..shutdown..basic_datagram_socket] 
-Disable sends or receives on the socket. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.shutdown.overload1 shutdown]``(
-      shutdown_type what);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.shutdown.overload2 shutdown]``(
-      shutdown_type what,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.shutdown.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::shutdown (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::shutdown (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what,
-      asio::error_code & ec);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_datagram_socket::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.shutdown_type..shutdown_type..basic_datagram_socket] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_datagram_socket.shutdown_type.shutdown_receive..shutdown_receive..basic_datagram_socket]
-[indexterm2 asio.indexterm.basic_datagram_socket.shutdown_type.shutdown_send..shutdown_send..basic_datagram_socket]
-[indexterm2 asio.indexterm.basic_datagram_socket.shutdown_type.shutdown_both..shutdown_both..basic_datagram_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_datagram_socket::wait]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.wait..wait..basic_datagram_socket] 
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_datagram_socket.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_datagram_socket.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_datagram_socket.wait.overload2 more...]]``
-
-
-[section:overload1 basic_datagram_socket::wait (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.wait(asio::ip::tcp::socket::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_datagram_socket::wait (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.wait(asio::ip::tcp::socket::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_datagram_socket::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_datagram_socket.wait_type..wait_type..basic_datagram_socket] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_datagram_socket.wait_type.wait_read..wait_read..basic_datagram_socket]
-[indexterm2 asio.indexterm.basic_datagram_socket.wait_type.wait_write..wait_write..basic_datagram_socket]
-[indexterm2 asio.indexterm.basic_datagram_socket.wait_type.wait_error..wait_error..basic_datagram_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_datagram_socket basic_datagram_socket::~basic_datagram_socket]
-
-[indexterm2 asio.indexterm.basic_datagram_socket._basic_datagram_socket..~basic_datagram_socket..basic_datagram_socket] 
-Destroys the socket. 
-
-
-  ~basic_datagram_socket();
-
-
-This function destroys the socket, cancelling any outstanding asynchronous operations associated with the socket as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_datagram_socket__rebind_executor basic_datagram_socket::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_datagram_socket__rebind_executor..basic_datagram_socket::rebind_executor]
-
-
-Rebinds the socket type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_datagram_socket::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_datagram_socket__rebind_executor.other..other..basic_datagram_socket::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_datagram_socket< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]] [constructor]]
-    [Construct a basic_datagram_socket without opening it. 
-     [hr]
-     Construct and open a basic_datagram_socket. 
-     [hr]
-     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_datagram_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_datagram_socket from another. 
-     [hr]
-     Move-construct a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_datagram_socket from another. 
-     [hr]
-     Move-assign a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
-    [Receive a datagram with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send_to [*send_to]]]
-    [Send a datagram to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket._basic_datagram_socket [*~basic_datagram_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class template provides asynchronous and blocking datagram-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_datagram_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_deadline_timer basic_deadline_timer]
-
-[indexterm1 asio.indexterm.basic_deadline_timer..basic_deadline_timer]
-
-
-Provides waitable timer functionality. 
-
-
-  template<
-      typename Time,
-      typename ``[link asio.reference.TimeTraits TimeTraits]`` = asio::time_traits<Time>,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_deadline_timer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.time_type [*time_type]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
-    [The time traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
-    [Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
-    [Get the timer's expiry time relative to now. 
-     [hr]
-     Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer._basic_deadline_timer [*~basic_deadline_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_deadline_timer `basic_deadline_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A deadline timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use the [link asio.reference.deadline_timer `deadline_timer`] typedef.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait: 
-
-  // Construct a timer without setting an expiry time.
-  asio::deadline_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_from_now(boost::posix_time::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait: 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::deadline_timer timer(my_context,
-      boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active deadline_timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_from_now(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_deadline_timer::expires_from_now()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_wait basic_deadline_timer::async_wait]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.async_wait..async_wait..basic_deadline_timer] 
-Start an asynchronous wait on the timer. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function may be used to initiate an asynchronous wait against the timer. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-For each call to `async_wait()`, the completion handler will be called exactly once. The completion handler will be called when:
-
-
-* The timer has expired.
-
-
-* The timer was cancelled, in which case the handler is passed the error code `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the timer expires. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_deadline_timer basic_deadline_timer::basic_deadline_timer]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.basic_deadline_timer..basic_deadline_timer..basic_deadline_timer] 
-Constructor. 
-
-
-  explicit ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload1 basic_deadline_timer]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload2 basic_deadline_timer]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload2 more...]]``
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload3 basic_deadline_timer]``(
-      const executor_type & ex,
-      const time_type & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload4 basic_deadline_timer]``(
-      ExecutionContext & context,
-      const time_type & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload4 more...]]``
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload5 basic_deadline_timer]``(
-      const executor_type & ex,
-      const duration_type & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload6 basic_deadline_timer]``(
-      ExecutionContext & context,
-      const duration_type & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload6 more...]]``
-
-
-Move-construct a [link asio.reference.basic_deadline_timer `basic_deadline_timer`] from another. 
-
-
-  ``[link asio.reference.basic_deadline_timer.basic_deadline_timer.overload7 basic_deadline_timer]``(
-      basic_deadline_timer && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.basic_deadline_timer.overload7 more...]]``
-
-
-[section:overload1 basic_deadline_timer::basic_deadline_timer (1 of 7 overloads)]
-
-
-Constructor. 
-
-
-  basic_deadline_timer(
-      const executor_type & ex);
-
-
-This constructor creates a timer without setting an expiry time. The `expires_at()` or `expires_from_now()` functions must be called to set an expiry time before the timer can be waited on.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::basic_deadline_timer (2 of 7 overloads)]
-
-
-Constructor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_deadline_timer(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer without setting an expiry time. The `expires_at()` or `expires_from_now()` functions must be called to set an expiry time before the timer can be waited on.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_deadline_timer::basic_deadline_timer (3 of 7 overloads)]
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  basic_deadline_timer(
-      const executor_type & ex,
-      const time_type & expiry_time);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, expressed as an absolute time. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_deadline_timer::basic_deadline_timer (4 of 7 overloads)]
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_deadline_timer(
-      ExecutionContext & context,
-      const time_type & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, expressed as an absolute time. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_deadline_timer::basic_deadline_timer (5 of 7 overloads)]
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  basic_deadline_timer(
-      const executor_type & ex,
-      const duration_type & expiry_time);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, relative to now. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_deadline_timer::basic_deadline_timer (6 of 7 overloads)]
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_deadline_timer(
-      ExecutionContext & context,
-      const duration_type & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, relative to now. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_deadline_timer::basic_deadline_timer (7 of 7 overloads)]
-
-
-Move-construct a [link asio.reference.basic_deadline_timer `basic_deadline_timer`] from another. 
-
-
-  basic_deadline_timer(
-      basic_deadline_timer && other);
-
-
-This constructor moves a timer from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_deadline_timer `basic_deadline_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_deadline_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_deadline_timer::cancel]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.cancel..cancel..basic_deadline_timer] 
-Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.cancel.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_deadline_timer::cancel (1 of 2 overloads)]
-
-
-Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t cancel();
-
-
-This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::cancel (2 of 2 overloads)]
-
-
-Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t cancel(
-      asio::error_code & ec);
-
-
-This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel_one basic_deadline_timer::cancel_one]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.cancel_one..cancel_one..basic_deadline_timer] 
-Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.cancel_one.overload1 cancel_one]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.cancel_one.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.cancel_one.overload2 cancel_one]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.cancel_one.overload2 more...]]``
-
-
-[section:overload1 basic_deadline_timer::cancel_one (1 of 2 overloads)]
-
-
-Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t cancel_one();
-
-
-This function forces the completion of one pending asynchronous wait operation against the timer. Handlers are cancelled in FIFO order. The handler for the cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled. That is, either 0 or 1.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel_one()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::cancel_one (2 of 2 overloads)]
-
-
-Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t cancel_one(
-      asio::error_code & ec);
-
-
-This function forces the completion of one pending asynchronous wait operation against the timer. Handlers are cancelled in FIFO order. The handler for the cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled. That is, either 0 or 1.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel_one()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:duration_type basic_deadline_timer::duration_type]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.duration_type..duration_type..basic_deadline_timer] 
-The duration type. 
-
-
-  typedef traits_type::duration_type duration_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_deadline_timer::executor_type]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.executor_type..executor_type..basic_deadline_timer] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:expires_at basic_deadline_timer::expires_at]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.expires_at..expires_at..basic_deadline_timer] 
-Get the timer's expiry time as an absolute time. 
-
-
-  time_type ``[link asio.reference.basic_deadline_timer.expires_at.overload1 expires_at]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_at.overload1 more...]]``
-
-
-Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.expires_at.overload2 expires_at]``(
-      const time_type & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_at.overload2 more...]]``
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.expires_at.overload3 expires_at]``(
-      const time_type & expiry_time,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_at.overload3 more...]]``
-
-
-[section:overload1 basic_deadline_timer::expires_at (1 of 3 overloads)]
-
-
-Get the timer's expiry time as an absolute time. 
-
-
-  time_type expires_at() const;
-
-
-This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::expires_at (2 of 3 overloads)]
-
-
-Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t expires_at(
-      const time_type & expiry_time);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_at()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 basic_deadline_timer::expires_at (3 of 3 overloads)]
-
-
-Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t expires_at(
-      const time_type & expiry_time,
-      asio::error_code & ec);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_at()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:expires_from_now basic_deadline_timer::expires_from_now]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.expires_from_now..expires_from_now..basic_deadline_timer] 
-Get the timer's expiry time relative to now. 
-
-
-  duration_type ``[link asio.reference.basic_deadline_timer.expires_from_now.overload1 expires_from_now]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_from_now.overload1 more...]]``
-
-
-Set the timer's expiry time relative to now. 
-
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.expires_from_now.overload2 expires_from_now]``(
-      const duration_type & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_from_now.overload2 more...]]``
-
-  std::size_t ``[link asio.reference.basic_deadline_timer.expires_from_now.overload3 expires_from_now]``(
-      const duration_type & expiry_time,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.expires_from_now.overload3 more...]]``
-
-
-[section:overload1 basic_deadline_timer::expires_from_now (1 of 3 overloads)]
-
-
-Get the timer's expiry time relative to now. 
-
-
-  duration_type expires_from_now() const;
-
-
-This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::expires_from_now (2 of 3 overloads)]
-
-
-Set the timer's expiry time relative to now. 
-
-
-  std::size_t expires_from_now(
-      const duration_type & expiry_time);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_from_now()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 basic_deadline_timer::expires_from_now (3 of 3 overloads)]
-
-
-Set the timer's expiry time relative to now. 
-
-
-  std::size_t expires_from_now(
-      const duration_type & expiry_time,
-      asio::error_code & ec);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_from_now()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor basic_deadline_timer::get_executor]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.get_executor..get_executor..basic_deadline_timer] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:operator_eq_ basic_deadline_timer::operator=]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.operator_eq_..operator=..basic_deadline_timer] 
-Move-assign a [link asio.reference.basic_deadline_timer `basic_deadline_timer`] from another. 
-
-
-  basic_deadline_timer & operator=(
-      basic_deadline_timer && other);
-
-
-This assignment operator moves a timer from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_deadline_timer `basic_deadline_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_deadline_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:time_type basic_deadline_timer::time_type]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.time_type..time_type..basic_deadline_timer] 
-The time type. 
-
-
-  typedef traits_type::time_type time_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:traits_type basic_deadline_timer::traits_type]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.traits_type..traits_type..basic_deadline_timer] 
-The time traits type. 
-
-
-  typedef TimeTraits traits_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:wait basic_deadline_timer::wait]
-
-[indexterm2 asio.indexterm.basic_deadline_timer.wait..wait..basic_deadline_timer] 
-Perform a blocking wait on the timer. 
-
-
-  void ``[link asio.reference.basic_deadline_timer.wait.overload1 wait]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_deadline_timer.wait.overload2 wait]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_deadline_timer.wait.overload2 more...]]``
-
-
-[section:overload1 basic_deadline_timer::wait (1 of 2 overloads)]
-
-
-Perform a blocking wait on the timer. 
-
-
-  void wait();
-
-
-This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_deadline_timer::wait (2 of 2 overloads)]
-
-
-Perform a blocking wait on the timer. 
-
-
-  void wait(
-      asio::error_code & ec);
-
-
-This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_deadline_timer basic_deadline_timer::~basic_deadline_timer]
-
-[indexterm2 asio.indexterm.basic_deadline_timer._basic_deadline_timer..~basic_deadline_timer..basic_deadline_timer] 
-Destroys the timer. 
-
-
-  ~basic_deadline_timer();
-
-
-This function destroys the timer, cancelling any outstanding asynchronous wait operations associated with the timer as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_deadline_timer__rebind_executor basic_deadline_timer::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_deadline_timer__rebind_executor..basic_deadline_timer::rebind_executor]
-
-
-Rebinds the timer type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer__rebind_executor.other [*other]]]
-    [The timer type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_deadline_timer::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_deadline_timer__rebind_executor.other..other..basic_deadline_timer::rebind_executor] 
-The timer type when rebound to the specified executor. 
-
-
-  typedef basic_deadline_timer< Time, TimeTraits, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.time_type [*time_type]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
-    [The time traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
-    [Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
-    [Get the timer's expiry time relative to now. 
-     [hr]
-     Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer._basic_deadline_timer [*~basic_deadline_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_deadline_timer `basic_deadline_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A deadline timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use the [link asio.reference.deadline_timer `deadline_timer`] typedef.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait: 
-
-  // Construct a timer without setting an expiry time.
-  asio::deadline_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_from_now(boost::posix_time::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait: 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::deadline_timer timer(my_context,
-      boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active deadline_timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_from_now(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_deadline_timer::expires_from_now()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_file basic_file]
-
-[indexterm1 asio.indexterm.basic_file..basic_file]
-
-
-Provides file functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_file :
-    public file_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.basic_file [*basic_file]] [constructor]]
-    [Construct a basic_file without opening it. 
-     [hr]
-     Construct and open a basic_file. 
-     [hr]
-     Construct a basic_file on an existing native file handle. 
-     [hr]
-     Construct a basic_file on an existing native file. 
-     [hr]
-     Move-construct a basic_file from another. 
-     [hr]
-     Move-construct a basic_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_file from another. 
-     [hr]
-     Move-assign a basic_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file._basic_file [*~basic_file]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_file `basic_file`] class template provides functionality that is common to both stream-oriented and random-access files.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:append basic_file::append]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.append..append..basic_file] 
-Open the file in append mode. 
-
-
-  static const flags append = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:assign basic_file::assign]
-
-[indexterm2 asio.indexterm.basic_file.assign..assign..basic_file] 
-Assign an existing native file to the file. 
-
-
-  void ``[link asio.reference.basic_file.assign.overload1 assign]``(
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.assign.overload2 assign]``(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.assign.overload2 more...]]``
-
-
-[section:overload1 basic_file::assign (1 of 2 overloads)]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::assign (2 of 2 overloads)]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_file basic_file::basic_file]
-
-[indexterm2 asio.indexterm.basic_file.basic_file..basic_file..basic_file] 
-Construct a [link asio.reference.basic_file `basic_file`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_file.basic_file.overload1 basic_file]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_file.basic_file.overload2 basic_file]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_file `basic_file`]. 
-
-
-  explicit ``[link asio.reference.basic_file.basic_file.overload3 basic_file]``(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_file.basic_file.overload4 basic_file]``(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload4 more...]]``
-
-  explicit ``[link asio.reference.basic_file.basic_file.overload5 basic_file]``(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_file.basic_file.overload6 basic_file]``(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_file `basic_file`] on an existing native file handle. 
-
-
-  ``[link asio.reference.basic_file.basic_file.overload7 basic_file]``(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload7 more...]]``
-
-
-Construct a [link asio.reference.basic_file `basic_file`] on an existing native file. 
-
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_file.basic_file.overload8 basic_file]``(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_file `basic_file`] from another. 
-
-
-  ``[link asio.reference.basic_file.basic_file.overload9 basic_file]``(
-      basic_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_file `basic_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_file.basic_file.overload10 basic_file]``(
-      basic_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_file.basic_file.overload10 more...]]``
-
-
-[section:overload1 basic_file::basic_file (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] without opening it. 
-
-
-  basic_file(
-      const executor_type & ex);
-
-
-This constructor initialises a file without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::basic_file (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_file(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_file::basic_file (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_file `basic_file`]. 
-
-
-  basic_file(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-
-
-This constructor initialises a file and opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_file::basic_file (4 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_file(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file and opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_file::basic_file (5 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_file `basic_file`]. 
-
-
-  basic_file(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This constructor initialises a file and opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_file::basic_file (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_file(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file and opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_file::basic_file (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] on an existing native file handle. 
-
-
-  basic_file(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-
-
-This constructor initialises a file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][A native file handle.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_file::basic_file (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_file `basic_file`] on an existing native file. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_file(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][A native file.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_file::basic_file (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_file `basic_file`] from another. 
-
-
-  basic_file(
-      basic_file && other);
-
-
-This constructor moves a file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_file `basic_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_file::basic_file (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_file `basic_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_file(
-      basic_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_file `basic_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_file::cancel]
-
-[indexterm2 asio.indexterm.basic_file.cancel..cancel..basic_file] 
-Cancel all asynchronous operations associated with the file. 
-
-
-  void ``[link asio.reference.basic_file.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_file.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_file::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_file::close]
-
-[indexterm2 asio.indexterm.basic_file.close..close..basic_file] 
-Close the file. 
-
-
-  void ``[link asio.reference.basic_file.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_file.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.close.overload2 more...]]``
-
-
-[section:overload1 basic_file::close (1 of 2 overloads)]
-
-
-Close the file. 
-
-
-  void close();
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::close (2 of 2 overloads)]
-
-
-Close the file. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  ...
-  asio::error_code ec;
-  file.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:create basic_file::create]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.create..create..basic_file] 
-Create the file if it does not exist. 
-
-
-  static const flags create = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:exclusive basic_file::exclusive]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.exclusive..exclusive..basic_file] 
-Ensure a new file is created. Must be combined with `create`. 
-
-
-  static const flags exclusive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:executor_type basic_file::executor_type]
-
-[indexterm2 asio.indexterm.basic_file.executor_type..executor_type..basic_file] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:flags basic_file::flags]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.flags..flags..basic_file] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_file::get_executor]
-
-[indexterm2 asio.indexterm.basic_file.get_executor..get_executor..basic_file] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open basic_file::is_open]
-
-[indexterm2 asio.indexterm.basic_file.is_open..is_open..basic_file] 
-Determine whether the file is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_file::native_handle]
-
-[indexterm2 asio.indexterm.basic_file.native_handle..native_handle..basic_file] 
-Get the native file representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the file. This is intended to allow access to native file functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_file::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_file.native_handle_type..native_handle_type..basic_file] 
-The native representation of a file. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:open basic_file::open]
-
-[indexterm2 asio.indexterm.basic_file.open..open..basic_file] 
-Open the file using the specified path. 
-
-
-  void ``[link asio.reference.basic_file.open.overload1 open]``(
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.open.overload2 open]``(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.open.overload2 more...]]``
-
-  void ``[link asio.reference.basic_file.open.overload3 open]``(
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.open.overload3 more...]]``
-
-  void ``[link asio.reference.basic_file.open.overload4 open]``(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.open.overload4 more...]]``
-
-
-[section:overload1 basic_file::open (1 of 4 overloads)]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::open (2 of 4 overloads)]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_file::open (3 of 4 overloads)]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_file::open (4 of 4 overloads)]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_file::operator=]
-
-[indexterm2 asio.indexterm.basic_file.operator_eq_..operator=..basic_file] 
-Move-assign a [link asio.reference.basic_file `basic_file`] from another. 
-
-
-  basic_file & ``[link asio.reference.basic_file.operator_eq_.overload1 operator=]``(
-      basic_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_file `basic_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_file & > ``[link asio.reference.basic_file.operator_eq_.overload2 operator=]``(
-      basic_file< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_file::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_file `basic_file`] from another. 
-
-
-  basic_file & operator=(
-      basic_file && other);
-
-
-This assignment operator moves a file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_file `basic_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_file `basic_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_file & > operator=(
-      basic_file< Executor1 > && other);
-
-
-This assignment operator moves a file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_file `basic_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:read_only basic_file::read_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.read_only..read_only..basic_file] 
-Open the file for reading. 
-
-
-  static const flags read_only = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:read_write basic_file::read_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.read_write..read_write..basic_file] 
-Open the file for reading and writing. 
-
-
-  static const flags read_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:release basic_file::release]
-
-[indexterm2 asio.indexterm.basic_file.release..release..basic_file] 
-Release ownership of the underlying native file. 
-
-
-  native_handle_type ``[link asio.reference.basic_file.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_file.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_file.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.release.overload2 more...]]``
-
-
-[section:overload1 basic_file::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:resize basic_file::resize]
-
-[indexterm2 asio.indexterm.basic_file.resize..resize..basic_file] 
-Alter the size of the file. 
-
-
-  void ``[link asio.reference.basic_file.resize.overload1 resize]``(
-      uint64_t n);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.resize.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.resize.overload2 resize]``(
-      uint64_t n,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.resize.overload2 more...]]``
-
-
-[section:overload1 basic_file::resize (1 of 2 overloads)]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::resize (2 of 2 overloads)]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n,
-      asio::error_code & ec);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:seek_basis basic_file::seek_basis]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.seek_basis..seek_basis..basic_file] 
-Basis for seeking in a file. 
-
-  enum seek_basis
-
-[indexterm2 asio.indexterm.basic_file.seek_basis.seek_set..seek_set..basic_file]
-[indexterm2 asio.indexterm.basic_file.seek_basis.seek_cur..seek_cur..basic_file]
-[indexterm2 asio.indexterm.basic_file.seek_basis.seek_end..seek_end..basic_file]
-
-[heading Values]
-[variablelist
-
-  [
-    [seek_set]
-    [Seek to an absolute position. ]
-  ]
-
-  [
-    [seek_cur]
-    [Seek to an offset relative to the current file position. ]
-  ]
-
-  [
-    [seek_end]
-    [Seek to an offset relative to the end of the file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:size basic_file::size]
-
-[indexterm2 asio.indexterm.basic_file.size..size..basic_file] 
-Get the size of the file. 
-
-
-  uint64_t ``[link asio.reference.basic_file.size.overload1 size]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_file.size.overload1 more...]]``
-
-  uint64_t ``[link asio.reference.basic_file.size.overload2 size]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_file.size.overload2 more...]]``
-
-
-[section:overload1 basic_file::size (1 of 2 overloads)]
-
-
-Get the size of the file. 
-
-
-  uint64_t size() const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::size (2 of 2 overloads)]
-
-
-Get the size of the file. 
-
-
-  uint64_t size(
-      asio::error_code & ec) const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:sync_all basic_file::sync_all]
-
-[indexterm2 asio.indexterm.basic_file.sync_all..sync_all..basic_file] 
-Synchronise the file to disk. 
-
-
-  void ``[link asio.reference.basic_file.sync_all.overload1 sync_all]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_file.sync_all.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.sync_all.overload2 sync_all]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.sync_all.overload2 more...]]``
-
-
-[section:overload1 basic_file::sync_all (1 of 2 overloads)]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all();
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::sync_all (2 of 2 overloads)]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all(
-      asio::error_code & ec);
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:sync_all_on_write basic_file::sync_all_on_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.sync_all_on_write..sync_all_on_write..basic_file] 
-Open the file so that write operations automatically synchronise the file data and metadata to disk. 
-
-
-  static const flags sync_all_on_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:sync_data basic_file::sync_data]
-
-[indexterm2 asio.indexterm.basic_file.sync_data..sync_data..basic_file] 
-Synchronise the file data to disk. 
-
-
-  void ``[link asio.reference.basic_file.sync_data.overload1 sync_data]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_file.sync_data.overload1 more...]]``
-
-  void ``[link asio.reference.basic_file.sync_data.overload2 sync_data]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_file.sync_data.overload2 more...]]``
-
-
-[section:overload1 basic_file::sync_data (1 of 2 overloads)]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data();
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_file::sync_data (2 of 2 overloads)]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data(
-      asio::error_code & ec);
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:truncate basic_file::truncate]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.truncate..truncate..basic_file] 
-Open the file with any existing contents truncated. 
-
-
-  static const flags truncate = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:write_only basic_file::write_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_file.write_only..write_only..basic_file] 
-Open the file for writing. 
-
-
-  static const flags write_only = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_basic_file basic_file::~basic_file]
-
-[indexterm2 asio.indexterm.basic_file._basic_file..~basic_file..basic_file] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~basic_file();
-
-
-This function destroys the file, cancelling any outstanding asynchronous operations associated with the file as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_file__rebind_executor basic_file::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_file__rebind_executor..basic_file::rebind_executor]
-
-
-Rebinds the file type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_file__rebind_executor.other [*other]]]
-    [The file type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_file::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_file__rebind_executor.other..other..basic_file::rebind_executor] 
-The file type when rebound to the specified executor. 
-
-
-  typedef basic_file< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.basic_file [*basic_file]] [constructor]]
-    [Construct a basic_file without opening it. 
-     [hr]
-     Construct and open a basic_file. 
-     [hr]
-     Construct a basic_file on an existing native file handle. 
-     [hr]
-     Construct a basic_file on an existing native file. 
-     [hr]
-     Move-construct a basic_file from another. 
-     [hr]
-     Move-construct a basic_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_file from another. 
-     [hr]
-     Move-assign a basic_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file._basic_file [*~basic_file]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_file `basic_file`] class template provides functionality that is common to both stream-oriented and random-access files.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_io_object basic_io_object]
-
-[indexterm1 asio.indexterm.basic_io_object..basic_io_object]
-
-
-Base class for all I/O objects. 
-
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService]``>
-  class basic_io_object
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_io_object.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_io_object.implementation_type [*implementation_type]]]
-    [The underlying implementation type of I/O object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_io_object.service_type [*service_type]]]
-    [The type of the service that will be used to provide I/O operations. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_io_object.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object.get_io_context [*get_io_context]]]
-    [(Deprecated: Use get_executor().) Get the io_context associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object.get_io_service [*get_io_service]]]
-    [(Deprecated: Use get_executor().) Get the io_context associated with the object. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_io_object.basic_io_object [*basic_io_object]] [constructor]]
-    [Construct a basic_io_object. 
-     [hr]
-     Move-construct a basic_io_object. 
-     [hr]
-     Perform a converting move-construction of a basic_io_object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object.get_implementation [*get_implementation]]]
-    [Get the underlying implementation of the I/O object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object.get_service [*get_service]]]
-    [Get the service associated with the I/O object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object.operator_eq_ [*operator=]]]
-    [Move-assign a basic_io_object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object._basic_io_object [*~basic_io_object]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-
-[heading Remarks]
-      
-All I/O objects are non-copyable. However, when using C++0x, certain I/O objects do support move construction and move assignment. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_io_object basic_io_object::basic_io_object]
-
-[indexterm2 asio.indexterm.basic_io_object.basic_io_object..basic_io_object..basic_io_object] 
-Construct a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  explicit ``[link asio.reference.basic_io_object.basic_io_object.overload1 basic_io_object]``(
-      asio::io_context & io_context);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.basic_io_object.overload1 more...]]``
-
-
-Move-construct a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  ``[link asio.reference.basic_io_object.basic_io_object.overload2 basic_io_object]``(
-      basic_io_object && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.basic_io_object.overload2 more...]]``
-
-
-Perform a converting move-construction of a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService1]``>
-  ``[link asio.reference.basic_io_object.basic_io_object.overload3 basic_io_object]``(
-      IoObjectService1 & other_service,
-      typename IoObjectService1::implementation_type & other_implementation);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.basic_io_object.overload3 more...]]``
-
-
-[section:overload1 basic_io_object::basic_io_object (1 of 3 overloads)]
-
-
-Construct a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  basic_io_object(
-      asio::io_context & io_context);
-
-
-Performs: 
-
-  get_service().construct(get_implementation()); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object::basic_io_object (2 of 3 overloads)]
-
-
-Move-construct a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  basic_io_object(
-      basic_io_object && other);
-
-
-Performs: 
-
-  get_service().move_construct(
-     get_implementation(), other.get_implementation()); 
-
-
-
-
-
-[heading Remarks]
-      
-Available only for services that support movability, 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_io_object::basic_io_object (3 of 3 overloads)]
-
-
-Perform a converting move-construction of a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService1]``>
-  basic_io_object(
-      IoObjectService1 & other_service,
-      typename IoObjectService1::implementation_type & other_implementation);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_io_object::executor_type]
-
-[indexterm2 asio.indexterm.basic_io_object.executor_type..executor_type..basic_io_object] 
-The type of the executor associated with the object. 
-
-
-  typedef asio::io_context::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_io_object::get_executor]
-
-[indexterm2 asio.indexterm.basic_io_object.get_executor..get_executor..basic_io_object] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:get_implementation basic_io_object::get_implementation]
-
-[indexterm2 asio.indexterm.basic_io_object.get_implementation..get_implementation..basic_io_object] 
-Get the underlying implementation of the I/O object. 
-
-
-  implementation_type & ``[link asio.reference.basic_io_object.get_implementation.overload1 get_implementation]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.get_implementation.overload1 more...]]``
-
-  const implementation_type & ``[link asio.reference.basic_io_object.get_implementation.overload2 get_implementation]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.get_implementation.overload2 more...]]``
-
-
-[section:overload1 basic_io_object::get_implementation (1 of 2 overloads)]
-
-
-Get the underlying implementation of the I/O object. 
-
-
-  implementation_type & get_implementation();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object::get_implementation (2 of 2 overloads)]
-
-
-Get the underlying implementation of the I/O object. 
-
-
-  const implementation_type & get_implementation() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_io_context basic_io_object::get_io_context]
-
-[indexterm2 asio.indexterm.basic_io_object.get_io_context..get_io_context..basic_io_object] 
-(Deprecated: Use `get_executor()`.) Get the [link asio.reference.io_context `io_context`] associated with the object. 
-
-
-  asio::io_context & get_io_context();
-
-
-This function may be used to obtain the [link asio.reference.io_context `io_context`] object that the I/O object uses to dispatch handlers for asynchronous operations.
-
-
-[heading Return Value]
-      
-A reference to the [link asio.reference.io_context `io_context`] object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:get_io_service basic_io_object::get_io_service]
-
-[indexterm2 asio.indexterm.basic_io_object.get_io_service..get_io_service..basic_io_object] 
-(Deprecated: Use `get_executor()`.) Get the [link asio.reference.io_context `io_context`] associated with the object. 
-
-
-  asio::io_context & get_io_service();
-
-
-This function may be used to obtain the [link asio.reference.io_context `io_context`] object that the I/O object uses to dispatch handlers for asynchronous operations.
-
-
-[heading Return Value]
-      
-A reference to the [link asio.reference.io_context `io_context`] object that the I/O object will use to dispatch handlers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[section:get_service basic_io_object::get_service]
-
-[indexterm2 asio.indexterm.basic_io_object.get_service..get_service..basic_io_object] 
-Get the service associated with the I/O object. 
-
-
-  service_type & ``[link asio.reference.basic_io_object.get_service.overload1 get_service]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.get_service.overload1 more...]]``
-
-  const service_type & ``[link asio.reference.basic_io_object.get_service.overload2 get_service]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object.get_service.overload2 more...]]``
-
-
-[section:overload1 basic_io_object::get_service (1 of 2 overloads)]
-
-
-Get the service associated with the I/O object. 
-
-
-  service_type & get_service();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object::get_service (2 of 2 overloads)]
-
-
-Get the service associated with the I/O object. 
-
-
-  const service_type & get_service() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:implementation_type basic_io_object::implementation_type]
-
-[indexterm2 asio.indexterm.basic_io_object.implementation_type..implementation_type..basic_io_object] 
-The underlying implementation type of I/O object. 
-
-
-  typedef service_type::implementation_type implementation_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ basic_io_object::operator=]
-
-[indexterm2 asio.indexterm.basic_io_object.operator_eq_..operator=..basic_io_object] 
-Move-assign a [link asio.reference.basic_io_object `basic_io_object`]. 
-
-
-  basic_io_object & operator=(
-      basic_io_object && other);
-
-
-Performs: 
-
-  get_service().move_assign(get_implementation(),
-     other.get_service(), other.get_implementation()); 
-
-
-
-
-
-[heading Remarks]
-      
-Available only for services that support movability, 
-
-
-
-
-[endsect]
-
-
-
-[section:service_type basic_io_object::service_type]
-
-[indexterm2 asio.indexterm.basic_io_object.service_type..service_type..basic_io_object] 
-The type of the service that will be used to provide I/O operations. 
-
-
-  typedef IoObjectService service_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_basic_io_object basic_io_object::~basic_io_object]
-
-[indexterm2 asio.indexterm.basic_io_object._basic_io_object..~basic_io_object..basic_io_object] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~basic_io_object();
-
-
-Performs: 
-
-  get_service().destroy(get_implementation()); 
-
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_io_object_lt__IoObjectService_comma__true__gt_ basic_io_object< IoObjectService, true >]
-
-[indexterm1 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_..basic_io_object< IoObjectService, true >]
-
-
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService]``>
-  class basic_io_object< IoObjectService, true >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.executor_type [*executor_type]]]
-    []
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.implementation_type [*implementation_type]]]
-    []
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.service_type [*service_type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_executor [*get_executor]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_io_context [*get_io_context]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_io_service [*get_io_service]]]
-    []
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object [*basic_io_object]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation [*get_implementation]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service [*get_service]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.operator_eq_ [*operator=]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_._basic_io_object [*~basic_io_object]] [destructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_io_object basic_io_object< IoObjectService, true >::basic_io_object]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object..basic_io_object..basic_io_object< IoObjectService, true >] 
-
-  explicit ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload1 basic_io_object]``(
-      asio::io_context & io_context);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload1 more...]]``
-
-  ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload2 basic_io_object]``(
-      basic_io_object && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService1]``>
-  ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload3 basic_io_object]``(
-      IoObjectService1 & other_service,
-      typename IoObjectService1::implementation_type & other_implementation);
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.basic_io_object.overload3 more...]]``
-
-
-[section:overload1 basic_io_object< IoObjectService, true >::basic_io_object (1 of 3 overloads)]
-
-
-
-  basic_io_object(
-      asio::io_context & io_context);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object< IoObjectService, true >::basic_io_object (2 of 3 overloads)]
-
-
-
-  basic_io_object(
-      basic_io_object && other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_io_object< IoObjectService, true >::basic_io_object (3 of 3 overloads)]
-
-
-
-  template<
-      typename ``[link asio.reference.IoObjectService IoObjectService1]``>
-  basic_io_object(
-      IoObjectService1 & other_service,
-      typename IoObjectService1::implementation_type & other_implementation);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_io_object< IoObjectService, true >::executor_type]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.executor_type..executor_type..basic_io_object< IoObjectService, true >] 
-
-  typedef asio::io_context::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_io_object< IoObjectService, true >::get_executor]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.get_executor..get_executor..basic_io_object< IoObjectService, true >] 
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:get_implementation basic_io_object< IoObjectService, true >::get_implementation]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation..get_implementation..basic_io_object< IoObjectService, true >] 
-
-  implementation_type & ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation.overload1 get_implementation]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation.overload1 more...]]``
-
-  const implementation_type & ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation.overload2 get_implementation]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_implementation.overload2 more...]]``
-
-
-[section:overload1 basic_io_object< IoObjectService, true >::get_implementation (1 of 2 overloads)]
-
-
-
-  implementation_type & get_implementation();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object< IoObjectService, true >::get_implementation (2 of 2 overloads)]
-
-
-
-  const implementation_type & get_implementation() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_io_context basic_io_object< IoObjectService, true >::get_io_context]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.get_io_context..get_io_context..basic_io_object< IoObjectService, true >] 
-
-  asio::io_context & get_io_context();
-
-
-
-[endsect]
-
-
-
-[section:get_io_service basic_io_object< IoObjectService, true >::get_io_service]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.get_io_service..get_io_service..basic_io_object< IoObjectService, true >] 
-
-  asio::io_context & get_io_service();
-
-
-
-[endsect]
-
-
-[section:get_service basic_io_object< IoObjectService, true >::get_service]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service..get_service..basic_io_object< IoObjectService, true >] 
-
-  service_type & ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service.overload1 get_service]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service.overload1 more...]]``
-
-  const service_type & ``[link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service.overload2 get_service]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_io_object_lt__IoObjectService_comma__true__gt_.get_service.overload2 more...]]``
-
-
-[section:overload1 basic_io_object< IoObjectService, true >::get_service (1 of 2 overloads)]
-
-
-
-  service_type & get_service();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_io_object< IoObjectService, true >::get_service (2 of 2 overloads)]
-
-
-
-  const service_type & get_service() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:implementation_type basic_io_object< IoObjectService, true >::implementation_type]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.implementation_type..implementation_type..basic_io_object< IoObjectService, true >] 
-
-  typedef service_type::implementation_type implementation_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ basic_io_object< IoObjectService, true >::operator=]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.operator_eq_..operator=..basic_io_object< IoObjectService, true >] 
-
-  basic_io_object & operator=(
-      basic_io_object && other);
-
-
-
-[endsect]
-
-
-
-[section:service_type basic_io_object< IoObjectService, true >::service_type]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_.service_type..service_type..basic_io_object< IoObjectService, true >] 
-
-  typedef IoObjectService service_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_io_object.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_basic_io_object basic_io_object< IoObjectService, true >::~basic_io_object]
-
-[indexterm2 asio.indexterm.basic_io_object_lt__IoObjectService_comma__true__gt_._basic_io_object..~basic_io_object..basic_io_object< IoObjectService, true >] 
-
-  ~basic_io_object();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_random_access_file basic_random_access_file]
-
-[indexterm1 asio.indexterm.basic_random_access_file..basic_random_access_file]
-
-
-Provides random-access file functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_random_access_file :
-    public basic_file< Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_random_access_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.basic_random_access_file [*basic_random_access_file]] [constructor]]
-    [Construct a basic_random_access_file without opening it. 
-     [hr]
-     Construct and open a basic_random_access_file. 
-     [hr]
-     Construct a basic_random_access_file on an existing native file. 
-     [hr]
-     Move-construct a basic_random_access_file from another. 
-     [hr]
-     Move-construct a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_random_access_file from another. 
-     [hr]
-     Move-assign a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file._basic_random_access_file [*~basic_random_access_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_random_access_file `basic_random_access_file`] class template provides asynchronous and blocking random-access file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some_at` and `write_some_at` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single file object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:append basic_random_access_file::append]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.append..append..basic_random_access_file] 
-Open the file in append mode. 
-
-
-  static const flags append = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:assign basic_random_access_file::assign]
-
-[indexterm2 asio.indexterm.basic_random_access_file.assign..assign..basic_random_access_file] 
-Assign an existing native file to the file. 
-
-
-  void ``[link asio.reference.basic_random_access_file.assign.overload1 assign]``(
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.assign.overload2 assign]``(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.assign.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some_at basic_random_access_file::async_read_some_at]
-
-[indexterm2 asio.indexterm.basic_random_access_file.async_read_some_at..async_read_some_at..basic_random_access_file] 
-Start an asynchronous read at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the random-access handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read_at `async_read_at`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_read_some_at(42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some_at basic_random_access_file::async_write_some_at]
-
-[indexterm2 asio.indexterm.basic_random_access_file.async_write_some_at..async_write_some_at..basic_random_access_file] 
-Start an asynchronous write at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the random-access handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not write all of the data to the file. Consider using the [link asio.reference.async_write_at `async_write_at`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_write_some_at(42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_random_access_file basic_random_access_file::basic_random_access_file]
-
-[indexterm2 asio.indexterm.basic_random_access_file.basic_random_access_file..basic_random_access_file..basic_random_access_file] 
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload1 basic_random_access_file]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload2 basic_random_access_file]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_random_access_file `basic_random_access_file`]. 
-
-
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload3 basic_random_access_file]``(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload4 basic_random_access_file]``(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload4 more...]]``
-
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload5 basic_random_access_file]``(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload6 basic_random_access_file]``(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] on an existing native file. 
-
-
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload7 basic_random_access_file]``(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload8 basic_random_access_file]``(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] from another. 
-
-
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload9 basic_random_access_file]``(
-      basic_random_access_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_random_access_file.basic_random_access_file.overload10 basic_random_access_file]``(
-      basic_random_access_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.basic_random_access_file.overload10 more...]]``
-
-
-[section:overload1 basic_random_access_file::basic_random_access_file (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] without opening it. 
-
-
-  basic_random_access_file(
-      const executor_type & ex);
-
-
-This constructor initialises a file without opening it. The file needs to be opened before data can be read from or or written to it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::basic_random_access_file (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_file(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file without opening it. The file needs to be opened before data can be read from or or written to it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_random_access_file::basic_random_access_file (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_random_access_file `basic_random_access_file`]. 
-
-
-  basic_random_access_file(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_random_access_file::basic_random_access_file (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_random_access_file `basic_random_access_file`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_file(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_random_access_file::basic_random_access_file (5 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_random_access_file `basic_random_access_file`]. 
-
-
-  basic_random_access_file(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_random_access_file::basic_random_access_file (6 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_random_access_file `basic_random_access_file`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_file(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_random_access_file::basic_random_access_file (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] on an existing native file. 
-
-
-  basic_random_access_file(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-
-
-This constructor initialises a random-access file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][The new underlying file implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_random_access_file::basic_random_access_file (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] on an existing native file. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_file(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a random-access file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][The new underlying file implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_random_access_file::basic_random_access_file (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] from another. 
-
-
-  basic_random_access_file(
-      basic_random_access_file && other);
-
-
-This constructor moves a random-access file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_random_access_file `basic_random_access_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_random_access_file::basic_random_access_file (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_random_access_file `basic_random_access_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_random_access_file(
-      basic_random_access_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a random-access file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_random_access_file `basic_random_access_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_random_access_file::cancel]
-
-[indexterm2 asio.indexterm.basic_random_access_file.cancel..cancel..basic_random_access_file] 
-Cancel all asynchronous operations associated with the file. 
-
-
-  void ``[link asio.reference.basic_random_access_file.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_random_access_file::close]
-
-[indexterm2 asio.indexterm.basic_random_access_file.close..close..basic_random_access_file] 
-Close the file. 
-
-
-  void ``[link asio.reference.basic_random_access_file.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.close.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::close (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Close the file. 
-
-
-  void close();
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::close (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Close the file. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  ...
-  asio::error_code ec;
-  file.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:create basic_random_access_file::create]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.create..create..basic_random_access_file] 
-Create the file if it does not exist. 
-
-
-  static const flags create = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:exclusive basic_random_access_file::exclusive]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.exclusive..exclusive..basic_random_access_file] 
-Ensure a new file is created. Must be combined with `create`. 
-
-
-  static const flags exclusive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:executor_type basic_random_access_file::executor_type]
-
-[indexterm2 asio.indexterm.basic_random_access_file.executor_type..executor_type..basic_random_access_file] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:flags basic_random_access_file::flags]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.flags..flags..basic_random_access_file] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_random_access_file::get_executor]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.get_executor..get_executor..basic_random_access_file] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open basic_random_access_file::is_open]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.is_open..is_open..basic_random_access_file] 
-Determine whether the file is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_random_access_file::native_handle]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.native_handle..native_handle..basic_random_access_file] 
-Get the native file representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the file. This is intended to allow access to native file functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_random_access_file::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_random_access_file.native_handle_type..native_handle_type..basic_random_access_file] 
-The native representation of a file. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:open basic_random_access_file::open]
-
-[indexterm2 asio.indexterm.basic_random_access_file.open..open..basic_random_access_file] 
-Open the file using the specified path. 
-
-
-  void ``[link asio.reference.basic_random_access_file.open.overload1 open]``(
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.open.overload2 open]``(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.open.overload2 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.open.overload3 open]``(
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.open.overload3 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.open.overload4 open]``(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.open.overload4 more...]]``
-
-
-[section:overload1 basic_random_access_file::open (1 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::open (2 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_random_access_file::open (3 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_random_access_file::open (4 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_random_access_file::operator=]
-
-[indexterm2 asio.indexterm.basic_random_access_file.operator_eq_..operator=..basic_random_access_file] 
-Move-assign a [link asio.reference.basic_random_access_file `basic_random_access_file`] from another. 
-
-
-  basic_random_access_file & ``[link asio.reference.basic_random_access_file.operator_eq_.overload1 operator=]``(
-      basic_random_access_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_random_access_file `basic_random_access_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_random_access_file & > ``[link asio.reference.basic_random_access_file.operator_eq_.overload2 operator=]``(
-      basic_random_access_file< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_random_access_file `basic_random_access_file`] from another. 
-
-
-  basic_random_access_file & operator=(
-      basic_random_access_file && other);
-
-
-This assignment operator moves a random-access file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_random_access_file `basic_random_access_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_random_access_file `basic_random_access_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_random_access_file & > operator=(
-      basic_random_access_file< Executor1 > && other);
-
-
-This assignment operator moves a random-access file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_random_access_file `basic_random_access_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:read_only basic_random_access_file::read_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.read_only..read_only..basic_random_access_file] 
-Open the file for reading. 
-
-
-  static const flags read_only = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:read_some_at basic_random_access_file::read_some_at]
-
-[indexterm2 asio.indexterm.basic_random_access_file.read_some_at..read_some_at..basic_random_access_file] 
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_random_access_file.read_some_at.overload1 read_some_at]``(
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.read_some_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_random_access_file.read_some_at.overload2 read_some_at]``(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.read_some_at.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::read_some_at (1 of 2 overloads)]
-
-
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the end of the file was reached.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read_at `read_at`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.read_some_at(42, asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::read_some_at (2 of 2 overloads)]
-
-
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read_at `read_at`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:read_write basic_random_access_file::read_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.read_write..read_write..basic_random_access_file] 
-Open the file for reading and writing. 
-
-
-  static const flags read_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:release basic_random_access_file::release]
-
-[indexterm2 asio.indexterm.basic_random_access_file.release..release..basic_random_access_file] 
-Release ownership of the underlying native file. 
-
-
-  native_handle_type ``[link asio.reference.basic_random_access_file.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_random_access_file.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.release.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::release (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::release (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:resize basic_random_access_file::resize]
-
-[indexterm2 asio.indexterm.basic_random_access_file.resize..resize..basic_random_access_file] 
-Alter the size of the file. 
-
-
-  void ``[link asio.reference.basic_random_access_file.resize.overload1 resize]``(
-      uint64_t n);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.resize.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.resize.overload2 resize]``(
-      uint64_t n,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.resize.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::resize (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::resize (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n,
-      asio::error_code & ec);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:seek_basis basic_random_access_file::seek_basis]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.seek_basis..seek_basis..basic_random_access_file] 
-Basis for seeking in a file. 
-
-  enum seek_basis
-
-[indexterm2 asio.indexterm.basic_random_access_file.seek_basis.seek_set..seek_set..basic_random_access_file]
-[indexterm2 asio.indexterm.basic_random_access_file.seek_basis.seek_cur..seek_cur..basic_random_access_file]
-[indexterm2 asio.indexterm.basic_random_access_file.seek_basis.seek_end..seek_end..basic_random_access_file]
-
-[heading Values]
-[variablelist
-
-  [
-    [seek_set]
-    [Seek to an absolute position. ]
-  ]
-
-  [
-    [seek_cur]
-    [Seek to an offset relative to the current file position. ]
-  ]
-
-  [
-    [seek_end]
-    [Seek to an offset relative to the end of the file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:size basic_random_access_file::size]
-
-[indexterm2 asio.indexterm.basic_random_access_file.size..size..basic_random_access_file] 
-Get the size of the file. 
-
-
-  uint64_t ``[link asio.reference.basic_random_access_file.size.overload1 size]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.size.overload1 more...]]``
-
-  uint64_t ``[link asio.reference.basic_random_access_file.size.overload2 size]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.size.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::size (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Get the size of the file. 
-
-
-  uint64_t size() const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::size (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Get the size of the file. 
-
-
-  uint64_t size(
-      asio::error_code & ec) const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:sync_all basic_random_access_file::sync_all]
-
-[indexterm2 asio.indexterm.basic_random_access_file.sync_all..sync_all..basic_random_access_file] 
-Synchronise the file to disk. 
-
-
-  void ``[link asio.reference.basic_random_access_file.sync_all.overload1 sync_all]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.sync_all.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.sync_all.overload2 sync_all]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.sync_all.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::sync_all (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all();
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::sync_all (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all(
-      asio::error_code & ec);
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:sync_all_on_write basic_random_access_file::sync_all_on_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.sync_all_on_write..sync_all_on_write..basic_random_access_file] 
-Open the file so that write operations automatically synchronise the file data and metadata to disk. 
-
-
-  static const flags sync_all_on_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:sync_data basic_random_access_file::sync_data]
-
-[indexterm2 asio.indexterm.basic_random_access_file.sync_data..sync_data..basic_random_access_file] 
-Synchronise the file data to disk. 
-
-
-  void ``[link asio.reference.basic_random_access_file.sync_data.overload1 sync_data]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.sync_data.overload1 more...]]``
-
-  void ``[link asio.reference.basic_random_access_file.sync_data.overload2 sync_data]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.sync_data.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::sync_data (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data();
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::sync_data (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data(
-      asio::error_code & ec);
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:truncate basic_random_access_file::truncate]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.truncate..truncate..basic_random_access_file] 
-Open the file with any existing contents truncated. 
-
-
-  static const flags truncate = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:write_only basic_random_access_file::write_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_random_access_file.write_only..write_only..basic_random_access_file] 
-Open the file for writing. 
-
-
-  static const flags write_only = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:write_some_at basic_random_access_file::write_some_at]
-
-[indexterm2 asio.indexterm.basic_random_access_file.write_some_at..write_some_at..basic_random_access_file] 
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_random_access_file.write_some_at.overload1 write_some_at]``(
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.write_some_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_random_access_file.write_some_at.overload2 write_some_at]``(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_random_access_file.write_some_at.overload2 more...]]``
-
-
-[section:overload1 basic_random_access_file::write_some_at (1 of 2 overloads)]
-
-
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the end of the file was reached.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some\_at operation may not write all of the data. Consider using the [link asio.reference.write_at `write_at`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.write_some_at(42, asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_random_access_file::write_some_at (2 of 2 overloads)]
-
-
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not write all of the data to the file. Consider using the [link asio.reference.write_at `write_at`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_random_access_file basic_random_access_file::~basic_random_access_file]
-
-[indexterm2 asio.indexterm.basic_random_access_file._basic_random_access_file..~basic_random_access_file..basic_random_access_file] 
-Destroys the file. 
-
-
-  ~basic_random_access_file();
-
-
-This function destroys the file, cancelling any outstanding asynchronous operations associated with the file as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_random_access_file__rebind_executor basic_random_access_file::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_random_access_file__rebind_executor..basic_random_access_file::rebind_executor]
-
-
-Rebinds the file type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_random_access_file__rebind_executor.other [*other]]]
-    [The file type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_random_access_file::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_random_access_file__rebind_executor.other..other..basic_random_access_file::rebind_executor] 
-The file type when rebound to the specified executor. 
-
-
-  typedef basic_random_access_file< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_random_access_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.basic_random_access_file [*basic_random_access_file]] [constructor]]
-    [Construct a basic_random_access_file without opening it. 
-     [hr]
-     Construct and open a basic_random_access_file. 
-     [hr]
-     Construct a basic_random_access_file on an existing native file. 
-     [hr]
-     Move-construct a basic_random_access_file from another. 
-     [hr]
-     Move-construct a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_random_access_file from another. 
-     [hr]
-     Move-assign a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file._basic_random_access_file [*~basic_random_access_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_random_access_file `basic_random_access_file`] class template provides asynchronous and blocking random-access file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some_at` and `write_some_at` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single file object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_raw_socket basic_raw_socket]
-
-[indexterm1 asio.indexterm.basic_raw_socket..basic_raw_socket]
-
-
-Provides raw-oriented socket functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_raw_socket :
-    public basic_socket< Protocol, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_raw_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]] [constructor]]
-    [Construct a basic_raw_socket without opening it. 
-     [hr]
-     Construct and open a basic_raw_socket. 
-     [hr]
-     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_raw_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_raw_socket from another. 
-     [hr]
-     Move-construct a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_raw_socket from another. 
-     [hr]
-     Move-assign a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive_from [*receive_from]]]
-    [Receive raw data with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send_to [*send_to]]]
-    [Send raw data to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket._basic_raw_socket [*~basic_raw_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_raw_socket `basic_raw_socket`] class template provides asynchronous and blocking raw-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_raw_socket::assign]
-
-[indexterm2 asio.indexterm.basic_raw_socket.assign..assign..basic_raw_socket] 
-Assign an existing native socket to the socket. 
-
-
-  void ``[link asio.reference.basic_raw_socket.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.assign.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_connect basic_raw_socket::async_connect]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_connect..async_connect..basic_raw_socket] 
-Start an asynchronous connect. 
-
-
-  template<
-      typename ``[link asio.reference.ConnectToken ConnectToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      const endpoint_type & peer_endpoint,
-      ConnectToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously connect a socket to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void connect_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Connect succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_connect(endpoint, connect_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:async_receive basic_raw_socket::async_receive]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_receive..async_receive..basic_raw_socket] 
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_receive.overload1 async_receive]``(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_receive.overload2 async_receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_receive.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::async_receive (1 of 2 overloads)]
-
-
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the raw socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected raw socket.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::async_receive (2 of 2 overloads)]
-
-
-Start an asynchronous receive on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the raw socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_receive operation can only be used with a connected socket. Use the async\_receive\_from function to receive data on an unconnected raw socket.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_receive_from basic_raw_socket::async_receive_from]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_receive_from..async_receive_from..basic_raw_socket] 
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_receive_from.overload1 async_receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_receive_from.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_receive_from.overload2 async_receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_receive_from.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::async_receive_from (1 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive raw data. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive_from(
-     asio::buffer(data, size), 0, sender_endpoint, handler); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::async_receive_from (2 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive raw data. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data. Ownership of the sender\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_send basic_raw_socket::async_send]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_send..async_send..basic_raw_socket] 
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_send.overload1 async_send]``(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_send.overload2 async_send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_send.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::async_send (1 of 2 overloads)]
-
-
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the raw socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected raw socket.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_send(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::async_send (2 of 2 overloads)]
-
-
-Start an asynchronous send on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the raw socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_send operation can only be used with a connected socket. Use the async\_send\_to function to send data on an unconnected raw socket.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_send_to basic_raw_socket::async_send_to]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_send_to..async_send_to..basic_raw_socket] 
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_send_to.overload1 async_send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_send_to.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_raw_socket.async_send_to.overload2 async_send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.async_send_to.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::async_send_to (1 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send raw data to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint destination(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_send_to(
-      asio::buffer(data, size), destination, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::async_send_to (2 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send raw data to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[destination][The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait basic_raw_socket::async_wait]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.async_wait..async_wait..basic_raw_socket] 
-Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:at_mark basic_raw_socket::at_mark]
-
-[indexterm2 asio.indexterm.basic_raw_socket.at_mark..at_mark..basic_raw_socket] 
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool ``[link asio.reference.basic_raw_socket.at_mark.overload1 at_mark]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.at_mark.overload1 more...]]``
-
-  bool ``[link asio.reference.basic_raw_socket.at_mark.overload2 at_mark]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.at_mark.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::at_mark (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark() const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::at_mark (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark(
-      asio::error_code & ec) const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:available basic_raw_socket::available]
-
-[indexterm2 asio.indexterm.basic_raw_socket.available..available..basic_raw_socket] 
-Determine the number of bytes available for reading. 
-
-
-  std::size_t ``[link asio.reference.basic_raw_socket.available.overload1 available]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.available.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_raw_socket.available.overload2 available]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.available.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::available (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available() const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::available (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available(
-      asio::error_code & ec) const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_raw_socket basic_raw_socket::basic_raw_socket]
-
-[indexterm2 asio.indexterm.basic_raw_socket.basic_raw_socket..basic_raw_socket..basic_raw_socket] 
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload1 basic_raw_socket]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload2 basic_raw_socket]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_raw_socket `basic_raw_socket`]. 
-
-
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload3 basic_raw_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload4 basic_raw_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload4 more...]]``
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`], opening it and binding it to the given local endpoint. 
-
-
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload5 basic_raw_socket]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload6 basic_raw_socket]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] on an existing native socket. 
-
-
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload7 basic_raw_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload8 basic_raw_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] from another. 
-
-
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload9 basic_raw_socket]``(
-      basic_raw_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_raw_socket.basic_raw_socket.overload10 basic_raw_socket]``(
-      basic_raw_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.basic_raw_socket.overload10 more...]]``
-
-
-[section:overload1 basic_raw_socket::basic_raw_socket (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] without opening it. 
-
-
-  basic_raw_socket(
-      const executor_type & ex);
-
-
-This constructor creates a raw socket without opening it. The `open()` function must be called before data can be sent or received on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::basic_raw_socket (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_raw_socket(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a raw socket without opening it. The `open()` function must be called before data can be sent or received on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::basic_raw_socket (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_raw_socket `basic_raw_socket`]. 
-
-
-  basic_raw_socket(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates and opens a raw socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_raw_socket::basic_raw_socket (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_raw_socket `basic_raw_socket`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_raw_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a raw socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_raw_socket::basic_raw_socket (5 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`], opening it and binding it to the given local endpoint. 
-
-
-  basic_raw_socket(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-
-
-This constructor creates a raw socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the raw socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_raw_socket::basic_raw_socket (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`], opening it and binding it to the given local endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_raw_socket(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a raw socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the raw socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_raw_socket::basic_raw_socket (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] on an existing native socket. 
-
-
-  basic_raw_socket(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-This constructor creates a raw socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_raw_socket::basic_raw_socket (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] on an existing native socket. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_raw_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a raw socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_raw_socket::basic_raw_socket (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] from another. 
-
-
-  basic_raw_socket(
-      basic_raw_socket && other);
-
-
-This constructor moves a raw socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_raw_socket `basic_raw_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_raw_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_raw_socket::basic_raw_socket (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_raw_socket `basic_raw_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_raw_socket(
-      basic_raw_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a raw socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_raw_socket `basic_raw_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_raw_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_raw_socket::bind]
-
-[indexterm2 asio.indexterm.basic_raw_socket.bind..bind..basic_raw_socket] 
-Bind the socket to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_raw_socket.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.bind.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::bind (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::bind (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  asio::error_code ec;
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_raw_socket::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.broadcast..broadcast..basic_raw_socket] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_raw_socket::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.bytes_readable..bytes_readable..basic_raw_socket] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_raw_socket::cancel]
-
-[indexterm2 asio.indexterm.basic_raw_socket.cancel..cancel..basic_raw_socket] 
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void ``[link asio.reference.basic_raw_socket.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_raw_socket::close]
-
-[indexterm2 asio.indexterm.basic_raw_socket.close..close..basic_raw_socket] 
-Close the socket. 
-
-
-  void ``[link asio.reference.basic_raw_socket.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.close.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::close (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close();
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::close (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect basic_raw_socket::connect]
-
-[indexterm2 asio.indexterm.basic_raw_socket.connect..connect..basic_raw_socket] 
-Connect the socket to the specified endpoint. 
-
-
-  void ``[link asio.reference.basic_raw_socket.connect.overload1 connect]``(
-      const endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.connect.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.connect.overload2 connect]``(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.connect.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::connect (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.connect(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::connect (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  asio::error_code ec;
-  socket.connect(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_raw_socket::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.debug..debug..basic_raw_socket] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_raw_socket::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.do_not_route..do_not_route..basic_raw_socket] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_raw_socket::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.enable_connection_aborted..enable_connection_aborted..basic_raw_socket] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_raw_socket::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_raw_socket.endpoint_type..endpoint_type..basic_raw_socket] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_raw_socket::executor_type]
-
-[indexterm2 asio.indexterm.basic_raw_socket.executor_type..executor_type..basic_raw_socket] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_raw_socket::get_executor]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.get_executor..get_executor..basic_raw_socket] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_raw_socket::get_option]
-
-[indexterm2 asio.indexterm.basic_raw_socket.get_option..get_option..basic_raw_socket] 
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_raw_socket.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_raw_socket.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::get_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::get_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  asio::error_code ec;
-  socket.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_raw_socket::io_control]
-
-[indexterm2 asio.indexterm.basic_raw_socket.io_control..io_control..basic_raw_socket] 
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_raw_socket.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_raw_socket.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::io_control (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::io_control (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_raw_socket::is_open]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.is_open..is_open..basic_raw_socket] 
-Determine whether the socket is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_raw_socket::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.keep_alive..keep_alive..basic_raw_socket] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_raw_socket::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.linger..linger..basic_raw_socket] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:local_endpoint basic_raw_socket::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_raw_socket.local_endpoint..local_endpoint..basic_raw_socket] 
-Get the local endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_raw_socket.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_raw_socket.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::local_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::local_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer basic_raw_socket::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_raw_socket.lowest_layer..lowest_layer..basic_raw_socket] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_raw_socket.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_raw_socket.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_raw_socket::lowest_layer_type]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.lowest_layer_type..lowest_layer_type..basic_raw_socket] 
-A [link asio.reference.basic_socket `basic_socket`] is always the lowest layer. 
-
-
-  typedef basic_socket< Protocol, Executor > lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections basic_raw_socket::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.max_connections..max_connections..basic_raw_socket] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_raw_socket::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.max_listen_connections..max_listen_connections..basic_raw_socket] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_raw_socket::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.message_do_not_route..message_do_not_route..basic_raw_socket] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_raw_socket::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.message_end_of_record..message_end_of_record..basic_raw_socket] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_raw_socket::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.message_flags..message_flags..basic_raw_socket] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_raw_socket::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.message_out_of_band..message_out_of_band..basic_raw_socket] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_raw_socket::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.message_peek..message_peek..basic_raw_socket] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_raw_socket::native_handle]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.native_handle..native_handle..basic_raw_socket] 
-Get the native socket representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_raw_socket::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_raw_socket.native_handle_type..native_handle_type..basic_raw_socket] 
-The native representation of a socket. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_raw_socket::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_raw_socket.native_non_blocking..native_non_blocking..basic_raw_socket] 
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool ``[link asio.reference.basic_raw_socket.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void ``[link asio.reference.basic_raw_socket.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::native_non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying socket is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::native_non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::native_non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_raw_socket::non_blocking]
-
-[indexterm2 asio.indexterm.basic_raw_socket.non_blocking..non_blocking..basic_raw_socket] 
-Gets the non-blocking mode of the socket. 
-
-
-  bool ``[link asio.reference.basic_raw_socket.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void ``[link asio.reference.basic_raw_socket.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the socket. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_raw_socket::open]
-
-[indexterm2 asio.indexterm.basic_raw_socket.open..open..basic_raw_socket] 
-Open the socket using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_raw_socket.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.open.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::open (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::open (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  socket.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_raw_socket::operator=]
-
-[indexterm2 asio.indexterm.basic_raw_socket.operator_eq_..operator=..basic_raw_socket] 
-Move-assign a [link asio.reference.basic_raw_socket `basic_raw_socket`] from another. 
-
-
-  basic_raw_socket & ``[link asio.reference.basic_raw_socket.operator_eq_.overload1 operator=]``(
-      basic_raw_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_raw_socket `basic_raw_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_raw_socket & > ``[link asio.reference.basic_raw_socket.operator_eq_.overload2 operator=]``(
-      basic_raw_socket< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_raw_socket `basic_raw_socket`] from another. 
-
-
-  basic_raw_socket & operator=(
-      basic_raw_socket && other);
-
-
-This assignment operator moves a raw socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_raw_socket `basic_raw_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_raw_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_raw_socket `basic_raw_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_raw_socket & > operator=(
-      basic_raw_socket< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves a raw socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_raw_socket `basic_raw_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_raw_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_raw_socket::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.out_of_band_inline..out_of_band_inline..basic_raw_socket] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_raw_socket::protocol_type]
-
-[indexterm2 asio.indexterm.basic_raw_socket.protocol_type..protocol_type..basic_raw_socket] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:receive basic_raw_socket::receive]
-
-[indexterm2 asio.indexterm.basic_raw_socket.receive..receive..basic_raw_socket] 
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive.overload1 receive]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive.overload2 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive.overload3 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::receive (1 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::receive (2 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::receive (3 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to receive data on the raw socket. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Remarks]
-      
-The receive operation can only be used with a connected socket. Use the receive\_from function to receive data on an unconnected raw socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_buffer_size basic_raw_socket::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.receive_buffer_size..receive_buffer_size..basic_raw_socket] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:receive_from basic_raw_socket::receive_from]
-
-[indexterm2 asio.indexterm.basic_raw_socket.receive_from..receive_from..basic_raw_socket] 
-Receive raw data with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive_from.overload1 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive_from.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive_from.overload2 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive_from.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.receive_from.overload3 receive_from]``(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.receive_from.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::receive_from (1 of 3 overloads)]
-
-
-Receive raw data with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint);
-
-
-This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint sender_endpoint;
-  socket.receive_from(
-      asio::buffer(data, size), sender_endpoint);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::receive_from (2 of 3 overloads)]
-
-
-Receive raw data with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags);
-
-
-This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::receive_from (3 of 3 overloads)]
-
-
-Receive raw data with the endpoint of the sender. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive_from(
-      const MutableBufferSequence & buffers,
-      endpoint_type & sender_endpoint,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[sender_endpoint][An endpoint object that receives the endpoint of the remote sender of the data.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_low_watermark basic_raw_socket::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.receive_low_watermark..receive_low_watermark..basic_raw_socket] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_raw_socket::release]
-
-[indexterm2 asio.indexterm.basic_raw_socket.release..release..basic_raw_socket] 
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type ``[link asio.reference.basic_raw_socket.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_raw_socket.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.release.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::release (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::release (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:remote_endpoint basic_raw_socket::remote_endpoint]
-
-[indexterm2 asio.indexterm.basic_raw_socket.remote_endpoint..remote_endpoint..basic_raw_socket] 
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_raw_socket.remote_endpoint.overload1 remote_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.remote_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_raw_socket.remote_endpoint.overload2 remote_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.remote_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::remote_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint() const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::remote_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_raw_socket::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.reuse_address..reuse_address..basic_raw_socket] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send basic_raw_socket::send]
-
-[indexterm2 asio.indexterm.basic_raw_socket.send..send..basic_raw_socket] 
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send.overload1 send]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send.overload2 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send.overload3 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::send (1 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One ore more data buffers to be sent on the socket.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.send(asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::send (2 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One ore more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::send (3 of 3 overloads)]
-
-
-Send some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send data on the raw socket. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Remarks]
-      
-The send operation can only be used with a connected socket. Use the send\_to function to send data on an unconnected raw socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:send_buffer_size basic_raw_socket::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.send_buffer_size..send_buffer_size..basic_raw_socket] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_raw_socket::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.send_low_watermark..send_low_watermark..basic_raw_socket] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send_to basic_raw_socket::send_to]
-
-[indexterm2 asio.indexterm.basic_raw_socket.send_to..send_to..basic_raw_socket] 
-Send raw data to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send_to.overload1 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send_to.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send_to.overload2 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send_to.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_raw_socket.send_to.overload3 send_to]``(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.send_to.overload3 more...]]``
-
-
-[section:overload1 basic_raw_socket::send_to (1 of 3 overloads)]
-
-
-Send raw data to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination);
-
-
-This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::ip::udp::endpoint destination(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.send_to(asio::buffer(data, size), destination);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::send_to (2 of 3 overloads)]
-
-
-Send raw data to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags);
-
-
-This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_raw_socket::send_to (3 of 3 overloads)]
-
-
-Send raw data to the specified endpoint. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send_to(
-      const ConstBufferSequence & buffers,
-      const endpoint_type & destination,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send raw data to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent to the remote endpoint.]]
-
-[[destination][The remote endpoint to which the data will be sent.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_option basic_raw_socket::set_option]
-
-[indexterm2 asio.indexterm.basic_raw_socket.set_option..set_option..basic_raw_socket] 
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_raw_socket.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_raw_socket.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::set_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::set_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  asio::error_code ec;
-  socket.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown basic_raw_socket::shutdown]
-
-[indexterm2 asio.indexterm.basic_raw_socket.shutdown..shutdown..basic_raw_socket] 
-Disable sends or receives on the socket. 
-
-
-  void ``[link asio.reference.basic_raw_socket.shutdown.overload1 shutdown]``(
-      shutdown_type what);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.shutdown.overload2 shutdown]``(
-      shutdown_type what,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.shutdown.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::shutdown (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::shutdown (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what,
-      asio::error_code & ec);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_raw_socket::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.shutdown_type..shutdown_type..basic_raw_socket] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_raw_socket.shutdown_type.shutdown_receive..shutdown_receive..basic_raw_socket]
-[indexterm2 asio.indexterm.basic_raw_socket.shutdown_type.shutdown_send..shutdown_send..basic_raw_socket]
-[indexterm2 asio.indexterm.basic_raw_socket.shutdown_type.shutdown_both..shutdown_both..basic_raw_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_raw_socket::wait]
-
-[indexterm2 asio.indexterm.basic_raw_socket.wait..wait..basic_raw_socket] 
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_raw_socket.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_raw_socket.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_raw_socket.wait.overload2 more...]]``
-
-
-[section:overload1 basic_raw_socket::wait (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.wait(asio::ip::tcp::socket::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_raw_socket::wait (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.wait(asio::ip::tcp::socket::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_raw_socket::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_raw_socket.wait_type..wait_type..basic_raw_socket] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_raw_socket.wait_type.wait_read..wait_read..basic_raw_socket]
-[indexterm2 asio.indexterm.basic_raw_socket.wait_type.wait_write..wait_write..basic_raw_socket]
-[indexterm2 asio.indexterm.basic_raw_socket.wait_type.wait_error..wait_error..basic_raw_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_raw_socket basic_raw_socket::~basic_raw_socket]
-
-[indexterm2 asio.indexterm.basic_raw_socket._basic_raw_socket..~basic_raw_socket..basic_raw_socket] 
-Destroys the socket. 
-
-
-  ~basic_raw_socket();
-
-
-This function destroys the socket, cancelling any outstanding asynchronous operations associated with the socket as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_raw_socket__rebind_executor basic_raw_socket::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_raw_socket__rebind_executor..basic_raw_socket::rebind_executor]
-
-
-Rebinds the socket type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_raw_socket__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_raw_socket::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_raw_socket__rebind_executor.other..other..basic_raw_socket::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_raw_socket< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_raw_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]] [constructor]]
-    [Construct a basic_raw_socket without opening it. 
-     [hr]
-     Construct and open a basic_raw_socket. 
-     [hr]
-     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_raw_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_raw_socket from another. 
-     [hr]
-     Move-construct a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_raw_socket from another. 
-     [hr]
-     Move-assign a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive_from [*receive_from]]]
-    [Receive raw data with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send_to [*send_to]]]
-    [Send raw data to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket._basic_raw_socket [*~basic_raw_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_raw_socket `basic_raw_socket`] class template provides asynchronous and blocking raw-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_raw_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_readable_pipe basic_readable_pipe]
-
-[indexterm1 asio.indexterm.basic_readable_pipe..basic_readable_pipe]
-
-
-Provides pipe functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_readable_pipe
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_readable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_readable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.basic_readable_pipe [*basic_readable_pipe]] [constructor]]
-    [Construct a basic_readable_pipe without opening it. 
-     [hr]
-     Construct a basic_readable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_readable_pipe from another. 
-     [hr]
-     Move-construct a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_readable_pipe from another. 
-     [hr]
-     Move-assign a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.read_some [*read_some]]]
-    [Read some data from the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe._basic_readable_pipe [*~basic_readable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_readable_pipe `basic_readable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_readable_pipe::assign]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.assign..assign..basic_readable_pipe] 
-Assign an existing native pipe to the pipe. 
-
-
-  void ``[link asio.reference.basic_readable_pipe.assign.overload1 assign]``(
-      const native_handle_type & native_pipe);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_readable_pipe.assign.overload2 assign]``(
-      const native_handle_type & native_pipe,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.assign.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::assign (1 of 2 overloads)]
-
-
-Assign an existing native pipe to the pipe. 
-
-
-  void assign(
-      const native_handle_type & native_pipe);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::assign (2 of 2 overloads)]
-
-
-Assign an existing native pipe to the pipe. 
-
-
-  void assign(
-      const native_handle_type & native_pipe,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some basic_readable_pipe::async_read_some]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.async_read_some..async_read_some..basic_readable_pipe] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the pipe. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_readable_pipe.async_read_some(
-      asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-[section:basic_readable_pipe basic_readable_pipe::basic_readable_pipe]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.basic_readable_pipe..basic_readable_pipe..basic_readable_pipe] 
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload1 basic_readable_pipe]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload2 basic_readable_pipe]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload2 more...]]``
-
-
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] on an existing native pipe. 
-
-
-  ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload3 basic_readable_pipe]``(
-      const executor_type & ex,
-      const native_handle_type & native_pipe);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload4 basic_readable_pipe]``(
-      ExecutionContext & context,
-      const native_handle_type & native_pipe,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload4 more...]]``
-
-
-Move-construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from another. 
-
-
-  ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload5 basic_readable_pipe]``(
-      basic_readable_pipe && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload5 more...]]``
-
-
-Move-construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_readable_pipe.basic_readable_pipe.overload6 basic_readable_pipe]``(
-      basic_readable_pipe< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.basic_readable_pipe.overload6 more...]]``
-
-
-[section:overload1 basic_readable_pipe::basic_readable_pipe (1 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] without opening it. 
-
-
-  basic_readable_pipe(
-      const executor_type & ex);
-
-
-This constructor creates a pipe without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::basic_readable_pipe (2 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_readable_pipe(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a pipe without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_readable_pipe::basic_readable_pipe (3 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] on an existing native pipe. 
-
-
-  basic_readable_pipe(
-      const executor_type & ex,
-      const native_handle_type & native_pipe);
-
-
-This constructor creates a pipe object to hold an existing native pipe.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe.]]
-
-[[native_pipe][A native pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_readable_pipe::basic_readable_pipe (4 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] on an existing native pipe. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_readable_pipe(
-      ExecutionContext & context,
-      const native_handle_type & native_pipe,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a pipe object to hold an existing native pipe.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe.]]
-
-[[native_pipe][A native pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_readable_pipe::basic_readable_pipe (5 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from another. 
-
-
-  basic_readable_pipe(
-      basic_readable_pipe && other);
-
-
-This constructor moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_readable_pipe `basic_readable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_readable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_readable_pipe::basic_readable_pipe (6 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_readable_pipe(
-      basic_readable_pipe< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_readable_pipe `basic_readable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_readable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_readable_pipe::cancel]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.cancel..cancel..basic_readable_pipe] 
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void ``[link asio.reference.basic_readable_pipe.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_readable_pipe.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_readable_pipe::close]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.close..close..basic_readable_pipe] 
-Close the pipe. 
-
-
-  void ``[link asio.reference.basic_readable_pipe.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_readable_pipe.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.close.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::close (1 of 2 overloads)]
-
-
-Close the pipe. 
-
-
-  void close();
-
-
-This function is used to close the pipe. Any asynchronous read operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::close (2 of 2 overloads)]
-
-
-Close the pipe. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the pipe. Any asynchronous read operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_readable_pipe::executor_type]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.executor_type..executor_type..basic_readable_pipe] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_readable_pipe::get_executor]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.get_executor..get_executor..basic_readable_pipe] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open basic_readable_pipe::is_open]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.is_open..is_open..basic_readable_pipe] 
-Determine whether the pipe is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer basic_readable_pipe::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.lowest_layer..lowest_layer..basic_readable_pipe] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_readable_pipe.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_readable_pipe.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_readable_pipe::lowest_layer_type]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.lowest_layer_type..lowest_layer_type..basic_readable_pipe] 
-A [link asio.reference.basic_readable_pipe `basic_readable_pipe`] is always the lowest layer. 
-
-
-  typedef basic_readable_pipe lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_readable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_readable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.basic_readable_pipe [*basic_readable_pipe]] [constructor]]
-    [Construct a basic_readable_pipe without opening it. 
-     [hr]
-     Construct a basic_readable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_readable_pipe from another. 
-     [hr]
-     Move-construct a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_readable_pipe from another. 
-     [hr]
-     Move-assign a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.read_some [*read_some]]]
-    [Read some data from the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe._basic_readable_pipe [*~basic_readable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_readable_pipe `basic_readable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle basic_readable_pipe::native_handle]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.native_handle..native_handle..basic_readable_pipe] 
-Get the native pipe representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the pipe. This is intended to allow access to native pipe functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_readable_pipe::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.native_handle_type..native_handle_type..basic_readable_pipe] 
-The native representation of a pipe. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ basic_readable_pipe::operator=]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.operator_eq_..operator=..basic_readable_pipe] 
-Move-assign a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from another. 
-
-
-  basic_readable_pipe & ``[link asio.reference.basic_readable_pipe.operator_eq_.overload1 operator=]``(
-      basic_readable_pipe && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_readable_pipe & > ``[link asio.reference.basic_readable_pipe.operator_eq_.overload2 operator=]``(
-      basic_readable_pipe< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from another. 
-
-
-  basic_readable_pipe & operator=(
-      basic_readable_pipe && other);
-
-
-This assignment operator moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_readable_pipe `basic_readable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_readable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_readable_pipe `basic_readable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_readable_pipe & > operator=(
-      basic_readable_pipe< Executor1 > && other);
-
-
-This assignment operator moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_readable_pipe `basic_readable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_readable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some basic_readable_pipe::read_some]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.read_some..read_some..basic_readable_pipe] 
-Read some data from the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_readable_pipe.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_readable_pipe.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.read_some.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::read_some (1 of 2 overloads)]
-
-
-Read some data from the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the pipe. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_readable_pipe.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::read_some (2 of 2 overloads)]
-
-
-Read some data from the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the pipe. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:release basic_readable_pipe::release]
-
-[indexterm2 asio.indexterm.basic_readable_pipe.release..release..basic_readable_pipe] 
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type ``[link asio.reference.basic_readable_pipe.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_readable_pipe.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_readable_pipe.release.overload2 more...]]``
-
-
-[section:overload1 basic_readable_pipe::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous read operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native pipe is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_readable_pipe::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native pipe is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_readable_pipe basic_readable_pipe::~basic_readable_pipe]
-
-[indexterm2 asio.indexterm.basic_readable_pipe._basic_readable_pipe..~basic_readable_pipe..basic_readable_pipe] 
-Destroys the pipe. 
-
-
-  ~basic_readable_pipe();
-
-
-This function destroys the pipe, cancelling any outstanding asynchronous wait operations associated with the pipe as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_readable_pipe__rebind_executor basic_readable_pipe::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_readable_pipe__rebind_executor..basic_readable_pipe::rebind_executor]
-
-
-Rebinds the pipe type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe__rebind_executor.other [*other]]]
-    [The pipe type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_readable_pipe::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_readable_pipe__rebind_executor.other..other..basic_readable_pipe::rebind_executor] 
-The pipe type when rebound to the specified executor. 
-
-
-  typedef basic_readable_pipe< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_readable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_readable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.basic_readable_pipe [*basic_readable_pipe]] [constructor]]
-    [Construct a basic_readable_pipe without opening it. 
-     [hr]
-     Construct a basic_readable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_readable_pipe from another. 
-     [hr]
-     Move-construct a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_readable_pipe from another. 
-     [hr]
-     Move-assign a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.read_some [*read_some]]]
-    [Read some data from the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe._basic_readable_pipe [*~basic_readable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_readable_pipe `basic_readable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_seq_packet_socket basic_seq_packet_socket]
-
-[indexterm1 asio.indexterm.basic_seq_packet_socket..basic_seq_packet_socket]
-
-
-Provides sequenced packet socket functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_seq_packet_socket :
-    public basic_socket< Protocol, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket [*basic_seq_packet_socket]] [constructor]]
-    [Construct a basic_seq_packet_socket without opening it. 
-     [hr]
-     Construct and open a basic_seq_packet_socket. 
-     [hr]
-     Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_seq_packet_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from another. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_seq_packet_socket from another. 
-     [hr]
-     Move-assign a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket._basic_seq_packet_socket [*~basic_seq_packet_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] class template provides asynchronous and blocking sequenced packet socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_seq_packet_socket::assign]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.assign..assign..basic_seq_packet_socket] 
-Assign an existing native socket to the socket. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.assign.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_connect basic_seq_packet_socket::async_connect]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.async_connect..async_connect..basic_seq_packet_socket] 
-Start an asynchronous connect. 
-
-
-  template<
-      typename ``[link asio.reference.ConnectToken ConnectToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      const endpoint_type & peer_endpoint,
-      ConnectToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously connect a socket to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void connect_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Connect succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_connect(endpoint, connect_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:async_receive basic_seq_packet_socket::async_receive]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.async_receive..async_receive..basic_seq_packet_socket] 
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_seq_packet_socket.async_receive.overload1 async_receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags & out_flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.async_receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_seq_packet_socket.async_receive.overload2 async_receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.async_receive.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::async_receive (1 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags & out_flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the sequenced packet socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[out_flags][Once the asynchronous operation completes, contains flags associated with the received data. For example, if the `socket_base::message_end_of_record` bit is set then the received data marks the end of a record. The caller must guarantee that the referenced variable remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(asio::buffer(data, size), out_flags, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::async_receive (2 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the sequenced data socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[in_flags][Flags specifying how the receive call is to be made.]]
-
-[[out_flags][Once the asynchronous operation completes, contains flags associated with the received data. For example, if the `socket_base::message_end_of_record` bit is set then the received data marks the end of a record. The caller must guarantee that the referenced variable remains valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(
-      asio::buffer(data, size),
-      0, out_flags, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_send basic_seq_packet_socket::async_send]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.async_send..async_send..basic_seq_packet_socket] 
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the sequenced packet socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_send(asio::buffer(data, size), 0, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_wait basic_seq_packet_socket::async_wait]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.async_wait..async_wait..basic_seq_packet_socket] 
-Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:at_mark basic_seq_packet_socket::at_mark]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.at_mark..at_mark..basic_seq_packet_socket] 
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool ``[link asio.reference.basic_seq_packet_socket.at_mark.overload1 at_mark]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.at_mark.overload1 more...]]``
-
-  bool ``[link asio.reference.basic_seq_packet_socket.at_mark.overload2 at_mark]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.at_mark.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::at_mark (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark() const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::at_mark (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark(
-      asio::error_code & ec) const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:available basic_seq_packet_socket::available]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.available..available..basic_seq_packet_socket] 
-Determine the number of bytes available for reading. 
-
-
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.available.overload1 available]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.available.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.available.overload2 available]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.available.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::available (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available() const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::available (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available(
-      asio::error_code & ec) const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_seq_packet_socket basic_seq_packet_socket::basic_seq_packet_socket]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.basic_seq_packet_socket..basic_seq_packet_socket..basic_seq_packet_socket] 
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload1 basic_seq_packet_socket]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload2 basic_seq_packet_socket]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`]. 
-
-
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload3 basic_seq_packet_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload4 basic_seq_packet_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload4 more...]]``
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`], opening it and binding it to the given local endpoint. 
-
-
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload5 basic_seq_packet_socket]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload6 basic_seq_packet_socket]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] on an existing native socket. 
-
-
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload7 basic_seq_packet_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload8 basic_seq_packet_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from another. 
-
-
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload9 basic_seq_packet_socket]``(
-      basic_seq_packet_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload10 basic_seq_packet_socket]``(
-      basic_seq_packet_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket.overload10 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::basic_seq_packet_socket (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] without opening it. 
-
-
-  basic_seq_packet_socket(
-      const executor_type & ex);
-
-
-This constructor creates a sequenced packet socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::basic_seq_packet_socket (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_seq_packet_socket(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a sequenced packet socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_seq_packet_socket::basic_seq_packet_socket (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`]. 
-
-
-  basic_seq_packet_socket(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates and opens a sequenced\_packet socket. The socket needs to be connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_seq_packet_socket::basic_seq_packet_socket (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_seq_packet_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a sequenced\_packet socket. The socket needs to be connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_seq_packet_socket::basic_seq_packet_socket (5 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`], opening it and binding it to the given local endpoint. 
-
-
-  basic_seq_packet_socket(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-
-
-This constructor creates a sequenced packet socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the sequenced packet socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_seq_packet_socket::basic_seq_packet_socket (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`], opening it and binding it to the given local endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_seq_packet_socket(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a sequenced packet socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the sequenced packet socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_seq_packet_socket::basic_seq_packet_socket (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] on an existing native socket. 
-
-
-  basic_seq_packet_socket(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-This constructor creates a sequenced packet socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_seq_packet_socket::basic_seq_packet_socket (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] on an existing native socket. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_seq_packet_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a sequenced packet socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_seq_packet_socket::basic_seq_packet_socket (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from another. 
-
-
-  basic_seq_packet_socket(
-      basic_seq_packet_socket && other);
-
-
-This constructor moves a sequenced packet socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_seq_packet_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_seq_packet_socket::basic_seq_packet_socket (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_seq_packet_socket(
-      basic_seq_packet_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a sequenced packet socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_seq_packet_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_seq_packet_socket::bind]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.bind..bind..basic_seq_packet_socket] 
-Bind the socket to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.bind.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::bind (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::bind (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  asio::error_code ec;
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_seq_packet_socket::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.broadcast..broadcast..basic_seq_packet_socket] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_seq_packet_socket::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.bytes_readable..bytes_readable..basic_seq_packet_socket] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_seq_packet_socket::cancel]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.cancel..cancel..basic_seq_packet_socket] 
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_seq_packet_socket::close]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.close..close..basic_seq_packet_socket] 
-Close the socket. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.close.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::close (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close();
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::close (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect basic_seq_packet_socket::connect]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.connect..connect..basic_seq_packet_socket] 
-Connect the socket to the specified endpoint. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.connect.overload1 connect]``(
-      const endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.connect.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.connect.overload2 connect]``(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.connect.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::connect (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.connect(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::connect (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  asio::error_code ec;
-  socket.connect(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_seq_packet_socket::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.debug..debug..basic_seq_packet_socket] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_seq_packet_socket::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.do_not_route..do_not_route..basic_seq_packet_socket] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_seq_packet_socket::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.enable_connection_aborted..enable_connection_aborted..basic_seq_packet_socket] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_seq_packet_socket::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.endpoint_type..endpoint_type..basic_seq_packet_socket] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_seq_packet_socket::executor_type]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.executor_type..executor_type..basic_seq_packet_socket] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_seq_packet_socket::get_executor]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.get_executor..get_executor..basic_seq_packet_socket] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_seq_packet_socket::get_option]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.get_option..get_option..basic_seq_packet_socket] 
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_seq_packet_socket.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_seq_packet_socket.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::get_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::get_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  asio::error_code ec;
-  socket.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_seq_packet_socket::io_control]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.io_control..io_control..basic_seq_packet_socket] 
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_seq_packet_socket.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_seq_packet_socket.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::io_control (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::io_control (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_seq_packet_socket::is_open]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.is_open..is_open..basic_seq_packet_socket] 
-Determine whether the socket is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_seq_packet_socket::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.keep_alive..keep_alive..basic_seq_packet_socket] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_seq_packet_socket::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.linger..linger..basic_seq_packet_socket] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:local_endpoint basic_seq_packet_socket::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.local_endpoint..local_endpoint..basic_seq_packet_socket] 
-Get the local endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_seq_packet_socket.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_seq_packet_socket.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::local_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::local_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer basic_seq_packet_socket::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.lowest_layer..lowest_layer..basic_seq_packet_socket] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_seq_packet_socket.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_seq_packet_socket.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_seq_packet_socket::lowest_layer_type]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.lowest_layer_type..lowest_layer_type..basic_seq_packet_socket] 
-A [link asio.reference.basic_socket `basic_socket`] is always the lowest layer. 
-
-
-  typedef basic_socket< Protocol, Executor > lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections basic_seq_packet_socket::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.max_connections..max_connections..basic_seq_packet_socket] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_seq_packet_socket::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.max_listen_connections..max_listen_connections..basic_seq_packet_socket] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_seq_packet_socket::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.message_do_not_route..message_do_not_route..basic_seq_packet_socket] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_seq_packet_socket::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.message_end_of_record..message_end_of_record..basic_seq_packet_socket] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_seq_packet_socket::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.message_flags..message_flags..basic_seq_packet_socket] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_seq_packet_socket::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.message_out_of_band..message_out_of_band..basic_seq_packet_socket] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_seq_packet_socket::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.message_peek..message_peek..basic_seq_packet_socket] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_seq_packet_socket::native_handle]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.native_handle..native_handle..basic_seq_packet_socket] 
-Get the native socket representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_seq_packet_socket::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.native_handle_type..native_handle_type..basic_seq_packet_socket] 
-The native representation of a socket. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_seq_packet_socket::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.native_non_blocking..native_non_blocking..basic_seq_packet_socket] 
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool ``[link asio.reference.basic_seq_packet_socket.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::native_non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying socket is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::native_non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_seq_packet_socket::native_non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_seq_packet_socket::non_blocking]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.non_blocking..non_blocking..basic_seq_packet_socket] 
-Gets the non-blocking mode of the socket. 
-
-
-  bool ``[link asio.reference.basic_seq_packet_socket.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the socket. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_seq_packet_socket::non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_seq_packet_socket::open]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.open..open..basic_seq_packet_socket] 
-Open the socket using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.open.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::open (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::open (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  socket.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_seq_packet_socket::operator=]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.operator_eq_..operator=..basic_seq_packet_socket] 
-Move-assign a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from another. 
-
-
-  basic_seq_packet_socket & ``[link asio.reference.basic_seq_packet_socket.operator_eq_.overload1 operator=]``(
-      basic_seq_packet_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_seq_packet_socket & > ``[link asio.reference.basic_seq_packet_socket.operator_eq_.overload2 operator=]``(
-      basic_seq_packet_socket< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from another. 
-
-
-  basic_seq_packet_socket & operator=(
-      basic_seq_packet_socket && other);
-
-
-This assignment operator moves a sequenced packet socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_seq_packet_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_seq_packet_socket & > operator=(
-      basic_seq_packet_socket< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves a sequenced packet socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_seq_packet_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_seq_packet_socket::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.out_of_band_inline..out_of_band_inline..basic_seq_packet_socket] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_seq_packet_socket::protocol_type]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.protocol_type..protocol_type..basic_seq_packet_socket] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:receive basic_seq_packet_socket::receive]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.receive..receive..basic_seq_packet_socket] 
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.receive.overload1 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags & out_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.receive.overload2 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.receive.overload2 more...]]``
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.receive.overload3 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.receive.overload3 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::receive (1 of 3 overloads)]
-
-
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags & out_flags);
-
-
-This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[out_flags][After the receive call completes, contains flags associated with the received data. For example, if the `socket_base::message_end_of_record` bit is set then the received data marks the end of a record.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size), out_flags);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::receive (2 of 3 overloads)]
-
-
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags);
-
-
-This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[in_flags][Flags specifying how the receive call is to be made.]]
-
-[[out_flags][After the receive call completes, contains flags associated with the received data. For example, if the `socket_base::message_end_of_record` bit is set then the received data marks the end of a record.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size), 0, out_flags);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_seq_packet_socket::receive (3 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags & out_flags,
-      asio::error_code & ec);
-
-
-This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[in_flags][Flags specifying how the receive call is to be made.]]
-
-[[out_flags][After the receive call completes, contains flags associated with the received data. For example, if the `socket_base::message_end_of_record` bit is set then the received data marks the end of a record.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_buffer_size basic_seq_packet_socket::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.receive_buffer_size..receive_buffer_size..basic_seq_packet_socket] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_low_watermark basic_seq_packet_socket::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.receive_low_watermark..receive_low_watermark..basic_seq_packet_socket] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_seq_packet_socket::release]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.release..release..basic_seq_packet_socket] 
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type ``[link asio.reference.basic_seq_packet_socket.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_seq_packet_socket.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.release.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::release (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::release (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:remote_endpoint basic_seq_packet_socket::remote_endpoint]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.remote_endpoint..remote_endpoint..basic_seq_packet_socket] 
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_seq_packet_socket.remote_endpoint.overload1 remote_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.remote_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_seq_packet_socket.remote_endpoint.overload2 remote_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.remote_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::remote_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint() const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::remote_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_seq_packet_socket::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.reuse_address..reuse_address..basic_seq_packet_socket] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send basic_seq_packet_socket::send]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.send..send..basic_seq_packet_socket] 
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.send.overload1 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_seq_packet_socket.send.overload2 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.send.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::send (1 of 2 overloads)]
-
-
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to send data on the sequenced packet socket. The function call will block until the data has been sent successfully, or an until error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.send(asio::buffer(data, size), 0);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::send (2 of 2 overloads)]
-
-
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send data on the sequenced packet socket. The function call will block the data has been sent successfully, or an until error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:send_buffer_size basic_seq_packet_socket::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.send_buffer_size..send_buffer_size..basic_seq_packet_socket] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_seq_packet_socket::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.send_low_watermark..send_low_watermark..basic_seq_packet_socket] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:set_option basic_seq_packet_socket::set_option]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.set_option..set_option..basic_seq_packet_socket] 
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_seq_packet_socket.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_seq_packet_socket.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::set_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::set_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  asio::error_code ec;
-  socket.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown basic_seq_packet_socket::shutdown]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.shutdown..shutdown..basic_seq_packet_socket] 
-Disable sends or receives on the socket. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.shutdown.overload1 shutdown]``(
-      shutdown_type what);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.shutdown.overload2 shutdown]``(
-      shutdown_type what,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.shutdown.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::shutdown (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::shutdown (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what,
-      asio::error_code & ec);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_seq_packet_socket::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.shutdown_type..shutdown_type..basic_seq_packet_socket] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.shutdown_type.shutdown_receive..shutdown_receive..basic_seq_packet_socket]
-[indexterm2 asio.indexterm.basic_seq_packet_socket.shutdown_type.shutdown_send..shutdown_send..basic_seq_packet_socket]
-[indexterm2 asio.indexterm.basic_seq_packet_socket.shutdown_type.shutdown_both..shutdown_both..basic_seq_packet_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_seq_packet_socket::wait]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.wait..wait..basic_seq_packet_socket] 
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_seq_packet_socket.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_seq_packet_socket.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_seq_packet_socket.wait.overload2 more...]]``
-
-
-[section:overload1 basic_seq_packet_socket::wait (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.wait(asio::ip::tcp::socket::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_seq_packet_socket::wait (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.wait(asio::ip::tcp::socket::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_seq_packet_socket::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.wait_type..wait_type..basic_seq_packet_socket] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket.wait_type.wait_read..wait_read..basic_seq_packet_socket]
-[indexterm2 asio.indexterm.basic_seq_packet_socket.wait_type.wait_write..wait_write..basic_seq_packet_socket]
-[indexterm2 asio.indexterm.basic_seq_packet_socket.wait_type.wait_error..wait_error..basic_seq_packet_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_seq_packet_socket basic_seq_packet_socket::~basic_seq_packet_socket]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket._basic_seq_packet_socket..~basic_seq_packet_socket..basic_seq_packet_socket] 
-Destroys the socket. 
-
-
-  ~basic_seq_packet_socket();
-
-
-This function destroys the socket, cancelling any outstanding asynchronous operations associated with the socket as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_seq_packet_socket__rebind_executor basic_seq_packet_socket::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_seq_packet_socket__rebind_executor..basic_seq_packet_socket::rebind_executor]
-
-
-Rebinds the socket type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_seq_packet_socket::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_seq_packet_socket__rebind_executor.other..other..basic_seq_packet_socket::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_seq_packet_socket< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket [*basic_seq_packet_socket]] [constructor]]
-    [Construct a basic_seq_packet_socket without opening it. 
-     [hr]
-     Construct and open a basic_seq_packet_socket. 
-     [hr]
-     Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_seq_packet_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from another. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_seq_packet_socket from another. 
-     [hr]
-     Move-assign a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket._basic_seq_packet_socket [*~basic_seq_packet_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] class template provides asynchronous and blocking sequenced packet socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_seq_packet_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_serial_port basic_serial_port]
-
-[indexterm1 asio.indexterm.basic_serial_port..basic_serial_port]
-
-
-Provides serial port functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_serial_port :
-    public serial_port_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
-    [Rebinds the serial port type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_basic_serial_port is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.native_handle_type [*native_handle_type]]]
-    [The native representation of a serial port. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_serial_port.assign [*assign]]]
-    [Assign an existing native serial port to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]] [constructor]]
-    [Construct a basic_serial_port without opening it. 
-     [hr]
-     Construct and open a basic_serial_port. 
-     [hr]
-     Construct a basic_serial_port on an existing native serial port. 
-     [hr]
-     Move-construct a basic_serial_port from another. 
-     [hr]
-     Move-construct a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.close [*close]]]
-    [Close the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_option [*get_option]]]
-    [Get an option from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.is_open [*is_open]]]
-    [Determine whether the serial port is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.native_handle [*native_handle]]]
-    [Get the native serial port representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.open [*open]]]
-    [Open the serial port using the specified device name. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.operator_eq_ [*operator=]]]
-    [Move-assign a basic_serial_port from another. 
-     [hr]
-     Move-assign a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.read_some [*read_some]]]
-    [Read some data from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.send_break [*send_break]]]
-    [Send a break sequence to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.set_option [*set_option]]]
-    [Set an option on the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.write_some [*write_some]]]
-    [Write some data to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port._basic_serial_port [*~basic_serial_port]] [destructor]]
-    [Destroys the serial port. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_serial_port `basic_serial_port`] class provides a wrapper over serial port functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_serial_port::assign]
-
-[indexterm2 asio.indexterm.basic_serial_port.assign..assign..basic_serial_port] 
-Assign an existing native serial port to the serial port. 
-
-
-  void ``[link asio.reference.basic_serial_port.assign.overload1 assign]``(
-      const native_handle_type & native_serial_port);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_serial_port.assign.overload2 assign]``(
-      const native_handle_type & native_serial_port,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.assign.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::assign (1 of 2 overloads)]
-
-
-Assign an existing native serial port to the serial port. 
-
-
-  void assign(
-      const native_handle_type & native_serial_port);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::assign (2 of 2 overloads)]
-
-
-Assign an existing native serial port to the serial port. 
-
-
-  void assign(
-      const native_handle_type & native_serial_port,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some basic_serial_port::async_read_some]
-
-[indexterm2 asio.indexterm.basic_serial_port.async_read_some..async_read_some..basic_serial_port] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the serial port. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_serial_port.async_read_some(
-      asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some basic_serial_port::async_write_some]
-
-[indexterm2 asio.indexterm.basic_serial_port.async_write_some..async_write_some..basic_serial_port] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the serial port. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the serial port. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_serial_port.async_write_some(
-      asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_serial_port basic_serial_port::basic_serial_port]
-
-[indexterm2 asio.indexterm.basic_serial_port.basic_serial_port..basic_serial_port..basic_serial_port] 
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_serial_port.basic_serial_port.overload1 basic_serial_port]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_serial_port.basic_serial_port.overload2 basic_serial_port]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_serial_port `basic_serial_port`]. 
-
-
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload3 basic_serial_port]``(
-      const executor_type & ex,
-      const char * device);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload4 basic_serial_port]``(
-      ExecutionContext & context,
-      const char * device,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload4 more...]]``
-
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload5 basic_serial_port]``(
-      const executor_type & ex,
-      const std::string & device);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload6 basic_serial_port]``(
-      ExecutionContext & context,
-      const std::string & device,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] on an existing native serial port. 
-
-
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload7 basic_serial_port]``(
-      const executor_type & ex,
-      const native_handle_type & native_serial_port);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload8 basic_serial_port]``(
-      ExecutionContext & context,
-      const native_handle_type & native_serial_port,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_serial_port `basic_serial_port`] from another. 
-
-
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload9 basic_serial_port]``(
-      basic_serial_port && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_serial_port `basic_serial_port`] from a serial port of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_serial_port.basic_serial_port.overload10 basic_serial_port]``(
-      basic_serial_port< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.basic_serial_port.overload10 more...]]``
-
-
-[section:overload1 basic_serial_port::basic_serial_port (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] without opening it. 
-
-
-  basic_serial_port(
-      const executor_type & ex);
-
-
-This constructor creates a serial port without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::basic_serial_port (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_serial_port(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a serial port without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_serial_port::basic_serial_port (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_serial_port `basic_serial_port`]. 
-
-
-  basic_serial_port(
-      const executor_type & ex,
-      const char * device);
-
-
-This constructor creates and opens a serial port for the specified device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[device][The platform-specific device name for this serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_serial_port::basic_serial_port (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_serial_port `basic_serial_port`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_serial_port(
-      ExecutionContext & context,
-      const char * device,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates and opens a serial port for the specified device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[device][The platform-specific device name for this serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_serial_port::basic_serial_port (5 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_serial_port `basic_serial_port`]. 
-
-
-  basic_serial_port(
-      const executor_type & ex,
-      const std::string & device);
-
-
-This constructor creates and opens a serial port for the specified device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[device][The platform-specific device name for this serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_serial_port::basic_serial_port (6 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_serial_port `basic_serial_port`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_serial_port(
-      ExecutionContext & context,
-      const std::string & device,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates and opens a serial port for the specified device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[device][The platform-specific device name for this serial port. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_serial_port::basic_serial_port (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] on an existing native serial port. 
-
-
-  basic_serial_port(
-      const executor_type & ex,
-      const native_handle_type & native_serial_port);
-
-
-This constructor creates a serial port object to hold an existing native serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[native_serial_port][A native serial port.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_serial_port::basic_serial_port (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_serial_port `basic_serial_port`] on an existing native serial port. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_serial_port(
-      ExecutionContext & context,
-      const native_handle_type & native_serial_port,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a serial port object to hold an existing native serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the serial port will use, by default, to dispatch handlers for any asynchronous operations performed on the serial port.]]
-
-[[native_serial_port][A native serial port.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_serial_port::basic_serial_port (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_serial_port `basic_serial_port`] from another. 
-
-
-  basic_serial_port(
-      basic_serial_port && other);
-
-
-This constructor moves a serial port from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_serial_port `basic_serial_port`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_serial_port(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_serial_port::basic_serial_port (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_serial_port `basic_serial_port`] from a serial port of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_serial_port(
-      basic_serial_port< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a serial port from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_serial_port `basic_serial_port`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_serial_port(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_serial_port::cancel]
-
-[indexterm2 asio.indexterm.basic_serial_port.cancel..cancel..basic_serial_port] 
-Cancel all asynchronous operations associated with the serial port. 
-
-
-  void ``[link asio.reference.basic_serial_port.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_serial_port.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the serial port. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the serial port. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_serial_port::close]
-
-[indexterm2 asio.indexterm.basic_serial_port.close..close..basic_serial_port] 
-Close the serial port. 
-
-
-  void ``[link asio.reference.basic_serial_port.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_serial_port.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.close.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::close (1 of 2 overloads)]
-
-
-Close the serial port. 
-
-
-  void close();
-
-
-This function is used to close the serial port. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::close (2 of 2 overloads)]
-
-
-Close the serial port. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the serial port. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_serial_port::executor_type]
-
-[indexterm2 asio.indexterm.basic_serial_port.executor_type..executor_type..basic_serial_port] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_serial_port::get_executor]
-
-[indexterm2 asio.indexterm.basic_serial_port.get_executor..get_executor..basic_serial_port] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_serial_port::get_option]
-
-[indexterm2 asio.indexterm.basic_serial_port.get_option..get_option..basic_serial_port] 
-Get an option from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
-  void ``[link asio.reference.basic_serial_port.get_option.overload1 get_option]``(
-      GettableSerialPortOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
-  void ``[link asio.reference.basic_serial_port.get_option.overload2 get_option]``(
-      GettableSerialPortOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::get_option (1 of 2 overloads)]
-
-
-Get an option from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
-  void get_option(
-      GettableSerialPortOption & option) const;
-
-
-This function is used to get the current value of an option on the serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the serial port.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::get_option (2 of 2 overloads)]
-
-
-Get an option from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSerialPortOption GettableSerialPortOption]``>
-  void get_option(
-      GettableSerialPortOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the serial port.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_serial_port::is_open]
-
-[indexterm2 asio.indexterm.basic_serial_port.is_open..is_open..basic_serial_port] 
-Determine whether the serial port is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer basic_serial_port::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_serial_port.lowest_layer..lowest_layer..basic_serial_port] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_serial_port.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_serial_port.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_serial_port `basic_serial_port`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_serial_port `basic_serial_port`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_serial_port::lowest_layer_type]
-
-[indexterm2 asio.indexterm.basic_serial_port.lowest_layer_type..lowest_layer_type..basic_serial_port] 
-A basic\_basic\_serial\_port is always the lowest layer. 
-
-
-  typedef basic_serial_port lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
-    [Rebinds the serial port type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_basic_serial_port is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.native_handle_type [*native_handle_type]]]
-    [The native representation of a serial port. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_serial_port.assign [*assign]]]
-    [Assign an existing native serial port to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]] [constructor]]
-    [Construct a basic_serial_port without opening it. 
-     [hr]
-     Construct and open a basic_serial_port. 
-     [hr]
-     Construct a basic_serial_port on an existing native serial port. 
-     [hr]
-     Move-construct a basic_serial_port from another. 
-     [hr]
-     Move-construct a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.close [*close]]]
-    [Close the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_option [*get_option]]]
-    [Get an option from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.is_open [*is_open]]]
-    [Determine whether the serial port is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.native_handle [*native_handle]]]
-    [Get the native serial port representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.open [*open]]]
-    [Open the serial port using the specified device name. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.operator_eq_ [*operator=]]]
-    [Move-assign a basic_serial_port from another. 
-     [hr]
-     Move-assign a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.read_some [*read_some]]]
-    [Read some data from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.send_break [*send_break]]]
-    [Send a break sequence to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.set_option [*set_option]]]
-    [Set an option on the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.write_some [*write_some]]]
-    [Write some data to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port._basic_serial_port [*~basic_serial_port]] [destructor]]
-    [Destroys the serial port. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_serial_port `basic_serial_port`] class provides a wrapper over serial port functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle basic_serial_port::native_handle]
-
-[indexterm2 asio.indexterm.basic_serial_port.native_handle..native_handle..basic_serial_port] 
-Get the native serial port representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the serial port. This is intended to allow access to native serial port functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_serial_port::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_serial_port.native_handle_type..native_handle_type..basic_serial_port] 
-The native representation of a serial port. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:open basic_serial_port::open]
-
-[indexterm2 asio.indexterm.basic_serial_port.open..open..basic_serial_port] 
-Open the serial port using the specified device name. 
-
-
-  void ``[link asio.reference.basic_serial_port.open.overload1 open]``(
-      const std::string & device);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_serial_port.open.overload2 open]``(
-      const std::string & device,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.open.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::open (1 of 2 overloads)]
-
-
-Open the serial port using the specified device name. 
-
-
-  void open(
-      const std::string & device);
-
-
-This function opens the serial port for the specified device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[device][The platform-specific device name.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::open (2 of 2 overloads)]
-
-
-Open the serial port using the specified device name. 
-
-
-  void open(
-      const std::string & device,
-      asio::error_code & ec);
-
-
-This function opens the serial port using the given platform-specific device name.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[device][The platform-specific device name.]]
-
-[[ec][Set the indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_serial_port::operator=]
-
-[indexterm2 asio.indexterm.basic_serial_port.operator_eq_..operator=..basic_serial_port] 
-Move-assign a [link asio.reference.basic_serial_port `basic_serial_port`] from another. 
-
-
-  basic_serial_port & ``[link asio.reference.basic_serial_port.operator_eq_.overload1 operator=]``(
-      basic_serial_port && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_serial_port `basic_serial_port`] from a serial port of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_serial_port & > ``[link asio.reference.basic_serial_port.operator_eq_.overload2 operator=]``(
-      basic_serial_port< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_serial_port `basic_serial_port`] from another. 
-
-
-  basic_serial_port & operator=(
-      basic_serial_port && other);
-
-
-This assignment operator moves a serial port from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_serial_port `basic_serial_port`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_serial_port(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_serial_port `basic_serial_port`] from a serial port of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_serial_port & > operator=(
-      basic_serial_port< Executor1 > && other);
-
-
-This assignment operator moves a serial port from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_serial_port `basic_serial_port`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_serial_port(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some basic_serial_port::read_some]
-
-[indexterm2 asio.indexterm.basic_serial_port.read_some..read_some..basic_serial_port] 
-Read some data from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_serial_port.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_serial_port.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.read_some.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::read_some (1 of 2 overloads)]
-
-
-Read some data from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_serial_port.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::read_some (2 of 2 overloads)]
-
-
-Read some data from the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:send_break basic_serial_port::send_break]
-
-[indexterm2 asio.indexterm.basic_serial_port.send_break..send_break..basic_serial_port] 
-Send a break sequence to the serial port. 
-
-
-  void ``[link asio.reference.basic_serial_port.send_break.overload1 send_break]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.send_break.overload1 more...]]``
-
-  void ``[link asio.reference.basic_serial_port.send_break.overload2 send_break]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.send_break.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::send_break (1 of 2 overloads)]
-
-
-Send a break sequence to the serial port. 
-
-
-  void send_break();
-
-
-This function causes a break sequence of platform-specific duration to be sent out the serial port.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::send_break (2 of 2 overloads)]
-
-
-Send a break sequence to the serial port. 
-
-
-  void send_break(
-      asio::error_code & ec);
-
-
-This function causes a break sequence of platform-specific duration to be sent out the serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_option basic_serial_port::set_option]
-
-[indexterm2 asio.indexterm.basic_serial_port.set_option..set_option..basic_serial_port] 
-Set an option on the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
-  void ``[link asio.reference.basic_serial_port.set_option.overload1 set_option]``(
-      const SettableSerialPortOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
-  void ``[link asio.reference.basic_serial_port.set_option.overload2 set_option]``(
-      const SettableSerialPortOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::set_option (1 of 2 overloads)]
-
-
-Set an option on the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
-  void set_option(
-      const SettableSerialPortOption & option);
-
-
-This function is used to set an option on the serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be set on the serial port.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::set_option (2 of 2 overloads)]
-
-
-Set an option on the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSerialPortOption SettableSerialPortOption]``>
-  void set_option(
-      const SettableSerialPortOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the serial port.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be set on the serial port.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some basic_serial_port::write_some]
-
-[indexterm2 asio.indexterm.basic_serial_port.write_some..write_some..basic_serial_port] 
-Write some data to the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_serial_port.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_serial_port.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_serial_port.write_some.overload2 more...]]``
-
-
-[section:overload1 basic_serial_port::write_some (1 of 2 overloads)]
-
-
-Write some data to the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the serial port.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  basic_serial_port.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_serial_port::write_some (2 of 2 overloads)]
-
-
-Write some data to the serial port. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the serial port.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_serial_port basic_serial_port::~basic_serial_port]
-
-[indexterm2 asio.indexterm.basic_serial_port._basic_serial_port..~basic_serial_port..basic_serial_port] 
-Destroys the serial port. 
-
-
-  ~basic_serial_port();
-
-
-This function destroys the serial port, cancelling any outstanding asynchronous wait operations associated with the serial port as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_serial_port__rebind_executor basic_serial_port::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_serial_port__rebind_executor..basic_serial_port::rebind_executor]
-
-
-Rebinds the serial port type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_serial_port__rebind_executor.other [*other]]]
-    [The serial port type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_serial_port::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_serial_port__rebind_executor.other..other..basic_serial_port::rebind_executor] 
-The serial port type when rebound to the specified executor. 
-
-
-  typedef basic_serial_port< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
-    [Rebinds the serial port type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_basic_serial_port is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.native_handle_type [*native_handle_type]]]
-    [The native representation of a serial port. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_serial_port.assign [*assign]]]
-    [Assign an existing native serial port to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]] [constructor]]
-    [Construct a basic_serial_port without opening it. 
-     [hr]
-     Construct and open a basic_serial_port. 
-     [hr]
-     Construct a basic_serial_port on an existing native serial port. 
-     [hr]
-     Move-construct a basic_serial_port from another. 
-     [hr]
-     Move-construct a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.close [*close]]]
-    [Close the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_option [*get_option]]]
-    [Get an option from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.is_open [*is_open]]]
-    [Determine whether the serial port is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.native_handle [*native_handle]]]
-    [Get the native serial port representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.open [*open]]]
-    [Open the serial port using the specified device name. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.operator_eq_ [*operator=]]]
-    [Move-assign a basic_serial_port from another. 
-     [hr]
-     Move-assign a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.read_some [*read_some]]]
-    [Read some data from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.send_break [*send_break]]]
-    [Send a break sequence to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.set_option [*set_option]]]
-    [Set an option on the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.write_some [*write_some]]]
-    [Write some data to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port._basic_serial_port [*~basic_serial_port]] [destructor]]
-    [Destroys the serial port. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_serial_port `basic_serial_port`] class provides a wrapper over serial port functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_signal_set basic_signal_set]
-
-[indexterm1 asio.indexterm.basic_signal_set..basic_signal_set]
-
-
-Provides signal functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_signal_set :
-    public signal_set_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
-    [Rebinds the signal set type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags [*flags]]]
-    [Enumeration representing the different types of flags that may specified when adding a signal to a set. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags_t [*flags_t]]]
-    [Portability typedef. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_signal_set.add [*add]]]
-    [Add a signal to a signal_set. 
-     [hr]
-     Add a signal to a signal_set with the specified flags. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.async_wait [*async_wait]]]
-    [Start an asynchronous operation to wait for a signal to be delivered. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.basic_signal_set [*basic_signal_set]] [constructor]]
-    [Construct a signal set without adding any signals. 
-     [hr]
-     Construct a signal set and add one signal. 
-     [hr]
-     Construct a signal set and add two signals. 
-     [hr]
-     Construct a signal set and add three signals. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.cancel [*cancel]]]
-    [Cancel all operations associated with the signal set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.clear [*clear]]]
-    [Remove all signals from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.remove [*remove]]]
-    [Remove a signal from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set._basic_signal_set [*~basic_signal_set]] [destructor]]
-    [Destroys the signal set. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_signal_set `basic_signal_set`] class provides the ability to perform an asynchronous wait for one or more signals to occur.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Example]
-  
-Performing an asynchronous wait: 
-
-  void handler(
-      const asio::error_code& error,
-      int signal_number)
-  {
-    if (!error)
-    {
-      // A signal occurred.
-    }
-  }
-
-  ...
-
-  // Construct a signal set registered for process termination.
-  asio::signal_set signals(my_context, SIGINT, SIGTERM);
-
-  // Start an asynchronous wait for one of the signals to occur.
-  signals.async_wait(handler);
-
-
-
-
-
-[heading Queueing of signal notifications]
-  
-
-
-If a signal is registered with a signal\_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async\_wait operation on that signal\_set will dequeue the notification. If multiple notifications are queued, subsequent async\_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
-
-If a signal number is removed from a signal\_set (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.
-
-
-[heading Multiple registration of signals]
-  
-
-
-The same signal number may be registered with different signal\_set objects. When the signal occurs, one handler is called for each signal\_set object.
-
-Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.
-
-
-[heading Signal masking on POSIX platforms]
-  
-
-
-POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using signal\_set objects are unblocked in at least one thread. 
-
-[heading Requirements]
-
-['Header: ][^asio/basic_signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:add basic_signal_set::add]
-
-[indexterm2 asio.indexterm.basic_signal_set.add..add..basic_signal_set] 
-Add a signal to a signal\_set. 
-
-
-  void ``[link asio.reference.basic_signal_set.add.overload1 add]``(
-      int signal_number);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.add.overload1 more...]]``
-
-  void ``[link asio.reference.basic_signal_set.add.overload2 add]``(
-      int signal_number,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.add.overload2 more...]]``
-
-
-Add a signal to a signal\_set with the specified flags. 
-
-
-  void ``[link asio.reference.basic_signal_set.add.overload3 add]``(
-      int signal_number,
-      flags_t f);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.add.overload3 more...]]``
-
-  void ``[link asio.reference.basic_signal_set.add.overload4 add]``(
-      int signal_number,
-      flags_t f,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.add.overload4 more...]]``
-
-
-[section:overload1 basic_signal_set::add (1 of 4 overloads)]
-
-
-Add a signal to a signal\_set. 
-
-
-  void add(
-      int signal_number);
-
-
-This function adds the specified signal to the set. It has no effect if the signal is already in the set.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be added to the set.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_signal_set::add (2 of 4 overloads)]
-
-
-Add a signal to a signal\_set. 
-
-
-  void add(
-      int signal_number,
-      asio::error_code & ec);
-
-
-This function adds the specified signal to the set. It has no effect if the signal is already in the set.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be added to the set.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_signal_set::add (3 of 4 overloads)]
-
-
-Add a signal to a signal\_set with the specified flags. 
-
-
-  void add(
-      int signal_number,
-      flags_t f);
-
-
-This function adds the specified signal to the set. It has no effect if the signal is already in the set.
-
-Flags other than `flags::dont_care` require OS support for the `sigaction` call, and this function will fail with `error::operation_not_supported` if this is unavailable.
-
-The specified flags will conflict with a prior, active registration of the same signal, if either specified a flags value other than `flags::dont_care`. In this case, the `add` will fail with `error::invalid_argument`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be added to the set.]]
-
-[[f][Flags to modify the behaviour of the specified signal.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_signal_set::add (4 of 4 overloads)]
-
-
-Add a signal to a signal\_set with the specified flags. 
-
-
-  void add(
-      int signal_number,
-      flags_t f,
-      asio::error_code & ec);
-
-
-This function adds the specified signal to the set. It has no effect if the signal is already in the set.
-
-Flags other than `flags::dont_care` require OS support for the `sigaction` call, and this function will fail with `error::operation_not_supported` if this is unavailable.
-
-The specified flags will conflict with a prior, active registration of the same signal, if either specified a flags value other than `flags::dont_care`. In this case, the `add` will fail with `error::invalid_argument`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be added to the set.]]
-
-[[f][Flags to modify the behaviour of the specified signal.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait basic_signal_set::async_wait]
-
-[indexterm2 asio.indexterm.basic_signal_set.async_wait..async_wait..basic_signal_set] 
-Start an asynchronous operation to wait for a signal to be delivered. 
-
-
-  template<
-      typename ``[link asio.reference.SignalToken SignalToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      SignalToken && token = default_completion_token_t< executor_type >());
-
-
-This function may be used to initiate an asynchronous wait against the signal set. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-For each call to `async_wait()`, the completion handler will be called exactly once. The completion handler will be called when:
-
-
-* One of the registered signals in the signal set occurs; or
-
-
-* The signal set was cancelled, in which case the handler is passed the error code `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    int signal_number // Indicates which signal occurred.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, int) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_signal_set basic_signal_set::basic_signal_set]
-
-[indexterm2 asio.indexterm.basic_signal_set.basic_signal_set..basic_signal_set..basic_signal_set] 
-Construct a signal set without adding any signals. 
-
-
-  explicit ``[link asio.reference.basic_signal_set.basic_signal_set.overload1 basic_signal_set]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_signal_set.basic_signal_set.overload2 basic_signal_set]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload2 more...]]``
-
-
-Construct a signal set and add one signal. 
-
-
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload3 basic_signal_set]``(
-      const executor_type & ex,
-      int signal_number_1);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload4 basic_signal_set]``(
-      ExecutionContext & context,
-      int signal_number_1,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload4 more...]]``
-
-
-Construct a signal set and add two signals. 
-
-
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload5 basic_signal_set]``(
-      const executor_type & ex,
-      int signal_number_1,
-      int signal_number_2);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload6 basic_signal_set]``(
-      ExecutionContext & context,
-      int signal_number_1,
-      int signal_number_2,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload6 more...]]``
-
-
-Construct a signal set and add three signals. 
-
-
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload7 basic_signal_set]``(
-      const executor_type & ex,
-      int signal_number_1,
-      int signal_number_2,
-      int signal_number_3);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_signal_set.basic_signal_set.overload8 basic_signal_set]``(
-      ExecutionContext & context,
-      int signal_number_1,
-      int signal_number_2,
-      int signal_number_3,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.basic_signal_set.overload8 more...]]``
-
-
-[section:overload1 basic_signal_set::basic_signal_set (1 of 8 overloads)]
-
-
-Construct a signal set without adding any signals. 
-
-
-  basic_signal_set(
-      const executor_type & ex);
-
-
-This constructor creates a signal set without registering for any signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_signal_set::basic_signal_set (2 of 8 overloads)]
-
-
-Construct a signal set without adding any signals. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_signal_set(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a signal set without registering for any signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_signal_set::basic_signal_set (3 of 8 overloads)]
-
-
-Construct a signal set and add one signal. 
-
-
-  basic_signal_set(
-      const executor_type & ex,
-      int signal_number_1);
-
-
-This constructor creates a signal set and registers for one signal.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(ex);
-  signals.add(signal_number_1); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_signal_set::basic_signal_set (4 of 8 overloads)]
-
-
-Construct a signal set and add one signal. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_signal_set(
-      ExecutionContext & context,
-      int signal_number_1,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a signal set and registers for one signal.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(context);
-  signals.add(signal_number_1); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_signal_set::basic_signal_set (5 of 8 overloads)]
-
-
-Construct a signal set and add two signals. 
-
-
-  basic_signal_set(
-      const executor_type & ex,
-      int signal_number_1,
-      int signal_number_2);
-
-
-This constructor creates a signal set and registers for two signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The first signal number to be added.]]
-
-[[signal_number_2][The second signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(ex);
-  signals.add(signal_number_1);
-  signals.add(signal_number_2); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_signal_set::basic_signal_set (6 of 8 overloads)]
-
-
-Construct a signal set and add two signals. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_signal_set(
-      ExecutionContext & context,
-      int signal_number_1,
-      int signal_number_2,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a signal set and registers for two signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The first signal number to be added.]]
-
-[[signal_number_2][The second signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(context);
-  signals.add(signal_number_1);
-  signals.add(signal_number_2); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_signal_set::basic_signal_set (7 of 8 overloads)]
-
-
-Construct a signal set and add three signals. 
-
-
-  basic_signal_set(
-      const executor_type & ex,
-      int signal_number_1,
-      int signal_number_2,
-      int signal_number_3);
-
-
-This constructor creates a signal set and registers for three signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The first signal number to be added.]]
-
-[[signal_number_2][The second signal number to be added.]]
-
-[[signal_number_3][The third signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(ex);
-  signals.add(signal_number_1);
-  signals.add(signal_number_2);
-  signals.add(signal_number_3); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_signal_set::basic_signal_set (8 of 8 overloads)]
-
-
-Construct a signal set and add three signals. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_signal_set(
-      ExecutionContext & context,
-      int signal_number_1,
-      int signal_number_2,
-      int signal_number_3,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a signal set and registers for three signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the signal set will use, by default, to dispatch handlers for any asynchronous operations performed on the signal set.]]
-
-[[signal_number_1][The first signal number to be added.]]
-
-[[signal_number_2][The second signal number to be added.]]
-
-[[signal_number_3][The third signal number to be added.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to performing: 
-
-  asio::signal_set signals(context);
-  signals.add(signal_number_1);
-  signals.add(signal_number_2);
-  signals.add(signal_number_3); 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_signal_set::cancel]
-
-[indexterm2 asio.indexterm.basic_signal_set.cancel..cancel..basic_signal_set] 
-Cancel all operations associated with the signal set. 
-
-
-  void ``[link asio.reference.basic_signal_set.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_signal_set.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_signal_set::cancel (1 of 2 overloads)]
-
-
-Cancel all operations associated with the signal set. 
-
-
-  void cancel();
-
-
-This function forces the completion of any pending asynchronous wait operations against the signal set. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancellation does not alter the set of registered signals.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If a registered signal occurred before `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_signal_set::cancel (2 of 2 overloads)]
-
-
-Cancel all operations associated with the signal set. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function forces the completion of any pending asynchronous wait operations against the signal set. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancellation does not alter the set of registered signals.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-If a registered signal occurred before `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:clear basic_signal_set::clear]
-
-[indexterm2 asio.indexterm.basic_signal_set.clear..clear..basic_signal_set] 
-Remove all signals from a signal\_set. 
-
-
-  void ``[link asio.reference.basic_signal_set.clear.overload1 clear]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.clear.overload1 more...]]``
-
-  void ``[link asio.reference.basic_signal_set.clear.overload2 clear]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.clear.overload2 more...]]``
-
-
-[section:overload1 basic_signal_set::clear (1 of 2 overloads)]
-
-
-Remove all signals from a signal\_set. 
-
-
-  void clear();
-
-
-This function removes all signals from the set. It has no effect if the set is already empty.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Removes all queued notifications. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_signal_set::clear (2 of 2 overloads)]
-
-
-Remove all signals from a signal\_set. 
-
-
-  void clear(
-      asio::error_code & ec);
-
-
-This function removes all signals from the set. It has no effect if the set is already empty.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Removes all queued notifications. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_signal_set::executor_type]
-
-[indexterm2 asio.indexterm.basic_signal_set.executor_type..executor_type..basic_signal_set] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:flags basic_signal_set::flags]
-
-
-['Inherited from signal_set_base.]
-
-[indexterm2 asio.indexterm.basic_signal_set.flags..flags..basic_signal_set] 
-Enumeration representing the different types of flags that may specified when adding a signal to a set. 
-
-  enum flags
-
-[indexterm2 asio.indexterm.basic_signal_set.flags.none..none..basic_signal_set]
-[indexterm2 asio.indexterm.basic_signal_set.flags.restart..restart..basic_signal_set]
-[indexterm2 asio.indexterm.basic_signal_set.flags.no_child_stop..no_child_stop..basic_signal_set]
-[indexterm2 asio.indexterm.basic_signal_set.flags.no_child_wait..no_child_wait..basic_signal_set]
-[indexterm2 asio.indexterm.basic_signal_set.flags.dont_care..dont_care..basic_signal_set]
-
-[heading Values]
-[variablelist
-
-  [
-    [none]
-    [Bitmask representing no flags. ]
-  ]
-
-  [
-    [restart]
-    [Affects the behaviour of interruptible functions such that, if the function would have failed with error::interrupted when interrupted by the specified signal, the function shall instead be restarted and not fail with error::interrupted. ]
-  ]
-
-  [
-    [no_child_stop]
-    [Do not generate SIGCHLD when child processes stop or stopped child processes continue. ]
-  ]
-
-  [
-    [no_child_wait]
-    [Do not transform child processes into zombies when they terminate. ]
-  ]
-
-  [
-    [dont_care]
-    [Special value to indicate that the signal registration does not care which flags are set, and so will not conflict with any prior registrations of the same signal. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:flags_t basic_signal_set::flags_t]
-
-
-['Inherited from signal_set_base.]
-
-[indexterm2 asio.indexterm.basic_signal_set.flags_t..flags_t..basic_signal_set] 
-Portability typedef. 
-
-
-  typedef flags flags_t;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_signal_set::get_executor]
-
-[indexterm2 asio.indexterm.basic_signal_set.get_executor..get_executor..basic_signal_set] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:remove basic_signal_set::remove]
-
-[indexterm2 asio.indexterm.basic_signal_set.remove..remove..basic_signal_set] 
-Remove a signal from a signal\_set. 
-
-
-  void ``[link asio.reference.basic_signal_set.remove.overload1 remove]``(
-      int signal_number);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.remove.overload1 more...]]``
-
-  void ``[link asio.reference.basic_signal_set.remove.overload2 remove]``(
-      int signal_number,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_signal_set.remove.overload2 more...]]``
-
-
-[section:overload1 basic_signal_set::remove (1 of 2 overloads)]
-
-
-Remove a signal from a signal\_set. 
-
-
-  void remove(
-      int signal_number);
-
-
-This function removes the specified signal from the set. It has no effect if the signal is not in the set.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be removed from the set.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Removes any notifications that have been queued for the specified signal number. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_signal_set::remove (2 of 2 overloads)]
-
-
-Remove a signal from a signal\_set. 
-
-
-  void remove(
-      int signal_number,
-      asio::error_code & ec);
-
-
-This function removes the specified signal from the set. It has no effect if the signal is not in the set.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[signal_number][The signal to be removed from the set.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Removes any notifications that have been queued for the specified signal number. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_signal_set basic_signal_set::~basic_signal_set]
-
-[indexterm2 asio.indexterm.basic_signal_set._basic_signal_set..~basic_signal_set..basic_signal_set] 
-Destroys the signal set. 
-
-
-  ~basic_signal_set();
-
-
-This function destroys the signal set, cancelling any outstanding asynchronous wait operations associated with the signal set as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_signal_set__rebind_executor basic_signal_set::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_signal_set__rebind_executor..basic_signal_set::rebind_executor]
-
-
-Rebinds the signal set type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_signal_set__rebind_executor.other [*other]]]
-    [The signal set type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_signal_set::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_signal_set__rebind_executor.other..other..basic_signal_set::rebind_executor] 
-The signal set type when rebound to the specified executor. 
-
-
-  typedef basic_signal_set< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
-    [Rebinds the signal set type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags [*flags]]]
-    [Enumeration representing the different types of flags that may specified when adding a signal to a set. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags_t [*flags_t]]]
-    [Portability typedef. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_signal_set.add [*add]]]
-    [Add a signal to a signal_set. 
-     [hr]
-     Add a signal to a signal_set with the specified flags. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.async_wait [*async_wait]]]
-    [Start an asynchronous operation to wait for a signal to be delivered. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.basic_signal_set [*basic_signal_set]] [constructor]]
-    [Construct a signal set without adding any signals. 
-     [hr]
-     Construct a signal set and add one signal. 
-     [hr]
-     Construct a signal set and add two signals. 
-     [hr]
-     Construct a signal set and add three signals. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.cancel [*cancel]]]
-    [Cancel all operations associated with the signal set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.clear [*clear]]]
-    [Remove all signals from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.remove [*remove]]]
-    [Remove a signal from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set._basic_signal_set [*~basic_signal_set]] [destructor]]
-    [Destroys the signal set. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_signal_set `basic_signal_set`] class provides the ability to perform an asynchronous wait for one or more signals to occur.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Example]
-  
-Performing an asynchronous wait: 
-
-  void handler(
-      const asio::error_code& error,
-      int signal_number)
-  {
-    if (!error)
-    {
-      // A signal occurred.
-    }
-  }
-
-  ...
-
-  // Construct a signal set registered for process termination.
-  asio::signal_set signals(my_context, SIGINT, SIGTERM);
-
-  // Start an asynchronous wait for one of the signals to occur.
-  signals.async_wait(handler);
-
-
-
-
-
-[heading Queueing of signal notifications]
-  
-
-
-If a signal is registered with a signal\_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async\_wait operation on that signal\_set will dequeue the notification. If multiple notifications are queued, subsequent async\_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
-
-If a signal number is removed from a signal\_set (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.
-
-
-[heading Multiple registration of signals]
-  
-
-
-The same signal number may be registered with different signal\_set objects. When the signal occurs, one handler is called for each signal\_set object.
-
-Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.
-
-
-[heading Signal masking on POSIX platforms]
-  
-
-
-POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using signal\_set objects are unblocked in at least one thread. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket basic_socket]
-
-[indexterm1 asio.indexterm.basic_socket..basic_socket]
-
-
-Provides socket functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_socket :
-    public socket_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_socket::assign]
-
-[indexterm2 asio.indexterm.basic_socket.assign..assign..basic_socket] 
-Assign an existing native socket to the socket. 
-
-
-  void ``[link asio.reference.basic_socket.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.assign.overload2 more...]]``
-
-
-[section:overload1 basic_socket::assign (1 of 2 overloads)]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::assign (2 of 2 overloads)]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_connect basic_socket::async_connect]
-
-[indexterm2 asio.indexterm.basic_socket.async_connect..async_connect..basic_socket] 
-Start an asynchronous connect. 
-
-
-  template<
-      typename ``[link asio.reference.ConnectToken ConnectToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      const endpoint_type & peer_endpoint,
-      ConnectToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously connect a socket to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void connect_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Connect succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_connect(endpoint, connect_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_wait basic_socket::async_wait]
-
-[indexterm2 asio.indexterm.basic_socket.async_wait..async_wait..basic_socket] 
-Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:at_mark basic_socket::at_mark]
-
-[indexterm2 asio.indexterm.basic_socket.at_mark..at_mark..basic_socket] 
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool ``[link asio.reference.basic_socket.at_mark.overload1 at_mark]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.at_mark.overload1 more...]]``
-
-  bool ``[link asio.reference.basic_socket.at_mark.overload2 at_mark]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.at_mark.overload2 more...]]``
-
-
-[section:overload1 basic_socket::at_mark (1 of 2 overloads)]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark() const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::at_mark (2 of 2 overloads)]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark(
-      asio::error_code & ec) const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:available basic_socket::available]
-
-[indexterm2 asio.indexterm.basic_socket.available..available..basic_socket] 
-Determine the number of bytes available for reading. 
-
-
-  std::size_t ``[link asio.reference.basic_socket.available.overload1 available]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.available.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_socket.available.overload2 available]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.available.overload2 more...]]``
-
-
-[section:overload1 basic_socket::available (1 of 2 overloads)]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available() const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::available (2 of 2 overloads)]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available(
-      asio::error_code & ec) const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_socket basic_socket::basic_socket]
-
-[indexterm2 asio.indexterm.basic_socket.basic_socket..basic_socket..basic_socket] 
-Construct a [link asio.reference.basic_socket `basic_socket`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_socket.basic_socket.overload1 basic_socket]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_socket.basic_socket.overload2 basic_socket]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_socket `basic_socket`]. 
-
-
-  ``[link asio.reference.basic_socket.basic_socket.overload3 basic_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket.basic_socket.overload4 basic_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload4 more...]]``
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`], opening it and binding it to the given local endpoint. 
-
-
-  ``[link asio.reference.basic_socket.basic_socket.overload5 basic_socket]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket.basic_socket.overload6 basic_socket]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`] on an existing native socket. 
-
-
-  ``[link asio.reference.basic_socket.basic_socket.overload7 basic_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket.basic_socket.overload8 basic_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket `basic_socket`] from another. 
-
-
-  ``[link asio.reference.basic_socket.basic_socket.overload9 basic_socket]``(
-      basic_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket `basic_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_socket.basic_socket.overload10 basic_socket]``(
-      basic_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.basic_socket.overload10 more...]]``
-
-
-[section:overload1 basic_socket::basic_socket (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`] without opening it. 
-
-
-  basic_socket(
-      const executor_type & ex);
-
-
-This constructor creates a socket without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::basic_socket (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a socket without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket::basic_socket (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_socket `basic_socket`]. 
-
-
-  basic_socket(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates and opens a socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_socket::basic_socket (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_socket `basic_socket`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_socket::basic_socket (5 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`], opening it and binding it to the given local endpoint. 
-
-
-  basic_socket(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-
-
-This constructor creates a socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_socket::basic_socket (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`], opening it and binding it to the given local endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_socket::basic_socket (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`] on an existing native socket. 
-
-
-  basic_socket(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-This constructor creates a socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][A native socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_socket::basic_socket (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket `basic_socket`] on an existing native socket. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][A native socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_socket::basic_socket (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket `basic_socket`] from another. 
-
-
-  basic_socket(
-      basic_socket && other);
-
-
-This constructor moves a socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket `basic_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_socket::basic_socket (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket `basic_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_socket(
-      basic_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket `basic_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_socket::bind]
-
-[indexterm2 asio.indexterm.basic_socket.bind..bind..basic_socket] 
-Bind the socket to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_socket.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.bind.overload2 more...]]``
-
-
-[section:overload1 basic_socket::bind (1 of 2 overloads)]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::bind (2 of 2 overloads)]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  asio::error_code ec;
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_socket::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.broadcast..broadcast..basic_socket] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_socket::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.bytes_readable..bytes_readable..basic_socket] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_socket::cancel]
-
-[indexterm2 asio.indexterm.basic_socket.cancel..cancel..basic_socket] 
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void ``[link asio.reference.basic_socket.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_socket::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_socket::close]
-
-[indexterm2 asio.indexterm.basic_socket.close..close..basic_socket] 
-Close the socket. 
-
-
-  void ``[link asio.reference.basic_socket.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.close.overload2 more...]]``
-
-
-[section:overload1 basic_socket::close (1 of 2 overloads)]
-
-
-Close the socket. 
-
-
-  void close();
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::close (2 of 2 overloads)]
-
-
-Close the socket. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect basic_socket::connect]
-
-[indexterm2 asio.indexterm.basic_socket.connect..connect..basic_socket] 
-Connect the socket to the specified endpoint. 
-
-
-  void ``[link asio.reference.basic_socket.connect.overload1 connect]``(
-      const endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.connect.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.connect.overload2 connect]``(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.connect.overload2 more...]]``
-
-
-[section:overload1 basic_socket::connect (1 of 2 overloads)]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.connect(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::connect (2 of 2 overloads)]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  asio::error_code ec;
-  socket.connect(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_socket::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.debug..debug..basic_socket] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_socket::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.do_not_route..do_not_route..basic_socket] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_socket::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.enable_connection_aborted..enable_connection_aborted..basic_socket] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_socket::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_socket.endpoint_type..endpoint_type..basic_socket] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_socket::executor_type]
-
-[indexterm2 asio.indexterm.basic_socket.executor_type..executor_type..basic_socket] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_socket::get_executor]
-
-[indexterm2 asio.indexterm.basic_socket.get_executor..get_executor..basic_socket] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_socket::get_option]
-
-[indexterm2 asio.indexterm.basic_socket.get_option..get_option..basic_socket] 
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_socket.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_socket.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_socket::get_option (1 of 2 overloads)]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::get_option (2 of 2 overloads)]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  asio::error_code ec;
-  socket.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_socket::io_control]
-
-[indexterm2 asio.indexterm.basic_socket.io_control..io_control..basic_socket] 
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_socket.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_socket.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_socket::io_control (1 of 2 overloads)]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::io_control (2 of 2 overloads)]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_socket::is_open]
-
-[indexterm2 asio.indexterm.basic_socket.is_open..is_open..basic_socket] 
-Determine whether the socket is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_socket::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.keep_alive..keep_alive..basic_socket] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_socket::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.linger..linger..basic_socket] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:local_endpoint basic_socket::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_socket.local_endpoint..local_endpoint..basic_socket] 
-Get the local endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_socket.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_socket.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_socket::local_endpoint (1 of 2 overloads)]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::local_endpoint (2 of 2 overloads)]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer basic_socket::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_socket.lowest_layer..lowest_layer..basic_socket] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_socket.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_socket.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_socket::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_socket::lowest_layer_type]
-
-[indexterm2 asio.indexterm.basic_socket.lowest_layer_type..lowest_layer_type..basic_socket] 
-A [link asio.reference.basic_socket `basic_socket`] is always the lowest layer. 
-
-
-  typedef basic_socket< Protocol, Executor > lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections basic_socket::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.max_connections..max_connections..basic_socket] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_socket::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.max_listen_connections..max_listen_connections..basic_socket] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_socket::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.message_do_not_route..message_do_not_route..basic_socket] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_socket::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.message_end_of_record..message_end_of_record..basic_socket] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_socket::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.message_flags..message_flags..basic_socket] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_socket::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.message_out_of_band..message_out_of_band..basic_socket] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_socket::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.message_peek..message_peek..basic_socket] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_socket::native_handle]
-
-[indexterm2 asio.indexterm.basic_socket.native_handle..native_handle..basic_socket] 
-Get the native socket representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_socket::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_socket.native_handle_type..native_handle_type..basic_socket] 
-The native representation of a socket. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_socket::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_socket.native_non_blocking..native_non_blocking..basic_socket] 
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool ``[link asio.reference.basic_socket.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void ``[link asio.reference.basic_socket.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_socket.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_socket::native_non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying socket is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::native_non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket::native_non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_socket::non_blocking]
-
-[indexterm2 asio.indexterm.basic_socket.non_blocking..non_blocking..basic_socket] 
-Gets the non-blocking mode of the socket. 
-
-
-  bool ``[link asio.reference.basic_socket.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void ``[link asio.reference.basic_socket.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_socket.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_socket::non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the socket. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket::non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_socket::open]
-
-[indexterm2 asio.indexterm.basic_socket.open..open..basic_socket] 
-Open the socket using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_socket.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.open.overload2 more...]]``
-
-
-[section:overload1 basic_socket::open (1 of 2 overloads)]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::open (2 of 2 overloads)]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  socket.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_socket::operator=]
-
-[indexterm2 asio.indexterm.basic_socket.operator_eq_..operator=..basic_socket] 
-Move-assign a [link asio.reference.basic_socket `basic_socket`] from another. 
-
-
-  basic_socket & ``[link asio.reference.basic_socket.operator_eq_.overload1 operator=]``(
-      basic_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_socket `basic_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_socket & > ``[link asio.reference.basic_socket.operator_eq_.overload2 operator=]``(
-      basic_socket< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_socket::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_socket `basic_socket`] from another. 
-
-
-  basic_socket & operator=(
-      basic_socket && other);
-
-
-This assignment operator moves a socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket `basic_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_socket `basic_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_socket & > operator=(
-      basic_socket< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves a socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket `basic_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_socket::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.out_of_band_inline..out_of_band_inline..basic_socket] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_socket::protocol_type]
-
-[indexterm2 asio.indexterm.basic_socket.protocol_type..protocol_type..basic_socket] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_buffer_size basic_socket::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.receive_buffer_size..receive_buffer_size..basic_socket] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_low_watermark basic_socket::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.receive_low_watermark..receive_low_watermark..basic_socket] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_socket::release]
-
-[indexterm2 asio.indexterm.basic_socket.release..release..basic_socket] 
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type ``[link asio.reference.basic_socket.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_socket.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.release.overload2 more...]]``
-
-
-[section:overload1 basic_socket::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:remote_endpoint basic_socket::remote_endpoint]
-
-[indexterm2 asio.indexterm.basic_socket.remote_endpoint..remote_endpoint..basic_socket] 
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_socket.remote_endpoint.overload1 remote_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.remote_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_socket.remote_endpoint.overload2 remote_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.remote_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_socket::remote_endpoint (1 of 2 overloads)]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint() const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::remote_endpoint (2 of 2 overloads)]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_socket::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.reuse_address..reuse_address..basic_socket] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_buffer_size basic_socket::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.send_buffer_size..send_buffer_size..basic_socket] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_socket::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.send_low_watermark..send_low_watermark..basic_socket] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:set_option basic_socket::set_option]
-
-[indexterm2 asio.indexterm.basic_socket.set_option..set_option..basic_socket] 
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_socket.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_socket.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_socket::set_option (1 of 2 overloads)]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::set_option (2 of 2 overloads)]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  asio::error_code ec;
-  socket.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown basic_socket::shutdown]
-
-[indexterm2 asio.indexterm.basic_socket.shutdown..shutdown..basic_socket] 
-Disable sends or receives on the socket. 
-
-
-  void ``[link asio.reference.basic_socket.shutdown.overload1 shutdown]``(
-      shutdown_type what);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.shutdown.overload2 shutdown]``(
-      shutdown_type what,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.shutdown.overload2 more...]]``
-
-
-[section:overload1 basic_socket::shutdown (1 of 2 overloads)]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::shutdown (2 of 2 overloads)]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what,
-      asio::error_code & ec);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_socket::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.shutdown_type..shutdown_type..basic_socket] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_socket.shutdown_type.shutdown_receive..shutdown_receive..basic_socket]
-[indexterm2 asio.indexterm.basic_socket.shutdown_type.shutdown_send..shutdown_send..basic_socket]
-[indexterm2 asio.indexterm.basic_socket.shutdown_type.shutdown_both..shutdown_both..basic_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_socket::wait]
-
-[indexterm2 asio.indexterm.basic_socket.wait..wait..basic_socket] 
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_socket.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket.wait.overload2 more...]]``
-
-
-[section:overload1 basic_socket::wait (1 of 2 overloads)]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.wait(asio::ip::tcp::socket::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket::wait (2 of 2 overloads)]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.wait(asio::ip::tcp::socket::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_socket::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket.wait_type..wait_type..basic_socket] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_socket.wait_type.wait_read..wait_read..basic_socket]
-[indexterm2 asio.indexterm.basic_socket.wait_type.wait_write..wait_write..basic_socket]
-[indexterm2 asio.indexterm.basic_socket.wait_type.wait_error..wait_error..basic_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_socket basic_socket::~basic_socket]
-
-[indexterm2 asio.indexterm.basic_socket._basic_socket..~basic_socket..basic_socket] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~basic_socket();
-
-
-This function destroys the socket, cancelling any outstanding asynchronous operations associated with the socket as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket__rebind_executor basic_socket::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_socket__rebind_executor..basic_socket::rebind_executor]
-
-
-Rebinds the socket type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_socket::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_socket__rebind_executor.other..other..basic_socket::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_socket< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket_acceptor basic_socket_acceptor]
-
-[indexterm1 asio.indexterm.basic_socket_acceptor..basic_socket_acceptor]
-
-
-Provides the ability to accept new connections. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_socket_acceptor :
-    public socket_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the acceptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
-    [The native representation of an acceptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.accept [*accept]]]
-    [Accept a new connection. 
-     [hr]
-     Accept a new connection and obtain the endpoint of the peer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.assign [*assign]]]
-    [Assigns an existing native acceptor to the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
-    [Start an asynchronous accept. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]] [constructor]]
-    [Construct an acceptor without opening it. 
-     [hr]
-     Construct an open acceptor. 
-     [hr]
-     Construct an acceptor opened on the given endpoint. 
-     [hr]
-     Construct a basic_socket_acceptor on an existing native acceptor. 
-     [hr]
-     Move-construct a basic_socket_acceptor from another. 
-     [hr]
-     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.bind [*bind]]]
-    [Bind the acceptor to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.close [*close]]]
-    [Close the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_option [*get_option]]]
-    [Get an option from the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.io_control [*io_control]]]
-    [Perform an IO control command on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.is_open [*is_open]]]
-    [Determine whether the acceptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.listen [*listen]]]
-    [Place the acceptor into the state where it will listen for new connections. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
-    [Get the native acceptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native acceptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native acceptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the acceptor. 
-     [hr]
-     Sets the non-blocking mode of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.open [*open]]]
-    [Open the acceptor using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_acceptor from another. 
-     [hr]
-     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.release [*release]]]
-    [Release ownership of the underlying native acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.set_option [*set_option]]]
-    [Set an option on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.wait [*wait]]]
-    [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]] [destructor]]
-    [Destroys the acceptor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `accept` operations are thread safe, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to synchronous `accept` operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-[heading Example]
-  
-Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
-  acceptor.open(endpoint.protocol());
-  acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:accept basic_socket_acceptor::accept]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.accept..accept..basic_socket_acceptor] 
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void ``[link asio.reference.basic_socket_acceptor.accept.overload1 accept]``(
-      basic_socket< Protocol1, Executor1 > & peer,
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void ``[link asio.reference.basic_socket_acceptor.accept.overload2 accept]``(
-      basic_socket< Protocol1, Executor1 > & peer,
-      asio::error_code & ec,
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload2 more...]]``
-
-
-Accept a new connection and obtain the endpoint of the peer. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void ``[link asio.reference.basic_socket_acceptor.accept.overload3 accept]``(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void ``[link asio.reference.basic_socket_acceptor.accept.overload4 accept]``(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload4 more...]]``
-
-  Protocol::socket::template rebind_executor< executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload5 accept]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload5 more...]]``
-
-  Protocol::socket::template rebind_executor< executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload6 accept]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other ``[link asio.reference.basic_socket_acceptor.accept.overload7 accept]``(
-      const Executor1 & ex,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload8 accept]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload8 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other ``[link asio.reference.basic_socket_acceptor.accept.overload9 accept]``(
-      const Executor1 & ex,
-      asio::error_code & ec,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload9 more...]]``
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload10 accept]``(
-      ExecutionContext & context,
-      asio::error_code & ec,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload10 more...]]``
-
-  Protocol::socket::template rebind_executor< executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload11 accept]``(
-      endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload11 more...]]``
-
-  Protocol::socket::template rebind_executor< executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload12 accept]``(
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload12 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other ``[link asio.reference.basic_socket_acceptor.accept.overload13 accept]``(
-      const Executor1 & ex,
-      endpoint_type & peer_endpoint,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload13 more...]]``
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload14 accept]``(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload14 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other ``[link asio.reference.basic_socket_acceptor.accept.overload15 accept]``(
-      const executor_type & ex,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload15 more...]]``
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other ``[link asio.reference.basic_socket_acceptor.accept.overload16 accept]``(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.accept.overload16 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::accept (1 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void accept(
-      basic_socket< Protocol1, Executor1 > & peer,
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(my_context);
-  acceptor.accept(socket);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::accept (2 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void accept(
-      basic_socket< Protocol1, Executor1 > & peer,
-      asio::error_code & ec,
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  acceptor.accept(socket, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_acceptor::accept (3 of 16 overloads)]
-
-
-Accept a new connection and obtain the endpoint of the peer. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void accept(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint);
-
-
-This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted.]]
-
-[[peer_endpoint][An endpoint object which will receive the endpoint of the remote peer.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint;
-  acceptor.accept(socket, endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_socket_acceptor::accept (4 of 16 overloads)]
-
-
-Accept a new connection and obtain the endpoint of the peer. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  void accept(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted.]]
-
-[[peer_endpoint][An endpoint object which will receive the endpoint of the remote peer.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint;
-  asio::error_code ec;
-  acceptor.accept(socket, endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_socket_acceptor::accept (5 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  Protocol::socket::template rebind_executor< executor_type >::other accept();
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_socket_acceptor::accept (6 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  Protocol::socket::template rebind_executor< executor_type >::other accept(
-      asio::error_code & ec);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept(ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_socket_acceptor::accept (7 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other accept(
-      const Executor1 & ex,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-]
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_socket_acceptor::accept (8 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other accept(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-]
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_socket_acceptor::accept (9 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other accept(
-      const Executor1 & ex,
-      asio::error_code & ec,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept(my_context2, ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_socket_acceptor::accept (10 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other accept(
-      ExecutionContext & context,
-      asio::error_code & ec,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(acceptor.accept(my_context2, ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 basic_socket_acceptor::accept (11 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  Protocol::socket::template rebind_executor< executor_type >::other accept(
-      endpoint_type & peer_endpoint);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-]
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(acceptor.accept(endpoint));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 basic_socket_acceptor::accept (12 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  Protocol::socket::template rebind_executor< executor_type >::other accept(
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(acceptor.accept(endpoint, ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 basic_socket_acceptor::accept (13 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other accept(
-      const Executor1 & ex,
-      endpoint_type & peer_endpoint,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-]
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(
-      acceptor.accept(my_context2, endpoint));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload14 basic_socket_acceptor::accept (14 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other accept(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-]
-
-
-[heading Return Value]
-      
-A socket object representing the newly accepted connection.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(
-      acceptor.accept(my_context2, endpoint));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload15 basic_socket_acceptor::accept (15 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  Protocol::socket::template rebind_executor< Executor1 >::other accept(
-      const executor_type & ex,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec,
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(
-      acceptor.accept(my_context2, endpoint, ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload16 basic_socket_acceptor::accept (16 of 16 overloads)]
-
-
-Accept a new connection. 
-
-
-  template<
-      typename ExecutionContext>
-  Protocol::socket::template rebind_executor< typenameExecutionContext::executor_type >::other accept(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      asio::error_code & ec,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to accept a new connection from a peer. The function call will block until a new connection has been accepted successfully or an error occurs.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, a socket object representing the newly accepted connection. On error, a socket object where `is_open()` is false.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  asio::ip::tcp::socket socket(
-      acceptor.accept(my_context2, endpoint, ec));
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:assign basic_socket_acceptor::assign]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.assign..assign..basic_socket_acceptor] 
-Assigns an existing native acceptor to the acceptor. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.assign.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::assign (1 of 2 overloads)]
-
-
-Assigns an existing native acceptor to the acceptor. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::assign (2 of 2 overloads)]
-
-
-Assigns an existing native acceptor to the acceptor. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_accept basic_socket_acceptor::async_accept]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.async_accept..async_accept..basic_socket_acceptor] 
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.AcceptToken AcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload1 async_accept]``(
-      basic_socket< Protocol1, Executor1 > & peer,
-      AcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.AcceptToken AcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload2 async_accept]``(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint,
-      AcceptToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload3 async_accept]``(
-      MoveAcceptToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload4 async_accept]``(
-      const Executor1 & ex,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload4 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload5 async_accept]``(
-      ExecutionContext & context,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload6 async_accept]``(
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload7 async_accept]``(
-      const Executor1 & ex,
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload7 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_socket_acceptor.async_accept.overload8 async_accept]``(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.async_accept.overload8 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::async_accept (1 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.AcceptToken AcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      basic_socket< Protocol1, Executor1 > & peer,
-      AcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< Protocol, Protocol1 >::value >  = 0);
-
-
-This function is used to asynchronously accept a new connection into a socket, and additionally obtain the endpoint of the remote peer. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::socket socket(my_context);
-  acceptor.async_accept(socket, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::async_accept (2 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.AcceptToken AcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      basic_socket< protocol_type, Executor1 > & peer,
-      endpoint_type & peer_endpoint,
-      AcceptToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously accept a new connection into a socket, and additionally obtain the endpoint of the remote peer. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer][The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer\_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_acceptor::async_accept (3 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      MoveAcceptToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template
-      rebind_executor<executor_type>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template
-      rebind_executor<executor_type>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  acceptor.async_accept(accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_socket_acceptor::async_accept (4 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      const Executor1 & ex,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template rebind_executor<
-      Executor1>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template rebind_executor<
-      Executor1>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  acceptor.async_accept(my_context2, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_socket_acceptor::async_accept (5 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      ExecutionContext & context,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  acceptor.async_accept(my_context2, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_socket_acceptor::async_accept (6 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template
-      rebind_executor<executor_type>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template
-      rebind_executor<executor_type>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  acceptor.async_accept(endpoint, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_socket_acceptor::async_accept (7 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      const Executor1 & ex,
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_executor< Executor1 >::value||execution::is_executor< Executor1 >::value >  = 0);
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template rebind_executor<
-      Executor1>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template rebind_executor<
-      Executor1>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  acceptor.async_accept(my_context2, endpoint, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_socket_acceptor::async_accept (8 of 8 overloads)]
-
-
-Start an asynchronous accept. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MoveAcceptToken MoveAcceptToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_accept(
-      ExecutionContext & context,
-      endpoint_type & peer_endpoint,
-      MoveAcceptToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to asynchronously accept a new connection. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-This overload requires that the Protocol template parameter satisfy the AcceptableProtocol type requirements.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][The I/O execution context object to be used for the newly accepted socket.]]
-
-[[peer_endpoint][An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer\_endpoint object is retained by the caller, which must guarantee that it is valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the accept completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    // Result of operation.
-    const asio::error_code& error,
-
-    // On success, the newly accepted socket.
-    typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other peer
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code,
-    typename Protocol::socket::template rebind_executor<
-      typename ExecutionContext::executor_type>::other)) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void accept_handler(const asio::error_code& error,
-      asio::ip::tcp::socket peer)
-  {
-    if (!error)
-    {
-      // Accept succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint;
-  acceptor.async_accept(my_context2, endpoint, accept_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait basic_socket_acceptor::async_wait]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.async_wait..async_wait..basic_socket_acceptor] 
-Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for an acceptor to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired acceptor state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  acceptor.async_wait(
-      asio::ip::tcp::acceptor::wait_read,
-      wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_socket_acceptor basic_socket_acceptor::basic_socket_acceptor]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.basic_socket_acceptor..basic_socket_acceptor..basic_socket_acceptor] 
-Construct an acceptor without opening it. 
-
-
-  explicit ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload1 basic_socket_acceptor]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload2 basic_socket_acceptor]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload2 more...]]``
-
-
-Construct an open acceptor. 
-
-
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload3 basic_socket_acceptor]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload4 basic_socket_acceptor]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload4 more...]]``
-
-
-Construct an acceptor opened on the given endpoint. 
-
-
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload5 basic_socket_acceptor]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint,
-      bool reuse_addr = true);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload6 basic_socket_acceptor]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      bool reuse_addr = true,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] on an existing native acceptor. 
-
-
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload7 basic_socket_acceptor]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload8 basic_socket_acceptor]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from another. 
-
-
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload9 basic_socket_acceptor]``(
-      basic_socket_acceptor && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from an acceptor of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload10 basic_socket_acceptor]``(
-      basic_socket_acceptor< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.basic_socket_acceptor.overload10 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::basic_socket_acceptor (1 of 10 overloads)]
-
-
-Construct an acceptor without opening it. 
-
-
-  basic_socket_acceptor(
-      const executor_type & ex);
-
-
-This constructor creates an acceptor without opening it to listen for new connections. The `open()` function must be called before the acceptor can accept new socket connections.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::basic_socket_acceptor (2 of 10 overloads)]
-
-
-Construct an acceptor without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket_acceptor(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates an acceptor without opening it to listen for new connections. The `open()` function must be called before the acceptor can accept new socket connections.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_acceptor::basic_socket_acceptor (3 of 10 overloads)]
-
-
-Construct an open acceptor. 
-
-
-  basic_socket_acceptor(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates an acceptor and automatically opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_socket_acceptor::basic_socket_acceptor (4 of 10 overloads)]
-
-
-Construct an open acceptor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket_acceptor(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates an acceptor and automatically opens it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_socket_acceptor::basic_socket_acceptor (5 of 10 overloads)]
-
-
-Construct an acceptor opened on the given endpoint. 
-
-
-  basic_socket_acceptor(
-      const executor_type & ex,
-      const endpoint_type & endpoint,
-      bool reuse_addr = true);
-
-
-This constructor creates an acceptor and automatically opens it to listen for new connections on the specified endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[endpoint][An endpoint on the local machine on which the acceptor will listen for new connections.]]
-
-[[reuse_addr][Whether the constructor should set the socket option `socket_base::reuse_address`.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to the following code: 
-
-  basic_socket_acceptor<Protocol> acceptor(my_context);
-  acceptor.open(endpoint.protocol());
-  if (reuse_addr)
-    acceptor.set_option(socket_base::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_socket_acceptor::basic_socket_acceptor (6 of 10 overloads)]
-
-
-Construct an acceptor opened on the given endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket_acceptor(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      bool reuse_addr = true,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates an acceptor and automatically opens it to listen for new connections on the specified endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[endpoint][An endpoint on the local machine on which the acceptor will listen for new connections.]]
-
-[[reuse_addr][Whether the constructor should set the socket option `socket_base::reuse_address`.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This constructor is equivalent to the following code: 
-
-  basic_socket_acceptor<Protocol> acceptor(my_context);
-  acceptor.open(endpoint.protocol());
-  if (reuse_addr)
-    acceptor.set_option(socket_base::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_socket_acceptor::basic_socket_acceptor (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] on an existing native acceptor. 
-
-
-  basic_socket_acceptor(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor);
-
-
-This constructor creates an acceptor object to hold an existing native acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_acceptor][A native acceptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_socket_acceptor::basic_socket_acceptor (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] on an existing native acceptor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_socket_acceptor(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_acceptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates an acceptor object to hold an existing native acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the acceptor will use, by default, to dispatch handlers for any asynchronous operations performed on the acceptor.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_acceptor][A native acceptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_socket_acceptor::basic_socket_acceptor (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from another. 
-
-
-  basic_socket_acceptor(
-      basic_socket_acceptor && other);
-
-
-This constructor moves an acceptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket_acceptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_socket_acceptor::basic_socket_acceptor (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from an acceptor of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_socket_acceptor(
-      basic_socket_acceptor< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves an acceptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket_acceptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_socket_acceptor::bind]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.bind..bind..basic_socket_acceptor] 
-Bind the acceptor to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.bind.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::bind (1 of 2 overloads)]
-
-
-Bind the acceptor to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket acceptor to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket acceptor will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
-  acceptor.open(endpoint.protocol());
-  acceptor.bind(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::bind (2 of 2 overloads)]
-
-
-Bind the acceptor to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket acceptor to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket acceptor will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 12345);
-  acceptor.open(endpoint.protocol());
-  asio::error_code ec;
-  acceptor.bind(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_socket_acceptor::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.broadcast..broadcast..basic_socket_acceptor] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_socket_acceptor::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.bytes_readable..bytes_readable..basic_socket_acceptor] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_socket_acceptor::cancel]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.cancel..cancel..basic_socket_acceptor] 
-Cancel all asynchronous operations associated with the acceptor. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the acceptor. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the acceptor. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_socket_acceptor::close]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.close..close..basic_socket_acceptor] 
-Close the acceptor. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.close.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::close (1 of 2 overloads)]
-
-
-Close the acceptor. 
-
-
-  void close();
-
-
-This function is used to close the acceptor. Any asynchronous accept operations will be cancelled immediately.
-
-A subsequent call to `open()` is required before the acceptor can again be used to again perform socket accept operations.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::close (2 of 2 overloads)]
-
-
-Close the acceptor. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the acceptor. Any asynchronous accept operations will be cancelled immediately.
-
-A subsequent call to `open()` is required before the acceptor can again be used to again perform socket accept operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::error_code ec;
-  acceptor.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_socket_acceptor::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.debug..debug..basic_socket_acceptor] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_socket_acceptor::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.do_not_route..do_not_route..basic_socket_acceptor] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_socket_acceptor::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.enable_connection_aborted..enable_connection_aborted..basic_socket_acceptor] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_socket_acceptor::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.endpoint_type..endpoint_type..basic_socket_acceptor] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_socket_acceptor::executor_type]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.executor_type..executor_type..basic_socket_acceptor] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_socket_acceptor::get_executor]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.get_executor..get_executor..basic_socket_acceptor] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_socket_acceptor::get_option]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.get_option..get_option..basic_socket_acceptor] 
-Get an option from the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_socket_acceptor.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_socket_acceptor.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::get_option (1 of 2 overloads)]
-
-
-Get an option from the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the acceptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_REUSEADDR option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::get_option (2 of 2 overloads)]
-
-
-Get an option from the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the acceptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_REUSEADDR option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::reuse_address option;
-  asio::error_code ec;
-  acceptor.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_socket_acceptor::io_control]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.io_control..io_control..basic_socket_acceptor] 
-Perform an IO control command on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_socket_acceptor.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_socket_acceptor.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::io_control (1 of 2 overloads)]
-
-
-Perform an IO control command on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the acceptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::non_blocking_io command(true);
-  socket.io_control(command);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::io_control (2 of 2 overloads)]
-
-
-Perform an IO control command on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the acceptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::non_blocking_io command(true);
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_socket_acceptor::is_open]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.is_open..is_open..basic_socket_acceptor] 
-Determine whether the acceptor is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_socket_acceptor::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.keep_alive..keep_alive..basic_socket_acceptor] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_socket_acceptor::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.linger..linger..basic_socket_acceptor] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:listen basic_socket_acceptor::listen]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.listen..listen..basic_socket_acceptor] 
-Place the acceptor into the state where it will listen for new connections. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.listen.overload1 listen]``(
-      int backlog = socket_base::max_listen_connections);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.listen.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.listen.overload2 listen]``(
-      int backlog,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.listen.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::listen (1 of 2 overloads)]
-
-
-Place the acceptor into the state where it will listen for new connections. 
-
-
-  void listen(
-      int backlog = socket_base::max_listen_connections);
-
-
-This function puts the socket acceptor into the state where it may accept new connections.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[backlog][The maximum length of the queue of pending connections.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::listen (2 of 2 overloads)]
-
-
-Place the acceptor into the state where it will listen for new connections. 
-
-
-  void listen(
-      int backlog,
-      asio::error_code & ec);
-
-
-This function puts the socket acceptor into the state where it may accept new connections.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[backlog][The maximum length of the queue of pending connections.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::error_code ec;
-  acceptor.listen(asio::socket_base::max_listen_connections, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:local_endpoint basic_socket_acceptor::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.local_endpoint..local_endpoint..basic_socket_acceptor] 
-Get the local endpoint of the acceptor. 
-
-
-  endpoint_type ``[link asio.reference.basic_socket_acceptor.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_socket_acceptor.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::local_endpoint (1 of 2 overloads)]
-
-
-Get the local endpoint of the acceptor. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the acceptor.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the acceptor.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::local_endpoint (2 of 2 overloads)]
-
-
-Get the local endpoint of the acceptor. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the acceptor. Returns a default-constructed endpoint object if an error occurred and the error handler did not throw an exception.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:max_connections basic_socket_acceptor::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.max_connections..max_connections..basic_socket_acceptor] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_socket_acceptor::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.max_listen_connections..max_listen_connections..basic_socket_acceptor] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_socket_acceptor::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.message_do_not_route..message_do_not_route..basic_socket_acceptor] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_socket_acceptor::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.message_end_of_record..message_end_of_record..basic_socket_acceptor] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_socket_acceptor::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.message_flags..message_flags..basic_socket_acceptor] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_socket_acceptor::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.message_out_of_band..message_out_of_band..basic_socket_acceptor] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_socket_acceptor::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.message_peek..message_peek..basic_socket_acceptor] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_socket_acceptor::native_handle]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.native_handle..native_handle..basic_socket_acceptor] 
-Get the native acceptor representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the acceptor. This is intended to allow access to native acceptor functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_socket_acceptor::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.native_handle_type..native_handle_type..basic_socket_acceptor] 
-The native representation of an acceptor. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_socket_acceptor::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.native_non_blocking..native_non_blocking..basic_socket_acceptor] 
-Gets the non-blocking mode of the native acceptor implementation. 
-
-
-  bool ``[link asio.reference.basic_socket_acceptor.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native acceptor implementation. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::native_non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the native acceptor implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native acceptor. This mode has no effect on the behaviour of the acceptor object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying acceptor is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the acceptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native acceptor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::native_non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native acceptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native acceptor. It has no effect on the behaviour of the acceptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying acceptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_acceptor::native_non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native acceptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native acceptor. It has no effect on the behaviour of the acceptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying acceptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_socket_acceptor::non_blocking]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.non_blocking..non_blocking..basic_socket_acceptor] 
-Gets the non-blocking mode of the acceptor. 
-
-
-  bool ``[link asio.reference.basic_socket_acceptor.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the acceptor. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the acceptor. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the acceptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the acceptor. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the acceptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_acceptor::non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the acceptor. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the acceptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_socket_acceptor::open]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.open..open..basic_socket_acceptor] 
-Open the acceptor using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.open.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::open (1 of 2 overloads)]
-
-
-Open the acceptor using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket acceptor so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  acceptor.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::open (2 of 2 overloads)]
-
-
-Open the acceptor using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket acceptor so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::error_code ec;
-  acceptor.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_socket_acceptor::operator=]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.operator_eq_..operator=..basic_socket_acceptor] 
-Move-assign a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from another. 
-
-
-  basic_socket_acceptor & ``[link asio.reference.basic_socket_acceptor.operator_eq_.overload1 operator=]``(
-      basic_socket_acceptor && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from an acceptor of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_socket_acceptor & > ``[link asio.reference.basic_socket_acceptor.operator_eq_.overload2 operator=]``(
-      basic_socket_acceptor< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from another. 
-
-
-  basic_socket_acceptor & operator=(
-      basic_socket_acceptor && other);
-
-
-This assignment operator moves an acceptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket_acceptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] from an acceptor of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_socket_acceptor & > operator=(
-      basic_socket_acceptor< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves an acceptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_socket_acceptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_socket_acceptor::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.out_of_band_inline..out_of_band_inline..basic_socket_acceptor] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_socket_acceptor::protocol_type]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.protocol_type..protocol_type..basic_socket_acceptor] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_buffer_size basic_socket_acceptor::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.receive_buffer_size..receive_buffer_size..basic_socket_acceptor] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_low_watermark basic_socket_acceptor::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.receive_low_watermark..receive_low_watermark..basic_socket_acceptor] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_socket_acceptor::release]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.release..release..basic_socket_acceptor] 
-Release ownership of the underlying native acceptor. 
-
-
-  native_handle_type ``[link asio.reference.basic_socket_acceptor.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_socket_acceptor.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.release.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native acceptor. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous accept operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native acceptor is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native acceptor. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous accept operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native acceptor is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_socket_acceptor::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.reuse_address..reuse_address..basic_socket_acceptor] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_buffer_size basic_socket_acceptor::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.send_buffer_size..send_buffer_size..basic_socket_acceptor] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_socket_acceptor::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.send_low_watermark..send_low_watermark..basic_socket_acceptor] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:set_option basic_socket_acceptor::set_option]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.set_option..set_option..basic_socket_acceptor] 
-Set an option on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_socket_acceptor.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_socket_acceptor.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::set_option (1 of 2 overloads)]
-
-
-Set an option on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the acceptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the SOL\_SOCKET/SO\_REUSEADDR option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::set_option (2 of 2 overloads)]
-
-
-Set an option on the acceptor. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the acceptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the acceptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the SOL\_SOCKET/SO\_REUSEADDR option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::ip::tcp::acceptor::reuse_address option(true);
-  asio::error_code ec;
-  acceptor.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_socket_acceptor::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.shutdown_type..shutdown_type..basic_socket_acceptor] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.shutdown_type.shutdown_receive..shutdown_receive..basic_socket_acceptor]
-[indexterm2 asio.indexterm.basic_socket_acceptor.shutdown_type.shutdown_send..shutdown_send..basic_socket_acceptor]
-[indexterm2 asio.indexterm.basic_socket_acceptor.shutdown_type.shutdown_both..shutdown_both..basic_socket_acceptor]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_socket_acceptor::wait]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.wait..wait..basic_socket_acceptor] 
-Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_socket_acceptor.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_socket_acceptor.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_acceptor.wait.overload2 more...]]``
-
-
-[section:overload1 basic_socket_acceptor::wait (1 of 2 overloads)]
-
-
-Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for an acceptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired acceptor state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for an acceptor to become readable. 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  acceptor.wait(asio::ip::tcp::acceptor::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_acceptor::wait (2 of 2 overloads)]
-
-
-Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for an acceptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired acceptor state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for an acceptor to become readable. 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::error_code ec;
-  acceptor.wait(asio::ip::tcp::acceptor::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_socket_acceptor::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.wait_type..wait_type..basic_socket_acceptor] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_socket_acceptor.wait_type.wait_read..wait_read..basic_socket_acceptor]
-[indexterm2 asio.indexterm.basic_socket_acceptor.wait_type.wait_write..wait_write..basic_socket_acceptor]
-[indexterm2 asio.indexterm.basic_socket_acceptor.wait_type.wait_error..wait_error..basic_socket_acceptor]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_socket_acceptor basic_socket_acceptor::~basic_socket_acceptor]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor._basic_socket_acceptor..~basic_socket_acceptor..basic_socket_acceptor] 
-Destroys the acceptor. 
-
-
-  ~basic_socket_acceptor();
-
-
-This function destroys the acceptor, cancelling any outstanding asynchronous operations associated with the acceptor as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket_acceptor__rebind_executor basic_socket_acceptor::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_socket_acceptor__rebind_executor..basic_socket_acceptor::rebind_executor]
-
-
-Rebinds the acceptor type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_socket_acceptor::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_socket_acceptor__rebind_executor.other..other..basic_socket_acceptor::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_socket_acceptor< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the acceptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
-    [The native representation of an acceptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.accept [*accept]]]
-    [Accept a new connection. 
-     [hr]
-     Accept a new connection and obtain the endpoint of the peer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.assign [*assign]]]
-    [Assigns an existing native acceptor to the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
-    [Start an asynchronous accept. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]] [constructor]]
-    [Construct an acceptor without opening it. 
-     [hr]
-     Construct an open acceptor. 
-     [hr]
-     Construct an acceptor opened on the given endpoint. 
-     [hr]
-     Construct a basic_socket_acceptor on an existing native acceptor. 
-     [hr]
-     Move-construct a basic_socket_acceptor from another. 
-     [hr]
-     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.bind [*bind]]]
-    [Bind the acceptor to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.close [*close]]]
-    [Close the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_option [*get_option]]]
-    [Get an option from the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.io_control [*io_control]]]
-    [Perform an IO control command on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.is_open [*is_open]]]
-    [Determine whether the acceptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.listen [*listen]]]
-    [Place the acceptor into the state where it will listen for new connections. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
-    [Get the native acceptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native acceptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native acceptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the acceptor. 
-     [hr]
-     Sets the non-blocking mode of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.open [*open]]]
-    [Open the acceptor using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_acceptor from another. 
-     [hr]
-     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.release [*release]]]
-    [Release ownership of the underlying native acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.set_option [*set_option]]]
-    [Set an option on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.wait [*wait]]]
-    [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]] [destructor]]
-    [Destroys the acceptor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `accept` operations are thread safe, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to synchronous `accept` operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-[heading Example]
-  
-Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
-  acceptor.open(endpoint.protocol());
-  acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_acceptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket_iostream basic_socket_iostream]
-
-[indexterm1 asio.indexterm.basic_socket_iostream..basic_socket_iostream]
-
-
-Iostream interface for a socket. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename Clock = chrono::steady_clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = wait_traits<Clock>>
-  class basic_socket_iostream :
-    public std::basic_iostream< char >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration [*duration]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration_type [*duration_type]]]
-    [(Deprecated: Use duration.) The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_point [*time_point]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_type [*time_type]]]
-    [(Deprecated: Use time_point.) The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]] [constructor]]
-    [Construct a basic_socket_iostream without establishing a connection. 
-     [hr]
-     Construct a basic_socket_iostream from the supplied socket. 
-     [hr]
-     Move-construct a basic_socket_iostream from another. 
-     [hr]
-     Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.close [*close]]]
-    [Close the connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.connect [*connect]]]
-    [Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.error [*error]]]
-    [Get the last error associated with the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_after [*expires_after]]]
-    [Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time as an absolute time. 
-     [hr]
-     Set the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expiry [*expiry]]]
-    [Get the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_iostream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
-    [Return a pointer to the underlying streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.socket [*socket]]]
-    [Get a reference to the underlying socket. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_socket_iostream basic_socket_iostream::basic_socket_iostream]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.basic_socket_iostream..basic_socket_iostream..basic_socket_iostream] 
-Construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] without establishing a connection. 
-
-
-  ``[link asio.reference.basic_socket_iostream.basic_socket_iostream.overload1 basic_socket_iostream]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.basic_socket_iostream.overload1 more...]]``
-
-
-Construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] from the supplied socket. 
-
-
-  explicit ``[link asio.reference.basic_socket_iostream.basic_socket_iostream.overload2 basic_socket_iostream]``(
-      basic_stream_socket< protocol_type > s);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.basic_socket_iostream.overload2 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] from another. 
-
-
-  ``[link asio.reference.basic_socket_iostream.basic_socket_iostream.overload3 basic_socket_iostream]``(
-      basic_socket_iostream && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.basic_socket_iostream.overload3 more...]]``
-
-
-Establish a connection to an endpoint corresponding to a resolver query. 
-
-
-  template<
-      typename... T>
-  explicit ``[link asio.reference.basic_socket_iostream.basic_socket_iostream.overload4 basic_socket_iostream]``(
-      T... x);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.basic_socket_iostream.overload4 more...]]``
-
-
-[section:overload1 basic_socket_iostream::basic_socket_iostream (1 of 4 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] without establishing a connection. 
-
-
-  basic_socket_iostream();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_iostream::basic_socket_iostream (2 of 4 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] from the supplied socket. 
-
-
-  basic_socket_iostream(
-      basic_stream_socket< protocol_type > s);
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_iostream::basic_socket_iostream (3 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] from another. 
-
-
-  basic_socket_iostream(
-      basic_socket_iostream && other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_socket_iostream::basic_socket_iostream (4 of 4 overloads)]
-
-
-Establish a connection to an endpoint corresponding to a resolver query. 
-
-
-  template<
-      typename... T>
-  basic_socket_iostream(
-      T... x);
-
-
-This constructor automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:clock_type basic_socket_iostream::clock_type]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.clock_type..clock_type..basic_socket_iostream] 
-The clock type. 
-
-
-  typedef Clock clock_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:close basic_socket_iostream::close]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.close..close..basic_socket_iostream] 
-Close the connection. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:connect basic_socket_iostream::connect]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.connect..connect..basic_socket_iostream] 
-Establish a connection to an endpoint corresponding to a resolver query. 
-
-
-  template<
-      typename... T>
-  void connect(
-      T... x);
-
-
-This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object. 
-
-
-[endsect]
-
-
-
-[section:duration basic_socket_iostream::duration]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.duration..duration..basic_socket_iostream] 
-The duration type. 
-
-
-  typedef WaitTraits::duration duration;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:duration_type basic_socket_iostream::duration_type]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.duration_type..duration_type..basic_socket_iostream] 
-(Deprecated: Use duration.) The duration type. 
-
-
-  typedef WaitTraits::duration_type duration_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_socket_iostream::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.endpoint_type..endpoint_type..basic_socket_iostream] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error basic_socket_iostream::error]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.error..error..basic_socket_iostream] 
-Get the last error associated with the stream. 
-
-
-  const asio::error_code & error() const;
-
-
-
-[heading Return Value]
-      
-An `error_code` corresponding to the last error from the stream.
-
-
-[heading Example]
-  
-To print the error associated with a failure to establish a connection: 
-
-  tcp::iostream s("www.boost.org", "http");
-  if (!s)
-  {
-    std::cout << "Error: " << s.error().message() << std::endl;
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:expires_after basic_socket_iostream::expires_after]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.expires_after..expires_after..basic_socket_iostream] 
-Set the stream's expiry time relative to now. 
-
-
-  void expires_after(
-      const duration & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:expires_at basic_socket_iostream::expires_at]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.expires_at..expires_at..basic_socket_iostream] 
-(Deprecated: Use `expiry()`.) Get the stream's expiry time as an absolute time. 
-
-
-  time_point ``[link asio.reference.basic_socket_iostream.expires_at.overload1 expires_at]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.expires_at.overload1 more...]]``
-
-
-Set the stream's expiry time as an absolute time. 
-
-
-  void ``[link asio.reference.basic_socket_iostream.expires_at.overload2 expires_at]``(
-      const time_point & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.expires_at.overload2 more...]]``
-
-
-[section:overload1 basic_socket_iostream::expires_at (1 of 2 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the stream's expiry time as an absolute time. 
-
-
-  time_point expires_at() const;
-
-
-
-[heading Return Value]
-      
-An absolute time value representing the stream's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_iostream::expires_at (2 of 2 overloads)]
-
-
-Set the stream's expiry time as an absolute time. 
-
-
-  void expires_at(
-      const time_point & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the stream. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:expires_from_now basic_socket_iostream::expires_from_now]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.expires_from_now..expires_from_now..basic_socket_iostream] 
-(Deprecated: Use `expiry()`.) Get the stream's expiry time relative to now. 
-
-
-  duration ``[link asio.reference.basic_socket_iostream.expires_from_now.overload1 expires_from_now]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.expires_from_now.overload1 more...]]``
-
-
-(Deprecated: Use `expires_after()`.) Set the stream's expiry time relative to now. 
-
-
-  void ``[link asio.reference.basic_socket_iostream.expires_from_now.overload2 expires_from_now]``(
-      const duration & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_iostream.expires_from_now.overload2 more...]]``
-
-
-[section:overload1 basic_socket_iostream::expires_from_now (1 of 2 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the stream's expiry time relative to now. 
-
-
-  duration expires_from_now() const;
-
-
-
-[heading Return Value]
-      
-A relative time value representing the stream's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_iostream::expires_from_now (2 of 2 overloads)]
-
-
-(Deprecated: Use `expires_after()`.) Set the stream's expiry time relative to now. 
-
-
-  void expires_from_now(
-      const duration & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:expiry basic_socket_iostream::expiry]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.expiry..expiry..basic_socket_iostream] 
-Get the stream's expiry time as an absolute time. 
-
-
-  time_point expiry() const;
-
-
-
-[heading Return Value]
-      
-An absolute time value representing the stream's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:operator_eq_ basic_socket_iostream::operator=]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.operator_eq_..operator=..basic_socket_iostream] 
-Move-assign a [link asio.reference.basic_socket_iostream `basic_socket_iostream`] from another. 
-
-
-  basic_socket_iostream & operator=(
-      basic_socket_iostream && other);
-
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_socket_iostream::protocol_type]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.protocol_type..protocol_type..basic_socket_iostream] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:rdbuf basic_socket_iostream::rdbuf]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.rdbuf..rdbuf..basic_socket_iostream] 
-Return a pointer to the underlying streambuf. 
-
-
-  basic_socket_streambuf< Protocol, Clock, WaitTraits > * rdbuf() const;
-
-
-
-[endsect]
-
-
-
-[section:socket basic_socket_iostream::socket]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.socket..socket..basic_socket_iostream] 
-Get a reference to the underlying socket. 
-
-
-  basic_socket< Protocol > & socket();
-
-
-
-[endsect]
-
-
-
-[section:time_point basic_socket_iostream::time_point]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.time_point..time_point..basic_socket_iostream] 
-The time type. 
-
-
-  typedef WaitTraits::time_point time_point;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:time_type basic_socket_iostream::time_type]
-
-[indexterm2 asio.indexterm.basic_socket_iostream.time_type..time_type..basic_socket_iostream] 
-(Deprecated: Use time\_point.) The time type. 
-
-
-  typedef WaitTraits::time_type time_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_iostream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_socket_streambuf basic_socket_streambuf]
-
-[indexterm1 asio.indexterm.basic_socket_streambuf..basic_socket_streambuf]
-
-
-Iostream streambuf for a socket. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename Clock = chrono::steady_clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = wait_traits<Clock>>
-  class basic_socket_streambuf :
-    public std::streambuf,
-    basic_socket< Protocol >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.duration [*duration]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.duration_type [*duration_type]]]
-    [(Deprecated: Use duration.) The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.time_point [*time_point]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_streambuf.time_type [*time_type]]]
-    [(Deprecated: Use time_point.) The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_streambuf.basic_socket_streambuf [*basic_socket_streambuf]] [constructor]]
-    [Construct a basic_socket_streambuf without establishing a connection. 
-     [hr]
-     Construct a basic_socket_streambuf from the supplied socket. 
-     [hr]
-     Move-construct a basic_socket_streambuf from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.close [*close]]]
-    [Close the connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.connect [*connect]]]
-    [Establish a connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.error [*error]]]
-    [Get the last error associated with the stream buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.expires_after [*expires_after]]]
-    [Set the stream buffer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the stream buffer's expiry time as an absolute time. 
-     [hr]
-     Set the stream buffer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the stream buffer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the stream buffer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.expiry [*expiry]]]
-    [Get the stream buffer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_streambuf from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.puberror [*puberror]]]
-    [(Deprecated: Use error().) Get the last error associated with the stream buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.socket [*socket]]]
-    [Get a reference to the underlying socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf._basic_socket_streambuf [*~basic_socket_streambuf]] [destructor]]
-    [Destructor flushes buffered data. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_streambuf.overflow [*overflow]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.setbuf [*setbuf]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.sync [*sync]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_streambuf.underflow [*underflow]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_socket_streambuf basic_socket_streambuf::basic_socket_streambuf]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.basic_socket_streambuf..basic_socket_streambuf..basic_socket_streambuf] 
-Construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] without establishing a connection. 
-
-
-  ``[link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload1 basic_socket_streambuf]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload1 more...]]``
-
-
-Construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] from the supplied socket. 
-
-
-  explicit ``[link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload2 basic_socket_streambuf]``(
-      basic_stream_socket< protocol_type > s);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload2 more...]]``
-
-
-Move-construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] from another. 
-
-
-  ``[link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload3 basic_socket_streambuf]``(
-      basic_socket_streambuf && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.basic_socket_streambuf.overload3 more...]]``
-
-
-[section:overload1 basic_socket_streambuf::basic_socket_streambuf (1 of 3 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] without establishing a connection. 
-
-
-  basic_socket_streambuf();
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_streambuf::basic_socket_streambuf (2 of 3 overloads)]
-
-
-Construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] from the supplied socket. 
-
-
-  basic_socket_streambuf(
-      basic_stream_socket< protocol_type > s);
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_socket_streambuf::basic_socket_streambuf (3 of 3 overloads)]
-
-
-Move-construct a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] from another. 
-
-
-  basic_socket_streambuf(
-      basic_socket_streambuf && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:clock_type basic_socket_streambuf::clock_type]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.clock_type..clock_type..basic_socket_streambuf] 
-The clock type. 
-
-
-  typedef Clock clock_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:close basic_socket_streambuf::close]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.close..close..basic_socket_streambuf] 
-Close the connection. 
-
-
-  basic_socket_streambuf * close();
-
-
-
-[heading Return Value]
-      
-`this` if a connection was successfully established, a null pointer otherwise. 
-
-
-
-
-[endsect]
-
-
-[section:connect basic_socket_streambuf::connect]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.connect..connect..basic_socket_streambuf] 
-Establish a connection. 
-
-
-  basic_socket_streambuf * ``[link asio.reference.basic_socket_streambuf.connect.overload1 connect]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.connect.overload1 more...]]``
-
-  template<
-      typename... T>
-  basic_socket_streambuf * ``[link asio.reference.basic_socket_streambuf.connect.overload2 connect]``(
-      T... x);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.connect.overload2 more...]]``
-
-
-[section:overload1 basic_socket_streambuf::connect (1 of 2 overloads)]
-
-
-Establish a connection. 
-
-
-  basic_socket_streambuf * connect(
-      const endpoint_type & endpoint);
-
-
-This function establishes a connection to the specified endpoint.
-
-
-[heading Return Value]
-      
-`this` if a connection was successfully established, a null pointer otherwise. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_streambuf::connect (2 of 2 overloads)]
-
-
-Establish a connection. 
-
-
-  template<
-      typename... T>
-  basic_socket_streambuf * connect(
-      T... x);
-
-
-This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object.
-
-
-[heading Return Value]
-      
-`this` if a connection was successfully established, a null pointer otherwise. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:duration basic_socket_streambuf::duration]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.duration..duration..basic_socket_streambuf] 
-The duration type. 
-
-
-  typedef WaitTraits::duration duration;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:duration_type basic_socket_streambuf::duration_type]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.duration_type..duration_type..basic_socket_streambuf] 
-(Deprecated: Use duration.) The duration type. 
-
-
-  typedef WaitTraits::duration_type duration_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_socket_streambuf::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.endpoint_type..endpoint_type..basic_socket_streambuf] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error basic_socket_streambuf::error]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.error..error..basic_socket_streambuf] 
-Get the last error associated with the stream buffer. 
-
-
-  const asio::error_code & error() const;
-
-
-
-[heading Return Value]
-      
-An `error_code` corresponding to the last error from the stream buffer. 
-
-
-
-
-[endsect]
-
-
-
-[section:expires_after basic_socket_streambuf::expires_after]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.expires_after..expires_after..basic_socket_streambuf] 
-Set the stream buffer's expiry time relative to now. 
-
-
-  void expires_after(
-      const duration & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:expires_at basic_socket_streambuf::expires_at]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.expires_at..expires_at..basic_socket_streambuf] 
-(Deprecated: Use `expiry()`.) Get the stream buffer's expiry time as an absolute time. 
-
-
-  time_point ``[link asio.reference.basic_socket_streambuf.expires_at.overload1 expires_at]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.expires_at.overload1 more...]]``
-
-
-Set the stream buffer's expiry time as an absolute time. 
-
-
-  void ``[link asio.reference.basic_socket_streambuf.expires_at.overload2 expires_at]``(
-      const time_point & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.expires_at.overload2 more...]]``
-
-
-[section:overload1 basic_socket_streambuf::expires_at (1 of 2 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the stream buffer's expiry time as an absolute time. 
-
-
-  time_point expires_at() const;
-
-
-
-[heading Return Value]
-      
-An absolute time value representing the stream buffer's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_streambuf::expires_at (2 of 2 overloads)]
-
-
-Set the stream buffer's expiry time as an absolute time. 
-
-
-  void expires_at(
-      const time_point & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the stream. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:expires_from_now basic_socket_streambuf::expires_from_now]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.expires_from_now..expires_from_now..basic_socket_streambuf] 
-(Deprecated: Use `expiry()`.) Get the stream buffer's expiry time relative to now. 
-
-
-  duration ``[link asio.reference.basic_socket_streambuf.expires_from_now.overload1 expires_from_now]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.expires_from_now.overload1 more...]]``
-
-
-(Deprecated: Use `expires_after()`.) Set the stream buffer's expiry time relative to now. 
-
-
-  void ``[link asio.reference.basic_socket_streambuf.expires_from_now.overload2 expires_from_now]``(
-      const duration & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_socket_streambuf.expires_from_now.overload2 more...]]``
-
-
-[section:overload1 basic_socket_streambuf::expires_from_now (1 of 2 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the stream buffer's expiry time relative to now. 
-
-
-  duration expires_from_now() const;
-
-
-
-[heading Return Value]
-      
-A relative time value representing the stream buffer's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_socket_streambuf::expires_from_now (2 of 2 overloads)]
-
-
-(Deprecated: Use `expires_after()`.) Set the stream buffer's expiry time relative to now. 
-
-
-  void expires_from_now(
-      const duration & expiry_time);
-
-
-This function sets the expiry time associated with the stream. Stream operations performed after this time (where the operations cannot be completed using the internal buffers) will fail with the error `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:expiry basic_socket_streambuf::expiry]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.expiry..expiry..basic_socket_streambuf] 
-Get the stream buffer's expiry time as an absolute time. 
-
-
-  time_point expiry() const;
-
-
-
-[heading Return Value]
-      
-An absolute time value representing the stream buffer's expiry time. 
-
-
-
-
-[endsect]
-
-
-
-[section:operator_eq_ basic_socket_streambuf::operator=]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.operator_eq_..operator=..basic_socket_streambuf] 
-Move-assign a [link asio.reference.basic_socket_streambuf `basic_socket_streambuf`] from another. 
-
-
-  basic_socket_streambuf & operator=(
-      basic_socket_streambuf && other);
-
-
-
-[endsect]
-
-
-
-[section:overflow basic_socket_streambuf::overflow]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.overflow..overflow..basic_socket_streambuf] 
-
-  int_type overflow(
-      int_type c);
-
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_socket_streambuf::protocol_type]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.protocol_type..protocol_type..basic_socket_streambuf] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:puberror basic_socket_streambuf::puberror]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.puberror..puberror..basic_socket_streambuf] 
-(Deprecated: Use error().) Get the last error associated with the stream buffer. 
-
-
-  const asio::error_code & puberror() const;
-
-
-
-[heading Return Value]
-      
-An `error_code` corresponding to the last error from the stream buffer. 
-
-
-
-
-[endsect]
-
-
-
-[section:setbuf basic_socket_streambuf::setbuf]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.setbuf..setbuf..basic_socket_streambuf] 
-
-  std::streambuf * setbuf(
-      char_type * s,
-      std::streamsize n);
-
-
-
-[endsect]
-
-
-
-[section:socket basic_socket_streambuf::socket]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.socket..socket..basic_socket_streambuf] 
-Get a reference to the underlying socket. 
-
-
-  basic_socket< Protocol > & socket();
-
-
-
-[endsect]
-
-
-
-[section:sync basic_socket_streambuf::sync]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.sync..sync..basic_socket_streambuf] 
-
-  int sync();
-
-
-
-[endsect]
-
-
-
-[section:time_point basic_socket_streambuf::time_point]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.time_point..time_point..basic_socket_streambuf] 
-The time type. 
-
-
-  typedef WaitTraits::time_point time_point;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:time_type basic_socket_streambuf::time_type]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.time_type..time_type..basic_socket_streambuf] 
-(Deprecated: Use time\_point.) The time type. 
-
-
-  typedef WaitTraits::time_type time_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_socket_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:underflow basic_socket_streambuf::underflow]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf.underflow..underflow..basic_socket_streambuf] 
-
-  int_type underflow();
-
-
-
-[endsect]
-
-
-
-[section:_basic_socket_streambuf basic_socket_streambuf::~basic_socket_streambuf]
-
-[indexterm2 asio.indexterm.basic_socket_streambuf._basic_socket_streambuf..~basic_socket_streambuf..basic_socket_streambuf] 
-Destructor flushes buffered data. 
-
-
-  virtual ~basic_socket_streambuf();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_stream_file basic_stream_file]
-
-[indexterm1 asio.indexterm.basic_stream_file..basic_stream_file]
-
-
-Provides stream-oriented file functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_stream_file :
-    public basic_file< Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.basic_stream_file [*basic_stream_file]] [constructor]]
-    [Construct a basic_stream_file without opening it. 
-     [hr]
-     Construct and open a basic_stream_file. 
-     [hr]
-     Construct a basic_stream_file on an existing native file. 
-     [hr]
-     Move-construct a basic_stream_file from another. 
-     [hr]
-     Move-construct a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_file from another. 
-     [hr]
-     Move-assign a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.read_some [*read_some]]]
-    [Read some data from the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.seek [*seek]]]
-    [Seek to a position in the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.write_some [*write_some]]]
-    [Write some data to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file._basic_stream_file [*~basic_stream_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_file `basic_stream_file`] class template provides asynchronous and blocking stream-oriented file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:append basic_stream_file::append]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.append..append..basic_stream_file] 
-Open the file in append mode. 
-
-
-  static const flags append = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:assign basic_stream_file::assign]
-
-[indexterm2 asio.indexterm.basic_stream_file.assign..assign..basic_stream_file] 
-Assign an existing native file to the file. 
-
-
-  void ``[link asio.reference.basic_stream_file.assign.overload1 assign]``(
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.assign.overload2 assign]``(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.assign.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Assign an existing native file to the file. 
-
-
-  void assign(
-      const native_handle_type & native_file,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some basic_stream_file::async_read_some]
-
-[indexterm2 asio.indexterm.basic_stream_file.async_read_some..async_read_some..basic_stream_file] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the stream file. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  file.async_read_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some basic_stream_file::async_write_some]
-
-[indexterm2 asio.indexterm.basic_stream_file.async_write_some..async_write_some..basic_stream_file] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the stream file. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the file. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  file.async_write_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_stream_file basic_stream_file::basic_stream_file]
-
-[indexterm2 asio.indexterm.basic_stream_file.basic_stream_file..basic_stream_file..basic_stream_file] 
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_stream_file.basic_stream_file.overload1 basic_stream_file]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_stream_file.basic_stream_file.overload2 basic_stream_file]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_stream_file `basic_stream_file`]. 
-
-
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload3 basic_stream_file]``(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload4 basic_stream_file]``(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload4 more...]]``
-
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload5 basic_stream_file]``(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload6 basic_stream_file]``(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] on an existing native file. 
-
-
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload7 basic_stream_file]``(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload8 basic_stream_file]``(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_stream_file `basic_stream_file`] from another. 
-
-
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload9 basic_stream_file]``(
-      basic_stream_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_stream_file `basic_stream_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_stream_file.basic_stream_file.overload10 basic_stream_file]``(
-      basic_stream_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.basic_stream_file.overload10 more...]]``
-
-
-[section:overload1 basic_stream_file::basic_stream_file (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] without opening it. 
-
-
-  basic_stream_file(
-      const executor_type & ex);
-
-
-This constructor initialises a file without opening it. The file needs to be opened before data can be read from or or written to it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::basic_stream_file (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_file(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a file without opening it. The file needs to be opened before data can be read from or or written to it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_file::basic_stream_file (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_file `basic_stream_file`]. 
-
-
-  basic_stream_file(
-      const executor_type & ex,
-      const char * path,
-      file_base::flags open_flags);
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_stream_file::basic_stream_file (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_file `basic_stream_file`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_file(
-      ExecutionContext & context,
-      const char * path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_stream_file::basic_stream_file (5 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_file `basic_stream_file`]. 
-
-
-  basic_stream_file(
-      const executor_type & ex,
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_stream_file::basic_stream_file (6 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_file `basic_stream_file`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_file(
-      ExecutionContext & context,
-      const std::string & path,
-      file_base::flags open_flags,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises and opens a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_stream_file::basic_stream_file (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] on an existing native file. 
-
-
-  basic_stream_file(
-      const executor_type & ex,
-      const native_handle_type & native_file);
-
-
-This constructor initialises a stream file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][The new underlying file implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_stream_file::basic_stream_file (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_file `basic_stream_file`] on an existing native file. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_file(
-      ExecutionContext & context,
-      const native_handle_type & native_file,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor initialises a stream file object to hold an existing native file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the file will use, by default, to dispatch handlers for any asynchronous operations performed on the file.]]
-
-[[native_file][The new underlying file implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_stream_file::basic_stream_file (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_stream_file `basic_stream_file`] from another. 
-
-
-  basic_stream_file(
-      basic_stream_file && other);
-
-
-This constructor moves a stream file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_file `basic_stream_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_stream_file::basic_stream_file (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_stream_file `basic_stream_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_stream_file(
-      basic_stream_file< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a stream file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_file `basic_stream_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_stream_file::cancel]
-
-[indexterm2 asio.indexterm.basic_stream_file.cancel..cancel..basic_stream_file] 
-Cancel all asynchronous operations associated with the file. 
-
-
-  void ``[link asio.reference.basic_stream_file.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Cancel all asynchronous operations associated with the file. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using the `close()` function to simultaneously cancel the outstanding operations and close the file.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_stream_file::close]
-
-[indexterm2 asio.indexterm.basic_stream_file.close..close..basic_stream_file] 
-Close the file. 
-
-
-  void ``[link asio.reference.basic_stream_file.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.close.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::close (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Close the file. 
-
-
-  void close();
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::close (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Close the file. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the file. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  ...
-  asio::error_code ec;
-  file.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:create basic_stream_file::create]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.create..create..basic_stream_file] 
-Create the file if it does not exist. 
-
-
-  static const flags create = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:exclusive basic_stream_file::exclusive]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.exclusive..exclusive..basic_stream_file] 
-Ensure a new file is created. Must be combined with `create`. 
-
-
-  static const flags exclusive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:executor_type basic_stream_file::executor_type]
-
-[indexterm2 asio.indexterm.basic_stream_file.executor_type..executor_type..basic_stream_file] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:flags basic_stream_file::flags]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.flags..flags..basic_stream_file] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_stream_file::get_executor]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_stream_file.get_executor..get_executor..basic_stream_file] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open basic_stream_file::is_open]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_stream_file.is_open..is_open..basic_stream_file] 
-Determine whether the file is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_stream_file::native_handle]
-
-
-['Inherited from basic_file.]
-
-[indexterm2 asio.indexterm.basic_stream_file.native_handle..native_handle..basic_stream_file] 
-Get the native file representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the file. This is intended to allow access to native file functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_stream_file::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_stream_file.native_handle_type..native_handle_type..basic_stream_file] 
-The native representation of a file. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:open basic_stream_file::open]
-
-[indexterm2 asio.indexterm.basic_stream_file.open..open..basic_stream_file] 
-Open the file using the specified path. 
-
-
-  void ``[link asio.reference.basic_stream_file.open.overload1 open]``(
-      const char * path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.open.overload2 open]``(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.open.overload2 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.open.overload3 open]``(
-      const std::string & path,
-      file_base::flags open_flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.open.overload3 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.open.overload4 open]``(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.open.overload4 more...]]``
-
-
-[section:overload1 basic_stream_file::open (1 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::open (2 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const char * path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_file::open (3 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  file.open("/path/to/my/file", asio::stream_file::read_only);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_stream_file::open (4 of 4 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Open the file using the specified path. 
-
-
-  void open(
-      const std::string & path,
-      file_base::flags open_flags,
-      asio::error_code & ec);
-
-
-This function opens the file so that it will use the specified path.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The path name identifying the file to be opened.]]
-
-[[open_flags][A set of flags that determine how the file should be opened.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::stream_file file(my_context);
-  asio::error_code ec;
-  file.open("/path/to/my/file", asio::stream_file::read_only, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_stream_file::operator=]
-
-[indexterm2 asio.indexterm.basic_stream_file.operator_eq_..operator=..basic_stream_file] 
-Move-assign a [link asio.reference.basic_stream_file `basic_stream_file`] from another. 
-
-
-  basic_stream_file & ``[link asio.reference.basic_stream_file.operator_eq_.overload1 operator=]``(
-      basic_stream_file && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_stream_file `basic_stream_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_file & > ``[link asio.reference.basic_stream_file.operator_eq_.overload2 operator=]``(
-      basic_stream_file< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_stream_file `basic_stream_file`] from another. 
-
-
-  basic_stream_file & operator=(
-      basic_stream_file && other);
-
-
-This assignment operator moves a stream file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_file `basic_stream_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_stream_file `basic_stream_file`] from a file of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_file & > operator=(
-      basic_stream_file< Executor1 > && other);
-
-
-This assignment operator moves a stream file from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_file `basic_stream_file`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_file(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:read_only basic_stream_file::read_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.read_only..read_only..basic_stream_file] 
-Open the file for reading. 
-
-
-  static const flags read_only = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:read_some basic_stream_file::read_some]
-
-[indexterm2 asio.indexterm.basic_stream_file.read_some..read_some..basic_stream_file] 
-Read some data from the file. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_file.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_file.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.read_some.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::read_some (1 of 2 overloads)]
-
-
-Read some data from the file. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the stream file. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the end of the file was reached.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  file.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::read_some (2 of 2 overloads)]
-
-
-Read some data from the file. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the stream file. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:read_write basic_stream_file::read_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.read_write..read_write..basic_stream_file] 
-Open the file for reading and writing. 
-
-
-  static const flags read_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:release basic_stream_file::release]
-
-[indexterm2 asio.indexterm.basic_stream_file.release..release..basic_stream_file] 
-Release ownership of the underlying native file. 
-
-
-  native_handle_type ``[link asio.reference.basic_stream_file.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_stream_file.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.release.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::release (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::release (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Release ownership of the underlying native file. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read and write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native file is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:resize basic_stream_file::resize]
-
-[indexterm2 asio.indexterm.basic_stream_file.resize..resize..basic_stream_file] 
-Alter the size of the file. 
-
-
-  void ``[link asio.reference.basic_stream_file.resize.overload1 resize]``(
-      uint64_t n);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.resize.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.resize.overload2 resize]``(
-      uint64_t n,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.resize.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::resize (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::resize (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Alter the size of the file. 
-
-
-  void resize(
-      uint64_t n,
-      asio::error_code & ec);
-
-
-This function resizes the file to the specified size, in bytes. If the current file size exceeds `n` then any extra data is discarded. If the current size is less than `n` then the file is extended and filled with zeroes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The new size for the file.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:seek basic_stream_file::seek]
-
-[indexterm2 asio.indexterm.basic_stream_file.seek..seek..basic_stream_file] 
-Seek to a position in the file. 
-
-
-  uint64_t ``[link asio.reference.basic_stream_file.seek.overload1 seek]``(
-      int64_t offset,
-      file_base::seek_basis whence);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.seek.overload1 more...]]``
-
-  uint64_t ``[link asio.reference.basic_stream_file.seek.overload2 seek]``(
-      int64_t offset,
-      file_base::seek_basis whence,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.seek.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::seek (1 of 2 overloads)]
-
-
-Seek to a position in the file. 
-
-
-  uint64_t seek(
-      int64_t offset,
-      file_base::seek_basis whence);
-
-
-This function updates the current position in the file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The requested position in the file, relative to `whence`.]]
-
-[[whence][One of `seek_set`, `seek_cur` or `seek_end`.]]
-
-]
-
-
-[heading Return Value]
-      
-The new position relative to the beginning of the file.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::seek (2 of 2 overloads)]
-
-
-Seek to a position in the file. 
-
-
-  uint64_t seek(
-      int64_t offset,
-      file_base::seek_basis whence,
-      asio::error_code & ec);
-
-
-This function updates the current position in the file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The requested position in the file, relative to `whence`.]]
-
-[[whence][One of `seek_set`, `seek_cur` or `seek_end`.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The new position relative to the beginning of the file. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:seek_basis basic_stream_file::seek_basis]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.seek_basis..seek_basis..basic_stream_file] 
-Basis for seeking in a file. 
-
-  enum seek_basis
-
-[indexterm2 asio.indexterm.basic_stream_file.seek_basis.seek_set..seek_set..basic_stream_file]
-[indexterm2 asio.indexterm.basic_stream_file.seek_basis.seek_cur..seek_cur..basic_stream_file]
-[indexterm2 asio.indexterm.basic_stream_file.seek_basis.seek_end..seek_end..basic_stream_file]
-
-[heading Values]
-[variablelist
-
-  [
-    [seek_set]
-    [Seek to an absolute position. ]
-  ]
-
-  [
-    [seek_cur]
-    [Seek to an offset relative to the current file position. ]
-  ]
-
-  [
-    [seek_end]
-    [Seek to an offset relative to the end of the file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:size basic_stream_file::size]
-
-[indexterm2 asio.indexterm.basic_stream_file.size..size..basic_stream_file] 
-Get the size of the file. 
-
-
-  uint64_t ``[link asio.reference.basic_stream_file.size.overload1 size]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.size.overload1 more...]]``
-
-  uint64_t ``[link asio.reference.basic_stream_file.size.overload2 size]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.size.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::size (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Get the size of the file. 
-
-
-  uint64_t size() const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::size (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Get the size of the file. 
-
-
-  uint64_t size(
-      asio::error_code & ec) const;
-
-
-This function determines the size of the file, in bytes.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:sync_all basic_stream_file::sync_all]
-
-[indexterm2 asio.indexterm.basic_stream_file.sync_all..sync_all..basic_stream_file] 
-Synchronise the file to disk. 
-
-
-  void ``[link asio.reference.basic_stream_file.sync_all.overload1 sync_all]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.sync_all.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.sync_all.overload2 sync_all]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.sync_all.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::sync_all (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all();
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::sync_all (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file to disk. 
-
-
-  void sync_all(
-      asio::error_code & ec);
-
-
-This function synchronises the file data and metadata to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:sync_all_on_write basic_stream_file::sync_all_on_write]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.sync_all_on_write..sync_all_on_write..basic_stream_file] 
-Open the file so that write operations automatically synchronise the file data and metadata to disk. 
-
-
-  static const flags sync_all_on_write = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:sync_data basic_stream_file::sync_data]
-
-[indexterm2 asio.indexterm.basic_stream_file.sync_data..sync_data..basic_stream_file] 
-Synchronise the file data to disk. 
-
-
-  void ``[link asio.reference.basic_stream_file.sync_data.overload1 sync_data]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.sync_data.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_file.sync_data.overload2 sync_data]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.sync_data.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::sync_data (1 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data();
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::sync_data (2 of 2 overloads)]
-
-
-['Inherited from basic_file.]
-
-
-Synchronise the file data to disk. 
-
-
-  void sync_data(
-      asio::error_code & ec);
-
-
-This function synchronises the file data to disk. Note that the semantics of this synchronisation vary between operation systems.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:truncate basic_stream_file::truncate]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.truncate..truncate..basic_stream_file] 
-Open the file with any existing contents truncated. 
-
-
-  static const flags truncate = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:write_only basic_stream_file::write_only]
-
-
-['Inherited from file_base.]
-
-[indexterm2 asio.indexterm.basic_stream_file.write_only..write_only..basic_stream_file] 
-Open the file for writing. 
-
-
-  static const flags write_only = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:write_some basic_stream_file::write_some]
-
-[indexterm2 asio.indexterm.basic_stream_file.write_some..write_some..basic_stream_file] 
-Write some data to the file. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_file.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_file.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_file.write_some.overload2 more...]]``
-
-
-[section:overload1 basic_stream_file::write_some (1 of 2 overloads)]
-
-
-Write some data to the file. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the stream file. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the file.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the end of the file was reached.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  file.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_file::write_some (2 of 2 overloads)]
-
-
-Write some data to the file. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the stream file. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the file.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_stream_file basic_stream_file::~basic_stream_file]
-
-[indexterm2 asio.indexterm.basic_stream_file._basic_stream_file..~basic_stream_file..basic_stream_file] 
-Destroys the file. 
-
-
-  ~basic_stream_file();
-
-
-This function destroys the file, cancelling any outstanding asynchronous operations associated with the file as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_stream_file__rebind_executor basic_stream_file::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_stream_file__rebind_executor..basic_stream_file::rebind_executor]
-
-
-Rebinds the file type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_file__rebind_executor.other [*other]]]
-    [The file type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_stream_file::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_stream_file__rebind_executor.other..other..basic_stream_file::rebind_executor] 
-The file type when rebound to the specified executor. 
-
-
-  typedef basic_stream_file< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.basic_stream_file [*basic_stream_file]] [constructor]]
-    [Construct a basic_stream_file without opening it. 
-     [hr]
-     Construct and open a basic_stream_file. 
-     [hr]
-     Construct a basic_stream_file on an existing native file. 
-     [hr]
-     Move-construct a basic_stream_file from another. 
-     [hr]
-     Move-construct a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_file from another. 
-     [hr]
-     Move-assign a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.read_some [*read_some]]]
-    [Read some data from the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.seek [*seek]]]
-    [Seek to a position in the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.write_some [*write_some]]]
-    [Write some data to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file._basic_stream_file [*~basic_stream_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_file `basic_stream_file`] class template provides asynchronous and blocking stream-oriented file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_stream_socket basic_stream_socket]
-
-[indexterm1 asio.indexterm.basic_stream_socket..basic_stream_socket]
-
-
-Provides stream-oriented socket functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_stream_socket :
-    public basic_socket< Protocol, Executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]] [constructor]]
-    [Construct a basic_stream_socket without opening it. 
-     [hr]
-     Construct and open a basic_stream_socket. 
-     [hr]
-     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_stream_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_stream_socket from another. 
-     [hr]
-     Move-construct a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_socket from another. 
-     [hr]
-     Move-assign a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.read_some [*read_some]]]
-    [Read some data from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.write_some [*write_some]]]
-    [Write some data to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket._basic_stream_socket [*~basic_stream_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_socket `basic_stream_socket`] class template provides asynchronous and blocking stream-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_stream_socket::assign]
-
-[indexterm2 asio.indexterm.basic_stream_socket.assign..assign..basic_stream_socket] 
-Assign an existing native socket to the socket. 
-
-
-  void ``[link asio.reference.basic_stream_socket.assign.overload1 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.assign.overload2 assign]``(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.assign.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::assign (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::assign (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Assign an existing native socket to the socket. 
-
-
-  void assign(
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_connect basic_stream_socket::async_connect]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_connect..async_connect..basic_stream_socket] 
-Start an asynchronous connect. 
-
-
-  template<
-      typename ``[link asio.reference.ConnectToken ConnectToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_connect(
-      const endpoint_type & peer_endpoint,
-      ConnectToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously connect a socket to the specified remote endpoint. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the connect completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void connect_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Connect succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.async_connect(endpoint, connect_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_read_some basic_stream_socket::async_read_some]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_read_some..async_read_some..basic_stream_socket] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the stream socket. socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_read_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:async_receive basic_stream_socket::async_receive]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_receive..async_receive..basic_stream_socket] 
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_stream_socket.async_receive.overload1 async_receive]``(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.async_receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_stream_socket.async_receive.overload2 async_receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.async_receive.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::async_receive (1 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the stream socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is received before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::async_receive (2 of 2 overloads)]
-
-
-Start an asynchronous receive. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously receive data from the stream socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the receive completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes received.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is received before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_receive(asio::buffer(data, size), 0, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:async_send basic_stream_socket::async_send]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_send..async_send..basic_stream_socket] 
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_stream_socket.async_send.overload1 async_send]``(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.async_send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.basic_stream_socket.async_send.overload2 async_send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.async_send.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::async_send (1 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the stream socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_send(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::async_send (2 of 2 overloads)]
-
-
-Start an asynchronous send. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously send data on the stream socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the send completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes sent.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_send(asio::buffer(data, size), 0, handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait basic_stream_socket::async_wait]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_wait..async_wait..basic_stream_socket] 
-Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a socket to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.async_wait(asio::ip::tcp::socket::wait_read, wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some basic_stream_socket::async_write_some]
-
-[indexterm2 asio.indexterm.basic_stream_socket.async_write_some..async_write_some..basic_stream_socket] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the stream socket. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the socket. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.async_write_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-On POSIX or Windows operating systems, this asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:at_mark basic_stream_socket::at_mark]
-
-[indexterm2 asio.indexterm.basic_stream_socket.at_mark..at_mark..basic_stream_socket] 
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool ``[link asio.reference.basic_stream_socket.at_mark.overload1 at_mark]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.at_mark.overload1 more...]]``
-
-  bool ``[link asio.reference.basic_stream_socket.at_mark.overload2 at_mark]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.at_mark.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::at_mark (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark() const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::at_mark (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine whether the socket is at the out-of-band data mark. 
-
-
-  bool at_mark(
-      asio::error_code & ec) const;
-
-
-This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A bool indicating whether the socket is at the out-of-band data mark. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:available basic_stream_socket::available]
-
-[indexterm2 asio.indexterm.basic_stream_socket.available..available..basic_stream_socket] 
-Determine the number of bytes available for reading. 
-
-
-  std::size_t ``[link asio.reference.basic_stream_socket.available.overload1 available]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.available.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.basic_stream_socket.available.overload2 available]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.available.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::available (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available() const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::available (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Determine the number of bytes available for reading. 
-
-
-  std::size_t available(
-      asio::error_code & ec) const;
-
-
-This function is used to determine the number of bytes that may be read without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes that may be read without blocking, or 0 if an error occurs. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_stream_socket basic_stream_socket::basic_stream_socket]
-
-[indexterm2 asio.indexterm.basic_stream_socket.basic_stream_socket..basic_stream_socket..basic_stream_socket] 
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload1 basic_stream_socket]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload2 basic_stream_socket]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload2 more...]]``
-
-
-Construct and open a [link asio.reference.basic_stream_socket `basic_stream_socket`]. 
-
-
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload3 basic_stream_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload4 basic_stream_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload4 more...]]``
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`], opening it and binding it to the given local endpoint. 
-
-
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload5 basic_stream_socket]``(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload6 basic_stream_socket]``(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload6 more...]]``
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] on an existing native socket. 
-
-
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload7 basic_stream_socket]``(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload7 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload8 basic_stream_socket]``(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload8 more...]]``
-
-
-Move-construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] from another. 
-
-
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload9 basic_stream_socket]``(
-      basic_stream_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload9 more...]]``
-
-
-Move-construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_stream_socket.basic_stream_socket.overload10 basic_stream_socket]``(
-      basic_stream_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.basic_stream_socket.overload10 more...]]``
-
-
-[section:overload1 basic_stream_socket::basic_stream_socket (1 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] without opening it. 
-
-
-  basic_stream_socket(
-      const executor_type & ex);
-
-
-This constructor creates a stream socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::basic_stream_socket (2 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_socket(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a stream socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_socket::basic_stream_socket (3 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_socket `basic_stream_socket`]. 
-
-
-  basic_stream_socket(
-      const executor_type & ex,
-      const protocol_type & protocol);
-
-
-This constructor creates and opens a stream socket. The socket needs to be connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_stream_socket::basic_stream_socket (4 of 10 overloads)]
-
-
-Construct and open a [link asio.reference.basic_stream_socket `basic_stream_socket`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a stream socket. The socket needs to be connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_stream_socket::basic_stream_socket (5 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`], opening it and binding it to the given local endpoint. 
-
-
-  basic_stream_socket(
-      const executor_type & ex,
-      const endpoint_type & endpoint);
-
-
-This constructor creates a stream socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the stream socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_stream_socket::basic_stream_socket (6 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`], opening it and binding it to the given local endpoint. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_socket(
-      ExecutionContext & context,
-      const endpoint_type & endpoint,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a stream socket and automatically opens it bound to the specified endpoint on the local machine. The protocol used is the protocol associated with the given endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[endpoint][An endpoint on the local machine to which the stream socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_stream_socket::basic_stream_socket (7 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] on an existing native socket. 
-
-
-  basic_stream_socket(
-      const executor_type & ex,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket);
-
-
-This constructor creates a stream socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_stream_socket::basic_stream_socket (8 of 10 overloads)]
-
-
-Construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] on an existing native socket. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_socket(
-      ExecutionContext & context,
-      const protocol_type & protocol,
-      const native_handle_type & native_socket,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a stream socket object to hold an existing native socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the socket will use, by default, to dispatch handlers for any asynchronous operations performed on the socket.]]
-
-[[protocol][An object specifying protocol parameters to be used.]]
-
-[[native_socket][The new underlying socket implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 basic_stream_socket::basic_stream_socket (9 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] from another. 
-
-
-  basic_stream_socket(
-      basic_stream_socket && other);
-
-
-This constructor moves a stream socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_socket `basic_stream_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 basic_stream_socket::basic_stream_socket (10 of 10 overloads)]
-
-
-Move-construct a [link asio.reference.basic_stream_socket `basic_stream_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_stream_socket(
-      basic_stream_socket< Protocol1, Executor1 > && other,
-      constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a stream socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_socket `basic_stream_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind basic_stream_socket::bind]
-
-[indexterm2 asio.indexterm.basic_stream_socket.bind..bind..basic_stream_socket] 
-Bind the socket to the given local endpoint. 
-
-
-  void ``[link asio.reference.basic_stream_socket.bind.overload1 bind]``(
-      const endpoint_type & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.bind.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.bind.overload2 bind]``(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.bind.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::bind (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345));
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::bind (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Bind the socket to the given local endpoint. 
-
-
-  void bind(
-      const endpoint_type & endpoint,
-      asio::error_code & ec);
-
-
-This function binds the socket to the specified endpoint on the local machine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[endpoint][An endpoint on the local machine to which the socket will be bound.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-  asio::error_code ec;
-  socket.bind(asio::ip::tcp::endpoint(
-        asio::ip::tcp::v4(), 12345), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:broadcast basic_stream_socket::broadcast]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.broadcast..broadcast..basic_stream_socket] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable basic_stream_socket::bytes_readable]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.bytes_readable..bytes_readable..basic_stream_socket] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel basic_stream_socket::cancel]
-
-[indexterm2 asio.indexterm.basic_stream_socket.cancel..cancel..basic_stream_socket] 
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void ``[link asio.reference.basic_stream_socket.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::cancel (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::cancel (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Cancel all asynchronous operations associated with the socket. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls to `cancel()` will always fail with `asio::error::operation_not_supported` when run on Windows XP, Windows Server 2003, and earlier versions of Windows, unless ASIO\_ENABLE\_CANCELIO is defined. However, the CancelIo function has two issues that should be considered before enabling its use:
-
-
-* It will only cancel asynchronous operations that were initiated in the current thread.
-
-
-* It can appear to complete without error, but the request to cancel the unfinished operations may be silently ignored by the operating system. Whether it works or not seems to depend on the drivers that are installed.
-
-For portable cancellation, consider using one of the following alternatives:
-
-
-* Disable asio's I/O completion port backend by defining ASIO\_DISABLE\_IOCP.
-
-
-* Use the `close()` function to simultaneously cancel the outstanding operations and close the socket.
-
-When running on Windows Vista, Windows Server 2008, and later, the CancelIoEx function is always used. This function does not have the problems described above. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_stream_socket::close]
-
-[indexterm2 asio.indexterm.basic_stream_socket.close..close..basic_stream_socket] 
-Close the socket. 
-
-
-  void ``[link asio.reference.basic_stream_socket.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.close.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::close (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close();
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::close (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Close the socket. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the socket. Any asynchronous send, receive or connect operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.close(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-[heading Remarks]
-      
-For portable behaviour with respect to graceful closure of a connected socket, call `shutdown()` before closing the socket. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect basic_stream_socket::connect]
-
-[indexterm2 asio.indexterm.basic_stream_socket.connect..connect..basic_stream_socket] 
-Connect the socket to the specified endpoint. 
-
-
-  void ``[link asio.reference.basic_stream_socket.connect.overload1 connect]``(
-      const endpoint_type & peer_endpoint);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.connect.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.connect.overload2 connect]``(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.connect.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::connect (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  socket.connect(endpoint);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::connect (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Connect the socket to the specified endpoint. 
-
-
-  void connect(
-      const endpoint_type & peer_endpoint,
-      asio::error_code & ec);
-
-
-This function is used to connect a socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs.
-
-The socket is automatically opened if it is not already open. If the connect fails, and the socket was automatically opened, the socket is not returned to the closed state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[peer_endpoint][The remote endpoint to which the socket will be connected.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::ip::tcp::endpoint endpoint(
-      asio::ip::address::from_string("1.2.3.4"), 12345);
-  asio::error_code ec;
-  socket.connect(endpoint, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:debug basic_stream_socket::debug]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.debug..debug..basic_stream_socket] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route basic_stream_socket::do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.do_not_route..do_not_route..basic_stream_socket] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted basic_stream_socket::enable_connection_aborted]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.enable_connection_aborted..enable_connection_aborted..basic_stream_socket] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint_type basic_stream_socket::endpoint_type]
-
-[indexterm2 asio.indexterm.basic_stream_socket.endpoint_type..endpoint_type..basic_stream_socket] 
-The endpoint type. 
-
-
-  typedef Protocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_stream_socket::executor_type]
-
-[indexterm2 asio.indexterm.basic_stream_socket.executor_type..executor_type..basic_stream_socket] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_stream_socket::get_executor]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.get_executor..get_executor..basic_stream_socket] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:get_option basic_stream_socket::get_option]
-
-[indexterm2 asio.indexterm.basic_stream_socket.get_option..get_option..basic_stream_socket] 
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_stream_socket.get_option.overload1 get_option]``(
-      GettableSocketOption & option) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.get_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void ``[link asio.reference.basic_stream_socket.get_option.overload2 get_option]``(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.get_option.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::get_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::get_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get an option from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.GettableSocketOption GettableSocketOption]``>
-  void get_option(
-      GettableSocketOption & option,
-      asio::error_code & ec) const;
-
-
-This function is used to get the current value of an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The option value to be obtained from the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the value of the SOL\_SOCKET/SO\_KEEPALIVE option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::keep_alive option;
-  asio::error_code ec;
-  socket.get_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:io_control basic_stream_socket::io_control]
-
-[indexterm2 asio.indexterm.basic_stream_socket.io_control..io_control..basic_stream_socket] 
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_stream_socket.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.basic_stream_socket.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.io_control.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::io_control (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::io_control (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Perform an IO control command on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::socket::bytes_readable command;
-  asio::error_code ec;
-  socket.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open basic_stream_socket::is_open]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.is_open..is_open..basic_stream_socket] 
-Determine whether the socket is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:keep_alive basic_stream_socket::keep_alive]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.keep_alive..keep_alive..basic_stream_socket] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger basic_stream_socket::linger]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.linger..linger..basic_stream_socket] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:local_endpoint basic_stream_socket::local_endpoint]
-
-[indexterm2 asio.indexterm.basic_stream_socket.local_endpoint..local_endpoint..basic_stream_socket] 
-Get the local endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_stream_socket.local_endpoint.overload1 local_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.local_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_stream_socket.local_endpoint.overload2 local_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.local_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::local_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint() const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::local_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the local endpoint of the socket. 
-
-
-  endpoint_type local_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the locally bound endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer basic_stream_socket::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_stream_socket.lowest_layer..lowest_layer..basic_stream_socket] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_stream_socket.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_stream_socket.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_socket `basic_socket`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_stream_socket::lowest_layer_type]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.lowest_layer_type..lowest_layer_type..basic_stream_socket] 
-A [link asio.reference.basic_socket `basic_socket`] is always the lowest layer. 
-
-
-  typedef basic_socket< Protocol, Executor > lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.basic_socket [*basic_socket]] [constructor]]
-    [Construct a basic_socket without opening it. 
-     [hr]
-     Construct and open a basic_socket. 
-     [hr]
-     Construct a basic_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_socket from another. 
-     [hr]
-     Move-construct a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket from another. 
-     [hr]
-     Move-assign a basic_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket._basic_socket [*~basic_socket]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket `basic_socket`] class template provides functionality that is common to both stream-oriented and datagram-oriented sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections basic_stream_socket::max_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.max_connections..max_connections..basic_stream_socket] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections basic_stream_socket::max_listen_connections]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.max_listen_connections..max_listen_connections..basic_stream_socket] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route basic_stream_socket::message_do_not_route]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.message_do_not_route..message_do_not_route..basic_stream_socket] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record basic_stream_socket::message_end_of_record]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.message_end_of_record..message_end_of_record..basic_stream_socket] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags basic_stream_socket::message_flags]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.message_flags..message_flags..basic_stream_socket] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band basic_stream_socket::message_out_of_band]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.message_out_of_band..message_out_of_band..basic_stream_socket] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek basic_stream_socket::message_peek]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.message_peek..message_peek..basic_stream_socket] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:native_handle basic_stream_socket::native_handle]
-
-
-['Inherited from basic_socket.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.native_handle..native_handle..basic_stream_socket] 
-Get the native socket representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the socket. This is intended to allow access to native socket functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_stream_socket::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_stream_socket.native_handle_type..native_handle_type..basic_stream_socket] 
-The native representation of a socket. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking basic_stream_socket::native_non_blocking]
-
-[indexterm2 asio.indexterm.basic_stream_socket.native_non_blocking..native_non_blocking..basic_stream_socket] 
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool ``[link asio.reference.basic_stream_socket.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void ``[link asio.reference.basic_stream_socket.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_stream_socket::native_non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the native socket implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying socket is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::native_non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_socket::native_non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the native socket implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying socket is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense.]]
-
-]
-
-
-[heading Example]
-  
-This function is intended to allow the encapsulation of arbitrary non-blocking system calls as asynchronous operations, in a way that is transparent to the user of the socket object. The following example illustrates how Linux's `sendfile` system call might be encapsulated: 
-
-  template <typename Handler>
-  struct sendfile_op
-  {
-    tcp::socket& sock_;
-    int fd_;
-    Handler handler_;
-    off_t offset_;
-    std::size_t total_bytes_transferred_;
-
-    // Function call operator meeting WriteHandler requirements.
-    // Used as the handler for the async_write_some operation.
-    void operator()(asio::error_code ec, std::size_t)
-    {
-      // Put the underlying socket into non-blocking mode.
-      if (!ec)
-        if (!sock_.native_non_blocking())
-          sock_.native_non_blocking(true, ec);
-
-      if (!ec)
-      {
-        for (;;)
-        {
-          // Try the system call.
-          errno = 0;
-          int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-          ec = asio::error_code(n < 0 ? errno : 0,
-              asio::error::get_system_category());
-          total_bytes_transferred_ += ec ? 0 : n;
-
-          // Retry operation immediately if interrupted by signal.
-          if (ec == asio::error::interrupted)
-            continue;
-
-          // Check if we need to run the operation again.
-          if (ec == asio::error::would_block
-              || ec == asio::error::try_again)
-          {
-            // We have to wait for the socket to become ready again.
-            sock_.async_wait(tcp::socket::wait_write, *this);
-            return;
-          }
-
-          if (ec || n == 0)
-          {
-            // An error occurred, or we have reached the end of the file.
-            // Either way we must exit the loop so we can call the handler.
-            break;
-          }
-
-          // Loop around to try calling sendfile again.
-        }
-      }
-
-      // Pass result back to user's handler.
-      handler_(ec, total_bytes_transferred_);
-    }
-  };
-
-  template <typename Handler>
-  void async_sendfile(tcp::socket& sock, int fd, Handler h)
-  {
-    sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-    sock.async_wait(tcp::socket::wait_write, op);
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking basic_stream_socket::non_blocking]
-
-[indexterm2 asio.indexterm.basic_stream_socket.non_blocking..non_blocking..basic_stream_socket] 
-Gets the non-blocking mode of the socket. 
-
-
-  bool ``[link asio.reference.basic_stream_socket.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void ``[link asio.reference.basic_stream_socket.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.non_blocking.overload3 more...]]``
-
-
-[section:overload1 basic_stream_socket::non_blocking (1 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Gets the non-blocking mode of the socket. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::non_blocking (2 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_socket::non_blocking (3 of 3 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Sets the non-blocking mode of the socket. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the socket's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:open basic_stream_socket::open]
-
-[indexterm2 asio.indexterm.basic_stream_socket.open..open..basic_stream_socket] 
-Open the socket using the specified protocol. 
-
-
-  void ``[link asio.reference.basic_stream_socket.open.overload1 open]``(
-      const protocol_type & protocol = protocol_type());
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.open.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.open.overload2 open]``(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.open.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::open (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol = protocol_type());
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying protocol parameters to be used.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  socket.open(asio::ip::tcp::v4());
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::open (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Open the socket using the specified protocol. 
-
-
-  void open(
-      const protocol_type & protocol,
-      asio::error_code & ec);
-
-
-This function opens the socket so that it will use the specified protocol.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][An object specifying which protocol is to be used.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  asio::error_code ec;
-  socket.open(asio::ip::tcp::v4(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ basic_stream_socket::operator=]
-
-[indexterm2 asio.indexterm.basic_stream_socket.operator_eq_..operator=..basic_stream_socket] 
-Move-assign a [link asio.reference.basic_stream_socket `basic_stream_socket`] from another. 
-
-
-  basic_stream_socket & ``[link asio.reference.basic_stream_socket.operator_eq_.overload1 operator=]``(
-      basic_stream_socket && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_stream_socket `basic_stream_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_stream_socket & > ``[link asio.reference.basic_stream_socket.operator_eq_.overload2 operator=]``(
-      basic_stream_socket< Protocol1, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_stream_socket `basic_stream_socket`] from another. 
-
-
-  basic_stream_socket & operator=(
-      basic_stream_socket && other);
-
-
-This assignment operator moves a stream socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_socket `basic_stream_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_stream_socket `basic_stream_socket`] from a socket of another protocol type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol1]``,
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Protocol1, Protocol >::value &&is_convertible< Executor1, Executor >::value, basic_stream_socket & > operator=(
-      basic_stream_socket< Protocol1, Executor1 > && other);
-
-
-This assignment operator moves a stream socket from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_stream_socket `basic_stream_socket`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_socket(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:out_of_band_inline basic_stream_socket::out_of_band_inline]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.out_of_band_inline..out_of_band_inline..basic_stream_socket] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type basic_stream_socket::protocol_type]
-
-[indexterm2 asio.indexterm.basic_stream_socket.protocol_type..protocol_type..basic_stream_socket] 
-The protocol type. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:read_some basic_stream_socket::read_some]
-
-[indexterm2 asio.indexterm.basic_stream_socket.read_some..read_some..basic_stream_socket] 
-Read some data from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.read_some.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::read_some (1 of 2 overloads)]
-
-
-Read some data from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::read_some (2 of 2 overloads)]
-
-
-Read some data from the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:receive basic_stream_socket::receive]
-
-[indexterm2 asio.indexterm.basic_stream_socket.receive..receive..basic_stream_socket] 
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.receive.overload1 receive]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.receive.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.receive.overload2 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.receive.overload2 more...]]``
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.receive.overload3 receive]``(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.receive.overload3 more...]]``
-
-
-[section:overload1 basic_stream_socket::receive (1 of 3 overloads)]
-
-
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::receive (2 of 3 overloads)]
-
-
-Receive some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To receive into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.receive(asio::buffer(data, size), 0);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on receiving into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_socket::receive (3 of 3 overloads)]
-
-
-Receive some data on a connected socket. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t receive(
-      const MutableBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be received.]]
-
-[[flags][Flags specifying how the receive call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes received. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The receive operation may not receive all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:receive_buffer_size basic_stream_socket::receive_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.receive_buffer_size..receive_buffer_size..basic_stream_socket] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_low_watermark basic_stream_socket::receive_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.receive_low_watermark..receive_low_watermark..basic_stream_socket] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:release basic_stream_socket::release]
-
-[indexterm2 asio.indexterm.basic_stream_socket.release..release..basic_stream_socket] 
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type ``[link asio.reference.basic_stream_socket.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_stream_socket.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.release.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::release (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::release (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Release ownership of the underlying native socket. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous connect, send and receive operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native socket is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:remote_endpoint basic_stream_socket::remote_endpoint]
-
-[indexterm2 asio.indexterm.basic_stream_socket.remote_endpoint..remote_endpoint..basic_stream_socket] 
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type ``[link asio.reference.basic_stream_socket.remote_endpoint.overload1 remote_endpoint]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.remote_endpoint.overload1 more...]]``
-
-  endpoint_type ``[link asio.reference.basic_stream_socket.remote_endpoint.overload2 remote_endpoint]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.remote_endpoint.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::remote_endpoint (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint() const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::remote_endpoint (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Get the remote endpoint of the socket. 
-
-
-  endpoint_type remote_endpoint(
-      asio::error_code & ec) const;
-
-
-This function is used to obtain the remote endpoint of the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:reuse_address basic_stream_socket::reuse_address]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.reuse_address..reuse_address..basic_stream_socket] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:send basic_stream_socket::send]
-
-[indexterm2 asio.indexterm.basic_stream_socket.send..send..basic_stream_socket] 
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.send.overload1 send]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.send.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.send.overload2 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.send.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.send.overload3 send]``(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.send.overload3 more...]]``
-
-
-[section:overload1 basic_stream_socket::send (1 of 3 overloads)]
-
-
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.send(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::send (2 of 3 overloads)]
-
-
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags);
-
-
-This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To send a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.send(asio::buffer(data, size), 0);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on sending multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_stream_socket::send (3 of 3 overloads)]
-
-
-Send some data on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t send(
-      const ConstBufferSequence & buffers,
-      socket_base::message_flags flags,
-      asio::error_code & ec);
-
-
-This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be sent on the socket.]]
-
-[[flags][Flags specifying how the send call is to be made.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes sent. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The send operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:send_buffer_size basic_stream_socket::send_buffer_size]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.send_buffer_size..send_buffer_size..basic_stream_socket] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark basic_stream_socket::send_low_watermark]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.send_low_watermark..send_low_watermark..basic_stream_socket] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:set_option basic_stream_socket::set_option]
-
-[indexterm2 asio.indexterm.basic_stream_socket.set_option..set_option..basic_stream_socket] 
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_stream_socket.set_option.overload1 set_option]``(
-      const SettableSocketOption & option);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.set_option.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void ``[link asio.reference.basic_stream_socket.set_option.overload2 set_option]``(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.set_option.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::set_option (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::set_option (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Set an option on the socket. 
-
-
-  template<
-      typename ``[link asio.reference.SettableSocketOption SettableSocketOption]``>
-  void set_option(
-      const SettableSocketOption & option,
-      asio::error_code & ec);
-
-
-This function is used to set an option on the socket.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[option][The new option value to be set on the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Setting the IPPROTO\_TCP/TCP\_NODELAY option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  asio::error_code ec;
-  socket.set_option(option, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown basic_stream_socket::shutdown]
-
-[indexterm2 asio.indexterm.basic_stream_socket.shutdown..shutdown..basic_stream_socket] 
-Disable sends or receives on the socket. 
-
-
-  void ``[link asio.reference.basic_stream_socket.shutdown.overload1 shutdown]``(
-      shutdown_type what);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.shutdown.overload2 shutdown]``(
-      shutdown_type what,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.shutdown.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::shutdown (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::shutdown (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Disable sends or receives on the socket. 
-
-
-  void shutdown(
-      shutdown_type what,
-      asio::error_code & ec);
-
-
-This function is used to disable send operations, receive operations, or both.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[what][Determines what types of operation will no longer be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Shutting down the send side of the socket: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.shutdown(asio::ip::tcp::socket::shutdown_send, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:shutdown_type basic_stream_socket::shutdown_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.shutdown_type..shutdown_type..basic_stream_socket] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.basic_stream_socket.shutdown_type.shutdown_receive..shutdown_receive..basic_stream_socket]
-[indexterm2 asio.indexterm.basic_stream_socket.shutdown_type.shutdown_send..shutdown_send..basic_stream_socket]
-[indexterm2 asio.indexterm.basic_stream_socket.shutdown_type.shutdown_both..shutdown_both..basic_stream_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:wait basic_stream_socket::wait]
-
-[indexterm2 asio.indexterm.basic_stream_socket.wait..wait..basic_stream_socket] 
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.basic_stream_socket.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_stream_socket.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.wait.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::wait (1 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  socket.wait(asio::ip::tcp::socket::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::wait (2 of 2 overloads)]
-
-
-['Inherited from basic_socket.]
-
-
-Wait for the socket to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a socket to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired socket state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a socket to become readable. 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::error_code ec;
-  socket.wait(asio::ip::tcp::socket::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type basic_stream_socket::wait_type]
-
-
-['Inherited from socket_base.]
-
-[indexterm2 asio.indexterm.basic_stream_socket.wait_type..wait_type..basic_stream_socket] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.basic_stream_socket.wait_type.wait_read..wait_read..basic_stream_socket]
-[indexterm2 asio.indexterm.basic_stream_socket.wait_type.wait_write..wait_write..basic_stream_socket]
-[indexterm2 asio.indexterm.basic_stream_socket.wait_type.wait_error..wait_error..basic_stream_socket]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-[section:write_some basic_stream_socket::write_some]
-
-[indexterm2 asio.indexterm.basic_stream_socket.write_some..write_some..basic_stream_socket] 
-Write some data to the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_stream_socket.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_stream_socket.write_some.overload2 more...]]``
-
-
-[section:overload1 basic_stream_socket::write_some (1 of 2 overloads)]
-
-
-Write some data to the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the socket.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  socket.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_stream_socket::write_some (2 of 2 overloads)]
-
-
-Write some data to the socket. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the socket.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_stream_socket basic_stream_socket::~basic_stream_socket]
-
-[indexterm2 asio.indexterm.basic_stream_socket._basic_stream_socket..~basic_stream_socket..basic_stream_socket] 
-Destroys the socket. 
-
-
-  ~basic_stream_socket();
-
-
-This function destroys the socket, cancelling any outstanding asynchronous operations associated with the socket as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_stream_socket__rebind_executor basic_stream_socket::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_stream_socket__rebind_executor..basic_stream_socket::rebind_executor]
-
-
-Rebinds the socket type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor.other [*other]]]
-    [The socket type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_stream_socket::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_stream_socket__rebind_executor.other..other..basic_stream_socket::rebind_executor] 
-The socket type when rebound to the specified executor. 
-
-
-  typedef basic_stream_socket< Protocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]] [constructor]]
-    [Construct a basic_stream_socket without opening it. 
-     [hr]
-     Construct and open a basic_stream_socket. 
-     [hr]
-     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_stream_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_stream_socket from another. 
-     [hr]
-     Move-construct a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_socket from another. 
-     [hr]
-     Move-assign a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.read_some [*read_some]]]
-    [Read some data from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.write_some [*write_some]]]
-    [Write some data to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket._basic_stream_socket [*~basic_stream_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_socket `basic_stream_socket`] class template provides asynchronous and blocking stream-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_stream_socket.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_streambuf basic_streambuf]
-
-[indexterm1 asio.indexterm.basic_streambuf..basic_streambuf]
-
-
-Automatically resizable buffer class based on std::streambuf. 
-
-
-  template<
-      typename Allocator = std::allocator<char>>
-  class basic_streambuf :
-    public std::streambuf,
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent the input sequence as a list of buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent the output sequence as a list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]] [constructor]]
-    [Construct a basic_streambuf object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.capacity [*capacity]]]
-    [Get the current capacity of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.commit [*commit]]]
-    [Move characters from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.consume [*consume]]]
-    [Remove characters from the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.data [*data]]]
-    [Get a list of buffers that represents the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.max_size [*max_size]]]
-    [Get the maximum size of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.prepare [*prepare]]]
-    [Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.size [*size]]]
-    [Get the size of the input sequence. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.overflow [*overflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.reserve [*reserve]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.underflow [*underflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-]
-
-The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.
-
-The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:
-
-
-* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.
-
-
-* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-
-* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 
-
-  size() <= max_size()
-
-
-Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.
-
-The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.
-
-
-[heading Examples]
-  
-Writing directly from an streambuf to a socket: 
-
-  asio::streambuf b;
-  std::ostream os(&b);
-  os << "Hello, World!\n";
-
-  // try sending some data in input sequence
-  size_t n = sock.send(b.data());
-
-  b.consume(n); // sent data is removed from input sequence
-
-
-
-
-Reading from a socket directly into a streambuf: 
-
-  asio::streambuf b;
-
-  // reserve 512 bytes in output sequence
-  asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
-
-  size_t n = sock.receive(bufs);
-
-  // received data is "committed" from output sequence to input sequence
-  b.commit(n);
-
-  std::istream is(&b);
-  std::string s;
-  is >> s;
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:basic_streambuf basic_streambuf::basic_streambuf]
-
-[indexterm2 asio.indexterm.basic_streambuf.basic_streambuf..basic_streambuf..basic_streambuf] 
-Construct a [link asio.reference.basic_streambuf `basic_streambuf`] object. 
-
-
-  basic_streambuf(
-      std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)(),
-      const Allocator & allocator = Allocator());
-
-
-Constructs a streambuf with the specified maximum size. The initial size of the streambuf's input sequence is 0. 
-
-
-[endsect]
-
-
-
-[section:capacity basic_streambuf::capacity]
-
-[indexterm2 asio.indexterm.basic_streambuf.capacity..capacity..basic_streambuf] 
-Get the current capacity of the [link asio.reference.basic_streambuf `basic_streambuf`]. 
-
-
-  std::size_t capacity() const;
-
-
-
-[heading Return Value]
-      
-The current total capacity of the streambuf, i.e. for both the input sequence and output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:commit basic_streambuf::commit]
-
-[indexterm2 asio.indexterm.basic_streambuf.commit..commit..basic_streambuf] 
-Move characters from the output sequence to the input sequence. 
-
-
-  void commit(
-      std::size_t n);
-
-
-Appends `n` characters from the start of the output sequence to the input sequence. The beginning of the output sequence is advanced by `n` characters.
-
-Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence.
-
-
-[heading Remarks]
-      
-If `n` is greater than the size of the output sequence, the entire output sequence is moved to the input sequence and no error is issued. 
-
-
-
-
-[endsect]
-
-
-
-[section:const_buffers_type basic_streambuf::const_buffers_type]
-
-[indexterm2 asio.indexterm.basic_streambuf.const_buffers_type..const_buffers_type..basic_streambuf] 
-The type used to represent the input sequence as a list of buffers. 
-
-
-  typedef implementation_defined const_buffers_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:consume basic_streambuf::consume]
-
-[indexterm2 asio.indexterm.basic_streambuf.consume..consume..basic_streambuf] 
-Remove characters from the input sequence. 
-
-
-  void consume(
-      std::size_t n);
-
-
-Removes `n` characters from the beginning of the input sequence.
-
-
-[heading Remarks]
-      
-If `n` is greater than the size of the input sequence, the entire input sequence is consumed and no error is issued. 
-
-
-
-
-[endsect]
-
-
-
-[section:data basic_streambuf::data]
-
-[indexterm2 asio.indexterm.basic_streambuf.data..data..basic_streambuf] 
-Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type data() const;
-
-
-
-[heading Return Value]
-      
-An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing all character arrays in the input sequence.
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `basic_streambuf` member function that modifies the input sequence or output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:max_size basic_streambuf::max_size]
-
-[indexterm2 asio.indexterm.basic_streambuf.max_size..max_size..basic_streambuf] 
-Get the maximum size of the [link asio.reference.basic_streambuf `basic_streambuf`]. 
-
-
-  std::size_t max_size() const;
-
-
-
-[heading Return Value]
-      
-The allowed maximum of the sum of the sizes of the input sequence and output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:mutable_buffers_type basic_streambuf::mutable_buffers_type]
-
-[indexterm2 asio.indexterm.basic_streambuf.mutable_buffers_type..mutable_buffers_type..basic_streambuf] 
-The type used to represent the output sequence as a list of buffers. 
-
-
-  typedef implementation_defined mutable_buffers_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:overflow basic_streambuf::overflow]
-
-[indexterm2 asio.indexterm.basic_streambuf.overflow..overflow..basic_streambuf] 
-Override std::streambuf behaviour. 
-
-
-  int_type overflow(
-      int_type c);
-
-
-Behaves according to the specification of `std::streambuf::overflow()`, with the specialisation that `std::length_error` is thrown if appending the character to the input sequence would require the condition `size() > max_size()` to be true. 
-
-
-[endsect]
-
-
-
-[section:prepare basic_streambuf::prepare]
-
-[indexterm2 asio.indexterm.basic_streambuf.prepare..prepare..basic_streambuf] 
-Get a list of buffers that represents the output sequence, with the given size. 
-
-
-  mutable_buffers_type prepare(
-      std::size_t n);
-
-
-Ensures that the output sequence can accommodate `n` characters, reallocating character array objects as necessary.
-
-
-[heading Return Value]
-      
-An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing character array objects at the start of the output sequence such that the sum of the buffer sizes is `n`.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[std::length_error][If `size() + n > max_size()`.]]
-
-]
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `basic_streambuf` member function that modifies the input sequence or output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:reserve basic_streambuf::reserve]
-
-[indexterm2 asio.indexterm.basic_streambuf.reserve..reserve..basic_streambuf] 
-
-  void reserve(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size basic_streambuf::size]
-
-[indexterm2 asio.indexterm.basic_streambuf.size..size..basic_streambuf] 
-Get the size of the input sequence. 
-
-
-  std::size_t size() const;
-
-
-
-[heading Return Value]
-      
-The size of the input sequence. The value is equal to that calculated for `s` in the following code: 
-
-  size_t s = 0;
-  const_buffers_type bufs = data();
-  const_buffers_type::const_iterator i = bufs.begin();
-  while (i != bufs.end())
-  {
-    const_buffer buf(*i++);
-    s += buf.size();
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:underflow basic_streambuf::underflow]
-
-[indexterm2 asio.indexterm.basic_streambuf.underflow..underflow..basic_streambuf] 
-Override std::streambuf behaviour. 
-
-
-  int_type underflow();
-
-
-Behaves according to the specification of `std::streambuf::underflow()`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_streambuf_ref basic_streambuf_ref]
-
-[indexterm1 asio.indexterm.basic_streambuf_ref..basic_streambuf_ref]
-
-
-Adapts [link asio.reference.basic_streambuf `basic_streambuf`] to the dynamic buffer sequence type requirements. 
-
-
-  template<
-      typename Allocator = std::allocator<char>>
-  class basic_streambuf_ref
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_streambuf_ref.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent the input sequence as a list of buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_streambuf_ref.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent the output sequence as a list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf_ref.basic_streambuf_ref [*basic_streambuf_ref]] [constructor]]
-    [Construct a basic_streambuf_ref for the given basic_streambuf object. 
-     [hr]
-     Copy construct a basic_streambuf_ref. 
-     [hr]
-     Move construct a basic_streambuf_ref. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.capacity [*capacity]]]
-    [Get the current capacity of the dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.commit [*commit]]]
-    [Move bytes from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.consume [*consume]]]
-    [Remove characters from the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.data [*data]]]
-    [Get a list of buffers that represents the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.max_size [*max_size]]]
-    [Get the maximum size of the dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.prepare [*prepare]]]
-    [Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf_ref.size [*size]]]
-    [Get the size of the input sequence. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_streambuf_ref basic_streambuf_ref::basic_streambuf_ref]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.basic_streambuf_ref..basic_streambuf_ref..basic_streambuf_ref] 
-Construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`] for the given [link asio.reference.basic_streambuf `basic_streambuf`] object. 
-
-
-  explicit ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload1 basic_streambuf_ref]``(
-      basic_streambuf< Allocator > & sb);
-  ``  [''''&raquo;''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload1 more...]]``
-
-
-Copy construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. 
-
-
-  ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload2 basic_streambuf_ref]``(
-      const basic_streambuf_ref & other);
-  ``  [''''&raquo;''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload2 more...]]``
-
-
-Move construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. 
-
-
-  ``[link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload3 basic_streambuf_ref]``(
-      basic_streambuf_ref && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_streambuf_ref.basic_streambuf_ref.overload3 more...]]``
-
-
-[section:overload1 basic_streambuf_ref::basic_streambuf_ref (1 of 3 overloads)]
-
-
-Construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`] for the given [link asio.reference.basic_streambuf `basic_streambuf`] object. 
-
-
-  basic_streambuf_ref(
-      basic_streambuf< Allocator > & sb);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_streambuf_ref::basic_streambuf_ref (2 of 3 overloads)]
-
-
-Copy construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. 
-
-
-  basic_streambuf_ref(
-      const basic_streambuf_ref & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_streambuf_ref::basic_streambuf_ref (3 of 3 overloads)]
-
-
-Move construct a [link asio.reference.basic_streambuf_ref `basic_streambuf_ref`]. 
-
-
-  basic_streambuf_ref(
-      basic_streambuf_ref && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:capacity basic_streambuf_ref::capacity]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.capacity..capacity..basic_streambuf_ref] 
-Get the current capacity of the dynamic buffer. 
-
-
-  std::size_t capacity() const;
-
-
-
-[endsect]
-
-
-
-[section:commit basic_streambuf_ref::commit]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.commit..commit..basic_streambuf_ref] 
-Move bytes from the output sequence to the input sequence. 
-
-
-  void commit(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:const_buffers_type basic_streambuf_ref::const_buffers_type]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.const_buffers_type..const_buffers_type..basic_streambuf_ref] 
-The type used to represent the input sequence as a list of buffers. 
-
-
-  typedef basic_streambuf< Allocator >::const_buffers_type const_buffers_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent the input sequence as a list of buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent the output sequence as a list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]] [constructor]]
-    [Construct a basic_streambuf object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.capacity [*capacity]]]
-    [Get the current capacity of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.commit [*commit]]]
-    [Move characters from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.consume [*consume]]]
-    [Remove characters from the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.data [*data]]]
-    [Get a list of buffers that represents the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.max_size [*max_size]]]
-    [Get the maximum size of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.prepare [*prepare]]]
-    [Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.size [*size]]]
-    [Get the size of the input sequence. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.overflow [*overflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.reserve [*reserve]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.underflow [*underflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-]
-
-The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.
-
-The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:
-
-
-* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.
-
-
-* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-
-* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 
-
-  size() <= max_size()
-
-
-Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.
-
-The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.
-
-
-[heading Examples]
-  
-Writing directly from an streambuf to a socket: 
-
-  asio::streambuf b;
-  std::ostream os(&b);
-  os << "Hello, World!\n";
-
-  // try sending some data in input sequence
-  size_t n = sock.send(b.data());
-
-  b.consume(n); // sent data is removed from input sequence
-
-
-
-
-Reading from a socket directly into a streambuf: 
-
-  asio::streambuf b;
-
-  // reserve 512 bytes in output sequence
-  asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
-
-  size_t n = sock.receive(bufs);
-
-  // received data is "committed" from output sequence to input sequence
-  b.commit(n);
-
-  std::istream is(&b);
-  std::string s;
-  is >> s;
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:consume basic_streambuf_ref::consume]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.consume..consume..basic_streambuf_ref] 
-Remove characters from the input sequence. 
-
-
-  void consume(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:data basic_streambuf_ref::data]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.data..data..basic_streambuf_ref] 
-Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type data() const;
-
-
-
-[endsect]
-
-
-
-[section:max_size basic_streambuf_ref::max_size]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.max_size..max_size..basic_streambuf_ref] 
-Get the maximum size of the dynamic buffer. 
-
-
-  std::size_t max_size() const;
-
-
-
-[endsect]
-
-
-
-[section:mutable_buffers_type basic_streambuf_ref::mutable_buffers_type]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.mutable_buffers_type..mutable_buffers_type..basic_streambuf_ref] 
-The type used to represent the output sequence as a list of buffers. 
-
-
-  typedef basic_streambuf< Allocator >::mutable_buffers_type mutable_buffers_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent the input sequence as a list of buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent the output sequence as a list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]] [constructor]]
-    [Construct a basic_streambuf object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.capacity [*capacity]]]
-    [Get the current capacity of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.commit [*commit]]]
-    [Move characters from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.consume [*consume]]]
-    [Remove characters from the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.data [*data]]]
-    [Get a list of buffers that represents the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.max_size [*max_size]]]
-    [Get the maximum size of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.prepare [*prepare]]]
-    [Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.size [*size]]]
-    [Get the size of the input sequence. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.overflow [*overflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.reserve [*reserve]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.underflow [*underflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-]
-
-The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.
-
-The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:
-
-
-* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.
-
-
-* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-
-* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 
-
-  size() <= max_size()
-
-
-Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.
-
-The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.
-
-
-[heading Examples]
-  
-Writing directly from an streambuf to a socket: 
-
-  asio::streambuf b;
-  std::ostream os(&b);
-  os << "Hello, World!\n";
-
-  // try sending some data in input sequence
-  size_t n = sock.send(b.data());
-
-  b.consume(n); // sent data is removed from input sequence
-
-
-
-
-Reading from a socket directly into a streambuf: 
-
-  asio::streambuf b;
-
-  // reserve 512 bytes in output sequence
-  asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
-
-  size_t n = sock.receive(bufs);
-
-  // received data is "committed" from output sequence to input sequence
-  b.commit(n);
-
-  std::istream is(&b);
-  std::string s;
-  is >> s;
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:prepare basic_streambuf_ref::prepare]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.prepare..prepare..basic_streambuf_ref] 
-Get a list of buffers that represents the output sequence, with the given size. 
-
-
-  mutable_buffers_type prepare(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size basic_streambuf_ref::size]
-
-[indexterm2 asio.indexterm.basic_streambuf_ref.size..size..basic_streambuf_ref] 
-Get the size of the input sequence. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_system_executor basic_system_executor]
-
-[indexterm1 asio.indexterm.basic_system_executor..basic_system_executor]
-
-
-An executor that uses arbitrary threads. 
-
-
-  template<
-      typename Blocking,
-      typename Relationship,
-      typename Allocator>
-  class basic_system_executor
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.defer [*defer]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
-    [Inform the executor that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
-    [Inform the executor that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.post [*post]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query [*query]]]
-    [Query the current value of the allocator property. 
-     [hr]
-     Query the occupancy (recommended number of work items) for the system context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.always property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
-
-[heading Requirements]
-
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:basic_system_executor basic_system_executor::basic_system_executor]
-
-[indexterm2 asio.indexterm.basic_system_executor.basic_system_executor..basic_system_executor..basic_system_executor] 
-Default constructor. 
-
-
-  basic_system_executor();
-
-
-
-[endsect]
-
-
-
-[section:context basic_system_executor::context]
-
-[indexterm2 asio.indexterm.basic_system_executor.context..context..basic_system_executor] 
-Obtain the underlying execution context. 
-
-
-  system_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer basic_system_executor::defer]
-
-[indexterm2 asio.indexterm.basic_system_executor.defer..defer..basic_system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void defer(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch basic_system_executor::dispatch]
-
-[indexterm2 asio.indexterm.basic_system_executor.dispatch..dispatch..basic_system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void dispatch(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will always be executed inside this function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:execute basic_system_executor::execute]
-
-[indexterm2 asio.indexterm.basic_system_executor.execute..execute..basic_system_executor] 
-Execution function. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-
-[endsect]
-
-
-
-[section:on_work_finished basic_system_executor::on_work_finished]
-
-[indexterm2 asio.indexterm.basic_system_executor.on_work_finished..on_work_finished..basic_system_executor] 
-Inform the executor that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-For the system executor, this is a no-op. 
-
-
-[endsect]
-
-
-
-[section:on_work_started basic_system_executor::on_work_started]
-
-[indexterm2 asio.indexterm.basic_system_executor.on_work_started..on_work_started..basic_system_executor] 
-Inform the executor that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-For the system executor, this is a no-op. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ basic_system_executor::operator!=]
-
-[indexterm2 asio.indexterm.basic_system_executor.operator_not__eq_..operator!=..basic_system_executor] 
-Compare two executors for inequality. 
-
-
-  bool operator!=(
-      const basic_system_executor & ,
-      const basic_system_executor & );
-
-
-Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
-
-[heading Requirements]
-
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ basic_system_executor::operator==]
-
-[indexterm2 asio.indexterm.basic_system_executor.operator_eq__eq_..operator==..basic_system_executor] 
-Compare two executors for equality. 
-
-
-  bool operator==(
-      const basic_system_executor & ,
-      const basic_system_executor & );
-
-
-Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
-
-[heading Requirements]
-
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post basic_system_executor::post]
-
-[indexterm2 asio.indexterm.basic_system_executor.post..post..basic_system_executor] 
-Request the system executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void post(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run on an unspecified system thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:query basic_system_executor::query]
-
-[indexterm2 asio.indexterm.basic_system_executor.query..query..basic_system_executor] 
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator ``[link asio.reference.basic_system_executor.query.overload1 query]``(
-      execution::allocator_t< OtherAllocator > ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload1 more...]]``
-
-  constexpr Allocator ``[link asio.reference.basic_system_executor.query.overload2 query]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload2 more...]]``
-
-
-Query the occupancy (recommended number of work items) for the system context. 
-
-
-  std::size_t ``[link asio.reference.basic_system_executor.query.overload3 query]``(
-      execution::occupancy_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query.overload3 more...]]``
-
-
-[section:overload1 basic_system_executor::query (1 of 3 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t< OtherAllocator > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_system_executor::query (2 of 3 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  constexpr Allocator query(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_system_executor::query (3 of 3 overloads)]
-
-
-Query the occupancy (recommended number of work items) for the system context. 
-
-
-  std::size_t query(
-      execution::occupancy_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  std::size_t occupancy = asio::query(
-      ex, asio::execution::occupancy); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:query__static basic_system_executor::query]
-
-[indexterm2 asio.indexterm.basic_system_executor.query__static..query..basic_system_executor] 
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t ``[link asio.reference.basic_system_executor.query__static.overload1 query]``(
-      execution::mapping_t );
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload1 more...]]``
-
-
-Query the current value of the `context` property. 
-
-
-  static system_context & ``[link asio.reference.basic_system_executor.query__static.overload2 query]``(
-      execution::context_t );
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload2 more...]]``
-
-
-Query the current value of the `blocking` property. 
-
-
-  static constexpr execution::blocking_t ``[link asio.reference.basic_system_executor.query__static.overload3 query]``(
-      execution::blocking_t );
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload3 more...]]``
-
-
-Query the current value of the `relationship` property. 
-
-
-  static constexpr execution::relationship_t ``[link asio.reference.basic_system_executor.query__static.overload4 query]``(
-      execution::relationship_t );
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.query__static.overload4 more...]]``
-
-
-[section:overload1 basic_system_executor::query (1 of 4 overloads)]
-
-
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t query(
-      execution::mapping_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  if (asio::query(ex, asio::execution::mapping)
-        == asio::execution::mapping.thread)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_system_executor::query (2 of 4 overloads)]
-
-
-Query the current value of the `context` property. 
-
-
-  static system_context & query(
-      execution::context_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  asio::system_context& pool = asio::query(
-      ex, asio::execution::context); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_system_executor::query (3 of 4 overloads)]
-
-
-Query the current value of the `blocking` property. 
-
-
-  static constexpr execution::blocking_t query(
-      execution::blocking_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  if (asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.always)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_system_executor::query (4 of 4 overloads)]
-
-
-Query the current value of the `relationship` property. 
-
-
-  static constexpr execution::relationship_t query(
-      execution::relationship_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::system_executor ex;
-  if (asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.continuation)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:require basic_system_executor::require]
-
-[indexterm2 asio.indexterm.basic_system_executor.require..require..basic_system_executor] 
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  basic_system_executor< execution::blocking_t::possibly_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload1 require]``(
-      execution::blocking_t::possibly_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload1 more...]]``
-
-
-Obtain an executor with the `blocking.always` property. 
-
-
-  basic_system_executor< execution::blocking_t::always_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload2 require]``(
-      execution::blocking_t::always_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload2 more...]]``
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  basic_system_executor< execution::blocking_t::never_t, Relationship, Allocator > ``[link asio.reference.basic_system_executor.require.overload3 require]``(
-      execution::blocking_t::never_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload3 more...]]``
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  basic_system_executor< Blocking, execution::relationship_t::continuation_t, Allocator > ``[link asio.reference.basic_system_executor.require.overload4 require]``(
-      execution::relationship_t::continuation_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload4 more...]]``
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  basic_system_executor< Blocking, execution::relationship_t::fork_t, Allocator > ``[link asio.reference.basic_system_executor.require.overload5 require]``(
-      execution::relationship_t::fork_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload5 more...]]``
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  basic_system_executor< Blocking, Relationship, OtherAllocator > ``[link asio.reference.basic_system_executor.require.overload6 require]``(
-      execution::allocator_t< OtherAllocator > a) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload6 more...]]``
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  basic_system_executor< Blocking, Relationship, std::allocator< void > > ``[link asio.reference.basic_system_executor.require.overload7 require]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_system_executor.require.overload7 more...]]``
-
-
-[section:overload1 basic_system_executor::require (1 of 7 overloads)]
-
-
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  basic_system_executor< execution::blocking_t::possibly_t, Relationship, Allocator > require(
-      execution::blocking_t::possibly_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_system_executor::require (2 of 7 overloads)]
-
-
-Obtain an executor with the `blocking.always` property. 
-
-
-  basic_system_executor< execution::blocking_t::always_t, Relationship, Allocator > require(
-      execution::blocking_t::always_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.always); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_system_executor::require (3 of 7 overloads)]
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  basic_system_executor< execution::blocking_t::never_t, Relationship, Allocator > require(
-      execution::blocking_t::never_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.never); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_system_executor::require (4 of 7 overloads)]
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  basic_system_executor< Blocking, execution::relationship_t::continuation_t, Allocator > require(
-      execution::relationship_t::continuation_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.continuation); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_system_executor::require (5 of 7 overloads)]
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  basic_system_executor< Blocking, execution::relationship_t::fork_t, Allocator > require(
-      execution::relationship_t::fork_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.fork); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_system_executor::require (6 of 7 overloads)]
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  basic_system_executor< Blocking, Relationship, OtherAllocator > require(
-      execution::allocator_t< OtherAllocator > a) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator(my_allocator)); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_system_executor::require (7 of 7 overloads)]
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  basic_system_executor< Blocking, Relationship, std::allocator< void > > require(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::system_executor ex1;
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_waitable_timer basic_waitable_timer]
-
-[indexterm1 asio.indexterm.basic_waitable_timer..basic_waitable_timer]
-
-
-Provides waitable timer functionality. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_waitable_timer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.duration [*duration]]]
-    [The duration type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.time_point [*time_point]]]
-    [The time point type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
-    [The wait traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
-    [Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expiry [*expiry]]]
-    [Get the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use one of the [link asio.reference.steady_timer `steady_timer`], [link asio.reference.system_timer `system_timer`] or [link asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
-
-
-[heading Remarks]
-      
-This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait (C++11): 
-
-  // Construct a timer without setting an expiry time.
-  asio::steady_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_after(std::chrono::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait (C++11): 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::steady_timer timer(my_context,
-      std::chrono::steady_clock::now() + std::chrono::seconds(60));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active waitable timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_after(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_wait basic_waitable_timer::async_wait]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.async_wait..async_wait..basic_waitable_timer] 
-Start an asynchronous wait on the timer. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function may be used to initiate an asynchronous wait against the timer. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-For each call to `async_wait()`, the completion handler will be called exactly once. The completion handler will be called when:
-
-
-* The timer has expired.
-
-
-* The timer was cancelled, in which case the handler is passed the error code `asio::error::operation_aborted`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the timer expires. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_waitable_timer basic_waitable_timer::basic_waitable_timer]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.basic_waitable_timer..basic_waitable_timer..basic_waitable_timer] 
-Constructor. 
-
-
-  explicit ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload1 basic_waitable_timer]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload2 basic_waitable_timer]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload2 more...]]``
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload3 basic_waitable_timer]``(
-      const executor_type & ex,
-      const time_point & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload4 basic_waitable_timer]``(
-      ExecutionContext & context,
-      const time_point & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload4 more...]]``
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload5 basic_waitable_timer]``(
-      const executor_type & ex,
-      const duration & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload5 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload6 basic_waitable_timer]``(
-      ExecutionContext & context,
-      const duration & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload6 more...]]``
-
-
-Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload7 basic_waitable_timer]``(
-      basic_waitable_timer && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_waitable_timer.basic_waitable_timer.overload8 basic_waitable_timer]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.basic_waitable_timer.overload8 more...]]``
-
-
-[section:overload1 basic_waitable_timer::basic_waitable_timer (1 of 8 overloads)]
-
-
-Constructor. 
-
-
-  basic_waitable_timer(
-      const executor_type & ex);
-
-
-This constructor creates a timer without setting an expiry time. The `expires_at()` or `expires_after()` functions must be called to set an expiry time before the timer can be waited on.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::basic_waitable_timer (2 of 8 overloads)]
-
-
-Constructor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_waitable_timer(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer without setting an expiry time. The `expires_at()` or `expires_after()` functions must be called to set an expiry time before the timer can be waited on.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_waitable_timer::basic_waitable_timer (3 of 8 overloads)]
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  basic_waitable_timer(
-      const executor_type & ex,
-      const time_point & expiry_time);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor object that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, expressed as an absolute time. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_waitable_timer::basic_waitable_timer (4 of 8 overloads)]
-
-
-Constructor to set a particular expiry time as an absolute time. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_waitable_timer(
-      ExecutionContext & context,
-      const time_point & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, expressed as an absolute time. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_waitable_timer::basic_waitable_timer (5 of 8 overloads)]
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  basic_waitable_timer(
-      const executor_type & ex,
-      const duration & expiry_time);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, relative to now. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_waitable_timer::basic_waitable_timer (6 of 8 overloads)]
-
-
-Constructor to set a particular expiry time relative to now. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_waitable_timer(
-      ExecutionContext & context,
-      const duration & expiry_time,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a timer and sets the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the timer will use, by default, to dispatch handlers for any asynchronous operations performed on the timer.]]
-
-[[expiry_time][The expiry time to be used for the timer, relative to now. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 basic_waitable_timer::basic_waitable_timer (7 of 8 overloads)]
-
-
-Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  basic_waitable_timer(
-      basic_waitable_timer && other);
-
-
-This constructor moves a timer from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 basic_waitable_timer::basic_waitable_timer (8 of 8 overloads)]
-
-
-Move-construct a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_waitable_timer(
-      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a timer from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_waitable_timer::cancel]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.cancel..cancel..basic_waitable_timer] 
-Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.cancel.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_waitable_timer::cancel (1 of 2 overloads)]
-
-
-Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t cancel();
-
-
-This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::cancel (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Cancel any asynchronous operations that are waiting on the timer. 
-
-
-  std::size_t cancel(
-      asio::error_code & ec);
-
-
-This function forces the completion of any pending asynchronous wait operations against the timer. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel_one basic_waitable_timer::cancel_one]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.cancel_one..cancel_one..basic_waitable_timer] 
-Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.cancel_one.overload1 cancel_one]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.cancel_one.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.cancel_one.overload2 cancel_one]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.cancel_one.overload2 more...]]``
-
-
-[section:overload1 basic_waitable_timer::cancel_one (1 of 2 overloads)]
-
-
-Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t cancel_one();
-
-
-This function forces the completion of one pending asynchronous wait operation against the timer. Handlers are cancelled in FIFO order. The handler for the cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled. That is, either 0 or 1.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel_one()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::cancel_one (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Cancels one asynchronous operation that is waiting on the timer. 
-
-
-  std::size_t cancel_one(
-      asio::error_code & ec);
-
-
-This function forces the completion of one pending asynchronous wait operation against the timer. Handlers are cancelled in FIFO order. The handler for the cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-Cancelling the timer does not change the expiry time.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled. That is, either 0 or 1.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `cancel_one()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:clock_type basic_waitable_timer::clock_type]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.clock_type..clock_type..basic_waitable_timer] 
-The clock type. 
-
-
-  typedef Clock clock_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:duration basic_waitable_timer::duration]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.duration..duration..basic_waitable_timer] 
-The duration type of the clock. 
-
-
-  typedef clock_type::duration duration;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type basic_waitable_timer::executor_type]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.executor_type..executor_type..basic_waitable_timer] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:expires_after basic_waitable_timer::expires_after]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.expires_after..expires_after..basic_waitable_timer] 
-Set the timer's expiry time relative to now. 
-
-
-  std::size_t expires_after(
-      const duration & expiry_time);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_after()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[section:expires_at basic_waitable_timer::expires_at]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.expires_at..expires_at..basic_waitable_timer] 
-(Deprecated: Use `expiry()`.) Get the timer's expiry time as an absolute time. 
-
-
-  time_point ``[link asio.reference.basic_waitable_timer.expires_at.overload1 expires_at]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_at.overload1 more...]]``
-
-
-Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.expires_at.overload2 expires_at]``(
-      const time_point & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_at.overload2 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.expires_at.overload3 expires_at]``(
-      const time_point & expiry_time,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_at.overload3 more...]]``
-
-
-[section:overload1 basic_waitable_timer::expires_at (1 of 3 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the timer's expiry time as an absolute time. 
-
-
-  time_point expires_at() const;
-
-
-This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::expires_at (2 of 3 overloads)]
-
-
-Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t expires_at(
-      const time_point & expiry_time);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_at()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 basic_waitable_timer::expires_at (3 of 3 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Set the timer's expiry time as an absolute time. 
-
-
-  std::size_t expires_at(
-      const time_point & expiry_time,
-      asio::error_code & ec);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_at()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:expires_from_now basic_waitable_timer::expires_from_now]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.expires_from_now..expires_from_now..basic_waitable_timer] 
-(Deprecated: Use `expiry()`.) Get the timer's expiry time relative to now. 
-
-
-  duration ``[link asio.reference.basic_waitable_timer.expires_from_now.overload1 expires_from_now]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_from_now.overload1 more...]]``
-
-
-(Deprecated: Use `expires_after()`.) Set the timer's expiry time relative to now. 
-
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.expires_from_now.overload2 expires_from_now]``(
-      const duration & expiry_time);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_from_now.overload2 more...]]``
-
-  std::size_t ``[link asio.reference.basic_waitable_timer.expires_from_now.overload3 expires_from_now]``(
-      const duration & expiry_time,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.expires_from_now.overload3 more...]]``
-
-
-[section:overload1 basic_waitable_timer::expires_from_now (1 of 3 overloads)]
-
-
-(Deprecated: Use `expiry()`.) Get the timer's expiry time relative to now. 
-
-
-  duration expires_from_now() const;
-
-
-This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::expires_from_now (2 of 3 overloads)]
-
-
-(Deprecated: Use `expires_after()`.) Set the timer's expiry time relative to now. 
-
-
-  std::size_t expires_from_now(
-      const duration & expiry_time);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_from_now()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-
-[section:overload3 basic_waitable_timer::expires_from_now (3 of 3 overloads)]
-
-
-(Deprecated: Use `expires_after()`.) Set the timer's expiry time relative to now. 
-
-
-  std::size_t expires_from_now(
-      const duration & expiry_time,
-      asio::error_code & ec);
-
-
-This function sets the expiry time. Any pending asynchronous wait operations will be cancelled. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[expiry_time][The expiry time to be used for the timer.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of asynchronous operations that were cancelled.
-
-
-[heading Remarks]
-      
-If the timer has already expired when `expires_from_now()` is called, then the handlers for asynchronous wait operations will:
-
-
-* have already been invoked; or
-
-
-* have been queued for invocation in the near future.
-
-These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:expiry basic_waitable_timer::expiry]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.expiry..expiry..basic_waitable_timer] 
-Get the timer's expiry time as an absolute time. 
-
-
-  time_point expiry() const;
-
-
-This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value. 
-
-
-[endsect]
-
-
-
-[section:get_executor basic_waitable_timer::get_executor]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.get_executor..get_executor..basic_waitable_timer] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:operator_eq_ basic_waitable_timer::operator=]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.operator_eq_..operator=..basic_waitable_timer] 
-Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  basic_waitable_timer & ``[link asio.reference.basic_waitable_timer.operator_eq_.overload1 operator=]``(
-      basic_waitable_timer && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.operator_eq_.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_waitable_timer & > ``[link asio.reference.basic_waitable_timer.operator_eq_.overload2 operator=]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_waitable_timer::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  basic_waitable_timer & operator=(
-      basic_waitable_timer && other);
-
-
-This assignment operator moves a timer from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_waitable_timer `basic_waitable_timer`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_waitable_timer & > operator=(
-      basic_waitable_timer< Clock, WaitTraits, Executor1 > && other);
-
-
-This assignment operator moves a timer from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_waitable_timer `basic_waitable_timer`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_waitable_timer(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:time_point basic_waitable_timer::time_point]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.time_point..time_point..basic_waitable_timer] 
-The time point type of the clock. 
-
-
-  typedef clock_type::time_point time_point;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:traits_type basic_waitable_timer::traits_type]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.traits_type..traits_type..basic_waitable_timer] 
-The wait traits type. 
-
-
-  typedef WaitTraits traits_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:wait basic_waitable_timer::wait]
-
-[indexterm2 asio.indexterm.basic_waitable_timer.wait..wait..basic_waitable_timer] 
-Perform a blocking wait on the timer. 
-
-
-  void ``[link asio.reference.basic_waitable_timer.wait.overload1 wait]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.wait.overload1 more...]]``
-
-  void ``[link asio.reference.basic_waitable_timer.wait.overload2 wait]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_waitable_timer.wait.overload2 more...]]``
-
-
-[section:overload1 basic_waitable_timer::wait (1 of 2 overloads)]
-
-
-Perform a blocking wait on the timer. 
-
-
-  void wait();
-
-
-This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_waitable_timer::wait (2 of 2 overloads)]
-
-
-Perform a blocking wait on the timer. 
-
-
-  void wait(
-      asio::error_code & ec);
-
-
-This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_waitable_timer basic_waitable_timer::~basic_waitable_timer]
-
-[indexterm2 asio.indexterm.basic_waitable_timer._basic_waitable_timer..~basic_waitable_timer..basic_waitable_timer] 
-Destroys the timer. 
-
-
-  ~basic_waitable_timer();
-
-
-This function destroys the timer, cancelling any outstanding asynchronous wait operations associated with the timer as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_waitable_timer__rebind_executor basic_waitable_timer::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_waitable_timer__rebind_executor..basic_waitable_timer::rebind_executor]
-
-
-Rebinds the timer type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor.other [*other]]]
-    [The timer type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_waitable_timer::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_waitable_timer__rebind_executor.other..other..basic_waitable_timer::rebind_executor] 
-The timer type when rebound to the specified executor. 
-
-
-  typedef basic_waitable_timer< Clock, WaitTraits, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.duration [*duration]]]
-    [The duration type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.time_point [*time_point]]]
-    [The time point type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
-    [The wait traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
-    [Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expiry [*expiry]]]
-    [Get the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use one of the [link asio.reference.steady_timer `steady_timer`], [link asio.reference.system_timer `system_timer`] or [link asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
-
-
-[heading Remarks]
-      
-This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait (C++11): 
-
-  // Construct a timer without setting an expiry time.
-  asio::steady_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_after(std::chrono::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait (C++11): 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::steady_timer timer(my_context,
-      std::chrono::steady_clock::now() + std::chrono::seconds(60));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active waitable timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_after(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_waitable_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_writable_pipe basic_writable_pipe]
-
-[indexterm1 asio.indexterm.basic_writable_pipe..basic_writable_pipe]
-
-
-Provides pipe functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_writable_pipe
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_writable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_writable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.basic_writable_pipe [*basic_writable_pipe]] [constructor]]
-    [Construct a basic_writable_pipe without opening it. 
-     [hr]
-     Construct a basic_writable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_writable_pipe from another. 
-     [hr]
-     Move-construct a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_writable_pipe from another. 
-     [hr]
-     Move-assign a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.write_some [*write_some]]]
-    [Write some data to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe._basic_writable_pipe [*~basic_writable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_writable_pipe `basic_writable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign basic_writable_pipe::assign]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.assign..assign..basic_writable_pipe] 
-Assign an existing native pipe to the pipe. 
-
-
-  void ``[link asio.reference.basic_writable_pipe.assign.overload1 assign]``(
-      const native_handle_type & native_pipe);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.assign.overload1 more...]]``
-
-  void ``[link asio.reference.basic_writable_pipe.assign.overload2 assign]``(
-      const native_handle_type & native_pipe,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.assign.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::assign (1 of 2 overloads)]
-
-
-Assign an existing native pipe to the pipe. 
-
-
-  void assign(
-      const native_handle_type & native_pipe);
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::assign (2 of 2 overloads)]
-
-
-Assign an existing native pipe to the pipe. 
-
-
-  void assign(
-      const native_handle_type & native_pipe,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_write_some basic_writable_pipe::async_write_some]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.async_write_some..async_write_some..basic_writable_pipe] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the pipe. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the pipe. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  pipe.async_write_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-[section:basic_writable_pipe basic_writable_pipe::basic_writable_pipe]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.basic_writable_pipe..basic_writable_pipe..basic_writable_pipe] 
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] without opening it. 
-
-
-  explicit ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload1 basic_writable_pipe]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload2 basic_writable_pipe]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload2 more...]]``
-
-
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] on an existing native pipe. 
-
-
-  ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload3 basic_writable_pipe]``(
-      const executor_type & ex,
-      const native_handle_type & native_pipe);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload4 basic_writable_pipe]``(
-      ExecutionContext & context,
-      const native_handle_type & native_pipe,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload4 more...]]``
-
-
-Move-construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from another. 
-
-
-  ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload5 basic_writable_pipe]``(
-      basic_writable_pipe && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload5 more...]]``
-
-
-Move-construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.basic_writable_pipe.basic_writable_pipe.overload6 basic_writable_pipe]``(
-      basic_writable_pipe< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.basic_writable_pipe.overload6 more...]]``
-
-
-[section:overload1 basic_writable_pipe::basic_writable_pipe (1 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] without opening it. 
-
-
-  basic_writable_pipe(
-      const executor_type & ex);
-
-
-This constructor creates a pipe without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::basic_writable_pipe (2 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_writable_pipe(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a pipe without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 basic_writable_pipe::basic_writable_pipe (3 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] on an existing native pipe. 
-
-
-  basic_writable_pipe(
-      const executor_type & ex,
-      const native_handle_type & native_pipe);
-
-
-This constructor creates a pipe object to hold an existing native pipe.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe.]]
-
-[[native_pipe][A native pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 basic_writable_pipe::basic_writable_pipe (4 of 6 overloads)]
-
-
-Construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] on an existing native pipe. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_writable_pipe(
-      ExecutionContext & context,
-      const native_handle_type & native_pipe,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a pipe object to hold an existing native pipe.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the pipe will use, by default, to dispatch handlers for any asynchronous operations performed on the pipe.]]
-
-[[native_pipe][A native pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 basic_writable_pipe::basic_writable_pipe (5 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from another. 
-
-
-  basic_writable_pipe(
-      basic_writable_pipe && other);
-
-
-This constructor moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_writable_pipe `basic_writable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_writable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 basic_writable_pipe::basic_writable_pipe (6 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_writable_pipe(
-      basic_writable_pipe< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_writable_pipe `basic_writable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_writable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel basic_writable_pipe::cancel]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.cancel..cancel..basic_writable_pipe] 
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void ``[link asio.reference.basic_writable_pipe.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.basic_writable_pipe.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.cancel.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the pipe. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close basic_writable_pipe::close]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.close..close..basic_writable_pipe] 
-Close the pipe. 
-
-
-  void ``[link asio.reference.basic_writable_pipe.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.close.overload1 more...]]``
-
-  void ``[link asio.reference.basic_writable_pipe.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.close.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::close (1 of 2 overloads)]
-
-
-Close the pipe. 
-
-
-  void close();
-
-
-This function is used to close the pipe. Any asynchronous write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::close (2 of 2 overloads)]
-
-
-Close the pipe. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the pipe. Any asynchronous write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type basic_writable_pipe::executor_type]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.executor_type..executor_type..basic_writable_pipe] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor basic_writable_pipe::get_executor]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.get_executor..get_executor..basic_writable_pipe] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open basic_writable_pipe::is_open]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.is_open..is_open..basic_writable_pipe] 
-Determine whether the pipe is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer basic_writable_pipe::lowest_layer]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.lowest_layer..lowest_layer..basic_writable_pipe] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.basic_writable_pipe.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.basic_writable_pipe.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type basic_writable_pipe::lowest_layer_type]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.lowest_layer_type..lowest_layer_type..basic_writable_pipe] 
-A [link asio.reference.basic_writable_pipe `basic_writable_pipe`] is always the lowest layer. 
-
-
-  typedef basic_writable_pipe lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_writable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_writable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.basic_writable_pipe [*basic_writable_pipe]] [constructor]]
-    [Construct a basic_writable_pipe without opening it. 
-     [hr]
-     Construct a basic_writable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_writable_pipe from another. 
-     [hr]
-     Move-construct a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_writable_pipe from another. 
-     [hr]
-     Move-assign a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.write_some [*write_some]]]
-    [Write some data to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe._basic_writable_pipe [*~basic_writable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_writable_pipe `basic_writable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle basic_writable_pipe::native_handle]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.native_handle..native_handle..basic_writable_pipe] 
-Get the native pipe representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the pipe. This is intended to allow access to native pipe functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type basic_writable_pipe::native_handle_type]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.native_handle_type..native_handle_type..basic_writable_pipe] 
-The native representation of a pipe. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ basic_writable_pipe::operator=]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.operator_eq_..operator=..basic_writable_pipe] 
-Move-assign a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from another. 
-
-
-  basic_writable_pipe & ``[link asio.reference.basic_writable_pipe.operator_eq_.overload1 operator=]``(
-      basic_writable_pipe && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_writable_pipe & > ``[link asio.reference.basic_writable_pipe.operator_eq_.overload2 operator=]``(
-      basic_writable_pipe< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from another. 
-
-
-  basic_writable_pipe & operator=(
-      basic_writable_pipe && other);
-
-
-This assignment operator moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_writable_pipe `basic_writable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_writable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.basic_writable_pipe `basic_writable_pipe`] from a pipe of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_writable_pipe & > operator=(
-      basic_writable_pipe< Executor1 > && other);
-
-
-This assignment operator moves a pipe from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.basic_writable_pipe `basic_writable_pipe`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_writable_pipe(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:release basic_writable_pipe::release]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.release..release..basic_writable_pipe] 
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type ``[link asio.reference.basic_writable_pipe.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.basic_writable_pipe.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.release.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native pipe is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native pipe. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native pipe is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some basic_writable_pipe::write_some]
-
-[indexterm2 asio.indexterm.basic_writable_pipe.write_some..write_some..basic_writable_pipe] 
-Write some data to the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_writable_pipe.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.basic_writable_pipe.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.basic_writable_pipe.write_some.overload2 more...]]``
-
-
-[section:overload1 basic_writable_pipe::write_some (1 of 2 overloads)]
-
-
-Write some data to the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the pipe. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the pipe.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  pipe.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_writable_pipe::write_some (2 of 2 overloads)]
-
-
-Write some data to the pipe. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the pipe. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the pipe.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_writable_pipe basic_writable_pipe::~basic_writable_pipe]
-
-[indexterm2 asio.indexterm.basic_writable_pipe._basic_writable_pipe..~basic_writable_pipe..basic_writable_pipe] 
-Destroys the pipe. 
-
-
-  ~basic_writable_pipe();
-
-
-This function destroys the pipe, cancelling any outstanding asynchronous wait operations associated with the pipe as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_writable_pipe__rebind_executor basic_writable_pipe::rebind_executor]
-
-[indexterm1 asio.indexterm.basic_writable_pipe__rebind_executor..basic_writable_pipe::rebind_executor]
-
-
-Rebinds the pipe type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe__rebind_executor.other [*other]]]
-    [The pipe type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other basic_writable_pipe::rebind_executor::other]
-
-[indexterm2 asio.indexterm.basic_writable_pipe__rebind_executor.other..other..basic_writable_pipe::rebind_executor] 
-The pipe type when rebound to the specified executor. 
-
-
-  typedef basic_writable_pipe< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_writable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_writable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.basic_writable_pipe [*basic_writable_pipe]] [constructor]]
-    [Construct a basic_writable_pipe without opening it. 
-     [hr]
-     Construct a basic_writable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_writable_pipe from another. 
-     [hr]
-     Move-construct a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_writable_pipe from another. 
-     [hr]
-     Move-assign a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.write_some [*write_some]]]
-    [Write some data to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe._basic_writable_pipe [*~basic_writable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_writable_pipe `basic_writable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/basic_writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:basic_yield_context basic_yield_context]
-
-[indexterm1 asio.indexterm.basic_yield_context..basic_yield_context]
-
-
-A [link asio.overview.model.completion_tokens completion token] that represents the currently executing coroutine. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_yield_context
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_yield_context.cancellation_slot_type [*cancellation_slot_type]]]
-    [The cancellation slot type associated with the yield context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_yield_context.executor_type [*executor_type]]]
-    [The executor type associated with the yield context. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_yield_context.basic_yield_context [*basic_yield_context]] [constructor]]
-    [Construct a yield context from another yield context type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.cancelled [*cancelled]]]
-    [Determine whether the current coroutine has been cancelled. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_cancellation_slot [*get_cancellation_slot]]]
-    [Get the cancellation slot associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_cancellation_state [*get_cancellation_state]]]
-    [Get the cancellation state associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_executor [*get_executor]]]
-    [Get the executor associated with the yield context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.operator_lb__rb_ [*operator\[\]]]]
-    [Return a yield context that sets the specified error_code. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.reset_cancellation_state [*reset_cancellation_state]]]
-    [Reset the cancellation state associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.throw_if_cancelled [*throw_if_cancelled]]]
-    [Determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-     [hr]
-     Set whether the coroutine throws if trying to suspend when it has been cancelled. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_yield_context `basic_yield_context`] class is a completion token type that is used to represent the currently executing stackful coroutine. A [link asio.reference.basic_yield_context `basic_yield_context`] object may be passed as a completion token to an asynchronous operation. For example:
-
-
-
-  template <typename Executor>
-  void my_coroutine(basic_yield_context<Executor> yield)
-  {
-    ...
-    std::size_t n = my_socket.async_read_some(buffer, yield);
-    ...
-  } 
-
-
-
-
-The initiating function (async\_read\_some in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned. 
-
-[heading Requirements]
-
-['Header: ][^asio/spawn.hpp]
-
-['Convenience header: ]None
-
-
-[section:basic_yield_context basic_yield_context::basic_yield_context]
-
-[indexterm2 asio.indexterm.basic_yield_context.basic_yield_context..basic_yield_context..basic_yield_context] 
-Construct a yield context from another yield context type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  basic_yield_context(
-      const basic_yield_context< OtherExecutor > & other,
-      constraint_t< is_convertible< OtherExecutor, Executor >::value >  = 0);
-
-
-Requires that OtherExecutor be convertible to Executor. 
-
-
-[endsect]
-
-
-
-[section:cancellation_slot_type basic_yield_context::cancellation_slot_type]
-
-[indexterm2 asio.indexterm.basic_yield_context.cancellation_slot_type..cancellation_slot_type..basic_yield_context] 
-The cancellation slot type associated with the yield context. 
-
-
-  typedef cancellation_slot cancellation_slot_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.assign [*assign]]]
-    [Installs a handler into the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.cancellation_slot [*cancellation_slot]] [constructor]]
-    [Creates a slot that is not connected to any cancellation signal. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.clear [*clear]]]
-    [Clears the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.emplace [*emplace]]]
-    [Installs a handler into the slot, constructing the new object directly. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.has_handler [*has_handler]]]
-    [Returns whether the slot is connected and has an installed handler. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.is_connected [*is_connected]]]
-    [Returns whether the slot is connected to a signal. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.operator_not__eq_ [*operator!=]]]
-    [Compare two slots for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.operator_eq__eq_ [*operator==]]]
-    [Compare two slots for equality. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/spawn.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:cancelled basic_yield_context::cancelled]
-
-[indexterm2 asio.indexterm.basic_yield_context.cancelled..cancelled..basic_yield_context] 
-Determine whether the current coroutine has been cancelled. 
-
-
-  cancellation_type_t cancelled() const;
-
-
-
-[endsect]
-
-
-
-[section:executor_type basic_yield_context::executor_type]
-
-[indexterm2 asio.indexterm.basic_yield_context.executor_type..executor_type..basic_yield_context] 
-The executor type associated with the yield context. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/spawn.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:get_cancellation_slot basic_yield_context::get_cancellation_slot]
-
-[indexterm2 asio.indexterm.basic_yield_context.get_cancellation_slot..get_cancellation_slot..basic_yield_context] 
-Get the cancellation slot associated with the coroutine. 
-
-
-  cancellation_slot_type get_cancellation_slot() const;
-
-
-
-[endsect]
-
-
-
-[section:get_cancellation_state basic_yield_context::get_cancellation_state]
-
-[indexterm2 asio.indexterm.basic_yield_context.get_cancellation_state..get_cancellation_state..basic_yield_context] 
-Get the cancellation state associated with the coroutine. 
-
-
-  cancellation_state get_cancellation_state() const;
-
-
-
-[endsect]
-
-
-
-[section:get_executor basic_yield_context::get_executor]
-
-[indexterm2 asio.indexterm.basic_yield_context.get_executor..get_executor..basic_yield_context] 
-Get the executor associated with the yield context. 
-
-
-  executor_type get_executor() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_lb__rb_ basic_yield_context::operator\[\]]
-
-[indexterm2 asio.indexterm.basic_yield_context.operator_lb__rb_..operator\[\]..basic_yield_context] 
-Return a yield context that sets the specified error\_code. 
-
-
-  basic_yield_context operator[](
-      asio::error_code & ec) const;
-
-
-By default, when a yield context is used with an asynchronous operation, a non-success error\_code is converted to system\_error and thrown. This operator may be used to specify an error\_code object that should instead be set with the asynchronous operation's result. For example:
-
-
-
-  template <typename Executor>
-  void my_coroutine(basic_yield_context<Executor> yield)
-  {
-    ...
-    std::size_t n = my_socket.async_read_some(buffer, yield[ec]);
-    if (ec)
-    {
-      // An error occurred.
-    }
-    ...
-  } 
-
-
-
-
-
-[endsect]
-
-
-[section:reset_cancellation_state basic_yield_context::reset_cancellation_state]
-
-[indexterm2 asio.indexterm.basic_yield_context.reset_cancellation_state..reset_cancellation_state..basic_yield_context] 
-Reset the cancellation state associated with the coroutine. 
-
-
-  void ``[link asio.reference.basic_yield_context.reset_cancellation_state.overload1 reset_cancellation_state]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_yield_context.reset_cancellation_state.overload1 more...]]``
-
-  template<
-      typename Filter>
-  void ``[link asio.reference.basic_yield_context.reset_cancellation_state.overload2 reset_cancellation_state]``(
-      Filter && filter) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_yield_context.reset_cancellation_state.overload2 more...]]``
-
-  template<
-      typename InFilter,
-      typename OutFilter>
-  void ``[link asio.reference.basic_yield_context.reset_cancellation_state.overload3 reset_cancellation_state]``(
-      InFilter && in_filter,
-      OutFilter && out_filter) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_yield_context.reset_cancellation_state.overload3 more...]]``
-
-
-[section:overload1 basic_yield_context::reset_cancellation_state (1 of 3 overloads)]
-
-
-Reset the cancellation state associated with the coroutine. 
-
-
-  void reset_cancellation_state() const;
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.spawn `spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P)`, into the current coroutine's cancellation state object. 
-
-
-[endsect]
-
-
-
-[section:overload2 basic_yield_context::reset_cancellation_state (2 of 3 overloads)]
-
-
-Reset the cancellation state associated with the coroutine. 
-
-
-  template<
-      typename Filter>
-  void reset_cancellation_state(
-      Filter && filter) const;
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.spawn `spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P,
-std::forward<Filter>(filter))`, into the current coroutine's cancellation state object. 
-
-
-[endsect]
-
-
-
-[section:overload3 basic_yield_context::reset_cancellation_state (3 of 3 overloads)]
-
-
-Reset the cancellation state associated with the coroutine. 
-
-
-  template<
-      typename InFilter,
-      typename OutFilter>
-  void reset_cancellation_state(
-      InFilter && in_filter,
-      OutFilter && out_filter) const;
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.spawn `spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P, std::forward<InFilter>(in_filter), std::forward<OutFilter>(out_filter))`, into the current coroutine's cancellation state object. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:throw_if_cancelled basic_yield_context::throw_if_cancelled]
-
-[indexterm2 asio.indexterm.basic_yield_context.throw_if_cancelled..throw_if_cancelled..basic_yield_context] 
-Determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  bool ``[link asio.reference.basic_yield_context.throw_if_cancelled.overload1 throw_if_cancelled]``() const;
-  ``  [''''&raquo;''' [link asio.reference.basic_yield_context.throw_if_cancelled.overload1 more...]]``
-
-
-Set whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  void ``[link asio.reference.basic_yield_context.throw_if_cancelled.overload2 throw_if_cancelled]``(
-      bool value) const;
-  ``  [''''&raquo;''' [link asio.reference.basic_yield_context.throw_if_cancelled.overload2 more...]]``
-
-
-[section:overload1 basic_yield_context::throw_if_cancelled (1 of 2 overloads)]
-
-
-Determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  bool throw_if_cancelled() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 basic_yield_context::throw_if_cancelled (2 of 2 overloads)]
-
-
-Set whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  void throw_if_cancelled(
-      bool value) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind_allocator bind_allocator]
-
-[indexterm1 asio.indexterm.bind_allocator..bind_allocator]
-
-Create a partial completion token that associates an allocator. 
-
-  template<
-      typename Allocator>
-  partial_allocator_binder< Allocator > ``[link asio.reference.bind_allocator.overload1 bind_allocator]``(
-      const Allocator & ex);
-  ``  [''''&raquo;''' [link asio.reference.bind_allocator.overload1 more...]]``
-
-Associate an object of type `T` with an allocator of type `Allocator`. 
-
-  template<
-      typename Allocator,
-      typename T>
-  allocator_binder< decay_t< T >, Allocator > ``[link asio.reference.bind_allocator.overload2 bind_allocator]``(
-      const Allocator & s,
-      T && t);
-  ``  [''''&raquo;''' [link asio.reference.bind_allocator.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 bind_allocator (1 of 2 overloads)]
-
-
-Create a partial completion token that associates an allocator. 
-
-
-  template<
-      typename Allocator>
-  partial_allocator_binder< Allocator > bind_allocator(
-      const Allocator & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 bind_allocator (2 of 2 overloads)]
-
-
-Associate an object of type `T` with an allocator of type `Allocator`. 
-
-
-  template<
-      typename Allocator,
-      typename T>
-  allocator_binder< decay_t< T >, Allocator > bind_allocator(
-      const Allocator & s,
-      T && t);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind_cancellation_slot bind_cancellation_slot]
-
-[indexterm1 asio.indexterm.bind_cancellation_slot..bind_cancellation_slot]
-
-Create a partial completion token that associates a cancellation slot. 
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  partial_cancellation_slot_binder< CancellationSlot > ``[link asio.reference.bind_cancellation_slot.overload1 bind_cancellation_slot]``(
-      const CancellationSlot & ex);
-  ``  [''''&raquo;''' [link asio.reference.bind_cancellation_slot.overload1 more...]]``
-
-Associate an object of type `T` with a cancellation slot of type `CancellationSlot`. 
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename T>
-  cancellation_slot_binder< decay_t< T >, CancellationSlot > ``[link asio.reference.bind_cancellation_slot.overload2 bind_cancellation_slot]``(
-      const CancellationSlot & s,
-      T && t);
-  ``  [''''&raquo;''' [link asio.reference.bind_cancellation_slot.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 bind_cancellation_slot (1 of 2 overloads)]
-
-
-Create a partial completion token that associates a cancellation slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  partial_cancellation_slot_binder< CancellationSlot > bind_cancellation_slot(
-      const CancellationSlot & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 bind_cancellation_slot (2 of 2 overloads)]
-
-
-Associate an object of type `T` with a cancellation slot of type `CancellationSlot`. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename T>
-  cancellation_slot_binder< decay_t< T >, CancellationSlot > bind_cancellation_slot(
-      const CancellationSlot & s,
-      T && t);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind_executor bind_executor]
-
-[indexterm1 asio.indexterm.bind_executor..bind_executor]
-
-Create a partial completion token that associates an executor. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  partial_executor_binder< Executor > ``[link asio.reference.bind_executor.overload1 bind_executor]``(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.bind_executor.overload1 more...]]``
-
-Associate an object of type `T` with an executor of type `Executor`. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T>
-  executor_binder< decay_t< T >, Executor > ``[link asio.reference.bind_executor.overload2 bind_executor]``(
-      const Executor & ex,
-      T && t,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.bind_executor.overload2 more...]]``
-
-Create a partial completion token that associates an execution context's executor. 
-
-  template<
-      typename ExecutionContext>
-  partial_executor_binder< typename ExecutionContext::executor_type > ``[link asio.reference.bind_executor.overload3 bind_executor]``(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.bind_executor.overload3 more...]]``
-
-Associate an object of type `T` with an execution context's executor. 
-
-  template<
-      typename ExecutionContext,
-      typename T>
-  executor_binder< decay_t< T >, typename ExecutionContext::executor_type > ``[link asio.reference.bind_executor.overload4 bind_executor]``(
-      ExecutionContext & ctx,
-      T && t,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.bind_executor.overload4 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 bind_executor (1 of 4 overloads)]
-
-
-Create a partial completion token that associates an executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  partial_executor_binder< Executor > bind_executor(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 bind_executor (2 of 4 overloads)]
-
-
-Associate an object of type `T` with an executor of type `Executor`. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T>
-  executor_binder< decay_t< T >, Executor > bind_executor(
-      const Executor & ex,
-      T && t,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 bind_executor (3 of 4 overloads)]
-
-
-Create a partial completion token that associates an execution context's executor. 
-
-
-  template<
-      typename ExecutionContext>
-  partial_executor_binder< typename ExecutionContext::executor_type > bind_executor(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload4 bind_executor (4 of 4 overloads)]
-
-
-Associate an object of type `T` with an execution context's executor. 
-
-
-  template<
-      typename ExecutionContext,
-      typename T>
-  executor_binder< decay_t< T >, typename ExecutionContext::executor_type > bind_executor(
-      ExecutionContext & ctx,
-      T && t,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:bind_immediate_executor bind_immediate_executor]
-
-[indexterm1 asio.indexterm.bind_immediate_executor..bind_immediate_executor]
-
-Create a partial completion token that associates an executor. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  partial_immediate_executor_binder< Executor > ``[link asio.reference.bind_immediate_executor.overload1 bind_immediate_executor]``(
-      const Executor & ex);
-  ``  [''''&raquo;''' [link asio.reference.bind_immediate_executor.overload1 more...]]``
-
-Associate an object of type `T` with a immediate executor of type `Executor`. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T>
-  immediate_executor_binder< decay_t< T >, Executor > ``[link asio.reference.bind_immediate_executor.overload2 bind_immediate_executor]``(
-      const Executor & e,
-      T && t);
-  ``  [''''&raquo;''' [link asio.reference.bind_immediate_executor.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 bind_immediate_executor (1 of 2 overloads)]
-
-
-Create a partial completion token that associates an executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  partial_immediate_executor_binder< Executor > bind_immediate_executor(
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 bind_immediate_executor (2 of 2 overloads)]
-
-
-Associate an object of type `T` with a immediate executor of type `Executor`. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T>
-  immediate_executor_binder< decay_t< T >, Executor > bind_immediate_executor(
-      const Executor & e,
-      T && t);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer buffer]
-
-[indexterm1 asio.indexterm.buffer..buffer]
-
-The [link asio.reference.buffer `buffer`] function is used to create a buffer object to represent raw memory, an array of POD elements, a vector of POD elements, or a std::string. 
-
-
-Create a new modifiable buffer from an existing buffer. 
-
-  mutable_buffer ``[link asio.reference.buffer.overload1 buffer]``(
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload1 more...]]``
-
-  mutable_buffer ``[link asio.reference.buffer.overload2 buffer]``(
-      const mutable_buffer & b,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload2 more...]]``
-
-Create a new non-modifiable buffer from an existing buffer. 
-
-  const_buffer ``[link asio.reference.buffer.overload3 buffer]``(
-      const const_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload3 more...]]``
-
-  const_buffer ``[link asio.reference.buffer.overload4 buffer]``(
-      const const_buffer & b,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload4 more...]]``
-
-Create a new modifiable buffer that represents the given memory range. 
-
-  mutable_buffer ``[link asio.reference.buffer.overload5 buffer]``(
-      void * data,
-      std::size_t size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload5 more...]]``
-
-Create a new non-modifiable buffer that represents the given memory range. 
-
-  const_buffer ``[link asio.reference.buffer.overload6 buffer]``(
-      const void * data,
-      std::size_t size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload6 more...]]``
-
-Create a new modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload7 buffer]``(
-      PodType((&data)[N]);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload7 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload8 buffer]``(
-      PodType((&data)[N],
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload8 more...]]``
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload9 buffer]``(
-      const PodType((&data)[N]);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload9 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload10 buffer]``(
-      const PodType((&data)[N],
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload10 more...]]``
-
-Create a new modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload11 buffer]``(
-      boost::array< PodType, N > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload11 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload12 buffer]``(
-      boost::array< PodType, N > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload12 more...]]``
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload13 buffer]``(
-      boost::array< const PodType, N > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload13 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload14 buffer]``(
-      boost::array< const PodType, N > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload14 more...]]``
-
-Create a new modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload15 buffer]``(
-      std::array< PodType, N > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload15 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer ``[link asio.reference.buffer.overload16 buffer]``(
-      std::array< PodType, N > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload16 more...]]``
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload17 buffer]``(
-      std::array< const PodType, N > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload17 more...]]``
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer ``[link asio.reference.buffer.overload18 buffer]``(
-      std::array< const PodType, N > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload18 more...]]``
-
-Create a new modifiable buffer that represents the given POD vector. 
-
-  template<
-      typename PodType,
-      typename Allocator>
-  mutable_buffer ``[link asio.reference.buffer.overload19 buffer]``(
-      std::vector< PodType, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload19 more...]]``
-
-  template<
-      typename PodType,
-      typename Allocator>
-  mutable_buffer ``[link asio.reference.buffer.overload20 buffer]``(
-      std::vector< PodType, Allocator > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload20 more...]]``
-
-Create a new non-modifiable buffer that represents the given POD vector. 
-
-  template<
-      typename PodType,
-      typename Allocator>
-  const_buffer ``[link asio.reference.buffer.overload21 buffer]``(
-      const std::vector< PodType, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload21 more...]]``
-
-  template<
-      typename PodType,
-      typename Allocator>
-  const_buffer ``[link asio.reference.buffer.overload22 buffer]``(
-      const std::vector< PodType, Allocator > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload22 more...]]``
-
-Create a new modifiable buffer that represents the given string. 
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  mutable_buffer ``[link asio.reference.buffer.overload23 buffer]``(
-      std::basic_string< Elem, Traits, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload23 more...]]``
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  mutable_buffer ``[link asio.reference.buffer.overload24 buffer]``(
-      std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload24 more...]]``
-
-Create a new non-modifiable buffer that represents the given string. 
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  const_buffer ``[link asio.reference.buffer.overload25 buffer]``(
-      const std::basic_string< Elem, Traits, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload25 more...]]``
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  const_buffer ``[link asio.reference.buffer.overload26 buffer]``(
-      const std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload26 more...]]``
-
-Create a new non-modifiable buffer that represents the given string\_view. 
-
-  template<
-      typename Elem,
-      typename Traits>
-  const_buffer ``[link asio.reference.buffer.overload27 buffer]``(
-      basic_string_view< Elem, Traits > data);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload27 more...]]``
-
-Create a new non-modifiable buffer that represents the given string. 
-
-  template<
-      typename Elem,
-      typename Traits>
-  const_buffer ``[link asio.reference.buffer.overload28 buffer]``(
-      basic_string_view< Elem, Traits > data,
-      std::size_t max_size_in_bytes);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload28 more...]]``
-
-Create a new modifiable buffer from a contiguous container. 
-
-  template<
-      typename T>
-  mutable_buffer ``[link asio.reference.buffer.overload29 buffer]``(
-      T & data,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload29 more...]]``
-
-  template<
-      typename T>
-  mutable_buffer ``[link asio.reference.buffer.overload30 buffer]``(
-      T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload30 more...]]``
-
-Create a new non-modifiable buffer from a contiguous container. 
-
-  template<
-      typename T>
-  const_buffer ``[link asio.reference.buffer.overload31 buffer]``(
-      T & data,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload31 more...]]``
-
-  template<
-      typename T>
-  const_buffer ``[link asio.reference.buffer.overload32 buffer]``(
-      T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload32 more...]]``
-
-  template<
-      typename T>
-  const_buffer ``[link asio.reference.buffer.overload33 buffer]``(
-      const T & data,
-      constraint_t< is_contiguous_iterator< typename T::const_iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload33 more...]]``
-
-  template<
-      typename T>
-  const_buffer ``[link asio.reference.buffer.overload34 buffer]``(
-      const T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::const_iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload34 more...]]``
-
-Obtain a buffer representing the entire registered buffer. 
-
-  mutable_registered_buffer ``[link asio.reference.buffer.overload35 buffer]``(
-      const mutable_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload35 more...]]``
-
-  const_registered_buffer ``[link asio.reference.buffer.overload36 buffer]``(
-      const const_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload36 more...]]``
-
-Obtain a buffer representing part of a registered buffer. 
-
-  mutable_registered_buffer ``[link asio.reference.buffer.overload37 buffer]``(
-      const mutable_registered_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload37 more...]]``
-
-  const_registered_buffer ``[link asio.reference.buffer.overload38 buffer]``(
-      const const_registered_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.buffer.overload38 more...]]``
-
-A buffer object represents a contiguous region of memory as a 2-tuple consisting of a pointer and size in bytes. A tuple of the form `{void*, size_t}` specifies a mutable (modifiable) region of memory. Similarly, a tuple of the form `{const void*, size_t}` specifies a const (non-modifiable) region of memory. These two forms correspond to the classes [link asio.reference.mutable_buffer `mutable_buffer`] and [link asio.reference.const_buffer `const_buffer`], respectively. To mirror C++'s conversion rules, a [link asio.reference.mutable_buffer `mutable_buffer`] is implicitly convertible to a [link asio.reference.const_buffer `const_buffer`], and the opposite conversion is not permitted.
-
-The simplest use case involves reading or writing a single buffer of a specified size:
-
-
-
-  sock.send(asio::buffer(data, size)); 
-
-
-
-
-In the above example, the return value of [link asio.reference.buffer `buffer`] meets the requirements of the ConstBufferSequence concept so that it may be directly passed to the socket's write function. A buffer created for modifiable memory also meets the requirements of the MutableBufferSequence concept.
-
-An individual buffer may be created from a builtin array, std::vector, std::array or boost::array of POD elements. This helps prevent buffer overruns by automatically determining the size of the buffer:
-
-
-
-  char d1[128];
-  size_t bytes_transferred = sock.receive(asio::buffer(d1));
-
-  std::vector<char> d2(128);
-  bytes_transferred = sock.receive(asio::buffer(d2));
-
-  std::array<char, 128> d3;
-  bytes_transferred = sock.receive(asio::buffer(d3));
-
-  boost::array<char, 128> d4;
-  bytes_transferred = sock.receive(asio::buffer(d4)); 
-
-
-
-
-In all three cases above, the buffers created are exactly 128 bytes long. Note that a vector is ['never] automatically resized when creating or using a buffer. The buffer size is determined using the vector's `size()` member function, and not its capacity.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-  asio::const_buffer b2 = ...;
-  std::size_t s2 = b2.size();
-  const void* p2 = b2.data(); 
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered.
-
-For convenience, a [link asio.reference.buffer_size `buffer_size`] function is provided that works with both buffers and buffer sequences (that is, types meeting the ConstBufferSequence or MutableBufferSequence type requirements). In this case, the function returns the total size of all buffers in the sequence.
-
-
-[heading Buffer Copying]
-  
-
-
-The [link asio.reference.buffer_copy `buffer_copy`] function may be used to copy raw bytes between individual buffers and buffer sequences.
-
-In particular, when used with the [link asio.reference.buffer_size `buffer_size`] function, the [link asio.reference.buffer_copy `buffer_copy`] function can be used to linearise a sequence of buffers. For example:
-
-
-
-  vector<const_buffer> buffers = ...;
-
-  vector<unsigned char> data(asio::buffer_size(buffers));
-  asio::buffer_copy(asio::buffer(data), buffers); 
-
-
-
-
-Note that [link asio.reference.buffer_copy `buffer_copy`] is implemented in terms of `memcpy`, and consequently it cannot be used to copy between overlapping memory regions.
-
-
-[heading Buffer Invalidation]
-  
-
-
-A buffer object does not have any ownership of the memory it refers to. It is the responsibility of the application to ensure the memory region remains valid until it is no longer required for an I/O operation. When the memory is no longer available, the buffer is said to have been invalidated.
-
-For the [link asio.reference.buffer `buffer`] overloads that accept an argument of type std::vector, the buffer objects returned are invalidated by any vector operation that also invalidates all references, pointers and iterators referring to the elements in the sequence (C++ Std, 23.2.4)
-
-For the [link asio.reference.buffer `buffer`] overloads that accept an argument of type std::basic\_string, the buffer objects returned are invalidated according to the rules defined for invalidation of references, pointers and iterators referring to elements of the sequence (C++ Std, 21.3).
-
-
-[heading Buffer Arithmetic]
-  
-
-
-Buffer objects may be manipulated using simple arithmetic in a safe way which helps prevent buffer overruns. Consider an array initialised as follows:
-
-
-
-  boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; 
-
-
-
-
-A buffer object `b1` created using:
-
-
-
-  b1 = asio::buffer(a); 
-
-
-
-
-represents the entire array, `{ 'a', 'b', 'c', 'd', 'e' }`. An optional second argument to the [link asio.reference.buffer `buffer`] function may be used to limit the size, in bytes, of the buffer:
-
-
-
-  b2 = asio::buffer(a, 3); 
-
-
-
-
-such that `b2` represents the data `{ 'a', 'b', 'c' }`. Even if the size argument exceeds the actual size of the array, the size of the buffer object created will be limited to the array size.
-
-An offset may be applied to an existing buffer to create a new one:
-
-
-
-  b3 = b1 + 2; 
-
-
-
-
-where `b3` will set to represent `{ 'c', 'd', 'e' }`. If the offset exceeds the size of the existing buffer, the newly created buffer will be empty.
-
-Both an offset and size may be specified to create a buffer that corresponds to a specific range of bytes within an existing buffer:
-
-
-
-  b4 = asio::buffer(b1 + 1, 3); 
-
-
-
-
-so that `b4` will refer to the bytes `{ 'b', 'c', 'd' }`.
-
-
-[heading Buffers and Scatter-Gather I/O]
-  
-
-
-To read or write using multiple buffers (i.e. scatter-gather I/O), multiple buffer objects may be assigned into a container that supports the MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts:
-
-
-
-  char d1[128];
-  std::vector<char> d2(128);
-  boost::array<char, 128> d3;
-
-  boost::array<mutable_buffer, 3> bufs1 = {
-    asio::buffer(d1),
-    asio::buffer(d2),
-    asio::buffer(d3) };
-  bytes_transferred = sock.receive(bufs1);
-
-  std::vector<const_buffer> bufs2;
-  bufs2.push_back(asio::buffer(d1));
-  bufs2.push_back(asio::buffer(d2));
-  bufs2.push_back(asio::buffer(d3));
-  bytes_transferred = sock.send(bufs2); 
-
-
-
-
-
-[heading Buffer Literals]
-  
-
-
-The `_buf` literal suffix, defined in namespace `asio::buffer_literals`, may be used to create `const_buffer` objects from string, binary integer, and hexadecimal integer literals. For example:
-
-
-
-  using namespace asio::buffer_literals;
-
-  asio::const_buffer b1 = "hello"_buf;
-  asio::const_buffer b2 = 0xdeadbeef_buf;
-  asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
-  asio::const_buffer b4 = 0b1010101011001100_buf; 
-
-
-
-
-Note that the memory associated with a buffer literal is valid for the lifetime of the program. This means that the buffer can be safely used with asynchronous operations. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer (1 of 38 overloads)]
-
-
-Create a new modifiable buffer from an existing buffer. 
-
-
-  mutable_buffer buffer(
-      const mutable_buffer & b);
-
-
-
-[heading Return Value]
-      
-`mutable_buffer(b)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer (2 of 38 overloads)]
-
-
-Create a new modifiable buffer from an existing buffer. 
-
-
-  mutable_buffer buffer(
-      const mutable_buffer & b,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     b.data(),
-     min(b.size(), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 buffer (3 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from an existing buffer. 
-
-
-  const_buffer buffer(
-      const const_buffer & b);
-
-
-
-[heading Return Value]
-      
-`const_buffer(b)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 buffer (4 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from an existing buffer. 
-
-
-  const_buffer buffer(
-      const const_buffer & b,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     b.data(),
-     min(b.size(), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 buffer (5 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given memory range. 
-
-
-  mutable_buffer buffer(
-      void * data,
-      std::size_t size_in_bytes);
-
-
-
-[heading Return Value]
-      
-`mutable_buffer(data, size_in_bytes)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 buffer (6 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given memory range. 
-
-
-  const_buffer buffer(
-      const void * data,
-      std::size_t size_in_bytes);
-
-
-
-[heading Return Value]
-      
-`const_buffer(data, size_in_bytes)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 buffer (7 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      PodType((&data)[N]);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     static_cast<void*>(data),
-     N * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 buffer (8 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      PodType((&data)[N],
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     static_cast<void*>(data),
-     min(N * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 buffer (9 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      const PodType((&data)[N]);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     static_cast<const void*>(data),
-     N * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 buffer (10 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      const PodType((&data)[N],
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     static_cast<const void*>(data),
-     min(N * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 buffer (11 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      boost::array< PodType, N > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.data(),
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 buffer (12 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      boost::array< PodType, N > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.data(),
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 buffer (13 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      boost::array< const PodType, N > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.data(),
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload14 buffer (14 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      boost::array< const PodType, N > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.data(),
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload15 buffer (15 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      std::array< PodType, N > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.data(),
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload16 buffer (16 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  mutable_buffer buffer(
-      std::array< PodType, N > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.data(),
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload17 buffer (17 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      std::array< const PodType, N > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.data(),
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload18 buffer (18 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD array. 
-
-
-  template<
-      typename PodType,
-      std::size_t N>
-  const_buffer buffer(
-      std::array< const PodType, N > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.data(),
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload19 buffer (19 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD vector. 
-
-
-  template<
-      typename PodType,
-      typename Allocator>
-  mutable_buffer buffer(
-      std::vector< PodType, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any vector operation that would also invalidate iterators. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload20 buffer (20 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given POD vector. 
-
-
-  template<
-      typename PodType,
-      typename Allocator>
-  mutable_buffer buffer(
-      std::vector< PodType, Allocator > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any vector operation that would also invalidate iterators. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload21 buffer (21 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD vector. 
-
-
-  template<
-      typename PodType,
-      typename Allocator>
-  const_buffer buffer(
-      const std::vector< PodType, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     data.size() * sizeof(PodType)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any vector operation that would also invalidate iterators. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload22 buffer (22 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given POD vector. 
-
-
-  template<
-      typename PodType,
-      typename Allocator>
-  const_buffer buffer(
-      const std::vector< PodType, Allocator > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     min(data.size() * sizeof(PodType), max_size_in_bytes)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any vector operation that would also invalidate iterators. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload23 buffer (23 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  mutable_buffer buffer(
-      std::basic_string< Elem, Traits, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-`mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(Elem))`.
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any non-const operation called on the given string object. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload24 buffer (24 of 38 overloads)]
-
-
-Create a new modifiable buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  mutable_buffer buffer(
-      std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     min(data.size() * sizeof(Elem), max_size_in_bytes)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any non-const operation called on the given string object. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload25 buffer (25 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  const_buffer buffer(
-      const std::basic_string< Elem, Traits, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-`const_buffer(data.data(), data.size() * sizeof(Elem))`.
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any non-const operation called on the given string object. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload26 buffer (26 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  const_buffer buffer(
-      const std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.data(),
-     min(data.size() * sizeof(Elem), max_size_in_bytes)); 
-
-
-
-
-
-[heading Remarks]
-      
-The buffer is invalidated by any non-const operation called on the given string object. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload27 buffer (27 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given string\_view. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  const_buffer buffer(
-      basic_string_view< Elem, Traits > data);
-
-
-
-[heading Return Value]
-      
-`mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(Elem))`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload28 buffer (28 of 38 overloads)]
-
-
-Create a new non-modifiable buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  const_buffer buffer(
-      basic_string_view< Elem, Traits > data,
-      std::size_t max_size_in_bytes);
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     min(data.size() * sizeof(Elem), max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload29 buffer (29 of 38 overloads)]
-
-
-Create a new modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  mutable_buffer buffer(
-      T & data,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     data.size() * sizeof(typename T::value_type)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload30 buffer (30 of 38 overloads)]
-
-
-Create a new modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  mutable_buffer buffer(
-      T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.mutable_buffer `mutable_buffer`] value equivalent to: 
-
-  mutable_buffer(
-     data.size() ? &data[0] : 0,
-     min(
-       data.size() * sizeof(typename T::value_type),
-       max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload31 buffer (31 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  const_buffer buffer(
-      T & data,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     data.size() * sizeof(typename T::value_type)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload32 buffer (32 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  const_buffer buffer(
-      T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< is_const< remove_reference_t< typename std::iterator_traits< typename T::iterator >::reference > >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     min(
-       data.size() * sizeof(typename T::value_type),
-       max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload33 buffer (33 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  const_buffer buffer(
-      const T & data,
-      constraint_t< is_contiguous_iterator< typename T::const_iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     data.size() * sizeof(typename T::value_type)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload34 buffer (34 of 38 overloads)]
-
-
-Create a new non-modifiable buffer from a contiguous container. 
-
-
-  template<
-      typename T>
-  const_buffer buffer(
-      const T & data,
-      std::size_t max_size_in_bytes,
-      constraint_t< is_contiguous_iterator< typename T::const_iterator >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, const_buffer >::value, defaulted_constraint >  = defaulted_constraint(),
-      constraint_t< !is_convertible< T, mutable_buffer >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-
-[heading Return Value]
-      
-A [link asio.reference.const_buffer `const_buffer`] value equivalent to: 
-
-  const_buffer(
-     data.size() ? &data[0] : 0,
-     min(
-       data.size() * sizeof(typename T::value_type),
-       max_size_in_bytes)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload35 buffer (35 of 38 overloads)]
-
-
-Obtain a buffer representing the entire registered buffer. 
-
-
-  mutable_registered_buffer buffer(
-      const mutable_registered_buffer & b);
-
-
-
-[endsect]
-
-
-
-[section:overload36 buffer (36 of 38 overloads)]
-
-
-Obtain a buffer representing the entire registered buffer. 
-
-
-  const_registered_buffer buffer(
-      const const_registered_buffer & b);
-
-
-
-[endsect]
-
-
-
-[section:overload37 buffer (37 of 38 overloads)]
-
-
-Obtain a buffer representing part of a registered buffer. 
-
-
-  mutable_registered_buffer buffer(
-      const mutable_registered_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload38 buffer (38 of 38 overloads)]
-
-
-Obtain a buffer representing part of a registered buffer. 
-
-
-  const_registered_buffer buffer(
-      const const_registered_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer_cast buffer_cast]
-
-[indexterm1 asio.indexterm.buffer_cast..buffer_cast]
-
-(Deprecated: Use the `data()` member function.) The [link asio.reference.buffer_cast `buffer_cast`] function is used to obtain a pointer to the underlying memory region associated with a buffer. 
-
-
-Cast a non-modifiable buffer to a specified pointer to POD type. 
-
-  template<
-      typename PointerToPodType>
-  PointerToPodType ``[link asio.reference.buffer_cast.overload1 buffer_cast]``(
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_cast.overload1 more...]]``
-
-  template<
-      typename PointerToPodType>
-  PointerToPodType ``[link asio.reference.buffer_cast.overload2 buffer_cast]``(
-      const const_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_cast.overload2 more...]]``
-
-
-[heading Examples:]
-  
-
-
-To access the memory of a non-modifiable buffer, use: 
-
-  asio::const_buffer b1 = ...;
-  const unsigned char* p1 = asio::buffer_cast<const unsigned char*>(b1);
-
-
-
-
-To access the memory of a modifiable buffer, use: 
-
-  asio::mutable_buffer b2 = ...;
-  unsigned char* p2 = asio::buffer_cast<unsigned char*>(b2);
-
-
-
-
-The [link asio.reference.buffer_cast `buffer_cast`] function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer_cast (1 of 2 overloads)]
-
-
-Cast a non-modifiable buffer to a specified pointer to POD type. 
-
-
-  template<
-      typename PointerToPodType>
-  PointerToPodType buffer_cast(
-      const mutable_buffer & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_cast (2 of 2 overloads)]
-
-
-Cast a non-modifiable buffer to a specified pointer to POD type. 
-
-
-  template<
-      typename PointerToPodType>
-  PointerToPodType buffer_cast(
-      const const_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer_copy buffer_copy]
-
-[indexterm1 asio.indexterm.buffer_copy..buffer_copy]
-
-The [link asio.reference.buffer_copy `buffer_copy`] function is used to copy bytes from a source buffer (or buffer sequence) to a target buffer (or buffer sequence). 
-
-
-Copies bytes from a source buffer sequence to a target buffer sequence. 
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffer_copy.overload1 buffer_copy]``(
-      const MutableBufferSequence & target,
-      const ConstBufferSequence & source);
-  ``  [''''&raquo;''' [link asio.reference.buffer_copy.overload1 more...]]``
-
-Copies a limited number of bytes from a source buffer sequence to a target buffer sequence. 
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffer_copy.overload2 buffer_copy]``(
-      const MutableBufferSequence & target,
-      const ConstBufferSequence & source,
-      std::size_t max_bytes_to_copy);
-  ``  [''''&raquo;''' [link asio.reference.buffer_copy.overload2 more...]]``
-
-The `buffer_copy` function is available in two forms:
-
-
-* A 2-argument form: `buffer_copy(target, source)` 
-
-
-* A 3-argument form: `buffer_copy(target, source, max_bytes_to_copy)` 
-
-Both forms return the number of bytes actually copied. The number of bytes copied is the lesser of:
-
-
-* `buffer_size(target)` 
-
-
-* `buffer_size(source)` 
-
-
-* `If` specified, `max_bytes_to_copy`.
-
-This prevents buffer overflow, regardless of the buffer sizes used in the copy operation.
-
-Note that [link asio.reference.buffer_copy `buffer_copy`] is implemented in terms of `memcpy`, and consequently it cannot be used to copy between overlapping memory regions. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer_copy (1 of 2 overloads)]
-
-
-Copies bytes from a source buffer sequence to a target buffer sequence. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t buffer_copy(
-      const MutableBufferSequence & target,
-      const ConstBufferSequence & source);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[target][A modifiable buffer sequence representing the memory regions to which the bytes will be copied.]]
-
-[[source][A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes copied.
-
-
-[heading Remarks]
-      
-The number of bytes copied is the lesser of:
-
-
-* `buffer_size(target)` 
-
-
-* `buffer_size(source)` 
-
-This function is implemented in terms of `memcpy`, and consequently it cannot be used to copy between overlapping memory regions. 
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_copy (2 of 2 overloads)]
-
-
-Copies a limited number of bytes from a source buffer sequence to a target buffer sequence. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t buffer_copy(
-      const MutableBufferSequence & target,
-      const ConstBufferSequence & source,
-      std::size_t max_bytes_to_copy);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[target][A modifiable buffer sequence representing the memory regions to which the bytes will be copied.]]
-
-[[source][A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.]]
-
-[[max_bytes_to_copy][The maximum number of bytes to be copied.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes copied.
-
-
-[heading Remarks]
-      
-The number of bytes copied is the lesser of:
-
-
-* `buffer_size(target)` 
-
-
-* `buffer_size(source)` 
-
-
-* `max_bytes_to_copy` 
-
-This function is implemented in terms of `memcpy`, and consequently it cannot be used to copy between overlapping memory regions. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer_literals__operator_quot__quot__buf buffer_literals::operator""_buf]
-
-[indexterm1 asio.indexterm.buffer_literals__operator_quot__quot__buf..buffer_literals::operator""_buf]
-
-Literal operator for creating [link asio.reference.const_buffer `const_buffer`] objects from string literals. 
-
-  const_buffer ``[link asio.reference.buffer_literals__operator_quot__quot__buf.overload1 operator""_buf]``(
-      const char * data,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.buffer_literals__operator_quot__quot__buf.overload1 more...]]``
-
-Literal operator for creating [link asio.reference.const_buffer `const_buffer`] objects from unbounded binary or hexadecimal integer literals. 
-
-  template<
-      char... Chars>
-  const_buffer ``[link asio.reference.buffer_literals__operator_quot__quot__buf.overload2 operator""_buf]``();
-  ``  [''''&raquo;''' [link asio.reference.buffer_literals__operator_quot__quot__buf.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer_literals::operator""_buf (1 of 2 overloads)]
-
-
-Literal operator for creating [link asio.reference.const_buffer `const_buffer`] objects from string literals. 
-
-
-  const_buffer operator""_buf(
-      const char * data,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_literals::operator""_buf (2 of 2 overloads)]
-
-
-Literal operator for creating [link asio.reference.const_buffer `const_buffer`] objects from unbounded binary or hexadecimal integer literals. 
-
-
-  template<
-      char... Chars>
-  const_buffer operator""_buf();
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer_registration buffer_registration]
-
-[indexterm1 asio.indexterm.buffer_registration..buffer_registration]
-
-
-Automatically registers and unregistered buffers with an execution context. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename Allocator = std::allocator<void>>
-  class buffer_registration
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.buffer_registration.allocator_type [*allocator_type]]]
-    [The allocator type used for allocating storage for the buffers container. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffer_registration.const_iterator [*const_iterator]]]
-    [The type of a const iterator over the registered buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffer_registration.iterator [*iterator]]]
-    [The type of an iterator over the registered buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffer_registration.at [*at]]]
-    [Get the buffer at the specified index. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.begin [*begin]]]
-    [Get the begin iterator for the sequence of registered buffers. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.buffer_registration [*buffer_registration]] [constructor]]
-    [Register buffers with an executor's execution context. 
-     [hr]
-     Register buffers with an execution context. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.cbegin [*cbegin]]]
-    [Get the begin iterator for the sequence of registered buffers. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.cend [*cend]]]
-    [Get the end iterator for the sequence of registered buffers. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.end [*end]]]
-    [Get the end iterator for the sequence of registered buffers. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.operator_eq_ [*operator=]]]
-    [Move assignment. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.operator_lb__rb_ [*operator\[\]]]]
-    [Get the buffer at the specified index. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration.size [*size]]]
-    [Get the number of registered buffers. ]
-  ]
-  
-  [
-    [[link asio.reference.buffer_registration._buffer_registration [*~buffer_registration]] [destructor]]
-    [Unregisters the buffers. ]
-  ]
-  
-]
-
-For portability, applications should assume that only one registration is permitted per execution context. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer_registration.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocator_type buffer_registration::allocator_type]
-
-[indexterm2 asio.indexterm.buffer_registration.allocator_type..allocator_type..buffer_registration] 
-The allocator type used for allocating storage for the buffers container. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer_registration.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:at buffer_registration::at]
-
-[indexterm2 asio.indexterm.buffer_registration.at..at..buffer_registration] 
-Get the buffer at the specified index. 
-
-
-  const mutable_registered_buffer & at(
-      std::size_t i);
-
-
-
-[endsect]
-
-
-
-[section:begin buffer_registration::begin]
-
-[indexterm2 asio.indexterm.buffer_registration.begin..begin..buffer_registration] 
-Get the begin iterator for the sequence of registered buffers. 
-
-
-  const_iterator begin() const;
-
-
-
-[endsect]
-
-
-[section:buffer_registration buffer_registration::buffer_registration]
-
-[indexterm2 asio.indexterm.buffer_registration.buffer_registration..buffer_registration..buffer_registration] 
-Register buffers with an executor's execution context. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.buffer_registration.buffer_registration.overload1 buffer_registration]``(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      const allocator_type & alloc = allocator_type(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_registration.buffer_registration.overload1 more...]]``
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.buffer_registration.buffer_registration.overload2 buffer_registration]``(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      const allocator_type & alloc = allocator_type(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_registration.buffer_registration.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.buffer_registration.buffer_registration.overload3 buffer_registration]``(
-      buffer_registration && other);
-  ``  [''''&raquo;''' [link asio.reference.buffer_registration.buffer_registration.overload3 more...]]``
-
-
-[section:overload1 buffer_registration::buffer_registration (1 of 3 overloads)]
-
-
-Register buffers with an executor's execution context. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  buffer_registration(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      const allocator_type & alloc = allocator_type(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_registration::buffer_registration (2 of 3 overloads)]
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ExecutionContext>
-  buffer_registration(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      const allocator_type & alloc = allocator_type(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 buffer_registration::buffer_registration (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  buffer_registration(
-      buffer_registration && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cbegin buffer_registration::cbegin]
-
-[indexterm2 asio.indexterm.buffer_registration.cbegin..cbegin..buffer_registration] 
-Get the begin iterator for the sequence of registered buffers. 
-
-
-  const_iterator cbegin() const;
-
-
-
-[endsect]
-
-
-
-[section:cend buffer_registration::cend]
-
-[indexterm2 asio.indexterm.buffer_registration.cend..cend..buffer_registration] 
-Get the end iterator for the sequence of registered buffers. 
-
-
-  const_iterator cend() const;
-
-
-
-[endsect]
-
-
-
-[section:const_iterator buffer_registration::const_iterator]
-
-[indexterm2 asio.indexterm.buffer_registration.const_iterator..const_iterator..buffer_registration] 
-The type of a const iterator over the registered buffers. 
-
-
-  typedef unspecified const_iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer_registration.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:end buffer_registration::end]
-
-[indexterm2 asio.indexterm.buffer_registration.end..end..buffer_registration] 
-Get the end iterator for the sequence of registered buffers. 
-
-
-  const_iterator end() const;
-
-
-
-[endsect]
-
-
-
-[section:iterator buffer_registration::iterator]
-
-[indexterm2 asio.indexterm.buffer_registration.iterator..iterator..buffer_registration] 
-The type of an iterator over the registered buffers. 
-
-
-  typedef unspecified iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer_registration.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ buffer_registration::operator=]
-
-[indexterm2 asio.indexterm.buffer_registration.operator_eq_..operator=..buffer_registration] 
-Move assignment. 
-
-
-  buffer_registration & operator=(
-      buffer_registration && other);
-
-
-
-[endsect]
-
-
-
-[section:operator_lb__rb_ buffer_registration::operator\[\]]
-
-[indexterm2 asio.indexterm.buffer_registration.operator_lb__rb_..operator\[\]..buffer_registration] 
-Get the buffer at the specified index. 
-
-
-  const mutable_registered_buffer & operator[](
-      std::size_t i);
-
-
-
-[endsect]
-
-
-
-[section:size buffer_registration::size]
-
-[indexterm2 asio.indexterm.buffer_registration.size..size..buffer_registration] 
-Get the number of registered buffers. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[section:_buffer_registration buffer_registration::~buffer_registration]
-
-[indexterm2 asio.indexterm.buffer_registration._buffer_registration..~buffer_registration..buffer_registration] 
-Unregisters the buffers. 
-
-
-  ~buffer_registration();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:buffer_sequence_begin buffer_sequence_begin]
-
-[indexterm1 asio.indexterm.buffer_sequence_begin..buffer_sequence_begin]
-
-The [link asio.reference.buffer_sequence_begin `buffer_sequence_begin`] function returns an iterator pointing to the first element in a buffer sequence. 
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-  template<
-      typename MutableBuffer>
-  const mutable_buffer * ``[link asio.reference.buffer_sequence_begin.overload1 buffer_sequence_begin]``(
-      const MutableBuffer & b,
-      constraint_t< is_convertible< const MutableBuffer *, const mutable_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload1 more...]]``
-
-  template<
-      typename ConstBuffer>
-  const const_buffer * ``[link asio.reference.buffer_sequence_begin.overload2 buffer_sequence_begin]``(
-      const ConstBuffer & b,
-      constraint_t< is_convertible< const ConstBuffer *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload2 more...]]``
-
-  template<
-      typename C>
-  auto ``[link asio.reference.buffer_sequence_begin.overload3 buffer_sequence_begin]``(
-      C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload3 more...]]``
-
-  template<
-      typename C>
-  auto ``[link asio.reference.buffer_sequence_begin.overload4 buffer_sequence_begin]``(
-      const C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload4 more...]]``
-
-Get an iterator to the first element in a buffer sequence. 
-
-  const mutable_buffer * ``[link asio.reference.buffer_sequence_begin.overload5 buffer_sequence_begin]``(
-      const mutable_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload5 more...]]``
-
-  const const_buffer * ``[link asio.reference.buffer_sequence_begin.overload6 buffer_sequence_begin]``(
-      const const_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_begin.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer_sequence_begin (1 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  template<
-      typename MutableBuffer>
-  const mutable_buffer * buffer_sequence_begin(
-      const MutableBuffer & b,
-      constraint_t< is_convertible< const MutableBuffer *, const mutable_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_sequence_begin (2 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  template<
-      typename ConstBuffer>
-  const const_buffer * buffer_sequence_begin(
-      const ConstBuffer & b,
-      constraint_t< is_convertible< const ConstBuffer *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 buffer_sequence_begin (3 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  template<
-      typename C>
-  auto buffer_sequence_begin(
-      C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload4 buffer_sequence_begin (4 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  template<
-      typename C>
-  auto buffer_sequence_begin(
-      const C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload5 buffer_sequence_begin (5 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  const mutable_buffer * buffer_sequence_begin(
-      const mutable_registered_buffer & b);
-
-
-
-[endsect]
-
-
-
-[section:overload6 buffer_sequence_begin (6 of 6 overloads)]
-
-
-Get an iterator to the first element in a buffer sequence. 
-
-
-  const const_buffer * buffer_sequence_begin(
-      const const_registered_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffer_sequence_end buffer_sequence_end]
-
-[indexterm1 asio.indexterm.buffer_sequence_end..buffer_sequence_end]
-
-The [link asio.reference.buffer_sequence_end `buffer_sequence_end`] function returns an iterator pointing to one past the end element in a buffer sequence. 
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-  template<
-      typename MutableBuffer>
-  const mutable_buffer * ``[link asio.reference.buffer_sequence_end.overload1 buffer_sequence_end]``(
-      const MutableBuffer & b,
-      constraint_t< is_convertible< const MutableBuffer *, const mutable_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload1 more...]]``
-
-  template<
-      typename ConstBuffer>
-  const const_buffer * ``[link asio.reference.buffer_sequence_end.overload2 buffer_sequence_end]``(
-      const ConstBuffer & b,
-      constraint_t< is_convertible< const ConstBuffer *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload2 more...]]``
-
-  template<
-      typename C>
-  auto ``[link asio.reference.buffer_sequence_end.overload3 buffer_sequence_end]``(
-      C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload3 more...]]``
-
-  template<
-      typename C>
-  auto ``[link asio.reference.buffer_sequence_end.overload4 buffer_sequence_end]``(
-      const C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload4 more...]]``
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-  const mutable_buffer * ``[link asio.reference.buffer_sequence_end.overload5 buffer_sequence_end]``(
-      const mutable_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload5 more...]]``
-
-  const const_buffer * ``[link asio.reference.buffer_sequence_end.overload6 buffer_sequence_end]``(
-      const const_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.buffer_sequence_end.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 buffer_sequence_end (1 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  template<
-      typename MutableBuffer>
-  const mutable_buffer * buffer_sequence_end(
-      const MutableBuffer & b,
-      constraint_t< is_convertible< const MutableBuffer *, const mutable_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffer_sequence_end (2 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  template<
-      typename ConstBuffer>
-  const const_buffer * buffer_sequence_end(
-      const ConstBuffer & b,
-      constraint_t< is_convertible< const ConstBuffer *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 buffer_sequence_end (3 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  template<
-      typename C>
-  auto buffer_sequence_end(
-      C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload4 buffer_sequence_end (4 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  template<
-      typename C>
-  auto buffer_sequence_end(
-      const C & c,
-      constraint_t< !is_convertible< const C *, const mutable_buffer * >::value &&!is_convertible< const C *, const const_buffer * >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload5 buffer_sequence_end (5 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  const mutable_buffer * buffer_sequence_end(
-      const mutable_registered_buffer & b);
-
-
-
-[endsect]
-
-
-
-[section:overload6 buffer_sequence_end (6 of 6 overloads)]
-
-
-Get an iterator to one past the end element in a buffer sequence. 
-
-
-  const const_buffer * buffer_sequence_end(
-      const const_registered_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:buffer_size buffer_size]
-
-[indexterm1 asio.indexterm.buffer_size..buffer_size]
-
-Get the total number of bytes in a buffer sequence. 
-
-
-  template<
-      typename BufferSequence>
-  std::size_t buffer_size(
-      const BufferSequence & b);
-
-
-The `buffer_size` function determines the total size of all buffers in the buffer sequence, as if computed as follows:
-
-
-
-  size_t total_size = 0;
-  auto i = asio::buffer_sequence_begin(buffers);
-  auto end = asio::buffer_sequence_end(buffers);
-  for (; i != end; ++i)
-  {
-    const_buffer b(*i);
-    total_size += b.size();
-  }
-  return total_size; 
-
-
-
-
-The `BufferSequence` template parameter may meet either of the `ConstBufferSequence` or `MutableBufferSequence` type requirements. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:buffered_read_stream buffered_read_stream]
-
-[indexterm1 asio.indexterm.buffered_read_stream..buffered_read_stream]
-
-
-Adds buffering to the read-related operations of a stream. 
-
-
-  template<
-      typename Stream>
-  class buffered_read_stream :
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.buffered_read_stream.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_read_stream.lowest_layer_type [*lowest_layer_type]]]
-    [The type of the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_read_stream.next_layer_type [*next_layer_type]]]
-    [The type of the next layer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffered_read_stream.async_fill [*async_fill]]]
-    [Start an asynchronous fill. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.buffered_read_stream [*buffered_read_stream]] [constructor]]
-    [Construct, passing the specified argument to initialise the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.close [*close]]]
-    [Close the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.fill [*fill]]]
-    [Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-     [hr]
-     Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.in_avail [*in_avail]]]
-    [Determine the amount of data that may be read without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.next_layer [*next_layer]]]
-    [Get a reference to the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.peek [*peek]]]
-    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.read_some [*read_some]]]
-    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_read_stream.write_some [*write_some]]]
-    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-     [hr]
-     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffered_read_stream.default_buffer_size [*default_buffer_size]] [static]]
-    [The default buffer size. ]
-  ]
-
-]
-
-The [link asio.reference.buffered_read_stream `buffered_read_stream`] class template can be used to add buffering to the synchronous and asynchronous read operations of a stream.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_read_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_fill buffered_read_stream::async_fill]
-
-[indexterm2 asio.indexterm.buffered_read_stream.async_fill..async_fill..buffered_read_stream] 
-Start an asynchronous fill. 
-
-
-  template<
-      typename ``[link asio.reference.ReadHandler ReadHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_fill(
-      ReadHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_read_some buffered_read_stream::async_read_some]
-
-[indexterm2 asio.indexterm.buffered_read_stream.async_read_some..async_read_some..buffered_read_stream] 
-Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadHandler ReadHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some buffered_read_stream::async_write_some]
-
-[indexterm2 asio.indexterm.buffered_read_stream.async_write_some..async_write_some..buffered_read_stream] 
-Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteHandler WriteHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[section:buffered_read_stream buffered_read_stream::buffered_read_stream]
-
-[indexterm2 asio.indexterm.buffered_read_stream.buffered_read_stream..buffered_read_stream..buffered_read_stream] 
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  explicit ``[link asio.reference.buffered_read_stream.buffered_read_stream.overload1 buffered_read_stream]``(
-      Arg && a);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.buffered_read_stream.overload1 more...]]``
-
-  template<
-      typename Arg>
-  ``[link asio.reference.buffered_read_stream.buffered_read_stream.overload2 buffered_read_stream]``(
-      Arg && a,
-      std::size_t buffer_size);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.buffered_read_stream.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::buffered_read_stream (1 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_read_stream(
-      Arg && a);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::buffered_read_stream (2 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_read_stream(
-      Arg && a,
-      std::size_t buffer_size);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close buffered_read_stream::close]
-
-[indexterm2 asio.indexterm.buffered_read_stream.close..close..buffered_read_stream] 
-Close the stream. 
-
-
-  void ``[link asio.reference.buffered_read_stream.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.close.overload1 more...]]``
-
-  void ``[link asio.reference.buffered_read_stream.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.close.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::close (1 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::close (2 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:default_buffer_size buffered_read_stream::default_buffer_size]
-
-[indexterm2 asio.indexterm.buffered_read_stream.default_buffer_size..default_buffer_size..buffered_read_stream] 
-The default buffer size. 
-
-
-  static const std::size_t default_buffer_size = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:executor_type buffered_read_stream::executor_type]
-
-[indexterm2 asio.indexterm.buffered_read_stream.executor_type..executor_type..buffered_read_stream] 
-The type of the executor associated with the object. 
-
-
-  typedef lowest_layer_type::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_read_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:fill buffered_read_stream::fill]
-
-[indexterm2 asio.indexterm.buffered_read_stream.fill..fill..buffered_read_stream] 
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-
-
-  std::size_t ``[link asio.reference.buffered_read_stream.fill.overload1 fill]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.fill.overload1 more...]]``
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 
-
-
-  std::size_t ``[link asio.reference.buffered_read_stream.fill.overload2 fill]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.fill.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::fill (1 of 2 overloads)]
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-
-
-  std::size_t fill();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::fill (2 of 2 overloads)]
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 
-
-
-  std::size_t fill(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor buffered_read_stream::get_executor]
-
-[indexterm2 asio.indexterm.buffered_read_stream.get_executor..get_executor..buffered_read_stream] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:in_avail buffered_read_stream::in_avail]
-
-[indexterm2 asio.indexterm.buffered_read_stream.in_avail..in_avail..buffered_read_stream] 
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t ``[link asio.reference.buffered_read_stream.in_avail.overload1 in_avail]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.in_avail.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.buffered_read_stream.in_avail.overload2 in_avail]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.in_avail.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::in_avail (1 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::in_avail (2 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer buffered_read_stream::lowest_layer]
-
-[indexterm2 asio.indexterm.buffered_read_stream.lowest_layer..lowest_layer..buffered_read_stream] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.buffered_read_stream.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.buffered_read_stream.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type buffered_read_stream::lowest_layer_type]
-
-[indexterm2 asio.indexterm.buffered_read_stream.lowest_layer_type..lowest_layer_type..buffered_read_stream] 
-The type of the lowest layer. 
-
-
-  typedef next_layer_type::lowest_layer_type lowest_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_read_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:next_layer buffered_read_stream::next_layer]
-
-[indexterm2 asio.indexterm.buffered_read_stream.next_layer..next_layer..buffered_read_stream] 
-Get a reference to the next layer. 
-
-
-  next_layer_type & next_layer();
-
-
-
-[endsect]
-
-
-
-[section:next_layer_type buffered_read_stream::next_layer_type]
-
-[indexterm2 asio.indexterm.buffered_read_stream.next_layer_type..next_layer_type..buffered_read_stream] 
-The type of the next layer. 
-
-
-  typedef remove_reference_t< Stream > next_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_read_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:peek buffered_read_stream::peek]
-
-[indexterm2 asio.indexterm.buffered_read_stream.peek..peek..buffered_read_stream] 
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.peek.overload1 peek]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.peek.overload1 more...]]``
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.peek.overload2 peek]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.peek.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::peek (1 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::peek (2 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some buffered_read_stream::read_some]
-
-[indexterm2 asio.indexterm.buffered_read_stream.read_some..read_some..buffered_read_stream] 
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.read_some.overload1 more...]]``
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.read_some.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::read_some (1 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::read_some (2 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some buffered_read_stream::write_some]
-
-[indexterm2 asio.indexterm.buffered_read_stream.write_some..write_some..buffered_read_stream] 
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.write_some.overload1 more...]]``
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_read_stream.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_read_stream.write_some.overload2 more...]]``
-
-
-[section:overload1 buffered_read_stream::write_some (1 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_read_stream::write_some (2 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffered_stream buffered_stream]
-
-[indexterm1 asio.indexterm.buffered_stream..buffered_stream]
-
-
-Adds buffering to the read- and write-related operations of a stream. 
-
-
-  template<
-      typename Stream>
-  class buffered_stream :
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.buffered_stream.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_stream.lowest_layer_type [*lowest_layer_type]]]
-    [The type of the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_stream.next_layer_type [*next_layer_type]]]
-    [The type of the next layer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffered_stream.async_fill [*async_fill]]]
-    [Start an asynchronous fill. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.async_flush [*async_flush]]]
-    [Start an asynchronous flush. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.buffered_stream [*buffered_stream]] [constructor]]
-    [Construct, passing the specified argument to initialise the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.close [*close]]]
-    [Close the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.fill [*fill]]]
-    [Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-     [hr]
-     Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.flush [*flush]]]
-    [Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-     [hr]
-     Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.in_avail [*in_avail]]]
-    [Determine the amount of data that may be read without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.next_layer [*next_layer]]]
-    [Get a reference to the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.peek [*peek]]]
-    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.read_some [*read_some]]]
-    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_stream.write_some [*write_some]]]
-    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-     [hr]
-     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. ]
-  ]
-  
-]
-
-The [link asio.reference.buffered_stream `buffered_stream`] class template can be used to add buffering to the synchronous and asynchronous read and write operations of a stream.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_fill buffered_stream::async_fill]
-
-[indexterm2 asio.indexterm.buffered_stream.async_fill..async_fill..buffered_stream] 
-Start an asynchronous fill. 
-
-
-  template<
-      typename ``[link asio.reference.ReadHandler ReadHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_fill(
-      ReadHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_flush buffered_stream::async_flush]
-
-[indexterm2 asio.indexterm.buffered_stream.async_flush..async_flush..buffered_stream] 
-Start an asynchronous flush. 
-
-
-  template<
-      typename ``[link asio.reference.WriteHandler WriteHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_flush(
-      WriteHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_read_some buffered_stream::async_read_some]
-
-[indexterm2 asio.indexterm.buffered_stream.async_read_some..async_read_some..buffered_stream] 
-Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadHandler ReadHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some buffered_stream::async_write_some]
-
-[indexterm2 asio.indexterm.buffered_stream.async_write_some..async_write_some..buffered_stream] 
-Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteHandler WriteHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[section:buffered_stream buffered_stream::buffered_stream]
-
-[indexterm2 asio.indexterm.buffered_stream.buffered_stream..buffered_stream..buffered_stream] 
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  explicit ``[link asio.reference.buffered_stream.buffered_stream.overload1 buffered_stream]``(
-      Arg && a);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.buffered_stream.overload1 more...]]``
-
-  template<
-      typename Arg>
-  explicit ``[link asio.reference.buffered_stream.buffered_stream.overload2 buffered_stream]``(
-      Arg && a,
-      std::size_t read_buffer_size,
-      std::size_t write_buffer_size);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.buffered_stream.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::buffered_stream (1 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_stream(
-      Arg && a);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::buffered_stream (2 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_stream(
-      Arg && a,
-      std::size_t read_buffer_size,
-      std::size_t write_buffer_size);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close buffered_stream::close]
-
-[indexterm2 asio.indexterm.buffered_stream.close..close..buffered_stream] 
-Close the stream. 
-
-
-  void ``[link asio.reference.buffered_stream.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.close.overload1 more...]]``
-
-  void ``[link asio.reference.buffered_stream.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.close.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::close (1 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::close (2 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type buffered_stream::executor_type]
-
-[indexterm2 asio.indexterm.buffered_stream.executor_type..executor_type..buffered_stream] 
-The type of the executor associated with the object. 
-
-
-  typedef lowest_layer_type::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:fill buffered_stream::fill]
-
-[indexterm2 asio.indexterm.buffered_stream.fill..fill..buffered_stream] 
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-
-
-  std::size_t ``[link asio.reference.buffered_stream.fill.overload1 fill]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.fill.overload1 more...]]``
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 
-
-
-  std::size_t ``[link asio.reference.buffered_stream.fill.overload2 fill]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.fill.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::fill (1 of 2 overloads)]
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. 
-
-
-  std::size_t fill();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::fill (2 of 2 overloads)]
-
-
-Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. 
-
-
-  std::size_t fill(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:flush buffered_stream::flush]
-
-[indexterm2 asio.indexterm.buffered_stream.flush..flush..buffered_stream] 
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-
-
-  std::size_t ``[link asio.reference.buffered_stream.flush.overload1 flush]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.flush.overload1 more...]]``
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 
-
-
-  std::size_t ``[link asio.reference.buffered_stream.flush.overload2 flush]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.flush.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::flush (1 of 2 overloads)]
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-
-
-  std::size_t flush();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::flush (2 of 2 overloads)]
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 
-
-
-  std::size_t flush(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor buffered_stream::get_executor]
-
-[indexterm2 asio.indexterm.buffered_stream.get_executor..get_executor..buffered_stream] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:in_avail buffered_stream::in_avail]
-
-[indexterm2 asio.indexterm.buffered_stream.in_avail..in_avail..buffered_stream] 
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t ``[link asio.reference.buffered_stream.in_avail.overload1 in_avail]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.in_avail.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.buffered_stream.in_avail.overload2 in_avail]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.in_avail.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::in_avail (1 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::in_avail (2 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer buffered_stream::lowest_layer]
-
-[indexterm2 asio.indexterm.buffered_stream.lowest_layer..lowest_layer..buffered_stream] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.buffered_stream.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.buffered_stream.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type buffered_stream::lowest_layer_type]
-
-[indexterm2 asio.indexterm.buffered_stream.lowest_layer_type..lowest_layer_type..buffered_stream] 
-The type of the lowest layer. 
-
-
-  typedef next_layer_type::lowest_layer_type lowest_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:next_layer buffered_stream::next_layer]
-
-[indexterm2 asio.indexterm.buffered_stream.next_layer..next_layer..buffered_stream] 
-Get a reference to the next layer. 
-
-
-  next_layer_type & next_layer();
-
-
-
-[endsect]
-
-
-
-[section:next_layer_type buffered_stream::next_layer_type]
-
-[indexterm2 asio.indexterm.buffered_stream.next_layer_type..next_layer_type..buffered_stream] 
-The type of the next layer. 
-
-
-  typedef remove_reference_t< Stream > next_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:peek buffered_stream::peek]
-
-[indexterm2 asio.indexterm.buffered_stream.peek..peek..buffered_stream] 
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.peek.overload1 peek]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.peek.overload1 more...]]``
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.peek.overload2 peek]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.peek.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::peek (1 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::peek (2 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some buffered_stream::read_some]
-
-[indexterm2 asio.indexterm.buffered_stream.read_some..read_some..buffered_stream] 
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.read_some.overload1 more...]]``
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.read_some.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::read_some (1 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::read_some (2 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some buffered_stream::write_some]
-
-[indexterm2 asio.indexterm.buffered_stream.write_some..write_some..buffered_stream] 
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.write_some.overload1 more...]]``
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_stream.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_stream.write_some.overload2 more...]]``
-
-
-[section:overload1 buffered_stream::write_some (1 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_stream::write_some (2 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:buffered_write_stream buffered_write_stream]
-
-[indexterm1 asio.indexterm.buffered_write_stream..buffered_write_stream]
-
-
-Adds buffering to the write-related operations of a stream. 
-
-
-  template<
-      typename Stream>
-  class buffered_write_stream :
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.buffered_write_stream.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_write_stream.lowest_layer_type [*lowest_layer_type]]]
-    [The type of the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffered_write_stream.next_layer_type [*next_layer_type]]]
-    [The type of the next layer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffered_write_stream.async_flush [*async_flush]]]
-    [Start an asynchronous flush. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.buffered_write_stream [*buffered_write_stream]] [constructor]]
-    [Construct, passing the specified argument to initialise the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.close [*close]]]
-    [Close the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.flush [*flush]]]
-    [Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-     [hr]
-     Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.in_avail [*in_avail]]]
-    [Determine the amount of data that may be read without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.next_layer [*next_layer]]]
-    [Get a reference to the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.peek [*peek]]]
-    [Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.read_some [*read_some]]]
-    [Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-     [hr]
-     Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. ]
-  ]
-  
-  [
-    [[link asio.reference.buffered_write_stream.write_some [*write_some]]]
-    [Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-     [hr]
-     Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffered_write_stream.default_buffer_size [*default_buffer_size]] [static]]
-    [The default buffer size. ]
-  ]
-
-]
-
-The [link asio.reference.buffered_write_stream `buffered_write_stream`] class template can be used to add buffering to the synchronous and asynchronous write operations of a stream.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_write_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:async_flush buffered_write_stream::async_flush]
-
-[indexterm2 asio.indexterm.buffered_write_stream.async_flush..async_flush..buffered_write_stream] 
-Start an asynchronous flush. 
-
-
-  template<
-      typename ``[link asio.reference.WriteHandler WriteHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_flush(
-      WriteHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_read_some buffered_write_stream::async_read_some]
-
-[indexterm2 asio.indexterm.buffered_write_stream.async_read_some..async_read_some..buffered_write_stream] 
-Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadHandler ReadHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some buffered_write_stream::async_write_some]
-
-[indexterm2 asio.indexterm.buffered_write_stream.async_write_some..async_write_some..buffered_write_stream] 
-Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteHandler WriteHandler]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteHandler && handler = default_completion_token_t< executor_type >());
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[section:buffered_write_stream buffered_write_stream::buffered_write_stream]
-
-[indexterm2 asio.indexterm.buffered_write_stream.buffered_write_stream..buffered_write_stream..buffered_write_stream] 
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  explicit ``[link asio.reference.buffered_write_stream.buffered_write_stream.overload1 buffered_write_stream]``(
-      Arg && a);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.buffered_write_stream.overload1 more...]]``
-
-  template<
-      typename Arg>
-  ``[link asio.reference.buffered_write_stream.buffered_write_stream.overload2 buffered_write_stream]``(
-      Arg && a,
-      std::size_t buffer_size);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.buffered_write_stream.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::buffered_write_stream (1 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_write_stream(
-      Arg && a);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::buffered_write_stream (2 of 2 overloads)]
-
-
-Construct, passing the specified argument to initialise the next layer. 
-
-
-  template<
-      typename Arg>
-  buffered_write_stream(
-      Arg && a,
-      std::size_t buffer_size);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close buffered_write_stream::close]
-
-[indexterm2 asio.indexterm.buffered_write_stream.close..close..buffered_write_stream] 
-Close the stream. 
-
-
-  void ``[link asio.reference.buffered_write_stream.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.close.overload1 more...]]``
-
-  void ``[link asio.reference.buffered_write_stream.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.close.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::close (1 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::close (2 of 2 overloads)]
-
-
-Close the stream. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:default_buffer_size buffered_write_stream::default_buffer_size]
-
-[indexterm2 asio.indexterm.buffered_write_stream.default_buffer_size..default_buffer_size..buffered_write_stream] 
-The default buffer size. 
-
-
-  static const std::size_t default_buffer_size = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:executor_type buffered_write_stream::executor_type]
-
-[indexterm2 asio.indexterm.buffered_write_stream.executor_type..executor_type..buffered_write_stream] 
-The type of the executor associated with the object. 
-
-
-  typedef lowest_layer_type::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_write_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:flush buffered_write_stream::flush]
-
-[indexterm2 asio.indexterm.buffered_write_stream.flush..flush..buffered_write_stream] 
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-
-
-  std::size_t ``[link asio.reference.buffered_write_stream.flush.overload1 flush]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.flush.overload1 more...]]``
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 
-
-
-  std::size_t ``[link asio.reference.buffered_write_stream.flush.overload2 flush]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.flush.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::flush (1 of 2 overloads)]
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. 
-
-
-  std::size_t flush();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::flush (2 of 2 overloads)]
-
-
-Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. 
-
-
-  std::size_t flush(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor buffered_write_stream::get_executor]
-
-[indexterm2 asio.indexterm.buffered_write_stream.get_executor..get_executor..buffered_write_stream] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:in_avail buffered_write_stream::in_avail]
-
-[indexterm2 asio.indexterm.buffered_write_stream.in_avail..in_avail..buffered_write_stream] 
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t ``[link asio.reference.buffered_write_stream.in_avail.overload1 in_avail]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.in_avail.overload1 more...]]``
-
-  std::size_t ``[link asio.reference.buffered_write_stream.in_avail.overload2 in_avail]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.in_avail.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::in_avail (1 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::in_avail (2 of 2 overloads)]
-
-
-Determine the amount of data that may be read without blocking. 
-
-
-  std::size_t in_avail(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:lowest_layer buffered_write_stream::lowest_layer]
-
-[indexterm2 asio.indexterm.buffered_write_stream.lowest_layer..lowest_layer..buffered_write_stream] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.buffered_write_stream.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.buffered_write_stream.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type buffered_write_stream::lowest_layer_type]
-
-[indexterm2 asio.indexterm.buffered_write_stream.lowest_layer_type..lowest_layer_type..buffered_write_stream] 
-The type of the lowest layer. 
-
-
-  typedef next_layer_type::lowest_layer_type lowest_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_write_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:next_layer buffered_write_stream::next_layer]
-
-[indexterm2 asio.indexterm.buffered_write_stream.next_layer..next_layer..buffered_write_stream] 
-Get a reference to the next layer. 
-
-
-  next_layer_type & next_layer();
-
-
-
-[endsect]
-
-
-
-[section:next_layer_type buffered_write_stream::next_layer_type]
-
-[indexterm2 asio.indexterm.buffered_write_stream.next_layer_type..next_layer_type..buffered_write_stream] 
-The type of the next layer. 
-
-
-  typedef remove_reference_t< Stream > next_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffered_write_stream.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:peek buffered_write_stream::peek]
-
-[indexterm2 asio.indexterm.buffered_write_stream.peek..peek..buffered_write_stream] 
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.peek.overload1 peek]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.peek.overload1 more...]]``
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.peek.overload2 peek]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.peek.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::peek (1 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::peek (2 of 2 overloads)]
-
-
-Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t peek(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some buffered_write_stream::read_some]
-
-[indexterm2 asio.indexterm.buffered_write_stream.read_some..read_some..buffered_write_stream] 
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.read_some.overload1 more...]]``
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.read_some.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::read_some (1 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::read_some (2 of 2 overloads)]
-
-
-Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some buffered_write_stream::write_some]
-
-[indexterm2 asio.indexterm.buffered_write_stream.write_some..write_some..buffered_write_stream] 
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.write_some.overload1 more...]]``
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.buffered_write_stream.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.buffered_write_stream.write_some.overload2 more...]]``
-
-
-[section:overload1 buffered_write_stream::write_some (1 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffered_write_stream::write_some (2 of 2 overloads)]
-
-
-Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:buffers_begin buffers_begin]
-
-[indexterm1 asio.indexterm.buffers_begin..buffers_begin]
-
-Construct an iterator representing the beginning of the buffers' data. 
-
-
-  template<
-      typename BufferSequence>
-  buffers_iterator< BufferSequence > buffers_begin(
-      const BufferSequence & buffers);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:buffers_end buffers_end]
-
-[indexterm1 asio.indexterm.buffers_end..buffers_end]
-
-Construct an iterator representing the end of the buffers' data. 
-
-
-  template<
-      typename BufferSequence>
-  buffers_iterator< BufferSequence > buffers_end(
-      const BufferSequence & buffers);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:buffers_iterator buffers_iterator]
-
-[indexterm1 asio.indexterm.buffers_iterator..buffers_iterator]
-
-
-A random access iterator over the bytes in a buffer sequence. 
-
-
-  template<
-      typename BufferSequence,
-      typename ByteType = char>
-  class buffers_iterator
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.buffers_iterator.difference_type [*difference_type]]]
-    [The type used for the distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffers_iterator.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffers_iterator.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffers_iterator.reference [*reference]]]
-    [The type of the result of applying operator*() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.buffers_iterator.value_type [*value_type]]]
-    [The type of the value pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffers_iterator.begin [*begin]] [static]]
-    [Construct an iterator representing the beginning of the buffers' data. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.buffers_iterator [*buffers_iterator]] [constructor]]
-    [Default constructor. Creates an iterator in an undefined state. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.end [*end]] [static]]
-    [Construct an iterator representing the end of the buffers' data. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_plus__eq_ [*operator+=]]]
-    [Addition operator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_minus__minus_ [*operator--]]]
-    [Decrement operator (prefix). 
-     [hr]
-     Decrement operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_minus__eq_ [*operator-=]]]
-    [Subtraction operator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_lb__rb_ [*operator\[\]]]]
-    [Access an individual element. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.buffers_iterator.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_plus_ [*operator+]]]
-    [Addition operator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_minus_ [*operator-]]]
-    [Subtraction operator. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_lt_ [*operator<]]]
-    [Compare two iterators. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_lt__eq_ [*operator<=]]]
-    [Compare two iterators. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_gt_ [*operator>]]]
-    [Compare two iterators. ]
-  ]
-  
-  [
-    [[link asio.reference.buffers_iterator.operator_gt__eq_ [*operator>=]]]
-    [Compare two iterators. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:begin buffers_iterator::begin]
-
-[indexterm2 asio.indexterm.buffers_iterator.begin..begin..buffers_iterator] 
-Construct an iterator representing the beginning of the buffers' data. 
-
-
-  static buffers_iterator begin(
-      const BufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:buffers_iterator buffers_iterator::buffers_iterator]
-
-[indexterm2 asio.indexterm.buffers_iterator.buffers_iterator..buffers_iterator..buffers_iterator] 
-Default constructor. Creates an iterator in an undefined state. 
-
-
-  buffers_iterator();
-
-
-
-[endsect]
-
-
-
-[section:difference_type buffers_iterator::difference_type]
-
-[indexterm2 asio.indexterm.buffers_iterator.difference_type..difference_type..buffers_iterator] 
-The type used for the distance between two iterators. 
-
-
-  typedef std::ptrdiff_t difference_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:end buffers_iterator::end]
-
-[indexterm2 asio.indexterm.buffers_iterator.end..end..buffers_iterator] 
-Construct an iterator representing the end of the buffers' data. 
-
-
-  static buffers_iterator end(
-      const BufferSequence & buffers);
-
-
-
-[endsect]
-
-
-
-[section:iterator_category buffers_iterator::iterator_category]
-
-[indexterm2 asio.indexterm.buffers_iterator.iterator_category..iterator_category..buffers_iterator] 
-The iterator category. 
-
-
-  typedef std::random_access_iterator_tag iterator_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ buffers_iterator::operator!=]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_not__eq_..operator!=..buffers_iterator] 
-Test two iterators for inequality. 
-
-
-  bool operator!=(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_star_ buffers_iterator::operator*]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_star_..operator*..buffers_iterator] 
-Dereference an iterator. 
-
-
-  reference operator*() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus_ buffers_iterator::operator+]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_plus_..operator+..buffers_iterator] 
-Addition operator. 
-
-
-  buffers_iterator ``[link asio.reference.buffers_iterator.operator_plus_.overload1 operator+]``(
-      const buffers_iterator & iter,
-      std::ptrdiff_t difference);
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_plus_.overload1 more...]]``
-
-  buffers_iterator ``[link asio.reference.buffers_iterator.operator_plus_.overload2 operator+]``(
-      std::ptrdiff_t difference,
-      const buffers_iterator & iter);
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 buffers_iterator::operator+ (1 of 2 overloads)]
-
-
-Addition operator. 
-
-
-  buffers_iterator operator+(
-      const buffers_iterator & iter,
-      std::ptrdiff_t difference);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:overload2 buffers_iterator::operator+ (2 of 2 overloads)]
-
-
-Addition operator. 
-
-
-  buffers_iterator operator+(
-      std::ptrdiff_t difference,
-      const buffers_iterator & iter);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_plus__plus_ buffers_iterator::operator++]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_plus__plus_..operator++..buffers_iterator] 
-Increment operator (prefix). 
-
-
-  buffers_iterator & ``[link asio.reference.buffers_iterator.operator_plus__plus_.overload1 operator++]``();
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_plus__plus_.overload1 more...]]``
-
-
-Increment operator (postfix). 
-
-
-  buffers_iterator ``[link asio.reference.buffers_iterator.operator_plus__plus_.overload2 operator++]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_plus__plus_.overload2 more...]]``
-
-
-[section:overload1 buffers_iterator::operator++ (1 of 2 overloads)]
-
-
-Increment operator (prefix). 
-
-
-  buffers_iterator & operator++();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffers_iterator::operator++ (2 of 2 overloads)]
-
-
-Increment operator (postfix). 
-
-
-  buffers_iterator operator++(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ buffers_iterator::operator+=]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_plus__eq_..operator+=..buffers_iterator] 
-Addition operator. 
-
-
-  buffers_iterator & operator+=(
-      std::ptrdiff_t difference);
-
-
-
-[endsect]
-
-
-[section:operator_minus_ buffers_iterator::operator-]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_minus_..operator-..buffers_iterator] 
-Subtraction operator. 
-
-
-  buffers_iterator ``[link asio.reference.buffers_iterator.operator_minus_.overload1 operator-]``(
-      const buffers_iterator & iter,
-      std::ptrdiff_t difference);
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_minus_.overload1 more...]]``
-
-  std::ptrdiff_t ``[link asio.reference.buffers_iterator.operator_minus_.overload2 operator-]``(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_minus_.overload2 more...]]``
-
-
-[section:overload1 buffers_iterator::operator- (1 of 2 overloads)]
-
-
-Subtraction operator. 
-
-
-  buffers_iterator operator-(
-      const buffers_iterator & iter,
-      std::ptrdiff_t difference);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:overload2 buffers_iterator::operator- (2 of 2 overloads)]
-
-
-Subtraction operator. 
-
-
-  std::ptrdiff_t operator-(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_minus__minus_ buffers_iterator::operator--]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_minus__minus_..operator--..buffers_iterator] 
-Decrement operator (prefix). 
-
-
-  buffers_iterator & ``[link asio.reference.buffers_iterator.operator_minus__minus_.overload1 operator--]``();
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_minus__minus_.overload1 more...]]``
-
-
-Decrement operator (postfix). 
-
-
-  buffers_iterator ``[link asio.reference.buffers_iterator.operator_minus__minus_.overload2 operator--]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.buffers_iterator.operator_minus__minus_.overload2 more...]]``
-
-
-[section:overload1 buffers_iterator::operator-- (1 of 2 overloads)]
-
-
-Decrement operator (prefix). 
-
-
-  buffers_iterator & operator--();
-
-
-
-[endsect]
-
-
-
-[section:overload2 buffers_iterator::operator-- (2 of 2 overloads)]
-
-
-Decrement operator (postfix). 
-
-
-  buffers_iterator operator--(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_minus__eq_ buffers_iterator::operator-=]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_minus__eq_..operator-=..buffers_iterator] 
-Subtraction operator. 
-
-
-  buffers_iterator & operator-=(
-      std::ptrdiff_t difference);
-
-
-
-[endsect]
-
-
-
-[section:operator_arrow_ buffers_iterator::operator->]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_arrow_..operator->..buffers_iterator] 
-Dereference an iterator. 
-
-
-  pointer operator->() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_lt_ buffers_iterator::operator<]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_lt_..operator<..buffers_iterator] 
-Compare two iterators. 
-
-
-  bool operator<(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt__eq_ buffers_iterator::operator<=]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_lt__eq_..operator<=..buffers_iterator] 
-Compare two iterators. 
-
-
-  bool operator<=(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ buffers_iterator::operator==]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_eq__eq_..operator==..buffers_iterator] 
-Test two iterators for equality. 
-
-
-  bool operator==(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ buffers_iterator::operator>]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_gt_..operator>..buffers_iterator] 
-Compare two iterators. 
-
-
-  bool operator>(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ buffers_iterator::operator>=]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_gt__eq_..operator>=..buffers_iterator] 
-Compare two iterators. 
-
-
-  bool operator>=(
-      const buffers_iterator & a,
-      const buffers_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lb__rb_ buffers_iterator::operator\[\]]
-
-[indexterm2 asio.indexterm.buffers_iterator.operator_lb__rb_..operator\[\]..buffers_iterator] 
-Access an individual element. 
-
-
-  reference operator[](
-      std::ptrdiff_t difference) const;
-
-
-
-[endsect]
-
-
-
-[section:pointer buffers_iterator::pointer]
-
-[indexterm2 asio.indexterm.buffers_iterator.pointer..pointer..buffers_iterator] 
-The type of the result of applying `operator->()` to the iterator. 
-
-
-  typedef const_or_non_const_ByteType * pointer;
-
-
-
-If the buffer sequence stores buffer objects that are convertible to [link asio.reference.mutable_buffer `mutable_buffer`], this is a pointer to a non-const ByteType. Otherwise, a pointer to a const ByteType. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reference buffers_iterator::reference]
-
-[indexterm2 asio.indexterm.buffers_iterator.reference..reference..buffers_iterator] 
-The type of the result of applying `operator*()` to the iterator. 
-
-
-  typedef const_or_non_const_ByteType & reference;
-
-
-
-If the buffer sequence stores buffer objects that are convertible to [link asio.reference.mutable_buffer `mutable_buffer`], this is a reference to a non-const ByteType. Otherwise, a reference to a const ByteType. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:value_type buffers_iterator::value_type]
-
-[indexterm2 asio.indexterm.buffers_iterator.value_type..value_type..buffers_iterator] 
-The type of the value pointed to by the iterator. 
-
-
-  typedef ByteType value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffers_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:can_prefer can_prefer]
-
-[indexterm1 asio.indexterm.can_prefer..can_prefer]
-
-
-A type trait that determines whether a `prefer` expression is well-formed. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct can_prefer :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `can_prefer` is a trait that is derived from `true_type` if the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)` is well formed; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/prefer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:can_query can_query]
-
-[indexterm1 asio.indexterm.can_query..can_query]
-
-
-A type trait that determines whether a `query` expression is well-formed. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct can_query :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `can_query` is a trait that is derived from `true_type` if the expression `asio::query(std::declval<T>(), std::declval<Property>())` is well formed; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:can_require can_require]
-
-[indexterm1 asio.indexterm.can_require..can_require]
-
-
-A type trait that determines whether a `require` expression is well-formed. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct can_require :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `can_require` is a trait that is derived from `true_type` if the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)` is well formed; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:can_require_concept can_require_concept]
-
-[indexterm1 asio.indexterm.can_require_concept..can_require_concept]
-
-
-A type trait that determines whether a `require_concept` expression is well-formed. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct can_require_concept :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `can_require_concept` is a trait that is derived from `true_type` if the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())` is well formed; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require_concept.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:cancel_after cancel_after]
-
-[indexterm1 asio.indexterm.cancel_after..cancel_after]
-
-Create a partial completion token adapter that cancels an operation if not complete before the specified relative timeout has elapsed. 
-
-  template<
-      typename Rep,
-      typename Period>
-  partial_cancel_after< chrono::steady_clock > ``[link asio.reference.cancel_after.overload1 cancel_after]``(
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload1 more...]]``
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period>
-  partial_cancel_after_timer< Clock, WaitTraits, Executor > ``[link asio.reference.cancel_after.overload2 cancel_after]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload2 more...]]``
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete before the specified relative timeout has elapsed. 
-
-  template<
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_t< decay_t< CompletionToken >, chrono::steady_clock > ``[link asio.reference.cancel_after.overload3 cancel_after]``(
-      const chrono::duration< Rep, Period > & timeout,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload3 more...]]``
-
-  template<
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_t< decay_t< CompletionToken >, chrono::steady_clock > ``[link asio.reference.cancel_after.overload4 cancel_after]``(
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload4 more...]]``
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > ``[link asio.reference.cancel_after.overload5 cancel_after]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload5 more...]]``
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_timer< decay_t< CompletionToken >, chrono::steady_clock > ``[link asio.reference.cancel_after.overload6 cancel_after]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_after.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_after.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 cancel_after (1 of 6 overloads)]
-
-
-Create a partial completion token adapter that cancels an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Rep,
-      typename Period>
-  partial_cancel_after< chrono::steady_clock > cancel_after(
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 cancel_after (2 of 6 overloads)]
-
-
-Create a partial completion token adapter that cancels an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period>
-  partial_cancel_after_timer< Clock, WaitTraits, Executor > cancel_after(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 cancel_after (3 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_t< decay_t< CompletionToken >, chrono::steady_clock > cancel_after(
-      const chrono::duration< Rep, Period > & timeout,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 cancel_after (4 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_t< decay_t< CompletionToken >, chrono::steady_clock > cancel_after(
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 cancel_after (5 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > cancel_after(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 cancel_after (6 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete before the specified relative timeout has elapsed. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Rep,
-      typename Period,
-      typename CompletionToken>
-  cancel_after_timer< decay_t< CompletionToken >, chrono::steady_clock > cancel_after(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::duration< Rep, Period > & timeout,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_after, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel_after_t cancel_after_t]
-
-[indexterm1 asio.indexterm.cancel_after_t..cancel_after_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter that cancels an operation after a timeout. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>>
-  class cancel_after_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_after_t.cancel_after_t [*cancel_after_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_after_t.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_after_t.timeout_ [*timeout_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_after_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.cancel_after_t `cancel_after_t`] class is used to indicate that an asynchronous operation should be cancelled if not complete before the specified duration has elapsed. 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_after.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_after_t cancel_after_t::cancel_after_t]
-
-[indexterm2 asio.indexterm.cancel_after_t.cancel_after_t..cancel_after_t..cancel_after_t] 
-Constructor. 
-
-
-  template<
-      typename T>
-  cancel_after_t(
-      T && completion_token,
-      const typename Clock::duration & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:cancel_type_ cancel_after_t::cancel_type_]
-
-[indexterm2 asio.indexterm.cancel_after_t.cancel_type_..cancel_type_..cancel_after_t] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:timeout_ cancel_after_t::timeout_]
-
-[indexterm2 asio.indexterm.cancel_after_t.timeout_..timeout_..cancel_after_t] 
-
-  Clock::duration timeout_;
-
-
-
-[endsect]
-
-
-
-[section:token_ cancel_after_t::token_]
-
-[indexterm2 asio.indexterm.cancel_after_t.token_..token_..cancel_after_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancel_after_timer cancel_after_timer]
-
-[indexterm1 asio.indexterm.cancel_after_timer..cancel_after_timer]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter that cancels an operation after a timeout. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class cancel_after_timer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_after_timer.cancel_after_timer [*cancel_after_timer]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_after_timer.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_after_timer.timeout_ [*timeout_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_after_timer.timer_ [*timer_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_after_timer.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.cancel_after_timer `cancel_after_timer`] class is used to indicate that an asynchronous operation should be cancelled if not complete before the specified duration has elapsed. 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_after.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_after_timer cancel_after_timer::cancel_after_timer]
-
-[indexterm2 asio.indexterm.cancel_after_timer.cancel_after_timer..cancel_after_timer..cancel_after_timer] 
-Constructor. 
-
-
-  template<
-      typename T>
-  cancel_after_timer(
-      T && completion_token,
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const typename Clock::duration & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:cancel_type_ cancel_after_timer::cancel_type_]
-
-[indexterm2 asio.indexterm.cancel_after_timer.cancel_type_..cancel_type_..cancel_after_timer] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:timeout_ cancel_after_timer::timeout_]
-
-[indexterm2 asio.indexterm.cancel_after_timer.timeout_..timeout_..cancel_after_timer] 
-
-  Clock::duration timeout_;
-
-
-
-[endsect]
-
-
-
-[section:timer_ cancel_after_timer::timer_]
-
-[indexterm2 asio.indexterm.cancel_after_timer.timer_..timer_..cancel_after_timer] 
-
-  basic_waitable_timer< Clock, WaitTraits, Executor > & timer_;
-
-
-
-[endsect]
-
-
-
-[section:token_ cancel_after_timer::token_]
-
-[indexterm2 asio.indexterm.cancel_after_timer.token_..token_..cancel_after_timer] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancel_at cancel_at]
-
-[indexterm1 asio.indexterm.cancel_at..cancel_at]
-
-Create a partial completion token adapter that cancels an operation if not complete by the specified absolute time. 
-
-  template<
-      typename Clock,
-      typename Duration>
-  partial_cancel_at< Clock > ``[link asio.reference.cancel_at.overload1 cancel_at]``(
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload1 more...]]``
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  partial_cancel_at_timer< Clock, WaitTraits, Executor > ``[link asio.reference.cancel_at.overload2 cancel_at]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload2 more...]]``
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete by the specified absolute time. 
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename Duration>
-  cancel_at_t< decay_t< CompletionToken >, Clock > ``[link asio.reference.cancel_at.overload3 cancel_at]``(
-      const chrono::time_point< Clock, Duration > & expiry,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload3 more...]]``
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename Duration>
-  cancel_at_t< decay_t< CompletionToken >, Clock > ``[link asio.reference.cancel_at.overload4 cancel_at]``(
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload4 more...]]``
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  cancel_at_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > ``[link asio.reference.cancel_at.overload5 cancel_at]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload5 more...]]``
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  cancel_at_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > ``[link asio.reference.cancel_at.overload6 cancel_at]``(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.cancel_at.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 cancel_at (1 of 6 overloads)]
-
-
-Create a partial completion token adapter that cancels an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename Clock,
-      typename Duration>
-  partial_cancel_at< Clock > cancel_at(
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 cancel_at (2 of 6 overloads)]
-
-
-Create a partial completion token adapter that cancels an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  partial_cancel_at_timer< Clock, WaitTraits, Executor > cancel_at(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 cancel_at (3 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename Duration>
-  cancel_at_t< decay_t< CompletionToken >, Clock > cancel_at(
-      const chrono::time_point< Clock, Duration > & expiry,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 cancel_at (4 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename Duration>
-  cancel_at_t< decay_t< CompletionToken >, Clock > cancel_at(
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 cancel_at (5 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  cancel_at_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > cancel_at(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 cancel_at (6 of 6 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to cancel an operation if not complete by the specified absolute time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Duration>
-  cancel_at_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > cancel_at(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const chrono::time_point< Clock, Duration > & expiry,
-      cancellation_type_t cancel_type,
-      CompletionToken && completion_token);
-
-
-
-[heading Thread Safety]
-  
-When an asynchronous operation is used with cancel\_at, a timer async\_wait operation is performed in parallel to the main operation. If this parallel async\_wait completes first, a cancellation request is emitted to cancel the main operation. Consequently, the application must ensure that the asynchronous operation is performed within an implicit or explicit strand. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel_at_t cancel_at_t]
-
-[indexterm1 asio.indexterm.cancel_at_t..cancel_at_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter that cancels an operation at a given time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>>
-  class cancel_at_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_at_t.cancel_at_t [*cancel_at_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_at_t.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_at_t.expiry_ [*expiry_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_at_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.cancel_at_t `cancel_at_t`] class is used to indicate that an asynchronous operation should be cancelled if not complete at the specified absolute time. 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_at_t cancel_at_t::cancel_at_t]
-
-[indexterm2 asio.indexterm.cancel_at_t.cancel_at_t..cancel_at_t..cancel_at_t] 
-Constructor. 
-
-
-  template<
-      typename T>
-  cancel_at_t(
-      T && completion_token,
-      const typename Clock::time_point & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:cancel_type_ cancel_at_t::cancel_type_]
-
-[indexterm2 asio.indexterm.cancel_at_t.cancel_type_..cancel_type_..cancel_at_t] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:expiry_ cancel_at_t::expiry_]
-
-[indexterm2 asio.indexterm.cancel_at_t.expiry_..expiry_..cancel_at_t] 
-
-  Clock::time_point expiry_;
-
-
-
-[endsect]
-
-
-
-[section:token_ cancel_at_t::token_]
-
-[indexterm2 asio.indexterm.cancel_at_t.token_..token_..cancel_at_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancel_at_timer cancel_at_timer]
-
-[indexterm1 asio.indexterm.cancel_at_timer..cancel_at_timer]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter that cancels an operation at a given time. 
-
-
-  template<
-      typename CompletionToken,
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class cancel_at_timer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_at_timer.cancel_at_timer [*cancel_at_timer]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancel_at_timer.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_at_timer.expiry_ [*expiry_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_at_timer.timer_ [*timer_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.cancel_at_timer.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.cancel_at_timer `cancel_at_timer`] class is used to indicate that an asynchronous operation should be cancelled if not complete at the specified absolute time. 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_at_timer cancel_at_timer::cancel_at_timer]
-
-[indexterm2 asio.indexterm.cancel_at_timer.cancel_at_timer..cancel_at_timer..cancel_at_timer] 
-Constructor. 
-
-
-  template<
-      typename T>
-  cancel_at_timer(
-      T && completion_token,
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const typename Clock::time_point & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:cancel_type_ cancel_at_timer::cancel_type_]
-
-[indexterm2 asio.indexterm.cancel_at_timer.cancel_type_..cancel_type_..cancel_at_timer] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:expiry_ cancel_at_timer::expiry_]
-
-[indexterm2 asio.indexterm.cancel_at_timer.expiry_..expiry_..cancel_at_timer] 
-
-  Clock::time_point expiry_;
-
-
-
-[endsect]
-
-
-
-[section:timer_ cancel_at_timer::timer_]
-
-[indexterm2 asio.indexterm.cancel_at_timer.timer_..timer_..cancel_at_timer] 
-
-  basic_waitable_timer< Clock, WaitTraits, Executor > & timer_;
-
-
-
-[endsect]
-
-
-
-[section:token_ cancel_at_timer::token_]
-
-[indexterm2 asio.indexterm.cancel_at_timer.token_..token_..cancel_at_timer] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancellation_filter cancellation_filter]
-
-[indexterm1 asio.indexterm.cancellation_filter..cancellation_filter]
-
-
-A simple cancellation signal propagation filter. 
-
-
-  template<
-      cancellation_type_t Mask>
-  struct cancellation_filter
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_filter.operator_lp__rp_ [*operator()]]]
-    [Returns type & Mask. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ cancellation_filter::operator()]
-
-[indexterm2 asio.indexterm.cancellation_filter.operator_lp__rp_..operator()..cancellation_filter] 
-Returns `type & Mask`. 
-
-
-  cancellation_type_t operator()(
-      cancellation_type_t type) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancellation_signal cancellation_signal]
-
-[indexterm1 asio.indexterm.cancellation_signal..cancellation_signal]
-
-
-A cancellation signal with a single slot. 
-
-
-  class cancellation_signal
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_signal.cancellation_signal [*cancellation_signal]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.cancellation_signal.emit [*emit]]]
-    [Emits the signal and causes invocation of the slot's handler, if any. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_signal.slot [*slot]]]
-    [Returns the single slot associated with the signal. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_signal._cancellation_signal [*~cancellation_signal]] [destructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_signal.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancellation_signal cancellation_signal::cancellation_signal]
-
-[indexterm2 asio.indexterm.cancellation_signal.cancellation_signal..cancellation_signal..cancellation_signal] 
-
-  constexpr cancellation_signal();
-
-
-
-[endsect]
-
-
-
-[section:emit cancellation_signal::emit]
-
-[indexterm2 asio.indexterm.cancellation_signal.emit..emit..cancellation_signal] 
-Emits the signal and causes invocation of the slot's handler, if any. 
-
-
-  void emit(
-      cancellation_type_t type);
-
-
-
-[endsect]
-
-
-
-[section:slot cancellation_signal::slot]
-
-[indexterm2 asio.indexterm.cancellation_signal.slot..slot..cancellation_signal] 
-Returns the single slot associated with the signal. 
-
-
-  cancellation_slot slot();
-
-
-The signal object must remain valid for as long the slot may be used. Destruction of the signal invalidates the slot. 
-
-
-[endsect]
-
-
-
-[section:_cancellation_signal cancellation_signal::~cancellation_signal]
-
-[indexterm2 asio.indexterm.cancellation_signal._cancellation_signal..~cancellation_signal..cancellation_signal] 
-
-  ~cancellation_signal();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancellation_slot cancellation_slot]
-
-[indexterm1 asio.indexterm.cancellation_slot..cancellation_slot]
-
-
-A slot associated with a cancellation signal. 
-
-
-  class cancellation_slot
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.assign [*assign]]]
-    [Installs a handler into the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.cancellation_slot [*cancellation_slot]] [constructor]]
-    [Creates a slot that is not connected to any cancellation signal. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.clear [*clear]]]
-    [Clears the slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.emplace [*emplace]]]
-    [Installs a handler into the slot, constructing the new object directly. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.has_handler [*has_handler]]]
-    [Returns whether the slot is connected and has an installed handler. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.is_connected [*is_connected]]]
-    [Returns whether the slot is connected to a signal. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot.operator_not__eq_ [*operator!=]]]
-    [Compare two slots for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot.operator_eq__eq_ [*operator==]]]
-    [Compare two slots for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_signal.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:assign cancellation_slot::assign]
-
-[indexterm2 asio.indexterm.cancellation_slot.assign..assign..cancellation_slot] 
-Installs a handler into the slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationHandler CancellationHandler]``>
-  decay_t< CancellationHandler > & assign(
-      CancellationHandler && handler);
-
-
-Destroys any existing handler in the slot, then installs the new handler, constructing it as a decay-copy of the supplied handler.
-
-The handler is a function object to be called when the signal is emitted. The signature of the handler must be 
-
-  void handler(asio::cancellation_type_t); 
-
-
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be installed.]]
-
-]
-
-
-[heading Return Value]
-      
-A reference to the newly installed handler. 
-
-
-
-
-[endsect]
-
-
-
-[section:cancellation_slot cancellation_slot::cancellation_slot]
-
-[indexterm2 asio.indexterm.cancellation_slot.cancellation_slot..cancellation_slot..cancellation_slot] 
-Creates a slot that is not connected to any cancellation signal. 
-
-
-  constexpr cancellation_slot();
-
-
-
-[endsect]
-
-
-
-[section:clear cancellation_slot::clear]
-
-[indexterm2 asio.indexterm.cancellation_slot.clear..clear..cancellation_slot] 
-Clears the slot. 
-
-
-  void clear();
-
-
-Destroys any existing handler in the slot. 
-
-
-[endsect]
-
-
-
-[section:emplace cancellation_slot::emplace]
-
-[indexterm2 asio.indexterm.cancellation_slot.emplace..emplace..cancellation_slot] 
-Installs a handler into the slot, constructing the new object directly. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationHandler CancellationHandler]``,
-      typename... Args>
-  CancellationHandler & emplace(
-      Args &&... args);
-
-
-Destroys any existing handler in the slot, then installs the new handler, constructing it with the supplied `args`.
-
-The handler is a function object to be called when the signal is emitted. The signature of the handler must be 
-
-  void handler(asio::cancellation_type_t); 
-
-
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[args][Arguments to be passed to the `CancellationHandler` object's constructor.]]
-
-]
-
-
-[heading Return Value]
-      
-A reference to the newly installed handler.
-
-
-[heading Remarks]
-      
-Handlers installed into the slot via `emplace` are not required to be copy constructible or move constructible. 
-
-
-
-
-[endsect]
-
-
-
-[section:has_handler cancellation_slot::has_handler]
-
-[indexterm2 asio.indexterm.cancellation_slot.has_handler..has_handler..cancellation_slot] 
-Returns whether the slot is connected and has an installed handler. 
-
-
-  constexpr bool has_handler() const;
-
-
-
-[endsect]
-
-
-
-[section:is_connected cancellation_slot::is_connected]
-
-[indexterm2 asio.indexterm.cancellation_slot.is_connected..is_connected..cancellation_slot] 
-Returns whether the slot is connected to a signal. 
-
-
-  constexpr bool is_connected() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ cancellation_slot::operator!=]
-
-[indexterm2 asio.indexterm.cancellation_slot.operator_not__eq_..operator!=..cancellation_slot] 
-Compare two slots for inequality. 
-
-
-  constexpr bool operator!=(
-      const cancellation_slot & lhs,
-      const cancellation_slot & rhs);
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_signal.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ cancellation_slot::operator==]
-
-[indexterm2 asio.indexterm.cancellation_slot.operator_eq__eq_..operator==..cancellation_slot] 
-Compare two slots for equality. 
-
-
-  constexpr bool operator==(
-      const cancellation_slot & lhs,
-      const cancellation_slot & rhs);
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_signal.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancellation_slot_binder cancellation_slot_binder]
-
-[indexterm1 asio.indexterm.cancellation_slot_binder..cancellation_slot_binder]
-
-
-A call wrapper type to bind a cancellation slot of type `CancellationSlot` to an object of type `T`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  class cancellation_slot_binder
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.argument_type [*argument_type]]]
-    [The type of the function's argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.cancellation_slot_type [*cancellation_slot_type]]]
-    [The type of the associated cancellation slot. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.first_argument_type [*first_argument_type]]]
-    [The type of the function's first argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.result_type [*result_type]]]
-    [The return type if a function. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.second_argument_type [*second_argument_type]]]
-    [The type of the function's second argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.cancellation_slot_binder.target_type [*target_type]]]
-    [The type of the target object. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_slot_binder.cancellation_slot_binder [*cancellation_slot_binder]] [constructor]]
-    [Construct a cancellation slot wrapper for the specified object. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Construct a copy, but specify a different cancellation slot. 
-     [hr]
-     Construct a copy of a different cancellation slot wrapper type. 
-     [hr]
-     Construct a copy of a different cancellation slot wrapper type, but specify a different cancellation slot. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Move construct the target object, but specify a different cancellation slot. 
-     [hr]
-     Move construct from a different cancellation slot wrapper type. 
-     [hr]
-     Move construct from a different cancellation slot wrapper type, but specify a different cancellation slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot_binder.get [*get]]]
-    [Obtain a reference to the target object. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot_binder.get_cancellation_slot [*get_cancellation_slot]]]
-    [Obtain the associated cancellation slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot_binder.operator_lp__rp_ [*operator()]]]
-    [Forwarding function call operator. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_slot_binder._cancellation_slot_binder [*~cancellation_slot_binder]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:argument_type cancellation_slot_binder::argument_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.argument_type..argument_type..cancellation_slot_binder] 
-The type of the function's argument. 
-
-
-  typedef see_below argument_type;
-
-
-
-The type of `argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting a single argument, `argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `argument_type`, then `argument_type` is a synonym for `T::argument_type`;
-
-
-* otherwise `argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancellation_slot_binder cancellation_slot_binder::cancellation_slot_binder]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.cancellation_slot_binder..cancellation_slot_binder..cancellation_slot_binder] 
-Construct a cancellation slot wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload1 cancellation_slot_binder]``(
-      const cancellation_slot_type & s,
-      U && u);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload2 cancellation_slot_binder]``(
-      const cancellation_slot_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload2 more...]]``
-
-
-Construct a copy, but specify a different cancellation slot. 
-
-
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload3 cancellation_slot_binder]``(
-      const cancellation_slot_type & s,
-      const cancellation_slot_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload3 more...]]``
-
-
-Construct a copy of a different cancellation slot wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload4 cancellation_slot_binder]``(
-      const cancellation_slot_binder< U, OtherCancellationSlot > & other,
-      constraint_t< is_constructible< CancellationSlot, OtherCancellationSlot >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload4 more...]]``
-
-
-Construct a copy of a different cancellation slot wrapper type, but specify a different cancellation slot. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload5 cancellation_slot_binder]``(
-      const cancellation_slot_type & s,
-      const cancellation_slot_binder< U, OtherCancellationSlot > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload5 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload6 cancellation_slot_binder]``(
-      cancellation_slot_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload6 more...]]``
-
-
-Move construct the target object, but specify a different cancellation slot. 
-
-
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload7 cancellation_slot_binder]``(
-      const cancellation_slot_type & s,
-      cancellation_slot_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload7 more...]]``
-
-
-Move construct from a different cancellation slot wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload8 cancellation_slot_binder]``(
-      cancellation_slot_binder< U, OtherCancellationSlot > && other,
-      constraint_t< is_constructible< CancellationSlot, OtherCancellationSlot >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload8 more...]]``
-
-
-Move construct from a different cancellation slot wrapper type, but specify a different cancellation slot. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  ``[link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload9 cancellation_slot_binder]``(
-      const cancellation_slot_type & s,
-      cancellation_slot_binder< U, OtherCancellationSlot > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.cancellation_slot_binder.overload9 more...]]``
-
-
-[section:overload1 cancellation_slot_binder::cancellation_slot_binder (1 of 9 overloads)]
-
-
-Construct a cancellation slot wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  cancellation_slot_binder(
-      const cancellation_slot_type & s,
-      U && u);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload2 cancellation_slot_binder::cancellation_slot_binder (2 of 9 overloads)]
-
-
-Copy constructor. 
-
-
-  cancellation_slot_binder(
-      const cancellation_slot_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 cancellation_slot_binder::cancellation_slot_binder (3 of 9 overloads)]
-
-
-Construct a copy, but specify a different cancellation slot. 
-
-
-  cancellation_slot_binder(
-      const cancellation_slot_type & s,
-      const cancellation_slot_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 cancellation_slot_binder::cancellation_slot_binder (4 of 9 overloads)]
-
-
-Construct a copy of a different cancellation slot wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  cancellation_slot_binder(
-      const cancellation_slot_binder< U, OtherCancellationSlot > & other,
-      constraint_t< is_constructible< CancellationSlot, OtherCancellationSlot >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the `CancellationSlot` type is constructible from type `OtherCancellationSlot`, and the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload5 cancellation_slot_binder::cancellation_slot_binder (5 of 9 overloads)]
-
-
-Construct a copy of a different cancellation slot wrapper type, but specify a different cancellation slot. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  cancellation_slot_binder(
-      const cancellation_slot_type & s,
-      const cancellation_slot_binder< U, OtherCancellationSlot > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload6 cancellation_slot_binder::cancellation_slot_binder (6 of 9 overloads)]
-
-
-Move constructor. 
-
-
-  cancellation_slot_binder(
-      cancellation_slot_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload7 cancellation_slot_binder::cancellation_slot_binder (7 of 9 overloads)]
-
-
-Move construct the target object, but specify a different cancellation slot. 
-
-
-  cancellation_slot_binder(
-      const cancellation_slot_type & s,
-      cancellation_slot_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload8 cancellation_slot_binder::cancellation_slot_binder (8 of 9 overloads)]
-
-
-Move construct from a different cancellation slot wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  cancellation_slot_binder(
-      cancellation_slot_binder< U, OtherCancellationSlot > && other,
-      constraint_t< is_constructible< CancellationSlot, OtherCancellationSlot >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload9 cancellation_slot_binder::cancellation_slot_binder (9 of 9 overloads)]
-
-
-Move construct from a different cancellation slot wrapper type, but specify a different cancellation slot. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.CancellationSlot OtherCancellationSlot]``>
-  cancellation_slot_binder(
-      const cancellation_slot_type & s,
-      cancellation_slot_binder< U, OtherCancellationSlot > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancellation_slot_type cancellation_slot_binder::cancellation_slot_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.cancellation_slot_type..cancellation_slot_type..cancellation_slot_binder] 
-The type of the associated cancellation slot. 
-
-
-  typedef CancellationSlot cancellation_slot_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:first_argument_type cancellation_slot_binder::first_argument_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.first_argument_type..first_argument_type..cancellation_slot_binder] 
-The type of the function's first argument. 
-
-
-  typedef see_below first_argument_type;
-
-
-
-The type of `first_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `first_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `first_argument_type` is a synonym for `T::first_argument_type`;
-
-
-* otherwise `first_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:get cancellation_slot_binder::get]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.get..get..cancellation_slot_binder] 
-Obtain a reference to the target object. 
-
-
-  target_type & ``[link asio.reference.cancellation_slot_binder.get.overload1 get]``();
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.get.overload1 more...]]``
-
-  const target_type & ``[link asio.reference.cancellation_slot_binder.get.overload2 get]``() const;
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.get.overload2 more...]]``
-
-
-[section:overload1 cancellation_slot_binder::get (1 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  target_type & get();
-
-
-
-[endsect]
-
-
-
-[section:overload2 cancellation_slot_binder::get (2 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  const target_type & get() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_cancellation_slot cancellation_slot_binder::get_cancellation_slot]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.get_cancellation_slot..get_cancellation_slot..cancellation_slot_binder] 
-Obtain the associated cancellation slot. 
-
-
-  cancellation_slot_type get_cancellation_slot() const;
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ cancellation_slot_binder::operator()]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.operator_lp__rp_..operator()..cancellation_slot_binder] 
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.cancellation_slot_binder.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.cancellation_slot_binder.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.cancellation_slot_binder.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 cancellation_slot_binder::operator() (1 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 cancellation_slot_binder::operator() (2 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:result_type cancellation_slot_binder::result_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.result_type..result_type..cancellation_slot_binder] 
-The return type if a function. 
-
-
-  typedef see_below result_type;
-
-
-
-The type of `result_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to function type, `result_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `result_type`, then `result_type` is a synonym for `T::result_type`;
-
-
-* otherwise `result_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:second_argument_type cancellation_slot_binder::second_argument_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.second_argument_type..second_argument_type..cancellation_slot_binder] 
-The type of the function's second argument. 
-
-
-  typedef see_below second_argument_type;
-
-
-
-The type of `second_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `second_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `second_argument_type` is a synonym for `T::second_argument_type`;
-
-
-* otherwise `second_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:target_type cancellation_slot_binder::target_type]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder.target_type..target_type..cancellation_slot_binder] 
-The type of the target object. 
-
-
-  typedef T target_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_cancellation_slot_binder cancellation_slot_binder::~cancellation_slot_binder]
-
-[indexterm2 asio.indexterm.cancellation_slot_binder._cancellation_slot_binder..~cancellation_slot_binder..cancellation_slot_binder] 
-Destructor. 
-
-
-  ~cancellation_slot_binder();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:cancellation_state cancellation_state]
-
-[indexterm1 asio.indexterm.cancellation_state..cancellation_state]
-
-
-A cancellation state is used for chaining signals and slots in compositions. 
-
-
-  class cancellation_state
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_state.cancellation_state [*cancellation_state]] [constructor]]
-    [Construct a disconnected cancellation state. 
-     [hr]
-     Construct and attach to a parent slot to create a new child slot. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_state.cancelled [*cancelled]]]
-    [Returns the cancellation types that have been triggered. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_state.clear [*clear]]]
-    [Clears the specified cancellation types, if they have been triggered. ]
-  ]
-  
-  [
-    [[link asio.reference.cancellation_state.slot [*slot]]]
-    [Returns the single child slot associated with the state. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:cancellation_state cancellation_state::cancellation_state]
-
-[indexterm2 asio.indexterm.cancellation_state.cancellation_state..cancellation_state..cancellation_state] 
-Construct a disconnected cancellation state. 
-
-
-  constexpr ``[link asio.reference.cancellation_state.cancellation_state.overload1 cancellation_state]``();
-  ``  [''''&raquo;''' [link asio.reference.cancellation_state.cancellation_state.overload1 more...]]``
-
-
-Construct and attach to a parent slot to create a new child slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  explicit constexpr ``[link asio.reference.cancellation_state.cancellation_state.overload2 cancellation_state]``(
-      CancellationSlot slot);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_state.cancellation_state.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename Filter>
-  constexpr ``[link asio.reference.cancellation_state.cancellation_state.overload3 cancellation_state]``(
-      CancellationSlot slot,
-      Filter filter);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_state.cancellation_state.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename InFilter,
-      typename OutFilter>
-  constexpr ``[link asio.reference.cancellation_state.cancellation_state.overload4 cancellation_state]``(
-      CancellationSlot slot,
-      InFilter in_filter,
-      OutFilter out_filter);
-  ``  [''''&raquo;''' [link asio.reference.cancellation_state.cancellation_state.overload4 more...]]``
-
-
-[section:overload1 cancellation_state::cancellation_state (1 of 4 overloads)]
-
-
-Construct a disconnected cancellation state. 
-
-
-  constexpr cancellation_state();
-
-
-
-[endsect]
-
-
-
-[section:overload2 cancellation_state::cancellation_state (2 of 4 overloads)]
-
-
-Construct and attach to a parent slot to create a new child slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  constexpr cancellation_state(
-      CancellationSlot slot);
-
-
-Initialises the cancellation state so that it allows terminal cancellation only. Equivalent to `cancellation_state(slot,
-enable_terminal_cancellation())`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[slot][The parent cancellation slot to which the state will be attached. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 cancellation_state::cancellation_state (3 of 4 overloads)]
-
-
-Construct and attach to a parent slot to create a new child slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename Filter>
-  constexpr cancellation_state(
-      CancellationSlot slot,
-      Filter filter);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[slot][The parent cancellation slot to which the state will be attached.]]
-
-[[filter][A function object that is used to transform incoming cancellation signals as they are received from the parent slot. This function object must have the signature: 
-``
-  asio::cancellation_type_t filter(
-     asio::cancellation_type_t); 
-``
-]]
-
-]
-
-The library provides the following pre-defined cancellation filters:
-
-
-* [link asio.reference.disable_cancellation `disable_cancellation`] 
-
-* [link asio.reference.enable_terminal_cancellation `enable_terminal_cancellation`] 
-
-* [link asio.reference.enable_partial_cancellation `enable_partial_cancellation`] 
-
-* [link asio.reference.enable_total_cancellation `enable_total_cancellation`] 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 cancellation_state::cancellation_state (4 of 4 overloads)]
-
-
-Construct and attach to a parent slot to create a new child slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``,
-      typename InFilter,
-      typename OutFilter>
-  constexpr cancellation_state(
-      CancellationSlot slot,
-      InFilter in_filter,
-      OutFilter out_filter);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[slot][The parent cancellation slot to which the state will be attached.]]
-
-[[in_filter][A function object that is used to transform incoming cancellation signals as they are received from the parent slot. This function object must have the signature: 
-``
-  asio::cancellation_type_t in_filter(
-     asio::cancellation_type_t); 
-``
-]]
-
-[[out_filter][A function object that is used to transform outcoming cancellation signals as they are relayed to the child slot. This function object must have the signature: 
-``
-  asio::cancellation_type_t out_filter(
-     asio::cancellation_type_t); 
-``
-]]
-
-]
-
-The library provides the following pre-defined cancellation filters:
-
-
-* [link asio.reference.disable_cancellation `disable_cancellation`] 
-
-* [link asio.reference.enable_terminal_cancellation `enable_terminal_cancellation`] 
-
-* [link asio.reference.enable_partial_cancellation `enable_partial_cancellation`] 
-
-* [link asio.reference.enable_total_cancellation `enable_total_cancellation`] 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancelled cancellation_state::cancelled]
-
-[indexterm2 asio.indexterm.cancellation_state.cancelled..cancelled..cancellation_state] 
-Returns the cancellation types that have been triggered. 
-
-
-  cancellation_type_t cancelled() const;
-
-
-
-[endsect]
-
-
-
-[section:clear cancellation_state::clear]
-
-[indexterm2 asio.indexterm.cancellation_state.clear..clear..cancellation_state] 
-Clears the specified cancellation types, if they have been triggered. 
-
-
-  void clear(
-      cancellation_type_t mask = cancellation_type::all);
-
-
-
-[endsect]
-
-
-
-[section:slot cancellation_state::slot]
-
-[indexterm2 asio.indexterm.cancellation_state.slot..slot..cancellation_state] 
-Returns the single child slot associated with the state. 
-
-
-  constexpr cancellation_slot slot() const;
-
-
-This sub-slot is used with the operations that are being composed. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:cancellation_type cancellation_type]
-
-[indexterm1 asio.indexterm.cancellation_type..cancellation_type]
-
-Enumeration representing the different types of cancellation that may be requested from or implemented by an asynchronous operation. 
-
-  enum class cancellation_type : unsigned int
-
-[indexterm2 asio.indexterm.cancellation_type.none..none..cancellation_type]
-[indexterm2 asio.indexterm.cancellation_type.terminal..terminal..cancellation_type]
-[indexterm2 asio.indexterm.cancellation_type.partial..partial..cancellation_type]
-[indexterm2 asio.indexterm.cancellation_type.total..total..cancellation_type]
-[indexterm2 asio.indexterm.cancellation_type.all..all..cancellation_type]
-
-[heading Values]
-[variablelist
-
-  [
-    [none]
-    [Bitmask representing no types of cancellation. ]
-  ]
-
-  [
-    [terminal]
-    [Requests cancellation where, following a successful cancellation, the only safe operations on the I/O object are closure or destruction. ]
-  ]
-
-  [
-    [partial]
-    [Requests cancellation where a successful cancellation may result in partial side effects or no side effects. Following cancellation, the I/O object is in a well-known state, and may be used for further operations. ]
-  ]
-
-  [
-    [total]
-    [Requests cancellation where a successful cancellation results in no apparent side effects. Following cancellation, the I/O object is in the same observable state as it was prior to the operation. ]
-  ]
-
-  [
-    [all]
-    [Bitmask representing all types of cancellation. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_type.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:cancellation_type_t cancellation_type_t]
-
-[indexterm1 asio.indexterm.cancellation_type_t..cancellation_type_t]
-
-Portability typedef. 
-
-
-  typedef cancellation_type cancellation_type_t;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_type.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:co_composed co_composed]
-
-[indexterm1 asio.indexterm.co_composed..co_composed]
-
-Creates an initiation function object that may be used to launch a coroutine-based composed asynchronous operation. 
-
-
-  template<
-      typename... Signatures,
-      typename Implementation,
-      typename... IoObjectsOrExecutors>
-  auto co_composed(
-      Implementation && implementation,
-      IoObjectsOrExecutors &&... io_objects_or_executors);
-
-
-The co\_composed utility simplifies the implementation of composed asynchronous operations by automatically adapting a coroutine to be an initiation function object for use with `async_initiate`. When awaiting asynchronous operations, the coroutine automatically uses a conforming intermediate completion handler.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[implementation][A function object that contains the coroutine-based implementation of the composed asynchronous operation. The first argument to the function object represents the state of the operation, and may be used to test for cancellation. The remaining arguments are those passed to `async_initiate` after the completion token.]]
-
-[[io_objects_or_executors][Zero or more I/O objects or I/O executors for which outstanding work must be maintained while the operation is incomplete.]]
-
-]
-
-
-[heading Per-Operation Cancellation]
-  
-By default, terminal per-operation cancellation is enabled for composed operations that use co\_composed. To disable cancellation for the composed operation, or to alter its supported cancellation types, call the state's `reset_cancellation_state` function.
-
-
-[heading Examples]
-  
-The following example illustrates manual error handling and explicit checks for cancellation. The completion handler is invoked via a `co_yield` to the state's `complete` function, which never returns.
-
-
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(std::error_code)>(
-        asio::co_composed(
-          [](auto state, tcp::socket& socket) -> void
-          {
-            state.reset_cancellation_state(
-              asio::enable_terminal_cancellation());
-
-            while (!state.cancelled())
-            {
-              char data[1024];
-              auto [e1, n1] =
-                co_await socket.async_read_some(
-                  asio::buffer(data));
-
-              if (e1)
-                co_yield state.complete(e1);
-
-              if (!!state.cancelled())
-                co_yield state.complete(
-                  make_error_code(asio::error::operation_aborted));
-
-              auto [e2, n2] =
-                co_await asio::async_write(socket,
-                  asio::buffer(data, n1));
-
-              if (e2)
-                co_yield state.complete(e2);
-            }
-          }, socket),
-        token, std::ref(socket));
-  } 
-
-
-
-
-This next example shows exception-based error handling and implicit checks for cancellation. The completion handler is invoked after returning from the coroutine via `co_return`. Valid `co_return` values are specified using completion signatures passed to the `co_composed` function.
-
-
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      CompletionToken&& token)
-  {
-    return asio::async_initiate<
-      CompletionToken, void(std::error_code)>(
-        asio::co_composed<
-          void(std::error_code)>(
-            [](auto state, tcp::socket& socket) -> void
-            {
-              try
-              {
-                state.throw_if_cancelled(true);
-                state.reset_cancellation_state(
-                  asio::enable_terminal_cancellation());
-
-                for (;;)
-                {
-                  char data[1024];
-                  std::size_t n = co_await socket.async_read_some(
-                      asio::buffer(data));
-
-                  co_await asio::async_write(socket,
-                      asio::buffer(data, n));
-                }
-              }
-              catch (const std::system_error& e)
-              {
-                co_return {e.code()};
-              }
-            }, socket),
-        token, std::ref(socket));
-  } 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/co_composed.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:co_spawn co_spawn]
-
-[indexterm1 asio.indexterm.co_spawn..co_spawn]
-
-Spawn a new coroutined-based thread of execution. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload1 co_spawn]``(
-      const Executor & ex,
-      awaitable< T, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t<(is_executor< Executor >::value||execution::is_executor< Executor >::value) &&is_convertible< Executor, AwaitableExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload2 co_spawn]``(
-      const Executor & ex,
-      awaitable< void, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t<(is_executor< Executor >::value||execution::is_executor< Executor >::value) &&is_convertible< Executor, AwaitableExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload2 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename T,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload3 co_spawn]``(
-      ExecutionContext & ctx,
-      awaitable< T, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload3 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload4 co_spawn]``(
-      ExecutionContext & ctx,
-      awaitable< void, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload5 co_spawn]``(
-      const Executor & ex,
-      F && f,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload5 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename F,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.co_spawn.overload6 co_spawn]``(
-      ExecutionContext & ctx,
-      F && f,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.co_spawn.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/co_spawn.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 co_spawn (1 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename T,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      const Executor & ex,
-      awaitable< T, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t<(is_executor< Executor >::value||execution::is_executor< Executor >::value) &&is_convertible< Executor, AwaitableExecutor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The executor that will be used to schedule the new thread of execution.]]
-
-[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
-``
-  void handler(std::exception_ptr, T); 
-``
-]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, T) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<std::size_t> echo(tcp::socket socket)
-  {
-    std::size_t bytes_transferred = 0;
-
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-
-        bytes_transferred += n;
-      }
-    }
-    catch (const std::exception&)
-    {
-    }
-
-    co_return bytes_transferred;
-  }
-
-  // ...
-
-  asio::co_spawn(my_executor,
-    echo(std::move(my_tcp_socket)),
-    [](std::exception_ptr e, std::size_t n)
-    {
-      std::cout << "transferred " << n << "\n";
-    });
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 co_spawn (2 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      const Executor & ex,
-      awaitable< void, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t<(is_executor< Executor >::value||execution::is_executor< Executor >::value) &&is_convertible< Executor, AwaitableExecutor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The executor that will be used to schedule the new thread of execution.]]
-
-[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
-``
-  void handler(std::exception_ptr); 
-``
-]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-      }
-    }
-    catch (const std::exception& e)
-    {
-      std::cerr << "Exception: " << e.what() << "\n";
-    }
-  }
-
-  // ...
-
-  asio::co_spawn(my_executor,
-    echo(std::move(my_tcp_socket)),
-    asio::detached);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 co_spawn (3 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename T,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      ExecutionContext & ctx,
-      awaitable< T, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
-
-[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
-``
-  void handler(std::exception_ptr); 
-``
-]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, T) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<std::size_t> echo(tcp::socket socket)
-  {
-    std::size_t bytes_transferred = 0;
-
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-
-        bytes_transferred += n;
-      }
-    }
-    catch (const std::exception&)
-    {
-    }
-
-    co_return bytes_transferred;
-  }
-
-  // ...
-
-  asio::co_spawn(my_io_context,
-    echo(std::move(my_tcp_socket)),
-    [](std::exception_ptr e, std::size_t n)
-    {
-      std::cout << "transferred " << n << "\n";
-    });
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 co_spawn (4 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Executor1 AwaitableExecutor]``,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      ExecutionContext & ctx,
-      awaitable< void, AwaitableExecutor > a,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value &&is_convertible< typename ExecutionContext::executor_type, AwaitableExecutor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
-
-[[a][The [link asio.reference.awaitable `awaitable`] object that is the result of calling the coroutine's entry point function.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. The function signature of the completion handler must be: 
-``
-  void handler(std::exception_ptr); 
-``
-]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> echo(tcp::socket socket)
-  {
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-      }
-    }
-    catch (const std::exception& e)
-    {
-      std::cerr << "Exception: " << e.what() << "\n";
-    }
-  }
-
-  // ...
-
-  asio::co_spawn(my_io_context,
-    echo(std::move(my_tcp_socket)),
-    asio::detached);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 co_spawn (5 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      const Executor & ex,
-      F && f,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The executor that will be used to schedule the new thread of execution.]]
-
-[[f][A nullary function object with a return type of the form `asio::awaitable<R,E>` that will be used as the coroutine's entry point.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. If `R` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the first template argument to the `awaitable` returned by the supplied function object `F:` 
-
-  asio::awaitable<R, AwaitableExecutor> F() 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<std::size_t> echo(tcp::socket socket)
-  {
-    std::size_t bytes_transferred = 0;
-
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-
-        bytes_transferred += n;
-      }
-    }
-    catch (const std::exception&)
-    {
-    }
-
-    co_return bytes_transferred;
-  }
-
-  // ...
-
-  asio::co_spawn(my_executor,
-    [socket = std::move(my_tcp_socket)]() mutable
-      -> asio::awaitable<void>
-    {
-      try
-      {
-        char data[1024];
-        for (;;)
-        {
-          std::size_t n = co_await socket.async_read_some(
-              asio::buffer(data), asio::use_awaitable);
-
-          co_await asio::async_write(socket,
-              asio::buffer(data, n), asio::use_awaitable);
-        }
-      }
-      catch (const std::exception& e)
-      {
-        std::cerr << "Exception: " << e.what() << "\n";
-      }
-    }, asio::detached);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 co_spawn (6 of 6 overloads)]
-
-
-Spawn a new coroutined-based thread of execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename F,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      ExecutionContext & ctx,
-      F && f,
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context that will provide the executor to be used to schedule the new thread of execution.]]
-
-[[f][A nullary function object with a return type of the form `asio::awaitable<R,E>` that will be used as the coroutine's entry point.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the thread of execution has completed. If `R` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the first template argument to the `awaitable` returned by the supplied function object `F:` 
-
-  asio::awaitable<R, AwaitableExecutor> F() 
-
-
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<std::size_t> echo(tcp::socket socket)
-  {
-    std::size_t bytes_transferred = 0;
-
-    try
-    {
-      char data[1024];
-      for (;;)
-      {
-        std::size_t n = co_await socket.async_read_some(
-            asio::buffer(data), asio::use_awaitable);
-
-        co_await asio::async_write(socket,
-            asio::buffer(data, n), asio::use_awaitable);
-
-        bytes_transferred += n;
-      }
-    }
-    catch (const std::exception&)
-    {
-    }
-
-    co_return bytes_transferred;
-  }
-
-  // ...
-
-  asio::co_spawn(my_io_context,
-    [socket = std::move(my_tcp_socket)]() mutable
-      -> asio::awaitable<void>
-    {
-      try
-      {
-        char data[1024];
-        for (;;)
-        {
-          std::size_t n = co_await socket.async_read_some(
-              asio::buffer(data), asio::use_awaitable);
-
-          co_await asio::async_write(socket,
-              asio::buffer(data, n), asio::use_awaitable);
-        }
-      }
-      catch (const std::exception& e)
-      {
-        std::cerr << "Exception: " << e.what() << "\n";
-      }
-    }, asio::detached);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call [link asio.reference.this_coro__reset_cancellation_state `this_coro::reset_cancellation_state`]. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:completion_signature_of completion_signature_of]
-
-[indexterm1 asio.indexterm.completion_signature_of..completion_signature_of]
-
-
-The [link asio.reference.completion_signature_of `completion_signature_of`] trait determines the completion signature of an asynchronous operation. 
-
-
-  template<
-      typename T,
-      typename... Args>
-  struct completion_signature_of
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.completion_signature_of.type [*type]]]
-    []
-  
-  ]
-
-]
-
-Class template `completion_signature_of` is a trait with a member type alias `type` that denotes the completion signature of the asynchronous operation initiated by the expression `T(Args..., token)` operation, where `token` is an unspecified completion token type. If the asynchronous operation does not have exactly one completion signature, the instantion of the trait is well-formed but the member type alias `type` is omitted. If the expression `T(Args..., token)` is not an asynchronous operation then use of the trait is ill-formed. 
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type completion_signature_of::type]
-
-[indexterm2 asio.indexterm.completion_signature_of.type..type..completion_signature_of] 
-
-  typedef automatically_determined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:completion_signature_of_t completion_signature_of_t]
-
-[indexterm1 asio.indexterm.completion_signature_of_t..completion_signature_of_t]
-
-
-  typedef typename completion_signature_of< T, Args... >::type completion_signature_of_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.completion_signature_of.type [*type]]]
-    []
-  
-  ]
-
-]
-
-Class template `completion_signature_of` is a trait with a member type alias `type` that denotes the completion signature of the asynchronous operation initiated by the expression `T(Args..., token)` operation, where `token` is an unspecified completion token type. If the asynchronous operation does not have exactly one completion signature, the instantion of the trait is well-formed but the member type alias `type` is omitted. If the expression `T(Args..., token)` is not an asynchronous operation then use of the trait is ill-formed. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:composed composed]
-
-[indexterm1 asio.indexterm.composed..composed]
-
-Creates an initiation function object that may be used to launch an asynchronous operation with a stateful implementation. 
-
-
-  template<
-      typename... Signatures,
-      typename Implementation,
-      typename... IoObjectsOrExecutors>
-  auto composed(
-      Implementation && implementation,
-      IoObjectsOrExecutors &&... io_objects_or_executors);
-
-
-The `composed` function simplifies the implementation of composed asynchronous operations automatically by wrapping a stateful function object for use as an initiation function object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[implementation][A function object that contains the implementation of the composed asynchronous operation. The first argument to the function object is a non-const reference to the enclosing intermediate completion handler. The remaining arguments are any arguments that originate from the completion handlers of any asynchronous operations performed by the implementation.]]
-
-[[io_objects_or_executors][Zero or more I/O objects or I/O executors for which outstanding work must be maintained.]]
-
-]
-
-
-[heading Per-Operation Cancellation]
-  
-By default, terminal per-operation cancellation is enabled for composed operations that are implemented using `composed`. To disable cancellation for the composed operation, or to alter its supported cancellation types, call the `self` object's `reset_cancellation_state` function.
-
-
-[heading Example:]
-  
-
-
-
-
-  struct async_echo_implementation
-  {
-    tcp::socket& socket_;
-    asio::mutable_buffer buffer_;
-    enum { starting, reading, writing } state_;
-
-    template <typename Self>
-    void operator()(Self& self,
-        asio::error_code error,
-        std::size_t n)
-    {
-      switch (state_)
-      {
-      case starting:
-        state_ = reading;
-        socket_.async_read_some(
-            buffer_, std::move(self));
-        break;
-      case reading:
-        if (error)
-        {
-          self.complete(error, 0);
-        }
-        else
-        {
-          state_ = writing;
-          asio::async_write(socket_, buffer_,
-              asio::transfer_exactly(n),
-              std::move(self));
-        }
-        break;
-      case writing:
-        self.complete(error, n);
-        break;
-      }
-    }
-  };
-
-  template <typename CompletionToken>
-  auto async_echo(tcp::socket& socket,
-      asio::mutable_buffer buffer,
-      CompletionToken&& token)
-    -> decltype(
-      asio::async_initiate<CompletionToken,
-        void(asio::error_code, std::size_t)>(
-          asio::composed(
-            async_echo_implementation{socket, buffer,
-              async_echo_implementation::starting}, socket),
-          token))
-  {
-    return asio::async_initiate<CompletionToken,
-      void(asio::error_code, std::size_t)>(
-        asio::composed(
-          async_echo_implementation{socket, buffer,
-            async_echo_implementation::starting}, socket),
-        token, asio::error_code{}, 0);
-  } 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/composed.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:connect connect]
-
-[indexterm1 asio.indexterm.connect..connect]
-
-The `connect` function is a composed operation that establishes a socket connection by trying each endpoint in a sequence. 
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``>
-  Protocol::endpoint ``[link asio.reference.connect.overload1 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``>
-  Protocol::endpoint ``[link asio.reference.connect.overload2 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      asio::error_code & ec,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload2 more...]]``
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator ``[link asio.reference.connect.overload3 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator ``[link asio.reference.connect.overload4 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      asio::error_code & ec,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload4 more...]]``
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator ``[link asio.reference.connect.overload5 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator ``[link asio.reference.connect.overload6 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Protocol::endpoint ``[link asio.reference.connect.overload7 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Protocol::endpoint ``[link asio.reference.connect.overload8 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload8 more...]]``
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator ``[link asio.reference.connect.overload9 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator ``[link asio.reference.connect.overload10 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload10 more...]]``
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator ``[link asio.reference.connect.overload11 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload11 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator ``[link asio.reference.connect.overload12 connect]``(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.connect.overload12 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/connect.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 connect (1 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``>
-  Protocol::endpoint connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-]
-
-
-[heading Return Value]
-      
-The successfully connected endpoint.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-  asio::connect(s, r.resolve(q)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 connect (2 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``>
-  Protocol::endpoint connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      asio::error_code & ec,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, the successfully connected endpoint. Otherwise, a default-constructed endpoint.
-
-
-[heading Example]
-  
-
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-  asio::error_code ec;
-  asio::connect(s, r.resolve(q), ec);
-  if (ec)
-  {
-    // An error occurred.
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 connect (3 of 12 overloads)]
-
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 connect (4 of 12 overloads)]
-
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      asio::error_code & ec,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 connect (5 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-]
-
-
-[heading Return Value]
-      
-An iterator denoting the successfully connected endpoint.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Example]
-  
-
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::resolver::results_type e = r.resolve(q);
-  tcp::socket s(my_context);
-  asio::connect(s, e.begin(), e.end()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 connect (6 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      asio::error_code & ec);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Example]
-  
-
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::resolver::results_type e = r.resolve(q);
-  tcp::socket s(my_context);
-  asio::error_code ec;
-  asio::connect(s, e.begin(), e.end(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 connect (7 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Protocol::endpoint connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-]
-
-
-[heading Return Value]
-      
-The successfully connected endpoint.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-  tcp::endpoint e = asio::connect(s,
-      r.resolve(q), my_connect_condition());
-  std::cout << "Connected to: " << e << std::endl; 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 connect (8 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.EndpointSequence EndpointSequence]``,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Protocol::endpoint connect(
-      basic_socket< Protocol, Executor > & s,
-      const EndpointSequence & endpoints,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< is_endpoint_sequence< EndpointSequence >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, decltype(declval< const EndpointSequence & >().begin())>::value >= 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[endpoints][A sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, the successfully connected endpoint. Otherwise, a default-constructed endpoint.
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::socket s(my_context);
-  asio::error_code ec;
-  tcp::endpoint e = asio::connect(s,
-      r.resolve(q), my_connect_condition(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  else
-  {
-    std::cout << "Connected to: " << e << std::endl;
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 connect (9 of 12 overloads)]
-
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 connect (10 of 12 overloads)]
-
-
-(Deprecated: Use range overload.) Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< !is_endpoint_sequence< Iterator >::value >  = 0,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Remarks]
-      
-This overload assumes that a default constructed object of type `Iterator` represents the end of the sequence. This is a valid assumption for iterator types such as `asio::ip::tcp::resolver::iterator`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 connect (11 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-]
-
-
-[heading Return Value]
-      
-An iterator denoting the successfully connected endpoint.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the sequence is empty, the associated `error_code` is `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::resolver::results_type e = r.resolve(q);
-  tcp::socket s(my_context);
-  tcp::resolver::results_type::iterator i = asio::connect(
-      s, e.begin(), e.end(), my_connect_condition());
-  std::cout << "Connected to: " << i->endpoint() << std::endl; 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 connect (12 of 12 overloads)]
-
-
-Establishes a socket connection by trying each endpoint in a sequence. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Iterator,
-      typename ``[link asio.reference.ConnectCondition ConnectCondition]``>
-  Iterator connect(
-      basic_socket< Protocol, Executor > & s,
-      Iterator begin,
-      Iterator end,
-      ConnectCondition connect_condition,
-      asio::error_code & ec,
-      constraint_t< is_connect_condition< ConnectCondition, Iterator >::value >  = 0);
-
-
-This function attempts to connect a socket to one of a sequence of endpoints. It does this by repeated calls to the socket's `connect` member function, once for each endpoint in the sequence, until a connection is successfully established.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The socket to be connected. If the socket is already open, it will be closed.]]
-
-[[begin][An iterator pointing to the start of a sequence of endpoints.]]
-
-[[end][An iterator pointing to the end of a sequence of endpoints.]]
-
-[[connect_condition][A function object that is called prior to each connection attempt. The signature of the function object must be: 
-``
-  bool connect_condition(
-     const asio::error_code& ec,
-     const typename Protocol::endpoint& next); 
-``
-The `ec` parameter contains the result from the most recent connect operation. Before the first connection attempt, `ec` is always set to indicate success. The `next` parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped.]]
-
-[[ec][Set to indicate what error occurred, if any. If the sequence is empty, set to `asio::error::not_found`. Otherwise, contains the error from the last connection attempt.]]
-
-]
-
-
-[heading Return Value]
-      
-On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
-
-
-[heading Example]
-  
-The following connect condition function object can be used to output information about the individual connection attempts: 
-
-  struct my_connect_condition
-  {
-    bool operator()(
-        const asio::error_code& ec,
-        const::tcp::endpoint& next)
-    {
-      if (ec) std::cout << "Error: " << ec.message() << std::endl;
-      std::cout << "Trying: " << next << std::endl;
-      return true;
-    }
-  }; 
-
-
-It would be used with the [link asio.reference.connect `connect`] function as follows: 
-
-  tcp::resolver r(my_context);
-  tcp::resolver::query q("host", "service");
-  tcp::resolver::results_type e = r.resolve(q);
-  tcp::socket s(my_context);
-  asio::error_code ec;
-  tcp::resolver::results_type::iterator i = asio::connect(
-      s, e.begin(), e.end(), my_connect_condition());
-  if (ec)
-  {
-    // An error occurred.
-  }
-  else
-  {
-    std::cout << "Connected to: " << i->endpoint() << std::endl;
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:connect_pipe connect_pipe]
-
-[indexterm1 asio.indexterm.connect_pipe..connect_pipe]
-
-Connect two pipe ends using an anonymous pipe. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void ``[link asio.reference.connect_pipe.overload1 connect_pipe]``(
-      basic_readable_pipe< Executor1 > & read_end,
-      basic_writable_pipe< Executor2 > & write_end);
-  ``  [''''&raquo;''' [link asio.reference.connect_pipe.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void ``[link asio.reference.connect_pipe.overload2 connect_pipe]``(
-      basic_readable_pipe< Executor1 > & read_end,
-      basic_writable_pipe< Executor2 > & write_end,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.connect_pipe.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/connect_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 connect_pipe (1 of 2 overloads)]
-
-
-Connect two pipe ends using an anonymous pipe. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void connect_pipe(
-      basic_readable_pipe< Executor1 > & read_end,
-      basic_writable_pipe< Executor2 > & write_end);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[read_end][The read end of the pipe.]]
-
-[[write_end][The write end of the pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 connect_pipe (2 of 2 overloads)]
-
-
-Connect two pipe ends using an anonymous pipe. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void connect_pipe(
-      basic_readable_pipe< Executor1 > & read_end,
-      basic_writable_pipe< Executor2 > & write_end,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[read_end][The read end of the pipe.]]
-
-[[write_end][The write end of the pipe.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:consign consign]
-
-[indexterm1 asio.indexterm.consign..consign]
-
-Completion token adapter used to specify that the completion handler should carry additional values along with it. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  constexpr consign_t< decay_t< CompletionToken >, decay_t< Values >... > consign(
-      CompletionToken && completion_token,
-      Values &&... values);
-
-
-This completion token adapter is typically used to keep at least one copy of an object, such as a smart pointer, alive until the completion handler is called. 
-
-[heading Requirements]
-
-['Header: ][^asio/consign.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:consign_t consign_t]
-
-[indexterm1 asio.indexterm.consign_t..consign_t]
-
-
-Completion token type used to specify that the completion handler should carry additional values along with it. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  class consign_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.consign_t.consign_t [*consign_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-This completion token adapter is typically used to keep at least one copy of an object, such as a smart pointer, alive until the completion handler is called. 
-
-[heading Requirements]
-
-['Header: ][^asio/consign.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:consign_t consign_t::consign_t]
-
-[indexterm2 asio.indexterm.consign_t.consign_t..consign_t..consign_t] 
-Constructor. 
-
-
-  template<
-      typename T,
-      typename... V>
-  constexpr consign_t(
-      T && completion_token,
-      V &&... values);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:const_buffer const_buffer]
-
-[indexterm1 asio.indexterm.const_buffer..const_buffer]
-
-
-Holds a buffer that cannot be modified. 
-
-
-  class const_buffer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.const_buffer [*const_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. 
-     [hr]
-     Construct a non-modifiable buffer from a modifiable one. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.const_buffer `const_buffer`] class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::const_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:const_buffer const_buffer::const_buffer]
-
-[indexterm2 asio.indexterm.const_buffer.const_buffer..const_buffer..const_buffer] 
-Construct an empty buffer. 
-
-
-  ``[link asio.reference.const_buffer.const_buffer.overload1 const_buffer]``();
-  ``  [''''&raquo;''' [link asio.reference.const_buffer.const_buffer.overload1 more...]]``
-
-
-Construct a buffer to represent a given memory range. 
-
-
-  ``[link asio.reference.const_buffer.const_buffer.overload2 const_buffer]``(
-      const void * data,
-      std::size_t size);
-  ``  [''''&raquo;''' [link asio.reference.const_buffer.const_buffer.overload2 more...]]``
-
-
-Construct a non-modifiable buffer from a modifiable one. 
-
-
-  ``[link asio.reference.const_buffer.const_buffer.overload3 const_buffer]``(
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_buffer.const_buffer.overload3 more...]]``
-
-
-[section:overload1 const_buffer::const_buffer (1 of 3 overloads)]
-
-
-Construct an empty buffer. 
-
-
-  const_buffer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_buffer::const_buffer (2 of 3 overloads)]
-
-
-Construct a buffer to represent a given memory range. 
-
-
-  const_buffer(
-      const void * data,
-      std::size_t size);
-
-
-
-[endsect]
-
-
-
-[section:overload3 const_buffer::const_buffer (3 of 3 overloads)]
-
-
-Construct a non-modifiable buffer from a modifiable one. 
-
-
-  const_buffer(
-      const mutable_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:data const_buffer::data]
-
-[indexterm2 asio.indexterm.const_buffer.data..data..const_buffer] 
-Get a pointer to the beginning of the memory range. 
-
-
-  const void * data() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus_ const_buffer::operator+]
-
-[indexterm2 asio.indexterm.const_buffer.operator_plus_..operator+..const_buffer] 
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer ``[link asio.reference.const_buffer.operator_plus_.overload1 operator+]``(
-      const const_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.const_buffer.operator_plus_.overload1 more...]]``
-
-  const_buffer ``[link asio.reference.const_buffer.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const const_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_buffer.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 const_buffer::operator+ (1 of 2 overloads)]
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer operator+(
-      const const_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_buffer::operator+ (2 of 2 overloads)]
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer operator+(
-      std::size_t n,
-      const const_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ const_buffer::operator+=]
-
-[indexterm2 asio.indexterm.const_buffer.operator_plus__eq_..operator+=..const_buffer] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  const_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size const_buffer::size]
-
-[indexterm2 asio.indexterm.const_buffer.size..size..const_buffer] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:const_buffers_1 const_buffers_1]
-
-[indexterm1 asio.indexterm.const_buffers_1..const_buffers_1]
-
-
-(Deprecated: Use [link asio.reference.const_buffer `const_buffer`].) Adapts a single non-modifiable buffer so that it meets the requirements of the ConstBufferSequence concept. 
-
-
-  class const_buffers_1 :
-    public const_buffer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.const_buffers_1.const_iterator [*const_iterator]]]
-    [A random-access iterator type that may be used to read elements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.const_buffers_1.value_type [*value_type]]]
-    [The type for each element in the list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffers_1.begin [*begin]]]
-    [Get a random-access iterator to the first element. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffers_1.const_buffers_1 [*const_buffers_1]] [constructor]]
-    [Construct to represent a given memory range. 
-     [hr]
-     Construct to represent a single non-modifiable buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffers_1.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffers_1.end [*end]]]
-    [Get a random-access iterator for one past the last element. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffers_1.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffers_1.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffers_1.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:begin const_buffers_1::begin]
-
-[indexterm2 asio.indexterm.const_buffers_1.begin..begin..const_buffers_1] 
-Get a random-access iterator to the first element. 
-
-
-  const_iterator begin() const;
-
-
-
-[endsect]
-
-
-[section:const_buffers_1 const_buffers_1::const_buffers_1]
-
-[indexterm2 asio.indexterm.const_buffers_1.const_buffers_1..const_buffers_1..const_buffers_1] 
-Construct to represent a given memory range. 
-
-
-  ``[link asio.reference.const_buffers_1.const_buffers_1.overload1 const_buffers_1]``(
-      const void * data,
-      std::size_t size);
-  ``  [''''&raquo;''' [link asio.reference.const_buffers_1.const_buffers_1.overload1 more...]]``
-
-
-Construct to represent a single non-modifiable buffer. 
-
-
-  explicit ``[link asio.reference.const_buffers_1.const_buffers_1.overload2 const_buffers_1]``(
-      const const_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_buffers_1.const_buffers_1.overload2 more...]]``
-
-
-[section:overload1 const_buffers_1::const_buffers_1 (1 of 2 overloads)]
-
-
-Construct to represent a given memory range. 
-
-
-  const_buffers_1(
-      const void * data,
-      std::size_t size);
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_buffers_1::const_buffers_1 (2 of 2 overloads)]
-
-
-Construct to represent a single non-modifiable buffer. 
-
-
-  const_buffers_1(
-      const const_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:const_iterator const_buffers_1::const_iterator]
-
-[indexterm2 asio.indexterm.const_buffers_1.const_iterator..const_iterator..const_buffers_1] 
-A random-access iterator type that may be used to read elements. 
-
-
-  typedef const const_buffer * const_iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:data const_buffers_1::data]
-
-
-['Inherited from const_buffer.]
-
-[indexterm2 asio.indexterm.const_buffers_1.data..data..const_buffers_1] 
-Get a pointer to the beginning of the memory range. 
-
-
-  const void * data() const;
-
-
-
-[endsect]
-
-
-
-[section:end const_buffers_1::end]
-
-[indexterm2 asio.indexterm.const_buffers_1.end..end..const_buffers_1] 
-Get a random-access iterator for one past the last element. 
-
-
-  const_iterator end() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus_ const_buffers_1::operator+]
-
-[indexterm2 asio.indexterm.const_buffers_1.operator_plus_..operator+..const_buffers_1] 
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer ``[link asio.reference.const_buffers_1.operator_plus_.overload1 operator+]``(
-      const const_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.const_buffers_1.operator_plus_.overload1 more...]]``
-
-  const_buffer ``[link asio.reference.const_buffers_1.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const const_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_buffers_1.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 const_buffers_1::operator+ (1 of 2 overloads)]
-
-
-['Inherited from const_buffer.]
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer operator+(
-      const const_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_buffers_1::operator+ (2 of 2 overloads)]
-
-
-['Inherited from const_buffer.]
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_buffer operator+(
-      std::size_t n,
-      const const_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ const_buffers_1::operator+=]
-
-
-['Inherited from const_buffer.]
-
-[indexterm2 asio.indexterm.const_buffers_1.operator_plus__eq_..operator+=..const_buffers_1] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  const_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size const_buffers_1::size]
-
-
-['Inherited from const_buffer.]
-
-[indexterm2 asio.indexterm.const_buffers_1.size..size..const_buffers_1] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[section:value_type const_buffers_1::value_type]
-
-[indexterm2 asio.indexterm.const_buffers_1.value_type..value_type..const_buffers_1] 
-The type for each element in the list of buffers. 
-
-
-  typedef const_buffer value_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.const_buffer [*const_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. 
-     [hr]
-     Construct a non-modifiable buffer from a modifiable one. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.const_buffer `const_buffer`] class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::const_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:const_registered_buffer const_registered_buffer]
-
-[indexterm1 asio.indexterm.const_registered_buffer..const_registered_buffer]
-
-
-Holds a registered buffer over non-modifiable data. 
-
-
-  class const_registered_buffer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_registered_buffer.buffer [*buffer]]]
-    [Get the underlying constant buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.const_registered_buffer.const_registered_buffer [*const_registered_buffer]] [constructor]]
-    [Default constructor creates an invalid registered buffer. 
-     [hr]
-     Construct a non-modifiable buffer from a modifiable one. ]
-  ]
-  
-  [
-    [[link asio.reference.const_registered_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_registered_buffer.id [*id]]]
-    [Get the registered buffer identifier. ]
-  ]
-  
-  [
-    [[link asio.reference.const_registered_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_registered_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_registered_buffer.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable registered buffer that is offset from the start of another. 
-
-     Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-Satisfies the `ConstBufferSequence` type requirements. 
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:buffer const_registered_buffer::buffer]
-
-[indexterm2 asio.indexterm.const_registered_buffer.buffer..buffer..const_registered_buffer] 
-Get the underlying constant buffer. 
-
-
-  const const_buffer & buffer() const;
-
-
-
-[endsect]
-
-
-[section:const_registered_buffer const_registered_buffer::const_registered_buffer]
-
-[indexterm2 asio.indexterm.const_registered_buffer.const_registered_buffer..const_registered_buffer..const_registered_buffer] 
-Default constructor creates an invalid registered buffer. 
-
-
-  ``[link asio.reference.const_registered_buffer.const_registered_buffer.overload1 const_registered_buffer]``();
-  ``  [''''&raquo;''' [link asio.reference.const_registered_buffer.const_registered_buffer.overload1 more...]]``
-
-
-Construct a non-modifiable buffer from a modifiable one. 
-
-
-  ``[link asio.reference.const_registered_buffer.const_registered_buffer.overload2 const_registered_buffer]``(
-      const mutable_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_registered_buffer.const_registered_buffer.overload2 more...]]``
-
-
-[section:overload1 const_registered_buffer::const_registered_buffer (1 of 2 overloads)]
-
-
-Default constructor creates an invalid registered buffer. 
-
-
-  const_registered_buffer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_registered_buffer::const_registered_buffer (2 of 2 overloads)]
-
-
-Construct a non-modifiable buffer from a modifiable one. 
-
-
-  const_registered_buffer(
-      const mutable_registered_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:data const_registered_buffer::data]
-
-[indexterm2 asio.indexterm.const_registered_buffer.data..data..const_registered_buffer] 
-Get a pointer to the beginning of the memory range. 
-
-
-  const void * data() const;
-
-
-
-[heading Return Value]
-      
-`buffer().data()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:id const_registered_buffer::id]
-
-[indexterm2 asio.indexterm.const_registered_buffer.id..id..const_registered_buffer] 
-Get the registered buffer identifier. 
-
-
-  const registered_buffer_id & id() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus_ const_registered_buffer::operator+]
-
-[indexterm2 asio.indexterm.const_registered_buffer.operator_plus_..operator+..const_registered_buffer] 
-Create a new non-modifiable registered buffer that is offset from the start of another. 
-
-
-  const_registered_buffer ``[link asio.reference.const_registered_buffer.operator_plus_.overload1 operator+]``(
-      const const_registered_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.const_registered_buffer.operator_plus_.overload1 more...]]``
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_registered_buffer ``[link asio.reference.const_registered_buffer.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const const_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.const_registered_buffer.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 const_registered_buffer::operator+ (1 of 2 overloads)]
-
-
-Create a new non-modifiable registered buffer that is offset from the start of another. 
-
-
-  const_registered_buffer operator+(
-      const const_registered_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 const_registered_buffer::operator+ (2 of 2 overloads)]
-
-
-Create a new non-modifiable buffer that is offset from the start of another. 
-
-
-  const_registered_buffer operator+(
-      std::size_t n,
-      const const_registered_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ const_registered_buffer::operator+=]
-
-[indexterm2 asio.indexterm.const_registered_buffer.operator_plus__eq_..operator+=..const_registered_buffer] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  const_registered_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size const_registered_buffer::size]
-
-[indexterm2 asio.indexterm.const_registered_buffer.size..size..const_registered_buffer] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[heading Return Value]
-      
-`buffer().size()`. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:coroutine coroutine]
-
-[indexterm1 asio.indexterm.coroutine..coroutine]
-
-
-Provides support for implementing stackless coroutines. 
-
-
-  class coroutine
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.coroutine.coroutine [*coroutine]] [constructor]]
-    [Constructs a coroutine in its initial state. ]
-  ]
-  
-  [
-    [[link asio.reference.coroutine.is_child [*is_child]]]
-    [Returns true if the coroutine is the child of a fork. ]
-  ]
-  
-  [
-    [[link asio.reference.coroutine.is_complete [*is_complete]]]
-    [Returns true if the coroutine has reached its terminal state. ]
-  ]
-  
-  [
-    [[link asio.reference.coroutine.is_parent [*is_parent]]]
-    [Returns true if the coroutine is the parent of a fork. ]
-  ]
-  
-]
-
-The `coroutine` class may be used to implement stackless coroutines. The class itself is used to store the current state of the coroutine.
-
-Coroutines are copy-constructible and assignable, and the space overhead is a single int. They can be used as a base class:
-
-
-
-  class session : coroutine
-  {
-    ...
-  }; 
-
-
-
-
-or as a data member:
-
-
-
-  class session
-  {
-    ...
-    coroutine coro_;
-  }; 
-
-
-
-
-or even bound in as a function argument using lambdas or `bind()`. The important thing is that as the application maintains a copy of the object for as long as the coroutine must be kept alive.
-
-
-[heading Pseudo-keywords]
-  
-
-
-A coroutine is used in conjunction with certain "pseudo-keywords", which are implemented as macros. These macros are defined by a header file:
-
-
-
-  #include <asio/yield.hpp>
-
-
-
-
-and may conversely be undefined as follows:
-
-
-
-  #include <asio/unyield.hpp>
-
-
-
-
-[*reenter]
-
-The `reenter` macro is used to define the body of a coroutine. It takes a single argument: a pointer or reference to a coroutine object. For example, if the base class is a coroutine object you may write:
-
-
-
-  reenter (this)
-  {
-    ... coroutine body ...
-  } 
-
-
-
-
-and if a data member or other variable you can write:
-
-
-
-  reenter (coro_)
-  {
-    ... coroutine body ...
-  } 
-
-
-
-
-When `reenter` is executed at runtime, control jumps to the location of the last `yield` or `fork`.
-
-The coroutine body may also be a single statement, such as:
-
-
-
-  reenter (this) for (;;)
-  {
-    ...
-  } 
-
-
-
-
-[*Limitation:] The `reenter` macro is implemented using a switch. This means that you must take care when using local variables within the coroutine body. The local variable is not allowed in a position where reentering the coroutine could bypass the variable definition.
-
-[*yield ['statement]]
-
-This form of the `yield` keyword is often used with asynchronous operations:
-
-
-
-  yield socket_->async_read_some(buffer(*buffer_), *this); 
-
-
-
-
-This divides into four logical steps:
-
-
-* `yield` saves the current state of the coroutine. 
-
-* The statement initiates the asynchronous operation. 
-
-* The resume point is defined immediately following the statement. 
-
-* Control is transferred to the end of the coroutine body.
-
-When the asynchronous operation completes, the function object is invoked and `reenter` causes control to transfer to the resume point. It is important to remember to carry the coroutine state forward with the asynchronous operation. In the above snippet, the current class is a function object object with a coroutine object as base class or data member.
-
-The statement may also be a compound statement, and this permits us to define local variables with limited scope:
-
-
-
-  yield
-  {
-    mutable_buffers_1 b = buffer(*buffer_);
-    socket_->async_read_some(b, *this);
-  } 
-
-
-
-
-[*yield return ['expression] ;]
-
-This form of `yield` is often used in generators or coroutine-based parsers. For example, the function object:
-
-
-
-  struct interleave : coroutine
-  {
-    istream& is1;
-    istream& is2;
-    char operator()(char c)
-    {
-      reenter (this) for (;;)
-      {
-        yield return is1.get();
-        yield return is2.get();
-      }
-    }
-  }; 
-
-
-
-
-defines a trivial coroutine that interleaves the characters from two input streams.
-
-This type of `yield` divides into three logical steps:
-
-
-* `yield` saves the current state of the coroutine. 
-
-* The resume point is defined immediately following the semicolon. 
-
-* The value of the expression is returned from the function.
-
-[*yield ;]
-
-This form of `yield` is equivalent to the following steps:
-
-
-* `yield` saves the current state of the coroutine. 
-
-* The resume point is defined immediately following the semicolon. 
-
-* Control is transferred to the end of the coroutine body.
-
-This form might be applied when coroutines are used for cooperative threading and scheduling is explicitly managed. For example:
-
-
-
-  struct task : coroutine
-  {
-    ...
-    void operator()()
-    {
-      reenter (this)
-      {
-        while (... not finished ...)
-        {
-          ... do something ...
-          yield;
-          ... do some more ...
-          yield;
-        }
-      }
-    }
-    ...
-  };
-  ...
-  task t1, t2;
-  for (;;)
-  {
-    t1();
-    t2();
-  } 
-
-
-
-
-[*yield break ;]
-
-The final form of `yield` is used to explicitly terminate the coroutine. This form is comprised of two steps:
-
-
-* `yield` sets the coroutine state to indicate termination. 
-
-* Control is transferred to the end of the coroutine body.
-
-Once terminated, calls to `is_complete()` return true and the coroutine cannot be reentered.
-
-Note that a coroutine may also be implicitly terminated if the coroutine body is exited without a yield, e.g. by return, throw or by running to the end of the body.
-
-[*fork ['statement]]
-
-The `fork` pseudo-keyword is used when "forking" a coroutine, i.e. splitting it into two (or more) copies. One use of `fork` is in a server, where a new coroutine is created to handle each client connection:
-
-
-
-  reenter (this)
-  {
-    do
-    {
-      socket_.reset(new tcp::socket(my_context_));
-      yield acceptor->async_accept(*socket_, *this);
-      fork server(*this)();
-    } while (is_parent());
-    ... client-specific handling follows ...
-  } 
-
-
-
-
-The logical steps involved in a `fork` are:
-
-
-* `fork` saves the current state of the coroutine. 
-
-* The statement creates a copy of the coroutine and either executes it immediately or schedules it for later execution. 
-
-* The resume point is defined immediately following the semicolon. 
-
-* For the "parent", control immediately continues from the next line.
-
-The functions `is_parent()` and `is_child()` can be used to differentiate between parent and child. You would use these functions to alter subsequent control flow.
-
-Note that `fork` doesn't do the actual forking by itself. It is the application's responsibility to create a clone of the coroutine and call it. The clone can be called immediately, as above, or scheduled for delayed execution using something like [link asio.reference.post `post`].
-
-
-[heading Alternate macro names]
-  
-
-
-If preferred, an application can use macro names that follow a more typical naming convention, rather than the pseudo-keywords. These are:
-
-
-* `ASIO_CORO_REENTER` instead of `reenter` 
-
-* `ASIO_CORO_YIELD` instead of `yield` 
-
-* `ASIO_CORO_FORK` instead of `fork` 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/coroutine.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:coroutine coroutine::coroutine]
-
-[indexterm2 asio.indexterm.coroutine.coroutine..coroutine..coroutine] 
-Constructs a coroutine in its initial state. 
-
-
-  coroutine();
-
-
-
-[endsect]
-
-
-
-[section:is_child coroutine::is_child]
-
-[indexterm2 asio.indexterm.coroutine.is_child..is_child..coroutine] 
-Returns true if the coroutine is the child of a fork. 
-
-
-  bool is_child() const;
-
-
-
-[endsect]
-
-
-
-[section:is_complete coroutine::is_complete]
-
-[indexterm2 asio.indexterm.coroutine.is_complete..is_complete..coroutine] 
-Returns true if the coroutine has reached its terminal state. 
-
-
-  bool is_complete() const;
-
-
-
-[endsect]
-
-
-
-[section:is_parent coroutine::is_parent]
-
-[indexterm2 asio.indexterm.coroutine.is_parent..is_parent..coroutine] 
-Returns true if the coroutine is the parent of a fork. 
-
-
-  bool is_parent() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:deadline_timer deadline_timer]
-
-[indexterm1 asio.indexterm.deadline_timer..deadline_timer]
-
-Typedef for the typical usage of timer. Uses a UTC clock. 
-
-
-  typedef basic_deadline_timer< boost::posix_time::ptime > deadline_timer;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.duration_type [*duration_type]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.time_type [*time_type]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_deadline_timer.traits_type [*traits_type]]]
-    [The time traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_deadline_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.basic_deadline_timer [*basic_deadline_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_at [*expires_at]]]
-    [Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.expires_from_now [*expires_from_now]]]
-    [Get the timer's expiry time relative to now. 
-     [hr]
-     Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_deadline_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_deadline_timer._basic_deadline_timer [*~basic_deadline_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_deadline_timer `basic_deadline_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A deadline timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use the [link asio.reference.deadline_timer `deadline_timer`] typedef.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait: 
-
-  // Construct a timer without setting an expiry time.
-  asio::deadline_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_from_now(boost::posix_time::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait: 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::deadline_timer timer(my_context,
-      boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active deadline_timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_from_now(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_deadline_timer::expires_from_now()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/deadline_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:default_completion_token default_completion_token]
-
-[indexterm1 asio.indexterm.default_completion_token..default_completion_token]
-
-
-Traits type used to determine the default completion token type associated with a type (such as an executor). 
-
-
-  template<
-      typename T>
-  struct default_completion_token
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.default_completion_token.type [*type]]]
-    [If T has a nested type default_completion_token_type, T::default_completion_token_type. Otherwise the typedef type is asio::deferred_t. ]
-  
-  ]
-
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type.
-
-Specialisations of this trait may provide a nested typedef `type`, which is a default-constructible completion token type.
-
-If not otherwise specialised, the default completion token type is [link asio.reference.deferred_t `deferred_t`]. 
-
-[heading Requirements]
-
-['Header: ][^asio/default_completion_token.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type default_completion_token::type]
-
-[indexterm2 asio.indexterm.default_completion_token.type..type..default_completion_token] 
-If `T` has a nested type `default_completion_token_type`, `T::default_completion_token_type`. Otherwise the typedef `type` is [link asio.reference.deferred_t `deferred_t`]. 
-
-
-  typedef see_below type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/default_completion_token.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:default_completion_token_t default_completion_token_t]
-
-[indexterm1 asio.indexterm.default_completion_token_t..default_completion_token_t]
-
-
-  typedef typename default_completion_token< T >::type default_completion_token_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.default_completion_token.type [*type]]]
-    [If T has a nested type default_completion_token_type, T::default_completion_token_type. Otherwise the typedef type is asio::deferred_t. ]
-  
-  ]
-
-]
-
-A program may specialise this traits type if the `T` template parameter in the specialisation is a user-defined type.
-
-Specialisations of this trait may provide a nested typedef `type`, which is a default-constructible completion token type.
-
-If not otherwise specialised, the default completion token type is [link asio.reference.deferred_t `deferred_t`]. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/default_completion_token.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:defer defer]
-
-[indexterm1 asio.indexterm.defer..defer]
-
-Submits a completion token or function object for execution. 
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto ``[link asio.reference.defer.overload1 defer]``(
-      NullaryToken && token);
-  ``  [''''&raquo;''' [link asio.reference.defer.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.defer.overload2 defer]``(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.defer.overload2 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto ``[link asio.reference.defer.overload3 defer]``(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.defer.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/defer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 defer (1 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto defer(
-      NullaryToken && token);
-
-
-This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `defer()`.
-
-The use of `defer()`, rather than [link asio.reference.post `post`], indicates the caller's preference that the executor defer the queueing of the function object. This may allow the executor to optimise queueing for cases when the function object represents a continuation of the current call context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex` of type `Ex` by performing 
-
-  auto ex = get_associated_executor(handler); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(
-     require(ex, execution::blocking.never),
-     execution::relationship.continuation,
-     execution::allocator(alloc)
-   ).execute(std::forward<CompletionHandler>(completion_handler)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.defer(
-     std::forward<CompletionHandler>(completion_handler),
-     alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 defer (2 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto defer(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-
-
-This function submits an object for execution using the specified executor. The function object is queued for execution, and is never called from the current thread prior to returning from `defer()`.
-
-The use of `defer()`, rather than [link asio.reference.post `post`], indicates the caller's preference that the executor defer the queueing of the function object. This may allow the executor to optimise queueing for cases when the function object represents a continuation of the current call context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The target executor.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{ex}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    using executor_type = Executor;
-    explicit Init(const Executor& ex) : ex_(ex) {}
-    executor_type get_executor() const noexcept { return ex_; }
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  private:
-    Executor ex_; // exposition only
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex1` of type `Ex1` by performing 
-
-  auto ex1 = get_associated_executor(handler, ex); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is true, constructs a function object `f` with a member `executor_` that is initialised with `prefer(ex1, execution::outstanding_work.tracked)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is false, constructs a function object `f` with a member `work_` that is initialised with `make_work_guard(ex1)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  work_.get_executor().dispatch(std::move(handler_), a);
-  work_.reset(); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(
-     require(ex, execution::blocking.never),
-     execution::relationship.continuation,
-     execution::allocator(alloc)
-   ).execute(std::move(f)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.defer(std::move(f), alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 defer (3 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto defer(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context, from which the target executor is obtained.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-`defer(ctx.get_executor(), forward<NullaryToken>(token))`.
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:deferred deferred]
-
-[indexterm1 asio.indexterm.deferred..deferred]
-
-A [link asio.overview.model.completion_tokens completion token] object used to specify that an asynchronous operation should return a function object to lazily launch the operation. 
-
-
-  constexpr deferred_t deferred;
-
-
-See the documentation for [link asio.reference.deferred_t `deferred_t`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:deferred_async_operation deferred_async_operation]
-
-[indexterm1 asio.indexterm.deferred_async_operation..deferred_async_operation]
-
-
-Encapsulates a deferred asynchronous operation. 
-
-
-  template<
-      typename Signature,
-      typename Initiation,
-      typename... InitArgs>
-  class deferred_async_operation
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_async_operation.deferred_async_operation [*deferred_async_operation]] [constructor]]
-    [Construct a deferred asynchronous operation from the arguments to an initiation function object. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_async_operation.operator_lp__rp_ [*operator()]]]
-    [Initiate the asynchronous operation using the supplied completion token. 
-     [hr]
-     ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_async_operation deferred_async_operation::deferred_async_operation]
-
-[indexterm2 asio.indexterm.deferred_async_operation.deferred_async_operation..deferred_async_operation..deferred_async_operation] 
-Construct a deferred asynchronous operation from the arguments to an initiation function object. 
-
-
-  template<
-      typename I,
-      typename... A>
-  constexpr deferred_async_operation(
-      deferred_init_tag ,
-      I && initiation,
-      A &&... init_args);
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_async_operation::operator()]
-
-[indexterm2 asio.indexterm.deferred_async_operation.operator_lp__rp_..operator()..deferred_async_operation] 
-Initiate the asynchronous operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_async_operation.operator_lp__rp_.overload1 operator()]``(
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.deferred_async_operation.operator_lp__rp_.overload1 more...]]``
-
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_async_operation.operator_lp__rp_.overload2 operator()]``(
-      CompletionToken && token) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_async_operation.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_async_operation::operator() (1 of 2 overloads)]
-
-
-Initiate the asynchronous operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_async_operation::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_ deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >]
-
-[indexterm1 asio.indexterm.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_..deferred_async_operation< deferred_signatures< Signatures\.\.\. >, Initiation, InitArgs\.\.\. >]
-
-
-Encapsulates a deferred asynchronous operation thas has multiple completion signatures. 
-
-
-  template<
-      typename... Signatures,
-      typename Initiation,
-      typename... InitArgs>
-  class deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.deferred_async_operation [*deferred_async_operation]]]
-    [Construct a deferred asynchronous operation from the arguments to an initiation function object. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_ [*operator()]]]
-    [Initiate the asynchronous operation using the supplied completion token. 
-     [hr]
-     ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_async_operation deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >::deferred_async_operation]
-
-[indexterm2 asio.indexterm.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.deferred_async_operation..deferred_async_operation..deferred_async_operation< deferred_signatures< Signatures\.\.\. >, Initiation, InitArgs\.\.\. >] 
-Construct a deferred asynchronous operation from the arguments to an initiation function object. 
-
-
-  template<
-      typename I,
-      typename... A>
-  constexpr deferred_async_operation(
-      deferred_init_tag ,
-      I && initiation,
-      A &&... init_args);
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >::operator()]
-
-[indexterm2 asio.indexterm.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_..operator()..deferred_async_operation< deferred_signatures< Signatures\.\.\. >, Initiation, InitArgs\.\.\. >] 
-Initiate the asynchronous operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_.overload1 operator()]``(
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_.overload1 more...]]``
-
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_.overload2 operator()]``(
-      CompletionToken && token) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_async_operation_lt__deferred_signatures_lt__Signatures_ellipsis___gt__comma__Initiation_comma__InitArgs_ellipsis___gt_.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >::operator() (1 of 2 overloads)]
-
-
-Initiate the asynchronous operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_async_operation< deferred_signatures< Signatures... >, Initiation, InitArgs... >::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_conditional deferred_conditional]
-
-[indexterm1 asio.indexterm.deferred_conditional..deferred_conditional]
-
-
-Used to represent a deferred conditional branch. 
-
-
-  template<
-      typename OnTrue = deferred_noop,
-      typename OnFalse = deferred_noop>
-  class deferred_conditional
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_conditional.deferred_conditional [*deferred_conditional]] [constructor]]
-    [Construct a deferred conditional with the value to determine which branch will be executed. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_conditional.operator_lp__rp_ [*operator()]]]
-    [Invoke the conditional branch bsaed on the stored value. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_conditional.otherwise [*otherwise]]]
-    [Set the false branch of the conditional. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_conditional.then [*then]]]
-    [Set the true branch of the conditional. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_conditional deferred_conditional::deferred_conditional]
-
-[indexterm2 asio.indexterm.deferred_conditional.deferred_conditional..deferred_conditional..deferred_conditional] 
-Construct a deferred conditional with the value to determine which branch will be executed. 
-
-
-  constexpr deferred_conditional(
-      bool b);
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_conditional::operator()]
-
-[indexterm2 asio.indexterm.deferred_conditional.operator_lp__rp_..operator()..deferred_conditional] 
-Invoke the conditional branch bsaed on the stored value. 
-
-
-  template<
-      typename... Args>
-  auto ``[link asio.reference.deferred_conditional.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.deferred_conditional.operator_lp__rp_.overload1 more...]]``
-
-
-
-  template<
-      typename... Args>
-  auto ``[link asio.reference.deferred_conditional.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_conditional.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_conditional::operator() (1 of 2 overloads)]
-
-
-Invoke the conditional branch bsaed on the stored value. 
-
-
-  template<
-      typename... Args>
-  auto operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_conditional::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename... Args>
-  auto operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:otherwise deferred_conditional::otherwise]
-
-[indexterm2 asio.indexterm.deferred_conditional.otherwise..otherwise..deferred_conditional] 
-Set the false branch of the conditional. 
-
-
-  template<
-      typename T>
-  deferred_conditional< OnTrue, T > otherwise(
-      T on_false,
-      constraint_t< is_deferred< T >::value > *  = 0,
-      constraint_t< !is_same< conditional_t< true, OnTrue, T >, deferred_noop >::value > *  = 0,
-      constraint_t< is_same< conditional_t< true, OnFalse, T >, deferred_noop >::value > *  = 0);
-
-
-
-[endsect]
-
-
-
-[section:then deferred_conditional::then]
-
-[indexterm2 asio.indexterm.deferred_conditional.then..then..deferred_conditional] 
-Set the true branch of the conditional. 
-
-
-  template<
-      typename T>
-  deferred_conditional< T, OnFalse > then(
-      T on_true,
-      constraint_t< is_deferred< T >::value > *  = 0,
-      constraint_t< is_same< conditional_t< true, OnTrue, T >, deferred_noop >::value > *  = 0);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:deferred_function deferred_function]
-
-[indexterm1 asio.indexterm.deferred_function..deferred_function]
-
-
-Wraps a function object so that it may be used as an element in a deferred composition. 
-
-
-  template<
-      typename Function>
-  class deferred_function
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_function.deferred_function [*deferred_function]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_function.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_function.function_ [*function_]]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_function deferred_function::deferred_function]
-
-[indexterm2 asio.indexterm.deferred_function.deferred_function..deferred_function..deferred_function] 
-Constructor. 
-
-
-  template<
-      typename F>
-  constexpr deferred_function(
-      deferred_init_tag ,
-      F && function);
-
-
-
-[endsect]
-
-
-
-[section:function_ deferred_function::function_]
-
-[indexterm2 asio.indexterm.deferred_function.function_..function_..deferred_function] 
-
-  Function function_;
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_function::operator()]
-
-[indexterm2 asio.indexterm.deferred_function.operator_lp__rp_..operator()..deferred_function] 
-
-  template<
-      typename... Args>
-  auto ``[link asio.reference.deferred_function.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.deferred_function.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  auto ``[link asio.reference.deferred_function.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_function.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_function::operator() (1 of 2 overloads)]
-
-
-
-  template<
-      typename... Args>
-  auto operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_function::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename... Args>
-  auto operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_init_tag deferred_init_tag]
-
-[indexterm1 asio.indexterm.deferred_init_tag..deferred_init_tag]
-
-
-Tag type to disambiguate deferred constructors. 
-
-
-  struct deferred_init_tag
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:deferred_noop deferred_noop]
-
-[indexterm1 asio.indexterm.deferred_noop..deferred_noop]
-
-
-Used to represent an empty deferred action. 
-
-
-  struct deferred_noop
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_noop.operator_lp__rp_ [*operator()]]]
-    [No effect. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:operator_lp__rp_ deferred_noop::operator()]
-
-[indexterm2 asio.indexterm.deferred_noop.operator_lp__rp_..operator()..deferred_noop] 
-No effect. 
-
-
-  template<
-      typename... Args>
-  void ``[link asio.reference.deferred_noop.operator_lp__rp_.overload1 operator()]``(
-      Args && ...);
-  ``  [''''&raquo;''' [link asio.reference.deferred_noop.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  void ``[link asio.reference.deferred_noop.operator_lp__rp_.overload2 operator()]``(
-      Args && ...) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_noop.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_noop::operator() (1 of 2 overloads)]
-
-
-No effect. 
-
-
-  template<
-      typename... Args>
-  void operator()(
-      Args && ...);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_noop::operator() (2 of 2 overloads)]
-
-
-No effect. 
-
-
-  template<
-      typename... Args>
-  void operator()(
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_sequence deferred_sequence]
-
-[indexterm1 asio.indexterm.deferred_sequence..deferred_sequence]
-
-
-Defines a link between two consecutive operations in a sequence. 
-
-
-  template<
-      typename Head,
-      typename Tail>
-  class deferred_sequence :
-    public detail::deferred_sequence_types::base
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_sequence.deferred_sequence [*deferred_sequence]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.deferred_sequence.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_sequence deferred_sequence::deferred_sequence]
-
-[indexterm2 asio.indexterm.deferred_sequence.deferred_sequence..deferred_sequence..deferred_sequence] 
-
-  template<
-      typename H,
-      typename T>
-  constexpr deferred_sequence(
-      deferred_init_tag ,
-      H && head,
-      T && tail);
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_sequence::operator()]
-
-[indexterm2 asio.indexterm.deferred_sequence.operator_lp__rp_..operator()..deferred_sequence] 
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_sequence.operator_lp__rp_.overload1 operator()]``(
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.deferred_sequence.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_sequence.operator_lp__rp_.overload2 operator()]``(
-      CompletionToken && token) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_sequence.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_sequence::operator() (1 of 2 overloads)]
-
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_sequence::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_signatures deferred_signatures]
-
-[indexterm1 asio.indexterm.deferred_signatures..deferred_signatures]
-
-
-Helper type to wrap multiple completion signatures. 
-
-
-  template<
-      typename... Signatures>
-  struct deferred_signatures
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:deferred_t deferred_t]
-
-[indexterm1 asio.indexterm.deferred_t..deferred_t]
-
-
-Class used to specify that an asynchronous operation should return a function object to lazily launch the operation. 
-
-
-  class deferred_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.deferred_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use deferred_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.deferred_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the deferred_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use deferred_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.deferred_t [*deferred_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.operator_lp__rp_ [*operator()]]]
-    [Creates a new deferred from a function. 
-     [hr]
-     Passes through anything that is already deferred. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.values [*values]] [static]]
-    [Returns a deferred operation that returns the provided values. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.when [*when]] [static]]
-    [Creates a conditional object for branching deferred operations. ]
-  ]
-  
-]
-
-The [link asio.reference.deferred_t `deferred_t`] class is used to indicate that an asynchronous operation should return a function object which is itself an initiation function. A [link asio.reference.deferred_t `deferred_t`] object may be passed as a completion token to an asynchronous operation, typically as the default completion token:
-
-
-
-  auto my_deferred_op = my_socket.async_read_some(my_buffer); 
-
-
-
-
-or by explicitly passing the special value `asio::deferred:` 
-
-
-
-  auto my_deferred_op
-   = my_socket.async_read_some(my_buffer,
-       asio::deferred); 
-
-
-
-
-The initiating function (async\_read\_some in the above example) returns a function object that will lazily initiate the operation. 
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:as_default_on deferred_t::as_default_on]
-
-[indexterm2 asio.indexterm.deferred_t.as_default_on..as_default_on..deferred_t] 
-Function helper to adapt an I/O object to use `deferred_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t deferred_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.deferred_t.as_default_on_t..as_default_on_t..deferred_t] 
-Type alias to adapt an I/O object to use `deferred_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.deferred_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify deferred_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:deferred_t deferred_t::deferred_t]
-
-[indexterm2 asio.indexterm.deferred_t.deferred_t..deferred_t..deferred_t] 
-Default constructor. 
-
-
-  constexpr deferred_t();
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_t::operator()]
-
-[indexterm2 asio.indexterm.deferred_t.operator_lp__rp_..operator()..deferred_t] 
-Creates a new deferred from a function. 
-
-
-  template<
-      typename Function>
-  constraint_t< !is_deferred< decay_t< Function > >::value, deferred_function< decay_t< Function > > > ``[link asio.reference.deferred_t.operator_lp__rp_.overload1 operator()]``(
-      Function && function) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_t.operator_lp__rp_.overload1 more...]]``
-
-
-Passes through anything that is already deferred. 
-
-
-  template<
-      typename T>
-  constraint_t< is_deferred< decay_t< T > >::value, decay_t< T > > ``[link asio.reference.deferred_t.operator_lp__rp_.overload2 operator()]``(
-      T && t) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_t.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_t::operator() (1 of 2 overloads)]
-
-
-Creates a new deferred from a function. 
-
-
-  template<
-      typename Function>
-  constraint_t< !is_deferred< decay_t< Function > >::value, deferred_function< decay_t< Function > > > operator()(
-      Function && function) const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_t::operator() (2 of 2 overloads)]
-
-
-Passes through anything that is already deferred. 
-
-
-  template<
-      typename T>
-  constraint_t< is_deferred< decay_t< T > >::value, decay_t< T > > operator()(
-      T && t) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:values deferred_t::values]
-
-[indexterm2 asio.indexterm.deferred_t.values..values..deferred_t] 
-Returns a deferred operation that returns the provided values. 
-
-
-  template<
-      typename... Args>
-  static constexpr deferred_values< decay_t< Args >... > values(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:when deferred_t::when]
-
-[indexterm2 asio.indexterm.deferred_t.when..when..deferred_t] 
-Creates a conditional object for branching deferred operations. 
-
-
-  static constexpr deferred_conditional when(
-      bool b);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:deferred_t__executor_with_default deferred_t::executor_with_default]
-
-[indexterm1 asio.indexterm.deferred_t__executor_with_default..deferred_t::executor_with_default]
-
-
-Adapts an executor to add the `deferred_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.deferred_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify deferred_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:default_completion_token_type deferred_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.deferred_t__executor_with_default.default_completion_token_type..default_completion_token_type..deferred_t::executor_with_default] 
-Specify `deferred_t` as the default completion token type. 
-
-
-  typedef deferred_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.deferred_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use deferred_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.deferred_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the deferred_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use deferred_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.deferred_t [*deferred_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.operator_lp__rp_ [*operator()]]]
-    [Creates a new deferred from a function. 
-     [hr]
-     Passes through anything that is already deferred. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.values [*values]] [static]]
-    [Returns a deferred operation that returns the provided values. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_t.when [*when]] [static]]
-    [Creates a conditional object for branching deferred operations. ]
-  ]
-  
-]
-
-The [link asio.reference.deferred_t `deferred_t`] class is used to indicate that an asynchronous operation should return a function object which is itself an initiation function. A [link asio.reference.deferred_t `deferred_t`] object may be passed as a completion token to an asynchronous operation, typically as the default completion token:
-
-
-
-  auto my_deferred_op = my_socket.async_read_some(my_buffer); 
-
-
-
-
-or by explicitly passing the special value `asio::deferred:` 
-
-
-
-  auto my_deferred_op
-   = my_socket.async_read_some(my_buffer,
-       asio::deferred); 
-
-
-
-
-The initiating function (async\_read\_some in the above example) returns a function object that will lazily initiate the operation. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_with_default deferred_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.deferred_t__executor_with_default.executor_with_default..executor_with_default..deferred_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor1]``>
-  executor_with_default(
-      const InnerExecutor1 & ex,
-      constraint_t< conditional_t< !is_same< InnerExecutor1, executor_with_default >::value, is_convertible< InnerExecutor1, InnerExecutor >, false_type >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:deferred_values deferred_values]
-
-[indexterm1 asio.indexterm.deferred_values..deferred_values]
-
-
-Encapsulates deferred values. 
-
-
-  template<
-      typename... Values>
-  class deferred_values
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_values.deferred_values [*deferred_values]] [constructor]]
-    [Construct a deferred asynchronous operation from the arguments to an initiation function object. ]
-  ]
-  
-  [
-    [[link asio.reference.deferred_values.operator_lp__rp_ [*operator()]]]
-    [Initiate the deferred operation using the supplied completion token. 
-     [hr]
-     ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:deferred_values deferred_values::deferred_values]
-
-[indexterm2 asio.indexterm.deferred_values.deferred_values..deferred_values..deferred_values] 
-Construct a deferred asynchronous operation from the arguments to an initiation function object. 
-
-
-  template<
-      typename... V>
-  constexpr deferred_values(
-      deferred_init_tag ,
-      V &&... values);
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ deferred_values::operator()]
-
-[indexterm2 asio.indexterm.deferred_values.operator_lp__rp_..operator()..deferred_values] 
-Initiate the deferred operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_values.operator_lp__rp_.overload1 operator()]``(
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.deferred_values.operator_lp__rp_.overload1 more...]]``
-
-
-
-  template<
-      typename CompletionToken>
-  auto ``[link asio.reference.deferred_values.operator_lp__rp_.overload2 operator()]``(
-      CompletionToken && token) const;
-  ``  [''''&raquo;''' [link asio.reference.deferred_values.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 deferred_values::operator() (1 of 2 overloads)]
-
-
-Initiate the deferred operation using the supplied completion token. 
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-
-[section:overload2 deferred_values::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename CompletionToken>
-  auto operator()(
-      CompletionToken && token) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:deferred_values__initiate deferred_values::initiate]
-
-[indexterm1 asio.indexterm.deferred_values__initiate..deferred_values::initiate]
-
-
-
-  struct initiate
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.deferred_values__initiate.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ deferred_values::initiate::operator()]
-
-[indexterm2 asio.indexterm.deferred_values__initiate.operator_lp__rp_..operator()..deferred_values::initiate] 
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``,
-      typename... V>
-  void operator()(
-      Handler handler,
-      V &&... values);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:detached detached]
-
-[indexterm1 asio.indexterm.detached..detached]
-
-A [link asio.overview.model.completion_tokens completion token] object used to specify that an asynchronous operation is detached. 
-
-
-  constexpr detached_t detached;
-
-
-See the documentation for [link asio.reference.detached_t `detached_t`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/detached.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:detached_t detached_t]
-
-[indexterm1 asio.indexterm.detached_t..detached_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] type used to specify that an asynchronous operation is detached. 
-
-
-  class detached_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.detached_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use detached_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.detached_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the detached_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.detached_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use detached_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.detached_t.detached_t [*detached_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-The [link asio.reference.detached_t `detached_t`] class is used to indicate that an asynchronous operation is detached. That is, there is no completion handler waiting for the operation's result. A [link asio.reference.detached_t `detached_t`] object may be passed as a handler to an asynchronous operation, typically using the special value `asio::detached`. For example:
-
-
-
-  my_socket.async_send(my_buffer, asio::detached);
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/detached.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:as_default_on detached_t::as_default_on]
-
-[indexterm2 asio.indexterm.detached_t.as_default_on..as_default_on..detached_t] 
-Function helper to adapt an I/O object to use `detached_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t detached_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.detached_t.as_default_on_t..as_default_on_t..detached_t] 
-Type alias to adapt an I/O object to use `detached_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.detached_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify detached_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.detached_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. 
-     [hr]
-     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/detached.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:detached_t detached_t::detached_t]
-
-[indexterm2 asio.indexterm.detached_t.detached_t..detached_t..detached_t] 
-Constructor. 
-
-
-  constexpr detached_t();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:detached_t__executor_with_default detached_t::executor_with_default]
-
-[indexterm1 asio.indexterm.detached_t__executor_with_default..detached_t::executor_with_default]
-
-
-Adapts an executor to add the `detached_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.detached_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify detached_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.detached_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. 
-     [hr]
-     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/detached.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:default_completion_token_type detached_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.detached_t__executor_with_default.default_completion_token_type..default_completion_token_type..detached_t::executor_with_default] 
-Specify `detached_t` as the default completion token type. 
-
-
-  typedef detached_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.detached_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use detached_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.detached_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the detached_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.detached_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use detached_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.detached_t.detached_t [*detached_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-The [link asio.reference.detached_t `detached_t`] class is used to indicate that an asynchronous operation is detached. That is, there is no completion handler waiting for the operation's result. A [link asio.reference.detached_t `detached_t`] object may be passed as a handler to an asynchronous operation, typically using the special value `asio::detached`. For example:
-
-
-
-  my_socket.async_send(my_buffer, asio::detached);
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/detached.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:executor_with_default detached_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.detached_t__executor_with_default.executor_with_default..executor_with_default..detached_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  ``[link asio.reference.detached_t__executor_with_default.executor_with_default.overload1 executor_with_default]``(
-      const InnerExecutor & ex);
-  ``  [''''&raquo;''' [link asio.reference.detached_t__executor_with_default.executor_with_default.overload1 more...]]``
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.detached_t__executor_with_default.executor_with_default.overload2 executor_with_default]``(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.detached_t__executor_with_default.executor_with_default.overload2 more...]]``
-
-
-[section:overload1 detached_t::executor_with_default::executor_with_default (1 of 2 overloads)]
-
-
-Construct the adapted executor from the inner executor type. 
-
-
-  executor_with_default(
-      const InnerExecutor & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 detached_t::executor_with_default::executor_with_default (2 of 2 overloads)]
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_with_default(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:disable_cancellation disable_cancellation]
-
-[indexterm1 asio.indexterm.disable_cancellation..disable_cancellation]
-
-A cancellation filter that disables cancellation. 
-
-
-  typedef cancellation_filter< cancellation_type::none > disable_cancellation;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_filter.operator_lp__rp_ [*operator()]]]
-    [Returns type & Mask. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:dispatch dispatch]
-
-[indexterm1 asio.indexterm.dispatch..dispatch]
-
-Submits a completion token or function object for execution. 
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto ``[link asio.reference.dispatch.overload1 dispatch]``(
-      NullaryToken && token);
-  ``  [''''&raquo;''' [link asio.reference.dispatch.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.dispatch.overload2 dispatch]``(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.dispatch.overload2 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto ``[link asio.reference.dispatch.overload3 dispatch]``(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.dispatch.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/dispatch.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 dispatch (1 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto dispatch(
-      NullaryToken && token);
-
-
-This function submits an object for execution using the object's associated executor. The function object may be called from the current thread prior to returning from `dispatch()`. Otherwise, it is queued for execution.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex` of type `Ex` by performing 
-
-  auto ex = get_associated_executor(handler); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(ex, execution::allocator(alloc)).execute(
-     std::forward<CompletionHandler>(completion_handler)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.dispatch(
-     std::forward<CompletionHandler>(completion_handler),
-     alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dispatch (2 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto dispatch(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-
-
-This function submits an object for execution using the specified executor. The function object may be called from the current thread prior to returning from `dispatch()`. Otherwise, it is queued for execution.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The target executor.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{ex}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    using executor_type = Executor;
-    explicit Init(const Executor& ex) : ex_(ex) {}
-    executor_type get_executor() const noexcept { return ex_; }
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  private:
-    Executor ex_; // exposition only
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex1` of type `Ex1` by performing 
-
-  auto ex1 = get_associated_executor(handler, ex); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is true, constructs a function object `f` with a member `executor_` that is initialised with `prefer(ex1, execution::outstanding_work.tracked)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is false, constructs a function object `f` with a member `work_` that is initialised with `make_work_guard(ex1)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  work_.get_executor().dispatch(std::move(handler_), a);
-  work_.reset(); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(ex, execution::allocator(alloc)).execute(std::move(f)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.dispatch(std::move(f), alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 dispatch (3 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto dispatch(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context, from which the target executor is obtained.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-`dispatch(ctx.get_executor(), forward<NullaryToken>(token))`.
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:dynamic_buffer dynamic_buffer]
-
-[indexterm1 asio.indexterm.dynamic_buffer..dynamic_buffer]
-
-The [link asio.reference.dynamic_buffer `dynamic_buffer`] function is used to create a dynamically resized buffer from a `std::basic_string` or `std::vector`. 
-
-
-Create a new dynamic buffer that represents the given string. 
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  dynamic_string_buffer< Elem, Traits, Allocator > ``[link asio.reference.dynamic_buffer.overload1 dynamic_buffer]``(
-      std::basic_string< Elem, Traits, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_buffer.overload1 more...]]``
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  dynamic_string_buffer< Elem, Traits, Allocator > ``[link asio.reference.dynamic_buffer.overload2 dynamic_buffer]``(
-      std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_buffer.overload2 more...]]``
-
-Create a new dynamic buffer that represents the given vector. 
-
-  template<
-      typename Elem,
-      typename Allocator>
-  dynamic_vector_buffer< Elem, Allocator > ``[link asio.reference.dynamic_buffer.overload3 dynamic_buffer]``(
-      std::vector< Elem, Allocator > & data);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_buffer.overload3 more...]]``
-
-  template<
-      typename Elem,
-      typename Allocator>
-  dynamic_vector_buffer< Elem, Allocator > ``[link asio.reference.dynamic_buffer.overload4 dynamic_buffer]``(
-      std::vector< Elem, Allocator > & data,
-      std::size_t max_size);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_buffer.overload4 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 dynamic_buffer (1 of 4 overloads)]
-
-
-Create a new dynamic buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  dynamic_string_buffer< Elem, Traits, Allocator > dynamic_buffer(
-      std::basic_string< Elem, Traits, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-`dynamic_string_buffer<Elem, Traits, Allocator>(data)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dynamic_buffer (2 of 4 overloads)]
-
-
-Create a new dynamic buffer that represents the given string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  dynamic_string_buffer< Elem, Traits, Allocator > dynamic_buffer(
-      std::basic_string< Elem, Traits, Allocator > & data,
-      std::size_t max_size);
-
-
-
-[heading Return Value]
-      
-`dynamic_string_buffer<Elem, Traits, Allocator>(data,
-max_size)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 dynamic_buffer (3 of 4 overloads)]
-
-
-Create a new dynamic buffer that represents the given vector. 
-
-
-  template<
-      typename Elem,
-      typename Allocator>
-  dynamic_vector_buffer< Elem, Allocator > dynamic_buffer(
-      std::vector< Elem, Allocator > & data);
-
-
-
-[heading Return Value]
-      
-`dynamic_vector_buffer<Elem, Allocator>(data)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 dynamic_buffer (4 of 4 overloads)]
-
-
-Create a new dynamic buffer that represents the given vector. 
-
-
-  template<
-      typename Elem,
-      typename Allocator>
-  dynamic_vector_buffer< Elem, Allocator > dynamic_buffer(
-      std::vector< Elem, Allocator > & data,
-      std::size_t max_size);
-
-
-
-[heading Return Value]
-      
-`dynamic_vector_buffer<Elem, Allocator>(data, max_size)`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:dynamic_string_buffer dynamic_string_buffer]
-
-[indexterm1 asio.indexterm.dynamic_string_buffer..dynamic_string_buffer]
-
-
-Adapt a basic\_string to the DynamicBuffer requirements. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename Allocator>
-  class dynamic_string_buffer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.dynamic_string_buffer.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent a sequence of constant buffers that refers to the underlying memory. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.dynamic_string_buffer.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent a sequence of mutable buffers that refers to the underlying memory. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.dynamic_string_buffer.capacity [*capacity]]]
-    [Get the maximum size that the buffer may grow to without triggering reallocation. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.commit [*commit]]]
-    [DynamicBuffer_v1: Move bytes from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.consume [*consume]]]
-    [DynamicBuffer_v1: Remove characters from the input sequence. DynamicBuffer_v2: Consume the specified number of bytes from the beginning of the underlying memory. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.data [*data]]]
-    [DynamicBuffer_v1: Get a list of buffers that represents the input sequence. 
-     [hr]
-     DynamicBuffer_v2: Get a sequence of buffers that represents the underlying memory. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.dynamic_string_buffer [*dynamic_string_buffer]] [constructor]]
-    [Construct a dynamic buffer from a string. 
-     [hr]
-     DynamicBuffer_v2: Copy construct a dynamic buffer. 
-     [hr]
-     Move construct a dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.grow [*grow]]]
-    [DynamicBuffer_v2: Grow the underlying memory by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.max_size [*max_size]]]
-    [Get the maximum size of the dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.prepare [*prepare]]]
-    [DynamicBuffer_v1: Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.shrink [*shrink]]]
-    [DynamicBuffer_v2: Shrink the underlying memory by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_string_buffer.size [*size]]]
-    [DynamicBuffer_v1: Get the size of the input sequence. DynamicBuffer_v2: Get the current size of the underlying memory. ]
-  ]
-  
-]
-
-Requires that `sizeof(Elem) == 1`. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:capacity dynamic_string_buffer::capacity]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.capacity..capacity..dynamic_string_buffer] 
-Get the maximum size that the buffer may grow to without triggering reallocation. 
-
-
-  std::size_t capacity() const;
-
-
-
-[heading Return Value]
-      
-The current capacity of the underlying string if less than `max_size()`. Otherwise returns `max_size()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:commit dynamic_string_buffer::commit]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.commit..commit..dynamic_string_buffer] 
-[*DynamicBuffer\_v1:] Move bytes from the output sequence to the input sequence. 
-
-
-  void commit(
-      std::size_t n);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The number of bytes to append from the start of the output sequence to the end of the input sequence. The remainder of the output sequence is discarded.]]
-
-]
-
-Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence.
-
-
-[heading Remarks]
-      
-If `n` is greater than the size of the output sequence, the entire output sequence is moved to the input sequence and no error is issued. 
-
-
-
-
-[endsect]
-
-
-
-[section:const_buffers_type dynamic_string_buffer::const_buffers_type]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.const_buffers_type..const_buffers_type..dynamic_string_buffer] 
-The type used to represent a sequence of constant buffers that refers to the underlying memory. 
-
-
-  typedef const_buffer const_buffers_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.const_buffer [*const_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. 
-     [hr]
-     Construct a non-modifiable buffer from a modifiable one. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.const_buffer `const_buffer`] class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::const_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:consume dynamic_string_buffer::consume]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.consume..consume..dynamic_string_buffer] 
-[*DynamicBuffer\_v1:] Remove characters from the input sequence. [*DynamicBuffer\_v2:] Consume the specified number of bytes from the beginning of the underlying memory. 
-
-
-  void consume(
-      std::size_t n);
-
-
-[*DynamicBuffer\_v1:] Removes `n` characters from the beginning of the input sequence. 
-[heading Remarks]
-      
-If `n` is greater than the size of the input sequence, the entire input sequence is consumed and no error is issued.
-
-[*DynamicBuffer\_v2:] Erases `n` bytes from the beginning of the string. If `n` is greater than the current size of the string, the string is emptied. 
-
-
-[endsect]
-
-
-[section:data dynamic_string_buffer::data]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.data..data..dynamic_string_buffer] 
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type ``[link asio.reference.dynamic_string_buffer.data.overload1 data]``() const;
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.data.overload1 more...]]``
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  mutable_buffers_type ``[link asio.reference.dynamic_string_buffer.data.overload2 data]``(
-      std::size_t pos,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.data.overload2 more...]]``
-
-  const_buffers_type ``[link asio.reference.dynamic_string_buffer.data.overload3 data]``(
-      std::size_t pos,
-      std::size_t n) const;
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.data.overload3 more...]]``
-
-
-[section:overload1 dynamic_string_buffer::data (1 of 3 overloads)]
-
-
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type data() const;
-
-
-
-[heading Return Value]
-      
-An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing the basic\_string memory in the input sequence.
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that resizes or erases the string. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dynamic_string_buffer::data (2 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  mutable_buffers_type data(
-      std::size_t pos,
-      std::size_t n);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[pos][Position of the first byte to represent in the buffer sequence]]
-
-[[n][The number of bytes to return in the buffer sequence. If the underlying memory is shorter, the buffer sequence represents as many bytes as are available.]]
-
-]
-
-
-[heading Return Value]
-      
-An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing the basic\_string memory.
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that resizes or erases the string. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 dynamic_string_buffer::data (3 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  const_buffers_type data(
-      std::size_t pos,
-      std::size_t n) const;
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[pos][Position of the first byte to represent in the buffer sequence]]
-
-[[n][The number of bytes to return in the buffer sequence. If the underlying memory is shorter, the buffer sequence represents as many bytes as are available.]]
-
-]
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that resizes or erases the string. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:dynamic_string_buffer dynamic_string_buffer::dynamic_string_buffer]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.dynamic_string_buffer..dynamic_string_buffer..dynamic_string_buffer] 
-Construct a dynamic buffer from a string. 
-
-
-  explicit ``[link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload1 dynamic_string_buffer]``(
-      std::basic_string< Elem, Traits, Allocator > & s,
-      std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)());
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload1 more...]]``
-
-
-[*DynamicBuffer\_v2:] Copy construct a dynamic buffer. 
-
-
-  ``[link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload2 dynamic_string_buffer]``(
-      const dynamic_string_buffer & other);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload2 more...]]``
-
-
-Move construct a dynamic buffer. 
-
-
-  ``[link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload3 dynamic_string_buffer]``(
-      dynamic_string_buffer && other);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_string_buffer.dynamic_string_buffer.overload3 more...]]``
-
-
-[section:overload1 dynamic_string_buffer::dynamic_string_buffer (1 of 3 overloads)]
-
-
-Construct a dynamic buffer from a string. 
-
-
-  dynamic_string_buffer(
-      std::basic_string< Elem, Traits, Allocator > & s,
-      std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)());
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The string to be used as backing storage for the dynamic buffer. The object stores a reference to the string and the user is responsible for ensuring that the string object remains valid while the [link asio.reference.dynamic_string_buffer `dynamic_string_buffer`] object, and copies of the object, are in use.]]
-
-]
-
-[*DynamicBuffer\_v1:] Any existing data in the string is treated as the dynamic buffer's input sequence.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[maximum_size][Specifies a maximum size for the buffer, in bytes. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dynamic_string_buffer::dynamic_string_buffer (2 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Copy construct a dynamic buffer. 
-
-
-  dynamic_string_buffer(
-      const dynamic_string_buffer & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 dynamic_string_buffer::dynamic_string_buffer (3 of 3 overloads)]
-
-
-Move construct a dynamic buffer. 
-
-
-  dynamic_string_buffer(
-      dynamic_string_buffer && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:grow dynamic_string_buffer::grow]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.grow..grow..dynamic_string_buffer] 
-[*DynamicBuffer\_v2:] Grow the underlying memory by the specified number of bytes. 
-
-
-  void grow(
-      std::size_t n);
-
-
-Resizes the string to accommodate an additional `n` bytes at the end.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[std::length_error][If `size() + n > max_size()`. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:max_size dynamic_string_buffer::max_size]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.max_size..max_size..dynamic_string_buffer] 
-Get the maximum size of the dynamic buffer. 
-
-
-  std::size_t max_size() const;
-
-
-
-[heading Return Value]
-      
-The allowed maximum size of the underlying memory. 
-
-
-
-
-[endsect]
-
-
-
-[section:mutable_buffers_type dynamic_string_buffer::mutable_buffers_type]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.mutable_buffers_type..mutable_buffers_type..dynamic_string_buffer] 
-The type used to represent a sequence of mutable buffers that refers to the underlying memory. 
-
-
-  typedef mutable_buffer mutable_buffers_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.mutable_buffer `mutable_buffer`] class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:prepare dynamic_string_buffer::prepare]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.prepare..prepare..dynamic_string_buffer] 
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the output sequence, with the given size. 
-
-
-  mutable_buffers_type prepare(
-      std::size_t n);
-
-
-Ensures that the output sequence can accommodate `n` bytes, resizing the basic\_string object as necessary.
-
-
-[heading Return Value]
-      
-An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing basic\_string memory at the start of the output sequence of size `n`.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[std::length_error][If `size() + n > max_size()`.]]
-
-]
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_string_buffer` or `basic_string` member function that modifies the input sequence or output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:shrink dynamic_string_buffer::shrink]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.shrink..shrink..dynamic_string_buffer] 
-[*DynamicBuffer\_v2:] Shrink the underlying memory by the specified number of bytes. 
-
-
-  void shrink(
-      std::size_t n);
-
-
-Erases `n` bytes from the end of the string by resizing the basic\_string object. If `n` is greater than the current size of the string, the string is emptied. 
-
-
-[endsect]
-
-
-
-[section:size dynamic_string_buffer::size]
-
-[indexterm2 asio.indexterm.dynamic_string_buffer.size..size..dynamic_string_buffer] 
-[*DynamicBuffer\_v1:] Get the size of the input sequence. [*DynamicBuffer\_v2:] Get the current size of the underlying memory. 
-
-
-  std::size_t size() const;
-
-
-
-[heading Return Value]
-      
-[*DynamicBuffer\_v1] The current size of the input sequence. [*DynamicBuffer\_v2:] The current size of the underlying string if less than `max_size()`. Otherwise returns `max_size()`. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:dynamic_vector_buffer dynamic_vector_buffer]
-
-[indexterm1 asio.indexterm.dynamic_vector_buffer..dynamic_vector_buffer]
-
-
-Adapt a vector to the DynamicBuffer requirements. 
-
-
-  template<
-      typename Elem,
-      typename Allocator>
-  class dynamic_vector_buffer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.dynamic_vector_buffer.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent a sequence of constant buffers that refers to the underlying memory. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.dynamic_vector_buffer.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent a sequence of mutable buffers that refers to the underlying memory. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.dynamic_vector_buffer.capacity [*capacity]]]
-    [Get the maximum size that the buffer may grow to without triggering reallocation. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.commit [*commit]]]
-    [DynamicBuffer_v1: Move bytes from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.consume [*consume]]]
-    [DynamicBuffer_v1: Remove characters from the input sequence. DynamicBuffer_v2: Consume the specified number of bytes from the beginning of the underlying memory. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.data [*data]]]
-    [DynamicBuffer_v1: Get a list of buffers that represents the input sequence. 
-     [hr]
-     DynamicBuffer_v2: Get a sequence of buffers that represents the underlying memory. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer [*dynamic_vector_buffer]] [constructor]]
-    [Construct a dynamic buffer from a vector. 
-     [hr]
-     DynamicBuffer_v2: Copy construct a dynamic buffer. 
-     [hr]
-     Move construct a dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.grow [*grow]]]
-    [DynamicBuffer_v2: Grow the underlying memory by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.max_size [*max_size]]]
-    [Get the maximum size of the dynamic buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.prepare [*prepare]]]
-    [DynamicBuffer_v1: Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.shrink [*shrink]]]
-    [DynamicBuffer_v2: Shrink the underlying memory by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.dynamic_vector_buffer.size [*size]]]
-    [DynamicBuffer_v1: Get the size of the input sequence. DynamicBuffer_v2: Get the current size of the underlying memory. ]
-  ]
-  
-]
-
-Requires that `sizeof(Elem) == 1`. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:capacity dynamic_vector_buffer::capacity]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.capacity..capacity..dynamic_vector_buffer] 
-Get the maximum size that the buffer may grow to without triggering reallocation. 
-
-
-  std::size_t capacity() const;
-
-
-
-[heading Return Value]
-      
-[*DynamicBuffer\_v1:] The current total capacity of the buffer, i.e. for both the input sequence and output sequence. [*DynamicBuffer\_v2:] The current capacity of the underlying vector if less than `max_size()`. Otherwise returns `max_size()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:commit dynamic_vector_buffer::commit]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.commit..commit..dynamic_vector_buffer] 
-[*DynamicBuffer\_v1:] Move bytes from the output sequence to the input sequence. 
-
-
-  void commit(
-      std::size_t n);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[n][The number of bytes to append from the start of the output sequence to the end of the input sequence. The remainder of the output sequence is discarded.]]
-
-]
-
-Requires a preceding call `prepare(x)` where `x >= n`, and no intervening operations that modify the input or output sequence.
-
-
-[heading Remarks]
-      
-If `n` is greater than the size of the output sequence, the entire output sequence is moved to the input sequence and no error is issued. 
-
-
-
-
-[endsect]
-
-
-
-[section:const_buffers_type dynamic_vector_buffer::const_buffers_type]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.const_buffers_type..const_buffers_type..dynamic_vector_buffer] 
-The type used to represent a sequence of constant buffers that refers to the underlying memory. 
-
-
-  typedef const_buffer const_buffers_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.const_buffer [*const_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. 
-     [hr]
-     Construct a non-modifiable buffer from a modifiable one. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.const_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.const_buffer.operator_plus_ [*operator+]]]
-    [Create a new non-modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.const_buffer `const_buffer`] class provides a safe representation of a buffer that cannot be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::const_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  const unsigned char* p1 = static_cast<const unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:consume dynamic_vector_buffer::consume]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.consume..consume..dynamic_vector_buffer] 
-[*DynamicBuffer\_v1:] Remove characters from the input sequence. [*DynamicBuffer\_v2:] Consume the specified number of bytes from the beginning of the underlying memory. 
-
-
-  void consume(
-      std::size_t n);
-
-
-[*DynamicBuffer\_v1:] Removes `n` characters from the beginning of the input sequence. 
-[heading Remarks]
-      
-If `n` is greater than the size of the input sequence, the entire input sequence is consumed and no error is issued.
-
-[*DynamicBuffer\_v2:] Erases `n` bytes from the beginning of the vector. If `n` is greater than the current size of the vector, the vector is emptied. 
-
-
-[endsect]
-
-
-[section:data dynamic_vector_buffer::data]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.data..data..dynamic_vector_buffer] 
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type ``[link asio.reference.dynamic_vector_buffer.data.overload1 data]``() const;
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.data.overload1 more...]]``
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  mutable_buffers_type ``[link asio.reference.dynamic_vector_buffer.data.overload2 data]``(
-      std::size_t pos,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.data.overload2 more...]]``
-
-  const_buffers_type ``[link asio.reference.dynamic_vector_buffer.data.overload3 data]``(
-      std::size_t pos,
-      std::size_t n) const;
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.data.overload3 more...]]``
-
-
-[section:overload1 dynamic_vector_buffer::data (1 of 3 overloads)]
-
-
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the input sequence. 
-
-
-  const_buffers_type data() const;
-
-
-
-[heading Return Value]
-      
-An object of type `const_buffers_type` that satisfies ConstBufferSequence requirements, representing the vector memory in the input sequence.
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_vector_buffer` or `vector` member function that modifies the input sequence or output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dynamic_vector_buffer::data (2 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  mutable_buffers_type data(
-      std::size_t pos,
-      std::size_t n);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[pos][Position of the first byte to represent in the buffer sequence]]
-
-[[n][The number of bytes to return in the buffer sequence. If the underlying memory is shorter, the buffer sequence represents as many bytes as are available.]]
-
-]
-
-
-[heading Return Value]
-      
-An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing the vector memory.
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_vector_buffer` or `vector` member function that resizes or erases the vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 dynamic_vector_buffer::data (3 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Get a sequence of buffers that represents the underlying memory. 
-
-
-  const_buffers_type data(
-      std::size_t pos,
-      std::size_t n) const;
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[pos][Position of the first byte to represent in the buffer sequence]]
-
-[[n][The number of bytes to return in the buffer sequence. If the underlying memory is shorter, the buffer sequence represents as many bytes as are available.]]
-
-]
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_vector_buffer` or `vector` member function that resizes or erases the vector. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:dynamic_vector_buffer dynamic_vector_buffer::dynamic_vector_buffer]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.dynamic_vector_buffer..dynamic_vector_buffer..dynamic_vector_buffer] 
-Construct a dynamic buffer from a vector. 
-
-
-  explicit ``[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload1 dynamic_vector_buffer]``(
-      std::vector< Elem, Allocator > & v,
-      std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)());
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload1 more...]]``
-
-
-[*DynamicBuffer\_v2:] Copy construct a dynamic buffer. 
-
-
-  ``[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload2 dynamic_vector_buffer]``(
-      const dynamic_vector_buffer & other);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload2 more...]]``
-
-
-Move construct a dynamic buffer. 
-
-
-  ``[link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload3 dynamic_vector_buffer]``(
-      dynamic_vector_buffer && other);
-  ``  [''''&raquo;''' [link asio.reference.dynamic_vector_buffer.dynamic_vector_buffer.overload3 more...]]``
-
-
-[section:overload1 dynamic_vector_buffer::dynamic_vector_buffer (1 of 3 overloads)]
-
-
-Construct a dynamic buffer from a vector. 
-
-
-  dynamic_vector_buffer(
-      std::vector< Elem, Allocator > & v,
-      std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)());
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[v][The vector to be used as backing storage for the dynamic buffer. The object stores a reference to the vector and the user is responsible for ensuring that the vector object remains valid while the [link asio.reference.dynamic_vector_buffer `dynamic_vector_buffer`] object, and copies of the object, are in use.]]
-
-[[maximum_size][Specifies a maximum size for the buffer, in bytes. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 dynamic_vector_buffer::dynamic_vector_buffer (2 of 3 overloads)]
-
-
-[*DynamicBuffer\_v2:] Copy construct a dynamic buffer. 
-
-
-  dynamic_vector_buffer(
-      const dynamic_vector_buffer & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 dynamic_vector_buffer::dynamic_vector_buffer (3 of 3 overloads)]
-
-
-Move construct a dynamic buffer. 
-
-
-  dynamic_vector_buffer(
-      dynamic_vector_buffer && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:grow dynamic_vector_buffer::grow]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.grow..grow..dynamic_vector_buffer] 
-[*DynamicBuffer\_v2:] Grow the underlying memory by the specified number of bytes. 
-
-
-  void grow(
-      std::size_t n);
-
-
-Resizes the vector to accommodate an additional `n` bytes at the end.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[std::length_error][If `size() + n > max_size()`. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:max_size dynamic_vector_buffer::max_size]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.max_size..max_size..dynamic_vector_buffer] 
-Get the maximum size of the dynamic buffer. 
-
-
-  std::size_t max_size() const;
-
-
-
-[heading Return Value]
-      
-[*DynamicBuffer\_v1:] The allowed maximum of the sum of the sizes of the input sequence and output sequence. [*DynamicBuffer\_v2:] The allowed maximum size of the underlying memory. 
-
-
-
-
-[endsect]
-
-
-
-[section:mutable_buffers_type dynamic_vector_buffer::mutable_buffers_type]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.mutable_buffers_type..mutable_buffers_type..dynamic_vector_buffer] 
-The type used to represent a sequence of mutable buffers that refers to the underlying memory. 
-
-
-  typedef mutable_buffer mutable_buffers_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.mutable_buffer `mutable_buffer`] class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:prepare dynamic_vector_buffer::prepare]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.prepare..prepare..dynamic_vector_buffer] 
-[*DynamicBuffer\_v1:] Get a list of buffers that represents the output sequence, with the given size. 
-
-
-  mutable_buffers_type prepare(
-      std::size_t n);
-
-
-Ensures that the output sequence can accommodate `n` bytes, resizing the vector object as necessary.
-
-
-[heading Return Value]
-      
-An object of type `mutable_buffers_type` that satisfies MutableBufferSequence requirements, representing vector memory at the start of the output sequence of size `n`.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[std::length_error][If `size() + n > max_size()`.]]
-
-]
-
-
-[heading Remarks]
-      
-The returned object is invalidated by any `dynamic_vector_buffer` or `vector` member function that modifies the input sequence or output sequence. 
-
-
-
-
-[endsect]
-
-
-
-[section:shrink dynamic_vector_buffer::shrink]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.shrink..shrink..dynamic_vector_buffer] 
-[*DynamicBuffer\_v2:] Shrink the underlying memory by the specified number of bytes. 
-
-
-  void shrink(
-      std::size_t n);
-
-
-Erases `n` bytes from the end of the vector by resizing the vector object. If `n` is greater than the current size of the vector, the vector is emptied. 
-
-
-[endsect]
-
-
-
-[section:size dynamic_vector_buffer::size]
-
-[indexterm2 asio.indexterm.dynamic_vector_buffer.size..size..dynamic_vector_buffer] 
-[*DynamicBuffer\_v1:] Get the size of the input sequence. [*DynamicBuffer\_v2:] Get the current size of the underlying memory. 
-
-
-  std::size_t size() const;
-
-
-
-[heading Return Value]
-      
-[*DynamicBuffer\_v1] The current size of the input sequence. [*DynamicBuffer\_v2:] The current size of the underlying vector if less than `max_size()`. Otherwise returns `max_size()`. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:enable_partial_cancellation enable_partial_cancellation]
-
-[indexterm1 asio.indexterm.enable_partial_cancellation..enable_partial_cancellation]
-
-A cancellation filter that enables terminal and partial cancellation. 
-
-
-  typedef cancellation_filter< cancellation_type::terminal|cancellation_type::partial > enable_partial_cancellation;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_filter.operator_lp__rp_ [*operator()]]]
-    [Returns type & Mask. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_terminal_cancellation enable_terminal_cancellation]
-
-[indexterm1 asio.indexterm.enable_terminal_cancellation..enable_terminal_cancellation]
-
-A cancellation filter that enables terminal cancellation only. 
-
-
-  typedef cancellation_filter< cancellation_type::terminal > enable_terminal_cancellation;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_filter.operator_lp__rp_ [*operator()]]]
-    [Returns type & Mask. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_total_cancellation enable_total_cancellation]
-
-[indexterm1 asio.indexterm.enable_total_cancellation..enable_total_cancellation]
-
-A cancellation filter that enables terminal, partial and total cancellation. 
-
-
-  typedef cancellation_filter< cancellation_type::terminal|cancellation_type::partial|cancellation_type::total > enable_total_cancellation;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.cancellation_filter.operator_lp__rp_ [*operator()]]]
-    [Returns type & Mask. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/cancellation_state.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__addrinfo_category error::addrinfo_category]
-
-[indexterm1 asio.indexterm.error__addrinfo_category..error::addrinfo_category]
-
-
-  static const asio::error_category & addrinfo_category = asio::error::get_addrinfo_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__addrinfo_errors error::addrinfo_errors]
-
-[indexterm1 asio.indexterm.error__addrinfo_errors..error::addrinfo_errors]
-
-  enum addrinfo_errors
-
-[indexterm2 asio.indexterm.error__addrinfo_errors.service_not_found..service_not_found..error::addrinfo_errors]
-[indexterm2 asio.indexterm.error__addrinfo_errors.socket_type_not_supported..socket_type_not_supported..error::addrinfo_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [service_not_found]
-    [The service is not supported for the given socket type. ]
-  ]
-
-  [
-    [socket_type_not_supported]
-    [The socket type is not supported. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__basic_errors error::basic_errors]
-
-[indexterm1 asio.indexterm.error__basic_errors..error::basic_errors]
-
-  enum basic_errors
-
-[indexterm2 asio.indexterm.error__basic_errors.access_denied..access_denied..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.address_family_not_supported..address_family_not_supported..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.address_in_use..address_in_use..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.already_connected..already_connected..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.already_started..already_started..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.broken_pipe..broken_pipe..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.connection_aborted..connection_aborted..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.connection_refused..connection_refused..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.connection_reset..connection_reset..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.bad_descriptor..bad_descriptor..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.fault..fault..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.host_unreachable..host_unreachable..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.in_progress..in_progress..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.interrupted..interrupted..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.invalid_argument..invalid_argument..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.message_size..message_size..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.name_too_long..name_too_long..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.network_down..network_down..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.network_reset..network_reset..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.network_unreachable..network_unreachable..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_descriptors..no_descriptors..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_buffer_space..no_buffer_space..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_memory..no_memory..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_permission..no_permission..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_protocol_option..no_protocol_option..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.no_such_device..no_such_device..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.not_connected..not_connected..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.not_socket..not_socket..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.operation_aborted..operation_aborted..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.operation_not_supported..operation_not_supported..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.shut_down..shut_down..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.timed_out..timed_out..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.try_again..try_again..error::basic_errors]
-[indexterm2 asio.indexterm.error__basic_errors.would_block..would_block..error::basic_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [access_denied]
-    [Permission denied. ]
-  ]
-
-  [
-    [address_family_not_supported]
-    [Address family not supported by protocol. ]
-  ]
-
-  [
-    [address_in_use]
-    [Address already in use. ]
-  ]
-
-  [
-    [already_connected]
-    [Transport endpoint is already connected. ]
-  ]
-
-  [
-    [already_started]
-    [Operation already in progress. ]
-  ]
-
-  [
-    [broken_pipe]
-    [Broken pipe. ]
-  ]
-
-  [
-    [connection_aborted]
-    [A connection has been aborted. ]
-  ]
-
-  [
-    [connection_refused]
-    [Connection refused. ]
-  ]
-
-  [
-    [connection_reset]
-    [Connection reset by peer. ]
-  ]
-
-  [
-    [bad_descriptor]
-    [Bad file descriptor. ]
-  ]
-
-  [
-    [fault]
-    [Bad address. ]
-  ]
-
-  [
-    [host_unreachable]
-    [No route to host. ]
-  ]
-
-  [
-    [in_progress]
-    [Operation now in progress. ]
-  ]
-
-  [
-    [interrupted]
-    [Interrupted system call. ]
-  ]
-
-  [
-    [invalid_argument]
-    [Invalid argument. ]
-  ]
-
-  [
-    [message_size]
-    [Message too long. ]
-  ]
-
-  [
-    [name_too_long]
-    [The name was too long. ]
-  ]
-
-  [
-    [network_down]
-    [Network is down. ]
-  ]
-
-  [
-    [network_reset]
-    [Network dropped connection on reset. ]
-  ]
-
-  [
-    [network_unreachable]
-    [Network is unreachable. ]
-  ]
-
-  [
-    [no_descriptors]
-    [Too many open files. ]
-  ]
-
-  [
-    [no_buffer_space]
-    [No buffer space available. ]
-  ]
-
-  [
-    [no_memory]
-    [Cannot allocate memory. ]
-  ]
-
-  [
-    [no_permission]
-    [Operation not permitted. ]
-  ]
-
-  [
-    [no_protocol_option]
-    [Protocol not available. ]
-  ]
-
-  [
-    [no_such_device]
-    [No such device. ]
-  ]
-
-  [
-    [not_connected]
-    [Transport endpoint is not connected. ]
-  ]
-
-  [
-    [not_socket]
-    [Socket operation on non-socket. ]
-  ]
-
-  [
-    [operation_aborted]
-    [Operation cancelled. ]
-  ]
-
-  [
-    [operation_not_supported]
-    [Operation not supported. ]
-  ]
-
-  [
-    [shut_down]
-    [Cannot send after transport endpoint shutdown. ]
-  ]
-
-  [
-    [timed_out]
-    [Connection timed out. ]
-  ]
-
-  [
-    [try_again]
-    [Resource temporarily unavailable. ]
-  ]
-
-  [
-    [would_block]
-    [The socket is marked non-blocking and the requested operation would block. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__clear error::clear]
-
-[indexterm1 asio.indexterm.error__clear..error::clear]
-
-
-  void clear(
-      asio::error_code & ec);
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__get_addrinfo_category error::get_addrinfo_category]
-
-[indexterm1 asio.indexterm.error__get_addrinfo_category..error::get_addrinfo_category]
-
-
-  const asio::error_category & get_addrinfo_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/error.ipp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__get_misc_category error::get_misc_category]
-
-[indexterm1 asio.indexterm.error__get_misc_category..error::get_misc_category]
-
-
-  const asio::error_category & get_misc_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/error.ipp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__get_netdb_category error::get_netdb_category]
-
-[indexterm1 asio.indexterm.error__get_netdb_category..error::get_netdb_category]
-
-
-  const asio::error_category & get_netdb_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/error.ipp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__get_ssl_category error::get_ssl_category]
-
-[indexterm1 asio.indexterm.error__get_ssl_category..error::get_ssl_category]
-
-
-  const asio::error_category & get_ssl_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:error__get_system_category error::get_system_category]
-
-[indexterm1 asio.indexterm.error__get_system_category..error::get_system_category]
-
-
-  const asio::error_category & get_system_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:error__make_error_code error::make_error_code]
-
-[indexterm1 asio.indexterm.error__make_error_code..error::make_error_code]
-
-  asio::error_code ``[link asio.reference.error__make_error_code.overload1 make_error_code]``(
-      basic_errors e);
-  ``  [''''&raquo;''' [link asio.reference.error__make_error_code.overload1 more...]]``
-
-  asio::error_code ``[link asio.reference.error__make_error_code.overload2 make_error_code]``(
-      netdb_errors e);
-  ``  [''''&raquo;''' [link asio.reference.error__make_error_code.overload2 more...]]``
-
-  asio::error_code ``[link asio.reference.error__make_error_code.overload3 make_error_code]``(
-      addrinfo_errors e);
-  ``  [''''&raquo;''' [link asio.reference.error__make_error_code.overload3 more...]]``
-
-  asio::error_code ``[link asio.reference.error__make_error_code.overload4 make_error_code]``(
-      misc_errors e);
-  ``  [''''&raquo;''' [link asio.reference.error__make_error_code.overload4 more...]]``
-
-  asio::error_code ``[link asio.reference.error__make_error_code.overload5 make_error_code]``(
-      ssl_errors e);
-  ``  [''''&raquo;''' [link asio.reference.error__make_error_code.overload5 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 error::make_error_code (1 of 5 overloads)]
-
-
-
-  asio::error_code make_error_code(
-      basic_errors e);
-
-
-
-[endsect]
-
-
-
-[section:overload2 error::make_error_code (2 of 5 overloads)]
-
-
-
-  asio::error_code make_error_code(
-      netdb_errors e);
-
-
-
-[endsect]
-
-
-
-[section:overload3 error::make_error_code (3 of 5 overloads)]
-
-
-
-  asio::error_code make_error_code(
-      addrinfo_errors e);
-
-
-
-[endsect]
-
-
-
-[section:overload4 error::make_error_code (4 of 5 overloads)]
-
-
-
-  asio::error_code make_error_code(
-      misc_errors e);
-
-
-
-[endsect]
-
-
-
-[section:overload5 error::make_error_code (5 of 5 overloads)]
-
-
-
-  asio::error_code make_error_code(
-      ssl_errors e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:error__misc_category error::misc_category]
-
-[indexterm1 asio.indexterm.error__misc_category..error::misc_category]
-
-
-  static const asio::error_category & misc_category = asio::error::get_misc_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__misc_errors error::misc_errors]
-
-[indexterm1 asio.indexterm.error__misc_errors..error::misc_errors]
-
-  enum misc_errors
-
-[indexterm2 asio.indexterm.error__misc_errors.already_open..already_open..error::misc_errors]
-[indexterm2 asio.indexterm.error__misc_errors.eof..eof..error::misc_errors]
-[indexterm2 asio.indexterm.error__misc_errors.not_found..not_found..error::misc_errors]
-[indexterm2 asio.indexterm.error__misc_errors.fd_set_failure..fd_set_failure..error::misc_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [already_open]
-    [Already open. ]
-  ]
-
-  [
-    [eof]
-    [End of file or stream. ]
-  ]
-
-  [
-    [not_found]
-    [Element not found. ]
-  ]
-
-  [
-    [fd_set_failure]
-    [The descriptor cannot fit into the select system call's fd_set. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__netdb_category error::netdb_category]
-
-[indexterm1 asio.indexterm.error__netdb_category..error::netdb_category]
-
-
-  static const asio::error_category & netdb_category = asio::error::get_netdb_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__netdb_errors error::netdb_errors]
-
-[indexterm1 asio.indexterm.error__netdb_errors..error::netdb_errors]
-
-  enum netdb_errors
-
-[indexterm2 asio.indexterm.error__netdb_errors.host_not_found..host_not_found..error::netdb_errors]
-[indexterm2 asio.indexterm.error__netdb_errors.host_not_found_try_again..host_not_found_try_again..error::netdb_errors]
-[indexterm2 asio.indexterm.error__netdb_errors.no_data..no_data..error::netdb_errors]
-[indexterm2 asio.indexterm.error__netdb_errors.no_recovery..no_recovery..error::netdb_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [host_not_found]
-    [Host not found (authoritative). ]
-  ]
-
-  [
-    [host_not_found_try_again]
-    [Host not found (non-authoritative). ]
-  ]
-
-  [
-    [no_data]
-    [The query is valid but does not have associated address data. ]
-  ]
-
-  [
-    [no_recovery]
-    [A non-recoverable error occurred. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error__ssl_category error::ssl_category]
-
-[indexterm1 asio.indexterm.error__ssl_category..error::ssl_category]
-
-
-  static const asio::error_category & ssl_category = asio::error::get_ssl_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:error__ssl_errors error::ssl_errors]
-
-[indexterm1 asio.indexterm.error__ssl_errors..error::ssl_errors]
-
-  enum ssl_errors
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:error__system_category error::system_category]
-
-[indexterm1 asio.indexterm.error__system_category..error::system_category]
-
-
-  static const asio::error_category & system_category = asio::error::get_system_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error_category error_category]
-
-[indexterm1 asio.indexterm.error_category..error_category]
-
-
-  typedef std::error_category error_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/error_code.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:error_code error_code]
-
-[indexterm1 asio.indexterm.error_code..error_code]
-
-
-  typedef std::error_code error_code;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/error_code.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:execution__allocator execution::allocator]
-
-[indexterm1 asio.indexterm.execution__allocator..execution::allocator]
-
-A special value used for accessing the [link asio.reference.execution__allocator_t `execution::allocator_t`] property. 
-
-
-  constexpr allocator_t< void > allocator;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/allocator.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__allocator_t execution::allocator_t]
-
-[indexterm1 asio.indexterm.execution__allocator_t..execution::allocator_t]
-
-
-A property to describe which allocator an executor will use to allocate the memory required to store a submitted function object. 
-
-
-  template<
-      typename ``[link asio.reference.ProtoAllocator ProtoAllocator]``>
-  struct allocator_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__allocator_t.allocator_t [*allocator_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__allocator_t.value [*value]]]
-    [Obtain the allocator stored in the allocator_t property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__allocator_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The allocator_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__allocator_t.is_preferable [*is_preferable]] [static]]
-    [The allocator_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__allocator_t.is_requirable [*is_requirable]] [static]]
-    [The allocator_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/allocator.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:allocator_t execution::allocator_t::allocator_t]
-
-[indexterm2 asio.indexterm.execution__allocator_t.allocator_t..allocator_t..execution::allocator_t] 
-Default constructor. 
-
-
-  constexpr allocator_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::allocator_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__allocator_t.is_applicable_property_v..is_applicable_property_v..execution::allocator_t] 
-The [link asio.reference.execution__allocator_t `execution::allocator_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::allocator_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__allocator_t.is_preferable..is_preferable..execution::allocator_t] 
-The [link asio.reference.execution__allocator_t `execution::allocator_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::allocator_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__allocator_t.is_requirable..is_requirable..execution::allocator_t] 
-The [link asio.reference.execution__allocator_t `execution::allocator_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:value execution::allocator_t::value]
-
-[indexterm2 asio.indexterm.execution__allocator_t.value..value..execution::allocator_t] 
-Obtain the allocator stored in the [link asio.reference.execution__allocator_t `execution::allocator_t`] property object. 
-
-
-  constexpr ProtoAllocator value() const;
-
-
-Present only if `ProtoAllocator` is non-void. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__any_executor execution::any_executor]
-
-[indexterm1 asio.indexterm.execution__any_executor..execution::any_executor]
-
-
-Polymorphic executor wrapper. 
-
-
-  template<
-      typename... SupportableProperties>
-  class any_executor
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__any_executor.any_executor [*any_executor]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct in an empty state. Equivalent effects to default constructor. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Construct to point to the same target as another any_executor. 
-     [hr]
-     Construct a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.execute [*execute]]]
-    [Execute the function on the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.operator_bool [*operator bool]]]
-    [Determine whether the wrapper has a target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. 
-     [hr]
-     Assignment operator that sets the polymorphic wrapper to the empty state. 
-     [hr]
-     Assignment operator to create a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.prefer [*prefer]]]
-    [Obtain a polymorphic wrapper with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.query [*query]]]
-    [Obtain the value associated with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.require [*require]]]
-    [Obtain a polymorphic wrapper with the specified property. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.swap [*swap]]]
-    [Swap targets with another polymorphic wrapper. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.target [*target]]]
-    [Get a pointer to the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.target_type [*target_type]]]
-    [Get the type of the target executor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor._any_executor [*~any_executor]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__any_executor.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__any_executor.operator_eq__eq_ [*operator==]]]
-    [Equality operator. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/any_executor.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-[section:any_executor execution::any_executor::any_executor]
-
-[indexterm2 asio.indexterm.execution__any_executor.any_executor..any_executor..execution::any_executor] 
-Default constructor. 
-
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload1 any_executor]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload1 more...]]``
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload2 any_executor]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload3 any_executor]``(
-      const any_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload4 any_executor]``(
-      any_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload4 more...]]``
-
-
-Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.execution__any_executor.any_executor.overload5 any_executor]``(
-      any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload5 more...]]``
-
-  template<
-      class... OtherSupportableProperties>
-  ``[link asio.reference.execution__any_executor.any_executor.overload6 any_executor]``(
-      std::nothrow_t ,
-      any_executor< OtherSupportableProperties... > e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload6 more...]]``
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload7 any_executor]``(
-      std::nothrow_t ,
-      const any_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload7 more...]]``
-
-  ``[link asio.reference.execution__any_executor.any_executor.overload8 any_executor]``(
-      std::nothrow_t ,
-      any_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload8 more...]]``
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.execution__any_executor.any_executor.overload9 any_executor]``(
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.execution__any_executor.any_executor.overload10 any_executor]``(
-      std::nothrow_t ,
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.any_executor.overload10 more...]]``
-
-
-[section:overload1 execution::any_executor::any_executor (1 of 10 overloads)]
-
-
-Default constructor. 
-
-
-  any_executor();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::any_executor::any_executor (2 of 10 overloads)]
-
-
-Construct in an empty state. Equivalent effects to default constructor. 
-
-
-  any_executor(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::any_executor::any_executor (3 of 10 overloads)]
-
-
-Copy constructor. 
-
-
-  any_executor(
-      const any_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload4 execution::any_executor::any_executor (4 of 10 overloads)]
-
-
-Move constructor. 
-
-
-  any_executor(
-      any_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload5 execution::any_executor::any_executor (5 of 10 overloads)]
-
-
-Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_executor(
-      any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload6 execution::any_executor::any_executor (6 of 10 overloads)]
-
-
-Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
-
-
-  template<
-      class... OtherSupportableProperties>
-  any_executor(
-      std::nothrow_t ,
-      any_executor< OtherSupportableProperties... > e);
-
-
-
-[endsect]
-
-
-
-[section:overload7 execution::any_executor::any_executor (7 of 10 overloads)]
-
-
-Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
-
-
-  any_executor(
-      std::nothrow_t ,
-      const any_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload8 execution::any_executor::any_executor (8 of 10 overloads)]
-
-
-Construct to point to the same target as another [link asio.reference.execution__any_executor `execution::any_executor`]. 
-
-
-  any_executor(
-      std::nothrow_t ,
-      any_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload9 execution::any_executor::any_executor (9 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_executor(
-      Executor e);
-
-
-
-[endsect]
-
-
-
-[section:overload10 execution::any_executor::any_executor (10 of 10 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_executor(
-      std::nothrow_t ,
-      Executor e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:context execution::any_executor::context]
-
-[indexterm2 asio.indexterm.execution__any_executor.context..context..execution::any_executor] 
-Obtain the underlying execution context. 
-
-
-  automatically_determined context() const;
-
-
-This function is provided for backward compatibility. It is automatically defined when the `SupportableProperties`... list includes a property of type `execution::context_as<U>`, for some type `U`. 
-
-
-[endsect]
-
-
-
-[section:execute execution::any_executor::execute]
-
-[indexterm2 asio.indexterm.execution__any_executor.execute..execute..execution::any_executor] 
-Execute the function on the target executor. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-Throws [link asio.reference.bad_executor `bad_executor`] if the polymorphic wrapper has no target. 
-
-
-[endsect]
-
-
-
-[section:operator_bool execution::any_executor::operator bool]
-
-[indexterm2 asio.indexterm.execution__any_executor.operator_bool..operator bool..execution::any_executor] 
-Determine whether the wrapper has a target executor. 
-
-
-  operator bool() const;
-
-
-
-[heading Return Value]
-      
-`true` if the polymorphic wrapper has a target executor, otherwise false. 
-
-
-
-
-[endsect]
-
-
-[section:operator_not__eq_ execution::any_executor::operator!=]
-
-[indexterm2 asio.indexterm.execution__any_executor.operator_not__eq_..operator!=..execution::any_executor] 
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_not__eq_.overload1 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_not__eq_.overload1 more...]]``
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_not__eq_.overload2 operator!=]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_not__eq_.overload2 more...]]``
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_not__eq_.overload3 operator!=]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_not__eq_.overload3 more...]]``
-
-
-[section:overload1 execution::any_executor::operator!= (1 of 3 overloads)]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::any_executor::operator!= (2 of 3 overloads)]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::any_executor::operator!= (3 of 3 overloads)]
-
-
-Inequality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator!=(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ execution::any_executor::operator=]
-
-[indexterm2 asio.indexterm.execution__any_executor.operator_eq_..operator=..execution::any_executor] 
-Assignment operator. 
-
-
-  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload1 operator=]``(
-      const any_executor & e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload2 operator=]``(
-      any_executor && e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload2 more...]]``
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload3 operator=]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload3 more...]]``
-
-
-Assignment operator to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_executor & ``[link asio.reference.execution__any_executor.operator_eq_.overload4 operator=]``(
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq_.overload4 more...]]``
-
-
-[section:overload1 execution::any_executor::operator= (1 of 4 overloads)]
-
-
-Assignment operator. 
-
-
-  any_executor & operator=(
-      const any_executor & e);
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::any_executor::operator= (2 of 4 overloads)]
-
-
-Move assignment operator. 
-
-
-  any_executor & operator=(
-      any_executor && e);
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::any_executor::operator= (3 of 4 overloads)]
-
-
-Assignment operator that sets the polymorphic wrapper to the empty state. 
-
-
-  any_executor & operator=(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload4 execution::any_executor::operator= (4 of 4 overloads)]
-
-
-Assignment operator to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  any_executor & operator=(
-      Executor e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq__eq_ execution::any_executor::operator==]
-
-[indexterm2 asio.indexterm.execution__any_executor.operator_eq__eq_..operator==..execution::any_executor] 
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_eq__eq_.overload1 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq__eq_.overload1 more...]]``
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_eq__eq_.overload2 operator==]``(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq__eq_.overload2 more...]]``
-
-  template<
-      typename... SupportableProperties>
-  bool ``[link asio.reference.execution__any_executor.operator_eq__eq_.overload3 operator==]``(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.operator_eq__eq_.overload3 more...]]``
-
-
-[section:overload1 execution::any_executor::operator== (1 of 3 overloads)]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::any_executor::operator== (2 of 3 overloads)]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      const any_executor< SupportableProperties... > & a,
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::any_executor::operator== (3 of 3 overloads)]
-
-
-Equality operator. 
-
-
-  template<
-      typename... SupportableProperties>
-  bool operator==(
-      nullptr_t ,
-      const any_executor< SupportableProperties... > & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:prefer execution::any_executor::prefer]
-
-[indexterm2 asio.indexterm.execution__any_executor.prefer..prefer..execution::any_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor prefer(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::prefer(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:query execution::any_executor::query]
-
-[indexterm2 asio.indexterm.execution__any_executor.query..query..execution::any_executor] 
-Obtain the value associated with the specified property. 
-
-
-  template<
-      typename Property>
-  Property::polymorphic_query_result_type query(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  execution::any_executor<execution::occupancy_t> ex = ...;
-  size_t n = asio::query(ex, execution::occupancy); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:require execution::any_executor::require]
-
-[indexterm2 asio.indexterm.execution__any_executor.require..require..execution::any_executor] 
-Obtain a polymorphic wrapper with the specified property. 
-
-
-  template<
-      typename Property>
-  any_executor require(
-      Property ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] and [link asio.reference.prefer `prefer`] customisation points.
-
-For example: 
-
-  execution::any_executor<execution::blocking_t::possibly_t> ex = ...;
-  auto ex2 = asio::requre(ex, execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:swap execution::any_executor::swap]
-
-[indexterm2 asio.indexterm.execution__any_executor.swap..swap..execution::any_executor] 
-Swap targets with another polymorphic wrapper. 
-
-
-  void swap(
-      any_executor & other);
-
-
-
-[endsect]
-
-
-[section:target execution::any_executor::target]
-
-[indexterm2 asio.indexterm.execution__any_executor.target..target..execution::any_executor] 
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * ``[link asio.reference.execution__any_executor.target.overload1 target]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.target.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * ``[link asio.reference.execution__any_executor.target.overload2 target]``() const;
-  ``  [''''&raquo;''' [link asio.reference.execution__any_executor.target.overload2 more...]]``
-
-
-[section:overload1 execution::any_executor::target (1 of 2 overloads)]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * target();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::any_executor::target (2 of 2 overloads)]
-
-
-Get a pointer to the target executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * target() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:target_type execution::any_executor::target_type]
-
-[indexterm2 asio.indexterm.execution__any_executor.target_type..target_type..execution::any_executor] 
-Get the type of the target executor. 
-
-
-  const type_info & target_type() const;
-
-
-
-[endsect]
-
-
-
-[section:_any_executor execution::any_executor::~any_executor]
-
-[indexterm2 asio.indexterm.execution__any_executor._any_executor..~any_executor..execution::any_executor] 
-Destructor. 
-
-
-  ~any_executor();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__bad_executor execution::bad_executor]
-
-[indexterm1 asio.indexterm.execution__bad_executor..execution::bad_executor]
-
-
-Exception thrown when trying to access an empty polymorphic executor. 
-
-
-  class bad_executor :
-    public exception
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__bad_executor.bad_executor [*bad_executor]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__bad_executor.what [*what]]]
-    [Obtain message associated with exception. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/bad_executor.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:bad_executor execution::bad_executor::bad_executor]
-
-[indexterm2 asio.indexterm.execution__bad_executor.bad_executor..bad_executor..execution::bad_executor] 
-Constructor. 
-
-
-  bad_executor();
-
-
-
-[endsect]
-
-
-
-[section:what execution::bad_executor::what]
-
-[indexterm2 asio.indexterm.execution__bad_executor.what..what..execution::bad_executor] 
-Obtain message associated with exception. 
-
-
-  virtual const char * what() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:execution__blocking execution::blocking]
-
-[indexterm1 asio.indexterm.execution__blocking..execution::blocking]
-
-A special value used for accessing the [link asio.reference.execution__blocking_t `execution::blocking_t`] property. 
-
-
-  constexpr blocking_t blocking;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:execution__blocking_adaptation execution::blocking_adaptation]
-
-[indexterm1 asio.indexterm.execution__blocking_adaptation..execution::blocking_adaptation]
-
-A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property. 
-
-
-  constexpr blocking_adaptation_t blocking_adaptation;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__blocking_adaptation_t execution::blocking_adaptation_t]
-
-[indexterm1 asio.indexterm.execution__blocking_adaptation_t..execution::blocking_adaptation_t]
-
-
-A property to describe whether automatic adaptation of an executor is allowed in order to apply the [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property. 
-
-
-  struct blocking_adaptation_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t [*allowed_t]]]
-    [A sub-property that indicates that automatic adaptation is allowed. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t [*disallowed_t]]]
-    [A sub-property that indicates that automatic adaptation is not allowed. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__blocking_adaptation_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t [*blocking_adaptation_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from a sub-property value. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.allowed [*allowed]] [static]]
-    [A special value used for accessing the blocking_adaptation_t::allowed_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.disallowed [*disallowed]] [static]]
-    [A special value used for accessing the blocking_adaptation_t::disallowed_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_adaptation_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.is_preferable [*is_preferable]] [static]]
-    [The top-level blocking_adaptation_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.is_requirable [*is_requirable]] [static]]
-    [The top-level blocking_adaptation_t property cannot be required. ]
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.operator_not__eq_ [*operator!=]]]
-    [Compare property values for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_adaptation_t.operator_eq__eq_ [*operator==]]]
-    [Compare property values for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:allowed execution::blocking_adaptation_t::allowed]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.allowed..allowed..execution::blocking_adaptation_t] 
-A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property. 
-
-
-  static constexpr allowed_t allowed;
-
-
-
-[endsect]
-
-
-[section:blocking_adaptation_t execution::blocking_adaptation_t::blocking_adaptation_t]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.blocking_adaptation_t..blocking_adaptation_t..execution::blocking_adaptation_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload1 blocking_adaptation_t]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload1 more...]]``
-
-
-Construct from a sub-property value. 
-
-
-  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload2 blocking_adaptation_t]``(
-      disallowed_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload2 more...]]``
-
-  constexpr ``[link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload3 blocking_adaptation_t]``(
-      allowed_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_adaptation_t.blocking_adaptation_t.overload3 more...]]``
-
-
-[section:overload1 execution::blocking_adaptation_t::blocking_adaptation_t (1 of 3 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr blocking_adaptation_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::blocking_adaptation_t::blocking_adaptation_t (2 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr blocking_adaptation_t(
-      disallowed_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::blocking_adaptation_t::blocking_adaptation_t (3 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr blocking_adaptation_t(
-      allowed_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:disallowed execution::blocking_adaptation_t::disallowed]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.disallowed..disallowed..execution::blocking_adaptation_t] 
-A special value used for accessing the [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property. 
-
-
-  static constexpr disallowed_t disallowed;
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::blocking_adaptation_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t] 
-The [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_adaptation_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_preferable..is_preferable..execution::blocking_adaptation_t] 
-The top-level [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_adaptation_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.is_requirable..is_requirable..execution::blocking_adaptation_t] 
-The top-level [link asio.reference.execution__blocking_adaptation_t `execution::blocking_adaptation_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ execution::blocking_adaptation_t::operator!=]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.operator_not__eq_..operator!=..execution::blocking_adaptation_t] 
-Compare property values for inequality. 
-
-
-  constexpr bool operator!=(
-      const blocking_adaptation_t & a,
-      const blocking_adaptation_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ execution::blocking_adaptation_t::operator==]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.operator_eq__eq_..operator==..execution::blocking_adaptation_t] 
-Compare property values for equality. 
-
-
-  constexpr bool operator==(
-      const blocking_adaptation_t & a,
-      const blocking_adaptation_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_adaptation_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_adaptation_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_adaptation_t__allowed_t execution::blocking_adaptation_t::allowed_t]
-
-[indexterm1 asio.indexterm.execution__blocking_adaptation_t__allowed_t..execution::blocking_adaptation_t::allowed_t]
-
-
-A sub-property that indicates that automatic adaptation is allowed. 
-
-
-  struct allowed_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.allowed_t [*allowed_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_adaptation_t::allowed_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_preferable [*is_preferable]] [static]]
-    [The blocking_adaptation_t::allowed_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__allowed_t.is_requirable [*is_requirable]] [static]]
-    [The blocking_adaptation_t::allowed_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:allowed_t execution::blocking_adaptation_t::allowed_t::allowed_t]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.allowed_t..allowed_t..execution::blocking_adaptation_t::allowed_t] 
-Default constructor. 
-
-
-  constexpr allowed_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::blocking_adaptation_t::allowed_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t::allowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_adaptation_t::allowed_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_preferable..is_preferable..execution::blocking_adaptation_t::allowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_adaptation_t::allowed_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.is_requirable..is_requirable..execution::blocking_adaptation_t::allowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__allowed_t `execution::blocking_adaptation_t::allowed_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_adaptation_t::allowed_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t::allowed_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_adaptation_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::blocking_adaptation_t::allowed_t::value]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__allowed_t.value..value..execution::blocking_adaptation_t::allowed_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr blocking_adaptation_t value();
-
-
-
-[heading Return Value]
-      
-`allowed_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_adaptation_t__disallowed_t execution::blocking_adaptation_t::disallowed_t]
-
-[indexterm1 asio.indexterm.execution__blocking_adaptation_t__disallowed_t..execution::blocking_adaptation_t::disallowed_t]
-
-
-A sub-property that indicates that automatic adaptation is not allowed. 
-
-
-  struct disallowed_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.disallowed_t [*disallowed_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_adaptation_t::disallowed_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_preferable [*is_preferable]] [static]]
-    [The blocking_adaptation_t::disallowed_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_adaptation_t__disallowed_t.is_requirable [*is_requirable]] [static]]
-    [The blocking_adaptation_t::disallowed_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:disallowed_t execution::blocking_adaptation_t::disallowed_t::disallowed_t]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.disallowed_t..disallowed_t..execution::blocking_adaptation_t::disallowed_t] 
-Default constructor. 
-
-
-  constexpr disallowed_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::blocking_adaptation_t::disallowed_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_adaptation_t::disallowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_adaptation_t::disallowed_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_preferable..is_preferable..execution::blocking_adaptation_t::disallowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_adaptation_t::disallowed_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.is_requirable..is_requirable..execution::blocking_adaptation_t::disallowed_t] 
-The [link asio.reference.execution__blocking_adaptation_t__disallowed_t `execution::blocking_adaptation_t::disallowed_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_adaptation_t::disallowed_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_adaptation_t::disallowed_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_adaptation_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking_adaptation.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::blocking_adaptation_t::disallowed_t::value]
-
-[indexterm2 asio.indexterm.execution__blocking_adaptation_t__disallowed_t.value..value..execution::blocking_adaptation_t::disallowed_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr blocking_adaptation_t value();
-
-
-
-[heading Return Value]
-      
-`disallowed_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_t execution::blocking_t]
-
-[indexterm1 asio.indexterm.execution__blocking_t..execution::blocking_t]
-
-
-A property to describe what guarantees an executor makes about the blocking behaviour of their execution functions. 
-
-
-  struct blocking_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__always_t [*always_t]]]
-    [A sub-property that indicates that invocation of an executor's execution function shall block until completion of all invocations of the submitted function object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__never_t [*never_t]]]
-    [A sub-property that indicates that invocation of an executor's execution function shall not block pending completion of the invocations of the submitted function object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__possibly_t [*possibly_t]]]
-    [A sub-property that indicates that invocation of an executor's execution function may block pending completion of one or more invocations of the submitted function object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__blocking_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t.blocking_t [*blocking_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from a sub-property value. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t.always [*always]] [static]]
-    [A special value used for accessing the blocking_t::always_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t.is_preferable [*is_preferable]] [static]]
-    [The top-level blocking_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t.is_requirable [*is_requirable]] [static]]
-    [The top-level blocking_t property cannot be required. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t.never [*never]] [static]]
-    [A special value used for accessing the blocking_t::never_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t.possibly [*possibly]] [static]]
-    [A special value used for accessing the blocking_t::possibly_t property. ]
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t.operator_not__eq_ [*operator!=]]]
-    [Compare property values for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_t.operator_eq__eq_ [*operator==]]]
-    [Compare property values for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:always execution::blocking_t::always]
-
-[indexterm2 asio.indexterm.execution__blocking_t.always..always..execution::blocking_t] 
-A special value used for accessing the [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property. 
-
-
-  static constexpr always_t always;
-
-
-
-[endsect]
-
-
-[section:blocking_t execution::blocking_t::blocking_t]
-
-[indexterm2 asio.indexterm.execution__blocking_t.blocking_t..blocking_t..execution::blocking_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload1 blocking_t]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload1 more...]]``
-
-
-Construct from a sub-property value. 
-
-
-  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload2 blocking_t]``(
-      possibly_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload2 more...]]``
-
-  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload3 blocking_t]``(
-      always_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload3 more...]]``
-
-  constexpr ``[link asio.reference.execution__blocking_t.blocking_t.overload4 blocking_t]``(
-      never_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__blocking_t.blocking_t.overload4 more...]]``
-
-
-[section:overload1 execution::blocking_t::blocking_t (1 of 4 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr blocking_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::blocking_t::blocking_t (2 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr blocking_t(
-      possibly_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::blocking_t::blocking_t (3 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr blocking_t(
-      always_t );
-
-
-
-[endsect]
-
-
-
-[section:overload4 execution::blocking_t::blocking_t (4 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr blocking_t(
-      never_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_applicable_property_v execution::blocking_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t] 
-The [link asio.reference.execution__blocking_t `execution::blocking_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_t.is_preferable..is_preferable..execution::blocking_t] 
-The top-level [link asio.reference.execution__blocking_t `execution::blocking_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_t.is_requirable..is_requirable..execution::blocking_t] 
-The top-level [link asio.reference.execution__blocking_t `execution::blocking_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:never execution::blocking_t::never]
-
-[indexterm2 asio.indexterm.execution__blocking_t.never..never..execution::blocking_t] 
-A special value used for accessing the [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property. 
-
-
-  static constexpr never_t never;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ execution::blocking_t::operator!=]
-
-[indexterm2 asio.indexterm.execution__blocking_t.operator_not__eq_..operator!=..execution::blocking_t] 
-Compare property values for inequality. 
-
-
-  constexpr bool operator!=(
-      const blocking_t & a,
-      const blocking_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ execution::blocking_t::operator==]
-
-[indexterm2 asio.indexterm.execution__blocking_t.operator_eq__eq_..operator==..execution::blocking_t] 
-Compare property values for equality. 
-
-
-  constexpr bool operator==(
-      const blocking_t & a,
-      const blocking_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:possibly execution::blocking_t::possibly]
-
-[indexterm2 asio.indexterm.execution__blocking_t.possibly..possibly..execution::blocking_t] 
-A special value used for accessing the [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property. 
-
-
-  static constexpr possibly_t possibly;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_t__always_t execution::blocking_t::always_t]
-
-[indexterm1 asio.indexterm.execution__blocking_t__always_t..execution::blocking_t::always_t]
-
-
-A sub-property that indicates that invocation of an executor's execution function shall block until completion of all invocations of the submitted function object. 
-
-
-  struct always_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__always_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__always_t.always_t [*always_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_t__always_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__always_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_t::always_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__always_t.is_preferable [*is_preferable]] [static]]
-    [The blocking_t::always_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__always_t.is_requirable [*is_requirable]] [static]]
-    [The blocking_t::always_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:always_t execution::blocking_t::always_t::always_t]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.always_t..always_t..execution::blocking_t::always_t] 
-Default constructor. 
-
-
-  constexpr always_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::blocking_t::always_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::always_t] 
-The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_t::always_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_preferable..is_preferable..execution::blocking_t::always_t] 
-The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_t::always_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.is_requirable..is_requirable..execution::blocking_t::always_t] 
-The [link asio.reference.execution__blocking_t__always_t `execution::blocking_t::always_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_t::always_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::always_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::blocking_t::always_t::value]
-
-[indexterm2 asio.indexterm.execution__blocking_t__always_t.value..value..execution::blocking_t::always_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr blocking_t value();
-
-
-
-[heading Return Value]
-      
-`always_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_t__never_t execution::blocking_t::never_t]
-
-[indexterm1 asio.indexterm.execution__blocking_t__never_t..execution::blocking_t::never_t]
-
-
-A sub-property that indicates that invocation of an executor's execution function shall not block pending completion of the invocations of the submitted function object. 
-
-
-  struct never_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__never_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__never_t.never_t [*never_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_t__never_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__never_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_t::never_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__never_t.is_preferable [*is_preferable]] [static]]
-    [The blocking_t::never_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__never_t.is_requirable [*is_requirable]] [static]]
-    [The blocking_t::never_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::blocking_t::never_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::never_t] 
-The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_t::never_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_preferable..is_preferable..execution::blocking_t::never_t] 
-The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_t::never_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.is_requirable..is_requirable..execution::blocking_t::never_t] 
-The [link asio.reference.execution__blocking_t__never_t `execution::blocking_t::never_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:never_t execution::blocking_t::never_t::never_t]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.never_t..never_t..execution::blocking_t::never_t] 
-Default constructor. 
-
-
-  constexpr never_t();
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_t::never_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::never_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::blocking_t::never_t::value]
-
-[indexterm2 asio.indexterm.execution__blocking_t__never_t.value..value..execution::blocking_t::never_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr blocking_t value();
-
-
-
-[heading Return Value]
-      
-`never_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__blocking_t__possibly_t execution::blocking_t::possibly_t]
-
-[indexterm1 asio.indexterm.execution__blocking_t__possibly_t..execution::blocking_t::possibly_t]
-
-
-A sub-property that indicates that invocation of an executor's execution function may block pending completion of one or more invocations of the submitted function object. 
-
-
-  struct possibly_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__blocking_t__possibly_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__possibly_t.possibly_t [*possibly_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__blocking_t__possibly_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__blocking_t__possibly_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The blocking_t::possibly_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__possibly_t.is_preferable [*is_preferable]] [static]]
-    [The blocking_t::possibly_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__blocking_t__possibly_t.is_requirable [*is_requirable]] [static]]
-    [The blocking_t::possibly_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::blocking_t::possibly_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_applicable_property_v..is_applicable_property_v..execution::blocking_t::possibly_t] 
-The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::blocking_t::possibly_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_preferable..is_preferable..execution::blocking_t::possibly_t] 
-The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::blocking_t::possibly_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.is_requirable..is_requirable..execution::blocking_t::possibly_t] 
-The [link asio.reference.execution__blocking_t__possibly_t `execution::blocking_t::possibly_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::blocking_t::possibly_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::blocking_t::possibly_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef blocking_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/blocking.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:possibly_t execution::blocking_t::possibly_t::possibly_t]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.possibly_t..possibly_t..execution::blocking_t::possibly_t] 
-Default constructor. 
-
-
-  constexpr possibly_t();
-
-
-
-[endsect]
-
-
-
-[section:value execution::blocking_t::possibly_t::value]
-
-[indexterm2 asio.indexterm.execution__blocking_t__possibly_t.value..value..execution::blocking_t::possibly_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr blocking_t value();
-
-
-
-[heading Return Value]
-      
-`possibly_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:execution__context execution::context]
-
-[indexterm1 asio.indexterm.execution__context..execution::context]
-
-A special value used for accessing the [link asio.reference.execution__context_t `execution::context_t`] property. 
-
-
-  constexpr context_t context;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:execution__context_as execution::context_as]
-
-[indexterm1 asio.indexterm.execution__context_as..execution::context_as]
-
-A special value used for accessing the [link asio.reference.execution__context_as_t `execution::context_as_t`] property. 
-
-
-  template <typename U>
-  constexpr context_as_t context_as;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context_as.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__context_as_t execution::context_as_t]
-
-[indexterm1 asio.indexterm.execution__context_as_t..execution::context_as_t]
-
-
-A property that is used to obtain the execution context that is associated with an executor. 
-
-
-  template<
-      typename U>
-  struct context_as_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__context_as_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__context_as_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The context_as_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__context_as_t.is_preferable [*is_preferable]] [static]]
-    [The context_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__context_as_t.is_requirable [*is_requirable]] [static]]
-    [The context_t property cannot be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context_as.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::context_as_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__context_as_t.is_applicable_property_v..is_applicable_property_v..execution::context_as_t] 
-The [link asio.reference.execution__context_as_t `execution::context_as_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::context_as_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__context_as_t.is_preferable..is_preferable..execution::context_as_t] 
-The [link asio.reference.execution__context_t `execution::context_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::context_as_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__context_as_t.is_requirable..is_requirable..execution::context_as_t] 
-The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::context_as_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__context_as_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::context_as_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef T polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context_as.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__context_t execution::context_t]
-
-[indexterm1 asio.indexterm.execution__context_t..execution::context_t]
-
-
-A property that is used to obtain the execution context that is associated with an executor. 
-
-
-  struct context_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__context_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__context_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The context_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__context_t.is_preferable [*is_preferable]] [static]]
-    [The context_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__context_t.is_requirable [*is_requirable]] [static]]
-    [The context_t property cannot be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::context_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__context_t.is_applicable_property_v..is_applicable_property_v..execution::context_t] 
-The [link asio.reference.execution__context_t `execution::context_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::context_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__context_t.is_preferable..is_preferable..execution::context_t] 
-The [link asio.reference.execution__context_t `execution::context_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::context_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__context_t.is_requirable..is_requirable..execution::context_t] 
-The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::context_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__context_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::context_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef std::any polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__invocable_archetype execution::invocable_archetype]
-
-[indexterm1 asio.indexterm.execution__invocable_archetype..execution::invocable_archetype]
-
-
-An archetypal function object used for determining adherence to the execution::executor concept. 
-
-
-  struct invocable_archetype
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__invocable_archetype.operator_lp__rp_ [*operator()]]]
-    [Function call operator. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/invocable_archetype.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:operator_lp__rp_ execution::invocable_archetype::operator()]
-
-[indexterm2 asio.indexterm.execution__invocable_archetype.operator_lp__rp_..operator()..execution::invocable_archetype] 
-Function call operator. 
-
-
-  template<
-      typename... Args>
-  void operator()(
-      Args && ...);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__is_executor execution::is_executor]
-
-[indexterm1 asio.indexterm.execution__is_executor..execution::is_executor]
-
-
-The [link asio.reference.execution__is_executor `execution::is_executor`] trait detects whether a type T satisfies the execution::executor concept. 
-
-
-  template<
-      typename T>
-  struct is_executor :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_executor` is a UnaryTypeTrait that is derived from `true_type` if the type `T` meets the concept definition for an executor, otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/execution/executor.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__mapping execution::mapping]
-
-[indexterm1 asio.indexterm.execution__mapping..execution::mapping]
-
-A special value used for accessing the [link asio.reference.execution__mapping_t `execution::mapping_t`] property. 
-
-
-  constexpr mapping_t mapping;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__mapping_t execution::mapping_t]
-
-[indexterm1 asio.indexterm.execution__mapping_t..execution::mapping_t]
-
-
-A property to describe what guarantees an executor makes about the mapping of execution agents on to threads of execution. 
-
-
-  struct mapping_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__new_thread_t [*new_thread_t]]]
-    [A sub-property that indicates that execution agents are mapped on to new threads of execution. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__other_t [*other_t]]]
-    [A sub-property that indicates that the mapping of execution agents is implementation-defined. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__thread_t [*thread_t]]]
-    [A sub-property that indicates that execution agents are mapped on to threads of execution. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__mapping_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t.mapping_t [*mapping_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from a sub-property value. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The mapping_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t.is_preferable [*is_preferable]] [static]]
-    [The top-level mapping_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t.is_requirable [*is_requirable]] [static]]
-    [The top-level mapping_t property cannot be required. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t.new_thread [*new_thread]] [static]]
-    [A special value used for accessing the mapping_t::new_thread_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t.other [*other]] [static]]
-    [A special value used for accessing the mapping_t::other_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t.thread [*thread]] [static]]
-    [A special value used for accessing the mapping_t::thread_t property. ]
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t.operator_not__eq_ [*operator!=]]]
-    [Compare property values for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__mapping_t.operator_eq__eq_ [*operator==]]]
-    [Compare property values for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::mapping_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__mapping_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t] 
-The [link asio.reference.execution__mapping_t `execution::mapping_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::mapping_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__mapping_t.is_preferable..is_preferable..execution::mapping_t] 
-The top-level [link asio.reference.execution__mapping_t `execution::mapping_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::mapping_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__mapping_t.is_requirable..is_requirable..execution::mapping_t] 
-The top-level [link asio.reference.execution__mapping_t `execution::mapping_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-[section:mapping_t execution::mapping_t::mapping_t]
-
-[indexterm2 asio.indexterm.execution__mapping_t.mapping_t..mapping_t..execution::mapping_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload1 mapping_t]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload1 more...]]``
-
-
-Construct from a sub-property value. 
-
-
-  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload2 mapping_t]``(
-      thread_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload2 more...]]``
-
-  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload3 mapping_t]``(
-      new_thread_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload3 more...]]``
-
-  constexpr ``[link asio.reference.execution__mapping_t.mapping_t.overload4 mapping_t]``(
-      other_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__mapping_t.mapping_t.overload4 more...]]``
-
-
-[section:overload1 execution::mapping_t::mapping_t (1 of 4 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr mapping_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::mapping_t::mapping_t (2 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr mapping_t(
-      thread_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::mapping_t::mapping_t (3 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr mapping_t(
-      new_thread_t );
-
-
-
-[endsect]
-
-
-
-[section:overload4 execution::mapping_t::mapping_t (4 of 4 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr mapping_t(
-      other_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:new_thread execution::mapping_t::new_thread]
-
-[indexterm2 asio.indexterm.execution__mapping_t.new_thread..new_thread..execution::mapping_t] 
-A special value used for accessing the [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property. 
-
-
-  static constexpr new_thread_t new_thread;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ execution::mapping_t::operator!=]
-
-[indexterm2 asio.indexterm.execution__mapping_t.operator_not__eq_..operator!=..execution::mapping_t] 
-Compare property values for inequality. 
-
-
-  constexpr bool operator!=(
-      const mapping_t & a,
-      const mapping_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ execution::mapping_t::operator==]
-
-[indexterm2 asio.indexterm.execution__mapping_t.operator_eq__eq_..operator==..execution::mapping_t] 
-Compare property values for equality. 
-
-
-  constexpr bool operator==(
-      const mapping_t & a,
-      const mapping_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:other execution::mapping_t::other]
-
-[indexterm2 asio.indexterm.execution__mapping_t.other..other..execution::mapping_t] 
-A special value used for accessing the [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property. 
-
-
-  static constexpr other_t other;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::mapping_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__mapping_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef mapping_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:thread execution::mapping_t::thread]
-
-[indexterm2 asio.indexterm.execution__mapping_t.thread..thread..execution::mapping_t] 
-A special value used for accessing the [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property. 
-
-
-  static constexpr thread_t thread;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__mapping_t__new_thread_t execution::mapping_t::new_thread_t]
-
-[indexterm1 asio.indexterm.execution__mapping_t__new_thread_t..execution::mapping_t::new_thread_t]
-
-
-A sub-property that indicates that execution agents are mapped on to new threads of execution. 
-
-
-  struct new_thread_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__new_thread_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__new_thread_t.new_thread_t [*new_thread_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__mapping_t__new_thread_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__new_thread_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The mapping_t::new_thread_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__new_thread_t.is_preferable [*is_preferable]] [static]]
-    [The mapping_t::new_thread_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__new_thread_t.is_requirable [*is_requirable]] [static]]
-    [The mapping_t::new_thread_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::mapping_t::new_thread_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::new_thread_t] 
-The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::mapping_t::new_thread_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_preferable..is_preferable..execution::mapping_t::new_thread_t] 
-The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::mapping_t::new_thread_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.is_requirable..is_requirable..execution::mapping_t::new_thread_t] 
-The [link asio.reference.execution__mapping_t__new_thread_t `execution::mapping_t::new_thread_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:new_thread_t execution::mapping_t::new_thread_t::new_thread_t]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.new_thread_t..new_thread_t..execution::mapping_t::new_thread_t] 
-Default constructor. 
-
-
-  constexpr new_thread_t();
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::mapping_t::new_thread_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::new_thread_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef mapping_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::mapping_t::new_thread_t::value]
-
-[indexterm2 asio.indexterm.execution__mapping_t__new_thread_t.value..value..execution::mapping_t::new_thread_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr mapping_t value();
-
-
-
-[heading Return Value]
-      
-`new_thread_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__mapping_t__other_t execution::mapping_t::other_t]
-
-[indexterm1 asio.indexterm.execution__mapping_t__other_t..execution::mapping_t::other_t]
-
-
-A sub-property that indicates that the mapping of execution agents is implementation-defined. 
-
-
-  struct other_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__other_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__other_t.other_t [*other_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__mapping_t__other_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__other_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The mapping_t::other_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__other_t.is_preferable [*is_preferable]] [static]]
-    [The mapping_t::other_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__other_t.is_requirable [*is_requirable]] [static]]
-    [The mapping_t::other_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::mapping_t::other_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::other_t] 
-The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::mapping_t::other_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_preferable..is_preferable..execution::mapping_t::other_t] 
-The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::mapping_t::other_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.is_requirable..is_requirable..execution::mapping_t::other_t] 
-The [link asio.reference.execution__mapping_t__other_t `execution::mapping_t::other_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:other_t execution::mapping_t::other_t::other_t]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.other_t..other_t..execution::mapping_t::other_t] 
-Default constructor. 
-
-
-  constexpr other_t();
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::mapping_t::other_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::other_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef mapping_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::mapping_t::other_t::value]
-
-[indexterm2 asio.indexterm.execution__mapping_t__other_t.value..value..execution::mapping_t::other_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr mapping_t value();
-
-
-
-[heading Return Value]
-      
-`other_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__mapping_t__thread_t execution::mapping_t::thread_t]
-
-[indexterm1 asio.indexterm.execution__mapping_t__thread_t..execution::mapping_t::thread_t]
-
-
-A sub-property that indicates that execution agents are mapped on to threads of execution. 
-
-
-  struct thread_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__mapping_t__thread_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__thread_t.thread_t [*thread_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__mapping_t__thread_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__mapping_t__thread_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The mapping_t::thread_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__thread_t.is_preferable [*is_preferable]] [static]]
-    [The mapping_t::thread_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__mapping_t__thread_t.is_requirable [*is_requirable]] [static]]
-    [The mapping_t::thread_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::mapping_t::thread_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_applicable_property_v..is_applicable_property_v..execution::mapping_t::thread_t] 
-The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::mapping_t::thread_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_preferable..is_preferable..execution::mapping_t::thread_t] 
-The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::mapping_t::thread_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.is_requirable..is_requirable..execution::mapping_t::thread_t] 
-The [link asio.reference.execution__mapping_t__thread_t `execution::mapping_t::thread_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::mapping_t::thread_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::mapping_t::thread_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef mapping_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/mapping.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:thread_t execution::mapping_t::thread_t::thread_t]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.thread_t..thread_t..execution::mapping_t::thread_t] 
-Default constructor. 
-
-
-  constexpr thread_t();
-
-
-
-[endsect]
-
-
-
-[section:value execution::mapping_t::thread_t::value]
-
-[indexterm2 asio.indexterm.execution__mapping_t__thread_t.value..value..execution::mapping_t::thread_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr mapping_t value();
-
-
-
-[heading Return Value]
-      
-`thread_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:execution__occupancy execution::occupancy]
-
-[indexterm1 asio.indexterm.execution__occupancy..execution::occupancy]
-
-A special value used for accessing the [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property. 
-
-
-  constexpr occupancy_t occupancy;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/occupancy.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__occupancy_t execution::occupancy_t]
-
-[indexterm1 asio.indexterm.execution__occupancy_t..execution::occupancy_t]
-
-
-A property that gives an estimate of the number of execution agents that should occupy the associated execution context. 
-
-
-  struct occupancy_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__occupancy_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__occupancy_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The occupancy_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__occupancy_t.is_preferable [*is_preferable]] [static]]
-    [The occupancy_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__occupancy_t.is_requirable [*is_requirable]] [static]]
-    [The occupancy_t property cannot be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/occupancy.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::occupancy_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__occupancy_t.is_applicable_property_v..is_applicable_property_v..execution::occupancy_t] 
-The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::occupancy_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__occupancy_t.is_preferable..is_preferable..execution::occupancy_t] 
-The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::occupancy_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__occupancy_t.is_requirable..is_requirable..execution::occupancy_t] 
-The [link asio.reference.execution__occupancy_t `execution::occupancy_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::occupancy_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__occupancy_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::occupancy_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef std::size_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/occupancy.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:execution__outstanding_work execution::outstanding_work]
-
-[indexterm1 asio.indexterm.execution__outstanding_work..execution::outstanding_work]
-
-A special value used for accessing the [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property. 
-
-
-  constexpr outstanding_work_t outstanding_work;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__outstanding_work_t execution::outstanding_work_t]
-
-[indexterm1 asio.indexterm.execution__outstanding_work_t..execution::outstanding_work_t]
-
-
-A property to describe whether task submission is likely in the future. 
-
-
-  struct outstanding_work_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__outstanding_work_t__tracked_t [*tracked_t]]]
-    [A sub-property that indicates that the executor represents likely future submission of a function object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__outstanding_work_t__untracked_t [*untracked_t]]]
-    [A sub-property that indicates that the executor does not represent likely future submission of a function object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__outstanding_work_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.outstanding_work_t [*outstanding_work_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from a sub-property value. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The outstanding_work_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.is_preferable [*is_preferable]] [static]]
-    [The top-level outstanding_work_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.is_requirable [*is_requirable]] [static]]
-    [The top-level outstanding_work_t property cannot be required. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.tracked [*tracked]] [static]]
-    [A special value used for accessing the outstanding_work_t::tracked_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.untracked [*untracked]] [static]]
-    [A special value used for accessing the outstanding_work_t::untracked_t property. ]
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t.operator_not__eq_ [*operator!=]]]
-    [Compare property values for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__outstanding_work_t.operator_eq__eq_ [*operator==]]]
-    [Compare property values for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::outstanding_work_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t] 
-The [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::outstanding_work_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.is_preferable..is_preferable..execution::outstanding_work_t] 
-The top-level [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::outstanding_work_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.is_requirable..is_requirable..execution::outstanding_work_t] 
-The top-level [link asio.reference.execution__outstanding_work_t `execution::outstanding_work_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ execution::outstanding_work_t::operator!=]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.operator_not__eq_..operator!=..execution::outstanding_work_t] 
-Compare property values for inequality. 
-
-
-  constexpr bool operator!=(
-      const outstanding_work_t & a,
-      const outstanding_work_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ execution::outstanding_work_t::operator==]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.operator_eq__eq_..operator==..execution::outstanding_work_t] 
-Compare property values for equality. 
-
-
-  constexpr bool operator==(
-      const outstanding_work_t & a,
-      const outstanding_work_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:outstanding_work_t execution::outstanding_work_t::outstanding_work_t]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.outstanding_work_t..outstanding_work_t..execution::outstanding_work_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload1 outstanding_work_t]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload1 more...]]``
-
-
-Construct from a sub-property value. 
-
-
-  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload2 outstanding_work_t]``(
-      untracked_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload2 more...]]``
-
-  constexpr ``[link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload3 outstanding_work_t]``(
-      tracked_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__outstanding_work_t.outstanding_work_t.overload3 more...]]``
-
-
-[section:overload1 execution::outstanding_work_t::outstanding_work_t (1 of 3 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr outstanding_work_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::outstanding_work_t::outstanding_work_t (2 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr outstanding_work_t(
-      untracked_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::outstanding_work_t::outstanding_work_t (3 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr outstanding_work_t(
-      tracked_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:polymorphic_query_result_type execution::outstanding_work_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef outstanding_work_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:tracked execution::outstanding_work_t::tracked]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.tracked..tracked..execution::outstanding_work_t] 
-A special value used for accessing the [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property. 
-
-
-  static constexpr tracked_t tracked;
-
-
-
-[endsect]
-
-
-
-[section:untracked execution::outstanding_work_t::untracked]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t.untracked..untracked..execution::outstanding_work_t] 
-A special value used for accessing the [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property. 
-
-
-  static constexpr untracked_t untracked;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__outstanding_work_t__tracked_t execution::outstanding_work_t::tracked_t]
-
-[indexterm1 asio.indexterm.execution__outstanding_work_t__tracked_t..execution::outstanding_work_t::tracked_t]
-
-
-A sub-property that indicates that the executor represents likely future submission of a function object. 
-
-
-  struct tracked_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.tracked_t [*tracked_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The outstanding_work_t::untracked_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_preferable [*is_preferable]] [static]]
-    [The outstanding_work_t::tracked_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__tracked_t.is_requirable [*is_requirable]] [static]]
-    [The outstanding_work_t::tracked_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::outstanding_work_t::tracked_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t::tracked_t] 
-The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::outstanding_work_t::tracked_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_preferable..is_preferable..execution::outstanding_work_t::tracked_t] 
-The [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::outstanding_work_t::tracked_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.is_requirable..is_requirable..execution::outstanding_work_t::tracked_t] 
-The [link asio.reference.execution__outstanding_work_t__tracked_t `execution::outstanding_work_t::tracked_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::outstanding_work_t::tracked_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t::tracked_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef outstanding_work_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:tracked_t execution::outstanding_work_t::tracked_t::tracked_t]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.tracked_t..tracked_t..execution::outstanding_work_t::tracked_t] 
-Default constructor. 
-
-
-  constexpr tracked_t();
-
-
-
-[endsect]
-
-
-
-[section:value execution::outstanding_work_t::tracked_t::value]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__tracked_t.value..value..execution::outstanding_work_t::tracked_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr outstanding_work_t value();
-
-
-
-[heading Return Value]
-      
-`tracked_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__outstanding_work_t__untracked_t execution::outstanding_work_t::untracked_t]
-
-[indexterm1 asio.indexterm.execution__outstanding_work_t__untracked_t..execution::outstanding_work_t::untracked_t]
-
-
-A sub-property that indicates that the executor does not represent likely future submission of a function object. 
-
-
-  struct untracked_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.untracked_t [*untracked_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The outstanding_work_t::untracked_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_preferable [*is_preferable]] [static]]
-    [The outstanding_work_t::untracked_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__outstanding_work_t__untracked_t.is_requirable [*is_requirable]] [static]]
-    [The outstanding_work_t::untracked_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::outstanding_work_t::untracked_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_applicable_property_v..is_applicable_property_v..execution::outstanding_work_t::untracked_t] 
-The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::outstanding_work_t::untracked_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_preferable..is_preferable..execution::outstanding_work_t::untracked_t] 
-The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::outstanding_work_t::untracked_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.is_requirable..is_requirable..execution::outstanding_work_t::untracked_t] 
-The [link asio.reference.execution__outstanding_work_t__untracked_t `execution::outstanding_work_t::untracked_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::outstanding_work_t::untracked_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::outstanding_work_t::untracked_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef outstanding_work_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/outstanding_work.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:untracked_t execution::outstanding_work_t::untracked_t::untracked_t]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.untracked_t..untracked_t..execution::outstanding_work_t::untracked_t] 
-Default constructor. 
-
-
-  constexpr untracked_t();
-
-
-
-[endsect]
-
-
-
-[section:value execution::outstanding_work_t::untracked_t::value]
-
-[indexterm2 asio.indexterm.execution__outstanding_work_t__untracked_t.value..value..execution::outstanding_work_t::untracked_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr outstanding_work_t value();
-
-
-
-[heading Return Value]
-      
-`untracked_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__prefer_only execution::prefer_only]
-
-[indexterm1 asio.indexterm.execution__prefer_only..execution::prefer_only]
-
-
-A property adapter that is used with the polymorphic executor wrapper to mark properties as preferable, but not requirable. 
-
-
-  template<
-      typename Property>
-  struct prefer_only
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__prefer_only.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__prefer_only.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The prefer_only adapter applies to the same types as the nested property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__prefer_only.is_preferable [*is_preferable]] [static]]
-    [The context_t property can be preferred, it the underlying property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__prefer_only.is_requirable [*is_requirable]] [static]]
-    [The context_t property cannot be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/prefer_only.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:is_applicable_property_v execution::prefer_only::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__prefer_only.is_applicable_property_v..is_applicable_property_v..execution::prefer_only] 
-The [link asio.reference.execution__prefer_only `execution::prefer_only`] adapter applies to the same types as the nested property. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v =
-    is_applicable_property<T, Property>::value;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::prefer_only::is_preferable]
-
-[indexterm2 asio.indexterm.execution__prefer_only.is_preferable..is_preferable..execution::prefer_only] 
-The [link asio.reference.execution__context_t `execution::context_t`] property can be preferred, it the underlying property can be preferred. 
-
-
-  static constexpr bool is_preferable = automatically_determined;
-
-
-`true` if `Property::is_preferable` is `true`, otherwise `false`. 
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::prefer_only::is_requirable]
-
-[indexterm2 asio.indexterm.execution__prefer_only.is_requirable..is_requirable..execution::prefer_only] 
-The [link asio.reference.execution__context_t `execution::context_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::prefer_only::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__prefer_only.polymorphic_query_result_type..polymorphic_query_result_type..execution::prefer_only] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef Property::polymorphic_query_result_type polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/prefer_only.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:execution__relationship execution::relationship]
-
-[indexterm1 asio.indexterm.execution__relationship..execution::relationship]
-
-A special value used for accessing the [link asio.reference.execution__relationship_t `execution::relationship_t`] property. 
-
-
-  constexpr relationship_t relationship;
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:execution__relationship_t execution::relationship_t]
-
-[indexterm1 asio.indexterm.execution__relationship_t..execution::relationship_t]
-
-
-A property to describe whether submitted tasks represent continuations of the calling context. 
-
-
-  struct relationship_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__relationship_t__continuation_t [*continuation_t]]]
-    [A sub-property that indicates that the executor represents a continuation of the calling context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__relationship_t__fork_t [*fork_t]]]
-    [A sub-property that indicates that the executor does not represent a continuation of the calling context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution__relationship_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t.relationship_t [*relationship_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from a sub-property value. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t.continuation [*continuation]] [static]]
-    [A special value used for accessing the relationship_t::continuation_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t.fork [*fork]] [static]]
-    [A special value used for accessing the relationship_t::fork_t property. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The relationship_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t.is_preferable [*is_preferable]] [static]]
-    [The top-level relationship_t property cannot be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t.is_requirable [*is_requirable]] [static]]
-    [The top-level relationship_t property cannot be required. ]
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t.operator_not__eq_ [*operator!=]]]
-    [Compare property values for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__relationship_t.operator_eq__eq_ [*operator==]]]
-    [Compare property values for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:continuation execution::relationship_t::continuation]
-
-[indexterm2 asio.indexterm.execution__relationship_t.continuation..continuation..execution::relationship_t] 
-A special value used for accessing the [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property. 
-
-
-  static constexpr continuation_t continuation;
-
-
-
-[endsect]
-
-
-
-[section:fork execution::relationship_t::fork]
-
-[indexterm2 asio.indexterm.execution__relationship_t.fork..fork..execution::relationship_t] 
-A special value used for accessing the [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property. 
-
-
-  static constexpr fork_t fork;
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::relationship_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__relationship_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t] 
-The [link asio.reference.execution__relationship_t `execution::relationship_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::relationship_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__relationship_t.is_preferable..is_preferable..execution::relationship_t] 
-The top-level [link asio.reference.execution__relationship_t `execution::relationship_t`] property cannot be preferred. 
-
-
-  static constexpr bool is_preferable = false;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::relationship_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__relationship_t.is_requirable..is_requirable..execution::relationship_t] 
-The top-level [link asio.reference.execution__relationship_t `execution::relationship_t`] property cannot be required. 
-
-
-  static constexpr bool is_requirable = false;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ execution::relationship_t::operator!=]
-
-[indexterm2 asio.indexterm.execution__relationship_t.operator_not__eq_..operator!=..execution::relationship_t] 
-Compare property values for inequality. 
-
-
-  constexpr bool operator!=(
-      const relationship_t & a,
-      const relationship_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ execution::relationship_t::operator==]
-
-[indexterm2 asio.indexterm.execution__relationship_t.operator_eq__eq_..operator==..execution::relationship_t] 
-Compare property values for equality. 
-
-
-  constexpr bool operator==(
-      const relationship_t & a,
-      const relationship_t & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::relationship_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__relationship_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef relationship_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[section:relationship_t execution::relationship_t::relationship_t]
-
-[indexterm2 asio.indexterm.execution__relationship_t.relationship_t..relationship_t..execution::relationship_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload1 relationship_t]``();
-  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload1 more...]]``
-
-
-Construct from a sub-property value. 
-
-
-  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload2 relationship_t]``(
-      fork_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload2 more...]]``
-
-  constexpr ``[link asio.reference.execution__relationship_t.relationship_t.overload3 relationship_t]``(
-      continuation_t );
-  ``  [''''&raquo;''' [link asio.reference.execution__relationship_t.relationship_t.overload3 more...]]``
-
-
-[section:overload1 execution::relationship_t::relationship_t (1 of 3 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr relationship_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 execution::relationship_t::relationship_t (2 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr relationship_t(
-      fork_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 execution::relationship_t::relationship_t (3 of 3 overloads)]
-
-
-Construct from a sub-property value. 
-
-
-  constexpr relationship_t(
-      continuation_t );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:execution__relationship_t__continuation_t execution::relationship_t::continuation_t]
-
-[indexterm1 asio.indexterm.execution__relationship_t__continuation_t..execution::relationship_t::continuation_t]
-
-
-A sub-property that indicates that the executor represents a continuation of the calling context. 
-
-
-  struct continuation_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__relationship_t__continuation_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t__continuation_t.continuation_t [*continuation_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__relationship_t__continuation_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t__continuation_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The relationship_t::continuation_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t__continuation_t.is_preferable [*is_preferable]] [static]]
-    [The relationship_t::continuation_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t__continuation_t.is_requirable [*is_requirable]] [static]]
-    [The relationship_t::continuation_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:continuation_t execution::relationship_t::continuation_t::continuation_t]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.continuation_t..continuation_t..execution::relationship_t::continuation_t] 
-Default constructor. 
-
-
-  constexpr continuation_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::relationship_t::continuation_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t::continuation_t] 
-The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::relationship_t::continuation_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_preferable..is_preferable..execution::relationship_t::continuation_t] 
-The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::relationship_t::continuation_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.is_requirable..is_requirable..execution::relationship_t::continuation_t] 
-The [link asio.reference.execution__relationship_t__continuation_t `execution::relationship_t::continuation_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::relationship_t::continuation_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t::continuation_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef relationship_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::relationship_t::continuation_t::value]
-
-[indexterm2 asio.indexterm.execution__relationship_t__continuation_t.value..value..execution::relationship_t::continuation_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr relationship_t value();
-
-
-
-[heading Return Value]
-      
-`continuation_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution__relationship_t__fork_t execution::relationship_t::fork_t]
-
-[indexterm1 asio.indexterm.execution__relationship_t__fork_t..execution::relationship_t::fork_t]
-
-
-A sub-property that indicates that the executor does not represent a continuation of the calling context. 
-
-
-  struct fork_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution__relationship_t__fork_t.polymorphic_query_result_type [*polymorphic_query_result_type]]]
-    [The type returned by queries against an any_executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t__fork_t.fork_t [*fork_t]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution__relationship_t__fork_t.value [*value]] [static]]
-    [Get the value associated with a property object. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution__relationship_t__fork_t.is_applicable_property_v [*is_applicable_property_v]] [static]]
-    [The relationship_t::fork_t property applies to executors. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t__fork_t.is_preferable [*is_preferable]] [static]]
-    [The relationship_t::fork_t property can be preferred. ]
-  ]
-
-  [
-    [[link asio.reference.execution__relationship_t__fork_t.is_requirable [*is_requirable]] [static]]
-    [The relationship_t::fork_t property can be required. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:fork_t execution::relationship_t::fork_t::fork_t]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.fork_t..fork_t..execution::relationship_t::fork_t] 
-Default constructor. 
-
-
-  constexpr fork_t();
-
-
-
-[endsect]
-
-
-
-[section:is_applicable_property_v execution::relationship_t::fork_t::is_applicable_property_v]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_applicable_property_v..is_applicable_property_v..execution::relationship_t::fork_t] 
-The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property applies to executors. 
-
-
-  template <typename T>
-  static constexpr bool is_applicable_property_v = is_executor_v<T>;
-
-
-
-[endsect]
-
-
-
-[section:is_preferable execution::relationship_t::fork_t::is_preferable]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_preferable..is_preferable..execution::relationship_t::fork_t] 
-The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property can be preferred. 
-
-
-  static constexpr bool is_preferable = true;
-
-
-
-[endsect]
-
-
-
-[section:is_requirable execution::relationship_t::fork_t::is_requirable]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.is_requirable..is_requirable..execution::relationship_t::fork_t] 
-The [link asio.reference.execution__relationship_t__fork_t `execution::relationship_t::fork_t`] property can be required. 
-
-
-  static constexpr bool is_requirable = true;
-
-
-
-[endsect]
-
-
-
-[section:polymorphic_query_result_type execution::relationship_t::fork_t::polymorphic_query_result_type]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.polymorphic_query_result_type..polymorphic_query_result_type..execution::relationship_t::fork_t] 
-The type returned by queries against an `any_executor`. 
-
-
-  typedef relationship_t polymorphic_query_result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution/relationship.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:value execution::relationship_t::fork_t::value]
-
-[indexterm2 asio.indexterm.execution__relationship_t__fork_t.value..value..execution::relationship_t::fork_t] 
-Get the value associated with a property object. 
-
-
-  static constexpr relationship_t value();
-
-
-
-[heading Return Value]
-      
-`fork_t()`; 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution_context execution_context]
-
-[indexterm1 asio.indexterm.execution_context..execution_context]
-
-
-A context for function object execution. 
-
-
-  class execution_context :
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.execution_context__id [*id]]]
-    [Class used to uniquely identify a service. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution_context__service [*service]]]
-    [Base class for all io_context services. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.execution_context.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context.execution_context [*execution_context]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context._execution_context [*~execution_context]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context.add_service [*add_service]]]
-    [(Deprecated: Use make_service().) Add a service object to the execution_context. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context.has_service [*has_service]]]
-    [Determine if an execution_context contains a specified service type. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context.make_service [*make_service]]]
-    [Creates a service object and adds it to the execution_context. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context.use_service [*use_service]]]
-    [Obtain the service object corresponding to the given type. ]
-  ]
-  
-]
-
-An execution context represents a place where function objects will be executed. An `io_context` is an example of an execution context.
-
-
-[heading The execution_context class and services]
-  
-
-
-Class [link asio.reference.execution_context `execution_context`] implements an extensible, type-safe, polymorphic set of services, indexed by service type.
-
-Services exist to manage the resources that are shared across an execution context. For example, timers may be implemented in terms of a single timer queue, and this queue would be stored in a service.
-
-Access to the services of an [link asio.reference.execution_context `execution_context`] is via three function templates, `use_service()`, `add_service()` and `has_service()`.
-
-In a call to `use_service<Service>()`, the type argument chooses a service, making available all members of the named type. If `Service` is not present in an [link asio.reference.execution_context `execution_context`], an object of type `Service` is created and added to the [link asio.reference.execution_context `execution_context`]. A C++ program can check if an [link asio.reference.execution_context `execution_context`] implements a particular service with the function template `has_service<Service>()`.
-
-Service objects may be explicitly added to an [link asio.reference.execution_context `execution_context`] using the function template `add_service<Service>()`. If the `Service` is already present, the [link asio.reference.service_already_exists `service_already_exists`] exception is thrown. If the owner of the service is not the same object as the [link asio.reference.execution_context `execution_context`] parameter, the [link asio.reference.invalid_service_owner `invalid_service_owner`] exception is thrown.
-
-Once a service reference is obtained from an [link asio.reference.execution_context `execution_context`] object by calling `use_service()`, that reference remains usable as long as the owning [link asio.reference.execution_context `execution_context`] object exists.
-
-All service implementations have [link asio.reference.execution_context__service `execution_context::service`] as a public base class. Custom services may be implemented by deriving from this class and then added to an [link asio.reference.execution_context `execution_context`] using the facilities described above.
-
-
-[heading The execution_context as a base class]
-  
-
-
-Class [link asio.reference.execution_context `execution_context`] may be used only as a base class for concrete execution context types. The `io_context` is an example of such a derived type.
-
-On destruction, a class that is derived from [link asio.reference.execution_context `execution_context`] must perform `execution_context::shutdown()` followed by `execution_context::destroy()`.
-
-This destruction sequence permits programs to simplify their resource management by using `shared_ptr<>`. Where an object's lifetime is tied to the lifetime of a connection (or some other sequence of asynchronous operations), a `shared_ptr` to the object would be bound into the handlers for all asynchronous operations associated with it. This works as follows:
-
-
-* When a single connection ends, all associated asynchronous operations complete. The corresponding handler objects are destroyed, and all `shared_ptr` references to the objects are destroyed.
-
-
-* To shut down the whole program, the [link asio.reference.io_context `io_context`] function stop() is called to terminate any run() calls as soon as possible. The [link asio.reference.io_context `io_context`] destructor calls `shutdown()` and `destroy()` to destroy all pending handlers, causing all `shared_ptr` references to all connection objects to be destroyed. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:add_service execution_context::add_service]
-
-[indexterm2 asio.indexterm.execution_context.add_service..add_service..execution_context] 
-(Deprecated: Use `make_service()`.) Add a service object to the [link asio.reference.execution_context `execution_context`]. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  void add_service(
-      execution_context & e,
-      Service * svc);
-
-
-This function is used to add a service to the [link asio.reference.execution_context `execution_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]]
-
-[[svc][The service object. On success, ownership of the service object is transferred to the [link asio.reference.execution_context `execution_context`]. When the [link asio.reference.execution_context `execution_context`] object is destroyed, it will destroy the service object by performing: 
-``
-  delete static_cast<execution_context::service*>(svc) 
-``
-]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`].]]
-
-[[asio::invalid_service_owner][Thrown if the service's owning [link asio.reference.execution_context `execution_context`] is not the [link asio.reference.execution_context `execution_context`] object specified by the `e` parameter. ]]
-
-]
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:destroy execution_context::destroy]
-
-[indexterm2 asio.indexterm.execution_context.destroy..destroy..execution_context] 
-Destroys all services in the context. 
-
-
-  void destroy();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order * of the beginning of service object lifetime, performs `delete static_cast<execution_context::service*>(svc)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:execution_context execution_context::execution_context]
-
-[indexterm2 asio.indexterm.execution_context.execution_context..execution_context..execution_context] 
-Constructor. 
-
-
-  execution_context();
-
-
-
-[endsect]
-
-
-
-[section:fork_event execution_context::fork_event]
-
-[indexterm2 asio.indexterm.execution_context.fork_event..fork_event..execution_context] 
-Fork-related event notifications. 
-
-  enum fork_event
-
-[indexterm2 asio.indexterm.execution_context.fork_event.fork_prepare..fork_prepare..execution_context]
-[indexterm2 asio.indexterm.execution_context.fork_event.fork_parent..fork_parent..execution_context]
-[indexterm2 asio.indexterm.execution_context.fork_event.fork_child..fork_child..execution_context]
-
-[heading Values]
-[variablelist
-
-  [
-    [fork_prepare]
-    [Notify the context that the process is about to fork. ]
-  ]
-
-  [
-    [fork_parent]
-    [Notify the context that the process has forked and is the parent. ]
-  ]
-
-  [
-    [fork_child]
-    [Notify the context that the process has forked and is the child. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:has_service execution_context::has_service]
-
-[indexterm2 asio.indexterm.execution_context.has_service..has_service..execution_context] 
-Determine if an [link asio.reference.execution_context `execution_context`] contains a specified service type. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  bool has_service(
-      execution_context & e);
-
-
-This function is used to determine whether the [link asio.reference.execution_context `execution_context`] contains a service object corresponding to the given service type.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]]
-
-]
-
-
-[heading Return Value]
-      
-A boolean indicating whether the [link asio.reference.execution_context `execution_context`] contains the service. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:make_service execution_context::make_service]
-
-[indexterm2 asio.indexterm.execution_context.make_service..make_service..execution_context] 
-Creates a service object and adds it to the [link asio.reference.execution_context `execution_context`]. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``,
-      typename... Args>
-  Service & make_service(
-      execution_context & e,
-      Args &&... args);
-
-
-This function is used to add a service to the [link asio.reference.execution_context `execution_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]]
-
-[[args][Zero or more arguments to be passed to the service constructor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::service_already_exists][Thrown if a service of the given type is already present in the [link asio.reference.execution_context `execution_context`]. ]]
-
-]
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:notify_fork execution_context::notify_fork]
-
-[indexterm2 asio.indexterm.execution_context.notify_fork..notify_fork..execution_context] 
-Notify the [link asio.reference.execution_context `execution_context`] of a fork-related event. 
-
-
-  void notify_fork(
-      fork_event event);
-
-
-This function is used to inform the [link asio.reference.execution_context `execution_context`] that the process is about to fork, or has just forked. This allows the [link asio.reference.execution_context `execution_context`], and the services it contains, to perform any necessary housekeeping to ensure correct operation following a fork.
-
-This function must not be called while any other [link asio.reference.execution_context `execution_context`] function, or any function associated with the [link asio.reference.execution_context `execution_context`]'s derived class, is being called in another thread. It is, however, safe to call this function from within a completion handler, provided no other thread is accessing the [link asio.reference.execution_context `execution_context`] or its derived class.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[event][A fork-related event.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the notification fails the [link asio.reference.execution_context `execution_context`] object should no longer be used and should be destroyed.]]
-
-]
-
-
-[heading Example]
-  
-The following code illustrates how to incorporate the `notify_fork()` function: 
-
-  my_execution_context.notify_fork(execution_context::fork_prepare);
-  if (fork() == 0)
-  {
-    // This is the child process.
-    my_execution_context.notify_fork(execution_context::fork_child);
-  }
-  else
-  {
-    // This is the parent process.
-    my_execution_context.notify_fork(execution_context::fork_parent);
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, performs `svc->notify_fork();`. When processing the fork\_prepare event, services are visited in reverse order of the beginning of service object lifetime. Otherwise, services are visited in order of the beginning of service object lifetime. 
-
-
-
-
-[endsect]
-
-
-
-[section:shutdown execution_context::shutdown]
-
-[indexterm2 asio.indexterm.execution_context.shutdown..shutdown..execution_context] 
-Shuts down all services in the context. 
-
-
-  void shutdown();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order of the beginning of service object lifetime, performs `svc->shutdown()`. 
-
-
-
-
-[endsect]
-
-
-[section:use_service execution_context::use_service]
-
-[indexterm2 asio.indexterm.execution_context.use_service..use_service..execution_context] 
-Obtain the service object corresponding to the given type. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  Service & ``[link asio.reference.execution_context.use_service.overload1 use_service]``(
-      execution_context & e);
-  ``  [''''&raquo;''' [link asio.reference.execution_context.use_service.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  Service & ``[link asio.reference.execution_context.use_service.overload2 use_service]``(
-      io_context & ioc);
-  ``  [''''&raquo;''' [link asio.reference.execution_context.use_service.overload2 more...]]``
-
-
-[section:overload1 execution_context::use_service (1 of 2 overloads)]
-
-
-Obtain the service object corresponding to the given type. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  Service & use_service(
-      execution_context & e);
-
-
-This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the [link asio.reference.execution_context `execution_context`] will create a new instance of the service.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][The [link asio.reference.execution_context `execution_context`] object that owns the service.]]
-
-]
-
-
-[heading Return Value]
-      
-The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-
-[section:overload2 execution_context::use_service (2 of 2 overloads)]
-
-
-Obtain the service object corresponding to the given type. 
-
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  Service & use_service(
-      io_context & ioc);
-
-
-This function is used to locate a service object that corresponds to the given service type. If there is no existing implementation of the service, then the [link asio.reference.io_context `io_context`] will create a new instance of the service.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ioc][The [link asio.reference.io_context `io_context`] object that owns the service.]]
-
-]
-
-
-[heading Return Value]
-      
-The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller.
-
-
-[heading Remarks]
-      
-This overload is preserved for backwards compatibility with services that inherit from [link asio.reference.io_context__service `io_context::service`]. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_execution_context execution_context::~execution_context]
-
-[indexterm2 asio.indexterm.execution_context._execution_context..~execution_context..execution_context] 
-Destructor. 
-
-
-  ~execution_context();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution_context__id execution_context::id]
-
-[indexterm1 asio.indexterm.execution_context__id..execution_context::id]
-
-
-Class used to uniquely identify a service. 
-
-
-  class id :
-    noncopyable
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context__id.id [*id]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:id execution_context::id::id]
-
-[indexterm2 asio.indexterm.execution_context__id.id..id..execution_context::id] 
-Constructor. 
-
-
-  id();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:execution_context__service execution_context::service]
-
-[indexterm1 asio.indexterm.execution_context__service..execution_context::service]
-
-
-Base class for all [link asio.reference.io_context `io_context`] services. 
-
-
-  class service :
-    noncopyable
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context__service.context [*context]]]
-    [Get the context object that owns the service. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context__service.service [*service]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context__service._service [*~service]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Private Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.execution_context__service.notify_fork [*notify_fork]]]
-    [Handle notification of a fork-related event to perform any necessary housekeeping. ]
-  ]
-  
-  [
-    [[link asio.reference.execution_context__service.shutdown [*shutdown]]]
-    [Destroy all user-defined handler objects owned by the service. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:context execution_context::service::context]
-
-[indexterm2 asio.indexterm.execution_context__service.context..context..execution_context::service] 
-Get the context object that owns the service. 
-
-
-  execution_context & context();
-
-
-
-[endsect]
-
-
-
-[section:service execution_context::service::service]
-
-[indexterm2 asio.indexterm.execution_context__service.service..service..execution_context::service] 
-Constructor. 
-
-
-  service(
-      execution_context & owner);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[owner][The [link asio.reference.execution_context `execution_context`] object that owns the service. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:_service execution_context::service::~service]
-
-[indexterm2 asio.indexterm.execution_context__service._service..~service..execution_context::service] 
-Destructor. 
-
-
-  virtual ~service();
-
-
-
-[endsect]
-
-
-
-[section:notify_fork execution_context::service::notify_fork]
-
-[indexterm2 asio.indexterm.execution_context__service.notify_fork..notify_fork..execution_context::service] 
-Handle notification of a fork-related event to perform any necessary housekeeping. 
-
-
-  virtual void notify_fork(
-      execution_context::fork_event event);
-
-
-This function is not a pure virtual so that services only have to implement it if necessary. The default implementation does nothing. 
-
-
-[endsect]
-
-
-
-[section:shutdown execution_context::service::shutdown]
-
-[indexterm2 asio.indexterm.execution_context__service.shutdown..shutdown..execution_context::service] 
-Destroy all user-defined handler objects owned by the service. 
-
-
-  void shutdown();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:executor executor]
-
-[indexterm1 asio.indexterm.executor..executor]
-
-
-Polymorphic wrapper for executors. 
-
-
-  class executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.executor__unspecified_bool_type_t [*unspecified_bool_type_t]]]
-    []
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor.unspecified_bool_type [*unspecified_bool_type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.defer [*defer]]]
-    [Request the executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.dispatch [*dispatch]]]
-    [Request the executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.executor [*executor]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct from nullptr. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Construct a polymorphic wrapper for the specified executor. 
-     [hr]
-     Construct a polymorphic executor that points to the same target as another polymorphic executor. 
-     [hr]
-     Construct a polymorphic executor that moves the target from another polymorphic executor. 
-     [hr]
-     Allocator-aware constructor to create a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.on_work_finished [*on_work_finished]]]
-    [Inform the executor that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.on_work_started [*on_work_started]]]
-    [Inform the executor that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.operator_unspecified_bool_type [*operator unspecified_bool_type]]]
-    [Operator to test if the executor contains a valid target. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     
-     [hr]
-     Assignment operator for nullptr_t. 
-     [hr]
-     Assignment operator to create a polymorphic wrapper for the specified executor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.post [*post]]]
-    [Request the executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.target [*target]]]
-    [Obtain a pointer to the target executor object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.target_type [*target_type]]]
-    [Obtain type information for the target executor object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.unspecified_bool_true [*unspecified_bool_true]] [static]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.executor._executor [*~executor]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.executor.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.executor.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:context executor::context]
-
-[indexterm2 asio.indexterm.executor.context..context..executor] 
-Obtain the underlying execution context. 
-
-
-  execution_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer executor::defer]
-
-[indexterm2 asio.indexterm.executor.defer..defer..executor] 
-Request the executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void defer(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object is executed according to the rules of the target executor object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch executor::dispatch]
-
-[indexterm2 asio.indexterm.executor.dispatch..dispatch..executor] 
-Request the executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void dispatch(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object is executed according to the rules of the target executor object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:executor executor::executor]
-
-[indexterm2 asio.indexterm.executor.executor..executor..executor] 
-Default constructor. 
-
-
-  ``[link asio.reference.executor.executor.overload1 executor]``();
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload1 more...]]``
-
-
-Construct from nullptr. 
-
-
-  ``[link asio.reference.executor.executor.overload2 executor]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.executor.executor.overload3 executor]``(
-      const executor & other);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.executor.executor.overload4 executor]``(
-      executor && other);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload4 more...]]``
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.executor.executor.overload5 executor]``(
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload5 more...]]``
-
-
-Construct a polymorphic executor that points to the same target as another polymorphic executor. 
-
-
-  ``[link asio.reference.executor.executor.overload6 executor]``(
-      std::nothrow_t ,
-      const executor & other);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload6 more...]]``
-
-
-Construct a polymorphic executor that moves the target from another polymorphic executor. 
-
-
-  ``[link asio.reference.executor.executor.overload7 executor]``(
-      std::nothrow_t ,
-      executor && other);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  ``[link asio.reference.executor.executor.overload8 executor]``(
-      std::nothrow_t ,
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload8 more...]]``
-
-
-Allocator-aware constructor to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Allocator>
-  ``[link asio.reference.executor.executor.overload9 executor]``(
-      allocator_arg_t ,
-      const Allocator & a,
-      Executor e);
-  ``  [''''&raquo;''' [link asio.reference.executor.executor.overload9 more...]]``
-
-
-[section:overload1 executor::executor (1 of 9 overloads)]
-
-
-Default constructor. 
-
-
-  executor();
-
-
-
-[endsect]
-
-
-
-[section:overload2 executor::executor (2 of 9 overloads)]
-
-
-Construct from nullptr. 
-
-
-  executor(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload3 executor::executor (3 of 9 overloads)]
-
-
-Copy constructor. 
-
-
-  executor(
-      const executor & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 executor::executor (4 of 9 overloads)]
-
-
-Move constructor. 
-
-
-  executor(
-      executor && other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 executor::executor (5 of 9 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor(
-      Executor e);
-
-
-
-[endsect]
-
-
-
-[section:overload6 executor::executor (6 of 9 overloads)]
-
-
-Construct a polymorphic executor that points to the same target as another polymorphic executor. 
-
-
-  executor(
-      std::nothrow_t ,
-      const executor & other);
-
-
-
-[endsect]
-
-
-
-[section:overload7 executor::executor (7 of 9 overloads)]
-
-
-Construct a polymorphic executor that moves the target from another polymorphic executor. 
-
-
-  executor(
-      std::nothrow_t ,
-      executor && other);
-
-
-
-[endsect]
-
-
-
-[section:overload8 executor::executor (8 of 9 overloads)]
-
-
-Construct a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor(
-      std::nothrow_t ,
-      Executor e);
-
-
-
-[endsect]
-
-
-
-[section:overload9 executor::executor (9 of 9 overloads)]
-
-
-Allocator-aware constructor to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Allocator>
-  executor(
-      allocator_arg_t ,
-      const Allocator & a,
-      Executor e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:on_work_finished executor::on_work_finished]
-
-[indexterm2 asio.indexterm.executor.on_work_finished..on_work_finished..executor] 
-Inform the executor that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-
-[endsect]
-
-
-
-[section:on_work_started executor::on_work_started]
-
-[indexterm2 asio.indexterm.executor.on_work_started..on_work_started..executor] 
-Inform the executor that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_unspecified_bool_type executor::operator unspecified_bool_type]
-
-[indexterm2 asio.indexterm.executor.operator_unspecified_bool_type..operator unspecified_bool_type..executor] 
-Operator to test if the executor contains a valid target. 
-
-
-  operator unspecified_bool_type() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ executor::operator!=]
-
-[indexterm2 asio.indexterm.executor.operator_not__eq_..operator!=..executor] 
-Compare two executors for inequality. 
-
-
-  bool operator!=(
-      const executor & a,
-      const executor & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ executor::operator=]
-
-[indexterm2 asio.indexterm.executor.operator_eq_..operator=..executor] 
-Assignment operator. 
-
-
-  executor & ``[link asio.reference.executor.operator_eq_.overload1 operator=]``(
-      const executor & other);
-  ``  [''''&raquo;''' [link asio.reference.executor.operator_eq_.overload1 more...]]``
-
-
-
-  executor & ``[link asio.reference.executor.operator_eq_.overload2 operator=]``(
-      executor && other);
-  ``  [''''&raquo;''' [link asio.reference.executor.operator_eq_.overload2 more...]]``
-
-
-Assignment operator for nullptr\_t. 
-
-
-  executor & ``[link asio.reference.executor.operator_eq_.overload3 operator=]``(
-      nullptr_t );
-  ``  [''''&raquo;''' [link asio.reference.executor.operator_eq_.overload3 more...]]``
-
-
-Assignment operator to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor & ``[link asio.reference.executor.operator_eq_.overload4 operator=]``(
-      Executor && e);
-  ``  [''''&raquo;''' [link asio.reference.executor.operator_eq_.overload4 more...]]``
-
-
-[section:overload1 executor::operator= (1 of 4 overloads)]
-
-
-Assignment operator. 
-
-
-  executor & operator=(
-      const executor & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 executor::operator= (2 of 4 overloads)]
-
-
-
-  executor & operator=(
-      executor && other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 executor::operator= (3 of 4 overloads)]
-
-
-Assignment operator for nullptr\_t. 
-
-
-  executor & operator=(
-      nullptr_t );
-
-
-
-[endsect]
-
-
-
-[section:overload4 executor::operator= (4 of 4 overloads)]
-
-
-Assignment operator to create a polymorphic wrapper for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor & operator=(
-      Executor && e);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ executor::operator==]
-
-[indexterm2 asio.indexterm.executor.operator_eq__eq_..operator==..executor] 
-Compare two executors for equality. 
-
-
-  bool operator==(
-      const executor & a,
-      const executor & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post executor::post]
-
-[indexterm2 asio.indexterm.executor.post..post..executor] 
-Request the executor to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void post(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object is executed according to the rules of the target executor object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:target executor::target]
-
-[indexterm2 asio.indexterm.executor.target..target..executor] 
-Obtain a pointer to the target executor object. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * ``[link asio.reference.executor.target.overload1 target]``();
-  ``  [''''&raquo;''' [link asio.reference.executor.target.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * ``[link asio.reference.executor.target.overload2 target]``() const;
-  ``  [''''&raquo;''' [link asio.reference.executor.target.overload2 more...]]``
-
-
-[section:overload1 executor::target (1 of 2 overloads)]
-
-
-Obtain a pointer to the target executor object. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  Executor * target();
-
-
-
-[heading Return Value]
-      
-If `target_type() == typeid(T)`, a pointer to the stored executor target; otherwise, a null pointer. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 executor::target (2 of 2 overloads)]
-
-
-Obtain a pointer to the target executor object. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  const Executor * target() const;
-
-
-
-[heading Return Value]
-      
-If `target_type() == typeid(T)`, a pointer to the stored executor target; otherwise, a null pointer. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:target_type executor::target_type]
-
-[indexterm2 asio.indexterm.executor.target_type..target_type..executor] 
-Obtain type information for the target executor object. 
-
-
-  const std::type_info & target_type() const;
-
-
-
-[heading Return Value]
-      
-If `*this` has a target type of type `T`, `typeid(T)`; otherwise, `typeid(void)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:unspecified_bool_true executor::unspecified_bool_true]
-
-[indexterm2 asio.indexterm.executor.unspecified_bool_true..unspecified_bool_true..executor] 
-
-  static void unspecified_bool_true(
-      unspecified_bool_type_t );
-
-
-
-[endsect]
-
-
-
-[section:unspecified_bool_type executor::unspecified_bool_type]
-
-[indexterm2 asio.indexterm.executor.unspecified_bool_type..unspecified_bool_type..executor] 
-
-  typedef void(* unspecified_bool_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_executor executor::~executor]
-
-[indexterm2 asio.indexterm.executor._executor..~executor..executor] 
-Destructor. 
-
-
-  ~executor();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:executor__unspecified_bool_type_t executor::unspecified_bool_type_t]
-
-[indexterm1 asio.indexterm.executor__unspecified_bool_type_t..executor::unspecified_bool_type_t]
-
-
-
-  struct unspecified_bool_type_t
-
-
-[heading Requirements]
-
-['Header: ][^asio/executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:executor_arg executor_arg]
-
-[indexterm1 asio.indexterm.executor_arg..executor_arg]
-
-A special value, similar to std::nothrow, used to disambiguate constructors that accept executor arguments. 
-
-
-  constexpr executor_arg_t executor_arg;
-
-
-See [link asio.reference.executor_arg_t `executor_arg_t`] and [link asio.reference.uses_executor `uses_executor`] for more information. 
-
-[heading Requirements]
-
-['Header: ][^asio/uses_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:executor_arg_t executor_arg_t]
-
-[indexterm1 asio.indexterm.executor_arg_t..executor_arg_t]
-
-
-A special type, similar to std::nothrow\_t, used to disambiguate constructors that accept executor arguments. 
-
-
-  struct executor_arg_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.executor_arg_t.executor_arg_t [*executor_arg_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-The [link asio.reference.executor_arg_t `executor_arg_t`] struct is an empty structure type used as a unique type to disambiguate constructor and function overloading. Specifically, some types have constructors with [link asio.reference.executor_arg_t `executor_arg_t`] as the first argument, immediately followed by an argument of a type that satisfies the Executor type requirements. 
-
-[heading Requirements]
-
-['Header: ][^asio/uses_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:executor_arg_t executor_arg_t::executor_arg_t]
-
-[indexterm2 asio.indexterm.executor_arg_t.executor_arg_t..executor_arg_t..executor_arg_t] 
-Constructor. 
-
-
-  constexpr executor_arg_t();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:executor_binder executor_binder]
-
-[indexterm1 asio.indexterm.executor_binder..executor_binder]
-
-
-A call wrapper type to bind an executor of type `Executor` to an object of type `T`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class executor_binder
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.executor_binder.argument_type [*argument_type]]]
-    [The type of the function's argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor_binder.executor_type [*executor_type]]]
-    [The type of the associated executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor_binder.first_argument_type [*first_argument_type]]]
-    [The type of the function's first argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor_binder.result_type [*result_type]]]
-    [The return type if a function. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor_binder.second_argument_type [*second_argument_type]]]
-    [The type of the function's second argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.executor_binder.target_type [*target_type]]]
-    [The type of the target object. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.executor_binder.executor_binder [*executor_binder]] [constructor]]
-    [Construct an executor wrapper for the specified object. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Construct a copy, but specify a different executor. 
-     [hr]
-     Construct a copy of a different executor wrapper type. 
-     [hr]
-     Construct a copy of a different executor wrapper type, but specify a different executor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Move construct the target object, but specify a different executor. 
-     [hr]
-     Move construct from a different executor wrapper type. 
-     [hr]
-     Move construct from a different executor wrapper type, but specify a different executor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_binder.get [*get]]]
-    [Obtain a reference to the target object. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_binder.get_executor [*get_executor]]]
-    [Obtain the associated executor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_binder.operator_lp__rp_ [*operator()]]]
-    [Forwarding function call operator. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_binder._executor_binder [*~executor_binder]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:argument_type executor_binder::argument_type]
-
-[indexterm2 asio.indexterm.executor_binder.argument_type..argument_type..executor_binder] 
-The type of the function's argument. 
-
-
-  typedef see_below argument_type;
-
-
-
-The type of `argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting a single argument, `argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `argument_type`, then `argument_type` is a synonym for `T::argument_type`;
-
-
-* otherwise `argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:executor_binder executor_binder::executor_binder]
-
-[indexterm2 asio.indexterm.executor_binder.executor_binder..executor_binder..executor_binder] 
-Construct an executor wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  ``[link asio.reference.executor_binder.executor_binder.overload1 executor_binder]``(
-      executor_arg_t ,
-      const executor_type & e,
-      U && u);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.executor_binder.executor_binder.overload2 executor_binder]``(
-      const executor_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload2 more...]]``
-
-
-Construct a copy, but specify a different executor. 
-
-
-  ``[link asio.reference.executor_binder.executor_binder.overload3 executor_binder]``(
-      executor_arg_t ,
-      const executor_type & e,
-      const executor_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload3 more...]]``
-
-
-Construct a copy of a different executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.executor_binder.executor_binder.overload4 executor_binder]``(
-      const executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload4 more...]]``
-
-
-Construct a copy of a different executor wrapper type, but specify a different executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.executor_binder.executor_binder.overload5 executor_binder]``(
-      executor_arg_t ,
-      const executor_type & e,
-      const executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload5 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.executor_binder.executor_binder.overload6 executor_binder]``(
-      executor_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload6 more...]]``
-
-
-Move construct the target object, but specify a different executor. 
-
-
-  ``[link asio.reference.executor_binder.executor_binder.overload7 executor_binder]``(
-      executor_arg_t ,
-      const executor_type & e,
-      executor_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload7 more...]]``
-
-
-Move construct from a different executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.executor_binder.executor_binder.overload8 executor_binder]``(
-      executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload8 more...]]``
-
-
-Move construct from a different executor wrapper type, but specify a different executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.executor_binder.executor_binder.overload9 executor_binder]``(
-      executor_arg_t ,
-      const executor_type & e,
-      executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.executor_binder.overload9 more...]]``
-
-
-[section:overload1 executor_binder::executor_binder (1 of 9 overloads)]
-
-
-Construct an executor wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  executor_binder(
-      executor_arg_t ,
-      const executor_type & e,
-      U && u);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload2 executor_binder::executor_binder (2 of 9 overloads)]
-
-
-Copy constructor. 
-
-
-  executor_binder(
-      const executor_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 executor_binder::executor_binder (3 of 9 overloads)]
-
-
-Construct a copy, but specify a different executor. 
-
-
-  executor_binder(
-      executor_arg_t ,
-      const executor_type & e,
-      const executor_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 executor_binder::executor_binder (4 of 9 overloads)]
-
-
-Construct a copy of a different executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_binder(
-      const executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the `Executor` type is constructible from type `OtherExecutor`, and the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload5 executor_binder::executor_binder (5 of 9 overloads)]
-
-
-Construct a copy of a different executor wrapper type, but specify a different executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_binder(
-      executor_arg_t ,
-      const executor_type & e,
-      const executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload6 executor_binder::executor_binder (6 of 9 overloads)]
-
-
-Move constructor. 
-
-
-  executor_binder(
-      executor_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload7 executor_binder::executor_binder (7 of 9 overloads)]
-
-
-Move construct the target object, but specify a different executor. 
-
-
-  executor_binder(
-      executor_arg_t ,
-      const executor_type & e,
-      executor_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload8 executor_binder::executor_binder (8 of 9 overloads)]
-
-
-Move construct from a different executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_binder(
-      executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload9 executor_binder::executor_binder (9 of 9 overloads)]
-
-
-Move construct from a different executor wrapper type, but specify a different executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_binder(
-      executor_arg_t ,
-      const executor_type & e,
-      executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type executor_binder::executor_type]
-
-[indexterm2 asio.indexterm.executor_binder.executor_type..executor_type..executor_binder] 
-The type of the associated executor. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:first_argument_type executor_binder::first_argument_type]
-
-[indexterm2 asio.indexterm.executor_binder.first_argument_type..first_argument_type..executor_binder] 
-The type of the function's first argument. 
-
-
-  typedef see_below first_argument_type;
-
-
-
-The type of `first_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `first_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `first_argument_type` is a synonym for `T::first_argument_type`;
-
-
-* otherwise `first_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:get executor_binder::get]
-
-[indexterm2 asio.indexterm.executor_binder.get..get..executor_binder] 
-Obtain a reference to the target object. 
-
-
-  target_type & ``[link asio.reference.executor_binder.get.overload1 get]``();
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.get.overload1 more...]]``
-
-  const target_type & ``[link asio.reference.executor_binder.get.overload2 get]``() const;
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.get.overload2 more...]]``
-
-
-[section:overload1 executor_binder::get (1 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  target_type & get();
-
-
-
-[endsect]
-
-
-
-[section:overload2 executor_binder::get (2 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  const target_type & get() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor executor_binder::get_executor]
-
-[indexterm2 asio.indexterm.executor_binder.get_executor..get_executor..executor_binder] 
-Obtain the associated executor. 
-
-
-  executor_type get_executor() const;
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ executor_binder::operator()]
-
-[indexterm2 asio.indexterm.executor_binder.operator_lp__rp_..operator()..executor_binder] 
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.executor_binder.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.executor_binder.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.executor_binder.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 executor_binder::operator() (1 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 executor_binder::operator() (2 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:result_type executor_binder::result_type]
-
-[indexterm2 asio.indexterm.executor_binder.result_type..result_type..executor_binder] 
-The return type if a function. 
-
-
-  typedef see_below result_type;
-
-
-
-The type of `result_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to function type, `result_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `result_type`, then `result_type` is a synonym for `T::result_type`;
-
-
-* otherwise `result_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:second_argument_type executor_binder::second_argument_type]
-
-[indexterm2 asio.indexterm.executor_binder.second_argument_type..second_argument_type..executor_binder] 
-The type of the function's second argument. 
-
-
-  typedef see_below second_argument_type;
-
-
-
-The type of `second_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `second_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `second_argument_type` is a synonym for `T::second_argument_type`;
-
-
-* otherwise `second_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:target_type executor_binder::target_type]
-
-[indexterm2 asio.indexterm.executor_binder.target_type..target_type..executor_binder] 
-The type of the target object. 
-
-
-  typedef T target_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_executor_binder executor_binder::~executor_binder]
-
-[indexterm2 asio.indexterm.executor_binder._executor_binder..~executor_binder..executor_binder] 
-Destructor. 
-
-
-  ~executor_binder();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:executor_work_guard executor_work_guard]
-
-[indexterm1 asio.indexterm.executor_work_guard..executor_work_guard]
-
-
-An object of type `executor_work_guard` controls ownership of outstanding executor work within a scope. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class executor_work_guard
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.executor_work_guard.executor_type [*executor_type]]]
-    [The underlying executor type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.executor_work_guard.executor_work_guard [*executor_work_guard]] [constructor]]
-    [Constructs a executor_work_guard object for the specified executor. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_work_guard.get_executor [*get_executor]]]
-    [Obtain the associated executor. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_work_guard.owns_work [*owns_work]]]
-    [Whether the executor_work_guard object owns some outstanding work. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_work_guard.reset [*reset]]]
-    [Indicate that the work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.executor_work_guard._executor_work_guard [*~executor_work_guard]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/executor_work_guard.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:executor_type executor_work_guard::executor_type]
-
-[indexterm2 asio.indexterm.executor_work_guard.executor_type..executor_type..executor_work_guard] 
-The underlying executor type. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/executor_work_guard.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:executor_work_guard executor_work_guard::executor_work_guard]
-
-[indexterm2 asio.indexterm.executor_work_guard.executor_work_guard..executor_work_guard..executor_work_guard] 
-Constructs a `executor_work_guard` object for the specified executor. 
-
-
-  explicit ``[link asio.reference.executor_work_guard.executor_work_guard.overload1 executor_work_guard]``(
-      const executor_type & e);
-  ``  [''''&raquo;''' [link asio.reference.executor_work_guard.executor_work_guard.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.executor_work_guard.executor_work_guard.overload2 executor_work_guard]``(
-      const executor_work_guard & other);
-  ``  [''''&raquo;''' [link asio.reference.executor_work_guard.executor_work_guard.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.executor_work_guard.executor_work_guard.overload3 executor_work_guard]``(
-      executor_work_guard && other);
-  ``  [''''&raquo;''' [link asio.reference.executor_work_guard.executor_work_guard.overload3 more...]]``
-
-
-[section:overload1 executor_work_guard::executor_work_guard (1 of 3 overloads)]
-
-
-Constructs a `executor_work_guard` object for the specified executor. 
-
-
-  executor_work_guard(
-      const executor_type & e);
-
-
-Stores a copy of `e` and calls `on_work_started()` on it. 
-
-
-[endsect]
-
-
-
-[section:overload2 executor_work_guard::executor_work_guard (2 of 3 overloads)]
-
-
-Copy constructor. 
-
-
-  executor_work_guard(
-      const executor_work_guard & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 executor_work_guard::executor_work_guard (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  executor_work_guard(
-      executor_work_guard && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_executor executor_work_guard::get_executor]
-
-[indexterm2 asio.indexterm.executor_work_guard.get_executor..get_executor..executor_work_guard] 
-Obtain the associated executor. 
-
-
-  executor_type get_executor() const;
-
-
-
-[endsect]
-
-
-
-[section:owns_work executor_work_guard::owns_work]
-
-[indexterm2 asio.indexterm.executor_work_guard.owns_work..owns_work..executor_work_guard] 
-Whether the [link asio.reference.executor_work_guard `executor_work_guard`] object owns some outstanding work. 
-
-
-  bool owns_work() const;
-
-
-
-[endsect]
-
-
-
-[section:reset executor_work_guard::reset]
-
-[indexterm2 asio.indexterm.executor_work_guard.reset..reset..executor_work_guard] 
-Indicate that the work is no longer outstanding. 
-
-
-  void reset();
-
-
-Unless the object has already been reset, or is in a moved-from state, calls `on_work_finished()` on the stored executor. 
-
-
-[endsect]
-
-
-
-[section:_executor_work_guard executor_work_guard::~executor_work_guard]
-
-[indexterm2 asio.indexterm.executor_work_guard._executor_work_guard..~executor_work_guard..executor_work_guard] 
-Destructor. 
-
-
-  ~executor_work_guard();
-
-
-Unless the object has already been reset, or is in a moved-from state, calls `on_work_finished()` on the stored executor. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:experimental__as_single experimental::as_single]
-
-[indexterm1 asio.indexterm.experimental__as_single..experimental::as_single]
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single argument. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr as_single_t< decay_t< CompletionToken > > as_single(
-      CompletionToken && completion_token);
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__as_single_t experimental::as_single_t]
-
-[indexterm1 asio.indexterm.experimental__as_single_t..experimental::as_single_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter used to specify that the completion handler arguments should be combined into a single argument. 
-
-
-  template<
-      typename CompletionToken>
-  class as_single_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use as_single_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__default_constructor_tag [*default_constructor_tag]]]
-    [Tag type used to prevent the "default" constructor from being used for conversions. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the as_single_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use as_single_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__as_single_t.as_single_t [*as_single_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.experimental__as_single_t `experimental::as_single_t`] class is used to indicate that any arguments to the completion handler should be combined and passed as a single argument. If there is already one argument, that argument is passed as-is. If there is more than argument, the arguments are first moved into a `std::tuple` and that tuple is then passed to the completion handler. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[section:as_default_on experimental::as_single_t::as_default_on]
-
-[indexterm2 asio.indexterm.experimental__as_single_t.as_default_on..as_default_on..experimental::as_single_t] 
-Function helper to adapt an I/O object to use `as_single_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t experimental::as_single_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.experimental__as_single_t.as_default_on_t..as_default_on_t..experimental::as_single_t] 
-Type alias to adapt an I/O object to use `as_single_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify as_single_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. 
-     [hr]
-     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:as_single_t experimental::as_single_t::as_single_t]
-
-[indexterm2 asio.indexterm.experimental__as_single_t.as_single_t..as_single_t..experimental::as_single_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.experimental__as_single_t.as_single_t.overload1 as_single_t]``(
-      default_constructor_tag  = default_constructor_tag(),
-      CompletionToken token = CompletionToken());
-  ``  [''''&raquo;''' [link asio.reference.experimental__as_single_t.as_single_t.overload1 more...]]``
-
-
-Constructor. 
-
-
-  template<
-      typename T>
-  explicit constexpr ``[link asio.reference.experimental__as_single_t.as_single_t.overload2 as_single_t]``(
-      T && completion_token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__as_single_t.as_single_t.overload2 more...]]``
-
-
-[section:overload1 experimental::as_single_t::as_single_t (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr as_single_t(
-      default_constructor_tag  = default_constructor_tag(),
-      CompletionToken token = CompletionToken());
-
-
-This constructor is only valid if the underlying completion token is default constructible and move constructible. The underlying completion token is itself defaulted as an argument to allow it to capture a source location. 
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::as_single_t::as_single_t (2 of 2 overloads)]
-
-
-Constructor. 
-
-
-  template<
-      typename T>
-  constexpr as_single_t(
-      T && completion_token);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:token_ experimental::as_single_t::token_]
-
-[indexterm2 asio.indexterm.experimental__as_single_t.token_..token_..experimental::as_single_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__as_single_t__default_constructor_tag experimental::as_single_t::default_constructor_tag]
-
-[indexterm1 asio.indexterm.experimental__as_single_t__default_constructor_tag..experimental::as_single_t::default_constructor_tag]
-
-
-Tag type used to prevent the "default" constructor from being used for conversions. 
-
-
-  struct default_constructor_tag
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-[section:experimental__as_single_t__executor_with_default experimental::as_single_t::executor_with_default]
-
-[indexterm1 asio.indexterm.experimental__as_single_t__executor_with_default..experimental::as_single_t::executor_with_default]
-
-
-Adapts an executor to add the `as_single_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify as_single_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. 
-     [hr]
-     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[section:default_completion_token_type experimental::as_single_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.experimental__as_single_t__executor_with_default.default_completion_token_type..default_completion_token_type..experimental::as_single_t::executor_with_default] 
-Specify `as_single_t` as the default completion token type. 
-
-
-  typedef as_single_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use as_single_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__default_constructor_tag [*default_constructor_tag]]]
-    [Tag type used to prevent the "default" constructor from being used for conversions. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__as_single_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the as_single_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use as_single_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__as_single_t.as_single_t [*as_single_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__as_single_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.experimental__as_single_t `experimental::as_single_t`] class is used to indicate that any arguments to the completion handler should be combined and passed as a single argument. If there is already one argument, that argument is passed as-is. If there is more than argument, the arguments are first moved into a `std::tuple` and that tuple is then passed to the completion handler. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/as_single.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:executor_with_default experimental::as_single_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.experimental__as_single_t__executor_with_default.executor_with_default..executor_with_default..experimental::as_single_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  ``[link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default.overload1 executor_with_default]``(
-      const InnerExecutor & ex);
-  ``  [''''&raquo;''' [link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default.overload1 more...]]``
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default.overload2 executor_with_default]``(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__as_single_t__executor_with_default.executor_with_default.overload2 more...]]``
-
-
-[section:overload1 experimental::as_single_t::executor_with_default::executor_with_default (1 of 2 overloads)]
-
-
-Construct the adapted executor from the inner executor type. 
-
-
-  executor_with_default(
-      const InnerExecutor & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::as_single_t::executor_with_default::executor_with_default (2 of 2 overloads)]
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_with_default(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__awaitable_operators__operator_amp__amp_ experimental::awaitable_operators::operator&&]
-
-[indexterm1 asio.indexterm.experimental__awaitable_operators__operator_amp__amp_..experimental::awaitable_operators::operator&&]
-
-Wait for both operations to succeed. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< void, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload1 operator&&]``(
-      awaitable< void, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload1 more...]]``
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< U, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload2 operator&&]``(
-      awaitable< void, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload2 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< T, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload3 operator&&]``(
-      awaitable< T, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload3 more...]]``
-
-  template<
-      typename T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T, U >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload4 operator&&]``(
-      awaitable< T, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload4 more...]]``
-
-  template<
-      typename... T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T..., std::monostate >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload5 operator&&]``(
-      awaitable< std::tuple< T... >, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload5 more...]]``
-
-  template<
-      typename... T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T..., U >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload6 operator&&]``(
-      awaitable< std::tuple< T... >, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_amp__amp_.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/awaitable_operators.hpp]
-
-['Convenience header: ]None
-
-
-[section:overload1 experimental::awaitable_operators::operator&& (1 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< void, Executor > operator&&(
-      awaitable< void, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::awaitable_operators::operator&& (2 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< U, Executor > operator&&(
-      awaitable< void, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::awaitable_operators::operator&& (3 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< T, Executor > operator&&(
-      awaitable< T, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload4 experimental::awaitable_operators::operator&& (4 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T, U >, Executor > operator&&(
-      awaitable< T, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload5 experimental::awaitable_operators::operator&& (5 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename... T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T..., std::monostate >, Executor > operator&&(
-      awaitable< std::tuple< T... >, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload6 experimental::awaitable_operators::operator&& (6 of 6 overloads)]
-
-
-Wait for both operations to succeed. 
-
-
-  template<
-      typename... T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::tuple< T..., U >, Executor > operator&&(
-      awaitable< std::tuple< T... >, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations fails, the other is cancelled as the AND-condition can no longer be satisfied. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__awaitable_operators__operator_pipe__pipe_ experimental::awaitable_operators::operator||]
-
-[indexterm1 asio.indexterm.experimental__awaitable_operators__operator_pipe__pipe_..experimental::awaitable_operators::operator||]
-
-Wait for one operation to succeed. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< std::monostate, std::monostate >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload1 operator||]``(
-      awaitable< void, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload1 more...]]``
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< std::monostate, U >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload2 operator||]``(
-      awaitable< void, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload2 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T, std::monostate >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload3 operator||]``(
-      awaitable< T, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload3 more...]]``
-
-  template<
-      typename T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T, U >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload4 operator||]``(
-      awaitable< T, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload4 more...]]``
-
-  template<
-      typename... T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T..., std::monostate >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload5 operator||]``(
-      awaitable< std::variant< T... >, Executor > t,
-      awaitable< void, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload5 more...]]``
-
-  template<
-      typename... T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T..., U >, Executor > ``[link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload6 operator||]``(
-      awaitable< std::variant< T... >, Executor > t,
-      awaitable< U, Executor > u);
-  ``  [''''&raquo;''' [link asio.reference.experimental__awaitable_operators__operator_pipe__pipe_.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/awaitable_operators.hpp]
-
-['Convenience header: ]None
-
-
-[section:overload1 experimental::awaitable_operators::operator|| (1 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< std::monostate, std::monostate >, Executor > operator||(
-      awaitable< void, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::awaitable_operators::operator|| (2 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< std::monostate, U >, Executor > operator||(
-      awaitable< void, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::awaitable_operators::operator|| (3 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T, std::monostate >, Executor > operator||(
-      awaitable< T, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload4 experimental::awaitable_operators::operator|| (4 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T, U >, Executor > operator||(
-      awaitable< T, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload5 experimental::awaitable_operators::operator|| (5 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename... T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T..., std::monostate >, Executor > operator||(
-      awaitable< std::variant< T... >, Executor > t,
-      awaitable< void, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-
-[section:overload6 experimental::awaitable_operators::operator|| (6 of 6 overloads)]
-
-
-Wait for one operation to succeed. 
-
-
-  template<
-      typename... T,
-      typename U,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  awaitable< std::variant< T..., U >, Executor > operator||(
-      awaitable< std::variant< T... >, Executor > t,
-      awaitable< U, Executor > u);
-
-
-If one operations succeeds, the other is cancelled as the OR-condition is already satisfied. 
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__basic_channel experimental::basic_channel]
-
-[indexterm1 asio.indexterm.experimental__basic_channel..experimental::basic_channel]
-
-
-A channel for messages. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Traits,
-      typename... Signatures>
-  class basic_channel
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel__rebind_executor [*rebind_executor]]]
-    [Rebinds the channel type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel.executor_type [*executor_type]]]
-    [The type of the executor associated with the channel. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel.traits_type [*traits_type]]]
-    [The traits type associated with the channel. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__basic_channel.async_receive [*async_receive]]]
-    [Asynchronously receive a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.async_send [*async_send]]]
-    [Asynchronously send a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.basic_channel [*basic_channel]] [constructor]]
-    [Construct a basic_channel. 
-     [hr]
-     Construct and open a basic_channel. 
-     [hr]
-     Move-construct a basic_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.cancel [*cancel]]]
-    [Cancel all asynchronous operations waiting on the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.capacity [*capacity]]]
-    [Get the capacity of the channel's buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.close [*close]]]
-    [Close the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.is_open [*is_open]]]
-    [Determine whether the channel is open. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.operator_eq_ [*operator=]]]
-    [Move-assign a basic_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.ready [*ready]]]
-    [Determine whether a message can be received without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.reset [*reset]]]
-    [Reset the channel to its initial state. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_receive [*try_receive]]]
-    [Try to receive a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send [*try_send]]]
-    [Try to send a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_n [*try_send_n]]]
-    [Try to send a number of messages without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_n_via_dispatch [*try_send_n_via_dispatch]]]
-    [Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_via_dispatch [*try_send_via_dispatch]]]
-    [Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel._basic_channel [*~basic_channel]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The [link asio.reference.experimental__basic_channel `experimental::basic_channel`] class template is used for sending messages between different parts of the same application. A ['message] is defined as a collection of arguments to be passed to a completion handler, and the set of messages supported by a channel is specified by its `Traits` and `Signatures...` template parameters. Messages may be sent and received using asynchronous or non-blocking synchronous operations.
-
-Unless customising the traits, applications will typically use the `experimental::channel` alias template. For example: 
-
-  void send_loop(int i, steady_timer& timer,
-      channel<void(error_code, int)>& ch)
-  {
-    if (i < 10)
-    {
-      timer.expires_after(chrono::seconds(1));
-      timer.async_wait(
-          [i, &timer, &ch](error_code error)
-          {
-            if (!error)
-            {
-              ch.async_send(error_code(), i,
-                  [i, &timer, &ch](error_code error)
-                  {
-                    if (!error)
-                    {
-                      send_loop(i + 1, timer, ch);
-                    }
-                  });
-            }
-          });
-    }
-    else
-    {
-      ch.close();
-    }
-  }
-
-  void receive_loop(channel<void(error_code, int)>& ch)
-  {
-    ch.async_receive(
-        [&ch](error_code error, int i)
-        {
-          if (!error)
-          {
-            std::cout << "Received " << i << "\n";
-            receive_loop(ch);
-          }
-        });
-  } 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-The [link asio.reference.experimental__basic_channel `experimental::basic_channel`] class template is not thread-safe, and would typically be used for passing messages between application code that runs on the same thread or in the same strand. Consider using [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`], and its alias template `experimental::concurrent_channel`, to pass messages between code running in different threads. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_channel.hpp]
-
-['Convenience header: ]None
-
-
-[section:async_receive experimental::basic_channel::async_receive]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.async_receive..async_receive..experimental::basic_channel] 
-Asynchronously receive a message. 
-
-
-  template<
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
-
-
-
-[heading Completion Signature]
-  
-As determined by the `Signatures...` template parameter and the channel traits. 
-
-
-
-
-[endsect]
-
-
-
-[section:async_send experimental::basic_channel::async_send]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.async_send..async_send..experimental::basic_channel] 
-Asynchronously send a message. 
-
-
-  template<
-      typename... Args,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      Args &&... args,
-      CompletionToken && token);
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[section:basic_channel experimental::basic_channel::basic_channel]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.basic_channel..basic_channel..experimental::basic_channel] 
-Construct a [link asio.reference.experimental__basic_channel `experimental::basic_channel`]. 
-
-
-  ``[link asio.reference.experimental__basic_channel.basic_channel.overload1 basic_channel]``(
-      const executor_type & ex,
-      std::size_t max_buffer_size = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.basic_channel.overload1 more...]]``
-
-
-Construct and open a [link asio.reference.experimental__basic_channel `experimental::basic_channel`]. 
-
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.experimental__basic_channel.basic_channel.overload2 basic_channel]``(
-      ExecutionContext & context,
-      std::size_t max_buffer_size = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.basic_channel.overload2 more...]]``
-
-
-Move-construct a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  ``[link asio.reference.experimental__basic_channel.basic_channel.overload3 basic_channel]``(
-      basic_channel && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.basic_channel.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.experimental__basic_channel.basic_channel.overload4 basic_channel]``(
-      basic_channel< Executor1, Traits, Signatures... > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.basic_channel.overload4 more...]]``
-
-
-[section:overload1 experimental::basic_channel::basic_channel (1 of 4 overloads)]
-
-
-Construct a [link asio.reference.experimental__basic_channel `experimental::basic_channel`]. 
-
-
-  basic_channel(
-      const executor_type & ex,
-      std::size_t max_buffer_size = 0);
-
-
-This constructor creates and channel.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the channel will use, by default, to dispatch handlers for any asynchronous operations performed on the channel.]]
-
-[[max_buffer_size][The maximum number of messages that may be buffered in the channel. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::basic_channel::basic_channel (2 of 4 overloads)]
-
-
-Construct and open a [link asio.reference.experimental__basic_channel `experimental::basic_channel`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_channel(
-      ExecutionContext & context,
-      std::size_t max_buffer_size = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a channel.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the channel will use, by default, to dispatch handlers for any asynchronous operations performed on the channel.]]
-
-[[max_buffer_size][The maximum number of messages that may be buffered in the channel. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::basic_channel::basic_channel (3 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  basic_channel(
-      basic_channel && other);
-
-
-This constructor moves a channel from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_channel `experimental::basic_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 experimental::basic_channel::basic_channel (4 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_channel(
-      basic_channel< Executor1, Traits, Signatures... > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a channel from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_channel `experimental::basic_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancel experimental::basic_channel::cancel]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.cancel..cancel..experimental::basic_channel] 
-Cancel all asynchronous operations waiting on the channel. 
-
-
-  void cancel();
-
-
-All outstanding send operations will complete with the error `asio::experimental::error::channel_cancelled`. Outstanding receive operations complete with the result as determined by the channel traits. 
-
-
-[endsect]
-
-
-
-[section:capacity experimental::basic_channel::capacity]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.capacity..capacity..experimental::basic_channel] 
-Get the capacity of the channel's buffer. 
-
-
-  std::size_t capacity();
-
-
-
-[endsect]
-
-
-
-[section:close experimental::basic_channel::close]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.close..close..experimental::basic_channel] 
-Close the channel. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:executor_type experimental::basic_channel::executor_type]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.executor_type..executor_type..experimental::basic_channel] 
-The type of the executor associated with the channel. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:get_executor experimental::basic_channel::get_executor]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.get_executor..get_executor..experimental::basic_channel] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open experimental::basic_channel::is_open]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.is_open..is_open..experimental::basic_channel] 
-Determine whether the channel is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ experimental::basic_channel::operator=]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.operator_eq_..operator=..experimental::basic_channel] 
-Move-assign a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  basic_channel & ``[link asio.reference.experimental__basic_channel.operator_eq_.overload1 operator=]``(
-      basic_channel && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.operator_eq_.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_channel & > ``[link asio.reference.experimental__basic_channel.operator_eq_.overload2 operator=]``(
-      basic_channel< Executor1, Traits, Signatures... > && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_channel.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 experimental::basic_channel::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  basic_channel & operator=(
-      basic_channel && other);
-
-
-This assignment operator moves a channel from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_channel `experimental::basic_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::basic_channel::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.experimental__basic_channel `experimental::basic_channel`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_channel & > operator=(
-      basic_channel< Executor1, Traits, Signatures... > && other);
-
-
-This assignment operator moves a channel from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_channel `experimental::basic_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:ready experimental::basic_channel::ready]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.ready..ready..experimental::basic_channel] 
-Determine whether a message can be received without blocking. 
-
-
-  bool ready() const;
-
-
-
-[endsect]
-
-
-
-[section:reset experimental::basic_channel::reset]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.reset..reset..experimental::basic_channel] 
-Reset the channel to its initial state. 
-
-
-  void reset();
-
-
-
-[endsect]
-
-
-
-[section:traits_type experimental::basic_channel::traits_type]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.traits_type..traits_type..experimental::basic_channel] 
-The traits type associated with the channel. 
-
-
-  typedef Traits::template rebind< Signatures... >::other traits_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:try_receive experimental::basic_channel::try_receive]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.try_receive..try_receive..experimental::basic_channel] 
-Try to receive a message without blocking. 
-
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``>
-  bool try_receive(
-      Handler && handler);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send experimental::basic_channel::try_send]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.try_send..try_send..experimental::basic_channel] 
-Try to send a message without blocking. 
-
-
-  template<
-      typename... Args>
-  bool try_send(
-      Args &&... args);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_n experimental::basic_channel::try_send_n]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.try_send_n..try_send_n..experimental::basic_channel] 
-Try to send a number of messages without blocking. 
-
-
-  template<
-      typename... Args>
-  std::size_t try_send_n(
-      std::size_t count,
-      Args &&... args);
-
-
-
-[heading Return Value]
-      
-The number of messages that were sent. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_n_via_dispatch experimental::basic_channel::try_send_n_via_dispatch]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.try_send_n_via_dispatch..try_send_n_via_dispatch..experimental::basic_channel] 
-Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. 
-
-
-  template<
-      typename... Args>
-  std::size_t try_send_n_via_dispatch(
-      std::size_t count,
-      Args &&... args);
-
-
-The receive operations' completion handlers may be called from inside this function.
-
-
-[heading Return Value]
-      
-The number of messages that were sent. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_via_dispatch experimental::basic_channel::try_send_via_dispatch]
-
-[indexterm2 asio.indexterm.experimental__basic_channel.try_send_via_dispatch..try_send_via_dispatch..experimental::basic_channel] 
-Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. 
-
-
-  template<
-      typename... Args>
-  bool try_send_via_dispatch(
-      Args &&... args);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-The receive operation's completion handler may be called from inside this function.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:_basic_channel experimental::basic_channel::~basic_channel]
-
-[indexterm2 asio.indexterm.experimental__basic_channel._basic_channel..~basic_channel..experimental::basic_channel] 
-Destructor. 
-
-
-  ~basic_channel();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__basic_channel__rebind_executor experimental::basic_channel::rebind_executor]
-
-[indexterm1 asio.indexterm.experimental__basic_channel__rebind_executor..experimental::basic_channel::rebind_executor]
-
-
-Rebinds the channel type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel__rebind_executor.other [*other]]]
-    [The channel type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_channel.hpp]
-
-['Convenience header: ]None
-
-
-[section:other experimental::basic_channel::rebind_executor::other]
-
-[indexterm2 asio.indexterm.experimental__basic_channel__rebind_executor.other..other..experimental::basic_channel::rebind_executor] 
-The channel type when rebound to the specified executor. 
-
-
-  typedef basic_channel< Executor1, Traits, Signatures... > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel__rebind_executor [*rebind_executor]]]
-    [Rebinds the channel type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel.executor_type [*executor_type]]]
-    [The type of the executor associated with the channel. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_channel.traits_type [*traits_type]]]
-    [The traits type associated with the channel. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__basic_channel.async_receive [*async_receive]]]
-    [Asynchronously receive a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.async_send [*async_send]]]
-    [Asynchronously send a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.basic_channel [*basic_channel]] [constructor]]
-    [Construct a basic_channel. 
-     [hr]
-     Construct and open a basic_channel. 
-     [hr]
-     Move-construct a basic_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.cancel [*cancel]]]
-    [Cancel all asynchronous operations waiting on the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.capacity [*capacity]]]
-    [Get the capacity of the channel's buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.close [*close]]]
-    [Close the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.is_open [*is_open]]]
-    [Determine whether the channel is open. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.operator_eq_ [*operator=]]]
-    [Move-assign a basic_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.ready [*ready]]]
-    [Determine whether a message can be received without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.reset [*reset]]]
-    [Reset the channel to its initial state. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_receive [*try_receive]]]
-    [Try to receive a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send [*try_send]]]
-    [Try to send a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_n [*try_send_n]]]
-    [Try to send a number of messages without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_n_via_dispatch [*try_send_n_via_dispatch]]]
-    [Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel.try_send_via_dispatch [*try_send_via_dispatch]]]
-    [Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_channel._basic_channel [*~basic_channel]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The [link asio.reference.experimental__basic_channel `experimental::basic_channel`] class template is used for sending messages between different parts of the same application. A ['message] is defined as a collection of arguments to be passed to a completion handler, and the set of messages supported by a channel is specified by its `Traits` and `Signatures...` template parameters. Messages may be sent and received using asynchronous or non-blocking synchronous operations.
-
-Unless customising the traits, applications will typically use the `experimental::channel` alias template. For example: 
-
-  void send_loop(int i, steady_timer& timer,
-      channel<void(error_code, int)>& ch)
-  {
-    if (i < 10)
-    {
-      timer.expires_after(chrono::seconds(1));
-      timer.async_wait(
-          [i, &timer, &ch](error_code error)
-          {
-            if (!error)
-            {
-              ch.async_send(error_code(), i,
-                  [i, &timer, &ch](error_code error)
-                  {
-                    if (!error)
-                    {
-                      send_loop(i + 1, timer, ch);
-                    }
-                  });
-            }
-          });
-    }
-    else
-    {
-      ch.close();
-    }
-  }
-
-  void receive_loop(channel<void(error_code, int)>& ch)
-  {
-    ch.async_receive(
-        [&ch](error_code error, int i)
-        {
-          if (!error)
-          {
-            std::cout << "Received " << i << "\n";
-            receive_loop(ch);
-          }
-        });
-  } 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-The [link asio.reference.experimental__basic_channel `experimental::basic_channel`] class template is not thread-safe, and would typically be used for passing messages between application code that runs on the same thread or in the same strand. Consider using [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`], and its alias template `experimental::concurrent_channel`, to pass messages between code running in different threads. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__basic_concurrent_channel experimental::basic_concurrent_channel]
-
-[indexterm1 asio.indexterm.experimental__basic_concurrent_channel..experimental::basic_concurrent_channel]
-
-
-A channel for messages. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Traits,
-      typename... Signatures>
-  class basic_concurrent_channel
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel__rebind_executor [*rebind_executor]]]
-    [Rebinds the channel type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel.executor_type [*executor_type]]]
-    [The type of the executor associated with the channel. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel.traits_type [*traits_type]]]
-    [The traits type associated with the channel. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.async_receive [*async_receive]]]
-    [Asynchronously receive a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.async_send [*async_send]]]
-    [Asynchronously send a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel [*basic_concurrent_channel]] [constructor]]
-    [Construct a basic_concurrent_channel. 
-     [hr]
-     Construct and open a basic_concurrent_channel. 
-     [hr]
-     Move-construct a basic_concurrent_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.cancel [*cancel]]]
-    [Cancel all asynchronous operations waiting on the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.capacity [*capacity]]]
-    [Get the capacity of the channel's buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.close [*close]]]
-    [Close the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.is_open [*is_open]]]
-    [Determine whether the channel is open. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.operator_eq_ [*operator=]]]
-    [Move-assign a basic_concurrent_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.ready [*ready]]]
-    [Determine whether a message can be received without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.reset [*reset]]]
-    [Reset the channel to its initial state. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_receive [*try_receive]]]
-    [Try to receive a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send [*try_send]]]
-    [Try to send a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_n [*try_send_n]]]
-    [Try to send a number of messages without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_n_via_dispatch [*try_send_n_via_dispatch]]]
-    [Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_via_dispatch [*try_send_via_dispatch]]]
-    [Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel._basic_concurrent_channel [*~basic_concurrent_channel]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] class template is used for sending messages between different parts of the same application. A ['message] is defined as a collection of arguments to be passed to a completion handler, and the set of messages supported by a channel is specified by its `Traits` and `Signatures...` template parameters. Messages may be sent and received using asynchronous or non-blocking synchronous operations.
-
-Unless customising the traits, applications will typically use the `experimental::concurrent_channel` alias template. For example: 
-
-  void send_loop(int i, steady_timer& timer,
-      concurrent_channel<void(error_code, int)>& ch)
-  {
-    if (i < 10)
-    {
-      timer.expires_after(chrono::seconds(1));
-      timer.async_wait(
-          [i, &timer, &ch](error_code error)
-          {
-            if (!error)
-            {
-              ch.async_send(error_code(), i,
-                  [i, &timer, &ch](error_code error)
-                  {
-                    if (!error)
-                    {
-                      send_loop(i + 1, timer, ch);
-                    }
-                  });
-            }
-          });
-    }
-    else
-    {
-      ch.close();
-    }
-  }
-
-  void receive_loop(concurent_channel<void(error_code, int)>& ch)
-  {
-    ch.async_receive(
-        [&ch](error_code error, int i)
-        {
-          if (!error)
-          {
-            std::cout << "Received " << i << "\n";
-            receive_loop(ch);
-          }
-        });
-  } 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-The [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] class template is thread-safe, and would typically be used for passing messages between application code that run on different threads. Consider using [link asio.reference.experimental__basic_channel `experimental::basic_channel`], and its alias template `experimental::channel`, to pass messages between code running in a single thread or on the same strand. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[section:async_receive experimental::basic_concurrent_channel::async_receive]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.async_receive..async_receive..experimental::basic_concurrent_channel] 
-Asynchronously receive a message. 
-
-
-  template<
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_receive(
-      CompletionToken && token = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``);
-
-
-
-[endsect]
-
-
-
-[section:async_send experimental::basic_concurrent_channel::async_send]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.async_send..async_send..experimental::basic_concurrent_channel] 
-Asynchronously send a message. 
-
-
-  template<
-      typename... Args,
-      typename CompletionToken = ``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_send(
-      Args &&... args,
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-[section:basic_concurrent_channel experimental::basic_concurrent_channel::basic_concurrent_channel]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.basic_concurrent_channel..basic_concurrent_channel..experimental::basic_concurrent_channel] 
-Construct a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`]. 
-
-
-  ``[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload1 basic_concurrent_channel]``(
-      const executor_type & ex,
-      std::size_t max_buffer_size = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload1 more...]]``
-
-
-Construct and open a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`]. 
-
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload2 basic_concurrent_channel]``(
-      ExecutionContext & context,
-      std::size_t max_buffer_size = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload2 more...]]``
-
-
-Move-construct a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  ``[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload3 basic_concurrent_channel]``(
-      basic_concurrent_channel && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload4 basic_concurrent_channel]``(
-      basic_concurrent_channel< Executor1, Traits, Signatures... > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel.overload4 more...]]``
-
-
-[section:overload1 experimental::basic_concurrent_channel::basic_concurrent_channel (1 of 4 overloads)]
-
-
-Construct a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`]. 
-
-
-  basic_concurrent_channel(
-      const executor_type & ex,
-      std::size_t max_buffer_size = 0);
-
-
-This constructor creates and channel.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the channel will use, by default, to dispatch handlers for any asynchronous operations performed on the channel.]]
-
-[[max_buffer_size][The maximum number of messages that may be buffered in the channel. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::basic_concurrent_channel::basic_concurrent_channel (2 of 4 overloads)]
-
-
-Construct and open a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`]. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_concurrent_channel(
-      ExecutionContext & context,
-      std::size_t max_buffer_size = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates and opens a channel.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the channel will use, by default, to dispatch handlers for any asynchronous operations performed on the channel.]]
-
-[[max_buffer_size][The maximum number of messages that may be buffered in the channel. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::basic_concurrent_channel::basic_concurrent_channel (3 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  basic_concurrent_channel(
-      basic_concurrent_channel && other);
-
-
-This constructor moves a channel from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_concurrent_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 experimental::basic_concurrent_channel::basic_concurrent_channel (4 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_concurrent_channel(
-      basic_concurrent_channel< Executor1, Traits, Signatures... > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a channel from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_concurrent_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancel experimental::basic_concurrent_channel::cancel]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.cancel..cancel..experimental::basic_concurrent_channel] 
-Cancel all asynchronous operations waiting on the channel. 
-
-
-  void cancel();
-
-
-All outstanding send operations will complete with the error `asio::experimental::error::channel_cancelled`. Outstanding receive operations complete with the result as determined by the channel traits. 
-
-
-[endsect]
-
-
-
-[section:capacity experimental::basic_concurrent_channel::capacity]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.capacity..capacity..experimental::basic_concurrent_channel] 
-Get the capacity of the channel's buffer. 
-
-
-  std::size_t capacity();
-
-
-
-[endsect]
-
-
-
-[section:close experimental::basic_concurrent_channel::close]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.close..close..experimental::basic_concurrent_channel] 
-Close the channel. 
-
-
-  void close();
-
-
-
-[endsect]
-
-
-
-[section:executor_type experimental::basic_concurrent_channel::executor_type]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.executor_type..executor_type..experimental::basic_concurrent_channel] 
-The type of the executor associated with the channel. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:get_executor experimental::basic_concurrent_channel::get_executor]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.get_executor..get_executor..experimental::basic_concurrent_channel] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open experimental::basic_concurrent_channel::is_open]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.is_open..is_open..experimental::basic_concurrent_channel] 
-Determine whether the channel is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ experimental::basic_concurrent_channel::operator=]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.operator_eq_..operator=..experimental::basic_concurrent_channel] 
-Move-assign a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  basic_concurrent_channel & ``[link asio.reference.experimental__basic_concurrent_channel.operator_eq_.overload1 operator=]``(
-      basic_concurrent_channel && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.operator_eq_.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_concurrent_channel & > ``[link asio.reference.experimental__basic_concurrent_channel.operator_eq_.overload2 operator=]``(
-      basic_concurrent_channel< Executor1, Traits, Signatures... > && other);
-  ``  [''''&raquo;''' [link asio.reference.experimental__basic_concurrent_channel.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 experimental::basic_concurrent_channel::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  basic_concurrent_channel & operator=(
-      basic_concurrent_channel && other);
-
-
-This assignment operator moves a channel from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_concurrent_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::basic_concurrent_channel::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_concurrent_channel & > operator=(
-      basic_concurrent_channel< Executor1, Traits, Signatures... > && other);
-
-
-This assignment operator moves a channel from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_concurrent_channel(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:ready experimental::basic_concurrent_channel::ready]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.ready..ready..experimental::basic_concurrent_channel] 
-Determine whether a message can be received without blocking. 
-
-
-  bool ready() const;
-
-
-
-[endsect]
-
-
-
-[section:reset experimental::basic_concurrent_channel::reset]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.reset..reset..experimental::basic_concurrent_channel] 
-Reset the channel to its initial state. 
-
-
-  void reset();
-
-
-
-[endsect]
-
-
-
-[section:traits_type experimental::basic_concurrent_channel::traits_type]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.traits_type..traits_type..experimental::basic_concurrent_channel] 
-The traits type associated with the channel. 
-
-
-  typedef Traits::template rebind< Signatures... >::other traits_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:try_receive experimental::basic_concurrent_channel::try_receive]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.try_receive..try_receive..experimental::basic_concurrent_channel] 
-Try to receive a message without blocking. 
-
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``>
-  bool try_receive(
-      Handler && handler);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send experimental::basic_concurrent_channel::try_send]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.try_send..try_send..experimental::basic_concurrent_channel] 
-Try to send a message without blocking. 
-
-
-  template<
-      typename... Args>
-  bool try_send(
-      Args &&... args);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_n experimental::basic_concurrent_channel::try_send_n]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.try_send_n..try_send_n..experimental::basic_concurrent_channel] 
-Try to send a number of messages without blocking. 
-
-
-  template<
-      typename... Args>
-  std::size_t try_send_n(
-      std::size_t count,
-      Args &&... args);
-
-
-
-[heading Return Value]
-      
-The number of messages that were sent. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_n_via_dispatch experimental::basic_concurrent_channel::try_send_n_via_dispatch]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.try_send_n_via_dispatch..try_send_n_via_dispatch..experimental::basic_concurrent_channel] 
-Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. 
-
-
-  template<
-      typename... Args>
-  std::size_t try_send_n_via_dispatch(
-      std::size_t count,
-      Args &&... args);
-
-
-The receive operations' completion handlers may be called from inside this function.
-
-
-[heading Return Value]
-      
-The number of messages that were sent. 
-
-
-
-
-[endsect]
-
-
-
-[section:try_send_via_dispatch experimental::basic_concurrent_channel::try_send_via_dispatch]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel.try_send_via_dispatch..try_send_via_dispatch..experimental::basic_concurrent_channel] 
-Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. 
-
-
-  template<
-      typename... Args>
-  bool try_send_via_dispatch(
-      Args &&... args);
-
-
-Fails if the buffer is full and there are no waiting receive operations.
-
-The receive operation's completion handler may be called from inside this function.
-
-
-[heading Return Value]
-      
-`true` on success, `false` on failure. 
-
-
-
-
-[endsect]
-
-
-
-[section:_basic_concurrent_channel experimental::basic_concurrent_channel::~basic_concurrent_channel]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel._basic_concurrent_channel..~basic_concurrent_channel..experimental::basic_concurrent_channel] 
-Destructor. 
-
-
-  ~basic_concurrent_channel();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__basic_concurrent_channel__rebind_executor experimental::basic_concurrent_channel::rebind_executor]
-
-[indexterm1 asio.indexterm.experimental__basic_concurrent_channel__rebind_executor..experimental::basic_concurrent_channel::rebind_executor]
-
-
-Rebinds the channel type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel__rebind_executor.other [*other]]]
-    [The channel type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[section:other experimental::basic_concurrent_channel::rebind_executor::other]
-
-[indexterm2 asio.indexterm.experimental__basic_concurrent_channel__rebind_executor.other..other..experimental::basic_concurrent_channel::rebind_executor] 
-The channel type when rebound to the specified executor. 
-
-
-  typedef basic_concurrent_channel< Executor1, Traits, Signatures... > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel__rebind_executor [*rebind_executor]]]
-    [Rebinds the channel type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel.executor_type [*executor_type]]]
-    [The type of the executor associated with the channel. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__basic_concurrent_channel.traits_type [*traits_type]]]
-    [The traits type associated with the channel. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.async_receive [*async_receive]]]
-    [Asynchronously receive a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.async_send [*async_send]]]
-    [Asynchronously send a message. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.basic_concurrent_channel [*basic_concurrent_channel]] [constructor]]
-    [Construct a basic_concurrent_channel. 
-     [hr]
-     Construct and open a basic_concurrent_channel. 
-     [hr]
-     Move-construct a basic_concurrent_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.cancel [*cancel]]]
-    [Cancel all asynchronous operations waiting on the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.capacity [*capacity]]]
-    [Get the capacity of the channel's buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.close [*close]]]
-    [Close the channel. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.is_open [*is_open]]]
-    [Determine whether the channel is open. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.operator_eq_ [*operator=]]]
-    [Move-assign a basic_concurrent_channel from another. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.ready [*ready]]]
-    [Determine whether a message can be received without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.reset [*reset]]]
-    [Reset the channel to its initial state. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_receive [*try_receive]]]
-    [Try to receive a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send [*try_send]]]
-    [Try to send a message without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_n [*try_send_n]]]
-    [Try to send a number of messages without blocking. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_n_via_dispatch [*try_send_n_via_dispatch]]]
-    [Try to send a number of messages without blocking, using dispatch semantics to call the receive operations' completion handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel.try_send_via_dispatch [*try_send_via_dispatch]]]
-    [Try to send a message without blocking, using dispatch semantics to call the receive operation's completion handler. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__basic_concurrent_channel._basic_concurrent_channel [*~basic_concurrent_channel]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] class template is used for sending messages between different parts of the same application. A ['message] is defined as a collection of arguments to be passed to a completion handler, and the set of messages supported by a channel is specified by its `Traits` and `Signatures...` template parameters. Messages may be sent and received using asynchronous or non-blocking synchronous operations.
-
-Unless customising the traits, applications will typically use the `experimental::concurrent_channel` alias template. For example: 
-
-  void send_loop(int i, steady_timer& timer,
-      concurrent_channel<void(error_code, int)>& ch)
-  {
-    if (i < 10)
-    {
-      timer.expires_after(chrono::seconds(1));
-      timer.async_wait(
-          [i, &timer, &ch](error_code error)
-          {
-            if (!error)
-            {
-              ch.async_send(error_code(), i,
-                  [i, &timer, &ch](error_code error)
-                  {
-                    if (!error)
-                    {
-                      send_loop(i + 1, timer, ch);
-                    }
-                  });
-            }
-          });
-    }
-    else
-    {
-      ch.close();
-    }
-  }
-
-  void receive_loop(concurent_channel<void(error_code, int)>& ch)
-  {
-    ch.async_receive(
-        [&ch](error_code error, int i)
-        {
-          if (!error)
-          {
-            std::cout << "Received " << i << "\n";
-            receive_loop(ch);
-          }
-        });
-  } 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-The [link asio.reference.experimental__basic_concurrent_channel `experimental::basic_concurrent_channel`] class template is thread-safe, and would typically be used for passing messages between application code that run on different threads. Consider using [link asio.reference.experimental__basic_channel `experimental::basic_channel`], and its alias template `experimental::channel`, to pass messages between code running in a single thread or on the same strand. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/basic_concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:experimental__channel experimental::channel]
-
-[indexterm1 asio.indexterm.experimental__channel..experimental::channel]
-
-Template type alias for common use of channel. 
-
-
-  typedef typename detail::channel_type< ExecutorOrSignature >::template inner< Signatures... >::type channel;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__detail__channel_type__inner [*inner]]]
-    []
-  
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__channel_traits experimental::channel_traits]
-
-[indexterm1 asio.indexterm.experimental__channel_traits..experimental::channel_traits]
-
-
-
-  template<
-      typename... Signatures>
-  struct channel_traits
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits__container [*container]]]
-    [Determine the container for the specified elements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits__rebind [*rebind]]]
-    [Rebind the traits to a new set of signatures. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits.receive_cancelled_signature [*receive_cancelled_signature]]]
-    [The signature of a channel cancellation notification. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits.receive_closed_signature [*receive_closed_signature]]]
-    [The signature of a channel closed notification. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__channel_traits.invoke_receive_cancelled [*invoke_receive_cancelled]] [static]]
-    [Invoke the specified handler with a cancellation notification. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__channel_traits.invoke_receive_closed [*invoke_receive_closed]] [static]]
-    [Invoke the specified handler with a closed notification. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[section:invoke_receive_cancelled experimental::channel_traits::invoke_receive_cancelled]
-
-[indexterm2 asio.indexterm.experimental__channel_traits.invoke_receive_cancelled..invoke_receive_cancelled..experimental::channel_traits] 
-Invoke the specified handler with a cancellation notification. 
-
-
-  template<
-      typename F>
-  static void invoke_receive_cancelled(
-      F f);
-
-
-
-[endsect]
-
-
-
-[section:invoke_receive_closed experimental::channel_traits::invoke_receive_closed]
-
-[indexterm2 asio.indexterm.experimental__channel_traits.invoke_receive_closed..invoke_receive_closed..experimental::channel_traits] 
-Invoke the specified handler with a closed notification. 
-
-
-  template<
-      typename F>
-  static void invoke_receive_closed(
-      F f);
-
-
-
-[endsect]
-
-
-
-[section:receive_cancelled_signature experimental::channel_traits::receive_cancelled_signature]
-
-[indexterm2 asio.indexterm.experimental__channel_traits.receive_cancelled_signature..receive_cancelled_signature..experimental::channel_traits] 
-The signature of a channel cancellation notification. 
-
-
-  typedef void receive_cancelled_signature;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:receive_closed_signature experimental::channel_traits::receive_closed_signature]
-
-[indexterm2 asio.indexterm.experimental__channel_traits.receive_closed_signature..receive_closed_signature..experimental::channel_traits] 
-The signature of a channel closed notification. 
-
-
-  typedef void receive_closed_signature;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__channel_traits__container experimental::channel_traits::container]
-
-[indexterm1 asio.indexterm.experimental__channel_traits__container..experimental::channel_traits::container]
-
-
-Determine the container for the specified elements. 
-
-
-  template<
-      typename Element>
-  struct container
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits__container.type [*type]]]
-    []
-  
-  ]
-
-]
-
-This nested structure must have a single nested type `other` that aliases a container type for the specified element type. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[section:type experimental::channel_traits::container::type]
-
-[indexterm2 asio.indexterm.experimental__channel_traits__container.type..type..experimental::channel_traits::container] 
-
-  typedef user_defined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__channel_traits__rebind experimental::channel_traits::rebind]
-
-[indexterm1 asio.indexterm.experimental__channel_traits__rebind..experimental::channel_traits::rebind]
-
-
-Rebind the traits to a new set of signatures. 
-
-
-  template<
-      typename... NewSignatures>
-  struct rebind
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__channel_traits__rebind.other [*other]]]
-    []
-  
-  ]
-
-]
-
-This nested structure must have a single nested type `other` that aliases a traits type with the specified set of signatures. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[section:other experimental::channel_traits::rebind::other]
-
-[indexterm2 asio.indexterm.experimental__channel_traits__rebind.other..other..experimental::channel_traits::rebind] 
-
-  typedef user_defined other;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__co_spawn experimental::co_spawn]
-
-[indexterm1 asio.indexterm.experimental__co_spawn..experimental::co_spawn]
-
-Spawn a resumable coroutine. 
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload1 co_spawn]``(
-      coro< void, T, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload1 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload2 co_spawn]``(
-      coro< void(), T, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload2 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload3 co_spawn]``(
-      coro< void() noexcept, T, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload4 co_spawn]``(
-      coro< void, void, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload5 co_spawn]``(
-      coro< void(), void, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__co_spawn.overload6 co_spawn]``(
-      coro< void() noexcept, void, Executor > c,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__co_spawn.overload6 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/co_spawn.hpp]
-
-['Convenience header: ]None
-
-
-[section:overload1 experimental::co_spawn (1 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void, T, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::co_spawn (2 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void(), T, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::co_spawn (3 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void() noexcept, T, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 experimental::co_spawn (4 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void, void, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 experimental::co_spawn (5 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void(), void, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 experimental::co_spawn (6 of 6 overloads)]
-
-
-Spawn a resumable coroutine. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` co_spawn(
-      coro< void() noexcept, void, Executor > c,
-      CompletionToken && token);
-
-
-This function spawns the coroutine for execution on its executor. It binds the lifetime of the coroutine to the executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[c][The coroutine]]
-
-[[token][The completion token]]
-
-]
-
-
-[heading Return Value]
-      
-Implementation defined 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:experimental__concurrent_channel experimental::concurrent_channel]
-
-[indexterm1 asio.indexterm.experimental__concurrent_channel..experimental::concurrent_channel]
-
-Template type alias for common use of channel. 
-
-
-  typedef typename detail::concurrent_channel_type< ExecutorOrSignature >::template inner< Signatures... >::type concurrent_channel;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__detail__concurrent_channel_type__inner [*inner]]]
-    []
-  
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/concurrent_channel.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__coro experimental::coro]
-
-[indexterm1 asio.indexterm.experimental__coro..experimental::coro]
-
-
-The main type of a resumable coroutine. 
-
-
-  template<
-      typename Yield = void,
-      typename Return = void,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor,
-      typename Allocator = std::allocator<void>>
-  struct coro
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__coro.allocator_type [*allocator_type]]]
-    [The allocator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.completion_handler [*completion_handler]]]
-    [Completion handler type used by async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.error_type [*error_type]]]
-    [The error type of the coroutine. Void for noexcept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.executor_type [*executor_type]]]
-    [The executor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.input_type [*input_type]]]
-    [The value that can be passed into a symmetrical cororoutine. void if asymmetrical. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.promise_type [*promise_type]]]
-    [The internal promise-type of the coroutine. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.result_type [*result_type]]]
-    [The type received by a co_await or async_resume. Its a combination of yield and return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.return_type [*return_type]]]
-    [The type that can be passed out through a co_return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.signature_type [*signature_type]]]
-    [The signature used by the async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.traits [*traits]]]
-    [The traits of the coroutine. See asio::experimental::coro_traits for details. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.yield_type [*yield_type]]]
-    [The type that can be passed out through a co_yield. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.async_resume [*async_resume]]]
-    [Resume the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.coro [*coro]] [constructor]]
-    [The default constructor, gives an invalid coroutine. 
-     [hr]
-     Move constructor. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_allocator [*get_allocator]]]
-    [Get the used allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_executor [*get_executor]]]
-    [Get the used executor. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.is_open [*is_open]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_bool [*operator bool]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_co_await [*operator co_await]]]
-    [Operator used for coroutines without input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_lp__rp_ [*operator()]]]
-    [Operator used for coroutines with input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_eq_ [*operator=]]]
-    [Move assignment. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro._coro [*~coro]] [destructor]]
-    [Destructor. Destroys the coroutine, if it holds a valid one. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.is_noexcept [*is_noexcept]] [static]]
-    [Whether or not the coroutine is noexcept. ]
-  ]
-
-]
-
-Template parameter `Yield` specifies type or signature used by co\_yield, `Return` specifies the type used for co\_return, and `Executor` specifies the underlying executor type. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[section:allocator_type experimental::coro::allocator_type]
-
-[indexterm2 asio.indexterm.experimental__coro.allocator_type..allocator_type..experimental::coro] 
-The allocator type. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:async_resume experimental::coro::async_resume]
-
-[indexterm2 asio.indexterm.experimental__coro.async_resume..async_resume..experimental::coro] 
-Resume the coroutine. 
-
-
-  template<
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__coro.async_resume.overload1 async_resume]``(
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.async_resume.overload1 more...]]``
-
-  template<
-      typename CompletionToken,
-      detail::convertible_to< input_type > T>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.experimental__coro.async_resume.overload2 async_resume]``(
-      T && ip,
-      CompletionToken && token);
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.async_resume.overload2 more...]]``
-
-
-[section:overload1 experimental::coro::async_resume (1 of 2 overloads)]
-
-
-Resume the coroutine. 
-
-
-  template<
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resume(
-      CompletionToken && token);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The completion token of the async resume.]]
-
-]
-
-
-[heading Attention]
-      
-Calling an invalid coroutine with a noexcept signature is undefined behaviour.
-
-
-[heading Remarks]
-      
-This overload is only available for coroutines without an input value. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::coro::async_resume (2 of 2 overloads)]
-
-
-Resume the coroutine. 
-
-
-  template<
-      typename CompletionToken,
-      detail::convertible_to< input_type > T>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resume(
-      T && ip,
-      CompletionToken && token);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The completion token of the async resume.]]
-
-]
-
-
-[heading Attention]
-      
-Calling an invalid coroutine with a noexcept signature is undefined behaviour.
-
-
-[heading Remarks]
-      
-This overload is only available for coroutines with an input value. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:completion_handler experimental::coro::completion_handler]
-
-[indexterm2 asio.indexterm.experimental__coro.completion_handler..completion_handler..experimental::coro] 
-Completion handler type used by async\_resume. 
-
-
-  typedef typename traits::completion_handler completion_handler;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:coro experimental::coro::coro]
-
-[indexterm2 asio.indexterm.experimental__coro.coro..coro..experimental::coro] 
-The default constructor, gives an invalid coroutine. 
-
-
-  ``[link asio.reference.experimental__coro.coro.overload1 coro]``();
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.coro.overload1 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.experimental__coro.coro.overload2 coro]``(
-      coro && lhs);
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.coro.overload2 more...]]``
-
-
-
-  ``[link asio.reference.experimental__coro.coro.overload3 coro]``(
-      const coro & );
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.coro.overload3 more...]]``
-
-
-[section:overload1 experimental::coro::coro (1 of 3 overloads)]
-
-
-The default constructor, gives an invalid coroutine. 
-
-
-  coro();
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::coro::coro (2 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  coro(
-      coro && lhs);
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::coro::coro (3 of 3 overloads)]
-
-
-
-  coro(
-      const coro & );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:error_type experimental::coro::error_type]
-
-[indexterm2 asio.indexterm.experimental__coro.error_type..error_type..experimental::coro] 
-The error type of the coroutine. Void for noexcept. 
-
-
-  typedef typename traits::error_type error_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:executor_type experimental::coro::executor_type]
-
-[indexterm2 asio.indexterm.experimental__coro.executor_type..executor_type..experimental::coro] 
-The executor type. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:get_allocator experimental::coro::get_allocator]
-
-[indexterm2 asio.indexterm.experimental__coro.get_allocator..get_allocator..experimental::coro] 
-Get the used allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-
-[section:get_executor experimental::coro::get_executor]
-
-[indexterm2 asio.indexterm.experimental__coro.get_executor..get_executor..experimental::coro] 
-Get the used executor. 
-
-
-  executor_type get_executor() const;
-
-
-
-[endsect]
-
-
-
-[section:input_type experimental::coro::input_type]
-
-[indexterm2 asio.indexterm.experimental__coro.input_type..input_type..experimental::coro] 
-The value that can be passed into a symmetrical cororoutine. `void` if asymmetrical. 
-
-
-  typedef typename traits::input_type input_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:is_noexcept experimental::coro::is_noexcept]
-
-[indexterm2 asio.indexterm.experimental__coro.is_noexcept..is_noexcept..experimental::coro] 
-Whether or not the coroutine is noexcept. 
-
-
-  static constexpr bool is_noexcept = traits::is_noexcept;
-
-
-
-[endsect]
-
-
-
-[section:is_open experimental::coro::is_open]
-
-[indexterm2 asio.indexterm.experimental__coro.is_open..is_open..experimental::coro] 
-Check whether the coroutine is open, i.e. can be resumed. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_bool experimental::coro::operator bool]
-
-[indexterm2 asio.indexterm.experimental__coro.operator_bool..operator bool..experimental::coro] 
-Check whether the coroutine is open, i.e. can be resumed. 
-
-
-  operator bool() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_co_await experimental::coro::operator co_await]
-
-[indexterm2 asio.indexterm.experimental__coro.operator_co_await..operator co_await..experimental::coro] 
-Operator used for coroutines without input value. 
-
-
-  auto operator co_await();
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ experimental::coro::operator()]
-
-[indexterm2 asio.indexterm.experimental__coro.operator_lp__rp_..operator()..experimental::coro] 
-Operator used for coroutines with input value. 
-
-
-  template<
-      detail::convertible_to< input_type > T>
-  auto operator()(
-      T && ip);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ip][The input value]]
-
-]
-
-
-[heading Return Value]
-      
-An awaitable handle.
-
-
-
-  coro<void> push_values(coro<double(int)> c)
-  {
-     std::optional<double> res = co_await c(42);
-  }
-
-
-
-
-
-[endsect]
-
-
-[section:operator_eq_ experimental::coro::operator=]
-
-[indexterm2 asio.indexterm.experimental__coro.operator_eq_..operator=..experimental::coro] 
-Move assignment. 
-
-
-  coro & ``[link asio.reference.experimental__coro.operator_eq_.overload1 operator=]``(
-      coro && lhs);
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.operator_eq_.overload1 more...]]``
-
-  coro & ``[link asio.reference.experimental__coro.operator_eq_.overload2 operator=]``(
-      const coro & );
-  ``  [''''&raquo;''' [link asio.reference.experimental__coro.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 experimental::coro::operator= (1 of 2 overloads)]
-
-
-Move assignment. 
-
-
-  coro & operator=(
-      coro && lhs);
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::coro::operator= (2 of 2 overloads)]
-
-
-
-  coro & operator=(
-      const coro & );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:promise_type experimental::coro::promise_type]
-
-[indexterm2 asio.indexterm.experimental__coro.promise_type..promise_type..experimental::coro] 
-The internal promise-type of the coroutine. 
-
-
-  typedef detail::coro_promise< Yield, Return, Executor, Allocator > promise_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:result_type experimental::coro::result_type]
-
-[indexterm2 asio.indexterm.experimental__coro.result_type..result_type..experimental::coro] 
-The type received by a co\_await or async\_resume. Its a combination of yield and return. 
-
-
-  typedef typename traits::result_type result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:return_type experimental::coro::return_type]
-
-[indexterm2 asio.indexterm.experimental__coro.return_type..return_type..experimental::coro] 
-The type that can be passed out through a co\_return. 
-
-
-  typedef typename traits::return_type return_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:signature_type experimental::coro::signature_type]
-
-[indexterm2 asio.indexterm.experimental__coro.signature_type..signature_type..experimental::coro] 
-The signature used by the async\_resume. 
-
-
-  typedef typename traits::signature_type signature_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:traits experimental::coro::traits]
-
-[indexterm2 asio.indexterm.experimental__coro.traits..traits..experimental::coro] 
-The traits of the coroutine. See [link asio.reference.experimental__coro_traits `experimental::coro_traits`] for details. 
-
-
-  typedef coro_traits< Yield, Return, Executor > traits;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.completion_handler [*completion_handler]]]
-    [Completion handler type used by async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.error_type [*error_type]]]
-    [The error type of the coroutine. void for noexcept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.input_type [*input_type]]]
-    [The value that can be passed into a symmetrical cororoutine. void if asymmetrical. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.result_type [*result_type]]]
-    [The type received by a co_await or async_resume. It's a combination of yield and return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.return_type [*return_type]]]
-    [The type that can be passed out through a co_return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.signature_type [*signature_type]]]
-    [The signature used by the async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.yield_type [*yield_type]]]
-    [The type that can be passed out through a co_yield. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro_traits.is_noexcept [*is_noexcept]] [static]]
-    [Whether or not the coroutine is noexcept. ]
-  ]
-
-]
-
-Template parameter `Yield` specifies type or signature used by co\_yield, `Return` specifies the type used for co\_return, and `Executor` specifies the underlying executor type. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:yield_type experimental::coro::yield_type]
-
-[indexterm2 asio.indexterm.experimental__coro.yield_type..yield_type..experimental::coro] 
-The type that can be passed out through a co\_yield. 
-
-
-  typedef typename traits::yield_type yield_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:_coro experimental::coro::~coro]
-
-[indexterm2 asio.indexterm.experimental__coro._coro..~coro..experimental::coro] 
-Destructor. Destroys the coroutine, if it holds a valid one. 
-
-
-  ~coro();
-
-
-
-[heading Remarks]
-      
-This does not cancel an active coroutine. Destructing a resumable coroutine, i.e. one with a call to async\_resume that has not completed, is undefined behaviour. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__coro_traits experimental::coro_traits]
-
-[indexterm1 asio.indexterm.experimental__coro_traits..experimental::coro_traits]
-
-
-The traits describing the resumable coroutine behaviour. 
-
-
-  template<
-      typename Yield,
-      typename Return,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct coro_traits
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.completion_handler [*completion_handler]]]
-    [Completion handler type used by async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.error_type [*error_type]]]
-    [The error type of the coroutine. void for noexcept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.input_type [*input_type]]]
-    [The value that can be passed into a symmetrical cororoutine. void if asymmetrical. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.result_type [*result_type]]]
-    [The type received by a co_await or async_resume. It's a combination of yield and return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.return_type [*return_type]]]
-    [The type that can be passed out through a co_return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.signature_type [*signature_type]]]
-    [The signature used by the async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro_traits.yield_type [*yield_type]]]
-    [The type that can be passed out through a co_yield. ]
-  
-  ]
-
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro_traits.is_noexcept [*is_noexcept]] [static]]
-    [Whether or not the coroutine is noexcept. ]
-  ]
-
-]
-
-Template parameter `Yield` specifies type or signature used by co\_yield, `Return` specifies the type used for co\_return, and `Executor` specifies the underlying executor type. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[section:completion_handler experimental::coro_traits::completion_handler]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.completion_handler..completion_handler..experimental::coro_traits] 
-Completion handler type used by async\_resume. 
-
-
-  typedef argument_dependent completion_handler;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:error_type experimental::coro_traits::error_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.error_type..error_type..experimental::coro_traits] 
-The error type of the coroutine. `void` for noexcept. 
-
-
-  typedef argument_dependent error_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:input_type experimental::coro_traits::input_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.input_type..input_type..experimental::coro_traits] 
-The value that can be passed into a symmetrical cororoutine. `void` if asymmetrical. 
-
-
-  typedef argument_dependent input_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:is_noexcept experimental::coro_traits::is_noexcept]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.is_noexcept..is_noexcept..experimental::coro_traits] 
-Whether or not the coroutine is noexcept. 
-
-
-  static constexpr bool is_noexcept = argument_dependent;
-
-
-
-[endsect]
-
-
-
-[section:result_type experimental::coro_traits::result_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.result_type..result_type..experimental::coro_traits] 
-The type received by a co\_await or async\_resume. It's a combination of yield and return. 
-
-
-  typedef argument_dependent result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:return_type experimental::coro_traits::return_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.return_type..return_type..experimental::coro_traits] 
-The type that can be passed out through a co\_return. 
-
-
-  typedef argument_dependent return_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:signature_type experimental::coro_traits::signature_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.signature_type..signature_type..experimental::coro_traits] 
-The signature used by the async\_resume. 
-
-
-  typedef argument_dependent signature_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:yield_type experimental::coro_traits::yield_type]
-
-[indexterm2 asio.indexterm.experimental__coro_traits.yield_type..yield_type..experimental::coro_traits] 
-The type that can be passed out through a co\_yield. 
-
-
-  typedef argument_dependent yield_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro_traits.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:experimental__error__channel_category experimental::error::channel_category]
-
-[indexterm1 asio.indexterm.experimental__error__channel_category..experimental::error::channel_category]
-
-
-  static const asio::error_category & channel_category = asio::experimental::error::get_channel_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_error.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:experimental__error__channel_errors experimental::error::channel_errors]
-
-[indexterm1 asio.indexterm.experimental__error__channel_errors..experimental::error::channel_errors]
-
-  enum channel_errors
-
-[indexterm2 asio.indexterm.experimental__error__channel_errors.channel_closed..channel_closed..experimental::error::channel_errors]
-[indexterm2 asio.indexterm.experimental__error__channel_errors.channel_cancelled..channel_cancelled..experimental::error::channel_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [channel_closed]
-    [The channel was closed. ]
-  ]
-
-  [
-    [channel_cancelled]
-    [The channel was cancelled. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_error.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:experimental__error__get_channel_category experimental::error::get_channel_category]
-
-[indexterm1 asio.indexterm.experimental__error__get_channel_category..experimental::error::get_channel_category]
-
-
-  const asio::error_category & get_channel_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_error.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:experimental__error__make_error_code experimental::error::make_error_code]
-
-[indexterm1 asio.indexterm.experimental__error__make_error_code..experimental::error::make_error_code]
-
-
-  asio::error_code make_error_code(
-      channel_errors e);
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_error.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:experimental__generator experimental::generator]
-
-[indexterm1 asio.indexterm.experimental__generator..experimental::generator]
-
-A generator is a coro that returns void and yields value. 
-
-
-  typedef coro< T, void, Executor, Allocator > generator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__coro.allocator_type [*allocator_type]]]
-    [The allocator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.completion_handler [*completion_handler]]]
-    [Completion handler type used by async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.error_type [*error_type]]]
-    [The error type of the coroutine. Void for noexcept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.executor_type [*executor_type]]]
-    [The executor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.input_type [*input_type]]]
-    [The value that can be passed into a symmetrical cororoutine. void if asymmetrical. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.promise_type [*promise_type]]]
-    [The internal promise-type of the coroutine. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.result_type [*result_type]]]
-    [The type received by a co_await or async_resume. Its a combination of yield and return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.return_type [*return_type]]]
-    [The type that can be passed out through a co_return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.signature_type [*signature_type]]]
-    [The signature used by the async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.traits [*traits]]]
-    [The traits of the coroutine. See asio::experimental::coro_traits for details. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.yield_type [*yield_type]]]
-    [The type that can be passed out through a co_yield. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.async_resume [*async_resume]]]
-    [Resume the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.coro [*coro]] [constructor]]
-    [The default constructor, gives an invalid coroutine. 
-     [hr]
-     Move constructor. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_allocator [*get_allocator]]]
-    [Get the used allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_executor [*get_executor]]]
-    [Get the used executor. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.is_open [*is_open]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_bool [*operator bool]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_co_await [*operator co_await]]]
-    [Operator used for coroutines without input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_lp__rp_ [*operator()]]]
-    [Operator used for coroutines with input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_eq_ [*operator=]]]
-    [Move assignment. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro._coro [*~coro]] [destructor]]
-    [Destructor. Destroys the coroutine, if it holds a valid one. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.is_noexcept [*is_noexcept]] [static]]
-    [Whether or not the coroutine is noexcept. ]
-  ]
-
-]
-
-Template parameter `Yield` specifies type or signature used by co\_yield, `Return` specifies the type used for co\_return, and `Executor` specifies the underlying executor type. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__is_async_operation_range experimental::is_async_operation_range]
-
-[indexterm1 asio.indexterm.experimental__is_async_operation_range..experimental::is_async_operation_range]
-
-
-Type trait used to determine whether a type is a range of asynchronous operations that can be used with with `make_parallel_group`. 
-
-
-  template<
-      typename T>
-  struct is_async_operation_range
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__is_async_operation_range.value [*value]] [static]]
-    [The value member is true if the type may be used as a range of asynchronous operations. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[section:value experimental::is_async_operation_range::value]
-
-[indexterm2 asio.indexterm.experimental__is_async_operation_range.value..value..experimental::is_async_operation_range] 
-The value member is true if the type may be used as a range of asynchronous operations. 
-
-
-  static const bool value;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__is_promise experimental::is_promise]
-
-[indexterm1 asio.indexterm.experimental__is_promise..experimental::is_promise]
-
-
-
-  template<
-      typename T>
-  struct is_promise :
-    public std::false_type
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-[section:experimental__is_promise_lt__promise_lt__Ts_ellipsis___gt___gt_ experimental::is_promise< promise< Ts... > >]
-
-[indexterm1 asio.indexterm.experimental__is_promise_lt__promise_lt__Ts_ellipsis___gt___gt_..experimental::is_promise< promise< Ts\.\.\. > >]
-
-
-
-  template<
-      typename ... Ts>
-  struct is_promise< promise< Ts... > > :
-    public std::true_type
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__is_promise_v experimental::is_promise_v]
-
-[indexterm1 asio.indexterm.experimental__is_promise_v..experimental::is_promise_v]
-
-
-  constexpr bool is_promise_v = is_promise<T>::value;
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__make_parallel_group experimental::make_parallel_group]
-
-[indexterm1 asio.indexterm.experimental__make_parallel_group..experimental::make_parallel_group]
-
-Create a group of operations that may be launched in parallel. 
-
-  template<
-      typename... Ops>
-  parallel_group< Ops... > ``[link asio.reference.experimental__make_parallel_group.overload1 make_parallel_group]``(
-      Ops... ops);
-  ``  [''''&raquo;''' [link asio.reference.experimental__make_parallel_group.overload1 more...]]``
-
-  template<
-      typename Range>
-  ranged_parallel_group< decay_t< Range > > ``[link asio.reference.experimental__make_parallel_group.overload2 make_parallel_group]``(
-      Range && range,
-      constraint_t< is_async_operation_range< decay_t< Range > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__make_parallel_group.overload2 more...]]``
-
-  template<
-      typename Allocator,
-      typename Range>
-  ranged_parallel_group< decay_t< Range >, Allocator > ``[link asio.reference.experimental__make_parallel_group.overload3 make_parallel_group]``(
-      allocator_arg_t ,
-      const Allocator & allocator,
-      Range && range,
-      constraint_t< is_async_operation_range< decay_t< Range > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__make_parallel_group.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[section:overload1 experimental::make_parallel_group (1 of 3 overloads)]
-
-
-Create a group of operations that may be launched in parallel. 
-
-
-  template<
-      typename... Ops>
-  parallel_group< Ops... > make_parallel_group(
-      Ops... ops);
-
-
-For example: 
-
-  asio::experimental::make_parallel_group(
-    in.async_read_some(asio::buffer(data)),
-    timer.async_wait()
-  ).async_wait(
-    asio::experimental::wait_for_all(),
-    [](
-        std::array<std::size_t, 2> completion_order,
-        std::error_code ec1, std::size_t n1,
-        std::error_code ec2
-    )
-    {
-      switch (completion_order[0])
-      {
-      case 0:
-        {
-          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-        }
-        break;
-      case 1:
-        {
-          std::cout << "timer finished: " << ec2 << "\n";
-        }
-        break;
-      }
-    }
-  );
-
-
-
-
-If preferred, the asynchronous operations may be explicitly packaged as function objects: 
-
-  asio::experimental::make_parallel_group(
-    [&](auto token)
-    {
-      return in.async_read_some(asio::buffer(data), token);
-    },
-    [&](auto token)
-    {
-      return timer.async_wait(token);
-    }
-  ).async_wait(
-    asio::experimental::wait_for_all(),
-    [](
-        std::array<std::size_t, 2> completion_order,
-        std::error_code ec1, std::size_t n1,
-        std::error_code ec2
-    )
-    {
-      switch (completion_order[0])
-      {
-      case 0:
-        {
-          std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-        }
-        break;
-      case 1:
-        {
-          std::cout << "timer finished: " << ec2 << "\n";
-        }
-        break;
-      }
-    }
-  );
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::make_parallel_group (2 of 3 overloads)]
-
-
-Create a group of operations that may be launched in parallel. 
-
-
-  template<
-      typename Range>
-  ranged_parallel_group< decay_t< Range > > make_parallel_group(
-      Range && range,
-      constraint_t< is_async_operation_range< decay_t< Range > >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[range][A range containing the operations to be launched.]]
-
-]
-
-For example: 
-
-  using op_type =
-    decltype(socket1.async_read_some(asio::buffer(data1)));
-
-  std::vector<op_type> ops;
-  ops.push_back(socket1.async_read_some(asio::buffer(data1)));
-  ops.push_back(socket2.async_read_some(asio::buffer(data2)));
-
-  asio::experimental::make_parallel_group(ops).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::vector<std::size_t> completion_order,
-          std::vector<std::error_code> e,
-          std::vector<std::size_t> n
-        )
-      {
-        for (std::size_t i = 0; i < completion_order.size(); ++i)
-        {
-          std::size_t idx = completion_order[i];
-          std::cout << "socket " << idx << " finished: ";
-          std::cout << e[idx] << ", " << n[idx] << "\n";
-        }
-      }
-    );
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::make_parallel_group (3 of 3 overloads)]
-
-
-Create a group of operations that may be launched in parallel. 
-
-
-  template<
-      typename Allocator,
-      typename Range>
-  ranged_parallel_group< decay_t< Range >, Allocator > make_parallel_group(
-      allocator_arg_t ,
-      const Allocator & allocator,
-      Range && range,
-      constraint_t< is_async_operation_range< decay_t< Range > >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[allocator][Specifies the allocator to be used with the result vectors.]]
-
-[[range][A range containing the operations to be launched.]]
-
-]
-
-For example: 
-
-  using op_type =
-    decltype(socket1.async_read_some(asio::buffer(data1)));
-
-  std::vector<op_type> ops;
-  ops.push_back(socket1.async_read_some(asio::buffer(data1)));
-  ops.push_back(socket2.async_read_some(asio::buffer(data2)));
-
-  asio::experimental::make_parallel_group(
-      std::allocator_arg_t,
-      my_allocator,
-      ops
-    ).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::vector<std::size_t> completion_order,
-          std::vector<std::error_code> e,
-          std::vector<std::size_t> n
-        )
-      {
-        for (std::size_t i = 0; i < completion_order.size(); ++i)
-        {
-          std::size_t idx = completion_order[i];
-          std::cout << "socket " << idx << " finished: ";
-          std::cout << e[idx] << ", " << n[idx] << "\n";
-        }
-      }
-    );
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__parallel_group experimental::parallel_group]
-
-[indexterm1 asio.indexterm.experimental__parallel_group..experimental::parallel_group]
-
-
-A group of asynchronous operations that may be launched in parallel. 
-
-
-  template<
-      typename... Ops>
-  class parallel_group
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__parallel_group.signature [*signature]]]
-    [The completion signature for the group of operations. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__parallel_group.async_wait [*async_wait]]]
-    [Initiate an asynchronous wait for the group of operations. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__parallel_group.parallel_group [*parallel_group]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-See the documentation for [link asio.reference.experimental__make_parallel_group `experimental::make_parallel_group`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[section:async_wait experimental::parallel_group::async_wait]
-
-[indexterm2 asio.indexterm.experimental__parallel_group.async_wait..async_wait..experimental::parallel_group] 
-Initiate an asynchronous wait for the group of operations. 
-
-
-  template<
-      typename CancellationCondition,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      CancellationCondition cancellation_condition,
-      CompletionToken && token);
-
-
-Launches the group and asynchronously waits for completion.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[cancellation_condition][A function object, called on completion of an operation within the group, that is used to determine whether to cancel the remaining operations. The function object is passed the arguments of the completed operation's handler. To trigger cancellation of the remaining operations, it must return a [link asio.reference.cancellation_type `cancellation_type`] value other than `asio::cancellation_type::none`.]]
-
-[[token][A [link asio.overview.model.completion_tokens completion token] whose signature is comprised of a `std::array<std::size_t, N>` indicating the completion order of the operations, followed by all operations' completion handler arguments.]]
-
-]
-
-The library provides the following `cancellation_condition` types:
-
-
-* [link asio.reference.experimental__wait_for_all `experimental::wait_for_all`] 
-
-* [link asio.reference.experimental__wait_for_one `experimental::wait_for_one`] 
-
-* [link asio.reference.experimental__wait_for_one_error `experimental::wait_for_one_error`] 
-
-* [link asio.reference.experimental__wait_for_one_success `experimental::wait_for_one_success`] 
-
-
-
-
-[endsect]
-
-
-
-[section:parallel_group experimental::parallel_group::parallel_group]
-
-[indexterm2 asio.indexterm.experimental__parallel_group.parallel_group..parallel_group..experimental::parallel_group] 
-Constructor. 
-
-
-  parallel_group(
-      Ops... ops);
-
-
-
-[endsect]
-
-
-
-[section:signature experimental::parallel_group::signature]
-
-[indexterm2 asio.indexterm.experimental__parallel_group.signature..signature..experimental::parallel_group] 
-The completion signature for the group of operations. 
-
-
-  typedef detail::parallel_group_signature< sizeof...(Ops), completion_signature_of_t< Ops >... >::type signature;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__promise experimental::promise]
-
-[indexterm1 asio.indexterm.experimental__promise..experimental::promise]
-
-
-A disposable handle for an eager operation. 
-
-
-  template<
-      typename Signature = void(),
-      typename ``[link asio.reference.Executor1 Executor]`` = asio::any_io_executor,
-      typename Allocator = std::allocator<void>>
-  struct promise
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__promise.value_type [*value_type]]]
-    [The value that's returned by the promise. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__promise.cancel [*cancel]]]
-    [Cancel the promise. Usually done through the destructor. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__promise.completed [*completed]]]
-    [Check if the promise is completed already. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__promise.operator_lp__rp_ [*operator()]]]
-    [Wait for the promise to become ready. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__promise.promise [*promise]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.experimental__promise._promise [*~promise]] [destructor]]
-    [Destruct the promise and cancel the operation. ]
-  ]
-  
-]
-
-
-
-[variablelist
-  
-[[Signature][The signature of the operation.]]
-
-[[Executor][The executor to be used by the promise (taken from the operation).]]
-
-[[Allocator][The allocator used for the promise. Can be set through use\_allocator.]]
-
-]
-
-A promise can be used to initiate an asynchronous option that can be completed later. If the promise gets destroyed before completion, the operation gets a cancel signal and the result is ignored.
-
-A promise fulfills the requirements of async\_operation.
-
-
-[heading Examples]
-  
-Reading and writing from one coroutine. 
-
-  awaitable<void> read_write_some(asio::ip::tcp::socket & sock,
-      asio::mutable_buffer read_buf, asio::const_buffer to_write)
-  {
-    auto p = asio::async_read(read_buf,
-        asio::experimental::use_promise);
-    co_await asio::async_write_some(to_write);
-    co_await p;
-  }
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:cancel experimental::promise::cancel]
-
-[indexterm2 asio.indexterm.experimental__promise.cancel..cancel..experimental::promise] 
-Cancel the promise. Usually done through the destructor. 
-
-
-  void cancel(
-      cancellation_type level = cancellation_type::all);
-
-
-
-[endsect]
-
-
-
-[section:completed experimental::promise::completed]
-
-[indexterm2 asio.indexterm.experimental__promise.completed..completed..experimental::promise] 
-Check if the promise is completed already. 
-
-
-  bool completed() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ experimental::promise::operator()]
-
-[indexterm2 asio.indexterm.experimental__promise.operator_lp__rp_..operator()..experimental::promise] 
-Wait for the promise to become ready. 
-
-
-  template<
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` operator()(
-      CompletionToken && token);
-
-
-
-[endsect]
-
-
-[section:promise experimental::promise::promise]
-
-[indexterm2 asio.indexterm.experimental__promise.promise..promise..experimental::promise] 
-
-  ``[link asio.reference.experimental__promise.promise.overload1 promise]``();
-  ``  [''''&raquo;''' [link asio.reference.experimental__promise.promise.overload1 more...]]``
-
-  ``[link asio.reference.experimental__promise.promise.overload2 promise]``(
-      const promise & );
-  ``  [''''&raquo;''' [link asio.reference.experimental__promise.promise.overload2 more...]]``
-
-  ``[link asio.reference.experimental__promise.promise.overload3 promise]``(
-      promise && );
-  ``  [''''&raquo;''' [link asio.reference.experimental__promise.promise.overload3 more...]]``
-
-
-[section:overload1 experimental::promise::promise (1 of 3 overloads)]
-
-
-
-  promise();
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::promise::promise (2 of 3 overloads)]
-
-
-
-  promise(
-      const promise & );
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::promise::promise (3 of 3 overloads)]
-
-
-
-  promise(
-      promise && );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:value_type experimental::promise::value_type]
-
-[indexterm2 asio.indexterm.experimental__promise.value_type..value_type..experimental::promise] 
-The value that's returned by the promise. 
-
-
-  typedef typename promise_value_type< Ts... >::type value_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__promise_value_type.type [*type]]]
-    []
-  
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:_promise experimental::promise::~promise]
-
-[indexterm2 asio.indexterm.experimental__promise._promise..~promise..experimental::promise] 
-Destruct the promise and cancel the operation. 
-
-
-  ~promise();
-
-
-It is safe to destruct a promise of a promise that didn't complete. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__promise_value_type experimental::promise_value_type]
-
-[indexterm1 asio.indexterm.experimental__promise_value_type..experimental::promise_value_type]
-
-
-
-  template<
-      typename ... Ts>
-  struct promise_value_type
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__promise_value_type.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:type experimental::promise_value_type::type]
-
-[indexterm2 asio.indexterm.experimental__promise_value_type.type..type..experimental::promise_value_type] 
-
-  typedef std::tuple< Ts... > type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__promise_value_type_lt__T__gt_ experimental::promise_value_type< T >]
-
-[indexterm1 asio.indexterm.experimental__promise_value_type_lt__T__gt_..experimental::promise_value_type< T >]
-
-
-
-  template<
-      typename T>
-  struct promise_value_type< T >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__promise_value_type_lt__T__gt_.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:type experimental::promise_value_type< T >::type]
-
-[indexterm2 asio.indexterm.experimental__promise_value_type_lt__T__gt_.type..type..experimental::promise_value_type< T >] 
-
-  typedef T type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__promise_value_type_lt__gt_ experimental::promise_value_type<>]
-
-[indexterm1 asio.indexterm.experimental__promise_value_type_lt__gt_..experimental::promise_value_type<>]
-
-
-
-  template<>
-  struct promise_value_type<>
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__promise_value_type_lt__gt_.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:type experimental::promise_value_type<>::type]
-
-[indexterm2 asio.indexterm.experimental__promise_value_type_lt__gt_.type..type..experimental::promise_value_type<>] 
-
-  typedef std::tuple<> type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__ranged_parallel_group experimental::ranged_parallel_group]
-
-[indexterm1 asio.indexterm.experimental__ranged_parallel_group..experimental::ranged_parallel_group]
-
-
-A range-based group of asynchronous operations that may be launched in parallel. 
-
-
-  template<
-      typename Range,
-      typename Allocator = std::allocator<void>>
-  class ranged_parallel_group
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__ranged_parallel_group.signature [*signature]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__ranged_parallel_group.async_wait [*async_wait]]]
-    [Initiate an asynchronous wait for the group of operations. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__ranged_parallel_group.ranged_parallel_group [*ranged_parallel_group]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-See the documentation for [link asio.reference.experimental__make_parallel_group `experimental::make_parallel_group`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[section:async_wait experimental::ranged_parallel_group::async_wait]
-
-[indexterm2 asio.indexterm.experimental__ranged_parallel_group.async_wait..async_wait..experimental::ranged_parallel_group] 
-Initiate an asynchronous wait for the group of operations. 
-
-
-  template<
-      typename CancellationCondition,
-      typename CompletionToken>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      CancellationCondition cancellation_condition,
-      CompletionToken && token);
-
-
-Launches the group and asynchronously waits for completion.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[cancellation_condition][A function object, called on completion of an operation within the group, that is used to determine whether to cancel the remaining operations. The function object is passed the arguments of the completed operation's handler. To trigger cancellation of the remaining operations, it must return a [link asio.reference.cancellation_type `cancellation_type`] value other than `asio::cancellation_type::none`.]]
-
-[[token][A [link asio.overview.model.completion_tokens completion token] whose signature is comprised of a `std::vector<std::size_t, Allocator>` indicating the completion order of the operations, followed by a vector for each of the completion signature's arguments.]]
-
-]
-
-The library provides the following `cancellation_condition` types:
-
-
-* [link asio.reference.experimental__wait_for_all `experimental::wait_for_all`] 
-
-* [link asio.reference.experimental__wait_for_one `experimental::wait_for_one`] 
-
-* [link asio.reference.experimental__wait_for_one_error `experimental::wait_for_one_error`] 
-
-* [link asio.reference.experimental__wait_for_one_success `experimental::wait_for_one_success`] 
-
-
-
-
-[endsect]
-
-
-
-[section:ranged_parallel_group experimental::ranged_parallel_group::ranged_parallel_group]
-
-[indexterm2 asio.indexterm.experimental__ranged_parallel_group.ranged_parallel_group..ranged_parallel_group..experimental::ranged_parallel_group] 
-Constructor. 
-
-
-  ranged_parallel_group(
-      Range range,
-      const Allocator & allocator = Allocator());
-
-
-
-[endsect]
-
-
-
-[section:signature experimental::ranged_parallel_group::signature]
-
-[indexterm2 asio.indexterm.experimental__ranged_parallel_group.signature..signature..experimental::ranged_parallel_group] 
-
-  typedef Allocator ::type signature;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/parallel_group.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:experimental__task experimental::task]
-
-[indexterm1 asio.indexterm.experimental__task..experimental::task]
-
-A task is a coro that does not yield values. 
-
-
-  typedef coro< void(), T, Executor, Allocator > task;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__coro.allocator_type [*allocator_type]]]
-    [The allocator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.completion_handler [*completion_handler]]]
-    [Completion handler type used by async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.error_type [*error_type]]]
-    [The error type of the coroutine. Void for noexcept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.executor_type [*executor_type]]]
-    [The executor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.input_type [*input_type]]]
-    [The value that can be passed into a symmetrical cororoutine. void if asymmetrical. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.promise_type [*promise_type]]]
-    [The internal promise-type of the coroutine. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.result_type [*result_type]]]
-    [The type received by a co_await or async_resume. Its a combination of yield and return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.return_type [*return_type]]]
-    [The type that can be passed out through a co_return. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.signature_type [*signature_type]]]
-    [The signature used by the async_resume. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.traits [*traits]]]
-    [The traits of the coroutine. See asio::experimental::coro_traits for details. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__coro.yield_type [*yield_type]]]
-    [The type that can be passed out through a co_yield. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.async_resume [*async_resume]]]
-    [Resume the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.coro [*coro]] [constructor]]
-    [The default constructor, gives an invalid coroutine. 
-     [hr]
-     Move constructor. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_allocator [*get_allocator]]]
-    [Get the used allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.get_executor [*get_executor]]]
-    [Get the used executor. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.is_open [*is_open]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_bool [*operator bool]]]
-    [Check whether the coroutine is open, i.e. can be resumed. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_co_await [*operator co_await]]]
-    [Operator used for coroutines without input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_lp__rp_ [*operator()]]]
-    [Operator used for coroutines with input value. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro.operator_eq_ [*operator=]]]
-    [Move assignment. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__coro._coro [*~coro]] [destructor]]
-    [Destructor. Destroys the coroutine, if it holds a valid one. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__coro.is_noexcept [*is_noexcept]] [static]]
-    [Whether or not the coroutine is noexcept. ]
-  ]
-
-]
-
-Template parameter `Yield` specifies type or signature used by co\_yield, `Return` specifies the type used for co\_return, and `Executor` specifies the underlying executor type. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:experimental__use_coro experimental::use_coro]
-
-[indexterm1 asio.indexterm.experimental__use_coro..experimental::use_coro]
-
-A [link asio.overview.model.completion_tokens completion token] object that represents the currently executing resumable coroutine. 
-
-
-  constexpr use_coro_t use_coro;
-
-
-See the documentation for asio::use\_coro\_t for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__use_coro_t experimental::use_coro_t]
-
-[indexterm1 asio.indexterm.experimental__use_coro_t..experimental::use_coro_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] that creates another coro for the task completion. 
-
-
-  template<
-      typename Allocator = std::allocator<void>>
-  struct use_coro_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t.allocator_type [*allocator_type]]]
-    [The allocator type. The allocator is used when constructing the std::promise object for a given asynchronous operation. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use use_coro_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_coro_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_coro_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_coro_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.get_allocator [*get_allocator]]]
-    [Obtain allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.rebind [*rebind]]]
-    [Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.use_coro_t [*use_coro_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor used to specify file name, line, and function name. ]
-  ]
-  
-]
-
-The `use_coro_t` class, with its value `use_coro`, is used to represent an operation that can be awaited by the current resumable coroutine. This completion token may be passed as a handler to an asynchronous operation. For example:
-
-
-
-  coro<void> my_coroutine(tcp::socket my_socket)
-  {
-    std::size_t n = co_await my_socket.async_read_some(buffer, use_coro);
-    ...
-  } 
-
-
-
-
-When used with co\_await, the initiating function (`async_read_some` in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned.
-
-Note that this token is not the most efficient (use the default completion token `asio::deferred` for that) but does provide type erasure, as it will always return a `coro`. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[section:allocator_type experimental::use_coro_t::allocator_type]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.allocator_type..allocator_type..experimental::use_coro_t] 
-The allocator type. The allocator is used when constructing the `std::promise` object for a given asynchronous operation. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:as_default_on experimental::use_coro_t::as_default_on]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.as_default_on..as_default_on..experimental::use_coro_t] 
-Function helper to adapt an I/O object to use `use_coro_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t experimental::use_coro_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.as_default_on_t..as_default_on_t..experimental::use_coro_t] 
-Type alias to adapt an I/O object to use `use_coro_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify use_coro_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_coro_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:get_allocator experimental::use_coro_t::get_allocator]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.get_allocator..get_allocator..experimental::use_coro_t] 
-Obtain allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-
-[section:rebind experimental::use_coro_t::rebind]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.rebind..rebind..experimental::use_coro_t] 
-Specify an alternate allocator. 
-
-
-  template<
-      typename OtherAllocator>
-  use_coro_t< OtherAllocator > rebind(
-      const OtherAllocator & allocator) const;
-
-
-
-[endsect]
-
-
-[section:use_coro_t experimental::use_coro_t::use_coro_t]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t.use_coro_t..use_coro_t..experimental::use_coro_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.experimental__use_coro_t.use_coro_t.overload1 use_coro_t]``(
-      allocator_type allocator = allocator_type{});
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_coro_t.use_coro_t.overload1 more...]]``
-
-
-Constructor used to specify file name, line, and function name. 
-
-
-  constexpr ``[link asio.reference.experimental__use_coro_t.use_coro_t.overload2 use_coro_t]``(
-      const char * file_name,
-      int line,
-      const char * function_name,
-      allocator_type allocator = allocator_type{});
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_coro_t.use_coro_t.overload2 more...]]``
-
-
-[section:overload1 experimental::use_coro_t::use_coro_t (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr use_coro_t(
-      allocator_type allocator = allocator_type{});
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::use_coro_t::use_coro_t (2 of 2 overloads)]
-
-
-Constructor used to specify file name, line, and function name. 
-
-
-  constexpr use_coro_t(
-      const char * file_name,
-      int line,
-      const char * function_name,
-      allocator_type allocator = allocator_type{});
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__use_coro_t__executor_with_default experimental::use_coro_t::executor_with_default]
-
-[indexterm1 asio.indexterm.experimental__use_coro_t__executor_with_default..experimental::use_coro_t::executor_with_default]
-
-
-Adapts an executor to add the `use_coro_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify use_coro_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_coro_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[section:default_completion_token_type experimental::use_coro_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t__executor_with_default.default_completion_token_type..default_completion_token_type..experimental::use_coro_t::executor_with_default] 
-Specify `use_coro_t` as the default completion token type. 
-
-
-  typedef use_coro_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t.allocator_type [*allocator_type]]]
-    [The allocator type. The allocator is used when constructing the std::promise object for a given asynchronous operation. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use use_coro_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_coro_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_coro_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_coro_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_coro_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.get_allocator [*get_allocator]]]
-    [Obtain allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.rebind [*rebind]]]
-    [Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_coro_t.use_coro_t [*use_coro_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor used to specify file name, line, and function name. ]
-  ]
-  
-]
-
-The `use_coro_t` class, with its value `use_coro`, is used to represent an operation that can be awaited by the current resumable coroutine. This completion token may be passed as a handler to an asynchronous operation. For example:
-
-
-
-  coro<void> my_coroutine(tcp::socket my_socket)
-  {
-    std::size_t n = co_await my_socket.async_read_some(buffer, use_coro);
-    ...
-  } 
-
-
-
-
-When used with co\_await, the initiating function (`async_read_some` in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned.
-
-Note that this token is not the most efficient (use the default completion token `asio::deferred` for that) but does provide type erasure, as it will always return a `coro`. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_coro.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:executor_with_default experimental::use_coro_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.experimental__use_coro_t__executor_with_default.executor_with_default..executor_with_default..experimental::use_coro_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor1]``>
-  executor_with_default(
-      const InnerExecutor1 & ex,
-      constraint_t< conditional_t< !is_same< InnerExecutor1, executor_with_default >::value, is_convertible< InnerExecutor1, InnerExecutor >, false_type >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:experimental__use_promise experimental::use_promise]
-
-[indexterm1 asio.indexterm.experimental__use_promise..experimental::use_promise]
-
-
-  constexpr use_promise_t use_promise;
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:experimental__use_promise_t experimental::use_promise_t]
-
-[indexterm1 asio.indexterm.experimental__use_promise_t..experimental::use_promise_t]
-
-
-
-  template<
-      typename Allocator = std::allocator<void>>
-  struct use_promise_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_promise_t.allocator_type [*allocator_type]]]
-    [The allocator type. The allocator is used when constructing the promise object for a given asynchronous operation. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_promise_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_promise_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_promise_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_promise_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.get_allocator [*get_allocator]]]
-    [Obtain allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.rebind [*rebind]]]
-    [Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.use_promise_t [*use_promise_t]] [constructor]]
-    [Construct using default-constructed allocator. 
-     [hr]
-     Construct using specified allocator. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:allocator_type experimental::use_promise_t::allocator_type]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t.allocator_type..allocator_type..experimental::use_promise_t] 
-The allocator type. The allocator is used when constructing the `promise` object for a given asynchronous operation. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-
-[section:as_default_on experimental::use_promise_t::as_default_on]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t.as_default_on..as_default_on..experimental::use_promise_t] 
-Function helper to adapt an I/O object to use `use_promise_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:get_allocator experimental::use_promise_t::get_allocator]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t.get_allocator..get_allocator..experimental::use_promise_t] 
-Obtain allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-
-[section:rebind experimental::use_promise_t::rebind]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t.rebind..rebind..experimental::use_promise_t] 
-Specify an alternate allocator. 
-
-
-  template<
-      typename OtherAllocator>
-  use_promise_t< OtherAllocator > rebind(
-      const OtherAllocator & allocator) const;
-
-
-
-[endsect]
-
-
-[section:use_promise_t experimental::use_promise_t::use_promise_t]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t.use_promise_t..use_promise_t..experimental::use_promise_t] 
-Construct using default-constructed allocator. 
-
-
-  constexpr ``[link asio.reference.experimental__use_promise_t.use_promise_t.overload1 use_promise_t]``();
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_promise_t.use_promise_t.overload1 more...]]``
-
-
-Construct using specified allocator. 
-
-
-  explicit ``[link asio.reference.experimental__use_promise_t.use_promise_t.overload2 use_promise_t]``(
-      const Allocator & allocator);
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_promise_t.use_promise_t.overload2 more...]]``
-
-
-[section:overload1 experimental::use_promise_t::use_promise_t (1 of 2 overloads)]
-
-
-Construct using default-constructed allocator. 
-
-
-  constexpr use_promise_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::use_promise_t::use_promise_t (2 of 2 overloads)]
-
-
-Construct using specified allocator. 
-
-
-  use_promise_t(
-      const Allocator & allocator);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__use_promise_t__executor_with_default experimental::use_promise_t::executor_with_default]
-
-[indexterm1 asio.indexterm.experimental__use_promise_t__executor_with_default..experimental::use_promise_t::executor_with_default]
-
-
-Adapts an executor to add the `use_promise_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_promise_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify use_promise_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_promise_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. 
-     [hr]
-     Convert the specified executor to the inner executor type, then use that to construct the adapted executor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_promise.hpp]
-
-['Convenience header: ]None
-
-
-[section:default_completion_token_type experimental::use_promise_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t__executor_with_default.default_completion_token_type..default_completion_token_type..experimental::use_promise_t::executor_with_default] 
-Specify `use_promise_t` as the default completion token type. 
-
-
-  typedef use_promise_t< Allocator > default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.experimental__use_promise_t.allocator_type [*allocator_type]]]
-    [The allocator type. The allocator is used when constructing the promise object for a given asynchronous operation. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.experimental__use_promise_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_promise_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__use_promise_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_promise_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.get_allocator [*get_allocator]]]
-    [Obtain allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.rebind [*rebind]]]
-    [Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.experimental__use_promise_t.use_promise_t [*use_promise_t]] [constructor]]
-    [Construct using default-constructed allocator. 
-     [hr]
-     Construct using specified allocator. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/use_promise.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:executor_with_default experimental::use_promise_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.experimental__use_promise_t__executor_with_default.executor_with_default..executor_with_default..experimental::use_promise_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  ``[link asio.reference.experimental__use_promise_t__executor_with_default.executor_with_default.overload1 executor_with_default]``(
-      const InnerExecutor & ex);
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_promise_t__executor_with_default.executor_with_default.overload1 more...]]``
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.experimental__use_promise_t__executor_with_default.executor_with_default.overload2 executor_with_default]``(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.experimental__use_promise_t__executor_with_default.executor_with_default.overload2 more...]]``
-
-
-[section:overload1 experimental::use_promise_t::executor_with_default::executor_with_default (1 of 2 overloads)]
-
-
-Construct the adapted executor from the inner executor type. 
-
-
-  executor_with_default(
-      const InnerExecutor & ex);
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::use_promise_t::executor_with_default::executor_with_default (2 of 2 overloads)]
-
-
-Convert the specified executor to the inner executor type, then use that to construct the adapted executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  executor_with_default(
-      const OtherExecutor & ex,
-      constraint_t< is_convertible< OtherExecutor, InnerExecutor >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:experimental__wait_for_all experimental::wait_for_all]
-
-[indexterm1 asio.indexterm.experimental__wait_for_all..experimental::wait_for_all]
-
-
-Wait for all operations to complete. 
-
-
-  class wait_for_all
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__wait_for_all.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/cancellation_condition.hpp]
-
-['Convenience header: ]None
-
-
-[section:operator_lp__rp_ experimental::wait_for_all::operator()]
-
-[indexterm2 asio.indexterm.experimental__wait_for_all.operator_lp__rp_..operator()..experimental::wait_for_all] 
-
-  template<
-      typename... Args>
-  constexpr cancellation_type_t operator()(
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__wait_for_one experimental::wait_for_one]
-
-[indexterm1 asio.indexterm.experimental__wait_for_one..experimental::wait_for_one]
-
-
-Wait until an operation completes, then cancel the others. 
-
-
-  class wait_for_one
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__wait_for_one.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.experimental__wait_for_one.wait_for_one [*wait_for_one]] [constructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/cancellation_condition.hpp]
-
-['Convenience header: ]None
-
-
-[section:operator_lp__rp_ experimental::wait_for_one::operator()]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one.operator_lp__rp_..operator()..experimental::wait_for_one] 
-
-  template<
-      typename... Args>
-  constexpr cancellation_type_t operator()(
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-
-[section:wait_for_one experimental::wait_for_one::wait_for_one]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one.wait_for_one..wait_for_one..experimental::wait_for_one] 
-
-  constexpr wait_for_one(
-      cancellation_type_t cancel_type = cancellation_type::all);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__wait_for_one_error experimental::wait_for_one_error]
-
-[indexterm1 asio.indexterm.experimental__wait_for_one_error..experimental::wait_for_one_error]
-
-
-Wait until an operation completes with an error, then cancel the others. 
-
-
-  class wait_for_one_error
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__wait_for_one_error.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.experimental__wait_for_one_error.wait_for_one_error [*wait_for_one_error]] [constructor]]
-    []
-  ]
-  
-]
-
-If no operation completes with an error, waits for completion of all operations. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/cancellation_condition.hpp]
-
-['Convenience header: ]None
-
-[section:operator_lp__rp_ experimental::wait_for_one_error::operator()]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one_error.operator_lp__rp_..operator()..experimental::wait_for_one_error] 
-
-  constexpr cancellation_type_t ``[link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload1 operator()]``() const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< !is_same< decay_t< E >, asio::error_code >::value &&!is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > ``[link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload2 operator()]``(
-      const E & ,
-      Args && ...) const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload2 more...]]``
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< is_same< decay_t< E >, asio::error_code >::value||is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > ``[link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload3 operator()]``(
-      const E & e,
-      Args && ...) const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_error.operator_lp__rp_.overload3 more...]]``
-
-
-[section:overload1 experimental::wait_for_one_error::operator() (1 of 3 overloads)]
-
-
-
-  constexpr cancellation_type_t operator()() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::wait_for_one_error::operator() (2 of 3 overloads)]
-
-
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< !is_same< decay_t< E >, asio::error_code >::value &&!is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > operator()(
-      const E & ,
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::wait_for_one_error::operator() (3 of 3 overloads)]
-
-
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< is_same< decay_t< E >, asio::error_code >::value||is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > operator()(
-      const E & e,
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_for_one_error experimental::wait_for_one_error::wait_for_one_error]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one_error.wait_for_one_error..wait_for_one_error..experimental::wait_for_one_error] 
-
-  constexpr wait_for_one_error(
-      cancellation_type_t cancel_type = cancellation_type::all);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__wait_for_one_success experimental::wait_for_one_success]
-
-[indexterm1 asio.indexterm.experimental__wait_for_one_success..experimental::wait_for_one_success]
-
-
-Wait until an operation completes without an error, then cancel the others. 
-
-
-  class wait_for_one_success
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__wait_for_one_success.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.experimental__wait_for_one_success.wait_for_one_success [*wait_for_one_success]] [constructor]]
-    []
-  ]
-  
-]
-
-If no operation completes without an error, waits for completion of all operations. 
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/cancellation_condition.hpp]
-
-['Convenience header: ]None
-
-[section:operator_lp__rp_ experimental::wait_for_one_success::operator()]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one_success.operator_lp__rp_..operator()..experimental::wait_for_one_success] 
-
-  constexpr cancellation_type_t ``[link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload1 operator()]``() const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< !is_same< decay_t< E >, asio::error_code >::value &&!is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > ``[link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload2 operator()]``(
-      const E & ,
-      Args && ...) const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload2 more...]]``
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< is_same< decay_t< E >, asio::error_code >::value||is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > ``[link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload3 operator()]``(
-      const E & e,
-      Args && ...) const;
-  ``  [''''&raquo;''' [link asio.reference.experimental__wait_for_one_success.operator_lp__rp_.overload3 more...]]``
-
-
-[section:overload1 experimental::wait_for_one_success::operator() (1 of 3 overloads)]
-
-
-
-  constexpr cancellation_type_t operator()() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 experimental::wait_for_one_success::operator() (2 of 3 overloads)]
-
-
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< !is_same< decay_t< E >, asio::error_code >::value &&!is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > operator()(
-      const E & ,
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-
-[section:overload3 experimental::wait_for_one_success::operator() (3 of 3 overloads)]
-
-
-
-  template<
-      typename E,
-      typename... Args>
-  constexpr constraint_t< is_same< decay_t< E >, asio::error_code >::value||is_same< decay_t< E >, std::exception_ptr >::value, cancellation_type_t > operator()(
-      const E & e,
-      Args && ...) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_for_one_success experimental::wait_for_one_success::wait_for_one_success]
-
-[indexterm2 asio.indexterm.experimental__wait_for_one_success.wait_for_one_success..wait_for_one_success..experimental::wait_for_one_success] 
-
-  constexpr wait_for_one_success(
-      cancellation_type_t cancel_type = cancellation_type::all);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:file_base file_base]
-
-[indexterm1 asio.indexterm.file_base..file_base]
-
-
-The [link asio.reference.file_base `file_base`] class is used as a base for the [link asio.reference.basic_stream_file `basic_stream_file`] and [link asio.reference.basic_random_access_file `basic_random_access_file`] class templates so that we have a common place to define flags. 
-
-
-  class file_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.file_base.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.file_base.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.file_base._file_base [*~file_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.file_base.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.file_base.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/file_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:append file_base::append]
-
-[indexterm2 asio.indexterm.file_base.append..append..file_base] 
-Open the file in append mode. 
-
-
-  static const flags append = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:create file_base::create]
-
-[indexterm2 asio.indexterm.file_base.create..create..file_base] 
-Create the file if it does not exist. 
-
-
-  static const flags create = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:exclusive file_base::exclusive]
-
-[indexterm2 asio.indexterm.file_base.exclusive..exclusive..file_base] 
-Ensure a new file is created. Must be combined with `create`. 
-
-
-  static const flags exclusive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:flags file_base::flags]
-
-[indexterm2 asio.indexterm.file_base.flags..flags..file_base] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/file_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:read_only file_base::read_only]
-
-[indexterm2 asio.indexterm.file_base.read_only..read_only..file_base] 
-Open the file for reading. 
-
-
-  static const flags read_only = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:read_write file_base::read_write]
-
-[indexterm2 asio.indexterm.file_base.read_write..read_write..file_base] 
-Open the file for reading and writing. 
-
-
-  static const flags read_write = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:seek_basis file_base::seek_basis]
-
-[indexterm2 asio.indexterm.file_base.seek_basis..seek_basis..file_base] 
-Basis for seeking in a file. 
-
-  enum seek_basis
-
-[indexterm2 asio.indexterm.file_base.seek_basis.seek_set..seek_set..file_base]
-[indexterm2 asio.indexterm.file_base.seek_basis.seek_cur..seek_cur..file_base]
-[indexterm2 asio.indexterm.file_base.seek_basis.seek_end..seek_end..file_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [seek_set]
-    [Seek to an absolute position. ]
-  ]
-
-  [
-    [seek_cur]
-    [Seek to an offset relative to the current file position. ]
-  ]
-
-  [
-    [seek_end]
-    [Seek to an offset relative to the end of the file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:sync_all_on_write file_base::sync_all_on_write]
-
-[indexterm2 asio.indexterm.file_base.sync_all_on_write..sync_all_on_write..file_base] 
-Open the file so that write operations automatically synchronise the file data and metadata to disk. 
-
-
-  static const flags sync_all_on_write = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:truncate file_base::truncate]
-
-[indexterm2 asio.indexterm.file_base.truncate..truncate..file_base] 
-Open the file with any existing contents truncated. 
-
-
-  static const flags truncate = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:write_only file_base::write_only]
-
-[indexterm2 asio.indexterm.file_base.write_only..write_only..file_base] 
-Open the file for writing. 
-
-
-  static const flags write_only = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_file_base file_base::~file_base]
-
-[indexterm2 asio.indexterm.file_base._file_base..~file_base..file_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~file_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:generic__basic_endpoint generic::basic_endpoint]
-
-[indexterm1 asio.indexterm.generic__basic_endpoint..generic::basic_endpoint]
-
-
-Describes an endpoint for any socket type. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  class basic_endpoint
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint from the specified socket address. 
-     [hr]
-     Construct an endpoint from the specific endpoint type. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__basic_endpoint `generic::basic_endpoint`] class template describes an endpoint that may be associated with any socket type.
-
-
-[heading Remarks]
-      
-The socket types sockaddr type must be able to fit into a `sockaddr_storage` structure.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_endpoint generic::basic_endpoint::basic_endpoint]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.basic_endpoint..basic_endpoint..generic::basic_endpoint] 
-Default constructor. 
-
-
-  ``[link asio.reference.generic__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.basic_endpoint.overload1 more...]]``
-
-
-Construct an endpoint from the specified socket address. 
-
-
-  ``[link asio.reference.generic__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
-      const void * socket_address,
-      std::size_t socket_address_size,
-      int socket_protocol = 0);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.basic_endpoint.overload2 more...]]``
-
-
-Construct an endpoint from the specific endpoint type. 
-
-
-  template<
-      typename ``[link asio.reference.Endpoint Endpoint]``>
-  ``[link asio.reference.generic__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
-      const Endpoint & endpoint);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.basic_endpoint.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.generic__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.basic_endpoint.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.generic__basic_endpoint.basic_endpoint.overload5 basic_endpoint]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.basic_endpoint.overload5 more...]]``
-
-
-[section:overload1 generic::basic_endpoint::basic_endpoint (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  basic_endpoint();
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::basic_endpoint::basic_endpoint (2 of 5 overloads)]
-
-
-Construct an endpoint from the specified socket address. 
-
-
-  basic_endpoint(
-      const void * socket_address,
-      std::size_t socket_address_size,
-      int socket_protocol = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 generic::basic_endpoint::basic_endpoint (3 of 5 overloads)]
-
-
-Construct an endpoint from the specific endpoint type. 
-
-
-  template<
-      typename ``[link asio.reference.Endpoint Endpoint]``>
-  basic_endpoint(
-      const Endpoint & endpoint);
-
-
-
-[endsect]
-
-
-
-[section:overload4 generic::basic_endpoint::basic_endpoint (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_endpoint(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 generic::basic_endpoint::basic_endpoint (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  basic_endpoint(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:capacity generic::basic_endpoint::capacity]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.capacity..capacity..generic::basic_endpoint] 
-Get the capacity of the endpoint in the native type. 
-
-
-  std::size_t capacity() const;
-
-
-
-[endsect]
-
-
-[section:data generic::basic_endpoint::data]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.data..data..generic::basic_endpoint] 
-Get the underlying endpoint in the native type. 
-
-
-  data_type * ``[link asio.reference.generic__basic_endpoint.data.overload1 data]``();
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.data.overload1 more...]]``
-
-  const data_type * ``[link asio.reference.generic__basic_endpoint.data.overload2 data]``() const;
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.data.overload2 more...]]``
-
-
-[section:overload1 generic::basic_endpoint::data (1 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  data_type * data();
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::basic_endpoint::data (2 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  const data_type * data() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:data_type generic::basic_endpoint::data_type]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.data_type..data_type..generic::basic_endpoint] 
-The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. 
-
-
-  typedef implementation_defined data_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ generic::basic_endpoint::operator!=]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_not__eq_..operator!=..generic::basic_endpoint] 
-Compare two endpoints for inequality. 
-
-
-  bool operator!=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ generic::basic_endpoint::operator<]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_lt_..operator<..generic::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt__eq_ generic::basic_endpoint::operator<=]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_lt__eq_..operator<=..generic::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ generic::basic_endpoint::operator=]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_eq_..operator=..generic::basic_endpoint] 
-Assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.generic__basic_endpoint.operator_eq_.overload1 operator=]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.generic__basic_endpoint.operator_eq_.overload2 operator=]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.generic__basic_endpoint.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 generic::basic_endpoint::operator= (1 of 2 overloads)]
-
-
-Assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::basic_endpoint::operator= (2 of 2 overloads)]
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ generic::basic_endpoint::operator==]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_eq__eq_..operator==..generic::basic_endpoint] 
-Compare two endpoints for equality. 
-
-
-  bool operator==(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ generic::basic_endpoint::operator>]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_gt_..operator>..generic::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ generic::basic_endpoint::operator>=]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.operator_gt__eq_..operator>=..generic::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol generic::basic_endpoint::protocol]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.protocol..protocol..generic::basic_endpoint] 
-The protocol associated with the endpoint. 
-
-
-  protocol_type protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type generic::basic_endpoint::protocol_type]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.protocol_type..protocol_type..generic::basic_endpoint] 
-The protocol type associated with the endpoint. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:resize generic::basic_endpoint::resize]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.resize..resize..generic::basic_endpoint] 
-Set the underlying size of the endpoint in the native type. 
-
-
-  void resize(
-      std::size_t new_size);
-
-
-
-[endsect]
-
-
-
-[section:size generic::basic_endpoint::size]
-
-[indexterm2 asio.indexterm.generic__basic_endpoint.size..size..generic::basic_endpoint] 
-Get the underlying size of the endpoint in the native type. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:generic__datagram_protocol generic::datagram_protocol]
-
-[indexterm1 asio.indexterm.generic__datagram_protocol..generic::datagram_protocol]
-
-
-Encapsulates the flags needed for a generic datagram-oriented socket. 
-
-
-  class datagram_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__datagram_protocol.endpoint [*endpoint]]]
-    [The type of an endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__datagram_protocol.socket [*socket]]]
-    [The generic socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__datagram_protocol.datagram_protocol [*datagram_protocol]] [constructor]]
-    [Construct a protocol object for a specific address family and protocol. 
-     [hr]
-     Construct a generic protocol object from a specific protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__datagram_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__datagram_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__datagram_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__datagram_protocol.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__datagram_protocol.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__datagram_protocol `generic::datagram_protocol`] class contains flags necessary for datagram-oriented sockets of any address family and protocol.
-
-
-[heading Examples]
-  
-Constructing using a native address family and socket protocol: 
-
-  datagram_protocol p(AF_INET, IPPROTO_UDP); 
-
-
-Constructing from a specific protocol type: 
-
-  datagram_protocol p(asio::ip::udp::v4()); 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:datagram_protocol generic::datagram_protocol::datagram_protocol]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.datagram_protocol..datagram_protocol..generic::datagram_protocol] 
-Construct a protocol object for a specific address family and protocol. 
-
-
-  ``[link asio.reference.generic__datagram_protocol.datagram_protocol.overload1 datagram_protocol]``(
-      int address_family,
-      int socket_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__datagram_protocol.datagram_protocol.overload1 more...]]``
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  ``[link asio.reference.generic__datagram_protocol.datagram_protocol.overload2 datagram_protocol]``(
-      const Protocol & source_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__datagram_protocol.datagram_protocol.overload2 more...]]``
-
-
-[section:overload1 generic::datagram_protocol::datagram_protocol (1 of 2 overloads)]
-
-
-Construct a protocol object for a specific address family and protocol. 
-
-
-  datagram_protocol(
-      int address_family,
-      int socket_protocol);
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::datagram_protocol::datagram_protocol (2 of 2 overloads)]
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  datagram_protocol(
-      const Protocol & source_protocol);
-
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[][]]
-
-]
-
-c bad\_cast Thrown if the source protocol is not datagram-oriented. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:endpoint generic::datagram_protocol::endpoint]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.endpoint..endpoint..generic::datagram_protocol] 
-The type of an endpoint. 
-
-
-  typedef basic_endpoint< datagram_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint from the specified socket address. 
-     [hr]
-     Construct an endpoint from the specific endpoint type. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__basic_endpoint `generic::basic_endpoint`] class template describes an endpoint that may be associated with any socket type.
-
-
-[heading Remarks]
-      
-The socket types sockaddr type must be able to fit into a `sockaddr_storage` structure.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family generic::datagram_protocol::family]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.family..family..generic::datagram_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ generic::datagram_protocol::operator!=]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.operator_not__eq_..operator!=..generic::datagram_protocol] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const datagram_protocol & p1,
-      const datagram_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ generic::datagram_protocol::operator==]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.operator_eq__eq_..operator==..generic::datagram_protocol] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const datagram_protocol & p1,
-      const datagram_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol generic::datagram_protocol::protocol]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.protocol..protocol..generic::datagram_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:socket generic::datagram_protocol::socket]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.socket..socket..generic::datagram_protocol] 
-The generic socket type. 
-
-
-  typedef basic_datagram_socket< datagram_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]] [constructor]]
-    [Construct a basic_datagram_socket without opening it. 
-     [hr]
-     Construct and open a basic_datagram_socket. 
-     [hr]
-     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_datagram_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_datagram_socket from another. 
-     [hr]
-     Move-construct a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_datagram_socket from another. 
-     [hr]
-     Move-assign a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
-    [Receive a datagram with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send_to [*send_to]]]
-    [Send a datagram to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket._basic_datagram_socket [*~basic_datagram_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class template provides asynchronous and blocking datagram-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type generic::datagram_protocol::type]
-
-[indexterm2 asio.indexterm.generic__datagram_protocol.type..type..generic::datagram_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:generic__raw_protocol generic::raw_protocol]
-
-[indexterm1 asio.indexterm.generic__raw_protocol..generic::raw_protocol]
-
-
-Encapsulates the flags needed for a generic raw socket. 
-
-
-  class raw_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__raw_protocol.endpoint [*endpoint]]]
-    [The type of an endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__raw_protocol.socket [*socket]]]
-    [The generic socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__raw_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__raw_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__raw_protocol.raw_protocol [*raw_protocol]] [constructor]]
-    [Construct a protocol object for a specific address family and protocol. 
-     [hr]
-     Construct a generic protocol object from a specific protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__raw_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__raw_protocol.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__raw_protocol.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__raw_protocol `generic::raw_protocol`] class contains flags necessary for raw sockets of any address family and protocol.
-
-
-[heading Examples]
-  
-Constructing using a native address family and socket protocol: 
-
-  raw_protocol p(AF_INET, IPPROTO_ICMP); 
-
-
-Constructing from a specific protocol type: 
-
-  raw_protocol p(asio::ip::icmp::v4()); 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/raw_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint generic::raw_protocol::endpoint]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.endpoint..endpoint..generic::raw_protocol] 
-The type of an endpoint. 
-
-
-  typedef basic_endpoint< raw_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint from the specified socket address. 
-     [hr]
-     Construct an endpoint from the specific endpoint type. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__basic_endpoint `generic::basic_endpoint`] class template describes an endpoint that may be associated with any socket type.
-
-
-[heading Remarks]
-      
-The socket types sockaddr type must be able to fit into a `sockaddr_storage` structure.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/raw_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family generic::raw_protocol::family]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.family..family..generic::raw_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ generic::raw_protocol::operator!=]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.operator_not__eq_..operator!=..generic::raw_protocol] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const raw_protocol & p1,
-      const raw_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/raw_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ generic::raw_protocol::operator==]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.operator_eq__eq_..operator==..generic::raw_protocol] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const raw_protocol & p1,
-      const raw_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/raw_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol generic::raw_protocol::protocol]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.protocol..protocol..generic::raw_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-[section:raw_protocol generic::raw_protocol::raw_protocol]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.raw_protocol..raw_protocol..generic::raw_protocol] 
-Construct a protocol object for a specific address family and protocol. 
-
-
-  ``[link asio.reference.generic__raw_protocol.raw_protocol.overload1 raw_protocol]``(
-      int address_family,
-      int socket_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__raw_protocol.raw_protocol.overload1 more...]]``
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  ``[link asio.reference.generic__raw_protocol.raw_protocol.overload2 raw_protocol]``(
-      const Protocol & source_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__raw_protocol.raw_protocol.overload2 more...]]``
-
-
-[section:overload1 generic::raw_protocol::raw_protocol (1 of 2 overloads)]
-
-
-Construct a protocol object for a specific address family and protocol. 
-
-
-  raw_protocol(
-      int address_family,
-      int socket_protocol);
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::raw_protocol::raw_protocol (2 of 2 overloads)]
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  raw_protocol(
-      const Protocol & source_protocol);
-
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[][]]
-
-]
-
-c bad\_cast Thrown if the source protocol is not raw-oriented. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:socket generic::raw_protocol::socket]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.socket..socket..generic::raw_protocol] 
-The generic socket type. 
-
-
-  typedef basic_raw_socket< raw_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_raw_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]] [constructor]]
-    [Construct a basic_raw_socket without opening it. 
-     [hr]
-     Construct and open a basic_raw_socket. 
-     [hr]
-     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_raw_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_raw_socket from another. 
-     [hr]
-     Move-construct a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_raw_socket from another. 
-     [hr]
-     Move-assign a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive_from [*receive_from]]]
-    [Receive raw data with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send_to [*send_to]]]
-    [Send raw data to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket._basic_raw_socket [*~basic_raw_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_raw_socket `basic_raw_socket`] class template provides asynchronous and blocking raw-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/raw_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type generic::raw_protocol::type]
-
-[indexterm2 asio.indexterm.generic__raw_protocol.type..type..generic::raw_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:generic__seq_packet_protocol generic::seq_packet_protocol]
-
-[indexterm1 asio.indexterm.generic__seq_packet_protocol..generic::seq_packet_protocol]
-
-
-Encapsulates the flags needed for a generic sequenced packet socket. 
-
-
-  class seq_packet_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__seq_packet_protocol.endpoint [*endpoint]]]
-    [The type of an endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__seq_packet_protocol.socket [*socket]]]
-    [The generic socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__seq_packet_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__seq_packet_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__seq_packet_protocol.seq_packet_protocol [*seq_packet_protocol]] [constructor]]
-    [Construct a protocol object for a specific address family and protocol. 
-     [hr]
-     Construct a generic protocol object from a specific protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__seq_packet_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__seq_packet_protocol.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__seq_packet_protocol.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__seq_packet_protocol `generic::seq_packet_protocol`] class contains flags necessary for seq\_packet-oriented sockets of any address family and protocol.
-
-
-[heading Examples]
-  
-Constructing using a native address family and socket protocol: 
-
-  seq_packet_protocol p(AF_INET, IPPROTO_SCTP); 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint generic::seq_packet_protocol::endpoint]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.endpoint..endpoint..generic::seq_packet_protocol] 
-The type of an endpoint. 
-
-
-  typedef basic_endpoint< seq_packet_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint from the specified socket address. 
-     [hr]
-     Construct an endpoint from the specific endpoint type. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__basic_endpoint `generic::basic_endpoint`] class template describes an endpoint that may be associated with any socket type.
-
-
-[heading Remarks]
-      
-The socket types sockaddr type must be able to fit into a `sockaddr_storage` structure.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family generic::seq_packet_protocol::family]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.family..family..generic::seq_packet_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ generic::seq_packet_protocol::operator!=]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.operator_not__eq_..operator!=..generic::seq_packet_protocol] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const seq_packet_protocol & p1,
-      const seq_packet_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ generic::seq_packet_protocol::operator==]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.operator_eq__eq_..operator==..generic::seq_packet_protocol] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const seq_packet_protocol & p1,
-      const seq_packet_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol generic::seq_packet_protocol::protocol]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.protocol..protocol..generic::seq_packet_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-[section:seq_packet_protocol generic::seq_packet_protocol::seq_packet_protocol]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.seq_packet_protocol..seq_packet_protocol..generic::seq_packet_protocol] 
-Construct a protocol object for a specific address family and protocol. 
-
-
-  ``[link asio.reference.generic__seq_packet_protocol.seq_packet_protocol.overload1 seq_packet_protocol]``(
-      int address_family,
-      int socket_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__seq_packet_protocol.seq_packet_protocol.overload1 more...]]``
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  ``[link asio.reference.generic__seq_packet_protocol.seq_packet_protocol.overload2 seq_packet_protocol]``(
-      const Protocol & source_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__seq_packet_protocol.seq_packet_protocol.overload2 more...]]``
-
-
-[section:overload1 generic::seq_packet_protocol::seq_packet_protocol (1 of 2 overloads)]
-
-
-Construct a protocol object for a specific address family and protocol. 
-
-
-  seq_packet_protocol(
-      int address_family,
-      int socket_protocol);
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::seq_packet_protocol::seq_packet_protocol (2 of 2 overloads)]
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  seq_packet_protocol(
-      const Protocol & source_protocol);
-
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[][]]
-
-]
-
-c bad\_cast Thrown if the source protocol is not based around sequenced packets. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:socket generic::seq_packet_protocol::socket]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.socket..socket..generic::seq_packet_protocol] 
-The generic socket type. 
-
-
-  typedef basic_seq_packet_socket< seq_packet_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket [*basic_seq_packet_socket]] [constructor]]
-    [Construct a basic_seq_packet_socket without opening it. 
-     [hr]
-     Construct and open a basic_seq_packet_socket. 
-     [hr]
-     Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_seq_packet_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from another. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_seq_packet_socket from another. 
-     [hr]
-     Move-assign a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket._basic_seq_packet_socket [*~basic_seq_packet_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] class template provides asynchronous and blocking sequenced packet socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type generic::seq_packet_protocol::type]
-
-[indexterm2 asio.indexterm.generic__seq_packet_protocol.type..type..generic::seq_packet_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:generic__stream_protocol generic::stream_protocol]
-
-[indexterm1 asio.indexterm.generic__stream_protocol..generic::stream_protocol]
-
-
-Encapsulates the flags needed for a generic stream-oriented socket. 
-
-
-  class stream_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__stream_protocol.endpoint [*endpoint]]]
-    [The type of an endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__stream_protocol.iostream [*iostream]]]
-    [The generic socket iostream type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__stream_protocol.socket [*socket]]]
-    [The generic socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__stream_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__stream_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__stream_protocol.stream_protocol [*stream_protocol]] [constructor]]
-    [Construct a protocol object for a specific address family and protocol. 
-     [hr]
-     Construct a generic protocol object from a specific protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__stream_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__stream_protocol.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__stream_protocol.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__stream_protocol `generic::stream_protocol`] class contains flags necessary for stream-oriented sockets of any address family and protocol.
-
-
-[heading Examples]
-  
-Constructing using a native address family and socket protocol: 
-
-  stream_protocol p(AF_INET, IPPROTO_TCP); 
-
-
-Constructing from a specific protocol type: 
-
-  stream_protocol p(asio::ip::tcp::v4()); 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint generic::stream_protocol::endpoint]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.endpoint..endpoint..generic::stream_protocol] 
-The type of an endpoint. 
-
-
-  typedef basic_endpoint< stream_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.generic__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint from the specified socket address. 
-     [hr]
-     Construct an endpoint from the specific endpoint type. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.generic__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-The [link asio.reference.generic__basic_endpoint `generic::basic_endpoint`] class template describes an endpoint that may be associated with any socket type.
-
-
-[heading Remarks]
-      
-The socket types sockaddr type must be able to fit into a `sockaddr_storage` structure.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family generic::stream_protocol::family]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.family..family..generic::stream_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:iostream generic::stream_protocol::iostream]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.iostream..iostream..generic::stream_protocol] 
-The generic socket iostream type. 
-
-
-  typedef basic_socket_iostream< stream_protocol > iostream;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration [*duration]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration_type [*duration_type]]]
-    [(Deprecated: Use duration.) The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_point [*time_point]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_type [*time_type]]]
-    [(Deprecated: Use time_point.) The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]] [constructor]]
-    [Construct a basic_socket_iostream without establishing a connection. 
-     [hr]
-     Construct a basic_socket_iostream from the supplied socket. 
-     [hr]
-     Move-construct a basic_socket_iostream from another. 
-     [hr]
-     Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.close [*close]]]
-    [Close the connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.connect [*connect]]]
-    [Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.error [*error]]]
-    [Get the last error associated with the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_after [*expires_after]]]
-    [Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time as an absolute time. 
-     [hr]
-     Set the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expiry [*expiry]]]
-    [Get the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_iostream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
-    [Return a pointer to the underlying streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.socket [*socket]]]
-    [Get a reference to the underlying socket. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ generic::stream_protocol::operator!=]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.operator_not__eq_..operator!=..generic::stream_protocol] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const stream_protocol & p1,
-      const stream_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ generic::stream_protocol::operator==]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.operator_eq__eq_..operator==..generic::stream_protocol] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const stream_protocol & p1,
-      const stream_protocol & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol generic::stream_protocol::protocol]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.protocol..protocol..generic::stream_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:socket generic::stream_protocol::socket]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.socket..socket..generic::stream_protocol] 
-The generic socket type. 
-
-
-  typedef basic_stream_socket< stream_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]] [constructor]]
-    [Construct a basic_stream_socket without opening it. 
-     [hr]
-     Construct and open a basic_stream_socket. 
-     [hr]
-     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_stream_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_stream_socket from another. 
-     [hr]
-     Move-construct a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_socket from another. 
-     [hr]
-     Move-assign a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.read_some [*read_some]]]
-    [Read some data from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.write_some [*write_some]]]
-    [Write some data to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket._basic_stream_socket [*~basic_stream_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_socket `basic_stream_socket`] class template provides asynchronous and blocking stream-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/generic/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:stream_protocol generic::stream_protocol::stream_protocol]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.stream_protocol..stream_protocol..generic::stream_protocol] 
-Construct a protocol object for a specific address family and protocol. 
-
-
-  ``[link asio.reference.generic__stream_protocol.stream_protocol.overload1 stream_protocol]``(
-      int address_family,
-      int socket_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__stream_protocol.stream_protocol.overload1 more...]]``
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  ``[link asio.reference.generic__stream_protocol.stream_protocol.overload2 stream_protocol]``(
-      const Protocol & source_protocol);
-  ``  [''''&raquo;''' [link asio.reference.generic__stream_protocol.stream_protocol.overload2 more...]]``
-
-
-[section:overload1 generic::stream_protocol::stream_protocol (1 of 2 overloads)]
-
-
-Construct a protocol object for a specific address family and protocol. 
-
-
-  stream_protocol(
-      int address_family,
-      int socket_protocol);
-
-
-
-[endsect]
-
-
-
-[section:overload2 generic::stream_protocol::stream_protocol (2 of 2 overloads)]
-
-
-Construct a generic protocol object from a specific protocol. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  stream_protocol(
-      const Protocol & source_protocol);
-
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[][]]
-
-]
-
-c bad\_cast Thrown if the source protocol is not stream-oriented. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:type generic::stream_protocol::type]
-
-[indexterm2 asio.indexterm.generic__stream_protocol.type..type..generic::stream_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:get_associated_allocator get_associated_allocator]
-
-[indexterm1 asio.indexterm.get_associated_allocator..get_associated_allocator]
-
-Helper function to obtain an object's associated allocator. 
-
-  template<
-      typename T>
-  associated_allocator< T >::type ``[link asio.reference.get_associated_allocator.overload1 get_associated_allocator]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_allocator.overload1 more...]]``
-
-  template<
-      typename T,
-      typename Allocator>
-  auto ``[link asio.reference.get_associated_allocator.overload2 get_associated_allocator]``(
-      const T & t,
-      const Allocator & a);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_allocator.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/associated_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 get_associated_allocator (1 of 2 overloads)]
-
-
-Helper function to obtain an object's associated allocator. 
-
-
-  template<
-      typename T>
-  associated_allocator< T >::type get_associated_allocator(
-      const T & t);
-
-
-
-[heading Return Value]
-      
-`associated_allocator<T>::get(t)` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 get_associated_allocator (2 of 2 overloads)]
-
-
-Helper function to obtain an object's associated allocator. 
-
-
-  template<
-      typename T,
-      typename Allocator>
-  auto get_associated_allocator(
-      const T & t,
-      const Allocator & a);
-
-
-
-[heading Return Value]
-      
-`associated_allocator<T, Allocator>::get(t, a)` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:get_associated_cancellation_slot get_associated_cancellation_slot]
-
-[indexterm1 asio.indexterm.get_associated_cancellation_slot..get_associated_cancellation_slot]
-
-Helper function to obtain an object's associated [link asio.reference.cancellation_slot `cancellation_slot`]. 
-
-  template<
-      typename T>
-  associated_cancellation_slot< T >::type ``[link asio.reference.get_associated_cancellation_slot.overload1 get_associated_cancellation_slot]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_cancellation_slot.overload1 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  auto ``[link asio.reference.get_associated_cancellation_slot.overload2 get_associated_cancellation_slot]``(
-      const T & t,
-      const CancellationSlot & st);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_cancellation_slot.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/associated_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 get_associated_cancellation_slot (1 of 2 overloads)]
-
-
-Helper function to obtain an object's associated [link asio.reference.cancellation_slot `cancellation_slot`]. 
-
-
-  template<
-      typename T>
-  associated_cancellation_slot< T >::type get_associated_cancellation_slot(
-      const T & t);
-
-
-
-[heading Return Value]
-      
-`associated_cancellation_slot<T>::get(t)` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 get_associated_cancellation_slot (2 of 2 overloads)]
-
-
-Helper function to obtain an object's associated [link asio.reference.cancellation_slot `cancellation_slot`]. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  auto get_associated_cancellation_slot(
-      const T & t,
-      const CancellationSlot & st);
-
-
-
-[heading Return Value]
-      
-`associated_cancellation_slot<T, CancellationSlot>::get(t, st)` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:get_associated_executor get_associated_executor]
-
-[indexterm1 asio.indexterm.get_associated_executor..get_associated_executor]
-
-Helper function to obtain an object's associated executor. 
-
-  template<
-      typename T>
-  associated_executor< T >::type ``[link asio.reference.get_associated_executor.overload1 get_associated_executor]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_executor.overload1 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  auto ``[link asio.reference.get_associated_executor.overload2 get_associated_executor]``(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_executor.overload2 more...]]``
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  associated_executor< T, typenameExecutionContext::executor_type >::type ``[link asio.reference.get_associated_executor.overload3 get_associated_executor]``(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_executor.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/associated_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 get_associated_executor (1 of 3 overloads)]
-
-
-Helper function to obtain an object's associated executor. 
-
-
-  template<
-      typename T>
-  associated_executor< T >::type get_associated_executor(
-      const T & t);
-
-
-
-[heading Return Value]
-      
-`associated_executor<T>::get(t)` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 get_associated_executor (2 of 3 overloads)]
-
-
-Helper function to obtain an object's associated executor. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  auto get_associated_executor(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Return Value]
-      
-`associated_executor<T, Executor>::get(t, ex)` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 get_associated_executor (3 of 3 overloads)]
-
-
-Helper function to obtain an object's associated executor. 
-
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  associated_executor< T, typenameExecutionContext::executor_type >::type get_associated_executor(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Return Value]
-      
-`associated_executor<T, typename ExecutionContext::executor_type>::get(t, ctx.get_executor())` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:get_associated_immediate_executor get_associated_immediate_executor]
-
-[indexterm1 asio.indexterm.get_associated_immediate_executor..get_associated_immediate_executor]
-
-Helper function to obtain an object's associated executor. 
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  auto ``[link asio.reference.get_associated_immediate_executor.overload1 get_associated_immediate_executor]``(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_immediate_executor.overload1 more...]]``
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  associated_immediate_executor< T, typenameExecutionContext::executor_type >::type ``[link asio.reference.get_associated_immediate_executor.overload2 get_associated_immediate_executor]``(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.get_associated_immediate_executor.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/associated_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 get_associated_immediate_executor (1 of 2 overloads)]
-
-
-Helper function to obtain an object's associated executor. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  auto get_associated_immediate_executor(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Return Value]
-      
-`associated_immediate_executor<T, Executor>::get(t, ex)` 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 get_associated_immediate_executor (2 of 2 overloads)]
-
-
-Helper function to obtain an object's associated executor. 
-
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  associated_immediate_executor< T, typenameExecutionContext::executor_type >::type get_associated_immediate_executor(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Return Value]
-      
-`associated_immediate_executor<T, typename ExecutionContext::executor_type>::get(t, ctx.get_executor())` 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:high_resolution_timer high_resolution_timer]
-
-[indexterm1 asio.indexterm.high_resolution_timer..high_resolution_timer]
-
-Typedef for a timer based on the high resolution clock. 
-
-
-  typedef basic_waitable_timer< chrono::high_resolution_clock > high_resolution_timer;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.duration [*duration]]]
-    [The duration type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.time_point [*time_point]]]
-    [The time point type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
-    [The wait traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
-    [Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expiry [*expiry]]]
-    [Get the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use one of the [link asio.reference.steady_timer `steady_timer`], [link asio.reference.system_timer `system_timer`] or [link asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
-
-
-[heading Remarks]
-      
-This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait (C++11): 
-
-  // Construct a timer without setting an expiry time.
-  asio::steady_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_after(std::chrono::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait (C++11): 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::steady_timer timer(my_context,
-      std::chrono::steady_clock::now() + std::chrono::seconds(60));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active waitable timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_after(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-This typedef uses the C++11 `<chrono>` standard library facility, if available. Otherwise, it may use the Boost.Chrono library. To explicitly utilise Boost.Chrono, use the [link asio.reference.basic_waitable_timer `basic_waitable_timer`] template directly: 
-
-  typedef basic_waitable_timer<boost::chrono::high_resolution_clock> timer;
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/high_resolution_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:immediate_executor_binder immediate_executor_binder]
-
-[indexterm1 asio.indexterm.immediate_executor_binder..immediate_executor_binder]
-
-
-A call wrapper type to bind a immediate executor of type `Executor` to an object of type `T`. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class immediate_executor_binder
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.argument_type [*argument_type]]]
-    [The type of the function's argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.first_argument_type [*first_argument_type]]]
-    [The type of the function's first argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.immediate_executor_type [*immediate_executor_type]]]
-    [The type of the associated immediate executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.result_type [*result_type]]]
-    [The return type if a function. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.second_argument_type [*second_argument_type]]]
-    [The type of the function's second argument. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.immediate_executor_binder.target_type [*target_type]]]
-    [The type of the target object. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.immediate_executor_binder.get [*get]]]
-    [Obtain a reference to the target object. ]
-  ]
-  
-  [
-    [[link asio.reference.immediate_executor_binder.get_immediate_executor [*get_immediate_executor]]]
-    [Obtain the associated immediate executor. ]
-  ]
-  
-  [
-    [[link asio.reference.immediate_executor_binder.immediate_executor_binder [*immediate_executor_binder]] [constructor]]
-    [Construct a immediate executor wrapper for the specified object. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Construct a copy, but specify a different immediate executor. 
-     [hr]
-     Construct a copy of a different immediate executor wrapper type. 
-     [hr]
-     Construct a copy of a different immediate executor wrapper type, but specify a different immediate executor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Move construct the target object, but specify a different immediate executor. 
-     [hr]
-     Move construct from a different immediate executor wrapper type. 
-     [hr]
-     Move construct from a different immediate executor wrapper type, but specify a different immediate executor. ]
-  ]
-  
-  [
-    [[link asio.reference.immediate_executor_binder.operator_lp__rp_ [*operator()]]]
-    [Forwarding function call operator. ]
-  ]
-  
-  [
-    [[link asio.reference.immediate_executor_binder._immediate_executor_binder [*~immediate_executor_binder]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:argument_type immediate_executor_binder::argument_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.argument_type..argument_type..immediate_executor_binder] 
-The type of the function's argument. 
-
-
-  typedef see_below argument_type;
-
-
-
-The type of `argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting a single argument, `argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `argument_type`, then `argument_type` is a synonym for `T::argument_type`;
-
-
-* otherwise `argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:first_argument_type immediate_executor_binder::first_argument_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.first_argument_type..first_argument_type..immediate_executor_binder] 
-The type of the function's first argument. 
-
-
-  typedef see_below first_argument_type;
-
-
-
-The type of `first_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `first_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `first_argument_type` is a synonym for `T::first_argument_type`;
-
-
-* otherwise `first_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:get immediate_executor_binder::get]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.get..get..immediate_executor_binder] 
-Obtain a reference to the target object. 
-
-
-  target_type & ``[link asio.reference.immediate_executor_binder.get.overload1 get]``();
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.get.overload1 more...]]``
-
-  const target_type & ``[link asio.reference.immediate_executor_binder.get.overload2 get]``() const;
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.get.overload2 more...]]``
-
-
-[section:overload1 immediate_executor_binder::get (1 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  target_type & get();
-
-
-
-[endsect]
-
-
-
-[section:overload2 immediate_executor_binder::get (2 of 2 overloads)]
-
-
-Obtain a reference to the target object. 
-
-
-  const target_type & get() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:get_immediate_executor immediate_executor_binder::get_immediate_executor]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.get_immediate_executor..get_immediate_executor..immediate_executor_binder] 
-Obtain the associated immediate executor. 
-
-
-  immediate_executor_type get_immediate_executor() const;
-
-
-
-[endsect]
-
-
-[section:immediate_executor_binder immediate_executor_binder::immediate_executor_binder]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.immediate_executor_binder..immediate_executor_binder..immediate_executor_binder] 
-Construct a immediate executor wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload1 immediate_executor_binder]``(
-      const immediate_executor_type & e,
-      U && u);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload2 immediate_executor_binder]``(
-      const immediate_executor_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload2 more...]]``
-
-
-Construct a copy, but specify a different immediate executor. 
-
-
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload3 immediate_executor_binder]``(
-      const immediate_executor_type & e,
-      const immediate_executor_binder & other);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload3 more...]]``
-
-
-Construct a copy of a different immediate executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload4 immediate_executor_binder]``(
-      const immediate_executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload4 more...]]``
-
-
-Construct a copy of a different immediate executor wrapper type, but specify a different immediate executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload5 immediate_executor_binder]``(
-      const immediate_executor_type & e,
-      const immediate_executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload5 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload6 immediate_executor_binder]``(
-      immediate_executor_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload6 more...]]``
-
-
-Move construct the target object, but specify a different immediate executor. 
-
-
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload7 immediate_executor_binder]``(
-      const immediate_executor_type & e,
-      immediate_executor_binder && other);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload7 more...]]``
-
-
-Move construct from a different immediate executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload8 immediate_executor_binder]``(
-      immediate_executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload8 more...]]``
-
-
-Move construct from a different immediate executor wrapper type, but specify a different immediate executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.immediate_executor_binder.immediate_executor_binder.overload9 immediate_executor_binder]``(
-      const immediate_executor_type & e,
-      immediate_executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.immediate_executor_binder.overload9 more...]]``
-
-
-[section:overload1 immediate_executor_binder::immediate_executor_binder (1 of 9 overloads)]
-
-
-Construct a immediate executor wrapper for the specified object. 
-
-
-  template<
-      typename U>
-  immediate_executor_binder(
-      const immediate_executor_type & e,
-      U && u);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload2 immediate_executor_binder::immediate_executor_binder (2 of 9 overloads)]
-
-
-Copy constructor. 
-
-
-  immediate_executor_binder(
-      const immediate_executor_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 immediate_executor_binder::immediate_executor_binder (3 of 9 overloads)]
-
-
-Construct a copy, but specify a different immediate executor. 
-
-
-  immediate_executor_binder(
-      const immediate_executor_type & e,
-      const immediate_executor_binder & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 immediate_executor_binder::immediate_executor_binder (4 of 9 overloads)]
-
-
-Construct a copy of a different immediate executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  immediate_executor_binder(
-      const immediate_executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the `Executor` type is constructible from type `OtherExecutor`, and the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload5 immediate_executor_binder::immediate_executor_binder (5 of 9 overloads)]
-
-
-Construct a copy of a different immediate executor wrapper type, but specify a different immediate executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  immediate_executor_binder(
-      const immediate_executor_type & e,
-      const immediate_executor_binder< U, OtherExecutor > & other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-This constructor is only valid if the type `T` is constructible from type `U`. 
-
-
-[endsect]
-
-
-
-[section:overload6 immediate_executor_binder::immediate_executor_binder (6 of 9 overloads)]
-
-
-Move constructor. 
-
-
-  immediate_executor_binder(
-      immediate_executor_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload7 immediate_executor_binder::immediate_executor_binder (7 of 9 overloads)]
-
-
-Move construct the target object, but specify a different immediate executor. 
-
-
-  immediate_executor_binder(
-      const immediate_executor_type & e,
-      immediate_executor_binder && other);
-
-
-
-[endsect]
-
-
-
-[section:overload8 immediate_executor_binder::immediate_executor_binder (8 of 9 overloads)]
-
-
-Move construct from a different immediate executor wrapper type. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  immediate_executor_binder(
-      immediate_executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< Executor, OtherExecutor >::value >  = 0,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload9 immediate_executor_binder::immediate_executor_binder (9 of 9 overloads)]
-
-
-Move construct from a different immediate executor wrapper type, but specify a different immediate executor. 
-
-
-  template<
-      typename U,
-      typename ``[link asio.reference.Executor1 OtherExecutor]``>
-  immediate_executor_binder(
-      const immediate_executor_type & e,
-      immediate_executor_binder< U, OtherExecutor > && other,
-      constraint_t< is_constructible< T, U >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:immediate_executor_type immediate_executor_binder::immediate_executor_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.immediate_executor_type..immediate_executor_type..immediate_executor_binder] 
-The type of the associated immediate executor. 
-
-
-  typedef Executor immediate_executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ immediate_executor_binder::operator()]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.operator_lp__rp_..operator()..immediate_executor_binder] 
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.immediate_executor_binder.operator_lp__rp_.overload1 operator()]``(
-      Args &&... args);
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.operator_lp__rp_.overload1 more...]]``
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> ``[link asio.reference.immediate_executor_binder.operator_lp__rp_.overload2 operator()]``(
-      Args &&... args) const;
-  ``  [''''&raquo;''' [link asio.reference.immediate_executor_binder.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 immediate_executor_binder::operator() (1 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args);
-
-
-
-[endsect]
-
-
-
-[section:overload2 immediate_executor_binder::operator() (2 of 2 overloads)]
-
-
-Forwarding function call operator. 
-
-
-  template<
-      typename... Args>
-  result_of_t< T(Args...)> operator()(
-      Args &&... args) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:result_type immediate_executor_binder::result_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.result_type..result_type..immediate_executor_binder] 
-The return type if a function. 
-
-
-  typedef see_below result_type;
-
-
-
-The type of `result_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to function type, `result_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `result_type`, then `result_type` is a synonym for `T::result_type`;
-
-
-* otherwise `result_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:second_argument_type immediate_executor_binder::second_argument_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.second_argument_type..second_argument_type..immediate_executor_binder] 
-The type of the function's second argument. 
-
-
-  typedef see_below second_argument_type;
-
-
-
-The type of `second_argument_type` is based on the type `T` of the wrapper's target object:
-
-
-* if `T` is a pointer to a function type accepting two arguments, `second_argument_type` is a synonym for the return type of `T`;
-
-
-* if `T` is a class type with a member type `first_argument_type`, then `second_argument_type` is a synonym for `T::second_argument_type`;
-
-
-* otherwise `second_argument_type` is not defined. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:target_type immediate_executor_binder::target_type]
-
-[indexterm2 asio.indexterm.immediate_executor_binder.target_type..target_type..immediate_executor_binder] 
-The type of the target object. 
-
-
-  typedef T target_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_immediate_executor_binder immediate_executor_binder::~immediate_executor_binder]
-
-[indexterm2 asio.indexterm.immediate_executor_binder._immediate_executor_binder..~immediate_executor_binder..immediate_executor_binder] 
-Destructor. 
-
-
-  ~immediate_executor_binder();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:invalid_service_owner invalid_service_owner]
-
-[indexterm1 asio.indexterm.invalid_service_owner..invalid_service_owner]
-
-
-Exception thrown when trying to add a service object to an [link asio.reference.execution_context `execution_context`] where the service has a different owner. 
-
-
-  class invalid_service_owner :
-    public std::logic_error
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.invalid_service_owner.invalid_service_owner [*invalid_service_owner]] [constructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:invalid_service_owner invalid_service_owner::invalid_service_owner]
-
-[indexterm2 asio.indexterm.invalid_service_owner.invalid_service_owner..invalid_service_owner..invalid_service_owner] 
-
-  invalid_service_owner();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:io_context io_context]
-
-[indexterm1 asio.indexterm.io_context..io_context]
-
-
-Provides core I/O functionality. 
-
-
-  class io_context :
-    public execution_context
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.io_context__basic_executor_type [*basic_executor_type]]]
-    [Executor implementation type used to submit functions to an io_context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__service [*service]]]
-    [Base class for all io_context services. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__strand [*strand]]]
-    [Provides serialised handler execution. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__work [*work]]]
-    [(Deprecated: Use executor_work_guard.) Class to inform the io_context when it has work to do. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.count_type [*count_type]]]
-    [The type used to count the number of handlers executed by the context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.executor_type [*executor_type]]]
-    [Executor used to submit functions to an io_context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.dispatch [*dispatch]]]
-    [(Deprecated: Use asio::dispatch().) Request the io_context to invoke the given handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.get_executor [*get_executor]]]
-    [Obtains the executor associated with the io_context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.io_context [*io_context]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.poll [*poll]]]
-    [Run the io_context object's event processing loop to execute ready handlers. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute ready handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.poll_one [*poll_one]]]
-    [Run the io_context object's event processing loop to execute one ready handler. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute one ready handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.post [*post]]]
-    [(Deprecated: Use asio::post().) Request the io_context to invoke the given handler and return immediately. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.reset [*reset]]]
-    [(Deprecated: Use restart().) Reset the io_context in preparation for a subsequent run() invocation. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.restart [*restart]]]
-    [Restart the io_context in preparation for a subsequent run() invocation. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run [*run]]]
-    [Run the io_context object's event processing loop. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_for [*run_for]]]
-    [Run the io_context object's event processing loop for a specified duration. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one [*run_one]]]
-    [Run the io_context object's event processing loop to execute at most one handler. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one_for [*run_one_for]]]
-    [Run the io_context object's event processing loop for a specified duration to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one_until [*run_one_until]]]
-    [Run the io_context object's event processing loop until a specified time to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_until [*run_until]]]
-    [Run the io_context object's event processing loop until a specified time. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.stop [*stop]]]
-    [Stop the io_context object's event processing loop. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.stopped [*stopped]]]
-    [Determine whether the io_context object has been stopped. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.wrap [*wrap]]]
-    [(Deprecated: Use asio::bind_executor().) Create a new handler that automatically dispatches the wrapped handler on the io_context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context._io_context [*~io_context]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.use_service [*use_service]]]
-    []
-  ]
-  
-]
-
-The [link asio.reference.io_context `io_context`] class provides the core I/O functionality for users of the asynchronous I/O objects, including:
-
-
-* `asio::ip::tcp::socket` 
-
-* `asio::ip::tcp::acceptor` 
-
-* `asio::ip::udp::socket` 
-
-* [link asio.reference.deadline_timer `deadline_timer`].
-
-The [link asio.reference.io_context `io_context`] class also includes facilities intended for developers of custom asynchronous services.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe, with the specific exceptions of the `restart()` and `notify_fork()` functions. Calling `restart()` while there are unfinished `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` calls results in undefined behaviour. The `notify_fork()` function should not be called while any [link asio.reference.io_context `io_context`] function, or any function on an I/O object that is associated with the [link asio.reference.io_context `io_context`], is being called in another thread.
-
-
-
-[heading Synchronous and asynchronous operations]
-  
-
-
-Synchronous operations on I/O objects implicitly run the [link asio.reference.io_context `io_context`] object for an individual operation. The [link asio.reference.io_context `io_context`] functions `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` must be called for the [link asio.reference.io_context `io_context`] to perform asynchronous operations on behalf of a C++ program. Notification that an asynchronous operation has completed is delivered by invocation of the associated handler. Handlers are invoked only by a thread that is currently calling any overload of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` for the [link asio.reference.io_context `io_context`].
-
-
-[heading Effect of exceptions thrown from handlers]
-  
-
-
-If an exception is thrown from a handler, the exception is allowed to propagate through the throwing thread's invocation of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()`. No other threads that are calling any of these functions are affected. It is then the responsibility of the application to catch the exception.
-
-After the exception has been caught, the `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` call may be restarted ['without] the need for an intervening call to `restart()`. This allows the thread to rejoin the [link asio.reference.io_context `io_context`] object's thread pool without impacting any other threads in the pool.
-
-For example:
-
-
-
-  asio::io_context io_context;
-  ...
-  for (;;)
-  {
-    try
-    {
-      io_context.run();
-      break; // run() exited normally
-    }
-    catch (my_exception& e)
-    {
-      // Deal with exception as appropriate.
-    }
-  }
-
-
-
-
-
-[heading Submitting arbitrary tasks to the io_context]
-  
-
-
-To submit functions to the [link asio.reference.io_context `io_context`], use the [link asio.reference.dispatch `dispatch`], [link asio.reference.post `post`] or [link asio.reference.defer `defer`] free functions.
-
-For example:
-
-
-
-  void my_task()
-  {
-    ...
-  }
-
-  ...
-
-  asio::io_context io_context;
-
-  // Submit a function to the io_context.
-  asio::post(io_context, my_task);
-
-  // Submit a lambda object to the io_context.
-  asio::post(io_context,
-      []()
-      {
-        ...
-      });
-
-  // Run the io_context until it runs out of work.
-  io_context.run(); 
-
-
-
-
-
-[heading Stopping the io_context from running out of work]
-  
-
-
-Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by using the [link asio.reference.make_work_guard `make_work_guard`] function to create an object of type asio::executor\_work\_guard<io\_context::executor\_type>:
-
-
-
-  asio::io_context io_context;
-  asio::executor_work_guard<asio::io_context::executor_type>
-    = asio::make_work_guard(io_context);
-  ... 
-
-
-
-
-To effect a shutdown, the application will then need to call the [link asio.reference.io_context `io_context`] object's `stop()` member function. This will cause the [link asio.reference.io_context `io_context`] `run()` call to return as soon as possible, abandoning unfinished operations and without permitting ready handlers to be dispatched.
-
-Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly reset.
-
-
-
-  asio::io_context io_context;
-  asio::executor_work_guard<asio::io_context::executor_type>
-    = asio::make_work_guard(io_context);
-  ...
-  work.reset(); // Allow run() to exit. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:count_type io_context::count_type]
-
-[indexterm2 asio.indexterm.io_context.count_type..count_type..io_context] 
-The type used to count the number of handlers executed by the context. 
-
-
-  typedef std::size_t count_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:destroy io_context::destroy]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.io_context.destroy..destroy..io_context] 
-Destroys all services in the context. 
-
-
-  void destroy();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order * of the beginning of service object lifetime, performs `delete static_cast<execution_context::service*>(svc)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch io_context::dispatch]
-
-[indexterm2 asio.indexterm.io_context.dispatch..dispatch..io_context] 
-(Deprecated: Use [link asio.reference.dispatch `dispatch`].) Request the [link asio.reference.io_context `io_context`] to invoke the given handler. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto dispatch(
-      LegacyCompletionHandler && handler);
-
-
-This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given handler.
-
-The [link asio.reference.io_context `io_context`] guarantees that the handler will only be called in a thread in which the `run()`, `run_one()`, `poll()` or `poll_one()` member functions is currently being invoked. The handler may be executed inside this function if the guarantee can be met.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be called. The [link asio.reference.io_context `io_context`] will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Remarks]
-      
-This function throws an exception only if:
-
-
-* the handler's associated allocator; or
-
-
-* the handler's copy constructor
-
-throws an exception. 
-
-
-[endsect]
-
-
-
-[section:executor_type io_context::executor_type]
-
-[indexterm2 asio.indexterm.io_context.executor_type..executor_type..io_context] 
-Executor used to submit functions to an [link asio.reference.io_context `io_context`]. 
-
-
-  typedef basic_executor_type< std::allocator< void >, 0 > executor_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__basic_executor_type.basic_executor_type [*basic_executor_type]] [constructor]]
-    [Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.defer [*defer]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.dispatch [*dispatch]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.on_work_finished [*on_work_finished]]]
-    [Inform the io_context that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.on_work_started [*on_work_started]]]
-    [Inform the io_context that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.post [*post]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.query [*query]]]
-    [Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. 
-     [hr]
-     Query the current value of the allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the outstanding_work property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the outstanding_work.tracked property. 
-     [hr]
-     Obtain an executor with the outstanding_work.untracked property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the io_context is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type._basic_executor_type [*~basic_executor_type]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:fork_event io_context::fork_event]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.io_context.fork_event..fork_event..io_context] 
-Fork-related event notifications. 
-
-  enum fork_event
-
-[indexterm2 asio.indexterm.io_context.fork_event.fork_prepare..fork_prepare..io_context]
-[indexterm2 asio.indexterm.io_context.fork_event.fork_parent..fork_parent..io_context]
-[indexterm2 asio.indexterm.io_context.fork_event.fork_child..fork_child..io_context]
-
-[heading Values]
-[variablelist
-
-  [
-    [fork_prepare]
-    [Notify the context that the process is about to fork. ]
-  ]
-
-  [
-    [fork_parent]
-    [Notify the context that the process has forked and is the parent. ]
-  ]
-
-  [
-    [fork_child]
-    [Notify the context that the process has forked and is the child. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:get_executor io_context::get_executor]
-
-[indexterm2 asio.indexterm.io_context.get_executor..get_executor..io_context] 
-Obtains the executor associated with the [link asio.reference.io_context `io_context`]. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-[section:io_context io_context::io_context]
-
-[indexterm2 asio.indexterm.io_context.io_context..io_context..io_context] 
-Constructor. 
-
-
-  ``[link asio.reference.io_context.io_context.overload1 io_context]``();
-  ``  [''''&raquo;''' [link asio.reference.io_context.io_context.overload1 more...]]``
-
-  explicit ``[link asio.reference.io_context.io_context.overload2 io_context]``(
-      int concurrency_hint);
-  ``  [''''&raquo;''' [link asio.reference.io_context.io_context.overload2 more...]]``
-
-
-[section:overload1 io_context::io_context (1 of 2 overloads)]
-
-
-Constructor. 
-
-
-  io_context();
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::io_context (2 of 2 overloads)]
-
-
-Constructor. 
-
-
-  io_context(
-      int concurrency_hint);
-
-
-Construct with a hint about the required level of concurrency.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[concurrency_hint][A suggestion to the implementation on how many threads it should allow to run simultaneously. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:notify_fork io_context::notify_fork]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.io_context.notify_fork..notify_fork..io_context] 
-Notify the [link asio.reference.execution_context `execution_context`] of a fork-related event. 
-
-
-  void notify_fork(
-      fork_event event);
-
-
-This function is used to inform the [link asio.reference.execution_context `execution_context`] that the process is about to fork, or has just forked. This allows the [link asio.reference.execution_context `execution_context`], and the services it contains, to perform any necessary housekeeping to ensure correct operation following a fork.
-
-This function must not be called while any other [link asio.reference.execution_context `execution_context`] function, or any function associated with the [link asio.reference.execution_context `execution_context`]'s derived class, is being called in another thread. It is, however, safe to call this function from within a completion handler, provided no other thread is accessing the [link asio.reference.execution_context `execution_context`] or its derived class.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[event][A fork-related event.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the notification fails the [link asio.reference.execution_context `execution_context`] object should no longer be used and should be destroyed.]]
-
-]
-
-
-[heading Example]
-  
-The following code illustrates how to incorporate the `notify_fork()` function: 
-
-  my_execution_context.notify_fork(execution_context::fork_prepare);
-  if (fork() == 0)
-  {
-    // This is the child process.
-    my_execution_context.notify_fork(execution_context::fork_child);
-  }
-  else
-  {
-    // This is the parent process.
-    my_execution_context.notify_fork(execution_context::fork_parent);
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, performs `svc->notify_fork();`. When processing the fork\_prepare event, services are visited in reverse order of the beginning of service object lifetime. Otherwise, services are visited in order of the beginning of service object lifetime. 
-
-
-
-
-[endsect]
-
-
-[section:poll io_context::poll]
-
-[indexterm2 asio.indexterm.io_context.poll..poll..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute ready handlers. 
-
-
-  count_type ``[link asio.reference.io_context.poll.overload1 poll]``();
-  ``  [''''&raquo;''' [link asio.reference.io_context.poll.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute ready handlers. 
-
-
-  count_type ``[link asio.reference.io_context.poll.overload2 poll]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.io_context.poll.overload2 more...]]``
-
-
-[section:overload1 io_context::poll (1 of 2 overloads)]
-
-
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute ready handlers. 
-
-
-  count_type poll();
-
-
-The `poll()` function runs handlers that are ready to run, without blocking, until the [link asio.reference.io_context `io_context`] has been stopped or there are no more ready handlers.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::poll (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute ready handlers. 
-
-
-  count_type poll(
-      asio::error_code & ec);
-
-
-The `poll()` function runs handlers that are ready to run, without blocking, until the [link asio.reference.io_context `io_context`] has been stopped or there are no more ready handlers.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:poll_one io_context::poll_one]
-
-[indexterm2 asio.indexterm.io_context.poll_one..poll_one..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute one ready handler. 
-
-
-  count_type ``[link asio.reference.io_context.poll_one.overload1 poll_one]``();
-  ``  [''''&raquo;''' [link asio.reference.io_context.poll_one.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute one ready handler. 
-
-
-  count_type ``[link asio.reference.io_context.poll_one.overload2 poll_one]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.io_context.poll_one.overload2 more...]]``
-
-
-[section:overload1 io_context::poll_one (1 of 2 overloads)]
-
-
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute one ready handler. 
-
-
-  count_type poll_one();
-
-
-The `poll_one()` function runs at most one handler that is ready to run, without blocking.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::poll_one (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute one ready handler. 
-
-
-  count_type poll_one(
-      asio::error_code & ec);
-
-
-The `poll_one()` function runs at most one handler that is ready to run, without blocking.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:post io_context::post]
-
-[indexterm2 asio.indexterm.io_context.post..post..io_context] 
-(Deprecated: Use [link asio.reference.post `post`].) Request the [link asio.reference.io_context `io_context`] to invoke the given handler and return immediately. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto post(
-      LegacyCompletionHandler && handler);
-
-
-This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given handler, but without allowing the [link asio.reference.io_context `io_context`] to call the handler from inside this function.
-
-The [link asio.reference.io_context `io_context`] guarantees that the handler will only be called in a thread in which the `run()`, `run_one()`, `poll()` or `poll_one()` member functions is currently being invoked.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be called. The [link asio.reference.io_context `io_context`] will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Remarks]
-      
-This function throws an exception only if:
-
-
-* the handler's associated allocator; or
-
-
-* the handler's copy constructor
-
-throws an exception. 
-
-
-[endsect]
-
-
-
-[section:reset io_context::reset]
-
-[indexterm2 asio.indexterm.io_context.reset..reset..io_context] 
-(Deprecated: Use `restart()`.) Reset the [link asio.reference.io_context `io_context`] in preparation for a subsequent `run()` invocation. 
-
-
-  void reset();
-
-
-This function must be called prior to any second or later set of invocations of the `run()`, `run_one()`, `poll()` or `poll_one()` functions when a previous invocation of these functions returned due to the [link asio.reference.io_context `io_context`] being stopped or running out of work. After a call to `restart()`, the [link asio.reference.io_context `io_context`] object's `stopped()` function will return `false`.
-
-This function must not be called while there are any unfinished calls to the `run()`, `run_one()`, `poll()` or `poll_one()` functions. 
-
-
-[endsect]
-
-
-
-[section:restart io_context::restart]
-
-[indexterm2 asio.indexterm.io_context.restart..restart..io_context] 
-Restart the [link asio.reference.io_context `io_context`] in preparation for a subsequent `run()` invocation. 
-
-
-  void restart();
-
-
-This function must be called prior to any second or later set of invocations of the `run()`, `run_one()`, `poll()` or `poll_one()` functions when a previous invocation of these functions returned due to the [link asio.reference.io_context `io_context`] being stopped or running out of work. After a call to `restart()`, the [link asio.reference.io_context `io_context`] object's `stopped()` function will return `false`.
-
-This function must not be called while there are any unfinished calls to the `run()`, `run_one()`, `poll()` or `poll_one()` functions. 
-
-
-[endsect]
-
-
-[section:run io_context::run]
-
-[indexterm2 asio.indexterm.io_context.run..run..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop. 
-
-
-  count_type ``[link asio.reference.io_context.run.overload1 run]``();
-  ``  [''''&raquo;''' [link asio.reference.io_context.run.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop. 
-
-
-  count_type ``[link asio.reference.io_context.run.overload2 run]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.io_context.run.overload2 more...]]``
-
-
-[section:overload1 io_context::run (1 of 2 overloads)]
-
-
-Run the [link asio.reference.io_context `io_context`] object's event processing loop. 
-
-
-  count_type run();
-
-
-The `run()` function blocks until all work has finished and there are no more handlers to be dispatched, or until the [link asio.reference.io_context `io_context`] has been stopped.
-
-Multiple threads may call the `run()` function to set up a pool of threads from which the [link asio.reference.io_context `io_context`] may execute handlers. All threads that are waiting in the pool are equivalent and the [link asio.reference.io_context `io_context`] may choose any one of them to invoke a handler.
-
-A normal exit from the `run()` function implies that the [link asio.reference.io_context `io_context`] object is stopped (the `stopped()` function returns `true`). Subsequent calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately unless there is a prior call to `restart()`.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed.
-
-
-[heading Remarks]
-      
-Calling the `run()` function from a thread that is currently calling one of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` on the same [link asio.reference.io_context `io_context`] object may introduce the potential for deadlock. It is the caller's reponsibility to avoid this.
-
-The `poll()` function may also be used to dispatch ready handlers, but without blocking. 
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::run (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop. 
-
-
-  count_type run(
-      asio::error_code & ec);
-
-
-The `run()` function blocks until all work has finished and there are no more handlers to be dispatched, or until the [link asio.reference.io_context `io_context`] has been stopped.
-
-Multiple threads may call the `run()` function to set up a pool of threads from which the [link asio.reference.io_context `io_context`] may execute handlers. All threads that are waiting in the pool are equivalent and the [link asio.reference.io_context `io_context`] may choose any one of them to invoke a handler.
-
-A normal exit from the `run()` function implies that the [link asio.reference.io_context `io_context`] object is stopped (the `stopped()` function returns `true`). Subsequent calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately unless there is a prior call to `restart()`.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed.
-
-
-[heading Remarks]
-      
-Calling the `run()` function from a thread that is currently calling one of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` on the same [link asio.reference.io_context `io_context`] object may introduce the potential for deadlock. It is the caller's reponsibility to avoid this.
-
-The `poll()` function may also be used to dispatch ready handlers, but without blocking. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:run_for io_context::run_for]
-
-[indexterm2 asio.indexterm.io_context.run_for..run_for..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop for a specified duration. 
-
-
-  template<
-      typename Rep,
-      typename Period>
-  std::size_t run_for(
-      const chrono::duration< Rep, Period > & rel_time);
-
-
-The `run_for()` function blocks until all work has finished and there are no more handlers to be dispatched, until the [link asio.reference.io_context `io_context`] has been stopped, or until the specified duration has elapsed.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[rel_time][The duration for which the call may block.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-[section:run_one io_context::run_one]
-
-[indexterm2 asio.indexterm.io_context.run_one..run_one..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute at most one handler. 
-
-
-  count_type ``[link asio.reference.io_context.run_one.overload1 run_one]``();
-  ``  [''''&raquo;''' [link asio.reference.io_context.run_one.overload1 more...]]``
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute at most one handler. 
-
-
-  count_type ``[link asio.reference.io_context.run_one.overload2 run_one]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.io_context.run_one.overload2 more...]]``
-
-
-[section:overload1 io_context::run_one (1 of 2 overloads)]
-
-
-Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute at most one handler. 
-
-
-  count_type run_one();
-
-
-The `run_one()` function blocks until one handler has been dispatched, or until the [link asio.reference.io_context `io_context`] has been stopped.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. A zero return value implies that the [link asio.reference.io_context `io_context`] object is stopped (the `stopped()` function returns `true`). Subsequent calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately unless there is a prior call to `restart()`.
-
-
-[heading Remarks]
-      
-Calling the `run_one()` function from a thread that is currently calling one of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` on the same [link asio.reference.io_context `io_context`] object may introduce the potential for deadlock. It is the caller's reponsibility to avoid this. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::run_one (2 of 2 overloads)]
-
-
-(Deprecated: Use non-error\_code overload.) Run the [link asio.reference.io_context `io_context`] object's event processing loop to execute at most one handler. 
-
-
-  count_type run_one(
-      asio::error_code & ec);
-
-
-The `run_one()` function blocks until one handler has been dispatched, or until the [link asio.reference.io_context `io_context`] has been stopped.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. A zero return value implies that the [link asio.reference.io_context `io_context`] object is stopped (the `stopped()` function returns `true`). Subsequent calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately unless there is a prior call to `restart()`.
-
-
-[heading Return Value]
-      
-The number of handlers that were executed.
-
-
-[heading Remarks]
-      
-Calling the `run_one()` function from a thread that is currently calling one of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` on the same [link asio.reference.io_context `io_context`] object may introduce the potential for deadlock. It is the caller's reponsibility to avoid this. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:run_one_for io_context::run_one_for]
-
-[indexterm2 asio.indexterm.io_context.run_one_for..run_one_for..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop for a specified duration to execute at most one handler. 
-
-
-  template<
-      typename Rep,
-      typename Period>
-  std::size_t run_one_for(
-      const chrono::duration< Rep, Period > & rel_time);
-
-
-The `run_one_for()` function blocks until one handler has been dispatched, until the [link asio.reference.io_context `io_context`] has been stopped, or until the specified duration has elapsed.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[rel_time][The duration for which the call may block.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-
-[section:run_one_until io_context::run_one_until]
-
-[indexterm2 asio.indexterm.io_context.run_one_until..run_one_until..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop until a specified time to execute at most one handler. 
-
-
-  template<
-      typename Clock,
-      typename Duration>
-  std::size_t run_one_until(
-      const chrono::time_point< Clock, Duration > & abs_time);
-
-
-The `run_one_until()` function blocks until one handler has been dispatched, until the [link asio.reference.io_context `io_context`] has been stopped, or until the specified time has been reached.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[abs_time][The time point until which the call may block.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-
-[section:run_until io_context::run_until]
-
-[indexterm2 asio.indexterm.io_context.run_until..run_until..io_context] 
-Run the [link asio.reference.io_context `io_context`] object's event processing loop until a specified time. 
-
-
-  template<
-      typename Clock,
-      typename Duration>
-  std::size_t run_until(
-      const chrono::time_point< Clock, Duration > & abs_time);
-
-
-The `run_until()` function blocks until all work has finished and there are no more handlers to be dispatched, until the [link asio.reference.io_context `io_context`] has been stopped, or until the specified time has been reached.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[abs_time][The time point until which the call may block.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of handlers that were executed. 
-
-
-
-
-[endsect]
-
-
-
-[section:shutdown io_context::shutdown]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.io_context.shutdown..shutdown..io_context] 
-Shuts down all services in the context. 
-
-
-  void shutdown();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order of the beginning of service object lifetime, performs `svc->shutdown()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:stop io_context::stop]
-
-[indexterm2 asio.indexterm.io_context.stop..stop..io_context] 
-Stop the [link asio.reference.io_context `io_context`] object's event processing loop. 
-
-
-  void stop();
-
-
-This function does not block, but instead simply signals the [link asio.reference.io_context `io_context`] to stop. All invocations of its `run()` or `run_one()` member functions should return as soon as possible. Subsequent calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately until `restart()` is called. 
-
-
-[endsect]
-
-
-
-[section:stopped io_context::stopped]
-
-[indexterm2 asio.indexterm.io_context.stopped..stopped..io_context] 
-Determine whether the [link asio.reference.io_context `io_context`] object has been stopped. 
-
-
-  bool stopped() const;
-
-
-This function is used to determine whether an [link asio.reference.io_context `io_context`] object has been stopped, either through an explicit call to `stop()`, or due to running out of work. When an [link asio.reference.io_context `io_context`] object is stopped, calls to `run()`, `run_one()`, `poll()` or `poll_one()` will return immediately without invoking any handlers.
-
-
-[heading Return Value]
-      
-`true` if the [link asio.reference.io_context `io_context`] object is stopped, otherwise `false`. 
-
-
-
-
-[endsect]
-
-
-
-[section:use_service io_context::use_service]
-
-[indexterm2 asio.indexterm.io_context.use_service..use_service..io_context] 
-
-  template<
-      typename ``[link asio.reference.Service Service]``>
-  Service & use_service(
-      io_context & ioc);
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:wrap io_context::wrap]
-
-[indexterm2 asio.indexterm.io_context.wrap..wrap..io_context] 
-(Deprecated: Use [link asio.reference.bind_executor `bind_executor`].) Create a new handler that automatically dispatches the wrapped handler on the [link asio.reference.io_context `io_context`]. 
-
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``>
-  unspecified wrap(
-      Handler handler);
-
-
-This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the [link asio.reference.io_context `io_context`] object's dispatch function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be wrapped. The [link asio.reference.io_context `io_context`] will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(A1 a1, ... An an); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-A function object that, when invoked, passes the wrapped handler to the [link asio.reference.io_context `io_context`] object's dispatch function. Given a function object with the signature: 
-
-  R f(A1 a1, ... An an); 
-
-
-If this function object is passed to the wrap function like so: 
-
-  io_context.wrap(f); 
-
-
-then the return value is a function object with the signature 
-
-  void g(A1 a1, ... An an); 
-
-
-that, when invoked, executes code equivalent to: 
-
-  io_context.dispatch(boost::bind(f, a1, ... an)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:_io_context io_context::~io_context]
-
-[indexterm2 asio.indexterm.io_context._io_context..~io_context..io_context] 
-Destructor. 
-
-
-  ~io_context();
-
-
-On destruction, the [link asio.reference.io_context `io_context`] performs the following sequence of operations:
-
-
-* For each service object `svc` in the [link asio.reference.io_context `io_context`] set, in reverse order of the beginning of service object lifetime, performs `svc->shutdown()`.
-
-
-* Uninvoked handler objects that were scheduled for deferred invocation on the [link asio.reference.io_context `io_context`], or any associated strand, are destroyed.
-
-
-* For each service object `svc` in the [link asio.reference.io_context `io_context`] set, in reverse order of the beginning of service object lifetime, performs `delete static_cast<io_context::service*>(svc)`.
-
-
-[heading Remarks]
-      
-The destruction sequence described above permits programs to simplify their resource management by using `shared_ptr<>`. Where an object's lifetime is tied to the lifetime of a connection (or some other sequence of asynchronous operations), a `shared_ptr` to the object would be bound into the handlers for all asynchronous operations associated with it. This works as follows:
-
-
-* When a single connection ends, all associated asynchronous operations complete. The corresponding handler objects are destroyed, and all `shared_ptr` references to the objects are destroyed.
-
-
-* To shut down the whole program, the [link asio.reference.io_context `io_context`] function `stop()` is called to terminate any `run()` calls as soon as possible. The [link asio.reference.io_context `io_context`] destructor defined above destroys all handlers, causing all `shared_ptr` references to all connection objects to be destroyed. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:io_context__basic_executor_type io_context::basic_executor_type]
-
-[indexterm1 asio.indexterm.io_context__basic_executor_type..io_context::basic_executor_type]
-
-
-Executor implementation type used to submit functions to an [link asio.reference.io_context `io_context`]. 
-
-
-  template<
-      typename Allocator,
-      uintptr_t Bits>
-  class basic_executor_type :
-    Allocator
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__basic_executor_type.basic_executor_type [*basic_executor_type]] [constructor]]
-    [Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.defer [*defer]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.dispatch [*dispatch]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.on_work_finished [*on_work_finished]]]
-    [Inform the io_context that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.on_work_started [*on_work_started]]]
-    [Inform the io_context that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.post [*post]]]
-    [Request the io_context to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.query [*query]]]
-    [Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. 
-     [hr]
-     Query the current value of the allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the outstanding_work property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the outstanding_work.tracked property. 
-     [hr]
-     Obtain an executor with the outstanding_work.untracked property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the io_context is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type._basic_executor_type [*~basic_executor_type]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__basic_executor_type.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_executor_type io_context::basic_executor_type::basic_executor_type]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.basic_executor_type..basic_executor_type..io_context::basic_executor_type] 
-Copy constructor. 
-
-
-  ``[link asio.reference.io_context__basic_executor_type.basic_executor_type.overload1 basic_executor_type]``(
-      const basic_executor_type & other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.basic_executor_type.overload1 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.io_context__basic_executor_type.basic_executor_type.overload2 basic_executor_type]``(
-      basic_executor_type && other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.basic_executor_type.overload2 more...]]``
-
-
-[section:overload1 io_context::basic_executor_type::basic_executor_type (1 of 2 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_executor_type(
-      const basic_executor_type & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::basic_executor_type::basic_executor_type (2 of 2 overloads)]
-
-
-Move constructor. 
-
-
-  basic_executor_type(
-      basic_executor_type && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:context io_context::basic_executor_type::context]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.context..context..io_context::basic_executor_type] 
-Obtain the underlying execution context. 
-
-
-  io_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer io_context::basic_executor_type::defer]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.defer..defer..io_context::basic_executor_type] 
-Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void defer(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. The function object will never be executed inside `defer()`. Instead, it will be scheduled to run on the [link asio.reference.io_context `io_context`].
-
-If the current thread belongs to the [link asio.reference.io_context `io_context`], `defer()` will delay scheduling the function object until the current thread returns control to the pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch io_context::basic_executor_type::dispatch]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.dispatch..dispatch..io_context::basic_executor_type] 
-Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void dispatch(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. If the current thread is running the [link asio.reference.io_context `io_context`], `dispatch()` executes the function before returning. Otherwise, the function will be scheduled to run on the [link asio.reference.io_context `io_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:execute io_context::basic_executor_type::execute]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.execute..execute..io_context::basic_executor_type] 
-Execution function. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-
-[endsect]
-
-
-
-[section:on_work_finished io_context::basic_executor_type::on_work_finished]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.on_work_finished..on_work_finished..io_context::basic_executor_type] 
-Inform the [link asio.reference.io_context `io_context`] that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-This function is used to inform the [link asio.reference.io_context `io_context`] that some work has finished. Once the count of unfinished work reaches zero, the [link asio.reference.io_context `io_context`] is stopped and the `run()` and `run_one()` functions may exit. 
-
-
-[endsect]
-
-
-
-[section:on_work_started io_context::basic_executor_type::on_work_started]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.on_work_started..on_work_started..io_context::basic_executor_type] 
-Inform the [link asio.reference.io_context `io_context`] that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-This function is used to inform the [link asio.reference.io_context `io_context`] that some work has begun. This ensures that the [link asio.reference.io_context `io_context`]'s `run()` and `run_one()` functions do not exit while the work is underway. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ io_context::basic_executor_type::operator!=]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_not__eq_..operator!=..io_context::basic_executor_type] 
-Compare two executors for inequality. 
-
-
-  bool operator!=(
-      const basic_executor_type & a,
-      const basic_executor_type & b);
-
-
-Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ io_context::basic_executor_type::operator=]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_eq_..operator=..io_context::basic_executor_type] 
-Assignment operator. 
-
-
-  basic_executor_type & ``[link asio.reference.io_context__basic_executor_type.operator_eq_.overload1 operator=]``(
-      const basic_executor_type & other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_executor_type & ``[link asio.reference.io_context__basic_executor_type.operator_eq_.overload2 operator=]``(
-      basic_executor_type && other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 io_context::basic_executor_type::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_executor_type & operator=(
-      const basic_executor_type & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::basic_executor_type::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_executor_type & operator=(
-      basic_executor_type && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ io_context::basic_executor_type::operator==]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.operator_eq__eq_..operator==..io_context::basic_executor_type] 
-Compare two executors for equality. 
-
-
-  bool operator==(
-      const basic_executor_type & a,
-      const basic_executor_type & b);
-
-
-Two executors are equal if they refer to the same underlying [link asio.reference.io_context `io_context`]. 
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post io_context::basic_executor_type::post]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.post..post..io_context::basic_executor_type] 
-Request the [link asio.reference.io_context `io_context`] to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void post(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the [link asio.reference.io_context `io_context`] to execute the given function object. The function object will never be executed inside `post()`. Instead, it will be scheduled to run on the [link asio.reference.io_context `io_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:query io_context::basic_executor_type::query]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.query..query..io_context::basic_executor_type] 
-Query the current value of the `context` property. 
-
-
-  io_context & ``[link asio.reference.io_context__basic_executor_type.query.overload1 query]``(
-      execution::context_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload1 more...]]``
-
-
-Query the current value of the `blocking` property. 
-
-
-  constexpr execution::blocking_t ``[link asio.reference.io_context__basic_executor_type.query.overload2 query]``(
-      execution::blocking_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload2 more...]]``
-
-
-Query the current value of the `relationship` property. 
-
-
-  constexpr execution::relationship_t ``[link asio.reference.io_context__basic_executor_type.query.overload3 query]``(
-      execution::relationship_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload3 more...]]``
-
-
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator ``[link asio.reference.io_context__basic_executor_type.query.overload4 query]``(
-      execution::allocator_t< OtherAllocator > ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload4 more...]]``
-
-  constexpr Allocator ``[link asio.reference.io_context__basic_executor_type.query.overload5 query]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query.overload5 more...]]``
-
-
-[section:overload1 io_context::basic_executor_type::query (1 of 5 overloads)]
-
-
-Query the current value of the `context` property. 
-
-
-  io_context & query(
-      execution::context_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  asio::io_context& ctx = asio::query(
-      ex, asio::execution::context); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::basic_executor_type::query (2 of 5 overloads)]
-
-
-Query the current value of the `blocking` property. 
-
-
-  constexpr execution::blocking_t query(
-      execution::blocking_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  if (asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.always)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 io_context::basic_executor_type::query (3 of 5 overloads)]
-
-
-Query the current value of the `relationship` property. 
-
-
-  constexpr execution::relationship_t query(
-      execution::relationship_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  if (asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.continuation)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 io_context::basic_executor_type::query (4 of 5 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t< OtherAllocator > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 io_context::basic_executor_type::query (5 of 5 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  constexpr Allocator query(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:query__static io_context::basic_executor_type::query]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.query__static..query..io_context::basic_executor_type] 
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t ``[link asio.reference.io_context__basic_executor_type.query__static.overload1 query]``(
-      execution::mapping_t );
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query__static.overload1 more...]]``
-
-
-Query the current value of the `outstanding_work` property. 
-
-
-  static constexpr execution::outstanding_work_t ``[link asio.reference.io_context__basic_executor_type.query__static.overload2 query]``(
-      execution::outstanding_work_t );
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.query__static.overload2 more...]]``
-
-
-[section:overload1 io_context::basic_executor_type::query (1 of 2 overloads)]
-
-
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t query(
-      execution::mapping_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  if (asio::query(ex, asio::execution::mapping)
-        == asio::execution::mapping.thread)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::basic_executor_type::query (2 of 2 overloads)]
-
-
-Query the current value of the `outstanding_work` property. 
-
-
-  static constexpr execution::outstanding_work_t query(
-      execution::outstanding_work_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_io_context.get_executor();
-  if (asio::query(ex, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.tracked)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:require io_context::basic_executor_type::require]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.require..require..io_context::basic_executor_type] 
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload1 require]``(
-      execution::blocking_t::possibly_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload1 more...]]``
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload2 require]``(
-      execution::blocking_t::never_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload2 more...]]``
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload3 require]``(
-      execution::relationship_t::fork_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload3 more...]]``
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.io_context__basic_executor_type.require.overload4 require]``(
-      execution::relationship_t::continuation_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload4 more...]]``
-
-
-Obtain an executor with the `outstanding_work.tracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.io_context__basic_executor_type.require.overload5 require]``(
-      execution::outstanding_work_t::tracked_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload5 more...]]``
-
-
-Obtain an executor with the `outstanding_work.untracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.io_context__basic_executor_type.require.overload6 require]``(
-      execution::outstanding_work_t::untracked_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload6 more...]]``
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr basic_executor_type< OtherAllocator, Bits > ``[link asio.reference.io_context__basic_executor_type.require.overload7 require]``(
-      execution::allocator_t< OtherAllocator > a) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload7 more...]]``
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  constexpr basic_executor_type< std::allocator< void >, Bits > ``[link asio.reference.io_context__basic_executor_type.require.overload8 require]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__basic_executor_type.require.overload8 more...]]``
-
-
-[section:overload1 io_context::basic_executor_type::require (1 of 8 overloads)]
-
-
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::blocking_t::possibly_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::basic_executor_type::require (2 of 8 overloads)]
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::blocking_t::never_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.never); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 io_context::basic_executor_type::require (3 of 8 overloads)]
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::relationship_t::fork_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.fork); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 io_context::basic_executor_type::require (4 of 8 overloads)]
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::relationship_t::continuation_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.continuation); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 io_context::basic_executor_type::require (5 of 8 overloads)]
-
-
-Obtain an executor with the `outstanding_work.tracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::outstanding_work_t::tracked_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::outstanding_work.tracked); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 io_context::basic_executor_type::require (6 of 8 overloads)]
-
-
-Obtain an executor with the `outstanding_work.untracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::outstanding_work_t::untracked_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::outstanding_work.untracked); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 io_context::basic_executor_type::require (7 of 8 overloads)]
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr basic_executor_type< OtherAllocator, Bits > require(
-      execution::allocator_t< OtherAllocator > a) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator(my_allocator)); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 io_context::basic_executor_type::require (8 of 8 overloads)]
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  constexpr basic_executor_type< std::allocator< void >, Bits > require(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_io_context.get_executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:running_in_this_thread io_context::basic_executor_type::running_in_this_thread]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type.running_in_this_thread..running_in_this_thread..io_context::basic_executor_type] 
-Determine whether the [link asio.reference.io_context `io_context`] is running in the current thread. 
-
-
-  bool running_in_this_thread() const;
-
-
-
-[heading Return Value]
-      
-`true` if the current thread is running the [link asio.reference.io_context `io_context`]. Otherwise returns `false`. 
-
-
-
-
-[endsect]
-
-
-
-[section:_basic_executor_type io_context::basic_executor_type::~basic_executor_type]
-
-[indexterm2 asio.indexterm.io_context__basic_executor_type._basic_executor_type..~basic_executor_type..io_context::basic_executor_type] 
-Destructor. 
-
-
-  ~basic_executor_type();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:io_context__service io_context::service]
-
-[indexterm1 asio.indexterm.io_context__service..io_context::service]
-
-
-Base class for all [link asio.reference.io_context `io_context`] services. 
-
-
-  class service :
-    public execution_context::service
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__service.context [*context]]]
-    [Get the context object that owns the service. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__service.get_io_context [*get_io_context]]]
-    [Get the io_context object that owns the service. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__service.service [*service]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__service._service [*~service]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:context io_context::service::context]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.io_context__service.context..context..io_context::service] 
-Get the context object that owns the service. 
-
-
-  execution_context & context();
-
-
-
-[endsect]
-
-
-
-[section:get_io_context io_context::service::get_io_context]
-
-[indexterm2 asio.indexterm.io_context__service.get_io_context..get_io_context..io_context::service] 
-Get the [link asio.reference.io_context `io_context`] object that owns the service. 
-
-
-  asio::io_context & get_io_context();
-
-
-
-[endsect]
-
-
-
-[section:service io_context::service::service]
-
-[indexterm2 asio.indexterm.io_context__service.service..service..io_context::service] 
-Constructor. 
-
-
-  service(
-      asio::io_context & owner);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[owner][The [link asio.reference.io_context `io_context`] object that owns the service. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:_service io_context::service::~service]
-
-[indexterm2 asio.indexterm.io_context__service._service..~service..io_context::service] 
-Destructor. 
-
-
-  virtual ~service();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:io_context__strand io_context::strand]
-
-[indexterm1 asio.indexterm.io_context__strand..io_context::strand]
-
-
-Provides serialised handler execution. 
-
-
-  class strand
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__strand.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.defer [*defer]]]
-    [Request the strand to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.dispatch [*dispatch]]]
-    [Request the strand to invoke the given function object. 
-     [hr]
-     (Deprecated: Use asio::dispatch().) Request the strand to invoke the given handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.on_work_finished [*on_work_finished]]]
-    [Inform the strand that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.on_work_started [*on_work_started]]]
-    [Inform the strand that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.post [*post]]]
-    [Request the strand to invoke the given function object. 
-     [hr]
-     (Deprecated: Use asio::post().) Request the strand to invoke the given handler and return immediately. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the strand is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.strand [*strand]] [constructor]]
-    [Constructor. 
-     [hr]
-     Copy constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.wrap [*wrap]]]
-    [(Deprecated: Use asio::bind_executor().) Create a new handler that automatically dispatches the wrapped handler on the strand. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand._strand [*~strand]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__strand.operator_not__eq_ [*operator!=]]]
-    [Compare two strands for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__strand.operator_eq__eq_ [*operator==]]]
-    [Compare two strands for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.io_context__strand `io_context::strand`] class provides the ability to post and dispatch handlers with the guarantee that none of those handlers will execute concurrently.
-
-
-[heading Order of handler invocation]
-  
-Given:
-
-
-* a strand object `s` 
-
-
-* an object `a` meeting completion handler requirements
-
-
-* an object `a1` which is an arbitrary copy of `a` made by the implementation
-
-
-* an object `b` meeting completion handler requirements
-
-
-* an object `b1` which is an arbitrary copy of `b` made by the implementation
-
-if any of the following conditions are true:
-
-
-* `s.post(a)` happens-before `s.post(b)` 
-
-
-* `s.post(a)` happens-before `s.dispatch(b)`, where the latter is performed outside the strand
-
-
-* `s.dispatch(a)` happens-before `s.post(b)`, where the former is performed outside the strand
-
-
-* `s.dispatch(a)` happens-before `s.dispatch(b)`, where both are performed outside the strand
-
-then `a()` happens-before `b()` 
-
-Note that in the following case: 
-
-  async_op_1(..., s.wrap(a));
-  async_op_2(..., s.wrap(b)); 
-
-
-the completion of the first async operation will perform `s.dispatch(a)`, and the second will perform `s.dispatch(b)`, but the order in which those are performed is unspecified. That is, you cannot state whether one happens-before the other. Therefore none of the above conditions are met and no ordering guarantee is made.
-
-
-[heading Remarks]
-      
-The implementation makes no guarantee that handlers posted or dispatched through different `strand` objects will be invoked concurrently.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_context_strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:context io_context::strand::context]
-
-[indexterm2 asio.indexterm.io_context__strand.context..context..io_context::strand] 
-Obtain the underlying execution context. 
-
-
-  asio::io_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer io_context::strand::defer]
-
-[indexterm2 asio.indexterm.io_context__strand.defer..defer..io_context::strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void defer(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run by the underlying [link asio.reference.io_context `io_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:dispatch io_context::strand::dispatch]
-
-[indexterm2 asio.indexterm.io_context__strand.dispatch..dispatch..io_context::strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void ``[link asio.reference.io_context__strand.dispatch.overload1 dispatch]``(
-      Function && f,
-      const Allocator & a) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.dispatch.overload1 more...]]``
-
-
-(Deprecated: Use [link asio.reference.dispatch `dispatch`].) Request the strand to invoke the given handler. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto ``[link asio.reference.io_context__strand.dispatch.overload2 dispatch]``(
-      LegacyCompletionHandler && handler);
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.dispatch.overload2 more...]]``
-
-
-[section:overload1 io_context::strand::dispatch (1 of 2 overloads)]
-
-
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void dispatch(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the strand to execute the given function object on its underlying [link asio.reference.io_context `io_context`]. The function object will be executed inside this function if the strand is not otherwise busy and if the underlying [link asio.reference.io_context `io_context`]'s executor's `dispatch()` function is also able to execute the function before returning.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::strand::dispatch (2 of 2 overloads)]
-
-
-(Deprecated: Use [link asio.reference.dispatch `dispatch`].) Request the strand to invoke the given handler. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto dispatch(
-      LegacyCompletionHandler && handler);
-
-
-This function is used to ask the strand to execute the given handler.
-
-The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The handler may be executed inside this function if the guarantee can be met. If this function is called from within a handler that was posted or dispatched through the same strand, then the new handler will be executed immediately.
-
-The strand's guarantee is in addition to the guarantee provided by the underlying [link asio.reference.io_context `io_context`]. The [link asio.reference.io_context `io_context`] guarantees that the handler will only be called in a thread in which the [link asio.reference.io_context `io_context`]'s run member function is currently being invoked.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:on_work_finished io_context::strand::on_work_finished]
-
-[indexterm2 asio.indexterm.io_context__strand.on_work_finished..on_work_finished..io_context::strand] 
-Inform the strand that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-The strand delegates this call to its underlying [link asio.reference.io_context `io_context`]. 
-
-
-[endsect]
-
-
-
-[section:on_work_started io_context::strand::on_work_started]
-
-[indexterm2 asio.indexterm.io_context__strand.on_work_started..on_work_started..io_context::strand] 
-Inform the strand that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-The strand delegates this call to its underlying [link asio.reference.io_context `io_context`]. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ io_context::strand::operator!=]
-
-[indexterm2 asio.indexterm.io_context__strand.operator_not__eq_..operator!=..io_context::strand] 
-Compare two strands for inequality. 
-
-
-  bool operator!=(
-      const strand & a,
-      const strand & b);
-
-
-Two strands are equal if they refer to the same ordered, non-concurrent state. 
-
-[heading Requirements]
-
-['Header: ][^asio/io_context_strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ io_context::strand::operator==]
-
-[indexterm2 asio.indexterm.io_context__strand.operator_eq__eq_..operator==..io_context::strand] 
-Compare two strands for equality. 
-
-
-  bool operator==(
-      const strand & a,
-      const strand & b);
-
-
-Two strands are equal if they refer to the same ordered, non-concurrent state. 
-
-[heading Requirements]
-
-['Header: ][^asio/io_context_strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:post io_context::strand::post]
-
-[indexterm2 asio.indexterm.io_context__strand.post..post..io_context::strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void ``[link asio.reference.io_context__strand.post.overload1 post]``(
-      Function && f,
-      const Allocator & a) const;
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.post.overload1 more...]]``
-
-
-(Deprecated: Use [link asio.reference.post `post`].) Request the strand to invoke the given handler and return immediately. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto ``[link asio.reference.io_context__strand.post.overload2 post]``(
-      LegacyCompletionHandler && handler);
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.post.overload2 more...]]``
-
-
-[section:overload1 io_context::strand::post (1 of 2 overloads)]
-
-
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void post(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled to run by the underlying [link asio.reference.io_context `io_context`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::strand::post (2 of 2 overloads)]
-
-
-(Deprecated: Use [link asio.reference.post `post`].) Request the strand to invoke the given handler and return immediately. 
-
-
-  template<
-      typename ``[link asio.reference.LegacyCompletionHandler LegacyCompletionHandler]``>
-  auto post(
-      LegacyCompletionHandler && handler);
-
-
-This function is used to ask the strand to execute the given handler, but without allowing the strand to call the handler from inside this function.
-
-The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The strand's guarantee is in addition to the guarantee provided by the underlying [link asio.reference.io_context `io_context`]. The [link asio.reference.io_context `io_context`] guarantees that the handler will only be called in a thread in which the [link asio.reference.io_context `io_context`]'s run member function is currently being invoked.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:running_in_this_thread io_context::strand::running_in_this_thread]
-
-[indexterm2 asio.indexterm.io_context__strand.running_in_this_thread..running_in_this_thread..io_context::strand] 
-Determine whether the strand is running in the current thread. 
-
-
-  bool running_in_this_thread() const;
-
-
-
-[heading Return Value]
-      
-`true` if the current thread is executing a handler that was submitted to the strand using `post()`, `dispatch()` or `wrap()`. Otherwise returns `false`. 
-
-
-
-
-[endsect]
-
-
-[section:strand io_context::strand::strand]
-
-[indexterm2 asio.indexterm.io_context__strand.strand..strand..io_context::strand] 
-Constructor. 
-
-
-  explicit ``[link asio.reference.io_context__strand.strand.overload1 strand]``(
-      asio::io_context & io_context);
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.strand.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.io_context__strand.strand.overload2 strand]``(
-      const strand & other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__strand.strand.overload2 more...]]``
-
-
-[section:overload1 io_context::strand::strand (1 of 2 overloads)]
-
-
-Constructor. 
-
-
-  strand(
-      asio::io_context & io_context);
-
-
-Constructs the strand.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[io_context][The [link asio.reference.io_context `io_context`] object that the strand will use to dispatch handlers that are ready to be run. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::strand::strand (2 of 2 overloads)]
-
-
-Copy constructor. 
-
-
-  strand(
-      const strand & other);
-
-
-Creates a copy such that both strand objects share the same underlying state. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wrap io_context::strand::wrap]
-
-[indexterm2 asio.indexterm.io_context__strand.wrap..wrap..io_context::strand] 
-(Deprecated: Use [link asio.reference.bind_executor `bind_executor`].) Create a new handler that automatically dispatches the wrapped handler on the strand. 
-
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``>
-  unspecified wrap(
-      Handler handler);
-
-
-This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the strand's dispatch function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][The handler to be wrapped. The strand will make a copy of the handler object as required. The function signature of the handler must be: 
-``
-  void handler(A1 a1, ... An an); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-A function object that, when invoked, passes the wrapped handler to the strand's dispatch function. Given a function object with the signature: 
-
-  R f(A1 a1, ... An an); 
-
-
-If this function object is passed to the wrap function like so: 
-
-  strand.wrap(f); 
-
-
-then the return value is a function object with the signature 
-
-  void g(A1 a1, ... An an); 
-
-
-that, when invoked, executes code equivalent to: 
-
-  strand.dispatch(boost::bind(f, a1, ... an)); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:_strand io_context::strand::~strand]
-
-[indexterm2 asio.indexterm.io_context__strand._strand..~strand..io_context::strand] 
-Destructor. 
-
-
-  ~strand();
-
-
-Destroys a strand.
-
-Handlers posted through the strand that have not yet been invoked will still be dispatched in a way that meets the guarantee of non-concurrency. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:io_context__work io_context::work]
-
-[indexterm1 asio.indexterm.io_context__work..io_context::work]
-
-
-(Deprecated: Use [link asio.reference.executor_work_guard `executor_work_guard`].) Class to inform the [link asio.reference.io_context `io_context`] when it has work to do. 
-
-
-  class work
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context__work.get_io_context [*get_io_context]]]
-    [Get the io_context associated with the work. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__work.work [*work]] [constructor]]
-    [Constructor notifies the io_context that work is starting. 
-     [hr]
-     Copy constructor notifies the io_context that work is starting. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context__work._work [*~work]] [destructor]]
-    [Destructor notifies the io_context that the work is complete. ]
-  ]
-  
-]
-
-The work class is used to inform the [link asio.reference.io_context `io_context`] when work starts and finishes. This ensures that the [link asio.reference.io_context `io_context`] object's `run()` function will not exit while work is underway, and that it does exit when there is no unfinished work remaining.
-
-The work class is copy-constructible so that it may be used as a data member in a handler class. It is not assignable. 
-
-[heading Requirements]
-
-['Header: ][^asio/io_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:get_io_context io_context::work::get_io_context]
-
-[indexterm2 asio.indexterm.io_context__work.get_io_context..get_io_context..io_context::work] 
-Get the [link asio.reference.io_context `io_context`] associated with the work. 
-
-
-  asio::io_context & get_io_context();
-
-
-
-[endsect]
-
-
-[section:work io_context::work::work]
-
-[indexterm2 asio.indexterm.io_context__work.work..work..io_context::work] 
-Constructor notifies the [link asio.reference.io_context `io_context`] that work is starting. 
-
-
-  explicit ``[link asio.reference.io_context__work.work.overload1 work]``(
-      asio::io_context & io_context);
-  ``  [''''&raquo;''' [link asio.reference.io_context__work.work.overload1 more...]]``
-
-
-Copy constructor notifies the [link asio.reference.io_context `io_context`] that work is starting. 
-
-
-  ``[link asio.reference.io_context__work.work.overload2 work]``(
-      const work & other);
-  ``  [''''&raquo;''' [link asio.reference.io_context__work.work.overload2 more...]]``
-
-
-[section:overload1 io_context::work::work (1 of 2 overloads)]
-
-
-Constructor notifies the [link asio.reference.io_context `io_context`] that work is starting. 
-
-
-  work(
-      asio::io_context & io_context);
-
-
-The constructor is used to inform the [link asio.reference.io_context `io_context`] that some work has begun. This ensures that the [link asio.reference.io_context `io_context`] object's `run()` function will not exit while the work is underway. 
-
-
-[endsect]
-
-
-
-[section:overload2 io_context::work::work (2 of 2 overloads)]
-
-
-Copy constructor notifies the [link asio.reference.io_context `io_context`] that work is starting. 
-
-
-  work(
-      const work & other);
-
-
-The constructor is used to inform the [link asio.reference.io_context `io_context`] that some work has begun. This ensures that the [link asio.reference.io_context `io_context`] object's `run()` function will not exit while the work is underway. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_work io_context::work::~work]
-
-[indexterm2 asio.indexterm.io_context__work._work..~work..io_context::work] 
-Destructor notifies the [link asio.reference.io_context `io_context`] that the work is complete. 
-
-
-  ~work();
-
-
-The destructor is used to inform the [link asio.reference.io_context `io_context`] that some work has finished. Once the count of unfinished work reaches zero, the [link asio.reference.io_context `io_context`] object's `run()` function is permitted to exit. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:io_service io_service]
-
-[indexterm1 asio.indexterm.io_service..io_service]
-
-Typedef for backwards compatibility. 
-
-
-  typedef io_context io_service;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.io_context__basic_executor_type [*basic_executor_type]]]
-    [Executor implementation type used to submit functions to an io_context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__service [*service]]]
-    [Base class for all io_context services. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__strand [*strand]]]
-    [Provides serialised handler execution. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context__work [*work]]]
-    [(Deprecated: Use executor_work_guard.) Class to inform the io_context when it has work to do. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.count_type [*count_type]]]
-    [The type used to count the number of handlers executed by the context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.executor_type [*executor_type]]]
-    [Executor used to submit functions to an io_context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.io_context.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.dispatch [*dispatch]]]
-    [(Deprecated: Use asio::dispatch().) Request the io_context to invoke the given handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.get_executor [*get_executor]]]
-    [Obtains the executor associated with the io_context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.io_context [*io_context]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.poll [*poll]]]
-    [Run the io_context object's event processing loop to execute ready handlers. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute ready handlers. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.poll_one [*poll_one]]]
-    [Run the io_context object's event processing loop to execute one ready handler. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute one ready handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.post [*post]]]
-    [(Deprecated: Use asio::post().) Request the io_context to invoke the given handler and return immediately. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.reset [*reset]]]
-    [(Deprecated: Use restart().) Reset the io_context in preparation for a subsequent run() invocation. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.restart [*restart]]]
-    [Restart the io_context in preparation for a subsequent run() invocation. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run [*run]]]
-    [Run the io_context object's event processing loop. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_for [*run_for]]]
-    [Run the io_context object's event processing loop for a specified duration. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one [*run_one]]]
-    [Run the io_context object's event processing loop to execute at most one handler. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Run the io_context object's event processing loop to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one_for [*run_one_for]]]
-    [Run the io_context object's event processing loop for a specified duration to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_one_until [*run_one_until]]]
-    [Run the io_context object's event processing loop until a specified time to execute at most one handler. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.run_until [*run_until]]]
-    [Run the io_context object's event processing loop until a specified time. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.stop [*stop]]]
-    [Stop the io_context object's event processing loop. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.stopped [*stopped]]]
-    [Determine whether the io_context object has been stopped. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.wrap [*wrap]]]
-    [(Deprecated: Use asio::bind_executor().) Create a new handler that automatically dispatches the wrapped handler on the io_context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context._io_context [*~io_context]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.io_context.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.io_context.use_service [*use_service]]]
-    []
-  ]
-  
-]
-
-The [link asio.reference.io_context `io_context`] class provides the core I/O functionality for users of the asynchronous I/O objects, including:
-
-
-* `asio::ip::tcp::socket` 
-
-* `asio::ip::tcp::acceptor` 
-
-* `asio::ip::udp::socket` 
-
-* [link asio.reference.deadline_timer `deadline_timer`].
-
-The [link asio.reference.io_context `io_context`] class also includes facilities intended for developers of custom asynchronous services.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe, with the specific exceptions of the `restart()` and `notify_fork()` functions. Calling `restart()` while there are unfinished `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` calls results in undefined behaviour. The `notify_fork()` function should not be called while any [link asio.reference.io_context `io_context`] function, or any function on an I/O object that is associated with the [link asio.reference.io_context `io_context`], is being called in another thread.
-
-
-
-[heading Synchronous and asynchronous operations]
-  
-
-
-Synchronous operations on I/O objects implicitly run the [link asio.reference.io_context `io_context`] object for an individual operation. The [link asio.reference.io_context `io_context`] functions `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` must be called for the [link asio.reference.io_context `io_context`] to perform asynchronous operations on behalf of a C++ program. Notification that an asynchronous operation has completed is delivered by invocation of the associated handler. Handlers are invoked only by a thread that is currently calling any overload of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` for the [link asio.reference.io_context `io_context`].
-
-
-[heading Effect of exceptions thrown from handlers]
-  
-
-
-If an exception is thrown from a handler, the exception is allowed to propagate through the throwing thread's invocation of `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()`. No other threads that are calling any of these functions are affected. It is then the responsibility of the application to catch the exception.
-
-After the exception has been caught, the `run()`, `run_one()`, `run_for()`, `run_until()`, `poll()` or `poll_one()` call may be restarted ['without] the need for an intervening call to `restart()`. This allows the thread to rejoin the [link asio.reference.io_context `io_context`] object's thread pool without impacting any other threads in the pool.
-
-For example:
-
-
-
-  asio::io_context io_context;
-  ...
-  for (;;)
-  {
-    try
-    {
-      io_context.run();
-      break; // run() exited normally
-    }
-    catch (my_exception& e)
-    {
-      // Deal with exception as appropriate.
-    }
-  }
-
-
-
-
-
-[heading Submitting arbitrary tasks to the io_context]
-  
-
-
-To submit functions to the [link asio.reference.io_context `io_context`], use the [link asio.reference.dispatch `dispatch`], [link asio.reference.post `post`] or [link asio.reference.defer `defer`] free functions.
-
-For example:
-
-
-
-  void my_task()
-  {
-    ...
-  }
-
-  ...
-
-  asio::io_context io_context;
-
-  // Submit a function to the io_context.
-  asio::post(io_context, my_task);
-
-  // Submit a lambda object to the io_context.
-  asio::post(io_context,
-      []()
-      {
-        ...
-      });
-
-  // Run the io_context until it runs out of work.
-  io_context.run(); 
-
-
-
-
-
-[heading Stopping the io_context from running out of work]
-  
-
-
-Some applications may need to prevent an [link asio.reference.io_context `io_context`] object's `run()` call from returning when there is no more work to do. For example, the [link asio.reference.io_context `io_context`] may be being run in a background thread that is launched prior to the application's asynchronous operations. The `run()` call may be kept running by using the [link asio.reference.make_work_guard `make_work_guard`] function to create an object of type asio::executor\_work\_guard<io\_context::executor\_type>:
-
-
-
-  asio::io_context io_context;
-  asio::executor_work_guard<asio::io_context::executor_type>
-    = asio::make_work_guard(io_context);
-  ... 
-
-
-
-
-To effect a shutdown, the application will then need to call the [link asio.reference.io_context `io_context`] object's `stop()` member function. This will cause the [link asio.reference.io_context `io_context`] `run()` call to return as soon as possible, abandoning unfinished operations and without permitting ready handlers to be dispatched.
-
-Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly reset.
-
-
-
-  asio::io_context io_context;
-  asio::executor_work_guard<asio::io_context::executor_type>
-    = asio::make_work_guard(io_context);
-  ...
-  work.reset(); // Allow run() to exit. 
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/io_service.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__address ip::address]
-
-[indexterm1 asio.indexterm.ip__address..ip::address]
-
-
-Implements version-independent IP addresses. 
-
-
-  class address
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address.address [*address]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from an IPv4 address. 
-     [hr]
-     Construct an address from an IPv6 address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address().) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.is_v4 [*is_v4]]]
-    [Get whether the address is an IP version 4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.is_v6 [*is_v6]]]
-    [Get whether the address is an IP version 6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. 
-     [hr]
-     Assign from an IPv4 address. 
-     [hr]
-     Assign from an IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.to_string [*to_string]]]
-    [Get the address as a string. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.to_v4 [*to_v4]]]
-    [Get the address as an IP version 4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.to_v6 [*to_v6]]]
-    [Get the address as an IP version 6 address. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address.make_address [*make_address]]]
-    [Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address `ip::address`] class provides the ability to use either IP version 4 or version 6 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:address ip::address::address]
-
-[indexterm2 asio.indexterm.ip__address.address..address..ip::address] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__address.address.overload1 address]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__address.address.overload1 more...]]``
-
-
-Construct an address from an IPv4 address. 
-
-
-  ``[link asio.reference.ip__address.address.overload2 address]``(
-      const asio::ip::address_v4 & ipv4_address);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.address.overload2 more...]]``
-
-
-Construct an address from an IPv6 address. 
-
-
-  ``[link asio.reference.ip__address.address.overload3 address]``(
-      const asio::ip::address_v6 & ipv6_address);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.address.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__address.address.overload4 address]``(
-      const address & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.address.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__address.address.overload5 address]``(
-      address && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.address.overload5 more...]]``
-
-
-[section:overload1 ip::address::address (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  address();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address::address (2 of 5 overloads)]
-
-
-Construct an address from an IPv4 address. 
-
-
-  address(
-      const asio::ip::address_v4 & ipv4_address);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address::address (3 of 5 overloads)]
-
-
-Construct an address from an IPv6 address. 
-
-
-  address(
-      const asio::ip::address_v6 & ipv6_address);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address::address (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  address(
-      const address & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::address::address (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  address(
-      address && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:from_string ip::address::from_string]
-
-[indexterm2 asio.indexterm.ip__address.from_string..from_string..ip::address] 
-(Deprecated: Use `make_address()`.) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  static address ``[link asio.reference.ip__address.from_string.overload1 from_string]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.from_string.overload1 more...]]``
-
-  static address ``[link asio.reference.ip__address.from_string.overload2 from_string]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.from_string.overload2 more...]]``
-
-  static address ``[link asio.reference.ip__address.from_string.overload3 from_string]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.from_string.overload3 more...]]``
-
-  static address ``[link asio.reference.ip__address.from_string.overload4 from_string]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.from_string.overload4 more...]]``
-
-
-[section:overload1 ip::address::from_string (1 of 4 overloads)]
-
-
-(Deprecated: Use `make_address()`.) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  static address from_string(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address::from_string (2 of 4 overloads)]
-
-
-(Deprecated: Use `make_address()`.) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  static address from_string(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address::from_string (3 of 4 overloads)]
-
-
-(Deprecated: Use `make_address()`.) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  static address from_string(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address::from_string (4 of 4 overloads)]
-
-
-(Deprecated: Use `make_address()`.) Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  static address from_string(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_loopback ip::address::is_loopback]
-
-[indexterm2 asio.indexterm.ip__address.is_loopback..is_loopback..ip::address] 
-Determine whether the address is a loopback address. 
-
-
-  bool is_loopback() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast ip::address::is_multicast]
-
-[indexterm2 asio.indexterm.ip__address.is_multicast..is_multicast..ip::address] 
-Determine whether the address is a multicast address. 
-
-
-  bool is_multicast() const;
-
-
-
-[endsect]
-
-
-
-[section:is_unspecified ip::address::is_unspecified]
-
-[indexterm2 asio.indexterm.ip__address.is_unspecified..is_unspecified..ip::address] 
-Determine whether the address is unspecified. 
-
-
-  bool is_unspecified() const;
-
-
-
-[endsect]
-
-
-
-[section:is_v4 ip::address::is_v4]
-
-[indexterm2 asio.indexterm.ip__address.is_v4..is_v4..ip::address] 
-Get whether the address is an IP version 4 address. 
-
-
-  bool is_v4() const;
-
-
-
-[endsect]
-
-
-
-[section:is_v6 ip::address::is_v6]
-
-[indexterm2 asio.indexterm.ip__address.is_v6..is_v6..ip::address] 
-Get whether the address is an IP version 6 address. 
-
-
-  bool is_v6() const;
-
-
-
-[endsect]
-
-
-[section:make_address ip::address::make_address]
-
-[indexterm2 asio.indexterm.ip__address.make_address..make_address..ip::address] 
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address ``[link asio.reference.ip__address.make_address.overload1 make_address]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload1 more...]]``
-
-  address ``[link asio.reference.ip__address.make_address.overload2 make_address]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload2 more...]]``
-
-  address ``[link asio.reference.ip__address.make_address.overload3 make_address]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload3 more...]]``
-
-  address ``[link asio.reference.ip__address.make_address.overload4 make_address]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload4 more...]]``
-
-  address ``[link asio.reference.ip__address.make_address.overload5 make_address]``(
-      string_view str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload5 more...]]``
-
-  address ``[link asio.reference.ip__address.make_address.overload6 make_address]``(
-      string_view str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.make_address.overload6 more...]]``
-
-
-[section:overload1 ip::address::make_address (1 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address::make_address (2 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address::make_address (3 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address::make_address (4 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::address::make_address (5 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      string_view str);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::address::make_address (6 of 6 overloads)]
-
-
-Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. 
-
-
-  address make_address(
-      string_view str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_not__eq_ ip::address::operator!=]
-
-[indexterm2 asio.indexterm.ip__address.operator_not__eq_..operator!=..ip::address] 
-Compare two addresses for inequality. 
-
-
-  bool operator!=(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ ip::address::operator<]
-
-[indexterm2 asio.indexterm.ip__address.operator_lt_..operator<..ip::address] 
-Compare addresses for ordering. 
-
-
-  bool operator<(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt__lt_ ip::address::operator<<]
-
-[indexterm2 asio.indexterm.ip__address.operator_lt__lt_..operator<<..ip::address] 
-Output an address as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const address & addr);
-
-
-Used to output a human-readable string for a specified address.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[addr][The address to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-
-[section:operator_lt__eq_ ip::address::operator<=]
-
-[indexterm2 asio.indexterm.ip__address.operator_lt__eq_..operator<=..ip::address] 
-Compare addresses for ordering. 
-
-
-  bool operator<=(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::address::operator=]
-
-[indexterm2 asio.indexterm.ip__address.operator_eq_..operator=..ip::address] 
-Assign from another address. 
-
-
-  address & ``[link asio.reference.ip__address.operator_eq_.overload1 operator=]``(
-      const address & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another address. 
-
-
-  address & ``[link asio.reference.ip__address.operator_eq_.overload2 operator=]``(
-      address && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.operator_eq_.overload2 more...]]``
-
-
-Assign from an IPv4 address. 
-
-
-  address & ``[link asio.reference.ip__address.operator_eq_.overload3 operator=]``(
-      const asio::ip::address_v4 & ipv4_address);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.operator_eq_.overload3 more...]]``
-
-
-Assign from an IPv6 address. 
-
-
-  address & ``[link asio.reference.ip__address.operator_eq_.overload4 operator=]``(
-      const asio::ip::address_v6 & ipv6_address);
-  ``  [''''&raquo;''' [link asio.reference.ip__address.operator_eq_.overload4 more...]]``
-
-
-[section:overload1 ip::address::operator= (1 of 4 overloads)]
-
-
-Assign from another address. 
-
-
-  address & operator=(
-      const address & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address::operator= (2 of 4 overloads)]
-
-
-Move-assign from another address. 
-
-
-  address & operator=(
-      address && other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address::operator= (3 of 4 overloads)]
-
-
-Assign from an IPv4 address. 
-
-
-  address & operator=(
-      const asio::ip::address_v4 & ipv4_address);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address::operator= (4 of 4 overloads)]
-
-
-Assign from an IPv6 address. 
-
-
-  address & operator=(
-      const asio::ip::address_v6 & ipv6_address);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::address::operator==]
-
-[indexterm2 asio.indexterm.ip__address.operator_eq__eq_..operator==..ip::address] 
-Compare two addresses for equality. 
-
-
-  bool operator==(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ ip::address::operator>]
-
-[indexterm2 asio.indexterm.ip__address.operator_gt_..operator>..ip::address] 
-Compare addresses for ordering. 
-
-
-  bool operator>(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ ip::address::operator>=]
-
-[indexterm2 asio.indexterm.ip__address.operator_gt__eq_..operator>=..ip::address] 
-Compare addresses for ordering. 
-
-
-  bool operator>=(
-      const address & a1,
-      const address & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:to_string ip::address::to_string]
-
-[indexterm2 asio.indexterm.ip__address.to_string..to_string..ip::address] 
-Get the address as a string. 
-
-
-  std::string ``[link asio.reference.ip__address.to_string.overload1 to_string]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address.to_string.overload1 more...]]``
-
-
-(Deprecated: Use other overload.) Get the address as a string. 
-
-
-  std::string ``[link asio.reference.ip__address.to_string.overload2 to_string]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address.to_string.overload2 more...]]``
-
-
-[section:overload1 ip::address::to_string (1 of 2 overloads)]
-
-
-Get the address as a string. 
-
-
-  std::string to_string() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address::to_string (2 of 2 overloads)]
-
-
-(Deprecated: Use other overload.) Get the address as a string. 
-
-
-  std::string to_string(
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:to_v4 ip::address::to_v4]
-
-[indexterm2 asio.indexterm.ip__address.to_v4..to_v4..ip::address] 
-Get the address as an IP version 4 address. 
-
-
-  asio::ip::address_v4 to_v4() const;
-
-
-
-[endsect]
-
-
-
-[section:to_v6 ip::address::to_v6]
-
-[indexterm2 asio.indexterm.ip__address.to_v6..to_v6..ip::address] 
-Get the address as an IP version 6 address. 
-
-
-  asio::ip::address_v6 to_v6() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__address_v4 ip::address_v4]
-
-[indexterm1 asio.indexterm.ip__address_v4..ip::address_v4]
-
-
-Implements IP version 4 style addresses. 
-
-
-  class address_v4
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v4.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__address_v4.uint_type [*uint_type]]]
-    [The type used to represent an address as an unsigned integer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.address_v4 [*address_v4]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes. 
-     [hr]
-     Construct an address from an unsigned integer in host byte order. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.broadcast [*broadcast]] [static]]
-    [Obtain an address object that represents the broadcast address. 
-     [hr]
-     (Deprecated: Use network_v4 class.) Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v4().) Create an address from an IP address string in dotted decimal form. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_a [*is_class_a]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class A address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_b [*is_class_b]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class B address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_c [*is_class_c]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class C address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.netmask [*netmask]] [static]]
-    [(Deprecated: Use network_v4 class.) Obtain the netmask that corresponds to the address, based on its address class. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_string [*to_string]]]
-    [Get the address as a string in dotted decimal format. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string in dotted decimal format. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_uint [*to_uint]]]
-    [Get the address as an unsigned integer in host byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_ulong [*to_ulong]]]
-    [(Deprecated: Use to_uint().) Get the address as an unsigned long in host byte order. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.make_address_v4 [*make_address_v4]]]
-    [Create an IPv4 address from raw bytes in network order. 
-
-     Create an IPv4 address from an unsigned integer in host byte order. 
-
-     Create an IPv4 address from an IP address string in dotted decimal form. 
-
-     Create an IPv4 address from a IPv4-mapped IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]]
-    [Create an IPv4 network from an address and prefix length. 
-
-     Create an IPv4 network from an address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v4 `ip::address_v4`] class provides the ability to use and manipulate IP version 4 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:address_v4 ip::address_v4::address_v4]
-
-[indexterm2 asio.indexterm.ip__address_v4.address_v4..address_v4..ip::address_v4] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__address_v4.address_v4.overload1 address_v4]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.address_v4.overload1 more...]]``
-
-
-Construct an address from raw bytes. 
-
-
-  explicit ``[link asio.reference.ip__address_v4.address_v4.overload2 address_v4]``(
-      const bytes_type & bytes);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.address_v4.overload2 more...]]``
-
-
-Construct an address from an unsigned integer in host byte order. 
-
-
-  explicit ``[link asio.reference.ip__address_v4.address_v4.overload3 address_v4]``(
-      uint_type addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.address_v4.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__address_v4.address_v4.overload4 address_v4]``(
-      const address_v4 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.address_v4.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__address_v4.address_v4.overload5 address_v4]``(
-      address_v4 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.address_v4.overload5 more...]]``
-
-
-[section:overload1 ip::address_v4::address_v4 (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  address_v4();
-
-
-Initialises the `address_v4` object such that: 
-* `to_bytes()` yields `{0, 0, 0, 0}`; and 
-
-* `to_uint() == 0`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::address_v4 (2 of 5 overloads)]
-
-
-Construct an address from raw bytes. 
-
-
-  address_v4(
-      const bytes_type & bytes);
-
-
-Initialises the `address_v4` object such that `to_bytes() == bytes`.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[out_of_range][Thrown if any element in `bytes` is not in the range `0 - 0xFF`. Note that no range checking is required for platforms where `std::numeric_limits<unsigned char>::max()` is `0xFF`. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v4::address_v4 (3 of 5 overloads)]
-
-
-Construct an address from an unsigned integer in host byte order. 
-
-
-  address_v4(
-      uint_type addr);
-
-
-Initialises the `address_v4` object such that `to_uint() == addr`. 
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v4::address_v4 (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  address_v4(
-      const address_v4 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::address_v4::address_v4 (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  address_v4(
-      address_v4 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:any ip::address_v4::any]
-
-[indexterm2 asio.indexterm.ip__address_v4.any..any..ip::address_v4] 
-Obtain an address object that represents any address. 
-
-
-  static address_v4 any();
-
-
-This functions returns an address that represents the "any" address `0.0.0.0`.
-
-
-[heading Return Value]
-      
-A default-constructed `address_v4` object. 
-
-
-
-
-[endsect]
-
-
-[section:broadcast ip::address_v4::broadcast]
-
-[indexterm2 asio.indexterm.ip__address_v4.broadcast..broadcast..ip::address_v4] 
-Obtain an address object that represents the broadcast address. 
-
-
-  static address_v4 ``[link asio.reference.ip__address_v4.broadcast.overload1 broadcast]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.broadcast.overload1 more...]]``
-
-
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. 
-
-
-  static address_v4 ``[link asio.reference.ip__address_v4.broadcast.overload2 broadcast]``(
-      const address_v4 & addr,
-      const address_v4 & mask);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.broadcast.overload2 more...]]``
-
-
-[section:overload1 ip::address_v4::broadcast (1 of 2 overloads)]
-
-
-Obtain an address object that represents the broadcast address. 
-
-
-  static address_v4 broadcast();
-
-
-This function returns an address that represents the broadcast address `255.255.255.255`.
-
-
-[heading Return Value]
-      
-`address_v4(0xFFFFFFFF)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::broadcast (2 of 2 overloads)]
-
-
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. 
-
-
-  static address_v4 broadcast(
-      const address_v4 & addr,
-      const address_v4 & mask);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:bytes_type ip::address_v4::bytes_type]
-
-[indexterm2 asio.indexterm.ip__address_v4.bytes_type..bytes_type..ip::address_v4] 
-The type used to represent an address as an array of bytes. 
-
-
-  typedef array< unsigned char, 4 > bytes_type;
-
-
-
-
-[heading Remarks]
-      
-This type is defined in terms of the C++0x template `std::array` when it is available. Otherwise, it uses `boost:array`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:from_string ip::address_v4::from_string]
-
-[indexterm2 asio.indexterm.ip__address_v4.from_string..from_string..ip::address_v4] 
-(Deprecated: Use `make_address_v4()`.) Create an address from an IP address string in dotted decimal form. 
-
-
-  static address_v4 ``[link asio.reference.ip__address_v4.from_string.overload1 from_string]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.from_string.overload1 more...]]``
-
-  static address_v4 ``[link asio.reference.ip__address_v4.from_string.overload2 from_string]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.from_string.overload2 more...]]``
-
-  static address_v4 ``[link asio.reference.ip__address_v4.from_string.overload3 from_string]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.from_string.overload3 more...]]``
-
-  static address_v4 ``[link asio.reference.ip__address_v4.from_string.overload4 from_string]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.from_string.overload4 more...]]``
-
-
-[section:overload1 ip::address_v4::from_string (1 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v4()`.) Create an address from an IP address string in dotted decimal form. 
-
-
-  static address_v4 from_string(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::from_string (2 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v4()`.) Create an address from an IP address string in dotted decimal form. 
-
-
-  static address_v4 from_string(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v4::from_string (3 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v4()`.) Create an address from an IP address string in dotted decimal form. 
-
-
-  static address_v4 from_string(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v4::from_string (4 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v4()`.) Create an address from an IP address string in dotted decimal form. 
-
-
-  static address_v4 from_string(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_class_a ip::address_v4::is_class_a]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_class_a..is_class_a..ip::address_v4] 
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Determine whether the address is a class A address. 
-
-
-  bool is_class_a() const;
-
-
-
-[endsect]
-
-
-
-[section:is_class_b ip::address_v4::is_class_b]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_class_b..is_class_b..ip::address_v4] 
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Determine whether the address is a class B address. 
-
-
-  bool is_class_b() const;
-
-
-
-[endsect]
-
-
-
-[section:is_class_c ip::address_v4::is_class_c]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_class_c..is_class_c..ip::address_v4] 
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Determine whether the address is a class C address. 
-
-
-  bool is_class_c() const;
-
-
-
-[endsect]
-
-
-
-[section:is_loopback ip::address_v4::is_loopback]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_loopback..is_loopback..ip::address_v4] 
-Determine whether the address is a loopback address. 
-
-
-  bool is_loopback() const;
-
-
-This function tests whether the address is in the address block `127.0.0.0/8`, which corresponds to the address range `127.0.0.0 - 127.255.255.255`.
-
-
-[heading Return Value]
-      
-`(to_uint() & 0xFF000000) == 0x7F000000`. 
-
-
-
-
-[endsect]
-
-
-
-[section:is_multicast ip::address_v4::is_multicast]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_multicast..is_multicast..ip::address_v4] 
-Determine whether the address is a multicast address. 
-
-
-  bool is_multicast() const;
-
-
-This function tests whether the address is in the multicast address block `224.0.0.0/4`, which corresponds to the address range `224.0.0.0 - 239.255.255.255`.
-
-
-[heading Return Value]
-      
-`(to_uint() & 0xF0000000) == 0xE0000000`. 
-
-
-
-
-[endsect]
-
-
-
-[section:is_unspecified ip::address_v4::is_unspecified]
-
-[indexterm2 asio.indexterm.ip__address_v4.is_unspecified..is_unspecified..ip::address_v4] 
-Determine whether the address is unspecified. 
-
-
-  bool is_unspecified() const;
-
-
-This function tests whether the address is the unspecified address `0.0.0.0`.
-
-
-[heading Return Value]
-      
-`to_uint() == 0`. 
-
-
-
-
-[endsect]
-
-
-
-[section:loopback ip::address_v4::loopback]
-
-[indexterm2 asio.indexterm.ip__address_v4.loopback..loopback..ip::address_v4] 
-Obtain an address object that represents the loopback address. 
-
-
-  static address_v4 loopback();
-
-
-This function returns an address that represents the well-known loopback address `127.0.0.1`.
-
-
-[heading Return Value]
-      
-`address_v4(0x7F000001)`. 
-
-
-
-
-[endsect]
-
-
-[section:make_address_v4 ip::address_v4::make_address_v4]
-
-[indexterm2 asio.indexterm.ip__address_v4.make_address_v4..make_address_v4..ip::address_v4] 
-Create an IPv4 address from raw bytes in network order. 
-
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload1 make_address_v4]``(
-      const address_v4::bytes_type & bytes);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload1 more...]]``
-
-
-Create an IPv4 address from an unsigned integer in host byte order. 
-
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload2 make_address_v4]``(
-      address_v4::uint_type addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload2 more...]]``
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload3 make_address_v4]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload3 more...]]``
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload4 make_address_v4]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload4 more...]]``
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload5 make_address_v4]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload5 more...]]``
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload6 make_address_v4]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload6 more...]]``
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload7 make_address_v4]``(
-      string_view str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload7 more...]]``
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload8 make_address_v4]``(
-      string_view str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload8 more...]]``
-
-
-Create an IPv4 address from a IPv4-mapped IPv6 address. 
-
-
-  address_v4 ``[link asio.reference.ip__address_v4.make_address_v4.overload9 make_address_v4]``(
-      v4_mapped_t ,
-      const address_v6 & v6_addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_address_v4.overload9 more...]]``
-
-
-[section:overload1 ip::address_v4::make_address_v4 (1 of 9 overloads)]
-
-
-Create an IPv4 address from raw bytes in network order. 
-
-
-  address_v4 make_address_v4(
-      const address_v4::bytes_type & bytes);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::make_address_v4 (2 of 9 overloads)]
-
-
-Create an IPv4 address from an unsigned integer in host byte order. 
-
-
-  address_v4 make_address_v4(
-      address_v4::uint_type addr);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v4::make_address_v4 (3 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v4::make_address_v4 (4 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::address_v4::make_address_v4 (5 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::address_v4::make_address_v4 (6 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload7 ip::address_v4::make_address_v4 (7 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      string_view str);
-
-
-
-[endsect]
-
-
-
-[section:overload8 ip::address_v4::make_address_v4 (8 of 9 overloads)]
-
-
-Create an IPv4 address from an IP address string in dotted decimal form. 
-
-
-  address_v4 make_address_v4(
-      string_view str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload9 ip::address_v4::make_address_v4 (9 of 9 overloads)]
-
-
-Create an IPv4 address from a IPv4-mapped IPv6 address. 
-
-
-  address_v4 make_address_v4(
-      v4_mapped_t ,
-      const address_v6 & v6_addr);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:make_network_v4 ip::address_v4::make_network_v4]
-
-[indexterm2 asio.indexterm.ip__address_v4.make_network_v4..make_network_v4..ip::address_v4] 
-Create an IPv4 network from an address and prefix length. 
-
-
-  network_v4 ``[link asio.reference.ip__address_v4.make_network_v4.overload1 make_network_v4]``(
-      const address_v4 & addr,
-      unsigned short prefix_len);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_network_v4.overload1 more...]]``
-
-
-Create an IPv4 network from an address and netmask. 
-
-
-  network_v4 ``[link asio.reference.ip__address_v4.make_network_v4.overload2 make_network_v4]``(
-      const address_v4 & addr,
-      const address_v4 & mask);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.make_network_v4.overload2 more...]]``
-
-
-[section:overload1 ip::address_v4::make_network_v4 (1 of 2 overloads)]
-
-
-Create an IPv4 network from an address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      const address_v4 & addr,
-      unsigned short prefix_len);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::make_network_v4 (2 of 2 overloads)]
-
-
-Create an IPv4 network from an address and netmask. 
-
-
-  network_v4 make_network_v4(
-      const address_v4 & addr,
-      const address_v4 & mask);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:netmask ip::address_v4::netmask]
-
-[indexterm2 asio.indexterm.ip__address_v4.netmask..netmask..ip::address_v4] 
-(Deprecated: Use [link asio.reference.ip__network_v4 `ip::network_v4`] class.) Obtain the netmask that corresponds to the address, based on its address class. 
-
-
-  static address_v4 netmask(
-      const address_v4 & addr);
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::address_v4::operator!=]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_not__eq_..operator!=..ip::address_v4] 
-Compare two addresses for inequality. 
-
-
-  bool operator!=(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ ip::address_v4::operator<]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_lt_..operator<..ip::address_v4] 
-Compare addresses for ordering. 
-
-
-  bool operator<(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-Compares two addresses in host byte order.
-
-
-[heading Return Value]
-      
-`a1.to_uint() < a2.to_uint()`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_lt__lt_ ip::address_v4::operator<<]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_lt__lt_..operator<<..ip::address_v4] 
-Output an address as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v4.operator_lt__lt_.overload1 operator<<]``(
-      std::basic_ostream< Elem, Traits > & os,
-      const address_v4 & addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.operator_lt__lt_.overload1 more...]]``
-
-
-Output a network as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v4.operator_lt__lt_.overload2 operator<<]``(
-      std::basic_ostream< Elem, Traits > & os,
-      const network_v4 & net);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.operator_lt__lt_.overload2 more...]]``
-
-
-[section:overload1 ip::address_v4::operator<< (1 of 2 overloads)]
-
-
-Output an address as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const address_v4 & addr);
-
-
-Used to output a human-readable string for a specified address.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[addr][The address to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::operator<< (2 of 2 overloads)]
-
-
-Output a network as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const network_v4 & net);
-
-
-Used to output a human-readable string for a specified network.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[net][The network to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_lt__eq_ ip::address_v4::operator<=]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_lt__eq_..operator<=..ip::address_v4] 
-Compare addresses for ordering. 
-
-
-  bool operator<=(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-Compares two addresses in host byte order.
-
-
-[heading Return Value]
-      
-`a1.to_uint() <= a2.to_uint()`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::address_v4::operator=]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_eq_..operator=..ip::address_v4] 
-Assign from another address. 
-
-
-  address_v4 & ``[link asio.reference.ip__address_v4.operator_eq_.overload1 operator=]``(
-      const address_v4 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another address. 
-
-
-  address_v4 & ``[link asio.reference.ip__address_v4.operator_eq_.overload2 operator=]``(
-      address_v4 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::address_v4::operator= (1 of 2 overloads)]
-
-
-Assign from another address. 
-
-
-  address_v4 & operator=(
-      const address_v4 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::operator= (2 of 2 overloads)]
-
-
-Move-assign from another address. 
-
-
-  address_v4 & operator=(
-      address_v4 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::address_v4::operator==]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_eq__eq_..operator==..ip::address_v4] 
-Compare two addresses for equality. 
-
-
-  bool operator==(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ ip::address_v4::operator>]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_gt_..operator>..ip::address_v4] 
-Compare addresses for ordering. 
-
-
-  bool operator>(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-Compares two addresses in host byte order.
-
-
-[heading Return Value]
-      
-`a1.to_uint() > a2.to_uint()`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ ip::address_v4::operator>=]
-
-[indexterm2 asio.indexterm.ip__address_v4.operator_gt__eq_..operator>=..ip::address_v4] 
-Compare addresses for ordering. 
-
-
-  bool operator>=(
-      const address_v4 & a1,
-      const address_v4 & a2);
-
-
-Compares two addresses in host byte order.
-
-
-[heading Return Value]
-      
-`a1.to_uint() >= a2.to_uint()`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:to_bytes ip::address_v4::to_bytes]
-
-[indexterm2 asio.indexterm.ip__address_v4.to_bytes..to_bytes..ip::address_v4] 
-Get the address in bytes, in network byte order. 
-
-
-  bytes_type to_bytes() const;
-
-
-
-[endsect]
-
-
-[section:to_string ip::address_v4::to_string]
-
-[indexterm2 asio.indexterm.ip__address_v4.to_string..to_string..ip::address_v4] 
-Get the address as a string in dotted decimal format. 
-
-
-  std::string ``[link asio.reference.ip__address_v4.to_string.overload1 to_string]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.to_string.overload1 more...]]``
-
-
-(Deprecated: Use other overload.) Get the address as a string in dotted decimal format. 
-
-
-  std::string ``[link asio.reference.ip__address_v4.to_string.overload2 to_string]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v4.to_string.overload2 more...]]``
-
-
-[section:overload1 ip::address_v4::to_string (1 of 2 overloads)]
-
-
-Get the address as a string in dotted decimal format. 
-
-
-  std::string to_string() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v4::to_string (2 of 2 overloads)]
-
-
-(Deprecated: Use other overload.) Get the address as a string in dotted decimal format. 
-
-
-  std::string to_string(
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:to_uint ip::address_v4::to_uint]
-
-[indexterm2 asio.indexterm.ip__address_v4.to_uint..to_uint..ip::address_v4] 
-Get the address as an unsigned integer in host byte order. 
-
-
-  uint_type to_uint() const;
-
-
-
-[endsect]
-
-
-
-[section:to_ulong ip::address_v4::to_ulong]
-
-[indexterm2 asio.indexterm.ip__address_v4.to_ulong..to_ulong..ip::address_v4] 
-(Deprecated: Use `to_uint()`.) Get the address as an unsigned long in host byte order. 
-
-
-  unsigned long to_ulong() const;
-
-
-
-[endsect]
-
-
-
-[section:uint_type ip::address_v4::uint_type]
-
-[indexterm2 asio.indexterm.ip__address_v4.uint_type..uint_type..ip::address_v4] 
-The type used to represent an address as an unsigned integer. 
-
-
-  typedef uint_least32_t uint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ip__address_v4_iterator ip::address_v4_iterator]
-
-[indexterm1 asio.indexterm.ip__address_v4_iterator..ip::address_v4_iterator]
-
-An input iterator that can be used for traversing IPv4 addresses. 
-
-
-  typedef basic_address_iterator< address_v4 > address_v4_iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__address_v4_range ip::address_v4_range]
-
-[indexterm1 asio.indexterm.ip__address_v4_range..ip::address_v4_range]
-
-Represents a range of IPv4 addresses. 
-
-
-  typedef basic_address_range< address_v4 > address_v4_range;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.iterator [*iterator]]]
-    [The type of an iterator that points into the range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range [*basic_address_range]]]
-    [Construct an empty range. 
-     [hr]
-     Construct an range that represents the given range of addresses. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.begin [*begin]]]
-    [Obtain an iterator that points to the start of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.empty [*empty]]]
-    [Determine whether the range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.end [*end]]]
-    [Obtain an iterator that points to the end of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.find [*find]]]
-    [Find an address in the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.size [*size]]]
-    [Return the size of the range. ]
-  ]
-  
-]
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__address_v6 ip::address_v6]
-
-[indexterm1 asio.indexterm.ip__address_v6..ip::address_v6]
-
-
-Implements IP version 6 style addresses. 
-
-
-  class address_v6
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v6.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.address_v6 [*address_v6]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes and scope ID. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv6 address from an IP address string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_link_local [*is_link_local]]]
-    [Determine whether the address is link local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]]
-    [Determine whether the address is a global multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]]
-    [Determine whether the address is a link-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]]
-    [Determine whether the address is a node-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]]
-    [Determine whether the address is a org-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]]
-    [Determine whether the address is a site-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_site_local [*is_site_local]]]
-    [Determine whether the address is site local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]]
-    [(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]]
-    [Determine whether the address is a mapped IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.scope_id [*scope_id]]]
-    [The scope ID of the address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_string [*to_string]]]
-    [Get the address as a string. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_v4 [*to_v4]]]
-    [(Deprecated: Use make_address_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_compatible [*v4_compatible]] [static]]
-    [(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_mapped [*v4_mapped]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.make_address_v6 [*make_address_v6]]]
-    [Create an IPv6 address from raw bytes and scope ID. 
-
-     Create an IPv6 address from an IP address string. 
-
-     Createan IPv6 address from an IP address string. 
-
-     Create an IPv4-mapped IPv6 address from an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]]
-    [Create an IPv6 network from an address and prefix length. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v6 `ip::address_v6`] class provides the ability to use and manipulate IP version 6 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:address_v6 ip::address_v6::address_v6]
-
-[indexterm2 asio.indexterm.ip__address_v6.address_v6..address_v6..ip::address_v6] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__address_v6.address_v6.overload1 address_v6]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.address_v6.overload1 more...]]``
-
-
-Construct an address from raw bytes and scope ID. 
-
-
-  explicit ``[link asio.reference.ip__address_v6.address_v6.overload2 address_v6]``(
-      const bytes_type & bytes,
-      scope_id_type scope_id = 0);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.address_v6.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__address_v6.address_v6.overload3 address_v6]``(
-      const address_v6 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.address_v6.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__address_v6.address_v6.overload4 address_v6]``(
-      address_v6 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.address_v6.overload4 more...]]``
-
-
-[section:overload1 ip::address_v6::address_v6 (1 of 4 overloads)]
-
-
-Default constructor. 
-
-
-  address_v6();
-
-
-Initialises the `address_v6` object such that: 
-* `to_bytes()` yields `{0, 0, ..., 0}`; and 
-
-* `scope_id() == 0`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::address_v6 (2 of 4 overloads)]
-
-
-Construct an address from raw bytes and scope ID. 
-
-
-  address_v6(
-      const bytes_type & bytes,
-      scope_id_type scope_id = 0);
-
-
-Initialises the `address_v6` object such that: 
-* `to_bytes() == bytes`; and 
-
-* `this->scope_id() == scope_id`.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[out_of_range][Thrown if any element in `bytes` is not in the range `0 - 0xFF`. Note that no range checking is required for platforms where `std::numeric_limits<unsigned char>::max()` is `0xFF`. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v6::address_v6 (3 of 4 overloads)]
-
-
-Copy constructor. 
-
-
-  address_v6(
-      const address_v6 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v6::address_v6 (4 of 4 overloads)]
-
-
-Move constructor. 
-
-
-  address_v6(
-      address_v6 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:any ip::address_v6::any]
-
-[indexterm2 asio.indexterm.ip__address_v6.any..any..ip::address_v6] 
-Obtain an address object that represents any address. 
-
-
-  static address_v6 any();
-
-
-This functions returns an address that represents the "any" address `::`.
-
-
-[heading Return Value]
-      
-A default-constructed `address_v6` object. 
-
-
-
-
-[endsect]
-
-
-
-[section:bytes_type ip::address_v6::bytes_type]
-
-[indexterm2 asio.indexterm.ip__address_v6.bytes_type..bytes_type..ip::address_v6] 
-The type used to represent an address as an array of bytes. 
-
-
-  typedef array< unsigned char, 16 > bytes_type;
-
-
-
-
-[heading Remarks]
-      
-This type is defined in terms of the C++0x template `std::array` when it is available. Otherwise, it uses `boost:array`. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:from_string ip::address_v6::from_string]
-
-[indexterm2 asio.indexterm.ip__address_v6.from_string..from_string..ip::address_v6] 
-(Deprecated: Use `make_address_v6()`.) Create an IPv6 address from an IP address string. 
-
-
-  static address_v6 ``[link asio.reference.ip__address_v6.from_string.overload1 from_string]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.from_string.overload1 more...]]``
-
-  static address_v6 ``[link asio.reference.ip__address_v6.from_string.overload2 from_string]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.from_string.overload2 more...]]``
-
-  static address_v6 ``[link asio.reference.ip__address_v6.from_string.overload3 from_string]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.from_string.overload3 more...]]``
-
-  static address_v6 ``[link asio.reference.ip__address_v6.from_string.overload4 from_string]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.from_string.overload4 more...]]``
-
-
-[section:overload1 ip::address_v6::from_string (1 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v6()`.) Create an IPv6 address from an IP address string. 
-
-
-  static address_v6 from_string(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::from_string (2 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v6()`.) Create an IPv6 address from an IP address string. 
-
-
-  static address_v6 from_string(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v6::from_string (3 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v6()`.) Create an IPv6 address from an IP address string. 
-
-
-  static address_v6 from_string(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v6::from_string (4 of 4 overloads)]
-
-
-(Deprecated: Use `make_address_v6()`.) Create an IPv6 address from an IP address string. 
-
-
-  static address_v6 from_string(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_link_local ip::address_v6::is_link_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_link_local..is_link_local..ip::address_v6] 
-Determine whether the address is link local. 
-
-
-  bool is_link_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_loopback ip::address_v6::is_loopback]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_loopback..is_loopback..ip::address_v6] 
-Determine whether the address is a loopback address. 
-
-
-  bool is_loopback() const;
-
-
-This function tests whether the address is the loopback address `::1`. 
-
-
-[endsect]
-
-
-
-[section:is_multicast ip::address_v6::is_multicast]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast..is_multicast..ip::address_v6] 
-Determine whether the address is a multicast address. 
-
-
-  bool is_multicast() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast_global ip::address_v6::is_multicast_global]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast_global..is_multicast_global..ip::address_v6] 
-Determine whether the address is a global multicast address. 
-
-
-  bool is_multicast_global() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast_link_local ip::address_v6::is_multicast_link_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast_link_local..is_multicast_link_local..ip::address_v6] 
-Determine whether the address is a link-local multicast address. 
-
-
-  bool is_multicast_link_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast_node_local ip::address_v6::is_multicast_node_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast_node_local..is_multicast_node_local..ip::address_v6] 
-Determine whether the address is a node-local multicast address. 
-
-
-  bool is_multicast_node_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast_org_local ip::address_v6::is_multicast_org_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast_org_local..is_multicast_org_local..ip::address_v6] 
-Determine whether the address is a org-local multicast address. 
-
-
-  bool is_multicast_org_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_multicast_site_local ip::address_v6::is_multicast_site_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_multicast_site_local..is_multicast_site_local..ip::address_v6] 
-Determine whether the address is a site-local multicast address. 
-
-
-  bool is_multicast_site_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_site_local ip::address_v6::is_site_local]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_site_local..is_site_local..ip::address_v6] 
-Determine whether the address is site local. 
-
-
-  bool is_site_local() const;
-
-
-
-[endsect]
-
-
-
-[section:is_unspecified ip::address_v6::is_unspecified]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_unspecified..is_unspecified..ip::address_v6] 
-Determine whether the address is unspecified. 
-
-
-  bool is_unspecified() const;
-
-
-This function tests whether the address is the loopback address `::`. 
-
-
-[endsect]
-
-
-
-[section:is_v4_compatible ip::address_v6::is_v4_compatible]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_v4_compatible..is_v4_compatible..ip::address_v6] 
-(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. 
-
-
-  bool is_v4_compatible() const;
-
-
-
-[endsect]
-
-
-
-[section:is_v4_mapped ip::address_v6::is_v4_mapped]
-
-[indexterm2 asio.indexterm.ip__address_v6.is_v4_mapped..is_v4_mapped..ip::address_v6] 
-Determine whether the address is a mapped IPv4 address. 
-
-
-  bool is_v4_mapped() const;
-
-
-
-[endsect]
-
-
-
-[section:loopback ip::address_v6::loopback]
-
-[indexterm2 asio.indexterm.ip__address_v6.loopback..loopback..ip::address_v6] 
-Obtain an address object that represents the loopback address. 
-
-
-  static address_v6 loopback();
-
-
-This function returns an address that represents the well-known loopback address `::1`. 
-
-
-[endsect]
-
-
-[section:make_address_v6 ip::address_v6::make_address_v6]
-
-[indexterm2 asio.indexterm.ip__address_v6.make_address_v6..make_address_v6..ip::address_v6] 
-Create an IPv6 address from raw bytes and scope ID. 
-
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload1 make_address_v6]``(
-      const address_v6::bytes_type & bytes,
-      scope_id_type scope_id = 0);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload1 more...]]``
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload2 make_address_v6]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload2 more...]]``
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload3 make_address_v6]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload3 more...]]``
-
-
-Createan IPv6 address from an IP address string. 
-
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload4 make_address_v6]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload4 more...]]``
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload5 make_address_v6]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload5 more...]]``
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload6 make_address_v6]``(
-      string_view str);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload6 more...]]``
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload7 make_address_v6]``(
-      string_view str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload7 more...]]``
-
-
-Create an IPv4-mapped IPv6 address from an IPv4 address. 
-
-
-  address_v6 ``[link asio.reference.ip__address_v6.make_address_v6.overload8 make_address_v6]``(
-      v4_mapped_t ,
-      const address_v4 & v4_addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.make_address_v6.overload8 more...]]``
-
-
-[section:overload1 ip::address_v6::make_address_v6 (1 of 8 overloads)]
-
-
-Create an IPv6 address from raw bytes and scope ID. 
-
-
-  address_v6 make_address_v6(
-      const address_v6::bytes_type & bytes,
-      scope_id_type scope_id = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::make_address_v6 (2 of 8 overloads)]
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::address_v6::make_address_v6 (3 of 8 overloads)]
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::address_v6::make_address_v6 (4 of 8 overloads)]
-
-
-Createan IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::address_v6::make_address_v6 (5 of 8 overloads)]
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::address_v6::make_address_v6 (6 of 8 overloads)]
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      string_view str);
-
-
-
-[endsect]
-
-
-
-[section:overload7 ip::address_v6::make_address_v6 (7 of 8 overloads)]
-
-
-Create an IPv6 address from an IP address string. 
-
-
-  address_v6 make_address_v6(
-      string_view str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload8 ip::address_v6::make_address_v6 (8 of 8 overloads)]
-
-
-Create an IPv4-mapped IPv6 address from an IPv4 address. 
-
-
-  address_v6 make_address_v6(
-      v4_mapped_t ,
-      const address_v4 & v4_addr);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:make_network_v6 ip::address_v6::make_network_v6]
-
-[indexterm2 asio.indexterm.ip__address_v6.make_network_v6..make_network_v6..ip::address_v6] 
-Create an IPv6 network from an address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      const address_v6 & addr,
-      unsigned short prefix_len);
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::address_v6::operator!=]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_not__eq_..operator!=..ip::address_v6] 
-Compare two addresses for inequality. 
-
-
-  bool operator!=(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ ip::address_v6::operator<]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_lt_..operator<..ip::address_v6] 
-Compare addresses for ordering. 
-
-
-  bool operator<(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_lt__lt_ ip::address_v6::operator<<]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_lt__lt_..operator<<..ip::address_v6] 
-Output an address as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v6.operator_lt__lt_.overload1 operator<<]``(
-      std::basic_ostream< Elem, Traits > & os,
-      const address_v6 & addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.operator_lt__lt_.overload1 more...]]``
-
-
-Output a network as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & ``[link asio.reference.ip__address_v6.operator_lt__lt_.overload2 operator<<]``(
-      std::basic_ostream< Elem, Traits > & os,
-      const network_v6 & net);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.operator_lt__lt_.overload2 more...]]``
-
-
-[section:overload1 ip::address_v6::operator<< (1 of 2 overloads)]
-
-
-Output an address as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const address_v6 & addr);
-
-
-Used to output a human-readable string for a specified address.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[addr][The address to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::operator<< (2 of 2 overloads)]
-
-
-Output a network as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const network_v6 & net);
-
-
-Used to output a human-readable string for a specified network.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[net][The network to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_lt__eq_ ip::address_v6::operator<=]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_lt__eq_..operator<=..ip::address_v6] 
-Compare addresses for ordering. 
-
-
-  bool operator<=(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::address_v6::operator=]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_eq_..operator=..ip::address_v6] 
-Assign from another address. 
-
-
-  address_v6 & ``[link asio.reference.ip__address_v6.operator_eq_.overload1 operator=]``(
-      const address_v6 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another address. 
-
-
-  address_v6 & ``[link asio.reference.ip__address_v6.operator_eq_.overload2 operator=]``(
-      address_v6 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::address_v6::operator= (1 of 2 overloads)]
-
-
-Assign from another address. 
-
-
-  address_v6 & operator=(
-      const address_v6 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::operator= (2 of 2 overloads)]
-
-
-Move-assign from another address. 
-
-
-  address_v6 & operator=(
-      address_v6 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::address_v6::operator==]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_eq__eq_..operator==..ip::address_v6] 
-Compare two addresses for equality. 
-
-
-  bool operator==(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ ip::address_v6::operator>]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_gt_..operator>..ip::address_v6] 
-Compare addresses for ordering. 
-
-
-  bool operator>(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ ip::address_v6::operator>=]
-
-[indexterm2 asio.indexterm.ip__address_v6.operator_gt__eq_..operator>=..ip::address_v6] 
-Compare addresses for ordering. 
-
-
-  bool operator>=(
-      const address_v6 & a1,
-      const address_v6 & a2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:scope_id ip::address_v6::scope_id]
-
-[indexterm2 asio.indexterm.ip__address_v6.scope_id..scope_id..ip::address_v6] 
-The scope ID of the address. 
-
-
-  scope_id_type ``[link asio.reference.ip__address_v6.scope_id.overload1 scope_id]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.scope_id.overload1 more...]]``
-
-  void ``[link asio.reference.ip__address_v6.scope_id.overload2 scope_id]``(
-      scope_id_type id);
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.scope_id.overload2 more...]]``
-
-
-[section:overload1 ip::address_v6::scope_id (1 of 2 overloads)]
-
-
-The scope ID of the address. 
-
-
-  scope_id_type scope_id() const;
-
-
-Returns the scope ID associated with the IPv6 address. 
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::scope_id (2 of 2 overloads)]
-
-
-The scope ID of the address. 
-
-
-  void scope_id(
-      scope_id_type id);
-
-
-Modifies the scope ID associated with the IPv6 address.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[id][The new scope ID. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:to_bytes ip::address_v6::to_bytes]
-
-[indexterm2 asio.indexterm.ip__address_v6.to_bytes..to_bytes..ip::address_v6] 
-Get the address in bytes, in network byte order. 
-
-
-  bytes_type to_bytes() const;
-
-
-
-[endsect]
-
-
-[section:to_string ip::address_v6::to_string]
-
-[indexterm2 asio.indexterm.ip__address_v6.to_string..to_string..ip::address_v6] 
-Get the address as a string. 
-
-
-  std::string ``[link asio.reference.ip__address_v6.to_string.overload1 to_string]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.to_string.overload1 more...]]``
-
-
-(Deprecated: Use other overload.) Get the address as a string. 
-
-
-  std::string ``[link asio.reference.ip__address_v6.to_string.overload2 to_string]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__address_v6.to_string.overload2 more...]]``
-
-
-[section:overload1 ip::address_v6::to_string (1 of 2 overloads)]
-
-
-Get the address as a string. 
-
-
-  std::string to_string() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::address_v6::to_string (2 of 2 overloads)]
-
-
-(Deprecated: Use other overload.) Get the address as a string. 
-
-
-  std::string to_string(
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:to_v4 ip::address_v6::to_v4]
-
-[indexterm2 asio.indexterm.ip__address_v6.to_v4..to_v4..ip::address_v6] 
-(Deprecated: Use make\_address\_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. 
-
-
-  address_v4 to_v4() const;
-
-
-
-[endsect]
-
-
-
-[section:v4_compatible ip::address_v6::v4_compatible]
-
-[indexterm2 asio.indexterm.ip__address_v6.v4_compatible..v4_compatible..ip::address_v6] 
-(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. 
-
-
-  static address_v6 v4_compatible(
-      const address_v4 & addr);
-
-
-
-[endsect]
-
-
-
-[section:v4_mapped ip::address_v6::v4_mapped]
-
-[indexterm2 asio.indexterm.ip__address_v6.v4_mapped..v4_mapped..ip::address_v6] 
-(Deprecated: Use `make_address_v6()`.) Create an IPv4-mapped IPv6 address. 
-
-
-  static address_v6 v4_mapped(
-      const address_v4 & addr);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ip__address_v6_iterator ip::address_v6_iterator]
-
-[indexterm1 asio.indexterm.ip__address_v6_iterator..ip::address_v6_iterator]
-
-An input iterator that can be used for traversing IPv6 addresses. 
-
-
-  typedef basic_address_iterator< address_v6 > address_v6_iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__address_v6_range ip::address_v6_range]
-
-[indexterm1 asio.indexterm.ip__address_v6_range..ip::address_v6_range]
-
-Represents a range of IPv6 addresses. 
-
-
-  typedef basic_address_range< address_v6 > address_v6_range;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.iterator [*iterator]]]
-    [The type of an iterator that points into the range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range [*basic_address_range]]]
-    [Construct an empty range. 
-     [hr]
-     Construct an range that represents the given range of addresses. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.begin [*begin]]]
-    [Obtain an iterator that points to the start of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.empty [*empty]]]
-    [Determine whether the range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.end [*end]]]
-    [Obtain an iterator that points to the end of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.find [*find]]]
-    [Find an address in the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__bad_address_cast ip::bad_address_cast]
-
-[indexterm1 asio.indexterm.ip__bad_address_cast..ip::bad_address_cast]
-
-
-Thrown to indicate a failed address conversion. 
-
-
-  class bad_address_cast :
-    public std::bad_cast
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__bad_address_cast.bad_address_cast [*bad_address_cast]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Copy constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__bad_address_cast.what [*what]]]
-    [Get the message associated with the exception. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__bad_address_cast._bad_address_cast [*~bad_address_cast]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/bad_address_cast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:bad_address_cast ip::bad_address_cast::bad_address_cast]
-
-[indexterm2 asio.indexterm.ip__bad_address_cast.bad_address_cast..bad_address_cast..ip::bad_address_cast] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__bad_address_cast.bad_address_cast.overload1 bad_address_cast]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__bad_address_cast.bad_address_cast.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__bad_address_cast.bad_address_cast.overload2 bad_address_cast]``(
-      const bad_address_cast & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__bad_address_cast.bad_address_cast.overload2 more...]]``
-
-
-[section:overload1 ip::bad_address_cast::bad_address_cast (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  bad_address_cast();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::bad_address_cast::bad_address_cast (2 of 2 overloads)]
-
-
-Copy constructor. 
-
-
-  bad_address_cast(
-      const bad_address_cast & other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:what ip::bad_address_cast::what]
-
-[indexterm2 asio.indexterm.ip__bad_address_cast.what..what..ip::bad_address_cast] 
-Get the message associated with the exception. 
-
-
-  virtual const char * what() const;
-
-
-
-[endsect]
-
-
-
-[section:_bad_address_cast ip::bad_address_cast::~bad_address_cast]
-
-[indexterm2 asio.indexterm.ip__bad_address_cast._bad_address_cast..~bad_address_cast..ip::bad_address_cast] 
-Destructor. 
-
-
-  virtual ~bad_address_cast();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_address_iterator ip::basic_address_iterator]
-
-[indexterm1 asio.indexterm.ip__basic_address_iterator..ip::basic_address_iterator]
-
-
-
-  template<
-       >
-  class basic_address_iterator
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:ip__basic_address_iterator_lt__address_v4__gt_ ip::basic_address_iterator< address_v4 >]
-
-[indexterm1 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_..ip::basic_address_iterator< address_v4 >]
-
-
-An input iterator that can be used for traversing IPv4 addresses. 
-
-
-  template<>
-  class basic_address_iterator< address_v4 >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_address_iterator ip::basic_address_iterator< address_v4 >::basic_address_iterator]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator..basic_address_iterator..ip::basic_address_iterator< address_v4 >] 
-Construct an iterator that points to the specified address. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload1 basic_address_iterator]``(
-      const address_v4 & addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload2 basic_address_iterator]``(
-      const basic_address_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload3 basic_address_iterator]``(
-      basic_address_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator.overload3 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v4 >::basic_address_iterator (1 of 3 overloads)]
-
-
-Construct an iterator that points to the specified address. 
-
-
-  basic_address_iterator(
-      const address_v4 & addr);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v4 >::basic_address_iterator (2 of 3 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_address_iterator(
-      const basic_address_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_address_iterator< address_v4 >::basic_address_iterator (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  basic_address_iterator(
-      basic_address_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:difference_type ip::basic_address_iterator< address_v4 >::difference_type]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.difference_type..difference_type..ip::basic_address_iterator< address_v4 >] 
-Distance between two iterators. 
-
-
-  typedef std::ptrdiff_t difference_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:iterator_category ip::basic_address_iterator< address_v4 >::iterator_category]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.iterator_category..iterator_category..ip::basic_address_iterator< address_v4 >] 
-Denotes that the iterator satisfies the input iterator requirements. 
-
-
-  typedef std::input_iterator_tag iterator_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::basic_address_iterator< address_v4 >::operator!=]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_not__eq_..operator!=..ip::basic_address_iterator< address_v4 >] 
-Compare two addresses for inequality. 
-
-
-  bool operator!=(
-      const basic_address_iterator & a,
-      const basic_address_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_star_ ip::basic_address_iterator< address_v4 >::operator*]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_star_..operator*..ip::basic_address_iterator< address_v4 >] 
-Dereference the iterator. 
-
-
-  const address_v4 & operator*() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus__plus_ ip::basic_address_iterator< address_v4 >::operator++]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_..operator++..ip::basic_address_iterator< address_v4 >] 
-Pre-increment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_.overload1 operator++]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_.overload1 more...]]``
-
-
-Post-increment operator. 
-
-
-  basic_address_iterator ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_.overload2 operator++]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v4 >::operator++ (1 of 2 overloads)]
-
-
-Pre-increment operator. 
-
-
-  basic_address_iterator & operator++();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v4 >::operator++ (2 of 2 overloads)]
-
-
-Post-increment operator. 
-
-
-  basic_address_iterator operator++(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_minus__minus_ ip::basic_address_iterator< address_v4 >::operator--]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_..operator--..ip::basic_address_iterator< address_v4 >] 
-Pre-decrement operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_.overload1 operator--]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_.overload1 more...]]``
-
-
-Post-decrement operator. 
-
-
-  basic_address_iterator ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_.overload2 operator--]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v4 >::operator-- (1 of 2 overloads)]
-
-
-Pre-decrement operator. 
-
-
-  basic_address_iterator & operator--();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v4 >::operator-- (2 of 2 overloads)]
-
-
-Post-decrement operator. 
-
-
-  basic_address_iterator operator--(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_arrow_ ip::basic_address_iterator< address_v4 >::operator->]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_arrow_..operator->..ip::basic_address_iterator< address_v4 >] 
-Dereference the iterator. 
-
-
-  const address_v4 * operator->() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_address_iterator< address_v4 >::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_..operator=..ip::basic_address_iterator< address_v4 >] 
-Assignment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_.overload1 operator=]``(
-      const basic_address_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_.overload2 operator=]``(
-      basic_address_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v4 >::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_address_iterator & operator=(
-      const basic_address_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v4 >::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_address_iterator & operator=(
-      basic_address_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::basic_address_iterator< address_v4 >::operator==]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq__eq_..operator==..ip::basic_address_iterator< address_v4 >] 
-Compare two addresses for equality. 
-
-
-  bool operator==(
-      const basic_address_iterator & a,
-      const basic_address_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:pointer ip::basic_address_iterator< address_v4 >::pointer]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.pointer..pointer..ip::basic_address_iterator< address_v4 >] 
-The type of a pointer to an element pointed to by the iterator. 
-
-
-  typedef const address_v4 * pointer;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reference ip::basic_address_iterator< address_v4 >::reference]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.reference..reference..ip::basic_address_iterator< address_v4 >] 
-The type of a reference to an element pointed to by the iterator. 
-
-
-  typedef const address_v4 & reference;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v4.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__address_v4.uint_type [*uint_type]]]
-    [The type used to represent an address as an unsigned integer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.address_v4 [*address_v4]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes. 
-     [hr]
-     Construct an address from an unsigned integer in host byte order. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.broadcast [*broadcast]] [static]]
-    [Obtain an address object that represents the broadcast address. 
-     [hr]
-     (Deprecated: Use network_v4 class.) Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v4().) Create an address from an IP address string in dotted decimal form. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_a [*is_class_a]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class A address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_b [*is_class_b]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class B address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_c [*is_class_c]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class C address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.netmask [*netmask]] [static]]
-    [(Deprecated: Use network_v4 class.) Obtain the netmask that corresponds to the address, based on its address class. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_string [*to_string]]]
-    [Get the address as a string in dotted decimal format. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string in dotted decimal format. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_uint [*to_uint]]]
-    [Get the address as an unsigned integer in host byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_ulong [*to_ulong]]]
-    [(Deprecated: Use to_uint().) Get the address as an unsigned long in host byte order. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.make_address_v4 [*make_address_v4]]]
-    [Create an IPv4 address from raw bytes in network order. 
-
-     Create an IPv4 address from an unsigned integer in host byte order. 
-
-     Create an IPv4 address from an IP address string in dotted decimal form. 
-
-     Create an IPv4 address from a IPv4-mapped IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]]
-    [Create an IPv4 network from an address and prefix length. 
-
-     Create an IPv4 network from an address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v4 `ip::address_v4`] class provides the ability to use and manipulate IP version 4 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:value_type ip::basic_address_iterator< address_v4 >::value_type]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v4__gt_.value_type..value_type..ip::basic_address_iterator< address_v4 >] 
-The type of the elements pointed to by the iterator. 
-
-
-  typedef address_v4 value_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v4.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__address_v4.uint_type [*uint_type]]]
-    [The type used to represent an address as an unsigned integer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.address_v4 [*address_v4]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes. 
-     [hr]
-     Construct an address from an unsigned integer in host byte order. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.broadcast [*broadcast]] [static]]
-    [Obtain an address object that represents the broadcast address. 
-     [hr]
-     (Deprecated: Use network_v4 class.) Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v4().) Create an address from an IP address string in dotted decimal form. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_a [*is_class_a]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class A address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_b [*is_class_b]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class B address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_class_c [*is_class_c]]]
-    [(Deprecated: Use network_v4 class.) Determine whether the address is a class C address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.netmask [*netmask]] [static]]
-    [(Deprecated: Use network_v4 class.) Obtain the netmask that corresponds to the address, based on its address class. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_string [*to_string]]]
-    [Get the address as a string in dotted decimal format. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string in dotted decimal format. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_uint [*to_uint]]]
-    [Get the address as an unsigned integer in host byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.to_ulong [*to_ulong]]]
-    [(Deprecated: Use to_uint().) Get the address as an unsigned long in host byte order. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4.make_address_v4 [*make_address_v4]]]
-    [Create an IPv4 address from raw bytes in network order. 
-
-     Create an IPv4 address from an unsigned integer in host byte order. 
-
-     Create an IPv4 address from an IP address string in dotted decimal form. 
-
-     Create an IPv4 address from a IPv4-mapped IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.make_network_v4 [*make_network_v4]]]
-    [Create an IPv4 network from an address and prefix length. 
-
-     Create an IPv4 network from an address and netmask. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v4.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v4 `ip::address_v4`] class provides the ability to use and manipulate IP version 4 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_address_iterator_lt__address_v6__gt_ ip::basic_address_iterator< address_v6 >]
-
-[indexterm1 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_..ip::basic_address_iterator< address_v6 >]
-
-
-An input iterator that can be used for traversing IPv6 addresses. 
-
-
-  template<>
-  class basic_address_iterator< address_v6 >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_address_iterator ip::basic_address_iterator< address_v6 >::basic_address_iterator]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator..basic_address_iterator..ip::basic_address_iterator< address_v6 >] 
-Construct an iterator that points to the specified address. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload1 basic_address_iterator]``(
-      const address_v6 & addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload2 basic_address_iterator]``(
-      const basic_address_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload3 basic_address_iterator]``(
-      basic_address_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator.overload3 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v6 >::basic_address_iterator (1 of 3 overloads)]
-
-
-Construct an iterator that points to the specified address. 
-
-
-  basic_address_iterator(
-      const address_v6 & addr);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v6 >::basic_address_iterator (2 of 3 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_address_iterator(
-      const basic_address_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_address_iterator< address_v6 >::basic_address_iterator (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  basic_address_iterator(
-      basic_address_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:difference_type ip::basic_address_iterator< address_v6 >::difference_type]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.difference_type..difference_type..ip::basic_address_iterator< address_v6 >] 
-Distance between two iterators. 
-
-
-  typedef std::ptrdiff_t difference_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:iterator_category ip::basic_address_iterator< address_v6 >::iterator_category]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.iterator_category..iterator_category..ip::basic_address_iterator< address_v6 >] 
-Denotes that the iterator satisfies the input iterator requirements. 
-
-
-  typedef std::input_iterator_tag iterator_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::basic_address_iterator< address_v6 >::operator!=]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_not__eq_..operator!=..ip::basic_address_iterator< address_v6 >] 
-Compare two addresses for inequality. 
-
-
-  bool operator!=(
-      const basic_address_iterator & a,
-      const basic_address_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_star_ ip::basic_address_iterator< address_v6 >::operator*]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_star_..operator*..ip::basic_address_iterator< address_v6 >] 
-Dereference the iterator. 
-
-
-  const address_v6 & operator*() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus__plus_ ip::basic_address_iterator< address_v6 >::operator++]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_..operator++..ip::basic_address_iterator< address_v6 >] 
-Pre-increment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_.overload1 operator++]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_.overload1 more...]]``
-
-
-Post-increment operator. 
-
-
-  basic_address_iterator ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_.overload2 operator++]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v6 >::operator++ (1 of 2 overloads)]
-
-
-Pre-increment operator. 
-
-
-  basic_address_iterator & operator++();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v6 >::operator++ (2 of 2 overloads)]
-
-
-Post-increment operator. 
-
-
-  basic_address_iterator operator++(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_minus__minus_ ip::basic_address_iterator< address_v6 >::operator--]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_..operator--..ip::basic_address_iterator< address_v6 >] 
-Pre-decrement operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_.overload1 operator--]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_.overload1 more...]]``
-
-
-Post-decrement operator. 
-
-
-  basic_address_iterator ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_.overload2 operator--]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v6 >::operator-- (1 of 2 overloads)]
-
-
-Pre-decrement operator. 
-
-
-  basic_address_iterator & operator--();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v6 >::operator-- (2 of 2 overloads)]
-
-
-Post-decrement operator. 
-
-
-  basic_address_iterator operator--(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_arrow_ ip::basic_address_iterator< address_v6 >::operator->]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_arrow_..operator->..ip::basic_address_iterator< address_v6 >] 
-Dereference the iterator. 
-
-
-  const address_v6 * operator->() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_address_iterator< address_v6 >::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_..operator=..ip::basic_address_iterator< address_v6 >] 
-Assignment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_.overload1 operator=]``(
-      const basic_address_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_address_iterator & ``[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_.overload2 operator=]``(
-      basic_address_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_iterator< address_v6 >::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_address_iterator & operator=(
-      const basic_address_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_iterator< address_v6 >::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_address_iterator & operator=(
-      basic_address_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::basic_address_iterator< address_v6 >::operator==]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq__eq_..operator==..ip::basic_address_iterator< address_v6 >] 
-Compare two addresses for equality. 
-
-
-  bool operator==(
-      const basic_address_iterator & a,
-      const basic_address_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:pointer ip::basic_address_iterator< address_v6 >::pointer]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.pointer..pointer..ip::basic_address_iterator< address_v6 >] 
-The type of a pointer to an element pointed to by the iterator. 
-
-
-  typedef const address_v6 * pointer;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reference ip::basic_address_iterator< address_v6 >::reference]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.reference..reference..ip::basic_address_iterator< address_v6 >] 
-The type of a reference to an element pointed to by the iterator. 
-
-
-  typedef const address_v6 & reference;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v6.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.address_v6 [*address_v6]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes and scope ID. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv6 address from an IP address string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_link_local [*is_link_local]]]
-    [Determine whether the address is link local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]]
-    [Determine whether the address is a global multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]]
-    [Determine whether the address is a link-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]]
-    [Determine whether the address is a node-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]]
-    [Determine whether the address is a org-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]]
-    [Determine whether the address is a site-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_site_local [*is_site_local]]]
-    [Determine whether the address is site local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]]
-    [(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]]
-    [Determine whether the address is a mapped IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.scope_id [*scope_id]]]
-    [The scope ID of the address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_string [*to_string]]]
-    [Get the address as a string. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_v4 [*to_v4]]]
-    [(Deprecated: Use make_address_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_compatible [*v4_compatible]] [static]]
-    [(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_mapped [*v4_mapped]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.make_address_v6 [*make_address_v6]]]
-    [Create an IPv6 address from raw bytes and scope ID. 
-
-     Create an IPv6 address from an IP address string. 
-
-     Createan IPv6 address from an IP address string. 
-
-     Create an IPv4-mapped IPv6 address from an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]]
-    [Create an IPv6 network from an address and prefix length. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v6 `ip::address_v6`] class provides the ability to use and manipulate IP version 6 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:value_type ip::basic_address_iterator< address_v6 >::value_type]
-
-[indexterm2 asio.indexterm.ip__basic_address_iterator_lt__address_v6__gt_.value_type..value_type..ip::basic_address_iterator< address_v6 >] 
-The type of the elements pointed to by the iterator. 
-
-
-  typedef address_v6 value_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__address_v6.bytes_type [*bytes_type]]]
-    [The type used to represent an address as an array of bytes. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.address_v6 [*address_v6]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an address from raw bytes and scope ID. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.any [*any]] [static]]
-    [Obtain an address object that represents any address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.from_string [*from_string]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv6 address from an IP address string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_link_local [*is_link_local]]]
-    [Determine whether the address is link local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_loopback [*is_loopback]]]
-    [Determine whether the address is a loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast [*is_multicast]]]
-    [Determine whether the address is a multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_global [*is_multicast_global]]]
-    [Determine whether the address is a global multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_link_local [*is_multicast_link_local]]]
-    [Determine whether the address is a link-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_node_local [*is_multicast_node_local]]]
-    [Determine whether the address is a node-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_org_local [*is_multicast_org_local]]]
-    [Determine whether the address is a org-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_multicast_site_local [*is_multicast_site_local]]]
-    [Determine whether the address is a site-local multicast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_site_local [*is_site_local]]]
-    [Determine whether the address is site local. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_unspecified [*is_unspecified]]]
-    [Determine whether the address is unspecified. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_compatible [*is_v4_compatible]]]
-    [(Deprecated: No replacement.) Determine whether the address is an IPv4-compatible address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.is_v4_mapped [*is_v4_mapped]]]
-    [Determine whether the address is a mapped IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.loopback [*loopback]] [static]]
-    [Obtain an address object that represents the loopback address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq_ [*operator=]]]
-    [Assign from another address. 
-     [hr]
-     Move-assign from another address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.scope_id [*scope_id]]]
-    [The scope ID of the address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_bytes [*to_bytes]]]
-    [Get the address in bytes, in network byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_string [*to_string]]]
-    [Get the address as a string. 
-     [hr]
-     (Deprecated: Use other overload.) Get the address as a string. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.to_v4 [*to_v4]]]
-    [(Deprecated: Use make_address_v4().) Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_compatible [*v4_compatible]] [static]]
-    [(Deprecated: No replacement.) Create an IPv4-compatible IPv6 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.v4_mapped [*v4_mapped]] [static]]
-    [(Deprecated: Use make_address_v6().) Create an IPv4-mapped IPv6 address. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt_ [*operator<]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__eq_ [*operator<=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt_ [*operator>]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_gt__eq_ [*operator>=]]]
-    [Compare addresses for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6.make_address_v6 [*make_address_v6]]]
-    [Create an IPv6 address from raw bytes and scope ID. 
-
-     Create an IPv6 address from an IP address string. 
-
-     Createan IPv6 address from an IP address string. 
-
-     Create an IPv4-mapped IPv6 address from an IPv4 address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.make_network_v6 [*make_network_v6]]]
-    [Create an IPv6 network from an address and prefix length. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__address_v6.operator_lt__lt_ [*operator<<]]]
-    [Output an address as a string. 
-
-     Output a network as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__address_v6 `ip::address_v6`] class provides the ability to use and manipulate IP version 6 addresses.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_address_range ip::basic_address_range]
-
-[indexterm1 asio.indexterm.ip__basic_address_range..ip::basic_address_range]
-
-
-
-  template<
-       >
-  class basic_address_range
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:ip__basic_address_range_lt__address_v4__gt_ ip::basic_address_range< address_v4 >]
-
-[indexterm1 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_..ip::basic_address_range< address_v4 >]
-
-
-Represents a range of IPv4 addresses. 
-
-
-  template<>
-  class basic_address_range< address_v4 >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.iterator [*iterator]]]
-    [The type of an iterator that points into the range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range [*basic_address_range]]]
-    [Construct an empty range. 
-     [hr]
-     Construct an range that represents the given range of addresses. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.begin [*begin]]]
-    [Obtain an iterator that points to the start of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.empty [*empty]]]
-    [Determine whether the range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.end [*end]]]
-    [Obtain an iterator that points to the end of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.find [*find]]]
-    [Find an address in the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.size [*size]]]
-    [Return the size of the range. ]
-  ]
-  
-]
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_address_range ip::basic_address_range< address_v4 >::basic_address_range]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.basic_address_range..basic_address_range..ip::basic_address_range< address_v4 >] 
-Construct an empty range. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload1 basic_address_range]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload1 more...]]``
-
-
-Construct an range that represents the given range of addresses. 
-
-
-  explicit ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload2 basic_address_range]``(
-      const iterator & first,
-      const iterator & last);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload3 basic_address_range]``(
-      const basic_address_range & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload4 basic_address_range]``(
-      basic_address_range && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.basic_address_range.overload4 more...]]``
-
-
-[section:overload1 ip::basic_address_range< address_v4 >::basic_address_range (1 of 4 overloads)]
-
-
-Construct an empty range. 
-
-
-  basic_address_range();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_range< address_v4 >::basic_address_range (2 of 4 overloads)]
-
-
-Construct an range that represents the given range of addresses. 
-
-
-  basic_address_range(
-      const iterator & first,
-      const iterator & last);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_address_range< address_v4 >::basic_address_range (3 of 4 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_address_range(
-      const basic_address_range & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_address_range< address_v4 >::basic_address_range (4 of 4 overloads)]
-
-
-Move constructor. 
-
-
-  basic_address_range(
-      basic_address_range && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:begin ip::basic_address_range< address_v4 >::begin]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.begin..begin..ip::basic_address_range< address_v4 >] 
-Obtain an iterator that points to the start of the range. 
-
-
-  iterator begin() const;
-
-
-
-[endsect]
-
-
-
-[section:empty ip::basic_address_range< address_v4 >::empty]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.empty..empty..ip::basic_address_range< address_v4 >] 
-Determine whether the range is empty. 
-
-
-  bool empty() const;
-
-
-
-[endsect]
-
-
-
-[section:end ip::basic_address_range< address_v4 >::end]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.end..end..ip::basic_address_range< address_v4 >] 
-Obtain an iterator that points to the end of the range. 
-
-
-  iterator end() const;
-
-
-
-[endsect]
-
-
-
-[section:find ip::basic_address_range< address_v4 >::find]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.find..find..ip::basic_address_range< address_v4 >] 
-Find an address in the range. 
-
-
-  iterator find(
-      const address_v4 & addr) const;
-
-
-
-[endsect]
-
-
-
-[section:iterator ip::basic_address_range< address_v4 >::iterator]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.iterator..iterator..ip::basic_address_range< address_v4 >] 
-The type of an iterator that points into the range. 
-
-
-  typedef basic_address_iterator< address_v4 > iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v4__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_address_range< address_v4 >::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.operator_eq_..operator=..ip::basic_address_range< address_v4 >] 
-Assignment operator. 
-
-
-  basic_address_range & ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_.overload1 operator=]``(
-      const basic_address_range & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_address_range & ``[link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_.overload2 operator=]``(
-      basic_address_range && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v4__gt_.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_range< address_v4 >::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_address_range & operator=(
-      const basic_address_range & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_range< address_v4 >::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_address_range & operator=(
-      basic_address_range && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:size ip::basic_address_range< address_v4 >::size]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v4__gt_.size..size..ip::basic_address_range< address_v4 >] 
-Return the size of the range. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_address_range_lt__address_v6__gt_ ip::basic_address_range< address_v6 >]
-
-[indexterm1 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_..ip::basic_address_range< address_v6 >]
-
-
-Represents a range of IPv6 addresses. 
-
-
-  template<>
-  class basic_address_range< address_v6 >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.iterator [*iterator]]]
-    [The type of an iterator that points into the range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range [*basic_address_range]]]
-    [Construct an empty range. 
-     [hr]
-     Construct an range that represents the given range of addresses. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.begin [*begin]]]
-    [Obtain an iterator that points to the start of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.empty [*empty]]]
-    [Determine whether the range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.end [*end]]]
-    [Obtain an iterator that points to the end of the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.find [*find]]]
-    [Find an address in the range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_address_range ip::basic_address_range< address_v6 >::basic_address_range]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.basic_address_range..basic_address_range..ip::basic_address_range< address_v6 >] 
-Construct an empty range. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload1 basic_address_range]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload1 more...]]``
-
-
-Construct an range that represents the given range of addresses. 
-
-
-  explicit ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload2 basic_address_range]``(
-      const iterator & first,
-      const iterator & last);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload3 basic_address_range]``(
-      const basic_address_range & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload4 basic_address_range]``(
-      basic_address_range && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.basic_address_range.overload4 more...]]``
-
-
-[section:overload1 ip::basic_address_range< address_v6 >::basic_address_range (1 of 4 overloads)]
-
-
-Construct an empty range. 
-
-
-  basic_address_range();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_range< address_v6 >::basic_address_range (2 of 4 overloads)]
-
-
-Construct an range that represents the given range of addresses. 
-
-
-  basic_address_range(
-      const iterator & first,
-      const iterator & last);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_address_range< address_v6 >::basic_address_range (3 of 4 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_address_range(
-      const basic_address_range & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_address_range< address_v6 >::basic_address_range (4 of 4 overloads)]
-
-
-Move constructor. 
-
-
-  basic_address_range(
-      basic_address_range && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:begin ip::basic_address_range< address_v6 >::begin]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.begin..begin..ip::basic_address_range< address_v6 >] 
-Obtain an iterator that points to the start of the range. 
-
-
-  iterator begin() const;
-
-
-
-[endsect]
-
-
-
-[section:empty ip::basic_address_range< address_v6 >::empty]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.empty..empty..ip::basic_address_range< address_v6 >] 
-Determine whether the range is empty. 
-
-
-  bool empty() const;
-
-
-
-[endsect]
-
-
-
-[section:end ip::basic_address_range< address_v6 >::end]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.end..end..ip::basic_address_range< address_v6 >] 
-Obtain an iterator that points to the end of the range. 
-
-
-  iterator end() const;
-
-
-
-[endsect]
-
-
-
-[section:find ip::basic_address_range< address_v6 >::find]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.find..find..ip::basic_address_range< address_v6 >] 
-Find an address in the range. 
-
-
-  iterator find(
-      const address_v6 & addr) const;
-
-
-
-[endsect]
-
-
-
-[section:iterator ip::basic_address_range< address_v6 >::iterator]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.iterator..iterator..ip::basic_address_range< address_v6 >] 
-The type of an iterator that points into the range. 
-
-
-  typedef basic_address_iterator< address_v6 > iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.difference_type [*difference_type]]]
-    [Distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.iterator_category [*iterator_category]]]
-    [Denotes that the iterator satisfies the input iterator requirements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.pointer [*pointer]]]
-    [The type of a pointer to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.reference [*reference]]]
-    [The type of a reference to an element pointed to by the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.value_type [*value_type]]]
-    [The type of the elements pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.basic_address_iterator [*basic_address_iterator]]]
-    [Construct an iterator that points to the specified address. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_star_ [*operator*]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_plus__plus_ [*operator++]]]
-    [Pre-increment operator. 
-     [hr]
-     Post-increment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_minus__minus_ [*operator--]]]
-    [Pre-decrement operator. 
-     [hr]
-     Post-decrement operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_arrow_ [*operator->]]]
-    [Dereference the iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_not__eq_ [*operator!=]]]
-    [Compare two addresses for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_address_iterator_lt__address_v6__gt_.operator_eq__eq_ [*operator==]]]
-    [Compare two addresses for equality. ]
-  ]
-  
-]
-
-In addition to satisfying the input iterator requirements, this iterator also supports decrement.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6_range.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_address_range< address_v6 >::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_address_range_lt__address_v6__gt_.operator_eq_..operator=..ip::basic_address_range< address_v6 >] 
-Assignment operator. 
-
-
-  basic_address_range & ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_.overload1 operator=]``(
-      const basic_address_range & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_address_range & ``[link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_.overload2 operator=]``(
-      basic_address_range && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_address_range_lt__address_v6__gt_.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_address_range< address_v6 >::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_address_range & operator=(
-      const basic_address_range & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_address_range< address_v6 >::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_address_range & operator=(
-      basic_address_range && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:ip__basic_endpoint ip::basic_endpoint]
-
-[indexterm1 asio.indexterm.ip__basic_endpoint..ip::basic_endpoint]
-
-
-Describes an endpoint for a version-independent IP socket. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  class basic_endpoint
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.address [*address]]]
-    [Get the IP address associated with the endpoint. 
-     [hr]
-     Set the IP address associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 
-     [hr]
-     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.port [*port]]]
-    [Get the port associated with the endpoint. The port number is always in the host's byte order. 
-     [hr]
-     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_endpoint `ip::basic_endpoint`] class template describes an endpoint that may be associated with a particular socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:address ip::basic_endpoint::address]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.address..address..ip::basic_endpoint] 
-Get the IP address associated with the endpoint. 
-
-
-  asio::ip::address ``[link asio.reference.ip__basic_endpoint.address.overload1 address]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.address.overload1 more...]]``
-
-
-Set the IP address associated with the endpoint. 
-
-
-  void ``[link asio.reference.ip__basic_endpoint.address.overload2 address]``(
-      const asio::ip::address & addr);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.address.overload2 more...]]``
-
-
-[section:overload1 ip::basic_endpoint::address (1 of 2 overloads)]
-
-
-Get the IP address associated with the endpoint. 
-
-
-  asio::ip::address address() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_endpoint::address (2 of 2 overloads)]
-
-
-Set the IP address associated with the endpoint. 
-
-
-  void address(
-      const asio::ip::address & addr);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_endpoint ip::basic_endpoint::basic_endpoint]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.basic_endpoint..basic_endpoint..ip::basic_endpoint] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.basic_endpoint.overload1 more...]]``
-
-
-Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR\_ANY or in6addr\_any). This constructor would typically be used for accepting new connections. 
-
-
-  ``[link asio.reference.ip__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
-      const InternetProtocol & internet_protocol,
-      port_type port_num);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.basic_endpoint.overload2 more...]]``
-
-
-Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-
-
-  ``[link asio.reference.ip__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
-      const asio::ip::address & addr,
-      port_type port_num);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.basic_endpoint.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.basic_endpoint.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_endpoint.basic_endpoint.overload5 basic_endpoint]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.basic_endpoint.overload5 more...]]``
-
-
-[section:overload1 ip::basic_endpoint::basic_endpoint (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  basic_endpoint();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_endpoint::basic_endpoint (2 of 5 overloads)]
-
-
-Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR\_ANY or in6addr\_any). This constructor would typically be used for accepting new connections. 
-
-
-  basic_endpoint(
-      const InternetProtocol & internet_protocol,
-      port_type port_num);
-
-
-
-[heading Examples]
-  
-To initialise an IPv4 TCP endpoint for port 1234, use: 
-
-  asio::ip::tcp::endpoint ep(asio::ip::tcp::v4(), 1234);
-
-
-
-
-To specify an IPv6 UDP endpoint for port 9876, use: 
-
-  asio::ip::udp::endpoint ep(asio::ip::udp::v6(), 9876);
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_endpoint::basic_endpoint (3 of 5 overloads)]
-
-
-Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-
-
-  basic_endpoint(
-      const asio::ip::address & addr,
-      port_type port_num);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_endpoint::basic_endpoint (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_endpoint(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::basic_endpoint::basic_endpoint (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  basic_endpoint(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:capacity ip::basic_endpoint::capacity]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.capacity..capacity..ip::basic_endpoint] 
-Get the capacity of the endpoint in the native type. 
-
-
-  std::size_t capacity() const;
-
-
-
-[endsect]
-
-
-[section:data ip::basic_endpoint::data]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.data..data..ip::basic_endpoint] 
-Get the underlying endpoint in the native type. 
-
-
-  data_type * ``[link asio.reference.ip__basic_endpoint.data.overload1 data]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.data.overload1 more...]]``
-
-  const data_type * ``[link asio.reference.ip__basic_endpoint.data.overload2 data]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.data.overload2 more...]]``
-
-
-[section:overload1 ip::basic_endpoint::data (1 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  data_type * data();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_endpoint::data (2 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  const data_type * data() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:data_type ip::basic_endpoint::data_type]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.data_type..data_type..ip::basic_endpoint] 
-The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. 
-
-
-  typedef implementation_defined data_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::basic_endpoint::operator!=]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_not__eq_..operator!=..ip::basic_endpoint] 
-Compare two endpoints for inequality. 
-
-
-  bool operator!=(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ ip::basic_endpoint::operator<]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_lt_..operator<..ip::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt__lt_ ip::basic_endpoint::operator<<]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_lt__lt_..operator<<..ip::basic_endpoint] 
-Output an endpoint as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const basic_endpoint< InternetProtocol > & endpoint);
-
-
-Used to output a human-readable string for a specified endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[endpoint][The endpoint to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-
-[section:operator_lt__eq_ ip::basic_endpoint::operator<=]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_lt__eq_..operator<=..ip::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<=(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_endpoint::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_eq_..operator=..ip::basic_endpoint] 
-Assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.ip__basic_endpoint.operator_eq_.overload1 operator=]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.ip__basic_endpoint.operator_eq_.overload2 operator=]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_endpoint::operator= (1 of 2 overloads)]
-
-
-Assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_endpoint::operator= (2 of 2 overloads)]
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::basic_endpoint::operator==]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_eq__eq_..operator==..ip::basic_endpoint] 
-Compare two endpoints for equality. 
-
-
-  bool operator==(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ ip::basic_endpoint::operator>]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_gt_..operator>..ip::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ ip::basic_endpoint::operator>=]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.operator_gt__eq_..operator>=..ip::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>=(
-      const basic_endpoint< InternetProtocol > & e1,
-      const basic_endpoint< InternetProtocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:port ip::basic_endpoint::port]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.port..port..ip::basic_endpoint] 
-Get the port associated with the endpoint. The port number is always in the host's byte order. 
-
-
-  port_type ``[link asio.reference.ip__basic_endpoint.port.overload1 port]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.port.overload1 more...]]``
-
-
-Set the port associated with the endpoint. The port number is always in the host's byte order. 
-
-
-  void ``[link asio.reference.ip__basic_endpoint.port.overload2 port]``(
-      port_type port_num);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_endpoint.port.overload2 more...]]``
-
-
-[section:overload1 ip::basic_endpoint::port (1 of 2 overloads)]
-
-
-Get the port associated with the endpoint. The port number is always in the host's byte order. 
-
-
-  port_type port() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_endpoint::port (2 of 2 overloads)]
-
-
-Set the port associated with the endpoint. The port number is always in the host's byte order. 
-
-
-  void port(
-      port_type port_num);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:protocol ip::basic_endpoint::protocol]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.protocol..protocol..ip::basic_endpoint] 
-The protocol associated with the endpoint. 
-
-
-  protocol_type protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type ip::basic_endpoint::protocol_type]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.protocol_type..protocol_type..ip::basic_endpoint] 
-The protocol type associated with the endpoint. 
-
-
-  typedef InternetProtocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:resize ip::basic_endpoint::resize]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.resize..resize..ip::basic_endpoint] 
-Set the underlying size of the endpoint in the native type. 
-
-
-  void resize(
-      std::size_t new_size);
-
-
-
-[endsect]
-
-
-
-[section:size ip::basic_endpoint::size]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint.size..size..ip::basic_endpoint] 
-Get the underlying size of the endpoint in the native type. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_resolver ip::basic_resolver]
-
-[indexterm1 asio.indexterm.ip__basic_resolver..ip::basic_resolver]
-
-
-Provides endpoint resolution functionality. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class basic_resolver :
-    public ip::resolver_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
-    [Rebinds the resolver type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.iterator [*iterator]]]
-    [(Deprecated.) The iterator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.query [*query]]]
-    [(Deprecated.) The query type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.results_type [*results_type]]]
-    [The results type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]] [constructor]]
-    [Construct with executor. 
-     [hr]
-     Construct with execution context. 
-     [hr]
-     Move-construct a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the resolver. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
-    [Move-assign a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.resolve [*resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]] [destructor]]
-    [Destroys the resolver. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address_configured ip::basic_resolver::address_configured]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.address_configured..address_configured..ip::basic_resolver] 
-Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 
-
-
-  static const flags address_configured = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:all_matching ip::basic_resolver::all_matching]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.all_matching..all_matching..ip::basic_resolver] 
-If used with v4\_mapped, return all matching IPv6 and IPv4 addresses. 
-
-
-  static const flags all_matching = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:async_resolve ip::basic_resolver::async_resolve]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.async_resolve..async_resolve..ip::basic_resolver] 
-(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload1 async_resolve]``(
-      const query & q,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload1 more...]]``
-
-
-Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload2 async_resolve]``(
-      string_view host,
-      string_view service,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload3 async_resolve]``(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload4 async_resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload5 async_resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload5 more...]]``
-
-
-Asynchronously perform reverse resolution of an endpoint to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ip__basic_resolver.async_resolve.overload6 async_resolve]``(
-      const endpoint_type & e,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.async_resolve.overload6 more...]]``
-
-
-[section:overload1 ip::basic_resolver::async_resolve (1 of 6 overloads)]
-
-
-(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      const query & q,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously resolve a query into a list of endpoint entries. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[q][A query object that determines what endpoints will be returned.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver::async_resolve (2 of 6 overloads)]
-
-
-Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      string_view host,
-      string_view service,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver::async_resolve (3 of 6 overloads)]
-
-
-Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to resolve host and service names into a list of endpoint entries. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_resolver::async_resolve (4 of 6 overloads)]
-
-
-Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to resolve host and service names into a list of endpoint entries. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload5 ip::basic_resolver::async_resolve (5 of 6 overloads)]
-
-
-Asynchronously perform forward resolution of a query to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to resolve host and service names into a list of endpoint entries. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload6 ip::basic_resolver::async_resolve (6 of 6 overloads)]
-
-
-Asynchronously perform reverse resolution of an endpoint to a list of entries. 
-
-
-  template<
-      typename ``[link asio.reference.ResolveToken ResolveToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_resolve(
-      const endpoint_type & e,
-      ResolveToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously resolve an endpoint into a list of endpoint entries. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][An endpoint object that determines what endpoints will be returned.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the resolve completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    resolver::results_type results // Resolved endpoints as a range.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-A successful resolve operation is guaranteed to pass a non-empty range to the handler.
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, results_type) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_resolver ip::basic_resolver::basic_resolver]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.basic_resolver..basic_resolver..ip::basic_resolver] 
-Construct with executor. 
-
-
-  explicit ``[link asio.reference.ip__basic_resolver.basic_resolver.overload1 basic_resolver]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.basic_resolver.overload1 more...]]``
-
-
-Construct with execution context. 
-
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.ip__basic_resolver.basic_resolver.overload2 basic_resolver]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.basic_resolver.overload2 more...]]``
-
-
-Move-construct a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  ``[link asio.reference.ip__basic_resolver.basic_resolver.overload3 basic_resolver]``(
-      basic_resolver && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.basic_resolver.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.ip__basic_resolver.basic_resolver.overload4 basic_resolver]``(
-      basic_resolver< InternetProtocol, Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.basic_resolver.overload4 more...]]``
-
-
-[section:overload1 ip::basic_resolver::basic_resolver (1 of 4 overloads)]
-
-
-Construct with executor. 
-
-
-  basic_resolver(
-      const executor_type & ex);
-
-
-This constructor creates a [link asio.reference.ip__basic_resolver `ip::basic_resolver`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the resolver will use, by default, to dispatch handlers for any asynchronous operations performed on the resolver. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver::basic_resolver (2 of 4 overloads)]
-
-
-Construct with execution context. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_resolver(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a [link asio.reference.ip__basic_resolver `ip::basic_resolver`].
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the resolver will use, by default, to dispatch handlers for any asynchronous operations performed on the resolver. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver::basic_resolver (3 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  basic_resolver(
-      basic_resolver && other);
-
-
-This constructor moves a resolver from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.ip__basic_resolver `ip::basic_resolver`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_resolver(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_resolver::basic_resolver (4 of 4 overloads)]
-
-
-Move-construct a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_resolver(
-      basic_resolver< InternetProtocol, Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value >  = 0);
-
-
-This constructor moves a resolver from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.ip__basic_resolver `ip::basic_resolver`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_resolver(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:cancel ip::basic_resolver::cancel]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.cancel..cancel..ip::basic_resolver] 
-Cancel any asynchronous operations that are waiting on the resolver. 
-
-
-  void cancel();
-
-
-This function forces the completion of any pending asynchronous operations on the host resolver. The handler for each cancelled operation will be invoked with the `asio::error::operation_aborted` error code. 
-
-
-[endsect]
-
-
-
-[section:canonical_name ip::basic_resolver::canonical_name]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.canonical_name..canonical_name..ip::basic_resolver] 
-Determine the canonical name of the host specified in the query. 
-
-
-  static const flags canonical_name = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:endpoint_type ip::basic_resolver::endpoint_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.endpoint_type..endpoint_type..ip::basic_resolver] 
-The endpoint type. 
-
-
-  typedef InternetProtocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_type ip::basic_resolver::executor_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.executor_type..executor_type..ip::basic_resolver] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:flags ip::basic_resolver::flags]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.flags..flags..ip::basic_resolver] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor ip::basic_resolver::get_executor]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.get_executor..get_executor..ip::basic_resolver] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-
-[section:iterator ip::basic_resolver::iterator]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.iterator..iterator..ip::basic_resolver] 
-(Deprecated.) The iterator type. 
-
-
-  typedef basic_resolver_iterator< InternetProtocol > iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.difference_type [*difference_type]]]
-    [The type used for the distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.reference [*reference]]]
-    [The type of the result of applying operator*() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.value_type [*value_type]]]
-    [The type of the value pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]] [constructor]]
-    [Default constructor creates an end iterator. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move-assignment operator. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.dereference [*dereference]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.equal [*equal]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.increment [*increment]]]
-    []
-  ]
-  
-]
-
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.index_ [*index_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_iterator `ip::basic_resolver_iterator`] class template is used to define iterators over the results returned by a resolver.
-
-The iterator's value\_type, obtained when the iterator is dereferenced, is: 
-
-  const basic_resolver_entry<InternetProtocol> 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:numeric_host ip::basic_resolver::numeric_host]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.numeric_host..numeric_host..ip::basic_resolver] 
-Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 
-
-
-  static const flags numeric_host = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:numeric_service ip::basic_resolver::numeric_service]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.numeric_service..numeric_service..ip::basic_resolver] 
-Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 
-
-
-  static const flags numeric_service = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_resolver::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.operator_eq_..operator=..ip::basic_resolver] 
-Move-assign a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  basic_resolver & ``[link asio.reference.ip__basic_resolver.operator_eq_.overload1 operator=]``(
-      basic_resolver && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.operator_eq_.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_resolver & > ``[link asio.reference.ip__basic_resolver.operator_eq_.overload2 operator=]``(
-      basic_resolver< InternetProtocol, Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver::operator= (1 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  basic_resolver & operator=(
-      basic_resolver && other);
-
-
-This assignment operator moves a resolver from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.ip__basic_resolver `ip::basic_resolver`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_resolver(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.ip__basic_resolver `ip::basic_resolver`] from another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_resolver & > operator=(
-      basic_resolver< InternetProtocol, Executor1 > && other);
-
-
-This assignment operator moves a resolver from one object to another. Cancels any outstanding asynchronous operations associated with the target object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.ip__basic_resolver `ip::basic_resolver`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_resolver(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:passive ip::basic_resolver::passive]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.passive..passive..ip::basic_resolver] 
-Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 
-
-
-  static const flags passive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type ip::basic_resolver::protocol_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.protocol_type..protocol_type..ip::basic_resolver] 
-The protocol type. 
-
-
-  typedef InternetProtocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:query ip::basic_resolver::query]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.query..query..ip::basic_resolver] 
-(Deprecated.) The query type. 
-
-
-  typedef basic_resolver_query< InternetProtocol > query;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_query.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint query. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]] [constructor]]
-    [Construct with specified service name for any protocol. 
-     [hr]
-     Construct with specified service name for a given protocol. 
-     [hr]
-     Construct with specified host name and service name for any protocol. 
-     [hr]
-     Construct with specified host name and service name for a given protocol. 
-     [hr]
-     Copy construct a basic_resolver_query from another. 
-     [hr]
-     Move construct a basic_resolver_query from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.hints [*hints]]]
-    [Get the hints associated with the query. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
-    [Get the host name associated with the query. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
-    [Get the service name associated with the query. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver_query `ip::basic_resolver_query`] class template describes a query that can be passed to a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:resolve ip::basic_resolver::resolve]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.resolve..resolve..ip::basic_resolver] 
-(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload1 resolve]``(
-      const query & q);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload1 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload2 resolve]``(
-      const query & q,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload2 more...]]``
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload3 resolve]``(
-      string_view host,
-      string_view service);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload3 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload4 resolve]``(
-      string_view host,
-      string_view service,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload4 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload5 resolve]``(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload5 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload6 resolve]``(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload6 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload7 resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload7 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload8 resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload8 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload9 resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload9 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload10 resolve]``(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload10 more...]]``
-
-
-Perform reverse resolution of an endpoint to a list of entries. 
-
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload11 resolve]``(
-      const endpoint_type & e);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload11 more...]]``
-
-  results_type ``[link asio.reference.ip__basic_resolver.resolve.overload12 resolve]``(
-      const endpoint_type & e,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver.resolve.overload12 more...]]``
-
-
-[section:overload1 ip::basic_resolver::resolve (1 of 12 overloads)]
-
-
-(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const query & q);
-
-
-This function is used to resolve a query into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[q][A query object that determines what endpoints will be returned.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver::resolve (2 of 12 overloads)]
-
-
-(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const query & q,
-      asio::error_code & ec);
-
-
-This function is used to resolve a query into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[q][A query object that determines what endpoints will be returned.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver::resolve (3 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      string_view host,
-      string_view service);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_resolver::resolve (4 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      string_view host,
-      string_view service,
-      asio::error_code & ec);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload5 ip::basic_resolver::resolve (5 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload6 ip::basic_resolver::resolve (6 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      asio::error_code & ec);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload7 ip::basic_resolver::resolve (7 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload8 ip::basic_resolver::resolve (8 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      asio::error_code & ec);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload9 ip::basic_resolver::resolve (9 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload10 ip::basic_resolver::resolve (10 of 12 overloads)]
-
-
-Perform forward resolution of a query to a list of entries. 
-
-
-  results_type resolve(
-      const protocol_type & protocol,
-      string_view host,
-      string_view service,
-      resolver_base::flags resolve_flags,
-      asio::error_code & ec);
-
-
-This function is used to resolve host and service names into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts. See the [link asio.reference.ip__resolver_base `ip::resolver_base`] documentation for the set of available flags.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload11 ip::basic_resolver::resolve (11 of 12 overloads)]
-
-
-Perform reverse resolution of an endpoint to a list of entries. 
-
-
-  results_type resolve(
-      const endpoint_type & e);
-
-
-This function is used to resolve an endpoint into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][An endpoint object that determines what endpoints will be returned.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. A successful call to this function is guaranteed to return a non-empty range.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 ip::basic_resolver::resolve (12 of 12 overloads)]
-
-
-Perform reverse resolution of an endpoint to a list of entries. 
-
-
-  results_type resolve(
-      const endpoint_type & e,
-      asio::error_code & ec);
-
-
-This function is used to resolve an endpoint into a list of endpoint entries.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[e][An endpoint object that determines what endpoints will be returned.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-A range object representing the list of endpoint entries. An empty range is returned if an error occurs. A successful call to this function is guaranteed to return a non-empty range. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:results_type ip::basic_resolver::results_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.results_type..results_type..ip::basic_resolver] 
-The results type. 
-
-
-  typedef basic_resolver_results< InternetProtocol > results_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.const_iterator [*const_iterator]]]
-    [The type of an iterator into the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.const_reference [*const_reference]]]
-    [The type of a const reference to a value in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.difference_type [*difference_type]]]
-    [Type used to represent the distance between two iterators in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the results. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.iterator [*iterator]]]
-    [The type of an iterator into the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.protocol_type [*protocol_type]]]
-    [The protocol type associated with the results. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.reference [*reference]]]
-    [The type of a non-const reference to a value in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.size_type [*size_type]]]
-    [Type used to represent a count of the elements in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.value_type [*value_type]]]
-    [The type of a value in the results range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.basic_resolver_results [*basic_resolver_results]] [constructor]]
-    [Default constructor creates an empty range. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.begin [*begin]]]
-    [Obtain a begin iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.cbegin [*cbegin]]]
-    [Obtain a begin iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.cend [*cend]]]
-    [Obtain an end iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.empty [*empty]]]
-    [Determine whether the results range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.end [*end]]]
-    [Obtain an end iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.max_size [*max_size]]]
-    [Get the maximum number of entries permitted in a results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move-assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.size [*size]]]
-    [Get the number of entries in the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.swap [*swap]]]
-    [Swap the results range with another. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.dereference [*dereference]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.equal [*equal]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.increment [*increment]]]
-    []
-  ]
-  
-]
-
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.index_ [*index_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_results `ip::basic_resolver_results`] class template is used to define a range over the results returned by a resolver.
-
-The iterator's value\_type, obtained when a results iterator is dereferenced, is: 
-
-  const basic_resolver_entry<InternetProtocol> 
-
-
-
-
-
-[heading Remarks]
-      
-For backward compatibility, [link asio.reference.ip__basic_resolver_results `ip::basic_resolver_results`] is derived from [link asio.reference.ip__basic_resolver_iterator `ip::basic_resolver_iterator`]. This derivation is deprecated.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:v4_mapped ip::basic_resolver::v4_mapped]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver.v4_mapped..v4_mapped..ip::basic_resolver] 
-If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 
-
-
-  static const flags v4_mapped = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_basic_resolver ip::basic_resolver::~basic_resolver]
-
-[indexterm2 asio.indexterm.ip__basic_resolver._basic_resolver..~basic_resolver..ip::basic_resolver] 
-Destroys the resolver. 
-
-
-  ~basic_resolver();
-
-
-This function destroys the resolver, cancelling any outstanding asynchronous wait operations associated with the resolver as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_resolver__rebind_executor ip::basic_resolver::rebind_executor]
-
-[indexterm1 asio.indexterm.ip__basic_resolver__rebind_executor..ip::basic_resolver::rebind_executor]
-
-
-Rebinds the resolver type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor.other [*other]]]
-    [The resolver type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other ip::basic_resolver::rebind_executor::other]
-
-[indexterm2 asio.indexterm.ip__basic_resolver__rebind_executor.other..other..ip::basic_resolver::rebind_executor] 
-The resolver type when rebound to the specified executor. 
-
-
-  typedef basic_resolver< InternetProtocol, Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
-    [Rebinds the resolver type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.iterator [*iterator]]]
-    [(Deprecated.) The iterator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.query [*query]]]
-    [(Deprecated.) The query type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.results_type [*results_type]]]
-    [The results type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]] [constructor]]
-    [Construct with executor. 
-     [hr]
-     Construct with execution context. 
-     [hr]
-     Move-construct a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the resolver. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
-    [Move-assign a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.resolve [*resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]] [destructor]]
-    [Destroys the resolver. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_resolver_entry ip::basic_resolver_entry]
-
-[indexterm1 asio.indexterm.ip__basic_resolver_entry..ip::basic_resolver_entry]
-
-
-An entry produced by a resolver. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  class basic_resolver_entry
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the endpoint entry. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint entry. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry [*basic_resolver_entry]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct with specified endpoint, host name and service name. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.endpoint [*endpoint]]]
-    [Get the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.host_name [*host_name]]]
-    [Get the host name associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.operator_endpoint_type [*operator endpoint_type]]]
-    [Convert to the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.service_name [*service_name]]]
-    [Get the service name associated with the entry. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_entry `ip::basic_resolver_entry`] class template describes an entry as returned by a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_entry.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_resolver_entry ip::basic_resolver_entry::basic_resolver_entry]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.basic_resolver_entry..basic_resolver_entry..ip::basic_resolver_entry] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload1 basic_resolver_entry]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload1 more...]]``
-
-
-Construct with specified endpoint, host name and service name. 
-
-
-  ``[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload2 basic_resolver_entry]``(
-      const endpoint_type & ep,
-      string_view host,
-      string_view service);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.basic_resolver_entry.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_entry::basic_resolver_entry (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  basic_resolver_entry();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_entry::basic_resolver_entry (2 of 2 overloads)]
-
-
-Construct with specified endpoint, host name and service name. 
-
-
-  basic_resolver_entry(
-      const endpoint_type & ep,
-      string_view host,
-      string_view service);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:endpoint ip::basic_resolver_entry::endpoint]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.endpoint..endpoint..ip::basic_resolver_entry] 
-Get the endpoint associated with the entry. 
-
-
-  endpoint_type endpoint() const;
-
-
-
-[endsect]
-
-
-
-[section:endpoint_type ip::basic_resolver_entry::endpoint_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.endpoint_type..endpoint_type..ip::basic_resolver_entry] 
-The endpoint type associated with the endpoint entry. 
-
-
-  typedef InternetProtocol::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_entry.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:host_name ip::basic_resolver_entry::host_name]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.host_name..host_name..ip::basic_resolver_entry] 
-Get the host name associated with the entry. 
-
-
-  std::string ``[link asio.reference.ip__basic_resolver_entry.host_name.overload1 host_name]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.host_name.overload1 more...]]``
-
-  template<
-      class Allocator>
-  std::basic_string< char, std::char_traits< char >, Allocator > ``[link asio.reference.ip__basic_resolver_entry.host_name.overload2 host_name]``(
-      const Allocator & alloc = Allocator()) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.host_name.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_entry::host_name (1 of 2 overloads)]
-
-
-Get the host name associated with the entry. 
-
-
-  std::string host_name() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_entry::host_name (2 of 2 overloads)]
-
-
-Get the host name associated with the entry. 
-
-
-  template<
-      class Allocator>
-  std::basic_string< char, std::char_traits< char >, Allocator > host_name(
-      const Allocator & alloc = Allocator()) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_endpoint_type ip::basic_resolver_entry::operator endpoint_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.operator_endpoint_type..operator endpoint_type..ip::basic_resolver_entry] 
-Convert to the endpoint associated with the entry. 
-
-
-  operator endpoint_type() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type ip::basic_resolver_entry::protocol_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.protocol_type..protocol_type..ip::basic_resolver_entry] 
-The protocol type associated with the endpoint entry. 
-
-
-  typedef InternetProtocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_entry.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:service_name ip::basic_resolver_entry::service_name]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_entry.service_name..service_name..ip::basic_resolver_entry] 
-Get the service name associated with the entry. 
-
-
-  std::string ``[link asio.reference.ip__basic_resolver_entry.service_name.overload1 service_name]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.service_name.overload1 more...]]``
-
-  template<
-      class Allocator>
-  std::basic_string< char, std::char_traits< char >, Allocator > ``[link asio.reference.ip__basic_resolver_entry.service_name.overload2 service_name]``(
-      const Allocator & alloc = Allocator()) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_entry.service_name.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_entry::service_name (1 of 2 overloads)]
-
-
-Get the service name associated with the entry. 
-
-
-  std::string service_name() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_entry::service_name (2 of 2 overloads)]
-
-
-Get the service name associated with the entry. 
-
-
-  template<
-      class Allocator>
-  std::basic_string< char, std::char_traits< char >, Allocator > service_name(
-      const Allocator & alloc = Allocator()) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:ip__basic_resolver_iterator ip::basic_resolver_iterator]
-
-[indexterm1 asio.indexterm.ip__basic_resolver_iterator..ip::basic_resolver_iterator]
-
-
-An iterator over the entries produced by a resolver. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  class basic_resolver_iterator
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.difference_type [*difference_type]]]
-    [The type used for the distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.reference [*reference]]]
-    [The type of the result of applying operator*() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.value_type [*value_type]]]
-    [The type of the value pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]] [constructor]]
-    [Default constructor creates an end iterator. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move-assignment operator. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.dereference [*dereference]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.equal [*equal]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.increment [*increment]]]
-    []
-  ]
-  
-]
-
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.index_ [*index_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_iterator `ip::basic_resolver_iterator`] class template is used to define iterators over the results returned by a resolver.
-
-The iterator's value\_type, obtained when the iterator is dereferenced, is: 
-
-  const basic_resolver_entry<InternetProtocol> 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_resolver_iterator ip::basic_resolver_iterator::basic_resolver_iterator]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.basic_resolver_iterator..basic_resolver_iterator..ip::basic_resolver_iterator] 
-Default constructor creates an end iterator. 
-
-
-  ``[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload1 basic_resolver_iterator]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload2 basic_resolver_iterator]``(
-      const basic_resolver_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload3 basic_resolver_iterator]``(
-      basic_resolver_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator.overload3 more...]]``
-
-
-[section:overload1 ip::basic_resolver_iterator::basic_resolver_iterator (1 of 3 overloads)]
-
-
-Default constructor creates an end iterator. 
-
-
-  basic_resolver_iterator();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_iterator::basic_resolver_iterator (2 of 3 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_resolver_iterator(
-      const basic_resolver_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver_iterator::basic_resolver_iterator (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  basic_resolver_iterator(
-      basic_resolver_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:dereference ip::basic_resolver_iterator::dereference]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.dereference..dereference..ip::basic_resolver_iterator] 
-
-  const basic_resolver_entry< InternetProtocol > & dereference() const;
-
-
-
-[endsect]
-
-
-
-[section:difference_type ip::basic_resolver_iterator::difference_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.difference_type..difference_type..ip::basic_resolver_iterator] 
-The type used for the distance between two iterators. 
-
-
-  typedef std::ptrdiff_t difference_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:equal ip::basic_resolver_iterator::equal]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.equal..equal..ip::basic_resolver_iterator] 
-
-  bool equal(
-      const basic_resolver_iterator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:increment ip::basic_resolver_iterator::increment]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.increment..increment..ip::basic_resolver_iterator] 
-
-  void increment();
-
-
-
-[endsect]
-
-
-
-[section:index_ ip::basic_resolver_iterator::index_]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.index_..index_..ip::basic_resolver_iterator] 
-
-  std::size_t index_;
-
-
-
-[endsect]
-
-
-
-[section:iterator_category ip::basic_resolver_iterator::iterator_category]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.iterator_category..iterator_category..ip::basic_resolver_iterator] 
-The iterator category. 
-
-
-  typedef std::forward_iterator_tag iterator_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::basic_resolver_iterator::operator!=]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_not__eq_..operator!=..ip::basic_resolver_iterator] 
-Test two iterators for inequality. 
-
-
-  bool operator!=(
-      const basic_resolver_iterator & a,
-      const basic_resolver_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_star_ ip::basic_resolver_iterator::operator*]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_star_..operator*..ip::basic_resolver_iterator] 
-Dereference an iterator. 
-
-
-  const basic_resolver_entry< InternetProtocol > & operator*() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus__plus_ ip::basic_resolver_iterator::operator++]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_plus__plus_..operator++..ip::basic_resolver_iterator] 
-Increment operator (prefix). 
-
-
-  basic_resolver_iterator & ``[link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_.overload1 operator++]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_.overload1 more...]]``
-
-
-Increment operator (postfix). 
-
-
-  basic_resolver_iterator ``[link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_.overload2 operator++]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_iterator::operator++ (1 of 2 overloads)]
-
-
-Increment operator (prefix). 
-
-
-  basic_resolver_iterator & operator++();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_iterator::operator++ (2 of 2 overloads)]
-
-
-Increment operator (postfix). 
-
-
-  basic_resolver_iterator operator++(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_arrow_ ip::basic_resolver_iterator::operator->]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_arrow_..operator->..ip::basic_resolver_iterator] 
-Dereference an iterator. 
-
-
-  const basic_resolver_entry< InternetProtocol > * operator->() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_resolver_iterator::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_eq_..operator=..ip::basic_resolver_iterator] 
-Assignment operator. 
-
-
-  basic_resolver_iterator & ``[link asio.reference.ip__basic_resolver_iterator.operator_eq_.overload1 operator=]``(
-      const basic_resolver_iterator & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.operator_eq_.overload1 more...]]``
-
-
-Move-assignment operator. 
-
-
-  basic_resolver_iterator & ``[link asio.reference.ip__basic_resolver_iterator.operator_eq_.overload2 operator=]``(
-      basic_resolver_iterator && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_iterator.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_iterator::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_resolver_iterator & operator=(
-      const basic_resolver_iterator & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_iterator::operator= (2 of 2 overloads)]
-
-
-Move-assignment operator. 
-
-
-  basic_resolver_iterator & operator=(
-      basic_resolver_iterator && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::basic_resolver_iterator::operator==]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.operator_eq__eq_..operator==..ip::basic_resolver_iterator] 
-Test two iterators for equality. 
-
-
-  bool operator==(
-      const basic_resolver_iterator & a,
-      const basic_resolver_iterator & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:pointer ip::basic_resolver_iterator::pointer]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.pointer..pointer..ip::basic_resolver_iterator] 
-The type of the result of applying `operator->()` to the iterator. 
-
-
-  typedef const basic_resolver_entry< InternetProtocol > * pointer;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reference ip::basic_resolver_iterator::reference]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.reference..reference..ip::basic_resolver_iterator] 
-The type of the result of applying `operator*()` to the iterator. 
-
-
-  typedef const basic_resolver_entry< InternetProtocol > & reference;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the endpoint entry. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint entry. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry [*basic_resolver_entry]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct with specified endpoint, host name and service name. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.endpoint [*endpoint]]]
-    [Get the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.host_name [*host_name]]]
-    [Get the host name associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.operator_endpoint_type [*operator endpoint_type]]]
-    [Convert to the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.service_name [*service_name]]]
-    [Get the service name associated with the entry. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_entry `ip::basic_resolver_entry`] class template describes an entry as returned by a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:value_type ip::basic_resolver_iterator::value_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.value_type..value_type..ip::basic_resolver_iterator] 
-The type of the value pointed to by the iterator. 
-
-
-  typedef basic_resolver_entry< InternetProtocol > value_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the endpoint entry. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint entry. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry [*basic_resolver_entry]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct with specified endpoint, host name and service name. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.endpoint [*endpoint]]]
-    [Get the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.host_name [*host_name]]]
-    [Get the host name associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.operator_endpoint_type [*operator endpoint_type]]]
-    [Convert to the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.service_name [*service_name]]]
-    [Get the service name associated with the entry. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_entry `ip::basic_resolver_entry`] class template describes an entry as returned by a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:values_ ip::basic_resolver_iterator::values_]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_iterator.values_..values_..ip::basic_resolver_iterator] 
-
-  values_ptr_type values_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_resolver_query ip::basic_resolver_query]
-
-[indexterm1 asio.indexterm.ip__basic_resolver_query..ip::basic_resolver_query]
-
-
-An query to be passed to a resolver. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  class basic_resolver_query :
-    public ip::resolver_query_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_query.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_query.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint query. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.basic_resolver_query [*basic_resolver_query]] [constructor]]
-    [Construct with specified service name for any protocol. 
-     [hr]
-     Construct with specified service name for a given protocol. 
-     [hr]
-     Construct with specified host name and service name for any protocol. 
-     [hr]
-     Construct with specified host name and service name for a given protocol. 
-     [hr]
-     Copy construct a basic_resolver_query from another. 
-     [hr]
-     Move construct a basic_resolver_query from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.hints [*hints]]]
-    [Get the hints associated with the query. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.host_name [*host_name]]]
-    [Get the host name associated with the query. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_query.service_name [*service_name]]]
-    [Get the service name associated with the query. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_query.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver_query `ip::basic_resolver_query`] class template describes a query that can be passed to a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address_configured ip::basic_resolver_query::address_configured]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.address_configured..address_configured..ip::basic_resolver_query] 
-Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 
-
-
-  static const flags address_configured = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:all_matching ip::basic_resolver_query::all_matching]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.all_matching..all_matching..ip::basic_resolver_query] 
-If used with v4\_mapped, return all matching IPv6 and IPv4 addresses. 
-
-
-  static const flags all_matching = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:basic_resolver_query ip::basic_resolver_query::basic_resolver_query]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.basic_resolver_query..basic_resolver_query..ip::basic_resolver_query] 
-Construct with specified service name for any protocol. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload1 basic_resolver_query]``(
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = passive|address_configured);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload1 more...]]``
-
-
-Construct with specified service name for a given protocol. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload2 basic_resolver_query]``(
-      const protocol_type & protocol,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = passive|address_configured);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload2 more...]]``
-
-
-Construct with specified host name and service name for any protocol. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload3 basic_resolver_query]``(
-      const std::string & host,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = address_configured);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload3 more...]]``
-
-
-Construct with specified host name and service name for a given protocol. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload4 basic_resolver_query]``(
-      const protocol_type & protocol,
-      const std::string & host,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = address_configured);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload4 more...]]``
-
-
-Copy construct a `basic_resolver_query` from another. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload5 basic_resolver_query]``(
-      const basic_resolver_query & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload5 more...]]``
-
-
-Move construct a `basic_resolver_query` from another. 
-
-
-  ``[link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload6 basic_resolver_query]``(
-      basic_resolver_query && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_query.basic_resolver_query.overload6 more...]]``
-
-
-[section:overload1 ip::basic_resolver_query::basic_resolver_query (1 of 6 overloads)]
-
-
-Construct with specified service name for any protocol. 
-
-
-  basic_resolver_query(
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = passive|address_configured);
-
-
-This constructor is typically used to perform name resolution for local service binding.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for local service binding.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_query::basic_resolver_query (2 of 6 overloads)]
-
-
-Construct with specified service name for a given protocol. 
-
-
-  basic_resolver_query(
-      const protocol_type & protocol,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = passive|address_configured);
-
-
-This constructor is typically used to perform name resolution for local service binding with a specific protocol version.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for local service binding.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver_query::basic_resolver_query (3 of 6 overloads)]
-
-
-Construct with specified host name and service name for any protocol. 
-
-
-  basic_resolver_query(
-      const std::string & host,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = address_configured);
-
-
-This constructor is typically used to perform name resolution for communication with remote hosts.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload4 ip::basic_resolver_query::basic_resolver_query (4 of 6 overloads)]
-
-
-Construct with specified host name and service name for a given protocol. 
-
-
-  basic_resolver_query(
-      const protocol_type & protocol,
-      const std::string & host,
-      const std::string & service,
-      resolver_query_base::flags resolve_flags = address_configured);
-
-
-This constructor is typically used to perform name resolution for communication with remote hosts.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[protocol][A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.]]
-
-[[host][A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.]]
-
-[[service][A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.]]
-
-[[resolve_flags][A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts.]]
-
-]
-
-
-[heading Remarks]
-      
-On POSIX systems, host names may be locally defined in the file `/etc/hosts`. On Windows, host names may be defined in the file `c:\windows\system32\drivers\etc\hosts`. Remote host name resolution is performed using DNS. Operating systems may use additional locations when resolving host names (such as NETBIOS names on Windows).
-
-On POSIX systems, service names are typically defined in the file `/etc/services`. On Windows, service names may be found in the file `c:\windows\system32\drivers\etc\services`. Operating systems may use additional locations when resolving service names. 
-
-
-[endsect]
-
-
-
-[section:overload5 ip::basic_resolver_query::basic_resolver_query (5 of 6 overloads)]
-
-
-Copy construct a `basic_resolver_query` from another. 
-
-
-  basic_resolver_query(
-      const basic_resolver_query & other);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::basic_resolver_query::basic_resolver_query (6 of 6 overloads)]
-
-
-Move construct a `basic_resolver_query` from another. 
-
-
-  basic_resolver_query(
-      basic_resolver_query && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:canonical_name ip::basic_resolver_query::canonical_name]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.canonical_name..canonical_name..ip::basic_resolver_query] 
-Determine the canonical name of the host specified in the query. 
-
-
-  static const flags canonical_name = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:flags ip::basic_resolver_query::flags]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.flags..flags..ip::basic_resolver_query] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:hints ip::basic_resolver_query::hints]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.hints..hints..ip::basic_resolver_query] 
-Get the hints associated with the query. 
-
-
-  const asio::detail::addrinfo_type & hints() const;
-
-
-
-[endsect]
-
-
-
-[section:host_name ip::basic_resolver_query::host_name]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.host_name..host_name..ip::basic_resolver_query] 
-Get the host name associated with the query. 
-
-
-  std::string host_name() const;
-
-
-
-[endsect]
-
-
-
-[section:numeric_host ip::basic_resolver_query::numeric_host]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.numeric_host..numeric_host..ip::basic_resolver_query] 
-Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 
-
-
-  static const flags numeric_host = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:numeric_service ip::basic_resolver_query::numeric_service]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.numeric_service..numeric_service..ip::basic_resolver_query] 
-Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 
-
-
-  static const flags numeric_service = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:passive ip::basic_resolver_query::passive]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.passive..passive..ip::basic_resolver_query] 
-Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 
-
-
-  static const flags passive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type ip::basic_resolver_query::protocol_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.protocol_type..protocol_type..ip::basic_resolver_query] 
-The protocol type associated with the endpoint query. 
-
-
-  typedef InternetProtocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:service_name ip::basic_resolver_query::service_name]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.service_name..service_name..ip::basic_resolver_query] 
-Get the service name associated with the query. 
-
-
-  std::string service_name() const;
-
-
-
-[endsect]
-
-
-
-[section:v4_mapped ip::basic_resolver_query::v4_mapped]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_query.v4_mapped..v4_mapped..ip::basic_resolver_query] 
-If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 
-
-
-  static const flags v4_mapped = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_resolver_results ip::basic_resolver_results]
-
-[indexterm1 asio.indexterm.ip__basic_resolver_results..ip::basic_resolver_results]
-
-
-A range of entries produced by a resolver. 
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  class basic_resolver_results :
-    public ip::basic_resolver_iterator< InternetProtocol >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.const_iterator [*const_iterator]]]
-    [The type of an iterator into the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.const_reference [*const_reference]]]
-    [The type of a const reference to a value in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.difference_type [*difference_type]]]
-    [Type used to represent the distance between two iterators in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the results. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.iterator [*iterator]]]
-    [The type of an iterator into the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.protocol_type [*protocol_type]]]
-    [The protocol type associated with the results. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.reference [*reference]]]
-    [The type of a non-const reference to a value in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.size_type [*size_type]]]
-    [Type used to represent a count of the elements in the range. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_results.value_type [*value_type]]]
-    [The type of a value in the results range. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.basic_resolver_results [*basic_resolver_results]] [constructor]]
-    [Default constructor creates an empty range. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.begin [*begin]]]
-    [Obtain a begin iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.cbegin [*cbegin]]]
-    [Obtain a begin iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.cend [*cend]]]
-    [Obtain an end iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.empty [*empty]]]
-    [Determine whether the results range is empty. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.end [*end]]]
-    [Obtain an end iterator for the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.max_size [*max_size]]]
-    [Get the maximum number of entries permitted in a results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move-assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.size [*size]]]
-    [Get the number of entries in the results range. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.swap [*swap]]]
-    [Swap the results range with another. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.dereference [*dereference]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.equal [*equal]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.increment [*increment]]]
-    []
-  ]
-  
-]
-
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.index_ [*index_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_results.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_results `ip::basic_resolver_results`] class template is used to define a range over the results returned by a resolver.
-
-The iterator's value\_type, obtained when a results iterator is dereferenced, is: 
-
-  const basic_resolver_entry<InternetProtocol> 
-
-
-
-
-
-[heading Remarks]
-      
-For backward compatibility, [link asio.reference.ip__basic_resolver_results `ip::basic_resolver_results`] is derived from [link asio.reference.ip__basic_resolver_iterator `ip::basic_resolver_iterator`]. This derivation is deprecated.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_resolver_results ip::basic_resolver_results::basic_resolver_results]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.basic_resolver_results..basic_resolver_results..ip::basic_resolver_results] 
-Default constructor creates an empty range. 
-
-
-  ``[link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload1 basic_resolver_results]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload1 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload2 basic_resolver_results]``(
-      const basic_resolver_results & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload2 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload3 basic_resolver_results]``(
-      basic_resolver_results && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.basic_resolver_results.overload3 more...]]``
-
-
-[section:overload1 ip::basic_resolver_results::basic_resolver_results (1 of 3 overloads)]
-
-
-Default constructor creates an empty range. 
-
-
-  basic_resolver_results();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_results::basic_resolver_results (2 of 3 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_resolver_results(
-      const basic_resolver_results & other);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::basic_resolver_results::basic_resolver_results (3 of 3 overloads)]
-
-
-Move constructor. 
-
-
-  basic_resolver_results(
-      basic_resolver_results && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:begin ip::basic_resolver_results::begin]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.begin..begin..ip::basic_resolver_results] 
-Obtain a begin iterator for the results range. 
-
-
-  const_iterator begin() const;
-
-
-
-[endsect]
-
-
-
-[section:cbegin ip::basic_resolver_results::cbegin]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.cbegin..cbegin..ip::basic_resolver_results] 
-Obtain a begin iterator for the results range. 
-
-
-  const_iterator cbegin() const;
-
-
-
-[endsect]
-
-
-
-[section:cend ip::basic_resolver_results::cend]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.cend..cend..ip::basic_resolver_results] 
-Obtain an end iterator for the results range. 
-
-
-  const_iterator cend() const;
-
-
-
-[endsect]
-
-
-
-[section:const_iterator ip::basic_resolver_results::const_iterator]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.const_iterator..const_iterator..ip::basic_resolver_results] 
-The type of an iterator into the range. 
-
-
-  typedef basic_resolver_iterator< protocol_type > const_iterator;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.difference_type [*difference_type]]]
-    [The type used for the distance between two iterators. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.iterator_category [*iterator_category]]]
-    [The iterator category. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.pointer [*pointer]]]
-    [The type of the result of applying operator->() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.reference [*reference]]]
-    [The type of the result of applying operator*() to the iterator. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_iterator.value_type [*value_type]]]
-    [The type of the value pointed to by the iterator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.basic_resolver_iterator [*basic_resolver_iterator]] [constructor]]
-    [Default constructor creates an end iterator. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_star_ [*operator*]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_plus__plus_ [*operator++]]]
-    [Increment operator (prefix). 
-     [hr]
-     Increment operator (postfix). ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_arrow_ [*operator->]]]
-    [Dereference an iterator. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move-assignment operator. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.dereference [*dereference]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.equal [*equal]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.increment [*increment]]]
-    []
-  ]
-  
-]
-
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.index_ [*index_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_not__eq_ [*operator!=]]]
-    [Test two iterators for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_iterator.operator_eq__eq_ [*operator==]]]
-    [Test two iterators for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_iterator `ip::basic_resolver_iterator`] class template is used to define iterators over the results returned by a resolver.
-
-The iterator's value\_type, obtained when the iterator is dereferenced, is: 
-
-  const basic_resolver_entry<InternetProtocol> 
-
-
-
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:const_reference ip::basic_resolver_results::const_reference]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.const_reference..const_reference..ip::basic_resolver_results] 
-The type of a const reference to a value in the range. 
-
-
-  typedef const value_type & const_reference;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:dereference ip::basic_resolver_results::dereference]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.dereference..dereference..ip::basic_resolver_results] 
-
-  const basic_resolver_entry< InternetProtocol > & dereference() const;
-
-
-
-[endsect]
-
-
-
-[section:difference_type ip::basic_resolver_results::difference_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.difference_type..difference_type..ip::basic_resolver_results] 
-Type used to represent the distance between two iterators in the range. 
-
-
-  typedef std::ptrdiff_t difference_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:empty ip::basic_resolver_results::empty]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.empty..empty..ip::basic_resolver_results] 
-Determine whether the results range is empty. 
-
-
-  bool empty() const;
-
-
-
-[endsect]
-
-
-
-[section:end ip::basic_resolver_results::end]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.end..end..ip::basic_resolver_results] 
-Obtain an end iterator for the results range. 
-
-
-  const_iterator end() const;
-
-
-
-[endsect]
-
-
-
-[section:endpoint_type ip::basic_resolver_results::endpoint_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.endpoint_type..endpoint_type..ip::basic_resolver_results] 
-The endpoint type associated with the results. 
-
-
-  typedef protocol_type::endpoint endpoint_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:equal ip::basic_resolver_results::equal]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.equal..equal..ip::basic_resolver_results] 
-
-  bool equal(
-      const basic_resolver_iterator & other) const;
-
-
-
-[endsect]
-
-
-
-[section:increment ip::basic_resolver_results::increment]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.increment..increment..ip::basic_resolver_results] 
-
-  void increment();
-
-
-
-[endsect]
-
-
-
-[section:index_ ip::basic_resolver_results::index_]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.index_..index_..ip::basic_resolver_results] 
-
-  std::size_t index_;
-
-
-
-[endsect]
-
-
-
-[section:iterator ip::basic_resolver_results::iterator]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.iterator..iterator..ip::basic_resolver_results] 
-The type of an iterator into the range. 
-
-
-  typedef const_iterator iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:iterator_category ip::basic_resolver_results::iterator_category]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.iterator_category..iterator_category..ip::basic_resolver_results] 
-The iterator category. 
-
-
-  typedef std::forward_iterator_tag iterator_category;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_size ip::basic_resolver_results::max_size]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.max_size..max_size..ip::basic_resolver_results] 
-Get the maximum number of entries permitted in a results range. 
-
-
-  size_type max_size() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::basic_resolver_results::operator!=]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_not__eq_..operator!=..ip::basic_resolver_results] 
-Test two iterators for inequality. 
-
-
-  bool operator!=(
-      const basic_resolver_results & a,
-      const basic_resolver_results & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_star_ ip::basic_resolver_results::operator*]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_star_..operator*..ip::basic_resolver_results] 
-Dereference an iterator. 
-
-
-  const basic_resolver_entry< InternetProtocol > & operator*() const;
-
-
-
-[endsect]
-
-
-[section:operator_plus__plus_ ip::basic_resolver_results::operator++]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_plus__plus_..operator++..ip::basic_resolver_results] 
-Increment operator (prefix). 
-
-
-  basic_resolver_iterator & ``[link asio.reference.ip__basic_resolver_results.operator_plus__plus_.overload1 operator++]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.operator_plus__plus_.overload1 more...]]``
-
-
-Increment operator (postfix). 
-
-
-  basic_resolver_iterator ``[link asio.reference.ip__basic_resolver_results.operator_plus__plus_.overload2 operator++]``(
-      int );
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.operator_plus__plus_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_results::operator++ (1 of 2 overloads)]
-
-
-['Inherited from ip::basic_resolver.]
-
-
-Increment operator (prefix). 
-
-
-  basic_resolver_iterator & operator++();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_results::operator++ (2 of 2 overloads)]
-
-
-['Inherited from ip::basic_resolver.]
-
-
-Increment operator (postfix). 
-
-
-  basic_resolver_iterator operator++(
-      int );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_arrow_ ip::basic_resolver_results::operator->]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_arrow_..operator->..ip::basic_resolver_results] 
-Dereference an iterator. 
-
-
-  const basic_resolver_entry< InternetProtocol > * operator->() const;
-
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::basic_resolver_results::operator=]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_eq_..operator=..ip::basic_resolver_results] 
-Assignment operator. 
-
-
-  basic_resolver_results & ``[link asio.reference.ip__basic_resolver_results.operator_eq_.overload1 operator=]``(
-      const basic_resolver_results & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.operator_eq_.overload1 more...]]``
-
-
-Move-assignment operator. 
-
-
-  basic_resolver_results & ``[link asio.reference.ip__basic_resolver_results.operator_eq_.overload2 operator=]``(
-      basic_resolver_results && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__basic_resolver_results.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::basic_resolver_results::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_resolver_results & operator=(
-      const basic_resolver_results & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::basic_resolver_results::operator= (2 of 2 overloads)]
-
-
-Move-assignment operator. 
-
-
-  basic_resolver_results & operator=(
-      basic_resolver_results && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::basic_resolver_results::operator==]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.operator_eq__eq_..operator==..ip::basic_resolver_results] 
-Test two iterators for equality. 
-
-
-  bool operator==(
-      const basic_resolver_results & a,
-      const basic_resolver_results & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:pointer ip::basic_resolver_results::pointer]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.pointer..pointer..ip::basic_resolver_results] 
-The type of the result of applying `operator->()` to the iterator. 
-
-
-  typedef const basic_resolver_entry< InternetProtocol > * pointer;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol_type ip::basic_resolver_results::protocol_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.protocol_type..protocol_type..ip::basic_resolver_results] 
-The protocol type associated with the results. 
-
-
-  typedef InternetProtocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reference ip::basic_resolver_results::reference]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.reference..reference..ip::basic_resolver_results] 
-The type of a non-const reference to a value in the range. 
-
-
-  typedef value_type & reference;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:size ip::basic_resolver_results::size]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.size..size..ip::basic_resolver_results] 
-Get the number of entries in the results range. 
-
-
-  size_type size() const;
-
-
-
-[endsect]
-
-
-
-[section:size_type ip::basic_resolver_results::size_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.size_type..size_type..ip::basic_resolver_results] 
-Type used to represent a count of the elements in the range. 
-
-
-  typedef std::size_t size_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:swap ip::basic_resolver_results::swap]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.swap..swap..ip::basic_resolver_results] 
-Swap the results range with another. 
-
-
-  void swap(
-      basic_resolver_results & that);
-
-
-
-[endsect]
-
-
-
-[section:value_type ip::basic_resolver_results::value_type]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.value_type..value_type..ip::basic_resolver_results] 
-The type of a value in the results range. 
-
-
-  typedef basic_resolver_entry< protocol_type > value_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.endpoint_type [*endpoint_type]]]
-    [The endpoint type associated with the endpoint entry. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver_entry.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint entry. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver_entry.basic_resolver_entry [*basic_resolver_entry]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct with specified endpoint, host name and service name. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.endpoint [*endpoint]]]
-    [Get the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.host_name [*host_name]]]
-    [Get the host name associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.operator_endpoint_type [*operator endpoint_type]]]
-    [Convert to the endpoint associated with the entry. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver_entry.service_name [*service_name]]]
-    [Get the service name associated with the entry. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_resolver_entry `ip::basic_resolver_entry`] class template describes an entry as returned by a resolver.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_resolver_results.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:values_ ip::basic_resolver_results::values_]
-
-
-['Inherited from ip::basic_resolver.]
-
-[indexterm2 asio.indexterm.ip__basic_resolver_results.values_..values_..ip::basic_resolver_results] 
-
-  values_ptr_type values_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__host_name ip::host_name]
-
-[indexterm1 asio.indexterm.ip__host_name..ip::host_name]
-
-Get the current host name. 
-
-  std::string ``[link asio.reference.ip__host_name.overload1 host_name]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__host_name.overload1 more...]]``
-
-  std::string ``[link asio.reference.ip__host_name.overload2 host_name]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__host_name.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/ip/host_name.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 ip::host_name (1 of 2 overloads)]
-
-
-Get the current host name. 
-
-
-  std::string host_name();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::host_name (2 of 2 overloads)]
-
-
-Get the current host name. 
-
-
-  std::string host_name(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:ip__icmp ip::icmp]
-
-[indexterm1 asio.indexterm.ip__icmp..ip::icmp]
-
-
-Encapsulates the flags needed for ICMP. 
-
-
-  class icmp
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__icmp.endpoint [*endpoint]]]
-    [The type of a ICMP endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__icmp.resolver [*resolver]]]
-    [The ICMP resolver type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__icmp.socket [*socket]]]
-    [The ICMP socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__icmp.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__icmp.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__icmp.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__icmp.v4 [*v4]] [static]]
-    [Construct to represent the IPv4 ICMP protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__icmp.v6 [*v6]] [static]]
-    [Construct to represent the IPv6 ICMP protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__icmp.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__icmp.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__icmp `ip::icmp`] class contains flags necessary for ICMP sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint ip::icmp::endpoint]
-
-[indexterm2 asio.indexterm.ip__icmp.endpoint..endpoint..ip::icmp] 
-The type of a ICMP endpoint. 
-
-
-  typedef basic_endpoint< icmp > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.address [*address]]]
-    [Get the IP address associated with the endpoint. 
-     [hr]
-     Set the IP address associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 
-     [hr]
-     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.port [*port]]]
-    [Get the port associated with the endpoint. The port number is always in the host's byte order. 
-     [hr]
-     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_endpoint `ip::basic_endpoint`] class template describes an endpoint that may be associated with a particular socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family ip::icmp::family]
-
-[indexterm2 asio.indexterm.ip__icmp.family..family..ip::icmp] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::icmp::operator!=]
-
-[indexterm2 asio.indexterm.ip__icmp.operator_not__eq_..operator!=..ip::icmp] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const icmp & p1,
-      const icmp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ ip::icmp::operator==]
-
-[indexterm2 asio.indexterm.ip__icmp.operator_eq__eq_..operator==..ip::icmp] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const icmp & p1,
-      const icmp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol ip::icmp::protocol]
-
-[indexterm2 asio.indexterm.ip__icmp.protocol..protocol..ip::icmp] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:resolver ip::icmp::resolver]
-
-[indexterm2 asio.indexterm.ip__icmp.resolver..resolver..ip::icmp] 
-The ICMP resolver type. 
-
-
-  typedef basic_resolver< icmp > resolver;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
-    [Rebinds the resolver type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.iterator [*iterator]]]
-    [(Deprecated.) The iterator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.query [*query]]]
-    [(Deprecated.) The query type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.results_type [*results_type]]]
-    [The results type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]] [constructor]]
-    [Construct with executor. 
-     [hr]
-     Construct with execution context. 
-     [hr]
-     Move-construct a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the resolver. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
-    [Move-assign a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.resolve [*resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]] [destructor]]
-    [Destroys the resolver. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:socket ip::icmp::socket]
-
-[indexterm2 asio.indexterm.ip__icmp.socket..socket..ip::icmp] 
-The ICMP socket type. 
-
-
-  typedef basic_raw_socket< icmp > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_raw_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_raw_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.basic_raw_socket [*basic_raw_socket]] [constructor]]
-    [Construct a basic_raw_socket without opening it. 
-     [hr]
-     Construct and open a basic_raw_socket. 
-     [hr]
-     Construct a basic_raw_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_raw_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_raw_socket from another. 
-     [hr]
-     Move-construct a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_raw_socket from another. 
-     [hr]
-     Move-assign a basic_raw_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.receive_from [*receive_from]]]
-    [Receive raw data with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.send_to [*send_to]]]
-    [Send raw data to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_raw_socket._basic_raw_socket [*~basic_raw_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_raw_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_raw_socket `basic_raw_socket`] class template provides asynchronous and blocking raw-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/icmp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type ip::icmp::type]
-
-[indexterm2 asio.indexterm.ip__icmp.type..type..ip::icmp] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[section:v4 ip::icmp::v4]
-
-[indexterm2 asio.indexterm.ip__icmp.v4..v4..ip::icmp] 
-Construct to represent the IPv4 ICMP protocol. 
-
-
-  static icmp v4();
-
-
-
-[endsect]
-
-
-
-[section:v6 ip::icmp::v6]
-
-[indexterm2 asio.indexterm.ip__icmp.v6..v6..ip::icmp] 
-Construct to represent the IPv6 ICMP protocol. 
-
-
-  static icmp v6();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ip__multicast__enable_loopback ip::multicast::enable_loopback]
-
-[indexterm1 asio.indexterm.ip__multicast__enable_loopback..ip::multicast::enable_loopback]
-
-Socket option determining whether outgoing multicast packets will be received on the same socket if it is a member of the multicast group. 
-
-
-  typedef implementation_defined enable_loopback;
-
-
-
-Implements the IPPROTO\_IP/IP\_MULTICAST\_LOOP socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::multicast::enable_loopback option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::multicast::enable_loopback option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/multicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__multicast__hops ip::multicast::hops]
-
-[indexterm1 asio.indexterm.ip__multicast__hops..ip::multicast::hops]
-
-Socket option for time-to-live associated with outgoing multicast packets. 
-
-
-  typedef implementation_defined hops;
-
-
-
-Implements the IPPROTO\_IP/IP\_MULTICAST\_TTL socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::multicast::hops option(4);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::multicast::hops option;
-  socket.get_option(option);
-  int ttl = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/multicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__multicast__join_group ip::multicast::join_group]
-
-[indexterm1 asio.indexterm.ip__multicast__join_group..ip::multicast::join_group]
-
-Socket option to join a multicast group on a specified interface. 
-
-
-  typedef implementation_defined join_group;
-
-
-
-Implements the IPPROTO\_IP/IP\_ADD\_MEMBERSHIP socket option.
-
-
-[heading Examples]
-  
-Setting the option to join a multicast group: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::address multicast_address =
-    asio::ip::address::from_string("225.0.0.1");
-  asio::ip::multicast::join_group option(multicast_address);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/multicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__multicast__leave_group ip::multicast::leave_group]
-
-[indexterm1 asio.indexterm.ip__multicast__leave_group..ip::multicast::leave_group]
-
-Socket option to leave a multicast group on a specified interface. 
-
-
-  typedef implementation_defined leave_group;
-
-
-
-Implements the IPPROTO\_IP/IP\_DROP\_MEMBERSHIP socket option.
-
-
-[heading Examples]
-  
-Setting the option to leave a multicast group: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::address multicast_address =
-    asio::ip::address::from_string("225.0.0.1");
-  asio::ip::multicast::leave_group option(multicast_address);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/multicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__multicast__outbound_interface ip::multicast::outbound_interface]
-
-[indexterm1 asio.indexterm.ip__multicast__outbound_interface..ip::multicast::outbound_interface]
-
-Socket option for local interface to use for outgoing multicast packets. 
-
-
-  typedef implementation_defined outbound_interface;
-
-
-
-Implements the IPPROTO\_IP/IP\_MULTICAST\_IF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::address_v4 local_interface =
-    asio::ip::address_v4::from_string("1.2.3.4");
-  asio::ip::multicast::outbound_interface option(local_interface);
-  socket.set_option(option);
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/multicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__network_v4 ip::network_v4]
-
-[indexterm1 asio.indexterm.ip__network_v4..ip::network_v4]
-
-
-Represents an IPv4 network. 
-
-
-  class network_v4
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v4.address [*address]]]
-    [Obtain the address object specified when the network object was created. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.broadcast [*broadcast]]]
-    [Obtain an address object that represents the network's broadcast address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.canonical [*canonical]]]
-    [Obtain the true network address, omitting any host bits. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.hosts [*hosts]]]
-    [Obtain an address range corresponding to the hosts in the network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.is_host [*is_host]]]
-    [Test if network is a valid host address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.is_subnet_of [*is_subnet_of]]]
-    [Test if a network is a real subnet of another network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.netmask [*netmask]]]
-    [Obtain the netmask that was specified when the network object was created. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.network [*network]]]
-    [Obtain an address object that represents the network address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.network_v4 [*network_v4]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct a network based on the specified address and prefix length. 
-     [hr]
-     Construct network based on the specified address and netmask. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.operator_eq_ [*operator=]]]
-    [Assign from another network. 
-     [hr]
-     Move-assign from another network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.prefix_length [*prefix_length]]]
-    [Obtain the prefix length that was specified when the network object was created. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.to_string [*to_string]]]
-    [Get the network as an address in dotted decimal format. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v4.operator_not__eq_ [*operator!=]]]
-    [Compare two networks for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v4.operator_eq__eq_ [*operator==]]]
-    [Compare two networks for equality. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v4.make_network_v4 [*make_network_v4]]]
-    [Create an IPv4 network from a string containing IP address and prefix length. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__network_v4 `ip::network_v4`] class provides the ability to use and manipulate IP version 4 networks.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address ip::network_v4::address]
-
-[indexterm2 asio.indexterm.ip__network_v4.address..address..ip::network_v4] 
-Obtain the address object specified when the network object was created. 
-
-
-  address_v4 address() const;
-
-
-
-[endsect]
-
-
-
-[section:broadcast ip::network_v4::broadcast]
-
-[indexterm2 asio.indexterm.ip__network_v4.broadcast..broadcast..ip::network_v4] 
-Obtain an address object that represents the network's broadcast address. 
-
-
-  address_v4 broadcast() const;
-
-
-
-[endsect]
-
-
-
-[section:canonical ip::network_v4::canonical]
-
-[indexterm2 asio.indexterm.ip__network_v4.canonical..canonical..ip::network_v4] 
-Obtain the true network address, omitting any host bits. 
-
-
-  network_v4 canonical() const;
-
-
-
-[endsect]
-
-
-
-[section:hosts ip::network_v4::hosts]
-
-[indexterm2 asio.indexterm.ip__network_v4.hosts..hosts..ip::network_v4] 
-Obtain an address range corresponding to the hosts in the network. 
-
-
-  address_v4_range hosts() const;
-
-
-
-[endsect]
-
-
-
-[section:is_host ip::network_v4::is_host]
-
-[indexterm2 asio.indexterm.ip__network_v4.is_host..is_host..ip::network_v4] 
-Test if network is a valid host address. 
-
-
-  bool is_host() const;
-
-
-
-[endsect]
-
-
-
-[section:is_subnet_of ip::network_v4::is_subnet_of]
-
-[indexterm2 asio.indexterm.ip__network_v4.is_subnet_of..is_subnet_of..ip::network_v4] 
-Test if a network is a real subnet of another network. 
-
-
-  bool is_subnet_of(
-      const network_v4 & other) const;
-
-
-
-[endsect]
-
-
-[section:make_network_v4 ip::network_v4::make_network_v4]
-
-[indexterm2 asio.indexterm.ip__network_v4.make_network_v4..make_network_v4..ip::network_v4] 
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload1 make_network_v4]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload1 more...]]``
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload2 make_network_v4]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload2 more...]]``
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload3 make_network_v4]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload3 more...]]``
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload4 make_network_v4]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload4 more...]]``
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload5 make_network_v4]``(
-      string_view str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload5 more...]]``
-
-  network_v4 ``[link asio.reference.ip__network_v4.make_network_v4.overload6 make_network_v4]``(
-      string_view str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.make_network_v4.overload6 more...]]``
-
-
-[section:overload1 ip::network_v4::make_network_v4 (1 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v4::make_network_v4 (2 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::network_v4::make_network_v4 (3 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::network_v4::make_network_v4 (4 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::network_v4::make_network_v4 (5 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      string_view str);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::network_v4::make_network_v4 (6 of 6 overloads)]
-
-
-Create an IPv4 network from a string containing IP address and prefix length. 
-
-
-  network_v4 make_network_v4(
-      string_view str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:netmask ip::network_v4::netmask]
-
-[indexterm2 asio.indexterm.ip__network_v4.netmask..netmask..ip::network_v4] 
-Obtain the netmask that was specified when the network object was created. 
-
-
-  address_v4 netmask() const;
-
-
-
-[endsect]
-
-
-
-[section:network ip::network_v4::network]
-
-[indexterm2 asio.indexterm.ip__network_v4.network..network..ip::network_v4] 
-Obtain an address object that represents the network address. 
-
-
-  address_v4 network() const;
-
-
-
-[endsect]
-
-
-[section:network_v4 ip::network_v4::network_v4]
-
-[indexterm2 asio.indexterm.ip__network_v4.network_v4..network_v4..ip::network_v4] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__network_v4.network_v4.overload1 network_v4]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.network_v4.overload1 more...]]``
-
-
-Construct a network based on the specified address and prefix length. 
-
-
-  ``[link asio.reference.ip__network_v4.network_v4.overload2 network_v4]``(
-      const address_v4 & addr,
-      unsigned short prefix_len);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.network_v4.overload2 more...]]``
-
-
-Construct network based on the specified address and netmask. 
-
-
-  ``[link asio.reference.ip__network_v4.network_v4.overload3 network_v4]``(
-      const address_v4 & addr,
-      const address_v4 & mask);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.network_v4.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__network_v4.network_v4.overload4 network_v4]``(
-      const network_v4 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.network_v4.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__network_v4.network_v4.overload5 network_v4]``(
-      network_v4 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.network_v4.overload5 more...]]``
-
-
-[section:overload1 ip::network_v4::network_v4 (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  network_v4();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v4::network_v4 (2 of 5 overloads)]
-
-
-Construct a network based on the specified address and prefix length. 
-
-
-  network_v4(
-      const address_v4 & addr,
-      unsigned short prefix_len);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::network_v4::network_v4 (3 of 5 overloads)]
-
-
-Construct network based on the specified address and netmask. 
-
-
-  network_v4(
-      const address_v4 & addr,
-      const address_v4 & mask);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::network_v4::network_v4 (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  network_v4(
-      const network_v4 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::network_v4::network_v4 (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  network_v4(
-      network_v4 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_not__eq_ ip::network_v4::operator!=]
-
-[indexterm2 asio.indexterm.ip__network_v4.operator_not__eq_..operator!=..ip::network_v4] 
-Compare two networks for inequality. 
-
-
-  bool operator!=(
-      const network_v4 & a,
-      const network_v4 & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::network_v4::operator=]
-
-[indexterm2 asio.indexterm.ip__network_v4.operator_eq_..operator=..ip::network_v4] 
-Assign from another network. 
-
-
-  network_v4 & ``[link asio.reference.ip__network_v4.operator_eq_.overload1 operator=]``(
-      const network_v4 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another network. 
-
-
-  network_v4 & ``[link asio.reference.ip__network_v4.operator_eq_.overload2 operator=]``(
-      network_v4 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::network_v4::operator= (1 of 2 overloads)]
-
-
-Assign from another network. 
-
-
-  network_v4 & operator=(
-      const network_v4 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v4::operator= (2 of 2 overloads)]
-
-
-Move-assign from another network. 
-
-
-  network_v4 & operator=(
-      network_v4 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::network_v4::operator==]
-
-[indexterm2 asio.indexterm.ip__network_v4.operator_eq__eq_..operator==..ip::network_v4] 
-Compare two networks for equality. 
-
-
-  bool operator==(
-      const network_v4 & a,
-      const network_v4 & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:prefix_length ip::network_v4::prefix_length]
-
-[indexterm2 asio.indexterm.ip__network_v4.prefix_length..prefix_length..ip::network_v4] 
-Obtain the prefix length that was specified when the network object was created. 
-
-
-  unsigned short prefix_length() const;
-
-
-
-[endsect]
-
-
-[section:to_string ip::network_v4::to_string]
-
-[indexterm2 asio.indexterm.ip__network_v4.to_string..to_string..ip::network_v4] 
-Get the network as an address in dotted decimal format. 
-
-
-  std::string ``[link asio.reference.ip__network_v4.to_string.overload1 to_string]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.to_string.overload1 more...]]``
-
-  std::string ``[link asio.reference.ip__network_v4.to_string.overload2 to_string]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v4.to_string.overload2 more...]]``
-
-
-[section:overload1 ip::network_v4::to_string (1 of 2 overloads)]
-
-
-Get the network as an address in dotted decimal format. 
-
-
-  std::string to_string() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v4::to_string (2 of 2 overloads)]
-
-
-Get the network as an address in dotted decimal format. 
-
-
-  std::string to_string(
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:ip__network_v6 ip::network_v6]
-
-[indexterm1 asio.indexterm.ip__network_v6..ip::network_v6]
-
-
-Represents an IPv6 network. 
-
-
-  class network_v6
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v6.address [*address]]]
-    [Obtain the address object specified when the network object was created. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.canonical [*canonical]]]
-    [Obtain the true network address, omitting any host bits. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.hosts [*hosts]]]
-    [Obtain an address range corresponding to the hosts in the network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.is_host [*is_host]]]
-    [Test if network is a valid host address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.is_subnet_of [*is_subnet_of]]]
-    [Test if a network is a real subnet of another network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.network [*network]]]
-    [Obtain an address object that represents the network address. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.network_v6 [*network_v6]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct a network based on the specified address and prefix length. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.operator_eq_ [*operator=]]]
-    [Assign from another network. 
-     [hr]
-     Move-assign from another network. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.prefix_length [*prefix_length]]]
-    [Obtain the prefix length that was specified when the network object was created. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.to_string [*to_string]]]
-    [Get the network as an address in dotted decimal format. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v6.operator_not__eq_ [*operator!=]]]
-    [Compare two networks for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__network_v6.operator_eq__eq_ [*operator==]]]
-    [Compare two networks for equality. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__network_v6.make_network_v6 [*make_network_v6]]]
-    [Create an IPv6 network from a string containing IP address and prefix length. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__network_v6 `ip::network_v6`] class provides the ability to use and manipulate IP version 6 networks.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address ip::network_v6::address]
-
-[indexterm2 asio.indexterm.ip__network_v6.address..address..ip::network_v6] 
-Obtain the address object specified when the network object was created. 
-
-
-  address_v6 address() const;
-
-
-
-[endsect]
-
-
-
-[section:canonical ip::network_v6::canonical]
-
-[indexterm2 asio.indexterm.ip__network_v6.canonical..canonical..ip::network_v6] 
-Obtain the true network address, omitting any host bits. 
-
-
-  network_v6 canonical() const;
-
-
-
-[endsect]
-
-
-
-[section:hosts ip::network_v6::hosts]
-
-[indexterm2 asio.indexterm.ip__network_v6.hosts..hosts..ip::network_v6] 
-Obtain an address range corresponding to the hosts in the network. 
-
-
-  address_v6_range hosts() const;
-
-
-
-[endsect]
-
-
-
-[section:is_host ip::network_v6::is_host]
-
-[indexterm2 asio.indexterm.ip__network_v6.is_host..is_host..ip::network_v6] 
-Test if network is a valid host address. 
-
-
-  bool is_host() const;
-
-
-
-[endsect]
-
-
-
-[section:is_subnet_of ip::network_v6::is_subnet_of]
-
-[indexterm2 asio.indexterm.ip__network_v6.is_subnet_of..is_subnet_of..ip::network_v6] 
-Test if a network is a real subnet of another network. 
-
-
-  bool is_subnet_of(
-      const network_v6 & other) const;
-
-
-
-[endsect]
-
-
-[section:make_network_v6 ip::network_v6::make_network_v6]
-
-[indexterm2 asio.indexterm.ip__network_v6.make_network_v6..make_network_v6..ip::network_v6] 
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload1 make_network_v6]``(
-      const char * str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload1 more...]]``
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload2 make_network_v6]``(
-      const char * str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload2 more...]]``
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload3 make_network_v6]``(
-      const std::string & str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload3 more...]]``
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload4 make_network_v6]``(
-      const std::string & str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload4 more...]]``
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload5 make_network_v6]``(
-      string_view str);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload5 more...]]``
-
-  network_v6 ``[link asio.reference.ip__network_v6.make_network_v6.overload6 make_network_v6]``(
-      string_view str,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.make_network_v6.overload6 more...]]``
-
-
-[section:overload1 ip::network_v6::make_network_v6 (1 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      const char * str);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v6::make_network_v6 (2 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      const char * str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::network_v6::make_network_v6 (3 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      const std::string & str);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::network_v6::make_network_v6 (4 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      const std::string & str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload5 ip::network_v6::make_network_v6 (5 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      string_view str);
-
-
-
-[endsect]
-
-
-
-[section:overload6 ip::network_v6::make_network_v6 (6 of 6 overloads)]
-
-
-Create an IPv6 network from a string containing IP address and prefix length. 
-
-
-  network_v6 make_network_v6(
-      string_view str,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:network ip::network_v6::network]
-
-[indexterm2 asio.indexterm.ip__network_v6.network..network..ip::network_v6] 
-Obtain an address object that represents the network address. 
-
-
-  address_v6 network() const;
-
-
-
-[endsect]
-
-
-[section:network_v6 ip::network_v6::network_v6]
-
-[indexterm2 asio.indexterm.ip__network_v6.network_v6..network_v6..ip::network_v6] 
-Default constructor. 
-
-
-  ``[link asio.reference.ip__network_v6.network_v6.overload1 network_v6]``();
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.network_v6.overload1 more...]]``
-
-
-Construct a network based on the specified address and prefix length. 
-
-
-  ``[link asio.reference.ip__network_v6.network_v6.overload2 network_v6]``(
-      const address_v6 & addr,
-      unsigned short prefix_len);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.network_v6.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.ip__network_v6.network_v6.overload3 network_v6]``(
-      const network_v6 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.network_v6.overload3 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.ip__network_v6.network_v6.overload4 network_v6]``(
-      network_v6 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.network_v6.overload4 more...]]``
-
-
-[section:overload1 ip::network_v6::network_v6 (1 of 4 overloads)]
-
-
-Default constructor. 
-
-
-  network_v6();
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v6::network_v6 (2 of 4 overloads)]
-
-
-Construct a network based on the specified address and prefix length. 
-
-
-  network_v6(
-      const address_v6 & addr,
-      unsigned short prefix_len);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ip::network_v6::network_v6 (3 of 4 overloads)]
-
-
-Copy constructor. 
-
-
-  network_v6(
-      const network_v6 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 ip::network_v6::network_v6 (4 of 4 overloads)]
-
-
-Move constructor. 
-
-
-  network_v6(
-      network_v6 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_not__eq_ ip::network_v6::operator!=]
-
-[indexterm2 asio.indexterm.ip__network_v6.operator_not__eq_..operator!=..ip::network_v6] 
-Compare two networks for inequality. 
-
-
-  bool operator!=(
-      const network_v6 & a,
-      const network_v6 & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ ip::network_v6::operator=]
-
-[indexterm2 asio.indexterm.ip__network_v6.operator_eq_..operator=..ip::network_v6] 
-Assign from another network. 
-
-
-  network_v6 & ``[link asio.reference.ip__network_v6.operator_eq_.overload1 operator=]``(
-      const network_v6 & other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another network. 
-
-
-  network_v6 & ``[link asio.reference.ip__network_v6.operator_eq_.overload2 operator=]``(
-      network_v6 && other);
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 ip::network_v6::operator= (1 of 2 overloads)]
-
-
-Assign from another network. 
-
-
-  network_v6 & operator=(
-      const network_v6 & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v6::operator= (2 of 2 overloads)]
-
-
-Move-assign from another network. 
-
-
-  network_v6 & operator=(
-      network_v6 && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ ip::network_v6::operator==]
-
-[indexterm2 asio.indexterm.ip__network_v6.operator_eq__eq_..operator==..ip::network_v6] 
-Compare two networks for equality. 
-
-
-  bool operator==(
-      const network_v6 & a,
-      const network_v6 & b);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/network_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:prefix_length ip::network_v6::prefix_length]
-
-[indexterm2 asio.indexterm.ip__network_v6.prefix_length..prefix_length..ip::network_v6] 
-Obtain the prefix length that was specified when the network object was created. 
-
-
-  unsigned short prefix_length() const;
-
-
-
-[endsect]
-
-
-[section:to_string ip::network_v6::to_string]
-
-[indexterm2 asio.indexterm.ip__network_v6.to_string..to_string..ip::network_v6] 
-Get the network as an address in dotted decimal format. 
-
-
-  std::string ``[link asio.reference.ip__network_v6.to_string.overload1 to_string]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.to_string.overload1 more...]]``
-
-  std::string ``[link asio.reference.ip__network_v6.to_string.overload2 to_string]``(
-      asio::error_code & ec) const;
-  ``  [''''&raquo;''' [link asio.reference.ip__network_v6.to_string.overload2 more...]]``
-
-
-[section:overload1 ip::network_v6::to_string (1 of 2 overloads)]
-
-
-Get the network as an address in dotted decimal format. 
-
-
-  std::string to_string() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 ip::network_v6::to_string (2 of 2 overloads)]
-
-
-Get the network as an address in dotted decimal format. 
-
-
-  std::string to_string(
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:ip__port_type ip::port_type]
-
-[indexterm1 asio.indexterm.ip__port_type..ip::port_type]
-
-Type used for storing port numbers. 
-
-
-  typedef uint_least16_t port_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__resolver_base ip::resolver_base]
-
-[indexterm1 asio.indexterm.ip__resolver_base..ip::resolver_base]
-
-
-The [link asio.reference.ip__resolver_base `ip::resolver_base`] class is used as a base for the [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class templates to provide a common place to define the flag constants. 
-
-
-  class resolver_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__resolver_base.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__resolver_base._resolver_base [*~resolver_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__resolver_base.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_base.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/resolver_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address_configured ip::resolver_base::address_configured]
-
-[indexterm2 asio.indexterm.ip__resolver_base.address_configured..address_configured..ip::resolver_base] 
-Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 
-
-
-  static const flags address_configured = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:all_matching ip::resolver_base::all_matching]
-
-[indexterm2 asio.indexterm.ip__resolver_base.all_matching..all_matching..ip::resolver_base] 
-If used with v4\_mapped, return all matching IPv6 and IPv4 addresses. 
-
-
-  static const flags all_matching = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:canonical_name ip::resolver_base::canonical_name]
-
-[indexterm2 asio.indexterm.ip__resolver_base.canonical_name..canonical_name..ip::resolver_base] 
-Determine the canonical name of the host specified in the query. 
-
-
-  static const flags canonical_name = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:flags ip::resolver_base::flags]
-
-[indexterm2 asio.indexterm.ip__resolver_base.flags..flags..ip::resolver_base] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/resolver_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:numeric_host ip::resolver_base::numeric_host]
-
-[indexterm2 asio.indexterm.ip__resolver_base.numeric_host..numeric_host..ip::resolver_base] 
-Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 
-
-
-  static const flags numeric_host = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:numeric_service ip::resolver_base::numeric_service]
-
-[indexterm2 asio.indexterm.ip__resolver_base.numeric_service..numeric_service..ip::resolver_base] 
-Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 
-
-
-  static const flags numeric_service = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:passive ip::resolver_base::passive]
-
-[indexterm2 asio.indexterm.ip__resolver_base.passive..passive..ip::resolver_base] 
-Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 
-
-
-  static const flags passive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:v4_mapped ip::resolver_base::v4_mapped]
-
-[indexterm2 asio.indexterm.ip__resolver_base.v4_mapped..v4_mapped..ip::resolver_base] 
-If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 
-
-
-  static const flags v4_mapped = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_resolver_base ip::resolver_base::~resolver_base]
-
-[indexterm2 asio.indexterm.ip__resolver_base._resolver_base..~resolver_base..ip::resolver_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~resolver_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__resolver_query_base ip::resolver_query_base]
-
-[indexterm1 asio.indexterm.ip__resolver_query_base..ip::resolver_query_base]
-
-
-The [link asio.reference.ip__resolver_query_base `ip::resolver_query_base`] class is used as a base for the [link asio.reference.ip__basic_resolver_query `ip::basic_resolver_query`] class templates to provide a common place to define the flag constants. 
-
-
-  class resolver_query_base :
-    public ip::resolver_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__resolver_query_base.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__resolver_query_base._resolver_query_base [*~resolver_query_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__resolver_query_base.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/resolver_query_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:address_configured ip::resolver_query_base::address_configured]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.address_configured..address_configured..ip::resolver_query_base] 
-Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. 
-
-
-  static const flags address_configured = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:all_matching ip::resolver_query_base::all_matching]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.all_matching..all_matching..ip::resolver_query_base] 
-If used with v4\_mapped, return all matching IPv6 and IPv4 addresses. 
-
-
-  static const flags all_matching = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:canonical_name ip::resolver_query_base::canonical_name]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.canonical_name..canonical_name..ip::resolver_query_base] 
-Determine the canonical name of the host specified in the query. 
-
-
-  static const flags canonical_name = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:flags ip::resolver_query_base::flags]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.flags..flags..ip::resolver_query_base] 
-A bitmask type (C++ Std [lib.bitmask.types]). 
-
-
-  typedef unspecified flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/resolver_query_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:numeric_host ip::resolver_query_base::numeric_host]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.numeric_host..numeric_host..ip::resolver_query_base] 
-Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. 
-
-
-  static const flags numeric_host = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:numeric_service ip::resolver_query_base::numeric_service]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.numeric_service..numeric_service..ip::resolver_query_base] 
-Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. 
-
-
-  static const flags numeric_service = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:passive ip::resolver_query_base::passive]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.passive..passive..ip::resolver_query_base] 
-Indicate that returned endpoint is intended for use as a locally bound socket endpoint. 
-
-
-  static const flags passive = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:v4_mapped ip::resolver_query_base::v4_mapped]
-
-
-['Inherited from ip::resolver_base.]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base.v4_mapped..v4_mapped..ip::resolver_query_base] 
-If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. 
-
-
-  static const flags v4_mapped = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_resolver_query_base ip::resolver_query_base::~resolver_query_base]
-
-[indexterm2 asio.indexterm.ip__resolver_query_base._resolver_query_base..~resolver_query_base..ip::resolver_query_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~resolver_query_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ip__scope_id_type ip::scope_id_type]
-
-[indexterm1 asio.indexterm.ip__scope_id_type..ip::scope_id_type]
-
-Type used for storing IPv6 scope IDs. 
-
-
-  typedef uint_least32_t scope_id_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:ip__tcp ip::tcp]
-
-[indexterm1 asio.indexterm.ip__tcp..ip::tcp]
-
-
-Encapsulates the flags needed for TCP. 
-
-
-  class tcp
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__tcp.acceptor [*acceptor]]]
-    [The TCP acceptor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__tcp.endpoint [*endpoint]]]
-    [The type of a TCP endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__tcp.iostream [*iostream]]]
-    [The TCP iostream type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__tcp.no_delay [*no_delay]]]
-    [Socket option for disabling the Nagle algorithm. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__tcp.resolver [*resolver]]]
-    [The TCP resolver type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__tcp.socket [*socket]]]
-    [The TCP socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__tcp.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__tcp.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__tcp.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__tcp.v4 [*v4]] [static]]
-    [Construct to represent the IPv4 TCP protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__tcp.v6 [*v6]] [static]]
-    [Construct to represent the IPv6 TCP protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__tcp.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__tcp.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__tcp `ip::tcp`] class contains flags necessary for TCP sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:acceptor ip::tcp::acceptor]
-
-[indexterm2 asio.indexterm.ip__tcp.acceptor..acceptor..ip::tcp] 
-The TCP acceptor type. 
-
-
-  typedef basic_socket_acceptor< tcp > acceptor;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the acceptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
-    [The native representation of an acceptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.accept [*accept]]]
-    [Accept a new connection. 
-     [hr]
-     Accept a new connection and obtain the endpoint of the peer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.assign [*assign]]]
-    [Assigns an existing native acceptor to the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
-    [Start an asynchronous accept. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]] [constructor]]
-    [Construct an acceptor without opening it. 
-     [hr]
-     Construct an open acceptor. 
-     [hr]
-     Construct an acceptor opened on the given endpoint. 
-     [hr]
-     Construct a basic_socket_acceptor on an existing native acceptor. 
-     [hr]
-     Move-construct a basic_socket_acceptor from another. 
-     [hr]
-     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.bind [*bind]]]
-    [Bind the acceptor to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.close [*close]]]
-    [Close the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_option [*get_option]]]
-    [Get an option from the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.io_control [*io_control]]]
-    [Perform an IO control command on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.is_open [*is_open]]]
-    [Determine whether the acceptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.listen [*listen]]]
-    [Place the acceptor into the state where it will listen for new connections. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
-    [Get the native acceptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native acceptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native acceptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the acceptor. 
-     [hr]
-     Sets the non-blocking mode of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.open [*open]]]
-    [Open the acceptor using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_acceptor from another. 
-     [hr]
-     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.release [*release]]]
-    [Release ownership of the underlying native acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.set_option [*set_option]]]
-    [Set an option on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.wait [*wait]]]
-    [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]] [destructor]]
-    [Destroys the acceptor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `accept` operations are thread safe, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to synchronous `accept` operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-[heading Example]
-  
-Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
-  acceptor.open(endpoint.protocol());
-  acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint ip::tcp::endpoint]
-
-[indexterm2 asio.indexterm.ip__tcp.endpoint..endpoint..ip::tcp] 
-The type of a TCP endpoint. 
-
-
-  typedef basic_endpoint< tcp > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.address [*address]]]
-    [Get the IP address associated with the endpoint. 
-     [hr]
-     Set the IP address associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 
-     [hr]
-     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.port [*port]]]
-    [Get the port associated with the endpoint. The port number is always in the host's byte order. 
-     [hr]
-     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_endpoint `ip::basic_endpoint`] class template describes an endpoint that may be associated with a particular socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family ip::tcp::family]
-
-[indexterm2 asio.indexterm.ip__tcp.family..family..ip::tcp] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:iostream ip::tcp::iostream]
-
-[indexterm2 asio.indexterm.ip__tcp.iostream..iostream..ip::tcp] 
-The TCP iostream type. 
-
-
-  typedef basic_socket_iostream< tcp > iostream;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration [*duration]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration_type [*duration_type]]]
-    [(Deprecated: Use duration.) The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_point [*time_point]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_type [*time_type]]]
-    [(Deprecated: Use time_point.) The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]] [constructor]]
-    [Construct a basic_socket_iostream without establishing a connection. 
-     [hr]
-     Construct a basic_socket_iostream from the supplied socket. 
-     [hr]
-     Move-construct a basic_socket_iostream from another. 
-     [hr]
-     Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.close [*close]]]
-    [Close the connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.connect [*connect]]]
-    [Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.error [*error]]]
-    [Get the last error associated with the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_after [*expires_after]]]
-    [Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time as an absolute time. 
-     [hr]
-     Set the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expiry [*expiry]]]
-    [Get the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_iostream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
-    [Return a pointer to the underlying streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.socket [*socket]]]
-    [Get a reference to the underlying socket. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:no_delay ip::tcp::no_delay]
-
-[indexterm2 asio.indexterm.ip__tcp.no_delay..no_delay..ip::tcp] 
-Socket option for disabling the Nagle algorithm. 
-
-
-  typedef implementation_defined no_delay;
-
-
-
-Implements the IPPROTO\_TCP/TCP\_NODELAY socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::tcp::no_delay option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::tcp::operator!=]
-
-[indexterm2 asio.indexterm.ip__tcp.operator_not__eq_..operator!=..ip::tcp] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const tcp & p1,
-      const tcp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ ip::tcp::operator==]
-
-[indexterm2 asio.indexterm.ip__tcp.operator_eq__eq_..operator==..ip::tcp] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const tcp & p1,
-      const tcp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol ip::tcp::protocol]
-
-[indexterm2 asio.indexterm.ip__tcp.protocol..protocol..ip::tcp] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:resolver ip::tcp::resolver]
-
-[indexterm2 asio.indexterm.ip__tcp.resolver..resolver..ip::tcp] 
-The TCP resolver type. 
-
-
-  typedef basic_resolver< tcp > resolver;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
-    [Rebinds the resolver type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.iterator [*iterator]]]
-    [(Deprecated.) The iterator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.query [*query]]]
-    [(Deprecated.) The query type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.results_type [*results_type]]]
-    [The results type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]] [constructor]]
-    [Construct with executor. 
-     [hr]
-     Construct with execution context. 
-     [hr]
-     Move-construct a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the resolver. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
-    [Move-assign a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.resolve [*resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]] [destructor]]
-    [Destroys the resolver. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:socket ip::tcp::socket]
-
-[indexterm2 asio.indexterm.ip__tcp.socket..socket..ip::tcp] 
-The TCP socket type. 
-
-
-  typedef basic_stream_socket< tcp > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]] [constructor]]
-    [Construct a basic_stream_socket without opening it. 
-     [hr]
-     Construct and open a basic_stream_socket. 
-     [hr]
-     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_stream_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_stream_socket from another. 
-     [hr]
-     Move-construct a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_socket from another. 
-     [hr]
-     Move-assign a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.read_some [*read_some]]]
-    [Read some data from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.write_some [*write_some]]]
-    [Write some data to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket._basic_stream_socket [*~basic_stream_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_socket `basic_stream_socket`] class template provides asynchronous and blocking stream-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/tcp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type ip::tcp::type]
-
-[indexterm2 asio.indexterm.ip__tcp.type..type..ip::tcp] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[section:v4 ip::tcp::v4]
-
-[indexterm2 asio.indexterm.ip__tcp.v4..v4..ip::tcp] 
-Construct to represent the IPv4 TCP protocol. 
-
-
-  static tcp v4();
-
-
-
-[endsect]
-
-
-
-[section:v6 ip::tcp::v6]
-
-[indexterm2 asio.indexterm.ip__tcp.v6..v6..ip::tcp] 
-Construct to represent the IPv6 TCP protocol. 
-
-
-  static tcp v6();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__udp ip::udp]
-
-[indexterm1 asio.indexterm.ip__udp..ip::udp]
-
-
-Encapsulates the flags needed for UDP. 
-
-
-  class udp
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__udp.endpoint [*endpoint]]]
-    [The type of a UDP endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__udp.resolver [*resolver]]]
-    [The UDP resolver type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__udp.socket [*socket]]]
-    [The UDP socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__udp.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__udp.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__udp.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__udp.v4 [*v4]] [static]]
-    [Construct to represent the IPv4 UDP protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__udp.v6 [*v6]] [static]]
-    [Construct to represent the IPv6 UDP protocol. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__udp.operator_not__eq_ [*operator!=]]]
-    [Compare two protocols for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__udp.operator_eq__eq_ [*operator==]]]
-    [Compare two protocols for equality. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__udp `ip::udp`] class contains flags necessary for UDP sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint ip::udp::endpoint]
-
-[indexterm2 asio.indexterm.ip__udp.endpoint..endpoint..ip::udp] 
-The type of a UDP endpoint. 
-
-
-  typedef basic_endpoint< udp > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.address [*address]]]
-    [Get the IP address associated with the endpoint. 
-     [hr]
-     Set the IP address associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. 
-     [hr]
-     Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.port [*port]]]
-    [Get the port associated with the endpoint. The port number is always in the host's byte order. 
-     [hr]
-     Set the port associated with the endpoint. The port number is always in the host's byte order. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.ip__basic_endpoint `ip::basic_endpoint`] class template describes an endpoint that may be associated with a particular socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family ip::udp::family]
-
-[indexterm2 asio.indexterm.ip__udp.family..family..ip::udp] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ ip::udp::operator!=]
-
-[indexterm2 asio.indexterm.ip__udp.operator_not__eq_..operator!=..ip::udp] 
-Compare two protocols for inequality. 
-
-
-  bool operator!=(
-      const udp & p1,
-      const udp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ ip::udp::operator==]
-
-[indexterm2 asio.indexterm.ip__udp.operator_eq__eq_..operator==..ip::udp] 
-Compare two protocols for equality. 
-
-
-  bool operator==(
-      const udp & p1,
-      const udp & p2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol ip::udp::protocol]
-
-[indexterm2 asio.indexterm.ip__udp.protocol..protocol..ip::udp] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:resolver ip::udp::resolver]
-
-[indexterm2 asio.indexterm.ip__udp.resolver..resolver..ip::udp] 
-The UDP resolver type. 
-
-
-  typedef basic_resolver< udp > resolver;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver__rebind_executor [*rebind_executor]]]
-    [Rebinds the resolver type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.iterator [*iterator]]]
-    [(Deprecated.) The iterator type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.query [*query]]]
-    [(Deprecated.) The query type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ip__basic_resolver.results_type [*results_type]]]
-    [The results type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform forward resolution of a query to a list of entries. 
-     [hr]
-     Asynchronously perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.basic_resolver [*basic_resolver]] [constructor]]
-    [Construct with executor. 
-     [hr]
-     Construct with execution context. 
-     [hr]
-     Move-construct a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the resolver. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.operator_eq_ [*operator=]]]
-    [Move-assign a basic_resolver from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver.resolve [*resolve]]]
-    [(Deprecated: Use overload with separate host and service parameters.) Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform forward resolution of a query to a list of entries. 
-     [hr]
-     Perform reverse resolution of an endpoint to a list of entries. ]
-  ]
-  
-  [
-    [[link asio.reference.ip__basic_resolver._basic_resolver [*~basic_resolver]] [destructor]]
-    [Destroys the resolver. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_resolver.address_configured [*address_configured]] [static]]
-    [Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.all_matching [*all_matching]] [static]]
-    [If used with v4_mapped, return all matching IPv6 and IPv4 addresses. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.canonical_name [*canonical_name]] [static]]
-    [Determine the canonical name of the host specified in the query. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_host [*numeric_host]] [static]]
-    [Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.numeric_service [*numeric_service]] [static]]
-    [Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.passive [*passive]] [static]]
-    [Indicate that returned endpoint is intended for use as a locally bound socket endpoint. ]
-  ]
-
-  [
-    [[link asio.reference.ip__basic_resolver.v4_mapped [*v4_mapped]] [static]]
-    [If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. ]
-  ]
-
-]
-
-The [link asio.reference.ip__basic_resolver `ip::basic_resolver`] class template provides the ability to resolve a query to a list of endpoints.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:socket ip::udp::socket]
-
-[indexterm2 asio.indexterm.ip__udp.socket..socket..ip::udp] 
-The UDP socket type. 
-
-
-  typedef basic_datagram_socket< udp > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]] [constructor]]
-    [Construct a basic_datagram_socket without opening it. 
-     [hr]
-     Construct and open a basic_datagram_socket. 
-     [hr]
-     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_datagram_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_datagram_socket from another. 
-     [hr]
-     Move-construct a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_datagram_socket from another. 
-     [hr]
-     Move-assign a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
-    [Receive a datagram with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send_to [*send_to]]]
-    [Send a datagram to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket._basic_datagram_socket [*~basic_datagram_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class template provides asynchronous and blocking datagram-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/udp.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type ip::udp::type]
-
-[indexterm2 asio.indexterm.ip__udp.type..type..ip::udp] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[section:v4 ip::udp::v4]
-
-[indexterm2 asio.indexterm.ip__udp.v4..v4..ip::udp] 
-Construct to represent the IPv4 UDP protocol. 
-
-
-  static udp v4();
-
-
-
-[endsect]
-
-
-
-[section:v6 ip::udp::v6]
-
-[indexterm2 asio.indexterm.ip__udp.v6..v6..ip::udp] 
-Construct to represent the IPv6 UDP protocol. 
-
-
-  static udp v6();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ip__unicast__hops ip::unicast::hops]
-
-[indexterm1 asio.indexterm.ip__unicast__hops..ip::unicast::hops]
-
-Socket option for time-to-live associated with outgoing unicast packets. 
-
-
-  typedef implementation_defined hops;
-
-
-
-Implements the IPPROTO\_IP/IP\_UNICAST\_TTL socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::unicast::hops option(4);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::ip::unicast::hops option;
-  socket.get_option(option);
-  int ttl = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/unicast.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__v4_mapped_t ip::v4_mapped_t]
-
-[indexterm1 asio.indexterm.ip__v4_mapped_t..ip::v4_mapped_t]
-
-Tag type used for distinguishing overloads that deal in IPv4-mapped IPv6 addresses. 
-
-  enum v4_mapped_t
-
-[indexterm2 asio.indexterm.ip__v4_mapped_t.v4_mapped..v4_mapped..ip::v4_mapped_t]
-
-[heading Values]
-[variablelist
-
-  [
-    [v4_mapped]
-    []
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:ip__v6_only ip::v6_only]
-
-[indexterm1 asio.indexterm.ip__v6_only..ip::v6_only]
-
-Socket option for determining whether an IPv6 socket supports IPv6 communication only. 
-
-
-  typedef implementation_defined v6_only;
-
-
-
-Implements the IPPROTO\_IPV6/IPV6\_V6ONLY socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::v6_only option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::ip::v6_only option;
-  socket.get_option(option);
-  bool v6_only = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ip/v6_only.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:is_applicable_property is_applicable_property]
-
-[indexterm1 asio.indexterm.is_applicable_property..is_applicable_property]
-
-
-
-  template<
-      typename T,
-      typename Property,
-        = void>
-  struct is_applicable_property
-
-
-[heading Requirements]
-
-['Header: ][^asio/is_applicable_property.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_async_operation is_async_operation]
-
-[indexterm1 asio.indexterm.is_async_operation..is_async_operation]
-
-
-The [link asio.reference.is_async_operation `is_async_operation`] trait detects whether a type `T` and arguments `Args`... may be used to initiate an asynchronous operation. 
-
-
-  template<
-      typename T,
-      typename... Args>
-  struct is_async_operation :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_async_operation` is a trait is derived from `true_type` if the expression `T(Args..., token)` initiates an asynchronous operation, where `token` is an unspecified completion token type. Otherwise, `is_async_operation` is derived from `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/async_result.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_completion_condition is_completion_condition]
-
-[indexterm1 asio.indexterm.is_completion_condition..is_completion_condition]
-
-
-Trait for determining whether a function object is a completion condition. 
-
-
-  template<
-      typename T>
-  struct is_completion_condition
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_completion_condition.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/completion_condition.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_completion_condition::value]
-
-[indexterm2 asio.indexterm.is_completion_condition.value..value..is_completion_condition] 
-
-  static constexpr bool value = automatically_determined;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:is_connect_condition is_connect_condition]
-
-[indexterm1 asio.indexterm.is_connect_condition..is_connect_condition]
-
-
-Trait for determining whether a function object is a connect condition that can be used with `connect` and `async_connect`. 
-
-
-  template<
-      typename T,
-      typename Iterator>
-  struct is_connect_condition
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_connect_condition.value [*value]] [static]]
-    [The value member is true if the type may be used as a connect condition. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/connect.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_connect_condition::value]
-
-[indexterm2 asio.indexterm.is_connect_condition.value..value..is_connect_condition] 
-The value member is true if the type may be used as a connect condition. 
-
-
-  static constexpr bool value = automatically_determined;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:is_const_buffer_sequence is_const_buffer_sequence]
-
-[indexterm1 asio.indexterm.is_const_buffer_sequence..is_const_buffer_sequence]
-
-
-Trait to determine whether a type satisfies the ConstBufferSequence requirements. 
-
-
-  template<
-      typename T>
-  struct is_const_buffer_sequence :
-    public integral_constant< bool, automatically_determined >
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_contiguous_iterator is_contiguous_iterator]
-
-[indexterm1 asio.indexterm.is_contiguous_iterator..is_contiguous_iterator]
-
-
-The [link asio.reference.is_contiguous_iterator `is_contiguous_iterator`] class is a traits class that may be used to determine whether a type is a contiguous iterator. 
-
-
-  template<
-      typename T>
-  struct is_contiguous_iterator :
-    public integral_constant< bool, std::contiguous_iterator< T > >
-
-
-[heading Requirements]
-
-['Header: ][^asio/is_contiguous_iterator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_deferred is_deferred]
-
-[indexterm1 asio.indexterm.is_deferred..is_deferred]
-
-
-Trait for detecting objects that are usable as deferred operations. 
-
-
-  template<
-      typename T>
-  struct is_deferred :
-    public false_type
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_dynamic_buffer is_dynamic_buffer]
-
-[indexterm1 asio.indexterm.is_dynamic_buffer..is_dynamic_buffer]
-
-
-Trait to determine whether a type satisfies the DynamicBuffer requirements. 
-
-
-  template<
-      typename T>
-  struct is_dynamic_buffer :
-    public integral_constant< bool, automatically_determined >
-
-
-If `ASIO_NO_DYNAMIC_BUFFER_V1` is not defined, determines whether the type satisfies the DynamicBuffer\_v1 requirements. Otherwise, if `ASIO_NO_DYNAMIC_BUFFER_V1` is defined, determines whether the type satisfies the DynamicBuffer\_v2 requirements. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_dynamic_buffer_v1 is_dynamic_buffer_v1]
-
-[indexterm1 asio.indexterm.is_dynamic_buffer_v1..is_dynamic_buffer_v1]
-
-
-Trait to determine whether a type satisfies the DynamicBuffer\_v1 requirements. 
-
-
-  template<
-      typename T>
-  struct is_dynamic_buffer_v1 :
-    public integral_constant< bool, automatically_determined >
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_dynamic_buffer_v2 is_dynamic_buffer_v2]
-
-[indexterm1 asio.indexterm.is_dynamic_buffer_v2..is_dynamic_buffer_v2]
-
-
-Trait to determine whether a type satisfies the DynamicBuffer\_v2 requirements. 
-
-
-  template<
-      typename T>
-  struct is_dynamic_buffer_v2 :
-    public integral_constant< bool, automatically_determined >
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_endpoint_sequence is_endpoint_sequence]
-
-[indexterm1 asio.indexterm.is_endpoint_sequence..is_endpoint_sequence]
-
-
-Type trait used to determine whether a type is an endpoint sequence that can be used with with `connect` and `async_connect`. 
-
-
-  template<
-      typename T>
-  struct is_endpoint_sequence
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_endpoint_sequence.value [*value]] [static]]
-    [The value member is true if the type may be used as an endpoint sequence. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/connect.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_endpoint_sequence::value]
-
-[indexterm2 asio.indexterm.is_endpoint_sequence.value..value..is_endpoint_sequence] 
-The value member is true if the type may be used as an endpoint sequence. 
-
-
-  static const bool value = automatically_determined;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:is_executor is_executor]
-
-[indexterm1 asio.indexterm.is_executor..is_executor]
-
-
-The [link asio.reference.is_executor `is_executor`] trait detects whether a type T meets the Executor type requirements. 
-
-
-  template<
-      typename T>
-  struct is_executor :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_executor` is a UnaryTypeTrait that is derived from `true_type` if the type `T` meets the syntactic requirements for Executor, otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/is_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_match_condition is_match_condition]
-
-[indexterm1 asio.indexterm.is_match_condition..is_match_condition]
-
-
-Type trait used to determine whether a type can be used as a match condition function with read\_until and async\_read\_until. 
-
-
-  template<
-      typename T>
-  struct is_match_condition
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_match_condition.value [*value]] [static]]
-    [The value member is true if the type may be used as a match condition. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/read_until.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_match_condition::value]
-
-[indexterm2 asio.indexterm.is_match_condition.value..value..is_match_condition] 
-The value member is true if the type may be used as a match condition. 
-
-
-  static const bool value;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:is_mutable_buffer_sequence is_mutable_buffer_sequence]
-
-[indexterm1 asio.indexterm.is_mutable_buffer_sequence..is_mutable_buffer_sequence]
-
-
-Trait to determine whether a type satisfies the MutableBufferSequence requirements. 
-
-
-  template<
-      typename T>
-  struct is_mutable_buffer_sequence :
-    public integral_constant< bool, automatically_determined >
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_nothrow_prefer is_nothrow_prefer]
-
-[indexterm1 asio.indexterm.is_nothrow_prefer..is_nothrow_prefer]
-
-
-A type trait that determines whether a `prefer` expression will not throw. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct is_nothrow_prefer :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_nothrow_prefer` is a trait that is derived from `true_type` if the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)` is `noexcept`; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/prefer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_nothrow_query is_nothrow_query]
-
-[indexterm1 asio.indexterm.is_nothrow_query..is_nothrow_query]
-
-
-A type trait that determines whether a `query` expression will not throw. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct is_nothrow_query :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_nothrow_query` is a trait that is derived from `true_type` if the expression `asio::query(std::declval<T>(), std::declval<Property>())` is `noexcept`; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_nothrow_require is_nothrow_require]
-
-[indexterm1 asio.indexterm.is_nothrow_require..is_nothrow_require]
-
-
-A type trait that determines whether a `require` expression will not throw. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct is_nothrow_require :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_nothrow_require` is a trait that is derived from `true_type` if the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)` is `noexcept`; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_nothrow_require_concept is_nothrow_require_concept]
-
-[indexterm1 asio.indexterm.is_nothrow_require_concept..is_nothrow_require_concept]
-
-
-A type trait that determines whether a `require_concept` expression will not throw. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct is_nothrow_require_concept :
-    public integral_constant< bool, automatically_determined >
-
-
-Class template `is_nothrow_require_concept` is a trait that is derived from `true_type` if the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())` is `noexcept`; otherwise `false_type`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require_concept.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:is_read_buffered is_read_buffered]
-
-[indexterm1 asio.indexterm.is_read_buffered..is_read_buffered]
-
-
-The [link asio.reference.is_read_buffered `is_read_buffered`] class is a traits class that may be used to determine whether a stream type supports buffering of read data. 
-
-
-  template<
-      typename Stream>
-  class is_read_buffered
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_read_buffered.value [*value]] [static]]
-    [The value member is true only if the Stream type supports buffering of read data. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/is_read_buffered.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_read_buffered::value]
-
-[indexterm2 asio.indexterm.is_read_buffered.value..value..is_read_buffered] 
-The value member is true only if the Stream type supports buffering of read data. 
-
-
-  static const bool value;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:is_write_buffered is_write_buffered]
-
-[indexterm1 asio.indexterm.is_write_buffered..is_write_buffered]
-
-
-The [link asio.reference.is_write_buffered `is_write_buffered`] class is a traits class that may be used to determine whether a stream type supports buffering of written data. 
-
-
-  template<
-      typename Stream>
-  class is_write_buffered
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.is_write_buffered.value [*value]] [static]]
-    [The value member is true only if the Stream type supports buffering of written data. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/is_write_buffered.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value is_write_buffered::value]
-
-[indexterm2 asio.indexterm.is_write_buffered.value..value..is_write_buffered] 
-The value member is true only if the Stream type supports buffering of written data. 
-
-
-  static const bool value;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:local__basic_endpoint local::basic_endpoint]
-
-[indexterm1 asio.indexterm.local__basic_endpoint..local::basic_endpoint]
-
-
-Describes an endpoint for a UNIX socket. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``>
-  class basic_endpoint
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using the specified path name. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.path [*path]]]
-    [Get the path associated with the endpoint. 
-     [hr]
-     Set the path associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.local__basic_endpoint `local::basic_endpoint`] class template describes an endpoint that may be associated with a particular UNIX socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_endpoint local::basic_endpoint::basic_endpoint]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.basic_endpoint..basic_endpoint..local::basic_endpoint] 
-Default constructor. 
-
-
-  ``[link asio.reference.local__basic_endpoint.basic_endpoint.overload1 basic_endpoint]``();
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.basic_endpoint.overload1 more...]]``
-
-
-Construct an endpoint using the specified path name. 
-
-
-  ``[link asio.reference.local__basic_endpoint.basic_endpoint.overload2 basic_endpoint]``(
-      const char * path_name);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.basic_endpoint.overload2 more...]]``
-
-  ``[link asio.reference.local__basic_endpoint.basic_endpoint.overload3 basic_endpoint]``(
-      const std::string & path_name);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.basic_endpoint.overload3 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.local__basic_endpoint.basic_endpoint.overload4 basic_endpoint]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.basic_endpoint.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.local__basic_endpoint.basic_endpoint.overload5 basic_endpoint]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.basic_endpoint.overload5 more...]]``
-
-
-[section:overload1 local::basic_endpoint::basic_endpoint (1 of 5 overloads)]
-
-
-Default constructor. 
-
-
-  basic_endpoint();
-
-
-
-[endsect]
-
-
-
-[section:overload2 local::basic_endpoint::basic_endpoint (2 of 5 overloads)]
-
-
-Construct an endpoint using the specified path name. 
-
-
-  basic_endpoint(
-      const char * path_name);
-
-
-
-[endsect]
-
-
-
-[section:overload3 local::basic_endpoint::basic_endpoint (3 of 5 overloads)]
-
-
-Construct an endpoint using the specified path name. 
-
-
-  basic_endpoint(
-      const std::string & path_name);
-
-
-
-[endsect]
-
-
-
-[section:overload4 local::basic_endpoint::basic_endpoint (4 of 5 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_endpoint(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload5 local::basic_endpoint::basic_endpoint (5 of 5 overloads)]
-
-
-Move constructor. 
-
-
-  basic_endpoint(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:capacity local::basic_endpoint::capacity]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.capacity..capacity..local::basic_endpoint] 
-Get the capacity of the endpoint in the native type. 
-
-
-  std::size_t capacity() const;
-
-
-
-[endsect]
-
-
-[section:data local::basic_endpoint::data]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.data..data..local::basic_endpoint] 
-Get the underlying endpoint in the native type. 
-
-
-  data_type * ``[link asio.reference.local__basic_endpoint.data.overload1 data]``();
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.data.overload1 more...]]``
-
-  const data_type * ``[link asio.reference.local__basic_endpoint.data.overload2 data]``() const;
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.data.overload2 more...]]``
-
-
-[section:overload1 local::basic_endpoint::data (1 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  data_type * data();
-
-
-
-[endsect]
-
-
-
-[section:overload2 local::basic_endpoint::data (2 of 2 overloads)]
-
-
-Get the underlying endpoint in the native type. 
-
-
-  const data_type * data() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:data_type local::basic_endpoint::data_type]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.data_type..data_type..local::basic_endpoint] 
-The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. 
-
-
-  typedef implementation_defined data_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ local::basic_endpoint::operator!=]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_not__eq_..operator!=..local::basic_endpoint] 
-Compare two endpoints for inequality. 
-
-
-  bool operator!=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt_ local::basic_endpoint::operator<]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_lt_..operator<..local::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_lt__lt_ local::basic_endpoint::operator<<]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_lt__lt_..operator<<..local::basic_endpoint] 
-Output an endpoint as a string. 
-
-
-  template<
-      typename Elem,
-      typename Traits,
-      typename ``[link asio.reference.Protocol Protocol]``>
-  std::basic_ostream< Elem, Traits > & operator<<(
-      std::basic_ostream< Elem, Traits > & os,
-      const basic_endpoint< Protocol > & endpoint);
-
-
-Used to output a human-readable string for a specified endpoint.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[os][The output stream to which the string will be written.]]
-
-[[endpoint][The endpoint to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The output stream. 
-
-
-
-
-[endsect]
-
-
-
-[section:operator_lt__eq_ local::basic_endpoint::operator<=]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_lt__eq_..operator<=..local::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator<=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ local::basic_endpoint::operator=]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_eq_..operator=..local::basic_endpoint] 
-Assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.local__basic_endpoint.operator_eq_.overload1 operator=]``(
-      const basic_endpoint & other);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.operator_eq_.overload1 more...]]``
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & ``[link asio.reference.local__basic_endpoint.operator_eq_.overload2 operator=]``(
-      basic_endpoint && other);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 local::basic_endpoint::operator= (1 of 2 overloads)]
-
-
-Assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      const basic_endpoint & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 local::basic_endpoint::operator= (2 of 2 overloads)]
-
-
-Move-assign from another endpoint. 
-
-
-  basic_endpoint & operator=(
-      basic_endpoint && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ local::basic_endpoint::operator==]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_eq__eq_..operator==..local::basic_endpoint] 
-Compare two endpoints for equality. 
-
-
-  bool operator==(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt_ local::basic_endpoint::operator>]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_gt_..operator>..local::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_gt__eq_ local::basic_endpoint::operator>=]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.operator_gt__eq_..operator>=..local::basic_endpoint] 
-Compare endpoints for ordering. 
-
-
-  bool operator>=(
-      const basic_endpoint< Protocol > & e1,
-      const basic_endpoint< Protocol > & e2);
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:path local::basic_endpoint::path]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.path..path..local::basic_endpoint] 
-Get the path associated with the endpoint. 
-
-
-  std::string ``[link asio.reference.local__basic_endpoint.path.overload1 path]``() const;
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.path.overload1 more...]]``
-
-
-Set the path associated with the endpoint. 
-
-
-  void ``[link asio.reference.local__basic_endpoint.path.overload2 path]``(
-      const char * p);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.path.overload2 more...]]``
-
-  void ``[link asio.reference.local__basic_endpoint.path.overload3 path]``(
-      const std::string & p);
-  ``  [''''&raquo;''' [link asio.reference.local__basic_endpoint.path.overload3 more...]]``
-
-
-[section:overload1 local::basic_endpoint::path (1 of 3 overloads)]
-
-
-Get the path associated with the endpoint. 
-
-
-  std::string path() const;
-
-
-
-[endsect]
-
-
-
-[section:overload2 local::basic_endpoint::path (2 of 3 overloads)]
-
-
-Set the path associated with the endpoint. 
-
-
-  void path(
-      const char * p);
-
-
-
-[endsect]
-
-
-
-[section:overload3 local::basic_endpoint::path (3 of 3 overloads)]
-
-
-Set the path associated with the endpoint. 
-
-
-  void path(
-      const std::string & p);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:protocol local::basic_endpoint::protocol]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.protocol..protocol..local::basic_endpoint] 
-The protocol associated with the endpoint. 
-
-
-  protocol_type protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol_type local::basic_endpoint::protocol_type]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.protocol_type..protocol_type..local::basic_endpoint] 
-The protocol type associated with the endpoint. 
-
-
-  typedef Protocol protocol_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:resize local::basic_endpoint::resize]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.resize..resize..local::basic_endpoint] 
-Set the underlying size of the endpoint in the native type. 
-
-
-  void resize(
-      std::size_t new_size);
-
-
-
-[endsect]
-
-
-
-[section:size local::basic_endpoint::size]
-
-[indexterm2 asio.indexterm.local__basic_endpoint.size..size..local::basic_endpoint] 
-Get the underlying size of the endpoint in the native type. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:local__connect_pair local::connect_pair]
-
-[indexterm1 asio.indexterm.local__connect_pair..local::connect_pair]
-
-Create a pair of connected sockets. 
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void ``[link asio.reference.local__connect_pair.overload1 connect_pair]``(
-      basic_socket< Protocol, Executor1 > & socket1,
-      basic_socket< Protocol, Executor2 > & socket2);
-  ``  [''''&raquo;''' [link asio.reference.local__connect_pair.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void ``[link asio.reference.local__connect_pair.overload2 connect_pair]``(
-      basic_socket< Protocol, Executor1 > & socket1,
-      basic_socket< Protocol, Executor2 > & socket2,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.local__connect_pair.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/local/connect_pair.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 local::connect_pair (1 of 2 overloads)]
-
-
-Create a pair of connected sockets. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void connect_pair(
-      basic_socket< Protocol, Executor1 > & socket1,
-      basic_socket< Protocol, Executor2 > & socket2);
-
-
-
-[endsect]
-
-
-
-[section:overload2 local::connect_pair (2 of 2 overloads)]
-
-
-Create a pair of connected sockets. 
-
-
-  template<
-      typename ``[link asio.reference.Protocol Protocol]``,
-      typename ``[link asio.reference.Executor1 Executor1]``,
-      typename ``[link asio.reference.Executor1 Executor2]``>
-  void connect_pair(
-      basic_socket< Protocol, Executor1 > & socket1,
-      basic_socket< Protocol, Executor2 > & socket2,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:local__datagram_protocol local::datagram_protocol]
-
-[indexterm1 asio.indexterm.local__datagram_protocol..local::datagram_protocol]
-
-
-Encapsulates the flags needed for datagram-oriented UNIX sockets. 
-
-
-  class datagram_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__datagram_protocol.endpoint [*endpoint]]]
-    [The type of a UNIX domain endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__datagram_protocol.socket [*socket]]]
-    [The UNIX domain socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__datagram_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.local__datagram_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.local__datagram_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-The [link asio.reference.local__datagram_protocol `local::datagram_protocol`] class contains flags necessary for datagram-oriented UNIX domain sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:endpoint local::datagram_protocol::endpoint]
-
-[indexterm2 asio.indexterm.local__datagram_protocol.endpoint..endpoint..local::datagram_protocol] 
-The type of a UNIX domain endpoint. 
-
-
-  typedef basic_endpoint< datagram_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using the specified path name. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.path [*path]]]
-    [Get the path associated with the endpoint. 
-     [hr]
-     Set the path associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.local__basic_endpoint `local::basic_endpoint`] class template describes an endpoint that may be associated with a particular UNIX socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family local::datagram_protocol::family]
-
-[indexterm2 asio.indexterm.local__datagram_protocol.family..family..local::datagram_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol local::datagram_protocol::protocol]
-
-[indexterm2 asio.indexterm.local__datagram_protocol.protocol..protocol..local::datagram_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:socket local::datagram_protocol::socket]
-
-[indexterm2 asio.indexterm.local__datagram_protocol.socket..socket..local::datagram_protocol] 
-The UNIX domain socket type. 
-
-
-  typedef basic_datagram_socket< datagram_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_datagram_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_receive_from [*async_receive_from]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send [*async_send]]]
-    [Start an asynchronous send on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_send_to [*async_send_to]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.basic_datagram_socket [*basic_datagram_socket]] [constructor]]
-    [Construct a basic_datagram_socket without opening it. 
-     [hr]
-     Construct and open a basic_datagram_socket. 
-     [hr]
-     Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_datagram_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_datagram_socket from another. 
-     [hr]
-     Move-construct a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_datagram_socket from another. 
-     [hr]
-     Move-assign a basic_datagram_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive [*receive]]]
-    [Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.receive_from [*receive_from]]]
-    [Receive a datagram with the endpoint of the sender. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send [*send]]]
-    [Send some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.send_to [*send_to]]]
-    [Send a datagram to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_datagram_socket._basic_datagram_socket [*~basic_datagram_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_datagram_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class template provides asynchronous and blocking datagram-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `send_to`, `receive`, `receive_from`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/datagram_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type local::datagram_protocol::type]
-
-[indexterm2 asio.indexterm.local__datagram_protocol.type..type..local::datagram_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:local__seq_packet_protocol local::seq_packet_protocol]
-
-[indexterm1 asio.indexterm.local__seq_packet_protocol..local::seq_packet_protocol]
-
-
-Encapsulates the flags needed for seq\_packet UNIX sockets. 
-
-
-  class seq_packet_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__seq_packet_protocol.acceptor [*acceptor]]]
-    [The UNIX domain acceptor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__seq_packet_protocol.endpoint [*endpoint]]]
-    [The type of a UNIX domain endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__seq_packet_protocol.socket [*socket]]]
-    [The UNIX domain socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__seq_packet_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.local__seq_packet_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.local__seq_packet_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-The [link asio.reference.local__seq_packet_protocol `local::seq_packet_protocol`] class contains flags necessary for sequenced packet UNIX domain sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:acceptor local::seq_packet_protocol::acceptor]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.acceptor..acceptor..local::seq_packet_protocol] 
-The UNIX domain acceptor type. 
-
-
-  typedef basic_socket_acceptor< seq_packet_protocol > acceptor;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the acceptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
-    [The native representation of an acceptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.accept [*accept]]]
-    [Accept a new connection. 
-     [hr]
-     Accept a new connection and obtain the endpoint of the peer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.assign [*assign]]]
-    [Assigns an existing native acceptor to the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
-    [Start an asynchronous accept. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]] [constructor]]
-    [Construct an acceptor without opening it. 
-     [hr]
-     Construct an open acceptor. 
-     [hr]
-     Construct an acceptor opened on the given endpoint. 
-     [hr]
-     Construct a basic_socket_acceptor on an existing native acceptor. 
-     [hr]
-     Move-construct a basic_socket_acceptor from another. 
-     [hr]
-     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.bind [*bind]]]
-    [Bind the acceptor to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.close [*close]]]
-    [Close the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_option [*get_option]]]
-    [Get an option from the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.io_control [*io_control]]]
-    [Perform an IO control command on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.is_open [*is_open]]]
-    [Determine whether the acceptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.listen [*listen]]]
-    [Place the acceptor into the state where it will listen for new connections. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
-    [Get the native acceptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native acceptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native acceptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the acceptor. 
-     [hr]
-     Sets the non-blocking mode of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.open [*open]]]
-    [Open the acceptor using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_acceptor from another. 
-     [hr]
-     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.release [*release]]]
-    [Release ownership of the underlying native acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.set_option [*set_option]]]
-    [Set an option on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.wait [*wait]]]
-    [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]] [destructor]]
-    [Destroys the acceptor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `accept` operations are thread safe, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to synchronous `accept` operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-[heading Example]
-  
-Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
-  acceptor.open(endpoint.protocol());
-  acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint local::seq_packet_protocol::endpoint]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.endpoint..endpoint..local::seq_packet_protocol] 
-The type of a UNIX domain endpoint. 
-
-
-  typedef basic_endpoint< seq_packet_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using the specified path name. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.path [*path]]]
-    [Get the path associated with the endpoint. 
-     [hr]
-     Set the path associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.local__basic_endpoint `local::basic_endpoint`] class template describes an endpoint that may be associated with a particular UNIX socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family local::seq_packet_protocol::family]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.family..family..local::seq_packet_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:protocol local::seq_packet_protocol::protocol]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.protocol..protocol..local::seq_packet_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:socket local::seq_packet_protocol::socket]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.socket..socket..local::seq_packet_protocol] 
-The UNIX domain socket type. 
-
-
-  typedef basic_seq_packet_socket< seq_packet_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_seq_packet_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.basic_seq_packet_socket [*basic_seq_packet_socket]] [constructor]]
-    [Construct a basic_seq_packet_socket without opening it. 
-     [hr]
-     Construct and open a basic_seq_packet_socket. 
-     [hr]
-     Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_seq_packet_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from another. 
-     [hr]
-     Move-construct a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_seq_packet_socket from another. 
-     [hr]
-     Move-assign a basic_seq_packet_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_seq_packet_socket._basic_seq_packet_socket [*~basic_seq_packet_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_seq_packet_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_seq_packet_socket `basic_seq_packet_socket`] class template provides asynchronous and blocking sequenced packet socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/seq_packet_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type local::seq_packet_protocol::type]
-
-[indexterm2 asio.indexterm.local__seq_packet_protocol.type..type..local::seq_packet_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:local__stream_protocol local::stream_protocol]
-
-[indexterm1 asio.indexterm.local__stream_protocol..local::stream_protocol]
-
-
-Encapsulates the flags needed for stream-oriented UNIX sockets. 
-
-
-  class stream_protocol
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__stream_protocol.acceptor [*acceptor]]]
-    [The UNIX domain acceptor type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__stream_protocol.endpoint [*endpoint]]]
-    [The type of a UNIX domain endpoint. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__stream_protocol.iostream [*iostream]]]
-    [The UNIX domain iostream type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__stream_protocol.socket [*socket]]]
-    [The UNIX domain socket type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__stream_protocol.family [*family]]]
-    [Obtain an identifier for the protocol family. ]
-  ]
-  
-  [
-    [[link asio.reference.local__stream_protocol.protocol [*protocol]]]
-    [Obtain an identifier for the protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.local__stream_protocol.type [*type]]]
-    [Obtain an identifier for the type of the protocol. ]
-  ]
-  
-]
-
-The [link asio.reference.local__stream_protocol `local::stream_protocol`] class contains flags necessary for stream-oriented UNIX domain sockets.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:acceptor local::stream_protocol::acceptor]
-
-[indexterm2 asio.indexterm.local__stream_protocol.acceptor..acceptor..local::stream_protocol] 
-The UNIX domain acceptor type. 
-
-
-  typedef basic_socket_acceptor< stream_protocol > acceptor;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the acceptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.native_handle_type [*native_handle_type]]]
-    [The native representation of an acceptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_acceptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.accept [*accept]]]
-    [Accept a new connection. 
-     [hr]
-     Accept a new connection and obtain the endpoint of the peer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.assign [*assign]]]
-    [Assigns an existing native acceptor to the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_accept [*async_accept]]]
-    [Start an asynchronous accept. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.basic_socket_acceptor [*basic_socket_acceptor]] [constructor]]
-    [Construct an acceptor without opening it. 
-     [hr]
-     Construct an open acceptor. 
-     [hr]
-     Construct an acceptor opened on the given endpoint. 
-     [hr]
-     Construct a basic_socket_acceptor on an existing native acceptor. 
-     [hr]
-     Move-construct a basic_socket_acceptor from another. 
-     [hr]
-     Move-construct a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.bind [*bind]]]
-    [Bind the acceptor to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.close [*close]]]
-    [Close the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.get_option [*get_option]]]
-    [Get an option from the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.io_control [*io_control]]]
-    [Perform an IO control command on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.is_open [*is_open]]]
-    [Determine whether the acceptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.listen [*listen]]]
-    [Place the acceptor into the state where it will listen for new connections. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_handle [*native_handle]]]
-    [Get the native acceptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native acceptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native acceptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the acceptor. 
-     [hr]
-     Sets the non-blocking mode of the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.open [*open]]]
-    [Open the acceptor using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_acceptor from another. 
-     [hr]
-     Move-assign a basic_socket_acceptor from an acceptor of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.release [*release]]]
-    [Release ownership of the underlying native acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.set_option [*set_option]]]
-    [Set an option on the acceptor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor.wait [*wait]]]
-    [Wait for the acceptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_acceptor._basic_socket_acceptor [*~basic_socket_acceptor]] [destructor]]
-    [Destroys the acceptor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_socket_acceptor.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_socket_acceptor `basic_socket_acceptor`] class template is used for accepting new socket connections.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `accept` operations are thread safe, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to synchronous `accept` operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-[heading Example]
-  
-Opening a socket acceptor with the SO\_REUSEADDR option enabled: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
-  acceptor.open(endpoint.protocol());
-  acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor.bind(endpoint);
-  acceptor.listen();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:endpoint local::stream_protocol::endpoint]
-
-[indexterm2 asio.indexterm.local__stream_protocol.endpoint..endpoint..local::stream_protocol] 
-The type of a UNIX domain endpoint. 
-
-
-  typedef basic_endpoint< stream_protocol > endpoint;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.data_type [*data_type]]]
-    [The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.local__basic_endpoint.protocol_type [*protocol_type]]]
-    [The protocol type associated with the endpoint. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.basic_endpoint [*basic_endpoint]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct an endpoint using the specified path name. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.capacity [*capacity]]]
-    [Get the capacity of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.data [*data]]]
-    [Get the underlying endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq_ [*operator=]]]
-    [Assign from another endpoint. 
-     [hr]
-     Move-assign from another endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.path [*path]]]
-    [Get the path associated with the endpoint. 
-     [hr]
-     Set the path associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.protocol [*protocol]]]
-    [The protocol associated with the endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.resize [*resize]]]
-    [Set the underlying size of the endpoint in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.size [*size]]]
-    [Get the underlying size of the endpoint in the native type. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_not__eq_ [*operator!=]]]
-    [Compare two endpoints for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt_ [*operator<]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__eq_ [*operator<=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_eq__eq_ [*operator==]]]
-    [Compare two endpoints for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt_ [*operator>]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-  [
-    [[link asio.reference.local__basic_endpoint.operator_gt__eq_ [*operator>=]]]
-    [Compare endpoints for ordering. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.local__basic_endpoint.operator_lt__lt_ [*operator<<]]]
-    [Output an endpoint as a string. ]
-  ]
-  
-]
-
-The [link asio.reference.local__basic_endpoint `local::basic_endpoint`] class template describes an endpoint that may be associated with a particular UNIX socket.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:family local::stream_protocol::family]
-
-[indexterm2 asio.indexterm.local__stream_protocol.family..family..local::stream_protocol] 
-Obtain an identifier for the protocol family. 
-
-
-  int family() const;
-
-
-
-[endsect]
-
-
-
-[section:iostream local::stream_protocol::iostream]
-
-[indexterm2 asio.indexterm.local__stream_protocol.iostream..iostream..local::stream_protocol] 
-The UNIX domain iostream type. 
-
-
-  typedef basic_socket_iostream< stream_protocol > iostream;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration [*duration]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.duration_type [*duration_type]]]
-    [(Deprecated: Use duration.) The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_point [*time_point]]]
-    [The time type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_socket_iostream.time_type [*time_type]]]
-    [(Deprecated: Use time_point.) The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_socket_iostream.basic_socket_iostream [*basic_socket_iostream]] [constructor]]
-    [Construct a basic_socket_iostream without establishing a connection. 
-     [hr]
-     Construct a basic_socket_iostream from the supplied socket. 
-     [hr]
-     Move-construct a basic_socket_iostream from another. 
-     [hr]
-     Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.close [*close]]]
-    [Close the connection. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.connect [*connect]]]
-    [Establish a connection to an endpoint corresponding to a resolver query. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.error [*error]]]
-    [Get the last error associated with the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_after [*expires_after]]]
-    [Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time as an absolute time. 
-     [hr]
-     Set the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the stream's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the stream's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.expiry [*expiry]]]
-    [Get the stream's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.operator_eq_ [*operator=]]]
-    [Move-assign a basic_socket_iostream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.rdbuf [*rdbuf]]]
-    [Return a pointer to the underlying streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_socket_iostream.socket [*socket]]]
-    [Get a reference to the underlying socket. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:protocol local::stream_protocol::protocol]
-
-[indexterm2 asio.indexterm.local__stream_protocol.protocol..protocol..local::stream_protocol] 
-Obtain an identifier for the protocol. 
-
-
-  int protocol() const;
-
-
-
-[endsect]
-
-
-
-[section:socket local::stream_protocol::socket]
-
-[indexterm2 asio.indexterm.local__stream_protocol.socket..socket..local::stream_protocol] 
-The UNIX domain socket type. 
-
-
-  typedef basic_stream_socket< stream_protocol > socket;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_socket__rebind_executor [*rebind_executor]]]
-    [Rebinds the socket type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.endpoint_type [*endpoint_type]]]
-    [The endpoint type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_socket is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.native_handle_type [*native_handle_type]]]
-    [The native representation of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.protocol_type [*protocol_type]]]
-    [The protocol type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_socket.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.assign [*assign]]]
-    [Assign an existing native socket to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_connect [*async_connect]]]
-    [Start an asynchronous connect. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_receive [*async_receive]]]
-    [Start an asynchronous receive. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_send [*async_send]]]
-    [Start an asynchronous send. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_wait [*async_wait]]]
-    [Asynchronously wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.at_mark [*at_mark]]]
-    [Determine whether the socket is at the out-of-band data mark. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.available [*available]]]
-    [Determine the number of bytes available for reading. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.basic_stream_socket [*basic_stream_socket]] [constructor]]
-    [Construct a basic_stream_socket without opening it. 
-     [hr]
-     Construct and open a basic_stream_socket. 
-     [hr]
-     Construct a basic_stream_socket, opening it and binding it to the given local endpoint. 
-     [hr]
-     Construct a basic_stream_socket on an existing native socket. 
-     [hr]
-     Move-construct a basic_stream_socket from another. 
-     [hr]
-     Move-construct a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.bind [*bind]]]
-    [Bind the socket to the given local endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.close [*close]]]
-    [Close the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.connect [*connect]]]
-    [Connect the socket to the specified endpoint. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.get_option [*get_option]]]
-    [Get an option from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.io_control [*io_control]]]
-    [Perform an IO control command on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.is_open [*is_open]]]
-    [Determine whether the socket is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.local_endpoint [*local_endpoint]]]
-    [Get the local endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_handle [*native_handle]]]
-    [Get the native socket representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native socket implementation. 
-     [hr]
-     Sets the non-blocking mode of the native socket implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the socket. 
-     [hr]
-     Sets the non-blocking mode of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.open [*open]]]
-    [Open the socket using the specified protocol. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_socket from another. 
-     [hr]
-     Move-assign a basic_stream_socket from a socket of another protocol type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.read_some [*read_some]]]
-    [Read some data from the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.receive [*receive]]]
-    [Receive some data on the socket. 
-     [hr]
-     Receive some data on a connected socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.release [*release]]]
-    [Release ownership of the underlying native socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.remote_endpoint [*remote_endpoint]]]
-    [Get the remote endpoint of the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.send [*send]]]
-    [Send some data on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.set_option [*set_option]]]
-    [Set an option on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.shutdown [*shutdown]]]
-    [Disable sends or receives on the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.wait [*wait]]]
-    [Wait for the socket to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket.write_some [*write_some]]]
-    [Write some data to the socket. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_socket._basic_stream_socket [*~basic_stream_socket]] [destructor]]
-    [Destroys the socket. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_socket.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_socket `basic_stream_socket`] class template provides asynchronous and blocking stream-oriented socket functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `send`, `receive`, `connect`, and `shutdown` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single socket object. Other synchronous operations, such as `open` or `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/local/stream_protocol.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:type local::stream_protocol::type]
-
-[indexterm2 asio.indexterm.local__stream_protocol.type..type..local::stream_protocol] 
-Obtain an identifier for the type of the protocol. 
-
-
-  int type() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:make_strand make_strand]
-
-[indexterm1 asio.indexterm.make_strand..make_strand]
-
-The [link asio.reference.make_strand `make_strand`] function creates a [link asio.reference.strand `strand`] object for an executor or execution context. 
-
-
-Create a [link asio.reference.strand `strand`] object for an executor. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  strand< Executor > ``[link asio.reference.make_strand.overload1 make_strand]``(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_strand.overload1 more...]]``
-
-Create a [link asio.reference.strand `strand`] object for an execution context. 
-
-  template<
-      typename ExecutionContext>
-  strand< typename ExecutionContext::executor_type > ``[link asio.reference.make_strand.overload2 make_strand]``(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_strand.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 make_strand (1 of 2 overloads)]
-
-
-Create a [link asio.reference.strand `strand`] object for an executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  strand< Executor > make_strand(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][An executor.]]
-
-]
-
-
-[heading Return Value]
-      
-A strand constructed with the specified executor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 make_strand (2 of 2 overloads)]
-
-
-Create a [link asio.reference.strand `strand`] object for an execution context. 
-
-
-  template<
-      typename ExecutionContext>
-  strand< typename ExecutionContext::executor_type > make_strand(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context, from which an executor will be obtained.]]
-
-]
-
-
-[heading Return Value]
-      
-A strand constructed with the execution context's executor, obtained by performing `ctx.get_executor()`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:make_work_guard make_work_guard]
-
-[indexterm1 asio.indexterm.make_work_guard..make_work_guard]
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor_work_guard< Executor > ``[link asio.reference.make_work_guard.overload1 make_work_guard]``(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  executor_work_guard< typename ExecutionContext::executor_type > ``[link asio.reference.make_work_guard.overload2 make_work_guard]``(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload2 more...]]``
-
-  template<
-      typename T>
-  executor_work_guard< typename constraint_t< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value, associated_executor< T > >::type > ``[link asio.reference.make_work_guard.overload3 make_work_guard]``(
-      const T & t);
-  ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload3 more...]]``
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor_work_guard< associated_executor_t< T, Executor > > ``[link asio.reference.make_work_guard.overload4 make_work_guard]``(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload4 more...]]``
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  executor_work_guard< associated_executor_t< T, typename ExecutionContext::executor_type > > ``[link asio.reference.make_work_guard.overload5 make_work_guard]``(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< !is_executor< T >::value >  = 0,
-      constraint_t< !execution::is_executor< T >::value >  = 0,
-      constraint_t< !is_convertible< T &, execution_context & >::value >  = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.make_work_guard.overload5 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/executor_work_guard.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 make_work_guard (1 of 5 overloads)]
-
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor_work_guard< Executor > make_work_guard(
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][An executor.]]
-
-]
-
-
-[heading Return Value]
-      
-A work guard constructed with the specified executor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 make_work_guard (2 of 5 overloads)]
-
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-
-  template<
-      typename ExecutionContext>
-  executor_work_guard< typename ExecutionContext::executor_type > make_work_guard(
-      ExecutionContext & ctx,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context, from which an executor will be obtained.]]
-
-]
-
-
-[heading Return Value]
-      
-A work guard constructed with the execution context's executor, obtained by performing `ctx.get_executor()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 make_work_guard (3 of 5 overloads)]
-
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-
-  template<
-      typename T>
-  executor_work_guard< typename constraint_t< !is_executor< T >::value &&!execution::is_executor< T >::value &&!is_convertible< T &, execution_context & >::value, associated_executor< T > >::type > make_work_guard(
-      const T & t);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[t][An arbitrary object, such as a completion handler, for which the associated executor will be obtained.]]
-
-]
-
-
-[heading Return Value]
-      
-A work guard constructed with the associated executor of the object `t`, which is obtained as if by calling `get_associated_executor(t)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 make_work_guard (4 of 5 overloads)]
-
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  executor_work_guard< associated_executor_t< T, Executor > > make_work_guard(
-      const T & t,
-      const Executor & ex,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[t][An arbitrary object, such as a completion handler, for which the associated executor will be obtained.]]
-
-[[ex][An executor to be used as the candidate object when determining the associated executor.]]
-
-]
-
-
-[heading Return Value]
-      
-A work guard constructed with the associated executor of the object `t`, which is obtained as if by calling `get_associated_executor(t,
-ex)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 make_work_guard (5 of 5 overloads)]
-
-
-Create an [link asio.reference.executor_work_guard `executor_work_guard`] object. 
-
-
-  template<
-      typename T,
-      typename ExecutionContext>
-  executor_work_guard< associated_executor_t< T, typename ExecutionContext::executor_type > > make_work_guard(
-      const T & t,
-      ExecutionContext & ctx,
-      constraint_t< !is_executor< T >::value >  = 0,
-      constraint_t< !execution::is_executor< T >::value >  = 0,
-      constraint_t< !is_convertible< T &, execution_context & >::value >  = 0,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[t][An arbitrary object, such as a completion handler, for which the associated executor will be obtained.]]
-
-[[ctx][An execution context, from which an executor is obtained to use as the candidate object for determining the associated executor.]]
-
-]
-
-
-[heading Return Value]
-      
-A work guard constructed with the associated executor of the object `t`, which is obtained as if by calling `get_associated_executor(t, ctx.get_executor())`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:multiple_exceptions multiple_exceptions]
-
-[indexterm1 asio.indexterm.multiple_exceptions..multiple_exceptions]
-
-
-Exception thrown when there are multiple pending exceptions to rethrow. 
-
-
-  class multiple_exceptions :
-    public exception
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.multiple_exceptions.first_exception [*first_exception]]]
-    [Obtain a pointer to the first exception. ]
-  ]
-  
-  [
-    [[link asio.reference.multiple_exceptions.multiple_exceptions [*multiple_exceptions]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.multiple_exceptions.what [*what]]]
-    [Obtain message associated with exception. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/multiple_exceptions.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:first_exception multiple_exceptions::first_exception]
-
-[indexterm2 asio.indexterm.multiple_exceptions.first_exception..first_exception..multiple_exceptions] 
-Obtain a pointer to the first exception. 
-
-
-  std::exception_ptr first_exception() const;
-
-
-
-[endsect]
-
-
-
-[section:multiple_exceptions multiple_exceptions::multiple_exceptions]
-
-[indexterm2 asio.indexterm.multiple_exceptions.multiple_exceptions..multiple_exceptions..multiple_exceptions] 
-Constructor. 
-
-
-  multiple_exceptions(
-      std::exception_ptr first);
-
-
-
-[endsect]
-
-
-
-[section:what multiple_exceptions::what]
-
-[indexterm2 asio.indexterm.multiple_exceptions.what..what..multiple_exceptions] 
-Obtain message associated with exception. 
-
-
-  virtual const char * what() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:mutable_buffer mutable_buffer]
-
-[indexterm1 asio.indexterm.mutable_buffer..mutable_buffer]
-
-
-Holds a buffer that can be modified. 
-
-
-  class mutable_buffer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.mutable_buffer `mutable_buffer`] class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:data mutable_buffer::data]
-
-[indexterm2 asio.indexterm.mutable_buffer.data..data..mutable_buffer] 
-Get a pointer to the beginning of the memory range. 
-
-
-  void * data() const;
-
-
-
-[endsect]
-
-
-[section:mutable_buffer mutable_buffer::mutable_buffer]
-
-[indexterm2 asio.indexterm.mutable_buffer.mutable_buffer..mutable_buffer..mutable_buffer] 
-Construct an empty buffer. 
-
-
-  ``[link asio.reference.mutable_buffer.mutable_buffer.overload1 mutable_buffer]``();
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffer.mutable_buffer.overload1 more...]]``
-
-
-Construct a buffer to represent a given memory range. 
-
-
-  ``[link asio.reference.mutable_buffer.mutable_buffer.overload2 mutable_buffer]``(
-      void * data,
-      std::size_t size);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffer.mutable_buffer.overload2 more...]]``
-
-
-[section:overload1 mutable_buffer::mutable_buffer (1 of 2 overloads)]
-
-
-Construct an empty buffer. 
-
-
-  mutable_buffer();
-
-
-
-[endsect]
-
-
-
-[section:overload2 mutable_buffer::mutable_buffer (2 of 2 overloads)]
-
-
-Construct a buffer to represent a given memory range. 
-
-
-  mutable_buffer(
-      void * data,
-      std::size_t size);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_plus_ mutable_buffer::operator+]
-
-[indexterm2 asio.indexterm.mutable_buffer.operator_plus_..operator+..mutable_buffer] 
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer ``[link asio.reference.mutable_buffer.operator_plus_.overload1 operator+]``(
-      const mutable_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffer.operator_plus_.overload1 more...]]``
-
-  mutable_buffer ``[link asio.reference.mutable_buffer.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffer.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 mutable_buffer::operator+ (1 of 2 overloads)]
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer operator+(
-      const mutable_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 mutable_buffer::operator+ (2 of 2 overloads)]
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer operator+(
-      std::size_t n,
-      const mutable_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ mutable_buffer::operator+=]
-
-[indexterm2 asio.indexterm.mutable_buffer.operator_plus__eq_..operator+=..mutable_buffer] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  mutable_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size mutable_buffer::size]
-
-[indexterm2 asio.indexterm.mutable_buffer.size..size..mutable_buffer] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:mutable_buffers_1 mutable_buffers_1]
-
-[indexterm1 asio.indexterm.mutable_buffers_1..mutable_buffers_1]
-
-
-(Deprecated: Use [link asio.reference.mutable_buffer `mutable_buffer`].) Adapts a single modifiable buffer so that it meets the requirements of the MutableBufferSequence concept. 
-
-
-  class mutable_buffers_1 :
-    public mutable_buffer
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.mutable_buffers_1.const_iterator [*const_iterator]]]
-    [A random-access iterator type that may be used to read elements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.mutable_buffers_1.value_type [*value_type]]]
-    [The type for each element in the list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffers_1.begin [*begin]]]
-    [Get a random-access iterator to the first element. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffers_1.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffers_1.end [*end]]]
-    [Get a random-access iterator for one past the last element. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffers_1.mutable_buffers_1 [*mutable_buffers_1]] [constructor]]
-    [Construct to represent a given memory range. 
-     [hr]
-     Construct to represent a single modifiable buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffers_1.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffers_1.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffers_1.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:begin mutable_buffers_1::begin]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.begin..begin..mutable_buffers_1] 
-Get a random-access iterator to the first element. 
-
-
-  const_iterator begin() const;
-
-
-
-[endsect]
-
-
-
-[section:const_iterator mutable_buffers_1::const_iterator]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.const_iterator..const_iterator..mutable_buffers_1] 
-A random-access iterator type that may be used to read elements. 
-
-
-  typedef const mutable_buffer * const_iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:data mutable_buffers_1::data]
-
-
-['Inherited from mutable_buffer.]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.data..data..mutable_buffers_1] 
-Get a pointer to the beginning of the memory range. 
-
-
-  void * data() const;
-
-
-
-[endsect]
-
-
-
-[section:end mutable_buffers_1::end]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.end..end..mutable_buffers_1] 
-Get a random-access iterator for one past the last element. 
-
-
-  const_iterator end() const;
-
-
-
-[endsect]
-
-
-[section:mutable_buffers_1 mutable_buffers_1::mutable_buffers_1]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.mutable_buffers_1..mutable_buffers_1..mutable_buffers_1] 
-Construct to represent a given memory range. 
-
-
-  ``[link asio.reference.mutable_buffers_1.mutable_buffers_1.overload1 mutable_buffers_1]``(
-      void * data,
-      std::size_t size);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffers_1.mutable_buffers_1.overload1 more...]]``
-
-
-Construct to represent a single modifiable buffer. 
-
-
-  explicit ``[link asio.reference.mutable_buffers_1.mutable_buffers_1.overload2 mutable_buffers_1]``(
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffers_1.mutable_buffers_1.overload2 more...]]``
-
-
-[section:overload1 mutable_buffers_1::mutable_buffers_1 (1 of 2 overloads)]
-
-
-Construct to represent a given memory range. 
-
-
-  mutable_buffers_1(
-      void * data,
-      std::size_t size);
-
-
-
-[endsect]
-
-
-
-[section:overload2 mutable_buffers_1::mutable_buffers_1 (2 of 2 overloads)]
-
-
-Construct to represent a single modifiable buffer. 
-
-
-  mutable_buffers_1(
-      const mutable_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_plus_ mutable_buffers_1::operator+]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.operator_plus_..operator+..mutable_buffers_1] 
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer ``[link asio.reference.mutable_buffers_1.operator_plus_.overload1 operator+]``(
-      const mutable_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffers_1.operator_plus_.overload1 more...]]``
-
-  mutable_buffer ``[link asio.reference.mutable_buffers_1.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const mutable_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.mutable_buffers_1.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 mutable_buffers_1::operator+ (1 of 2 overloads)]
-
-
-['Inherited from mutable_buffer.]
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer operator+(
-      const mutable_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 mutable_buffers_1::operator+ (2 of 2 overloads)]
-
-
-['Inherited from mutable_buffer.]
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_buffer operator+(
-      std::size_t n,
-      const mutable_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ mutable_buffers_1::operator+=]
-
-
-['Inherited from mutable_buffer.]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.operator_plus__eq_..operator+=..mutable_buffers_1] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  mutable_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size mutable_buffers_1::size]
-
-
-['Inherited from mutable_buffer.]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.size..size..mutable_buffers_1] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[endsect]
-
-
-
-[section:value_type mutable_buffers_1::value_type]
-
-[indexterm2 asio.indexterm.mutable_buffers_1.value_type..value_type..mutable_buffers_1] 
-The type for each element in the list of buffers. 
-
-
-  typedef mutable_buffer value_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.mutable_buffer `mutable_buffer`] class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:mutable_registered_buffer mutable_registered_buffer]
-
-[indexterm1 asio.indexterm.mutable_registered_buffer..mutable_registered_buffer]
-
-
-Holds a registered buffer over modifiable data. 
-
-
-  class mutable_registered_buffer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_registered_buffer.buffer [*buffer]]]
-    [Get the underlying mutable buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_registered_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_registered_buffer.id [*id]]]
-    [Get the registered buffer identifier. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_registered_buffer.mutable_registered_buffer [*mutable_registered_buffer]] [constructor]]
-    [Default constructor creates an invalid registered buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_registered_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_registered_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_registered_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable registered buffer that is offset from the start of another. 
-
-     Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-Satisfies the `MutableBufferSequence` type requirements. 
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:buffer mutable_registered_buffer::buffer]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.buffer..buffer..mutable_registered_buffer] 
-Get the underlying mutable buffer. 
-
-
-  const mutable_buffer & buffer() const;
-
-
-
-[endsect]
-
-
-
-[section:data mutable_registered_buffer::data]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.data..data..mutable_registered_buffer] 
-Get a pointer to the beginning of the memory range. 
-
-
-  void * data() const;
-
-
-
-[heading Return Value]
-      
-`buffer().data()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:id mutable_registered_buffer::id]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.id..id..mutable_registered_buffer] 
-Get the registered buffer identifier. 
-
-
-  const registered_buffer_id & id() const;
-
-
-
-[endsect]
-
-
-
-[section:mutable_registered_buffer mutable_registered_buffer::mutable_registered_buffer]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.mutable_registered_buffer..mutable_registered_buffer..mutable_registered_buffer] 
-Default constructor creates an invalid registered buffer. 
-
-
-  mutable_registered_buffer();
-
-
-
-[endsect]
-
-
-[section:operator_plus_ mutable_registered_buffer::operator+]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.operator_plus_..operator+..mutable_registered_buffer] 
-Create a new modifiable registered buffer that is offset from the start of another. 
-
-
-  mutable_registered_buffer ``[link asio.reference.mutable_registered_buffer.operator_plus_.overload1 operator+]``(
-      const mutable_registered_buffer & b,
-      std::size_t n);
-  ``  [''''&raquo;''' [link asio.reference.mutable_registered_buffer.operator_plus_.overload1 more...]]``
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_registered_buffer ``[link asio.reference.mutable_registered_buffer.operator_plus_.overload2 operator+]``(
-      std::size_t n,
-      const mutable_registered_buffer & b);
-  ``  [''''&raquo;''' [link asio.reference.mutable_registered_buffer.operator_plus_.overload2 more...]]``
-
-
-[section:overload1 mutable_registered_buffer::operator+ (1 of 2 overloads)]
-
-
-Create a new modifiable registered buffer that is offset from the start of another. 
-
-
-  mutable_registered_buffer operator+(
-      const mutable_registered_buffer & b,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:overload2 mutable_registered_buffer::operator+ (2 of 2 overloads)]
-
-
-Create a new modifiable buffer that is offset from the start of another. 
-
-
-  mutable_registered_buffer operator+(
-      std::size_t n,
-      const mutable_registered_buffer & b);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_plus__eq_ mutable_registered_buffer::operator+=]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.operator_plus__eq_..operator+=..mutable_registered_buffer] 
-Move the start of the buffer by the specified number of bytes. 
-
-
-  mutable_registered_buffer & operator+=(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:size mutable_registered_buffer::size]
-
-[indexterm2 asio.indexterm.mutable_registered_buffer.size..size..mutable_registered_buffer] 
-Get the size of the memory range. 
-
-
-  std::size_t size() const;
-
-
-
-[heading Return Value]
-      
-`buffer().size()`. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:null_buffers null_buffers]
-
-[indexterm1 asio.indexterm.null_buffers..null_buffers]
-
-
-(Deprecated: Use the socket/descriptor wait() and async\_wait() member functions.) An implementation of both the ConstBufferSequence and MutableBufferSequence concepts to represent a null buffer sequence. 
-
-
-  class null_buffers
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.null_buffers.const_iterator [*const_iterator]]]
-    [A random-access iterator type that may be used to read elements. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.null_buffers.value_type [*value_type]]]
-    [The type for each element in the list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.null_buffers.begin [*begin]]]
-    [Get a random-access iterator to the first element. ]
-  ]
-  
-  [
-    [[link asio.reference.null_buffers.end [*end]]]
-    [Get a random-access iterator for one past the last element. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:begin null_buffers::begin]
-
-[indexterm2 asio.indexterm.null_buffers.begin..begin..null_buffers] 
-Get a random-access iterator to the first element. 
-
-
-  const_iterator begin() const;
-
-
-
-[endsect]
-
-
-
-[section:const_iterator null_buffers::const_iterator]
-
-[indexterm2 asio.indexterm.null_buffers.const_iterator..const_iterator..null_buffers] 
-A random-access iterator type that may be used to read elements. 
-
-
-  typedef const mutable_buffer * const_iterator;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:end null_buffers::end]
-
-[indexterm2 asio.indexterm.null_buffers.end..end..null_buffers] 
-Get a random-access iterator for one past the last element. 
-
-
-  const_iterator end() const;
-
-
-
-[endsect]
-
-
-
-[section:value_type null_buffers::value_type]
-
-[indexterm2 asio.indexterm.null_buffers.value_type..value_type..null_buffers] 
-The type for each element in the list of buffers. 
-
-
-  typedef mutable_buffer value_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.data [*data]]]
-    [Get a pointer to the beginning of the memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.mutable_buffer [*mutable_buffer]] [constructor]]
-    [Construct an empty buffer. 
-     [hr]
-     Construct a buffer to represent a given memory range. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.operator_plus__eq_ [*operator+=]]]
-    [Move the start of the buffer by the specified number of bytes. ]
-  ]
-  
-  [
-    [[link asio.reference.mutable_buffer.size [*size]]]
-    [Get the size of the memory range. ]
-  ]
-  
-]
-
-[heading Related Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.mutable_buffer.operator_plus_ [*operator+]]]
-    [Create a new modifiable buffer that is offset from the start of another. ]
-  ]
-  
-]
-
-The [link asio.reference.mutable_buffer `mutable_buffer`] class provides a safe representation of a buffer that can be modified. It does not own the underlying data, and so is cheap to copy or assign.
-
-
-[heading Accessing Buffer Contents]
-  
-
-
-The contents of a buffer may be accessed using the `data()` and `size()` member functions:
-
-
-
-  asio::mutable_buffer b1 = ...;
-  std::size_t s1 = b1.size();
-  unsigned char* p1 = static_cast<unsigned char*>(b1.data());
-
-
-
-
-The `data()` member function permits violations of type safety, so uses of it in application code should be carefully considered. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:operator_pipe_ operator|]
-
-[indexterm1 asio.indexterm.operator_pipe_..operator|]
-
-Pipe operator used to chain deferred operations. 
-
-
-  template<
-      typename Head,
-      typename Tail>
-  auto operator|(
-      Head head,
-      Tail && tail);
-
-
-[heading Requirements]
-
-['Header: ][^asio/deferred.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:partial_allocator_binder partial_allocator_binder]
-
-[indexterm1 asio.indexterm.partial_allocator_binder..partial_allocator_binder]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the supplied allocator as its associated allocator. 
-
-
-  template<
-      typename Allocator>
-  struct partial_allocator_binder
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_allocator_binder.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler should have the allocator as its associated allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_allocator_binder.partial_allocator_binder [*partial_allocator_binder]] [constructor]]
-    [Constructor that specifies associated allocator. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_allocator_binder.allocator_ [*allocator_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/bind_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocator_ partial_allocator_binder::allocator_]
-
-[indexterm2 asio.indexterm.partial_allocator_binder.allocator_..allocator_..partial_allocator_binder] 
-
-  Allocator allocator_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_allocator_binder::operator()]
-
-[indexterm2 asio.indexterm.partial_allocator_binder.operator_lp__rp_..operator()..partial_allocator_binder] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the allocator as its associated allocator. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr allocator_binder< decay_t< CompletionToken >, Allocator > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_allocator_binder partial_allocator_binder::partial_allocator_binder]
-
-[indexterm2 asio.indexterm.partial_allocator_binder.partial_allocator_binder..partial_allocator_binder..partial_allocator_binder] 
-Constructor that specifies associated allocator. 
-
-
-  partial_allocator_binder(
-      const Allocator & ex);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_as_tuple partial_as_tuple]
-
-[indexterm1 asio.indexterm.partial_as_tuple..partial_as_tuple]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  struct partial_as_tuple
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_as_tuple.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler arguments should be combined into a single tuple argument. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_as_tuple.partial_as_tuple [*partial_as_tuple]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/as_tuple.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ partial_as_tuple::operator()]
-
-[indexterm2 asio.indexterm.partial_as_tuple.operator_lp__rp_..operator()..partial_as_tuple] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr as_tuple_t< decay_t< CompletionToken > > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_as_tuple partial_as_tuple::partial_as_tuple]
-
-[indexterm2 asio.indexterm.partial_as_tuple.partial_as_tuple..partial_as_tuple..partial_as_tuple] 
-Default constructor. 
-
-
-  constexpr partial_as_tuple();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_cancel_after partial_cancel_after]
-
-[indexterm1 asio.indexterm.partial_cancel_after..partial_cancel_after]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to cancel an operation after a timeout. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>>
-  class partial_cancel_after
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_after.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler arguments should be combined into a single tuple argument. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_cancel_after.partial_cancel_after [*partial_cancel_after]] [constructor]]
-    [Constructor that specifies the timeout duration and cancellation type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_after.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_after.timeout_ [*timeout_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_after.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_type_ partial_cancel_after::cancel_type_]
-
-[indexterm2 asio.indexterm.partial_cancel_after.cancel_type_..cancel_type_..partial_cancel_after] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_cancel_after::operator()]
-
-[indexterm2 asio.indexterm.partial_cancel_after.operator_lp__rp_..operator()..partial_cancel_after] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  cancel_after_t< decay_t< CompletionToken >, Clock, WaitTraits > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_cancel_after partial_cancel_after::partial_cancel_after]
-
-[indexterm2 asio.indexterm.partial_cancel_after.partial_cancel_after..partial_cancel_after..partial_cancel_after] 
-Constructor that specifies the timeout duration and cancellation type. 
-
-
-  partial_cancel_after(
-      const typename Clock::duration & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:timeout_ partial_cancel_after::timeout_]
-
-[indexterm2 asio.indexterm.partial_cancel_after.timeout_..timeout_..partial_cancel_after] 
-
-  Clock::duration timeout_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_cancel_after_timer partial_cancel_after_timer]
-
-[indexterm1 asio.indexterm.partial_cancel_after_timer..partial_cancel_after_timer]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to cancel an operation after a timeout. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class partial_cancel_after_timer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_after_timer.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler arguments should be combined into a single tuple argument. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_cancel_after_timer.partial_cancel_after_timer [*partial_cancel_after_timer]] [constructor]]
-    [Constructor that specifies the timeout duration and cancellation type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_after_timer.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_after_timer.timeout_ [*timeout_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_after_timer.timer_ [*timer_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_after.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_type_ partial_cancel_after_timer::cancel_type_]
-
-[indexterm2 asio.indexterm.partial_cancel_after_timer.cancel_type_..cancel_type_..partial_cancel_after_timer] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_cancel_after_timer::operator()]
-
-[indexterm2 asio.indexterm.partial_cancel_after_timer.operator_lp__rp_..operator()..partial_cancel_after_timer] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  cancel_after_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_cancel_after_timer partial_cancel_after_timer::partial_cancel_after_timer]
-
-[indexterm2 asio.indexterm.partial_cancel_after_timer.partial_cancel_after_timer..partial_cancel_after_timer..partial_cancel_after_timer] 
-Constructor that specifies the timeout duration and cancellation type. 
-
-
-  partial_cancel_after_timer(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const typename Clock::duration & timeout,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:timeout_ partial_cancel_after_timer::timeout_]
-
-[indexterm2 asio.indexterm.partial_cancel_after_timer.timeout_..timeout_..partial_cancel_after_timer] 
-
-  Clock::duration timeout_;
-
-
-
-[endsect]
-
-
-
-[section:timer_ partial_cancel_after_timer::timer_]
-
-[indexterm2 asio.indexterm.partial_cancel_after_timer.timer_..timer_..partial_cancel_after_timer] 
-
-  basic_waitable_timer< Clock, WaitTraits, Executor > & timer_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_cancel_at partial_cancel_at]
-
-[indexterm1 asio.indexterm.partial_cancel_at..partial_cancel_at]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to cancel an operation at a given time. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>>
-  class partial_cancel_at
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_at.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler arguments should be combined into a single tuple argument. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_cancel_at.partial_cancel_at [*partial_cancel_at]] [constructor]]
-    [Constructor that specifies the expiry and cancellation type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_at.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_at.expiry_ [*expiry_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_type_ partial_cancel_at::cancel_type_]
-
-[indexterm2 asio.indexterm.partial_cancel_at.cancel_type_..cancel_type_..partial_cancel_at] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:expiry_ partial_cancel_at::expiry_]
-
-[indexterm2 asio.indexterm.partial_cancel_at.expiry_..expiry_..partial_cancel_at] 
-
-  Clock::time_point expiry_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_cancel_at::operator()]
-
-[indexterm2 asio.indexterm.partial_cancel_at.operator_lp__rp_..operator()..partial_cancel_at] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr cancel_at_t< decay_t< CompletionToken >, Clock, WaitTraits > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_cancel_at partial_cancel_at::partial_cancel_at]
-
-[indexterm2 asio.indexterm.partial_cancel_at.partial_cancel_at..partial_cancel_at..partial_cancel_at] 
-Constructor that specifies the expiry and cancellation type. 
-
-
-  partial_cancel_at(
-      const typename Clock::time_point & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_cancel_at_timer partial_cancel_at_timer]
-
-[indexterm1 asio.indexterm.partial_cancel_at_timer..partial_cancel_at_timer]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to cancel an operation at a given time. 
-
-
-  template<
-      typename Clock,
-      typename ``[link asio.reference.WaitTraits WaitTraits]`` = asio::wait_traits<Clock>,
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class partial_cancel_at_timer
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_at_timer.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler arguments should be combined into a single tuple argument. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_cancel_at_timer.partial_cancel_at_timer [*partial_cancel_at_timer]] [constructor]]
-    [Constructor that specifies the expiry and cancellation type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancel_at_timer.cancel_type_ [*cancel_type_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_at_timer.expiry_ [*expiry_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.partial_cancel_at_timer.timer_ [*timer_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/cancel_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancel_type_ partial_cancel_at_timer::cancel_type_]
-
-[indexterm2 asio.indexterm.partial_cancel_at_timer.cancel_type_..cancel_type_..partial_cancel_at_timer] 
-
-  cancellation_type_t cancel_type_;
-
-
-
-[endsect]
-
-
-
-[section:expiry_ partial_cancel_at_timer::expiry_]
-
-[indexterm2 asio.indexterm.partial_cancel_at_timer.expiry_..expiry_..partial_cancel_at_timer] 
-
-  Clock::time_point expiry_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_cancel_at_timer::operator()]
-
-[indexterm2 asio.indexterm.partial_cancel_at_timer.operator_lp__rp_..operator()..partial_cancel_at_timer] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler arguments should be combined into a single tuple argument. 
-
-
-  template<
-      typename CompletionToken>
-  cancel_at_timer< decay_t< CompletionToken >, Clock, WaitTraits, Executor > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_cancel_at_timer partial_cancel_at_timer::partial_cancel_at_timer]
-
-[indexterm2 asio.indexterm.partial_cancel_at_timer.partial_cancel_at_timer..partial_cancel_at_timer..partial_cancel_at_timer] 
-Constructor that specifies the expiry and cancellation type. 
-
-
-  partial_cancel_at_timer(
-      basic_waitable_timer< Clock, WaitTraits, Executor > & timer,
-      const typename Clock::time_point & expiry,
-      cancellation_type_t cancel_type = cancellation_type::terminal);
-
-
-
-[endsect]
-
-
-
-[section:timer_ partial_cancel_at_timer::timer_]
-
-[indexterm2 asio.indexterm.partial_cancel_at_timer.timer_..timer_..partial_cancel_at_timer] 
-
-  basic_waitable_timer< Clock, WaitTraits, Executor > & timer_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_cancellation_slot_binder partial_cancellation_slot_binder]
-
-[indexterm1 asio.indexterm.partial_cancellation_slot_binder..partial_cancellation_slot_binder]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the supplied cancellation slot as its associated cancellation slot. 
-
-
-  template<
-      typename ``[link asio.reference.CancellationSlot CancellationSlot]``>
-  struct partial_cancellation_slot_binder
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancellation_slot_binder.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler should have the cancellation slot as its associated cancellation slot. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_cancellation_slot_binder.partial_cancellation_slot_binder [*partial_cancellation_slot_binder]] [constructor]]
-    [Constructor that specifies associated cancellation slot. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_cancellation_slot_binder.cancellation_slot_ [*cancellation_slot_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/bind_cancellation_slot.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancellation_slot_ partial_cancellation_slot_binder::cancellation_slot_]
-
-[indexterm2 asio.indexterm.partial_cancellation_slot_binder.cancellation_slot_..cancellation_slot_..partial_cancellation_slot_binder] 
-
-  CancellationSlot cancellation_slot_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_cancellation_slot_binder::operator()]
-
-[indexterm2 asio.indexterm.partial_cancellation_slot_binder.operator_lp__rp_..operator()..partial_cancellation_slot_binder] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the cancellation slot as its associated cancellation slot. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr cancellation_slot_binder< decay_t< CompletionToken >, CancellationSlot > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_cancellation_slot_binder partial_cancellation_slot_binder::partial_cancellation_slot_binder]
-
-[indexterm2 asio.indexterm.partial_cancellation_slot_binder.partial_cancellation_slot_binder..partial_cancellation_slot_binder..partial_cancellation_slot_binder] 
-Constructor that specifies associated cancellation slot. 
-
-
-  partial_cancellation_slot_binder(
-      const CancellationSlot & ex);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_executor_binder partial_executor_binder]
-
-[indexterm1 asio.indexterm.partial_executor_binder..partial_executor_binder]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the supplied executor as its associated executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct partial_executor_binder
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_executor_binder.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler should have the executor as its associated executor. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_executor_binder.partial_executor_binder [*partial_executor_binder]] [constructor]]
-    [Constructor that specifies associated executor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_executor_binder.executor_ [*executor_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/bind_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:executor_ partial_executor_binder::executor_]
-
-[indexterm2 asio.indexterm.partial_executor_binder.executor_..executor_..partial_executor_binder] 
-
-  Executor executor_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_executor_binder::operator()]
-
-[indexterm2 asio.indexterm.partial_executor_binder.operator_lp__rp_..operator()..partial_executor_binder] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the executor as its associated executor. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr executor_binder< decay_t< CompletionToken >, Executor > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_executor_binder partial_executor_binder::partial_executor_binder]
-
-[indexterm2 asio.indexterm.partial_executor_binder.partial_executor_binder..partial_executor_binder..partial_executor_binder] 
-Constructor that specifies associated executor. 
-
-
-  partial_executor_binder(
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_immediate_executor_binder partial_immediate_executor_binder]
-
-[indexterm1 asio.indexterm.partial_immediate_executor_binder..partial_immediate_executor_binder]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the supplied executor as its associated immediate executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct partial_immediate_executor_binder
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_immediate_executor_binder.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler should have the executor as its associated immediate executor. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_immediate_executor_binder.partial_immediate_executor_binder [*partial_immediate_executor_binder]] [constructor]]
-    [Constructor that specifies associated executor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_immediate_executor_binder.executor_ [*executor_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/bind_immediate_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:executor_ partial_immediate_executor_binder::executor_]
-
-[indexterm2 asio.indexterm.partial_immediate_executor_binder.executor_..executor_..partial_immediate_executor_binder] 
-
-  Executor executor_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_immediate_executor_binder::operator()]
-
-[indexterm2 asio.indexterm.partial_immediate_executor_binder.operator_lp__rp_..operator()..partial_immediate_executor_binder] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should have the executor as its associated immediate executor. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr immediate_executor_binder< decay_t< CompletionToken >, Executor > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_immediate_executor_binder partial_immediate_executor_binder::partial_immediate_executor_binder]
-
-[indexterm2 asio.indexterm.partial_immediate_executor_binder.partial_immediate_executor_binder..partial_immediate_executor_binder..partial_immediate_executor_binder] 
-Constructor that specifies associated executor. 
-
-
-  partial_immediate_executor_binder(
-      const Executor & ex);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:partial_redirect_error partial_redirect_error]
-
-[indexterm1 asio.indexterm.partial_redirect_error..partial_redirect_error]
-
-
-A function object type that adapts a [link asio.overview.model.completion_tokens completion token] to capture error\_code values to a variable. 
-
-
-  class partial_redirect_error
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_redirect_error.operator_lp__rp_ [*operator()]]]
-    [Adapt a completion token to specify that the completion handler should capture error_code values to a variable. ]
-  ]
-  
-  [
-    [[link asio.reference.partial_redirect_error.partial_redirect_error [*partial_redirect_error]] [constructor]]
-    [Constructor that specifies the variable used to capture error_code values. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.partial_redirect_error.ec_ [*ec_]]]
-    []
-  ]
-
-]
-
-May also be used directly as a completion token, in which case it adapts the asynchronous operation's default completion token (or [link asio.reference.deferred `deferred`] if no default is available). 
-
-[heading Requirements]
-
-['Header: ][^asio/redirect_error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:ec_ partial_redirect_error::ec_]
-
-[indexterm2 asio.indexterm.partial_redirect_error.ec_..ec_..partial_redirect_error] 
-
-  asio::error_code & ec_;
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ partial_redirect_error::operator()]
-
-[indexterm2 asio.indexterm.partial_redirect_error.operator_lp__rp_..operator()..partial_redirect_error] 
-Adapt a [link asio.overview.model.completion_tokens completion token] to specify that the completion handler should capture error\_code values to a variable. 
-
-
-  template<
-      typename CompletionToken>
-  constexpr redirect_error_t< decay_t< CompletionToken > > operator()(
-      CompletionToken && completion_token) const;
-
-
-
-[endsect]
-
-
-
-[section:partial_redirect_error partial_redirect_error::partial_redirect_error]
-
-[indexterm2 asio.indexterm.partial_redirect_error.partial_redirect_error..partial_redirect_error..partial_redirect_error] 
-Constructor that specifies the variable used to capture error\_code values. 
-
-
-  partial_redirect_error(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:placeholders__bytes_transferred placeholders::bytes_transferred]
-
-[indexterm1 asio.indexterm.placeholders__bytes_transferred..placeholders::bytes_transferred]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the bytes\_transferred argument of a handler for asynchronous functions such as `asio::basic_stream_socket::async_write_some` or [link asio.reference.async_write `async_write`]. 
-
-
-  unspecified bytes_transferred;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:placeholders__endpoint placeholders::endpoint]
-
-[indexterm1 asio.indexterm.placeholders__endpoint..placeholders::endpoint]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the results argument of a handler for asynchronous functions such as [link asio.reference.async_connect `async_connect`]. 
-
-
-  unspecified endpoint;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:placeholders__error placeholders::error]
-
-[indexterm1 asio.indexterm.placeholders__error..placeholders::error]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the error argument of a handler for any of the asynchronous functions. 
-
-
-  unspecified error;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:placeholders__iterator placeholders::iterator]
-
-[indexterm1 asio.indexterm.placeholders__iterator..placeholders::iterator]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the iterator argument of a handler for asynchronous functions such as [link asio.reference.async_connect `async_connect`]. 
-
-
-  unspecified iterator;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:placeholders__results placeholders::results]
-
-[indexterm1 asio.indexterm.placeholders__results..placeholders::results]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the results argument of a handler for asynchronous functions such as asio::basic\_resolver::async\_resolve. 
-
-
-  unspecified results;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:placeholders__signal_number placeholders::signal_number]
-
-[indexterm1 asio.indexterm.placeholders__signal_number..placeholders::signal_number]
-
-An argument placeholder, for use with std::bind() or boost::bind(), that corresponds to the signal\_number argument of a handler for asynchronous functions such as `asio::signal_set::async_wait`. 
-
-
-  unspecified signal_number;
-
-
-[heading Requirements]
-
-['Header: ][^asio/placeholders.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:posix__basic_descriptor posix::basic_descriptor]
-
-[indexterm1 asio.indexterm.posix__basic_descriptor..posix::basic_descriptor]
-
-
-Provides POSIX descriptor functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_descriptor :
-    public posix::descriptor_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign posix::basic_descriptor::assign]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.assign..assign..posix::basic_descriptor] 
-Assign an existing native descriptor to the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.assign.overload1 assign]``(
-      const native_handle_type & native_descriptor);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.assign.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.assign.overload2 assign]``(
-      const native_handle_type & native_descriptor,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.assign.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::assign (1 of 2 overloads)]
-
-
-Assign an existing native descriptor to the descriptor. 
-
-
-  void assign(
-      const native_handle_type & native_descriptor);
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::assign (2 of 2 overloads)]
-
-
-Assign an existing native descriptor to the descriptor. 
-
-
-  void assign(
-      const native_handle_type & native_descriptor,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait posix::basic_descriptor::async_wait]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.async_wait..async_wait..posix::basic_descriptor] 
-Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  descriptor.async_wait(
-      asio::posix::stream_descriptor::wait_read,
-      wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_descriptor posix::basic_descriptor::basic_descriptor]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.basic_descriptor..basic_descriptor..posix::basic_descriptor] 
-Construct a descriptor without opening it. 
-
-
-  explicit ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload1 basic_descriptor]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload2 basic_descriptor]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload2 more...]]``
-
-
-Construct a descriptor on an existing native descriptor. 
-
-
-  ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload3 basic_descriptor]``(
-      const executor_type & ex,
-      const native_handle_type & native_descriptor);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload4 basic_descriptor]``(
-      ExecutionContext & context,
-      const native_handle_type & native_descriptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload4 more...]]``
-
-
-Move-construct a descriptor from another. 
-
-
-  ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload5 basic_descriptor]``(
-      basic_descriptor && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload5 more...]]``
-
-
-Move-construct a [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.posix__basic_descriptor.basic_descriptor.overload6 basic_descriptor]``(
-      basic_descriptor< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.basic_descriptor.overload6 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::basic_descriptor (1 of 6 overloads)]
-
-
-Construct a descriptor without opening it. 
-
-
-  basic_descriptor(
-      const executor_type & ex);
-
-
-This constructor creates a descriptor without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::basic_descriptor (2 of 6 overloads)]
-
-
-Construct a descriptor without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_descriptor(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a descriptor without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_descriptor::basic_descriptor (3 of 6 overloads)]
-
-
-Construct a descriptor on an existing native descriptor. 
-
-
-  basic_descriptor(
-      const executor_type & ex,
-      const native_handle_type & native_descriptor);
-
-
-This constructor creates a descriptor object to hold an existing native descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor.]]
-
-[[native_descriptor][A native descriptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 posix::basic_descriptor::basic_descriptor (4 of 6 overloads)]
-
-
-Construct a descriptor on an existing native descriptor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_descriptor(
-      ExecutionContext & context,
-      const native_handle_type & native_descriptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a descriptor object to hold an existing native descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor.]]
-
-[[native_descriptor][A native descriptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 posix::basic_descriptor::basic_descriptor (5 of 6 overloads)]
-
-
-Move-construct a descriptor from another. 
-
-
-  basic_descriptor(
-      basic_descriptor && other);
-
-
-This constructor moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other descriptor object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 posix::basic_descriptor::basic_descriptor (6 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_descriptor(
-      basic_descriptor< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:bytes_readable posix::basic_descriptor::bytes_readable]
-
-
-['Inherited from posix::descriptor_base.]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.bytes_readable..bytes_readable..posix::basic_descriptor] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::descriptor_base::bytes_readable command(true);
-  descriptor.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel posix::basic_descriptor::cancel]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.cancel..cancel..posix::basic_descriptor] 
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.cancel.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close posix::basic_descriptor::close]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.close..close..posix::basic_descriptor] 
-Close the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.close.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.close.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::close (1 of 2 overloads)]
-
-
-Close the descriptor. 
-
-
-  void close();
-
-
-This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::close (2 of 2 overloads)]
-
-
-Close the descriptor. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type posix::basic_descriptor::executor_type]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.executor_type..executor_type..posix::basic_descriptor] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor posix::basic_descriptor::get_executor]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.get_executor..get_executor..posix::basic_descriptor] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:io_control posix::basic_descriptor::io_control]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.io_control..io_control..posix::basic_descriptor] 
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.posix__basic_descriptor.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.posix__basic_descriptor.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.io_control.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::io_control (1 of 2 overloads)]
-
-
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the descriptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::posix::stream_descriptor::bytes_readable command;
-  descriptor.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::io_control (2 of 2 overloads)]
-
-
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the descriptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::posix::stream_descriptor::bytes_readable command;
-  asio::error_code ec;
-  descriptor.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open posix::basic_descriptor::is_open]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.is_open..is_open..posix::basic_descriptor] 
-Determine whether the descriptor is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer posix::basic_descriptor::lowest_layer]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.lowest_layer..lowest_layer..posix::basic_descriptor] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.posix__basic_descriptor.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.posix__basic_descriptor.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a descriptor cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a descriptor cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type posix::basic_descriptor::lowest_layer_type]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.lowest_layer_type..lowest_layer_type..posix::basic_descriptor] 
-A descriptor is always the lowest layer. 
-
-
-  typedef basic_descriptor lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle posix::basic_descriptor::native_handle]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.native_handle..native_handle..posix::basic_descriptor] 
-Get the native descriptor representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type posix::basic_descriptor::native_handle_type]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.native_handle_type..native_handle_type..posix::basic_descriptor] 
-The native representation of a descriptor. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking posix::basic_descriptor::native_non_blocking]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.native_non_blocking..native_non_blocking..posix::basic_descriptor] 
-Gets the non-blocking mode of the native descriptor implementation. 
-
-
-  bool ``[link asio.reference.posix__basic_descriptor.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::native_non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the native descriptor implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native descriptor. This mode has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying descriptor is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the descriptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native descriptor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::native_non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying descriptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_descriptor::native_non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying descriptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking posix::basic_descriptor::non_blocking]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.non_blocking..non_blocking..posix::basic_descriptor] 
-Gets the non-blocking mode of the descriptor. 
-
-
-  bool ``[link asio.reference.posix__basic_descriptor.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.non_blocking.overload3 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::non_blocking (1 of 3 overloads)]
-
-
-Gets the non-blocking mode of the descriptor. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::non_blocking (2 of 3 overloads)]
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_descriptor::non_blocking (3 of 3 overloads)]
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ posix::basic_descriptor::operator=]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.operator_eq_..operator=..posix::basic_descriptor] 
-Move-assign a descriptor from another. 
-
-
-  basic_descriptor & ``[link asio.reference.posix__basic_descriptor.operator_eq_.overload1 operator=]``(
-      basic_descriptor && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_descriptor & > ``[link asio.reference.posix__basic_descriptor.operator_eq_.overload2 operator=]``(
-      basic_descriptor< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::operator= (1 of 2 overloads)]
-
-
-Move-assign a descriptor from another. 
-
-
-  basic_descriptor & operator=(
-      basic_descriptor && other);
-
-
-This assignment operator moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other descriptor object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_descriptor & > operator=(
-      basic_descriptor< Executor1 > && other);
-
-
-This assignment operator moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:release posix::basic_descriptor::release]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.release..release..posix::basic_descriptor] 
-Release ownership of the native descriptor implementation. 
-
-
-  native_handle_type release();
-
-
-This function may be used to obtain the underlying representation of the descriptor. After calling this function, `is_open()` returns false. The caller is responsible for closing the descriptor.
-
-All outstanding asynchronous read or write operations will finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. 
-
-
-[endsect]
-
-
-[section:wait posix::basic_descriptor::wait]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.wait..wait..posix::basic_descriptor] 
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.posix__basic_descriptor.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.wait.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_descriptor.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_descriptor.wait.overload2 more...]]``
-
-
-[section:overload1 posix::basic_descriptor::wait (1 of 2 overloads)]
-
-
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a descriptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a descriptor to become readable. 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  descriptor.wait(asio::posix::stream_descriptor::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_descriptor::wait (2 of 2 overloads)]
-
-
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a descriptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a descriptor to become readable. 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::error_code ec;
-  descriptor.wait(asio::posix::stream_descriptor::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type posix::basic_descriptor::wait_type]
-
-
-['Inherited from posix::descriptor_base.]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.wait_type..wait_type..posix::basic_descriptor] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.posix__basic_descriptor.wait_type.wait_read..wait_read..posix::basic_descriptor]
-[indexterm2 asio.indexterm.posix__basic_descriptor.wait_type.wait_write..wait_write..posix::basic_descriptor]
-[indexterm2 asio.indexterm.posix__basic_descriptor.wait_type.wait_error..wait_error..posix::basic_descriptor]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a descriptor to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a descriptor to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a descriptor to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `descriptor::wait()` and `descriptor::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_basic_descriptor posix::basic_descriptor::~basic_descriptor]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor._basic_descriptor..~basic_descriptor..posix::basic_descriptor] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~basic_descriptor();
-
-
-This function destroys the descriptor, cancelling any outstanding asynchronous wait operations associated with the descriptor as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:posix__basic_descriptor__rebind_executor posix::basic_descriptor::rebind_executor]
-
-[indexterm1 asio.indexterm.posix__basic_descriptor__rebind_executor..posix::basic_descriptor::rebind_executor]
-
-
-Rebinds the descriptor type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor.other [*other]]]
-    [The descriptor type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other posix::basic_descriptor::rebind_executor::other]
-
-[indexterm2 asio.indexterm.posix__basic_descriptor__rebind_executor.other..other..posix::basic_descriptor::rebind_executor] 
-The descriptor type when rebound to the specified executor. 
-
-
-  typedef basic_descriptor< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:posix__basic_stream_descriptor posix::basic_stream_descriptor]
-
-[indexterm1 asio.indexterm.posix__basic_stream_descriptor..posix::basic_stream_descriptor]
-
-
-Provides stream-oriented descriptor functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_stream_descriptor :
-    public posix::basic_descriptor< any_io_executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]] [constructor]]
-    [Construct a stream descriptor without opening it. 
-     [hr]
-     Construct a stream descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a stream descriptor from another. 
-     [hr]
-     Move-construct a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a stream descriptor from another. 
-     [hr]
-     Move-assign a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
-    [Read some data from the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
-    [Write some data to the descriptor. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] class template provides asynchronous and blocking stream-oriented descriptor functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some` and `write_some` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single descriptor object. Other synchronous operations, such as `close`, are not thread safe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign posix::basic_stream_descriptor::assign]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.assign..assign..posix::basic_stream_descriptor] 
-Assign an existing native descriptor to the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.assign.overload1 assign]``(
-      const native_handle_type & native_descriptor);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.assign.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.assign.overload2 assign]``(
-      const native_handle_type & native_descriptor,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.assign.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::assign (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Assign an existing native descriptor to the descriptor. 
-
-
-  void assign(
-      const native_handle_type & native_descriptor);
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::assign (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Assign an existing native descriptor to the descriptor. 
-
-
-  void assign(
-      const native_handle_type & native_descriptor,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some posix::basic_stream_descriptor::async_read_some]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.async_read_some..async_read_some..posix::basic_stream_descriptor] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the stream descriptor. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  descriptor.async_read_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_wait posix::basic_stream_descriptor::async_wait]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.async_wait..async_wait..posix::basic_stream_descriptor] 
-Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      wait_type w,
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to perform an asynchronous wait for a descriptor to enter a ready to read, write or error condition state. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Example]
-  
-
-
-  void wait_handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Wait succeeded.
-    }
-  }
-
-  ...
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  descriptor.async_wait(
-      asio::posix::stream_descriptor::wait_read,
-      wait_handler);
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some posix::basic_stream_descriptor::async_write_some]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.async_write_some..async_write_some..posix::basic_stream_descriptor] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the stream descriptor. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the descriptor. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  descriptor.async_write_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_stream_descriptor posix::basic_stream_descriptor::basic_stream_descriptor]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.basic_stream_descriptor..basic_stream_descriptor..posix::basic_stream_descriptor] 
-Construct a stream descriptor without opening it. 
-
-
-  explicit ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload1 basic_stream_descriptor]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload2 basic_stream_descriptor]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload2 more...]]``
-
-
-Construct a stream descriptor on an existing native descriptor. 
-
-
-  ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload3 basic_stream_descriptor]``(
-      const executor_type & ex,
-      const native_handle_type & native_descriptor);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload4 basic_stream_descriptor]``(
-      ExecutionContext & context,
-      const native_handle_type & native_descriptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload4 more...]]``
-
-
-Move-construct a stream descriptor from another. 
-
-
-  ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload5 basic_stream_descriptor]``(
-      basic_stream_descriptor && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload5 more...]]``
-
-
-Move-construct a [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload6 basic_stream_descriptor]``(
-      basic_stream_descriptor< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor.overload6 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::basic_stream_descriptor (1 of 6 overloads)]
-
-
-Construct a stream descriptor without opening it. 
-
-
-  basic_stream_descriptor(
-      const executor_type & ex);
-
-
-This constructor creates a stream descriptor without opening it. The descriptor needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::basic_stream_descriptor (2 of 6 overloads)]
-
-
-Construct a stream descriptor without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_descriptor(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a stream descriptor without opening it. The descriptor needs to be opened and then connected or accepted before data can be sent or received on it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_stream_descriptor::basic_stream_descriptor (3 of 6 overloads)]
-
-
-Construct a stream descriptor on an existing native descriptor. 
-
-
-  basic_stream_descriptor(
-      const executor_type & ex,
-      const native_handle_type & native_descriptor);
-
-
-This constructor creates a stream descriptor object to hold an existing native descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor.]]
-
-[[native_descriptor][The new underlying descriptor implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 posix::basic_stream_descriptor::basic_stream_descriptor (4 of 6 overloads)]
-
-
-Construct a stream descriptor on an existing native descriptor. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_descriptor(
-      ExecutionContext & context,
-      const native_handle_type & native_descriptor,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a stream descriptor object to hold an existing native descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the descriptor will use, by default, to dispatch handlers for any asynchronous operations performed on the descriptor.]]
-
-[[native_descriptor][The new underlying descriptor implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 posix::basic_stream_descriptor::basic_stream_descriptor (5 of 6 overloads)]
-
-
-Move-construct a stream descriptor from another. 
-
-
-  basic_stream_descriptor(
-      basic_stream_descriptor && other);
-
-
-This constructor moves a stream descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream descriptor object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 posix::basic_stream_descriptor::basic_stream_descriptor (6 of 6 overloads)]
-
-
-Move-construct a [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_stream_descriptor(
-      basic_stream_descriptor< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:bytes_readable posix::basic_stream_descriptor::bytes_readable]
-
-
-['Inherited from posix::descriptor_base.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.bytes_readable..bytes_readable..posix::basic_stream_descriptor] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::descriptor_base::bytes_readable command(true);
-  descriptor.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:cancel posix::basic_stream_descriptor::cancel]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.cancel..cancel..posix::basic_stream_descriptor] 
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.cancel.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::cancel (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::cancel (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Cancel all asynchronous operations associated with the descriptor. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close posix::basic_stream_descriptor::close]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.close..close..posix::basic_stream_descriptor] 
-Close the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.close.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.close.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::close (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Close the descriptor. 
-
-
-  void close();
-
-
-This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::close (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Close the descriptor. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the descriptor. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type posix::basic_stream_descriptor::executor_type]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.executor_type..executor_type..posix::basic_stream_descriptor] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor posix::basic_stream_descriptor::get_executor]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.get_executor..get_executor..posix::basic_stream_descriptor] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-[section:io_control posix::basic_stream_descriptor::io_control]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.io_control..io_control..posix::basic_stream_descriptor] 
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.posix__basic_stream_descriptor.io_control.overload1 io_control]``(
-      IoControlCommand & command);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.io_control.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void ``[link asio.reference.posix__basic_stream_descriptor.io_control.overload2 io_control]``(
-      IoControlCommand & command,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.io_control.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::io_control (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command);
-
-
-This function is used to execute an IO control command on the descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the descriptor.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::posix::stream_descriptor::bytes_readable command;
-  descriptor.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::io_control (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Perform an IO control command on the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.IoControlCommand IoControlCommand]``>
-  void io_control(
-      IoControlCommand & command,
-      asio::error_code & ec);
-
-
-This function is used to execute an IO control command on the descriptor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[command][The IO control command to be performed on the descriptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-
-[heading Example]
-  
-Getting the number of bytes ready to read: 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::posix::stream_descriptor::bytes_readable command;
-  asio::error_code ec;
-  descriptor.io_control(command, ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:is_open posix::basic_stream_descriptor::is_open]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.is_open..is_open..posix::basic_stream_descriptor] 
-Determine whether the descriptor is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer posix::basic_stream_descriptor::lowest_layer]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.lowest_layer..lowest_layer..posix::basic_stream_descriptor] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.posix__basic_stream_descriptor.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.posix__basic_stream_descriptor.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since a descriptor cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since a descriptor cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type posix::basic_stream_descriptor::lowest_layer_type]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.lowest_layer_type..lowest_layer_type..posix::basic_stream_descriptor] 
-A descriptor is always the lowest layer. 
-
-
-  typedef basic_descriptor lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle posix::basic_stream_descriptor::native_handle]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.native_handle..native_handle..posix::basic_stream_descriptor] 
-Get the native descriptor representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type posix::basic_stream_descriptor::native_handle_type]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.native_handle_type..native_handle_type..posix::basic_stream_descriptor] 
-The native representation of a descriptor. 
-
-
-  typedef basic_descriptor< Executor >::native_handle_type native_handle_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:native_non_blocking posix::basic_stream_descriptor::native_non_blocking]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.native_non_blocking..native_non_blocking..posix::basic_stream_descriptor] 
-Gets the non-blocking mode of the native descriptor implementation. 
-
-
-  bool ``[link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload1 native_non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload2 native_non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload3 native_non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.native_non_blocking.overload3 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::native_non_blocking (1 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Gets the non-blocking mode of the native descriptor implementation. 
-
-
-  bool native_non_blocking() const;
-
-
-This function is used to retrieve the non-blocking mode of the underlying native descriptor. This mode has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Return Value]
-      
-`true` if the underlying descriptor is in non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).
-
-
-[heading Remarks]
-      
-The current non-blocking mode is cached by the descriptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native descriptor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::native_non_blocking (2 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode);
-
-
-This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying descriptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_stream_descriptor::native_non_blocking (3 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Sets the non-blocking mode of the native descriptor implementation. 
-
-
-  void native_non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the underlying descriptor is put into non-blocking mode and direct system calls may fail with `asio::error::would_block` (or the equivalent system error).]]
-
-[[ec][Set to indicate what error occurred, if any. If the `mode` is `false`, but the current value of `non_blocking()` is `true`, this function fails with `asio::error::invalid_argument`, as the combination does not make sense. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:non_blocking posix::basic_stream_descriptor::non_blocking]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.non_blocking..non_blocking..posix::basic_stream_descriptor] 
-Gets the non-blocking mode of the descriptor. 
-
-
-  bool ``[link asio.reference.posix__basic_stream_descriptor.non_blocking.overload1 non_blocking]``() const;
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.non_blocking.overload1 more...]]``
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.non_blocking.overload2 non_blocking]``(
-      bool mode);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.non_blocking.overload2 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.non_blocking.overload3 non_blocking]``(
-      bool mode,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.non_blocking.overload3 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::non_blocking (1 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Gets the non-blocking mode of the descriptor. 
-
-
-  bool non_blocking() const;
-
-
-
-[heading Return Value]
-      
-`true` if the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::non_blocking (2 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void non_blocking(
-      bool mode);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 posix::basic_stream_descriptor::non_blocking (3 of 3 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Sets the non-blocking mode of the descriptor. 
-
-
-  void non_blocking(
-      bool mode,
-      asio::error_code & ec);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[mode][If `true`, the descriptor's synchronous operations will fail with `asio::error::would_block` if they are unable to perform the requested operation immediately. If `false`, synchronous operations will block until complete.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-The non-blocking mode has no effect on the behaviour of asynchronous operations. Asynchronous operations will never fail with the error `asio::error::would_block`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:operator_eq_ posix::basic_stream_descriptor::operator=]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.operator_eq_..operator=..posix::basic_stream_descriptor] 
-Move-assign a stream descriptor from another. 
-
-
-  basic_stream_descriptor & ``[link asio.reference.posix__basic_stream_descriptor.operator_eq_.overload1 operator=]``(
-      basic_stream_descriptor && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.operator_eq_.overload1 more...]]``
-
-
-Move-assign a [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_descriptor & > ``[link asio.reference.posix__basic_stream_descriptor.operator_eq_.overload2 operator=]``(
-      basic_stream_descriptor< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::operator= (1 of 2 overloads)]
-
-
-Move-assign a stream descriptor from another. 
-
-
-  basic_stream_descriptor & operator=(
-      basic_stream_descriptor && other);
-
-
-This assignment operator moves a stream descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream descriptor object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::operator= (2 of 2 overloads)]
-
-
-Move-assign a [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] from a descriptor of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_descriptor & > operator=(
-      basic_stream_descriptor< Executor1 > && other);
-
-
-This assignment operator moves a descriptor from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_descriptor(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some posix::basic_stream_descriptor::read_some]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.read_some..read_some..posix::basic_stream_descriptor] 
-Read some data from the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.posix__basic_stream_descriptor.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.posix__basic_stream_descriptor.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.read_some.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::read_some (1 of 2 overloads)]
-
-
-Read some data from the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  descriptor.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::read_some (2 of 2 overloads)]
-
-
-Read some data from the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:release posix::basic_stream_descriptor::release]
-
-
-['Inherited from posix::basic_descriptor.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.release..release..posix::basic_stream_descriptor] 
-Release ownership of the native descriptor implementation. 
-
-
-  native_handle_type release();
-
-
-This function may be used to obtain the underlying representation of the descriptor. After calling this function, `is_open()` returns false. The caller is responsible for closing the descriptor.
-
-All outstanding asynchronous read or write operations will finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. 
-
-
-[endsect]
-
-
-[section:wait posix::basic_stream_descriptor::wait]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.wait..wait..posix::basic_stream_descriptor] 
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.wait.overload1 wait]``(
-      wait_type w);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.wait.overload1 more...]]``
-
-  void ``[link asio.reference.posix__basic_stream_descriptor.wait.overload2 wait]``(
-      wait_type w,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.wait.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::wait (1 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w);
-
-
-This function is used to perform a blocking wait for a descriptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a descriptor to become readable. 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  descriptor.wait(asio::posix::stream_descriptor::wait_read);
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::wait (2 of 2 overloads)]
-
-
-['Inherited from posix::basic_descriptor.]
-
-
-Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. 
-
-
-  void wait(
-      wait_type w,
-      asio::error_code & ec);
-
-
-This function is used to perform a blocking wait for a descriptor to enter a ready to read, write or error condition state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[w][Specifies the desired descriptor state.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Example]
-  
-Waiting for a descriptor to become readable. 
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::error_code ec;
-  descriptor.wait(asio::posix::stream_descriptor::wait_read, ec);
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait_type posix::basic_stream_descriptor::wait_type]
-
-
-['Inherited from posix::descriptor_base.]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.wait_type..wait_type..posix::basic_stream_descriptor] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.wait_type.wait_read..wait_read..posix::basic_stream_descriptor]
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.wait_type.wait_write..wait_write..posix::basic_stream_descriptor]
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.wait_type.wait_error..wait_error..posix::basic_stream_descriptor]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a descriptor to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a descriptor to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a descriptor to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `descriptor::wait()` and `descriptor::async_wait()`. 
-
-
-[endsect]
-
-
-[section:write_some posix::basic_stream_descriptor::write_some]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor.write_some..write_some..posix::basic_stream_descriptor] 
-Write some data to the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.posix__basic_stream_descriptor.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.posix__basic_stream_descriptor.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.posix__basic_stream_descriptor.write_some.overload2 more...]]``
-
-
-[section:overload1 posix::basic_stream_descriptor::write_some (1 of 2 overloads)]
-
-
-Write some data to the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the descriptor.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  descriptor.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 posix::basic_stream_descriptor::write_some (2 of 2 overloads)]
-
-
-Write some data to the descriptor. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the descriptor.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:posix__basic_stream_descriptor__rebind_executor posix::basic_stream_descriptor::rebind_executor]
-
-[indexterm1 asio.indexterm.posix__basic_stream_descriptor__rebind_executor..posix::basic_stream_descriptor::rebind_executor]
-
-
-Rebinds the descriptor type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor__rebind_executor.other [*other]]]
-    [The descriptor type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other posix::basic_stream_descriptor::rebind_executor::other]
-
-[indexterm2 asio.indexterm.posix__basic_stream_descriptor__rebind_executor.other..other..posix::basic_stream_descriptor::rebind_executor] 
-The descriptor type when rebound to the specified executor. 
-
-
-  typedef basic_stream_descriptor< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]] [constructor]]
-    [Construct a stream descriptor without opening it. 
-     [hr]
-     Construct a stream descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a stream descriptor from another. 
-     [hr]
-     Move-construct a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a stream descriptor from another. 
-     [hr]
-     Move-assign a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
-    [Read some data from the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
-    [Write some data to the descriptor. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] class template provides asynchronous and blocking stream-oriented descriptor functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some` and `write_some` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single descriptor object. Other synchronous operations, such as `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/basic_stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:posix__descriptor posix::descriptor]
-
-[indexterm1 asio.indexterm.posix__descriptor..posix::descriptor]
-
-Typedef for the typical usage of [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`]. 
-
-
-  typedef basic_descriptor descriptor;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.basic_descriptor [*basic_descriptor]] [constructor]]
-    [Construct a descriptor without opening it. 
-     [hr]
-     Construct a descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a descriptor from another. 
-     [hr]
-     Move-construct a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a descriptor from another. 
-     [hr]
-     Move-assign a basic_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_descriptor._basic_descriptor [*~basic_descriptor]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_descriptor `posix::basic_descriptor`] class template provides the ability to wrap a POSIX descriptor.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:posix__descriptor_base posix::descriptor_base]
-
-[indexterm1 asio.indexterm.posix__descriptor_base..posix::descriptor_base]
-
-
-The [link asio.reference.posix__descriptor_base `posix::descriptor_base`] class is used as a base for the descriptor class as a place to define the associated IO control commands. 
-
-
-  class descriptor_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__descriptor_base.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__descriptor_base.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__descriptor_base._descriptor_base [*~descriptor_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/posix/descriptor_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:bytes_readable posix::descriptor_base::bytes_readable]
-
-[indexterm2 asio.indexterm.posix__descriptor_base.bytes_readable..bytes_readable..posix::descriptor_base] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::posix::stream_descriptor descriptor(my_context);
-  ...
-  asio::descriptor_base::bytes_readable command(true);
-  descriptor.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/descriptor_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:wait_type posix::descriptor_base::wait_type]
-
-[indexterm2 asio.indexterm.posix__descriptor_base.wait_type..wait_type..posix::descriptor_base] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.posix__descriptor_base.wait_type.wait_read..wait_read..posix::descriptor_base]
-[indexterm2 asio.indexterm.posix__descriptor_base.wait_type.wait_write..wait_write..posix::descriptor_base]
-[indexterm2 asio.indexterm.posix__descriptor_base.wait_type.wait_error..wait_error..posix::descriptor_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a descriptor to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a descriptor to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a descriptor to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `descriptor::wait()` and `descriptor::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_descriptor_base posix::descriptor_base::~descriptor_base]
-
-[indexterm2 asio.indexterm.posix__descriptor_base._descriptor_base..~descriptor_base..posix::descriptor_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~descriptor_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:posix__stream_descriptor posix::stream_descriptor]
-
-[indexterm1 asio.indexterm.posix__stream_descriptor..posix::stream_descriptor]
-
-Typedef for the typical usage of a stream-oriented descriptor. 
-
-
-  typedef basic_stream_descriptor stream_descriptor;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor__rebind_executor [*rebind_executor]]]
-    [Rebinds the descriptor type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer_type [*lowest_layer_type]]]
-    [A descriptor is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle_type [*native_handle_type]]]
-    [The native representation of a descriptor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.posix__basic_stream_descriptor.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.assign [*assign]]]
-    [Assign an existing native descriptor to the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_wait [*async_wait]]]
-    [Asynchronously wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.basic_stream_descriptor [*basic_stream_descriptor]] [constructor]]
-    [Construct a stream descriptor without opening it. 
-     [hr]
-     Construct a stream descriptor on an existing native descriptor. 
-     [hr]
-     Move-construct a stream descriptor from another. 
-     [hr]
-     Move-construct a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.close [*close]]]
-    [Close the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.io_control [*io_control]]]
-    [Perform an IO control command on the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.is_open [*is_open]]]
-    [Determine whether the descriptor is open. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_handle [*native_handle]]]
-    [Get the native descriptor representation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.native_non_blocking [*native_non_blocking]]]
-    [Gets the non-blocking mode of the native descriptor implementation. 
-     [hr]
-     Sets the non-blocking mode of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.non_blocking [*non_blocking]]]
-    [Gets the non-blocking mode of the descriptor. 
-     [hr]
-     Sets the non-blocking mode of the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.operator_eq_ [*operator=]]]
-    [Move-assign a stream descriptor from another. 
-     [hr]
-     Move-assign a basic_stream_descriptor from a descriptor of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.read_some [*read_some]]]
-    [Read some data from the descriptor. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.release [*release]]]
-    [Release ownership of the native descriptor implementation. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.wait [*wait]]]
-    [Wait for the descriptor to become ready to read, ready to write, or to have pending error conditions. ]
-  ]
-  
-  [
-    [[link asio.reference.posix__basic_stream_descriptor.write_some [*write_some]]]
-    [Write some data to the descriptor. ]
-  ]
-  
-]
-
-The [link asio.reference.posix__basic_stream_descriptor `posix::basic_stream_descriptor`] class template provides asynchronous and blocking stream-oriented descriptor functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some` and `write_some` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single descriptor object. Other synchronous operations, such as `close`, are not thread safe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/posix/stream_descriptor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:post post]
-
-[indexterm1 asio.indexterm.post..post]
-
-Submits a completion token or function object for execution. 
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto ``[link asio.reference.post.overload1 post]``(
-      NullaryToken && token);
-  ``  [''''&raquo;''' [link asio.reference.post.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.post.overload2 post]``(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.post.overload2 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto ``[link asio.reference.post.overload3 post]``(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.post.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/post.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 post (1 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.NullaryToken NullaryToken]``>
-  auto post(
-      NullaryToken && token);
-
-
-This function submits an object for execution using the object's associated executor. The function object is queued for execution, and is never called from the current thread prior to returning from `post()`.
-
-The use of `post()`, rather than [link asio.reference.defer `defer`], indicates the caller's preference that the function object be eagerly queued for execution.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex` of type `Ex` by performing 
-
-  auto ex = get_associated_executor(handler); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(
-     require(ex, execution::blocking.never),
-     execution::relationship.fork,
-     execution::allocator(alloc)
-   ).execute(std::forward<CompletionHandler>(completion_handler)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.post(
-     std::forward<CompletionHandler>(completion_handler),
-     alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 post (2 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<Executor>>
-  auto post(
-      const Executor & ex,
-      NullaryToken && token = default_completion_token_t< Executor >(),
-      constraint_t<(execution::is_executor< Executor >::value &&can_require< Executor, execution::blocking_t::never_t >::value)||is_executor< Executor >::value >  = 0);
-
-
-This function submits an object for execution using the specified executor. The function object is queued for execution, and is never called from the current thread prior to returning from `post()`.
-
-The use of `post()`, rather than [link asio.reference.defer `defer`], indicates the caller's preference that the function object be eagerly queued for execution.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The target executor.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-This function returns `async_initiate<NullaryToken, void()>(Init{ex}, token)`, where `Init` is a function object type defined as:
-
-
-
-  class Init
-  {
-  public:
-    using executor_type = Executor;
-    explicit Init(const Executor& ex) : ex_(ex) {}
-    executor_type get_executor() const noexcept { return ex_; }
-    template <typename CompletionHandler>
-      void operator()(CompletionHandler&& completion_handler) const;
-  private:
-    Executor ex_; // exposition only
-  }; 
-
-
-
-
-The function call operator of `Init:` 
-
-
-* Obtains the handler's associated executor object `ex1` of type `Ex1` by performing 
-
-  auto ex1 = get_associated_executor(handler, ex); 
-
-
-
-
-
-* Obtains the handler's associated allocator object `alloc` by performing 
-
-  auto alloc = get_associated_allocator(handler); 
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is true, constructs a function object `f` with a member `executor_` that is initialised with `prefer(ex1, execution::outstanding_work.tracked)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  prefer(executor_, execution::allocator(a)).execute(std::move(handler_));
-
-
-
-
-
-* If `execution::is_executor<Ex1>::value` is false, constructs a function object `f` with a member `work_` that is initialised with `make_work_guard(ex1)`, a member `handler_` that is a decay-copy of `completion_handler`, and a function call operator that performs: 
-
-  auto a = get_associated_allocator(handler_);
-  work_.get_executor().dispatch(std::move(handler_), a);
-  work_.reset(); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is true, performs 
-
-  prefer(
-     require(ex, execution::blocking.never),
-     execution::relationship.fork,
-     execution::allocator(alloc)
-   ).execute(std::move(f)); 
-
-
-
-
-
-* If `execution::is_executor<Ex>::value` is false, performs 
-
-  ex.post(std::move(f), alloc); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 post (3 of 3 overloads)]
-
-
-Submits a completion token or function object for execution. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.NullaryToken NullaryToken]`` = default_completion_token_t<typename ExecutionContext::executor_type>>
-  auto post(
-      ExecutionContext & ctx,
-      NullaryToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][An execution context, from which the target executor is obtained.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler. The function signature of the completion handler must be: 
-``
-  void handler(); 
-``
-]]
-
-]
-
-
-[heading Return Value]
-      
-`post(ctx.get_executor(), forward<NullaryToken>(token))`.
-
-
-[heading Completion Signature]
-  
-
-
-  void() 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:prefer prefer]
-
-[indexterm1 asio.indexterm.prefer..prefer]
-
-A customisation point that attempts to apply a property to an object. 
-
-
-  constexpr unspecified prefer = unspecified;
-
-
-The name `prefer` denotes a customisation point object. The expression `asio::prefer(E, P0, Pn...)` for some subexpressions `E` and `P0`, and where `Pn...` represents `N` subexpressions (where `N` is 0 or more, and with types `T = decay_t<decltype(E)>` and `Prop0 = decay_t<decltype(P0)>`) is expression-equivalent to:
-
-
-* If `is_applicable_property_v<T, Prop0> && Prop0::is_preferable` is not a well-formed constant expression with value `true`, `asio::prefer(E, P0, Pn...)` is ill-formed.
-
-
-* Otherwise, `E` if `N == 0` and the expression `Prop0::template static_query_v<T> == Prop0::value()` is a well-formed constant expression with value `true`.
-
-
-* Otherwise, `(E).require(P0)` if `N == 0` and the expression `(E).require(P0)` is a valid expression.
-
-
-* Otherwise, `require(E, P0)` if `N == 0` and the expression `require(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require` customization point object.
-
-
-* Otherwise, `(E).prefer(P0)` if `N == 0` and the expression `(E).prefer(P0)` is a valid expression.
-
-
-* Otherwise, `prefer(E, P0)` if `N == 0` and the expression `prefer(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `prefer` customization point object.
-
-
-* Otherwise, `E` if `N == 0`.
-
-
-* Otherwise, `asio::prefer(asio::prefer(E, P0), Pn...)` if `N > 0` and the expression `asio::prefer(asio::prefer(E, P0), Pn...)` is a valid expression.
-
-
-* Otherwise, `asio::prefer(E, P0, Pn...)` is ill-formed. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/prefer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:prefer_result prefer_result]
-
-[indexterm1 asio.indexterm.prefer_result..prefer_result]
-
-
-A type trait that determines the result type of a `prefer` expression. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct prefer_result
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.prefer_result.type [*type]]]
-    [The result of the prefer expression. ]
-  
-  ]
-
-]
-
-Class template `prefer_result` is a trait that determines the result type of the expression `asio::prefer(std::declval<T>(), std::declval<Properties>()...)`. 
-
-[heading Requirements]
-
-['Header: ][^asio/prefer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type prefer_result::type]
-
-[indexterm2 asio.indexterm.prefer_result.type..type..prefer_result] 
-The result of the `prefer` expression. 
-
-
-  typedef automatically_determined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/prefer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:prepend prepend]
-
-[indexterm1 asio.indexterm.prepend..prepend]
-
-Completion token type used to specify that the completion handler arguments should be passed additional values before the results of the operation. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  constexpr prepend_t< decay_t< CompletionToken >, decay_t< Values >... > prepend(
-      CompletionToken && completion_token,
-      Values &&... values);
-
-
-[heading Requirements]
-
-['Header: ][^asio/prepend.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:prepend_t prepend_t]
-
-[indexterm1 asio.indexterm.prepend_t..prepend_t]
-
-
-Completion token type used to specify that the completion handler arguments should be passed additional values before the results of the operation. 
-
-
-  template<
-      typename CompletionToken,
-      typename... Values>
-  class prepend_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.prepend_t.prepend_t [*prepend_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.prepend_t.token_ [*token_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.prepend_t.values_ [*values_]]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/prepend.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:prepend_t prepend_t::prepend_t]
-
-[indexterm2 asio.indexterm.prepend_t.prepend_t..prepend_t..prepend_t] 
-Constructor. 
-
-
-  template<
-      typename T,
-      typename... V>
-  constexpr prepend_t(
-      T && completion_token,
-      V &&... values);
-
-
-
-[endsect]
-
-
-
-[section:token_ prepend_t::token_]
-
-[indexterm2 asio.indexterm.prepend_t.token_..token_..prepend_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[section:values_ prepend_t::values_]
-
-[indexterm2 asio.indexterm.prepend_t.values_..values_..prepend_t] 
-
-  std::tuple< Values... > values_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:query query]
-
-[indexterm1 asio.indexterm.query..query]
-
-A customisation point that queries the value of a property. 
-
-
-  constexpr unspecified query = unspecified;
-
-
-The name `query` denotes a customization point object. The expression `asio::query(E, P)` for some subexpressions `E` and `P` (with types `T = decay_t<decltype(E)>` and `Prop = decay_t<decltype(P)>`) is expression-equivalent to:
-
-
-* If `is_applicable_property_v<T, Prop>` is not a well-formed constant expression with value `true`, `asio::query(E,
-  P)` is ill-formed.
-
-
-* Otherwise, `Prop::template static_query_v<T>` if the expression `Prop::template static_query_v<T>` is a well-formed constant expression.
-
-
-* Otherwise, `(E).query(P)` if the expression `(E).query(P)` is well-formed.
-
-
-* Otherwise, `query(E, P)` if the expression `query(E, P)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `query` customization point object.
-
-
-* Otherwise, `asio::query(E, P)` is ill-formed. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:query_result query_result]
-
-[indexterm1 asio.indexterm.query_result..query_result]
-
-
-A type trait that determines the result type of a `query` expression. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct query_result
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.query_result.type [*type]]]
-    [The result of the query expression. ]
-  
-  ]
-
-]
-
-Class template `query_result` is a trait that determines the result type of the expression `asio::query(std::declval<T>(), std::declval<Property>())`. 
-
-[heading Requirements]
-
-['Header: ][^asio/query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type query_result::type]
-
-[indexterm2 asio.indexterm.query_result.type..type..query_result] 
-The result of the `query` expression. 
-
-
-  typedef automatically_determined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/query.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:random_access_file random_access_file]
-
-[indexterm1 asio.indexterm.random_access_file..random_access_file]
-
-Typedef for the typical usage of a random-access file. 
-
-
-  typedef basic_random_access_file random_access_file;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_random_access_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_random_access_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.basic_random_access_file [*basic_random_access_file]] [constructor]]
-    [Construct a basic_random_access_file without opening it. 
-     [hr]
-     Construct and open a basic_random_access_file. 
-     [hr]
-     Construct a basic_random_access_file on an existing native file. 
-     [hr]
-     Move-construct a basic_random_access_file from another. 
-     [hr]
-     Move-construct a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_random_access_file from another. 
-     [hr]
-     Move-assign a basic_random_access_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_random_access_file._basic_random_access_file [*~basic_random_access_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_random_access_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_random_access_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_random_access_file `basic_random_access_file`] class template provides asynchronous and blocking random-access file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-Synchronous `read_some_at` and `write_some_at` operations are thread safe with respect to each other, if the underlying operating system calls are also thread safe. This means that it is permitted to perform concurrent calls to these synchronous operations on a single file object. Other synchronous operations, such as `open` or `close`, are not thread safe. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/random_access_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:read read]
-
-[indexterm1 asio.indexterm.read..read]
-
-The `read` function is a composed operation that reads a certain amount of data from a stream before returning. 
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.read.overload1 read]``(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.read.overload2 read]``(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload3 read]``(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload4 read]``(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read.overload5 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read.overload6 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload7 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload8 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload8 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read.overload9 read]``(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b);
-  ``  [''''&raquo;''' [link asio.reference.read.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read.overload10 read]``(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read.overload10 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload11 read]``(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload11 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload12 read]``(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload12 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read.overload13 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload13 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read.overload14 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload14 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload15 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload15 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read.overload16 read]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read.overload16 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/read.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 read (1 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read(s, asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 read (2 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read(s, asio::buffer(data, size), ec); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 read (3 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read(s, asio::buffer(data, size),
-     asio::transfer_at_least(32)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 read (4 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_mutable_buffer_sequence< MutableBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 read (5 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 read (6 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 read (7 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 read (8 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 read (9 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, b,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 read (10 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, b,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 read (11 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 read (12 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 read (13 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload14 read (14 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The supplied buffer is full (that is, it has reached maximum size).
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload15 read (15 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload16 read (16 of 16 overloads)]
-
-
-Attempt to read a certain amount of data from a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
-
-
-* The specified dynamic buffer sequence is full (that is, it has reached maximum size).
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_at read_at]
-
-[indexterm1 asio.indexterm.read_at..read_at]
-
-The `read_at` function is a composed operation that reads a certain amount of data at the specified offset before returning. 
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.read_at.overload1 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.read_at.overload2 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read_at.overload3 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read_at.overload4 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload4 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_at.overload5 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_at.overload6 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload6 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read_at.overload7 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.read_at.overload8 read_at]``(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_at.overload8 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/read_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 read_at (1 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read_at(d, 42, asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read_at(
-     d, 42, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 read_at (2 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read_at(d, 42,
-     asio::buffer(data, size), ec); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read_at(
-     d, 42, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 read_at (3 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::read_at(d, 42, asio::buffer(data, size),
-     asio::transfer_at_least(32)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 read_at (4 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The supplied buffers are full. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 read_at (5 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read_at(
-     d, 42, b,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 read_at (6 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::read_at(
-     d, 42, b,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 read_at (7 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 read_at (8 of 8 overloads)]
-
-
-Attempt to read a certain amount of data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessReadDevice SyncRandomAccessReadDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t read_at(
-      SyncRandomAccessReadDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's read\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.]]
-
-[[offset][The offset at which the data will be read.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object into which the data will be read.]]
-
-[[completion_condition][The function object to be called to determine whether the read operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest read_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read\_some\_at function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_until read_until]
-
-[indexterm1 asio.indexterm.read_until..read_until]
-
-The `read_until` function is a composed operation that reads data into a dynamic buffer sequence, or into a streambuf, until it contains a delimiter, matches a regular expression, or a function object indicates a match. 
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read_until.overload1 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read_until.overload2 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read_until.overload3 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.read_until.overload4 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload4 more...]]``
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload5 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload6 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload6 more...]]``
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload7 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload8 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload8 more...]]``
-
-Read data into a streambuf until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_until.overload9 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_until.overload10 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload10 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_until.overload11 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload11 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.read_until.overload12 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload12 more...]]``
-
-Read data into a streambuf until some part of the data it contains matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload13 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload13 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload14 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload14 more...]]``
-
-Read data into a streambuf until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload15 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload15 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload16 read_until]``(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload16 more...]]``
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read_until.overload17 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload17 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read_until.overload18 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload18 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read_until.overload19 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload19 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.read_until.overload20 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload20 more...]]``
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload21 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload21 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits>
-  std::size_t ``[link asio.reference.read_until.overload22 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload22 more...]]``
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload23 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload23 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition>
-  std::size_t ``[link asio.reference.read_until.overload24 read_until]``(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.read_until.overload24 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/read_until.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 read_until (1 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a newline is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), '\n');
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 read_until (2 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      char delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 read_until (3 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), "\r\n");
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 read_until (4 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      string_view delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 read_until (5 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), boost::regex("\r\n"));
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 read_until (6 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 read_until (7 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<typename DynamicBuffer_v1::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic\_buffer's get area that have been fully consumed by the match function.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To read data into a dynamic buffer sequence until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::const_buffers_1> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  std::string data;
-  asio::read_until(s, data, match_whitespace);
-
-
-
-
-To read data into a `std::string` until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  std::string data;
-  asio::read_until(s, data, match_char('a'));
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 read_until (8 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v1 && buffers,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<DynamicBuffer_v1::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area that have been fully consumed by the match function. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 read_until (9 of 24 overloads)]
-
-
-Read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the delimiter.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a streambuf until a newline is encountered: 
-
-  asio::streambuf b;
-  asio::read_until(s, b, '\n');
-  std::istream is(&b);
-  std::string line;
-  std::getline(is, line); 
-
-
-After the `read_until` operation completes successfully, the buffer `b` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 read_until (10 of 24 overloads)]
-
-
-Read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      char delim,
-      asio::error_code & ec);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 read_until (11 of 24 overloads)]
-
-
-Read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the delimiter.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a streambuf until a newline is encountered: 
-
-  asio::streambuf b;
-  asio::read_until(s, b, "\r\n");
-  std::istream is(&b);
-  std::string line;
-  std::getline(is, line); 
-
-
-After the `read_until` operation completes successfully, the buffer `b` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 read_until (12 of 24 overloads)]
-
-
-Read data into a streambuf until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      string_view delim,
-      asio::error_code & ec);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the streambuf contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 read_until (13 of 24 overloads)]
-
-
-Read data into a streambuf until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the streambuf's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a streambuf until a CR-LF sequence is encountered: 
-
-  asio::streambuf b;
-  asio::read_until(s, b, boost::regex("\r\n"));
-  std::istream is(&b);
-  std::string line;
-  std::getline(is, line); 
-
-
-After the `read_until` operation completes successfully, the buffer `b` contains the data which matched the regular expression: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `std::getline` then extracts the data up to and including the newline (which is discarded), so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r' } 
-
-
-The remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload14 read_until (14 of 24 overloads)]
-
-
-Read data into a streambuf until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec);
-
-
-This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the streambuf's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload15 read_until (15 of 24 overloads)]
-
-
-Read data into a streambuf until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-
-
-This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area that have been fully consumed by the match function.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To read data into a streambuf until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::streambuf::const_buffers_type> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_whitespace);
-
-
-
-
-To read data into a streambuf until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_char('a'));
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload16 read_until (16 of 24 overloads)]
-
-
-Read data into a streambuf until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename Allocator,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      asio::basic_streambuf< Allocator > & b,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0);
-
-
-This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[b][A streambuf object into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the streambuf's get area that have been fully consumed by the match function. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload17 read_until (17 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a newline is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), '\n');
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload18 read_until (18 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      char delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter character.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload19 read_until (19 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), "\r\n");
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload20 read_until (20 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until it contains a specified delimiter. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      string_view delim,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains the specified delimiter. The call will block until one of the following conditions is true:
-
-
-* The get area of the dynamic buffer sequence contains the specified delimiter.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains the delimiter, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][The dynamic buffer sequence into which the data will be read.]]
-
-[[delim][The delimiter string.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the delimiter. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond the delimiter. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload21 read_until (21 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Example]
-  
-To read data into a `std::string` until a CR-LF sequence is encountered: 
-
-  std::string data;
-  std::size_t n = asio::read_until(s,
-      asio::dynamic_buffer(data), boost::regex("\r\n"));
-  std::string line = data.substr(0, n);
-  data.erase(0, n); 
-
-
-After the `read_until` operation completes successfully, the string `data` contains the delimiter: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } 
-
-
-The call to `substr` then extracts the data up to and including the delimiter, so that the string `line` contains: 
-
-  { 'a', 'b', ..., 'c', '\r', '\n' } 
-
-
-After the call to `erase`, the remaining data is left in the buffer `b` as follows: 
-
-  { 'd', 'e', ... } 
-
-
-This data may be the start of a new line, to be extracted by a subsequent `read_until` operation. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload22 read_until (22 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until some part of the data it contains matches a regular expression. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename Traits>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      const boost::basic_regex< char, Traits > & expr,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until the dynamic buffer sequence's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
-
-
-* A substring of the dynamic buffer sequence's get area matches the regular expression.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the dynamic buffer sequence's get area already contains data that matches the regular expression, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[expr][The regular expression.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload23 read_until (23 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<typename DynamicBuffer_v2::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic\_buffer's get area that have been fully consumed by the match function.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects.
-
-
-[heading Examples]
-  
-To read data into a dynamic buffer sequence until whitespace is encountered: 
-
-  typedef asio::buffers_iterator<
-      asio::const_buffers_1> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  std::string data;
-  asio::read_until(s, data, match_whitespace);
-
-
-
-
-To read data into a `std::string` until a matching character is found: 
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  std::string data;
-  asio::read_until(s, data, match_char('a'));
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload24 read_until (24 of 24 overloads)]
-
-
-Read data into a dynamic buffer sequence until a function object indicates a match. 
-
-
-  template<
-      typename ``[link asio.reference.SyncReadStream SyncReadStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename MatchCondition>
-  std::size_t read_until(
-      SyncReadStream & s,
-      DynamicBuffer_v2 buffers,
-      MatchCondition match_condition,
-      asio::error_code & ec,
-      constraint_t< is_match_condition< MatchCondition >::value >  = 0,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to read data into the specified dynamic buffer sequence until a user-defined match condition function object, when applied to the data contained in the dynamic buffer sequence, indicates a successful match. The call will block until one of the following conditions is true:
-
-
-* The match condition function object returns a std::pair where the second element evaluates to true.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's read\_some function. If the match condition function object already indicates a match, the function returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream from which the data is to be read. The type must support the SyncReadStream concept.]]
-
-[[buffers][A dynamic buffer sequence into which the data will be read.]]
-
-[[match_condition][The function object to be called to determine whether a match exists. The signature of the function object must be: 
-``
-  pair<iterator, bool> match_condition(iterator begin, iterator end);
-``
-where `iterator` represents the type: 
-``
-  buffers_iterator<DynamicBuffer_v2::const_buffers_type>
-``
-The iterator parameters `begin` and `end` define the range of bytes to be scanned to determine whether there is a match. The `first` member of the return value is an iterator marking one-past-the-end of the bytes that have been consumed by the match function. This iterator is used to calculate the `begin` parameter for any subsequent invocation of the match condition. The `second` member of the return value is true if a match has been found, false otherwise.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes in the dynamic buffer sequence's get area that have been fully consumed by the match function. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-After a successful read\_until operation, the dynamic buffer sequence may contain additional data beyond that which matched the function object. An application will typically leave that data in the dynamic buffer sequence for a subsequent read\_until operation to examine.
-
-
-[heading Remarks]
-      
-The default implementation of the `is_match_condition` type trait evaluates to true for function pointers and function objects with a `result_type` typedef. It must be specialised for other user-defined function objects. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:readable_pipe readable_pipe]
-
-[indexterm1 asio.indexterm.readable_pipe..readable_pipe]
-
-Typedef for the typical usage of a readable pipe. 
-
-
-  typedef basic_readable_pipe readable_pipe;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_readable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_readable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_readable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.basic_readable_pipe [*basic_readable_pipe]] [constructor]]
-    [Construct a basic_readable_pipe without opening it. 
-     [hr]
-     Construct a basic_readable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_readable_pipe from another. 
-     [hr]
-     Move-construct a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_readable_pipe from another. 
-     [hr]
-     Move-assign a basic_readable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.read_some [*read_some]]]
-    [Read some data from the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_readable_pipe._basic_readable_pipe [*~basic_readable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_readable_pipe `basic_readable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/readable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:recycling_allocator recycling_allocator]
-
-[indexterm1 asio.indexterm.recycling_allocator..recycling_allocator]
-
-
-An allocator that caches memory blocks in thread-local storage for reuse. 
-
-
-  template<
-      typename T>
-  class recycling_allocator
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator__rebind [*rebind]]]
-    [Rebind the allocator to another value_type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.recycling_allocator.value_type [*value_type]]]
-    [The type of object allocated by the recycling allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.recycling_allocator.allocate [*allocate]]]
-    [Allocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.deallocate [*deallocate]]]
-    [Deallocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. Always returns false. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. Always returns true. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.recycling_allocator [*recycling_allocator]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Converting constructor. ]
-  ]
-  
-]
-
-The @recycling\_allocator uses a simple strategy where a limited number of small memory blocks are cached in thread-local storage, if the current thread is running an `io_context` or is part of a `thread_pool`. 
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocate recycling_allocator::allocate]
-
-[indexterm2 asio.indexterm.recycling_allocator.allocate..allocate..recycling_allocator] 
-Allocate memory for the specified number of values. 
-
-
-  T * allocate(
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:deallocate recycling_allocator::deallocate]
-
-[indexterm2 asio.indexterm.recycling_allocator.deallocate..deallocate..recycling_allocator] 
-Deallocate memory for the specified number of values. 
-
-
-  void deallocate(
-      T * p,
-      std::size_t n);
-
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ recycling_allocator::operator!=]
-
-[indexterm2 asio.indexterm.recycling_allocator.operator_not__eq_..operator!=..recycling_allocator] 
-Inequality operator. Always returns false. 
-
-
-  constexpr bool operator!=(
-      const recycling_allocator & ) const;
-
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ recycling_allocator::operator==]
-
-[indexterm2 asio.indexterm.recycling_allocator.operator_eq__eq_..operator==..recycling_allocator] 
-Equality operator. Always returns true. 
-
-
-  constexpr bool operator==(
-      const recycling_allocator & ) const;
-
-
-
-[endsect]
-
-
-[section:recycling_allocator recycling_allocator::recycling_allocator]
-
-[indexterm2 asio.indexterm.recycling_allocator.recycling_allocator..recycling_allocator..recycling_allocator] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.recycling_allocator.recycling_allocator.overload1 recycling_allocator]``();
-  ``  [''''&raquo;''' [link asio.reference.recycling_allocator.recycling_allocator.overload1 more...]]``
-
-
-Converting constructor. 
-
-
-  template<
-      typename U>
-  constexpr ``[link asio.reference.recycling_allocator.recycling_allocator.overload2 recycling_allocator]``(
-      const recycling_allocator< U > & );
-  ``  [''''&raquo;''' [link asio.reference.recycling_allocator.recycling_allocator.overload2 more...]]``
-
-
-[section:overload1 recycling_allocator::recycling_allocator (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr recycling_allocator();
-
-
-
-[endsect]
-
-
-
-[section:overload2 recycling_allocator::recycling_allocator (2 of 2 overloads)]
-
-
-Converting constructor. 
-
-
-  template<
-      typename U>
-  constexpr recycling_allocator(
-      const recycling_allocator< U > & );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:value_type recycling_allocator::value_type]
-
-[indexterm2 asio.indexterm.recycling_allocator.value_type..value_type..recycling_allocator] 
-The type of object allocated by the recycling allocator. 
-
-
-  typedef T value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:recycling_allocator__rebind recycling_allocator::rebind]
-
-[indexterm1 asio.indexterm.recycling_allocator__rebind..recycling_allocator::rebind]
-
-
-Rebind the allocator to another value\_type. 
-
-
-  template<
-      typename U>
-  struct rebind
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator__rebind.other [*other]]]
-    [The rebound allocator type. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other recycling_allocator::rebind::other]
-
-[indexterm2 asio.indexterm.recycling_allocator__rebind.other..other..recycling_allocator::rebind] 
-The rebound `allocator` type. 
-
-
-  typedef recycling_allocator< U > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator__rebind [*rebind]]]
-    [Rebind the allocator to another value_type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.recycling_allocator.value_type [*value_type]]]
-    [The type of object allocated by the recycling allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.recycling_allocator.allocate [*allocate]]]
-    [Allocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.deallocate [*deallocate]]]
-    [Deallocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. Always returns false. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. Always returns true. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.recycling_allocator [*recycling_allocator]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Converting constructor. ]
-  ]
-  
-]
-
-The @recycling\_allocator uses a simple strategy where a limited number of small memory blocks are cached in thread-local storage, if the current thread is running an `io_context` or is part of a `thread_pool`. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:recycling_allocator_lt__void__gt_ recycling_allocator< void >]
-
-[indexterm1 asio.indexterm.recycling_allocator_lt__void__gt_..recycling_allocator< void >]
-
-
-A proto-allocator that caches memory blocks in thread-local storage for reuse. 
-
-
-  template<>
-  class recycling_allocator< void >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator_lt__void__gt___rebind [*recycling_allocator< void >::rebind]]]
-    [Rebind the allocator to another value_type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.recycling_allocator_lt__void__gt_.value_type [*value_type]]]
-    [No values are allocated by a proto-allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.recycling_allocator_lt__void__gt_.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. Always returns false. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator_lt__void__gt_.operator_eq__eq_ [*operator==]]]
-    [Equality operator. Always returns true. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator_lt__void__gt_.recycling_allocator [*recycling_allocator]]]
-    [Default constructor. 
-     [hr]
-     Converting constructor. ]
-  ]
-  
-]
-
-The @recycling\_allocator uses a simple strategy where a limited number of small memory blocks are cached in thread-local storage, if the current thread is running an `io_context` or is part of a `thread_pool`. 
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_not__eq_ recycling_allocator< void >::operator!=]
-
-[indexterm2 asio.indexterm.recycling_allocator_lt__void__gt_.operator_not__eq_..operator!=..recycling_allocator< void >] 
-Inequality operator. Always returns false. 
-
-
-  constexpr bool operator!=(
-      const recycling_allocator & ) const;
-
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ recycling_allocator< void >::operator==]
-
-[indexterm2 asio.indexterm.recycling_allocator_lt__void__gt_.operator_eq__eq_..operator==..recycling_allocator< void >] 
-Equality operator. Always returns true. 
-
-
-  constexpr bool operator==(
-      const recycling_allocator & ) const;
-
-
-
-[endsect]
-
-
-[section:recycling_allocator recycling_allocator< void >::recycling_allocator]
-
-[indexterm2 asio.indexterm.recycling_allocator_lt__void__gt_.recycling_allocator..recycling_allocator..recycling_allocator< void >] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.recycling_allocator_lt__void__gt_.recycling_allocator.overload1 recycling_allocator]``();
-  ``  [''''&raquo;''' [link asio.reference.recycling_allocator_lt__void__gt_.recycling_allocator.overload1 more...]]``
-
-
-Converting constructor. 
-
-
-  template<
-      typename U>
-  constexpr ``[link asio.reference.recycling_allocator_lt__void__gt_.recycling_allocator.overload2 recycling_allocator]``(
-      const recycling_allocator< U > & );
-  ``  [''''&raquo;''' [link asio.reference.recycling_allocator_lt__void__gt_.recycling_allocator.overload2 more...]]``
-
-
-[section:overload1 recycling_allocator< void >::recycling_allocator (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr recycling_allocator();
-
-
-
-[endsect]
-
-
-
-[section:overload2 recycling_allocator< void >::recycling_allocator (2 of 2 overloads)]
-
-
-Converting constructor. 
-
-
-  template<
-      typename U>
-  constexpr recycling_allocator(
-      const recycling_allocator< U > & );
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:value_type recycling_allocator< void >::value_type]
-
-[indexterm2 asio.indexterm.recycling_allocator_lt__void__gt_.value_type..value_type..recycling_allocator< void >] 
-No values are allocated by a proto-allocator. 
-
-
-  typedef void value_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:recycling_allocator_lt__void__gt___rebind recycling_allocator< void >::rebind]
-
-[indexterm1 asio.indexterm.recycling_allocator_lt__void__gt___rebind..recycling_allocator< void >::rebind]
-
-
-Rebind the allocator to another value\_type. 
-
-
-  template<>
-  struct recycling_allocator< void >::rebind
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator_lt__void__gt___rebind.other [*other]]]
-    [The rebound allocator type. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other recycling_allocator< void >::rebind::other]
-
-[indexterm2 asio.indexterm.recycling_allocator_lt__void__gt___rebind.other..other..recycling_allocator< void >::rebind] 
-The rebound `allocator` type. 
-
-
-  typedef recycling_allocator< U > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.recycling_allocator__rebind [*rebind]]]
-    [Rebind the allocator to another value_type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.recycling_allocator.value_type [*value_type]]]
-    [The type of object allocated by the recycling allocator. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.recycling_allocator.allocate [*allocate]]]
-    [Allocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.deallocate [*deallocate]]]
-    [Deallocate memory for the specified number of values. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_not__eq_ [*operator!=]]]
-    [Inequality operator. Always returns false. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.operator_eq__eq_ [*operator==]]]
-    [Equality operator. Always returns true. ]
-  ]
-  
-  [
-    [[link asio.reference.recycling_allocator.recycling_allocator [*recycling_allocator]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Converting constructor. ]
-  ]
-  
-]
-
-The @recycling\_allocator uses a simple strategy where a limited number of small memory blocks are cached in thread-local storage, if the current thread is running an `io_context` or is part of a `thread_pool`. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/recycling_allocator.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:redirect_error redirect_error]
-
-[indexterm1 asio.indexterm.redirect_error..redirect_error]
-
-Create a partial completion token adapter that captures error\_code values to a variable. 
-
-  partial_redirect_error ``[link asio.reference.redirect_error.overload1 redirect_error]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.redirect_error.overload1 more...]]``
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to capture error\_code values to a variable. 
-
-  template<
-      typename CompletionToken>
-  redirect_error_t< decay_t< CompletionToken > > ``[link asio.reference.redirect_error.overload2 redirect_error]``(
-      CompletionToken && completion_token,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.redirect_error.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/redirect_error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 redirect_error (1 of 2 overloads)]
-
-
-Create a partial completion token adapter that captures error\_code values to a variable. 
-
-
-  partial_redirect_error redirect_error(
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:overload2 redirect_error (2 of 2 overloads)]
-
-
-Adapt a [link asio.overview.model.completion_tokens completion token] to capture error\_code values to a variable. 
-
-
-  template<
-      typename CompletionToken>
-  redirect_error_t< decay_t< CompletionToken > > redirect_error(
-      CompletionToken && completion_token,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:redirect_error_t redirect_error_t]
-
-[indexterm1 asio.indexterm.redirect_error_t..redirect_error_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] adapter used to specify that an error produced by an asynchronous operation is captured to an error\_code variable. 
-
-
-  template<
-      typename CompletionToken>
-  class redirect_error_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.redirect_error_t.redirect_error_t [*redirect_error_t]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.redirect_error_t.ec_ [*ec_]]]
-    []
-  ]
-
-  [
-    [[link asio.reference.redirect_error_t.token_ [*token_]]]
-    []
-  ]
-
-]
-
-The [link asio.reference.redirect_error_t `redirect_error_t`] class is used to indicate that any error\_code produced by an asynchronous operation is captured to a specified variable. 
-
-[heading Requirements]
-
-['Header: ][^asio/redirect_error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:ec_ redirect_error_t::ec_]
-
-[indexterm2 asio.indexterm.redirect_error_t.ec_..ec_..redirect_error_t] 
-
-  asio::error_code & ec_;
-
-
-
-[endsect]
-
-
-
-[section:redirect_error_t redirect_error_t::redirect_error_t]
-
-[indexterm2 asio.indexterm.redirect_error_t.redirect_error_t..redirect_error_t..redirect_error_t] 
-Constructor. 
-
-
-  template<
-      typename T>
-  redirect_error_t(
-      T && completion_token,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:token_ redirect_error_t::token_]
-
-[indexterm2 asio.indexterm.redirect_error_t.token_..token_..redirect_error_t] 
-
-  CompletionToken token_;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:register_buffers register_buffers]
-
-[indexterm1 asio.indexterm.register_buffers..register_buffers]
-
-Register buffers with an execution context. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  buffer_registration< MutableBufferSequence > ``[link asio.reference.register_buffers.overload1 register_buffers]``(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.register_buffers.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename Allocator>
-  buffer_registration< MutableBufferSequence, Allocator > ``[link asio.reference.register_buffers.overload2 register_buffers]``(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      const Allocator & alloc,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.register_buffers.overload2 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  buffer_registration< MutableBufferSequence > ``[link asio.reference.register_buffers.overload3 register_buffers]``(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.register_buffers.overload3 more...]]``
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename Allocator>
-  buffer_registration< MutableBufferSequence, Allocator > ``[link asio.reference.register_buffers.overload4 register_buffers]``(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      const Allocator & alloc,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.register_buffers.overload4 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/buffer_registration.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 register_buffers (1 of 4 overloads)]
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  buffer_registration< MutableBufferSequence > register_buffers(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload2 register_buffers (2 of 4 overloads)]
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename Allocator>
-  buffer_registration< MutableBufferSequence, Allocator > register_buffers(
-      const Executor & ex,
-      const MutableBufferSequence & buffer_sequence,
-      const Allocator & alloc,
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 register_buffers (3 of 4 overloads)]
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  buffer_registration< MutableBufferSequence > register_buffers(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload4 register_buffers (4 of 4 overloads)]
-
-
-Register buffers with an execution context. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename Allocator>
-  buffer_registration< MutableBufferSequence, Allocator > register_buffers(
-      ExecutionContext & ctx,
-      const MutableBufferSequence & buffer_sequence,
-      const Allocator & alloc,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:registered_buffer_id registered_buffer_id]
-
-[indexterm1 asio.indexterm.registered_buffer_id..registered_buffer_id]
-
-
-Type used to identify a registered buffer. 
-
-
-  class registered_buffer_id
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.registered_buffer_id.native_handle_type [*native_handle_type]]]
-    [The native buffer identifier type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.registered_buffer_id.native_handle [*native_handle]]]
-    [Get the native buffer identifier type. ]
-  ]
-  
-  [
-    [[link asio.reference.registered_buffer_id.registered_buffer_id [*registered_buffer_id]] [constructor]]
-    [Default constructor creates an invalid registered buffer identifier. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.registered_buffer_id.operator_not__eq_ [*operator!=]]]
-    [Compare two IDs for equality. ]
-  ]
-  
-  [
-    [[link asio.reference.registered_buffer_id.operator_eq__eq_ [*operator==]]]
-    [Compare two IDs for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:native_handle registered_buffer_id::native_handle]
-
-[indexterm2 asio.indexterm.registered_buffer_id.native_handle..native_handle..registered_buffer_id] 
-Get the native buffer identifier type. 
-
-
-  native_handle_type native_handle() const;
-
-
-
-[endsect]
-
-
-
-[section:native_handle_type registered_buffer_id::native_handle_type]
-
-[indexterm2 asio.indexterm.registered_buffer_id.native_handle_type..native_handle_type..registered_buffer_id] 
-The native buffer identifier type. 
-
-
-  typedef int native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ registered_buffer_id::operator!=]
-
-[indexterm2 asio.indexterm.registered_buffer_id.operator_not__eq_..operator!=..registered_buffer_id] 
-Compare two IDs for equality. 
-
-
-  bool operator!=(
-      const registered_buffer_id & lhs,
-      const registered_buffer_id & rhs);
-
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq__eq_ registered_buffer_id::operator==]
-
-[indexterm2 asio.indexterm.registered_buffer_id.operator_eq__eq_..operator==..registered_buffer_id] 
-Compare two IDs for equality. 
-
-
-  bool operator==(
-      const registered_buffer_id & lhs,
-      const registered_buffer_id & rhs);
-
-
-[heading Requirements]
-
-['Header: ][^asio/registered_buffer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:registered_buffer_id registered_buffer_id::registered_buffer_id]
-
-[indexterm2 asio.indexterm.registered_buffer_id.registered_buffer_id..registered_buffer_id..registered_buffer_id] 
-Default constructor creates an invalid registered buffer identifier. 
-
-
-  registered_buffer_id();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:require require]
-
-[indexterm1 asio.indexterm.require..require]
-
-A customisation point that applies a concept-preserving property to an object. 
-
-
-  constexpr unspecified require = unspecified;
-
-
-The name `require` denotes a customisation point object. The expression `asio::require(E, P0, Pn...)` for some subexpressions `E` and `P0`, and where `Pn...` represents `N` subexpressions (where `N` is 0 or more, and with types `T = decay_t<decltype(E)>` and `Prop0 = decay_t<decltype(P0)>`) is expression-equivalent to:
-
-
-* If `is_applicable_property_v<T, Prop0> && Prop0::is_requirable` is not a well-formed constant expression with value `true`, `asio::require(E, P0, Pn...)` is ill-formed.
-
-
-* Otherwise, `E` if `N == 0` and the expression `Prop0::template static_query_v<T> == Prop0::value()` is a well-formed constant expression with value `true`.
-
-
-* Otherwise, `(E).require(P0)` if `N == 0` and the expression `(E).require(P0)` is a valid expression.
-
-
-* Otherwise, `require(E, P0)` if `N == 0` and the expression `require(E, P0)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require` customization point object.
-
-
-* Otherwise, `asio::require(asio::require(E, P0), Pn...)` if `N > 0` and the expression `asio::require(asio::require(E, P0), Pn...)` is a valid expression.
-
-
-* Otherwise, `asio::require(E, P0, Pn...)` is ill-formed. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/require.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:require_concept require_concept]
-
-[indexterm1 asio.indexterm.require_concept..require_concept]
-
-A customisation point that applies a concept-enforcing property to an object. 
-
-
-  constexpr unspecified require_concept = unspecified;
-
-
-The name `require_concept` denotes a customization point object. The expression `asio::require_concept(E, P)` for some subexpressions `E` and `P` (with types `T = decay_t<decltype(E)>` and `Prop = decay_t<decltype(P)>`) is expression-equivalent to:
-
-
-* If `is_applicable_property_v<T, Prop> && Prop::is_requirable_concept` is not a well-formed constant expression with value `true`, `asio::require_concept(E, P)` is ill-formed.
-
-
-* Otherwise, `E` if the expression `Prop::template static_query_v<T> == Prop::value()` is a well-formed constant expression with value `true`.
-
-
-* Otherwise, `(E).require_concept(P)` if the expression `(E).require_concept(P)` is well-formed.
-
-
-* Otherwise, `require_concept(E, P)` if the expression `require_concept(E, P)` is a valid expression with overload resolution performed in a context that does not include the declaration of the `require_concept` customization point object.
-
-
-* Otherwise, `asio::require_concept(E, P)` is ill-formed. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/require_concept.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:require_concept_result require_concept_result]
-
-[indexterm1 asio.indexterm.require_concept_result..require_concept_result]
-
-
-A type trait that determines the result type of a `require_concept` expression. 
-
-
-  template<
-      typename T,
-      typename Property>
-  struct require_concept_result
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.require_concept_result.type [*type]]]
-    [The result of the require_concept expression. ]
-  
-  ]
-
-]
-
-Class template `require_concept_result` is a trait that determines the result type of the expression `asio::require_concept(std::declval<T>(), std::declval<Property>())`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require_concept.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type require_concept_result::type]
-
-[indexterm2 asio.indexterm.require_concept_result.type..type..require_concept_result] 
-The result of the `require_concept` expression. 
-
-
-  typedef automatically_determined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/require_concept.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:require_result require_result]
-
-[indexterm1 asio.indexterm.require_result..require_result]
-
-
-A type trait that determines the result type of a `require` expression. 
-
-
-  template<
-      typename T,
-      typename... Properties>
-  struct require_result
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.require_result.type [*type]]]
-    [The result of the require expression. ]
-  
-  ]
-
-]
-
-Class template `require_result` is a trait that determines the result type of the expression `asio::require(std::declval<T>(), std::declval<Properties>()...)`. 
-
-[heading Requirements]
-
-['Header: ][^asio/require.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:type require_result::type]
-
-[indexterm2 asio.indexterm.require_result.type..type..require_result] 
-The result of the `require` expression. 
-
-
-  typedef automatically_determined type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/require.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:resolver_errc__try_again resolver_errc::try_again]
-
-[indexterm1 asio.indexterm.resolver_errc__try_again..resolver_errc::try_again]
-
-
-  const error::netdb_errors try_again = error::host_not_found_try_again;
-
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:serial_port serial_port]
-
-[indexterm1 asio.indexterm.serial_port..serial_port]
-
-Typedef for the typical usage of a serial port. 
-
-
-  typedef basic_serial_port serial_port;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_serial_port__rebind_executor [*rebind_executor]]]
-    [Rebinds the serial port type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_basic_serial_port is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_serial_port.native_handle_type [*native_handle_type]]]
-    [The native representation of a serial port. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_serial_port.assign [*assign]]]
-    [Assign an existing native serial port to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.basic_serial_port [*basic_serial_port]] [constructor]]
-    [Construct a basic_serial_port without opening it. 
-     [hr]
-     Construct and open a basic_serial_port. 
-     [hr]
-     Construct a basic_serial_port on an existing native serial port. 
-     [hr]
-     Move-construct a basic_serial_port from another. 
-     [hr]
-     Move-construct a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.close [*close]]]
-    [Close the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.get_option [*get_option]]]
-    [Get an option from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.is_open [*is_open]]]
-    [Determine whether the serial port is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.native_handle [*native_handle]]]
-    [Get the native serial port representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.open [*open]]]
-    [Open the serial port using the specified device name. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.operator_eq_ [*operator=]]]
-    [Move-assign a basic_serial_port from another. 
-     [hr]
-     Move-assign a basic_serial_port from a serial port of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.read_some [*read_some]]]
-    [Read some data from the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.send_break [*send_break]]]
-    [Send a break sequence to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.set_option [*set_option]]]
-    [Set an option on the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port.write_some [*write_some]]]
-    [Write some data to the serial port. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_serial_port._basic_serial_port [*~basic_serial_port]] [destructor]]
-    [Destroys the serial port. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_serial_port `basic_serial_port`] class provides a wrapper over serial port functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:serial_port_base serial_port_base]
-
-[indexterm1 asio.indexterm.serial_port_base..serial_port_base]
-
-
-The [link asio.reference.serial_port_base `serial_port_base`] class is used as a base for the [link asio.reference.basic_serial_port `basic_serial_port`] class template so that we have a common place to define the serial port options. 
-
-
-  class serial_port_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.serial_port_base__baud_rate [*baud_rate]]]
-    [Serial port option to permit changing the baud rate. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.serial_port_base__character_size [*character_size]]]
-    [Serial port option to permit changing the character size. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.serial_port_base__flow_control [*flow_control]]]
-    [Serial port option to permit changing the flow control. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.serial_port_base__parity [*parity]]]
-    [Serial port option to permit changing the parity. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.serial_port_base__stop_bits [*stop_bits]]]
-    [Serial port option to permit changing the number of stop bits. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base._serial_port_base [*~serial_port_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:_serial_port_base serial_port_base::~serial_port_base]
-
-[indexterm2 asio.indexterm.serial_port_base._serial_port_base..~serial_port_base..serial_port_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~serial_port_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:serial_port_base__baud_rate serial_port_base::baud_rate]
-
-[indexterm1 asio.indexterm.serial_port_base__baud_rate..serial_port_base::baud_rate]
-
-
-Serial port option to permit changing the baud rate. 
-
-
-  class baud_rate
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base__baud_rate.baud_rate [*baud_rate]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__baud_rate.load [*load]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__baud_rate.store [*store]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__baud_rate.value [*value]]]
-    []
-  ]
-  
-]
-
-Implements changing the baud rate for a given serial port. 
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:baud_rate serial_port_base::baud_rate::baud_rate]
-
-[indexterm2 asio.indexterm.serial_port_base__baud_rate.baud_rate..baud_rate..serial_port_base::baud_rate] 
-
-  baud_rate(
-      unsigned int rate = 0);
-
-
-
-[endsect]
-
-
-
-[section:load serial_port_base::baud_rate::load]
-
-[indexterm2 asio.indexterm.serial_port_base__baud_rate.load..load..serial_port_base::baud_rate] 
-
-  void load(
-      const ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:store serial_port_base::baud_rate::store]
-
-[indexterm2 asio.indexterm.serial_port_base__baud_rate.store..store..serial_port_base::baud_rate] 
-
-  void store(
-      ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-
-[section:value serial_port_base::baud_rate::value]
-
-[indexterm2 asio.indexterm.serial_port_base__baud_rate.value..value..serial_port_base::baud_rate] 
-
-  unsigned int value() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:serial_port_base__character_size serial_port_base::character_size]
-
-[indexterm1 asio.indexterm.serial_port_base__character_size..serial_port_base::character_size]
-
-
-Serial port option to permit changing the character size. 
-
-
-  class character_size
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base__character_size.character_size [*character_size]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__character_size.load [*load]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__character_size.store [*store]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__character_size.value [*value]]]
-    []
-  ]
-  
-]
-
-Implements changing the character size for a given serial port. 
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:character_size serial_port_base::character_size::character_size]
-
-[indexterm2 asio.indexterm.serial_port_base__character_size.character_size..character_size..serial_port_base::character_size] 
-
-  character_size(
-      unsigned int t = 8);
-
-
-
-[endsect]
-
-
-
-[section:load serial_port_base::character_size::load]
-
-[indexterm2 asio.indexterm.serial_port_base__character_size.load..load..serial_port_base::character_size] 
-
-  void load(
-      const ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:store serial_port_base::character_size::store]
-
-[indexterm2 asio.indexterm.serial_port_base__character_size.store..store..serial_port_base::character_size] 
-
-  void store(
-      ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-
-[section:value serial_port_base::character_size::value]
-
-[indexterm2 asio.indexterm.serial_port_base__character_size.value..value..serial_port_base::character_size] 
-
-  unsigned int value() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:serial_port_base__flow_control serial_port_base::flow_control]
-
-[indexterm1 asio.indexterm.serial_port_base__flow_control..serial_port_base::flow_control]
-
-
-Serial port option to permit changing the flow control. 
-
-
-  class flow_control
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.serial_port_base__flow_control.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base__flow_control.flow_control [*flow_control]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__flow_control.load [*load]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__flow_control.store [*store]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__flow_control.value [*value]]]
-    []
-  ]
-  
-]
-
-Implements changing the flow control for a given serial port. 
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:flow_control serial_port_base::flow_control::flow_control]
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.flow_control..flow_control..serial_port_base::flow_control] 
-
-  flow_control(
-      type t = none);
-
-
-
-[endsect]
-
-
-
-[section:load serial_port_base::flow_control::load]
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.load..load..serial_port_base::flow_control] 
-
-  void load(
-      const ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:store serial_port_base::flow_control::store]
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.store..store..serial_port_base::flow_control] 
-
-  void store(
-      ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-
-[section:type serial_port_base::flow_control::type]
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.type..type..serial_port_base::flow_control] 
-  enum type
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.type.none..none..serial_port_base::flow_control]
-[indexterm2 asio.indexterm.serial_port_base__flow_control.type.software..software..serial_port_base::flow_control]
-[indexterm2 asio.indexterm.serial_port_base__flow_control.type.hardware..hardware..serial_port_base::flow_control]
-
-[heading Values]
-[variablelist
-
-  [
-    [none]
-    []
-  ]
-
-  [
-    [software]
-    []
-  ]
-
-  [
-    [hardware]
-    []
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:value serial_port_base::flow_control::value]
-
-[indexterm2 asio.indexterm.serial_port_base__flow_control.value..value..serial_port_base::flow_control] 
-
-  type value() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:serial_port_base__parity serial_port_base::parity]
-
-[indexterm1 asio.indexterm.serial_port_base__parity..serial_port_base::parity]
-
-
-Serial port option to permit changing the parity. 
-
-
-  class parity
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.serial_port_base__parity.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base__parity.load [*load]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__parity.parity [*parity]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__parity.store [*store]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__parity.value [*value]]]
-    []
-  ]
-  
-]
-
-Implements changing the parity for a given serial port. 
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:load serial_port_base::parity::load]
-
-[indexterm2 asio.indexterm.serial_port_base__parity.load..load..serial_port_base::parity] 
-
-  void load(
-      const ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:parity serial_port_base::parity::parity]
-
-[indexterm2 asio.indexterm.serial_port_base__parity.parity..parity..serial_port_base::parity] 
-
-  parity(
-      type t = none);
-
-
-
-[endsect]
-
-
-
-[section:store serial_port_base::parity::store]
-
-[indexterm2 asio.indexterm.serial_port_base__parity.store..store..serial_port_base::parity] 
-
-  void store(
-      ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-
-[section:type serial_port_base::parity::type]
-
-[indexterm2 asio.indexterm.serial_port_base__parity.type..type..serial_port_base::parity] 
-  enum type
-
-[indexterm2 asio.indexterm.serial_port_base__parity.type.none..none..serial_port_base::parity]
-[indexterm2 asio.indexterm.serial_port_base__parity.type.odd..odd..serial_port_base::parity]
-[indexterm2 asio.indexterm.serial_port_base__parity.type.even..even..serial_port_base::parity]
-
-[heading Values]
-[variablelist
-
-  [
-    [none]
-    []
-  ]
-
-  [
-    [odd]
-    []
-  ]
-
-  [
-    [even]
-    []
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:value serial_port_base::parity::value]
-
-[indexterm2 asio.indexterm.serial_port_base__parity.value..value..serial_port_base::parity] 
-
-  type value() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:serial_port_base__stop_bits serial_port_base::stop_bits]
-
-[indexterm1 asio.indexterm.serial_port_base__stop_bits..serial_port_base::stop_bits]
-
-
-Serial port option to permit changing the number of stop bits. 
-
-
-  class stop_bits
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.serial_port_base__stop_bits.type [*type]]]
-    []
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.serial_port_base__stop_bits.load [*load]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__stop_bits.stop_bits [*stop_bits]] [constructor]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__stop_bits.store [*store]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.serial_port_base__stop_bits.value [*value]]]
-    []
-  ]
-  
-]
-
-Implements changing the number of stop bits for a given serial port. 
-
-[heading Requirements]
-
-['Header: ][^asio/serial_port_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:load serial_port_base::stop_bits::load]
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.load..load..serial_port_base::stop_bits] 
-
-  void load(
-      const ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-
-[section:stop_bits serial_port_base::stop_bits::stop_bits]
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.stop_bits..stop_bits..serial_port_base::stop_bits] 
-
-  stop_bits(
-      type t = one);
-
-
-
-[endsect]
-
-
-
-[section:store serial_port_base::stop_bits::store]
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.store..store..serial_port_base::stop_bits] 
-
-  void store(
-      ASIO_OPTION_STORAGE & storage,
-      asio::error_code & ec) const;
-
-
-
-[endsect]
-
-
-
-[section:type serial_port_base::stop_bits::type]
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.type..type..serial_port_base::stop_bits] 
-  enum type
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.type.one..one..serial_port_base::stop_bits]
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.type.onepointfive..onepointfive..serial_port_base::stop_bits]
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.type.two..two..serial_port_base::stop_bits]
-
-[heading Values]
-[variablelist
-
-  [
-    [one]
-    []
-  ]
-
-  [
-    [onepointfive]
-    []
-  ]
-
-  [
-    [two]
-    []
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:value serial_port_base::stop_bits::value]
-
-[indexterm2 asio.indexterm.serial_port_base__stop_bits.value..value..serial_port_base::stop_bits] 
-
-  type value() const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:service_already_exists service_already_exists]
-
-[indexterm1 asio.indexterm.service_already_exists..service_already_exists]
-
-
-Exception thrown when trying to add a duplicate service to an [link asio.reference.execution_context `execution_context`]. 
-
-
-  class service_already_exists :
-    public std::logic_error
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.service_already_exists.service_already_exists [*service_already_exists]] [constructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/execution_context.hpp]
-
-['Convenience header: ][^asio/execution.hpp]
-
-
-[section:service_already_exists service_already_exists::service_already_exists]
-
-[indexterm2 asio.indexterm.service_already_exists.service_already_exists..service_already_exists..service_already_exists] 
-
-  service_already_exists();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:signal_set signal_set]
-
-[indexterm1 asio.indexterm.signal_set..signal_set]
-
-Typedef for the typical usage of a signal set. 
-
-
-  typedef basic_signal_set signal_set;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_signal_set__rebind_executor [*rebind_executor]]]
-    [Rebinds the signal set type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags [*flags]]]
-    [Enumeration representing the different types of flags that may specified when adding a signal to a set. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_signal_set.flags_t [*flags_t]]]
-    [Portability typedef. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_signal_set.add [*add]]]
-    [Add a signal to a signal_set. 
-     [hr]
-     Add a signal to a signal_set with the specified flags. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.async_wait [*async_wait]]]
-    [Start an asynchronous operation to wait for a signal to be delivered. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.basic_signal_set [*basic_signal_set]] [constructor]]
-    [Construct a signal set without adding any signals. 
-     [hr]
-     Construct a signal set and add one signal. 
-     [hr]
-     Construct a signal set and add two signals. 
-     [hr]
-     Construct a signal set and add three signals. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.cancel [*cancel]]]
-    [Cancel all operations associated with the signal set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.clear [*clear]]]
-    [Remove all signals from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set.remove [*remove]]]
-    [Remove a signal from a signal_set. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_signal_set._basic_signal_set [*~basic_signal_set]] [destructor]]
-    [Destroys the signal set. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_signal_set `basic_signal_set`] class provides the ability to perform an asynchronous wait for one or more signals to occur.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Example]
-  
-Performing an asynchronous wait: 
-
-  void handler(
-      const asio::error_code& error,
-      int signal_number)
-  {
-    if (!error)
-    {
-      // A signal occurred.
-    }
-  }
-
-  ...
-
-  // Construct a signal set registered for process termination.
-  asio::signal_set signals(my_context, SIGINT, SIGTERM);
-
-  // Start an asynchronous wait for one of the signals to occur.
-  signals.async_wait(handler);
-
-
-
-
-
-[heading Queueing of signal notifications]
-  
-
-
-If a signal is registered with a signal\_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async\_wait operation on that signal\_set will dequeue the notification. If multiple notifications are queued, subsequent async\_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
-
-If a signal number is removed from a signal\_set (using the `remove` or `erase` member functions) then any queued notifications for that signal are discarded.
-
-
-[heading Multiple registration of signals]
-  
-
-
-The same signal number may be registered with different signal\_set objects. When the signal occurs, one handler is called for each signal\_set object.
-
-Note that multiple registration only works for signals that are registered using Asio. The application must not also register a signal handler using functions such as `signal()` or `sigaction()`.
-
-
-[heading Signal masking on POSIX platforms]
-  
-
-
-POSIX allows signals to be blocked using functions such as `sigprocmask()` and `pthread_sigmask()`. For signals to be delivered, programs must ensure that any signals registered using signal\_set objects are unblocked in at least one thread. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/signal_set.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:signal_set_base signal_set_base]
-
-[indexterm1 asio.indexterm.signal_set_base..signal_set_base]
-
-
-The [link asio.reference.signal_set_base `signal_set_base`] class is used as a base for the [link asio.reference.basic_signal_set `basic_signal_set`] class templates so that we have a common place to define the flags enum. 
-
-
-  class signal_set_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.signal_set_base.flags [*flags]]]
-    [Enumeration representing the different types of flags that may specified when adding a signal to a set. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.signal_set_base.flags_t [*flags_t]]]
-    [Portability typedef. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.signal_set_base._signal_set_base [*~signal_set_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/signal_set_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:flags signal_set_base::flags]
-
-[indexterm2 asio.indexterm.signal_set_base.flags..flags..signal_set_base] 
-Enumeration representing the different types of flags that may specified when adding a signal to a set. 
-
-  enum flags
-
-[indexterm2 asio.indexterm.signal_set_base.flags.none..none..signal_set_base]
-[indexterm2 asio.indexterm.signal_set_base.flags.restart..restart..signal_set_base]
-[indexterm2 asio.indexterm.signal_set_base.flags.no_child_stop..no_child_stop..signal_set_base]
-[indexterm2 asio.indexterm.signal_set_base.flags.no_child_wait..no_child_wait..signal_set_base]
-[indexterm2 asio.indexterm.signal_set_base.flags.dont_care..dont_care..signal_set_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [none]
-    [Bitmask representing no flags. ]
-  ]
-
-  [
-    [restart]
-    [Affects the behaviour of interruptible functions such that, if the function would have failed with error::interrupted when interrupted by the specified signal, the function shall instead be restarted and not fail with error::interrupted. ]
-  ]
-
-  [
-    [no_child_stop]
-    [Do not generate SIGCHLD when child processes stop or stopped child processes continue. ]
-  ]
-
-  [
-    [no_child_wait]
-    [Do not transform child processes into zombies when they terminate. ]
-  ]
-
-  [
-    [dont_care]
-    [Special value to indicate that the signal registration does not care which flags are set, and so will not conflict with any prior registrations of the same signal. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:flags_t signal_set_base::flags_t]
-
-[indexterm2 asio.indexterm.signal_set_base.flags_t..flags_t..signal_set_base] 
-Portability typedef. 
-
-
-  typedef flags flags_t;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/signal_set_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:_signal_set_base signal_set_base::~signal_set_base]
-
-[indexterm2 asio.indexterm.signal_set_base._signal_set_base..~signal_set_base..signal_set_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~signal_set_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:socket_base socket_base]
-
-[indexterm1 asio.indexterm.socket_base..socket_base]
-
-
-The [link asio.reference.socket_base `socket_base`] class is used as a base for the [link asio.reference.basic_stream_socket `basic_stream_socket`] and [link asio.reference.basic_datagram_socket `basic_datagram_socket`] class templates so that we have a common place to define the shutdown\_type and enum. 
-
-
-  class socket_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.socket_base.broadcast [*broadcast]]]
-    [Socket option to permit sending of broadcast messages. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.bytes_readable [*bytes_readable]]]
-    [IO control command to get the amount of data that can be read without blocking. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.debug [*debug]]]
-    [Socket option to enable socket-level debugging. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.do_not_route [*do_not_route]]]
-    [Socket option to prevent routing, use local interfaces only. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.enable_connection_aborted [*enable_connection_aborted]]]
-    [Socket option to report aborted connections on accept. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.keep_alive [*keep_alive]]]
-    [Socket option to send keep-alives. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.linger [*linger]]]
-    [Socket option to specify whether the socket lingers on close if unsent data is present. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.message_flags [*message_flags]]]
-    [Bitmask type for flags that can be passed to send and receive operations. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.out_of_band_inline [*out_of_band_inline]]]
-    [Socket option for putting received out-of-band data inline. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.receive_buffer_size [*receive_buffer_size]]]
-    [Socket option for the receive buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.receive_low_watermark [*receive_low_watermark]]]
-    [Socket option for the receive low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.reuse_address [*reuse_address]]]
-    [Socket option to allow the socket to be bound to an address that is already in use. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.send_buffer_size [*send_buffer_size]]]
-    [Socket option for the send buffer size of a socket. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.send_low_watermark [*send_low_watermark]]]
-    [Socket option for the send low watermark. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.shutdown_type [*shutdown_type]]]
-    [Different ways a socket may be shutdown. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.socket_base.wait_type [*wait_type]]]
-    [Wait types. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.socket_base._socket_base [*~socket_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.socket_base.max_connections [*max_connections]] [static]]
-    [(Deprecated: Use max_listen_connections.) The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.socket_base.max_listen_connections [*max_listen_connections]] [static]]
-    [The maximum length of the queue of pending incoming connections. ]
-  ]
-
-  [
-    [[link asio.reference.socket_base.message_do_not_route [*message_do_not_route]] [static]]
-    [Specify that the data should not be subject to routing. ]
-  ]
-
-  [
-    [[link asio.reference.socket_base.message_end_of_record [*message_end_of_record]] [static]]
-    [Specifies that the data marks the end of a record. ]
-  ]
-
-  [
-    [[link asio.reference.socket_base.message_out_of_band [*message_out_of_band]] [static]]
-    [Process out-of-band data. ]
-  ]
-
-  [
-    [[link asio.reference.socket_base.message_peek [*message_peek]] [static]]
-    [Peek at incoming data without removing it from the input queue. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:broadcast socket_base::broadcast]
-
-[indexterm2 asio.indexterm.socket_base.broadcast..broadcast..socket_base] 
-Socket option to permit sending of broadcast messages. 
-
-
-  typedef implementation_defined broadcast;
-
-
-
-Implements the SOL\_SOCKET/SO\_BROADCAST socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::broadcast option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:bytes_readable socket_base::bytes_readable]
-
-[indexterm2 asio.indexterm.socket_base.bytes_readable..bytes_readable..socket_base] 
-IO control command to get the amount of data that can be read without blocking. 
-
-
-  typedef implementation_defined bytes_readable;
-
-
-
-Implements the FIONREAD IO control command.
-
-
-[heading Example]
-  
-
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::bytes_readable command(true);
-  socket.io_control(command);
-  std::size_t bytes_readable = command.get();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:debug socket_base::debug]
-
-[indexterm2 asio.indexterm.socket_base.debug..debug..socket_base] 
-Socket option to enable socket-level debugging. 
-
-
-  typedef implementation_defined debug;
-
-
-
-Implements the SOL\_SOCKET/SO\_DEBUG socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::debug option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:do_not_route socket_base::do_not_route]
-
-[indexterm2 asio.indexterm.socket_base.do_not_route..do_not_route..socket_base] 
-Socket option to prevent routing, use local interfaces only. 
-
-
-  typedef implementation_defined do_not_route;
-
-
-
-Implements the SOL\_SOCKET/SO\_DONTROUTE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::udp::socket socket(my_context);
-  ...
-  asio::socket_base::do_not_route option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:enable_connection_aborted socket_base::enable_connection_aborted]
-
-[indexterm2 asio.indexterm.socket_base.enable_connection_aborted..enable_connection_aborted..socket_base] 
-Socket option to report aborted connections on accept. 
-
-
-  typedef implementation_defined enable_connection_aborted;
-
-
-
-Implements a custom socket option that determines whether or not an accept operation is permitted to fail with `asio::error::connection_aborted`. By default the option is false.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::enable_connection_aborted option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:keep_alive socket_base::keep_alive]
-
-[indexterm2 asio.indexterm.socket_base.keep_alive..keep_alive..socket_base] 
-Socket option to send keep-alives. 
-
-
-  typedef implementation_defined keep_alive;
-
-
-
-Implements the SOL\_SOCKET/SO\_KEEPALIVE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::keep_alive option;
-  socket.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:linger socket_base::linger]
-
-[indexterm2 asio.indexterm.socket_base.linger..linger..socket_base] 
-Socket option to specify whether the socket lingers on close if unsent data is present. 
-
-
-  typedef implementation_defined linger;
-
-
-
-Implements the SOL\_SOCKET/SO\_LINGER socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option(true, 30);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::linger option;
-  socket.get_option(option);
-  bool is_set = option.enabled();
-  unsigned short timeout = option.timeout();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:max_connections socket_base::max_connections]
-
-[indexterm2 asio.indexterm.socket_base.max_connections..max_connections..socket_base] 
-(Deprecated: Use max\_listen\_connections.) The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:max_listen_connections socket_base::max_listen_connections]
-
-[indexterm2 asio.indexterm.socket_base.max_listen_connections..max_listen_connections..socket_base] 
-The maximum length of the queue of pending incoming connections. 
-
-
-  static const int max_listen_connections = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_do_not_route socket_base::message_do_not_route]
-
-[indexterm2 asio.indexterm.socket_base.message_do_not_route..message_do_not_route..socket_base] 
-Specify that the data should not be subject to routing. 
-
-
-  static const int message_do_not_route = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_end_of_record socket_base::message_end_of_record]
-
-[indexterm2 asio.indexterm.socket_base.message_end_of_record..message_end_of_record..socket_base] 
-Specifies that the data marks the end of a record. 
-
-
-  static const int message_end_of_record = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_flags socket_base::message_flags]
-
-[indexterm2 asio.indexterm.socket_base.message_flags..message_flags..socket_base] 
-Bitmask type for flags that can be passed to send and receive operations. 
-
-
-  typedef int message_flags;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:message_out_of_band socket_base::message_out_of_band]
-
-[indexterm2 asio.indexterm.socket_base.message_out_of_band..message_out_of_band..socket_base] 
-Process out-of-band data. 
-
-
-  static const int message_out_of_band = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:message_peek socket_base::message_peek]
-
-[indexterm2 asio.indexterm.socket_base.message_peek..message_peek..socket_base] 
-Peek at incoming data without removing it from the input queue. 
-
-
-  static const int message_peek = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:out_of_band_inline socket_base::out_of_band_inline]
-
-[indexterm2 asio.indexterm.socket_base.out_of_band_inline..out_of_band_inline..socket_base] 
-Socket option for putting received out-of-band data inline. 
-
-
-  typedef implementation_defined out_of_band_inline;
-
-
-
-Implements the SOL\_SOCKET/SO\_OOBINLINE socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option(true);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::out_of_band_inline option;
-  socket.get_option(option);
-  bool value = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_buffer_size socket_base::receive_buffer_size]
-
-[indexterm2 asio.indexterm.socket_base.receive_buffer_size..receive_buffer_size..socket_base] 
-Socket option for the receive buffer size of a socket. 
-
-
-  typedef implementation_defined receive_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:receive_low_watermark socket_base::receive_low_watermark]
-
-[indexterm2 asio.indexterm.socket_base.receive_low_watermark..receive_low_watermark..socket_base] 
-Socket option for the receive low watermark. 
-
-
-  typedef implementation_defined receive_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_RCVLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::receive_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:reuse_address socket_base::reuse_address]
-
-[indexterm2 asio.indexterm.socket_base.reuse_address..reuse_address..socket_base] 
-Socket option to allow the socket to be bound to an address that is already in use. 
-
-
-  typedef implementation_defined reuse_address;
-
-
-
-Implements the SOL\_SOCKET/SO\_REUSEADDR socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option(true);
-  acceptor.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::acceptor acceptor(my_context);
-  ...
-  asio::socket_base::reuse_address option;
-  acceptor.get_option(option);
-  bool is_set = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_buffer_size socket_base::send_buffer_size]
-
-[indexterm2 asio.indexterm.socket_base.send_buffer_size..send_buffer_size..socket_base] 
-Socket option for the send buffer size of a socket. 
-
-
-  typedef implementation_defined send_buffer_size;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDBUF socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option(8192);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_buffer_size option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:send_low_watermark socket_base::send_low_watermark]
-
-[indexterm2 asio.indexterm.socket_base.send_low_watermark..send_low_watermark..socket_base] 
-Socket option for the send low watermark. 
-
-
-  typedef implementation_defined send_low_watermark;
-
-
-
-Implements the SOL\_SOCKET/SO\_SNDLOWAT socket option.
-
-
-[heading Examples]
-  
-Setting the option: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option(1024);
-  socket.set_option(option);
-
-
-
-
-
-Getting the current option value: 
-
-  asio::ip::tcp::socket socket(my_context);
-  ...
-  asio::socket_base::send_low_watermark option;
-  socket.get_option(option);
-  int size = option.value();
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/socket_base.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:shutdown_type socket_base::shutdown_type]
-
-[indexterm2 asio.indexterm.socket_base.shutdown_type..shutdown_type..socket_base] 
-Different ways a socket may be shutdown. 
-
-  enum shutdown_type
-
-[indexterm2 asio.indexterm.socket_base.shutdown_type.shutdown_receive..shutdown_receive..socket_base]
-[indexterm2 asio.indexterm.socket_base.shutdown_type.shutdown_send..shutdown_send..socket_base]
-[indexterm2 asio.indexterm.socket_base.shutdown_type.shutdown_both..shutdown_both..socket_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [shutdown_receive]
-    [Shutdown the receive side of the socket. ]
-  ]
-
-  [
-    [shutdown_send]
-    [Shutdown the send side of the socket. ]
-  ]
-
-  [
-    [shutdown_both]
-    [Shutdown both send and receive on the socket. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:wait_type socket_base::wait_type]
-
-[indexterm2 asio.indexterm.socket_base.wait_type..wait_type..socket_base] 
-Wait types. 
-
-  enum wait_type
-
-[indexterm2 asio.indexterm.socket_base.wait_type.wait_read..wait_read..socket_base]
-[indexterm2 asio.indexterm.socket_base.wait_type.wait_write..wait_write..socket_base]
-[indexterm2 asio.indexterm.socket_base.wait_type.wait_error..wait_error..socket_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [wait_read]
-    [Wait for a socket to become ready to read. ]
-  ]
-
-  [
-    [wait_write]
-    [Wait for a socket to become ready to write. ]
-  ]
-
-  [
-    [wait_error]
-    [Wait for a socket to have error conditions pending. ]
-  ]
-
-]
-
-
-For use with `basic_socket::wait()` and `basic_socket::async_wait()`. 
-
-
-[endsect]
-
-
-
-[section:_socket_base socket_base::~socket_base]
-
-[indexterm2 asio.indexterm.socket_base._socket_base..~socket_base..socket_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~socket_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:spawn spawn]
-
-[indexterm1 asio.indexterm.spawn..spawn]
-
-Start a new stackful coroutine. 
-
-
-Start a new stackful coroutine that executes on a given executor. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.spawn.overload1 spawn]``(
-      const Executor & ex,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload1 more...]]``
-
-Start a new stackful coroutine that executes on a given execution context. 
-
-  template<
-      typename ExecutionContext,
-      typename F,
-      typename CompletionToken = default_completion_token_t<            typename ExecutionContext::executor_type>>
-  auto ``[link asio.reference.spawn.overload2 spawn]``(
-      ExecutionContext & ctx,
-      F && function,
-      CompletionToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload2 more...]]``
-
-Start a new stackful coroutine, inheriting the executor of another. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.spawn.overload3 spawn]``(
-      const basic_yield_context< Executor > & ctx,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload3 more...]]``
-
-Start a new stackful coroutine that executes on a given executor. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.spawn.overload4 spawn]``(
-      const Executor & ex,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload4 more...]]``
-
-Start a new stackful coroutine that executes on a given execution context. 
-
-  template<
-      typename ExecutionContext,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<            typename ExecutionContext::executor_type>>
-  auto ``[link asio.reference.spawn.overload5 spawn]``(
-      ExecutionContext & ctx,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload5 more...]]``
-
-Start a new stackful coroutine, inheriting the executor of another. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto ``[link asio.reference.spawn.overload6 spawn]``(
-      const basic_yield_context< Executor > & ctx,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload6 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine, calling the specified handler when it completes. 
-
-  template<
-      typename Function>
-  void ``[link asio.reference.spawn.overload7 spawn]``(
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``,
-      typename Function>
-  void ``[link asio.reference.spawn.overload8 spawn]``(
-      Handler && handler,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< !is_executor< decay_t< Handler > >::value &&!execution::is_executor< decay_t< Handler > >::value &&!is_convertible< Handler &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload8 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine, inheriting the execution context of another. 
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Function>
-  void ``[link asio.reference.spawn.overload9 spawn]``(
-      basic_yield_context< Executor > ctx,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload9 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given executor. 
-
-  template<
-      typename Function,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  void ``[link asio.reference.spawn.overload10 spawn]``(
-      const Executor & ex,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload10 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given strand. 
-
-  template<
-      typename Function,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  void ``[link asio.reference.spawn.overload11 spawn]``(
-      const strand< Executor > & ex,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload11 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes in the context of a strand. 
-
-  template<
-      typename Function>
-  void ``[link asio.reference.spawn.overload12 spawn]``(
-      const asio::io_context::strand & s,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload12 more...]]``
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given execution context. 
-
-  template<
-      typename Function,
-      typename ExecutionContext>
-  void ``[link asio.reference.spawn.overload13 spawn]``(
-      ExecutionContext & ctx,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.spawn.overload13 more...]]``
-
-The [link asio.reference.spawn `spawn`] function is a high-level wrapper over the Boost.Coroutine library. This function enables programs to implement asynchronous logic in a synchronous manner, as illustrated by the following example:
-
-
-
-  asio::spawn(my_strand, do_echo, asio::detached);
-
-  // ...
-
-  void do_echo(asio::yield_context yield)
-  {
-    try
-    {
-      char data[128];
-      for (;;)
-      {
-        std::size_t length =
-          my_socket.async_read_some(
-            asio::buffer(data), yield);
-
-        asio::async_write(my_socket,
-            asio::buffer(data, length), yield);
-      }
-    }
-    catch (std::exception& e)
-    {
-      // ...
-    }
-  } 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/spawn.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 spawn (1 of 13 overloads)]
-
-
-Start a new stackful coroutine that executes on a given executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto spawn(
-      const Executor & ex,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][Identifies the executor that will run the stackful coroutine.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 spawn (2 of 13 overloads)]
-
-
-Start a new stackful coroutine that executes on a given execution context. 
-
-
-  template<
-      typename ExecutionContext,
-      typename F,
-      typename CompletionToken = default_completion_token_t<            typename ExecutionContext::executor_type>>
-  auto spawn(
-      ExecutionContext & ctx,
-      F && function,
-      CompletionToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the execution context that will run the stackful coroutine.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 spawn (3 of 13 overloads)]
-
-
-Start a new stackful coroutine, inheriting the executor of another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto spawn(
-      const basic_yield_context< Executor > & ctx,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the current coroutine as a parent of the new coroutine. This specifies that the new coroutine should inherit the executor of the parent. For example, if the parent coroutine is executing in a particular strand, then the new coroutine will execute in the same strand.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 spawn (4 of 13 overloads)]
-
-
-Start a new stackful coroutine that executes on a given executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto spawn(
-      const Executor & ex,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine using the specified stack allocator.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][Identifies the executor that will run the stackful coroutine.]]
-
-[[stack_allocator][Denotes the allocator to be used to allocate the underlying coroutine's stack. The type must satisfy the stack-allocator concept defined by the Boost.Context library.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 spawn (5 of 13 overloads)]
-
-
-Start a new stackful coroutine that executes on a given execution context. 
-
-
-  template<
-      typename ExecutionContext,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<            typename ExecutionContext::executor_type>>
-  auto spawn(
-      ExecutionContext & ctx,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< typename ExecutionContext::executor_type >(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the execution context that will run the stackful coroutine.]]
-
-[[stack_allocator][Denotes the allocator to be used to allocate the underlying coroutine's stack. The type must satisfy the stack-allocator concept defined by the Boost.Context library.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 spawn (6 of 13 overloads)]
-
-
-Start a new stackful coroutine, inheriting the executor of another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename StackAllocator,
-      typename F,
-      typename CompletionToken = default_completion_token_t<Executor>>
-  auto spawn(
-      const basic_yield_context< Executor > & ctx,
-      allocator_arg_t ,
-      StackAllocator && stack_allocator,
-      F && function,
-      CompletionToken && token = default_completion_token_t< Executor >(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-This function is used to launch a new stackful coroutine using the specified stack allocator.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the current coroutine as a parent of the new coroutine. This specifies that the new coroutine should inherit the executor of the parent. For example, if the parent coroutine is executing in a particular strand, then the new coroutine will execute in the same strand.]]
-
-[[stack_allocator][Denotes the allocator to be used to allocate the underlying coroutine's stack. The type must satisfy the stack-allocator concept defined by the Boost.Context library.]]
-
-[[function][The coroutine function. The function must be callable the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will handle the notification that the coroutine has completed. If the return type `R` of `function` is `void`, the function signature of the completion handler must be:]]
-
-]
-
-
-
-  void handler(std::exception_ptr); 
-
-
-Otherwise, the function signature of the completion handler must be: 
-
-  void handler(std::exception_ptr, R); 
-
-
-
-
-
-[heading Completion Signature]
-  
-
-
-  void(std::exception_ptr, R) 
-
-
-where `R` is the return type of the function object.
-
-
-[heading Per-Operation Cancellation]
-  
-The new thread of execution is created with a cancellation state that supports `cancellation_type::terminal` values only. To change the cancellation state, call the [link asio.reference.basic_yield_context `basic_yield_context`] member function `reset_cancellation_state`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 spawn (7 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine, calling the specified handler when it completes. 
-
-
-  template<
-      typename Function>
-  void spawn(
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-where Executor is the associated executor type of `Function`.]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 spawn (8 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine, calling the specified handler when it completes. 
-
-
-  template<
-      typename ``[link asio.reference.Handler Handler]``,
-      typename Function>
-  void spawn(
-      Handler && handler,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< !is_executor< decay_t< Handler > >::value &&!execution::is_executor< decay_t< Handler > >::value &&!is_convertible< Handler &, execution_context & >::value >  = 0);
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[handler][A handler to be called when the coroutine exits. More importantly, the handler provides an execution context (via the the handler invocation hook) for the coroutine. The handler must have the signature: 
-``
-  void handler(); 
-``
-]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-where Executor is the associated executor type of `Handler`.]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 spawn (9 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine, inheriting the execution context of another. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename Function>
-  void spawn(
-      basic_yield_context< Executor > ctx,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the current coroutine as a parent of the new coroutine. This specifies that the new coroutine should inherit the execution context of the parent. For example, if the parent coroutine is executing in a particular strand, then the new coroutine will execute in the same strand.]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(basic_yield_context<Executor> yield); 
-``
-]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 spawn (10 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given executor. 
-
-
-  template<
-      typename Function,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  void spawn(
-      const Executor & ex,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< is_executor< Executor >::value||execution::is_executor< Executor >::value >  = 0);
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][Identifies the executor that will run the coroutine. The new coroutine is automatically given its own explicit strand within this executor.]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(yield_context yield); 
-``
-]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 spawn (11 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given strand. 
-
-
-  template<
-      typename Function,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  void spawn(
-      const strand< Executor > & ex,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][Identifies the strand that will run the coroutine.]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(yield_context yield); 
-``
-]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 spawn (12 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes in the context of a strand. 
-
-
-  template<
-      typename Function>
-  void spawn(
-      const asio::io_context::strand & s,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][Identifies a strand. By starting multiple coroutines on the same strand, the implementation ensures that none of those coroutines can execute simultaneously.]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(yield_context yield); 
-``
-]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 spawn (13 of 13 overloads)]
-
-
-(Deprecated: Use overloads with a completion token.) Start a new stackful coroutine that executes on a given execution context. 
-
-
-  template<
-      typename Function,
-      typename ExecutionContext>
-  void spawn(
-      ExecutionContext & ctx,
-      Function && function,
-      const boost::coroutines::attributes & attributes = boost::coroutines::attributes(),
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This function is used to launch a new coroutine.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ctx][Identifies the execution context that will run the coroutine. The new coroutine is implicitly given its own strand within this execution context.]]
-
-[[function][The coroutine function. The function must have the signature: 
-``
-  void function(yield_context yield); 
-``
-]]
-
-[[attributes][Boost.Coroutine attributes used to customise the coroutine. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:ssl__context ssl::context]
-
-[indexterm1 asio.indexterm.ssl__context..ssl::context]
-
-
-
-  class context :
-    public ssl::context_base,
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__context.file_format [*file_format]]]
-    [File format types. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context.method [*method]]]
-    [Different methods supported by a context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context.native_handle_type [*native_handle_type]]]
-    [The native handle type of the SSL context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context.options [*options]]]
-    [Bitmask type for SSL options. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context.password_purpose [*password_purpose]]]
-    [Purpose of PEM password. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__context.add_certificate_authority [*add_certificate_authority]]]
-    [Add certification authority for performing verification. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.add_verify_path [*add_verify_path]]]
-    [Add a directory containing certificate authority files to be used for performing verification. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.clear_options [*clear_options]]]
-    [Clear options on the context. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.context [*context]] [constructor]]
-    [Constructor. 
-     [hr]
-     Construct to take ownership of a native handle. 
-     [hr]
-     Move-construct a context from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.load_verify_file [*load_verify_file]]]
-    [Load a certification authority file for performing verification. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.native_handle [*native_handle]]]
-    [Get the underlying implementation in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.operator_eq_ [*operator=]]]
-    [Move-assign a context from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_default_verify_paths [*set_default_verify_paths]]]
-    [Configures the context to use the default directories for finding certification authority certificates. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_options [*set_options]]]
-    [Set options on the context. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_password_callback [*set_password_callback]]]
-    [Set the password callback. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_verify_callback [*set_verify_callback]]]
-    [Set the callback used to verify peer certificates. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_verify_depth [*set_verify_depth]]]
-    [Set the peer verification depth. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.set_verify_mode [*set_verify_mode]]]
-    [Set the peer verification mode. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_certificate [*use_certificate]]]
-    [Use a certificate from a memory buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_certificate_chain [*use_certificate_chain]]]
-    [Use a certificate chain from a memory buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_certificate_chain_file [*use_certificate_chain_file]]]
-    [Use a certificate chain from a file. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_certificate_file [*use_certificate_file]]]
-    [Use a certificate from a file. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_private_key [*use_private_key]]]
-    [Use a private key from a memory buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_private_key_file [*use_private_key_file]]]
-    [Use a private key from a file. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_rsa_private_key [*use_rsa_private_key]]]
-    [Use an RSA private key from a memory buffer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_rsa_private_key_file [*use_rsa_private_key_file]]]
-    [Use an RSA private key from a file. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_tmp_dh [*use_tmp_dh]]]
-    [Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context.use_tmp_dh_file [*use_tmp_dh_file]]]
-    [Use the specified file to obtain the temporary Diffie-Hellman parameters. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__context._context [*~context]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__context.default_workarounds [*default_workarounds]] [static]]
-    [Implement various bug workarounds. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_compression [*no_compression]] [static]]
-    [Disable compression. Compression is disabled by default. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_sslv2 [*no_sslv2]] [static]]
-    [Disable SSL v2. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_sslv3 [*no_sslv3]] [static]]
-    [Disable SSL v3. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_tlsv1 [*no_tlsv1]] [static]]
-    [Disable TLS v1. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_tlsv1_1 [*no_tlsv1_1]] [static]]
-    [Disable TLS v1.1. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_tlsv1_2 [*no_tlsv1_2]] [static]]
-    [Disable TLS v1.2. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.no_tlsv1_3 [*no_tlsv1_3]] [static]]
-    [Disable TLS v1.3. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context.single_dh_use [*single_dh_use]] [static]]
-    [Always create a new key when using tmp_dh parameters. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/context.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-[section:add_certificate_authority ssl::context::add_certificate_authority]
-
-[indexterm2 asio.indexterm.ssl__context.add_certificate_authority..add_certificate_authority..ssl::context] 
-Add certification authority for performing verification. 
-
-
-  void ``[link asio.reference.ssl__context.add_certificate_authority.overload1 add_certificate_authority]``(
-      const const_buffer & ca);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.add_certificate_authority.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.add_certificate_authority.overload2 add_certificate_authority]``(
-      const const_buffer & ca,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.add_certificate_authority.overload2 more...]]``
-
-
-[section:overload1 ssl::context::add_certificate_authority (1 of 2 overloads)]
-
-
-Add certification authority for performing verification. 
-
-
-  void add_certificate_authority(
-      const const_buffer & ca);
-
-
-This function is used to add one trusted certification authority from a memory buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ca][The buffer containing the certification authority certificate. The certificate must use the PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_get_cert_store` and `X509_STORE_add_cert`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::add_certificate_authority (2 of 2 overloads)]
-
-
-Add certification authority for performing verification. 
-
-
-  void add_certificate_authority(
-      const const_buffer & ca,
-      asio::error_code & ec);
-
-
-This function is used to add one trusted certification authority from a memory buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ca][The buffer containing the certification authority certificate. The certificate must use the PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_get_cert_store` and `X509_STORE_add_cert`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:add_verify_path ssl::context::add_verify_path]
-
-[indexterm2 asio.indexterm.ssl__context.add_verify_path..add_verify_path..ssl::context] 
-Add a directory containing certificate authority files to be used for performing verification. 
-
-
-  void ``[link asio.reference.ssl__context.add_verify_path.overload1 add_verify_path]``(
-      const std::string & path);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.add_verify_path.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.add_verify_path.overload2 add_verify_path]``(
-      const std::string & path,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.add_verify_path.overload2 more...]]``
-
-
-[section:overload1 ssl::context::add_verify_path (1 of 2 overloads)]
-
-
-Add a directory containing certificate authority files to be used for performing verification. 
-
-
-  void add_verify_path(
-      const std::string & path);
-
-
-This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The name of a directory containing the certificates.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_load_verify_locations`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::add_verify_path (2 of 2 overloads)]
-
-
-Add a directory containing certificate authority files to be used for performing verification. 
-
-
-  void add_verify_path(
-      const std::string & path,
-      asio::error_code & ec);
-
-
-This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[path][The name of a directory containing the certificates.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_load_verify_locations`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:clear_options ssl::context::clear_options]
-
-[indexterm2 asio.indexterm.ssl__context.clear_options..clear_options..ssl::context] 
-Clear options on the context. 
-
-
-  void ``[link asio.reference.ssl__context.clear_options.overload1 clear_options]``(
-      options o);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.clear_options.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.clear_options.overload2 clear_options]``(
-      options o,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.clear_options.overload2 more...]]``
-
-
-[section:overload1 ssl::context::clear_options (1 of 2 overloads)]
-
-
-Clear options on the context. 
-
-
-  void clear_options(
-      options o);
-
-
-This function may be used to configure the SSL options used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[o][A bitmask of options. The available option values are defined in the [link asio.reference.ssl__context_base `ssl::context_base`] class. The specified options, if currently enabled on the context, are cleared.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_clear_options`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::clear_options (2 of 2 overloads)]
-
-
-Clear options on the context. 
-
-
-  void clear_options(
-      options o,
-      asio::error_code & ec);
-
-
-This function may be used to configure the SSL options used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[o][A bitmask of options. The available option values are defined in the [link asio.reference.ssl__context_base `ssl::context_base`] class. The specified options, if currently enabled on the context, are cleared.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_clear_options`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:context ssl::context::context]
-
-[indexterm2 asio.indexterm.ssl__context.context..context..ssl::context] 
-Constructor. 
-
-
-  explicit ``[link asio.reference.ssl__context.context.overload1 context]``(
-      method m);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.context.overload1 more...]]``
-
-
-Construct to take ownership of a native handle. 
-
-
-  explicit ``[link asio.reference.ssl__context.context.overload2 context]``(
-      native_handle_type native_handle);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.context.overload2 more...]]``
-
-
-Move-construct a context from another. 
-
-
-  ``[link asio.reference.ssl__context.context.overload3 context]``(
-      context && other);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.context.overload3 more...]]``
-
-
-[section:overload1 ssl::context::context (1 of 3 overloads)]
-
-
-Constructor. 
-
-
-  context(
-      method m);
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::context (2 of 3 overloads)]
-
-
-Construct to take ownership of a native handle. 
-
-
-  context(
-      native_handle_type native_handle);
-
-
-
-[endsect]
-
-
-
-[section:overload3 ssl::context::context (3 of 3 overloads)]
-
-
-Move-construct a context from another. 
-
-
-  context(
-      context && other);
-
-
-This constructor moves an SSL context from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other context object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the following operations only are valid for the moved-from object: 
-* Destruction. 
-
-* As a target for move-assignment. 
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:default_workarounds ssl::context::default_workarounds]
-
-[indexterm2 asio.indexterm.ssl__context.default_workarounds..default_workarounds..ssl::context] 
-Implement various bug workarounds. 
-
-
-  static const uint64_t default_workarounds = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:file_format ssl::context::file_format]
-
-[indexterm2 asio.indexterm.ssl__context.file_format..file_format..ssl::context] 
-File format types. 
-
-  enum file_format
-
-[indexterm2 asio.indexterm.ssl__context.file_format.asn1..asn1..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.file_format.pem..pem..ssl::context]
-
-[heading Values]
-[variablelist
-
-  [
-    [asn1]
-    [ASN.1 file. ]
-  ]
-
-  [
-    [pem]
-    [PEM file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:load_verify_file ssl::context::load_verify_file]
-
-[indexterm2 asio.indexterm.ssl__context.load_verify_file..load_verify_file..ssl::context] 
-Load a certification authority file for performing verification. 
-
-
-  void ``[link asio.reference.ssl__context.load_verify_file.overload1 load_verify_file]``(
-      const std::string & filename);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.load_verify_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.load_verify_file.overload2 load_verify_file]``(
-      const std::string & filename,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.load_verify_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::load_verify_file (1 of 2 overloads)]
-
-
-Load a certification authority file for performing verification. 
-
-
-  void load_verify_file(
-      const std::string & filename);
-
-
-This function is used to load one or more trusted certification authorities from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of a file containing certification authority certificates in PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_load_verify_locations`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::load_verify_file (2 of 2 overloads)]
-
-
-Load a certification authority file for performing verification. 
-
-
-  void load_verify_file(
-      const std::string & filename,
-      asio::error_code & ec);
-
-
-This function is used to load the certificates for one or more trusted certification authorities from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of a file containing certification authority certificates in PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_load_verify_locations`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:method ssl::context::method]
-
-[indexterm2 asio.indexterm.ssl__context.method..method..ssl::context] 
-Different methods supported by a context. 
-
-  enum method
-
-[indexterm2 asio.indexterm.ssl__context.method.sslv2..sslv2..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv2_client..sslv2_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv2_server..sslv2_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv3..sslv3..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv3_client..sslv3_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv3_server..sslv3_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv1..tlsv1..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv1_client..tlsv1_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv1_server..tlsv1_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv23..sslv23..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv23_client..sslv23_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.sslv23_server..sslv23_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv11..tlsv11..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv11_client..tlsv11_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv11_server..tlsv11_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv12..tlsv12..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv12_client..tlsv12_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv12_server..tlsv12_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv13..tlsv13..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv13_client..tlsv13_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tlsv13_server..tlsv13_server..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tls..tls..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tls_client..tls_client..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.method.tls_server..tls_server..ssl::context]
-
-[heading Values]
-[variablelist
-
-  [
-    [sslv2]
-    [Generic SSL version 2. ]
-  ]
-
-  [
-    [sslv2_client]
-    [SSL version 2 client. ]
-  ]
-
-  [
-    [sslv2_server]
-    [SSL version 2 server. ]
-  ]
-
-  [
-    [sslv3]
-    [Generic SSL version 3. ]
-  ]
-
-  [
-    [sslv3_client]
-    [SSL version 3 client. ]
-  ]
-
-  [
-    [sslv3_server]
-    [SSL version 3 server. ]
-  ]
-
-  [
-    [tlsv1]
-    [Generic TLS version 1. ]
-  ]
-
-  [
-    [tlsv1_client]
-    [TLS version 1 client. ]
-  ]
-
-  [
-    [tlsv1_server]
-    [TLS version 1 server. ]
-  ]
-
-  [
-    [sslv23]
-    [Generic SSL/TLS. ]
-  ]
-
-  [
-    [sslv23_client]
-    [SSL/TLS client. ]
-  ]
-
-  [
-    [sslv23_server]
-    [SSL/TLS server. ]
-  ]
-
-  [
-    [tlsv11]
-    [Generic TLS version 1.1. ]
-  ]
-
-  [
-    [tlsv11_client]
-    [TLS version 1.1 client. ]
-  ]
-
-  [
-    [tlsv11_server]
-    [TLS version 1.1 server. ]
-  ]
-
-  [
-    [tlsv12]
-    [Generic TLS version 1.2. ]
-  ]
-
-  [
-    [tlsv12_client]
-    [TLS version 1.2 client. ]
-  ]
-
-  [
-    [tlsv12_server]
-    [TLS version 1.2 server. ]
-  ]
-
-  [
-    [tlsv13]
-    [Generic TLS version 1.3. ]
-  ]
-
-  [
-    [tlsv13_client]
-    [TLS version 1.3 client. ]
-  ]
-
-  [
-    [tlsv13_server]
-    [TLS version 1.3 server. ]
-  ]
-
-  [
-    [tls]
-    [Generic TLS. ]
-  ]
-
-  [
-    [tls_client]
-    [TLS client. ]
-  ]
-
-  [
-    [tls_server]
-    [TLS server. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:native_handle ssl::context::native_handle]
-
-[indexterm2 asio.indexterm.ssl__context.native_handle..native_handle..ssl::context] 
-Get the underlying implementation in the native type. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type ssl::context::native_handle_type]
-
-[indexterm2 asio.indexterm.ssl__context.native_handle_type..native_handle_type..ssl::context] 
-The native handle type of the SSL context. 
-
-
-  typedef SSL_CTX * native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/context.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:no_compression ssl::context::no_compression]
-
-[indexterm2 asio.indexterm.ssl__context.no_compression..no_compression..ssl::context] 
-Disable compression. Compression is disabled by default. 
-
-
-  static const uint64_t no_compression = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_sslv2 ssl::context::no_sslv2]
-
-[indexterm2 asio.indexterm.ssl__context.no_sslv2..no_sslv2..ssl::context] 
-Disable SSL v2. 
-
-
-  static const uint64_t no_sslv2 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_sslv3 ssl::context::no_sslv3]
-
-[indexterm2 asio.indexterm.ssl__context.no_sslv3..no_sslv3..ssl::context] 
-Disable SSL v3. 
-
-
-  static const uint64_t no_sslv3 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1 ssl::context::no_tlsv1]
-
-[indexterm2 asio.indexterm.ssl__context.no_tlsv1..no_tlsv1..ssl::context] 
-Disable TLS v1. 
-
-
-  static const uint64_t no_tlsv1 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_1 ssl::context::no_tlsv1_1]
-
-[indexterm2 asio.indexterm.ssl__context.no_tlsv1_1..no_tlsv1_1..ssl::context] 
-Disable TLS v1.1. 
-
-
-  static const uint64_t no_tlsv1_1 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_2 ssl::context::no_tlsv1_2]
-
-[indexterm2 asio.indexterm.ssl__context.no_tlsv1_2..no_tlsv1_2..ssl::context] 
-Disable TLS v1.2. 
-
-
-  static const uint64_t no_tlsv1_2 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_3 ssl::context::no_tlsv1_3]
-
-[indexterm2 asio.indexterm.ssl__context.no_tlsv1_3..no_tlsv1_3..ssl::context] 
-Disable TLS v1.3. 
-
-
-  static const uint64_t no_tlsv1_3 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:operator_eq_ ssl::context::operator=]
-
-[indexterm2 asio.indexterm.ssl__context.operator_eq_..operator=..ssl::context] 
-Move-assign a context from another. 
-
-
-  context & operator=(
-      context && other);
-
-
-This assignment operator moves an SSL context from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other context object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the following operations only are valid for the moved-from object: 
-* Destruction. 
-
-* As a target for move-assignment. 
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:options ssl::context::options]
-
-[indexterm2 asio.indexterm.ssl__context.options..options..ssl::context] 
-Bitmask type for SSL options. 
-
-
-  typedef uint64_t options;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/context.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:password_purpose ssl::context::password_purpose]
-
-[indexterm2 asio.indexterm.ssl__context.password_purpose..password_purpose..ssl::context] 
-Purpose of PEM password. 
-
-  enum password_purpose
-
-[indexterm2 asio.indexterm.ssl__context.password_purpose.for_reading..for_reading..ssl::context]
-[indexterm2 asio.indexterm.ssl__context.password_purpose.for_writing..for_writing..ssl::context]
-
-[heading Values]
-[variablelist
-
-  [
-    [for_reading]
-    [The password is needed for reading/decryption. ]
-  ]
-
-  [
-    [for_writing]
-    [The password is needed for writing/encryption. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:set_default_verify_paths ssl::context::set_default_verify_paths]
-
-[indexterm2 asio.indexterm.ssl__context.set_default_verify_paths..set_default_verify_paths..ssl::context] 
-Configures the context to use the default directories for finding certification authority certificates. 
-
-
-  void ``[link asio.reference.ssl__context.set_default_verify_paths.overload1 set_default_verify_paths]``();
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_default_verify_paths.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.set_default_verify_paths.overload2 set_default_verify_paths]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_default_verify_paths.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_default_verify_paths (1 of 2 overloads)]
-
-
-Configures the context to use the default directories for finding certification authority certificates. 
-
-
-  void set_default_verify_paths();
-
-
-This function specifies that the context should use the default, system-dependent directories for locating certification authority certificates.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_default_verify_paths`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_default_verify_paths (2 of 2 overloads)]
-
-
-Configures the context to use the default directories for finding certification authority certificates. 
-
-
-  void set_default_verify_paths(
-      asio::error_code & ec);
-
-
-This function specifies that the context should use the default, system-dependent directories for locating certification authority certificates.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_default_verify_paths`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_options ssl::context::set_options]
-
-[indexterm2 asio.indexterm.ssl__context.set_options..set_options..ssl::context] 
-Set options on the context. 
-
-
-  void ``[link asio.reference.ssl__context.set_options.overload1 set_options]``(
-      options o);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_options.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.set_options.overload2 set_options]``(
-      options o,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_options.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_options (1 of 2 overloads)]
-
-
-Set options on the context. 
-
-
-  void set_options(
-      options o);
-
-
-This function may be used to configure the SSL options used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[o][A bitmask of options. The available option values are defined in the [link asio.reference.ssl__context_base `ssl::context_base`] class. The options are bitwise-ored with any existing value for the options.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_options`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_options (2 of 2 overloads)]
-
-
-Set options on the context. 
-
-
-  void set_options(
-      options o,
-      asio::error_code & ec);
-
-
-This function may be used to configure the SSL options used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[o][A bitmask of options. The available option values are defined in the [link asio.reference.ssl__context_base `ssl::context_base`] class. The options are bitwise-ored with any existing value for the options.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_options`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_password_callback ssl::context::set_password_callback]
-
-[indexterm2 asio.indexterm.ssl__context.set_password_callback..set_password_callback..ssl::context] 
-Set the password callback. 
-
-
-  template<
-      typename PasswordCallback>
-  void ``[link asio.reference.ssl__context.set_password_callback.overload1 set_password_callback]``(
-      PasswordCallback callback);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_password_callback.overload1 more...]]``
-
-  template<
-      typename PasswordCallback>
-  void ``[link asio.reference.ssl__context.set_password_callback.overload2 set_password_callback]``(
-      PasswordCallback callback,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_password_callback.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_password_callback (1 of 2 overloads)]
-
-
-Set the password callback. 
-
-
-  template<
-      typename PasswordCallback>
-  void set_password_callback(
-      PasswordCallback callback);
-
-
-This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for obtaining the password. The function signature of the handler must be: 
-``
-  std::string password_callback(
-    std::size_t max_length,  // The maximum size for a password.
-    password_purpose purpose // Whether password is for reading or writing.
-  ); 
-``
-The return value of the callback is a string containing the password.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_default_passwd_cb`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_password_callback (2 of 2 overloads)]
-
-
-Set the password callback. 
-
-
-  template<
-      typename PasswordCallback>
-  void set_password_callback(
-      PasswordCallback callback,
-      asio::error_code & ec);
-
-
-This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for obtaining the password. The function signature of the handler must be: 
-``
-  std::string password_callback(
-    std::size_t max_length,  // The maximum size for a password.
-    password_purpose purpose // Whether password is for reading or writing.
-  ); 
-``
-The return value of the callback is a string containing the password.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_default_passwd_cb`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_callback ssl::context::set_verify_callback]
-
-[indexterm2 asio.indexterm.ssl__context.set_verify_callback..set_verify_callback..ssl::context] 
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void ``[link asio.reference.ssl__context.set_verify_callback.overload1 set_verify_callback]``(
-      VerifyCallback callback);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_callback.overload1 more...]]``
-
-  template<
-      typename VerifyCallback>
-  void ``[link asio.reference.ssl__context.set_verify_callback.overload2 set_verify_callback]``(
-      VerifyCallback callback,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_callback.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_verify_callback (1 of 2 overloads)]
-
-
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void set_verify_callback(
-      VerifyCallback callback);
-
-
-This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for verifying a certificate. The function signature of the handler must be: 
-``
-  bool verify_callback(
-    bool preverified, // True if the certificate passed pre-verification.
-    verify_context& ctx // The peer certificate and other context.
-  ); 
-``
-The return value of the callback is true if the certificate has passed verification, false otherwise.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_verify_callback (2 of 2 overloads)]
-
-
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void set_verify_callback(
-      VerifyCallback callback,
-      asio::error_code & ec);
-
-
-This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for verifying a certificate. The function signature of the handler must be: 
-``
-  bool verify_callback(
-    bool preverified, // True if the certificate passed pre-verification.
-    verify_context& ctx // The peer certificate and other context.
-  ); 
-``
-The return value of the callback is true if the certificate has passed verification, false otherwise.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_depth ssl::context::set_verify_depth]
-
-[indexterm2 asio.indexterm.ssl__context.set_verify_depth..set_verify_depth..ssl::context] 
-Set the peer verification depth. 
-
-
-  void ``[link asio.reference.ssl__context.set_verify_depth.overload1 set_verify_depth]``(
-      int depth);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_depth.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.set_verify_depth.overload2 set_verify_depth]``(
-      int depth,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_depth.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_verify_depth (1 of 2 overloads)]
-
-
-Set the peer verification depth. 
-
-
-  void set_verify_depth(
-      int depth);
-
-
-This function may be used to configure the maximum verification depth allowed by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[depth][Maximum depth for the certificate chain verification that shall be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify_depth`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_verify_depth (2 of 2 overloads)]
-
-
-Set the peer verification depth. 
-
-
-  void set_verify_depth(
-      int depth,
-      asio::error_code & ec);
-
-
-This function may be used to configure the maximum verification depth allowed by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[depth][Maximum depth for the certificate chain verification that shall be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify_depth`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_mode ssl::context::set_verify_mode]
-
-[indexterm2 asio.indexterm.ssl__context.set_verify_mode..set_verify_mode..ssl::context] 
-Set the peer verification mode. 
-
-
-  void ``[link asio.reference.ssl__context.set_verify_mode.overload1 set_verify_mode]``(
-      verify_mode v);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_mode.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.set_verify_mode.overload2 set_verify_mode]``(
-      verify_mode v,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.set_verify_mode.overload2 more...]]``
-
-
-[section:overload1 ssl::context::set_verify_mode (1 of 2 overloads)]
-
-
-Set the peer verification mode. 
-
-
-  void set_verify_mode(
-      verify_mode v);
-
-
-This function may be used to configure the peer verification mode used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[v][A bitmask of peer verification modes. See [link asio.reference.ssl__verify_mode `ssl::verify_mode`] for available values.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::set_verify_mode (2 of 2 overloads)]
-
-
-Set the peer verification mode. 
-
-
-  void set_verify_mode(
-      verify_mode v,
-      asio::error_code & ec);
-
-
-This function may be used to configure the peer verification mode used by the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[v][A bitmask of peer verification modes. See [link asio.reference.ssl__verify_mode `ssl::verify_mode`] for available values.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_verify`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:single_dh_use ssl::context::single_dh_use]
-
-[indexterm2 asio.indexterm.ssl__context.single_dh_use..single_dh_use..ssl::context] 
-Always create a new key when using tmp\_dh parameters. 
-
-
-  static const uint64_t single_dh_use = implementation_defined;
-
-
-
-[endsect]
-
-
-[section:use_certificate ssl::context::use_certificate]
-
-[indexterm2 asio.indexterm.ssl__context.use_certificate..use_certificate..ssl::context] 
-Use a certificate from a memory buffer. 
-
-
-  void ``[link asio.reference.ssl__context.use_certificate.overload1 use_certificate]``(
-      const const_buffer & certificate,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_certificate.overload2 use_certificate]``(
-      const const_buffer & certificate,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_certificate (1 of 2 overloads)]
-
-
-Use a certificate from a memory buffer. 
-
-
-  void use_certificate(
-      const const_buffer & certificate,
-      file_format format);
-
-
-This function is used to load a certificate into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[certificate][The buffer containing the certificate.]]
-
-[[format][The certificate format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate` or SSL\_CTX\_use\_certificate\_ASN1. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_certificate (2 of 2 overloads)]
-
-
-Use a certificate from a memory buffer. 
-
-
-  void use_certificate(
-      const const_buffer & certificate,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load a certificate into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[certificate][The buffer containing the certificate.]]
-
-[[format][The certificate format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate` or SSL\_CTX\_use\_certificate\_ASN1. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_certificate_chain ssl::context::use_certificate_chain]
-
-[indexterm2 asio.indexterm.ssl__context.use_certificate_chain..use_certificate_chain..ssl::context] 
-Use a certificate chain from a memory buffer. 
-
-
-  void ``[link asio.reference.ssl__context.use_certificate_chain.overload1 use_certificate_chain]``(
-      const const_buffer & chain);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_chain.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_certificate_chain.overload2 use_certificate_chain]``(
-      const const_buffer & chain,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_chain.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_certificate_chain (1 of 2 overloads)]
-
-
-Use a certificate chain from a memory buffer. 
-
-
-  void use_certificate_chain(
-      const const_buffer & chain);
-
-
-This function is used to load a certificate chain into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[chain][The buffer containing the certificate chain. The certificate chain must use the PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate` and SSL\_CTX\_add\_extra\_chain\_cert. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_certificate_chain (2 of 2 overloads)]
-
-
-Use a certificate chain from a memory buffer. 
-
-
-  void use_certificate_chain(
-      const const_buffer & chain,
-      asio::error_code & ec);
-
-
-This function is used to load a certificate chain into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[chain][The buffer containing the certificate chain. The certificate chain must use the PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate` and SSL\_CTX\_add\_extra\_chain\_cert. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_certificate_chain_file ssl::context::use_certificate_chain_file]
-
-[indexterm2 asio.indexterm.ssl__context.use_certificate_chain_file..use_certificate_chain_file..ssl::context] 
-Use a certificate chain from a file. 
-
-
-  void ``[link asio.reference.ssl__context.use_certificate_chain_file.overload1 use_certificate_chain_file]``(
-      const std::string & filename);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_chain_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_certificate_chain_file.overload2 use_certificate_chain_file]``(
-      const std::string & filename,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_chain_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_certificate_chain_file (1 of 2 overloads)]
-
-
-Use a certificate chain from a file. 
-
-
-  void use_certificate_chain_file(
-      const std::string & filename);
-
-
-This function is used to load a certificate chain into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the certificate. The file must use the PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate_chain_file`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_certificate_chain_file (2 of 2 overloads)]
-
-
-Use a certificate chain from a file. 
-
-
-  void use_certificate_chain_file(
-      const std::string & filename,
-      asio::error_code & ec);
-
-
-This function is used to load a certificate chain into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the certificate. The file must use the PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate_chain_file`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_certificate_file ssl::context::use_certificate_file]
-
-[indexterm2 asio.indexterm.ssl__context.use_certificate_file..use_certificate_file..ssl::context] 
-Use a certificate from a file. 
-
-
-  void ``[link asio.reference.ssl__context.use_certificate_file.overload1 use_certificate_file]``(
-      const std::string & filename,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_certificate_file.overload2 use_certificate_file]``(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_certificate_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_certificate_file (1 of 2 overloads)]
-
-
-Use a certificate from a file. 
-
-
-  void use_certificate_file(
-      const std::string & filename,
-      file_format format);
-
-
-This function is used to load a certificate into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the certificate.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate_file`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_certificate_file (2 of 2 overloads)]
-
-
-Use a certificate from a file. 
-
-
-  void use_certificate_file(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load a certificate into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the certificate.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_certificate_file`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_private_key ssl::context::use_private_key]
-
-[indexterm2 asio.indexterm.ssl__context.use_private_key..use_private_key..ssl::context] 
-Use a private key from a memory buffer. 
-
-
-  void ``[link asio.reference.ssl__context.use_private_key.overload1 use_private_key]``(
-      const const_buffer & private_key,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_private_key.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_private_key.overload2 use_private_key]``(
-      const const_buffer & private_key,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_private_key.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_private_key (1 of 2 overloads)]
-
-
-Use a private key from a memory buffer. 
-
-
-  void use_private_key(
-      const const_buffer & private_key,
-      file_format format);
-
-
-This function is used to load a private key into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[private_key][The buffer containing the private key.]]
-
-[[format][The private key format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_PrivateKey` or SSL\_CTX\_use\_PrivateKey\_ASN1. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_private_key (2 of 2 overloads)]
-
-
-Use a private key from a memory buffer. 
-
-
-  void use_private_key(
-      const const_buffer & private_key,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load a private key into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[private_key][The buffer containing the private key.]]
-
-[[format][The private key format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_PrivateKey` or SSL\_CTX\_use\_PrivateKey\_ASN1. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_private_key_file ssl::context::use_private_key_file]
-
-[indexterm2 asio.indexterm.ssl__context.use_private_key_file..use_private_key_file..ssl::context] 
-Use a private key from a file. 
-
-
-  void ``[link asio.reference.ssl__context.use_private_key_file.overload1 use_private_key_file]``(
-      const std::string & filename,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_private_key_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_private_key_file.overload2 use_private_key_file]``(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_private_key_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_private_key_file (1 of 2 overloads)]
-
-
-Use a private key from a file. 
-
-
-  void use_private_key_file(
-      const std::string & filename,
-      file_format format);
-
-
-This function is used to load a private key into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the private key.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_PrivateKey_file`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_private_key_file (2 of 2 overloads)]
-
-
-Use a private key from a file. 
-
-
-  void use_private_key_file(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load a private key into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the private key.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_PrivateKey_file`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_rsa_private_key ssl::context::use_rsa_private_key]
-
-[indexterm2 asio.indexterm.ssl__context.use_rsa_private_key..use_rsa_private_key..ssl::context] 
-Use an RSA private key from a memory buffer. 
-
-
-  void ``[link asio.reference.ssl__context.use_rsa_private_key.overload1 use_rsa_private_key]``(
-      const const_buffer & private_key,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_rsa_private_key.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_rsa_private_key.overload2 use_rsa_private_key]``(
-      const const_buffer & private_key,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_rsa_private_key.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_rsa_private_key (1 of 2 overloads)]
-
-
-Use an RSA private key from a memory buffer. 
-
-
-  void use_rsa_private_key(
-      const const_buffer & private_key,
-      file_format format);
-
-
-This function is used to load an RSA private key into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[private_key][The buffer containing the RSA private key.]]
-
-[[format][The private key format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_RSAPrivateKey` or SSL\_CTX\_use\_RSAPrivateKey\_ASN1. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_rsa_private_key (2 of 2 overloads)]
-
-
-Use an RSA private key from a memory buffer. 
-
-
-  void use_rsa_private_key(
-      const const_buffer & private_key,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load an RSA private key into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[private_key][The buffer containing the RSA private key.]]
-
-[[format][The private key format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_RSAPrivateKey` or SSL\_CTX\_use\_RSAPrivateKey\_ASN1. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_rsa_private_key_file ssl::context::use_rsa_private_key_file]
-
-[indexterm2 asio.indexterm.ssl__context.use_rsa_private_key_file..use_rsa_private_key_file..ssl::context] 
-Use an RSA private key from a file. 
-
-
-  void ``[link asio.reference.ssl__context.use_rsa_private_key_file.overload1 use_rsa_private_key_file]``(
-      const std::string & filename,
-      file_format format);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_rsa_private_key_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_rsa_private_key_file.overload2 use_rsa_private_key_file]``(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_rsa_private_key_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_rsa_private_key_file (1 of 2 overloads)]
-
-
-Use an RSA private key from a file. 
-
-
-  void use_rsa_private_key_file(
-      const std::string & filename,
-      file_format format);
-
-
-This function is used to load an RSA private key into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the RSA private key.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_RSAPrivateKey_file`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_rsa_private_key_file (2 of 2 overloads)]
-
-
-Use an RSA private key from a file. 
-
-
-  void use_rsa_private_key_file(
-      const std::string & filename,
-      file_format format,
-      asio::error_code & ec);
-
-
-This function is used to load an RSA private key into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the RSA private key.]]
-
-[[format][The file format (ASN.1 or PEM).]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_use_RSAPrivateKey_file`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_tmp_dh ssl::context::use_tmp_dh]
-
-[indexterm2 asio.indexterm.ssl__context.use_tmp_dh..use_tmp_dh..ssl::context] 
-Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void ``[link asio.reference.ssl__context.use_tmp_dh.overload1 use_tmp_dh]``(
-      const const_buffer & dh);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_tmp_dh.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_tmp_dh.overload2 use_tmp_dh]``(
-      const const_buffer & dh,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_tmp_dh.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_tmp_dh (1 of 2 overloads)]
-
-
-Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void use_tmp_dh(
-      const const_buffer & dh);
-
-
-This function is used to load Diffie-Hellman parameters into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[dh][The memory buffer containing the Diffie-Hellman parameters. The buffer must use the PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_tmp_dh`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_tmp_dh (2 of 2 overloads)]
-
-
-Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void use_tmp_dh(
-      const const_buffer & dh,
-      asio::error_code & ec);
-
-
-This function is used to load Diffie-Hellman parameters into the context from a buffer.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[dh][The memory buffer containing the Diffie-Hellman parameters. The buffer must use the PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_tmp_dh`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_tmp_dh_file ssl::context::use_tmp_dh_file]
-
-[indexterm2 asio.indexterm.ssl__context.use_tmp_dh_file..use_tmp_dh_file..ssl::context] 
-Use the specified file to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void ``[link asio.reference.ssl__context.use_tmp_dh_file.overload1 use_tmp_dh_file]``(
-      const std::string & filename);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_tmp_dh_file.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__context.use_tmp_dh_file.overload2 use_tmp_dh_file]``(
-      const std::string & filename,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__context.use_tmp_dh_file.overload2 more...]]``
-
-
-[section:overload1 ssl::context::use_tmp_dh_file (1 of 2 overloads)]
-
-
-Use the specified file to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void use_tmp_dh_file(
-      const std::string & filename);
-
-
-This function is used to load Diffie-Hellman parameters into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_tmp_dh`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::context::use_tmp_dh_file (2 of 2 overloads)]
-
-
-Use the specified file to obtain the temporary Diffie-Hellman parameters. 
-
-
-  void use_tmp_dh_file(
-      const std::string & filename,
-      asio::error_code & ec);
-
-
-This function is used to load Diffie-Hellman parameters into the context from a file.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[filename][The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_CTX_set_tmp_dh`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_context ssl::context::~context]
-
-[indexterm2 asio.indexterm.ssl__context._context..~context..ssl::context] 
-Destructor. 
-
-
-  ~context();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__context_base ssl::context_base]
-
-[indexterm1 asio.indexterm.ssl__context_base..ssl::context_base]
-
-
-The [link asio.reference.ssl__context_base `ssl::context_base`] class is used as a base for the basic\_context class template so that we have a common place to define various enums. 
-
-
-  class context_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__context_base.file_format [*file_format]]]
-    [File format types. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context_base.method [*method]]]
-    [Different methods supported by a context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context_base.options [*options]]]
-    [Bitmask type for SSL options. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__context_base.password_purpose [*password_purpose]]]
-    [Purpose of PEM password. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__context_base._context_base [*~context_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__context_base.default_workarounds [*default_workarounds]] [static]]
-    [Implement various bug workarounds. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_compression [*no_compression]] [static]]
-    [Disable compression. Compression is disabled by default. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_sslv2 [*no_sslv2]] [static]]
-    [Disable SSL v2. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_sslv3 [*no_sslv3]] [static]]
-    [Disable SSL v3. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_tlsv1 [*no_tlsv1]] [static]]
-    [Disable TLS v1. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_tlsv1_1 [*no_tlsv1_1]] [static]]
-    [Disable TLS v1.1. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_tlsv1_2 [*no_tlsv1_2]] [static]]
-    [Disable TLS v1.2. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.no_tlsv1_3 [*no_tlsv1_3]] [static]]
-    [Disable TLS v1.3. ]
-  ]
-
-  [
-    [[link asio.reference.ssl__context_base.single_dh_use [*single_dh_use]] [static]]
-    [Always create a new key when using tmp_dh parameters. ]
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/context_base.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:default_workarounds ssl::context_base::default_workarounds]
-
-[indexterm2 asio.indexterm.ssl__context_base.default_workarounds..default_workarounds..ssl::context_base] 
-Implement various bug workarounds. 
-
-
-  static const uint64_t default_workarounds = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:file_format ssl::context_base::file_format]
-
-[indexterm2 asio.indexterm.ssl__context_base.file_format..file_format..ssl::context_base] 
-File format types. 
-
-  enum file_format
-
-[indexterm2 asio.indexterm.ssl__context_base.file_format.asn1..asn1..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.file_format.pem..pem..ssl::context_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [asn1]
-    [ASN.1 file. ]
-  ]
-
-  [
-    [pem]
-    [PEM file. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:method ssl::context_base::method]
-
-[indexterm2 asio.indexterm.ssl__context_base.method..method..ssl::context_base] 
-Different methods supported by a context. 
-
-  enum method
-
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv2..sslv2..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv2_client..sslv2_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv2_server..sslv2_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv3..sslv3..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv3_client..sslv3_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv3_server..sslv3_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv1..tlsv1..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv1_client..tlsv1_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv1_server..tlsv1_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv23..sslv23..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv23_client..sslv23_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.sslv23_server..sslv23_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv11..tlsv11..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv11_client..tlsv11_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv11_server..tlsv11_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv12..tlsv12..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv12_client..tlsv12_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv12_server..tlsv12_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv13..tlsv13..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv13_client..tlsv13_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tlsv13_server..tlsv13_server..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tls..tls..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tls_client..tls_client..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.method.tls_server..tls_server..ssl::context_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [sslv2]
-    [Generic SSL version 2. ]
-  ]
-
-  [
-    [sslv2_client]
-    [SSL version 2 client. ]
-  ]
-
-  [
-    [sslv2_server]
-    [SSL version 2 server. ]
-  ]
-
-  [
-    [sslv3]
-    [Generic SSL version 3. ]
-  ]
-
-  [
-    [sslv3_client]
-    [SSL version 3 client. ]
-  ]
-
-  [
-    [sslv3_server]
-    [SSL version 3 server. ]
-  ]
-
-  [
-    [tlsv1]
-    [Generic TLS version 1. ]
-  ]
-
-  [
-    [tlsv1_client]
-    [TLS version 1 client. ]
-  ]
-
-  [
-    [tlsv1_server]
-    [TLS version 1 server. ]
-  ]
-
-  [
-    [sslv23]
-    [Generic SSL/TLS. ]
-  ]
-
-  [
-    [sslv23_client]
-    [SSL/TLS client. ]
-  ]
-
-  [
-    [sslv23_server]
-    [SSL/TLS server. ]
-  ]
-
-  [
-    [tlsv11]
-    [Generic TLS version 1.1. ]
-  ]
-
-  [
-    [tlsv11_client]
-    [TLS version 1.1 client. ]
-  ]
-
-  [
-    [tlsv11_server]
-    [TLS version 1.1 server. ]
-  ]
-
-  [
-    [tlsv12]
-    [Generic TLS version 1.2. ]
-  ]
-
-  [
-    [tlsv12_client]
-    [TLS version 1.2 client. ]
-  ]
-
-  [
-    [tlsv12_server]
-    [TLS version 1.2 server. ]
-  ]
-
-  [
-    [tlsv13]
-    [Generic TLS version 1.3. ]
-  ]
-
-  [
-    [tlsv13_client]
-    [TLS version 1.3 client. ]
-  ]
-
-  [
-    [tlsv13_server]
-    [TLS version 1.3 server. ]
-  ]
-
-  [
-    [tls]
-    [Generic TLS. ]
-  ]
-
-  [
-    [tls_client]
-    [TLS client. ]
-  ]
-
-  [
-    [tls_server]
-    [TLS server. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:no_compression ssl::context_base::no_compression]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_compression..no_compression..ssl::context_base] 
-Disable compression. Compression is disabled by default. 
-
-
-  static const uint64_t no_compression = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_sslv2 ssl::context_base::no_sslv2]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_sslv2..no_sslv2..ssl::context_base] 
-Disable SSL v2. 
-
-
-  static const uint64_t no_sslv2 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_sslv3 ssl::context_base::no_sslv3]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_sslv3..no_sslv3..ssl::context_base] 
-Disable SSL v3. 
-
-
-  static const uint64_t no_sslv3 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1 ssl::context_base::no_tlsv1]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_tlsv1..no_tlsv1..ssl::context_base] 
-Disable TLS v1. 
-
-
-  static const uint64_t no_tlsv1 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_1 ssl::context_base::no_tlsv1_1]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_tlsv1_1..no_tlsv1_1..ssl::context_base] 
-Disable TLS v1.1. 
-
-
-  static const uint64_t no_tlsv1_1 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_2 ssl::context_base::no_tlsv1_2]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_tlsv1_2..no_tlsv1_2..ssl::context_base] 
-Disable TLS v1.2. 
-
-
-  static const uint64_t no_tlsv1_2 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:no_tlsv1_3 ssl::context_base::no_tlsv1_3]
-
-[indexterm2 asio.indexterm.ssl__context_base.no_tlsv1_3..no_tlsv1_3..ssl::context_base] 
-Disable TLS v1.3. 
-
-
-  static const uint64_t no_tlsv1_3 = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:options ssl::context_base::options]
-
-[indexterm2 asio.indexterm.ssl__context_base.options..options..ssl::context_base] 
-Bitmask type for SSL options. 
-
-
-  typedef uint64_t options;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/context_base.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:password_purpose ssl::context_base::password_purpose]
-
-[indexterm2 asio.indexterm.ssl__context_base.password_purpose..password_purpose..ssl::context_base] 
-Purpose of PEM password. 
-
-  enum password_purpose
-
-[indexterm2 asio.indexterm.ssl__context_base.password_purpose.for_reading..for_reading..ssl::context_base]
-[indexterm2 asio.indexterm.ssl__context_base.password_purpose.for_writing..for_writing..ssl::context_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [for_reading]
-    [The password is needed for reading/decryption. ]
-  ]
-
-  [
-    [for_writing]
-    [The password is needed for writing/encryption. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:single_dh_use ssl::context_base::single_dh_use]
-
-[indexterm2 asio.indexterm.ssl__context_base.single_dh_use..single_dh_use..ssl::context_base] 
-Always create a new key when using tmp\_dh parameters. 
-
-
-  static const uint64_t single_dh_use = implementation_defined;
-
-
-
-[endsect]
-
-
-
-[section:_context_base ssl::context_base::~context_base]
-
-[indexterm2 asio.indexterm.ssl__context_base._context_base..~context_base..ssl::context_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~context_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ssl__error__get_stream_category ssl::error::get_stream_category]
-
-[indexterm1 asio.indexterm.ssl__error__get_stream_category..ssl::error::get_stream_category]
-
-
-  const asio::error_category & get_stream_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__error__make_error_code ssl::error::make_error_code]
-
-[indexterm1 asio.indexterm.ssl__error__make_error_code..ssl::error::make_error_code]
-
-
-  asio::error_code make_error_code(
-      stream_errors e);
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__error__stream_category ssl::error::stream_category]
-
-[indexterm1 asio.indexterm.ssl__error__stream_category..ssl::error::stream_category]
-
-
-  static const asio::error_category & stream_category = asio::ssl::error::get_stream_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__error__stream_errors ssl::error::stream_errors]
-
-[indexterm1 asio.indexterm.ssl__error__stream_errors..ssl::error::stream_errors]
-
-  enum stream_errors
-
-[indexterm2 asio.indexterm.ssl__error__stream_errors.stream_truncated..stream_truncated..ssl::error::stream_errors]
-[indexterm2 asio.indexterm.ssl__error__stream_errors.unspecified_system_error..unspecified_system_error..ssl::error::stream_errors]
-[indexterm2 asio.indexterm.ssl__error__stream_errors.unexpected_result..unexpected_result..ssl::error::stream_errors]
-
-[heading Values]
-[variablelist
-
-  [
-    [stream_truncated]
-    [The underlying stream closed before the ssl stream gracefully shut down. ]
-  ]
-
-  [
-    [unspecified_system_error]
-    [The underlying SSL library returned a system error without providing further information. ]
-  ]
-
-  [
-    [unexpected_result]
-    [The underlying SSL library generated an unexpected result from a function call. ]
-  ]
-
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-[section:ssl__host_name_verification ssl::host_name_verification]
-
-[indexterm1 asio.indexterm.ssl__host_name_verification..ssl::host_name_verification]
-
-
-Verifies a certificate against a host\_name according to the rules described in RFC 6125. 
-
-
-  class host_name_verification
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__host_name_verification.result_type [*result_type]]]
-    [The type of the function object's result. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__host_name_verification.host_name_verification [*host_name_verification]] [constructor]]
-    [Constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__host_name_verification.operator_lp__rp_ [*operator()]]]
-    [Perform certificate verification. ]
-  ]
-  
-]
-
-
-[heading Example]
-  
-The following example shows how to synchronously open a secure connection to a given host name: 
-
-  using asio::ip::tcp;
-  namespace ssl = asio::ssl;
-  typedef ssl::stream<tcp::socket> ssl_socket;
-
-  // Create a context that uses the default paths for finding CA certificates.
-  ssl::context ctx(ssl::context::sslv23);
-  ctx.set_default_verify_paths();
-
-  // Open a socket and connect it to the remote host.
-  asio::io_context io_context;
-  ssl_socket sock(io_context, ctx);
-  tcp::resolver resolver(io_context);
-  tcp::resolver::query query("host.name", "https");
-  asio::connect(sock.lowest_layer(), resolver.resolve(query));
-  sock.lowest_layer().set_option(tcp::no_delay(true));
-
-  // Perform SSL handshake and verify the remote host's certificate.
-  sock.set_verify_mode(ssl::verify_peer);
-  sock.set_verify_callback(ssl::host_name_verification("host.name"));
-  sock.handshake(ssl_socket::client);
-
-  // ... read and write as normal ...
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/host_name_verification.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:host_name_verification ssl::host_name_verification::host_name_verification]
-
-[indexterm2 asio.indexterm.ssl__host_name_verification.host_name_verification..host_name_verification..ssl::host_name_verification] 
-Constructor. 
-
-
-  host_name_verification(
-      const std::string & host);
-
-
-
-[endsect]
-
-
-
-[section:operator_lp__rp_ ssl::host_name_verification::operator()]
-
-[indexterm2 asio.indexterm.ssl__host_name_verification.operator_lp__rp_..operator()..ssl::host_name_verification] 
-Perform certificate verification. 
-
-
-  bool operator()(
-      bool preverified,
-      verify_context & ctx) const;
-
-
-
-[endsect]
-
-
-
-[section:result_type ssl::host_name_verification::result_type]
-
-[indexterm2 asio.indexterm.ssl__host_name_verification.result_type..result_type..ssl::host_name_verification] 
-The type of the function object's result. 
-
-
-  typedef bool result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/host_name_verification.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__rfc2818_verification ssl::rfc2818_verification]
-
-[indexterm1 asio.indexterm.ssl__rfc2818_verification..ssl::rfc2818_verification]
-
-
-(Deprecated. Use [link asio.reference.ssl__host_name_verification `ssl::host_name_verification`].) Verifies a certificate against a hostname according to the rules described in RFC 2818. 
-
-
-  class rfc2818_verification
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__rfc2818_verification.result_type [*result_type]]]
-    [The type of the function object's result. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__rfc2818_verification.operator_lp__rp_ [*operator()]]]
-    [Perform certificate verification. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__rfc2818_verification.rfc2818_verification [*rfc2818_verification]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-
-[heading Example]
-  
-The following example shows how to synchronously open a secure connection to a given host name: 
-
-  using asio::ip::tcp;
-  namespace ssl = asio::ssl;
-  typedef ssl::stream<tcp::socket> ssl_socket;
-
-  // Create a context that uses the default paths for finding CA certificates.
-  ssl::context ctx(ssl::context::sslv23);
-  ctx.set_default_verify_paths();
-
-  // Open a socket and connect it to the remote host.
-  asio::io_context io_context;
-  ssl_socket sock(io_context, ctx);
-  tcp::resolver resolver(io_context);
-  tcp::resolver::query query("host.name", "https");
-  asio::connect(sock.lowest_layer(), resolver.resolve(query));
-  sock.lowest_layer().set_option(tcp::no_delay(true));
-
-  // Perform SSL handshake and verify the remote host's certificate.
-  sock.set_verify_mode(ssl::verify_peer);
-  sock.set_verify_callback(ssl::rfc2818_verification("host.name"));
-  sock.handshake(ssl_socket::client);
-
-  // ... read and write as normal ...
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/rfc2818_verification.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:operator_lp__rp_ ssl::rfc2818_verification::operator()]
-
-[indexterm2 asio.indexterm.ssl__rfc2818_verification.operator_lp__rp_..operator()..ssl::rfc2818_verification] 
-Perform certificate verification. 
-
-
-  bool operator()(
-      bool preverified,
-      verify_context & ctx) const;
-
-
-
-[endsect]
-
-
-
-[section:result_type ssl::rfc2818_verification::result_type]
-
-[indexterm2 asio.indexterm.ssl__rfc2818_verification.result_type..result_type..ssl::rfc2818_verification] 
-The type of the function object's result. 
-
-
-  typedef bool result_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/rfc2818_verification.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:rfc2818_verification ssl::rfc2818_verification::rfc2818_verification]
-
-[indexterm2 asio.indexterm.ssl__rfc2818_verification.rfc2818_verification..rfc2818_verification..ssl::rfc2818_verification] 
-Constructor. 
-
-
-  rfc2818_verification(
-      const std::string & host);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__stream ssl::stream]
-
-[indexterm1 asio.indexterm.ssl__stream..ssl::stream]
-
-
-Provides stream-oriented functionality using SSL. 
-
-
-  template<
-      typename Stream>
-  class stream :
-    public ssl::stream_base,
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__stream__impl_struct [*impl_struct]]]
-    [Structure for use with deprecated impl_type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__stream.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__stream.handshake_type [*handshake_type]]]
-    [Different handshake types. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__stream.lowest_layer_type [*lowest_layer_type]]]
-    [The type of the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__stream.native_handle_type [*native_handle_type]]]
-    [The native handle type of the SSL stream. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.ssl__stream.next_layer_type [*next_layer_type]]]
-    [The type of the next layer. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__stream.async_handshake [*async_handshake]]]
-    [Start an asynchronous SSL handshake. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.async_shutdown [*async_shutdown]]]
-    [Asynchronously shut down SSL on the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.handshake [*handshake]]]
-    [Perform SSL handshaking. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.native_handle [*native_handle]]]
-    [Get the underlying implementation in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.next_layer [*next_layer]]]
-    [Get a reference to the next layer. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.operator_eq_ [*operator=]]]
-    [Move-assign a stream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.read_some [*read_some]]]
-    [Read some data from the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.set_verify_callback [*set_verify_callback]]]
-    [Set the callback used to verify peer certificates. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.set_verify_depth [*set_verify_depth]]]
-    [Set the peer verification depth. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.set_verify_mode [*set_verify_mode]]]
-    [Set the peer verification mode. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.shutdown [*shutdown]]]
-    [Shut down SSL on the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.stream [*stream]] [constructor]]
-    [Construct a stream. 
-     [hr]
-     Construct a stream from an existing native implementation. 
-     [hr]
-     Move-construct a stream from another. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream.write_some [*write_some]]]
-    [Write some data to the stream. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__stream._stream [*~stream]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The stream class template provides asynchronous and blocking stream-oriented functionality using SSL.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand.
-
-
-[heading Example]
-  
-To use the SSL stream template with an `ip::tcp::socket`, you would write: 
-
-  asio::io_context my_context;
-  asio::ssl::context ctx(asio::ssl::context::sslv23);
-  asio::ssl::stream<asio::ip::tcp::socket> sock(my_context, ctx);
-
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-[section:async_handshake ssl::stream::async_handshake]
-
-[indexterm2 asio.indexterm.ssl__stream.async_handshake..async_handshake..ssl::stream] 
-Start an asynchronous SSL handshake. 
-
-
-  template<
-      typename ``[link asio.reference.HandshakeToken HandshakeToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ssl__stream.async_handshake.overload1 async_handshake]``(
-      handshake_type type,
-      HandshakeToken && token = default_completion_token_t< executor_type >());
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.async_handshake.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.BufferedHandshakeToken BufferedHandshakeToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` ``[link asio.reference.ssl__stream.async_handshake.overload2 async_handshake]``(
-      handshake_type type,
-      const ConstBufferSequence & buffers,
-      BufferedHandshakeToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.async_handshake.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::async_handshake (1 of 2 overloads)]
-
-
-Start an asynchronous SSL handshake. 
-
-
-  template<
-      typename ``[link asio.reference.HandshakeToken HandshakeToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_handshake(
-      handshake_type type,
-      HandshakeToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously perform an SSL handshake on the stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the handshake completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `Stream` type's `async_read_some` and `async_write_some` operations. 
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::async_handshake (2 of 2 overloads)]
-
-
-Start an asynchronous SSL handshake. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.BufferedHandshakeToken BufferedHandshakeToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_handshake(
-      handshake_type type,
-      const ConstBufferSequence & buffers,
-      BufferedHandshakeToken && token = default_completion_token_t< executor_type >(),
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-
-
-This function is used to asynchronously perform an SSL handshake on the stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-[[buffers][The buffered data to be reused for the handshake. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the handshake completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Amount of buffers used in handshake.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `Stream` type's `async_read_some` and `async_write_some` operations. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some ssl::stream::async_read_some]
-
-[indexterm2 asio.indexterm.ssl__stream.async_read_some..async_read_some..ssl::stream] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read one or more bytes of data from the stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `Stream` type's `async_read_some` and `async_write_some` operations. 
-
-
-[endsect]
-
-
-
-[section:async_shutdown ssl::stream::async_shutdown]
-
-[indexterm2 asio.indexterm.ssl__stream.async_shutdown..async_shutdown..ssl::stream] 
-Asynchronously shut down SSL on the stream. 
-
-
-  template<
-      typename ``[link asio.reference.ShutdownToken ShutdownToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_shutdown(
-      ShutdownToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously shut down SSL on the stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the shutdown completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `Stream` type's `async_read_some` and `async_write_some` operations. 
-
-
-[endsect]
-
-
-
-[section:async_write_some ssl::stream::async_write_some]
-
-[indexterm2 asio.indexterm.ssl__stream.async_write_some..async_write_some..ssl::stream] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write one or more bytes of data to the stream. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The async\_write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-if they are also supported by the `Stream` type's `async_read_some` and `async_write_some` operations. 
-
-
-[endsect]
-
-
-
-[section:executor_type ssl::stream::executor_type]
-
-[indexterm2 asio.indexterm.ssl__stream.executor_type..executor_type..ssl::stream] 
-The type of the executor associated with the object. 
-
-
-  typedef lowest_layer_type::executor_type executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor ssl::stream::get_executor]
-
-[indexterm2 asio.indexterm.ssl__stream.get_executor..get_executor..ssl::stream] 
-Get the executor associated with the object. 
-
-
-  executor_type get_executor();
-
-
-This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations.
-
-
-[heading Return Value]
-      
-A copy of the executor that stream will use to dispatch handlers. 
-
-
-
-
-[endsect]
-
-
-[section:handshake ssl::stream::handshake]
-
-[indexterm2 asio.indexterm.ssl__stream.handshake..handshake..ssl::stream] 
-Perform SSL handshaking. 
-
-
-  void ``[link asio.reference.ssl__stream.handshake.overload1 handshake]``(
-      handshake_type type);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.handshake.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__stream.handshake.overload2 handshake]``(
-      handshake_type type,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.handshake.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  void ``[link asio.reference.ssl__stream.handshake.overload3 handshake]``(
-      handshake_type type,
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.handshake.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  void ``[link asio.reference.ssl__stream.handshake.overload4 handshake]``(
-      handshake_type type,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.handshake.overload4 more...]]``
-
-
-[section:overload1 ssl::stream::handshake (1 of 4 overloads)]
-
-
-Perform SSL handshaking. 
-
-
-  void handshake(
-      handshake_type type);
-
-
-This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::handshake (2 of 4 overloads)]
-
-
-Perform SSL handshaking. 
-
-
-  void handshake(
-      handshake_type type,
-      asio::error_code & ec);
-
-
-This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ssl::stream::handshake (3 of 4 overloads)]
-
-
-Perform SSL handshaking. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  void handshake(
-      handshake_type type,
-      const ConstBufferSequence & buffers);
-
-
-This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-[[buffers][The buffered data to be reused for the handshake.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 ssl::stream::handshake (4 of 4 overloads)]
-
-
-Perform SSL handshaking. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  void handshake(
-      handshake_type type,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[type][The type of handshaking to be performed, i.e. as a client or as a server.]]
-
-[[buffers][The buffered data to be reused for the handshake.]]
-
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:handshake_type ssl::stream::handshake_type]
-
-[indexterm2 asio.indexterm.ssl__stream.handshake_type..handshake_type..ssl::stream] 
-Different handshake types. 
-
-  enum handshake_type
-
-[indexterm2 asio.indexterm.ssl__stream.handshake_type.client..client..ssl::stream]
-[indexterm2 asio.indexterm.ssl__stream.handshake_type.server..server..ssl::stream]
-
-[heading Values]
-[variablelist
-
-  [
-    [client]
-    [Perform handshaking as a client. ]
-  ]
-
-  [
-    [server]
-    [Perform handshaking as a server. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-[section:lowest_layer ssl::stream::lowest_layer]
-
-[indexterm2 asio.indexterm.ssl__stream.lowest_layer..lowest_layer..ssl::stream] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.ssl__stream.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.lowest_layer.overload1 more...]]``
-
-  const lowest_layer_type & ``[link asio.reference.ssl__stream.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of stream layers.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::lowest_layer (2 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a reference to the lowest layer in a stack of stream layers.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type ssl::stream::lowest_layer_type]
-
-[indexterm2 asio.indexterm.ssl__stream.lowest_layer_type..lowest_layer_type..ssl::stream] 
-The type of the lowest layer. 
-
-
-  typedef next_layer_type::lowest_layer_type lowest_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle ssl::stream::native_handle]
-
-[indexterm2 asio.indexterm.ssl__stream.native_handle..native_handle..ssl::stream] 
-Get the underlying implementation in the native type. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided.
-
-
-[heading Example]
-  
-The `native_handle()` function returns a pointer of type `SSL*` that is suitable for passing to functions such as `SSL_get_verify_result` and `SSL_get_peer_certificate:` 
-
-  asio::ssl::stream<asio::ip::tcp::socket> sock(io_ctx, ctx);
-
-  // ... establish connection and perform handshake ...
-
-  if (X509* cert = SSL_get_peer_certificate(sock.native_handle()))
-  {
-    if (SSL_get_verify_result(sock.native_handle()) == X509_V_OK)
-    {
-      // ...
-    }
-  }
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:native_handle_type ssl::stream::native_handle_type]
-
-[indexterm2 asio.indexterm.ssl__stream.native_handle_type..native_handle_type..ssl::stream] 
-The native handle type of the SSL stream. 
-
-
-  typedef SSL * native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-[section:next_layer ssl::stream::next_layer]
-
-[indexterm2 asio.indexterm.ssl__stream.next_layer..next_layer..ssl::stream] 
-Get a reference to the next layer. 
-
-
-  const next_layer_type & ``[link asio.reference.ssl__stream.next_layer.overload1 next_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.next_layer.overload1 more...]]``
-
-  next_layer_type & ``[link asio.reference.ssl__stream.next_layer.overload2 next_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.next_layer.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::next_layer (1 of 2 overloads)]
-
-
-Get a reference to the next layer. 
-
-
-  const next_layer_type & next_layer() const;
-
-
-This function returns a reference to the next layer in a stack of stream layers.
-
-
-[heading Return Value]
-      
-A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::next_layer (2 of 2 overloads)]
-
-
-Get a reference to the next layer. 
-
-
-  next_layer_type & next_layer();
-
-
-This function returns a reference to the next layer in a stack of stream layers.
-
-
-[heading Return Value]
-      
-A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:next_layer_type ssl::stream::next_layer_type]
-
-[indexterm2 asio.indexterm.ssl__stream.next_layer_type..next_layer_type..ssl::stream] 
-The type of the next layer. 
-
-
-  typedef remove_reference_t< Stream > next_layer_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:operator_eq_ ssl::stream::operator=]
-
-[indexterm2 asio.indexterm.ssl__stream.operator_eq_..operator=..ssl::stream] 
-Move-assign a stream from another. 
-
-
-  stream & operator=(
-      stream && other);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream object from which the move will occur. Must have no outstanding asynchronous operations associated with it. Following the move, `other` has a valid but unspecified state where the only safe operation is destruction, or use as the target of a move assignment. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:read_some ssl::stream::read_some]
-
-[indexterm2 asio.indexterm.ssl__stream.read_some..read_some..ssl::stream] 
-Read some data from the stream. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.ssl__stream.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.ssl__stream.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.read_some.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::read_some (1 of 2 overloads)]
-
-
-Read some data from the stream. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::read_some (2 of 2 overloads)]
-
-
-Read some data from the stream. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_callback ssl::stream::set_verify_callback]
-
-[indexterm2 asio.indexterm.ssl__stream.set_verify_callback..set_verify_callback..ssl::stream] 
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void ``[link asio.reference.ssl__stream.set_verify_callback.overload1 set_verify_callback]``(
-      VerifyCallback callback);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_callback.overload1 more...]]``
-
-  template<
-      typename VerifyCallback>
-  void ``[link asio.reference.ssl__stream.set_verify_callback.overload2 set_verify_callback]``(
-      VerifyCallback callback,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_callback.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::set_verify_callback (1 of 2 overloads)]
-
-
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void set_verify_callback(
-      VerifyCallback callback);
-
-
-This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for verifying a certificate. The function signature of the handler must be: 
-``
-  bool verify_callback(
-    bool preverified, // True if the certificate passed pre-verification.
-    verify_context& ctx // The peer certificate and other context.
-  ); 
-``
-The return value of the callback is true if the certificate has passed verification, false otherwise.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::set_verify_callback (2 of 2 overloads)]
-
-
-Set the callback used to verify peer certificates. 
-
-
-  template<
-      typename VerifyCallback>
-  void set_verify_callback(
-      VerifyCallback callback,
-      asio::error_code & ec);
-
-
-This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[callback][The function object to be used for verifying a certificate. The function signature of the handler must be: 
-``
-  bool verify_callback(
-    bool preverified, // True if the certificate passed pre-verification.
-    verify_context& ctx // The peer certificate and other context.
-  ); 
-``
-The return value of the callback is true if the certificate has passed verification, false otherwise.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_depth ssl::stream::set_verify_depth]
-
-[indexterm2 asio.indexterm.ssl__stream.set_verify_depth..set_verify_depth..ssl::stream] 
-Set the peer verification depth. 
-
-
-  void ``[link asio.reference.ssl__stream.set_verify_depth.overload1 set_verify_depth]``(
-      int depth);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_depth.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__stream.set_verify_depth.overload2 set_verify_depth]``(
-      int depth,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_depth.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::set_verify_depth (1 of 2 overloads)]
-
-
-Set the peer verification depth. 
-
-
-  void set_verify_depth(
-      int depth);
-
-
-This function may be used to configure the maximum verification depth allowed by the stream.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[depth][Maximum depth for the certificate chain verification that shall be allowed.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify_depth`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::set_verify_depth (2 of 2 overloads)]
-
-
-Set the peer verification depth. 
-
-
-  void set_verify_depth(
-      int depth,
-      asio::error_code & ec);
-
-
-This function may be used to configure the maximum verification depth allowed by the stream.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[depth][Maximum depth for the certificate chain verification that shall be allowed.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify_depth`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:set_verify_mode ssl::stream::set_verify_mode]
-
-[indexterm2 asio.indexterm.ssl__stream.set_verify_mode..set_verify_mode..ssl::stream] 
-Set the peer verification mode. 
-
-
-  void ``[link asio.reference.ssl__stream.set_verify_mode.overload1 set_verify_mode]``(
-      verify_mode v);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_mode.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__stream.set_verify_mode.overload2 set_verify_mode]``(
-      verify_mode v,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.set_verify_mode.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::set_verify_mode (1 of 2 overloads)]
-
-
-Set the peer verification mode. 
-
-
-  void set_verify_mode(
-      verify_mode v);
-
-
-This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[v][A bitmask of peer verification modes. See [link asio.reference.ssl__verify_mode `ssl::verify_mode`] for available values.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::set_verify_mode (2 of 2 overloads)]
-
-
-Set the peer verification mode. 
-
-
-  void set_verify_mode(
-      verify_mode v,
-      asio::error_code & ec);
-
-
-This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[v][A bitmask of peer verification modes. See [link asio.reference.ssl__verify_mode `ssl::verify_mode`] for available values.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-Calls `SSL_set_verify`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:shutdown ssl::stream::shutdown]
-
-[indexterm2 asio.indexterm.ssl__stream.shutdown..shutdown..ssl::stream] 
-Shut down SSL on the stream. 
-
-
-  void ``[link asio.reference.ssl__stream.shutdown.overload1 shutdown]``();
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.shutdown.overload1 more...]]``
-
-  void ``[link asio.reference.ssl__stream.shutdown.overload2 shutdown]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.shutdown.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::shutdown (1 of 2 overloads)]
-
-
-Shut down SSL on the stream. 
-
-
-  void shutdown();
-
-
-This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::shutdown (2 of 2 overloads)]
-
-
-Shut down SSL on the stream. 
-
-
-  void shutdown(
-      asio::error_code & ec);
-
-
-This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:stream ssl::stream::stream]
-
-[indexterm2 asio.indexterm.ssl__stream.stream..stream..ssl::stream] 
-Construct a stream. 
-
-
-  template<
-      typename Arg>
-  ``[link asio.reference.ssl__stream.stream.overload1 stream]``(
-      Arg && arg,
-      context & ctx);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.stream.overload1 more...]]``
-
-
-Construct a stream from an existing native implementation. 
-
-
-  template<
-      typename Arg>
-  ``[link asio.reference.ssl__stream.stream.overload2 stream]``(
-      Arg && arg,
-      native_handle_type handle);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.stream.overload2 more...]]``
-
-
-Move-construct a stream from another. 
-
-
-  ``[link asio.reference.ssl__stream.stream.overload3 stream]``(
-      stream && other);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.stream.overload3 more...]]``
-
-
-[section:overload1 ssl::stream::stream (1 of 3 overloads)]
-
-
-Construct a stream. 
-
-
-  template<
-      typename Arg>
-  stream(
-      Arg && arg,
-      context & ctx);
-
-
-This constructor creates a stream and initialises the underlying stream object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[arg][The argument to be passed to initialise the underlying stream.]]
-
-[[ctx][The SSL context to be used for the stream. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::stream (2 of 3 overloads)]
-
-
-Construct a stream from an existing native implementation. 
-
-
-  template<
-      typename Arg>
-  stream(
-      Arg && arg,
-      native_handle_type handle);
-
-
-This constructor creates a stream and initialises the underlying stream object. On success, ownership of the native implementation is transferred to the stream, and it will be cleaned up when the stream is destroyed.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[arg][The argument to be passed to initialise the underlying stream.]]
-
-[[handle][An existing native SSL implementation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 ssl::stream::stream (3 of 3 overloads)]
-
-
-Move-construct a stream from another. 
-
-
-  stream(
-      stream && other);
-
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream object from which the move will occur. Must have no outstanding asynchronous operations associated with it. Following the move, `other` has a valid but unspecified state where the only safe operation is destruction, or use as the target of a move assignment. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some ssl::stream::write_some]
-
-[indexterm2 asio.indexterm.ssl__stream.write_some..write_some..ssl::stream] 
-Write some data to the stream. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.ssl__stream.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.ssl__stream.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.ssl__stream.write_some.overload2 more...]]``
-
-
-[section:overload1 ssl::stream::write_some (1 of 2 overloads)]
-
-
-Write some data to the stream. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The data to be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 ssl::stream::write_some (2 of 2 overloads)]
-
-
-Write some data to the stream. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][The data to be written to the stream.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_stream ssl::stream::~stream]
-
-[indexterm2 asio.indexterm.ssl__stream._stream..~stream..ssl::stream] 
-Destructor. 
-
-
-  ~stream();
-
-
-
-[heading Remarks]
-      
-A `stream` object must not be destroyed while there are pending asynchronous operations associated with it. 
-
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__stream__impl_struct ssl::stream::impl_struct]
-
-[indexterm1 asio.indexterm.ssl__stream__impl_struct..ssl::stream::impl_struct]
-
-
-Structure for use with deprecated impl\_type. 
-
-
-  struct impl_struct
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__stream__impl_struct.ssl [*ssl]]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:ssl ssl::stream::impl_struct::ssl]
-
-[indexterm2 asio.indexterm.ssl__stream__impl_struct.ssl..ssl..ssl::stream::impl_struct] 
-
-  SSL * ssl;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__stream_base ssl::stream_base]
-
-[indexterm1 asio.indexterm.ssl__stream_base..ssl::stream_base]
-
-
-The [link asio.reference.ssl__stream_base `ssl::stream_base`] class is used as a base for the [link asio.reference.ssl__stream `ssl::stream`] class template so that we have a common place to define various enums. 
-
-
-  class stream_base
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__stream_base.handshake_type [*handshake_type]]]
-    [Different handshake types. ]
-  
-  ]
-
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__stream_base._stream_base [*~stream_base]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/stream_base.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:handshake_type ssl::stream_base::handshake_type]
-
-[indexterm2 asio.indexterm.ssl__stream_base.handshake_type..handshake_type..ssl::stream_base] 
-Different handshake types. 
-
-  enum handshake_type
-
-[indexterm2 asio.indexterm.ssl__stream_base.handshake_type.client..client..ssl::stream_base]
-[indexterm2 asio.indexterm.ssl__stream_base.handshake_type.server..server..ssl::stream_base]
-
-[heading Values]
-[variablelist
-
-  [
-    [client]
-    [Perform handshaking as a client. ]
-  ]
-
-  [
-    [server]
-    [Perform handshaking as a server. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:_stream_base ssl::stream_base::~stream_base]
-
-[indexterm2 asio.indexterm.ssl__stream_base._stream_base..~stream_base..ssl::stream_base] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~stream_base();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ssl__verify_client_once ssl::verify_client_once]
-
-[indexterm1 asio.indexterm.ssl__verify_client_once..ssl::verify_client_once]
-
-Do not request client certificate on renegotiation. Ignored unless [link asio.reference.ssl__verify_peer `ssl::verify_peer`] is set. 
-
-
-  const int verify_client_once = implementation_defined;
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_mode.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-[section:ssl__verify_context ssl::verify_context]
-
-[indexterm1 asio.indexterm.ssl__verify_context..ssl::verify_context]
-
-
-A simple wrapper around the X509\_STORE\_CTX type, used during verification of a peer certificate. 
-
-
-  class verify_context :
-    noncopyable
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.ssl__verify_context.native_handle_type [*native_handle_type]]]
-    [The native handle type of the verification context. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__verify_context.native_handle [*native_handle]]]
-    [Get the underlying implementation in the native type. ]
-  ]
-  
-  [
-    [[link asio.reference.ssl__verify_context.verify_context [*verify_context]] [constructor]]
-    [Constructor. ]
-  ]
-  
-]
-
-
-[heading Remarks]
-      
-The [link asio.reference.ssl__verify_context `ssl::verify_context`] does not own the underlying X509\_STORE\_CTX object. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_context.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:native_handle ssl::verify_context::native_handle]
-
-[indexterm2 asio.indexterm.ssl__verify_context.native_handle..native_handle..ssl::verify_context] 
-Get the underlying implementation in the native type. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type ssl::verify_context::native_handle_type]
-
-[indexterm2 asio.indexterm.ssl__verify_context.native_handle_type..native_handle_type..ssl::verify_context] 
-The native handle type of the verification context. 
-
-
-  typedef X509_STORE_CTX * native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_context.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:verify_context ssl::verify_context::verify_context]
-
-[indexterm2 asio.indexterm.ssl__verify_context.verify_context..verify_context..ssl::verify_context] 
-Constructor. 
-
-
-  verify_context(
-      native_handle_type handle);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:ssl__verify_fail_if_no_peer_cert ssl::verify_fail_if_no_peer_cert]
-
-[indexterm1 asio.indexterm.ssl__verify_fail_if_no_peer_cert..ssl::verify_fail_if_no_peer_cert]
-
-Fail verification if the peer has no certificate. Ignored unless [link asio.reference.ssl__verify_peer `ssl::verify_peer`] is set. 
-
-
-  const int verify_fail_if_no_peer_cert = implementation_defined;
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_mode.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__verify_mode ssl::verify_mode]
-
-[indexterm1 asio.indexterm.ssl__verify_mode..ssl::verify_mode]
-
-Bitmask type for peer verification. 
-
-
-  typedef int verify_mode;
-
-
-
-Possible values are:
-
-
-* [link asio.reference.ssl__verify_none `ssl::verify_none`] 
-
-* [link asio.reference.ssl__verify_peer `ssl::verify_peer`] 
-
-* [link asio.reference.ssl__verify_fail_if_no_peer_cert `ssl::verify_fail_if_no_peer_cert`] 
-
-* [link asio.reference.ssl__verify_client_once `ssl::verify_client_once`] 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_mode.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__verify_none ssl::verify_none]
-
-[indexterm1 asio.indexterm.ssl__verify_none..ssl::verify_none]
-
-No verification. 
-
-
-  const int verify_none = implementation_defined;
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_mode.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:ssl__verify_peer ssl::verify_peer]
-
-[indexterm1 asio.indexterm.ssl__verify_peer..ssl::verify_peer]
-
-Verify the peer. 
-
-
-  const int verify_peer = implementation_defined;
-
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/verify_mode.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[endsect]
-
-
-
-[section:static_thread_pool static_thread_pool]
-
-[indexterm1 asio.indexterm.static_thread_pool..static_thread_pool]
-
-
-  typedef thread_pool static_thread_pool;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.thread_pool__basic_executor_type [*basic_executor_type]]]
-    [Executor implementation type used to submit functions to a thread pool. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.thread_pool.executor_type [*executor_type]]]
-    [Executor used to submit functions to a thread pool. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.thread_pool.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool.attach [*attach]]]
-    [Attaches the current thread to the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.executor [*executor]]]
-    [Obtains the executor associated with the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.get_executor [*get_executor]]]
-    [Obtains the executor associated with the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.join [*join]]]
-    [Joins the threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.stop [*stop]]]
-    [Stops the threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.thread_pool [*thread_pool]] [constructor]]
-    [Constructs a pool with an automatically determined number of threads. 
-     [hr]
-     Constructs a pool with a specified number of threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.wait [*wait]]]
-    [Waits for threads to complete. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool._thread_pool [*~thread_pool]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-The thread pool class is an execution context where functions are permitted to run on one of a fixed number of threads.
-
-
-[heading Submitting tasks to the pool]
-  
-
-
-To submit functions to the thread pool, use the [link asio.reference.dispatch `dispatch`], [link asio.reference.post `post`] or [link asio.reference.defer `defer`] free functions.
-
-For example:
-
-
-
-  void my_task()
-  {
-    ...
-  }
-
-  ...
-
-  // Launch the pool with four threads.
-  asio::thread_pool pool(4);
-
-  // Submit a function to the pool.
-  asio::post(pool, my_task);
-
-  // Submit a lambda object to the pool.
-  asio::post(pool,
-      []()
-      {
-        ...
-      });
-
-  // Wait for all tasks in the pool to complete.
-  pool.join(); 
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/static_thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:steady_timer steady_timer]
-
-[indexterm1 asio.indexterm.steady_timer..steady_timer]
-
-Typedef for a timer based on the steady clock. 
-
-
-  typedef basic_waitable_timer< chrono::steady_clock > steady_timer;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.duration [*duration]]]
-    [The duration type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.time_point [*time_point]]]
-    [The time point type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
-    [The wait traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
-    [Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expiry [*expiry]]]
-    [Get the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use one of the [link asio.reference.steady_timer `steady_timer`], [link asio.reference.system_timer `system_timer`] or [link asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
-
-
-[heading Remarks]
-      
-This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait (C++11): 
-
-  // Construct a timer without setting an expiry time.
-  asio::steady_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_after(std::chrono::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait (C++11): 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::steady_timer timer(my_context,
-      std::chrono::steady_clock::now() + std::chrono::seconds(60));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active waitable timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_after(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-This typedef uses the C++11 `<chrono>` standard library facility, if available. Otherwise, it may use the Boost.Chrono library. To explicitly utilise Boost.Chrono, use the [link asio.reference.basic_waitable_timer `basic_waitable_timer`] template directly: 
-
-  typedef basic_waitable_timer<boost::chrono::steady_clock> timer;
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/steady_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:strand strand]
-
-[indexterm1 asio.indexterm.strand..strand]
-
-
-Provides serialised function invocation for any executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``>
-  class strand
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.strand.inner_executor_type [*inner_executor_type]]]
-    [The type of the underlying executor. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.strand.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.defer [*defer]]]
-    [Request the strand to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.dispatch [*dispatch]]]
-    [Request the strand to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.execute [*execute]]]
-    [Request the strand to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.get_inner_executor [*get_inner_executor]]]
-    [Obtain the underlying executor. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.on_work_finished [*on_work_finished]]]
-    [Inform the strand that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.on_work_started [*on_work_started]]]
-    [Inform the strand that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Converting assignment operator. 
-     [hr]
-     Move assignment operator. 
-     [hr]
-     Converting move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.post [*post]]]
-    [Request the strand to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.prefer [*prefer]]]
-    [Forward a preference to the underlying executor. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.query [*query]]]
-    [Forward a query to the underlying executor. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.require [*require]]]
-    [Forward a requirement to the underlying executor. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the strand is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.strand [*strand]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Construct a strand for the specified executor. 
-     [hr]
-     Copy constructor. 
-     [hr]
-     Converting constructor. 
-     [hr]
-     Move constructor. 
-     [hr]
-     Converting move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.strand._strand [*~strand]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.strand.operator_not__eq_ [*operator!=]]]
-    [Compare two strands for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.strand.operator_eq__eq_ [*operator==]]]
-    [Compare two strands for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:context strand::context]
-
-[indexterm2 asio.indexterm.strand.context..context..strand] 
-Obtain the underlying execution context. 
-
-
-  execution_context & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer strand::defer]
-
-[indexterm2 asio.indexterm.strand.defer..defer..strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void defer(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled by the underlying executor's defer function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch strand::dispatch]
-
-[indexterm2 asio.indexterm.strand.dispatch..dispatch..strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void dispatch(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the strand to execute the given function object on its underlying executor. The function object will be executed inside this function if the strand is not otherwise busy and if the underlying executor's `dispatch()` function is also able to execute the function before returning.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:execute strand::execute]
-
-[indexterm2 asio.indexterm.strand.execute..execute..strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function>
-  constraint_t< traits::execute_member< const Executor &, Function >::is_valid, void > execute(
-      Function && f) const;
-
-
-This function is used to ask the strand to execute the given function object on its underlying executor. The function object will be executed according to the properties of the underlying executor.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:get_inner_executor strand::get_inner_executor]
-
-[indexterm2 asio.indexterm.strand.get_inner_executor..get_inner_executor..strand] 
-Obtain the underlying executor. 
-
-
-  inner_executor_type get_inner_executor() const;
-
-
-
-[endsect]
-
-
-
-[section:inner_executor_type strand::inner_executor_type]
-
-[indexterm2 asio.indexterm.strand.inner_executor_type..inner_executor_type..strand] 
-The type of the underlying executor. 
-
-
-  typedef Executor inner_executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:on_work_finished strand::on_work_finished]
-
-[indexterm2 asio.indexterm.strand.on_work_finished..on_work_finished..strand] 
-Inform the strand that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-The strand delegates this call to its underlying executor. 
-
-
-[endsect]
-
-
-
-[section:on_work_started strand::on_work_started]
-
-[indexterm2 asio.indexterm.strand.on_work_started..on_work_started..strand] 
-Inform the strand that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-The strand delegates this call to its underlying executor. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ strand::operator!=]
-
-[indexterm2 asio.indexterm.strand.operator_not__eq_..operator!=..strand] 
-Compare two strands for inequality. 
-
-
-  bool operator!=(
-      const strand & a,
-      const strand & b);
-
-
-Two strands are equal if they refer to the same ordered, non-concurrent state. 
-
-[heading Requirements]
-
-['Header: ][^asio/strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ strand::operator=]
-
-[indexterm2 asio.indexterm.strand.operator_eq_..operator=..strand] 
-Assignment operator. 
-
-
-  strand & ``[link asio.reference.strand.operator_eq_.overload1 operator=]``(
-      const strand & other);
-  ``  [''''&raquo;''' [link asio.reference.strand.operator_eq_.overload1 more...]]``
-
-
-Converting assignment operator. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand & ``[link asio.reference.strand.operator_eq_.overload2 operator=]``(
-      const strand< OtherExecutor > & other);
-  ``  [''''&raquo;''' [link asio.reference.strand.operator_eq_.overload2 more...]]``
-
-
-Move assignment operator. 
-
-
-  strand & ``[link asio.reference.strand.operator_eq_.overload3 operator=]``(
-      strand && other);
-  ``  [''''&raquo;''' [link asio.reference.strand.operator_eq_.overload3 more...]]``
-
-
-Converting move assignment operator. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand & ``[link asio.reference.strand.operator_eq_.overload4 operator=]``(
-      strand< OtherExecutor > && other);
-  ``  [''''&raquo;''' [link asio.reference.strand.operator_eq_.overload4 more...]]``
-
-
-[section:overload1 strand::operator= (1 of 4 overloads)]
-
-
-Assignment operator. 
-
-
-  strand & operator=(
-      const strand & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 strand::operator= (2 of 4 overloads)]
-
-
-Converting assignment operator. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand & operator=(
-      const strand< OtherExecutor > & other);
-
-
-This assignment operator is only valid if the `OtherExecutor` type is convertible to `Executor`. 
-
-
-[endsect]
-
-
-
-[section:overload3 strand::operator= (3 of 4 overloads)]
-
-
-Move assignment operator. 
-
-
-  strand & operator=(
-      strand && other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 strand::operator= (4 of 4 overloads)]
-
-
-Converting move assignment operator. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand & operator=(
-      strand< OtherExecutor > && other);
-
-
-This assignment operator is only valid if the `OtherExecutor` type is convertible to `Executor`. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ strand::operator==]
-
-[indexterm2 asio.indexterm.strand.operator_eq__eq_..operator==..strand] 
-Compare two strands for equality. 
-
-
-  bool operator==(
-      const strand & a,
-      const strand & b);
-
-
-Two strands are equal if they refer to the same ordered, non-concurrent state. 
-
-[heading Requirements]
-
-['Header: ][^asio/strand.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post strand::post]
-
-[indexterm2 asio.indexterm.strand.post..post..strand] 
-Request the strand to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename Allocator>
-  void post(
-      Function && f,
-      const Allocator & a) const;
-
-
-This function is used to ask the executor to execute the given function object. The function object will never be executed inside this function. Instead, it will be scheduled by the underlying executor's defer function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:prefer strand::prefer]
-
-[indexterm2 asio.indexterm.strand.prefer..prefer..strand] 
-Forward a preference to the underlying executor. 
-
-
-  template<
-      typename Property>
-  constraint_t< can_prefer< const Executor &, Property >::value &&!is_convertible< Property, execution::blocking_t::always_t >::value, strand< decay_t< prefer_result_t< const Executor &, Property > > > > prefer(
-      const Property & p) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.prefer `prefer`] customisation point.
-
-For example: 
-
-  asio::strand<my_executor_type> ex1 = ...;
-  auto ex2 = asio::prefer(ex1,
-      asio::execution::blocking.never); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:query strand::query]
-
-[indexterm2 asio.indexterm.strand.query..query..strand] 
-Forward a query to the underlying executor. 
-
-
-  template<
-      typename Property>
-  constraint_t< can_query< const Executor &, Property >::value, conditional_t< is_convertible< Property, execution::blocking_t >::value, execution::blocking_t, query_result_t< const Executor &, Property > > > query(
-      const Property & p) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  asio::strand<my_executor_type> ex = ...;
-  if (asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.never)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:require strand::require]
-
-[indexterm2 asio.indexterm.strand.require..require..strand] 
-Forward a requirement to the underlying executor. 
-
-
-  template<
-      typename Property>
-  constraint_t< can_require< const Executor &, Property >::value &&!is_convertible< Property, execution::blocking_t::always_t >::value, strand< decay_t< require_result_t< const Executor &, Property > > > > require(
-      const Property & p) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  asio::strand<my_executor_type> ex1 = ...;
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.never); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:running_in_this_thread strand::running_in_this_thread]
-
-[indexterm2 asio.indexterm.strand.running_in_this_thread..running_in_this_thread..strand] 
-Determine whether the strand is running in the current thread. 
-
-
-  bool running_in_this_thread() const;
-
-
-
-[heading Return Value]
-      
-`true` if the current thread is executing a function that was submitted to the strand using `post()`, `dispatch()` or `defer()`. Otherwise returns `false`. 
-
-
-
-
-[endsect]
-
-
-[section:strand strand::strand]
-
-[indexterm2 asio.indexterm.strand.strand..strand..strand] 
-Default constructor. 
-
-
-  ``[link asio.reference.strand.strand.overload1 strand]``();
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload1 more...]]``
-
-
-Construct a strand for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  explicit ``[link asio.reference.strand.strand.overload2 strand]``(
-      const Executor1 & e,
-      constraint_t< conditional_t< !is_same< Executor1, strand >::value, is_convertible< Executor1, Executor >, false_type >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload2 more...]]``
-
-
-Copy constructor. 
-
-
-  ``[link asio.reference.strand.strand.overload3 strand]``(
-      const strand & other);
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload3 more...]]``
-
-
-Converting constructor. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.strand.strand.overload4 strand]``(
-      const strand< OtherExecutor > & other);
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload4 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.strand.strand.overload5 strand]``(
-      strand && other);
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload5 more...]]``
-
-
-Converting move constructor. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  ``[link asio.reference.strand.strand.overload6 strand]``(
-      strand< OtherExecutor > && other);
-  ``  [''''&raquo;''' [link asio.reference.strand.strand.overload6 more...]]``
-
-
-[section:overload1 strand::strand (1 of 6 overloads)]
-
-
-Default constructor. 
-
-
-  strand();
-
-
-This constructor is only valid if the underlying executor type is default constructible. 
-
-
-[endsect]
-
-
-
-[section:overload2 strand::strand (2 of 6 overloads)]
-
-
-Construct a strand for the specified executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  strand(
-      const Executor1 & e,
-      constraint_t< conditional_t< !is_same< Executor1, strand >::value, is_convertible< Executor1, Executor >, false_type >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 strand::strand (3 of 6 overloads)]
-
-
-Copy constructor. 
-
-
-  strand(
-      const strand & other);
-
-
-
-[endsect]
-
-
-
-[section:overload4 strand::strand (4 of 6 overloads)]
-
-
-Converting constructor. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand(
-      const strand< OtherExecutor > & other);
-
-
-This constructor is only valid if the `OtherExecutor` type is convertible to `Executor`. 
-
-
-[endsect]
-
-
-
-[section:overload5 strand::strand (5 of 6 overloads)]
-
-
-Move constructor. 
-
-
-  strand(
-      strand && other);
-
-
-
-[endsect]
-
-
-
-[section:overload6 strand::strand (6 of 6 overloads)]
-
-
-Converting move constructor. 
-
-
-  template<
-      class ``[link asio.reference.Executor1 OtherExecutor]``>
-  strand(
-      strand< OtherExecutor > && other);
-
-
-This constructor is only valid if the `OtherExecutor` type is convertible to `Executor`. 
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_strand strand::~strand]
-
-[indexterm2 asio.indexterm.strand._strand..~strand..strand] 
-Destructor. 
-
-
-  ~strand();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:stream_file stream_file]
-
-[indexterm1 asio.indexterm.stream_file..stream_file]
-
-Typedef for the typical usage of a stream-oriented file. 
-
-
-  typedef basic_stream_file stream_file;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_stream_file__rebind_executor [*rebind_executor]]]
-    [Rebinds the file type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.flags [*flags]]]
-    [A bitmask type (C++ Std \[lib.bitmask.types\]). ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.native_handle_type [*native_handle_type]]]
-    [The native representation of a file. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_stream_file.seek_basis [*seek_basis]]]
-    [Basis for seeking in a file. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.assign [*assign]]]
-    [Assign an existing native file to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.basic_stream_file [*basic_stream_file]] [constructor]]
-    [Construct a basic_stream_file without opening it. 
-     [hr]
-     Construct and open a basic_stream_file. 
-     [hr]
-     Construct a basic_stream_file on an existing native file. 
-     [hr]
-     Move-construct a basic_stream_file from another. 
-     [hr]
-     Move-construct a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.close [*close]]]
-    [Close the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.is_open [*is_open]]]
-    [Determine whether the file is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.native_handle [*native_handle]]]
-    [Get the native file representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.open [*open]]]
-    [Open the file using the specified path. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.operator_eq_ [*operator=]]]
-    [Move-assign a basic_stream_file from another. 
-     [hr]
-     Move-assign a basic_stream_file from a file of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.read_some [*read_some]]]
-    [Read some data from the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.release [*release]]]
-    [Release ownership of the underlying native file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.resize [*resize]]]
-    [Alter the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.seek [*seek]]]
-    [Seek to a position in the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.size [*size]]]
-    [Get the size of the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_all [*sync_all]]]
-    [Synchronise the file to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.sync_data [*sync_data]]]
-    [Synchronise the file data to disk. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file.write_some [*write_some]]]
-    [Write some data to the file. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_stream_file._basic_stream_file [*~basic_stream_file]] [destructor]]
-    [Destroys the file. ]
-  ]
-  
-]
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_stream_file.append [*append]] [static]]
-    [Open the file in append mode. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.create [*create]] [static]]
-    [Create the file if it does not exist. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.exclusive [*exclusive]] [static]]
-    [Ensure a new file is created. Must be combined with create. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_only [*read_only]] [static]]
-    [Open the file for reading. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.read_write [*read_write]] [static]]
-    [Open the file for reading and writing. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.sync_all_on_write [*sync_all_on_write]] [static]]
-    [Open the file so that write operations automatically synchronise the file data and metadata to disk. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.truncate [*truncate]] [static]]
-    [Open the file with any existing contents truncated. ]
-  ]
-
-  [
-    [[link asio.reference.basic_stream_file.write_only [*write_only]] [static]]
-    [Open the file for writing. ]
-  ]
-
-]
-
-The [link asio.reference.basic_stream_file `basic_stream_file`] class template provides asynchronous and blocking stream-oriented file functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/stream_file.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:streambuf streambuf]
-
-[indexterm1 asio.indexterm.streambuf..streambuf]
-
-Typedef for the typical usage of [link asio.reference.basic_streambuf `basic_streambuf`]. 
-
-
-  typedef basic_streambuf streambuf;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_streambuf.const_buffers_type [*const_buffers_type]]]
-    [The type used to represent the input sequence as a list of buffers. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_streambuf.mutable_buffers_type [*mutable_buffers_type]]]
-    [The type used to represent the output sequence as a list of buffers. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.basic_streambuf [*basic_streambuf]] [constructor]]
-    [Construct a basic_streambuf object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.capacity [*capacity]]]
-    [Get the current capacity of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.commit [*commit]]]
-    [Move characters from the output sequence to the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.consume [*consume]]]
-    [Remove characters from the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.data [*data]]]
-    [Get a list of buffers that represents the input sequence. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.max_size [*max_size]]]
-    [Get the maximum size of the basic_streambuf. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.prepare [*prepare]]]
-    [Get a list of buffers that represents the output sequence, with the given size. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.size [*size]]]
-    [Get the size of the input sequence. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_streambuf.overflow [*overflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.reserve [*reserve]]]
-    []
-  ]
-  
-  [
-    [[link asio.reference.basic_streambuf.underflow [*underflow]]]
-    [Override std::streambuf behaviour. ]
-  ]
-  
-]
-
-The `basic_streambuf` class is derived from `std::streambuf` to associate the streambuf's input and output sequences with one or more character arrays. These character arrays are internal to the `basic_streambuf` object, but direct access to the array elements is provided to permit them to be used efficiently with I/O operations. Characters written to the output sequence of a `basic_streambuf` object are appended to the input sequence of the same object.
-
-The `basic_streambuf` class's public interface is intended to permit the following implementation strategies:
-
-
-* A single contiguous character array, which is reallocated as necessary to accommodate changes in the size of the character sequence. This is the implementation approach currently used in Asio.
-
-
-* A sequence of one or more character arrays, where each array is of the same size. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-
-* A sequence of one or more character arrays of varying sizes. Additional character array objects are appended to the sequence to accommodate changes in the size of the character sequence.
-
-The constructor for [link asio.reference.basic_streambuf `basic_streambuf`] accepts a `size_t` argument specifying the maximum of the sum of the sizes of the input sequence and output sequence. During the lifetime of the `basic_streambuf` object, the following invariant holds: 
-
-  size() <= max_size()
-
-
-Any member function that would, if successful, cause the invariant to be violated shall throw an exception of class `std::length_error`.
-
-The constructor for `basic_streambuf` takes an Allocator argument. A copy of this argument is used for any memory allocation performed, by the constructor and by all member functions, during the lifetime of each `basic_streambuf` object.
-
-
-[heading Examples]
-  
-Writing directly from an streambuf to a socket: 
-
-  asio::streambuf b;
-  std::ostream os(&b);
-  os << "Hello, World!\n";
-
-  // try sending some data in input sequence
-  size_t n = sock.send(b.data());
-
-  b.consume(n); // sent data is removed from input sequence
-
-
-
-
-Reading from a socket directly into a streambuf: 
-
-  asio::streambuf b;
-
-  // reserve 512 bytes in output sequence
-  asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
-
-  size_t n = sock.receive(bufs);
-
-  // received data is "committed" from output sequence to input sequence
-  b.commit(n);
-
-  std::istream is(&b);
-  std::string s;
-  is >> s;
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/streambuf.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:system_category system_category]
-
-[indexterm1 asio.indexterm.system_category..system_category]
-
-Returns the error category used for the system errors produced by asio. 
-
-
-  const error_category & system_category();
-
-
-[heading Requirements]
-
-['Header: ][^asio/impl/error_code.ipp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:system_context system_context]
-
-[indexterm1 asio.indexterm.system_context..system_context]
-
-
-The executor context for the system executor. 
-
-
-  class system_context :
-    public execution_context
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.system_context.executor_type [*executor_type]]]
-    [The executor type associated with the context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.system_context.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.system_context.get_executor [*get_executor]]]
-    [Obtain an executor for the context. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context.join [*join]]]
-    [Join all threads in the system thread pool. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context.stop [*stop]]]
-    [Signal all threads in the system thread pool to stop. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context.stopped [*stopped]]]
-    [Determine whether the system thread pool has been stopped. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context._system_context [*~system_context]] [destructor]]
-    [Destructor shuts down all threads in the system thread pool. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.system_context.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.system_context.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/system_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:destroy system_context::destroy]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.system_context.destroy..destroy..system_context] 
-Destroys all services in the context. 
-
-
-  void destroy();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order * of the beginning of service object lifetime, performs `delete static_cast<execution_context::service*>(svc)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:executor_type system_context::executor_type]
-
-[indexterm2 asio.indexterm.system_context.executor_type..executor_type..system_context] 
-The executor type associated with the context. 
-
-
-  typedef basic_system_executor< execution::blocking_t::possibly_t, execution::relationship_t::fork_t, std::allocator< void > > executor_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.defer [*defer]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
-    [Inform the executor that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
-    [Inform the executor that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.post [*post]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query [*query]]]
-    [Query the current value of the allocator property. 
-     [hr]
-     Query the occupancy (recommended number of work items) for the system context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.always property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/system_context.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:fork_event system_context::fork_event]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.system_context.fork_event..fork_event..system_context] 
-Fork-related event notifications. 
-
-  enum fork_event
-
-[indexterm2 asio.indexterm.system_context.fork_event.fork_prepare..fork_prepare..system_context]
-[indexterm2 asio.indexterm.system_context.fork_event.fork_parent..fork_parent..system_context]
-[indexterm2 asio.indexterm.system_context.fork_event.fork_child..fork_child..system_context]
-
-[heading Values]
-[variablelist
-
-  [
-    [fork_prepare]
-    [Notify the context that the process is about to fork. ]
-  ]
-
-  [
-    [fork_parent]
-    [Notify the context that the process has forked and is the parent. ]
-  ]
-
-  [
-    [fork_child]
-    [Notify the context that the process has forked and is the child. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:get_executor system_context::get_executor]
-
-[indexterm2 asio.indexterm.system_context.get_executor..get_executor..system_context] 
-Obtain an executor for the context. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-
-[section:join system_context::join]
-
-[indexterm2 asio.indexterm.system_context.join..join..system_context] 
-Join all threads in the system thread pool. 
-
-
-  void join();
-
-
-
-[endsect]
-
-
-
-[section:notify_fork system_context::notify_fork]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.system_context.notify_fork..notify_fork..system_context] 
-Notify the [link asio.reference.execution_context `execution_context`] of a fork-related event. 
-
-
-  void notify_fork(
-      fork_event event);
-
-
-This function is used to inform the [link asio.reference.execution_context `execution_context`] that the process is about to fork, or has just forked. This allows the [link asio.reference.execution_context `execution_context`], and the services it contains, to perform any necessary housekeeping to ensure correct operation following a fork.
-
-This function must not be called while any other [link asio.reference.execution_context `execution_context`] function, or any function associated with the [link asio.reference.execution_context `execution_context`]'s derived class, is being called in another thread. It is, however, safe to call this function from within a completion handler, provided no other thread is accessing the [link asio.reference.execution_context `execution_context`] or its derived class.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[event][A fork-related event.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the notification fails the [link asio.reference.execution_context `execution_context`] object should no longer be used and should be destroyed.]]
-
-]
-
-
-[heading Example]
-  
-The following code illustrates how to incorporate the `notify_fork()` function: 
-
-  my_execution_context.notify_fork(execution_context::fork_prepare);
-  if (fork() == 0)
-  {
-    // This is the child process.
-    my_execution_context.notify_fork(execution_context::fork_child);
-  }
-  else
-  {
-    // This is the parent process.
-    my_execution_context.notify_fork(execution_context::fork_parent);
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, performs `svc->notify_fork();`. When processing the fork\_prepare event, services are visited in reverse order of the beginning of service object lifetime. Otherwise, services are visited in order of the beginning of service object lifetime. 
-
-
-
-
-[endsect]
-
-
-
-[section:shutdown system_context::shutdown]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.system_context.shutdown..shutdown..system_context] 
-Shuts down all services in the context. 
-
-
-  void shutdown();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order of the beginning of service object lifetime, performs `svc->shutdown()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:stop system_context::stop]
-
-[indexterm2 asio.indexterm.system_context.stop..stop..system_context] 
-Signal all threads in the system thread pool to stop. 
-
-
-  void stop();
-
-
-
-[endsect]
-
-
-
-[section:stopped system_context::stopped]
-
-[indexterm2 asio.indexterm.system_context.stopped..stopped..system_context] 
-Determine whether the system thread pool has been stopped. 
-
-
-  bool stopped() const;
-
-
-
-[endsect]
-
-
-
-[section:_system_context system_context::~system_context]
-
-[indexterm2 asio.indexterm.system_context._system_context..~system_context..system_context] 
-Destructor shuts down all threads in the system thread pool. 
-
-
-  ~system_context();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:system_error system_error]
-
-[indexterm1 asio.indexterm.system_error..system_error]
-
-
-  typedef std::system_error system_error;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/system_error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:system_executor system_executor]
-
-[indexterm1 asio.indexterm.system_executor..system_executor]
-
-An executor that uses arbitrary threads. 
-
-
-  typedef basic_system_executor< execution::blocking_t::possibly_t, execution::relationship_t::fork_t, std::allocator< void > > system_executor;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.basic_system_executor [*basic_system_executor]] [constructor]]
-    [Default constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.defer [*defer]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.dispatch [*dispatch]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_finished [*on_work_finished]]]
-    [Inform the executor that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.on_work_started [*on_work_started]]]
-    [Inform the executor that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.post [*post]]]
-    [Request the system executor to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query [*query]]]
-    [Query the current value of the allocator property. 
-     [hr]
-     Query the occupancy (recommended number of work items) for the system context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.always property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_system_executor.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_system_executor.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
-
-
-The system executor represents an execution context where functions are permitted to run on arbitrary threads. When the blocking.never property is established, the system executor will schedule the function to run on an unspecified system thread pool. When either blocking.possibly or blocking.always is established, the executor invokes the function immediately. 
-
-[heading Requirements]
-
-['Header: ][^asio/system_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:system_timer system_timer]
-
-[indexterm1 asio.indexterm.system_timer..system_timer]
-
-Typedef for a timer based on the system clock. 
-
-
-  typedef basic_waitable_timer< chrono::system_clock > system_timer;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer__rebind_executor [*rebind_executor]]]
-    [Rebinds the timer type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.clock_type [*clock_type]]]
-    [The clock type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.duration [*duration]]]
-    [The duration type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.time_point [*time_point]]]
-    [The time point type of the clock. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_waitable_timer.traits_type [*traits_type]]]
-    [The wait traits type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_waitable_timer.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.basic_waitable_timer [*basic_waitable_timer]] [constructor]]
-    [Constructor. 
-     [hr]
-     Constructor to set a particular expiry time as an absolute time. 
-     [hr]
-     Constructor to set a particular expiry time relative to now. 
-     [hr]
-     Move-construct a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel [*cancel]]]
-    [Cancel any asynchronous operations that are waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancel any asynchronous operations that are waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.cancel_one [*cancel_one]]]
-    [Cancels one asynchronous operation that is waiting on the timer. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Cancels one asynchronous operation that is waiting on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_after [*expires_after]]]
-    [Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_at [*expires_at]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time as an absolute time. 
-     [hr]
-     Set the timer's expiry time as an absolute time. 
-     [hr]
-     (Deprecated: Use non-error_code overload.) Set the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expires_from_now [*expires_from_now]]]
-    [(Deprecated: Use expiry().) Get the timer's expiry time relative to now. 
-     [hr]
-     (Deprecated: Use expires_after().) Set the timer's expiry time relative to now. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.expiry [*expiry]]]
-    [Get the timer's expiry time as an absolute time. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.operator_eq_ [*operator=]]]
-    [Move-assign a basic_waitable_timer from another. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer.wait [*wait]]]
-    [Perform a blocking wait on the timer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_waitable_timer._basic_waitable_timer [*~basic_waitable_timer]] [destructor]]
-    [Destroys the timer. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template provides the ability to perform a blocking or asynchronous wait for a timer to expire.
-
-A waitable timer is always in one of two states: "expired" or "not expired". If the `wait()` or `async_wait()` function is called on an expired timer, the wait operation will complete immediately.
-
-Most applications will use one of the [link asio.reference.steady_timer `steady_timer`], [link asio.reference.system_timer `system_timer`] or [link asio.reference.high_resolution_timer `high_resolution_timer`] typedefs.
-
-
-[heading Remarks]
-      
-This waitable timer functionality is for use with the C++11 standard library's `<chrono>` facility, or with the Boost.Chrono library.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Examples]
-  
-Performing a blocking wait (C++11): 
-
-  // Construct a timer without setting an expiry time.
-  asio::steady_timer timer(my_context);
-
-  // Set an expiry time relative to now.
-  timer.expires_after(std::chrono::seconds(5));
-
-  // Wait for the timer to expire.
-  timer.wait();
-
-
-
-
-
-Performing an asynchronous wait (C++11): 
-
-  void handler(const asio::error_code& error)
-  {
-    if (!error)
-    {
-      // Timer expired.
-    }
-  }
-
-  ...
-
-  // Construct a timer with an absolute expiry time.
-  asio::steady_timer timer(my_context,
-      std::chrono::steady_clock::now() + std::chrono::seconds(60));
-
-  // Start an asynchronous wait.
-  timer.async_wait(handler);
-
-
-
-
-
-[heading Changing an active waitable timer's expiry time]
-  
-
-
-Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
-
-
-
-  void on_some_event()
-  {
-    if (my_timer.expires_after(seconds(5)) > 0)
-    {
-      // We managed to cancel the timer. Start new asynchronous wait.
-      my_timer.async_wait(on_timeout);
-    }
-    else
-    {
-      // Too late, timer has already expired!
-    }
-  }
-
-  void on_timeout(const asio::error_code& e)
-  {
-    if (e != asio::error::operation_aborted)
-    {
-      // Timer was not cancelled, take necessary action.
-    }
-  }
-
-
-
-
-
-* The `asio::basic_waitable_timer::expires_after()` function cancels any pending asynchronous waits, and returns the number of asynchronous waits that were cancelled. If it returns 0 then you were too late and the wait handler has already been executed, or will soon be executed. If it returns 1 then the wait handler was successfully cancelled.
-
-
-* If a wait handler is cancelled, the [link asio.reference.error_code `error_code`] passed to it contains the value `asio::error::operation_aborted`. 
-
-
-
-
-This typedef uses the C++11 `<chrono>` standard library facility, if available. Otherwise, it may use the Boost.Chrono library. To explicitly utilise Boost.Chrono, use the [link asio.reference.basic_waitable_timer `basic_waitable_timer`] template directly: 
-
-  typedef basic_waitable_timer<boost::chrono::system_clock> timer;
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/system_timer.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:this_coro__cancellation_state this_coro::cancellation_state]
-
-[indexterm1 asio.indexterm.this_coro__cancellation_state..this_coro::cancellation_state]
-
-Awaitable object that returns the cancellation state of the current coroutine. 
-
-
-  constexpr cancellation_state_t cancellation_state;
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    asio::cancellation_state cs
-      = co_await asio::this_coro::cancellation_state;
-
-    // ...
-
-    if (cs.cancelled() != asio::cancellation_type::none)
-      // ...
-  } 
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:this_coro__cancellation_state_t this_coro::cancellation_state_t]
-
-[indexterm1 asio.indexterm.this_coro__cancellation_state_t..this_coro::cancellation_state_t]
-
-
-Awaitable type that returns the cancellation state of the current coroutine. 
-
-
-  struct cancellation_state_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.this_coro__cancellation_state_t.cancellation_state_t [*cancellation_state_t]] [constructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:cancellation_state_t this_coro::cancellation_state_t::cancellation_state_t]
-
-[indexterm2 asio.indexterm.this_coro__cancellation_state_t.cancellation_state_t..cancellation_state_t..this_coro::cancellation_state_t] 
-
-  constexpr cancellation_state_t();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:this_coro__executor this_coro::executor]
-
-[indexterm1 asio.indexterm.this_coro__executor..this_coro::executor]
-
-Awaitable object that returns the executor of the current coroutine. 
-
-
-  constexpr executor_t executor;
-
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:this_coro__executor_t this_coro::executor_t]
-
-[indexterm1 asio.indexterm.this_coro__executor_t..this_coro::executor_t]
-
-
-Awaitable type that returns the executor of the current coroutine. 
-
-
-  struct executor_t
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.this_coro__executor_t.executor_t [*executor_t]] [constructor]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:executor_t this_coro::executor_t::executor_t]
-
-[indexterm2 asio.indexterm.this_coro__executor_t.executor_t..executor_t..this_coro::executor_t] 
-
-  constexpr executor_t();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:this_coro__reset_cancellation_state this_coro::reset_cancellation_state]
-
-[indexterm1 asio.indexterm.this_coro__reset_cancellation_state..this_coro::reset_cancellation_state]
-
-Returns an awaitable object that may be used to reset the cancellation state of the current coroutine. 
-
-  constexpr unspecified ``[link asio.reference.this_coro__reset_cancellation_state.overload1 reset_cancellation_state]``();
-  ``  [''''&raquo;''' [link asio.reference.this_coro__reset_cancellation_state.overload1 more...]]``
-
-  template<
-      typename Filter>
-  constexpr unspecified ``[link asio.reference.this_coro__reset_cancellation_state.overload2 reset_cancellation_state]``(
-      Filter && filter);
-  ``  [''''&raquo;''' [link asio.reference.this_coro__reset_cancellation_state.overload2 more...]]``
-
-  template<
-      typename InFilter,
-      typename OutFilter>
-  constexpr unspecified ``[link asio.reference.this_coro__reset_cancellation_state.overload3 reset_cancellation_state]``(
-      InFilter && in_filter,
-      OutFilter && out_filter);
-  ``  [''''&raquo;''' [link asio.reference.this_coro__reset_cancellation_state.overload3 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 this_coro::reset_cancellation_state (1 of 3 overloads)]
-
-
-Returns an awaitable object that may be used to reset the cancellation state of the current coroutine. 
-
-
-  constexpr unspecified reset_cancellation_state();
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.co_spawn `co_spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P)`, into the current coroutine's cancellation state object.
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    co_await asio::this_coro::reset_cancellation_state();
-
-    // ...
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-The cancellation state is shared by all coroutines in the same "thread
-of execution" that was created using [link asio.reference.co_spawn `co_spawn`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 this_coro::reset_cancellation_state (2 of 3 overloads)]
-
-
-Returns an awaitable object that may be used to reset the cancellation state of the current coroutine. 
-
-
-  template<
-      typename Filter>
-  constexpr unspecified reset_cancellation_state(
-      Filter && filter);
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.co_spawn `co_spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P,
-std::forward<Filter>(filter))`, into the current coroutine's cancellation state object.
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    co_await asio::this_coro::reset_cancellation_state(
-        asio::enable_partial_cancellation());
-
-    // ...
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-The cancellation state is shared by all coroutines in the same "thread
-of execution" that was created using [link asio.reference.co_spawn `co_spawn`]. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 this_coro::reset_cancellation_state (3 of 3 overloads)]
-
-
-Returns an awaitable object that may be used to reset the cancellation state of the current coroutine. 
-
-
-  template<
-      typename InFilter,
-      typename OutFilter>
-  constexpr unspecified reset_cancellation_state(
-      InFilter && in_filter,
-      OutFilter && out_filter);
-
-
-Let `P` be the cancellation slot associated with the current coroutine's [link asio.reference.co_spawn `co_spawn`] completion handler. Assigns a new [link asio.reference.cancellation_state `cancellation_state`] object `S`, constructed as `S(P, std::forward<InFilter>(in_filter), std::forward<OutFilter>(out_filter))`, into the current coroutine's cancellation state object.
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    co_await asio::this_coro::reset_cancellation_state(
-        asio::enable_partial_cancellation(),
-        asio::disable_cancellation());
-
-    // ...
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-The cancellation state is shared by all coroutines in the same "thread
-of execution" that was created using [link asio.reference.co_spawn `co_spawn`]. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:this_coro__throw_if_cancelled this_coro::throw_if_cancelled]
-
-[indexterm1 asio.indexterm.this_coro__throw_if_cancelled..this_coro::throw_if_cancelled]
-
-Returns an awaitable object that may be used to determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-  constexpr unspecified ``[link asio.reference.this_coro__throw_if_cancelled.overload1 throw_if_cancelled]``();
-  ``  [''''&raquo;''' [link asio.reference.this_coro__throw_if_cancelled.overload1 more...]]``
-
-Returns an awaitable object that may be used to specify whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-  constexpr unspecified ``[link asio.reference.this_coro__throw_if_cancelled.overload2 throw_if_cancelled]``(
-      bool value);
-  ``  [''''&raquo;''' [link asio.reference.this_coro__throw_if_cancelled.overload2 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/this_coro.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 this_coro::throw_if_cancelled (1 of 2 overloads)]
-
-
-Returns an awaitable object that may be used to determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  constexpr unspecified throw_if_cancelled();
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    if (co_await asio::this_coro::throw_if_cancelled)
-      // ...
-
-    // ...
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 this_coro::throw_if_cancelled (2 of 2 overloads)]
-
-
-Returns an awaitable object that may be used to specify whether the coroutine throws if trying to suspend when it has been cancelled. 
-
-
-  constexpr unspecified throw_if_cancelled(
-      bool value);
-
-
-
-[heading Example]
-  
-
-
-  asio::awaitable<void> my_coroutine()
-  {
-    co_await asio::this_coro::throw_if_cancelled(false);
-
-    // ...
-  } 
-
-
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:thread thread]
-
-[indexterm1 asio.indexterm.thread..thread]
-
-
-A simple abstraction for starting threads. 
-
-
-  class thread :
-    noncopyable
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread.join [*join]]]
-    [Wait for the thread to exit. ]
-  ]
-  
-  [
-    [[link asio.reference.thread.thread [*thread]] [constructor]]
-    [Start a new thread that executes the supplied function. ]
-  ]
-  
-  [
-    [[link asio.reference.thread._thread [*~thread]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-The [link asio.reference.thread `thread`] class implements the smallest possible subset of the functionality of boost::thread. It is intended to be used only for starting a thread and waiting for it to exit. If more extensive threading capabilities are required, you are strongly advised to use something else.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-[heading Example]
-  
-A typical use of [link asio.reference.thread `thread`] would be to launch a thread to run an [link asio.reference.io_context `io_context`]'s event processing loop:
-
-
-
-
-  asio::io_context io_context;
-  // ...
-  asio::thread t(boost::bind(&asio::io_context::run, &io_context));
-  // ...
-  t.join(); 
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/thread.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:join thread::join]
-
-[indexterm2 asio.indexterm.thread.join..join..thread] 
-Wait for the thread to exit. 
-
-
-  void join();
-
-
-This function will block until the thread has exited.
-
-If this function is not called before the thread object is destroyed, the thread itself will continue to run until completion. You will, however, no longer have the ability to wait for it to exit. 
-
-
-[endsect]
-
-
-
-[section:thread thread::thread]
-
-[indexterm2 asio.indexterm.thread.thread..thread..thread] 
-Start a new thread that executes the supplied function. 
-
-
-  template<
-      typename Function>
-  thread(
-      Function f);
-
-
-This constructor creates a new thread that will execute the given function or function object.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function or function object to be run in the thread. The function signature must be: 
-``
-  void f(); 
-``
-]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:_thread thread::~thread]
-
-[indexterm2 asio.indexterm.thread._thread..~thread..thread] 
-Destructor. 
-
-
-  ~thread();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:thread_pool thread_pool]
-
-[indexterm1 asio.indexterm.thread_pool..thread_pool]
-
-
-A simple fixed-size thread pool. 
-
-
-  class thread_pool :
-    public execution_context
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.thread_pool__basic_executor_type [*basic_executor_type]]]
-    [Executor implementation type used to submit functions to a thread pool. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.thread_pool.executor_type [*executor_type]]]
-    [Executor used to submit functions to a thread pool. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.thread_pool.fork_event [*fork_event]]]
-    [Fork-related event notifications. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool.attach [*attach]]]
-    [Attaches the current thread to the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.executor [*executor]]]
-    [Obtains the executor associated with the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.get_executor [*get_executor]]]
-    [Obtains the executor associated with the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.join [*join]]]
-    [Joins the threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.notify_fork [*notify_fork]]]
-    [Notify the execution_context of a fork-related event. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.stop [*stop]]]
-    [Stops the threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.thread_pool [*thread_pool]] [constructor]]
-    [Constructs a pool with an automatically determined number of threads. 
-     [hr]
-     Constructs a pool with a specified number of threads. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.wait [*wait]]]
-    [Waits for threads to complete. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool._thread_pool [*~thread_pool]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool.destroy [*destroy]]]
-    [Destroys all services in the context. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool.shutdown [*shutdown]]]
-    [Shuts down all services in the context. ]
-  ]
-  
-]
-
-The thread pool class is an execution context where functions are permitted to run on one of a fixed number of threads.
-
-
-[heading Submitting tasks to the pool]
-  
-
-
-To submit functions to the thread pool, use the [link asio.reference.dispatch `dispatch`], [link asio.reference.post `post`] or [link asio.reference.defer `defer`] free functions.
-
-For example:
-
-
-
-  void my_task()
-  {
-    ...
-  }
-
-  ...
-
-  // Launch the pool with four threads.
-  asio::thread_pool pool(4);
-
-  // Submit a function to the pool.
-  asio::post(pool, my_task);
-
-  // Submit a lambda object to the pool.
-  asio::post(pool,
-      []()
-      {
-        ...
-      });
-
-  // Wait for all tasks in the pool to complete.
-  pool.join(); 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:attach thread_pool::attach]
-
-[indexterm2 asio.indexterm.thread_pool.attach..attach..thread_pool] 
-Attaches the current thread to the pool. 
-
-
-  void attach();
-
-
-This function attaches the current thread to the pool so that it may be used for executing submitted function objects. Blocks the calling thread until the pool is stopped or joined and has no outstanding work. 
-
-
-[endsect]
-
-
-
-[section:destroy thread_pool::destroy]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.thread_pool.destroy..destroy..thread_pool] 
-Destroys all services in the context. 
-
-
-  void destroy();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order * of the beginning of service object lifetime, performs `delete static_cast<execution_context::service*>(svc)`. 
-
-
-
-
-[endsect]
-
-
-
-[section:executor thread_pool::executor]
-
-[indexterm2 asio.indexterm.thread_pool.executor..executor..thread_pool] 
-Obtains the executor associated with the pool. 
-
-
-  executor_type executor();
-
-
-
-[endsect]
-
-
-
-[section:executor_type thread_pool::executor_type]
-
-[indexterm2 asio.indexterm.thread_pool.executor_type..executor_type..thread_pool] 
-Executor used to submit functions to a thread pool. 
-
-
-  typedef basic_executor_type< std::allocator< void >, 0 > executor_type;
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.basic_executor_type [*basic_executor_type]] [constructor]]
-    [Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.defer [*defer]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.dispatch [*dispatch]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.on_work_finished [*on_work_finished]]]
-    [Inform the thread pool that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.on_work_started [*on_work_started]]]
-    [Inform the thread pool that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.post [*post]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.query [*query]]]
-    [Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. 
-     [hr]
-     Query the current value of the allocator property. 
-     [hr]
-     Query the occupancy (recommended number of work items) for the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the outstanding_work property. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.always property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the outstanding_work.tracked property. 
-     [hr]
-     Obtain an executor with the outstanding_work.untracked property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the thread pool is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type._basic_executor_type [*~basic_executor_type]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:fork_event thread_pool::fork_event]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.thread_pool.fork_event..fork_event..thread_pool] 
-Fork-related event notifications. 
-
-  enum fork_event
-
-[indexterm2 asio.indexterm.thread_pool.fork_event.fork_prepare..fork_prepare..thread_pool]
-[indexterm2 asio.indexterm.thread_pool.fork_event.fork_parent..fork_parent..thread_pool]
-[indexterm2 asio.indexterm.thread_pool.fork_event.fork_child..fork_child..thread_pool]
-
-[heading Values]
-[variablelist
-
-  [
-    [fork_prepare]
-    [Notify the context that the process is about to fork. ]
-  ]
-
-  [
-    [fork_parent]
-    [Notify the context that the process has forked and is the parent. ]
-  ]
-
-  [
-    [fork_child]
-    [Notify the context that the process has forked and is the child. ]
-  ]
-
-]
-
-
-
-[endsect]
-
-
-
-[section:get_executor thread_pool::get_executor]
-
-[indexterm2 asio.indexterm.thread_pool.get_executor..get_executor..thread_pool] 
-Obtains the executor associated with the pool. 
-
-
-  executor_type get_executor();
-
-
-
-[endsect]
-
-
-
-[section:join thread_pool::join]
-
-[indexterm2 asio.indexterm.thread_pool.join..join..thread_pool] 
-Joins the threads. 
-
-
-  void join();
-
-
-This function blocks until the threads in the pool have completed. If `stop()` is not called prior to `join()`, the `join()` call will wait until the pool has no more outstanding work. 
-
-
-[endsect]
-
-
-
-[section:notify_fork thread_pool::notify_fork]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.thread_pool.notify_fork..notify_fork..thread_pool] 
-Notify the [link asio.reference.execution_context `execution_context`] of a fork-related event. 
-
-
-  void notify_fork(
-      fork_event event);
-
-
-This function is used to inform the [link asio.reference.execution_context `execution_context`] that the process is about to fork, or has just forked. This allows the [link asio.reference.execution_context `execution_context`], and the services it contains, to perform any necessary housekeeping to ensure correct operation following a fork.
-
-This function must not be called while any other [link asio.reference.execution_context `execution_context`] function, or any function associated with the [link asio.reference.execution_context `execution_context`]'s derived class, is being called in another thread. It is, however, safe to call this function from within a completion handler, provided no other thread is accessing the [link asio.reference.execution_context `execution_context`] or its derived class.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[event][A fork-related event.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. If the notification fails the [link asio.reference.execution_context `execution_context`] object should no longer be used and should be destroyed.]]
-
-]
-
-
-[heading Example]
-  
-The following code illustrates how to incorporate the `notify_fork()` function: 
-
-  my_execution_context.notify_fork(execution_context::fork_prepare);
-  if (fork() == 0)
-  {
-    // This is the child process.
-    my_execution_context.notify_fork(execution_context::fork_child);
-  }
-  else
-  {
-    // This is the parent process.
-    my_execution_context.notify_fork(execution_context::fork_parent);
-  } 
-
-
-
-
-
-[heading Remarks]
-      
-For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, performs `svc->notify_fork();`. When processing the fork\_prepare event, services are visited in reverse order of the beginning of service object lifetime. Otherwise, services are visited in order of the beginning of service object lifetime. 
-
-
-
-
-[endsect]
-
-
-
-[section:shutdown thread_pool::shutdown]
-
-
-['Inherited from execution_context.]
-
-[indexterm2 asio.indexterm.thread_pool.shutdown..shutdown..thread_pool] 
-Shuts down all services in the context. 
-
-
-  void shutdown();
-
-
-This function is implemented as follows:
-
-
-* For each service object `svc` in the [link asio.reference.execution_context `execution_context`] set, in reverse order of the beginning of service object lifetime, performs `svc->shutdown()`. 
-
-
-
-
-[endsect]
-
-
-
-[section:stop thread_pool::stop]
-
-[indexterm2 asio.indexterm.thread_pool.stop..stop..thread_pool] 
-Stops the threads. 
-
-
-  void stop();
-
-
-This function stops the threads as soon as possible. As a result of calling `stop()`, pending function objects may be never be invoked. 
-
-
-[endsect]
-
-
-[section:thread_pool thread_pool::thread_pool]
-
-[indexterm2 asio.indexterm.thread_pool.thread_pool..thread_pool..thread_pool] 
-Constructs a pool with an automatically determined number of threads. 
-
-
-  ``[link asio.reference.thread_pool.thread_pool.overload1 thread_pool]``();
-  ``  [''''&raquo;''' [link asio.reference.thread_pool.thread_pool.overload1 more...]]``
-
-
-Constructs a pool with a specified number of threads. 
-
-
-  ``[link asio.reference.thread_pool.thread_pool.overload2 thread_pool]``(
-      std::size_t num_threads);
-  ``  [''''&raquo;''' [link asio.reference.thread_pool.thread_pool.overload2 more...]]``
-
-
-[section:overload1 thread_pool::thread_pool (1 of 2 overloads)]
-
-
-Constructs a pool with an automatically determined number of threads. 
-
-
-  thread_pool();
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::thread_pool (2 of 2 overloads)]
-
-
-Constructs a pool with a specified number of threads. 
-
-
-  thread_pool(
-      std::size_t num_threads);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:wait thread_pool::wait]
-
-[indexterm2 asio.indexterm.thread_pool.wait..wait..thread_pool] 
-Waits for threads to complete. 
-
-
-  void wait();
-
-
-This function blocks until the threads in the pool have completed. If `stop()` is not called prior to `wait()`, the `wait()` call will wait until the pool has no more outstanding work. 
-
-
-[endsect]
-
-
-
-[section:_thread_pool thread_pool::~thread_pool]
-
-[indexterm2 asio.indexterm.thread_pool._thread_pool..~thread_pool..thread_pool] 
-Destructor. 
-
-
-  ~thread_pool();
-
-
-Automatically stops and joins the pool, if not explicitly done beforehand. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:thread_pool__basic_executor_type thread_pool::basic_executor_type]
-
-[indexterm1 asio.indexterm.thread_pool__basic_executor_type..thread_pool::basic_executor_type]
-
-
-Executor implementation type used to submit functions to a thread pool. 
-
-
-  template<
-      typename Allocator,
-      unsigned int Bits>
-  class basic_executor_type
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.basic_executor_type [*basic_executor_type]] [constructor]]
-    [Copy constructor. 
-     [hr]
-     Move constructor. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.context [*context]]]
-    [Obtain the underlying execution context. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.defer [*defer]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.dispatch [*dispatch]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.execute [*execute]]]
-    [Execution function. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.on_work_finished [*on_work_finished]]]
-    [Inform the thread pool that some work is no longer outstanding. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.on_work_started [*on_work_started]]]
-    [Inform the thread pool that it has some outstanding work to do. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_eq_ [*operator=]]]
-    [Assignment operator. 
-     [hr]
-     Move assignment operator. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.post [*post]]]
-    [Request the thread pool to invoke the given function object. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.query [*query]]]
-    [Query the current value of the context property. 
-     [hr]
-     Query the current value of the blocking property. 
-     [hr]
-     Query the current value of the relationship property. 
-     [hr]
-     Query the current value of the allocator property. 
-     [hr]
-     Query the occupancy (recommended number of work items) for the pool. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.query__static [*query]] [static]]
-    [Query the current value of the mapping property. 
-     [hr]
-     Query the current value of the outstanding_work property. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.require [*require]]]
-    [Obtain an executor with the blocking.possibly property. 
-     [hr]
-     Obtain an executor with the blocking.always property. 
-     [hr]
-     Obtain an executor with the blocking.never property. 
-     [hr]
-     Obtain an executor with the relationship.fork property. 
-     [hr]
-     Obtain an executor with the relationship.continuation property. 
-     [hr]
-     Obtain an executor with the outstanding_work.tracked property. 
-     [hr]
-     Obtain an executor with the outstanding_work.untracked property. 
-     [hr]
-     Obtain an executor with the specified allocator property. 
-     [hr]
-     Obtain an executor with the default allocator property. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.running_in_this_thread [*running_in_this_thread]]]
-    [Determine whether the thread pool is running in the current thread. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type._basic_executor_type [*~basic_executor_type]] [destructor]]
-    [Destructor. ]
-  ]
-  
-]
-
-[heading Friends]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_not__eq_ [*operator!=]]]
-    [Compare two executors for inequality. ]
-  ]
-  
-  [
-    [[link asio.reference.thread_pool__basic_executor_type.operator_eq__eq_ [*operator==]]]
-    [Compare two executors for equality. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:basic_executor_type thread_pool::basic_executor_type::basic_executor_type]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.basic_executor_type..basic_executor_type..thread_pool::basic_executor_type] 
-Copy constructor. 
-
-
-  ``[link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload1 basic_executor_type]``(
-      const basic_executor_type & other);
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload1 more...]]``
-
-
-Move constructor. 
-
-
-  ``[link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload2 basic_executor_type]``(
-      basic_executor_type && other);
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.basic_executor_type.overload2 more...]]``
-
-
-[section:overload1 thread_pool::basic_executor_type::basic_executor_type (1 of 2 overloads)]
-
-
-Copy constructor. 
-
-
-  basic_executor_type(
-      const basic_executor_type & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::basic_executor_type::basic_executor_type (2 of 2 overloads)]
-
-
-Move constructor. 
-
-
-  basic_executor_type(
-      basic_executor_type && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:context thread_pool::basic_executor_type::context]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.context..context..thread_pool::basic_executor_type] 
-Obtain the underlying execution context. 
-
-
-  thread_pool & context() const;
-
-
-
-[endsect]
-
-
-
-[section:defer thread_pool::basic_executor_type::defer]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.defer..defer..thread_pool::basic_executor_type] 
-Request the thread pool to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void defer(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the thread pool to execute the given function object. The function object will never be executed inside `defer()`. Instead, it will be scheduled to run on the thread pool.
-
-If the current thread belongs to the thread pool, `defer()` will delay scheduling the function object until the current thread returns control to the pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:dispatch thread_pool::basic_executor_type::dispatch]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.dispatch..dispatch..thread_pool::basic_executor_type] 
-Request the thread pool to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void dispatch(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the thread pool to execute the given function object. If the current thread belongs to the pool, `dispatch()` executes the function before returning. Otherwise, the function will be scheduled to run on the thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:execute thread_pool::basic_executor_type::execute]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.execute..execute..thread_pool::basic_executor_type] 
-Execution function. 
-
-
-  template<
-      typename Function>
-  void execute(
-      Function && f) const;
-
-
-
-[endsect]
-
-
-
-[section:on_work_finished thread_pool::basic_executor_type::on_work_finished]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.on_work_finished..on_work_finished..thread_pool::basic_executor_type] 
-Inform the thread pool that some work is no longer outstanding. 
-
-
-  void on_work_finished() const;
-
-
-This function is used to inform the thread pool that some work has finished. Once the count of unfinished work reaches zero, the thread pool's `join()` function is permitted to exit. 
-
-
-[endsect]
-
-
-
-[section:on_work_started thread_pool::basic_executor_type::on_work_started]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.on_work_started..on_work_started..thread_pool::basic_executor_type] 
-Inform the thread pool that it has some outstanding work to do. 
-
-
-  void on_work_started() const;
-
-
-This function is used to inform the thread pool that some work has begun. This ensures that the thread pool's `join()` function will not return while the work is underway. 
-
-
-[endsect]
-
-
-
-[section:operator_not__eq_ thread_pool::basic_executor_type::operator!=]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_not__eq_..operator!=..thread_pool::basic_executor_type] 
-Compare two executors for inequality. 
-
-
-  bool operator!=(
-      const basic_executor_type & a,
-      const basic_executor_type & b);
-
-
-Two executors are equal if they refer to the same underlying thread pool. 
-
-[heading Requirements]
-
-['Header: ][^asio/thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ thread_pool::basic_executor_type::operator=]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_eq_..operator=..thread_pool::basic_executor_type] 
-Assignment operator. 
-
-
-  basic_executor_type & ``[link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload1 operator=]``(
-      const basic_executor_type & other);
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload1 more...]]``
-
-
-Move assignment operator. 
-
-
-  basic_executor_type & ``[link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload2 operator=]``(
-      basic_executor_type && other);
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 thread_pool::basic_executor_type::operator= (1 of 2 overloads)]
-
-
-Assignment operator. 
-
-
-  basic_executor_type & operator=(
-      const basic_executor_type & other);
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::basic_executor_type::operator= (2 of 2 overloads)]
-
-
-Move assignment operator. 
-
-
-  basic_executor_type & operator=(
-      basic_executor_type && other);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_eq__eq_ thread_pool::basic_executor_type::operator==]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.operator_eq__eq_..operator==..thread_pool::basic_executor_type] 
-Compare two executors for equality. 
-
-
-  bool operator==(
-      const basic_executor_type & a,
-      const basic_executor_type & b);
-
-
-Two executors are equal if they refer to the same underlying thread pool. 
-
-[heading Requirements]
-
-['Header: ][^asio/thread_pool.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:post thread_pool::basic_executor_type::post]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.post..post..thread_pool::basic_executor_type] 
-Request the thread pool to invoke the given function object. 
-
-
-  template<
-      typename Function,
-      typename OtherAllocator>
-  void post(
-      Function && f,
-      const OtherAllocator & a) const;
-
-
-This function is used to ask the thread pool to execute the given function object. The function object will never be executed inside `post()`. Instead, it will be scheduled to run on the thread pool.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[f][The function object to be called. The executor will make a copy of the handler object as required. The function signature of the function object must be: 
-``
-  void function(); 
-``
-]]
-
-[[a][An allocator that may be used by the executor to allocate the internal storage needed for function invocation. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[section:query thread_pool::basic_executor_type::query]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.query..query..thread_pool::basic_executor_type] 
-Query the current value of the `context` property. 
-
-
-  thread_pool & ``[link asio.reference.thread_pool__basic_executor_type.query.overload1 query]``(
-      execution::context_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload1 more...]]``
-
-
-Query the current value of the `blocking` property. 
-
-
-  constexpr execution::blocking_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload2 query]``(
-      execution::blocking_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload2 more...]]``
-
-
-Query the current value of the `relationship` property. 
-
-
-  constexpr execution::relationship_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload3 query]``(
-      execution::relationship_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload3 more...]]``
-
-
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator ``[link asio.reference.thread_pool__basic_executor_type.query.overload4 query]``(
-      execution::allocator_t< OtherAllocator > ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload4 more...]]``
-
-  constexpr Allocator ``[link asio.reference.thread_pool__basic_executor_type.query.overload5 query]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload5 more...]]``
-
-
-Query the occupancy (recommended number of work items) for the pool. 
-
-
-  std::size_t ``[link asio.reference.thread_pool__basic_executor_type.query.overload6 query]``(
-      execution::occupancy_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query.overload6 more...]]``
-
-
-[section:overload1 thread_pool::basic_executor_type::query (1 of 6 overloads)]
-
-
-Query the current value of the `context` property. 
-
-
-  thread_pool & query(
-      execution::context_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  asio::thread_pool& pool = asio::query(
-      ex, asio::execution::context); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::basic_executor_type::query (2 of 6 overloads)]
-
-
-Query the current value of the `blocking` property. 
-
-
-  constexpr execution::blocking_t query(
-      execution::blocking_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  if (asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.always)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 thread_pool::basic_executor_type::query (3 of 6 overloads)]
-
-
-Query the current value of the `relationship` property. 
-
-
-  constexpr execution::relationship_t query(
-      execution::relationship_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  if (asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.continuation)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 thread_pool::basic_executor_type::query (4 of 6 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr Allocator query(
-      execution::allocator_t< OtherAllocator > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 thread_pool::basic_executor_type::query (5 of 6 overloads)]
-
-
-Query the current value of the `allocator` property. 
-
-
-  constexpr Allocator query(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  auto alloc = asio::query(ex,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 thread_pool::basic_executor_type::query (6 of 6 overloads)]
-
-
-Query the occupancy (recommended number of work items) for the pool. 
-
-
-  std::size_t query(
-      execution::occupancy_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  std::size_t occupancy = asio::query(
-      ex, asio::execution::occupancy); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:query__static thread_pool::basic_executor_type::query]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.query__static..query..thread_pool::basic_executor_type] 
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t ``[link asio.reference.thread_pool__basic_executor_type.query__static.overload1 query]``(
-      execution::mapping_t );
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query__static.overload1 more...]]``
-
-
-Query the current value of the `outstanding_work` property. 
-
-
-  static constexpr execution::outstanding_work_t ``[link asio.reference.thread_pool__basic_executor_type.query__static.overload2 query]``(
-      execution::outstanding_work_t );
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.query__static.overload2 more...]]``
-
-
-[section:overload1 thread_pool::basic_executor_type::query (1 of 2 overloads)]
-
-
-Query the current value of the `mapping` property. 
-
-
-  static constexpr execution::mapping_t query(
-      execution::mapping_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  if (asio::query(ex, asio::execution::mapping)
-        == asio::execution::mapping.thread)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::basic_executor_type::query (2 of 2 overloads)]
-
-
-Query the current value of the `outstanding_work` property. 
-
-
-  static constexpr execution::outstanding_work_t query(
-      execution::outstanding_work_t );
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.query `query`] customisation point.
-
-For example: 
-
-  auto ex = my_thread_pool.executor();
-  if (asio::query(ex, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.tracked)
-    ... 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:require thread_pool::basic_executor_type::require]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.require..require..thread_pool::basic_executor_type] 
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload1 require]``(
-      execution::blocking_t::possibly_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload1 more...]]``
-
-
-Obtain an executor with the `blocking.always` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload2 require]``(
-      execution::blocking_t::always_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload2 more...]]``
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload3 require]``(
-      execution::blocking_t::never_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload3 more...]]``
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.thread_pool__basic_executor_type.require.overload4 require]``(
-      execution::relationship_t::fork_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload4 more...]]``
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  constexpr basic_executor_type ``[link asio.reference.thread_pool__basic_executor_type.require.overload5 require]``(
-      execution::relationship_t::continuation_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload5 more...]]``
-
-
-Obtain an executor with the `outstanding_work.tracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload6 require]``(
-      execution::outstanding_work_t::tracked_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload6 more...]]``
-
-
-Obtain an executor with the `outstanding_work.untracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > ``[link asio.reference.thread_pool__basic_executor_type.require.overload7 require]``(
-      execution::outstanding_work_t::untracked_t ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload7 more...]]``
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr basic_executor_type< OtherAllocator, Bits > ``[link asio.reference.thread_pool__basic_executor_type.require.overload8 require]``(
-      execution::allocator_t< OtherAllocator > a) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload8 more...]]``
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  constexpr basic_executor_type< std::allocator< void >, Bits > ``[link asio.reference.thread_pool__basic_executor_type.require.overload9 require]``(
-      execution::allocator_t< void > ) const;
-  ``  [''''&raquo;''' [link asio.reference.thread_pool__basic_executor_type.require.overload9 more...]]``
-
-
-[section:overload1 thread_pool::basic_executor_type::require (1 of 9 overloads)]
-
-
-Obtain an executor with the `blocking.possibly` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::blocking_t::possibly_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.possibly); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 thread_pool::basic_executor_type::require (2 of 9 overloads)]
-
-
-Obtain an executor with the `blocking.always` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::blocking_t::always_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.always); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 thread_pool::basic_executor_type::require (3 of 9 overloads)]
-
-
-Obtain an executor with the `blocking.never` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::blocking_t::never_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::blocking.never); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 thread_pool::basic_executor_type::require (4 of 9 overloads)]
-
-
-Obtain an executor with the `relationship.fork` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::relationship_t::fork_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.fork); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 thread_pool::basic_executor_type::require (5 of 9 overloads)]
-
-
-Obtain an executor with the `relationship.continuation` property. 
-
-
-  constexpr basic_executor_type require(
-      execution::relationship_t::continuation_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::relationship.continuation); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 thread_pool::basic_executor_type::require (6 of 9 overloads)]
-
-
-Obtain an executor with the `outstanding_work.tracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::outstanding_work_t::tracked_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::outstanding_work.tracked); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 thread_pool::basic_executor_type::require (7 of 9 overloads)]
-
-
-Obtain an executor with the `outstanding_work.untracked` property. 
-
-
-  constexpr basic_executor_type< Allocator, unspecified > require(
-      execution::outstanding_work_t::untracked_t ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::outstanding_work.untracked); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 thread_pool::basic_executor_type::require (8 of 9 overloads)]
-
-
-Obtain an executor with the specified `allocator` property. 
-
-
-  template<
-      typename OtherAllocator>
-  constexpr basic_executor_type< OtherAllocator, Bits > require(
-      execution::allocator_t< OtherAllocator > a) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator(my_allocator)); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 thread_pool::basic_executor_type::require (9 of 9 overloads)]
-
-
-Obtain an executor with the default `allocator` property. 
-
-
-  constexpr basic_executor_type< std::allocator< void >, Bits > require(
-      execution::allocator_t< void > ) const;
-
-
-Do not call this function directly. It is intended for use with the [link asio.reference.require `require`] customisation point.
-
-For example: 
-
-  auto ex1 = my_thread_pool.executor();
-  auto ex2 = asio::require(ex1,
-      asio::execution::allocator); 
-
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:running_in_this_thread thread_pool::basic_executor_type::running_in_this_thread]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type.running_in_this_thread..running_in_this_thread..thread_pool::basic_executor_type] 
-Determine whether the thread pool is running in the current thread. 
-
-
-  bool running_in_this_thread() const;
-
-
-
-[heading Return Value]
-      
-`true` if the current thread is running the thread pool. Otherwise returns `false`. 
-
-
-
-
-[endsect]
-
-
-
-[section:_basic_executor_type thread_pool::basic_executor_type::~basic_executor_type]
-
-[indexterm2 asio.indexterm.thread_pool__basic_executor_type._basic_executor_type..~basic_executor_type..thread_pool::basic_executor_type] 
-Destructor. 
-
-
-  ~basic_executor_type();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:time_traits time_traits]
-
-[indexterm1 asio.indexterm.time_traits..time_traits]
-
-
-Time traits suitable for use with the deadline timer. 
-
-
-  template<
-      typename Time>
-  struct time_traits
-
-
-[heading Requirements]
-
-['Header: ][^asio/time_traits.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:time_traits_lt__ptime__gt_ time_traits< boost::posix_time::ptime >]
-
-[indexterm1 asio.indexterm.time_traits_lt__ptime__gt_..time_traits< boost::posix_time::ptime >]
-
-
-Time traits specialised for posix\_time. 
-
-
-  template<>
-  struct time_traits< boost::posix_time::ptime >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.time_traits_lt__ptime__gt_.duration_type [*duration_type]]]
-    [The duration type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.time_traits_lt__ptime__gt_.time_type [*time_type]]]
-    [The time type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.time_traits_lt__ptime__gt_.add [*add]] [static]]
-    [Add a duration to a time. ]
-  ]
-  
-  [
-    [[link asio.reference.time_traits_lt__ptime__gt_.less_than [*less_than]] [static]]
-    [Test whether one time is less than another. ]
-  ]
-  
-  [
-    [[link asio.reference.time_traits_lt__ptime__gt_.now [*now]] [static]]
-    [Get the current time. ]
-  ]
-  
-  [
-    [[link asio.reference.time_traits_lt__ptime__gt_.subtract [*subtract]] [static]]
-    [Subtract one time from another. ]
-  ]
-  
-  [
-    [[link asio.reference.time_traits_lt__ptime__gt_.to_posix_duration [*to_posix_duration]] [static]]
-    [Convert to POSIX duration type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/time_traits.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:add time_traits< boost::posix_time::ptime >::add]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.add..add..time_traits< boost::posix_time::ptime >] 
-Add a duration to a time. 
-
-
-  static time_type add(
-      const time_type & t,
-      const duration_type & d);
-
-
-
-[endsect]
-
-
-
-[section:duration_type time_traits< boost::posix_time::ptime >::duration_type]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.duration_type..duration_type..time_traits< boost::posix_time::ptime >] 
-The duration type. 
-
-
-  typedef boost::posix_time::time_duration duration_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/time_traits.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:less_than time_traits< boost::posix_time::ptime >::less_than]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.less_than..less_than..time_traits< boost::posix_time::ptime >] 
-Test whether one time is less than another. 
-
-
-  static bool less_than(
-      const time_type & t1,
-      const time_type & t2);
-
-
-
-[endsect]
-
-
-
-[section:now time_traits< boost::posix_time::ptime >::now]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.now..now..time_traits< boost::posix_time::ptime >] 
-Get the current time. 
-
-
-  static time_type now();
-
-
-
-[endsect]
-
-
-
-[section:subtract time_traits< boost::posix_time::ptime >::subtract]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.subtract..subtract..time_traits< boost::posix_time::ptime >] 
-Subtract one time from another. 
-
-
-  static duration_type subtract(
-      const time_type & t1,
-      const time_type & t2);
-
-
-
-[endsect]
-
-
-
-[section:time_type time_traits< boost::posix_time::ptime >::time_type]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.time_type..time_type..time_traits< boost::posix_time::ptime >] 
-The time type. 
-
-
-  typedef boost::posix_time::ptime time_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/time_traits.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:to_posix_duration time_traits< boost::posix_time::ptime >::to_posix_duration]
-
-[indexterm2 asio.indexterm.time_traits_lt__ptime__gt_.to_posix_duration..to_posix_duration..time_traits< boost::posix_time::ptime >] 
-Convert to POSIX duration type. 
-
-
-  static boost::posix_time::time_duration to_posix_duration(
-      const duration_type & d);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:transfer_all transfer_all]
-
-[indexterm1 asio.indexterm.transfer_all..transfer_all]
-
-Return a completion condition function object that indicates that a read or write operation should continue until all of the data has been transferred, or until an error occurs. 
-
-
-  unspecified transfer_all();
-
-
-This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
-
-
-[heading Example]
-  
-Reading until a buffer is full: 
-
-  boost::array<char, 128> buf;
-  asio::error_code ec;
-  std::size_t n = asio::read(
-      sock, asio::buffer(buf),
-      asio::transfer_all(), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  else
-  {
-    // n == 128
-  }
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/completion_condition.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:transfer_at_least transfer_at_least]
-
-[indexterm1 asio.indexterm.transfer_at_least..transfer_at_least]
-
-Return a completion condition function object that indicates that a read or write operation should continue until a minimum number of bytes has been transferred, or until an error occurs. 
-
-
-  unspecified transfer_at_least(
-      std::size_t minimum);
-
-
-This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
-
-
-[heading Example]
-  
-Reading until a buffer is full or contains at least 64 bytes: 
-
-  boost::array<char, 128> buf;
-  asio::error_code ec;
-  std::size_t n = asio::read(
-      sock, asio::buffer(buf),
-      asio::transfer_at_least(64), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  else
-  {
-    // n >= 64 && n <= 128
-  }
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/completion_condition.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:transfer_exactly transfer_exactly]
-
-[indexterm1 asio.indexterm.transfer_exactly..transfer_exactly]
-
-Return a completion condition function object that indicates that a read or write operation should continue until an exact number of bytes has been transferred, or until an error occurs. 
-
-
-  unspecified transfer_exactly(
-      std::size_t size);
-
-
-This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
-
-
-[heading Example]
-  
-Reading until a buffer is full or contains exactly 64 bytes: 
-
-  boost::array<char, 128> buf;
-  asio::error_code ec;
-  std::size_t n = asio::read(
-      sock, asio::buffer(buf),
-      asio::transfer_exactly(64), ec);
-  if (ec)
-  {
-    // An error occurred.
-  }
-  else
-  {
-    // n == 64
-  }
-
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/completion_condition.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:use_awaitable use_awaitable]
-
-[indexterm1 asio.indexterm.use_awaitable..use_awaitable]
-
-A [link asio.overview.model.completion_tokens completion token] object that represents the currently executing coroutine. 
-
-
-  constexpr use_awaitable_t use_awaitable;
-
-
-See the documentation for [link asio.reference.use_awaitable_t `use_awaitable_t`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/use_awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:use_awaitable_t use_awaitable_t]
-
-[indexterm1 asio.indexterm.use_awaitable_t..use_awaitable_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] that represents the currently executing coroutine. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  struct use_awaitable_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.use_awaitable_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.use_awaitable_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_awaitable_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.use_awaitable_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor used to specify file name, line, and function name. ]
-  ]
-  
-]
-
-The `use_awaitable_t` class, with its value `use_awaitable`, is used to represent the currently executing coroutine. This completion token may be passed as a handler to an asynchronous operation. For example:
-
-
-
-  awaitable<void> my_coroutine()
-  {
-    std::size_t n = co_await my_socket.async_read_some(buffer, use_awaitable);
-    ...
-  } 
-
-
-
-
-When used with co\_await, the initiating function (`async_read_some` in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned. 
-
-[heading Requirements]
-
-['Header: ][^asio/use_awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:as_default_on use_awaitable_t::as_default_on]
-
-[indexterm2 asio.indexterm.use_awaitable_t.as_default_on..as_default_on..use_awaitable_t] 
-Function helper to adapt an I/O object to use `use_awaitable_t` as its default completion token type. 
-
-
-  template<
-      typename T>
-  static decay_t< T >::template rebind_executor< executor_with_default< typenamedecay_t< T >::executor_type > >::other as_default_on(
-      T && object);
-
-
-
-[endsect]
-
-
-
-[section:as_default_on_t use_awaitable_t::as_default_on_t]
-
-[indexterm2 asio.indexterm.use_awaitable_t.as_default_on_t..as_default_on_t..use_awaitable_t] 
-Type alias to adapt an I/O object to use `use_awaitable_t` as its default completion token type. 
-
-
-  typedef typename T::template rebind_executor< executor_with_default< typename T::executor_type > >::other as_default_on_t;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.use_awaitable_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify use_awaitable_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.use_awaitable_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-
-[heading Requirements]
-
-['Header: ][^asio/use_awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:use_awaitable_t use_awaitable_t::use_awaitable_t]
-
-[indexterm2 asio.indexterm.use_awaitable_t.use_awaitable_t..use_awaitable_t..use_awaitable_t] 
-Default constructor. 
-
-
-  constexpr ``[link asio.reference.use_awaitable_t.use_awaitable_t.overload1 use_awaitable_t]``();
-  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t.use_awaitable_t.overload1 more...]]``
-
-
-Constructor used to specify file name, line, and function name. 
-
-
-  constexpr ``[link asio.reference.use_awaitable_t.use_awaitable_t.overload2 use_awaitable_t]``(
-      const char * file_name,
-      int line,
-      const char * function_name);
-  ``  [''''&raquo;''' [link asio.reference.use_awaitable_t.use_awaitable_t.overload2 more...]]``
-
-
-[section:overload1 use_awaitable_t::use_awaitable_t (1 of 2 overloads)]
-
-
-Default constructor. 
-
-
-  constexpr use_awaitable_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 use_awaitable_t::use_awaitable_t (2 of 2 overloads)]
-
-
-Constructor used to specify file name, line, and function name. 
-
-
-  constexpr use_awaitable_t(
-      const char * file_name,
-      int line,
-      const char * function_name);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:use_awaitable_t__executor_with_default use_awaitable_t::executor_with_default]
-
-[indexterm1 asio.indexterm.use_awaitable_t__executor_with_default..use_awaitable_t::executor_with_default]
-
-
-Adapts an executor to add the `use_awaitable_t` completion token as the default. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor]``>
-  struct executor_with_default :
-    public InnerExecutor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.use_awaitable_t__executor_with_default.default_completion_token_type [*default_completion_token_type]]]
-    [Specify use_awaitable_t as the default completion token type. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.use_awaitable_t__executor_with_default.executor_with_default [*executor_with_default]] [constructor]]
-    [Construct the adapted executor from the inner executor type. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/use_awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:default_completion_token_type use_awaitable_t::executor_with_default::default_completion_token_type]
-
-[indexterm2 asio.indexterm.use_awaitable_t__executor_with_default.default_completion_token_type..default_completion_token_type..use_awaitable_t::executor_with_default] 
-Specify `use_awaitable_t` as the default completion token type. 
-
-
-  typedef use_awaitable_t default_completion_token_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.use_awaitable_t.as_default_on_t [*as_default_on_t]]]
-    [Type alias to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.use_awaitable_t__executor_with_default [*executor_with_default]]]
-    [Adapts an executor to add the use_awaitable_t completion token as the default. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.use_awaitable_t.as_default_on [*as_default_on]] [static]]
-    [Function helper to adapt an I/O object to use use_awaitable_t as its default completion token type. ]
-  ]
-  
-  [
-    [[link asio.reference.use_awaitable_t.use_awaitable_t [*use_awaitable_t]] [constructor]]
-    [Default constructor. 
-     [hr]
-     Constructor used to specify file name, line, and function name. ]
-  ]
-  
-]
-
-The `use_awaitable_t` class, with its value `use_awaitable`, is used to represent the currently executing coroutine. This completion token may be passed as a handler to an asynchronous operation. For example:
-
-
-
-  awaitable<void> my_coroutine()
-  {
-    std::size_t n = co_await my_socket.async_read_some(buffer, use_awaitable);
-    ...
-  } 
-
-
-
-
-When used with co\_await, the initiating function (`async_read_some` in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/use_awaitable.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:executor_with_default use_awaitable_t::executor_with_default::executor_with_default]
-
-[indexterm2 asio.indexterm.use_awaitable_t__executor_with_default.executor_with_default..executor_with_default..use_awaitable_t::executor_with_default] 
-Construct the adapted executor from the inner executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 InnerExecutor1]``>
-  executor_with_default(
-      const InnerExecutor1 & ex,
-      constraint_t< conditional_t< !is_same< InnerExecutor1, executor_with_default >::value, is_convertible< InnerExecutor1, InnerExecutor >, false_type >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:use_future use_future]
-
-[indexterm1 asio.indexterm.use_future..use_future]
-
-A [link asio.overview.model.completion_tokens completion token] object that causes an asynchronous operation to return a future. 
-
-
-  constexpr use_future_t use_future;
-
-
-See the documentation for [link asio.reference.use_future_t `use_future_t`] for a usage example. 
-
-[heading Requirements]
-
-['Header: ][^asio/use_future.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:use_future_t use_future_t]
-
-[indexterm1 asio.indexterm.use_future_t..use_future_t]
-
-
-A [link asio.overview.model.completion_tokens completion token] type that causes an asynchronous operation to return a future. 
-
-
-  template<
-      typename Allocator = std::allocator<void>>
-  class use_future_t
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.use_future_t.allocator_type [*allocator_type]]]
-    [The allocator type. The allocator is used when constructing the std::promise object for a given asynchronous operation. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.use_future_t.get_allocator [*get_allocator]]]
-    [Obtain allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.use_future_t.operator_lp__rp_ [*operator()]]]
-    [Wrap a function object in a packaged task. 
-     [hr]
-     ]
-  ]
-  
-  [
-    [[link asio.reference.use_future_t.operator_lb__rb_ [*operator\[\]]]]
-    [(Deprecated: Use rebind().) Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.use_future_t.rebind [*rebind]]]
-    [Specify an alternate allocator. ]
-  ]
-  
-  [
-    [[link asio.reference.use_future_t.use_future_t [*use_future_t]] [constructor]]
-    [Construct using default-constructed allocator. 
-     [hr]
-     Construct using specified allocator. ]
-  ]
-  
-]
-
-The [link asio.reference.use_future_t `use_future_t`] class is a completion token type that is used to indicate that an asynchronous operation should return a std::future object. A [link asio.reference.use_future_t `use_future_t`] object may be passed as a completion token to an asynchronous operation, typically using the special value `asio::use_future`. For example:
-
-
-
-  std::future<std::size_t> my_future
-   = my_socket.async_read_some(my_buffer, asio::use_future); 
-
-
-
-
-The initiating function (async\_read\_some in the above example) returns a future that will receive the result of the operation. If the operation completes with an error\_code indicating failure, it is converted into a system\_error and passed back to the caller via the future. 
-
-[heading Requirements]
-
-['Header: ][^asio/use_future.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:allocator_type use_future_t::allocator_type]
-
-[indexterm2 asio.indexterm.use_future_t.allocator_type..allocator_type..use_future_t] 
-The allocator type. The allocator is used when constructing the `std::promise` object for a given asynchronous operation. 
-
-
-  typedef Allocator allocator_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/use_future.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_allocator use_future_t::get_allocator]
-
-[indexterm2 asio.indexterm.use_future_t.get_allocator..get_allocator..use_future_t] 
-Obtain allocator. 
-
-
-  allocator_type get_allocator() const;
-
-
-
-[endsect]
-
-
-[section:operator_lp__rp_ use_future_t::operator()]
-
-[indexterm2 asio.indexterm.use_future_t.operator_lp__rp_..operator()..use_future_t] 
-Wrap a function object in a packaged task. 
-
-
-  template<
-      typename Function>
-  unspecified ``[link asio.reference.use_future_t.operator_lp__rp_.overload1 operator()]``(
-      Function && f) const;
-  ``  [''''&raquo;''' [link asio.reference.use_future_t.operator_lp__rp_.overload1 more...]]``
-
-
-
-  template<
-      typename Function>
-  detail::packaged_token< decay_t< Function >, Allocator > ``[link asio.reference.use_future_t.operator_lp__rp_.overload2 operator()]``(
-      Function && f) const;
-  ``  [''''&raquo;''' [link asio.reference.use_future_t.operator_lp__rp_.overload2 more...]]``
-
-
-[section:overload1 use_future_t::operator() (1 of 2 overloads)]
-
-
-Wrap a function object in a packaged task. 
-
-
-  template<
-      typename Function>
-  unspecified operator()(
-      Function && f) const;
-
-
-The `package` function is used to adapt a function object as a packaged task. When this adapter is passed as a completion token to an asynchronous operation, the result of the function object is retuned via a std::future.
-
-
-[heading Example]
-  
-
-
-
-
-  std::future<std::size_t> fut =
-    my_socket.async_read_some(buffer,
-      use_future([](asio::error_code ec, std::size_t n)
-        {
-          return ec ? 0 : n;
-        }));
-  ...
-  std::size_t n = fut.get(); 
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 use_future_t::operator() (2 of 2 overloads)]
-
-
-
-  template<
-      typename Function>
-  detail::packaged_token< decay_t< Function >, Allocator > operator()(
-      Function && f) const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:operator_lb__rb_ use_future_t::operator\[\]]
-
-[indexterm2 asio.indexterm.use_future_t.operator_lb__rb_..operator\[\]..use_future_t] 
-(Deprecated: Use `rebind()`.) Specify an alternate allocator. 
-
-
-  template<
-      typename OtherAllocator>
-  use_future_t< OtherAllocator > operator[](
-      const OtherAllocator & allocator) const;
-
-
-
-[endsect]
-
-
-
-[section:rebind use_future_t::rebind]
-
-[indexterm2 asio.indexterm.use_future_t.rebind..rebind..use_future_t] 
-Specify an alternate allocator. 
-
-
-  template<
-      typename OtherAllocator>
-  use_future_t< OtherAllocator > rebind(
-      const OtherAllocator & allocator) const;
-
-
-
-[endsect]
-
-
-[section:use_future_t use_future_t::use_future_t]
-
-[indexterm2 asio.indexterm.use_future_t.use_future_t..use_future_t..use_future_t] 
-Construct using default-constructed allocator. 
-
-
-  constexpr ``[link asio.reference.use_future_t.use_future_t.overload1 use_future_t]``();
-  ``  [''''&raquo;''' [link asio.reference.use_future_t.use_future_t.overload1 more...]]``
-
-
-Construct using specified allocator. 
-
-
-  explicit ``[link asio.reference.use_future_t.use_future_t.overload2 use_future_t]``(
-      const Allocator & allocator);
-  ``  [''''&raquo;''' [link asio.reference.use_future_t.use_future_t.overload2 more...]]``
-
-
-[section:overload1 use_future_t::use_future_t (1 of 2 overloads)]
-
-
-Construct using default-constructed allocator. 
-
-
-  constexpr use_future_t();
-
-
-
-[endsect]
-
-
-
-[section:overload2 use_future_t::use_future_t (2 of 2 overloads)]
-
-
-Construct using specified allocator. 
-
-
-  use_future_t(
-      const Allocator & allocator);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:uses_executor uses_executor]
-
-[indexterm1 asio.indexterm.uses_executor..uses_executor]
-
-
-The [link asio.reference.uses_executor `uses_executor`] trait detects whether a type T has an associated executor that is convertible from type Executor. 
-
-
-  template<
-      typename T,
-      typename ``[link asio.reference.Executor1 Executor]``>
-  struct uses_executor :
-    public false_type
-
-
-Meets the BinaryTypeTrait requirements. The Asio library provides a definition that is derived from false\_type. A program may specialize this template to derive from true\_type for a user-defined type T that can be constructed with an executor, where the first argument of a constructor has type [link asio.reference.executor_arg_t `executor_arg_t`] and the second argument is convertible from type Executor. 
-
-[heading Requirements]
-
-['Header: ][^asio/uses_executor.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-[section:wait_traits wait_traits]
-
-[indexterm1 asio.indexterm.wait_traits..wait_traits]
-
-
-Wait traits suitable for use with the [link asio.reference.basic_waitable_timer `basic_waitable_timer`] class template. 
-
-
-  template<
-      typename Clock>
-  struct wait_traits
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.wait_traits.to_wait_duration [*to_wait_duration]] [static]]
-    [Convert a clock duration into a duration used for waiting. ]
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/wait_traits.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:to_wait_duration wait_traits::to_wait_duration]
-
-[indexterm2 asio.indexterm.wait_traits.to_wait_duration..to_wait_duration..wait_traits] 
-Convert a clock duration into a duration used for waiting. 
-
-
-  static Clock::duration ``[link asio.reference.wait_traits.to_wait_duration.overload1 to_wait_duration]``(
-      const typename Clock::duration & d);
-  ``  [''''&raquo;''' [link asio.reference.wait_traits.to_wait_duration.overload1 more...]]``
-
-  static Clock::duration ``[link asio.reference.wait_traits.to_wait_duration.overload2 to_wait_duration]``(
-      const typename Clock::time_point & t);
-  ``  [''''&raquo;''' [link asio.reference.wait_traits.to_wait_duration.overload2 more...]]``
-
-
-[section:overload1 wait_traits::to_wait_duration (1 of 2 overloads)]
-
-
-Convert a clock duration into a duration used for waiting. 
-
-
-  static Clock::duration to_wait_duration(
-      const typename Clock::duration & d);
-
-
-
-[heading Return Value]
-      
-`d`. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 wait_traits::to_wait_duration (2 of 2 overloads)]
-
-
-Convert a clock duration into a duration used for waiting. 
-
-
-  static Clock::duration to_wait_duration(
-      const typename Clock::time_point & t);
-
-
-
-[heading Return Value]
-      
-`d`. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:windows__basic_object_handle windows::basic_object_handle]
-
-[indexterm1 asio.indexterm.windows__basic_object_handle..windows::basic_object_handle]
-
-
-Provides object-oriented handle functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_object_handle
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An object handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_object_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the object handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.basic_object_handle [*basic_object_handle]] [constructor]]
-    [Construct an object handle without opening it. 
-     [hr]
-     Construct an object handle on an existing native handle. 
-     [hr]
-     Move-construct an object handle from another. 
-     [hr]
-     Move-construct an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.operator_eq_ [*operator=]]]
-    [Move-assign an object handle from another. 
-     [hr]
-     Move-assign an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.wait [*wait]]]
-    [Perform a blocking wait on the object handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_object_handle `windows::basic_object_handle`] class provides asynchronous and blocking object-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign windows::basic_object_handle::assign]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.assign..assign..windows::basic_object_handle] 
-Assign an existing native handle to the handle. 
-
-
-  void ``[link asio.reference.windows__basic_object_handle.assign.overload1 assign]``(
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.assign.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_object_handle.assign.overload2 assign]``(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.assign.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::assign (1 of 2 overloads)]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle);
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::assign (2 of 2 overloads)]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_wait windows::basic_object_handle::async_wait]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.async_wait..async_wait..windows::basic_object_handle] 
-Start an asynchronous wait on the object handle. 
-
-
-  template<
-      typename ``[link asio.reference.WaitToken WaitToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_wait(
-      WaitToken && token = default_completion_token_t< executor_type >());
-
-
-This function is be used to initiate an asynchronous wait against the object handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the wait completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error // Result of operation.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code) 
-
-
-
-
-
-
-
-[endsect]
-
-
-[section:basic_object_handle windows::basic_object_handle::basic_object_handle]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.basic_object_handle..basic_object_handle..windows::basic_object_handle] 
-Construct an object handle without opening it. 
-
-
-  explicit ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload1 basic_object_handle]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload2 basic_object_handle]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload2 more...]]``
-
-
-Construct an object handle on an existing native handle. 
-
-
-  ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload3 basic_object_handle]``(
-      const executor_type & ex,
-      const native_handle_type & native_handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload4 basic_object_handle]``(
-      ExecutionContext & context,
-      const native_handle_type & native_handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload4 more...]]``
-
-
-Move-construct an object handle from another. 
-
-
-  ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload5 basic_object_handle]``(
-      basic_object_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload5 more...]]``
-
-
-Move-construct an object handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.windows__basic_object_handle.basic_object_handle.overload6 basic_object_handle]``(
-      basic_object_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.basic_object_handle.overload6 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::basic_object_handle (1 of 6 overloads)]
-
-
-Construct an object handle without opening it. 
-
-
-  basic_object_handle(
-      const executor_type & ex);
-
-
-This constructor creates an object handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the object handle will use, by default, to dispatch handlers for any asynchronous operations performed on the object handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::basic_object_handle (2 of 6 overloads)]
-
-
-Construct an object handle without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_object_handle(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates an object handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the object handle will use, by default, to dispatch handlers for any asynchronous operations performed on the object handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::basic_object_handle::basic_object_handle (3 of 6 overloads)]
-
-
-Construct an object handle on an existing native handle. 
-
-
-  basic_object_handle(
-      const executor_type & ex,
-      const native_handle_type & native_handle);
-
-
-This constructor creates an object handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the object handle will use, by default, to dispatch handlers for any asynchronous operations performed on the object handle.]]
-
-[[native_handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 windows::basic_object_handle::basic_object_handle (4 of 6 overloads)]
-
-
-Construct an object handle on an existing native handle. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_object_handle(
-      ExecutionContext & context,
-      const native_handle_type & native_handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates an object handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the object handle will use, by default, to dispatch handlers for any asynchronous operations performed on the object handle.]]
-
-[[native_handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 windows::basic_object_handle::basic_object_handle (5 of 6 overloads)]
-
-
-Move-construct an object handle from another. 
-
-
-  basic_object_handle(
-      basic_object_handle && other);
-
-
-This constructor moves an object handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other object handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 windows::basic_object_handle::basic_object_handle (6 of 6 overloads)]
-
-
-Move-construct an object handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_object_handle(
-      basic_object_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves an object handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other object handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel windows::basic_object_handle::cancel]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.cancel..cancel..windows::basic_object_handle] 
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void ``[link asio.reference.windows__basic_object_handle.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_object_handle.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.cancel.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close windows::basic_object_handle::close]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.close..close..windows::basic_object_handle] 
-Close the handle. 
-
-
-  void ``[link asio.reference.windows__basic_object_handle.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.close.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_object_handle.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.close.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::close (1 of 2 overloads)]
-
-
-Close the handle. 
-
-
-  void close();
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::close (2 of 2 overloads)]
-
-
-Close the handle. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type windows::basic_object_handle::executor_type]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.executor_type..executor_type..windows::basic_object_handle] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor windows::basic_object_handle::get_executor]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.get_executor..get_executor..windows::basic_object_handle] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open windows::basic_object_handle::is_open]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.is_open..is_open..windows::basic_object_handle] 
-Determine whether the handle is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer windows::basic_object_handle::lowest_layer]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.lowest_layer..lowest_layer..windows::basic_object_handle] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.windows__basic_object_handle.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.windows__basic_object_handle.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since an object handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since an object handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type windows::basic_object_handle::lowest_layer_type]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.lowest_layer_type..lowest_layer_type..windows::basic_object_handle] 
-An object handle is always the lowest layer. 
-
-
-  typedef basic_object_handle lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An object handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_object_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the object handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.basic_object_handle [*basic_object_handle]] [constructor]]
-    [Construct an object handle without opening it. 
-     [hr]
-     Construct an object handle on an existing native handle. 
-     [hr]
-     Move-construct an object handle from another. 
-     [hr]
-     Move-construct an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.operator_eq_ [*operator=]]]
-    [Move-assign an object handle from another. 
-     [hr]
-     Move-assign an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.wait [*wait]]]
-    [Perform a blocking wait on the object handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_object_handle `windows::basic_object_handle`] class provides asynchronous and blocking object-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle windows::basic_object_handle::native_handle]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.native_handle..native_handle..windows::basic_object_handle] 
-Get the native handle representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type windows::basic_object_handle::native_handle_type]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.native_handle_type..native_handle_type..windows::basic_object_handle] 
-The native representation of a handle. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ windows::basic_object_handle::operator=]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.operator_eq_..operator=..windows::basic_object_handle] 
-Move-assign an object handle from another. 
-
-
-  basic_object_handle & ``[link asio.reference.windows__basic_object_handle.operator_eq_.overload1 operator=]``(
-      basic_object_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.operator_eq_.overload1 more...]]``
-
-
-Move-assign an object handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_object_handle & > ``[link asio.reference.windows__basic_object_handle.operator_eq_.overload2 operator=]``(
-      basic_object_handle< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::operator= (1 of 2 overloads)]
-
-
-Move-assign an object handle from another. 
-
-
-  basic_object_handle & operator=(
-      basic_object_handle && other);
-
-
-This assignment operator moves an object handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other object handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::operator= (2 of 2 overloads)]
-
-
-Move-assign an object handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_object_handle & > operator=(
-      basic_object_handle< Executor1 > && other);
-
-
-This assignment operator moves an object handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other object handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_object_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:wait windows::basic_object_handle::wait]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle.wait..wait..windows::basic_object_handle] 
-Perform a blocking wait on the object handle. 
-
-
-  void ``[link asio.reference.windows__basic_object_handle.wait.overload1 wait]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.wait.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_object_handle.wait.overload2 wait]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_object_handle.wait.overload2 more...]]``
-
-
-[section:overload1 windows::basic_object_handle::wait (1 of 2 overloads)]
-
-
-Perform a blocking wait on the object handle. 
-
-
-  void wait();
-
-
-This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_object_handle::wait (2 of 2 overloads)]
-
-
-Perform a blocking wait on the object handle. 
-
-
-  void wait(
-      asio::error_code & ec);
-
-
-This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:windows__basic_object_handle__rebind_executor windows::basic_object_handle::rebind_executor]
-
-[indexterm1 asio.indexterm.windows__basic_object_handle__rebind_executor..windows::basic_object_handle::rebind_executor]
-
-
-Rebinds the handle type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle__rebind_executor.other [*other]]]
-    [The handle type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other windows::basic_object_handle::rebind_executor::other]
-
-[indexterm2 asio.indexterm.windows__basic_object_handle__rebind_executor.other..other..windows::basic_object_handle::rebind_executor] 
-The handle type when rebound to the specified executor. 
-
-
-  typedef basic_object_handle< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An object handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_object_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the object handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.basic_object_handle [*basic_object_handle]] [constructor]]
-    [Construct an object handle without opening it. 
-     [hr]
-     Construct an object handle on an existing native handle. 
-     [hr]
-     Move-construct an object handle from another. 
-     [hr]
-     Move-construct an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.operator_eq_ [*operator=]]]
-    [Move-assign an object handle from another. 
-     [hr]
-     Move-assign an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.wait [*wait]]]
-    [Perform a blocking wait on the object handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_object_handle `windows::basic_object_handle`] class provides asynchronous and blocking object-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:windows__basic_overlapped_handle windows::basic_overlapped_handle]
-
-[indexterm1 asio.indexterm.windows__basic_overlapped_handle..windows::basic_overlapped_handle]
-
-
-Provides Windows handle functionality for objects that support overlapped I/O. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_overlapped_handle
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign windows::basic_overlapped_handle::assign]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.assign..assign..windows::basic_overlapped_handle] 
-Assign an existing native handle to the handle. 
-
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.assign.overload1 assign]``(
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.assign.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.assign.overload2 assign]``(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.assign.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::assign (1 of 2 overloads)]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle);
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::assign (2 of 2 overloads)]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:basic_overlapped_handle windows::basic_overlapped_handle::basic_overlapped_handle]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.basic_overlapped_handle..basic_overlapped_handle..windows::basic_overlapped_handle] 
-Construct an overlapped handle without opening it. 
-
-
-  explicit ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload1 basic_overlapped_handle]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload2 basic_overlapped_handle]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload2 more...]]``
-
-
-Construct an overlapped handle on an existing native handle. 
-
-
-  ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload3 basic_overlapped_handle]``(
-      const executor_type & ex,
-      const native_handle_type & native_handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload4 basic_overlapped_handle]``(
-      ExecutionContext & context,
-      const native_handle_type & native_handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload4 more...]]``
-
-
-Move-construct an overlapped handle from another. 
-
-
-  ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload5 basic_overlapped_handle]``(
-      basic_overlapped_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload5 more...]]``
-
-
-Move-construct an overlapped handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload6 basic_overlapped_handle]``(
-      basic_overlapped_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle.overload6 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::basic_overlapped_handle (1 of 6 overloads)]
-
-
-Construct an overlapped handle without opening it. 
-
-
-  basic_overlapped_handle(
-      const executor_type & ex);
-
-
-This constructor creates an overlapped handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the overlapped handle will use, by default, to dispatch handlers for any asynchronous operations performed on the overlapped handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::basic_overlapped_handle (2 of 6 overloads)]
-
-
-Construct an overlapped handle without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_overlapped_handle(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates an overlapped handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the overlapped handle will use, by default, to dispatch handlers for any asynchronous operations performed on the overlapped handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::basic_overlapped_handle::basic_overlapped_handle (3 of 6 overloads)]
-
-
-Construct an overlapped handle on an existing native handle. 
-
-
-  basic_overlapped_handle(
-      const executor_type & ex,
-      const native_handle_type & native_handle);
-
-
-This constructor creates an overlapped handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the overlapped handle will use, by default, to dispatch handlers for any asynchronous operations performed on the overlapped handle.]]
-
-[[native_handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 windows::basic_overlapped_handle::basic_overlapped_handle (4 of 6 overloads)]
-
-
-Construct an overlapped handle on an existing native handle. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_overlapped_handle(
-      ExecutionContext & context,
-      const native_handle_type & native_handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates an overlapped handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the overlapped handle will use, by default, to dispatch handlers for any asynchronous operations performed on the overlapped handle.]]
-
-[[native_handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 windows::basic_overlapped_handle::basic_overlapped_handle (5 of 6 overloads)]
-
-
-Move-construct an overlapped handle from another. 
-
-
-  basic_overlapped_handle(
-      basic_overlapped_handle && other);
-
-
-This constructor moves a handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other overlapped handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `overlapped_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 windows::basic_overlapped_handle::basic_overlapped_handle (6 of 6 overloads)]
-
-
-Move-construct an overlapped handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_overlapped_handle(
-      basic_overlapped_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other overlapped handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `overlapped_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel windows::basic_overlapped_handle::cancel]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.cancel..cancel..windows::basic_overlapped_handle] 
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.cancel.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::cancel (1 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::cancel (2 of 2 overloads)]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close windows::basic_overlapped_handle::close]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.close..close..windows::basic_overlapped_handle] 
-Close the handle. 
-
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.close.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_overlapped_handle.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.close.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::close (1 of 2 overloads)]
-
-
-Close the handle. 
-
-
-  void close();
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::close (2 of 2 overloads)]
-
-
-Close the handle. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type windows::basic_overlapped_handle::executor_type]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.executor_type..executor_type..windows::basic_overlapped_handle] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor windows::basic_overlapped_handle::get_executor]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.get_executor..get_executor..windows::basic_overlapped_handle] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open windows::basic_overlapped_handle::is_open]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.is_open..is_open..windows::basic_overlapped_handle] 
-Determine whether the handle is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer windows::basic_overlapped_handle::lowest_layer]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.lowest_layer..lowest_layer..windows::basic_overlapped_handle] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.windows__basic_overlapped_handle.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.windows__basic_overlapped_handle.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::lowest_layer (1 of 2 overloads)]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::lowest_layer (2 of 2 overloads)]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type windows::basic_overlapped_handle::lowest_layer_type]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.lowest_layer_type..lowest_layer_type..windows::basic_overlapped_handle] 
-An overlapped\_handle is always the lowest layer. 
-
-
-  typedef basic_overlapped_handle lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle windows::basic_overlapped_handle::native_handle]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.native_handle..native_handle..windows::basic_overlapped_handle] 
-Get the native handle representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type windows::basic_overlapped_handle::native_handle_type]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.native_handle_type..native_handle_type..windows::basic_overlapped_handle] 
-The native representation of a handle. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ windows::basic_overlapped_handle::operator=]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.operator_eq_..operator=..windows::basic_overlapped_handle] 
-Move-assign an overlapped handle from another. 
-
-
-  basic_overlapped_handle & ``[link asio.reference.windows__basic_overlapped_handle.operator_eq_.overload1 operator=]``(
-      basic_overlapped_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.operator_eq_.overload1 more...]]``
-
-
-Move-assign an overlapped handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_overlapped_handle & > ``[link asio.reference.windows__basic_overlapped_handle.operator_eq_.overload2 operator=]``(
-      basic_overlapped_handle< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::operator= (1 of 2 overloads)]
-
-
-Move-assign an overlapped handle from another. 
-
-
-  basic_overlapped_handle & operator=(
-      basic_overlapped_handle && other);
-
-
-This assignment operator moves a handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other overlapped handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `overlapped_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::operator= (2 of 2 overloads)]
-
-
-Move-assign an overlapped handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_overlapped_handle & > operator=(
-      basic_overlapped_handle< Executor1 > && other);
-
-
-This assignment operator moves a handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other overlapped handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `overlapped_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:release windows::basic_overlapped_handle::release]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle.release..release..windows::basic_overlapped_handle] 
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type ``[link asio.reference.windows__basic_overlapped_handle.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.windows__basic_overlapped_handle.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_overlapped_handle.release.overload2 more...]]``
-
-
-[section:overload1 windows::basic_overlapped_handle::release (1 of 2 overloads)]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_overlapped_handle::release (2 of 2 overloads)]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_basic_overlapped_handle windows::basic_overlapped_handle::~basic_overlapped_handle]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle._basic_overlapped_handle..~basic_overlapped_handle..windows::basic_overlapped_handle] 
-Protected destructor to prevent deletion through this type. 
-
-
-  ~basic_overlapped_handle();
-
-
-This function destroys the handle, cancelling any outstanding asynchronous wait operations associated with the handle as if by calling `cancel`. 
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:windows__basic_overlapped_handle__rebind_executor windows::basic_overlapped_handle::rebind_executor]
-
-[indexterm1 asio.indexterm.windows__basic_overlapped_handle__rebind_executor..windows::basic_overlapped_handle::rebind_executor]
-
-
-Rebinds the handle type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor.other [*other]]]
-    [The handle type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other windows::basic_overlapped_handle::rebind_executor::other]
-
-[indexterm2 asio.indexterm.windows__basic_overlapped_handle__rebind_executor.other..other..windows::basic_overlapped_handle::rebind_executor] 
-The handle type when rebound to the specified executor. 
-
-
-  typedef basic_overlapped_handle< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:windows__basic_random_access_handle windows::basic_random_access_handle]
-
-[indexterm1 asio.indexterm.windows__basic_random_access_handle..windows::basic_random_access_handle]
-
-
-Provides random-access handle functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_random_access_handle :
-    public windows::basic_overlapped_handle< any_io_executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_random_access_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]] [constructor]]
-    [Construct a random-access handle without opening it. 
-     [hr]
-     Construct a random-access handle on an existing native handle. 
-     [hr]
-     Move-construct a random-access handle from another. 
-     [hr]
-     Move-construct a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.operator_eq_ [*operator=]]]
-    [Move-assign a random-access handle from another. 
-     [hr]
-     Move-assign a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_random_access_handle `windows::basic_random_access_handle`] class provides asynchronous and blocking random-access handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign windows::basic_random_access_handle::assign]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.assign..assign..windows::basic_random_access_handle] 
-Assign an existing native handle to the handle. 
-
-
-  void ``[link asio.reference.windows__basic_random_access_handle.assign.overload1 assign]``(
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.assign.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_random_access_handle.assign.overload2 assign]``(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.assign.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::assign (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle);
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::assign (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some_at windows::basic_random_access_handle::async_read_some_at]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.async_read_some_at..async_read_some_at..windows::basic_random_access_handle] 
-Start an asynchronous read at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the random-access handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read_at `async_read_at`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_read_some_at(42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some_at windows::basic_random_access_handle::async_write_some_at]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.async_write_some_at..async_write_some_at..windows::basic_random_access_handle] 
-Start an asynchronous write at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the random-access handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write_at `async_write_at`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_write_some_at(42, asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_random_access_handle windows::basic_random_access_handle::basic_random_access_handle]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.basic_random_access_handle..basic_random_access_handle..windows::basic_random_access_handle] 
-Construct a random-access handle without opening it. 
-
-
-  explicit ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload1 basic_random_access_handle]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload2 basic_random_access_handle]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload2 more...]]``
-
-
-Construct a random-access handle on an existing native handle. 
-
-
-  ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload3 basic_random_access_handle]``(
-      const executor_type & ex,
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload4 basic_random_access_handle]``(
-      ExecutionContext & context,
-      const native_handle_type & handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload4 more...]]``
-
-
-Move-construct a random-access handle from another. 
-
-
-  ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload5 basic_random_access_handle]``(
-      basic_random_access_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload5 more...]]``
-
-
-Move-construct a random-access handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload6 basic_random_access_handle]``(
-      basic_random_access_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.basic_random_access_handle.overload6 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::basic_random_access_handle (1 of 6 overloads)]
-
-
-Construct a random-access handle without opening it. 
-
-
-  basic_random_access_handle(
-      const executor_type & ex);
-
-
-This constructor creates a random-access handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the random-access handle will use, by default, to dispatch handlers for any asynchronous operations performed on the random-access handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::basic_random_access_handle (2 of 6 overloads)]
-
-
-Construct a random-access handle without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_handle(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a random-access handle without opening it. The handle needs to be opened or assigned before data can be written to or read from it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the random-access handle will use, by default, to dispatch handlers for any asynchronous operations performed on the random-access handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::basic_random_access_handle::basic_random_access_handle (3 of 6 overloads)]
-
-
-Construct a random-access handle on an existing native handle. 
-
-
-  basic_random_access_handle(
-      const executor_type & ex,
-      const native_handle_type & handle);
-
-
-This constructor creates a random-access handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the random-access handle will use, by default, to dispatch handlers for any asynchronous operations performed on the random-access handle.]]
-
-[[handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 windows::basic_random_access_handle::basic_random_access_handle (4 of 6 overloads)]
-
-
-Construct a random-access handle on an existing native handle. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_random_access_handle(
-      ExecutionContext & context,
-      const native_handle_type & handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a random-access handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the random-access handle will use, by default, to dispatch handlers for any asynchronous operations performed on the random-access handle.]]
-
-[[handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 windows::basic_random_access_handle::basic_random_access_handle (5 of 6 overloads)]
-
-
-Move-construct a random-access handle from another. 
-
-
-  basic_random_access_handle(
-      basic_random_access_handle && other);
-
-
-This constructor moves a random-access handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other random-access handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 windows::basic_random_access_handle::basic_random_access_handle (6 of 6 overloads)]
-
-
-Move-construct a random-access handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_random_access_handle(
-      basic_random_access_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a random-access handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other random-access handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel windows::basic_random_access_handle::cancel]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.cancel..cancel..windows::basic_random_access_handle] 
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void ``[link asio.reference.windows__basic_random_access_handle.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_random_access_handle.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.cancel.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::cancel (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::cancel (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close windows::basic_random_access_handle::close]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.close..close..windows::basic_random_access_handle] 
-Close the handle. 
-
-
-  void ``[link asio.reference.windows__basic_random_access_handle.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.close.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_random_access_handle.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.close.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::close (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Close the handle. 
-
-
-  void close();
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::close (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Close the handle. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type windows::basic_random_access_handle::executor_type]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.executor_type..executor_type..windows::basic_random_access_handle] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor windows::basic_random_access_handle::get_executor]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.get_executor..get_executor..windows::basic_random_access_handle] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open windows::basic_random_access_handle::is_open]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.is_open..is_open..windows::basic_random_access_handle] 
-Determine whether the handle is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer windows::basic_random_access_handle::lowest_layer]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.lowest_layer..lowest_layer..windows::basic_random_access_handle] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.windows__basic_random_access_handle.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.windows__basic_random_access_handle.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type windows::basic_random_access_handle::lowest_layer_type]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.lowest_layer_type..lowest_layer_type..windows::basic_random_access_handle] 
-An overlapped\_handle is always the lowest layer. 
-
-
-  typedef basic_overlapped_handle lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle windows::basic_random_access_handle::native_handle]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.native_handle..native_handle..windows::basic_random_access_handle] 
-Get the native handle representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type windows::basic_random_access_handle::native_handle_type]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.native_handle_type..native_handle_type..windows::basic_random_access_handle] 
-The native representation of a handle. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ windows::basic_random_access_handle::operator=]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.operator_eq_..operator=..windows::basic_random_access_handle] 
-Move-assign a random-access handle from another. 
-
-
-  basic_random_access_handle & ``[link asio.reference.windows__basic_random_access_handle.operator_eq_.overload1 operator=]``(
-      basic_random_access_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.operator_eq_.overload1 more...]]``
-
-
-Move-assign a random-access handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_random_access_handle & > ``[link asio.reference.windows__basic_random_access_handle.operator_eq_.overload2 operator=]``(
-      basic_random_access_handle< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::operator= (1 of 2 overloads)]
-
-
-Move-assign a random-access handle from another. 
-
-
-  basic_random_access_handle & operator=(
-      basic_random_access_handle && other);
-
-
-This assignment operator moves a random-access handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other random-access handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::operator= (2 of 2 overloads)]
-
-
-Move-assign a random-access handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_random_access_handle & > operator=(
-      basic_random_access_handle< Executor1 > && other);
-
-
-This assignment operator moves a random-access handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other random-access handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_random_access_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some_at windows::basic_random_access_handle::read_some_at]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.read_some_at..read_some_at..windows::basic_random_access_handle] 
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_random_access_handle.read_some_at.overload1 read_some_at]``(
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.read_some_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_random_access_handle.read_some_at.overload2 read_some_at]``(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.read_some_at.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::read_some_at (1 of 2 overloads)]
-
-
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read_at `read_at`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.read_some_at(42, asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::read_some_at (2 of 2 overloads)]
-
-
-Read some data from the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some_at(
-      uint64_t offset,
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be read.]]
-
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read_at `read_at`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:release windows::basic_random_access_handle::release]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.release..release..windows::basic_random_access_handle] 
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type ``[link asio.reference.windows__basic_random_access_handle.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.windows__basic_random_access_handle.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.release.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::release (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::release (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some_at windows::basic_random_access_handle::write_some_at]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle.write_some_at..write_some_at..windows::basic_random_access_handle] 
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_random_access_handle.write_some_at.overload1 write_some_at]``(
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.write_some_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_random_access_handle.write_some_at.overload2 write_some_at]``(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_random_access_handle.write_some_at.overload2 more...]]``
-
-
-[section:overload1 windows::basic_random_access_handle::write_some_at (1 of 2 overloads)]
-
-
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some\_at operation may not write all of the data. Consider using the [link asio.reference.write_at `write_at`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.write_some_at(42, asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_random_access_handle::write_some_at (2 of 2 overloads)]
-
-
-Write some data to the handle at the specified offset. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some_at(
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more data buffers to be written to the handle.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write_at `write_at`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:windows__basic_random_access_handle__rebind_executor windows::basic_random_access_handle::rebind_executor]
-
-[indexterm1 asio.indexterm.windows__basic_random_access_handle__rebind_executor..windows::basic_random_access_handle::rebind_executor]
-
-
-Rebinds the handle type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle__rebind_executor.other [*other]]]
-    [The handle type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other windows::basic_random_access_handle::rebind_executor::other]
-
-[indexterm2 asio.indexterm.windows__basic_random_access_handle__rebind_executor.other..other..windows::basic_random_access_handle::rebind_executor] 
-The handle type when rebound to the specified executor. 
-
-
-  typedef basic_random_access_handle< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_random_access_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]] [constructor]]
-    [Construct a random-access handle without opening it. 
-     [hr]
-     Construct a random-access handle on an existing native handle. 
-     [hr]
-     Move-construct a random-access handle from another. 
-     [hr]
-     Move-construct a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.operator_eq_ [*operator=]]]
-    [Move-assign a random-access handle from another. 
-     [hr]
-     Move-assign a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_random_access_handle `windows::basic_random_access_handle`] class provides asynchronous and blocking random-access handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:windows__basic_stream_handle windows::basic_stream_handle]
-
-[indexterm1 asio.indexterm.windows__basic_stream_handle..windows::basic_stream_handle]
-
-
-Provides stream-oriented handle functionality. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]`` = any_io_executor>
-  class basic_stream_handle :
-    public windows::basic_overlapped_handle< any_io_executor >
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_stream_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]] [constructor]]
-    [Construct a stream handle without opening it. 
-     [hr]
-     Construct a stream handle on an existing native handle. 
-     [hr]
-     Move-construct a stream handle from another. 
-     [hr]
-     Move-construct a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.operator_eq_ [*operator=]]]
-    [Move-assign a stream handle from another. 
-     [hr]
-     Move-assign a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
-    [Read some data from the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
-    [Write some data to the handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_stream_handle `windows::basic_stream_handle`] class provides asynchronous and blocking stream-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-[section:assign windows::basic_stream_handle::assign]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.assign..assign..windows::basic_stream_handle] 
-Assign an existing native handle to the handle. 
-
-
-  void ``[link asio.reference.windows__basic_stream_handle.assign.overload1 assign]``(
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.assign.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_stream_handle.assign.overload2 assign]``(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.assign.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::assign (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle);
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::assign (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Assign an existing native handle to the handle. 
-
-
-  void assign(
-      const native_handle_type & handle,
-      asio::error_code & ec);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:async_read_some windows::basic_stream_handle::async_read_some]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.async_read_some..async_read_some..windows::basic_stream_handle] 
-Start an asynchronous read. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``,
-      typename ``[link asio.reference.ReadToken ReadToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_read_some(
-      const MutableBufferSequence & buffers,
-      ReadToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously read data from the stream handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the read completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes read.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The read operation may not read all of the requested number of bytes. Consider using the [link asio.reference.async_read `async_read`] function if you need to ensure that the requested amount of data is read before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_read_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-
-[section:async_write_some windows::basic_stream_handle::async_write_some]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.async_write_some..async_write_some..windows::basic_stream_handle] 
-Start an asynchronous write. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.WriteToken WriteToken]`` = default_completion_token_t<executor_type>>
-  ``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]`` async_write_some(
-      const ConstBufferSequence & buffers,
-      WriteToken && token = default_completion_token_t< executor_type >());
-
-
-This function is used to asynchronously write data to the stream handle. It is an initiating function for an [link asio.overview.model.async_ops asynchronous operation], and always returns immediately.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the handle. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the completion handler is called.]]
-
-[[token][The [link asio.overview.model.completion_tokens completion token] that will be used to produce a completion handler, which will be called when the write completes. Potential completion tokens include [link asio.reference.use_future `use_future`], [link asio.reference.use_awaitable `use_awaitable`], [link asio.reference.yield_context `yield_context`], or a function object with the correct completion signature. The function signature of the completion handler must be: 
-``
-  void handler(
-    const asio::error_code& error, // Result of operation.
-    std::size_t bytes_transferred // Number of bytes written.
-  ); 
-``
-Regardless of whether the asynchronous operation completes immediately or not, the completion handler will not be invoked from within this function. On immediate completion, invocation of the handler will be performed in a manner equivalent to using [link asio.reference.async_immediate `async_immediate`].]]
-
-]
-
-
-[heading Completion Signature]
-  
-
-
-  void(asio::error_code, std::size_t) 
-
-
-
-
-
-[heading Remarks]
-      
-The write operation may not transmit all of the data to the peer. Consider using the [link asio.reference.async_write `async_write`] function if you need to ensure that all data is written before the asynchronous operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.async_write_some(asio::buffer(data, size), handler);
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Per-Operation Cancellation]
-  
-This asynchronous operation supports cancellation for the following [link asio.reference.cancellation_type `cancellation_type`] values:
-
-
-* `cancellation_type::terminal` 
-
-
-* `cancellation_type::partial` 
-
-
-* `cancellation_type::total` 
-
-
-
-
-[endsect]
-
-
-[section:basic_stream_handle windows::basic_stream_handle::basic_stream_handle]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.basic_stream_handle..basic_stream_handle..windows::basic_stream_handle] 
-Construct a stream handle without opening it. 
-
-
-  explicit ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload1 basic_stream_handle]``(
-      const executor_type & ex);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload1 more...]]``
-
-  template<
-      typename ExecutionContext>
-  explicit ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload2 basic_stream_handle]``(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload2 more...]]``
-
-
-Construct a stream handle on an existing native handle. 
-
-
-  ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload3 basic_stream_handle]``(
-      const executor_type & ex,
-      const native_handle_type & handle);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload3 more...]]``
-
-  template<
-      typename ExecutionContext>
-  ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload4 basic_stream_handle]``(
-      ExecutionContext & context,
-      const native_handle_type & handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload4 more...]]``
-
-
-Move-construct a stream handle from another. 
-
-
-  ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload5 basic_stream_handle]``(
-      basic_stream_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload5 more...]]``
-
-
-Move-construct a stream handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  ``[link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload6 basic_stream_handle]``(
-      basic_stream_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.basic_stream_handle.overload6 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::basic_stream_handle (1 of 6 overloads)]
-
-
-Construct a stream handle without opening it. 
-
-
-  basic_stream_handle(
-      const executor_type & ex);
-
-
-This constructor creates a stream handle without opening it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the stream handle will use, by default, to dispatch handlers for any asynchronous operations performed on the stream handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::basic_stream_handle (2 of 6 overloads)]
-
-
-Construct a stream handle without opening it. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_handle(
-      ExecutionContext & context,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor creates a stream handle without opening it. The handle needs to be opened or assigned before data can be written to or read from it.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the stream handle will use, by default, to dispatch handlers for any asynchronous operations performed on the stream handle. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::basic_stream_handle::basic_stream_handle (3 of 6 overloads)]
-
-
-Construct a stream handle on an existing native handle. 
-
-
-  basic_stream_handle(
-      const executor_type & ex,
-      const native_handle_type & handle);
-
-
-This constructor creates a stream handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ex][The I/O executor that the stream handle will use, by default, to dispatch handlers for any asynchronous operations performed on the stream handle.]]
-
-[[handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 windows::basic_stream_handle::basic_stream_handle (4 of 6 overloads)]
-
-
-Construct a stream handle on an existing native handle. 
-
-
-  template<
-      typename ExecutionContext>
-  basic_stream_handle(
-      ExecutionContext & context,
-      const native_handle_type & handle,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-This constructor creates a stream handle object to hold an existing native handle.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[context][An execution context which provides the I/O executor that the stream handle will use, by default, to dispatch handlers for any asynchronous operations performed on the stream handle.]]
-
-[[handle][The new underlying handle implementation.]]
-
-]
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 windows::basic_stream_handle::basic_stream_handle (5 of 6 overloads)]
-
-
-Move-construct a stream handle from another. 
-
-
-  basic_stream_handle(
-      basic_stream_handle && other);
-
-
-This constructor moves a stream handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 windows::basic_stream_handle::basic_stream_handle (6 of 6 overloads)]
-
-
-Move-construct a stream handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  basic_stream_handle(
-      basic_stream_handle< Executor1 > && other,
-      constraint_t< is_convertible< Executor1, Executor >::value, defaulted_constraint >  = defaulted_constraint());
-
-
-This constructor moves a stream handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:cancel windows::basic_stream_handle::cancel]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.cancel..cancel..windows::basic_stream_handle] 
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void ``[link asio.reference.windows__basic_stream_handle.cancel.overload1 cancel]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.cancel.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_stream_handle.cancel.overload2 cancel]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.cancel.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::cancel (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel();
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::cancel (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Cancel all asynchronous operations associated with the handle. 
-
-
-  void cancel(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous read or write operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:close windows::basic_stream_handle::close]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.close..close..windows::basic_stream_handle] 
-Close the handle. 
-
-
-  void ``[link asio.reference.windows__basic_stream_handle.close.overload1 close]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.close.overload1 more...]]``
-
-  void ``[link asio.reference.windows__basic_stream_handle.close.overload2 close]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.close.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::close (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Close the handle. 
-
-
-  void close();
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::close (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Close the handle. 
-
-
-  void close(
-      asio::error_code & ec);
-
-
-This function is used to close the handle. Any asynchronous read or write operations will be cancelled immediately, and will complete with the `asio::error::operation_aborted` error.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:executor_type windows::basic_stream_handle::executor_type]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.executor_type..executor_type..windows::basic_stream_handle] 
-The type of the executor associated with the object. 
-
-
-  typedef Executor executor_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:get_executor windows::basic_stream_handle::get_executor]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.get_executor..get_executor..windows::basic_stream_handle] 
-Get the executor associated with the object. 
-
-
-  const executor_type & get_executor();
-
-
-
-[endsect]
-
-
-
-[section:is_open windows::basic_stream_handle::is_open]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.is_open..is_open..windows::basic_stream_handle] 
-Determine whether the handle is open. 
-
-
-  bool is_open() const;
-
-
-
-[endsect]
-
-
-[section:lowest_layer windows::basic_stream_handle::lowest_layer]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.lowest_layer..lowest_layer..windows::basic_stream_handle] 
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & ``[link asio.reference.windows__basic_stream_handle.lowest_layer.overload1 lowest_layer]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.lowest_layer.overload1 more...]]``
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & ``[link asio.reference.windows__basic_stream_handle.lowest_layer.overload2 lowest_layer]``() const;
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.lowest_layer.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::lowest_layer (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Get a reference to the lowest layer. 
-
-
-  lowest_layer_type & lowest_layer();
-
-
-This function returns a reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::lowest_layer (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Get a const reference to the lowest layer. 
-
-
-  const lowest_layer_type & lowest_layer() const;
-
-
-This function returns a const reference to the lowest layer in a stack of layers. Since an overlapped\_handle cannot contain any further layers, it simply returns a reference to itself.
-
-
-[heading Return Value]
-      
-A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:lowest_layer_type windows::basic_stream_handle::lowest_layer_type]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.lowest_layer_type..lowest_layer_type..windows::basic_stream_handle] 
-An overlapped\_handle is always the lowest layer. 
-
-
-  typedef basic_overlapped_handle lowest_layer_type;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:native_handle windows::basic_stream_handle::native_handle]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.native_handle..native_handle..windows::basic_stream_handle] 
-Get the native handle representation. 
-
-
-  native_handle_type native_handle();
-
-
-This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided. 
-
-
-[endsect]
-
-
-
-[section:native_handle_type windows::basic_stream_handle::native_handle_type]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.native_handle_type..native_handle_type..windows::basic_stream_handle] 
-The native representation of a handle. 
-
-
-  typedef implementation_defined native_handle_type;
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:operator_eq_ windows::basic_stream_handle::operator=]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.operator_eq_..operator=..windows::basic_stream_handle] 
-Move-assign a stream handle from another. 
-
-
-  basic_stream_handle & ``[link asio.reference.windows__basic_stream_handle.operator_eq_.overload1 operator=]``(
-      basic_stream_handle && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.operator_eq_.overload1 more...]]``
-
-
-Move-assign a stream handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_handle & > ``[link asio.reference.windows__basic_stream_handle.operator_eq_.overload2 operator=]``(
-      basic_stream_handle< Executor1 > && other);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.operator_eq_.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::operator= (1 of 2 overloads)]
-
-
-Move-assign a stream handle from another. 
-
-
-  basic_stream_handle & operator=(
-      basic_stream_handle && other);
-
-
-This assignment operator moves a stream handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::operator= (2 of 2 overloads)]
-
-
-Move-assign a stream handle from a handle of another executor type. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  constraint_t< is_convertible< Executor1, Executor >::value, basic_stream_handle & > operator=(
-      basic_stream_handle< Executor1 > && other);
-
-
-This assignment operator moves a stream handle from one object to another.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[other][The other stream handle object from which the move will occur.]]
-
-]
-
-
-[heading Remarks]
-      
-Following the move, the moved-from object is in the same state as if constructed using the `basic_stream_handle(const executor_type&)` constructor. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:read_some windows::basic_stream_handle::read_some]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.read_some..read_some..windows::basic_stream_handle] 
-Read some data from the handle. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_stream_handle.read_some.overload1 read_some]``(
-      const MutableBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.read_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_stream_handle.read_some.overload2 read_some]``(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.read_some.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::read_some (1 of 2 overloads)]
-
-
-Read some data from the handle. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers);
-
-
-This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes.
-
-
-[heading Example]
-  
-To read into a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.read_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on reading into multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::read_some (2 of 2 overloads)]
-
-
-Read some data from the handle. 
-
-
-  template<
-      typename ``[link asio.reference.MutableBufferSequence MutableBufferSequence]``>
-  std::size_t read_some(
-      const MutableBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more buffers into which the data will be read.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes read. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The read\_some operation may not read all of the requested number of bytes. Consider using the [link asio.reference.read `read`] function if you need to ensure that the requested amount of data is read before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:release windows::basic_stream_handle::release]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.release..release..windows::basic_stream_handle] 
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type ``[link asio.reference.windows__basic_stream_handle.release.overload1 release]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.release.overload1 more...]]``
-
-  native_handle_type ``[link asio.reference.windows__basic_stream_handle.release.overload2 release]``(
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.release.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::release (1 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release();
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::release (2 of 2 overloads)]
-
-
-['Inherited from windows::basic_overlapped_handle.]
-
-
-Release ownership of the underlying native handle. 
-
-
-  native_handle_type release(
-      asio::error_code & ec);
-
-
-This function causes all outstanding asynchronous operations to finish immediately, and the handlers for cancelled operations will be passed the `asio::error::operation_aborted` error. Ownership of the native handle is then transferred to the caller.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Remarks]
-      
-This function is unsupported on Windows versions prior to Windows 8.1, and will fail with `asio::error::operation_not_supported` on these platforms. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_some windows::basic_stream_handle::write_some]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle.write_some..write_some..windows::basic_stream_handle] 
-Write some data to the handle. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_stream_handle.write_some.overload1 write_some]``(
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.write_some.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.windows__basic_stream_handle.write_some.overload2 write_some]``(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.windows__basic_stream_handle.write_some.overload2 more...]]``
-
-
-[section:overload1 windows::basic_stream_handle::write_some (1 of 2 overloads)]
-
-
-Write some data to the handle. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the handle.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. An error code of `asio::error::eof` indicates that the connection was closed by the peer.]]
-
-]
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  handle.write_some(asio::buffer(data, size));
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::basic_stream_handle::write_some (2 of 2 overloads)]
-
-
-Write some data to the handle. 
-
-
-  template<
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_some(
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[buffers][One or more data buffers to be written to the handle.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. Returns 0 if an error occurred.
-
-
-[heading Remarks]
-      
-The write\_some operation may not transmit all of the data to the peer. Consider using the [link asio.reference.write `write`] function if you need to ensure that all data is written before the blocking operation completes. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[endsect]
-
-[section:windows__basic_stream_handle__rebind_executor windows::basic_stream_handle::rebind_executor]
-
-[indexterm1 asio.indexterm.windows__basic_stream_handle__rebind_executor..windows::basic_stream_handle::rebind_executor]
-
-
-Rebinds the handle type to another executor. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor1]``>
-  struct rebind_executor
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle__rebind_executor.other [*other]]]
-    [The handle type when rebound to the specified executor. ]
-  
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:other windows::basic_stream_handle::rebind_executor::other]
-
-[indexterm2 asio.indexterm.windows__basic_stream_handle__rebind_executor.other..other..windows::basic_stream_handle::rebind_executor] 
-The handle type when rebound to the specified executor. 
-
-
-  typedef basic_stream_handle< Executor1 > other;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_stream_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]] [constructor]]
-    [Construct a stream handle without opening it. 
-     [hr]
-     Construct a stream handle on an existing native handle. 
-     [hr]
-     Move-construct a stream handle from another. 
-     [hr]
-     Move-construct a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.operator_eq_ [*operator=]]]
-    [Move-assign a stream handle from another. 
-     [hr]
-     Move-assign a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
-    [Read some data from the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
-    [Write some data to the handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_stream_handle `windows::basic_stream_handle`] class provides asynchronous and blocking stream-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/basic_stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:windows__object_handle windows::object_handle]
-
-[indexterm1 asio.indexterm.windows__object_handle..windows::object_handle]
-
-Typedef for the typical usage of an object handle. 
-
-
-  typedef basic_object_handle object_handle;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An object handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_object_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_object_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.async_wait [*async_wait]]]
-    [Start an asynchronous wait on the object handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.basic_object_handle [*basic_object_handle]] [constructor]]
-    [Construct an object handle without opening it. 
-     [hr]
-     Construct an object handle on an existing native handle. 
-     [hr]
-     Move-construct an object handle from another. 
-     [hr]
-     Move-construct an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.operator_eq_ [*operator=]]]
-    [Move-assign an object handle from another. 
-     [hr]
-     Move-assign an object handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_object_handle.wait [*wait]]]
-    [Perform a blocking wait on the object handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_object_handle `windows::basic_object_handle`] class provides asynchronous and blocking object-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/object_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:windows__overlapped_handle windows::overlapped_handle]
-
-[indexterm1 asio.indexterm.windows__overlapped_handle..windows::overlapped_handle]
-
-Typedef for the typical usage of an overlapped handle. 
-
-
-  typedef basic_overlapped_handle overlapped_handle;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.basic_overlapped_handle [*basic_overlapped_handle]] [constructor]]
-    [Construct an overlapped handle without opening it. 
-     [hr]
-     Construct an overlapped handle on an existing native handle. 
-     [hr]
-     Move-construct an overlapped handle from another. 
-     [hr]
-     Move-construct an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.operator_eq_ [*operator=]]]
-    [Move-assign an overlapped handle from another. 
-     [hr]
-     Move-assign an overlapped handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_overlapped_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-]
-
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_overlapped_handle._basic_overlapped_handle [*~basic_overlapped_handle]] [destructor]]
-    [Protected destructor to prevent deletion through this type. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__overlapped_handle `windows::overlapped_handle`] class provides the ability to wrap a Windows handle. The underlying object referred to by the handle must support overlapped I/O.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/overlapped_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:windows__overlapped_ptr windows::overlapped_ptr]
-
-[indexterm1 asio.indexterm.windows__overlapped_ptr..windows::overlapped_ptr]
-
-
-Wraps a handler to create an OVERLAPPED object for use with overlapped I/O. 
-
-
-  class overlapped_ptr :
-    noncopyable
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__overlapped_ptr.complete [*complete]]]
-    [Post completion notification for overlapped operation. Releases ownership. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__overlapped_ptr.get [*get]]]
-    [Get the contained OVERLAPPED object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__overlapped_ptr.overlapped_ptr [*overlapped_ptr]] [constructor]]
-    [Construct an empty overlapped_ptr. 
-     [hr]
-     Construct an overlapped_ptr to contain the specified handler. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__overlapped_ptr.release [*release]]]
-    [Release ownership of the OVERLAPPED object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__overlapped_ptr.reset [*reset]]]
-    [Reset to empty. 
-     [hr]
-     Reset to contain the specified handler, freeing any current OVERLAPPED object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__overlapped_ptr._overlapped_ptr [*~overlapped_ptr]] [destructor]]
-    [Destructor automatically frees the OVERLAPPED object unless released. ]
-  ]
-  
-]
-
-A special-purpose smart pointer used to wrap an application handler so that it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/overlapped_ptr.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:complete windows::overlapped_ptr::complete]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr.complete..complete..windows::overlapped_ptr] 
-Post completion notification for overlapped operation. Releases ownership. 
-
-
-  void complete(
-      const asio::error_code & ec,
-      std::size_t bytes_transferred);
-
-
-
-[endsect]
-
-
-[section:get windows::overlapped_ptr::get]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr.get..get..windows::overlapped_ptr] 
-Get the contained OVERLAPPED object. 
-
-
-  OVERLAPPED * ``[link asio.reference.windows__overlapped_ptr.get.overload1 get]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.get.overload1 more...]]``
-
-  const OVERLAPPED * ``[link asio.reference.windows__overlapped_ptr.get.overload2 get]``() const;
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.get.overload2 more...]]``
-
-
-[section:overload1 windows::overlapped_ptr::get (1 of 2 overloads)]
-
-
-Get the contained OVERLAPPED object. 
-
-
-  OVERLAPPED * get();
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::overlapped_ptr::get (2 of 2 overloads)]
-
-
-Get the contained OVERLAPPED object. 
-
-
-  const OVERLAPPED * get() const;
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:overlapped_ptr windows::overlapped_ptr::overlapped_ptr]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr.overlapped_ptr..overlapped_ptr..windows::overlapped_ptr] 
-Construct an empty [link asio.reference.windows__overlapped_ptr `windows::overlapped_ptr`]. 
-
-
-  ``[link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload1 overlapped_ptr]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload1 more...]]``
-
-
-Construct an [link asio.reference.windows__overlapped_ptr `windows::overlapped_ptr`] to contain the specified handler. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Handler Handler]``>
-  explicit ``[link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload2 overlapped_ptr]``(
-      ExecutionContext & context,
-      Handler && handler,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Handler Handler]``>
-  explicit ``[link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload3 overlapped_ptr]``(
-      const Executor & ex,
-      Handler && handler,
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.overlapped_ptr.overload3 more...]]``
-
-
-[section:overload1 windows::overlapped_ptr::overlapped_ptr (1 of 3 overloads)]
-
-
-Construct an empty [link asio.reference.windows__overlapped_ptr `windows::overlapped_ptr`]. 
-
-
-  overlapped_ptr();
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::overlapped_ptr::overlapped_ptr (2 of 3 overloads)]
-
-
-Construct an [link asio.reference.windows__overlapped_ptr `windows::overlapped_ptr`] to contain the specified handler. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Handler Handler]``>
-  overlapped_ptr(
-      ExecutionContext & context,
-      Handler && handler,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::overlapped_ptr::overlapped_ptr (3 of 3 overloads)]
-
-
-Construct an [link asio.reference.windows__overlapped_ptr `windows::overlapped_ptr`] to contain the specified handler. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Handler Handler]``>
-  overlapped_ptr(
-      const Executor & ex,
-      Handler && handler,
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:release windows::overlapped_ptr::release]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr.release..release..windows::overlapped_ptr] 
-Release ownership of the OVERLAPPED object. 
-
-
-  OVERLAPPED * release();
-
-
-
-[endsect]
-
-
-[section:reset windows::overlapped_ptr::reset]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr.reset..reset..windows::overlapped_ptr] 
-Reset to empty. 
-
-
-  void ``[link asio.reference.windows__overlapped_ptr.reset.overload1 reset]``();
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.reset.overload1 more...]]``
-
-
-Reset to contain the specified handler, freeing any current OVERLAPPED object. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Handler Handler]``>
-  void ``[link asio.reference.windows__overlapped_ptr.reset.overload2 reset]``(
-      ExecutionContext & context,
-      Handler && handler,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.reset.overload2 more...]]``
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Handler Handler]``>
-  void ``[link asio.reference.windows__overlapped_ptr.reset.overload3 reset]``(
-      const Executor & ex,
-      Handler && handler,
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.windows__overlapped_ptr.reset.overload3 more...]]``
-
-
-[section:overload1 windows::overlapped_ptr::reset (1 of 3 overloads)]
-
-
-Reset to empty. 
-
-
-  void reset();
-
-
-
-[endsect]
-
-
-
-[section:overload2 windows::overlapped_ptr::reset (2 of 3 overloads)]
-
-
-Reset to contain the specified handler, freeing any current OVERLAPPED object. 
-
-
-  template<
-      typename ExecutionContext,
-      typename ``[link asio.reference.Handler Handler]``>
-  void reset(
-      ExecutionContext & context,
-      Handler && handler,
-      constraint_t< is_convertible< ExecutionContext &, execution_context & >::value >  = 0);
-
-
-
-[endsect]
-
-
-
-[section:overload3 windows::overlapped_ptr::reset (3 of 3 overloads)]
-
-
-Reset to contain the specified handler, freeing any current OVERLAPPED object. 
-
-
-  template<
-      typename ``[link asio.reference.Executor1 Executor]``,
-      typename ``[link asio.reference.Handler Handler]``>
-  void reset(
-      const Executor & ex,
-      Handler && handler,
-      constraint_t< execution::is_executor< Executor >::value||is_executor< Executor >::value >  = 0);
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:_overlapped_ptr windows::overlapped_ptr::~overlapped_ptr]
-
-[indexterm2 asio.indexterm.windows__overlapped_ptr._overlapped_ptr..~overlapped_ptr..windows::overlapped_ptr] 
-Destructor automatically frees the OVERLAPPED object unless released. 
-
-
-  ~overlapped_ptr();
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-
-[section:windows__random_access_handle windows::random_access_handle]
-
-[indexterm1 asio.indexterm.windows__random_access_handle..windows::random_access_handle]
-
-Typedef for the typical usage of a random-access handle. 
-
-
-  typedef basic_random_access_handle random_access_handle;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_random_access_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_random_access_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_read_some_at [*async_read_some_at]]]
-    [Start an asynchronous read at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.async_write_some_at [*async_write_some_at]]]
-    [Start an asynchronous write at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.basic_random_access_handle [*basic_random_access_handle]] [constructor]]
-    [Construct a random-access handle without opening it. 
-     [hr]
-     Construct a random-access handle on an existing native handle. 
-     [hr]
-     Move-construct a random-access handle from another. 
-     [hr]
-     Move-construct a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.operator_eq_ [*operator=]]]
-    [Move-assign a random-access handle from another. 
-     [hr]
-     Move-assign a random-access handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.read_some_at [*read_some_at]]]
-    [Read some data from the handle at the specified offset. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_random_access_handle.write_some_at [*write_some_at]]]
-    [Write some data to the handle at the specified offset. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_random_access_handle `windows::basic_random_access_handle`] class provides asynchronous and blocking random-access handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/random_access_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:windows__stream_handle windows::stream_handle]
-
-[indexterm1 asio.indexterm.windows__stream_handle..windows::stream_handle]
-
-Typedef for the typical usage of a stream-oriented handle. 
-
-
-  typedef basic_stream_handle stream_handle;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle__rebind_executor [*rebind_executor]]]
-    [Rebinds the handle type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer_type [*lowest_layer_type]]]
-    [An overlapped_handle is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.windows__basic_stream_handle.native_handle_type [*native_handle_type]]]
-    [The native representation of a handle. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.windows__basic_stream_handle.assign [*assign]]]
-    [Assign an existing native handle to the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_read_some [*async_read_some]]]
-    [Start an asynchronous read. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.basic_stream_handle [*basic_stream_handle]] [constructor]]
-    [Construct a stream handle without opening it. 
-     [hr]
-     Construct a stream handle on an existing native handle. 
-     [hr]
-     Move-construct a stream handle from another. 
-     [hr]
-     Move-construct a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.close [*close]]]
-    [Close the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.is_open [*is_open]]]
-    [Determine whether the handle is open. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.native_handle [*native_handle]]]
-    [Get the native handle representation. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.operator_eq_ [*operator=]]]
-    [Move-assign a stream handle from another. 
-     [hr]
-     Move-assign a stream handle from a handle of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.read_some [*read_some]]]
-    [Read some data from the handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.release [*release]]]
-    [Release ownership of the underlying native handle. ]
-  ]
-  
-  [
-    [[link asio.reference.windows__basic_stream_handle.write_some [*write_some]]]
-    [Write some data to the handle. ]
-  ]
-  
-]
-
-The [link asio.reference.windows__basic_stream_handle `windows::basic_stream_handle`] class provides asynchronous and blocking stream-oriented handle functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe.
-
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/windows/stream_handle.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-
-[section:writable_pipe writable_pipe]
-
-[indexterm1 asio.indexterm.writable_pipe..writable_pipe]
-
-Typedef for the typical usage of a writable pipe. 
-
-
-  typedef basic_writable_pipe writable_pipe;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe__rebind_executor [*rebind_executor]]]
-    [Rebinds the pipe type to another executor. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.executor_type [*executor_type]]]
-    [The type of the executor associated with the object. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.lowest_layer_type [*lowest_layer_type]]]
-    [A basic_writable_pipe is always the lowest layer. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_writable_pipe.native_handle_type [*native_handle_type]]]
-    [The native representation of a pipe. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_writable_pipe.assign [*assign]]]
-    [Assign an existing native pipe to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.async_write_some [*async_write_some]]]
-    [Start an asynchronous write. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.basic_writable_pipe [*basic_writable_pipe]] [constructor]]
-    [Construct a basic_writable_pipe without opening it. 
-     [hr]
-     Construct a basic_writable_pipe on an existing native pipe. 
-     [hr]
-     Move-construct a basic_writable_pipe from another. 
-     [hr]
-     Move-construct a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.cancel [*cancel]]]
-    [Cancel all asynchronous operations associated with the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.close [*close]]]
-    [Close the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.get_executor [*get_executor]]]
-    [Get the executor associated with the object. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.is_open [*is_open]]]
-    [Determine whether the pipe is open. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.lowest_layer [*lowest_layer]]]
-    [Get a reference to the lowest layer. 
-     [hr]
-     Get a const reference to the lowest layer. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.native_handle [*native_handle]]]
-    [Get the native pipe representation. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.operator_eq_ [*operator=]]]
-    [Move-assign a basic_writable_pipe from another. 
-     [hr]
-     Move-assign a basic_writable_pipe from a pipe of another executor type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.release [*release]]]
-    [Release ownership of the underlying native pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe.write_some [*write_some]]]
-    [Write some data to the pipe. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_writable_pipe._basic_writable_pipe [*~basic_writable_pipe]] [destructor]]
-    [Destroys the pipe. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_writable_pipe `basic_writable_pipe`] class provides a wrapper over pipe functionality.
-
-
-[heading Thread Safety]
-  
-['Distinct] ['objects:] Safe.
-
-['Shared] ['objects:] Unsafe. 
-
-
-
-
-[heading Requirements]
-
-['Header: ][^asio/writable_pipe.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[endsect]
-
-
-[section:write write]
-
-[indexterm1 asio.indexterm.write..write]
-
-The `write` function is a composed operation that writes a certain amount of data to a stream before returning. 
-
-
-Write all of the supplied data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.write.overload1 write]``(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.write.overload2 write]``(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload2 more...]]``
-
-Write a certain amount of data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload3 write]``(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload4 write]``(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload4 more...]]``
-
-Write all of the supplied data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.write.overload5 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t ``[link asio.reference.write.overload6 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload6 more...]]``
-
-Write a certain amount of data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload7 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload8 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload8 more...]]``
-
-Write all of the supplied data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.write.overload9 write]``(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b);
-  ``  [''''&raquo;''' [link asio.reference.write.overload9 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.write.overload10 write]``(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.write.overload10 more...]]``
-
-Write a certain amount of data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload11 write]``(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload11 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload12 write]``(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload12 more...]]``
-
-Write all of the supplied data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.write.overload13 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload13 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t ``[link asio.reference.write.overload14 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload14 more...]]``
-
-Write a certain amount of data to a stream before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload15 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload15 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write.overload16 write]``(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write.overload16 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/write.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 write (1 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write(s, asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 write (2 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write(s, asio::buffer(data, size), ec); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 write (3 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write(s, asio::buffer(data, size),
-     asio::transfer_at_least(32)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 write (4 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_const_buffer_sequence< ConstBufferSequence >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 write (5 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 write (6 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 write (7 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 write (8 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v1 DynamicBuffer_v1]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v1 && buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v1< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< !is_dynamic_buffer_v2< decay_t< DynamicBuffer_v1 > >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload9 write (9 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator>
-  std::size_t write(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, b,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload10 write (10 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator>
-  std::size_t write(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, b,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload11 write (11 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload12 write (12 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload13 write (13 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload14 write (14 of 16 overloads)]
-
-
-Write all of the supplied data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write(
-     s, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload15 write (15 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload16 write (16 of 16 overloads)]
-
-
-Write a certain amount of data to a stream before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncWriteStream SyncWriteStream]``,
-      typename ``[link asio.reference.DynamicBuffer_v2 DynamicBuffer_v2]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write(
-      SyncWriteStream & s,
-      DynamicBuffer_v2 buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_dynamic_buffer_v2< DynamicBuffer_v2 >::value >  = 0,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied dynamic buffer sequence has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the stream's write\_some function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[s][The stream to which the data is to be written. The type must support the SyncWriteStream concept.]]
-
-[[buffers][The dynamic buffer sequence from which data will be written. Successfully written data is automatically consumed from the buffers.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write\_some function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-[section:write_at write_at]
-
-[indexterm1 asio.indexterm.write_at..write_at]
-
-The `write_at` function is a composed operation that writes a certain amount of data at a specified offset before returning. 
-
-
-Write all of the supplied data at the specified offset before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.write_at.overload1 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload1 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t ``[link asio.reference.write_at.overload2 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload2 more...]]``
-
-Write a certain amount of data at a specified offset before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write_at.overload3 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload3 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write_at.overload4 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload4 more...]]``
-
-Write all of the supplied data at the specified offset before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.write_at.overload5 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload5 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator>
-  std::size_t ``[link asio.reference.write_at.overload6 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload6 more...]]``
-
-Write a certain amount of data at a specified offset before returning. 
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write_at.overload7 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload7 more...]]``
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t ``[link asio.reference.write_at.overload8 write_at]``(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-  ``  [''''&raquo;''' [link asio.reference.write_at.overload8 more...]]``
-
-[heading Requirements]
-
-['Header: ][^asio/impl/write_at.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:overload1 write_at (1 of 8 overloads)]
-
-
-Write all of the supplied data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write_at(d, 42, asio::buffer(data, size)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write_at(
-     d, offset, buffers,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload2 write_at (2 of 8 overloads)]
-
-
-Write all of the supplied data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      asio::error_code & ec);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write_at(d, 42,
-     asio::buffer(data, size), ec); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write_at(
-     d, offset, buffers,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload3 write_at (3 of 8 overloads)]
-
-
-Write a certain amount of data at a specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Example]
-  
-To write a single data buffer use the [link asio.reference.buffer `buffer`] function as follows: 
-
-  asio::write_at(d, 42, asio::buffer(data, size),
-     asio::transfer_at_least(32)); 
-
-
-See the [link asio.reference.buffer `buffer`] documentation for information on writing multiple buffers in one go, and how to use it with arrays, boost::array or std::vector. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload4 write_at (4 of 8 overloads)]
-
-
-Write a certain amount of data at a specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename ``[link asio.reference.ConstBufferSequence ConstBufferSequence]``,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      const ConstBufferSequence & buffers,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied buffers has been written. That is, the bytes transferred is equal to the sum of the buffer sizes.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[buffers][One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-
-[section:overload5 write_at (5 of 8 overloads)]
-
-
-Write all of the supplied data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure.]]
-
-]
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write_at(
-     d, 42, b,
-     asio::transfer_all()); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload6 write_at (6 of 8 overloads)]
-
-
-Write all of the supplied data at the specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      asio::error_code & ec);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* An error occurred.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Remarks]
-      
-This overload is equivalent to calling: 
-
-  asio::write_at(
-     d, 42, b,
-     asio::transfer_all(), ec); 
-
-
-
-
-
-
-
-[endsect]
-
-
-
-[section:overload7 write_at (7 of 8 overloads)]
-
-
-Write a certain amount of data at a specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes transferred.
-
-
-[heading Exceptions]
-    
-
-[variablelist
-  
-[[asio::system_error][Thrown on failure. ]]
-
-]
-
-
-
-
-[endsect]
-
-
-
-[section:overload8 write_at (8 of 8 overloads)]
-
-
-Write a certain amount of data at a specified offset before returning. 
-
-
-  template<
-      typename ``[link asio.reference.SyncRandomAccessWriteDevice SyncRandomAccessWriteDevice]``,
-      typename Allocator,
-      typename ``[link asio.reference.CompletionCondition CompletionCondition]``>
-  std::size_t write_at(
-      SyncRandomAccessWriteDevice & d,
-      uint64_t offset,
-      basic_streambuf< Allocator > & b,
-      CompletionCondition completion_condition,
-      asio::error_code & ec,
-      constraint_t< is_completion_condition< CompletionCondition >::value >  = 0);
-
-
-This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
-
-
-* All of the data in the supplied [link asio.reference.basic_streambuf `basic_streambuf`] has been written.
-
-
-* The completion\_condition function object returns 0.
-
-This operation is implemented in terms of zero or more calls to the device's write\_some\_at function.
-
-
-[heading Parameters]
-    
-
-[variablelist
-  
-[[d][The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.]]
-
-[[offset][The offset at which the data will be written.]]
-
-[[b][The [link asio.reference.basic_streambuf `basic_streambuf`] object from which data will be written.]]
-
-[[completion_condition][The function object to be called to determine whether the write operation is complete. The signature of the function object must be: 
-``
-  std::size_t completion_condition(
-    // Result of latest write_some_at operation.
-    const asio::error_code& error,
-
-    // Number of bytes transferred so far.
-    std::size_t bytes_transferred
-  ); 
-``
-A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write\_some\_at function.]]
-
-[[ec][Set to indicate what error occurred, if any.]]
-
-]
-
-
-[heading Return Value]
-      
-The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error. 
-
-
-
-
-[endsect]
-
-
-[endsect]
-
-
-[section:yield_context yield_context]
-
-[indexterm1 asio.indexterm.yield_context..yield_context]
-
-A [link asio.overview.model.completion_tokens completion token] object that represents the currently executing coroutine. 
-
-
-  typedef basic_yield_context< any_io_executor > yield_context;
-
-
-[heading Types]
-[table
-  [[Name][Description]]
-
-  [
-
-    [[link asio.reference.basic_yield_context.cancellation_slot_type [*cancellation_slot_type]]]
-    [The cancellation slot type associated with the yield context. ]
-  
-  ]
-
-  [
-
-    [[link asio.reference.basic_yield_context.executor_type [*executor_type]]]
-    [The executor type associated with the yield context. ]
-  
-  ]
-
-]
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.basic_yield_context.basic_yield_context [*basic_yield_context]] [constructor]]
-    [Construct a yield context from another yield context type. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.cancelled [*cancelled]]]
-    [Determine whether the current coroutine has been cancelled. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_cancellation_slot [*get_cancellation_slot]]]
-    [Get the cancellation slot associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_cancellation_state [*get_cancellation_state]]]
-    [Get the cancellation state associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.get_executor [*get_executor]]]
-    [Get the executor associated with the yield context. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.operator_lb__rb_ [*operator\[\]]]]
-    [Return a yield context that sets the specified error_code. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.reset_cancellation_state [*reset_cancellation_state]]]
-    [Reset the cancellation state associated with the coroutine. ]
-  ]
-  
-  [
-    [[link asio.reference.basic_yield_context.throw_if_cancelled [*throw_if_cancelled]]]
-    [Determine whether the coroutine throws if trying to suspend when it has been cancelled. 
-     [hr]
-     Set whether the coroutine throws if trying to suspend when it has been cancelled. ]
-  ]
-  
-]
-
-The [link asio.reference.basic_yield_context `basic_yield_context`] class is a completion token type that is used to represent the currently executing stackful coroutine. A [link asio.reference.basic_yield_context `basic_yield_context`] object may be passed as a completion token to an asynchronous operation. For example:
-
-
-
-  template <typename Executor>
-  void my_coroutine(basic_yield_context<Executor> yield)
-  {
-    ...
-    std::size_t n = my_socket.async_read_some(buffer, yield);
-    ...
-  } 
-
-
-
-
-The initiating function (async\_read\_some in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned. 
-
-
-[heading Requirements]
-
-['Header: ][^asio/spawn.hpp]
-
-['Convenience header: ]None
-
-
-[endsect]
-
-
-[section:ip__address__gt_ ip::address >]
-
-[indexterm1 asio.indexterm.ip__address__gt_..ip::address >]
-
-
-
-  template<>
-  struct hash< asio::ip::address >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address__gt_.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ ip::address >::operator()]
-
-[indexterm2 asio.indexterm.ip__address__gt_.operator_lp__rp_..operator()..ip::address >] 
-
-  std::size_t operator()(
-      const asio::ip::address & addr) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__address_v4__gt_ ip::address_v4 >]
-
-[indexterm1 asio.indexterm.ip__address_v4__gt_..ip::address_v4 >]
-
-
-
-  template<>
-  struct hash< asio::ip::address_v4 >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v4__gt_.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v4.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ ip::address_v4 >::operator()]
-
-[indexterm2 asio.indexterm.ip__address_v4__gt_.operator_lp__rp_..operator()..ip::address_v4 >] 
-
-  std::size_t operator()(
-      const asio::ip::address_v4 & addr) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__address_v6__gt_ ip::address_v6 >]
-
-[indexterm1 asio.indexterm.ip__address_v6__gt_..ip::address_v6 >]
-
-
-
-  template<>
-  struct hash< asio::ip::address_v6 >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__address_v6__gt_.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/address_v6.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ ip::address_v6 >::operator()]
-
-[indexterm2 asio.indexterm.ip__address_v6__gt_.operator_lp__rp_..operator()..ip::address_v6 >] 
-
-  std::size_t operator()(
-      const asio::ip::address_v6 & addr) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ip__basic_endpoint_lt__InternetProtocol__gt___gt_ ip::basic_endpoint< InternetProtocol > >]
-
-[indexterm1 asio.indexterm.ip__basic_endpoint_lt__InternetProtocol__gt___gt_..ip::basic_endpoint< InternetProtocol > >]
-
-
-
-  template<
-      typename ``[link asio.reference.InternetProtocol InternetProtocol]``>
-  struct hash< asio::ip::basic_endpoint< InternetProtocol > >
-
-
-[heading Member Functions]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ip__basic_endpoint_lt__InternetProtocol__gt___gt_.operator_lp__rp_ [*operator()]]]
-    []
-  ]
-  
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ip/basic_endpoint.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:operator_lp__rp_ ip::basic_endpoint< InternetProtocol > >::operator()]
-
-[indexterm2 asio.indexterm.ip__basic_endpoint_lt__InternetProtocol__gt___gt_.operator_lp__rp_..operator()..ip::basic_endpoint< InternetProtocol > >] 
-
-  std::size_t operator()(
-      const asio::ip::basic_endpoint< InternetProtocol > & ep) const;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:error__addrinfo_errors__gt_ error::addrinfo_errors >]
-
-[indexterm1 asio.indexterm.error__addrinfo_errors__gt_..error::addrinfo_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::error::addrinfo_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.error__addrinfo_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value error::addrinfo_errors >::value]
-
-[indexterm2 asio.indexterm.error__addrinfo_errors__gt_.value..value..error::addrinfo_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:error__basic_errors__gt_ error::basic_errors >]
-
-[indexterm1 asio.indexterm.error__basic_errors__gt_..error::basic_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::error::basic_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.error__basic_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value error::basic_errors >::value]
-
-[indexterm2 asio.indexterm.error__basic_errors__gt_.value..value..error::basic_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:error__misc_errors__gt_ error::misc_errors >]
-
-[indexterm1 asio.indexterm.error__misc_errors__gt_..error::misc_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::error::misc_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.error__misc_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value error::misc_errors >::value]
-
-[indexterm2 asio.indexterm.error__misc_errors__gt_.value..value..error::misc_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:error__netdb_errors__gt_ error::netdb_errors >]
-
-[indexterm1 asio.indexterm.error__netdb_errors__gt_..error::netdb_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::error::netdb_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.error__netdb_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/error.hpp]
-
-['Convenience header: ][^asio.hpp]
-
-
-[section:value error::netdb_errors >::value]
-
-[indexterm2 asio.indexterm.error__netdb_errors__gt_.value..value..error::netdb_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:error__ssl_errors__gt_ error::ssl_errors >]
-
-[indexterm1 asio.indexterm.error__ssl_errors__gt_..error::ssl_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::error::ssl_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.error__ssl_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:value error::ssl_errors >::value]
-
-[indexterm2 asio.indexterm.error__ssl_errors__gt_.value..value..error::ssl_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:experimental__error__channel_errors__gt_ experimental::error::channel_errors >]
-
-[indexterm1 asio.indexterm.experimental__error__channel_errors__gt_..experimental::error::channel_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::experimental::error::channel_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.experimental__error__channel_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/experimental/channel_error.hpp]
-
-['Convenience header: ]None
-
-
-[section:value experimental::error::channel_errors >::value]
-
-[indexterm2 asio.indexterm.experimental__error__channel_errors__gt_.value..value..experimental::error::channel_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[section:ssl__error__stream_errors__gt_ ssl::error::stream_errors >]
-
-[indexterm1 asio.indexterm.ssl__error__stream_errors__gt_..ssl::error::stream_errors >]
-
-
-
-  template<>
-  struct is_error_code_enum< asio::ssl::error::stream_errors >
-
-
-[heading Data Members]
-[table
-  [[Name][Description]]
-
-  [
-    [[link asio.reference.ssl__error__stream_errors__gt_.value [*value]] [static]]
-    []
-  ]
-
-]
-
-[heading Requirements]
-
-['Header: ][^asio/ssl/error.hpp]
-
-['Convenience header: ][^asio/ssl.hpp]
-
-
-[section:value ssl::error::stream_errors >::value]
-
-[indexterm2 asio.indexterm.ssl__error__stream_errors__gt_.value..value..ssl::error::stream_errors >] 
-
-  static const bool value = true;
-
-
-
-[endsect]
-
-
-
-[endsect]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.xsl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.xsl
deleted file mode 100644
index ea556cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/reference.xsl
+++ /dev/null
@@ -1,2147 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-
-<!--
-  Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-  Distributed under the Boost Software License, Version 1.0. (See accompanying
-  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<xsl:output method="text"/>
-<xsl:strip-space elements="*"/>
-<xsl:preserve-space elements="para type"/>
-
-
-<xsl:variable name="newline">
-<xsl:text>
-</xsl:text>
-</xsl:variable>
-
-
-<xsl:variable name="all-compounddefs" select="/doxygen//compounddef"/>
-<xsl:variable name="all-memberdefs" select="/doxygen//memberdef"/>
-
-
-<!--
-  Loop over all top-level documentation elements (i.e. classes, functions,
-  variables and typedefs at namespace scope). The elements are sorted by name.
-  Anything in a "detail" namespace or with "_handler" in the name is skipped.
--->
-<xsl:template match="/doxygen">
-<xsl:text>[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:reference Reference]
-
-[xinclude quickref.xml]
-
-[include requirements/asynchronous_operations.qbk]
-[include requirements/read_write_operations.qbk]
-[include requirements/synchronous_socket_operations.qbk]
-[include requirements/asynchronous_socket_operations.qbk]
-[include requirements/AcceptableProtocol.qbk]
-[include requirements/AcceptHandler.qbk]
-[include requirements/AcceptToken.qbk]
-[include requirements/AsyncRandomAccessReadDevice.qbk]
-[include requirements/AsyncRandomAccessWriteDevice.qbk]
-[include requirements/AsyncReadStream.qbk]
-[include requirements/AsyncWriteStream.qbk]
-[include requirements/BufferedHandshakeHandler.qbk]
-[include requirements/BufferedHandshakeToken.qbk]
-[include requirements/CancellationHandler.qbk]
-[include requirements/CancellationSlot.qbk]
-[include requirements/CompletionCondition.qbk]
-[include requirements/ConnectCondition.qbk]
-[include requirements/ConnectHandler.qbk]
-[include requirements/ConnectToken.qbk]
-[include requirements/ConstBufferSequence.qbk]
-[include requirements/DynamicBuffer.qbk]
-[include requirements/DynamicBuffer_v1.qbk]
-[include requirements/DynamicBuffer_v2.qbk]
-[include requirements/Endpoint.qbk]
-[include requirements/EndpointSequence.qbk]
-[include requirements/ExecutionContext.qbk]
-[include requirements/Executor.qbk]
-[include requirements/GettableSerialPortOption.qbk]
-[include requirements/GettableSocketOption.qbk]
-[include requirements/Handler.qbk]
-[include requirements/HandshakeHandler.qbk]
-[include requirements/HandshakeToken.qbk]
-[include requirements/InternetProtocol.qbk]
-[include requirements/IoControlCommand.qbk]
-[include requirements/IoObjectService.qbk]
-[include requirements/IteratorConnectHandler.qbk]
-[include requirements/IteratorConnectToken.qbk]
-[include requirements/LegacyCompletionHandler.qbk]
-[include requirements/MoveAcceptHandler.qbk]
-[include requirements/MoveAcceptToken.qbk]
-[include requirements/MutableBufferSequence.qbk]
-[include requirements/NullaryToken.qbk]
-[include requirements/ProtoAllocator.qbk]
-[include requirements/Protocol.qbk]
-[include requirements/RangeConnectHandler.qbk]
-[include requirements/RangeConnectToken.qbk]
-[include requirements/ReadHandler.qbk]
-[include requirements/ReadToken.qbk]
-[include requirements/ResolveHandler.qbk]
-[include requirements/ResolveToken.qbk]
-[include requirements/Service.qbk]
-[include requirements/SettableSerialPortOption.qbk]
-[include requirements/SettableSocketOption.qbk]
-[include requirements/ShutdownHandler.qbk]
-[include requirements/ShutdownToken.qbk]
-[include requirements/SignalHandler.qbk]
-[include requirements/SignalToken.qbk]
-[include requirements/SyncRandomAccessReadDevice.qbk]
-[include requirements/SyncRandomAccessWriteDevice.qbk]
-[include requirements/SyncReadStream.qbk]
-[include requirements/SyncWriteStream.qbk]
-[include requirements/TimeTraits.qbk]
-[include requirements/WaitHandler.qbk]
-[include requirements/WaitToken.qbk]
-[include requirements/WaitTraits.qbk]
-[include requirements/WriteHandler.qbk]
-[include requirements/WriteToken.qbk]
-
-</xsl:text>
-
-  <xsl:for-each select="
-      compounddef[@kind = 'class' or @kind = 'struct'] |
-      compounddef[@kind = 'namespace']/sectiondef[@kind = 'func' or @kind = 'var' or @kind = 'enum' or @kind = 'typedef']/memberdef">
-    <xsl:sort select="concat((. | ancestor::*)/compoundname, '::', name, ':x')"/>
-    <xsl:sort select="name"/>
-    <xsl:choose>
-      <xsl:when test="@kind='class' or @kind='struct'">
-        <xsl:if test="
-            contains(compoundname, 'asio::') and
-            not(contains(compoundname, '::detail')) and
-            not(contains(compoundname, '::service::key')) and
-            not(contains(compoundname, '::cancellation_state::impl')) and
-            not(contains(compoundname, '_handler')) and
-            not(contains(compoundname, '_helper')) and
-            not(contains(compoundname, 'std_allocator_void')) and
-            not(contains(compoundname, 'thread_function')) and
-            not(contains(compoundname, 'context_impl')) and
-            not(contains(compoundname, 'initiate_')) and
-            not(contains(compoundname, '_adapter')) and
-            not(contains(compoundname, '_is_deprecated')) or
-            contains(compoundname, 'asio::any_completion_handler')">
-          <xsl:call-template name="class"/>
-        </xsl:if>
-      </xsl:when>
-      <xsl:otherwise>
-        <xsl:if test="
-            not(contains(ancestor::*/compoundname, '::detail')) and
-            not(contains(ancestor::*/compoundname, '::service::key')) and
-            not(contains(ancestor::*/compoundname, '::cancellation_state::impl')) and
-            not(contains(ancestor::*/compoundname, '_helper')) and
-            not(contains(ancestor::*/compoundname, 'initiate_')) and
-            not(contains(name, '_helper')) and
-            not(contains(name, 'std_allocator_void')) and
-            not(contains(name, 'thread_function')) and
-            not(contains(name, 'io_context_impl')) and
-            not(contains(name, 'initiate_')) and
-            not(contains(name, '_adapter')) and
-            not(contains(name, '_is_deprecated'))">
-          <xsl:call-template name="namespace-memberdef"/>
-        </xsl:if>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:for-each>
-
-  <xsl:value-of select="$newline"/>
-  <xsl:text>[endsect]</xsl:text>
-  <xsl:value-of select="$newline"/>
-
-</xsl:template>
-
-
-<!--========== Utilities ==========-->
-
-<xsl:template name="strip-asio-ns">
-  <xsl:param name="name"/>
-  <xsl:choose>
-    <xsl:when test="contains($name, 'boost::system::is_error_code_enum')">
-      <xsl:value-of select="$name"/>
-    </xsl:when>
-    <xsl:when test="contains($name, 'asio::')">
-      <xsl:value-of select="substring-after($name, 'asio::')"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$name"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="strip-ns">
-  <xsl:param name="name"/>
-  <xsl:choose>
-    <xsl:when test="contains($name, 'boost::system::is_error_code_enum')">
-      <xsl:value-of select="$name"/>
-    </xsl:when>
-    <xsl:when test="contains($name, '::') and contains($name, '&lt;')">
-      <xsl:choose>
-        <xsl:when test="string-length(substring-before($name, '::')) &lt; string-length(substring-before($name, '&lt;'))">
-          <xsl:call-template name="strip-ns">
-            <xsl:with-param name="name" select="substring-after($name, '::')"/>
-          </xsl:call-template>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:value-of select="$name"/>
-        </xsl:otherwise>
-      </xsl:choose>
-    </xsl:when>
-    <xsl:when test="contains($name, '::')">
-      <xsl:call-template name="strip-ns">
-        <xsl:with-param name="name" select="substring-after($name, '::')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$name"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="cleanup-type">
-  <xsl:param name="name"/>
-  <xsl:param name="function-name"/>
-  <xsl:variable name="type">
-    <xsl:choose>
-      <xsl:when test="contains($name, 'ASIO_DECL ')">
-        <xsl:value-of select="substring-after($name, 'ASIO_DECL ')"/>
-      </xsl:when>
-      <xsl:when test="contains($name, 'ASIO_DECL')">
-        <xsl:value-of select="substring-after($name, 'ASIO_DECL')"/>
-      </xsl:when>
-      <xsl:when test="$name = 'virtual'"></xsl:when>
-      <xsl:otherwise>
-        <xsl:value-of select="$name"/>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:variable>
-  <xsl:choose>
-    <xsl:when test="$type='void_or_deduced'">
-      <xsl:text>``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]``</xsl:text>
-    </xsl:when>
-    <xsl:when test="$type='auto' and starts-with($function-name, 'async_')">
-      <xsl:text>``[link asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type ['DEDUCED]]``</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$type"/>
-    </xsl:otherwise>   
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="make-id">
-  <xsl:param name="name"/>
-  <xsl:param name="static"/>
-  <xsl:choose>
-    <xsl:when test="$name='query' and $static='yes'">
-      <xsl:text>query__static</xsl:text>
-    </xsl:when>
-    <xsl:when test="contains($name, 'boost::system::')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="substring-after($name, 'boost::system::')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, 'boost::asio::error::')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, 'boost::asio::error::'), substring-after($name, 'boost::asio::error::'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '::')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '::'), '__', substring-after($name, '::'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '=')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '='), '_eq_', substring-after($name, '='))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '!')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '!'), '_not_', substring-after($name, '!'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '-&gt;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '-&gt;'), '_arrow_', substring-after($name, '-&gt;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&lt;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&lt;'), '_lt_', substring-after($name, '&lt;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&gt;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&gt;'), '_gt_', substring-after($name, '&gt;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&amp;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&amp;'), '_amp_', substring-after($name, '&amp;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '[')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '['), '_lb_', substring-after($name, '['))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, ']')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, ']'), '_rb_', substring-after($name, ']'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '(')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '('), '_lp_', substring-after($name, '('))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, ')')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, ')'), '_rp_', substring-after($name, ')'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '+')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '+'), '_plus_', substring-after($name, '+'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '-')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '-'), '_minus_', substring-after($name, '-'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '*')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '*'), '_star_', substring-after($name, '*'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '~')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '~'), '_', substring-after($name, '~'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '^')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '^'), '_hat_', substring-after($name, '^'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '|')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '|'), '_pipe_', substring-after($name, '|'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, ',')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, ','), '_comma_', substring-after($name, ','))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&quot;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&quot;'), '_quot_', substring-after($name, '&quot;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '...')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '...'), '_ellipsis_', substring-after($name, '...'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, ' ')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, ' '), '_', substring-after($name, ' '))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, 'boost__posix_time__ptime')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, 'boost__posix_time__ptime'), 'ptime', substring-after($name, 'boost__posix_time__ptime'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$name"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<!--========== Markup ==========-->
-
-<xsl:template match="para" mode="markup">
-<xsl:text>
-</xsl:text><xsl:apply-templates mode="markup"/><xsl:text>
-</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="para" mode="markup-nested">
-<xsl:apply-templates mode="markup-nested"/>
-</xsl:template>
-
-
-<xsl:template match="title" mode="markup">
-  <xsl:variable name="title">
-    <xsl:value-of select="."/>
-  </xsl:variable>
-  <xsl:if test="string-length($title) > 0">
-[heading <xsl:value-of select="."/>]
-  </xsl:if>
-</xsl:template>
-
-
-<xsl:template match="programlisting" mode="markup">
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-  <xsl:apply-templates mode="codeline"/>
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="programlisting" mode="markup-nested">
-  <xsl:value-of select="$newline"/>
-  <xsl:text>``</xsl:text>
-  <xsl:value-of select="$newline"/>
-  <xsl:apply-templates mode="codeline"/>
-  <xsl:if test="substring(., string-length(.)) = $newline">
-    <xsl:value-of select="$newline"/>
-  </xsl:if>
-  <xsl:text>``</xsl:text>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="codeline" mode="codeline">
-  <xsl:variable name="code">
-    <xsl:apply-templates mode="codeline"/>
-  </xsl:variable>
-  <xsl:if test="string-length(.) &gt; 0">
-    <xsl:choose>
-      <xsl:when test="position() = 1 and starts-with($code, ' ')">
-        <xsl:text> </xsl:text>
-      </xsl:when>
-      <xsl:otherwise>
-        <xsl:text>  </xsl:text>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:if>
-  <xsl:value-of select="$code"/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="sp" mode="markup">
-<xsl:text> </xsl:text>
-</xsl:template>
-
-
-<xsl:template match="sp" mode="markup-nested">
-<xsl:text> </xsl:text>
-</xsl:template>
-
-
-<xsl:template match="sp" mode="codeline">
-  <xsl:text> </xsl:text>
-</xsl:template>
-
-
-<xsl:template match="linebreak" mode="markup">
-<xsl:text>
-
-</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="linebreak" mode="markup-nested">
-<xsl:text>
-
-</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="computeroutput" mode="markup">
-<xsl:text>`</xsl:text><xsl:value-of select="."/><xsl:text>`</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="computeroutput" mode="markup-nested">
-<xsl:text>`</xsl:text><xsl:value-of select="."/><xsl:text>`</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="listitem" mode="markup">
-* <xsl:call-template name="strip-leading-whitespace">
-  <xsl:with-param name="text">
-    <xsl:apply-templates mode="markup"/>
-  </xsl:with-param>
-</xsl:call-template>
-</xsl:template>
-
-
-<xsl:template match="bold" mode="markup">[*<xsl:apply-templates mode="markup"/>]</xsl:template>
-
-
-<xsl:template match="emphasis" mode="markup">['<xsl:apply-templates mode="markup"/>]</xsl:template>
-
-
-<xsl:template match="parameterlist" mode="markup">
-  <xsl:choose>
-    <xsl:when test="@kind='param'">
-[heading Parameters]
-    </xsl:when>
-    <xsl:when test="@kind='exception'">
-[heading Exceptions]
-    </xsl:when>
-  </xsl:choose>
-
-[variablelist
-  <xsl:apply-templates mode="markup"/>
-]
-</xsl:template>
-
-
-<xsl:template match="parameteritem" mode="markup">
-[[<xsl:value-of select="parameternamelist"/>][<xsl:apply-templates select="parameterdescription" mode="markup-nested"/>]]
-</xsl:template>
-
-
-<xsl:template match="simplesect" mode="markup">
-  <xsl:choose>
-    <xsl:when test="@kind='return'">
-[heading Return Value]
-      <xsl:apply-templates mode="markup"/>
-    </xsl:when>
-    <xsl:when test="@kind='see'">
-    </xsl:when>
-    <xsl:when test="@kind='note'">
-[heading Remarks]
-      <xsl:apply-templates mode="markup"/>
-    </xsl:when>
-    <xsl:when test="@kind='attention'">
-[heading Attention]
-      <xsl:apply-templates mode="markup"/>
-    </xsl:when>
-    <xsl:when test="@kind='par'">
-      <xsl:if test="not(starts-with(title, 'Concepts:'))">
-        <xsl:apply-templates mode="markup"/>
-      </xsl:if>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:apply-templates mode="markup"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="text()" mode="markup">
-  <xsl:variable name="text" select="."/>
-  <xsl:variable name="starts-with-whitespace" select="
-      starts-with($text, ' ') or starts-with($text, $newline)"/>
-  <xsl:variable name="preceding-node-name">
-    <xsl:for-each select="preceding-sibling::*">
-      <xsl:if test="position() = last()">
-        <xsl:value-of select="local-name()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:variable name="after-newline" select="
-      $preceding-node-name = 'programlisting' or
-      $preceding-node-name = 'linebreak'"/>
-  <xsl:choose>
-    <xsl:when test="$starts-with-whitespace and $after-newline">
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text">
-          <xsl:call-template name="strip-leading-whitespace">
-            <xsl:with-param name="text" select="$text"/>
-          </xsl:call-template>
-        </xsl:with-param>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text" select="$text"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="text()" mode="markup-nested">
-  <xsl:variable name="text" select="."/>
-  <xsl:variable name="starts-with-whitespace" select="
-      starts-with($text, ' ') or starts-with($text, $newline)"/>
-  <xsl:variable name="preceding-node-name">
-    <xsl:for-each select="preceding-sibling::*">
-      <xsl:if test="position() = last()">
-        <xsl:value-of select="local-name()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:variable name="after-newline" select="
-      $preceding-node-name = 'programlisting' or
-      $preceding-node-name = 'linebreak'"/>
-  <xsl:choose>
-    <xsl:when test="$starts-with-whitespace and $after-newline">
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text">
-          <xsl:call-template name="strip-leading-whitespace">
-            <xsl:with-param name="text" select="$text"/>
-          </xsl:call-template>
-        </xsl:with-param>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text" select="$text"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="strip-leading-whitespace">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="starts-with($text, ' ')">
-      <xsl:call-template name="strip-leading-whitespace">
-        <xsl:with-param name="text" select="substring($text, 2)"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="starts-with($text, $newline)">
-      <xsl:call-template name="strip-leading-whitespace">
-        <xsl:with-param name="text" select="substring($text, 2)"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="escape-text">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="contains($text, '_')">
-      <xsl:value-of select="substring-before($text, '_')"/>
-      <xsl:text>\_</xsl:text>
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text" select="substring-after($text, '_')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="escape-name">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="contains($text, '[')">
-      <xsl:value-of select="substring-before($text, '[')"/>
-      <xsl:text>\[</xsl:text>
-      <xsl:call-template name="escape-name">
-        <xsl:with-param name="text" select="substring-after($text, '[')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($text, ']')">
-      <xsl:value-of select="substring-before($text, ']')"/>
-      <xsl:text>\]</xsl:text>
-      <xsl:call-template name="escape-name">
-        <xsl:with-param name="text" select="substring-after($text, ']')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($text, '...')">
-      <xsl:value-of select="substring-before($text, '...')"/>
-      <xsl:text>\.\.\.</xsl:text>
-      <xsl:call-template name="escape-name">
-        <xsl:with-param name="text" select="substring-after($text, '...')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='compound']" mode="markup">
-  <xsl:variable name="name">
-    <xsl:value-of select="."/>
-  </xsl:variable>
-  <xsl:choose>
-    <xsl:when test="contains(@refid, 'asio') or contains($name, 'asio::')">
-      <xsl:variable name="dox-ref-id" select="@refid"/>
-      <xsl:variable name="ref-name">
-        <xsl:call-template name="strip-asio-ns">
-          <xsl:with-param name="name"
-            select="(($all-compounddefs)[@id=$dox-ref-id])[1]/compoundname"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="ref-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name" select="$ref-name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:text>[link asio.reference.</xsl:text>
-      <xsl:value-of select="$ref-id"/>
-      <xsl:text> `</xsl:text>
-      <xsl:value-of name="text" select="$ref-name"/>
-      <xsl:text>`]</xsl:text>
-    </xsl:when>
-    <xsl:when test="@refid = 'asynchronous_operation'">
-      <xsl:text>[link asio.overview.model.async_ops </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="@refid = 'completion_token'">
-      <xsl:text>[link asio.overview.model.completion_tokens </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:text>`</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>`</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='compound']" mode="markup-nested">
-  <xsl:variable name="name">
-    <xsl:value-of select="."/>
-  </xsl:variable>
-  <xsl:choose>
-    <xsl:when test="contains(@refid, 'asio') or contains($name, 'asio::')">
-      <xsl:variable name="dox-ref-id" select="@refid"/>
-      <xsl:variable name="ref-name">
-        <xsl:call-template name="strip-asio-ns">
-          <xsl:with-param name="name"
-            select="(($all-compounddefs)[@id=$dox-ref-id])[1]/compoundname"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="ref-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name" select="$ref-name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:text>[link asio.reference.</xsl:text>
-      <xsl:value-of select="$ref-id"/>
-      <xsl:text> `</xsl:text>
-      <xsl:value-of name="text" select="$ref-name"/>
-      <xsl:text>`]</xsl:text>
-    </xsl:when>
-    <xsl:when test="@refid = 'asynchronous_operation'">
-      <xsl:text>[link asio.overview.model.async_ops </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="@refid = 'completion_token'">
-      <xsl:text>[link asio.overview.model.completion_tokens </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:text>`</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>`</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='member']" mode="markup">
-  <xsl:variable name="dox-ref-id" select="@refid"/>
-  <xsl:variable name="memberdefs" select="($all-memberdefs)[@id=$dox-ref-id]"/>
-  <xsl:choose>
-    <xsl:when test="contains(@refid, 'namespaceasio') and count($memberdefs) &gt; 0">
-      <xsl:variable name="dox-compound-name" select="($memberdefs)[1]/../../compoundname"/>
-      <xsl:variable name="dox-name" select="($memberdefs)[1]/name"/>
-      <xsl:variable name="ref-name">
-        <xsl:call-template name="strip-asio-ns">
-          <xsl:with-param name="name" select="concat($dox-compound-name,'::',$dox-name)"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="ref-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name" select="$ref-name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:text>[link asio.reference.</xsl:text>
-      <xsl:value-of select="$ref-id"/>
-      <xsl:text> `</xsl:text>
-      <xsl:value-of name="text" select="$ref-name"/>
-      <xsl:text>`]</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:text>`</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>`</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='member']" mode="markup-nested">
-  <xsl:variable name="dox-ref-id" select="@refid"/>
-  <xsl:variable name="memberdefs" select="($all-memberdefs)[@id=$dox-ref-id]"/>
-  <xsl:choose>
-    <xsl:when test="contains(@refid, 'namespaceasio') and count($memberdefs) &gt; 0">
-      <xsl:variable name="dox-compound-name" select="($memberdefs)[1]/../../compoundname"/>
-      <xsl:variable name="dox-name" select="($memberdefs)[1]/name"/>
-      <xsl:variable name="ref-name">
-        <xsl:call-template name="strip-asio-ns">
-          <xsl:with-param name="name" select="concat($dox-compound-name,'::',$dox-name)"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="ref-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name" select="$ref-name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:text>[link asio.reference.</xsl:text>
-      <xsl:value-of select="$ref-id"/>
-      <xsl:text> `</xsl:text>
-      <xsl:value-of name="text" select="$ref-name"/>
-      <xsl:text>`]</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:text>`</xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>`</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="header-requirements">
-  <xsl:param name="file"/>
-  <xsl:value-of select="$newline"/>
-  <xsl:text>[heading Requirements]</xsl:text>
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-  <xsl:text>['Header: ]</xsl:text>
-  <xsl:text>[^asio/</xsl:text>
-  <xsl:value-of select="substring-after($file, 'asio/')"/>
-  <xsl:text>]</xsl:text>
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-  <xsl:text>['Convenience header: ]</xsl:text>
-  <xsl:choose>
-    <xsl:when test="contains($file, 'asio/execution')">
-      <xsl:text>[^asio/execution.hpp]</xsl:text>
-    </xsl:when>
-    <xsl:when test="contains($file, 'asio/ssl')">
-      <xsl:text>[^asio/ssl.hpp]</xsl:text>
-    </xsl:when>
-    <xsl:when test="contains($file, 'asio/spawn')">
-      <xsl:text>None</xsl:text>
-    </xsl:when>
-    <xsl:when test="contains($file, 'asio/experimental')">
-      <xsl:text>None</xsl:text>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:text>[^asio.hpp]</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<!--========== Class ==========-->
-
-<xsl:template name="class">
-  <xsl:variable name="class-name">
-    <xsl:call-template name="strip-asio-ns">
-      <xsl:with-param name="name" select="compoundname"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="escaped-class-name">
-    <xsl:call-template name="escape-name">
-      <xsl:with-param name="text" select="$class-name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="unqualified-class-name">
-    <xsl:call-template name="strip-ns">
-      <xsl:with-param name="name" select="compoundname"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="class-id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$class-name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="class-file" select="location/@file"/>
-[section:<xsl:value-of select="$class-id"/><xsl:text> </xsl:text><xsl:value-of select="$class-name"/>]
-
-[indexterm1 asio.indexterm.<xsl:value-of select="$class-id"/>..<xsl:value-of select="$escaped-class-name"/>]
-
-<xsl:apply-templates select="briefdescription" mode="markup"/><xsl:text>
-
-</xsl:text>
-
-<xsl:apply-templates select="templateparamlist"
- mode="class-detail"/><xsl:text>  </xsl:text><xsl:value-of select="@kind"/><xsl:text> </xsl:text><xsl:value-of
- select="$unqualified-class-name"/><xsl:if test="count(basecompoundref[not(contains(.,'::detail'))]) > 0"> :</xsl:if><xsl:text>
-</xsl:text><xsl:for-each select="basecompoundref[not(contains(.,'::detail'))]">
-<xsl:text>    </xsl:text><xsl:if test="@prot='public'">public </xsl:if><xsl:call-template
- name="strip-asio-ns"><xsl:with-param name="name" select="."/></xsl:call-template><xsl:if
- test="not(position() = last())">,</xsl:if><xsl:text>
-</xsl:text></xsl:for-each><xsl:text>
-</xsl:text>
-
-<xsl:call-template name="class-tables">
-  <xsl:with-param name="class-name" select="$class-name"/>
-  <xsl:with-param name="class-id" select="$class-id"/>
-  <xsl:with-param name="unqualified-class-name" select="$unqualified-class-name"/>
-</xsl:call-template>
-
-<xsl:apply-templates select="detaileddescription" mode="markup"/>
-
-<xsl:call-template name="header-requirements">
-  <xsl:with-param name="file" select="$class-file"/>
-</xsl:call-template>
-
-<xsl:call-template name="class-members">
-  <xsl:with-param name="class-name" select="$class-name"/>
-  <xsl:with-param name="class-id" select="$class-id"/>
-  <xsl:with-param name="class-file" select="$class-file"/>
-</xsl:call-template>
-
-[endsect]
-</xsl:template>
-
-
-<xsl:template name="class-tables">
-<xsl:param name="class-name"/>
-<xsl:param name="class-id"/>
-<xsl:param name="unqualified-class-name"/>
-<xsl:if test="
-    count(
-      sectiondef[@kind='public-type'] |
-      innerclass[@prot='public' and not(contains(., '_handler'))]) &gt; 0">
-[heading Types]
-[table
-  [[Name][Description]]
-<xsl:for-each select="
-    sectiondef[@kind='public-type']/memberdef |
-    innerclass[@prot='public' and not(contains(., '_handler')) and not(contains(., 'thread_function')) and not(contains(., 'initiate_'))]" mode="class-table">
-  <xsl:sort select="concat(name, (.)[not(name)])"/>
-  [
-<xsl:choose>
-  <xsl:when test="count(name) &gt; 0">
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="name"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="name"/>]]]
-    [<xsl:call-template name="escape-name"><xsl:with-param name="text" select="briefdescription"/></xsl:call-template>]
-  </xsl:when>
-  <xsl:otherwise>
-    <xsl:variable name="type-name">
-      <xsl:call-template name="strip-asio-ns">
-        <xsl:with-param name="name" select="."/>
-      </xsl:call-template>
-    </xsl:variable>
-    <xsl:variable name="unqualified-type-name">
-      <xsl:call-template name="strip-ns">
-        <xsl:with-param name="name" select="."/>
-      </xsl:call-template>
-    </xsl:variable>
-    <xsl:variable name="type-id">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name" select="$type-name"/>
-      </xsl:call-template>
-    </xsl:variable>
-    <xsl:variable name="type-ref-id" select="@refid"/>
-    [[link asio.reference.<xsl:value-of select="$type-id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$unqualified-type-name"/>]]]
-    [<xsl:value-of select="(($all-compounddefs)[@id=$type-ref-id])[1]/briefdescription"/>]
-  </xsl:otherwise>
-</xsl:choose>
-  ]
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='public-func' or @kind='public-static-func']) > 0">
-[heading Member Functions]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='public-func' or @kind='public-static-func']/memberdef" mode="class-table">
-  <xsl:sort select="name"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="escaped-name">
-    <xsl:call-template name="escape-name">
-      <xsl:with-param name="text" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-      <xsl:with-param name="static" select="@static"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:if test="$overload-position = 1">
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="$id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$escaped-name"/><xsl:text>]]</xsl:text>
-      <xsl:if test="$name=$unqualified-class-name"> [constructor]</xsl:if>
-      <xsl:if test="starts-with($name, '~')"> [destructor]</xsl:if>
-      <xsl:if test="@static='yes'"> [static]</xsl:if>
-      <xsl:text>]
-    [</xsl:text><xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="not($overload-position = 1) and not(briefdescription = preceding-sibling::*/briefdescription)">
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     [hr]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     </xsl:text>
-    <xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="$overload-position = $overload-count">
-  <xsl:text>]
-  ]
-  </xsl:text>
-  </xsl:if>
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='protected-func' or @kind='protected-static-func']) > 0">
-[heading Protected Member Functions]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='protected-func' or @kind='protected-static-func']/memberdef" mode="class-table">
-  <xsl:sort select="name"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-      <xsl:with-param name="static" select="@static"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:if test="$overload-position = 1">
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="$id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$name"/><xsl:text>]]</xsl:text>
-      <xsl:if test="$name=$unqualified-class-name"> [constructor]</xsl:if>
-      <xsl:if test="starts-with($name, '~')"> [destructor]</xsl:if>
-      <xsl:if test="@static='yes'"> [static]</xsl:if>
-      <xsl:text>]
-    [</xsl:text><xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="not($overload-position = 1) and not(briefdescription = preceding-sibling::*/briefdescription)">
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     [hr]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     </xsl:text>
-    <xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="$overload-position = $overload-count">
-  <xsl:text>]
-  ]
-  </xsl:text>
-  </xsl:if>
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="$class-name = 'execution_context::service'">
-<xsl:if test="count(sectiondef[@kind='private-func']) > 0">
-[heading Private Member Functions]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='private-func']/memberdef" mode="class-table">
-  <xsl:sort select="name"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-      <xsl:with-param name="static" select="@static"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:if test="$overload-position = 1">
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="$id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$name"/><xsl:text>]]</xsl:text>
-      <xsl:if test="$name=$unqualified-class-name"> [constructor]</xsl:if>
-      <xsl:if test="starts-with($name, '~')"> [destructor]</xsl:if>
-      <xsl:if test="@static='yes'"> [static]</xsl:if>
-      <xsl:text>]
-    [</xsl:text><xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="not($overload-position = 1) and not(briefdescription = preceding-sibling::*/briefdescription)">
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     [hr]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     </xsl:text>
-    <xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="$overload-position = $overload-count">
-  <xsl:text>]
-  ]
-  </xsl:text>
-  </xsl:if>
-</xsl:for-each>
-]
-</xsl:if>
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='public-attrib' or @kind='public-static-attrib']) > 0">
-[heading Data Members]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='public-attrib' or @kind='public-static-attrib']/memberdef" mode="class-table">
-  <xsl:sort select="name"/>
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="name"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="name"/><xsl:text>]]</xsl:text>
-      <xsl:if test="@static='yes'"> [static]</xsl:if>]
-    [<xsl:value-of select="briefdescription"/>]
-  ]
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='protected-attrib' or @kind='protected-static-attrib']/memberdef[not(name='impl_')]) > 0">
-[heading Protected Data Members]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='protected-attrib' or @kind='protected-static-attrib']/memberdef[not(name='impl_')]" mode="class-table">
-  <xsl:sort select="name"/>
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="name"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="name"/><xsl:text>]]</xsl:text>
-      <xsl:if test="@static='yes'"> [static]</xsl:if>]
-    [<xsl:value-of select="briefdescription"/>]
-  ]
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='friend']/memberdef[not(type = 'class') and not(contains(name, '_helper'))]) &gt; 0">
-[heading Friends]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='friend']/memberdef[not(type = 'class') and not(contains(name, '_helper'))]" mode="class-table">
-  <xsl:sort select="name"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:if test="$overload-position = 1">
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="$id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$name"/><xsl:text>]]]
-    [</xsl:text><xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="not($overload-position = 1) and not(briefdescription = preceding-sibling::*/briefdescription)">
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     [hr]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     </xsl:text>
-    <xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="$overload-position = $overload-count">
-  <xsl:text>]
-  ]
-  </xsl:text>
-  </xsl:if>
-</xsl:for-each>
-]
-</xsl:if>
-
-<xsl:if test="count(sectiondef[@kind='related']/memberdef) &gt; 0">
-[heading Related Functions]
-[table
-  [[Name][Description]]
-<xsl:for-each select="sectiondef[@kind='related']/memberdef" mode="class-table">
-  <xsl:sort select="name"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:if test="$overload-position = 1">
-  [
-    [[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of select="$id"/>
-      <xsl:text> </xsl:text>[*<xsl:value-of select="$name"/><xsl:text>]]]
-    [</xsl:text><xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="not($overload-position = 1) and not(briefdescription = preceding-sibling::*/briefdescription)">
-    <xsl:value-of select="$newline"/>
-    <xsl:value-of select="$newline"/>
-    <xsl:text>     </xsl:text>
-    <xsl:value-of select="briefdescription"/>
-  </xsl:if>
-  <xsl:if test="$overload-position = $overload-count">
-  <xsl:text>]
-  ]
-  </xsl:text>
-  </xsl:if>
-</xsl:for-each>
-]
-</xsl:if>
-
-</xsl:template>
-
-
-<xsl:template name="class-members">
-<xsl:param name="class-name"/>
-<xsl:param name="class-id"/>
-<xsl:param name="class-file"/>
-<xsl:apply-templates select="sectiondef[@kind='public-type' or @kind='public-func' or @kind='public-static-func' or @kind='public-attrib' or @kind='public-static-attrib' or @kind='protected-func' or @kind='protected-static-func' or @kind='protected-attrib' or @kind='protected-static-attrib' or @kind='friend' or @kind='related']/memberdef[not(type = 'class') and not(contains(name, '_helper')) and not(name = 'impl_')]" mode="class-detail">
-  <xsl:sort select="name"/>
-  <xsl:with-param name="class-name" select="$class-name"/>
-  <xsl:with-param name="class-id" select="$class-id"/>
-  <xsl:with-param name="class-file" select="$class-file"/>
-</xsl:apply-templates>
-<xsl:if test="$class-name = 'execution_context::service'">
-  <xsl:apply-templates select="sectiondef[@kind='private-func']/memberdef[not(type = 'class') and not(contains(name, '_helper'))]" mode="class-detail">
-    <xsl:sort select="name"/>
-    <xsl:with-param name="class-name" select="$class-name"/>
-    <xsl:with-param name="class-id" select="$class-id"/>
-    <xsl:with-param name="class-file" select="$class-file"/>
-  </xsl:apply-templates>
-</xsl:if>
-</xsl:template>
-
-
-<!-- Class detail -->
-
-<xsl:template match="memberdef" mode="class-detail">
-  <xsl:param name="class-name"/>
-  <xsl:param name="class-id"/>
-  <xsl:param name="class-file"/>
-  <xsl:variable name="name">
-    <xsl:value-of select="name"/>
-  </xsl:variable>
-  <xsl:variable name="escaped-name">
-    <xsl:call-template name="escape-name">
-      <xsl:with-param name="text" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="escaped-class-name">
-    <xsl:call-template name="escape-name">
-      <xsl:with-param name="text" select="$class-name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-      <xsl:with-param name="static" select="@static"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-
-<xsl:if test="$overload-count &gt; 1 and $overload-position = 1">
-[section:<xsl:value-of select="$id"/><xsl:text> </xsl:text>
-<xsl:value-of select="$class-name"/>::<xsl:value-of select="$escaped-name"/>]
-
-<xsl:text>[indexterm2 </xsl:text>
-<xsl:text>asio.indexterm.</xsl:text>
-<xsl:value-of select="$class-id"/>
-<xsl:text>.</xsl:text>
-<xsl:value-of select="$id"/>
-<xsl:text>..</xsl:text>
-<xsl:value-of select="$escaped-name"/>
-<xsl:text>..</xsl:text>
-<xsl:value-of select="$escaped-class-name"/>
-<xsl:text>] </xsl:text>
-
-<xsl:apply-templates select="briefdescription" mode="markup"/><xsl:text>
-</xsl:text>
-
-<xsl:for-each select="../memberdef[name = $name]">
-<xsl:if test="position() &gt; 1 and not(briefdescription = preceding-sibling::*/briefdescription)">
-  <xsl:value-of select="$newline"/>
-  <xsl:apply-templates select="briefdescription" mode="markup"/>
-  <xsl:value-of select="$newline"/>
-</xsl:if>
-<xsl:text>
-</xsl:text><xsl:apply-templates select="templateparamlist" mode="class-detail"/>
-<xsl:text>  </xsl:text>
- <xsl:if test="@explicit='yes'">explicit </xsl:if>
- <xsl:if test="@static='yes'">static </xsl:if>
- <xsl:if test="@virt='virtual'">virtual </xsl:if>
- <xsl:variable name="stripped-type">
-  <xsl:call-template name="cleanup-type">
-    <xsl:with-param name="name" select="type"/>
-    <xsl:with-param name="function-name" select="name"/>
-  </xsl:call-template>
- </xsl:variable>
- <xsl:if test="string-length($stripped-type) &gt; 0">
- <xsl:value-of select="$stripped-type"/><xsl:text> </xsl:text>
-</xsl:if>``[link asio.reference.<xsl:value-of select="$class-id"/>.<xsl:value-of
- select="$id"/>.overload<xsl:value-of select="position()"/><xsl:text> </xsl:text><xsl:value-of
- select="name"/>]``(<xsl:apply-templates select="param"
- mode="class-detail"/>)<xsl:if test="@const='yes'"> const</xsl:if>;
-<xsl:text>  ``  [''''&amp;raquo;'''</xsl:text>
-<xsl:text> [link asio.reference.</xsl:text>
-<xsl:value-of select="$class-id"/>.<xsl:value-of
- select="$id"/>.overload<xsl:value-of select="position()"/>
-<xsl:text> more...]]``
-</xsl:text>
-</xsl:for-each>
-</xsl:if>
-
-[section:<xsl:if test="$overload-count = 1"><xsl:value-of select="$id"/></xsl:if>
-<xsl:if test="$overload-count &gt; 1">overload<xsl:value-of select="$overload-position"/></xsl:if>
-<xsl:text> </xsl:text><xsl:value-of select="$class-name"/>::<xsl:value-of select="$escaped-name"/>
-<xsl:if test="$overload-count &gt; 1"> (<xsl:value-of
- select="$overload-position"/> of <xsl:value-of select="$overload-count"/> overloads)</xsl:if>]
-
-<xsl:if test="not(starts-with($doxygen-id, ../../@id))">
-<xsl:variable name="inherited-from" select="($all-compounddefs)[starts-with($doxygen-id, @id)]/compoundname"/>
-<xsl:if test="not(contains($inherited-from, '::detail'))">
-['Inherited from <xsl:call-template name="strip-asio-ns">
-<xsl:with-param name="name" select="$inherited-from"/>
-</xsl:call-template>.]<xsl:text>
-
-</xsl:text></xsl:if></xsl:if>
-
-<xsl:if test="$overload-count = 1">
-  <xsl:text>[indexterm2 </xsl:text>
-  <xsl:text>asio.indexterm.</xsl:text>
-  <xsl:value-of select="$class-id"/>
-  <xsl:text>.</xsl:text>
-  <xsl:value-of select="$id"/>
-  <xsl:text>..</xsl:text>
-  <xsl:value-of select="$escaped-name"/>
-  <xsl:text>..</xsl:text>
-  <xsl:value-of select="$escaped-class-name"/>
-  <xsl:text>] </xsl:text>
-</xsl:if>
-
-<xsl:apply-templates select="briefdescription" mode="markup"/><xsl:text>
-</xsl:text>
-
-  <xsl:choose>
-    <xsl:when test="@kind='typedef'">
-      <xsl:call-template name="typedef" mode="class-detail">
-        <xsl:with-param name="class-name" select="$class-name"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="@kind='variable'">
-      <xsl:call-template name="variable" mode="class-detail"/>
-    </xsl:when>
-    <xsl:when test="@kind='enum'">
-      <xsl:call-template name="enum" mode="class-detail">
-        <xsl:with-param name="enum-name" select="$class-name"/>
-        <xsl:with-param name="id" select="concat($class-id, '.', $id)"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="@kind='function'">
-      <xsl:call-template name="function" mode="class-detail"/>
-    </xsl:when>
-    <xsl:when test="@kind='friend'">
-      <xsl:call-template name="function" mode="class-detail"/>
-    </xsl:when>
-  </xsl:choose>
-
-<xsl:text>
-</xsl:text><xsl:apply-templates select="detaileddescription" mode="markup"/>
-
-<xsl:if test="@kind='typedef' or @kind='friend'">
-  <xsl:call-template name="header-requirements">
-    <xsl:with-param name="file" select="$class-file"/>
-  </xsl:call-template>
-</xsl:if>
-
-[endsect]
-
-<xsl:if test="$overload-count &gt; 1 and $overload-position = $overload-count">
-[endsect]
-</xsl:if>
-</xsl:template>
-
-
-<xsl:template name="typedef">
-<xsl:param name="class-name"/>
-<xsl:text>
-  </xsl:text>typedef <xsl:value-of select="type"/><xsl:text> </xsl:text><xsl:value-of select="name"/>;<xsl:text>
-
-</xsl:text>
-<xsl:if test="count(type/ref) &gt; 0 and not(contains(type, '*')) and not(contains(name, 'polymorphic_query_result_type'))">
-  <xsl:variable name="class-refid">
-    <xsl:choose>
-      <xsl:when test="type='basic_address_iterator&lt; address_v4 &gt;'">
-        <xsl:text>classasio_1_1ip_1_1basic__address__iterator_3_01address__v4_01_4</xsl:text>
-      </xsl:when>
-      <xsl:when test="type='basic_address_iterator&lt; address_v6 &gt;'">
-        <xsl:text>classasio_1_1ip_1_1basic__address__iterator_3_01address__v6_01_4</xsl:text>
-      </xsl:when>
-      <xsl:when test="type='basic_address_range&lt; address_v4 &gt;'">
-        <xsl:text>classasio_1_1ip_1_1basic__address__range_3_01address__v4_01_4</xsl:text>
-      </xsl:when>
-      <xsl:when test="type='basic_address_range&lt; address_v6 &gt;'">
-        <xsl:text>classasio_1_1ip_1_1basic__address__range_3_01address__v6_01_4</xsl:text>
-      </xsl:when>
-      <xsl:otherwise>
-        <xsl:for-each select="type/ref[1]">
-          <xsl:value-of select="@refid"/>
-        </xsl:for-each>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:variable>
-  <xsl:variable name="name" select="name"/>
-  <xsl:for-each select="($all-compounddefs)[@id=$class-refid]">
-    <xsl:call-template name="class-tables">
-      <xsl:with-param name="class-name">
-        <xsl:value-of select="concat($class-name, '::', $name)"/>
-      </xsl:with-param>
-      <xsl:with-param name="class-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name">
-            <xsl:call-template name="strip-asio-ns">
-              <xsl:with-param name="name" select="compoundname"/>
-            </xsl:call-template>
-          </xsl:with-param>
-        </xsl:call-template>
-      </xsl:with-param>
-      <xsl:with-param name="unqualified-class-name">
-        <xsl:call-template name="strip-ns">
-          <xsl:with-param name="name" select="compoundname"/>
-        </xsl:call-template>
-      </xsl:with-param>
-    </xsl:call-template>
-    <xsl:apply-templates select="detaileddescription" mode="markup"/>
-  </xsl:for-each>
-</xsl:if>
-</xsl:template>
-
-
-<xsl:template name="variable">
-<xsl:if test="contains(name, 'is_applicable_property_v')">
-<xsl:text>
-  template &lt;typename T&gt;</xsl:text>
-</xsl:if>
-<xsl:if test="contains(name, 'context_as')">
-<xsl:text>
-  template &lt;typename U&gt;</xsl:text>
-</xsl:if>
-<xsl:text>
-  </xsl:text><xsl:if test="@static='yes'">static </xsl:if><xsl:value-of
- select="type"/><xsl:text> </xsl:text><xsl:value-of select="name"/>
- <xsl:if test="count(initializer) = 1"><xsl:text> </xsl:text>
- <xsl:value-of select="initializer"/></xsl:if>;
-</xsl:template>
-
-
-<xsl:template name="enum">
-<xsl:param name="enum-name"/>
-<xsl:param name="id"/>
-<xsl:text>  enum </xsl:text>
-<xsl:if test="name='cancellation_type'">
-  <xsl:text>class </xsl:text>
-</xsl:if>
-<xsl:value-of select="name"/>
-<xsl:if test="name='cancellation_type'">
-  <xsl:text> : unsigned int</xsl:text>
-</xsl:if>
-<xsl:text>
-</xsl:text><xsl:if test="count(enumvalue) &gt; 0">
-<xsl:value-of select="$newline"/>
-<xsl:for-each select="enumvalue">
-  <xsl:text>[indexterm2 </xsl:text>
-  <xsl:text>asio.indexterm.</xsl:text>
-  <xsl:value-of select="$id"/>
-  <xsl:text>.</xsl:text>
-  <xsl:value-of select="name"/>
-  <xsl:text>..</xsl:text>
-  <xsl:value-of select="name"/>
-  <xsl:text>..</xsl:text>
-  <xsl:value-of select="$enum-name"/>
-  <xsl:text>]</xsl:text>
-  <xsl:value-of select="$newline"/>
-</xsl:for-each>
-[heading Values]
-[variablelist
-<xsl:for-each select="enumvalue">
-  [
-    [<xsl:value-of select="name"/>]
-    [<xsl:value-of select="briefdescription"/>]
-  ]
-</xsl:for-each>
-]
-</xsl:if>
-</xsl:template>
-
-
-<xsl:template name="function">
-<xsl:text>
-</xsl:text>
-<xsl:variable name="doxygen-id">
-  <xsl:value-of select="@id"/>
-</xsl:variable>
-<xsl:choose>
-  <xsl:when test="count(($all-memberdefs)[@id=$doxygen-id]/templateparamlist) = 1">
-    <xsl:apply-templates select="($all-memberdefs)[@id=$doxygen-id]/templateparamlist" mode="class-detail"/>
-  </xsl:when>
-  <xsl:otherwise>
-    <xsl:apply-templates select="templateparamlist" mode="class-detail"/>
-  </xsl:otherwise>
-</xsl:choose>
-<xsl:variable name="stripped-type">
- <xsl:call-template name="cleanup-type">
-   <xsl:with-param name="name" select="type"/>
-   <xsl:with-param name="function-name" select="name"/>
- </xsl:call-template>
-</xsl:variable>
-<xsl:text>  </xsl:text><xsl:if test="@static='yes'">static </xsl:if><xsl:if 
- test="@virt='virtual'">virtual </xsl:if><xsl:if
- test="string-length($stripped-type) &gt; 0"><xsl:value-of select="$stripped-type"/><xsl:text> </xsl:text></xsl:if>
-<xsl:value-of select="name"/>(<xsl:apply-templates select="param"
- mode="class-detail"/>)<xsl:if test="@const='yes'"> const</xsl:if>;
-</xsl:template>
-
-
-<xsl:template match="templateparamlist" mode="class-detail">
-<xsl:text>  </xsl:text>template&lt;<xsl:apply-templates select="param" mode="class-detail-template"/>&gt;
-</xsl:template>
-
-
-<xsl:template match="param" mode="class-detail-template">
-<xsl:variable name="type">
-  <xsl:choose>
-    <xsl:when test="count(declname) &gt; 0">
-      <xsl:value-of select="type"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="substring-before(type, ' ')"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:variable>
-<xsl:variable name="declname">
-  <xsl:choose>
-    <xsl:when test="count(declname) &gt; 0">
-      <xsl:value-of select="declname"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="substring-after(type, ' ')"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:variable>
-<xsl:text>
-      </xsl:text><xsl:value-of select="$type"/><xsl:text> </xsl:text>
-      <xsl:choose>
-        <xsl:when test="$declname = '_'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'A'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Allocator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Arg'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Args'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Associator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'AwaitableExecutor'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Bits'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Blocking'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'BufferSequence'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'ByteType'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'C'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'CancellationCondition'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Chars'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Clock'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'CompletionHandler'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'CompletionToken'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'ConstBuffer'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Context_Service'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'DefaultCandidate'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Duration'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'DatagramSocketService1'">
-          <xsl:value-of select="concat('``[link asio.reference.DatagramSocketService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'E'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Element'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'EndpointIterator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Elem'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'ErrorEnum'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'ExecutionContext'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Executor'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Executor2'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'F'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'F1'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'F2'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Filter'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Function'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'H'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Head'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'I'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'IoObjectService1'">
-          <xsl:value-of select="concat('``[link asio.reference.IoObjectService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Impl'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Implementation'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'InFilter'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'InitArgs'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Initiation'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'InnerExecutor'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'InnerExecutor1'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'IoObjectsOrExecutors'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Iterator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Mask'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'MatchCondition'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'MutableBuffer'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'N'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'NewSignatures'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OnFalse'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OnTrue'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Ops'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OtherAllocator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OtherCancellationSlot'">
-          <xsl:value-of select="concat('``[link asio.reference.CancellationSlot ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OtherExecutor'">
-          <xsl:value-of select="concat('``[link asio.reference.Executor1 ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OtherHandler'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OtherSupportableProperties'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OutFilter'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'OutstandingWork'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'PasswordCallback'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Period'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'PodType'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'PointerToPodType'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Properties'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Property'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Protocol1'">
-          <xsl:value-of select="concat('``[link asio.reference.Protocol ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Ps'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'R'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Range'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'RawCompletionToken'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'RawSocketService1'">
-          <xsl:value-of select="concat('``[link asio.reference.RawSocketService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Relationship'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Rep'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Result'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Return'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'S'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'SeqPacketSocketService1'">
-          <xsl:value-of select="concat('``[link asio.reference.SeqPacketSocketService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Signature'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Signatures'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'SocketAcceptorService1' or $declname = 'SocketAcceptorService2'">
-          <xsl:value-of select="concat('``[link asio.reference.SocketAcceptorService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'SocketService1' or $declname = 'SocketService2'">
-          <xsl:value-of select="concat('``[link asio.reference.SocketService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'StackAllocator'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Stream'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'StreamSocketService1'">
-          <xsl:value-of select="concat('``[link asio.reference.StreamSocketService ', $declname, ']``')"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'SupportableProperties'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'T'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Tail'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Ts'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'T1'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'TN'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Time'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'TimeType'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Traits'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'U'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'V'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Values'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Vs'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'VerifyCallback'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Y'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = 'Yield'">
-          <xsl:value-of select="$declname"/>
-        </xsl:when>
-        <xsl:when test="$declname = ''">
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:value-of select="concat('``[link asio.reference.', $declname, ' ', $declname, ']``')"/>
-        </xsl:otherwise>
-      </xsl:choose>
-      <xsl:if test="count(defval) > 0"> = <xsl:choose>
-        <xsl:when test="defval = 'default_token'">
-          <xsl:text>``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``</xsl:text>
-        </xsl:when>
-        <xsl:otherwise><xsl:value-of select="defval"/></xsl:otherwise>
-        </xsl:choose></xsl:if>
-      <xsl:if test="not(position() = last())">,</xsl:if>
-</xsl:template>
-
-
-<xsl:template match="param" mode="class-detail">
-<xsl:text>
-      </xsl:text>
-  <xsl:choose>
-    <xsl:when test="string-length(array) &gt; 0">
-      <xsl:value-of select="substring-before(type, '&amp;')"/>
-      <xsl:text>(&amp;</xsl:text>
-      <xsl:value-of select="declname"/>
-      <xsl:text>)</xsl:text>
-      <xsl:value-of select="array"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="type"/>
-      <xsl:text> </xsl:text>
-      <xsl:value-of select="declname"/>
-    </xsl:otherwise>
-  </xsl:choose>
-  <xsl:if test="count(defval) > 0"> = <xsl:choose>
-    <xsl:when test="defval = 'default_token'">
-      <xsl:text>``[link asio.reference.asynchronous_operations.default_completion_tokens ['DEFAULT]]``</xsl:text>
-    </xsl:when>
-    <xsl:otherwise><xsl:value-of select="defval"/></xsl:otherwise>
-  </xsl:choose></xsl:if>
-  <xsl:if test="not(position() = last())">,</xsl:if>
-</xsl:template>
-
-
-<xsl:template match="*" mode="class-detail"/>
-
-
-<!--========== Namespace ==========-->
-
-<xsl:template name="namespace-memberdef">
-  <xsl:variable name="name">
-    <xsl:call-template name="strip-asio-ns">
-      <xsl:with-param name="name" select="concat(../../compoundname, '::', name)"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="unqualified-name">
-    <xsl:call-template name="strip-ns">
-      <xsl:with-param name="name" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="id">
-    <xsl:call-template name="make-id">
-      <xsl:with-param name="name" select="$name"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:variable name="doxygen-id">
-    <xsl:value-of select="@id"/>
-  </xsl:variable>
-  <xsl:variable name="overload-count">
-    <xsl:value-of select="count(../memberdef[name = $unqualified-name])"/>
-  </xsl:variable>
-  <xsl:variable name="overload-position">
-    <xsl:for-each select="../memberdef[name = $unqualified-name]">
-      <xsl:if test="@id = $doxygen-id">
-        <xsl:value-of select="position()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-
-<xsl:if test="$overload-count &gt; 1 and $overload-position = 1">
-[section:<xsl:value-of select="$id"/><xsl:text> </xsl:text><xsl:value-of select="$name"/>]
-
-<xsl:text>[indexterm1 </xsl:text>
-<xsl:text>asio.indexterm.</xsl:text>
-<xsl:value-of select="$id"/>
-<xsl:text>..</xsl:text>
-<xsl:value-of select="$name"/>
-<xsl:text>]</xsl:text>
-<xsl:value-of select="$newline"/>
-
-<xsl:for-each select="($all-compounddefs)[@kind='group' and compoundname=$name]">
-  <xsl:apply-templates select="briefdescription" mode="markup"/>
-  <xsl:value-of select="$newline"/>
-</xsl:for-each>
-
-<xsl:for-each select="../memberdef[name = $unqualified-name]">
-<xsl:variable name="stripped-type">
- <xsl:call-template name="cleanup-type">
-   <xsl:with-param name="name" select="type"/>
-   <xsl:with-param name="function-name" select="$unqualified-name"/>
- </xsl:call-template>
-</xsl:variable>
-<xsl:if test="position() = 1 or not(briefdescription = preceding-sibling::memberdef[1]/briefdescription)">
-  <xsl:apply-templates select="briefdescription" mode="markup"/>
-</xsl:if>
-<xsl:text>
-</xsl:text><xsl:apply-templates select="templateparamlist" mode="class-detail"/>
-<xsl:text>  </xsl:text><xsl:if test="string-length($stripped-type) &gt; 0"><xsl:value-of
- select="$stripped-type"/><xsl:text> </xsl:text></xsl:if>``[link asio.reference.<xsl:value-of
- select="$id"/>.overload<xsl:value-of select="position()"/><xsl:text> </xsl:text>
-<xsl:value-of select="name"/>]``(<xsl:apply-templates select="param" mode="class-detail"/>);
-<xsl:text>  ``  [''''&amp;raquo;'''</xsl:text>
-<xsl:text> [link asio.reference.</xsl:text>
-<xsl:value-of select="$id"/>.overload<xsl:value-of select="position()"/>
-<xsl:text> more...]]``
-</xsl:text>
-</xsl:for-each>
-
-<xsl:for-each select="($all-compounddefs)[@kind='group' and compoundname=$name]">
-  <xsl:apply-templates select="detaileddescription" mode="markup"/>
-</xsl:for-each>
-
-<xsl:call-template name="header-requirements">
-  <xsl:with-param name="file" select="location/@file"/>
-</xsl:call-template>
-
-</xsl:if>
-
-[section:<xsl:if test="$overload-count = 1"><xsl:value-of select="$id"/></xsl:if>
-<xsl:if test="$overload-count &gt; 1">overload<xsl:value-of select="$overload-position"/>
-</xsl:if><xsl:text> </xsl:text><xsl:value-of select="$name"/>
-<xsl:if test="$overload-count &gt; 1"> (<xsl:value-of
- select="$overload-position"/> of <xsl:value-of select="$overload-count"/> overloads)</xsl:if>]
-
-<xsl:if test="$overload-count = 1">
-  <xsl:text>[indexterm1 </xsl:text>
-  <xsl:text>asio.indexterm.</xsl:text>
-  <xsl:value-of select="$id"/>
-  <xsl:text>..</xsl:text>
-  <xsl:value-of select="$name"/>
-  <xsl:text>]</xsl:text>
-  <xsl:value-of select="$newline"/>
-</xsl:if>
-
-<xsl:apply-templates select="briefdescription" mode="markup"/><xsl:text>
-</xsl:text>
-
-  <xsl:choose>
-    <xsl:when test="@kind='typedef'">
-      <xsl:call-template name="typedef">
-        <xsl:with-param name="class-name" select="$name"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="@kind='variable'">
-      <xsl:call-template name="variable"/>
-    </xsl:when>
-    <xsl:when test="@kind='enum'">
-      <xsl:call-template name="enum">
-        <xsl:with-param name="enum-name" select="$name"/>
-        <xsl:with-param name="id" select="$id"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="@kind='function'">
-      <xsl:call-template name="function"/>
-    </xsl:when>
-  </xsl:choose>
-
-<xsl:text>
-</xsl:text><xsl:apply-templates select="detaileddescription" mode="markup"/>
-
-<xsl:if test="$overload-count = 1">
-  <xsl:call-template name="header-requirements">
-    <xsl:with-param name="file" select="location/@file"/>
-  </xsl:call-template>
-</xsl:if>
-
-[endsect]
-
-<xsl:if test="$overload-count &gt; 1 and $overload-position = $overload-count">
-[endsect]
-</xsl:if>
-</xsl:template>
-
-
-</xsl:stylesheet>
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/release_checklist.htm b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/release_checklist.htm
deleted file mode 100644
index 3ce2cbe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/release_checklist.htm
+++ /dev/null
@@ -1,68 +0,0 @@
-<html>
-  <head>
-    <title>asio Release Checklist</title>
-  </head>
-  <body>
-    <h1>asio Release Checklist</h1>
-    <form>
-      <table border="1">
-        <tr>
-          <td>Update version number in configure.ac</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Update version number and date in README</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Generate a clean distribution by doing a `make maintainer-clean`
-              followed by the steps necessary to do a `make dist'</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution on Mac OS X using g++ 4.0 with
-              adjacent boost directory</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution on Linux using g++ 3.4 using the
-              `--with-boost' configure option</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution on Solaris using g++ 3.3 with
-              adjacent boost directory</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution using MSVC 7.1 with adjacent boost
-              directory</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution using bcc32 5.6.4 with adjacent
-              boost directory</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Unpack/build/test distribution using MinGW-4.1.0 with adjacent
-              boost directory</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Commit version number changes to CVS</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Apply CVS tag of the form asio-x-y-z</td>
-          <td><input type="checkbox"></td>
-        </tr>
-        <tr>
-          <td>Generate a clean distribution by doing a `make maintainer-clean`
-              followed by the steps necessary to do a `make dist'</td>
-          <td><input type="checkbox"></td>
-        </tr>
-      </table>
-    </form>
-  </body>
-</html>
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptHandler.qbk
deleted file mode 100644
index abefba3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AcceptHandler Accept handler requirements]
-
-An accept handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of an accept handler
-class should work correctly in the expression `h(ec)`, where `ec` is an lvalue
-of type `const error_code`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptToken.qbk
deleted file mode 100644
index bf2d054..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptToken.qbk
+++ /dev/null
@@ -1,99 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AcceptToken Accept token requirements]
-
-A accept token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code)`.
-
-[heading Examples]
-
-A free function as a accept token:
-
-  void accept_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A accept token function object:
-
-  struct accept_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a accept token:
-
-  acceptor.async_accept(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a accept token using
-`std::bind()`:
-
-  void my_class::accept_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  acceptor.async_accept(...,
-      std::bind(&my_class::accept_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a accept token using
-`boost::bind()`:
-
-  void my_class::accept_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  acceptor.async_accept(...,
-      boost::bind(&my_class::accept_handler,
-        this, asio::placeholders::error));
-
-Using [link asio.reference.use_future use_future] as a accept token:
-
-  std::future<void> f = acceptor.async_accept(..., asio::use_future);
-  ...
-  try
-  {
-    f.get();
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a accept token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      co_await acceptor.async_accept(..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptableProtocol.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptableProtocol.qbk
deleted file mode 100644
index a01ea2d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AcceptableProtocol.qbk
+++ /dev/null
@@ -1,25 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AcceptableProtocol Acceptable protocol requirements]
-
-A type `X` meets the `AcceptableProtocol` requirements if it satisfies the
-requirements of [link asio.reference.Protocol `Protocol`] as well as the
-additional requirements listed below.
-
-[table AcceptableProtocol requirements
-  [[expression] [return type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::socket`]
-    [A type that satisfies the requirements of `Destructible` (C++Std
-     \[destructible\]) and `MoveConstructible` (C++Std \[moveconstructible\]),
-     and that is publicly and unambiguously derived from `basic_socket<X>`.]
-    []
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessReadDevice.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessReadDevice.qbk
deleted file mode 100644
index 705f126..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessReadDevice.qbk
+++ /dev/null
@@ -1,56 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AsyncRandomAccessReadDevice Buffer-oriented asynchronous random-access
-read device requirements]
-
-In the table below, `a` denotes an asynchronous random access read device
-object, `o` denotes an offset of type `boost::uint64_t`, `mb` denotes an object
-satisfying [link asio.reference.MutableBufferSequence mutable buffer sequence]
-requirements, and `h` denotes an object satisfying [link
-asio.reference.ReadHandler read handler] requirements.
-
-[table Buffer-oriented asynchronous random-access read device requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.get_executor()`]
-    [A type satisfying the [link asio.reference.Executor1 Executor requirements].]
-    [Returns the associated I/O executor.]
-  ]
-  [
-    [`a.async_read_some_at(o, mb, h);`]
-    [`void`]
-    [
-      Initiates an asynchronous operation to read one or more bytes of data
-      from the device `a` at the offset `o`. The operation is performed via the
-      `io_service` object `a.get_io_service()` and behaves according to [link
-      asio.reference.asynchronous_operations asynchronous operation]
-      requirements.[br]
-      [br]
-      The mutable buffer sequence `mb` specifies memory where the data should
-      be placed. The `async_read_some_at` operation shall always fill a buffer
-      in the sequence completely before proceeding to the next.[br]
-      [br]
-      The implementation shall maintain one or more copies of `mb` until such
-      time as the read operation no longer requires access to the memory
-      specified by the buffers in the sequence. The program must ensure the
-      memory is valid until:[br]
-      [br]
-      [mdash] the last copy of `mb` is destroyed, or[br]
-      [br]
-      [mdash] the handler for the asynchronous read operation is invoked,[br]
-      [br]
-      whichever comes first.[br]
-      [br]
-      If the total size of all buffers in the sequence `mb` is `0`, the
-      asynchronous read operation shall complete immediately and pass `0` as
-      the argument to the handler that specifies the number of bytes read.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessWriteDevice.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessWriteDevice.qbk
deleted file mode 100644
index 5c9b2bb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncRandomAccessWriteDevice.qbk
+++ /dev/null
@@ -1,57 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AsyncRandomAccessWriteDevice Buffer-oriented asynchronous
-random-access write device requirements]
-
-In the table below, `a` denotes an asynchronous write stream object, `o`
-denotes an offset of type `boost::uint64_t`, `cb` denotes an object satisfying
-[link asio.reference.ConstBufferSequence constant buffer sequence]
-requirements, and `h` denotes an object satisfying [link
-asio.reference.WriteHandler write handler] requirements.
-
-[table Buffer-oriented asynchronous random-access write device requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.get_executor()`]
-    [A type satisfying the [link asio.reference.Executor1 Executor requirements].]
-    [Returns the associated I/O executor.]
-  ]
-  [
-    [`a.async_write_some_at(o, cb, h);`]
-    [`void`]
-    [
-      Initiates an asynchronous operation to write one or more bytes of data to
-      the device `a` at offset `o`. The operation is performed via the
-      `io_service` object `a.get_io_service()` and behaves according to [link
-      asio.reference.asynchronous_operations asynchronous operation]
-      requirements.[br]
-      [br]
-      The constant buffer sequence `cb` specifies memory where the data to be
-      written is located. The `async_write_some_at` operation shall always
-      write a buffer in the sequence completely before proceeding to the
-      next.[br]
-      [br]
-      The implementation shall maintain one or more copies of `cb` until such
-      time as the write operation no longer requires access to the memory
-      specified by the buffers in the sequence. The program must ensure the
-      memory is valid until:[br]
-      [br]
-      [mdash] the last copy of `cb` is destroyed, or[br]
-      [br]
-      [mdash] the handler for the asynchronous write operation is invoked,[br]
-      [br]
-      whichever comes first.[br]
-      [br]
-      If the total size of all buffers in the sequence `cb` is `0`, the
-      asynchronous write operation shall complete immediately and pass `0` as
-      the argument to the handler that specifies the number of bytes written.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncReadStream.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncReadStream.qbk
deleted file mode 100644
index 1d76fad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncReadStream.qbk
+++ /dev/null
@@ -1,50 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AsyncReadStream Buffer-oriented asynchronous read stream requirements]
-
-A type `X` meets the `AsyncReadStream` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a value of type `X`, `mb` denotes a (possibly
-const) value satisfying the [link asio.reference.MutableBufferSequence
-`MutableBufferSequence`] requirements, and `t` is a completion token.
-
-[table AsyncReadStream requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.get_executor()`]
-    [A type satisfying the [link asio.reference.Executor1 Executor requirements].]
-    [Returns the associated I/O executor.]
-  ]
-  [
-    [`a.async_read_some(mb,t)`]
-    [
-      The return type is determined according to the requirements for an
-      [link asio.reference.asynchronous_operations asynchronous operation].
-    ]
-    [
-      Meets the requirements for a [link asio.reference.read_write_operations
-      read operation] and an [link asio.reference.asynchronous_operations
-      asynchronous operation] with completion signature `void(error_code ec,
-      size_t n)`.[br]
-      [br]
-      If `buffer_size(mb) > 0`, initiates an asynchronous operation to read one
-      or more bytes of data from the stream `a` into the buffer sequence `mb`.
-      If successful, `ec` is set such that `!ec` is `true`, and `n` is the
-      number of bytes read. If an error occurred, `ec` is set such that `!!ec`
-      is `true`, and `n` is 0. If all data has been read from the stream, and
-      the stream performed an orderly shutdown, `ec` is
-      `stream_errc::eof` and `n` is 0.[br]
-      [br]
-      If `buffer_size(mb) == 0`, the operation completes immediately. `ec` is
-      set such that `!ec` is `true`, and `n` is 0.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncWriteStream.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncWriteStream.qbk
deleted file mode 100644
index de6ed5e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/AsyncWriteStream.qbk
+++ /dev/null
@@ -1,48 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:AsyncWriteStream Buffer-oriented asynchronous write stream requirements]
-
-A type `X` meets the `AsyncWriteStream` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a value of type `X`, `cb` denotes a (possibly
-const) value satisfying the [link asio.reference.ConstBufferSequence
-`ConstBufferSequence`] requirements, and `t` is a completion token.
-
-[table AsyncWriteStream requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.get_executor()`]
-    [A type satisfying the [link asio.reference.Executor1 Executor requirements].]
-    [Returns the associated I/O executor.]
-  ]
-  [
-    [`a.async_write_some(cb,t)`]
-    [
-      The return type is determined according to the requirements for an
-      [link asio.reference.asynchronous_operations asynchronous operation].
-    ]
-    [
-      Meets the requirements for a [link asio.reference.read_write_operations
-      write operation] and an [link asio.reference.asynchronous_operations
-      asynchronous operation] with completion signature `void(error_code ec,
-      size_t n)`.[br]
-      [br]
-      If `buffer_size(cb) > 0`, initiates an asynchronous operation to write
-      one or more bytes of data to the stream `a` from the buffer sequence
-      `cb`. If successful, `ec` is set such that `!ec` is `true`, and `n` is
-      the number of bytes written. If an error occurred, `ec` is set such that
-      `!!ec` is `true`, and `n` is 0.[br]
-      [br]
-      If `buffer_size(cb) == 0`, the operation completes immediately. `ec` is
-      set such that `!ec` is `true`, and `n` is 0.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeHandler.qbk
deleted file mode 100644
index 50938dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:BufferedHandshakeHandler Buffered handshake handler requirements]
-
-A buffered handshake handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a buffered handshake handler
-class should work correctly in the expression `h(ec, s)`, where `ec` is an
-lvalue of type `const error_code` and `s` is an lvalue of type `const size_t`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeToken.qbk
deleted file mode 100644
index 2832faa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/BufferedHandshakeToken.qbk
+++ /dev/null
@@ -1,111 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:BufferedHandshakeToken SSL buffered handshake token requirements]
-
-A buffered_handshake token is a [link asio.overview.model.completion_tokens
-completion token] for completion signature `void(error_code, size_t)`.
-
-[heading Examples]
-
-A free function as a buffered_handshake token:
-
-  void buffered_handshake_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-
-A buffered_handshake token function object:
-
-  struct buffered_handshake_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec,
-        std::size_t bytes_transferred)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a buffered_handshake token:
-
-  ssl_stream.async_handshake(...,
-      [](const asio::error_code& ec,
-        std::size_t bytes_transferred)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a buffered_handshake token using
-`std::bind()`:
-
-  void my_class::buffered_handshake_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      std::bind(&my_class::buffered_handshake_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a buffered_handshake token using
-`boost::bind()`:
-
-  void my_class::buffered_handshake_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      boost::bind(&my_class::buffered_handshake_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::bytes_transferred));
-
-Using [link asio.reference.use_future use_future] as a buffered handshake token:
-
-  std::future<std::size_t> f =
-    ssl_stream.async_handshake(..., asio::use_future);
-  ...
-  try
-  {
-    std::size_t n = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a buffered handshake
-token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      std::size_t n =
-        co_await ssl_stream.async_handshake(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationHandler.qbk
deleted file mode 100644
index 18e93af..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationHandler.qbk
+++ /dev/null
@@ -1,49 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:CancellationHandler Cancellation handler requirements]
-
-A value `h` of a cancellation handler class should work correctly in the
-expression `h(t)`, where `t` is a value of type
-`asio::cancellation_type`.
-
-[heading Examples]
-
-A free function as a cancellation handler:
-
-  void cancellation_handler(
-      asio::cancellation_type type)
-  {
-    ...
-  }
-
-  slot.assign(cancellation_handler);
-
-A cancellation handler function object:
-
-  struct cancellation_handler
-  {
-    ...
-    void operator()(
-        asio::cancellation_type type)
-    {
-      ...
-    }
-    ...
-  };
-
-  cancellation_handler& h = slot.assign(cancellation_handler{ ... });
-
-A lambda as a cancellation handler:
-
-  auto& h = slot.assign(
-      [](asio::cancellation_type type)
-      {
-        ...
-      });
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationSlot.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationSlot.qbk
deleted file mode 100644
index 541e30f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CancellationSlot.qbk
+++ /dev/null
@@ -1,92 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:CancellationSlot Cancellation slot requirements]
-
-A type `X` meets the `CancellationSlot` requirements if it satisfies the
-requirements of `CopyConstructible` (C++Std [copyconstructible]) and
-`Destructible` (C++Std [destructible]), as well as the additional requirements
-listed below.
-
-In the table below, `x1` and `x2` denote (possibly const) values of type `X`,
-`mx1` denotes an xvalue of type `X`, `H` denotes a type that satisfies
-`CancellationHandler`, `h` denotes an xvalue of type `H`, and `u0` to `uN`
-denote identifiers.
-
-[table CancellationSlot requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X u(x1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u == x1`.]
-  ]
-  [
-    [`X u(mx1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u` equals the prior value of `mx1`.]
-  ]
-  [
-    [`x1 == x2`]
-    [`bool`]
-    [ Returns `true` only if `x1` and `x2` can be interchanged with identical
-     effects.
-     [br]
-     `operator==` shall be reflexive, symmetric, and transitive, and shall not
-     exit via an exception.]
-  ]
-  [
-    [`x1 != x2`]
-    [`bool`]
-    [Same as `!(x1 == x2)`.]
-  ]
-  [
-    [`x1.is_connected()`]
-    [`bool`]
-    [Returns `false` only if the slot can never cause the invocation of a
-     handler attached to the slot using `assign` or `emplace`.]
-  ]
-  [
-    [`x1.has_handler()`]
-    [`bool`]
-    [Returns `true` if a handler has been attached to the slot.]
-  ]
-  [
-    [`x1.assign(h)`]
-    [`H&`]
-    [Destroys the existing handler that is attached to the slot, if any, and
-     attaches a move-constructed decay-copy of the handler `h`.[br]
-     [br]
-     Returns a reference to the newly attached handler.[br]
-     [br]
-     post: `x1.has_handler() == true`.]
-  ]
-  [
-    [`x1.emplace<H>(u0, ..., uN)`]
-    [`H&`]
-    [Requires that `is_constructible<H, decltype(u0), ...,
-     decltype(u0)>::value` be true.[br]
-     [br]
-     Destroys the existing handler that is attached to the slot, if any, and
-     attaches a handler of type `H` constructed with the specified arguments
-     `u0, ..., uN`.[br]
-     [br]
-     Returns a reference to the newly attached handler.[br]
-     [br]
-     post: `x1.has_handler() == true`.]
-  ]
-  [
-    [`x1.clear()`]
-    []
-    [Post: `x1.has_handler() == false`.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CompletionCondition.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CompletionCondition.qbk
deleted file mode 100644
index 0b8d2b9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/CompletionCondition.qbk
+++ /dev/null
@@ -1,42 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:CompletionCondition Completion condition requirements]
-
-A ['completion condition] is a function object that is used with the algorithms
-[link asio.reference.read `read`], [link asio.reference.async_read
-`async_read`], [link asio.reference.write `write`], and [link
-asio.reference.async_write `async_write`] to determine when the algorithm has
-completed transferring data.
-
-A type `X` meets the `CompletionCondition` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and
-`MoveConstructible` (C++Std [moveconstructible]), as well as the additional
-requirements listed below.
-
-In the table below, `x` denotes a value of type `X`, `ec` denotes a (possibly
-const) value of type `error_code`, and `n` denotes a (possibly const) value of
-type `size_t`.
-
-[table CompletionCondition requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`x(ec, n)`]
-    [`size_t`]
-    [
-      Let `n` be the total number of bytes transferred by the read or write
-      algorithm so far.[br]
-      [br]
-      Returns the maximum number of bytes to be transferred on the next
-      `read_some`, `async_read_some`, `write_some`, or `async_write_some`
-      operation performed by the algorithm. Returns `0` to indicate that the
-      algorithm is complete.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectCondition.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectCondition.qbk
deleted file mode 100644
index ac2e5ae..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectCondition.qbk
+++ /dev/null
@@ -1,34 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ConnectCondition Connect condition requirements]
-
-A type `X` meets the `ConnectCondition` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and
-`CopyConstructible` (C++Std [copyconstructible]), as well as the additional
-requirements listed below.
-
-In the table below, `x` denotes a value of type `X`, `ec` denotes a (possibly
-const) value of type `error_code`, and `ep` denotes a (possibly const) value of
-some type satisfying the [link asio.reference.Endpoint endpoint] requirements.
-
-[table ConnectCondition requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`x(ec, ep)`]
-    [`bool`]
-    [
-      Returns `true` to indicate that the `connect` or `async_connect`
-      algorithm should attempt a connection to the endpoint `ep`. Otherwise,
-      returns `false` to indicate that the algorithm should not attempt
-      connection to the endpoint `ep`, and should instead skip to the next
-      endpoint in the sequence.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectHandler.qbk
deleted file mode 100644
index d4ea215..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ConnectHandler Connect handler requirements]
-
-A connect handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a connect handler
-class should work correctly in the expression `h(ec)`, where `ec` is an lvalue
-of type `const error_code`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectToken.qbk
deleted file mode 100644
index 79cc5c7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConnectToken.qbk
+++ /dev/null
@@ -1,99 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ConnectToken Connect token requirements]
-
-A connect token is a [link asio.overview.model.completion_tokens completion token]
-for completion signature `void(error_code)`.
-
-[heading Examples]
-
-A free function as a connect token:
-
-  void connect_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A connect token function object:
-
-  struct connect_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a connect token:
-
-  socket.async_connect(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a connect token using
-`std::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  socket.async_connect(...,
-      std::bind(&my_class::connect_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a connect token using
-`boost::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  socket.async_connect(...,
-      boost::bind(&my_class::connect_handler,
-        this, asio::placeholders::error));
-
-Using [link asio.reference.use_future use_future] as a connect token:
-
-  std::future<void> f = socket.async_connect(..., asio::use_future);
-  ...
-  try
-  {
-    f.get();
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a connect token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      co_await socket.async_connect(..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConstBufferSequence.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConstBufferSequence.qbk
deleted file mode 100644
index cde278f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ConstBufferSequence.qbk
+++ /dev/null
@@ -1,53 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ConstBufferSequence Constant buffer sequence requirements]
-
-A ['constant buffer sequence] represents a set of memory regions that may be
-used as input to an operation, such as the `send` operation of a socket.
-
-A type `X` meets the `ConstBufferSequence` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and
-`CopyConstructible` (C++Std [copyconstructible]), as well as the additional
-requirements listed below.
-
-In the table below, `x` denotes a (possibly const) value of type `X`, and `u`
-denotes an identifier.
-
-[table ConstBufferSequence requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`asio::buffer_sequence_begin(x)`[br]
-     `asio::buffer_sequence_end(x)`]
-    [An iterator type meeting the requirements for bidirectional iterators
-     (C++Std \[bidirectional.iterators\]) whose value type is convertible to
-     `const_buffer`.]
-    []
-  ]
-  [
-    [``
-      X u(x);
-    ``]
-    []
-    [post:[br]
-     ``
-       equal(
-         asio::buffer_sequence_begin(x),
-         asio::buffer_sequence_end(x),
-         asio::buffer_sequence_begin(u),
-         asio::buffer_sequence_end(u),
-         [](const const_buffer& b1,
-            const const_buffer& b2)
-          {
-            return b1.data() == b2.data()
-                && b1.size() == b2.size();
-          })
-     ``]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer.qbk
deleted file mode 100644
index 71ee3fe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer.qbk
+++ /dev/null
@@ -1,16 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:DynamicBuffer Dynamic buffer requirements]
-
-See:
-
-* [link asio.reference.DynamicBuffer_v1 Dynamic buffer requirements (version 1)]
-
-* [link asio.reference.DynamicBuffer_v2 Dynamic buffer requirements (version 2)]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v1.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v1.qbk
deleted file mode 100644
index 6cf03c9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v1.qbk
+++ /dev/null
@@ -1,93 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:DynamicBuffer_v1 Dynamic buffer requirements (version 1)]
-
-A dynamic buffer encapsulates memory storage that may be automatically resized
-as required, where the memory is divided into an input sequence followed by an
-output sequence. These memory regions are internal to the dynamic buffer
-sequence, but direct access to the elements is provided to permit them to be
-efficiently used with I/O operations, such as the `send` or `receive`
-operations of a socket. Data written to the output sequence of a dynamic buffer
-sequence object is appended to the input sequence of the same object.
-
-A dynamic buffer type `X` shall satisfy the requirements of `MoveConstructible`
-(C++ Std, [moveconstructible]) types in addition to those listed below.
-
-In the table below, `X` denotes a dynamic buffer class, `x` denotes a
-value of type `X&`, `x1` denotes values of type `const X&`, and `n` denotes a
-value of type `size_t`, and `u` denotes an identifier.
-
-[table DynamicBuffer_v1 requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::const_buffers_type`]
-    [type meeting [link asio.reference.ConstBufferSequence ConstBufferSequence]
-     requirements.]
-    [This type represents the memory associated with the input sequence.]
-  ]
-  [
-    [`X::mutable_buffers_type`]
-    [type meeting [link asio.reference.MutableBufferSequence MutableBufferSequence]
-     requirements.]
-    [This type represents the memory associated with the output sequence.]
-  ]
-  [
-    [`x1.size()`]
-    [`size_t`]
-    [Returns the size, in bytes, of the input sequence.]
-  ]
-  [
-    [`x1.max_size()`]
-    [`size_t`]
-    [Returns the permitted maximum of the sum of the sizes of the input
-     sequence and output sequence.]
-  ]
-  [
-    [`x1.capacity()`]
-    [`size_t`]
-    [Returns the maximum sum of the sizes of the input sequence and output
-     sequence that the dynamic buffer can hold without requiring reallocation.]
-  ]
-  [
-    [`x1.data()`]
-    [`X::const_buffers_type`]
-    [Returns a constant buffer sequence `u` that represents the memory
-     associated with the input sequence, and where `buffer_size(u) == size()`.]
-  ]
-  [
-    [`x.prepare(n)`]
-    [`X::mutable_buffers_type`]
-    [Requires: `size() + n <= max_size()`.[br]
-     [br]
-     Returns a mutable buffer sequence `u` representing the output sequence, and
-     where `buffer_size(u) == n`. The dynamic buffer reallocates memory as
-     required. All constant or mutable buffer sequences previously obtained
-     using `data()` or `prepare()` are invalidated.[br]
-     [br]
-     Throws: `length_error` if `size() + n > max_size()`.]
-  ]
-  [
-    [`x.commit(n)`]
-    []
-    [Appends `n` bytes from the start of the output sequence to the end of the
-     input sequence. The remainder of the output sequence is discarded. If `n`
-     is greater than the size of the output sequence, the entire output sequence
-     is appended to the input sequence. All constant or mutable buffer sequences
-     previously obtained using `data()` or `prepare()` are invalidated.]
-  ]
-  [
-    [`x.consume(n)`]
-    []
-    [Removes `n` bytes from beginning of the input sequence. If `n` is greater
-     than the size of the input sequence, the entire input sequence is removed.
-     All constant or mutable buffer sequences previously obtained using `data()`
-     or `prepare()` are invalidated.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v2.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v2.qbk
deleted file mode 100644
index 6b28f03..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/DynamicBuffer_v2.qbk
+++ /dev/null
@@ -1,94 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:DynamicBuffer_v2 Dynamic buffer requirements (version 2)]
-
-A dynamic buffer encapsulates memory storage that may be automatically resized
-as required.
-
-A dynamic buffer type `X` shall satisfy the requirements of `CopyConstructible`
-(C++ Std, [copyconstructible]) types in addition to those listed below.
-
-In the table below, `X` denotes a dynamic buffer class, `x` denotes a value of
-type `X&`, `x1` denotes values of type `const X&`, `pos` and `n` denote values
-of type `size_t`, and `u` denotes an identifier.
-
-[table DynamicBuffer_v2 requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::const_buffers_type`]
-    [type meeting [link asio.reference.ConstBufferSequence ConstBufferSequence]
-     requirements.]
-    [This type represents the underlying memory as a sequence of @c const_buffer
-     objects.]
-  ]
-  [
-    [`X::mutable_buffers_type`]
-    [type meeting [link asio.reference.MutableBufferSequence MutableBufferSequence]
-     requirements.]
-    [This type represents the underlying memory as a sequence of @c
-     mutable_buffer objects.]
-  ]
-  [
-    [`x1.size()`]
-    [`size_t`]
-    [Returns the size, in bytes, of the underlying memory.]
-  ]
-  [
-    [`x1.max_size()`]
-    [`size_t`]
-    [Returns the permitted maximum size of the underlying memory.]
-  ]
-  [
-    [`x1.capacity()`]
-    [`size_t`]
-    [Returns the maximum size to which the underlying memory can grow without
-     requiring reallocation.]
-  ]
-  [
-    [`x1.data(pos, n)`]
-    [`X::const_buffers_type`]
-    [Returns a constant buffer sequence `u` that represents the underlying
-     memory beginning at offset `pos`, and where `buffer_size(u) <= n`.]
-  ]
-  [
-    [`x.data(pos, n)`]
-    [`X::mutable_buffers_type`]
-    [Returns a mutable buffer sequence `u` that represents the underlying
-     memory beginning at offset `pos`, and where `buffer_size(u) <= n`.]
-  ]
-  [
-    [`x.grow(n)`]
-    []
-    [Requires: `size() + n <= max_size()`.[br]
-     [br]
-     Extends the underlying memory to accommodate `n` additional bytes at the
-     end. The dynamic buffer reallocates memory as required. All constant or
-     mutable buffer sequences previously obtained using `data()` are
-     invalidated.[br]
-     [br]
-     Throws: `length_error` if `size() + n > max_size()`.]
-  ]
-  [
-    [`x.shrink(n)`]
-    []
-    [Removes `n` bytes from the end of the underlying memory. If `n` is greater
-     than the size of the underlying memory, the entire underlying memory is
-     emptied. All constant or mutable buffer sequences previously obtained
-     using `data()` are invalidated.]
-  ]
-  [
-    [`x.consume(n)`]
-    []
-    [Removes `n` bytes from the beginning of the underlying memory. If `n` is
-     greater than the size of the underlying memory, the entire underlying memory
-     is emptied. All constant or mutable buffer sequences previously obtained
-     using `data()` are invalidated.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Endpoint.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Endpoint.qbk
deleted file mode 100644
index 6c2eb94..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Endpoint.qbk
+++ /dev/null
@@ -1,97 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:Endpoint Endpoint requirements]
-
-A type `X` meets the `Endpoint` requirements if it satisfies the requirements
-of `Destructible` (C++Std [destructible]), `DefaultConstructible` (C++Std
-[defaultconstructible]), `CopyConstructible` (C++Std [copyconstructible]),
-and `CopyAssignable` (C++Std [copyassignable]), as well as the additional
-requirements listed below.
-
-The default constructor and move operations of the type `X` shall not exit via
-an exception.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, and `u`
-denotes an identifier.
-
-[table Endpoint requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::protocol_type`]
-    [type meeting [link asio.reference.Protocol `Protocol`] requirements]
-    []
-  ]
-  [
-    [`a.protocol()`]
-    [`protocol_type`]
-    []
-  ]
-]
-
-In the table below, `a` denotes a (possibly const) value of type `X`, `b`
-denotes a value of type `X`, and `s` denotes a (possibly const) value of a type
-that is convertible to `size_t` and denotes a size in bytes.
-
-[table Endpoint requirements for extensible implementations
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.data()`]
-    [`const void*`]
-    [
-      Returns a pointer suitable for passing as the /address/ argument to
-      functions such as __POSIX__ __connect__, or as the /dest_addr/ argument
-      to functions such as  __POSIX__ __sendto__. The implementation shall
-      perform a `static_cast` on the pointer to convert it to `const
-      sockaddr*`.
-    ]
-  ]
-  [
-    [`b.data()`]
-    [`void*`]
-    [
-      Returns a pointer suitable for passing as the /address/ argument to
-      functions such as __POSIX__ __accept__, __getpeername__, __getsockname__
-      and __recvfrom__. The implementation shall perform a `static_cast` on the
-      pointer to convert it to `sockaddr*`.
-    ]
-  ]
-  [
-    [`a.size()`]
-    [`size_t`]
-    [
-      Returns a value suitable for passing as the /address_len/ argument
-      to functions such as __POSIX__ __connect__, or as the /dest_len/ argument
-      to functions such as __POSIX__ __sendto__, after appropriate integer
-      conversion has been performed.
-    ]
-  ]
-  [
-    [`b.resize(s)`]
-    []
-    [
-      pre: `s >= 0`[br]
-      post: `a.size() == s`[br]
-      Passed the value contained in the /address_len/ argument to functions
-      such as __POSIX__ __accept__, __getpeername__, __getsockname__ and
-      __recvfrom__, after successful completion of the function. Permitted to
-      throw an exception if the protocol associated with the endpoint object
-      `a` does not support the specified size.
-    ]
-  ]
-  [
-    [`a.capacity()`]
-    [`size_t`]
-    [
-      Returns a value suitable for passing as the /address_len/ argument to
-      functions such as __POSIX__ __accept__, __getpeername__, __getsockname__
-      and __recvfrom__, after appropriate integer conversion has been performed.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/EndpointSequence.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/EndpointSequence.qbk
deleted file mode 100644
index d5100ff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/EndpointSequence.qbk
+++ /dev/null
@@ -1,30 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:EndpointSequence Endpoint sequence requirements]
-
-A type `X` meets the `EndpointSequence` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and `CopyConstructible`
-(C++Std [copyconstructible]), as well as the additional requirements listed
-below.
-
-In the table below, `x` denotes a (possibly const) value of type `X`.
-
-[table EndpointSequence requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`x.begin()`[br]
-     `x.end()`]
-    [A type meeting the requirements for forward iterators
-     (C++Std \[forward.iterators\]) whose value type is convertible to
-     a type satisfying the [link asio.reference.Endpoint `Endpoint`]
-     requirements.]
-    [[half_open_range `x.begin()`,`x.end()`] is a valid range.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ExecutionContext.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ExecutionContext.qbk
deleted file mode 100644
index 1846f6e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ExecutionContext.qbk
+++ /dev/null
@@ -1,36 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ExecutionContext Execution context requirements]
-
-A type `X` meets the `ExecutionContext` requirements if it is publicly and
-unambiguously derived from `execution_context`, and satisfies the additional
-requirements listed below.
-
-In the table below, `x` denotes a value of type `X`.
-
-[table ExecutionContext requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`X::executor_type`]
-    [type meeting [link asio.reference.Executor1 `Executor`] requirements]
-    []
-  ]
-  [
-    [`x.~X()`]
-    []
-    [Destroys all unexecuted function objects that were submitted via an
-     executor object that is associated with the execution context.]
-  ]
-  [
-    [`x.get_executor()`]
-    [`X::executor_type`]
-    [Returns an executor object that is associated with the execution context.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Executor.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Executor.qbk
deleted file mode 100644
index c1c33ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Executor.qbk
+++ /dev/null
@@ -1,222 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:Executor1 Executor requirements]
-
-[heading Standard executors]
-
-Let `executor-of-impl` be the exposition-only concept
-
-    template<class E, class F>
-      concept executor-of-impl =
-        invocable<decay_t<F>&> &&
-        constructible_from<decay_t<F>, F> &&
-        move_constructible<decay_t<F>> &&
-        copy_constructible<E> &&
-        is_nothrow_copy_constructible_v<E> &&
-        equality_comparable<E> /* nothrow */ &&
-        requires(const E& e, F&& f) {
-          e.execute((F&&)f);
-        };
-
-Then the `executor` and `executor_of` concepts are defined as follows:
-
-    template<class E>
-      concept executor =
-        executor-of-impl<E, execution::invocable_archetype>;
-
-    template<class E, class F>
-      concept executor_of =
-        executor<E> &&
-        executor-of-impl<E, F>;
-
-Neither an executor's equality comparison nor `swap` operation shall exit via
-an exception.
-
-None of an executor type's copy constructor, destructor, equality comparison,
-`swap` function, `execute` function, or associated `query` functions shall
-introduce data races as a result of concurrent invocations of those functions
-from different threads.
-
-For any two (possibly const) values `x1` and `x2` of some executor type `X`,
-`x1 == x2` shall return `true` only if `asio::query(x1,p) == asio::query(x2,p)`
-for every property `p` where both `asio::query(x1,p)` and `asio::query(x2,p)`
-are well-formed and result in a non-void type that is `equality_comparable`
-(C++Std [equalitycomparable]). [inline_note The above requirements imply that `x1
-== x2` returns `true` if `x1` and `x2` can be interchanged with identical
-effects. An executor may conceptually contain additional properties which are
-not exposed by a named property type that can be observed via `asio::query`; in
-this case, it is up to the concrete executor implementation to decide if these
-properties affect equality. Returning `false` does not necessarily imply that
-the effects are not identical.]
-
-An executor type's destructor shall not block pending completion of the
-submitted function objects. [inline_note The ability to wait for completion of
-submitted function objects may be provided by the associated execution
-context.]
-
-In addition to the above requirements, types `E` and `F` model `executor_of`
-only if they satisfy the requirements of the Table below.
-
-Let:
-
-* `e` denotes a (possibly const) executor object of type `E`,
-
-* `cf` denotes the function object `DECAY_COPY(std::forward<F>(f))`
-
-* `f` denotes a function of type `F&&` invocable as `cf()` and where
-  `decay_t<F>` models `move_constructible`.
-
-The expression `e.execute(f)`:
-
-* Evaluates `DECAY_COPY(std::forward<F>(f))` on the calling thread to create
-  `cf` that will be invoked at most once by an execution agent.
-
-* May block pending completion of this invocation. Synchronizes with
-  [intro.multithread] the invocation of `f`.
-
-* Shall not propagate any exception thrown by the function object or any other
-  function submitted to the executor.
-
-[inline_note The treatment of exceptions thrown by one-way submitted functions
-is implementation-defined. The forward progress guarantee of the associated
-execution agent(s) is implementation-defined.]
-
-[heading Networking TS-style executors]
-
-The library describes a standard set of requirements for ['executors]. A type
-meeting the `Executor` requirements embodies a set of rules for determining how
-submitted function objects are to be executed.
-
-A type `X` meets the `Executor` requirements if it satisfies the requirements of
-`CopyConstructible` (C++Std [copyconstructible]) and `Destructible` (C++Std
-[destructible]), as well as the additional requirements listed below.
-
-No constructor, comparison operator, copy operation, move operation, swap
-operation, or member functions `context`, `on_work_started`, and
-`on_work_finished` on these types shall exit via an exception.
-
-The executor copy constructor, comparison operators, and other member functions
-defined in these requirements shall not introduce data races as a result of
-concurrent calls to those functions from different threads.
-
-Let `ctx` be the execution context returned by the executor's `context()`
-member function. An executor becomes ['invalid] when the first call to
-`ctx.shutdown()` returns. The effect of calling `on_work_started`,
-`on_work_finished`, `dispatch`, `post`, or `defer` on an invalid executor is
-undefined. [inline_note The copy constructor, comparison operators, and
-`context()` member function continue to remain valid until `ctx` is destroyed.]
-
-In the table below, `x1` and `x2` denote (possibly const) values of type `X`,
-`mx1` denotes an xvalue of type `X`, `f` denotes a `MoveConstructible` (C++Std
-[moveconstructible]) function object callable with zero arguments, `a` denotes
-a (possibly const) value of type `A` meeting the `Allocator` requirements
-(C++Std [allocator.requirements]), and `u` denotes an identifier.
-
-[table Executor requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X u(x1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u == x1` and
-     `std::addressof(u.context()) == std::addressof(x1.context()).`]
-  ]
-  [
-    [`X u(mx1);`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     post: `u` equals the prior value of `mx1` and
-     `std::addressof(u.context())` equals the prior value of
-     `std::addressof(mx1.context())`.]
-  ]
-  [
-    [`x1 == x2`]
-    [`bool`]
-    [ Returns `true` only if `x1` and `x2` can be interchanged with identical
-     effects in any of the expressions defined in these type requirements.
-     [inline_note Returning `false` does not necessarily imply that the effects
-     are not identical.][br]
-     [br]
-     `operator==` shall be reflexive, symmetric, and transitive, and shall not
-     exit via an exception.]
-  ]
-  [
-    [`x1 != x2`]
-    [`bool`]
-    [Same as `!(x1 == x2)`.]
-  ]
-  [
-    [`x1.context()`]
-    [`execution_context&`, or `E&` where `E` is a type that satifisfies the
-     [link asio.reference.ExecutionContext `ExecutionContext`] requirements.]
-    [Shall not exit via an exception.[br]
-     [br]
-     The comparison operators and member functions defined in these
-     requirements shall not alter the reference returned by this function.]
-  ]
-  [
-    [`x1.on_work_started()`]
-    []
-    [Shall not exit via an exception.]
-  ]
-  [
-    [`x1.on_work_finished()`]
-    []
-    [Shall not exit via an exception.[br]
-     [br]
-     Precondition: A preceding call `x2.on_work_started()` where `x1 == x2`.]
-  ]
-  [
-    [`x1.dispatch(std::move(f),a)`]
-    []
-    [Effects: Creates an object `f1` initialized with
-     [^['DECAY_COPY]]`(forward<Func>(f))` (C++Std \[thread.decaycopy\]) in the
-     current thread of execution . Calls `f1()` at most once. The executor may
-     block forward progress of the caller until `f1()` finishes execution.[br]
-     [br]
-     Executor implementations should use the supplied allocator to allocate any
-     memory required to store the function object. Prior to invoking the
-     function object, the executor shall deallocate any memory allocated.
-     [inline_note Executors defined in this Technical Specification always use
-     the supplied allocator unless otherwise specified.][br]
-     [br]
-     Synchronization: The invocation of `dispatch` synchronizes with (C++Std
-     \[intro.multithread\]) the invocation of `f1`.]
-  ]
-  [
-    [`x1.post(std::move(f),a)`[br]
-     `x1.defer(std::move(f),a)`]
-    []
-    [Effects: Creates an object `f1` initialized with
-     [^['DECAY_COPY]]`(forward<Func>(f))` in the current thread of execution.
-     Calls `f1()` at most once. The executor shall not block forward progress
-     of the caller pending completion of `f1()`.[br]
-     [br]
-     Executor implementations should use the supplied allocator to allocate any
-     memory required to store the function object. Prior to invoking the
-     function object, the executor shall deallocate any memory allocated.
-     [inline_note Executors defined in this Technical Specification always use
-     the supplied allocator unless otherwise specified.][br]
-     [br]
-     Synchronization: The invocation of `post` or `defer` synchronizes with
-     (C++Std \[intro.multithread\]) the invocation of `f1`.[br]
-     [br]
-     [inline_note Although the requirements placed on `defer` are identical to
-     `post`, the use of `post` conveys a preference that the caller ['does not]
-     block the first step of [^f1]'s progress, whereas `defer` conveys a
-     preference that the caller ['does] block the first step of [^f1]. One use
-     of `defer` is to convey the intention of the caller that [^f1] is a
-     continuation of the current call context. The executor may use this
-     information to optimize or otherwise adjust the way in which `f1` is
-     invoked.]]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSerialPortOption.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSerialPortOption.qbk
deleted file mode 100644
index 7733a8b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSerialPortOption.qbk
+++ /dev/null
@@ -1,33 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:GettableSerialPortOption Gettable serial port option requirements]
-
-In the table below, `X` denotes a serial port option class, `a` denotes a value
-of `X`, `ec` denotes a value of type `error_code`, and `s` denotes a value of
-implementation-defined type ['[^storage]] (where ['[^storage]] is the type
-`DCB` on Windows and `termios` on __POSIX__ platforms), and `u` denotes an
-identifier.
-
-[table GettableSerialPortOption requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [
-      `const `['[^storage]]`& u = s;`[br]
-      `a.load(u, ec);`
-    ]
-    [`error_code`]
-    [
-      Retrieves the value of the serial port option from the storage.[br]
-      [br]
-      If successful, sets `ec` such that `!ec` is true. If an error occurred,
-      sets `ec` such that `!!ec` is true. Returns `ec`.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSocketOption.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSocketOption.qbk
deleted file mode 100644
index 49db064..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/GettableSocketOption.qbk
+++ /dev/null
@@ -1,67 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:GettableSocketOption Gettable socket option requirements]
-
-A type `X` meets the `GettableSocketOption` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, `b`
-denotes a value of type `X`, `p` denotes a (possibly const) value that meets
-the [link asio.reference.Protocol `Protocol`] requirements, and `s` denotes a
-(possibly const) value of a type that is convertible to `size_t` and denotes a
-size in bytes.
-
-[table GettableSocketOption requirements for extensible implementations
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.level(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /level/ argument to __POSIX__
-      __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.name(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /option_name/ argument to
-      __POSIX__ __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`b.data(p)`]
-    [`void*`]
-    [
-      Returns a pointer suitable for passing as the /option_value/ argument to
-      __POSIX__ __getsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.size(p)`]
-    [`size_t`]
-    [
-      Returns a value suitable for passing as the /option_len/ argument to
-      __POSIX__ __getsockopt__ (or equivalent), after appropriate
-      integer conversion has been performed.
-    ]
-  ]
-  [
-    [`b.resize(p,s)`]
-    []
-    [
-      post: `b.size(p) == s`.[br]
-      Passed the value contained in the /option_len/ argument to __POSIX__
-      __getsockopt__ (or equivalent) after successful completion of the
-      function. Permitted to throw an exception if the socket option object `b`
-      does not support the specified size.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Handler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Handler.qbk
deleted file mode 100644
index 89e5f24..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Handler.qbk
+++ /dev/null
@@ -1,19 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:Handler Handlers]
-
-A handler must satisfy the requirements of `Destructible` (C++Std
-[destructible]) and `MoveConstructible` (C++Std [moveconstructible]).
-
-A handler may expose additional information and behaviour via [link
-asio.overview.model.associators associators], such as [link
-asio.reference.associated_allocator `associated_allocator`], [link
-asio.reference.associated_executor `associated_executor`], and [link
-asio.reference.associated_cancellation_slot `associated_cancellation_slot`].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeHandler.qbk
deleted file mode 100644
index 7cb4a79..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:HandshakeHandler SSL handshake handler requirements]
-
-A handshake handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a handshake handler
-class should work correctly in the expression `h(ec)`, where `ec` is an lvalue
-of type `const error_code`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeToken.qbk
deleted file mode 100644
index 00b3947..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/HandshakeToken.qbk
+++ /dev/null
@@ -1,99 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:HandshakeToken SSL handshake token requirements]
-
-A handshake token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code)`.
-
-[heading Examples]
-
-A free function as a handshake token:
-
-  void handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A handshake token function object:
-
-  struct handshake_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a handshake token:
-
-  ssl_stream.async_handshake(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a handshake token using
-`std::bind()`:
-
-  void my_class::handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      std::bind(&my_class::handshake_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a handshake token using
-`boost::bind()`:
-
-  void my_class::handshake_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_handshake(...,
-      boost::bind(&my_class::handshake_handler,
-        this, asio::placeholders::error));
-
-Using [link asio.reference.use_future use_future] as a handshake token:
-
-  std::future<void> f = ssl_stream.async_handshake(..., asio::use_future);
-  ...
-  try
-  {
-    f.get();
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a handshake token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      co_await ssl_stream.async_handshake(..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/InternetProtocol.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/InternetProtocol.qbk
deleted file mode 100644
index 84a5460..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/InternetProtocol.qbk
+++ /dev/null
@@ -1,47 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:InternetProtocol Internet protocol requirements]
-
-A type `X` meets the `InternetProtocol` requirements if it satisfies the
-requirements of [link asio.reference.AcceptableProtocol `AcceptableProtocol`],
-as well as the additional requirements listed below.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, and `b`
-denotes a (possibly const) value of type `X`.
-
-[table InternetProtocol requirements
-  [[expression] [return type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::resolver`]
-    [`ip::basic_resolver<X>`]
-    [The type of a resolver for the protocol.]
-  ]
-  [
-    [`X::v4()`]
-    [`X`]
-    [Returns an object representing the IP version 4 protocol.]
-  ]
-  [
-    [`X::v6()`]
-    [`X`]
-    [Returns an object representing the IP version 6 protocol.]
-  ]
-  [
-    [`a == b`]
-    [convertible to `bool`]
-    [Returns `true` if `a` and `b` represent the same IP protocol version,
-     otherwise `false`.]
-  ]
-  [
-    [`a != b`]
-    [convertible to `bool`]
-    [Returns `!(a == b)`.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoControlCommand.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoControlCommand.qbk
deleted file mode 100644
index c4a7002..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoControlCommand.qbk
+++ /dev/null
@@ -1,34 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:IoControlCommand I/O control command requirements]
-
-A type `X` meets the `IoControlCommand` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, and `b`
-denotes a value of type `X`.
-
-[table IoControlCommand requirements for extensible implementations
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.name()`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /request/ argument to
-      __POSIX__ __ioctl__ (or equivalent).
-    ]
-  ]
-  [
-    [`b.data()`]
-    [`void*`]
-    [
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoObjectService.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoObjectService.qbk
deleted file mode 100644
index afe90c9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IoObjectService.qbk
+++ /dev/null
@@ -1,62 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:IoObjectService I/O object service requirements]
-
-An I/O object service must meet the requirements for a [link
-asio.reference.Service service], as well as the requirements listed
-below.
-
-In the table below, `X` denotes an I/O object service class, `a` and `ao` denote
-values of type `X`, `b` and `c` denote values of type `X::implementation_type`,
-and `u` denotes an identifier.
-
-[table IoObjectService requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`X::implementation_type`]
-    []
-    []
-  ]
-  [
-    [`X::implementation_type u;`]
-    []
-    [note: `X::implementation_type` has a public default constructor and
-     destructor.]
-  ]
-  [
-    [``
-      a.construct(b);
-    ``]
-    []
-    []
-  ]
-  [
-    [``
-      a.destroy(b);
-    ``]
-    []
-    [note: `destroy()` will only be called on a value that has previously been
-     initialised with `construct()` or `move_construct()`.]
-  ]
-  [
-    [``
-      a.move_construct(b, c);
-    ``]
-    []
-    [note: only required for I/O objects that support movability.]
-  ]
-  [
-    [``
-      a.move_assign(b, ao, c);
-    ``]
-    []
-    [note: only required for I/O objects that support movability.]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectHandler.qbk
deleted file mode 100644
index 58948e9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectHandler.qbk
+++ /dev/null
@@ -1,16 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:IteratorConnectHandler Iterator connect handler requirements]
-
-An iterator connect handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of an iterator connect handler
-class should work correctly in the expression `h(ec, i)`, where `ec` is an
-lvalue of type `const error_code` and `i` is an lvalue of the type `Iterator`
-used in the corresponding `async_connect()` function.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectToken.qbk
deleted file mode 100644
index 1c851a0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/IteratorConnectToken.qbk
+++ /dev/null
@@ -1,113 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:IteratorConnectToken Iterator connect token requirements]
-
-An iterator connect token is a [link asio.overview.model.completion_tokens
-completion token] for completion signature `void(error_code, Iterator)`, where
-the type `Iterator` is used in the corresponding `async_connect()` function.
-
-[heading Examples]
-
-A free function as an iterator connect token:
-
-  void connect_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::iterator iterator)
-  {
-    ...
-  }
-
-An iterator connect token function object:
-
-  struct connect_handler
-  {
-    ...
-    template <typename Iterator>
-    void operator()(
-        const asio::error_code& ec,
-        Iterator iterator)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as an iterator connect token:
-
-  asio::async_connect(...,
-      [](const asio::error_code& ec,
-        asio::ip::tcp::resolver::iterator iterator)
-      {
-        ...
-      });
-
-A non-static class member function adapted to an iterator connect token using
-`std::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::iterator iterator)
-  {
-    ...
-  }
-  ...
-  asio::async_connect(...,
-      std::bind(&my_class::connect_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to an iterator connect token using
-`boost::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::iterator iterator)
-  {
-    ...
-  }
-  ...
-  asio::async_connect(...,
-      boost::bind(&my_class::connect_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::iterator));
-
-Using [link asio.reference.use_future use_future] as an iterator connect token:
-
-  std::future<asio::ip::tcp::resolver::iterator> f =
-    asio::async_connect(..., asio::use_future);
-  ...
-  try
-  {
-    asio::ip::tcp::resolver::iterator i = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as an iterator connect
-token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      asio::ip::tcp::resolver::iterator i =
-        co_await asio::async_connect(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/LegacyCompletionHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/LegacyCompletionHandler.qbk
deleted file mode 100644
index 663a771..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/LegacyCompletionHandler.qbk
+++ /dev/null
@@ -1,65 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:LegacyCompletionHandler Legacy completion handler requirements]
-
-A legacy completion handler must meet the requirements for a [link
-asio.reference.Handler handler]. A legacy completion handler must meet the
-requirements of `CopyConstructible` types (C++Std [copyconstructible]). A value
-`h` of a completion handler class should work correctly in the expression
-`h()`.
-
-[heading Examples]
-
-A free function as a completion handler:
-
-  void completion_handler()
-  {
-    ...
-  }
-
-A completion handler function object:
-
-  struct completion_handler
-  {
-    ...
-    void operator()()
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a completion handler:
-
-  my_io_service.post(
-      []()
-      {
-        ...
-      });
-
-A non-static class member function adapted to a completion handler using
-`std::bind()`:
-
-  void my_class::completion_handler()
-  {
-    ...
-  }
-  ...
-  my_io_service.post(std::bind(&my_class::completion_handler, this));
-
-A non-static class member function adapted to a completion handler using
-`boost::bind()`:
-
-  void my_class::completion_handler()
-  {
-    ...
-  }
-  ...
-  my_io_service.post(boost::bind(&my_class::completion_handler, this));
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptHandler.qbk
deleted file mode 100644
index 579a5e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptHandler.qbk
+++ /dev/null
@@ -1,16 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:MoveAcceptHandler Move accept handler requirements]
-
-A move accept handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a move accept handler class
-should work correctly in the expression `h(ec, s)`, where `ec` is an lvalue of
-type `const error_code` and `s` is an lvalue of the nested type
-`Protocol::socket` for the type `Protocol` of the socket class template.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptToken.qbk
deleted file mode 100644
index e34c1cb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MoveAcceptToken.qbk
+++ /dev/null
@@ -1,94 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:MoveAcceptToken Move accept token requirements]
-
-A move accept token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code, typename Protocol::socket)`
-or completion signature `void(error_code, typename Protocol::socket::template
-rebind_executor<Executor>::other)`, for the type `Protocol` of the acceptor
-class template.
-
-[heading Examples]
-
-A free function as a move accept token:
-
-  void accept_handler(
-      const asio::error_code& ec, asio::ip::tcp::socket s)
-  {
-    ...
-  }
-
-A move accept token function object:
-
-  struct accept_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec, asio::ip::tcp::socket s)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a move accept token:
-
-  acceptor.async_accept(...,
-      [](const asio::error_code& ec, asio::ip::tcp::socket s)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a move accept token using
-`std::bind()`:
-
-  void my_class::accept_handler(
-      const asio::error_code& ec, asio::ip::tcp::socket socket)
-  {
-    ...
-  }
-  ...
-  asio::async_accept(...,
-      std::bind(&my_class::accept_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-Using [link asio.reference.use_future use_future] as a move accept token:
-
-  std::future<asio::ip::tcp::socket> f =
-    acceptor.async_accept(..., asio::use_future);
-  ...
-  try
-  {
-    asio::ip::tcp::socket s = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a move accept token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      asio::ip::tcp::socket s =
-        co_await acceptor.async_accept(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MutableBufferSequence.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MutableBufferSequence.qbk
deleted file mode 100644
index 9a3e5e7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/MutableBufferSequence.qbk
+++ /dev/null
@@ -1,54 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:MutableBufferSequence Mutable buffer sequence requirements]
-
-A ['mutable buffer sequence] represents a set of memory regions that may be
-used to receive the output of an operation, such as the `receive` operation of
-a socket.
-
-A type `X` meets the `MutableBufferSequence` requirements if it satisfies the
-requirements of `Destructible` (C++Std [destructible]) and
-`CopyConstructible` (C++Std [copyconstructible]), as well as the additional
-requirements listed below.
-
-In the table below, `x` denotes a (possibly const) value of type `X`, and `u`
-denotes an identifier.
-
-[table MutableBufferSequence requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`asio::buffer_sequence_begin(x)`[br]
-     `asio::buffer_sequence_end(x)`]
-    [An iterator type meeting the requirements for bidirectional iterators
-     (C++Std \[bidirectional.iterators\]) whose value type is convertible to
-     `mutable_buffer`.]
-    []
-  ]
-  [
-    [``
-      X u(x);
-    ``]
-    []
-    [post:[br]
-     ``
-       equal(
-         asio::buffer_sequence_begin(x),
-         asio::buffer_sequence_end(x),
-         asio::buffer_sequence_begin(u),
-         asio::buffer_sequence_end(u),
-         [](const mutable_buffer& b1,
-            const mutable_buffer& b2)
-          {
-            return b1.data() == b2.data()
-                && b1.size() == b2.size();
-          })
-     ``]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/NullaryToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/NullaryToken.qbk
deleted file mode 100644
index 013626d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/NullaryToken.qbk
+++ /dev/null
@@ -1,79 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:NullaryToken Nullary token requirements]
-
-A nullary token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void()`.
-
-[heading Examples]
-
-A free function as a nullary token:
-
-  void nullary_handler()
-  {
-    ...
-  }
-
-A nullary token function object:
-
-  struct nullary_handler
-  {
-    ...
-    void operator()()
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a nullary token:
-
-  asio::post(...,
-      []()
-      {
-        ...
-      });
-
-A non-static class member function adapted to a nullary token using
-`std::bind()`:
-
-  void my_class::nullary_handler()
-  {
-    ...
-  }
-  ...
-  asio::post(...,
-      std::bind(&my_class::nullary_handler, this));
-
-A non-static class member function adapted to a nullary token using
-`boost::bind()`:
-
-  void my_class::nullary_handler()
-  {
-    ...
-  }
-  ...
-  asio::post(...,
-      boost::bind(&my_class::nullary_handler, this));
-
-Using [link asio.reference.use_future use_future] as a nullary token:
-
-  std::future<void> f = asio::post(..., asio::use_future);
-  ...
-  f.get();
-
-Using [link asio.reference.use_awaitable use_awaitable] as a nullary token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    ...
-    co_await asio::post(..., asio::use_awaitable);
-    ...
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ProtoAllocator.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ProtoAllocator.qbk
deleted file mode 100644
index 3a1c0fb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ProtoAllocator.qbk
+++ /dev/null
@@ -1,19 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ProtoAllocator Proto-allocator requirements]
-
-A type `A` meets the proto-allocator requirements if `A` is `CopyConstructible`
-(C++Std [copyconstructible]), `Destructible` (C++Std [destructible]), and
-`allocator_traits<A>::rebind_alloc<U>` meets the allocator requirements (C++Std
-[allocator.requirements]), where `U` is an object type. [inline_note For
-example, `std::allocator<void>` meets the proto-allocator requirements but not
-the allocator requirements.] No constructor, comparison operator, copy
-operation, move operation, or swap operation on these types shall exit via an
-exception.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Protocol.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Protocol.qbk
deleted file mode 100644
index 531f4bc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Protocol.qbk
+++ /dev/null
@@ -1,56 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:Protocol Protocol requirements]
-
-A type `X` meets the `Protocol` requirements if it satisfies the requirements
-of `Destructible` (C++Std [destructible]), `CopyConstructible` (C++Std
-[copyconstructible]), and `CopyAssignable` (C++Std [copyassignable]), as well
-as the additional requirements listed below.
-
-No copy or move operation of the type `X` shall exit via an exception.
-
-[table Protocol requirements
-  [[expression] [return type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`X::endpoint`]
-    [type meeting [link asio.reference.Endpoint endpoint] requirements]
-    []
-  ]
-]
-
-In the table below, `a` denotes a (possibly const) value of type `X`.
-
-[table Protocol requirements for extensible implementations
-  [[expression] [return type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.family()`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /domain/ argument to
-      __POSIX__ __socket__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.type()`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /type/ argument to __POSIX__
-      __socket__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.protocol()`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /protocol/ argument to
-      __POSIX__ __socket__ (or equivalent).
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectHandler.qbk
deleted file mode 100644
index c17c8f9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectHandler.qbk
+++ /dev/null
@@ -1,16 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:RangeConnectHandler Range connect handler requirements]
-
-A range connect handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a range connect handler class
-should work correctly in the expression `h(ec, ep)`, where `ec` is an lvalue of
-type `const error_code` and `ep` is an lvalue of the type `Protocol::endpoint`
-for the `Protocol` type in the corresponding `async_connect()` function.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectToken.qbk
deleted file mode 100644
index a36d9bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/RangeConnectToken.qbk
+++ /dev/null
@@ -1,114 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:RangeConnectToken Range connect token requirements]
-
-A range connect token is a [link asio.overview.model.completion_tokens
-completion token] for completion signature `void(error_code, typename
-Protocol::endpoint)`, where the type `Protocol` is used in the corresponding
-`async_connect()` function.
-
-[heading Examples]
-
-A free function as a range connect token:
-
-  void connect_handler(
-      const asio::error_code& ec,
-      const asio::ip::tcp::endpoint& endpoint)
-  {
-    ...
-  }
-
-A range connect token function object:
-
-  struct connect_handler
-  {
-    ...
-    template <typename Range>
-    void operator()(
-        const asio::error_code& ec,
-        const asio::ip::tcp::endpoint& endpoint)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a range connect token:
-
-  asio::async_connect(...,
-      [](const asio::error_code& ec,
-        const asio::ip::tcp::endpoint& endpoint)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a range connect token using
-`std::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec,
-      const asio::ip::tcp::endpoint& endpoint)
-  {
-    ...
-  }
-  ...
-  asio::async_connect(...,
-      std::bind(&my_class::connect_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a range connect token using
-`boost::bind()`:
-
-  void my_class::connect_handler(
-      const asio::error_code& ec,
-      const asio::ip::tcp::endpoint& endpoint)
-  {
-    ...
-  }
-  ...
-  asio::async_connect(...,
-      boost::bind(&my_class::connect_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::endpoint));
-
-Using [link asio.reference.use_future use_future] as a range connect token:
-
-  std::future<asio::ip::tcp::endpoint> f =
-    asio::async_connect(..., asio::use_future);
-  ...
-  try
-  {
-    asio::ip::tcp::endpoint e = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a range connect
-token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      asio::ip::tcp::endpoint e =
-        co_await asio::async_connect(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadHandler.qbk
deleted file mode 100644
index 4f6b328..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ReadHandler Read handler requirements]
-
-A read handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a read handler class
-should work correctly in the expression `h(ec, s)`, where `ec` is an lvalue of
-type `const error_code` and `s` is an lvalue of type `const size_t`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadToken.qbk
deleted file mode 100644
index 5195077..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ReadToken.qbk
+++ /dev/null
@@ -1,110 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ReadToken Read token requirements]
-
-A read token is a [link asio.overview.model.completion_tokens completion token]
-for completion signature `void(error_code, size_t)`.
-
-[heading Examples]
-
-A free function as a read token:
-
-  void read_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-
-A read token function object:
-
-  struct read_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec,
-        std::size_t bytes_transferred)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a read token:
-
-  socket.async_read_some(...,
-      [](const asio::error_code& ec,
-        std::size_t bytes_transferred)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a read token using
-`std::bind()`:
-
-  void my_class::read_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  socket.async_read_some(...,
-      std::bind(&my_class::read_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a read token using
-`boost::bind()`:
-
-  void my_class::read_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  socket.async_read_some(...,
-      boost::bind(&my_class::read_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::bytes_transferred));
-
-Using [link asio.reference.use_future use_future] as a read token:
-
-  std::future<std::size_t> f =
-    socket.async_read_some(..., asio::use_future);
-  ...
-  try
-  {
-    std::size_t n = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a read token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      std::size_t n =
-        co_await socket.async_read_some(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveHandler.qbk
deleted file mode 100644
index a714f03..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveHandler.qbk
+++ /dev/null
@@ -1,18 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ResolveHandler Resolve handler requirements]
-
-A resolve handler must meet the requirements for a [link asio.reference.Handler
-handler]. A value `h` of a resolve handler class should work correctly in the
-expression `h(ec, r)`, where `ec` is an lvalue of type `const error_code` and
-`r` is an lvalue of type `const ip::basic_resolver_results<InternetProtocol>`.
-`InternetProtocol` is the template parameter of the [link
-asio.reference.ip__basic_resolver `ip::basic_resolver<>`] which is used to
-initiate the asynchronous operation.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveToken.qbk
deleted file mode 100644
index 63af2a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ResolveToken.qbk
+++ /dev/null
@@ -1,112 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ResolveToken Resolve token requirements]
-
-A resolve token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code,
-ip::basic_resolver_results<InternetProtocol>)`, for a specified
-`InternetProtocol`.
-
-[heading Examples]
-
-A free function as a resolve token:
-
-  void resolve_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::results_type results)
-  {
-    ...
-  }
-
-A resolve token function object:
-
-  struct resolve_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec,
-        asio::ip::tcp::resolver::results_type results)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a resolve token:
-
-  resolver.async_resolve(...,
-      [](const asio::error_code& ec,
-        asio::ip::tcp::resolver::results_type results)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a resolve token using
-`std::bind()`:
-
-  void my_class::resolve_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::results_type results)
-  {
-    ...
-  }
-  ...
-  resolver.async_resolve(...,
-      std::bind(&my_class::resolve_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a resolve token using
-`boost::bind()`:
-
-  void my_class::resolve_handler(
-      const asio::error_code& ec,
-      asio::ip::tcp::resolver::results_type results)
-  {
-    ...
-  }
-  ...
-  resolver.async_resolve(...,
-      boost::bind(&my_class::resolve_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::results));
-
-Using [link asio.reference.use_future use_future] as a resolve token:
-
-  std::future<asio::ip::tcp::resolver::results_type> f =
-    resolver.async_resolve(..., asio::use_future);
-  ...
-  try
-  {
-    asio::ip::tcp::resolver::results_type r = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a resolve token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      asio::ip::tcp::resolver::results_type r =
-        co_await resolver.async_resolve(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Service.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Service.qbk
deleted file mode 100644
index a7acb39..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/Service.qbk
+++ /dev/null
@@ -1,40 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:Service Service requirements]
-
-A class is a ['service] if it is publicly and unambiguously derived from
-`execution_context::service`, or if it is publicly and unambiguously derived
-from another service. For a service `S`, `S::key_type` shall be valid and
-denote a type (C++Std [temp.deduct]), `is_base_of_v<typename S::key_type, S>`
-shall be `true`, and `S` shall satisfy the `Destructible` requirements (C++Std
-[destructible]).
-
-The first parameter of all service constructors shall be an lvalue reference to
-`execution_context`. This parameter denotes the `execution_context` object that
-represents a set of services, of which the service object will be a member.
-[inline_note These constructors may be called by the `make_service` function.]
-
-A service shall provide an explicit constructor with a single parameter of
-lvalue reference to `execution_context`. [inline_note This constructor may be
-called by the `use_service` function.]
-
-  class my_service : public execution_context::service
-  {
-  public:
-    typedef my_service key_type;
-    explicit my_service(execution_context& ctx);
-    my_service(execution_context& ctx, int some_value);
-  private:
-    virtual void shutdown() noexcept override;
-    ...
-  };
-
-A service's `shutdown` member function shall destroy all copies of user-defined
-function objects that are held by the service.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSerialPortOption.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSerialPortOption.qbk
deleted file mode 100644
index 311d1a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSerialPortOption.qbk
+++ /dev/null
@@ -1,33 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SettableSerialPortOption Settable serial port option requirements]
-
-In the table below, `X` denotes a serial port option class, `a` denotes a value
-of `X`, `ec` denotes a value of type `error_code`, and `s` denotes a value of
-implementation-defined type ['[^storage]] (where ['[^storage]] is the type
-`DCB` on Windows and `termios` on __POSIX__ platforms), and `u` denotes an
-identifier.
-
-[table SettableSerialPortOption requirements
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [
-      `const X& u = a;`[br]
-      `u.store(s, ec);`
-    ]
-    [`error_code`]
-    [
-      Saves the value of the serial port option to the storage.[br]
-      [br]
-      If successful, sets `ec` such that `!ec` is true. If an error occurred,
-      sets `ec` such that `!!ec` is true. Returns `ec`.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSocketOption.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSocketOption.qbk
deleted file mode 100644
index 0f3f964..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SettableSocketOption.qbk
+++ /dev/null
@@ -1,54 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SettableSocketOption Settable socket option requirements]
-
-A type `X` meets the `SettableSocketOption` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a (possibly const) value of type `X`, `p`
-denotes a (possibly const) value that meets the [link asio.reference.Protocol
-`Protocol`] requirements, and `u` denotes an identifier.
-
-[table SettableSocketOption requirements for extensible implementations
-  [[expression] [type] [assertion/note[br]pre/post-conditions]]
-  [
-    [`a.level(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /level/ argument to __POSIX__
-      __setsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.name(p)`]
-    [`int`]
-    [
-      Returns a value suitable for passing as the /option_name/ argument to
-      __POSIX__ __setsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.data(p)`]
-    [`const void*`]
-    [
-      Returns a pointer suitable for passing as the /option_value/ argument to
-      __POSIX__ __setsockopt__ (or equivalent).
-    ]
-  ]
-  [
-    [`a.size(p)`]
-    [`size_t`]
-    [
-      Returns a value suitable for passing as the /option_len/ argument to
-      __POSIX__ __setsockopt__ (or equivalent), after appropriate integer
-      conversion has been performed.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownHandler.qbk
deleted file mode 100644
index 7f7018f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ShutdownHandler SSL shutdown handler requirements]
-
-A shutdown handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a shutdown handler
-class should work correctly in the expression `h(ec)`, where `ec` is an lvalue
-of type `const error_code`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownToken.qbk
deleted file mode 100644
index f326115..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/ShutdownToken.qbk
+++ /dev/null
@@ -1,99 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:ShutdownToken SSL shutdown token requirements]
-
-A shutdown token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code)`.
-
-[heading Examples]
-
-A free function as a shutdown token:
-
-  void shutdown_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A shutdown token function object:
-
-  struct shutdown_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a shutdown token:
-
-  ssl_stream.async_shutdown(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a shutdown token using
-`std::bind()`:
-
-  void my_class::shutdown_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_shutdown(...,
-      std::bind(&my_class::shutdown_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a shutdown token using
-`boost::bind()`:
-
-  void my_class::shutdown_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  ssl_stream.async_shutdown(...,
-      boost::bind(&my_class::shutdown_handler,
-        this, asio::placeholders::error));
-
-Using [link asio.reference.use_future use_future] as a shutdown token:
-
-  std::future<void> f = ssl_stream.async_shutdown(..., asio::use_future);
-  ...
-  try
-  {
-    f.get();
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a shutdown token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      co_await ssl_stream.async_shutdown(..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalHandler.qbk
deleted file mode 100644
index 3744309..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SignalHandler Signal handler requirements]
-
-A signal handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a signal handler class
-should work correctly in the expression `h(ec, n)`, where `ec` is an lvalue of
-type `const error_code` and `n` is an lvalue of type `const int`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalToken.qbk
deleted file mode 100644
index f5245dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SignalToken.qbk
+++ /dev/null
@@ -1,109 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SignalToken Signal token requirements]
-
-A signal token is a [link asio.overview.model.completion_tokens completion
-token] for completion signature `void(error_code, int)`.
-
-[heading Examples]
-
-A free function as a signal token:
-
-  void signal_handler(
-      const asio::error_code& ec,
-      int signal_number)
-  {
-    ...
-  }
-
-A signal token function object:
-
-  struct signal_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec,
-        int signal_number)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a signal token:
-
-  signal_set.async_wait(...,
-      [](const asio::error_code& ec,
-        int signal_number)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a signal token using
-`std::bind()`:
-
-  void my_class::signal_handler(
-      const asio::error_code& ec,
-      int signal_number)
-  {
-    ...
-  }
-  ...
-  signal_set.async_wait(...,
-      std::bind(&my_class::signal_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a signal token using
-`boost::bind()`:
-
-  void my_class::signal_handler(
-      const asio::error_code& ec,
-      int signal_number)
-  {
-    ...
-  }
-  ...
-  signal_set.async_wait(...,
-      boost::bind(&my_class::signal_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::signal_number));
-
-Using [link asio.reference.use_future use_future] as a signal token:
-
-  std::future<int> f = signal_set.async_wait(..., asio::use_future);
-  ...
-  try
-  {
-    int signo = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a signal token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      int signo =
-        co_await signal_set.async_wait(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessReadDevice.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessReadDevice.qbk
deleted file mode 100644
index 4d2805f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessReadDevice.qbk
+++ /dev/null
@@ -1,49 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SyncRandomAccessReadDevice Buffer-oriented synchronous random-access
-read device requirements]
-
-In the table below, `a` denotes a synchronous random-access read device object,
-`o` denotes an offset of type `boost::uint64_t`, `mb` denotes an object
-satisfying [link asio.reference.MutableBufferSequence mutable buffer sequence]
-requirements, and `ec` denotes an object of type `error_code`.
-
-[table Buffer-oriented synchronous random-access read device requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.read_some_at(o, mb);`]
-    [`size_t`]
-    [Equivalent to:
-     ``
-       error_code ec;
-       size_t s = a.read_some_at(o, mb, ec);
-       if (ec) throw system_error(ec);
-       return s;
-     ``]
-  ]
-  [
-    [`a.read_some_at(o, mb, ec);`]
-    [`size_t`]
-    [
-      Reads one or more bytes of data from the device `a` at offset `o`.[br]
-      [br]
-      The mutable buffer sequence `mb` specifies memory where the data should
-      be placed. The `read_some_at` operation shall always fill a buffer in the
-      sequence completely before proceeding to the next.[br]
-      [br]
-      If successful, returns the number of bytes read and sets `ec` such that
-      `!ec` is true. If an error occurred, returns `0` and sets `ec` such that
-      `!!ec` is true.[br]
-      [br]
-      If the total size of all buffers in the sequence `mb` is `0`, the
-      function shall return `0` immediately.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessWriteDevice.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessWriteDevice.qbk
deleted file mode 100644
index 6276c8c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncRandomAccessWriteDevice.qbk
+++ /dev/null
@@ -1,49 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SyncRandomAccessWriteDevice Buffer-oriented synchronous random-access
-write device requirements]
-
-In the table below, `a` denotes a synchronous random-access write device
-object, `o` denotes an offset of type `boost::uint64_t`, `cb` denotes an object
-satisfying [link asio.reference.ConstBufferSequence constant buffer sequence]
-requirements, and `ec` denotes an object of type `error_code`.
-
-[table Buffer-oriented synchronous random-access write device requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.write_some_at(o, cb);`]
-    [`size_t`]
-    [Equivalent to:
-     ``
-       error_code ec;
-       size_t s = a.write_some(o, cb, ec);
-       if (ec) throw system_error(ec);
-       return s;
-     ``]
-  ]
-  [
-    [`a.write_some_at(o, cb, ec);`]
-    [`size_t`]
-    [
-      Writes one or more bytes of data to the device `a` at offset `o`.[br]
-      [br]
-      The constant buffer sequence `cb` specifies memory where the data to be
-      written is located. The `write_some_at` operation shall always write a
-      buffer in the sequence completely before proceeding to the next.[br]
-      [br]
-      If successful, returns the number of bytes written and sets `ec` such
-      that `!ec` is true. If an error occurred, returns `0` and sets `ec` such
-      that `!!ec` is true.[br]
-      [br]
-      If the total size of all buffers in the sequence `cb` is `0`, the
-      function shall return `0` immediately.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncReadStream.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncReadStream.qbk
deleted file mode 100644
index 27def27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncReadStream.qbk
+++ /dev/null
@@ -1,41 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SyncReadStream Buffer-oriented synchronous read stream requirements]
-
-A type `X` meets the `SyncReadStream` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a value of type `X`, `mb` denotes a (possibly
-const) value satisfying the [link asio.reference.MutableBufferSequence
-`MutableBufferSequence`] requirements, and `ec` denotes an object of type
-`error_code`.
-
-[table SyncReadStream requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.read_some(mb)`[br]
-     `a.read_some(mb,ec)`]
-    [`size_t`]
-    [
-      Meets the requirements for a [link asio.reference.read_write_operations
-      read operation].[br]
-      [br]
-      If `buffer_size(mb) > 0`, reads one or more bytes of data from the stream
-      `a` into the buffer sequence `mb`. If successful, sets `ec` such that
-      `!ec` is `true`, and returns the number of bytes read. If an error
-      occurred, sets `ec` such that `!!ec` is `true`, and returns 0. If all
-      data has been read from the stream, and the stream performed an orderly
-      shutdown, sets `ec` to `stream_errc::eof` and returns 0.[br]
-      [br]
-      If `buffer_size(mb) == 0`, the operation shall not block. Sets `ec` such
-      that `!ec` is `true`, and returns 0.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncWriteStream.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncWriteStream.qbk
deleted file mode 100644
index 9b55cca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/SyncWriteStream.qbk
+++ /dev/null
@@ -1,39 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:SyncWriteStream Buffer-oriented synchronous write stream requirements]
-
-A type `X` meets the `SyncWriteStream` requirements if it satisfies the
-requirements listed below.
-
-In the table below, `a` denotes a value of type `X`, `cb` denotes a (possibly
-const) value satisfying the [link asio.reference.ConstBufferSequence
-`ConstBufferSequence`] requirements, and `ec` denotes an object of type
-`error_code`.
-
-[table SyncWriteStream requirements
-  [[operation] [type] [semantics, pre/post-conditions]]
-  [
-    [`a.write_some(cb)`[br]
-     `a.write_some(cb,ec)`]
-    [`size_t`]
-    [
-      Meets the requirements for a [link asio.reference.read_write_operations
-      write operation].[br]
-      [br]
-      If `buffer_size(cb) > 0`, writes one or more bytes of data to the stream
-      `a` from the buffer sequence `cb`. If successful, sets `ec` such that
-      `!ec` is `true`, and returns the number of bytes written. If an error
-      occurred, sets `ec` such that `!!ec` is `true`, and returns 0.[br]
-      [br]
-      If `buffer_size(cb) == 0`, the operation shall not block. Sets `ec` such
-      that `!ec` is `true`, and returns 0.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/TimeTraits.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/TimeTraits.qbk
deleted file mode 100644
index 09b0d38..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/TimeTraits.qbk
+++ /dev/null
@@ -1,72 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:TimeTraits Time traits requirements]
-
-In the table below, `X` denotes a time traits class for time type `Time`, `t`,
-`t1`, and `t2` denote values of type `Time`, and `d` denotes a value of type
-`X::duration_type`.
-
-[table TimeTraits requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`X::time_type`]
-    [`Time`]
-    [
-      Represents an absolute time. Must support default construction, and meet
-      the requirements for `CopyConstructible` and `Assignable`.
-    ]
-  ]
-  [
-    [`X::duration_type`]
-    []
-    [
-      Represents the difference between two absolute times. Must support
-      default construction, and meet the requirements for `CopyConstructible`
-      and `Assignable`. A duration can be positive, negative, or zero.
-    ]
-  ]
-  [
-    [`X::now();`]
-    [`time_type`]
-    [
-      Returns the current time.
-    ]
-  ]
-  [
-    [`X::add(t, d);`]
-    [`time_type`]
-    [
-      Returns a new absolute time resulting from adding the duration `d` to the
-      absolute time `t`.
-    ]
-  ]
-  [
-    [`X::subtract(t1, t2);`]
-    [`duration_type`]
-    [
-      Returns the duration resulting from subtracting `t2` from `t1`.
-    ]
-  ]
-  [
-    [`X::less_than(t1, t2);`]
-    [`bool`]
-    [
-      Returns whether `t1` is to be treated as less than `t2`.
-    ]
-  ]
-  [
-    [`X::to_posix_duration(d);`]
-    [`date_time::time_duration_type`]
-    [
-      Returns the `date_time::time_duration_type` value that most closely
-      represents the duration `d`.
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitHandler.qbk
deleted file mode 100644
index ac9dc9f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:WaitHandler Wait handler requirements]
-
-A wait handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a wait handler class
-should work correctly in the expression `h(ec)`, where `ec` is an lvalue of
-type `const error_code`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitToken.qbk
deleted file mode 100644
index 046f142..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitToken.qbk
+++ /dev/null
@@ -1,99 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:WaitToken Wait token requirements]
-
-A wait token is a [link asio.overview.model.completion_tokens completion token]
-for completion signature `void(error_code)`.
-
-[heading Examples]
-
-A free function as a wait token:
-
-  void wait_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-
-A wait token function object:
-
-  struct wait_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a wait token:
-
-  socket.async_wait(...,
-      [](const asio::error_code& ec)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a wait token using
-`std::bind()`:
-
-  void my_class::wait_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  socket.async_wait(...,
-      std::bind(&my_class::wait_handler,
-        this, std::placeholders::_1));
-
-A non-static class member function adapted to a wait token using
-`boost::bind()`:
-
-  void my_class::wait_handler(
-      const asio::error_code& ec)
-  {
-    ...
-  }
-  ...
-  socket.async_wait(...,
-      boost::bind(&my_class::wait_handler,
-        this, asio::placeholders::error));
-
-Using [link asio.reference.use_future use_future] as a wait token:
-
-  std::future<void> f = socket.async_wait(..., asio::use_future);
-  ...
-  try
-  {
-    f.get();
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a wait token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      co_await socket.async_wait(..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitTraits.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitTraits.qbk
deleted file mode 100644
index c96e160..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WaitTraits.qbk
+++ /dev/null
@@ -1,52 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:WaitTraits Wait traits requirements]
-
-The `basic_waitable_timer` template uses wait traits to allow programs to
-customize `wait` and `async_wait` behavior.
-[inline_note Possible uses of wait traits include:[br]
-[mdash] To enable timers based on non-realtime clocks.[br]
-[mdash] Determining how quickly wallclock-based timers respond to system time
-changes.[br]
-[mdash] Correcting for errors or rounding timeouts to boundaries.[br]
-[mdash] Preventing duration overflow. That is, a program may set a timer's
-expiry `e` to be `Clock::max()` (meaning never reached) or `Clock::min()`
-(meaning always in the past). As a result, computing the duration until timer
-expiry as `e - Clock::now()` may cause overflow.]
-
-For a type `Clock` meeting the `Clock` requirements (C++Std
-[time.clock.req]), a type `X` meets the `WaitTraits` requirements if it
-satisfies the requirements listed below.
-
-In the table below, `t` denotes a (possibly const) value of type
-`Clock::time_point`; and `d` denotes a (possibly const) value of type
-`Clock::duration`.
-
-[table WaitTraits requirements
-  [[expression] [return type] [assertion/note[br]pre/post-condition]]
-  [
-    [`X::to_wait_duration(d)`]
-    [`Clock::duration`]
-    [
-      Returns a `Clock::duration` value to be used in a `wait` or `async_wait`
-      operation. [inline_note The return value is typically representative of
-      the duration `d`.]
-    ]
-  ]
-  [
-    [`X::to_wait_duration(t)`]
-    [`Clock::duration`]
-    [
-      Returns a `Clock::duration` value to be used in a `wait` or `async_wait`
-      operation. [inline_note The return value is typically representative of
-      the duration from `Clock::now()` until the time point `t`.]
-    ]
-  ]
-]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteHandler.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteHandler.qbk
deleted file mode 100644
index bfe7469..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteHandler.qbk
+++ /dev/null
@@ -1,15 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:WriteHandler Write handler requirements]
-
-A write handler must meet the requirements for a [link
-asio.reference.Handler handler]. A value `h` of a write handler class
-should work correctly in the expression `h(ec, s)`, where `ec` is an lvalue of
-type `const error_code` and `s` is an lvalue of type `const size_t`.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteToken.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteToken.qbk
deleted file mode 100644
index dc5ec25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/WriteToken.qbk
+++ /dev/null
@@ -1,110 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:WriteToken Write token requirements]
-
-A write token is a [link asio.overview.model.completion_tokens completion token]
-for completion signature `void(error_code, size_t)`.
-
-[heading Examples]
-
-A free function as a write token:
-
-  void write_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-
-A write token function object:
-
-  struct write_handler
-  {
-    ...
-    void operator()(
-        const asio::error_code& ec,
-        std::size_t bytes_transferred)
-    {
-      ...
-    }
-    ...
-  };
-
-A lambda as a write token:
-
-  socket.async_write_some(...,
-      [](const asio::error_code& ec,
-        std::size_t bytes_transferred)
-      {
-        ...
-      });
-
-A non-static class member function adapted to a write token using
-`std::bind()`:
-
-  void my_class::write_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  socket.async_write_some(...,
-      std::bind(&my_class::write_handler,
-        this, std::placeholders::_1,
-        std::placeholders::_2));
-
-A non-static class member function adapted to a write token using
-`boost::bind()`:
-
-  void my_class::write_handler(
-      const asio::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    ...
-  }
-  ...
-  socket.async_write_some(...,
-      boost::bind(&my_class::write_handler,
-        this, asio::placeholders::error,
-        asio::placeholders::bytes_transferred));
-
-Using [link asio.reference.use_future use_future] as a write token:
-
-  std::future<std::size_t> f =
-    socket.async_write_some(..., asio::use_future);
-  ...
-  try
-  {
-    std::size_t n = f.get();
-    ...
-  }
-  catch (const system_error& e)
-  {
-    ...
-  }
-
-Using [link asio.reference.use_awaitable use_awaitable] as a write token:
-
-  asio::awaitable<void> my_coroutine()
-  {
-    try
-    {
-      ...
-      std::size_t n =
-        co_await socket.async_write_some(
-            ..., asio::use_awaitable);
-      ...
-    }
-    catch (const system_error& e)
-    {
-      ...
-    }
-  }
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_operations.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_operations.qbk
deleted file mode 100644
index 3e03241..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_operations.qbk
+++ /dev/null
@@ -1,408 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:asynchronous_operations Requirements on asynchronous operations]
-
-This section uses the names `Alloc1`, `Alloc2`, `alloc1`, `alloc2`, `Args`,
-`CompletionHandler`, `completion_handler`, `Executor1`, `Executor2`, `ex1`,
-`ex2`, `f`, [^['i]], [^['N]], `Signatures`, `token`, `initiation`, `Initiation`,
-[^T[sub ['i]]], [^t[sub ['i]]], `work1`, and `work2` as placeholders for
-specifying the requirements below.
-
-[heading General asynchronous operation concepts]
-
-An ['initiating function] is a function which may be called to start an
-asynchronous operation. A ['completion handler] is a function object that will
-be invoked, at most once, with the result of the asynchronous operation.
-
-The lifecycle of an asynchronous operation is comprised of the following events
-and phases:
-
-[mdash] Event 1: The asynchronous operation is started by a call to the
-initiating function.
-
-[mdash] Phase 1: The asynchronous operation is now ['outstanding].
-
-[mdash] Event 2: The externally observable side effects of the asynchronous
-operation, if any, are fully established. The completion handler is submitted
-to an executor.
-
-[mdash] Phase 2: The asynchronous operation is now ['completed].
-
-[mdash] Event 3: The completion handler is called with the result of the
-asynchronous operation.
-
-In this library, all functions with the prefix `async_` are initiating
-functions.
-
-[heading Completion tokens and handlers]
-
-Initiating functions:
-
-[mdash] are function templates with template parameter `CompletionToken`;
-
-[mdash] accept, as the final parameter, a ['completion token] object `token`
-of type `CompletionToken`;
-
-[mdash] specify one or more ['completion signatures], referred to below as a
-variadic pack of call signatures (C++Std [func.def]) `Signatures`, that
-determine the possible argument sets to the completion handler.
-
-In this library, initiating functions specify a ['Completion signature] element
-that defines the call signatures `Signatures`. The ['Completion signature]
-elements in this library may have named parameters, and the results of an
-asynchronous operation may be specified in terms of these names.
-
-Completion token behaviour is determined through specialisation of the
-`async_result` trait. These specialisations must have the form:
-
-  template <class CompletionToken, class... Signatures>
-  struct async_result
-  {
-    template<
-        class Initiation,
-        class RawCompletionToken,
-        class... Args
-      >
-    static initiating-fn-return-type initiate(
-        Initiation&& initiation,
-        RawCompletionToken&& token,
-        Args&&... args
-      );
-  };
-
-An `async_result` specialisation’s implementation of the `initiate()` static
-member function must:
-
-* Transform the completion token into an object `completion_handler` of type
-  `CompletionHandler`. The type `CompletionHandler` must satisfy the
-  requirements of `Destructible` (C++Std [destructible]) and `MoveConstructible`
-  (C++Std [moveconstructible]), and be callable with the specified call
-  signatures.
-
-* Cause the invocation of the function object `initiation` as if by calling:
-  ``
-  std::forward<Initiation>(initiation)(
-      std::move(completion_handler),
-      std::forward<Args>(args)...);
-  ``
-
-This invocation of `initiation` may be immediate, or it may be deferred (e.g.
-to support lazy evaluation). If `initiation` is deferred, the `initiation` and
-`args...` objects must be decay-copied and moved as required.
-
-The `async_result` trait must be specialised for the decayed type of a
-`CompletionToken`. A helper function template `async_initiate` is provided to
-simplify correct invocation of `async_result<>::initiate` for the appropriate
-specialisation:
-
-  template<
-      class CompletionToken,
-      completion_signature... Signatures,
-      class Initiation,
-      class... Args
-    >
-  ``['DEDUCED]`` async_initiate(
-      Initiation&& initiation,
-      CompletionToken& token,
-      Args&&... args
-    );
-
-[inline_note No other requirements are placed on the type `CompletionToken`.]
-
-[heading Automatic deduction of initiating function return type]
-
-An initiating function returns [^async_initiate<CompletionToken,
-Signatures...>(initiation, token, ['unspecified-args...])], where `initiation`
-is a function object of unspecified type `Initiation`, which is defined as:
-
-  class Initiation
-  {
-  public:
-    using executor_type = Executor; // optional
-    executor_type get_executor() const noexcept; // optional
-
-    template <class CompletionHandler, ``['unspecified-args...]``>
-      void operator()(CompletionHandler&& completion_handler, ``['unspecified-args...]``) const;
-  };
-
-For the sake of exposition, this library sometimes annotates functions with a
-return type ['[^DEDUCED]]. For every function declaration that returns
-['[^DEDUCED]], the meaning is equivalent to an automatically deduced return
-type, having the type of the expression [^async_initiate<CompletionToken,
-Signatures...>(initiation, token, ['unspecified-args...])].
-
-\[['Example:] Given an asynchronous operation with a single ['Completion
-signature] `void(R1 r1, R2 r2)`, an initiating function meeting these
-requirements may be implemented as follows:
-
-  template<class CompletionToken>
-  auto async_xyz(T1 t1, T2 t2, CompletionToken&& token)
-  {
-    return async_initiate<CompletionToken, void(R1, R2)>(
-        [](auto completion_handler, T1 t1, T2 t2)
-        {
-          // initiate the operation and cause completion_handler to be invoked
-          // with the result
-        }, token, std::move(t1), std::move(t2));
-  }
-
-The concepts `completion_token_for` and `completion_handler_for` may also be
-used to improve compile-time diagnostics:
-
-  template<completion_token_for<void(R1, R2)> CompletionToken>
-  auto async_xyz(T1 t1, T2 t2, CompletionToken&& token)
-  {
-    return async_initiate<CompletionToken, void(R1, R2)>(
-        [](completion_handler_for<void(R1, R2)> auto completion_handler, T1 t1, T2 t2)
-        {
-          // initiate the operation and cause completion_handler to be invoked
-          // with the result
-        }, token, std::move(t1), std::move(t2));
-  }
-
-Initiation functions may also be implemented using the `async_result` trait
-directly:
-
-  template<class CompletionToken>
-  auto async_xyz(T1 t1, T2 t2, CompletionToken&& token)
-  {
-    return async_result<decay_t<CompletionToken>, void(R1, R2)>::initiate(
-        [](auto completion_handler, T1 t1, T2 t2)
-        {
-          // initiate the operation and cause completion_handler to be invoked
-          // with the result
-        }, forward<CompletionToken>(token), std::move(t1), std::move(t2));
-  }
-
-Note the use of `decay_t` and `forward` applied to the `CompletionToken` type.
-However, the first form is preferred as it preserves compatibility with legacy
-completion token requirements.
-
-'''&mdash;'''['end example]\]
-
-[heading Lifetime of initiating function arguments]
-
-Unless otherwise specified, the lifetime of arguments to initiating functions
-shall be treated as follows:
-
-[mdash] If the parameter has a pointer type or has a type of lvalue reference
-to non-const, the implementation may assume the validity of the pointee or
-referent, respectively, until the completion handler is invoked. [inline_note
-In other words, the program must guarantee the validity of the argument until
-the completion handler is invoked.]
-
-[mdash] Otherwise, the implementation must not assume the validity of the
-argument after the initiating function completes. [inline_note In other words,
-the program is not required to guarantee the validity of the argument after the
-initiating function completes.] The implementation may make copies of the
-argument, and all copies shall be destroyed no later than immediately after
-invocation of the completion handler.
-
-[heading Non-blocking requirements on initiating functions]
-
-An initiating function shall not block (C++Std [defns.block]) the calling
-thread pending completion of the outstanding operation.
-
-[inline_note Initiating functions may still block the calling thread for other
-reasons. For example, an initiating function may lock a mutex in order to
-synchronize access to shared data.]
-
-[heading Associated executor]
-
-Certain objects that participate in asynchronous operations have an
-['associated executor]. These are obtained as specified in the sections below.
-
-[heading Associated I/O executor]
-
-An asynchronous operation has an associated executor satisfying the [link
-asio.reference.Executor1 `Executor`] requirements. If not otherwise specified by
-the asynchronous operation, this associated executor is an object of type
-`system_executor`.
-
-All asynchronous operations in this library have an associated I/O executor
-object that is determined as follows:
-
-[mdash] If the initiating function is a member function, the associated
-executor is that returned by the `get_executor` member function on the same
-object.
-
-[mdash] If the initiating function is not a member function, the associated
-executor is that returned by the `get_executor` member function of the first
-argument to the initiating function.
-
-The operation's associated I/O executor may be exposed via the `Initiation`
-function object's `executor_type` type alias and `get_executor()` member
-function.
-
-Let `Executor1` be the type of the associated executor. Let `ex1` be a value of
-type `Executor1`, representing the associated executor object obtained as
-described above.
-
-[heading Associated completion handler executor]
-
-A completion handler object of type `CompletionHandler` has an associated
-executor of type `Executor2` satisfying the [link asio.reference.Executor1
-Executor requirements]. The type `Executor2` is
-`associated_executor_t<CompletionHandler, Executor1>`. Let `ex2` be a value of
-type `Executor2` obtained by performing
-`get_associated_executor(completion_handler, ex1)`.
-
-[heading Associated immediate completion executor]
-
-A completion handler object of type `CompletionHandler` has an associated
-immediate executor of type `Executor3` satisfying the
-[link asio.reference.Executor1 Executor requirements]. The type `Executor3` is
-`associated_immediate_executor_t<CompletionHandler, Executor1>`. Let `ex3` be a
-value of type `Executor3` obtained by performing
-`get_associated_immediate_executor(completion_handler, ex1)`.
-
-[heading Outstanding work]
-
-If the operation does not complete immediately (that is, the operation does not
-complete within the thread of execution calling the initiating function, before
-the initiating function returns) then, until the asynchronous operation has
-completed, the asynchronous operation shall maintain:
-
-[mdash] an object `work1` of type `executor_work_guard<Executor1>`, initialized
-as `work1(ex1)`, and where `work1.owns_work() == true`; and
-
-[mdash] an object `work2` of type `executor_work_guard<Executor2>`, initialized
-as `work2(ex2)`, and where `work2.owns_work() == true`.
-
-[heading Allocation of intermediate storage]
-
-Asynchronous operations may allocate memory. [inline_note Such as a data
-structure to store copies of the `completion_handler` object and the initiating
-function's arguments.]
-
-Let `Alloc1` be a type, satisfying the [link asio.reference.ProtoAllocator
-`ProtoAllocator`] requirements, that represents the asynchronous operation's
-default allocation strategy. [inline_note Typically `std::allocator<void>`.]
-Let `alloc1` be a value of type `Alloc1`.
-
-A completion handler object of type `CompletionHandler` has an associated
-allocator object `alloc2` of type `Alloc2` satisfying the [link
-asio.reference.ProtoAllocator `ProtoAllocator`] requirements. The type `Alloc2`
-is `associated_allocator_t<CompletionHandler, Alloc1>`. Let `alloc2` be a value
-of type `Alloc2` obtained by performing
-`get_associated_allocator(completion_handler, alloc1)`.
-
-The asynchronous operations defined in this library:
-
-[mdash] If required, allocate memory using only the completion handler's
-associated allocator.
-
-[mdash] Prior to completion handler execution, deallocate any memory allocated
-using the completion handler's associated allocator.
-
-[inline_note The implementation may perform operating system or underlying API
-calls that perform memory allocations not using the associated allocator.
-Invocations of the allocator functions may not introduce data races (See C++Std
-\[res.on.data.races\]).]
-
-[heading Execution of completion handler on completion of asynchronous operation]
-
-Let `Args...` be the argument types of a completion signature in
-`Signatures...` and let [^['N]] be `sizeof...(Args)`. Let [^['i]] be in the
-range [half_open_range `0`,[^['N]]]. Let [^T[sub ['i]]] be the [^['i]]th type
-in `Args...` and let [^t[sub ['i]]] be the [^['i]]th completion handler
-argument associated with [^T[sub ['i]]].
-
-Let `f` be a function object that:
-
-[mdash] is callable as `f()`, and when so called invokes `completion_handler`
-as if by [^std::move(completion_handler)(forward<T[sub ['0]]>(t[sub ['0]]), ...,
-forward<T[sub ['N-1]]>(t[sub ['N-1]]))];
-
-[mdash] has an associated executor such that `get_associated_executor(f, ex1)`
-returns an executor that is equal to `ex2`; and
-
-[mdash] has an associated allocator such that `get_associated_allocator(f,
-alloc1)` returns an allocator that is equal to `alloc2`.
-
-[inline_note These associated executor and allocator requirements on `f` are
-typically implemented by specialising the associator traits for `f` so that they
-forward to the associator traits for `completion_handler`.]
-
-If an asynchonous operation completes immediately (that is, the operation
-completes within the thread of execution calling the initiating function, and
-before the initiating function returns), the completion handler shall be
-submitted for execution as if by performing `post(ex1, std::move(f))`.
-
-Otherwise, when the operation completes, the completion handler shall be
-submitted for execution as if by performing `dispatch(ex2, std::move(f))`.
-
-[heading Optimisation of immediate completion]
-
-If an asynchronous operation completes immediately then, as an optimisation,
-the operation may either:
-
-[mdash] obtain the associated immediate completion executor `ex3` by performing
-`get_associated_immediate_executor(completion_handler, ex1)`, and then
-submit the completion handler for execution as if by performing `dispatch(ex3,
-std::move(f))`; or
-
-[mdash] submit the completion handler for execution by performing the expression
-`post(ex2, std::move(f))`, if that expression is well-formed.
-
-[inline_note If `completion_handler` does not customise the associated immediate
-executor, the behaviour of the first optimisation is equivalent to `post(ex1,
-std::move(f))`.]
-
-[heading Completion handlers and exceptions]
-
-Completion handlers are permitted to throw exceptions. The effect of any
-exception propagated from the execution of a completion handler is determined
-by the executor which is executing the completion handler.
-
-[heading Default completion tokens]
-
-Every I/O executor type has an associated default completion token type. This is
-specified via the `default_completion_token` trait. This trait may be used in
-asynchronous operation declarations as follows:
-
-  template <
-      typename IoObject,
-      typename CompletionToken =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type
-    >
-  auto async_xyz(
-      IoObject& io_object,
-      CompletionToken&& token =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type{}
-    );
-
-If not specialised, this trait type is `void`, meaning no default completion
-token type is available for the given I/O executor.
-
-\[['Example:] The `default_completion_token` trait is specialised for the
-`use_awaitable` completion token so that it may be used as shown in the
-following example:
-
-  auto socket = use_awaitable.as_default_on(tcp::socket(my_context));
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-
-In this example, the type of the `socket` object is transformed from
-`tcp::socket` to have an I/O executor with the default completion token set to
-`use_awaitable`.
-
-Alternatively, the socket type may be computed directly:
-
-  using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
-  tcp_socket socket(my_context);
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-
-'''&mdash;'''['end example]\]
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_socket_operations.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_socket_operations.qbk
deleted file mode 100644
index 81a7f80..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/asynchronous_socket_operations.qbk
+++ /dev/null
@@ -1,39 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:asynchronous_socket_operations Requirements on asynchronous socket operations]
-
-In this library, ['asynchronous socket operations] are those member functions
-having prefix `async_`.
-
-For an object `s`, a program may initiate asynchronous socket operations such
-that there are multiple simultaneously outstanding asynchronous operations.
-
-When there are multiple outstanding asynchronous [link
-asio.reference.read_write_operations read operations] on `s`:
-
-[mdash] having no argument `flags` of type `socket_base::message_flags`, or
-
-[mdash] having an argument `flags` of type `socket_base::message_flags` but
-where `(flags & socket_base::message_out_of_band) == 0`
-
-then the `buffers` are filled in the order in which these operations were
-issued. The order of invocation of the completion handlers for these operations
-is unspecified.
-
-When there are multiple outstanding asynchronous [link
-asio.reference.read_write_operations read operations] on `s` having an argument
-`flags` of type `socket_base::message_flags` where `(flags &
-socket_base::message_out_of_band) != 0` then the `buffers` are filled in the
-order in which these operations were issued.
-
-When there are multiple outstanding asynchronous [link
-asio.reference.read_write_operations write operations] on `s`, the `buffers`
-are transmitted in the order in which these operations were issued. The order
-of invocation of the completion handlers for these operations is unspecified.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/read_write_operations.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/read_write_operations.qbk
deleted file mode 100644
index ca0910a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/read_write_operations.qbk
+++ /dev/null
@@ -1,34 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:read_write_operations Requirements on read and write operations]
-
-A ['read operation] is an operation that reads data into a mutable buffer
-sequence argument of a type meeting [link asio.reference.MutableBufferSequence
-`MutableBufferSequence`] requirements. The mutable buffer sequence specifies
-memory where the data should be placed. A read operation shall always fill a
-buffer in the sequence completely before proceeding to the next.
-
-A ['write operation] is an operation that writes data from a constant buffer
-sequence argument of a type meeting [link asio.reference.ConstBufferSequence
-`ConstBufferSequence`] requirements. The constant buffer sequence specifies
-memory where the data to be written is located. A write operation shall always
-write a buffer in the sequence completely before proceeding to the next.
-
-If a read or write operation is also an [link
-asio.reference.asynchronous_operations asynchronous operation], the operation
-shall maintain one or more copies of the buffer sequence until such time as the
-operation no longer requires access to the memory specified by the buffers in
-the sequence. The program shall ensure the memory remains valid until:
-
-[mdash] the last copy of the buffer sequence is destroyed, or
-
-[mdash] the completion handler for the asynchronous operation is invoked,
-
-whichever comes first.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/synchronous_socket_operations.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/synchronous_socket_operations.qbk
deleted file mode 100644
index 575c463..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/requirements/synchronous_socket_operations.qbk
+++ /dev/null
@@ -1,37 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:synchronous_socket_operations Requirements on synchronous socket operations]
-
-In this section, ['synchronous socket operations] are those member functions
-specified as two overloads, with and without an argument of type `error_code&`:
-
-  ``[*['R f]]``(``['[*A1]]`` a1, ``['[*A2]]`` a2, ..., ``['[*AN]]`` aN);
-  ``[*['R f]]``(``['[*A1]]`` a1, ``['[*A2]]`` a2, ..., ``['[*AN]]`` aN, error_code& ec);
-
-For an object `s`, the conditions under which its synchronous socket operations
-may block the calling thread (C++Std [defns.block]) are determined as follows.
-
-If:
-
-[mdash] `s.non_blocking() == true`,
-
-[mdash] the synchronous socket operation is specified in terms of a __POSIX__
-function other than `__poll__`,
-
-[mdash] that __POSIX__ function lists `EWOULDBLOCK` or `EAGAIN`
-in its failure conditions, and
-
-[mdash] the effects of the operation cannot be established immediately
-
-then the synchronous socket operation shall not block the calling thread.
-[inline_note And the effects of the operation are not established.]
-
-Otherwise, the synchronous socket operation shall block the calling thread
-until the effects are established.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_exception_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_exception_dox.txt
deleted file mode 100644
index b355e29..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_exception_dox.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-/**
-\namespace std
-*/
-
-/**
-\class std::exception
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_executors.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_executors.qbk
deleted file mode 100644
index e2667d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/std_executors.qbk
+++ /dev/null
@@ -1,216 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:std_executors Proposed Standard Executors]
-
-Asio provides a complete implementation of the proposed standard executors, as
-described in [@http://wg21.link/P0443r13 P0443r13], [@http://wg21.link/P1348r0
-P1348r0], and [@http://wg21.link/P1393r0 P1393r0].
-
-Just as with executors under the Networking TS model, a standard executor
-represents a policy as to how, when, and where a piece of code should be
-executed. Most existing code should continue to work with little or no change.
-
-[heading Standard Executor Implementations in Asio]
-
-The [link asio.reference.io_context.executor_type `io_context::executor_type`],
-[link asio.reference.thread_pool.executor_type `thread_pool::executor_type`],
-[link asio.reference.system_executor `system_executor`], and [link
-asio.reference.strand `strand`] executors meet the requirements for the
-proposed standard executors. For compatibility, these classes also meet the
-requirements for the Networking TS model of executors.
-
-[heading Standard Executor Use in Asio]
-
-All I/O objects such as [link asio.reference.ip__tcp.socket `ip::tcp::socket`],
-asynchronous operations, and utilities including [link asio.reference.dispatch
-`dispatch`], [link asio.reference.post `post`], [link asio.reference.defer
-`defer`], [link asio.reference.get_associated_executor
-`get_associated_executor`], [link asio.reference.bind_executor
-`bind_executor`], [link asio.reference.make_work_guard `make_work_guard`],
-[link asio.reference.spawn `spawn`], [link asio.reference.co_spawn `co_spawn`],
-[link asio.reference.async_compose `async_compose`], [link
-asio.reference.use_future `use_future`], etc., can interoperate with both
-proposed standard executors, and with Networking TS executors. Asio's
-implementation determines at compile time which model a particular executor
-meets; the proposed standard executor model is used in preference if both are
-detected.
-
-Support for the existing Networking TS model of executors can be disabled
-by defining `ASIO_NO_TS_EXECUTORS`.
-
-[heading Polymorphic I/O Executor]
-
-The [link asio.reference.any_io_executor `any_io_executor`] type alias is the
-default runtime-polymorphic executor for all I/O objects. This type alias
-points to the [link asio.reference.execution__any_executor
-`execution::any_executor<>`] template with a set of supportable properties
-specified for use with I/O.
-
-This new name may break existing code that directly uses the old polymorphic
-wrapper, [link asio.reference.executor `executor`]. If required for backward
-compatibility, `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` can be defined, which changes
-the `any_io_executor` type alias to instead point to the `executor` polymorphic
-wrapper.
-
-[heading Implementing a Minimal I/O Executor]
-
-Standard executor properties make what were previously hard requirements on an
-executor (such as work counting, or the ability to distinguish between `post`,
-`dispatch`, and `defer`) into optional facilities. With this relaxation, the
-minimal requirements for an I/O executor are:
-
-* Conformance to the [link asio.reference.Executor1.standard_executors
-  `executor`] concept.
-
-* The ability to query the [link asio.reference.execution__context
-  `execution::context`] property, with the result being [link
-  asio.reference.execution_context `execution_context&`] or a reference to a
-  class that is derived from `execution_context`.
-
-* The `execute` operation having, at minimum, the [link
-  asio.reference.execution__blocking_t.never `execution::blocking.never`]
-  semantic.
-
-The following example shows a minimal I/O executor. Given a queue submission
-operation implemented elsewhere:
-
-```
-queue_t queue_create();
-template <typename F> void queue_submit(queue_t q, F f);
-```
-
-the executor may be defined as follows:
-
-```
-struct minimal_io_executor
-{
-  asio::execution_context* context_;
-  queue_t queue_;
-
-  bool operator==(const minimal_io_executor& other) const noexcept
-  {
-    return context_ == other.context_ && queue_ == other.queue_;
-  }
-
-  bool operator!=(const minimal_io_executor& other) const noexcept
-  {
-    return !(*this == other);
-  }
-
-  asio::execution_context& query(
-      asio::execution::context_t) const noexcept
-  {
-    return *context_;
-  }
-
-  static constexpr asio::execution::blocking_t::never_t query(
-      asio::execution::blocking_t) noexcept
-  {
-    // This executor always has blocking.never semantics.
-    return asio::execution::blocking.never;
-  }
-
-  template <class F>
-  void execute(F f) const
-  {
-    queue_submit(queue_, std::move(f));
-  }
-};
-```
-
-This executor may be created as follows:
-
-```
-asio::execution_context context;
-queue_t queue = queue_create();
-minimal_io_executor executor{&context, queue};
-```
-
-and then used with I/O objects:
-
-```
-asio::ip::tcp::acceptor acceptor(executor);
-```
-
-or assigned into the [link asio.reference.any_io_executor `any_io_executor`]
-polymorphic wrapper:
-
-```
-asio::any_io_executor poly_executor = executor;
-```
-
-[heading Traits for Deducing Conformance to the Executor Concept]
-
-Older C++ standards and compilers require some assistance to determine whether
-an executor implementation conforms to the `executor` concept and type
-requirements. This is achieved through specialisation of traits. The following
-code shows a specialisation of these traits for the `minimal_io_executor`
-example from above:
-
-```
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<minimal_io_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<minimal_io_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <>
-struct query_member<minimal_io_executor,
-    asio::execution::context_t>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution_context& result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Property>
-struct query_static_constexpr_member<minimal_io_executor, Property,
-    typename enable_if<
-      std::is_convertible<Property, asio::execution::blocking_t>::value
-    >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef asio::execution::blocking_t::never_t result_type;
-  static constexpr result_type value() noexcept { return result_type(); }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-```
-
-Asio uses an extensive set of traits to implement all of the proposed standard
-executor functionality on older C++ standards. These traits may be found under
-the [^asio/traits] include directory.
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.dox b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.dox
deleted file mode 100644
index 0295f0e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.dox
+++ /dev/null
@@ -1,349 +0,0 @@
-# Doxyfile 1.9.8
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = "Asio Tutorial"
-PROJECT_NUMBER         =
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
-OUTPUT_DIRECTORY       = .
-CREATE_SUBDIRS         = NO
-CREATE_SUBDIRS_LEVEL   = 8
-ALLOW_UNICODE_NAMES    = NO
-OUTPUT_LANGUAGE        = English
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ABBREVIATE_BRIEF       =
-ALWAYS_DETAILED_SEC    = YES
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        = ./../../
-STRIP_FROM_INC_PATH    =
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-JAVADOC_BANNER         = NO
-QT_AUTOBRIEF           = NO
-MULTILINE_CPP_IS_BRIEF = YES
-PYTHON_DOCSTRING       = YES
-INHERIT_DOCS           = YES
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 2
-ALIASES                =
-OPTIMIZE_OUTPUT_FOR_C  = NO
-OPTIMIZE_OUTPUT_JAVA   = NO
-OPTIMIZE_FOR_FORTRAN   = NO
-OPTIMIZE_OUTPUT_VHDL   = NO
-OPTIMIZE_OUTPUT_SLICE  = NO
-EXTENSION_MAPPING      =
-MARKDOWN_SUPPORT       = YES
-TOC_INCLUDE_HEADINGS   = 5
-MARKDOWN_ID_STYLE      = DOXYGEN
-AUTOLINK_SUPPORT       = YES
-BUILTIN_STL_SUPPORT    = NO
-CPP_CLI_SUPPORT        = NO
-SIP_SUPPORT            = NO
-IDL_PROPERTY_SUPPORT   = YES
-DISTRIBUTE_GROUP_DOC   = NO
-GROUP_NESTED_COMPOUNDS = NO
-SUBGROUPING            = YES
-INLINE_GROUPED_CLASSES = NO
-INLINE_SIMPLE_STRUCTS  = NO
-TYPEDEF_HIDES_STRUCT   = NO
-LOOKUP_CACHE_SIZE      = 0
-NUM_PROC_THREADS       = 1
-TIMESTAMP              = NO
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = NO
-EXTRACT_PRIVATE        = YES
-EXTRACT_PRIV_VIRTUAL   = NO
-EXTRACT_PACKAGE        = NO
-EXTRACT_STATIC         = YES
-EXTRACT_LOCAL_CLASSES  = NO
-EXTRACT_LOCAL_METHODS  = NO
-EXTRACT_ANON_NSPACES   = NO
-RESOLVE_UNNAMED_PARAMS = YES
-HIDE_UNDOC_MEMBERS     = YES
-HIDE_UNDOC_CLASSES     = YES
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-HIDE_COMPOUND_REFERENCE= NO
-SHOW_HEADERFILE        = YES
-SHOW_INCLUDE_FILES     = NO
-SHOW_GROUPED_MEMB_INC  = NO
-FORCE_LOCAL_INCLUDES   = NO
-INLINE_INFO            = NO
-SORT_MEMBER_DOCS       = NO
-SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
-SORT_GROUP_NAMES       = NO
-SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
-GENERATE_TODOLIST      = NO
-GENERATE_TESTLIST      = NO
-GENERATE_BUGLIST       = NO
-GENERATE_DEPRECATEDLIST= NO
-ENABLED_SECTIONS       =
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = NO
-SHOW_FILES             = YES
-SHOW_NAMESPACES        = YES
-FILE_VERSION_FILTER    =
-LAYOUT_FILE            =
-CITE_BIB_FILES         =
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_IF_INCOMPLETE_DOC = YES
-WARN_NO_PARAMDOC       = NO
-WARN_IF_UNDOC_ENUM_VAL = NO
-WARN_AS_ERROR          = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LINE_FORMAT       = "at line $line of file $file"
-WARN_LOGFILE           =
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  = ./../examples/cpp11/tutorial/index_dox.txt \
-                         ./../examples/cpp11/tutorial/timer_dox.txt \
-                         ./../examples/cpp11/tutorial/daytime_dox.txt \
-                         ./boost_bind_dox.txt
-INPUT_ENCODING         = UTF-8
-INPUT_FILE_ENCODING    =
-FILE_PATTERNS          =
-RECURSIVE              = NO
-EXCLUDE                =
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       =
-EXCLUDE_SYMBOLS        =
-EXAMPLE_PATH           = ./../examples
-EXAMPLE_PATTERNS       =
-EXAMPLE_RECURSIVE      = YES
-IMAGE_PATH             =
-INPUT_FILTER           =
-FILTER_PATTERNS        =
-FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
-USE_MDFILE_AS_MAINPAGE =
-FORTRAN_COMMENT_AFTER  = 72
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = NO
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-REFERENCES_LINK_SOURCE = YES
-SOURCE_TOOLTIPS        = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-IGNORE_PREFIX          =
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = NO
-HTML_OUTPUT            = .
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            =
-HTML_FOOTER            =
-HTML_STYLESHEET        =
-HTML_EXTRA_STYLESHEET  =
-HTML_EXTRA_FILES       =
-HTML_COLORSTYLE        = AUTO_LIGHT
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_DYNAMIC_MENUS     = YES
-HTML_DYNAMIC_SECTIONS  = NO
-HTML_CODE_FOLDING      = YES
-HTML_INDEX_NUM_ENTRIES = 100
-GENERATE_DOCSET        = NO
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-DOCSET_FEEDURL         =
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
-GENERATE_HTMLHELP      = NO
-CHM_FILE               =
-HHC_LOCATION           =
-GENERATE_CHI           = NO
-CHM_INDEX_ENCODING     =
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-SITEMAP_URL            =
-GENERATE_QHP           = NO
-QCH_FILE               =
-QHP_NAMESPACE          = org.doxygen.Project
-QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
-QHG_LOCATION           =
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
-DISABLE_INDEX          = YES
-GENERATE_TREEVIEW      = NO
-FULL_SIDEBAR           = NO
-ENUM_VALUES_PER_LINE   = 1
-TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
-OBFUSCATE_EMAILS       = YES
-HTML_FORMULA_FORMAT    = png
-FORMULA_FONTSIZE       = 10
-FORMULA_MACROFILE      =
-USE_MATHJAX            = NO
-MATHJAX_VERSION        = MathJax_2
-MATHJAX_FORMAT         = HTML-CSS
-MATHJAX_RELPATH        =
-MATHJAX_EXTENSIONS     =
-MATHJAX_CODEFILE       =
-SEARCHENGINE           = NO
-SERVER_BASED_SEARCH    = NO
-EXTERNAL_SEARCH        = NO
-SEARCHENGINE_URL       =
-SEARCHDATA_FILE        = searchdata.xml
-EXTERNAL_SEARCH_ID     =
-EXTRA_SEARCH_MAPPINGS  =
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-LATEX_MAKEINDEX_CMD    = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         =
-LATEX_HEADER           =
-LATEX_FOOTER           =
-LATEX_EXTRA_STYLESHEET =
-LATEX_EXTRA_FILES      =
-PDF_HYPERLINKS         = NO
-USE_PDFLATEX           = NO
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-LATEX_BIB_STYLE        = plain
-LATEX_EMOJI_DIRECTORY  =
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    =
-RTF_EXTENSIONS_FILE    =
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_SUBDIR             =
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = YES
-XML_OUTPUT             = xml
-XML_PROGRAMLISTING     = YES
-XML_NS_MEMB_FILE_SCOPE = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-GENERATE_DOCBOOK       = NO
-DOCBOOK_OUTPUT         = docbook
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# Configuration options related to Sqlite3 output
-#---------------------------------------------------------------------------
-GENERATE_SQLITE3       = NO
-SQLITE3_OUTPUT         = sqlite3
-SQLITE3_RECREATE_DB    = YES
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX =
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           =
-INCLUDE_FILE_PATTERNS  =
-PREDEFINED             = GENERATING_DOCUMENTATION
-EXPAND_AS_DEFINED      =
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-TAGFILES               = reference.tags
-GENERATE_TAGFILE       =
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-EXTERNAL_PAGES         = YES
-#---------------------------------------------------------------------------
-# Configuration options related to diagram generator tools
-#---------------------------------------------------------------------------
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = YES
-DOT_NUM_THREADS        = 0
-DOT_COMMON_ATTR        = "fontname=Helvetica,fontsize=10"
-DOT_EDGE_ATTR          = "labelfontname=Helvetica,labelfontsize=10"
-DOT_NODE_ATTR          = "shape=box,height=0.2,width=0.4"
-DOT_FONTPATH           =
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-GROUP_GRAPHS           = YES
-UML_LOOK               = YES
-UML_LIMIT_NUM_FIELDS   = 10
-DOT_UML_DETAILS        = NO
-DOT_WRAP_THRESHOLD     = 17
-TEMPLATE_RELATIONS     = YES
-INCLUDE_GRAPH          = NO
-INCLUDED_BY_GRAPH      = NO
-CALL_GRAPH             = NO
-CALLER_GRAPH           = NO
-GRAPHICAL_HIERARCHY    = NO
-DIRECTORY_GRAPH        = YES
-DIR_GRAPH_MAX_DEPTH    = 1
-DOT_IMAGE_FORMAT       = png
-INTERACTIVE_SVG        = NO
-DOT_PATH               =
-DOTFILE_DIRS           =
-DIA_PATH               =
-DIAFILE_DIRS           =
-PLANTUML_JAR_PATH      =
-PLANTUML_CFG_FILE      =
-PLANTUML_INCLUDE_PATH  =
-DOT_GRAPH_MAX_NODES    = 50
-MAX_DOT_GRAPH_DEPTH    = 0
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = NO
-DOT_CLEANUP            = YES
-MSCGEN_TOOL            =
-MSCFILE_DIRS           =
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.qbk
deleted file mode 100644
index 865c714..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.qbk
+++ /dev/null
@@ -1,2210 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:tutorial Tutorial]
-
-[heading Basic Skills]
-
-The tutorial programs in this first section introduce the fundamental concepts required to use the asio toolkit. Before plunging into the complex world of network programming, these tutorial programs illustrate the basic skills using simple asynchronous timers.
-
-* [link asio.tutorial.tuttimer1 Timer.1 - Using a timer synchronously]
-
-
-* [link asio.tutorial.tuttimer2 Timer.2 - Using a timer asynchronously]
-
-
-* [link asio.tutorial.tuttimer3 Timer.3 - Binding arguments to a completion handler]
-
-
-* [link asio.tutorial.tuttimer4 Timer.4 - Using a member function as a completion handler]
-
-
-* [link asio.tutorial.tuttimer5 Timer.5 - Synchronising completion handlers in multithreaded programs]
-
-
-
-
-[heading Introduction to Sockets]
-
-The tutorial programs in this section show how to use asio to develop simple client and server programs. These tutorial programs are based around the [@http://www.ietf.org/rfc/rfc867.txt daytime] protocol, which supports both TCP and UDP.
-
-The first three tutorial programs implement the daytime protocol using TCP.
-
-* [link asio.tutorial.tutdaytime1 Daytime.1 - A synchronous TCP daytime client]
-
-
-* [link asio.tutorial.tutdaytime2 Daytime.2 - A synchronous TCP daytime server]
-
-
-* [link asio.tutorial.tutdaytime3 Daytime.3 - An asynchronous TCP daytime server]
-
-
-
-The next three tutorial programs implement the daytime protocol using UDP.
-
-* [link asio.tutorial.tutdaytime4 Daytime.4 - A synchronous UDP daytime client]
-
-
-* [link asio.tutorial.tutdaytime5 Daytime.5 - A synchronous UDP daytime server]
-
-
-* [link asio.tutorial.tutdaytime6 Daytime.6 - An asynchronous UDP daytime server]
-
-
-
-The last tutorial program in this section demonstrates how asio allows the TCP and UDP servers to be easily combined into a single program.
-
-* [link asio.tutorial.tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server]
-
-
-
-
-[section:tuttimer1 Timer.1 - Using a timer synchronously]
-
-This tutorial program introduces asio by showing how to perform a blocking wait on a timer.
-
-
-
-We start by including the necessary header files.
-
-All of the asio classes can be used by simply including the `"asio.hpp"` header file.
-
-
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-All programs that use asio need to have at least one I/O execution context, such as an 
-[link asio.reference.io_context io_context] or 
-[link asio.reference.thread_pool thread_pool] object. An I/O execution context provides access to I/O functionality. We declare an object of type 
-[link asio.reference.io_context io_context] first thing in the main function.
-
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-Next we declare an object of type asio::steady\_timer. The core asio classes that provide I/O functionality (or as in this case timer functionality) always take an executor, or a reference to an execution context (such as 
-[link asio.reference.io_context io_context]), as their first constructor argument. The second argument to the constructor sets the timer to expire 5 seconds from now.
-
-
-
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(5));
-
-In this simple example we perform a blocking wait on the timer. That is, the call to [link asio.reference.basic_waitable_timer.wait steady_timer::wait()] will not return until the timer has expired, 5 seconds after it was created (i.e. not from when the wait starts).
-
-A timer is always in one of two states: "expired" or "not expired". If the [link asio.reference.basic_waitable_timer.wait steady_timer::wait()] function is called on an expired timer, it will return immediately.
-
-
-  ``''''''``  t.wait();
-
-Finally we print the obligatory `"Hello, world!"` message to show when the timer has expired.
-
-
-
-  ``''''''``  std::cout << "Hello, world!" << std::endl;
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tuttimer1.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Next: [link asio.tutorial.tuttimer2 Timer.2 - Using a timer asynchronously]
-
-
-
-[section:src Source listing for Timer.1]
-
-
-  ``''''''``//
-  ``''''''``// timer.cpp
-  ``''''''``// ~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(5));
-  ``''''''``  t.wait();
-
-  ``''''''``  std::cout << "Hello, world!" << std::endl;
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tuttimer1 Timer.1 - Using a timer synchronously]
-
-[endsect]
-
-[endsect]
-
-[section:tuttimer2 Timer.2 - Using a timer asynchronously]
-
-This tutorial program demonstrates how to use asio's asynchronous functionality by modifying the program from tutorial Timer.1 to perform an asynchronous wait on the timer.
-
-
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-Using asio's asynchronous functionality means supplying a [link asio.overview.model.completion_tokens completion token], which determines how the result will be delivered to a [*completion handler] when an [link asio.overview.model.async_ops asynchronous operation] completes. In this program we define a function called `print` to be called when the asynchronous wait finishes.
-
-
-
-  ``''''''``void print(const std::error_code& /*e*/)
-  ``''''''``{
-  ``''''''``  std::cout << "Hello, world!" << std::endl;
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(5));
-
-Next, instead of doing a blocking wait as in tutorial Timer.1, we call the [link asio.reference.basic_waitable_timer.async_wait steady_timer::async_wait()] function to perform an asynchronous wait. When calling this function we pass the `print` function that was defined above.
-
-
-  ``''''''``  t.async_wait(&print);
-
-Finally, we must call the asio::io\_context::run() member function on the io\_context object.
-
-The asio library provides a guarantee that completion handlers will only be called from threads that are currently calling asio::io\_context::run(). Therefore unless the asio::io\_context::run() function is called the completion handler for the asynchronous wait completion will never be invoked.
-
-The asio::io\_context::run() function will also continue to run while there is still "work" to do. In this example, the work is the asynchronous wait on the timer, so the call will not return until the timer has expired and the completion handler has returned.
-
-It is important to remember to give the io\_context some work to do before calling asio::io\_context::run(). For example, if we had omitted the above call to [link asio.reference.basic_waitable_timer.async_wait steady_timer::async_wait()], the io\_context would not have had any work to do, and consequently asio::io\_context::run() would have returned immediately.
-
-
-  ``''''''``  io.run();
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tuttimer2.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tuttimer1 Timer.1 - Using a timer synchronously]
-
-Next: [link asio.tutorial.tuttimer3 Timer.3 - Binding arguments to a completion handler]
-
-
-
-[section:src Source listing for Timer.2]
-
-
-  ``''''''``//
-  ``''''''``// timer.cpp
-  ``''''''``// ~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``void print(const std::error_code& /*e*/)
-  ``''''''``{
-  ``''''''``  std::cout << "Hello, world!" << std::endl;
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(5));
-  ``''''''``  t.async_wait(&print);
-
-  ``''''''``  io.run();
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tuttimer2 Timer.2 - Using a timer asynchronously]
-
-[endsect]
-
-[endsect]
-
-[section:tuttimer3 Timer.3 - Binding arguments to a completion handler]
-
-In this tutorial we will modify the program from tutorial Timer.2 so that the timer fires once a second. This will show how to pass additional parameters to your handler function.
-
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-To implement a repeating timer using asio you need to change the timer's expiry time in your completion handler, and to then start a new asynchronous wait. Obviously this means that the completion handler will need to be able to access the timer object. To this end we add two new parameters to the `print` function:
-
-* a pointer to a timer object; and
-
-
-* a counter so that we can stop the program when the timer fires for the sixth time
-
-
-
-at the end of the parameter list.
-
-
-
-  ``''''''``void print(const std::error_code& /*e*/,
-  ``''''''``    asio::steady_timer* t, int* count)
-  ``''''''``{
-
-As mentioned above, this tutorial program uses a counter to stop running when the timer fires for the sixth time. However you will observe that there is no explicit call to ask the io\_context to stop. Recall that in tutorial Timer.2 we learnt that the asio::io\_context::run() function completes when there is no more "work" to do. By not starting a new asynchronous wait on the timer when `count` reaches 5, the io\_context will run out of work and stop running.
-
-
-  ``''''''``  if (*count < 5)
-  ``''''''``  {
-  ``''''''``    std::cout << *count << std::endl;
-  ``''''''``    ++(*count);
-
-Next we move the expiry time for the timer along by one second from the previous expiry time. By calculating the new expiry time relative to the old, we can ensure that the timer does not drift away from the whole-second mark due to any delays in processing the handler.
-
-
-
-  ``''''''``    t->expires_at(t->expiry() + asio::chrono::seconds(1));
-
-Then we start a new asynchronous wait on the timer. As you can see, the `std::bind` function is used to associate the extra parameters with your completion handler. The [link asio.reference.basic_waitable_timer.async_wait steady_timer::async_wait()] function expects a handler function (or function object) with the signature `void(const std::error_code&)`. Binding the additional parameters converts your `print` function into a function object that matches the signature correctly.
-
-In this example, the asio::placeholders::error argument to `std::bind` is a named placeholder for the error object passed to the handler. When initiating the asynchronous operation, and if using `std::bind`, you must specify only the arguments that match the handler's parameter list. In tutorial Timer.4 you will see that this placeholder may be elided if the parameter is not needed by the completion handler.
-
-
-  ``''''''``    t->async_wait(std::bind(print,
-  ``''''''``          asio::placeholders::error, t, count));
-  ``''''''``  }
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-A new `count` variable is added so that we can stop the program when the timer fires for the sixth time.
-
-
-
-  ``''''''``  int count = 0;
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(1));
-
-As in Step 4, when making the call to [link asio.reference.basic_waitable_timer.async_wait steady_timer::async_wait()] from `main` we bind the additional parameters needed for the `print` function.
-
-
-  ``''''''``  t.async_wait(std::bind(print,
-  ``''''''``        asio::placeholders::error, &t, &count));
-
-  ``''''''``  io.run();
-
-Finally, just to prove that the `count` variable was being used in the `print` handler function, we will print out its new value.
-
-
-
-  ``''''''``  std::cout << "Final count is " << count << std::endl;
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tuttimer3.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tuttimer2 Timer.2 - Using a timer asynchronously]
-
-Next: [link asio.tutorial.tuttimer4 Timer.4 - Using a member function as a completion handler]
-
-
-
-[section:src Source listing for Timer.3]
-
-
-  ``''''''``//
-  ``''''''``// timer.cpp
-  ``''''''``// ~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``void print(const std::error_code& /*e*/,
-  ``''''''``    asio::steady_timer* t, int* count)
-  ``''''''``{
-  ``''''''``  if (*count < 5)
-  ``''''''``  {
-  ``''''''``    std::cout << *count << std::endl;
-  ``''''''``    ++(*count);
-
-  ``''''''``    t->expires_at(t->expiry() + asio::chrono::seconds(1));
-  ``''''''``    t->async_wait(std::bind(print,
-  ``''''''``          asio::placeholders::error, t, count));
-  ``''''''``  }
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-
-  ``''''''``  int count = 0;
-  ``''''''``  asio::steady_timer t(io, asio::chrono::seconds(1));
-  ``''''''``  t.async_wait(std::bind(print,
-  ``''''''``        asio::placeholders::error, &t, &count));
-
-  ``''''''``  io.run();
-
-  ``''''''``  std::cout << "Final count is " << count << std::endl;
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tuttimer3 Timer.3 - Binding arguments to a completion handler]
-
-[endsect]
-
-[endsect]
-
-[section:tuttimer4 Timer.4 - Using a member function as a completion handler]
-
-In this tutorial we will see how to use a class member function as a completion handler. The program should execute identically to the tutorial program from tutorial Timer.3.
-
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-Instead of defining a free function `print` as the completion handler, as we did in the earlier tutorial programs, we now define a class called `printer`.
-
-
-
-  ``''''''``class printer
-  ``''''''``{
-  ``''''''``public:
-
-The constructor of this class will take a reference to the io\_context object and use it when initialising the `timer_` member. The counter used to shut down the program is now also a member of the class.
-
-
-  ``''''''``  printer(asio::io_context& io)
-  ``''''''``    : timer_(io, asio::chrono::seconds(1)),
-  ``''''''``      count_(0)
-  ``''''''``  {
-
-The `std::bind` function works just as well with class member functions as with free functions. Since all non-static class member functions have an implicit `this` parameter, we need to bind `this` to the function. As in tutorial Timer.3, `std::bind` converts our completion handler (now a member function) into a function object that can be invoked as though it has the signature `void(const
-std::error_code&)`.
-
-You will note that the asio::placeholders::error placeholder is not specified here, as the `print` member function does not accept an error object as a parameter.
-
-
-  ``''''''``    timer_.async_wait(std::bind(&printer::print, this));
-  ``''''''``  }
-
-In the class destructor we will print out the final value of the counter.
-
-
-
-  ``''''''``  ~printer()
-  ``''''''``  {
-  ``''''''``    std::cout << "Final count is " << count_ << std::endl;
-  ``''''''``  }
-
-The `print` member function is very similar to the `print` function from tutorial Timer.3, except that it now operates on the class data members instead of having the timer and counter passed in as parameters.
-
-
-
-  ``''''''``  void print()
-  ``''''''``  {
-  ``''''''``    if (count_ < 5)
-  ``''''''``    {
-  ``''''''``      std::cout << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer_.expires_at(timer_.expiry() + asio::chrono::seconds(1));
-  ``''''''``      timer_.async_wait(std::bind(&printer::print, this));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  asio::steady_timer timer_;
-  ``''''''``  int count_;
-  ``''''''``};
-
-The `main` function is much simpler than before, as it now declares a local `printer` object before running the io\_context as normal.
-
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-  ``''''''``  printer p(io);
-  ``''''''``  io.run();
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tuttimer4.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tuttimer3 Timer.3 - Binding arguments to a completion handler]
-
-Next: [link asio.tutorial.tuttimer5 Timer.5 - Synchronising completion handlers in multithreaded programs]
-
-
-
-
-
-[section:src Source listing for Timer.4]
-
-
-  ``''''''``//
-  ``''''''``// timer.cpp
-  ``''''''``// ~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``class printer
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  printer(asio::io_context& io)
-  ``''''''``    : timer_(io, asio::chrono::seconds(1)),
-  ``''''''``      count_(0)
-  ``''''''``  {
-  ``''''''``    timer_.async_wait(std::bind(&printer::print, this));
-  ``''''''``  }
-
-  ``''''''``  ~printer()
-  ``''''''``  {
-  ``''''''``    std::cout << "Final count is " << count_ << std::endl;
-  ``''''''``  }
-
-  ``''''''``  void print()
-  ``''''''``  {
-  ``''''''``    if (count_ < 5)
-  ``''''''``    {
-  ``''''''``      std::cout << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer_.expires_at(timer_.expiry() + asio::chrono::seconds(1));
-  ``''''''``      timer_.async_wait(std::bind(&printer::print, this));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  asio::steady_timer timer_;
-  ``''''''``  int count_;
-  ``''''''``};
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-  ``''''''``  printer p(io);
-  ``''''''``  io.run();
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tuttimer4 Timer.4 - Using a member function as a completion handler]
-
-[endsect]
-
-[endsect]
-
-[section:tuttimer5 Timer.5 - Synchronising completion handlers in multithreaded programs]
-
-This tutorial demonstrates the use of the 
-[link asio.reference.strand strand] class template to synchronise completion handlers in a multithreaded program.
-
-The previous four tutorials avoided the issue of handler synchronisation by calling the asio::io\_context::run() function from one thread only. As you already know, the asio library provides a guarantee that completion handlers will only be called from threads that are currently calling asio::io\_context::run(). Consequently, calling asio::io\_context::run() from only one thread ensures that completion handlers cannot run concurrently.
-
-The single threaded approach is usually the best place to start when developing applications using asio. The downside is the limitations it places on programs, particularly servers, including:
-
-* Poor responsiveness when handlers can take a long time to complete. 
-
-
-* An inability to scale on multiprocessor systems. 
-
-
-
-
-If you find yourself running into these limitations, an alternative approach is to have a pool of threads calling asio::io\_context::run(). However, as this allows handlers to execute concurrently, we need a method of synchronisation when handlers might be accessing a shared, thread-unsafe resource.
-
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <thread>
-  ``''''''``#include <asio.hpp>
-
-We start by defining a class called `printer`, similar to the class in the previous tutorial. This class will extend the previous tutorial by running two timers in parallel.
-
-
-
-  ``''''''``class printer
-  ``''''''``{
-  ``''''''``public:
-
-In addition to initialising a pair of asio::steady\_timer members, the constructor initialises the `strand_` member, an object of type asio::strand<asio::io\_context::executor\_type>.
-
-The 
-[link asio.reference.strand strand] class template is an executor adapter that guarantees that, for those handlers that are dispatched through it, an executing handler will be allowed to complete before the next one is started. This is guaranteed irrespective of the number of threads that are calling asio::io\_context::run(). Of course, the handlers may still execute concurrently with other handlers that were not dispatched through an 
-[link asio.reference.strand strand], or were dispatched through a different 
-[link asio.reference.strand strand] object.
-
-
-  ``''''''``  printer(asio::io_context& io)
-  ``''''''``    : strand_(asio::make_strand(io)),
-  ``''''''``      timer1_(io, asio::chrono::seconds(1)),
-  ``''''''``      timer2_(io, asio::chrono::seconds(1)),
-  ``''''''``      count_(0)
-  ``''''''``  {
-
-When initiating the asynchronous operations, each completion handler is "bound" to an asio::strand<asio::io\_context::executor\_type> object. The asio::bind\_executor() function returns a new handler that automatically dispatches its contained handler through the 
-[link asio.reference.strand strand] object. By binding the handlers to the same 
-[link asio.reference.strand strand], we are ensuring that they cannot execute concurrently.
-
-
-  ``''''''``    timer1_.async_wait(asio::bind_executor(strand_,
-  ``''''''``          std::bind(&printer::print1, this)));
-
-  ``''''''``    timer2_.async_wait(asio::bind_executor(strand_,
-  ``''''''``          std::bind(&printer::print2, this)));
-  ``''''''``  }
-
-  ``''''''``  ~printer()
-  ``''''''``  {
-  ``''''''``    std::cout << "Final count is " << count_ << std::endl;
-  ``''''''``  }
-
-In a multithreaded program, the handlers for asynchronous operations should be synchronised if they access shared resources. In this tutorial, the shared resources used by the handlers (`print1` and `print2`) are `std::cout` and the `count_` data member.
-
-
-
-  ``''''''``  void print1()
-  ``''''''``  {
-  ``''''''``    if (count_ < 10)
-  ``''''''``    {
-  ``''''''``      std::cout << "Timer 1: " << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer1_.expires_at(timer1_.expiry() + asio::chrono::seconds(1));
-
-  ``''''''``      timer1_.async_wait(asio::bind_executor(strand_,
-  ``''''''``            std::bind(&printer::print1, this)));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``  void print2()
-  ``''''''``  {
-  ``''''''``    if (count_ < 10)
-  ``''''''``    {
-  ``''''''``      std::cout << "Timer 2: " << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer2_.expires_at(timer2_.expiry() + asio::chrono::seconds(1));
-
-  ``''''''``      timer2_.async_wait(asio::bind_executor(strand_,
-  ``''''''``            std::bind(&printer::print2, this)));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  asio::strand<asio::io_context::executor_type> strand_;
-  ``''''''``  asio::steady_timer timer1_;
-  ``''''''``  asio::steady_timer timer2_;
-  ``''''''``  int count_;
-  ``''''''``};
-
-The `main` function now causes asio::io\_context::run() to be called from two threads: the main thread and one additional thread. This is accomplished using an 
-[link asio.reference.thread thread] object.
-
-Just as it would with a call from a single thread, concurrent calls to asio::io\_context::run() will continue to execute while there is "work" left to do. The background thread will not exit until all asynchronous operations have completed.
-
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-  ``''''''``  printer p(io);
-  ``''''''``  std::thread t([&]{ io.run(); });
-
-See the [link asio.tutorial.tuttimer5.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tuttimer4 Timer.4 - Using a member function as a completion handler]
-
-
-
-
-
-[section:src Source listing for Timer.5]
-
-
-  ``''''''``//
-  ``''''''``// timer.cpp
-  ``''''''``// ~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <thread>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``class printer
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  printer(asio::io_context& io)
-  ``''''''``    : strand_(asio::make_strand(io)),
-  ``''''''``      timer1_(io, asio::chrono::seconds(1)),
-  ``''''''``      timer2_(io, asio::chrono::seconds(1)),
-  ``''''''``      count_(0)
-  ``''''''``  {
-  ``''''''``    timer1_.async_wait(asio::bind_executor(strand_,
-  ``''''''``          std::bind(&printer::print1, this)));
-
-  ``''''''``    timer2_.async_wait(asio::bind_executor(strand_,
-  ``''''''``          std::bind(&printer::print2, this)));
-  ``''''''``  }
-
-  ``''''''``  ~printer()
-  ``''''''``  {
-  ``''''''``    std::cout << "Final count is " << count_ << std::endl;
-  ``''''''``  }
-
-  ``''''''``  void print1()
-  ``''''''``  {
-  ``''''''``    if (count_ < 10)
-  ``''''''``    {
-  ``''''''``      std::cout << "Timer 1: " << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer1_.expires_at(timer1_.expiry() + asio::chrono::seconds(1));
-
-  ``''''''``      timer1_.async_wait(asio::bind_executor(strand_,
-  ``''''''``            std::bind(&printer::print1, this)));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``  void print2()
-  ``''''''``  {
-  ``''''''``    if (count_ < 10)
-  ``''''''``    {
-  ``''''''``      std::cout << "Timer 2: " << count_ << std::endl;
-  ``''''''``      ++count_;
-
-  ``''''''``      timer2_.expires_at(timer2_.expiry() + asio::chrono::seconds(1));
-
-  ``''''''``      timer2_.async_wait(asio::bind_executor(strand_,
-  ``''''''``            std::bind(&printer::print2, this)));
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  asio::strand<asio::io_context::executor_type> strand_;
-  ``''''''``  asio::steady_timer timer1_;
-  ``''''''``  asio::steady_timer timer2_;
-  ``''''''``  int count_;
-  ``''''''``};
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  asio::io_context io;
-  ``''''''``  printer p(io);
-  ``''''''``  std::thread t([&]{ io.run(); });
-  ``''''''``  io.run();
-  ``''''''``  t.join();
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tuttimer5 Timer.5 - Synchronising completion handlers in multithreaded programs]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime1 Daytime.1 - A synchronous TCP daytime client]
-
-This tutorial program shows how to use asio to implement a client application with TCP.
-
-
-
-We start by including the necessary header files.
-
-
-  ``''''''``#include <array>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-The purpose of this application is to access a daytime service, so we need the user to specify the server.
-
-
-
-  ``''''''``using asio::ip::tcp;
-
-  ``''''''``int main(int argc, char* argv[])
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    if (argc != 2)
-  ``''''''``    {
-  ``''''''``      std::cerr << "Usage: client <host>" << std::endl;
-  ``''''''``      return 1;
-  ``''''''``    }
-
-All programs that use asio need to have at least one I/O execution context, such as an 
-[link asio.reference.io_context io_context] object.
-
-
-
-  ``''''''``    asio::io_context io_context;
-
-We need to turn the server name that was specified as a parameter to the application, into a TCP endpoint. To do this we use an [link asio.reference.ip__tcp.resolver ip::tcp::resolver] object.
-
-
-
-  ``''''''``    tcp::resolver resolver(io_context);
-
-A resolver takes a host name and service name and turns them into a list of endpoints. We perform a resolve call using the name of the server, specified in `argv[1]`, and the name of the service, in this case `"daytime"`.
-
-The list of endpoints is returned using an object of type [link asio.reference.ip__basic_resolver.results_type ip::tcp::resolver::results_type]. This object is a range, with begin() and end() member functions that may be used for iterating over the results.
-
-
-  ``''''''``    tcp::resolver::results_type endpoints =
-  ``''''''``      resolver.resolve(argv[1], "daytime");
-
-Now we create and connect the socket. The list of endpoints obtained above may contain both IPv4 and IPv6 endpoints, so we need to try each of them until we find one that works. This keeps the client program independent of a specific IP version. The asio::connect() function does this for us automatically.
-
-
-
-  ``''''''``    tcp::socket socket(io_context);
-  ``''''''``    asio::connect(socket, endpoints);
-
-The connection is open. All we need to do now is read the response from the daytime service.
-
-We use a `std::array` to hold the received data. The asio::buffer() function automatically determines the size of the array to help prevent buffer overruns. Instead of a `std::array`, we could have used a `char []` or `std::vector`.
-
-
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      std::array<char, 128> buf;
-  ``''''''``      std::error_code error;
-
-  ``''''''``      size_t len = socket.read_some(asio::buffer(buf), error);
-
-When the server closes the connection, the [link asio.reference.basic_stream_socket.read_some ip::tcp::socket::read_some()] function will exit with the asio::error::eof error, which is how we know to exit the loop.
-
-
-
-  ``''''''``      if (error == asio::error::eof)
-  ``''''''``        break; // Connection closed cleanly by peer.
-  ``''''''``      else if (error)
-  ``''''''``        throw std::system_error(error); // Some other error.
-
-  ``''''''``      std::cout.write(buf.data(), len);
-  ``''''''``    }
-
-Finally, handle any exceptions that may have been thrown.
-
-
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-See the [link asio.tutorial.tutdaytime1.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Next: [link asio.tutorial.tutdaytime2 Daytime.2 - A synchronous TCP daytime server]
-
-
-
-[section:src Source listing for Daytime.1]
-
-
-  ``''''''``//
-  ``''''''``// client.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <array>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::tcp;
-
-  ``''''''``int main(int argc, char* argv[])
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    if (argc != 2)
-  ``''''''``    {
-  ``''''''``      std::cerr << "Usage: client <host>" << std::endl;
-  ``''''''``      return 1;
-  ``''''''``    }
-
-  ``''''''``    asio::io_context io_context;
-
-  ``''''''``    tcp::resolver resolver(io_context);
-  ``''''''``    tcp::resolver::results_type endpoints =
-  ``''''''``      resolver.resolve(argv[1], "daytime");
-
-  ``''''''``    tcp::socket socket(io_context);
-  ``''''''``    asio::connect(socket, endpoints);
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      std::array<char, 128> buf;
-  ``''''''``      std::error_code error;
-
-  ``''''''``      size_t len = socket.read_some(asio::buffer(buf), error);
-
-  ``''''''``      if (error == asio::error::eof)
-  ``''''''``        break; // Connection closed cleanly by peer.
-  ``''''''``      else if (error)
-  ``''''''``        throw std::system_error(error); // Some other error.
-
-  ``''''''``      std::cout.write(buf.data(), len);
-  ``''''''``    }
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime1 Daytime.1 - A synchronous TCP daytime client]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime2 Daytime.2 - A synchronous TCP daytime server]
-
-This tutorial program shows how to use asio to implement a server application with TCP.
-
-
-  ``''''''``#include <ctime>
-  ``''''''``#include <iostream>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::tcp;
-
-We define the function `make_daytime_string()` to create the string to be sent back to the client. This function will be reused in all of our daytime server applications.
-
-
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-
-A [link asio.reference.ip__tcp.acceptor ip::tcp::acceptor] object needs to be created to listen for new connections. It is initialised to listen on TCP port 13, for IP version 4.
-
-
-
-  ``''''''``    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 13));
-
-This is an iterative server, which means that it will handle one connection at a time. Create a socket that will represent the connection to the client, and then wait for a connection.
-
-
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      tcp::socket socket(io_context);
-  ``''''''``      acceptor.accept(socket);
-
-A client is accessing our service. Determine the current time and transfer this information to the client.
-
-
-
-  ``''''''``      std::string message = make_daytime_string();
-
-  ``''''''``      std::error_code ignored_error;
-  ``''''''``      asio::write(socket, asio::buffer(message), ignored_error);
-  ``''''''``    }
-  ``''''''``  }
-
-Finally, handle any exceptions.
-
-
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tutdaytime2.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime1 Daytime.1 - A synchronous TCP daytime client]
-
-Next: [link asio.tutorial.tutdaytime3 Daytime.3 - An asynchronous TCP daytime server]
-
-
-
-[section:src Source listing for Daytime.2]
-
-
-  ``''''''``//
-  ``''''''``// server.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <ctime>
-  ``''''''``#include <iostream>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::tcp;
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-
-  ``''''''``    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 13));
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      tcp::socket socket(io_context);
-  ``''''''``      acceptor.accept(socket);
-
-  ``''''''``      std::string message = make_daytime_string();
-
-  ``''''''``      std::error_code ignored_error;
-  ``''''''``      asio::write(socket, asio::buffer(message), ignored_error);
-  ``''''''``    }
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime2 Daytime.2 - A synchronous TCP daytime server]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime3 Daytime.3 - An asynchronous TCP daytime server]
-
-[heading The main() function]
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-
-We need to create a server object to accept incoming client connections. The 
-[link asio.reference.io_context io_context] object provides I/O services, such as sockets, that the server object will use.
-
-
-  ``''''''``    asio::io_context io_context;
-  ``''''''``    tcp_server server(io_context);
-
-Run the 
-[link asio.reference.io_context io_context] object so that it will perform asynchronous operations on your behalf.
-
-
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-
-
-[heading The tcp_server class]
-
-
-  ``''''''``class tcp_server
-  ``''''''``{
-  ``''''''``public:
-
-The constructor initialises an acceptor to listen on TCP port 13.
-
-
-  ``''''''``  tcp_server(asio::io_context& io_context)
-  ``''''''``    : io_context_(io_context),
-  ``''''''``      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``private:
-
-The function `start_accept()` creates a socket and initiates an asynchronous accept operation to wait for a new connection.
-
-
-  ``''''''``  void start_accept()
-  ``''''''``  {
-  ``''''''``    tcp_connection::pointer new_connection =
-  ``''''''``      tcp_connection::create(io_context_);
-
-  ``''''''``    acceptor_.async_accept(new_connection->socket(),
-  ``''''''``        std::bind(&tcp_server::handle_accept, this, new_connection,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-The function `handle_accept()` is called when the asynchronous accept operation initiated by `start_accept()` finishes. It services the client request, and then calls `start_accept()` to initiate the next accept operation.
-
-
-
-  ``''''''``  void handle_accept(tcp_connection::pointer new_connection,
-  ``''''''``      const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      new_connection->start();
-  ``''''''``    }
-
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-
-
-[heading The tcp_connection class]
-
-We will use `shared_ptr` and `enable_shared_from_this` because we want to keep the `tcp_connection` object alive as long as there is an operation that refers to it.
-
-
-  ``''''''``class tcp_connection
-  ``''''''``  : public std::enable_shared_from_this<tcp_connection>
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  typedef std::shared_ptr<tcp_connection> pointer;
-
-  ``''''''``  static pointer create(asio::io_context& io_context)
-  ``''''''``  {
-  ``''''''``    return pointer(new tcp_connection(io_context));
-  ``''''''``  }
-
-  ``''''''``  tcp::socket& socket()
-  ``''''''``  {
-  ``''''''``    return socket_;
-  ``''''''``  }
-
-In the function `start()`, we call asio::async\_write() to serve the data to the client. Note that we are using asio::async\_write(), rather than [link asio.reference.basic_stream_socket.async_write_some ip::tcp::socket::async_write_some()], to ensure that the entire block of data is sent.
-
-
-
-  ``''''''``  void start()
-  ``''''''``  {
-
-The data to be sent is stored in the class member `message_` as we need to keep the data valid until the asynchronous operation is complete.
-
-
-  ``''''''``    message_ = make_daytime_string();
-
-When initiating the asynchronous operation, and if using `std::bind`, you must specify only the arguments that match the handler's parameter list. In this program, both of the argument placeholders (asio::placeholders::error and asio::placeholders::bytes\_transferred) could potentially have been removed, since they are not being used in `handle_write()`.
-
-
-
-  ``''''''``    asio::async_write(socket_, asio::buffer(message_),
-  ``''''''``        std::bind(&tcp_connection::handle_write, shared_from_this(),
-  ``''''''``          asio::placeholders::error,
-  ``''''''``          asio::placeholders::bytes_transferred));
-
-Any further actions for this client connection are now the responsibility of `handle_write()`.
-
-
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  tcp_connection(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  void handle_write(const std::error_code& /*error*/,
-  ``''''''``      size_t /*bytes_transferred*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  tcp::socket socket_;
-  ``''''''``  std::string message_;
-  ``''''''``};
-
-
-
-[heading Removing unused handler parameters]
-
-You may have noticed that the `error`, and `bytes_transferred` parameters are not used in the body of the `handle_write()` function. If parameters are not needed, it is possible to remove them from the function so that it looks like:
-
-
-  ``''''''``void handle_write()
-  ``''''''``{
-  ``''''''``}
-
-
-
-The asio::async\_write() call used to initiate the call can then be changed to just:
-
-
-  ``''''''``asio::async_write(socket_, asio::buffer(message_),
-  ``''''''``    std::bind(&tcp_connection::handle_write, shared_from_this()));
-
-
-
-See the [link asio.tutorial.tutdaytime3.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime2 Daytime.2 - A synchronous TCP daytime server]
-
-Next: [link asio.tutorial.tutdaytime4 Daytime.4 - A synchronous UDP daytime client]
-
-
-
-[section:src Source listing for Daytime.3]
-
-
-  ``''''''``//
-  ``''''''``// server.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <ctime>
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <memory>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::tcp;
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``class tcp_connection
-  ``''''''``  : public std::enable_shared_from_this<tcp_connection>
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  typedef std::shared_ptr<tcp_connection> pointer;
-
-  ``''''''``  static pointer create(asio::io_context& io_context)
-  ``''''''``  {
-  ``''''''``    return pointer(new tcp_connection(io_context));
-  ``''''''``  }
-
-  ``''''''``  tcp::socket& socket()
-  ``''''''``  {
-  ``''''''``    return socket_;
-  ``''''''``  }
-
-  ``''''''``  void start()
-  ``''''''``  {
-  ``''''''``    message_ = make_daytime_string();
-
-  ``''''''``    asio::async_write(socket_, asio::buffer(message_),
-  ``''''''``        std::bind(&tcp_connection::handle_write, shared_from_this(),
-  ``''''''``          asio::placeholders::error,
-  ``''''''``          asio::placeholders::bytes_transferred));
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  tcp_connection(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  void handle_write(const std::error_code& /*error*/,
-  ``''''''``      size_t /*bytes_transferred*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  tcp::socket socket_;
-  ``''''''``  std::string message_;
-  ``''''''``};
-
-  ``''''''``class tcp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  tcp_server(asio::io_context& io_context)
-  ``''''''``    : io_context_(io_context),
-  ``''''''``      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_accept()
-  ``''''''``  {
-  ``''''''``    tcp_connection::pointer new_connection =
-  ``''''''``      tcp_connection::create(io_context_);
-
-  ``''''''``    acceptor_.async_accept(new_connection->socket(),
-  ``''''''``        std::bind(&tcp_server::handle_accept, this, new_connection,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-  ``''''''``  void handle_accept(tcp_connection::pointer new_connection,
-  ``''''''``      const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      new_connection->start();
-  ``''''''``    }
-
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``  asio::io_context& io_context_;
-  ``''''''``  tcp::acceptor acceptor_;
-  ``''''''``};
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-  ``''''''``    tcp_server server(io_context);
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime3 Daytime.3 - An asynchronous TCP daytime server]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime4 Daytime.4 - A synchronous UDP daytime client]
-
-This tutorial program shows how to use asio to implement a client application with UDP.
-
-
-  ``''''''``#include <array>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::udp;
-
-The start of the application is essentially the same as for the TCP daytime client.
-
-
-
-  ``''''''``int main(int argc, char* argv[])
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    if (argc != 2)
-  ``''''''``    {
-  ``''''''``      std::cerr << "Usage: client <host>" << std::endl;
-  ``''''''``      return 1;
-  ``''''''``    }
-
-  ``''''''``    asio::io_context io_context;
-
-We use an [link asio.reference.ip__udp.resolver ip::udp::resolver] object to find the correct remote endpoint to use based on the host and service names. The query is restricted to return only IPv4 endpoints by the [link asio.reference.ip__udp.v4 ip::udp::v4()] argument.
-
-
-
-  ``''''''``    udp::resolver resolver(io_context);
-  ``''''''``    udp::endpoint receiver_endpoint =
-  ``''''''``      *resolver.resolve(udp::v4(), argv[1], "daytime").begin();
-
-The [link asio.reference.ip__basic_resolver.resolve ip::udp::resolver::resolve()] function is guaranteed to return at least one endpoint in the list if it does not fail. This means it is safe to dereference the return value directly.
-
-Since UDP is datagram-oriented, we will not be using a stream socket. Create an [link asio.reference.ip__udp.socket ip::udp::socket] and initiate contact with the remote endpoint.
-
-
-
-  ``''''''``    udp::socket socket(io_context);
-  ``''''''``    socket.open(udp::v4());
-
-  ``''''''``    std::array<char, 1> send_buf  = {{ 0 }};
-  ``''''''``    socket.send_to(asio::buffer(send_buf), receiver_endpoint);
-
-Now we need to be ready to accept whatever the server sends back to us. The endpoint on our side that receives the server's response will be initialised by [link asio.reference.basic_datagram_socket.receive_from ip::udp::socket::receive_from()].
-
-
-
-  ``''''''``    std::array<char, 128> recv_buf;
-  ``''''''``    udp::endpoint sender_endpoint;
-  ``''''''``    size_t len = socket.receive_from(
-  ``''''''``        asio::buffer(recv_buf), sender_endpoint);
-
-  ``''''''``    std::cout.write(recv_buf.data(), len);
-  ``''''''``  }
-
-Finally, handle any exceptions that may have been thrown.
-
-
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tutdaytime4.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime3 Daytime.3 - An asynchronous TCP daytime server]
-
-Next: [link asio.tutorial.tutdaytime5 Daytime.5 - A synchronous UDP daytime server]
-
-
-
-[section:src Source listing for Daytime.4]
-
-
-  ``''''''``//
-  ``''''''``// client.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <array>
-  ``''''''``#include <iostream>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::udp;
-
-  ``''''''``int main(int argc, char* argv[])
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    if (argc != 2)
-  ``''''''``    {
-  ``''''''``      std::cerr << "Usage: client <host>" << std::endl;
-  ``''''''``      return 1;
-  ``''''''``    }
-
-  ``''''''``    asio::io_context io_context;
-
-  ``''''''``    udp::resolver resolver(io_context);
-  ``''''''``    udp::endpoint receiver_endpoint =
-  ``''''''``      *resolver.resolve(udp::v4(), argv[1], "daytime").begin();
-
-  ``''''''``    udp::socket socket(io_context);
-  ``''''''``    socket.open(udp::v4());
-
-  ``''''''``    std::array<char, 1> send_buf  = {{ 0 }};
-  ``''''''``    socket.send_to(asio::buffer(send_buf), receiver_endpoint);
-
-  ``''''''``    std::array<char, 128> recv_buf;
-  ``''''''``    udp::endpoint sender_endpoint;
-  ``''''''``    size_t len = socket.receive_from(
-  ``''''''``        asio::buffer(recv_buf), sender_endpoint);
-
-  ``''''''``    std::cout.write(recv_buf.data(), len);
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime4 Daytime.4 - A synchronous UDP daytime client]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime5 Daytime.5 - A synchronous UDP daytime server]
-
-This tutorial program shows how to use asio to implement a server application with UDP.
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-
-Create an [link asio.reference.ip__udp.socket ip::udp::socket] object to receive requests on UDP port 13.
-
-
-
-  ``''''''``    udp::socket socket(io_context, udp::endpoint(udp::v4(), 13));
-
-Wait for a client to initiate contact with us. The remote\_endpoint object will be populated by [link asio.reference.basic_datagram_socket.receive_from ip::udp::socket::receive_from()].
-
-
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      std::array<char, 1> recv_buf;
-  ``''''''``      udp::endpoint remote_endpoint;
-  ``''''''``      socket.receive_from(asio::buffer(recv_buf), remote_endpoint);
-
-Determine what we are going to send back to the client.
-
-
-
-  ``''''''``      std::string message = make_daytime_string();
-
-Send the response to the remote\_endpoint.
-
-
-
-  ``''''''``      std::error_code ignored_error;
-  ``''''''``      socket.send_to(asio::buffer(message),
-  ``''''''``          remote_endpoint, 0, ignored_error);
-  ``''''''``    }
-  ``''''''``  }
-
-Finally, handle any exceptions.
-
-
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-See the [link asio.tutorial.tutdaytime5.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime4 Daytime.4 - A synchronous UDP daytime client]
-
-Next: [link asio.tutorial.tutdaytime6 Daytime.6 - An asynchronous UDP daytime server]
-
-
-
-[section:src Source listing for Daytime.5]
-
-
-  ``''''''``//
-  ``''''''``// server.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <array>
-  ``''''''``#include <ctime>
-  ``''''''``#include <iostream>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::udp;
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-
-  ``''''''``    udp::socket socket(io_context, udp::endpoint(udp::v4(), 13));
-
-  ``''''''``    for (;;)
-  ``''''''``    {
-  ``''''''``      std::array<char, 1> recv_buf;
-  ``''''''``      udp::endpoint remote_endpoint;
-  ``''''''``      socket.receive_from(asio::buffer(recv_buf), remote_endpoint);
-
-  ``''''''``      std::string message = make_daytime_string();
-
-  ``''''''``      std::error_code ignored_error;
-  ``''''''``      socket.send_to(asio::buffer(message),
-  ``''''''``          remote_endpoint, 0, ignored_error);
-  ``''''''``    }
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime5 Daytime.5 - A synchronous UDP daytime server]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime6 Daytime.6 - An asynchronous UDP daytime server]
-
-[heading The main() function]
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-
-Create a server object to accept incoming client requests, and run the 
-[link asio.reference.io_context io_context] object.
-
-
-  ``''''''``    asio::io_context io_context;
-  ``''''''``    udp_server server(io_context);
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-
-
-[heading The udp_server class]
-
-
-  ``''''''``class udp_server
-  ``''''''``{
-  ``''''''``public:
-
-The constructor initialises a socket to listen on UDP port 13.
-
-
-  ``''''''``  udp_server(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_receive();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_receive()
-  ``''''''``  {
-
-The function [link asio.reference.basic_datagram_socket.async_receive_from ip::udp::socket::async_receive_from()] will cause the application to listen in the background for a new request. When such a request is received, the 
-[link asio.reference.io_context io_context] object will invoke the `handle_receive()` function with two arguments: a value of type std::error\_code indicating whether the operation succeeded or failed, and a `size_t` value `bytes_transferred` specifying the number of bytes received.
-
-
-  ``''''''``    socket_.async_receive_from(
-  ``''''''``        asio::buffer(recv_buffer_), remote_endpoint_,
-  ``''''''``        std::bind(&udp_server::handle_receive, this,
-  ``''''''``          asio::placeholders::error,
-  ``''''''``          asio::placeholders::bytes_transferred));
-  ``''''''``  }
-
-The function `handle_receive()` will service the client request.
-
-
-
-  ``''''''``  void handle_receive(const std::error_code& error,
-  ``''''''``      std::size_t /*bytes_transferred*/)
-  ``''''''``  {
-
-The `error` parameter contains the result of the asynchronous operation. Since we only provide the 1-byte `recv_buffer_` to contain the client's request, the 
-[link asio.reference.io_context io_context] object would return an error if the client sent anything larger. We can ignore such an error if it comes up.
-
-
-  ``''''''``    if (!error)
-  ``''''''``    {
-
-Determine what we are going to send.
-
-
-  ``''''''``      std::shared_ptr<std::string> message(
-  ``''''''``          new std::string(make_daytime_string()));
-
-We now call [link asio.reference.basic_datagram_socket.async_send_to ip::udp::socket::async_send_to()] to serve the data to the client.
-
-
-
-  ``''''''``      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-  ``''''''``          std::bind(&udp_server::handle_send, this, message,
-  ``''''''``            asio::placeholders::error,
-  ``''''''``            asio::placeholders::bytes_transferred));
-
-When initiating the asynchronous operation, and if using `std::bind`, you must specify only the arguments that match the handler's parameter list. In this program, both of the argument placeholders (asio::placeholders::error and asio::placeholders::bytes\_transferred) could potentially have been removed.
-
-Start listening for the next client request.
-
-
-
-  ``''''''``      start_receive();
-
-Any further actions for this client request are now the responsibility of `handle_send()`.
-
-
-  ``''''''``    }
-  ``''''''``  }
-
-The function `handle_send()` is invoked after the service request has been completed.
-
-
-
-  ``''''''``  void handle_send(std::shared_ptr<std::string> /*message*/,
-  ``''''''``      const std::error_code& /*error*/,
-  ``''''''``      std::size_t /*bytes_transferred*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  udp::socket socket_;
-  ``''''''``  udp::endpoint remote_endpoint_;
-  ``''''''``  std::array<char, 1> recv_buffer_;
-  ``''''''``};
-
-See the [link asio.tutorial.tutdaytime6.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime5 Daytime.5 - A synchronous UDP daytime server]
-
-Next: [link asio.tutorial.tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server]
-
-
-
-[section:src Source listing for Daytime.6]
-
-
-  ``''''''``//
-  ``''''''``// server.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <array>
-  ``''''''``#include <ctime>
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <memory>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::udp;
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``class udp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  udp_server(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_receive();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_receive()
-  ``''''''``  {
-  ``''''''``    socket_.async_receive_from(
-  ``''''''``        asio::buffer(recv_buffer_), remote_endpoint_,
-  ``''''''``        std::bind(&udp_server::handle_receive, this,
-  ``''''''``          asio::placeholders::error,
-  ``''''''``          asio::placeholders::bytes_transferred));
-  ``''''''``  }
-
-  ``''''''``  void handle_receive(const std::error_code& error,
-  ``''''''``      std::size_t /*bytes_transferred*/)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      std::shared_ptr<std::string> message(
-  ``''''''``          new std::string(make_daytime_string()));
-
-  ``''''''``      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-  ``''''''``          std::bind(&udp_server::handle_send, this, message,
-  ``''''''``            asio::placeholders::error,
-  ``''''''``            asio::placeholders::bytes_transferred));
-
-  ``''''''``      start_receive();
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``  void handle_send(std::shared_ptr<std::string> /*message*/,
-  ``''''''``      const std::error_code& /*error*/,
-  ``''''''``      std::size_t /*bytes_transferred*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  udp::socket socket_;
-  ``''''''``  udp::endpoint remote_endpoint_;
-  ``''''''``  std::array<char, 1> recv_buffer_;
-  ``''''''``};
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-  ``''''''``    udp_server server(io_context);
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime6 Daytime.6 - An asynchronous UDP daytime server]
-
-[endsect]
-
-[endsect]
-
-[section:tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server]
-
-This tutorial program shows how to combine the two asynchronous servers that we have just written, into a single server application.
-
-[heading The main() function]
-
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-
-We will begin by creating a server object to accept a TCP client connection.
-
-
-  ``''''''``    tcp_server server1(io_context);
-
-We also need a server object to accept a UDP client request.
-
-
-  ``''''''``    udp_server server2(io_context);
-
-We have created two lots of work for the 
-[link asio.reference.io_context io_context] object to do.
-
-
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-
-
-[heading The tcp_connection and tcp_server classes]
-
-The following two classes are taken from [link asio.tutorial.tutdaytime3 Daytime.3].
-
-
-  ``''''''``class tcp_connection
-  ``''''''``  : public std::enable_shared_from_this<tcp_connection>
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  typedef std::shared_ptr<tcp_connection> pointer;
-
-  ``''''''``  static pointer create(asio::io_context& io_context)
-  ``''''''``  {
-  ``''''''``    return pointer(new tcp_connection(io_context));
-  ``''''''``  }
-
-  ``''''''``  tcp::socket& socket()
-  ``''''''``  {
-  ``''''''``    return socket_;
-  ``''''''``  }
-
-  ``''''''``  void start()
-  ``''''''``  {
-  ``''''''``    message_ = make_daytime_string();
-
-  ``''''''``    asio::async_write(socket_, asio::buffer(message_),
-  ``''''''``        std::bind(&tcp_connection::handle_write, shared_from_this()));
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  tcp_connection(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  void handle_write()
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  tcp::socket socket_;
-  ``''''''``  std::string message_;
-  ``''''''``};
-
-  ``''''''``class tcp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  tcp_server(asio::io_context& io_context)
-  ``''''''``    : io_context_(io_context),
-  ``''''''``      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_accept()
-  ``''''''``  {
-  ``''''''``    tcp_connection::pointer new_connection =
-  ``''''''``      tcp_connection::create(io_context_);
-
-  ``''''''``    acceptor_.async_accept(new_connection->socket(),
-  ``''''''``        std::bind(&tcp_server::handle_accept, this, new_connection,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-  ``''''''``  void handle_accept(tcp_connection::pointer new_connection,
-  ``''''''``      const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      new_connection->start();
-  ``''''''``    }
-
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``  asio::io_context& io_context_;
-  ``''''''``  tcp::acceptor acceptor_;
-  ``''''''``};
-
-
-
-[heading The udp_server class]
-
-Similarly, this next class is taken from the [link asio.tutorial.tutdaytime6 previous tutorial step].
-
-
-  ``''''''``class udp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  udp_server(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_receive();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_receive()
-  ``''''''``  {
-  ``''''''``    socket_.async_receive_from(
-  ``''''''``        asio::buffer(recv_buffer_), remote_endpoint_,
-  ``''''''``        std::bind(&udp_server::handle_receive, this,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-  ``''''''``  void handle_receive(const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      std::shared_ptr<std::string> message(
-  ``''''''``          new std::string(make_daytime_string()));
-
-  ``''''''``      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-  ``''''''``          std::bind(&udp_server::handle_send, this, message));
-
-  ``''''''``      start_receive();
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``  void handle_send(std::shared_ptr<std::string> /*message*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  udp::socket socket_;
-  ``''''''``  udp::endpoint remote_endpoint_;
-  ``''''''``  std::array<char, 1> recv_buffer_;
-  ``''''''``};
-
-See the [link asio.tutorial.tutdaytime7.src full source listing]
-
-Return to the [link asio.tutorial tutorial index]
-
-Previous: [link asio.tutorial.tutdaytime6 Daytime.6 - An asynchronous UDP daytime server]
-
-
-
-[section:src Source listing for Daytime.7]
-
-
-  ``''''''``//
-  ``''''''``// server.cpp
-  ``''''''``// ~~~~~~~~~~
-  ``''''''``//
-  ``''''''``// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-  ``''''''``//
-  ``''''''``// Distributed under the Boost Software License, Version 1.0. (See accompanying
-  ``''''''``// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-  ``''''''``//
-
-  ``''''''``#include <array>
-  ``''''''``#include <ctime>
-  ``''''''``#include <functional>
-  ``''''''``#include <iostream>
-  ``''''''``#include <memory>
-  ``''''''``#include <string>
-  ``''''''``#include <asio.hpp>
-
-  ``''''''``using asio::ip::tcp;
-  ``''''''``using asio::ip::udp;
-
-  ``''''''``std::string make_daytime_string()
-  ``''''''``{
-  ``''''''``  using namespace std; // For time_t, time and ctime;
-  ``''''''``  time_t now = time(0);
-  ``''''''``  return ctime(&now);
-  ``''''''``}
-
-  ``''''''``class tcp_connection
-  ``''''''``  : public std::enable_shared_from_this<tcp_connection>
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  typedef std::shared_ptr<tcp_connection> pointer;
-
-  ``''''''``  static pointer create(asio::io_context& io_context)
-  ``''''''``  {
-  ``''''''``    return pointer(new tcp_connection(io_context));
-  ``''''''``  }
-
-  ``''''''``  tcp::socket& socket()
-  ``''''''``  {
-  ``''''''``    return socket_;
-  ``''''''``  }
-
-  ``''''''``  void start()
-  ``''''''``  {
-  ``''''''``    message_ = make_daytime_string();
-
-  ``''''''``    asio::async_write(socket_, asio::buffer(message_),
-  ``''''''``        std::bind(&tcp_connection::handle_write, shared_from_this()));
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  tcp_connection(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  void handle_write()
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  tcp::socket socket_;
-  ``''''''``  std::string message_;
-  ``''''''``};
-
-  ``''''''``class tcp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  tcp_server(asio::io_context& io_context)
-  ``''''''``    : io_context_(io_context),
-  ``''''''``      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_accept()
-  ``''''''``  {
-  ``''''''``    tcp_connection::pointer new_connection =
-  ``''''''``      tcp_connection::create(io_context_);
-
-  ``''''''``    acceptor_.async_accept(new_connection->socket(),
-  ``''''''``        std::bind(&tcp_server::handle_accept, this, new_connection,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-  ``''''''``  void handle_accept(tcp_connection::pointer new_connection,
-  ``''''''``      const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      new_connection->start();
-  ``''''''``    }
-
-  ``''''''``    start_accept();
-  ``''''''``  }
-
-  ``''''''``  asio::io_context& io_context_;
-  ``''''''``  tcp::acceptor acceptor_;
-  ``''''''``};
-
-  ``''''''``class udp_server
-  ``''''''``{
-  ``''''''``public:
-  ``''''''``  udp_server(asio::io_context& io_context)
-  ``''''''``    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  ``''''''``  {
-  ``''''''``    start_receive();
-  ``''''''``  }
-
-  ``''''''``private:
-  ``''''''``  void start_receive()
-  ``''''''``  {
-  ``''''''``    socket_.async_receive_from(
-  ``''''''``        asio::buffer(recv_buffer_), remote_endpoint_,
-  ``''''''``        std::bind(&udp_server::handle_receive, this,
-  ``''''''``          asio::placeholders::error));
-  ``''''''``  }
-
-  ``''''''``  void handle_receive(const std::error_code& error)
-  ``''''''``  {
-  ``''''''``    if (!error)
-  ``''''''``    {
-  ``''''''``      std::shared_ptr<std::string> message(
-  ``''''''``          new std::string(make_daytime_string()));
-
-  ``''''''``      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-  ``''''''``          std::bind(&udp_server::handle_send, this, message));
-
-  ``''''''``      start_receive();
-  ``''''''``    }
-  ``''''''``  }
-
-  ``''''''``  void handle_send(std::shared_ptr<std::string> /*message*/)
-  ``''''''``  {
-  ``''''''``  }
-
-  ``''''''``  udp::socket socket_;
-  ``''''''``  udp::endpoint remote_endpoint_;
-  ``''''''``  std::array<char, 1> recv_buffer_;
-  ``''''''``};
-
-  ``''''''``int main()
-  ``''''''``{
-  ``''''''``  try
-  ``''''''``  {
-  ``''''''``    asio::io_context io_context;
-  ``''''''``    tcp_server server1(io_context);
-  ``''''''``    udp_server server2(io_context);
-  ``''''''``    io_context.run();
-  ``''''''``  }
-  ``''''''``  catch (std::exception& e)
-  ``''''''``  {
-  ``''''''``    std::cerr << e.what() << std::endl;
-  ``''''''``  }
-
-  ``''''''``  return 0;
-  ``''''''``}
-
-Return to [link asio.tutorial.tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server]
-
-[endsect]
-
-[endsect]
-
-[section:boost_bind boost::bind]
-
-See the [@http://www.boost.org/libs/bind/bind.html Boost: bind.hpp documentation] for more information on how to use `boost::bind`. 
-
-[endsect]
-
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.xsl b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.xsl
deleted file mode 100644
index 06c015a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/tutorial.xsl
+++ /dev/null
@@ -1,454 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-
-<!--
-  Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-  Distributed under the Boost Software License, Version 1.0. (See accompanying
-  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<xsl:output method="text"/>
-<xsl:strip-space elements="*"/>
-
-
-<xsl:variable name="newline">
-<xsl:text>
-</xsl:text>
-</xsl:variable>
-
-
-<xsl:template match="/doxygen">
-<xsl:text>[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:tutorial Tutorial]
-
-</xsl:text>
-
-  <xsl:for-each select="compounddef[@kind = 'page' and @id = 'indexpage']">
-    <xsl:apply-templates select="detaileddescription"/>
-  </xsl:for-each>
-
-  <xsl:for-each select="
-      compounddef[
-        @kind = 'page' and
-        @id != 'indexpage' and
-        not(contains(@id, 'src'))]">
-    <xsl:text>[section:</xsl:text>
-    <xsl:value-of select="concat(@id, ' ', title)"/>
-    <xsl:text>]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:value-of select="$newline"/>
-    <xsl:apply-templates select="detaileddescription"/>
-    <xsl:variable name="srcid" select="concat(@id, 'src')"/>
-    <xsl:if test="count(/doxygen/compounddef[@id = $srcid]) &gt; 0">
-      <xsl:value-of select="$newline"/>
-      <xsl:value-of select="$newline"/>
-      <xsl:text>[section:src </xsl:text>
-      <xsl:value-of select="/doxygen/compounddef[@id = $srcid]/title"/>
-      <xsl:text>]</xsl:text>
-      <xsl:value-of select="$newline"/>
-      <xsl:value-of select="$newline"/>
-      <xsl:apply-templates select="/doxygen/compounddef[@id = $srcid]/detaileddescription"/>
-      <xsl:text>[endsect]</xsl:text>
-      <xsl:value-of select="$newline"/>
-      <xsl:value-of select="$newline"/>
-    </xsl:if>
-    <xsl:text>[endsect]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:value-of select="$newline"/>
-  </xsl:for-each>
-
-  <xsl:value-of select="$newline"/>
-  <xsl:text>[endsect]</xsl:text>
-  <xsl:value-of select="$newline"/>
-
-</xsl:template>
-
-
-<!--========== Utilities ==========-->
-
-<xsl:template name="strip-asio-ns">
-  <xsl:param name="name"/>
-  <xsl:choose>
-    <xsl:when test="contains($name, 'boost::system::is_error_code_enum')">
-      <xsl:value-of select="$name"/>
-    </xsl:when>
-    <xsl:when test="contains($name, 'asio::')">
-      <xsl:value-of select="substring-after($name, 'asio::')"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$name"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="make-id">
-  <xsl:param name="name"/>
-  <xsl:choose>
-    <xsl:when test="contains($name, '::')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '::'), '__', substring-after($name, '::'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '=')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '='), '_eq_', substring-after($name, '='))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '!')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '!'), '_not_', substring-after($name, '!'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&lt;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&lt;'), '_lt_', substring-after($name, '&lt;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&gt;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&gt;'), '_gt_', substring-after($name, '&gt;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '&amp;')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '&amp;'), '_amp_', substring-after($name, '&amp;'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '+')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '+'), '_plus_', substring-after($name, '+'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, '~')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, '~'), '_', substring-after($name, '~'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, ' ')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, ' '), '_', substring-after($name, ' '))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="contains($name, 'boost__posix_time__ptime')">
-      <xsl:call-template name="make-id">
-        <xsl:with-param name="name"
-         select="concat(substring-before($name, 'boost__posix_time__ptime'), 'ptime', substring-after($name, 'boost__posix_time__ptime'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$name"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="replace-scope-marker">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="contains($text, '_1_1')">
-      <xsl:call-template name="replace-scope-marker">
-        <xsl:with-param name="text"
-         select="concat(substring-before($text, '_1_1'), '::', substring-after($text, '_1_1'))"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="refid-to-anchor">
-  <xsl:param name="text"/>
-  <xsl:variable name="scoped-text">
-    <xsl:call-template name="replace-scope-marker">
-      <xsl:with-param name="text" select="$text"/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:value-of select="substring-after($scoped-text, '_1')"/>
-</xsl:template>
-
-
-<!--========== Markup ==========-->
-
-<xsl:template match="para">
-  <xsl:apply-templates/>
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="title">
-  <xsl:variable name="title">
-    <xsl:value-of select="."/>
-  </xsl:variable>
-  <xsl:if test="string-length($title) > 0">
-    <xsl:text>[heading </xsl:text>
-    <xsl:value-of select="."/>
-    <xsl:text>]</xsl:text>
-    <xsl:value-of select="$newline"/>
-    <xsl:value-of select="$newline"/>
-  </xsl:if>
-</xsl:template>
-
-
-<xsl:template match="programlisting">
-  <xsl:value-of select="$newline"/>
-  <xsl:apply-templates/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="codeline">
-  <xsl:if test="string-length(.) &gt; 0">
-    <xsl:text>  ``''''''``</xsl:text>
-  </xsl:if>
-  <xsl:apply-templates mode="codeline"/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="sp">
-  <xsl:text> </xsl:text>
-</xsl:template>
-
-
-<xsl:template match="sp" mode="codeline">
-  <xsl:text> </xsl:text>
-</xsl:template>
-
-
-<xsl:template match="linebreak">
-  <xsl:value-of select="$newline"/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="listitem">
-  <xsl:text>* </xsl:text>
-  <xsl:apply-templates/>
-  <xsl:value-of select="$newline"/>
-</xsl:template>
-
-
-<xsl:template match="emphasis">
-  <xsl:text>[*</xsl:text>
-  <xsl:value-of select="."/>
-  <xsl:text>]</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="computeroutput">
-  <xsl:text>`</xsl:text>
-  <xsl:value-of select="."/>
-  <xsl:text>`</xsl:text>
-</xsl:template>
-
-
-<xsl:template match="text()">
-  <xsl:variable name="text" select="."/>
-  <xsl:variable name="starts-with-whitespace" select="
-      starts-with($text, ' ') or starts-with($text, $newline)"/>
-  <xsl:variable name="preceding-node-name">
-    <xsl:for-each select="preceding-sibling::*">
-      <xsl:if test="position() = last()">
-        <xsl:value-of select="local-name()"/>
-      </xsl:if>
-    </xsl:for-each>
-  </xsl:variable>
-  <xsl:variable name="after-newline" select="
-      $preceding-node-name = 'programlisting' or
-      $preceding-node-name = 'linebreak'"/>
-  <xsl:choose>
-    <xsl:when test="$starts-with-whitespace and $after-newline">
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text">
-          <xsl:call-template name="strip-leading-whitespace">
-            <xsl:with-param name="text" select="$text"/>
-          </xsl:call-template>
-        </xsl:with-param>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text" select="$text"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="strip-leading-whitespace">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="starts-with($text, ' ')">
-      <xsl:call-template name="strip-leading-whitespace">
-        <xsl:with-param name="text" select="substring($text, 2)"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:when test="starts-with($text, $newline)">
-      <xsl:call-template name="strip-leading-whitespace">
-        <xsl:with-param name="text" select="substring($text, 2)"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template name="escape-text">
-  <xsl:param name="text"/>
-  <xsl:choose>
-    <xsl:when test="contains($text, '_')">
-      <xsl:value-of select="substring-before($text, '_')"/>
-      <xsl:text>\_</xsl:text>
-      <xsl:call-template name="escape-text">
-        <xsl:with-param name="text" select="substring-after($text, '_')"/>
-      </xsl:call-template>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:value-of select="$text"/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='compound']">
-  <xsl:variable name="name">
-    <xsl:value-of select="."/>
-  </xsl:variable>
-  <xsl:variable name="refid">
-    <xsl:value-of select="@refid"/>
-  </xsl:variable>
-  <xsl:choose>
-    <xsl:when test="$refid = 'index'">
-      <xsl:text>[link asio.tutorial </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="$refid = 'asynchronous_operation'">
-      <xsl:text>[link asio.overview.model.async_ops </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="$refid = 'completion_token'">
-      <xsl:text>[link asio.overview.model.completion_tokens </xsl:text>
-      <xsl:value-of select="."/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="count(/doxygen/compounddef[@id=$refid]) &gt; 0">
-      <xsl:text>[link asio.tutorial.</xsl:text>
-      <xsl:choose>
-        <xsl:when test="contains($refid, 'src')">
-          <xsl:value-of select="substring-before($refid, 'src')"/>
-          <xsl:text>.src</xsl:text>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:value-of select="$refid"/>
-        </xsl:otherwise>
-      </xsl:choose>
-      <xsl:value-of select="concat(' ', .)"/>
-      <xsl:text>]</xsl:text>
-    </xsl:when>
-    <xsl:when test="contains($name, 'asio::')">
-      <xsl:variable name="ref-name">
-        <xsl:call-template name="strip-asio-ns">
-          <xsl:with-param name="name" select="$name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="ref-id">
-        <xsl:call-template name="make-id">
-          <xsl:with-param name="name" select="$ref-name"/>
-        </xsl:call-template>
-      </xsl:variable>
-[link asio.reference.<xsl:value-of select="$ref-id"/><xsl:text> </xsl:text><xsl:value-of
- select="$ref-name"/>]</xsl:when>
-    <xsl:otherwise>
-      <xsl:apply-templates/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ref[@kindref='member']">
-  <xsl:variable name="refid">
-    <xsl:value-of select="@refid"/>
-  </xsl:variable>
-  <xsl:variable name="text">
-    <xsl:call-template name="strip-asio-ns">
-      <xsl:with-param name="name" select="."/>
-    </xsl:call-template>
-  </xsl:variable>
-  <xsl:choose>
-    <xsl:when test="contains(@external, 'reference.tags')">
-      <xsl:variable name="anchor">
-        <xsl:call-template name="refid-to-anchor">
-          <xsl:with-param name="text" select="$refid"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:choose>
-        <xsl:when test="count(document('reference.tags')/tagfile/compound[@kind='class']/member[anchor=$anchor]) &gt; 0">
-          <xsl:for-each select="document('reference.tags')/tagfile/compound[@kind='class']/member[anchor=$anchor]">
-            <xsl:variable name="scope">
-              <xsl:call-template name="make-id">
-                <xsl:with-param name="name">
-                  <xsl:call-template name="strip-asio-ns">
-                    <xsl:with-param name="name" select="../name"/>
-                  </xsl:call-template>
-                </xsl:with-param>
-              </xsl:call-template>
-            </xsl:variable>
-            <xsl:variable name="name">
-              <xsl:call-template name="make-id">
-                <xsl:with-param name="name" select="name"/>
-              </xsl:call-template>
-            </xsl:variable>
-            <xsl:text>[link asio.reference.</xsl:text>
-            <xsl:if test="string-length($scope) &gt; 0">
-              <xsl:value-of select="$scope"/><xsl:text>.</xsl:text>
-            </xsl:if>
-            <xsl:value-of select="$name"/>
-            <xsl:text> </xsl:text><xsl:value-of select="$text"/><xsl:text>]</xsl:text>
-          </xsl:for-each>
-        </xsl:when>
-        <xsl:otherwise>
-          <xsl:apply-templates/>
-        </xsl:otherwise>
-      </xsl:choose>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:apply-templates/>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:template>
-
-
-<xsl:template match="ulink">
-  <xsl:text>[@</xsl:text>
-  <xsl:value-of select="@url"/>
-  <xsl:text> </xsl:text>
-  <xsl:value-of select="."/>
-  <xsl:text>]</xsl:text>
-</xsl:template>
-
-
-</xsl:stylesheet>
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/using.qbk b/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/using.qbk
deleted file mode 100644
index 9e7e4fb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/doc/using.qbk
+++ /dev/null
@@ -1,419 +0,0 @@
-[/
- / Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
- /
- / Distributed under the Boost Software License, Version 1.0. (See accompanying
- / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- /]
-
-[section:using Using, Building, and Configuring Asio]
-
-[heading Supported Platforms]
-
-The following platform and compiler combinations are regularly tested:
-
-* Linux using g++ 4.6 or later
-* Linux using clang 3.4 or later
-* FreeBSD using g++ 9 or later
-* macOS using Xcode 10 or later
-* Win32 using Visual C++ 11.0 (Visual Studio 2012) or later
-* Win64 using Visual C++ 11.0 (Visual Studio 2012) or later
-
-The following platforms may also work:
-
-* AIX
-* Android
-* HP-UX
-* iOS
-* NetBSD
-* OpenBSD
-* QNX Neutrino
-* Solaris
-* Tru64
-* Win32 using MinGW.
-* Win32 using Cygwin. (`__USE_W32_SOCKETS` must be defined.)
-
-[heading Dependencies]
-
-The following libraries must be available in order to link programs that use
-Asio:
-
-* Boost.Coroutine (optional) if you use [link asio.reference.spawn
-`spawn()`] to launch coroutines.
-
-* Boost.Regex (optional) if you use any of the [link
-asio.reference.read_until `read_until()`] or [link
-asio.reference.async_read_until `async_read_until()`] overloads that take
-a `boost::regex` parameter.
-
-* [@http://www.openssl.org OpenSSL] (optional) if you use Asio's SSL
-support.
-
-Furthermore, some of the examples also require Boost.Date_Time or
-Boost.Serialization libraries.
-
-[note With MSVC or Borland C++ you may want to add `-DBOOST_DATE_TIME_NO_LIB`
-and `-DBOOST_REGEX_NO_LIB` to your project settings to disable autolinking of
-the Boost.Date_Time and Boost.Regex libraries respectively. Alternatively, you
-may choose to build these libraries and link to them.]
-
-[heading Optional separate compilation]
-
-By default, Asio is a header-only library. However, some developers may prefer
-to build Asio using separately compiled source code. To do this, add `#include
-<asio/impl/src.hpp>` to one (and only one) source file in a program, then build
-the program with `ASIO_SEPARATE_COMPILATION` defined in the project\/compiler
-settings. Alternatively, `ASIO_DYN_LINK` may be defined to build a
-separately-compiled Asio as part of a shared library.
-
-If using Asio's SSL support, you will also need to add `#include
-<asio/ssl/impl/src.hpp>`.
-
-[heading Debugger support]
-
-Some debugger extensions for use with Asio may be found at
-[@https://github.com/chriskohlhoff/asio-debugger-extensions].
-
-[heading Building the tests and examples on Linux or UNIX]
-
-If the boost directory (e.g. the directory called `boost_1_34_1`) is in the
-same directory as the asio source kit, then you may configure asio by simply
-going:
-
-  ./configure
-
-in the root directory of the asio source kit. Note that configure will always
-use the most recent boost version it knows about (i.e. 1.34.1) in preference to
-earlier versions, if there is more than one version present.
-
-If the boost directory is in some other location, then you need to
-specify this directory when running configure:
-
-  ./configure --with-boost=``['path_to_boost]``
-
-When specifying the boost directory in this way you should ensure that you use
-an absolute path.
-
-To build the examples, simply run `make` in the root directory of the asio
-source kit. To also build and run the unit tests, to confirm that asio is
-working correctly, run `make check`.
-
-[heading Building the tests and examples with MSVC]
-
-To build using the MSVC 9.0 (or later) command line compiler, perform the
-following steps in a Command Prompt window:
-
-* If you are using a version of boost other than 1.34.1, or if the boost
-  directory (i.e. the directory called `boost_1_34_1`) is not in the same
-  directory as the asio source kit, then specify the location of boost by
-  running a command similar to [^set BOOSTDIR=['path_to_boost]]. Ensure that
-  you specify an absolute path.
-
-* Change to the asio `src` directory.
-
-* Execute the command `nmake -f Makefile.msc`.
-
-* Execute the command `nmake -f Makefile.msc check` to run a suite of tests to
-  confirm that asio is working correctly.
-
-[heading Building the tests and examples with MinGW]
-
-To build using the MinGW g++ compiler from the command line, perform the
-following steps in a Command Prompt window:
-
-* If you are using a version of boost other than 1.34.1, or if the boost
-  directory (i.e. the directory called `boost_1_34_1`) is not in the same
-  directory as the asio source kit, then specify the location of boost by
-  running a command similar to [^set BOOSTDIR=['path_to_boost]]. Ensure that
-  you specify an absolute path using ['forward slashes] (i.e.
-  `c:/projects/boost_1_34_1` rather than `c:\projects\boost_1_34_1`).
-
-* Change to the asio `src` directory.
-
-* Execute the command `make -f Makefile.mgw`.
-
-* Execute the command `make -f Makefile.mgw check` to run a suite of tests to
-  confirm that asio is working correctly.
-
-[note The above instructions do not work when building inside MSYS. If you want
-to build using MSYS, you should use [^export] rather than [^set] to specify the
-location of boost.]
-
-[heading Macros]
-
-The macros listed in the table below may be used to control the interface,
-functionality, and behaviour of Asio.
-
-[table
-  [[Macro][Description]]
-  [
-    [`ASIO_NO_DEPRECATED`]
-    [
-      Disables Asio's deprecated interfaces and functionality.
-
-      See [link asio.net_ts Networking TS Compatibility] for a list of older
-      interfaces that have been deprecated, and their replacements.
-    ]
-  ]
-  [
-    [`ASIO_NO_TS_EXECUTORS`]
-    [
-      Disables Asio's support for the Networking TS executor model.
-
-      By default, Asio simultaneously supports both Networking TS-style
-      executors, and executors that adhere to the proposed standard executor
-      model. This macro may be used to limit support to the proposed standard
-      executors only. See [link asio.std_executors Proposed Standard
-      Executors] for more information.
-    ]
-  ]
-  [
-    [`ASIO_USE_TS_EXECUTOR_AS_DEFAULT`]
-    [
-      Specifies that [link asio.reference.any_io_executor `any_io_executor`]
-      refer to the Networking TS-style polymorphic wrapper.
-
-      The `any_io_executor` type alias is the default runtime-polymorphic
-      executor for all I/O objects. This type alias points to the [link
-      asio.reference.execution__any_executor `execution::any_executor<>`]
-      template with a set of supportable properties specified for use with I/O.
-
-      This new name may break existing code that directly uses the old
-      Networking TS-style polymorphic wrapper, [link asio.reference.executor
-      `executor`]. If required for backward compatibility,
-      `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` changes the `any_io_executor` type
-      alias to instead point to the `executor` polymorphic wrapper.
-
-      See [link asio.std_executors Proposed Standard Executors] for more
-      information.
-    ]
-  ]
-  [
-    [`ASIO_NO_DYNAMIC_BUFFER_V1`]
-    [
-      Disables support for the [link asio.reference.DynamicBuffer_v1
-      `DynamicBuffer_v1`] type requirements.
-
-      By default, dynamic buffer operations such as [link asio.reference.read
-      `read`], [link asio.reference.async_read `async_read`], [link
-      asio.reference.read_until `read_until`], [link
-      asio.reference.async_read_until `async_read_until`], [link
-      asio.reference.write `write`], and [link asio.reference.async_write
-      `async_write`] support both the `DynamicBuffer_v1` and the [link
-      asio.reference.DynamicBuffer_v2 `DynamicBuffer_v2`] type requirements
-      for dynamic buffers.
-
-      When `ASIO_NO_DYNAMIC_BUFFER_V1` is defined, all support for
-      `DynamicBuffer_v1` types and functions is #ifdef-ed out. Support for
-      using [link asio.reference.basic_streambuf `basic_streambuf`] with the
-      `read`, `async_read`, `read_until`, `async_read_until`, `write`, and
-      `async_write` functions is also disabled as a consequence.
-    ]
-  ]
-  [
-    [`ASIO_ENABLE_BUFFER_DEBUGGING`]
-    [
-      Enables Asio's buffer debugging support, which can help identify when
-      invalid buffers are used in read or write operations (e.g. if a
-      std::string object being written is destroyed before the write operation
-      completes).
-
-      When using Microsoft Visual C++ 11.0 or later, this macro is defined
-      automatically if the compiler's iterator debugging support is enabled,
-      unless `ASIO_DISABLE_BUFFER_DEBUGGING` has been defined.
-
-      When using g++, this macro is defined automatically if standard library
-      debugging is enabled (`_GLIBCXX_DEBUG` is defined), unless
-      `ASIO_DISABLE_BUFFER_DEBUGGING` has been defined.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_BUFFER_DEBUGGING`]
-    [
-      Explictly disables Asio's buffer debugging support.
-    ]
-  ]
-  [
-    [`ASIO_ENABLE_HANDLER_TRACKING`]
-    [
-      Enables Asio's [link asio.overview.core.handler_tracking Handler
-      Tracking] debugging facility.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_DEV_POLL`]
-    [
-      Explicitly disables [^/dev/poll] support on Solaris, forcing the use of
-      a `select`-based implementation.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_EPOLL`]
-    [
-      Explicitly disables `epoll` support on Linux, forcing the use of a
-      `select`-based implementation.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_EVENTFD`]
-    [
-      Explicitly disables `eventfd` support on Linux, forcing the use of a
-      pipe to interrupt blocked epoll/select system calls.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_KQUEUE`]
-    [
-      Explicitly disables `kqueue` support on macOS and BSD variants,
-      forcing the use of a `select`-based implementation.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_IOCP`]
-    [
-      Explicitly disables I/O completion ports support on Windows, forcing the
-      use of a `select`-based implementation.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_THREADS`]
-    [
-      Explicitly disables Asio's threading support, independent of whether or
-      not Boost supports threads.
-    ]
-  ]
-  [
-    [`ASIO_NO_WIN32_LEAN_AND_MEAN`]
-    [
-      By default, Asio will automatically define `WIN32_LEAN_AND_MEAN` when
-      compiling for Windows, to minimise the number of Windows SDK header files
-      and features that are included. The presence of
-      `ASIO_NO_WIN32_LEAN_AND_MEAN` prevents `WIN32_LEAN_AND_MEAN` from
-      being defined.
-    ]
-  ]
-  [
-    [`ASIO_NO_NOMINMAX`]
-    [
-      By default, Asio will automatically define `NOMINMAX` when compiling for
-      Windows, to suppress the definition of the `min()` and `max()` macros.
-      The presence of `ASIO_NO_NOMINMAX` prevents `NOMINMAX` from being
-      defined.
-    ]
-  ]
-  [
-    [`ASIO_NO_DEFAULT_LINKED_LIBS`]
-    [
-      When compiling for Windows using Microsoft Visual C++ or Borland C++, Asio
-      will automatically link in the necessary Windows SDK libraries for sockets
-      support (i.e. [^ws2_32.lib] and [^mswsock.lib], or [^ws2.lib] when
-      building for Windows CE). The `ASIO_NO_DEFAULT_LINKED_LIBS` macro
-      prevents these libraries from being linked.
-    ]
-  ]
-  [
-    [`ASIO_ENABLE_CANCELIO`]
-    [
-      Enables use of the `CancelIo` function on older versions of Windows. If
-      not enabled, calls to `cancel()` on a socket object will always fail with
-      `asio::error::operation_not_supported` when run on Windows XP, Windows
-      Server 2003, and earlier versions of Windows. When running on Windows
-      Vista, Windows Server 2008, and later, the `CancelIoEx` function is
-      always used.
-
-      The `CancelIo` function has two issues that should be considered before
-      enabling its use:
-
-      * It will only cancel asynchronous operations that were initiated in the
-        current thread.
-
-      * It can appear to complete without error, but the request
-        to cancel the unfinished operations may be silently ignored by the
-        operating system. Whether it works or not seems to depend on the
-        drivers that are installed.
-
-      For portable cancellation, consider using one of the following
-      alternatives:
-
-      * Disable asio's I/O completion port backend by defining
-        ASIO_DISABLE_IOCP.
-
-      * Use the socket object's close() function to simultaneously
-        cancel the outstanding operations and close the socket.
-    ]
-  ]
-  [
-    [`ASIO_NO_TYPEID`]
-    [
-      Disables uses of the `typeid` operator in asio. Defined automatically if
-      `BOOST_NO_TYPEID` is defined.
-    ]
-  ]
-  [
-    [`ASIO_HASH_MAP_BUCKETS`]
-    [
-      Determines the number of buckets in asio's internal `hash_map` objects.
-      The value should be a comma separated list of prime numbers, in ascending
-      order. The `hash_map` implementation will automatically increase the
-      number of buckets as the number of elements in the map increases.
-
-      Some examples:
-
-      * Defining `ASIO_HASH_MAP_BUCKETS` to `1021` means that the `hash_map`
-        objects will always contain 1021 buckets, irrespective of the number of
-        elements in the map.
-
-      * Defining `ASIO_HASH_MAP_BUCKETS` to `53,389,1543` means that the
-        `hash_map` objects will initially contain 53 buckets. The number of
-        buckets will be increased to 389 and then 1543 as elements are added to
-        the map.
-    ]
-  ]
-  [
-    [`ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM`]
-    [
-      Changes [link asio.reference.basic_socket_streambuf
-      `basic_socket_streambuf`] and [link asio.reference.basic_socket_iostream
-      `basic_socket_iostream`] to use the old Boost.Date_Time interface, rather
-      than chrono.
-    ]
-  ]
-  [
-    [`ASIO_SEPARATE_COMPILATION`]
-    [
-      Uses separately compiled source code for Asio's implementation.
-
-      See [link asio.using.optional_separate_compilation above] for further
-      information.
-    ]
-  ]
-  [
-    [`ASIO_DYN_LINK`]
-    [
-      Uses separately compiled source code for Asio's implementation,
-      with symbols exported for inclusion as part of a shared library.
-
-      See [link asio.using.optional_separate_compilation above] for further
-      information.
-    ]
-  ]
-  [
-    [`ASIO_DISABLE_VISIBILITY`]
-    [
-      Disables all symbol visibility pragmas.
-
-      Note: If symbols are hidden, extra care must be taken to ensure that Asio
-      types are not passed across shared library API boundaries.
-    ]
-  ]
-]
-
-[include platform_macros.qbk]
-
-[heading Mailing List]
-
-A mailing list specifically for Asio may be found on
-[@http://sourceforge.net/mail/?group_id=122478 SourceForge.net]. Newsgroup
-access is provided via [@http://dir.gmane.org/gmane.comp.lib.boost.asio.user
-Gmane].
-
-[endsect]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/Makefile.am
deleted file mode 100644
index a132a46..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/Makefile.am
+++ /dev/null
@@ -1,308 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-if SEPARATE_COMPILATION
-noinst_LIBRARIES = libasio.a
-libasio_a_SOURCES = ../../asio.cpp
-if HAVE_OPENSSL
-libasio_a_SOURCES += ../../asio_ssl.cpp
-endif
-LDADD = libasio.a
-endif
-
-noinst_PROGRAMS = \
-	allocation/server \
-	buffers/reference_counted \
-	chat/chat_client \
-	chat/chat_server \
-	deferred/deferred_1 \
-	deferred/deferred_2 \
-	echo/async_tcp_echo_server \
-	echo/async_udp_echo_server \
-	echo/blocking_tcp_echo_client \
-	echo/blocking_tcp_echo_server \
-	echo/blocking_udp_echo_client \
-	echo/blocking_udp_echo_server \
-	executors/actor \
-	executors/bank_account_1 \
-	executors/bank_account_2 \
-	executors/fork_join \
-	executors/pipeline \
-	executors/priority_scheduler \
-	files/blocking_file_copy \
-	files/async_file_copy \
-	futures/daytime_client \
-	handler_tracking/async_tcp_echo_server \
-	http/client/async_client \
-	http/client/sync_client \
-	http/server/http_server \
-	http/server2/http_server \
-	http/server3/http_server \
-	http/server4/http_server \
-	icmp/ping \
-	invocation/prioritised_handlers \
-	iostreams/daytime_client \
-	iostreams/daytime_server \
-	iostreams/http_client \
-	multicast/receiver \
-	multicast/sender \
-	nonblocking/third_party_lib \
-	operations/composed_1 \
-	operations/composed_2 \
-	operations/composed_3 \
-	operations/composed_4 \
-	operations/composed_5 \
-	operations/composed_6 \
-	operations/composed_7 \
-	operations/composed_8 \
-  parallel_group/ranged_wait_for_all \
-  parallel_group/wait_for_all \
-  parallel_group/wait_for_one \
-  parallel_group/wait_for_one_error \
-  parallel_group/wait_for_one_success \
-	porthopper/client \
-	porthopper/server \
-	services/daytime_client \
-	socks4/sync_client \
-	timeouts/async_tcp_client \
-	timeouts/blocking_tcp_client \
-	timeouts/blocking_token_tcp_client \
-	timeouts/blocking_udp_client \
-	timeouts/server \
-	timers/time_t_timer \
-	tutorial/timer1/timer \
-	tutorial/timer2/timer \
-	tutorial/timer3/timer \
-	tutorial/timer4/timer \
-	tutorial/timer5/timer \
-	tutorial/daytime1/client \
-	tutorial/daytime2/server \
-	tutorial/daytime3/server \
-	tutorial/daytime4/client \
-	tutorial/daytime5/server \
-	tutorial/daytime6/server \
-	tutorial/daytime7/server \
-	type_erasure/type_erasure
-
-if !WINDOWS_TARGET
-noinst_PROGRAMS += \
-	chat/posix_chat_client \
-	fork/daemon \
-	fork/process_per_connection \
-	local/connect_pair \
-	local/iostream_client \
-	local/stream_server \
-	local/stream_client \
-	local/fd_passing_stream_server \
-	local/fd_passing_stream_client
-endif
-
-if WINDOWS_TARGET
-noinst_PROGRAMS += \
-	windows/transmit_file
-endif
-
-if HAVE_OPENSSL
-noinst_PROGRAMS += \
-	ssl/client \
-	ssl/server
-endif
-
-if HAVE_BOOST_COROUTINE
-noinst_PROGRAMS += \
-  spawn/echo_server \
-  spawn/parallel_grep
-endif
-
-noinst_HEADERS = \
-	chat/chat_message.hpp \
-	handler_tracking/custom_tracking.hpp \
-	http/server/connection.hpp \
-	http/server/connection_manager.hpp \
-	http/server/header.hpp \
-	http/server/mime_types.hpp \
-	http/server/reply.hpp \
-	http/server/request.hpp \
-	http/server/request_handler.hpp \
-	http/server/request_parser.hpp \
-	http/server/server.hpp \
-	http/server2/connection.hpp \
-	http/server2/io_context_pool.hpp \
-	http/server2/header.hpp \
-	http/server2/mime_types.hpp \
-	http/server2/reply.hpp \
-	http/server2/request.hpp \
-	http/server2/request_handler.hpp \
-	http/server2/request_parser.hpp \
-	http/server2/server.hpp \
-	http/server3/connection.hpp \
-	http/server3/header.hpp \
-	http/server3/mime_types.hpp \
-	http/server3/reply.hpp \
-	http/server3/request.hpp \
-	http/server3/request_handler.hpp \
-	http/server3/request_parser.hpp \
-	http/server3/server.hpp \
-	http/server4/file_handler.hpp \
-	http/server4/header.hpp \
-	http/server4/mime_types.hpp \
-	http/server4/reply.hpp \
-	http/server4/request.hpp \
-	http/server4/request_parser.hpp \
-	http/server4/server.hpp \
-	icmp/icmp_header.hpp \
-	icmp/ipv4_header.hpp \
-	porthopper/protocol.hpp \
-	services/basic_logger.hpp \
-	services/logger.hpp \
-	services/logger_service.hpp \
-	socks4/socks4.hpp \
-	type_erasure/line_reader.hpp \
-	type_erasure/stdin_line_reader.hpp \
-	type_erasure/sleep.hpp
-
-AM_CXXFLAGS = -I$(srcdir)/../../../include
-
-allocation_server_SOURCES = allocation/server.cpp
-buffers_reference_counted_SOURCES = buffers/reference_counted.cpp
-chat_chat_client_SOURCES = chat/chat_client.cpp
-chat_chat_server_SOURCES = chat/chat_server.cpp
-deferred_deferred_1_SOURCES = deferred/deferred_1.cpp
-deferred_deferred_2_SOURCES = deferred/deferred_2.cpp
-echo_async_tcp_echo_server_SOURCES = echo/async_tcp_echo_server.cpp
-echo_async_udp_echo_server_SOURCES = echo/async_udp_echo_server.cpp
-echo_blocking_tcp_echo_client_SOURCES = echo/blocking_tcp_echo_client.cpp
-echo_blocking_tcp_echo_server_SOURCES = echo/blocking_tcp_echo_server.cpp
-echo_blocking_udp_echo_client_SOURCES = echo/blocking_udp_echo_client.cpp
-echo_blocking_udp_echo_server_SOURCES = echo/blocking_udp_echo_server.cpp
-executors_actor_SOURCES = executors/actor.cpp
-executors_bank_account_1_SOURCES = executors/bank_account_1.cpp
-executors_bank_account_2_SOURCES = executors/bank_account_2.cpp
-executors_fork_join_SOURCES = executors/fork_join.cpp
-executors_pipeline_SOURCES = executors/pipeline.cpp
-executors_priority_scheduler_SOURCES = executors/priority_scheduler.cpp
-files_blocking_file_copy_SOURCES = files/blocking_file_copy.cpp
-files_async_file_copy_SOURCES = files/async_file_copy.cpp
-futures_daytime_client_SOURCES = futures/daytime_client.cpp
-handler_tracking_async_tcp_echo_server_SOURCES = handler_tracking/async_tcp_echo_server.cpp
-http_client_async_client_SOURCES = http/client/async_client.cpp
-http_client_sync_client_SOURCES = http/client/sync_client.cpp
-http_server_http_server_SOURCES = \
-	http/server/connection.cpp \
-	http/server/connection_manager.cpp \
-	http/server/main.cpp \
-	http/server/mime_types.cpp \
-	http/server/reply.cpp \
-	http/server/request_handler.cpp \
-	http/server/request_parser.cpp \
-	http/server/server.cpp
-http_server2_http_server_SOURCES = \
-	http/server2/connection.cpp \
-	http/server2/io_context_pool.cpp \
-	http/server2/main.cpp \
-	http/server2/mime_types.cpp \
-	http/server2/reply.cpp \
-	http/server2/request_handler.cpp \
-	http/server2/request_parser.cpp \
-	http/server2/server.cpp
-http_server3_http_server_SOURCES = \
-	http/server3/connection.cpp \
-	http/server3/main.cpp \
-	http/server3/mime_types.cpp \
-	http/server3/reply.cpp \
-	http/server3/request_handler.cpp \
-	http/server3/request_parser.cpp \
-	http/server3/server.cpp
-http_server4_http_server_SOURCES = \
-	http/server4/file_handler.cpp \
-	http/server4/main.cpp \
-	http/server4/mime_types.cpp \
-	http/server4/reply.cpp \
-	http/server4/request_parser.cpp \
-	http/server4/server.cpp
-icmp_ping_SOURCES = icmp/ping.cpp
-invocation_prioritised_handlers_SOURCES = invocation/prioritised_handlers.cpp
-iostreams_daytime_client_SOURCES = iostreams/daytime_client.cpp
-iostreams_daytime_server_SOURCES = iostreams/daytime_server.cpp
-iostreams_http_client_SOURCES = iostreams/http_client.cpp
-multicast_receiver_SOURCES = multicast/receiver.cpp
-multicast_sender_SOURCES = multicast/sender.cpp
-nonblocking_third_party_lib_SOURCES = nonblocking/third_party_lib.cpp
-operations_composed_1_SOURCES = operations/composed_1.cpp
-operations_composed_2_SOURCES = operations/composed_2.cpp
-operations_composed_3_SOURCES = operations/composed_3.cpp
-operations_composed_4_SOURCES = operations/composed_4.cpp
-operations_composed_5_SOURCES = operations/composed_5.cpp
-operations_composed_6_SOURCES = operations/composed_6.cpp
-operations_composed_7_SOURCES = operations/composed_7.cpp
-operations_composed_8_SOURCES = operations/composed_8.cpp
-parallel_group_ranged_wait_for_all_SOURCES = parallel_group/ranged_wait_for_all.cpp
-parallel_group_wait_for_all_SOURCES = parallel_group/wait_for_all.cpp
-parallel_group_wait_for_one_SOURCES = parallel_group/wait_for_one.cpp
-parallel_group_wait_for_one_error_SOURCES = parallel_group/wait_for_one_error.cpp
-parallel_group_wait_for_one_success_SOURCES = parallel_group/wait_for_one_success.cpp
-porthopper_client_SOURCES = porthopper/client.cpp
-porthopper_server_SOURCES = porthopper/server.cpp
-services_daytime_client_SOURCES = \
-	services/daytime_client.cpp \
-	services/logger_service.cpp
-socks4_sync_client_SOURCES = socks4/sync_client.cpp
-timeouts_async_tcp_client_SOURCES = timeouts/async_tcp_client.cpp
-timeouts_blocking_tcp_client_SOURCES = timeouts/blocking_tcp_client.cpp
-timeouts_blocking_token_tcp_client_SOURCES = timeouts/blocking_token_tcp_client.cpp
-timeouts_blocking_udp_client_SOURCES = timeouts/blocking_udp_client.cpp
-timeouts_server_SOURCES = timeouts/server.cpp
-timers_time_t_timer_SOURCES = timers/time_t_timer.cpp
-tutorial_timer1_timer_SOURCES = tutorial/timer1/timer.cpp
-tutorial_timer2_timer_SOURCES = tutorial/timer2/timer.cpp
-tutorial_timer3_timer_SOURCES = tutorial/timer3/timer.cpp
-tutorial_timer4_timer_SOURCES = tutorial/timer4/timer.cpp
-tutorial_timer5_timer_SOURCES = tutorial/timer5/timer.cpp
-tutorial_daytime1_client_SOURCES = tutorial/daytime1/client.cpp
-tutorial_daytime2_server_SOURCES = tutorial/daytime2/server.cpp
-tutorial_daytime3_server_SOURCES = tutorial/daytime3/server.cpp
-tutorial_daytime4_client_SOURCES = tutorial/daytime4/client.cpp
-tutorial_daytime5_server_SOURCES = tutorial/daytime5/server.cpp
-tutorial_daytime6_server_SOURCES = tutorial/daytime6/server.cpp
-tutorial_daytime7_server_SOURCES = tutorial/daytime7/server.cpp
-type_erasure_type_erasure_SOURCES = type_erasure/main.cpp type_erasure/stdin_line_reader.cpp type_erasure/sleep.cpp
-
-if !WINDOWS_TARGET
-chat_posix_chat_client_SOURCES = chat/posix_chat_client.cpp
-fork_daemon_SOURCES = fork/daemon.cpp
-fork_process_per_connection_SOURCES = fork/process_per_connection.cpp
-local_connect_pair_SOURCES = local/connect_pair.cpp
-local_iostream_client_SOURCES = local/iostream_client.cpp
-local_stream_server_SOURCES = local/stream_server.cpp
-local_stream_client_SOURCES = local/stream_client.cpp
-local_fd_passing_stream_server_SOURCES = local/fd_passing_stream_server.cpp
-local_fd_passing_stream_client_SOURCES = local/fd_passing_stream_client.cpp
-endif
-
-if WINDOWS_TARGET
-windows_transmit_file_SOURCES = windows/transmit_file.cpp
-endif
-
-if HAVE_OPENSSL
-ssl_client_SOURCES = ssl/client.cpp
-ssl_server_SOURCES = ssl/server.cpp
-endif
-
-if HAVE_BOOST_COROUTINE
-spawn_echo_server_SOURCES = spawn/echo_server.cpp
-spawn_echo_server_LDADD = $(LDADD) -lboost_coroutine -lboost_context -lboost_thread -lboost_chrono -lboost_system
-spawn_parallel_grep_SOURCES = spawn/parallel_grep.cpp
-spawn_parallel_grep_LDADD = $(LDADD) -lboost_coroutine -lboost_context -lboost_thread -lboost_chrono -lboost_system
-endif
-
-EXTRA_DIST = \
-	serialization/client.cpp \
-	serialization/server.cpp \
-	serialization/connection.hpp \
-	serialization/stock.hpp \
-	ssl/README \
-	ssl/ca.pem \
-	ssl/server.pem \
-	ssl/dh4096.pem
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/.gitignore
deleted file mode 100644
index 180ba88..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/server.cpp
deleted file mode 100644
index 48bc119..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/allocation/server.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "asio.hpp"
-
-using asio::ip::tcp;
-
-// Class to manage the memory to be used for handler-based custom allocation.
-// It contains a single block of memory which may be returned for allocation
-// requests. If the memory is in use when an allocation request is made, the
-// allocator delegates allocation to the global heap.
-class handler_memory
-{
-public:
-  handler_memory()
-    : in_use_(false)
-  {
-  }
-
-  handler_memory(const handler_memory&) = delete;
-  handler_memory& operator=(const handler_memory&) = delete;
-
-  void* allocate(std::size_t size)
-  {
-    if (!in_use_ && size < sizeof(storage_))
-    {
-      in_use_ = true;
-      return &storage_;
-    }
-    else
-    {
-      return ::operator new(size);
-    }
-  }
-
-  void deallocate(void* pointer)
-  {
-    if (pointer == &storage_)
-    {
-      in_use_ = false;
-    }
-    else
-    {
-      ::operator delete(pointer);
-    }
-  }
-
-private:
-  // Storage space used for handler-based custom memory allocation.
-  typename std::aligned_storage<1024>::type storage_;
-
-  // Whether the handler-based custom allocation storage has been used.
-  bool in_use_;
-};
-
-// The allocator to be associated with the handler objects. This allocator only
-// needs to satisfy the C++11 minimal allocator requirements.
-template <typename T>
-class handler_allocator
-{
-public:
-  using value_type = T;
-
-  explicit handler_allocator(handler_memory& mem)
-    : memory_(mem)
-  {
-  }
-
-  template <typename U>
-  handler_allocator(const handler_allocator<U>& other) noexcept
-    : memory_(other.memory_)
-  {
-  }
-
-  bool operator==(const handler_allocator& other) const noexcept
-  {
-    return &memory_ == &other.memory_;
-  }
-
-  bool operator!=(const handler_allocator& other) const noexcept
-  {
-    return &memory_ != &other.memory_;
-  }
-
-  T* allocate(std::size_t n) const
-  {
-    return static_cast<T*>(memory_.allocate(sizeof(T) * n));
-  }
-
-  void deallocate(T* p, std::size_t /*n*/) const
-  {
-    return memory_.deallocate(p);
-  }
-
-private:
-  template <typename> friend class handler_allocator;
-
-  // The underlying memory.
-  handler_memory& memory_;
-};
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_),
-        asio::bind_allocator(
-          handler_allocator<int>(handler_memory_),
-          [this, self](std::error_code ec, std::size_t length)
-          {
-            if (!ec)
-            {
-              do_write(length);
-            }
-          }));
-  }
-
-  void do_write(std::size_t length)
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_, asio::buffer(data_, length),
-        asio::bind_allocator(
-          handler_allocator<int>(handler_memory_),
-          [this, self](std::error_code ec, std::size_t /*length*/)
-          {
-            if (!ec)
-            {
-              do_read();
-            }
-          }));
-  }
-
-  // The socket used to communicate with the client.
-  tcp::socket socket_;
-
-  // Buffer used to store data received from the client.
-  std::array<char, 1024> data_;
-
-  // The memory to use for handler-based custom memory allocation.
-  handler_memory handler_memory_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    server s(io_context, std::atoi(argv[1]));
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/.gitignore
deleted file mode 100644
index abe68c6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-reference_counted
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/reference_counted.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/reference_counted.cpp
deleted file mode 100644
index cee56ff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/buffers/reference_counted.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-// reference_counted.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-#include <memory>
-#include <utility>
-#include <vector>
-#include <ctime>
-
-using asio::ip::tcp;
-
-// A reference-counted non-modifiable buffer class.
-class shared_const_buffer
-{
-public:
-  // Construct from a std::string.
-  explicit shared_const_buffer(const std::string& data)
-    : data_(new std::vector<char>(data.begin(), data.end())),
-      buffer_(asio::buffer(*data_))
-  {
-  }
-
-  // Implement the ConstBufferSequence requirements.
-  typedef asio::const_buffer value_type;
-  typedef const asio::const_buffer* const_iterator;
-  const asio::const_buffer* begin() const { return &buffer_; }
-  const asio::const_buffer* end() const { return &buffer_ + 1; }
-
-private:
-  std::shared_ptr<std::vector<char> > data_;
-  asio::const_buffer buffer_;
-};
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    do_write();
-  }
-
-private:
-  void do_write()
-  {
-    std::time_t now = std::time(0);
-    shared_const_buffer buffer(std::ctime(&now));
-
-    auto self(shared_from_this());
-    asio::async_write(socket_, buffer,
-        [self](std::error_code /*ec*/, std::size_t /*length*/)
-        {
-        });
-  }
-
-  // The socket used to communicate with the client.
-  tcp::socket socket_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: reference_counted <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_client.cpp
deleted file mode 100644
index c0393ee..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_client.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-//
-// chat_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <deque>
-#include <iostream>
-#include <thread>
-#include "asio.hpp"
-#include "chat_message.hpp"
-
-using asio::ip::tcp;
-
-typedef std::deque<chat_message> chat_message_queue;
-
-class chat_client
-{
-public:
-  chat_client(asio::io_context& io_context,
-      const tcp::resolver::results_type& endpoints)
-    : io_context_(io_context),
-      socket_(io_context)
-  {
-    do_connect(endpoints);
-  }
-
-  void write(const chat_message& msg)
-  {
-    asio::post(io_context_,
-        [this, msg]()
-        {
-          bool write_in_progress = !write_msgs_.empty();
-          write_msgs_.push_back(msg);
-          if (!write_in_progress)
-          {
-            do_write();
-          }
-        });
-  }
-
-  void close()
-  {
-    asio::post(io_context_, [this]() { socket_.close(); });
-  }
-
-private:
-  void do_connect(const tcp::resolver::results_type& endpoints)
-  {
-    asio::async_connect(socket_, endpoints,
-        [this](std::error_code ec, tcp::endpoint)
-        {
-          if (!ec)
-          {
-            do_read_header();
-          }
-        });
-  }
-
-  void do_read_header()
-  {
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.data(), chat_message::header_length),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && read_msg_.decode_header())
-          {
-            do_read_body();
-          }
-          else
-          {
-            socket_.close();
-          }
-        });
-  }
-
-  void do_read_body()
-  {
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.body(), read_msg_.body_length()),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            std::cout.write(read_msg_.body(), read_msg_.body_length());
-            std::cout << "\n";
-            do_read_header();
-          }
-          else
-          {
-            socket_.close();
-          }
-        });
-  }
-
-  void do_write()
-  {
-    asio::async_write(socket_,
-        asio::buffer(write_msgs_.front().data(),
-          write_msgs_.front().length()),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            write_msgs_.pop_front();
-            if (!write_msgs_.empty())
-            {
-              do_write();
-            }
-          }
-          else
-          {
-            socket_.close();
-          }
-        });
-  }
-
-private:
-  asio::io_context& io_context_;
-  tcp::socket socket_;
-  chat_message read_msg_;
-  chat_message_queue write_msgs_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: chat_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::resolver resolver(io_context);
-    auto endpoints = resolver.resolve(argv[1], argv[2]);
-    chat_client c(io_context, endpoints);
-
-    std::thread t([&io_context](){ io_context.run(); });
-
-    char line[chat_message::max_body_length + 1];
-    while (std::cin.getline(line, chat_message::max_body_length + 1))
-    {
-      chat_message msg;
-      msg.body_length(std::strlen(line));
-      std::memcpy(msg.body(), line, msg.body_length());
-      msg.encode_header();
-      c.write(msg);
-    }
-
-    c.close();
-    t.join();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_message.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_message.hpp
deleted file mode 100644
index 2ae82fa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_message.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// chat_message.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef CHAT_MESSAGE_HPP
-#define CHAT_MESSAGE_HPP
-
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-
-class chat_message
-{
-public:
-  static constexpr std::size_t header_length = 4;
-  static constexpr std::size_t max_body_length = 512;
-
-  chat_message()
-    : body_length_(0)
-  {
-  }
-
-  const char* data() const
-  {
-    return data_;
-  }
-
-  char* data()
-  {
-    return data_;
-  }
-
-  std::size_t length() const
-  {
-    return header_length + body_length_;
-  }
-
-  const char* body() const
-  {
-    return data_ + header_length;
-  }
-
-  char* body()
-  {
-    return data_ + header_length;
-  }
-
-  std::size_t body_length() const
-  {
-    return body_length_;
-  }
-
-  void body_length(std::size_t new_length)
-  {
-    body_length_ = new_length;
-    if (body_length_ > max_body_length)
-      body_length_ = max_body_length;
-  }
-
-  bool decode_header()
-  {
-    char header[header_length + 1] = "";
-    std::strncat(header, data_, header_length);
-    body_length_ = std::atoi(header);
-    if (body_length_ > max_body_length)
-    {
-      body_length_ = 0;
-      return false;
-    }
-    return true;
-  }
-
-  void encode_header()
-  {
-    char header[header_length + 1] = "";
-    std::sprintf(header, "%4d", static_cast<int>(body_length_));
-    std::memcpy(data_, header, header_length);
-  }
-
-private:
-  char data_[header_length + max_body_length];
-  std::size_t body_length_;
-};
-
-#endif // CHAT_MESSAGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_server.cpp
deleted file mode 100644
index 7a5dfe3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/chat_server.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-//
-// chat_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <deque>
-#include <iostream>
-#include <list>
-#include <memory>
-#include <set>
-#include <utility>
-#include "asio.hpp"
-#include "chat_message.hpp"
-
-using asio::ip::tcp;
-
-//----------------------------------------------------------------------
-
-typedef std::deque<chat_message> chat_message_queue;
-
-//----------------------------------------------------------------------
-
-class chat_participant
-{
-public:
-  virtual ~chat_participant() {}
-  virtual void deliver(const chat_message& msg) = 0;
-};
-
-typedef std::shared_ptr<chat_participant> chat_participant_ptr;
-
-//----------------------------------------------------------------------
-
-class chat_room
-{
-public:
-  void join(chat_participant_ptr participant)
-  {
-    participants_.insert(participant);
-    for (auto msg: recent_msgs_)
-      participant->deliver(msg);
-  }
-
-  void leave(chat_participant_ptr participant)
-  {
-    participants_.erase(participant);
-  }
-
-  void deliver(const chat_message& msg)
-  {
-    recent_msgs_.push_back(msg);
-    while (recent_msgs_.size() > max_recent_msgs)
-      recent_msgs_.pop_front();
-
-    for (auto participant: participants_)
-      participant->deliver(msg);
-  }
-
-private:
-  std::set<chat_participant_ptr> participants_;
-  enum { max_recent_msgs = 100 };
-  chat_message_queue recent_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-class chat_session
-  : public chat_participant,
-    public std::enable_shared_from_this<chat_session>
-{
-public:
-  chat_session(tcp::socket socket, chat_room& room)
-    : socket_(std::move(socket)),
-      room_(room)
-  {
-  }
-
-  void start()
-  {
-    room_.join(shared_from_this());
-    do_read_header();
-  }
-
-  void deliver(const chat_message& msg)
-  {
-    bool write_in_progress = !write_msgs_.empty();
-    write_msgs_.push_back(msg);
-    if (!write_in_progress)
-    {
-      do_write();
-    }
-  }
-
-private:
-  void do_read_header()
-  {
-    auto self(shared_from_this());
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.data(), chat_message::header_length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && read_msg_.decode_header())
-          {
-            do_read_body();
-          }
-          else
-          {
-            room_.leave(shared_from_this());
-          }
-        });
-  }
-
-  void do_read_body()
-  {
-    auto self(shared_from_this());
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.body(), read_msg_.body_length()),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            room_.deliver(read_msg_);
-            do_read_header();
-          }
-          else
-          {
-            room_.leave(shared_from_this());
-          }
-        });
-  }
-
-  void do_write()
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_,
-        asio::buffer(write_msgs_.front().data(),
-          write_msgs_.front().length()),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            write_msgs_.pop_front();
-            if (!write_msgs_.empty())
-            {
-              do_write();
-            }
-          }
-          else
-          {
-            room_.leave(shared_from_this());
-          }
-        });
-  }
-
-  tcp::socket socket_;
-  chat_room& room_;
-  chat_message read_msg_;
-  chat_message_queue write_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-class chat_server
-{
-public:
-  chat_server(asio::io_context& io_context,
-      const tcp::endpoint& endpoint)
-    : acceptor_(io_context, endpoint)
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<chat_session>(std::move(socket), room_)->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-  chat_room room_;
-};
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc < 2)
-    {
-      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    std::list<chat_server> servers;
-    for (int i = 1; i < argc; ++i)
-    {
-      tcp::endpoint endpoint(tcp::v4(), std::atoi(argv[i]));
-      servers.emplace_back(io_context, endpoint);
-    }
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/posix_chat_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/posix_chat_client.cpp
deleted file mode 100644
index a77b8cf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/chat/posix_chat_client.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-//
-// posix_chat_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-#include "chat_message.hpp"
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-using asio::ip::tcp;
-namespace posix = asio::posix;
-
-class posix_chat_client
-{
-public:
-  posix_chat_client(asio::io_context& io_context,
-      const tcp::resolver::results_type& endpoints)
-    : socket_(io_context),
-      input_(io_context, ::dup(STDIN_FILENO)),
-      output_(io_context, ::dup(STDOUT_FILENO)),
-      input_buffer_(chat_message::max_body_length)
-  {
-    do_connect(endpoints);
-  }
-
-private:
-  void do_connect(const tcp::resolver::results_type& endpoints)
-  {
-    asio::async_connect(socket_, endpoints,
-        [this](std::error_code ec, tcp::endpoint)
-        {
-          if (!ec)
-          {
-            do_read_header();
-            do_read_input();
-          }
-        });
-  }
-
-  void do_read_header()
-  {
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.data(), chat_message::header_length),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && read_msg_.decode_header())
-          {
-            do_read_body();
-          }
-          else
-          {
-            close();
-          }
-        });
-  }
-
-  void do_read_body()
-  {
-    asio::async_read(socket_,
-        asio::buffer(read_msg_.body(), read_msg_.body_length()),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_write_output();
-          }
-          else
-          {
-            close();
-          }
-        });
-  }
-
-  void do_write_output()
-  {
-    // Write out the message we just received, terminated by a newline.
-    static char eol[] = { '\n' };
-    std::array<asio::const_buffer, 2> buffers = {{
-      asio::buffer(read_msg_.body(), read_msg_.body_length()),
-      asio::buffer(eol) }};
-    asio::async_write(output_, buffers,
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_read_header();
-          }
-          else
-          {
-            close();
-          }
-        });
-  }
-
-  void do_read_input()
-  {
-    // Read a line of input entered by the user.
-    asio::async_read_until(input_, input_buffer_, '\n',
-        [this](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            // Write the message (minus the newline) to the server.
-            write_msg_.body_length(length - 1);
-            input_buffer_.sgetn(write_msg_.body(), length - 1);
-            input_buffer_.consume(1); // Remove newline from input.
-            write_msg_.encode_header();
-            do_write_message();
-          }
-          else if (ec == asio::error::not_found)
-          {
-            // Didn't get a newline. Send whatever we have.
-            write_msg_.body_length(input_buffer_.size());
-            input_buffer_.sgetn(write_msg_.body(), input_buffer_.size());
-            write_msg_.encode_header();
-            do_write_message();
-          }
-          else
-          {
-            close();
-          }
-        });
-  }
-
-  void do_write_message()
-  {
-    asio::async_write(socket_,
-        asio::buffer(write_msg_.data(), write_msg_.length()),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_read_input();
-          }
-          else
-          {
-            close();
-          }
-        });
-  }
-
-  void close()
-  {
-    // Cancel all outstanding asynchronous operations.
-    socket_.close();
-    input_.close();
-    output_.close();
-  }
-
-private:
-  tcp::socket socket_;
-  posix::stream_descriptor input_;
-  posix::stream_descriptor output_;
-  chat_message read_msg_;
-  chat_message write_msg_;
-  asio::streambuf input_buffer_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: posix_chat_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::resolver resolver(io_context);
-    tcp::resolver::results_type endpoints = resolver.resolve(argv[1], argv[2]);
-
-    posix_chat_client c(io_context, endpoints);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/.gitignore
deleted file mode 100644
index 02ac0d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-deferred_[0-9]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_1.cpp
deleted file mode 100644
index db9213e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_1.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// deferred_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  auto deferred_op = timer.async_wait(deferred);
-
-  std::move(deferred_op)(
-      [](std::error_code ec)
-      {
-        std::cout << "timer wait finished: " << ec.message() << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_2.cpp
deleted file mode 100644
index 0752828..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/deferred/deferred_2.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// deferred_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  auto deferred_op = timer.async_wait(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer.expires_after(std::chrono::seconds(1));
-          return timer.async_wait(deferred);
-        }
-      )
-    );
-
-  std::move(deferred_op)(
-      [](std::error_code ec)
-      {
-        std::cout << "second timer wait finished: " << ec.message() << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_tcp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_tcp_echo_server.cpp
deleted file mode 100644
index b8ba533..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_tcp_echo_server.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//
-// async_tcp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <utility>
-#include "asio.hpp"
-
-using asio::ip::tcp;
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_, max_length),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            do_write(length);
-          }
-        });
-  }
-
-  void do_write(std::size_t length)
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_read();
-          }
-        });
-  }
-
-  tcp::socket socket_;
-  enum { max_length = 1024 };
-  char data_[max_length];
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: async_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_udp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_udp_echo_server.cpp
deleted file mode 100644
index 8e5c26f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/async_udp_echo_server.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// async_udp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include "asio.hpp"
-
-using asio::ip::udp;
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : socket_(io_context, udp::endpoint(udp::v4(), port))
-  {
-    do_receive();
-  }
-
-  void do_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(data_, max_length), sender_endpoint_,
-        [this](std::error_code ec, std::size_t bytes_recvd)
-        {
-          if (!ec && bytes_recvd > 0)
-          {
-            do_send(bytes_recvd);
-          }
-          else
-          {
-            do_receive();
-          }
-        });
-  }
-
-  void do_send(std::size_t length)
-  {
-    socket_.async_send_to(
-        asio::buffer(data_, length), sender_endpoint_,
-        [this](std::error_code /*ec*/, std::size_t /*bytes_sent*/)
-        {
-          do_receive();
-        });
-  }
-
-private:
-  udp::socket socket_;
-  udp::endpoint sender_endpoint_;
-  enum { max_length = 1024 };
-  char data_[max_length];
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: async_udp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_client.cpp
deleted file mode 100644
index 8a28120..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_client.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// blocking_tcp_echo_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-using asio::ip::tcp;
-
-enum { max_length = 1024 };
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_tcp_echo_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::socket s(io_context);
-    tcp::resolver resolver(io_context);
-    asio::connect(s, resolver.resolve(argv[1], argv[2]));
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    asio::write(s, asio::buffer(request, request_length));
-
-    char reply[max_length];
-    size_t reply_length = asio::read(s,
-        asio::buffer(reply, request_length));
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_server.cpp
deleted file mode 100644
index 34e5f22..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_tcp_echo_server.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//
-// blocking_tcp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <thread>
-#include <utility>
-#include "asio.hpp"
-
-using asio::ip::tcp;
-
-const int max_length = 1024;
-
-void session(tcp::socket sock)
-{
-  try
-  {
-    for (;;)
-    {
-      char data[max_length];
-
-      std::error_code error;
-      size_t length = sock.read_some(asio::buffer(data), error);
-      if (error == asio::error::eof)
-        break; // Connection closed cleanly by peer.
-      else if (error)
-        throw std::system_error(error); // Some other error.
-
-      asio::write(sock, asio::buffer(data, length));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception in thread: " << e.what() << "\n";
-  }
-}
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  tcp::acceptor a(io_context, tcp::endpoint(tcp::v4(), port));
-  for (;;)
-  {
-    std::thread(session, a.accept()).detach();
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_client.cpp
deleted file mode 100644
index 3f2b60e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_client.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// blocking_udp_echo_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_udp_echo_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    udp::socket s(io_context, udp::endpoint(udp::v4(), 0));
-
-    udp::resolver resolver(io_context);
-    udp::resolver::results_type endpoints =
-      resolver.resolve(udp::v4(), argv[1], argv[2]);
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    s.send_to(asio::buffer(request, request_length), *endpoints.begin());
-
-    char reply[max_length];
-    udp::endpoint sender_endpoint;
-    size_t reply_length = s.receive_from(
-        asio::buffer(reply, max_length), sender_endpoint);
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_server.cpp
deleted file mode 100644
index 64c6def..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/echo/blocking_udp_echo_server.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// blocking_udp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include "asio.hpp"
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  udp::socket sock(io_context, udp::endpoint(udp::v4(), port));
-  for (;;)
-  {
-    char data[max_length];
-    udp::endpoint sender_endpoint;
-    size_t length = sock.receive_from(
-        asio::buffer(data, max_length), sender_endpoint);
-    sock.send_to(asio::buffer(data, length), sender_endpoint);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_udp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/.gitignore
deleted file mode 100644
index 183cecf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-actor
-bank_account_[0-9]
-fork_join
-pipeline
-priority_scheduler
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/actor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/actor.cpp
deleted file mode 100644
index 1f0e2c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/actor.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-#include <asio/any_io_executor.hpp>
-#include <asio/defer.hpp>
-#include <asio/post.hpp>
-#include <asio/strand.hpp>
-#include <asio/system_executor.hpp>
-#include <condition_variable>
-#include <deque>
-#include <memory>
-#include <mutex>
-#include <typeinfo>
-#include <vector>
-
-using asio::any_io_executor;
-using asio::defer;
-using asio::post;
-using asio::strand;
-using asio::system_executor;
-
-//------------------------------------------------------------------------------
-// A tiny actor framework
-// ~~~~~~~~~~~~~~~~~~~~~~
-
-class actor;
-
-// Used to identify the sender and recipient of messages.
-typedef actor* actor_address;
-
-// Base class for all registered message handlers.
-class message_handler_base
-{
-public:
-  virtual ~message_handler_base() {}
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const = 0;
-};
-
-// Base class for a handler for a specific message type.
-template <class Message>
-class message_handler : public message_handler_base
-{
-public:
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from) = 0;
-};
-
-// Concrete message handler for a specific message type.
-template <class Actor, class Message>
-class mf_message_handler : public message_handler<Message>
-{
-public:
-  // Construct a message handler to invoke the specified member function.
-  mf_message_handler(void (Actor::* mf)(Message, actor_address), Actor* a)
-    : function_(mf), actor_(a)
-  {
-  }
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const
-  {
-    return typeid(Message);
-  }
-
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from)
-  {
-    (actor_->*function_)(std::move(msg), from);
-  }
-
-  // Determine whether the message handler represents the specified function.
-  bool is_function(void (Actor::* mf)(Message, actor_address)) const
-  {
-    return mf == function_;
-  }
-
-private:
-  void (Actor::* function_)(Message, actor_address);
-  Actor* actor_;
-};
-
-// Base class for all actors.
-class actor
-{
-public:
-  virtual ~actor()
-  {
-  }
-
-  // Obtain the actor's address for use as a message sender or recipient.
-  actor_address address()
-  {
-    return this;
-  }
-
-  // Send a message from one actor to another.
-  template <class Message>
-  friend void send(Message msg, actor_address from, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    post(to->executor_,
-      [=]
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-protected:
-  // Construct the actor to use the specified executor for all message handlers.
-  actor(any_io_executor e)
-    : executor_(std::move(e))
-  {
-  }
-
-  // Register a handler for a specific message type. Duplicates are permitted.
-  template <class Actor, class Message>
-  void register_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    handlers_.push_back(
-      std::make_shared<mf_message_handler<Actor, Message>>(
-        mf, static_cast<Actor*>(this)));
-  }
-
-  // Deregister a handler. Removes only the first matching handler.
-  template <class Actor, class Message>
-  void deregister_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    const std::type_info& id = typeid(Message);
-    for (auto iter = handlers_.begin(); iter != handlers_.end(); ++iter)
-    {
-      if ((*iter)->message_id() == id)
-      {
-        auto mh = static_cast<mf_message_handler<Actor, Message>*>(iter->get());
-        if (mh->is_function(mf))
-        {
-          handlers_.erase(iter);
-          return;
-        }
-      }
-    }
-  }
-
-  // Send a message from within a message handler.
-  template <class Message>
-  void tail_send(Message msg, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    actor* from = this;
-    defer(to->executor_,
-      [=]
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-private:
-  // Find the matching message handlers, if any, and call them.
-  template <class Message>
-  void call_handler(Message msg, actor_address from)
-  {
-    const std::type_info& message_id = typeid(Message);
-    for (auto& h: handlers_)
-    {
-      if (h->message_id() == message_id)
-      {
-        auto mh = static_cast<message_handler<Message>*>(h.get());
-        mh->handle_message(msg, from);
-      }
-    }
-  }
-
-  // All messages associated with a single actor object should be processed
-  // non-concurrently. We use a strand to ensure non-concurrent execution even
-  // if the underlying executor may use multiple threads.
-  strand<any_io_executor> executor_;
-
-  std::vector<std::shared_ptr<message_handler_base>> handlers_;
-};
-
-// A concrete actor that allows synchronous message retrieval.
-template <class Message>
-class receiver : public actor
-{
-public:
-  receiver()
-    : actor(system_executor())
-  {
-    register_handler(&receiver::message_handler);
-  }
-
-  // Block until a message has been received.
-  Message wait()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    condition_.wait(lock, [this]{ return !message_queue_.empty(); });
-    Message msg(std::move(message_queue_.front()));
-    message_queue_.pop_front();
-    return msg;
-  }
-
-private:
-  // Handle a new message by adding it to the queue and waking a waiter.
-  void message_handler(Message msg, actor_address /* from */)
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    message_queue_.push_back(std::move(msg));
-    condition_.notify_one();
-  }
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::deque<Message> message_queue_;
-};
-
-//------------------------------------------------------------------------------
-
-#include <asio/thread_pool.hpp>
-#include <iostream>
-
-using asio::thread_pool;
-
-class member : public actor
-{
-public:
-  explicit member(any_io_executor e)
-    : actor(std::move(e))
-  {
-    register_handler(&member::init_handler);
-  }
-
-private:
-  void init_handler(actor_address next, actor_address from)
-  {
-    next_ = next;
-    caller_ = from;
-
-    register_handler(&member::token_handler);
-    deregister_handler(&member::init_handler);
-  }
-
-  void token_handler(int token, actor_address /*from*/)
-  {
-    int msg(token);
-    actor_address to(caller_);
-
-    if (token > 0)
-    {
-      msg = token - 1;
-      to = next_;
-    }
-
-    tail_send(msg, to);
-  }
-
-  actor_address next_;
-  actor_address caller_;
-};
-
-int main()
-{
-  const std::size_t num_threads = 16;
-  const int num_hops = 50000000;
-  const std::size_t num_actors = 503;
-  const int token_value = (num_hops + num_actors - 1) / num_actors;
-  const std::size_t actors_per_thread = num_actors / num_threads;
-
-  struct single_thread_pool : thread_pool { single_thread_pool() : thread_pool(1) {} };
-  single_thread_pool pools[num_threads];
-  std::vector<std::shared_ptr<member>> members(num_actors);
-  receiver<int> rcvr;
-
-  // Create the member actors.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    members[i] = std::make_shared<member>(pools[(i / actors_per_thread) % num_threads].get_executor());
-
-  // Initialise the actors by passing each one the address of the next actor in the ring.
-  for (std::size_t i = num_actors, next_i = 0; i > 0; next_i = --i)
-    send(members[next_i]->address(), rcvr.address(), members[i - 1]->address());
-
-  // Send exactly one token to each actor, all with the same initial value, rounding up if required.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    send(token_value, rcvr.address(), members[i]->address());
-
-  // Wait for all signal messages, indicating the tokens have all reached zero.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    rcvr.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_1.cpp
deleted file mode 100644
index a63d7fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_1.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// Traditional active object pattern.
-// Member functions do not block.
-
-class bank_account
-{
-  int balance_ = 0;
-  mutable static_thread_pool pool_{1};
-
-public:
-  void deposit(int amount)
-  {
-    pool_.executor().execute(
-        [this, amount]
-        {
-          balance_ += amount;
-        });
-  }
-
-  void withdraw(int amount)
-  {
-    pool_.executor().execute(
-        [this, amount]
-        {
-          if (balance_ >= amount)
-            balance_ -= amount;
-        });
-  }
-
-  void print_balance() const
-  {
-    pool_.executor().execute(
-        [this]
-        {
-          std::cout << "balance = " << balance_ << "\n";
-        });
-  }
-
-  ~bank_account()
-  {
-    pool_.wait();
-  }
-};
-
-int main()
-{
-  bank_account acct;
-  acct.deposit(20);
-  acct.withdraw(10);
-  acct.print_balance();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_2.cpp
deleted file mode 100644
index 45a24ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/bank_account_2.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// Traditional active object pattern.
-// Member functions block until operation is finished.
-
-class bank_account
-{
-  int balance_ = 0;
-  mutable static_thread_pool pool_{1};
-
-public:
-  void deposit(int amount)
-  {
-    asio::require(pool_.executor(), execution::blocking.always).execute(
-        [this, amount]
-        {
-          balance_ += amount;
-        });
-  }
-
-  void withdraw(int amount)
-  {
-    asio::require(pool_.executor(), execution::blocking.always).execute(
-        [this, amount]
-        {
-          if (balance_ >= amount)
-            balance_ -= amount;
-        });
-  }
-
-  int balance() const
-  {
-    int result = 0;
-    asio::require(pool_.executor(), execution::blocking.always).execute(
-        [this, &result]
-        {
-          result = balance_;
-        });
-    return result;
-  }
-};
-
-int main()
-{
-  bank_account acct;
-  acct.deposit(20);
-  acct.withdraw(10);
-  std::cout << "balance = " << acct.balance() << "\n";
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/fork_join.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/fork_join.cpp
deleted file mode 100644
index 58077ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/fork_join.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <algorithm>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <numeric>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// A fixed-size thread pool used to implement fork/join semantics. Functions
-// are scheduled using a simple FIFO queue. Implementing work stealing, or
-// using a queue based on atomic operations, are left as tasks for the reader.
-class fork_join_pool
-{
-public:
-  // The constructor starts a thread pool with the specified number of threads.
-  // Note that the thread_count is not a fixed limit on the pool's concurrency.
-  // Additional threads may temporarily be added to the pool if they join a
-  // fork_executor.
-  explicit fork_join_pool(
-      std::size_t thread_count = std::max(std::thread::hardware_concurrency(), 1u) * 2)
-    : use_count_(1),
-      threads_(thread_count)
-  {
-    try
-    {
-      // Ask each thread in the pool to dequeue and execute functions until
-      // it is time to shut down, i.e. the use count is zero.
-      for (thread_count_ = 0; thread_count_ < thread_count; ++thread_count_)
-      {
-        threads_.executor().execute(
-            [this]
-            {
-              std::unique_lock<std::mutex> lock(mutex_);
-              while (use_count_ > 0)
-                if (!execute_next(lock))
-                  condition_.wait(lock);
-            });
-      }
-    }
-    catch (...)
-    {
-      stop_threads();
-      threads_.wait();
-      throw;
-    }
-  }
-
-  // The destructor waits for the pool to finish executing functions.
-  ~fork_join_pool()
-  {
-    stop_threads();
-    threads_.wait();
-  }
-
-private:
-  friend class fork_executor;
-
-  // The base for all functions that are queued in the pool.
-  struct function_base
-  {
-    std::shared_ptr<std::size_t> work_count_;
-    void (*execute_)(std::shared_ptr<function_base>& p);
-  };
-
-  // Execute the next function from the queue, if any. Returns true if a
-  // function was executed, and false if the queue was empty.
-  bool execute_next(std::unique_lock<std::mutex>& lock)
-  {
-    if (queue_.empty())
-      return false;
-    auto p(queue_.front());
-    queue_.pop();
-    lock.unlock();
-    execute(lock, p);
-    return true;
-  }
-
-  // Execute a function and decrement the outstanding work.
-  void execute(std::unique_lock<std::mutex>& lock,
-      std::shared_ptr<function_base>& p)
-  {
-    std::shared_ptr<std::size_t> work_count(std::move(p->work_count_));
-    try
-    {
-      p->execute_(p);
-      lock.lock();
-      do_work_finished(work_count);
-    }
-    catch (...)
-    {
-      lock.lock();
-      do_work_finished(work_count);
-      throw;
-    }
-  }
-
-  // Increment outstanding work.
-  void do_work_started(const std::shared_ptr<std::size_t>& work_count) noexcept
-  {
-    if (++(*work_count) == 1)
-      ++use_count_;
-  }
-
-  // Decrement outstanding work. Notify waiting threads if we run out.
-  void do_work_finished(const std::shared_ptr<std::size_t>& work_count) noexcept
-  {
-    if (--(*work_count) == 0)
-    {
-      --use_count_;
-      condition_.notify_all();
-    }
-  }
-
-  // Dispatch a function, executing it immediately if the queue is already
-  // loaded. Otherwise adds the function to the queue and wakes a thread.
-  void do_execute(std::shared_ptr<function_base> p,
-      const std::shared_ptr<std::size_t>& work_count)
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    if (queue_.size() > thread_count_ * 16)
-    {
-      do_work_started(work_count);
-      lock.unlock();
-      execute(lock, p);
-    }
-    else
-    {
-      queue_.push(p);
-      do_work_started(work_count);
-      condition_.notify_one();
-    }
-  }
-
-  // Ask all threads to shut down.
-  void stop_threads()
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    --use_count_;
-    condition_.notify_all();
-  }
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::queue<std::shared_ptr<function_base>> queue_;
-  std::size_t use_count_;
-  std::size_t thread_count_;
-  static_thread_pool threads_;
-};
-
-// A class that satisfies the Executor requirements. Every function or piece of
-// work associated with a fork_executor is part of a single, joinable group.
-class fork_executor
-{
-public:
-  fork_executor(fork_join_pool& ctx)
-    : context_(ctx),
-      work_count_(std::make_shared<std::size_t>(0))
-  {
-  }
-
-  fork_join_pool& query(execution::context_t) const noexcept
-  {
-    return context_;
-  }
-
-  template <class Func>
-  void execute(Func f) const
-  {
-    auto p(std::make_shared<function<Func>>(std::move(f), work_count_));
-    context_.do_execute(p, work_count_);
-  }
-
-  friend bool operator==(const fork_executor& a,
-      const fork_executor& b) noexcept
-  {
-    return a.work_count_ == b.work_count_;
-  }
-
-  friend bool operator!=(const fork_executor& a,
-      const fork_executor& b) noexcept
-  {
-    return a.work_count_ != b.work_count_;
-  }
-
-  // Block until all work associated with the executor is complete. While it is
-  // waiting, the thread may be borrowed to execute functions from the queue.
-  void join() const
-  {
-    std::unique_lock<std::mutex> lock(context_.mutex_);
-    while (*work_count_ > 0)
-      if (!context_.execute_next(lock))
-        context_.condition_.wait(lock);
-  }
-
-private:
-  template <class Func>
-  struct function : fork_join_pool::function_base
-  {
-    explicit function(Func f, const std::shared_ptr<std::size_t>& w)
-      : function_(std::move(f))
-    {
-      work_count_ = w;
-      execute_ = [](std::shared_ptr<fork_join_pool::function_base>& p)
-      {
-        Func tmp(std::move(static_cast<function*>(p.get())->function_));
-        p.reset();
-        tmp();
-      };
-    }
-
-    Func function_;
-  };
-
-  fork_join_pool& context_;
-  std::shared_ptr<std::size_t> work_count_;
-};
-
-// Helper class to automatically join a fork_executor when exiting a scope.
-class join_guard
-{
-public:
-  explicit join_guard(const fork_executor& ex) : ex_(ex) {}
-  join_guard(const join_guard&) = delete;
-  join_guard(join_guard&&) = delete;
-  ~join_guard() { ex_.join(); }
-
-private:
-  fork_executor ex_;
-};
-
-//------------------------------------------------------------------------------
-
-#include <algorithm>
-#include <iostream>
-#include <random>
-#include <vector>
-
-fork_join_pool pool;
-
-template <class Iterator>
-void fork_join_sort(Iterator begin, Iterator end)
-{
-  std::size_t n = end - begin;
-  if (n > 32768)
-  {
-    {
-      fork_executor fork(pool);
-      join_guard join(fork);
-      fork.execute([=]{ fork_join_sort(begin, begin + n / 2); });
-      fork.execute([=]{ fork_join_sort(begin + n / 2, end); });
-    }
-    std::inplace_merge(begin, begin + n / 2, end);
-  }
-  else
-  {
-    std::sort(begin, end);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  if (argc != 2)
-  {
-    std::cerr << "Usage: fork_join <size>\n";
-    return 1;
-  }
-
-  std::vector<double> vec(std::atoll(argv[1]));
-  std::iota(vec.begin(), vec.end(), 0);
-
-  std::random_device rd;
-  std::mt19937 g(rd());
-  std::shuffle(vec.begin(), vec.end(), g);
-
-  std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-
-  fork_join_sort(vec.begin(), vec.end());
-
-  std::chrono::steady_clock::duration elapsed = std::chrono::steady_clock::now() - start;
-
-  std::cout << "sort took ";
-  std::cout << std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
-  std::cout << " microseconds" << std::endl;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/pipeline.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/pipeline.cpp
deleted file mode 100644
index f441e32..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/pipeline.cpp
+++ /dev/null
@@ -1,288 +0,0 @@
-#include <asio/associated_executor.hpp>
-#include <asio/bind_executor.hpp>
-#include <asio/execution_context.hpp>
-#include <asio/post.hpp>
-#include <asio/system_executor.hpp>
-#include <asio/use_future.hpp>
-#include <condition_variable>
-#include <future>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
-#include <cctype>
-
-using asio::execution_context;
-using asio::executor_binder;
-using asio::get_associated_executor;
-using asio::post;
-using asio::system_executor;
-using asio::use_future;
-using asio::use_service;
-namespace execution = asio::execution;
-
-// An executor that launches a new thread for each function submitted to it.
-// This class satisfies the executor requirements.
-class thread_executor
-{
-private:
-  // Service to track all threads started through a thread_executor.
-  class thread_bag : public execution_context::service
-  {
-  public:
-    typedef thread_bag key_type;
-
-    explicit thread_bag(execution_context& ctx)
-      : execution_context::service(ctx)
-    {
-    }
-
-    void add_thread(std::thread&& t)
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      threads_.push_back(std::move(t));
-    }
-
-  private:
-    virtual void shutdown()
-    {
-      for (auto& t : threads_)
-        t.join();
-    }
-
-    std::mutex mutex_;
-    std::vector<std::thread> threads_;
-  };
-
-public:
-  execution_context& query(execution::context_t) const
-  {
-    return asio::query(system_executor(), execution::context);
-  }
-
-  execution::blocking_t query(execution::blocking_t) const
-  {
-    return execution::blocking.never;
-  }
-
-  thread_executor require(execution::blocking_t::never_t) const
-  {
-    return *this;
-  }
-
-  template <class Func>
-  void execute(Func f) const
-  {
-    thread_bag& bag = use_service<thread_bag>(query(execution::context));
-    bag.add_thread(std::thread(std::move(f)));
-  }
-
-  friend bool operator==(const thread_executor&,
-      const thread_executor&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const thread_executor&,
-      const thread_executor&) noexcept
-  {
-    return false;
-  }
-};
-
-// Base class for all thread-safe queue implementations.
-class queue_impl_base
-{
-  template <class> friend class queue_front;
-  template <class> friend class queue_back;
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  bool stop_ = false;
-};
-
-// Underlying implementation of a thread-safe queue, shared between the
-// queue_front and queue_back classes.
-template <class T>
-class queue_impl : public queue_impl_base
-{
-  template <class> friend class queue_front;
-  template <class> friend class queue_back;
-  std::queue<T> queue_;
-};
-
-// The front end of a queue between consecutive pipeline stages.
-template <class T>
-class queue_front
-{
-public:
-  typedef T value_type;
-
-  explicit queue_front(std::shared_ptr<queue_impl<T>> impl)
-    : impl_(impl)
-  {
-  }
-
-  void push(T t)
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    impl_->queue_.push(std::move(t));
-    impl_->condition_.notify_one();
-  }
-
-  void stop()
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    impl_->stop_ = true;
-    impl_->condition_.notify_one();
-  }
-
-private:
-  std::shared_ptr<queue_impl<T>> impl_;
-};
-
-// The back end of a queue between consecutive pipeline stages.
-template <class T>
-class queue_back
-{
-public:
-  typedef T value_type;
-
-  explicit queue_back(std::shared_ptr<queue_impl<T>> impl)
-    : impl_(impl)
-  {
-  }
-
-  bool pop(T& t)
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    while (impl_->queue_.empty() && !impl_->stop_)
-      impl_->condition_.wait(lock);
-    if (!impl_->queue_.empty())
-    {
-      t = impl_->queue_.front();
-      impl_->queue_.pop();
-      return true;
-    }
-    return false;
-  }
-
-private:
-  std::shared_ptr<queue_impl<T>> impl_;
-};
-
-// Launch the last stage in a pipeline.
-template <class T, class F>
-std::future<void> pipeline(queue_back<T> in, F f)
-{
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function, and as we're the last stage return a future so that the
-  // caller can wait for the pipeline to finish.
-  return post(ex, use_future([in, f]() mutable { f(in); }));
-}
-
-// Launch an intermediate stage in a pipeline.
-template <class T, class F, class... Tail>
-std::future<void> pipeline(queue_back<T> in, F f, Tail... t)
-{
-  // Determine the output queue type.
-  typedef typename executor_binder<F, thread_executor>::second_argument_type::value_type output_value_type;
-
-  // Create the output queue and its implementation.
-  auto out_impl = std::make_shared<queue_impl<output_value_type>>();
-  queue_front<output_value_type> out(out_impl);
-  queue_back<output_value_type> next_in(out_impl);
-
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function.
-  post(ex, [in, out, f]() mutable
-      {
-        f(in, out);
-        out.stop();
-      });
-
-  // Launch the rest of the pipeline.
-  return pipeline(next_in, std::move(t)...);
-}
-
-// Launch the first stage in a pipeline.
-template <class F, class... Tail>
-std::future<void> pipeline(F f, Tail... t)
-{
-  // Determine the output queue type.
-  typedef typename executor_binder<F, thread_executor>::argument_type::value_type output_value_type;
-
-  // Create the output queue and its implementation.
-  auto out_impl = std::make_shared<queue_impl<output_value_type>>();
-  queue_front<output_value_type> out(out_impl);
-  queue_back<output_value_type> next_in(out_impl);
-
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function.
-  post(ex, [out, f]() mutable
-      {
-        f(out);
-        out.stop();
-      });
-
-  // Launch the rest of the pipeline.
-  return pipeline(next_in, std::move(t)...);
-}
-
-//------------------------------------------------------------------------------
-
-#include <asio/thread_pool.hpp>
-#include <iostream>
-#include <string>
-
-using asio::bind_executor;
-using asio::thread_pool;
-
-void reader(queue_front<std::string> out)
-{
-  std::string line;
-  while (std::getline(std::cin, line))
-    out.push(line);
-}
-
-void filter(queue_back<std::string> in, queue_front<std::string> out)
-{
-  std::string line;
-  while (in.pop(line))
-    if (line.length() > 5)
-      out.push(line);
-}
-
-void upper(queue_back<std::string> in, queue_front<std::string> out)
-{
-  std::string line;
-  while (in.pop(line))
-  {
-    std::string new_line;
-    for (char c : line)
-      new_line.push_back(std::toupper(c));
-    out.push(new_line);
-  }
-}
-
-void writer(queue_back<std::string> in)
-{
-  std::size_t count = 0;
-  std::string line;
-  while (in.pop(line))
-    std::cout << count++ << ": " << line << std::endl;
-}
-
-int main()
-{
-  thread_pool pool(1);
-
-  auto f = pipeline(reader, filter, bind_executor(pool, upper), writer);
-  f.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/priority_scheduler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/priority_scheduler.cpp
deleted file mode 100644
index d8ef79f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/executors/priority_scheduler.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include <asio/dispatch.hpp>
-#include <asio/execution_context.hpp>
-#include <condition_variable>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <queue>
-
-using asio::dispatch;
-using asio::execution_context;
-namespace execution = asio::execution;
-
-class priority_scheduler : public execution_context
-{
-public:
-  // A class that satisfies the Executor requirements.
-  class executor_type
-  {
-  public:
-    executor_type(priority_scheduler& ctx, int pri) noexcept
-      : context_(ctx), priority_(pri)
-    {
-    }
-
-    priority_scheduler& query(execution::context_t) const noexcept
-    {
-      return context_;
-    }
-
-    template <class Func>
-    void execute(Func f) const
-    {
-      auto p(std::make_shared<item<Func>>(priority_, std::move(f)));
-      std::lock_guard<std::mutex> lock(context_.mutex_);
-      context_.queue_.push(p);
-      context_.condition_.notify_one();
-    }
-
-    friend bool operator==(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ == &b.context_;
-    }
-
-    friend bool operator!=(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ != &b.context_;
-    }
-
-  private:
-    priority_scheduler& context_;
-    int priority_;
-  };
-
-  ~priority_scheduler() noexcept
-  {
-    shutdown();
-    destroy();
-  }
-
-  executor_type get_executor(int pri = 0) noexcept
-  {
-    return executor_type(*const_cast<priority_scheduler*>(this), pri);
-  }
-
-  void run()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    for (;;)
-    {
-      condition_.wait(lock, [&]{ return stopped_ || !queue_.empty(); });
-      if (stopped_)
-        return;
-      auto p(queue_.top());
-      queue_.pop();
-      lock.unlock();
-      p->execute_(p);
-      lock.lock();
-    }
-  }
-
-  void stop()
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    stopped_ = true;
-    condition_.notify_all();
-  }
-
-private:
-  struct item_base
-  {
-    int priority_;
-    void (*execute_)(std::shared_ptr<item_base>&);
-  };
-
-  template <class Func>
-  struct item : item_base
-  {
-    item(int pri, Func f) : function_(std::move(f))
-    {
-      priority_ = pri;
-      execute_ = [](std::shared_ptr<item_base>& p)
-      {
-        Func tmp(std::move(static_cast<item*>(p.get())->function_));
-        p.reset();
-        tmp();
-      };
-    }
-
-    Func function_;
-  };
-
-  struct item_comp
-  {
-    bool operator()(
-        const std::shared_ptr<item_base>& a,
-        const std::shared_ptr<item_base>& b)
-    {
-      return a->priority_ < b->priority_;
-    }
-  };
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::priority_queue<
-    std::shared_ptr<item_base>,
-    std::vector<std::shared_ptr<item_base>>,
-    item_comp> queue_;
-  bool stopped_ = false;
-};
-
-int main()
-{
-  priority_scheduler sched;
-  auto low = sched.get_executor(0);
-  auto med = sched.get_executor(1);
-  auto high = sched.get_executor(2);
-  dispatch(low, []{ std::cout << "1\n"; });
-  dispatch(low, []{ std::cout << "11\n"; });
-  dispatch(med, []{ std::cout << "2\n"; });
-  dispatch(med, []{ std::cout << "22\n"; });
-  dispatch(high, []{ std::cout << "3\n"; });
-  dispatch(high, []{ std::cout << "33\n"; });
-  dispatch(high, []{ std::cout << "333\n"; });
-  dispatch(sched.get_executor(-1), [&]{ sched.stop(); });
-  sched.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/.gitignore
deleted file mode 100644
index faaf32f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-async_file_copy
-blocking_file_copy
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/async_file_copy.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/async_file_copy.cpp
deleted file mode 100644
index edfb276..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/async_file_copy.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// async_file_copy.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_FILE)
-
-class file_copier
-{
-public:
-  file_copier(asio::io_context& io_context,
-      const char* from, const char* to)
-    : from_file_(io_context, from,
-        asio::stream_file::read_only),
-      to_file_(io_context, to,
-        asio::stream_file::write_only
-          | asio::stream_file::create
-          | asio::stream_file::truncate)
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    from_file_.async_read_some(asio::buffer(data_),
-        [this](std::error_code error, std::size_t n)
-        {
-          if (!error)
-          {
-            do_write(n);
-          }
-          else if (error != asio::error::eof)
-          {
-            std::cerr << "Error copying file: " << error.message() << "\n";
-          }
-        });
-  }
-
-  void do_write(std::size_t n)
-  {
-    asio::async_write(to_file_, asio::buffer(data_, n),
-        [this](std::error_code error, std::size_t /*n*/)
-        {
-          if (!error)
-          {
-            do_read();
-          }
-          else
-          {
-            std::cerr << "Error copying file: " << error.message() << "\n";
-          }
-        });
-  }
-
-  asio::stream_file from_file_;
-  asio::stream_file to_file_;
-  char data_[4096];
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: async_file_copy <from> <to>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    file_copier copier(io_context, argv[1], argv[2]);
-    copier.start();
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-    return 1;
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_FILE)
-int main() {}
-#endif // defined(ASIO_HAS_FILE)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/blocking_file_copy.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/blocking_file_copy.cpp
deleted file mode 100644
index 6e111b4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/files/blocking_file_copy.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//
-// blocking_file_copy.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_FILE)
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_file_copy <from> <to>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    asio::stream_file from_file(io_context, argv[1],
-        asio::stream_file::read_only);
-
-    asio::stream_file to_file(io_context, argv[2],
-        asio::stream_file::write_only
-          | asio::stream_file::create
-          | asio::stream_file::truncate);
-
-    char data[4096];
-    std::error_code error;
-    for (;;)
-    {
-      std::size_t n = from_file.read_some(asio::buffer(data), error);
-      if (error)
-        break;
-      asio::write(to_file, asio::buffer(data, n), error);
-      if (error)
-        break;
-    }
-
-    if (error && error != asio::error::eof)
-    {
-      std::cerr << "Error copying file: " << error.message() << "\n";
-      return 1;
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-    return 1;
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_FILE)
-int main() {}
-#endif // defined(ASIO_HAS_FILE)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/.gitignore
deleted file mode 100644
index 6b565fe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-daemon
-process_per_connection
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/daemon.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/daemon.cpp
deleted file mode 100644
index 547acb3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/daemon.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-//
-// daemon.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <asio/signal_set.hpp>
-#include <array>
-#include <ctime>
-#include <iostream>
-#include <syslog.h>
-#include <unistd.h>
-
-using asio::ip::udp;
-
-class udp_daytime_server
-{
-public:
-  udp_daytime_server(asio::io_context& io_context)
-    : socket_(io_context, {udp::v4(), 13})
-  {
-    receive();
-  }
-
-private:
-  void receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(recv_buffer_), remote_endpoint_,
-        [this](std::error_code ec, std::size_t /*n*/)
-        {
-          if (!ec)
-          {
-            using namespace std; // For time_t, time and ctime;
-            time_t now = time(0);
-            std::string message = ctime(&now);
-
-            std::error_code ignored_ec;
-            socket_.send_to(asio::buffer(message),
-                remote_endpoint_, 0, ignored_ec);
-          }
-
-          receive();
-        });
-  }
-
-  udp::socket socket_;
-  udp::endpoint remote_endpoint_;
-  std::array<char, 1> recv_buffer_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    // Initialise the server before becoming a daemon. If the process is
-    // started from a shell, this means any errors will be reported back to the
-    // user.
-    udp_daytime_server server(io_context);
-
-    // Register signal handlers so that the daemon may be shut down. You may
-    // also want to register for other signals, such as SIGHUP to trigger a
-    // re-read of a configuration file.
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait(
-        [&](std::error_code /*ec*/, int /*signo*/)
-        {
-          io_context.stop();
-        });
-
-    // Inform the io_context that we are about to become a daemon. The
-    // io_context cleans up any internal resources, such as threads, that may
-    // interfere with forking.
-    io_context.notify_fork(asio::io_context::fork_prepare);
-
-    // Fork the process and have the parent exit. If the process was started
-    // from a shell, this returns control to the user. Forking a new process is
-    // also a prerequisite for the subsequent call to setsid().
-    if (pid_t pid = fork())
-    {
-      if (pid > 0)
-      {
-        // We're in the parent process and need to exit.
-        //
-        // When the exit() function is used, the program terminates without
-        // invoking local variables' destructors. Only global variables are
-        // destroyed. As the io_context object is a local variable, this means
-        // we do not have to call:
-        //
-        //   io_context.notify_fork(asio::io_context::fork_parent);
-        //
-        // However, this line should be added before each call to exit() if
-        // using a global io_context object. An additional call:
-        //
-        //   io_context.notify_fork(asio::io_context::fork_prepare);
-        //
-        // should also precede the second fork().
-        exit(0);
-      }
-      else
-      {
-        syslog(LOG_ERR | LOG_USER, "First fork failed: %m");
-        return 1;
-      }
-    }
-
-    // Make the process a new session leader. This detaches it from the
-    // terminal.
-    setsid();
-
-    // A process inherits its working directory from its parent. This could be
-    // on a mounted filesystem, which means that the running daemon would
-    // prevent this filesystem from being unmounted. Changing to the root
-    // directory avoids this problem.
-    chdir("/");
-
-    // The file mode creation mask is also inherited from the parent process.
-    // We don't want to restrict the permissions on files created by the
-    // daemon, so the mask is cleared.
-    umask(0);
-
-    // A second fork ensures the process cannot acquire a controlling terminal.
-    if (pid_t pid = fork())
-    {
-      if (pid > 0)
-      {
-        exit(0);
-      }
-      else
-      {
-        syslog(LOG_ERR | LOG_USER, "Second fork failed: %m");
-        return 1;
-      }
-    }
-
-    // Close the standard streams. This decouples the daemon from the terminal
-    // that started it.
-    close(0);
-    close(1);
-    close(2);
-
-    // We don't want the daemon to have any standard input.
-    if (open("/dev/null", O_RDONLY) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to open /dev/null: %m");
-      return 1;
-    }
-
-    // Send standard output to a log file.
-    const char* output = "/tmp/asio.daemon.out";
-    const int flags = O_WRONLY | O_CREAT | O_APPEND;
-    const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
-    if (open(output, flags, mode) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to open output file %s: %m", output);
-      return 1;
-    }
-
-    // Also send standard error to the same log file.
-    if (dup(1) < 0)
-    {
-      syslog(LOG_ERR | LOG_USER, "Unable to dup output descriptor: %m");
-      return 1;
-    }
-
-    // Inform the io_context that we have finished becoming a daemon. The
-    // io_context uses this opportunity to create any internal file descriptors
-    // that need to be private to the new process.
-    io_context.notify_fork(asio::io_context::fork_child);
-
-    // The io_context can now be used normally.
-    syslog(LOG_INFO | LOG_USER, "Daemon started");
-    io_context.run();
-    syslog(LOG_INFO | LOG_USER, "Daemon stopped");
-  }
-  catch (std::exception& e)
-  {
-    syslog(LOG_ERR | LOG_USER, "Exception: %s", e.what());
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/process_per_connection.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/process_per_connection.cpp
deleted file mode 100644
index cad52e7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/fork/process_per_connection.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//
-// process_per_connection.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdlib>
-#include <iostream>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-using asio::ip::tcp;
-
-class server
-{
-public:
-  server(asio::io_context& io_context, unsigned short port)
-    : io_context_(io_context),
-      signal_(io_context, SIGCHLD),
-      acceptor_(io_context, {tcp::v4(), port}),
-      socket_(io_context)
-  {
-    wait_for_signal();
-    accept();
-  }
-
-private:
-  void wait_for_signal()
-  {
-    signal_.async_wait(
-        [this](std::error_code /*ec*/, int /*signo*/)
-        {
-          // Only the parent process should check for this signal. We can
-          // determine whether we are in the parent by checking if the acceptor
-          // is still open.
-          if (acceptor_.is_open())
-          {
-            // Reap completed child processes so that we don't end up with
-            // zombies.
-            int status = 0;
-            while (waitpid(-1, &status, WNOHANG) > 0) {}
-
-            wait_for_signal();
-          }
-        });
-  }
-
-  void accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket new_socket)
-        {
-          if (!ec)
-          {
-            // Take ownership of the newly accepted socket.
-            socket_ = std::move(new_socket);
-
-            // Inform the io_context that we are about to fork. The io_context
-            // cleans up any internal resources, such as threads, that may
-            // interfere with forking.
-            io_context_.notify_fork(asio::io_context::fork_prepare);
-
-            if (fork() == 0)
-            {
-              // Inform the io_context that the fork is finished and that this
-              // is the child process. The io_context uses this opportunity to
-              // create any internal file descriptors that must be private to
-              // the new process.
-              io_context_.notify_fork(asio::io_context::fork_child);
-
-              // The child won't be accepting new connections, so we can close
-              // the acceptor. It remains open in the parent.
-              acceptor_.close();
-
-              // The child process is not interested in processing the SIGCHLD
-              // signal.
-              signal_.cancel();
-
-              read();
-            }
-            else
-            {
-
-              // Inform the io_context that the fork is finished (or failed)
-              // and that this is the parent process. The io_context uses this
-              // opportunity to recreate any internal resources that were
-              // cleaned up during preparation for the fork.
-              io_context_.notify_fork(asio::io_context::fork_parent);
-
-              // The parent process can now close the newly accepted socket. It
-              // remains open in the child.
-              socket_.close();
-
-              accept();
-            }
-          }
-          else
-          {
-            std::cerr << "Accept error: " << ec.message() << std::endl;
-            accept();
-          }
-        });
-  }
-
-  void read()
-  {
-    socket_.async_read_some(asio::buffer(data_),
-        [this](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-            write(length);
-        });
-  }
-
-  void write(std::size_t length)
-  {
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-            read();
-        });
-  }
-
-  asio::io_context& io_context_;
-  asio::signal_set signal_;
-  tcp::acceptor acceptor_;
-  tcp::socket socket_;
-  std::array<char, 1024> data_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: process_per_connection <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    using namespace std; // For atoi.
-    server s(io_context, atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/daytime_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/daytime_client.cpp
deleted file mode 100644
index 2f5314e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/futures/daytime_client.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// daytime_client.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <future>
-#include <iostream>
-#include <thread>
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <asio/use_future.hpp>
-
-using asio::ip::udp;
-
-void get_daytime(asio::io_context& io_context, const char* hostname)
-{
-  try
-  {
-    udp::resolver resolver(io_context);
-
-    std::future<udp::resolver::results_type> endpoints =
-      resolver.async_resolve(
-          udp::v4(), hostname, "daytime",
-          asio::use_future);
-
-    // The async_resolve operation above returns the endpoints as a future
-    // value that is not retrieved ...
-
-    udp::socket socket(io_context, udp::v4());
-
-    std::array<char, 1> send_buf  = {{ 0 }};
-    std::future<std::size_t> send_length =
-      socket.async_send_to(asio::buffer(send_buf),
-          *endpoints.get().begin(), // ... until here. This call may block.
-          asio::use_future);
-
-    // Do other things here while the send completes.
-
-    send_length.get(); // Blocks until the send is complete. Throws any errors.
-
-    std::array<char, 128> recv_buf;
-    udp::endpoint sender_endpoint;
-    std::future<std::size_t> recv_length =
-      socket.async_receive_from(
-          asio::buffer(recv_buf),
-          sender_endpoint,
-          asio::use_future);
-
-    // Do other things here while the receive completes.
-
-    std::cout.write(
-        recv_buf.data(),
-        recv_length.get()); // Blocks until receive is complete.
-  }
-  catch (std::system_error& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: daytime_client <host>" << std::endl;
-      return 1;
-    }
-
-    // We run the io_context off in its own thread so that it operates
-    // completely asynchronously with respect to the rest of the program.
-    asio::io_context io_context;
-    auto work = asio::make_work_guard(io_context);
-    std::thread thread([&io_context](){ io_context.run(); });
-
-    get_daytime(io_context, argv[1]);
-
-    io_context.stop();
-    thread.join();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/.gitignore
deleted file mode 100644
index 8a4272c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-async_tcp_echo_server
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/async_tcp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/async_tcp_echo_server.cpp
deleted file mode 100644
index 42a31f7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/async_tcp_echo_server.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//
-// async_tcp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <utility>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-// Define a helper macro to invoke ASIO_HANDLER_LOCATION with the current
-// file name, line number, and function name. For the function name, you might
-// also consider using __PRETTY_FUNCTION__, BOOST_CURRENT_FUNCTION, or a hand-
-// crafted name. For C++20 or later, you may also use std::source_location.
-#define HANDLER_LOCATION \
-  ASIO_HANDLER_LOCATION((__FILE__, __LINE__, __func__))
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    HANDLER_LOCATION;
-
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    HANDLER_LOCATION;
-
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_, max_length),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          HANDLER_LOCATION;
-
-          if (!ec)
-          {
-            do_write(length);
-          }
-        });
-  }
-
-  void do_write(std::size_t length)
-  {
-    HANDLER_LOCATION;
-
-    auto self(shared_from_this());
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          HANDLER_LOCATION;
-
-          if (!ec)
-          {
-            do_read();
-          }
-        });
-  }
-
-  tcp::socket socket_;
-  enum { max_length = 1024 };
-  char data_[max_length];
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    HANDLER_LOCATION;
-
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          HANDLER_LOCATION;
-
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: async_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/custom_tracking.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/custom_tracking.hpp
deleted file mode 100644
index 57b162a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/handler_tracking/custom_tracking.hpp
+++ /dev/null
@@ -1,211 +0,0 @@
-//
-// custom_tracking.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef CUSTOM_TRACKING_HPP
-#define CUSTOM_TRACKING_HPP
-
-#include <cinttypes>
-#include <cstdint>
-#include <cstdio>
-
-# define ASIO_INHERIT_TRACKED_HANDLER \
-  : public ::custom_tracking::tracked_handler
-
-# define ASIO_ALSO_INHERIT_TRACKED_HANDLER \
-  , public ::custom_tracking::tracked_handler
-
-# define ASIO_HANDLER_TRACKING_INIT \
-  ::custom_tracking::init()
-
-# define ASIO_HANDLER_LOCATION(args) \
-  ::custom_tracking::location args
-
-# define ASIO_HANDLER_CREATION(args) \
-  ::custom_tracking::creation args
-
-# define ASIO_HANDLER_COMPLETION(args) \
-  ::custom_tracking::completion tracked_completion args
-
-# define ASIO_HANDLER_INVOCATION_BEGIN(args) \
-  tracked_completion.invocation_begin args
-
-# define ASIO_HANDLER_INVOCATION_END \
-  tracked_completion.invocation_end()
-
-# define ASIO_HANDLER_OPERATION(args) \
-  ::custom_tracking::operation args
-
-# define ASIO_HANDLER_REACTOR_REGISTRATION(args) \
-  ::custom_tracking::reactor_registration args
-
-# define ASIO_HANDLER_REACTOR_DEREGISTRATION(args) \
-  ::custom_tracking::reactor_deregistration args
-
-# define ASIO_HANDLER_REACTOR_READ_EVENT 1
-# define ASIO_HANDLER_REACTOR_WRITE_EVENT 2
-# define ASIO_HANDLER_REACTOR_ERROR_EVENT 4
-
-# define ASIO_HANDLER_REACTOR_EVENTS(args) \
-  ::custom_tracking::reactor_events args
-
-# define ASIO_HANDLER_REACTOR_OPERATION(args) \
-  ::custom_tracking::reactor_operation args
-
-struct custom_tracking
-{
-  // Base class for objects containing tracked handlers.
-  struct tracked_handler
-  {
-    std::uintmax_t handler_id_ = 0; // To uniquely identify a handler.
-    std::uintmax_t tree_id_ = 0; // To identify related handlers.
-    const char* object_type_; // The object type associated with the handler.
-    std::uintmax_t native_handle_; // Native handle, if any.
-  };
-
-  // Initialise the tracking system.
-  static void init()
-  {
-  }
-
-  // Record a source location.
-  static void location(const char* file_name,
-      int line, const char* function_name)
-  {
-    std::printf("At location %s:%d in %s\n", file_name, line, function_name);
-  }
-
-  // Record the creation of a tracked handler.
-  static void creation(asio::execution_context& /*ctx*/,
-      tracked_handler& h, const char* object_type, void* /*object*/,
-      std::uintmax_t native_handle, const char* op_name)
-  {
-    // Generate a unique id for the new handler.
-    static std::atomic<std::uintmax_t> next_handler_id{1};
-    h.handler_id_ = next_handler_id++;
-
-    // Copy the tree identifier forward from the current handler.
-    if (*current_completion())
-      h.tree_id_ = (*current_completion())->handler_.tree_id_;
-
-    // Store various attributes of the operation to use in later output.
-    h.object_type_ = object_type;
-    h.native_handle_ = native_handle;
-
-    std::printf(
-        "Starting operation %s.%s for native_handle = %" PRIuMAX
-        ", handler = %" PRIuMAX ", tree = %" PRIuMAX "\n",
-        object_type, op_name, h.native_handle_, h.handler_id_, h.tree_id_);
-  }
-
-  struct completion
-  {
-    explicit completion(const tracked_handler& h)
-      : handler_(h),
-        next_(*current_completion())
-    {
-      *current_completion() = this;
-    }
-
-    completion(const completion&) = delete;
-    completion& operator=(const completion&) = delete;
-
-    // Destructor records only when an exception is thrown from the handler, or
-    // if the memory is being freed without the handler having been invoked.
-    ~completion()
-    {
-      *current_completion() = next_;
-    }
-
-    // Records that handler is to be invoked with the specified arguments.
-    template <class... Args>
-    void invocation_begin(Args&&... /*args*/)
-    {
-      std::printf("Entering handler %" PRIuMAX " in tree %" PRIuMAX "\n",
-          handler_.handler_id_, handler_.tree_id_);
-    }
-
-    // Record that handler invocation has ended.
-    void invocation_end()
-    {
-      std::printf("Leaving handler %" PRIuMAX " in tree %" PRIuMAX "\n",
-          handler_.handler_id_, handler_.tree_id_);
-    }
-
-    tracked_handler handler_;
-
-    // Completions may nest. Here we stash a pointer to the outer completion.
-    completion* next_;
-  };
-
-  static completion** current_completion()
-  {
-    static ASIO_THREAD_KEYWORD completion* current = nullptr;
-    return &current;
-  }
-
-  // Record an operation that is not directly associated with a handler.
-  static void operation(asio::execution_context& /*ctx*/,
-      const char* /*object_type*/, void* /*object*/,
-      std::uintmax_t /*native_handle*/, const char* /*op_name*/)
-  {
-  }
-
-  // Record that a descriptor has been registered with the reactor.
-  static void reactor_registration(asio::execution_context& context,
-      uintmax_t native_handle, uintmax_t registration)
-  {
-    std::printf("Adding to reactor native_handle = %" PRIuMAX
-        ", registration = %" PRIuMAX "\n", native_handle, registration);
-  }
-
-  // Record that a descriptor has been deregistered from the reactor.
-  static void reactor_deregistration(asio::execution_context& context,
-      uintmax_t native_handle, uintmax_t registration)
-  {
-    std::printf("Removing from reactor native_handle = %" PRIuMAX
-        ", registration = %" PRIuMAX "\n", native_handle, registration);
-  }
-
-  // Record reactor-based readiness events associated with a descriptor.
-  static void reactor_events(asio::execution_context& context,
-      uintmax_t registration, unsigned events)
-  {
-    std::printf(
-        "Reactor readiness for registration = %" PRIuMAX ", events =%s%s%s\n",
-        registration,
-        (events & ASIO_HANDLER_REACTOR_READ_EVENT) ? " read" : "",
-        (events & ASIO_HANDLER_REACTOR_WRITE_EVENT) ? " write" : "",
-        (events & ASIO_HANDLER_REACTOR_ERROR_EVENT) ? " error" : "");
-  }
-
-  // Record a reactor-based operation that is associated with a handler.
-  static void reactor_operation(const tracked_handler& h,
-      const char* op_name, const std::error_code& ec)
-  {
-    std::printf(
-        "Performed operation %s.%s for native_handle = %" PRIuMAX
-        ", ec = %s:%d\n", h.object_type_, op_name, h.native_handle_,
-        ec.category().name(), ec.value());
-  }
-
-  // Record a reactor-based operation that is associated with a handler.
-  static void reactor_operation(const tracked_handler& h,
-      const char* op_name, const std::error_code& ec,
-      std::size_t bytes_transferred)
-  {
-    std::printf(
-        "Performed operation %s.%s for native_handle = %" PRIuMAX
-        ", ec = %s:%d, n = %" PRIuMAX "\n", h.object_type_, op_name,
-        h.native_handle_, ec.category().name(), ec.value(),
-        static_cast<uintmax_t>(bytes_transferred));
-  }
-};
-
-#endif // CUSTOM_TRACKING_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/.gitignore
deleted file mode 100644
index e80f510..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/async_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/async_client.cpp
deleted file mode 100644
index 309ae25..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/async_client.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-//
-// async_client.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <functional>
-#include <iostream>
-#include <istream>
-#include <ostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-class client
-{
-public:
-  client(asio::io_context& io_context,
-      const std::string& server, const std::string& path)
-    : resolver_(io_context),
-      socket_(io_context)
-  {
-    // Form the request. We specify the "Connection: close" header so that the
-    // server will close the socket after transmitting the response. This will
-    // allow us to treat all data up until the EOF as the content.
-    std::ostream request_stream(&request_);
-    request_stream << "GET " << path << " HTTP/1.0\r\n";
-    request_stream << "Host: " << server << "\r\n";
-    request_stream << "Accept: */*\r\n";
-    request_stream << "Connection: close\r\n\r\n";
-
-    // Start an asynchronous resolve to translate the server and service names
-    // into a list of endpoints.
-    resolver_.async_resolve(server, "http",
-        std::bind(&client::handle_resolve, this,
-          asio::placeholders::error,
-          asio::placeholders::results));
-  }
-
-private:
-  void handle_resolve(const std::error_code& err,
-      const tcp::resolver::results_type& endpoints)
-  {
-    if (!err)
-    {
-      // Attempt a connection to each endpoint in the list until we
-      // successfully establish a connection.
-      asio::async_connect(socket_, endpoints,
-          std::bind(&client::handle_connect, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      std::cout << "Error: " << err.message() << "\n";
-    }
-  }
-
-  void handle_connect(const std::error_code& err)
-  {
-    if (!err)
-    {
-      // The connection was successful. Send the request.
-      asio::async_write(socket_, request_,
-          std::bind(&client::handle_write_request, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      std::cout << "Error: " << err.message() << "\n";
-    }
-  }
-
-  void handle_write_request(const std::error_code& err)
-  {
-    if (!err)
-    {
-      // Read the response status line. The response_ streambuf will
-      // automatically grow to accommodate the entire line. The growth may be
-      // limited by passing a maximum size to the streambuf constructor.
-      asio::async_read_until(socket_, response_, "\r\n",
-          std::bind(&client::handle_read_status_line, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      std::cout << "Error: " << err.message() << "\n";
-    }
-  }
-
-  void handle_read_status_line(const std::error_code& err)
-  {
-    if (!err)
-    {
-      // Check that response is OK.
-      std::istream response_stream(&response_);
-      std::string http_version;
-      response_stream >> http_version;
-      unsigned int status_code;
-      response_stream >> status_code;
-      std::string status_message;
-      std::getline(response_stream, status_message);
-      if (!response_stream || http_version.substr(0, 5) != "HTTP/")
-      {
-        std::cout << "Invalid response\n";
-        return;
-      }
-      if (status_code != 200)
-      {
-        std::cout << "Response returned with status code ";
-        std::cout << status_code << "\n";
-        return;
-      }
-
-      // Read the response headers, which are terminated by a blank line.
-      asio::async_read_until(socket_, response_, "\r\n\r\n",
-          std::bind(&client::handle_read_headers, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      std::cout << "Error: " << err << "\n";
-    }
-  }
-
-  void handle_read_headers(const std::error_code& err)
-  {
-    if (!err)
-    {
-      // Process the response headers.
-      std::istream response_stream(&response_);
-      std::string header;
-      while (std::getline(response_stream, header) && header != "\r")
-        std::cout << header << "\n";
-      std::cout << "\n";
-
-      // Write whatever content we already have to output.
-      if (response_.size() > 0)
-        std::cout << &response_;
-
-      // Start reading remaining data until EOF.
-      asio::async_read(socket_, response_,
-          asio::transfer_at_least(1),
-          std::bind(&client::handle_read_content, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      std::cout << "Error: " << err << "\n";
-    }
-  }
-
-  void handle_read_content(const std::error_code& err)
-  {
-    if (!err)
-    {
-      // Write all of the data that has been read so far.
-      std::cout << &response_;
-
-      // Continue reading remaining data until EOF.
-      asio::async_read(socket_, response_,
-          asio::transfer_at_least(1),
-          std::bind(&client::handle_read_content, this,
-            asio::placeholders::error));
-    }
-    else if (err != asio::error::eof)
-    {
-      std::cout << "Error: " << err << "\n";
-    }
-  }
-
-  tcp::resolver resolver_;
-  tcp::socket socket_;
-  asio::streambuf request_;
-  asio::streambuf response_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cout << "Usage: async_client <server> <path>\n";
-      std::cout << "Example:\n";
-      std::cout << "  async_client www.boost.org /LICENSE_1_0.txt\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    client c(io_context, argv[1], argv[2]);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/sync_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/sync_client.cpp
deleted file mode 100644
index 4f5ad09..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/client/sync_client.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-// sync_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <istream>
-#include <ostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cout << "Usage: sync_client <server> <path>\n";
-      std::cout << "Example:\n";
-      std::cout << "  sync_client www.boost.org /LICENSE_1_0.txt\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    // Get a list of endpoints corresponding to the server name.
-    tcp::resolver resolver(io_context);
-    tcp::resolver::results_type endpoints = resolver.resolve(argv[1], "http");
-
-    // Try each endpoint until we successfully establish a connection.
-    tcp::socket socket(io_context);
-    asio::connect(socket, endpoints);
-
-    // Form the request. We specify the "Connection: close" header so that the
-    // server will close the socket after transmitting the response. This will
-    // allow us to treat all data up until the EOF as the content.
-    asio::streambuf request;
-    std::ostream request_stream(&request);
-    request_stream << "GET " << argv[2] << " HTTP/1.0\r\n";
-    request_stream << "Host: " << argv[1] << "\r\n";
-    request_stream << "Accept: */*\r\n";
-    request_stream << "Connection: close\r\n\r\n";
-
-    // Send the request.
-    asio::write(socket, request);
-
-    // Read the response status line. The response streambuf will automatically
-    // grow to accommodate the entire line. The growth may be limited by passing
-    // a maximum size to the streambuf constructor.
-    asio::streambuf response;
-    asio::read_until(socket, response, "\r\n");
-
-    // Check that response is OK.
-    std::istream response_stream(&response);
-    std::string http_version;
-    response_stream >> http_version;
-    unsigned int status_code;
-    response_stream >> status_code;
-    std::string status_message;
-    std::getline(response_stream, status_message);
-    if (!response_stream || http_version.substr(0, 5) != "HTTP/")
-    {
-      std::cout << "Invalid response\n";
-      return 1;
-    }
-    if (status_code != 200)
-    {
-      std::cout << "Response returned with status code " << status_code << "\n";
-      return 1;
-    }
-
-    // Read the response headers, which are terminated by a blank line.
-    asio::read_until(socket, response, "\r\n\r\n");
-
-    // Process the response headers.
-    std::string header;
-    while (std::getline(response_stream, header) && header != "\r")
-      std::cout << header << "\n";
-    std::cout << "\n";
-
-    // Write whatever content we already have to output.
-    if (response.size() > 0)
-      std::cout << &response;
-
-    // Read until EOF, writing data to output as we go.
-    std::error_code error;
-    while (asio::read(socket, response,
-          asio::transfer_at_least(1), error))
-      std::cout << &response;
-    if (error != asio::error::eof)
-      throw std::system_error(error);
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_1K.html b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_1K.html
deleted file mode 100644
index b8b6040..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_1K.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<!--
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<html>
-<body>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the<br/>
-</body>
-</html>
-
-<!-- boostinspect:nounlinked -->
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_2K.html b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_2K.html
deleted file mode 100644
index 3804e8f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_2K.html
+++ /dev/null
@@ -1,49 +0,0 @@
-<!--
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<html>
-<body>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps ove<br/>
-</body>
-</html>
-
-<!-- boostinspect:nounlinked -->
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_4K.html b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_4K.html
deleted file mode 100644
index 54945c4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_4K.html
+++ /dev/null
@@ -1,91 +0,0 @@
-<!--
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<html>
-<body>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox<br/>
-</body>
-</html>
-
-<!-- boostinspect:nounlinked -->
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_8K.html b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_8K.html
deleted file mode 100644
index b2602ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/doc_root/data_8K.html
+++ /dev/null
@@ -1,175 +0,0 @@
-<!--
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--->
-
-<html>
-<body>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-The quick brown fox jumps over the lazy dog<br/>
-....
-</body>
-</html>
-
-<!-- boostinspect:nounlinked -->
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.cpp
deleted file mode 100644
index 58d619f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//
-// connection.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "connection.hpp"
-#include <utility>
-#include "connection_manager.hpp"
-#include "request_handler.hpp"
-
-namespace http {
-namespace server {
-
-connection::connection(asio::ip::tcp::socket socket,
-    connection_manager& manager, request_handler& handler)
-  : socket_(std::move(socket)),
-    connection_manager_(manager),
-    request_handler_(handler)
-{
-}
-
-void connection::start()
-{
-  do_read();
-}
-
-void connection::stop()
-{
-  socket_.close();
-}
-
-void connection::do_read()
-{
-  auto self(shared_from_this());
-  socket_.async_read_some(asio::buffer(buffer_),
-      [this, self](std::error_code ec, std::size_t bytes_transferred)
-      {
-        if (!ec)
-        {
-          request_parser::result_type result;
-          std::tie(result, std::ignore) = request_parser_.parse(
-              request_, buffer_.data(), buffer_.data() + bytes_transferred);
-
-          if (result == request_parser::good)
-          {
-            request_handler_.handle_request(request_, reply_);
-            do_write();
-          }
-          else if (result == request_parser::bad)
-          {
-            reply_ = reply::stock_reply(reply::bad_request);
-            do_write();
-          }
-          else
-          {
-            do_read();
-          }
-        }
-        else if (ec != asio::error::operation_aborted)
-        {
-          connection_manager_.stop(shared_from_this());
-        }
-      });
-}
-
-void connection::do_write()
-{
-  auto self(shared_from_this());
-  asio::async_write(socket_, reply_.to_buffers(),
-      [this, self](std::error_code ec, std::size_t)
-      {
-        if (!ec)
-        {
-          // Initiate graceful connection closure.
-          std::error_code ignored_ec;
-          socket_.shutdown(asio::ip::tcp::socket::shutdown_both,
-            ignored_ec);
-        }
-
-        if (ec != asio::error::operation_aborted)
-        {
-          connection_manager_.stop(shared_from_this());
-        }
-      });
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.hpp
deleted file mode 100644
index 1d671eb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//
-// connection.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_CONNECTION_HPP
-#define HTTP_CONNECTION_HPP
-
-#include <asio.hpp>
-#include <array>
-#include <memory>
-#include "reply.hpp"
-#include "request.hpp"
-#include "request_handler.hpp"
-#include "request_parser.hpp"
-
-namespace http {
-namespace server {
-
-class connection_manager;
-
-/// Represents a single connection from a client.
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  connection(const connection&) = delete;
-  connection& operator=(const connection&) = delete;
-
-  /// Construct a connection with the given socket.
-  explicit connection(asio::ip::tcp::socket socket,
-      connection_manager& manager, request_handler& handler);
-
-  /// Start the first asynchronous operation for the connection.
-  void start();
-
-  /// Stop all asynchronous operations associated with the connection.
-  void stop();
-
-private:
-  /// Perform an asynchronous read operation.
-  void do_read();
-
-  /// Perform an asynchronous write operation.
-  void do_write();
-
-  /// Socket for the connection.
-  asio::ip::tcp::socket socket_;
-
-  /// The manager for this connection.
-  connection_manager& connection_manager_;
-
-  /// The handler used to process the incoming request.
-  request_handler& request_handler_;
-
-  /// Buffer for incoming data.
-  std::array<char, 8192> buffer_;
-
-  /// The incoming request.
-  request request_;
-
-  /// The parser for the incoming request.
-  request_parser request_parser_;
-
-  /// The reply to be sent back to the client.
-  reply reply_;
-};
-
-typedef std::shared_ptr<connection> connection_ptr;
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_CONNECTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.cpp
deleted file mode 100644
index 8816191..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// connection_manager.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "connection_manager.hpp"
-
-namespace http {
-namespace server {
-
-connection_manager::connection_manager()
-{
-}
-
-void connection_manager::start(connection_ptr c)
-{
-  connections_.insert(c);
-  c->start();
-}
-
-void connection_manager::stop(connection_ptr c)
-{
-  connections_.erase(c);
-  c->stop();
-}
-
-void connection_manager::stop_all()
-{
-  for (auto c: connections_)
-    c->stop();
-  connections_.clear();
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.hpp
deleted file mode 100644
index 0b35408..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/connection_manager.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// connection_manager.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_CONNECTION_MANAGER_HPP
-#define HTTP_CONNECTION_MANAGER_HPP
-
-#include <set>
-#include "connection.hpp"
-
-namespace http {
-namespace server {
-
-/// Manages open connections so that they may be cleanly stopped when the server
-/// needs to shut down.
-class connection_manager
-{
-public:
-  connection_manager(const connection_manager&) = delete;
-  connection_manager& operator=(const connection_manager&) = delete;
-
-  /// Construct a connection manager.
-  connection_manager();
-
-  /// Add the specified connection to the manager and start it.
-  void start(connection_ptr c);
-
-  /// Stop the specified connection.
-  void stop(connection_ptr c);
-
-  /// Stop all connections.
-  void stop_all();
-
-private:
-  /// The managed connections.
-  std::set<connection_ptr> connections_;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_CONNECTION_MANAGER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/header.hpp
deleted file mode 100644
index e91e6ff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/header.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// header.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_HEADER_HPP
-#define HTTP_HEADER_HPP
-
-#include <string>
-
-namespace http {
-namespace server {
-
-struct header
-{
-  std::string name;
-  std::string value;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/main.cpp
deleted file mode 100644
index b76044a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/main.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-#include "server.hpp"
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 4)
-    {
-      std::cerr << "Usage: http_server <address> <port> <doc_root>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 80 .\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 80 .\n";
-      return 1;
-    }
-
-    // Initialise the server.
-    http::server::server s(argv[1], argv[2], argv[3]);
-
-    // Run the server until stopped.
-    s.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.cpp
deleted file mode 100644
index 23153ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// mime_types.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "mime_types.hpp"
-
-namespace http {
-namespace server {
-namespace mime_types {
-
-struct mapping
-{
-  const char* extension;
-  const char* mime_type;
-} mappings[] =
-{
-  { "gif", "image/gif" },
-  { "htm", "text/html" },
-  { "html", "text/html" },
-  { "jpg", "image/jpeg" },
-  { "png", "image/png" }
-};
-
-std::string extension_to_type(const std::string& extension)
-{
-  for (mapping m: mappings)
-  {
-    if (m.extension == extension)
-    {
-      return m.mime_type;
-    }
-  }
-
-  return "text/plain";
-}
-
-} // namespace mime_types
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.hpp
deleted file mode 100644
index fcefce5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/mime_types.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// mime_types.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_MIME_TYPES_HPP
-#define HTTP_MIME_TYPES_HPP
-
-#include <string>
-
-namespace http {
-namespace server {
-namespace mime_types {
-
-/// Convert a file extension into a MIME type.
-std::string extension_to_type(const std::string& extension);
-
-} // namespace mime_types
-} // namespace server
-} // namespace http
-
-#endif // HTTP_MIME_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.cpp
deleted file mode 100644
index 9d8f04e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// reply.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "reply.hpp"
-#include <string>
-
-namespace http {
-namespace server {
-
-namespace status_strings {
-
-const std::string ok =
-  "HTTP/1.0 200 OK\r\n";
-const std::string created =
-  "HTTP/1.0 201 Created\r\n";
-const std::string accepted =
-  "HTTP/1.0 202 Accepted\r\n";
-const std::string no_content =
-  "HTTP/1.0 204 No Content\r\n";
-const std::string multiple_choices =
-  "HTTP/1.0 300 Multiple Choices\r\n";
-const std::string moved_permanently =
-  "HTTP/1.0 301 Moved Permanently\r\n";
-const std::string moved_temporarily =
-  "HTTP/1.0 302 Moved Temporarily\r\n";
-const std::string not_modified =
-  "HTTP/1.0 304 Not Modified\r\n";
-const std::string bad_request =
-  "HTTP/1.0 400 Bad Request\r\n";
-const std::string unauthorized =
-  "HTTP/1.0 401 Unauthorized\r\n";
-const std::string forbidden =
-  "HTTP/1.0 403 Forbidden\r\n";
-const std::string not_found =
-  "HTTP/1.0 404 Not Found\r\n";
-const std::string internal_server_error =
-  "HTTP/1.0 500 Internal Server Error\r\n";
-const std::string not_implemented =
-  "HTTP/1.0 501 Not Implemented\r\n";
-const std::string bad_gateway =
-  "HTTP/1.0 502 Bad Gateway\r\n";
-const std::string service_unavailable =
-  "HTTP/1.0 503 Service Unavailable\r\n";
-
-asio::const_buffer to_buffer(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return asio::buffer(ok);
-  case reply::created:
-    return asio::buffer(created);
-  case reply::accepted:
-    return asio::buffer(accepted);
-  case reply::no_content:
-    return asio::buffer(no_content);
-  case reply::multiple_choices:
-    return asio::buffer(multiple_choices);
-  case reply::moved_permanently:
-    return asio::buffer(moved_permanently);
-  case reply::moved_temporarily:
-    return asio::buffer(moved_temporarily);
-  case reply::not_modified:
-    return asio::buffer(not_modified);
-  case reply::bad_request:
-    return asio::buffer(bad_request);
-  case reply::unauthorized:
-    return asio::buffer(unauthorized);
-  case reply::forbidden:
-    return asio::buffer(forbidden);
-  case reply::not_found:
-    return asio::buffer(not_found);
-  case reply::internal_server_error:
-    return asio::buffer(internal_server_error);
-  case reply::not_implemented:
-    return asio::buffer(not_implemented);
-  case reply::bad_gateway:
-    return asio::buffer(bad_gateway);
-  case reply::service_unavailable:
-    return asio::buffer(service_unavailable);
-  default:
-    return asio::buffer(internal_server_error);
-  }
-}
-
-} // namespace status_strings
-
-namespace misc_strings {
-
-const char name_value_separator[] = { ':', ' ' };
-const char crlf[] = { '\r', '\n' };
-
-} // namespace misc_strings
-
-std::vector<asio::const_buffer> reply::to_buffers()
-{
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(status_strings::to_buffer(status));
-  for (std::size_t i = 0; i < headers.size(); ++i)
-  {
-    header& h = headers[i];
-    buffers.push_back(asio::buffer(h.name));
-    buffers.push_back(asio::buffer(misc_strings::name_value_separator));
-    buffers.push_back(asio::buffer(h.value));
-    buffers.push_back(asio::buffer(misc_strings::crlf));
-  }
-  buffers.push_back(asio::buffer(misc_strings::crlf));
-  buffers.push_back(asio::buffer(content));
-  return buffers;
-}
-
-namespace stock_replies {
-
-const char ok[] = "";
-const char created[] =
-  "<html>"
-  "<head><title>Created</title></head>"
-  "<body><h1>201 Created</h1></body>"
-  "</html>";
-const char accepted[] =
-  "<html>"
-  "<head><title>Accepted</title></head>"
-  "<body><h1>202 Accepted</h1></body>"
-  "</html>";
-const char no_content[] =
-  "<html>"
-  "<head><title>No Content</title></head>"
-  "<body><h1>204 Content</h1></body>"
-  "</html>";
-const char multiple_choices[] =
-  "<html>"
-  "<head><title>Multiple Choices</title></head>"
-  "<body><h1>300 Multiple Choices</h1></body>"
-  "</html>";
-const char moved_permanently[] =
-  "<html>"
-  "<head><title>Moved Permanently</title></head>"
-  "<body><h1>301 Moved Permanently</h1></body>"
-  "</html>";
-const char moved_temporarily[] =
-  "<html>"
-  "<head><title>Moved Temporarily</title></head>"
-  "<body><h1>302 Moved Temporarily</h1></body>"
-  "</html>";
-const char not_modified[] =
-  "<html>"
-  "<head><title>Not Modified</title></head>"
-  "<body><h1>304 Not Modified</h1></body>"
-  "</html>";
-const char bad_request[] =
-  "<html>"
-  "<head><title>Bad Request</title></head>"
-  "<body><h1>400 Bad Request</h1></body>"
-  "</html>";
-const char unauthorized[] =
-  "<html>"
-  "<head><title>Unauthorized</title></head>"
-  "<body><h1>401 Unauthorized</h1></body>"
-  "</html>";
-const char forbidden[] =
-  "<html>"
-  "<head><title>Forbidden</title></head>"
-  "<body><h1>403 Forbidden</h1></body>"
-  "</html>";
-const char not_found[] =
-  "<html>"
-  "<head><title>Not Found</title></head>"
-  "<body><h1>404 Not Found</h1></body>"
-  "</html>";
-const char internal_server_error[] =
-  "<html>"
-  "<head><title>Internal Server Error</title></head>"
-  "<body><h1>500 Internal Server Error</h1></body>"
-  "</html>";
-const char not_implemented[] =
-  "<html>"
-  "<head><title>Not Implemented</title></head>"
-  "<body><h1>501 Not Implemented</h1></body>"
-  "</html>";
-const char bad_gateway[] =
-  "<html>"
-  "<head><title>Bad Gateway</title></head>"
-  "<body><h1>502 Bad Gateway</h1></body>"
-  "</html>";
-const char service_unavailable[] =
-  "<html>"
-  "<head><title>Service Unavailable</title></head>"
-  "<body><h1>503 Service Unavailable</h1></body>"
-  "</html>";
-
-std::string to_string(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return ok;
-  case reply::created:
-    return created;
-  case reply::accepted:
-    return accepted;
-  case reply::no_content:
-    return no_content;
-  case reply::multiple_choices:
-    return multiple_choices;
-  case reply::moved_permanently:
-    return moved_permanently;
-  case reply::moved_temporarily:
-    return moved_temporarily;
-  case reply::not_modified:
-    return not_modified;
-  case reply::bad_request:
-    return bad_request;
-  case reply::unauthorized:
-    return unauthorized;
-  case reply::forbidden:
-    return forbidden;
-  case reply::not_found:
-    return not_found;
-  case reply::internal_server_error:
-    return internal_server_error;
-  case reply::not_implemented:
-    return not_implemented;
-  case reply::bad_gateway:
-    return bad_gateway;
-  case reply::service_unavailable:
-    return service_unavailable;
-  default:
-    return internal_server_error;
-  }
-}
-
-} // namespace stock_replies
-
-reply reply::stock_reply(reply::status_type status)
-{
-  reply rep;
-  rep.status = status;
-  rep.content = stock_replies::to_string(status);
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = "text/html";
-  return rep;
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.hpp
deleted file mode 100644
index f1eee1f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/reply.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// reply.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_REPLY_HPP
-#define HTTP_REPLY_HPP
-
-#include <string>
-#include <vector>
-#include <asio.hpp>
-#include "header.hpp"
-
-namespace http {
-namespace server {
-
-/// A reply to be sent to a client.
-struct reply
-{
-  /// The status of the reply.
-  enum status_type
-  {
-    ok = 200,
-    created = 201,
-    accepted = 202,
-    no_content = 204,
-    multiple_choices = 300,
-    moved_permanently = 301,
-    moved_temporarily = 302,
-    not_modified = 304,
-    bad_request = 400,
-    unauthorized = 401,
-    forbidden = 403,
-    not_found = 404,
-    internal_server_error = 500,
-    not_implemented = 501,
-    bad_gateway = 502,
-    service_unavailable = 503
-  } status;
-
-  /// The headers to be included in the reply.
-  std::vector<header> headers;
-
-  /// The content to be sent in the reply.
-  std::string content;
-
-  /// Convert the reply into a vector of buffers. The buffers do not own the
-  /// underlying memory blocks, therefore the reply object must remain valid and
-  /// not be changed until the write operation has completed.
-  std::vector<asio::const_buffer> to_buffers();
-
-  /// Get a stock reply.
-  static reply stock_reply(status_type status);
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_REPLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request.hpp
deleted file mode 100644
index 93a96db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// request.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_REQUEST_HPP
-#define HTTP_REQUEST_HPP
-
-#include <string>
-#include <vector>
-#include "header.hpp"
-
-namespace http {
-namespace server {
-
-/// A request received from a client.
-struct request
-{
-  std::string method;
-  std::string uri;
-  int http_version_major;
-  int http_version_minor;
-  std::vector<header> headers;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_REQUEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.cpp
deleted file mode 100644
index 97b4ac6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// request_handler.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_handler.hpp"
-#include <fstream>
-#include <sstream>
-#include <string>
-#include "mime_types.hpp"
-#include "reply.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server {
-
-request_handler::request_handler(const std::string& doc_root)
-  : doc_root_(doc_root)
-{
-}
-
-void request_handler::handle_request(const request& req, reply& rep)
-{
-  // Decode url to path.
-  std::string request_path;
-  if (!url_decode(req.uri, request_path))
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // Request path must be absolute and not contain "..".
-  if (request_path.empty() || request_path[0] != '/'
-      || request_path.find("..") != std::string::npos)
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // If path ends in slash (i.e. is a directory) then add "index.html".
-  if (request_path[request_path.size() - 1] == '/')
-  {
-    request_path += "index.html";
-  }
-
-  // Determine the file extension.
-  std::size_t last_slash_pos = request_path.find_last_of("/");
-  std::size_t last_dot_pos = request_path.find_last_of(".");
-  std::string extension;
-  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
-  {
-    extension = request_path.substr(last_dot_pos + 1);
-  }
-
-  // Open the file to send back.
-  std::string full_path = doc_root_ + request_path;
-  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
-  if (!is)
-  {
-    rep = reply::stock_reply(reply::not_found);
-    return;
-  }
-
-  // Fill out the reply to be sent to the client.
-  rep.status = reply::ok;
-  char buf[512];
-  while (is.read(buf, sizeof(buf)).gcount() > 0)
-    rep.content.append(buf, is.gcount());
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = mime_types::extension_to_type(extension);
-}
-
-bool request_handler::url_decode(const std::string& in, std::string& out)
-{
-  out.clear();
-  out.reserve(in.size());
-  for (std::size_t i = 0; i < in.size(); ++i)
-  {
-    if (in[i] == '%')
-    {
-      if (i + 3 <= in.size())
-      {
-        int value = 0;
-        std::istringstream is(in.substr(i + 1, 2));
-        if (is >> std::hex >> value)
-        {
-          out += static_cast<char>(value);
-          i += 2;
-        }
-        else
-        {
-          return false;
-        }
-      }
-      else
-      {
-        return false;
-      }
-    }
-    else if (in[i] == '+')
-    {
-      out += ' ';
-    }
-    else
-    {
-      out += in[i];
-    }
-  }
-  return true;
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.hpp
deleted file mode 100644
index 978b37c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_handler.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// request_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_REQUEST_HANDLER_HPP
-#define HTTP_REQUEST_HANDLER_HPP
-
-#include <string>
-
-namespace http {
-namespace server {
-
-struct reply;
-struct request;
-
-/// The common handler for all incoming requests.
-class request_handler
-{
-public:
-  request_handler(const request_handler&) = delete;
-  request_handler& operator=(const request_handler&) = delete;
-
-  /// Construct with a directory containing files to be served.
-  explicit request_handler(const std::string& doc_root);
-
-  /// Handle a request and produce a reply.
-  void handle_request(const request& req, reply& rep);
-
-private:
-  /// The directory containing the files to be served.
-  std::string doc_root_;
-
-  /// Perform URL-decoding on a string. Returns false if the encoding was
-  /// invalid.
-  static bool url_decode(const std::string& in, std::string& out);
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_REQUEST_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.cpp
deleted file mode 100644
index ff56e9c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-//
-// request_parser.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_parser.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server {
-
-request_parser::request_parser()
-  : state_(method_start)
-{
-}
-
-void request_parser::reset()
-{
-  state_ = method_start;
-}
-
-request_parser::result_type request_parser::consume(request& req, char input)
-{
-  switch (state_)
-  {
-  case method_start:
-    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = method;
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case method:
-    if (input == ' ')
-    {
-      state_ = uri;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case uri:
-    if (input == ' ')
-    {
-      state_ = http_version_h;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.uri.push_back(input);
-      return indeterminate;
-    }
-  case http_version_h:
-    if (input == 'H')
-    {
-      state_ = http_version_t_1;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_1:
-    if (input == 'T')
-    {
-      state_ = http_version_t_2;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_2:
-    if (input == 'T')
-    {
-      state_ = http_version_p;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_p:
-    if (input == 'P')
-    {
-      state_ = http_version_slash;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_slash:
-    if (input == '/')
-    {
-      req.http_version_major = 0;
-      req.http_version_minor = 0;
-      state_ = http_version_major_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major_start:
-    if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      state_ = http_version_major;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major:
-    if (input == '.')
-    {
-      state_ = http_version_minor_start;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor_start:
-    if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      state_ = http_version_minor;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_1;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_1:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_line_start:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_3;
-      return indeterminate;
-    }
-    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
-    {
-      state_ = header_lws;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.push_back(header());
-      req.headers.back().name.push_back(input);
-      state_ = header_name;
-      return indeterminate;
-    }
-  case header_lws:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (input == ' ' || input == '\t')
-    {
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = header_value;
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case header_name:
-    if (input == ':')
-    {
-      state_ = space_before_header_value;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().name.push_back(input);
-      return indeterminate;
-    }
-  case space_before_header_value:
-    if (input == ' ')
-    {
-      state_ = header_value;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_value:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case expecting_newline_2:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_3:
-    return (input == '\n') ? good : bad;
-  default:
-    return bad;
-  }
-}
-
-bool request_parser::is_char(int c)
-{
-  return c >= 0 && c <= 127;
-}
-
-bool request_parser::is_ctl(int c)
-{
-  return (c >= 0 && c <= 31) || (c == 127);
-}
-
-bool request_parser::is_tspecial(int c)
-{
-  switch (c)
-  {
-  case '(': case ')': case '<': case '>': case '@':
-  case ',': case ';': case ':': case '\\': case '"':
-  case '/': case '[': case ']': case '?': case '=':
-  case '{': case '}': case ' ': case '\t':
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool request_parser::is_digit(int c)
-{
-  return c >= '0' && c <= '9';
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.hpp
deleted file mode 100644
index 260e875..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/request_parser.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// request_parser.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_REQUEST_PARSER_HPP
-#define HTTP_REQUEST_PARSER_HPP
-
-#include <tuple>
-
-namespace http {
-namespace server {
-
-struct request;
-
-/// Parser for incoming requests.
-class request_parser
-{
-public:
-  /// Construct ready to parse the request method.
-  request_parser();
-
-  /// Reset to initial parser state.
-  void reset();
-
-  /// Result of parse.
-  enum result_type { good, bad, indeterminate };
-
-  /// Parse some data. The enum return value is good when a complete request has
-  /// been parsed, bad if the data is invalid, indeterminate when more data is
-  /// required. The InputIterator return value indicates how much of the input
-  /// has been consumed.
-  template <typename InputIterator>
-  std::tuple<result_type, InputIterator> parse(request& req,
-      InputIterator begin, InputIterator end)
-  {
-    while (begin != end)
-    {
-      result_type result = consume(req, *begin++);
-      if (result == good || result == bad)
-        return std::make_tuple(result, begin);
-    }
-    return std::make_tuple(indeterminate, begin);
-  }
-
-private:
-  /// Handle the next character of input.
-  result_type consume(request& req, char input);
-
-  /// Check if a byte is an HTTP character.
-  static bool is_char(int c);
-
-  /// Check if a byte is an HTTP control character.
-  static bool is_ctl(int c);
-
-  /// Check if a byte is defined as an HTTP tspecial character.
-  static bool is_tspecial(int c);
-
-  /// Check if a byte is a digit.
-  static bool is_digit(int c);
-
-  /// The current state of the parser.
-  enum state
-  {
-    method_start,
-    method,
-    uri,
-    http_version_h,
-    http_version_t_1,
-    http_version_t_2,
-    http_version_p,
-    http_version_slash,
-    http_version_major_start,
-    http_version_major,
-    http_version_minor_start,
-    http_version_minor,
-    expecting_newline_1,
-    header_line_start,
-    header_lws,
-    header_name,
-    space_before_header_value,
-    header_value,
-    expecting_newline_2,
-    expecting_newline_3
-  } state_;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_REQUEST_PARSER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.cpp
deleted file mode 100644
index d824ebb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "server.hpp"
-#include <signal.h>
-#include <utility>
-
-namespace http {
-namespace server {
-
-server::server(const std::string& address, const std::string& port,
-    const std::string& doc_root)
-  : io_context_(1),
-    signals_(io_context_),
-    acceptor_(io_context_),
-    connection_manager_(),
-    request_handler_(doc_root)
-{
-  // Register to handle the signals that indicate when the server should exit.
-  // It is safe to register for the same signal multiple times in a program,
-  // provided all registration for the specified signal is made through Asio.
-  signals_.add(SIGINT);
-  signals_.add(SIGTERM);
-#if defined(SIGQUIT)
-  signals_.add(SIGQUIT);
-#endif // defined(SIGQUIT)
-
-  do_await_stop();
-
-  // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
-  asio::ip::tcp::resolver resolver(io_context_);
-  asio::ip::tcp::endpoint endpoint =
-    *resolver.resolve(address, port).begin();
-  acceptor_.open(endpoint.protocol());
-  acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor_.bind(endpoint);
-  acceptor_.listen();
-
-  do_accept();
-}
-
-void server::run()
-{
-  // The io_context::run() call will block until all asynchronous operations
-  // have finished. While the server is running, there is always at least one
-  // asynchronous operation outstanding: the asynchronous accept call waiting
-  // for new incoming connections.
-  io_context_.run();
-}
-
-void server::do_accept()
-{
-  acceptor_.async_accept(
-      [this](std::error_code ec, asio::ip::tcp::socket socket)
-      {
-        // Check whether the server was stopped by a signal before this
-        // completion handler had a chance to run.
-        if (!acceptor_.is_open())
-        {
-          return;
-        }
-
-        if (!ec)
-        {
-          connection_manager_.start(std::make_shared<connection>(
-              std::move(socket), connection_manager_, request_handler_));
-        }
-
-        do_accept();
-      });
-}
-
-void server::do_await_stop()
-{
-  signals_.async_wait(
-      [this](std::error_code /*ec*/, int /*signo*/)
-      {
-        // The server is stopped by cancelling all outstanding asynchronous
-        // operations. Once all operations have finished the io_context::run()
-        // call will exit.
-        acceptor_.close();
-        connection_manager_.stop_all();
-      });
-}
-
-} // namespace server
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.hpp
deleted file mode 100644
index c88d014..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server/server.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// server.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER_HPP
-#define HTTP_SERVER_HPP
-
-#include <asio.hpp>
-#include <string>
-#include "connection.hpp"
-#include "connection_manager.hpp"
-#include "request_handler.hpp"
-
-namespace http {
-namespace server {
-
-/// The top-level class of the HTTP server.
-class server
-{
-public:
-  server(const server&) = delete;
-  server& operator=(const server&) = delete;
-
-  /// Construct the server to listen on the specified TCP address and port, and
-  /// serve up files from the given directory.
-  explicit server(const std::string& address, const std::string& port,
-      const std::string& doc_root);
-
-  /// Run the server's io_context loop.
-  void run();
-
-private:
-  /// Perform an asynchronous accept operation.
-  void do_accept();
-
-  /// Wait for a request to stop the server.
-  void do_await_stop();
-
-  /// The io_context used to perform asynchronous operations.
-  asio::io_context io_context_;
-
-  /// The signal_set is used to register for process termination notifications.
-  asio::signal_set signals_;
-
-  /// Acceptor used to listen for incoming connections.
-  asio::ip::tcp::acceptor acceptor_;
-
-  /// The connection manager which owns all live connections.
-  connection_manager connection_manager_;
-
-  /// The handler for all incoming requests.
-  request_handler request_handler_;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_SERVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.cpp
deleted file mode 100644
index ab8ab9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// connection.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "connection.hpp"
-#include <utility>
-#include "request_handler.hpp"
-
-namespace http {
-namespace server2 {
-
-connection::connection(asio::ip::tcp::socket socket,
-    request_handler& handler)
-  : socket_(std::move(socket)),
-    request_handler_(handler)
-{
-}
-
-void connection::start()
-{
-  do_read();
-}
-
-void connection::do_read()
-{
-  auto self(shared_from_this());
-  socket_.async_read_some(asio::buffer(buffer_),
-      [this, self](std::error_code ec, std::size_t bytes_transferred)
-      {
-        if (!ec)
-        {
-          request_parser::result_type result;
-          std::tie(result, std::ignore) = request_parser_.parse(
-              request_, buffer_.data(), buffer_.data() + bytes_transferred);
-
-          if (result == request_parser::good)
-          {
-            request_handler_.handle_request(request_, reply_);
-            do_write();
-          }
-          else if (result == request_parser::bad)
-          {
-            reply_ = reply::stock_reply(reply::bad_request);
-            do_write();
-          }
-          else
-          {
-            do_read();
-          }
-        }
-
-        // If an error occurs then no new asynchronous operations are
-        // started. This means that all shared_ptr references to the
-        // connection object will disappear and the object will be
-        // destroyed automatically after this handler returns. The
-        // connection class's destructor closes the socket.
-      });
-}
-
-void connection::do_write()
-{
-  auto self(shared_from_this());
-  asio::async_write(socket_, reply_.to_buffers(),
-      [this, self](std::error_code ec, std::size_t)
-      {
-        if (!ec)
-        {
-          // Initiate graceful connection closure.
-          std::error_code ignored_ec;
-          socket_.shutdown(asio::ip::tcp::socket::shutdown_both,
-            ignored_ec);
-        }
-
-        // No new asynchronous operations are started. This means that
-        // all shared_ptr references to the connection object will
-        // disappear and the object will be destroyed automatically after
-        // this handler returns. The connection class's destructor closes
-        // the socket.
-      });
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.hpp
deleted file mode 100644
index 7d4a473..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/connection.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// connection.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_CONNECTION_HPP
-#define HTTP_SERVER2_CONNECTION_HPP
-
-#include <asio.hpp>
-#include <array>
-#include <memory>
-#include "reply.hpp"
-#include "request.hpp"
-#include "request_handler.hpp"
-#include "request_parser.hpp"
-
-namespace http {
-namespace server2 {
-
-/// Represents a single connection from a client.
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  connection(const connection&) = delete;
-  connection& operator=(const connection&) = delete;
-
-  /// Construct a connection with the given socket.
-  explicit connection(asio::ip::tcp::socket socket,
-      request_handler& handler);
-
-  /// Start the first asynchronous operation for the connection.
-  void start();
-
-private:
-  /// Perform an asynchronous read operation.
-  void do_read();
-
-  /// Perform an asynchronous write operation.
-  void do_write();
-
-  /// Socket for the connection.
-  asio::ip::tcp::socket socket_;
-
-  /// The handler used to process the incoming request.
-  request_handler& request_handler_;
-
-  /// Buffer for incoming data.
-  std::array<char, 8192> buffer_;
-
-  /// The incoming request.
-  request request_;
-
-  /// The parser for the incoming request.
-  request_parser request_parser_;
-
-  /// The reply to be sent back to the client.
-  reply reply_;
-};
-
-typedef std::shared_ptr<connection> connection_ptr;
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_CONNECTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/header.hpp
deleted file mode 100644
index f888dde..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/header.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// header.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_HEADER_HPP
-#define HTTP_SERVER2_HEADER_HPP
-
-#include <string>
-
-namespace http {
-namespace server2 {
-
-struct header
-{
-  std::string name;
-  std::string value;
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.cpp
deleted file mode 100644
index bea0890..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// io_context_pool.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "server.hpp"
-#include <stdexcept>
-#include <thread>
-
-namespace http {
-namespace server2 {
-
-io_context_pool::io_context_pool(std::size_t pool_size)
-  : next_io_context_(0)
-{
-  if (pool_size == 0)
-    throw std::runtime_error("io_context_pool size is 0");
-
-  // Give all the io_contexts work to do so that their run() functions will not
-  // exit until they are explicitly stopped.
-  for (std::size_t i = 0; i < pool_size; ++i)
-  {
-    io_context_ptr io_context(new asio::io_context);
-    io_contexts_.push_back(io_context);
-    work_.push_back(asio::make_work_guard(*io_context));
-  }
-}
-
-void io_context_pool::run()
-{
-  // Create a pool of threads to run all of the io_contexts.
-  std::vector<std::thread> threads;
-  for (std::size_t i = 0; i < io_contexts_.size(); ++i)
-    threads.emplace_back([this, i]{ io_contexts_[i]->run(); });
-
-  // Wait for all threads in the pool to exit.
-  for (std::size_t i = 0; i < threads.size(); ++i)
-    threads[i].join();
-}
-
-void io_context_pool::stop()
-{
-  // Explicitly stop all io_contexts.
-  for (std::size_t i = 0; i < io_contexts_.size(); ++i)
-    io_contexts_[i]->stop();
-}
-
-asio::io_context& io_context_pool::get_io_context()
-{
-  // Use a round-robin scheme to choose the next io_context to use.
-  asio::io_context& io_context = *io_contexts_[next_io_context_];
-  ++next_io_context_;
-  if (next_io_context_ == io_contexts_.size())
-    next_io_context_ = 0;
-  return io_context;
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.hpp
deleted file mode 100644
index 0946ba6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/io_context_pool.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// io_context_pool.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_IO_SERVICE_POOL_HPP
-#define HTTP_SERVER2_IO_SERVICE_POOL_HPP
-
-#include <asio.hpp>
-#include <list>
-#include <memory>
-#include <vector>
-
-namespace http {
-namespace server2 {
-
-/// A pool of io_context objects.
-class io_context_pool
-{
-public:
-  /// Construct the io_context pool.
-  explicit io_context_pool(std::size_t pool_size);
-
-  /// Run all io_context objects in the pool.
-  void run();
-
-  /// Stop all io_context objects in the pool.
-  void stop();
-
-  /// Get an io_context to use.
-  asio::io_context& get_io_context();
-
-private:
-  io_context_pool(const io_context_pool&) = delete;
-  io_context_pool& operator=(const io_context_pool&) = delete;
-
-  typedef std::shared_ptr<asio::io_context> io_context_ptr;
-  typedef asio::executor_work_guard<
-    asio::io_context::executor_type> io_context_work;
-
-  /// The pool of io_contexts.
-  std::vector<io_context_ptr> io_contexts_;
-
-  /// The work that keeps the io_contexts running.
-  std::list<io_context_work> work_;
-
-  /// The next io_context to use for a connection.
-  std::size_t next_io_context_;
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_IO_SERVICE_POOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/main.cpp
deleted file mode 100644
index 5b6a9a3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/main.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-#include "server.hpp"
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 5)
-    {
-      std::cerr << "Usage: http_server <address> <port> <threads> <doc_root>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 80 1 .\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 80 1 .\n";
-      return 1;
-    }
-
-    // Initialise the server.
-    std::size_t num_threads = std::stoi(argv[3]);
-    http::server2::server s(argv[1], argv[2], argv[4], num_threads);
-
-    // Run the server until stopped.
-    s.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.cpp
deleted file mode 100644
index 0307933..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// mime_types.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "mime_types.hpp"
-
-namespace http {
-namespace server2 {
-namespace mime_types {
-
-struct mapping
-{
-  const char* extension;
-  const char* mime_type;
-} mappings[] =
-{
-  { "gif", "image/gif" },
-  { "htm", "text/html" },
-  { "html", "text/html" },
-  { "jpg", "image/jpeg" },
-  { "png", "image/png" },
-  { 0, 0 } // Marks end of list.
-};
-
-std::string extension_to_type(const std::string& extension)
-{
-  for (mapping* m = mappings; m->extension; ++m)
-  {
-    if (m->extension == extension)
-    {
-      return m->mime_type;
-    }
-  }
-
-  return "text/plain";
-}
-
-} // namespace mime_types
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.hpp
deleted file mode 100644
index 32985c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/mime_types.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// mime_types.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_MIME_TYPES_HPP
-#define HTTP_SERVER2_MIME_TYPES_HPP
-
-#include <string>
-
-namespace http {
-namespace server2 {
-namespace mime_types {
-
-/// Convert a file extension into a MIME type.
-std::string extension_to_type(const std::string& extension);
-
-} // namespace mime_types
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_MIME_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.cpp
deleted file mode 100644
index d48bfd9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// reply.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "reply.hpp"
-#include <string>
-
-namespace http {
-namespace server2 {
-
-namespace status_strings {
-
-const std::string ok =
-  "HTTP/1.0 200 OK\r\n";
-const std::string created =
-  "HTTP/1.0 201 Created\r\n";
-const std::string accepted =
-  "HTTP/1.0 202 Accepted\r\n";
-const std::string no_content =
-  "HTTP/1.0 204 No Content\r\n";
-const std::string multiple_choices =
-  "HTTP/1.0 300 Multiple Choices\r\n";
-const std::string moved_permanently =
-  "HTTP/1.0 301 Moved Permanently\r\n";
-const std::string moved_temporarily =
-  "HTTP/1.0 302 Moved Temporarily\r\n";
-const std::string not_modified =
-  "HTTP/1.0 304 Not Modified\r\n";
-const std::string bad_request =
-  "HTTP/1.0 400 Bad Request\r\n";
-const std::string unauthorized =
-  "HTTP/1.0 401 Unauthorized\r\n";
-const std::string forbidden =
-  "HTTP/1.0 403 Forbidden\r\n";
-const std::string not_found =
-  "HTTP/1.0 404 Not Found\r\n";
-const std::string internal_server_error =
-  "HTTP/1.0 500 Internal Server Error\r\n";
-const std::string not_implemented =
-  "HTTP/1.0 501 Not Implemented\r\n";
-const std::string bad_gateway =
-  "HTTP/1.0 502 Bad Gateway\r\n";
-const std::string service_unavailable =
-  "HTTP/1.0 503 Service Unavailable\r\n";
-
-asio::const_buffer to_buffer(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return asio::buffer(ok);
-  case reply::created:
-    return asio::buffer(created);
-  case reply::accepted:
-    return asio::buffer(accepted);
-  case reply::no_content:
-    return asio::buffer(no_content);
-  case reply::multiple_choices:
-    return asio::buffer(multiple_choices);
-  case reply::moved_permanently:
-    return asio::buffer(moved_permanently);
-  case reply::moved_temporarily:
-    return asio::buffer(moved_temporarily);
-  case reply::not_modified:
-    return asio::buffer(not_modified);
-  case reply::bad_request:
-    return asio::buffer(bad_request);
-  case reply::unauthorized:
-    return asio::buffer(unauthorized);
-  case reply::forbidden:
-    return asio::buffer(forbidden);
-  case reply::not_found:
-    return asio::buffer(not_found);
-  case reply::internal_server_error:
-    return asio::buffer(internal_server_error);
-  case reply::not_implemented:
-    return asio::buffer(not_implemented);
-  case reply::bad_gateway:
-    return asio::buffer(bad_gateway);
-  case reply::service_unavailable:
-    return asio::buffer(service_unavailable);
-  default:
-    return asio::buffer(internal_server_error);
-  }
-}
-
-} // namespace status_strings
-
-namespace misc_strings {
-
-const char name_value_separator[] = { ':', ' ' };
-const char crlf[] = { '\r', '\n' };
-
-} // namespace misc_strings
-
-std::vector<asio::const_buffer> reply::to_buffers()
-{
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(status_strings::to_buffer(status));
-  for (std::size_t i = 0; i < headers.size(); ++i)
-  {
-    header& h = headers[i];
-    buffers.push_back(asio::buffer(h.name));
-    buffers.push_back(asio::buffer(misc_strings::name_value_separator));
-    buffers.push_back(asio::buffer(h.value));
-    buffers.push_back(asio::buffer(misc_strings::crlf));
-  }
-  buffers.push_back(asio::buffer(misc_strings::crlf));
-  buffers.push_back(asio::buffer(content));
-  return buffers;
-}
-
-namespace stock_replies {
-
-const char ok[] = "";
-const char created[] =
-  "<html>"
-  "<head><title>Created</title></head>"
-  "<body><h1>201 Created</h1></body>"
-  "</html>";
-const char accepted[] =
-  "<html>"
-  "<head><title>Accepted</title></head>"
-  "<body><h1>202 Accepted</h1></body>"
-  "</html>";
-const char no_content[] =
-  "<html>"
-  "<head><title>No Content</title></head>"
-  "<body><h1>204 Content</h1></body>"
-  "</html>";
-const char multiple_choices[] =
-  "<html>"
-  "<head><title>Multiple Choices</title></head>"
-  "<body><h1>300 Multiple Choices</h1></body>"
-  "</html>";
-const char moved_permanently[] =
-  "<html>"
-  "<head><title>Moved Permanently</title></head>"
-  "<body><h1>301 Moved Permanently</h1></body>"
-  "</html>";
-const char moved_temporarily[] =
-  "<html>"
-  "<head><title>Moved Temporarily</title></head>"
-  "<body><h1>302 Moved Temporarily</h1></body>"
-  "</html>";
-const char not_modified[] =
-  "<html>"
-  "<head><title>Not Modified</title></head>"
-  "<body><h1>304 Not Modified</h1></body>"
-  "</html>";
-const char bad_request[] =
-  "<html>"
-  "<head><title>Bad Request</title></head>"
-  "<body><h1>400 Bad Request</h1></body>"
-  "</html>";
-const char unauthorized[] =
-  "<html>"
-  "<head><title>Unauthorized</title></head>"
-  "<body><h1>401 Unauthorized</h1></body>"
-  "</html>";
-const char forbidden[] =
-  "<html>"
-  "<head><title>Forbidden</title></head>"
-  "<body><h1>403 Forbidden</h1></body>"
-  "</html>";
-const char not_found[] =
-  "<html>"
-  "<head><title>Not Found</title></head>"
-  "<body><h1>404 Not Found</h1></body>"
-  "</html>";
-const char internal_server_error[] =
-  "<html>"
-  "<head><title>Internal Server Error</title></head>"
-  "<body><h1>500 Internal Server Error</h1></body>"
-  "</html>";
-const char not_implemented[] =
-  "<html>"
-  "<head><title>Not Implemented</title></head>"
-  "<body><h1>501 Not Implemented</h1></body>"
-  "</html>";
-const char bad_gateway[] =
-  "<html>"
-  "<head><title>Bad Gateway</title></head>"
-  "<body><h1>502 Bad Gateway</h1></body>"
-  "</html>";
-const char service_unavailable[] =
-  "<html>"
-  "<head><title>Service Unavailable</title></head>"
-  "<body><h1>503 Service Unavailable</h1></body>"
-  "</html>";
-
-std::string to_string(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return ok;
-  case reply::created:
-    return created;
-  case reply::accepted:
-    return accepted;
-  case reply::no_content:
-    return no_content;
-  case reply::multiple_choices:
-    return multiple_choices;
-  case reply::moved_permanently:
-    return moved_permanently;
-  case reply::moved_temporarily:
-    return moved_temporarily;
-  case reply::not_modified:
-    return not_modified;
-  case reply::bad_request:
-    return bad_request;
-  case reply::unauthorized:
-    return unauthorized;
-  case reply::forbidden:
-    return forbidden;
-  case reply::not_found:
-    return not_found;
-  case reply::internal_server_error:
-    return internal_server_error;
-  case reply::not_implemented:
-    return not_implemented;
-  case reply::bad_gateway:
-    return bad_gateway;
-  case reply::service_unavailable:
-    return service_unavailable;
-  default:
-    return internal_server_error;
-  }
-}
-
-} // namespace stock_replies
-
-reply reply::stock_reply(reply::status_type status)
-{
-  reply rep;
-  rep.status = status;
-  rep.content = stock_replies::to_string(status);
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = "text/html";
-  return rep;
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.hpp
deleted file mode 100644
index f4be7ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/reply.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// reply.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_REPLY_HPP
-#define HTTP_SERVER2_REPLY_HPP
-
-#include <string>
-#include <vector>
-#include <asio.hpp>
-#include "header.hpp"
-
-namespace http {
-namespace server2 {
-
-/// A reply to be sent to a client.
-struct reply
-{
-  /// The status of the reply.
-  enum status_type
-  {
-    ok = 200,
-    created = 201,
-    accepted = 202,
-    no_content = 204,
-    multiple_choices = 300,
-    moved_permanently = 301,
-    moved_temporarily = 302,
-    not_modified = 304,
-    bad_request = 400,
-    unauthorized = 401,
-    forbidden = 403,
-    not_found = 404,
-    internal_server_error = 500,
-    not_implemented = 501,
-    bad_gateway = 502,
-    service_unavailable = 503
-  } status;
-
-  /// The headers to be included in the reply.
-  std::vector<header> headers;
-
-  /// The content to be sent in the reply.
-  std::string content;
-
-  /// Convert the reply into a vector of buffers. The buffers do not own the
-  /// underlying memory blocks, therefore the reply object must remain valid and
-  /// not be changed until the write operation has completed.
-  std::vector<asio::const_buffer> to_buffers();
-
-  /// Get a stock reply.
-  static reply stock_reply(status_type status);
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_REPLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request.hpp
deleted file mode 100644
index b0000b0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// request.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_REQUEST_HPP
-#define HTTP_SERVER2_REQUEST_HPP
-
-#include <string>
-#include <vector>
-#include "header.hpp"
-
-namespace http {
-namespace server2 {
-
-/// A request received from a client.
-struct request
-{
-  std::string method;
-  std::string uri;
-  int http_version_major;
-  int http_version_minor;
-  std::vector<header> headers;
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_REQUEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.cpp
deleted file mode 100644
index c57fa97..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// request_handler.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_handler.hpp"
-#include <fstream>
-#include <sstream>
-#include <string>
-#include "mime_types.hpp"
-#include "reply.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server2 {
-
-request_handler::request_handler(const std::string& doc_root)
-  : doc_root_(doc_root)
-{
-}
-
-void request_handler::handle_request(const request& req, reply& rep)
-{
-  // Decode url to path.
-  std::string request_path;
-  if (!url_decode(req.uri, request_path))
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // Request path must be absolute and not contain "..".
-  if (request_path.empty() || request_path[0] != '/'
-      || request_path.find("..") != std::string::npos)
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // If path ends in slash (i.e. is a directory) then add "index.html".
-  if (request_path[request_path.size() - 1] == '/')
-  {
-    request_path += "index.html";
-  }
-
-  // Determine the file extension.
-  std::size_t last_slash_pos = request_path.find_last_of("/");
-  std::size_t last_dot_pos = request_path.find_last_of(".");
-  std::string extension;
-  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
-  {
-    extension = request_path.substr(last_dot_pos + 1);
-  }
-
-  // Open the file to send back.
-  std::string full_path = doc_root_ + request_path;
-  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
-  if (!is)
-  {
-    rep = reply::stock_reply(reply::not_found);
-    return;
-  }
-
-  // Fill out the reply to be sent to the client.
-  rep.status = reply::ok;
-  char buf[512];
-  while (is.read(buf, sizeof(buf)).gcount() > 0)
-    rep.content.append(buf, is.gcount());
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = mime_types::extension_to_type(extension);
-}
-
-bool request_handler::url_decode(const std::string& in, std::string& out)
-{
-  out.clear();
-  out.reserve(in.size());
-  for (std::size_t i = 0; i < in.size(); ++i)
-  {
-    if (in[i] == '%')
-    {
-      if (i + 3 <= in.size())
-      {
-        int value = 0;
-        std::istringstream is(in.substr(i + 1, 2));
-        if (is >> std::hex >> value)
-        {
-          out += static_cast<char>(value);
-          i += 2;
-        }
-        else
-        {
-          return false;
-        }
-      }
-      else
-      {
-        return false;
-      }
-    }
-    else if (in[i] == '+')
-    {
-      out += ' ';
-    }
-    else
-    {
-      out += in[i];
-    }
-  }
-  return true;
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.hpp
deleted file mode 100644
index c9e9ebf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_handler.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// request_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_REQUEST_HANDLER_HPP
-#define HTTP_SERVER2_REQUEST_HANDLER_HPP
-
-#include <string>
-
-namespace http {
-namespace server2 {
-
-struct reply;
-struct request;
-
-/// The common handler for all incoming requests.
-class request_handler
-{
-public:
-  request_handler(const request_handler&) = delete;
-  request_handler& operator=(const request_handler&) = delete;
-
-  /// Construct with a directory containing files to be served.
-  explicit request_handler(const std::string& doc_root);
-
-  /// Handle a request and produce a reply.
-  void handle_request(const request& req, reply& rep);
-
-private:
-  /// The directory containing the files to be served.
-  std::string doc_root_;
-
-  /// Perform URL-decoding on a string. Returns false if the encoding was
-  /// invalid.
-  static bool url_decode(const std::string& in, std::string& out);
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_REQUEST_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.cpp
deleted file mode 100644
index 2cd8ac0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-//
-// request_parser.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_parser.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server2 {
-
-request_parser::request_parser()
-  : state_(method_start)
-{
-}
-
-void request_parser::reset()
-{
-  state_ = method_start;
-}
-
-request_parser::result_type request_parser::consume(request& req, char input)
-{
-  switch (state_)
-  {
-  case method_start:
-    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = method;
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case method:
-    if (input == ' ')
-    {
-      state_ = uri;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case uri:
-    if (input == ' ')
-    {
-      state_ = http_version_h;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.uri.push_back(input);
-      return indeterminate;
-    }
-  case http_version_h:
-    if (input == 'H')
-    {
-      state_ = http_version_t_1;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_1:
-    if (input == 'T')
-    {
-      state_ = http_version_t_2;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_2:
-    if (input == 'T')
-    {
-      state_ = http_version_p;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_p:
-    if (input == 'P')
-    {
-      state_ = http_version_slash;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_slash:
-    if (input == '/')
-    {
-      req.http_version_major = 0;
-      req.http_version_minor = 0;
-      state_ = http_version_major_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major_start:
-    if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      state_ = http_version_major;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major:
-    if (input == '.')
-    {
-      state_ = http_version_minor_start;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor_start:
-    if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      state_ = http_version_minor;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_1;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_1:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_line_start:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_3;
-      return indeterminate;
-    }
-    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
-    {
-      state_ = header_lws;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.push_back(header());
-      req.headers.back().name.push_back(input);
-      state_ = header_name;
-      return indeterminate;
-    }
-  case header_lws:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (input == ' ' || input == '\t')
-    {
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = header_value;
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case header_name:
-    if (input == ':')
-    {
-      state_ = space_before_header_value;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().name.push_back(input);
-      return indeterminate;
-    }
-  case space_before_header_value:
-    if (input == ' ')
-    {
-      state_ = header_value;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_value:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case expecting_newline_2:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_3:
-    return (input == '\n') ? good : bad;
-  default:
-    return bad;
-  }
-}
-
-bool request_parser::is_char(int c)
-{
-  return c >= 0 && c <= 127;
-}
-
-bool request_parser::is_ctl(int c)
-{
-  return (c >= 0 && c <= 31) || (c == 127);
-}
-
-bool request_parser::is_tspecial(int c)
-{
-  switch (c)
-  {
-  case '(': case ')': case '<': case '>': case '@':
-  case ',': case ';': case ':': case '\\': case '"':
-  case '/': case '[': case ']': case '?': case '=':
-  case '{': case '}': case ' ': case '\t':
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool request_parser::is_digit(int c)
-{
-  return c >= '0' && c <= '9';
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.hpp
deleted file mode 100644
index 1d11168..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/request_parser.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// request_parser.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_REQUEST_PARSER_HPP
-#define HTTP_SERVER2_REQUEST_PARSER_HPP
-
-#include <tuple>
-
-namespace http {
-namespace server2 {
-
-struct request;
-
-/// Parser for incoming requests.
-class request_parser
-{
-public:
-  /// Construct ready to parse the request method.
-  request_parser();
-
-  /// Reset to initial parser state.
-  void reset();
-
-  /// Result of parse.
-  enum result_type { good, bad, indeterminate };
-
-  /// Parse some data. The enum return value is good when a complete request has
-  /// been parsed, bad if the data is invalid, indeterminate when more data is
-  /// required. The InputIterator return value indicates how much of the input
-  /// has been consumed.
-  template <typename InputIterator>
-  std::tuple<result_type, InputIterator> parse(request& req,
-      InputIterator begin, InputIterator end)
-  {
-    while (begin != end)
-    {
-      result_type result = consume(req, *begin++);
-      if (result == good || result == bad)
-        return std::make_tuple(result, begin);
-    }
-    return std::make_tuple(indeterminate, begin);
-  }
-
-private:
-  /// Handle the next character of input.
-  result_type consume(request& req, char input);
-
-  /// Check if a byte is an HTTP character.
-  static bool is_char(int c);
-
-  /// Check if a byte is an HTTP control character.
-  static bool is_ctl(int c);
-
-  /// Check if a byte is defined as an HTTP tspecial character.
-  static bool is_tspecial(int c);
-
-  /// Check if a byte is a digit.
-  static bool is_digit(int c);
-
-  /// The current state of the parser.
-  enum state
-  {
-    method_start,
-    method,
-    uri,
-    http_version_h,
-    http_version_t_1,
-    http_version_t_2,
-    http_version_p,
-    http_version_slash,
-    http_version_major_start,
-    http_version_major,
-    http_version_minor_start,
-    http_version_minor,
-    expecting_newline_1,
-    header_line_start,
-    header_lws,
-    header_name,
-    space_before_header_value,
-    header_value,
-    expecting_newline_2,
-    expecting_newline_3
-  } state_;
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_REQUEST_PARSER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.cpp
deleted file mode 100644
index 2ae7330..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "server.hpp"
-#include <signal.h>
-#include <utility>
-#include "connection.hpp"
-
-namespace http {
-namespace server2 {
-
-server::server(const std::string& address, const std::string& port,
-    const std::string& doc_root, std::size_t io_context_pool_size)
-  : io_context_pool_(io_context_pool_size),
-    signals_(io_context_pool_.get_io_context()),
-    acceptor_(io_context_pool_.get_io_context()),
-    request_handler_(doc_root)
-{
-  // Register to handle the signals that indicate when the server should exit.
-  // It is safe to register for the same signal multiple times in a program,
-  // provided all registration for the specified signal is made through Asio.
-  signals_.add(SIGINT);
-  signals_.add(SIGTERM);
-#if defined(SIGQUIT)
-  signals_.add(SIGQUIT);
-#endif // defined(SIGQUIT)
-
-  do_await_stop();
-
-  // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
-  asio::ip::tcp::resolver resolver(acceptor_.get_executor());
-  asio::ip::tcp::endpoint endpoint =
-    *resolver.resolve(address, port).begin();
-  acceptor_.open(endpoint.protocol());
-  acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor_.bind(endpoint);
-  acceptor_.listen();
-
-  do_accept();
-}
-
-void server::run()
-{
-  io_context_pool_.run();
-}
-
-void server::do_accept()
-{
-  acceptor_.async_accept(io_context_pool_.get_io_context(),
-      [this](std::error_code ec, asio::ip::tcp::socket socket)
-      {
-        // Check whether the server was stopped by a signal before this
-        // completion handler had a chance to run.
-        if (!acceptor_.is_open())
-        {
-          return;
-        }
-
-        if (!ec)
-        {
-          std::make_shared<connection>(
-              std::move(socket), request_handler_)->start();
-        }
-
-        do_accept();
-      });
-}
-
-void server::do_await_stop()
-{
-  signals_.async_wait(
-      [this](std::error_code /*ec*/, int /*signo*/)
-      {
-        io_context_pool_.stop();
-      });
-}
-
-} // namespace server2
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.hpp
deleted file mode 100644
index 9d34a77..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server2/server.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// server.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER2_SERVER_HPP
-#define HTTP_SERVER2_SERVER_HPP
-
-#include <asio.hpp>
-#include <string>
-#include "io_context_pool.hpp"
-#include "request_handler.hpp"
-
-namespace http {
-namespace server2 {
-
-/// The top-level class of the HTTP server.
-class server
-{
-public:
-  server(const server&) = delete;
-  server& operator=(const server&) = delete;
-
-  /// Construct the server to listen on the specified TCP address and port, and
-  /// serve up files from the given directory.
-  explicit server(const std::string& address, const std::string& port,
-      const std::string& doc_root, std::size_t io_context_pool_size);
-
-  /// Run the server's io_context loop.
-  void run();
-
-private:
-  /// Perform an asynchronous accept operation.
-  void do_accept();
-
-  /// Wait for a request to stop the server.
-  void do_await_stop();
-
-  /// The pool of io_context objects used to perform asynchronous operations.
-  io_context_pool io_context_pool_;
-
-  /// The signal_set is used to register for process termination notifications.
-  asio::signal_set signals_;
-
-  /// Acceptor used to listen for incoming connections.
-  asio::ip::tcp::acceptor acceptor_;
-
-  /// The handler for all incoming requests.
-  request_handler request_handler_;
-};
-
-} // namespace server2
-} // namespace http
-
-#endif // HTTP_SERVER2_SERVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.cpp
deleted file mode 100644
index d407036..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// connection.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "connection.hpp"
-#include <utility>
-#include "request_handler.hpp"
-
-namespace http {
-namespace server3 {
-
-connection::connection(asio::ip::tcp::socket socket,
-    request_handler& handler)
-  : socket_(std::move(socket)),
-    request_handler_(handler)
-{
-}
-
-void connection::start()
-{
-  do_read();
-}
-
-void connection::do_read()
-{
-  auto self(shared_from_this());
-  socket_.async_read_some(asio::buffer(buffer_),
-      [this, self](std::error_code ec, std::size_t bytes_transferred)
-      {
-        if (!ec)
-        {
-          request_parser::result_type result;
-          std::tie(result, std::ignore) = request_parser_.parse(
-              request_, buffer_.data(), buffer_.data() + bytes_transferred);
-
-          if (result == request_parser::good)
-          {
-            request_handler_.handle_request(request_, reply_);
-            do_write();
-          }
-          else if (result == request_parser::bad)
-          {
-            reply_ = reply::stock_reply(reply::bad_request);
-            do_write();
-          }
-          else
-          {
-            do_read();
-          }
-        }
-
-        // If an error occurs then no new asynchronous operations are
-        // started. This means that all shared_ptr references to the
-        // connection object will disappear and the object will be
-        // destroyed automatically after this handler returns. The
-        // connection class's destructor closes the socket.
-      });
-}
-
-void connection::do_write()
-{
-  auto self(shared_from_this());
-  asio::async_write(socket_, reply_.to_buffers(),
-      [this, self](std::error_code ec, std::size_t)
-      {
-        if (!ec)
-        {
-          // Initiate graceful connection closure.
-          std::error_code ignored_ec;
-          socket_.shutdown(asio::ip::tcp::socket::shutdown_both,
-            ignored_ec);
-        }
-
-        // No new asynchronous operations are started. This means that
-        // all shared_ptr references to the connection object will
-        // disappear and the object will be destroyed automatically after
-        // this handler returns. The connection class's destructor closes
-        // the socket.
-      });
-}
-
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.hpp
deleted file mode 100644
index 878cd45..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/connection.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// connection.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_CONNECTION_HPP
-#define HTTP_SERVER3_CONNECTION_HPP
-
-#include <asio.hpp>
-#include <array>
-#include <memory>
-#include "reply.hpp"
-#include "request.hpp"
-#include "request_handler.hpp"
-#include "request_parser.hpp"
-
-namespace http {
-namespace server3 {
-
-/// Represents a single connection from a client.
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  connection(const connection&) = delete;
-  connection& operator=(const connection&) = delete;
-
-  /// Construct a connection with the given socket.
-  explicit connection(asio::ip::tcp::socket socket,
-      request_handler& handler);
-
-  /// Start the first asynchronous operation for the connection.
-  void start();
-
-private:
-  /// Perform an asynchronous read operation.
-  void do_read();
-
-  /// Perform an asynchronous write operation.
-  void do_write();
-
-  /// Socket for the connection.
-  asio::ip::tcp::socket socket_;
-
-  /// The handler used to process the incoming request.
-  request_handler& request_handler_;
-
-  /// Buffer for incoming data.
-  std::array<char, 8192> buffer_;
-
-  /// The incoming request.
-  request request_;
-
-  /// The parser for the incoming request.
-  request_parser request_parser_;
-
-  /// The reply to be sent back to the client.
-  reply reply_;
-};
-
-typedef std::shared_ptr<connection> connection_ptr;
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_CONNECTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/header.hpp
deleted file mode 100644
index 8ab5d14..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/header.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// header.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_HEADER_HPP
-#define HTTP_SERVER3_HEADER_HPP
-
-#include <string>
-
-namespace http {
-namespace server3 {
-
-struct header
-{
-  std::string name;
-  std::string value;
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/main.cpp
deleted file mode 100644
index 243de69..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/main.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-#include "server.hpp"
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 5)
-    {
-      std::cerr << "Usage: http_server <address> <port> <threads> <doc_root>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 80 1 .\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 80 1 .\n";
-      return 1;
-    }
-
-    // Initialise the server.
-    std::size_t num_threads = std::stoi(argv[3]);
-    http::server3::server s(argv[1], argv[2], argv[4], num_threads);
-
-    // Run the server until stopped.
-    s.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.cpp
deleted file mode 100644
index d0d804c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// mime_types.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "mime_types.hpp"
-
-namespace http {
-namespace server3 {
-namespace mime_types {
-
-struct mapping
-{
-  const char* extension;
-  const char* mime_type;
-} mappings[] =
-{
-  { "gif", "image/gif" },
-  { "htm", "text/html" },
-  { "html", "text/html" },
-  { "jpg", "image/jpeg" },
-  { "png", "image/png" },
-  { 0, 0 } // Marks end of list.
-};
-
-std::string extension_to_type(const std::string& extension)
-{
-  for (mapping* m = mappings; m->extension; ++m)
-  {
-    if (m->extension == extension)
-    {
-      return m->mime_type;
-    }
-  }
-
-  return "text/plain";
-}
-
-} // namespace mime_types
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.hpp
deleted file mode 100644
index a144c86..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/mime_types.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// mime_types.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_MIME_TYPES_HPP
-#define HTTP_SERVER3_MIME_TYPES_HPP
-
-#include <string>
-
-namespace http {
-namespace server3 {
-namespace mime_types {
-
-/// Convert a file extension into a MIME type.
-std::string extension_to_type(const std::string& extension);
-
-} // namespace mime_types
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_MIME_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.cpp
deleted file mode 100644
index 4695d4a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// reply.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "reply.hpp"
-#include <string>
-
-namespace http {
-namespace server3 {
-
-namespace status_strings {
-
-const std::string ok =
-  "HTTP/1.0 200 OK\r\n";
-const std::string created =
-  "HTTP/1.0 201 Created\r\n";
-const std::string accepted =
-  "HTTP/1.0 202 Accepted\r\n";
-const std::string no_content =
-  "HTTP/1.0 204 No Content\r\n";
-const std::string multiple_choices =
-  "HTTP/1.0 300 Multiple Choices\r\n";
-const std::string moved_permanently =
-  "HTTP/1.0 301 Moved Permanently\r\n";
-const std::string moved_temporarily =
-  "HTTP/1.0 302 Moved Temporarily\r\n";
-const std::string not_modified =
-  "HTTP/1.0 304 Not Modified\r\n";
-const std::string bad_request =
-  "HTTP/1.0 400 Bad Request\r\n";
-const std::string unauthorized =
-  "HTTP/1.0 401 Unauthorized\r\n";
-const std::string forbidden =
-  "HTTP/1.0 403 Forbidden\r\n";
-const std::string not_found =
-  "HTTP/1.0 404 Not Found\r\n";
-const std::string internal_server_error =
-  "HTTP/1.0 500 Internal Server Error\r\n";
-const std::string not_implemented =
-  "HTTP/1.0 501 Not Implemented\r\n";
-const std::string bad_gateway =
-  "HTTP/1.0 502 Bad Gateway\r\n";
-const std::string service_unavailable =
-  "HTTP/1.0 503 Service Unavailable\r\n";
-
-asio::const_buffer to_buffer(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return asio::buffer(ok);
-  case reply::created:
-    return asio::buffer(created);
-  case reply::accepted:
-    return asio::buffer(accepted);
-  case reply::no_content:
-    return asio::buffer(no_content);
-  case reply::multiple_choices:
-    return asio::buffer(multiple_choices);
-  case reply::moved_permanently:
-    return asio::buffer(moved_permanently);
-  case reply::moved_temporarily:
-    return asio::buffer(moved_temporarily);
-  case reply::not_modified:
-    return asio::buffer(not_modified);
-  case reply::bad_request:
-    return asio::buffer(bad_request);
-  case reply::unauthorized:
-    return asio::buffer(unauthorized);
-  case reply::forbidden:
-    return asio::buffer(forbidden);
-  case reply::not_found:
-    return asio::buffer(not_found);
-  case reply::internal_server_error:
-    return asio::buffer(internal_server_error);
-  case reply::not_implemented:
-    return asio::buffer(not_implemented);
-  case reply::bad_gateway:
-    return asio::buffer(bad_gateway);
-  case reply::service_unavailable:
-    return asio::buffer(service_unavailable);
-  default:
-    return asio::buffer(internal_server_error);
-  }
-}
-
-} // namespace status_strings
-
-namespace misc_strings {
-
-const char name_value_separator[] = { ':', ' ' };
-const char crlf[] = { '\r', '\n' };
-
-} // namespace misc_strings
-
-std::vector<asio::const_buffer> reply::to_buffers()
-{
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(status_strings::to_buffer(status));
-  for (std::size_t i = 0; i < headers.size(); ++i)
-  {
-    header& h = headers[i];
-    buffers.push_back(asio::buffer(h.name));
-    buffers.push_back(asio::buffer(misc_strings::name_value_separator));
-    buffers.push_back(asio::buffer(h.value));
-    buffers.push_back(asio::buffer(misc_strings::crlf));
-  }
-  buffers.push_back(asio::buffer(misc_strings::crlf));
-  buffers.push_back(asio::buffer(content));
-  return buffers;
-}
-
-namespace stock_replies {
-
-const char ok[] = "";
-const char created[] =
-  "<html>"
-  "<head><title>Created</title></head>"
-  "<body><h1>201 Created</h1></body>"
-  "</html>";
-const char accepted[] =
-  "<html>"
-  "<head><title>Accepted</title></head>"
-  "<body><h1>202 Accepted</h1></body>"
-  "</html>";
-const char no_content[] =
-  "<html>"
-  "<head><title>No Content</title></head>"
-  "<body><h1>204 Content</h1></body>"
-  "</html>";
-const char multiple_choices[] =
-  "<html>"
-  "<head><title>Multiple Choices</title></head>"
-  "<body><h1>300 Multiple Choices</h1></body>"
-  "</html>";
-const char moved_permanently[] =
-  "<html>"
-  "<head><title>Moved Permanently</title></head>"
-  "<body><h1>301 Moved Permanently</h1></body>"
-  "</html>";
-const char moved_temporarily[] =
-  "<html>"
-  "<head><title>Moved Temporarily</title></head>"
-  "<body><h1>302 Moved Temporarily</h1></body>"
-  "</html>";
-const char not_modified[] =
-  "<html>"
-  "<head><title>Not Modified</title></head>"
-  "<body><h1>304 Not Modified</h1></body>"
-  "</html>";
-const char bad_request[] =
-  "<html>"
-  "<head><title>Bad Request</title></head>"
-  "<body><h1>400 Bad Request</h1></body>"
-  "</html>";
-const char unauthorized[] =
-  "<html>"
-  "<head><title>Unauthorized</title></head>"
-  "<body><h1>401 Unauthorized</h1></body>"
-  "</html>";
-const char forbidden[] =
-  "<html>"
-  "<head><title>Forbidden</title></head>"
-  "<body><h1>403 Forbidden</h1></body>"
-  "</html>";
-const char not_found[] =
-  "<html>"
-  "<head><title>Not Found</title></head>"
-  "<body><h1>404 Not Found</h1></body>"
-  "</html>";
-const char internal_server_error[] =
-  "<html>"
-  "<head><title>Internal Server Error</title></head>"
-  "<body><h1>500 Internal Server Error</h1></body>"
-  "</html>";
-const char not_implemented[] =
-  "<html>"
-  "<head><title>Not Implemented</title></head>"
-  "<body><h1>501 Not Implemented</h1></body>"
-  "</html>";
-const char bad_gateway[] =
-  "<html>"
-  "<head><title>Bad Gateway</title></head>"
-  "<body><h1>502 Bad Gateway</h1></body>"
-  "</html>";
-const char service_unavailable[] =
-  "<html>"
-  "<head><title>Service Unavailable</title></head>"
-  "<body><h1>503 Service Unavailable</h1></body>"
-  "</html>";
-
-std::string to_string(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return ok;
-  case reply::created:
-    return created;
-  case reply::accepted:
-    return accepted;
-  case reply::no_content:
-    return no_content;
-  case reply::multiple_choices:
-    return multiple_choices;
-  case reply::moved_permanently:
-    return moved_permanently;
-  case reply::moved_temporarily:
-    return moved_temporarily;
-  case reply::not_modified:
-    return not_modified;
-  case reply::bad_request:
-    return bad_request;
-  case reply::unauthorized:
-    return unauthorized;
-  case reply::forbidden:
-    return forbidden;
-  case reply::not_found:
-    return not_found;
-  case reply::internal_server_error:
-    return internal_server_error;
-  case reply::not_implemented:
-    return not_implemented;
-  case reply::bad_gateway:
-    return bad_gateway;
-  case reply::service_unavailable:
-    return service_unavailable;
-  default:
-    return internal_server_error;
-  }
-}
-
-} // namespace stock_replies
-
-reply reply::stock_reply(reply::status_type status)
-{
-  reply rep;
-  rep.status = status;
-  rep.content = stock_replies::to_string(status);
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = "text/html";
-  return rep;
-}
-
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.hpp
deleted file mode 100644
index fd9c7ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/reply.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// reply.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_REPLY_HPP
-#define HTTP_SERVER3_REPLY_HPP
-
-#include <string>
-#include <vector>
-#include <asio.hpp>
-#include "header.hpp"
-
-namespace http {
-namespace server3 {
-
-/// A reply to be sent to a client.
-struct reply
-{
-  /// The status of the reply.
-  enum status_type
-  {
-    ok = 200,
-    created = 201,
-    accepted = 202,
-    no_content = 204,
-    multiple_choices = 300,
-    moved_permanently = 301,
-    moved_temporarily = 302,
-    not_modified = 304,
-    bad_request = 400,
-    unauthorized = 401,
-    forbidden = 403,
-    not_found = 404,
-    internal_server_error = 500,
-    not_implemented = 501,
-    bad_gateway = 502,
-    service_unavailable = 503
-  } status;
-
-  /// The headers to be included in the reply.
-  std::vector<header> headers;
-
-  /// The content to be sent in the reply.
-  std::string content;
-
-  /// Convert the reply into a vector of buffers. The buffers do not own the
-  /// underlying memory blocks, therefore the reply object must remain valid and
-  /// not be changed until the write operation has completed.
-  std::vector<asio::const_buffer> to_buffers();
-
-  /// Get a stock reply.
-  static reply stock_reply(status_type status);
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_REPLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request.hpp
deleted file mode 100644
index 89a2f28..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// request.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_REQUEST_HPP
-#define HTTP_SERVER3_REQUEST_HPP
-
-#include <string>
-#include <vector>
-#include "header.hpp"
-
-namespace http {
-namespace server3 {
-
-/// A request received from a client.
-struct request
-{
-  std::string method;
-  std::string uri;
-  int http_version_major;
-  int http_version_minor;
-  std::vector<header> headers;
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_REQUEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.cpp
deleted file mode 100644
index bdc6bd6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// request_handler.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_handler.hpp"
-#include <fstream>
-#include <sstream>
-#include <string>
-#include "mime_types.hpp"
-#include "reply.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server3 {
-
-request_handler::request_handler(const std::string& doc_root)
-  : doc_root_(doc_root)
-{
-}
-
-void request_handler::handle_request(const request& req, reply& rep)
-{
-  // Decode url to path.
-  std::string request_path;
-  if (!url_decode(req.uri, request_path))
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // Request path must be absolute and not contain "..".
-  if (request_path.empty() || request_path[0] != '/'
-      || request_path.find("..") != std::string::npos)
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // If path ends in slash (i.e. is a directory) then add "index.html".
-  if (request_path[request_path.size() - 1] == '/')
-  {
-    request_path += "index.html";
-  }
-
-  // Determine the file extension.
-  std::size_t last_slash_pos = request_path.find_last_of("/");
-  std::size_t last_dot_pos = request_path.find_last_of(".");
-  std::string extension;
-  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
-  {
-    extension = request_path.substr(last_dot_pos + 1);
-  }
-
-  // Open the file to send back.
-  std::string full_path = doc_root_ + request_path;
-  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
-  if (!is)
-  {
-    rep = reply::stock_reply(reply::not_found);
-    return;
-  }
-
-  // Fill out the reply to be sent to the client.
-  rep.status = reply::ok;
-  char buf[512];
-  while (is.read(buf, sizeof(buf)).gcount() > 0)
-    rep.content.append(buf, is.gcount());
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = mime_types::extension_to_type(extension);
-}
-
-bool request_handler::url_decode(const std::string& in, std::string& out)
-{
-  out.clear();
-  out.reserve(in.size());
-  for (std::size_t i = 0; i < in.size(); ++i)
-  {
-    if (in[i] == '%')
-    {
-      if (i + 3 <= in.size())
-      {
-        int value = 0;
-        std::istringstream is(in.substr(i + 1, 2));
-        if (is >> std::hex >> value)
-        {
-          out += static_cast<char>(value);
-          i += 2;
-        }
-        else
-        {
-          return false;
-        }
-      }
-      else
-      {
-        return false;
-      }
-    }
-    else if (in[i] == '+')
-    {
-      out += ' ';
-    }
-    else
-    {
-      out += in[i];
-    }
-  }
-  return true;
-}
-
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.hpp
deleted file mode 100644
index e3fe84e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_handler.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// request_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_REQUEST_HANDLER_HPP
-#define HTTP_SERVER3_REQUEST_HANDLER_HPP
-
-#include <string>
-
-namespace http {
-namespace server3 {
-
-struct reply;
-struct request;
-
-/// The common handler for all incoming requests.
-class request_handler
-{
-public:
-  request_handler(const request_handler&) = delete;
-  request_handler& operator=(const request_handler&) = delete;
-
-  /// Construct with a directory containing files to be served.
-  explicit request_handler(const std::string& doc_root);
-
-  /// Handle a request and produce a reply.
-  void handle_request(const request& req, reply& rep);
-
-private:
-  /// The directory containing the files to be served.
-  std::string doc_root_;
-
-  /// Perform URL-decoding on a string. Returns false if the encoding was
-  /// invalid.
-  static bool url_decode(const std::string& in, std::string& out);
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_REQUEST_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.cpp
deleted file mode 100644
index 9fb6424..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-//
-// request_parser.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_parser.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server3 {
-
-request_parser::request_parser()
-  : state_(method_start)
-{
-}
-
-void request_parser::reset()
-{
-  state_ = method_start;
-}
-
-request_parser::result_type request_parser::consume(request& req, char input)
-{
-  switch (state_)
-  {
-  case method_start:
-    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = method;
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case method:
-    if (input == ' ')
-    {
-      state_ = uri;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case uri:
-    if (input == ' ')
-    {
-      state_ = http_version_h;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.uri.push_back(input);
-      return indeterminate;
-    }
-  case http_version_h:
-    if (input == 'H')
-    {
-      state_ = http_version_t_1;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_1:
-    if (input == 'T')
-    {
-      state_ = http_version_t_2;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_2:
-    if (input == 'T')
-    {
-      state_ = http_version_p;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_p:
-    if (input == 'P')
-    {
-      state_ = http_version_slash;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_slash:
-    if (input == '/')
-    {
-      req.http_version_major = 0;
-      req.http_version_minor = 0;
-      state_ = http_version_major_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major_start:
-    if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      state_ = http_version_major;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major:
-    if (input == '.')
-    {
-      state_ = http_version_minor_start;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor_start:
-    if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      state_ = http_version_minor;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_1;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_1:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_line_start:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_3;
-      return indeterminate;
-    }
-    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
-    {
-      state_ = header_lws;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.push_back(header());
-      req.headers.back().name.push_back(input);
-      state_ = header_name;
-      return indeterminate;
-    }
-  case header_lws:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (input == ' ' || input == '\t')
-    {
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = header_value;
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case header_name:
-    if (input == ':')
-    {
-      state_ = space_before_header_value;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().name.push_back(input);
-      return indeterminate;
-    }
-  case space_before_header_value:
-    if (input == ' ')
-    {
-      state_ = header_value;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_value:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case expecting_newline_2:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_3:
-    return (input == '\n') ? good : bad;
-  default:
-    return bad;
-  }
-}
-
-bool request_parser::is_char(int c)
-{
-  return c >= 0 && c <= 127;
-}
-
-bool request_parser::is_ctl(int c)
-{
-  return (c >= 0 && c <= 31) || (c == 127);
-}
-
-bool request_parser::is_tspecial(int c)
-{
-  switch (c)
-  {
-  case '(': case ')': case '<': case '>': case '@':
-  case ',': case ';': case ':': case '\\': case '"':
-  case '/': case '[': case ']': case '?': case '=':
-  case '{': case '}': case ' ': case '\t':
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool request_parser::is_digit(int c)
-{
-  return c >= '0' && c <= '9';
-}
-
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.hpp
deleted file mode 100644
index a8334ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/request_parser.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// request_parser.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_REQUEST_PARSER_HPP
-#define HTTP_SERVER3_REQUEST_PARSER_HPP
-
-#include <tuple>
-
-namespace http {
-namespace server3 {
-
-struct request;
-
-/// Parser for incoming requests.
-class request_parser
-{
-public:
-  /// Construct ready to parse the request method.
-  request_parser();
-
-  /// Reset to initial parser state.
-  void reset();
-
-  /// Result of parse.
-  enum result_type { good, bad, indeterminate };
-
-  /// Parse some data. The enum return value is good when a complete request has
-  /// been parsed, bad if the data is invalid, indeterminate when more data is
-  /// required. The InputIterator return value indicates how much of the input
-  /// has been consumed.
-  template <typename InputIterator>
-  std::tuple<result_type, InputIterator> parse(request& req,
-      InputIterator begin, InputIterator end)
-  {
-    while (begin != end)
-    {
-      result_type result = consume(req, *begin++);
-      if (result == good || result == bad)
-        return std::make_tuple(result, begin);
-    }
-    return std::make_tuple(indeterminate, begin);
-  }
-
-private:
-  /// Handle the next character of input.
-  result_type consume(request& req, char input);
-
-  /// Check if a byte is an HTTP character.
-  static bool is_char(int c);
-
-  /// Check if a byte is an HTTP control character.
-  static bool is_ctl(int c);
-
-  /// Check if a byte is defined as an HTTP tspecial character.
-  static bool is_tspecial(int c);
-
-  /// Check if a byte is a digit.
-  static bool is_digit(int c);
-
-  /// The current state of the parser.
-  enum state
-  {
-    method_start,
-    method,
-    uri,
-    http_version_h,
-    http_version_t_1,
-    http_version_t_2,
-    http_version_p,
-    http_version_slash,
-    http_version_major_start,
-    http_version_major,
-    http_version_minor_start,
-    http_version_minor,
-    expecting_newline_1,
-    header_line_start,
-    header_lws,
-    header_name,
-    space_before_header_value,
-    header_value,
-    expecting_newline_2,
-    expecting_newline_3
-  } state_;
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_REQUEST_PARSER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.cpp
deleted file mode 100644
index c8da4b4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "server.hpp"
-#include <signal.h>
-#include <thread>
-#include <utility>
-#include <vector>
-#include "connection.hpp"
-
-namespace http {
-namespace server3 {
-
-server::server(const std::string& address, const std::string& port,
-    const std::string& doc_root, std::size_t thread_pool_size)
-  : thread_pool_size_(thread_pool_size),
-    signals_(io_context_),
-    acceptor_(io_context_),
-    request_handler_(doc_root)
-{
-  // Register to handle the signals that indicate when the server should exit.
-  // It is safe to register for the same signal multiple times in a program,
-  // provided all registration for the specified signal is made through Asio.
-  signals_.add(SIGINT);
-  signals_.add(SIGTERM);
-#if defined(SIGQUIT)
-  signals_.add(SIGQUIT);
-#endif // defined(SIGQUIT)
-
-  do_await_stop();
-
-  // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
-  asio::ip::tcp::resolver resolver(io_context_);
-  asio::ip::tcp::endpoint endpoint =
-    *resolver.resolve(address, port).begin();
-  acceptor_.open(endpoint.protocol());
-  acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor_.bind(endpoint);
-  acceptor_.listen();
-
-  do_accept();
-}
-
-void server::run()
-{
-  // Create a pool of threads to run the io_context.
-  std::vector<std::thread> threads;
-  for (std::size_t i = 0; i < thread_pool_size_; ++i)
-    threads.emplace_back([this]{ io_context_.run(); });
-
-  // Wait for all threads in the pool to exit.
-  for (std::size_t i = 0; i < threads.size(); ++i)
-    threads[i].join();
-}
-
-void server::do_accept()
-{
-  // The newly accepted socket is put into its own strand to ensure that all
-  // completion handlers associated with the connection do not run concurrently.
-  acceptor_.async_accept(asio::make_strand(io_context_),
-      [this](std::error_code ec, asio::ip::tcp::socket socket)
-      {
-        // Check whether the server was stopped by a signal before this
-        // completion handler had a chance to run.
-        if (!acceptor_.is_open())
-        {
-          return;
-        }
-
-        if (!ec)
-        {
-          std::make_shared<connection>(
-              std::move(socket), request_handler_)->start();
-        }
-
-        do_accept();
-      });
-}
-
-void server::do_await_stop()
-{
-  signals_.async_wait(
-      [this](std::error_code /*ec*/, int /*signo*/)
-      {
-        io_context_.stop();
-      });
-}
-
-} // namespace server3
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.hpp
deleted file mode 100644
index 2948cad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server3/server.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// server.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER3_SERVER_HPP
-#define HTTP_SERVER3_SERVER_HPP
-
-#include <asio.hpp>
-#include <string>
-#include "request_handler.hpp"
-
-namespace http {
-namespace server3 {
-
-/// The top-level class of the HTTP server.
-class server
-{
-public:
-  server(const server&) = delete;
-  server& operator=(const server&) = delete;
-
-  /// Construct the server to listen on the specified TCP address and port, and
-  /// serve up files from the given directory.
-  explicit server(const std::string& address, const std::string& port,
-      const std::string& doc_root, std::size_t thread_pool_size);
-
-  /// Run the server's io_context loop.
-  void run();
-
-private:
-  /// Perform an asynchronous accept operation.
-  void do_accept();
-
-  /// Wait for a request to stop the server.
-  void do_await_stop();
-
-  /// The number of threads that will call io_context::run().
-  std::size_t thread_pool_size_;
-
-  /// The io_context used to perform asynchronous operations.
-  asio::io_context io_context_;
-
-  /// The signal_set is used to register for process termination notifications.
-  asio::signal_set signals_;
-
-  /// Acceptor used to listen for incoming connections.
-  asio::ip::tcp::acceptor acceptor_;
-
-  /// The handler for all incoming requests.
-  request_handler request_handler_;
-};
-
-} // namespace server3
-} // namespace http
-
-#endif // HTTP_SERVER3_SERVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.cpp
deleted file mode 100644
index ad982e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// file_handler.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "file_handler.hpp"
-#include <fstream>
-#include <sstream>
-#include <string>
-#include "mime_types.hpp"
-#include "reply.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server4 {
-
-file_handler::file_handler(const std::string& doc_root)
-  : doc_root_(doc_root)
-{
-}
-
-void file_handler::operator()(const request& req, reply& rep)
-{
-  // Decode url to path.
-  std::string request_path;
-  if (!url_decode(req.uri, request_path))
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // Request path must be absolute and not contain "..".
-  if (request_path.empty() || request_path[0] != '/'
-      || request_path.find("..") != std::string::npos)
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // If path ends in slash (i.e. is a directory) then add "index.html".
-  if (request_path[request_path.size() - 1] == '/')
-  {
-    request_path += "index.html";
-  }
-
-  // Determine the file extension.
-  std::size_t last_slash_pos = request_path.find_last_of("/");
-  std::size_t last_dot_pos = request_path.find_last_of(".");
-  std::string extension;
-  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
-  {
-    extension = request_path.substr(last_dot_pos + 1);
-  }
-
-  // Open the file to send back.
-  std::string full_path = doc_root_ + request_path;
-  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
-  if (!is)
-  {
-    rep = reply::stock_reply(reply::not_found);
-    return;
-  }
-
-  // Fill out the reply to be sent to the client.
-  rep.status = reply::ok;
-  char buf[512];
-  while (is.read(buf, sizeof(buf)).gcount() > 0)
-    rep.content.append(buf, is.gcount());
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = mime_types::extension_to_type(extension);
-}
-
-bool file_handler::url_decode(const std::string& in, std::string& out)
-{
-  out.clear();
-  out.reserve(in.size());
-  for (std::size_t i = 0; i < in.size(); ++i)
-  {
-    if (in[i] == '%')
-    {
-      if (i + 3 <= in.size())
-      {
-        int value = 0;
-        std::istringstream is(in.substr(i + 1, 2));
-        if (is >> std::hex >> value)
-        {
-          out += static_cast<char>(value);
-          i += 2;
-        }
-        else
-        {
-          return false;
-        }
-      }
-      else
-      {
-        return false;
-      }
-    }
-    else if (in[i] == '+')
-    {
-      out += ' ';
-    }
-    else
-    {
-      out += in[i];
-    }
-  }
-  return true;
-}
-
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.hpp
deleted file mode 100644
index a16e5b6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/file_handler.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// file_handler.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_FILE_HANDLER_HPP
-#define HTTP_SERVER4_FILE_HANDLER_HPP
-
-#include <string>
-
-namespace http {
-namespace server4 {
-
-struct reply;
-struct request;
-
-/// The common handler for all incoming requests.
-class file_handler
-{
-public:
-  /// Construct with a directory containing files to be served.
-  explicit file_handler(const std::string& doc_root);
-
-  /// Handle a request and produce a reply.
-  void operator()(const request& req, reply& rep);
-
-private:
-  /// The directory containing the files to be served.
-  std::string doc_root_;
-
-  /// Perform URL-decoding on a string. Returns false if the encoding was
-  /// invalid.
-  static bool url_decode(const std::string& in, std::string& out);
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_FILE_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/header.hpp
deleted file mode 100644
index a4148e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/header.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// header.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_HEADER_HPP
-#define HTTP_SERVER4_HEADER_HPP
-
-#include <string>
-
-namespace http {
-namespace server4 {
-
-struct header
-{
-  std::string name;
-  std::string value;
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/main.cpp
deleted file mode 100644
index 29706e6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/main.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <asio.hpp>
-#include <signal.h>
-#include "server.hpp"
-#include "file_handler.hpp"
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 4)
-    {
-      std::cerr << "Usage: http_server <address> <port> <doc_root>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 80 .\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 80 .\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    // Launch the initial server coroutine.
-    http::server4::server(io_context, argv[1], argv[2],
-        http::server4::file_handler(argv[3]))();
-
-    // Wait for signals indicating time to shut down.
-    asio::signal_set signals(io_context);
-    signals.add(SIGINT);
-    signals.add(SIGTERM);
-#if defined(SIGQUIT)
-    signals.add(SIGQUIT);
-#endif // defined(SIGQUIT)
-    signals.async_wait(
-        [&io_context](std::error_code, int)
-        {
-          io_context.stop();
-        });
-
-    // Run the server.
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.cpp
deleted file mode 100644
index 6cf11e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// mime_types.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "mime_types.hpp"
-
-namespace http {
-namespace server4 {
-namespace mime_types {
-
-struct mapping
-{
-  const char* extension;
-  const char* mime_type;
-} mappings[] =
-{
-  { "gif", "image/gif" },
-  { "htm", "text/html" },
-  { "html", "text/html" },
-  { "jpg", "image/jpeg" },
-  { "png", "image/png" },
-  { 0, 0 } // Marks end of list.
-};
-
-std::string extension_to_type(const std::string& extension)
-{
-  for (mapping* m = mappings; m->extension; ++m)
-  {
-    if (m->extension == extension)
-    {
-      return m->mime_type;
-    }
-  }
-
-  return "text/plain";
-}
-
-} // namespace mime_types
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.hpp
deleted file mode 100644
index 6086fce..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/mime_types.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// mime_types.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_MIME_TYPES_HPP
-#define HTTP_SERVER4_MIME_TYPES_HPP
-
-#include <string>
-
-namespace http {
-namespace server4 {
-namespace mime_types {
-
-/// Convert a file extension into a MIME type.
-std::string extension_to_type(const std::string& extension);
-
-} // namespace mime_types
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_MIME_TYPES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.cpp
deleted file mode 100644
index 4e5752e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// reply.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "reply.hpp"
-#include <string>
-
-namespace http {
-namespace server4 {
-
-namespace status_strings {
-
-const std::string ok =
-  "HTTP/1.0 200 OK\r\n";
-const std::string created =
-  "HTTP/1.0 201 Created\r\n";
-const std::string accepted =
-  "HTTP/1.0 202 Accepted\r\n";
-const std::string no_content =
-  "HTTP/1.0 204 No Content\r\n";
-const std::string multiple_choices =
-  "HTTP/1.0 300 Multiple Choices\r\n";
-const std::string moved_permanently =
-  "HTTP/1.0 301 Moved Permanently\r\n";
-const std::string moved_temporarily =
-  "HTTP/1.0 302 Moved Temporarily\r\n";
-const std::string not_modified =
-  "HTTP/1.0 304 Not Modified\r\n";
-const std::string bad_request =
-  "HTTP/1.0 400 Bad Request\r\n";
-const std::string unauthorized =
-  "HTTP/1.0 401 Unauthorized\r\n";
-const std::string forbidden =
-  "HTTP/1.0 403 Forbidden\r\n";
-const std::string not_found =
-  "HTTP/1.0 404 Not Found\r\n";
-const std::string internal_server_error =
-  "HTTP/1.0 500 Internal Server Error\r\n";
-const std::string not_implemented =
-  "HTTP/1.0 501 Not Implemented\r\n";
-const std::string bad_gateway =
-  "HTTP/1.0 502 Bad Gateway\r\n";
-const std::string service_unavailable =
-  "HTTP/1.0 503 Service Unavailable\r\n";
-
-asio::const_buffer to_buffer(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return asio::buffer(ok);
-  case reply::created:
-    return asio::buffer(created);
-  case reply::accepted:
-    return asio::buffer(accepted);
-  case reply::no_content:
-    return asio::buffer(no_content);
-  case reply::multiple_choices:
-    return asio::buffer(multiple_choices);
-  case reply::moved_permanently:
-    return asio::buffer(moved_permanently);
-  case reply::moved_temporarily:
-    return asio::buffer(moved_temporarily);
-  case reply::not_modified:
-    return asio::buffer(not_modified);
-  case reply::bad_request:
-    return asio::buffer(bad_request);
-  case reply::unauthorized:
-    return asio::buffer(unauthorized);
-  case reply::forbidden:
-    return asio::buffer(forbidden);
-  case reply::not_found:
-    return asio::buffer(not_found);
-  case reply::internal_server_error:
-    return asio::buffer(internal_server_error);
-  case reply::not_implemented:
-    return asio::buffer(not_implemented);
-  case reply::bad_gateway:
-    return asio::buffer(bad_gateway);
-  case reply::service_unavailable:
-    return asio::buffer(service_unavailable);
-  default:
-    return asio::buffer(internal_server_error);
-  }
-}
-
-} // namespace status_strings
-
-namespace misc_strings {
-
-const char name_value_separator[] = { ':', ' ' };
-const char crlf[] = { '\r', '\n' };
-
-} // namespace misc_strings
-
-std::vector<asio::const_buffer> reply::to_buffers()
-{
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(status_strings::to_buffer(status));
-  for (std::size_t i = 0; i < headers.size(); ++i)
-  {
-    header& h = headers[i];
-    buffers.push_back(asio::buffer(h.name));
-    buffers.push_back(asio::buffer(misc_strings::name_value_separator));
-    buffers.push_back(asio::buffer(h.value));
-    buffers.push_back(asio::buffer(misc_strings::crlf));
-  }
-  buffers.push_back(asio::buffer(misc_strings::crlf));
-  buffers.push_back(asio::buffer(content));
-  return buffers;
-}
-
-namespace stock_replies {
-
-const char ok[] = "";
-const char created[] =
-  "<html>"
-  "<head><title>Created</title></head>"
-  "<body><h1>201 Created</h1></body>"
-  "</html>";
-const char accepted[] =
-  "<html>"
-  "<head><title>Accepted</title></head>"
-  "<body><h1>202 Accepted</h1></body>"
-  "</html>";
-const char no_content[] =
-  "<html>"
-  "<head><title>No Content</title></head>"
-  "<body><h1>204 Content</h1></body>"
-  "</html>";
-const char multiple_choices[] =
-  "<html>"
-  "<head><title>Multiple Choices</title></head>"
-  "<body><h1>300 Multiple Choices</h1></body>"
-  "</html>";
-const char moved_permanently[] =
-  "<html>"
-  "<head><title>Moved Permanently</title></head>"
-  "<body><h1>301 Moved Permanently</h1></body>"
-  "</html>";
-const char moved_temporarily[] =
-  "<html>"
-  "<head><title>Moved Temporarily</title></head>"
-  "<body><h1>302 Moved Temporarily</h1></body>"
-  "</html>";
-const char not_modified[] =
-  "<html>"
-  "<head><title>Not Modified</title></head>"
-  "<body><h1>304 Not Modified</h1></body>"
-  "</html>";
-const char bad_request[] =
-  "<html>"
-  "<head><title>Bad Request</title></head>"
-  "<body><h1>400 Bad Request</h1></body>"
-  "</html>";
-const char unauthorized[] =
-  "<html>"
-  "<head><title>Unauthorized</title></head>"
-  "<body><h1>401 Unauthorized</h1></body>"
-  "</html>";
-const char forbidden[] =
-  "<html>"
-  "<head><title>Forbidden</title></head>"
-  "<body><h1>403 Forbidden</h1></body>"
-  "</html>";
-const char not_found[] =
-  "<html>"
-  "<head><title>Not Found</title></head>"
-  "<body><h1>404 Not Found</h1></body>"
-  "</html>";
-const char internal_server_error[] =
-  "<html>"
-  "<head><title>Internal Server Error</title></head>"
-  "<body><h1>500 Internal Server Error</h1></body>"
-  "</html>";
-const char not_implemented[] =
-  "<html>"
-  "<head><title>Not Implemented</title></head>"
-  "<body><h1>501 Not Implemented</h1></body>"
-  "</html>";
-const char bad_gateway[] =
-  "<html>"
-  "<head><title>Bad Gateway</title></head>"
-  "<body><h1>502 Bad Gateway</h1></body>"
-  "</html>";
-const char service_unavailable[] =
-  "<html>"
-  "<head><title>Service Unavailable</title></head>"
-  "<body><h1>503 Service Unavailable</h1></body>"
-  "</html>";
-
-std::string to_string(reply::status_type status)
-{
-  switch (status)
-  {
-  case reply::ok:
-    return ok;
-  case reply::created:
-    return created;
-  case reply::accepted:
-    return accepted;
-  case reply::no_content:
-    return no_content;
-  case reply::multiple_choices:
-    return multiple_choices;
-  case reply::moved_permanently:
-    return moved_permanently;
-  case reply::moved_temporarily:
-    return moved_temporarily;
-  case reply::not_modified:
-    return not_modified;
-  case reply::bad_request:
-    return bad_request;
-  case reply::unauthorized:
-    return unauthorized;
-  case reply::forbidden:
-    return forbidden;
-  case reply::not_found:
-    return not_found;
-  case reply::internal_server_error:
-    return internal_server_error;
-  case reply::not_implemented:
-    return not_implemented;
-  case reply::bad_gateway:
-    return bad_gateway;
-  case reply::service_unavailable:
-    return service_unavailable;
-  default:
-    return internal_server_error;
-  }
-}
-
-} // namespace stock_replies
-
-reply reply::stock_reply(reply::status_type status)
-{
-  reply rep;
-  rep.status = status;
-  rep.content = stock_replies::to_string(status);
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = "text/html";
-  return rep;
-}
-
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.hpp
deleted file mode 100644
index d08579a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/reply.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// reply.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_REPLY_HPP
-#define HTTP_SERVER4_REPLY_HPP
-
-#include <string>
-#include <vector>
-#include <asio.hpp>
-#include "header.hpp"
-
-namespace http {
-namespace server4 {
-
-/// A reply to be sent to a client.
-struct reply
-{
-  /// The status of the reply.
-  enum status_type
-  {
-    ok = 200,
-    created = 201,
-    accepted = 202,
-    no_content = 204,
-    multiple_choices = 300,
-    moved_permanently = 301,
-    moved_temporarily = 302,
-    not_modified = 304,
-    bad_request = 400,
-    unauthorized = 401,
-    forbidden = 403,
-    not_found = 404,
-    internal_server_error = 500,
-    not_implemented = 501,
-    bad_gateway = 502,
-    service_unavailable = 503
-  } status;
-
-  /// The headers to be included in the reply.
-  std::vector<header> headers;
-
-  /// The content to be sent in the reply.
-  std::string content;
-
-  /// Convert the reply into a vector of buffers. The buffers do not own the
-  /// underlying memory blocks, therefore the reply object must remain valid and
-  /// not be changed until the write operation has completed.
-  std::vector<asio::const_buffer> to_buffers();
-
-  /// Get a stock reply.
-  static reply stock_reply(status_type status);
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_REPLY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request.hpp
deleted file mode 100644
index 8b20c4d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// request.hpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_REQUEST_HPP
-#define HTTP_SERVER4_REQUEST_HPP
-
-#include <string>
-#include <vector>
-#include "header.hpp"
-
-namespace http {
-namespace server4 {
-
-/// A request received from a client.
-struct request
-{
-  std::string method;
-  std::string uri;
-  int http_version_major;
-  int http_version_minor;
-  std::vector<header> headers;
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_REQUEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.cpp
deleted file mode 100644
index a0e87c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// request_handler.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_handler.hpp"
-#include <fstream>
-#include <sstream>
-#include <string>
-#include "mime_types.hpp"
-#include "reply.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server4 {
-
-request_handler::request_handler(const std::string& doc_root)
-  : doc_root_(doc_root)
-{
-}
-
-void request_handler::handle_request(const request& req, reply& rep)
-{
-  // Decode url to path.
-  std::string request_path;
-  if (!url_decode(req.uri, request_path))
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // Request path must be absolute and not contain "..".
-  if (request_path.empty() || request_path[0] != '/'
-      || request_path.find("..") != std::string::npos)
-  {
-    rep = reply::stock_reply(reply::bad_request);
-    return;
-  }
-
-  // If path ends in slash (i.e. is a directory) then add "index.html".
-  if (request_path[request_path.size() - 1] == '/')
-  {
-    request_path += "index.html";
-  }
-
-  // Determine the file extension.
-  std::size_t last_slash_pos = request_path.find_last_of("/");
-  std::size_t last_dot_pos = request_path.find_last_of(".");
-  std::string extension;
-  if (last_dot_pos != std::string::npos && last_dot_pos > last_slash_pos)
-  {
-    extension = request_path.substr(last_dot_pos + 1);
-  }
-
-  // Open the file to send back.
-  std::string full_path = doc_root_ + request_path;
-  std::ifstream is(full_path.c_str(), std::ios::in | std::ios::binary);
-  if (!is)
-  {
-    rep = reply::stock_reply(reply::not_found);
-    return;
-  }
-
-  // Fill out the reply to be sent to the client.
-  rep.status = reply::ok;
-  char buf[512];
-  while (is.read(buf, sizeof(buf)).gcount() > 0)
-    rep.content.append(buf, is.gcount());
-  rep.headers.resize(2);
-  rep.headers[0].name = "Content-Length";
-  rep.headers[0].value = std::to_string(rep.content.size());
-  rep.headers[1].name = "Content-Type";
-  rep.headers[1].value = mime_types::extension_to_type(extension);
-}
-
-bool request_handler::url_decode(const std::string& in, std::string& out)
-{
-  out.clear();
-  out.reserve(in.size());
-  for (std::size_t i = 0; i < in.size(); ++i)
-  {
-    if (in[i] == '%')
-    {
-      if (i + 3 <= in.size())
-      {
-        int value = 0;
-        std::istringstream is(in.substr(i + 1, 2));
-        if (is >> std::hex >> value)
-        {
-          out += static_cast<char>(value);
-          i += 2;
-        }
-        else
-        {
-          return false;
-        }
-      }
-      else
-      {
-        return false;
-      }
-    }
-    else if (in[i] == '+')
-    {
-      out += ' ';
-    }
-    else
-    {
-      out += in[i];
-    }
-  }
-  return true;
-}
-
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.hpp
deleted file mode 100644
index 8881703..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_handler.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// request_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_REQUEST_HANDLER_HPP
-#define HTTP_SERVER4_REQUEST_HANDLER_HPP
-
-#include <string>
-
-namespace http {
-namespace server4 {
-
-struct reply;
-struct request;
-
-/// The common handler for all incoming requests.
-class request_handler
-{
-public:
-  request_handler(const request_handler&) = delete;
-  request_handler& operator=(const request_handler&) = delete;
-
-  /// Construct with a directory containing files to be served.
-  explicit request_handler(const std::string& doc_root);
-
-  /// Handle a request and produce a reply.
-  void handle_request(const request& req, reply& rep);
-
-private:
-  /// The directory containing the files to be served.
-  std::string doc_root_;
-
-  /// Perform URL-decoding on a string. Returns false if the encoding was
-  /// invalid.
-  static bool url_decode(const std::string& in, std::string& out);
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_REQUEST_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.cpp
deleted file mode 100644
index ec557fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.cpp
+++ /dev/null
@@ -1,315 +0,0 @@
-//
-// request_parser.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "request_parser.hpp"
-#include "request.hpp"
-
-namespace http {
-namespace server4 {
-
-request_parser::request_parser()
-  : state_(method_start)
-{
-}
-
-void request_parser::reset()
-{
-  state_ = method_start;
-}
-
-request_parser::result_type request_parser::consume(request& req, char input)
-{
-  switch (state_)
-  {
-  case method_start:
-    if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = method;
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case method:
-    if (input == ' ')
-    {
-      state_ = uri;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.method.push_back(input);
-      return indeterminate;
-    }
-  case uri:
-    if (input == ' ')
-    {
-      state_ = http_version_h;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.uri.push_back(input);
-      return indeterminate;
-    }
-  case http_version_h:
-    if (input == 'H')
-    {
-      state_ = http_version_t_1;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_1:
-    if (input == 'T')
-    {
-      state_ = http_version_t_2;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_t_2:
-    if (input == 'T')
-    {
-      state_ = http_version_p;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_p:
-    if (input == 'P')
-    {
-      state_ = http_version_slash;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_slash:
-    if (input == '/')
-    {
-      req.http_version_major = 0;
-      req.http_version_minor = 0;
-      state_ = http_version_major_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major_start:
-    if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      state_ = http_version_major;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_major:
-    if (input == '.')
-    {
-      state_ = http_version_minor_start;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_major = req.http_version_major * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor_start:
-    if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      state_ = http_version_minor;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case http_version_minor:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_1;
-      return indeterminate;
-    }
-    else if (is_digit(input))
-    {
-      req.http_version_minor = req.http_version_minor * 10 + input - '0';
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_1:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_line_start:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_3;
-      return indeterminate;
-    }
-    else if (!req.headers.empty() && (input == ' ' || input == '\t'))
-    {
-      state_ = header_lws;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.push_back(header());
-      req.headers.back().name.push_back(input);
-      state_ = header_name;
-      return indeterminate;
-    }
-  case header_lws:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (input == ' ' || input == '\t')
-    {
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      state_ = header_value;
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case header_name:
-    if (input == ':')
-    {
-      state_ = space_before_header_value;
-      return indeterminate;
-    }
-    else if (!is_char(input) || is_ctl(input) || is_tspecial(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().name.push_back(input);
-      return indeterminate;
-    }
-  case space_before_header_value:
-    if (input == ' ')
-    {
-      state_ = header_value;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case header_value:
-    if (input == '\r')
-    {
-      state_ = expecting_newline_2;
-      return indeterminate;
-    }
-    else if (is_ctl(input))
-    {
-      return bad;
-    }
-    else
-    {
-      req.headers.back().value.push_back(input);
-      return indeterminate;
-    }
-  case expecting_newline_2:
-    if (input == '\n')
-    {
-      state_ = header_line_start;
-      return indeterminate;
-    }
-    else
-    {
-      return bad;
-    }
-  case expecting_newline_3:
-    return (input == '\n') ? good : bad;
-  default:
-    return bad;
-  }
-}
-
-bool request_parser::is_char(int c)
-{
-  return c >= 0 && c <= 127;
-}
-
-bool request_parser::is_ctl(int c)
-{
-  return (c >= 0 && c <= 31) || (c == 127);
-}
-
-bool request_parser::is_tspecial(int c)
-{
-  switch (c)
-  {
-  case '(': case ')': case '<': case '>': case '@':
-  case ',': case ';': case ':': case '\\': case '"':
-  case '/': case '[': case ']': case '?': case '=':
-  case '{': case '}': case ' ': case '\t':
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool request_parser::is_digit(int c)
-{
-  return c >= '0' && c <= '9';
-}
-
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.hpp
deleted file mode 100644
index 4129c48..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/request_parser.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// request_parser.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_REQUEST_PARSER_HPP
-#define HTTP_SERVER4_REQUEST_PARSER_HPP
-
-#include <tuple>
-
-namespace http {
-namespace server4 {
-
-struct request;
-
-/// Parser for incoming requests.
-class request_parser
-{
-public:
-  /// Construct ready to parse the request method.
-  request_parser();
-
-  /// Reset to initial parser state.
-  void reset();
-
-  /// Result of parse.
-  enum result_type { good, bad, indeterminate };
-
-  /// Parse some data. The enum return value is good when a complete request has
-  /// been parsed, bad if the data is invalid, indeterminate when more data is
-  /// required. The InputIterator return value indicates how much of the input
-  /// has been consumed.
-  template <typename InputIterator>
-  std::tuple<result_type, InputIterator> parse(request& req,
-      InputIterator begin, InputIterator end)
-  {
-    while (begin != end)
-    {
-      result_type result = consume(req, *begin++);
-      if (result == good || result == bad)
-        return std::make_tuple(result, begin);
-    }
-    return std::make_tuple(indeterminate, begin);
-  }
-
-private:
-  /// Handle the next character of input.
-  result_type consume(request& req, char input);
-
-  /// Check if a byte is an HTTP character.
-  static bool is_char(int c);
-
-  /// Check if a byte is an HTTP control character.
-  static bool is_ctl(int c);
-
-  /// Check if a byte is defined as an HTTP tspecial character.
-  static bool is_tspecial(int c);
-
-  /// Check if a byte is a digit.
-  static bool is_digit(int c);
-
-  /// The current state of the parser.
-  enum state
-  {
-    method_start,
-    method,
-    uri,
-    http_version_h,
-    http_version_t_1,
-    http_version_t_2,
-    http_version_p,
-    http_version_slash,
-    http_version_major_start,
-    http_version_major,
-    http_version_minor_start,
-    http_version_minor,
-    expecting_newline_1,
-    header_line_start,
-    header_lws,
-    header_name,
-    space_before_header_value,
-    header_value,
-    expecting_newline_2,
-    expecting_newline_3
-  } state_;
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_REQUEST_PARSER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.cpp
deleted file mode 100644
index 9c75f75..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "server.hpp"
-#include "request.hpp"
-#include "reply.hpp"
-
-namespace http {
-namespace server4 {
-
-server::server(asio::io_context& io_context,
-    const std::string& address, const std::string& port,
-    std::function<void(const request&, reply&)> request_handler)
-  : request_handler_(request_handler)
-{
-  tcp::resolver resolver(io_context);
-  asio::ip::tcp::endpoint endpoint =
-    *resolver.resolve(address, port).begin();
-  acceptor_.reset(new tcp::acceptor(io_context, endpoint));
-}
-
-// Enable the pseudo-keywords reenter, yield and fork.
-#include <asio/yield.hpp>
-
-void server::operator()(std::error_code ec, std::size_t length)
-{
-  // In this example we keep the error handling code in one place by
-  // hoisting it outside the coroutine. An alternative approach would be to
-  // check the value of ec after each yield for an asynchronous operation.
-  if (!ec)
-  {
-    // On reentering a coroutine, control jumps to the location of the last
-    // yield or fork. The argument to the "reenter" pseudo-keyword can be a
-    // pointer or reference to an object of type coroutine.
-    reenter (this)
-    {
-      // Loop to accept incoming connections.
-      do
-      {
-        // Create a new socket for the next incoming connection.
-        socket_.reset(new tcp::socket(acceptor_->get_executor()));
-
-        // Accept a new connection. The "yield" pseudo-keyword saves the current
-        // line number and exits the coroutine's "reenter" block. We use the
-        // server coroutine as the completion handler for the async_accept
-        // operation. When the asynchronous operation completes, the io_context
-        // invokes the function call operator, we "reenter" the coroutine, and
-        // then control resumes at the following line.
-        yield acceptor_->async_accept(*socket_, *this);
-
-        // We "fork" by cloning a new server coroutine to handle the connection.
-        // After forking we have a parent coroutine and a child coroutine. Both
-        // parent and child continue execution at the following line. They can
-        // be distinguished using the functions coroutine::is_parent() and
-        // coroutine::is_child().
-        fork server(*this)();
-
-        // The parent continues looping to accept the next incoming connection.
-        // The child exits the loop and processes the connection.
-      } while (is_parent());
-
-      // Create the objects needed to receive a request on the connection.
-      buffer_.reset(new std::array<char, 8192>);
-      request_.reset(new request);
-
-      // Loop until a complete request (or an invalid one) has been received.
-      do
-      {
-        // Receive some more data. When control resumes at the following line,
-        // the ec and length parameters reflect the result of the asynchronous
-        // operation.
-        yield socket_->async_read_some(asio::buffer(*buffer_), *this);
-
-        // Parse the data we just received.
-        std::tie(parse_result_, std::ignore)
-          = request_parser_.parse(*request_,
-              buffer_->data(), buffer_->data() + length);
-
-        // An indeterminate result means we need more data, so keep looping.
-      } while (parse_result_ == request_parser::indeterminate);
-
-      // Create the reply object that will be sent back to the client.
-      reply_.reset(new reply);
-
-      if (parse_result_ == request_parser::good)
-      {
-        // A valid request was received. Call the user-supplied function object
-        // to process the request and compose a reply.
-        request_handler_(*request_, *reply_);
-      }
-      else
-      {
-        // The request was invalid.
-        *reply_ = reply::stock_reply(reply::bad_request);
-      }
-
-      // Send the reply back to the client.
-      yield asio::async_write(*socket_, reply_->to_buffers(), *this);
-
-      // Initiate graceful connection closure.
-      socket_->shutdown(tcp::socket::shutdown_both, ec);
-    }
-  }
-
-  // If an error occurs then the coroutine is not reentered. Consequently, no
-  // new asynchronous operations are started. This means that all shared_ptr
-  // references will disappear and the resources associated with the coroutine
-  // will be destroyed automatically after this function call returns.
-}
-
-// Disable the pseudo-keywords reenter, yield and fork.
-#include <asio/unyield.hpp>
-
-} // namespace server4
-} // namespace http
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.hpp
deleted file mode 100644
index 54d6783..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/http/server4/server.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// server.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HTTP_SERVER4_SERVER_HPP
-#define HTTP_SERVER4_SERVER_HPP
-
-#include <asio.hpp>
-#include <array>
-#include <functional>
-#include <memory>
-#include <string>
-#include "request_parser.hpp"
-
-namespace http {
-namespace server4 {
-
-struct request;
-struct reply;
-
-/// The top-level coroutine of the HTTP server.
-class server : asio::coroutine
-{
-public:
-  /// Construct the server to listen on the specified TCP address and port, and
-  /// serve up files from the given directory.
-  explicit server(asio::io_context& io_context,
-      const std::string& address, const std::string& port,
-      std::function<void(const request&, reply&)> request_handler);
-
-  /// Perform work associated with the server.
-  void operator()(
-      std::error_code ec = std::error_code(),
-      std::size_t length = 0);
-
-private:
-  typedef asio::ip::tcp tcp;
-
-  /// The user-supplied handler for all incoming requests.
-  std::function<void(const request&, reply&)> request_handler_;
-
-  /// Acceptor used to listen for incoming connections.
-  std::shared_ptr<tcp::acceptor> acceptor_;
-
-  /// The current connection from a client.
-  std::shared_ptr<tcp::socket> socket_;
-
-  /// Buffer for incoming data.
-  std::shared_ptr<std::array<char, 8192>> buffer_;
-
-  /// The incoming request.
-  std::shared_ptr<request> request_;
-
-  /// Whether the request is valid or not.
-  request_parser::result_type parse_result_;
-
-  /// The parser for the incoming request.
-  request_parser request_parser_;
-
-  /// The reply to be sent back to the client.
-  std::shared_ptr<reply> reply_;
-};
-
-} // namespace server4
-} // namespace http
-
-#endif // HTTP_SERVER4_SERVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/.gitignore
deleted file mode 100644
index 62ea912..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-ping
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/icmp_header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/icmp_header.hpp
deleted file mode 100644
index 347f13a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/icmp_header.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// icmp_header.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ICMP_HEADER_HPP
-#define ICMP_HEADER_HPP
-
-#include <istream>
-#include <ostream>
-#include <algorithm>
-
-// ICMP header for both IPv4 and IPv6.
-//
-// The wire format of an ICMP header is:
-//
-// 0               8               16                             31
-// +---------------+---------------+------------------------------+      ---
-// |               |               |                              |       ^
-// |     type      |     code      |          checksum            |       |
-// |               |               |                              |       |
-// +---------------+---------------+------------------------------+    8 bytes
-// |                               |                              |       |
-// |          identifier           |       sequence number        |       |
-// |                               |                              |       v
-// +-------------------------------+------------------------------+      ---
-
-class icmp_header
-{
-public:
-  enum { echo_reply = 0, destination_unreachable = 3, source_quench = 4,
-    redirect = 5, echo_request = 8, time_exceeded = 11, parameter_problem = 12,
-    timestamp_request = 13, timestamp_reply = 14, info_request = 15,
-    info_reply = 16, address_request = 17, address_reply = 18 };
-
-  icmp_header() { std::fill(rep_, rep_ + sizeof(rep_), 0); }
-
-  unsigned char type() const { return rep_[0]; }
-  unsigned char code() const { return rep_[1]; }
-  unsigned short checksum() const { return decode(2, 3); }
-  unsigned short identifier() const { return decode(4, 5); }
-  unsigned short sequence_number() const { return decode(6, 7); }
-
-  void type(unsigned char n) { rep_[0] = n; }
-  void code(unsigned char n) { rep_[1] = n; }
-  void checksum(unsigned short n) { encode(2, 3, n); }
-  void identifier(unsigned short n) { encode(4, 5, n); }
-  void sequence_number(unsigned short n) { encode(6, 7, n); }
-
-  friend std::istream& operator>>(std::istream& is, icmp_header& header)
-    { return is.read(reinterpret_cast<char*>(header.rep_), 8); }
-
-  friend std::ostream& operator<<(std::ostream& os, const icmp_header& header)
-    { return os.write(reinterpret_cast<const char*>(header.rep_), 8); }
-
-private:
-  unsigned short decode(int a, int b) const
-    { return (rep_[a] << 8) + rep_[b]; }
-
-  void encode(int a, int b, unsigned short n)
-  {
-    rep_[a] = static_cast<unsigned char>(n >> 8);
-    rep_[b] = static_cast<unsigned char>(n & 0xFF);
-  }
-
-  unsigned char rep_[8];
-};
-
-template <typename Iterator>
-void compute_checksum(icmp_header& header,
-    Iterator body_begin, Iterator body_end)
-{
-  unsigned int sum = (header.type() << 8) + header.code()
-    + header.identifier() + header.sequence_number();
-
-  Iterator body_iter = body_begin;
-  while (body_iter != body_end)
-  {
-    sum += (static_cast<unsigned char>(*body_iter++) << 8);
-    if (body_iter != body_end)
-      sum += static_cast<unsigned char>(*body_iter++);
-  }
-
-  sum = (sum >> 16) + (sum & 0xFFFF);
-  sum += (sum >> 16);
-  header.checksum(static_cast<unsigned short>(~sum));
-}
-
-#endif // ICMP_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ipv4_header.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ipv4_header.hpp
deleted file mode 100644
index 771dd34..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ipv4_header.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//
-// ipv4_header.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef IPV4_HEADER_HPP
-#define IPV4_HEADER_HPP
-
-#include <algorithm>
-#include <asio/ip/address_v4.hpp>
-
-// Packet header for IPv4.
-//
-// The wire format of an IPv4 header is:
-//
-// 0               8               16                             31
-// +-------+-------+---------------+------------------------------+      ---
-// |       |       |               |                              |       ^
-// |version|header |    type of    |    total length in bytes     |       |
-// |  (4)  | length|    service    |                              |       |
-// +-------+-------+---------------+-+-+-+------------------------+       |
-// |                               | | | |                        |       |
-// |        identification         |0|D|M|    fragment offset     |       |
-// |                               | |F|F|                        |       |
-// +---------------+---------------+-+-+-+------------------------+       |
-// |               |               |                              |       |
-// | time to live  |   protocol    |       header checksum        |   20 bytes
-// |               |               |                              |       |
-// +---------------+---------------+------------------------------+       |
-// |                                                              |       |
-// |                      source IPv4 address                     |       |
-// |                                                              |       |
-// +--------------------------------------------------------------+       |
-// |                                                              |       |
-// |                   destination IPv4 address                   |       |
-// |                                                              |       v
-// +--------------------------------------------------------------+      ---
-// |                                                              |       ^
-// |                                                              |       |
-// /                        options (if any)                      /    0 - 40
-// /                                                              /     bytes
-// |                                                              |       |
-// |                                                              |       v
-// +--------------------------------------------------------------+      ---
-
-class ipv4_header
-{
-public:
-  ipv4_header() { std::fill(rep_, rep_ + sizeof(rep_), 0); }
-
-  unsigned char version() const { return (rep_[0] >> 4) & 0xF; }
-  unsigned short header_length() const { return (rep_[0] & 0xF) * 4; }
-  unsigned char type_of_service() const { return rep_[1]; }
-  unsigned short total_length() const { return decode(2, 3); }
-  unsigned short identification() const { return decode(4, 5); }
-  bool dont_fragment() const { return (rep_[6] & 0x40) != 0; }
-  bool more_fragments() const { return (rep_[6] & 0x20) != 0; }
-  unsigned short fragment_offset() const { return decode(6, 7) & 0x1FFF; }
-  unsigned int time_to_live() const { return rep_[8]; }
-  unsigned char protocol() const { return rep_[9]; }
-  unsigned short header_checksum() const { return decode(10, 11); }
-
-  asio::ip::address_v4 source_address() const
-  {
-    asio::ip::address_v4::bytes_type bytes
-      = { { rep_[12], rep_[13], rep_[14], rep_[15] } };
-    return asio::ip::address_v4(bytes);
-  }
-
-  asio::ip::address_v4 destination_address() const
-  {
-    asio::ip::address_v4::bytes_type bytes
-      = { { rep_[16], rep_[17], rep_[18], rep_[19] } };
-    return asio::ip::address_v4(bytes);
-  }
-
-  friend std::istream& operator>>(std::istream& is, ipv4_header& header)
-  {
-    is.read(reinterpret_cast<char*>(header.rep_), 20);
-    if (header.version() != 4)
-      is.setstate(std::ios::failbit);
-    std::streamsize options_length = header.header_length() - 20;
-    if (options_length < 0 || options_length > 40)
-      is.setstate(std::ios::failbit);
-    else
-      is.read(reinterpret_cast<char*>(header.rep_) + 20, options_length);
-    return is;
-  }
-
-private:
-  unsigned short decode(int a, int b) const
-    { return (rep_[a] << 8) + rep_[b]; }
-
-  unsigned char rep_[60];
-};
-
-#endif // IPV4_HEADER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ping.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ping.cpp
deleted file mode 100644
index f179ea3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/icmp/ping.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//
-// ping.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <istream>
-#include <iostream>
-#include <ostream>
-
-#include "icmp_header.hpp"
-#include "ipv4_header.hpp"
-
-using asio::ip::icmp;
-using asio::steady_timer;
-namespace chrono = asio::chrono;
-
-class pinger
-{
-public:
-  pinger(asio::io_context& io_context, const char* destination)
-    : resolver_(io_context), socket_(io_context, icmp::v4()),
-      timer_(io_context), sequence_number_(0), num_replies_(0)
-  {
-    destination_ = *resolver_.resolve(icmp::v4(), destination, "").begin();
-
-    start_send();
-    start_receive();
-  }
-
-private:
-  void start_send()
-  {
-    std::string body("\"Hello!\" from Asio ping.");
-
-    // Create an ICMP header for an echo request.
-    icmp_header echo_request;
-    echo_request.type(icmp_header::echo_request);
-    echo_request.code(0);
-    echo_request.identifier(get_identifier());
-    echo_request.sequence_number(++sequence_number_);
-    compute_checksum(echo_request, body.begin(), body.end());
-
-    // Encode the request packet.
-    asio::streambuf request_buffer;
-    std::ostream os(&request_buffer);
-    os << echo_request << body;
-
-    // Send the request.
-    time_sent_ = steady_timer::clock_type::now();
-    socket_.send_to(request_buffer.data(), destination_);
-
-    // Wait up to five seconds for a reply.
-    num_replies_ = 0;
-    timer_.expires_at(time_sent_ + chrono::seconds(5));
-    timer_.async_wait(std::bind(&pinger::handle_timeout, this));
-  }
-
-  void handle_timeout()
-  {
-    if (num_replies_ == 0)
-      std::cout << "Request timed out" << std::endl;
-
-    // Requests must be sent no less than one second apart.
-    timer_.expires_at(time_sent_ + chrono::seconds(1));
-    timer_.async_wait(std::bind(&pinger::start_send, this));
-  }
-
-  void start_receive()
-  {
-    // Discard any data already in the buffer.
-    reply_buffer_.consume(reply_buffer_.size());
-
-    // Wait for a reply. We prepare the buffer to receive up to 64KB.
-    socket_.async_receive(reply_buffer_.prepare(65536),
-        std::bind(&pinger::handle_receive, this, std::placeholders::_2));
-  }
-
-  void handle_receive(std::size_t length)
-  {
-    // The actual number of bytes received is committed to the buffer so that we
-    // can extract it using a std::istream object.
-    reply_buffer_.commit(length);
-
-    // Decode the reply packet.
-    std::istream is(&reply_buffer_);
-    ipv4_header ipv4_hdr;
-    icmp_header icmp_hdr;
-    is >> ipv4_hdr >> icmp_hdr;
-
-    // We can receive all ICMP packets received by the host, so we need to
-    // filter out only the echo replies that match the our identifier and
-    // expected sequence number.
-    if (is && icmp_hdr.type() == icmp_header::echo_reply
-          && icmp_hdr.identifier() == get_identifier()
-          && icmp_hdr.sequence_number() == sequence_number_)
-    {
-      // If this is the first reply, interrupt the five second timeout.
-      if (num_replies_++ == 0)
-        timer_.cancel();
-
-      // Print out some information about the reply packet.
-      chrono::steady_clock::time_point now = chrono::steady_clock::now();
-      chrono::steady_clock::duration elapsed = now - time_sent_;
-      std::cout << length - ipv4_hdr.header_length()
-        << " bytes from " << ipv4_hdr.source_address()
-        << ": icmp_seq=" << icmp_hdr.sequence_number()
-        << ", ttl=" << ipv4_hdr.time_to_live()
-        << ", time="
-        << chrono::duration_cast<chrono::milliseconds>(elapsed).count()
-        << std::endl;
-    }
-
-    start_receive();
-  }
-
-  static unsigned short get_identifier()
-  {
-#if defined(ASIO_WINDOWS)
-    return static_cast<unsigned short>(::GetCurrentProcessId());
-#else
-    return static_cast<unsigned short>(::getpid());
-#endif
-  }
-
-  icmp::resolver resolver_;
-  icmp::endpoint destination_;
-  icmp::socket socket_;
-  steady_timer timer_;
-  unsigned short sequence_number_;
-  chrono::steady_clock::time_point time_sent_;
-  asio::streambuf reply_buffer_;
-  std::size_t num_replies_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: ping <host>" << std::endl;
-#if !defined(ASIO_WINDOWS)
-      std::cerr << "(You may need to run this program as root.)" << std::endl;
-#endif
-      return 1;
-    }
-
-    asio::io_context io_context;
-    pinger p(io_context, argv[1]);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/.gitignore
deleted file mode 100644
index e5876b7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-prioritised_handlers
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp
deleted file mode 100644
index 533bfd0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp
+++ /dev/null
@@ -1,202 +0,0 @@
-//
-// prioritised_handlers.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio.hpp"
-#include <iostream>
-#include <memory>
-#include <queue>
-
-using asio::ip::tcp;
-
-class handler_priority_queue : public asio::execution_context
-{
-public:
-  template <typename Function>
-  void add(int priority, Function function)
-  {
-    std::unique_ptr<queued_handler_base> handler(
-        new queued_handler<Function>(
-          priority, std::move(function)));
-
-    handlers_.push(std::move(handler));
-  }
-
-  void execute_all()
-  {
-    while (!handlers_.empty())
-    {
-      handlers_.top()->execute();
-      handlers_.pop();
-    }
-  }
-
-  class executor
-  {
-  public:
-    executor(handler_priority_queue& q, int p)
-      : context_(q), priority_(p)
-    {
-    }
-
-    handler_priority_queue& context() const noexcept
-    {
-      return context_;
-    }
-
-    template <typename Function, typename Allocator>
-    void dispatch(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    template <typename Function, typename Allocator>
-    void post(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    template <typename Function, typename Allocator>
-    void defer(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    void on_work_started() const noexcept {}
-    void on_work_finished() const noexcept {}
-
-    bool operator==(const executor& other) const noexcept
-    {
-      return &context_ == &other.context_ && priority_ == other.priority_;
-    }
-
-    bool operator!=(const executor& other) const noexcept
-    {
-      return !operator==(other);
-    }
-
-  private:
-    handler_priority_queue& context_;
-    int priority_;
-  };
-
-  template <typename Handler>
-  asio::executor_binder<Handler, executor>
-  wrap(int priority, Handler handler)
-  {
-    return asio::bind_executor(
-        executor(*this, priority), std::move(handler));
-  }
-
-private:
-  class queued_handler_base
-  {
-  public:
-    queued_handler_base(int p)
-      : priority_(p)
-    {
-    }
-
-    virtual ~queued_handler_base()
-    {
-    }
-
-    virtual void execute() = 0;
-
-    friend bool operator<(const std::unique_ptr<queued_handler_base>& a,
-        const std::unique_ptr<queued_handler_base>& b) noexcept
-    {
-      return a->priority_ < b->priority_;
-    }
-
-  private:
-    int priority_;
-  };
-
-  template <typename Function>
-  class queued_handler : public queued_handler_base
-  {
-  public:
-    queued_handler(int p, Function f)
-      : queued_handler_base(p), function_(std::move(f))
-    {
-    }
-
-    void execute() override
-    {
-      function_();
-    }
-
-  private:
-    Function function_;
-  };
-
-  std::priority_queue<std::unique_ptr<queued_handler_base>> handlers_;
-};
-
-//----------------------------------------------------------------------
-
-void high_priority_handler(const std::error_code& /*ec*/,
-    tcp::socket /*socket*/)
-{
-  std::cout << "High priority handler\n";
-}
-
-void middle_priority_handler(const std::error_code& /*ec*/)
-{
-  std::cout << "Middle priority handler\n";
-}
-
-struct low_priority_handler
-{
-  // Make the handler a move-only type.
-  low_priority_handler() = default;
-  low_priority_handler(const low_priority_handler&) = delete;
-  low_priority_handler(low_priority_handler&&) = default;
-
-  void operator()()
-  {
-    std::cout << "Low priority handler\n";
-  }
-};
-
-int main()
-{
-  asio::io_context io_context;
-
-  handler_priority_queue pri_queue;
-
-  // Post a completion handler to be run immediately.
-  asio::post(io_context, pri_queue.wrap(0, low_priority_handler()));
-
-  // Start an asynchronous accept that will complete immediately.
-  tcp::endpoint endpoint(asio::ip::address_v4::loopback(), 0);
-  tcp::acceptor acceptor(io_context, endpoint);
-  tcp::socket server_socket(io_context);
-  acceptor.async_accept(pri_queue.wrap(100, high_priority_handler));
-  tcp::socket client_socket(io_context);
-  client_socket.connect(acceptor.local_endpoint());
-
-  // Set a deadline timer to expire immediately.
-  asio::steady_timer timer(io_context);
-  timer.expires_at(asio::steady_timer::clock_type::time_point::min());
-  timer.async_wait(pri_queue.wrap(42, middle_priority_handler));
-
-  while (io_context.run_one())
-  {
-    // The custom invocation hook adds the handlers to the priority queue
-    // rather than executing them from within the poll_one() call.
-    while (io_context.poll_one())
-      ;
-
-    pri_queue.execute_all();
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/.gitignore
deleted file mode 100644
index bc2b4f8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-*_server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_client.cpp
deleted file mode 100644
index 0c8df19..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_client.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// daytime_client.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: daytime_client <host>" << std::endl;
-      return 1;
-    }
-
-    tcp::iostream s(argv[1], "daytime");
-    if (!s)
-    {
-      std::cout << "Unable to connect: " << s.error().message() << std::endl;
-      return 1;
-    }
-
-    std::string line;
-    std::getline(s, line);
-    std::cout << line << std::endl;
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_server.cpp
deleted file mode 100644
index 1e64408..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/daytime_server.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// daytime_server.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <ctime>
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    tcp::endpoint endpoint(tcp::v4(), 13);
-    tcp::acceptor acceptor(io_context, endpoint);
-
-    for (;;)
-    {
-      tcp::iostream stream;
-      std::error_code ec;
-      acceptor.accept(stream.socket(), ec);
-      if (!ec)
-      {
-        stream << make_daytime_string();
-      }
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/http_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/http_client.cpp
deleted file mode 100644
index 313f177..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/iostreams/http_client.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// http_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <istream>
-#include <ostream>
-#include <string>
-#include <asio/ip/tcp.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cout << "Usage: http_client <server> <path>\n";
-      std::cout << "Example:\n";
-      std::cout << "  http_client www.boost.org /LICENSE_1_0.txt\n";
-      return 1;
-    }
-
-    asio::ip::tcp::iostream s;
-
-    // The entire sequence of I/O operations must complete within 60 seconds.
-    // If an expiry occurs, the socket is automatically closed and the stream
-    // becomes bad.
-    s.expires_after(std::chrono::seconds(60));
-
-    // Establish a connection to the server.
-    s.connect(argv[1], "http");
-    if (!s)
-    {
-      std::cout << "Unable to connect: " << s.error().message() << "\n";
-      return 1;
-    }
-
-    // Send the request. We specify the "Connection: close" header so that the
-    // server will close the socket after transmitting the response. This will
-    // allow us to treat all data up until the EOF as the content.
-    s << "GET " << argv[2] << " HTTP/1.0\r\n";
-    s << "Host: " << argv[1] << "\r\n";
-    s << "Accept: */*\r\n";
-    s << "Connection: close\r\n\r\n";
-
-    // By default, the stream is tied with itself. This means that the stream
-    // automatically flush the buffered output before attempting a read. It is
-    // not necessary not explicitly flush the stream at this point.
-
-    // Check that response is OK.
-    std::string http_version;
-    s >> http_version;
-    unsigned int status_code;
-    s >> status_code;
-    std::string status_message;
-    std::getline(s, status_message);
-    if (!s || http_version.substr(0, 5) != "HTTP/")
-    {
-      std::cout << "Invalid response\n";
-      return 1;
-    }
-    if (status_code != 200)
-    {
-      std::cout << "Response returned with status code " << status_code << "\n";
-      return 1;
-    }
-
-    // Process the response headers, which are terminated by a blank line.
-    std::string header;
-    while (std::getline(s, header) && header != "\r")
-      std::cout << header << "\n";
-    std::cout << "\n";
-
-    // Write the remaining data to output.
-    std::cout << s.rdbuf();
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/.gitignore
deleted file mode 100644
index ad39f8f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/.gitignore
+++ /dev/null
@@ -1,15 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-connect_pair
-stream_server
-stream_client
-iostream_client
-fd_passing_stream_server
-fd_passing_stream_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/connect_pair.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/connect_pair.cpp
deleted file mode 100644
index 50d0a06..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/connect_pair.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// connect_pair.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <iostream>
-#include <string>
-#include <cctype>
-#include <asio.hpp>
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-using asio::local::stream_protocol;
-
-class uppercase_filter
-{
-public:
-  uppercase_filter(stream_protocol::socket sock)
-    : socket_(std::move(sock))
-  {
-    read();
-  }
-
-private:
-  void read()
-  {
-    socket_.async_read_some(asio::buffer(data_),
-        [this](std::error_code ec, std::size_t size)
-        {
-          if (!ec)
-          {
-            // Compute result.
-            for (std::size_t i = 0; i < size; ++i)
-              data_[i] = std::toupper(data_[i]);
-
-            // Send result.
-            write(size);
-          }
-          else
-          {
-            throw std::system_error(ec);
-          }
-        });
-  }
-
-  void write(std::size_t size)
-  {
-    asio::async_write(socket_, asio::buffer(data_, size),
-        [this](std::error_code ec, std::size_t /*size*/)
-        {
-          if (!ec)
-          {
-            // Wait for request.
-            read();
-          }
-          else
-          {
-            throw std::system_error(ec);
-          }
-        });
-  }
-
-  stream_protocol::socket socket_;
-  std::array<char, 512> data_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    // Create a connected pair and pass one end to a filter.
-    stream_protocol::socket socket(io_context);
-    stream_protocol::socket filter_socket(io_context);
-    asio::local::connect_pair(socket, filter_socket);
-    uppercase_filter filter(std::move(filter_socket));
-
-    // The io_context runs in a background thread to perform filtering.
-    asio::thread thread(
-        [&io_context]()
-        {
-          try
-          {
-            io_context.run();
-          }
-          catch (std::exception& e)
-          {
-            std::cerr << "Exception in thread: " << e.what() << "\n";
-            std::exit(1);
-          }
-        });
-
-    for (;;)
-    {
-      // Collect request from user.
-      std::cout << "Enter a string: ";
-      std::string request;
-      std::getline(std::cin, request);
-
-      // Send request to filter.
-      asio::write(socket, asio::buffer(request));
-
-      // Wait for reply from filter.
-      std::vector<char> reply(request.size());
-      asio::read(socket, asio::buffer(reply));
-
-      // Show reply to user.
-      std::cout << "Result: ";
-      std::cout.write(&reply[0], request.size());
-      std::cout << std::endl;
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-    std::exit(1);
-  }
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_client.cpp
deleted file mode 100644
index 229509f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_client.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//
-// fd_passing_stream_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2021 Heiko Hund (heiko at openvpn dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Demonstrates how to pass file descriptors between processes with Asio.
-// The client send a file name (destfile) to the server. The server opens
-// the file and the associated file descriptor back to the client.
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-#include <sys/types.h>
-#include <sys/socket.h>
-
-using asio::local::stream_protocol;
-
-constexpr std::size_t max_length = 1024;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: fd_passing_stream_client <serversocket>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    stream_protocol::socket s(io_context);
-    s.connect(stream_protocol::endpoint(argv[1]));
-
-    std::cout << "Enter path to write to: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    asio::write(s, asio::buffer(request, request_length));
-
-    char reply[max_length];
-    struct msghdr msg = {};
-    struct iovec iov = { reply, sizeof(reply) };
-    msg.msg_iov = &iov;
-    msg.msg_iovlen = 1;
-
-    union
-    {
-      struct cmsghdr align;
-      char buf[CMSG_SPACE(sizeof(int))];
-    } cmsgu;
-    msg.msg_control = cmsgu.buf;
-    msg.msg_controllen = sizeof(cmsgu.buf);
-
-    ::recvmsg(s.native_handle(), &msg, 0);
-
-    int fd = -1;
-    struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
-    while (cmsg != NULL)
-    {
-      if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
-      {
-        std::memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd));
-        break;
-      }
-      cmsg = CMSG_NXTHDR(&msg, cmsg);
-    }
-
-    if (fd != -1)
-    {
-      std::cout << "File descriptor received is: " << fd << "\n";
-      FILE* f(::fdopen(fd, "w+"));
-      if (f)
-      {
-        ::fprintf(f, "stream_client writing to received fd #%d\n", fd);
-        ::fclose(f);
-      }
-      else
-        ::close(fd);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_server.cpp
deleted file mode 100644
index 5082185..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/fd_passing_stream_server.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-//
-// fd_passing_stream_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2021 Heiko Hund (heiko at openvpn dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Demonstrates how to pass file descriptors between processes with Asio.
-// The client sends a file name to the server. The server opens the file and
-// passes the associated file descriptor back to the client.
-
-#include <array>
-#include <cstdio>
-#include <cassert>
-#include <iostream>
-#include <memory>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-using asio::local::stream_protocol;
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(stream_protocol::socket sock)
-    : socket_(std::move(sock))
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          if (ec)
-            return;
-
-          assert(length < data_.size());
-          data_[length] = 0;
-          do_write(data_.data());
-        });
-  }
-
-  void do_write(const char* filename)
-  {
-    auto self(shared_from_this());
-    socket_.async_wait(stream_protocol::socket::wait_write,
-        [this, self, filename](std::error_code ec)
-        {
-          if (ec)
-            return;
-
-          FILE* f(::fopen(filename, "w+"));
-          if (!f)
-            return;
-
-          struct msghdr msg = {};
-          char buf[] = { 0 };
-          struct iovec iov = { buf, sizeof(buf) };
-          msg.msg_iov = &iov;
-          msg.msg_iovlen = 1;
-
-          union
-          {
-            struct cmsghdr align;
-            char buf[CMSG_SPACE(sizeof(int))];
-          } cmsgu;
-          msg.msg_control = cmsgu.buf;
-          msg.msg_controllen = sizeof(cmsgu.buf);
-
-          struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);
-          cmsg->cmsg_len = CMSG_LEN(sizeof(int));
-          cmsg->cmsg_level = SOL_SOCKET;
-          cmsg->cmsg_type = SCM_RIGHTS;
-          int fd = ::fileno(f);
-          std::memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
-
-          ssize_t s(::sendmsg(socket_.native_handle(), &msg, 0));
-          ::fclose(f);
-          if (s != -1)
-            do_read();
-        });
-  }
-
-  // The socket used to communicate with the client.
-  stream_protocol::socket socket_;
-
-  // Buffer used to store data received from the client.
-  std::array<char, 1024> data_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, const std::string& file)
-    : acceptor_(io_context, stream_protocol::endpoint(file))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, stream_protocol::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  stream_protocol::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: fd_passing_stream_server <socketfile>\n";
-      std::cerr << "*** WARNING: existing file is removed ***\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    std::remove(argv[1]);
-    server s(io_context, argv[1]);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/iostream_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/iostream_client.cpp
deleted file mode 100644
index 932f29d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/iostream_client.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// stream_client.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-using asio::local::stream_protocol;
-
-constexpr std::size_t max_length = 1024;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: iostream_client <file>\n";
-      return 1;
-    }
-
-    stream_protocol::endpoint ep(argv[1]);
-    stream_protocol::iostream s(ep);
-    if (!s)
-    {
-      std::cerr << "Unable to connect: " << s.error().message() << std::endl;
-      return 1;
-    }
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t length = std::strlen(request);
-    s << request;
-
-    char reply[max_length];
-    s.read(reply, length);
-    std::cout << "Reply is: ";
-    std::cout.write(reply, length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_client.cpp
deleted file mode 100644
index 32f4089..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_client.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// stream_client.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-using asio::local::stream_protocol;
-
-constexpr std::size_t max_length = 1024;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: stream_client <file>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    stream_protocol::socket s(io_context);
-    s.connect(stream_protocol::endpoint(argv[1]));
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    asio::write(s, asio::buffer(request, request_length));
-
-    char reply[max_length];
-    size_t reply_length = asio::read(s,
-        asio::buffer(reply, request_length));
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_server.cpp
deleted file mode 100644
index 85cd58f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/local/stream_server.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// stream_server.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <cstdio>
-#include <iostream>
-#include <memory>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-
-using asio::local::stream_protocol;
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(stream_protocol::socket sock)
-    : socket_(std::move(sock))
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-            do_write(length);
-        });
-  }
-
-  void do_write(std::size_t length)
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_,
-        asio::buffer(data_, length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-            do_read();
-        });
-  }
-
-  // The socket used to communicate with the client.
-  stream_protocol::socket socket_;
-
-  // Buffer used to store data received from the client.
-  std::array<char, 1024> data_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, const std::string& file)
-    : acceptor_(io_context, stream_protocol::endpoint(file))
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, stream_protocol::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  stream_protocol::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: stream_server <file>\n";
-      std::cerr << "*** WARNING: existing file is removed ***\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    std::remove(argv[1]);
-    server s(io_context, argv[1]);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_LOCAL_SOCKETS)
-# error Local sockets not available on this platform.
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/.gitignore
deleted file mode 100644
index 0c30ebd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-receiver
-sender
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/receiver.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/receiver.cpp
deleted file mode 100644
index 5973bed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/receiver.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//
-// receiver.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <iostream>
-#include <string>
-#include "asio.hpp"
-
-constexpr short multicast_port = 30001;
-
-class receiver
-{
-public:
-  receiver(asio::io_context& io_context,
-      const asio::ip::address& listen_address,
-      const asio::ip::address& multicast_address)
-    : socket_(io_context)
-  {
-    // Create the socket so that multiple may be bound to the same address.
-    asio::ip::udp::endpoint listen_endpoint(
-        listen_address, multicast_port);
-    socket_.open(listen_endpoint.protocol());
-    socket_.set_option(asio::ip::udp::socket::reuse_address(true));
-    socket_.bind(listen_endpoint);
-
-    // Join the multicast group.
-    socket_.set_option(
-        asio::ip::multicast::join_group(multicast_address));
-
-    do_receive();
-  }
-
-private:
-  void do_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(data_), sender_endpoint_,
-        [this](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            std::cout.write(data_.data(), length);
-            std::cout << std::endl;
-
-            do_receive();
-          }
-        });
-  }
-
-  asio::ip::udp::socket socket_;
-  asio::ip::udp::endpoint sender_endpoint_;
-  std::array<char, 1024> data_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: receiver <listen_address> <multicast_address>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 239.255.0.1\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 ff31::8000:1234\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    receiver r(io_context,
-        asio::ip::make_address(argv[1]),
-        asio::ip::make_address(argv[2]));
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/sender.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/sender.cpp
deleted file mode 100644
index dc3cf7f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/multicast/sender.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// sender.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <sstream>
-#include <string>
-#include "asio.hpp"
-
-constexpr short multicast_port = 30001;
-constexpr int max_message_count = 10;
-
-class sender
-{
-public:
-  sender(asio::io_context& io_context,
-      const asio::ip::address& multicast_address)
-    : endpoint_(multicast_address, multicast_port),
-      socket_(io_context, endpoint_.protocol()),
-      timer_(io_context),
-      message_count_(0)
-  {
-    do_send();
-  }
-
-private:
-  void do_send()
-  {
-    std::ostringstream os;
-    os << "Message " << message_count_++;
-    message_ = os.str();
-
-    socket_.async_send_to(
-        asio::buffer(message_), endpoint_,
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && message_count_ < max_message_count)
-            do_timeout();
-        });
-  }
-
-  void do_timeout()
-  {
-    timer_.expires_after(std::chrono::seconds(1));
-    timer_.async_wait(
-        [this](std::error_code ec)
-        {
-          if (!ec)
-            do_send();
-        });
-  }
-
-private:
-  asio::ip::udp::endpoint endpoint_;
-  asio::ip::udp::socket socket_;
-  asio::steady_timer timer_;
-  int message_count_;
-  std::string message_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: sender <multicast_address>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    sender 239.255.0.1\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    sender ff31::8000:1234\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    sender s(io_context, asio::ip::make_address(argv[1]));
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/.gitignore
deleted file mode 100644
index 760e0dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-third_party_lib
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/third_party_lib.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/third_party_lib.cpp
deleted file mode 100644
index 7239a59..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/nonblocking/third_party_lib.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// third_party_lib.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <array>
-#include <iostream>
-#include <memory>
-
-using asio::ip::tcp;
-
-namespace third_party_lib {
-
-// Simulation of a third party library that wants to perform read and write
-// operations directly on a socket. It needs to be polled to determine whether
-// it requires a read or write operation, and notified when the socket is ready
-// for reading or writing.
-class session
-{
-public:
-  session(tcp::socket& socket)
-    : socket_(socket)
-  {
-  }
-
-  // Returns true if the third party library wants to be notified when the
-  // socket is ready for reading.
-  bool want_read() const
-  {
-    return state_ == reading;
-  }
-
-  // Notify that third party library that it should perform its read operation.
-  void do_read(std::error_code& ec)
-  {
-    if (std::size_t len = socket_.read_some(asio::buffer(data_), ec))
-    {
-      write_buffer_ = asio::buffer(data_, len);
-      state_ = writing;
-    }
-  }
-
-  // Returns true if the third party library wants to be notified when the
-  // socket is ready for writing.
-  bool want_write() const
-  {
-    return state_ == writing;
-  }
-
-  // Notify that third party library that it should perform its write operation.
-  void do_write(std::error_code& ec)
-  {
-    if (std::size_t len = socket_.write_some(
-          asio::buffer(write_buffer_), ec))
-    {
-      write_buffer_ = write_buffer_ + len;
-      state_ = asio::buffer_size(write_buffer_) > 0 ? writing : reading;
-    }
-  }
-
-private:
-  tcp::socket& socket_;
-  enum { reading, writing } state_ = reading;
-  std::array<char, 128> data_;
-  asio::const_buffer write_buffer_;
-};
-
-} // namespace third_party_lib
-
-// The glue between asio's sockets and the third party library.
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  connection(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    // Put the socket into non-blocking mode.
-    socket_.non_blocking(true);
-
-    do_operations();
-  }
-
-private:
-  void do_operations()
-  {
-    auto self(shared_from_this());
-
-    // Start a read operation if the third party library wants one.
-    if (session_impl_.want_read() && !read_in_progress_)
-    {
-      read_in_progress_ = true;
-      socket_.async_wait(tcp::socket::wait_read,
-          [this, self](std::error_code ec)
-          {
-            read_in_progress_ = false;
-
-            // Notify third party library that it can perform a read.
-            if (!ec)
-              session_impl_.do_read(ec);
-
-            // The third party library successfully performed a read on the
-            // socket. Start new read or write operations based on what it now
-            // wants.
-            if (!ec || ec == asio::error::would_block)
-              do_operations();
-
-            // Otherwise, an error occurred. Closing the socket cancels any
-            // outstanding asynchronous read or write operations. The
-            // connection object will be destroyed automatically once those
-            // outstanding operations complete.
-            else
-              socket_.close();
-          });
-    }
-
-    // Start a write operation if the third party library wants one.
-    if (session_impl_.want_write() && !write_in_progress_)
-    {
-      write_in_progress_ = true;
-      socket_.async_wait(tcp::socket::wait_write,
-          [this, self](std::error_code ec)
-          {
-            write_in_progress_ = false;
-
-            // Notify third party library that it can perform a write.
-            if (!ec)
-              session_impl_.do_write(ec);
-
-            // The third party library successfully performed a write on the
-            // socket. Start new read or write operations based on what it now
-            // wants.
-            if (!ec || ec == asio::error::would_block)
-              do_operations();
-
-            // Otherwise, an error occurred. Closing the socket cancels any
-            // outstanding asynchronous read or write operations. The
-            // connection object will be destroyed automatically once those
-            // outstanding operations complete.
-            else
-              socket_.close();
-          });
-    }
-  }
-
-private:
-  tcp::socket socket_;
-  third_party_lib::session session_impl_{socket_};
-  bool read_in_progress_ = false;
-  bool write_in_progress_ = false;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, unsigned short port)
-    : acceptor_(io_context, {tcp::v4(), port})
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<connection>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: third_party_lib <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/.gitignore
deleted file mode 100644
index fd7a399..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-composed_[0-9]
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_1.cpp
deleted file mode 100644
index 054dbdb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_1.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//
-// composed_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-//------------------------------------------------------------------------------
-
-// This is the simplest example of a composed asynchronous operation, where we
-// simply repackage an existing operation. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In this example we are trivially delegating to an underlying asynchronous
-  // operation, so we can deduce the return type from that.
-  -> decltype(
-      asio::async_write(socket,
-        asio::buffer(message, std::strlen(message)),
-        std::forward<CompletionToken>(token)))
-{
-  // When delegating to the underlying operation we must take care to perfectly
-  // forward the completion token. This ensures that our operation works
-  // correctly with move-only function objects as callbacks, as well as other
-  // completion token types.
-  return asio::async_write(socket,
-      asio::buffer(message, std::strlen(message)),
-      std::forward<CompletionToken>(token));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_2.cpp
deleted file mode 100644
index 306d4b3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_2.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-//
-// composed_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This next simplest example of a composed asynchronous operation involves
-// repackaging multiple operations but choosing to invoke just one of them. All
-// of these underlying operations have the same completion signature. The
-// asynchronous operation requirements are met by delegating responsibility to
-// the underlying operations.
-
-// In addition to determining the mechanism by which an asynchronous operation
-// delivers its result, a completion token also determines the time when the
-// operation commences. For example, when the completion token is a simple
-// callback the operation commences before the initiating function returns.
-// However, if the completion token's delivery mechanism uses a future, we
-// might instead want to defer initiation of the operation until the returned
-// future object is waited upon.
-//
-// To enable this, when implementing an asynchronous operation we must package
-// the initiation step as a function object.
-struct async_write_message_initiation
-{
-  // The initiation function object's call operator is passed the concrete
-  // completion handler produced by the completion token. This completion
-  // handler matches the asynchronous operation's completion handler signature,
-  // which in this example is:
-  //
-  //   void(std::error_code error, std::size_t)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments as members in the initiaton function object. However, we should
-  // prefer to propagate them as function call arguments as this allows the
-  // completion token to optimise how they are passed. For example, a lazy
-  // future which defers initiation would need to make a decay-copy of the
-  // arguments, but when using a simple callback the arguments can be trivially
-  // forwarded straight through.)
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& completion_handler, tcp::socket& socket,
-      const char* message, bool allow_partial_write) const
-  {
-    if (allow_partial_write)
-    {
-      // When delegating to an underlying operation we must take care to
-      // perfectly forward the completion handler. This ensures that our
-      // operation works correctly with move-only function objects as
-      // callbacks.
-      return socket.async_write_some(
-          asio::buffer(message, std::strlen(message)),
-          std::forward<CompletionHandler>(completion_handler));
-    }
-    else
-    {
-      // As above, we must perfectly forward the completion handler when calling
-      // the alternate underlying operation.
-      return asio::async_write(socket,
-          asio::buffer(message, std::strlen(message)),
-          std::forward<CompletionHandler>(completion_handler));
-    }
-  }
-};
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, bool allow_partial_write,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_initiate.
-  -> decltype(
-      asio::async_initiate<
-        CompletionToken, void(std::error_code, std::size_t)>(
-          async_write_message_initiation(),
-          token, std::ref(socket), message, allow_partial_write))
-{
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code, std::size_t)>(
-      async_write_message_initiation(),
-      token, std::ref(socket), message, allow_partial_write);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n", false,
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", false, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", false, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_3.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_3.cpp
deleted file mode 100644
index e0b5ddc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_3.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-//
-// composed_3.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-// In addition to determining the mechanism by which an asynchronous operation
-// delivers its result, a completion token also determines the time when the
-// operation commences. For example, when the completion token is a simple
-// callback the operation commences before the initiating function returns.
-// However, if the completion token's delivery mechanism uses a future, we
-// might instead want to defer initiation of the operation until the returned
-// future object is waited upon.
-//
-// To enable this, when implementing an asynchronous operation we must package
-// the initiation step as a function object.
-struct async_write_message_initiation
-{
-  // The initiation function object's call operator is passed the concrete
-  // completion handler produced by the completion token. This completion
-  // handler matches the asynchronous operation's completion handler signature,
-  // which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments as members in the initiaton function object. However, we should
-  // prefer to propagate them as function call arguments as this allows the
-  // completion token to optimise how they are passed. For example, a lazy
-  // future which defers initiation would need to make a decay-copy of the
-  // arguments, but when using a simple callback the arguments can be trivially
-  // forwarded straight through.)
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& completion_handler,
-      tcp::socket& socket, const char* message) const
-  {
-    // The async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // This differs from our operation's signature in that it is also passed
-    // the number of bytes transferred as an argument of type std::size_t. We
-    // will adapt our completion handler to async_write's completion handler
-    // signature by using std::bind, which drops the additional argument.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    asio::async_write(socket,
-        asio::buffer(message, std::strlen(message)),
-        asio::bind_executor(executor,
-          std::bind(std::forward<CompletionHandler>(
-            completion_handler), std::placeholders::_1)));
-  }
-};
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_initiate.
-  -> decltype(
-      asio::async_initiate<
-        CompletionToken, void(std::error_code)>(
-          async_write_message_initiation(),
-          token, std::ref(socket), message))
-{
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      async_write_message_initiation(),
-      token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  // Get the result of the operation.
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_4.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_4.cpp
deleted file mode 100644
index 29fe269..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_4.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-//
-// composed_4.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. We will also intercept an empty
-// message as an invalid argument, and propagate the corresponding error to the
-// user. The asynchronous operation requirements are met by delegating
-// responsibility to the underlying operation.
-
-// In addition to determining the mechanism by which an asynchronous operation
-// delivers its result, a completion token also determines the time when the
-// operation commences. For example, when the completion token is a simple
-// callback the operation commences before the initiating function returns.
-// However, if the completion token's delivery mechanism uses a future, we
-// might instead want to defer initiation of the operation until the returned
-// future object is waited upon.
-//
-// To enable this, when implementing an asynchronous operation we must package
-// the initiation step as a function object.
-struct async_write_message_initiation
-{
-  // The initiation function object's call operator is passed the concrete
-  // completion handler produced by the completion token. This completion
-  // handler matches the asynchronous operation's completion handler signature,
-  // which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments as members in the initiaton function object. However, we should
-  // prefer to propagate them as function call arguments as this allows the
-  // completion token to optimise how they are passed. For example, a lazy
-  // future which defers initiation would need to make a decay-copy of the
-  // arguments, but when using a simple callback the arguments can be trivially
-  // forwarded straight through.)
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& completion_handler,
-      tcp::socket& socket, const char* message) const
-  {
-    // The post operation has a completion handler signature of:
-    //
-    //   void()
-    //
-    // and the async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // Both of these operations' completion handler signatures differ from our
-    // operation's completion handler signature. We will adapt our completion
-    // handler to these signatures by using std::bind, which drops the
-    // additional arguments.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    std::size_t length = std::strlen(message);
-    if (length == 0)
-    {
-      asio::post(
-          asio::bind_executor(executor,
-            std::bind(std::forward<CompletionHandler>(completion_handler),
-              asio::error::invalid_argument)));
-    }
-    else
-    {
-      asio::async_write(socket,
-          asio::buffer(message, length),
-          asio::bind_executor(executor,
-            std::bind(std::forward<CompletionHandler>(completion_handler),
-              std::placeholders::_1)));
-    }
-  }
-};
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_initiate.
-  -> decltype(
-      asio::async_initiate<
-        CompletionToken, void(std::error_code)>(
-          async_write_message_initiation(),
-          token, std::ref(socket), message))
-{
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      async_write_message_initiation(),
-      token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket, "", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_5.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_5.cpp
deleted file mode 100644
index 06a7af4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_5.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-//
-// composed_5.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation automatically serialises a message, using its I/O
-// streams insertion operator, before sending it on the socket. To do this, it
-// must allocate a buffer for the encoded message and ensure this buffer's
-// validity until the underlying async_write operation completes.
-
-// In addition to determining the mechanism by which an asynchronous operation
-// delivers its result, a completion token also determines the time when the
-// operation commences. For example, when the completion token is a simple
-// callback the operation commences before the initiating function returns.
-// However, if the completion token's delivery mechanism uses a future, we
-// might instead want to defer initiation of the operation until the returned
-// future object is waited upon.
-//
-// To enable this, when implementing an asynchronous operation we must package
-// the initiation step as a function object.
-struct async_write_message_initiation
-{
-  // The initiation function object's call operator is passed the concrete
-  // completion handler produced by the completion token. This completion
-  // handler matches the asynchronous operation's completion handler signature,
-  // which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments as members in the initiaton function object. However, we should
-  // prefer to propagate them as function call arguments as this allows the
-  // completion token to optimise how they are passed. For example, a lazy
-  // future which defers initiation would need to make a decay-copy of the
-  // arguments, but when using a simple callback the arguments can be trivially
-  // forwarded straight through.)
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& completion_handler,
-      tcp::socket& socket, std::unique_ptr<std::string> encoded_message) const
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object, rather than
-    // using a lambda or std::bind.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket so
-      // that it can obtain the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The user-supplied completion handler.
-      typename std::decay<CompletionHandler>::type handler_;
-
-      // The function call operator matches the completion signature of the
-      // async_write operation.
-      void operator()(const std::error_code& error, std::size_t /*n*/)
-      {
-        // Deallocate the encoded message before calling the user-supplied
-        // completion handler.
-        encoded_message_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        // The arguments must match the completion signature of our composed
-        // operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<CompletionHandler>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<CompletionHandler>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{socket, std::move(encoded_message),
-          std::forward<CompletionHandler>(completion_handler)});
-  }
-};
-
-template <typename T, typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const T& message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_initiate.
-  -> decltype(
-      asio::async_initiate<
-        CompletionToken, void(std::error_code)>(
-          async_write_message_initiation(), token,
-          std::ref(socket), std::declval<std::unique_ptr<std::string>>()))
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      async_write_message_initiation(), token,
-      std::ref(socket), std::move(encoded_message));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, 123456,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      std::string("abcdef"), asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, 654.321, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_6.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_6.cpp
deleted file mode 100644
index 70b6450..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_6.cpp
+++ /dev/null
@@ -1,350 +0,0 @@
-//
-// composed_6.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/executor_work_guard.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-// In addition to determining the mechanism by which an asynchronous operation
-// delivers its result, a completion token also determines the time when the
-// operation commences. For example, when the completion token is a simple
-// callback the operation commences before the initiating function returns.
-// However, if the completion token's delivery mechanism uses a future, we
-// might instead want to defer initiation of the operation until the returned
-// future object is waited upon.
-//
-// To enable this, when implementing an asynchronous operation we must package
-// the initiation step as a function object.
-struct async_write_message_initiation
-{
-  // The initiation function object's call operator is passed the concrete
-  // completion handler produced by the completion token. This completion
-  // handler matches the asynchronous operation's completion handler signature,
-  // which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments as members in the initiaton function object. However, we should
-  // prefer to propagate them as function call arguments as this allows the
-  // completion token to optimise how they are passed. For example, a lazy
-  // future which defers initiation would need to make a decay-copy of the
-  // arguments, but when using a simple callback the arguments can be trivially
-  // forwarded straight through.)
-  template <typename CompletionHandler>
-  void operator()(CompletionHandler&& completion_handler, tcp::socket& socket,
-      std::unique_ptr<std::string> encoded_message, std::size_t repeat_count,
-      std::unique_ptr<asio::steady_timer> delay_timer) const
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket as
-      // it is used for multiple async_write operations, as well as for
-      // obtaining the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The repeat count remaining.
-      std::size_t repeat_count_;
-
-      // A steady timer used for introducing a delay.
-      std::unique_ptr<asio::steady_timer> delay_timer_;
-
-      // To manage the cycle between the multiple underlying asychronous
-      // operations, our intermediate completion handler is implemented as a
-      // state machine.
-      enum { starting, waiting, writing } state_;
-
-      // As our composed operation performs multiple underlying I/O operations,
-      // we should maintain a work object against the I/O executor. This tells
-      // the I/O executor that there is still more work to come in the future.
-      asio::executor_work_guard<tcp::socket::executor_type> io_work_;
-
-      // The user-supplied completion handler, called once only on completion
-      // of the entire composed operation.
-      typename std::decay<CompletionHandler>::type handler_;
-
-      // By having a default value for the second argument, this function call
-      // operator matches the completion signature of both the async_write and
-      // steady_timer::async_wait operations.
-      void operator()(const std::error_code& error, std::size_t = 0)
-      {
-        if (!error)
-        {
-          switch (state_)
-          {
-          case starting:
-          case writing:
-            if (repeat_count_ > 0)
-            {
-              --repeat_count_;
-              state_ = waiting;
-              delay_timer_->expires_after(std::chrono::seconds(1));
-              delay_timer_->async_wait(std::move(*this));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state_ = writing;
-            asio::async_write(socket_,
-                asio::buffer(*encoded_message_), std::move(*this));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // We no longer have any future work coming for the I/O executor.
-        io_work_.reset();
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message_.reset();
-        delay_timer_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<CompletionHandler>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<CompletionHandler>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{
-          socket, std::move(encoded_message),
-          repeat_count, std::move(delay_timer),
-          intermediate_completion_handler::starting,
-          asio::make_work_guard(socket.get_executor()),
-          std::forward<CompletionHandler>(completion_handler)});
-  }
-};
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_initiate.
-  -> decltype(
-      asio::async_initiate<
-        CompletionToken, void(std::error_code)>(
-          async_write_message_initiation(), token, std::ref(socket),
-          std::declval<std::unique_ptr<std::string>>(), repeat_count,
-          std::declval<std::unique_ptr<asio::steady_timer>>()))
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      async_write_message_initiation(), token, std::ref(socket),
-      std::move(encoded_message), repeat_count, std::move(delay_timer));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_7.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_7.cpp
deleted file mode 100644
index 8eb83dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_7.cpp
+++ /dev/null
@@ -1,268 +0,0 @@
-//
-// composed_7.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-// In this example, the composed operation's logic is implemented as a state
-// machine within a hand-crafted function object.
-struct async_write_messages_implementation
-{
-  // The implementation holds a reference to the socket as it is used for
-  // multiple async_write operations.
-  tcp::socket& socket_;
-
-  // The allocated buffer for the encoded message. The std::unique_ptr smart
-  // pointer is move-only, and as a consequence our implementation is also
-  // move-only.
-  std::unique_ptr<std::string> encoded_message_;
-
-  // The repeat count remaining.
-  std::size_t repeat_count_;
-
-  // A steady timer used for introducing a delay.
-  std::unique_ptr<asio::steady_timer> delay_timer_;
-
-  // To manage the cycle between the multiple underlying asychronous
-  // operations, our implementation is a state machine.
-  enum { starting, waiting, writing } state_;
-
-  // The first argument to our function object's call operator is a reference
-  // to the enclosing intermediate completion handler. This intermediate
-  // completion handler is provided for us by the asio::async_compose
-  // function, and takes care of all the details required to implement a
-  // conforming asynchronous operation. When calling an underlying asynchronous
-  // operation, we pass it this enclosing intermediate completion handler
-  // as the completion token.
-  //
-  // All arguments after the first must be defaulted to allow the state machine
-  // to be started, as well as to allow the completion handler to match the
-  // completion signature of both the async_write and steady_timer::async_wait
-  // operations.
-  template <typename Self>
-  void operator()(Self& self,
-      const std::error_code& error = std::error_code(),
-      std::size_t = 0)
-  {
-    if (!error)
-    {
-      switch (state_)
-      {
-      case starting:
-      case writing:
-        if (repeat_count_ > 0)
-        {
-          --repeat_count_;
-          state_ = waiting;
-          delay_timer_->expires_after(std::chrono::seconds(1));
-          delay_timer_->async_wait(std::move(self));
-          return; // Composed operation not yet complete.
-        }
-        break; // Composed operation complete, continue below.
-      case waiting:
-        state_ = writing;
-        asio::async_write(socket_,
-            asio::buffer(*encoded_message_), std::move(self));
-        return; // Composed operation not yet complete.
-      }
-    }
-
-    // This point is reached only on completion of the entire composed
-    // operation.
-
-    // Deallocate the encoded message and delay timer before calling the
-    // user-supplied completion handler.
-    encoded_message_.reset();
-    delay_timer_.reset();
-
-    // Call the user-supplied handler with the result of the operation.
-    self.complete(error);
-  }
-};
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_compose.
-  -> decltype(
-      asio::async_compose<
-        CompletionToken, void(std::error_code)>(
-          std::declval<async_write_messages_implementation>(),
-          token, socket))
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation in an intermediate completion handler
-  // that meets the requirements of a conforming asynchronous operation. This
-  // includes tracking outstanding work against the I/O executors associated
-  // with the operation (in this example, this is the socket's executor).
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      async_write_messages_implementation{
-        socket, std::move(encoded_message),
-        repeat_count, std::move(delay_timer),
-        async_write_messages_implementation::starting},
-      token, socket);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_8.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_8.cpp
deleted file mode 100644
index ce22a5b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/operations/composed_8.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-//
-// composed_8.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations,
-// using asio's stackless coroutines support to express the flow of control. It
-// automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-#include <asio/yield.hpp>
-
-// In this example, the composed operation's logic is implemented as a state
-// machine within a hand-crafted function object.
-struct async_write_messages_implementation
-{
-  // The implementation holds a reference to the socket as it is used for
-  // multiple async_write operations.
-  tcp::socket& socket_;
-
-  // The allocated buffer for the encoded message. The std::unique_ptr smart
-  // pointer is move-only, and as a consequence our implementation is also
-  // move-only.
-  std::unique_ptr<std::string> encoded_message_;
-
-  // The repeat count remaining.
-  std::size_t repeat_count_;
-
-  // A steady timer used for introducing a delay.
-  std::unique_ptr<asio::steady_timer> delay_timer_;
-
-  // The coroutine state.
-  asio::coroutine coro_;
-
-  // The first argument to our function object's call operator is a reference
-  // to the enclosing intermediate completion handler. This intermediate
-  // completion handler is provided for us by the asio::async_compose
-  // function, and takes care of all the details required to implement a
-  // conforming asynchronous operation. When calling an underlying asynchronous
-  // operation, we pass it this enclosing intermediate completion handler
-  // as the completion token.
-  //
-  // All arguments after the first must be defaulted to allow the state machine
-  // to be started, as well as to allow the completion handler to match the
-  // completion signature of both the async_write and steady_timer::async_wait
-  // operations.
-  template <typename Self>
-  void operator()(Self& self,
-      const std::error_code& error = std::error_code(),
-      std::size_t = 0)
-  {
-    reenter (coro_)
-    {
-      while (repeat_count_ > 0)
-      {
-        --repeat_count_;
-
-        delay_timer_->expires_after(std::chrono::seconds(1));
-        yield delay_timer_->async_wait(std::move(self));
-        if (error)
-          break;
-
-        yield asio::async_write(socket_,
-            asio::buffer(*encoded_message_), std::move(self));
-        if (error)
-          break;
-      }
-
-      // Deallocate the encoded message and delay timer before calling the
-      // user-supplied completion handler.
-      encoded_message_.reset();
-      delay_timer_.reset();
-
-      // Call the user-supplied handler with the result of the operation.
-      self.complete(error);
-    }
-  }
-};
-
-#include <asio/unyield.hpp>
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++11 we deduce the type from the call to asio::async_compose.
-  -> decltype(
-      asio::async_compose<
-        CompletionToken, void(std::error_code)>(
-          std::declval<async_write_messages_implementation>(),
-          token, socket))
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation in an intermediate completion handler
-  // that meets the requirements of a conforming asynchronous operation. This
-  // includes tracking outstanding work against the I/O executors associated
-  // with the operation (in this example, this is the socket's executor).
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      async_write_messages_implementation{socket,
-        std::move(encoded_message), repeat_count,
-        std::move(delay_timer), asio::coroutine()},
-      token, socket);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation and its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/.gitignore
deleted file mode 100644
index 4d16a0e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/.gitignore
+++ /dev/null
@@ -1,15 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-parallel_sort
-ranged_wait_for_all
-wait_for_all
-wait_for_one
-wait_for_one_error
-wait_for_one_success
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/ranged_wait_for_all.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/ranged_wait_for_all.cpp
deleted file mode 100644
index a0d8f56..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/ranged_wait_for_all.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// ranged_wait_for_all.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-#include <vector>
-
-#ifdef ASIO_HAS_POSIX_STREAM_DESCRIPTOR
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor out(ctx, ::dup(STDOUT_FILENO));
-  asio::posix::stream_descriptor err(ctx, ::dup(STDERR_FILENO));
-
-  using op_type = decltype(
-      out.async_write_some(asio::buffer("", 0))
-    );
-
-  std::vector<op_type> ops;
-
-  ops.push_back(
-      out.async_write_some(asio::buffer("first\r\n", 7))
-    );
-
-  ops.push_back(
-      err.async_write_some(asio::buffer("second\r\n", 8))
-    );
-
-  asio::experimental::make_parallel_group(ops).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::vector<std::size_t> completion_order,
-          std::vector<std::error_code> ec,
-          std::vector<std::size_t> n
-      )
-      {
-        for (std::size_t i = 0; i < completion_order.size(); ++i)
-        {
-          std::size_t idx = completion_order[i];
-          std::cout << "operation " << idx << " finished: ";
-          std::cout << ec[idx] << ", " << n[idx] << "\n";
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_all.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_all.cpp
deleted file mode 100644
index 033fad0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_all.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// wait_for_all.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#ifdef ASIO_HAS_POSIX_STREAM_DESCRIPTOR
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      in.async_read_some(asio::buffer(data)),
-      timer.async_wait()
-    ).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one.cpp
deleted file mode 100644
index aaa1924..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// wait_for_one.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      in.async_read_some(asio::buffer(data)),
-      timer.async_wait()
-    ).async_wait(
-      asio::experimental::wait_for_one(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_error.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_error.cpp
deleted file mode 100644
index 904db90..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_error.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// wait_for_one_error.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      in.async_read_some(asio::buffer(data)),
-      timer.async_wait()
-    ).async_wait(
-      asio::experimental::wait_for_one_error(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_success.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_success.cpp
deleted file mode 100644
index d4206cf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/parallel_group/wait_for_one_success.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// wait_for_one_error.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      in.async_read_some(asio::buffer(data)),
-      timer.async_wait()
-    ).async_wait(
-      asio::experimental::wait_for_one_success(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/.gitignore
deleted file mode 100644
index 692ea7e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-client
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/client.cpp
deleted file mode 100644
index e093612..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/client.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <algorithm>
-#include <cstdlib>
-#include <exception>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <utility>
-#include "protocol.hpp"
-
-using asio::ip::tcp;
-using asio::ip::udp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: client <host> <port>\n";
-      return 1;
-    }
-    using namespace std; // For atoi.
-    std::string host_name = argv[1];
-    std::string port = argv[2];
-
-    asio::io_context io_context;
-
-    // Determine the location of the server.
-    tcp::resolver resolver(io_context);
-    tcp::endpoint remote_endpoint = *resolver.resolve(host_name, port).begin();
-
-    // Establish the control connection to the server.
-    tcp::socket control_socket(io_context);
-    control_socket.connect(remote_endpoint);
-
-    // Create a datagram socket to receive data from the server.
-    udp::socket data_socket(io_context, udp::endpoint(udp::v4(), 0));
-
-    // Determine what port we will receive data on.
-    udp::endpoint data_endpoint = data_socket.local_endpoint();
-
-    // Ask the server to start sending us data.
-    control_request start = control_request::start(data_endpoint.port());
-    asio::write(control_socket, start.to_buffers());
-
-    unsigned long last_frame_number = 0;
-    for (;;)
-    {
-      // Receive 50 messages on the current data socket.
-      for (int i = 0; i < 50; ++i)
-      {
-        // Receive a frame from the server.
-        frame f;
-        data_socket.receive(f.to_buffers(), 0);
-        if (f.number() > last_frame_number)
-        {
-          last_frame_number = f.number();
-          std::cout << "\n" << f.payload();
-        }
-      }
-
-      // Time to switch to a new socket. To ensure seamless handover we will
-      // continue to receive packets using the old socket until data arrives on
-      // the new one.
-      std::cout << " Starting renegotiation";
-
-      // Create the new data socket.
-      udp::socket new_data_socket(io_context, udp::endpoint(udp::v4(), 0));
-
-      // Determine the new port we will use to receive data.
-      udp::endpoint new_data_endpoint = new_data_socket.local_endpoint();
-
-      // Ask the server to switch over to the new port.
-      control_request change = control_request::change(
-          data_endpoint.port(), new_data_endpoint.port());
-      std::error_code control_result;
-      asio::async_write(control_socket, change.to_buffers(),
-          [&](std::error_code ec, std::size_t /*length*/)
-          {
-            control_result = ec;
-          });
-
-      // Try to receive a frame from the server on the new data socket. If we
-      // successfully receive a frame on this new data socket we can consider
-      // the renegotation complete. In that case we will close the old data
-      // socket, which will cause any outstanding receive operation on it to be
-      // cancelled.
-      frame f1;
-      std::error_code new_data_socket_result;
-      new_data_socket.async_receive(f1.to_buffers(),
-          [&](std::error_code ec, std::size_t /*length*/)
-          {
-            new_data_socket_result = ec;
-            if (!ec)
-            {
-              // We have successfully received a frame on the new data socket,
-              // so we can close the old data socket. This will cancel any
-              // outstanding receive operation on the old data socket.
-              data_socket.close();
-            }
-          });
-
-      // This loop will continue until we have successfully completed the
-      // renegotiation (i.e. received a frame on the new data socket), or some
-      // unrecoverable error occurs.
-      bool done = false;
-      while (!done)
-      {
-        // Even though we're performing a renegotation, we want to continue
-        // receiving data as smoothly as possible. Therefore we will continue to
-        // try to receive a frame from the server on the old data socket. If we
-        // receive a frame on this socket we will interrupt the io_context,
-        // print the frame, and resume waiting for the other operations to
-        // complete.
-        frame f2;
-        done = true; // Let's be optimistic.
-        if (data_socket.is_open()) // May have been closed by receive handler.
-        {
-          data_socket.async_receive(f2.to_buffers(), 0,
-              [&](std::error_code ec, std::size_t /*length*/)
-              {
-                if (!ec)
-                {
-                  // We have successfully received a frame on the old data
-                  // socket. Stop the io_context so that we can print it.
-                  io_context.stop();
-                  done = false;
-                }
-              });
-        }
-
-        // Run the operations in parallel. This will block until all operations
-        // have finished, or until the io_context is interrupted. (No threads!)
-        io_context.restart();
-        io_context.run();
-
-        // If the io_context.run() was interrupted then we have received a frame
-        // on the old data socket. We need to keep waiting for the renegotation
-        // operations to complete.
-        if (!done)
-        {
-          if (f2.number() > last_frame_number)
-          {
-            last_frame_number = f2.number();
-            std::cout << "\n" << f2.payload();
-          }
-        }
-      }
-
-      // Since the loop has finished, we have either successfully completed
-      // the renegotation, or an error has occurred. First we'll check for
-      // errors.
-      if (control_result)
-        throw std::system_error(control_result);
-      if (new_data_socket_result)
-        throw std::system_error(new_data_socket_result);
-
-      // If we get here it means we have successfully started receiving data on
-      // the new data socket. This new data socket will be used from now on
-      // (until the next time we renegotiate).
-      std::cout << " Renegotiation complete";
-      data_socket = std::move(new_data_socket);
-      data_endpoint = new_data_endpoint;
-      if (f1.number() > last_frame_number)
-      {
-        last_frame_number = f1.number();
-        std::cout << "\n" << f1.payload();
-      }
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/protocol.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/protocol.hpp
deleted file mode 100644
index 46f9938..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/protocol.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-//
-// protocol.hpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef PORTHOPPER_PROTOCOL_HPP
-#define PORTHOPPER_PROTOCOL_HPP
-
-#include <asio.hpp>
-#include <array>
-#include <cstring>
-#include <iomanip>
-#include <string>
-#include <strstream>
-
-// This request is sent by the client to the server over a TCP connection.
-// The client uses it to perform three functions:
-// - To request that data start being sent to a given port.
-// - To request that data is no longer sent to a given port.
-// - To change the target port to another.
-class control_request
-{
-public:
-  // Construct an empty request. Used when receiving.
-  control_request()
-  {
-  }
-
-  // Create a request to start sending data to a given port.
-  static const control_request start(unsigned short port)
-  {
-    return control_request(0, port);
-  }
-
-  // Create a request to stop sending data to a given port.
-  static const control_request stop(unsigned short port)
-  {
-    return control_request(port, 0);
-  }
-
-  // Create a request to change the port that data is sent to.
-  static const control_request change(
-      unsigned short old_port, unsigned short new_port)
-  {
-    return control_request(old_port, new_port);
-  }
-
-  // Get the old port. Returns 0 for start requests.
-  unsigned short old_port() const
-  {
-    std::istrstream is(data_, encoded_port_size);
-    unsigned short port = 0;
-    is >> std::setw(encoded_port_size) >> std::hex >> port;
-    return port;
-  }
-
-  // Get the new port. Returns 0 for stop requests.
-  unsigned short new_port() const
-  {
-    std::istrstream is(data_ + encoded_port_size, encoded_port_size);
-    unsigned short port = 0;
-    is >> std::setw(encoded_port_size) >> std::hex >> port;
-    return port;
-  }
-
-  // Obtain buffers for reading from or writing to a socket.
-  std::array<asio::mutable_buffer, 1> to_buffers()
-  {
-    std::array<asio::mutable_buffer, 1> buffers
-      = { { asio::buffer(data_) } };
-    return buffers;
-  }
-
-private:
-  // Construct with specified old and new ports.
-  control_request(unsigned short old_port_number,
-      unsigned short new_port_number)
-  {
-    std::ostrstream os(data_, control_request_size);
-    os << std::setw(encoded_port_size) << std::hex << old_port_number;
-    os << std::setw(encoded_port_size) << std::hex << new_port_number;
-  }
-
-  // The length in bytes of a control_request and its components.
-  enum
-  {
-    encoded_port_size = 4, // 16-bit port in hex.
-    control_request_size = encoded_port_size * 2
-  };
-
-  // The encoded request data.
-  char data_[control_request_size];
-};
-
-// This frame is sent from the server to subscribed clients over UDP.
-class frame
-{
-public:
-  // The maximum allowable length of the payload.
-  enum { payload_size = 32 };
-
-  // Construct an empty frame. Used when receiving.
-  frame()
-  {
-  }
-
-  // Construct a frame with specified frame number and payload.
-  frame(unsigned long frame_number, const std::string& payload_data)
-  {
-    std::ostrstream os(data_, frame_size);
-    os << std::setw(encoded_number_size) << std::hex << frame_number;
-    os << std::setw(payload_size)
-      << std::setfill(' ') << payload_data.substr(0, payload_size);
-  }
-
-  // Get the frame number.
-  unsigned long number() const
-  {
-    std::istrstream is(data_, encoded_number_size);
-    unsigned long frame_number = 0;
-    is >> std::setw(encoded_number_size) >> std::hex >> frame_number;
-    return frame_number;
-  }
-
-  // Get the payload data.
-  const std::string payload() const
-  {
-    return std::string(data_ + encoded_number_size, payload_size);
-  }
-
-  // Obtain buffers for reading from or writing to a socket.
-  std::array<asio::mutable_buffer, 1> to_buffers()
-  {
-    std::array<asio::mutable_buffer, 1> buffers
-      = { { asio::buffer(data_) } };
-    return buffers;
-  }
-
-private:
-  // The length in bytes of a frame and its components.
-  enum
-  {
-    encoded_number_size = 8, // Frame number in hex.
-    frame_size = encoded_number_size + payload_size
-  };
-
-  // The encoded frame data.
-  char data_[frame_size];
-};
-
-#endif // PORTHOPPER_PROTOCOL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/server.cpp
deleted file mode 100644
index 4a77622..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/porthopper/server.cpp
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <cmath>
-#include <cstdlib>
-#include <exception>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <set>
-#include "protocol.hpp"
-
-using asio::ip::tcp;
-using asio::ip::udp;
-
-typedef std::shared_ptr<tcp::socket> tcp_socket_ptr;
-typedef std::shared_ptr<asio::steady_timer> timer_ptr;
-typedef std::shared_ptr<control_request> control_request_ptr;
-
-class server
-{
-public:
-  // Construct the server to wait for incoming control connections.
-  server(asio::io_context& io_context, unsigned short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)),
-      timer_(io_context),
-      udp_socket_(io_context, udp::endpoint(udp::v4(), 0)),
-      next_frame_number_(1)
-  {
-    // Start waiting for a new control connection.
-    tcp_socket_ptr new_socket(new tcp::socket(acceptor_.get_executor()));
-    acceptor_.async_accept(*new_socket,
-        std::bind(&server::handle_accept, this,
-          asio::placeholders::error, new_socket));
-
-    // Start the timer used to generate outgoing frames.
-    timer_.expires_after(asio::chrono::milliseconds(100));
-    timer_.async_wait(std::bind(&server::handle_timer, this));
-  }
-
-  // Handle a new control connection.
-  void handle_accept(const std::error_code& ec, tcp_socket_ptr socket)
-  {
-    if (!ec)
-    {
-      // Start receiving control requests on the connection.
-      control_request_ptr request(new control_request);
-      asio::async_read(*socket, request->to_buffers(),
-          std::bind(&server::handle_control_request, this,
-            asio::placeholders::error, socket, request));
-    }
-
-    // Start waiting for a new control connection.
-    tcp_socket_ptr new_socket(new tcp::socket(acceptor_.get_executor()));
-    acceptor_.async_accept(*new_socket,
-        std::bind(&server::handle_accept, this,
-          asio::placeholders::error, new_socket));
-  }
-
-  // Handle a new control request.
-  void handle_control_request(const std::error_code& ec,
-      tcp_socket_ptr socket, control_request_ptr request)
-  {
-    if (!ec)
-    {
-      // Delay handling of the control request to simulate network latency.
-      timer_ptr delay_timer(
-          new asio::steady_timer(acceptor_.get_executor()));
-      delay_timer->expires_after(asio::chrono::seconds(2));
-      delay_timer->async_wait(
-          std::bind(&server::handle_control_request_timer, this,
-            socket, request, delay_timer));
-    }
-  }
-
-  void handle_control_request_timer(tcp_socket_ptr socket,
-      control_request_ptr request, timer_ptr /*delay_timer*/)
-  {
-    // Determine what address this client is connected from, since
-    // subscriptions must be stored on the server as a complete endpoint, not
-    // just a port. We use the non-throwing overload of remote_endpoint() since
-    // it may fail if the socket is no longer connected.
-    std::error_code ec;
-    tcp::endpoint remote_endpoint = socket->remote_endpoint(ec);
-    if (!ec)
-    {
-      // Remove old port subscription, if any.
-      if (unsigned short old_port = request->old_port())
-      {
-        udp::endpoint old_endpoint(remote_endpoint.address(), old_port);
-        subscribers_.erase(old_endpoint);
-        std::cout << "Removing subscription " << old_endpoint << std::endl;
-      }
-
-      // Add new port subscription, if any.
-      if (unsigned short new_port = request->new_port())
-      {
-        udp::endpoint new_endpoint(remote_endpoint.address(), new_port);
-        subscribers_.insert(new_endpoint);
-        std::cout << "Adding subscription " << new_endpoint << std::endl;
-      }
-    }
-
-    // Wait for next control request on this connection.
-    asio::async_read(*socket, request->to_buffers(),
-        std::bind(&server::handle_control_request, this,
-          asio::placeholders::error, socket, request));
-  }
-
-  // Every time the timer fires we will generate a new frame and send it to all
-  // subscribers.
-  void handle_timer()
-  {
-    // Generate payload.
-    double x = next_frame_number_ * 0.2;
-    double y = std::sin(x);
-    int char_index = static_cast<int>((y + 1.0) * (frame::payload_size / 2));
-    std::string payload;
-    for (int i = 0; i < frame::payload_size; ++i)
-      payload += (i == char_index ? '*' : '.');
-
-    // Create the frame to be sent to all subscribers.
-    frame f(next_frame_number_++, payload);
-
-    // Send frame to all subscribers. We can use synchronous calls here since
-    // UDP send operations typically do not block.
-    std::set<udp::endpoint>::iterator j;
-    for (j = subscribers_.begin(); j != subscribers_.end(); ++j)
-    {
-      std::error_code ec;
-      udp_socket_.send_to(f.to_buffers(), *j, 0, ec);
-    }
-
-    // Wait for next timeout.
-    timer_.expires_after(asio::chrono::milliseconds(100));
-    timer_.async_wait(std::bind(&server::handle_timer, this));
-  }
-
-private:
-  // The acceptor used to accept incoming control connections.
-  tcp::acceptor acceptor_;
-
-  // The timer used for generating data.
-  asio::steady_timer timer_;
-
-  // The socket used to send data to subscribers.
-  udp::socket udp_socket_;
-
-  // The next frame number.
-  unsigned long next_frame_number_;
-
-  // The set of endpoints that are subscribed.
-  std::set<udp::endpoint> subscribers_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    using namespace std; // For atoi.
-    server s(io_context, atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/.gitignore
deleted file mode 100644
index 692ea7e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-client
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/client.cpp
deleted file mode 100644
index 10ec87f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/client.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <functional>
-#include <iostream>
-#include <vector>
-#include "connection.hpp" // Must come before boost/serialization headers.
-#include <boost/serialization/vector.hpp>
-#include "stock.hpp"
-
-namespace s11n_example {
-
-/// Downloads stock quote information from a server.
-class client
-{
-public:
-  /// Constructor starts the asynchronous connect operation.
-  client(asio::io_context& io_context,
-      const std::string& host, const std::string& service)
-    : connection_(io_context.get_executor())
-  {
-    // Resolve the host name into an IP address.
-    asio::ip::tcp::resolver resolver(io_context);
-    asio::ip::tcp::resolver::query query(host, service);
-    asio::ip::tcp::resolver::iterator endpoint_iterator =
-      resolver.resolve(query);
-
-    // Start an asynchronous connect operation.
-    asio::async_connect(connection_.socket(), endpoint_iterator,
-        std::bind(&client::handle_connect, this,
-          asio::placeholders::error));
-  }
-
-  /// Handle completion of a connect operation.
-  void handle_connect(const asio::error_code& e)
-  {
-    if (!e)
-    {
-      // Successfully established connection. Start operation to read the list
-      // of stocks. The connection::async_read() function will automatically
-      // decode the data that is read from the underlying socket.
-      connection_.async_read(stocks_,
-          std::bind(&client::handle_read, this,
-            asio::placeholders::error));
-    }
-    else
-    {
-      // An error occurred. Log it and return. Since we are not starting a new
-      // operation the io_context will run out of work to do and the client will
-      // exit.
-      std::cerr << e.message() << std::endl;
-    }
-  }
-
-  /// Handle completion of a read operation.
-  void handle_read(const asio::error_code& e)
-  {
-    if (!e)
-    {
-      // Print out the data that was received.
-      for (std::size_t i = 0; i < stocks_.size(); ++i)
-      {
-        std::cout << "Stock number " << i << "\n";
-        std::cout << "  code: " << stocks_[i].code << "\n";
-        std::cout << "  name: " << stocks_[i].name << "\n";
-        std::cout << "  open_price: " << stocks_[i].open_price << "\n";
-        std::cout << "  high_price: " << stocks_[i].high_price << "\n";
-        std::cout << "  low_price: " << stocks_[i].low_price << "\n";
-        std::cout << "  last_price: " << stocks_[i].last_price << "\n";
-        std::cout << "  buy_price: " << stocks_[i].buy_price << "\n";
-        std::cout << "  buy_quantity: " << stocks_[i].buy_quantity << "\n";
-        std::cout << "  sell_price: " << stocks_[i].sell_price << "\n";
-        std::cout << "  sell_quantity: " << stocks_[i].sell_quantity << "\n";
-      }
-    }
-    else
-    {
-      // An error occurred.
-      std::cerr << e.message() << std::endl;
-    }
-
-    // Since we are not starting a new operation the io_context will run out of
-    // work to do and the client will exit.
-  }
-
-private:
-  /// The connection to the server.
-  connection connection_;
-
-  /// The data received from the server.
-  std::vector<stock> stocks_;
-};
-
-} // namespace s11n_example
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 3)
-    {
-      std::cerr << "Usage: client <host> <port>" << std::endl;
-      return 1;
-    }
-
-    asio::io_context io_context;
-    s11n_example::client client(io_context, argv[1], argv[2]);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/connection.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/connection.hpp
deleted file mode 100644
index 14d96f7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/connection.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-//
-// connection.hpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SERIALIZATION_CONNECTION_HPP
-#define SERIALIZATION_CONNECTION_HPP
-
-#include <asio.hpp>
-#include <boost/archive/text_iarchive.hpp>
-#include <boost/archive/text_oarchive.hpp>
-#include <functional>
-#include <iomanip>
-#include <memory>
-#include <string>
-#include <sstream>
-#include <tuple>
-#include <vector>
-
-namespace s11n_example {
-
-/// The connection class provides serialization primitives on top of a socket.
-/**
- * Each message sent using this class consists of:
- * @li An 8-byte header containing the length of the serialized data in
- * hexadecimal.
- * @li The serialized data.
- */
-class connection
-{
-public:
-  /// Constructor.
-  connection(const asio::any_io_executor& ex)
-    : socket_(ex)
-  {
-  }
-
-  /// Get the underlying socket. Used for making a connection or for accepting
-  /// an incoming connection.
-  asio::ip::tcp::socket& socket()
-  {
-    return socket_;
-  }
-
-  /// Asynchronously write a data structure to the socket.
-  template <typename T, typename Handler>
-  void async_write(const T& t, Handler handler)
-  {
-    // Serialize the data first so we know how large it is.
-    std::ostringstream archive_stream;
-    boost::archive::text_oarchive archive(archive_stream);
-    archive << t;
-    outbound_data_ = archive_stream.str();
-
-    // Format the header.
-    std::ostringstream header_stream;
-    header_stream << std::setw(header_length)
-      << std::hex << outbound_data_.size();
-    if (!header_stream || header_stream.str().size() != header_length)
-    {
-      // Something went wrong, inform the caller.
-      std::error_code error(asio::error::invalid_argument);
-      asio::post(socket_.get_executor(), std::bind(handler, error));
-      return;
-    }
-    outbound_header_ = header_stream.str();
-
-    // Write the serialized data to the socket. We use "gather-write" to send
-    // both the header and the data in a single write operation.
-    std::vector<asio::const_buffer> buffers;
-    buffers.push_back(asio::buffer(outbound_header_));
-    buffers.push_back(asio::buffer(outbound_data_));
-    asio::async_write(socket_, buffers, handler);
-  }
-
-  /// Asynchronously read a data structure from the socket.
-  template <typename T, typename Handler>
-  void async_read(T& t, Handler handler)
-  {
-    // Issue a read operation to read exactly the number of bytes in a header.
-    void (connection::*f)(const std::error_code&, T&, std::tuple<Handler>)
-      = &connection::handle_read_header<T, Handler>;
-    asio::async_read(socket_, asio::buffer(inbound_header_),
-        std::bind(f,
-          this, asio::placeholders::error, std::ref(t),
-          std::make_tuple(handler)));
-  }
-
-  /// Handle a completed read of a message header.
-  template <typename T, typename Handler>
-  void handle_read_header(const std::error_code& e,
-      T& t, std::tuple<Handler> handler)
-  {
-    if (e)
-    {
-      std::get<0>(handler)(e);
-    }
-    else
-    {
-      // Determine the length of the serialized data.
-      std::istringstream is(std::string(inbound_header_, header_length));
-      std::size_t inbound_data_size = 0;
-      if (!(is >> std::hex >> inbound_data_size))
-      {
-        // Header doesn't seem to be valid. Inform the caller.
-        std::error_code error(asio::error::invalid_argument);
-        std::get<0>(handler)(error);
-        return;
-      }
-
-      // Start an asynchronous call to receive the data.
-      inbound_data_.resize(inbound_data_size);
-      void (connection::*f)(
-          const std::error_code&,
-          T&, std::tuple<Handler>)
-        = &connection::handle_read_data<T, Handler>;
-      asio::async_read(socket_, asio::buffer(inbound_data_),
-        std::bind(f, this,
-          asio::placeholders::error, std::ref(t), handler));
-    }
-  }
-
-  /// Handle a completed read of message data.
-  template <typename T, typename Handler>
-  void handle_read_data(const std::error_code& e,
-      T& t, std::tuple<Handler> handler)
-  {
-    if (e)
-    {
-      std::get<0>(handler)(e);
-    }
-    else
-    {
-      // Extract the data structure from the data just received.
-      try
-      {
-        std::string archive_data(&inbound_data_[0], inbound_data_.size());
-        std::istringstream archive_stream(archive_data);
-        boost::archive::text_iarchive archive(archive_stream);
-        archive >> t;
-      }
-      catch (std::exception& e)
-      {
-        // Unable to decode data.
-        std::error_code error(asio::error::invalid_argument);
-        std::get<0>(handler)(error);
-        return;
-      }
-
-      // Inform caller that data has been received ok.
-      std::get<0>(handler)(e);
-    }
-  }
-
-private:
-  /// The underlying socket.
-  asio::ip::tcp::socket socket_;
-
-  /// The size of a fixed length header.
-  enum { header_length = 8 };
-
-  /// Holds an outbound header.
-  std::string outbound_header_;
-
-  /// Holds the outbound data.
-  std::string outbound_data_;
-
-  /// Holds an inbound header.
-  char inbound_header_[header_length];
-
-  /// Holds the inbound data.
-  std::vector<char> inbound_data_;
-};
-
-typedef std::shared_ptr<connection> connection_ptr;
-
-} // namespace s11n_example
-
-#endif // SERIALIZATION_CONNECTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/server.cpp
deleted file mode 100644
index a032e86..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/server.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <functional>
-#include <iostream>
-#include <vector>
-#include "connection.hpp" // Must come before boost/serialization headers.
-#include <boost/serialization/vector.hpp>
-#include "stock.hpp"
-
-namespace s11n_example {
-
-/// Serves stock quote information to any client that connects to it.
-class server
-{
-public:
-  /// Constructor opens the acceptor and starts waiting for the first incoming
-  /// connection.
-  server(asio::io_context& io_context, unsigned short port)
-    : acceptor_(io_context,
-        asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port))
-  {
-    // Create the data to be sent to each client.
-    stock s;
-    s.code = "ABC";
-    s.name = "A Big Company";
-    s.open_price = 4.56;
-    s.high_price = 5.12;
-    s.low_price = 4.33;
-    s.last_price = 4.98;
-    s.buy_price = 4.96;
-    s.buy_quantity = 1000;
-    s.sell_price = 4.99;
-    s.sell_quantity = 2000;
-    stocks_.push_back(s);
-    s.code = "DEF";
-    s.name = "Developer Entertainment Firm";
-    s.open_price = 20.24;
-    s.high_price = 22.88;
-    s.low_price = 19.50;
-    s.last_price = 19.76;
-    s.buy_price = 19.72;
-    s.buy_quantity = 34000;
-    s.sell_price = 19.85;
-    s.sell_quantity = 45000;
-    stocks_.push_back(s);
-
-    // Start an accept operation for a new connection.
-    connection_ptr new_conn(new connection(acceptor_.get_executor()));
-    acceptor_.async_accept(new_conn->socket(),
-        std::bind(&server::handle_accept, this,
-          asio::placeholders::error, new_conn));
-  }
-
-  /// Handle completion of a accept operation.
-  void handle_accept(const std::error_code& e, connection_ptr conn)
-  {
-    if (!e)
-    {
-      // Successfully accepted a new connection. Send the list of stocks to the
-      // client. The connection::async_write() function will automatically
-      // serialize the data structure for us.
-      conn->async_write(stocks_,
-          std::bind(&server::handle_write, this,
-            asio::placeholders::error, conn));
-    }
-
-    // Start an accept operation for a new connection.
-    connection_ptr new_conn(new connection(acceptor_.get_executor()));
-    acceptor_.async_accept(new_conn->socket(),
-        std::bind(&server::handle_accept, this,
-          asio::placeholders::error, new_conn));
-  }
-
-  /// Handle completion of a write operation.
-  void handle_write(const std::error_code& e, connection_ptr conn)
-  {
-    // Nothing to do. The socket will be closed automatically when the last
-    // reference to the connection object goes away.
-  }
-
-private:
-  /// The acceptor object used to accept incoming socket connections.
-  asio::ip::tcp::acceptor acceptor_;
-
-  /// The data to be sent to each client.
-  std::vector<stock> stocks_;
-};
-
-} // namespace s11n_example
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    // Check command line arguments.
-    if (argc != 2)
-    {
-      std::cerr << "Usage: server <port>" << std::endl;
-      return 1;
-    }
-    unsigned short port = std::stoi(argv[1]);
-
-    asio::io_context io_context;
-    s11n_example::server server(io_context, port);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/stock.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/stock.hpp
deleted file mode 100644
index bb30551..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/serialization/stock.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// stock.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SERIALIZATION_STOCK_HPP
-#define SERIALIZATION_STOCK_HPP
-
-#include <string>
-
-namespace s11n_example {
-
-/// Structure to hold information about a single stock.
-struct stock
-{
-  std::string code;
-  std::string name;
-  double open_price;
-  double high_price;
-  double low_price;
-  double last_price;
-  double buy_price;
-  int buy_quantity;
-  double sell_price;
-  int sell_quantity;
-
-  template <typename Archive>
-  void serialize(Archive& ar, const unsigned int version)
-  {
-    ar & code;
-    ar & name;
-    ar & open_price;
-    ar & high_price;
-    ar & low_price;
-    ar & last_price;
-    ar & buy_price;
-    ar & buy_quantity;
-    ar & sell_price;
-    ar & sell_quantity;
-  }
-};
-
-} // namespace s11n_example
-
-#endif // SERIALIZATION_STOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/.gitignore
deleted file mode 100644
index 701b1b8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
-log.txt
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/basic_logger.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/basic_logger.hpp
deleted file mode 100644
index 6e4d7a0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/basic_logger.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//
-// basic_logger.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SERVICES_BASIC_LOGGER_HPP
-#define SERVICES_BASIC_LOGGER_HPP
-
-#include <asio.hpp>
-#include <string>
-
-namespace services {
-
-/// Class to provide simple logging functionality. Use the services::logger
-/// typedef.
-template <typename Service>
-class basic_logger
-{
-public:
-  /// The type of the service that will be used to provide timer operations.
-  typedef Service service_type;
-
-  /// The native implementation type of the timer.
-  typedef typename service_type::impl_type impl_type;
-
-  /// Constructor.
-  /**
-   * This constructor creates a logger.
-   *
-   * @param context The execution context used to locate the logger service.
-   *
-   * @param identifier An identifier for this logger.
-   */
-  explicit basic_logger(asio::execution_context& context,
-      const std::string& identifier)
-    : service_(asio::use_service<Service>(context)),
-      impl_(service_.null())
-  {
-    service_.create(impl_, identifier);
-  }
-
-  basic_logger(const basic_logger&) = delete;
-  basic_logger& operator=(basic_logger&) = delete;
-
-  /// Destructor.
-  ~basic_logger()
-  {
-    service_.destroy(impl_);
-  }
-
-  /// Set the output file for all logger instances.
-  void use_file(const std::string& file)
-  {
-    service_.use_file(impl_, file);
-  }
-
-  /// Log a message.
-  void log(const std::string& message)
-  {
-    service_.log(impl_, message);
-  }
-
-private:
-  /// The backend service implementation.
-  service_type& service_;
-
-  /// The underlying native implementation.
-  impl_type impl_;
-};
-
-} // namespace services
-
-#endif // SERVICES_BASIC_LOGGER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/daytime_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/daytime_client.cpp
deleted file mode 100644
index 360134f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/daytime_client.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//
-// daytime_client.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <functional>
-#include <iostream>
-#include "logger.hpp"
-
-using asio::ip::tcp;
-
-char read_buffer[1024];
-
-void read_handler(const asio::error_code& e,
-    std::size_t bytes_transferred, tcp::socket* s)
-{
-  if (!e)
-  {
-    std::cout.write(read_buffer, bytes_transferred);
-
-    s->async_read_some(asio::buffer(read_buffer),
-        std::bind(read_handler, asio::placeholders::error,
-          asio::placeholders::bytes_transferred, s));
-  }
-  else
-  {
-    asio::execution_context& context = asio::query(
-        s->get_executor(), asio::execution::context);
-    services::logger logger(context, "read_handler");
-
-    std::string msg = "Read error: ";
-    msg += e.message();
-    logger.log(msg);
-  }
-}
-
-void connect_handler(const asio::error_code& e, tcp::socket* s)
-{
-  asio::execution_context& context = asio::query(
-      s->get_executor(), asio::execution::context);
-  services::logger logger(context, "connect_handler");
-
-  if (!e)
-  {
-    logger.log("Connection established");
-
-    s->async_read_some(asio::buffer(read_buffer),
-        std::bind(read_handler, asio::placeholders::error,
-          asio::placeholders::bytes_transferred, s));
-  }
-  else
-  {
-    std::string msg = "Unable to establish connection: ";
-    msg += e.message();
-    logger.log(msg);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: daytime_client <host>" << std::endl;
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    // Set the name of the file that all logger instances will use.
-    services::logger logger(io_context, "");
-    logger.use_file("log.txt");
-
-    // Resolve the address corresponding to the given host.
-    tcp::resolver resolver(io_context);
-    tcp::resolver::results_type endpoints =
-      resolver.resolve(argv[1], "daytime");
-
-    // Start an asynchronous connect.
-    tcp::socket socket(io_context);
-    asio::async_connect(socket, endpoints,
-        std::bind(connect_handler,
-          asio::placeholders::error, &socket));
-
-    // Run the io_context until all operations have finished.
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger.hpp
deleted file mode 100644
index 2ab366c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// logger.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SERVICES_LOGGER_HPP
-#define SERVICES_LOGGER_HPP
-
-#include "basic_logger.hpp"
-#include "logger_service.hpp"
-
-namespace services {
-
-/// Typedef for typical logger usage.
-typedef basic_logger<logger_service> logger;
-
-} // namespace services
-
-#endif // SERVICES_LOGGER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.cpp
deleted file mode 100644
index 74d67c7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-// logger_service.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "logger_service.hpp"
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.hpp
deleted file mode 100644
index d0beaf1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/services/logger_service.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//
-// logger_service.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SERVICES_LOGGER_SERVICE_HPP
-#define SERVICES_LOGGER_SERVICE_HPP
-
-#include <asio.hpp>
-#include <functional>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <thread>
-
-namespace services {
-
-/// Service implementation for the logger.
-class logger_service
-  : public asio::execution_context::service
-{
-public:
-  /// The type used to identify this service in the execution context.
-  typedef logger_service key_type;
-
-  /// The backend implementation of a logger.
-  struct logger_impl
-  {
-    explicit logger_impl(const std::string& ident) : identifier(ident) {}
-    std::string identifier;
-  };
-
-  /// The type for an implementation of the logger.
-  typedef logger_impl* impl_type;
-
-  /// Constructor creates a thread to run a private io_context.
-  logger_service(asio::execution_context& context)
-    : asio::execution_context::service(context),
-      work_io_context_(),
-      work_(asio::make_work_guard(work_io_context_)),
-      work_thread_([this]{ work_io_context_.run(); })
-  {
-  }
-
-  logger_service(const logger_service&) = delete;
-  logger_service& operator=(const logger_service&) = delete;;
-
-  /// Destructor shuts down the private io_context.
-  ~logger_service()
-  {
-    /// Indicate that we have finished with the private io_context. Its
-    /// io_context::run() function will exit once all other work has completed.
-    work_.reset();
-    if (work_thread_.joinable())
-      work_thread_.join();
-  }
-
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown()
-  {
-  }
-
-  /// Return a null logger implementation.
-  impl_type null() const
-  {
-    return 0;
-  }
-
-  /// Create a new logger implementation.
-  void create(impl_type& impl, const std::string& identifier)
-  {
-    impl = new logger_impl(identifier);
-  }
-
-  /// Destroy a logger implementation.
-  void destroy(impl_type& impl)
-  {
-    delete impl;
-    impl = null();
-  }
-
-  /// Set the output file for the logger. The current implementation sets the
-  /// output file for all logger instances, and so the impl parameter is not
-  /// actually needed. It is retained here to illustrate how service functions
-  /// are typically defined.
-  void use_file(impl_type& /*impl*/, const std::string& file)
-  {
-    // Pass the work of opening the file to the background thread.
-    asio::post(work_io_context_,
-        std::bind(&logger_service::use_file_impl, this, file));
-  }
-
-  /// Log a message.
-  void log(impl_type& impl, const std::string& message)
-  {
-    // Format the text to be logged.
-    std::ostringstream os;
-    os << impl->identifier << ": " << message;
-
-    // Pass the work of writing to the file to the background thread.
-    asio::post(work_io_context_,
-        std::bind(&logger_service::log_impl, this, os.str()));
-  }
-
-private:
-  /// Helper function used to open the output file from within the private
-  /// io_context's thread.
-  void use_file_impl(const std::string& file)
-  {
-    ofstream_.close();
-    ofstream_.clear();
-    ofstream_.open(file.c_str());
-  }
-
-  /// Helper function used to log a message from within the private io_context's
-  /// thread.
-  void log_impl(const std::string& text)
-  {
-    ofstream_ << text << std::endl;
-  }
-
-  /// Private io_context used for performing logging operations.
-  asio::io_context work_io_context_;
-
-  /// Work for the private io_context to perform. If we do not give the
-  /// io_context some work to do then the io_context::run() function will exit
-  /// immediately.
-  asio::executor_work_guard<
-      asio::io_context::executor_type> work_;
-
-  /// Thread used for running the work io_context's run loop.
-  std::thread work_thread_;
-
-  /// The file to which log messages will be written.
-  std::ofstream ofstream_;
-};
-
-} // namespace services
-
-#endif // SERVICES_LOGGER_SERVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/.gitignore
deleted file mode 100644
index e11e0de..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-sync_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/socks4.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/socks4.hpp
deleted file mode 100644
index ed79940..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/socks4.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-//
-// socks4.hpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SOCKS4_HPP
-#define SOCKS4_HPP
-
-#include <array>
-#include <string>
-#include <asio/buffer.hpp>
-#include <asio/ip/tcp.hpp>
-
-namespace socks4 {
-
-const unsigned char version = 0x04;
-
-class request
-{
-public:
-  enum command_type
-  {
-    connect = 0x01,
-    bind = 0x02
-  };
-
-  request(command_type cmd, const asio::ip::tcp::endpoint& endpoint,
-      const std::string& user_id)
-    : version_(version),
-      command_(cmd),
-      user_id_(user_id),
-      null_byte_(0)
-  {
-    // Only IPv4 is supported by the SOCKS 4 protocol.
-    if (endpoint.protocol() != asio::ip::tcp::v4())
-    {
-      throw std::system_error(
-          asio::error::address_family_not_supported);
-    }
-
-    // Convert port number to network byte order.
-    unsigned short port = endpoint.port();
-    port_high_byte_ = (port >> 8) & 0xff;
-    port_low_byte_ = port & 0xff;
-
-    // Save IP address in network byte order.
-    address_ = endpoint.address().to_v4().to_bytes();
-  }
-
-  std::array<asio::const_buffer, 7> buffers() const
-  {
-    return
-    {
-      {
-        asio::buffer(&version_, 1),
-        asio::buffer(&command_, 1),
-        asio::buffer(&port_high_byte_, 1),
-        asio::buffer(&port_low_byte_, 1),
-        asio::buffer(address_),
-        asio::buffer(user_id_),
-        asio::buffer(&null_byte_, 1)
-      }
-    };
-  }
-
-private:
-  unsigned char version_;
-  unsigned char command_;
-  unsigned char port_high_byte_;
-  unsigned char port_low_byte_;
-  asio::ip::address_v4::bytes_type address_;
-  std::string user_id_;
-  unsigned char null_byte_;
-};
-
-class reply
-{
-public:
-  enum status_type
-  {
-    request_granted = 0x5a,
-    request_failed = 0x5b,
-    request_failed_no_identd = 0x5c,
-    request_failed_bad_user_id = 0x5d
-  };
-
-  reply()
-    : null_byte_(0),
-      status_()
-  {
-  }
-
-  std::array<asio::mutable_buffer, 5> buffers()
-  {
-    return
-    {
-      {
-        asio::buffer(&null_byte_, 1),
-        asio::buffer(&status_, 1),
-        asio::buffer(&port_high_byte_, 1),
-        asio::buffer(&port_low_byte_, 1),
-        asio::buffer(address_)
-      }
-    };
-  }
-
-  bool success() const
-  {
-    return null_byte_ == 0 && status_ == request_granted;
-  }
-
-  unsigned char status() const
-  {
-    return status_;
-  }
-
-  asio::ip::tcp::endpoint endpoint() const
-  {
-    unsigned short port = port_high_byte_;
-    port = (port << 8) & 0xff00;
-    port = port | port_low_byte_;
-
-    asio::ip::address_v4 address(address_);
-
-    return asio::ip::tcp::endpoint(address, port);
-  }
-
-private:
-  unsigned char null_byte_;
-  unsigned char status_;
-  unsigned char port_high_byte_;
-  unsigned char port_low_byte_;
-  asio::ip::address_v4::bytes_type address_;
-};
-
-} // namespace socks4
-
-#endif // SOCKS4_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/sync_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/sync_client.cpp
deleted file mode 100644
index f661aca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/socks4/sync_client.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//
-// sync_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <iostream>
-#include <iomanip>
-#include <ostream>
-#include <string>
-#include <asio.hpp>
-#include "socks4.hpp"
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 4)
-    {
-      std::cout << "Usage: sync_client <socks4server> <socks4port> <user>\n";
-      std::cout << "Examples:\n";
-      std::cout << "  sync_client 127.0.0.1 1080 chris\n";
-      std::cout << "  sync_client localhost socks chris\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    // Get a list of endpoints corresponding to the SOCKS 4 server name.
-    tcp::resolver resolver(io_context);
-    auto endpoints = resolver.resolve(argv[1], argv[2]);
-
-    // Try each endpoint until we successfully establish a connection to the
-    // SOCKS 4 server.
-    tcp::socket socket(io_context);
-    asio::connect(socket, endpoints);
-
-    // Get an endpoint for the Boost website. This will be passed to the SOCKS
-    // 4 server. Explicitly specify IPv4 since SOCKS 4 does not support IPv6.
-    auto http_endpoint =
-      *resolver.resolve(tcp::v4(), "www.boost.org", "http").begin();
-
-    // Send the request to the SOCKS 4 server.
-    socks4::request socks_request(
-        socks4::request::connect, http_endpoint, argv[3]);
-    asio::write(socket, socks_request.buffers());
-
-    // Receive a response from the SOCKS 4 server.
-    socks4::reply socks_reply;
-    asio::read(socket, socks_reply.buffers());
-
-    // Check whether we successfully negotiated with the SOCKS 4 server.
-    if (!socks_reply.success())
-    {
-      std::cout << "Connection failed.\n";
-      std::cout << "status = 0x" << std::hex << socks_reply.status();
-      return 1;
-    }
-
-    // Form the HTTP request. We specify the "Connection: close" header so that
-    // the server will close the socket after transmitting the response. This
-    // will allow us to treat all data up until the EOF as the response.
-    std::string request =
-      "GET / HTTP/1.0\r\n"
-      "Host: www.boost.org\r\n"
-      "Accept: */*\r\n"
-      "Connection: close\r\n\r\n";
-
-    // Send the HTTP request.
-    asio::write(socket, asio::buffer(request));
-
-    // Read until EOF, writing data to output as we go.
-    std::array<char, 512> response;
-    std::error_code error;
-    while (std::size_t s = socket.read_some(
-          asio::buffer(response), error))
-      std::cout.write(response.data(), s);
-    if (error != asio::error::eof)
-      throw std::system_error(error);
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/.gitignore
deleted file mode 100644
index 6b8a121..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/.gitignore
+++ /dev/null
@@ -1,12 +0,0 @@
-.deps
-.dirstamp
-parallel_grep
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/echo_server.cpp
deleted file mode 100644
index ae949d6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/echo_server.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// echo_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/spawn.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/write.hpp>
-#include <iostream>
-#include <memory>
-
-using asio::ip::tcp;
-
-class session : public std::enable_shared_from_this<session>
-{
-public:
-  explicit session(asio::io_context& io_context, tcp::socket socket)
-    : socket_(std::move(socket)),
-      timer_(io_context),
-      strand_(io_context.get_executor())
-  {
-  }
-
-  void go()
-  {
-    auto self(shared_from_this());
-    asio::spawn(strand_,
-        [this, self](asio::yield_context yield)
-        {
-          try
-          {
-            char data[128];
-            for (;;)
-            {
-              timer_.expires_after(std::chrono::seconds(10));
-              std::size_t n = socket_.async_read_some(asio::buffer(data), yield);
-              asio::async_write(socket_, asio::buffer(data, n), yield);
-            }
-          }
-          catch (std::exception& e)
-          {
-            socket_.close();
-            timer_.cancel();
-          }
-        }, asio::detached);
-
-    asio::spawn(strand_,
-        [this, self](asio::yield_context yield)
-        {
-          while (socket_.is_open())
-          {
-            std::error_code ignored_ec;
-            timer_.async_wait(yield[ignored_ec]);
-            if (timer_.expiry() <= asio::steady_timer::clock_type::now())
-              socket_.close();
-          }
-        }, asio::detached);
-  }
-
-private:
-  tcp::socket socket_;
-  asio::steady_timer timer_;
-  asio::strand<asio::io_context::executor_type> strand_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    asio::spawn(io_context,
-        [&](asio::yield_context yield)
-        {
-          tcp::acceptor acceptor(io_context,
-            tcp::endpoint(tcp::v4(), std::atoi(argv[1])));
-
-          for (;;)
-          {
-            std::error_code ec;
-            tcp::socket socket(io_context);
-            acceptor.async_accept(socket, yield[ec]);
-            if (!ec)
-            {
-              std::make_shared<session>(io_context, std::move(socket))->go();
-            }
-          }
-        },
-        [](std::exception_ptr e)
-        {
-          if (e)
-            std::rethrow_exception(e);
-        });
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/parallel_grep.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/parallel_grep.cpp
deleted file mode 100644
index f4a5b11..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/spawn/parallel_grep.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//
-// parallel_grep.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/detached.hpp>
-#include <asio/dispatch.hpp>
-#include <asio/post.hpp>
-#include <asio/spawn.hpp>
-#include <asio/strand.hpp>
-#include <asio/thread_pool.hpp>
-#include <fstream>
-#include <iostream>
-#include <string>
-
-using asio::detached;
-using asio::dispatch;
-using asio::spawn;
-using asio::strand;
-using asio::thread_pool;
-using asio::yield_context;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc < 2)
-    {
-      std::cerr << "Usage: parallel_grep <string> <files...>\n";
-      return 1;
-    }
-
-    // We use a fixed size pool of threads for reading the input files. The
-    // number of threads is automatically determined based on the number of
-    // CPUs available in the system.
-    thread_pool pool;
-
-    // To prevent the output from being garbled, we use a strand to synchronise
-    // printing.
-    strand<thread_pool::executor_type> output_strand(pool.get_executor());
-
-    // Spawn a new coroutine for each file specified on the command line.
-    std::string search_string = argv[1];
-    for (int argn = 2; argn < argc; ++argn)
-    {
-      std::string input_file = argv[argn];
-      spawn(pool,
-        [=](yield_context yield)
-        {
-          std::ifstream is(input_file.c_str());
-          std::string line;
-          std::size_t line_num = 0;
-          while (std::getline(is, line))
-          {
-            // If we find a match, send a message to the output.
-            if (line.find(search_string) != std::string::npos)
-            {
-              dispatch(output_strand,
-                  [=]
-                  {
-                    std::cout << input_file << ':' << line << std::endl;
-                  });
-            }
-
-            // Every so often we yield control to another coroutine.
-            if (++line_num % 10 == 0)
-              post(yield);
-          }
-        }, detached);
-    }
-
-    // Join the thread pool to wait for all the spawned tasks to complete.
-    pool.join();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/.gitignore
deleted file mode 100644
index a678112..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-server
-client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/README b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/README
deleted file mode 100644
index 8304d06..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/README
+++ /dev/null
@@ -1,8 +0,0 @@
-The passphrase for both the CA and server private keys is "test".
-
-
--------------------------------------------------------------------------------
-Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-
-Distributed under the Boost Software License, Version 1.0. (See accompanying
-file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/ca.pem b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/ca.pem
deleted file mode 100644
index 4580bc1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/ca.pem
+++ /dev/null
@@ -1,50 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDVDCCAjygAwIBAgIUX3cVQ47QyJp7SOy0RPzP743W9MwwDQYJKoZIhvcNAQEL
-BQAwOzELMAkGA1UEBhMCQVUxDDAKBgNVBAgMA05TVzEPMA0GA1UEBwwGU3lkbmV5
-MQ0wCwYDVQQKDARhc2lvMB4XDTIxMTExMTIxMTA1MloXDTI2MTExMDIxMTA1Mlow
-OzELMAkGA1UEBhMCQVUxDDAKBgNVBAgMA05TVzEPMA0GA1UEBwwGU3lkbmV5MQ0w
-CwYDVQQKDARhc2lvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyURD
-LjKxTCkapmWhY0bP1NaaOPzIJTTB0dzREOlmRmBmiHpW7DaRx7qBm6jYDKQ7OCbz
-30/j8K4TjHOLIwxzXhXMYTJOcN2giPHNUBvm9oEuDAhYgltArJQnBBEH+3C1hCIv
-1+uhTWo0HpGXTeJnvboTZ1YgmbOgr6lMhNiu9QmPX885DxWf6sDq8mRgCDX2x8sk
-Ls0HuLSo88Osjx532yEhnrZgexsByhoRD3yrKHV5mWpaunk5BMsP/XMuQHayFmbO
-siqnHJoL1znGVH003PcBGmEDmoIUqhLiBi2gWGu1pmckP9loqQUTEn0aLOVclHf4
-slWq344zh4tJCpQMfQIDAQABo1AwTjAdBgNVHQ4EFgQUfiX1CMQrGDi9mIBAg9cg
-m0RwLJUwHwYDVR0jBBgwFoAUfiX1CMQrGDi9mIBAg9cgm0RwLJUwDAYDVR0TBAUw
-AwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAnDnVNSb8z/pNFaZ6YAZ+ukfNT3jjbGm1
-10BOLqJj8s5A8/JkwjaWhky/DuGXDywgEvzXC18aNAxASeqO8h9pAZtszu6NWB4s
-h3r+dEQakMacxrZ+jBL/cYLrUv9r3KMPKxaDnplkamqFA/9eNmoV7vDyGtGPZuD6
-oTROtQqqDSrxthCkqnibAfusi7RmlCdvJa0kVK7krKJZAhi8W9f32+lBPv9oq3Ns
-dAxnOj/D3UnhNoIt0EdjqUdLo2U39dt5s5Syj2rFUAgfbc02Rwx65kq8AjTRlW/M
-KDpGsifwIB8b7wActMUO8c3GptptNVWmFm5+Mmk54P//P3tIAx9KXw==
------END CERTIFICATE-----
------BEGIN ENCRYPTED PRIVATE KEY-----
-MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIPcVUeQ7ZElgCAggA
-MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECGKlFVN6/gIlBIIEyJPeknsA5dvV
-WK27AZzs4wM6WrsD6ba+kPJyZTpon5pn4eoTiw4UCvo7C+21G9jCqbIbDrgTWHwH
-zu6YrBFTZgRUpdLkLsyUsp4UJrZ8xJ7N/jWlG763CyluFE5oBFLz2Vt/DSDSaWdA
-sKdxua/1kvw+KYoDqlObMFIspM5TrndcMnWkOgyvQAvnH0NZXFFBa4QGFrwWDrCo
-m12CzMLwaPMrNFBffCTqZnL1AajT+EYqPTi+cQ5mkRpZ2cuzhdug2eki1KkD12ZN
-3d8Ehl8bfbLEqRE/HnggleRRt7ia1xkzruqQp14JA2UsrioGMF5nvWgWrbyHfpui
-KrCsDwDelrArW/GCki53QBQMuH8Q1YmoNrRZwlG257eA1LiJvmxRyIjKYu0RP+Q8
-EOldycy51VsPVPApUbv9r4IJldrIJiwlmRxxM36uKtFhfojnsWzJORDYI8C37uKi
-UEPiD4GSEH6C0lGO94IoZPjl9z/rZ0qZx1VRHl3nxZc0AQvvj9bWMbyRwsgb6wod
-P8JSy6uEib9UxuenNHzTd48GcNhJbhOqd4IV0XKhi8W1Kil3mMdc3QAwKaLTx12/
-1GrbMui061uyeM6Rf6Xao0PApDnUNmxcFSTsoarG0yH7Q0WZMgKTDCCGhhtZKlE6
-x7pRsnxiFaIpoh32EVIRI+ZXh2rXBcwa2ew0aEccRXtPFvcmdjevkrHuCggc+M+Y
-seFqTHVGWf8eS6o08w095DboD0vFpZXZMRfycTbA7BiE4NYE/uc7v5cH3Ax9l2ef
-zG7o9idDt+/RX7OcetxDFw4eQbq7PfjvrfXS1DcRUEyJ04emh7oxlkAUUNsFtabN
-T0ggvHxcQWkYRE5oPlkbgpwKpK4LDcApXKFwCDKPur2W5Q7KHRfDLtSvZvYarJum
-8j2pGpEis/bdTih29ofNsX6a0Yo5Tlj+9+1c/6/Xi7XvRk/Vbgkoa3iVQ3ckdCuZ
-vO7cRYZBBs6W/Ti3hWFzPEX9FfcnSUp9bEnH4ASnmUcp8PDBJYeaI6HqpO3XbkbF
-l70eDNakd2cDNjQzkFpBT7HO+HtqU3xNt9K0z2gMB7iTDVFyIzh26joCR2O8tiqS
-wUJFkoLPb74GSB7WzE+gb4jXX6n9609PUoR3f896mM34uX3CsY8lA+/0ZGpHnFDA
-ToKdmz6WKIAw0E20nyzLuLwPZgj7HLcR7zza4raipe9QxIdyJr5O+jzGt+OjSM9b
-K1agibRE5DChqQ+P+ikOc6nG7UNyn+lKSjGEbwuzi8F0iugMgcTc/vYO8OWDNGpd
-D1euA5OuVPdfatFa16Fyr4MJJIfE83C4/kSj05fdoyb6pJkOjHhUppVMe+ES5kwl
-YI8RES2XVJzUSxnWsIM613YlMgIZ9xgcuIADnO7gaKJ4RQG+9wJ853Uo4+n89K7F
-Y6KzihuYAUkbAw1pPo1TODom7A/gB9stqRUSQlZWmIgtnJ8wPjt/we0gzPM8LQzb
-ye4KOLjH5iquFc4MU4TtN3gvp9P5R9UFrGeMImS5eMUmBQHckDNdIAtMj7M1wUpR
-JVrzDXWDjC21sLn95NtNMPb+FRlt/biTV3IE3ZmX0kbuCRoH7b7hhR41Zpoajwl0
-FqYigB5gnVodGUWuBgDUqA==
------END ENCRYPTED PRIVATE KEY-----
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/client.cpp
deleted file mode 100644
index 6799d2a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/client.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include "asio.hpp"
-#include "asio/ssl.hpp"
-
-using asio::ip::tcp;
-using std::placeholders::_1;
-using std::placeholders::_2;
-
-enum { max_length = 1024 };
-
-class client
-{
-public:
-  client(asio::io_context& io_context,
-      asio::ssl::context& context,
-      const tcp::resolver::results_type& endpoints)
-    : socket_(io_context, context)
-  {
-    socket_.set_verify_mode(asio::ssl::verify_peer);
-    socket_.set_verify_callback(
-        std::bind(&client::verify_certificate, this, _1, _2));
-
-    connect(endpoints);
-  }
-
-private:
-  bool verify_certificate(bool preverified,
-      asio::ssl::verify_context& ctx)
-  {
-    // The verify callback can be used to check whether the certificate that is
-    // being presented is valid for the peer. For example, RFC 2818 describes
-    // the steps involved in doing this for HTTPS. Consult the OpenSSL
-    // documentation for more details. Note that the callback is called once
-    // for each certificate in the certificate chain, starting from the root
-    // certificate authority.
-
-    // In this example we will simply print the certificate's subject name.
-    char subject_name[256];
-    X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
-    X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
-    std::cout << "Verifying " << subject_name << "\n";
-
-    return preverified;
-  }
-
-  void connect(const tcp::resolver::results_type& endpoints)
-  {
-    asio::async_connect(socket_.lowest_layer(), endpoints,
-        [this](const std::error_code& error,
-          const tcp::endpoint& /*endpoint*/)
-        {
-          if (!error)
-          {
-            handshake();
-          }
-          else
-          {
-            std::cout << "Connect failed: " << error.message() << "\n";
-          }
-        });
-  }
-
-  void handshake()
-  {
-    socket_.async_handshake(asio::ssl::stream_base::client,
-        [this](const std::error_code& error)
-        {
-          if (!error)
-          {
-            send_request();
-          }
-          else
-          {
-            std::cout << "Handshake failed: " << error.message() << "\n";
-          }
-        });
-  }
-
-  void send_request()
-  {
-    std::cout << "Enter message: ";
-    std::cin.getline(request_, max_length);
-    size_t request_length = std::strlen(request_);
-
-    asio::async_write(socket_,
-        asio::buffer(request_, request_length),
-        [this](const std::error_code& error, std::size_t length)
-        {
-          if (!error)
-          {
-            receive_response(length);
-          }
-          else
-          {
-            std::cout << "Write failed: " << error.message() << "\n";
-          }
-        });
-  }
-
-  void receive_response(std::size_t length)
-  {
-    asio::async_read(socket_,
-        asio::buffer(reply_, length),
-        [this](const std::error_code& error, std::size_t length)
-        {
-          if (!error)
-          {
-            std::cout << "Reply: ";
-            std::cout.write(reply_, length);
-            std::cout << "\n";
-          }
-          else
-          {
-            std::cout << "Read failed: " << error.message() << "\n";
-          }
-        });
-  }
-
-  asio::ssl::stream<tcp::socket> socket_;
-  char request_[max_length];
-  char reply_[max_length];
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::resolver resolver(io_context);
-    auto endpoints = resolver.resolve(argv[1], argv[2]);
-
-    asio::ssl::context ctx(asio::ssl::context::sslv23);
-    ctx.load_verify_file("ca.pem");
-
-    client c(io_context, ctx, endpoints);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/dh4096.pem b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/dh4096.pem
deleted file mode 100644
index dc2559c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/dh4096.pem
+++ /dev/null
@@ -1,25 +0,0 @@
------BEGIN X9.42 DH PARAMETERS-----
-MIIELQKCAgEA8eEBgatlTk0QKIwUqHsteHJXzEr0xAW7RLeNid8DdGjTnFw68eV+
-s1YbipEqQVTFG+VZPaof9v0CH2KOdbgWD0KRPC49HB8O/wARFKpy5eJltVe1r07w
-+V1Vjciqkh/vGq/yFQsbqwyWJy6AelsbHdSC9Bg9pmu4+pbVGW15zK7PkfjfoO9V
-JYbhdqFIPg+9NRRWsl/U9UoyeeIGImI9I4k3fqtv311C6VVErFZylCj7nn45L7IY
-GfPcCO5E8FD6EqBv5WnhMNYHMJu9brRvOoAyAyWprqR+aVzHd+DFamDQdsuQjKTk
-3+r07znWJfjp6FVTzR5SvjrKg1knK5TibIksoKOlsFZ06bGkFWHjqXNAKhnSpCiU
-GJd0qe7pTD+TGQJGWskJpoph+tkICUa+6MyzP9+U6T9hISIY/BpVuWn/iwdLqsvV
-s5bg2RjRraww/4Rjm0NyEOTk2MxaLB9gcyu6zcrhX5XRiMgt+jhKwEMwJCEJYkxn
-C0yv08A5v6RceFm1jY+8FT0IzRqsWIGV7beNdqtE0B4LBTuN1yQ6x8CKEb6mbIHG
-d0XLGppELhD8QUwAr5HiVGTAsS9JlMGgXVkyDtxrVSeS1zHWt77skRQ9UlfJfYMm
-5wxHj5QCdQ7ma3oMMZBZutNlkevMzYHIxwqhZstf4ud0j0VMftwZ3GMCggIBAJL7
-cU6/YSxzYDGUcPc6WGT+FAghR0LdhT3Q3Xz1rQRBwSSMPm9NZhyJC3fb+hBl/44X
-AHOu1/3dYIWlXPMuHZZdtlt+hkD/sIob16By20Z0p81Kvh3HQglVDJGlFzTmQbTd
-CM/EP8eJFiNeMcJB0RgeKyzikRsV4r/acZZM56swTlsRvSDFMh3v9YyYTZbCTwxm
-PIVOsxI8uBoWRCzY3yWzjmlZ2u5TR+Z0IVonmNqk6XAKRgxV12YfQVXzzpPZQA9S
-GHoD/NQoMdBAi3p4pLEYJ5qMRLYPQbBfSNu5eP9e5uZOiBp/28bVnzEelDGuFupr
-lvywkZEVL1KaYtZ/dGkPFXt+A7mNsw5xeDTRjgL4uUJvCNIkjgVEfIrLdUf5IVsU
-V8BgunAvgfH+Hy6Tx89v/QGsUWJPhjkSZnXwJ7Ipcsm+Zg0zAZwKDZEQtDLXVPRL
-OfCfXMXvlw2u6OHlhSbqO69zZG3dJTlcnjy06n4JYcUim7Mj3Kduige6VWofeEk9
-M/kHrPqNdFE5tHLh2nHcw9yExKHN+l/OUGAvNDfOVS+S+fNSKT0RfC9dMpHLN+Ok
-fGuskGzLQAVYF+DYEcnJ++0LEFtd0J381ndSc0iJuH60rKDTqxoRqv7lcdwLFlEV
-sQSRoas8s+y+b3FfSu7j0p44qLG9oxZ/WFcWnuUyAiEAjvAD9p3bw8AH0s7dUrX/
-RT1Ge+J/n0tlsgw+LY3zafE=
------END X9.42 DH PARAMETERS-----
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.cpp
deleted file mode 100644
index 90fdb92..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <functional>
-#include <iostream>
-#include "asio.hpp"
-#include "asio/ssl.hpp"
-
-using asio::ip::tcp;
-
-class session : public std::enable_shared_from_this<session>
-{
-public:
-  session(asio::ssl::stream<tcp::socket> socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    do_handshake();
-  }
-
-private:
-  void do_handshake()
-  {
-    auto self(shared_from_this());
-    socket_.async_handshake(asio::ssl::stream_base::server,
-        [this, self](const std::error_code& error)
-        {
-          if (!error)
-          {
-            do_read();
-          }
-        });
-  }
-
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_),
-        [this, self](const std::error_code& ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            do_write(length);
-          }
-        });
-  }
-
-  void do_write(std::size_t length)
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this, self](const std::error_code& ec,
-          std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_read();
-          }
-        });
-  }
-
-  asio::ssl::stream<tcp::socket> socket_;
-  char data_[1024];
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, unsigned short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)),
-      context_(asio::ssl::context::sslv23)
-  {
-    context_.set_options(
-        asio::ssl::context::default_workarounds
-        | asio::ssl::context::no_sslv2
-        | asio::ssl::context::single_dh_use);
-    context_.set_password_callback(std::bind(&server::get_password, this));
-    context_.use_certificate_chain_file("server.pem");
-    context_.use_private_key_file("server.pem", asio::ssl::context::pem);
-    context_.use_tmp_dh_file("dh4096.pem");
-
-    do_accept();
-  }
-
-private:
-  std::string get_password() const
-  {
-    return "test";
-  }
-
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](const std::error_code& error, tcp::socket socket)
-        {
-          if (!error)
-          {
-            std::make_shared<session>(
-                asio::ssl::stream<tcp::socket>(
-                  std::move(socket), context_))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-  asio::ssl::context context_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    using namespace std; // For atoi.
-    server s(io_context, atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.pem b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.pem
deleted file mode 100644
index a7bcba7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/ssl/server.pem
+++ /dev/null
@@ -1,99 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDDjCCAfYCFGGcJXlIeQHiq/qOakbISU5cihPvMA0GCSqGSIb3DQEBCwUAMDsx
-CzAJBgNVBAYTAkFVMQwwCgYDVQQIDANOU1cxDzANBgNVBAcMBlN5ZG5leTENMAsG
-A1UECgwEYXNpbzAeFw0yMTExMTEyMTExNDRaFw0yNjExMTAyMTExNDRaMEwxCzAJ
-BgNVBAYTAkFVMQwwCgYDVQQIDANOU1cxDzANBgNVBAcMBlN5ZG5leTENMAsGA1UE
-CgwEYXNpbzEPMA0GA1UECwwGc2VydmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-MIIBCgKCAQEAu67TzZCFNTZ5c1gKwXfdTH3bP0OB5n6dqXGK6jkPb699dyM4oPtY
-2f+OyxJspk8D5pX6HuZ+hLGAsHxfCN+A3RegVZJCR/gXrrMPl/6PfDxtkeFXWy+6
-NAPxqppMj8gbX/czTdNFwgW4J8/RLyH53utjAGQtCRr97EbBOsTSeOmyAxbw4mRt
-EvHjacKFcSZzJDlyxCia37791MulZ4lwOZZlke5NzoOqkBIAusQgg7fMWDvH27PD
-T+taIyBsYTVJWHf5kMklAlWYXZvNjZp/QGt13lDORg2aSc/P2pE4iLyhbZcpuW+W
-nHB7IY1wjDL55/ORCjz3VlNIAMXHP5YQxwIDAQABMA0GCSqGSIb3DQEBCwUAA4IB
-AQC3iiwQTgDP4ixulisYIGlJb8iuhxH9G41hm8dF/1qlIfXWxsbjb+g7M5U/3JCb
-fwCGoz7uBdj/CKkIb5wx83GVC1yVLbNSvCIS827qxic4GACEYGGAy4Ub5tUCQrLr
-JUQTP1WVJcgiKvk7OAcXdA+k/CcNXH153gUPDZz+/BedXe2VbM6LDsqPeSxXfbZN
-AWXARAuly7cQk/xkYkPldRRhx4htNCbnkG1qyEqNcYQN1SY9Qhbrm2HkAUntzQ7G
-umo4JdbIX6MJ5fYNs+yN/lJB7PiJP8Mz1AtOz4x9JxcLyuB6sapT8Tj53n9g/+m1
-Tqd8lHpWe6oM0sgdWfzdBNir
------END CERTIFICATE-----
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,9E0E6B9970E055F1
-
-oFvN3t50B2TSeNsRo1vwhVYlMmt0w3MD3Ar75fti4fRhBrWoH4rBPrSouWK4OMDK
-CakfVhzJIEvaMav843grS4V+ooAsfnAtiQiQj+5xjZ8PlCuWir5gyjgqeN4zN6ZT
-2s/oEy5Kx7Ru5AWMkv+NPW5l3iS3c+Hupfb/auITwECSCCsCBxgNtJ8z0iXjv9Dr
-hqvqcI+4F5DSiol3QhitbpQ/k2PKu92AZhPcr9e5HrqeUD7aqfX2q3i+tnJvxC93
-0mvy133bX2ZAGAKMheW/GuzcETfwU80wvmrwHXI9rnuAUaJhrDiIZQ79gubZ0Pcm
-w4Y6Z5xxeErb7zKBi+pHKst8MJ7rfSz/N878su6cpESRC/w1paVX7m8/q61kzBkj
-+h2qe9DupXBejQkriN+Z858nFtBKbWlFsmAg1FLZonworTUfV2c7S9yzMV/29VOE
-T0Bt8BU1Hp+bCjreF4JGbnUJnRQoASpisfUkrD6Ar4GI56Edkkx6hkF0cXdcvfCN
-qyhxzcvf/aV1M2kcpBRX9mIfjoFMFNz7uRIxyqPLaDkigwJemoaBo3n9/W5F7N7B
-AGNEZ3QhUlc8EyWpGRZRzMevu5wdz1b2+MqItOhPXUo2XcLEj2iFkVDdbj/d9jQH
-9ZIe4hQTSf784tAzt2Jp2RHmm22390GB1jdzG/CzbGlAKmaTTEe4FJcd/eLOEZuD
-4+iFsEb/bWcCyXkBKkdEoDDMJW8xi5d/1ezJM03nqhvkekDqyhJUJPCbmY1SCX1X
-4AO40jJmWQxwj26Pnnncacz4tuecZNqovz+POpKQSIctrQSV4wgf35137KBt7/O7
-EU0N7Qj4xTigyGkEHCZt7BgD8fFrxiP1OkUmFRHEE7Dxiagz6omJV8ien+p9wIgS
-QcqkJlgKMwVepjuCuEyvg5oIkAPvp24yhePSJkEvvoDLvM2Kub/CM+UkN8dSgsZk
-+ZBE9Oi62AWWow8/ib8Um5DNIEZsq+5CQLeBG7f5kTIBAoA9UceaEgbxzOVUCBcX
-L7QsJ3pZ/ei1qx/9tChO/OXa9tleXcjGg7/q/6i6pUyZuqZlt+hk+3HtFmTXIjsM
-chbUSMEJ2isv9MDamTtunt9N92A6OxUkAs68kCO/bzotldXMKZVjOohNnML5q/3U
-vpsuN8NNwaNHCAM7pjols4V7ebX1lDZFR1hbj+szKMhVKzFfig1lRHafgRrR6H6P
-mUK16lKzUbmvwv2IU/3wck+4UNeB/+lRmfAfBasQytnbt+5fwwNkVSrDY2Kxe0nz
-2k3eIYST+ygxGuNrW9rnFbBpTJb0OE5cpgun8xxDE91AmL550AcZff+9ulDBhZg1
-eMoKUALlEdDNPffVTH8Iupn0jMnJsjXynztcEVhx4h2aA5X6/2i035uEybCn33qP
-J7g30oe2C69BSC0YmkT3MjF6Wrhy+M8dU0dDggRhY6JSS8wESvwGenaPi7SZlbxb
-Elmc44bHros1YfGl/xDdhju134/aMBG1GlZlReI+Rwnp9DCp04xiiJb9YKyUNaGY
-7BTGWyie/WYYKbX1ZlxqWA9jxow8PM1XYHuanau1/aYT16L7E83HG3qkyuFIlLJh
------END RSA PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIDVDCCAjygAwIBAgIUX3cVQ47QyJp7SOy0RPzP743W9MwwDQYJKoZIhvcNAQEL
-BQAwOzELMAkGA1UEBhMCQVUxDDAKBgNVBAgMA05TVzEPMA0GA1UEBwwGU3lkbmV5
-MQ0wCwYDVQQKDARhc2lvMB4XDTIxMTExMTIxMTA1MloXDTI2MTExMDIxMTA1Mlow
-OzELMAkGA1UEBhMCQVUxDDAKBgNVBAgMA05TVzEPMA0GA1UEBwwGU3lkbmV5MQ0w
-CwYDVQQKDARhc2lvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyURD
-LjKxTCkapmWhY0bP1NaaOPzIJTTB0dzREOlmRmBmiHpW7DaRx7qBm6jYDKQ7OCbz
-30/j8K4TjHOLIwxzXhXMYTJOcN2giPHNUBvm9oEuDAhYgltArJQnBBEH+3C1hCIv
-1+uhTWo0HpGXTeJnvboTZ1YgmbOgr6lMhNiu9QmPX885DxWf6sDq8mRgCDX2x8sk
-Ls0HuLSo88Osjx532yEhnrZgexsByhoRD3yrKHV5mWpaunk5BMsP/XMuQHayFmbO
-siqnHJoL1znGVH003PcBGmEDmoIUqhLiBi2gWGu1pmckP9loqQUTEn0aLOVclHf4
-slWq344zh4tJCpQMfQIDAQABo1AwTjAdBgNVHQ4EFgQUfiX1CMQrGDi9mIBAg9cg
-m0RwLJUwHwYDVR0jBBgwFoAUfiX1CMQrGDi9mIBAg9cgm0RwLJUwDAYDVR0TBAUw
-AwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAnDnVNSb8z/pNFaZ6YAZ+ukfNT3jjbGm1
-10BOLqJj8s5A8/JkwjaWhky/DuGXDywgEvzXC18aNAxASeqO8h9pAZtszu6NWB4s
-h3r+dEQakMacxrZ+jBL/cYLrUv9r3KMPKxaDnplkamqFA/9eNmoV7vDyGtGPZuD6
-oTROtQqqDSrxthCkqnibAfusi7RmlCdvJa0kVK7krKJZAhi8W9f32+lBPv9oq3Ns
-dAxnOj/D3UnhNoIt0EdjqUdLo2U39dt5s5Syj2rFUAgfbc02Rwx65kq8AjTRlW/M
-KDpGsifwIB8b7wActMUO8c3GptptNVWmFm5+Mmk54P//P3tIAx9KXw==
------END CERTIFICATE-----
------BEGIN ENCRYPTED PRIVATE KEY-----
-MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIPcVUeQ7ZElgCAggA
-MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECGKlFVN6/gIlBIIEyJPeknsA5dvV
-WK27AZzs4wM6WrsD6ba+kPJyZTpon5pn4eoTiw4UCvo7C+21G9jCqbIbDrgTWHwH
-zu6YrBFTZgRUpdLkLsyUsp4UJrZ8xJ7N/jWlG763CyluFE5oBFLz2Vt/DSDSaWdA
-sKdxua/1kvw+KYoDqlObMFIspM5TrndcMnWkOgyvQAvnH0NZXFFBa4QGFrwWDrCo
-m12CzMLwaPMrNFBffCTqZnL1AajT+EYqPTi+cQ5mkRpZ2cuzhdug2eki1KkD12ZN
-3d8Ehl8bfbLEqRE/HnggleRRt7ia1xkzruqQp14JA2UsrioGMF5nvWgWrbyHfpui
-KrCsDwDelrArW/GCki53QBQMuH8Q1YmoNrRZwlG257eA1LiJvmxRyIjKYu0RP+Q8
-EOldycy51VsPVPApUbv9r4IJldrIJiwlmRxxM36uKtFhfojnsWzJORDYI8C37uKi
-UEPiD4GSEH6C0lGO94IoZPjl9z/rZ0qZx1VRHl3nxZc0AQvvj9bWMbyRwsgb6wod
-P8JSy6uEib9UxuenNHzTd48GcNhJbhOqd4IV0XKhi8W1Kil3mMdc3QAwKaLTx12/
-1GrbMui061uyeM6Rf6Xao0PApDnUNmxcFSTsoarG0yH7Q0WZMgKTDCCGhhtZKlE6
-x7pRsnxiFaIpoh32EVIRI+ZXh2rXBcwa2ew0aEccRXtPFvcmdjevkrHuCggc+M+Y
-seFqTHVGWf8eS6o08w095DboD0vFpZXZMRfycTbA7BiE4NYE/uc7v5cH3Ax9l2ef
-zG7o9idDt+/RX7OcetxDFw4eQbq7PfjvrfXS1DcRUEyJ04emh7oxlkAUUNsFtabN
-T0ggvHxcQWkYRE5oPlkbgpwKpK4LDcApXKFwCDKPur2W5Q7KHRfDLtSvZvYarJum
-8j2pGpEis/bdTih29ofNsX6a0Yo5Tlj+9+1c/6/Xi7XvRk/Vbgkoa3iVQ3ckdCuZ
-vO7cRYZBBs6W/Ti3hWFzPEX9FfcnSUp9bEnH4ASnmUcp8PDBJYeaI6HqpO3XbkbF
-l70eDNakd2cDNjQzkFpBT7HO+HtqU3xNt9K0z2gMB7iTDVFyIzh26joCR2O8tiqS
-wUJFkoLPb74GSB7WzE+gb4jXX6n9609PUoR3f896mM34uX3CsY8lA+/0ZGpHnFDA
-ToKdmz6WKIAw0E20nyzLuLwPZgj7HLcR7zza4raipe9QxIdyJr5O+jzGt+OjSM9b
-K1agibRE5DChqQ+P+ikOc6nG7UNyn+lKSjGEbwuzi8F0iugMgcTc/vYO8OWDNGpd
-D1euA5OuVPdfatFa16Fyr4MJJIfE83C4/kSj05fdoyb6pJkOjHhUppVMe+ES5kwl
-YI8RES2XVJzUSxnWsIM613YlMgIZ9xgcuIADnO7gaKJ4RQG+9wJ853Uo4+n89K7F
-Y6KzihuYAUkbAw1pPo1TODom7A/gB9stqRUSQlZWmIgtnJ8wPjt/we0gzPM8LQzb
-ye4KOLjH5iquFc4MU4TtN3gvp9P5R9UFrGeMImS5eMUmBQHckDNdIAtMj7M1wUpR
-JVrzDXWDjC21sLn95NtNMPb+FRlt/biTV3IE3ZmX0kbuCRoH7b7hhR41Zpoajwl0
-FqYigB5gnVodGUWuBgDUqA==
------END ENCRYPTED PRIVATE KEY-----
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/.gitignore
deleted file mode 100644
index dda7f39..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/async_tcp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/async_tcp_client.cpp
deleted file mode 100644
index b8f2cbe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/async_tcp_client.cpp
+++ /dev/null
@@ -1,311 +0,0 @@
-//
-// async_tcp_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/read_until.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/write.hpp"
-#include <functional>
-#include <iostream>
-#include <string>
-
-using asio::steady_timer;
-using asio::ip::tcp;
-using std::placeholders::_1;
-using std::placeholders::_2;
-
-//
-// This class manages socket timeouts by applying the concept of a deadline.
-// Some asynchronous operations are given deadlines by which they must complete.
-// Deadlines are enforced by an "actor" that persists for the lifetime of the
-// client object:
-//
-//  +----------------+
-//  |                |
-//  | check_deadline |<---+
-//  |                |    |
-//  +----------------+    | async_wait()
-//              |         |
-//              +---------+
-//
-// If the deadline actor determines that the deadline has expired, the socket
-// is closed and any outstanding operations are consequently cancelled.
-//
-// Connection establishment involves trying each endpoint in turn until a
-// connection is successful, or the available endpoints are exhausted. If the
-// deadline actor closes the socket, the connect actor is woken up and moves to
-// the next endpoint.
-//
-//  +---------------+
-//  |               |
-//  | start_connect |<---+
-//  |               |    |
-//  +---------------+    |
-//           |           |
-//  async_-  |    +----------------+
-// connect() |    |                |
-//           +--->| handle_connect |
-//                |                |
-//                +----------------+
-//                          :
-// Once a connection is     :
-// made, the connect        :
-// actor forks in two -     :
-//                          :
-// an actor for reading     :       and an actor for
-// inbound messages:        :       sending heartbeats:
-//                          :
-//  +------------+          :          +-------------+
-//  |            |<- - - - -+- - - - ->|             |
-//  | start_read |                     | start_write |<---+
-//  |            |<---+                |             |    |
-//  +------------+    |                +-------------+    | async_wait()
-//          |         |                        |          |
-//  async_- |    +-------------+       async_- |    +--------------+
-//   read_- |    |             |       write() |    |              |
-//  until() +--->| handle_read |               +--->| handle_write |
-//               |             |                    |              |
-//               +-------------+                    +--------------+
-//
-// The input actor reads messages from the socket, where messages are delimited
-// by the newline character. The deadline for a complete message is 30 seconds.
-//
-// The heartbeat actor sends a heartbeat (a message that consists of a single
-// newline character) every 10 seconds. In this example, no deadline is applied
-// to message sending.
-//
-class client
-{
-public:
-  client(asio::io_context& io_context)
-    : socket_(io_context),
-      deadline_(io_context),
-      heartbeat_timer_(io_context)
-  {
-  }
-
-  // Called by the user of the client class to initiate the connection process.
-  // The endpoints will have been obtained using a tcp::resolver.
-  void start(tcp::resolver::results_type endpoints)
-  {
-    // Start the connect actor.
-    endpoints_ = endpoints;
-    start_connect(endpoints_.begin());
-
-    // Start the deadline actor. You will note that we're not setting any
-    // particular deadline here. Instead, the connect and input actors will
-    // update the deadline prior to each asynchronous operation.
-    deadline_.async_wait(std::bind(&client::check_deadline, this));
-  }
-
-  // This function terminates all the actors to shut down the connection. It
-  // may be called by the user of the client class, or by the class itself in
-  // response to graceful termination or an unrecoverable error.
-  void stop()
-  {
-    stopped_ = true;
-    std::error_code ignored_error;
-    socket_.close(ignored_error);
-    deadline_.cancel();
-    heartbeat_timer_.cancel();
-  }
-
-private:
-  void start_connect(tcp::resolver::results_type::iterator endpoint_iter)
-  {
-    if (endpoint_iter != endpoints_.end())
-    {
-      std::cout << "Trying " << endpoint_iter->endpoint() << "...\n";
-
-      // Set a deadline for the connect operation.
-      deadline_.expires_after(std::chrono::seconds(60));
-
-      // Start the asynchronous connect operation.
-      socket_.async_connect(endpoint_iter->endpoint(),
-          std::bind(&client::handle_connect,
-            this, _1, endpoint_iter));
-    }
-    else
-    {
-      // There are no more endpoints to try. Shut down the client.
-      stop();
-    }
-  }
-
-  void handle_connect(const std::error_code& error,
-      tcp::resolver::results_type::iterator endpoint_iter)
-  {
-    if (stopped_)
-      return;
-
-    // The async_connect() function automatically opens the socket at the start
-    // of the asynchronous operation. If the socket is closed at this time then
-    // the timeout handler must have run first.
-    if (!socket_.is_open())
-    {
-      std::cout << "Connect timed out\n";
-
-      // Try the next available endpoint.
-      start_connect(++endpoint_iter);
-    }
-
-    // Check if the connect operation failed before the deadline expired.
-    else if (error)
-    {
-      std::cout << "Connect error: " << error.message() << "\n";
-
-      // We need to close the socket used in the previous connection attempt
-      // before starting a new one.
-      socket_.close();
-
-      // Try the next available endpoint.
-      start_connect(++endpoint_iter);
-    }
-
-    // Otherwise we have successfully established a connection.
-    else
-    {
-      std::cout << "Connected to " << endpoint_iter->endpoint() << "\n";
-
-      // Start the input actor.
-      start_read();
-
-      // Start the heartbeat actor.
-      start_write();
-    }
-  }
-
-  void start_read()
-  {
-    // Set a deadline for the read operation.
-    deadline_.expires_after(std::chrono::seconds(30));
-
-    // Start an asynchronous operation to read a newline-delimited message.
-    asio::async_read_until(socket_,
-        asio::dynamic_buffer(input_buffer_), '\n',
-        std::bind(&client::handle_read, this, _1, _2));
-  }
-
-  void handle_read(const std::error_code& error, std::size_t n)
-  {
-    if (stopped_)
-      return;
-
-    if (!error)
-    {
-      // Extract the newline-delimited message from the buffer.
-      std::string line(input_buffer_.substr(0, n - 1));
-      input_buffer_.erase(0, n);
-
-      // Empty messages are heartbeats and so ignored.
-      if (!line.empty())
-      {
-        std::cout << "Received: " << line << "\n";
-      }
-
-      start_read();
-    }
-    else
-    {
-      std::cout << "Error on receive: " << error.message() << "\n";
-
-      stop();
-    }
-  }
-
-  void start_write()
-  {
-    if (stopped_)
-      return;
-
-    // Start an asynchronous operation to send a heartbeat message.
-    asio::async_write(socket_, asio::buffer("\n", 1),
-        std::bind(&client::handle_write, this, _1));
-  }
-
-  void handle_write(const std::error_code& error)
-  {
-    if (stopped_)
-      return;
-
-    if (!error)
-    {
-      // Wait 10 seconds before sending the next heartbeat.
-      heartbeat_timer_.expires_after(std::chrono::seconds(10));
-      heartbeat_timer_.async_wait(std::bind(&client::start_write, this));
-    }
-    else
-    {
-      std::cout << "Error on heartbeat: " << error.message() << "\n";
-
-      stop();
-    }
-  }
-
-  void check_deadline()
-  {
-    if (stopped_)
-      return;
-
-    // Check whether the deadline has passed. We compare the deadline against
-    // the current time since a new asynchronous operation may have moved the
-    // deadline before this actor had a chance to run.
-    if (deadline_.expiry() <= steady_timer::clock_type::now())
-    {
-      // The deadline has passed. The socket is closed so that any outstanding
-      // asynchronous operations are cancelled.
-      socket_.close();
-
-      // There is no longer an active deadline. The expiry is set to the
-      // maximum time point so that the actor takes no action until a new
-      // deadline is set.
-      deadline_.expires_at(steady_timer::time_point::max());
-    }
-
-    // Put the actor back to sleep.
-    deadline_.async_wait(std::bind(&client::check_deadline, this));
-  }
-
-private:
-  bool stopped_ = false;
-  tcp::resolver::results_type endpoints_;
-  tcp::socket socket_;
-  std::string input_buffer_;
-  steady_timer deadline_;
-  steady_timer heartbeat_timer_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    tcp::resolver r(io_context);
-    client c(io_context);
-
-    c.start(r.resolve(argv[1], argv[2]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_tcp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_tcp_client.cpp
deleted file mode 100644
index e29edc2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_tcp_client.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-//
-// blocking_tcp_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/buffer.hpp"
-#include "asio/connect.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/read_until.hpp"
-#include "asio/system_error.hpp"
-#include "asio/write.hpp"
-#include <cstdlib>
-#include <iostream>
-#include <string>
-
-using asio::ip::tcp;
-
-//----------------------------------------------------------------------
-
-//
-// This class manages socket timeouts by running the io_context using the timed
-// io_context::run_for() member function. Each asynchronous operation is given
-// a timeout within which it must complete. The socket operations themselves
-// use lambdas as completion handlers. For a given socket operation, the client
-// object runs the io_context to block thread execution until the operation
-// completes or the timeout is reached. If the io_context::run_for() function
-// times out, the socket is closed and the outstanding asynchronous operation
-// is cancelled.
-//
-class client
-{
-public:
-  void connect(const std::string& host, const std::string& service,
-      std::chrono::steady_clock::duration timeout)
-  {
-    // Resolve the host name and service to a list of endpoints.
-    auto endpoints = tcp::resolver(io_context_).resolve(host, service);
-
-    // Start the asynchronous operation itself. The lambda that is used as a
-    // callback will update the error variable when the operation completes.
-    // The blocking_udp_client.cpp example shows how you can use std::bind
-    // rather than a lambda.
-    std::error_code error;
-    asio::async_connect(socket_, endpoints,
-        [&](const std::error_code& result_error,
-            const tcp::endpoint& /*result_endpoint*/)
-        {
-          error = result_error;
-        });
-
-    // Run the operation until it completes, or until the timeout.
-    run(timeout);
-
-    // Determine whether a connection was successfully established.
-    if (error)
-      throw std::system_error(error);
-  }
-
-  std::string read_line(std::chrono::steady_clock::duration timeout)
-  {
-    // Start the asynchronous operation. The lambda that is used as a callback
-    // will update the error and n variables when the operation completes. The
-    // blocking_udp_client.cpp example shows how you can use std::bind rather
-    // than a lambda.
-    std::error_code error;
-    std::size_t n = 0;
-    asio::async_read_until(socket_,
-        asio::dynamic_buffer(input_buffer_), '\n',
-        [&](const std::error_code& result_error,
-            std::size_t result_n)
-        {
-          error = result_error;
-          n = result_n;
-        });
-
-    // Run the operation until it completes, or until the timeout.
-    run(timeout);
-
-    // Determine whether the read completed successfully.
-    if (error)
-      throw std::system_error(error);
-
-    std::string line(input_buffer_.substr(0, n - 1));
-    input_buffer_.erase(0, n);
-    return line;
-  }
-
-  void write_line(const std::string& line,
-      std::chrono::steady_clock::duration timeout)
-  {
-    std::string data = line + "\n";
-
-    // Start the asynchronous operation itself. The lambda that is used as a
-    // callback will update the error variable when the operation completes.
-    // The blocking_udp_client.cpp example shows how you can use std::bind
-    // rather than a lambda.
-    std::error_code error;
-    asio::async_write(socket_, asio::buffer(data),
-        [&](const std::error_code& result_error,
-            std::size_t /*result_n*/)
-        {
-          error = result_error;
-        });
-
-    // Run the operation until it completes, or until the timeout.
-    run(timeout);
-
-    // Determine whether the read completed successfully.
-    if (error)
-      throw std::system_error(error);
-  }
-
-private:
-  void run(std::chrono::steady_clock::duration timeout)
-  {
-    // Restart the io_context, as it may have been left in the "stopped" state
-    // by a previous operation.
-    io_context_.restart();
-
-    // Block until the asynchronous operation has completed, or timed out. If
-    // the pending asynchronous operation is a composed operation, the deadline
-    // applies to the entire operation, rather than individual operations on
-    // the socket.
-    io_context_.run_for(timeout);
-
-    // If the asynchronous operation completed successfully then the io_context
-    // would have been stopped due to running out of work. If it was not
-    // stopped, then the io_context::run_for call must have timed out.
-    if (!io_context_.stopped())
-    {
-      // Close the socket to cancel the outstanding asynchronous operation.
-      socket_.close();
-
-      // Run the io_context again until the operation completes.
-      io_context_.run();
-    }
-  }
-
-  asio::io_context io_context_;
-  tcp::socket socket_{io_context_};
-  std::string input_buffer_;
-};
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 4)
-    {
-      std::cerr << "Usage: blocking_tcp_client <host> <port> <message>\n";
-      return 1;
-    }
-
-    client c;
-    c.connect(argv[1], argv[2], std::chrono::seconds(10));
-
-    auto time_sent = std::chrono::steady_clock::now();
-
-    c.write_line(argv[3], std::chrono::seconds(10));
-
-    for (;;)
-    {
-      std::string line = c.read_line(std::chrono::seconds(10));
-
-      // Keep going until we get back the line that was sent.
-      if (line == argv[3])
-        break;
-    }
-
-    auto time_received = std::chrono::steady_clock::now();
-
-    std::cout << "Round trip time: ";
-    std::cout << std::chrono::duration_cast<
-      std::chrono::microseconds>(
-        time_received - time_sent).count();
-    std::cout << " microseconds\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_token_tcp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_token_tcp_client.cpp
deleted file mode 100644
index 085570d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_token_tcp_client.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// blocking_token_tcp_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/connect.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/read_until.hpp"
-#include "asio/streambuf.hpp"
-#include "asio/system_error.hpp"
-#include "asio/write.hpp"
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <string>
-
-using asio::ip::tcp;
-
-// NOTE: This example uses the new form of the asio::async_result trait.
-// For an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-// We will use our sockets only with an io_context.
-using tcp_socket = asio::basic_stream_socket<
-    tcp, asio::io_context::executor_type>;
-
-//----------------------------------------------------------------------
-
-// A custom completion token that makes asynchronous operations behave as
-// though they are blocking calls with a timeout.
-struct close_after
-{
-  close_after(std::chrono::steady_clock::duration t, tcp_socket& s)
-    : timeout_(t), socket_(s)
-  {
-  }
-
-  // The maximum time to wait for an asynchronous operation to complete.
-  std::chrono::steady_clock::duration timeout_;
-
-  // The socket to be closed if the operation does not complete in time.
-  tcp_socket& socket_;
-};
-
-namespace asio {
-
-// The async_result template is specialised to allow the close_after token to
-// be used with asynchronous operations that have a completion signature of
-// void(error_code, T). Generalising this for all completion signature forms is
-// left as an exercise for the reader.
-template <typename T>
-class async_result<close_after, void(std::error_code, T)>
-{
-public:
-  // The initiate() function is used to launch the asynchronous operation by
-  // calling the operation's initiation function object. For the close_after
-  // completion token, we use this function to run the io_context until the
-  // operation is complete.
-  template <typename Init, typename... Args>
-  static T initiate(Init init, close_after token, Args&&... args)
-  {
-    asio::io_context& io_context = asio::query(
-        token.socket_.get_executor(), asio::execution::context);
-
-    // Call the operation's initiation function object to start the operation.
-    // A lambda is supplied as the completion handler, to be called when the
-    // operation completes.
-    std::error_code error;
-    T result;
-    init([&](std::error_code e, T t)
-        {
-          error = e;
-          result = t;
-        }, std::forward<Args>(args)...);
-
-    // Restart the io_context, as it may have been left in the "stopped" state
-    // by a previous operation.
-    io_context.restart();
-
-    // Block until the asynchronous operation has completed, or timed out. If
-    // the pending asynchronous operation is a composed operation, the deadline
-    // applies to the entire operation, rather than individual operations on
-    // the socket.
-    io_context.run_for(token.timeout_);
-
-    // If the asynchronous operation completed successfully then the io_context
-    // would have been stopped due to running out of work. If it was not
-    // stopped, then the io_context::run_for call must have timed out and the
-    // operation is still incomplete.
-    if (!io_context.stopped())
-    {
-      // Close the socket to cancel the outstanding asynchronous operation.
-      token.socket_.close();
-
-      // Run the io_context again until the operation completes.
-      io_context.run();
-    }
-
-    // If the operation failed, throw an exception. Otherwise return the result.
-    return error ? throw std::system_error(error) : result;
-  }
-};
-
-} // namespace asio
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 4)
-    {
-      std::cerr << "Usage: blocking_tcp_client <host> <port> <message>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    // Resolve the host name and service to a list of endpoints.
-    auto endpoints = tcp::resolver(io_context).resolve(argv[1], argv[2]);
-
-    tcp_socket socket(io_context);
-
-    // Run an asynchronous connect operation with a timeout.
-    asio::async_connect(socket, endpoints,
-        close_after(std::chrono::seconds(10), socket));
-
-    auto time_sent = std::chrono::steady_clock::now();
-
-    // Run an asynchronous write operation with a timeout.
-    std::string msg = argv[3] + std::string("\n");
-    asio::async_write(socket, asio::buffer(msg),
-        close_after(std::chrono::seconds(10), socket));
-
-    for (std::string input_buffer;;)
-    {
-      // Run an asynchronous read operation with a timeout.
-      std::size_t n = asio::async_read_until(socket,
-          asio::dynamic_buffer(input_buffer), '\n',
-          close_after(std::chrono::seconds(10), socket));
-
-      std::string line(input_buffer.substr(0, n - 1));
-      input_buffer.erase(0, n);
-
-      // Keep going until we get back the line that was sent.
-      if (line == argv[3])
-        break;
-    }
-
-    auto time_received = std::chrono::steady_clock::now();
-
-    std::cout << "Round trip time: ";
-    std::cout << std::chrono::duration_cast<
-      std::chrono::microseconds>(
-        time_received - time_sent).count();
-    std::cout << " microseconds\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_udp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_udp_client.cpp
deleted file mode 100644
index 4226b42..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/blocking_udp_client.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// blocking_udp_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/udp.hpp"
-#include <cstdlib>
-#include <functional>
-#include <iostream>
-
-using asio::ip::udp;
-using std::placeholders::_1;
-using std::placeholders::_2;
-
-//----------------------------------------------------------------------
-
-//
-// This class manages socket timeouts by running the io_context using the timed
-// io_context::run_for() member function. Each asynchronous operation is given
-// a timeout within which it must complete. The socket operations themselves
-// use std::bind to specify the completion handler:
-//
-//   +---------------+
-//   |               |
-//   |    receive    |
-//   |               |
-//   +---------------+
-//           |
-//  async_-  |    +----------------+
-// receive() |    |                |
-//           +--->| handle_receive |
-//                |                |
-//                +----------------+
-//
-// For a given socket operation, the client object runs the io_context to block
-// thread execution until the operation completes or the timeout is reached. If
-// the io_context::run_for() function times out, the socket is closed and the
-// outstanding asynchronous operation is cancelled.
-//
-class client
-{
-public:
-  client(const udp::endpoint& listen_endpoint)
-    : socket_(io_context_, listen_endpoint)
-  {
-  }
-
-  std::size_t receive(const asio::mutable_buffer& buffer,
-      std::chrono::steady_clock::duration timeout,
-      std::error_code& error)
-  {
-    // Start the asynchronous operation. The handle_receive function used as a
-    // callback will update the error and length variables.
-    std::size_t length = 0;
-    socket_.async_receive(asio::buffer(buffer),
-        std::bind(&client::handle_receive, _1, _2, &error, &length));
-
-    // Run the operation until it completes, or until the timeout.
-    run(timeout);
-
-    return length;
-  }
-
-private:
-  void run(std::chrono::steady_clock::duration timeout)
-  {
-    // Restart the io_context, as it may have been left in the "stopped" state
-    // by a previous operation.
-    io_context_.restart();
-
-    // Block until the asynchronous operation has completed, or timed out. If
-    // the pending asynchronous operation is a composed operation, the deadline
-    // applies to the entire operation, rather than individual operations on
-    // the socket.
-    io_context_.run_for(timeout);
-
-    // If the asynchronous operation completed successfully then the io_context
-    // would have been stopped due to running out of work. If it was not
-    // stopped, then the io_context::run_for call must have timed out.
-    if (!io_context_.stopped())
-    {
-      // Cancel the outstanding asynchronous operation.
-      socket_.cancel();
-
-      // Run the io_context again until the operation completes.
-      io_context_.run();
-    }
-  }
-
-  static void handle_receive(
-      const std::error_code& error, std::size_t length,
-      std::error_code* out_error, std::size_t* out_length)
-  {
-    *out_error = error;
-    *out_length = length;
-  }
-
-private:
-  asio::io_context io_context_;
-  udp::socket socket_;
-};
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    using namespace std; // For atoi.
-
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_udp_client <listen_addr> <listen_port>\n";
-      return 1;
-    }
-
-    udp::endpoint listen_endpoint(
-        asio::ip::make_address(argv[1]),
-        std::atoi(argv[2]));
-
-    client c(listen_endpoint);
-
-    for (;;)
-    {
-      char data[1024];
-      std::error_code error;
-      std::size_t n = c.receive(asio::buffer(data),
-          std::chrono::seconds(10), error);
-
-      if (error)
-      {
-        std::cout << "Receive error: " << error.message() << "\n";
-      }
-      else
-      {
-        std::cout << "Received: ";
-        std::cout.write(data, n);
-        std::cout << "\n";
-      }
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/server.cpp
deleted file mode 100644
index 6e18fc6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timeouts/server.cpp
+++ /dev/null
@@ -1,433 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <algorithm>
-#include <cstdlib>
-#include <deque>
-#include <iostream>
-#include <memory>
-#include <set>
-#include <string>
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "asio/read_until.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/write.hpp"
-
-using asio::steady_timer;
-using asio::ip::tcp;
-using asio::ip::udp;
-
-//----------------------------------------------------------------------
-
-class subscriber
-{
-public:
-  virtual ~subscriber() = default;
-  virtual void deliver(const std::string& msg) = 0;
-};
-
-typedef std::shared_ptr<subscriber> subscriber_ptr;
-
-//----------------------------------------------------------------------
-
-class channel
-{
-public:
-  void join(subscriber_ptr subscriber)
-  {
-    subscribers_.insert(subscriber);
-  }
-
-  void leave(subscriber_ptr subscriber)
-  {
-    subscribers_.erase(subscriber);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    for (const auto& s : subscribers_)
-    {
-      s->deliver(msg);
-    }
-  }
-
-private:
-  std::set<subscriber_ptr> subscribers_;
-};
-
-//----------------------------------------------------------------------
-
-//
-// This class manages socket timeouts by applying the concept of a deadline.
-// Some asynchronous operations are given deadlines by which they must complete.
-// Deadlines are enforced by two "actors" that persist for the lifetime of the
-// session object, one for input and one for output:
-//
-//  +----------------+                      +----------------+
-//  |                |                      |                |
-//  | check_deadline |<-------+             | check_deadline |<-------+
-//  |                |        |             |                |        |
-//  +----------------+        |             +----------------+        |
-//               |            |                          |            |
-//  async_wait() |    +----------------+    async_wait() |    +----------------+
-//   on input    |    |     lambda     |     on output   |    |     lambda     |
-//   deadline    +--->|       in       |     deadline    +--->|       in       |
-//                    | check_deadline |                      | check_deadline |
-//                    +----------------+                      +----------------+
-//
-// If either deadline actor determines that the corresponding deadline has
-// expired, the socket is closed and any outstanding operations are cancelled.
-//
-// The input actor reads messages from the socket, where messages are delimited
-// by the newline character:
-//
-//  +-------------+
-//  |             |
-//  |  read_line  |<----+
-//  |             |     |
-//  +-------------+     |
-//          |           |
-//  async_- |    +-------------+
-//   read_- |    |   lambda    |
-//  until() +--->|     in      |
-//               |  read_line  |
-//               +-------------+
-//
-// The deadline for receiving a complete message is 30 seconds. If a non-empty
-// message is received, it is delivered to all subscribers. If a heartbeat (a
-// message that consists of a single newline character) is received, a heartbeat
-// is enqueued for the client, provided there are no other messages waiting to
-// be sent.
-//
-// The output actor is responsible for sending messages to the client:
-//
-//  +----------------+
-//  |                |<---------------------+
-//  |  await_output  |                      |
-//  |                |<-------+             |
-//  +----------------+        |             |
-//    |            |          |             |
-//    |    async_- |  +----------------+    |
-//    |     wait() |  |     lambda     |    |
-//    |            +->|       in       |    |
-//    |               |  await_output  |    |
-//    |               +----------------+    |
-//    V                                     |
-//  +--------------+               +--------------+
-//  |              | async_write() |    lambda    |
-//  |  write_line  |-------------->|      in      |
-//  |              |               |  write_line  |
-//  +--------------+               +--------------+
-//
-// The output actor first waits for an output message to be enqueued. It does
-// this by using a steady_timer as an asynchronous condition variable. The
-// steady_timer will be signalled whenever the output queue is non-empty.
-//
-// Once a message is available, it is sent to the client. The deadline for
-// sending a complete message is 30 seconds. After the message is successfully
-// sent, the output actor again waits for the output queue to become non-empty.
-//
-class tcp_session
-  : public subscriber,
-    public std::enable_shared_from_this<tcp_session>
-{
-public:
-  tcp_session(tcp::socket socket, channel& ch)
-    : channel_(ch),
-      socket_(std::move(socket))
-  {
-    input_deadline_.expires_at(steady_timer::time_point::max());
-    output_deadline_.expires_at(steady_timer::time_point::max());
-
-    // The non_empty_output_queue_ steady_timer is set to the maximum time
-    // point whenever the output queue is empty. This ensures that the output
-    // actor stays asleep until a message is put into the queue.
-    non_empty_output_queue_.expires_at(steady_timer::time_point::max());
-  }
-
-  // Called by the server object to initiate the four actors.
-  void start()
-  {
-    channel_.join(shared_from_this());
-
-    read_line();
-    check_deadline(input_deadline_);
-
-    await_output();
-    check_deadline(output_deadline_);
-  }
-
-private:
-  void stop()
-  {
-    channel_.leave(shared_from_this());
-
-    std::error_code ignored_error;
-    socket_.close(ignored_error);
-    input_deadline_.cancel();
-    non_empty_output_queue_.cancel();
-    output_deadline_.cancel();
-  }
-
-  bool stopped() const
-  {
-    return !socket_.is_open();
-  }
-
-  void deliver(const std::string& msg) override
-  {
-    output_queue_.push_back(msg + "\n");
-
-    // Signal that the output queue contains messages. Modifying the expiry
-    // will wake the output actor, if it is waiting on the timer.
-    non_empty_output_queue_.expires_at(steady_timer::time_point::min());
-  }
-
-  void read_line()
-  {
-    // Set a deadline for the read operation.
-    input_deadline_.expires_after(std::chrono::seconds(30));
-
-    // Start an asynchronous operation to read a newline-delimited message.
-    auto self(shared_from_this());
-    asio::async_read_until(socket_,
-        asio::dynamic_buffer(input_buffer_), '\n',
-        [this, self](const std::error_code& error, std::size_t n)
-        {
-          // Check if the session was stopped while the operation was pending.
-          if (stopped())
-            return;
-
-          if (!error)
-          {
-            // Extract the newline-delimited message from the buffer.
-            std::string msg(input_buffer_.substr(0, n - 1));
-            input_buffer_.erase(0, n);
-
-            if (!msg.empty())
-            {
-              channel_.deliver(msg);
-            }
-            else
-            {
-
-              // We received a heartbeat message from the client. If there's
-              // nothing else being sent or ready to be sent, send a heartbeat
-              // right back.
-              if (output_queue_.empty())
-              {
-                output_queue_.push_back("\n");
-
-                // Signal that the output queue contains messages. Modifying
-                // the expiry will wake the output actor, if it is waiting on
-                // the timer.
-                non_empty_output_queue_.expires_at(
-                    steady_timer::time_point::min());
-              }
-            }
-
-            read_line();
-          }
-          else
-          {
-            stop();
-          }
-        });
-  }
-
-  void await_output()
-  {
-    auto self(shared_from_this());
-    non_empty_output_queue_.async_wait(
-        [this, self](const std::error_code& /*error*/)
-        {
-          // Check if the session was stopped while the operation was pending.
-          if (stopped())
-            return;
-
-          if (output_queue_.empty())
-          {
-            // There are no messages that are ready to be sent. The actor goes
-            // to sleep by waiting on the non_empty_output_queue_ timer. When a
-            // new message is added, the timer will be modified and the actor
-            // will wake.
-            non_empty_output_queue_.expires_at(steady_timer::time_point::max());
-            await_output();
-          }
-          else
-          {
-            write_line();
-          }
-        });
-  }
-
-  void write_line()
-  {
-    // Set a deadline for the write operation.
-    output_deadline_.expires_after(std::chrono::seconds(30));
-
-    // Start an asynchronous operation to send a message.
-    auto self(shared_from_this());
-    asio::async_write(socket_,
-        asio::buffer(output_queue_.front()),
-        [this, self](const std::error_code& error, std::size_t /*n*/)
-        {
-          // Check if the session was stopped while the operation was pending.
-          if (stopped())
-            return;
-
-          if (!error)
-          {
-            output_queue_.pop_front();
-
-            await_output();
-          }
-          else
-          {
-            stop();
-          }
-        });
-  }
-
-  void check_deadline(steady_timer& deadline)
-  {
-    auto self(shared_from_this());
-    deadline.async_wait(
-        [this, self, &deadline](const std::error_code& /*error*/)
-        {
-          // Check if the session was stopped while the operation was pending.
-          if (stopped())
-            return;
-
-          // Check whether the deadline has passed. We compare the deadline
-          // against the current time since a new asynchronous operation may
-          // have moved the deadline before this actor had a chance to run.
-          if (deadline.expiry() <= steady_timer::clock_type::now())
-          {
-            // The deadline has passed. Stop the session. The other actors will
-            // terminate as soon as possible.
-            stop();
-          }
-          else
-          {
-            // Put the actor back to sleep.
-            check_deadline(deadline);
-          }
-        });
-  }
-
-  channel& channel_;
-  tcp::socket socket_;
-  std::string input_buffer_;
-  steady_timer input_deadline_{socket_.get_executor()};
-  std::deque<std::string> output_queue_;
-  steady_timer non_empty_output_queue_{socket_.get_executor()};
-  steady_timer output_deadline_{socket_.get_executor()};
-};
-
-typedef std::shared_ptr<tcp_session> tcp_session_ptr;
-
-//----------------------------------------------------------------------
-
-class udp_broadcaster
-  : public subscriber
-{
-public:
-  udp_broadcaster(asio::io_context& io_context,
-      const udp::endpoint& broadcast_endpoint)
-    : socket_(io_context)
-  {
-    socket_.connect(broadcast_endpoint);
-    socket_.set_option(udp::socket::broadcast(true));
-  }
-
-private:
-  void deliver(const std::string& msg)
-  {
-    std::error_code ignored_error;
-    socket_.send(asio::buffer(msg), 0, ignored_error);
-  }
-
-  udp::socket socket_;
-};
-
-//----------------------------------------------------------------------
-
-class server
-{
-public:
-  server(asio::io_context& io_context,
-      const tcp::endpoint& listen_endpoint,
-      const udp::endpoint& broadcast_endpoint)
-    : io_context_(io_context),
-      acceptor_(io_context, listen_endpoint)
-  {
-    channel_.join(
-        std::make_shared<udp_broadcaster>(
-          io_context_, broadcast_endpoint));
-
-    accept();
-  }
-
-private:
-  void accept()
-  {
-    acceptor_.async_accept(
-        [this](const std::error_code& error, tcp::socket socket)
-        {
-          if (!error)
-          {
-            std::make_shared<tcp_session>(std::move(socket), channel_)->start();
-          }
-
-          accept();
-        });
-  }
-
-  asio::io_context& io_context_;
-  tcp::acceptor acceptor_;
-  channel channel_;
-};
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    using namespace std; // For atoi.
-
-    if (argc != 4)
-    {
-      std::cerr << "Usage: server <listen_port> <bcast_address> <bcast_port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::endpoint listen_endpoint(tcp::v4(), atoi(argv[1]));
-
-    udp::endpoint broadcast_endpoint(
-        asio::ip::make_address(argv[2]), atoi(argv[3]));
-
-    server s(io_context, listen_endpoint, broadcast_endpoint);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/.gitignore
deleted file mode 100644
index a3fe695..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*timer
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/time_t_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/time_t_timer.cpp
deleted file mode 100644
index bca436d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/timers/time_t_timer.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-// time_t_timer.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <ctime>
-#include <chrono>
-#include <iostream>
-
-// A custom implementation of the Clock concept from the standard C++ library.
-struct time_t_clock
-{
-  // The duration type.
-  typedef std::chrono::steady_clock::duration duration;
-
-  // The duration's underlying arithmetic representation.
-  typedef duration::rep rep;
-
-  // The ratio representing the duration's tick period.
-  typedef duration::period period;
-
-  // An absolute time point represented using the clock.
-  typedef std::chrono::time_point<time_t_clock> time_point;
-
-  // The clock is not monotonically increasing.
-  static constexpr bool is_steady = false;
-
-  // Get the current time.
-  static time_point now() noexcept
-  {
-    return time_point() + std::chrono::seconds(std::time(0));
-  }
-};
-
-// The asio::basic_waitable_timer template accepts an optional WaitTraits
-// template parameter. The underlying time_t clock has one-second granularity,
-// so these traits may be customised to reduce the latency between the clock
-// ticking over and a wait operation's completion. When the timeout is near
-// (less than one second away) we poll the clock more frequently to detect the
-// time change closer to when it occurs. The user can select the appropriate
-// trade off between accuracy and the increased CPU cost of polling. In extreme
-// cases, a zero duration may be returned to make the timers as accurate as
-// possible, albeit with 100% CPU usage.
-struct time_t_wait_traits
-{
-  // Determine how long until the clock should be next polled to determine
-  // whether the duration has elapsed.
-  static time_t_clock::duration to_wait_duration(
-      const time_t_clock::duration& d)
-  {
-    if (d > std::chrono::seconds(1))
-      return d - std::chrono::seconds(1);
-    else if (d > std::chrono::seconds(0))
-      return std::chrono::milliseconds(10);
-    else
-      return std::chrono::seconds(0);
-  }
-
-  // Determine how long until the clock should be next polled to determine
-  // whether the absoluate time has been reached.
-  static time_t_clock::duration to_wait_duration(
-      const time_t_clock::time_point& t)
-  {
-    return to_wait_duration(t - time_t_clock::now());
-  }
-};
-
-typedef asio::basic_waitable_timer<
-  time_t_clock, time_t_wait_traits> time_t_timer;
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    time_t_timer timer(io_context);
-
-    timer.expires_after(std::chrono::seconds(5));
-    std::cout << "Starting synchronous wait\n";
-    timer.wait();
-    std::cout << "Finished synchronous wait\n";
-
-    timer.expires_after(std::chrono::seconds(5));
-    std::cout << "Starting asynchronous wait\n";
-    timer.async_wait(
-        [](const std::error_code& /*error*/)
-        {
-          std::cout << "timeout\n";
-        });
-    io_context.run();
-    std::cout << "Finished asynchronous wait\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/.gitignore
deleted file mode 100644
index 2926eaf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-client
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/client.cpp
deleted file mode 100644
index 9d92775..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime1/client.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <iostream>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: client <host>" << std::endl;
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::resolver resolver(io_context);
-    tcp::resolver::results_type endpoints =
-      resolver.resolve(argv[1], "daytime");
-
-    tcp::socket socket(io_context);
-    asio::connect(socket, endpoints);
-
-    for (;;)
-    {
-      std::array<char, 128> buf;
-      std::error_code error;
-
-      size_t len = socket.read_some(asio::buffer(buf), error);
-
-      if (error == asio::error::eof)
-        break; // Connection closed cleanly by peer.
-      else if (error)
-        throw std::system_error(error); // Some other error.
-
-      std::cout.write(buf.data(), len);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/.gitignore
deleted file mode 100644
index 7f06efb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/server.cpp
deleted file mode 100644
index 971149d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime2/server.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <ctime>
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 13));
-
-    for (;;)
-    {
-      tcp::socket socket(io_context);
-      acceptor.accept(socket);
-
-      std::string message = make_daytime_string();
-
-      std::error_code ignored_error;
-      asio::write(socket, asio::buffer(message), ignored_error);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/.gitignore
deleted file mode 100644
index 7f06efb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/server.cpp
deleted file mode 100644
index 339de72..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime3/server.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <ctime>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-class tcp_connection
-  : public std::enable_shared_from_this<tcp_connection>
-{
-public:
-  typedef std::shared_ptr<tcp_connection> pointer;
-
-  static pointer create(asio::io_context& io_context)
-  {
-    return pointer(new tcp_connection(io_context));
-  }
-
-  tcp::socket& socket()
-  {
-    return socket_;
-  }
-
-  void start()
-  {
-    message_ = make_daytime_string();
-
-    asio::async_write(socket_, asio::buffer(message_),
-        std::bind(&tcp_connection::handle_write, shared_from_this(),
-          asio::placeholders::error,
-          asio::placeholders::bytes_transferred));
-  }
-
-private:
-  tcp_connection(asio::io_context& io_context)
-    : socket_(io_context)
-  {
-  }
-
-  void handle_write(const std::error_code& /*error*/,
-      size_t /*bytes_transferred*/)
-  {
-  }
-
-  tcp::socket socket_;
-  std::string message_;
-};
-
-class tcp_server
-{
-public:
-  tcp_server(asio::io_context& io_context)
-    : io_context_(io_context),
-      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  {
-    start_accept();
-  }
-
-private:
-  void start_accept()
-  {
-    tcp_connection::pointer new_connection =
-      tcp_connection::create(io_context_);
-
-    acceptor_.async_accept(new_connection->socket(),
-        std::bind(&tcp_server::handle_accept, this, new_connection,
-          asio::placeholders::error));
-  }
-
-  void handle_accept(tcp_connection::pointer new_connection,
-      const std::error_code& error)
-  {
-    if (!error)
-    {
-      new_connection->start();
-    }
-
-    start_accept();
-  }
-
-  asio::io_context& io_context_;
-  tcp::acceptor acceptor_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-    tcp_server server(io_context);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/.gitignore
deleted file mode 100644
index 2926eaf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-client
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/client.cpp
deleted file mode 100644
index 15f3d5d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime4/client.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <iostream>
-#include <asio.hpp>
-
-using asio::ip::udp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: client <host>" << std::endl;
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    udp::resolver resolver(io_context);
-    udp::endpoint receiver_endpoint =
-      *resolver.resolve(udp::v4(), argv[1], "daytime").begin();
-
-    udp::socket socket(io_context);
-    socket.open(udp::v4());
-
-    std::array<char, 1> send_buf  = {{ 0 }};
-    socket.send_to(asio::buffer(send_buf), receiver_endpoint);
-
-    std::array<char, 128> recv_buf;
-    udp::endpoint sender_endpoint;
-    size_t len = socket.receive_from(
-        asio::buffer(recv_buf), sender_endpoint);
-
-    std::cout.write(recv_buf.data(), len);
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/.gitignore
deleted file mode 100644
index 7f06efb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/server.cpp
deleted file mode 100644
index f47c9fa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime5/server.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <ctime>
-#include <iostream>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::udp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-
-    udp::socket socket(io_context, udp::endpoint(udp::v4(), 13));
-
-    for (;;)
-    {
-      std::array<char, 1> recv_buf;
-      udp::endpoint remote_endpoint;
-      socket.receive_from(asio::buffer(recv_buf), remote_endpoint);
-
-      std::string message = make_daytime_string();
-
-      std::error_code ignored_error;
-      socket.send_to(asio::buffer(message),
-          remote_endpoint, 0, ignored_error);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/.gitignore
deleted file mode 100644
index 7f06efb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/server.cpp
deleted file mode 100644
index 42c8079..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime6/server.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <ctime>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::udp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-class udp_server
-{
-public:
-  udp_server(asio::io_context& io_context)
-    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  {
-    start_receive();
-  }
-
-private:
-  void start_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(recv_buffer_), remote_endpoint_,
-        std::bind(&udp_server::handle_receive, this,
-          asio::placeholders::error,
-          asio::placeholders::bytes_transferred));
-  }
-
-  void handle_receive(const std::error_code& error,
-      std::size_t /*bytes_transferred*/)
-  {
-    if (!error)
-    {
-      std::shared_ptr<std::string> message(
-          new std::string(make_daytime_string()));
-
-      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-          std::bind(&udp_server::handle_send, this, message,
-            asio::placeholders::error,
-            asio::placeholders::bytes_transferred));
-
-      start_receive();
-    }
-  }
-
-  void handle_send(std::shared_ptr<std::string> /*message*/,
-      const std::error_code& /*error*/,
-      std::size_t /*bytes_transferred*/)
-  {
-  }
-
-  udp::socket socket_;
-  udp::endpoint remote_endpoint_;
-  std::array<char, 1> recv_buffer_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-    udp_server server(io_context);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/.gitignore
deleted file mode 100644
index 7f06efb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-server
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/server.cpp
deleted file mode 100644
index 9c9c22e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime7/server.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <array>
-#include <ctime>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <asio.hpp>
-
-using asio::ip::tcp;
-using asio::ip::udp;
-
-std::string make_daytime_string()
-{
-  using namespace std; // For time_t, time and ctime;
-  time_t now = time(0);
-  return ctime(&now);
-}
-
-class tcp_connection
-  : public std::enable_shared_from_this<tcp_connection>
-{
-public:
-  typedef std::shared_ptr<tcp_connection> pointer;
-
-  static pointer create(asio::io_context& io_context)
-  {
-    return pointer(new tcp_connection(io_context));
-  }
-
-  tcp::socket& socket()
-  {
-    return socket_;
-  }
-
-  void start()
-  {
-    message_ = make_daytime_string();
-
-    asio::async_write(socket_, asio::buffer(message_),
-        std::bind(&tcp_connection::handle_write, shared_from_this()));
-  }
-
-private:
-  tcp_connection(asio::io_context& io_context)
-    : socket_(io_context)
-  {
-  }
-
-  void handle_write()
-  {
-  }
-
-  tcp::socket socket_;
-  std::string message_;
-};
-
-class tcp_server
-{
-public:
-  tcp_server(asio::io_context& io_context)
-    : io_context_(io_context),
-      acceptor_(io_context, tcp::endpoint(tcp::v4(), 13))
-  {
-    start_accept();
-  }
-
-private:
-  void start_accept()
-  {
-    tcp_connection::pointer new_connection =
-      tcp_connection::create(io_context_);
-
-    acceptor_.async_accept(new_connection->socket(),
-        std::bind(&tcp_server::handle_accept, this, new_connection,
-          asio::placeholders::error));
-  }
-
-  void handle_accept(tcp_connection::pointer new_connection,
-      const std::error_code& error)
-  {
-    if (!error)
-    {
-      new_connection->start();
-    }
-
-    start_accept();
-  }
-
-  asio::io_context& io_context_;
-  tcp::acceptor acceptor_;
-};
-
-class udp_server
-{
-public:
-  udp_server(asio::io_context& io_context)
-    : socket_(io_context, udp::endpoint(udp::v4(), 13))
-  {
-    start_receive();
-  }
-
-private:
-  void start_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(recv_buffer_), remote_endpoint_,
-        std::bind(&udp_server::handle_receive, this,
-          asio::placeholders::error));
-  }
-
-  void handle_receive(const std::error_code& error)
-  {
-    if (!error)
-    {
-      std::shared_ptr<std::string> message(
-          new std::string(make_daytime_string()));
-
-      socket_.async_send_to(asio::buffer(*message), remote_endpoint_,
-          std::bind(&udp_server::handle_send, this, message));
-
-      start_receive();
-    }
-  }
-
-  void handle_send(std::shared_ptr<std::string> /*message*/)
-  {
-  }
-
-  udp::socket socket_;
-  udp::endpoint remote_endpoint_;
-  std::array<char, 1> recv_buffer_;
-};
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context;
-    tcp_server server1(io_context);
-    udp_server server2(io_context);
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime_dox.txt
deleted file mode 100644
index 2d2453f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/daytime_dox.txt
+++ /dev/null
@@ -1,498 +0,0 @@
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-/**
-\page tutdaytime1 Daytime.1 - A synchronous TCP daytime client
-
-This tutorial program shows how to use asio to implement a client application
-with TCP.
-
-\dontinclude daytime1/client.cpp
-\skip #include
-
-We start by including the necessary header files.
-
-\until asio.hpp
-
-The purpose of this application is to access a daytime service,
-so we need the user to specify the server.
-
-\until }
-
-All programs that use asio need to have at least one I/O execution context,
-such as an asio::io_context object.
-
-\until asio::io_context
-
-We need to turn the server name that was specified as a parameter to the
-application, into a TCP endpoint. To do this we use an
-asio::ip::tcp::resolver object.
-
-\until tcp::resolver
-
-A resolver takes a host name and service name and turns them into a list of
-endpoints. We perform a resolve call using the name of the server, specified in
-<tt>argv[1]</tt>, and the name of the service, in this case <tt>"daytime"</tt>.
-
-The list of endpoints is returned using an object of type
-asio::ip::tcp::resolver::results_type. This object is a range, with begin() and
-end() member functions that may be used for iterating over the results.
-
-\until resolver.resolve
-
-Now we create and connect the socket. The list of endpoints obtained above may
-contain both IPv4 and IPv6 endpoints, so we need to try each of them until we
-find one that works. This keeps the client program independent of a specific IP
-version. The asio::connect() function does this for us automatically.
-
-\until asio::connect
-
-The connection is open. All we need to do now is read the response from the
-daytime service.
-
-We use a <tt>std::array</tt> to hold the received data. The asio::buffer()
-function automatically determines the size of the array to help prevent buffer
-overruns. Instead of a <tt>std::array</tt>, we could have used a <tt>char
-[]</tt> or <tt>std::vector</tt>.
-
-\until read_some
-
-When the server closes the connection, the asio::ip::tcp::socket::read_some()
-function will exit with the asio::error::eof error, which is how we know to
-exit the loop.
-
-\until }
-
-Finally, handle any exceptions that may have been thrown.
-
-\until }
-\until }
-
-See the \ref tutdaytime1src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Next: \ref tutdaytime2
-
-*/
-
-/**
-\page tutdaytime1src Source listing for Daytime.1
-\include daytime1/client.cpp
-Return to \ref tutdaytime1
-*/
-
-/**
-\page tutdaytime2 Daytime.2 - A synchronous TCP daytime server
-
-This tutorial program shows how to use asio to implement a server application
-with TCP.
-
-\dontinclude daytime2/server.cpp
-\skip #include
-
-\until using
-
-We define the function <tt>make_daytime_string()</tt> to create the string to
-be sent back to the client. This function will be reused in all of our daytime
-server applications.
-
-\until asio::io_context
-
-A asio::ip::tcp::acceptor object needs to be created to listen
-for new connections. It is initialised to listen on TCP port 13, for IP version 4.
-
-\until tcp::acceptor
-
-This is an iterative server, which means that it will handle one
-connection at a time. Create a socket that will represent the connection to the
-client, and then wait for a connection.
-
-\until acceptor.accept
-
-A client is accessing our service. Determine the current time
-and transfer this information to the client. 
-
-\until }
-\until }
-
-Finally, handle any exceptions.
-
-\until }
-\until }
-
-See the \ref tutdaytime2src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime1 \n
-Next: \ref tutdaytime3
-
-*/
-
-/**
-\page tutdaytime2src Source listing for Daytime.2
-\include daytime2/server.cpp
-Return to \ref tutdaytime2
-*/
-
-/**
-\page tutdaytime3 Daytime.3 - An asynchronous TCP daytime server
-
-\section tutdaytime3funcmain The main() function
-
-\dontinclude daytime3/server.cpp
-\skip int main()
-\until try
-\until {
-
-We need to create a server object to accept incoming client connections. The
-asio::io_context object provides I/O services, such as sockets, that the
-server object will use.
-
-\until tcp_server
-
-Run the asio::io_context object so that it will perform asynchronous operations
-on your behalf.
-
-\until return 0;
-\until }
-
-\section tutdaytime3classtcp_server The tcp_server class
-
-\dontinclude daytime3/server.cpp
-\skip class tcp_server
-\until public:
-
-The constructor initialises an acceptor to listen on TCP port 13.
-
-\until private:
-
-The function <tt>start_accept()</tt> creates a socket and initiates an
-asynchronous accept operation to wait for a new connection.
-
-\until }
-
-The function <tt>handle_accept()</tt> is called when the asynchronous accept
-operation initiated by <tt>start_accept()</tt> finishes. It services the client
-request, and then calls <tt>start_accept()</tt> to initiate the next accept
-operation.
-
-\until }
-\until }
-
-\section tutdaytime3classtcp_connection The tcp_connection class
-
-We will use <tt>shared_ptr</tt> and <tt>enable_shared_from_this</tt> because we
-want to keep the <tt>tcp_connection</tt> object alive as long as there is an
-operation that refers to it.
-
-\dontinclude daytime3/server.cpp
-\skip class tcp_connection
-\until shared_ptr
-\until }
-\until }
-
-In the function <tt>start()</tt>, we call asio::async_write() to serve the data
-to the client. Note that we are using asio::async_write(), rather than
-asio::ip::tcp::socket::async_write_some(), to ensure that the entire block of
-data is sent.
-
-\until {
-
-The data to be sent is stored in the class member <tt>message_</tt> as we need
-to keep the data valid until the asynchronous operation is complete.
-
-\until message_
-
-When initiating the asynchronous operation, and if using @c std::bind, you
-must specify only the arguments that match the handler's parameter list. In
-this program, both of the argument placeholders (asio::placeholders::error and
-asio::placeholders::bytes_transferred) could potentially have been removed,
-since they are not being used in <tt>handle_write()</tt>.
-
-\until placeholders::bytes_transferred
-
-Any further actions for this client connection are now the responsibility of
-<tt>handle_write()</tt>.
-
-\until };
-
-\section tutdaytime3remunused Removing unused handler parameters
-
-You may have noticed that the <tt>error</tt>, and <tt>bytes_transferred</tt>
-parameters are not used in the body of the <tt>handle_write()</tt> function. If
-parameters are not needed, it is possible to remove them from the function so
-that it looks like:
-
-\code
-  void handle_write()
-  {
-  }
-\endcode
-
-The asio::async_write() call used to initiate the call can then be changed to
-just:
-
-\code
-  asio::async_write(socket_, asio::buffer(message_),
-      std::bind(&tcp_connection::handle_write, shared_from_this()));
-\endcode
-
-See the \ref tutdaytime3src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime2 \n
-Next: \ref tutdaytime4
-
-*/
-
-/**
-\page tutdaytime3src Source listing for Daytime.3
-\include daytime3/server.cpp
-Return to \ref tutdaytime3
-*/
-
-/**
-\page tutdaytime4 Daytime.4 - A synchronous UDP daytime client
-
-This tutorial program shows how to use asio to implement a client application
-with UDP.
-
-\dontinclude daytime4/client.cpp
-\skip #include
-\until using asio::ip::udp;
-
-The start of the application is essentially the same as for the TCP daytime
-client.
-
-\until asio::io_context
-
-We use an asio::ip::udp::resolver object to find the correct remote endpoint to
-use based on the host and service names. The query is restricted to return only
-IPv4 endpoints by the asio::ip::udp::v4() argument.
-
-\until udp::v4
-
-The asio::ip::udp::resolver::resolve() function is guaranteed to return at
-least one endpoint in the list if it does not fail. This means it is safe to
-dereference the return value directly.
-
-Since UDP is datagram-oriented, we will not be using a stream socket. Create an
-asio::ip::udp::socket and initiate contact with the remote endpoint.
-
-\until receiver_endpoint
-
-Now we need to be ready to accept whatever the server sends back to us. The
-endpoint on our side that receives the server's response will be initialised by
-asio::ip::udp::socket::receive_from(). 
-
-\until }
-
-Finally, handle any exceptions that may have been thrown.
-
-\until }
-\until }
-See the \ref tutdaytime4src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime3 \n
-Next: \ref tutdaytime5
-
-*/
-
-/**
-\page tutdaytime4src Source listing for Daytime.4
-\include daytime4/client.cpp
-Return to \ref tutdaytime4
-*/
-
-/**
-\page tutdaytime5 Daytime.5 - A synchronous UDP daytime server
-
-This tutorial program shows how to use asio to implement a server application
-with UDP.
-
-\dontinclude daytime5/server.cpp
-\skip int main()
-\until asio::io_context
-
-Create an asio::ip::udp::socket object to receive requests on UDP port 13.
-
-\until udp::socket
-
-Wait for a client to initiate contact with us. The remote_endpoint object will
-be populated by asio::ip::udp::socket::receive_from().
-
-\until receive_from
-
-Determine what we are going to send back to the client.
-
-\until std::string message
-
-Send the response to the remote_endpoint.
-
-\until }
-\until }
-
-Finally, handle any exceptions.
-
-\until }
-\until }
-
-See the \ref tutdaytime5src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime4 \n
-Next: \ref tutdaytime6
-
-*/
-
-/**
-\page tutdaytime5src Source listing for Daytime.5
-\include daytime5/server.cpp
-Return to \ref tutdaytime5
-*/
-
-/**
-\page tutdaytime6 Daytime.6 - An asynchronous UDP daytime server
-
-\section tutdaytime6funcmain The main() function
-
-\dontinclude daytime6/server.cpp
-\skip int main()
-\until try
-\until {
-
-Create a server object to accept incoming client requests, and run
-the asio::io_context object.
-
-\until return 0;
-\until }
-
-\section tutdaytime6classudp_server The udp_server class
-
-\dontinclude daytime6/server.cpp
-\skip class udp_server
-\until public:
-
-The constructor initialises a socket to listen on UDP port 13.
-
-\until private:
-\until {
-
-The function asio::ip::udp::socket::async_receive_from() will cause the
-application to listen in the background for a new request. When such a request
-is received, the asio::io_context object will invoke the
-<tt>handle_receive()</tt> function with two arguments: a value of type
-std::error_code indicating whether the operation succeeded or failed, and a
-<tt>size_t</tt> value <tt>bytes_transferred</tt> specifying the number of bytes
-received.
-
-\until }
-
-The function <tt>handle_receive()</tt> will service the client request.
-
-\until {
-
-The <tt>error</tt> parameter contains the result of the asynchronous operation.
-Since we only provide the 1-byte <tt>recv_buffer_</tt> to contain the client's
-request, the asio::io_context object would return an error if the client sent
-anything larger. We can ignore such an error if it comes up.
-
-\until {
-
-Determine what we are going to send.
-
-\until make_daytime_string()
-
-We now call asio::ip::udp::socket::async_send_to() to serve the data to the
-client.
-
-\until asio::placeholders::bytes_transferred
-
-When initiating the asynchronous operation, and if using @c std::bind, you
-must specify only the arguments that match the handler's parameter list. In
-this program, both of the argument placeholders (asio::placeholders::error and
-asio::placeholders::bytes_transferred) could potentially have been removed.
-
-Start listening for the next client request.
-
-\until start_receive
-
-Any further actions for this client request are now the responsibility of
-<tt>handle_send()</tt>.
-
-\until }
-\until }
-
-The function <tt>handle_send()</tt> is invoked after the service request has
-been completed.
-
-\until }
-\until }
-
-See the \ref tutdaytime6src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime5 \n
-Next: \ref tutdaytime7
-
-*/
-
-/**
-\page tutdaytime6src Source listing for Daytime.6
-\include daytime6/server.cpp
-Return to \ref tutdaytime6
-*/
-
-/**
-\page tutdaytime7 Daytime.7 - A combined TCP/UDP asynchronous server
-
-This tutorial program shows how to combine the two asynchronous servers that we
-have just written, into a single server application.
-
-\section tutdaytime7funcmain The main() function
-
-\dontinclude daytime7/server.cpp
-\skip int main()
-\until asio::io_context
-
-We will begin by creating a server object to accept a TCP client connection.
-
-\until tcp_server
-
-We also need a server object to accept a UDP client request.
-
-\until udp_server
-
-We have created two lots of work for the asio::io_context object to do.
-
-\until return 0;
-\until }
-
-\section tutdaytime7classtcp The tcp_connection and tcp_server classes
-
-The following two classes are taken from \ref tutdaytime3 "Daytime.3".
-
-\dontinclude daytime7/server.cpp
-\skip class tcp_connection
-\until };
-\until };
-
-\section tutdaytime7classudp The udp_server class
-
-Similarly, this next class is taken from the
-\ref tutdaytime6 "previous tutorial step".
-
-\dontinclude daytime7/server.cpp
-\skip class udp_server
-\until };
-
-See the \ref tutdaytime7src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tutdaytime6
-
-*/
-
-/**
-\page tutdaytime7src Source listing for Daytime.7
-\include daytime7/server.cpp
-Return to \ref tutdaytime7
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/index_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/index_dox.txt
deleted file mode 100644
index 0d6783e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/index_dox.txt
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-/**
-\mainpage asio Tutorial
-
-\section tuttimer Basic Skills
-
-The tutorial programs in this first section introduce the fundamental concepts
-required to use the asio toolkit. Before plunging into the complex world of
-network programming, these tutorial programs illustrate the basic skills using
-simple asynchronous timers.
-
-\li \ref tuttimer1
-\li \ref tuttimer2
-\li \ref tuttimer3
-\li \ref tuttimer4
-\li \ref tuttimer5
-
-\section tutdaytime Introduction to Sockets
-
-The tutorial programs in this section show how to use asio to develop simple
-client and server programs. These tutorial programs are based around the <a
-href="http://www.ietf.org/rfc/rfc867.txt">daytime</a> protocol, which supports
-both TCP and UDP. 
-
-The first three tutorial programs implement the daytime protocol using TCP.
-
-\li \ref tutdaytime1
-\li \ref tutdaytime2
-\li \ref tutdaytime3
-
-The next three tutorial programs implement the daytime protocol using UDP.
-
-\li \ref tutdaytime4
-\li \ref tutdaytime5
-\li \ref tutdaytime6
-
-The last tutorial program in this section demonstrates how asio allows the TCP
-and UDP servers to be easily combined into a single program.
-
-\li \ref tutdaytime7
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/.gitignore
deleted file mode 100644
index 1d47ca6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-timer
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/timer.cpp
deleted file mode 100644
index 37577dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer1/timer.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <asio.hpp>
-
-int main()
-{
-  asio::io_context io;
-
-  asio::steady_timer t(io, asio::chrono::seconds(5));
-  t.wait();
-
-  std::cout << "Hello, world!" << std::endl;
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/.gitignore
deleted file mode 100644
index 1d47ca6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-timer
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/timer.cpp
deleted file mode 100644
index c1620d7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer2/timer.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <asio.hpp>
-
-void print(const std::error_code& /*e*/)
-{
-  std::cout << "Hello, world!" << std::endl;
-}
-
-int main()
-{
-  asio::io_context io;
-
-  asio::steady_timer t(io, asio::chrono::seconds(5));
-  t.async_wait(&print);
-
-  io.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/.gitignore
deleted file mode 100644
index 1d47ca6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-timer
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/timer.cpp
deleted file mode 100644
index 990ea06..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer3/timer.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <functional>
-#include <iostream>
-#include <asio.hpp>
-
-void print(const std::error_code& /*e*/,
-    asio::steady_timer* t, int* count)
-{
-  if (*count < 5)
-  {
-    std::cout << *count << std::endl;
-    ++(*count);
-
-    t->expires_at(t->expiry() + asio::chrono::seconds(1));
-    t->async_wait(std::bind(print,
-          asio::placeholders::error, t, count));
-  }
-}
-
-int main()
-{
-  asio::io_context io;
-
-  int count = 0;
-  asio::steady_timer t(io, asio::chrono::seconds(1));
-  t.async_wait(std::bind(print,
-        asio::placeholders::error, &t, &count));
-
-  io.run();
-
-  std::cout << "Final count is " << count << std::endl;
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/.gitignore
deleted file mode 100644
index 1d47ca6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-timer
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/timer.cpp
deleted file mode 100644
index 7bfdd3e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer4/timer.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <functional>
-#include <iostream>
-#include <asio.hpp>
-
-class printer
-{
-public:
-  printer(asio::io_context& io)
-    : timer_(io, asio::chrono::seconds(1)),
-      count_(0)
-  {
-    timer_.async_wait(std::bind(&printer::print, this));
-  }
-
-  ~printer()
-  {
-    std::cout << "Final count is " << count_ << std::endl;
-  }
-
-  void print()
-  {
-    if (count_ < 5)
-    {
-      std::cout << count_ << std::endl;
-      ++count_;
-
-      timer_.expires_at(timer_.expiry() + asio::chrono::seconds(1));
-      timer_.async_wait(std::bind(&printer::print, this));
-    }
-  }
-
-private:
-  asio::steady_timer timer_;
-  int count_;
-};
-
-int main()
-{
-  asio::io_context io;
-  printer p(io);
-  io.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/.gitignore
deleted file mode 100644
index 1d47ca6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-timer
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/timer.cpp
deleted file mode 100644
index 6183069..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer5/timer.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <functional>
-#include <iostream>
-#include <thread>
-#include <asio.hpp>
-
-class printer
-{
-public:
-  printer(asio::io_context& io)
-    : strand_(asio::make_strand(io)),
-      timer1_(io, asio::chrono::seconds(1)),
-      timer2_(io, asio::chrono::seconds(1)),
-      count_(0)
-  {
-    timer1_.async_wait(asio::bind_executor(strand_,
-          std::bind(&printer::print1, this)));
-
-    timer2_.async_wait(asio::bind_executor(strand_,
-          std::bind(&printer::print2, this)));
-  }
-
-  ~printer()
-  {
-    std::cout << "Final count is " << count_ << std::endl;
-  }
-
-  void print1()
-  {
-    if (count_ < 10)
-    {
-      std::cout << "Timer 1: " << count_ << std::endl;
-      ++count_;
-
-      timer1_.expires_at(timer1_.expiry() + asio::chrono::seconds(1));
-
-      timer1_.async_wait(asio::bind_executor(strand_,
-            std::bind(&printer::print1, this)));
-    }
-  }
-
-  void print2()
-  {
-    if (count_ < 10)
-    {
-      std::cout << "Timer 2: " << count_ << std::endl;
-      ++count_;
-
-      timer2_.expires_at(timer2_.expiry() + asio::chrono::seconds(1));
-
-      timer2_.async_wait(asio::bind_executor(strand_,
-            std::bind(&printer::print2, this)));
-    }
-  }
-
-private:
-  asio::strand<asio::io_context::executor_type> strand_;
-  asio::steady_timer timer1_;
-  asio::steady_timer timer2_;
-  int count_;
-};
-
-int main()
-{
-  asio::io_context io;
-  printer p(io);
-  std::thread t([&]{ io.run(); });
-  io.run();
-  t.join();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer_dox.txt b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer_dox.txt
deleted file mode 100644
index 3fce286..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/tutorial/timer_dox.txt
+++ /dev/null
@@ -1,380 +0,0 @@
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-/**
-\page tuttimer1 Timer.1 - Using a timer synchronously
-
-This tutorial program introduces asio by showing how to perform a blocking
-wait on a timer.
-
-\dontinclude timer1/timer.cpp
-\skip #include
-
-We start by including the necessary header files.
-
-All of the asio classes can be used by simply including the <tt>"asio.hpp"</tt>
-header file.
-
-\until asio.hpp
-
-All programs that use asio need to have at least one I/O execution context,
-such as an asio::io_context or asio::thread_pool object. An I/O execution
-context provides access to I/O functionality. We declare an object of type
-asio::io_context first thing in the main function.
-
-\until asio::io_context
-
-Next we declare an object of type asio::steady_timer. The core asio classes
-that provide I/O functionality (or as in this case timer functionality) always
-take an executor, or a reference to an execution context (such as
-asio::io_context), as their first constructor argument. The second argument to
-the constructor sets the timer to expire 5 seconds from now.
-
-\until asio::steady_timer
-
-In this simple example we perform a blocking wait on the timer.
-That is, the call to asio::steady_timer::wait() will not return until the
-timer has expired, 5 seconds after it was created (i.e. <b>not</b> from when the
-wait starts).
-
-A timer is always in one of two states: "expired" or "not expired". If the
-asio::steady_timer::wait() function is called on an expired timer, it will
-return immediately.
-
-\until wait
-
-Finally we print the obligatory <tt>"Hello, world!"</tt>
-message to show when the timer has expired.
-
-\until }
-
-See the \ref tuttimer1src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Next: \ref tuttimer2
-
-*/
-
-/**
-\page tuttimer1src Source listing for Timer.1
-\include timer1/timer.cpp
-Return to \ref tuttimer1
-*/
-
-/**
-\page tuttimer2 Timer.2 - Using a timer asynchronously
-
-This tutorial program demonstrates how to use asio's asynchronous functionality
-by modifying the program from tutorial Timer.1 to perform an asynchronous wait
-on the timer.
-
-\dontinclude timer2/timer.cpp
-\skip #include
-
-\until asio.hpp
-
-Using asio's asynchronous functionality means supplying a @ref completion_token,
-which determines how the result will be delivered to a <em>completion
-handler</em> when an @ref asynchronous_operation completes. In this program we
-define a function called <tt>print</tt> to be called when the asynchronous wait
-finishes.
-
-\until asio::steady_timer 
-
-Next, instead of doing a blocking wait as in tutorial Timer.1,
-we call the asio::steady_timer::async_wait() function to perform an
-asynchronous wait. When calling this function we pass the <tt>print</tt>
-function that was defined above.
-
-\skipline async_wait
-
-Finally, we must call the asio::io_context::run() member function
-on the io_context object.
-
-The asio library provides a guarantee that completion handlers will <b>only</b>
-be called from threads that are currently calling asio::io_context::run().
-Therefore unless the asio::io_context::run() function is called the completion
-handler for the asynchronous wait completion will never be invoked.
-
-The asio::io_context::run() function will also continue to run while there is
-still "work" to do. In this example, the work is the asynchronous wait on the
-timer, so the call will not return until the timer has expired and the
-completion handler has returned.
-
-It is important to remember to give the io_context some work to do before
-calling asio::io_context::run(). For example, if we had omitted the above call
-to asio::steady_timer::async_wait(), the io_context would not have had any
-work to do, and consequently asio::io_context::run() would have returned
-immediately.
-
-\skip run
-\until }
-
-See the \ref tuttimer2src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tuttimer1 \n
-Next: \ref tuttimer3
-
-*/
-
-/**
-\page tuttimer2src Source listing for Timer.2
-\include timer2/timer.cpp
-Return to \ref tuttimer2
-*/
-
-/**
-\page tuttimer3 Timer.3 - Binding arguments to a completion handler
-
-In this tutorial we will modify the program from tutorial Timer.2 so that the
-timer fires once a second. This will show how to pass additional parameters to
-your handler function.
-
-\dontinclude timer3/timer.cpp
-\skip #include
-
-\until asio.hpp
-
-To implement a repeating timer using asio you need to change
-the timer's expiry time in your completion handler, and to then start a new
-asynchronous wait. Obviously this means that the completion handler will need
-to be able to access the timer object. To this end we add two new parameters
-to the <tt>print</tt> function:
-
-\li a pointer to a timer object; and
-
-\li a counter so that we can stop the program when the timer fires for the
-sixth time
-
-at the end of the parameter list.
-
-\until {
-
-As mentioned above, this tutorial program uses a counter to
-stop running when the timer fires for the sixth time. However you will observe
-that there is no explicit call to ask the io_context to stop. Recall that in
-tutorial Timer.2 we learnt that the asio::io_context::run() function completes
-when there is no more "work" to do. By not starting a new asynchronous wait on
-the timer when <tt>count</tt> reaches 5, the io_context will run out of work and
-stop running.
-
-\until ++
-
-Next we move the expiry time for the timer along by one second
-from the previous expiry time. By calculating the new expiry time relative to
-the old, we can ensure that the timer does not drift away from the
-whole-second mark due to any delays in processing the handler.
-
-\until expires_at
-
-Then we start a new asynchronous wait on the timer. As you can
-see, the @c std::bind function is used to associate the extra parameters
-with your completion handler. The asio::steady_timer::async_wait() function
-expects a handler function (or function object) with the signature
-<tt>void(const std::error_code&)</tt>. Binding the additional parameters
-converts your <tt>print</tt> function into a function object that matches the
-signature correctly.
-
-In this example, the asio::placeholders::error argument to @c std::bind is a
-named placeholder for the error object passed to the handler. When initiating
-the asynchronous operation, and if using @c std::bind, you must specify only
-the arguments that match the handler's parameter list. In tutorial Timer.4 you
-will see that this placeholder may be elided if the parameter is not needed by
-the completion handler.
-
-\until asio::io_context
-
-A new <tt>count</tt> variable is added so that we can stop the
-program when the timer fires for the sixth time.
-
-\until asio::steady_timer
-
-As in Step 4, when making the call to
-asio::steady_timer::async_wait() from <tt>main</tt> we bind the additional
-parameters needed for the <tt>print</tt> function.
-
-\until run
-
-Finally, just to prove that the <tt>count</tt> variable was
-being used in the <tt>print</tt> handler function, we will print out its new
-value.
-
-\until }
-
-See the \ref tuttimer3src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tuttimer2 \n
-Next: \ref tuttimer4
-
-*/
-
-/**
-\page tuttimer3src Source listing for Timer.3
-\include timer3/timer.cpp
-Return to \ref tuttimer3
-*/
-
-/**
-\page tuttimer4 Timer.4 - Using a member function as a completion handler
-
-In this tutorial we will see how to use a class member function as a completion
-handler. The program should execute identically to the tutorial program from
-tutorial Timer.3.
-
-\dontinclude timer4/timer.cpp
-\skip #include
-
-\until asio.hpp
-
-Instead of defining a free function <tt>print</tt> as the
-completion handler, as we did in the earlier tutorial programs, we now define a
-class called <tt>printer</tt>.
-
-\until public
-
-The constructor of this class will take a reference to the
-io_context object and use it when initialising the <tt>timer_</tt> member. The
-counter used to shut down the program is now also a member of the class.
-
-\until {
-
-The @c std::bind function works just as well with class
-member functions as with free functions. Since all non-static class member
-functions have an implicit <tt>this</tt> parameter, we need to bind
-<tt>this</tt> to the function. As in tutorial Timer.3, @c std::bind
-converts our completion handler (now a member function) into a function object
-that can be invoked as though it has the signature <tt>void(const
-std::error_code&)</tt>.
-
-You will note that the asio::placeholders::error placeholder is not specified
-here, as the <tt>print</tt> member function does not accept an error object as
-a parameter.
-
-\until }
-
-In the class destructor we will print out the final value of
-the counter.
-
-\until }
-
-The <tt>print</tt> member function is very similar to the
-<tt>print</tt> function from tutorial Timer.3, except that it now operates on
-the class data members instead of having the timer and counter passed in as
-parameters.
-
-\until };
-
-The <tt>main</tt> function is much simpler than before, as it
-now declares a local <tt>printer</tt> object before running the io_context as
-normal.
-
-\until }
-
-See the \ref tuttimer4src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tuttimer3 \n
-Next: \ref tuttimer5 \n
-
-*/
-
-/**
-\page tuttimer4src Source listing for Timer.4
-\include timer4/timer.cpp
-Return to \ref tuttimer4
-*/
-
-/**
-\page tuttimer5 Timer.5 - Synchronising completion handlers in multithreaded programs
-
-This tutorial demonstrates the use of the asio::strand class template to
-synchronise completion handlers in a multithreaded program.
-
-The previous four tutorials avoided the issue of handler synchronisation by
-calling the asio::io_context::run() function from one thread only. As you
-already know, the asio library provides a guarantee that completion handlers
-will <b>only</b> be called from threads that are currently calling
-asio::io_context::run(). Consequently, calling asio::io_context::run() from
-only one thread ensures that completion handlers cannot run concurrently.
-
-The single threaded approach is usually the best place to start when
-developing applications using asio. The downside is the limitations it places
-on programs, particularly servers, including:
-
-<ul>
-<li>Poor responsiveness when handlers can take a long time to complete.</li>
-<li>An inability to scale on multiprocessor systems.</li>
-</ul>
-
-If you find yourself running into these limitations, an alternative approach
-is to have a pool of threads calling asio::io_context::run(). However, as this
-allows handlers to execute concurrently, we need a method of synchronisation
-when handlers might be accessing a shared, thread-unsafe resource.
-
-\dontinclude timer5/timer.cpp
-\skip #include
-
-\until asio.hpp
-
-We start by defining a class called <tt>printer</tt>, similar
-to the class in the previous tutorial. This class will extend the previous
-tutorial by running two timers in parallel.
-
-\until public
-
-In addition to initialising a pair of asio::steady_timer members, the
-constructor initialises the <tt>strand_</tt> member, an object of type
-asio::strand<asio::io_context::executor_type>.
-
-The asio::strand class template is an executor adapter that guarantees
-that, for those handlers that are dispatched through it, an executing handler
-will be allowed to complete before the next one is started. This is guaranteed
-irrespective of the number of threads that are calling
-asio::io_context::run(). Of course, the handlers may still execute
-concurrently with other handlers that were <b>not</b> dispatched through an
-asio::strand, or were dispatched through a different asio::strand
-object.
-
-\until {
-
-When initiating the asynchronous operations, each completion handler is "bound"
-to an asio::strand<asio::io_context::executor_type> object. The
-asio::bind_executor() function returns a new handler that automatically
-dispatches its contained handler through the asio::strand object. By
-binding the handlers to the same asio::strand, we are ensuring that they
-cannot execute concurrently.
-
-\until }
-\until }
-
-In a multithreaded program, the handlers for asynchronous
-operations should be synchronised if they access shared resources. In this
-tutorial, the shared resources used by the handlers (<tt>print1</tt> and
-<tt>print2</tt>) are <tt>std::cout</tt> and the <tt>count_</tt> data member.
-
-\until };
-
-The <tt>main</tt> function now causes asio::io_context::run() to
-be called from two threads: the main thread and one additional thread. This is
-accomplished using an asio::thread object.
-
-Just as it would with a call from a single thread, concurrent calls to
-asio::io_context::run() will continue to execute while there is "work" left to
-do. The background thread will not exit until all asynchronous operations have
-completed.
-
-\until }
-
-See the \ref tuttimer5src "full source listing" \n
-Return to the \ref index "tutorial index" \n
-Previous: \ref tuttimer4 \n
-
-*/
-
-/**
-\page tuttimer5src Source listing for Timer.5
-\include timer5/timer.cpp
-Return to \ref tuttimer5
-*/
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/.gitignore
deleted file mode 100644
index 9e8415a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-type_erasure
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/line_reader.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/line_reader.hpp
deleted file mode 100644
index 87f0548..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/line_reader.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// line_reader.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef LINE_READER_HPP
-#define LINE_READER_HPP
-
-#include <asio/any_completion_handler.hpp>
-#include <asio/async_result.hpp>
-#include <asio/error.hpp>
-#include <string>
-
-class line_reader
-{
-private:
-  virtual void async_read_line_impl(std::string prompt,
-      asio::any_completion_handler<void(std::error_code, std::string)> handler) = 0;
-
-  struct initiate_read_line
-  {
-    template <typename Handler>
-    void operator()(Handler handler, line_reader* self, std::string prompt)
-    {
-      self->async_read_line_impl(std::move(prompt), std::move(handler));
-    }
-  };
-
-public:
-  virtual ~line_reader() {}
-
-  template <typename CompletionToken>
-  auto async_read_line(std::string prompt, CompletionToken&& token)
-    -> decltype(
-        asio::async_initiate<CompletionToken, void(std::error_code, std::string)>(
-          initiate_read_line(), token, this, prompt))
-  {
-    return asio::async_initiate<CompletionToken, void(std::error_code, std::string)>(
-        initiate_read_line(), token, this, prompt);
-  }
-};
-
-#endif // LINE_READER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/main.cpp
deleted file mode 100644
index 2111de6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/main.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "line_reader.hpp"
-#include "sleep.hpp"
-#include "stdin_line_reader.hpp"
-#include <asio/coroutine.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/use_awaitable.hpp>
-#include <iostream>
-
-#include <asio/yield.hpp>
-
-class read_loop : asio::coroutine
-{
-public:
-  read_loop(asio::any_io_executor e, line_reader& r)
-    : executor(std::move(e)),
-      reader(r)
-  {
-  }
-
-  void operator()(std::error_code ec = {}, std::string line = {})
-  {
-    reenter (this)
-    {
-      for (i = 0; i < 10; ++i)
-      {
-        yield reader.async_read_line("Enter something: ", *this);
-        if (ec) break;
-        std::cout << line;
-        yield async_sleep(executor, std::chrono::seconds(1), *this);
-        if (ec) break;
-      }
-    }
-  }
-
-private:
-  asio::any_io_executor executor;
-  line_reader& reader;
-  int i;
-};
-
-#include <asio/unyield.hpp>
-
-int main()
-{
-  asio::io_context ctx{1};
-  stdin_line_reader reader{ctx.get_executor()};
-  read_loop(ctx.get_executor(), reader)();
-  ctx.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.cpp
deleted file mode 100644
index b605866..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// sleep.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "sleep.hpp"
-#include <asio/consign.hpp>
-#include <asio/steady_timer.hpp>
-#include <memory>
-
-void async_sleep_impl(
-    asio::any_completion_handler<void(std::error_code)> handler,
-    asio::any_io_executor ex, std::chrono::nanoseconds duration)
-{
-  auto timer = std::make_shared<asio::steady_timer>(ex, duration);
-  timer->async_wait(asio::consign(std::move(handler), timer));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.hpp
deleted file mode 100644
index 299397a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/sleep.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// sleep.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SLEEP_HPP
-#define SLEEP_HPP
-
-#include <asio/any_completion_handler.hpp>
-#include <asio/any_io_executor.hpp>
-#include <asio/async_result.hpp>
-#include <asio/error.hpp>
-#include <chrono>
-
-void async_sleep_impl(
-    asio::any_completion_handler<void(std::error_code)> handler,
-    asio::any_io_executor ex, std::chrono::nanoseconds duration);
-
-template <typename CompletionToken>
-inline auto async_sleep(asio::any_io_executor ex,
-    std::chrono::nanoseconds duration, CompletionToken&& token)
-  -> decltype(
-      asio::async_initiate<CompletionToken, void(std::error_code)>(
-        async_sleep_impl, token, std::move(ex), duration))
-{
-  return asio::async_initiate<CompletionToken, void(std::error_code)>(
-      async_sleep_impl, token, std::move(ex), duration);
-}
-
-#endif // SLEEP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.cpp
deleted file mode 100644
index d2e25e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// stdin_line_reader.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "stdin_line_reader.hpp"
-#include <asio/deferred.hpp>
-#include <asio/read_until.hpp>
-#include <iostream>
-
-stdin_line_reader::stdin_line_reader(asio::any_io_executor ex)
-  : stdin_(ex, ::dup(STDIN_FILENO))
-{
-}
-
-void stdin_line_reader::async_read_line_impl(std::string prompt,
-    asio::any_completion_handler<void(std::error_code, std::string)> handler)
-{
-  std::cout << prompt;
-  std::cout.flush();
-
-  asio::async_read_until(stdin_, asio::dynamic_buffer(buffer_), '\n',
-      asio::deferred(
-        [this](std::error_code ec, std::size_t n)
-        {
-          if (!ec)
-          {
-            std::string result = buffer_.substr(0, n);
-            buffer_.erase(0, n);
-            return asio::deferred.values(ec, std::move(result));
-          }
-          else
-          {
-            return asio::deferred.values(ec, std::string{});
-          }
-        }
-      )
-    )(std::move(handler));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.hpp
deleted file mode 100644
index 43e6742..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/type_erasure/stdin_line_reader.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// stdin_line_reader.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef STDIN_LINE_READER_HPP
-#define STDIN_LINE_READER_HPP
-
-#include "line_reader.hpp"
-#include <asio/posix/stream_descriptor.hpp>
-
-class stdin_line_reader : public line_reader
-{
-public:
-  explicit stdin_line_reader(asio::any_io_executor ex);
-
-private:
-  void async_read_line_impl(std::string prompt,
-      asio::any_completion_handler<void(std::error_code, std::string)> handler) override;
-
-  asio::posix::stream_descriptor stdin_;
-  std::string buffer_;
-};
-
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/.gitignore
deleted file mode 100644
index 180ba88..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/transmit_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/transmit_file.cpp
deleted file mode 100644
index 0ffd048..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp11/windows/transmit_file.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-//
-// transmit_file.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <ctime>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <string>
-#include "asio.hpp"
-
-#if defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-
-using asio::ip::tcp;
-using asio::windows::overlapped_ptr;
-using asio::windows::random_access_handle;
-
-typedef asio::basic_stream_socket<tcp,
-    asio::io_context::executor_type> tcp_socket;
-
-typedef asio::basic_socket_acceptor<tcp,
-    asio::io_context::executor_type> tcp_acceptor;
-
-// A wrapper for the TransmitFile overlapped I/O operation.
-template <typename Handler>
-void transmit_file(tcp_socket& socket,
-    random_access_handle& file, Handler handler)
-{
-  // Construct an OVERLAPPED-derived object to contain the handler.
-  overlapped_ptr overlapped(socket.get_executor().context(), handler);
-
-  // Initiate the TransmitFile operation.
-  BOOL ok = ::TransmitFile(socket.native_handle(),
-      file.native_handle(), 0, 0, overlapped.get(), 0, 0);
-  DWORD last_error = ::GetLastError();
-
-  // Check if the operation completed immediately.
-  if (!ok && last_error != ERROR_IO_PENDING)
-  {
-    // The operation completed immediately, so a completion notification needs
-    // to be posted. When complete() is called, ownership of the OVERLAPPED-
-    // derived object passes to the io_context.
-    std::error_code ec(last_error,
-        asio::error::get_system_category());
-    overlapped.complete(ec, 0);
-  }
-  else
-  {
-    // The operation was successfully initiated, so ownership of the
-    // OVERLAPPED-derived object has passed to the io_context.
-    overlapped.release();
-  }
-}
-
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  typedef std::shared_ptr<connection> pointer;
-
-  static pointer create(asio::io_context& io_context,
-      const std::string& filename)
-  {
-    return pointer(new connection(io_context, filename));
-  }
-
-  tcp_socket& socket()
-  {
-    return socket_;
-  }
-
-  void start()
-  {
-    std::error_code ec;
-    file_.assign(::CreateFile(filename_.c_str(), GENERIC_READ, 0, 0,
-          OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0), ec);
-    if (file_.is_open())
-    {
-      transmit_file(socket_, file_,
-          std::bind(&connection::handle_write, shared_from_this(),
-            asio::placeholders::error,
-            asio::placeholders::bytes_transferred));
-    }
-  }
-
-private:
-  connection(asio::io_context& io_context, const std::string& filename)
-    : socket_(io_context),
-      filename_(filename),
-      file_(io_context)
-  {
-  }
-
-  void handle_write(const std::error_code& /*error*/,
-      size_t /*bytes_transferred*/)
-  {
-    std::error_code ignored_ec;
-    socket_.shutdown(tcp_socket::shutdown_both, ignored_ec);
-  }
-
-  tcp_socket socket_;
-  std::string filename_;
-  random_access_handle file_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context,
-      unsigned short port, const std::string& filename)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)),
-      filename_(filename)
-  {
-    start_accept();
-  }
-
-private:
-  void start_accept()
-  {
-    connection::pointer new_connection =
-      connection::create(acceptor_.get_executor().context(), filename_);
-
-    acceptor_.async_accept(new_connection->socket(),
-        std::bind(&server::handle_accept, this, new_connection,
-          asio::placeholders::error));
-  }
-
-  void handle_accept(connection::pointer new_connection,
-      const std::error_code& error)
-  {
-    if (!error)
-    {
-      new_connection->start();
-    }
-
-    start_accept();
-  }
-
-  tcp_acceptor acceptor_;
-  std::string filename_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: transmit_file <port> <filename>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    using namespace std; // For atoi.
-    server s(io_context, atoi(argv[1]), argv[2]);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << e.what() << std::endl;
-  }
-
-  return 0;
-}
-
-#else // defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-# error Overlapped I/O not available on this platform
-#endif // defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/Makefile.am
deleted file mode 100644
index 2ddf12a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/Makefile.am
+++ /dev/null
@@ -1,95 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-if SEPARATE_COMPILATION
-noinst_LIBRARIES = libasio.a
-libasio_a_SOURCES = ../../asio.cpp
-if HAVE_OPENSSL
-libasio_a_SOURCES += ../../asio_ssl.cpp
-endif
-LDADD = libasio.a
-endif
-
-noinst_PROGRAMS = \
-	deferred/deferred_1 \
-	deferred/deferred_2 \
-	deferred/deferred_3 \
-	deferred/deferred_4 \
-	deferred/deferred_5 \
-	deferred/deferred_6 \
-	deferred/deferred_7 \
-	echo/async_tcp_echo_server \
-	echo/async_udp_echo_server \
-	echo/blocking_tcp_echo_client \
-	echo/blocking_tcp_echo_server \
-	echo/blocking_udp_echo_client \
-	echo/blocking_udp_echo_server \
-	executors/actor \
-	executors/async_1 \
-	executors/async_2 \
-	executors/bank_account_1 \
-	executors/bank_account_2 \
-	executors/fork_join \
-	executors/pipeline \
-	executors/priority_scheduler \
-	iostreams/http_client \
-	operations/c_callback_wrapper \
-	operations/callback_wrapper \
-	operations/composed_1 \
-	operations/composed_1 \
-	operations/composed_2 \
-	operations/composed_3 \
-	operations/composed_4 \
-	operations/composed_5 \
-	operations/composed_6 \
-	operations/composed_7 \
-	operations/composed_8 \
-  parallel_group/parallel_sort \
-  parallel_group/ranged_wait_for_all \
-  parallel_group/wait_for_all \
-  parallel_group/wait_for_one \
-  parallel_group/wait_for_one_error \
-  parallel_group/wait_for_one_success
-
-AM_CXXFLAGS = -I$(srcdir)/../../../include
-
-deferred_deferred_1_SOURCES = deferred/deferred_1.cpp
-deferred_deferred_2_SOURCES = deferred/deferred_2.cpp
-deferred_deferred_3_SOURCES = deferred/deferred_3.cpp
-deferred_deferred_4_SOURCES = deferred/deferred_4.cpp
-deferred_deferred_5_SOURCES = deferred/deferred_5.cpp
-deferred_deferred_6_SOURCES = deferred/deferred_6.cpp
-deferred_deferred_7_SOURCES = deferred/deferred_7.cpp
-echo_async_tcp_echo_server_SOURCES = echo/async_tcp_echo_server.cpp
-echo_async_udp_echo_server_SOURCES = echo/async_udp_echo_server.cpp
-echo_blocking_tcp_echo_client_SOURCES = echo/blocking_tcp_echo_client.cpp
-echo_blocking_tcp_echo_server_SOURCES = echo/blocking_tcp_echo_server.cpp
-echo_blocking_udp_echo_client_SOURCES = echo/blocking_udp_echo_client.cpp
-echo_blocking_udp_echo_server_SOURCES = echo/blocking_udp_echo_server.cpp
-executors_actor_SOURCES = executors/actor.cpp
-executors_async_1_SOURCES = executors/async_1.cpp
-executors_async_2_SOURCES = executors/async_2.cpp
-executors_bank_account_1_SOURCES = executors/bank_account_1.cpp
-executors_bank_account_2_SOURCES = executors/bank_account_2.cpp
-executors_fork_join_SOURCES = executors/fork_join.cpp
-executors_pipeline_SOURCES = executors/pipeline.cpp
-executors_priority_scheduler_SOURCES = executors/priority_scheduler.cpp
-iostreams_http_client_SOURCES = iostreams/http_client.cpp
-operations_c_callback_wrapper_SOURCES = operations/c_callback_wrapper.cpp
-operations_callback_wrapper_SOURCES = operations/callback_wrapper.cpp
-operations_composed_1_SOURCES = operations/composed_1.cpp
-operations_composed_2_SOURCES = operations/composed_2.cpp
-operations_composed_3_SOURCES = operations/composed_3.cpp
-operations_composed_4_SOURCES = operations/composed_4.cpp
-operations_composed_5_SOURCES = operations/composed_5.cpp
-operations_composed_6_SOURCES = operations/composed_6.cpp
-operations_composed_7_SOURCES = operations/composed_7.cpp
-operations_composed_8_SOURCES = operations/composed_8.cpp
-parallel_group_parallel_sort_SOURCES = parallel_group/parallel_sort.cpp
-parallel_group_ranged_wait_for_all_SOURCES = parallel_group/ranged_wait_for_all.cpp
-parallel_group_wait_for_all_SOURCES = parallel_group/wait_for_all.cpp
-parallel_group_wait_for_one_SOURCES = parallel_group/wait_for_one.cpp
-parallel_group_wait_for_one_error_SOURCES = parallel_group/wait_for_one_error.cpp
-parallel_group_wait_for_one_success_SOURCES = parallel_group/wait_for_one_success.cpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/.gitignore
deleted file mode 100644
index 02ac0d2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-deferred_[0-9]
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_1.cpp
deleted file mode 100644
index db9213e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_1.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// deferred_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  auto deferred_op = timer.async_wait(deferred);
-
-  std::move(deferred_op)(
-      [](std::error_code ec)
-      {
-        std::cout << "timer wait finished: " << ec.message() << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_2.cpp
deleted file mode 100644
index 0752828..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_2.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// deferred_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  auto deferred_op = timer.async_wait(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer.expires_after(std::chrono::seconds(1));
-          return timer.async_wait(deferred);
-        }
-      )
-    );
-
-  std::move(deferred_op)(
-      [](std::error_code ec)
-      {
-        std::cout << "second timer wait finished: " << ec.message() << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_3.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_3.cpp
deleted file mode 100644
index 396e408..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_3.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// deferred_3.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-template <typename CompletionToken>
-auto async_wait_twice(asio::steady_timer& timer, CompletionToken&& token)
-{
-  return timer.async_wait(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer.expires_after(std::chrono::seconds(1));
-          return timer.async_wait(deferred);
-        }
-      )
-    )(
-      std::forward<CompletionToken>(token)
-    );
-}
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  async_wait_twice(
-      timer,
-      [](std::error_code ec)
-      {
-        std::cout << "second timer wait finished: " << ec.message() << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_4.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_4.cpp
deleted file mode 100644
index a8ea733..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_4.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// deferred_4.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-template <typename CompletionToken>
-auto async_wait_twice(asio::steady_timer& timer, CompletionToken&& token)
-{
-  return timer.async_wait(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer.expires_after(std::chrono::seconds(1));
-          return timer.async_wait(deferred);
-        }
-      )
-    )(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "second timer wait finished: " << ec.message() << "\n";
-          return deferred.values(42);
-        }
-      )
-    )(
-      std::forward<CompletionToken>(token)
-    );
-}
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  async_wait_twice(
-      timer,
-      [](int result)
-      {
-        std::cout << "result is " << result << "\n";
-      }
-    );
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_5.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_5.cpp
deleted file mode 100644
index d262b97..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_5.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// deferred_5.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::deferred;
-
-template <typename CompletionToken>
-auto async_wait_twice(asio::steady_timer& timer, CompletionToken&& token)
-{
-  return timer.async_wait(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer.expires_after(std::chrono::seconds(1));
-          return deferred.when(!ec)
-            .then(timer.async_wait(deferred))
-            .otherwise(deferred.values(ec));
-        }
-      )
-    )(
-      deferred(
-        [&](std::error_code ec)
-        {
-          std::cout << "second timer wait finished: " << ec.message() << "\n";
-          return deferred.when(!ec)
-            .then(deferred.values(42))
-            .otherwise(deferred.values(0));
-        }
-      )
-    )(
-      std::forward<CompletionToken>(token)
-    );
-}
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  async_wait_twice(
-      timer,
-      [](int result)
-      {
-        std::cout << "result is " << result << "\n";
-      }
-    );
-
-  // Uncomment the following line to trigger an error in async_wait_twice.
-  //timer.cancel();
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_6.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_6.cpp
deleted file mode 100644
index 7ccef58..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_6.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-//
-// deferred_6.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::append;
-using asio::deferred;
-
-template <typename CompletionToken>
-auto async_wait_twice(asio::steady_timer& timer, CompletionToken&& token)
-{
-  return deferred.values(&timer)(
-      deferred(
-        [](asio::steady_timer* timer)
-        {
-          timer->expires_after(std::chrono::seconds(1));
-          return timer->async_wait(append(deferred, timer));
-        }
-      )
-    )(
-      deferred(
-        [](std::error_code ec, asio::steady_timer* timer)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer->expires_after(std::chrono::seconds(1));
-          return deferred.when(!ec)
-            .then(timer->async_wait(deferred))
-            .otherwise(deferred.values(ec));
-        }
-      )
-    )(
-      deferred(
-        [](std::error_code ec)
-        {
-          std::cout << "second timer wait finished: " << ec.message() << "\n";
-          return deferred.when(!ec)
-            .then(deferred.values(42))
-            .otherwise(deferred.values(0));
-        }
-      )
-    )(
-      std::forward<CompletionToken>(token)
-    );
-}
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  async_wait_twice(
-      timer,
-      [](int result)
-      {
-        std::cout << "result is " << result << "\n";
-      }
-    );
-
-  // Uncomment the following line to trigger an error in async_wait_twice.
-  //timer.cancel();
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_7.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_7.cpp
deleted file mode 100644
index b073454..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/deferred/deferred_7.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// deferred_7.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-using asio::append;
-using asio::deferred;
-
-template <typename CompletionToken>
-auto async_wait_twice(asio::steady_timer& timer, CompletionToken&& token)
-{
-  return deferred.values(&timer)
-    | deferred(
-        [](asio::steady_timer* timer)
-        {
-          timer->expires_after(std::chrono::seconds(1));
-          return timer->async_wait(append(deferred, timer));
-        }
-      )
-    | deferred(
-        [](std::error_code ec, asio::steady_timer* timer)
-        {
-          std::cout << "first timer wait finished: " << ec.message() << "\n";
-          timer->expires_after(std::chrono::seconds(1));
-          return deferred.when(!ec)
-            .then(timer->async_wait(deferred))
-            .otherwise(deferred.values(ec));
-        }
-      )
-    | deferred(
-        [](std::error_code ec)
-        {
-          std::cout << "second timer wait finished: " << ec.message() << "\n";
-          return deferred.when(!ec)
-            .then(deferred.values(42))
-            .otherwise(deferred.values(0));
-        }
-      )
-    | std::forward<CompletionToken>(token);
-}
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::steady_timer timer(ctx);
-  timer.expires_after(std::chrono::seconds(1));
-
-  async_wait_twice(
-      timer,
-      [](int result)
-      {
-        std::cout << "result is " << result << "\n";
-      }
-    );
-
-  // Uncomment the following line to trigger an error in async_wait_twice.
-  //timer.cancel();
-
-  ctx.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/.gitignore
deleted file mode 100644
index 0882fa6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_server
-*_client
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_tcp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_tcp_echo_server.cpp
deleted file mode 100644
index 9bd1b72..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_tcp_echo_server.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// async_tcp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <memory>
-#include <utility>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::tcp;
-
-class session
-  : public std::enable_shared_from_this<session>
-{
-public:
-  session(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    do_read();
-  }
-
-private:
-  void do_read()
-  {
-    auto self(shared_from_this());
-    socket_.async_read_some(asio::buffer(data_, max_length),
-        [this, self](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            do_write(length);
-          }
-        });
-  }
-
-  void do_write(std::size_t length)
-  {
-    auto self(shared_from_this());
-    asio::async_write(socket_, asio::buffer(data_, length),
-        [this, self](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec)
-          {
-            do_read();
-          }
-        });
-  }
-
-  tcp::socket socket_;
-  enum { max_length = 1024 };
-  char data_[max_length];
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)),
-      socket_(io_context)
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(socket_,
-        [this](std::error_code ec)
-        {
-          if (!ec)
-          {
-            std::make_shared<session>(std::move(socket_))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-  tcp::socket socket_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: async_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_udp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_udp_echo_server.cpp
deleted file mode 100644
index b059af9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/async_udp_echo_server.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// async_udp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::udp;
-
-class server
-{
-public:
-  server(asio::io_context& io_context, short port)
-    : socket_(io_context, udp::endpoint(udp::v4(), port))
-  {
-    do_receive();
-  }
-
-  void do_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(data_, max_length), sender_endpoint_,
-        [this](std::error_code ec, std::size_t bytes_recvd)
-        {
-          if (!ec && bytes_recvd > 0)
-          {
-            do_send(bytes_recvd);
-          }
-          else
-          {
-            do_receive();
-          }
-        });
-  }
-
-  void do_send(std::size_t length)
-  {
-    socket_.async_send_to(
-        asio::buffer(data_, length), sender_endpoint_,
-        [this](std::error_code /*ec*/, std::size_t /*bytes_sent*/)
-        {
-          do_receive();
-        });
-  }
-
-private:
-  udp::socket socket_;
-  udp::endpoint sender_endpoint_;
-  enum { max_length = 1024 };
-  char data_[max_length];
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: async_udp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_client.cpp
deleted file mode 100644
index 8a28120..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_client.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// blocking_tcp_echo_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include "asio.hpp"
-
-using asio::ip::tcp;
-
-enum { max_length = 1024 };
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_tcp_echo_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    tcp::socket s(io_context);
-    tcp::resolver resolver(io_context);
-    asio::connect(s, resolver.resolve(argv[1], argv[2]));
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    asio::write(s, asio::buffer(request, request_length));
-
-    char reply[max_length];
-    size_t reply_length = asio::read(s,
-        asio::buffer(reply, request_length));
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_server.cpp
deleted file mode 100644
index 2116712..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_server.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// blocking_tcp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <thread>
-#include <utility>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::tcp;
-
-const int max_length = 1024;
-
-void session(tcp::socket sock)
-{
-  try
-  {
-    for (;;)
-    {
-      char data[max_length];
-
-      std::error_code error;
-      size_t length = sock.read_some(asio::buffer(data), error);
-      if (error == asio::stream_errc::eof)
-        break; // Connection closed cleanly by peer.
-      else if (error)
-        throw std::system_error(error); // Some other error.
-
-      asio::write(sock, asio::buffer(data, length));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception in thread: " << e.what() << "\n";
-  }
-}
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  tcp::acceptor a(io_context, tcp::endpoint(tcp::v4(), port));
-  for (;;)
-  {
-    tcp::socket sock(io_context);
-    a.accept(sock);
-    std::thread(session, std::move(sock)).detach();
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_client.cpp
deleted file mode 100644
index 4c8a284..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_client.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// blocking_udp_echo_client.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_udp_echo_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    udp::socket s(io_context, udp::endpoint(udp::v4(), 0));
-
-    udp::resolver resolver(io_context);
-    udp::endpoint endpoint =
-      *resolver.resolve(udp::v4(), argv[1], argv[2]).begin();
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    s.send_to(asio::buffer(request, request_length), endpoint);
-
-    char reply[max_length];
-    udp::endpoint sender_endpoint;
-    size_t reply_length = s.receive_from(
-        asio::buffer(reply, max_length), sender_endpoint);
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_server.cpp
deleted file mode 100644
index c3098bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_server.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// blocking_udp_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <iostream>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  udp::socket sock(io_context, udp::endpoint(udp::v4(), port));
-  for (;;)
-  {
-    char data[max_length];
-    udp::endpoint sender_endpoint;
-    size_t length = sock.receive_from(
-        asio::buffer(data, max_length), sender_endpoint);
-    sock.send_to(asio::buffer(data, length), sender_endpoint);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_udp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/.gitignore
deleted file mode 100644
index d51d7f0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-actor
-async_[0-9]
-bank_account_[0-9]
-fork_join
-pipeline
-priority_scheduler
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/actor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/actor.cpp
deleted file mode 100644
index a46caf4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/actor.cpp
+++ /dev/null
@@ -1,285 +0,0 @@
-#include <asio/any_io_executor.hpp>
-#include <asio/defer.hpp>
-#include <asio/post.hpp>
-#include <asio/strand.hpp>
-#include <asio/system_executor.hpp>
-#include <condition_variable>
-#include <deque>
-#include <memory>
-#include <mutex>
-#include <typeinfo>
-#include <vector>
-
-using asio::any_io_executor;
-using asio::defer;
-using asio::post;
-using asio::strand;
-using asio::system_executor;
-
-//------------------------------------------------------------------------------
-// A tiny actor framework
-// ~~~~~~~~~~~~~~~~~~~~~~
-
-class actor;
-
-// Used to identify the sender and recipient of messages.
-typedef actor* actor_address;
-
-// Base class for all registered message handlers.
-class message_handler_base
-{
-public:
-  virtual ~message_handler_base() {}
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const = 0;
-};
-
-// Base class for a handler for a specific message type.
-template <class Message>
-class message_handler : public message_handler_base
-{
-public:
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from) = 0;
-};
-
-// Concrete message handler for a specific message type.
-template <class Actor, class Message>
-class mf_message_handler : public message_handler<Message>
-{
-public:
-  // Construct a message handler to invoke the specified member function.
-  mf_message_handler(void (Actor::* mf)(Message, actor_address), Actor* a)
-    : function_(mf), actor_(a)
-  {
-  }
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const
-  {
-    return typeid(Message);
-  }
-
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from)
-  {
-    (actor_->*function_)(std::move(msg), from);
-  }
-
-  // Determine whether the message handler represents the specified function.
-  bool is_function(void (Actor::* mf)(Message, actor_address)) const
-  {
-    return mf == function_;
-  }
-
-private:
-  void (Actor::* function_)(Message, actor_address);
-  Actor* actor_;
-};
-
-// Base class for all actors.
-class actor
-{
-public:
-  virtual ~actor()
-  {
-  }
-
-  // Obtain the actor's address for use as a message sender or recipient.
-  actor_address address()
-  {
-    return this;
-  }
-
-  // Send a message from one actor to another.
-  template <class Message>
-  friend void send(Message msg, actor_address from, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    post(to->executor_,
-      [=, msg=std::move(msg)]() mutable
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-protected:
-  // Construct the actor to use the specified executor for all message handlers.
-  actor(any_io_executor e)
-    : executor_(std::move(e))
-  {
-  }
-
-  // Register a handler for a specific message type. Duplicates are permitted.
-  template <class Actor, class Message>
-  void register_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    handlers_.push_back(
-      std::make_shared<mf_message_handler<Actor, Message>>(
-        mf, static_cast<Actor*>(this)));
-  }
-
-  // Deregister a handler. Removes only the first matching handler.
-  template <class Actor, class Message>
-  void deregister_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    const std::type_info& id = typeid(Message);
-    for (auto iter = handlers_.begin(); iter != handlers_.end(); ++iter)
-    {
-      if ((*iter)->message_id() == id)
-      {
-        auto mh = static_cast<mf_message_handler<Actor, Message>*>(iter->get());
-        if (mh->is_function(mf))
-        {
-          handlers_.erase(iter);
-          return;
-        }
-      }
-    }
-  }
-
-  // Send a message from within a message handler.
-  template <class Message>
-  void tail_send(Message msg, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    defer(to->executor_,
-      [=, msg=std::move(msg), from=this]
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-private:
-  // Find the matching message handlers, if any, and call them.
-  template <class Message>
-  void call_handler(Message msg, actor_address from)
-  {
-    const std::type_info& message_id = typeid(Message);
-    for (auto& h: handlers_)
-    {
-      if (h->message_id() == message_id)
-      {
-        auto mh = static_cast<message_handler<Message>*>(h.get());
-        mh->handle_message(msg, from);
-      }
-    }
-  }
-
-  // All messages associated with a single actor object should be processed
-  // non-concurrently. We use a strand to ensure non-concurrent execution even
-  // if the underlying executor may use multiple threads.
-  strand<any_io_executor> executor_;
-
-  std::vector<std::shared_ptr<message_handler_base>> handlers_;
-};
-
-// A concrete actor that allows synchronous message retrieval.
-template <class Message>
-class receiver : public actor
-{
-public:
-  receiver()
-    : actor(system_executor())
-  {
-    register_handler(&receiver::message_handler);
-  }
-
-  // Block until a message has been received.
-  Message wait()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    condition_.wait(lock, [this]{ return !message_queue_.empty(); });
-    Message msg(std::move(message_queue_.front()));
-    message_queue_.pop_front();
-    return msg;
-  }
-
-private:
-  // Handle a new message by adding it to the queue and waking a waiter.
-  void message_handler(Message msg, actor_address /* from */)
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    message_queue_.push_back(std::move(msg));
-    condition_.notify_one();
-  }
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::deque<Message> message_queue_;
-};
-
-//------------------------------------------------------------------------------
-
-#include <asio/thread_pool.hpp>
-#include <iostream>
-
-using asio::thread_pool;
-
-class member : public actor
-{
-public:
-  explicit member(any_io_executor e)
-    : actor(std::move(e))
-  {
-    register_handler(&member::init_handler);
-  }
-
-private:
-  void init_handler(actor_address next, actor_address from)
-  {
-    next_ = next;
-    caller_ = from;
-
-    register_handler(&member::token_handler);
-    deregister_handler(&member::init_handler);
-  }
-
-  void token_handler(int token, actor_address /*from*/)
-  {
-    int msg(token);
-    actor_address to(caller_);
-
-    if (token > 0)
-    {
-      msg = token - 1;
-      to = next_;
-    }
-
-    tail_send(msg, to);
-  }
-
-  actor_address next_;
-  actor_address caller_;
-};
-
-int main()
-{
-  const std::size_t num_threads = 16;
-  const int num_hops = 50000000;
-  const std::size_t num_actors = 503;
-  const int token_value = (num_hops + num_actors - 1) / num_actors;
-  const std::size_t actors_per_thread = num_actors / num_threads;
-
-  struct single_thread_pool : thread_pool { single_thread_pool() : thread_pool(1) {} };
-  single_thread_pool pools[num_threads];
-  std::vector<std::shared_ptr<member>> members(num_actors);
-  receiver<int> rcvr;
-
-  // Create the member actors.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    members[i] = std::make_shared<member>(pools[(i / actors_per_thread) % num_threads].get_executor());
-
-  // Initialise the actors by passing each one the address of the next actor in the ring.
-  for (std::size_t i = num_actors, next_i = 0; i > 0; next_i = --i)
-    send(members[next_i]->address(), rcvr.address(), members[i - 1]->address());
-
-  // Send exactly one token to each actor, all with the same initial value, rounding up if required.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    send(token_value, rcvr.address(), members[i]->address());
-
-  // Wait for all signal messages, indicating the tokens have all reached zero.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    rcvr.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_1.cpp
deleted file mode 100644
index 0d1bdfc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_1.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <asio/associated_executor.hpp>
-#include <asio/bind_executor.hpp>
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-#include <string>
-
-using asio::bind_executor;
-using asio::get_associated_executor;
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// A function to asynchronously read a single line from an input stream.
-template <class IoExecutor, class Handler>
-void async_getline(IoExecutor io_ex, std::istream& is, Handler handler)
-{
-  // Track work for the handler's associated executor.
-  auto work_ex = asio::prefer(
-      get_associated_executor(handler, io_ex),
-      execution::outstanding_work.tracked);
-
-  // Post a function object to do the work asynchronously.
-  asio::require(io_ex, execution::blocking.never).execute(
-      [&is, work_ex, handler=std::move(handler)]() mutable
-      {
-        std::string line;
-        std::getline(is, line);
-
-        // Pass the result to the handler, via the associated executor.
-        asio::prefer(work_ex, execution::blocking.possibly).execute(
-            [line=std::move(line), handler=std::move(handler)]() mutable
-            {
-              handler(std::move(line));
-            });
-      });
-}
-
-int main()
-{
-  static_thread_pool io_pool(1);
-  static_thread_pool completion_pool(1);
-
-  std::cout << "Enter a line: ";
-
-  async_getline(io_pool.executor(), std::cin,
-      bind_executor(completion_pool.executor(),
-        [](std::string line)
-        {
-          std::cout << "Line: " << line << "\n";
-        }));
-
-  io_pool.wait();
-  completion_pool.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_2.cpp
deleted file mode 100644
index ee4a72e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/async_2.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include <asio/associated_executor.hpp>
-#include <asio/bind_executor.hpp>
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-#include <string>
-
-using asio::bind_executor;
-using asio::get_associated_executor;
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// A function to asynchronously read a single line from an input stream.
-template <class IoExecutor, class Handler>
-void async_getline(IoExecutor io_ex, std::istream& is, Handler handler)
-{
-  // Track work for the handler's associated executor.
-  auto work_ex = asio::prefer(
-      get_associated_executor(handler, io_ex),
-      execution::outstanding_work.tracked);
-
-  // Post a function object to do the work asynchronously.
-  asio::require(io_ex, execution::blocking.never).execute(
-      [&is, work_ex, handler=std::move(handler)]() mutable
-      {
-        std::string line;
-        std::getline(is, line);
-
-        // Pass the result to the handler, via the associated executor.
-        asio::prefer(work_ex, execution::blocking.possibly).execute(
-            [line=std::move(line), handler=std::move(handler)]() mutable
-            {
-              handler(std::move(line));
-            });
-      });
-}
-
-// A function to asynchronously read multiple lines from an input stream.
-template <class IoExecutor, class Handler>
-void async_getlines(IoExecutor io_ex, std::istream& is, std::string init, Handler handler)
-{
-  // Track work for the I/O executor.
-  auto io_work_ex = asio::prefer(io_ex,
-      execution::outstanding_work.tracked);
-
-  // Track work for the handler's associated executor.
-  auto handler_work_ex = asio::prefer(
-      get_associated_executor(handler, io_ex),
-      execution::outstanding_work.tracked);
-
-  // Use the associated executor for each operation in the composition.
-  async_getline(io_work_ex, is,
-      bind_executor(handler_work_ex,
-        [io_work_ex, &is, lines=std::move(init), handler=std::move(handler)]
-        (std::string line) mutable
-        {
-          if (line.empty())
-            handler(lines);
-          else
-            async_getlines(io_work_ex, is, lines + line + "\n", std::move(handler));
-        }));
-}
-
-int main()
-{
-  static_thread_pool io_pool(1);
-  static_thread_pool completion_pool(1);
-
-  std::cout << "Enter text, terminating with a blank line:\n";
-
-  async_getlines(io_pool.executor(), std::cin, "",
-      bind_executor(completion_pool.executor(), [](std::string lines)
-        {
-          std::cout << "Lines:\n" << lines << "\n";
-        }));
-
-  io_pool.wait();
-  completion_pool.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_1.cpp
deleted file mode 100644
index a63d7fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_1.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// Traditional active object pattern.
-// Member functions do not block.
-
-class bank_account
-{
-  int balance_ = 0;
-  mutable static_thread_pool pool_{1};
-
-public:
-  void deposit(int amount)
-  {
-    pool_.executor().execute(
-        [this, amount]
-        {
-          balance_ += amount;
-        });
-  }
-
-  void withdraw(int amount)
-  {
-    pool_.executor().execute(
-        [this, amount]
-        {
-          if (balance_ >= amount)
-            balance_ -= amount;
-        });
-  }
-
-  void print_balance() const
-  {
-    pool_.executor().execute(
-        [this]
-        {
-          std::cout << "balance = " << balance_ << "\n";
-        });
-  }
-
-  ~bank_account()
-  {
-    pool_.wait();
-  }
-};
-
-int main()
-{
-  bank_account acct;
-  acct.deposit(20);
-  acct.withdraw(10);
-  acct.print_balance();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_2.cpp
deleted file mode 100644
index c2de051..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/bank_account_2.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// Traditional active object pattern.
-// Member functions block until operation is finished.
-
-class bank_account
-{
-  int balance_ = 0;
-  mutable static_thread_pool pool_{1};
-
-public:
-  void deposit(int amount)
-  {
-    asio::require(pool_.executor(), execution::blocking.always).execute(
-        [this, amount]
-        {
-          balance_ += amount;
-        });
-  }
-
-  void withdraw(int amount)
-  {
-    asio::require(pool_.executor(),
-      execution::blocking.always).execute(
-        [this, amount]
-        {
-          if (balance_ >= amount)
-            balance_ -= amount;
-        });
-  }
-
-  int balance() const
-  {
-    int result = 0;
-    asio::require(pool_.executor(), execution::blocking.always).execute(
-        [this, &result]
-        {
-          result = balance_;
-        });
-    return result;
-  }
-};
-
-int main()
-{
-  bank_account acct;
-  acct.deposit(20);
-  acct.withdraw(10);
-  std::cout << "balance = " << acct.balance() << "\n";
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/fork_join.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/fork_join.cpp
deleted file mode 100644
index 58077ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/fork_join.cpp
+++ /dev/null
@@ -1,289 +0,0 @@
-#include <asio/execution.hpp>
-#include <asio/static_thread_pool.hpp>
-#include <algorithm>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <numeric>
-
-using asio::static_thread_pool;
-namespace execution = asio::execution;
-
-// A fixed-size thread pool used to implement fork/join semantics. Functions
-// are scheduled using a simple FIFO queue. Implementing work stealing, or
-// using a queue based on atomic operations, are left as tasks for the reader.
-class fork_join_pool
-{
-public:
-  // The constructor starts a thread pool with the specified number of threads.
-  // Note that the thread_count is not a fixed limit on the pool's concurrency.
-  // Additional threads may temporarily be added to the pool if they join a
-  // fork_executor.
-  explicit fork_join_pool(
-      std::size_t thread_count = std::max(std::thread::hardware_concurrency(), 1u) * 2)
-    : use_count_(1),
-      threads_(thread_count)
-  {
-    try
-    {
-      // Ask each thread in the pool to dequeue and execute functions until
-      // it is time to shut down, i.e. the use count is zero.
-      for (thread_count_ = 0; thread_count_ < thread_count; ++thread_count_)
-      {
-        threads_.executor().execute(
-            [this]
-            {
-              std::unique_lock<std::mutex> lock(mutex_);
-              while (use_count_ > 0)
-                if (!execute_next(lock))
-                  condition_.wait(lock);
-            });
-      }
-    }
-    catch (...)
-    {
-      stop_threads();
-      threads_.wait();
-      throw;
-    }
-  }
-
-  // The destructor waits for the pool to finish executing functions.
-  ~fork_join_pool()
-  {
-    stop_threads();
-    threads_.wait();
-  }
-
-private:
-  friend class fork_executor;
-
-  // The base for all functions that are queued in the pool.
-  struct function_base
-  {
-    std::shared_ptr<std::size_t> work_count_;
-    void (*execute_)(std::shared_ptr<function_base>& p);
-  };
-
-  // Execute the next function from the queue, if any. Returns true if a
-  // function was executed, and false if the queue was empty.
-  bool execute_next(std::unique_lock<std::mutex>& lock)
-  {
-    if (queue_.empty())
-      return false;
-    auto p(queue_.front());
-    queue_.pop();
-    lock.unlock();
-    execute(lock, p);
-    return true;
-  }
-
-  // Execute a function and decrement the outstanding work.
-  void execute(std::unique_lock<std::mutex>& lock,
-      std::shared_ptr<function_base>& p)
-  {
-    std::shared_ptr<std::size_t> work_count(std::move(p->work_count_));
-    try
-    {
-      p->execute_(p);
-      lock.lock();
-      do_work_finished(work_count);
-    }
-    catch (...)
-    {
-      lock.lock();
-      do_work_finished(work_count);
-      throw;
-    }
-  }
-
-  // Increment outstanding work.
-  void do_work_started(const std::shared_ptr<std::size_t>& work_count) noexcept
-  {
-    if (++(*work_count) == 1)
-      ++use_count_;
-  }
-
-  // Decrement outstanding work. Notify waiting threads if we run out.
-  void do_work_finished(const std::shared_ptr<std::size_t>& work_count) noexcept
-  {
-    if (--(*work_count) == 0)
-    {
-      --use_count_;
-      condition_.notify_all();
-    }
-  }
-
-  // Dispatch a function, executing it immediately if the queue is already
-  // loaded. Otherwise adds the function to the queue and wakes a thread.
-  void do_execute(std::shared_ptr<function_base> p,
-      const std::shared_ptr<std::size_t>& work_count)
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    if (queue_.size() > thread_count_ * 16)
-    {
-      do_work_started(work_count);
-      lock.unlock();
-      execute(lock, p);
-    }
-    else
-    {
-      queue_.push(p);
-      do_work_started(work_count);
-      condition_.notify_one();
-    }
-  }
-
-  // Ask all threads to shut down.
-  void stop_threads()
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    --use_count_;
-    condition_.notify_all();
-  }
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::queue<std::shared_ptr<function_base>> queue_;
-  std::size_t use_count_;
-  std::size_t thread_count_;
-  static_thread_pool threads_;
-};
-
-// A class that satisfies the Executor requirements. Every function or piece of
-// work associated with a fork_executor is part of a single, joinable group.
-class fork_executor
-{
-public:
-  fork_executor(fork_join_pool& ctx)
-    : context_(ctx),
-      work_count_(std::make_shared<std::size_t>(0))
-  {
-  }
-
-  fork_join_pool& query(execution::context_t) const noexcept
-  {
-    return context_;
-  }
-
-  template <class Func>
-  void execute(Func f) const
-  {
-    auto p(std::make_shared<function<Func>>(std::move(f), work_count_));
-    context_.do_execute(p, work_count_);
-  }
-
-  friend bool operator==(const fork_executor& a,
-      const fork_executor& b) noexcept
-  {
-    return a.work_count_ == b.work_count_;
-  }
-
-  friend bool operator!=(const fork_executor& a,
-      const fork_executor& b) noexcept
-  {
-    return a.work_count_ != b.work_count_;
-  }
-
-  // Block until all work associated with the executor is complete. While it is
-  // waiting, the thread may be borrowed to execute functions from the queue.
-  void join() const
-  {
-    std::unique_lock<std::mutex> lock(context_.mutex_);
-    while (*work_count_ > 0)
-      if (!context_.execute_next(lock))
-        context_.condition_.wait(lock);
-  }
-
-private:
-  template <class Func>
-  struct function : fork_join_pool::function_base
-  {
-    explicit function(Func f, const std::shared_ptr<std::size_t>& w)
-      : function_(std::move(f))
-    {
-      work_count_ = w;
-      execute_ = [](std::shared_ptr<fork_join_pool::function_base>& p)
-      {
-        Func tmp(std::move(static_cast<function*>(p.get())->function_));
-        p.reset();
-        tmp();
-      };
-    }
-
-    Func function_;
-  };
-
-  fork_join_pool& context_;
-  std::shared_ptr<std::size_t> work_count_;
-};
-
-// Helper class to automatically join a fork_executor when exiting a scope.
-class join_guard
-{
-public:
-  explicit join_guard(const fork_executor& ex) : ex_(ex) {}
-  join_guard(const join_guard&) = delete;
-  join_guard(join_guard&&) = delete;
-  ~join_guard() { ex_.join(); }
-
-private:
-  fork_executor ex_;
-};
-
-//------------------------------------------------------------------------------
-
-#include <algorithm>
-#include <iostream>
-#include <random>
-#include <vector>
-
-fork_join_pool pool;
-
-template <class Iterator>
-void fork_join_sort(Iterator begin, Iterator end)
-{
-  std::size_t n = end - begin;
-  if (n > 32768)
-  {
-    {
-      fork_executor fork(pool);
-      join_guard join(fork);
-      fork.execute([=]{ fork_join_sort(begin, begin + n / 2); });
-      fork.execute([=]{ fork_join_sort(begin + n / 2, end); });
-    }
-    std::inplace_merge(begin, begin + n / 2, end);
-  }
-  else
-  {
-    std::sort(begin, end);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  if (argc != 2)
-  {
-    std::cerr << "Usage: fork_join <size>\n";
-    return 1;
-  }
-
-  std::vector<double> vec(std::atoll(argv[1]));
-  std::iota(vec.begin(), vec.end(), 0);
-
-  std::random_device rd;
-  std::mt19937 g(rd());
-  std::shuffle(vec.begin(), vec.end(), g);
-
-  std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
-
-  fork_join_sort(vec.begin(), vec.end());
-
-  std::chrono::steady_clock::duration elapsed = std::chrono::steady_clock::now() - start;
-
-  std::cout << "sort took ";
-  std::cout << std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
-  std::cout << " microseconds" << std::endl;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/pipeline.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/pipeline.cpp
deleted file mode 100644
index 9754a27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/pipeline.cpp
+++ /dev/null
@@ -1,280 +0,0 @@
-#include <asio/associated_executor.hpp>
-#include <asio/bind_executor.hpp>
-#include <asio/execution.hpp>
-#include <condition_variable>
-#include <future>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
-#include <cctype>
-
-using asio::executor_binder;
-using asio::get_associated_executor;
-namespace execution = asio::execution;
-
-// An executor that launches a new thread for each function submitted to it.
-// This class satisfies the executor requirements.
-class thread_executor
-{
-private:
-  // Singleton execution context that manages threads launched by the new_thread_executor.
-  class thread_bag
-  {
-    friend class thread_executor;
-
-    void add_thread(std::thread&& t)
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      threads_.push_back(std::move(t));
-    }
-
-    thread_bag() = default;
-
-    ~thread_bag()
-    {
-      for (auto& t : threads_)
-        t.join();
-    }
-
-    std::mutex mutex_;
-    std::vector<std::thread> threads_;
-  };
-
-public:
-  static thread_bag& query(execution::context_t)
-  {
-    static thread_bag threads;
-    return threads;
-  }
-
-  static constexpr auto query(execution::blocking_t)
-  {
-    return execution::blocking.never;
-  }
-
-  template <class Func>
-  void execute(Func f) const
-  {
-    thread_bag& bag = query(execution::context);
-    bag.add_thread(std::thread(std::move(f)));
-  }
-
-  friend bool operator==(const thread_executor&,
-      const thread_executor&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const thread_executor&,
-      const thread_executor&) noexcept
-  {
-    return false;
-  }
-};
-
-// Base class for all thread-safe queue implementations.
-class queue_impl_base
-{
-  template <class> friend class queue_front;
-  template <class> friend class queue_back;
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  bool stop_ = false;
-};
-
-// Underlying implementation of a thread-safe queue, shared between the
-// queue_front and queue_back classes.
-template <class T>
-class queue_impl : public queue_impl_base
-{
-  template <class> friend class queue_front;
-  template <class> friend class queue_back;
-  std::queue<T> queue_;
-};
-
-// The front end of a queue between consecutive pipeline stages.
-template <class T>
-class queue_front
-{
-public:
-  typedef T value_type;
-
-  explicit queue_front(std::shared_ptr<queue_impl<T>> impl)
-    : impl_(impl)
-  {
-  }
-
-  void push(T t)
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    impl_->queue_.push(std::move(t));
-    impl_->condition_.notify_one();
-  }
-
-  void stop()
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    impl_->stop_ = true;
-    impl_->condition_.notify_one();
-  }
-
-private:
-  std::shared_ptr<queue_impl<T>> impl_;
-};
-
-// The back end of a queue between consecutive pipeline stages.
-template <class T>
-class queue_back
-{
-public:
-  typedef T value_type;
-
-  explicit queue_back(std::shared_ptr<queue_impl<T>> impl)
-    : impl_(impl)
-  {
-  }
-
-  bool pop(T& t)
-  {
-    std::unique_lock<std::mutex> lock(impl_->mutex_);
-    while (impl_->queue_.empty() && !impl_->stop_)
-      impl_->condition_.wait(lock);
-    if (!impl_->queue_.empty())
-    {
-      t = impl_->queue_.front();
-      impl_->queue_.pop();
-      return true;
-    }
-    return false;
-  }
-
-private:
-  std::shared_ptr<queue_impl<T>> impl_;
-};
-
-// Launch the last stage in a pipeline.
-template <class T, class F>
-std::future<void> pipeline(queue_back<T> in, F f)
-{
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function, and as we're the last stage return a future so that the
-  // caller can wait for the pipeline to finish.
-  std::packaged_task<void()> task(
-      [in, f = std::move(f)]() mutable
-      {
-        f(in);
-      });
-  std::future<void> fut = task.get_future();
-  asio::require(ex, execution::blocking.never).execute(std::move(task));
-  return fut;
-}
-
-// Launch an intermediate stage in a pipeline.
-template <class T, class F, class... Tail>
-std::future<void> pipeline(queue_back<T> in, F f, Tail... t)
-{
-  // Determine the output queue type.
-  typedef typename executor_binder<F, thread_executor>::second_argument_type::value_type output_value_type;
-
-  // Create the output queue and its implementation.
-  auto out_impl = std::make_shared<queue_impl<output_value_type>>();
-  queue_front<output_value_type> out(out_impl);
-  queue_back<output_value_type> next_in(out_impl);
-
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function.
-  asio::require(ex, execution::blocking.never).execute(
-      [in, out, f = std::move(f)]() mutable
-      {
-        f(in, out);
-        out.stop();
-      });
-
-  // Launch the rest of the pipeline.
-  return pipeline(next_in, std::move(t)...);
-}
-
-// Launch the first stage in a pipeline.
-template <class F, class... Tail>
-std::future<void> pipeline(F f, Tail... t)
-{
-  // Determine the output queue type.
-  typedef typename executor_binder<F, thread_executor>::argument_type::value_type output_value_type;
-
-  // Create the output queue and its implementation.
-  auto out_impl = std::make_shared<queue_impl<output_value_type>>();
-  queue_front<output_value_type> out(out_impl);
-  queue_back<output_value_type> next_in(out_impl);
-
-  // Get the function's associated executor, defaulting to thread_executor.
-  auto ex = get_associated_executor(f, thread_executor());
-
-  // Run the function.
-  asio::require(ex, execution::blocking.never).execute(
-      [out, f = std::move(f)]() mutable
-      {
-        f(out);
-        out.stop();
-      });
-
-  // Launch the rest of the pipeline.
-  return pipeline(next_in, std::move(t)...);
-}
-
-//------------------------------------------------------------------------------
-
-#include <asio/static_thread_pool.hpp>
-#include <iostream>
-#include <string>
-
-using asio::bind_executor;
-using asio::static_thread_pool;
-
-void reader(queue_front<std::string> out)
-{
-  std::string line;
-  while (std::getline(std::cin, line))
-    out.push(line);
-}
-
-void filter(queue_back<std::string> in, queue_front<std::string> out)
-{
-  std::string line;
-  while (in.pop(line))
-    if (line.length() > 5)
-      out.push(line);
-}
-
-void upper(queue_back<std::string> in, queue_front<std::string> out)
-{
-  std::string line;
-  while (in.pop(line))
-  {
-    std::string new_line;
-    for (char c : line)
-      new_line.push_back(std::toupper(c));
-    out.push(new_line);
-  }
-}
-
-void writer(queue_back<std::string> in)
-{
-  std::size_t count = 0;
-  std::string line;
-  while (in.pop(line))
-    std::cout << count++ << ": " << line << std::endl;
-}
-
-int main()
-{
-  static_thread_pool pool(1);
-
-  auto f = pipeline(reader, filter, bind_executor(pool.executor(), upper), writer);
-  f.wait();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/priority_scheduler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/priority_scheduler.cpp
deleted file mode 100644
index 20d36db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/executors/priority_scheduler.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-#include <asio/execution.hpp>
-#include <condition_variable>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <queue>
-
-namespace execution = asio::execution;
-
-namespace custom_props {
-
-  struct priority
-  {
-    template <typename T>
-    static constexpr bool is_applicable_property_v =
-      execution::is_executor<T>::value;
-
-    static constexpr bool is_requirable = true;
-    static constexpr bool is_preferable = true;
-
-    using polymorphic_query_result_type = int;
-
-    int value() const { return value_; }
-
-    int value_ = 1;
-  };
-
-  constexpr priority low_priority{0};
-  constexpr priority normal_priority{1};
-  constexpr priority high_priority{2};
-
-} // namespace custom_props
-
-class priority_scheduler
-{
-public:
-  // A class that satisfies the Executor requirements.
-  class executor_type
-  {
-  public:
-    executor_type(priority_scheduler& ctx) noexcept
-      : context_(ctx), priority_(custom_props::normal_priority.value())
-    {
-    }
-
-    priority_scheduler& query(execution::context_t) const noexcept
-    {
-      return context_;
-    }
-
-    int query(custom_props::priority) const noexcept
-    {
-      return priority_;
-    }
-
-    executor_type require(custom_props::priority pri) const
-    {
-      executor_type new_ex(*this);
-      new_ex.priority_ = pri.value();
-      return new_ex;
-    }
-
-    template <class Func>
-    void execute(Func f) const
-    {
-      auto p(std::make_shared<item<Func>>(priority_, std::move(f)));
-      std::lock_guard<std::mutex> lock(context_.mutex_);
-      context_.queue_.push(p);
-      context_.condition_.notify_one();
-    }
-
-    friend bool operator==(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ == &b.context_;
-    }
-
-    friend bool operator!=(const executor_type& a,
-        const executor_type& b) noexcept
-    {
-      return &a.context_ != &b.context_;
-    }
-
-  private:
-    priority_scheduler& context_;
-    int priority_;
-  };
-
-  executor_type executor() noexcept
-  {
-    return executor_type(*const_cast<priority_scheduler*>(this));
-  }
-
-  void run()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    for (;;)
-    {
-      condition_.wait(lock, [&]{ return stopped_ || !queue_.empty(); });
-      if (stopped_)
-        return;
-      auto p(queue_.top());
-      queue_.pop();
-      lock.unlock();
-      p->execute_(p);
-      lock.lock();
-    }
-  }
-
-  void stop()
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    stopped_ = true;
-    condition_.notify_all();
-  }
-
-private:
-  struct item_base
-  {
-    int priority_;
-    void (*execute_)(std::shared_ptr<item_base>&);
-  };
-
-  template <class Func>
-  struct item : item_base
-  {
-    item(int pri, Func f) : function_(std::move(f))
-    {
-      priority_ = pri;
-      execute_ = [](std::shared_ptr<item_base>& p)
-      {
-        Func tmp(std::move(static_cast<item*>(p.get())->function_));
-        p.reset();
-        tmp();
-      };
-    }
-
-    Func function_;
-  };
-
-  struct item_comp
-  {
-    bool operator()(
-        const std::shared_ptr<item_base>& a,
-        const std::shared_ptr<item_base>& b)
-    {
-      return a->priority_ < b->priority_;
-    }
-  };
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::priority_queue<
-    std::shared_ptr<item_base>,
-    std::vector<std::shared_ptr<item_base>>,
-    item_comp> queue_;
-  bool stopped_ = false;
-};
-
-int main()
-{
-  priority_scheduler sched;
-  auto ex = sched.executor();
-  auto prefer_low = asio::prefer(ex, custom_props::low_priority);
-  auto low = asio::require(ex, custom_props::low_priority);
-  auto med = asio::require(ex, custom_props::normal_priority);
-  auto high = asio::require(ex, custom_props::high_priority);
-  execution::any_executor<custom_props::priority> poly_high(high);
-  prefer_low.execute([]{ std::cout << "1\n"; });
-  low.execute([]{ std::cout << "11\n"; });
-  low.execute([]{ std::cout << "111\n"; });
-  med.execute([]{ std::cout << "2\n"; });
-  med.execute([]{ std::cout << "22\n"; });
-  high.execute([]{ std::cout << "3\n"; });
-  high.execute([]{ std::cout << "33\n"; });
-  high.execute([]{ std::cout << "333\n"; });
-  poly_high.execute([]{ std::cout << "3333\n"; });
-  asio::require(ex, custom_props::priority{-1}).execute([&]{ sched.stop(); });
-  sched.run();
-  std::cout << "polymorphic query result = " << asio::query(poly_high, custom_props::priority{}) << "\n";
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/.gitignore
deleted file mode 100644
index bc2b4f8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-*_server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/http_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/http_client.cpp
deleted file mode 100644
index 3ae02e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/iostreams/http_client.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// http_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <iostream>
-#include <istream>
-#include <ostream>
-#include <string>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cout << "Usage: http_client <server> <path>\n";
-      std::cout << "Example:\n";
-      std::cout << "  http_client www.boost.org /LICENSE_1_0.txt\n";
-      return 1;
-    }
-
-    asio::ip::tcp::iostream s;
-
-    // The entire sequence of I/O operations must complete within 60 seconds.
-    // If an expiry occurs, the socket is automatically closed and the stream
-    // becomes bad.
-    s.expires_after(std::chrono::seconds(60));
-
-    // Establish a connection to the server.
-    s.connect(argv[1], "http");
-    if (!s)
-    {
-      std::cout << "Unable to connect: " << s.error().message() << "\n";
-      return 1;
-    }
-
-    // Send the request. We specify the "Connection: close" header so that the
-    // server will close the socket after transmitting the response. This will
-    // allow us to treat all data up until the EOF as the content.
-    s << "GET " << argv[2] << " HTTP/1.0\r\n";
-    s << "Host: " << argv[1] << "\r\n";
-    s << "Accept: */*\r\n";
-    s << "Connection: close\r\n\r\n";
-
-    // By default, the stream is tied with itself. This means that the stream
-    // automatically flush the buffered output before attempting a read. It is
-    // not necessary not explicitly flush the stream at this point.
-
-    // Check that response is OK.
-    std::string http_version;
-    s >> http_version;
-    unsigned int status_code;
-    s >> status_code;
-    std::string status_message;
-    std::getline(s, status_message);
-    if (!s || http_version.substr(0, 5) != "HTTP/")
-    {
-      std::cout << "Invalid response\n";
-      return 1;
-    }
-    if (status_code != 200)
-    {
-      std::cout << "Response returned with status code " << status_code << "\n";
-      return 1;
-    }
-
-    // Process the response headers, which are terminated by a blank line.
-    std::string header;
-    while (std::getline(s, header) && header != "\r")
-      std::cout << header << "\n";
-    std::cout << "\n";
-
-    // Write the remaining data to output.
-    std::cout << s.rdbuf();
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/.gitignore
deleted file mode 100644
index 0d02e83..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/.gitignore
+++ /dev/null
@@ -1,12 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-c_callback_wrapper
-callback_wrapper
-composed_[0-9]
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/c_callback_wrapper.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/c_callback_wrapper.cpp
deleted file mode 100644
index 33b1c26..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/c_callback_wrapper.cpp
+++ /dev/null
@@ -1,230 +0,0 @@
-//
-// c_callback_wrapper.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-#include <memory>
-#include <new>
-
-//------------------------------------------------------------------------------
-
-// This is a mock implementation of a C-based API that uses the function pointer
-// plus void* context idiom for exposing a callback.
-
-void read_input(const char* prompt, void (*cb)(void*, const char*), void* arg)
-{
-  std::thread(
-      [prompt = std::string(prompt), cb, arg]
-      {
-        std::cout << prompt << ": ";
-        std::cout.flush();
-        std::string line;
-        std::getline(std::cin, line);
-        cb(arg, line.c_str());
-      }).detach();
-}
-
-//------------------------------------------------------------------------------
-
-// This is an asynchronous operation that wraps the C-based API.
-
-// To map our completion handler into a function pointer / void* callback, we
-// need to allocate some state that will live for the duration of the
-// operation. A pointer to this state will be passed to the C-based API.
-template <typename Handler>
-class read_input_state
-{
-public:
-  read_input_state(Handler&& handler)
-    : handler_(std::move(handler)),
-      work_(asio::make_work_guard(handler_))
-  {
-  }
-
-  // Create the state using the handler's associated allocator.
-  static read_input_state* create(Handler&& handler)
-  {
-    // A unique_ptr deleter that is used to destroy uninitialised objects.
-    struct deleter
-    {
-      // Get the handler's associated allocator type. If the handler does not
-      // specify an associated allocator, we will use a recycling allocator as
-      // the default. As the associated allocator is a proto-allocator, we must
-      // rebind it to the correct type before we can use it to allocate objects.
-      typename std::allocator_traits<
-        asio::associated_allocator_t<Handler,
-          asio::recycling_allocator<void>>>::template
-            rebind_alloc<read_input_state> alloc;
-
-      void operator()(read_input_state* ptr)
-      {
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-      }
-    } d{asio::get_associated_allocator(handler,
-          asio::recycling_allocator<void>())};
-
-    // Allocate memory for the state.
-    std::unique_ptr<read_input_state, deleter> uninit_ptr(
-        std::allocator_traits<decltype(d.alloc)>::allocate(d.alloc, 1), d);
-
-    // Construct the state into the newly allocated memory. This might throw.
-    read_input_state* ptr =
-      new (uninit_ptr.get()) read_input_state(std::move(handler));
-
-    // Release ownership of the memory and return the newly allocated state.
-    uninit_ptr.release();
-    return ptr;
-  }
-
-  static void callback(void* arg, const char* result)
-  {
-    read_input_state* self = static_cast<read_input_state*>(arg);
-
-    // A unique_ptr deleter that is used to destroy initialised objects.
-    struct deleter
-    {
-      // Get the handler's associated allocator type. If the handler does not
-      // specify an associated allocator, we will use a recycling allocator as
-      // the default. As the associated allocator is a proto-allocator, we must
-      // rebind it to the correct type before we can use it to allocate objects.
-      typename std::allocator_traits<
-        asio::associated_allocator_t<Handler,
-          asio::recycling_allocator<void>>>::template
-            rebind_alloc<read_input_state> alloc;
-
-      void operator()(read_input_state* ptr)
-      {
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, ptr);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-      }
-    } d{asio::get_associated_allocator(self->handler_,
-          asio::recycling_allocator<void>())};
-
-    // To conform to the rules regarding asynchronous operations and memory
-    // allocation, we must make a copy of the state and deallocate the memory
-    // before dispatching the completion handler.
-    std::unique_ptr<read_input_state, deleter> state_ptr(self, d);
-    read_input_state state(std::move(*self));
-    state_ptr.reset();
-
-    // Dispatch the completion handler through the handler's associated
-    // executor, using the handler's associated allocator.
-    asio::dispatch(state.work_.get_executor(),
-        asio::bind_allocator(d.alloc,
-          [
-            handler = std::move(state.handler_),
-            result = std::string(result)
-          ]() mutable
-          {
-            std::move(handler)(result);
-          }));
-  }
-
-private:
-  Handler handler_;
-
-  // According to the rules for asynchronous operations, we need to track
-  // outstanding work against the handler's associated executor until the
-  // asynchronous operation is complete.
-  asio::executor_work_guard<
-    asio::associated_executor_t<Handler>> work_;
-};
-
-// The initiating function for the asynchronous operation.
-template <typename CompletionToken>
-auto async_read_input(const std::string& prompt, CompletionToken&& token)
-{
-  // Define a function object that contains the code to launch the asynchronous
-  // operation. This is passed the concrete completion handler, followed by any
-  // additional arguments that were passed through the call to async_initiate.
-  auto init = [](auto handler, const std::string& prompt)
-  {
-    // The body of the initiation function object creates the long-lived state
-    // and passes it to the C-based API, along with the function pointer.
-    using state_type = read_input_state<decltype(handler)>;
-    read_input(prompt.c_str(), &state_type::callback,
-        state_type::create(std::move(handler)));
-  };
-
-  // The async_initiate function is used to transform the supplied completion
-  // token to the completion handler. When calling this function we explicitly
-  // specify the completion signature of the operation. We must also return the
-  // result of the call since the completion token may produce a return value,
-  // such as a future.
-  return asio::async_initiate<CompletionToken, void(std::string)>(
-      init, // First, pass the function object that launches the operation,
-      token, // then the completion token that will be transformed to a handler,
-      prompt); // and, finally, any additional arguments to the function object.
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  async_read_input("Enter your name",
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_read_input("Enter your name", asio::deferred);
-
-  // Launch our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  std::move(op)(
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::string> f =
-    async_read_input("Enter your name", asio::use_future);
-
-  std::string result = f.get();
-  std::cout << "Hello " << result << "\n";
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/callback_wrapper.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/callback_wrapper.cpp
deleted file mode 100644
index 3d5774c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/callback_wrapper.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// callback_wrapper.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-//------------------------------------------------------------------------------
-
-// This is a mock implementation of an API that uses a move-only function object
-// for exposing a callback. The callback has the signature void(std::string).
-
-template <typename Callback>
-void read_input(const std::string& prompt, Callback cb)
-{
-  std::thread(
-      [prompt, cb = std::move(cb)]() mutable
-      {
-        std::cout << prompt << ": ";
-        std::cout.flush();
-        std::string line;
-        std::getline(std::cin, line);
-        std::move(cb)(std::move(line));
-      }).detach();
-}
-
-//------------------------------------------------------------------------------
-
-// This is an asynchronous operation that wraps the callback-based API.
-
-// The initiating function for the asynchronous operation.
-template <typename CompletionToken>
-auto async_read_input(const std::string& prompt, CompletionToken&& token)
-{
-  // Define a function object that contains the code to launch the asynchronous
-  // operation. This is passed the concrete completion handler, followed by any
-  // additional arguments that were passed through the call to async_initiate.
-  auto init = [](auto handler, const std::string& prompt)
-  {
-    // According to the rules for asynchronous operations, we need to track
-    // outstanding work against the handler's associated executor until the
-    // asynchronous operation is complete.
-    auto work = asio::make_work_guard(handler);
-
-    // Launch the operation with a callback that will receive the result and
-    // pass it through to the asynchronous operation's completion handler.
-    read_input(prompt,
-        [
-          handler = std::move(handler),
-          work = std::move(work)
-        ](std::string result) mutable
-        {
-          // Get the handler's associated allocator. If the handler does not
-          // specify an allocator, use the recycling allocator as the default.
-          auto alloc = asio::get_associated_allocator(
-              handler, asio::recycling_allocator<void>());
-
-          // Dispatch the completion handler through the handler's associated
-          // executor, using the handler's associated allocator.
-          asio::dispatch(work.get_executor(),
-              asio::bind_allocator(alloc,
-                [
-                  handler = std::move(handler),
-                  result = std::string(result)
-                ]() mutable
-                {
-                  std::move(handler)(result);
-                }));
-        });
-  };
-
-  // The async_initiate function is used to transform the supplied completion
-  // token to the completion handler. When calling this function we explicitly
-  // specify the completion signature of the operation. We must also return the
-  // result of the call since the completion token may produce a return value,
-  // such as a future.
-  return asio::async_initiate<CompletionToken, void(std::string)>(
-      init, // First, pass the function object that launches the operation,
-      token, // then the completion token that will be transformed to a handler,
-      prompt); // and, finally, any additional arguments to the function object.
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to specify an associated executor.
-  async_read_input("Enter your name",
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_read_input("Enter your name", asio::deferred);
-
-  // Launch our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  std::move(op)(
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::string> f =
-    async_read_input("Enter your name", asio::use_future);
-
-  std::string result = f.get();
-  std::cout << "Hello " << result << "\n";
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_1.cpp
deleted file mode 100644
index 80eaced..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_1.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// composed_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-//------------------------------------------------------------------------------
-
-// This is the simplest example of a composed asynchronous operation, where we
-// simply repackage an existing operation. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of our underlying asynchronous operation.
-{
-  // When delegating to the underlying operation we must take care to perfectly
-  // forward the completion token. This ensures that our operation works
-  // correctly with move-only function objects as callbacks, as well as other
-  // completion token types.
-  return asio::async_write(socket,
-      asio::buffer(message, std::strlen(message)),
-      std::forward<CompletionToken>(token));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_2.cpp
deleted file mode 100644
index 18086bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_2.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//
-// composed_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This next simplest example of a composed asynchronous operation involves
-// repackaging multiple operations but choosing to invoke just one of them. All
-// of these underlying operations have the same completion signature. The
-// asynchronous operation requirements are met by delegating responsibility to
-// the underlying operations.
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, bool allow_partial_write,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error, std::size_t)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](auto&& completion_handler, tcp::socket& socket,
-      const char* message, bool allow_partial_write)
-  {
-    if (allow_partial_write)
-    {
-      // When delegating to an underlying operation we must take care to
-      // perfectly forward the completion handler. This ensures that our
-      // operation works correctly with move-only function objects as
-      // callbacks.
-      return socket.async_write_some(
-          asio::buffer(message, std::strlen(message)),
-          std::forward<decltype(completion_handler)>(completion_handler));
-    }
-    else
-    {
-      // As above, we must perfectly forward the completion handler when calling
-      // the alternate underlying operation.
-      return asio::async_write(socket,
-          asio::buffer(message, std::strlen(message)),
-          std::forward<decltype(completion_handler)>(completion_handler));
-    }
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code, std::size_t)>(
-      initiation, token, std::ref(socket), message, allow_partial_write);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n", false,
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", false, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", false, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_3.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_3.cpp
deleted file mode 100644
index 7b34794..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_3.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-//
-// composed_3.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](auto&& completion_handler,
-      tcp::socket& socket, const char* message)
-  {
-    // The async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // This differs from our operation's signature in that it is also passed
-    // the number of bytes transferred as an argument of type std::size_t. We
-    // will adapt our completion handler to async_write's completion handler
-    // signature by using std::bind, which drops the additional argument.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    asio::async_write(socket,
-        asio::buffer(message, std::strlen(message)),
-        asio::bind_executor(executor,
-          std::bind(std::forward<decltype(completion_handler)>(
-              completion_handler), std::placeholders::_1)));
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  // Get the result of the operation.
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_4.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_4.cpp
deleted file mode 100644
index 808a179..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_4.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-//
-// composed_4.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. We will also intercept an empty
-// message as an invalid argument, and propagate the corresponding error to the
-// user. The asynchronous operation requirements are met by delegating
-// responsibility to the underlying operation.
-
-template <typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](auto&& completion_handler,
-      tcp::socket& socket, const char* message)
-  {
-    // The post operation has a completion handler signature of:
-    //
-    //   void()
-    //
-    // and the async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // Both of these operations' completion handler signatures differ from our
-    // operation's completion handler signature. We will adapt our completion
-    // handler to these signatures by using std::bind, which drops the
-    // additional arguments.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    std::size_t length = std::strlen(message);
-    if (length == 0)
-    {
-      asio::post(
-          asio::bind_executor(executor,
-            std::bind(std::forward<decltype(completion_handler)>(
-                completion_handler), asio::error::invalid_argument)));
-    }
-    else
-    {
-      asio::async_write(socket,
-          asio::buffer(message, length),
-          asio::bind_executor(executor,
-            std::bind(std::forward<decltype(completion_handler)>(
-                completion_handler), std::placeholders::_1)));
-    }
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket, "", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_5.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_5.cpp
deleted file mode 100644
index c28cc8a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_5.cpp
+++ /dev/null
@@ -1,280 +0,0 @@
-//
-// composed_5.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation automatically serialises a message, using its I/O
-// streams insertion operator, before sending it on the socket. To do this, it
-// must allocate a buffer for the encoded message and ensure this buffer's
-// validity until the underlying async_write operation completes.
-
-template <typename T, typename CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const T& message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](auto&& completion_handler,
-      tcp::socket& socket, std::unique_ptr<std::string> encoded_message)
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object, rather than
-    // using a lambda or std::bind.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket so
-      // that it can obtain the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The user-supplied completion handler.
-      typename std::decay<decltype(completion_handler)>::type handler_;
-
-      // The function call operator matches the completion signature of the
-      // async_write operation.
-      void operator()(const std::error_code& error, std::size_t /*n*/)
-      {
-        // Deallocate the encoded message before calling the user-supplied
-        // completion handler.
-        encoded_message_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        // The arguments must match the completion signature of our composed
-        // operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{socket, std::move(encoded_message),
-          std::forward<decltype(completion_handler)>(completion_handler)});
-  };
-
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket),
-      std::move(encoded_message));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, 123456,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_message(socket,
-      std::string("abcdef"), asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, 654.321, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_6.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_6.cpp
deleted file mode 100644
index b056272..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_6.cpp
+++ /dev/null
@@ -1,341 +0,0 @@
-//
-// composed_6.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/executor_work_guard.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](auto&& completion_handler, tcp::socket& socket,
-      std::unique_ptr<std::string> encoded_message, std::size_t repeat_count,
-      std::unique_ptr<asio::steady_timer> delay_timer)
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket as
-      // it is used for multiple async_write operations, as well as for
-      // obtaining the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The repeat count remaining.
-      std::size_t repeat_count_;
-
-      // A steady timer used for introducing a delay.
-      std::unique_ptr<asio::steady_timer> delay_timer_;
-
-      // To manage the cycle between the multiple underlying asychronous
-      // operations, our intermediate completion handler is implemented as a
-      // state machine.
-      enum { starting, waiting, writing } state_;
-
-      // As our composed operation performs multiple underlying I/O operations,
-      // we should maintain a work object against the I/O executor. This tells
-      // the I/O executor that there is still more work to come in the future.
-      asio::executor_work_guard<tcp::socket::executor_type> io_work_;
-
-      // The user-supplied completion handler, called once only on completion
-      // of the entire composed operation.
-      typename std::decay<decltype(completion_handler)>::type handler_;
-
-      // By having a default value for the second argument, this function call
-      // operator matches the completion signature of both the async_write and
-      // steady_timer::async_wait operations.
-      void operator()(const std::error_code& error, std::size_t = 0)
-      {
-        if (!error)
-        {
-          switch (state_)
-          {
-          case starting:
-          case writing:
-            if (repeat_count_ > 0)
-            {
-              --repeat_count_;
-              state_ = waiting;
-              delay_timer_->expires_after(std::chrono::seconds(1));
-              delay_timer_->async_wait(std::move(*this));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state_ = writing;
-            asio::async_write(socket_,
-                asio::buffer(*encoded_message_), std::move(*this));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // We no longer have any future work coming for the I/O executor.
-        io_work_.reset();
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message_.reset();
-        delay_timer_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{
-          socket, std::move(encoded_message),
-          repeat_count, std::move(delay_timer),
-          intermediate_completion_handler::starting,
-          asio::make_work_guard(socket.get_executor()),
-          std::forward<decltype(completion_handler)>(completion_handler)});
-  };
-
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket),
-      std::move(encoded_message), repeat_count,
-      std::move(delay_timer));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_7.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_7.cpp
deleted file mode 100644
index 841249b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_7.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//
-// composed_7.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_compose.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // To manage the cycle between the multiple underlying asychronous
-  // operations, our implementation is a state machine.
-  enum { starting, waiting, writing };
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a state
-  // machine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // To manage the cycle between the multiple underlying asychronous
-        // operations, our implementation is a state machine.
-        state = starting
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        if (!error)
-        {
-          switch (state)
-          {
-          case starting:
-          case writing:
-            if (repeat_count > 0)
-            {
-              --repeat_count;
-              state = waiting;
-              delay_timer->expires_after(std::chrono::seconds(1));
-              delay_timer->async_wait(std::move(self));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state = writing;
-            asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message.reset();
-        delay_timer.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        self.complete(error);
-      },
-      token, socket);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_8.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_8.cpp
deleted file mode 100644
index d1f46dd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/operations/composed_8.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-//
-// composed_8.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/coroutine.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations,
-// using asio's stackless coroutines support to express the flow of control. It
-// automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-#include <asio/yield.hpp>
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_compose.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a stackless
-  // coroutine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // The coroutine state.
-        coro = asio::coroutine()
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        reenter (coro)
-        {
-          while (repeat_count > 0)
-          {
-            --repeat_count;
-
-            delay_timer->expires_after(std::chrono::seconds(1));
-            yield delay_timer->async_wait(std::move(self));
-            if (error)
-              break;
-
-            yield asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            if (error)
-              break;
-          }
-
-          // Deallocate the encoded message and delay timer before calling the
-          // user-supplied completion handler.
-          encoded_message.reset();
-          delay_timer.reset();
-
-          // Call the user-supplied handler with the result of the operation.
-          self.complete(error);
-        }
-      },
-      token, socket);
-}
-
-#include <asio/unyield.hpp>
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_write_messages(socket,
-      "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/.gitignore
deleted file mode 100644
index 4d16a0e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/.gitignore
+++ /dev/null
@@ -1,15 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-parallel_sort
-ranged_wait_for_all
-wait_for_all
-wait_for_one
-wait_for_one_error
-wait_for_one_success
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/parallel_sort.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/parallel_sort.cpp
deleted file mode 100644
index 4623e03..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/parallel_sort.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-//
-// parallel_sort.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <algorithm>
-#include <chrono>
-#include <functional>
-#include <iostream>
-#include <random>
-
-template <
-    typename Executor,
-    typename RandomAccessIterator,
-    ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-auto parallel_sort(
-    Executor executor,
-    RandomAccessIterator begin,
-    RandomAccessIterator end,
-    CompletionToken&& token);
-
-template <
-    typename Executor,
-    typename RandomAccessIterator>
-void parallel_sort_impl(
-    Executor executor,
-    RandomAccessIterator begin,
-    RandomAccessIterator end,
-    std::function<void()> continuation)
-{
-    std::size_t n = end - begin;
-    if (n <= 16384)
-    {
-      asio::post(executor,
-          [=]
-          {
-            std::sort(begin, end);
-            continuation();
-          }
-        );
-    }
-    else
-    {
-      asio::experimental::make_parallel_group(
-          [=](auto token)
-          {
-            return parallel_sort(executor, begin, begin + n / 2, token);
-          },
-          [=](auto token)
-          {
-            return parallel_sort(executor, begin + n / 2, end, token);
-          }
-        ).async_wait(
-          asio::experimental::wait_for_all(),
-          [=](std::array<std::size_t, 2>)
-          {
-            std::inplace_merge(begin, begin + n / 2, end);
-            continuation();
-          }
-        );
-    }
-}
-
-template <
-    typename Executor,
-    typename RandomAccessIterator,
-    ASIO_COMPLETION_TOKEN_FOR(void()) CompletionToken>
-auto parallel_sort(
-    Executor executor,
-    RandomAccessIterator begin,
-    RandomAccessIterator end,
-    CompletionToken&& token)
-{
-  return asio::async_compose<CompletionToken, void()>(
-      [=](auto& self, auto... args)
-      {
-        if (sizeof...(args) == 0)
-        {
-          using self_type = std::decay_t<decltype(self)>;
-          parallel_sort_impl(executor, begin, end,
-              [self = std::make_shared<self_type>(std::move(self))]
-              {
-                asio::dispatch(
-                    asio::append(
-                      std::move(*self), 0));
-              }
-            );
-        }
-        else
-        {
-          self.complete();
-        }
-      },
-      token
-    );
-}
-
-int main()
-{
-  asio::thread_pool pool(4);
-
-  std::vector<int> values(100'000'000);
-
-  std::random_device random_device;
-  std::mt19937 rng(random_device());
-  std::uniform_int_distribution<int> dist(1, 1'000'000);
-  std::generate(values.begin(), values.end(), [&]{ return dist(rng); });
-
-  std::cout << "starting sort\n";
-
-  auto begin = std::chrono::high_resolution_clock::now();
-
-  parallel_sort(
-      pool.get_executor(),
-      values.begin(),
-      values.end(),
-      asio::use_future
-    ).get();
-
-  auto end = std::chrono::high_resolution_clock::now();
-
-  auto duration = end - begin;
-  std::cout << "sort took "
-    << std::chrono::duration_cast<std::chrono::microseconds>(duration).count()
-    << " microseconds\n";
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/ranged_wait_for_all.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/ranged_wait_for_all.cpp
deleted file mode 100644
index a0d8f56..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/ranged_wait_for_all.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// ranged_wait_for_all.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-#include <vector>
-
-#ifdef ASIO_HAS_POSIX_STREAM_DESCRIPTOR
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor out(ctx, ::dup(STDOUT_FILENO));
-  asio::posix::stream_descriptor err(ctx, ::dup(STDERR_FILENO));
-
-  using op_type = decltype(
-      out.async_write_some(asio::buffer("", 0))
-    );
-
-  std::vector<op_type> ops;
-
-  ops.push_back(
-      out.async_write_some(asio::buffer("first\r\n", 7))
-    );
-
-  ops.push_back(
-      err.async_write_some(asio::buffer("second\r\n", 8))
-    );
-
-  asio::experimental::make_parallel_group(ops).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::vector<std::size_t> completion_order,
-          std::vector<std::error_code> ec,
-          std::vector<std::size_t> n
-      )
-      {
-        for (std::size_t i = 0; i < completion_order.size(); ++i)
-        {
-          std::size_t idx = completion_order[i];
-          std::cout << "operation " << idx << " finished: ";
-          std::cout << ec[idx] << ", " << n[idx] << "\n";
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_all.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_all.cpp
deleted file mode 100644
index f007326..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_all.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// wait_for_all.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#ifdef ASIO_HAS_POSIX_STREAM_DESCRIPTOR
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return in.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      asio::experimental::wait_for_all(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one.cpp
deleted file mode 100644
index 7b25e26..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// wait_for_one.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return in.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      asio::experimental::wait_for_one(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_error.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_error.cpp
deleted file mode 100644
index c157d0b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_error.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// wait_for_one_error.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return in.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      asio::experimental::wait_for_one_error(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_success.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_success.cpp
deleted file mode 100644
index a328600..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp14/parallel_group/wait_for_one_success.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// wait_for_one_error.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/parallel_group.hpp>
-#include <iostream>
-
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-int main()
-{
-  asio::io_context ctx;
-
-  asio::posix::stream_descriptor in(ctx, ::dup(STDIN_FILENO));
-  asio::steady_timer timer(ctx, std::chrono::seconds(5));
-
-  char data[1024];
-
-  asio::experimental::make_parallel_group(
-      [&](auto token)
-      {
-        return in.async_read_some(asio::buffer(data), token);
-      },
-      [&](auto token)
-      {
-        return timer.async_wait(token);
-      }
-    ).async_wait(
-      asio::experimental::wait_for_one_success(),
-      [](
-          std::array<std::size_t, 2> completion_order,
-          std::error_code ec1, std::size_t n1,
-          std::error_code ec2
-      )
-      {
-        switch (completion_order[0])
-        {
-        case 0:
-          {
-            std::cout << "descriptor finished: " << ec1 << ", " << n1 << "\n";
-          }
-          break;
-        case 1:
-          {
-            std::cout << "timer finished: " << ec2 << "\n";
-          }
-          break;
-        }
-      }
-    );
-
-  ctx.run();
-}
-
-#else // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-int main() {}
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/Makefile.am
deleted file mode 100644
index c3a571c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/Makefile.am
+++ /dev/null
@@ -1,37 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-if SEPARATE_COMPILATION
-noinst_LIBRARIES = libasio.a
-libasio_a_SOURCES = ../../asio.cpp
-if HAVE_OPENSSL
-libasio_a_SOURCES += ../../asio_ssl.cpp
-endif
-LDADD = libasio.a
-endif
-
-if HAVE_COROUTINES
-noinst_PROGRAMS = \
-	coroutines_ts/chat_server \
-	coroutines_ts/echo_server \
-	coroutines_ts/echo_server_with_default \
-	coroutines_ts/echo_server_with_as_single_default \
-	coroutines_ts/echo_server_with_as_tuple_default \
-	coroutines_ts/refactored_echo_server
-endif
-
-AM_CXXFLAGS = -I$(srcdir)/../../../include
-
-if HAVE_COROUTINES
-coroutines_ts_chat_server_SOURCES = coroutines_ts/chat_server.cpp
-coroutines_ts_echo_server_SOURCES = coroutines_ts/echo_server.cpp
-coroutines_ts_echo_server_with_default_SOURCES = coroutines_ts/echo_server_with_default.cpp
-coroutines_ts_echo_server_with_as_single_default_SOURCES = coroutines_ts/echo_server_with_as_single_default.cpp
-coroutines_ts_echo_server_with_as_tuple_default_SOURCES = coroutines_ts/echo_server_with_as_tuple_default.cpp
-coroutines_ts_refactored_echo_server_SOURCES = coroutines_ts/refactored_echo_server.cpp
-endif
-
-EXTRA_DIST = \
-	coroutines_ts/range_based_for.cpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/.gitignore
deleted file mode 100644
index 6932f65..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-*_server
-*_server_with_default
-*_server_with_as_single_default
-*_server_with_as_tuple_default
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/chat_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/chat_server.cpp
deleted file mode 100644
index cd5fba3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/chat_server.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-//
-// chat_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <deque>
-#include <iostream>
-#include <list>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <asio/awaitable.hpp>
-#include <asio/detached.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/read_until.hpp>
-#include <asio/redirect_error.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_awaitable.hpp>
-#include <asio/write.hpp>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::redirect_error;
-using asio::use_awaitable;
-
-//----------------------------------------------------------------------
-
-class chat_participant
-{
-public:
-  virtual ~chat_participant() {}
-  virtual void deliver(const std::string& msg) = 0;
-};
-
-typedef std::shared_ptr<chat_participant> chat_participant_ptr;
-
-//----------------------------------------------------------------------
-
-class chat_room
-{
-public:
-  void join(chat_participant_ptr participant)
-  {
-    participants_.insert(participant);
-    for (auto msg: recent_msgs_)
-      participant->deliver(msg);
-  }
-
-  void leave(chat_participant_ptr participant)
-  {
-    participants_.erase(participant);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    recent_msgs_.push_back(msg);
-    while (recent_msgs_.size() > max_recent_msgs)
-      recent_msgs_.pop_front();
-
-    for (auto participant: participants_)
-      participant->deliver(msg);
-  }
-
-private:
-  std::set<chat_participant_ptr> participants_;
-  enum { max_recent_msgs = 100 };
-  std::deque<std::string> recent_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-class chat_session
-  : public chat_participant,
-    public std::enable_shared_from_this<chat_session>
-{
-public:
-  chat_session(tcp::socket socket, chat_room& room)
-    : socket_(std::move(socket)),
-      timer_(socket_.get_executor()),
-      room_(room)
-  {
-    timer_.expires_at(std::chrono::steady_clock::time_point::max());
-  }
-
-  void start()
-  {
-    room_.join(shared_from_this());
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->reader(); },
-        detached);
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->writer(); },
-        detached);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    write_msgs_.push_back(msg);
-    timer_.cancel_one();
-  }
-
-private:
-  awaitable<void> reader()
-  {
-    try
-    {
-      for (std::string read_msg;;)
-      {
-        std::size_t n = co_await asio::async_read_until(socket_,
-            asio::dynamic_buffer(read_msg, 1024), "\n", use_awaitable);
-
-        room_.deliver(read_msg.substr(0, n));
-        read_msg.erase(0, n);
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  awaitable<void> writer()
-  {
-    try
-    {
-      while (socket_.is_open())
-      {
-        if (write_msgs_.empty())
-        {
-          asio::error_code ec;
-          co_await timer_.async_wait(redirect_error(use_awaitable, ec));
-        }
-        else
-        {
-          co_await asio::async_write(socket_,
-              asio::buffer(write_msgs_.front()), use_awaitable);
-          write_msgs_.pop_front();
-        }
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  void stop()
-  {
-    room_.leave(shared_from_this());
-    socket_.close();
-    timer_.cancel();
-  }
-
-  tcp::socket socket_;
-  asio::steady_timer timer_;
-  chat_room& room_;
-  std::deque<std::string> write_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-awaitable<void> listener(tcp::acceptor acceptor)
-{
-  chat_room room;
-
-  for (;;)
-  {
-    std::make_shared<chat_session>(
-        co_await acceptor.async_accept(use_awaitable),
-        room
-      )->start();
-  }
-}
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc < 2)
-    {
-      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
-      return 1;
-    }
-
-    asio::io_context io_context(1);
-
-    for (int i = 1; i < argc; ++i)
-    {
-      unsigned short port = std::atoi(argv[i]);
-      co_spawn(io_context,
-          listener(tcp::acceptor(io_context, {tcp::v4(), port})),
-          detached);
-    }
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server.cpp
deleted file mode 100644
index a953245..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// echo_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable;
-namespace this_coro = asio::this_coro;
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# define use_awaitable \
-  asio::use_awaitable_t(__FILE__, __LINE__, __PRETTY_FUNCTION__)
-#endif
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data), use_awaitable);
-      co_await async_write(socket, asio::buffer(data, n), use_awaitable);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp
deleted file mode 100644
index 4a692ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_single_default.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// echo_server_with_as_single_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/experimental/as_single.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::experimental::as_single_t;
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using default_token = as_single_t<use_awaitable_t<>>;
-using tcp_acceptor = default_token::as_default_on_t<tcp::acceptor>;
-using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  char data[1024];
-  for (;;)
-  {
-    auto [e1, nread] = co_await socket.async_read_some(asio::buffer(data));
-    if (nread == 0) break;
-    auto [e2, nwritten] = co_await async_write(socket, asio::buffer(data, nread));
-    if (nwritten != nread) break;
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    if (auto [e, socket] = co_await acceptor.async_accept(); socket.is_open())
-      co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp
deleted file mode 100644
index de162ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_as_tuple_default.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// echo_server_with_as_tuple_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/as_tuple.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::as_tuple_t;
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using default_token = as_tuple_t<use_awaitable_t<>>;
-using tcp_acceptor = default_token::as_default_on_t<tcp::acceptor>;
-using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  char data[1024];
-  for (;;)
-  {
-    auto [e1, nread] = co_await socket.async_read_some(asio::buffer(data));
-    if (nread == 0) break;
-    auto [e2, nwritten] = co_await async_write(socket, asio::buffer(data, nread));
-    if (nwritten != nread) break;
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    if (auto [e, socket] = co_await acceptor.async_accept(); socket.is_open())
-      co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_default.cpp
deleted file mode 100644
index 54344d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/echo_server_with_default.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// echo_server_with_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using tcp_acceptor = use_awaitable_t<>::as_default_on_t<tcp::acceptor>;
-using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data));
-      co_await async_write(socket, asio::buffer(data, n));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    auto socket = co_await acceptor.async_accept();
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/range_based_for.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/range_based_for.cpp
deleted file mode 100644
index 599ed80..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/range_based_for.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-//
-// range_based_for.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable;
-
-class connection_iter
-{
-  friend class connections;
-  tcp::acceptor* acceptor_ = nullptr;
-  tcp::socket socket_;
-
-  connection_iter(tcp::acceptor& a, tcp::socket s)
-    : acceptor_(&a), socket_(std::move(s)) {}
-
-public:
-  tcp::socket operator*()
-  {
-    return std::move(socket_);
-  }
-
-  awaitable<void> operator++()
-  {
-    socket_ = co_await acceptor_->async_accept(use_awaitable);
-  }
-
-  bool operator==(const connection_iter&) const noexcept
-  {
-    return false;
-  }
-
-  bool operator!=(const connection_iter&) const noexcept
-  {
-    return true;
-  }
-};
-
-class connections
-{
-  tcp::acceptor& acceptor_;
-
-public:
-  explicit connections(tcp::acceptor& a) : acceptor_(a) {}
-
-  awaitable<connection_iter> begin()
-  {
-    tcp::socket s = co_await acceptor_.async_accept(use_awaitable);
-    co_return connection_iter(acceptor_, std::move(s));
-  }
-
-  connection_iter end()
-  {
-    return connection_iter(acceptor_,
-        tcp::socket(acceptor_.get_executor()));
-  }
-};
-
-awaitable<void> listener(tcp::acceptor acceptor)
-{
-  for co_await (tcp::socket s : connections(acceptor))
-  {
-    co_await asio::async_write(s, asio::buffer("hello\r\n", 7), use_awaitable);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-    co_spawn(io_context, listener(std::move(acceptor)), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/refactored_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/refactored_echo_server.cpp
deleted file mode 100644
index dc7b03d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp17/coroutines_ts/refactored_echo_server.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// refactored_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo_once(tcp::socket& socket)
-{
-  char data[128];
-  std::size_t n = co_await socket.async_read_some(asio::buffer(data), use_awaitable);
-  co_await async_write(socket, asio::buffer(data, n), use_awaitable);
-}
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    for (;;)
-    {
-      // The asynchronous operations to echo a single chunk of data have been
-      // refactored into a separate function. When this function is called, the
-      // operations are still performed in the context of the current
-      // coroutine, and the behaviour is functionally equivalent.
-      co_await echo_once(socket);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/Makefile.am
deleted file mode 100644
index 619893c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/Makefile.am
+++ /dev/null
@@ -1,79 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-if SEPARATE_COMPILATION
-noinst_LIBRARIES = libasio.a
-libasio_a_SOURCES = ../../asio.cpp
-if HAVE_OPENSSL
-libasio_a_SOURCES += ../../asio_ssl.cpp
-endif
-LDADD = libasio.a
-endif
-
-noinst_PROGRAMS = \
-	invocation/completion_executor \
-	operations/c_callback_wrapper \
-	operations/callback_wrapper \
-	operations/composed_1 \
-	operations/composed_1 \
-	operations/composed_2 \
-	operations/composed_3 \
-	operations/composed_4 \
-	operations/composed_5 \
-	operations/composed_6 \
-	operations/composed_7 \
-	operations/composed_8
-
-if HAVE_COROUTINES
-noinst_PROGRAMS += \
-	channels/mutual_exclusion_1 \
-	channels/mutual_exclusion_2 \
-	channels/throttling_proxy \
-	coroutines/chat_server \
-	coroutines/echo_server \
-	coroutines/echo_server_with_default \
-	coroutines/echo_server_with_deferred \
-	coroutines/echo_server_with_deferred_default \
-	coroutines/echo_server_with_as_single_default \
-	coroutines/echo_server_with_as_tuple_default \
-	coroutines/refactored_echo_server \
-	coroutines/timeout \
-	type_erasure/type_erasure
-endif
-
-AM_CXXFLAGS = -I$(srcdir)/../../../include
-
-invocation_completion_executor_SOURCES = invocation/completion_executor.cpp
-operations_c_callback_wrapper_SOURCES = operations/c_callback_wrapper.cpp
-operations_callback_wrapper_SOURCES = operations/callback_wrapper.cpp
-operations_composed_1_SOURCES = operations/composed_1.cpp
-operations_composed_2_SOURCES = operations/composed_2.cpp
-operations_composed_3_SOURCES = operations/composed_3.cpp
-operations_composed_4_SOURCES = operations/composed_4.cpp
-operations_composed_5_SOURCES = operations/composed_5.cpp
-operations_composed_6_SOURCES = operations/composed_6.cpp
-operations_composed_7_SOURCES = operations/composed_7.cpp
-operations_composed_8_SOURCES = operations/composed_8.cpp
-
-if HAVE_COROUTINES
-channels_mutual_exclusion_1_SOURCES = channels/mutual_exclusion_1.cpp
-channels_mutual_exclusion_2_SOURCES = channels/mutual_exclusion_2.cpp
-channels_throttling_proxy_SOURCES = channels/throttling_proxy.cpp
-coroutines_chat_server_SOURCES = coroutines/chat_server.cpp
-coroutines_echo_server_SOURCES = coroutines/echo_server.cpp
-coroutines_echo_server_with_default_SOURCES = coroutines/echo_server_with_default.cpp
-coroutines_echo_server_with_deferred_SOURCES = coroutines/echo_server_with_deferred.cpp
-coroutines_echo_server_with_deferred_default_SOURCES = coroutines/echo_server_with_deferred_default.cpp
-coroutines_echo_server_with_as_single_default_SOURCES = coroutines/echo_server_with_as_single_default.cpp
-coroutines_echo_server_with_as_tuple_default_SOURCES = coroutines/echo_server_with_as_tuple_default.cpp
-coroutines_refactored_echo_server_SOURCES = coroutines/refactored_echo_server.cpp
-coroutines_timeout_SOURCES = coroutines/timeout.cpp
-type_erasure_type_erasure_SOURCES = type_erasure/main.cpp type_erasure/stdin_line_reader.cpp type_erasure/sleep.cpp
-endif
-
-EXTRA_DIST = \
-	type_erasure/line_reader.hpp \
-	type_erasure/stdin_line_reader.hpp \
-	type_erasure/sleep.hpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/.gitignore
deleted file mode 100644
index defb06a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-mutual_exclusion_[0-9]
-throttling_proxy
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_1.cpp
deleted file mode 100644
index 94f564f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_1.cpp
+++ /dev/null
@@ -1,181 +0,0 @@
-//
-// mutual_exclusion_1.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/channel.hpp>
-#include <iostream>
-#include <memory>
-
-using asio::as_tuple;
-using asio::awaitable;
-using asio::dynamic_buffer;
-using asio::co_spawn;
-using asio::detached;
-using asio::experimental::channel;
-using asio::io_context;
-using asio::ip::tcp;
-using asio::steady_timer;
-using namespace asio::buffer_literals;
-using namespace std::literals::chrono_literals;
-
-// This class implements a simple line-based protocol:
-//
-// * For event line that is received from the client, the session sends a
-//   message header followed by the content of the line as the message body.
-//
-// * The session generates heartbeat messages once a second.
-//
-// This protocol is implemented using two actors, handle_messages() and
-// send_heartbeats(), each written as a coroutine.
-class line_based_echo_session :
-  public std::enable_shared_from_this<line_based_echo_session>
-{
-  // The socket used to read from and write to the client. This socket is a
-  // data member as it is shared between the two actors.
-  tcp::socket socket_;
-
-  // As both of the actors will write to the socket, we need a lock to prevent
-  // these writes from overlapping. To achieve this, we use a channel with a
-  // buffer size of one. The lock is claimed by sending a message to the
-  // channel, and then released by receiving this message back again. If the
-  // lock is not held then the channel's buffer is empty, and the send will
-  // complete without delay. Otherwise, if the lock is held by the other actor,
-  // then the send operation will not complete until the lock is released.
-  channel<void()> write_lock_{socket_.get_executor(), 1};
-
-public:
-  line_based_echo_session(tcp::socket socket)
-    : socket_{std::move(socket)}
-  {
-    socket_.set_option(tcp::no_delay(true));
-  }
-
-  void start()
-  {
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->handle_messages(); },
-        detached);
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->send_heartbeats(); },
-        detached);
-  }
-
-private:
-  void stop()
-  {
-    socket_.close();
-    write_lock_.cancel();
-  }
-
-  awaitable<void> handle_messages()
-  {
-    try
-    {
-      constexpr std::size_t max_line_length = 1024;
-      std::string data;
-      for (;;)
-      {
-        // Read an entire line from the client.
-        std::size_t length = co_await async_read_until(socket_,
-            dynamic_buffer(data, max_line_length), '\n');
-
-        // Claim the write lock by sending a message to the channel. Since the
-        // channel signature is void(), there are no arguments to send in the
-        // message itself.
-        co_await write_lock_.async_send();
-
-        // Respond to the client with a message, echoing the line they sent.
-        co_await async_write(socket_, "<line>"_buf);
-        co_await async_write(socket_, dynamic_buffer(data, length));
-
-        // Release the lock by receiving the message back again.
-        write_lock_.try_receive([](auto...){});
-      }
-    }
-    catch (const std::exception&)
-    {
-      stop();
-    }
-  }
-
-  awaitable<void> send_heartbeats()
-  {
-    steady_timer timer{socket_.get_executor()};
-    try
-    {
-      for (;;)
-      {
-        // Wait one second before trying to send the next heartbeat.
-        timer.expires_after(1s);
-        co_await timer.async_wait();
-
-        // Claim the write lock by sending a message to the channel. Since the
-        // channel signature is void(), there are no arguments to send in the
-        // message itself.
-        co_await write_lock_.async_send();
-
-        // Send a heartbeat to the client. As the content of the heartbeat
-        // message never varies, a buffer literal can be used to specify the
-        // bytes of the message. The memory associated with a buffer literal is
-        // valid for the lifetime of the program, which mean that the buffer
-        // can be safely passed as-is to the asynchronous operation.
-        co_await async_write(socket_, "<heartbeat>\n"_buf);
-
-        // Release the lock by receiving the message back again.
-        write_lock_.try_receive([](auto...){});
-      }
-    }
-    catch (const std::exception&)
-    {
-      stop();
-    }
-  }
-
-};
-
-awaitable<void> listen(tcp::acceptor& acceptor)
-{
-  for (;;)
-  {
-    auto [e, socket] = co_await acceptor.async_accept(as_tuple);
-    if (!e)
-    {
-      std::make_shared<line_based_echo_session>(std::move(socket))->start();
-    }
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: mutual_exclusion_1";
-      std::cerr << " <listen_address> <listen_port>\n";
-      return 1;
-    }
-
-    io_context ctx;
-
-    auto listen_endpoint =
-      *tcp::resolver(ctx).resolve(argv[1], argv[2],
-          tcp::resolver::passive).begin();
-
-    tcp::acceptor acceptor(ctx, listen_endpoint);
-    co_spawn(ctx, listen(acceptor), detached);
-    ctx.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_2.cpp
deleted file mode 100644
index bc51701..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/mutual_exclusion_2.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-// mutual_exclusion_2.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/channel.hpp>
-#include <iostream>
-#include <memory>
-
-using asio::as_tuple;
-using asio::awaitable;
-using asio::dynamic_buffer;
-using asio::co_spawn;
-using asio::detached;
-using asio::experimental::channel;
-using asio::io_context;
-using asio::ip::tcp;
-using asio::steady_timer;
-using namespace asio::buffer_literals;
-using namespace std::literals::chrono_literals;
-
-// This class implements a simple line-based protocol:
-//
-// * For event line that is received from the client, the session sends a
-//   message header followed by the content of the line as the message body.
-//
-// * The session generates heartbeat messages once a second.
-//
-// This protocol is implemented using two actors, handle_messages() and
-// send_heartbeats(), each written as a coroutine.
-class line_based_echo_session :
-  public std::enable_shared_from_this<line_based_echo_session>
-{
-  // The socket used to read from and write to the client. This socket is a
-  // data member as it is shared between the two actors.
-  tcp::socket socket_;
-
-  // As both of the actors will write to the socket, we need a lock to prevent
-  // these writes from overlapping. To achieve this, we use a channel with a
-  // buffer size of one. The lock is claimed by sending a message to the
-  // channel, and then released by receiving this message back again. If the
-  // lock is not held then the channel's buffer is empty, and the send will
-  // complete without delay. Otherwise, if the lock is held by the other actor,
-  // then the send operation will not complete until the lock is released.
-  channel<void()> write_lock_{socket_.get_executor(), 1};
-
-public:
-  line_based_echo_session(tcp::socket socket)
-    : socket_{std::move(socket)}
-  {
-    socket_.set_option(tcp::no_delay(true));
-  }
-
-  void start()
-  {
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->handle_messages(); },
-        detached);
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->send_heartbeats(); },
-        detached);
-  }
-
-private:
-  void stop()
-  {
-    socket_.close();
-    write_lock_.cancel();
-  }
-
-  awaitable<void> handle_messages()
-  {
-    try
-    {
-      constexpr std::size_t max_line_length = 1024;
-      std::string data;
-      for (;;)
-      {
-        // Read an entire line from the client.
-        std::size_t length = co_await async_read_until(socket_,
-            dynamic_buffer(data, max_line_length), '\n');
-
-        // Claim the write lock by sending a message to the channel. Since the
-        // channel signature is void(), there are no arguments to send in the
-        // message itself. In this example we optimise for the common case,
-        // where the lock is not held by the other actor, by first trying a
-        // non-blocking send.
-        if (!write_lock_.try_send())
-        {
-          co_await write_lock_.async_send();
-        }
-
-        // Respond to the client with a message, echoing the line they sent.
-        co_await async_write(socket_, "<line>"_buf);
-        co_await async_write(socket_, dynamic_buffer(data, length));
-
-        // Release the lock by receiving the message back again.
-        write_lock_.try_receive([](auto...){});
-      }
-    }
-    catch (const std::exception&)
-    {
-      stop();
-    }
-  }
-
-  awaitable<void> send_heartbeats()
-  {
-    steady_timer timer{socket_.get_executor()};
-    try
-    {
-      for (;;)
-      {
-        // Wait one second before trying to send the next heartbeat.
-        timer.expires_after(1s);
-        co_await timer.async_wait();
-
-        // Claim the write lock by sending a message to the channel. Since the
-        // channel signature is void(), there are no arguments to send in the
-        // message itself. In this example we optimise for the common case,
-        // where the lock is not held by the other actor, by first trying a
-        // non-blocking send.
-        if (!write_lock_.try_send())
-        {
-          co_await write_lock_.async_send();
-        }
-
-        // Send a heartbeat to the client. As the content of the heartbeat
-        // message never varies, a buffer literal can be used to specify the
-        // bytes of the message. The memory associated with a buffer literal is
-        // valid for the lifetime of the program, which mean that the buffer
-        // can be safely passed as-is to the asynchronous operation.
-        co_await async_write(socket_, "<heartbeat>\n"_buf);
-
-        // Release the lock by receiving the message back again.
-        write_lock_.try_receive([](auto...){});
-      }
-    }
-    catch (const std::exception&)
-    {
-      stop();
-    }
-  }
-
-};
-
-awaitable<void> listen(tcp::acceptor& acceptor)
-{
-  for (;;)
-  {
-    auto [e, socket] = co_await acceptor.async_accept(as_tuple);
-    if (!e)
-    {
-      std::make_shared<line_based_echo_session>(std::move(socket))->start();
-    }
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: mutual_exclusion_1";
-      std::cerr << " <listen_address> <listen_port>\n";
-      return 1;
-    }
-
-    io_context ctx;
-
-    auto listen_endpoint =
-      *tcp::resolver(ctx).resolve(argv[1], argv[2],
-          tcp::resolver::passive).begin();
-
-    tcp::acceptor acceptor(ctx, listen_endpoint);
-    co_spawn(ctx, listen(acceptor), detached);
-    ctx.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/throttling_proxy.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/throttling_proxy.cpp
deleted file mode 100644
index d145c77..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/channels/throttling_proxy.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// throttling_proxy.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/awaitable_operators.hpp>
-#include <asio/experimental/channel.hpp>
-#include <iostream>
-
-using asio::as_tuple;
-using asio::awaitable;
-using asio::buffer;
-using asio::co_spawn;
-using asio::detached;
-using asio::experimental::channel;
-using asio::io_context;
-using asio::ip::tcp;
-using asio::steady_timer;
-namespace this_coro = asio::this_coro;
-using namespace asio::experimental::awaitable_operators;
-using namespace std::literals::chrono_literals;
-
-using token_channel = channel<void(asio::error_code, std::size_t)>;
-
-awaitable<void> produce_tokens(std::size_t bytes_per_token,
-    steady_timer::duration token_interval, token_channel& tokens)
-{
-  steady_timer timer(co_await this_coro::executor);
-  for (;;)
-  {
-    co_await tokens.async_send(asio::error_code{}, bytes_per_token);
-
-    timer.expires_after(token_interval);
-    co_await timer.async_wait();
-  }
-}
-
-awaitable<void> transfer(tcp::socket& from,
-    tcp::socket& to, token_channel& tokens)
-{
-  std::array<unsigned char, 4096> data;
-  for (;;)
-  {
-    std::size_t bytes_available = co_await tokens.async_receive();
-    while (bytes_available > 0)
-    {
-      std::size_t n = co_await from.async_read_some(
-          buffer(data, bytes_available));
-
-      co_await async_write(to, buffer(data, n));
-
-      bytes_available -= n;
-    }
-  }
-}
-
-awaitable<void> proxy(tcp::socket client, tcp::endpoint target)
-{
-  constexpr std::size_t number_of_tokens = 100;
-  constexpr size_t bytes_per_token = 20 * 1024;
-  constexpr steady_timer::duration token_interval = 100ms;
-
-  auto ex = client.get_executor();
-  tcp::socket server(ex);
-  token_channel client_tokens(ex, number_of_tokens);
-  token_channel server_tokens(ex, number_of_tokens);
-
-  co_await server.async_connect(target);
-  co_await (
-      produce_tokens(bytes_per_token, token_interval, client_tokens) &&
-      transfer(client, server, client_tokens) &&
-      produce_tokens(bytes_per_token, token_interval, server_tokens) &&
-      transfer(server, client, server_tokens)
-    );
-}
-
-awaitable<void> listen(tcp::acceptor& acceptor, tcp::endpoint target)
-{
-  for (;;)
-  {
-    auto [e, client] = co_await acceptor.async_accept(as_tuple);
-    if (!e)
-    {
-      auto ex = client.get_executor();
-      co_spawn(ex, proxy(std::move(client), target), detached);
-    }
-    else
-    {
-      std::cerr << "Accept failed: " << e.message() << "\n";
-      steady_timer timer(co_await this_coro::executor);
-      timer.expires_after(100ms);
-      co_await timer.async_wait();
-    }
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 5)
-    {
-      std::cerr << "Usage: throttling_proxy";
-      std::cerr << " <listen_address> <listen_port>";
-      std::cerr << " <target_address> <target_port>\n";
-      return 1;
-    }
-
-    io_context ctx;
-
-    auto listen_endpoint =
-      *tcp::resolver(ctx).resolve(argv[1], argv[2],
-          tcp::resolver::passive).begin();
-
-    auto target_endpoint =
-      *tcp::resolver(ctx).resolve(argv[3], argv[4]).begin();
-
-    tcp::acceptor acceptor(ctx, listen_endpoint);
-    co_spawn(ctx, listen(acceptor, target_endpoint), detached);
-    ctx.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/.gitignore
deleted file mode 100644
index d85e505..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/.gitignore
+++ /dev/null
@@ -1,16 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-*_server
-*_server_with_default
-*_server_with_deferred
-*_server_with_deferred_default
-*_server_with_as_single_default
-*_server_with_as_tuple_default
-timeout
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/chat_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/chat_server.cpp
deleted file mode 100644
index cd5fba3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/chat_server.cpp
+++ /dev/null
@@ -1,222 +0,0 @@
-//
-// chat_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <cstdlib>
-#include <deque>
-#include <iostream>
-#include <list>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <asio/awaitable.hpp>
-#include <asio/detached.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/read_until.hpp>
-#include <asio/redirect_error.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_awaitable.hpp>
-#include <asio/write.hpp>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::redirect_error;
-using asio::use_awaitable;
-
-//----------------------------------------------------------------------
-
-class chat_participant
-{
-public:
-  virtual ~chat_participant() {}
-  virtual void deliver(const std::string& msg) = 0;
-};
-
-typedef std::shared_ptr<chat_participant> chat_participant_ptr;
-
-//----------------------------------------------------------------------
-
-class chat_room
-{
-public:
-  void join(chat_participant_ptr participant)
-  {
-    participants_.insert(participant);
-    for (auto msg: recent_msgs_)
-      participant->deliver(msg);
-  }
-
-  void leave(chat_participant_ptr participant)
-  {
-    participants_.erase(participant);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    recent_msgs_.push_back(msg);
-    while (recent_msgs_.size() > max_recent_msgs)
-      recent_msgs_.pop_front();
-
-    for (auto participant: participants_)
-      participant->deliver(msg);
-  }
-
-private:
-  std::set<chat_participant_ptr> participants_;
-  enum { max_recent_msgs = 100 };
-  std::deque<std::string> recent_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-class chat_session
-  : public chat_participant,
-    public std::enable_shared_from_this<chat_session>
-{
-public:
-  chat_session(tcp::socket socket, chat_room& room)
-    : socket_(std::move(socket)),
-      timer_(socket_.get_executor()),
-      room_(room)
-  {
-    timer_.expires_at(std::chrono::steady_clock::time_point::max());
-  }
-
-  void start()
-  {
-    room_.join(shared_from_this());
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->reader(); },
-        detached);
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->writer(); },
-        detached);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    write_msgs_.push_back(msg);
-    timer_.cancel_one();
-  }
-
-private:
-  awaitable<void> reader()
-  {
-    try
-    {
-      for (std::string read_msg;;)
-      {
-        std::size_t n = co_await asio::async_read_until(socket_,
-            asio::dynamic_buffer(read_msg, 1024), "\n", use_awaitable);
-
-        room_.deliver(read_msg.substr(0, n));
-        read_msg.erase(0, n);
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  awaitable<void> writer()
-  {
-    try
-    {
-      while (socket_.is_open())
-      {
-        if (write_msgs_.empty())
-        {
-          asio::error_code ec;
-          co_await timer_.async_wait(redirect_error(use_awaitable, ec));
-        }
-        else
-        {
-          co_await asio::async_write(socket_,
-              asio::buffer(write_msgs_.front()), use_awaitable);
-          write_msgs_.pop_front();
-        }
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  void stop()
-  {
-    room_.leave(shared_from_this());
-    socket_.close();
-    timer_.cancel();
-  }
-
-  tcp::socket socket_;
-  asio::steady_timer timer_;
-  chat_room& room_;
-  std::deque<std::string> write_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-awaitable<void> listener(tcp::acceptor acceptor)
-{
-  chat_room room;
-
-  for (;;)
-  {
-    std::make_shared<chat_session>(
-        co_await acceptor.async_accept(use_awaitable),
-        room
-      )->start();
-  }
-}
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc < 2)
-    {
-      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
-      return 1;
-    }
-
-    asio::io_context io_context(1);
-
-    for (int i = 1; i < argc; ++i)
-    {
-      unsigned short port = std::atoi(argv[i]);
-      co_spawn(io_context,
-          listener(tcp::acceptor(io_context, {tcp::v4(), port})),
-          detached);
-    }
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server.cpp
deleted file mode 100644
index a953245..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// echo_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable;
-namespace this_coro = asio::this_coro;
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
-# define use_awaitable \
-  asio::use_awaitable_t(__FILE__, __LINE__, __PRETTY_FUNCTION__)
-#endif
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data), use_awaitable);
-      co_await async_write(socket, asio::buffer(data, n), use_awaitable);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp
deleted file mode 100644
index 4a692ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// echo_server_with_as_single_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/experimental/as_single.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::experimental::as_single_t;
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using default_token = as_single_t<use_awaitable_t<>>;
-using tcp_acceptor = default_token::as_default_on_t<tcp::acceptor>;
-using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  char data[1024];
-  for (;;)
-  {
-    auto [e1, nread] = co_await socket.async_read_some(asio::buffer(data));
-    if (nread == 0) break;
-    auto [e2, nwritten] = co_await async_write(socket, asio::buffer(data, nread));
-    if (nwritten != nread) break;
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    if (auto [e, socket] = co_await acceptor.async_accept(); socket.is_open())
-      co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp
deleted file mode 100644
index de162ca..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// echo_server_with_as_tuple_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/as_tuple.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::as_tuple_t;
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using default_token = as_tuple_t<use_awaitable_t<>>;
-using tcp_acceptor = default_token::as_default_on_t<tcp::acceptor>;
-using tcp_socket = default_token::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  char data[1024];
-  for (;;)
-  {
-    auto [e1, nread] = co_await socket.async_read_some(asio::buffer(data));
-    if (nread == 0) break;
-    auto [e2, nwritten] = co_await async_write(socket, asio::buffer(data, nread));
-    if (nwritten != nread) break;
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    if (auto [e, socket] = co_await acceptor.async_accept(); socket.is_open())
-      co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_default.cpp
deleted file mode 100644
index 54344d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_default.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// echo_server_with_default.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable_t;
-using tcp_acceptor = use_awaitable_t<>::as_default_on_t<tcp::acceptor>;
-using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp_socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data));
-      co_await async_write(socket, asio::buffer(data, n));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp_acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    auto socket = co_await acceptor.async_accept();
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred.cpp
deleted file mode 100644
index 54469ba..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// echo_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/deferred.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::deferred;
-using asio::detached;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data), deferred);
-      co_await async_write(socket, asio::buffer(data, n), deferred);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept(deferred);
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp
deleted file mode 100644
index 4c25ae3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// echo_server.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/deferred.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    char data[1024];
-    for (;;)
-    {
-      std::size_t n = co_await socket.async_read_some(asio::buffer(data));
-      co_await async_write(socket, asio::buffer(data, n));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept();
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/refactored_echo_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/refactored_echo_server.cpp
deleted file mode 100644
index dc7b03d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/refactored_echo_server.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// refactored_echo_server.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/write.hpp>
-#include <cstdio>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::use_awaitable;
-namespace this_coro = asio::this_coro;
-
-awaitable<void> echo_once(tcp::socket& socket)
-{
-  char data[128];
-  std::size_t n = co_await socket.async_read_some(asio::buffer(data), use_awaitable);
-  co_await async_write(socket, asio::buffer(data, n), use_awaitable);
-}
-
-awaitable<void> echo(tcp::socket socket)
-{
-  try
-  {
-    for (;;)
-    {
-      // The asynchronous operations to echo a single chunk of data have been
-      // refactored into a separate function. When this function is called, the
-      // operations are still performed in the context of the current
-      // coroutine, and the behaviour is functionally equivalent.
-      co_await echo_once(socket);
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::printf("echo Exception: %s\n", e.what());
-  }
-}
-
-awaitable<void> listener()
-{
-  auto executor = co_await this_coro::executor;
-  tcp::acceptor acceptor(executor, {tcp::v4(), 55555});
-  for (;;)
-  {
-    tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
-    co_spawn(executor, echo(std::move(socket)), detached);
-  }
-}
-
-int main()
-{
-  try
-  {
-    asio::io_context io_context(1);
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    co_spawn(io_context, listener(), detached);
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::printf("Exception: %s\n", e.what());
-  }
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/timeout.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/timeout.cpp
deleted file mode 100644
index 2ffcab7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/coroutines/timeout.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// timeout.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <asio/experimental/awaitable_operators.hpp>
-
-using namespace asio;
-using namespace asio::experimental::awaitable_operators;
-using time_point = std::chrono::steady_clock::time_point;
-using ip::tcp;
-
-awaitable<void> echo(tcp::socket& sock, time_point& deadline)
-{
-  char data[4196];
-  for (;;)
-  {
-    deadline = std::chrono::steady_clock::now() + std::chrono::seconds(10);
-    auto n = co_await sock.async_read_some(buffer(data), use_awaitable);
-    co_await async_write(sock, buffer(data, n), use_awaitable);
-  }
-}
-
-awaitable<void> watchdog(time_point& deadline)
-{
-  steady_timer timer(co_await this_coro::executor);
-  auto now = std::chrono::steady_clock::now();
-  while (deadline > now)
-  {
-    timer.expires_at(deadline);
-    co_await timer.async_wait(use_awaitable);
-    now = std::chrono::steady_clock::now();
-  }
-  throw std::system_error(std::make_error_code(std::errc::timed_out));
-}
-
-awaitable<void> handle_connection(tcp::socket sock)
-{
-  time_point deadline{};
-  co_await (echo(sock, deadline) && watchdog(deadline));
-}
-
-awaitable<void> listen(tcp::acceptor& acceptor)
-{
-  for (;;)
-  {
-    co_spawn(
-        acceptor.get_executor(),
-        handle_connection(co_await acceptor.async_accept(use_awaitable)),
-        detached);
-  }
-}
-
-int main()
-{
-  io_context ctx;
-  tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
-  co_spawn(ctx, listen(acceptor), detached);
-  ctx.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/.gitignore
deleted file mode 100644
index 3a21460..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-completion_executor
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/completion_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/completion_executor.cpp
deleted file mode 100644
index 409be96..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/invocation/completion_executor.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// completion_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio.hpp"
-#include <concepts>
-#include <iostream>
-
-using asio::ip::tcp;
-
-//----------------------------------------------------------------------
-
-// The logging_executor class implements a minimal executor that satisfies the
-// requirements for use as a completion executor. This means it may be bound to
-// a handler using bind_executor.
-class logging_executor
-{
-public:
-  // All executors must be no-throw equality comparable.
-  bool operator==(const logging_executor&) const noexcept = default;
-
-  // All executors must provide a const member function execute().
-  void execute(std::invocable auto handler) const
-  {
-    try
-    {
-      std::cout << "handler invocation starting\n";
-      std::move(handler)();
-      std::cout << "handler invocation complete\n";
-    }
-    catch (...)
-    {
-      std::cout << "handler invocation completed with exception\n";
-      throw;
-    }
-  }
-};
-
-// Confirm that a logging_executor satisfies the executor requirements.
-static_assert(asio::execution::executor<logging_executor>);
-
-// Confirm that a logging_executor can be used as a completion executor.
-static_assert(std::convertible_to<
-    logging_executor, asio::any_completion_executor>);
-
-//----------------------------------------------------------------------
-
-int main()
-{
-  asio::io_context io_context(1);
-
-  // Post a completion handler to be run immediately.
-  asio::post(io_context,
-      asio::bind_executor(logging_executor{},
-        []{ std::cout << "post complete\n"; }));
-
-  // Start an asynchronous accept that will complete immediately.
-  tcp::endpoint endpoint(asio::ip::address_v4::loopback(), 0);
-  tcp::acceptor acceptor(io_context, endpoint);
-  tcp::socket server_socket(io_context);
-  acceptor.async_accept(
-      asio::bind_executor(logging_executor{},
-        [](auto...){ std::cout << "async_accept complete\n"; }));
-  tcp::socket client_socket(io_context);
-  client_socket.connect(acceptor.local_endpoint());
-
-  // Set a timer to expire immediately.
-  asio::steady_timer timer(io_context);
-  timer.expires_at(asio::steady_timer::clock_type::time_point::min());
-  timer.async_wait(
-      asio::bind_executor(logging_executor{},
-        [](auto){ std::cout << "async_wait complete\n"; }));
-
-  io_context.run();
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/.gitignore
deleted file mode 100644
index 0d02e83..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/.gitignore
+++ /dev/null
@@ -1,12 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-c_callback_wrapper
-callback_wrapper
-composed_[0-9]
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/c_callback_wrapper.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/c_callback_wrapper.cpp
deleted file mode 100644
index f4fbe26..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/c_callback_wrapper.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-//
-// c_callback_wrapper.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-#include <memory>
-#include <new>
-
-//------------------------------------------------------------------------------
-
-// This is a mock implementation of a C-based API that uses the function pointer
-// plus void* context idiom for exposing a callback.
-
-void read_input(const char* prompt, void (*cb)(void*, const char*), void* arg)
-{
-  std::thread(
-      [prompt = std::string(prompt), cb, arg]
-      {
-        std::cout << prompt << ": ";
-        std::cout.flush();
-        std::string line;
-        std::getline(std::cin, line);
-        cb(arg, line.c_str());
-      }).detach();
-}
-
-//------------------------------------------------------------------------------
-
-// This is an asynchronous operation that wraps the C-based API.
-
-// To map our completion handler into a function pointer / void* callback, we
-// need to allocate some state that will live for the duration of the
-// operation. A pointer to this state will be passed to the C-based API.
-template <asio::completion_handler_for<void(std::string)> Handler>
-class read_input_state
-{
-public:
-  read_input_state(Handler&& handler)
-    : handler_(std::move(handler)),
-      work_(asio::make_work_guard(handler_))
-  {
-  }
-
-  // Create the state using the handler's associated allocator.
-  static read_input_state* create(Handler&& handler)
-  {
-    // A unique_ptr deleter that is used to destroy uninitialised objects.
-    struct deleter
-    {
-      // Get the handler's associated allocator type. If the handler does not
-      // specify an associated allocator, we will use a recycling allocator as
-      // the default. As the associated allocator is a proto-allocator, we must
-      // rebind it to the correct type before we can use it to allocate objects.
-      typename std::allocator_traits<
-        asio::associated_allocator_t<Handler,
-          asio::recycling_allocator<void>>>::template
-            rebind_alloc<read_input_state> alloc;
-
-      void operator()(read_input_state* ptr)
-      {
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-      }
-    } d{asio::get_associated_allocator(handler,
-          asio::recycling_allocator<void>())};
-
-    // Allocate memory for the state.
-    std::unique_ptr<read_input_state, deleter> uninit_ptr(
-        std::allocator_traits<decltype(d.alloc)>::allocate(d.alloc, 1), d);
-
-    // Construct the state into the newly allocated memory. This might throw.
-    read_input_state* ptr =
-      new (uninit_ptr.get()) read_input_state(std::move(handler));
-
-    // Release ownership of the memory and return the newly allocated state.
-    uninit_ptr.release();
-    return ptr;
-  }
-
-  static void callback(void* arg, const char* result)
-  {
-    read_input_state* self = static_cast<read_input_state*>(arg);
-
-    // A unique_ptr deleter that is used to destroy initialised objects.
-    struct deleter
-    {
-      // Get the handler's associated allocator type. If the handler does not
-      // specify an associated allocator, we will use a recycling allocator as
-      // the default. As the associated allocator is a proto-allocator, we must
-      // rebind it to the correct type before we can use it to allocate objects.
-      typename std::allocator_traits<
-        asio::associated_allocator_t<Handler,
-          asio::recycling_allocator<void>>>::template
-            rebind_alloc<read_input_state> alloc;
-
-      void operator()(read_input_state* ptr)
-      {
-        std::allocator_traits<decltype(alloc)>::destroy(alloc, ptr);
-        std::allocator_traits<decltype(alloc)>::deallocate(alloc, ptr, 1);
-      }
-    } d{asio::get_associated_allocator(self->handler_,
-          asio::recycling_allocator<void>())};
-
-    // To conform to the rules regarding asynchronous operations and memory
-    // allocation, we must make a copy of the state and deallocate the memory
-    // before dispatching the completion handler.
-    std::unique_ptr<read_input_state, deleter> state_ptr(self, d);
-    read_input_state state(std::move(*self));
-    state_ptr.reset();
-
-    // Dispatch the completion handler through the handler's associated
-    // executor, using the handler's associated allocator.
-    asio::dispatch(state.work_.get_executor(),
-        asio::bind_allocator(d.alloc,
-          [
-            handler = std::move(state.handler_),
-            result = std::string(result)
-          ]() mutable
-          {
-            std::move(handler)(result);
-          }));
-  }
-
-private:
-  Handler handler_;
-
-  // According to the rules for asynchronous operations, we need to track
-  // outstanding work against the handler's associated executor until the
-  // asynchronous operation is complete.
-  asio::executor_work_guard<
-    asio::associated_executor_t<Handler>> work_;
-};
-
-// The initiating function for the asynchronous operation.
-template <asio::completion_token_for<void(std::string)> CompletionToken>
-auto async_read_input(const std::string& prompt, CompletionToken&& token)
-{
-  // Define a function object that contains the code to launch the asynchronous
-  // operation. This is passed the concrete completion handler, followed by any
-  // additional arguments that were passed through the call to async_initiate.
-  auto init = [](
-      asio::completion_handler_for<void(std::string)> auto handler,
-      const std::string& prompt)
-  {
-    // The body of the initiation function object creates the long-lived state
-    // and passes it to the C-based API, along with the function pointer.
-    using state_type = read_input_state<decltype(handler)>;
-    read_input(prompt.c_str(), &state_type::callback,
-        state_type::create(std::move(handler)));
-  };
-
-  // The async_initiate function is used to transform the supplied completion
-  // token to the completion handler. When calling this function we explicitly
-  // specify the completion signature of the operation. We must also return the
-  // result of the call since the completion token may produce a return value,
-  // such as a future.
-  return asio::async_initiate<CompletionToken, void(std::string)>(
-      init, // First, pass the function object that launches the operation,
-      token, // then the completion token that will be transformed to a handler,
-      prompt); // and, finally, any additional arguments to the function object.
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  async_read_input("Enter your name",
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_read_input("Enter your name", asio::deferred);
-
-  // Launch our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  std::move(op)(
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::string> f =
-    async_read_input("Enter your name", asio::use_future);
-
-  std::string result = f.get();
-  std::cout << "Hello " << result << "\n";
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/callback_wrapper.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/callback_wrapper.cpp
deleted file mode 100644
index f8f37b4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/callback_wrapper.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-//
-// callback_wrapper.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio.hpp>
-#include <iostream>
-
-//------------------------------------------------------------------------------
-
-// This is a mock implementation of an API that uses a move-only function object
-// for exposing a callback. The callback has the signature void(std::string).
-
-template <typename Callback>
-void read_input(const std::string& prompt, Callback cb)
-{
-  std::thread(
-      [prompt, cb = std::move(cb)]() mutable
-      {
-        std::cout << prompt << ": ";
-        std::cout.flush();
-        std::string line;
-        std::getline(std::cin, line);
-        std::move(cb)(std::move(line));
-      }).detach();
-}
-
-//------------------------------------------------------------------------------
-
-// This is an asynchronous operation that wraps the callback-based API.
-
-// The initiating function for the asynchronous operation.
-template <asio::completion_token_for<void(std::string)> CompletionToken>
-auto async_read_input(const std::string& prompt, CompletionToken&& token)
-{
-  // Define a function object that contains the code to launch the asynchronous
-  // operation. This is passed the concrete completion handler, followed by any
-  // additional arguments that were passed through the call to async_initiate.
-  auto init = [](
-      asio::completion_handler_for<void(std::string)> auto handler,
-      const std::string& prompt)
-  {
-    // According to the rules for asynchronous operations, we need to track
-    // outstanding work against the handler's associated executor until the
-    // asynchronous operation is complete.
-    auto work = asio::make_work_guard(handler);
-
-    // Launch the operation with a callback that will receive the result and
-    // pass it through to the asynchronous operation's completion handler.
-    read_input(prompt,
-        [
-          handler = std::move(handler),
-          work = std::move(work)
-        ](std::string result) mutable
-        {
-          // Get the handler's associated allocator. If the handler does not
-          // specify an allocator, use the recycling allocator as the default.
-          auto alloc = asio::get_associated_allocator(
-              handler, asio::recycling_allocator<void>());
-
-          // Dispatch the completion handler through the handler's associated
-          // executor, using the handler's associated allocator.
-          asio::dispatch(work.get_executor(),
-              asio::bind_allocator(alloc,
-                [
-                  handler = std::move(handler),
-                  result = std::string(result)
-                ]() mutable
-                {
-                  std::move(handler)(result);
-                }));
-        });
-  };
-
-  // The async_initiate function is used to transform the supplied completion
-  // token to the completion handler. When calling this function we explicitly
-  // specify the completion signature of the operation. We must also return the
-  // result of the call since the completion token may produce a return value,
-  // such as a future.
-  return asio::async_initiate<CompletionToken, void(std::string)>(
-      init, // First, pass the function object that launches the operation,
-      token, // then the completion token that will be transformed to a handler,
-      prompt); // and, finally, any additional arguments to the function object.
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to specify an associated executor.
-  async_read_input("Enter your name",
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  auto op = async_read_input("Enter your name", asio::deferred);
-
-  // Launch our asynchronous operation using a lambda as a callback. We will use
-  // an io_context to obtain an associated executor.
-  std::move(op)(
-      asio::bind_executor(io_context,
-        [](const std::string& result)
-        {
-          std::cout << "Hello " << result << "\n";
-        }));
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::string> f =
-    async_read_input("Enter your name", asio::use_future);
-
-  std::string result = f.get();
-  std::cout << "Hello " << result << "\n";
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_1.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_1.cpp
deleted file mode 100644
index e7f795e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_1.cpp
+++ /dev/null
@@ -1,157 +0,0 @@
-//
-// composed_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-//------------------------------------------------------------------------------
-
-// This is the simplest example of a composed asynchronous operation, where we
-// simply repackage an existing operation. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <
-  asio::completion_token_for<void(std::error_code, std::size_t)>
-    CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of our underlying asynchronous operation.
-{
-  // When delegating to the underlying operation we must take care to perfectly
-  // forward the completion token. This ensures that our operation works
-  // correctly with move-only function objects as callbacks, as well as other
-  // completion token types.
-  return asio::async_write(socket,
-      asio::buffer(message, std::strlen(message)),
-      std::forward<CompletionToken>(token));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_message(
-      socket, "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_2.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_2.cpp
deleted file mode 100644
index ada029d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_2.cpp
+++ /dev/null
@@ -1,225 +0,0 @@
-//
-// composed_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This next simplest example of a composed asynchronous operation involves
-// repackaging multiple operations but choosing to invoke just one of them. All
-// of these underlying operations have the same completion signature. The
-// asynchronous operation requirements are met by delegating responsibility to
-// the underlying operations.
-
-template <
-  asio::completion_token_for<void(std::error_code, std::size_t)>
-    CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, bool allow_partial_write,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is void.
-  // However, when the completion token is asio::yield_context (used for
-  // stackful coroutines) the return type would be std::size_t, and when the
-  // completion token is asio::use_future it would be std::future<std::size_t>.
-  // When the completion token is asio::deferred, the return type differs for
-  // each asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error, std::size_t)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](
-      asio::completion_handler_for<void(std::error_code, std::size_t)>
-        auto&& completion_handler,
-      tcp::socket& socket,
-      const char* message,
-      bool allow_partial_write)
-  {
-    if (allow_partial_write)
-    {
-      // When delegating to an underlying operation we must take care to
-      // perfectly forward the completion handler. This ensures that our
-      // operation works correctly with move-only function objects as
-      // callbacks.
-      return socket.async_write_some(
-          asio::buffer(message, std::strlen(message)),
-          std::forward<decltype(completion_handler)>(completion_handler));
-    }
-    else
-    {
-      // As above, we must perfectly forward the completion handler when calling
-      // the alternate underlying operation.
-      return asio::async_write(socket,
-          asio::buffer(message, std::strlen(message)),
-          std::forward<decltype(completion_handler)>(completion_handler));
-    }
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code, std::size_t)>(
-      initiation, token, std::ref(socket), message, allow_partial_write);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n", false,
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_message(
-      socket, "Testing deferred\r\n", false, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error, std::size_t n)
-      {
-        if (!error)
-        {
-          std::cout << n << " bytes transferred\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<std::size_t> f = async_write_message(
-      socket, "Testing future\r\n", false, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    std::size_t n = f.get();
-    std::cout << n << " bytes transferred\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_3.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_3.cpp
deleted file mode 100644
index 46436a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_3.cpp
+++ /dev/null
@@ -1,232 +0,0 @@
-//
-// composed_3.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](
-      asio::completion_handler_for<void(std::error_code)>
-        auto&& completion_handler,
-      tcp::socket& socket,
-      const char* message)
-  {
-    // The async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // This differs from our operation's signature in that it is also passed
-    // the number of bytes transferred as an argument of type std::size_t. We
-    // will adapt our completion handler to async_write's completion handler
-    // signature by using std::bind, which drops the additional argument.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    asio::async_write(socket,
-        asio::buffer(message, std::strlen(message)),
-        asio::bind_executor(executor,
-          std::bind(std::forward<decltype(completion_handler)>(
-              completion_handler), std::placeholders::_1)));
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "Testing callback\r\n",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_message(
-      socket, "Testing deferred\r\n", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  // Get the result of the operation.
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_4.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_4.cpp
deleted file mode 100644
index 069f57c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_4.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-//
-// composed_4.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/bind_executor.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. We will also intercept an empty
-// message as an invalid argument, and propagate the corresponding error to the
-// user. The asynchronous operation requirements are met by delegating
-// responsibility to the underlying operation.
-
-template <
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const char* message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](
-      asio::completion_handler_for<void(std::error_code)>
-        auto&& completion_handler,
-      tcp::socket& socket,
-      const char* message)
-  {
-    // The post operation has a completion handler signature of:
-    //
-    //   void()
-    //
-    // and the async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // Both of these operations' completion handler signatures differ from our
-    // operation's completion handler signature. We will adapt our completion
-    // handler to these signatures by using std::bind, which drops the
-    // additional arguments.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    std::size_t length = std::strlen(message);
-    if (length == 0)
-    {
-      asio::post(
-          asio::bind_executor(executor,
-            std::bind(std::forward<decltype(completion_handler)>(
-                completion_handler), asio::error::invalid_argument)));
-    }
-    else
-    {
-      asio::async_write(socket,
-          asio::buffer(message, length),
-          asio::bind_executor(executor,
-            std::bind(std::forward<decltype(completion_handler)>(
-                completion_handler), std::placeholders::_1)));
-    }
-  };
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, "",
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op =
-    async_write_message(socket, "", asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, "", asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_5.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_5.cpp
deleted file mode 100644
index bec83ec..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_5.cpp
+++ /dev/null
@@ -1,284 +0,0 @@
-//
-// composed_5.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation automatically serialises a message, using its I/O
-// streams insertion operator, before sending it on the socket. To do this, it
-// must allocate a buffer for the encoded message and ensure this buffer's
-// validity until the underlying async_write operation completes.
-
-template <typename T,
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_message(tcp::socket& socket,
-    const T& message, CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](
-      asio::completion_handler_for<void(std::error_code)>
-        auto&& completion_handler,
-      tcp::socket& socket,
-      std::unique_ptr<std::string> encoded_message)
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object, rather than
-    // using a lambda or std::bind.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket so
-      // that it can obtain the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The user-supplied completion handler.
-      typename std::decay<decltype(completion_handler)>::type handler_;
-
-      // The function call operator matches the completion signature of the
-      // async_write operation.
-      void operator()(const std::error_code& error, std::size_t /*n*/)
-      {
-        // Deallocate the encoded message before calling the user-supplied
-        // completion handler.
-        encoded_message_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        // The arguments must match the completion signature of our composed
-        // operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{socket, std::move(encoded_message),
-          std::forward<decltype(completion_handler)>(completion_handler)});
-  };
-
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket),
-      std::move(encoded_message));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_message(socket, 123456,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_message(
-      socket, std::string("abcdef"), asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_message(
-      socket, 654.321, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_6.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_6.cpp
deleted file mode 100644
index da89886..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_6.cpp
+++ /dev/null
@@ -1,346 +0,0 @@
-//
-// composed_6.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/deferred.hpp>
-#include <asio/executor_work_guard.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_initiate function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-template <typename T,
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_initiate.
-{
-  // In addition to determining the mechanism by which an asynchronous
-  // operation delivers its result, a completion token also determines the time
-  // when the operation commences. For example, when the completion token is a
-  // simple callback the operation commences before the initiating function
-  // returns. However, if the completion token's delivery mechanism uses a
-  // future, we might instead want to defer initiation of the operation until
-  // the returned future object is waited upon.
-  //
-  // To enable this, when implementing an asynchronous operation we must
-  // package the initiation step as a function object. The initiation function
-  // object's call operator is passed the concrete completion handler produced
-  // by the completion token. This completion handler matches the asynchronous
-  // operation's completion handler signature, which in this example is:
-  //
-  //   void(std::error_code error)
-  //
-  // The initiation function object also receives any additional arguments
-  // required to start the operation. (Note: We could have instead passed these
-  // arguments in the lambda capture set. However, we should prefer to
-  // propagate them as function call arguments as this allows the completion
-  // token to optimise how they are passed. For example, a lazy future which
-  // defers initiation would need to make a decay-copy of the arguments, but
-  // when using a simple callback the arguments can be trivially forwarded
-  // straight through.)
-  auto initiation = [](
-      asio::completion_handler_for<void(std::error_code)>
-        auto&& completion_handler,
-      tcp::socket& socket,
-      std::unique_ptr<std::string> encoded_message,
-      std::size_t repeat_count,
-      std::unique_ptr<asio::steady_timer> delay_timer)
-  {
-    // In this example, the composed operation's intermediate completion
-    // handler is implemented as a hand-crafted function object.
-    struct intermediate_completion_handler
-    {
-      // The intermediate completion handler holds a reference to the socket as
-      // it is used for multiple async_write operations, as well as for
-      // obtaining the I/O executor (see get_executor below).
-      tcp::socket& socket_;
-
-      // The allocated buffer for the encoded message. The std::unique_ptr
-      // smart pointer is move-only, and as a consequence our intermediate
-      // completion handler is also move-only.
-      std::unique_ptr<std::string> encoded_message_;
-
-      // The repeat count remaining.
-      std::size_t repeat_count_;
-
-      // A steady timer used for introducing a delay.
-      std::unique_ptr<asio::steady_timer> delay_timer_;
-
-      // To manage the cycle between the multiple underlying asychronous
-      // operations, our intermediate completion handler is implemented as a
-      // state machine.
-      enum { starting, waiting, writing } state_;
-
-      // As our composed operation performs multiple underlying I/O operations,
-      // we should maintain a work object against the I/O executor. This tells
-      // the I/O executor that there is still more work to come in the future.
-      asio::executor_work_guard<tcp::socket::executor_type> io_work_;
-
-      // The user-supplied completion handler, called once only on completion
-      // of the entire composed operation.
-      typename std::decay<decltype(completion_handler)>::type handler_;
-
-      // By having a default value for the second argument, this function call
-      // operator matches the completion signature of both the async_write and
-      // steady_timer::async_wait operations.
-      void operator()(const std::error_code& error, std::size_t = 0)
-      {
-        if (!error)
-        {
-          switch (state_)
-          {
-          case starting:
-          case writing:
-            if (repeat_count_ > 0)
-            {
-              --repeat_count_;
-              state_ = waiting;
-              delay_timer_->expires_after(std::chrono::seconds(1));
-              delay_timer_->async_wait(std::move(*this));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state_ = writing;
-            asio::async_write(socket_,
-                asio::buffer(*encoded_message_), std::move(*this));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // We no longer have any future work coming for the I/O executor.
-        io_work_.reset();
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message_.reset();
-        delay_timer_.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        handler_(error);
-      }
-
-      // It is essential to the correctness of our composed operation that we
-      // preserve the executor of the user-supplied completion handler. With a
-      // hand-crafted function object we can do this by defining a nested type
-      // executor_type and member function get_executor. These obtain the
-      // completion handler's associated executor, and default to the I/O
-      // executor - in this case the executor of the socket - if the completion
-      // handler does not have its own.
-      using executor_type = asio::associated_executor_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          tcp::socket::executor_type>;
-
-      executor_type get_executor() const noexcept
-      {
-        return asio::get_associated_executor(
-            handler_, socket_.get_executor());
-      }
-
-      // Although not necessary for correctness, we may also preserve the
-      // allocator of the user-supplied completion handler. This is achieved by
-      // defining a nested type allocator_type and member function
-      // get_allocator. These obtain the completion handler's associated
-      // allocator, and default to std::allocator<void> if the completion
-      // handler does not have its own.
-      using allocator_type = asio::associated_allocator_t<
-          typename std::decay<decltype(completion_handler)>::type,
-          std::allocator<void>>;
-
-      allocator_type get_allocator() const noexcept
-      {
-        return asio::get_associated_allocator(
-            handler_, std::allocator<void>{});
-      }
-    };
-
-    // Initiate the underlying async_write operation using our intermediate
-    // completion handler.
-    auto encoded_message_buffer = asio::buffer(*encoded_message);
-    asio::async_write(socket, encoded_message_buffer,
-        intermediate_completion_handler{
-          socket, std::move(encoded_message),
-          repeat_count, std::move(delay_timer),
-          intermediate_completion_handler::starting,
-          asio::make_work_guard(socket.get_executor()),
-          std::forward<decltype(completion_handler)>(completion_handler)});
-  };
-
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_initiate function takes:
-  //
-  // - our initiation function object,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any additional arguments we need to initiate the operation.
-  //
-  // It then asks the completion token to create a completion handler (i.e. a
-  // callback) with the specified signature, and invoke the initiation function
-  // object with this completion handler as well as the additional arguments.
-  // The return value of async_initiate is the result of our operation's
-  // initiating function.
-  //
-  // Note that we wrap non-const reference arguments in std::reference_wrapper
-  // to prevent incorrect decay-copies of these objects.
-  return asio::async_initiate<
-    CompletionToken, void(std::error_code)>(
-      initiation, token, std::ref(socket),
-      std::move(encoded_message), repeat_count,
-      std::move(delay_timer));
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_messages(
-      socket, "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_7.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_7.cpp
deleted file mode 100644
index 9ae44c7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_7.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-//
-// composed_7.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-template <typename T,
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_compose.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // To manage the cycle between the multiple underlying asychronous
-  // operations, our implementation is a state machine.
-  enum { starting, waiting, writing };
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a state
-  // machine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // To manage the cycle between the multiple underlying asychronous
-        // operations, our implementation is a state machine.
-        state = starting
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        if (!error)
-        {
-          switch (state)
-          {
-          case starting:
-          case writing:
-            if (repeat_count > 0)
-            {
-              --repeat_count;
-              state = waiting;
-              delay_timer->expires_after(std::chrono::seconds(1));
-              delay_timer->async_wait(std::move(self));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state = writing;
-            asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message.reset();
-        delay_timer.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        self.complete(error);
-      },
-      token, socket);
-}
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_messages(
-      socket, "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_8.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_8.cpp
deleted file mode 100644
index 2735d74..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/operations/composed_8.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-//
-// composed_8.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/compose.hpp>
-#include <asio/coroutine.hpp>
-#include <asio/deferred.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations,
-// using asio's stackless coroutines support to express the flow of control. It
-// automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-#include <asio/yield.hpp>
-
-template <typename T,
-  asio::completion_token_for<void(std::error_code)> CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    CompletionToken&& token)
-  // The return type of the initiating function is deduced from the combination
-  // of:
-  //
-  // - the CompletionToken type,
-  // - the completion handler signature, and
-  // - the asynchronous operation's initiation function object.
-  //
-  // When the completion token is a simple callback, the return type is always
-  // void. In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>. When
-  // the completion token is asio::deferred, the return type differs for each
-  // asynchronous operation.
-  //
-  // In C++20 we can omit the return type as it is automatically deduced from
-  // the return type of asio::async_compose.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a stackless
-  // coroutine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // The coroutine state.
-        coro = asio::coroutine()
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        reenter (coro)
-        {
-          while (repeat_count > 0)
-          {
-            --repeat_count;
-
-            delay_timer->expires_after(std::chrono::seconds(1));
-            yield delay_timer->async_wait(std::move(self));
-            if (error)
-              break;
-
-            yield asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            if (error)
-              break;
-          }
-
-          // Deallocate the encoded message and delay timer before calling the
-          // user-supplied completion handler.
-          encoded_message.reset();
-          delay_timer.reset();
-
-          // Call the user-supplied handler with the result of the operation.
-          self.complete(error);
-        }
-      },
-      token, socket);
-}
-
-#include <asio/unyield.hpp>
-
-//------------------------------------------------------------------------------
-
-void test_callback()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using a lambda as a callback.
-  async_write_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_deferred()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the deferred completion token. This
-  // token causes the operation's initiating function to package up the
-  // operation with its arguments to return a function object, which may then be
-  // used to launch the asynchronous operation.
-  asio::async_operation auto op = async_write_messages(
-      socket, "Testing deferred\r\n", 5, asio::deferred);
-
-  // Launch the operation using a lambda as a callback.
-  std::move(op)(
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages sent\n";
-        }
-        else
-        {
-          std::cout << "Error: " << error.message() << "\n";
-        }
-      });
-
-  io_context.run();
-}
-
-//------------------------------------------------------------------------------
-
-void test_future()
-{
-  asio::io_context io_context;
-
-  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
-  tcp::socket socket = acceptor.accept();
-
-  // Test our asynchronous operation using the use_future completion token.
-  // This token causes the operation's initiating function to return a future,
-  // which may be used to synchronously wait for the result of the operation.
-  std::future<void> f = async_write_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_deferred();
-  test_future();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/.gitignore
deleted file mode 100644
index 9e8415a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/.gitignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-type_erasure
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/line_reader.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/line_reader.hpp
deleted file mode 100644
index fa19aec..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/line_reader.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// line_reader.hpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef LINE_READER_HPP
-#define LINE_READER_HPP
-
-#include <asio/any_completion_handler.hpp>
-#include <asio/async_result.hpp>
-#include <asio/error.hpp>
-#include <string>
-
-class line_reader
-{
-public:
-  virtual ~line_reader() {}
-
-  template <typename CompletionToken>
-  auto async_read_line(std::string prompt, CompletionToken&& token)
-  {
-    return asio::async_initiate<CompletionToken, void(asio::error_code, std::string)>(
-        [](auto handler, line_reader* self, std::string prompt)
-        {
-          self->async_read_line_impl(std::move(prompt), std::move(handler));
-        }, token, this, prompt);
-  }
-
-private:
-  virtual void async_read_line_impl(std::string prompt,
-      asio::any_completion_handler<void(asio::error_code, std::string)> handler) = 0;
-};
-
-#endif // LINE_READER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/main.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/main.cpp
deleted file mode 100644
index 1b80dcd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/main.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// main.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "line_reader.hpp"
-#include "sleep.hpp"
-#include "stdin_line_reader.hpp"
-#include <asio/co_spawn.hpp>
-#include <asio/detached.hpp>
-#include <asio/io_context.hpp>
-#include <asio/use_awaitable.hpp>
-#include <iostream>
-
-asio::awaitable<void> do_read(line_reader& reader)
-{
-  for (int i = 0; i < 10; ++i)
-  {
-    std::cout << co_await reader.async_read_line("Enter something: ", asio::use_awaitable);
-    co_await async_sleep(co_await asio::this_coro::executor, std::chrono::seconds(1), asio::use_awaitable);
-  }
-}
-
-int main()
-{
-  asio::io_context ctx{1};
-  stdin_line_reader reader{ctx.get_executor()};
-  co_spawn(ctx, do_read(reader), asio::detached);
-  ctx.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.cpp
deleted file mode 100644
index b605866..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// sleep.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "sleep.hpp"
-#include <asio/consign.hpp>
-#include <asio/steady_timer.hpp>
-#include <memory>
-
-void async_sleep_impl(
-    asio::any_completion_handler<void(std::error_code)> handler,
-    asio::any_io_executor ex, std::chrono::nanoseconds duration)
-{
-  auto timer = std::make_shared<asio::steady_timer>(ex, duration);
-  timer->async_wait(asio::consign(std::move(handler), timer));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.hpp
deleted file mode 100644
index 7e057fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/sleep.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// sleep.hpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef SLEEP_HPP
-#define SLEEP_HPP
-
-#include <asio/any_completion_handler.hpp>
-#include <asio/any_io_executor.hpp>
-#include <asio/async_result.hpp>
-#include <asio/error.hpp>
-#include <chrono>
-
-void async_sleep_impl(
-    asio::any_completion_handler<void(std::error_code)> handler,
-    asio::any_io_executor ex, std::chrono::nanoseconds duration);
-
-template <typename CompletionToken>
-inline auto async_sleep(asio::any_io_executor ex,
-    std::chrono::nanoseconds duration, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(std::error_code)>(
-      async_sleep_impl, token, std::move(ex), duration);
-}
-
-#endif // SLEEP_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.cpp
deleted file mode 100644
index 7467e82..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// stdin_line_reader.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "stdin_line_reader.hpp"
-#include <asio/deferred.hpp>
-#include <asio/read_until.hpp>
-#include <iostream>
-
-stdin_line_reader::stdin_line_reader(asio::any_io_executor ex)
-  : stdin_(ex, ::dup(STDIN_FILENO))
-{
-}
-
-void stdin_line_reader::async_read_line_impl(std::string prompt,
-    asio::any_completion_handler<void(asio::error_code, std::string)> handler)
-{
-  std::cout << prompt;
-  std::cout.flush();
-
-  asio::async_read_until(stdin_, asio::dynamic_buffer(buffer_), '\n',
-      asio::deferred(
-        [this](asio::error_code ec, std::size_t n)
-        {
-          if (!ec)
-          {
-            std::string result = buffer_.substr(0, n);
-            buffer_.erase(0, n);
-            return asio::deferred.values(ec, std::move(result));
-          }
-          else
-          {
-            return asio::deferred.values(ec, std::string{});
-          }
-        }
-      )
-    )(std::move(handler));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.hpp
deleted file mode 100644
index fd54f70..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/examples/cpp20/type_erasure/stdin_line_reader.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// stdin_line_reader.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef STDIN_LINE_READER_HPP
-#define STDIN_LINE_READER_HPP
-
-#include "line_reader.hpp"
-#include <asio/posix/stream_descriptor.hpp>
-
-class stdin_line_reader : public line_reader
-{
-public:
-  explicit stdin_line_reader(asio::any_io_executor ex);
-
-private:
-  void async_read_line_impl(std::string prompt,
-      asio::any_completion_handler<void(asio::error_code, std::string)> handler) override;
-
-  asio::posix::stream_descriptor stdin_;
-  std::string buffer_;
-};
-
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/.gitignore
deleted file mode 100644
index a35502b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_test
-*.ilk
-*.manifest
-*.pdb
-*.tds
-*.winmd
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/Makefile.am
deleted file mode 100644
index c051944..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/Makefile.am
+++ /dev/null
@@ -1,671 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-if SEPARATE_COMPILATION
-noinst_LIBRARIES = libasio.a
-libasio_a_SOURCES = ../asio.cpp
-if HAVE_OPENSSL
-libasio_a_SOURCES += ../asio_ssl.cpp
-endif
-LDADD = libasio.a
-endif
-
-SUBDIRS = properties
-
-check_PROGRAMS = \
-	unit/any_completion_executor \
-	unit/any_completion_handler \
-	unit/any_io_executor \
-	unit/append \
-	unit/as_tuple \
-	unit/associated_allocator \
-	unit/associated_cancellation_slot \
-	unit/associated_executor \
-	unit/associated_immediate_executor \
-	unit/associator \
-	unit/async_result \
-	unit/awaitable \
-	unit/basic_datagram_socket \
-	unit/basic_deadline_timer \
-	unit/basic_file \
-	unit/basic_random_access_file \
-	unit/basic_raw_socket \
-	unit/basic_readable_pipe \
-	unit/basic_seq_packet_socket \
-	unit/basic_serial_port \
-	unit/basic_signal_set \
-	unit/basic_socket \
-	unit/basic_socket_acceptor \
-	unit/basic_stream_file \
-	unit/basic_stream_socket \
-	unit/basic_streambuf \
-	unit/basic_waitable_timer \
-	unit/basic_writable_pipe \
-	unit/bind_allocator \
-	unit/bind_cancellation_slot \
-	unit/bind_executor \
-	unit/bind_immediate_executor \
-	unit/buffered_read_stream \
-	unit/buffered_stream \
-	unit/buffered_write_stream \
-	unit/buffer \
-	unit/buffer_registration \
-	unit/buffers_iterator \
-	unit/cancel_after \
-	unit/cancel_at \
-	unit/cancellation_signal \
-	unit/cancellation_state \
-	unit/cancellation_type \
-	unit/co_composed \
-	unit/co_spawn \
-	unit/completion_condition \
-	unit/compose \
-	unit/composed \
-	unit/connect \
-	unit/connect_pipe \
-	unit/consign \
-	unit/coroutine \
-	unit/deadline_timer \
-	unit/defer \
-	unit/deferred \
-	unit/detached \
-	unit/dispatch \
-	unit/error \
-	unit/execution/any_executor \
-	unit/execution/blocking \
-	unit/execution/blocking_adaptation \
-	unit/execution/context_as \
-	unit/execution/executor \
-	unit/execution/invocable_archetype \
-	unit/execution/mapping \
-	unit/execution/outstanding_work \
-	unit/execution/prefer_only \
-	unit/execution/relationship \
-	unit/execution_context \
-	unit/executor \
-	unit/executor_work_guard \
-	unit/file_base \
-	unit/generic/basic_endpoint \
-	unit/generic/datagram_protocol \
-	unit/generic/raw_protocol \
-	unit/generic/seq_packet_protocol \
-	unit/generic/stream_protocol \
-	unit/high_resolution_timer \
-	unit/immediate \
-	unit/io_context \
-	unit/io_context_strand \
-	unit/ip/address \
-	unit/ip/address_v4 \
-	unit/ip/address_v4_iterator \
-	unit/ip/address_v4_range \
-	unit/ip/address_v6 \
-	unit/ip/address_v6_iterator \
-	unit/ip/address_v6_range \
-	unit/ip/basic_endpoint \
-	unit/ip/basic_resolver \
-	unit/ip/basic_resolver_entry \
-	unit/ip/basic_resolver_iterator \
-	unit/ip/basic_resolver_query \
-	unit/ip/host_name \
-	unit/ip/icmp \
-	unit/ip/multicast \
-	unit/ip/network_v4 \
-	unit/ip/network_v6 \
-	unit/ip/resolver_query_base \
-	unit/ip/tcp \
-	unit/ip/udp \
-	unit/ip/unicast \
-	unit/ip/v6_only \
-	unit/is_read_buffered \
-	unit/is_write_buffered \
-	unit/local/basic_endpoint \
-	unit/local/connect_pair \
-	unit/local/datagram_protocol \
-	unit/local/seq_packet_protocol \
-	unit/local/stream_protocol \
-	unit/packaged_task \
-	unit/placeholders \
-	unit/posix/basic_descriptor \
-	unit/posix/basic_stream_descriptor \
-	unit/posix/descriptor \
-	unit/posix/descriptor_base \
-	unit/posix/stream_descriptor \
-	unit/post \
-	unit/prepend \
-	unit/random_access_file \
-	unit/read \
-	unit/read_at \
-	unit/read_until \
-	unit/readable_pipe \
-	unit/recycling_allocator \
-	unit/redirect_error \
-	unit/registered_buffer \
-	unit/serial_port \
-	unit/serial_port_base \
-	unit/signal_set \
-	unit/signal_set_base \
-	unit/socket_base \
-	unit/static_thread_pool \
-	unit/steady_timer \
-	unit/strand \
-	unit/stream_file \
-	unit/streambuf \
-	unit/system_context \
-	unit/system_executor \
-	unit/system_timer \
-	unit/this_coro \
-	unit/thread \
-	unit/thread_pool \
-	unit/time_traits \
-	unit/ts/buffer \
-	unit/ts/executor \
-	unit/ts/internet \
-	unit/ts/io_context \
-	unit/ts/net \
-	unit/ts/netfwd \
-	unit/ts/socket \
-	unit/ts/timer \
-	unit/use_awaitable \
-	unit/use_future \
-	unit/uses_executor \
-	unit/wait_traits \
-	unit/windows/basic_object_handle \
-	unit/windows/basic_overlapped_handle \
-	unit/windows/basic_random_access_handle \
-	unit/windows/basic_stream_handle \
-	unit/windows/object_handle \
-	unit/windows/overlapped_handle \
-	unit/windows/overlapped_ptr \
-	unit/windows/random_access_handle \
-	unit/windows/stream_handle \
-	unit/writable_pipe \
-	unit/write \
-	unit/write_at
-
-if !STANDALONE
-noinst_PROGRAMS = \
-	latency/tcp_client \
-	latency/tcp_server \
-	latency/udp_client \
-	latency/udp_server \
-	performance/client \
-	performance/server
-endif
-
-if HAVE_CXX11
-check_PROGRAMS += \
-	unit/experimental/basic_channel \
-	unit/experimental/basic_concurrent_channel \
-	unit/experimental/channel \
-	unit/experimental/channel_traits \
-	unit/experimental/concurrent_channel \
-	unit/experimental/parallel_group
-endif
-
-if HAVE_CXX20
-check_PROGRAMS += \
-	unit/experimental/promise
-
-if HAVE_COROUTINES
-check_PROGRAMS += \
-	unit/experimental/awaitable_operators \
-	unit/experimental/co_composed \
-	unit/experimental/coro/allocator \
-	unit/experimental/coro/cancel \
-	unit/experimental/coro/co_spawn \
-	unit/experimental/coro/exception \
-	unit/experimental/coro/executor \
-	unit/experimental/coro/partial \
-	unit/experimental/coro/simple_test \
-	unit/experimental/coro/stack_test \
-	unit/experimental/coro/use_coro
-endif
-endif
-
-if HAVE_OPENSSL
-check_PROGRAMS += \
-	unit/ssl/context_base \
-	unit/ssl/context \
-	unit/ssl/error \
-	unit/ssl/host_name_verification \
-	unit/ssl/rfc2818_verification \
-	unit/ssl/stream_base \
-	unit/ssl/stream
-endif
-
-TESTS = \
-	unit/any_completion_executor \
-	unit/any_completion_handler \
-	unit/any_io_executor \
-	unit/append \
-	unit/as_tuple \
-	unit/associated_allocator \
-	unit/associated_cancellation_slot \
-	unit/associated_executor \
-	unit/associated_immediate_executor \
-	unit/associator \
-	unit/async_result \
-	unit/awaitable \
-	unit/basic_datagram_socket \
-	unit/basic_deadline_timer \
-	unit/basic_file \
-	unit/basic_random_access_file \
-	unit/basic_raw_socket \
-	unit/basic_readable_pipe \
-	unit/basic_seq_packet_socket \
-	unit/basic_serial_port \
-	unit/basic_signal_set \
-	unit/basic_socket \
-	unit/basic_socket_acceptor \
-	unit/basic_stream_file \
-	unit/basic_stream_socket \
-	unit/basic_streambuf \
-	unit/basic_waitable_timer \
-	unit/basic_writable_pipe \
-	unit/bind_allocator \
-	unit/bind_cancellation_slot \
-	unit/bind_executor \
-	unit/bind_immediate_executor \
-	unit/buffered_read_stream \
-	unit/buffered_stream \
-	unit/buffered_write_stream \
-	unit/buffer \
-	unit/buffer_registration \
-	unit/buffers_iterator \
-	unit/cancel_after \
-	unit/cancel_at \
-	unit/cancellation_signal \
-	unit/cancellation_state \
-	unit/cancellation_type \
-	unit/co_composed \
-	unit/co_spawn \
-	unit/completion_condition \
-	unit/compose \
-	unit/composed \
-	unit/connect \
-	unit/connect_pipe \
-	unit/consign \
-	unit/deadline_timer \
-	unit/defer \
-	unit/deferred \
-	unit/detached \
-	unit/dispatch \
-	unit/error \
-	unit/execution/any_executor \
-	unit/execution/blocking \
-	unit/execution/blocking_adaptation \
-	unit/execution/context_as \
-	unit/execution/executor \
-	unit/execution/invocable_archetype \
-	unit/execution/mapping \
-	unit/execution/outstanding_work \
-	unit/execution/prefer_only \
-	unit/execution/relationship \
-	unit/execution_context \
-	unit/executor \
-	unit/executor_work_guard \
-	unit/file_base \
-	unit/high_resolution_timer \
-	unit/immediate \
-	unit/io_context \
-	unit/io_context_strand \
-	unit/ip/address \
-	unit/ip/address_v4 \
-	unit/ip/address_v4_iterator \
-	unit/ip/address_v4_range \
-	unit/ip/address_v6 \
-	unit/ip/address_v6_iterator \
-	unit/ip/address_v6_range \
-	unit/ip/basic_endpoint \
-	unit/ip/basic_resolver \
-	unit/ip/basic_resolver_entry \
-	unit/ip/basic_resolver_iterator \
-	unit/ip/basic_resolver_query \
-	unit/ip/host_name \
-	unit/ip/icmp \
-	unit/ip/multicast \
-	unit/ip/network_v4 \
-	unit/ip/network_v6 \
-	unit/ip/resolver_query_base \
-	unit/ip/tcp \
-	unit/ip/udp \
-	unit/ip/unicast \
-	unit/ip/v6_only \
-	unit/is_read_buffered \
-	unit/is_write_buffered \
-	unit/local/basic_endpoint \
-	unit/local/connect_pair \
-	unit/local/datagram_protocol \
-	unit/local/seq_packet_protocol \
-	unit/local/stream_protocol \
-	unit/packaged_task \
-	unit/placeholders \
-	unit/posix/basic_descriptor\
-	unit/posix/basic_stream_descriptor\
-	unit/posix/descriptor\
-	unit/posix/descriptor_base \
-	unit/posix/stream_descriptor \
-	unit/post \
-	unit/prepend \
-	unit/random_access_file \
-	unit/read \
-	unit/read_at \
-	unit/read_until \
-	unit/readable_pipe \
-	unit/recycling_allocator \
-	unit/redirect_error \
-	unit/registered_buffer \
-	unit/serial_port \
-	unit/serial_port_base \
-	unit/signal_set \
-	unit/signal_set_base \
-	unit/socket_base \
-	unit/static_thread_pool \
-	unit/steady_timer \
-	unit/strand \
-	unit/stream_file \
-	unit/streambuf \
-	unit/system_context \
-	unit/system_executor \
-	unit/system_timer \
-	unit/this_coro \
-	unit/thread \
-	unit/thread_pool \
-	unit/time_traits \
-	unit/ts/buffer \
-	unit/ts/executor \
-	unit/ts/internet \
-	unit/ts/io_context \
-	unit/ts/net \
-	unit/ts/netfwd \
-	unit/ts/socket \
-	unit/ts/timer \
-	unit/use_awaitable \
-	unit/use_future \
-	unit/uses_executor \
-	unit/wait_traits \
-	unit/windows/basic_object_handle \
-	unit/windows/basic_overlapped_handle \
-	unit/windows/basic_random_access_handle \
-	unit/windows/basic_stream_handle \
-	unit/windows/object_handle \
-	unit/windows/overlapped_handle \
-	unit/windows/overlapped_ptr \
-	unit/windows/random_access_handle \
-	unit/windows/stream_handle \
-	unit/writable_pipe \
-	unit/write \
-	unit/write_at
-
-if HAVE_CXX11
-TESTS += \
-	unit/experimental/basic_channel \
-	unit/experimental/basic_concurrent_channel \
-	unit/experimental/channel \
-	unit/experimental/channel_traits \
-	unit/experimental/concurrent_channel \
-	unit/experimental/parallel_group
-endif
-
-if HAVE_CXX20
-TESTS += \
-	unit/experimental/promise
-
-if HAVE_COROUTINES
-TESTS += \
-	unit/experimental/awaitable_operators \
-	unit/experimental/co_composed \
-	unit/experimental/coro/allocator \
-	unit/experimental/coro/cancel \
-	unit/experimental/coro/co_spawn \
-	unit/experimental/coro/exception \
-	unit/experimental/coro/executor \
-	unit/experimental/coro/partial \
-	unit/experimental/coro/simple_test \
-	unit/experimental/coro/stack_test \
-	unit/experimental/coro/use_coro
-endif
-endif
-
-if HAVE_OPENSSL
-TESTS += \
-	unit/ssl/context_base \
-	unit/ssl/context \
-	unit/ssl/error \
-	unit/ssl/host_name_verification \
-	unit/ssl/rfc2818_verification \
-	unit/ssl/stream_base \
-	unit/ssl/stream
-endif
-
-noinst_HEADERS = \
-	latency/high_res_clock.hpp \
-	unit/unit_test.hpp
-
-AM_CXXFLAGS = -I$(srcdir)/../../include
-
-if !STANDALONE
-latency_tcp_client_SOURCES = latency/tcp_client.cpp
-latency_tcp_server_SOURCES = latency/tcp_server.cpp
-latency_udp_client_SOURCES = latency/udp_client.cpp
-latency_udp_server_SOURCES = latency/udp_server.cpp
-performance_client_SOURCES = performance/client.cpp
-performance_server_SOURCES = performance/server.cpp
-endif
-
-unit_any_completion_executor_SOURCES = unit/any_completion_executor.cpp
-unit_any_completion_handler_SOURCES = unit/any_completion_handler.cpp
-unit_any_io_executor_SOURCES = unit/any_io_executor.cpp
-unit_append_SOURCES = unit/append.cpp
-unit_as_tuple_SOURCES = unit/as_tuple.cpp
-unit_associated_allocator_SOURCES = unit/associated_allocator.cpp
-unit_associated_cancellation_slot_SOURCES = unit/associated_cancellation_slot.cpp
-unit_associated_executor_SOURCES = unit/associated_executor.cpp
-unit_associated_immediate_executor_SOURCES = unit/associated_immediate_executor.cpp
-unit_associator_SOURCES = unit/associator.cpp
-unit_async_result_SOURCES = unit/async_result.cpp
-unit_awaitable_SOURCES = unit/awaitable.cpp
-unit_basic_datagram_socket_SOURCES = unit/basic_datagram_socket.cpp
-unit_basic_deadline_timer_SOURCES = unit/basic_deadline_timer.cpp
-unit_basic_file_SOURCES = unit/basic_file.cpp
-unit_basic_random_access_file_SOURCES = unit/basic_random_access_file.cpp
-unit_basic_raw_socket_SOURCES = unit/basic_raw_socket.cpp
-unit_basic_readable_pipe_SOURCES = unit/basic_readable_pipe.cpp
-unit_basic_seq_packet_socket_SOURCES = unit/basic_seq_packet_socket.cpp
-unit_basic_serial_port_SOURCES = unit/basic_serial_port.cpp
-unit_basic_signal_set_SOURCES = unit/basic_signal_set.cpp
-unit_basic_socket_SOURCES = unit/basic_socket.cpp
-unit_basic_socket_acceptor_SOURCES = unit/basic_socket_acceptor.cpp
-unit_basic_stream_file_SOURCES = unit/basic_stream_file.cpp
-unit_basic_stream_socket_SOURCES = unit/basic_stream_socket.cpp
-unit_basic_streambuf_SOURCES = unit/basic_streambuf.cpp
-unit_basic_waitable_timer_SOURCES = unit/basic_waitable_timer.cpp
-unit_basic_writable_pipe_SOURCES = unit/basic_writable_pipe.cpp
-unit_bind_allocator_SOURCES = unit/bind_allocator.cpp
-unit_bind_cancellation_slot_SOURCES = unit/bind_cancellation_slot.cpp
-unit_bind_executor_SOURCES = unit/bind_executor.cpp
-unit_bind_immediate_executor_SOURCES = unit/bind_immediate_executor.cpp
-unit_buffer_SOURCES = unit/buffer.cpp
-unit_buffer_registration_SOURCES = unit/buffer_registration.cpp
-unit_buffers_iterator_SOURCES = unit/buffers_iterator.cpp
-unit_buffered_read_stream_SOURCES = unit/buffered_read_stream.cpp
-unit_buffered_stream_SOURCES = unit/buffered_stream.cpp
-unit_buffered_write_stream_SOURCES = unit/buffered_write_stream.cpp
-unit_cancel_after_SOURCES = unit/cancel_after.cpp
-unit_cancel_at_SOURCES = unit/cancel_at.cpp
-unit_cancellation_signal_SOURCES = unit/cancellation_signal.cpp
-unit_cancellation_state_SOURCES = unit/cancellation_state.cpp
-unit_cancellation_type_SOURCES = unit/cancellation_type.cpp
-unit_co_composed_SOURCES = unit/co_composed.cpp
-unit_co_spawn_SOURCES = unit/co_spawn.cpp
-unit_completion_condition_SOURCES = unit/completion_condition.cpp
-unit_compose_SOURCES = unit/compose.cpp
-unit_composed_SOURCES = unit/composed.cpp
-unit_connect_SOURCES = unit/connect.cpp
-unit_connect_pipe_SOURCES = unit/connect_pipe.cpp
-unit_consign_SOURCES = unit/consign.cpp
-unit_coroutine_SOURCES = unit/coroutine.cpp
-unit_deadline_timer_SOURCES = unit/deadline_timer.cpp
-unit_defer_SOURCES = unit/defer.cpp
-unit_deferred_SOURCES = unit/deferred.cpp
-unit_detached_SOURCES = unit/detached.cpp
-unit_dispatch_SOURCES = unit/dispatch.cpp
-unit_error_SOURCES = unit/error.cpp
-unit_execution_any_executor_SOURCES = unit/execution/any_executor.cpp
-unit_execution_blocking_SOURCES = unit/execution/blocking.cpp
-unit_execution_blocking_adaptation_SOURCES = unit/execution/blocking_adaptation.cpp
-unit_execution_context_as_SOURCES = unit/execution/context_as.cpp
-unit_execution_executor_SOURCES = unit/execution/executor.cpp
-unit_execution_invocable_archetype_SOURCES = unit/execution/invocable_archetype.cpp
-unit_execution_mapping_SOURCES = unit/execution/mapping.cpp
-unit_execution_outstanding_work_SOURCES = unit/execution/outstanding_work.cpp
-unit_execution_prefer_only_SOURCES = unit/execution/prefer_only.cpp
-unit_execution_relationship_SOURCES = unit/execution/relationship.cpp
-unit_execution_context_SOURCES = unit/execution_context.cpp
-unit_executor_SOURCES = unit/executor.cpp
-unit_executor_work_guard_SOURCES = unit/executor_work_guard.cpp
-unit_file_base_SOURCES = unit/file_base.cpp
-unit_generic_basic_endpoint_SOURCES = unit/generic/basic_endpoint.cpp
-unit_generic_datagram_protocol_SOURCES = unit/generic/datagram_protocol.cpp
-unit_generic_raw_protocol_SOURCES = unit/generic/raw_protocol.cpp
-unit_generic_seq_packet_protocol_SOURCES = unit/generic/seq_packet_protocol.cpp
-unit_generic_stream_protocol_SOURCES = unit/generic/stream_protocol.cpp
-unit_high_resolution_timer_SOURCES = unit/high_resolution_timer.cpp
-unit_immediate_SOURCES = unit/immediate.cpp
-unit_io_context_SOURCES = unit/io_context.cpp
-unit_io_context_strand_SOURCES = unit/io_context_strand.cpp
-unit_ip_address_SOURCES = unit/ip/address.cpp
-unit_ip_address_v4_SOURCES = unit/ip/address_v4.cpp
-unit_ip_address_v4_iterator_SOURCES = unit/ip/address_v4_iterator.cpp
-unit_ip_address_v4_range_SOURCES = unit/ip/address_v4_range.cpp
-unit_ip_address_v6_SOURCES = unit/ip/address_v6.cpp
-unit_ip_address_v6_iterator_SOURCES = unit/ip/address_v6_iterator.cpp
-unit_ip_address_v6_range_SOURCES = unit/ip/address_v6_range.cpp
-unit_ip_basic_endpoint_SOURCES = unit/ip/basic_endpoint.cpp
-unit_ip_basic_resolver_SOURCES = unit/ip/basic_resolver.cpp
-unit_ip_basic_resolver_entry_SOURCES = unit/ip/basic_resolver_entry.cpp
-unit_ip_basic_resolver_iterator_SOURCES = unit/ip/basic_resolver_iterator.cpp
-unit_ip_basic_resolver_query_SOURCES = unit/ip/basic_resolver_query.cpp
-unit_ip_host_name_SOURCES = unit/ip/host_name.cpp
-unit_ip_icmp_SOURCES = unit/ip/icmp.cpp
-unit_ip_multicast_SOURCES = unit/ip/multicast.cpp
-unit_ip_network_v4_SOURCES = unit/ip/network_v4.cpp
-unit_ip_network_v6_SOURCES = unit/ip/network_v6.cpp
-unit_ip_resolver_query_base_SOURCES = unit/ip/resolver_query_base.cpp
-unit_ip_tcp_SOURCES = unit/ip/tcp.cpp
-unit_ip_udp_SOURCES = unit/ip/udp.cpp
-unit_ip_unicast_SOURCES = unit/ip/unicast.cpp
-unit_ip_v6_only_SOURCES = unit/ip/v6_only.cpp
-unit_is_read_buffered_SOURCES = unit/is_read_buffered.cpp
-unit_is_write_buffered_SOURCES = unit/is_write_buffered.cpp
-unit_local_basic_endpoint_SOURCES = unit/local/basic_endpoint.cpp
-unit_local_connect_pair_SOURCES = unit/local/connect_pair.cpp
-unit_local_datagram_protocol_SOURCES = unit/local/datagram_protocol.cpp
-unit_local_seq_packet_protocol_SOURCES = unit/local/seq_packet_protocol.cpp
-unit_local_stream_protocol_SOURCES = unit/local/stream_protocol.cpp
-unit_packaged_task_SOURCES = unit/packaged_task.cpp
-unit_placeholders_SOURCES = unit/placeholders.cpp
-unit_posix_basic_descriptor_SOURCES = unit/posix/basic_descriptor.cpp
-unit_posix_basic_stream_descriptor_SOURCES = unit/posix/basic_stream_descriptor.cpp
-unit_posix_descriptor_SOURCES = unit/posix/descriptor.cpp
-unit_posix_descriptor_base_SOURCES = unit/posix/descriptor_base.cpp
-unit_posix_stream_descriptor_SOURCES = unit/posix/stream_descriptor.cpp
-unit_post_SOURCES = unit/post.cpp
-unit_prepend_SOURCES = unit/prepend.cpp
-unit_random_access_file_SOURCES = unit/random_access_file.cpp
-unit_read_SOURCES = unit/read.cpp
-unit_read_at_SOURCES = unit/read_at.cpp
-unit_read_until_SOURCES = unit/read_until.cpp
-unit_readable_pipe_SOURCES = unit/readable_pipe.cpp
-unit_recycling_allocator_SOURCES = unit/recycling_allocator.cpp
-unit_redirect_error_SOURCES = unit/redirect_error.cpp
-unit_registered_buffer_SOURCES = unit/registered_buffer.cpp
-unit_serial_port_SOURCES = unit/serial_port.cpp
-unit_serial_port_base_SOURCES = unit/serial_port_base.cpp
-unit_signal_set_SOURCES = unit/signal_set.cpp
-unit_signal_set_base_SOURCES = unit/signal_set_base.cpp
-unit_socket_base_SOURCES = unit/socket_base.cpp
-unit_static_thread_pool_SOURCES = unit/static_thread_pool.cpp
-unit_steady_timer_SOURCES = unit/steady_timer.cpp
-unit_strand_SOURCES = unit/strand.cpp
-unit_stream_file_SOURCES = unit/stream_file.cpp
-unit_streambuf_SOURCES = unit/streambuf.cpp
-unit_system_context_SOURCES = unit/system_context.cpp
-unit_system_executor_SOURCES = unit/system_executor.cpp
-unit_system_timer_SOURCES = unit/system_timer.cpp
-unit_this_coro_SOURCES = unit/this_coro.cpp
-unit_thread_SOURCES = unit/thread.cpp
-unit_thread_pool_SOURCES = unit/thread_pool.cpp
-unit_time_traits_SOURCES = unit/time_traits.cpp
-unit_ts_buffer_SOURCES = unit/ts/buffer.cpp
-unit_ts_executor_SOURCES = unit/ts/executor.cpp
-unit_ts_internet_SOURCES = unit/ts/internet.cpp
-unit_ts_io_context_SOURCES = unit/ts/io_context.cpp
-unit_ts_net_SOURCES = unit/ts/net.cpp
-unit_ts_netfwd_SOURCES = unit/ts/netfwd.cpp
-unit_ts_socket_SOURCES = unit/ts/socket.cpp
-unit_ts_timer_SOURCES = unit/ts/timer.cpp
-unit_use_awaitable_SOURCES = unit/use_awaitable.cpp
-unit_use_future_SOURCES = unit/use_future.cpp
-unit_uses_executor_SOURCES = unit/uses_executor.cpp
-unit_wait_traits_SOURCES = unit/wait_traits.cpp
-unit_windows_basic_object_handle_SOURCES = unit/windows/basic_object_handle.cpp
-unit_windows_basic_overlapped_handle_SOURCES = unit/windows/basic_overlapped_handle.cpp
-unit_windows_basic_random_access_handle_SOURCES = unit/windows/basic_random_access_handle.cpp
-unit_windows_basic_stream_handle_SOURCES = unit/windows/basic_stream_handle.cpp
-unit_windows_object_handle_SOURCES = unit/windows/object_handle.cpp
-unit_windows_overlapped_handle_SOURCES = unit/windows/overlapped_handle.cpp
-unit_windows_overlapped_ptr_SOURCES = unit/windows/overlapped_ptr.cpp
-unit_windows_random_access_handle_SOURCES = unit/windows/random_access_handle.cpp
-unit_windows_stream_handle_SOURCES = unit/windows/stream_handle.cpp
-unit_writable_pipe_SOURCES = unit/writable_pipe.cpp
-unit_write_SOURCES = unit/write.cpp
-unit_write_at_SOURCES = unit/write_at.cpp
-
-if HAVE_CXX11
-unit_experimental_basic_channel_SOURCES = unit/experimental/basic_channel.cpp
-unit_experimental_basic_concurrent_channel_SOURCES = unit/experimental/basic_concurrent_channel.cpp
-unit_experimental_channel_SOURCES = unit/experimental/channel.cpp
-unit_experimental_channel_traits_SOURCES = unit/experimental/channel_traits.cpp
-unit_experimental_concurrent_channel_SOURCES = unit/experimental/concurrent_channel.cpp
-unit_experimental_parallel_group_SOURCES = unit/experimental/parallel_group.cpp
-endif
-
-if HAVE_CXX20
-unit_experimental_promise_SOURCES = unit/experimental/promise.cpp
-
-if HAVE_COROUTINES
-unit_experimental_awaitable_operators_SOURCES = unit/experimental/awaitable_operators.cpp
-unit_experimental_co_composed_SOURCES = unit/experimental/co_composed.cpp
-unit_experimental_coro_allocator_SOURCES = unit/experimental/coro/allocator.cpp
-unit_experimental_coro_cancel_SOURCES = unit/experimental/coro/cancel.cpp
-unit_experimental_coro_co_spawn_SOURCES = unit/experimental/coro/co_spawn.cpp
-unit_experimental_coro_exception_SOURCES = unit/experimental/coro/exception.cpp
-unit_experimental_coro_executor_SOURCES = unit/experimental/coro/executor.cpp
-unit_experimental_coro_partial_SOURCES = unit/experimental/coro/partial.cpp
-unit_experimental_coro_simple_test_SOURCES = unit/experimental/coro/simple_test.cpp
-unit_experimental_coro_stack_test_SOURCES = unit/experimental/coro/stack_test.cpp
-unit_experimental_coro_use_coro_SOURCES = unit/experimental/coro/use_coro.cpp
-endif
-endif
-
-if HAVE_OPENSSL
-unit_ssl_context_base_SOURCES = unit/ssl/context_base.cpp
-unit_ssl_context_SOURCES = unit/ssl/context.cpp
-unit_ssl_error_SOURCES = unit/ssl/error.cpp
-unit_ssl_stream_base_SOURCES = unit/ssl/stream_base.cpp
-unit_ssl_host_name_verification_SOURCES = unit/ssl/host_name_verification.cpp
-unit_ssl_rfc2818_verification_SOURCES = unit/ssl/rfc2818_verification.cpp
-unit_ssl_stream_SOURCES = unit/ssl/stream.cpp
-endif
-
-EXTRA_DIST = \
-	latency/allocator.hpp \
-	performance/handler_allocator.hpp \
-	unit/archetypes/async_ops.hpp \
-	unit/archetypes/async_result.hpp \
-	unit/archetypes/gettable_socket_option.hpp \
-	unit/archetypes/io_control_command.hpp \
-	unit/archetypes/settable_socket_option.hpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/.gitignore
deleted file mode 100644
index feea55d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*client
-*server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/allocator.hpp
deleted file mode 100644
index 2b186ae..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/allocator.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// allocator.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ALLOCATOR_HPP
-#define ALLOCATOR_HPP
-
-#include <boost/aligned_storage.hpp>
-
-// Represents a single connection from a client.
-class allocator
-{
-public:
-  allocator()
-    : in_use_(false)
-  {
-  }
-
-  void* allocate(std::size_t n)
-  {
-    if (in_use_ || n >= 1024)
-      return ::operator new(n);
-    in_use_ = true;
-    return static_cast<void*>(&space_);
-  }
-
-  void deallocate(void* p)
-  {
-    if (p != static_cast<void*>(&space_))
-      ::operator delete(p);
-    else
-      in_use_ = false;
-  }
-
-private:
-  allocator(const allocator&);
-  allocator& operator=(const allocator&);
-
-  // Whether the reusable memory space is currently in use.
-  bool in_use_;
-
-  // The reusable memory space made available by the allocator.
-  boost::aligned_storage<1024>::type space_;
-};
-
-#endif // ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/high_res_clock.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/high_res_clock.hpp
deleted file mode 100644
index a497834..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/high_res_clock.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// high_res_clock.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HIGH_RES_CLOCK_HPP
-#define HIGH_RES_CLOCK_HPP
-
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-
-#if defined(ASIO_WINDOWS)
-
-inline boost::uint64_t high_res_clock()
-{
-  LARGE_INTEGER i;
-  QueryPerformanceCounter(&i);
-  return i.QuadPart;
-}
-
-#elif defined(__GNUC__) && defined(__x86_64__)
-
-inline boost::uint64_t high_res_clock()
-{
-  unsigned long low, high;
-  __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high));
-  return (((boost::uint64_t)high) << 32) | low;
-}
-
-#else
-
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-
-inline boost::uint64_t high_res_clock()
-{
-  boost::posix_time::ptime now =
-    boost::posix_time::microsec_clock::universal_time();
-
-  boost::posix_time::ptime epoch(
-      boost::gregorian::date(1970, 1, 1),
-      boost::posix_time::seconds(0));
-
-  return (now - epoch).total_microseconds();
-}
-
-#endif
-
-#endif // HIGH_RES_CLOCK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_client.cpp
deleted file mode 100644
index 2a4c5b7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_client.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//
-// tcp_client.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/ip/tcp.hpp>
-#include <asio/read.hpp>
-#include <asio/write.hpp>
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include <boost/shared_ptr.hpp>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <vector>
-#include "high_res_clock.hpp"
-
-using asio::ip::tcp;
-using boost::posix_time::ptime;
-using boost::posix_time::microsec_clock;
-
-const int num_samples = 100000;
-
-struct transfer_all
-{
-  typedef std::size_t result_type;
-  std::size_t operator()(const asio::error_code& ec, std::size_t)
-  {
-    return (ec && ec != asio::error::would_block) ? 0 : ~0;
-  }
-};
-
-int main(int argc, char* argv[])
-{
-  if (argc != 6)
-  {
-    std::fprintf(stderr,
-        "Usage: tcp_client <ip> <port> "
-        "<nconns> <bufsize> {spin|block}\n");
-    return 1;
-  }
-
-  const char* ip = argv[1];
-  unsigned short port = static_cast<unsigned short>(std::atoi(argv[2]));
-  int num_connections = std::atoi(argv[3]);
-  std::size_t buf_size = static_cast<std::size_t>(std::atoi(argv[4]));
-  bool spin = (std::strcmp(argv[5], "spin") == 0);
-
-  asio::io_context io_context;
-  std::vector<boost::shared_ptr<tcp::socket> > sockets;
-
-  for (int i = 0; i < num_connections; ++i)
-  {
-    boost::shared_ptr<tcp::socket> s(new tcp::socket(io_context));
-
-    tcp::endpoint target(asio::ip::make_address(ip), port);
-    s->connect(target);
-
-    s->set_option(tcp::no_delay(true));
-
-    if (spin)
-    {
-      s->non_blocking(true);
-    }
-
-    sockets.push_back(s);
-  }
-
-  std::vector<unsigned char> write_buf(buf_size);
-  std::vector<unsigned char> read_buf(buf_size);
-
-  ptime start = microsec_clock::universal_time();
-  boost::uint64_t start_hr = high_res_clock();
-
-  boost::uint64_t samples[num_samples];
-  for (int i = 0; i < num_samples; ++i)
-  {
-    tcp::socket& socket = *sockets[i % num_connections];
-
-    boost::uint64_t t = high_res_clock();
-
-    asio::error_code ec;
-    asio::write(socket,
-        asio::buffer(write_buf),
-        transfer_all(), ec);
-
-    asio::read(socket,
-        asio::buffer(read_buf),
-        transfer_all(), ec);
-
-    samples[i] = high_res_clock() - t;
-  }
-
-  ptime stop = microsec_clock::universal_time();
-  boost::uint64_t stop_hr = high_res_clock();
-  boost::uint64_t elapsed_usec = (stop - start).total_microseconds();
-  boost::uint64_t elapsed_hr = stop_hr - start_hr;
-  double scale = 1.0 * elapsed_usec / elapsed_hr;
-
-  std::sort(samples, samples + num_samples);
-  std::printf("  0.0%%\t%f\n", samples[0] * scale);
-  std::printf("  0.1%%\t%f\n", samples[num_samples / 1000 - 1] * scale);
-  std::printf("  1.0%%\t%f\n", samples[num_samples / 100 - 1] * scale);
-  std::printf(" 10.0%%\t%f\n", samples[num_samples / 10 - 1] * scale);
-  std::printf(" 20.0%%\t%f\n", samples[num_samples * 2 / 10 - 1] * scale);
-  std::printf(" 30.0%%\t%f\n", samples[num_samples * 3 / 10 - 1] * scale);
-  std::printf(" 40.0%%\t%f\n", samples[num_samples * 4 / 10 - 1] * scale);
-  std::printf(" 50.0%%\t%f\n", samples[num_samples * 5 / 10 - 1] * scale);
-  std::printf(" 60.0%%\t%f\n", samples[num_samples * 6 / 10 - 1] * scale);
-  std::printf(" 70.0%%\t%f\n", samples[num_samples * 7 / 10 - 1] * scale);
-  std::printf(" 80.0%%\t%f\n", samples[num_samples * 8 / 10 - 1] * scale);
-  std::printf(" 90.0%%\t%f\n", samples[num_samples * 9 / 10 - 1] * scale);
-  std::printf(" 99.0%%\t%f\n", samples[num_samples * 99 / 100 - 1] * scale);
-  std::printf(" 99.9%%\t%f\n", samples[num_samples * 999 / 1000 - 1] * scale);
-  std::printf("100.0%%\t%f\n", samples[num_samples - 1] * scale);
-
-  double total = 0.0;
-  for (int i = 0; i < num_samples; ++i) total += samples[i] * scale;
-  std::printf("  mean\t%f\n", total / num_samples);
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_server.cpp
deleted file mode 100644
index c26c850..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/tcp_server.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//
-// tcp_server.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/read.hpp>
-#include <asio/write.hpp>
-#include <boost/shared_ptr.hpp>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <vector>
-
-using asio::ip::tcp;
-
-#include <asio/yield.hpp>
-
-class tcp_server : asio::coroutine
-{
-public:
-  tcp_server(tcp::acceptor& acceptor, std::size_t buf_size) :
-    acceptor_(acceptor),
-    socket_(acceptor_.get_executor()),
-    buffer_(buf_size)
-  {
-  }
-
-  void operator()(asio::error_code ec, std::size_t n = 0)
-  {
-    reenter (this) for (;;)
-    {
-      yield acceptor_.async_accept(socket_, ref(this));
-
-      while (!ec)
-      {
-        yield asio::async_read(socket_,
-            asio::buffer(buffer_), ref(this));
-
-        if (!ec)
-        {
-          for (std::size_t i = 0; i < n; ++i) buffer_[i] = ~buffer_[i];
-
-          yield asio::async_write(socket_,
-              asio::buffer(buffer_), ref(this));
-        }
-      }
-
-      socket_.close();
-    }
-  }
-
-  struct ref
-  {
-    explicit ref(tcp_server* p)
-      : p_(p)
-    {
-    }
-
-    void operator()(asio::error_code ec, std::size_t n = 0)
-    {
-      (*p_)(ec, n);
-    }
-
-  private:
-    tcp_server* p_;
-  };
-
-private:
-  tcp::acceptor& acceptor_;
-  tcp::socket socket_;
-  std::vector<unsigned char> buffer_;
-  tcp::endpoint sender_;
-};
-
-#include <asio/unyield.hpp>
-
-int main(int argc, char* argv[])
-{
-  if (argc != 5)
-  {
-    std::fprintf(stderr,
-        "Usage: tcp_server <port> <nconns> "
-        "<bufsize> {spin|block}\n");
-    return 1;
-  }
-
-  unsigned short port = static_cast<unsigned short>(std::atoi(argv[1]));
-  int max_connections = std::atoi(argv[2]);
-  std::size_t buf_size = std::atoi(argv[3]);
-  bool spin = (std::strcmp(argv[4], "spin") == 0);
-
-  asio::io_context io_context(1);
-  tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
-  std::vector<boost::shared_ptr<tcp_server> > servers;
-
-  for (int i = 0; i < max_connections; ++i)
-  {
-    boost::shared_ptr<tcp_server> s(new tcp_server(acceptor, buf_size));
-    servers.push_back(s);
-    (*s)(asio::error_code());
-  }
-
-  if (spin)
-    for (;;) io_context.poll();
-  else
-    io_context.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_client.cpp
deleted file mode 100644
index 2077674..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_client.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//
-// udp_client.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/ip/udp.hpp>
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include <algorithm>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <vector>
-#include "high_res_clock.hpp"
-
-using asio::ip::udp;
-using boost::posix_time::ptime;
-using boost::posix_time::microsec_clock;
-
-const int num_samples = 100000;
-
-int main(int argc, char* argv[])
-{
-  if (argc != 6)
-  {
-    std::fprintf(stderr,
-        "Usage: udp_client <ip> <port1> "
-        "<nports> <bufsize> {spin|block}\n");
-    return 1;
-  }
-
-  const char* ip = argv[1];
-  unsigned short first_port = static_cast<unsigned short>(std::atoi(argv[2]));
-  unsigned short num_ports = static_cast<unsigned short>(std::atoi(argv[3]));
-  std::size_t buf_size = static_cast<std::size_t>(std::atoi(argv[4]));
-  bool spin = (std::strcmp(argv[5], "spin") == 0);
-
-  asio::io_context io_context;
-
-  udp::socket socket(io_context, udp::endpoint(udp::v4(), 0));
-
-  if (spin)
-  {
-    socket.non_blocking(true);
-  }
-
-  udp::endpoint target(asio::ip::make_address(ip), first_port);
-  unsigned short last_port = first_port + num_ports - 1;
-  std::vector<unsigned char> write_buf(buf_size);
-  std::vector<unsigned char> read_buf(buf_size);
-
-  ptime start = microsec_clock::universal_time();
-  boost::uint64_t start_hr = high_res_clock();
-
-  boost::uint64_t samples[num_samples];
-  for (int i = 0; i < num_samples; ++i)
-  {
-    boost::uint64_t t = high_res_clock();
-
-    asio::error_code ec;
-    socket.send_to(asio::buffer(write_buf), target, 0, ec);
-
-    do socket.receive(asio::buffer(read_buf), 0, ec);
-    while (ec == asio::error::would_block);
-
-    samples[i] = high_res_clock() - t;
-
-    if (target.port() == last_port)
-      target.port(first_port);
-    else
-      target.port(target.port() + 1);
-  }
-
-  ptime stop = microsec_clock::universal_time();
-  boost::uint64_t stop_hr = high_res_clock();
-  boost::uint64_t elapsed_usec = (stop - start).total_microseconds();
-  boost::uint64_t elapsed_hr = stop_hr - start_hr;
-  double scale = 1.0 * elapsed_usec / elapsed_hr;
-
-  std::sort(samples, samples + num_samples);
-  std::printf("  0.0%%\t%f\n", samples[0] * scale);
-  std::printf("  0.1%%\t%f\n", samples[num_samples / 1000 - 1] * scale);
-  std::printf("  1.0%%\t%f\n", samples[num_samples / 100 - 1] * scale);
-  std::printf(" 10.0%%\t%f\n", samples[num_samples / 10 - 1] * scale);
-  std::printf(" 20.0%%\t%f\n", samples[num_samples * 2 / 10 - 1] * scale);
-  std::printf(" 30.0%%\t%f\n", samples[num_samples * 3 / 10 - 1] * scale);
-  std::printf(" 40.0%%\t%f\n", samples[num_samples * 4 / 10 - 1] * scale);
-  std::printf(" 50.0%%\t%f\n", samples[num_samples * 5 / 10 - 1] * scale);
-  std::printf(" 60.0%%\t%f\n", samples[num_samples * 6 / 10 - 1] * scale);
-  std::printf(" 70.0%%\t%f\n", samples[num_samples * 7 / 10 - 1] * scale);
-  std::printf(" 80.0%%\t%f\n", samples[num_samples * 8 / 10 - 1] * scale);
-  std::printf(" 90.0%%\t%f\n", samples[num_samples * 9 / 10 - 1] * scale);
-  std::printf(" 99.0%%\t%f\n", samples[num_samples * 99 / 100 - 1] * scale);
-  std::printf(" 99.9%%\t%f\n", samples[num_samples * 999 / 1000 - 1] * scale);
-  std::printf("100.0%%\t%f\n", samples[num_samples - 1] * scale);
-
-  double total = 0.0;
-  for (int i = 0; i < num_samples; ++i) total += samples[i] * scale;
-  std::printf("  mean\t%f\n", total / num_samples);
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_server.cpp
deleted file mode 100644
index 13483fa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/latency/udp_server.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-//
-// udp_server.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <boost/shared_ptr.hpp>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <vector>
-#include "allocator.hpp"
-
-using asio::ip::udp;
-
-#include <asio/yield.hpp>
-
-class udp_server : asio::coroutine
-{
-public:
-  udp_server(asio::io_context& io_context,
-      unsigned short port, std::size_t buf_size) :
-    socket_(io_context, udp::endpoint(udp::v4(), port)),
-    buffer_(buf_size)
-  {
-  }
-
-  void operator()(asio::error_code ec, std::size_t n = 0)
-  {
-    reenter (this) for (;;)
-    {
-      yield socket_.async_receive_from(
-          asio::buffer(buffer_),
-          sender_, ref(this));
-
-      if (!ec)
-      {
-        for (std::size_t i = 0; i < n; ++i) buffer_[i] = ~buffer_[i];
-        socket_.send_to(asio::buffer(buffer_, n), sender_, 0, ec);
-      }
-    }
-  }
-
-  friend void* asio_handler_allocate(std::size_t n, udp_server* s)
-  {
-    return s->allocator_.allocate(n);
-  }
-
-  friend void asio_handler_deallocate(void* p, std::size_t, udp_server* s)
-  {
-    s->allocator_.deallocate(p);
-  }
-
-  struct ref
-  {
-    explicit ref(udp_server* p)
-      : p_(p)
-    {
-    }
-
-    void operator()(asio::error_code ec, std::size_t n = 0)
-    {
-      (*p_)(ec, n);
-    }
-
-  private:
-    udp_server* p_;
-
-    friend void* asio_handler_allocate(std::size_t n, ref* r)
-    {
-      return asio_handler_allocate(n, r->p_);
-    }
-
-    friend void asio_handler_deallocate(void* p, std::size_t n, ref* r)
-    {
-      asio_handler_deallocate(p, n, r->p_);
-    }
-  };
-
-private:
-  udp::socket socket_;
-  std::vector<unsigned char> buffer_;
-  udp::endpoint sender_;
-  allocator allocator_;
-};
-
-#include <asio/unyield.hpp>
-
-int main(int argc, char* argv[])
-{
-  if (argc != 5)
-  {
-    std::fprintf(stderr,
-        "Usage: udp_server <port1> <nports> "
-        "<bufsize> {spin|block}\n");
-    return 1;
-  }
-
-  unsigned short first_port = static_cast<unsigned short>(std::atoi(argv[1]));
-  unsigned short num_ports = static_cast<unsigned short>(std::atoi(argv[2]));
-  std::size_t buf_size = std::atoi(argv[3]);
-  bool spin = (std::strcmp(argv[4], "spin") == 0);
-
-  asio::io_context io_context(1);
-  std::vector<boost::shared_ptr<udp_server> > servers;
-
-  for (unsigned short i = 0; i < num_ports; ++i)
-  {
-    unsigned short port = first_port + i;
-    boost::shared_ptr<udp_server> s(new udp_server(io_context, port, buf_size));
-    servers.push_back(s);
-    (*s)(asio::error_code());
-  }
-
-  if (spin)
-    for (;;) io_context.poll();
-  else
-    io_context.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/.gitignore
deleted file mode 100644
index 692ea7e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/.gitignore
+++ /dev/null
@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-client
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/client.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/client.cpp
deleted file mode 100644
index b42a6c5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/client.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio.hpp"
-#include <algorithm>
-#include <boost/bind/bind.hpp>
-#include <boost/mem_fn.hpp>
-#include <iostream>
-#include <list>
-#include <string>
-#include "handler_allocator.hpp"
-
-class stats
-{
-public:
-  stats()
-    : mutex_(),
-      total_bytes_written_(0),
-      total_bytes_read_(0)
-  {
-  }
-
-  void add(size_t bytes_written, size_t bytes_read)
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    total_bytes_written_ += bytes_written;
-    total_bytes_read_ += bytes_read;
-  }
-
-  void print()
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    std::cout << total_bytes_written_ << " total bytes written\n";
-    std::cout << total_bytes_read_ << " total bytes read\n";
-  }
-
-private:
-  asio::detail::mutex mutex_;
-  size_t total_bytes_written_;
-  size_t total_bytes_read_;
-};
-
-class session
-{
-public:
-  session(asio::io_context& ioc, size_t block_size, stats& s)
-    : strand_(ioc.get_executor()),
-      socket_(ioc),
-      block_size_(block_size),
-      read_data_(new char[block_size]),
-      read_data_length_(0),
-      write_data_(new char[block_size]),
-      unwritten_count_(0),
-      bytes_written_(0),
-      bytes_read_(0),
-      stats_(s)
-  {
-    for (size_t i = 0; i < block_size_; ++i)
-      write_data_[i] = static_cast<char>(i % 128);
-  }
-
-  ~session()
-  {
-    stats_.add(bytes_written_, bytes_read_);
-
-    delete[] read_data_;
-    delete[] write_data_;
-  }
-
-  void start(asio::ip::tcp::resolver::results_type endpoints)
-  {
-    asio::async_connect(socket_, endpoints,
-        asio::bind_executor(strand_,
-          boost::bind(&session::handle_connect, this,
-            asio::placeholders::error)));
-  }
-
-  void stop()
-  {
-    asio::post(strand_, boost::bind(&session::close_socket, this));
-  }
-
-private:
-  void handle_connect(const asio::error_code& err)
-  {
-    if (!err)
-    {
-      asio::error_code set_option_err;
-      asio::ip::tcp::no_delay no_delay(true);
-      socket_.set_option(no_delay, set_option_err);
-      if (!set_option_err)
-      {
-        ++unwritten_count_;
-        async_write(socket_, asio::buffer(write_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void handle_read(const asio::error_code& err, size_t length)
-  {
-    if (!err)
-    {
-      bytes_read_ += length;
-
-      read_data_length_ = length;
-      ++unwritten_count_;
-      if (unwritten_count_ == 1)
-      {
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void handle_write(const asio::error_code& err, size_t length)
-  {
-    if (!err && length > 0)
-    {
-      bytes_written_ += length;
-
-      --unwritten_count_;
-      if (unwritten_count_ == 1)
-      {
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void close_socket()
-  {
-    socket_.close();
-  }
-
-private:
-  asio::strand<asio::io_context::executor_type> strand_;
-  asio::ip::tcp::socket socket_;
-  size_t block_size_;
-  char* read_data_;
-  size_t read_data_length_;
-  char* write_data_;
-  int unwritten_count_;
-  size_t bytes_written_;
-  size_t bytes_read_;
-  stats& stats_;
-  handler_allocator read_allocator_;
-  handler_allocator write_allocator_;
-};
-
-class client
-{
-public:
-  client(asio::io_context& ioc,
-      const asio::ip::tcp::resolver::results_type endpoints,
-      size_t block_size, size_t session_count, int timeout)
-    : io_context_(ioc),
-      stop_timer_(ioc),
-      sessions_(),
-      stats_()
-  {
-    stop_timer_.expires_after(asio::chrono::seconds(timeout));
-    stop_timer_.async_wait(boost::bind(&client::handle_timeout, this));
-
-    for (size_t i = 0; i < session_count; ++i)
-    {
-      session* new_session = new session(io_context_, block_size, stats_);
-      new_session->start(endpoints);
-      sessions_.push_back(new_session);
-    }
-  }
-
-  ~client()
-  {
-    while (!sessions_.empty())
-    {
-      delete sessions_.front();
-      sessions_.pop_front();
-    }
-
-    stats_.print();
-  }
-
-  void handle_timeout()
-  {
-    std::for_each(sessions_.begin(), sessions_.end(),
-        boost::mem_fn(&session::stop));
-  }
-
-private:
-  asio::io_context& io_context_;
-  asio::steady_timer stop_timer_;
-  std::list<session*> sessions_;
-  stats stats_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 7)
-    {
-      std::cerr << "Usage: client <host> <port> <threads> <blocksize> ";
-      std::cerr << "<sessions> <time>\n";
-      return 1;
-    }
-
-    using namespace std; // For atoi.
-    const char* host = argv[1];
-    const char* port = argv[2];
-    int thread_count = atoi(argv[3]);
-    size_t block_size = atoi(argv[4]);
-    size_t session_count = atoi(argv[5]);
-    int timeout = atoi(argv[6]);
-
-    asio::io_context ioc;
-
-    asio::ip::tcp::resolver r(ioc);
-    asio::ip::tcp::resolver::results_type endpoints =
-      r.resolve(host, port);
-
-    client c(ioc, endpoints, block_size, session_count, timeout);
-
-    std::list<asio::thread*> threads;
-    while (--thread_count > 0)
-    {
-      asio::thread* new_thread = new asio::thread(
-          boost::bind(&asio::io_context::run, &ioc));
-      threads.push_back(new_thread);
-    }
-
-    ioc.run();
-
-    while (!threads.empty())
-    {
-      threads.front()->join();
-      delete threads.front();
-      threads.pop_front();
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/handler_allocator.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/handler_allocator.hpp
deleted file mode 100644
index 6c1b985..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/handler_allocator.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// handler_allocator.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HANDLER_ALLOCATOR_HPP
-#define HANDLER_ALLOCATOR_HPP
-
-#include "asio.hpp"
-#include <boost/aligned_storage.hpp>
-#include <boost/noncopyable.hpp>
-
-// Class to manage the memory to be used for handler-based custom allocation.
-// It contains a single block of memory which may be returned for allocation
-// requests. If the memory is in use when an allocation request is made, the
-// allocator delegates allocation to the global heap.
-class handler_allocator
-  : private boost::noncopyable
-{
-public:
-  handler_allocator()
-    : in_use_(false)
-  {
-  }
-
-  void* allocate(std::size_t size)
-  {
-    if (!in_use_ && size < storage_.size)
-    {
-      in_use_ = true;
-      return storage_.address();
-    }
-
-    return ::operator new(size);
-  }
-
-  void deallocate(void* pointer)
-  {
-    if (pointer == storage_.address())
-    {
-      in_use_ = false;
-    }
-    else
-    {
-      ::operator delete(pointer);
-    }
-  }
-
-private:
-  // Storage space used for handler-based custom memory allocation.
-  boost::aligned_storage<1024> storage_;
-
-  // Whether the handler-based custom allocation storage has been used.
-  bool in_use_;
-};
-
-// Wrapper class template for handler objects to allow handler memory
-// allocation to be customised. Calls to operator() are forwarded to the
-// encapsulated handler.
-template <typename Handler>
-class custom_alloc_handler
-{
-public:
-  custom_alloc_handler(handler_allocator& a, Handler h)
-    : allocator_(a),
-      handler_(h)
-  {
-  }
-
-  template <typename Arg1>
-  void operator()(Arg1 arg1)
-  {
-    handler_(arg1);
-  }
-
-  template <typename Arg1, typename Arg2>
-  void operator()(Arg1 arg1, Arg2 arg2)
-  {
-    handler_(arg1, arg2);
-  }
-
-  friend void* asio_handler_allocate(std::size_t size,
-      custom_alloc_handler<Handler>* this_handler)
-  {
-    return this_handler->allocator_.allocate(size);
-  }
-
-  friend void asio_handler_deallocate(void* pointer, std::size_t /*size*/,
-      custom_alloc_handler<Handler>* this_handler)
-  {
-    this_handler->allocator_.deallocate(pointer);
-  }
-
-private:
-  handler_allocator& allocator_;
-  Handler handler_;
-};
-
-// Helper function to wrap a handler object to add custom allocation.
-template <typename Handler>
-inline custom_alloc_handler<Handler> make_custom_alloc_handler(
-    handler_allocator& a, Handler h)
-{
-  return custom_alloc_handler<Handler>(a, h);
-}
-
-#endif // HANDLER_ALLOCATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/server.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/server.cpp
deleted file mode 100644
index 9de3c12..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/performance/server.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-//
-// server.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio.hpp"
-#include <algorithm>
-#include <boost/bind/bind.hpp>
-#include <iostream>
-#include <list>
-#include "handler_allocator.hpp"
-
-class session
-{
-public:
-  session(asio::io_context& ioc, size_t block_size)
-    : io_context_(ioc),
-      strand_(ioc.get_executor()),
-      socket_(ioc),
-      block_size_(block_size),
-      read_data_(new char[block_size]),
-      read_data_length_(0),
-      write_data_(new char[block_size]),
-      unsent_count_(0),
-      op_count_(0)
-  {
-  }
-
-  ~session()
-  {
-    delete[] read_data_;
-    delete[] write_data_;
-  }
-
-  asio::ip::tcp::socket& socket()
-  {
-    return socket_;
-  }
-
-  void start()
-  {
-    asio::error_code set_option_err;
-    asio::ip::tcp::no_delay no_delay(true);
-    socket_.set_option(no_delay, set_option_err);
-    if (!set_option_err)
-    {
-      ++op_count_;
-      socket_.async_read_some(asio::buffer(read_data_, block_size_),
-          asio::bind_executor(strand_,
-            make_custom_alloc_handler(read_allocator_,
-              boost::bind(&session::handle_read, this,
-                asio::placeholders::error,
-                asio::placeholders::bytes_transferred))));
-    }
-    else
-    {
-      asio::post(io_context_, boost::bind(&session::destroy, this));
-    }
-  }
-
-  void handle_read(const asio::error_code& err, size_t length)
-  {
-    --op_count_;
-
-    if (!err)
-    {
-      read_data_length_ = length;
-      ++unsent_count_;
-      if (unsent_count_ == 1)
-      {
-        op_count_ += 2;
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-
-    if (op_count_ == 0)
-      asio::post(io_context_, boost::bind(&session::destroy, this));
-  }
-
-  void handle_write(const asio::error_code& err)
-  {
-    --op_count_;
-
-    if (!err)
-    {
-      --unsent_count_;
-      if (unsent_count_ == 1)
-      {
-        op_count_ += 2;
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-
-    if (op_count_ == 0)
-      asio::post(io_context_, boost::bind(&session::destroy, this));
-  }
-
-  static void destroy(session* s)
-  {
-    delete s;
-  }
-
-private:
-  asio::io_context& io_context_;
-  asio::strand<asio::io_context::executor_type> strand_;
-  asio::ip::tcp::socket socket_;
-  size_t block_size_;
-  char* read_data_;
-  size_t read_data_length_;
-  char* write_data_;
-  int unsent_count_;
-  int op_count_;
-  handler_allocator read_allocator_;
-  handler_allocator write_allocator_;
-};
-
-class server
-{
-public:
-  server(asio::io_context& ioc, const asio::ip::tcp::endpoint& endpoint,
-      size_t block_size)
-    : io_context_(ioc),
-      acceptor_(ioc),
-      block_size_(block_size)
-  {
-    acceptor_.open(endpoint.protocol());
-    acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(1));
-    acceptor_.bind(endpoint);
-    acceptor_.listen();
-
-    start_accept();
-  }
-
-  void start_accept()
-  {
-    session* new_session = new session(io_context_, block_size_);
-    acceptor_.async_accept(new_session->socket(),
-        boost::bind(&server::handle_accept, this, new_session,
-          asio::placeholders::error));
-  }
-
-  void handle_accept(session* new_session, const asio::error_code& err)
-  {
-    if (!err)
-    {
-      new_session->start();
-    }
-    else
-    {
-      delete new_session;
-    }
-
-    start_accept();
-  }
-
-private:
-  asio::io_context& io_context_;
-  asio::ip::tcp::acceptor acceptor_;
-  size_t block_size_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 5)
-    {
-      std::cerr << "Usage: server <address> <port> <threads> <blocksize>\n";
-      return 1;
-    }
-
-    using namespace std; // For atoi.
-    asio::ip::address address = asio::ip::make_address(argv[1]);
-    short port = atoi(argv[2]);
-    int thread_count = atoi(argv[3]);
-    size_t block_size = atoi(argv[4]);
-
-    asio::io_context ioc;
-
-    server s(ioc, asio::ip::tcp::endpoint(address, port), block_size);
-
-    // Threads not currently supported in this test.
-    std::list<asio::thread*> threads;
-    while (--thread_count > 0)
-    {
-      asio::thread* new_thread = new asio::thread(
-          boost::bind(&asio::io_context::run, &ioc));
-      threads.push_back(new_thread);
-    }
-
-    ioc.run();
-
-    while (!threads.empty())
-    {
-      threads.front()->join();
-      delete threads.front();
-      threads.pop_front();
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/.gitignore
deleted file mode 100644
index 197c183..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-*_free
-*_free_prefer
-*_free_require
-*_member
-*_member_prefer
-*_member_require
-*_static
-*_unsupported
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.am b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.am
deleted file mode 100644
index 688b3f4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.am
+++ /dev/null
@@ -1,367 +0,0 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
-check_PROGRAMS = \
-	cpp03/query_free \
-	cpp03/query_member \
-	cpp03/query_static \
-	cpp03/can_query_free \
-	cpp03/can_query_member \
-	cpp03/can_query_static \
-	cpp03/can_query_unsupported \
-	cpp03/can_query_not_applicable_free \
-	cpp03/can_query_not_applicable_member \
-	cpp03/can_query_not_applicable_static \
-	cpp03/can_query_not_applicable_unsupported \
-	cpp03/require_concept_free \
-	cpp03/require_concept_member \
-	cpp03/require_concept_static \
-	cpp03/can_require_concept_free \
-	cpp03/can_require_concept_member \
-	cpp03/can_require_concept_static \
-	cpp03/can_require_concept_unsupported \
-	cpp03/can_require_concept_not_applicable_free \
-	cpp03/can_require_concept_not_applicable_member \
-	cpp03/can_require_concept_not_applicable_static \
-	cpp03/can_require_concept_not_applicable_unsupported \
-	cpp03/require_free \
-	cpp03/require_member \
-	cpp03/require_static \
-	cpp03/can_require_free \
-	cpp03/can_require_member \
-	cpp03/can_require_static \
-	cpp03/can_require_unsupported \
-	cpp03/can_require_not_applicable_free \
-	cpp03/can_require_not_applicable_member \
-	cpp03/can_require_not_applicable_static \
-	cpp03/can_require_not_applicable_unsupported \
-	cpp03/prefer_free_prefer \
-	cpp03/prefer_member_prefer \
-	cpp03/prefer_free_require \
-	cpp03/prefer_member_require \
-	cpp03/prefer_static \
-	cpp03/prefer_unsupported \
-	cpp03/can_prefer_free_prefer \
-	cpp03/can_prefer_free_require \
-	cpp03/can_prefer_member_prefer \
-	cpp03/can_prefer_member_require \
-	cpp03/can_prefer_static \
-	cpp03/can_prefer_unsupported \
-	cpp03/can_prefer_not_applicable_free_prefer \
-	cpp03/can_prefer_not_applicable_free_require \
-	cpp03/can_prefer_not_applicable_member_prefer \
-	cpp03/can_prefer_not_applicable_member_require \
-	cpp03/can_prefer_not_applicable_static \
-	cpp03/can_prefer_not_applicable_unsupported \
-	cpp03/can_prefer_not_preferable_free_prefer \
-	cpp03/can_prefer_not_preferable_free_require \
-	cpp03/can_prefer_not_preferable_member_prefer \
-	cpp03/can_prefer_not_preferable_member_require \
-	cpp03/can_prefer_not_preferable_static \
-	cpp03/can_prefer_not_preferable_unsupported
-
-cpp03_query_free_SOURCES = cpp03/query_free.cpp
-cpp03_query_member_SOURCES = cpp03/query_member.cpp
-cpp03_query_static_SOURCES = cpp03/query_static.cpp
-cpp03_can_query_free_SOURCES = cpp03/can_query_free.cpp
-cpp03_can_query_member_SOURCES = cpp03/can_query_member.cpp
-cpp03_can_query_static_SOURCES = cpp03/can_query_static.cpp
-cpp03_can_query_unsupported_SOURCES = cpp03/can_query_unsupported.cpp
-cpp03_can_query_not_applicable_free_SOURCES = cpp03/can_query_not_applicable_free.cpp
-cpp03_can_query_not_applicable_member_SOURCES = cpp03/can_query_not_applicable_member.cpp
-cpp03_can_query_not_applicable_static_SOURCES = cpp03/can_query_not_applicable_static.cpp
-cpp03_can_query_not_applicable_unsupported_SOURCES = cpp03/can_query_not_applicable_unsupported.cpp
-cpp03_require_concept_free_SOURCES = cpp03/require_concept_free.cpp
-cpp03_require_concept_member_SOURCES = cpp03/require_concept_member.cpp
-cpp03_require_concept_static_SOURCES = cpp03/require_concept_static.cpp
-cpp03_can_require_concept_free_SOURCES = cpp03/can_require_concept_free.cpp
-cpp03_can_require_concept_member_SOURCES = cpp03/can_require_concept_member.cpp
-cpp03_can_require_concept_static_SOURCES = cpp03/can_require_concept_static.cpp
-cpp03_can_require_concept_unsupported_SOURCES = cpp03/can_require_concept_unsupported.cpp
-cpp03_can_require_concept_not_applicable_free_SOURCES = cpp03/can_require_concept_not_applicable_free.cpp
-cpp03_can_require_concept_not_applicable_member_SOURCES = cpp03/can_require_concept_not_applicable_member.cpp
-cpp03_can_require_concept_not_applicable_static_SOURCES = cpp03/can_require_concept_not_applicable_static.cpp
-cpp03_can_require_concept_not_applicable_unsupported_SOURCES = cpp03/can_require_concept_not_applicable_unsupported.cpp
-cpp03_require_free_SOURCES = cpp03/require_free.cpp
-cpp03_require_member_SOURCES = cpp03/require_member.cpp
-cpp03_require_static_SOURCES = cpp03/require_static.cpp
-cpp03_can_require_free_SOURCES = cpp03/can_require_free.cpp
-cpp03_can_require_member_SOURCES = cpp03/can_require_member.cpp
-cpp03_can_require_static_SOURCES = cpp03/can_require_static.cpp
-cpp03_can_require_unsupported_SOURCES = cpp03/can_require_unsupported.cpp
-cpp03_can_require_not_applicable_free_SOURCES = cpp03/can_require_not_applicable_free.cpp
-cpp03_can_require_not_applicable_member_SOURCES = cpp03/can_require_not_applicable_member.cpp
-cpp03_can_require_not_applicable_static_SOURCES = cpp03/can_require_not_applicable_static.cpp
-cpp03_can_require_not_applicable_unsupported_SOURCES = cpp03/can_require_not_applicable_unsupported.cpp
-cpp03_prefer_free_prefer_SOURCES = cpp03/prefer_free_prefer.cpp
-cpp03_prefer_free_require_SOURCES = cpp03/prefer_free_require.cpp
-cpp03_prefer_member_prefer_SOURCES = cpp03/prefer_member_prefer.cpp
-cpp03_prefer_member_require_SOURCES = cpp03/prefer_member_require.cpp
-cpp03_prefer_static_SOURCES = cpp03/prefer_static.cpp
-cpp03_prefer_unsupported_SOURCES = cpp03/prefer_unsupported.cpp
-cpp03_can_prefer_free_prefer_SOURCES = cpp03/can_prefer_free_prefer.cpp
-cpp03_can_prefer_free_require_SOURCES = cpp03/can_prefer_free_require.cpp
-cpp03_can_prefer_member_prefer_SOURCES = cpp03/can_prefer_member_prefer.cpp
-cpp03_can_prefer_member_require_SOURCES = cpp03/can_prefer_member_require.cpp
-cpp03_can_prefer_static_SOURCES = cpp03/can_prefer_static.cpp
-cpp03_can_prefer_unsupported_SOURCES = cpp03/can_prefer_unsupported.cpp
-cpp03_can_prefer_not_applicable_free_prefer_SOURCES = cpp03/can_prefer_not_applicable_free_prefer.cpp
-cpp03_can_prefer_not_applicable_free_require_SOURCES = cpp03/can_prefer_not_applicable_free_require.cpp
-cpp03_can_prefer_not_applicable_member_prefer_SOURCES = cpp03/can_prefer_not_applicable_member_prefer.cpp
-cpp03_can_prefer_not_applicable_member_require_SOURCES = cpp03/can_prefer_not_applicable_member_require.cpp
-cpp03_can_prefer_not_applicable_static_SOURCES = cpp03/can_prefer_not_applicable_static.cpp
-cpp03_can_prefer_not_applicable_unsupported_SOURCES = cpp03/can_prefer_not_applicable_unsupported.cpp
-cpp03_can_prefer_not_preferable_free_prefer_SOURCES = cpp03/can_prefer_not_preferable_free_prefer.cpp
-cpp03_can_prefer_not_preferable_free_require_SOURCES = cpp03/can_prefer_not_preferable_free_require.cpp
-cpp03_can_prefer_not_preferable_member_prefer_SOURCES = cpp03/can_prefer_not_preferable_member_prefer.cpp
-cpp03_can_prefer_not_preferable_member_require_SOURCES = cpp03/can_prefer_not_preferable_member_require.cpp
-cpp03_can_prefer_not_preferable_static_SOURCES = cpp03/can_prefer_not_preferable_static.cpp
-cpp03_can_prefer_not_preferable_unsupported_SOURCES = cpp03/can_prefer_not_preferable_unsupported.cpp
-
-if HAVE_CXX11
-
-check_PROGRAMS += \
-	cpp11/query_free \
-	cpp11/query_member \
-	cpp11/query_static \
-	cpp11/can_query_free \
-	cpp11/can_query_member \
-	cpp11/can_query_static \
-	cpp11/can_query_unsupported \
-	cpp11/can_query_not_applicable_free \
-	cpp11/can_query_not_applicable_member \
-	cpp11/can_query_not_applicable_static \
-	cpp11/can_query_not_applicable_unsupported \
-	cpp11/require_concept_free \
-	cpp11/require_concept_member \
-	cpp11/require_concept_static \
-	cpp11/can_require_concept_free \
-	cpp11/can_require_concept_member \
-	cpp11/can_require_concept_static \
-	cpp11/can_require_concept_unsupported \
-	cpp11/can_require_concept_not_applicable_free \
-	cpp11/can_require_concept_not_applicable_member \
-	cpp11/can_require_concept_not_applicable_static \
-	cpp11/can_require_concept_not_applicable_unsupported \
-	cpp11/require_free \
-	cpp11/require_member \
-	cpp11/require_static \
-	cpp11/can_require_free \
-	cpp11/can_require_member \
-	cpp11/can_require_static \
-	cpp11/can_require_unsupported \
-	cpp11/can_require_not_applicable_free \
-	cpp11/can_require_not_applicable_member \
-	cpp11/can_require_not_applicable_static \
-	cpp11/can_require_not_applicable_unsupported \
-	cpp11/prefer_free_prefer \
-	cpp11/prefer_member_prefer \
-	cpp11/prefer_free_require \
-	cpp11/prefer_member_require \
-	cpp11/prefer_static \
-	cpp11/prefer_unsupported \
-	cpp11/can_prefer_free_prefer \
-	cpp11/can_prefer_free_require \
-	cpp11/can_prefer_member_prefer \
-	cpp11/can_prefer_member_require \
-	cpp11/can_prefer_static \
-	cpp11/can_prefer_unsupported \
-	cpp11/can_prefer_not_applicable_free_prefer \
-	cpp11/can_prefer_not_applicable_free_require \
-	cpp11/can_prefer_not_applicable_member_prefer \
-	cpp11/can_prefer_not_applicable_member_require \
-	cpp11/can_prefer_not_applicable_static \
-	cpp11/can_prefer_not_applicable_unsupported \
-	cpp11/can_prefer_not_preferable_free_prefer \
-	cpp11/can_prefer_not_preferable_free_require \
-	cpp11/can_prefer_not_preferable_member_prefer \
-	cpp11/can_prefer_not_preferable_member_require \
-	cpp11/can_prefer_not_preferable_static \
-	cpp11/can_prefer_not_preferable_unsupported
-
-cpp11_query_free_SOURCES = cpp11/query_free.cpp
-cpp11_query_member_SOURCES = cpp11/query_member.cpp
-cpp11_query_static_SOURCES = cpp11/query_static.cpp
-cpp11_can_query_free_SOURCES = cpp11/can_query_free.cpp
-cpp11_can_query_member_SOURCES = cpp11/can_query_member.cpp
-cpp11_can_query_static_SOURCES = cpp11/can_query_static.cpp
-cpp11_can_query_unsupported_SOURCES = cpp11/can_query_unsupported.cpp
-cpp11_can_query_not_applicable_free_SOURCES = cpp11/can_query_not_applicable_free.cpp
-cpp11_can_query_not_applicable_member_SOURCES = cpp11/can_query_not_applicable_member.cpp
-cpp11_can_query_not_applicable_static_SOURCES = cpp11/can_query_not_applicable_static.cpp
-cpp11_can_query_not_applicable_unsupported_SOURCES = cpp11/can_query_not_applicable_unsupported.cpp
-cpp11_require_concept_free_SOURCES = cpp11/require_concept_free.cpp
-cpp11_require_concept_member_SOURCES = cpp11/require_concept_member.cpp
-cpp11_require_concept_static_SOURCES = cpp11/require_concept_static.cpp
-cpp11_can_require_concept_free_SOURCES = cpp11/can_require_concept_free.cpp
-cpp11_can_require_concept_member_SOURCES = cpp11/can_require_concept_member.cpp
-cpp11_can_require_concept_static_SOURCES = cpp11/can_require_concept_static.cpp
-cpp11_can_require_concept_unsupported_SOURCES = cpp11/can_require_concept_unsupported.cpp
-cpp11_can_require_concept_not_applicable_free_SOURCES = cpp11/can_require_concept_not_applicable_free.cpp
-cpp11_can_require_concept_not_applicable_member_SOURCES = cpp11/can_require_concept_not_applicable_member.cpp
-cpp11_can_require_concept_not_applicable_static_SOURCES = cpp11/can_require_concept_not_applicable_static.cpp
-cpp11_can_require_concept_not_applicable_unsupported_SOURCES = cpp11/can_require_concept_not_applicable_unsupported.cpp
-cpp11_require_free_SOURCES = cpp11/require_free.cpp
-cpp11_require_member_SOURCES = cpp11/require_member.cpp
-cpp11_require_static_SOURCES = cpp11/require_static.cpp
-cpp11_can_require_free_SOURCES = cpp11/can_require_free.cpp
-cpp11_can_require_member_SOURCES = cpp11/can_require_member.cpp
-cpp11_can_require_static_SOURCES = cpp11/can_require_static.cpp
-cpp11_can_require_unsupported_SOURCES = cpp11/can_require_unsupported.cpp
-cpp11_can_require_not_applicable_free_SOURCES = cpp11/can_require_not_applicable_free.cpp
-cpp11_can_require_not_applicable_member_SOURCES = cpp11/can_require_not_applicable_member.cpp
-cpp11_can_require_not_applicable_static_SOURCES = cpp11/can_require_not_applicable_static.cpp
-cpp11_can_require_not_applicable_unsupported_SOURCES = cpp11/can_require_not_applicable_unsupported.cpp
-cpp11_prefer_free_prefer_SOURCES = cpp11/prefer_free_prefer.cpp
-cpp11_prefer_free_require_SOURCES = cpp11/prefer_free_require.cpp
-cpp11_prefer_member_prefer_SOURCES = cpp11/prefer_member_prefer.cpp
-cpp11_prefer_member_require_SOURCES = cpp11/prefer_member_require.cpp
-cpp11_prefer_static_SOURCES = cpp11/prefer_static.cpp
-cpp11_prefer_unsupported_SOURCES = cpp11/prefer_unsupported.cpp
-cpp11_can_prefer_free_prefer_SOURCES = cpp11/can_prefer_free_prefer.cpp
-cpp11_can_prefer_free_require_SOURCES = cpp11/can_prefer_free_require.cpp
-cpp11_can_prefer_member_prefer_SOURCES = cpp11/can_prefer_member_prefer.cpp
-cpp11_can_prefer_member_require_SOURCES = cpp11/can_prefer_member_require.cpp
-cpp11_can_prefer_static_SOURCES = cpp11/can_prefer_static.cpp
-cpp11_can_prefer_unsupported_SOURCES = cpp11/can_prefer_unsupported.cpp
-cpp11_can_prefer_not_applicable_free_prefer_SOURCES = cpp11/can_prefer_not_applicable_free_prefer.cpp
-cpp11_can_prefer_not_applicable_free_require_SOURCES = cpp11/can_prefer_not_applicable_free_require.cpp
-cpp11_can_prefer_not_applicable_member_prefer_SOURCES = cpp11/can_prefer_not_applicable_member_prefer.cpp
-cpp11_can_prefer_not_applicable_member_require_SOURCES = cpp11/can_prefer_not_applicable_member_require.cpp
-cpp11_can_prefer_not_applicable_static_SOURCES = cpp11/can_prefer_not_applicable_static.cpp
-cpp11_can_prefer_not_applicable_unsupported_SOURCES = cpp11/can_prefer_not_applicable_unsupported.cpp
-cpp11_can_prefer_not_preferable_free_prefer_SOURCES = cpp11/can_prefer_not_preferable_free_prefer.cpp
-cpp11_can_prefer_not_preferable_free_require_SOURCES = cpp11/can_prefer_not_preferable_free_require.cpp
-cpp11_can_prefer_not_preferable_member_prefer_SOURCES = cpp11/can_prefer_not_preferable_member_prefer.cpp
-cpp11_can_prefer_not_preferable_member_require_SOURCES = cpp11/can_prefer_not_preferable_member_require.cpp
-cpp11_can_prefer_not_preferable_static_SOURCES = cpp11/can_prefer_not_preferable_static.cpp
-cpp11_can_prefer_not_preferable_unsupported_SOURCES = cpp11/can_prefer_not_preferable_unsupported.cpp
-
-endif
-
-if HAVE_CXX14
-
-check_PROGRAMS += \
-	cpp14/query_free \
-	cpp14/query_member \
-	cpp14/query_static \
-	cpp14/can_query_free \
-	cpp14/can_query_member \
-	cpp14/can_query_static \
-	cpp14/can_query_unsupported \
-	cpp14/can_query_not_applicable_free \
-	cpp14/can_query_not_applicable_member \
-	cpp14/can_query_not_applicable_static \
-	cpp14/can_query_not_applicable_unsupported \
-	cpp14/require_concept_free \
-	cpp14/require_concept_member \
-	cpp14/require_concept_static \
-	cpp14/can_require_concept_free \
-	cpp14/can_require_concept_member \
-	cpp14/can_require_concept_static \
-	cpp14/can_require_concept_unsupported \
-	cpp14/can_require_concept_not_applicable_free \
-	cpp14/can_require_concept_not_applicable_member \
-	cpp14/can_require_concept_not_applicable_static \
-	cpp14/can_require_concept_not_applicable_unsupported \
-	cpp14/require_free \
-	cpp14/require_member \
-	cpp14/require_static \
-	cpp14/can_require_free \
-	cpp14/can_require_member \
-	cpp14/can_require_static \
-	cpp14/can_require_unsupported \
-	cpp14/can_require_not_applicable_free \
-	cpp14/can_require_not_applicable_member \
-	cpp14/can_require_not_applicable_static \
-	cpp14/can_require_not_applicable_unsupported \
-	cpp14/prefer_free_prefer \
-	cpp14/prefer_member_prefer \
-	cpp14/prefer_free_require \
-	cpp14/prefer_member_require \
-	cpp14/prefer_static \
-	cpp14/prefer_unsupported \
-	cpp14/can_prefer_free_prefer \
-	cpp14/can_prefer_free_require \
-	cpp14/can_prefer_member_prefer \
-	cpp14/can_prefer_member_require \
-	cpp14/can_prefer_static \
-	cpp14/can_prefer_unsupported \
-	cpp14/can_prefer_not_applicable_free_prefer \
-	cpp14/can_prefer_not_applicable_free_require \
-	cpp14/can_prefer_not_applicable_member_prefer \
-	cpp14/can_prefer_not_applicable_member_require \
-	cpp14/can_prefer_not_applicable_static \
-	cpp14/can_prefer_not_applicable_unsupported \
-	cpp14/can_prefer_not_preferable_free_prefer \
-	cpp14/can_prefer_not_preferable_free_require \
-	cpp14/can_prefer_not_preferable_member_prefer \
-	cpp14/can_prefer_not_preferable_member_require \
-	cpp14/can_prefer_not_preferable_static \
-	cpp14/can_prefer_not_preferable_unsupported
-
-cpp14_query_free_SOURCES = cpp14/query_free.cpp
-cpp14_query_member_SOURCES = cpp14/query_member.cpp
-cpp14_query_static_SOURCES = cpp14/query_static.cpp
-cpp14_can_query_free_SOURCES = cpp14/can_query_free.cpp
-cpp14_can_query_member_SOURCES = cpp14/can_query_member.cpp
-cpp14_can_query_static_SOURCES = cpp14/can_query_static.cpp
-cpp14_can_query_unsupported_SOURCES = cpp14/can_query_unsupported.cpp
-cpp14_can_query_not_applicable_free_SOURCES = cpp14/can_query_not_applicable_free.cpp
-cpp14_can_query_not_applicable_member_SOURCES = cpp14/can_query_not_applicable_member.cpp
-cpp14_can_query_not_applicable_static_SOURCES = cpp14/can_query_not_applicable_static.cpp
-cpp14_can_query_not_applicable_unsupported_SOURCES = cpp14/can_query_not_applicable_unsupported.cpp
-cpp14_require_concept_free_SOURCES = cpp14/require_concept_free.cpp
-cpp14_require_concept_member_SOURCES = cpp14/require_concept_member.cpp
-cpp14_require_concept_static_SOURCES = cpp14/require_concept_static.cpp
-cpp14_can_require_concept_free_SOURCES = cpp14/can_require_concept_free.cpp
-cpp14_can_require_concept_member_SOURCES = cpp14/can_require_concept_member.cpp
-cpp14_can_require_concept_static_SOURCES = cpp14/can_require_concept_static.cpp
-cpp14_can_require_concept_unsupported_SOURCES = cpp14/can_require_concept_unsupported.cpp
-cpp14_can_require_concept_not_applicable_free_SOURCES = cpp14/can_require_concept_not_applicable_free.cpp
-cpp14_can_require_concept_not_applicable_member_SOURCES = cpp14/can_require_concept_not_applicable_member.cpp
-cpp14_can_require_concept_not_applicable_static_SOURCES = cpp14/can_require_concept_not_applicable_static.cpp
-cpp14_can_require_concept_not_applicable_unsupported_SOURCES = cpp14/can_require_concept_not_applicable_unsupported.cpp
-cpp14_require_free_SOURCES = cpp14/require_free.cpp
-cpp14_require_member_SOURCES = cpp14/require_member.cpp
-cpp14_require_static_SOURCES = cpp14/require_static.cpp
-cpp14_can_require_free_SOURCES = cpp14/can_require_free.cpp
-cpp14_can_require_member_SOURCES = cpp14/can_require_member.cpp
-cpp14_can_require_static_SOURCES = cpp14/can_require_static.cpp
-cpp14_can_require_unsupported_SOURCES = cpp14/can_require_unsupported.cpp
-cpp14_can_require_not_applicable_free_SOURCES = cpp14/can_require_not_applicable_free.cpp
-cpp14_can_require_not_applicable_member_SOURCES = cpp14/can_require_not_applicable_member.cpp
-cpp14_can_require_not_applicable_static_SOURCES = cpp14/can_require_not_applicable_static.cpp
-cpp14_can_require_not_applicable_unsupported_SOURCES = cpp14/can_require_not_applicable_unsupported.cpp
-cpp14_prefer_free_prefer_SOURCES = cpp14/prefer_free_prefer.cpp
-cpp14_prefer_free_require_SOURCES = cpp14/prefer_free_require.cpp
-cpp14_prefer_member_prefer_SOURCES = cpp14/prefer_member_prefer.cpp
-cpp14_prefer_member_require_SOURCES = cpp14/prefer_member_require.cpp
-cpp14_prefer_static_SOURCES = cpp14/prefer_static.cpp
-cpp14_prefer_unsupported_SOURCES = cpp14/prefer_unsupported.cpp
-cpp14_can_prefer_free_prefer_SOURCES = cpp14/can_prefer_free_prefer.cpp
-cpp14_can_prefer_free_require_SOURCES = cpp14/can_prefer_free_require.cpp
-cpp14_can_prefer_member_prefer_SOURCES = cpp14/can_prefer_member_prefer.cpp
-cpp14_can_prefer_member_require_SOURCES = cpp14/can_prefer_member_require.cpp
-cpp14_can_prefer_static_SOURCES = cpp14/can_prefer_static.cpp
-cpp14_can_prefer_unsupported_SOURCES = cpp14/can_prefer_unsupported.cpp
-cpp14_can_prefer_not_applicable_free_prefer_SOURCES = cpp14/can_prefer_not_applicable_free_prefer.cpp
-cpp14_can_prefer_not_applicable_free_require_SOURCES = cpp14/can_prefer_not_applicable_free_require.cpp
-cpp14_can_prefer_not_applicable_member_prefer_SOURCES = cpp14/can_prefer_not_applicable_member_prefer.cpp
-cpp14_can_prefer_not_applicable_member_require_SOURCES = cpp14/can_prefer_not_applicable_member_require.cpp
-cpp14_can_prefer_not_applicable_static_SOURCES = cpp14/can_prefer_not_applicable_static.cpp
-cpp14_can_prefer_not_applicable_unsupported_SOURCES = cpp14/can_prefer_not_applicable_unsupported.cpp
-cpp14_can_prefer_not_preferable_free_prefer_SOURCES = cpp14/can_prefer_not_preferable_free_prefer.cpp
-cpp14_can_prefer_not_preferable_free_require_SOURCES = cpp14/can_prefer_not_preferable_free_require.cpp
-cpp14_can_prefer_not_preferable_member_prefer_SOURCES = cpp14/can_prefer_not_preferable_member_prefer.cpp
-cpp14_can_prefer_not_preferable_member_require_SOURCES = cpp14/can_prefer_not_preferable_member_require.cpp
-cpp14_can_prefer_not_preferable_static_SOURCES = cpp14/can_prefer_not_preferable_static.cpp
-cpp14_can_prefer_not_preferable_unsupported_SOURCES = cpp14/can_prefer_not_preferable_unsupported.cpp
-
-endif
-
-TESTS = $(check_PROGRAMS)
-
-AM_CXXFLAGS = -I$(srcdir)/../../../include
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.msc b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.msc
deleted file mode 100644
index d5a842a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/Makefile.msc
+++ /dev/null
@@ -1,308 +0,0 @@
-COMMON_CXXFLAGS = -nologo -GR -EHsc -I. -I../../../include
-
-!ifdef CXXLATEST
-STD_CXXFLAGS = -std:c++latest
-!endif
-
-!ifdef WARNINGS
-WARNINGS_CXXFLAGS = -W4 -wd4512 -wd4447
-!endif
-
-!ifdef STATICRTL
-! ifdef DEBUG
-DEBUG_CXXFLAGS = -Zi -MTd
-! else
-DEBUG_CXXFLAGS = -O2 -MT
-! endif
-!else
-! ifdef DEBUG
-DEBUG_CXXFLAGS = -Zi -MDd
-! else
-DEBUG_CXXFLAGS = -O2 -MD
-! endif
-!endif
-
-!ifdef UNICODE
-UNICODE_CXXFLAGS = -DUNICODE -D_UNICODE
-!endif
-
-!ifdef TRACKING
-TRACKING_CXXFLAGS = -DASIO_ENABLE_HANDLER_TRACKING
-!endif
-
-!ifndef _WIN32_WINNT
-! ifdef STORE
-_WIN32_WINNT=0x0603
-! else
-_WIN32_WINNT=0x0601
-! endif
-!endif
-
-!ifdef WIN9X
-DEFINES = \
-	-DASIO_DISABLE_IOCP \
-	-D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!else
-! ifdef STORE
-DEFINES = \
-	-DWINAPI_FAMILY=WINAPI_FAMILY_PC_APP \
-	-DBOOST_ALL_NO_LIB -D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DUNICODE -D_UNICODE \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-! else
-!  ifdef WINRT
-DEFINES = \
-	-ZW -FI SDKDDKVer.h -FI winapifamily.h -DWINAPI_FAMILY=WINAPI_PARTITION_APP \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!  else
-DEFINES = \
-	-D_WIN32_WINNT=$(_WIN32_WINNT) \
-	-DBOOST_ALL_NO_LIB \
-	-DBOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
-!  endif
-! endif
-!endif
-
-!ifdef STANDALONE
-STANDALONE_CXXFLAGS = -DASIO_STANDALONE
-!else
-STANDALONE_CXXFLAGS = -I$(BOOSTDIR) -DASIO_ENABLE_BOOST
-!endif
-
-CXXFLAGS = \
-	$(COMMON_CXXFLAGS) \
-	$(STD_CXXFLAGS) \
-	$(WARNINGS_CXXFLAGS) \
-	$(DEBUG_CXXFLAGS) \
-	$(UNICODE_CXXFLAGS) \
-	$(TRACKING_CXXFLAGS) \
-	$(STANDALONE_CXXFLAGS)
-
-CPP03_TEST_EXES = \
-	cpp03\query_free.exe \
-	cpp03\query_member.exe \
-	cpp03\query_static.exe \
-	cpp03\can_query_free.exe \
-	cpp03\can_query_member.exe \
-	cpp03\can_query_static.exe \
-	cpp03\can_query_unsupported.exe \
-	cpp03\can_query_not_applicable_free.exe \
-	cpp03\can_query_not_applicable_member.exe \
-	cpp03\can_query_not_applicable_static.exe \
-	cpp03\can_query_not_applicable_unsupported.exe \
-	cpp03\require_concept_free.exe \
-	cpp03\require_concept_member.exe \
-	cpp03\require_concept_static.exe \
-	cpp03\can_require_concept_free.exe \
-	cpp03\can_require_concept_member.exe \
-	cpp03\can_require_concept_static.exe \
-	cpp03\can_require_concept_unsupported.exe \
-	cpp03\can_require_concept_not_applicable_free.exe \
-	cpp03\can_require_concept_not_applicable_member.exe \
-	cpp03\can_require_concept_not_applicable_static.exe \
-	cpp03\can_require_concept_not_applicable_unsupported.exe \
-	cpp03\require_free.exe \
-	cpp03\require_member.exe \
-	cpp03\require_static.exe \
-	cpp03\can_require_free.exe \
-	cpp03\can_require_member.exe \
-	cpp03\can_require_static.exe \
-	cpp03\can_require_unsupported.exe \
-	cpp03\can_require_not_applicable_free.exe \
-	cpp03\can_require_not_applicable_member.exe \
-	cpp03\can_require_not_applicable_static.exe \
-	cpp03\can_require_not_applicable_unsupported.exe \
-	cpp03\prefer_free_prefer.exe \
-	cpp03\prefer_member_prefer.exe \
-	cpp03\prefer_free_require.exe \
-	cpp03\prefer_member_require.exe \
-	cpp03\prefer_static.exe \
-	cpp03\prefer_unsupported.exe \
-	cpp03\can_prefer_free_prefer.exe \
-	cpp03\can_prefer_free_require.exe \
-	cpp03\can_prefer_member_prefer.exe \
-	cpp03\can_prefer_member_require.exe \
-	cpp03\can_prefer_static.exe \
-	cpp03\can_prefer_unsupported.exe \
-	cpp03\can_prefer_not_applicable_free_prefer.exe \
-	cpp03\can_prefer_not_applicable_free_require.exe \
-	cpp03\can_prefer_not_applicable_member_prefer.exe \
-	cpp03\can_prefer_not_applicable_member_require.exe \
-	cpp03\can_prefer_not_applicable_static.exe \
-	cpp03\can_prefer_not_applicable_unsupported.exe \
-	cpp03\can_prefer_not_preferable_free_prefer.exe \
-	cpp03\can_prefer_not_preferable_free_require.exe \
-	cpp03\can_prefer_not_preferable_member_prefer.exe \
-	cpp03\can_prefer_not_preferable_member_require.exe \
-	cpp03\can_prefer_not_preferable_static.exe \
-	cpp03\can_prefer_not_preferable_unsupported.exe
-
-!ifdef CPP11
-
-CPP11_TEST_EXES = \
-	cpp11\query_free.exe \
-	cpp11\query_member.exe \
-	cpp11\query_static.exe \
-	cpp11\can_query_free.exe \
-	cpp11\can_query_member.exe \
-	cpp11\can_query_static.exe \
-	cpp11\can_query_unsupported.exe \
-	cpp11\can_query_not_applicable_free.exe \
-	cpp11\can_query_not_applicable_member.exe \
-	cpp11\can_query_not_applicable_static.exe \
-	cpp11\can_query_not_applicable_unsupported.exe \
-	cpp11\require_concept_free.exe \
-	cpp11\require_concept_member.exe \
-	cpp11\require_concept_static.exe \
-	cpp11\can_require_concept_free.exe \
-	cpp11\can_require_concept_member.exe \
-	cpp11\can_require_concept_static.exe \
-	cpp11\can_require_concept_unsupported.exe \
-	cpp11\can_require_concept_not_applicable_free.exe \
-	cpp11\can_require_concept_not_applicable_member.exe \
-	cpp11\can_require_concept_not_applicable_static.exe \
-	cpp11\can_require_concept_not_applicable_unsupported.exe \
-	cpp11\require_free.exe \
-	cpp11\require_member.exe \
-	cpp11\require_static.exe \
-	cpp11\can_require_free.exe \
-	cpp11\can_require_member.exe \
-	cpp11\can_require_static.exe \
-	cpp11\can_require_unsupported.exe \
-	cpp11\can_require_not_applicable_free.exe \
-	cpp11\can_require_not_applicable_member.exe \
-	cpp11\can_require_not_applicable_static.exe \
-	cpp11\can_require_not_applicable_unsupported.exe \
-	cpp11\prefer_free_prefer.exe \
-	cpp11\prefer_member_prefer.exe \
-	cpp11\prefer_free_require.exe \
-	cpp11\prefer_member_require.exe \
-	cpp11\prefer_static.exe \
-	cpp11\prefer_unsupported.exe \
-	cpp11\can_prefer_free_prefer.exe \
-	cpp11\can_prefer_free_require.exe \
-	cpp11\can_prefer_member_prefer.exe \
-	cpp11\can_prefer_member_require.exe \
-	cpp11\can_prefer_static.exe \
-	cpp11\can_prefer_unsupported.exe \
-	cpp11\can_prefer_not_applicable_free_prefer.exe \
-	cpp11\can_prefer_not_applicable_free_require.exe \
-	cpp11\can_prefer_not_applicable_member_prefer.exe \
-	cpp11\can_prefer_not_applicable_member_require.exe \
-	cpp11\can_prefer_not_applicable_static.exe \
-	cpp11\can_prefer_not_applicable_unsupported.exe \
-	cpp11\can_prefer_not_preferable_free_prefer.exe \
-	cpp11\can_prefer_not_preferable_free_require.exe \
-	cpp11\can_prefer_not_preferable_member_prefer.exe \
-	cpp11\can_prefer_not_preferable_member_require.exe \
-	cpp11\can_prefer_not_preferable_static.exe \
-	cpp11\can_prefer_not_preferable_unsupported.exe
-
-!endif
-
-!ifdef CPP14
-
-CPP14_TEST_EXES = \
-	cpp14\query_free.exe \
-	cpp14\query_member.exe \
-	cpp14\query_static.exe \
-	cpp14\can_query_free.exe \
-	cpp14\can_query_member.exe \
-	cpp14\can_query_static.exe \
-	cpp14\can_query_unsupported.exe \
-	cpp14\can_query_not_applicable_free.exe \
-	cpp14\can_query_not_applicable_member.exe \
-	cpp14\can_query_not_applicable_static.exe \
-	cpp14\can_query_not_applicable_unsupported.exe \
-	cpp14\require_concept_free.exe \
-	cpp14\require_concept_member.exe \
-	cpp14\require_concept_static.exe \
-	cpp14\can_require_concept_free.exe \
-	cpp14\can_require_concept_member.exe \
-	cpp14\can_require_concept_static.exe \
-	cpp14\can_require_concept_unsupported.exe \
-	cpp14\can_require_concept_not_applicable_free.exe \
-	cpp14\can_require_concept_not_applicable_member.exe \
-	cpp14\can_require_concept_not_applicable_static.exe \
-	cpp14\can_require_concept_not_applicable_unsupported.exe \
-	cpp14\require_free.exe \
-	cpp14\require_member.exe \
-	cpp14\require_static.exe \
-	cpp14\can_require_free.exe \
-	cpp14\can_require_member.exe \
-	cpp14\can_require_static.exe \
-	cpp14\can_require_unsupported.exe \
-	cpp14\can_require_not_applicable_free.exe \
-	cpp14\can_require_not_applicable_member.exe \
-	cpp14\can_require_not_applicable_static.exe \
-	cpp14\can_require_not_applicable_unsupported.exe \
-	cpp14\prefer_free_prefer.exe \
-	cpp14\prefer_member_prefer.exe \
-	cpp14\prefer_free_require.exe \
-	cpp14\prefer_member_require.exe \
-	cpp14\prefer_static.exe \
-	cpp14\prefer_unsupported.exe \
-	cpp14\can_prefer_free_prefer.exe \
-	cpp14\can_prefer_free_require.exe \
-	cpp14\can_prefer_member_prefer.exe \
-	cpp14\can_prefer_member_require.exe \
-	cpp14\can_prefer_static.exe \
-	cpp14\can_prefer_unsupported.exe \
-	cpp14\can_prefer_not_applicable_free_prefer.exe \
-	cpp14\can_prefer_not_applicable_free_require.exe \
-	cpp14\can_prefer_not_applicable_member_prefer.exe \
-	cpp14\can_prefer_not_applicable_member_require.exe \
-	cpp14\can_prefer_not_applicable_static.exe \
-	cpp14\can_prefer_not_applicable_unsupported.exe \
-	cpp14\can_prefer_not_preferable_free_prefer.exe \
-	cpp14\can_prefer_not_preferable_free_require.exe \
-	cpp14\can_prefer_not_preferable_member_prefer.exe \
-	cpp14\can_prefer_not_preferable_member_require.exe \
-	cpp14\can_prefer_not_preferable_static.exe \
-	cpp14\can_prefer_not_preferable_unsupported.exe
-
-!endif
-
-TEST_EXES = \
-	$(CPP03_TEST_EXES) \
-	$(CPP11_TEST_EXES) \
-	$(CPP14_TEST_EXES)
-
-all: \
-	$(TEST_EXES)
-
-check: $(TEST_EXES)
-	!@echo === Running $** === && $** && echo.
-
-{cpp03}.cpp{cpp03}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{cpp11}.cpp{cpp11}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-{cpp14}.cpp{cpp14}.exe:
-	cl -Fe$@ -Fo$(<:.cpp=.obj) $(CXXFLAGS) $(DEFINES) $< $(LIBS) -link -opt:ref
-
-clean:
-	-del /q /s cpp03\*.exe
-	-del /q /s cpp03\*.exe.manifest
-	-del /q /s cpp03\*.exp
-	-del /q /s cpp03\*.ilk
-	-del /q /s cpp03\*.pdb
-	-del /q /s cpp03\*.obj
-	-del /q /s cpp11\*.exe
-	-del /q /s cpp11\*.exe.manifest
-	-del /q /s cpp11\*.exp
-	-del /q /s cpp11\*.ilk
-	-del /q /s cpp11\*.pdb
-	-del /q /s cpp11\*.obj
-	-del /q /s cpp14\*.exe
-	-del /q /s cpp14\*.exe.manifest
-	-del /q /s cpp14\*.exp
-	-del /q /s cpp14\*.ilk
-	-del /q /s cpp14\*.pdb
-	-del /q /s cpp14\*.obj
-	-del /q /s *.pdb
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_prefer.cpp
deleted file mode 100644
index e9784f6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_prefer.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<2> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_require.cpp
deleted file mode 100644
index 693a461..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_free_require.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<2> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_prefer.cpp
deleted file mode 100644
index 011a347..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_prefer.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<2> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_require.cpp
deleted file mode 100644
index 9364391..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_member_require.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<2> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_prefer.cpp
deleted file mode 100644
index 8fd11c6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_prefer.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct prefer_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_require.cpp
deleted file mode 100644
index 5c205ad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_free_require.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_prefer.cpp
deleted file mode 100644
index 15e93fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_prefer.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct prefer_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_require.cpp
deleted file mode 100644
index 0a0f1f6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_member_require.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_static.cpp
deleted file mode 100644
index f564d2f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_static.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<1> >::value));
-  assert((!asio::can_prefer<object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_unsupported.cpp
deleted file mode 100644
index 0711d7c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// cpp03/can_prefer_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_prefer.cpp
deleted file mode 100644
index 3a522e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_prefer.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_require.cpp
deleted file mode 100644
index 39ea91f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_free_require.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_prefer.cpp
deleted file mode 100644
index e61f898..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_prefer.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_require.cpp
deleted file mode 100644
index 0052cc3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_member_require.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_static.cpp
deleted file mode 100644
index f342806..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<1> >::value));
-  assert((!asio::can_prefer<object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_unsupported.cpp
deleted file mode 100644
index 1469593..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_not_preferable_unsupported.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp03/can_prefer_not_preferable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_prefer<object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_static.cpp
deleted file mode 100644
index ac1f5c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<1> >::value));
-  assert((asio::can_prefer<object<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_prefer<const object<1>, prop<1> >::value));
-  assert((asio::can_prefer<const object<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_unsupported.cpp
deleted file mode 100644
index e59e5d0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_prefer_unsupported.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp03/can_prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_prefer<object<1>, prop<2> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_free.cpp
deleted file mode 100644
index d0d42fe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_free.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend int query(const object&, prop) { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct query_free<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_query<object, prop>::value));
-  assert((asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_member.cpp
deleted file mode 100644
index 9ead9be..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_member.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  int query(prop) const { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct query_member<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_query<object, prop>::value));
-  assert((asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_free.cpp
deleted file mode 100644
index b360327..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_free.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp03/can_query_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend int query(const object&, prop) { return 123; }
-};
-
-namespace asio {
-namespace traits {
-
-template<>
-struct query_free<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_query<object, prop>::value));
-  assert((!asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_member.cpp
deleted file mode 100644
index be339d0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_member.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp03/can_query_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  int query(prop) const { return 123; }
-};
-
-namespace asio {
-namespace traits {
-
-template<>
-struct query_member<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_query<object, prop>::value));
-  assert((!asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_static.cpp
deleted file mode 100644
index 127e2ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_static.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp03/can_query_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-  static int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_query<object, prop>::value));
-  assert((!asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_unsupported.cpp
deleted file mode 100644
index ec1c07a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// cpp03/can_query_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-int main()
-{
-  assert((!asio::can_query<object, prop>::value));
-  assert((!asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_static.cpp
deleted file mode 100644
index 9a30571..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_static.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-  static int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_query<object, prop>::value));
-  assert((asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_unsupported.cpp
deleted file mode 100644
index 8eefbe9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_query_unsupported.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// cpp03/can_query_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template <>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_query<object, prop>::value));
-  assert((!asio::can_query<const object, prop>::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_free.cpp
deleted file mode 100644
index 810dfc2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_free.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/can_require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_concept_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_member.cpp
deleted file mode 100644
index 615e8a0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_member.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/can_require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_concept_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_free.cpp
deleted file mode 100644
index c076dd4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_free.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_require_concept_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_concept_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((!asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_member.cpp
deleted file mode 100644
index e6e258e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_member.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_require_concept_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_concept_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((!asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_static.cpp
deleted file mode 100644
index c42a1b3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_static.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp03/can_require_concept_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((!asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_unsupported.cpp
deleted file mode 100644
index 261c4be..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp03/can_require_concept_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  assert((!asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((!asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_static.cpp
deleted file mode 100644
index 3c7d7bf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_static.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp03/can_require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require_concept<object<1>, prop<1> >::value));
-  assert((asio::can_require_concept<const object<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_unsupported.cpp
deleted file mode 100644
index 0fbcbd3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_concept_unsupported.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp03/can_require_concept_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require_concept<object<1>, prop<2> >::value));
-  assert((!asio::can_require_concept<const object<1>, prop<2> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_free.cpp
deleted file mode 100644
index fdd9241..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_free.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require<object<1>, prop<2> >::value));
-  assert((asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_require<const object<1>, prop<2> >::value));
-  assert((asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_member.cpp
deleted file mode 100644
index 3f9a427..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_member.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp03/can_require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require<object<1>, prop<2> >::value));
-  assert((asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((asio::can_require<const object<1>, prop<2> >::value));
-  assert((asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_free.cpp
deleted file mode 100644
index 4bf8ca3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_free.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_require_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require<object<1>, prop<2> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_require<const object<1>, prop<2> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_member.cpp
deleted file mode 100644
index 842c8d4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_member.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_require_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require<object<1>, prop<2> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_require<const object<1>, prop<2> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_static.cpp
deleted file mode 100644
index e8d9ac6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_static.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// cpp03/can_require_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require<object<1>, prop<1> >::value));
-  assert((!asio::can_require<object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_require<object<1>, prop<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_require<const object<1>, prop<1> >::value));
-  assert((!asio::can_require<const object<1>, prop<1>, prop<1> >::value));
-  assert((!asio::can_require<const object<1>, prop<1>, prop<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_unsupported.cpp
deleted file mode 100644
index 6fe2347..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// cpp03/can_require_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  assert((!asio::can_require<object<1>, prop<2> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_require<const object<1>, prop<2> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_static.cpp
deleted file mode 100644
index 5d4a657..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp03/can_require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  assert((asio::can_require<object<1>, prop<1> >::value));
-  assert((asio::can_require<object<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_require<object<1>, prop<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_require<const object<1>, prop<1> >::value));
-  assert((asio::can_require<const object<1>, prop<1>, prop<1> >::value));
-  assert((asio::can_require<const object<1>, prop<1>, prop<1>, prop<1> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_unsupported.cpp
deleted file mode 100644
index f3bf74b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/can_require_unsupported.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// cpp03/can_require_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  assert((!asio::can_require<object<1>, prop<2> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<object<1>, prop<2>, prop<3>, prop<4> >::value));
-  assert((!asio::can_require<const object<1>, prop<2> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3> >::value));
-  assert((!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4> >::value));
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_prefer.cpp
deleted file mode 100644
index dcf89c7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_prefer.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_require.cpp
deleted file mode 100644
index 223d3a6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_free_require.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_prefer.cpp
deleted file mode 100644
index 538f7b2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_prefer.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct prefer_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_require.cpp
deleted file mode 100644
index f659b6f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_member_require.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_static.cpp
deleted file mode 100644
index f5fcb7f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_static.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// cpp03/prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::prefer(o1, prop<1>());
-  object<1> o3 = asio::prefer(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::prefer(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::prefer(o5, prop<1>());
-  object<1> o7 = asio::prefer(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::prefer(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_unsupported.cpp
deleted file mode 100644
index 25e0f30..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/prefer_unsupported.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// cpp03/prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  const object<1>& o2 = asio::prefer(o1, prop<1>());
-  assert(&o1 == &o2);
-  (void)o2;
-
-  const object<1> o3 = {};
-  const object<1>& o4 = asio::prefer(o3, prop<1>());
-  assert(&o3 == &o4);
-  (void)o4;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_free.cpp
deleted file mode 100644
index a9aae56..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_free.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend int query(const object&, prop) { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct query_free<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_member.cpp
deleted file mode 100644
index a1ab83e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_member.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  int query(prop) const { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct query_member<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_static.cpp
deleted file mode 100644
index b0e0b40..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/query_static.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef int result_type;
-  static int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_free.cpp
deleted file mode 100644
index 6cccdd2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_free.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// cpp03/require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_concept_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_member.cpp
deleted file mode 100644
index 6734932..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_member.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// cpp03/require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_concept_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_static.cpp
deleted file mode 100644
index e92ffa1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_concept_static.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp03/require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  const object<1>& o2 = asio::require_concept(o1, prop<1>());
-  assert(&o1 == &o2);
-  (void)o2;
-
-  const object<1> o3 = {};
-  const object<1>& o4 = asio::require_concept(o3, prop<1>());
-  assert(&o3 == &o4);
-  (void)o4;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_free.cpp
deleted file mode 100644
index 04734ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_free.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_free<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_member.cpp
deleted file mode 100644
index fc6bdc2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_member.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp03/require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N, int M>
-struct require_member<object<N>, prop<M> >
-{
-  static const bool is_valid = true;
-  static const bool is_noexcept = true;
-  typedef object<M> result_type;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_static.cpp
deleted file mode 100644
index 33512b3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp03/require_static.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//
-// cpp03/require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static const bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static const bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static const bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::require(o1, prop<1>());
-  object<1> o3 = asio::require(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::require(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::require(o5, prop<1>());
-  object<1> o7 = asio::require(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::require(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_prefer.cpp
deleted file mode 100644
index 860fa6f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_prefer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_require.cpp
deleted file mode 100644
index b842e9a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_free_require.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_prefer.cpp
deleted file mode 100644
index 9f00cbc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_prefer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_require.cpp
deleted file mode 100644
index a81bae1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_member_require.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_prefer.cpp
deleted file mode 100644
index 9079c1f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_prefer.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_require.cpp
deleted file mode 100644
index 52fc618..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_free_require.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_prefer.cpp
deleted file mode 100644
index 93f0c85..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_prefer.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_require.cpp
deleted file mode 100644
index e17ec93..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_member_require.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_static.cpp
deleted file mode 100644
index 9087ed4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_static.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_unsupported.cpp
deleted file mode 100644
index b09d157..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// cpp11/can_prefer_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_prefer.cpp
deleted file mode 100644
index 28a1d15..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_prefer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_require.cpp
deleted file mode 100644
index cbb1054..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_free_require.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_prefer.cpp
deleted file mode 100644
index 2d46050..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_prefer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_require.cpp
deleted file mode 100644
index 4e03c02..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_member_require.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_static.cpp
deleted file mode 100644
index 0791d8a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_static.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_unsupported.cpp
deleted file mode 100644
index 059944e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_not_preferable_unsupported.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp11/can_prefer_not_preferable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_static.cpp
deleted file mode 100644
index c928f7f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp11/can_prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<1>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<1>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_unsupported.cpp
deleted file mode 100644
index 32d6ac5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_prefer_unsupported.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp11/can_prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_prefer<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_prefer<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_free.cpp
deleted file mode 100644
index 330493b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_free.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// cpp11/can_query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_query<object, prop>::value, "");
-  static_assert(asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_member.cpp
deleted file mode 100644
index e1442d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_member.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// cpp11/can_query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_query<object, prop>::value, "");
-  static_assert(asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_free.cpp
deleted file mode 100644
index 2be49af..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_free.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp11/can_query_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-int main()
-{
-  static_assert(!asio::can_query<object, prop>::value, "");
-  static_assert(!asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_member.cpp
deleted file mode 100644
index 788148d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_member.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp11/can_query_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-int main()
-{
-  static_assert(!asio::can_query<object, prop>::value, "");
-  static_assert(!asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_static.cpp
deleted file mode 100644
index c57848c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_static.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp11/can_query_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef int result_type;
-  static constexpr int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_query<object, prop>::value, "");
-  static_assert(!asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_unsupported.cpp
deleted file mode 100644
index 79bff62..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// cpp11/can_query_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_query<object, prop>::value, "");
-  static_assert(!asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_static.cpp
deleted file mode 100644
index 6dc2581..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_static.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef int result_type;
-  static constexpr int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_query<object, prop>::value, "");
-  static_assert(asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_unsupported.cpp
deleted file mode 100644
index 369955e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_query_unsupported.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// cpp11/can_query_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_query<object, prop>::value, "");
-  static_assert(!asio::can_query<const object, prop>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_free.cpp
deleted file mode 100644
index 3dd6170..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_free.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// cpp11/can_require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_member.cpp
deleted file mode 100644
index 55ac468..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_member.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// cpp11/can_require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_free.cpp
deleted file mode 100644
index af40b48..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_free.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp11/can_require_concept_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_member.cpp
deleted file mode 100644
index baf6b9f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_member.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp11/can_require_concept_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_static.cpp
deleted file mode 100644
index 7d7f138..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_static.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-// cpp11/can_require_concept_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_unsupported.cpp
deleted file mode 100644
index 13e05b2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp11/can_require_concept_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_static.cpp
deleted file mode 100644
index 07973a5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_static.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require_concept<object<1>, prop<1>>::value, "");
-  static_assert(asio::can_require_concept<const object<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_unsupported.cpp
deleted file mode 100644
index 4a4fee1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_concept_unsupported.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_require_concept_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_free.cpp
deleted file mode 100644
index b66965e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_free.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_member.cpp
deleted file mode 100644
index cac4641..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_member.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// cpp11/can_require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_free.cpp
deleted file mode 100644
index 9705b87..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_free.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_require_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_member.cpp
deleted file mode 100644
index cd7f75f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_member.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp11/can_require_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_static.cpp
deleted file mode 100644
index f852e45..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_static.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// cpp11/can_require_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require<object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<1>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_unsupported.cpp
deleted file mode 100644
index e6286ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// cpp11/can_require_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_static.cpp
deleted file mode 100644
index 4c1b38f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp11/can_require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  static_assert(asio::can_require<object<1>, prop<1>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_require<object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<1>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<1>, prop<1>>::value, "");
-  static_assert(asio::can_require<const object<1>, prop<1>, prop<1>, prop<1>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_unsupported.cpp
deleted file mode 100644
index bc9c4ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/can_require_unsupported.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// cpp11/can_require_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>>::value, "");
-  static_assert(!asio::can_require<const object<1>, prop<2>, prop<3>, prop<4>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_prefer.cpp
deleted file mode 100644
index 3faf001..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_prefer.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_require.cpp
deleted file mode 100644
index f30d0fb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_free_require.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_prefer.cpp
deleted file mode 100644
index 9803d5e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_prefer.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_require.cpp
deleted file mode 100644
index 701fb2d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_member_require.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_static.cpp
deleted file mode 100644
index 18cd713..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_static.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp11/prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::prefer(o1, prop<1>());
-  object<1> o3 = asio::prefer(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::prefer(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::prefer(o5, prop<1>());
-  object<1> o7 = asio::prefer(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::prefer(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::prefer(object<1>(), prop<1>());
-  constexpr object<1> o10 = asio::prefer(object<1>(), prop<1>(), prop<1>());
-  constexpr object<1> o11 = asio::prefer(object<1>(), prop<1>(), prop<1>(), prop<1>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_unsupported.cpp
deleted file mode 100644
index 8eb5423..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/prefer_unsupported.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// cpp11/prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::prefer(o1, prop<2>());
-  object<1> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<1> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::prefer(o5, prop<2>());
-  object<1> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<1> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<1> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<1> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_free.cpp
deleted file mode 100644
index 17a14dc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_free.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// cpp11/query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_member.cpp
deleted file mode 100644
index 18ea241..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_member.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// cpp11/query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_static.cpp
deleted file mode 100644
index 3290ab0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/query_static.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//
-// cpp11/query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-namespace asio {
-
-template<>
-struct is_applicable_property<object, prop>
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<>
-struct static_query<object, prop>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef int result_type;
-  static constexpr int value() { return 123; }
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_free.cpp
deleted file mode 100644
index 3f42298..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_free.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp11/require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-
-  constexpr object<2> o5 = asio::require_concept(object<1>(), prop<2>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_member.cpp
deleted file mode 100644
index 1f8bbf6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_member.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp11/require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-
-  constexpr object<2> o5 = asio::require_concept(object<1>(), prop<2>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_static.cpp
deleted file mode 100644
index b2a6f9d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_concept_static.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// cpp11/require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require_concept<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  const object<1>& o2 = asio::require_concept(o1, prop<1>());
-  assert(&o1 == &o2);
-  (void)o2;
-
-  const object<1> o3 = {};
-  const object<1>& o4 = asio::require_concept(o3, prop<1>());
-  assert(&o3 == &o4);
-  (void)o4;
-
-  constexpr object<1> o5 = asio::require_concept(object<1>(), prop<1>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_free.cpp
deleted file mode 100644
index 1acd5bc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_free.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::require(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::require(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::require(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_member.cpp
deleted file mode 100644
index e919283..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_member.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// cpp11/require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::require(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::require(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::require(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_static.cpp
deleted file mode 100644
index e752dac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp11/require_static.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//
-// cpp11/require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-namespace traits {
-
-template<int N>
-struct static_require<object<N>, prop<N> >
-{
-  static constexpr bool is_valid = true;
-};
-
-} // namespace traits
-} // namespace asio
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::require(o1, prop<1>());
-  object<1> o3 = asio::require(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::require(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::require(o5, prop<1>());
-  object<1> o7 = asio::require(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::require(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::require(object<1>(), prop<1>());
-  constexpr object<1> o10 = asio::require(object<1>(), prop<1>(), prop<1>());
-  constexpr object<1> o11 = asio::require(object<1>(), prop<1>(), prop<1>(), prop<1>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_prefer.cpp
deleted file mode 100644
index f7f2854..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_prefer.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_require.cpp
deleted file mode 100644
index a2a01e4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_free_require.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_prefer.cpp
deleted file mode 100644
index b0d9622..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_prefer.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_require.cpp
deleted file mode 100644
index 9d1146a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_member_require.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_prefer.cpp
deleted file mode 100644
index 1a305fc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_prefer.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_require.cpp
deleted file mode 100644
index c5d7324..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_free_require.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_prefer.cpp
deleted file mode 100644
index 66af105..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_prefer.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_require.cpp
deleted file mode 100644
index a2bf20b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_member_require.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_static.cpp
deleted file mode 100644
index 123fd86..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_static.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_preferable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>, prop<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_unsupported.cpp
deleted file mode 100644
index ed67b39..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// cpp14/can_prefer_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_prefer.cpp
deleted file mode 100644
index 99cb807..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_prefer.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_require.cpp
deleted file mode 100644
index 0e3329d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_free_require.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_prefer.cpp
deleted file mode 100644
index 12213cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_prefer.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_require.cpp
deleted file mode 100644
index d801a80..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_member_require.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_static.cpp
deleted file mode 100644
index cbaf4ee..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_static.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<1>, prop<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_unsupported.cpp
deleted file mode 100644
index aa37aed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_not_preferable_unsupported.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp14/can_prefer_not_preferable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = false;
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_static.cpp
deleted file mode 100644
index 3933a78..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_static.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// cpp14/can_prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(asio::can_prefer_v<object<1>, prop<1>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_prefer_v<object<1>, prop<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<1>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_prefer_v<const object<1>, prop<1>, prop<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_unsupported.cpp
deleted file mode 100644
index 09ce8e0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_prefer_unsupported.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// cpp14/can_prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_prefer_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_free.cpp
deleted file mode 100644
index 7654a78..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_free.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp14/can_query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-int main()
-{
-  static_assert(asio::can_query_v<object, prop>, "");
-  static_assert(asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_member.cpp
deleted file mode 100644
index 6bd6c02..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_member.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp14/can_query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-int main()
-{
-  static_assert(asio::can_query_v<object, prop>, "");
-  static_assert(asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_free.cpp
deleted file mode 100644
index bda1770..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_free.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp14/can_query_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-int main()
-{
-  static_assert(!asio::can_query_v<object, prop>, "");
-  static_assert(!asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_member.cpp
deleted file mode 100644
index 25b6ab9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_member.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp14/can_query_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-int main()
-{
-  static_assert(!asio::can_query_v<object, prop>, "");
-  static_assert(!asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_static.cpp
deleted file mode 100644
index 299a5e1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_static.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp14/can_query_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr int static_query_v = 123;
-};
-
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_query_v<object, prop>, "");
-  static_assert(!asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_unsupported.cpp
deleted file mode 100644
index cec0aea..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// cpp14/can_query_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-};
-
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_query_v<object, prop>, "");
-  static_assert(!asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_static.cpp
deleted file mode 100644
index 67b19ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_static.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp14/can_query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  template <typename> static constexpr int static_query_v = 123;
-};
-
-struct object
-{
-};
-
-int main()
-{
-  static_assert(asio::can_query_v<object, prop>, "");
-  static_assert(asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_unsupported.cpp
deleted file mode 100644
index 7e8f63f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_query_unsupported.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// cpp14/can_query_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-};
-
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_query_v<object, prop>, "");
-  static_assert(!asio::can_query_v<const object, prop>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_free.cpp
deleted file mode 100644
index e0dea96..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_free.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// cpp14/can_require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_member.cpp
deleted file mode 100644
index 7da0a58..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_member.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// cpp14/can_require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_free.cpp
deleted file mode 100644
index f6d4816..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_free.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp14/can_require_concept_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_member.cpp
deleted file mode 100644
index 5252cb7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_member.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// cpp14/can_require_concept_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_static.cpp
deleted file mode 100644
index 7da83a9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_static.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// cpp14/can_require_concept_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable_concept = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_unsupported.cpp
deleted file mode 100644
index 939b450..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// cpp14/can_require_concept_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require_concept_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_concept_v<const object<1>, prop<2>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_static.cpp
deleted file mode 100644
index 577363a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_static.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// cpp14/can_require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(asio::can_require_concept_v<object<1>, prop<1>>, "");
-  static_assert(asio::can_require_concept_v<const object<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_unsupported.cpp
deleted file mode 100644
index 2bcdc6c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_concept_unsupported.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_require_concept_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require_concept<object<1>, prop<2>>::value, "");
-  static_assert(!asio::can_require_concept<const object<1>, prop<2>>::value, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_free.cpp
deleted file mode 100644
index f0bda07..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_free.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_member.cpp
deleted file mode 100644
index 0eeb0aa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_member.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// cpp14/can_require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_free.cpp
deleted file mode 100644
index f68576e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_free.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_require_not_applicable_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_member.cpp
deleted file mode 100644
index 1c7aa95..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_member.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// cpp14/can_require_not_applicable_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  static_assert(!asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_static.cpp
deleted file mode 100644
index ba7b5a8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_static.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// cpp14/can_require_not_applicable_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  static constexpr bool is_requirable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require_v<object<1>, prop<1>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<1>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<1>, prop<1>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<1>, prop<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_unsupported.cpp
deleted file mode 100644
index 25d71e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_not_applicable_unsupported.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// cpp14/can_require_not_applicable_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(!asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_static.cpp
deleted file mode 100644
index f92c0b5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_static.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// cpp14/can_require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  static_assert(asio::can_require_v<object<1>, prop<1>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_require_v<object<1>, prop<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<1>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<1>, prop<1>>, "");
-  static_assert(asio::can_require_v<const object<1>, prop<1>, prop<1>, prop<1>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_unsupported.cpp
deleted file mode 100644
index 4cf2756..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/can_require_unsupported.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// cpp14/can_require_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-};
-
-template <int>
-struct object
-{
-};
-
-namespace asio {
-
-template<int N, int M>
-struct is_applicable_property<object<N>, prop<M> >
-{
-  static constexpr bool value = true;
-};
-
-} // namespace asio
-
-int main()
-{
-  static_assert(!asio::can_require_v<object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<object<1>, prop<2>, prop<3>, prop<4>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>>, "");
-  static_assert(!asio::can_require_v<const object<1>, prop<2>, prop<3>, prop<4>>, "");
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_prefer.cpp
deleted file mode 100644
index fce83ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_prefer.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/prefer_free_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> prefer(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_require.cpp
deleted file mode 100644
index 349aebe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_free_require.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/prefer_free_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_prefer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_prefer.cpp
deleted file mode 100644
index 56d29ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_prefer.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/prefer_member_prefer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> prefer(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_require.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_require.cpp
deleted file mode 100644
index 7b88df4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_member_require.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/prefer_member_require.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::prefer(o1, prop<2>());
-  object<3> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::prefer(o5, prop<2>());
-  object<3> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_static.cpp
deleted file mode 100644
index 8fd537a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp14/prefer_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::prefer(o1, prop<1>());
-  object<1> o3 = asio::prefer(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::prefer(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::prefer(o5, prop<1>());
-  object<1> o7 = asio::prefer(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::prefer(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::prefer(object<1>(), prop<1>());
-  constexpr object<1> o10 = asio::prefer(object<1>(), prop<1>(), prop<1>());
-  constexpr object<1> o11 = asio::prefer(object<1>(), prop<1>(), prop<1>(), prop<1>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_unsupported.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_unsupported.cpp
deleted file mode 100644
index 50b8da0..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/prefer_unsupported.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// cpp14/prefer_unsupported.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/prefer.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_preferable = true;
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::prefer(o1, prop<2>());
-  object<1> o3 = asio::prefer(o1, prop<2>(), prop<3>());
-  object<1> o4 = asio::prefer(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::prefer(o5, prop<2>());
-  object<1> o7 = asio::prefer(o5, prop<2>(), prop<3>());
-  object<1> o8 = asio::prefer(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::prefer(object<1>(), prop<2>());
-  constexpr object<1> o10 = asio::prefer(object<1>(), prop<2>(), prop<3>());
-  constexpr object<1> o11 = asio::prefer(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_free.cpp
deleted file mode 100644
index 24be8db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_free.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// cpp14/query_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-};
-
-struct object
-{
-  friend constexpr int query(const object&, prop) { return 123; }
-};
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_member.cpp
deleted file mode 100644
index fab0bed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_member.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// cpp14/query_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-};
-
-struct object
-{
-  constexpr int query(prop) const { return 123; }
-};
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_static.cpp
deleted file mode 100644
index d13ad85..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/query_static.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// cpp14/query_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/query.hpp"
-#include <cassert>
-
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  template <typename> static constexpr int static_query_v = 123;
-};
-
-struct object
-{
-};
-
-int main()
-{
-  object o1 = {};
-  int result1 = asio::query(o1, prop());
-  assert(result1 == 123);
-  (void)result1;
-
-  const object o2 = {};
-  int result2 = asio::query(o2, prop());
-  assert(result2 == 123);
-  (void)result2;
-
-  constexpr object o3 = {};
-  constexpr int result3 = asio::query(o3, prop());
-  assert(result3 == 123);
-  (void)result3;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_free.cpp
deleted file mode 100644
index d7323db..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_free.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp14/require_concept_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require_concept(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-
-  constexpr object<2> o5 = asio::require_concept(object<1>(), prop<2>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_member.cpp
deleted file mode 100644
index e21dda3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_member.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// cpp14/require_concept_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require_concept(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require_concept(o1, prop<2>());
-  (void)o2;
-
-  const object<1> o3 = {};
-  object<2> o4 = asio::require_concept(o3, prop<2>());
-  (void)o4;
-
-  constexpr object<2> o5 = asio::require_concept(object<1>(), prop<2>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_static.cpp
deleted file mode 100644
index 523ed75..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_concept_static.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//
-// cpp14/require_concept_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require_concept.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable_concept = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  object<1> o1 = {};
-  const object<1>& o2 = asio::require_concept(o1, prop<1>());
-  assert(&o1 == &o2);
-  (void)o2;
-
-  const object<1> o3 = {};
-  const object<1>& o4 = asio::require_concept(o3, prop<1>());
-  assert(&o3 == &o4);
-  (void)o4;
-
-  constexpr object<1> o5 = asio::require_concept(object<1>(), prop<1>());
-  (void)o5;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_free.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_free.cpp
deleted file mode 100644
index 32893ff..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_free.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/require_free.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  friend constexpr object<N> require(const object&, prop<N>)
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::require(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::require(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::require(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_member.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_member.cpp
deleted file mode 100644
index f2e58aa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_member.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// cpp14/require_member.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-};
-
-template <int>
-struct object
-{
-  template <int N>
-  constexpr object<N> require(prop<N>) const
-  {
-    return object<N>();
-  }
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<2> o2 = asio::require(o1, prop<2>());
-  object<3> o3 = asio::require(o1, prop<2>(), prop<3>());
-  object<4> o4 = asio::require(o1, prop<2>(), prop<3>(), prop<4>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<2> o6 = asio::require(o5, prop<2>());
-  object<3> o7 = asio::require(o5, prop<2>(), prop<3>());
-  object<4> o8 = asio::require(o5, prop<2>(), prop<3>(), prop<4>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<2> o9 = asio::require(object<1>(), prop<2>());
-  constexpr object<3> o10 = asio::require(object<1>(), prop<2>(), prop<3>());
-  constexpr object<4> o11 = asio::require(object<1>(), prop<2>(), prop<3>(), prop<4>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_static.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_static.cpp
deleted file mode 100644
index acdd7fb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/properties/cpp14/require_static.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-// cpp14/require_static.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio/require.hpp"
-#include <cassert>
-
-template <int>
-struct prop
-{
-  template <typename> static constexpr bool is_applicable_property_v = true;
-  static constexpr bool is_requirable = true;
-  template <typename> static constexpr bool static_query_v = true;
-  static constexpr bool value() { return true; }
-};
-
-template <int>
-struct object
-{
-};
-
-int main()
-{
-  object<1> o1 = {};
-  object<1> o2 = asio::require(o1, prop<1>());
-  object<1> o3 = asio::require(o1, prop<1>(), prop<1>());
-  object<1> o4 = asio::require(o1, prop<1>(), prop<1>(), prop<1>());
-  (void)o2;
-  (void)o3;
-  (void)o4;
-
-  const object<1> o5 = {};
-  object<1> o6 = asio::require(o5, prop<1>());
-  object<1> o7 = asio::require(o5, prop<1>(), prop<1>());
-  object<1> o8 = asio::require(o5, prop<1>(), prop<1>(), prop<1>());
-  (void)o6;
-  (void)o7;
-  (void)o8;
-
-  constexpr object<1> o9 = asio::require(object<1>(), prop<1>());
-  constexpr object<1> o10 = asio::require(object<1>(), prop<1>(), prop<1>());
-  constexpr object<1> o11 = asio::require(object<1>(), prop<1>(), prop<1>(), prop<1>());
-  (void)o9;
-  (void)o10;
-  (void)o11;
-}
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/.gitignore
deleted file mode 100644
index 8c8bebf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/.gitignore
+++ /dev/null
@@ -1,115 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-any_completion_executor
-any_completion_handler
-any_io_executor
-append
-as_tuple
-associated_allocator
-associated_cancellation_slot
-associated_executor
-associated_immediate_executor
-associator
-async_result
-awaitable
-basic_datagram_socket
-basic_deadline_timer
-basic_file
-basic_random_access_file
-basic_raw_socket
-basic_readable_pipe
-basic_seq_packet_socket
-basic_serial_port
-basic_signal_set
-basic_socket
-basic_socket_acceptor
-basic_stream_file
-basic_stream_socket
-basic_streambuf
-basic_waitable_timer
-basic_writable_pipe
-bind_allocator
-bind_cancellation_slot
-bind_executor
-bind_immediate_executor
-buffer
-buffer_registration
-buffered_read_stream
-buffered_stream
-buffered_write_stream
-buffers_iterator
-cancel_after
-cancel_at
-cancellation_signal
-cancellation_state
-cancellation_type
-co_composed
-co_spawn
-completion_condition
-compose
-composed
-connect
-connect_pipe
-consign
-coroutine
-deadline_timer
-defer
-deferred
-detached
-dispatch
-error
-error_handler
-execution_context
-executor
-executor_work_guard
-file_base
-high_resolution_timer
-immediate
-io_context
-io_context_strand
-io_service
-is_read_buffered
-is_write_buffered
-packaged_task
-placeholders
-post
-prepend
-random_access_file
-read
-read_at
-read_until
-readable_pipe
-recycling_allocator
-redirect_error
-registered_buffer
-serial_port
-serial_port_base
-signal_set
-signal_set_base
-socket_base
-static_thread_pool
-steady_timer
-strand
-streambuf
-stream_file
-system_context
-system_executor
-system_timer
-this_coro
-thread
-thread_pool
-time_traits
-use_awaitable
-use_future
-uses_executor
-wait_traits
-writable_pipe
-write
-write_at
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_executor.cpp
deleted file mode 100644
index 5d1d5b1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_executor.cpp
+++ /dev/null
@@ -1,463 +0,0 @@
-//
-// any_completion_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/any_completion_executor.hpp"
-
-#include <cstring>
-#include <functional>
-#include "asio/system_executor.hpp"
-#include "asio/thread_pool.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-static bool next_nothrow_new_fails = false;
-
-void* operator new(std::size_t n,
-    const std::nothrow_t&) noexcept
-{
-  if (next_nothrow_new_fails)
-  {
-    next_nothrow_new_fails = false;
-    return 0;
-  }
-  return ::operator new(n);
-}
-
-struct fat_executor
-{
-  fat_executor(int id)
-    : id_(id)
-  {
-    std::memset(data_, 0, sizeof(data_));
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ == b.id_;
-  }
-
-  friend bool operator!=(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ != b.id_;
-  }
-
-  int id_;
-  unsigned char data_[1024];
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<fat_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<fat_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void any_completion_executor_construction_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_completion_executor ex1;
-
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_completion_executor ex2(null_ptr);
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-  ASIO_CHECK(ex2 == null_ptr);
-  ASIO_CHECK(ex2 == ex1);
-
-  asio::any_completion_executor ex3(pool.executor());
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-  ASIO_CHECK(ex3 != null_ptr);
-  ASIO_CHECK(ex3 != ex1);
-
-  asio::any_completion_executor ex4(ex1);
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == null_ptr);
-  ASIO_CHECK(ex4 == ex1);
-
-  asio::any_completion_executor ex5(ex3);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 == ex3);
-
-  asio::any_completion_executor ex6 = fat_executor(1);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-
-  asio::any_completion_executor ex7 = fat_executor(1);
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex6);
-
-  asio::any_completion_executor ex8 = fat_executor(2);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex8 != null_ptr);
-  ASIO_CHECK(ex8 != ex1);
-  ASIO_CHECK(ex8 != ex6);
-  ASIO_CHECK(ex8 != ex7);
-
-  asio::any_completion_executor ex9(ex6);
-
-  ASIO_CHECK(ex9.target<void>() != 0);
-  ASIO_CHECK(ex9 != null_ptr);
-  ASIO_CHECK(ex9 != ex1);
-  ASIO_CHECK(ex9 == ex6);
-  ASIO_CHECK(ex9 == ex7);
-  ASIO_CHECK(ex9 != ex8);
-
-  asio::any_completion_executor ex10(std::move(ex1));
-
-  ASIO_CHECK(ex10.target<void>() == 0);
-  ASIO_CHECK(ex10 == null_ptr);
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_completion_executor ex11(std::move(ex3));
-
-  ASIO_CHECK(ex11.target<void>() != 0);
-  ASIO_CHECK(ex11 != null_ptr);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex3 == null_ptr);
-  ASIO_CHECK(ex11 == ex5);
-
-  asio::any_completion_executor ex12(std::move(ex7));
-
-  ASIO_CHECK(ex12.target<void>() != 0);
-  ASIO_CHECK(ex12 != null_ptr);
-  ASIO_CHECK(ex7.target<void>() == 0);
-  ASIO_CHECK(ex7 == null_ptr);
-  ASIO_CHECK(ex12 == ex6);
-  ASIO_CHECK(ex12 != ex8);
-}
-
-void any_completion_executor_nothrow_construction_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_completion_executor ex1;
-
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_completion_executor ex2(null_ptr);
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-  ASIO_CHECK(ex2 == null_ptr);
-  ASIO_CHECK(ex2 == ex1);
-
-  asio::any_completion_executor ex3(std::nothrow, pool.executor());
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-  ASIO_CHECK(ex3 != null_ptr);
-  ASIO_CHECK(ex3 != ex1);
-
-  asio::any_completion_executor ex4(std::nothrow, ex1);
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == null_ptr);
-  ASIO_CHECK(ex4 == ex1);
-
-  asio::any_completion_executor ex5(std::nothrow, ex3);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 == ex3);
-
-  asio::any_completion_executor ex6(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-
-  asio::any_completion_executor ex7(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex6);
-
-  asio::any_completion_executor ex8(std::nothrow, fat_executor(2));
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex8 != null_ptr);
-  ASIO_CHECK(ex8 != ex1);
-  ASIO_CHECK(ex8 != ex6);
-  ASIO_CHECK(ex8 != ex7);
-
-  asio::any_completion_executor ex9(std::nothrow, ex6);
-
-  ASIO_CHECK(ex9.target<void>() != 0);
-  ASIO_CHECK(ex9 != null_ptr);
-  ASIO_CHECK(ex9 != ex1);
-  ASIO_CHECK(ex9 == ex6);
-  ASIO_CHECK(ex9 == ex7);
-  ASIO_CHECK(ex9 != ex8);
-
-  asio::any_completion_executor ex10(std::nothrow, std::move(ex1));
-
-  ASIO_CHECK(ex10.target<void>() == 0);
-  ASIO_CHECK(ex10 == null_ptr);
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_completion_executor ex11(std::nothrow, std::move(ex3));
-
-  ASIO_CHECK(ex11.target<void>() != 0);
-  ASIO_CHECK(ex11 != null_ptr);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex3 == null_ptr);
-  ASIO_CHECK(ex11 == ex5);
-
-  asio::any_completion_executor ex12(std::nothrow, std::move(ex7));
-
-  ASIO_CHECK(ex12.target<void>() != 0);
-  ASIO_CHECK(ex12 != null_ptr);
-  ASIO_CHECK(ex7.target<void>() == 0);
-  ASIO_CHECK(ex7 == null_ptr);
-  ASIO_CHECK(ex12 == ex6);
-  ASIO_CHECK(ex12 != ex8);
-
-  next_nothrow_new_fails = true;
-  asio::any_completion_executor ex13(std::nothrow, fat_executor(3));
-
-  ASIO_CHECK(ex13.target<void>() == 0);
-  ASIO_CHECK(ex13 == null_ptr);
-  ASIO_CHECK(ex13 == ex1);
-}
-
-void any_completion_executor_assignment_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_completion_executor ex1;
-
-  asio::any_completion_executor ex2;
-  ex2 = null_ptr;
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-
-  asio::any_completion_executor ex3;
-  ex3 = pool.executor();
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-
-  asio::any_completion_executor ex4;
-  ex4 = ex1;
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == ex1);
-
-  ex4 = ex3;
-
-  ASIO_CHECK(ex4.target<void>() != 0);
-  ASIO_CHECK(ex4 == ex3);
-
-  asio::any_completion_executor ex5;
-  ex5 = fat_executor(1);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 != ex1);
-
-  asio::any_completion_executor ex6;
-  ex6 = fat_executor(1);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-  ASIO_CHECK(ex6 == ex5);
-
-  ex6 = fat_executor(2);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-  ASIO_CHECK(ex6 != ex5);
-
-  asio::any_completion_executor ex7;
-  ex7 = ex5;
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex5);
-  ASIO_CHECK(ex7 != ex6);
-
-  asio::any_completion_executor ex8;
-  ex8 = std::move(ex1);
-
-  ASIO_CHECK(ex8.target<void>() == 0);
-  ASIO_CHECK(ex1.target<void>() == 0);
-
-  ex8 = std::move(ex3);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex8 == ex4);
-
-  ex8 = std::move(ex5);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex5.target<void>() == 0);
-  ASIO_CHECK(ex8 == ex7);
-}
-
-void any_completion_executor_swap_test()
-{
-  thread_pool pool1(1);
-  thread_pool pool2(1);
-
-  asio::any_completion_executor ex1(pool1.executor());
-  asio::any_completion_executor ex2(pool2.executor());
-
-  asio::any_completion_executor ex3(ex1);
-  asio::any_completion_executor ex4(ex2);
-
-  ASIO_CHECK(ex3 == ex1);
-  ASIO_CHECK(ex4 == ex2);
-
-  ex3.swap(ex4);
-
-  ASIO_CHECK(ex3 == ex2);
-  ASIO_CHECK(ex4 == ex1);
-
-  execution::swap(ex3, ex4);
-
-  ASIO_CHECK(ex3 == ex1);
-  ASIO_CHECK(ex4 == ex2);
-}
-
-void any_completion_executor_query_test()
-{
-  thread_pool pool(1);
-  asio::any_completion_executor ex(pool.executor());
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking.possibly)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work.untracked)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship.fork)
-        == asio::execution::relationship.fork);
-}
-
-void any_completion_executor_execute_test()
-{
-  int count = 0;
-  thread_pool pool(1);
-  asio::any_completion_executor ex(pool.executor());
-
-  ex.execute(bindns::bind(increment, &count));
-
-  asio::prefer(ex, asio::execution::blocking.possibly).execute(
-      bindns::bind(increment, &count));
-
-  asio::prefer(ex,
-      asio::execution::blocking.possibly,
-      asio::execution::outstanding_work.tracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(ex,
-      asio::execution::blocking.possibly,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(ex,
-      asio::execution::blocking.possibly,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  pool.wait();
-
-  ASIO_CHECK(count == 5);
-}
-
-ASIO_TEST_SUITE
-(
-  "any_completion_executor",
-  ASIO_TEST_CASE(any_completion_executor_construction_test)
-  ASIO_TEST_CASE(any_completion_executor_nothrow_construction_test)
-  ASIO_TEST_CASE(any_completion_executor_assignment_test)
-  ASIO_TEST_CASE(any_completion_executor_swap_test)
-  ASIO_TEST_CASE(any_completion_executor_query_test)
-  ASIO_TEST_CASE(any_completion_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_handler.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_handler.cpp
deleted file mode 100644
index 887402d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_completion_handler.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-//
-// any_completion_handler.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/any_completion_handler.hpp"
-
-#include "unit_test.hpp"
-
-#include <functional>
-#include "asio/bind_allocator.hpp"
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/bind_immediate_executor.hpp"
-#include "asio/error.hpp"
-#include "asio/thread_pool.hpp"
-
-namespace bindns = std;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void any_completion_handler_construction_test()
-{
-  int count = 0;
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_completion_handler<void()> h1;
-
-  ASIO_CHECK(!h1);
-  ASIO_CHECK(h1 == null_ptr);
-
-  asio::any_completion_handler<void()> h2(null_ptr);
-
-  ASIO_CHECK(!h2);
-  ASIO_CHECK(h2 == null_ptr);
-
-  asio::any_completion_handler<void()> h3(
-      bindns::bind(&increment, &count));
-
-  ASIO_CHECK(!!h3);
-  ASIO_CHECK(h3 != null_ptr);
-
-  asio::any_completion_handler<void()> h4(std::move(h1));
-
-  ASIO_CHECK(!h4);
-  ASIO_CHECK(h4 == null_ptr);
-  ASIO_CHECK(!h1);
-  ASIO_CHECK(h1 == null_ptr);
-
-  asio::any_completion_handler<void()> h5(std::move(h3));
-
-  ASIO_CHECK(!!h5);
-  ASIO_CHECK(h5 != null_ptr);
-  ASIO_CHECK(!h3);
-  ASIO_CHECK(h3 == null_ptr);
-
-  asio::any_completion_handler<void()> h6(std::move(h5));
-
-  ASIO_CHECK(!!h6);
-  ASIO_CHECK(h6 != null_ptr);
-  ASIO_CHECK(!h5);
-  ASIO_CHECK(h5 == null_ptr);
-}
-
-void any_completion_handler_assignment_test()
-{
-  int count = 0;
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_completion_handler<void()> h1;
-
-  asio::any_completion_handler<void()> h2;
-  h2 = null_ptr;
-
-  ASIO_CHECK(!h2);
-
-  asio::any_completion_handler<void()> h3;
-  h3 = bindns::bind(&increment, &count);
-
-  ASIO_CHECK(!!h3);
-
-  asio::any_completion_handler<void()> h4;
-  h4 = std::move(h1);
-
-  ASIO_CHECK(!h4);
-  ASIO_CHECK(!h1);
-
-  h4 = std::move(h3);
-
-  ASIO_CHECK(!!h4);
-  ASIO_CHECK(!h3);
-}
-
-template <typename T>
-class handler_allocator
-{
-public:
-  using value_type = T;
-
-  explicit handler_allocator(int* count)
-    : count_(count)
-  {
-  }
-
-  template <typename U>
-  handler_allocator(const handler_allocator<U>& other) noexcept
-    : count_(other.count_)
-  {
-  }
-
-  bool operator==(const handler_allocator& other) const noexcept
-  {
-    return &count_ == &other.count_;
-  }
-
-  bool operator!=(const handler_allocator& other) const noexcept
-  {
-    return &count_ != &other.count_;
-  }
-
-  T* allocate(std::size_t n) const
-  {
-    ++(*count_);
-    return static_cast<T*>(::operator new(sizeof(T) * n));
-  }
-
-  void deallocate(T* p, std::size_t /*n*/) const
-  {
-    ::operator delete(p);
-  }
-
-private:
-  template <typename> friend class handler_allocator;
-
-  int* count_;
-};
-
-class cancel_handler
-{
-public:
-  explicit cancel_handler(int* count)
-    : count_(count)
-  {
-  }
-
-  void operator()(asio::cancellation_type_t)
-  {
-    ++(*count_);
-  }
-
-private:
-  int* count_;
-};
-
-void any_completion_handler_associator_test()
-{
-  typedef asio::any_completion_handler<void()> handler_type;
-
-  int count = 0;
-  int alloc_count = 0;
-  int cancel_count = 0;
-  asio::thread_pool pool(1);
-  asio::cancellation_signal sig;
-
-  asio::any_completion_handler<void()> h1(
-      asio::bind_allocator(handler_allocator<char>(&alloc_count),
-        asio::bind_cancellation_slot(sig.slot(),
-          asio::bind_executor(pool.get_executor(),
-            asio::bind_immediate_executor(asio::system_executor(),
-              bindns::bind(&increment, &count))))));
-
-  ASIO_CHECK(alloc_count == 1);
-
-  ASIO_REBIND_ALLOC(asio::associated_allocator<handler_type>::type,
-      char) alloc1(asio::get_associated_allocator(h1));
-  alloc1.deallocate(alloc1.allocate(1), 1);
-
-  ASIO_CHECK(alloc_count == 2);
-
-  asio::associated_cancellation_slot<handler_type>::type slot1
-    = asio::get_associated_cancellation_slot(h1);
-
-  ASIO_CHECK(slot1.is_connected());
-
-  slot1.emplace<cancel_handler>(&cancel_count);
-
-  ASIO_CHECK(cancel_count == 0);
-
-  sig.emit(asio::cancellation_type::terminal);
-
-  ASIO_CHECK(cancel_count == 1);
-
-  asio::associated_executor<handler_type>::type ex1
-    = asio::get_associated_executor(h1);
-
-  ASIO_CHECK(ex1 == pool.get_executor());
-
-  asio::associated_immediate_executor<
-    handler_type, asio::thread_pool::executor_type>::type ex2
-      = asio::get_associated_immediate_executor(h1, pool.get_executor());
-
-  ASIO_CHECK(ex2 == asio::system_executor());
-}
-
-void increment_with_error(asio::error_code ec,
-    asio::error_code* out_ec, int* count)
-{
-  *out_ec = ec;
-  ++(*count);
-}
-
-void any_completion_handler_invocation_test()
-{
-  int count = 0;
-  asio::error_code ec;
-
-  asio::any_completion_handler<void()> h1(
-      bindns::bind(&increment, &count));
-
-  ASIO_CHECK(count == 0);
-
-  std::move(h1)();
-
-  ASIO_CHECK(count == 1);
-
-  asio::any_completion_handler<void(asio::error_code)> h2(
-      bindns::bind(&increment_with_error,
-        bindns::placeholders::_1, &ec, &count));
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 1);
-
-  std::move(h2)(asio::error::eof);
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "any_completion_handler",
-  ASIO_TEST_CASE(any_completion_handler_construction_test)
-  ASIO_TEST_CASE(any_completion_handler_assignment_test)
-  ASIO_TEST_CASE(any_completion_handler_associator_test)
-  ASIO_TEST_CASE(any_completion_handler_invocation_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_io_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_io_executor.cpp
deleted file mode 100644
index e0a32ba..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/any_io_executor.cpp
+++ /dev/null
@@ -1,515 +0,0 @@
-//
-// any_io_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/any_io_executor.hpp"
-
-#include <cstring>
-#include <functional>
-#include "asio/system_executor.hpp"
-#include "asio/thread_pool.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-static bool next_nothrow_new_fails = false;
-
-void* operator new(std::size_t n,
-    const std::nothrow_t&) noexcept
-{
-  if (next_nothrow_new_fails)
-  {
-    next_nothrow_new_fails = false;
-    return 0;
-  }
-  return ::operator new(n);
-}
-
-struct fat_executor
-{
-  fat_executor(int id)
-    : id_(id)
-  {
-    std::memset(data_, 0, sizeof(data_));
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  execution_context& query(execution::context_t) const noexcept
-  {
-    return asio::query(system_executor(), execution::context);
-  }
-
-  constexpr static execution::blocking_t::never_t query(
-      execution::blocking_t) noexcept
-  {
-    return execution::blocking.never;
-  }
-
-  friend bool operator==(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ == b.id_;
-  }
-
-  friend bool operator!=(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ != b.id_;
-  }
-
-  int id_;
-  unsigned char data_[1024];
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<fat_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <>
-struct query_member<fat_executor, execution::context_t>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution_context& result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Property>
-struct query_static_constexpr_member<fat_executor, Property,
-    typename asio::enable_if<
-      asio::is_convertible<
-        Property,
-        asio::execution::blocking_t
-      >::value
-    >::type
-  >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef execution::blocking_t::never_t result_type;
-
-  static constexpr result_type value() noexcept
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<fat_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void any_io_executor_construction_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_io_executor ex1;
-
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_io_executor ex2(null_ptr);
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-  ASIO_CHECK(ex2 == null_ptr);
-  ASIO_CHECK(ex2 == ex1);
-
-  asio::any_io_executor ex3(pool.executor());
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-  ASIO_CHECK(ex3 != null_ptr);
-  ASIO_CHECK(ex3 != ex1);
-
-  asio::any_io_executor ex4(ex1);
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == null_ptr);
-  ASIO_CHECK(ex4 == ex1);
-
-  asio::any_io_executor ex5(ex3);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 == ex3);
-
-  asio::any_io_executor ex6 = fat_executor(1);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-
-  asio::any_io_executor ex7 = fat_executor(1);
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex6);
-
-  asio::any_io_executor ex8 = fat_executor(2);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex8 != null_ptr);
-  ASIO_CHECK(ex8 != ex1);
-  ASIO_CHECK(ex8 != ex6);
-  ASIO_CHECK(ex8 != ex7);
-
-  asio::any_io_executor ex9(ex6);
-
-  ASIO_CHECK(ex9.target<void>() != 0);
-  ASIO_CHECK(ex9 != null_ptr);
-  ASIO_CHECK(ex9 != ex1);
-  ASIO_CHECK(ex9 == ex6);
-  ASIO_CHECK(ex9 == ex7);
-  ASIO_CHECK(ex9 != ex8);
-
-  asio::any_io_executor ex10(std::move(ex1));
-
-  ASIO_CHECK(ex10.target<void>() == 0);
-  ASIO_CHECK(ex10 == null_ptr);
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_io_executor ex11(std::move(ex3));
-
-  ASIO_CHECK(ex11.target<void>() != 0);
-  ASIO_CHECK(ex11 != null_ptr);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex3 == null_ptr);
-  ASIO_CHECK(ex11 == ex5);
-
-  asio::any_io_executor ex12(std::move(ex7));
-
-  ASIO_CHECK(ex12.target<void>() != 0);
-  ASIO_CHECK(ex12 != null_ptr);
-  ASIO_CHECK(ex7.target<void>() == 0);
-  ASIO_CHECK(ex7 == null_ptr);
-  ASIO_CHECK(ex12 == ex6);
-  ASIO_CHECK(ex12 != ex8);
-}
-
-void any_io_executor_nothrow_construction_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_io_executor ex1;
-
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_io_executor ex2(null_ptr);
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-  ASIO_CHECK(ex2 == null_ptr);
-  ASIO_CHECK(ex2 == ex1);
-
-  asio::any_io_executor ex3(std::nothrow, pool.executor());
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-  ASIO_CHECK(ex3 != null_ptr);
-  ASIO_CHECK(ex3 != ex1);
-
-  asio::any_io_executor ex4(std::nothrow, ex1);
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == null_ptr);
-  ASIO_CHECK(ex4 == ex1);
-
-  asio::any_io_executor ex5(std::nothrow, ex3);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 == ex3);
-
-  asio::any_io_executor ex6(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-
-  asio::any_io_executor ex7(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex6);
-
-  asio::any_io_executor ex8(std::nothrow, fat_executor(2));
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex8 != null_ptr);
-  ASIO_CHECK(ex8 != ex1);
-  ASIO_CHECK(ex8 != ex6);
-  ASIO_CHECK(ex8 != ex7);
-
-  asio::any_io_executor ex9(std::nothrow, ex6);
-
-  ASIO_CHECK(ex9.target<void>() != 0);
-  ASIO_CHECK(ex9 != null_ptr);
-  ASIO_CHECK(ex9 != ex1);
-  ASIO_CHECK(ex9 == ex6);
-  ASIO_CHECK(ex9 == ex7);
-  ASIO_CHECK(ex9 != ex8);
-
-  asio::any_io_executor ex10(std::nothrow, std::move(ex1));
-
-  ASIO_CHECK(ex10.target<void>() == 0);
-  ASIO_CHECK(ex10 == null_ptr);
-  ASIO_CHECK(ex1.target<void>() == 0);
-  ASIO_CHECK(ex1 == null_ptr);
-
-  asio::any_io_executor ex11(std::nothrow, std::move(ex3));
-
-  ASIO_CHECK(ex11.target<void>() != 0);
-  ASIO_CHECK(ex11 != null_ptr);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex3 == null_ptr);
-  ASIO_CHECK(ex11 == ex5);
-
-  asio::any_io_executor ex12(std::nothrow, std::move(ex7));
-
-  ASIO_CHECK(ex12.target<void>() != 0);
-  ASIO_CHECK(ex12 != null_ptr);
-  ASIO_CHECK(ex7.target<void>() == 0);
-  ASIO_CHECK(ex7 == null_ptr);
-  ASIO_CHECK(ex12 == ex6);
-  ASIO_CHECK(ex12 != ex8);
-
-  next_nothrow_new_fails = true;
-  asio::any_io_executor ex13(std::nothrow, fat_executor(3));
-
-  ASIO_CHECK(ex13.target<void>() == 0);
-  ASIO_CHECK(ex13 == null_ptr);
-  ASIO_CHECK(ex13 == ex1);
-}
-
-void any_io_executor_assignment_test()
-{
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  asio::any_io_executor ex1;
-
-  asio::any_io_executor ex2;
-  ex2 = null_ptr;
-
-  ASIO_CHECK(ex2.target<void>() == 0);
-
-  asio::any_io_executor ex3;
-  ex3 = pool.executor();
-
-  ASIO_CHECK(ex3.target<void>() != 0);
-
-  asio::any_io_executor ex4;
-  ex4 = ex1;
-
-  ASIO_CHECK(ex4.target<void>() == 0);
-  ASIO_CHECK(ex4 == ex1);
-
-  ex4 = ex3;
-
-  ASIO_CHECK(ex4.target<void>() != 0);
-  ASIO_CHECK(ex4 == ex3);
-
-  asio::any_io_executor ex5;
-  ex5 = fat_executor(1);
-
-  ASIO_CHECK(ex5.target<void>() != 0);
-  ASIO_CHECK(ex5 != null_ptr);
-  ASIO_CHECK(ex5 != ex1);
-
-  asio::any_io_executor ex6;
-  ex6 = fat_executor(1);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-  ASIO_CHECK(ex6 == ex5);
-
-  ex6 = fat_executor(2);
-
-  ASIO_CHECK(ex6.target<void>() != 0);
-  ASIO_CHECK(ex6 != null_ptr);
-  ASIO_CHECK(ex6 != ex1);
-  ASIO_CHECK(ex6 != ex5);
-
-  asio::any_io_executor ex7;
-  ex7 = ex5;
-
-  ASIO_CHECK(ex7.target<void>() != 0);
-  ASIO_CHECK(ex7 != null_ptr);
-  ASIO_CHECK(ex7 != ex1);
-  ASIO_CHECK(ex7 == ex5);
-  ASIO_CHECK(ex7 != ex6);
-
-  asio::any_io_executor ex8;
-  ex8 = std::move(ex1);
-
-  ASIO_CHECK(ex8.target<void>() == 0);
-  ASIO_CHECK(ex1.target<void>() == 0);
-
-  ex8 = std::move(ex3);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex3.target<void>() == 0);
-  ASIO_CHECK(ex8 == ex4);
-
-  ex8 = std::move(ex5);
-
-  ASIO_CHECK(ex8.target<void>() != 0);
-  ASIO_CHECK(ex5.target<void>() == 0);
-  ASIO_CHECK(ex8 == ex7);
-}
-
-void any_io_executor_swap_test()
-{
-  thread_pool pool1(1);
-  thread_pool pool2(1);
-
-  asio::any_io_executor ex1(pool1.executor());
-  asio::any_io_executor ex2(pool2.executor());
-
-  asio::any_io_executor ex3(ex1);
-  asio::any_io_executor ex4(ex2);
-
-  ASIO_CHECK(ex3 == ex1);
-  ASIO_CHECK(ex4 == ex2);
-
-  ex3.swap(ex4);
-
-  ASIO_CHECK(ex3 == ex2);
-  ASIO_CHECK(ex4 == ex1);
-
-  execution::swap(ex3, ex4);
-
-  ASIO_CHECK(ex3 == ex1);
-  ASIO_CHECK(ex4 == ex2);
-}
-
-void any_io_executor_query_test()
-{
-  thread_pool pool(1);
-  asio::any_io_executor ex(pool.executor());
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking.possibly)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work.untracked)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship.fork)
-        == asio::execution::relationship.fork);
-}
-
-void any_io_executor_execute_test()
-{
-  int count = 0;
-  thread_pool pool(1);
-  asio::any_io_executor ex(pool.executor());
-
-  ex.execute(bindns::bind(increment, &count));
-
-  asio::prefer(ex, asio::execution::blocking.possibly).execute(
-      bindns::bind(increment, &count));
-
-  asio::require(ex, asio::execution::blocking.never).execute(
-      bindns::bind(increment, &count));
-
-  asio::require(
-      asio::prefer(ex, asio::execution::outstanding_work.tracked),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(
-      asio::prefer(ex,
-        asio::execution::outstanding_work.untracked),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(
-      asio::prefer(ex,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  pool.wait();
-
-  ASIO_CHECK(count == 6);
-}
-
-ASIO_TEST_SUITE
-(
-  "any_io_executor",
-  ASIO_TEST_CASE(any_io_executor_construction_test)
-  ASIO_TEST_CASE(any_io_executor_nothrow_construction_test)
-  ASIO_TEST_CASE(any_io_executor_assignment_test)
-  ASIO_TEST_CASE(any_io_executor_swap_test)
-  ASIO_TEST_CASE(any_io_executor_query_test)
-  ASIO_TEST_CASE(any_io_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/append.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/append.cpp
deleted file mode 100644
index 9aa00e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/append.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// append.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/append.hpp"
-
-#include "asio/bind_executor.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "unit_test.hpp"
-
-void append_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(
-      asio::append(
-        asio::bind_executor(io2.get_executor(),
-          [&count](asio::error_code, int a, int b)
-          {
-            ++count;
-            ASIO_CHECK(a == 123);
-            ASIO_CHECK(b == 321);
-          }), 123, 321));
-
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "append",
-  ASIO_TEST_CASE(append_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_ops.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_ops.hpp
deleted file mode 100644
index 3c2b130..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_ops.hpp
+++ /dev/null
@@ -1,413 +0,0 @@
-//
-// archetypes/async_ops.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ARCHETYPES_ASYNC_OPS_HPP
-#define ARCHETYPES_ASYNC_OPS_HPP
-
-#include <functional>
-#include "asio/associated_allocator.hpp"
-#include "asio/associated_executor.hpp"
-#include "asio/async_result.hpp"
-#include "asio/error.hpp"
-
-namespace archetypes {
-
-namespace bindns = std;
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void()>::return_type
-async_op_0(CompletionToken&& token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void()>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void()> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  ex.post(static_cast<handler_type&&>(completion.completion_handler), a);
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(asio::error_code)>::return_type
-async_op_ec_0(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(asio::error_code)>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(asio::error_code)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code()), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(asio::error::operation_aborted)), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(std::exception_ptr)>::return_type
-async_op_ex_0(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(std::exception_ptr)>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(std::exception_ptr)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::exception_ptr()), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::make_exception_ptr(std::runtime_error("blah"))), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(int)>::return_type
-async_op_1(ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(int)>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(int)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  ex.post(
-      bindns::bind(
-        static_cast<handler_type&&>(completion.completion_handler),
-        42), a);
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(asio::error_code, int)>::return_type
-async_op_ec_1(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(asio::error_code, int)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(asio::error_code, int)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(), 42), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(asio::error::operation_aborted),
-          0), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(std::exception_ptr, int)>::return_type
-async_op_ex_1(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(std::exception_ptr, int)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(std::exception_ptr, int)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::exception_ptr(), 42), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::make_exception_ptr(std::runtime_error("blah")), 0), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(int, double)>::return_type
-async_op_2(ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(int, double)>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(int, double)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  ex.post(
-      bindns::bind(
-        static_cast<handler_type&&>(completion.completion_handler),
-        42, 2.0), a);
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(asio::error_code, int, double)>::return_type
-async_op_ec_2(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(asio::error_code, int, double)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(asio::error_code, int, double)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(), 42, 2.0), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(asio::error::operation_aborted),
-          0, 0.0), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(std::exception_ptr, int, double)>::return_type
-async_op_ex_2(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(std::exception_ptr, int, double)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(std::exception_ptr, int, double)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::exception_ptr(), 42, 2.0), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::make_exception_ptr(std::runtime_error("blah")), 0, 0.0), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(int, double, char)>::return_type
-async_op_3(ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(int, double, char)>::completion_handler_type handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(int, double, char)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  ex.post(
-      bindns::bind(
-        static_cast<handler_type&&>(completion.completion_handler),
-        42, 2.0, 'a'), a);
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(asio::error_code, int, double, char)>::return_type
-async_op_ec_3(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(asio::error_code, int, double, char)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(asio::error_code, int, double, char)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(), 42, 2.0, 'a'), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          asio::error_code(asio::error::operation_aborted),
-          0, 0.0, 'z'), a);
-  }
-
-  return completion.result.get();
-}
-
-template <typename CompletionToken>
-typename asio::async_result<asio::decay_t<CompletionToken>,
-  void(std::exception_ptr, int, double, char)>::return_type
-async_op_ex_3(bool ok, ASIO_MOVE_ARG(CompletionToken) token)
-{
-  typedef typename asio::async_result<asio::decay_t<CompletionToken>,
-    void(std::exception_ptr, int, double, char)>::completion_handler_type
-      handler_type;
-
-  asio::async_completion<CompletionToken,
-    void(std::exception_ptr, int, double, char)> completion(token);
-
-  typename asio::associated_allocator<handler_type>::type a
-    = asio::get_associated_allocator(completion.completion_handler);
-
-  typename asio::associated_executor<handler_type>::type ex
-    = asio::get_associated_executor(completion.completion_handler);
-
-  if (ok)
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::exception_ptr(), 42, 2.0, 'a'), a);
-  }
-  else
-  {
-    ex.post(
-        bindns::bind(
-          static_cast<handler_type&&>(completion.completion_handler),
-          std::make_exception_ptr(std::runtime_error("blah")),
-          0, 0.0, 'z'), a);
-  }
-
-  return completion.result.get();
-}
-
-} // namespace archetypes
-
-#endif // ARCHETYPES_ASYNC_OPS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_result.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_result.hpp
deleted file mode 100644
index bfd9cf1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/async_result.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//
-// async_result.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ARCHETYPES_ASYNC_RESULT_HPP
-#define ARCHETYPES_ASYNC_RESULT_HPP
-
-#include <asio/async_result.hpp>
-#include <asio/system_executor.hpp>
-
-namespace archetypes {
-
-struct immediate_handler
-{
-};
-
-struct lazy_handler
-{
-};
-
-template <typename Signature>
-struct concrete_handler;
-
-template <typename R, typename Arg1>
-struct concrete_handler<R(Arg1)>
-{
-  concrete_handler()
-  {
-  }
-
-  void operator()(typename asio::decay<Arg1>::type)
-  {
-  }
-
-  concrete_handler(concrete_handler&&) {}
-private:
-  concrete_handler(const concrete_handler&);
-};
-
-template <typename R, typename Arg1, typename Arg2>
-struct concrete_handler<R(Arg1, Arg2)>
-{
-  concrete_handler()
-  {
-  }
-
-  void operator()(typename asio::decay<Arg1>::type,
-      typename asio::decay<Arg2>::type)
-  {
-  }
-};
-
-template <typename Signature>
-struct immediate_concrete_handler : concrete_handler<Signature>
-{
-  typedef asio::system_executor immediate_executor_type;
-
-  immediate_concrete_handler(immediate_handler)
-  {
-  }
-
-  immediate_executor_type get_immediate_executor() const noexcept
-  {
-    return immediate_executor_type();
-  }
-
-  immediate_concrete_handler(immediate_concrete_handler&&) {}
-private:
-  immediate_concrete_handler(const immediate_concrete_handler&);
-};
-
-template <typename Signature>
-struct lazy_concrete_handler : concrete_handler<Signature>
-{
-  lazy_concrete_handler(lazy_handler)
-  {
-  }
-
-  lazy_concrete_handler(lazy_concrete_handler&&) {}
-private:
-  lazy_concrete_handler(const lazy_concrete_handler&);
-};
-
-} // namespace archetypes
-
-namespace asio {
-
-template <typename Signature>
-class async_result<archetypes::immediate_handler, Signature>
-{
-public:
-  // The concrete completion handler type.
-  typedef archetypes::immediate_concrete_handler<Signature>
-    completion_handler_type;
-
-  // The return type of the initiating function.
-  typedef void return_type;
-
-  // Construct an async_result from a given handler.
-  explicit async_result(completion_handler_type&)
-  {
-  }
-
-  // Obtain the value to be returned from the initiating function.
-  void get()
-  {
-  }
-
-private:
-  // Disallow copying and assignment.
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-};
-
-template <typename Signature>
-class async_result<archetypes::lazy_handler, Signature>
-{
-public:
-  // The concrete completion handler type.
-  typedef archetypes::lazy_concrete_handler<Signature> completion_handler_type;
-
-  // The return type of the initiating function.
-  typedef int return_type;
-
-  // Construct an async_result from a given handler.
-  explicit async_result(completion_handler_type&)
-  {
-  }
-
-  // Obtain the value to be returned from the initiating function.
-  return_type get()
-  {
-    return 42;
-  }
-
-private:
-  // Disallow copying and assignment.
-  async_result(const async_result&) = delete;
-  async_result& operator=(const async_result&) = delete;
-};
-
-} // namespace asio
-
-#endif // ARCHETYPES_ASYNC_RESULT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/gettable_socket_option.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/gettable_socket_option.hpp
deleted file mode 100644
index e1c2d3f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/gettable_socket_option.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// gettable_socket_option.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ARCHETYPES_GETTABLE_SOCKET_OPTION_HPP
-#define ARCHETYPES_GETTABLE_SOCKET_OPTION_HPP
-
-#include <cstddef>
-
-namespace archetypes {
-
-template <typename PointerType>
-class gettable_socket_option
-{
-public:
-  template <typename Protocol>
-  int level(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  int name(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  PointerType* data(const Protocol&)
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  void resize(const Protocol&, std::size_t)
-  {
-  }
-};
-
-} // namespace archetypes
-
-#endif // ARCHETYPES_GETTABLE_SOCKET_OPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/io_control_command.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/io_control_command.hpp
deleted file mode 100644
index 45ed07c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/io_control_command.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// io_control_command.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ARCHETYPES_IO_CONTROL_COMMAND_HPP
-#define ARCHETYPES_IO_CONTROL_COMMAND_HPP
-
-namespace archetypes {
-
-class io_control_command
-{
-public:
-  int name() const
-  {
-    return 0;
-  }
-
-  void* data()
-  {
-    return 0;
-  }
-};
-
-} // namespace archetypes
-
-#endif // ARCHETYPES_IO_CONTROL_COMMAND_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/settable_socket_option.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/settable_socket_option.hpp
deleted file mode 100644
index 7a5867b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/archetypes/settable_socket_option.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// settable_socket_option.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ARCHETYPES_SETTABLE_SOCKET_OPTION_HPP
-#define ARCHETYPES_SETTABLE_SOCKET_OPTION_HPP
-
-#include <cstddef>
-
-namespace archetypes {
-
-template <typename PointerType>
-class settable_socket_option
-{
-public:
-  template <typename Protocol>
-  int level(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  int name(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  const PointerType* data(const Protocol&) const
-  {
-    return 0;
-  }
-
-  template <typename Protocol>
-  std::size_t size(const Protocol&) const
-  {
-    return 0;
-  }
-};
-
-} // namespace archetypes
-
-#endif // ARCHETYPES_SETTABLE_SOCKET_OPTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/as_tuple.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/as_tuple.cpp
deleted file mode 100644
index 84fa65d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/as_tuple.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//
-// as_tuple.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/as_tuple.hpp"
-
-#include "asio/bind_executor.hpp"
-#include "asio/deferred.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "asio/use_future.hpp"
-#include "unit_test.hpp"
-
-void as_tuple_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(
-      asio::as_tuple(
-        asio::bind_executor(io2.get_executor(),
-          [&count](std::tuple<asio::error_code>)
-          {
-            ++count;
-          })));
-
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(count == 1);
-
-  timer1.async_wait(
-      asio::as_tuple(
-        asio::bind_executor(io2.get_executor(),
-          asio::deferred)))(
-            [&count](std::tuple<asio::error_code>)
-            {
-              ++count;
-            });
-
-  ASIO_CHECK(count == 1);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(count == 1);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(count == 2);
-
-# if defined(ASIO_HAS_STD_FUTURE_CLASS)
-  std::future<std::tuple<asio::error_code> > f = timer1.async_wait(
-      asio::as_tuple(
-        asio::bind_executor(io2.get_executor(),
-          asio::use_future)));
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::ready);
-# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-}
-
-void as_tuple_constness_test()
-{
-# if defined(ASIO_HAS_STD_FUTURE_CLASS)
-  asio::io_context io1;
-  asio::system_timer timer1(io1);
-
-  auto tok1 = asio::as_tuple(asio::use_future);
-  (void)timer1.async_wait(tok1);
-  (void)timer1.async_wait(std::move(tok1));
-
-  const auto tok2 = asio::as_tuple(asio::use_future);
-  (void)timer1.async_wait(tok2);
-  (void)timer1.async_wait(std::move(tok2));
-
-  constexpr auto tok3 = asio::as_tuple(asio::use_future);
-  (void)timer1.async_wait(tok3);
-  (void)timer1.async_wait(std::move(tok3));
-# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-}
-
-void partial_as_tuple_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(asio::as_tuple)(
-      asio::bind_executor(io2.get_executor(),
-        [&count](std::tuple<asio::error_code>)
-        {
-          ++count;
-        }));
-
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(count == 1);
-
-  timer1.async_wait(asio::as_tuple)(
-      asio::bind_executor(io2.get_executor(),
-        asio::deferred))(
-          [&count](std::tuple<asio::error_code>)
-          {
-            ++count;
-          });
-
-  ASIO_CHECK(count == 1);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(count == 1);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(count == 2);
-
-# if defined(ASIO_HAS_STD_FUTURE_CLASS)
-  std::future<std::tuple<asio::error_code> > f
-    = timer1.async_wait(asio::as_tuple)(
-        asio::bind_executor(io2.get_executor(),
-          asio::use_future));
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::ready);
-# endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-}
-
-ASIO_TEST_SUITE
-(
-  "as_tuple",
-  ASIO_TEST_CASE(as_tuple_test)
-  ASIO_COMPILE_TEST_CASE(as_tuple_constness_test)
-  ASIO_TEST_CASE(partial_as_tuple_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_allocator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_allocator.cpp
deleted file mode 100644
index 69a8afb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_allocator.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// associated_allocator.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/associated_allocator.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "associated_allocator",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_cancellation_slot.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_cancellation_slot.cpp
deleted file mode 100644
index 96d4884..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_cancellation_slot.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// associated_cancellation_slot.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/associated_cancellation_slot.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "associated_cancellation_slot",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_executor.cpp
deleted file mode 100644
index 60b1f00..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_executor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// associated_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/associated_executor.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "associated_executor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_immediate_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_immediate_executor.cpp
deleted file mode 100644
index f085a2c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associated_immediate_executor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// associated_immediate_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/associated_immediate_executor.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "associated_immediate_executor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associator.cpp
deleted file mode 100644
index a35d95c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/associator.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// associator.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/associator.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "associator",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/async_result.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/async_result.cpp
deleted file mode 100644
index 75a4e91..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/async_result.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// async_result.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/async_result.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "async_result",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/awaitable.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/awaitable.cpp
deleted file mode 100644
index 39ca8dd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/awaitable.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// awaitable.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/awaitable.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "awaitable",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_datagram_socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_datagram_socket.cpp
deleted file mode 100644
index 44fa256..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_datagram_socket.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_datagram_socket.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_datagram_socket.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_datagram_socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_deadline_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_deadline_timer.cpp
deleted file mode 100644
index ec6a6e3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_deadline_timer.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_deadline_timer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_deadline_timer.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_deadline_timer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_file.cpp
deleted file mode 100644
index 5308d12..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_file.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_file.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_file.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_file",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_random_access_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_random_access_file.cpp
deleted file mode 100644
index fffaee3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_random_access_file.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_random_access_file.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_random_access_file.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_random_access_file",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_raw_socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_raw_socket.cpp
deleted file mode 100644
index 127df06..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_raw_socket.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_raw_socket.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_raw_socket.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_raw_socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_readable_pipe.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_readable_pipe.cpp
deleted file mode 100644
index f390acf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_readable_pipe.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_readable_pipe.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_readable_pipe.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_readable_pipe",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_seq_packet_socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_seq_packet_socket.cpp
deleted file mode 100644
index c8b9bfa..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_seq_packet_socket.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_seq_packet_socket.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_seq_packet_socket.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_seq_packet_socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_serial_port.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_serial_port.cpp
deleted file mode 100644
index 1a64348..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_serial_port.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// basic_serial_port.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_serial_port.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_serial_port",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_signal_set.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_signal_set.cpp
deleted file mode 100644
index 0134017..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_signal_set.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_signal_set.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_signal_set.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_signal_set",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket.cpp
deleted file mode 100644
index c2814e6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_socket.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_socket.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket_acceptor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket_acceptor.cpp
deleted file mode 100644
index 021a816..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_socket_acceptor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_socket_acceptor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_socket_acceptor.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_socket_acceptor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_file.cpp
deleted file mode 100644
index 9902122..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_file.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_stream_file.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_stream_file.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_stream_file",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_socket.cpp
deleted file mode 100644
index 1edbe5a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_stream_socket.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_stream_socket.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_stream_socket.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_stream_socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_streambuf.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_streambuf.cpp
deleted file mode 100644
index 9529dd8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_streambuf.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_streambuf.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_streambuf.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_streambuf",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_waitable_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_waitable_timer.cpp
deleted file mode 100644
index 9d6be41..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_waitable_timer.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_waitable_timer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_waitable_timer.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_waitable_timer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_writable_pipe.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_writable_pipe.cpp
deleted file mode 100644
index fc0d0fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/basic_writable_pipe.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_writable_pipe.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/basic_writable_pipe.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_writable_pipe",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_allocator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_allocator.cpp
deleted file mode 100644
index 5aec566..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_allocator.cpp
+++ /dev/null
@@ -1,259 +0,0 @@
-//
-// bind_allocator.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/bind_allocator.hpp"
-
-#include <functional>
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-
-template <typename T>
-class test_allocator
-{
-public:
-  typedef T value_type;
-
-  explicit test_allocator(int* allocations)
-    : allocations_(allocations)
-  {
-  }
-
-  template <typename U>
-  test_allocator(const test_allocator<U>& other)
-    : allocations_(other.allocations_)
-  {
-  }
-
-  template <typename U>
-  struct rebind
-  {
-    typedef test_allocator<U> other;
-  };
-
-  bool operator==(const test_allocator&) const
-  {
-    return true;
-  }
-
-  bool operator!=(const test_allocator&) const
-  {
-    return false;
-  }
-
-  T* allocate(std::size_t n) const
-  {
-    ++(*allocations_);
-    return static_cast<T*>(::operator new(sizeof(T) * n));
-  }
-
-  void deallocate(T* p, std::size_t /*n*/) const
-  {
-    --(*allocations_);
-    ::operator delete(p);
-  }
-
-//private:
-  int* allocations_;
-};
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void bind_allocator_to_function_object_test()
-{
-  io_context ioc;
-
-  int count = 0;
-  int allocations = 0;
-
-  timer t(ioc, chronons::seconds(1));
-  t.async_wait(
-      bind_allocator(
-        test_allocator<int>(&allocations),
-        bindns::bind(&increment, &count)));
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 0);
-
-  t.async_wait(
-      bind_allocator(
-        test_allocator<int>(&allocations),
-        bind_allocator(
-          std::allocator<void>(),
-          bindns::bind(&increment, &count))));
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-  ASIO_CHECK(allocations == 0);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-  void operator()(asio::error_code){ increment(count); }
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void(asio::error_code)>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void bind_allocator_to_completion_token_v1_test()
-{
-  io_context ioc;
-
-  int count = 0;
-  int allocations = 0;
-
-  timer t(ioc, chronons::seconds(1));
-  t.async_wait(
-      bind_allocator(
-        test_allocator<int>(&allocations),
-        incrementer_token_v1(&count)));
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 0);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void(asio::error_code)>
-{
-public:
-#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-  typedef void return_type;
-#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(bindns::bind(&increment, token.count),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void bind_allocator_to_completion_token_v2_test()
-{
-  io_context ioc;
-
-  int count = 0;
-  int allocations = 0;
-
-  timer t(ioc, chronons::seconds(1));
-  t.async_wait(
-      bind_allocator(
-        test_allocator<int>(&allocations),
-        incrementer_token_v2(&count)));
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 0);
-}
-
-void partial_bind_allocator_test()
-{
-  io_context ioc;
-
-  int count = 0;
-  int allocations = 0;
-
-  timer t(ioc, chronons::seconds(1));
-  t.async_wait(bind_allocator(test_allocator<int>(&allocations)))(
-      bindns::bind(&increment, &count));
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 0);
-
-  t.expires_after(chronons::seconds(1));
-  t.async_wait()(
-      bind_allocator(test_allocator<int>(&allocations)))(
-        incrementer_token_v2(&count));
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(allocations == 1);
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(allocations == 0);
-}
-
-ASIO_TEST_SUITE
-(
-  "bind_allocator",
-  ASIO_TEST_CASE(bind_allocator_to_function_object_test)
-  ASIO_TEST_CASE(bind_allocator_to_completion_token_v1_test)
-  ASIO_TEST_CASE(bind_allocator_to_completion_token_v2_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_cancellation_slot.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_cancellation_slot.cpp
deleted file mode 100644
index 902b429..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_cancellation_slot.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-//
-// bind_cancellation_slot.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/bind_cancellation_slot.hpp"
-
-#include <functional>
-#include "asio/cancellation_signal.hpp"
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-
-void increment_on_cancel(int* count, const asio::error_code& error)
-{
-  if (error == asio::error::operation_aborted)
-    ++(*count);
-}
-
-void bind_cancellation_slot_to_function_object_test()
-{
-  io_context ioc;
-  cancellation_signal sig;
-
-  int count = 0;
-
-  timer t(ioc, chronons::seconds(5));
-  t.async_wait(
-      bind_cancellation_slot(sig.slot(),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.poll();
-
-  ASIO_CHECK(count == 0);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.async_wait(
-      bind_cancellation_slot(sig.slot(),
-        bind_cancellation_slot(sig.slot(),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.poll();
-
-  ASIO_CHECK(count == 1);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-
-  void operator()(asio::error_code error)
-  {
-    increment_on_cancel(count, error);
-  }
-
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void(asio::error_code)>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void bind_cancellation_slot_to_completion_token_v1_test()
-{
-  io_context ioc;
-  cancellation_signal sig;
-
-  int count = 0;
-
-  timer t(ioc, chronons::seconds(5));
-  t.async_wait(
-      bind_cancellation_slot(sig.slot(),
-        incrementer_token_v1(&count)));
-
-  ioc.poll();
-
-  ASIO_CHECK(count == 0);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void(asio::error_code)>
-{
-public:
-#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-  typedef void return_type;
-#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(
-        bindns::bind(&increment_on_cancel,
-          token.count, bindns::placeholders::_1),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void bind_cancellation_slot_to_completion_token_v2_test()
-{
-  io_context ioc;
-  cancellation_signal sig;
-
-  int count = 0;
-
-  timer t(ioc, chronons::seconds(5));
-  t.async_wait(
-      bind_cancellation_slot(sig.slot(),
-        incrementer_token_v2(&count)));
-
-  ioc.poll();
-
-  ASIO_CHECK(count == 0);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-void partial_bind_cancellation_slot()
-{
-  io_context ioc;
-  cancellation_signal sig;
-
-  int count = 0;
-
-  timer t(ioc, chronons::seconds(5));
-  t.async_wait(bind_cancellation_slot(sig.slot()))(
-      bindns::bind(&increment_on_cancel,
-        &count, bindns::placeholders::_1));
-
-  ioc.poll();
-
-  ASIO_CHECK(count == 0);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.async_wait()(
-      bind_cancellation_slot(sig.slot()))(
-        incrementer_token_v2(&count));
-
-  ioc.restart();
-  ioc.poll();
-
-  ASIO_CHECK(count == 1);
-
-  sig.emit(asio::cancellation_type::all);
-
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "bind_cancellation_slot",
-  ASIO_TEST_CASE(bind_cancellation_slot_to_function_object_test)
-  ASIO_TEST_CASE(bind_cancellation_slot_to_completion_token_v1_test)
-  ASIO_TEST_CASE(bind_cancellation_slot_to_completion_token_v2_test)
-  ASIO_TEST_CASE(partial_bind_cancellation_slot)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_executor.cpp
deleted file mode 100644
index 6d46424..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_executor.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//
-// bind_executor.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/bind_executor.hpp"
-
-#include <functional>
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void bind_executor_to_function_object_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  timer t(ioc1, chronons::seconds(1));
-  t.async_wait(
-      bind_executor(
-        ioc2.get_executor(),
-        bindns::bind(&increment, &count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.async_wait(
-      bind_executor(
-        ioc2.get_executor(),
-        bind_executor(
-          asio::system_executor(),
-          bindns::bind(&increment, &count))));
-
-  ioc1.restart();
-  ioc1.run();
-
-  ASIO_CHECK(count == 1);
-
-  ioc2.restart();
-  ioc2.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-  void operator()(asio::error_code){ increment(count); }
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void(asio::error_code)>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void bind_executor_to_completion_token_v1_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  timer t(ioc1, chronons::seconds(1));
-  t.async_wait(
-      bind_executor(
-        ioc2.get_executor(),
-        incrementer_token_v1(&count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void(asio::error_code)>
-{
-public:
-#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-  typedef void return_type;
-#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(bindns::bind(&increment, token.count),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void bind_executor_to_completion_token_v2_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  timer t(ioc1, chronons::seconds(1));
-  t.async_wait(
-      bind_executor(
-        ioc2.get_executor(),
-        incrementer_token_v2(&count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-void partial_bind_executor_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  timer t(ioc1, chronons::seconds(1));
-  t.async_wait(bind_executor(ioc2.get_executor()))(
-      bindns::bind(&increment, &count));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(1));
-  t.async_wait()(
-      bind_executor(ioc2.get_executor()))(
-        incrementer_token_v2(&count));
-
-  ioc1.restart();
-  ioc1.run();
-
-  ASIO_CHECK(count == 1);
-
-  ioc2.restart();
-  ioc2.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "bind_executor",
-  ASIO_TEST_CASE(bind_executor_to_function_object_test)
-  ASIO_TEST_CASE(bind_executor_to_completion_token_v1_test)
-  ASIO_TEST_CASE(bind_executor_to_completion_token_v2_test)
-  ASIO_TEST_CASE(partial_bind_executor_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_immediate_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_immediate_executor.cpp
deleted file mode 100644
index 1a4b07d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/bind_immediate_executor.cpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//
-// bind_immediate_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/bind_immediate_executor.hpp"
-
-#include <functional>
-#include "asio/immediate.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void bind_immediate_executor_to_function_object_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  async_immediate(ioc1,
-      bind_immediate_executor(
-        ioc2.get_executor(),
-        bindns::bind(&increment, &count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-
-  async_immediate(ioc1.get_executor(),
-      bind_immediate_executor(
-        ioc2.get_executor(),
-        bind_immediate_executor(
-          asio::system_executor(),
-          bindns::bind(&increment, &count))));
-
-  ioc1.restart();
-  ioc1.run();
-
-  ASIO_CHECK(count == 1);
-
-  ioc2.restart();
-  ioc2.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-  void operator()(){ increment(count); }
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void()>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void bind_immediate_executor_to_completion_token_v1_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  async_immediate(ioc1,
-      bind_immediate_executor(
-        ioc2.get_executor(),
-        incrementer_token_v1(&count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void()>
-{
-public:
-#if !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-  typedef void return_type;
-#endif // !defined(ASIO_HAS_RETURN_TYPE_DEDUCTION)
-
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(bindns::bind(&increment, token.count),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void bind_immediate_executor_to_completion_token_v2_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  async_immediate(ioc1,
-      bind_immediate_executor(
-        ioc2.get_executor(),
-        incrementer_token_v2(&count)));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-void partial_bind_immediate_executor_test()
-{
-  io_context ioc1;
-  io_context ioc2;
-
-  int count = 0;
-
-  async_immediate(ioc1, bind_immediate_executor(ioc2.get_executor()))(
-      bindns::bind(&increment, &count));
-
-  ioc1.run();
-
-  ASIO_CHECK(count == 0);
-
-  ioc2.run();
-
-  ASIO_CHECK(count == 1);
-
-  async_immediate(ioc1, bind_immediate_executor(ioc2.get_executor()))(
-      incrementer_token_v2(&count));
-
-  ioc1.restart();
-  ioc1.run();
-
-  ASIO_CHECK(count == 1);
-
-  ioc2.restart();
-  ioc2.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "bind_immediate_executor",
-  ASIO_TEST_CASE(bind_immediate_executor_to_function_object_test)
-  ASIO_TEST_CASE(bind_immediate_executor_to_completion_token_v1_test)
-  ASIO_TEST_CASE(bind_immediate_executor_to_completion_token_v2_test)
-  ASIO_TEST_CASE(partial_bind_immediate_executor_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer.cpp
deleted file mode 100644
index 9fa1db6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer.cpp
+++ /dev/null
@@ -1,913 +0,0 @@
-//
-// buffer.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffer.hpp"
-
-#include <array>
-#include <cstring>
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-# include <boost/array.hpp>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-//------------------------------------------------------------------------------
-
-// buffer_compile test
-// ~~~~~~~~~~~~~~~~~~~
-// The following test checks that all overloads of the buffer function compile
-// and link correctly. Runtime failures are ignored.
-
-namespace buffer_compile {
-
-using namespace asio;
-
-template <typename T>
-class mutable_contiguous_container
-{
-public:
-  typedef T value_type;
-  typedef T* iterator;
-  typedef const T* const_iterator;
-  typedef T& reference;
-  typedef const T& const_reference;
-
-  mutable_contiguous_container() {}
-  std::size_t size() const { return 0; }
-  iterator begin() { return 0; }
-  const_iterator begin() const { return 0; }
-  iterator end() { return 0; }
-  const_iterator end() const { return 0; }
-};
-
-template <typename T>
-class const_contiguous_container
-{
-public:
-  typedef const T value_type;
-  typedef const T* iterator;
-  typedef const T* const_iterator;
-  typedef const T& reference;
-  typedef const T& const_reference;
-
-  const_contiguous_container() {}
-  std::size_t size() const { return 0; }
-  iterator begin() { return 0; }
-  const_iterator begin() const { return 0; }
-  iterator end() { return 0; }
-  const_iterator end() const { return 0; }
-};
-
-void test()
-{
-  try
-  {
-    char raw_data[1024];
-    const char const_raw_data[1024] = "";
-    void* void_ptr_data = raw_data;
-    const void* const_void_ptr_data = const_raw_data;
-#if defined(ASIO_HAS_BOOST_ARRAY)
-    boost::array<char, 1024> array_data;
-    const boost::array<char, 1024>& const_array_data_1 = array_data;
-    boost::array<const char, 1024> const_array_data_2 = { { 0 } };
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-    std::array<char, 1024> std_array_data;
-    const std::array<char, 1024>& const_std_array_data_1 = std_array_data;
-    std::array<const char, 1024> const_std_array_data_2 = { { 0 } };
-    std::vector<char> vector_data(1024);
-    const std::vector<char>& const_vector_data = vector_data;
-    std::string string_data(1024, ' ');
-    const std::string const_string_data(1024, ' ');
-    std::vector<mutable_buffer> mutable_buffer_sequence;
-    std::vector<const_buffer> const_buffer_sequence;
-#if defined(ASIO_HAS_STD_STRING_VIEW)
-    std::string_view string_view_data(string_data);
-#elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    std::experimental::string_view string_view_data(string_data);
-#endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    mutable_contiguous_container<char> mutable_contiguous_data;
-    const mutable_contiguous_container<char> const_mutable_contiguous_data;
-    const_contiguous_container<char> const_contiguous_data;
-    const const_contiguous_container<char> const_const_contiguous_data;
-
-    // mutable_buffer constructors.
-
-    mutable_buffer mb1;
-    mutable_buffer mb2(void_ptr_data, 1024);
-    mutable_buffer mb3(mb1);
-    (void)mb3;
-
-    // mutable_buffer functions.
-
-    void* ptr1 = mb1.data();
-    (void)ptr1;
-
-    std::size_t n1 = mb1.size();
-    (void)n1;
-
-    // mutable_buffer operators.
-
-    mb1 += 128;
-    mb1 = mb2 + 128;
-    mb1 = 128 + mb2;
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-    // mutable_buffers_1 constructors.
-
-    mutable_buffers_1 mbc1(mb1);
-    mutable_buffers_1 mbc2(mbc1);
-
-    // mutable_buffers_1 functions.
-
-    mutable_buffers_1::const_iterator iter1 = mbc1.begin();
-    (void)iter1;
-    mutable_buffers_1::const_iterator iter2 = mbc1.end();
-    (void)iter2;
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    // const_buffer constructors.
-
-    const_buffer cb1;
-    const_buffer cb2(const_void_ptr_data, 1024);
-    const_buffer cb3(cb1);
-    (void)cb3;
-    const_buffer cb4(mb1);
-    (void)cb4;
-
-    // const_buffer functions.
-
-    const void* ptr2 = cb1.data();
-    (void)ptr2;
-
-    std::size_t n2 = cb1.size();
-    (void)n2;
-
-    // const_buffer operators.
-
-    cb1 += 128;
-    cb1 = cb2 + 128;
-    cb1 = 128 + cb2;
-
-#if !defined(ASIO_NO_DEPRECATED)
-
-    // const_buffers_1 constructors.
-
-    const_buffers_1 cbc1(cb1);
-    const_buffers_1 cbc2(cbc1);
-
-    // const_buffers_1 functions.
-
-    const_buffers_1::const_iterator iter3 = cbc1.begin();
-    (void)iter3;
-    const_buffers_1::const_iterator iter4 = cbc1.end();
-    (void)iter4;
-
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    // buffer_size function overloads.
-
-    std::size_t size1 = buffer_size(mb1);
-    (void)size1;
-    std::size_t size2 = buffer_size(cb1);
-    (void)size2;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size3 = buffer_size(mbc1);
-    (void)size3;
-    std::size_t size4 = buffer_size(cbc1);
-    (void)size4;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size5 = buffer_size(mutable_buffer_sequence);
-    (void)size5;
-    std::size_t size6 = buffer_size(const_buffer_sequence);
-    (void)size6;
-
-    // buffer_cast function overloads.
-
-#if !defined(ASIO_NO_DEPRECATED)
-    void* ptr3 = buffer_cast<void*>(mb1);
-    (void)ptr3;
-    const void* ptr4 = buffer_cast<const void*>(cb1);
-    (void)ptr4;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    // buffer function overloads.
-
-    mb1 = buffer(mb2);
-    mb1 = buffer(mb2, 128);
-    cb1 = buffer(cb2);
-    cb1 = buffer(cb2, 128);
-    mb1 = buffer(void_ptr_data, 1024);
-    cb1 = buffer(const_void_ptr_data, 1024);
-    mb1 = buffer(raw_data);
-    mb1 = buffer(raw_data, 1024);
-    cb1 = buffer(const_raw_data);
-    cb1 = buffer(const_raw_data, 1024);
-#if defined(ASIO_HAS_BOOST_ARRAY)
-    mb1 = buffer(array_data);
-    mb1 = buffer(array_data, 1024);
-    cb1 = buffer(const_array_data_1);
-    cb1 = buffer(const_array_data_1, 1024);
-    cb1 = buffer(const_array_data_2);
-    cb1 = buffer(const_array_data_2, 1024);
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-    mb1 = buffer(std_array_data);
-    mb1 = buffer(std_array_data, 1024);
-    cb1 = buffer(const_std_array_data_1);
-    cb1 = buffer(const_std_array_data_1, 1024);
-    cb1 = buffer(const_std_array_data_2);
-    cb1 = buffer(const_std_array_data_2, 1024);
-    mb1 = buffer(vector_data);
-    mb1 = buffer(vector_data, 1024);
-    cb1 = buffer(const_vector_data);
-    cb1 = buffer(const_vector_data, 1024);
-    mb1 = buffer(string_data);
-    mb1 = buffer(string_data, 1024);
-    cb1 = buffer(const_string_data);
-    cb1 = buffer(const_string_data, 1024);
-#if defined(ASIO_HAS_STRING_VIEW)
-    cb1 = buffer(string_view_data);
-    cb1 = buffer(string_view_data, 1024);
-#endif // defined(ASIO_HAS_STRING_VIEW)
-    mb1 = buffer(mutable_contiguous_data);
-    mb1 = buffer(mutable_contiguous_data, 1024);
-    cb1 = buffer(const_mutable_contiguous_data);
-    cb1 = buffer(const_mutable_contiguous_data, 1024);
-    cb1 = buffer(const_contiguous_data);
-    cb1 = buffer(const_contiguous_data, 1024);
-    cb1 = buffer(const_const_contiguous_data);
-    cb1 = buffer(const_const_contiguous_data, 1024);
-
-    // buffer_copy function overloads.
-
-    std::size_t size7 = buffer_copy(mb1, cb2);
-    (void)size7;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size8 = buffer_copy(mb1, cbc2);
-    (void)size8;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size9 = buffer_copy(mb1, mb2);
-    (void)size9;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size10 = buffer_copy(mb1, mbc2);
-    (void)size10;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size11 = buffer_copy(mb1, const_buffer_sequence);
-    (void)size11;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size12 = buffer_copy(mbc1, cb2);
-    (void)size12;
-    std::size_t size13 = buffer_copy(mbc1, cbc2);
-    (void)size13;
-    std::size_t size14 = buffer_copy(mbc1, mb2);
-    (void)size14;
-    std::size_t size15 = buffer_copy(mbc1, mbc2);
-    (void)size15;
-    std::size_t size16 = buffer_copy(mbc1, const_buffer_sequence);
-    (void)size16;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size17 = buffer_copy(mutable_buffer_sequence, cb2);
-    (void)size17;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size18 = buffer_copy(mutable_buffer_sequence, cbc2);
-    (void)size18;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size19 = buffer_copy(mutable_buffer_sequence, mb2);
-    (void)size19;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size20 = buffer_copy(mutable_buffer_sequence, mbc2);
-    (void)size20;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size21 = buffer_copy(
-        mutable_buffer_sequence, const_buffer_sequence);
-    (void)size21;
-    std::size_t size22 = buffer_copy(mb1, cb2, 128);
-    (void)size22;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size23 = buffer_copy(mb1, cbc2, 128);
-    (void)size23;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size24 = buffer_copy(mb1, mb2, 128);
-    (void)size24;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size25 = buffer_copy(mb1, mbc2, 128);
-    (void)size25;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size26 = buffer_copy(mb1, const_buffer_sequence, 128);
-    (void)size26;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size27 = buffer_copy(mbc1, cb2, 128);
-    (void)size27;
-    std::size_t size28 = buffer_copy(mbc1, cbc2, 128);
-    (void)size28;
-    std::size_t size29 = buffer_copy(mbc1, mb2, 128);
-    (void)size29;
-    std::size_t size30 = buffer_copy(mbc1, mbc2, 128);
-    (void)size30;
-    std::size_t size31 = buffer_copy(mbc1, const_buffer_sequence, 128);
-    (void)size31;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size32 = buffer_copy(mutable_buffer_sequence, cb2, 128);
-    (void)size32;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size33 = buffer_copy(mutable_buffer_sequence, cbc2, 128);
-    (void)size33;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size34 = buffer_copy(mutable_buffer_sequence, mb2, 128);
-    (void)size34;
-#if !defined(ASIO_NO_DEPRECATED)
-    std::size_t size35 = buffer_copy(mutable_buffer_sequence, mbc2, 128);
-    (void)size35;
-#endif // !defined(ASIO_NO_DEPRECATED)
-    std::size_t size36 = buffer_copy(
-        mutable_buffer_sequence, const_buffer_sequence, 128);
-    (void)size36;
-
-    // dynamic_buffer function overloads.
-
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type> db1 = dynamic_buffer(string_data);
-    (void)db1;
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type> db2 = dynamic_buffer(string_data, 1024);
-    (void)db2;
-    dynamic_vector_buffer<char, std::allocator<char> >
-      db3 = dynamic_buffer(vector_data);
-    (void)db3;
-    dynamic_vector_buffer<char, std::allocator<char> >
-      db4 = dynamic_buffer(vector_data, 1024);
-    (void)db4;
-
-    // dynamic_buffer member functions.
-
-    std::size_t size37 = db1.size();
-    (void)size37;
-    std::size_t size38 = db3.size();
-    (void)size38;
-
-    std::size_t size39 = db1.max_size();
-    (void)size39;
-    std::size_t size40 = db3.max_size();
-    (void)size40;
-
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type>::const_buffers_type
-        cb5 = db1.data();
-    (void)cb5;
-    dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
-      cb6 = db3.data();
-    (void)cb6;
-
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type>::mutable_buffers_type mb5
-        = db1.prepare(1024);
-    (void)mb5;
-    dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
-      mb6 = db3.prepare(1024);
-    (void)mb6;
-
-    db1.commit(1024);
-    db3.commit(1024);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type>::mutable_buffers_type
-        mb7 = db1.data(0, 1);
-    (void)mb7;
-    dynamic_vector_buffer<char, std::allocator<char> >::mutable_buffers_type
-      mb8 = db3.data(0, 1);
-    (void)mb8;
-
-    dynamic_string_buffer<char, std::string::traits_type,
-      std::string::allocator_type>::const_buffers_type
-        cb7 = static_cast<const dynamic_string_buffer<char,
-          std::string::traits_type,
-            std::string::allocator_type>&>(db1).data(0, 1);
-    (void)cb7;
-    dynamic_vector_buffer<char, std::allocator<char> >::const_buffers_type
-      cb8 = static_cast<const dynamic_vector_buffer<char,
-        std::allocator<char> >&>(db3).data(0, 1);
-    (void)cb8;
-
-    db1.grow(1024);
-    db3.grow(1024);
-
-    db1.shrink(1024);
-    db3.shrink(1024);
-
-    db1.consume(0);
-    db3.consume(0);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace buffer_compile
-
-//------------------------------------------------------------------------------
-
-namespace buffer_copy_runtime {
-
-using namespace asio;
-using namespace std;
-
-void test()
-{
-  char dest_data[256];
-  char source_data[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mutable_buffer mb1 = asio::buffer(dest_data);
-  mutable_buffer mb2 = asio::buffer(source_data);
-  std::size_t n = buffer_copy(mb1, mb2);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  const_buffer cb1 = asio::buffer(source_data);
-  n = buffer_copy(mb1, cb1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-#if !defined(ASIO_NO_DEPRECATED)
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  mutable_buffers_1 mbc1 = asio::buffer(source_data);
-  n = buffer_copy(mb1, mbc1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  const_buffers_1 cbc1 = const_buffers_1(asio::buffer(source_data));
-  n = buffer_copy(mb1, cbc1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  mb1 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, mb1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  cb1 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, cb1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  mutable_buffers_1 mbc2 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, mbc2);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  cbc1 = const_buffers_1(asio::buffer(source_data));
-  n = buffer_copy(mbc1, cbc1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  std::vector<mutable_buffer> mv1;
-  mv1.push_back(asio::buffer(source_data, 5));
-  mv1.push_back(asio::buffer(source_data) + 5);
-  n = buffer_copy(mb1, mv1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  std::vector<const_buffer> cv1;
-  cv1.push_back(asio::buffer(source_data, 6));
-  cv1.push_back(asio::buffer(source_data) + 6);
-  n = buffer_copy(mb1, cv1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mv1.clear();
-  mv1.push_back(asio::buffer(dest_data, 7));
-  mv1.push_back(asio::buffer(dest_data) + 7);
-  cb1 = asio::buffer(source_data);
-  n = buffer_copy(mv1, cb1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mv1.clear();
-  mv1.push_back(asio::buffer(dest_data, 7));
-  mv1.push_back(asio::buffer(dest_data) + 7);
-  cv1.clear();
-  cv1.push_back(asio::buffer(source_data, 8));
-  cv1.push_back(asio::buffer(source_data) + 8);
-  n = buffer_copy(mv1, cv1);
-  ASIO_CHECK(n == sizeof(source_data));
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  mb2 = asio::buffer(source_data);
-  n = buffer_copy(mb1, mb2, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  cb1 = asio::buffer(source_data);
-  n = buffer_copy(mb1, cb1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-#if !defined(ASIO_NO_DEPRECATED)
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  mbc1 = asio::buffer(source_data);
-  n = buffer_copy(mb1, mbc1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  cbc1 = const_buffers_1(asio::buffer(source_data));
-  n = buffer_copy(mb1, cbc1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  mb1 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, mb1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  cb1 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, cb1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  mbc2 = asio::buffer(source_data);
-  n = buffer_copy(mbc1, mbc2, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mbc1 = asio::buffer(dest_data);
-  cbc1 = const_buffers_1(asio::buffer(source_data));
-  n = buffer_copy(mbc1, cbc1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  mv1.clear();
-  mv1.push_back(asio::buffer(source_data, 5));
-  mv1.push_back(asio::buffer(source_data) + 5);
-  n = buffer_copy(mb1, mv1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mb1 = asio::buffer(dest_data);
-  cv1.clear();
-  cv1.push_back(asio::buffer(source_data, 6));
-  cv1.push_back(asio::buffer(source_data) + 6);
-  n = buffer_copy(mb1, cv1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mv1.clear();
-  mv1.push_back(asio::buffer(dest_data, 7));
-  mv1.push_back(asio::buffer(dest_data) + 7);
-  cb1 = asio::buffer(source_data);
-  n = buffer_copy(mv1, cb1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-
-  memset(dest_data, 0, sizeof(dest_data));
-  mv1.clear();
-  mv1.push_back(asio::buffer(dest_data, 7));
-  mv1.push_back(asio::buffer(dest_data) + 7);
-  cv1.clear();
-  cv1.push_back(asio::buffer(source_data, 8));
-  cv1.push_back(asio::buffer(source_data) + 8);
-  n = buffer_copy(mv1, cv1, 10);
-  ASIO_CHECK(n == 10);
-  ASIO_CHECK(memcmp(dest_data, source_data, n) == 0);
-}
-
-} // namespace buffer_copy_runtime
-
-//------------------------------------------------------------------------------
-
-namespace buffer_sequence {
-
-using namespace asio;
-using namespace std;
-
-struct valid_const_a
-{
-  typedef const_buffer* const_iterator;
-  typedef const_buffer value_type;
-  const_buffer* begin() const { return 0; }
-  const_buffer* end() const { return 0; }
-};
-
-struct valid_const_b
-{
-  const_buffer* begin() const { return 0; }
-  const_buffer* end() const { return 0; }
-};
-
-struct valid_mutable_a
-{
-  typedef mutable_buffer* const_iterator;
-  typedef mutable_buffer value_type;
-  mutable_buffer* begin() const { return 0; }
-  mutable_buffer* end() const { return 0; }
-};
-
-struct valid_mutable_b
-{
-  mutable_buffer* begin() const { return 0; }
-  mutable_buffer* end() const { return 0; }
-};
-
-struct invalid_const_a
-{
-  typedef int value_type;
-  int* begin() const { return 0; }
-  const_buffer* end() const { return 0; }
-};
-
-struct invalid_const_b
-{
-  typedef const_buffer value_type;
-  const_buffer* begin() const { return 0; }
-};
-
-struct invalid_const_c
-{
-  typedef const_buffer value_type;
-  const_buffer* end() const { return 0; }
-};
-
-struct invalid_const_d
-{
-  int* begin() const { return 0; }
-  const_buffer* end() const { return 0; }
-};
-
-struct invalid_const_e
-{
-  const_buffer* begin() const { return 0; }
-};
-
-struct invalid_const_f
-{
-  const_buffer* end() const { return 0; }
-};
-
-struct invalid_mutable_a
-{
-  typedef int value_type;
-  int* begin() const { return 0; }
-  mutable_buffer* end() const { return 0; }
-};
-
-struct invalid_mutable_b
-{
-  typedef mutable_buffer value_type;
-  mutable_buffer* begin() const { return 0; }
-};
-
-struct invalid_mutable_c
-{
-  typedef mutable_buffer value_type;
-  mutable_buffer* end() const { return 0; }
-};
-
-struct invalid_mutable_d
-{
-  int* begin() const { return 0; }
-  mutable_buffer* end() const { return 0; }
-};
-
-struct invalid_mutable_e
-{
-  mutable_buffer* begin() const { return 0; }
-};
-
-struct invalid_mutable_f
-{
-  mutable_buffer* end() const { return 0; }
-};
-
-void test()
-{
-  ASIO_CHECK(is_const_buffer_sequence<const_buffer>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<const_buffer>::value);
-
-  const_buffer b1;
-  ASIO_CHECK(buffer_sequence_begin(b1) == &b1);
-  ASIO_CHECK(buffer_sequence_end(b1) == &b1 + 1);
-
-  ASIO_CHECK(is_const_buffer_sequence<mutable_buffer>::value);
-  ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffer>::value);
-
-  mutable_buffer b2;
-  ASIO_CHECK(buffer_sequence_begin(b2) == &b2);
-  ASIO_CHECK(buffer_sequence_end(b2) == &b2 + 1);
-
-#if !defined(ASIO_NO_DEPRECATED)
-  ASIO_CHECK(is_const_buffer_sequence<const_buffers_1>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<const_buffers_1>::value);
-
-  const_buffers_1 b3(0, 0);
-  ASIO_CHECK(buffer_sequence_begin(b3) == &b3);
-  ASIO_CHECK(buffer_sequence_end(b3) == &b3 + 1);
-
-  ASIO_CHECK(is_const_buffer_sequence<mutable_buffers_1>::value);
-  ASIO_CHECK(is_mutable_buffer_sequence<mutable_buffers_1>::value);
-
-  mutable_buffers_1 b4(0, 0);
-  ASIO_CHECK(buffer_sequence_begin(b4) == &b4);
-  ASIO_CHECK(buffer_sequence_end(b4) == &b4 + 1);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-  ASIO_CHECK(is_const_buffer_sequence<vector<const_buffer> >::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<vector<const_buffer> >::value);
-
-  vector<const_buffer> b5;
-  ASIO_CHECK(buffer_sequence_begin(b5) == b5.begin());
-  ASIO_CHECK(buffer_sequence_end(b5) == b5.end());
-
-  ASIO_CHECK(is_const_buffer_sequence<vector<mutable_buffer> >::value);
-  ASIO_CHECK(is_mutable_buffer_sequence<vector<mutable_buffer> >::value);
-
-  vector<mutable_buffer> b6;
-  ASIO_CHECK(buffer_sequence_begin(b6) == b6.begin());
-  ASIO_CHECK(buffer_sequence_end(b6) == b6.end());
-
-  ASIO_CHECK(is_const_buffer_sequence<valid_const_a>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_a>::value);
-
-  valid_const_a b7;
-  ASIO_CHECK(buffer_sequence_begin(b7) == b7.begin());
-  ASIO_CHECK(buffer_sequence_end(b7) == b7.end());
-
-  ASIO_CHECK(is_const_buffer_sequence<valid_const_b>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<valid_const_b>::value);
-
-  valid_const_b b8;
-  ASIO_CHECK(buffer_sequence_begin(b8) == b8.begin());
-  ASIO_CHECK(buffer_sequence_end(b8) == b8.end());
-
-  ASIO_CHECK(is_const_buffer_sequence<valid_mutable_a>::value);
-  ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_a>::value);
-
-  valid_mutable_a b9;
-  ASIO_CHECK(buffer_sequence_begin(b9) == b9.begin());
-  ASIO_CHECK(buffer_sequence_end(b9) == b9.end());
-
-  ASIO_CHECK(is_const_buffer_sequence<valid_mutable_b>::value);
-  ASIO_CHECK(is_mutable_buffer_sequence<valid_mutable_b>::value);
-
-  valid_mutable_b b10;
-  ASIO_CHECK(buffer_sequence_begin(b10) == b10.begin());
-  ASIO_CHECK(buffer_sequence_end(b10) == b10.end());
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_a>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_a>::value);
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_b>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_b>::value);
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_c>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_c>::value);
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_d>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_d>::value);
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_e>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_e>::value);
-
-  ASIO_CHECK(!is_const_buffer_sequence<invalid_const_f>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_const_f>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_a>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_b>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_c>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_d>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_e>::value);
-
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value);
-  ASIO_CHECK(!is_mutable_buffer_sequence<invalid_mutable_f>::value);
-}
-
-} // namespace buffer_sequence
-
-namespace buffer_literals {
-
-void test()
-{
-#if defined(ASIO_HAS_USER_DEFINED_LITERALS)
-  using namespace asio::buffer_literals;
-  using namespace std; // For memcmp.
-
-  asio::const_buffer b1 = ""_buf;
-  ASIO_CHECK(b1.size() == 0);
-
-  asio::const_buffer b2 = "hello"_buf;
-  ASIO_CHECK(b2.size() == 5);
-  ASIO_CHECK(memcmp(b2.data(), "hello", 5) == 0);
-
-  asio::const_buffer b3 = 0x00_buf;
-  ASIO_CHECK(b3.size() == 1);
-  ASIO_CHECK(memcmp(b3.data(), "\x00", 1) == 0);
-
-  asio::const_buffer b4 = 0X01_buf;
-  ASIO_CHECK(b4.size() == 1);
-  ASIO_CHECK(memcmp(b4.data(), "\x01", 1) == 0);
-
-  asio::const_buffer b5 = 0xaB_buf;
-  ASIO_CHECK(b5.size() == 1);
-  ASIO_CHECK(memcmp(b5.data(), "\xab", 1) == 0);
-
-  asio::const_buffer b6 = 0xABcd_buf;
-  ASIO_CHECK(b6.size() == 2);
-  ASIO_CHECK(memcmp(b6.data(), "\xab\xcd", 2) == 0);
-
-  asio::const_buffer b7 = 0x01ab01cd01ef01ba01dc01fe_buf;
-  ASIO_CHECK(b7.size() == 12);
-  ASIO_CHECK(memcmp(b7.data(),
-        "\x01\xab\x01\xcd\x01\xef\x01\xba\x01\xdc\x01\xfe", 12) == 0);
-
-  asio::const_buffer b8 = 0b00000000_buf;
-  ASIO_CHECK(b8.size() == 1);
-  ASIO_CHECK(memcmp(b8.data(), "\x00", 1) == 0);
-
-  asio::const_buffer b9 = 0B00000001_buf;
-  ASIO_CHECK(b9.size() == 1);
-  ASIO_CHECK(memcmp(b9.data(), "\x01", 1) == 0);
-
-  asio::const_buffer b10 = 0B11111111_buf;
-  ASIO_CHECK(b10.size() == 1);
-  ASIO_CHECK(memcmp(b10.data(), "\xFF", 1) == 0);
-
-  asio::const_buffer b11 = 0b1111000000001111_buf;
-  ASIO_CHECK(b11.size() == 2);
-  ASIO_CHECK(memcmp(b11.data(), "\xF0\x0F", 2) == 0);
-#endif // (defined(ASIO_HAS_USER_DEFINED_LITERALS)
-}
-
-} // namespace buffer_literals
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "buffer",
-  ASIO_COMPILE_TEST_CASE(buffer_compile::test)
-  ASIO_TEST_CASE(buffer_copy_runtime::test)
-  ASIO_TEST_CASE(buffer_sequence::test)
-  ASIO_TEST_CASE(buffer_literals::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer_registration.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer_registration.cpp
deleted file mode 100644
index 72826a3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffer_registration.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// buffer_registration.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffer_registration.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "buffer_registration",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_read_stream.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_read_stream.cpp
deleted file mode 100644
index 21b4abc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_read_stream.cpp
+++ /dev/null
@@ -1,329 +0,0 @@
-//
-// buffered_read_stream.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffered_read_stream.hpp"
-
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/system_error.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-# include <boost/array.hpp>
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-# include <array>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-typedef asio::buffered_read_stream<
-    asio::ip::tcp::socket> stream_type;
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void fill_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test_compile()
-{
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  using boost::array;
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-  using std::array;
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    array<asio::mutable_buffer, 2> mutable_buffers = {{
-        asio::buffer(mutable_char_buffer, 10),
-        asio::buffer(mutable_char_buffer + 10, 10) }};
-    array<asio::const_buffer, 2> const_buffers = {{
-        asio::buffer(const_char_buffer, 10),
-        asio::buffer(const_char_buffer + 10, 10) }};
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    stream_type stream1(ioc);
-    stream_type stream2(ioc, 1024);
-
-    stream_type::executor_type ex = stream1.get_executor();
-    (void)ex;
-
-    stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
-    (void)lowest_layer;
-
-    stream1.write_some(buffer(mutable_char_buffer));
-    stream1.write_some(buffer(const_char_buffer));
-    stream1.write_some(mutable_buffers);
-    stream1.write_some(const_buffers);
-    stream1.write_some(null_buffers());
-    stream1.write_some(buffer(mutable_char_buffer), ec);
-    stream1.write_some(buffer(const_char_buffer), ec);
-    stream1.write_some(mutable_buffers, ec);
-    stream1.write_some(const_buffers, ec);
-    stream1.write_some(null_buffers(), ec);
-
-    stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
-    stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
-    stream1.async_write_some(mutable_buffers, &write_some_handler);
-    stream1.async_write_some(const_buffers, &write_some_handler);
-    stream1.async_write_some(null_buffers(), &write_some_handler);
-    int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-    int i3 = stream1.async_write_some(mutable_buffers, lazy);
-    (void)i3;
-    int i4 = stream1.async_write_some(const_buffers, lazy);
-    (void)i4;
-    int i5 = stream1.async_write_some(null_buffers(), lazy);
-    (void)i5;
-
-    stream1.fill();
-    stream1.fill(ec);
-
-    stream1.async_fill(&fill_handler);
-    int i6 = stream1.async_fill(lazy);
-    (void)i6;
-
-    stream1.read_some(buffer(mutable_char_buffer));
-    stream1.read_some(mutable_buffers);
-    stream1.read_some(null_buffers());
-    stream1.read_some(buffer(mutable_char_buffer), ec);
-    stream1.read_some(mutable_buffers, ec);
-    stream1.read_some(null_buffers(), ec);
-
-    stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
-    stream1.async_read_some(mutable_buffers, &read_some_handler);
-    stream1.async_read_some(null_buffers(), &read_some_handler);
-    int i7 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i7;
-    int i8 = stream1.async_read_some(mutable_buffers, lazy);
-    (void)i8;
-    int i9 = stream1.async_read_some(null_buffers(), lazy);
-    (void)i9;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-void test_sync_operations()
-{
-  using namespace std; // For memcmp.
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.accept(server_socket.lowest_layer());
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += client_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += server_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += server_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += client_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  asio::error_code error;
-  bytes_read = client_socket.read_some(
-      asio::buffer(read_buf), error);
-
-  ASIO_CHECK(bytes_read == 0);
-  ASIO_CHECK(error == asio::error::eof);
-
-  client_socket.close(error);
-}
-
-void handle_accept(const asio::error_code& e)
-{
-  ASIO_CHECK(!e);
-}
-
-void handle_write(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_written)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_written += bytes_transferred;
-}
-
-void handle_read(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_read)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_read += bytes_transferred;
-}
-
-void handle_read_eof(const asio::error_code& e,
-    std::size_t bytes_transferred)
-{
-  ASIO_CHECK(e == asio::error::eof);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test_async_operations()
-{
-  using namespace std; // For memcmp.
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
-  io_context.run();
-  io_context.restart();
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    client_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    server_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    server_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    client_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
-}
-
-ASIO_TEST_SUITE
-(
-  "buffered_read_stream",
-  ASIO_COMPILE_TEST_CASE(test_compile)
-  ASIO_TEST_CASE(test_sync_operations)
-  ASIO_TEST_CASE(test_async_operations)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_stream.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_stream.cpp
deleted file mode 100644
index 4830ec2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_stream.cpp
+++ /dev/null
@@ -1,355 +0,0 @@
-//
-// buffered_stream.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffered_stream.hpp"
-
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/system_error.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-# include <boost/array.hpp>
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-# include <array>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-typedef asio::buffered_stream<
-    asio::ip::tcp::socket> stream_type;
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void flush_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void fill_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test_compile()
-{
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  using boost::array;
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-  using std::array;
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    array<asio::mutable_buffer, 2> mutable_buffers = {{
-        asio::buffer(mutable_char_buffer, 10),
-        asio::buffer(mutable_char_buffer + 10, 10) }};
-    array<asio::const_buffer, 2> const_buffers = {{
-        asio::buffer(const_char_buffer, 10),
-        asio::buffer(const_char_buffer + 10, 10) }};
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    stream_type stream1(ioc);
-    stream_type stream2(ioc, 1024, 1024);
-
-    stream_type::executor_type ex = stream1.get_executor();
-    (void)ex;
-
-    stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
-    (void)lowest_layer;
-
-    stream1.write_some(buffer(mutable_char_buffer));
-    stream1.write_some(buffer(const_char_buffer));
-    stream1.write_some(mutable_buffers);
-    stream1.write_some(const_buffers);
-    stream1.write_some(null_buffers());
-    stream1.write_some(buffer(mutable_char_buffer), ec);
-    stream1.write_some(buffer(const_char_buffer), ec);
-    stream1.write_some(mutable_buffers, ec);
-    stream1.write_some(const_buffers, ec);
-    stream1.write_some(null_buffers(), ec);
-
-    stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
-    stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
-    stream1.async_write_some(mutable_buffers, &write_some_handler);
-    stream1.async_write_some(const_buffers, &write_some_handler);
-    stream1.async_write_some(null_buffers(), &write_some_handler);
-    int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-    int i3 = stream1.async_write_some(mutable_buffers, lazy);
-    (void)i3;
-    int i4 = stream1.async_write_some(const_buffers, lazy);
-    (void)i4;
-    int i5 = stream1.async_write_some(null_buffers(), lazy);
-    (void)i5;
-
-    stream1.flush();
-    stream1.flush(ec);
-
-    stream1.async_flush(&flush_handler);
-    int i6 = stream1.async_flush(lazy);
-    (void)i6;
-
-    stream1.fill();
-    stream1.fill(ec);
-
-    stream1.async_fill(&fill_handler);
-    int i7 = stream1.async_fill(lazy);
-    (void)i7;
-
-    stream1.read_some(buffer(mutable_char_buffer));
-    stream1.read_some(mutable_buffers);
-    stream1.read_some(null_buffers());
-    stream1.read_some(buffer(mutable_char_buffer), ec);
-    stream1.read_some(mutable_buffers, ec);
-    stream1.read_some(null_buffers(), ec);
-
-    stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
-    stream1.async_read_some(mutable_buffers, &read_some_handler);
-    stream1.async_read_some(null_buffers(), &read_some_handler);
-    int i8 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i8;
-    int i9 = stream1.async_read_some(mutable_buffers, lazy);
-    (void)i9;
-    int i10 = stream1.async_read_some(null_buffers(), lazy);
-    (void)i10;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-void test_sync_operations()
-{
-  using namespace std; // For memcmp.
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.accept(server_socket.lowest_layer());
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += client_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-    client_socket.flush();
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += server_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += server_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-    server_socket.flush();
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += client_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  asio::error_code error;
-  bytes_read = client_socket.read_some(
-      asio::buffer(read_buf), error);
-
-  ASIO_CHECK(bytes_read == 0);
-  ASIO_CHECK(error == asio::error::eof);
-
-  client_socket.close(error);
-}
-
-void handle_accept(const asio::error_code& e)
-{
-  ASIO_CHECK(!e);
-}
-
-void handle_write(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_written)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_written += bytes_transferred;
-}
-
-void handle_flush(const asio::error_code& e)
-{
-  ASIO_CHECK(!e);
-}
-
-void handle_read(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_read)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_read += bytes_transferred;
-}
-
-void handle_read_eof(const asio::error_code& e,
-    std::size_t bytes_transferred)
-{
-  ASIO_CHECK(e == asio::error::eof);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test_async_operations()
-{
-  using namespace std; // For memcmp.
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
-  io_context.run();
-  io_context.restart();
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    client_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-    client_socket.async_flush(
-        bindns::bind(handle_flush, _1));
-    io_context.run();
-    io_context.restart();
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    server_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    server_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-    server_socket.async_flush(
-        bindns::bind(handle_flush, _1));
-    io_context.run();
-    io_context.restart();
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    client_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
-}
-
-ASIO_TEST_SUITE
-(
-  "buffered_stream",
-  ASIO_COMPILE_TEST_CASE(test_compile)
-  ASIO_TEST_CASE(test_sync_operations)
-  ASIO_TEST_CASE(test_async_operations)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_write_stream.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_write_stream.cpp
deleted file mode 100644
index 635ff98..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffered_write_stream.cpp
+++ /dev/null
@@ -1,344 +0,0 @@
-//
-// buffered_write_stream.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffered_write_stream.hpp"
-
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/buffer.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/system_error.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-# include <boost/array.hpp>
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-# include <array>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-typedef asio::buffered_write_stream<
-    asio::ip::tcp::socket> stream_type;
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void flush_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test_compile()
-{
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  using boost::array;
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-  using std::array;
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    array<asio::mutable_buffer, 2> mutable_buffers = {{
-        asio::buffer(mutable_char_buffer, 10),
-        asio::buffer(mutable_char_buffer + 10, 10) }};
-    array<asio::const_buffer, 2> const_buffers = {{
-        asio::buffer(const_char_buffer, 10),
-        asio::buffer(const_char_buffer + 10, 10) }};
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    stream_type stream1(ioc);
-    stream_type stream2(ioc, 1024);
-
-    stream_type::executor_type ex = stream1.get_executor();
-    (void)ex;
-
-    stream_type::lowest_layer_type& lowest_layer = stream1.lowest_layer();
-    (void)lowest_layer;
-
-    stream1.write_some(buffer(mutable_char_buffer));
-    stream1.write_some(buffer(const_char_buffer));
-    stream1.write_some(mutable_buffers);
-    stream1.write_some(const_buffers);
-    stream1.write_some(null_buffers());
-    stream1.write_some(buffer(mutable_char_buffer), ec);
-    stream1.write_some(buffer(const_char_buffer), ec);
-    stream1.write_some(mutable_buffers, ec);
-    stream1.write_some(const_buffers, ec);
-    stream1.write_some(null_buffers(), ec);
-
-    stream1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
-    stream1.async_write_some(buffer(const_char_buffer), &write_some_handler);
-    stream1.async_write_some(mutable_buffers, &write_some_handler);
-    stream1.async_write_some(const_buffers, &write_some_handler);
-    stream1.async_write_some(null_buffers(), &write_some_handler);
-    int i1 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = stream1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-    int i3 = stream1.async_write_some(mutable_buffers, lazy);
-    (void)i3;
-    int i4 = stream1.async_write_some(const_buffers, lazy);
-    (void)i4;
-    int i5 = stream1.async_write_some(null_buffers(), lazy);
-    (void)i5;
-
-    stream1.flush();
-    stream1.flush(ec);
-
-    stream1.async_flush(&flush_handler);
-    int i6 = stream1.async_flush(lazy);
-    (void)i6;
-
-    stream1.read_some(buffer(mutable_char_buffer));
-    stream1.read_some(mutable_buffers);
-    stream1.read_some(null_buffers());
-    stream1.read_some(buffer(mutable_char_buffer), ec);
-    stream1.read_some(mutable_buffers, ec);
-    stream1.read_some(null_buffers(), ec);
-
-    stream1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
-    stream1.async_read_some(mutable_buffers, &read_some_handler);
-    stream1.async_read_some(null_buffers(), &read_some_handler);
-    int i7 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i7;
-    int i8 = stream1.async_read_some(mutable_buffers, lazy);
-    (void)i8;
-    int i9 = stream1.async_read_some(null_buffers(), lazy);
-    (void)i9;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-void test_sync_operations()
-{
-  using namespace std; // For memcmp.
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.accept(server_socket.lowest_layer());
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += client_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-    client_socket.flush();
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += server_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    bytes_written += server_socket.write_some(
-        asio::buffer(write_buf + bytes_written));
-    server_socket.flush();
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    bytes_read += client_socket.read_some(
-        asio::buffer(read_buf + bytes_read));
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  asio::error_code error;
-  bytes_read = client_socket.read_some(
-      asio::buffer(read_buf), error);
-
-  ASIO_CHECK(bytes_read == 0);
-  ASIO_CHECK(error == asio::error::eof);
-
-  client_socket.close(error);
-}
-
-void handle_accept(const asio::error_code& e)
-{
-  ASIO_CHECK(!e);
-}
-
-void handle_write(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_written)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_written += bytes_transferred;
-}
-
-void handle_flush(const asio::error_code& e)
-{
-  ASIO_CHECK(!e);
-}
-
-void handle_read(const asio::error_code& e,
-    std::size_t bytes_transferred,
-    std::size_t* total_bytes_read)
-{
-  ASIO_CHECK(!e);
-  if (e)
-    throw asio::system_error(e); // Terminate test.
-  *total_bytes_read += bytes_transferred;
-}
-
-void handle_read_eof(const asio::error_code& e,
-    std::size_t bytes_transferred)
-{
-  ASIO_CHECK(e == asio::error::eof);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test_async_operations()
-{
-  using namespace std; // For memcmp.
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context io_context;
-
-  asio::ip::tcp::acceptor acceptor(io_context,
-      asio::ip::tcp::endpoint(asio::ip::tcp::v4(), 0));
-  asio::ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(asio::ip::address_v4::loopback());
-
-  stream_type client_socket(io_context);
-  client_socket.lowest_layer().connect(server_endpoint);
-
-  stream_type server_socket(io_context);
-  acceptor.async_accept(server_socket.lowest_layer(), &handle_accept);
-  io_context.run();
-  io_context.restart();
-
-  const char write_data[]
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  const asio::const_buffer write_buf = asio::buffer(write_data);
-
-  std::size_t bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    client_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-    client_socket.async_flush(
-        bindns::bind(handle_flush, _1));
-    io_context.run();
-    io_context.restart();
-  }
-
-  char read_data[sizeof(write_data)];
-  const asio::mutable_buffer read_buf = asio::buffer(read_data);
-
-  std::size_t bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    server_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  bytes_written = 0;
-  while (bytes_written < sizeof(write_data))
-  {
-    server_socket.async_write_some(
-        asio::buffer(write_buf + bytes_written),
-        bindns::bind(handle_write, _1, _2, &bytes_written));
-    io_context.run();
-    io_context.restart();
-    server_socket.async_flush(
-        bindns::bind(handle_flush, _1));
-    io_context.run();
-    io_context.restart();
-  }
-
-  bytes_read = 0;
-  while (bytes_read < sizeof(read_data))
-  {
-    client_socket.async_read_some(
-        asio::buffer(read_buf + bytes_read),
-        bindns::bind(handle_read, _1, _2, &bytes_read));
-    io_context.run();
-    io_context.restart();
-  }
-
-  ASIO_CHECK(bytes_written == sizeof(write_data));
-  ASIO_CHECK(bytes_read == sizeof(read_data));
-  ASIO_CHECK(memcmp(write_data, read_data, sizeof(write_data)) == 0);
-
-  server_socket.close();
-  client_socket.async_read_some(asio::buffer(read_buf), handle_read_eof);
-}
-
-ASIO_TEST_SUITE
-(
-  "buffered_write_stream",
-  ASIO_COMPILE_TEST_CASE(test_compile)
-  ASIO_TEST_CASE(test_sync_operations)
-  ASIO_TEST_CASE(test_async_operations)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffers_iterator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffers_iterator.cpp
deleted file mode 100644
index afd396b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/buffers_iterator.cpp
+++ /dev/null
@@ -1,280 +0,0 @@
-//
-// buffers_iterator.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/buffers_iterator.hpp"
-
-#include <array>
-#include "asio/buffer.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// buffers_iterator_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all operations on the buffers_iterator compile
-// and link correctly. Runtime failures are ignored.
-
-namespace buffers_iterator_compile {
-
-using std::array;
-using std::vector;
-using namespace asio;
-
-void test()
-{
-  try
-  {
-    char data1[16], data2[16];
-    const char cdata1[16] = "", cdata2[16] = "";
-    mutable_buffer mb1 = buffer(data1);
-    array<mutable_buffer, 2> mb2 = {{ buffer(data1), buffer(data2) }};
-    std::vector<mutable_buffer> mb3;
-    mb3.push_back(buffer(data1));
-    const_buffer cb1 = buffer(cdata1);
-    array<const_buffer, 2> cb2 = {{ buffer(cdata1), buffer(cdata2) }};
-    vector<const_buffer> cb3;
-    cb3.push_back(buffer(cdata1));
-
-    // buffers_iterator constructors.
-
-    buffers_iterator<mutable_buffer, char> bi1;
-    buffers_iterator<mutable_buffer, const char> bi2;
-    buffers_iterator<array<mutable_buffer, 2>, char> bi3;
-    buffers_iterator<array<mutable_buffer, 2>, const char> bi4;
-    buffers_iterator<vector<mutable_buffer>, char> bi5;
-    buffers_iterator<vector<mutable_buffer>, const char> bi6;
-    buffers_iterator<const_buffer, char> bi7;
-    buffers_iterator<const_buffer, const char> bi8;
-    buffers_iterator<array<const_buffer, 2>, char> bi9;
-    buffers_iterator<array<const_buffer, 2>, const char> bi10;
-    buffers_iterator<vector<const_buffer>, char> bi11;
-    buffers_iterator<vector<const_buffer>, const char> bi12;
-
-    buffers_iterator<mutable_buffer, char> bi13(
-        buffers_iterator<mutable_buffer, char>::begin(mb1));
-    buffers_iterator<mutable_buffer, const char> bi14(
-        buffers_iterator<mutable_buffer, const char>::begin(mb1));
-    buffers_iterator<array<mutable_buffer, 2>, char> bi15(
-        buffers_iterator<array<mutable_buffer, 2>, char>::begin(mb2));
-    buffers_iterator<array<mutable_buffer, 2>, const char> bi16(
-        buffers_iterator<array<mutable_buffer, 2>, const char>::begin(mb2));
-    buffers_iterator<vector<mutable_buffer>, char> bi17(
-        buffers_iterator<vector<mutable_buffer>, char>::begin(mb3));
-    buffers_iterator<vector<mutable_buffer>, const char> bi18(
-        buffers_iterator<vector<mutable_buffer>, const char>::begin(mb3));
-    buffers_iterator<const_buffer, char> bi19(
-        buffers_iterator<const_buffer, char>::begin(cb1));
-    buffers_iterator<const_buffer, const char> bi20(
-        buffers_iterator<const_buffer, const char>::begin(cb1));
-    buffers_iterator<array<const_buffer, 2>, char> bi21(
-        buffers_iterator<array<const_buffer, 2>, char>::begin(cb2));
-    buffers_iterator<array<const_buffer, 2>, const char> bi22(
-        buffers_iterator<array<const_buffer, 2>, const char>::begin(cb2));
-    buffers_iterator<vector<const_buffer>, char> bi23(
-        buffers_iterator<vector<const_buffer>, char>::begin(cb3));
-    buffers_iterator<vector<const_buffer>, const char> bi24(
-        buffers_iterator<vector<const_buffer>, const char>::begin(cb3));
-
-    // buffers_iterator member functions.
-
-    bi1 = buffers_iterator<mutable_buffer, char>::begin(mb1);
-    bi2 = buffers_iterator<mutable_buffer, const char>::begin(mb1);
-    bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::begin(mb2);
-    bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::begin(mb2);
-    bi5 = buffers_iterator<vector<mutable_buffer>, char>::begin(mb3);
-    bi6 = buffers_iterator<vector<mutable_buffer>, const char>::begin(mb3);
-    bi7 = buffers_iterator<const_buffer, char>::begin(cb1);
-    bi8 = buffers_iterator<const_buffer, const char>::begin(cb1);
-    bi9 = buffers_iterator<array<const_buffer, 2>, char>::begin(cb2);
-    bi10 = buffers_iterator<array<const_buffer, 2>, const char>::begin(cb2);
-    bi11 = buffers_iterator<vector<const_buffer>, char>::begin(cb3);
-    bi12 = buffers_iterator<vector<const_buffer>, const char>::begin(cb3);
-
-    bi1 = buffers_iterator<mutable_buffer, char>::end(mb1);
-    bi2 = buffers_iterator<mutable_buffer, const char>::end(mb1);
-    bi3 = buffers_iterator<array<mutable_buffer, 2>, char>::end(mb2);
-    bi4 = buffers_iterator<array<mutable_buffer, 2>, const char>::end(mb2);
-    bi5 = buffers_iterator<vector<mutable_buffer>, char>::end(mb3);
-    bi6 = buffers_iterator<vector<mutable_buffer>, const char>::end(mb3);
-    bi7 = buffers_iterator<const_buffer, char>::end(cb1);
-    bi8 = buffers_iterator<const_buffer, const char>::end(cb1);
-    bi9 = buffers_iterator<array<const_buffer, 2>, char>::end(cb2);
-    bi10 = buffers_iterator<array<const_buffer, 2>, const char>::end(cb2);
-    bi11 = buffers_iterator<vector<const_buffer>, char>::end(cb3);
-    bi12 = buffers_iterator<vector<const_buffer>, const char>::end(cb3);
-
-    // buffers_iterator related functions.
-
-    bi1 = buffers_begin(mb1);
-    bi3 = buffers_begin(mb2);
-    bi5 = buffers_begin(mb3);
-    bi7 = buffers_begin(cb1);
-    bi9 = buffers_begin(cb2);
-    bi11 = buffers_begin(cb3);
-
-    bi1 = buffers_end(mb1);
-    bi3 = buffers_end(mb2);
-    bi5 = buffers_end(mb3);
-    bi7 = buffers_end(cb1);
-    bi9 = buffers_end(cb2);
-    bi11 = buffers_end(cb3);
-
-    // RandomAccessIterator operations.
-
-    --bi1;
-    --bi2;
-    --bi3;
-    --bi4;
-    --bi5;
-    --bi6;
-    --bi7;
-    --bi8;
-    --bi9;
-    --bi10;
-    --bi11;
-    --bi12;
-
-    ++bi1;
-    ++bi2;
-    ++bi3;
-    ++bi4;
-    ++bi5;
-    ++bi6;
-    ++bi7;
-    ++bi8;
-    ++bi9;
-    ++bi10;
-    ++bi11;
-    ++bi12;
-
-    bi1--;
-    bi2--;
-    bi3--;
-    bi4--;
-    bi5--;
-    bi6--;
-    bi7--;
-    bi8--;
-    bi9--;
-    bi10--;
-    bi11--;
-    bi12--;
-
-    bi1++;
-    bi2++;
-    bi3++;
-    bi4++;
-    bi5++;
-    bi6++;
-    bi7++;
-    bi8++;
-    bi9++;
-    bi10++;
-    bi11++;
-    bi12++;
-
-    bi1 -= 1;
-    bi2 -= 1;
-    bi3 -= 1;
-    bi4 -= 1;
-    bi5 -= 1;
-    bi6 -= 1;
-    bi7 -= 1;
-    bi8 -= 1;
-    bi9 -= 1;
-    bi10 -= 1;
-    bi11 -= 1;
-    bi12 -= 1;
-
-    bi1 += 1;
-    bi2 += 1;
-    bi3 += 1;
-    bi4 += 1;
-    bi5 += 1;
-    bi6 += 1;
-    bi7 += 1;
-    bi8 += 1;
-    bi9 += 1;
-    bi10 += 1;
-    bi11 += 1;
-    bi12 += 1;
-
-    bi1 = bi1 - 1;
-    bi2 = bi2 - 1;
-    bi3 = bi3 - 1;
-    bi4 = bi4 - 1;
-    bi5 = bi5 - 1;
-    bi6 = bi6 - 1;
-    bi7 = bi7 - 1;
-    bi8 = bi8 - 1;
-    bi9 = bi9 - 1;
-    bi10 = bi10 - 1;
-    bi11 = bi11 - 1;
-    bi12 = bi12 - 1;
-
-    bi1 = bi1 + 1;
-    bi2 = bi2 + 1;
-    bi3 = bi3 + 1;
-    bi4 = bi4 + 1;
-    bi5 = bi5 + 1;
-    bi6 = bi6 + 1;
-    bi7 = bi7 + 1;
-    bi8 = bi8 + 1;
-    bi9 = bi9 + 1;
-    bi10 = bi10 + 1;
-    bi11 = bi11 + 1;
-    bi12 = bi12 + 1;
-
-    bi1 = (-1) + bi1;
-    bi2 = (-1) + bi2;
-    bi3 = (-1) + bi3;
-    bi4 = (-1) + bi4;
-    bi5 = (-1) + bi5;
-    bi6 = (-1) + bi6;
-    bi7 = (-1) + bi7;
-    bi8 = (-1) + bi8;
-    bi9 = (-1) + bi9;
-    bi10 = (-1) + bi10;
-    bi11 = (-1) + bi11;
-    bi12 = (-1) + bi12;
-
-    (void)static_cast<std::ptrdiff_t>(bi13 - bi1);
-    (void)static_cast<std::ptrdiff_t>(bi14 - bi2);
-    (void)static_cast<std::ptrdiff_t>(bi15 - bi3);
-    (void)static_cast<std::ptrdiff_t>(bi16 - bi4);
-    (void)static_cast<std::ptrdiff_t>(bi17 - bi5);
-    (void)static_cast<std::ptrdiff_t>(bi18 - bi6);
-    (void)static_cast<std::ptrdiff_t>(bi19 - bi7);
-    (void)static_cast<std::ptrdiff_t>(bi20 - bi8);
-    (void)static_cast<std::ptrdiff_t>(bi21 - bi9);
-    (void)static_cast<std::ptrdiff_t>(bi22 - bi10);
-    (void)static_cast<std::ptrdiff_t>(bi23 - bi11);
-    (void)static_cast<std::ptrdiff_t>(bi24 - bi12);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace buffers_iterator_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "buffers_iterator",
-  ASIO_COMPILE_TEST_CASE(buffers_iterator_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_after.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_after.cpp
deleted file mode 100644
index fc56f4a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_after.cpp
+++ /dev/null
@@ -1,515 +0,0 @@
-//
-// cancel_after.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/cancel_after.hpp"
-
-#include <functional>
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-namespace chronons = asio::chrono;
-
-void increment_on_cancel(int* count, const asio::error_code& error)
-{
-  if (error == asio::error::operation_aborted)
-    ++(*count);
-}
-
-void cancel_after_function_object_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        cancel_after(chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        cancel_after(chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::seconds(10),
-        cancel_after(chronons::milliseconds(100),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_after_timer_function_object_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(10),
-        cancel_after(cancellation_timer2, chronons::milliseconds(100),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-
-  void operator()(asio::error_code error)
-  {
-    increment_on_cancel(count, error);
-  }
-
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void(asio::error_code)>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void cancel_after_completion_token_v1_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        incrementer_token_v1(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        cancel_after(chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        cancel_after(chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::seconds(10),
-        cancel_after(chronons::milliseconds(100),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_after_timer_completion_token_v1_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        incrementer_token_v1(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(10),
-        cancel_after(cancellation_timer2, chronons::milliseconds(100),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void(asio::error_code)>
-{
-public:
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(
-        bindns::bind(&increment_on_cancel,
-          token.count, bindns::placeholders::_1),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void cancel_after_completion_token_v2_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        incrementer_token_v2(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        incrementer_token_v2(&count)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(chronons::seconds(5),
-        cancel_after(chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::milliseconds(100),
-        cancel_after(chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(chronons::seconds(10),
-        cancel_after(chronons::milliseconds(100),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_after_timer_completion_token_v2_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        incrementer_token_v2(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        incrementer_token_v2(&count)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(5),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::milliseconds(100),
-        cancel_after(cancellation_timer2, chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(
-      cancel_after(cancellation_timer1, chronons::seconds(10),
-        cancel_after(cancellation_timer2, chronons::milliseconds(100),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void partial_cancel_after_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(cancel_after(chronons::seconds(5)))(
-      incrementer_token_v2(&count));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(cancel_after(chronons::milliseconds(100)))(
-      incrementer_token_v2(&count));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-void partial_cancel_after_timer_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  t.async_wait(cancel_after(cancellation_timer, chronons::seconds(5)))(
-      incrementer_token_v2(&count));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  t.async_wait(cancel_after(cancellation_timer, chronons::milliseconds(100)))(
-      incrementer_token_v2(&count));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "cancel_after",
-  ASIO_TEST_CASE(cancel_after_function_object_test)
-  ASIO_TEST_CASE(cancel_after_timer_function_object_test)
-  ASIO_TEST_CASE(cancel_after_completion_token_v1_test)
-  ASIO_TEST_CASE(cancel_after_timer_completion_token_v1_test)
-  ASIO_TEST_CASE(cancel_after_completion_token_v2_test)
-  ASIO_TEST_CASE(cancel_after_timer_completion_token_v2_test)
-  ASIO_TEST_CASE(partial_cancel_after_test)
-  ASIO_TEST_CASE(partial_cancel_after_timer_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_at.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_at.cpp
deleted file mode 100644
index 02de7ae..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancel_at.cpp
+++ /dev/null
@@ -1,550 +0,0 @@
-//
-// cancel_at.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/cancel_at.hpp"
-
-#include <functional>
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-namespace chronons = asio::chrono;
-
-void increment_on_cancel(int* count, const asio::error_code& error)
-{
-  if (error == asio::error::operation_aborted)
-    ++(*count);
-}
-
-void cancel_at_function_object_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        cancel_at(now + chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        cancel_at(now + chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(10),
-        cancel_at(now + chronons::milliseconds(100),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_at_timer_function_object_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(10),
-        cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
-          bindns::bind(&increment_on_cancel,
-            &count, bindns::placeholders::_1))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-struct incrementer_token_v1
-{
-  explicit incrementer_token_v1(int* c) : count(c) {}
-  int* count;
-};
-
-struct incrementer_handler_v1
-{
-  explicit incrementer_handler_v1(incrementer_token_v1 t) : count(t.count) {}
-
-  void operator()(asio::error_code error)
-  {
-    increment_on_cancel(count, error);
-  }
-
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v1, void(asio::error_code)>
-{
-public:
-  typedef incrementer_handler_v1 completion_handler_type;
-  typedef void return_type;
-  explicit async_result(completion_handler_type&) {}
-  return_type get() {}
-};
-
-} // namespace asio
-
-void cancel_at_completion_token_v1_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        incrementer_token_v1(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        cancel_at(now + chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        cancel_at(now + chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(10),
-        cancel_at(now + chronons::milliseconds(100),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_at_timer_completion_token_v1_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        incrementer_token_v1(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        bindns::bind(&increment_on_cancel,
-          &count, bindns::placeholders::_1)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(10),
-        cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
-          incrementer_token_v1(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-struct incrementer_token_v2
-{
-  explicit incrementer_token_v2(int* c) : count(c) {}
-  int* count;
-};
-
-namespace asio {
-
-template <>
-class async_result<incrementer_token_v2, void(asio::error_code)>
-{
-public:
-  template <typename Initiation, typename... Args>
-  static void initiate(Initiation initiation,
-      incrementer_token_v2 token, Args&&... args)
-  {
-    initiation(
-        bindns::bind(&increment_on_cancel,
-          token.count, bindns::placeholders::_1),
-        static_cast<Args&&>(args)...);
-  }
-};
-
-} // namespace asio
-
-void cancel_at_completion_token_v2_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        incrementer_token_v2(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        incrementer_token_v2(&count)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(5),
-        cancel_at(now + chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::milliseconds(100),
-        cancel_at(now + chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(now + chronons::seconds(10),
-        cancel_at(now + chronons::milliseconds(100),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void cancel_at_timer_completion_token_v2_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer1(ioc);
-  steady_timer cancellation_timer2(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        incrementer_token_v2(&count)));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        incrementer_token_v2(&count)));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::milliseconds(100));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(5),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::milliseconds(100),
-        cancel_at(cancellation_timer2, now + chronons::seconds(10),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 2);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer1, now + chronons::seconds(10),
-        cancel_at(cancellation_timer2, now + chronons::milliseconds(100),
-          incrementer_token_v2(&count))));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-}
-
-void partial_cancel_at_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(cancel_at(now + chronons::seconds(5)))(
-      incrementer_token_v2(&count));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(cancel_at(now + chronons::milliseconds(100)))(
-      incrementer_token_v2(&count));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-void partial_cancel_at_timer_test()
-{
-  io_context ioc;
-  steady_timer cancellation_timer(ioc);
-  int count = 0;
-
-  steady_timer t(ioc, chronons::milliseconds(100));
-  auto now = steady_timer::clock_type::now();
-  t.async_wait(cancel_at(cancellation_timer, now + chronons::seconds(5)))(
-      incrementer_token_v2(&count));
-
-  ioc.run();
-
-  ASIO_CHECK(count == 0);
-
-  t.expires_after(chronons::seconds(5));
-  now = steady_timer::clock_type::now();
-  t.async_wait(
-      cancel_at(cancellation_timer, now + chronons::milliseconds(100)))(
-        incrementer_token_v2(&count));
-
-  ioc.restart();
-  ioc.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "cancel_at",
-  ASIO_TEST_CASE(cancel_at_function_object_test)
-  ASIO_TEST_CASE(cancel_at_timer_function_object_test)
-  ASIO_TEST_CASE(cancel_at_completion_token_v1_test)
-  ASIO_TEST_CASE(cancel_at_timer_completion_token_v1_test)
-  ASIO_TEST_CASE(cancel_at_completion_token_v2_test)
-  ASIO_TEST_CASE(cancel_at_timer_completion_token_v2_test)
-  ASIO_TEST_CASE(partial_cancel_at_test)
-  ASIO_TEST_CASE(partial_cancel_at_timer_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_signal.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_signal.cpp
deleted file mode 100644
index 0b0f72f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_signal.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// cancellation_signal.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/cancellation_signal.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "cancellation_signal",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_state.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_state.cpp
deleted file mode 100644
index 74bc656..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_state.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// cancellation_state.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/cancellation_state.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "cancellation_state",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_type.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_type.cpp
deleted file mode 100644
index fd6accb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/cancellation_type.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// cancellation_type.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/cancellation_type.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "cancellation_type",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_composed.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_composed.cpp
deleted file mode 100644
index 9ed0bfd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_composed.cpp
+++ /dev/null
@@ -1,565 +0,0 @@
-//
-// co_composed.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/co_composed.hpp"
-
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT)
-
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/deferred.hpp"
-#include "asio/detached.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-
-template <typename CompletionToken>
-auto async_throw(CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      [](auto) { throw 42; }, token);
-}
-
-template <typename CompletionToken>
-auto throw_first(CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed(
-        [](auto state) -> void
-        {
-          throw 42;
-          co_yield state.complete();
-        }), token);
-}
-
-void test_throw_first()
-{
-  try
-  {
-    throw_first(asio::detached);
-    ASIO_CHECK(0);
-  }
-  catch (int)
-  {
-  }
-}
-
-template <typename CompletionToken>
-auto throw_after_await(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed(
-        [](auto state, asio::io_context& ctx) -> void
-        {
-          co_await asio::post(ctx, asio::deferred);
-          throw 42;
-          co_yield state.complete();
-        }), token, std::ref(ctx));
-}
-
-void test_throw_after_await()
-{
-  try
-  {
-    asio::io_context ctx(1);
-    throw_after_await(ctx, asio::detached);
-    ctx.run();
-    ASIO_CHECK(0);
-  }
-  catch (int)
-  {
-  }
-}
-
-template <typename CompletionToken>
-auto throw_in_first_suspend(CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed(
-        [](auto state) -> void
-        {
-          co_await async_throw(asio::deferred);
-          co_yield state.complete();
-        }), token);
-}
-
-void test_throw_in_first_suspend()
-{
-  try
-  {
-    throw_in_first_suspend(asio::detached);
-    ASIO_CHECK(0);
-  }
-  catch (int)
-  {
-  }
-}
-
-template <typename CompletionToken>
-auto throw_in_suspend_after_await(
-    asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed(
-        [](auto state, asio::io_context& ctx) -> void
-        {
-          co_await asio::post(ctx, asio::deferred);
-          co_await async_throw(asio::deferred);
-          co_yield state.complete();
-        }), token, std::ref(ctx));
-}
-
-void test_throw_in_suspend_after_await()
-{
-  try
-  {
-    asio::io_context ctx(1);
-    throw_in_suspend_after_await(ctx, asio::detached);
-    ctx.run();
-    ASIO_CHECK(0);
-  }
-  catch (int)
-  {
-  }
-}
-
-template <typename CompletionToken>
-auto post_loop(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(int)>(
-      asio::co_composed(
-        [](auto state, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await asio::post(ctx, asio::deferred);
-          co_yield state.complete(i);
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_post_loop()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  post_loop(ctx, [&](int i){ count = i; });
-  ctx.run();
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto nested_post(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed(
-        [](auto state, asio::io_context& ctx) -> void
-        {
-          co_await asio::post(ctx, asio::deferred);
-          co_yield state.complete();
-        }, ctx), token, std::ref(ctx));
-}
-
-template <typename CompletionToken>
-auto nested_post_loop(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(int)>(
-      asio::co_composed(
-        [](auto state, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await nested_post(ctx, asio::deferred);
-          co_yield state.complete(i);
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_nested_post_loop()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  nested_post_loop(ctx, [&](int i){ count = i; });
-  ctx.run();
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto post_loop_return_1_0(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::co_composed<void()>(
-        [](auto, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await asio::post(ctx, asio::deferred);
-          co_return {};
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_post_loop_return_1_0()
-{
-  asio::io_context ctx(1);
-  bool done = false;
-  post_loop_return_1_0(ctx, [&]{ done = true; });
-  ctx.run();
-  ASIO_CHECK(done);
-}
-
-template <typename CompletionToken>
-auto post_loop_return_1_1(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(int)>(
-      asio::co_composed<void(int)>(
-        [](auto, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await asio::post(ctx, asio::deferred);
-          co_return {i};
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_post_loop_return_1_1()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  post_loop_return_1_1(ctx, [&](int i){ count = i; });
-  ctx.run();
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto post_loop_return_1_2(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(int, char)>(
-      asio::co_composed<void(int, char)>(
-        [](auto, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await asio::post(ctx, asio::deferred);
-          co_return {i, 'A'};
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_post_loop_return_1_2()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  char ch = 0;
-  post_loop_return_1_2(ctx, [&](int i, char c){ count = i, ch = c; });
-  ctx.run();
-  ASIO_CHECK(count == 100);
-  ASIO_CHECK(ch == 'A');
-}
-
-template <typename CompletionToken>
-auto post_loop_return_2(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(), void(int)>(
-      asio::co_composed<void(), void(int)>(
-        [](auto, asio::io_context& ctx) -> void
-        {
-          int i = 0;
-          for (; i < 100; ++i)
-            co_await asio::post(ctx, asio::deferred);
-          co_return {i};
-        }, ctx), token, std::ref(ctx));
-}
-
-void test_post_loop_return_2()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  post_loop_return_2(ctx, [&](int i = 0){ count = i; });
-  ctx.run();
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto complete_on_cancel(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<
-    CompletionToken, void(asio::error_code, int)>(
-      asio::co_composed<
-        void(asio::error_code, int)>(
-          [](auto state, asio::io_context& ctx) -> void
-          {
-            state.on_cancellation_complete_with(
-                asio::error::invalid_argument, 42);
-            int i = 0;
-            for (; i < 100; ++i)
-              co_await asio::post(ctx, asio::deferred);
-            co_return {asio::error::eof, i};
-          }, ctx), token, std::ref(ctx));
-}
-
-void test_complete_on_cancel()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  asio::error_code ec;
-  asio::cancellation_signal cancel;
-
-  complete_on_cancel(ctx,
-      [&](asio::error_code e, int i)
-      {
-        ec = e;
-        count = i;
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-
-  complete_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run_one();
-  cancel.emit(asio::cancellation_type::all);
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::invalid_argument);
-  ASIO_CHECK(count == 42);
-
-  complete_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto complete_with_default_on_cancel(
-    asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<
-    CompletionToken, void(asio::error_code, int)>(
-      asio::co_composed<
-        void(asio::error_code, int)>(
-          [](auto, asio::io_context& ctx) -> void
-          {
-            int i = 0;
-            for (; i < 100; ++i)
-              co_await asio::post(ctx, asio::deferred);
-            co_return {asio::error::eof, i};
-          }, ctx), token, std::ref(ctx));
-}
-
-void test_complete_with_default_on_cancel()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  asio::error_code ec;
-  asio::cancellation_signal cancel;
-
-  complete_with_default_on_cancel(ctx,
-      [&](asio::error_code e, int i)
-      {
-        ec = e;
-        count = i;
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-
-  complete_with_default_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run_one();
-  cancel.emit(asio::cancellation_type::all);
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::operation_aborted);
-  ASIO_CHECK(count == 0);
-
-  complete_with_default_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-}
-
-template <typename CompletionToken>
-auto throw_on_cancel(asio::io_context& ctx, CompletionToken&& token)
-{
-  return asio::async_initiate<
-    CompletionToken, void(asio::error_code, int)>(
-      asio::co_composed<
-        void(asio::error_code, int)>(
-          [](auto state, asio::io_context& ctx) -> void
-          {
-            try
-            {
-              state.throw_if_cancelled(true);
-              int i = 0;
-              for (; i < 100; ++i)
-                co_await asio::post(ctx, asio::deferred);
-              co_return {asio::error::eof, i};
-            }
-            catch (...)
-            {
-              co_return {asio::error::invalid_argument, 42};
-            }
-          }, ctx), token, std::ref(ctx));
-}
-
-void test_throw_on_cancel()
-{
-  asio::io_context ctx(1);
-  int count = 0;
-  asio::error_code ec;
-  asio::cancellation_signal cancel;
-
-  throw_on_cancel(ctx,
-      [&](asio::error_code e, int i)
-      {
-        ec = e;
-        count = i;
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-
-  throw_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run_one();
-  cancel.emit(asio::cancellation_type::all);
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::invalid_argument);
-  ASIO_CHECK(count == 42);
-
-  throw_on_cancel(ctx,
-      asio::bind_cancellation_slot(cancel.slot(),
-        [&](asio::error_code e, int i)
-        {
-          ec = e;
-          count = i;
-        }));
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec == asio::error::eof);
-  ASIO_CHECK(count == 100);
-}
-
-void test_no_signatures_detached()
-{
-  asio::io_context ctx(1);
-  int count1 = 0;
-  int count2 = 0;
-
-  asio::async_initiate(
-      asio::co_composed(
-        [](auto, asio::io_context& ctx, int& count1, int& count2) -> void
-        {
-          for (;;)
-          {
-            ++count1;
-            co_await asio::post(ctx, asio::deferred);
-            ++count2;
-          }
-        }), asio::detached, std::ref(ctx), std::ref(count1), std::ref(count2));
-
-  ASIO_ASSERT(count1 == 1);
-  ASIO_ASSERT(count2 == 0);
-
-  ctx.run_one();
-
-  ASIO_ASSERT(count1 == 2);
-  ASIO_ASSERT(count2 == 1);
-
-  ctx.restart();
-  ctx.run_one();
-
-  ASIO_ASSERT(count1 == 3);
-  ASIO_ASSERT(count2 == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "co_composed",
-  ASIO_TEST_CASE(test_throw_first)
-  ASIO_TEST_CASE(test_throw_after_await)
-  ASIO_TEST_CASE(test_throw_in_first_suspend)
-  ASIO_TEST_CASE(test_throw_in_suspend_after_await)
-  ASIO_TEST_CASE(test_post_loop)
-  ASIO_TEST_CASE(test_nested_post_loop)
-  ASIO_TEST_CASE(test_post_loop_return_1_0)
-  ASIO_TEST_CASE(test_post_loop_return_1_1)
-  ASIO_TEST_CASE(test_post_loop_return_1_2)
-  ASIO_TEST_CASE(test_post_loop_return_2)
-  ASIO_TEST_CASE(test_complete_on_cancel)
-  ASIO_TEST_CASE(test_complete_with_default_on_cancel)
-  ASIO_TEST_CASE(test_throw_on_cancel)
-  ASIO_TEST_CASE(test_no_signatures_detached)
-)
-
-#else // defined(ASIO_HAS_CO_AWAIT)
-
-ASIO_TEST_SUITE
-(
-  "co_composed",
-  ASIO_TEST_CASE(null_test)
-)
-
-#endif // defined(ASIO_HAS_CO_AWAIT)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_spawn.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_spawn.cpp
deleted file mode 100644
index c5d1fbf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/co_spawn.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-//
-// co_spawn.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/co_spawn.hpp"
-
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_CO_AWAIT)
-
-#include <stdexcept>
-#include "asio/any_completion_handler.hpp"
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/io_context.hpp"
-
-asio::awaitable<void> void_returning_coroutine()
-{
-  co_return;
-}
-
-asio::awaitable<int> int_returning_coroutine()
-{
-  co_return 42;
-}
-
-void test_co_spawn_with_any_completion_handler()
-{
-  asio::io_context ctx;
-
-  bool called = false;
-  asio::co_spawn(ctx, void_returning_coroutine(),
-      asio::any_completion_handler<void(std::exception_ptr)>(
-        [&](std::exception_ptr)
-        {
-          called = true;
-        }));
-
-  ASIO_CHECK(!called);
-
-  ctx.run();
-
-  ASIO_CHECK(called);
-
-  int result = 0;
-  asio::co_spawn(ctx, int_returning_coroutine(),
-      asio::any_completion_handler<void(std::exception_ptr, int)>(
-        [&](std::exception_ptr, int i)
-        {
-          result = i;
-        }));
-
-  ASIO_CHECK(result == 0);
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(result == 42);
-}
-
-void test_co_spawn_immediate_cancel()
-{
-  asio::cancellation_signal sig;
-  asio::io_context ctx;
-
-  std::exception_ptr result = nullptr;
-  bool called = false;
-  asio::co_spawn(ctx, void_returning_coroutine(),
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](std::exception_ptr e)
-        {
-          result = e;
-          called = true;
-        }));
-
-  ASIO_CHECK(!called);
-  ASIO_CHECK(result == nullptr);
-
-  sig.emit(asio::cancellation_type::all);
-  ctx.run();
-
-  ASIO_CHECK(called);
-  ASIO_CHECK(result != nullptr);
-
-  result = nullptr;
-  called = false;
-  asio::co_spawn(ctx, int_returning_coroutine(),
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](std::exception_ptr e, int i)
-        {
-          ASIO_CHECK(i != 42);
-          result = e;
-          called = true;
-        }));
-
-  ASIO_CHECK(!called);
-  ASIO_CHECK(result == nullptr);
-
-  sig.emit(asio::cancellation_type::all);
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(called);
-  ASIO_CHECK(result != nullptr);
-}
-
-ASIO_TEST_SUITE
-(
-  "co_spawn",
-  ASIO_TEST_CASE(test_co_spawn_with_any_completion_handler)
-  ASIO_TEST_CASE(test_co_spawn_immediate_cancel)
-)
-
-#else // defined(ASIO_HAS_CO_AWAIT)
-
-ASIO_TEST_SUITE
-(
-  "co_spawn",
-  ASIO_TEST_CASE(null_test)
-)
-
-#endif // defined(ASIO_HAS_CO_AWAIT)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/completion_condition.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/completion_condition.cpp
deleted file mode 100644
index 106789e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/completion_condition.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// completion_condition.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/completion_condition.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "completion_condition",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/compose.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/compose.cpp
deleted file mode 100644
index c9820af..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/compose.cpp
+++ /dev/null
@@ -1,528 +0,0 @@
-//
-// compose.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/compose.hpp"
-
-#include <functional>
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-class impl_0_completion_args
-{
-public:
-  explicit impl_0_completion_args(asio::io_context& ioc)
-    : ioc_(ioc),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self)
-  {
-    switch (state_)
-    {
-    case starting:
-      state_ = posting;
-      asio::post(ioc_, static_cast<Self&&>(self));
-      break;
-    case posting:
-      self.complete();
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  asio::io_context& ioc_;
-  enum { starting, posting } state_;
-};
-
-template <typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
-async_0_completion_args(asio::io_context& ioc,
-    CompletionToken&& token)
-{
-  return asio::async_compose<CompletionToken, void()>(
-      impl_0_completion_args(ioc), token);
-}
-
-void compose_0_args_handler(int* count)
-{
-  ++(*count);
-}
-
-struct compose_0_args_lvalue_handler
-{
-  int* count_;
-
-  void operator()()
-  {
-    ++(*count_);
-  }
-};
-
-void compose_0_completion_args_test()
-{
-  namespace bindns = std;
-
-  asio::io_context ioc;
-  int count = 0;
-
-  async_0_completion_args(ioc, bindns::bind(&compose_0_args_handler, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  ioc.restart();
-  count = 0;
-
-  compose_0_args_lvalue_handler lvalue_handler = { &count };
-  async_0_completion_args(ioc, lvalue_handler);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-}
-
-//------------------------------------------------------------------------------
-
-class impl_1_completion_arg
-{
-public:
-  explicit impl_1_completion_arg(asio::io_context& ioc)
-    : ioc_(ioc),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self)
-  {
-    switch (state_)
-    {
-    case starting:
-      state_ = posting;
-      asio::post(ioc_, static_cast<Self&&>(self));
-      break;
-    case posting:
-      self.complete(42);
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  asio::io_context& ioc_;
-  enum { starting, posting } state_;
-};
-
-template <typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void(int))
-async_1_completion_arg(asio::io_context& ioc,
-    CompletionToken&& token)
-{
-  return asio::async_compose<CompletionToken, void(int)>(
-      impl_1_completion_arg(ioc), token);
-}
-
-void compose_1_arg_handler(int* count, int* result_out, int result)
-{
-  ++(*count);
-  *result_out = result;
-}
-
-struct compose_1_arg_lvalue_handler
-{
-  int* count_;
-  int* result_out_;
-
-  void operator()(int result)
-  {
-    ++(*count_);
-    *result_out_ = result;
-  }
-};
-
-void compose_1_completion_arg_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  int count = 0;
-  int result = 0;
-
-  async_1_completion_arg(ioc,
-      bindns::bind(&compose_1_arg_handler, &count, &result, _1));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(result == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == 42);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  compose_1_arg_lvalue_handler lvalue_handler = { &count, &result };
-  async_1_completion_arg(ioc, lvalue_handler);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(result == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == 42);
-}
-
-//------------------------------------------------------------------------------
-
-typedef asio::enable_terminal_cancellation default_filter;
-
-template <typename CancellationFilter>
-class impl_cancellable
-{
-public:
-  explicit impl_cancellable(CancellationFilter cancellation_filter,
-      asio::system_timer& timer)
-    : cancellation_filter_(cancellation_filter),
-      timer_(timer),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self,
-      const asio::error_code& ec = asio::error_code())
-  {
-    switch (state_)
-    {
-    case starting:
-      if (!asio::is_same<CancellationFilter, default_filter>::value)
-        self.reset_cancellation_state(cancellation_filter_);
-      state_ = waiting;
-      timer_.expires_after(asio::chrono::milliseconds(100));
-      timer_.async_wait(static_cast<Self&&>(self));
-      break;
-    case waiting:
-      self.complete(!ec);
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  CancellationFilter cancellation_filter_;
-  asio::system_timer& timer_;
-  enum { starting, waiting } state_;
-};
-
-template <typename CancellationFilter, typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void(bool))
-async_cancellable(CancellationFilter cancellation_filter,
-    asio::system_timer& timer,
-    CompletionToken&& token)
-{
-  return asio::async_compose<CompletionToken, void(bool)>(
-      impl_cancellable<CancellationFilter>(cancellation_filter, timer), token);
-}
-
-void compose_partial_cancellation_handler(
-    int* count, bool* result_out, bool result)
-{
-  ++(*count);
-  *result_out = result;
-}
-
-void compose_default_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(default_filter(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-void compose_partial_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-void compose_total_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "compose",
-  ASIO_TEST_CASE(compose_0_completion_args_test)
-  ASIO_TEST_CASE(compose_1_completion_arg_test)
-  ASIO_TEST_CASE(compose_default_cancellation_test)
-  ASIO_TEST_CASE(compose_partial_cancellation_test)
-  ASIO_TEST_CASE(compose_total_cancellation_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/composed.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/composed.cpp
deleted file mode 100644
index d8bfb27..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/composed.cpp
+++ /dev/null
@@ -1,530 +0,0 @@
-//
-// composed.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/composed.hpp"
-
-#include <functional>
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-class impl_0_completion_args
-{
-public:
-  explicit impl_0_completion_args(asio::io_context& ioc)
-    : ioc_(ioc),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self)
-  {
-    switch (state_)
-    {
-    case starting:
-      state_ = posting;
-      asio::post(ioc_, static_cast<Self&&>(self));
-      break;
-    case posting:
-      self.complete();
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  asio::io_context& ioc_;
-  enum { starting, posting } state_;
-};
-
-template <typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void())
-async_0_completion_args(asio::io_context& ioc,
-    CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void()>(
-      asio::composed(impl_0_completion_args(ioc)), token);
-}
-
-void compose_0_args_handler(int* count)
-{
-  ++(*count);
-}
-
-struct compose_0_args_lvalue_handler
-{
-  int* count_;
-
-  void operator()()
-  {
-    ++(*count_);
-  }
-};
-
-void compose_0_completion_args_test()
-{
-  namespace bindns = std;
-
-  asio::io_context ioc;
-  int count = 0;
-
-  async_0_completion_args(ioc, bindns::bind(&compose_0_args_handler, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  ioc.restart();
-  count = 0;
-
-  compose_0_args_lvalue_handler lvalue_handler = { &count };
-  async_0_completion_args(ioc, lvalue_handler);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-}
-
-//------------------------------------------------------------------------------
-
-class impl_1_completion_arg
-{
-public:
-  explicit impl_1_completion_arg(asio::io_context& ioc)
-    : ioc_(ioc),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self)
-  {
-    switch (state_)
-    {
-    case starting:
-      state_ = posting;
-      asio::post(ioc_, static_cast<Self&&>(self));
-      break;
-    case posting:
-      self.complete(42);
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  asio::io_context& ioc_;
-  enum { starting, posting } state_;
-};
-
-template <typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void(int))
-async_1_completion_arg(asio::io_context& ioc,
-    CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(int)>(
-      asio::composed(impl_1_completion_arg(ioc)), token);
-}
-
-void compose_1_arg_handler(int* count, int* result_out, int result)
-{
-  ++(*count);
-  *result_out = result;
-}
-
-struct compose_1_arg_lvalue_handler
-{
-  int* count_;
-  int* result_out_;
-
-  void operator()(int result)
-  {
-    ++(*count_);
-    *result_out_ = result;
-  }
-};
-
-void compose_1_completion_arg_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  int count = 0;
-  int result = 0;
-
-  async_1_completion_arg(ioc,
-      bindns::bind(&compose_1_arg_handler, &count, &result, _1));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(result == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == 42);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  compose_1_arg_lvalue_handler lvalue_handler = { &count, &result };
-  async_1_completion_arg(ioc, lvalue_handler);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(result == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == 42);
-}
-
-//------------------------------------------------------------------------------
-
-typedef asio::enable_terminal_cancellation default_filter;
-
-template <typename CancellationFilter>
-class impl_cancellable
-{
-public:
-  explicit impl_cancellable(CancellationFilter cancellation_filter,
-      asio::system_timer& timer)
-    : cancellation_filter_(cancellation_filter),
-      timer_(timer),
-      state_(starting)
-  {
-  }
-
-  template <typename Self>
-  void operator()(Self& self,
-      const asio::error_code& ec = asio::error_code())
-  {
-    switch (state_)
-    {
-    case starting:
-      if (!asio::is_same<CancellationFilter, default_filter>::value)
-        self.reset_cancellation_state(cancellation_filter_);
-      state_ = waiting;
-      timer_.expires_after(asio::chrono::milliseconds(100));
-      timer_.async_wait(static_cast<Self&&>(self));
-      break;
-    case waiting:
-      self.complete(!ec);
-      break;
-    default:
-      break;
-    }
-  }
-
-private:
-  CancellationFilter cancellation_filter_;
-  asio::system_timer& timer_;
-  enum { starting, waiting } state_;
-};
-
-template <typename CancellationFilter, typename CompletionToken>
-ASIO_INITFN_RESULT_TYPE(CompletionToken, void(bool))
-async_cancellable(CancellationFilter cancellation_filter,
-    asio::system_timer& timer,
-    CompletionToken&& token)
-{
-  return asio::async_initiate<CompletionToken, void(bool)>(
-      asio::composed<void(bool)>(
-        impl_cancellable<CancellationFilter>(cancellation_filter, timer)),
-      token);
-}
-
-void compose_partial_cancellation_handler(
-    int* count, bool* result_out, bool result)
-{
-  ++(*count);
-  *result_out = result;
-}
-
-void compose_default_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(default_filter(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(default_filter(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-void compose_partial_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation unsupported. Operation completes successfully.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_partial_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-void compose_total_cancellation_test()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-
-  asio::io_context ioc;
-  asio::system_timer timer(ioc);
-  asio::cancellation_signal signal;
-  int count = 0;
-  bool result = false;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1));
-
-  ioc.run();
-
-  // No cancellation, operation completes successfully.
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == true);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Total cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::total);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Partial cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::partial);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-
-  ioc.restart();
-  count = 0;
-  result = 0;
-
-  async_cancellable(asio::enable_total_cancellation(), timer,
-      asio::bind_cancellation_slot(signal.slot(),
-        bindns::bind(&compose_partial_cancellation_handler,
-        &count, &result, _1)));
-
-  // Terminal cancellation works. Operation completes with failure.
-  signal.emit(asio::cancellation_type::terminal);
-
-  ioc.run();
-
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(result == false);
-}
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "compose",
-  ASIO_TEST_CASE(compose_0_completion_args_test)
-  ASIO_TEST_CASE(compose_1_completion_arg_test)
-  ASIO_TEST_CASE(compose_default_cancellation_test)
-  ASIO_TEST_CASE(compose_partial_cancellation_test)
-  ASIO_TEST_CASE(compose_total_cancellation_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect.cpp
deleted file mode 100644
index 3790388..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect.cpp
+++ /dev/null
@@ -1,1209 +0,0 @@
-//
-// connect.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/connect.hpp"
-
-#include <functional>
-#include <vector>
-#include "asio/detail/thread.hpp"
-#include "asio/ip/tcp.hpp"
-#include "unit_test.hpp"
-
-namespace bindns = std;
-using bindns::placeholders::_1;
-using bindns::placeholders::_2;
-
-class connection_sink
-{
-public:
-  connection_sink()
-    : acceptor_(io_context_,
-        asio::ip::tcp::endpoint(
-          asio::ip::address_v4::loopback(), 0)),
-      target_endpoint_(acceptor_.local_endpoint()),
-      socket_(io_context_),
-      thread_(bindns::bind(&connection_sink::run, this))
-  {
-  }
-
-  ~connection_sink()
-  {
-    io_context_.stop();
-    thread_.join();
-  }
-
-  asio::ip::tcp::endpoint target_endpoint()
-  {
-    return target_endpoint_;
-  }
-
-private:
-  void run()
-  {
-    io_context_.run();
-  }
-
-  void handle_accept()
-  {
-    socket_.close();
-    acceptor_.async_accept(socket_,
-        bindns::bind(&connection_sink::handle_accept, this));
-  }
-
-  asio::io_context io_context_;
-  asio::ip::tcp::acceptor acceptor_;
-  asio::ip::tcp::endpoint target_endpoint_;
-  asio::ip::tcp::socket socket_;
-  asio::detail::thread thread_;
-};
-
-bool true_cond_1(const asio::error_code& /*ec*/,
-    const asio::ip::tcp::endpoint& /*endpoint*/)
-{
-  return true;
-}
-
-struct true_cond_2
-{
-  template <typename Endpoint>
-  bool operator()(const asio::error_code& /*ec*/,
-      const Endpoint& /*endpoint*/)
-  {
-    return true;
-  }
-};
-
-std::vector<asio::ip::tcp::endpoint>::const_iterator legacy_true_cond_1(
-    const asio::error_code& /*ec*/,
-    std::vector<asio::ip::tcp::endpoint>::const_iterator next)
-{
-  return next;
-}
-
-struct legacy_true_cond_2
-{
-  template <typename Iterator>
-  Iterator operator()(const asio::error_code& /*ec*/, Iterator next)
-  {
-    return next;
-  }
-};
-
-bool false_cond(const asio::error_code& /*ec*/,
-    const asio::ip::tcp::endpoint& /*endpoint*/)
-{
-  return false;
-}
-
-void range_handler(const asio::error_code& ec,
-    const asio::ip::tcp::endpoint& endpoint,
-    asio::error_code* out_ec,
-    asio::ip::tcp::endpoint* out_endpoint)
-{
-  *out_ec = ec;
-  *out_endpoint = endpoint;
-}
-
-void iter_handler(const asio::error_code& ec,
-    std::vector<asio::ip::tcp::endpoint>::const_iterator iter,
-    asio::error_code* out_ec,
-    std::vector<asio::ip::tcp::endpoint>::const_iterator* out_iter)
-{
-  *out_ec = ec;
-  *out_iter = iter;
-}
-
-void test_connect_range()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-
-  try
-  {
-    result = asio::connect(socket, endpoints);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints);
-  ASIO_CHECK(result == endpoints[0]);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints);
-  ASIO_CHECK(result == endpoints[0]);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, endpoints);
-  ASIO_CHECK(result == endpoints[1]);
-}
-
-void test_connect_range_ec()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-  asio::error_code ec;
-
-  result = asio::connect(socket, endpoints, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, endpoints, ec);
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-}
-
-void test_connect_range_cond()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-
-  try
-  {
-    result = asio::connect(socket, endpoints, true_cond_1);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, endpoints, true_cond_2());
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, endpoints, legacy_true_cond_1);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, endpoints, legacy_true_cond_2());
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, endpoints, false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1);
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, true_cond_2());
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1);
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2());
-  ASIO_CHECK(result == endpoints[0]);
-
-  try
-  {
-    result = asio::connect(socket, endpoints, false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1);
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, true_cond_2());
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1);
-  ASIO_CHECK(result == endpoints[0]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2());
-  ASIO_CHECK(result == endpoints[0]);
-
-  try
-  {
-    result = asio::connect(socket, endpoints, false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1);
-  ASIO_CHECK(result == endpoints[1]);
-
-  result = asio::connect(socket, endpoints, true_cond_2());
-  ASIO_CHECK(result == endpoints[1]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1);
-  ASIO_CHECK(result == endpoints[1]);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2());
-  ASIO_CHECK(result == endpoints[1]);
-
-  try
-  {
-    result = asio::connect(socket, endpoints, false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-}
-
-void test_connect_range_cond_ec()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-  asio::error_code ec;
-
-  result = asio::connect(socket, endpoints, true_cond_1, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, endpoints, true_cond_2(), ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, endpoints, false_cond, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, false_cond, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, false_cond, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, endpoints, true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_1, ec);
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, endpoints, false_cond, ec);
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-}
-
-void test_connect_iter()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(), cendpoints.end());
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-}
-
-void test_connect_iter_ec()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-  asio::error_code ec;
-
-  result = asio::connect(socket,
-      cendpoints.begin(), cendpoints.end(), ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket,
-      cendpoints.begin(), cendpoints.end(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket,
-      cendpoints.begin(), cendpoints.end(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket,
-      cendpoints.begin(), cendpoints.end(), ec);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-}
-
-void test_connect_iter_cond()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), true_cond_1);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), true_cond_2());
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), legacy_true_cond_1);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), legacy_true_cond_2());
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin());
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2());
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-
-  try
-  {
-    result = asio::connect(socket, cendpoints.begin(),
-        cendpoints.end(), false_cond);
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::not_found);
-  }
-}
-
-void test_connect_iter_cond_ec()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-  asio::error_code ec;
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), false_cond, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), false_cond, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), false_cond, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_1, ec);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), legacy_true_cond_2(), ec);
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  result = asio::connect(socket, cendpoints.begin(),
-      cendpoints.end(), false_cond, ec);
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-}
-
-void test_async_connect_range()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-  asio::error_code ec;
-
-  asio::async_connect(socket, endpoints,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, endpoints,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, endpoints,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  asio::async_connect(socket, endpoints,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints)(
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-}
-
-void test_async_connect_range_cond()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  asio::ip::tcp::endpoint result;
-  asio::error_code ec;
-
-  asio::async_connect(socket, endpoints, true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, endpoints, true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, endpoints, false_cond,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, endpoints, true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, false_cond,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, endpoints, true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[0]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, false_cond,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  asio::async_connect(socket, endpoints, true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_1,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, legacy_true_cond_2(),
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == endpoints[1]);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, endpoints, false_cond,
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, endpoints, false_cond)(
-      bindns::bind(range_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == asio::ip::tcp::endpoint());
-  ASIO_CHECK(ec == asio::error::not_found);
-}
-
-void test_async_connect_iter()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-  asio::error_code ec;
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end())(
-      bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-}
-
-void test_async_connect_iter_cond()
-{
-  connection_sink sink;
-  asio::io_context io_context;
-  asio::ip::tcp::socket socket(io_context);
-  std::vector<asio::ip::tcp::endpoint> endpoints;
-  const std::vector<asio::ip::tcp::endpoint>& cendpoints = endpoints;
-  std::vector<asio::ip::tcp::endpoint>::const_iterator result;
-  asio::error_code ec;
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.push_back(sink.target_endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin());
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  endpoints.insert(endpoints.begin(), asio::ip::tcp::endpoint());
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_1, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      legacy_true_cond_2(), bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.begin() + 1);
-  ASIO_CHECK(!ec);
-
-  asio::async_connect(socket, cendpoints.begin(), cendpoints.end(),
-      false_cond, bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-
-  asio::async_connect(socket, cendpoints.begin(),
-      cendpoints.end(), false_cond)(
-        bindns::bind(iter_handler, _1, _2, &ec, &result));
-  io_context.restart();
-  io_context.run();
-  ASIO_CHECK(result == cendpoints.end());
-  ASIO_CHECK(ec == asio::error::not_found);
-}
-
-ASIO_TEST_SUITE
-(
-  "connect",
-  ASIO_TEST_CASE(test_connect_range)
-  ASIO_TEST_CASE(test_connect_range_ec)
-  ASIO_TEST_CASE(test_connect_range_cond)
-  ASIO_TEST_CASE(test_connect_range_cond_ec)
-  ASIO_TEST_CASE(test_connect_iter)
-  ASIO_TEST_CASE(test_connect_iter_ec)
-  ASIO_TEST_CASE(test_connect_iter_cond)
-  ASIO_TEST_CASE(test_connect_iter_cond_ec)
-  ASIO_TEST_CASE(test_async_connect_range)
-  ASIO_TEST_CASE(test_async_connect_range_cond)
-  ASIO_TEST_CASE(test_async_connect_iter)
-  ASIO_TEST_CASE(test_async_connect_iter_cond)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect_pipe.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect_pipe.cpp
deleted file mode 100644
index 8c71a5d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/connect_pipe.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-//
-// connect_pipe.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/connect_pipe.hpp"
-
-#include <functional>
-#include <string>
-#include "asio/io_context.hpp"
-#include "asio/read.hpp"
-#include "asio/readable_pipe.hpp"
-#include "asio/writable_pipe.hpp"
-#include "asio/write.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// connect_pipe_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all connect_pipe functions compile and link
-// correctly. Runtime failures are ignored.
-
-namespace connect_pipe_compile {
-
-void test()
-{
-#if defined(ASIO_HAS_PIPE)
-  using namespace asio;
-
-  try
-  {
-    asio::io_context io_context;
-    asio::error_code ec1;
-
-    readable_pipe p1(io_context);
-    writable_pipe p2(io_context);
-    connect_pipe(p1, p2);
-
-    readable_pipe p3(io_context);
-    writable_pipe p4(io_context);
-    connect_pipe(p3, p4, ec1);
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_PIPE)
-}
-
-} // namespace connect_pipe_compile
-
-//------------------------------------------------------------------------------
-
-// connect_pipe_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that connect_pipe operates correctly at runtime.
-
-namespace connect_pipe_runtime {
-
-static const char write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void handle_read(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-}
-
-void handle_write(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-}
-
-void test()
-{
-#if defined(ASIO_HAS_PIPE)
-  using namespace std; // For memcmp.
-  using namespace asio;
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  try
-  {
-    asio::io_context io_context;
-    asio::error_code ec1;
-    asio::error_code ec2;
-
-    readable_pipe p1(io_context);
-    writable_pipe p2(io_context);
-    connect_pipe(p1, p2);
-
-    std::string data1 = write_data;
-    asio::write(p2, asio::buffer(data1));
-
-    std::string data2;
-    data2.resize(data1.size());
-    asio::read(p1, asio::buffer(data2));
-
-    ASIO_CHECK(data1 == data2);
-
-    char read_buffer[sizeof(write_data)];
-    bool read_completed = false;
-    asio::async_read(p1,
-        asio::buffer(read_buffer),
-        bindns::bind(handle_read,
-          _1, _2, &read_completed));
-
-    bool write_completed = false;
-    asio::async_write(p2,
-        asio::buffer(write_data),
-        bindns::bind(handle_write,
-          _1, _2, &write_completed));
-
-    io_context.run();
-
-    ASIO_CHECK(read_completed);
-    ASIO_CHECK(write_completed);
-    ASIO_CHECK(memcmp(read_buffer, write_data, sizeof(write_data)) == 0);
-  }
-  catch (std::exception&)
-  {
-    ASIO_CHECK(false);
-  }
-#endif // defined(ASIO_HAS_PIPE)
-}
-
-} // namespace connect_pipe_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "connect_pipe",
-  ASIO_COMPILE_TEST_CASE(connect_pipe_compile::test)
-  ASIO_TEST_CASE(connect_pipe_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/consign.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/consign.cpp
deleted file mode 100644
index b24f528..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/consign.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//
-// consign.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/consign.hpp"
-
-#include "asio/bind_executor.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "unit_test.hpp"
-
-void consign_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(
-      asio::consign(
-        asio::bind_executor(io2.get_executor(),
-          [&count](asio::error_code)
-          {
-            ++count;
-          }), 123, 321));
-
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "consign",
-  ASIO_TEST_CASE(consign_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/coroutine.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/coroutine.cpp
deleted file mode 100644
index 72e6953..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/coroutine.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// coroutine.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/coroutine.hpp"
-
-#include "unit_test.hpp"
-
-// Must come after all other headers.
-#include "asio/yield.hpp"
-
-//------------------------------------------------------------------------------
-
-// Coroutine completes via yield break.
-
-void yield_break_coro(asio::coroutine& coro)
-{
-  reenter (coro)
-  {
-    yield return;
-    yield break;
-  }
-}
-
-void yield_break_test()
-{
-  asio::coroutine coro;
-  ASIO_CHECK(!coro.is_complete());
-  yield_break_coro(coro);
-  ASIO_CHECK(!coro.is_complete());
-  yield_break_coro(coro);
-  ASIO_CHECK(coro.is_complete());
-}
-
-//------------------------------------------------------------------------------
-
-// Coroutine completes via return.
-
-void return_coro(asio::coroutine& coro)
-{
-  reenter (coro)
-  {
-    return;
-  }
-}
-
-void return_test()
-{
-  asio::coroutine coro;
-  return_coro(coro);
-  ASIO_CHECK(coro.is_complete());
-}
-
-//------------------------------------------------------------------------------
-
-// Coroutine completes via exception.
-
-void exception_coro(asio::coroutine& coro)
-{
-  reenter (coro)
-  {
-    throw 1;
-  }
-}
-
-void exception_test()
-{
-  asio::coroutine coro;
-  try { exception_coro(coro); } catch (int) {}
-  ASIO_CHECK(coro.is_complete());
-}
-
-//------------------------------------------------------------------------------
-
-// Coroutine completes by falling off the end.
-
-void fall_off_end_coro(asio::coroutine& coro)
-{
-  reenter (coro)
-  {
-  }
-}
-
-void fall_off_end_test()
-{
-  asio::coroutine coro;
-  fall_off_end_coro(coro);
-  ASIO_CHECK(coro.is_complete());
-}
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "coroutine",
-  ASIO_TEST_CASE(yield_break_test)
-  ASIO_TEST_CASE(return_test)
-  ASIO_TEST_CASE(exception_test)
-  ASIO_TEST_CASE(fall_off_end_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deadline_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deadline_timer.cpp
deleted file mode 100644
index 9bc7f16..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deadline_timer.cpp
+++ /dev/null
@@ -1,444 +0,0 @@
-//
-// deadline_timer.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/deadline_timer.hpp"
-
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-
-#include <boost/bind/bind.hpp>
-#include "archetypes/async_result.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/io_context.hpp"
-#include "asio/placeholders.hpp"
-#include "asio/thread.hpp"
-
-using namespace boost::posix_time;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void decrement_to_zero(asio::deadline_timer* t, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    int before_value = *count;
-
-    t->expires_at(t->expires_at() + seconds(1));
-    t->async_wait(boost::bind(decrement_to_zero, t, count));
-
-    // Completion cannot nest, so count value should remain unchanged.
-    ASIO_CHECK(*count == before_value);
-  }
-}
-
-void increment_if_not_cancelled(int* count,
-    const asio::error_code& ec)
-{
-  if (!ec)
-    ++(*count);
-}
-
-void cancel_timer(asio::deadline_timer* t)
-{
-  std::size_t num_cancelled = t->cancel();
-  ASIO_CHECK(num_cancelled == 1);
-}
-
-void cancel_one_timer(asio::deadline_timer* t)
-{
-  std::size_t num_cancelled = t->cancel_one();
-  ASIO_CHECK(num_cancelled == 1);
-}
-
-ptime now()
-{
-#if defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-  return microsec_clock::universal_time();
-#else // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-  return second_clock::universal_time();
-#endif // defined(BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK)
-}
-
-void deadline_timer_test()
-{
-  asio::io_context ioc;
-  int count = 0;
-
-  ptime start = now();
-
-  asio::deadline_timer t1(ioc, seconds(1));
-  t1.wait();
-
-  // The timer must block until after its expiry time.
-  ptime end = now();
-  ptime expected_end = start + seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  asio::deadline_timer t2(ioc, seconds(1) + microseconds(500000));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end = start + seconds(1) + microseconds(500000);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  t2.expires_at(t2.expires_at() + seconds(1));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end += seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  t2.expires_from_now(seconds(1) + microseconds(200000));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end = start + seconds(1) + microseconds(200000);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  asio::deadline_timer t3(ioc, seconds(5));
-  t3.async_wait(boost::bind(increment, &count));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all operations have finished, and
-  // this should not be until after the timer's expiry time.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 3;
-  start = now();
-
-  asio::deadline_timer t4(ioc, seconds(1));
-  t4.async_wait(boost::bind(decrement_to_zero, &t4, &count));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 3);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() call will not return until all operations have finished, and
-  // this should not be until after the timer's final expiry time.
-  ASIO_CHECK(count == 0);
-  end = now();
-  expected_end = start + seconds(3);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 0;
-  start = now();
-
-  asio::deadline_timer t5(ioc, seconds(10));
-  t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
-        asio::placeholders::error));
-  asio::deadline_timer t6(ioc, seconds(1));
-  t6.async_wait(boost::bind(cancel_timer, &t5));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The timer should have been cancelled, so count should not have changed.
-  // The total run time should not have been much more than 1 second (and
-  // certainly far less than 10 seconds).
-  ASIO_CHECK(count == 0);
-  end = now();
-  expected_end = start + seconds(2);
-  ASIO_CHECK(end < expected_end);
-
-  // Wait on the timer again without cancelling it. This time the asynchronous
-  // wait should run to completion and increment the counter.
-  t5.async_wait(boost::bind(increment_if_not_cancelled, &count,
-        asio::placeholders::error));
-
-  ioc.restart();
-  ioc.run();
-
-  // The timer should not have been cancelled, so count should have changed.
-  // The total time since the timer was created should be more than 10 seconds.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(10);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 0;
-  start = now();
-
-  // Start two waits on a timer, one of which will be cancelled. The one
-  // which is not cancelled should still run to completion and increment the
-  // counter.
-  asio::deadline_timer t7(ioc, seconds(3));
-  t7.async_wait(boost::bind(increment_if_not_cancelled, &count,
-        asio::placeholders::error));
-  t7.async_wait(boost::bind(increment_if_not_cancelled, &count,
-        asio::placeholders::error));
-  asio::deadline_timer t8(ioc, seconds(1));
-  t8.async_wait(boost::bind(cancel_one_timer, &t7));
-
-  ioc.restart();
-  ioc.run();
-
-  // One of the waits should not have been cancelled, so count should have
-  // changed. The total time since the timer was created should be more than 3
-  // seconds.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(3);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-}
-
-void timer_handler(const asio::error_code&)
-{
-}
-
-void deadline_timer_cancel_test()
-{
-  static asio::io_context io_context;
-  struct timer
-  {
-    asio::deadline_timer t;
-    timer() : t(io_context) { t.expires_at(boost::posix_time::pos_infin); }
-  } timers[50];
-
-  timers[2].t.async_wait(&timer_handler);
-  timers[41].t.async_wait(&timer_handler);
-  for (int i = 10; i < 20; ++i)
-    timers[i].t.async_wait(&timer_handler);
-
-  ASIO_CHECK(timers[2].t.cancel() == 1);
-  ASIO_CHECK(timers[41].t.cancel() == 1);
-  for (int i = 10; i < 20; ++i)
-    ASIO_CHECK(timers[i].t.cancel() == 1);
-}
-
-struct custom_allocation_timer_handler
-{
-  custom_allocation_timer_handler(int* count) : count_(count) {}
-  void operator()(const asio::error_code&) {}
-  int* count_;
-
-  template <typename T>
-  struct allocator
-  {
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef T value_type;
-
-    template <typename U>
-    struct rebind
-    {
-      typedef allocator<U> other;
-    };
-
-    explicit allocator(int* count) noexcept
-      : count_(count)
-    {
-    }
-
-    allocator(const allocator& other) noexcept
-      : count_(other.count_)
-    {
-    }
-
-    template <typename U>
-    allocator(const allocator<U>& other) noexcept
-      : count_(other.count_)
-    {
-    }
-
-    pointer allocate(size_type n, const void* = 0)
-    {
-      ++(*count_);
-      return static_cast<T*>(::operator new(sizeof(T) * n));
-    }
-
-    void deallocate(pointer p, size_type)
-    {
-      --(*count_);
-      ::operator delete(p);
-    }
-
-    size_type max_size() const
-    {
-      return ~size_type(0);
-    }
-
-    void construct(pointer p, const T& v)
-    {
-      new (p) T(v);
-    }
-
-    void destroy(pointer p)
-    {
-      p->~T();
-    }
-
-    int* count_;
-  };
-
-  typedef allocator<int> allocator_type;
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_type(count_);
-  }
-};
-
-void deadline_timer_custom_allocation_test()
-{
-  static asio::io_context io_context;
-  struct timer
-  {
-    asio::deadline_timer t;
-    timer() : t(io_context) {}
-  } timers[100];
-
-  int allocation_count = 0;
-
-  for (int i = 0; i < 50; ++i)
-  {
-    timers[i].t.expires_at(boost::posix_time::pos_infin);
-    timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
-  }
-
-  for (int i = 50; i < 100; ++i)
-  {
-    timers[i].t.expires_at(boost::posix_time::neg_infin);
-    timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
-  }
-
-  for (int i = 0; i < 50; ++i)
-    timers[i].t.cancel();
-
-  io_context.run();
-
-  ASIO_CHECK(allocation_count == 0);
-}
-
-void io_context_run(asio::io_context* ioc)
-{
-  ioc->run();
-}
-
-void deadline_timer_thread_test()
-{
-  asio::io_context ioc;
-  asio::executor_work_guard<asio::io_context::executor_type> work
-    = asio::make_work_guard(ioc);
-  asio::deadline_timer t1(ioc);
-  asio::deadline_timer t2(ioc);
-  int count = 0;
-
-  asio::thread th(boost::bind(io_context_run, &ioc));
-
-  t2.expires_from_now(boost::posix_time::seconds(2));
-  t2.wait();
-
-  t1.expires_from_now(boost::posix_time::seconds(2));
-  t1.async_wait(boost::bind(increment, &count));
-
-  t2.expires_from_now(boost::posix_time::seconds(4));
-  t2.wait();
-
-  ioc.stop();
-  th.join();
-
-  ASIO_CHECK(count == 1);
-}
-
-void deadline_timer_async_result_test()
-{
-  asio::io_context ioc;
-  asio::deadline_timer t1(ioc);
-
-  t1.expires_from_now(boost::posix_time::seconds(1));
-  int i = t1.async_wait(archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-
-  ioc.run();
-}
-
-asio::deadline_timer make_timer(asio::io_context& ioc, int* count)
-{
-  asio::deadline_timer t(ioc);
-  t.expires_from_now(boost::posix_time::seconds(1));
-  t.async_wait(boost::bind(increment, count));
-  return t;
-}
-
-void deadline_timer_move_test()
-{
-  asio::io_context io_context1;
-  asio::io_context io_context2;
-  int count = 0;
-
-  asio::deadline_timer t1 = make_timer(io_context1, &count);
-  asio::deadline_timer t2 = make_timer(io_context2, &count);
-  asio::deadline_timer t3 = std::move(t1);
-
-  t2 = std::move(t1);
-
-  io_context2.run();
-
-  ASIO_CHECK(count == 1);
-
-  io_context1.run();
-
-  ASIO_CHECK(count == 2);
-}
-
-ASIO_TEST_SUITE
-(
-  "deadline_timer",
-  ASIO_TEST_CASE(deadline_timer_test)
-  ASIO_TEST_CASE(deadline_timer_cancel_test)
-  ASIO_TEST_CASE(deadline_timer_custom_allocation_test)
-  ASIO_TEST_CASE(deadline_timer_thread_test)
-  ASIO_TEST_CASE(deadline_timer_async_result_test)
-  ASIO_TEST_CASE(deadline_timer_move_test)
-)
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-ASIO_TEST_SUITE
-(
-  "deadline_timer",
-  ASIO_TEST_CASE(null_test)
-)
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/defer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/defer.cpp
deleted file mode 100644
index f41c1b9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/defer.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// defer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/defer.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "defer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deferred.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deferred.cpp
deleted file mode 100644
index b2db70d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/deferred.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// deferred.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/deferred.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/deferred",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/detached.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/detached.cpp
deleted file mode 100644
index 506c13d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/detached.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// detached.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/detached.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "detached",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/dispatch.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/dispatch.cpp
deleted file mode 100644
index f6fb84d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/dispatch.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// dispatch.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/dispatch.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "dispatch",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/error.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/error.cpp
deleted file mode 100644
index 3f8aa75..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/error.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// error.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/error.hpp"
-
-#include <sstream>
-#include "unit_test.hpp"
-
-void test_error_code(const asio::error_code& code)
-{
-  asio::error_code error(code);
-  ASIO_CHECK(code == error);
-
-  ASIO_CHECK(!code || error);
-  ASIO_CHECK(!code || !!error);
-
-  asio::error_code error2(error);
-  ASIO_CHECK(error == error2);
-  ASIO_CHECK(!(error != error2));
-
-  asio::error_code error3;
-  error3 = error;
-  ASIO_CHECK(error == error3);
-  ASIO_CHECK(!(error != error3));
-
-  std::ostringstream os;
-  os << error;
-  ASIO_CHECK(!os.str().empty());
-}
-
-void error_test()
-{
-  test_error_code(asio::error::access_denied);
-  test_error_code(asio::error::address_family_not_supported);
-  test_error_code(asio::error::address_in_use);
-  test_error_code(asio::error::already_connected);
-  test_error_code(asio::error::already_started);
-  test_error_code(asio::error::connection_aborted);
-  test_error_code(asio::error::connection_refused);
-  test_error_code(asio::error::connection_reset);
-  test_error_code(asio::error::bad_descriptor);
-  test_error_code(asio::error::eof);
-  test_error_code(asio::error::fault);
-  test_error_code(asio::error::host_not_found);
-  test_error_code(asio::error::host_not_found_try_again);
-  test_error_code(asio::error::host_unreachable);
-  test_error_code(asio::error::in_progress);
-  test_error_code(asio::error::interrupted);
-  test_error_code(asio::error::invalid_argument);
-  test_error_code(asio::error::message_size);
-  test_error_code(asio::error::network_down);
-  test_error_code(asio::error::network_reset);
-  test_error_code(asio::error::network_unreachable);
-  test_error_code(asio::error::no_descriptors);
-  test_error_code(asio::error::no_buffer_space);
-  test_error_code(asio::error::no_data);
-  test_error_code(asio::error::no_memory);
-  test_error_code(asio::error::no_permission);
-  test_error_code(asio::error::no_protocol_option);
-  test_error_code(asio::error::no_recovery);
-  test_error_code(asio::error::not_connected);
-  test_error_code(asio::error::not_socket);
-  test_error_code(asio::error::operation_aborted);
-  test_error_code(asio::error::operation_not_supported);
-  test_error_code(asio::error::service_not_found);
-  test_error_code(asio::error::shut_down);
-  test_error_code(asio::error::timed_out);
-  test_error_code(asio::error::try_again);
-  test_error_code(asio::error::would_block);
-}
-
-ASIO_TEST_SUITE
-(
-  "error",
-  ASIO_TEST_CASE(error_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/.gitignore
deleted file mode 100644
index 2176794..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/.gitignore
+++ /dev/null
@@ -1,19 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-any_executor
-blocking
-blocking_adaptation
-context_as
-executor
-invocable_archetype
-mapping
-outstanding_work
-prefer_only
-relationship
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/any_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/any_executor.cpp
deleted file mode 100644
index 3e2dabd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/any_executor.cpp
+++ /dev/null
@@ -1,1202 +0,0 @@
-//
-// any_executor.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/any_executor.hpp"
-
-#include <cstring>
-#include <functional>
-#include "asio/thread_pool.hpp"
-#include "../unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-static bool next_nothrow_new_fails = false;
-
-void* operator new(std::size_t n,
-    const std::nothrow_t&) noexcept
-{
-  if (next_nothrow_new_fails)
-  {
-    next_nothrow_new_fails = false;
-    return 0;
-  }
-  return ::operator new(n);
-}
-
-struct fat_executor
-{
-  fat_executor(int id)
-    : id_(id)
-  {
-    std::memset(data_, 0, sizeof(data_));
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  std::size_t query(execution::occupancy_t) const
-  {
-    return 1;
-  }
-
-  friend bool operator==(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ == b.id_;
-  }
-
-  friend bool operator!=(const fat_executor& a,
-      const fat_executor& b) noexcept
-  {
-    return a.id_ != b.id_;
-  }
-
-  int id_;
-  unsigned char data_[1024];
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<fat_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <>
-struct query_member<fat_executor, execution::occupancy_t>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-  typedef std::size_t result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<fat_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void any_executor_construction_test()
-{
-  typedef execution::any_executor<> ex_no_props_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t
-    > ex_one_prop_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::occupancy_t
-    > ex_two_props_t;
-
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  ex_two_props_t ex_two_props_1;
-
-  ASIO_CHECK(ex_two_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_1 == null_ptr);
-
-  ex_two_props_t ex_two_props_2(null_ptr);
-
-  ASIO_CHECK(ex_two_props_2.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_2 == null_ptr);
-  ASIO_CHECK(ex_two_props_2 == ex_two_props_1);
-
-  ex_two_props_t ex_two_props_3(pool.executor());
-
-  ASIO_CHECK(ex_two_props_3.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_3 != null_ptr);
-  ASIO_CHECK(ex_two_props_3 != ex_two_props_1);
-
-  ex_two_props_t ex_two_props_4(ex_two_props_1);
-
-  ASIO_CHECK(ex_two_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_4 == null_ptr);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_1);
-
-  ex_two_props_t ex_two_props_5(ex_two_props_3);
-
-  ASIO_CHECK(ex_two_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_5 != null_ptr);
-  ASIO_CHECK(ex_two_props_5 == ex_two_props_3);
-
-  ex_two_props_t ex_two_props_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_two_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_6 != null_ptr);
-  ASIO_CHECK(ex_two_props_6 != ex_two_props_1);
-
-  ex_two_props_t ex_two_props_7 = fat_executor(1);
-
-  ASIO_CHECK(ex_two_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_7 != null_ptr);
-  ASIO_CHECK(ex_two_props_7 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_7 == ex_two_props_6);
-
-  ex_two_props_t ex_two_props_8 = fat_executor(2);
-
-  ASIO_CHECK(ex_two_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_8 != null_ptr);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_6);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_7);
-
-  ex_two_props_t ex_two_props_9(ex_two_props_6);
-
-  ASIO_CHECK(ex_two_props_9.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_9 != null_ptr);
-  ASIO_CHECK(ex_two_props_9 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_9 == ex_two_props_6);
-  ASIO_CHECK(ex_two_props_9 == ex_two_props_7);
-  ASIO_CHECK(ex_two_props_9 != ex_two_props_8);
-
-  ex_two_props_t ex_two_props_10(std::move(ex_two_props_1));
-
-  ASIO_CHECK(ex_two_props_10.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_10 == null_ptr);
-  ASIO_CHECK(ex_two_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_1 == null_ptr);
-
-  ex_two_props_t ex_two_props_11(std::move(ex_two_props_3));
-
-  ASIO_CHECK(ex_two_props_11.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_11 != null_ptr);
-  ASIO_CHECK(ex_two_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_3 == null_ptr);
-  ASIO_CHECK(ex_two_props_11 == ex_two_props_5);
-
-  ex_two_props_t ex_two_props_12(std::move(ex_two_props_7));
-
-  ASIO_CHECK(ex_two_props_12.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_12 != null_ptr);
-  ASIO_CHECK(ex_two_props_7.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_7 == null_ptr);
-  ASIO_CHECK(ex_two_props_12 == ex_two_props_6);
-  ASIO_CHECK(ex_two_props_12 != ex_two_props_8);
-
-  ex_one_prop_t ex_one_prop_1;
-
-  ASIO_CHECK(ex_one_prop_1.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_1 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_2(null_ptr);
-
-  ASIO_CHECK(ex_one_prop_2.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_2 == null_ptr);
-  ASIO_CHECK(ex_one_prop_2 == ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_3(pool.executor());
-
-  ASIO_CHECK(ex_one_prop_3.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_3 != null_ptr);
-  ASIO_CHECK(ex_one_prop_3 != ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_4(ex_one_prop_1);
-
-  ASIO_CHECK(ex_one_prop_4.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_4 == null_ptr);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_5(ex_one_prop_3);
-
-  ASIO_CHECK(ex_one_prop_5.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_5 != null_ptr);
-  ASIO_CHECK(ex_one_prop_5 == ex_one_prop_3);
-
-  ex_one_prop_t ex_one_prop_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_one_prop_6.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_6 != null_ptr);
-  ASIO_CHECK(ex_one_prop_6 != ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_7 = fat_executor(1);
-
-  ASIO_CHECK(ex_one_prop_7.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_7 != null_ptr);
-  ASIO_CHECK(ex_one_prop_7 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_7 == ex_one_prop_6);
-
-  ex_one_prop_t ex_one_prop_8 = fat_executor(2);
-
-  ASIO_CHECK(ex_one_prop_8.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_8 != null_ptr);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_7);
-
-  ex_one_prop_t ex_one_prop_9(ex_one_prop_6);
-
-  ASIO_CHECK(ex_one_prop_9.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_9 != null_ptr);
-  ASIO_CHECK(ex_one_prop_9 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_9 == ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_9 == ex_one_prop_7);
-  ASIO_CHECK(ex_one_prop_9 != ex_one_prop_8);
-
-  ex_one_prop_t ex_one_prop_10(std::move(ex_one_prop_1));
-
-  ASIO_CHECK(ex_one_prop_10.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_10 == null_ptr);
-  ASIO_CHECK(ex_one_prop_1.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_1 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_11(std::move(ex_one_prop_3));
-
-  ASIO_CHECK(ex_one_prop_11.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_11 != null_ptr);
-  ASIO_CHECK(ex_one_prop_3.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_3 == null_ptr);
-  ASIO_CHECK(ex_one_prop_11 == ex_one_prop_5);
-
-  ex_one_prop_t ex_one_prop_12(std::move(ex_one_prop_7));
-
-  ASIO_CHECK(ex_one_prop_12.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_12 != null_ptr);
-  ASIO_CHECK(ex_one_prop_7.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_7 == null_ptr);
-  ASIO_CHECK(ex_one_prop_12 == ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_12 != ex_one_prop_8);
-
-  ex_one_prop_t ex_one_prop_13(ex_two_props_1);
-
-  ASIO_CHECK(ex_one_prop_13.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_13 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_14(ex_two_props_5);
-
-  ASIO_CHECK(ex_one_prop_14.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_14 != null_ptr);
-
-  ex_one_prop_t ex_one_prop_15(ex_two_props_9);
-
-  ASIO_CHECK(ex_one_prop_15.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_15 != null_ptr);
-
-  ex_no_props_t ex_no_props_1;
-
-  ASIO_CHECK(ex_no_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_1 == null_ptr);
-
-  ex_no_props_t ex_no_props_2(null_ptr);
-
-  ASIO_CHECK(ex_no_props_2.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_2 == null_ptr);
-  ASIO_CHECK(ex_no_props_2 == ex_no_props_1);
-
-  ex_no_props_t ex_no_props_3(pool.executor());
-
-  ASIO_CHECK(ex_no_props_3.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_3 != null_ptr);
-  ASIO_CHECK(ex_no_props_3 != ex_no_props_1);
-
-  ex_no_props_t ex_no_props_4(ex_no_props_1);
-
-  ASIO_CHECK(ex_no_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_4 == null_ptr);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_1);
-
-  ex_no_props_t ex_no_props_5(ex_no_props_3);
-
-  ASIO_CHECK(ex_no_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_5 != null_ptr);
-  ASIO_CHECK(ex_no_props_5 == ex_no_props_3);
-
-  ex_no_props_t ex_no_props_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_no_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_6 != null_ptr);
-  ASIO_CHECK(ex_no_props_6 != ex_no_props_1);
-
-  ex_no_props_t ex_no_props_7 = fat_executor(1);
-
-  ASIO_CHECK(ex_no_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_7 != null_ptr);
-  ASIO_CHECK(ex_no_props_7 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_7 == ex_no_props_6);
-
-  ex_no_props_t ex_no_props_8 = fat_executor(2);
-
-  ASIO_CHECK(ex_no_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_8 != null_ptr);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_6);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_7);
-
-  ex_no_props_t ex_no_props_9(ex_no_props_6);
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_9 != null_ptr);
-  ASIO_CHECK(ex_no_props_9 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_9 == ex_no_props_6);
-  ASIO_CHECK(ex_no_props_9 == ex_no_props_7);
-  ASIO_CHECK(ex_no_props_9 != ex_no_props_8);
-
-  ex_no_props_t ex_no_props_10(std::move(ex_no_props_1));
-
-  ASIO_CHECK(ex_no_props_10.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_10 == null_ptr);
-  ASIO_CHECK(ex_no_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_1 == null_ptr);
-
-  ex_no_props_t ex_no_props_11(std::move(ex_no_props_3));
-
-  ASIO_CHECK(ex_no_props_11.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_11 != null_ptr);
-  ASIO_CHECK(ex_no_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_3 == null_ptr);
-  ASIO_CHECK(ex_no_props_11 == ex_no_props_5);
-
-  ex_no_props_t ex_no_props_12(std::move(ex_no_props_7));
-
-  ASIO_CHECK(ex_no_props_12.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_12 != null_ptr);
-  ASIO_CHECK(ex_no_props_7.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_7 == null_ptr);
-  ASIO_CHECK(ex_no_props_12 == ex_no_props_6);
-  ASIO_CHECK(ex_no_props_12 != ex_no_props_8);
-
-  ex_no_props_t ex_no_props_13(ex_two_props_1);
-
-  ASIO_CHECK(ex_no_props_13.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_13 == null_ptr);
-
-  ex_no_props_t ex_no_props_14(ex_two_props_5);
-
-  ASIO_CHECK(ex_no_props_14.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_14 != null_ptr);
-
-  ex_no_props_t ex_no_props_15(ex_two_props_9);
-
-  ASIO_CHECK(ex_no_props_15.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_15 != null_ptr);
-
-  ex_no_props_t ex_no_props_16(ex_one_prop_1);
-
-  ASIO_CHECK(ex_no_props_16.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_16 == null_ptr);
-
-  ex_no_props_t ex_no_props_17(ex_one_prop_5);
-
-  ASIO_CHECK(ex_no_props_17.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_17 != null_ptr);
-
-  ex_no_props_t ex_no_props_18(ex_one_prop_9);
-
-  ASIO_CHECK(ex_no_props_18.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_18 != null_ptr);
-}
-
-void any_executor_nothrow_construction_test()
-{
-  typedef execution::any_executor<> ex_no_props_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t
-    > ex_one_prop_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::occupancy_t
-    > ex_two_props_t;
-
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  ex_two_props_t ex_two_props_1;
-
-  ASIO_CHECK(ex_two_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_1 == null_ptr);
-
-  ex_two_props_t ex_two_props_2(null_ptr);
-
-  ASIO_CHECK(ex_two_props_2.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_2 == null_ptr);
-  ASIO_CHECK(ex_two_props_2 == ex_two_props_1);
-
-  ex_two_props_t ex_two_props_3(std::nothrow, pool.executor());
-
-  ASIO_CHECK(ex_two_props_3.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_3 != null_ptr);
-  ASIO_CHECK(ex_two_props_3 != ex_two_props_1);
-
-  ex_two_props_t ex_two_props_4(std::nothrow, ex_two_props_1);
-
-  ASIO_CHECK(ex_two_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_4 == null_ptr);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_1);
-
-  ex_two_props_t ex_two_props_5(std::nothrow, ex_two_props_3);
-
-  ASIO_CHECK(ex_two_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_5 != null_ptr);
-  ASIO_CHECK(ex_two_props_5 == ex_two_props_3);
-
-  ex_two_props_t ex_two_props_6(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex_two_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_6 != null_ptr);
-  ASIO_CHECK(ex_two_props_6 != ex_two_props_1);
-
-  ex_two_props_t ex_two_props_7(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex_two_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_7 != null_ptr);
-  ASIO_CHECK(ex_two_props_7 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_7 == ex_two_props_6);
-
-  ex_two_props_t ex_two_props_8(std::nothrow, fat_executor(2));
-
-  ASIO_CHECK(ex_two_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_8 != null_ptr);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_6);
-  ASIO_CHECK(ex_two_props_8 != ex_two_props_7);
-
-  ex_two_props_t ex_two_props_9(std::nothrow, ex_two_props_6);
-
-  ASIO_CHECK(ex_two_props_9.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_9 != null_ptr);
-  ASIO_CHECK(ex_two_props_9 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_9 == ex_two_props_6);
-  ASIO_CHECK(ex_two_props_9 == ex_two_props_7);
-  ASIO_CHECK(ex_two_props_9 != ex_two_props_8);
-
-  ex_two_props_t ex_two_props_10(std::nothrow, std::move(ex_two_props_1));
-
-  ASIO_CHECK(ex_two_props_10.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_10 == null_ptr);
-  ASIO_CHECK(ex_two_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_1 == null_ptr);
-
-  ex_two_props_t ex_two_props_11(std::nothrow, std::move(ex_two_props_3));
-
-  ASIO_CHECK(ex_two_props_11.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_11 != null_ptr);
-  ASIO_CHECK(ex_two_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_3 == null_ptr);
-  ASIO_CHECK(ex_two_props_11 == ex_two_props_5);
-
-  ex_two_props_t ex_two_props_12(std::nothrow, std::move(ex_two_props_7));
-
-  ASIO_CHECK(ex_two_props_12.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_12 != null_ptr);
-  ASIO_CHECK(ex_two_props_7.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_7 == null_ptr);
-  ASIO_CHECK(ex_two_props_12 == ex_two_props_6);
-  ASIO_CHECK(ex_two_props_12 != ex_two_props_8);
-
-  next_nothrow_new_fails = true;
-  ex_two_props_t ex_two_props_13(std::nothrow, fat_executor(3));
-
-  ASIO_CHECK(ex_two_props_13.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_13 == null_ptr);
-  ASIO_CHECK(ex_two_props_13 == ex_two_props_1);
-
-  ex_one_prop_t ex_one_prop_1;
-
-  ASIO_CHECK(ex_one_prop_1.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_1 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_2(null_ptr);
-
-  ASIO_CHECK(ex_one_prop_2.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_2 == null_ptr);
-  ASIO_CHECK(ex_one_prop_2 == ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_3(std::nothrow, pool.executor());
-
-  ASIO_CHECK(ex_one_prop_3.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_3 != null_ptr);
-  ASIO_CHECK(ex_one_prop_3 != ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_4(std::nothrow, ex_one_prop_1);
-
-  ASIO_CHECK(ex_one_prop_4.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_4 == null_ptr);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_5(std::nothrow, ex_one_prop_3);
-
-  ASIO_CHECK(ex_one_prop_5.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_5 != null_ptr);
-  ASIO_CHECK(ex_one_prop_5 == ex_one_prop_3);
-
-  ex_one_prop_t ex_one_prop_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_one_prop_6.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_6 != null_ptr);
-  ASIO_CHECK(ex_one_prop_6 != ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_7(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex_one_prop_7.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_7 != null_ptr);
-  ASIO_CHECK(ex_one_prop_7 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_7 == ex_one_prop_6);
-
-  ex_one_prop_t ex_one_prop_8(std::nothrow, fat_executor(2));
-
-  ASIO_CHECK(ex_one_prop_8.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_8 != null_ptr);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_8 != ex_one_prop_7);
-
-  ex_one_prop_t ex_one_prop_9(std::nothrow, ex_one_prop_6);
-
-  ASIO_CHECK(ex_one_prop_9.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_9 != null_ptr);
-  ASIO_CHECK(ex_one_prop_9 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_9 == ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_9 == ex_one_prop_7);
-  ASIO_CHECK(ex_one_prop_9 != ex_one_prop_8);
-
-  ex_one_prop_t ex_one_prop_10(std::nothrow, std::move(ex_one_prop_1));
-
-  ASIO_CHECK(ex_one_prop_10.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_10 == null_ptr);
-  ASIO_CHECK(ex_one_prop_1.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_1 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_11(std::nothrow, std::move(ex_one_prop_3));
-
-  ASIO_CHECK(ex_one_prop_11.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_11 != null_ptr);
-  ASIO_CHECK(ex_one_prop_3.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_3 == null_ptr);
-  ASIO_CHECK(ex_one_prop_11 == ex_one_prop_5);
-
-  ex_one_prop_t ex_one_prop_12(std::nothrow, std::move(ex_one_prop_7));
-
-  ASIO_CHECK(ex_one_prop_12.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_12 != null_ptr);
-  ASIO_CHECK(ex_one_prop_7.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_7 == null_ptr);
-  ASIO_CHECK(ex_one_prop_12 == ex_one_prop_6);
-  ASIO_CHECK(ex_one_prop_12 != ex_one_prop_8);
-
-  ex_one_prop_t ex_one_prop_13(std::nothrow, ex_two_props_1);
-
-  ASIO_CHECK(ex_one_prop_13.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_13 == null_ptr);
-
-  ex_one_prop_t ex_one_prop_14(std::nothrow, ex_two_props_5);
-
-  ASIO_CHECK(ex_one_prop_14.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_14 != null_ptr);
-
-  ex_one_prop_t ex_one_prop_15(std::nothrow, ex_two_props_9);
-
-  ASIO_CHECK(ex_one_prop_15.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_15 != null_ptr);
-
-  next_nothrow_new_fails = true;
-  ex_one_prop_t ex_one_prop_16(std::nothrow, fat_executor(3));
-
-  ASIO_CHECK(ex_one_prop_16.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_16 == null_ptr);
-  ASIO_CHECK(ex_one_prop_16 == ex_one_prop_1);
-
-  ex_no_props_t ex_no_props_1;
-
-  ASIO_CHECK(ex_no_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_1 == null_ptr);
-
-  ex_no_props_t ex_no_props_2(null_ptr);
-
-  ASIO_CHECK(ex_no_props_2.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_2 == null_ptr);
-  ASIO_CHECK(ex_no_props_2 == ex_no_props_1);
-
-  ex_no_props_t ex_no_props_3(std::nothrow, pool.executor());
-
-  ASIO_CHECK(ex_no_props_3.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_3 != null_ptr);
-  ASIO_CHECK(ex_no_props_3 != ex_no_props_1);
-
-  ex_no_props_t ex_no_props_4(std::nothrow, ex_no_props_1);
-
-  ASIO_CHECK(ex_no_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_4 == null_ptr);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_1);
-
-  ex_no_props_t ex_no_props_5(std::nothrow, ex_no_props_3);
-
-  ASIO_CHECK(ex_no_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_5 != null_ptr);
-  ASIO_CHECK(ex_no_props_5 == ex_no_props_3);
-
-  ex_no_props_t ex_no_props_6(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex_no_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_6 != null_ptr);
-  ASIO_CHECK(ex_no_props_6 != ex_no_props_1);
-
-  ex_no_props_t ex_no_props_7(std::nothrow, fat_executor(1));
-
-  ASIO_CHECK(ex_no_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_7 != null_ptr);
-  ASIO_CHECK(ex_no_props_7 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_7 == ex_no_props_6);
-
-  ex_no_props_t ex_no_props_8(std::nothrow, fat_executor(2));
-
-  ASIO_CHECK(ex_no_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_8 != null_ptr);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_6);
-  ASIO_CHECK(ex_no_props_8 != ex_no_props_7);
-
-  ex_no_props_t ex_no_props_9(std::nothrow, ex_no_props_6);
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_9 != null_ptr);
-  ASIO_CHECK(ex_no_props_9 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_9 == ex_no_props_6);
-  ASIO_CHECK(ex_no_props_9 == ex_no_props_7);
-  ASIO_CHECK(ex_no_props_9 != ex_no_props_8);
-
-  ex_no_props_t ex_no_props_10(std::nothrow, std::move(ex_no_props_1));
-
-  ASIO_CHECK(ex_no_props_10.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_10 == null_ptr);
-  ASIO_CHECK(ex_no_props_1.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_1 == null_ptr);
-
-  ex_no_props_t ex_no_props_11(std::nothrow, std::move(ex_no_props_3));
-
-  ASIO_CHECK(ex_no_props_11.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_11 != null_ptr);
-  ASIO_CHECK(ex_no_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_3 == null_ptr);
-  ASIO_CHECK(ex_no_props_11 == ex_no_props_5);
-
-  ex_no_props_t ex_no_props_12(std::nothrow, std::move(ex_no_props_7));
-
-  ASIO_CHECK(ex_no_props_12.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_12 != null_ptr);
-  ASIO_CHECK(ex_no_props_7.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_7 == null_ptr);
-  ASIO_CHECK(ex_no_props_12 == ex_no_props_6);
-  ASIO_CHECK(ex_no_props_12 != ex_no_props_8);
-
-  ex_no_props_t ex_no_props_13(std::nothrow, ex_two_props_1);
-
-  ASIO_CHECK(ex_no_props_13.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_13 == null_ptr);
-
-  ex_no_props_t ex_no_props_14(std::nothrow, ex_two_props_5);
-
-  ASIO_CHECK(ex_no_props_14.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_14 != null_ptr);
-
-  ex_no_props_t ex_no_props_15(std::nothrow, ex_two_props_9);
-
-  ASIO_CHECK(ex_no_props_15.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_15 != null_ptr);
-
-  ex_no_props_t ex_no_props_16(std::nothrow, ex_one_prop_1);
-
-  ASIO_CHECK(ex_no_props_16.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_16 == null_ptr);
-
-  ex_no_props_t ex_no_props_17(std::nothrow, ex_one_prop_5);
-
-  ASIO_CHECK(ex_no_props_17.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_17 != null_ptr);
-
-  ex_no_props_t ex_no_props_18(std::nothrow, ex_one_prop_9);
-
-  ASIO_CHECK(ex_no_props_18.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_18 != null_ptr);
-
-  next_nothrow_new_fails = true;
-  ex_no_props_t ex_no_props_19(std::nothrow, fat_executor(3));
-
-  ASIO_CHECK(ex_no_props_19.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_19 == null_ptr);
-  ASIO_CHECK(ex_no_props_19 == ex_no_props_1);
-}
-
-void any_executor_assignment_test()
-{
-  typedef execution::any_executor<> ex_no_props_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t
-    > ex_one_prop_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::occupancy_t
-    > ex_two_props_t;
-
-  thread_pool pool(1);
-  asio::nullptr_t null_ptr = asio::nullptr_t();
-
-  ex_two_props_t ex_two_props_1;
-
-  ex_two_props_t ex_two_props_2;
-  ex_two_props_2 = null_ptr;
-
-  ASIO_CHECK(ex_two_props_2.target<void>() == 0);
-
-  ex_two_props_t ex_two_props_3;
-  ex_two_props_3 = pool.executor();
-
-  ASIO_CHECK(ex_two_props_3.target<void>() != 0);
-
-  ex_two_props_t ex_two_props_4;
-  ex_two_props_4 = ex_two_props_1;
-
-  ASIO_CHECK(ex_two_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_1);
-
-  ex_two_props_4 = ex_two_props_3;
-
-  ASIO_CHECK(ex_two_props_4.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_3);
-
-  ex_two_props_t ex_two_props_5;
-  ex_two_props_5 = fat_executor(1);
-
-  ASIO_CHECK(ex_two_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_5 != null_ptr);
-  ASIO_CHECK(ex_two_props_5 != ex_two_props_1);
-
-  ex_two_props_t ex_two_props_6;
-  ex_two_props_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_two_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_6 != null_ptr);
-  ASIO_CHECK(ex_two_props_6 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_6 == ex_two_props_5);
-
-  ex_two_props_6 = fat_executor(2);
-
-  ASIO_CHECK(ex_two_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_6 != null_ptr);
-  ASIO_CHECK(ex_two_props_6 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_6 != ex_two_props_5);
-
-  ex_two_props_t ex_two_props_7;
-  ex_two_props_7 = ex_two_props_5;
-
-  ASIO_CHECK(ex_two_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_7 != null_ptr);
-  ASIO_CHECK(ex_two_props_7 != ex_two_props_1);
-  ASIO_CHECK(ex_two_props_7 == ex_two_props_5);
-  ASIO_CHECK(ex_two_props_7 != ex_two_props_6);
-
-  ex_two_props_t ex_two_props_8;
-  ex_two_props_8 = std::move(ex_two_props_1);
-
-  ASIO_CHECK(ex_two_props_8.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_1.target<void>() == 0);
-
-  ex_two_props_8 = std::move(ex_two_props_3);
-
-  ASIO_CHECK(ex_two_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_8 == ex_two_props_4);
-
-  ex_two_props_8 = std::move(ex_two_props_5);
-
-  ASIO_CHECK(ex_two_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_two_props_5.target<void>() == 0);
-  ASIO_CHECK(ex_two_props_8 == ex_two_props_7);
-
-  ex_one_prop_t ex_one_prop_1;
-
-  ex_one_prop_t ex_one_prop_2;
-  ex_one_prop_2 = null_ptr;
-
-  ASIO_CHECK(ex_one_prop_2.target<void>() == 0);
-
-  ex_one_prop_t ex_one_prop_3;
-  ex_one_prop_3 = pool.executor();
-
-  ASIO_CHECK(ex_one_prop_3.target<void>() != 0);
-
-  ex_one_prop_t ex_one_prop_4;
-  ex_one_prop_4 = ex_one_prop_1;
-
-  ASIO_CHECK(ex_one_prop_4.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_1);
-
-  ex_one_prop_4 = ex_one_prop_3;
-
-  ASIO_CHECK(ex_one_prop_4.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_3);
-
-  ex_one_prop_t ex_one_prop_5;
-  ex_one_prop_5 = fat_executor(1);
-
-  ASIO_CHECK(ex_one_prop_5.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_5 != null_ptr);
-  ASIO_CHECK(ex_one_prop_5 != ex_one_prop_1);
-
-  ex_one_prop_t ex_one_prop_6;
-  ex_one_prop_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_one_prop_6.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_6 != null_ptr);
-  ASIO_CHECK(ex_one_prop_6 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_6 == ex_one_prop_5);
-
-  ex_one_prop_6 = fat_executor(2);
-
-  ASIO_CHECK(ex_one_prop_6.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_6 != null_ptr);
-  ASIO_CHECK(ex_one_prop_6 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_6 != ex_one_prop_5);
-
-  ex_one_prop_t ex_one_prop_7;
-  ex_one_prop_7 = ex_one_prop_5;
-
-  ASIO_CHECK(ex_one_prop_7.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_7 != null_ptr);
-  ASIO_CHECK(ex_one_prop_7 != ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_7 == ex_one_prop_5);
-  ASIO_CHECK(ex_one_prop_7 != ex_one_prop_6);
-
-  ex_one_prop_t ex_one_prop_8;
-  ex_one_prop_8 = std::move(ex_one_prop_1);
-
-  ASIO_CHECK(ex_one_prop_8.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_1.target<void>() == 0);
-
-  ex_one_prop_8 = std::move(ex_one_prop_3);
-
-  ASIO_CHECK(ex_one_prop_8.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_3.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_8 == ex_one_prop_4);
-
-  ex_one_prop_8 = std::move(ex_one_prop_5);
-
-  ASIO_CHECK(ex_one_prop_8.target<void>() != 0);
-  ASIO_CHECK(ex_one_prop_5.target<void>() == 0);
-  ASIO_CHECK(ex_one_prop_8 == ex_one_prop_7);
-
-  ex_one_prop_t ex_one_prop_9;
-  ex_one_prop_9 = ex_two_props_1;
-
-  ASIO_CHECK(ex_one_prop_9.target<void>() == 0);
-
-  ex_one_prop_9 = ex_two_props_4;
-
-  ASIO_CHECK(ex_one_prop_9.target<void>() != 0);
-
-  ex_one_prop_9 = ex_two_props_7;
-
-  ASIO_CHECK(ex_one_prop_9.target<void>() != 0);
-
-  ex_no_props_t ex_no_props_1;
-
-  ex_no_props_t ex_no_props_2;
-  ex_no_props_2 = null_ptr;
-
-  ASIO_CHECK(ex_no_props_2.target<void>() == 0);
-
-  ex_no_props_t ex_no_props_3;
-  ex_no_props_3 = pool.executor();
-
-  ASIO_CHECK(ex_no_props_3.target<void>() != 0);
-
-  ex_no_props_t ex_no_props_4;
-  ex_no_props_4 = ex_no_props_1;
-
-  ASIO_CHECK(ex_no_props_4.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_1);
-
-  ex_no_props_4 = ex_no_props_3;
-
-  ASIO_CHECK(ex_no_props_4.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_3);
-
-  ex_no_props_t ex_no_props_5;
-  ex_no_props_5 = fat_executor(1);
-
-  ASIO_CHECK(ex_no_props_5.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_5 != null_ptr);
-  ASIO_CHECK(ex_no_props_5 != ex_no_props_1);
-
-  ex_no_props_t ex_no_props_6;
-  ex_no_props_6 = fat_executor(1);
-
-  ASIO_CHECK(ex_no_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_6 != null_ptr);
-  ASIO_CHECK(ex_no_props_6 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_6 == ex_no_props_5);
-
-  ex_no_props_6 = fat_executor(2);
-
-  ASIO_CHECK(ex_no_props_6.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_6 != null_ptr);
-  ASIO_CHECK(ex_no_props_6 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_6 != ex_no_props_5);
-
-  ex_no_props_t ex_no_props_7;
-  ex_no_props_7 = ex_no_props_5;
-
-  ASIO_CHECK(ex_no_props_7.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_7 != null_ptr);
-  ASIO_CHECK(ex_no_props_7 != ex_no_props_1);
-  ASIO_CHECK(ex_no_props_7 == ex_no_props_5);
-  ASIO_CHECK(ex_no_props_7 != ex_no_props_6);
-
-  ex_no_props_t ex_no_props_8;
-  ex_no_props_8 = std::move(ex_no_props_1);
-
-  ASIO_CHECK(ex_no_props_8.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_1.target<void>() == 0);
-
-  ex_no_props_8 = std::move(ex_no_props_3);
-
-  ASIO_CHECK(ex_no_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_3.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_8 == ex_no_props_4);
-
-  ex_no_props_8 = std::move(ex_no_props_5);
-
-  ASIO_CHECK(ex_no_props_8.target<void>() != 0);
-  ASIO_CHECK(ex_no_props_5.target<void>() == 0);
-  ASIO_CHECK(ex_no_props_8 == ex_no_props_7);
-
-  ex_no_props_t ex_no_props_9;
-  ex_no_props_9 = ex_two_props_1;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() == 0);
-
-  ex_no_props_9 = ex_two_props_4;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-
-  ex_no_props_9 = ex_two_props_7;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-
-  ex_no_props_9 = ex_one_prop_1;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() == 0);
-
-  ex_no_props_9 = ex_one_prop_4;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-
-  ex_no_props_9 = ex_one_prop_7;
-
-  ASIO_CHECK(ex_no_props_9.target<void>() != 0);
-}
-
-void any_executor_swap_test()
-{
-  typedef execution::any_executor<> ex_no_props_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t
-    > ex_one_prop_t;
-
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::occupancy_t
-    > ex_two_props_t;
-
-  thread_pool pool1(1);
-  thread_pool pool2(1);
-
-  ex_no_props_t ex_no_props_1(pool1.executor());
-  ex_no_props_t ex_no_props_2(pool2.executor());
-
-  ex_no_props_t ex_no_props_3(ex_no_props_1);
-  ex_no_props_t ex_no_props_4(ex_no_props_2);
-
-  ASIO_CHECK(ex_no_props_3 == ex_no_props_1);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_2);
-
-  ex_no_props_3.swap(ex_no_props_4);
-
-  ASIO_CHECK(ex_no_props_3 == ex_no_props_2);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_1);
-
-  execution::swap(ex_no_props_3, ex_no_props_4);
-
-  ASIO_CHECK(ex_no_props_3 == ex_no_props_1);
-  ASIO_CHECK(ex_no_props_4 == ex_no_props_2);
-
-  ex_one_prop_t ex_one_prop_1(pool1.executor());
-  ex_one_prop_t ex_one_prop_2(pool2.executor());
-
-  ex_one_prop_t ex_one_prop_3(ex_one_prop_1);
-  ex_one_prop_t ex_one_prop_4(ex_one_prop_2);
-
-  ASIO_CHECK(ex_one_prop_3 == ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_2);
-
-  ex_one_prop_3.swap(ex_one_prop_4);
-
-  ASIO_CHECK(ex_one_prop_3 == ex_one_prop_2);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_1);
-
-  execution::swap(ex_one_prop_3, ex_one_prop_4);
-
-  ASIO_CHECK(ex_one_prop_3 == ex_one_prop_1);
-  ASIO_CHECK(ex_one_prop_4 == ex_one_prop_2);
-
-  ex_two_props_t ex_two_props_1(pool1.executor());
-  ex_two_props_t ex_two_props_2(pool2.executor());
-
-  ex_two_props_t ex_two_props_3(ex_two_props_1);
-  ex_two_props_t ex_two_props_4(ex_two_props_2);
-
-  ASIO_CHECK(ex_two_props_3 == ex_two_props_1);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_2);
-
-  ex_two_props_3.swap(ex_two_props_4);
-
-  ASIO_CHECK(ex_two_props_3 == ex_two_props_2);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_1);
-
-  execution::swap(ex_two_props_3, ex_two_props_4);
-
-  ASIO_CHECK(ex_two_props_3 == ex_two_props_1);
-  ASIO_CHECK(ex_two_props_4 == ex_two_props_2);
-}
-
-void any_executor_query_test()
-{
-  thread_pool pool(1);
-  execution::any_executor<
-      execution::blocking_t,
-      execution::outstanding_work_t,
-      execution::relationship_t,
-      execution::mapping_t::thread_t,
-      execution::occupancy_t>
-    ex(pool.executor());
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::blocking.possibly)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::outstanding_work.untracked)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::relationship.fork)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::mapping)
-        == asio::execution::mapping.thread);
-
-  ASIO_CHECK(
-      asio::query(ex, asio::execution::occupancy)
-        == 1);
-}
-
-void any_executor_execute_test()
-{
-  int count = 0;
-  thread_pool pool(1);
-  execution::any_executor<
-      execution::blocking_t::possibly_t,
-      execution::blocking_t::never_t,
-      execution::outstanding_work_t::untracked_t,
-      execution::outstanding_work_t::tracked_t,
-      execution::relationship_t::continuation_t>
-    ex(pool.executor());
-
-  ex.execute(bindns::bind(increment, &count));
-
-  asio::require(ex, asio::execution::blocking.possibly).execute(
-      bindns::bind(increment, &count));
-
-  asio::require(ex, asio::execution::blocking.never).execute(
-      bindns::bind(increment, &count));
-
-  asio::require(ex,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.tracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(ex,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(ex,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  pool.wait();
-
-  ASIO_CHECK(count == 6);
-}
-
-ASIO_TEST_SUITE
-(
-  "any_executor",
-  ASIO_TEST_CASE(any_executor_construction_test)
-  ASIO_TEST_CASE(any_executor_nothrow_construction_test)
-  ASIO_TEST_CASE(any_executor_assignment_test)
-  ASIO_TEST_CASE(any_executor_swap_test)
-  ASIO_TEST_CASE(any_executor_query_test)
-  ASIO_TEST_CASE(any_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking.cpp
deleted file mode 100644
index ce2ba2f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking.cpp
+++ /dev/null
@@ -1,1921 +0,0 @@
-//
-// blocking.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/blocking.hpp"
-
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "../unit_test.hpp"
-
-namespace exec = asio::execution;
-
-typedef exec::blocking_t s;
-typedef exec::blocking_t::possibly_t n1;
-typedef exec::blocking_t::always_t n2;
-typedef exec::blocking_t::never_t n3;
-
-struct ex_nq_nr
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <>
-struct is_executor<ex_nq_nr> : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_cq_nr
-{
-  static constexpr ResultType query(ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_cq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_static_constexpr_member<
-  ex_cq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef Result result_type; // Must return raw result type.
-
-  static constexpr result_type value()
-  {
-    return Result();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_mq_nr
-{
-  ResultType query(ParamType) const noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_mq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_member<
-  ex_mq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_fq_nr
-{
-  friend ResultType query(const ex_fq_nr&, ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_fq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_free<
-  ex_fq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_mq_mr
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  CurrentType query(OtherType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, OtherType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, OtherType>();
-  }
-
-  ex_mq_mr<OtherType, CurrentType> require(
-      OtherType) const noexcept
-  {
-    return ex_mq_mr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_mq_mr<CurrentType, CurrentType>
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, CurrentType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_mq_mr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_fq_fr
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend CurrentType query(const ex_fq_fr&, OtherType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> require(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> prefer(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_fq_fr<CurrentType, CurrentType>
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_fq_fr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_query()
-{
-  constexpr bool b1 =
-    asio::can_query<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_query<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_query<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_query<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_query()
-{
-  exec::blocking_t result1 = asio::query(Executor(), Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-
-  Executor ex1 = {};
-  exec::blocking_t result2 = asio::query(ex1, Param());
-  ASIO_CHECK(result2 == ExpectedResult());
-
-  const Executor ex2 = {};
-  exec::blocking_t result3 = asio::query(ex2, Param());
-  ASIO_CHECK(result3 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_constexpr_query()
-{
-  constexpr Executor ex1 = {};
-  constexpr exec::blocking_t result1 = asio::query(ex1, Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_require()
-{
-  constexpr bool b1 =
-    asio::can_require<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_require<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_require<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_require<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_require()
-{
-  ASIO_CHECK(
-      asio::query(
-        asio::require(Executor(), Param()),
-        Param()) == ExpectedResult());
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex1, Param()),
-        Param()) == ExpectedResult());
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex2, Param()),
-        Param()) == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_prefer()
-{
-  constexpr bool b1 =
-    asio::can_prefer<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_prefer<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_prefer<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_prefer<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_prefer()
-{
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(Executor(), Param()),
-          s())) == s(ExpectedResult()));
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex1, Param()),
-          s())) == s(ExpectedResult()));
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex2, Param()),
-          s())) == s(ExpectedResult()));
-}
-
-void test_vars()
-{
-  ASIO_CHECK(s() == exec::blocking);
-  ASIO_CHECK(s() != exec::blocking.possibly);
-  ASIO_CHECK(s() != exec::blocking.always);
-  ASIO_CHECK(s() != exec::blocking.never);
-  ASIO_CHECK(n1() == exec::blocking.possibly);
-  ASIO_CHECK(n1() != exec::blocking.always);
-  ASIO_CHECK(n1() != exec::blocking.never);
-  ASIO_CHECK(n2() == exec::blocking.always);
-  ASIO_CHECK(n2() != exec::blocking.possibly);
-  ASIO_CHECK(n2() != exec::blocking.never);
-  ASIO_CHECK(n3() == exec::blocking.never);
-  ASIO_CHECK(n3() != exec::blocking.possibly);
-  ASIO_CHECK(n3() != exec::blocking.always);
-}
-
-ASIO_TEST_SUITE
-(
-  "blocking",
-
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, s, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n2, false>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n3, false>)
-
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n2, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n3, false>)
-
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n2, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n3, true>)
-
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n1, n1>)
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n3, n1>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n3, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n3, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n3>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n3>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n1>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n2>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n3>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n3>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n2>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n3>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n3>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n3>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n1>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n2>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n3>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n3>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n2>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n3>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE(test_vars)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking_adaptation.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking_adaptation.cpp
deleted file mode 100644
index b6e77dd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/blocking_adaptation.cpp
+++ /dev/null
@@ -1,1323 +0,0 @@
-//
-// blocking_adaptation.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/blocking_adaptation.hpp"
-
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "../unit_test.hpp"
-
-namespace exec = asio::execution;
-
-typedef exec::blocking_adaptation_t s;
-typedef exec::blocking_adaptation_t::disallowed_t n1;
-typedef exec::blocking_adaptation_t::allowed_t n2;
-
-struct ex_nq_nr
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<ex_nq_nr>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename Function>
-struct execute_member<ex_nq_nr, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_cq_nr
-{
-  static constexpr ResultType query(ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct equality_comparable<ex_cq_nr<ResultType, ParamType, Result> >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-    typename Result, typename Function>
-struct execute_member<ex_cq_nr<ResultType, ParamType, Result>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_static_constexpr_member<
-  ex_cq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef Result result_type; // Must return raw result type.
-
-  static constexpr result_type value()
-  {
-    return Result();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_mq_nr
-{
-  ResultType query(ParamType) const noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct equality_comparable<ex_mq_nr<ResultType, ParamType, Result> >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-    typename Result, typename Function>
-struct execute_member<ex_mq_nr<ResultType, ParamType, Result>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_member<
-  ex_mq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_fq_nr
-{
-  friend ResultType query(const ex_fq_nr&, ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct equality_comparable<ex_fq_nr<ResultType, ParamType, Result> >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-    typename Result, typename Function>
-struct execute_member<ex_fq_nr<ResultType, ParamType, Result>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_free<
-  ex_fq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_mq_mr
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  CurrentType query(OtherType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, OtherType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, OtherType>();
-  }
-
-  ex_mq_mr<OtherType, CurrentType> require(
-      OtherType) const noexcept
-  {
-    return ex_mq_mr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_mq_mr<CurrentType, CurrentType>
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, CurrentType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename CurrentType, typename OtherType>
-struct equality_comparable<ex_mq_mr<CurrentType, OtherType> >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Function>
-struct execute_member<ex_mq_mr<CurrentType, OtherType>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_fq_fr
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend CurrentType query(const ex_fq_fr&, OtherType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> require(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> prefer(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_fq_fr<CurrentType, CurrentType>
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <typename CurrentType, typename OtherType>
-struct equality_comparable<ex_fq_fr<CurrentType, OtherType> >
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Function>
-struct execute_member<ex_fq_fr<CurrentType, OtherType>, Function>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_query()
-{
-  constexpr bool b1 =
-    asio::can_query<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_query<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_query<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_query<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_query()
-{
-  exec::blocking_adaptation_t result1 = asio::query(Executor(), Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-
-  Executor ex1 = {};
-  exec::blocking_adaptation_t result2 = asio::query(ex1, Param());
-  ASIO_CHECK(result2 == ExpectedResult());
-
-  const Executor ex2 = {};
-  exec::blocking_adaptation_t result3 = asio::query(ex2, Param());
-  ASIO_CHECK(result3 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_constexpr_query()
-{
-  constexpr Executor ex1 = {};
-  constexpr exec::blocking_adaptation_t result1 = asio::query(ex1, Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_require()
-{
-  constexpr bool b1 =
-    asio::can_require<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_require<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_require<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_require<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-void do_nothing()
-{
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_require()
-{
-  ASIO_CHECK(
-      asio::query(
-        asio::require(Executor(), Param()),
-        Param()) == ExpectedResult());
-
-  Executor ex1 = {};
-
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex1, Param()),
-        Param()) == ExpectedResult());
-
-  ASIO_CHECK((
-      asio::execution::is_executor<
-        typename asio::decay<
-          typename asio::require_result<Executor&, Param>::type
-        >::type
-      >::value));
-
-  const Executor ex2 = {};
-
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex2, Param()),
-        Param()) == ExpectedResult());
-
-  ASIO_CHECK((
-      asio::execution::is_executor<
-        typename asio::decay<
-          typename asio::require_result<const Executor&, Param>::type
-        >::type
-      >::value));
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_prefer()
-{
-  constexpr bool b1 =
-    asio::can_prefer<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_prefer<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_prefer<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_prefer<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_prefer()
-{
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(Executor(), Param()),
-          s())) == s(ExpectedResult()));
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex1, Param()),
-          s())) == s(ExpectedResult()));
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex2, Param()),
-          s())) == s(ExpectedResult()));
-}
-
-void test_vars()
-{
-  ASIO_CHECK(s() == exec::blocking_adaptation);
-  ASIO_CHECK(s() != exec::blocking_adaptation.disallowed);
-  ASIO_CHECK(s() != exec::blocking_adaptation.allowed);
-  ASIO_CHECK(n1() == exec::blocking_adaptation.disallowed);
-  ASIO_CHECK(n1() != exec::blocking_adaptation.allowed);
-  ASIO_CHECK(n2() == exec::blocking_adaptation.allowed);
-  ASIO_CHECK(n2() != exec::blocking_adaptation.disallowed);
-}
-
-ASIO_TEST_SUITE
-(
-  "blocking_adaptation",
-
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, s, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n2, true>)
-
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n1, n1>)
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n2, n2>)
-
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n1, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, n1, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, n2, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<n1, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n1, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, n1, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, n2, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<n1, s, n1>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n1, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n2, false>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n1, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n2, false>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n1, n2>)
-
-  ASIO_TEST_CASE(test_vars)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/context_as.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/context_as.cpp
deleted file mode 100644
index 13311ba..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/context_as.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// context_as.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/context_as.hpp"
-
-#include <functional>
-#include "asio/execution/any_executor.hpp"
-#include "asio/io_context.hpp"
-#include "asio/static_thread_pool.hpp"
-#include "../unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-void context_as_executor_query_test()
-{
-  static_thread_pool pool(1);
-
-  ASIO_CHECK(
-      &asio::query(pool.executor(),
-        execution::context_as_t<static_thread_pool&>())
-        == &pool);
-
-  execution::any_executor<
-      execution::context_as_t<static_thread_pool&>
-    > ex1 = pool.executor();
-
-  ASIO_CHECK(
-      &asio::query(ex1,
-        execution::context_as_t<static_thread_pool&>())
-        == &pool);
-
-  ASIO_CHECK(
-      &asio::query(ex1, execution::context)
-        == &pool);
-
-  ASIO_CHECK(
-      &asio::query(pool.executor(),
-        execution::context_as_t<const static_thread_pool&>())
-        == &pool);
-
-  execution::any_executor<
-      execution::context_as_t<const static_thread_pool&>
-    > ex2 = pool.executor();
-
-  ASIO_CHECK(
-      &asio::query(ex2,
-        execution::context_as_t<const static_thread_pool&>())
-        == &pool);
-
-  ASIO_CHECK(
-      &asio::query(ex2, execution::context)
-        == &pool);
-
-  io_context io_ctx;
-
-  ASIO_CHECK(
-      &asio::query(io_ctx.get_executor(),
-        execution::context_as_t<io_context&>())
-        == &io_ctx);
-
-  execution::any_executor<
-      execution::context_as_t<io_context&>
-    > ex3 = io_ctx.get_executor();
-
-  ASIO_CHECK(
-      &asio::query(ex3,
-        execution::context_as_t<io_context&>())
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(ex3, execution::context)
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(io_ctx.get_executor(),
-        execution::context_as_t<const io_context&>())
-        == &io_ctx);
-
-  execution::any_executor<
-      execution::context_as_t<const io_context&>
-    > ex4 = io_ctx.get_executor();
-
-  ASIO_CHECK(
-      &asio::query(ex4,
-        execution::context_as_t<const io_context&>())
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(ex4, execution::context)
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(io_ctx.get_executor(),
-        execution::context_as_t<execution_context&>())
-        == &io_ctx);
-
-  execution::any_executor<
-      execution::context_as_t<execution_context&>
-    > ex5 = io_ctx.get_executor();
-
-  ASIO_CHECK(
-      &asio::query(ex5,
-        execution::context_as_t<execution_context&>())
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(ex5, execution::context)
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(io_ctx.get_executor(),
-        execution::context_as_t<const execution_context&>())
-        == &io_ctx);
-
-  execution::any_executor<
-      execution::context_as_t<const execution_context&>
-    > ex6 = io_ctx.get_executor();
-
-  ASIO_CHECK(
-      &asio::query(ex6,
-        execution::context_as_t<const execution_context&>())
-        == &io_ctx);
-
-  ASIO_CHECK(
-      &asio::query(ex6, execution::context)
-        == &io_ctx);
-}
-
-ASIO_TEST_SUITE
-(
-  "context_as",
-  ASIO_TEST_CASE(context_as_executor_query_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/executor.cpp
deleted file mode 100644
index 8b02622..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/executor.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-// executor.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/executor.hpp"
-
-#include "../unit_test.hpp"
-
-struct not_an_executor
-{
-};
-
-struct executor
-{
-  executor()
-  {
-  }
-
-  executor(const executor&) noexcept
-  {
-  }
-
-  executor(executor&&) noexcept
-  {
-  }
-
-  template <typename F>
-  void execute(F&& f) const noexcept
-  {
-    (void)f;
-  }
-
-  bool operator==(const executor&) const noexcept
-  {
-    return true;
-  }
-
-  bool operator!=(const executor&) const noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_SET_ERROR_MEMBER_TRAIT)
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-void is_executor_test()
-{
-  ASIO_CHECK((
-      !asio::execution::is_executor<
-        void
-      >::value));
-
-  ASIO_CHECK((
-      !asio::execution::is_executor<
-        not_an_executor
-      >::value));
-
-  ASIO_CHECK((
-      asio::execution::is_executor<
-        executor
-      >::value));
-}
-
-ASIO_TEST_SUITE
-(
-  "executor",
-  ASIO_TEST_CASE(is_executor_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/invocable_archetype.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/invocable_archetype.cpp
deleted file mode 100644
index 5dbfb94..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/invocable_archetype.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// invocable_archetype.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/invocable_archetype.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "invocable_archetype",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/mapping.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/mapping.cpp
deleted file mode 100644
index 399aae3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/mapping.cpp
+++ /dev/null
@@ -1,1985 +0,0 @@
-//
-// mapping.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/mapping.hpp"
-
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "../unit_test.hpp"
-
-namespace exec = asio::execution;
-
-typedef exec::mapping_t s;
-typedef exec::mapping_t::thread_t n1;
-typedef exec::mapping_t::new_thread_t n2;
-typedef exec::mapping_t::other_t n3;
-
-struct ex_nq_nr
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <>
-struct is_executor<ex_nq_nr> : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_cq_nr
-{
-  static constexpr ResultType query(ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_cq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_static_constexpr_member<
-  ex_cq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef Result result_type; // Must return raw result type.
-
-  static constexpr result_type value()
-  {
-    return Result();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_mq_nr
-{
-  ResultType query(ParamType) const noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_mq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_member<
-  ex_mq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_fq_nr
-{
-  friend ResultType query(const ex_fq_nr&, ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_fq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_free<
-  ex_fq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_mq_mr
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  CurrentType query(OtherType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, OtherType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, OtherType>();
-  }
-
-  ex_mq_mr<OtherType, CurrentType> require(
-      OtherType) const noexcept
-  {
-    return ex_mq_mr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_mq_mr<CurrentType, CurrentType>
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, CurrentType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_mq_mr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_fq_fr
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend CurrentType query(const ex_fq_fr&, OtherType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> require(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> prefer(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_fq_fr<CurrentType, CurrentType>
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_fq_fr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_query()
-{
-  constexpr bool b1 =
-    asio::can_query<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_query<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_query<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_query<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_query()
-{
-  exec::mapping_t result1 = asio::query(Executor(), Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-
-  Executor ex1 = {};
-  exec::mapping_t result2 = asio::query(ex1, Param());
-  ASIO_CHECK(result2 == ExpectedResult());
-
-  const Executor ex2 = {};
-  exec::mapping_t result3 = asio::query(ex2, Param());
-  ASIO_CHECK(result3 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_constexpr_query()
-{
-  constexpr Executor ex1 = {};
-  constexpr exec::mapping_t result1 = asio::query(ex1, Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_require()
-{
-  constexpr bool b1 =
-    asio::can_require<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_require<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_require<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_require<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_require()
-{
-  ASIO_CHECK(
-      asio::query(
-        asio::require(Executor(), Param()),
-        Param()) == ExpectedResult());
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex1, Param()),
-        Param()) == ExpectedResult());
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex2, Param()),
-        Param()) == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_prefer()
-{
-  constexpr bool b1 =
-    asio::can_prefer<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_prefer<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_prefer<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_prefer<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_prefer()
-{
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(Executor(), Param()),
-          s())) == s(ExpectedResult()));
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex1, Param()),
-          s())) == s(ExpectedResult()));
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex2, Param()),
-          s())) == s(ExpectedResult()));
-}
-
-void test_vars()
-{
-  ASIO_CHECK(s() == exec::mapping);
-  ASIO_CHECK(s() != exec::mapping.thread);
-  ASIO_CHECK(s() != exec::mapping.new_thread);
-  ASIO_CHECK(s() != exec::mapping.other);
-  ASIO_CHECK(n1() == exec::mapping.thread);
-  ASIO_CHECK(n1() != exec::mapping.new_thread);
-  ASIO_CHECK(n1() != exec::mapping.other);
-  ASIO_CHECK(n2() == exec::mapping.new_thread);
-  ASIO_CHECK(n2() != exec::mapping.thread);
-  ASIO_CHECK(n2() != exec::mapping.other);
-  ASIO_CHECK(n3() == exec::mapping.other);
-  ASIO_CHECK(n3() != exec::mapping.thread);
-  ASIO_CHECK(n3() != exec::mapping.new_thread);
-}
-
-ASIO_TEST_SUITE
-(
-  "mapping",
-
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, s, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n2, false>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n3, false>)
-
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n2, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n3, false>)
-
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n2, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n3, true>)
-
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n1, n1>)
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n2, n1>)
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n3, n1>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n3, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n3, s, n3>, n3, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, s, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n3, n3>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n3, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n3, s, n3>, n3, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n3, n3>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n3, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n3, s, n3>, n3, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n3, n3>, n3, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n3, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n3, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n3, s, n3>, n1, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n3, s, n3>, n2, n3>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n3, s, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n3>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n3>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n1>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n2>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n3>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n3>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n3>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n1>, n2, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n2>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n3>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n3>, n2, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n3>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n3>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n1>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n2>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n3>, s, n3>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n3, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n3>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n1>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n2>, n3, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n3, n3>, n3, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n3, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n3>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n3>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n3, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n3>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n3>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n3>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n1>, n2, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n1>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n2>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n2>, n3, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n3>, n1, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n3>, n2, n3>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n3, n3>, n3, n3>)
-
-  ASIO_TEST_CASE(test_vars)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/outstanding_work.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/outstanding_work.cpp
deleted file mode 100644
index cddd0b5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/outstanding_work.cpp
+++ /dev/null
@@ -1,1252 +0,0 @@
-//
-// outstanding_work.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/outstanding_work.hpp"
-
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "../unit_test.hpp"
-
-namespace exec = asio::execution;
-
-typedef exec::outstanding_work_t s;
-typedef exec::outstanding_work_t::untracked_t n1;
-typedef exec::outstanding_work_t::tracked_t n2;
-
-struct ex_nq_nr
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <>
-struct is_executor<ex_nq_nr> : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_cq_nr
-{
-  static constexpr ResultType query(ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_cq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_static_constexpr_member<
-  ex_cq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef Result result_type; // Must return raw result type.
-
-  static constexpr result_type value()
-  {
-    return Result();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_mq_nr
-{
-  ResultType query(ParamType) const noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_mq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_member<
-  ex_mq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_fq_nr
-{
-  friend ResultType query(const ex_fq_nr&, ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_fq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_free<
-  ex_fq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_mq_mr
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  CurrentType query(OtherType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, OtherType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, OtherType>();
-  }
-
-  ex_mq_mr<OtherType, CurrentType> require(
-      OtherType) const noexcept
-  {
-    return ex_mq_mr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_mq_mr<CurrentType, CurrentType>
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, CurrentType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_mq_mr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_fq_fr
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend CurrentType query(const ex_fq_fr&, OtherType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> require(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> prefer(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_fq_fr<CurrentType, CurrentType>
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_fq_fr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_query()
-{
-  constexpr bool b1 =
-    asio::can_query<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_query<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_query<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_query<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_query()
-{
-  exec::outstanding_work_t result1 = asio::query(Executor(), Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-
-  Executor ex1 = {};
-  exec::outstanding_work_t result2 = asio::query(ex1, Param());
-  ASIO_CHECK(result2 == ExpectedResult());
-
-  const Executor ex2 = {};
-  exec::outstanding_work_t result3 = asio::query(ex2, Param());
-  ASIO_CHECK(result3 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_constexpr_query()
-{
-  constexpr Executor ex1 = {};
-  constexpr exec::outstanding_work_t result1 = asio::query(ex1, Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_require()
-{
-  constexpr bool b1 =
-    asio::can_require<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_require<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_require<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_require<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_require()
-{
-  ASIO_CHECK(
-      asio::query(
-        asio::require(Executor(), Param()),
-        Param()) == ExpectedResult());
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex1, Param()),
-        Param()) == ExpectedResult());
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex2, Param()),
-        Param()) == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_prefer()
-{
-  constexpr bool b1 =
-    asio::can_prefer<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_prefer<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_prefer<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_prefer<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_prefer()
-{
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(Executor(), Param()),
-          s())) == s(ExpectedResult()));
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex1, Param()),
-          s())) == s(ExpectedResult()));
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex2, Param()),
-          s())) == s(ExpectedResult()));
-}
-
-void test_vars()
-{
-  ASIO_CHECK(s() == exec::outstanding_work);
-  ASIO_CHECK(s() != exec::outstanding_work.untracked);
-  ASIO_CHECK(s() != exec::outstanding_work.tracked);
-  ASIO_CHECK(n1() == exec::outstanding_work.untracked);
-  ASIO_CHECK(n1() != exec::outstanding_work.tracked);
-  ASIO_CHECK(n2() == exec::outstanding_work.tracked);
-  ASIO_CHECK(n2() != exec::outstanding_work.untracked);
-}
-
-ASIO_TEST_SUITE
-(
-  "outstanding_work",
-
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, s, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n2, true>)
-
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n1, n1>)
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n2, n1>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE(test_vars)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/prefer_only.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/prefer_only.cpp
deleted file mode 100644
index 6050000..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/prefer_only.cpp
+++ /dev/null
@@ -1,533 +0,0 @@
-//
-// prefer_only.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/prefer_only.hpp"
-
-#include <functional>
-#include "asio/execution/any_executor.hpp"
-#include "../unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-static int possibly_blocking_count = 0;
-static int never_blocking_count = 0;
-
-struct possibly_blocking_executor
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-    ++possibly_blocking_count;
-  }
-
-  friend bool operator==(const possibly_blocking_executor&,
-      const possibly_blocking_executor&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const possibly_blocking_executor&,
-      const possibly_blocking_executor&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<possibly_blocking_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<possibly_blocking_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-struct never_blocking_executor
-{
-  static constexpr execution::blocking_t::never_t
-    query(execution::blocking_t) noexcept
-  {
-    return execution::blocking_t::never_t();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-    ++never_blocking_count;
-  }
-
-  friend bool operator==(const never_blocking_executor&,
-      const never_blocking_executor&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const never_blocking_executor&,
-      const never_blocking_executor&) noexcept
-  {
-    return false;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<never_blocking_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<never_blocking_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename Param>
-struct query_static_constexpr_member<
-  never_blocking_executor, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, execution::blocking_t>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::blocking_t::never_t result_type;
-
-  static constexpr result_type value()
-  {
-    return result_type();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-struct either_blocking_executor
-{
-  execution::blocking_t blocking_;
-
-  explicit either_blocking_executor(execution::blocking_t b)
-    : blocking_(b)
-  {
-  }
-
-  execution::blocking_t query(execution::blocking_t) const noexcept
-  {
-    return blocking_;
-  }
-
-  either_blocking_executor require(execution::blocking_t::possibly_t) const
-  {
-    return either_blocking_executor(execution::blocking.possibly);
-  }
-
-  either_blocking_executor require(execution::blocking_t::never_t) const
-  {
-    return either_blocking_executor(execution::blocking.never);
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-    if (blocking_ == execution::blocking.never)
-      ++never_blocking_count;
-    else
-      ++possibly_blocking_count;
-  }
-
-  friend bool operator==(const either_blocking_executor& a,
-      const either_blocking_executor& b) noexcept
-  {
-    return a.blocking_ == b.blocking_;
-  }
-
-  friend bool operator!=(const either_blocking_executor& a,
-      const either_blocking_executor& b) noexcept
-  {
-    return a.blocking_ != b.blocking_;
-  }
-};
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-template <typename F>
-struct execute_member<either_blocking_executor, F>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-  typedef void result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-template <>
-struct equality_comparable<either_blocking_executor>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Param>
-struct query_member<
-  either_blocking_executor, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, execution::blocking_t>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef execution::blocking_t result_type;
-};
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename Param>
-struct require_member<
-  either_blocking_executor, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, execution::blocking_t>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = false;
-
-  typedef either_blocking_executor result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-void prefer_only_executor_query_test()
-{
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::prefer_only<execution::blocking_t::possibly_t>,
-      execution::prefer_only<execution::blocking_t::never_t>
-    > executor_type;
-
-  executor_type ex1 = possibly_blocking_executor();
-
-  ASIO_CHECK(
-      asio::query(ex1, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex1, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex1, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex2 = asio::prefer(ex1, execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex2, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex2, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex2, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex3 = asio::prefer(ex1, execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex3, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex3, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex3, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex4 = never_blocking_executor();
-
-  ASIO_CHECK(
-      asio::query(ex4, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex4, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex4, execution::blocking.never)
-        == execution::blocking.never);
-
-  executor_type ex5 = asio::prefer(ex4, execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex5, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex5, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex5, execution::blocking.never)
-        == execution::blocking.never);
-
-  executor_type ex6 = asio::prefer(ex4, execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex6, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex6, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex6, execution::blocking.never)
-        == execution::blocking.never);
-
-  executor_type ex7 = either_blocking_executor(execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex7, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex7, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex7, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex8 = asio::prefer(ex7, execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex8, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex8, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex8, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex9 = asio::prefer(ex7, execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex9, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex9, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex9, execution::blocking.never)
-        == execution::blocking.never);
-
-  executor_type ex10 = either_blocking_executor(execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex10, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex10, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex10, execution::blocking.never)
-        == execution::blocking.never);
-
-  executor_type ex11 = asio::prefer(ex7, execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex11, execution::blocking)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex11, execution::blocking.possibly)
-        == execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ex11, execution::blocking.never)
-        == execution::blocking.possibly);
-
-  executor_type ex12 = asio::prefer(ex7, execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex12, execution::blocking)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex12, execution::blocking.possibly)
-        == execution::blocking.never);
-
-  ASIO_CHECK(
-      asio::query(ex12, execution::blocking.never)
-        == execution::blocking.never);
-}
-
-void do_nothing()
-{
-}
-
-void prefer_only_executor_execute_test()
-{
-  typedef execution::any_executor<
-      execution::blocking_t,
-      execution::prefer_only<execution::blocking_t::possibly_t>,
-      execution::prefer_only<execution::blocking_t::never_t>
-    > executor_type;
-
-  executor_type ex1 = possibly_blocking_executor();
-
-  ex1.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 1);
-  ASIO_CHECK(never_blocking_count == 0);
-
-  executor_type ex2 = asio::prefer(ex1, execution::blocking.possibly);
-
-  ex2.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 2);
-  ASIO_CHECK(never_blocking_count == 0);
-
-  executor_type ex3 = asio::prefer(ex1, execution::blocking.never);
-
-  ex3.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 3);
-  ASIO_CHECK(never_blocking_count == 0);
-
-  executor_type ex4 = never_blocking_executor();
-
-  ex4.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 3);
-  ASIO_CHECK(never_blocking_count == 1);
-
-  executor_type ex5 = asio::prefer(ex4, execution::blocking.possibly);
-
-  ex5.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 3);
-  ASIO_CHECK(never_blocking_count == 2);
-
-  executor_type ex6 = asio::prefer(ex4, execution::blocking.never);
-
-  ex6.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 3);
-  ASIO_CHECK(never_blocking_count == 3);
-
-  executor_type ex7 = either_blocking_executor(execution::blocking.possibly);
-
-  ex7.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 4);
-  ASIO_CHECK(never_blocking_count == 3);
-
-  executor_type ex8 = asio::prefer(ex7, execution::blocking.possibly);
-
-  ex8.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 5);
-  ASIO_CHECK(never_blocking_count == 3);
-
-  executor_type ex9 = asio::prefer(ex7, execution::blocking.never);
-
-  ex9.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 5);
-  ASIO_CHECK(never_blocking_count == 4);
-
-  executor_type ex10 = either_blocking_executor(execution::blocking.never);
-
-  ex10.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 5);
-  ASIO_CHECK(never_blocking_count == 5);
-
-  executor_type ex11 = asio::prefer(ex7, execution::blocking.possibly);
-
-  ex11.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 6);
-  ASIO_CHECK(never_blocking_count == 5);
-
-  executor_type ex12 = asio::prefer(ex7, execution::blocking.never);
-
-  ex12.execute(&do_nothing);
-  ASIO_CHECK(possibly_blocking_count == 6);
-  ASIO_CHECK(never_blocking_count == 6);
-}
-
-ASIO_TEST_SUITE
-(
-  "prefer_only",
-  ASIO_TEST_CASE(prefer_only_executor_query_test)
-  ASIO_TEST_CASE(prefer_only_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/relationship.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/relationship.cpp
deleted file mode 100644
index a91144e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution/relationship.cpp
+++ /dev/null
@@ -1,1252 +0,0 @@
-//
-// relationship.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution/relationship.hpp"
-
-#include "asio/prefer.hpp"
-#include "asio/query.hpp"
-#include "asio/require.hpp"
-#include "../unit_test.hpp"
-
-namespace exec = asio::execution;
-
-typedef exec::relationship_t s;
-typedef exec::relationship_t::fork_t n1;
-typedef exec::relationship_t::continuation_t n2;
-
-struct ex_nq_nr
-{
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_nq_nr&, const ex_nq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <>
-struct is_executor<ex_nq_nr> : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_cq_nr
-{
-  static constexpr ResultType query(ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_cq_nr&, const ex_cq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_cq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_static_constexpr_member<
-  ex_cq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef Result result_type; // Must return raw result type.
-
-  static constexpr result_type value()
-  {
-    return Result();
-  }
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_mq_nr
-{
-  ResultType query(ParamType) const noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_nr&, const ex_mq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_mq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_member<
-  ex_mq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename ResultType, typename ParamType, typename Result>
-struct ex_fq_nr
-{
-  friend ResultType query(const ex_fq_nr&, ParamType) noexcept
-  {
-    return Result();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_nr&, const ex_fq_nr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename ResultType, typename ParamType, typename Result>
-struct is_executor<ex_fq_nr<ResultType, ParamType, Result> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename ResultType, typename ParamType,
-  typename Result, typename Param>
-struct query_free<
-  ex_fq_nr<ResultType, ParamType, Result>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, ParamType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ResultType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_mq_mr
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  CurrentType query(OtherType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, OtherType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, OtherType>();
-  }
-
-  ex_mq_mr<OtherType, CurrentType> require(
-      OtherType) const noexcept
-  {
-    return ex_mq_mr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_mq_mr<CurrentType, CurrentType>
-{
-  CurrentType query(CurrentType) const noexcept
-  {
-    return CurrentType();
-  }
-
-  ex_mq_mr<CurrentType, CurrentType> require(
-      CurrentType) const noexcept
-  {
-    return ex_mq_mr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_mq_mr&, const ex_mq_mr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_mq_mr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_member<
-  ex_mq_mr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_mq_mr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename CurrentType, typename OtherType>
-struct ex_fq_fr
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend CurrentType query(const ex_fq_fr&, OtherType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> require(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, OtherType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, OtherType>();
-  }
-
-  friend ex_fq_fr<OtherType, CurrentType> prefer(
-      const ex_fq_fr&, OtherType) noexcept
-  {
-    return ex_fq_fr<OtherType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-template <typename CurrentType>
-struct ex_fq_fr<CurrentType, CurrentType>
-{
-  friend CurrentType query(const ex_fq_fr&, CurrentType) noexcept
-  {
-    return CurrentType();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> require(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  friend ex_fq_fr<CurrentType, CurrentType> prefer(
-      const ex_fq_fr&, CurrentType) noexcept
-  {
-    return ex_fq_fr<CurrentType, CurrentType>();
-  }
-
-  template <typename F>
-  void execute(const F&) const
-  {
-  }
-
-  friend bool operator==(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return true;
-  }
-
-  friend bool operator!=(const ex_fq_fr&, const ex_fq_fr&) noexcept
-  {
-    return false;
-  }
-};
-
-#if !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace execution {
-
-template <typename CurrentType, typename OtherType>
-struct is_executor<ex_fq_fr<CurrentType, OtherType> >
-  : asio::true_type
-{
-};
-
-} // namespace execution
-} // namespace asio
-
-#endif // !defined(ASIO_HAS_DEDUCED_EXECUTION_IS_EXECUTOR_TRAIT)
-
-namespace asio {
-namespace traits {
-
-#if !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct query_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-      || asio::is_convertible<Param, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef CurrentType result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_QUERY_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct require_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_FREE_TRAIT)
-
-#if !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, CurrentType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<CurrentType, OtherType> result_type;
-};
-
-template <typename CurrentType, typename OtherType, typename Param>
-struct prefer_free<
-  ex_fq_fr<CurrentType, OtherType>, Param,
-  typename asio::enable_if<
-    asio::is_convertible<Param, OtherType>::value
-      && !asio::is_same<CurrentType, OtherType>::value
-  >::type>
-{
-  static constexpr bool is_valid = true;
-  static constexpr bool is_noexcept = true;
-
-  typedef ex_fq_fr<OtherType, CurrentType> result_type;
-};
-
-#endif // !defined(ASIO_HAS_DEDUCED_PREFER_FREE_TRAIT)
-
-} // namespace traits
-} // namespace asio
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_query()
-{
-  constexpr bool b1 =
-    asio::can_query<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_query<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_query<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_query<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_query()
-{
-  exec::relationship_t result1 = asio::query(Executor(), Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-
-  Executor ex1 = {};
-  exec::relationship_t result2 = asio::query(ex1, Param());
-  ASIO_CHECK(result2 == ExpectedResult());
-
-  const Executor ex2 = {};
-  exec::relationship_t result3 = asio::query(ex2, Param());
-  ASIO_CHECK(result3 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_constexpr_query()
-{
-  constexpr Executor ex1 = {};
-  constexpr exec::relationship_t result1 = asio::query(ex1, Param());
-  ASIO_CHECK(result1 == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_require()
-{
-  constexpr bool b1 =
-    asio::can_require<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_require<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_require<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_require<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_require()
-{
-  ASIO_CHECK(
-      asio::query(
-        asio::require(Executor(), Param()),
-        Param()) == ExpectedResult());
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex1, Param()),
-        Param()) == ExpectedResult());
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      asio::query(
-        asio::require(ex2, Param()),
-        Param()) == ExpectedResult());
-}
-
-template <typename Executor, typename Param, bool ExpectedResult>
-void test_can_prefer()
-{
-  constexpr bool b1 =
-    asio::can_prefer<Executor, Param>::value;
-  ASIO_CHECK(b1 == ExpectedResult);
-
-  constexpr bool b2 =
-    asio::can_prefer<const Executor, Param>::value;
-  ASIO_CHECK(b2 == ExpectedResult);
-
-  constexpr bool b3 =
-    asio::can_prefer<Executor&, Param>::value;
-  ASIO_CHECK(b3 == ExpectedResult);
-
-  constexpr bool b4 =
-    asio::can_prefer<const Executor&, Param>::value;
-  ASIO_CHECK(b4 == ExpectedResult);
-}
-
-template <typename Executor, typename Param, typename ExpectedResult>
-void test_prefer()
-{
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(Executor(), Param()),
-          s())) == s(ExpectedResult()));
-
-  Executor ex1 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex1, Param()),
-          s())) == s(ExpectedResult()));
-
-  const Executor ex2 = {};
-  ASIO_CHECK(
-      s(asio::query(
-        asio::prefer(ex2, Param()),
-          s())) == s(ExpectedResult()));
-}
-
-void test_vars()
-{
-  ASIO_CHECK(s() == exec::relationship);
-  ASIO_CHECK(s() != exec::relationship.fork);
-  ASIO_CHECK(s() != exec::relationship.continuation);
-  ASIO_CHECK(n1() == exec::relationship.fork);
-  ASIO_CHECK(n1() != exec::relationship.continuation);
-  ASIO_CHECK(n2() == exec::relationship.continuation);
-  ASIO_CHECK(n2() != exec::relationship.fork);
-}
-
-ASIO_TEST_SUITE
-(
-  "relationship",
-
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, s, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_query<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, s, n1>)
-  ASIO_TEST_CASE3(test_constexpr_query<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_require<ex_nq_nr, n2, false>)
-
-  ASIO_TEST_CASE3(test_require<ex_nq_nr, n1, n1>)
-
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, s, false>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n1, true>)
-  ASIO_TEST_CASE3(test_can_prefer<ex_nq_nr, n2, true>)
-
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n1, n1>)
-  ASIO_TEST_CASE3(test_prefer<ex_nq_nr, n2, n1>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_constexpr_query<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_require<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_cq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_cq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_mq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_mq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_mq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, s, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_query<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, s, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, s, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_query<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, s, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n1, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<s, n2, n2>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n1, s, n1>, n2, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n1, false>)
-  ASIO_TEST_CASE5(test_can_require<ex_fq_nr<n2, s, n2>, n2, false>)
-
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, s, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n1, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<s, n2, n2>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n1, s, n1>, n2, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, s, false>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n1, true>)
-  ASIO_TEST_CASE5(test_can_prefer<ex_fq_nr<n2, s, n2>, n2, true>)
-
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, s, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n1, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<s, n2, n2>, n2, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n1, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n1, s, n1>, n2, n1>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n1, n2>)
-  ASIO_TEST_CASE5(test_prefer<ex_fq_nr<n2, s, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_mq_mr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_mq_mr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, s, true>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_query<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, s, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, s, n2>)
-  ASIO_TEST_CASE4(test_query<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n1>, n2, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n1, false>)
-  ASIO_TEST_CASE4(test_can_require<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_require<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n1, n2>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n1>, n2, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, s, false>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n1, true>)
-  ASIO_TEST_CASE4(test_can_prefer<ex_fq_fr<n2, n2>, n2, true>)
-
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n1>, n2, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n1, n2>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n1, n1>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n1>, n2, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n1, n2>)
-  ASIO_TEST_CASE4(test_prefer<ex_fq_fr<n2, n2>, n2, n2>)
-
-  ASIO_TEST_CASE(test_vars)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution_context.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution_context.cpp
deleted file mode 100644
index cf5a499..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/execution_context.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// execution_context.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/execution_context.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "execution_context",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor.cpp
deleted file mode 100644
index 7ea7505..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// executor.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/executor.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "executor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor_work_guard.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor_work_guard.cpp
deleted file mode 100644
index 5d7aecd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/executor_work_guard.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// executor_work_guard.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/executor_work_guard.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "executor_work_guard",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/.gitignore
deleted file mode 100644
index c1a6991..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/.gitignore
+++ /dev/null
@@ -1,18 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-awaitable_operators
-basic_channel
-basic_concurrent_channel
-channel
-channel_traits
-co_composed
-concurrent_channel
-parallel_group
-promise
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/awaitable_operators.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/awaitable_operators.cpp
deleted file mode 100644
index e79eeae..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/awaitable_operators.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-//
-// experimental/awaitable_operators.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/experimental/awaitable_operators.hpp"
-
-#include "asio/co_spawn.hpp"
-#include "asio/detached.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "../unit_test.hpp"
-
-using asio::awaitable;
-using namespace asio::experimental::awaitable_operators;
-
-struct move_only
-{
-  move_only(int i) : value(i) {}
-  move_only(const move_only&) = delete;
-  move_only(move_only&&) {}
-  move_only& operator=(const move_only&) = delete;
-  move_only& operator=(move_only&&) { return *this; }
-  int value;
-};
-
-awaitable<void> void_ok()
-{
-  co_return;
-}
-
-awaitable<void> void_ex()
-{
-  throw std::runtime_error("exception");
-  co_return;
-}
-
-awaitable<void> void_post_loop()
-{
-  for (;;)
-    co_await asio::post(asio::use_awaitable);
-}
-
-awaitable<int> int_0()
-{
-  co_return 0;
-}
-
-awaitable<int> int_1()
-{
-  co_return 1;
-}
-
-awaitable<int> int_2()
-{
-  co_return 2;
-}
-
-awaitable<int> int_ex()
-{
-  throw std::runtime_error("exception");
-  co_return -1;
-}
-
-awaitable<move_only> move_only_0()
-{
-  co_return move_only(0);
-}
-
-awaitable<move_only> move_only_1()
-{
-  co_return move_only(1);
-}
-
-awaitable<move_only> move_only_2()
-{
-  co_return move_only(2);
-}
-
-awaitable<move_only> move_only_ex()
-{
-  throw std::runtime_error("exception");
-  co_return move_only(-1);
-}
-
-awaitable<void> do_test_and_awaitable_operator()
-{
-  int i;
-  std::tuple<int, int> ii;
-  std::tuple<int, int, int> iii;
-
-  co_await (void_ok() && void_ok());
-  co_await (void_ok() && void_ok() && void_ok());
-  try { co_await (void_ex() && void_ok()); } catch (...) {}
-  try { co_await (void_ex() && void_ok() && void_ok()); } catch (...) {}
-  try { co_await (void_ex() && void_post_loop()); } catch (...) {}
-  try { co_await (void_ex() && void_ok() && void_post_loop()); } catch (...) {}
-
-  i = co_await (void_ok() && int_0());
-  ASIO_CHECK(i == 0);
-
-  i = co_await (void_ok() && int_1());
-  ASIO_CHECK(i == 1);
-
-  i = co_await (int_0() && void_ok());
-  ASIO_CHECK(i == 0);
-
-  ii = co_await (int_0() && int_1());
-  ASIO_CHECK(std::get<0>(ii) == 0);
-  ASIO_CHECK(std::get<1>(ii) == 1);
-
-  i = co_await (void_ok() && void_ok() && int_0());
-  ASIO_CHECK(i == 0);
-
-  i = co_await (void_ok() && int_0() && void_ok());
-  ASIO_CHECK(i == 0);
-
-  ii = co_await (void_ok() && int_0() && int_1());
-  ASIO_CHECK(std::get<0>(ii) == 0);
-  ASIO_CHECK(std::get<1>(ii) == 1);
-
-  ii = co_await (int_0() && void_ok() && int_1());
-  ASIO_CHECK(std::get<0>(ii) == 0);
-  ASIO_CHECK(std::get<1>(ii) == 1);
-
-  iii = co_await (int_0() && int_1() && int_2());
-  ASIO_CHECK(std::get<0>(iii) == 0);
-  ASIO_CHECK(std::get<1>(iii) == 1);
-  ASIO_CHECK(std::get<2>(iii) == 2);
-}
-
-void test_and_awaitable_operator()
-{
-  asio::io_context ctx;
-  co_spawn(ctx, do_test_and_awaitable_operator(), asio::detached);
-  ctx.run();
-}
-
-awaitable<void> do_test_or_awaitable_operator()
-{
-  std::variant<int, int> ii;
-  std::variant<int, std::monostate> iv;
-  std::variant<std::monostate, int> vi;
-  std::variant<std::monostate, std::monostate> vv;
-  std::variant<int, int, int> iii;
-  std::variant<int, int, std::monostate> iiv;
-  std::variant<int, std::monostate, int> ivi;
-  std::variant<int, std::monostate, std::monostate> ivv;
-  std::variant<std::monostate, int, int> vii;
-  std::variant<std::monostate, int, std::monostate> viv;
-  std::variant<std::monostate, std::monostate, int> vvi;
-  std::variant<std::monostate, std::monostate, std::monostate> vvv;
-
-  vv = co_await (void_ok() || void_ok());
-  ASIO_CHECK(vv.index() == 0);
-
-  vv = co_await (void_ex() || void_ok());
-  ASIO_CHECK(vv.index() == 1);
-
-  vi = co_await (void_ok() || int_0());
-  ASIO_CHECK(vi.index() == 0);
-
-  vi = co_await (void_ex() || int_0());
-  ASIO_CHECK(vi.index() == 1);
-
-  iv = co_await (int_0() || void_ex());
-  ASIO_CHECK(iv.index() == 0);
-  ASIO_CHECK(std::get<0>(iv) == 0);
-
-  ii = co_await (int_0() || int_1());
-  ASIO_CHECK(ii.index() == 0);
-  ASIO_CHECK(std::get<0>(ii) == 0);
-
-  ii = co_await (int_ex() || int_1());
-  ASIO_CHECK(ii.index() == 1);
-  ASIO_CHECK(std::get<1>(ii) == 1);
-
-  vvv = co_await (void_ok() || void_ok() || void_ok());
-  ASIO_CHECK(vvv.index() == 0);
-
-  vvv = co_await (void_ex() || void_ok() || void_ok());
-  ASIO_CHECK(vvv.index() == 1);
-
-  vvv = co_await (void_ex() || void_ex() || void_ok());
-  ASIO_CHECK(vvv.index() == 2);
-
-  vvi = co_await (void_ok() || void_ok() || int_0());
-  ASIO_CHECK(vvi.index() == 0);
-
-  viv = co_await (void_ok() || int_0() || void_ok());
-  ASIO_CHECK(viv.index() == 0);
-
-  viv = co_await (void_ex() || int_0() || void_ok());
-  ASIO_CHECK(viv.index() == 1);
-  ASIO_CHECK(std::get<1>(viv) == 0);
-
-  vii = co_await (void_ex() || int_0() || int_1());
-  ASIO_CHECK(vii.index() == 1);
-  ASIO_CHECK(std::get<1>(vii) == 0);
-
-  ivv = co_await (int_0() || void_ok() || void_ok());
-  ASIO_CHECK(ivv.index() == 0);
-  ASIO_CHECK(std::get<0>(ivv) == 0);
-
-  ivv = co_await (int_ex() || void_ok() || void_ok());
-  ASIO_CHECK(ivv.index() == 1);
-
-  ivi = co_await (int_0() || void_ok() || int_1());
-  ASIO_CHECK(ivi.index() == 0);
-  ASIO_CHECK(std::get<0>(ivi) == 0);
-
-  ivi = co_await (int_ex() || void_ok() || int_1());
-  ASIO_CHECK(ivi.index() == 1);
-
-  iiv = co_await (int_0() || int_1() || void_ok());
-  ASIO_CHECK(iiv.index() == 0);
-  ASIO_CHECK(std::get<0>(iiv) == 0);
-
-  iiv = co_await (int_ex() || int_1() || void_ok());
-  ASIO_CHECK(iiv.index() == 1);
-  ASIO_CHECK(std::get<0>(iiv) == 1);
-
-  iiv = co_await (int_ex() || int_ex() || void_ok());
-  ASIO_CHECK(iiv.index() == 2);
-
-  iii = co_await (int_0() || int_1() || int_2());
-  ASIO_CHECK(iii.index() == 0);
-  ASIO_CHECK(std::get<0>(iii) == 0);
-
-  iii = co_await (int_ex() || int_1() || int_2());
-  ASIO_CHECK(iii.index() == 1);
-  ASIO_CHECK(std::get<1>(iii) == 1);
-
-  iii = co_await (int_ex() || int_ex() || int_2());
-  ASIO_CHECK(iii.index() == 2);
-  ASIO_CHECK(std::get<2>(iii) == 2);
-
-  std::variant<move_only, int> mi = co_await (move_only_0() || int_1());
-  ASIO_CHECK(mi.index() == 0);
-  ASIO_CHECK(std::get<0>(mi).value == 0);
-
-  mi = co_await (move_only_ex() || int_1());
-  ASIO_CHECK(mi.index() == 1);
-  ASIO_CHECK(std::get<1>(mi) == 1);
-
-  std::variant<move_only, move_only> mm =
-    co_await (move_only_0() || move_only_1());
-  ASIO_CHECK(mm.index() == 0);
-  ASIO_CHECK(std::get<0>(mm).value == 0);
-
-  mm = co_await (move_only_ex() || move_only_1());
-  ASIO_CHECK(mm.index() == 1);
-  ASIO_CHECK(std::get<1>(mm).value == 1);
-
-  std::variant<move_only, move_only, move_only> mmm =
-    co_await (move_only_0() || move_only_1() || move_only_2());
-  ASIO_CHECK(mmm.index() == 0);
-  ASIO_CHECK(std::get<0>(mmm).value == 0);
-
-  mmm = co_await (move_only_ex() || move_only_1() || move_only_2());
-  ASIO_CHECK(mmm.index() == 1);
-  ASIO_CHECK(std::get<1>(mmm).value == 1);
-
-  mmm = co_await (move_only_ex() || move_only_ex() || move_only_2());
-  ASIO_CHECK(mmm.index() == 2);
-  ASIO_CHECK(std::get<2>(mmm).value == 2);
-}
-
-void test_or_awaitable_operator()
-{
-  asio::io_context ctx;
-  co_spawn(ctx, do_test_or_awaitable_operator(), asio::detached);
-  ctx.run();
-}
-
-ASIO_TEST_SUITE
-(
-  "experimental/awaitable_operators",
-  ASIO_TEST_CASE(test_and_awaitable_operator)
-  ASIO_TEST_CASE(test_or_awaitable_operator)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_channel.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_channel.cpp
deleted file mode 100644
index a277efe..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_channel.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// experimental/basic_channel.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/basic_channel.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/basic_channel",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_concurrent_channel.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_concurrent_channel.cpp
deleted file mode 100644
index 413d187..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/basic_concurrent_channel.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// experimental/basic_concurrent_channel.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/basic_concurrent_channel.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/basic_concurrent_channel",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel.cpp
deleted file mode 100644
index 6c5b67f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel.cpp
+++ /dev/null
@@ -1,888 +0,0 @@
-//
-// experimental/channel.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/channel.hpp"
-
-#include <utility>
-#include "asio/any_completion_handler.hpp"
-#include "asio/bind_executor.hpp"
-#include "asio/bind_immediate_executor.hpp"
-#include "asio/error.hpp"
-#include "asio/io_context.hpp"
-#include "asio/system_executor.hpp"
-#include "../unit_test.hpp"
-
-using namespace asio;
-using namespace asio::experimental;
-
-void unbuffered_channel_test()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send(asio::error::eof, "hello");
-
-  ASIO_CHECK(!b1);
-
-  std::string s1 = "abcdefghijklmnopqrstuvwxyz";
-  bool b2 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(!b2);
-  ASIO_CHECK(!s1.empty());
-
-  asio::error_code ec1;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s2 = std::move(s);
-      });
-
-  bool b3 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(b3);
-  ASIO_CHECK(s1.empty());
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s2 == "abcdefghijklmnopqrstuvwxyz");
-
-  bool b4 = ch1.try_receive([](asio::error_code, std::string){});
-
-  ASIO_CHECK(!b4);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s3 = "zyxwvutsrqponmlkjihgfedcba";
-  ch1.async_send(asio::error::eof, std::move(s3),
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  asio::error_code ec3;
-  std::string s4;
-  bool b5 = ch1.try_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec3 = ec;
-        s4 = s;
-      });
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec3 == asio::error::eof);
-  ASIO_CHECK(s4 == "zyxwvutsrqponmlkjihgfedcba");
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec2);
-}
-
-void buffered_channel_test()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send(asio::error::eof, "hello");
-
-  ASIO_CHECK(b1);
-
-  std::string s1 = "abcdefghijklmnopqrstuvwxyz";
-  bool b2 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(!b2);
-  ASIO_CHECK(!s1.empty());
-
-  asio::error_code ec1;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s2 = std::move(s);
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s2 == "hello");
-
-  bool b4 = ch1.try_receive([](asio::error_code, std::string){});
-
-  ASIO_CHECK(!b4);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s3 = "zyxwvutsrqponmlkjihgfedcba";
-  ch1.async_send(asio::error::eof, std::move(s3),
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  asio::error_code ec3;
-  std::string s4;
-  bool b5 = ch1.try_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec3 = ec;
-        s4 = s;
-      });
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec3 == asio::error::eof);
-  ASIO_CHECK(s4 == "zyxwvutsrqponmlkjihgfedcba");
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec2);
-
-  bool b6 = ch1.try_send(asio::error_code(), "goodbye");
-
-  ASIO_CHECK(b6);
-
-  ch1.close();
-
-  asio::error_code ec4;
-  std::string s5;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec4 = ec;
-        s5 = std::move(s);
-      });
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec4);
-  ASIO_CHECK(s5 == "goodbye");
-
-  asio::error_code ec5;
-  std::string s6;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec5 = ec;
-        s6 = std::move(s);
-      });
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec5 == asio::experimental::channel_errc::channel_closed);
-  ASIO_CHECK(s6.empty());
-}
-
-void buffered_error_channel_test()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code)> ch1(ctx, 1);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send(asio::error::eof);
-
-  ASIO_CHECK(b1);
-
-  bool b2 = ch1.try_send(asio::error::eof);
-
-  ASIO_CHECK(!b2);
-
-  asio::error_code ec1;
-  ch1.async_receive(
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-
-  bool b4 = ch1.try_receive([](asio::error_code){});
-
-  ASIO_CHECK(!b4);
-
-  asio::error_code ec2 = asio::error::would_block;
-  ch1.async_send(asio::error::eof,
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  asio::error_code ec3;
-  bool b5 = ch1.try_receive(
-      [&](asio::error_code ec)
-      {
-        ec3 = ec;
-      });
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec3 == asio::error::eof);
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec2);
-}
-
-void unbuffered_non_immediate_receive()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec2 = ec;
-        s2 = std::move(s);
-      });
-
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-}
-
-void unbuffered_immediate_receive()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      bind_immediate_executor(system_executor(),
-        [&](asio::error_code ec, std::string s)
-        {
-          ec2 = ec;
-          s2 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-}
-
-void unbuffered_executor_receive()
-{
-  io_context ctx;
-  io_context ctx2;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      bind_executor(ctx2,
-        [&](asio::error_code ec, std::string s)
-        {
-          ec2 = ec;
-          s2 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx2.run();
-
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-}
-
-void unbuffered_non_immediate_send()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s1 = std::move(s);
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s2),
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "0123456789");
-  ASIO_CHECK(!ec2);
-}
-
-void unbuffered_immediate_send()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s1 = std::move(s);
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s2),
-      bind_immediate_executor(system_executor(),
-        [&](asio::error_code ec)
-        {
-          ec2 = ec;
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(!ec2);
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "0123456789");
-}
-
-void unbuffered_executor_send()
-{
-  io_context ctx;
-  io_context ctx2;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s1 = std::move(s);
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s2),
-      bind_executor(ctx2,
-        [&](asio::error_code ec)
-        {
-          ec2 = ec;
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "0123456789");
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx2.run();
-
-  ASIO_CHECK(!ec2);
-}
-
-void buffered_non_immediate_receive()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec2 = ec;
-        s2 = std::move(s);
-      });
-
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-}
-
-void buffered_immediate_receive()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      bind_immediate_executor(system_executor(),
-        [&](asio::error_code ec, std::string s)
-        {
-          ec2 = ec;
-          s2 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-
-  ctx.restart();
-  ctx.run();
-}
-
-void buffered_executor_receive()
-{
-  io_context ctx;
-  io_context ctx2;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      bind_executor(ctx2,
-        [&](asio::error_code ec, std::string s)
-        {
-          ec2 = ec;
-          s2 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx2.run();
-
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-}
-
-void buffered_non_immediate_send()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      [&](asio::error_code ec)
-      {
-        ec1 = ec;
-      });
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(!ec1);
-}
-
-void buffered_immediate_send()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      bind_immediate_executor(system_executor(),
-        [&](asio::error_code ec)
-        {
-          ec1 = ec;
-        }));
-
-  ASIO_CHECK(!ec1);
-
-  ctx.run();
-}
-
-void buffered_executor_send()
-{
-  io_context ctx;
-  io_context ctx2;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1 = "0123456789";
-  ch1.async_send(asio::error::eof, std::move(s1),
-      bind_executor(ctx2,
-        [&](asio::error_code ec)
-        {
-          ec1 = ec;
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx2.run();
-
-  ASIO_CHECK(!ec1);
-}
-
-void try_send_via_dispatch()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      bind_executor(asio::system_executor(),
-        [&](asio::error_code ec, std::string s)
-        {
-          ec1 = ec;
-          s1 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.poll();
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  std::string s2 = "0123456789";
-  ch1.try_send_via_dispatch(asio::error::eof, std::move(s2));
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "0123456789");
-  ASIO_CHECK(s2.empty());
-}
-
-void try_send_n_via_dispatch()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      bind_executor(asio::system_executor(),
-        [&](asio::error_code ec, std::string s)
-        {
-          ec1 = ec;
-          s1 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2;
-  ch1.async_receive(
-      bind_executor(asio::system_executor(),
-        [&](asio::error_code ec, std::string s)
-        {
-          ec2 = ec;
-          s2 = std::move(s);
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  ctx.poll();
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  std::string s3 = "0123456789";
-  ch1.try_send_n_via_dispatch(2, asio::error::eof, std::move(s3));
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "0123456789");
-  ASIO_CHECK(ec2 == asio::error::eof);
-  ASIO_CHECK(s2 == "0123456789");
-  ASIO_CHECK(s3.empty());
-}
-
-struct multi_signature_handler
-{
-  std::string* s_;
-  asio::error_code* ec_;
-
-  void operator()(std::string s)
-  {
-    *s_ = s;
-  }
-
-  void operator()(asio::error_code ec)
-  {
-    *ec_ = ec;
-  }
-};
-
-void implicit_error_signature_channel_test()
-{
-  io_context ctx;
-
-  channel<void(std::string)> ch1(ctx);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send("hello");
-
-  ASIO_CHECK(!b1);
-
-  std::string s1 = "abcdefghijklmnopqrstuvwxyz";
-  bool b2 = ch1.try_send(std::move(s1));
-
-  ASIO_CHECK(!b2);
-  ASIO_CHECK(!s1.empty());
-
-  std::string s2;
-  asio::error_code ec1 = asio::error::would_block;
-  multi_signature_handler h1 = {&s2, &ec1};
-  ch1.async_receive(h1);
-
-  bool b3 = ch1.try_send(std::move(s1));
-
-  ASIO_CHECK(b3);
-  ASIO_CHECK(s1.empty());
-
-  ctx.run();
-
-  ASIO_CHECK(s2 == "abcdefghijklmnopqrstuvwxyz");
-  ASIO_CHECK(ec1 == asio::error::would_block);
-
-  std::string s3;
-  asio::error_code ec2;
-  multi_signature_handler h2 = {&s3, &ec2};
-  bool b4 = ch1.try_receive(h2);
-
-  ASIO_CHECK(!b4);
-
-  std::string s4 = "zyxwvutsrqponmlkjihgfedcba";
-  asio::error_code ec3;
-  ch1.async_send(std::move(s4),
-      [&](asio::error_code ec)
-      {
-        ec3 = ec;
-      });
-
-  std::string s5;
-  asio::error_code ec4 = asio::error::would_block;
-  multi_signature_handler h3 = {&s5, &ec4};
-  bool b5 = ch1.try_receive(h3);
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec4 == asio::error::would_block);
-  ASIO_CHECK(s5 == "zyxwvutsrqponmlkjihgfedcba");
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec3);
-
-  std::string s6;
-  asio::error_code ec5 = asio::error::would_block;
-  multi_signature_handler h4 = {&s6, &ec5};
-  ch1.async_receive(h4);
-
-  ch1.close();
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(s6.empty());
-  ASIO_CHECK(ec5 == asio::experimental::channel_errc::channel_closed);
-}
-
-void channel_with_any_completion_handler_test()
-{
-  io_context ctx;
-
-  channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  asio::error_code ec1 = asio::error::would_block;
-  std::string s1;
-  ch1.async_receive(
-      asio::any_completion_handler<
-        void(asio::error_code, std::string)>(
-          [&](asio::error_code ec, std::string s)
-          {
-            ec1 = ec;
-            s1 = std::move(s);
-          }));
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s2 = "zyxwvutsrqponmlkjihgfedcba";
-  ch1.async_send(asio::error::eof, std::move(s2),
-      asio::any_completion_handler<void(asio::error_code)>(
-        [&](asio::error_code ec)
-        {
-          ec2 = ec;
-        }));
-
-  ASIO_CHECK(ec1 == asio::error::would_block);
-  ASIO_CHECK(ec2 == asio::error::would_block);
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s1 == "zyxwvutsrqponmlkjihgfedcba");
-  ASIO_CHECK(!ec2);
-}
-
-ASIO_TEST_SUITE
-(
-  "experimental/channel",
-  ASIO_TEST_CASE(unbuffered_channel_test)
-  ASIO_TEST_CASE(buffered_channel_test)
-  ASIO_TEST_CASE(buffered_error_channel_test)
-  ASIO_TEST_CASE(unbuffered_non_immediate_receive)
-  ASIO_TEST_CASE(unbuffered_immediate_receive)
-  ASIO_TEST_CASE(unbuffered_executor_receive)
-  ASIO_TEST_CASE(unbuffered_non_immediate_send)
-  ASIO_TEST_CASE(unbuffered_immediate_send)
-  ASIO_TEST_CASE(unbuffered_executor_send)
-  ASIO_TEST_CASE(buffered_non_immediate_receive)
-  ASIO_TEST_CASE(buffered_immediate_receive)
-  ASIO_TEST_CASE(buffered_executor_receive)
-  ASIO_TEST_CASE(buffered_non_immediate_send)
-  ASIO_TEST_CASE(buffered_immediate_send)
-  ASIO_TEST_CASE(buffered_executor_send)
-  ASIO_TEST_CASE(try_send_via_dispatch)
-  ASIO_TEST_CASE(try_send_n_via_dispatch)
-  ASIO_TEST_CASE(implicit_error_signature_channel_test)
-  ASIO_TEST_CASE(channel_with_any_completion_handler_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel_traits.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel_traits.cpp
deleted file mode 100644
index b1c326f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/channel_traits.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// experimental/channel_traits.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/channel_traits.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/channel_traits",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/co_composed.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/co_composed.cpp
deleted file mode 100644
index 35e475c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/co_composed.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// experimental/co_composed.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/co_composed.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/co_composed",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/concurrent_channel.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/concurrent_channel.cpp
deleted file mode 100644
index e64e905..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/concurrent_channel.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-// experimental/concurrent_channel.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/concurrent_channel.hpp"
-
-#include <utility>
-#include "asio/error.hpp"
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-
-using namespace asio;
-using namespace asio::experimental;
-
-void unbuffered_concurrent_channel_test()
-{
-  io_context ctx;
-
-  concurrent_channel<void(asio::error_code, std::string)> ch1(ctx);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send(asio::error::eof, "hello");
-
-  ASIO_CHECK(!b1);
-
-  std::string s1 = "abcdefghijklmnopqrstuvwxyz";
-  bool b2 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(!b2);
-  ASIO_CHECK(!s1.empty());
-
-  asio::error_code ec1;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s2 = std::move(s);
-      });
-
-  bool b3 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(b3);
-  ASIO_CHECK(s1.empty());
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s2 == "abcdefghijklmnopqrstuvwxyz");
-
-  bool b4 = ch1.try_receive([](asio::error_code, std::string){});
-
-  ASIO_CHECK(!b4);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s3 = "zyxwvutsrqponmlkjihgfedcba";
-  ch1.async_send(asio::error::eof, std::move(s3),
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  asio::error_code ec3;
-  std::string s4;
-  bool b5 = ch1.try_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec3 = ec;
-        s4 = s;
-      });
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec3 == asio::error::eof);
-  ASIO_CHECK(s4 == "zyxwvutsrqponmlkjihgfedcba");
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec2);
-};
-
-void buffered_concurrent_channel_test()
-{
-  io_context ctx;
-
-  concurrent_channel<void(asio::error_code, std::string)> ch1(ctx, 1);
-
-  ASIO_CHECK(ch1.is_open());
-  ASIO_CHECK(!ch1.ready());
-
-  bool b1 = ch1.try_send(asio::error::eof, "hello");
-
-  ASIO_CHECK(b1);
-
-  std::string s1 = "abcdefghijklmnopqrstuvwxyz";
-  bool b2 = ch1.try_send(asio::error::eof, std::move(s1));
-
-  ASIO_CHECK(!b2);
-  ASIO_CHECK(!s1.empty());
-
-  asio::error_code ec1;
-  std::string s2;
-  ch1.async_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec1 = ec;
-        s2 = std::move(s);
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(ec1 == asio::error::eof);
-  ASIO_CHECK(s2 == "hello");
-
-  bool b4 = ch1.try_receive([](asio::error_code, std::string){});
-
-  ASIO_CHECK(!b4);
-
-  asio::error_code ec2 = asio::error::would_block;
-  std::string s3 = "zyxwvutsrqponmlkjihgfedcba";
-  ch1.async_send(asio::error::eof, std::move(s3),
-      [&](asio::error_code ec)
-      {
-        ec2 = ec;
-      });
-
-  asio::error_code ec3;
-  std::string s4;
-  bool b5 = ch1.try_receive(
-      [&](asio::error_code ec, std::string s)
-      {
-        ec3 = ec;
-        s4 = s;
-      });
-
-  ASIO_CHECK(b5);
-  ASIO_CHECK(ec3 == asio::error::eof);
-  ASIO_CHECK(s4 == "zyxwvutsrqponmlkjihgfedcba");
-
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(!ec2);
-};
-
-ASIO_TEST_SUITE
-(
-  "experimental/concurrent_channel",
-  ASIO_TEST_CASE(unbuffered_concurrent_channel_test)
-  ASIO_TEST_CASE(buffered_concurrent_channel_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/.gitignore
deleted file mode 100644
index 89cfade..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/.gitignore
+++ /dev/null
@@ -1,16 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-allocator
-cancel
-exception
-partial
-simple_test
-stack_test
-use_coro
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/allocator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/allocator.cpp
deleted file mode 100644
index a2aa8e5..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/allocator.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// experimental/coro/partial.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include <vector>
-#include "asio/io_context.hpp"
-#include "../../unit_test.hpp"
-
-namespace exp =  asio::experimental;
-
-namespace coro {
-
-template<typename Value = void>
-struct tracked_allocator
-{
-  using value_type = Value;
-  std::vector<std::pair<void*, std::size_t>> &allocs, &deallocs;
-
-  tracked_allocator(std::vector<std::pair<void*, std::size_t>>& allocs,
-                    std::vector<std::pair<void*, std::size_t>>& deallocs) : allocs(allocs), deallocs(deallocs) {}
-
-  template<typename T>
-  tracked_allocator(const tracked_allocator<T>& a) : allocs(a.allocs), deallocs(a.deallocs) {}
-
-  value_type* allocate(std::size_t n)
-  {
-    auto p = new char[n * sizeof(Value)];
-    allocs.emplace_back(p, n);
-    return reinterpret_cast<value_type*>(p);
-  }
-
-  void deallocate(void* p, std::size_t n)
-  {
-    deallocs.emplace_back(p, n);
-    delete[] static_cast<char*>(p);
-//    ASIO_CHECK(allocs.back() == deallocs.back());
-  }
-
-  bool operator==(const tracked_allocator& rhs) const
-  {
-    return &allocs == &rhs.allocs
-           && &deallocs == &rhs.deallocs;
-  }
-};
-
-exp::coro<void, void, asio::any_io_executor, tracked_allocator<void>>
-        alloc_test_impl(asio::io_context& ctx, int, std::allocator_arg_t, tracked_allocator<void> ta, double)
-{
-  co_return ;
-}
-
-void alloc_test()
-{
-  std::vector<std::pair<void*, std::size_t>> allocs, deallocs;
-  asio::io_context ctx;
-  bool ran = false;
-
-  {
-    auto pp = alloc_test_impl(ctx, 42, std::allocator_arg, {allocs, deallocs}, 42.);
-
-    ASIO_CHECK(allocs.size()  == 1u);
-    ASIO_CHECK(deallocs.empty());
-
-    pp.async_resume([&](auto e){ran = true; ASIO_CHECK(!e);});
-    ctx.run();
-    ASIO_CHECK(deallocs.size() == 0u);
-  }
-  ctx.restart();
-  ctx.run();
-  ASIO_CHECK(deallocs.size() == 1u);
-  ASIO_CHECK(allocs == deallocs);
-
-  ASIO_CHECK(ran);
-
-  ran = false;
-
-  auto p = asio::experimental::detail::post_coroutine(
-          ctx,
-          asio::bind_allocator(tracked_allocator{allocs, deallocs}, [&]{ran = true;})).handle;
-  ASIO_CHECK(allocs.size()  == 2u);
-  ASIO_CHECK(deallocs.size() == 1u);
-  p.resume();
-  ASIO_CHECK(allocs.size()  == 3u);
-  ASIO_CHECK(deallocs.size() == 2u);
-  ctx.restart();
-  ctx.run();
-
-  ASIO_CHECK(allocs == deallocs);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/allocate",
-  ASIO_TEST_CASE(::coro::alloc_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/cancel.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/cancel.cpp
deleted file mode 100644
index 31136ed..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/cancel.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-//
-// experimental/coro/cancel.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-#include <iostream>
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/this_coro.hpp"
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-namespace this_coro = asio::this_coro;
-
-namespace coro {
-
-auto coro_simple_cancel_impl(asio::io_context& ) noexcept
-  -> asio::experimental::coro<void() noexcept, asio::error_code>
-{
-    ASIO_CHECK(
-        !(co_await this_coro::cancellation_state).cancelled());
-
-    asio::steady_timer timer{
-        co_await this_coro::executor,
-        std::chrono::seconds(1)};
-
-    ASIO_CHECK(
-        !(co_await this_coro::cancellation_state).cancelled());
-
-    auto ec = co_await timer;
-
-    ASIO_CHECK(
-        (co_await this_coro::cancellation_state).cancelled());
-
-    co_return ec;
-}
-
-void coro_simple_cancel()
-{
-  asio::io_context ctx;
-  asio::cancellation_signal sig;
-
-  auto k = coro_simple_cancel_impl(ctx);
-
-  asio::error_code res_ec;
-  k.async_resume(
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](asio::error_code ec) {res_ec = ec;}));
-  asio::post(ctx, [&]{sig.emit(asio::cancellation_type::all);});
-
-  ASIO_CHECK(!res_ec);
-
-  ctx.run();
-
-  ASIO_CHECK(res_ec == asio::error::operation_aborted);
-}
-
-auto coro_throw_cancel_impl(asio::io_context& )
-  -> asio::experimental::coro<void() , void>
-{
-    asio::steady_timer timer{
-        co_await this_coro::executor,
-        std::chrono::seconds(1)};
-    co_await timer;
-}
-
-void coro_throw_cancel()
-{
-  asio::io_context ctx;
-  asio::cancellation_signal sig;
-
-  auto k = coro_throw_cancel_impl(ctx);
-
-  std::exception_ptr res_ex;
-  k.async_resume(
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](std::exception_ptr ex) {res_ex = ex;}));
-  asio::post(ctx, [&]{sig.emit(asio::cancellation_type::all);});
-
-  ASIO_CHECK(!res_ex);
-
-  ctx.run();
-
-  ASIO_CHECK(res_ex);
-  try
-  {
-    if (res_ex)
-      std::rethrow_exception(res_ex);
-  }
-  catch (asio::system_error& se)
-  {
-    ASIO_CHECK(se.code() == asio::error::operation_aborted);
-  }
-}
-
-auto coro_simple_cancel_nested_k(asio::io_context&, int& cnt) noexcept
-  -> asio::experimental::coro<
-      void() noexcept,
-      asio::error_code>
-{
-  asio::steady_timer timer{
-          co_await this_coro::executor,
-          std::chrono::milliseconds(100)};
-
-  ASIO_CHECK(!(co_await this_coro::cancellation_state).cancelled());
-  auto ec = co_await timer;
-  cnt++;
-  ASIO_CHECK((co_await this_coro::cancellation_state).cancelled());
-
-  co_return ec;
-}
-
-auto coro_simple_cancel_nested_kouter(
-    asio::io_context& ctx, int& cnt) noexcept
-  -> asio::experimental::coro<
-      asio::error_code() noexcept,
-      asio::error_code>
-{
-    ASIO_CHECK(cnt == 0);
-    co_yield co_await coro_simple_cancel_nested_k(ctx, cnt);
-    ASIO_CHECK(cnt == 1);
-    auto ec = co_await coro_simple_cancel_nested_k(ctx, cnt);
-    ASIO_CHECK(cnt == 2);
-    co_return ec;
-}
-
-void coro_simple_cancel_nested()
-{
-  asio::io_context ctx;
-  asio::cancellation_signal sig;
-
-  int cnt = 0;
-  auto kouter = coro_simple_cancel_nested_kouter(ctx, cnt);
-
-  asio::error_code res_ec;
-  kouter.async_resume(
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](asio::error_code ec) {res_ec = ec;}));
-  asio::post(ctx, [&]{sig.emit(asio::cancellation_type::all);});
-  ASIO_CHECK(!res_ec);
-  ctx.run();
-  ASIO_CHECK(res_ec == asio::error::operation_aborted);
-
-  ctx.restart();
-  res_ec = {};
-  kouter.async_resume(
-      asio::bind_cancellation_slot(sig.slot(),
-        [&](asio::error_code ec) {res_ec = ec;}));
-  asio::post(ctx, [&]{sig.emit(asio::cancellation_type::all);});
-  ASIO_CHECK(!res_ec);
-  ctx.run();
-  ASIO_CHECK(res_ec == asio::error::operation_aborted);
-  ASIO_CHECK(cnt == 2);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/cancel",
-  ASIO_TEST_CASE(::coro::coro_simple_cancel)
-  ASIO_TEST_CASE(::coro::coro_throw_cancel)
-  ASIO_TEST_CASE(::coro::coro_simple_cancel_nested)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/co_spawn.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/co_spawn.cpp
deleted file mode 100644
index 8e65862..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/co_spawn.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-//
-// experimental/coro/co_spawn.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/co_spawn.hpp"
-
-#include <iostream>
-#include "asio/io_context.hpp"
-#include "asio/steady_timer.hpp"
-#include "asio/this_coro.hpp"
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-namespace this_coro = asio::this_coro;
-
-namespace coro {
-
-auto coro_simple_co_spawn_impl(asio::io_context& , bool &done) noexcept
-  -> asio::experimental::coro<void() noexcept, int>
-{
-  asio::steady_timer timer(
-      co_await this_coro::executor,
-      std::chrono::milliseconds(10));
-
-  done = true;
-
-  co_return 42;
-}
-
-void coro_co_spawn()
-{
-  asio::io_context ctx;
-
-  bool done1 = false;
-  bool done2 = false;
-  int res = 0;
-
-  co_spawn(coro_simple_co_spawn_impl(ctx, done1),
-      [&](int r){done2= true;  res = r;});
-
-  ctx.run();
-
-  ASIO_CHECK(done1);
-  ASIO_CHECK(done2);
-  ASIO_CHECK(res == 42);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/co_spawn",
-  ASIO_TEST_CASE(::coro::coro_co_spawn)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/exception.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/exception.cpp
deleted file mode 100644
index e9fe5c8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/exception.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//
-// experimental/coro/exception.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include "asio/co_spawn.hpp"
-#include "asio/detached.hpp"
-#include "asio/io_context.hpp"
-#include "asio/use_awaitable.hpp"
-#include "asio/awaitable.hpp"
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace coro {
-
-template <typename Func>
-struct on_scope_exit
-{
-	Func func;
-
-  static_assert(noexcept(func()));
-
-  on_scope_exit(const Func &f)
-    : func(static_cast< Func && >(f))
-	{
-	}
-
-	on_scope_exit(Func &&f)
-    : func(f)
-	{
-	}
-
-  on_scope_exit(const on_scope_exit &) = delete;
-
-	~on_scope_exit()
-  {
-    func();
-  }
-};
-
-asio::experimental::coro<int> throwing_generator(
-  asio::any_io_executor, int &last, bool &destroyed)
-{
-  on_scope_exit x = [&]() noexcept { destroyed = true; };
-  (void)x;
-
-  int i = 0;
-  while (i < 3)
-  {
-    last = ++i;
-    co_yield last;
-  }
-
-  throw std::runtime_error("throwing-generator");
-}
-
-asio::awaitable<void> throwing_generator_test()
-{
-  int val = 0;
-  bool destr = false;
-  {
-    auto gi = throwing_generator(
-        co_await asio::this_coro::executor,
-        val, destr);
-    bool caught = false;
-    try
-    {
-      for (int i = 0; i < 10; i++)
-      {
-        ASIO_CHECK(val == i);
-        const auto next = co_await gi.async_resume(asio::use_awaitable);
-        ASIO_CHECK(next);
-        ASIO_CHECK(val == *next);
-        ASIO_CHECK(val == i + 1);
-      }
-    }
-    catch (std::runtime_error &err)
-    {
-      caught = true;
-      using std::operator ""sv;
-      ASIO_CHECK(err.what() == "throwing-generator"sv);
-    }
-    ASIO_CHECK(val == 3);
-    ASIO_CHECK(caught);
-  }
-  ASIO_CHECK(destr);
-};
-
-void run_throwing_generator_test()
-{
-  asio::io_context ctx;
-  asio::co_spawn(ctx, throwing_generator_test(), asio::detached);
-  ctx.run();
-}
-
-asio::experimental::coro<int(int)> throwing_stacked(
-    asio::any_io_executor exec, int &val,
-    bool &destroyed_inner, bool &destroyed)
-{
-  ASIO_CHECK((co_await asio::this_coro::throw_if_cancelled()));
-
-  on_scope_exit x = [&]() noexcept { destroyed = true; };
-  (void)x;
-
-  auto gen = throwing_generator(exec, val, destroyed_inner);
-  while (auto next = co_await gen) // 1, 2, 4, 8, ...
-    ASIO_CHECK(42 ==(co_yield *next)); // offset is delayed by one cycle
-}
-
-asio::awaitable<void> throwing_generator_stacked_test()
-{
-  int val = 0;
-  bool destr = false, destr_inner = false;
-  {
-    auto gi = throwing_stacked(
-        co_await asio::this_coro::executor,
-        val, destr, destr_inner);
-    bool caught = false;
-    try
-    {
-      for (int i = 0; i < 10; i++)
-      {
-        ASIO_CHECK(val == i);
-        const auto next =
-          co_await gi.async_resume(42, asio::use_awaitable);
-        ASIO_CHECK(next);
-        ASIO_CHECK(val == *next);
-        ASIO_CHECK(val == i + 1);
-      }
-    }
-    catch (std::runtime_error &err)
-    {
-      caught = true;
-      using std::operator ""sv;
-      ASIO_CHECK(err.what() == "throwing-generator"sv);
-    }
-    ASIO_CHECK(val == 3);
-    ASIO_CHECK(caught);
-  }
-  ASIO_CHECK(destr);
-  ASIO_CHECK(destr_inner);
-};
-
-void run_throwing_generator_stacked_test()
-{
-  asio::io_context ctx;
-  asio::co_spawn(ctx,
-      throwing_generator_stacked_test,
-      asio::detached);
-  ctx.run();
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/exception",
-  ASIO_TEST_CASE(::coro::run_throwing_generator_stacked_test)
-  ASIO_TEST_CASE(::coro::run_throwing_generator_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/executor.cpp
deleted file mode 100644
index e0893da..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/executor.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// experimental/coro/executor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include "asio/thread_pool.hpp"
-#include "asio/io_context.hpp"
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace coro {
-
-#define ASIO_CHECKPOINT() \
-  ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
-  << asio::detail::test_name() << ": " \
-  << "Checkpoint" << std::endl;
-
-template <typename T>
-void different_execs()
-{
-  asio::thread_pool th_ctx{1u};
-  asio::io_context ctx;
-
-  auto o = std::make_optional(
-      asio::prefer(th_ctx.get_executor(),
-        asio::execution::outstanding_work.tracked));
-
-  static bool ran_inner = false, ran_outer = false;
-
-  struct c_inner_t
-  {
-    auto operator()(asio::any_io_executor e) -> asio::experimental::coro<T>
-    {
-      auto p = e.target<asio::thread_pool::executor_type>();
-      ASIO_CHECKPOINT();
-      ASIO_CHECK(p);
-      ASIO_CHECK(p->running_in_this_thread());
-      ran_inner = true;
-      co_return;
-    };
-
-  };
-
-  c_inner_t c_inner;
-
-  struct c_outer_t
-  {
-
-    auto operator()(asio::any_io_executor e, int,
-        asio::experimental::coro<T> tp)
-      -> asio::experimental::coro<void>
-    {
-      auto p = e.target<asio::io_context::executor_type>();
-
-      ASIO_CHECK(p);
-      ASIO_CHECK(p->running_in_this_thread());
-      ASIO_CHECKPOINT();
-
-      co_await tp;
-
-      ASIO_CHECKPOINT();
-      ASIO_CHECK(p->running_in_this_thread());
-
-      ran_outer = true;
-    };
-  };
-
-  c_outer_t c_outer;
-
-  bool ran = false;
-  std::exception_ptr ex;
-
-  auto c = c_outer(ctx.get_executor(), 10, c_inner(th_ctx.get_executor()));
-  c.async_resume(
-      [&](std::exception_ptr e)
-      {
-        ASIO_CHECK(!e);
-        ASIO_CHECKPOINT();
-        ran = true;
-      });
-
-  ASIO_CHECK(!ran);
-  ctx.run();
-  o.reset();
-  ASIO_CHECK(ran);
-  ASIO_CHECK(ran_inner);
-  ASIO_CHECK(ran_outer);
-  ASIO_CHECK(!ex);
-
-  th_ctx.stop();
-  th_ctx.join();
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/partial",
-  ASIO_TEST_CASE(::coro::different_execs<void>)
-  ASIO_TEST_CASE(::coro::different_execs<int()>)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/partial.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/partial.cpp
deleted file mode 100644
index 651b829..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/partial.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// experimental/coro/partial.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include "asio/io_context.hpp"
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace coro {
-
-void partial()
-{
-  asio::io_context ctx;
-  bool ran = false;
-  auto p = detail::post_coroutine(ctx, [&]{ran = true;}).handle;
-  ASIO_CHECK(!ran);
-  p.resume();
-  ASIO_CHECK(!ran);
-  ctx.run();
-  ASIO_CHECK(ran);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/partial",
-  ASIO_TEST_CASE(::coro::partial)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/simple_test.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/simple_test.cpp
deleted file mode 100644
index 2bd4614..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/simple_test.cpp
+++ /dev/null
@@ -1,266 +0,0 @@
-//
-// experimental/coro/simple_test.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include "asio/co_spawn.hpp"
-#include "asio/detached.hpp"
-#include "asio/io_context.hpp"
-#include "asio/use_awaitable.hpp"
-#include <iostream>
-#include <vector>
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace asio {
-namespace experimental {
-
-template struct coro<void(), void, any_io_executor>;
-template struct coro<int(), void, any_io_executor>;
-template struct coro<void(), int, any_io_executor>;
-template struct coro<int(int), void, any_io_executor>;
-template struct coro<int(), int, any_io_executor>;
-template struct coro<int(int), int, any_io_executor>;
-
-template struct coro<void() noexcept, void, any_io_executor>;
-template struct coro<int() noexcept, void, any_io_executor>;
-template struct coro<void() noexcept, int, any_io_executor>;
-template struct coro<int(int) noexcept, void, any_io_executor>;
-template struct coro<int() noexcept, int, any_io_executor>;
-template struct coro<int(int) noexcept, int, any_io_executor>;
-
-} // namespace experimental
-} // namespace asio
-
-namespace coro {
-
-template <typename Func>
-struct on_scope_exit
-{
-	Func func;
-
-  static_assert(noexcept(func()));
-
-  on_scope_exit(const Func &f)
-    : func(static_cast< Func && >(f))
-	{
-	}
-
-	on_scope_exit(Func &&f)
-    : func(f)
-	{
-	}
-
-  on_scope_exit(const on_scope_exit &) = delete;
-
-	~on_scope_exit()
-  {
-    func();
-  }
-};
-
-asio::experimental::coro<int> generator_impl(
-    asio::any_io_executor, int& last, bool& destroyed)
-{
-  on_scope_exit x = [&]() noexcept { destroyed = true; };
-  (void)x;
-
-  int i = 0;
-  while (true)
-  {
-    last = ++i;
-    co_yield last;
-  }
-}
-
-asio::awaitable<void> generator_test()
-{
-  int val = 0;
-  bool destr = false;
-  {
-    auto gi = generator_impl(
-        co_await asio::this_coro::executor, val, destr);
-
-    for (int i = 0; i < 10; i++)
-    {
-      ASIO_CHECK(val == i);
-      const auto next = co_await gi.async_resume(asio::use_awaitable);
-      ASIO_CHECK(next);
-      ASIO_CHECK(val == *next);
-      ASIO_CHECK(val == i + 1);
-    }
-
-    ASIO_CHECK(!destr);
-  }
-  ASIO_CHECK(destr);
-};
-
-void run_generator_test()
-{
-  asio::io_context ctx;
-  asio::co_spawn(ctx, generator_test, asio::detached);
-  ctx.run();
-}
-
-asio::experimental::coro<void, int> task_test(asio::io_context&)
-{
-  co_return 42;
-}
-
-asio::experimental::coro<void, int> task_throw(asio::io_context&)
-{
-  throw std::logic_error(__func__);
-  co_return 42;
-}
-
-void run_task_test()
-{
-  asio::io_context ctx;
-
-  bool tt1 = false;
-  bool tt2 = false;
-  bool tt3 = false;
-  bool tt4 = false;
-  auto tt = task_test(ctx);
-  tt.async_resume(
-      [&](std::exception_ptr pt, int i)
-      {
-        tt1 = true;
-        ASIO_CHECK(!pt);
-        ASIO_CHECK(i == 42);
-        tt.async_resume(
-            [&](std::exception_ptr pt, int)
-            {
-              tt2 = true;
-              ASIO_CHECK(pt);
-            });
-      });
-
-  auto tt_2 = task_throw(ctx);
-
-  tt_2.async_resume(
-      [&](std::exception_ptr pt, int)
-      {
-        tt3 = true;
-        ASIO_CHECK(pt);
-        tt.async_resume(
-            [&](std::exception_ptr pt, int)
-            {
-              tt4 = true;
-              ASIO_CHECK(pt);
-            });
-      });
-
-  ctx.run();
-
-  ASIO_CHECK(tt1);
-  ASIO_CHECK(tt2);
-  ASIO_CHECK(tt3);
-  ASIO_CHECK(tt4);
-}
-
-asio::experimental::coro<char> completion_generator_test_impl(
-    asio::any_io_executor, int limit)
-{
-  for (int i = 0; i < limit; i++)
-    co_yield i;
-}
-
-asio::awaitable<void> completion_generator_test()
-{
-  std::vector<int> res;
-  auto g = completion_generator_test_impl(
-      co_await asio::this_coro::executor, 10);
-
-  ASIO_CHECK(g.is_open());
-  while (auto val = co_await g.async_resume(asio::use_awaitable))
-    res.push_back(*val);
-
-  ASIO_CHECK(!g.is_open());
-  ASIO_CHECK((res == std::vector{0,1,2,3,4,5,6,7,8,9}));
-}
-
-void run_completion_generator_test()
-{
-  asio::io_context ctx;
-  asio::co_spawn(ctx, completion_generator_test, asio::detached);
-  ctx.run();
-}
-
-asio::experimental::coro<int(int)>
-symmetrical_test_impl(asio::any_io_executor)
-{
-  int i = 0;
-  while (true)
-    i = (co_yield i) + i;
-}
-
-asio::awaitable<void> symmetrical_test()
-{
-  auto g = symmetrical_test_impl(co_await asio::this_coro::executor);
-
-  ASIO_CHECK(g.is_open());
-
-  ASIO_CHECK(0  == (co_await g.async_resume(0,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(1  == (co_await g.async_resume(1,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(3  == (co_await g.async_resume(2,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(6  == (co_await g.async_resume(3,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(10  == (co_await g.async_resume(4,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(15 == (co_await g.async_resume(5,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(21 == (co_await g.async_resume(6,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(28 == (co_await g.async_resume(7,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(36 == (co_await g.async_resume(8,
-          asio::use_awaitable)).value_or(-1));
-
-  ASIO_CHECK(45 == (co_await g.async_resume(9,
-          asio::use_awaitable)).value_or(-1));
-}
-
-void run_symmetrical_test()
-{
-  asio::io_context ctx;
-  asio::co_spawn(ctx, symmetrical_test, asio::detached);
-  ctx.run();
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/simple_test",
-  ASIO_TEST_CASE(::coro::run_generator_test)
-  ASIO_TEST_CASE(::coro::run_task_test)
-  ASIO_TEST_CASE(::coro::run_symmetrical_test)
-  ASIO_TEST_CASE(::coro::run_completion_generator_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/stack_test.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/stack_test.cpp
deleted file mode 100644
index 9177161..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/stack_test.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// experimental/coro/stack_test.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/coro.hpp"
-
-#include "asio/detached.hpp"
-#include "asio/io_context.hpp"
-#include <iostream>
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace coro {
-
-asio::experimental::coro<int()>
-  stack_generator(asio::any_io_executor, int i = 1)
-{
-  for (;;)
-  {
-    co_yield i;
-    i *= 2;
-  }
-}
-
-asio::experimental::coro<int(int)>
-stack_accumulate(asio::any_io_executor exec)
-{
-  auto gen  = stack_generator(exec);
-  int offset = 0;
-  while (auto next = co_await gen) // 1, 2, 4, 8, ...
-    offset  = co_yield *next + offset; // offset is delayed by one cycle
-}
-
-asio::experimental::coro<int>
-main_stack_coro(asio::io_context&, bool & done)
-{
-  auto g = stack_accumulate(co_await asio::this_coro::executor);
-
-  ASIO_CHECK(g.is_open());
-  ASIO_CHECK(1    == (co_await g(1000)).value_or(-1));
-  ASIO_CHECK(2002 == (co_await g(2000)).value_or(-1));
-  ASIO_CHECK(3004 == (co_await g(3000)).value_or(-1));
-  ASIO_CHECK(4008 == (co_await g(4000)).value_or(-1));
-  ASIO_CHECK(5016 == (co_await g(5000)).value_or(-1));
-  ASIO_CHECK(6032 == (co_await g(6000)).value_or(-1));
-  ASIO_CHECK(7064 == (co_await g(7000)).value_or(-1));
-  ASIO_CHECK(8128 == (co_await g(8000)).value_or(-1));
-  ASIO_CHECK(9256 == (co_await g(9000)).value_or(-1));
-  ASIO_CHECK(511 == (co_await g(-1)).value_or(-1));
-  done = true;
-}
-
-void stack_test()
-{
-  bool done = false;
-  asio::io_context ctx;
-  auto k = main_stack_coro(ctx, done);
-  k.async_resume(asio::detached);
-  ctx.run();
-  ASIO_CHECK(done);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/stack_test",
-  ASIO_TEST_CASE(::coro::stack_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/use_coro.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/use_coro.cpp
deleted file mode 100644
index f2cb7ad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/coro/use_coro.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// experimental/coro/use_coro.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/use_coro.hpp"
-
-#include "asio/steady_timer.hpp"
-#include <iostream>
-#include "../../unit_test.hpp"
-
-using namespace asio::experimental;
-
-namespace coro {
-
-asio::experimental::coro<void(), int>
-awaiter(asio::any_io_executor exec)
-{
-  asio::steady_timer timer{exec};
-  co_await timer.async_wait(use_coro);
-  co_return 42;
-}
-
-asio::experimental::coro<void() noexcept, int>
-awaiter_noexcept(asio::any_io_executor exec)
-{
-  asio::steady_timer timer{exec};
-  auto ec = co_await timer.async_wait(asio::deferred);
-  ASIO_CHECK(ec == asio::error_code{});
-  co_return 42;
-}
-
-void stack_test2()
-{
-  bool done = false;
-  asio::io_context ctx;
-
-  auto k = awaiter(ctx.get_executor());
-  auto k2 = awaiter_noexcept(ctx.get_executor());
-
-  k.async_resume(
-      [&](std::exception_ptr ex, int res)
-      {
-        ASIO_CHECK(!ex);
-        ASIO_CHECK(res == 42);
-        done = true;
-      });
-
-  k2.async_resume([&](int res)
-       {
-         ASIO_CHECK(res == 42);
-         done = true;
-       });
-
-  ctx.run();
-  ASIO_CHECK(done);
-}
-
-} // namespace coro
-
-ASIO_TEST_SUITE
-(
-  "coro/use_coro",
-  ASIO_TEST_CASE(::coro::stack_test2)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/parallel_group.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/parallel_group.cpp
deleted file mode 100644
index c91c95f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/parallel_group.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// experimental/parallel_group.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/parallel_group.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "experimental/parallel_group",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/promise.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/promise.cpp
deleted file mode 100644
index 67923a4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/experimental/promise.cpp
+++ /dev/null
@@ -1,226 +0,0 @@
-//
-// promise.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2021-2023 Klemens D. Morgenstern
-//                         (klemens dot morgenstern at gmx dot net)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/experimental/promise.hpp"
-
-#include "asio/append.hpp"
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/compose.hpp"
-#include "asio/deferred.hpp"
-#include "asio/experimental/use_promise.hpp"
-#include "asio/steady_timer.hpp"
-#include "../unit_test.hpp"
-
-namespace promise {
-
-void promise_tester()
-{
-  using namespace asio;
-  using namespace std::chrono;
-
-  io_context ctx;
-
-  steady_timer timer1{ctx}, timer2{ctx};
-
-  const auto started_when = steady_clock::now();
-  timer1.expires_at(started_when + milliseconds(5000));
-  timer2.expires_at(started_when + milliseconds(1000));
-  auto p1 = timer1.async_wait(experimental::use_promise);
-
-  steady_clock::time_point completed_when;
-  asio::error_code ec;
-  bool called = false;
-
-  p1([&](asio::error_code ec_)
-      {
-        ec = ec_;
-        called = true;
-        completed_when = steady_clock::now();
-      });
-
-  steady_clock::time_point timer2_done;
-  timer2.async_wait(
-      [&](asio::error_code)
-      {
-        timer2_done = steady_clock::now();
-        p1.cancel();
-      });
-
-  ctx.run();
-
-  static_assert(
-      asio::is_async_operation<decltype(p1)>::value,
-      "promise is async_op");
-
-  ASIO_CHECK(timer2_done + milliseconds(1) > started_when);
-  ASIO_CHECK(completed_when > timer2_done);
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == error::operation_aborted);
-
-  timer1.expires_after(milliseconds(0));
-  auto p2 = timer1.async_wait(
-      asio::append(experimental::use_promise, 123));
-
-  ec = asio::error::would_block;
-  called = false;
-
-  p2([&](asio::error_code ec_, int i)
-      {
-        ASIO_CHECK(i == 123);
-        ec = ec_;
-        called = true;
-      });
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(!called);
-
-  ctx.restart();
-  ctx.run();
-
-  static_assert(
-      asio::is_async_operation<decltype(p2)>::value,
-      "promise is async_op");
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(called);
-}
-
-void promise_slot_tester()
-{
-  using namespace asio;
-  using namespace std::chrono;
-
-  io_context ctx;
-
-  steady_timer timer1{ctx}, timer2{ctx};
-
-  const auto started_when = steady_clock::now();
-  timer1.expires_at(started_when + milliseconds(2500));
-  timer2.expires_at(started_when + milliseconds(1000));
-  auto p = timer1.async_wait(experimental::use_promise);
-
-  steady_clock::time_point completed_when;
-  asio::error_code ec;
-  bool called = false;
-
-  asio::cancellation_signal sig;
-
-  p(asio::bind_cancellation_slot(
-        sig.slot(),
-        [&](asio::error_code ec_)
-        {
-          ec = ec_;
-          called = true;
-          completed_when = steady_clock::now();
-        }));
-
-  steady_clock::time_point timer2_done;
-  timer2.async_wait(
-      [&](asio::error_code)
-      {
-        timer2_done = steady_clock::now();
-        sig.emit(asio::cancellation_type::all);
-      });
-
-  ctx.run();
-
-  static_assert(
-      asio::is_async_operation<decltype(p)>::value,
-      "promise is async_op");
-
-  ASIO_CHECK(timer2_done + milliseconds(1) > started_when);
-  ASIO_CHECK(completed_when > timer2_done);
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == error::operation_aborted);
-}
-
-void early_completion()
-{
-  using namespace asio;
-  using namespace std::chrono;
-
-  io_context ctx;
-  auto p = asio::post(ctx, asio::experimental::use_promise);
-  ctx.run();
-
-  ASIO_CHECK(p.completed());
-
-  bool completed = false;
-  p([&]{completed = true;});
-  ASIO_CHECK(!completed);
-  ctx.restart();
-  ctx.run();
-  ASIO_CHECK(completed);
-}
-
-struct test_cancel_impl_op
-{
-  asio::steady_timer & tim;
-  asio::error_code &ec;
-  template<typename Self>
-  void operator()(Self& self)
-  {
-    tim.async_wait(std::forward<Self>(self));
-  }
-
-  template<typename Self>
-  void operator()(Self& self, asio::error_code ec_)
-  {
-    ec = ec_;
-    self.complete(ec_);
-  }
-};
-
-template <typename CompletionToken>
-ASIO_INITFN_AUTO_RESULT_TYPE(
-    CompletionToken, void(asio::error_code))
-test_cancel_impl(asio::steady_timer & tim,
-                 asio::error_code &ec,
-                 CompletionToken&& token)
-{
-  return asio::async_compose<CompletionToken, void(asio::error_code)>(
-      test_cancel_impl_op{tim, ec}, token, tim);
-}
-
-void test_cancel()
-{
-  asio::io_context ctx;
-  asio::steady_timer tim{ctx, std::chrono::seconds(10)};
-  asio::error_code ec;
-
-  {
-    auto p = test_cancel_impl(
-        tim, ec, asio::experimental::use_promise);
-  }
-
-  ctx.run();
-
-  ASIO_CHECK_MESSAGE(
-      ec == asio::error::operation_aborted,
-      ec.message());
-}
-
-} // namespace promise
-
-ASIO_TEST_SUITE
-(
-  "promise",
-  ASIO_TEST_CASE(promise::promise_tester)
-  ASIO_TEST_CASE(promise::promise_slot_tester)
-  ASIO_TEST_CASE(promise::early_completion)
-  ASIO_TEST_CASE(promise::test_cancel)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/file_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/file_base.cpp
deleted file mode 100644
index 9f517fd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/file_base.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// file_base.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/post.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "file_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/.gitignore
deleted file mode 100644
index c057144..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/.gitignore
+++ /dev/null
@@ -1,14 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-basic_endpoint
-datagram_protocol
-raw_protocol
-seq_packet_protocol
-stream_protocol
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/basic_endpoint.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/basic_endpoint.cpp
deleted file mode 100644
index c02f32b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/basic_endpoint.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// generic/basic_endpoint.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/generic/basic_endpoint.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "generic/basic_endpoint",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/datagram_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/datagram_protocol.cpp
deleted file mode 100644
index 23957a7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/datagram_protocol.cpp
+++ /dev/null
@@ -1,292 +0,0 @@
-//
-// generic/datagram_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/generic/datagram_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "asio/ip/udp.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-
-#if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-# define generic cpp_generic
-#endif
-
-//------------------------------------------------------------------------------
-
-// generic_datagram_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// generic::datagram_socket::socket compile and link correctly. Runtime
-// failures are ignored.
-
-namespace generic_datagram_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace generic = asio::generic;
-  typedef generic::datagram_protocol dp;
-
-  const int af_inet = ASIO_OS_DEF(AF_INET);
-  const int ipproto_udp = ASIO_OS_DEF(IPPROTO_UDP);
-  const int sock_dgram = ASIO_OS_DEF(SOCK_DGRAM);
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    socket_base::send_buffer_size socket_option;
-    socket_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    asio::error_code ec;
-
-    // basic_datagram_socket constructors.
-
-    dp::socket socket1(ioc);
-    dp::socket socket2(ioc, dp(af_inet, ipproto_udp));
-    dp::socket socket3(ioc, dp::endpoint());
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    dp::socket::native_handle_type native_socket1
-      = ::socket(af_inet, sock_dgram, 0);
-    dp::socket socket4(ioc, dp(af_inet, ipproto_udp), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    dp::socket socket5(std::move(socket4));
-    asio::ip::udp::socket udp_socket(ioc);
-    dp::socket socket6(std::move(udp_socket));
-
-    // basic_datagram_socket operators.
-
-    socket1 = dp::socket(ioc);
-    socket1 = std::move(socket2);
-    socket1 = asio::ip::udp::socket(ioc);
-
-    // basic_io_object functions.
-
-    dp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    dp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(dp(af_inet, ipproto_udp));
-    socket1.open(dp(af_inet, ipproto_udp), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    dp::socket::native_handle_type native_socket2
-      = ::socket(af_inet, sock_dgram, 0);
-    socket1.assign(dp(af_inet, ipproto_udp), native_socket2);
-    dp::socket::native_handle_type native_socket3
-      = ::socket(af_inet, sock_dgram, 0);
-    socket1.assign(dp(af_inet, ipproto_udp), native_socket3, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    dp::socket::native_handle_type native_socket4 = socket1.native_handle();
-    (void)native_socket4;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(dp::endpoint());
-    socket1.bind(dp::endpoint(), ec);
-
-    socket1.connect(dp::endpoint());
-    socket1.connect(dp::endpoint(), ec);
-
-    socket1.async_connect(dp::endpoint(), connect_handler);
-    socket1.async_connect(dp::endpoint(), immediate);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    dp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    dp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    dp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    dp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_datagram_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler);
-    socket1.async_send(buffer(const_char_buffer), send_handler);
-    socket1.async_send(null_buffers(), send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint());
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint());
-    socket1.send_to(null_buffers(),
-        dp::endpoint());
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint(), in_flags);
-    socket1.send_to(null_buffers(),
-        dp::endpoint(), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint(), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        dp::endpoint(), in_flags, ec);
-
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(), send_handler);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(), send_handler);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(), immediate);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(), in_flags, immediate);
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
-    socket1.async_receive(null_buffers(), receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-
-    dp::endpoint endpoint;
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
-    socket1.receive_from(null_buffers(), endpoint);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
-    socket1.receive_from(null_buffers(), endpoint, in_flags);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
-    socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
-
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, receive_handler);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, receive_handler);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, immediate);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace generic_datagram_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "generic/datagram_protocol",
-  ASIO_COMPILE_TEST_CASE(generic_datagram_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/raw_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/raw_protocol.cpp
deleted file mode 100644
index d20ef5b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/raw_protocol.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-//
-// generic/raw_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/generic/raw_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "asio/ip/icmp.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-
-#if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-# define generic cpp_generic
-#endif
-
-//------------------------------------------------------------------------------
-
-// generic_raw_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// generic::raw_socket::socket compile and link correctly. Runtime failures
-// are ignored.
-
-namespace generic_raw_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace generic = asio::generic;
-  typedef generic::raw_protocol rp;
-
-  const int af_inet = ASIO_OS_DEF(AF_INET);
-  const int ipproto_icmp = ASIO_OS_DEF(IPPROTO_ICMP);
-  const int sock_raw = ASIO_OS_DEF(SOCK_RAW);
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    socket_base::send_buffer_size socket_option;
-    socket_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    asio::error_code ec;
-
-    // basic_raw_socket constructors.
-
-    rp::socket socket1(ioc);
-    rp::socket socket2(ioc, rp(af_inet, ipproto_icmp));
-    rp::socket socket3(ioc, rp::endpoint());
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    rp::socket::native_handle_type native_socket1
-      = ::socket(af_inet, sock_raw, 0);
-    rp::socket socket4(ioc, rp(af_inet, ipproto_icmp), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    rp::socket socket5(std::move(socket4));
-    asio::ip::icmp::socket icmp_socket(ioc);
-    rp::socket socket6(std::move(icmp_socket));
-
-    // basic_datagram_socket operators.
-
-    socket1 = rp::socket(ioc);
-    socket1 = std::move(socket2);
-    socket1 = asio::ip::icmp::socket(ioc);
-
-    // basic_io_object functions.
-
-    rp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    rp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(rp(af_inet, ipproto_icmp));
-    socket1.open(rp(af_inet, ipproto_icmp), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    rp::socket::native_handle_type native_socket2
-      = ::socket(af_inet, sock_raw, 0);
-    socket1.assign(rp(af_inet, ipproto_icmp), native_socket2);
-    rp::socket::native_handle_type native_socket3
-      = ::socket(af_inet, sock_raw, 0);
-    socket1.assign(rp(af_inet, ipproto_icmp), native_socket3, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    rp::socket::native_handle_type native_socket4 = socket1.native_handle();
-    (void)native_socket4;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(rp::endpoint());
-    socket1.bind(rp::endpoint(), ec);
-
-    socket1.connect(rp::endpoint());
-    socket1.connect(rp::endpoint(), ec);
-
-    socket1.async_connect(rp::endpoint(), connect_handler);
-    socket1.async_connect(rp::endpoint(), immediate);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    rp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    rp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    rp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    rp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_raw_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler);
-    socket1.async_send(buffer(const_char_buffer), send_handler);
-    socket1.async_send(null_buffers(), send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-
-    socket1.send_to(buffer(mutable_char_buffer),
-        rp::endpoint());
-    socket1.send_to(buffer(const_char_buffer),
-        rp::endpoint());
-    socket1.send_to(null_buffers(),
-        rp::endpoint());
-    socket1.send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        rp::endpoint(), in_flags);
-    socket1.send_to(null_buffers(),
-        rp::endpoint(), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        rp::endpoint(), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        rp::endpoint(), in_flags, ec);
-
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        rp::endpoint(), send_handler);
-    socket1.async_send_to(null_buffers(),
-        rp::endpoint(), send_handler);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        rp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(null_buffers(),
-        rp::endpoint(), in_flags, send_handler);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        rp::endpoint(), immediate);
-    socket1.async_send_to(null_buffers(),
-        rp::endpoint(), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        rp::endpoint(), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        rp::endpoint(), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        rp::endpoint(), in_flags, immediate);
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
-    socket1.async_receive(null_buffers(), receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-
-    rp::endpoint endpoint;
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
-    socket1.receive_from(null_buffers(), endpoint);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
-    socket1.receive_from(null_buffers(), endpoint, in_flags);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
-    socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
-
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, receive_handler);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, receive_handler);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, immediate);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace generic_raw_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "generic/raw_protocol",
-  ASIO_COMPILE_TEST_CASE(generic_raw_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/seq_packet_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/seq_packet_protocol.cpp
deleted file mode 100644
index 587445b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/seq_packet_protocol.cpp
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// generic/seq_packet_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/generic/seq_packet_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-
-#if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-# define generic cpp_generic
-#endif
-
-//------------------------------------------------------------------------------
-
-// generic_seq_packet_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// generic::seq_packet_socket::socket compile and link correctly. Runtime
-// failures are ignored.
-
-namespace generic_seq_packet_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace generic = asio::generic;
-  typedef generic::seq_packet_protocol spp;
-
-  const int af_inet = ASIO_OS_DEF(AF_INET);
-  const int sock_seqpacket = ASIO_OS_DEF(SOCK_SEQPACKET);
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    const socket_base::message_flags in_flags = 0;
-    socket_base::message_flags out_flags = 0;
-    socket_base::send_buffer_size socket_option;
-    socket_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    asio::error_code ec;
-
-    // basic_seq_packet_socket constructors.
-
-    spp::socket socket1(ioc);
-    spp::socket socket2(ioc, spp(af_inet, 0));
-    spp::socket socket3(ioc, spp::endpoint());
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    spp::socket::native_handle_type native_socket1
-      = ::socket(af_inet, sock_seqpacket, 0);
-    spp::socket socket4(ioc, spp(af_inet, 0), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    spp::socket socket5(std::move(socket4));
-
-    // basic_seq_packet_socket operators.
-
-    socket1 = spp::socket(ioc);
-    socket1 = std::move(socket2);
-
-    // basic_io_object functions.
-
-    spp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    spp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(spp(af_inet, 0));
-    socket1.open(spp(af_inet, 0), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    spp::socket::native_handle_type native_socket2
-      = ::socket(af_inet, sock_seqpacket, 0);
-    socket1.assign(spp(af_inet, 0), native_socket2);
-    spp::socket::native_handle_type native_socket3
-      = ::socket(af_inet, sock_seqpacket, 0);
-    socket1.assign(spp(af_inet, 0), native_socket3, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    spp::socket::native_handle_type native_socket4 = socket1.native_handle();
-    (void)native_socket4;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(spp::endpoint());
-    socket1.bind(spp::endpoint(), ec);
-
-    socket1.connect(spp::endpoint());
-    socket1.connect(spp::endpoint(), ec);
-
-    socket1.async_connect(spp::endpoint(), connect_handler);
-    socket1.async_connect(spp::endpoint(), immediate);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    spp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    spp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    spp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    spp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_seq_packet_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-
-    socket1.receive(buffer(mutable_char_buffer), out_flags);
-    socket1.receive(null_buffers(), out_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags);
-    socket1.receive(null_buffers(), in_flags, out_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags, ec);
-    socket1.receive(null_buffers(), in_flags, out_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), out_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), out_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        out_flags, receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, out_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), out_flags, immediate);
-    socket1.async_receive(null_buffers(), out_flags, immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        out_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, out_flags, immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace generic_seq_packet_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "generic/seq_packet_protocol",
-  ASIO_COMPILE_TEST_CASE(generic_seq_packet_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/stream_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/stream_protocol.cpp
deleted file mode 100644
index dedf6d7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/generic/stream_protocol.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-//
-// generic/stream_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/generic/stream_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-
-#if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-# define generic cpp_generic
-#endif
-
-//------------------------------------------------------------------------------
-
-// generic_stream_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// generic::stream_protocol::socket compile and link correctly. Runtime
-// failures are ignored.
-
-namespace generic_stream_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace generic = asio::generic;
-  typedef generic::stream_protocol sp;
-
-  const int af_inet = ASIO_OS_DEF(AF_INET);
-  const int ipproto_tcp = ASIO_OS_DEF(IPPROTO_TCP);
-  const int sock_stream = ASIO_OS_DEF(SOCK_STREAM);
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    socket_base::keep_alive socket_option;
-    socket_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    asio::error_code ec;
-
-    // basic_stream_socket constructors.
-
-    sp::socket socket1(ioc);
-    sp::socket socket2(ioc, sp(af_inet, ipproto_tcp));
-    sp::socket socket3(ioc, sp::endpoint());
-#if defined(ASIO_WINDOWS_RUNTIME)
-    Windows::Networking::Sockets::StreamSocket^ native_socket1 = nullptr;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    sp::socket::native_handle_type native_socket1
-      = ::socket(af_inet, sock_stream, 0);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-    sp::socket socket4(ioc, sp(af_inet, ipproto_tcp), native_socket1);
-
-    sp::socket socket5(std::move(socket4));
-    asio::ip::tcp::socket tcp_socket(ioc);
-    sp::socket socket6(std::move(tcp_socket));
-
-    // basic_stream_socket operators.
-
-    socket1 = sp::socket(ioc);
-    socket1 = std::move(socket2);
-    socket1 = asio::ip::tcp::socket(ioc);
-
-    // basic_io_object functions.
-
-    sp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    sp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(sp(af_inet, ipproto_tcp));
-    socket1.open(sp(af_inet, ipproto_tcp), ec);
-
-#if defined(ASIO_WINDOWS_RUNTIME)
-    Windows::Networking::Sockets::StreamSocket^ native_socket2 = nullptr;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    sp::socket::native_handle_type native_socket2
-      = ::socket(af_inet, sock_stream, 0);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-    socket1.assign(sp(af_inet, ipproto_tcp), native_socket2);
-#if defined(ASIO_WINDOWS_RUNTIME)
-    Windows::Networking::Sockets::StreamSocket^ native_socket3 = nullptr;
-#else // defined(ASIO_WINDOWS_RUNTIME)
-    sp::socket::native_handle_type native_socket3
-      = ::socket(af_inet, sock_stream, 0);
-#endif // defined(ASIO_WINDOWS_RUNTIME)
-    socket1.assign(sp(af_inet, ipproto_tcp), native_socket3, ec);
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    sp::socket::native_handle_type native_socket4 = socket1.native_handle();
-    (void)native_socket4;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(sp::endpoint());
-    socket1.bind(sp::endpoint(), ec);
-
-    socket1.connect(sp::endpoint());
-    socket1.connect(sp::endpoint(), ec);
-
-    socket1.async_connect(sp::endpoint(), connect_handler);
-    socket1.async_connect(sp::endpoint(), immediate);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    sp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    sp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    sp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    sp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_stream_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler);
-    socket1.async_send(buffer(const_char_buffer), send_handler);
-    socket1.async_send(null_buffers(), send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
-    socket1.async_receive(null_buffers(), receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-
-    socket1.write_some(buffer(mutable_char_buffer));
-    socket1.write_some(buffer(const_char_buffer));
-    socket1.write_some(null_buffers());
-    socket1.write_some(buffer(mutable_char_buffer), ec);
-    socket1.write_some(buffer(const_char_buffer), ec);
-    socket1.write_some(null_buffers(), ec);
-
-    socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
-    socket1.async_write_some(buffer(const_char_buffer), write_some_handler);
-    socket1.async_write_some(null_buffers(), write_some_handler);
-    socket1.async_write_some(buffer(mutable_char_buffer), immediate);
-    socket1.async_write_some(buffer(const_char_buffer), immediate);
-    socket1.async_write_some(null_buffers(), immediate);
-
-    socket1.read_some(buffer(mutable_char_buffer));
-    socket1.read_some(buffer(mutable_char_buffer), ec);
-    socket1.read_some(null_buffers(), ec);
-
-    socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
-    socket1.async_read_some(null_buffers(), read_some_handler);
-    socket1.async_read_some(buffer(mutable_char_buffer), immediate);
-    socket1.async_read_some(null_buffers(), immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace generic_stream_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "generic/stream_protocol",
-  ASIO_COMPILE_TEST_CASE(generic_stream_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/high_resolution_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/high_resolution_timer.cpp
deleted file mode 100644
index b8dd448..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/high_resolution_timer.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// high_resolution_timer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/high_resolution_timer.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "high_resolution_timer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/immediate.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/immediate.cpp
deleted file mode 100644
index 0666898..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/immediate.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// immediate.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/immediate.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "immediate",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context.cpp
deleted file mode 100644
index 4341fb6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-//
-// io_context.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/io_context.hpp"
-
-#include <functional>
-#include <sstream>
-#include "asio/bind_executor.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "asio/thread.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/deadline_timer.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/steady_timer.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-using namespace asio;
-namespace bindns = std;
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef deadline_timer timer;
-namespace chronons = boost::posix_time;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void decrement_to_zero(io_context* ioc, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    int before_value = *count;
-    asio::post(*ioc, bindns::bind(decrement_to_zero, ioc, count));
-
-    // Handler execution cannot nest, so count value should remain unchanged.
-    ASIO_CHECK(*count == before_value);
-  }
-}
-
-void nested_decrement_to_zero(io_context* ioc, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    asio::dispatch(*ioc,
-        bindns::bind(nested_decrement_to_zero, ioc, count));
-
-    // Handler execution is nested, so count value should now be zero.
-    ASIO_CHECK(*count == 0);
-  }
-}
-
-void sleep_increment(io_context* ioc, int* count)
-{
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  if (++(*count) < 3)
-    asio::post(*ioc, bindns::bind(sleep_increment, ioc, count));
-}
-
-void start_sleep_increments(io_context* ioc, int* count)
-{
-  // Give all threads a chance to start.
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  // Start the first of three increments.
-  asio::post(*ioc, bindns::bind(sleep_increment, ioc, count));
-}
-
-void throw_exception()
-{
-  throw 1;
-}
-
-void io_context_run(io_context* ioc)
-{
-  ioc->run();
-}
-
-void io_context_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  asio::post(ioc, bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 5);
-
-  count = 0;
-  ioc.restart();
-  executor_work_guard<io_context::executor_type> w = make_work_guard(ioc);
-  asio::post(ioc, bindns::bind(&io_context::stop, &ioc));
-  ASIO_CHECK(!ioc.stopped());
-  ioc.run();
-
-  // The only operation executed should have been to stop run().
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  asio::post(ioc, bindns::bind(increment, &count));
-  w.reset();
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 10;
-  ioc.restart();
-  asio::post(ioc, bindns::bind(decrement_to_zero, &ioc, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 10);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  count = 10;
-  ioc.restart();
-  asio::post(ioc, bindns::bind(nested_decrement_to_zero, &ioc, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 10);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  count = 10;
-  ioc.restart();
-  asio::dispatch(ioc,
-      bindns::bind(nested_decrement_to_zero, &ioc, &count));
-
-  // No handlers can be called until run() is called, even though nested
-  // delivery was specifically allowed in the previous call.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 10);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  count = 0;
-  int count2 = 0;
-  ioc.restart();
-  ASIO_CHECK(!ioc.stopped());
-  asio::post(ioc, bindns::bind(start_sleep_increments, &ioc, &count));
-  asio::post(ioc, bindns::bind(start_sleep_increments, &ioc, &count2));
-  thread thread1(bindns::bind(io_context_run, &ioc));
-  thread thread2(bindns::bind(io_context_run, &ioc));
-  thread1.join();
-  thread2.join();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 3);
-  ASIO_CHECK(count2 == 3);
-
-  count = 10;
-  io_context ioc2;
-  asio::dispatch(ioc, asio::bind_executor(ioc2,
-        bindns::bind(decrement_to_zero, &ioc2, &count)));
-  ioc.restart();
-  ASIO_CHECK(!ioc.stopped());
-  ioc.run();
-
-  // No decrement_to_zero handlers can be called until run() is called on the
-  // second io_context object.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 10);
-
-  ioc2.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(count == 0);
-
-  count = 0;
-  int exception_count = 0;
-  ioc.restart();
-  asio::post(ioc, &throw_exception);
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, bindns::bind(increment, &count));
-  asio::post(ioc, &throw_exception);
-  asio::post(ioc, bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(exception_count == 0);
-
-  for (;;)
-  {
-    try
-    {
-      ioc.run();
-      break;
-    }
-    catch (int)
-    {
-      ++exception_count;
-    }
-  }
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 3);
-  ASIO_CHECK(exception_count == 2);
-}
-
-class test_service : public asio::io_context::service
-{
-public:
-  static asio::io_context::id id;
-  test_service(asio::io_context& s)
-    : asio::io_context::service(s) {}
-private:
-  virtual void shutdown_service() {}
-};
-
-asio::io_context::id test_service::id;
-
-void io_context_service_test()
-{
-  asio::io_context ioc1;
-  asio::io_context ioc2;
-  asio::io_context ioc3;
-
-  // Implicit service registration.
-
-  asio::use_service<test_service>(ioc1);
-
-  ASIO_CHECK(asio::has_service<test_service>(ioc1));
-
-  test_service* svc1 = new test_service(ioc1);
-  try
-  {
-    asio::add_service(ioc1, svc1);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::service_already_exists&)
-  {
-  }
-  delete svc1;
-
-  // Explicit service registration.
-
-  test_service* svc2 = new test_service(ioc2);
-  asio::add_service(ioc2, svc2);
-
-  ASIO_CHECK(asio::has_service<test_service>(ioc2));
-  ASIO_CHECK(&asio::use_service<test_service>(ioc2) == svc2);
-
-  test_service* svc3 = new test_service(ioc2);
-  try
-  {
-    asio::add_service(ioc2, svc3);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::service_already_exists&)
-  {
-  }
-  delete svc3;
-
-  // Explicit registration with invalid owner.
-
-  test_service* svc4 = new test_service(ioc2);
-  try
-  {
-    asio::add_service(ioc3, svc4);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::invalid_service_owner&)
-  {
-  }
-  delete svc4;
-
-  ASIO_CHECK(!asio::has_service<test_service>(ioc3));
-}
-
-void io_context_executor_query_test()
-{
-  io_context ioc;
-
-  ASIO_CHECK(
-      &asio::query(ioc.get_executor(),
-        asio::execution::context)
-      == &ioc);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::blocking)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::blocking.possibly)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::outstanding_work)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::outstanding_work.untracked)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::relationship)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::relationship.fork)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::mapping)
-      == asio::execution::mapping.thread);
-
-  ASIO_CHECK(
-      asio::query(ioc.get_executor(),
-        asio::execution::allocator)
-      == std::allocator<void>());
-}
-
-void io_context_executor_execute_test()
-{
-  io_context ioc;
-  int count = 0;
-
-  ioc.get_executor().execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.possibly
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  ASIO_CHECK(!ioc.stopped());
-
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.tracked
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.fork
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(ioc.get_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::prefer(
-      asio::require(ioc.get_executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator(std::allocator<void>())
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::prefer(
-      asio::require(ioc.get_executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "io_context",
-  ASIO_TEST_CASE(io_context_test)
-  ASIO_TEST_CASE(io_context_service_test)
-  ASIO_TEST_CASE(io_context_executor_query_test)
-  ASIO_TEST_CASE(io_context_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context_strand.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context_strand.cpp
deleted file mode 100644
index be03eb4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/io_context_strand.cpp
+++ /dev/null
@@ -1,316 +0,0 @@
-//
-// io_context_strand.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/io_context_strand.hpp"
-
-#include <functional>
-#include <sstream>
-#include "asio/io_context.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "asio/thread.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/deadline_timer.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/steady_timer.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-using namespace asio;
-
-namespace bindns = std;
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef deadline_timer timer;
-namespace chronons = boost::posix_time;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void increment_without_lock(io_context::strand* s, int* count)
-{
-  ASIO_CHECK(!s->running_in_this_thread());
-
-  int original_count = *count;
-
-  dispatch(*s, bindns::bind(increment, count));
-
-  // No other functions are currently executing through the locking dispatcher,
-  // so the previous call to dispatch should have successfully nested.
-  ASIO_CHECK(*count == original_count + 1);
-}
-
-void increment_with_lock(io_context::strand* s, int* count)
-{
-  ASIO_CHECK(s->running_in_this_thread());
-
-  int original_count = *count;
-
-  dispatch(*s, bindns::bind(increment, count));
-
-  // The current function already holds the strand's lock, so the
-  // previous call to dispatch should have successfully nested.
-  ASIO_CHECK(*count == original_count + 1);
-}
-
-void sleep_increment(io_context* ioc, int* count)
-{
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  ++(*count);
-}
-
-void increment_by_a(int* count, int a)
-{
-  (*count) += a;
-}
-
-void increment_by_a_b(int* count, int a, int b)
-{
-  (*count) += a + b;
-}
-
-void increment_by_a_b_c(int* count, int a, int b, int c)
-{
-  (*count) += a + b + c;
-}
-
-void increment_by_a_b_c_d(int* count, int a, int b, int c, int d)
-{
-  (*count) += a + b + c + d;
-}
-
-void start_sleep_increments(io_context* ioc, io_context::strand* s, int* count)
-{
-  // Give all threads a chance to start.
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  // Start three increments.
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-}
-
-void throw_exception()
-{
-  throw 1;
-}
-
-void io_context_run(io_context* ioc)
-{
-  ioc->run();
-}
-
-void strand_test()
-{
-  io_context ioc;
-  io_context::strand s(ioc);
-  int count = 0;
-
-  post(ioc, bindns::bind(increment_without_lock, &s, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  post(s, bindns::bind(increment_with_lock, &s, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  post(ioc, bindns::bind(start_sleep_increments, &ioc, &s, &count));
-  thread thread1(bindns::bind(io_context_run, &ioc));
-  thread thread2(bindns::bind(io_context_run, &ioc));
-
-  // Check all events run one after another even though there are two threads.
-  timer timer1(ioc, chronons::seconds(3));
-  timer1.wait();
-  ASIO_CHECK(count == 0);
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expiry() + chronons::seconds(2));
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.wait();
-  ASIO_CHECK(count == 1);
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expiry() + chronons::seconds(2));
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.wait();
-  ASIO_CHECK(count == 2);
-
-  thread1.join();
-  thread2.join();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 3);
-
-  count = 0;
-  int exception_count = 0;
-  ioc.restart();
-  post(s, throw_exception);
-  post(s, bindns::bind(increment, &count));
-  post(s, bindns::bind(increment, &count));
-  post(s, throw_exception);
-  post(s, bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(exception_count == 0);
-
-  for (;;)
-  {
-    try
-    {
-      ioc.run();
-      break;
-    }
-    catch (int)
-    {
-      ++exception_count;
-    }
-  }
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 3);
-  ASIO_CHECK(exception_count == 2);
-
-  count = 0;
-  ioc.restart();
-
-  // Check for clean shutdown when handlers posted through an orphaned strand
-  // are abandoned.
-  {
-    io_context::strand s2(ioc);
-    post(s2, bindns::bind(increment, &count));
-    post(s2, bindns::bind(increment, &count));
-    post(s2, bindns::bind(increment, &count));
-  }
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-}
-
-void strand_wrap_test()
-{
-#if !defined(ASIO_NO_DEPRECATED)
-  io_context ioc;
-  io_context::strand s(ioc);
-  int count = 0;
-
-  s.wrap(bindns::bind(increment, &count))();
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  s.wrap(increment)(&count);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  s.wrap(increment_by_a)(&count, 1);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  s.wrap(increment_by_a_b)(&count, 1, 2);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 3);
-
-  count = 0;
-  s.wrap(increment_by_a_b_c)(&count, 1, 2, 3);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 6);
-
-  count = 0;
-  s.wrap(increment_by_a_b_c_d)(&count, 1, 2, 3, 4);
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 10);
-#endif // !defined(ASIO_NO_DEPRECATED)
-}
-
-ASIO_TEST_SUITE
-(
-  "strand",
-  ASIO_TEST_CASE(strand_test)
-  ASIO_TEST_CASE(strand_wrap_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/.gitignore
deleted file mode 100644
index 4c0337a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/.gitignore
+++ /dev/null
@@ -1,27 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-address
-address_v4*
-address_v6*
-basic_endpoint
-basic_resolver
-basic_resolver_entry
-basic_resolver_iterator
-basic_resolver_query
-host_name
-icmp
-multicast
-network_v4
-network_v6
-resolver_query_base
-tcp
-udp
-unicast
-v6_only
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/address.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/address.cpp
deleted file mode 100644
index a13a343..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/address.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// address.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/address.hpp"
-
-#include "../unit_test.hpp"
-#include <sstream>
-
-//------------------------------------------------------------------------------
-
-// ip_address_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::address compile and link correctly. Runtime failures are ignored.
-
-namespace ip_address_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    asio::error_code ec;
-
-    // address constructors.
-
-    ip::address addr1;
-    const ip::address_v4 const_addr_v4;
-    ip::address addr2(const_addr_v4);
-    const ip::address_v6 const_addr_v6;
-    ip::address addr3(const_addr_v6);
-
-    // address functions.
-
-    bool b = addr1.is_v4();
-    (void)b;
-
-    b = addr1.is_v6();
-    (void)b;
-
-    b = addr1.is_loopback();
-    (void)b;
-
-    b = addr1.is_unspecified();
-    (void)b;
-
-    b = addr1.is_multicast();
-    (void)b;
-
-    ip::address_v4 addr_v4_value = addr1.to_v4();
-    (void)addr_v4_value;
-
-    ip::address_v6 addr_v6_value = addr1.to_v6();
-    (void)addr_v6_value;
-
-    std::string string_value = addr1.to_string();
-#if !defined(ASIO_NO_DEPRECATED)
-    string_value = addr1.to_string(ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    // address static functions.
-
-#if !defined(ASIO_NO_DEPRECATED)
-    addr1 = ip::address::from_string("127.0.0.1");
-    addr1 = ip::address::from_string("127.0.0.1", ec);
-    addr1 = ip::address::from_string(string_value);
-    addr1 = ip::address::from_string(string_value, ec);
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    // address comparisons.
-
-    b = (addr1 == addr2);
-    (void)b;
-
-    b = (addr1 != addr2);
-    (void)b;
-
-    b = (addr1 < addr2);
-    (void)b;
-
-    b = (addr1 > addr2);
-    (void)b;
-
-    b = (addr1 <= addr2);
-    (void)b;
-
-    b = (addr1 >= addr2);
-    (void)b;
-
-    // address creation functions.
-
-    addr1 = ip::make_address("127.0.0.1");
-    addr1 = ip::make_address("127.0.0.1", ec);
-    addr1 = ip::make_address(string_value);
-    addr1 = ip::make_address(string_value, ec);
-#if defined(ASIO_HAS_STRING_VIEW)
-# if defined(ASIO_HAS_STD_STRING_VIEW)
-    std::string_view string_view_value("127.0.0.1");
-# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    std::experimental::string_view string_view_value("127.0.0.1");
-# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    addr1 = ip::make_address(string_view_value);
-    addr1 = ip::make_address(string_view_value, ec);
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-    // address I/O.
-
-    std::ostringstream os;
-    os << addr1;
-
-#if !defined(BOOST_NO_STD_WSTREAMBUF)
-    std::wostringstream wos;
-    wos << addr1;
-#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
-
-    std::size_t hash1 = std::hash<ip::address>()(addr1);
-    (void)hash1;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_address_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/address",
-  ASIO_COMPILE_TEST_CASE(ip_address_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_endpoint.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_endpoint.cpp
deleted file mode 100644
index d4aadb6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_endpoint.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_endpoint.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/basic_endpoint.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/basic_endpoint",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver.cpp
deleted file mode 100644
index 698a2ba..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_resolver.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/basic_resolver.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/basic_resolver",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_entry.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_entry.cpp
deleted file mode 100644
index 7de5b6f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_entry.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_resolver_entry.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/basic_resolver_entry.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/basic_resolver_entry",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_iterator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_iterator.cpp
deleted file mode 100644
index df7a54a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_iterator.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_resolver_iterator.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/basic_resolver_iterator.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/basic_resolver_iterator",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_query.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_query.cpp
deleted file mode 100644
index 6d10e44..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/basic_resolver_query.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_resolver_query.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/basic_resolver_query.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/basic_resolver_query",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/host_name.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/host_name.cpp
deleted file mode 100644
index 6972cbf..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/host_name.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// host_name.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/host_name.hpp"
-
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_host_name_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all host_name functions compile and link
-// correctly. Runtime failures are ignored.
-
-namespace ip_host_name_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    asio::error_code ec;
-
-    std::string host_name = ip::host_name();
-    std::string host_name2 = ip::host_name(ec);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_host_name_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/host_name",
-  ASIO_COMPILE_TEST_CASE(ip_host_name_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/icmp.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/icmp.cpp
deleted file mode 100644
index ec60267..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/icmp.cpp
+++ /dev/null
@@ -1,606 +0,0 @@
-//
-// icmp.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/icmp.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "asio/placeholders.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../archetypes/gettable_socket_option.hpp"
-#include "../archetypes/io_control_command.hpp"
-#include "../archetypes/settable_socket_option.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_icmp_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::icmp::socket compile and link correctly. Runtime failures are ignored.
-
-namespace ip_icmp_socket_compile {
-
-struct connect_handler
-{
-  connect_handler() {}
-  void operator()(const asio::error_code&) {}
-  connect_handler(connect_handler&&) {}
-private:
-  connect_handler(const connect_handler&);
-};
-
-struct send_handler
-{
-  send_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  send_handler(send_handler&&) {}
-private:
-  send_handler(const send_handler&);
-};
-
-struct receive_handler
-{
-  receive_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  receive_handler(receive_handler&&) {}
-private:
-  receive_handler(const receive_handler&);
-};
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    archetypes::settable_socket_option<void> settable_socket_option1;
-    archetypes::settable_socket_option<int> settable_socket_option2;
-    archetypes::settable_socket_option<double> settable_socket_option3;
-    archetypes::gettable_socket_option<void> gettable_socket_option1;
-    archetypes::gettable_socket_option<int> gettable_socket_option2;
-    archetypes::gettable_socket_option<double> gettable_socket_option3;
-    archetypes::io_control_command io_control_command;
-    archetypes::immediate_handler immediate;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_datagram_socket constructors.
-
-    ip::icmp::socket socket1(ioc);
-    ip::icmp::socket socket2(ioc, ip::icmp::v4());
-    ip::icmp::socket socket3(ioc, ip::icmp::v6());
-    ip::icmp::socket socket4(ioc, ip::icmp::endpoint(ip::icmp::v4(), 0));
-    ip::icmp::socket socket5(ioc, ip::icmp::endpoint(ip::icmp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::icmp::socket::native_handle_type native_socket1
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    ip::icmp::socket socket6(ioc, ip::icmp::v4(), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::icmp::socket socket7(ioc_ex);
-    ip::icmp::socket socket8(ioc_ex, ip::icmp::v4());
-    ip::icmp::socket socket9(ioc_ex, ip::icmp::v6());
-    ip::icmp::socket socket10(ioc_ex, ip::icmp::endpoint(ip::icmp::v4(), 0));
-    ip::icmp::socket socket11(ioc_ex, ip::icmp::endpoint(ip::icmp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::icmp::socket::native_handle_type native_socket2
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    ip::icmp::socket socket12(ioc_ex, ip::icmp::v4(), native_socket2);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::icmp::socket socket13(std::move(socket6));
-
-    // basic_datagram_socket operators.
-
-    socket1 = ip::icmp::socket(ioc);
-    socket1 = std::move(socket2);
-
-    // basic_io_object functions.
-
-    ip::icmp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    ip::icmp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    const ip::icmp::socket& socket14 = socket1;
-    const ip::icmp::socket::lowest_layer_type& lowest_layer2
-      = socket14.lowest_layer();
-    (void)lowest_layer2;
-
-    socket1.open(ip::icmp::v4());
-    socket1.open(ip::icmp::v6());
-    socket1.open(ip::icmp::v4(), ec);
-    socket1.open(ip::icmp::v6(), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::icmp::socket::native_handle_type native_socket3
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    socket1.assign(ip::icmp::v4(), native_socket3);
-    ip::icmp::socket::native_handle_type native_socket4
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    socket1.assign(ip::icmp::v4(), native_socket4, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    socket1.release();
-    socket1.release(ec);
-
-    ip::icmp::socket::native_handle_type native_socket5
-      = socket1.native_handle();
-    (void)native_socket5;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(ip::icmp::endpoint(ip::icmp::v4(), 0));
-    socket1.bind(ip::icmp::endpoint(ip::icmp::v6(), 0));
-    socket1.bind(ip::icmp::endpoint(ip::icmp::v4(), 0), ec);
-    socket1.bind(ip::icmp::endpoint(ip::icmp::v6(), 0), ec);
-
-    socket1.connect(ip::icmp::endpoint(ip::icmp::v4(), 0));
-    socket1.connect(ip::icmp::endpoint(ip::icmp::v6(), 0));
-    socket1.connect(ip::icmp::endpoint(ip::icmp::v4(), 0), ec);
-    socket1.connect(ip::icmp::endpoint(ip::icmp::v6(), 0), ec);
-
-    socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0),
-        connect_handler());
-    socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0),
-        connect_handler());
-    socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
-    socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
-    int i1 = socket1.async_connect(ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
-    (void)i1;
-    int i2 = socket1.async_connect(ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
-    (void)i2;
-
-    socket1.set_option(settable_socket_option1);
-    socket1.set_option(settable_socket_option1, ec);
-    socket1.set_option(settable_socket_option2);
-    socket1.set_option(settable_socket_option2, ec);
-    socket1.set_option(settable_socket_option3);
-    socket1.set_option(settable_socket_option3, ec);
-
-    socket1.get_option(gettable_socket_option1);
-    socket1.get_option(gettable_socket_option1, ec);
-    socket1.get_option(gettable_socket_option2);
-    socket1.get_option(gettable_socket_option2, ec);
-    socket1.get_option(gettable_socket_option3);
-    socket1.get_option(gettable_socket_option3, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    bool non_blocking1 = socket1.non_blocking();
-    (void)non_blocking1;
-    socket1.non_blocking(true);
-    socket1.non_blocking(false, ec);
-
-    bool non_blocking2 = socket1.native_non_blocking();
-    (void)non_blocking2;
-    socket1.native_non_blocking(true);
-    socket1.native_non_blocking(false, ec);
-
-    ip::icmp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    ip::icmp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    ip::icmp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    ip::icmp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_datagram_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler());
-    socket1.async_send(buffer(const_char_buffer), send_handler());
-    socket1.async_send(null_buffers(), send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler());
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler());
-    socket1.async_send(null_buffers(), in_flags, send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-    int i3 = socket1.async_send(buffer(mutable_char_buffer), lazy);
-    (void)i3;
-    int i4 = socket1.async_send(buffer(const_char_buffer), lazy);
-    (void)i4;
-    int i5 = socket1.async_send(null_buffers(), lazy);
-    (void)i5;
-    int i6 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
-    (void)i6;
-    int i7 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
-    (void)i7;
-    int i8 = socket1.async_send(null_buffers(), in_flags, lazy);
-    (void)i8;
-
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0));
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0));
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0));
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0));
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0));
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0));
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags);
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, ec);
-
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, immediate);
-    int i9 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
-    (void)i9;
-    int i10 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
-    (void)i10;
-    int i11 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
-    (void)i11;
-    int i12 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
-    (void)i12;
-    int i13 = socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), lazy);
-    (void)i13;
-    int i14 = socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), lazy);
-    (void)i14;
-    int i15 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
-    (void)i15;
-    int i16 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
-    (void)i16;
-    int i17 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
-    (void)i17;
-    int i18 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
-    (void)i18;
-    int i19 = socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v4(), 0), in_flags, lazy);
-    (void)i19;
-    int i20 = socket1.async_send_to(null_buffers(),
-        ip::icmp::endpoint(ip::icmp::v6(), 0), in_flags, lazy);
-    (void)i20;
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
-    socket1.async_receive(null_buffers(), receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler());
-    socket1.async_receive(null_buffers(), in_flags, receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-    int i21 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
-    (void)i21;
-    int i22 = socket1.async_receive(null_buffers(), lazy);
-    (void)i22;
-    int i23 = socket1.async_receive(buffer(mutable_char_buffer),
-        in_flags, lazy);
-    (void)i23;
-    int i24 = socket1.async_receive(null_buffers(), in_flags, lazy);
-    (void)i24;
-
-    ip::icmp::endpoint endpoint;
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
-    socket1.receive_from(null_buffers(), endpoint);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
-    socket1.receive_from(null_buffers(), endpoint, in_flags);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
-    socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
-
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, receive_handler());
-    socket1.async_receive_from(null_buffers(),
-        endpoint, receive_handler());
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, receive_handler());
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, receive_handler());
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, immediate);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, immediate);
-    int i25 = socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, lazy);
-    (void)i25;
-    int i26 = socket1.async_receive_from(null_buffers(),
-        endpoint, lazy);
-    (void)i26;
-    int i27 = socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, lazy);
-    (void)i27;
-    int i28 = socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, lazy);
-    (void)i28;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_icmp_socket_compile
-
-//------------------------------------------------------------------------------
-
-// ip_icmp_resolver_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::icmp::resolver compile and link correctly. Runtime failures are ignored.
-
-namespace ip_icmp_resolver_compile {
-
-struct resolve_handler
-{
-  resolve_handler() {}
-  void operator()(const asio::error_code&,
-      asio::ip::icmp::resolver::results_type) {}
-  resolve_handler(resolve_handler&&) {}
-private:
-  resolve_handler(const resolve_handler&);
-};
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::icmp::resolver::query q(ip::icmp::v4(), "localhost", "0");
-#endif // !defined(ASIO_NO_DEPRECATED)
-    ip::icmp::endpoint e(ip::address_v4::loopback(), 0);
-
-    // basic_resolver constructors.
-
-    ip::icmp::resolver resolver(ioc);
-    ip::icmp::resolver resolver2(ioc_ex);
-
-    ip::icmp::resolver resolver3(std::move(resolver));
-
-    // basic_resolver operators.
-
-    resolver = ip::icmp::resolver(ioc);
-    resolver = std::move(resolver3);
-
-    // basic_io_object functions.
-
-    ip::icmp::resolver::executor_type ex = resolver.get_executor();
-    (void)ex;
-
-    // basic_resolver functions.
-
-    resolver.cancel();
-
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::icmp::resolver::results_type results1 = resolver.resolve(q);
-    (void)results1;
-
-    ip::icmp::resolver::results_type results2 = resolver.resolve(q, ec);
-    (void)results2;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    ip::icmp::resolver::results_type results3 = resolver.resolve("", "");
-    (void)results3;
-
-    ip::icmp::resolver::results_type results4 = resolver.resolve("", "", ec);
-    (void)results4;
-
-    ip::icmp::resolver::results_type results5 =
-      resolver.resolve("", "", ip::icmp::resolver::flags());
-    (void)results5;
-
-    ip::icmp::resolver::results_type results6 =
-      resolver.resolve("", "", ip::icmp::resolver::flags(), ec);
-    (void)results6;
-
-    ip::icmp::resolver::results_type results7 =
-      resolver.resolve(ip::icmp::v4(), "", "");
-    (void)results7;
-
-    ip::icmp::resolver::results_type results8 =
-      resolver.resolve(ip::icmp::v4(), "", "", ec);
-    (void)results8;
-
-    ip::icmp::resolver::results_type results9 =
-      resolver.resolve(ip::icmp::v4(), "", "", ip::icmp::resolver::flags());
-    (void)results9;
-
-    ip::icmp::resolver::results_type results10 =
-      resolver.resolve(ip::icmp::v4(), "", "", ip::icmp::resolver::flags(), ec);
-    (void)results10;
-
-    ip::icmp::resolver::results_type results11 = resolver.resolve(e);
-    (void)results11;
-
-    ip::icmp::resolver::results_type results12 = resolver.resolve(e, ec);
-    (void)results12;
-
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(q, resolve_handler());
-    int i1 = resolver.async_resolve(q, lazy);
-    (void)i1;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    resolver.async_resolve("", "", resolve_handler());
-    int i2 = resolver.async_resolve("", "", lazy);
-    (void)i2;
-
-    resolver.async_resolve("", "",
-        ip::icmp::resolver::flags(), resolve_handler());
-    int i3 = resolver.async_resolve("", "",
-        ip::icmp::resolver::flags(), lazy);
-    (void)i3;
-    resolver.async_resolve(ip::icmp::v4(), "", "", resolve_handler());
-    int i4 = resolver.async_resolve(ip::icmp::v4(), "", "", lazy);
-    (void)i4;
-
-    resolver.async_resolve(ip::icmp::v4(),
-        "", "", ip::icmp::resolver::flags(), resolve_handler());
-    int i5 = resolver.async_resolve(ip::icmp::v4(),
-        "", "", ip::icmp::resolver::flags(), lazy);
-    (void)i5;
-
-    resolver.async_resolve(e, resolve_handler());
-    int i6 = resolver.async_resolve(e, lazy);
-    (void)i6;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_icmp_resolver_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/icmp",
-  ASIO_COMPILE_TEST_CASE(ip_icmp_socket_compile::test)
-  ASIO_COMPILE_TEST_CASE(ip_icmp_resolver_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/multicast.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/multicast.cpp
deleted file mode 100644
index 4f0b3f4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/multicast.cpp
+++ /dev/null
@@ -1,363 +0,0 @@
-//
-// multicast.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/multicast.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/ip/udp.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_multicast_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all nested classes, enums and constants in
-// ip::multicast compile and link correctly. Runtime failures are ignored.
-
-namespace ip_multicast_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    ip::udp::socket sock(ioc);
-    const ip::address address;
-    const ip::address_v4 address_v4;
-    const ip::address_v6 address_v6;
-
-    // join_group class.
-
-    ip::multicast::join_group join_group1;
-    ip::multicast::join_group join_group2(address);
-    ip::multicast::join_group join_group3(address_v4);
-    ip::multicast::join_group join_group4(address_v4, address_v4);
-    ip::multicast::join_group join_group5(address_v6);
-    ip::multicast::join_group join_group6(address_v6, 1);
-    sock.set_option(join_group6);
-
-    // leave_group class.
-
-    ip::multicast::leave_group leave_group1;
-    ip::multicast::leave_group leave_group2(address);
-    ip::multicast::leave_group leave_group3(address_v4);
-    ip::multicast::leave_group leave_group4(address_v4, address_v4);
-    ip::multicast::leave_group leave_group5(address_v6);
-    ip::multicast::leave_group leave_group6(address_v6, 1);
-    sock.set_option(leave_group6);
-
-    // outbound_interface class.
-
-    ip::multicast::outbound_interface outbound_interface1;
-    ip::multicast::outbound_interface outbound_interface2(address_v4);
-    ip::multicast::outbound_interface outbound_interface3(1);
-    sock.set_option(outbound_interface3);
-
-    // hops class.
-
-    ip::multicast::hops hops1(1024);
-    sock.set_option(hops1);
-    ip::multicast::hops hops2;
-    sock.get_option(hops2);
-    hops1 = 1;
-    (void)static_cast<int>(hops1.value());
-
-    // enable_loopback class.
-
-    ip::multicast::enable_loopback enable_loopback1(true);
-    sock.set_option(enable_loopback1);
-    ip::multicast::enable_loopback enable_loopback2;
-    sock.get_option(enable_loopback2);
-    enable_loopback1 = true;
-    (void)static_cast<bool>(enable_loopback1);
-    (void)static_cast<bool>(!enable_loopback1);
-    (void)static_cast<bool>(enable_loopback1.value());
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_multicast_compile
-
-//------------------------------------------------------------------------------
-
-// ip_multicast_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the socket options defined
-// in the ip::multicast namespace.
-
-namespace ip_multicast_runtime {
-
-#if defined(__hpux)
-// HP-UX doesn't declare this function extern "C", so it is declared again here
-// to avoid a linker error about an undefined symbol.
-extern "C" unsigned int if_nametoindex(const char*);
-#endif // defined(__hpux)
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-  asio::error_code ec;
-
-  ip::udp::endpoint ep_v4(ip::address_v4::loopback(), 0);
-  ip::udp::socket sock_v4(ioc);
-  sock_v4.open(ep_v4.protocol(), ec);
-  sock_v4.bind(ep_v4, ec);
-  bool have_v4 = !ec;
-
-  ip::udp::endpoint ep_v6(ip::address_v6::loopback(), 0);
-  ip::udp::socket sock_v6(ioc);
-  sock_v6.open(ep_v6.protocol(), ec);
-  sock_v6.bind(ep_v6, ec);
-  bool have_v6 = !ec;
-
-  ASIO_CHECK(have_v4 || have_v6);
-
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Windows CE seems to have problems with some multicast group addresses.
-  // The following address works on CE, but as it is not a private multicast
-  // address it will not be used on other platforms.
-  const ip::address multicast_address_v4 = ip::make_address("239.0.0.4", ec);
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  const ip::address multicast_address_v4 = ip::make_address("239.255.0.1", ec);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK(!have_v4 || !ec);
-
-#if (defined(__MACH__) && defined(__APPLE__)) \
-  || defined(__FreeBSD__) \
-  || defined(__NetBSD__) \
-  || defined(__OpenBSD__)
-  const ip::address multicast_address_v6 = ip::make_address("ff02::1%lo0", ec);
-#else // (defined(__MACH__) && defined(__APPLE__))
-      //   || defined(__FreeBSD__)
-      //   || defined(__NetBSD__)
-      //   || defined(__OpenBSD__)
-  const ip::address multicast_address_v6 = ip::make_address("ff01::1", ec);
-#endif // (defined(__MACH__) && defined(__APPLE__))
-       //   || defined(__FreeBSD__)
-       //   || defined(__NetBSD__)
-       //   || defined(__OpenBSD__)
-  ASIO_CHECK(!have_v6 || !ec);
-
-  // join_group class.
-
-  if (have_v4)
-  {
-    ip::multicast::join_group join_group(multicast_address_v4);
-    sock_v4.set_option(join_group, ec);
-    ASIO_CHECK_MESSAGE(!ec || ec == error::no_such_device,
-                       ec.value() << ", " << ec.message());
-
-    if (!ec)
-    {
-      // leave_group class.
-
-      ip::multicast::leave_group leave_group(multicast_address_v4);
-      sock_v4.set_option(leave_group, ec);
-      ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    }
-  }
-
-  if (have_v6)
-  {
-    ip::multicast::join_group join_group(multicast_address_v6);
-    sock_v6.set_option(join_group, ec);
-    ASIO_CHECK_MESSAGE(!ec || ec == error::no_such_device,
-                       ec.value() << ", " << ec.message());
-
-    if (!ec)
-    {
-      // leave_group class.
-
-      ip::multicast::leave_group leave_group(multicast_address_v6);
-      sock_v6.set_option(leave_group, ec);
-      ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    }
-  }
-
-  // outbound_interface class.
-
-  if (have_v4)
-  {
-    ip::multicast::outbound_interface outbound_interface(
-        ip::address_v4::loopback());
-    sock_v4.set_option(outbound_interface, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  }
-
-  if (have_v6)
-  {
-#if defined(__hpux)
-    ip::multicast::outbound_interface outbound_interface(if_nametoindex("lo0"));
-#else
-    ip::multicast::outbound_interface outbound_interface(1);
-#endif
-    sock_v6.set_option(outbound_interface, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  }
-
-  // hops class.
-
-  if (have_v4)
-  {
-    ip::multicast::hops hops1(1);
-    ASIO_CHECK(hops1.value() == 1);
-    sock_v4.set_option(hops1, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::hops hops2;
-    sock_v4.get_option(hops2, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(hops2.value() == 1);
-
-    ip::multicast::hops hops3(0);
-    ASIO_CHECK(hops3.value() == 0);
-    sock_v4.set_option(hops3, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::hops hops4;
-    sock_v4.get_option(hops4, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(hops4.value() == 0);
-  }
-
-  if (have_v6)
-  {
-    ip::multicast::hops hops1(1);
-    ASIO_CHECK(hops1.value() == 1);
-    sock_v6.set_option(hops1, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::hops hops2;
-    sock_v6.get_option(hops2, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(hops2.value() == 1);
-
-    ip::multicast::hops hops3(0);
-    ASIO_CHECK(hops3.value() == 0);
-    sock_v6.set_option(hops3, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::hops hops4;
-    sock_v6.get_option(hops4, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(hops4.value() == 0);
-  }
-
-  // enable_loopback class.
-
-  if (have_v4)
-  {
-    ip::multicast::enable_loopback enable_loopback1(true);
-    ASIO_CHECK(enable_loopback1.value());
-    ASIO_CHECK(static_cast<bool>(enable_loopback1));
-    ASIO_CHECK(!!enable_loopback1);
-    sock_v4.set_option(enable_loopback1, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::multicast::enable_loopback enable_loopback2;
-    sock_v4.get_option(enable_loopback2, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Not supported under Windows CE but can get value.
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(enable_loopback2.value());
-    ASIO_CHECK(static_cast<bool>(enable_loopback2));
-    ASIO_CHECK(!!enable_loopback2);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::multicast::enable_loopback enable_loopback3(false);
-    ASIO_CHECK(!enable_loopback3.value());
-    ASIO_CHECK(!static_cast<bool>(enable_loopback3));
-    ASIO_CHECK(!enable_loopback3);
-    sock_v4.set_option(enable_loopback3, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::multicast::enable_loopback enable_loopback4;
-    sock_v4.get_option(enable_loopback4, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Not supported under Windows CE but can get value.
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(!enable_loopback4.value());
-    ASIO_CHECK(!static_cast<bool>(enable_loopback4));
-    ASIO_CHECK(!enable_loopback4);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  }
-
-  if (have_v6)
-  {
-    ip::multicast::enable_loopback enable_loopback1(true);
-    ASIO_CHECK(enable_loopback1.value());
-    ASIO_CHECK(static_cast<bool>(enable_loopback1));
-    ASIO_CHECK(!!enable_loopback1);
-    sock_v6.set_option(enable_loopback1, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::enable_loopback enable_loopback2;
-    sock_v6.get_option(enable_loopback2, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(enable_loopback2.value());
-    ASIO_CHECK(static_cast<bool>(enable_loopback2));
-    ASIO_CHECK(!!enable_loopback2);
-
-    ip::multicast::enable_loopback enable_loopback3(false);
-    ASIO_CHECK(!enable_loopback3.value());
-    ASIO_CHECK(!static_cast<bool>(enable_loopback3));
-    ASIO_CHECK(!enable_loopback3);
-    sock_v6.set_option(enable_loopback3, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-    ip::multicast::enable_loopback enable_loopback4;
-    sock_v6.get_option(enable_loopback4, ec);
-    ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-    ASIO_CHECK(!enable_loopback4.value());
-    ASIO_CHECK(!static_cast<bool>(enable_loopback4));
-    ASIO_CHECK(!enable_loopback4);
-  }
-}
-
-} // namespace ip_multicast_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/multicast",
-  ASIO_COMPILE_TEST_CASE(ip_multicast_compile::test)
-  ASIO_TEST_CASE(ip_multicast_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v4.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v4.cpp
deleted file mode 100644
index 0b7a7a9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v4.cpp
+++ /dev/null
@@ -1,314 +0,0 @@
-//
-// network_v4.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/network_v4.hpp"
-
-#include "../unit_test.hpp"
-#include <sstream>
-
-//------------------------------------------------------------------------------
-
-// ip_network_v4_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::network_v4 compile and link correctly. Runtime failures are ignored.
-
-namespace ip_network_v4_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    asio::error_code ec;
-
-    // network_v4 constructors.
-
-    ip::network_v4 net1(ip::make_address_v4("192.168.1.0"), 32);
-    ip::network_v4 net2(ip::make_address_v4("192.168.1.0"),
-        ip::make_address_v4("255.255.255.0"));
-
-    // network_v4 functions.
-
-    ip::address_v4 addr1 = net1.address();
-    (void)addr1;
-
-    unsigned short prefix_len = net1.prefix_length();
-    (void)prefix_len;
-
-    ip::address_v4 addr2 = net1.netmask();
-    (void)addr2;
-
-    ip::address_v4 addr3 = net1.network();
-    (void)addr3;
-
-    ip::address_v4 addr4 = net1.broadcast();
-    (void)addr4;
-
-    ip::address_v4_range hosts = net1.hosts();
-    (void)hosts;
-
-    ip::network_v4 net3 = net1.canonical();
-    (void)net3;
-
-    bool b1 = net1.is_host();
-    (void)b1;
-
-    bool b2 = net1.is_subnet_of(net2);
-    (void)b2;
-
-    std::string s1 = net1.to_string();
-    (void)s1;
-
-    std::string s2 = net1.to_string(ec);
-    (void)s2;
-
-    // network_v4 comparisons.
-
-    bool b3 = (net1 == net2);
-    (void)b3;
-
-    bool b4 = (net1 != net2);
-    (void)b4;
-
-    // network_v4 creation functions.
-
-    net1 = ip::make_network_v4(ip::address_v4(), 24);
-    net1 = ip::make_network_v4(ip::address_v4(), ip::address_v4());
-    net1 = ip::make_network_v4("10.0.0.0/8");
-    net1 = ip::make_network_v4("10.0.0.0/8", ec);
-    net1 = ip::make_network_v4(s1);
-    net1 = ip::make_network_v4(s1, ec);
-#if defined(ASIO_HAS_STRING_VIEW)
-# if defined(ASIO_HAS_STD_STRING_VIEW)
-    std::string_view string_view_value("10.0.0.0/8");
-# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    std::experimental::string_view string_view_value("10.0.0.0/8");
-# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    net1 = ip::make_network_v4(string_view_value);
-    net1 = ip::make_network_v4(string_view_value, ec);
-#endif // defined(ASIO_HAS_STRING_VIEW)
-
-    // network_v4 I/O.
-
-    std::ostringstream os;
-    os << net1;
-
-#if !defined(BOOST_NO_STD_WSTREAMBUF)
-    std::wostringstream wos;
-    wos << net1;
-#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_network_v4_compile
-
-//------------------------------------------------------------------------------
-
-// ip_network_v4_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that the various public member functions meet the
-// necessary postconditions.
-
-namespace ip_network_v4_runtime {
-
-void test()
-{
-  using asio::ip::address_v4;
-  using asio::ip::make_address_v4;
-  using asio::ip::network_v4;
-  using asio::ip::make_network_v4;
-
-  address_v4 addr = make_address_v4("1.2.3.4");
-
-  // calculate prefix length
-
-  network_v4 net1(addr, make_address_v4("255.255.255.0"));
-  ASIO_CHECK(net1.prefix_length() == 24);
-
-  network_v4 net2(addr, make_address_v4("255.255.255.192"));
-  ASIO_CHECK(net2.prefix_length() == 26);
-
-  network_v4 net3(addr, make_address_v4("128.0.0.0"));
-  ASIO_CHECK(net3.prefix_length() == 1);
-
-  std::string msg;
-  try
-  {
-    make_network_v4(addr, make_address_v4("255.255.255.1"));
-  }
-  catch(std::exception& ex)
-  {
-    msg = ex.what();
-  }
-  ASIO_CHECK(msg == std::string("non-contiguous netmask"));
-
-  msg.clear();
-  try
-  {
-    make_network_v4(addr, make_address_v4("0.255.255.0"));
-  }
-  catch(std::exception& ex)
-  {
-    msg = ex.what();
-  }
-  ASIO_CHECK(msg == std::string("non-contiguous netmask"));
-
-  // calculate netmask
-
-  network_v4 net4(addr, 23);
-  ASIO_CHECK(net4.netmask() == make_address_v4("255.255.254.0"));
-
-  network_v4 net5(addr, 12);
-  ASIO_CHECK(net5.netmask() == make_address_v4("255.240.0.0"));
-
-  network_v4 net6(addr, 24);
-  ASIO_CHECK(net6.netmask() == make_address_v4("255.255.255.0"));
-
-  network_v4 net7(addr, 16);
-  ASIO_CHECK(net7.netmask() == make_address_v4("255.255.0.0"));
-
-  network_v4 net8(addr, 8);
-  ASIO_CHECK(net8.netmask() == make_address_v4("255.0.0.0"));
-
-  network_v4 net9(addr, 32);
-  ASIO_CHECK(net9.netmask() == make_address_v4("255.255.255.255"));
-
-  network_v4 net10(addr, 1);
-  ASIO_CHECK(net10.netmask() == make_address_v4("128.0.0.0"));
-
-  network_v4 net11(addr, 0);
-  ASIO_CHECK(net11.netmask() == make_address_v4("0.0.0.0"));
-
-  msg.clear();
-  try
-  {
-    make_network_v4(addr, 33);
-  }
-  catch(std::out_of_range& ex)
-  {
-    msg = ex.what();
-  }
-  ASIO_CHECK(msg == std::string("prefix length too large"));
-
-  // construct address range from address and prefix length
-  ASIO_CHECK(network_v4(make_address_v4("192.168.77.100"), 32).network() == make_address_v4("192.168.77.100"));
-  ASIO_CHECK(network_v4(make_address_v4("192.168.77.100"), 24).network() == make_address_v4("192.168.77.0"));
-  ASIO_CHECK(network_v4(make_address_v4("192.168.77.128"), 25).network() == make_address_v4("192.168.77.128"));
-
-  // construct address range from string in CIDR notation
-  ASIO_CHECK(make_network_v4("192.168.77.100/32").network() == make_address_v4("192.168.77.100"));
-  ASIO_CHECK(make_network_v4("192.168.77.100/24").network() == make_address_v4("192.168.77.0"));
-  ASIO_CHECK(make_network_v4("192.168.77.128/25").network() == make_address_v4("192.168.77.128"));
-
-  // construct network from invalid string
-  asio::error_code ec;
-  make_network_v4("10.0.0.256/24", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v4("10.0.0.0/33", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v4("10.0.0.0/-1", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v4("10.0.0.0/", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v4("10.0.0.0", ec);
-  ASIO_CHECK(!!ec);
-
-  // prefix length
-  ASIO_CHECK(make_network_v4("193.99.144.80/24").prefix_length() == 24);
-  ASIO_CHECK(network_v4(make_address_v4("193.99.144.80"), 24).prefix_length() == 24);
-  ASIO_CHECK(network_v4(make_address_v4("192.168.77.0"), make_address_v4("255.255.255.0")).prefix_length() == 24);
-
-  // to string
-  std::string a("192.168.77.0/32");
-  ASIO_CHECK(make_network_v4(a.c_str()).to_string() == a);
-  ASIO_CHECK(network_v4(make_address_v4("192.168.77.10"), 24).to_string() == std::string("192.168.77.10/24"));
-
-  // return host part
-  ASIO_CHECK(make_network_v4("192.168.77.11/24").address() == make_address_v4("192.168.77.11"));
-
-  // return host in CIDR notation
-  ASIO_CHECK(make_network_v4("192.168.78.30/20").address().to_string() == "192.168.78.30");
-
-  // return network in CIDR notation
-  ASIO_CHECK(make_network_v4("192.168.78.30/20").canonical().to_string() == "192.168.64.0/20");
-
-  // is host
-  ASIO_CHECK(make_network_v4("192.168.77.0/32").is_host());
-  ASIO_CHECK(!make_network_v4("192.168.77.0/31").is_host());
-
-  // is real subnet of
-  ASIO_CHECK(make_network_v4("192.168.0.192/24").is_subnet_of(make_network_v4("192.168.0.0/16")));
-  ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.192.168/16")));
-  ASIO_CHECK(make_network_v4("192.168.0.192/24").is_subnet_of(make_network_v4("192.168.192.168/16")));
-  ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/16")));
-  ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/23")));
-  ASIO_CHECK(make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.0.0/0")));
-  ASIO_CHECK(make_network_v4("192.168.0.0/32").is_subnet_of(make_network_v4("192.168.0.0/24")));
-
-  ASIO_CHECK(!make_network_v4("192.168.0.0/32").is_subnet_of(make_network_v4("192.168.0.0/32")));
-  ASIO_CHECK(!make_network_v4("192.168.0.0/24").is_subnet_of(make_network_v4("192.168.1.0/24")));
-  ASIO_CHECK(!make_network_v4("192.168.0.0/16").is_subnet_of(make_network_v4("192.168.1.0/24")));
-
-  network_v4 r(make_network_v4("192.168.0.0/24"));
-  ASIO_CHECK(!r.is_subnet_of(r));
-
-  network_v4 net12(make_network_v4("192.168.0.2/24"));
-  network_v4 net13(make_network_v4("192.168.1.1/28"));
-  network_v4 net14(make_network_v4("192.168.1.21/28"));
-  // network
-  ASIO_CHECK(net12.network() == make_address_v4("192.168.0.0"));
-  ASIO_CHECK(net13.network() == make_address_v4("192.168.1.0"));
-  ASIO_CHECK(net14.network() == make_address_v4("192.168.1.16"));
-  // netmask
-  ASIO_CHECK(net12.netmask() == make_address_v4("255.255.255.0"));
-  ASIO_CHECK(net13.netmask() == make_address_v4("255.255.255.240"));
-  ASIO_CHECK(net14.netmask() == make_address_v4("255.255.255.240"));
-  // broadcast
-  ASIO_CHECK(net12.broadcast() == make_address_v4("192.168.0.255"));
-  ASIO_CHECK(net13.broadcast() == make_address_v4("192.168.1.15"));
-  ASIO_CHECK(net14.broadcast() == make_address_v4("192.168.1.31"));
-  // iterator
-  ASIO_CHECK(std::distance(net12.hosts().begin(),net12.hosts().end()) == 254);
-  ASIO_CHECK(*net12.hosts().begin() == make_address_v4("192.168.0.1"));
-  ASIO_CHECK(net12.hosts().end() != net12.hosts().find(make_address_v4("192.168.0.10")));
-  ASIO_CHECK(net12.hosts().end() == net12.hosts().find(make_address_v4("192.168.1.10")));
-  ASIO_CHECK(std::distance(net13.hosts().begin(),net13.hosts().end()) == 14);
-  ASIO_CHECK(*net13.hosts().begin() == make_address_v4("192.168.1.1"));
-  ASIO_CHECK(net13.hosts().end() != net13.hosts().find(make_address_v4("192.168.1.14")));
-  ASIO_CHECK(net13.hosts().end() == net13.hosts().find(make_address_v4("192.168.1.15")));
-  ASIO_CHECK(std::distance(net14.hosts().begin(),net14.hosts().end()) == 14);
-  ASIO_CHECK(*net14.hosts().begin() == make_address_v4("192.168.1.17"));
-  ASIO_CHECK(net14.hosts().end() != net14.hosts().find(make_address_v4("192.168.1.30")));
-  ASIO_CHECK(net14.hosts().end() == net14.hosts().find(make_address_v4("192.168.1.31")));
-}
-
-} // namespace ip_network_v4_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/network_v4",
-  ASIO_COMPILE_TEST_CASE(ip_network_v4_compile::test)
-  ASIO_TEST_CASE(ip_network_v4_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v6.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v6.cpp
deleted file mode 100644
index d80b1d4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/network_v6.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-//
-// network_v6.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2014 Oliver Kowalke (oliver dot kowalke at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/network_v6.hpp"
-
-#include "../unit_test.hpp"
-#include <sstream>
-
-//------------------------------------------------------------------------------
-
-// ip_network_v6_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::network_v6 compile and link correctly. Runtime failures are ignored.
-
-namespace ip_network_v6_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    asio::error_code ec;
-
-    // network_v6 constructors.
-
-    ip::network_v6 net1(ip::make_address_v6("2001:370::10:7344"), 64);
-    ip::network_v6 net2(ip::make_address_v6("2001:370::10:7345"), 96);
-
-    // network_v6 functions.
-
-    ip::address_v6 addr1 = net1.address();
-    (void)addr1;
-
-    unsigned short prefix_len = net1.prefix_length();
-    (void)prefix_len;
-
-    ip::address_v6 addr3 = net1.network();
-    (void)addr3;
-
-    ip::address_v6_range hosts = net1.hosts();
-    (void)hosts;
-
-    ip::network_v6 net3 = net1.canonical();
-    (void)net3;
-
-    bool b1 = net1.is_host();
-    (void)b1;
-
-    bool b2 = net1.is_subnet_of(net2);
-    (void)b2;
-
-    std::string s1 = net1.to_string();
-    (void)s1;
-
-    std::string s2 = net1.to_string(ec);
-    (void)s2;
-
-    // network_v6 comparisons.
-
-    bool b3 = (net1 == net2);
-    (void)b3;
-
-    bool b4 = (net1 != net2);
-    (void)b4;
-
-    // network_v6 creation functions.
-
-    net1 = ip::make_network_v6(ip::address_v6(), 24);
-    net1 = ip::make_network_v6("10.0.0.0/8");
-    net1 = ip::make_network_v6("10.0.0.0/8", ec);
-    net1 = ip::make_network_v6(s1);
-    net1 = ip::make_network_v6(s1, ec);
-#if defined(ASIO_HAS_STRING_VIEW)
-# if defined(ASIO_HAS_STD_STRING_VIEW)
-    std::string_view string_view_value("0::0/8");
-# elif defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    std::experimental::string_view string_view_value("0::0/8");
-# endif // defined(ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW)
-    net1 = ip::make_network_v6(string_view_value);
-    net1 = ip::make_network_v6(string_view_value, ec);
-#endif // defined(ASIO_STD_STRING_VIEW)
-
-    // network_v6 I/O.
-
-    std::ostringstream os;
-    os << net1;
-
-#if !defined(BOOST_NO_STD_WSTREAMBUF)
-    std::wostringstream wos;
-    wos << net1;
-#endif // !defined(BOOST_NO_STD_WSTREAMBUF)
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_network_v6_compile
-
-//------------------------------------------------------------------------------
-
-// ip_network_v6_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that the various public member functions meet the
-// necessary postconditions.
-
-namespace ip_network_v6_runtime {
-
-void test()
-{
-  using asio::ip::address_v6;
-  using asio::ip::make_address_v6;
-  using asio::ip::network_v6;
-  using asio::ip::make_network_v6;
-
-  address_v6 addr = make_address_v6("2001:370::10:7344");
-
-  std::string msg;
-  try
-  {
-    make_network_v6(addr, 129);
-  }
-  catch(std::out_of_range& ex)
-  {
-    msg = ex.what();
-  }
-  ASIO_CHECK(msg == std::string("prefix length too large"));
-
-  // construct address range from address and prefix length
-  ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 128).network() == make_address_v6("2001:370::10:7344"));
-  ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 64).network() == make_address_v6("2001:370::"));
-  ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).network() == make_address_v6("2001:360::"));
-
-  // construct address range from string in CIDR notation
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/128").network() == make_address_v6("2001:370::10:7344"));
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/64").network() == make_address_v6("2001:370::"));
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/27").network() == make_address_v6("2001:360::"));
-
-  // construct network from invalid string
-  asio::error_code ec;
-  make_network_v6("a:b/24", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v6("2001:370::10:7344/129", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v6("2001:370::10:7344/-1", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v6("2001:370::10:7344/", ec);
-  ASIO_CHECK(!!ec);
-  make_network_v6("2001:370::10:7344", ec);
-  ASIO_CHECK(!!ec);
-
-  // prefix length
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/128").prefix_length() == 128);
-  ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).prefix_length() == 27);
-
-  // to string
-  std::string a("2001:370::10:7344/64");
-  ASIO_CHECK(make_network_v6(a.c_str()).to_string() == a);
-  ASIO_CHECK(network_v6(make_address_v6("2001:370::10:7344"), 27).to_string() == std::string("2001:370::10:7344/27"));
-
-  // return host part
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/64").address() == make_address_v6("2001:370::10:7344"));
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/27").address().to_string() == "2001:370::10:7344");
-
-  // return network in CIDR notation
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/27").canonical().to_string() == "2001:360::/27");
-
-  // is host
-  ASIO_CHECK(make_network_v6("2001:370::10:7344/128").is_host());
-  ASIO_CHECK(!make_network_v6("2001:370::10:7344/127").is_host());
-
-  // is real subnet of
-  ASIO_CHECK(make_network_v6("2001:370::10:3744/64").is_subnet_of(make_network_v6("2001:370::/16")));
-  ASIO_CHECK(make_network_v6("2001:370::/64").is_subnet_of(make_network_v6("2001:370::/16")));
-  ASIO_CHECK(make_network_v6("2001:0db8:85a3::/64").is_subnet_of(make_network_v6("2001:0d00::/24")));
-
-  ASIO_CHECK(!make_network_v6("2001:370::10:3744/128").is_subnet_of(make_network_v6("2001:370::10:3744/128")));
-  ASIO_CHECK(make_network_v6("2001:0db8:85a3::/64").is_subnet_of(make_network_v6("2001:0dc0::/24")));
-
-  network_v6 r(make_network_v6("2001:370::/64"));
-  ASIO_CHECK(!r.is_subnet_of(r));
-
-  network_v6 net12(make_network_v6("2001:370::10:7344/64"));
-  network_v6 net13(make_network_v6("2001:0db8::/127"));
-  network_v6 net14(make_network_v6("2001:0db8::/125"));
-  network_v6 net15(make_network_v6("2001:0db8::/119"));
-
-  // network
-  ASIO_CHECK(net12.network() == make_address_v6("2001:370::"));
-  ASIO_CHECK(net13.network() == make_address_v6("2001:0db8::"));
-  ASIO_CHECK(net14.network() == make_address_v6("2001:0db8::"));
-  ASIO_CHECK(net15.network() == make_address_v6("2001:0db8::"));
-
-  // iterator
-  //ASIO_CHECK(std::distance(net12.hosts().begin(),net12.hosts().end()) == 18446744073709552000);
-  ASIO_CHECK(std::distance(net13.hosts().begin(),net13.hosts().end()) == 2);
-  ASIO_CHECK(std::distance(net14.hosts().begin(),net14.hosts().end()) == 8);
-  ASIO_CHECK(std::distance(net15.hosts().begin(),net15.hosts().end()) == 512);
-  ASIO_CHECK(*net12.hosts().begin() == make_address_v6("2001:0370::"));
-  ASIO_CHECK(net12.hosts().end() != net12.hosts().find(make_address_v6("2001:0370::ffff:ffff:ffff:ffff")));
-  ASIO_CHECK(*net13.hosts().begin() == make_address_v6("2001:0db8::"));
-  ASIO_CHECK(net13.hosts().end() != net13.hosts().find(make_address_v6("2001:0db8::1")));
-  ASIO_CHECK(net13.hosts().end() == net13.hosts().find(make_address_v6("2001:0db8::2")));
-  ASIO_CHECK(*net14.hosts().begin() == make_address_v6("2001:0db8::"));
-  ASIO_CHECK(net14.hosts().end() != net14.hosts().find(make_address_v6("2001:0db8::7")));
-  ASIO_CHECK(net14.hosts().end() == net14.hosts().find(make_address_v6("2001:0db8::8")));
-  ASIO_CHECK(*net15.hosts().begin() == make_address_v6("2001:0db8::"));
-  ASIO_CHECK(net15.hosts().end() != net15.hosts().find(make_address_v6("2001:0db8::01ff")));
-  ASIO_CHECK(net15.hosts().end() == net15.hosts().find(make_address_v6("2001:0db8::0200")));
-}
-
-} // namespace ip_network_v6_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/network_v6",
-  ASIO_COMPILE_TEST_CASE(ip_network_v6_compile::test)
-  ASIO_TEST_CASE(ip_network_v6_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/resolver_query_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/resolver_query_base.cpp
deleted file mode 100644
index b38f509..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/resolver_query_base.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// resolver_query_base.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/resolver_query_base.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ip/resolver_query_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/tcp.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/tcp.cpp
deleted file mode 100644
index 2bbdc3a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/tcp.cpp
+++ /dev/null
@@ -1,1336 +0,0 @@
-//
-// tcp.cpp
-// ~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Enable cancel() support on Windows.
-#define ASIO_ENABLE_CANCELIO 1
-
-// Test that header file is self-contained.
-#include "asio/ip/tcp.hpp"
-
-#include <cstring>
-#include <functional>
-#include "asio/io_context.hpp"
-#include "asio/read.hpp"
-#include "asio/write.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../archetypes/gettable_socket_option.hpp"
-#include "../archetypes/io_control_command.hpp"
-#include "../archetypes/settable_socket_option.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-# include <boost/array.hpp>
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-# include <array>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_compile test
-// ~~~~~~~~~~~~~~~~~~~
-// The following test checks that all nested classes, enums and constants in
-// ip::tcp compile and link correctly. Runtime failures are ignored.
-
-namespace ip_tcp_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    ip::tcp::socket sock(ioc);
-
-    // no_delay class.
-
-    ip::tcp::no_delay no_delay1(true);
-    sock.set_option(no_delay1);
-    ip::tcp::no_delay no_delay2;
-    sock.get_option(no_delay2);
-    no_delay1 = true;
-    (void)static_cast<bool>(no_delay1);
-    (void)static_cast<bool>(!no_delay1);
-    (void)static_cast<bool>(no_delay1.value());
-
-    ip::tcp::endpoint ep;
-    (void)static_cast<std::size_t>(std::hash<ip::tcp::endpoint>()(ep));
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_tcp_compile
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_runtime test
-// ~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the ip::tcp class.
-
-namespace ip_tcp_runtime {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-  ip::tcp::socket sock(ioc, ip::tcp::v4());
-  asio::error_code ec;
-
-  // no_delay class.
-
-  ip::tcp::no_delay no_delay1(true);
-  ASIO_CHECK(no_delay1.value());
-  ASIO_CHECK(static_cast<bool>(no_delay1));
-  ASIO_CHECK(!!no_delay1);
-  sock.set_option(no_delay1, ec);
-  ASIO_CHECK(!ec);
-
-  ip::tcp::no_delay no_delay2;
-  sock.get_option(no_delay2, ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(no_delay2.value());
-  ASIO_CHECK(static_cast<bool>(no_delay2));
-  ASIO_CHECK(!!no_delay2);
-
-  ip::tcp::no_delay no_delay3(false);
-  ASIO_CHECK(!no_delay3.value());
-  ASIO_CHECK(!static_cast<bool>(no_delay3));
-  ASIO_CHECK(!no_delay3);
-  sock.set_option(no_delay3, ec);
-  ASIO_CHECK(!ec);
-
-  ip::tcp::no_delay no_delay4;
-  sock.get_option(no_delay4, ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(!no_delay4.value());
-  ASIO_CHECK(!static_cast<bool>(no_delay4));
-  ASIO_CHECK(!no_delay4);
-}
-
-} // namespace ip_tcp_runtime
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::tcp::socket compile and link correctly. Runtime failures are ignored.
-
-namespace ip_tcp_socket_compile {
-
-struct connect_handler
-{
-  connect_handler() {}
-  void operator()(const asio::error_code&) {}
-  connect_handler(connect_handler&&) {}
-private:
-  connect_handler(const connect_handler&);
-};
-
-struct wait_handler
-{
-  wait_handler() {}
-  void operator()(const asio::error_code&) {}
-  wait_handler(wait_handler&&) {}
-private:
-  wait_handler(const wait_handler&);
-};
-
-struct send_handler
-{
-  send_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  send_handler(send_handler&&) {}
-private:
-  send_handler(const send_handler&);
-};
-
-struct receive_handler
-{
-  receive_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  receive_handler(receive_handler&&) {}
-private:
-  receive_handler(const receive_handler&);
-};
-
-struct write_some_handler
-{
-  write_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_handler(write_some_handler&&) {}
-private:
-  write_some_handler(const write_some_handler&);
-};
-
-struct read_some_handler
-{
-  read_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_handler(read_some_handler&&) {}
-private:
-  read_some_handler(const read_some_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  using boost::array;
-#else // defined(ASIO_HAS_BOOST_ARRAY)
-  using std::array;
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    array<asio::mutable_buffer, 2> mutable_buffers = {{
-        asio::buffer(mutable_char_buffer, 10),
-        asio::buffer(mutable_char_buffer + 10, 10) }};
-    array<asio::const_buffer, 2> const_buffers = {{
-        asio::buffer(const_char_buffer, 10),
-        asio::buffer(const_char_buffer + 10, 10) }};
-    socket_base::message_flags in_flags = 0;
-    archetypes::settable_socket_option<void> settable_socket_option1;
-    archetypes::settable_socket_option<int> settable_socket_option2;
-    archetypes::settable_socket_option<double> settable_socket_option3;
-    archetypes::gettable_socket_option<void> gettable_socket_option1;
-    archetypes::gettable_socket_option<int> gettable_socket_option2;
-    archetypes::gettable_socket_option<double> gettable_socket_option3;
-    archetypes::io_control_command io_control_command;
-    archetypes::immediate_handler immediate;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_stream_socket constructors.
-
-    ip::tcp::socket socket1(ioc);
-    ip::tcp::socket socket2(ioc, ip::tcp::v4());
-    ip::tcp::socket socket3(ioc, ip::tcp::v6());
-    ip::tcp::socket socket4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
-    ip::tcp::socket socket5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::socket::native_handle_type native_socket1
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    ip::tcp::socket socket6(ioc, ip::tcp::v4(), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::tcp::socket socket7(ioc_ex);
-    ip::tcp::socket socket8(ioc_ex, ip::tcp::v4());
-    ip::tcp::socket socket9(ioc_ex, ip::tcp::v6());
-    ip::tcp::socket socket10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0));
-    ip::tcp::socket socket11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::socket::native_handle_type native_socket2
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    ip::tcp::socket socket12(ioc_ex, ip::tcp::v4(), native_socket2);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::tcp::socket socket13(std::move(socket5));
-
-    // basic_stream_socket operators.
-
-    socket1 = ip::tcp::socket(ioc);
-    socket1 = std::move(socket2);
-
-    // basic_io_object functions.
-
-    ip::tcp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    ip::tcp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    const ip::tcp::socket& socket14 = socket1;
-    const ip::tcp::socket::lowest_layer_type& lowest_layer2
-      = socket14.lowest_layer();
-    (void)lowest_layer2;
-
-    socket1.open(ip::tcp::v4());
-    socket1.open(ip::tcp::v6());
-    socket1.open(ip::tcp::v4(), ec);
-    socket1.open(ip::tcp::v6(), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::socket::native_handle_type native_socket3
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    socket1.assign(ip::tcp::v4(), native_socket3);
-    ip::tcp::socket::native_handle_type native_socket4
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    socket1.assign(ip::tcp::v4(), native_socket4, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    socket1.release();
-    socket1.release(ec);
-
-    ip::tcp::socket::native_handle_type native_socket5
-      = socket1.native_handle();
-    (void)native_socket5;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0));
-    socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0));
-    socket1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
-    socket1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
-
-    socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0));
-    socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0));
-    socket1.connect(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
-    socket1.connect(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
-
-    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0),
-        connect_handler());
-    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0),
-        connect_handler());
-    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), immediate);
-    socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), immediate);
-    int i1 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v4(), 0), lazy);
-    (void)i1;
-    int i2 = socket1.async_connect(ip::tcp::endpoint(ip::tcp::v6(), 0), lazy);
-    (void)i2;
-
-    socket1.set_option(settable_socket_option1);
-    socket1.set_option(settable_socket_option1, ec);
-    socket1.set_option(settable_socket_option2);
-    socket1.set_option(settable_socket_option2, ec);
-    socket1.set_option(settable_socket_option3);
-    socket1.set_option(settable_socket_option3, ec);
-
-    socket1.get_option(gettable_socket_option1);
-    socket1.get_option(gettable_socket_option1, ec);
-    socket1.get_option(gettable_socket_option2);
-    socket1.get_option(gettable_socket_option2, ec);
-    socket1.get_option(gettable_socket_option3);
-    socket1.get_option(gettable_socket_option3, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    bool non_blocking1 = socket1.non_blocking();
-    (void)non_blocking1;
-    socket1.non_blocking(true);
-    socket1.non_blocking(false, ec);
-
-    bool non_blocking2 = socket1.native_non_blocking();
-    (void)non_blocking2;
-    socket1.native_non_blocking(true);
-    socket1.native_non_blocking(false, ec);
-
-    ip::tcp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    ip::tcp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    ip::tcp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    ip::tcp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    socket1.wait(socket_base::wait_read);
-    socket1.wait(socket_base::wait_write, ec);
-
-    socket1.async_wait(socket_base::wait_read, wait_handler());
-    socket1.async_wait(socket_base::wait_read, immediate);
-    int i3 = socket1.async_wait(socket_base::wait_write, lazy);
-    (void)i3;
-
-    // basic_stream_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(mutable_buffers);
-    socket1.send(const_buffers);
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(mutable_buffers, in_flags);
-    socket1.send(const_buffers, in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(mutable_buffers, in_flags, ec);
-    socket1.send(const_buffers, in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler());
-    socket1.async_send(buffer(const_char_buffer), send_handler());
-    socket1.async_send(mutable_buffers, send_handler());
-    socket1.async_send(const_buffers, send_handler());
-    socket1.async_send(null_buffers(), send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler());
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler());
-    socket1.async_send(mutable_buffers, in_flags, send_handler());
-    socket1.async_send(const_buffers, in_flags, send_handler());
-    socket1.async_send(null_buffers(), in_flags, send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(mutable_buffers, immediate);
-    socket1.async_send(const_buffers, immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(mutable_buffers, in_flags, immediate);
-    socket1.async_send(const_buffers, in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-    int i4 = socket1.async_send(buffer(mutable_char_buffer), lazy);
-    (void)i4;
-    int i5 = socket1.async_send(buffer(const_char_buffer), lazy);
-    (void)i5;
-    int i6 = socket1.async_send(mutable_buffers, lazy);
-    (void)i6;
-    int i7 = socket1.async_send(const_buffers, lazy);
-    (void)i7;
-    int i8 = socket1.async_send(null_buffers(), lazy);
-    (void)i8;
-    int i9 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
-    (void)i9;
-    int i10 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
-    (void)i10;
-    int i11 = socket1.async_send(mutable_buffers, in_flags, lazy);
-    (void)i11;
-    int i12 = socket1.async_send(const_buffers, in_flags, lazy);
-    (void)i12;
-    int i13 = socket1.async_send(null_buffers(), in_flags, lazy);
-    (void)i13;
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(mutable_buffers);
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(mutable_buffers, in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(mutable_buffers, in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
-    socket1.async_receive(mutable_buffers, receive_handler());
-    socket1.async_receive(null_buffers(), receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler());
-    socket1.async_receive(mutable_buffers, in_flags, receive_handler());
-    socket1.async_receive(null_buffers(), in_flags, receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(mutable_buffers, immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_receive(mutable_buffers, in_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-    int i14 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
-    (void)i14;
-    int i15 = socket1.async_receive(mutable_buffers, lazy);
-    (void)i15;
-    int i16 = socket1.async_receive(null_buffers(), lazy);
-    (void)i16;
-    int i17 = socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        lazy);
-    (void)i17;
-    int i18 = socket1.async_receive(mutable_buffers, in_flags, lazy);
-    (void)i18;
-    int i19 = socket1.async_receive(null_buffers(), in_flags, lazy);
-    (void)i19;
-
-    socket1.write_some(buffer(mutable_char_buffer));
-    socket1.write_some(buffer(const_char_buffer));
-    socket1.write_some(mutable_buffers);
-    socket1.write_some(const_buffers);
-    socket1.write_some(null_buffers());
-    socket1.write_some(buffer(mutable_char_buffer), ec);
-    socket1.write_some(buffer(const_char_buffer), ec);
-    socket1.write_some(mutable_buffers, ec);
-    socket1.write_some(const_buffers, ec);
-    socket1.write_some(null_buffers(), ec);
-
-    socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
-    socket1.async_write_some(buffer(const_char_buffer), write_some_handler());
-    socket1.async_write_some(mutable_buffers, write_some_handler());
-    socket1.async_write_some(const_buffers, write_some_handler());
-    socket1.async_write_some(null_buffers(), write_some_handler());
-    socket1.async_write_some(buffer(mutable_char_buffer), immediate);
-    socket1.async_write_some(buffer(const_char_buffer), immediate);
-    socket1.async_write_some(mutable_buffers, immediate);
-    socket1.async_write_some(const_buffers, immediate);
-    socket1.async_write_some(null_buffers(), immediate);
-    int i20 = socket1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i20;
-    int i21 = socket1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i21;
-    int i22 = socket1.async_write_some(mutable_buffers, lazy);
-    (void)i22;
-    int i23 = socket1.async_write_some(const_buffers, lazy);
-    (void)i23;
-    int i24 = socket1.async_write_some(null_buffers(), lazy);
-    (void)i24;
-
-    socket1.read_some(buffer(mutable_char_buffer));
-    socket1.read_some(mutable_buffers);
-    socket1.read_some(null_buffers());
-    socket1.read_some(buffer(mutable_char_buffer), ec);
-    socket1.read_some(mutable_buffers, ec);
-    socket1.read_some(null_buffers(), ec);
-
-    socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
-    socket1.async_read_some(mutable_buffers, read_some_handler());
-    socket1.async_read_some(null_buffers(), read_some_handler());
-    socket1.async_read_some(buffer(mutable_char_buffer), immediate);
-    socket1.async_read_some(mutable_buffers, immediate);
-    socket1.async_read_some(null_buffers(), immediate);
-    int i25 = socket1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i25;
-    int i26 = socket1.async_read_some(mutable_buffers, lazy);
-    (void)i26;
-    int i27 = socket1.async_read_some(null_buffers(), lazy);
-    (void)i27;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_tcp_socket_compile
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_socket_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the ip::tcp::socket class.
-
-namespace ip_tcp_socket_runtime {
-
-static const char write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void handle_read_noop(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void handle_write_noop(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void handle_read(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-}
-
-void handle_write(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!err);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-}
-
-void handle_read_cancel(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(err == asio::error::operation_aborted);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void handle_read_eof(const asio::error_code& err,
-    size_t bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(err == asio::error::eof);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test()
-{
-  using namespace std; // For memcmp.
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  io_context ioc;
-
-  ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
-  ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(ip::address_v4::loopback());
-
-  ip::tcp::socket client_side_socket(ioc);
-  ip::tcp::socket server_side_socket(ioc);
-
-  client_side_socket.connect(server_endpoint);
-  acceptor.accept(server_side_socket);
-
-  // No-op read.
-
-  bool read_noop_completed = false;
-  client_side_socket.async_read_some(
-      asio::mutable_buffer(0, 0),
-      bindns::bind(handle_read_noop,
-        _1, _2, &read_noop_completed));
-
-  ioc.run();
-  ASIO_CHECK(read_noop_completed);
-
-  // No-op write.
-
-  bool write_noop_completed = false;
-  client_side_socket.async_write_some(
-      asio::const_buffer(0, 0),
-      bindns::bind(handle_write_noop,
-        _1, _2, &write_noop_completed));
-
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(write_noop_completed);
-
-  // Read and write to transfer data.
-
-  char read_buffer[sizeof(write_data)];
-  bool read_completed = false;
-  asio::async_read(client_side_socket,
-      asio::buffer(read_buffer),
-      bindns::bind(handle_read,
-        _1, _2, &read_completed));
-
-  bool write_completed = false;
-  asio::async_write(server_side_socket,
-      asio::buffer(write_data),
-      bindns::bind(handle_write,
-        _1, _2, &write_completed));
-
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(read_completed);
-  ASIO_CHECK(write_completed);
-  ASIO_CHECK(memcmp(read_buffer, write_data, sizeof(write_data)) == 0);
-
-  // Cancelled read.
-
-  bool read_cancel_completed = false;
-  asio::async_read(server_side_socket,
-      asio::buffer(read_buffer),
-      bindns::bind(handle_read_cancel,
-        _1, _2, &read_cancel_completed));
-
-  ioc.restart();
-  ioc.poll();
-  ASIO_CHECK(!read_cancel_completed);
-
-  server_side_socket.cancel();
-
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(read_cancel_completed);
-
-  // A read when the peer closes socket should fail with eof.
-
-  bool read_eof_completed = false;
-  asio::async_read(client_side_socket,
-      asio::buffer(read_buffer),
-      bindns::bind(handle_read_eof,
-        _1, _2, &read_eof_completed));
-
-  server_side_socket.close();
-
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(read_eof_completed);
-}
-
-} // namespace ip_tcp_socket_runtime
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_acceptor_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::tcp::acceptor compile and link correctly. Runtime failures are ignored.
-
-namespace ip_tcp_acceptor_compile {
-
-struct wait_handler
-{
-  wait_handler() {}
-  void operator()(const asio::error_code&) {}
-  wait_handler(wait_handler&&) {}
-private:
-  wait_handler(const wait_handler&);
-};
-
-struct accept_handler
-{
-  accept_handler() {}
-  void operator()(const asio::error_code&) {}
-  accept_handler(accept_handler&&) {}
-private:
-  accept_handler(const accept_handler&);
-};
-
-struct move_accept_handler
-{
-  move_accept_handler() {}
-  void operator()(
-      const asio::error_code&, asio::ip::tcp::socket) {}
-  move_accept_handler(move_accept_handler&&) {}
-private:
-  move_accept_handler(const move_accept_handler&) {}
-};
-
-struct move_accept_ioc_handler
-{
-  move_accept_ioc_handler() {}
-  void operator()(const asio::error_code&,
-      asio::basic_stream_socket<asio::ip::tcp,
-        asio::io_context::executor_type>) {}
-  move_accept_ioc_handler(move_accept_handler&&) {}
-private:
-  move_accept_ioc_handler(const move_accept_handler&) {}
-};
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    ip::tcp::socket peer_socket1(ioc);
-    asio::basic_stream_socket<ip::tcp,
-        io_context::executor_type> peer_socket2(ioc);
-    ip::tcp::endpoint peer_endpoint;
-    archetypes::settable_socket_option<void> settable_socket_option1;
-    archetypes::settable_socket_option<int> settable_socket_option2;
-    archetypes::settable_socket_option<double> settable_socket_option3;
-    archetypes::gettable_socket_option<void> gettable_socket_option1;
-    archetypes::gettable_socket_option<int> gettable_socket_option2;
-    archetypes::gettable_socket_option<double> gettable_socket_option3;
-    archetypes::io_control_command io_control_command;
-    archetypes::immediate_handler immediate;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_socket_acceptor constructors.
-
-    ip::tcp::acceptor acceptor1(ioc);
-    ip::tcp::acceptor acceptor2(ioc, ip::tcp::v4());
-    ip::tcp::acceptor acceptor3(ioc, ip::tcp::v6());
-    ip::tcp::acceptor acceptor4(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
-    ip::tcp::acceptor acceptor5(ioc, ip::tcp::endpoint(ip::tcp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::acceptor::native_handle_type native_acceptor1
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    ip::tcp::acceptor acceptor6(ioc, ip::tcp::v4(), native_acceptor1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::tcp::acceptor acceptor7(ioc_ex);
-    ip::tcp::acceptor acceptor8(ioc_ex, ip::tcp::v4());
-    ip::tcp::acceptor acceptor9(ioc_ex, ip::tcp::v6());
-    ip::tcp::acceptor acceptor10(ioc_ex, ip::tcp::endpoint(ip::tcp::v4(), 0));
-    ip::tcp::acceptor acceptor11(ioc_ex, ip::tcp::endpoint(ip::tcp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::acceptor::native_handle_type native_acceptor2
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    ip::tcp::acceptor acceptor12(ioc_ex, ip::tcp::v4(), native_acceptor2);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::tcp::acceptor acceptor13(std::move(acceptor5));
-
-    // basic_socket_acceptor operators.
-
-    acceptor1 = ip::tcp::acceptor(ioc);
-    acceptor1 = std::move(acceptor2);
-
-    // basic_io_object functions.
-
-    ip::tcp::acceptor::executor_type ex = acceptor1.get_executor();
-    (void)ex;
-
-    // basic_socket_acceptor functions.
-
-    acceptor1.open(ip::tcp::v4());
-    acceptor1.open(ip::tcp::v6());
-    acceptor1.open(ip::tcp::v4(), ec);
-    acceptor1.open(ip::tcp::v6(), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::tcp::acceptor::native_handle_type native_acceptor3
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    acceptor1.assign(ip::tcp::v4(), native_acceptor3);
-    ip::tcp::acceptor::native_handle_type native_acceptor4
-      = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    acceptor1.assign(ip::tcp::v4(), native_acceptor4, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = acceptor1.is_open();
-    (void)is_open;
-
-    acceptor1.close();
-    acceptor1.close(ec);
-
-    acceptor1.release();
-    acceptor1.release(ec);
-
-    ip::tcp::acceptor::native_handle_type native_acceptor5
-      = acceptor1.native_handle();
-    (void)native_acceptor5;
-
-    acceptor1.cancel();
-    acceptor1.cancel(ec);
-
-    acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0));
-    acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0));
-    acceptor1.bind(ip::tcp::endpoint(ip::tcp::v4(), 0), ec);
-    acceptor1.bind(ip::tcp::endpoint(ip::tcp::v6(), 0), ec);
-
-    acceptor1.set_option(settable_socket_option1);
-    acceptor1.set_option(settable_socket_option1, ec);
-    acceptor1.set_option(settable_socket_option2);
-    acceptor1.set_option(settable_socket_option2, ec);
-    acceptor1.set_option(settable_socket_option3);
-    acceptor1.set_option(settable_socket_option3, ec);
-
-    acceptor1.get_option(gettable_socket_option1);
-    acceptor1.get_option(gettable_socket_option1, ec);
-    acceptor1.get_option(gettable_socket_option2);
-    acceptor1.get_option(gettable_socket_option2, ec);
-    acceptor1.get_option(gettable_socket_option3);
-    acceptor1.get_option(gettable_socket_option3, ec);
-
-    acceptor1.io_control(io_control_command);
-    acceptor1.io_control(io_control_command, ec);
-
-    bool non_blocking1 = acceptor1.non_blocking();
-    (void)non_blocking1;
-    acceptor1.non_blocking(true);
-    acceptor1.non_blocking(false, ec);
-
-    bool non_blocking2 = acceptor1.native_non_blocking();
-    (void)non_blocking2;
-    acceptor1.native_non_blocking(true);
-    acceptor1.native_non_blocking(false, ec);
-
-    ip::tcp::endpoint endpoint1 = acceptor1.local_endpoint();
-    (void)endpoint1;
-    ip::tcp::endpoint endpoint2 = acceptor1.local_endpoint(ec);
-    (void)endpoint2;
-
-    acceptor1.wait(socket_base::wait_read);
-    acceptor1.wait(socket_base::wait_write, ec);
-
-    acceptor1.async_wait(socket_base::wait_read, wait_handler());
-    acceptor1.async_wait(socket_base::wait_read, immediate);
-    int i1 = acceptor1.async_wait(socket_base::wait_write, lazy);
-    (void)i1;
-
-    acceptor1.accept(peer_socket1);
-    acceptor1.accept(peer_socket1, ec);
-    acceptor1.accept(peer_socket1, peer_endpoint);
-    acceptor1.accept(peer_socket1, peer_endpoint, ec);
-
-    acceptor1.accept(peer_socket2);
-    acceptor1.accept(peer_socket2, ec);
-    acceptor1.accept(peer_socket2, peer_endpoint);
-    acceptor1.accept(peer_socket2, peer_endpoint, ec);
-
-    peer_socket1 = acceptor1.accept();
-    peer_socket1 = acceptor1.accept(ioc);
-    peer_socket1 = acceptor1.accept(ioc_ex);
-    peer_socket1 = acceptor1.accept(peer_endpoint);
-    peer_socket1 = acceptor1.accept(ioc, peer_endpoint);
-    peer_socket1 = acceptor1.accept(ioc_ex, peer_endpoint);
-    (void)peer_socket1;
-
-    peer_socket2 = acceptor1.accept(ioc);
-    peer_socket2 = acceptor1.accept(ioc_ex);
-    peer_socket2 = acceptor1.accept(ioc, peer_endpoint);
-    peer_socket2 = acceptor1.accept(ioc_ex, peer_endpoint);
-    (void)peer_socket2;
-
-    acceptor1.async_accept(peer_socket1, accept_handler());
-    acceptor1.async_accept(peer_socket1, peer_endpoint, accept_handler());
-    acceptor1.async_accept(peer_socket1, immediate);
-    acceptor1.async_accept(peer_socket1, peer_endpoint, immediate);
-    int i2 = acceptor1.async_accept(peer_socket1, lazy);
-    (void)i2;
-    int i3 = acceptor1.async_accept(peer_socket1, peer_endpoint, lazy);
-    (void)i3;
-
-    acceptor1.async_accept(peer_socket2, accept_handler());
-    acceptor1.async_accept(peer_socket2, peer_endpoint, accept_handler());
-    acceptor1.async_accept(peer_socket2, immediate);
-    acceptor1.async_accept(peer_socket2, peer_endpoint, immediate);
-    int i4 = acceptor1.async_accept(peer_socket2, lazy);
-    (void)i4;
-    int i5 = acceptor1.async_accept(peer_socket2, peer_endpoint, lazy);
-    (void)i5;
-
-    acceptor1.async_accept(move_accept_handler());
-    acceptor1.async_accept(ioc, move_accept_handler());
-    acceptor1.async_accept(ioc_ex, move_accept_handler());
-    acceptor1.async_accept(ioc_ex, move_accept_ioc_handler());
-    acceptor1.async_accept(peer_endpoint, move_accept_handler());
-    acceptor1.async_accept(ioc, peer_endpoint, move_accept_handler());
-    acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_handler());
-    acceptor1.async_accept(ioc_ex, peer_endpoint, move_accept_ioc_handler());
-    acceptor1.async_accept(immediate);
-    acceptor1.async_accept(ioc, immediate);
-    acceptor1.async_accept(ioc_ex, immediate);
-    acceptor1.async_accept(peer_endpoint, immediate);
-    acceptor1.async_accept(ioc, peer_endpoint, immediate);
-    acceptor1.async_accept(ioc_ex, peer_endpoint, immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_tcp_acceptor_compile
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_acceptor_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the ip::tcp::acceptor
-// class.
-
-namespace ip_tcp_acceptor_runtime {
-
-void handle_accept(const asio::error_code& err)
-{
-  ASIO_CHECK(!err);
-}
-
-void handle_connect(const asio::error_code& err)
-{
-  ASIO_CHECK(!err);
-}
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-
-  ip::tcp::acceptor acceptor(ioc, ip::tcp::endpoint(ip::tcp::v4(), 0));
-  ip::tcp::endpoint server_endpoint = acceptor.local_endpoint();
-  server_endpoint.address(ip::address_v4::loopback());
-
-  ip::tcp::socket client_side_socket(ioc);
-  ip::tcp::socket server_side_socket(ioc);
-
-  client_side_socket.connect(server_endpoint);
-  acceptor.accept(server_side_socket);
-
-  client_side_socket.close();
-  server_side_socket.close();
-
-  client_side_socket.connect(server_endpoint);
-  ip::tcp::endpoint client_endpoint;
-  acceptor.accept(server_side_socket, client_endpoint);
-
-  ip::tcp::endpoint client_side_local_endpoint
-    = client_side_socket.local_endpoint();
-  ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
-
-  ip::tcp::endpoint server_side_remote_endpoint
-    = server_side_socket.remote_endpoint();
-  ASIO_CHECK(server_side_remote_endpoint.port()
-      == client_endpoint.port());
-
-  client_side_socket.close();
-  server_side_socket.close();
-
-  acceptor.async_accept(server_side_socket, &handle_accept);
-  client_side_socket.async_connect(server_endpoint, &handle_connect);
-
-  ioc.run();
-
-  client_side_socket.close();
-  server_side_socket.close();
-
-  acceptor.async_accept(server_side_socket, client_endpoint, &handle_accept);
-  client_side_socket.async_connect(server_endpoint, &handle_connect);
-
-  ioc.restart();
-  ioc.run();
-
-  client_side_local_endpoint = client_side_socket.local_endpoint();
-  ASIO_CHECK(client_side_local_endpoint.port() == client_endpoint.port());
-
-  server_side_remote_endpoint = server_side_socket.remote_endpoint();
-  ASIO_CHECK(server_side_remote_endpoint.port()
-      == client_endpoint.port());
-}
-
-} // namespace ip_tcp_acceptor_runtime
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_resolver_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::tcp::resolver compile and link correctly. Runtime failures are ignored.
-
-namespace ip_tcp_resolver_compile {
-
-struct resolve_handler
-{
-  resolve_handler() {}
-  void operator()(const asio::error_code&,
-      asio::ip::tcp::resolver::results_type) {}
-  resolve_handler(resolve_handler&&) {}
-private:
-  resolve_handler(const resolve_handler&);
-};
-
-#if !defined(ASIO_NO_DEPRECATED)
-struct legacy_resolve_handler
-{
-  legacy_resolve_handler() {}
-  void operator()(const asio::error_code&,
-      asio::ip::tcp::resolver::iterator) {}
-  legacy_resolve_handler(legacy_resolve_handler&&) {}
-private:
-  legacy_resolve_handler(const legacy_resolve_handler&);
-};
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::tcp::resolver::query q(ip::tcp::v4(), "localhost", "0");
-#endif // !defined(ASIO_NO_DEPRECATED)
-    ip::tcp::endpoint e(ip::address_v4::loopback(), 0);
-
-    // basic_resolver constructors.
-
-    ip::tcp::resolver resolver(ioc);
-    ip::tcp::resolver resolver2(ioc_ex);
-
-    ip::tcp::resolver resolver3(std::move(resolver));
-
-    // basic_resolver operators.
-
-    resolver = ip::tcp::resolver(ioc);
-    resolver = std::move(resolver3);
-
-    // basic_io_object functions.
-
-    ip::tcp::resolver::executor_type ex = resolver.get_executor();
-    (void)ex;
-
-    // basic_resolver functions.
-
-    resolver.cancel();
-
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::tcp::resolver::results_type results1 = resolver.resolve(q);
-    (void)results1;
-
-    ip::tcp::resolver::results_type results2 = resolver.resolve(q, ec);
-    (void)results2;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    ip::tcp::resolver::results_type results3 = resolver.resolve("", "");
-    (void)results3;
-
-    ip::tcp::resolver::results_type results4 = resolver.resolve("", "", ec);
-    (void)results4;
-
-    ip::tcp::resolver::results_type results5 =
-      resolver.resolve("", "", ip::tcp::resolver::flags());
-    (void)results5;
-
-    ip::tcp::resolver::results_type results6 =
-      resolver.resolve("", "", ip::tcp::resolver::flags(), ec);
-    (void)results6;
-
-    ip::tcp::resolver::results_type results7 =
-      resolver.resolve(ip::tcp::v4(), "", "");
-    (void)results7;
-
-    ip::tcp::resolver::results_type results8 =
-      resolver.resolve(ip::tcp::v4(), "", "", ec);
-    (void)results8;
-
-    ip::tcp::resolver::results_type results9 =
-      resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags());
-    (void)results9;
-
-    ip::tcp::resolver::results_type results10 =
-      resolver.resolve(ip::tcp::v4(), "", "", ip::tcp::resolver::flags(), ec);
-    (void)results10;
-
-    ip::tcp::resolver::results_type results11 = resolver.resolve(e);
-    (void)results11;
-
-    ip::tcp::resolver::results_type results12 = resolver.resolve(e, ec);
-    (void)results12;
-
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(q, resolve_handler());
-    resolver.async_resolve(q, legacy_resolve_handler());
-    int i1 = resolver.async_resolve(q, lazy);
-    (void)i1;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    resolver.async_resolve("", "", resolve_handler());
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve("", "", legacy_resolve_handler());
-#endif // !defined(ASIO_NO_DEPRECATED)
-    int i2 = resolver.async_resolve("", "", lazy);
-    (void)i2;
-
-    resolver.async_resolve("", "",
-        ip::tcp::resolver::flags(), resolve_handler());
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve("", "",
-        ip::tcp::resolver::flags(), legacy_resolve_handler());
-#endif // !defined(ASIO_NO_DEPRECATED)
-    int i3 = resolver.async_resolve("", "",
-        ip::tcp::resolver::flags(), lazy);
-    (void)i3;
-
-    resolver.async_resolve(ip::tcp::v4(), "", "", resolve_handler());
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(ip::tcp::v4(), "", "", legacy_resolve_handler());
-#endif // !defined(ASIO_NO_DEPRECATED)
-    int i4 = resolver.async_resolve(ip::tcp::v4(), "", "", lazy);
-    (void)i4;
-
-    resolver.async_resolve(ip::tcp::v4(),
-        "", "", ip::tcp::resolver::flags(), resolve_handler());
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(ip::tcp::v4(),
-        "", "", ip::tcp::resolver::flags(), legacy_resolve_handler());
-#endif // !defined(ASIO_NO_DEPRECATED)
-    int i5 = resolver.async_resolve(ip::tcp::v4(),
-        "", "", ip::tcp::resolver::flags(), lazy);
-    (void)i5;
-
-    resolver.async_resolve(e, resolve_handler());
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(e, legacy_resolve_handler());
-#endif // !defined(ASIO_NO_DEPRECATED)
-    int i6 = resolver.async_resolve(e, lazy);
-    (void)i6;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_tcp_resolver_compile
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_resolver_entry_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::tcp::resolver::entry compile and link correctly. Runtime failures are
-// ignored.
-
-namespace ip_tcp_resolver_entry_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-  const ip::tcp::endpoint endpoint;
-  const std::string host_name;
-  const std::string service_name;
-  const std::allocator<char> alloc;
-
-  try
-  {
-    // basic_resolver_entry constructors.
-
-    const ip::basic_resolver_entry<ip::tcp> entry1;
-    ip::basic_resolver_entry<ip::tcp> entry2(endpoint, host_name, service_name);
-    ip::basic_resolver_entry<ip::tcp> entry3(entry1);
-    ip::basic_resolver_entry<ip::tcp> entry4(std::move(entry2));
-
-    // basic_resolver_entry functions.
-
-    ip::tcp::endpoint e1 = entry1.endpoint();
-    (void)e1;
-
-    ip::tcp::endpoint e2 = entry1;
-    (void)e2;
-
-    std::string s1 = entry1.host_name();
-    (void)s1;
-
-    std::string s2 = entry1.host_name(alloc);
-    (void)s2;
-
-    std::string s3 = entry1.service_name();
-    (void)s3;
-
-    std::string s4 = entry1.service_name(alloc);
-    (void)s4;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_tcp_resolver_entry_compile
-
-//------------------------------------------------------------------------------
-
-// ip_tcp_iostream_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public types and member functions on the
-// class ip::tcp::iostream compile and link correctly. Runtime failures are
-// ignored.
-
-namespace ip_tcp_iostream_compile {
-
-void test()
-{
-#if !defined(ASIO_NO_IOSTREAM)
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  asio::io_context ioc;
-  asio::ip::tcp::socket sock(ioc);
-
-  // basic_socket_iostream typedefs.
-
-  (void)static_cast<ip::tcp::iostream::protocol_type*>(0);
-  (void)static_cast<ip::tcp::iostream::endpoint_type*>(0);
-  (void)static_cast<ip::tcp::iostream::clock_type*>(0);
-  (void)static_cast<ip::tcp::iostream::time_point*>(0);
-  (void)static_cast<ip::tcp::iostream::duration*>(0);
-  (void)static_cast<ip::tcp::iostream::traits_type*>(0);
-
-  // basic_socket_iostream constructors.
-
-  ip::tcp::iostream ios1;
-
-  ip::tcp::iostream ios2(std::move(sock));
-
-  ip::tcp::iostream ios3("hostname", "service");
-
-  // basic_socket_iostream operators.
-
-  ios1 = ip::tcp::iostream();
-
-  ios2 = std::move(ios1);
-
-  // basic_socket_iostream members.
-
-  ios1.connect("hostname", "service");
-
-  ios1.close();
-
-  (void)static_cast<std::streambuf*>(ios1.rdbuf());
-
-  basic_socket<ip::tcp>& sref = ios1.socket();
-  (void)sref;
-
-  asio::error_code ec = ios1.error();
-  (void)ec;
-
-  ip::tcp::iostream::time_point tp = ios1.expiry();
-  (void)tp;
-
-  ios1.expires_at(tp);
-
-  ip::tcp::iostream::duration d = ip::tcp::iostream::duration();
-  ios1.expires_after(d);
-
-  // iostream operators.
-
-  int i = 0;
-  ios1 >> i;
-  ios1 << i;
-#endif // !defined(ASIO_NO_IOSTREAM)
-}
-
-} // namespace ip_tcp_iostream_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/tcp",
-  ASIO_COMPILE_TEST_CASE(ip_tcp_compile::test)
-  ASIO_TEST_CASE(ip_tcp_runtime::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_socket_compile::test)
-  ASIO_TEST_CASE(ip_tcp_socket_runtime::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_acceptor_compile::test)
-  ASIO_TEST_CASE(ip_tcp_acceptor_runtime::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_compile::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_entry_compile::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_resolver_entry_compile::test)
-  ASIO_COMPILE_TEST_CASE(ip_tcp_iostream_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/udp.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/udp.cpp
deleted file mode 100644
index ae67f9c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/udp.cpp
+++ /dev/null
@@ -1,692 +0,0 @@
-//
-// udp.cpp
-// ~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/udp.hpp"
-
-#include <cstring>
-#include <functional>
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../archetypes/gettable_socket_option.hpp"
-#include "../archetypes/io_control_command.hpp"
-#include "../archetypes/settable_socket_option.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_udp_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::udp::socket compile and link correctly. Runtime failures are ignored.
-
-namespace ip_udp_socket_compile {
-
-struct connect_handler
-{
-  connect_handler() {}
-  void operator()(const asio::error_code&) {}
-  connect_handler(connect_handler&&) {}
-private:
-  connect_handler(const connect_handler&);
-};
-
-struct wait_handler
-{
-  wait_handler() {}
-  void operator()(const asio::error_code&) {}
-  wait_handler(wait_handler&&) {}
-private:
-  wait_handler(const wait_handler&);
-};
-
-struct send_handler
-{
-  send_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  send_handler(send_handler&&) {}
-private:
-  send_handler(const send_handler&);
-};
-
-struct receive_handler
-{
-  receive_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  receive_handler(receive_handler&&) {}
-private:
-  receive_handler(const receive_handler&);
-};
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    archetypes::settable_socket_option<void> settable_socket_option1;
-    archetypes::settable_socket_option<int> settable_socket_option2;
-    archetypes::settable_socket_option<double> settable_socket_option3;
-    archetypes::gettable_socket_option<void> gettable_socket_option1;
-    archetypes::gettable_socket_option<int> gettable_socket_option2;
-    archetypes::gettable_socket_option<double> gettable_socket_option3;
-    archetypes::io_control_command io_control_command;
-    archetypes::immediate_handler immediate;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_datagram_socket constructors.
-
-    ip::udp::socket socket1(ioc);
-    ip::udp::socket socket2(ioc, ip::udp::v4());
-    ip::udp::socket socket3(ioc, ip::udp::v6());
-    ip::udp::socket socket4(ioc, ip::udp::endpoint(ip::udp::v4(), 0));
-    ip::udp::socket socket5(ioc, ip::udp::endpoint(ip::udp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::udp::socket::native_handle_type native_socket1
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    ip::udp::socket socket6(ioc, ip::udp::v4(), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::udp::socket socket7(ioc_ex);
-    ip::udp::socket socket8(ioc_ex, ip::udp::v4());
-    ip::udp::socket socket9(ioc_ex, ip::udp::v6());
-    ip::udp::socket socket10(ioc_ex, ip::udp::endpoint(ip::udp::v4(), 0));
-    ip::udp::socket socket11(ioc_ex, ip::udp::endpoint(ip::udp::v6(), 0));
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::udp::socket::native_handle_type native_socket2
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    ip::udp::socket socket12(ioc_ex, ip::udp::v4(), native_socket2);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    ip::udp::socket socket13(std::move(socket6));
-
-    // basic_datagram_socket operators.
-
-    socket1 = ip::udp::socket(ioc);
-    socket1 = std::move(socket2);
-
-    // basic_io_object functions.
-
-    ip::udp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    ip::udp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    const ip::udp::socket& socket14 = socket1;
-    const ip::udp::socket::lowest_layer_type& lowest_layer2
-      = socket14.lowest_layer();
-    (void)lowest_layer2;
-
-    socket1.open(ip::udp::v4());
-    socket1.open(ip::udp::v6());
-    socket1.open(ip::udp::v4(), ec);
-    socket1.open(ip::udp::v6(), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    ip::udp::socket::native_handle_type native_socket3
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    socket1.assign(ip::udp::v4(), native_socket3);
-    ip::udp::socket::native_handle_type native_socket4
-      = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-    socket1.assign(ip::udp::v4(), native_socket4, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    socket1.release();
-    socket1.release(ec);
-
-    ip::udp::socket::native_handle_type native_socket5
-      = socket1.native_handle();
-    (void)native_socket5;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0));
-    socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0));
-    socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), ec);
-    socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), ec);
-
-    socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0));
-    socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0));
-    socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), ec);
-    socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), ec);
-
-    socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0),
-        connect_handler());
-    socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0),
-        connect_handler());
-    socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), immediate);
-    socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), immediate);
-    int i1 = socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), lazy);
-    (void)i1;
-    int i2 = socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), lazy);
-    (void)i2;
-
-    socket1.set_option(settable_socket_option1);
-    socket1.set_option(settable_socket_option1, ec);
-    socket1.set_option(settable_socket_option2);
-    socket1.set_option(settable_socket_option2, ec);
-    socket1.set_option(settable_socket_option3);
-    socket1.set_option(settable_socket_option3, ec);
-
-    socket1.get_option(gettable_socket_option1);
-    socket1.get_option(gettable_socket_option1, ec);
-    socket1.get_option(gettable_socket_option2);
-    socket1.get_option(gettable_socket_option2, ec);
-    socket1.get_option(gettable_socket_option3);
-    socket1.get_option(gettable_socket_option3, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    bool non_blocking1 = socket1.non_blocking();
-    (void)non_blocking1;
-    socket1.non_blocking(true);
-    socket1.non_blocking(false, ec);
-
-    bool non_blocking2 = socket1.native_non_blocking();
-    (void)non_blocking2;
-    socket1.native_non_blocking(true);
-    socket1.native_non_blocking(false, ec);
-
-    ip::udp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    ip::udp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    ip::udp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    ip::udp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    socket1.wait(socket_base::wait_read);
-    socket1.wait(socket_base::wait_write, ec);
-
-    socket1.async_wait(socket_base::wait_read, wait_handler());
-    socket1.async_wait(socket_base::wait_read, immediate);
-    int i3 = socket1.async_wait(socket_base::wait_write, lazy);
-    (void)i3;
-
-    // basic_datagram_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler());
-    socket1.async_send(buffer(const_char_buffer), send_handler());
-    socket1.async_send(null_buffers(), send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler());
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler());
-    socket1.async_send(null_buffers(), in_flags, send_handler());
-    socket1.async_send(buffer(mutable_char_buffer), immediate);
-    socket1.async_send(buffer(const_char_buffer), immediate);
-    socket1.async_send(null_buffers(), immediate);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-    int i4 = socket1.async_send(buffer(mutable_char_buffer), lazy);
-    (void)i4;
-    int i5 = socket1.async_send(buffer(const_char_buffer), lazy);
-    (void)i5;
-    int i6 = socket1.async_send(null_buffers(), lazy);
-    (void)i6;
-    int i7 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
-    (void)i7;
-    int i8 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
-    (void)i8;
-    int i9 = socket1.async_send(null_buffers(), in_flags, lazy);
-    (void)i9;
-
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0));
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0));
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0));
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0));
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0));
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0));
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
-    socket1.send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
-
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, send_handler());
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, send_handler());
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, immediate);
-    socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, immediate);
-    int i10 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), lazy);
-    (void)i10;
-    int i11 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), lazy);
-    (void)i11;
-    int i12 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), lazy);
-    (void)i12;
-    int i13 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), lazy);
-    (void)i13;
-    int i14 = socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), lazy);
-    (void)i14;
-    int i15 = socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), lazy);
-    (void)i15;
-    int i16 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
-    (void)i16;
-    int i17 = socket1.async_send_to(buffer(mutable_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
-    (void)i17;
-    int i18 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
-    (void)i18;
-    int i19 = socket1.async_send_to(buffer(const_char_buffer),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
-    (void)i19;
-    int i20 = socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
-    (void)i20;
-    int i21 = socket1.async_send_to(null_buffers(),
-        ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
-    (void)i21;
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
-    socket1.async_receive(null_buffers(), receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler());
-    socket1.async_receive(null_buffers(), in_flags, receive_handler());
-    socket1.async_receive(buffer(mutable_char_buffer), immediate);
-    socket1.async_receive(null_buffers(), immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, immediate);
-    int i22 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
-    (void)i22;
-    int i23 = socket1.async_receive(null_buffers(), lazy);
-    (void)i23;
-    int i24 = socket1.async_receive(buffer(mutable_char_buffer),
-        in_flags, lazy);
-    (void)i24;
-    int i25 = socket1.async_receive(null_buffers(), in_flags, lazy);
-    (void)i25;
-
-    ip::udp::endpoint endpoint;
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
-    socket1.receive_from(null_buffers(), endpoint);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
-    socket1.receive_from(null_buffers(), endpoint, in_flags);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
-    socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
-
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, receive_handler());
-    socket1.async_receive_from(null_buffers(),
-        endpoint, receive_handler());
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, receive_handler());
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, receive_handler());
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, immediate);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, immediate);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, immediate);
-    int i26 = socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, lazy);
-    (void)i26;
-    int i27 = socket1.async_receive_from(null_buffers(),
-        endpoint, lazy);
-    (void)i27;
-    int i28 = socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, lazy);
-    (void)i28;
-    int i29 = socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, lazy);
-    (void)i29;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_udp_socket_compile
-
-//------------------------------------------------------------------------------
-
-// ip_udp_socket_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the ip::udp::socket class.
-
-namespace ip_udp_socket_runtime {
-
-void handle_send(size_t expected_bytes_sent,
-    const asio::error_code& err, size_t bytes_sent)
-{
-  ASIO_CHECK(!err);
-  ASIO_CHECK(expected_bytes_sent == bytes_sent);
-}
-
-void handle_recv(size_t expected_bytes_recvd,
-    const asio::error_code& err, size_t bytes_recvd)
-{
-  ASIO_CHECK(!err);
-  ASIO_CHECK(expected_bytes_recvd == bytes_recvd);
-}
-
-void test()
-{
-  using namespace std; // For memcmp and memset.
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  io_context ioc;
-
-  ip::udp::socket s1(ioc, ip::udp::endpoint(ip::udp::v4(), 0));
-  ip::udp::endpoint target_endpoint = s1.local_endpoint();
-  target_endpoint.address(ip::address_v4::loopback());
-
-  ip::udp::socket s2(ioc);
-  s2.open(ip::udp::v4());
-  s2.bind(ip::udp::endpoint(ip::udp::v4(), 0));
-  char send_msg[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  s2.send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint);
-
-  char recv_msg[sizeof(send_msg)];
-  ip::udp::endpoint sender_endpoint;
-  size_t bytes_recvd = s1.receive_from(buffer(recv_msg, sizeof(recv_msg)),
-      sender_endpoint);
-
-  ASIO_CHECK(bytes_recvd == sizeof(send_msg));
-  ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
-
-  memset(recv_msg, 0, sizeof(recv_msg));
-
-  target_endpoint = sender_endpoint;
-  s1.async_send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint,
-      bindns::bind(handle_send, sizeof(send_msg), _1, _2));
-  s2.async_receive_from(buffer(recv_msg, sizeof(recv_msg)), sender_endpoint,
-      bindns::bind(handle_recv, sizeof(recv_msg), _1, _2));
-
-  ioc.run();
-
-  ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
-}
-
-} // namespace ip_udp_socket_runtime
-
-//------------------------------------------------------------------------------
-
-// ip_udp_resolver_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ip::udp::resolver compile and link correctly. Runtime failures are ignored.
-
-namespace ip_udp_resolver_compile {
-
-struct resolve_handler
-{
-  resolve_handler() {}
-  void operator()(const asio::error_code&,
-      asio::ip::udp::resolver::results_type) {}
-  resolve_handler(resolve_handler&&) {}
-private:
-  resolve_handler(const resolve_handler&);
-};
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::udp::resolver::query q(ip::udp::v4(), "localhost", "0");
-#endif // !defined(ASIO_NO_DEPRECATED)
-    ip::udp::endpoint e(ip::address_v4::loopback(), 0);
-
-    // basic_resolver constructors.
-
-    ip::udp::resolver resolver(ioc);
-    ip::udp::resolver resolver2(ioc_ex);
-
-    ip::udp::resolver resolver3(std::move(resolver));
-
-    // basic_resolver operators.
-
-    resolver = ip::udp::resolver(ioc);
-    resolver = std::move(resolver3);
-
-    // basic_io_object functions.
-
-    ip::udp::resolver::executor_type ex = resolver.get_executor();
-    (void)ex;
-
-    // basic_resolver functions.
-
-    resolver.cancel();
-
-#if !defined(ASIO_NO_DEPRECATED)
-    ip::udp::resolver::results_type results1 = resolver.resolve(q);
-    (void)results1;
-
-    ip::udp::resolver::results_type results2 = resolver.resolve(q, ec);
-    (void)results2;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    ip::udp::resolver::results_type results3 = resolver.resolve("", "");
-    (void)results3;
-
-    ip::udp::resolver::results_type results4 = resolver.resolve("", "", ec);
-    (void)results4;
-
-    ip::udp::resolver::results_type results5 =
-      resolver.resolve("", "", ip::udp::resolver::flags());
-    (void)results5;
-
-    ip::udp::resolver::results_type results6 =
-      resolver.resolve("", "", ip::udp::resolver::flags(), ec);
-    (void)results6;
-
-    ip::udp::resolver::results_type results7 =
-      resolver.resolve(ip::udp::v4(), "", "");
-    (void)results7;
-
-    ip::udp::resolver::results_type results8 =
-      resolver.resolve(ip::udp::v4(), "", "", ec);
-    (void)results8;
-
-    ip::udp::resolver::results_type results9 =
-      resolver.resolve(ip::udp::v4(), "", "", ip::udp::resolver::flags());
-    (void)results9;
-
-    ip::udp::resolver::results_type results10 =
-      resolver.resolve(ip::udp::v4(), "", "", ip::udp::resolver::flags(), ec);
-    (void)results10;
-
-    ip::udp::resolver::results_type results11 = resolver.resolve(e);
-    (void)results11;
-
-    ip::udp::resolver::results_type results12 = resolver.resolve(e, ec);
-    (void)results12;
-
-#if !defined(ASIO_NO_DEPRECATED)
-    resolver.async_resolve(q, resolve_handler());
-    int i1 = resolver.async_resolve(q, lazy);
-    (void)i1;
-#endif // !defined(ASIO_NO_DEPRECATED)
-
-    resolver.async_resolve("", "", resolve_handler());
-    int i2 = resolver.async_resolve("", "", lazy);
-    (void)i2;
-
-    resolver.async_resolve("", "",
-        ip::udp::resolver::flags(), resolve_handler());
-    int i3 = resolver.async_resolve("", "",
-        ip::udp::resolver::flags(), lazy);
-    (void)i3;
-
-    resolver.async_resolve(ip::udp::v4(), "", "", resolve_handler());
-    int i4 = resolver.async_resolve(ip::udp::v4(), "", "", lazy);
-    (void)i4;
-
-    resolver.async_resolve(ip::udp::v4(),
-        "", "", ip::udp::resolver::flags(), resolve_handler());
-    int i5 = resolver.async_resolve(ip::udp::v4(),
-        "", "", ip::udp::resolver::flags(), lazy);
-    (void)i5;
-
-    resolver.async_resolve(e, resolve_handler());
-    int i6 = resolver.async_resolve(e, lazy);
-    (void)i6;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_udp_resolver_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/udp",
-  ASIO_COMPILE_TEST_CASE(ip_udp_socket_compile::test)
-  ASIO_TEST_CASE(ip_udp_socket_runtime::test)
-  ASIO_COMPILE_TEST_CASE(ip_udp_resolver_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/unicast.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/unicast.cpp
deleted file mode 100644
index db3497f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/unicast.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// unicast.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/unicast.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/ip/udp.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_unicast_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all nested classes, enums and constants in
-// ip::unicast compile and link correctly. Runtime failures are ignored.
-
-namespace ip_unicast_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    ip::udp::socket sock(ioc);
-
-    // hops class.
-
-    ip::unicast::hops hops1(1024);
-    sock.set_option(hops1);
-    ip::unicast::hops hops2;
-    sock.get_option(hops2);
-    hops1 = 1;
-    (void)static_cast<int>(hops1.value());
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_unicast_compile
-
-//------------------------------------------------------------------------------
-
-// ip_unicast_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the socket options defined
-// in the ip::unicast namespace.
-
-namespace ip_unicast_runtime {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-  asio::error_code ec;
-
-  ip::udp::endpoint ep_v4(ip::address_v4::loopback(), 0);
-  ip::udp::socket sock_v4(ioc);
-  sock_v4.open(ep_v4.protocol(), ec);
-  sock_v4.bind(ep_v4, ec);
-  bool have_v4 = !ec;
-
-  ip::udp::endpoint ep_v6(ip::address_v6::loopback(), 0);
-  ip::udp::socket sock_v6(ioc);
-  sock_v6.open(ep_v6.protocol(), ec);
-  sock_v6.bind(ep_v6, ec);
-  bool have_v6 = !ec;
-
-  ASIO_CHECK(have_v4 || have_v6);
-
-  // hops class.
-
-  if (have_v4)
-  {
-    ip::unicast::hops hops1(1);
-    ASIO_CHECK(hops1.value() == 1);
-    sock_v4.set_option(hops1, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK(!ec);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::unicast::hops hops2;
-    sock_v4.get_option(hops2, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK(!ec);
-    ASIO_CHECK(hops2.value() == 1);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::unicast::hops hops3(255);
-    ASIO_CHECK(hops3.value() == 255);
-    sock_v4.set_option(hops3, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK(!ec);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-    ip::unicast::hops hops4;
-    sock_v4.get_option(hops4, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    // Option is not supported under Windows CE.
-    ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-        ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-    ASIO_CHECK(!ec);
-    ASIO_CHECK(hops4.value() == 255);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  }
-
-  if (have_v6)
-  {
-    ip::unicast::hops hops1(1);
-    ASIO_CHECK(hops1.value() == 1);
-    sock_v6.set_option(hops1, ec);
-    ASIO_CHECK(!ec);
-
-    ip::unicast::hops hops2;
-    sock_v6.get_option(hops2, ec);
-    ASIO_CHECK(!ec);
-    ASIO_CHECK(hops2.value() == 1);
-
-    ip::unicast::hops hops3(255);
-    ASIO_CHECK(hops3.value() == 255);
-    sock_v6.set_option(hops3, ec);
-    ASIO_CHECK(!ec);
-
-    ip::unicast::hops hops4;
-    sock_v6.get_option(hops4, ec);
-    ASIO_CHECK(!ec);
-    ASIO_CHECK(hops4.value() == 255);
-  }
-}
-
-} // namespace ip_unicast_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/unicast",
-  ASIO_COMPILE_TEST_CASE(ip_unicast_compile::test)
-  ASIO_TEST_CASE(ip_unicast_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/v6_only.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/v6_only.cpp
deleted file mode 100644
index ba37fdb..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ip/v6_only.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//
-// v6_only.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ip/v6_only.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// ip_v6_only_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that the ip::v6_only socket option compiles and
-// link correctly. Runtime failures are ignored.
-
-namespace ip_v6_only_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    ip::udp::socket sock(ioc);
-
-    // v6_only class.
-
-    ip::v6_only v6_only1(true);
-    sock.set_option(v6_only1);
-    ip::v6_only v6_only2;
-    sock.get_option(v6_only2);
-    v6_only1 = true;
-    (void)static_cast<bool>(v6_only1);
-    (void)static_cast<bool>(!v6_only1);
-    (void)static_cast<bool>(v6_only1.value());
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ip_v6_only_compile
-
-//------------------------------------------------------------------------------
-
-// ip_v6_only_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the ip::v6_only socket
-// option.
-
-namespace ip_v6_only_runtime {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-  asio::error_code ec;
-
-  ip::tcp::endpoint ep_v6(ip::address_v6::loopback(), 0);
-  ip::tcp::acceptor acceptor_v6(ioc);
-  acceptor_v6.open(ep_v6.protocol(), ec);
-  acceptor_v6.bind(ep_v6, ec);
-  bool have_v6 = !ec;
-  acceptor_v6.close(ec);
-  acceptor_v6.open(ep_v6.protocol(), ec);
-
-  if (have_v6)
-  {
-    ip::v6_only v6_only1;
-    acceptor_v6.get_option(v6_only1, ec);
-    ASIO_CHECK(!ec);
-    bool have_dual_stack = !v6_only1.value();
-
-    if (have_dual_stack)
-    {
-      ip::v6_only v6_only2(false);
-      ASIO_CHECK(!v6_only2.value());
-      ASIO_CHECK(!static_cast<bool>(v6_only2));
-      ASIO_CHECK(!v6_only2);
-      acceptor_v6.set_option(v6_only2, ec);
-      ASIO_CHECK(!ec);
-
-      ip::v6_only v6_only3;
-      acceptor_v6.get_option(v6_only3, ec);
-      ASIO_CHECK(!ec);
-      ASIO_CHECK(!v6_only3.value());
-      ASIO_CHECK(!static_cast<bool>(v6_only3));
-      ASIO_CHECK(!v6_only3);
-
-      ip::v6_only v6_only4(true);
-      ASIO_CHECK(v6_only4.value());
-      ASIO_CHECK(static_cast<bool>(v6_only4));
-      ASIO_CHECK(!!v6_only4);
-      acceptor_v6.set_option(v6_only4, ec);
-      ASIO_CHECK(!ec);
-
-      ip::v6_only v6_only5;
-      acceptor_v6.get_option(v6_only5, ec);
-      ASIO_CHECK(!ec);
-      ASIO_CHECK(v6_only5.value());
-      ASIO_CHECK(static_cast<bool>(v6_only5));
-      ASIO_CHECK(!!v6_only5);
-    }
-  }
-}
-
-} // namespace ip_v6_only_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ip/v6_only",
-  ASIO_COMPILE_TEST_CASE(ip_v6_only_compile::test)
-  ASIO_TEST_CASE(ip_v6_only_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_read_buffered.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_read_buffered.cpp
deleted file mode 100644
index 031cd0f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_read_buffered.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// is_read_buffered.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/is_read_buffered.hpp"
-
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "unit_test.hpp"
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_stream
-{
-public:
-  typedef asio::io_context io_context_type;
-
-  typedef test_stream lowest_layer_type;
-
-  typedef io_context_type::executor_type executor_type;
-
-  test_stream(asio::io_context& io_context)
-    : io_context_(io_context)
-  {
-  }
-
-  io_context_type& io_context()
-  {
-    return io_context_;
-  }
-
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  template <typename Const_Buffers>
-  size_t write(const Const_Buffers&)
-  {
-    return 0;
-  }
-
-  template <typename Const_Buffers>
-  size_t write(const Const_Buffers&, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  template <typename Const_Buffers, typename Handler>
-  void async_write(const Const_Buffers&, Handler handler)
-  {
-    asio::error_code error;
-    asio::post(io_context_,
-        asio::detail::bind_handler(handler, error, 0));
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read(const Mutable_Buffers&)
-  {
-    return 0;
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read(const Mutable_Buffers&, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  template <typename Mutable_Buffers, typename Handler>
-  void async_read(const Mutable_Buffers&, Handler handler)
-  {
-    asio::error_code error;
-    asio::post(io_context_,
-        asio::detail::bind_handler(handler, error, 0));
-  }
-
-private:
-  io_context_type& io_context_;
-};
-
-void is_read_buffered_test()
-{
-  ASIO_CHECK(!asio::is_read_buffered<
-      asio::ip::tcp::socket>::value);
-
-  ASIO_CHECK(!!asio::is_read_buffered<
-      asio::buffered_read_stream<
-        asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!asio::is_read_buffered<
-      asio::buffered_write_stream<
-        asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!!asio::is_read_buffered<
-      asio::buffered_stream<asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!asio::is_read_buffered<test_stream>::value);
-
-  ASIO_CHECK(!!asio::is_read_buffered<
-      asio::buffered_read_stream<test_stream> >::value);
-
-  ASIO_CHECK(!asio::is_read_buffered<
-      asio::buffered_write_stream<test_stream> >::value);
-
-  ASIO_CHECK(!!asio::is_read_buffered<
-      asio::buffered_stream<test_stream> >::value);
-}
-
-ASIO_TEST_SUITE
-(
-  "is_read_buffered",
-  ASIO_TEST_CASE(is_read_buffered_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_write_buffered.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_write_buffered.cpp
deleted file mode 100644
index df7a9c8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/is_write_buffered.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// is_write_buffered.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/is_write_buffered.hpp"
-
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "unit_test.hpp"
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_stream
-{
-public:
-  typedef asio::io_context io_context_type;
-
-  typedef test_stream lowest_layer_type;
-
-  typedef io_context_type::executor_type executor_type;
-
-  test_stream(asio::io_context& io_context)
-    : io_context_(io_context)
-  {
-  }
-
-  io_context_type& io_context()
-  {
-    return io_context_;
-  }
-
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  template <typename Const_Buffers>
-  size_t write(const Const_Buffers&)
-  {
-    return 0;
-  }
-
-  template <typename Const_Buffers>
-  size_t write(const Const_Buffers&, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  template <typename Const_Buffers, typename Handler>
-  void async_write(const Const_Buffers&, Handler handler)
-  {
-    asio::error_code error;
-    asio::post(io_context_,
-        asio::detail::bind_handler(handler, error, 0));
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read(const Mutable_Buffers&)
-  {
-    return 0;
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read(const Mutable_Buffers&, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  template <typename Mutable_Buffers, typename Handler>
-  void async_read(const Mutable_Buffers&, Handler handler)
-  {
-    asio::error_code error;
-    asio::post(io_context_,
-        asio::detail::bind_handler(handler, error, 0));
-  }
-
-private:
-  io_context_type& io_context_;
-};
-
-void is_write_buffered_test()
-{
-  ASIO_CHECK(!asio::is_write_buffered<
-      asio::ip::tcp::socket>::value);
-
-  ASIO_CHECK(!asio::is_write_buffered<
-      asio::buffered_read_stream<
-        asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!!asio::is_write_buffered<
-      asio::buffered_write_stream<
-        asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!!asio::is_write_buffered<
-      asio::buffered_stream<asio::ip::tcp::socket> >::value);
-
-  ASIO_CHECK(!asio::is_write_buffered<test_stream>::value);
-
-  ASIO_CHECK(!asio::is_write_buffered<
-      asio::buffered_read_stream<test_stream> >::value);
-
-  ASIO_CHECK(!!asio::is_write_buffered<
-      asio::buffered_write_stream<test_stream> >::value);
-
-  ASIO_CHECK(!!asio::is_write_buffered<
-      asio::buffered_stream<test_stream> >::value);
-}
-
-ASIO_TEST_SUITE
-(
-  "is_write_buffered",
-  ASIO_TEST_CASE(is_write_buffered_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/.gitignore
deleted file mode 100644
index 7a26d9c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/.gitignore
+++ /dev/null
@@ -1,14 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-basic_endpoint
-connect_pair
-datagram_protocol
-seq_packet_protocol
-stream_protocol
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/basic_endpoint.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/basic_endpoint.cpp
deleted file mode 100644
index 855888e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/basic_endpoint.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_endpoint.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/local/basic_endpoint.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "local/basic_endpoint",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/connect_pair.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/connect_pair.cpp
deleted file mode 100644
index 095a0d8..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/connect_pair.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// connect_pair.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/local/connect_pair.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/local/datagram_protocol.hpp"
-#include "asio/local/stream_protocol.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// local_connect_pair_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all host_name functions compile and link
-// correctly. Runtime failures are ignored.
-
-namespace local_connect_pair_compile {
-
-void test()
-{
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-  using namespace asio;
-  namespace local = asio::local;
-  typedef local::datagram_protocol dp;
-  typedef local::stream_protocol sp;
-
-  try
-  {
-    asio::io_context io_context;
-    asio::error_code ec1;
-
-    dp::socket s1(io_context);
-    dp::socket s2(io_context);
-    local::connect_pair(s1, s2);
-
-    dp::socket s3(io_context);
-    dp::socket s4(io_context);
-    local::connect_pair(s3, s4, ec1);
-
-    sp::socket s5(io_context);
-    sp::socket s6(io_context);
-    local::connect_pair(s5, s6);
-
-    sp::socket s7(io_context);
-    sp::socket s8(io_context);
-    local::connect_pair(s7, s8, ec1);
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-}
-
-} // namespace local_connect_pair_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "local/connect_pair",
-  ASIO_COMPILE_TEST_CASE(local_connect_pair_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/datagram_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/datagram_protocol.cpp
deleted file mode 100644
index 23f677d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/datagram_protocol.cpp
+++ /dev/null
@@ -1,242 +0,0 @@
-//
-// datagram_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/local/datagram_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// local_datagram_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// local::datagram_socket::socket compile and link correctly. Runtime failures
-// are ignored.
-
-namespace local_datagram_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-  using namespace asio;
-  namespace local = asio::local;
-  typedef local::datagram_protocol dp;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    socket_base::send_buffer_size socket_option;
-    socket_base::bytes_readable io_control_command;
-    asio::error_code ec;
-
-    // basic_datagram_socket constructors.
-
-    dp::socket socket1(ioc);
-    dp::socket socket2(ioc, dp());
-    dp::socket socket3(ioc, dp::endpoint(""));
-    int native_socket1 = ::socket(AF_UNIX, SOCK_DGRAM, 0);
-    dp::socket socket4(ioc, dp(), native_socket1);
-
-    dp::socket socket5(ioc_ex);
-    dp::socket socket6(ioc_ex, dp());
-    dp::socket socket7(ioc_ex, dp::endpoint(""));
-    int native_socket2 = ::socket(AF_UNIX, SOCK_DGRAM, 0);
-    dp::socket socket8(ioc_ex, dp(), native_socket2);
-
-    // basic_io_object functions.
-
-    dp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    dp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(dp());
-    socket1.open(dp(), ec);
-
-    int native_socket3 = ::socket(AF_UNIX, SOCK_DGRAM, 0);
-    socket1.assign(dp(), native_socket3);
-    int native_socket4 = ::socket(AF_UNIX, SOCK_DGRAM, 0);
-    socket1.assign(dp(), native_socket4, ec);
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    dp::socket::native_handle_type native_socket5 = socket1.native_handle();
-    (void)native_socket5;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(dp::endpoint(""));
-    socket1.bind(dp::endpoint(""), ec);
-
-    socket1.connect(dp::endpoint(""));
-    socket1.connect(dp::endpoint(""), ec);
-
-    socket1.async_connect(dp::endpoint(""), connect_handler);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    dp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    dp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    dp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    dp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_datagram_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler);
-    socket1.async_send(buffer(const_char_buffer), send_handler);
-    socket1.async_send(null_buffers(), send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint(""));
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint(""));
-    socket1.send_to(null_buffers(),
-        dp::endpoint(""));
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint(""), in_flags);
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint(""), in_flags);
-    socket1.send_to(null_buffers(),
-        dp::endpoint(""), in_flags);
-    socket1.send_to(buffer(mutable_char_buffer),
-        dp::endpoint(""), in_flags, ec);
-    socket1.send_to(buffer(const_char_buffer),
-        dp::endpoint(""), in_flags, ec);
-    socket1.send_to(null_buffers(),
-        dp::endpoint(""), in_flags, ec);
-
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(""), send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(""), send_handler);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(""), send_handler);
-    socket1.async_send_to(buffer(mutable_char_buffer),
-        dp::endpoint(""), in_flags, send_handler);
-    socket1.async_send_to(buffer(const_char_buffer),
-        dp::endpoint(""), in_flags, send_handler);
-    socket1.async_send_to(null_buffers(),
-        dp::endpoint(""), in_flags, send_handler);
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
-    socket1.async_receive(null_buffers(), receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, receive_handler);
-
-    dp::endpoint endpoint;
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint);
-    socket1.receive_from(null_buffers(), endpoint);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
-    socket1.receive_from(null_buffers(), endpoint, in_flags);
-    socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
-    socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
-
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, receive_handler);
-    socket1.async_receive_from(buffer(mutable_char_buffer),
-        endpoint, in_flags, receive_handler);
-    socket1.async_receive_from(null_buffers(),
-        endpoint, in_flags, receive_handler);
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-}
-
-} // namespace local_datagram_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "local/datagram_protocol",
-  ASIO_COMPILE_TEST_CASE(local_datagram_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/seq_packet_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/seq_packet_protocol.cpp
deleted file mode 100644
index 0093482..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/seq_packet_protocol.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-//
-// local/seq_packet_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/local/seq_packet_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-#include "../archetypes/async_result.hpp"
-
-#if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
-# define local cpp_local
-#endif
-
-//------------------------------------------------------------------------------
-
-// local_seq_packet_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// local::seq_packet_socket::socket compile and link correctly. Runtime
-// failures are ignored.
-
-namespace local_seq_packet_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace local = asio::local;
-  typedef local::seq_packet_protocol spp;
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    const socket_base::message_flags in_flags = 0;
-    socket_base::message_flags out_flags = 0;
-    socket_base::send_buffer_size socket_option;
-    socket_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    asio::error_code ec;
-
-    // basic_seq_packet_socket constructors.
-
-    spp::socket socket1(ioc);
-    spp::socket socket2(ioc, spp());
-    spp::socket socket3(ioc, spp::endpoint());
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    spp::socket::native_handle_type native_socket1
-      = ::socket(AF_UNIX, SOCK_SEQPACKET, 0);
-    spp::socket socket4(ioc, spp(), native_socket1);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    spp::socket socket5(std::move(socket4));
-
-    // basic_seq_packet_socket operators.
-
-    socket1 = spp::socket(ioc);
-    socket1 = std::move(socket2);
-
-    // basic_io_object functions.
-
-    spp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    spp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(spp());
-    socket1.open(spp(), ec);
-
-#if !defined(ASIO_WINDOWS_RUNTIME)
-    spp::socket::native_handle_type native_socket2
-      = ::socket(AF_UNIX, SOCK_SEQPACKET, 0);
-    socket1.assign(spp(), native_socket2);
-    spp::socket::native_handle_type native_socket3
-      = ::socket(AF_UNIX, SOCK_SEQPACKET, 0);
-    socket1.assign(spp(), native_socket3, ec);
-#endif // !defined(ASIO_WINDOWS_RUNTIME)
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    spp::socket::native_handle_type native_socket4 = socket1.native_handle();
-    (void)native_socket4;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(spp::endpoint());
-    socket1.bind(spp::endpoint(), ec);
-
-    socket1.connect(spp::endpoint());
-    socket1.connect(spp::endpoint(), ec);
-
-    socket1.async_connect(spp::endpoint(), connect_handler);
-    socket1.async_connect(spp::endpoint(), immediate);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    spp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    spp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    spp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    spp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_seq_packet_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, immediate);
-    socket1.async_send(buffer(const_char_buffer), in_flags, immediate);
-    socket1.async_send(null_buffers(), in_flags, immediate);
-
-    socket1.receive(buffer(mutable_char_buffer), out_flags);
-    socket1.receive(null_buffers(), out_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags);
-    socket1.receive(null_buffers(), in_flags, out_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, out_flags, ec);
-    socket1.receive(null_buffers(), in_flags, out_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), out_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), out_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        out_flags, receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, out_flags, receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), out_flags, immediate);
-    socket1.async_receive(null_buffers(), out_flags, immediate);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        out_flags, immediate);
-    socket1.async_receive(null_buffers(), in_flags, out_flags, immediate);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace local_seq_packet_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "local/seq_packet_protocol",
-  ASIO_COMPILE_TEST_CASE(local_seq_packet_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/stream_protocol.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/stream_protocol.cpp
deleted file mode 100644
index 985d143..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/local/stream_protocol.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//
-// stream_protocol.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/local/stream_protocol.hpp"
-
-#include <cstring>
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// local_stream_protocol_socket_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// local::stream_protocol::socket compile and link correctly. Runtime failures
-// are ignored.
-
-namespace local_stream_protocol_socket_compile {
-
-void connect_handler(const asio::error_code&)
-{
-}
-
-void send_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void receive_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_LOCAL_SOCKETS)
-  using namespace asio;
-  namespace local = asio::local;
-  typedef local::stream_protocol sp;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    socket_base::message_flags in_flags = 0;
-    socket_base::keep_alive socket_option;
-    socket_base::bytes_readable io_control_command;
-    asio::error_code ec;
-
-    // basic_stream_socket constructors.
-
-    sp::socket socket1(ioc);
-    sp::socket socket2(ioc, sp());
-    sp::socket socket3(ioc, sp::endpoint(""));
-    int native_socket1 = ::socket(AF_UNIX, SOCK_STREAM, 0);
-    sp::socket socket4(ioc, sp(), native_socket1);
-
-    sp::socket socket5(ioc_ex);
-    sp::socket socket6(ioc_ex, sp());
-    sp::socket socket7(ioc_ex, sp::endpoint(""));
-    int native_socket2 = ::socket(AF_UNIX, SOCK_STREAM, 0);
-    sp::socket socket8(ioc_ex, sp(), native_socket2);
-
-    // basic_io_object functions.
-
-    sp::socket::executor_type ex = socket1.get_executor();
-    (void)ex;
-
-    // basic_socket functions.
-
-    sp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
-    (void)lowest_layer;
-
-    socket1.open(sp());
-    socket1.open(sp(), ec);
-
-    int native_socket3 = ::socket(AF_UNIX, SOCK_STREAM, 0);
-    socket1.assign(sp(), native_socket3);
-    int native_socket4 = ::socket(AF_UNIX, SOCK_STREAM, 0);
-    socket1.assign(sp(), native_socket4, ec);
-
-    bool is_open = socket1.is_open();
-    (void)is_open;
-
-    socket1.close();
-    socket1.close(ec);
-
-    sp::socket::native_handle_type native_socket5 = socket1.native_handle();
-    (void)native_socket5;
-
-    socket1.cancel();
-    socket1.cancel(ec);
-
-    bool at_mark1 = socket1.at_mark();
-    (void)at_mark1;
-    bool at_mark2 = socket1.at_mark(ec);
-    (void)at_mark2;
-
-    std::size_t available1 = socket1.available();
-    (void)available1;
-    std::size_t available2 = socket1.available(ec);
-    (void)available2;
-
-    socket1.bind(sp::endpoint(""));
-    socket1.bind(sp::endpoint(""), ec);
-
-    socket1.connect(sp::endpoint(""));
-    socket1.connect(sp::endpoint(""), ec);
-
-    socket1.async_connect(sp::endpoint(""), connect_handler);
-
-    socket1.set_option(socket_option);
-    socket1.set_option(socket_option, ec);
-
-    socket1.get_option(socket_option);
-    socket1.get_option(socket_option, ec);
-
-    socket1.io_control(io_control_command);
-    socket1.io_control(io_control_command, ec);
-
-    sp::endpoint endpoint1 = socket1.local_endpoint();
-    (void)endpoint1;
-    sp::endpoint endpoint2 = socket1.local_endpoint(ec);
-    (void)endpoint2;
-
-    sp::endpoint endpoint3 = socket1.remote_endpoint();
-    (void)endpoint3;
-    sp::endpoint endpoint4 = socket1.remote_endpoint(ec);
-    (void)endpoint4;
-
-    socket1.shutdown(socket_base::shutdown_both);
-    socket1.shutdown(socket_base::shutdown_both, ec);
-
-    // basic_stream_socket functions.
-
-    socket1.send(buffer(mutable_char_buffer));
-    socket1.send(buffer(const_char_buffer));
-    socket1.send(null_buffers());
-    socket1.send(buffer(mutable_char_buffer), in_flags);
-    socket1.send(buffer(const_char_buffer), in_flags);
-    socket1.send(null_buffers(), in_flags);
-    socket1.send(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.send(buffer(const_char_buffer), in_flags, ec);
-    socket1.send(null_buffers(), in_flags, ec);
-
-    socket1.async_send(buffer(mutable_char_buffer), send_handler);
-    socket1.async_send(buffer(const_char_buffer), send_handler);
-    socket1.async_send(null_buffers(), send_handler);
-    socket1.async_send(buffer(mutable_char_buffer), in_flags, send_handler);
-    socket1.async_send(buffer(const_char_buffer), in_flags, send_handler);
-    socket1.async_send(null_buffers(), in_flags, send_handler);
-
-    socket1.receive(buffer(mutable_char_buffer));
-    socket1.receive(null_buffers());
-    socket1.receive(buffer(mutable_char_buffer), in_flags);
-    socket1.receive(null_buffers(), in_flags);
-    socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
-    socket1.receive(null_buffers(), in_flags, ec);
-
-    socket1.async_receive(buffer(mutable_char_buffer), receive_handler);
-    socket1.async_receive(null_buffers(), receive_handler);
-    socket1.async_receive(buffer(mutable_char_buffer), in_flags,
-        receive_handler);
-    socket1.async_receive(null_buffers(), in_flags, receive_handler);
-
-    socket1.write_some(buffer(mutable_char_buffer));
-    socket1.write_some(buffer(const_char_buffer));
-    socket1.write_some(null_buffers());
-    socket1.write_some(buffer(mutable_char_buffer), ec);
-    socket1.write_some(buffer(const_char_buffer), ec);
-    socket1.write_some(null_buffers(), ec);
-
-    socket1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
-    socket1.async_write_some(buffer(const_char_buffer), write_some_handler);
-    socket1.async_write_some(null_buffers(), write_some_handler);
-
-    socket1.read_some(buffer(mutable_char_buffer));
-    socket1.read_some(buffer(mutable_char_buffer), ec);
-    socket1.read_some(null_buffers(), ec);
-
-    socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
-    socket1.async_read_some(null_buffers(), read_some_handler);
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_LOCAL_SOCKETS)
-}
-
-} // namespace local_stream_protocol_socket_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "local/stream_protocol",
-  ASIO_COMPILE_TEST_CASE(local_stream_protocol_socket_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/packaged_task.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/packaged_task.cpp
deleted file mode 100644
index 90b36d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/packaged_task.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// packaged_task.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/packaged_task.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "packaged_task",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/placeholders.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/placeholders.cpp
deleted file mode 100644
index 4f27d31..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/placeholders.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// placeholders.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/placeholders.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "placeholders",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/.gitignore
deleted file mode 100644
index 8ce6e1d..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/.gitignore
+++ /dev/null
@@ -1,14 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-basic_descriptor
-basic_stream_descriptor
-descriptor
-descriptor_base
-stream_descriptor
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_descriptor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_descriptor.cpp
deleted file mode 100644
index f05ed31..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_descriptor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_descriptor.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/posix/basic_descriptor.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "posix/basic_descriptor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_stream_descriptor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_stream_descriptor.cpp
deleted file mode 100644
index 8ea6685..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/basic_stream_descriptor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_stream_descriptor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/posix/basic_stream_descriptor.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "posix/basic_stream_descriptor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor.cpp
deleted file mode 100644
index c08ef8f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// descriptor.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/posix/descriptor.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "posix/descriptor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor_base.cpp
deleted file mode 100644
index 0437c9f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/descriptor_base.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// descriptor_base.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/posix/descriptor_base.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "posix/descriptor_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/stream_descriptor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/stream_descriptor.cpp
deleted file mode 100644
index a8fdc4b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/posix/stream_descriptor.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-// stream_descriptor.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/posix/stream_descriptor.hpp"
-
-#include "asio/io_context.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// posix_stream_descriptor_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// posix::stream_descriptor compile and link correctly. Runtime failures are
-// ignored.
-
-namespace posix_stream_descriptor_compile {
-
-void wait_handler(const asio::error_code&)
-{
-}
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-  using namespace asio;
-  namespace posix = asio::posix;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    posix::descriptor_base::bytes_readable io_control_command;
-    archetypes::immediate_handler immediate;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_stream_descriptor constructors.
-
-    posix::stream_descriptor descriptor1(ioc);
-    posix::stream_descriptor descriptor2(ioc_ex);
-    int native_descriptor1 = -1;
-    posix::stream_descriptor descriptor3(ioc, native_descriptor1);
-    posix::stream_descriptor descriptor4(ioc_ex, native_descriptor1);
-
-    posix::stream_descriptor descriptor5(std::move(descriptor2));
-
-    posix::basic_stream_descriptor<io_context::executor_type> descriptor6(ioc);
-    posix::stream_descriptor descriptor7(std::move(descriptor6));
-
-    // basic_stream_descriptor operators.
-
-    descriptor1 = posix::stream_descriptor(ioc);
-    descriptor1 = std::move(descriptor2);
-    descriptor1 = std::move(descriptor6);
-
-    // basic_io_object functions.
-
-    posix::stream_descriptor::executor_type ex = descriptor1.get_executor();
-    (void)ex;
-
-    // basic_descriptor functions.
-
-    posix::stream_descriptor::lowest_layer_type& lowest_layer
-      = descriptor1.lowest_layer();
-    (void)lowest_layer;
-
-    const posix::stream_descriptor& descriptor8 = descriptor1;
-    const posix::stream_descriptor::lowest_layer_type& lowest_layer2
-      = descriptor8.lowest_layer();
-    (void)lowest_layer2;
-
-    int native_descriptor2 = -1;
-    descriptor1.assign(native_descriptor2);
-
-    bool is_open = descriptor1.is_open();
-    (void)is_open;
-
-    descriptor1.close();
-    descriptor1.close(ec);
-
-    posix::stream_descriptor::native_handle_type native_descriptor3
-      = descriptor1.native_handle();
-    (void)native_descriptor3;
-
-    posix::stream_descriptor::native_handle_type native_descriptor4
-      = descriptor1.release();
-    (void)native_descriptor4;
-
-    descriptor1.cancel();
-    descriptor1.cancel(ec);
-
-    descriptor1.io_control(io_control_command);
-    descriptor1.io_control(io_control_command, ec);
-
-    bool non_blocking1 = descriptor1.non_blocking();
-    (void)non_blocking1;
-    descriptor1.non_blocking(true);
-    descriptor1.non_blocking(false, ec);
-
-    bool non_blocking2 = descriptor1.native_non_blocking();
-    (void)non_blocking2;
-    descriptor1.native_non_blocking(true);
-    descriptor1.native_non_blocking(false, ec);
-
-    descriptor1.wait(posix::descriptor_base::wait_read);
-    descriptor1.wait(posix::descriptor_base::wait_write, ec);
-
-    descriptor1.async_wait(posix::descriptor_base::wait_read, &wait_handler);
-    descriptor1.async_wait(posix::descriptor_base::wait_read, immediate);
-    int i1 = descriptor1.async_wait(posix::descriptor_base::wait_write, lazy);
-    (void)i1;
-
-    // basic_stream_descriptor functions.
-
-    descriptor1.write_some(buffer(mutable_char_buffer));
-    descriptor1.write_some(buffer(const_char_buffer));
-    descriptor1.write_some(null_buffers());
-    descriptor1.write_some(buffer(mutable_char_buffer), ec);
-    descriptor1.write_some(buffer(const_char_buffer), ec);
-    descriptor1.write_some(null_buffers(), ec);
-
-    descriptor1.async_write_some(buffer(mutable_char_buffer),
-        write_some_handler);
-    descriptor1.async_write_some(buffer(const_char_buffer),
-        write_some_handler);
-    descriptor1.async_write_some(null_buffers(),
-        write_some_handler);
-    descriptor1.async_write_some(buffer(mutable_char_buffer), immediate);
-    descriptor1.async_write_some(buffer(const_char_buffer), immediate);
-    descriptor1.async_write_some(null_buffers(), immediate);
-    int i2 = descriptor1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i2;
-    int i3 = descriptor1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i3;
-    int i4 = descriptor1.async_write_some(null_buffers(), lazy);
-    (void)i4;
-
-    descriptor1.read_some(buffer(mutable_char_buffer));
-    descriptor1.read_some(buffer(mutable_char_buffer), ec);
-    descriptor1.read_some(null_buffers(), ec);
-
-    descriptor1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
-    descriptor1.async_read_some(null_buffers(), read_some_handler);
-    descriptor1.async_read_some(buffer(mutable_char_buffer), immediate);
-    descriptor1.async_read_some(null_buffers(), immediate);
-    int i5 = descriptor1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i5;
-    int i6 = descriptor1.async_read_some(null_buffers(), lazy);
-    (void)i6;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-}
-
-} // namespace posix_stream_descriptor_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "posix/stream_descriptor",
-  ASIO_COMPILE_TEST_CASE(posix_stream_descriptor_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/post.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/post.cpp
deleted file mode 100644
index d2ef235..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/post.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// post.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/post.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "post",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/prepend.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/prepend.cpp
deleted file mode 100644
index cc26bf9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/prepend.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// prepend.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/prepend.hpp"
-
-#include "asio/bind_executor.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "unit_test.hpp"
-
-void prepend_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(
-      asio::prepend(
-        asio::bind_executor(io2.get_executor(),
-          [&count](int a, int b, asio::error_code)
-          {
-            ++count;
-            ASIO_CHECK(a == 123);
-            ASIO_CHECK(b == 321);
-          }), 123, 321));
-
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "prepend",
-  ASIO_TEST_CASE(prepend_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/random_access_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/random_access_file.cpp
deleted file mode 100644
index be703cd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/random_access_file.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-//
-// random_access_file.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/random_access_file.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-// random_access_file_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// random_access_file compile and link correctly. Runtime failures are ignored.
-
-namespace random_access_file_compile {
-
-struct write_some_at_handler
-{
-  write_some_at_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_at_handler(write_some_at_handler&&) {}
-private:
-  write_some_at_handler(const write_some_at_handler&);
-};
-
-struct read_some_at_handler
-{
-  read_some_at_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_at_handler(read_some_at_handler&&) {}
-private:
-  read_some_at_handler(const read_some_at_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_FILE)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-    const std::string path;
-
-    // basic_random_access_file constructors.
-
-    random_access_file file1(ioc);
-    random_access_file file2(ioc, "", random_access_file::read_only);
-    random_access_file file3(ioc, path, random_access_file::read_only);
-    random_access_file::native_handle_type native_file1 = file1.native_handle();
-    random_access_file file4(ioc, native_file1);
-
-    random_access_file file5(ioc_ex);
-    random_access_file file6(ioc_ex, "", random_access_file::read_only);
-    random_access_file file7(ioc_ex, path, random_access_file::read_only);
-    random_access_file::native_handle_type native_file2 = file1.native_handle();
-    random_access_file file8(ioc_ex, native_file2);
-
-    random_access_file file9(std::move(file8));
-
-    basic_random_access_file<io_context::executor_type> file10(ioc);
-    random_access_file file11(std::move(file10));
-
-    // basic_random_access_file operators.
-
-    file1 = random_access_file(ioc);
-    file1 = std::move(file2);
-    file1 = std::move(file10);
-
-    // basic_io_object functions.
-
-    random_access_file::executor_type ex = file1.get_executor();
-    (void)ex;
-
-    // basic_random_access_file functions.
-
-    file1.open("", random_access_file::read_only);
-    file1.open("", random_access_file::read_only, ec);
-
-    file1.open(path, random_access_file::read_only);
-    file1.open(path, random_access_file::read_only, ec);
-
-    random_access_file::native_handle_type native_file3 = file1.native_handle();
-    file1.assign(native_file3);
-    random_access_file::native_handle_type native_file4 = file1.native_handle();
-    file1.assign(native_file4, ec);
-
-    bool is_open = file1.is_open();
-    (void)is_open;
-
-    file1.close();
-    file1.close(ec);
-
-    random_access_file::native_handle_type native_file5 = file1.native_handle();
-    (void)native_file5;
-
-    random_access_file::native_handle_type native_file6 = file1.release();
-    (void)native_file6;
-    random_access_file::native_handle_type native_file7 = file1.release(ec);
-    (void)native_file7;
-
-    file1.cancel();
-    file1.cancel(ec);
-
-    asio::uint64_t s1 = file1.size();
-    (void)s1;
-    asio::uint64_t s2 = file1.size(ec);
-    (void)s2;
-
-    file1.resize(asio::uint64_t(0));
-    file1.resize(asio::uint64_t(0), ec);
-
-    file1.sync_all();
-    file1.sync_all(ec);
-
-    file1.sync_data();
-    file1.sync_data(ec);
-
-    file1.write_some_at(0, buffer(mutable_char_buffer));
-    file1.write_some_at(0, buffer(const_char_buffer));
-    file1.write_some_at(0, buffer(mutable_char_buffer), ec);
-    file1.write_some_at(0, buffer(const_char_buffer), ec);
-
-    file1.async_write_some_at(0, buffer(mutable_char_buffer),
-        write_some_at_handler());
-    file1.async_write_some_at(0, buffer(const_char_buffer),
-        write_some_at_handler());
-    int i1 = file1.async_write_some_at(0, buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = file1.async_write_some_at(0, buffer(const_char_buffer), lazy);
-    (void)i2;
-
-    file1.read_some_at(0, buffer(mutable_char_buffer));
-    file1.read_some_at(0, buffer(mutable_char_buffer), ec);
-
-    file1.async_read_some_at(0, buffer(mutable_char_buffer),
-        read_some_at_handler());
-    int i3 = file1.async_read_some_at(0, buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_FILE)
-}
-
-} // namespace random_access_file_compile
-
-ASIO_TEST_SUITE
-(
-  "random_access_file",
-  ASIO_COMPILE_TEST_CASE(random_access_file_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read.cpp
deleted file mode 100644
index b613140..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read.cpp
+++ /dev/null
@@ -1,5081 +0,0 @@
-//
-// read.cpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/read.hpp"
-
-#include <array>
-#include <cstring>
-#include <functional>
-#include <vector>
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/streambuf.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-#include <boost/array.hpp>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_stream
-{
-public:
-  typedef asio::io_context::executor_type executor_type;
-
-  test_stream(asio::io_context& io_context)
-    : io_context_(io_context),
-      length_(0),
-      position_(0),
-      next_read_length_(0)
-  {
-  }
-
-  executor_type get_executor() noexcept
-  {
-    return io_context_.get_executor();
-  }
-
-  void reset(const void* data, size_t length)
-  {
-    ASIO_CHECK(length <= max_length);
-
-    memcpy(data_, data, length);
-    length_ = length;
-    position_ = 0;
-    next_read_length_ = length;
-  }
-
-  void next_read_length(size_t length)
-  {
-    next_read_length_ = length;
-  }
-
-  template <typename Iterator>
-  bool check_buffers(Iterator begin, Iterator end, size_t length)
-  {
-    if (length != position_)
-      return false;
-
-    Iterator iter = begin;
-    size_t checked_length = 0;
-    for (; iter != end && checked_length < length; ++iter)
-    {
-      size_t buffer_length = asio::buffer_size(*iter);
-      if (buffer_length > length - checked_length)
-        buffer_length = length - checked_length;
-      if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
-        return false;
-      checked_length += buffer_length;
-    }
-
-    return true;
-  }
-
-  template <typename Const_Buffers>
-  bool check_buffers(const Const_Buffers& buffers, size_t length)
-  {
-    return check_buffers(asio::buffer_sequence_begin(buffers),
-        asio::buffer_sequence_end(buffers), length);
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some(const Mutable_Buffers& buffers)
-  {
-    size_t n = asio::buffer_copy(buffers,
-        asio::buffer(data_, length_) + position_,
-        next_read_length_);
-    position_ += n;
-    return n;
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some(const Mutable_Buffers& buffers,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return read_some(buffers);
-  }
-
-  template <typename Mutable_Buffers, typename Handler>
-  void async_read_some(const Mutable_Buffers& buffers,
-      Handler&& handler)
-  {
-    size_t bytes_transferred = read_some(buffers);
-    asio::post(get_executor(),
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler),
-          asio::error_code(), bytes_transferred));
-  }
-
-private:
-  asio::io_context& io_context_;
-  enum { max_length = 8192 };
-  char data_[max_length];
-  size_t length_;
-  size_t position_;
-  size_t next_read_length_;
-};
-
-static const char read_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void test_2_arg_zero_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::mutable_buffer> buffers;
-
-  size_t bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test_2_arg_mutable_buffer_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_2_arg_vector_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_2_arg_dynamic_string_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-}
-
-void test_2_arg_streambuf_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_3_arg_nothrow_zero_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::mutable_buffer> buffers;
-
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == 0);
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_mutable_buffer_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_vector_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_dynamic_string_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_streambuf_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-bool old_style_transfer_all(const asio::error_code& ec,
-    size_t /*bytes_transferred*/)
-{
-  return !!ec;
-}
-
-struct short_transfer
-{
-  short_transfer() {}
-  short_transfer(short_transfer&&) {}
-  size_t operator()(const asio::error_code& ec,
-      size_t /*bytes_transferred*/)
-  {
-    return !!ec ? 0 : 3;
-  }
-};
-
-void test_3_arg_mutable_buffer_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_3_arg_vector_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_3_arg_dynamic_string_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-}
-
-void test_3_arg_streambuf_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_4_arg_mutable_buffer_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_vector_buffers_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_dynamic_string_read()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_streambuf_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(), 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void async_read_handler(const asio::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!e);
-  ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
-}
-
-void test_3_arg_mutable_buffer_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-    asio::async_read(s, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_3_arg_boost_array_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  boost::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_3_arg_std_array_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_3_arg_vector_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_3_arg_dynamic_string_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read(s, sb, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-}
-
-void test_3_arg_streambuf_async_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read(s, sb, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_4_arg_mutable_buffer_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_4_arg_boost_array_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  boost::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_4_arg_std_array_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_4_arg_vector_buffers_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf, 39) + 32);
-  buffers.push_back(asio::buffer(read_buf) + 39);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read(s, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read(s, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(read_data)));
-}
-
-void test_4_arg_dynamic_string_async_read()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read(s, sb,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(0, sb.size()), sizeof(read_data)));
-}
-
-void test_4_arg_streambuf_async_read()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read(s, sb,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read(s, sb, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(sb.data(), sizeof(read_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-ASIO_TEST_SUITE
-(
-  "read",
-  ASIO_TEST_CASE(test_2_arg_zero_buffers_read)
-  ASIO_TEST_CASE(test_2_arg_mutable_buffer_read)
-  ASIO_TEST_CASE(test_2_arg_vector_buffers_read)
-  ASIO_TEST_CASE(test_2_arg_dynamic_string_read)
-  ASIO_TEST_CASE(test_2_arg_streambuf_read)
-  ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_read)
-  ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_read)
-  ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_read)
-  ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_read)
-  ASIO_TEST_CASE(test_3_arg_nothrow_streambuf_read)
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_read)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_read)
-  ASIO_TEST_CASE(test_3_arg_dynamic_string_read)
-  ASIO_TEST_CASE(test_3_arg_streambuf_read)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_read)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_read)
-  ASIO_TEST_CASE(test_4_arg_dynamic_string_read)
-  ASIO_TEST_CASE(test_4_arg_streambuf_read)
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_read)
-  ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_read)
-  ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_read)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_async_read)
-  ASIO_TEST_CASE(test_3_arg_dynamic_string_async_read)
-  ASIO_TEST_CASE(test_3_arg_streambuf_async_read)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read)
-  ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read)
-  ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read)
-  ASIO_TEST_CASE(test_4_arg_dynamic_string_async_read)
-  ASIO_TEST_CASE(test_4_arg_streambuf_async_read)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_at.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_at.cpp
deleted file mode 100644
index 3b967c2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_at.cpp
+++ /dev/null
@@ -1,7568 +0,0 @@
-//
-// read_at.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/read_at.hpp"
-
-#include <array>
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/streambuf.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-#include <boost/array.hpp>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_random_access_device
-{
-public:
-  typedef asio::io_context::executor_type executor_type;
-
-  test_random_access_device(asio::io_context& io_context)
-    : io_context_(io_context),
-      length_(0),
-      next_read_length_(0)
-  {
-  }
-
-  executor_type get_executor() noexcept
-  {
-    return io_context_.get_executor();
-  }
-
-  void reset(const void* data, size_t length)
-  {
-    ASIO_CHECK(length <= max_length);
-
-    length_ = 0;
-    while (length_ + length < max_length)
-    {
-      memcpy(data_ + length_, data, length);
-      length_ += length;
-    }
-
-    next_read_length_ = length;
-  }
-
-  void next_read_length(size_t length)
-  {
-    next_read_length_ = length;
-  }
-
-  template <typename Iterator>
-  bool check_buffers(asio::uint64_t offset,
-      Iterator begin, Iterator end, size_t length)
-  {
-    if (offset + length > max_length)
-      return false;
-
-    Iterator iter = begin;
-    size_t checked_length = 0;
-    for (; iter != end && checked_length < length; ++iter)
-    {
-      size_t buffer_length = asio::buffer_size(*iter);
-      if (buffer_length > length - checked_length)
-        buffer_length = length - checked_length;
-      if (memcmp(data_ + offset + checked_length,
-            iter->data(), buffer_length) != 0)
-        return false;
-      checked_length += buffer_length;
-    }
-
-    return true;
-  }
-
-  template <typename Const_Buffers>
-  bool check_buffers(asio::uint64_t offset,
-      const Const_Buffers& buffers, size_t length)
-  {
-    return check_buffers(offset, asio::buffer_sequence_begin(buffers),
-        asio::buffer_sequence_end(buffers), length);
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some_at(asio::uint64_t offset,
-      const Mutable_Buffers& buffers)
-  {
-    return asio::buffer_copy(buffers,
-        asio::buffer(data_, length_) + offset,
-        next_read_length_);
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some_at(asio::uint64_t offset,
-      const Mutable_Buffers& buffers, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return read_some_at(offset, buffers);
-  }
-
-  template <typename Mutable_Buffers, typename Handler>
-  void async_read_some_at(asio::uint64_t offset,
-      const Mutable_Buffers& buffers, Handler&& handler)
-  {
-    size_t bytes_transferred = read_some_at(offset, buffers);
-    asio::post(get_executor(),
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler),
-          asio::error_code(), bytes_transferred));
-  }
-
-private:
-  asio::io_context& io_context_;
-  enum { max_length = 8192 };
-  char data_[max_length];
-  size_t length_;
-  size_t next_read_length_;
-};
-
-static const char read_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void test_3_arg_mutable_buffer_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_3_arg_vector_buffers_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_3_arg_streambuf_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read_at(s, 0, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-}
-
-void test_4_arg_nothrow_mutable_buffer_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_nothrow_vector_buffers_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_nothrow_streambuf_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-bool old_style_transfer_all(const asio::error_code& ec,
-    size_t /*bytes_transferred*/)
-{
-  return !!ec;
-}
-
-struct short_transfer
-{
-  short_transfer() {}
-  short_transfer(short_transfer&&) {}
-  size_t operator()(const asio::error_code& ec,
-      size_t /*bytes_transferred*/)
-  {
-    return !!ec ? 0 : 3;
-  }
-};
-
-void test_4_arg_mutable_buffer_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_4_arg_vector_buffers_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  size_t bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_4_arg_streambuf_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  size_t bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-}
-
-void test_5_arg_mutable_buffer_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_5_arg_vector_buffers_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_5_arg_streambuf_read_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  asio::error_code error;
-  size_t bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 0, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 0, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  error = asio::error_code();
-  bytes_transferred = asio::read_at(s, 1234, sb,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(read_data));
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-  ASIO_CHECK(!error);
-}
-
-void async_read_handler(const asio::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!e);
-  ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
-}
-
-void test_4_arg_mutable_buffer_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_4_arg_boost_array_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  boost::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_4_arg_std_array_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_4_arg_vector_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_4_arg_streambuf_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read_at(s, 0, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read_at(s, 1234, sb,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb)(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-}
-
-void test_5_arg_mutable_buffer_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  asio::mutable_buffer buffers
-    = asio::buffer(read_buf, sizeof(read_buf));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_5_arg_boost_array_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  boost::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_5_arg_std_array_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::array<asio::mutable_buffer, 2> buffers = { {
-    asio::buffer(read_buf, 32),
-    asio::buffer(read_buf) + 32 } };
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_5_arg_vector_buffers_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  char read_buf[sizeof(read_data)];
-  std::vector<asio::mutable_buffer> buffers;
-  buffers.push_back(asio::buffer(read_buf, 32));
-  buffers.push_back(asio::buffer(read_buf) + 32);
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  bool called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  memset(read_buf, 0, sizeof(read_buf));
-  int i = asio::async_read_at(s, 1234, buffers,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  memset(read_buf, 0, sizeof(read_buf));
-  called = false;
-  asio::async_read_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(read_data)));
-}
-
-void test_5_arg_streambuf_async_read_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb(sizeof(read_data));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  bool called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 50);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 50));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_read_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 1);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 1));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_read_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 10);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 10));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(0, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_read_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == 42);
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), 42));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(0, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  sb.consume(sb.size());
-  int i = asio::async_read_at(s, 1234, sb,
-      short_transfer(), archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb.consume(sb.size());
-  called = false;
-  asio::async_read_at(s, 1234, sb, short_transfer())(
-      bindns::bind(async_read_handler,
-        _1, _2, sizeof(read_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(sb.size() == sizeof(read_data));
-  ASIO_CHECK(s.check_buffers(1234, sb.data(), sizeof(read_data)));
-}
-
-ASIO_TEST_SUITE
-(
-  "read_at",
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_read_at)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_read_at)
-  ASIO_TEST_CASE(test_3_arg_streambuf_read_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_read_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_read_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_streambuf_read_at)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_read_at)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_read_at)
-  ASIO_TEST_CASE(test_4_arg_streambuf_read_at)
-  ASIO_TEST_CASE(test_5_arg_mutable_buffer_read_at)
-  ASIO_TEST_CASE(test_5_arg_vector_buffers_read_at)
-  ASIO_TEST_CASE(test_5_arg_streambuf_read_at)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_read_at)
-  ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_read_at)
-  ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_read_at)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_async_read_at)
-  ASIO_TEST_CASE(test_4_arg_streambuf_async_read_at)
-  ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_read_at)
-  ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_read_at)
-  ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_read_at)
-  ASIO_TEST_CASE(test_5_arg_vector_buffers_async_read_at)
-  ASIO_TEST_CASE(test_5_arg_streambuf_async_read_at)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_until.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_until.cpp
deleted file mode 100644
index 7041e1f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/read_until.cpp
+++ /dev/null
@@ -1,1719 +0,0 @@
-//
-// read_until.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/read_until.hpp"
-
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/streambuf.hpp"
-#include "unit_test.hpp"
-
-class test_stream
-{
-public:
-  typedef asio::io_context::executor_type executor_type;
-
-  test_stream(asio::io_context& io_context)
-    : io_context_(io_context),
-      length_(0),
-      position_(0),
-      next_read_length_(0)
-  {
-  }
-
-  executor_type get_executor() noexcept
-  {
-    return io_context_.get_executor();
-  }
-
-  void reset(const void* data, size_t length)
-  {
-    using namespace std; // For memcpy.
-
-    ASIO_CHECK(length <= max_length);
-
-    memcpy(data_, data, length);
-    length_ = length;
-    position_ = 0;
-    next_read_length_ = length;
-  }
-
-  void next_read_length(size_t length)
-  {
-    next_read_length_ = length;
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some(const Mutable_Buffers& buffers)
-  {
-    size_t n = asio::buffer_copy(buffers,
-        asio::buffer(data_, length_) + position_,
-        next_read_length_);
-    position_ += n;
-    return n;
-  }
-
-  template <typename Mutable_Buffers>
-  size_t read_some(const Mutable_Buffers& buffers,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return read_some(buffers);
-  }
-
-  template <typename Mutable_Buffers, typename Handler>
-  void async_read_some(const Mutable_Buffers& buffers, Handler handler)
-  {
-    size_t bytes_transferred = read_some(buffers);
-    asio::post(get_executor(),
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler),
-          asio::error_code(), bytes_transferred));
-  }
-
-private:
-  asio::io_context& io_context_;
-  enum { max_length = 8192 };
-  char data_[max_length];
-  size_t length_;
-  size_t position_;
-  size_t next_read_length_;
-};
-
-static const char read_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void test_dynamic_string_read_until_char()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_read_until_char()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z');
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, 'Z', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Z', ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, 'Y', ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_dynamic_string_read_until_string()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_read_until_string()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ");
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, "XYZ", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "XYZ", ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, "WXY", ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-class match_char
-{
-public:
-  explicit match_char(char c) : c_(c) {}
-
-  template <typename Iterator>
-  std::pair<Iterator, bool> operator()(
-      Iterator begin, Iterator end) const
-  {
-    Iterator i = begin;
-    while (i != end)
-      if (c_ == *i++)
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-
-private:
-  char c_;
-};
-
-namespace asio {
-  template <> struct is_match_condition<match_char>
-  {
-    enum { value = true };
-  };
-} // namespace asio
-
-void test_dynamic_string_read_until_match_condition()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_read_until_match_condition()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  std::size_t length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'));
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb1.consume(sb1.size());
-  length = asio::read_until(s, sb1, match_char('Z'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Z'), ec);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  sb2.consume(sb2.size());
-  length = asio::read_until(s, sb2, match_char('Y'), ec);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void async_read_handler(
-    const asio::error_code& err, asio::error_code* err_out,
-    std::size_t bytes_transferred, std::size_t* bytes_out, bool* called)
-{
-  *err_out = err;
-  *bytes_out = bytes_transferred;
-  *called = true;
-}
-
-void test_dynamic_string_async_read_until_char()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, 'Y',
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y')(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_async_read_until_char()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Z',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y',
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, 'Y',
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, 'Y')(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_dynamic_string_async_read_until_string()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, "WXY",
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY")(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_async_read_until_string()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "XYZ",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY",
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, "WXY",
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, "WXY")(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_dynamic_string_async_read_until_match_condition()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data1, data2;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb1 = asio::dynamic_buffer(data1);
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb2 = asio::dynamic_buffer(data2, 25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, match_char('Y'),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'))(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-}
-
-void test_streambuf_async_read_until_match_condition()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb1;
-  asio::streambuf sb2(25);
-  asio::error_code ec;
-  std::size_t length;
-  bool called;
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb1.consume(sb1.size());
-  asio::async_read_until(s, sb1, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 26);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Z'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(ec == asio::error::not_found);
-  ASIO_CHECK(length == 0);
-
-  s.reset(read_data, sizeof(read_data));
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(1);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'),
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-
-  s.reset(read_data, sizeof(read_data));
-  sb2.consume(sb2.size());
-  int i = asio::async_read_until(s, sb2, match_char('Y'),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-
-  s.reset(read_data, sizeof(read_data));
-  s.next_read_length(10);
-  ec = asio::error_code();
-  length = 0;
-  called = false;
-  sb2.consume(sb2.size());
-  asio::async_read_until(s, sb2, match_char('Y'))(
-      bindns::bind(async_read_handler, _1, &ec,
-        _2, &length, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(length == 25);
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-ASIO_TEST_SUITE
-(
-  "read_until",
-  ASIO_TEST_CASE(test_dynamic_string_read_until_char)
-  ASIO_TEST_CASE(test_streambuf_read_until_char)
-  ASIO_TEST_CASE(test_dynamic_string_read_until_string)
-  ASIO_TEST_CASE(test_streambuf_read_until_string)
-  ASIO_TEST_CASE(test_dynamic_string_read_until_match_condition)
-  ASIO_TEST_CASE(test_streambuf_read_until_match_condition)
-  ASIO_TEST_CASE(test_dynamic_string_async_read_until_char)
-  ASIO_TEST_CASE(test_streambuf_async_read_until_char)
-  ASIO_TEST_CASE(test_dynamic_string_async_read_until_string)
-  ASIO_TEST_CASE(test_streambuf_async_read_until_string)
-  ASIO_TEST_CASE(test_dynamic_string_async_read_until_match_condition)
-  ASIO_TEST_CASE(test_streambuf_async_read_until_match_condition)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/readable_pipe.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/readable_pipe.cpp
deleted file mode 100644
index 6f29710..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/readable_pipe.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//
-// readable_pipe.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header pipe is self-contained.
-#include "asio/readable_pipe.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-// readable_pipe_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// readable_pipe compile and link correctly. Runtime failures are ignored.
-
-namespace readable_pipe_compile {
-
-struct write_some_handler
-{
-  write_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_handler(write_some_handler&&) {}
-private:
-  write_some_handler(const write_some_handler&);
-};
-
-struct read_some_handler
-{
-  read_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_handler(read_some_handler&&) {}
-private:
-  read_some_handler(const read_some_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_PIPE)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-    const std::string path;
-
-    // basic_readable_pipe constructors.
-
-    readable_pipe pipe1(ioc);
-    readable_pipe::native_handle_type native_pipe1 = pipe1.native_handle();
-    readable_pipe pipe2(ioc, native_pipe1);
-
-    readable_pipe pipe3(ioc_ex);
-    readable_pipe::native_handle_type native_pipe2 = pipe1.native_handle();
-    readable_pipe pipe4(ioc_ex, native_pipe2);
-
-    readable_pipe pipe5(std::move(pipe4));
-
-    basic_readable_pipe<io_context::executor_type> pipe6(ioc);
-    readable_pipe pipe7(std::move(pipe6));
-
-    // basic_readable_pipe operators.
-
-    pipe1 = readable_pipe(ioc);
-    pipe1 = std::move(pipe2);
-    pipe1 = std::move(pipe6);
-
-    // basic_io_object functions.
-
-    readable_pipe::executor_type ex = pipe1.get_executor();
-    (void)ex;
-
-    // basic_readable_pipe functions.
-
-    readable_pipe::native_handle_type native_pipe3 = pipe1.native_handle();
-    pipe1.assign(native_pipe3);
-    readable_pipe::native_handle_type native_pipe4 = pipe1.native_handle();
-    pipe1.assign(native_pipe4, ec);
-
-    bool is_open = pipe1.is_open();
-    (void)is_open;
-
-    pipe1.close();
-    pipe1.close(ec);
-
-    readable_pipe::native_handle_type native_pipe5 = pipe1.release();
-    (void)native_pipe5;
-    readable_pipe::native_handle_type native_pipe6 = pipe1.release(ec);
-    (void)native_pipe6;
-
-    readable_pipe::native_handle_type native_pipe7 = pipe1.native_handle();
-    (void)native_pipe7;
-
-    pipe1.cancel();
-    pipe1.cancel(ec);
-
-    pipe1.read_some(buffer(mutable_char_buffer));
-    pipe1.read_some(buffer(mutable_char_buffer), ec);
-
-    pipe1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
-    int i3 = pipe1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_PIPE)
-}
-
-} // namespace readable_pipe_compile
-
-ASIO_TEST_SUITE
-(
-  "readable_pipe",
-  ASIO_COMPILE_TEST_CASE(readable_pipe_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/recycling_allocator.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/recycling_allocator.cpp
deleted file mode 100644
index cc4654f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/recycling_allocator.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// recycling_allocator.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/recycling_allocator.hpp"
-
-#include "unit_test.hpp"
-#include <vector>
-#include "asio/detail/type_traits.hpp"
-
-void recycling_allocator_test()
-{
-  ASIO_CHECK((
-      asio::is_same<
-        asio::recycling_allocator<int>::value_type,
-        int
-      >::value));
-
-  ASIO_CHECK((
-      asio::is_same<
-        asio::recycling_allocator<void>::value_type,
-        void
-      >::value));
-
-  ASIO_CHECK((
-      asio::is_same<
-        asio::recycling_allocator<int>::rebind<char>::other,
-        asio::recycling_allocator<char>
-      >::value));
-
-  ASIO_CHECK((
-      asio::is_same<
-        asio::recycling_allocator<void>::rebind<char>::other,
-        asio::recycling_allocator<char>
-      >::value));
-
-  asio::recycling_allocator<int> a1;
-  asio::recycling_allocator<int> a2(a1);
-
-  ASIO_CHECK(a1 == a2);
-  ASIO_CHECK(!(a1 != a2));
-
-  asio::recycling_allocator<void> a3;
-  asio::recycling_allocator<void> a4(a3);
-
-  ASIO_CHECK(a3 == a4);
-  ASIO_CHECK(!(a3 != a4));
-
-  asio::recycling_allocator<int> a5(a4);
-  (void)a5;
-
-  asio::recycling_allocator<void> a6(a5);
-  (void)a6;
-
-  int* p = a1.allocate(42);
-  ASIO_CHECK(p != 0);
-
-  a1.deallocate(p, 42);
-
-  std::vector<int, asio::recycling_allocator<int> > v(42);
-  ASIO_CHECK(v.size() == 42);
-}
-
-ASIO_TEST_SUITE
-(
-  "recycling_allocator",
-  ASIO_TEST_CASE(recycling_allocator_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/redirect_error.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/redirect_error.cpp
deleted file mode 100644
index 929344a..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/redirect_error.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//
-// redirect_error.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/redirect_error.hpp"
-
-#include "asio/bind_executor.hpp"
-#include "asio/deferred.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/system_timer.hpp"
-#include "asio/use_future.hpp"
-#include "unit_test.hpp"
-
-struct redirect_error_handler
-{
-  int* count_;
-
-  explicit redirect_error_handler(int* c)
-    : count_(c)
-  {
-  }
-
-  void operator()()
-  {
-    ++(*count_);
-  }
-};
-
-void redirect_error_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  asio::error_code ec = asio::error::would_block;
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(
-      asio::redirect_error(
-        asio::bind_executor(io2.get_executor(),
-          redirect_error_handler(&count)), ec));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 1);
-
-  ec = asio::error::would_block;
-  timer1.async_wait(
-      asio::redirect_error(
-        asio::bind_executor(io2.get_executor(),
-          asio::deferred), ec))(redirect_error_handler(&count));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 1);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 1);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 2);
-
-#if defined(ASIO_HAS_STD_FUTURE_CLASS)
-  ec = asio::error::would_block;
-  std::future<void> f = timer1.async_wait(
-      asio::redirect_error(
-        asio::bind_executor(io2.get_executor(),
-          asio::use_future), ec));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::ready);
-#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-}
-
-void partial_redirect_error_test()
-{
-  asio::io_context io1;
-  asio::io_context io2;
-  asio::system_timer timer1(io1);
-  asio::error_code ec = asio::error::would_block;
-  int count = 0;
-
-  timer1.expires_after(asio::chrono::seconds(0));
-  timer1.async_wait(asio::redirect_error(ec))(
-      asio::bind_executor(io2.get_executor(),
-        redirect_error_handler(&count)));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 0);
-
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 0);
-
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 1);
-
-  ec = asio::error::would_block;
-  timer1.async_wait(asio::redirect_error(ec))(
-      asio::bind_executor(io2.get_executor(),
-        asio::deferred))(redirect_error_handler(&count));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 1);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 1);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 2);
-
-  ec = asio::error::would_block;
-  timer1.async_wait()(asio::redirect_error(ec))(
-      asio::bind_executor(io2.get_executor(),
-        asio::deferred))(redirect_error_handler(&count));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 2);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(count == 2);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(count == 3);
-
-#if defined(ASIO_HAS_STD_FUTURE_CLASS)
-  ec = asio::error::would_block;
-  std::future<void> f = timer1.async_wait(asio::redirect_error(ec))(
-      asio::bind_executor(io2.get_executor(), asio::use_future));
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io1.restart();
-  io1.run();
-
-  ASIO_CHECK(ec == asio::error::would_block);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::timeout);
-
-  io2.restart();
-  io2.run();
-
-  ASIO_CHECK(!ec);
-  ASIO_CHECK(f.wait_for(std::chrono::seconds(0))
-      == std::future_status::ready);
-#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
-}
-
-ASIO_TEST_SUITE
-(
-  "redirect_error",
-  ASIO_TEST_CASE(redirect_error_test)
-  ASIO_TEST_CASE(partial_redirect_error_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/registered_buffer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/registered_buffer.cpp
deleted file mode 100644
index 09c3341..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/registered_buffer.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-//
-// registered_buffer.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/registered_buffer.hpp"
-
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// registered_buffer_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all the mutable_registered_buffer and
-// const_registered_buffer classes compile and link correctly. Runtime
-// failures are ignored.
-
-namespace registered_buffer_compile {
-
-using namespace asio;
-
-void test()
-{
-  try
-  {
-    // mutable_registered_buffer constructors.
-
-    mutable_registered_buffer mb1;
-    mutable_registered_buffer mb2(mb1);
-    (void)mb2;
-
-    // mutable_registered_buffer functions.
-
-    mutable_buffer b1 = mb1.buffer();
-    (void)b1;
-
-    void* ptr1 = mb1.data();
-    (void)ptr1;
-
-    std::size_t n1 = mb1.size();
-    (void)n1;
-
-    registered_buffer_id id1 = mb1.id();
-    (void)id1;
-
-    // mutable_registered_buffer operators.
-
-    mb1 += 128;
-    mb1 = mb2 + 128;
-    mb1 = 128 + mb2;
-
-    // const_registered_buffer constructors.
-
-    const_registered_buffer cb1;
-    const_registered_buffer cb2(cb1);
-    (void)cb2;
-    const_registered_buffer cb3(mb1);
-    (void)cb3;
-
-    // const_registered_buffer functions.
-
-    const_buffer b2 = cb1.buffer();
-    (void)b2;
-
-    const void* ptr2 = cb1.data();
-    (void)ptr2;
-
-    std::size_t n2 = cb1.size();
-    (void)n2;
-
-    registered_buffer_id id2 = cb1.id();
-    (void)id2;
-
-    // const_registered_buffer operators.
-
-    cb1 += 128;
-    cb1 = cb2 + 128;
-    cb1 = 128 + cb2;
-
-    // buffer function overloads.
-
-    mb1 = buffer(mb2);
-    mb1 = buffer(mb2, 128);
-    cb1 = buffer(cb2);
-    cb1 = buffer(cb2, 128);
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace buffer_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "registered_buffer",
-  ASIO_COMPILE_TEST_CASE(registered_buffer_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port.cpp
deleted file mode 100644
index 9bbafd3..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-//
-// serial_port.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/serial_port.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// serial_port_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// serial_port compile and link correctly. Runtime failures are ignored.
-
-namespace serial_port_compile {
-
-struct write_some_handler
-{
-  write_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_handler(write_some_handler&&) {}
-private:
-  write_some_handler(const write_some_handler&);
-};
-
-struct read_some_handler
-{
-  read_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_handler(read_some_handler&&) {}
-private:
-  read_some_handler(const read_some_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_SERIAL_PORT)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    serial_port::baud_rate serial_port_option;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_serial_port constructors.
-
-    serial_port port1(ioc);
-    serial_port port2(ioc, "null");
-    serial_port::native_handle_type native_port1 = port1.native_handle();
-#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
-    // Skip this on older MSVC due to mysterious ambiguous overload errors.
-#else
-    serial_port port3(ioc, native_port1);
-#endif
-
-    serial_port port4(ioc_ex);
-    serial_port port5(ioc_ex, "null");
-    serial_port::native_handle_type native_port2 = port1.native_handle();
-    serial_port port6(ioc_ex, native_port2);
-
-    serial_port port7(std::move(port6));
-
-    basic_serial_port<io_context::executor_type> port8(ioc);
-    serial_port port9(std::move(port8));
-
-    // basic_serial_port operators.
-
-    port1 = serial_port(ioc);
-    port1 = std::move(port2);
-    port1 = std::move(port8);
-
-    // basic_io_object functions.
-
-    serial_port::executor_type ex = port1.get_executor();
-    (void)ex;
-
-    // basic_serial_port functions.
-
-    serial_port::lowest_layer_type& lowest_layer = port1.lowest_layer();
-    (void)lowest_layer;
-
-    const serial_port& port10 = port1;
-    const serial_port::lowest_layer_type& lowest_layer2 = port10.lowest_layer();
-    (void)lowest_layer2;
-
-    port1.open("null");
-    port1.open("null", ec);
-
-    serial_port::native_handle_type native_port3 = port1.native_handle();
-    port1.assign(native_port3);
-    serial_port::native_handle_type native_port4 = port1.native_handle();
-    port1.assign(native_port4, ec);
-
-    bool is_open = port1.is_open();
-    (void)is_open;
-
-    port1.close();
-    port1.close(ec);
-
-    serial_port::native_handle_type native_port5 = port1.native_handle();
-    (void)native_port5;
-
-    port1.cancel();
-    port1.cancel(ec);
-
-    port1.set_option(serial_port_option);
-    port1.set_option(serial_port_option, ec);
-
-    port1.get_option(serial_port_option);
-    port1.get_option(serial_port_option, ec);
-
-    port1.send_break();
-    port1.send_break(ec);
-
-    port1.write_some(buffer(mutable_char_buffer));
-    port1.write_some(buffer(const_char_buffer));
-    port1.write_some(buffer(mutable_char_buffer), ec);
-    port1.write_some(buffer(const_char_buffer), ec);
-
-    port1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
-    port1.async_write_some(buffer(const_char_buffer), write_some_handler());
-    int i1 = port1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = port1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-
-    port1.read_some(buffer(mutable_char_buffer));
-    port1.read_some(buffer(mutable_char_buffer), ec);
-
-    port1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
-    int i3 = port1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-}
-
-} // namespace serial_port_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "serial_port",
-  ASIO_COMPILE_TEST_CASE(serial_port_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port_base.cpp
deleted file mode 100644
index 1c888ef..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/serial_port_base.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//
-// serial_port_base.cpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/serial_port_base.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/serial_port.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// serial_port_base_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Verify that all options and and their accessors compile. Runtime failures are
-// ignored.
-
-namespace serial_port_base_compile {
-
-void test()
-{
-#if defined(ASIO_HAS_SERIAL_PORT)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    serial_port port(ioc);
-
-    // baud_rate class.
-
-    serial_port_base::baud_rate baud_rate1(9600);
-    port.set_option(baud_rate1);
-    serial_port_base::baud_rate baud_rate2;
-    port.get_option(baud_rate2);
-    (void)static_cast<unsigned int>(baud_rate2.value());
-
-    // flow_control class.
-
-    serial_port_base::flow_control flow_control1(
-      serial_port_base::flow_control::none);
-    port.set_option(flow_control1);
-    serial_port_base::flow_control flow_control2;
-    port.get_option(flow_control2);
-    (void)static_cast<serial_port_base::flow_control::type>(
-        flow_control2.value());
-
-    // parity class.
-
-    serial_port_base::parity parity1(serial_port_base::parity::none);
-    port.set_option(parity1);
-    serial_port_base::parity parity2;
-    port.get_option(parity2);
-    (void)static_cast<serial_port_base::parity::type>(parity2.value());
-
-    // stop_bits class.
-
-    serial_port_base::stop_bits stop_bits1(serial_port_base::stop_bits::one);
-    port.set_option(stop_bits1);
-    serial_port_base::stop_bits stop_bits2;
-    port.get_option(stop_bits2);
-    (void)static_cast<serial_port_base::stop_bits::type>(stop_bits2.value());
-
-    // character_size class.
-
-    serial_port_base::character_size character_size1(8);
-    port.set_option(character_size1);
-    serial_port_base::character_size character_size2;
-    port.get_option(character_size2);
-    (void)static_cast<unsigned int>(character_size2.value());
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-}
-
-} // namespace serial_port_base_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "serial_port_base",
-  ASIO_COMPILE_TEST_CASE(serial_port_base_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set.cpp
deleted file mode 100644
index 962be8b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// signal_set.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/signal_set.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// signal_set_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// signal_set compile and link correctly. Runtime failures are ignored.
-
-namespace signal_set_compile {
-
-void signal_handler(const asio::error_code&, int)
-{
-}
-
-void test()
-{
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_signal_set constructors.
-
-    signal_set set1(ioc);
-    signal_set set2(ioc, 1);
-    signal_set set3(ioc, 1, 2);
-    signal_set set4(ioc, 1, 2, 3);
-
-    signal_set set5(ioc_ex);
-    signal_set set6(ioc_ex, 1);
-    signal_set set7(ioc_ex, 1, 2);
-    signal_set set8(ioc_ex, 1, 2, 3);
-
-    // basic_io_object functions.
-
-    signal_set::executor_type ex = set1.get_executor();
-    (void)ex;
-
-    // basic_signal_set functions.
-
-    set1.add(1);
-    set1.add(1, ec);
-
-    set1.add(1, signal_set::flags::dont_care);
-    set1.add(1, signal_set::flags::dont_care, ec);
-
-    set1.remove(1);
-    set1.remove(1, ec);
-
-    set1.clear();
-    set1.clear(ec);
-
-    set1.cancel();
-    set1.cancel(ec);
-
-    set1.async_wait(&signal_handler);
-    int i = set1.async_wait(lazy);
-    (void)i;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace signal_set_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "signal_set",
-  ASIO_COMPILE_TEST_CASE(signal_set_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set_base.cpp
deleted file mode 100644
index 7f27e8c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/signal_set_base.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// signal_set_base.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/signal_set_base.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "signal_set_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/socket_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/socket_base.cpp
deleted file mode 100644
index 21f63ab..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/socket_base.cpp
+++ /dev/null
@@ -1,650 +0,0 @@
-//
-// socket_base.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/socket_base.hpp"
-
-#include "asio/io_context.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// socket_base_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all nested classes, enums and constants in
-// socket_base compile and link correctly. Runtime failures are ignored.
-
-namespace socket_base_compile {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    ip::tcp::socket sock(ioc);
-    char buf[1024];
-
-    // shutdown_type enumeration.
-
-    sock.shutdown(socket_base::shutdown_receive);
-    sock.shutdown(socket_base::shutdown_send);
-    sock.shutdown(socket_base::shutdown_both);
-
-    // message_flags constants.
-
-    sock.receive(buffer(buf), socket_base::message_peek);
-    sock.receive(buffer(buf), socket_base::message_out_of_band);
-    sock.send(buffer(buf), socket_base::message_do_not_route);
-
-    // broadcast class.
-
-    socket_base::broadcast broadcast1(true);
-    sock.set_option(broadcast1);
-    socket_base::broadcast broadcast2;
-    sock.get_option(broadcast2);
-    broadcast1 = true;
-    (void)static_cast<bool>(broadcast1);
-    (void)static_cast<bool>(!broadcast1);
-    (void)static_cast<bool>(broadcast1.value());
-
-    // debug class.
-
-    socket_base::debug debug1(true);
-    sock.set_option(debug1);
-    socket_base::debug debug2;
-    sock.get_option(debug2);
-    debug1 = true;
-    (void)static_cast<bool>(debug1);
-    (void)static_cast<bool>(!debug1);
-    (void)static_cast<bool>(debug1.value());
-
-    // do_not_route class.
-
-    socket_base::do_not_route do_not_route1(true);
-    sock.set_option(do_not_route1);
-    socket_base::do_not_route do_not_route2;
-    sock.get_option(do_not_route2);
-    do_not_route1 = true;
-    (void)static_cast<bool>(do_not_route1);
-    (void)static_cast<bool>(!do_not_route1);
-    (void)static_cast<bool>(do_not_route1.value());
-
-    // keep_alive class.
-
-    socket_base::keep_alive keep_alive1(true);
-    sock.set_option(keep_alive1);
-    socket_base::keep_alive keep_alive2;
-    sock.get_option(keep_alive2);
-    keep_alive1 = true;
-    (void)static_cast<bool>(keep_alive1);
-    (void)static_cast<bool>(!keep_alive1);
-    (void)static_cast<bool>(keep_alive1.value());
-
-    // send_buffer_size class.
-
-    socket_base::send_buffer_size send_buffer_size1(1024);
-    sock.set_option(send_buffer_size1);
-    socket_base::send_buffer_size send_buffer_size2;
-    sock.get_option(send_buffer_size2);
-    send_buffer_size1 = 1;
-    (void)static_cast<int>(send_buffer_size1.value());
-
-    // send_low_watermark class.
-
-    socket_base::send_low_watermark send_low_watermark1(128);
-    sock.set_option(send_low_watermark1);
-    socket_base::send_low_watermark send_low_watermark2;
-    sock.get_option(send_low_watermark2);
-    send_low_watermark1 = 1;
-    (void)static_cast<int>(send_low_watermark1.value());
-
-    // receive_buffer_size class.
-
-    socket_base::receive_buffer_size receive_buffer_size1(1024);
-    sock.set_option(receive_buffer_size1);
-    socket_base::receive_buffer_size receive_buffer_size2;
-    sock.get_option(receive_buffer_size2);
-    receive_buffer_size1 = 1;
-    (void)static_cast<int>(receive_buffer_size1.value());
-
-    // receive_low_watermark class.
-
-    socket_base::receive_low_watermark receive_low_watermark1(128);
-    sock.set_option(receive_low_watermark1);
-    socket_base::receive_low_watermark receive_low_watermark2;
-    sock.get_option(receive_low_watermark2);
-    receive_low_watermark1 = 1;
-    (void)static_cast<int>(receive_low_watermark1.value());
-
-    // reuse_address class.
-
-    socket_base::reuse_address reuse_address1(true);
-    sock.set_option(reuse_address1);
-    socket_base::reuse_address reuse_address2;
-    sock.get_option(reuse_address2);
-    reuse_address1 = true;
-    (void)static_cast<bool>(reuse_address1);
-    (void)static_cast<bool>(!reuse_address1);
-    (void)static_cast<bool>(reuse_address1.value());
-
-    // linger class.
-
-    socket_base::linger linger1(true, 30);
-    sock.set_option(linger1);
-    socket_base::linger linger2;
-    sock.get_option(linger2);
-    linger1.enabled(true);
-    (void)static_cast<bool>(linger1.enabled());
-    linger1.timeout(1);
-    (void)static_cast<int>(linger1.timeout());
-
-    // out_of_band_inline class.
-
-    socket_base::out_of_band_inline out_of_band_inline1(true);
-    sock.set_option(out_of_band_inline1);
-    socket_base::out_of_band_inline out_of_band_inline2;
-    sock.get_option(out_of_band_inline2);
-    out_of_band_inline1 = true;
-    (void)static_cast<bool>(out_of_band_inline1);
-    (void)static_cast<bool>(!out_of_band_inline1);
-    (void)static_cast<bool>(out_of_band_inline1.value());
-
-    // enable_connection_aborted class.
-
-    socket_base::enable_connection_aborted enable_connection_aborted1(true);
-    sock.set_option(enable_connection_aborted1);
-    socket_base::enable_connection_aborted enable_connection_aborted2;
-    sock.get_option(enable_connection_aborted2);
-    enable_connection_aborted1 = true;
-    (void)static_cast<bool>(enable_connection_aborted1);
-    (void)static_cast<bool>(!enable_connection_aborted1);
-    (void)static_cast<bool>(enable_connection_aborted1.value());
-
-    // bytes_readable class.
-
-    socket_base::bytes_readable bytes_readable;
-    sock.io_control(bytes_readable);
-    std::size_t bytes = bytes_readable.get();
-    (void)bytes;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace socket_base_compile
-
-//------------------------------------------------------------------------------
-
-// socket_base_runtime test
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks the runtime operation of the socket options and I/O
-// control commands defined in socket_base.
-
-namespace socket_base_runtime {
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  io_context ioc;
-  ip::udp::socket udp_sock(ioc, ip::udp::v4());
-  ip::tcp::socket tcp_sock(ioc, ip::tcp::v4());
-  ip::tcp::acceptor tcp_acceptor(ioc, ip::tcp::v4());
-  asio::error_code ec;
-
-  // broadcast class.
-
-  socket_base::broadcast broadcast1(true);
-  ASIO_CHECK(broadcast1.value());
-  ASIO_CHECK(static_cast<bool>(broadcast1));
-  ASIO_CHECK(!!broadcast1);
-  udp_sock.set_option(broadcast1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::broadcast broadcast2;
-  udp_sock.get_option(broadcast2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(broadcast2.value());
-  ASIO_CHECK(static_cast<bool>(broadcast2));
-  ASIO_CHECK(!!broadcast2);
-
-  socket_base::broadcast broadcast3(false);
-  ASIO_CHECK(!broadcast3.value());
-  ASIO_CHECK(!static_cast<bool>(broadcast3));
-  ASIO_CHECK(!broadcast3);
-  udp_sock.set_option(broadcast3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::broadcast broadcast4;
-  udp_sock.get_option(broadcast4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!broadcast4.value());
-  ASIO_CHECK(!static_cast<bool>(broadcast4));
-  ASIO_CHECK(!broadcast4);
-
-  // debug class.
-
-  socket_base::debug debug1(true);
-  ASIO_CHECK(debug1.value());
-  ASIO_CHECK(static_cast<bool>(debug1));
-  ASIO_CHECK(!!debug1);
-  udp_sock.set_option(debug1, ec);
-#if defined(__linux__)
-  // On Linux, only root can set SO_DEBUG.
-  bool not_root = (ec == asio::error::access_denied);
-  ASIO_CHECK(!ec || not_root);
-  ASIO_WARN_MESSAGE(!ec, "Must be root to set debug socket option");
-#else // defined(__linux__)
-# if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-# else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-# endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-#endif // defined(__linux__)
-
-  socket_base::debug debug2;
-  udp_sock.get_option(debug2, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-# if defined(__linux__)
-  ASIO_CHECK(debug2.value() || not_root);
-  ASIO_CHECK(static_cast<bool>(debug2) || not_root);
-  ASIO_CHECK(!!debug2 || not_root);
-# else // defined(__linux__)
-  ASIO_CHECK(debug2.value());
-  ASIO_CHECK(static_cast<bool>(debug2));
-  ASIO_CHECK(!!debug2);
-# endif // defined(__linux__)
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::debug debug3(false);
-  ASIO_CHECK(!debug3.value());
-  ASIO_CHECK(!static_cast<bool>(debug3));
-  ASIO_CHECK(!debug3);
-  udp_sock.set_option(debug3, ec);
-#if defined(__linux__)
-  ASIO_CHECK(!ec || not_root);
-#else // defined(__linux__)
-# if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-# else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-# endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-#endif // defined(__linux__)
-
-  socket_base::debug debug4;
-  udp_sock.get_option(debug4, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-# if defined(__linux__)
-  ASIO_CHECK(!debug4.value() || not_root);
-  ASIO_CHECK(!static_cast<bool>(debug4) || not_root);
-  ASIO_CHECK(!debug4 || not_root);
-# else // defined(__linux__)
-  ASIO_CHECK(!debug4.value());
-  ASIO_CHECK(!static_cast<bool>(debug4));
-  ASIO_CHECK(!debug4);
-# endif // defined(__linux__)
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  // do_not_route class.
-
-  socket_base::do_not_route do_not_route1(true);
-  ASIO_CHECK(do_not_route1.value());
-  ASIO_CHECK(static_cast<bool>(do_not_route1));
-  ASIO_CHECK(!!do_not_route1);
-  udp_sock.set_option(do_not_route1, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::do_not_route do_not_route2;
-  udp_sock.get_option(do_not_route2, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(do_not_route2.value());
-  ASIO_CHECK(static_cast<bool>(do_not_route2));
-  ASIO_CHECK(!!do_not_route2);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::do_not_route do_not_route3(false);
-  ASIO_CHECK(!do_not_route3.value());
-  ASIO_CHECK(!static_cast<bool>(do_not_route3));
-  ASIO_CHECK(!do_not_route3);
-  udp_sock.set_option(do_not_route3, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::do_not_route do_not_route4;
-  udp_sock.get_option(do_not_route4, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!do_not_route4.value());
-  ASIO_CHECK(!static_cast<bool>(do_not_route4));
-  ASIO_CHECK(!do_not_route4);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  // keep_alive class.
-
-  socket_base::keep_alive keep_alive1(true);
-  ASIO_CHECK(keep_alive1.value());
-  ASIO_CHECK(static_cast<bool>(keep_alive1));
-  ASIO_CHECK(!!keep_alive1);
-  tcp_sock.set_option(keep_alive1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::keep_alive keep_alive2;
-  tcp_sock.get_option(keep_alive2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(keep_alive2.value());
-  ASIO_CHECK(static_cast<bool>(keep_alive2));
-  ASIO_CHECK(!!keep_alive2);
-
-  socket_base::keep_alive keep_alive3(false);
-  ASIO_CHECK(!keep_alive3.value());
-  ASIO_CHECK(!static_cast<bool>(keep_alive3));
-  ASIO_CHECK(!keep_alive3);
-  tcp_sock.set_option(keep_alive3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::keep_alive keep_alive4;
-  tcp_sock.get_option(keep_alive4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!keep_alive4.value());
-  ASIO_CHECK(!static_cast<bool>(keep_alive4));
-  ASIO_CHECK(!keep_alive4);
-
-  // send_buffer_size class.
-
-  socket_base::send_buffer_size send_buffer_size1(4096);
-  ASIO_CHECK(send_buffer_size1.value() == 4096);
-  tcp_sock.set_option(send_buffer_size1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::send_buffer_size send_buffer_size2;
-  tcp_sock.get_option(send_buffer_size2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(send_buffer_size2.value() == 4096);
-
-  socket_base::send_buffer_size send_buffer_size3(16384);
-  ASIO_CHECK(send_buffer_size3.value() == 16384);
-  tcp_sock.set_option(send_buffer_size3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::send_buffer_size send_buffer_size4;
-  tcp_sock.get_option(send_buffer_size4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(send_buffer_size4.value() == 16384);
-
-  // send_low_watermark class.
-
-  socket_base::send_low_watermark send_low_watermark1(4096);
-  ASIO_CHECK(send_low_watermark1.value() == 4096);
-  tcp_sock.set_option(send_low_watermark1, ec);
-#if defined(WIN32) || defined(__linux__) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows, Linux or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif
-
-  socket_base::send_low_watermark send_low_watermark2;
-  tcp_sock.get_option(send_low_watermark2, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#elif defined(__linux__)
-  ASIO_CHECK(!ec); // Not supported on Linux but can get value.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(send_low_watermark2.value() == 4096);
-#endif
-
-  socket_base::send_low_watermark send_low_watermark3(8192);
-  ASIO_CHECK(send_low_watermark3.value() == 8192);
-  tcp_sock.set_option(send_low_watermark3, ec);
-#if defined(WIN32) || defined(__linux__) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows, Linux or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif
-
-  socket_base::send_low_watermark send_low_watermark4;
-  tcp_sock.get_option(send_low_watermark4, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#elif defined(__linux__)
-  ASIO_CHECK(!ec); // Not supported on Linux but can get value.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(send_low_watermark4.value() == 8192);
-#endif
-
-  // receive_buffer_size class.
-
-  socket_base::receive_buffer_size receive_buffer_size1(4096);
-  ASIO_CHECK(receive_buffer_size1.value() == 4096);
-  tcp_sock.set_option(receive_buffer_size1, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::receive_buffer_size receive_buffer_size2;
-  tcp_sock.get_option(receive_buffer_size2, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK(!ec); // Not supported under Windows CE but can get value.
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(receive_buffer_size2.value() == 4096);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::receive_buffer_size receive_buffer_size3(16384);
-  ASIO_CHECK(receive_buffer_size3.value() == 16384);
-  tcp_sock.set_option(receive_buffer_size3, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  // Option is not supported under Windows CE.
-  ASIO_CHECK_MESSAGE(ec == asio::error::no_protocol_option,
-      ec.value() << ", " << ec.message());
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  socket_base::receive_buffer_size receive_buffer_size4;
-  tcp_sock.get_option(receive_buffer_size4, ec);
-#if defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK(!ec); // Not supported under Windows CE but can get value.
-#else // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(receive_buffer_size4.value() == 16384);
-#endif // defined(ASIO_WINDOWS) && defined(UNDER_CE)
-
-  // receive_low_watermark class.
-
-  socket_base::receive_low_watermark receive_low_watermark1(4096);
-  ASIO_CHECK(receive_low_watermark1.value() == 4096);
-  tcp_sock.set_option(receive_low_watermark1, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif
-
-  socket_base::receive_low_watermark receive_low_watermark2;
-  tcp_sock.get_option(receive_low_watermark2, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(receive_low_watermark2.value() == 4096);
-#endif
-
-  socket_base::receive_low_watermark receive_low_watermark3(8192);
-  ASIO_CHECK(receive_low_watermark3.value() == 8192);
-  tcp_sock.set_option(receive_low_watermark3, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-#endif
-
-  socket_base::receive_low_watermark receive_low_watermark4;
-  tcp_sock.get_option(receive_low_watermark4, ec);
-#if defined(WIN32) || defined(__sun)
-  ASIO_CHECK(!!ec); // Not supported on Windows or Solaris.
-#else
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(receive_low_watermark4.value() == 8192);
-#endif
-
-  // reuse_address class.
-
-  socket_base::reuse_address reuse_address1(true);
-  ASIO_CHECK(reuse_address1.value());
-  ASIO_CHECK(static_cast<bool>(reuse_address1));
-  ASIO_CHECK(!!reuse_address1);
-  udp_sock.set_option(reuse_address1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::reuse_address reuse_address2;
-  udp_sock.get_option(reuse_address2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(reuse_address2.value());
-  ASIO_CHECK(static_cast<bool>(reuse_address2));
-  ASIO_CHECK(!!reuse_address2);
-
-  socket_base::reuse_address reuse_address3(false);
-  ASIO_CHECK(!reuse_address3.value());
-  ASIO_CHECK(!static_cast<bool>(reuse_address3));
-  ASIO_CHECK(!reuse_address3);
-  udp_sock.set_option(reuse_address3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::reuse_address reuse_address4;
-  udp_sock.get_option(reuse_address4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!reuse_address4.value());
-  ASIO_CHECK(!static_cast<bool>(reuse_address4));
-  ASIO_CHECK(!reuse_address4);
-
-  // linger class.
-
-  socket_base::linger linger1(true, 60);
-  ASIO_CHECK(linger1.enabled());
-  ASIO_CHECK(linger1.timeout() == 60);
-  tcp_sock.set_option(linger1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::linger linger2;
-  tcp_sock.get_option(linger2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(linger2.enabled());
-  ASIO_CHECK(linger2.timeout() == 60);
-
-  socket_base::linger linger3(false, 0);
-  ASIO_CHECK(!linger3.enabled());
-  ASIO_CHECK(linger3.timeout() == 0);
-  tcp_sock.set_option(linger3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::linger linger4;
-  tcp_sock.get_option(linger4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!linger4.enabled());
-
-  // enable_connection_aborted class.
-
-  socket_base::enable_connection_aborted enable_connection_aborted1(true);
-  ASIO_CHECK(enable_connection_aborted1.value());
-  ASIO_CHECK(static_cast<bool>(enable_connection_aborted1));
-  ASIO_CHECK(!!enable_connection_aborted1);
-  tcp_acceptor.set_option(enable_connection_aborted1, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::enable_connection_aborted enable_connection_aborted2;
-  tcp_acceptor.get_option(enable_connection_aborted2, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(enable_connection_aborted2.value());
-  ASIO_CHECK(static_cast<bool>(enable_connection_aborted2));
-  ASIO_CHECK(!!enable_connection_aborted2);
-
-  socket_base::enable_connection_aborted enable_connection_aborted3(false);
-  ASIO_CHECK(!enable_connection_aborted3.value());
-  ASIO_CHECK(!static_cast<bool>(enable_connection_aborted3));
-  ASIO_CHECK(!enable_connection_aborted3);
-  tcp_acceptor.set_option(enable_connection_aborted3, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-
-  socket_base::enable_connection_aborted enable_connection_aborted4;
-  tcp_acceptor.get_option(enable_connection_aborted4, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-  ASIO_CHECK(!enable_connection_aborted4.value());
-  ASIO_CHECK(!static_cast<bool>(enable_connection_aborted4));
-  ASIO_CHECK(!enable_connection_aborted4);
-
-  // bytes_readable class.
-
-  socket_base::bytes_readable bytes_readable;
-  udp_sock.io_control(bytes_readable, ec);
-  ASIO_CHECK_MESSAGE(!ec, ec.value() << ", " << ec.message());
-}
-
-} // namespace socket_base_runtime
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "socket_base",
-  ASIO_COMPILE_TEST_CASE(socket_base_compile::test)
-  ASIO_TEST_CASE(socket_base_runtime::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/.gitignore
deleted file mode 100644
index 33e5f53..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/.gitignore
+++ /dev/null
@@ -1,15 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-context
-context_base
-host_name_verification
-rfc2818_verification
-stream
-stream_base
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context.cpp
deleted file mode 100644
index 621bf11..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// context.cpp
-// ~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/context.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/context",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context_base.cpp
deleted file mode 100644
index 9ddddad..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/context_base.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// context_base.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/context_base.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/context_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/error.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/error.cpp
deleted file mode 100644
index 633d7b6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/error.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// error.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/error.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/error",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/host_name_verification.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/host_name_verification.cpp
deleted file mode 100644
index 7126e4b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/host_name_verification.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// host_name_verification.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/host_name_verification.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/host_name_verification",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/rfc2818_verification.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/rfc2818_verification.cpp
deleted file mode 100644
index adcfa95..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/rfc2818_verification.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// rfc2818_verification.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/rfc2818_verification.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/rfc2818_verification",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream.cpp
deleted file mode 100644
index 4671151..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-//
-// stream.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/stream.hpp"
-
-#include "asio.hpp"
-#include "asio/ssl.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// ssl_stream_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// ssl::stream::socket compile and link correctly. Runtime failures are ignored.
-
-namespace ssl_stream_compile {
-
-bool verify_callback(bool, asio::ssl::verify_context&)
-{
-  return false;
-}
-
-void handshake_handler(const asio::error_code&)
-{
-}
-
-void buffered_handshake_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void shutdown_handler(const asio::error_code&)
-{
-}
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-  using namespace asio;
-  namespace ip = asio::ip;
-
-  try
-  {
-    io_context ioc;
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    asio::ssl::context context(asio::ssl::context::sslv23);
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // ssl::stream constructors.
-
-    ssl::stream<ip::tcp::socket> stream1(ioc, context);
-    ip::tcp::socket socket1(ioc, ip::tcp::v4());
-    ssl::stream<ip::tcp::socket&> stream2(socket1, context);
-
-    ssl::stream<ip::tcp::socket> stream3
-      = ssl::stream<ip::tcp::socket>(ioc, context);
-    ssl::stream<ip::tcp::socket> stream4(std::move(stream3));
-
-    // ssl::stream assignment.
-
-    stream3 = std::move(stream4);
-
-    // basic_io_object functions.
-
-    ssl::stream<ip::tcp::socket>::executor_type ex = stream1.get_executor();
-    (void)ex;
-
-    // ssl::stream functions.
-
-    SSL* ssl1 = stream1.native_handle();
-    (void)ssl1;
-
-    ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer
-      = stream1.lowest_layer();
-    (void)lowest_layer;
-
-    const ssl::stream<ip::tcp::socket>& stream5 = stream1;
-    const ssl::stream<ip::tcp::socket>::lowest_layer_type& lowest_layer2
-      = stream5.lowest_layer();
-    (void)lowest_layer2;
-
-    stream1.set_verify_mode(ssl::verify_none);
-    stream1.set_verify_mode(ssl::verify_none, ec);
-
-    stream1.set_verify_depth(1);
-    stream1.set_verify_depth(1, ec);
-
-    stream1.set_verify_callback(verify_callback);
-    stream1.set_verify_callback(verify_callback, ec);
-
-    stream1.handshake(ssl::stream_base::client);
-    stream1.handshake(ssl::stream_base::server);
-    stream1.handshake(ssl::stream_base::client, ec);
-    stream1.handshake(ssl::stream_base::server, ec);
-
-    stream1.handshake(ssl::stream_base::client, buffer(mutable_char_buffer));
-    stream1.handshake(ssl::stream_base::server, buffer(mutable_char_buffer));
-    stream1.handshake(ssl::stream_base::client, buffer(const_char_buffer));
-    stream1.handshake(ssl::stream_base::server, buffer(const_char_buffer));
-    stream1.handshake(ssl::stream_base::client,
-        buffer(mutable_char_buffer), ec);
-    stream1.handshake(ssl::stream_base::server,
-        buffer(mutable_char_buffer), ec);
-    stream1.handshake(ssl::stream_base::client,
-        buffer(const_char_buffer), ec);
-    stream1.handshake(ssl::stream_base::server,
-        buffer(const_char_buffer), ec);
-
-    stream1.async_handshake(ssl::stream_base::client, handshake_handler);
-    stream1.async_handshake(ssl::stream_base::server, handshake_handler);
-    int i1 = stream1.async_handshake(ssl::stream_base::client, lazy);
-    (void)i1;
-    int i2 = stream1.async_handshake(ssl::stream_base::server, lazy);
-    (void)i2;
-
-    stream1.async_handshake(ssl::stream_base::client,
-        buffer(mutable_char_buffer), buffered_handshake_handler);
-    stream1.async_handshake(ssl::stream_base::server,
-        buffer(mutable_char_buffer), buffered_handshake_handler);
-    stream1.async_handshake(ssl::stream_base::client,
-        buffer(const_char_buffer), buffered_handshake_handler);
-    stream1.async_handshake(ssl::stream_base::server,
-        buffer(const_char_buffer), buffered_handshake_handler);
-    int i3 = stream1.async_handshake(ssl::stream_base::client,
-        buffer(mutable_char_buffer), lazy);
-    (void)i3;
-    int i4 = stream1.async_handshake(ssl::stream_base::server,
-        buffer(mutable_char_buffer), lazy);
-    (void)i4;
-    int i5 = stream1.async_handshake(ssl::stream_base::client,
-        buffer(const_char_buffer), lazy);
-    (void)i5;
-    int i6 = stream1.async_handshake(ssl::stream_base::server,
-        buffer(const_char_buffer), lazy);
-    (void)i6;
-
-    stream1.shutdown();
-    stream1.shutdown(ec);
-
-    stream1.async_shutdown(shutdown_handler);
-    int i7 = stream1.async_shutdown(lazy);
-    (void)i7;
-
-    stream1.write_some(buffer(mutable_char_buffer));
-    stream1.write_some(buffer(const_char_buffer));
-    stream1.write_some(buffer(mutable_char_buffer), ec);
-    stream1.write_some(buffer(const_char_buffer), ec);
-
-    stream1.async_write_some(buffer(mutable_char_buffer), write_some_handler);
-    stream1.async_write_some(buffer(const_char_buffer), write_some_handler);
-    int i8 = stream1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i8;
-    int i9 = stream1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i9;
-
-    stream1.read_some(buffer(mutable_char_buffer));
-    stream1.read_some(buffer(mutable_char_buffer), ec);
-
-    stream1.async_read_some(buffer(mutable_char_buffer), read_some_handler);
-    int i10 = stream1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i10;
-  }
-  catch (std::exception&)
-  {
-  }
-}
-
-} // namespace ssl_stream_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "ssl/stream",
-  ASIO_COMPILE_TEST_CASE(ssl_stream_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream_base.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream_base.cpp
deleted file mode 100644
index 7e6a1e6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ssl/stream_base.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// stream_base.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/ssl/stream_base.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ssl/stream_base",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/static_thread_pool.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/static_thread_pool.cpp
deleted file mode 100644
index b9b050b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/static_thread_pool.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// static_thread_pool.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/static_thread_pool.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "static_thread_pool",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/steady_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/steady_timer.cpp
deleted file mode 100644
index fe2c041..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/steady_timer.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// steady_timer.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/steady_timer.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "steady_timer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/strand.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/strand.cpp
deleted file mode 100644
index 90ae2bc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/strand.cpp
+++ /dev/null
@@ -1,458 +0,0 @@
-//
-// strand.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/strand.hpp"
-
-#include <functional>
-#include <sstream>
-#include "asio/executor.hpp"
-#include "asio/io_context.hpp"
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "asio/thread.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/deadline_timer.hpp"
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-# include "asio/steady_timer.hpp"
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-using namespace asio;
-namespace bindns = std;
-
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef deadline_timer timer;
-namespace chronons = boost::posix_time;
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-typedef steady_timer timer;
-namespace chronons = asio::chrono;
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void increment_without_lock(strand<io_context::executor_type>* s, int* count)
-{
-  ASIO_CHECK(!s->running_in_this_thread());
-
-  int original_count = *count;
-
-  dispatch(*s, bindns::bind(increment, count));
-
-  // No other functions are currently executing through the locking dispatcher,
-  // so the previous call to dispatch should have successfully nested.
-  ASIO_CHECK(*count == original_count + 1);
-}
-
-void increment_with_lock(strand<io_context::executor_type>* s, int* count)
-{
-  ASIO_CHECK(s->running_in_this_thread());
-
-  int original_count = *count;
-
-  dispatch(*s, bindns::bind(increment, count));
-
-  // The current function already holds the strand's lock, so the
-  // previous call to dispatch should have successfully nested.
-  ASIO_CHECK(*count == original_count + 1);
-}
-
-void sleep_increment(io_context* ioc, int* count)
-{
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  ++(*count);
-}
-
-void increment_by_a(int* count, int a)
-{
-  (*count) += a;
-}
-
-void increment_by_a_b(int* count, int a, int b)
-{
-  (*count) += a + b;
-}
-
-void increment_by_a_b_c(int* count, int a, int b, int c)
-{
-  (*count) += a + b + c;
-}
-
-void increment_by_a_b_c_d(int* count, int a, int b, int c, int d)
-{
-  (*count) += a + b + c + d;
-}
-
-void start_sleep_increments(io_context* ioc,
-    strand<io_context::executor_type>* s, int* count)
-{
-  // Give all threads a chance to start.
-  timer t(*ioc, chronons::seconds(2));
-  t.wait();
-
-  // Start three increments.
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-  post(*s, bindns::bind(sleep_increment, ioc, count));
-}
-
-void throw_exception()
-{
-  throw 1;
-}
-
-void io_context_run(io_context* ioc)
-{
-  ioc->run();
-}
-
-void strand_test()
-{
-  io_context ioc;
-  strand<io_context::executor_type> s = make_strand(ioc);
-  int count = 0;
-
-  post(ioc, bindns::bind(increment_without_lock, &s, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  post(s, bindns::bind(increment_with_lock, &s, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  post(ioc, bindns::bind(start_sleep_increments, &ioc, &s, &count));
-  thread thread1(bindns::bind(io_context_run, &ioc));
-  thread thread2(bindns::bind(io_context_run, &ioc));
-
-  // Check all events run one after another even though there are two threads.
-  timer timer1(ioc, chronons::seconds(3));
-  timer1.wait();
-  ASIO_CHECK(count == 0);
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expiry() + chronons::seconds(2));
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.wait();
-  ASIO_CHECK(count == 1);
-#if defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expires_at() + chronons::seconds(2));
-#else // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.expires_at(timer1.expiry() + chronons::seconds(2));
-#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
-  timer1.wait();
-  ASIO_CHECK(count == 2);
-
-  thread1.join();
-  thread2.join();
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 3);
-
-  count = 0;
-  int exception_count = 0;
-  ioc.restart();
-  post(s, throw_exception);
-  post(s, bindns::bind(increment, &count));
-  post(s, bindns::bind(increment, &count));
-  post(s, throw_exception);
-  post(s, bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(exception_count == 0);
-
-  for (;;)
-  {
-    try
-    {
-      ioc.run();
-      break;
-    }
-    catch (int)
-    {
-      ++exception_count;
-    }
-  }
-
-  // The run() calls will not return until all work has finished.
-  ASIO_CHECK(count == 3);
-  ASIO_CHECK(exception_count == 2);
-
-  count = 0;
-  ioc.restart();
-
-  // Check for clean shutdown when handlers posted through an orphaned strand
-  // are abandoned.
-  {
-    strand<io_context::executor_type> s2 = make_strand(ioc.get_executor());
-    post(s2, bindns::bind(increment, &count));
-    post(s2, bindns::bind(increment, &count));
-    post(s2, bindns::bind(increment, &count));
-  }
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(count == 0);
-}
-
-void strand_conversion_test()
-{
-  io_context ioc;
-  strand<io_context::executor_type> s1 = make_strand(ioc);
-
-  // Converting constructors.
-
-  strand<executor> s2(s1);
-  strand<executor> s3 = strand<io_context::executor_type>(s1);
-
-  // Converting assignment.
-
-  s3 = s1;
-  s3 = strand<io_context::executor_type>(s1);
-}
-
-void strand_query_test()
-{
-  io_context ioc;
-  strand<io_context::executor_type> s1 = make_strand(ioc);
-
-  ASIO_CHECK(
-      &asio::query(s1, asio::execution::context)
-        == &ioc);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::blocking)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::blocking.possibly)
-        == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::outstanding_work)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::outstanding_work.untracked)
-        == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::relationship)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::relationship.fork)
-        == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::mapping)
-        == asio::execution::mapping.thread);
-
-  ASIO_CHECK(
-      asio::query(s1, asio::execution::allocator)
-        == std::allocator<void>());
-}
-
-void strand_execute_test()
-{
-  io_context ioc;
-  strand<io_context::executor_type> s1 = make_strand(ioc);
-  int count = 0;
-
-  s1.execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(s1, asio::execution::blocking.possibly).execute(
-      bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(s1, asio::execution::blocking.never).execute(
-      bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  ASIO_CHECK(!ioc.stopped());
-
-  asio::require(s1,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.tracked
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(s1,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(s1,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.fork
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::require(s1,
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::prefer(
-      asio::require(s1,
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator(std::allocator<void>())
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-
-  count = 0;
-  ioc.restart();
-  asio::prefer(
-      asio::require(s1,
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator
-    ).execute(bindns::bind(increment, &count));
-
-  // No handlers can be called until run() is called.
-  ASIO_CHECK(!ioc.stopped());
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all work has finished.
-  ASIO_CHECK(ioc.stopped());
-  ASIO_CHECK(count == 1);
-}
-
-ASIO_TEST_SUITE
-(
-  "strand",
-  ASIO_TEST_CASE(strand_test)
-  ASIO_COMPILE_TEST_CASE(strand_conversion_test)
-  ASIO_TEST_CASE(strand_query_test)
-  ASIO_TEST_CASE(strand_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/stream_file.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/stream_file.cpp
deleted file mode 100644
index a441675..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/stream_file.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-//
-// stream_file.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/stream_file.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-// stream_file_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// stream_file compile and link correctly. Runtime failures are ignored.
-
-namespace stream_file_compile {
-
-struct write_some_handler
-{
-  write_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_handler(write_some_handler&&) {}
-private:
-  write_some_handler(const write_some_handler&);
-};
-
-struct read_some_handler
-{
-  read_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_handler(read_some_handler&&) {}
-private:
-  read_some_handler(const read_some_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_FILE)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-    const std::string path;
-
-    // basic_stream_file constructors.
-
-    stream_file file1(ioc);
-    stream_file file2(ioc, "", stream_file::read_only);
-    stream_file file3(ioc, path, stream_file::read_only);
-    stream_file::native_handle_type native_file1 = file1.native_handle();
-    stream_file file4(ioc, native_file1);
-
-    stream_file file5(ioc_ex);
-    stream_file file6(ioc_ex, "", stream_file::read_only);
-    stream_file file7(ioc_ex, path, stream_file::read_only);
-    stream_file::native_handle_type native_file2 = file1.native_handle();
-    stream_file file8(ioc_ex, native_file2);
-
-    stream_file file9(std::move(file8));
-
-    basic_stream_file<io_context::executor_type> file10(ioc);
-    stream_file file11(std::move(file10));
-
-    // basic_stream_file operators.
-
-    file1 = stream_file(ioc);
-    file1 = std::move(file2);
-    file1 = std::move(file10);
-
-    // basic_io_object functions.
-
-    stream_file::executor_type ex = file1.get_executor();
-    (void)ex;
-
-    // basic_stream_file functions.
-
-    file1.open("", stream_file::read_only);
-    file1.open("", stream_file::read_only, ec);
-
-    file1.open(path, stream_file::read_only);
-    file1.open(path, stream_file::read_only, ec);
-
-    stream_file::native_handle_type native_file3 = file1.native_handle();
-    file1.assign(native_file3);
-    stream_file::native_handle_type native_file4 = file1.native_handle();
-    file1.assign(native_file4, ec);
-
-    bool is_open = file1.is_open();
-    (void)is_open;
-
-    file1.close();
-    file1.close(ec);
-
-    stream_file::native_handle_type native_file5 = file1.native_handle();
-    (void)native_file5;
-
-    stream_file::native_handle_type native_file6 = file1.release();
-    (void)native_file6;
-    stream_file::native_handle_type native_file7 = file1.release(ec);
-    (void)native_file7;
-
-    file1.cancel();
-    file1.cancel(ec);
-
-    asio::uint64_t s1 = file1.size();
-    (void)s1;
-    asio::uint64_t s2 = file1.size(ec);
-    (void)s2;
-
-    file1.resize(asio::uint64_t(0));
-    file1.resize(asio::uint64_t(0), ec);
-
-    file1.sync_all();
-    file1.sync_all(ec);
-
-    file1.sync_data();
-    file1.sync_data(ec);
-
-    asio::uint64_t s3 = file1.seek(0, stream_file::seek_set);
-    (void)s3;
-    asio::uint64_t s4 = file1.seek(0, stream_file::seek_set, ec);
-    (void)s4;
-
-    file1.write_some(buffer(mutable_char_buffer));
-    file1.write_some(buffer(const_char_buffer));
-    file1.write_some(buffer(mutable_char_buffer), ec);
-    file1.write_some(buffer(const_char_buffer), ec);
-
-    file1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
-    file1.async_write_some(buffer(const_char_buffer), write_some_handler());
-    int i1 = file1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = file1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-
-    file1.read_some(buffer(mutable_char_buffer));
-    file1.read_some(buffer(mutable_char_buffer), ec);
-
-    file1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
-    int i3 = file1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_FILE)
-}
-
-} // namespace stream_file_compile
-
-ASIO_TEST_SUITE
-(
-  "stream_file",
-  ASIO_COMPILE_TEST_CASE(stream_file_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/streambuf.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/streambuf.cpp
deleted file mode 100644
index c1c8477..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/streambuf.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// streambuf.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/streambuf.hpp"
-
-#include "asio/buffer.hpp"
-#include "unit_test.hpp"
-
-void streambuf_test()
-{
-  asio::streambuf sb;
-
-  sb.sputn("abcd", 4);
-
-  ASIO_CHECK(sb.size() == 4);
-
-  for (int i = 0; i < 100; ++i)
-  {
-    sb.consume(3);
-
-    ASIO_CHECK(sb.size() == 1);
-
-    char buf[1];
-    sb.sgetn(buf, 1);
-
-    ASIO_CHECK(sb.size() == 0);
-
-    sb.sputn("ab", 2);
-
-    ASIO_CHECK(sb.size() == 2);
-
-    asio::buffer_copy(sb.prepare(10), asio::buffer("cd", 2));
-    sb.commit(2);
-
-    ASIO_CHECK(sb.size() == 4);
-  }
-
-  ASIO_CHECK(sb.size() == 4);
-
-  sb.consume(4);
-
-  ASIO_CHECK(sb.size() == 0);
-}
-
-ASIO_TEST_SUITE
-(
-  "streambuf",
-  ASIO_TEST_CASE(streambuf_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_context.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_context.cpp
deleted file mode 100644
index 297ab6b..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_context.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// system_context.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/system_context.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "system_context",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_executor.cpp
deleted file mode 100644
index 7b811cc..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_executor.cpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//
-// system_executor.cpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/system_executor.hpp"
-
-#include <functional>
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-
-namespace bindns = std;
-
-void increment(asio::detail::atomic_count* count)
-{
-  ++(*count);
-}
-
-void system_executor_query_test()
-{
-  ASIO_CHECK(
-      &asio::query(system_executor(),
-        asio::execution::context)
-      != static_cast<const system_context*>(0));
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::blocking)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::blocking.possibly)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::outstanding_work)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::outstanding_work.untracked)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::relationship)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::relationship.fork)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::mapping)
-      == asio::execution::mapping.thread);
-
-  ASIO_CHECK(
-      asio::query(system_executor(),
-        asio::execution::allocator)
-      == std::allocator<void>());
-}
-
-void system_executor_execute_test()
-{
-  asio::detail::atomic_count count(0);
-
-  system_executor().execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.possibly
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.always
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.fork
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(system_executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(
-      asio::require(system_executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator(std::allocator<void>())
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(
-      asio::require(system_executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator
-    ).execute(bindns::bind(increment, &count));
-
-  asio::query(system_executor(), execution::context).join();
-
-  ASIO_CHECK(count == 9);
-}
-
-ASIO_TEST_SUITE
-(
-  "system_executor",
-  ASIO_TEST_CASE(system_executor_query_test)
-  ASIO_TEST_CASE(system_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_timer.cpp
deleted file mode 100644
index 26a5720..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/system_timer.cpp
+++ /dev/null
@@ -1,500 +0,0 @@
-//
-// system_timer.cpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/system_timer.hpp"
-
-#include <functional>
-#include "asio/bind_cancellation_slot.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/executor_work_guard.hpp"
-#include "asio/io_context.hpp"
-#include "asio/thread.hpp"
-#include "unit_test.hpp"
-
-namespace bindns = std;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void decrement_to_zero(asio::system_timer* t, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    int before_value = *count;
-
-    t->expires_at(t->expiry() + asio::chrono::seconds(1));
-    t->async_wait(bindns::bind(decrement_to_zero, t, count));
-
-    // Completion cannot nest, so count value should remain unchanged.
-    ASIO_CHECK(*count == before_value);
-  }
-}
-
-void increment_if_not_cancelled(int* count,
-    const asio::error_code& ec)
-{
-  if (!ec)
-    ++(*count);
-}
-
-void cancel_timer(asio::system_timer* t)
-{
-  std::size_t num_cancelled = t->cancel();
-  ASIO_CHECK(num_cancelled == 1);
-}
-
-void cancel_one_timer(asio::system_timer* t)
-{
-  std::size_t num_cancelled = t->cancel_one();
-  ASIO_CHECK(num_cancelled == 1);
-}
-
-asio::system_timer::time_point now()
-{
-  return asio::system_timer::clock_type::now();
-}
-
-void system_timer_test()
-{
-  using asio::chrono::seconds;
-  using asio::chrono::microseconds;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  const asio::io_context::executor_type ioc_ex = ioc.get_executor();
-  int count = 0;
-
-  asio::system_timer::time_point start = now();
-
-  asio::system_timer t1(ioc, seconds(1));
-  t1.wait();
-
-  // The timer must block until after its expiry time.
-  asio::system_timer::time_point end = now();
-  asio::system_timer::time_point expected_end = start + seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  asio::system_timer t2(ioc_ex, seconds(1) + microseconds(500000));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end = start + seconds(1) + microseconds(500000);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  t2.expires_at(t2.expiry() + seconds(1));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end += seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  t2.expires_after(seconds(1) + microseconds(200000));
-  t2.wait();
-
-  // The timer must block until after its expiry time.
-  end = now();
-  expected_end = start + seconds(1) + microseconds(200000);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  start = now();
-
-  asio::system_timer t3(ioc, seconds(5));
-  t3.async_wait(bindns::bind(increment, &count));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.run();
-
-  // The run() call will not return until all operations have finished, and
-  // this should not be until after the timer's expiry time.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(1);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 3;
-  start = now();
-
-  asio::system_timer t4(ioc, seconds(1));
-  t4.async_wait(bindns::bind(decrement_to_zero, &t4, &count));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 3);
-
-  ioc.restart();
-  ioc.run();
-
-  // The run() call will not return until all operations have finished, and
-  // this should not be until after the timer's final expiry time.
-  ASIO_CHECK(count == 0);
-  end = now();
-  expected_end = start + seconds(3);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 0;
-  start = now();
-
-  asio::system_timer t5(ioc, seconds(10));
-  t5.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
-  asio::system_timer t6(ioc, seconds(1));
-  t6.async_wait(bindns::bind(cancel_timer, &t5));
-
-  // No completions can be delivered until run() is called.
-  ASIO_CHECK(count == 0);
-
-  ioc.restart();
-  ioc.run();
-
-  // The timer should have been cancelled, so count should not have changed.
-  // The total run time should not have been much more than 1 second (and
-  // certainly far less than 10 seconds).
-  ASIO_CHECK(count == 0);
-  end = now();
-  expected_end = start + seconds(2);
-  ASIO_CHECK(end < expected_end);
-
-  // Wait on the timer again without cancelling it. This time the asynchronous
-  // wait should run to completion and increment the counter.
-  t5.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
-
-  ioc.restart();
-  ioc.run();
-
-  // The timer should not have been cancelled, so count should have changed.
-  // The total time since the timer was created should be more than 10 seconds.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(10);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-
-  count = 0;
-  start = now();
-
-  // Start two waits on a timer, one of which will be cancelled. The one
-  // which is not cancelled should still run to completion and increment the
-  // counter.
-  asio::system_timer t7(ioc, seconds(3));
-  t7.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
-  t7.async_wait(bindns::bind(increment_if_not_cancelled, &count, _1));
-  asio::system_timer t8(ioc, seconds(1));
-  t8.async_wait(bindns::bind(cancel_one_timer, &t7));
-
-  ioc.restart();
-  ioc.run();
-
-  // One of the waits should not have been cancelled, so count should have
-  // changed. The total time since the timer was created should be more than 3
-  // seconds.
-  ASIO_CHECK(count == 1);
-  end = now();
-  expected_end = start + seconds(3);
-  ASIO_CHECK(expected_end < end || expected_end == end);
-}
-
-struct timer_handler
-{
-  timer_handler() {}
-  void operator()(const asio::error_code&) {}
-  timer_handler(timer_handler&&) {}
-private:
-  timer_handler(const timer_handler&);
-};
-
-void system_timer_cancel_test()
-{
-  static asio::io_context io_context;
-  struct timer
-  {
-    asio::system_timer t;
-    timer() : t(io_context)
-    {
-      t.expires_at((asio::system_timer::time_point::max)());
-    }
-  } timers[50];
-
-  timers[2].t.async_wait(timer_handler());
-  timers[41].t.async_wait(timer_handler());
-  for (int i = 10; i < 20; ++i)
-    timers[i].t.async_wait(timer_handler());
-
-  ASIO_CHECK(timers[2].t.cancel() == 1);
-  ASIO_CHECK(timers[41].t.cancel() == 1);
-  for (int i = 10; i < 20; ++i)
-    ASIO_CHECK(timers[i].t.cancel() == 1);
-}
-
-struct custom_allocation_timer_handler
-{
-  custom_allocation_timer_handler(int* count) : count_(count) {}
-  void operator()(const asio::error_code&) {}
-  int* count_;
-
-  template <typename T>
-  struct allocator
-  {
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef T value_type;
-
-    template <typename U>
-    struct rebind
-    {
-      typedef allocator<U> other;
-    };
-
-    explicit allocator(int* count) noexcept
-      : count_(count)
-    {
-    }
-
-    allocator(const allocator& other) noexcept
-      : count_(other.count_)
-    {
-    }
-
-    template <typename U>
-    allocator(const allocator<U>& other) noexcept
-      : count_(other.count_)
-    {
-    }
-
-    pointer allocate(size_type n, const void* = 0)
-    {
-      ++(*count_);
-      return static_cast<T*>(::operator new(sizeof(T) * n));
-    }
-
-    void deallocate(pointer p, size_type)
-    {
-      --(*count_);
-      ::operator delete(p);
-    }
-
-    size_type max_size() const
-    {
-      return ~size_type(0);
-    }
-
-    void construct(pointer p, const T& v)
-    {
-      new (p) T(v);
-    }
-
-    void destroy(pointer p)
-    {
-      p->~T();
-    }
-
-    int* count_;
-  };
-
-  typedef allocator<int> allocator_type;
-
-  allocator_type get_allocator() const noexcept
-  {
-    return allocator_type(count_);
-  }
-};
-
-void system_timer_custom_allocation_test()
-{
-  static asio::io_context io_context;
-  struct timer
-  {
-    asio::system_timer t;
-    timer() : t(io_context) {}
-  } timers[100];
-
-  int allocation_count = 0;
-
-  for (int i = 0; i < 50; ++i)
-  {
-    timers[i].t.expires_at((asio::system_timer::time_point::max)());
-    timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
-  }
-
-  for (int i = 50; i < 100; ++i)
-  {
-    timers[i].t.expires_at((asio::system_timer::time_point::min)());
-    timers[i].t.async_wait(custom_allocation_timer_handler(&allocation_count));
-  }
-
-  for (int i = 0; i < 50; ++i)
-    timers[i].t.cancel();
-
-  io_context.run();
-
-  ASIO_CHECK(allocation_count == 0);
-}
-
-void io_context_run(asio::io_context* ioc)
-{
-  ioc->run();
-}
-
-void system_timer_thread_test()
-{
-  asio::io_context ioc;
-  asio::executor_work_guard<asio::io_context::executor_type> work
-    = asio::make_work_guard(ioc);
-  asio::system_timer t1(ioc);
-  asio::system_timer t2(ioc);
-  int count = 0;
-
-  asio::thread th(bindns::bind(io_context_run, &ioc));
-
-  t2.expires_after(asio::chrono::seconds(2));
-  t2.wait();
-
-  t1.expires_after(asio::chrono::seconds(2));
-  t1.async_wait(bindns::bind(increment, &count));
-
-  t2.expires_after(asio::chrono::seconds(4));
-  t2.wait();
-
-  ioc.stop();
-  th.join();
-
-  ASIO_CHECK(count == 1);
-}
-
-asio::system_timer make_timer(asio::io_context& ioc, int* count)
-{
-  asio::system_timer t(ioc);
-  t.expires_after(asio::chrono::seconds(1));
-  t.async_wait(bindns::bind(increment, count));
-  return t;
-}
-
-typedef asio::basic_waitable_timer<
-    asio::system_timer::clock_type,
-    asio::system_timer::traits_type,
-    asio::io_context::executor_type> io_context_system_timer;
-
-io_context_system_timer make_convertible_timer(asio::io_context& ioc, int* count)
-{
-  io_context_system_timer t(ioc);
-  t.expires_after(asio::chrono::seconds(1));
-  t.async_wait(bindns::bind(increment, count));
-  return t;
-}
-
-void system_timer_move_test()
-{
-  asio::io_context io_context1;
-  asio::io_context io_context2;
-  int count = 0;
-
-  asio::system_timer t1 = make_timer(io_context1, &count);
-  asio::system_timer t2 = make_timer(io_context2, &count);
-  asio::system_timer t3 = std::move(t1);
-
-  t2 = std::move(t1);
-
-  io_context2.run();
-
-  ASIO_CHECK(count == 1);
-
-  io_context1.run();
-
-  ASIO_CHECK(count == 2);
-
-  asio::system_timer t4 = make_convertible_timer(io_context1, &count);
-  asio::system_timer t5 = make_convertible_timer(io_context2, &count);
-  asio::system_timer t6 = std::move(t4);
-
-  t2 = std::move(t4);
-
-  io_context2.restart();
-  io_context2.run();
-
-  ASIO_CHECK(count == 3);
-
-  io_context1.restart();
-  io_context1.run();
-
-  ASIO_CHECK(count == 4);
-}
-
-void system_timer_op_cancel_test()
-{
-  asio::cancellation_signal cancel_signal;
-  asio::io_context ioc;
-  int count = 0;
-
-  asio::system_timer timer(ioc, asio::chrono::seconds(10));
-
-  timer.async_wait(bindns::bind(increment, &count));
-
-  timer.async_wait(
-      asio::bind_cancellation_slot(
-        cancel_signal.slot(),
-        bindns::bind(increment, &count)));
-
-  timer.async_wait(bindns::bind(increment, &count));
-
-  ioc.poll();
-
-  ASIO_CHECK(count == 0);
-  ASIO_CHECK(!ioc.stopped());
-
-  cancel_signal.emit(asio::cancellation_type::all);
-
-  ioc.run_one();
-  ioc.poll();
-
-  ASIO_CHECK(count == 1);
-  ASIO_CHECK(!ioc.stopped());
-
-  timer.cancel();
-
-  ioc.run();
-
-  ASIO_CHECK(count == 3);
-  ASIO_CHECK(ioc.stopped());
-}
-
-ASIO_TEST_SUITE
-(
-  "system_timer",
-  ASIO_TEST_CASE(system_timer_test)
-  ASIO_TEST_CASE(system_timer_cancel_test)
-  ASIO_TEST_CASE(system_timer_custom_allocation_test)
-  ASIO_TEST_CASE(system_timer_thread_test)
-  ASIO_TEST_CASE(system_timer_move_test)
-  ASIO_TEST_CASE(system_timer_op_cancel_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/this_coro.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/this_coro.cpp
deleted file mode 100644
index d1e0fc6..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/this_coro.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// this_coro.cpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/this_coro.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "this_coro",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread.cpp
deleted file mode 100644
index b84db72..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// thread.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/thread.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "thread",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread_pool.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread_pool.cpp
deleted file mode 100644
index f65d796..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/thread_pool.cpp
+++ /dev/null
@@ -1,283 +0,0 @@
-//
-// thread_pool.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/thread_pool.hpp"
-
-#include <functional>
-#include "asio/dispatch.hpp"
-#include "asio/post.hpp"
-#include "unit_test.hpp"
-
-using namespace asio;
-namespace bindns = std;
-
-void increment(int* count)
-{
-  ++(*count);
-}
-
-void decrement_to_zero(thread_pool* pool, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    int before_value = *count;
-    asio::post(*pool, bindns::bind(decrement_to_zero, pool, count));
-
-    // Handler execution cannot nest, so count value should remain unchanged.
-    ASIO_CHECK(*count == before_value);
-  }
-}
-
-void nested_decrement_to_zero(thread_pool* pool, int* count)
-{
-  if (*count > 0)
-  {
-    --(*count);
-
-    asio::dispatch(*pool,
-        bindns::bind(nested_decrement_to_zero, pool, count));
-
-    // Handler execution is nested, so count value should now be zero.
-    ASIO_CHECK(*count == 0);
-  }
-}
-
-void thread_pool_test()
-{
-  thread_pool pool(1);
-
-  int count1 = 0;
-  asio::post(pool, bindns::bind(increment, &count1));
-
-  int count2 = 10;
-  asio::post(pool, bindns::bind(decrement_to_zero, &pool, &count2));
-
-  int count3 = 10;
-  asio::post(pool, bindns::bind(nested_decrement_to_zero, &pool, &count3));
-
-  pool.wait();
-
-  ASIO_CHECK(count1 == 1);
-  ASIO_CHECK(count2 == 0);
-  ASIO_CHECK(count3 == 0);
-}
-
-class test_service : public asio::execution_context::service
-{
-public:
-#if defined(ASIO_NO_TYPEID)
-  static asio::execution_context::id id;
-#endif // defined(ASIO_NO_TYPEID)
-
-  typedef test_service key_type;
-
-  test_service(asio::execution_context& ctx)
-    : asio::execution_context::service(ctx)
-  {
-  }
-
-private:
-  virtual void shutdown() {}
-};
-
-#if defined(ASIO_NO_TYPEID)
-asio::execution_context::id test_service::id;
-#endif // defined(ASIO_NO_TYPEID)
-
-void thread_pool_service_test()
-{
-  asio::thread_pool pool1(1);
-  asio::thread_pool pool2(1);
-  asio::thread_pool pool3(1);
-
-  // Implicit service registration.
-
-  asio::use_service<test_service>(pool1);
-
-  ASIO_CHECK(asio::has_service<test_service>(pool1));
-
-  test_service* svc1 = new test_service(pool1);
-  try
-  {
-    asio::add_service(pool1, svc1);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::service_already_exists&)
-  {
-  }
-  delete svc1;
-
-  // Explicit service registration.
-
-  test_service& svc2 = asio::make_service<test_service>(pool2);
-
-  ASIO_CHECK(asio::has_service<test_service>(pool2));
-  ASIO_CHECK(&asio::use_service<test_service>(pool2) == &svc2);
-
-  test_service* svc3 = new test_service(pool2);
-  try
-  {
-    asio::add_service(pool2, svc3);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::service_already_exists&)
-  {
-  }
-  delete svc3;
-
-  // Explicit registration with invalid owner.
-
-  test_service* svc4 = new test_service(pool2);
-  try
-  {
-    asio::add_service(pool3, svc4);
-    ASIO_ERROR("add_service did not throw");
-  }
-  catch (asio::invalid_service_owner&)
-  {
-  }
-  delete svc4;
-
-  ASIO_CHECK(!asio::has_service<test_service>(pool3));
-}
-
-void thread_pool_executor_query_test()
-{
-  thread_pool pool(1);
-
-  ASIO_CHECK(
-      &asio::query(pool.executor(),
-        asio::execution::context)
-      == &pool);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::blocking)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::blocking.possibly)
-      == asio::execution::blocking.possibly);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::outstanding_work)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::outstanding_work.untracked)
-      == asio::execution::outstanding_work.untracked);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::relationship)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::relationship.fork)
-      == asio::execution::relationship.fork);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::mapping)
-      == asio::execution::mapping.thread);
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::allocator)
-      == std::allocator<void>());
-
-  ASIO_CHECK(
-      asio::query(pool.executor(),
-        asio::execution::occupancy)
-      == 1);
-}
-
-void thread_pool_executor_execute_test()
-{
-  int count = 0;
-  thread_pool pool(1);
-
-  pool.executor().execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.possibly
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.always
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.never
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.tracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.fork
-    ).execute(bindns::bind(increment, &count));
-
-  asio::require(pool.executor(),
-      asio::execution::blocking.never,
-      asio::execution::outstanding_work.untracked,
-      asio::execution::relationship.continuation
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(
-      asio::require(pool.executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator(std::allocator<void>())
-    ).execute(bindns::bind(increment, &count));
-
-  asio::prefer(
-      asio::require(pool.executor(),
-        asio::execution::blocking.never,
-        asio::execution::outstanding_work.untracked,
-        asio::execution::relationship.continuation),
-      asio::execution::allocator
-    ).execute(bindns::bind(increment, &count));
-
-  pool.wait();
-
-  ASIO_CHECK(count == 10);
-}
-
-ASIO_TEST_SUITE
-(
-  "thread_pool",
-  ASIO_TEST_CASE(thread_pool_test)
-  ASIO_TEST_CASE(thread_pool_service_test)
-  ASIO_TEST_CASE(thread_pool_executor_query_test)
-  ASIO_TEST_CASE(thread_pool_executor_execute_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/time_traits.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/time_traits.cpp
deleted file mode 100644
index 2763d9e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/time_traits.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// time_traits.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/time_traits.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "time_traits",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/.gitignore
deleted file mode 100644
index c983d4c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/.gitignore
+++ /dev/null
@@ -1,17 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-buffer
-executor
-internet
-io_context
-net
-netfwd
-socket
-timer
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/buffer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/buffer.cpp
deleted file mode 100644
index 8f09c4f..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/buffer.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// buffer.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/buffer.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/buffer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/executor.cpp
deleted file mode 100644
index 9e318d9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/executor.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// executor.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/executor.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/executor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/internet.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/internet.cpp
deleted file mode 100644
index 1ee8320..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/internet.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// internet.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/internet.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/internet",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/io_context.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/io_context.cpp
deleted file mode 100644
index 365e257..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/io_context.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// io_context.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/io_context.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/io_context",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/net.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/net.cpp
deleted file mode 100644
index 25f6503..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/net.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// net.cpp
-// ~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/net.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/net",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/netfwd.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/netfwd.cpp
deleted file mode 100644
index 55af93c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/netfwd.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// netfwd.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/netfwd.hpp"
-
-// Test that forward declarations don't conflict with full declarations.
-#include "asio/ts/net.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/netfwd",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/socket.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/socket.cpp
deleted file mode 100644
index 4656fa2..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/socket.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// socket.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/socket.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/socket",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/timer.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/timer.cpp
deleted file mode 100644
index e956bd4..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/ts/timer.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// timer.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Prevent link dependency on the Boost.System library.
-#if !defined(BOOST_SYSTEM_NO_DEPRECATED)
-#define BOOST_SYSTEM_NO_DEPRECATED
-#endif // !defined(BOOST_SYSTEM_NO_DEPRECATED)
-
-// Test that header file is self-contained.
-#include "asio/ts/timer.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "ts/timer",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/unit_test.hpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/unit_test.hpp
deleted file mode 100644
index 135edb7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/unit_test.hpp
+++ /dev/null
@@ -1,190 +0,0 @@
-//
-// unit_test.hpp
-// ~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef UNIT_TEST_HPP
-#define UNIT_TEST_HPP
-
-#include "asio/detail/config.hpp"
-#include <iostream>
-#include "asio/detail/atomic_count.hpp"
-
-#if defined(__sun)
-# include <stdlib.h> // Needed for lrand48.
-#endif // defined(__sun)
-
-#if defined(__BORLANDC__) && !defined(__clang__)
-
-// Prevent use of intrinsic for strcmp.
-# include <cstring>
-# undef strcmp
-
-// Suppress error about condition always being true.
-# pragma option -w-ccc
-
-#endif // defined(__BORLANDC__) && !defined(__clang__)
-
-#if defined(ASIO_MSVC)
-# pragma warning (disable:4127)
-# pragma warning (push)
-# pragma warning (disable:4244)
-# pragma warning (disable:4702)
-#endif // defined(ASIO_MSVC)
-
-#if !defined(ASIO_TEST_IOSTREAM)
-# define ASIO_TEST_IOSTREAM std::cerr
-#endif // !defined(ASIO_TEST_IOSTREAM)
-
-namespace asio {
-namespace detail {
-
-inline const char*& test_name()
-{
-  static const char* name = 0;
-  return name;
-}
-
-inline atomic_count& test_errors()
-{
-  static atomic_count errors(0);
-  return errors;
-}
-
-inline void begin_test_suite(const char* name)
-{
-  asio::detail::test_name();
-  asio::detail::test_errors();
-  ASIO_TEST_IOSTREAM << name << " test suite begins" << std::endl;
-}
-
-inline int end_test_suite(const char* name)
-{
-  ASIO_TEST_IOSTREAM << name << " test suite ends" << std::endl;
-  ASIO_TEST_IOSTREAM << "\n*** ";
-  long errors = asio::detail::test_errors();
-  if (errors == 0)
-    ASIO_TEST_IOSTREAM << "No errors detected.";
-  else if (errors == 1)
-    ASIO_TEST_IOSTREAM << "1 error detected.";
-  else
-    ASIO_TEST_IOSTREAM << errors << " errors detected." << std::endl;
-  ASIO_TEST_IOSTREAM << std::endl;
-  return errors == 0 ? 0 : 1;
-}
-
-template <void (*Test)()>
-inline void run_test(const char* name)
-{
-  test_name() = name;
-  long errors_before = asio::detail::test_errors();
-  Test();
-  if (test_errors() == errors_before)
-    ASIO_TEST_IOSTREAM << name << " passed" << std::endl;
-  else
-    ASIO_TEST_IOSTREAM << name << " failed" << std::endl;
-}
-
-template <void (*)()>
-inline void compile_test(const char* name)
-{
-  ASIO_TEST_IOSTREAM << name << " passed" << std::endl;
-}
-
-#if defined(ASIO_NO_EXCEPTIONS)
-
-template <typename T>
-void throw_exception(const T& t)
-{
-  ASIO_TEST_IOSTREAM << "Exception: " << t.what() << std::endl;
-  std::abort();
-}
-
-#endif // defined(ASIO_NO_EXCEPTIONS)
-
-} // namespace detail
-} // namespace asio
-
-#define ASIO_CHECK(expr) \
-  do { if (!(expr)) { \
-    ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
-      << asio::detail::test_name() << ": " \
-      << "check '" << #expr << "' failed" << std::endl; \
-    ++asio::detail::test_errors(); \
-  } } while (0)
-
-#define ASIO_CHECK_MESSAGE(expr, msg) \
-  do { if (!(expr)) { \
-    ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
-      << asio::detail::test_name() << ": " \
-      << msg << std::endl; \
-    ++asio::detail::test_errors(); \
-  } } while (0)
-
-#define ASIO_WARN_MESSAGE(expr, msg) \
-  do { if (!(expr)) { \
-    ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
-      << asio::detail::test_name() << ": " \
-      << msg << std::endl; \
-  } } while (0)
-
-#define ASIO_ERROR(msg) \
-  do { \
-    ASIO_TEST_IOSTREAM << __FILE__ << "(" << __LINE__ << "): " \
-      << asio::detail::test_name() << ": " \
-      << msg << std::endl; \
-    ++asio::detail::test_errors(); \
-  } while (0)
-
-#define ASIO_TEST_SUITE(name, tests) \
-  int main() \
-  { \
-    asio::detail::begin_test_suite(name); \
-    tests \
-    return asio::detail::end_test_suite(name); \
-  }
-
-#define ASIO_TEST_CASE(test) \
-  asio::detail::run_test<&test>(#test);
-
-#define ASIO_TEST_CASE2(test1, test2) \
-  asio::detail::run_test<&test1, test2>(#test1 "," #test2);
-
-#define ASIO_TEST_CASE3(test1, test2, test3) \
-  asio::detail::run_test<&test1, test2, test3>( \
-    #test1 "," #test2 "," #test3);
-
-#define ASIO_TEST_CASE4(test1, test2, test3, test4) \
-  asio::detail::run_test<&test1, test2, test3, test4>( \
-    #test1 "," #test2 "," #test3 "," #test4);
-
-#define ASIO_TEST_CASE5(test1, test2, test3, test4, test5) \
-  asio::detail::run_test<&test1, test2, test3, test4, test5>( \
-    #test1 "," #test2 "," #test3 "," #test4 "," #test5);
-
-#define ASIO_COMPILE_TEST_CASE(test) \
-  asio::detail::compile_test<&test>(#test);
-
-inline void null_test()
-{
-}
-
-#if defined(__GNUC__) && defined(_AIX)
-
-// AIX needs this symbol defined in asio, even if it doesn't do anything.
-int test_main(int, char**)
-{
-}
-
-#endif // defined(__GNUC__) && defined(_AIX)
-
-#if defined(ASIO_MSVC)
-# pragma warning (pop)
-#endif // defined(ASIO_MSVC)
-
-#endif // UNIT_TEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_awaitable.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_awaitable.cpp
deleted file mode 100644
index 815f57e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_awaitable.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// use_awaitable.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/use_awaitable.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "use_awaitable",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_future.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_future.cpp
deleted file mode 100644
index ac12f7c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/use_future.cpp
+++ /dev/null
@@ -1,670 +0,0 @@
-//
-// use_future.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/use_future.hpp"
-
-#include <string>
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_STD_FUTURE_CLASS)
-
-#include "archetypes/async_ops.hpp"
-
-void use_future_0_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<void> f;
-
-  f = async_op_0(use_future);
-  try
-  {
-    f.get();
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_0(true, use_future);
-  try
-  {
-    f.get();
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_0(false, use_future);
-  try
-  {
-    f.get();
-    ASIO_CHECK(false);
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::operation_aborted);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_0(true, use_future);
-  try
-  {
-    f.get();
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_0(false, use_future);
-  try
-  {
-    f.get();
-    ASIO_CHECK(false);
-  }
-  catch (std::exception& e)
-  {
-    ASIO_CHECK(e.what() == std::string("blah"));
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-void use_future_1_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<int> f;
-
-  f = async_op_1(use_future);
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_1(true, use_future);
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_1(false, use_future);
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(false);
-    (void)i;
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::operation_aborted);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_1(true, use_future);
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_1(false, use_future);
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(false);
-    (void)i;
-  }
-  catch (std::exception& e)
-  {
-    ASIO_CHECK(e.what() == std::string("blah"));
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-void use_future_2_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<std::tuple<int, double>> f;
-
-  f = async_op_2(use_future);
-  try
-  {
-    int i;
-    double d;
-    std::tie(i, d) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_2(true, use_future);
-  try
-  {
-    int i;
-    double d;
-    std::tie(i, d) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_2(false, use_future);
-  try
-  {
-    std::tuple<int, double> t = f.get();
-    ASIO_CHECK(false);
-    (void)t;
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::operation_aborted);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_2(true, use_future);
-  try
-  {
-    int i;
-    double d;
-    std::tie(i, d) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_2(false, use_future);
-  try
-  {
-    std::tuple<int, double> t = f.get();
-    ASIO_CHECK(false);
-    (void)t;
-  }
-  catch (std::exception& e)
-  {
-    ASIO_CHECK(e.what() == std::string("blah"));
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-void use_future_3_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<std::tuple<int, double, char>> f;
-
-  f = async_op_3(use_future);
-  try
-  {
-    int i;
-    double d;
-    char c;
-    std::tie(i, d, c) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-    ASIO_CHECK(c == 'a');
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_3(true, use_future);
-  try
-  {
-    int i;
-    double d;
-    char c;
-    std::tie(i, d, c) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-    ASIO_CHECK(c == 'a');
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_3(false, use_future);
-  try
-  {
-    std::tuple<int, double, char> t = f.get();
-    ASIO_CHECK(false);
-    (void)t;
-  }
-  catch (asio::system_error& e)
-  {
-    ASIO_CHECK(e.code() == asio::error::operation_aborted);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_3(true, use_future);
-  try
-  {
-    int i;
-    double d;
-    char c;
-    std::tie(i, d, c) = f.get();
-    ASIO_CHECK(i == 42);
-    ASIO_CHECK(d == 2.0);
-    ASIO_CHECK(c == 'a');
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_3(false, use_future);
-  try
-  {
-    std::tuple<int, double, char> t = f.get();
-    ASIO_CHECK(false);
-    (void)t;
-  }
-  catch (std::exception& e)
-  {
-    ASIO_CHECK(e.what() == std::string("blah"));
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-int package_0()
-{
-  return 42;
-}
-
-int package_ec_0(asio::error_code ec)
-{
-  return ec ? 0 : 42;
-}
-
-int package_ex_0(std::exception_ptr ex)
-{
-  return ex ? 0 : 42;
-}
-
-void use_future_package_0_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<int> f;
-
-  f = async_op_0(use_future(package_0));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_0(true, use_future(&package_ec_0));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_0(false, use_future(package_ec_0));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_0(true, use_future(package_ex_0));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_0(false, use_future(package_ex_0));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-int package_1(int i)
-{
-  return i;
-}
-
-int package_ec_1(asio::error_code ec, int i)
-{
-  return ec ? 0 : i;
-}
-
-int package_ex_1(std::exception_ptr ex, int i)
-{
-  return ex ? 0 : i;
-}
-
-void use_future_package_1_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<int> f;
-
-  f = async_op_1(use_future(package_1));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_1(true, use_future(package_ec_1));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_1(false, use_future(package_ec_1));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_1(true, use_future(package_ex_1));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_1(false, use_future(package_ex_1));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-int package_2(int i, double)
-{
-  return i;
-}
-
-int package_ec_2(asio::error_code ec, int i, double)
-{
-  return ec ? 0 : i;
-}
-
-int package_ex_2(std::exception_ptr ex, int i, double)
-{
-  return ex ? 0 : i;
-}
-
-void use_future_package_2_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<int> f;
-
-  f = async_op_2(use_future(package_2));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_2(true, use_future(package_ec_2));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_2(false, use_future(package_ec_2));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_2(true, use_future(package_ex_2));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_2(false, use_future(package_ex_2));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-int package_3(int i, double, char)
-{
-  return i;
-}
-
-int package_ec_3(asio::error_code ec, int i, double, char)
-{
-  return ec ? 0 : i;
-}
-
-int package_ex_3(std::exception_ptr ex, int i, double, char)
-{
-  return ex ? 0 : i;
-}
-
-void use_future_package_3_test()
-{
-  using asio::use_future;
-  using namespace archetypes;
-
-  std::future<int> f;
-
-  f = async_op_3(use_future(package_3));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_3(true, use_future(package_ec_3));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ec_3(false, use_future(package_ec_3));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_3(true, use_future(package_ex_3));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 42);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-
-  f = async_op_ex_3(false, use_future(package_ex_3));
-  try
-  {
-    int i = f.get();
-    ASIO_CHECK(i == 0);
-  }
-  catch (...)
-  {
-    ASIO_CHECK(false);
-  }
-}
-
-ASIO_TEST_SUITE
-(
-  "use_future",
-  ASIO_TEST_CASE(use_future_0_test)
-  ASIO_TEST_CASE(use_future_1_test)
-  ASIO_TEST_CASE(use_future_2_test)
-  ASIO_TEST_CASE(use_future_3_test)
-  ASIO_TEST_CASE(use_future_package_0_test)
-  ASIO_TEST_CASE(use_future_package_1_test)
-  ASIO_TEST_CASE(use_future_package_2_test)
-  ASIO_TEST_CASE(use_future_package_3_test)
-)
-
-#else // defined(ASIO_HAS_STD_FUTURE_CLASS)
-
-ASIO_TEST_SUITE
-(
-  "use_future",
-  ASIO_TEST_CASE(null_test)
-)
-
-#endif // defined(ASIO_HAS_STD_FUTURE_CLASS)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/uses_executor.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/uses_executor.cpp
deleted file mode 100644
index f3d52c1..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/uses_executor.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// uses_executor.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/uses_executor.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "uses_executor",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/wait_traits.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/wait_traits.cpp
deleted file mode 100644
index 4bdb498..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/wait_traits.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// wait_traits.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/wait_traits.hpp"
-
-#include "unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "wait_traits",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/.gitignore b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/.gitignore
deleted file mode 100644
index 56de678..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/.gitignore
+++ /dev/null
@@ -1,18 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*.ilk
-*.manifest
-*.pdb
-*.tds
-basic_object_handle
-basic_overlapped_handle
-basic_random_access_handle
-basic_stream_handle
-object_handle
-overlapped_handle
-overlapped_ptr
-random_access_handle
-stream_handle
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_object_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_object_handle.cpp
deleted file mode 100644
index d4d6def..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_object_handle.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_object_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/basic_object_handle.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_object_handle",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_overlapped_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_overlapped_handle.cpp
deleted file mode 100644
index 62b5419..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_overlapped_handle.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_overlapped_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/basic_overlapped_handle.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_overlapped_handle",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_random_access_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_random_access_handle.cpp
deleted file mode 100644
index 4a2605e..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_random_access_handle.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_random_access_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/basic_random_access_handle.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_random_access_handle",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_stream_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_stream_handle.cpp
deleted file mode 100644
index 9cdf0bd..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/basic_stream_handle.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// basic_stream_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/basic_stream_handle.hpp"
-
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "basic_stream_handle",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/object_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/object_handle.cpp
deleted file mode 100644
index 0784ba9..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/object_handle.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//
-// object_handle.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/object_handle.hpp"
-
-#include "asio/io_context.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// windows_object_handle_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// windows::object_handle compile and link correctly. Runtime failures are
-// ignored.
-
-namespace windows_object_handle_compile {
-
-void wait_handler(const asio::error_code&)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-  using namespace asio;
-  namespace win = asio::windows;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_object_handle constructors.
-
-    win::object_handle handle1(ioc);
-    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
-#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
-    // Skip this on older MSVC due to mysterious ambiguous overload errors.
-#else
-    win::object_handle handle2(ioc, native_handle1);
-#endif
-
-    win::object_handle handle3(ioc_ex);
-    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
-    win::object_handle handle4(ioc_ex, native_handle2);
-
-    win::object_handle handle5(std::move(handle4));
-
-    win::basic_object_handle<io_context::executor_type> handle6(ioc);
-    win::object_handle handle7(std::move(handle6));
-
-    // basic_object_handle operators.
-
-    handle1 = win::object_handle(ioc);
-    handle1 = std::move(handle3);
-    handle1 = std::move(handle6);
-
-    // basic_io_object functions.
-
-    win::object_handle::executor_type ex = handle1.get_executor();
-    (void)ex;
-
-    // basic_handle functions.
-
-    win::object_handle::lowest_layer_type& lowest_layer
-      = handle1.lowest_layer();
-    (void)lowest_layer;
-
-    const win::object_handle& handle8 = handle1;
-    const win::object_handle::lowest_layer_type& lowest_layer3
-      = handle8.lowest_layer();
-    (void)lowest_layer3;
-
-    HANDLE native_handle4 = INVALID_HANDLE_VALUE;
-    handle1.assign(native_handle4);
-
-    bool is_open = handle1.is_open();
-    (void)is_open;
-
-    handle1.close();
-    handle1.close(ec);
-
-    win::object_handle::native_handle_type native_handle3
-      = handle1.native_handle();
-    (void)native_handle3;
-
-    handle1.cancel();
-    handle1.cancel(ec);
-
-    // basic_object_handle functions.
-
-    handle1.wait();
-    handle1.wait(ec);
-
-    handle1.async_wait(&wait_handler);
-    int i1 = handle1.async_wait(lazy);
-    (void)i1;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-}
-
-} // namespace windows_object_handle_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "windows/object_handle",
-  ASIO_COMPILE_TEST_CASE(windows_object_handle_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_handle.cpp
deleted file mode 100644
index 5cdd3da..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_handle.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// overlapped_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/overlapped_handle.hpp"
-
-#include "asio.hpp"
-#include "../unit_test.hpp"
-
-ASIO_TEST_SUITE
-(
-  "windows/overlapped_handle",
-  ASIO_TEST_CASE(null_test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_ptr.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_ptr.cpp
deleted file mode 100644
index fda1b2c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/overlapped_ptr.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//
-// overlapped_ptr.cpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/overlapped_ptr.hpp"
-
-#include "asio/any_io_executor.hpp"
-#include "asio/executor.hpp"
-#include "asio/io_context.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// windows_overlapped_ptr_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// windows::overlapped_ptr compile and link correctly. Runtime failures are
-// ignored.
-
-namespace windows_overlapped_ptr_compile {
-
-void overlapped_handler_1(const asio::error_code&, std::size_t)
-{
-}
-
-struct overlapped_handler_2
-{
-  void operator()(const asio::error_code&, std::size_t)
-  {
-  }
-};
-
-void test()
-{
-#if defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-  using namespace asio;
-  namespace win = asio::windows;
-
-  try
-  {
-    io_context ioc;
-    asio::any_io_executor ex1(ioc.get_executor());
-#if !defined(ASIO_NO_TS_EXECUTORS)
-    asio::executor ex2(ioc.get_executor());
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-    // basic_overlapped_ptr constructors.
-
-    win::overlapped_ptr ptr1;
-
-    win::overlapped_ptr ptr2(ioc, &overlapped_handler_1);
-    win::overlapped_ptr ptr3(ioc, overlapped_handler_2());
-
-    win::overlapped_ptr ptr4(ioc.get_executor(), &overlapped_handler_1);
-    win::overlapped_ptr ptr5(ioc.get_executor(), overlapped_handler_2());
-    win::overlapped_ptr ptr6(ex1, &overlapped_handler_1);
-    win::overlapped_ptr ptr7(ex1, overlapped_handler_2());
-#if !defined(ASIO_NO_TS_EXECUTORS)
-    win::overlapped_ptr ptr8(ex2, &overlapped_handler_1);
-    win::overlapped_ptr ptr9(ex2, overlapped_handler_2());
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-    // overlapped_ptr functions.
-
-    ptr1.reset();
-
-    ptr2.reset(ioc, &overlapped_handler_1);
-    ptr3.reset(ioc, overlapped_handler_2());
-
-    ptr2.reset(ioc.get_executor(), &overlapped_handler_1);
-    ptr3.reset(ioc.get_executor(), overlapped_handler_2());
-    ptr2.reset(ex1, &overlapped_handler_1);
-    ptr3.reset(ex1, overlapped_handler_2());
-#if !defined(ASIO_NO_TS_EXECUTORS)
-    ptr3.reset(ex2, &overlapped_handler_1);
-    ptr3.reset(ex2, overlapped_handler_2());
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-
-    OVERLAPPED* ov1 = ptr1.get();
-    (void)ov1;
-
-    const win::overlapped_ptr& ptr10(ptr1);
-    const OVERLAPPED* ov2 = ptr10.get();
-    (void)ov2;
-
-    OVERLAPPED* ov3 = ptr1.release();
-    (void)ov3;
-
-    asio::error_code ec;
-    std::size_t bytes_transferred = 0;
-    ptr1.complete(ec, bytes_transferred);
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
-}
-
-} // namespace windows_overlapped_ptr_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "windows/overlapped_ptr",
-  ASIO_COMPILE_TEST_CASE(windows_overlapped_ptr_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/random_access_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/random_access_handle.cpp
deleted file mode 100644
index 613732c..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/random_access_handle.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//
-// random_access_handle.cpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/random_access_handle.hpp"
-
-#include "asio/io_context.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// windows_random_access_handle_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// windows::random_access_handle compile and link correctly. Runtime failures
-// are ignored.
-
-namespace windows_random_access_handle_compile {
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-  using namespace asio;
-  namespace win = asio::windows;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    asio::uint64_t offset = 0;
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_random_access_handle constructors.
-
-    win::random_access_handle handle1(ioc);
-    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
-#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
-    // Skip this on older MSVC due to mysterious ambiguous overload errors.
-#else
-    win::random_access_handle handle2(ioc, native_handle1);
-#endif
-
-    win::random_access_handle handle3(ioc_ex);
-    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
-    win::random_access_handle handle4(ioc_ex, native_handle2);
-
-    win::random_access_handle handle5(std::move(handle4));
-
-    win::basic_random_access_handle<io_context::executor_type> handle6(ioc);
-    win::random_access_handle handle7(std::move(handle6));
-
-    // basic_random_access_handle operators.
-
-    handle1 = win::random_access_handle(ioc);
-    handle1 = std::move(handle4);
-    handle1 = std::move(handle6);
-
-    // basic_io_object functions.
-
-    windows::random_access_handle::executor_type ex = handle1.get_executor();
-    (void)ex;
-
-    // basic_overlapped_handle functions.
-
-    win::random_access_handle::lowest_layer_type& lowest_layer
-      = handle1.lowest_layer();
-    (void)lowest_layer;
-
-    const win::random_access_handle& handle8 = handle1;
-    const win::random_access_handle::lowest_layer_type& lowest_layer2
-      = handle8.lowest_layer();
-    (void)lowest_layer2;
-
-    HANDLE native_handle3 = INVALID_HANDLE_VALUE;
-    handle1.assign(native_handle3);
-
-    bool is_open = handle1.is_open();
-    (void)is_open;
-
-    handle1.close();
-    handle1.close(ec);
-
-    win::random_access_handle::native_handle_type native_handle4
-      = handle1.release();
-    (void)native_handle4;
-    win::random_access_handle::native_handle_type native_handle5
-      = handle1.release(ec);
-    (void)native_handle5;
-
-    win::random_access_handle::native_handle_type native_handle6
-      = handle1.native_handle();
-    (void)native_handle6;
-
-    handle1.cancel();
-    handle1.cancel(ec);
-
-    // basic_random_access_handle functions.
-
-    handle1.write_some_at(offset, buffer(mutable_char_buffer));
-    handle1.write_some_at(offset, buffer(const_char_buffer));
-    handle1.write_some_at(offset, buffer(mutable_char_buffer), ec);
-    handle1.write_some_at(offset, buffer(const_char_buffer), ec);
-
-    handle1.async_write_some_at(offset,
-        buffer(mutable_char_buffer), &write_some_handler);
-    handle1.async_write_some_at(offset,
-        buffer(const_char_buffer), &write_some_handler);
-    int i1 = handle1.async_write_some_at(offset,
-        buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = handle1.async_write_some_at(offset,
-        buffer(const_char_buffer), lazy);
-    (void)i2;
-
-    handle1.read_some_at(offset, buffer(mutable_char_buffer));
-    handle1.read_some_at(offset, buffer(mutable_char_buffer), ec);
-
-    handle1.async_read_some_at(offset,
-        buffer(mutable_char_buffer), &read_some_handler);
-    int i3 = handle1.async_read_some_at(offset,
-        buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
-}
-
-} // namespace windows_random_access_handle_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "windows/random_access_handle",
-  ASIO_COMPILE_TEST_CASE(windows_random_access_handle_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/stream_handle.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/stream_handle.cpp
deleted file mode 100644
index 1668dce..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/windows/stream_handle.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// stream_handle.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/windows/stream_handle.hpp"
-
-#include "asio/io_context.hpp"
-#include "../archetypes/async_result.hpp"
-#include "../unit_test.hpp"
-
-//------------------------------------------------------------------------------
-
-// windows_stream_handle_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// windows::stream_handle compile and link correctly. Runtime failures are
-// ignored.
-
-namespace windows_stream_handle_compile {
-
-void write_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void read_some_handler(const asio::error_code&, std::size_t)
-{
-}
-
-void test()
-{
-#if defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-  using namespace asio;
-  namespace win = asio::windows;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_stream_handle constructors.
-
-    win::stream_handle handle1(ioc);
-    HANDLE native_handle1 = INVALID_HANDLE_VALUE;
-#if defined(ASIO_MSVC) && (_MSC_VER < 1910)
-    // Skip this on older MSVC due to mysterious ambiguous overload errors.
-#else
-    win::stream_handle handle2(ioc, native_handle1);
-#endif
-
-    win::stream_handle handle3(ioc_ex);
-    HANDLE native_handle2 = INVALID_HANDLE_VALUE;
-    win::stream_handle handle4(ioc_ex, native_handle2);
-
-    win::stream_handle handle5(std::move(handle4));
-
-    win::basic_stream_handle<io_context::executor_type> handle6(ioc);
-    win::stream_handle handle7(std::move(handle6));
-
-    // basic_stream_handle operators.
-
-    handle1 = win::stream_handle(ioc);
-    handle1 = std::move(handle4);
-    handle1 = std::move(handle6);
-
-    // basic_io_object functions.
-
-    windows::stream_handle::executor_type ex = handle1.get_executor();
-    (void)ex;
-
-    // basic_overlapped_handle functions.
-
-    win::stream_handle::lowest_layer_type& lowest_layer
-      = handle1.lowest_layer();
-    (void)lowest_layer;
-
-    const win::stream_handle& handle8 = handle1;
-    const win::stream_handle::lowest_layer_type& lowest_layer2
-      = handle8.lowest_layer();
-    (void)lowest_layer2;
-
-    HANDLE native_handle3 = INVALID_HANDLE_VALUE;
-    handle1.assign(native_handle3);
-
-    bool is_open = handle1.is_open();
-    (void)is_open;
-
-    handle1.close();
-    handle1.close(ec);
-
-    win::stream_handle::native_handle_type native_handle4
-      = handle1.release();
-    (void)native_handle4;
-    win::stream_handle::native_handle_type native_handle5
-      = handle1.release(ec);
-    (void)native_handle5;
-
-    win::stream_handle::native_handle_type native_handle6
-      = handle1.native_handle();
-    (void)native_handle6;
-
-    handle1.cancel();
-    handle1.cancel(ec);
-
-    // basic_stream_handle functions.
-
-    handle1.write_some(buffer(mutable_char_buffer));
-    handle1.write_some(buffer(const_char_buffer));
-    handle1.write_some(buffer(mutable_char_buffer), ec);
-    handle1.write_some(buffer(const_char_buffer), ec);
-
-    handle1.async_write_some(buffer(mutable_char_buffer), &write_some_handler);
-    handle1.async_write_some(buffer(const_char_buffer), &write_some_handler);
-    int i1 = handle1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = handle1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-
-    handle1.read_some(buffer(mutable_char_buffer));
-    handle1.read_some(buffer(mutable_char_buffer), ec);
-
-    handle1.async_read_some(buffer(mutable_char_buffer), &read_some_handler);
-    int i3 = handle1.async_read_some(buffer(mutable_char_buffer), lazy);
-    (void)i3;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_WINDOWS_STREAM_HANDLE)
-}
-
-} // namespace windows_stream_handle_compile
-
-//------------------------------------------------------------------------------
-
-ASIO_TEST_SUITE
-(
-  "windows/stream_handle",
-  ASIO_COMPILE_TEST_CASE(windows_stream_handle_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/writable_pipe.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/writable_pipe.cpp
deleted file mode 100644
index 0cea754..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/writable_pipe.cpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//
-// writable_pipe.cpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header pipe is self-contained.
-#include "asio/writable_pipe.hpp"
-
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "unit_test.hpp"
-
-// writable_pipe_compile test
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-// The following test checks that all public member functions on the class
-// writable_pipe compile and link correctly. Runtime failures are ignored.
-
-namespace writable_pipe_compile {
-
-struct write_some_handler
-{
-  write_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  write_some_handler(write_some_handler&&) {}
-private:
-  write_some_handler(const write_some_handler&);
-};
-
-struct read_some_handler
-{
-  read_some_handler() {}
-  void operator()(const asio::error_code&, std::size_t) {}
-  read_some_handler(read_some_handler&&) {}
-private:
-  read_some_handler(const read_some_handler&);
-};
-
-void test()
-{
-#if defined(ASIO_HAS_PIPE)
-  using namespace asio;
-
-  try
-  {
-    io_context ioc;
-    const io_context::executor_type ioc_ex = ioc.get_executor();
-    char mutable_char_buffer[128] = "";
-    const char const_char_buffer[128] = "";
-    archetypes::lazy_handler lazy;
-    asio::error_code ec;
-
-    // basic_writable_pipe constructors.
-
-    writable_pipe pipe1(ioc);
-    writable_pipe::native_handle_type native_pipe1 = pipe1.native_handle();
-    writable_pipe pipe2(ioc, native_pipe1);
-
-    writable_pipe pipe3(ioc_ex);
-    writable_pipe::native_handle_type native_pipe2 = pipe1.native_handle();
-    writable_pipe pipe4(ioc_ex, native_pipe2);
-
-    writable_pipe pipe5(std::move(pipe4));
-
-    basic_writable_pipe<io_context::executor_type> pipe6(ioc);
-    writable_pipe pipe7(std::move(pipe6));
-
-    // basic_writable_pipe operators.
-
-    pipe1 = writable_pipe(ioc);
-    pipe1 = std::move(pipe2);
-    pipe1 = std::move(pipe6);
-
-    // basic_io_object functions.
-
-    writable_pipe::executor_type ex = pipe1.get_executor();
-    (void)ex;
-
-    // basic_writable_pipe functions.
-
-    writable_pipe::native_handle_type native_pipe3 = pipe1.native_handle();
-    pipe1.assign(native_pipe3);
-    writable_pipe::native_handle_type native_pipe4 = pipe1.native_handle();
-    pipe1.assign(native_pipe4, ec);
-
-    bool is_open = pipe1.is_open();
-    (void)is_open;
-
-    pipe1.close();
-    pipe1.close(ec);
-
-    writable_pipe::native_handle_type native_pipe5 = pipe1.release();
-    (void)native_pipe5;
-    writable_pipe::native_handle_type native_pipe6 = pipe1.release(ec);
-    (void)native_pipe6;
-
-    writable_pipe::native_handle_type native_pipe7 = pipe1.native_handle();
-    (void)native_pipe7;
-
-    pipe1.cancel();
-    pipe1.cancel(ec);
-
-    pipe1.write_some(buffer(mutable_char_buffer));
-    pipe1.write_some(buffer(const_char_buffer));
-    pipe1.write_some(buffer(mutable_char_buffer), ec);
-    pipe1.write_some(buffer(const_char_buffer), ec);
-
-    pipe1.async_write_some(buffer(mutable_char_buffer), write_some_handler());
-    pipe1.async_write_some(buffer(const_char_buffer), write_some_handler());
-    int i1 = pipe1.async_write_some(buffer(mutable_char_buffer), lazy);
-    (void)i1;
-    int i2 = pipe1.async_write_some(buffer(const_char_buffer), lazy);
-    (void)i2;
-  }
-  catch (std::exception&)
-  {
-  }
-#endif // defined(ASIO_HAS_PIPE)
-}
-
-} // namespace writable_pipe_compile
-
-ASIO_TEST_SUITE
-(
-  "writable_pipe",
-  ASIO_COMPILE_TEST_CASE(writable_pipe_compile::test)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write.cpp
deleted file mode 100644
index 7146f60..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write.cpp
+++ /dev/null
@@ -1,4979 +0,0 @@
-//
-// write.cpp
-// ~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/write.hpp"
-
-#include <array>
-#include <cstring>
-#include <functional>
-#include <vector>
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/streambuf.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-#include <boost/array.hpp>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_stream
-{
-public:
-  typedef asio::io_context::executor_type executor_type;
-
-  test_stream(asio::io_context& io_context)
-    : io_context_(io_context),
-      length_(max_length),
-      position_(0),
-      next_write_length_(max_length)
-  {
-    memset(data_, 0, max_length);
-  }
-
-  executor_type get_executor() noexcept
-  {
-    return io_context_.get_executor();
-  }
-
-  void reset(size_t length = max_length)
-  {
-    ASIO_CHECK(length <= max_length);
-
-    memset(data_, 0, max_length);
-    length_ = length;
-    position_ = 0;
-    next_write_length_ = length;
-  }
-
-  void next_write_length(size_t length)
-  {
-    next_write_length_ = length;
-  }
-
-  template <typename Iterator>
-  bool check_buffers(Iterator begin, Iterator end, size_t length)
-  {
-    if (length != position_)
-      return false;
-
-    Iterator iter = begin;
-    size_t checked_length = 0;
-    for (; iter != end && checked_length < length; ++iter)
-    {
-      size_t buffer_length = asio::buffer_size(*iter);
-      if (buffer_length > length - checked_length)
-        buffer_length = length - checked_length;
-      if (memcmp(data_ + checked_length, iter->data(), buffer_length) != 0)
-        return false;
-      checked_length += buffer_length;
-    }
-
-    return true;
-  }
-
-  template <typename Const_Buffers>
-  bool check_buffers(const Const_Buffers& buffers, size_t length)
-  {
-    return check_buffers(asio::buffer_sequence_begin(buffers),
-        asio::buffer_sequence_end(buffers), length);
-  }
-
-  template <typename Const_Buffers>
-  size_t write_some(const Const_Buffers& buffers)
-  {
-    size_t n = asio::buffer_copy(
-        asio::buffer(data_, length_) + position_,
-        buffers, next_write_length_);
-    position_ += n;
-    return n;
-  }
-
-  template <typename Const_Buffers>
-  size_t write_some(const Const_Buffers& buffers, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return write_some(buffers);
-  }
-
-  template <typename Const_Buffers, typename Handler>
-  void async_write_some(const Const_Buffers& buffers,
-      Handler&& handler)
-  {
-    size_t bytes_transferred = write_some(buffers);
-    asio::post(get_executor(),
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler),
-          asio::error_code(), bytes_transferred));
-  }
-
-private:
-  asio::io_context& io_context_;
-  enum { max_length = 8192 };
-  char data_[max_length];
-  size_t length_;
-  size_t position_;
-  size_t next_write_length_;
-};
-
-static const char write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-static char mutable_write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void test_2_arg_zero_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-
-  size_t bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == 0);
-}
-
-void test_2_arg_const_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_2_arg_mutable_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-}
-
-void test_2_arg_vector_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_2_arg_dynamic_string_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  size_t bytes_transferred = asio::write(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_nothrow_zero_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == 0);
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_const_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_mutable_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_vector_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_3_arg_nothrow_dynamic_string_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-bool old_style_transfer_all(const asio::error_code& ec,
-    size_t /*bytes_transferred*/)
-{
-  return !!ec;
-}
-
-struct short_transfer
-{
-  short_transfer() {}
-  short_transfer(short_transfer&&) {}
-  size_t operator()(const asio::error_code& ec,
-      size_t /*bytes_transferred*/)
-  {
-    return !!ec ? 0 : 3;
-  }
-};
-
-void test_3_arg_const_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_mutable_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-}
-
-void test_3_arg_vector_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_dynamic_string_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  size_t bytes_transferred = asio::write(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb, old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  bytes_transferred = asio::write(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  bytes_transferred = asio::write(s, sb, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_4_arg_const_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_mutable_buffer_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_vector_buffers_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, buffers, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_dynamic_string_write()
-{
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  asio::error_code error;
-  size_t bytes_transferred = asio::write(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bytes_transferred = asio::write(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write(s, sb, short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void async_write_handler(const asio::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!e);
-  ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
-}
-
-void test_3_arg_const_buffer_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_mutable_buffer_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-}
-
-void test_3_arg_boost_array_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  boost::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_3_arg_std_array_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_vector_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_dynamic_string_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  int i = asio::async_write(s, sb, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_3_arg_streambuf_async_write()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb;
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  int i = asio::async_write(s, sb, archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-void test_4_arg_const_buffer_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_4_arg_mutable_buffer_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(mutable_write_data)));
-}
-
-void test_4_arg_boost_array_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_stream s(ioc);
-  boost::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_4_arg_std_array_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_4_arg_vector_buffers_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data, 39) + 32);
-  buffers.push_back(asio::buffer(write_data) + 39);
-
-  s.reset();
-  bool called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write(s, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write(s, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_4_arg_dynamic_string_async_write()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  std::string data;
-  asio::dynamic_string_buffer<char, std::string::traits_type,
-    std::string::allocator_type> sb
-      = asio::dynamic_buffer(data, sizeof(write_data));
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  int i = asio::async_write(s, sb, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  data.assign(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-}
-
-void test_4_arg_streambuf_async_write()
-{
-#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_stream s(ioc);
-  asio::streambuf sb;
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 50));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write(s, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  int i = asio::async_write(s, sb, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write(s, sb, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(buffers, sizeof(write_data)));
-#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1)
-}
-
-ASIO_TEST_SUITE
-(
-  "write",
-  ASIO_TEST_CASE(test_2_arg_zero_buffers_write)
-  ASIO_TEST_CASE(test_2_arg_const_buffer_write)
-  ASIO_TEST_CASE(test_2_arg_mutable_buffer_write)
-  ASIO_TEST_CASE(test_2_arg_vector_buffers_write)
-  ASIO_TEST_CASE(test_2_arg_dynamic_string_write)
-  ASIO_TEST_CASE(test_3_arg_nothrow_zero_buffers_write)
-  ASIO_TEST_CASE(test_3_arg_nothrow_const_buffer_write)
-  ASIO_TEST_CASE(test_3_arg_nothrow_mutable_buffer_write)
-  ASIO_TEST_CASE(test_3_arg_nothrow_vector_buffers_write)
-  ASIO_TEST_CASE(test_3_arg_nothrow_dynamic_string_write)
-  ASIO_TEST_CASE(test_3_arg_const_buffer_write)
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_write)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_write)
-  ASIO_TEST_CASE(test_3_arg_dynamic_string_write)
-  ASIO_TEST_CASE(test_4_arg_const_buffer_write)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_write)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_write)
-  ASIO_TEST_CASE(test_4_arg_dynamic_string_write)
-  ASIO_TEST_CASE(test_3_arg_const_buffer_async_write)
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_async_write)
-  ASIO_TEST_CASE(test_3_arg_boost_array_buffers_async_write)
-  ASIO_TEST_CASE(test_3_arg_std_array_buffers_async_write)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_async_write)
-  ASIO_TEST_CASE(test_3_arg_dynamic_string_async_write)
-  ASIO_TEST_CASE(test_3_arg_streambuf_async_write)
-  ASIO_TEST_CASE(test_4_arg_const_buffer_async_write)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_write)
-  ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_write)
-  ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_write)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_async_write)
-  ASIO_TEST_CASE(test_4_arg_dynamic_string_async_write)
-  ASIO_TEST_CASE(test_4_arg_streambuf_async_write)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write_at.cpp b/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write_at.cpp
deleted file mode 100644
index b690a95..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tests/unit/write_at.cpp
+++ /dev/null
@@ -1,7635 +0,0 @@
-//
-// write_at.cpp
-// ~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-// Disable autolinking for unit tests.
-#if !defined(BOOST_ALL_NO_LIB)
-#define BOOST_ALL_NO_LIB 1
-#endif // !defined(BOOST_ALL_NO_LIB)
-
-// Test that header file is self-contained.
-#include "asio/write_at.hpp"
-
-#include <array>
-#include <cstring>
-#include <functional>
-#include "archetypes/async_result.hpp"
-#include "asio/io_context.hpp"
-#include "asio/post.hpp"
-#include "asio/streambuf.hpp"
-#include "unit_test.hpp"
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-#include <boost/array.hpp>
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-
-using namespace std; // For memcmp, memcpy and memset.
-
-class test_random_access_device
-{
-public:
-  typedef asio::io_context::executor_type executor_type;
-
-  test_random_access_device(asio::io_context& io_context)
-    : io_context_(io_context),
-      length_(max_length),
-      next_write_length_(max_length)
-  {
-    memset(data_, 0, max_length);
-  }
-
-  executor_type get_executor() noexcept
-  {
-    return io_context_.get_executor();
-  }
-
-  void reset()
-  {
-    memset(data_, 0, max_length);
-    next_write_length_ = max_length;
-  }
-
-  void next_write_length(size_t length)
-  {
-    next_write_length_ = length;
-  }
-
-  template <typename Iterator>
-  bool check_buffers(asio::uint64_t offset,
-      Iterator begin, Iterator end, size_t length)
-  {
-    if (offset + length > max_length)
-      return false;
-
-    Iterator iter = begin;
-    size_t checked_length = 0;
-    for (; iter != end && checked_length < length; ++iter)
-    {
-      size_t buffer_length = asio::buffer_size(*iter);
-      if (buffer_length > length - checked_length)
-        buffer_length = length - checked_length;
-      if (memcmp(data_ + offset + checked_length,
-            iter->data(), buffer_length) != 0)
-        return false;
-      checked_length += buffer_length;
-    }
-
-    return true;
-  }
-
-  template <typename Const_Buffers>
-  bool check_buffers(asio::uint64_t offset,
-      const Const_Buffers& buffers, size_t length)
-  {
-    return check_buffers(offset, asio::buffer_sequence_begin(buffers),
-        asio::buffer_sequence_end(buffers), length);
-  }
-
-  template <typename Const_Buffers>
-  size_t write_some_at(asio::uint64_t offset,
-      const Const_Buffers& buffers)
-  {
-    return asio::buffer_copy(
-        asio::buffer(data_, length_) + offset,
-        buffers, next_write_length_);
-  }
-
-  template <typename Const_Buffers>
-  size_t write_some_at(asio::uint64_t offset,
-      const Const_Buffers& buffers, asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return write_some_at(offset, buffers);
-  }
-
-  template <typename Const_Buffers, typename Handler>
-  void async_write_some_at(asio::uint64_t offset,
-      const Const_Buffers& buffers, Handler&& handler)
-  {
-    size_t bytes_transferred = write_some_at(offset, buffers);
-    asio::post(get_executor(),
-        asio::detail::bind_handler(
-          static_cast<Handler&&>(handler),
-          asio::error_code(), bytes_transferred));
-  }
-
-private:
-  asio::io_context& io_context_;
-  enum { max_length = 8192 };
-  char data_[max_length];
-  size_t length_;
-  size_t next_write_length_;
-};
-
-static const char write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-static char mutable_write_data[]
-  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-void test_3_arg_const_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_3_arg_mutable_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-}
-
-void test_3_arg_vector_buffers_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_4_arg_nothrow_const_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_nothrow_mutable_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_4_arg_nothrow_vector_buffers_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-bool old_style_transfer_all(const asio::error_code& ec,
-    size_t /*bytes_transferred*/)
-{
-  return !!ec;
-}
-
-struct short_transfer
-{
-  short_transfer() {}
-  short_transfer(short_transfer&&) {}
-  size_t operator()(const asio::error_code& ec,
-      size_t /*bytes_transferred*/)
-  {
-    return !!ec ? 0 : 3;
-  }
-};
-
-void test_4_arg_const_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_4_arg_mutable_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-}
-
-void test_4_arg_vector_buffers_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42));
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1));
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10));
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42));
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 0, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  bytes_transferred = asio::write_at(s, 1234, buffers, short_transfer());
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_5_arg_const_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_5_arg_mutable_buffer_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(mutable_write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-  ASIO_CHECK(!error);
-}
-
-void test_5_arg_vector_buffers_write_at()
-{
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  asio::error_code error;
-  size_t bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_all(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(1), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_at_least(42), error);
-  ASIO_CHECK(bytes_transferred == 50);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(1), error);
-  ASIO_CHECK(bytes_transferred == 1);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(10), error);
-  ASIO_CHECK(bytes_transferred == 10);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      asio::transfer_exactly(42), error);
-  ASIO_CHECK(bytes_transferred == 42);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      old_style_transfer_all, error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(1);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 0, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-
-  s.reset();
-  s.next_write_length(10);
-  error = asio::error_code();
-  bytes_transferred = asio::write_at(s, 1234, buffers,
-      short_transfer(), error);
-  ASIO_CHECK(bytes_transferred == sizeof(write_data));
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-  ASIO_CHECK(!error);
-}
-
-void async_write_handler(const asio::error_code& e,
-    size_t bytes_transferred, size_t expected_bytes_transferred, bool* called)
-{
-  *called = true;
-  ASIO_CHECK(!e);
-  ASIO_CHECK(bytes_transferred == expected_bytes_transferred);
-}
-
-void test_4_arg_const_buffer_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-}
-
-void test_4_arg_mutable_buffer_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-}
-
-void test_4_arg_boost_array_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  boost::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_4_arg_std_array_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-}
-
-void test_4_arg_vector_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-}
-
-void test_4_arg_streambuf_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb;
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write_at(s, 0, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  int i = asio::async_write_at(s, 0, sb,
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb)(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-}
-
-void test_5_arg_const_buffer_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_5_arg_mutable_buffer_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::mutable_buffer buffers
-    = asio::buffer(mutable_write_data, sizeof(mutable_write_data));
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(mutable_write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(mutable_write_data)));
-}
-
-void test_5_arg_boost_array_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-#if defined(ASIO_HAS_BOOST_ARRAY)
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  boost::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-#endif // defined(ASIO_HAS_BOOST_ARRAY)
-}
-
-void test_5_arg_std_array_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::array<asio::const_buffer, 2> buffers = { {
-    asio::buffer(write_data, 32),
-    asio::buffer(write_data) + 32 } };
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_5_arg_vector_buffers_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  std::vector<asio::const_buffer> buffers;
-  buffers.push_back(asio::buffer(write_data, 32));
-  buffers.push_back(asio::buffer(write_data) + 32);
-
-  s.reset();
-  bool called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  int i = asio::async_write_at(s, 0, buffers, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, buffers, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-void test_5_arg_streambuf_async_write_at()
-{
-  namespace bindns = std;
-  using bindns::placeholders::_1;
-  using bindns::placeholders::_2;
-
-  asio::io_context ioc;
-  test_random_access_device s(ioc);
-  asio::streambuf sb;
-  asio::const_buffer buffers
-    = asio::buffer(write_data, sizeof(write_data));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  bool called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_all(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 50));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_at_least(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 50, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 50));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(1),
-      bindns::bind(async_write_handler,
-        _1, _2, 1, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 1));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(10),
-      bindns::bind(async_write_handler,
-        _1, _2, 10, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 10));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb,
-      asio::transfer_exactly(42),
-      bindns::bind(async_write_handler,
-        _1, _2, 42, &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, 42));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb, old_style_transfer_all,
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  called = false;
-  asio::async_write_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(1);
-  called = false;
-  asio::async_write_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 0, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb, short_transfer(),
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  int i = asio::async_write_at(s, 0, sb, short_transfer(),
-      archetypes::lazy_handler());
-  ASIO_CHECK(i == 42);
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(s.check_buffers(0, buffers, sizeof(write_data)));
-
-  s.reset();
-  sb.consume(sb.size());
-  sb.sputn(write_data, sizeof(write_data));
-  s.next_write_length(10);
-  called = false;
-  asio::async_write_at(s, 1234, sb, short_transfer())(
-      bindns::bind(async_write_handler,
-        _1, _2, sizeof(write_data), &called));
-  ioc.restart();
-  ioc.run();
-  ASIO_CHECK(called);
-  ASIO_CHECK(s.check_buffers(1234, buffers, sizeof(write_data)));
-}
-
-ASIO_TEST_SUITE
-(
-  "write_at",
-  ASIO_TEST_CASE(test_3_arg_const_buffer_write_at)
-  ASIO_TEST_CASE(test_3_arg_mutable_buffer_write_at)
-  ASIO_TEST_CASE(test_3_arg_vector_buffers_write_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_const_buffer_write_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_mutable_buffer_write_at)
-  ASIO_TEST_CASE(test_4_arg_nothrow_vector_buffers_write_at)
-  ASIO_TEST_CASE(test_4_arg_const_buffer_write_at)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_write_at)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_write_at)
-  ASIO_TEST_CASE(test_5_arg_const_buffer_write_at)
-  ASIO_TEST_CASE(test_5_arg_mutable_buffer_write_at)
-  ASIO_TEST_CASE(test_5_arg_vector_buffers_write_at)
-  ASIO_TEST_CASE(test_4_arg_const_buffer_async_write_at)
-  ASIO_TEST_CASE(test_4_arg_mutable_buffer_async_write_at)
-  ASIO_TEST_CASE(test_4_arg_boost_array_buffers_async_write_at)
-  ASIO_TEST_CASE(test_4_arg_std_array_buffers_async_write_at)
-  ASIO_TEST_CASE(test_4_arg_vector_buffers_async_write_at)
-  ASIO_TEST_CASE(test_4_arg_streambuf_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_const_buffer_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_mutable_buffer_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_boost_array_buffers_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_std_array_buffers_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_vector_buffers_async_write_at)
-  ASIO_TEST_CASE(test_5_arg_streambuf_async_write_at)
-)
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerlive.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerlive.pl
deleted file mode 100755
index e24b8ac..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerlive.pl
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/perl -w
-#
-# handlerlive.pl
-# ~~~~~~~~~~~~~~
-#
-# A tool for post-processing the debug output generated by Asio-based programs
-# to print a list of "live" handlers. These are handlers that are associated
-# with operations that have not yet completed, or running handlers that have
-# not yet finished their execution. Programs write this output to the standard
-# error stream when compiled with the define `ASIO_ENABLE_HANDLER_TRACKING'.
-#
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-use strict;
-
-my %pending_handlers = ();
-my %running_handlers = ();
-
-#-------------------------------------------------------------------------------
-# Parse the debugging output and update the set of pending handlers.
-
-sub parse_debug_output()
-{
-  while (my $line = <>)
-  {
-    chomp($line);
-
-    if ($line =~ /\@asio\|([^|]*)\|([^|]*)\|(.*)$/)
-    {
-      my $action = $2;
-
-      # Handler creation.
-      if ($action =~ /^([0-9]+)\*([0-9]+)$/)
-      {
-        $pending_handlers{$2} = 1;
-      }
-
-      # Begin handler invocation. 
-      elsif ($action =~ /^>([0-9]+)$/)
-      {
-        delete($pending_handlers{$1});
-        $running_handlers{$1} = 1;
-      }
-
-      # End handler invocation.
-      elsif ($action =~ /^<([0-9]+)$/)
-      {
-        delete($running_handlers{$1});
-      }
-
-      # Handler threw exception.
-      elsif ($action =~ /^!([0-9]+)$/)
-      {
-        delete($running_handlers{$1});
-      }
-
-      # Handler was destroyed without being invoked.
-      elsif ($action =~ /^~([0-9]+)$/)
-      {
-        delete($pending_handlers{$1});
-      }
-    }
-  }
-}
-
-#-------------------------------------------------------------------------------
-# Print a list of incompleted handers, on a single line delimited by spaces.
-
-sub print_handlers($)
-{
-  my $handlers = shift;
-  my $prefix = "";
-  foreach my $handler (sort { $a <=> $b } keys %{$handlers})
-  {
-    print("$prefix$handler");
-    $prefix = " ";
-  }
-  print("\n") if ($prefix ne "");
-}
-
-#-------------------------------------------------------------------------------
-
-parse_debug_output();
-print_handlers(\%running_handlers);
-print_handlers(\%pending_handlers);
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlertree.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlertree.pl
deleted file mode 100755
index 83e9549..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlertree.pl
+++ /dev/null
@@ -1,140 +0,0 @@
-#!/usr/bin/perl -w
-#
-# handlertree.pl
-# ~~~~~~~~~~~~~~
-# A tool for post-processing the debug output generated by Asio-based programs
-# to print the tree of handlers that resulted in some specified handler ids.
-# Programs write this output to the standard error stream when compiled with
-# the define `ASIO_ENABLE_HANDLER_TRACKING'.
-#
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-use strict;
-
-my %target_handlers = ();
-my @cached_output = ();
-my %outstanding_handlers = ();
-my %running_handlers = ();
-
-#-------------------------------------------------------------------------------
-# Build the initial list of target handlers from the command line arguments.
-
-sub build_initial_target_handlers()
-{
-  for my $handler (@ARGV)
-  {
-    $target_handlers{$handler} = 1;
-  }
-}
-
-#-------------------------------------------------------------------------------
-# Parse the debugging output and cache the handler tracking lines.
-
-sub parse_debug_output()
-{
-  while (my $line = <STDIN>)
-  {
-    chomp($line);
-
-    if ($line =~ /\@asio\|([^|]*)\|([^|]*)\|(.*)$/)
-    {
-      push(@cached_output, $line);
-    }
-  }
-}
-
-#-------------------------------------------------------------------------------
-# Iterate over the cached output in revese and build a hash of all target
-# handlers' ancestors.
-
-sub build_target_handler_tree()
-{
-  my $i = scalar(@cached_output) - 1;
-  while ($i >= 0)
-  {
-    my $line = $cached_output[$i];
-
-    if ($line =~ /\@asio\|([^|]*)\|([^|]*)\|(.*)$/)
-    {
-      my $action = $2;
-
-      # Handler creation.
-      if ($action =~ /^([0-9]+)\*([0-9]+)$/)
-      {
-        if ($1 ne "0" and exists($target_handlers{$2}))
-        {
-          $target_handlers{$1} = 1;
-        }
-      }
-    }
-
-    --$i;
-  }
-}
-
-#-------------------------------------------------------------------------------
-# Print out all handler tracking records associated with the target handlers.
-
-sub print_target_handler_records()
-{
-  for my $line (@cached_output)
-  {
-    if ($line =~ /\@asio\|([^|]*)\|([^|]*)\|(.*)$/)
-    {
-      my $action = $2;
-
-      # Handler location.
-      if ($action =~ /^([0-9]+)\^([0-9]+)$/)
-      {
-        print("$line\n") if ($1 eq "0" or exists($target_handlers{$1})) and exists($target_handlers{$2});
-      }
-
-      # Handler creation.
-      if ($action =~ /^([0-9]+)\*([0-9]+)$/)
-      {
-        print("$1, $2, $line\n") if ($1 eq "0" or exists($target_handlers{$1})) and exists($target_handlers{$2});
-      }
-
-      # Begin handler invocation. 
-      elsif ($action =~ /^>([0-9]+)$/)
-      {
-        print("$line\n") if (exists($target_handlers{$1}));
-      }
-
-      # End handler invocation.
-      elsif ($action =~ /^<([0-9]+)$/)
-      {
-        print("$line\n") if (exists($target_handlers{$1}));
-      }
-
-      # Handler threw exception.
-      elsif ($action =~ /^!([0-9]+)$/)
-      {
-        print("$line\n") if (exists($target_handlers{$1}));
-      }
-
-      # Handler was destroyed without being invoked.
-      elsif ($action =~ /^~([0-9]+)$/)
-      {
-        print("$line\n") if (exists($target_handlers{$1}));
-      }
-
-      # Operation associated with a handler.
-      elsif ($action =~ /^\.([0-9]+)$/)
-      {
-        print("$line\n") if (exists($target_handlers{$1}));
-      }
-    }
-  }
-}
-
-#-------------------------------------------------------------------------------
-
-build_initial_target_handlers();
-parse_debug_output();
-build_target_handler_tree();
-print_target_handler_records();
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerviz.pl b/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerviz.pl
deleted file mode 100755
index 6bef1b7..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/src/tools/handlerviz.pl
+++ /dev/null
@@ -1,375 +0,0 @@
-#!/usr/bin/perl -w
-#
-# handlerviz.pl
-# ~~~~~~~~~~~~~
-#
-# A visualisation tool for post-processing the debug output generated by
-# Asio-based programs. Programs write this output to the standard error stream
-# when compiled with the define `ASIO_ENABLE_HANDLER_TRACKING'.
-#
-# This tool generates output intended for use with the GraphViz tool `dot'. For
-# example, to convert output to a PNG image, use:
-#
-#   perl handlerviz.pl < output.txt | dot -Tpng > output.png
-#
-# To convert to a PDF file, use:
-#
-#   perl handlerviz.pl < output.txt | dot -Tpdf > output.pdf
-#
-# Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-use strict;
-
-my %nodes = ();
-my @edges = ();
-my %locations = ();
-my %anon_nodes = ();
-my $anon_id = 0;
-my %all_nodes = ();
-my %pending_nodes = ();
-
-#-------------------------------------------------------------------------------
-# Parse the debugging output and populate the nodes and edges.
-
-sub parse_debug_output()
-{
-  while (my $line = <>)
-  {
-    chomp($line);
-
-    if ($line =~ /\@asio\|([^|]*)\|([^|]*)\|(.*)$/)
-    {
-      my $timestamp = $1;
-      my $action = $2;
-      my $description = $3;
-
-      # Handler creation.
-      if ($action =~ /^([0-9]+)\*([0-9]+)$/)
-      {
-        my $begin = $1;
-        my $end = $2;
-        my $label = $description;
-        $label =~ s/\./\\n/g;
-
-        if ($begin eq "0")
-        {
-          $begin = "a" . $anon_id++;
-          $anon_nodes{$begin} = $timestamp;
-          $all_nodes{"$timestamp-$begin"} = $begin;
-        }
-
-        my %edge = ( begin=>$begin, end=>$end, label=>$label );
-        push(@edges, \%edge);
-
-        $pending_nodes{$end} = 1;
-      }
-
-      # Handler location.
-      elsif ($action =~ /^([0-9]+)\^([0-9]+)$/)
-      {
-        if ($1 ne "0")
-        {
-          if (not exists($locations{($1,$2)}))
-          {
-            $locations{($1,$2)} = ();
-          }
-          push(@{$locations{($1,$2)}}, $description);
-        }
-      }
-
-      # Begin handler invocation. 
-      elsif ($action =~ /^>([0-9]+)$/)
-      {
-        my %new_node = ( label=>$description, entry=>$timestamp );
-        $new_node{content} = ();
-        $nodes{$1} = \%new_node;
-        $all_nodes{"$timestamp-$1"} = $1;
-        delete($pending_nodes{$1});
-      }
-
-      # End handler invocation.
-      elsif ($action =~ /^<([0-9]+)$/)
-      {
-        $nodes{$1}->{exit} = $timestamp;
-      }
-
-      # Handler threw exception.
-      elsif ($action =~ /^!([0-9]+)$/)
-      {
-        push(@{$nodes{$1}->{content}}, "exception");
-      }
-
-      # Handler was destroyed without being invoked.
-      elsif ($action =~ /^~([0-9]+)$/)
-      {
-        my %new_node = ( label=>"$timestamp destroyed" );
-        $new_node{content} = ();
-        $nodes{$1} = \%new_node;
-        $all_nodes{"$timestamp-$1"} = $1;
-        delete($pending_nodes{$1});
-      }
-
-      # Handler performed some operation.
-      elsif ($action =~ /^([0-9]+)$/)
-      {
-        if ($1 eq "0")
-        {
-          my $id = "a" . $anon_id++;
-          $anon_nodes{$id} = "$timestamp\\l$description";
-          $all_nodes{"$timestamp-$id"} = $id;
-        }
-        else
-        {
-          push(@{$nodes{$1}->{content}}, "$description");
-        }
-      }
-    }
-  }
-}
-
-#-------------------------------------------------------------------------------
-# Helper function to convert a string to escaped HTML text.
-
-sub escape($)
-{
-  my $text = shift;
-  $text =~ s/&/\&amp\;/g;
-  $text =~ s/</\&lt\;/g;
-  $text =~ s/>/\&gt\;/g;
-  $text =~ s/\t/    /g;
-  return $text;
-}
-
-#-------------------------------------------------------------------------------
-# Templates for dot output.
-
-my $graph_header = <<"EOF";
-/* Generated by handlerviz.pl */
-digraph "handlerviz output"
-{
-graph [ nodesep="1" ];
-node [ shape="box", fontsize="9" ];
-edge [ arrowtail="dot", fontsize="9" ];
-EOF
-
-my $graph_footer = <<"EOF";
-}
-EOF
-
-my $node_header = <<"EOF";
-"%name%"
-[
-label=<<table border="0" cellspacing="0">
-<tr><td align="left" bgcolor="gray" border="0">%label%</td></tr>
-EOF
-
-my $node_footer = <<"EOF";
-</table>>
-]
-EOF
-
-my $node_content = <<"EOF";
-<tr><td align="left" bgcolor="white" border="0">
-<font face="mono" point-size="9">%content%</font>
-</td></tr>
-EOF
-
-my $anon_nodes_header = <<"EOF";
-{
-node [ shape="record" ];
-EOF
-
-my $anon_nodes_footer = <<"EOF";
-}
-EOF
-
-my $anon_node = <<"EOF";
-"%name%" [ label="%label%", color="gray" ];
-EOF
-
-my $pending_nodes_header = <<"EOF";
-{
-node [ shape="record", color="red" ];
-rank = "max";
-EOF
-
-my $pending_nodes_footer = <<"EOF";
-}
-EOF
-
-my $pending_node = <<"EOF";
-"%name%";
-EOF
-
-my $edges_header = <<"EOF";
-{
-edge [ style="dashed", arrowhead="open" ];
-EOF
-
-my $edges_footer = <<"EOF";
-}
-EOF
-
-my $edge = <<"EOF";
-"%begin%" -> "%end%" [ label="%label%", labeltooltip="%tooltip%" ]
-EOF
-
-my $node_order_header = <<"EOF";
-{
-node [ style="invisible" ];
-edge [ style="invis", weight="100" ];
-EOF
-
-my $node_order_footer = <<"EOF";
-}
-EOF
-
-my $node_order = <<"EOF";
-{
-rank="same"
-"%begin%";
-"o%begin%";
-}
-"o%begin%" -> "o%end%";
-EOF
-
-#-------------------------------------------------------------------------------
-# Generate dot output from the nodes and edges.
-
-sub print_nodes()
-{
-  foreach my $name (sort keys %nodes)
-  {
-    my $node = $nodes{$name};
-    my $entry = $node->{entry};
-    my $exit = $node->{exit};
-    my $label = escape($node->{label});
-    my $header = $node_header;
-    $header =~ s/%name%/$name/g;
-    $header =~ s/%label%/$label/g;
-    print($header);
-
-    if (defined($exit) and defined($entry))
-    {
-      my $line = $node_content;
-      my $content = $entry . " + " . sprintf("%.6f", $exit - $entry) . "s";
-      $line =~ s/%content%/$content/g;
-      print($line);
-    }
-
-    foreach my $content (@{$node->{content}})
-    {
-      $content = escape($content);
-      $content = " " if length($content) == 0;
-      my $line = $node_content;
-      $line =~ s/%content%/$content/g;
-      print($line);
-    }
-
-    print($node_footer);
-  }
-}
-
-sub print_anon_nodes()
-{
-  print($anon_nodes_header);
-  foreach my $name (sort keys %anon_nodes)
-  {
-    my $label = $anon_nodes{$name};
-    my $line = $anon_node;
-    $line =~ s/%name%/$name/g;
-    $line =~ s/%label%/$label/g;
-    print($line);
-  }
-  print($anon_nodes_footer);
-}
-
-sub print_pending_nodes()
-{
-  print($pending_nodes_header);
-  foreach my $name (sort keys %pending_nodes)
-  {
-    my $line = $pending_node;
-    $line =~ s/%name%/$name/g;
-    print($line);
-  }
-  print($pending_nodes_footer);
-}
-
-sub print_edges()
-{
-  print($edges_header);
-  foreach my $e (@edges)
-  {
-    my $begin = $e->{begin};
-    my $end = $e->{end};
-    my $label = $e->{label};
-    my $tooltip = "";
-    if (exists($locations{($begin,$end)}))
-    {
-      for my $line (@{$locations{($begin,$end)}})
-      {
-        $tooltip = $tooltip . escape($line) . "\n";
-      }
-    }
-    my $line = $edge;
-    $line =~ s/%begin%/$begin/g;
-    $line =~ s/%end%/$end/g;
-    $line =~ s/%label%/$label/g;
-    $line =~ s/%tooltip%/$tooltip/g;
-    print($line);
-  }
-  print($edges_footer);
-}
-
-sub print_node_order()
-{
-  my $prev = "";
-  print($node_order_header);
-  foreach my $name (sort keys %all_nodes)
-  {
-    if ($prev ne "")
-    {
-      my $begin = $prev;
-      my $end = $all_nodes{$name};
-      my $line = $node_order;
-      $line =~ s/%begin%/$begin/g;
-      $line =~ s/%end%/$end/g;
-      print($line);
-    }
-    $prev = $all_nodes{$name};
-  }
-  foreach my $name (sort keys %pending_nodes)
-  {
-    if ($prev ne "")
-    {
-      my $begin = $prev;
-      my $line = $node_order;
-      $line =~ s/%begin%/$begin/g;
-      $line =~ s/%end%/$name/g;
-      print($line);
-    }
-    last;
-  }
-  print($node_order_footer);
-}
-
-sub generate_dot()
-{
-  print($graph_header);
-  print_nodes();
-  print_anon_nodes();
-  print_pending_nodes();
-  print_edges();
-  print_node_order();
-  print($graph_footer);
-}
-
-#-------------------------------------------------------------------------------
-
-parse_debug_output();
-generate_dot();
diff --git a/third_party/socket.io-client-cpp/lib/asio/asio/tsify.pl b/third_party/socket.io-client-cpp/lib/asio/asio/tsify.pl
deleted file mode 100755
index b871b91..0000000
--- a/third_party/socket.io-client-cpp/lib/asio/asio/tsify.pl
+++ /dev/null
@@ -1,574 +0,0 @@
-#!/usr/bin/perl -w
-
-use strict;
-use File::Path;
-# use Switch;
-
-our $output_dir = "tsified";
-
-sub print_line
-{
-  my ($output, $line, $from, $lineno) = @_;
-
-  # Warn if the resulting line is >80 characters wide.
-  if (length($line) > 80)
-  {
-    if ($from =~ /\.[chi]pp$/)
-    {
-      print("Warning: $from:$lineno: output >80 characters wide.\n");
-    }
-  }
-
-  # Write the output.
-  print($output $line . "\n");
-}
-
-sub source_contains_asio_thread_usage
-{
-  my ($from) = @_;
-
-  # Open the input file.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-
-  # Check file for use of asio::thread.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /asio::thread/)
-    {
-      close($input);
-      return 1;
-    }
-    elsif ($line =~ /^ *thread /)
-    {
-      close($input);
-      return 1;
-    }
-  }
-
-  close($input);
-  return 0;
-}
-
-sub source_contains_asio_include
-{
-  my ($from) = @_;
-
-  # Open the input file.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-
-  # Check file for inclusion of asio.hpp.
-  while (my $line = <$input>)
-  {
-    chomp($line);
-    if ($line =~ /# *include [<"]asio\.hpp[>"]/)
-    {
-      close($input);
-      return 1;
-    }
-  }
-
-  close($input);
-  return 0;
-}
-
-sub copy_source_file
-{
-  my ($from, $to) = @_;
-
-  # Ensure the output directory exists.
-  my $dir = $to;
-  $dir =~ s/[^\/]*$//;
-  mkpath($dir);
-
-  # First determine whether the file makes any use of asio::thread.
-  my $uses_asio_thread = source_contains_asio_thread_usage($from);
-
-  my $includes_asio = source_contains_asio_include($from);
-
-  my $is_asio_hpp = 0;
-  $is_asio_hpp = 1 if ($from =~ /asio\.hpp/);
-
-  my $needs_doc_link = 0;
-  $needs_doc_link = 1 if ($is_asio_hpp);
-
-  my $is_config_hpp = 0;
-  $is_config_hpp = 1 if ($from =~ /asio\/detail\/config\.hpp/);
-
-  my $is_error_hpp = 0;
-  $is_error_hpp = 1 if ($from =~ /asio\/error\.hpp/);
-
-  my $is_impl_src_hpp = 0;
-  $is_impl_src_hpp = 1 if ($from =~ /asio\/impl\/src\.hpp/);
-
-  my $is_test = 0;
-  $is_test = 1 if ($from =~ /tests\/unit/);
-
-  # Open the files.
-  open(my $input, "<$from") or die("Can't open $from for reading");
-  open(my $output, ">$to") or die("Can't open $to for writing");
-
-  # State for stripping out deprecated, extension, and old services code.
-  my $deprecated_state = 0;
-  my $extension_state = 0;
-  my $old_services_state = 0;
-
-  # State for simplifying namespaces in examples.
-  my $code_snippet_state = 0;
-
-  # Copy the content.
-  my $lineno = 1;
-  while (my $line = <$input>)
-  {
-    chomp($line);
-
-    # Strip out deprecated code.
-    if ($deprecated_state == 0)
-    {
-      if ($line =~ /#\s*if\s*defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = 1;
-        next;
-      }
-      elsif ($line =~ /#\s*if\s*!defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = -1;
-        next;
-      }
-    }
-    elsif ($deprecated_state == 1)
-    {
-      if ($line =~ /#\s*else\s*\/\/\s*!*defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = -1;
-        next;
-      }
-      elsif ($line =~ /#\s*endif\s*\/\/\s*!*defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = 0;
-        next;
-      }
-      else
-      {
-        $line =~ s/^# /#/;
-      }
-    }
-    elsif ($deprecated_state == -1)
-    {
-      if ($line =~ /#\s*else\s*\/\/\s*!*defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = 1;
-      }
-      elsif ($line =~ /#\s*endif\s*\/\/\s*!*defined\(ASIO_NO_DEPRECATED\)/)
-      {
-        $deprecated_state = -2;
-      }
-      next;
-    }
-    elsif ($deprecated_state == -2)
-    {
-      $deprecated_state = 0;
-      next if ($line eq "");
-    }
-
-    # Strip out code for extensions.
-    if ($extension_state == 0)
-    {
-      if ($line =~ /#\s*if\s*!defined\(ASIO_NO_EXTENSIONS\)\s*$/)
-      {
-        $extension_state = -1;
-        next;
-      }
-    }
-    elsif ($extension_state == -1)
-    {
-      $extension_state = -2 if ($line =~ /#\s*endif\s*\/\/\s*!defined\(ASIO_NO_EXTENSIONS\)\s*$/);
-      next;
-    }
-    elsif ($extension_state == -2)
-    {
-      $extension_state = 0;
-      next if ($line eq "");
-    }
-
-    # Strip out code for old services.
-    if ($old_services_state == 0)
-    {
-      if ($line =~ /#\s*if\s*defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = -1;
-        next;
-      }
-      elsif ($line =~ /#\s*if\s*!defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = 1;
-        next;
-      }
-    }
-    elsif ($old_services_state == 1)
-    {
-      if ($line =~ /#\s*else\s*\/\/\s*!*defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = -1;
-        next;
-      }
-      elsif ($line =~ /#\s*endif\s*\/\/\s*!*defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = 0;
-        next;
-      }
-      else
-      {
-        $line =~ s/^# /#/;
-      }
-    }
-    elsif ($old_services_state == -1)
-    {
-      if ($line =~ /#\s*else\s*\/\/\s*!*defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = 1;
-      }
-      elsif ($line =~ /#\s*endif\s*\/\/\s*!*defined\(ASIO_ENABLE_OLD_SERVICES\)/)
-      {
-        $old_services_state = -2;
-      }
-      next;
-    }
-    elsif ($old_services_state == -2)
-    {
-      $old_services_state = 0;
-      next if ($line eq "");
-    }
-
-    # Keep track of whether we are in an example.
-    if ($code_snippet_state == 0)
-    {
-      if ($line =~ /\@code/)
-      {
-        $code_snippet_state = 1;
-      }
-    }
-
-    # Unconditional replacements.
-    $line =~ s/[\\@]ref boost_bind/std::bind()/g;
-    if ($from =~ /.*\.txt$/)
-    {
-      $line =~ s/[\\@]ref async_read/std::experimental::net::v1::async_read()/g;
-      $line =~ s/[\\@]ref async_write/std::experimental::net::v1::async_write()/g;
-    }
-    if ($line =~ /asio_detail_posix_thread_function/)
-    {
-      $line =~ s/asio_detail_posix_thread_function/networking_ts_detail_posix_thread_function/g;
-    }
-    if ($line =~ /asio_signal_handler/)
-    {
-      $line =~ s/asio_signal_handler/networking_ts_signal_handler/g;
-    }
-    if ($line =~ /ASIO_/ && !($line =~ /NET_TS_/))
-    {
-      $line =~ s/ASIO_/NET_TS_/g;
-    }
-    if ($line =~ /asio_handler_/)
-    {
-      $line =~ s/asio_handler_/networking_ts_handler_/g;
-    }
-    if ($line =~ /asio_true_handler_/)
-    {
-      $line =~ s/asio_true_handler_/networking_ts_true_handler_/g;
-    }
-
-    # Lines skipped in asio/impl/src.hpp.
-    if ($is_impl_src_hpp)
-    {
-      next if
-        (
-             $line =~ /serial_port/
-          or $line =~ /\/local\//
-          or $line =~ /\/generic\//
-          or $line =~ /signal_set/
-        );
-    }
-
-    # Conditional replacements.
-    if ($line =~ /^(.* *)namespace asio \{/)
-    {
-      print_line($output, $1 . "namespace std {", $from, $lineno);
-      print_line($output, $1 . "namespace experimental {", $from, $lineno);
-      print_line($output, $1 . "namespace net {", $from, $lineno);
-      print_line($output, $1 . "inline namespace v1 {", $from, $lineno);
-    }
-    elsif ($line =~ /^(.* *)} \/\/ namespace asio$/)
-    {
-      print_line($output, $1 . "} // inline namespace v1", $from, $lineno);
-      print_line($output, $1 . "} // namespace net", $from, $lineno);
-      print_line($output, $1 . "} // namespace experimental", $from, $lineno);
-      print_line($output, $1 . "} // namespace std", $from, $lineno);
-    }
-    elsif ($line =~ /^(# *include )[<"](asio\.hpp)[>"]$/)
-    {
-      print_line($output, $1 . "<net>", $from, $lineno);
-      if ($uses_asio_thread)
-      {
-        print_line($output, $1 . "<thread>", $from, $lineno) if (!$is_test);
-        $uses_asio_thread = 0;
-      }
-    }
-    elsif ($line =~ /^(# *include )[<"]boost\/.*[>"].*$/)
-    {
-      if (!$includes_asio && $uses_asio_thread)
-      {
-        print_line($output, $1 . "<thread>", $from, $lineno) if (!$is_test);
-        $uses_asio_thread = 0;
-      }
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /^(# *include )[<"]asio\/thread\.hpp[>"]/)
-    {
-      if ($is_test)
-      {
-        print_line($output, $1 . "<experimental/__net_ts/detail/thread.hpp>", $from, $lineno);
-      }
-      else
-      {
-        # Line is removed.
-      }
-    }
-    elsif ($line =~ /(# *include )[<"]asio\/error_code\.hpp[>"]/)
-    {
-      if ($is_asio_hpp)
-      {
-        # Line is removed.
-      }
-      else
-      {
-        print_line($output, $1 . "<cerrno>", $from, $lineno) if ($is_error_hpp);
-        print_line($output, $1 . "<system_error>", $from, $lineno);
-      }
-    }
-    elsif ($line =~ /# *include [<"]asio\/impl\/error_code\.[hi]pp[>"]/)
-    {
-      # Line is removed.
-    }
-    elsif ($line =~ /(# *include )[<"]asio\/system_error\.hpp[>"]/)
-    {
-      if ($is_asio_hpp)
-      {
-        # Line is removed.
-      }
-      else
-      {
-        print_line($output, $1 . "<system_error>", $from, $lineno);
-      }
-    }
-    elsif ($line =~ /(^.*# *include )[<"]asio\/([^>"]*)[>"](.*)$/)
-    {
-      print_line($output, $1 . "<experimental/__net_ts/" . $2 . ">" . $3, $from, $lineno);
-    }
-    elsif ($line =~ /#.*defined\(.*ASIO_HAS_STD_SYSTEM_ERROR\)$/)
-    {
-      # Line is removed.
-    }
-    elsif ($line =~ /asio::thread\b/)
-    {
-      if ($is_test)
-      {
-        $line =~ s/asio::thread/std::experimental::net::v1::detail::thread/g;
-      }
-      else
-      {
-        $line =~ s/asio::thread/std::thread/g;
-      }
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /^( *)thread( .*)$/)
-    {
-      if ($is_test)
-      {
-        print_line($output, $1 . "std::experimental::net::v1::detail::thread" . $2, $from, $lineno);
-      }
-      else
-      {
-        print_line($output, $1 . "std::thread" . $2, $from, $lineno);
-      }
-    }
-    elsif ($line =~ /asio::/ && !($line =~ /boost::asio::/))
-    {
-      $line =~ s/asio::error_code/std::error_code/g;
-      $line =~ s/asio::error_category/std::error_category/g;
-      $line =~ s/asio::system_category/std::system_category/g;
-      $line =~ s/asio::system_error/std::system_error/g;
-      $line =~ s/asio::/std::experimental::net::v1::/g if $code_snippet_state == 0;
-      $line =~ s/asio::/std::experimental::net::/g if $code_snippet_state == 1;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /using namespace asio/)
-    {
-      $line =~ s/using namespace asio/using namespace std::experimental::net::v1/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /[\\@]ref boost_bind/)
-    {
-      $line =~ s/[\\@]ref boost_bind/std::bind()/g;
-      print_line($output, $line, $from, $lineno);
-    }
-    elsif ($line =~ /define.*DETAIL_CONFIG_HPP/)
-    {
-      print_line($output, $line, $from, $lineno);
-      print_line($output, "", $from, $lineno);
-      print_line($output, "#define NET_TS_STANDALONE 1", $from, $lineno);
-    }
-    else
-    {
-      print_line($output, $line, $from, $lineno);
-    }
-
-    # Keep track of whether we are in an example.
-    if ($code_snippet_state == 1)
-    {
-      if ($line =~ /\@endcode/)
-      {
-        $code_snippet_state = 0;
-      }
-    }
-
-    ++$lineno;
-  }
-
-  # Ok, we're done.
-  close($input);
-  close($output);
-}
-
-sub find_include_files
-{
-  my @root_includes = (
-      "asio/ts/buffer.hpp",
-      "asio/ts/executor.hpp",
-      "asio/ts/internet.hpp",
-      "asio/ts/io_context.hpp",
-      "asio/ts/net.hpp",
-      "asio/ts/netfwd.hpp",
-      "asio/ts/socket.hpp",
-      "asio/ts/timer.hpp");
-
-  my @excluded_includes = (
-      "asio/basic_deadline_timer.hpp",
-      "asio/basic_streambuf.hpp",
-      "asio/basic_streambuf_fwd.hpp",
-      "asio/datagram_socket_service.hpp",
-      "asio/deadline_timer.hpp",
-      "asio/deadline_timer_service.hpp",
-      "asio/io_context_strand.hpp",
-      "asio/detail/strand_service.hpp",
-      "asio/detail/impl/strand_service.hpp",
-      "asio/detail/impl/strand_service.ipp",
-      "asio/socket_acceptor_service.hpp",
-      "asio/seq_packet_socket_service.hpp",
-      "asio/stream_socket_service.hpp",
-      "asio/time_traits.hpp",
-      "asio/waitable_timer_service.hpp");
-
-  my @include_files = ();
-  my %known_includes = ();
-
-  foreach my $include (@root_includes)
-  {
-    $known_includes{$include} = 1;
-    push(@include_files, "include/" . $include);
-  }
-
-  foreach my $include (@excluded_includes)
-  {
-    $known_includes{$include} = 1;
-  }
-
-  my @unprocessed_includes = sort keys %known_includes;
-  while (scalar(@unprocessed_includes) > 0)
-  {
-    my $include = pop(@unprocessed_includes);
-
-    open(my $input, "<include/$include") or die("Can't open include/$include for reading");
-    while (my $line = <$input>)
-    {
-      chomp($line);
-      if ($line =~ /^\s*#\s*include\s*"(asio\/[^"]*)"/)
-      {
-        if (not defined($known_includes{$1}))
-        {
-          $known_includes{$1} = 1;
-          push(@include_files, "include/" . $1);
-          push(@unprocessed_includes, $1);
-        }
-      }
-    }
-    close($input);
-  }
-
-  return @include_files;
-}
-
-sub copy_include_files
-{
-  my @files = find_include_files();
-  push(@files, "include/asio/impl/src.hpp");
-
-  foreach my $file (@files)
-  {
-    if ($file ne "include/asio/thread.hpp"
-        and $file ne "include/asio/error_code.hpp"
-        and $file ne "include/asio/system_error.hpp"
-        and $file ne "include/asio/impl/error_code.hpp"
-        and $file ne "include/asio/impl/error_code.ipp")
-    {
-      my $from = $file;
-      my $to = $file;
-      $to =~ s/^include\/asio\//$output_dir\/include\/experimental\/__net_ts\//;
-      copy_source_file($from, $to);
-    }
-  }
-}
-
-sub create_top_level_includes
-{
-  my @includes = (
-      "buffer",
-      "executor",
-      "internet",
-      "io_context",
-      "net",
-      "netfwd",
-      "socket",
-      "timer");
-
-  our $output_dir;
-  mkpath("$output_dir/include/experimental");
-  foreach my $include (@includes)
-  {
-    open(my $output, ">$output_dir/include/experimental/$include")
-      or die("Can't open $output_dir/include/experimental/$include for writing");
-
-    my $guard = "NET_TS_" . uc($include) . "_INCLUDED";
-
-    print($output "//\n");
-    print($output "// experimental/$include\n");
-    print($output "// " . '~' x length("experimental/" . $include) . "\n");
-    print($output "//\n");
-    print($output "// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)\n");
-    print($output "//\n");
-    print($output "// Distributed under the Boost Software License, Version 1.0. (See accompanying\n");
-    print($output "// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n");
-    print($output "//\n");
-    print($output "\n");
-    print($output "#ifndef $guard\n");
-    print($output "#define $guard\n");
-    print($output "\n");
-    print($output "#include <experimental/__net_ts/ts/$include.hpp>\n");
-    print($output "\n");
-    print($output "#endif // $guard\n");
-
-    close($output);
-  }
-}
-
-copy_include_files();
-create_top_level_includes();
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/.gitignore b/third_party/socket.io-client-cpp/lib/rapidjson/.gitignore
deleted file mode 100644
index 95acb0c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/.gitignore
+++ /dev/null
@@ -1,22 +0,0 @@
-/bin/*
-!/bin/data
-!/bin/encodings
-!/bin/jsonchecker
-/build
-/doc/html
-/doc/doxygen_*.db
-*.a
-
-# Temporary files created during CMake build
-CMakeCache.txt
-CMakeFiles
-cmake_install.cmake
-CTestTestfile.cmake
-Makefile
-RapidJSON*.cmake
-RapidJSON.pc
-Testing
-/googletest
-install_manifest.txt
-Doxyfile
-DartConfiguration.tcl
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/.gitmodules b/third_party/socket.io-client-cpp/lib/rapidjson/.gitmodules
deleted file mode 100644
index 8e9d1f3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "thirdparty/gtest"]
-	path = thirdparty/gtest
-	url = https://chromium.googlesource.com/external/googletest.git
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/.travis.yml b/third_party/socket.io-client-cpp/lib/rapidjson/.travis.yml
deleted file mode 100644
index ac7240d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/.travis.yml
+++ /dev/null
@@ -1,44 +0,0 @@
-language: cpp
-
-compiler:
- - clang
- - gcc
-
-env:
-  matrix:
-    - CONF=debug   ARCH=x86_64
-    - CONF=release ARCH=x86_64
-    - CONF=debug   ARCH=x86
-    - CONF=release ARCH=x86
-  global:
-    - ARCH_FLAGS_x86='-m32'        # #266: don't use SSE on 32-bit
-    - ARCH_FLAGS_x86_64='-msse4.2' #       use SSE4.2 on 64-bit
-    - GITHUB_REPO='miloyip/rapidjson'
-    - secure: "HrsaCb+N66EG1HR+LWH1u51SjaJyRwJEDzqJGYMB7LJ/bfqb9mWKF1fLvZGk46W5t7TVaXRDD5KHFx9DPWvKn4gRUVkwTHEy262ah5ORh8M6n/6VVVajeV/AYt2C0sswdkDBDO4Xq+xy5gdw3G8s1A4Inbm73pUh+6vx+7ltBbk="
-
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -qq cmake doxygen valgrind
-  - if [ "$ARCH" = "x86" ]; then sudo apt-get install -qq g++-multilib libc6-dbg:i386; fi
-
-install: true
-
-before_script:
-#   hack to avoid Valgrind bug (https://bugs.kde.org/show_bug.cgi?id=326469),
-#   exposed by merging PR#163 (using -march=native)
-    - sed -i "s/-march=native//" CMakeLists.txt
-    - mkdir build 
-    - >
-        eval "ARCH_FLAGS=\${ARCH_FLAGS_${ARCH}}" ;
-        (cd build && cmake 
-        -DRAPIDJSON_HAS_STDSTRING=ON
-        -DCMAKE_VERBOSE_MAKEFILE=ON 
-        -DCMAKE_BUILD_TYPE=$CONF 
-        -DCMAKE_CXX_FLAGS="$ARCH_FLAGS" ..)
-
-script:
-  - cd build
-  - make tests
-  - make examples
-  - ctest -V `[ "$CONF" = "release" ] || echo "-E perftest"`
-  - make travis_doc
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/CMakeLists.txt
deleted file mode 100644
index 9c823ac..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/CMakeLists.txt
+++ /dev/null
@@ -1,112 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMakeModules)
-
-PROJECT(RapidJSON CXX)
-
-set(LIB_MAJOR_VERSION "0")
-set(LIB_MINOR_VERSION "12")
-set(LIB_PATCH_VERSION "0")
-set(LIB_VERSION_STRING "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_PATCH_VERSION}")
-
-# compile in release with debug info mode by default
-SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Build Type")
-
-# Build all binaries in a separate directory
-SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-
-option(RAPIDJSON_BUILD_DOC "Build rapidjson documentation." ON)
-option(RAPIDJSON_BUILD_EXAMPLES "Build rapidjson examples." ON)
-option(RAPIDJSON_BUILD_TESTS "Build rapidjson perftests and unittests." ON)
-
-option(RAPIDJSON_HAS_STDSTRING "" OFF)
-if(RAPIDJSON_HAS_STDSTRING)
-    add_definitions(-DRAPIDJSON_HAS_STDSTRING)
-endif()
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wall -Wextra")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native -Wall -Wextra")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
-endif()
-
-#add extra search paths for libraries and includes
-SET(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The directory the headers are installed in")
-SET(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE STRING "Directory where lib will install")
-SET(DOC_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/share/doc/${PROJECT_NAME}" CACHE PATH "Path to the documentation")
-
-IF(UNIX OR CYGWIN)
-    SET(_CMAKE_INSTALL_DIR "${LIB_INSTALL_DIR}/cmake/${PROJECT_NAME}")
-ELSEIF(WIN32)
-    SET(_CMAKE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/cmake")
-ENDIF()
-SET(CMAKE_INSTALL_DIR "${_CMAKE_INSTALL_DIR}" CACHE PATH "The directory cmake fiels are installed in")
-
-include_directories(${CMAKE_SOURCE_DIR}/include)
-
-if(RAPIDJSON_BUILD_DOC)
-    add_subdirectory(doc)
-endif()
-
-add_custom_target(travis_doc)
-add_custom_command(TARGET travis_doc
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/travis-doxygen.sh)
-
-if(RAPIDJSON_BUILD_EXAMPLES)
-    add_subdirectory(example)
-endif()
-
-if(RAPIDJSON_BUILD_TESTS)
-    if(MSVC11)
-        # required for VS2012 due to missing support for variadic templates
-        add_definitions(-D_VARIADIC_MAX=10)
-    endif(MSVC11)
-    add_subdirectory(test)
-    include(CTest)
-endif()
-
-# pkg-config
-IF (UNIX OR CYGWIN)
-  CONFIGURE_FILE (${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.in
-                  ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
-                  @ONLY)
-  INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
-      DESTINATION "${LIB_INSTALL_DIR}/pkgconfig"
-      COMPONENT pkgconfig)
-ENDIF()
-
-install(FILES readme.md
-        DESTINATION "${DOC_INSTALL_DIR}"
-        COMPONENT doc)
-
-install(DIRECTORY include/rapidjson
-    DESTINATION "${INCLUDE_INSTALL_DIR}"
-    COMPONENT dev)
-
-install(DIRECTORY example/
-    DESTINATION "${DOC_INSTALL_DIR}/examples"
-    COMPONENT examples
-    # Following patterns are for excluding the intermediate/object files
-    # from an install of in-source CMake build.
-    PATTERN "CMakeFiles" EXCLUDE
-    PATTERN "Makefile" EXCLUDE
-    PATTERN "cmake_install.cmake" EXCLUDE)
-
-# Provide config and version files to be used by other applications
-# ===============================
-
-export(PACKAGE ${PROJECT_NAME})
-
-# cmake-modules
-CONFIGURE_FILE(${PROJECT_NAME}Config.cmake.in
-    ${PROJECT_NAME}Config.cmake
-    @ONLY)
-CONFIGURE_FILE(${PROJECT_NAME}ConfigVersion.cmake.in
-    ${PROJECT_NAME}ConfigVersion.cmake
-    @ONLY)
-INSTALL(FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
-    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
-    DESTINATION "${CMAKE_INSTALL_DIR}"
-    COMPONENT dev)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/CMakeModules/FindGTestSrc.cmake b/third_party/socket.io-client-cpp/lib/rapidjson/CMakeModules/FindGTestSrc.cmake
deleted file mode 100644
index 89f132e..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/CMakeModules/FindGTestSrc.cmake
+++ /dev/null
@@ -1,22 +0,0 @@
-SET(GTEST_SEARCH_PATH 
-    "${GTEST_SOURCE_DIR}"
-    "${CMAKE_SOURCE_DIR}/thirdparty/gtest")
-
-IF(UNIX)
-    LIST(INSERT GTEST_SEARCH_PATH 1 "/usr/src/gtest")
-ENDIF()
-
-FIND_PATH(GTEST_SOURCE_DIR
-    NAMES CMakeLists.txt src/gtest_main.cc
-    PATHS ${GTEST_SEARCH_PATH})
-
-# Debian installs gtest include directory in /usr/include, thus need to look
-# for include directory separately from source directory.
-FIND_PATH(GTEST_INCLUDE_DIR
-    NAMES gtest/gtest.h
-    PATH_SUFFIXES include
-    PATHS ${GTEST_SEARCH_PATH})
-
-find_package_handle_standard_args(GTestSrc DEFAULT_MSG
-    GTEST_SOURCE_DIR
-    GTEST_INCLUDE_DIR)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSON.pc.in b/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSON.pc.in
deleted file mode 100644
index 7467f97..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSON.pc.in
+++ /dev/null
@@ -1,7 +0,0 @@
-includedir=@INCLUDE_INSTALL_DIR@
-
-Name: @PROJECT_NAME@
-Description: A fast JSON parser/generator for C++ with both SAX/DOM style API
-Version: @LIB_VERSION_STRING@
-URL: https://github.com/miloyip/rapidjson
-Cflags: -I${includedir}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfig.cmake.in b/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfig.cmake.in
deleted file mode 100644
index 9fa1218..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfig.cmake.in
+++ /dev/null
@@ -1,3 +0,0 @@
-get_filename_component(RAPIDJSON_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-set(RAPIDJSON_INCLUDE_DIRS "@INCLUDE_INSTALL_DIR@")
-message(STATUS "RapidJSON found. Headers: ${RAPIDJSON_INCLUDE_DIRS}")
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfigVersion.cmake.in b/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfigVersion.cmake.in
deleted file mode 100644
index 25741fc..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/RapidJSONConfigVersion.cmake.in
+++ /dev/null
@@ -1,10 +0,0 @@
-SET(PACKAGE_VERSION "@LIB_VERSION_STRING@")
-
-IF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
-  SET(PACKAGE_VERSION_EXACT "true")
-ENDIF (PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
-IF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
-  SET(PACKAGE_VERSION_COMPATIBLE "true")
-ELSE (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
-  SET(PACKAGE_VERSION_UNSUITABLE "true")
-ENDIF (NOT PACKAGE_FIND_VERSION VERSION_GREATER PACKAGE_VERSION)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/appveyor.yml b/third_party/socket.io-client-cpp/lib/rapidjson/appveyor.yml
deleted file mode 100644
index d1a9108..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/appveyor.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-version: 0.12.{build}
-
-configuration:
-- Debug
-- Release
-
-environment:
-  matrix:
-  - VS_VERSION: 11
-    VS_PLATFORM: win32
-  - VS_VERSION: 11
-    VS_PLATFORM: x64
-  - VS_VERSION: 12
-    VS_PLATFORM: win32
-  - VS_VERSION: 12
-    VS_PLATFORM: x64
-
-before_build:
-- git submodule update --init --recursive
-- cmake -H. -BBuild/VS -G "Visual Studio %VS_VERSION%" -DCMAKE_GENERATOR_PLATFORM=%VS_PLATFORM% -DBUILD_SHARED_LIBS=true -Wno-dev
-
-build:
-  project: Build\VS\RapidJSON.sln
-  parallel: true
-  verbosity: minimal
-
-test_script:
-- cd Build\VS && if %CONFIGURATION%==Debug (ctest --verbose -E perftest --build-config %CONFIGURATION%) else (ctest --verbose --build-config %CONFIGURATION%)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/glossary.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/glossary.json
deleted file mode 100644
index d6e6ca1..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/glossary.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
-    "glossary": {
-        "title": "example glossary",
-		"GlossDiv": {
-            "title": "S",
-			"GlossList": {
-                "GlossEntry": {
-                    "ID": "SGML",
-					"SortAs": "SGML",
-					"GlossTerm": "Standard Generalized Markup Language",
-					"Acronym": "SGML",
-					"Abbrev": "ISO 8879:1986",
-					"GlossDef": {
-                        "para": "A meta-markup language, used to create markup languages such as DocBook.",
-						"GlossSeeAlso": ["GML", "XML"]
-                    },
-					"GlossSee": "markup"
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/menu.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/menu.json
deleted file mode 100644
index 539c3af..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/menu.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{"menu": {
-    "header": "SVG Viewer",
-    "items": [
-        {"id": "Open"},
-        {"id": "OpenNew", "label": "Open New"},
-        null,
-        {"id": "ZoomIn", "label": "Zoom In"},
-        {"id": "ZoomOut", "label": "Zoom Out"},
-        {"id": "OriginalView", "label": "Original View"},
-        null,
-        {"id": "Quality"},
-        {"id": "Pause"},
-        {"id": "Mute"},
-        null,
-        {"id": "Find", "label": "Find..."},
-        {"id": "FindAgain", "label": "Find Again"},
-        {"id": "Copy"},
-        {"id": "CopyAgain", "label": "Copy Again"},
-        {"id": "CopySVG", "label": "Copy SVG"},
-        {"id": "ViewSVG", "label": "View SVG"},
-        {"id": "ViewSource", "label": "View Source"},
-        {"id": "SaveAs", "label": "Save As"},
-        null,
-        {"id": "Help"},
-        {"id": "About", "label": "About Adobe CVG Viewer..."}
-    ]
-}}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/readme.txt b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/readme.txt
deleted file mode 100644
index eb9ca0c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/readme.txt
+++ /dev/null
@@ -1 +0,0 @@
-sample.json is obtained from http://code.google.com/p/json-test-suite/downloads/detail?name=sample.zip
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/sample.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/sample.json
deleted file mode 100644
index 30930e7..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/sample.json
+++ /dev/null
@@ -1,3315 +0,0 @@
-{
- "a": {
-  "6U閆崬밺뀫颒myj츥휘:$薈mY햚#rz飏+玭V㭢뾿愴YꖚX亥ᮉ푊\u0006垡㐭룝\"厓ᔧḅ^Sqpv媫\"⤽걒\"˽Ἆ?ꇆ䬔未tv{DV鯀Tἆl凸g\\㈭ĭ즿UH㽤": null,
-  "b茤z\\.N": [[
-   "ZL:ￄዎ*Y|猫劁櫕荾Oj为1糕쪥泏S룂w࡛Ᏺ⸥蚙)",
-   {
-    "\"䬰ỐwD捾V`邀⠕VD㺝sH6[칑.:醥葹*뻵倻aD\"": true,
-    "e浱up蔽Cr෠JK軵xCʨ<뜡癙Y獩ｹ齈X/螗唻?<蘡+뷄㩤쳖3偑犾&\\첊xz坍崦ݻ鍴\"嵥B3㰃詤豺嚼aqJ⑆∥韼@\u000b㢊\u0015L臯.샥": false,
-    "l?Ǩ喳e6㔡$M꼄I,(3᝝縢,䊀疅뉲B㴔傳䂴\u0088㮰钘ꜵ!ᅛ韽>": -5514085325291784739,
-    "o㮚?\"춛㵉<\/﬊ࠃ䃪䝣wp6ἀ䱄[s*S嬈貒pᛥ㰉'돀": [{
-     "(QP윤懊FI<ꃣ『䕷[\"珒嶮?%Ḭ壍಻䇟0荤!藲끹bd浶tl\u2049#쯀@僞": {"i妾8홫": {
-      ",M맃䞛K5nAㆴVN㒊햬$n꩑&ꎝ椞阫?/ṏ세뉪1x쥼㻤㪙`\"$쟒薟B煌܀쨝ଢ଼2掳7㙟鴙X婢\u0002": "Vዉ菈᧷⦌kﮞఈnz*<?੃'ahhCFX(\u0007⮊E㭍䱾Gxꥩr❣.洎",
-      "뻴5bDD큯O傆盓왻U?ꞅꐊN鐭᧢τ\"迳豲8\u001b䃥ꂻ䴺ྸH筴,": {
-       "\"L鸔SE㬡XV&~͎'놅蔞눶l匛?'.K氁\\ƢẨ疇mΊ'꽳&!鹠m'|{P痊 秄쒿u\u00111䋧gϩx7t丗D䊨䠻z0.A0": -1.50139930144708198E18,
-       "8鋂뛷?첒B☚>﷜FM\"荭7ꍀ-VR<\/';䁙E9$䩉\f @s?퍪o3^衴cඎ䧪aK鼟ｑ䆨c{䳠5mᒲՙ蘹ᮩ": {
-        "F㲷JGo⯍P덵x뒳p䘧☔\"+ꨲ吿JfR㔹)4n紬G练Q፞!C|": true,
-        "p^㫮솎oc.೚A㤠??r\u000f)⾽⌲們M2.䴘䩳:⫭胃\\፾@Fᭌ\\K": false,
-        "蟌Tk愙潦伩": {
-         "a<\/@ᾛ慂侇瘎": -7271305752851720826,
-         "艓藬/>၄ṯ,XW~㲆w": {"E痧郶)㜓ha朗!N赻瞉駠uC\u20ad辠<Ve?폱!Im䁎搄:*s 9諚Prᵾ뒰髶B̌qWA8梸vS⫊⢳{t㺲q㺈랊뮣RqK밢쳪": [
-          false,
-          {
-           "\u000b=>x퓮⣫P1ࠫLMMX'M刼唳됤": null,
-           "P쓫晥%k覛ዩIUᇸ滨:噐혲lMR5䋈V梗>%幽u頖\\)쟟": null,
-           "eg+昉~矠䧞难\b?gQ쭷筝\\eꮠNl{ಢ哭|]Mn銌╥zꖘzⱷ⭤ᮜ^": [
-            -1.30142114406914976E17,
-            -1.7555215491128452E-19,
-            null,
-            "渾㨝ߏ牄귛r?돌?w[⚞ӻ~廩輫㼧/",
-            -4.5737191805302129E18,
-            null,
-            "xy࿑M[oc셒竓Ⓔx?뜓y䊦>-D켍(&&?XKkc꩖ﺸᏋ뵞K伕6ী)딀P朁yW揙?훻魢傎EG碸9類៌g踲C⟌aEX舲:z꒸许",
-            3808159498143417627,
-            null,
-            {"m試\u20df1{G8&뚈h홯J<\/": {
-             "3ஸ厠zs#1K7:rᥞoꅔꯧ&띇鵼鞫6跜#赿5l'8{7㕳(b/j\"厢aq籀ꏚ\u0015厼稥": [
-              -2226135764510113982,
-              true,
-              null,
-              {
-               "h%'맞S싅Hs&dl슾W0j鿏MםD놯L~S-㇡R쭬%": null,
-               "⟓咔謡칲\u0000孺ꛭx旑檉㶆?": null,
-               "恇I転;￸B2Y`z\\獓w,놏濐撐埵䂄)!䶢D=ഭ㴟jyY": {
-                "$ࡘt厛毣ൢI芁<겿骫⫦6tr惺a": [
-                 6.385779736989334E-20,
-                 false,
-                 true,
-                 true,
-                 [
-                  -6.891946211462334E-19,
-                  null,
-                  {
-                   "]-\\Ꟑ1/薓❧Ὂ\\l牑\u0007A郃)阜ᇒᓌ-塯`W峬G}SDb㬨Q臉⮻빌O鞟톴첂B㺱<ƈmu챑J㴹㷳픷Oㆩs": {
-                    "\"◉B\"pᶉt骔J꩸ᄇᛐi╰栛K쉷㉯鐩!㈐n칍䟅難>盥y铿e୔蒏M貹ヅ8嘋퀯䉶ጥ㏢殊뻳\"絧╿ꉑ䠥?∃蓊{}㣣Gk긔H1哵峱": false,
-                    "6.瀫cN䇮F㧺?\\椯=ڈT䘆4␘8qv": -3.5687501019676885E-19,
-                    "Q?yऴr혴{஀䳘p惭f1ﹸ䅷䕋贲<ྃᄊ繲hq\\b|#QSTs1c-7(䵢\u2069匏絘ꯉ:l毴汞t戀oෟᵶ뮱፣-醇Jx䙬䐁햢0࣫ᡁgrㄛ": "\u0011_xM/蘇Chv;dhA5.嗀绱V爤ﰦi뵲M",
-                    "⏑[\"ugoy^儣횎~U\\섯겜論l2jw஌yD腅̂\u0019": true,
-                    "ⵯɇ䐲᫿࢚!㯢l샅笶戮1꣖0Xe": null,
-                    "劅f넀識b宁焊E찓橵G!ʱ獓뭔雩괛": [{"p⹣켙[q>燣䍃㞽ᩲx:쓤삘7玑퇼0<\/q璂ᑁ[Z\\3䅵䧳\u0011㤧|妱緒C['췓Yꞟ3Z鳱雼P錻BU씧U`ᢶg蓱>.1ӧ譫'L_5V䏵Ц": [
-                     false,
-                     false,
-                     {"22䂍盥N霂얢<F8꼵7Gసyh뀍g᦭ꄢx硴嬢\u001a?E괆T|;7犟\"Wt%䐩O⨵t&#ᬋK'蜍Ძ揔⾠鲂T멷靃\u0018䓞cE": {"f=䏏츜瞾zw?孡鏣\\铀᫞yẆg(\u0011M6(s2]`ਫ": [[[{
-                      "'y몱纣4S@\\,i㷯럹Ua充Tᣢ9躘Zଞ쥿䐊s<\/刎\\\"뉦-8/": "蜑.X0꭛낢륹i젨ꚁ<8?s볕蝡|Q✬᯦@\\G㑢屿Mn졾J굤⥟JW뤵苑r쁕툄嵵?⾥O",
-                      "^1挲~[n귆誈央碠멪gI洷": -8214236471236116548,
-                      "sሣ%娌暡clr蟜㑓2\u000bS❟_X㨔⚴5~蔷ꀇ|Xu㬖,꤭卹r(g믇쩍%췸앙|栣U\\2]䤉+啠菡ꯎT鉹m\n/`SzDᅼ鞶": 1.1217523390167132E-19,
-                      "u톇=黚\\ ꂮ췵L>躰e9⑩_뵜斌n@B}$괻Yᐱ@䧋V\"☒-諯cV돯ʠ": true,
-                      "Ű螧ᔼ檍鍎땒딜qꄃH뜣<獧ूCY吓⸏>XQ㵡趌o끬k픀빯a(ܵ甏끆୯/6Nᪧ}搚ᆚ짌P牰泱鈷^d꣟#L삀\"㕹襻;k㸊\\f+": true,
-                      "쎣\",|⫝̸阊x庿k잣v庅$鈏괎炔k쬪O_": [
-                       "잩AzZGz3v愠ꉈⵎ?㊱}S尳௏p\r2>췝IP䘈M)w|\u000eE",
-                       -9222726055990423201,
-                       null,
-                       [
-                        false,
-                        {"´킮'뮤쯽Wx讐V,6ᩪ1紲aႈ\u205czD": [
-                         -930994432421097536,
-                         3157232031581030121,
-                         "l貚PY䃛5@䭄<nW\u001e",
-                         [
-                          3.801747732605161E18,
-                          [
-                           null,
-                           false,
-                           {
-                            "": 4.0442013775147072E16,
-                            "2J[sᡪ㞿|n'#廲꯬乞": true,
-                            "B[繰`\\㏏a̼㨀偛㽓<\/꥖ᵈO让\r43⡩徑ﬓ๨ﮕx:㣜o玐ꉟぢC珵὆ᓞ쇓Qs氯였9駵q혃Ljꂔ<\/昺+t䐋༻猙c沪~櫆bpJ9UᏐ:칣妙!皗F4㑄탎䕀櫳振讓": 7.3924182188256287E18,
-                            "H磵ai委曷n柋T<\/勿F&:ꣴfU@㿗榻Lb+?퍄sp\"᪟~>귻m㎮琸f": 1.0318894506812084E-19,
-                            "࢜⩢Ш䧔1肽씮+༎ᣰ闺馺窃䕨8Mƶq腽xc(៯夐J5굄䕁Qj_훨/~価.䢵慯틠퇱豠㼇Qﵘ$DuSp(8Uญ<\/ಟ룴𥳐ݩ$": 8350772684161555590,
-                            "ㆎQ䄾\u001bpᩭ${[諟^^骴᤮b^ㅥI┧T㉇⾞\"绦<AYJ⒃-oF<\/蛎mm;obh婃ᦢ": false,
-                            "䔤䣈?汝.p襟&d㱅\\Jᚠ@?O첁ࢽ휔VR蔩|㒢柺": [[
-                             "-ꕨ岓棻r@鿆^3~䪤Ѐ狼︌ﹲ\\᝸MlE쵠Q+",
-                             null,
-                             false,
-                             3346674396990536343,
-                             null,
-                             {
-                              "": null,
-                              "/䏨S쨑,&繷㉥8C엮赸3馢|뇲{鄎ꗇqFﶉ雕UD躢?Ꟛအ꽡[hᕱᗅ㦋쭞Mユ茍?L槽암V#성唐%㣕嘵\\ڹ(嘏躿&q": [
-                               -1364715155337673920,
-                               false,
-                               -8197733031775379251,
-                               "E팗鮲JwH\\觡܈᜝\"+뉞娂N휗v噙၂깼\u001dD帒l%-斔N",
-                               -3.844267973858711E-20,
-                               [{"쬯(褈Q 蟚뿢 /ⱖ㻥\u0017/?v邘䃡0U.Z1x?鯔V尠8Em<": [[[
-                                null,
-                                [
-                                 null,
-                                 -5841406347577698873,
-                                 "킷\"S⋄籞繗솸ᵣ浵w쑿ퟗ7nᎏx3앙z㘌쿸I葥覯㬏0ᆝb汆狺뷘ႀnꋋ",
-                                 -1227911573141158702,
-                                 {
-                                  "u㉮PᾺV鵸A\\g*ࡗ9슟晭+ͧↀ쿅H\u001c꾣犓}癇恛ᗬ黩䟘X梑鐆e>r䰂f矩'-7䡭桥Dz兔V9谶居㺍ᔊ䩯덲.\u001eL0ὅㅷ釣": [{
-                                   "<쯬J卷^숞u࠯䌗艞R9닪g㐾볎a䂈歖意:%鐔|ﵤ|y}>;2,覂⶚啵tb*仛8乒㓶B࿠㯉戩oX 貘5V嗆렽낁߼4h䧛ꍺM空\\b꿋貼": 8478577078537189402,
-                                   "VD*|吝z~h譺aᯒ": {
-                                    "YI췢K<\/濳xNne玗rJo쾘3핰鴊\"↱AR:ࢷ\"9?\"臁說)?誚ꊏe)_D翾W?&F6J@뺾ꍰNZ醊Z쾈വH嶿?炫㷱鬰M겈<bS}㎥l|刖k": {"H7鷮퇢_k": [
-                                     true,
-                                     "s㟑瀭좾쮀⑁Y찺k맢戲쀸俻ກ6儮끗扖puߖꜻ馶rꈞ痘?3ྚ畊惘䎗\"vv)*臔웅鿈䧲^v,껛㰙J <ᚶ5",
-                                     7950276470944656796,
-                                     4.9392301536234746E17,
-                                     -4796050478201554639,
-                                     "yꬴc<3㻚",
-                                     "o塁\u20a4蒵鮬裢CᴧnB㭱f.",
-                                     false,
-                                     [
-                                      false,
-                                      "㡐弑V?瀆䰺q!출㇞yᘪ꼼(IS~Ka 烿ꟿ샕桤\u0005HQҹ㯪罂q萾⚇懋⦕둡v",
-                                      1862560050083946970,
-                                      "\u20b6[|(뭹gꍒ펉O轄Dl묽]ﯨ髯QEbA㒾m@롴礠㕓2땫n6ْ엘঵篳R잷꙲m색摪|@㿫5aK设f胭r8/NI4춫栵\\꯬2]",
-                                      false,
-                                      {
-                                       "\u000b7*㙛燏.~?䔊p搕e_拺艿뷍f{ꔻ1s驙`$Ė戧?q⋬沭?塷᭚蹀unoa5": {
-                                        "S귯o紞㾕ᅶ侏銇12|ʟ畴iNAo?|Sw$M拲գ㭄紧螆+,梔": null,
-                                        "㭚0?xB疱敻ேBPwv뾃熉(ӠpJ]갢\"Bj'\u0016GE椱<\/zgៅx黢礇h},M9ﴦ?LḨ": "Si B%~㬒E",
-                                        "핇㉊살㍢숨~ȪRo䦅D桺0z]﬽蠆c9ᣨyPP㿷U~㞐?쯟퍸宒뉆U|}㉓郾ࣻ*櫎꼪䁗s?~7\u001e㘔h9{aឋ}:㶒P8": [{"\\R囡쐬nN柋琍؛7칾 :㶃衇徜V 深f1淍♠i?3S角폞^ᆞ\u20e8ṰD\u0007秡+躒臔&-6": {
-                                         "䨑g.fh㔗=8!\"狿ൻLU^뻱g䲚㻐'W}k欤?๒鲇S꧗䫾$ĥ피": -794055816303360636,
-                                         "外頮詋~텡竆繃䏩苨뾺朁꼃瘹f*㉀枙NH/\u2027ꢁ}j묎vペq︉식뜡Od5 N顯ି烅仟Qfㆤ嚢(i䬅c;맧?嶰㩼츱獡?-": {
-                                          "e݆㍡⬬'2㻒?U篲鿄\"隻Ҭ5NꭰꤺBꀈ拾᩺[刯5곑Na램ﴦ዆]㝓qw钄\u001b\"Y洊䗿祏塥迵[⼞⠳P$꠱5먃0轢`": [{"獰E賝﫚b먭N긆Ⰹ史2逶ꜛ?H짉~?P}jj}侷珿_T>᭨b,⻁鈵P䕡䀠८ⱄ홎鄣": {
-                                           "@?k2鶖㋮\"Oರ K㨇廪儲\u0017䍾J?);\b*묀㗠섳햭1MC V": null,
-                                           "UIICP!BUA`ᢈ㋸~袩㗪⾒=fB﮴l1ꡛ죘R辂여ҳ7쮡<䩲`熕8頁": 4481809488267626463,
-                                           "Y?+8먙ᚔ鋳蜩럶1㥔y璜౩`": [
-                                            null,
-                                            1.2850335807501874E-19,
-                                            "~V2",
-                                            2035406654801997866,
-                                            {
-                                             "<숻1>\"": -8062468865199390827,
-                                             "M㿣E]}qwG莎Gn᝶(ꔙ\\D⬲iꇲs寢t駇S뀡ꢜ": false,
-                                             "pꝤ㎏9W%>M;-U璏f(^j1?&RB隧 忓b똊E": "#G?C8.躬ꥯ'?냪#< 渟&헿란zpo왓Kj}鷧XﻘMツb䕖;㪻",
-                                             "vE풤幉xz뱕쫥Ug㦲aH} ᣟp:鬼Yᰟ<Fɋ잣緂頒⺏䉲瑑䅂,C~ޅG!f熢-B7~9Pqࡢ[츑#3ꕎ,Öඳ聁⩅㵧춀뿍xy䌏͂tdj!箧᳆|9蚡돬": -2.54467378964089632E17,
-                                             "䵈䅦5빖,궆-:໿댾仫0ᙚyᦝhqᚄ": null,
-                                             "侯Y\"湛졯劇U셎YX灍ⅸ2伴|筧\\䁒㶶᷏쁑Waᦵᗱ㜏늾膠<Jc63<G\u20fe䇹66僣k0O\"_@U": null,
-                                             "姪y$#s漴JH璌Ӊ脛J㝾펔ﹴoꈶ㚸PD:薠쏖%說ថ蹂1］⾕5튄": {
-                                              "᝾Huw3䮅如쿺䍟嫝]<鰨ݷ?꯯䫓傩|ᐶස媽\\澒≡闢": "Mm\"쏇ᯄ졽\"楇<\/ꥆ흭局n隴@鿣w⠊4P贈徎W㊋;䤞'.팇蒁䡴egpx嗎wஅ獗堮ᛐnˁ︖䀤4噙?໚郝᱋ޘॎt恑姫籕殥陃\"4[ꝬqL4Wꠎx",
-                                              "ℇj遌5B뒚\" U": "硄ꏘ{憠굏:&t䌨m Cઌ쿣鞛XFꠟs䝭ﶃ\"格a0x闊昵吲L\\杚聈aꁸj싹獅\"灟ﱡ馆*굖糠<ꔏ躎",
-                                              "톌賠弳ꟍb\"螖X50sĶ晠3f秂坯Iⓟ:萘": 5.573183333596288E18,
-                                              "%䴺": [[[[
-                                               -6957233336860166165,
-                                               false,
-                                               null,
-                                               {
-                                                "\"\\௮茒袀ᕥ23ୃ괶?䕎.嚲◉㏞L+ᵡ艱hL콇붆@": null,
-                                                "%螥9ꭌ<\/-t": true,
-                                                ",9|耢椸䁓Xk죱\u0015$Ώ鲞[?엢ᝲ혪즈ⴂ▂ℴ㗯\"g뺘\\ꍜ#\u0002ヮ}ሎ芲P[鹮轧@냲䃦=#(": 2.78562909315899616E17,
-                                                "R?H䧰ⵇ<,憰쮼Q總iR>H3镔ᴚ斦\\鏑r*2橱G⼔F/.j": true,
-                                                "RK좬뎂a홠f*f㱉ᮍ⦋潙㨋Gu곌SGI3I뿐\\F',)t`荁蘯囯ﮉ裲뇟쥼_ገ驪▵撏ᕤV": 1.52738225997956557E18,
-                                                "^k굲䪿꠹B逤%F㱢漥O披M㽯镞竇霒i꼂焅륓\u00059=皫之눃\u2047娤閍銤唫ၕb<\/w踲䔼u솆맚,䝒ᝳ'/it": "B餹饴is権ꖪ怯ꦂẉဎt\"!凢谵⧿0\\<=(uL䷍刨쑪>俆揓Cy襸Q힆䆭涷<\/ᐱ0ɧ䗾䚹\\ኜ?ꄢᇘ`䴢{囇}᠈䴥X4퓪檄]ꥷ/3謒ሴn+g騍X",
-                                                "GgG꽬[(嫓몍6\u0004궍宩㙻/>\u0011^辍dT腪hxǑ%ꊇk,8(W⧂結P鬜O": [{
-                                                 "M㴾c>\\ᓲ\u0019V{>ꤩ혙넪㭪躂TS-痴໸闓⍵/徯O.M㏥ʷD囎⧔쁳휤T??鉬뇙=#ꢫ숣BX䭼<\/d똬졬g榿)eꨋﯪ좇첻<?2K)": null,
-                                                 "Z17縬z]愀䖌 ᾋBCg5딒국憍꾓aⲷ턷u:U촳驿?雺楶\u0001\u001c{q*ᰗ苑B@k揰z.*蓗7ረIm\"Oᱍ@7?_": true,
-                                                 "㺃Z<": -4349275766673120695,
-                                                 "휃䠂fa塆ffixKe'덬鏗੄뺾w࠾鑎k땢m*႑햞鐮6攊&虜h黚,Y䱳Sﭼ둺pN6": [
-                                                  false,
-                                                  "IΎ䣲,\"ᬮ˪癘P~Qlnx喁Sᮔ༬˨I珌m䜛酛\u0003iꐸ㦧cQ帲晼D' \\(粋wQcN\\뵰跈",
-                                                  [
-                                                   "D0\\L?M1쥍Kaꏌsd+盌귤憊tz䌣댐בO坂wϢ%ὒgp,Ai⎧ᶆI餾ꦍ棩嘅᳉怴%m]ၶis纖D凜镧o심b U",
-                                                   {
-                                                    "?଼\u0011Rv&^[+匚I趈T媫\u0010.䥤ᆯ1q僤HydⲰl㒽K'ᅾiౕ豲초딨@\u0013J'쪪VD౼P4Ezg#8*㋤W馓]c쿯8": false,
-                                                    "c/擯X5~JmK䵶^쐎ച|B|u[솝(X뚤6v}W㤘⠛aR弌臌쾭諦eⒷ僡-;㩩⭖ⷴ徆龄갬{䱓ᥩ!﯏⊚ᇨ<v燡露`:볉癮꨽り★Ax7Ꮀ譥~舑\\Vꍋ\"$)v": "e&sFF쬘OBd슊寮f蠛জ봞mn~锆竒G脁\"趵G刕䕳&L唽붵<\/I,X팚B⍥X,kԇҗ眄_慡:U附ᓚA蕧>\u001a\u0011\";~쓆BH4坋攊7힪",
-                                                    "iT:L闞椕윚*滛gI≀Wਟඊ'ꢆ縺뱹鮚Nꩁ᧬蕼21줧\\䋯``⍐\\㏱鳨": 1927052677739832894,
-                                                    "쮁缦腃g]礿Y㬙 fヺSɪ꾾N㞈": [
-                                                     null,
-                                                     null,
-                                                     {
-                                                      "!t,灝Y 1䗉罵?c饃호䉂Cᐭ쒘z(즽sZG㬣sഖE4뢜㓕䏞丮Qp簍6EZឪ겛fx'ꩱQ0罣i{k锩*㤴㯞r迎jTⲤ渔m炅肳": [
-                                                       -3.3325685522591933E18,
-                                                       [{"㓁5]A䢕1룥BC?Ꙍ`r룔Ⳛ䙡u伲+\u0001്o": [
-                                                        null,
-                                                        4975309147809803991,
-                                                        null,
-                                                        null,
-                                                        {"T팘8Dﯲ稟MM☻㧚䥧/8ﻥ⥯aXLaH\"顾S☟耲ît7fS෉놁뮔/ꕼ䓈쁺4\\霶䠴ᩢ<\/t4?죵>uD5➶༆쉌럮⢀秙䘥\u20972ETR3濡恆vB? ~鸆\u0005": {
-                                                         "`閖m璝㥉b뜴?Wf;?DV콜\u2020퍉౓擝宏ZMj3mJ먡-傷뱙yח㸷꥿ ໘u=M읝!5吭L4v\\?ǎ7C홫": null,
-                                                         "|": false,
-                                                         "~Ztᛋ䚘\\擭㗝傪W陖+㗶qᵿ蘥ᙄp%䫎)}=⠔6ᮢS湟-螾-mXH?cp": 448751162044282216,
-                                                         "\u209fad놹j檋䇌ᶾ梕㉝bוּ<d䗱:줰M酄\u0000X#_r獢A饓ꍗُKo_跔?ᪧ嵜鼲<": null,
-                                                         "ꆘ)ubI@h@洭Ai㜎䏱k\u0003?T䉐3间%j6j棍j=❁\\U毮ᬹ*8䀔v6cpj⭬~Q꿾뺶펵悡!쩭厝l六㽫6퇓ޭ2>": {"?苴ꩠD䋓帘5騱qﱖPF?☸珗顒yU ᡫcb䫎 S@㥚gꮒ쎘泴멖\\:I鮱TZ듒ᶨQ3+f7캙\"?\f풾\\o杞紟﻽M.⏎靑OP": [
-                                                          -2.6990368911551596E18,
-                                                          [{"䒖@<᰿<\/⽬tTr腞&G%᳊秩蜰擻f㎳?S㵧\r*k뎾-乢겹隷j軛겷0룁鮁": {")DO0腦:춍逿:1㥨่!蛍樋2": [{
-                                                           ",ꌣf侴笾m๫ꆽ?1?U?\u0011ꌈꂇ": {
-                                                            "x捗甠nVq䅦w`CD⦂惺嘴0I#vỵ} \\귂S끴D얾?Ԓj溯\"v餄a": {
-                                                             "@翙c⢃趚痋i\u0015OQ⍝lq돆Y0pࢥ3쉨䜩^<8g懥0w)]䊑n洺o5쭝QL댊랖L镈Qnt⪟㒅십q헎鳒⮤眉ᔹ梠@O縠u泌ㄘb榚癸XޔFtj;iC": false,
-                                                             "I&뱋゘|蓔䔕측瓯%6ᗻHW\\N1貇#?僐ᗜgh᭪o'䗈꽹Rc욏/蔳迄༝!0邔䨷푪8疩)[쭶緄㇈୧ፐ": {
-                                                              "B+:ꉰ`s쾭)빼C羍A䫊pMgjdx䐝Hf9᥸W0!C樃'蘿f䫤סи\u0017Jve? 覝f둀⬣퓉Whk\"஼=չﳐ皆笁BIW虨쫓F廰饞": -642906201042308791,
-                                                              "sb,XcZ<\/m㉹ ;䑷@c䵀s奤⬷7`ꘖ蕘戚?Feb#輜}p4nH⬮eKL트}": [
-                                                               "RK鳗z=袤Pf|[,u욺",
-                                                               "Ẏᏻ罯뉋⺖锅젯㷻{H䰞쬙-쩓D]~\u0013O㳢gb@揶蔉|kᦂ❗!\u001ebM褐sca쨜襒y⺉룓",
-                                                               null,
-                                                               null,
-                                                               true,
-                                                               -1.650777344339075E-19,
-                                                               false,
-                                                               "☑lꄆs힨꤇]'uTന⌳농].1⋔괁沰\"IWഩ\u0019氜8쟇䔻;3衲恋,窌z펏喁횗?4?C넁问?ᥙ橭{稻Ⴗ_썔",
-                                                               "n?]讇빽嗁}1孅9#ꭨ靶v\u0014喈)vw祔}룼쮿I",
-                                                               -2.7033457331882025E18,
-                                                               {
-                                                                ";⚃^㱋x:饬ኡj'꧵T☽O㔬RO婎?향ᒭ搩$渣y4i;(Q>꿘e8q": "j~錘}0g;L萺*;ᕭꄮ0l潛烢5H▄쳂ꏒוֹꙶT犘≫x閦웧v",
-                                                                "~揯\u2018c4職렁E~ᑅቚꈂ?nq뎤.:慹`F햘+%鉎O瀜쟏敛菮⍌浢<\/㮺紿P鳆ࠉ8I-o?#jﮨ7v3Dt赻J9": null,
-                                                                "ࣝW䌈0ꍎqC逖,횅c၃swj;jJS櫍5槗OaB>D踾Y": {"㒰䵝F%?59.㍈cᕨ흕틎ḏ㋩B=9IېⓌ{:9.yw｝呰ㆮ肒᎒tI㾴62\"ዃ抡C﹬B<\/<EO꽓ᇕu&鋫\\禞퐹u꒍.7훯ಶ2䩦͉ᶱf깵ᷣ늎": [
-                                                                 5.5099570884646902E18,
-                                                                 "uQN濿m臇<%?谣鮢s]]x0躩慌闋<;( 鋤.0ᠵd1#벘a:Gs?햷'.)ㅴ䞟琯崈FS@O㌛ᓬ抢큌ើ냷쿟툥IZn[惵ꐧ3뙍[&v憙J>촋jo朣",
-                                                                 [
-                                                                  -7675533242647793366,
-                                                                  {"ᙧ呃:[㒺쳀쌡쏂H稈㢤\u001dᶗGG-{GHྻຊꡃ哸䵬;$?&d\\⥬こN圴됤挨-'ꕮ$PU%?冕눖i魁q騎Q": [
-                                                                   false,
-                                                                   [[
-                                                                    7929823049157504248,
-                                                                    [[
-                                                                     true,
-                                                                     "Z菙\u0017'eꕤ᱕l,0\\X\u001c[=雿8蠬L<\/낲긯W99g톉4ퟋb㝺\u0007劁'!麕Q궈oW:@X၎z蘻m絙璩귓죉+3柚怫tS捇蒣䝠-擶D[0=퉿8)q0ٟ",
-                                                                     "唉\nFA椭穒巯\\䥴䅺鿤S#b迅獘 ﶗ꬘\\?q1qN犠pX꜅^䤊⛤㢌[⬛휖岺q唻ⳡ틍\"㙙Eh@oA賑㗠y必Nꊑᗘ",
-                                                                     -2154220236962890773,
-                                                                     -3.2442003245397908E18,
-                                                                     "Wᄿ筠:瘫퀩?o貸q⊻(᎞KWf宛尨h^残3[U(='橄",
-                                                                     -7857990034281549164,
-                                                                     1.44283696979059942E18,
-                                                                     null,
-                                                                     {"ꫯAw跭喀 ?_9\"Aty背F=9缉ྦྷ@;?^鞀w:uN㘢Rỏ": [
-                                                                      7.393662029337442E15,
-                                                                      3564680942654233068,
-                                                                      [
-                                                                       false,
-                                                                       -5253931502642112194,
-                                                                       "煉\\辎ೆ罍5⒭1䪁䃑s䎢:[e5}峳ﴱn騎3?腳Hyꏃ膼N潭錖,Yᝋ˜YAၓ㬠bG렣䰣:",
-                                                                       true,
-                                                                       null,
-                                                                       {
-                                                                        "⒛'P&%죮|:⫶춞": -3818336746965687085,
-                                                                        "钖m<\/0ݎMtF2Pk=瓰୮洽겎.": [[
-                                                                         -8757574841556350607,
-                                                                         -3045234949333270161,
-                                                                         null,
-                                                                         {
-                                                                          "Ꮬr輳>⫇9hU##w@귪A\\C 鋺㘓ꖐ梒뒬묹㹻+郸嬏윤'+g<\/碴,}ꙫ>손;情d齆J䬁ຩ撛챝탹/R澡7剌tꤼ?ặ!`⏲睤\u00002똥଴⟏": null,
-                                                                          "\u20f2ܹe\\tAꥍư\\x当뿖렉禛;G檳ﯪS૰3~㘠#[J<}{奲 5箉⨔{놁<\/釿抋,嚠/曳m&WaOvT赋皺璑텁": [[
-                                                                           false,
-                                                                           null,
-                                                                           true,
-                                                                           -5.7131445659795661E18,
-                                                                           "萭m䓪D5|3婁ఞ>蠇晼6nﴺPp禽羱DS<睓닫屚삏姿",
-                                                                           true,
-                                                                           [
-                                                                            -8759747687917306831,
-                                                                            {
-                                                                             ">ⓛ\t,odKr{䘠?b퓸C嶈=DyEᙬ@ᴔ쨺芛髿UT퓻春<\/yꏸ>豚W釺N뜨^?꽴﨟5殺ᗃ翐%>퍂ဿ䄸沂Ea;A_\u0005閹殀W+窊?Ꭼd\u0013P汴G5썓揘": 4.342729067882445E-18,
-                                                                             "Q^즾眆@AN\u0011Kb榰냎Y#䝀ꀒᳺ'q暇睵s\"!3#I⊆畼寤@HxJ9": false,
-                                                                             "⿾D[)袨㇩i]웪䀤ᛰMvR<蟏㣨": {"v퇓L㪱ꖣ豛톤\\곱#kDTN": [{
-                                                                              "(쾴䡣,寴ph(C\"㳶w\"憳2s馆E!n!&柄<\/0Pꈗſ?㿳Qd鵔": {"娇堰孹L錮h嵅⛤躏顒?CglN束+쨣ﺜ\\MrH": {"獞䎇둃ቲ弭팭^ꄞ踦涟XK錆쳞ឌ`;੶S炥騞ଋ褂B៎{ڒ䭷ᶼ靜pI荗虶K$": [{"◖S~躘蒉꫿輜譝Q㽙闐@ᢗ¥E榁iء5┄^B[絮跉ᰥ遙PWi3wㄾⵀDJ9!w㞣ᄎ{듒ꓓb6\\篴??c⼰鶹⟧\\鮇ꮇ": [[
-                                                                               654120831325413520,
-                                                                               -1.9562073916357608E-19,
-                                                                               {
-                                                                                "DC(昐衵ἡ긙갵姭|֛[t": 7.6979110359897907E18,
-                                                                                "J␅))嫼❳9Xfd飉j7猬ᩉ+⤻眗벎E鰉Zﾶ63zၝ69}ZᶐL崭ᦥ⡦靚⋛ꎨ~i㨃咊ꧭo䰠阀3C(": -3.5844809362512589E17,
-                                                                                "p꣑팱쒬ꎑ뛡Ꙩ挴恍胔&7ᔈ묒4Hd硶훐㎖zꢼ豍㿢aሃ=<\/湉鵲EӅ%$F!퍶棌孼{O駍਺geu+": ")\u001b잓kŀX쩫A밁®ڣ癦狢)扔弒p}k縕ꩋ,䃉tࣼi",
-                                                                                "ァF肿輸<솄G-䢹䛸ꊏl`Tqꕗ蒞a氷⸅ᴉ蠰]S/{J왲m5{9.uέ~㕚㣹u>x8U讁B덺襪盎QhVS맅킃i识{벂磄Iහ䙅xZy/抍૭Z鲁-霳V据挦ℒ": null,
-                                                                                "㯛|Nꐸb7ⵐb?拠O\u0014ކ?-(EꞨ4ꕷᄤYᯕOW瞺~螸\"욿ќ<u鵵઎⸊倾쑷෻rT⪄牤銱;W殆͢芄ਰ嚝훚샢⊿+㲽": null,
-                                                                                "単逆ົ%_맛d)zJ%3칧_릟#95䌨怡\u001ci턠ॣi冘4赖'ਐ䧐_栔!": {
-                                                                                 "*?2~4㲌᭳쯁ftႷ1#oJ\b䊇镇됔 \u2079x䛁㊝ᮂN;穽跖s휇ᣄ홄傷z⸷(霸!3y뺏M쒿햏۽v㳉tở心3黎v쭻 Rp཮Vr~T?&˴k糒븥쩩r*D": null,
-                                                                                 "8@~홟ꔘk1[": -5570970366240640754,
-                                                                                 "BZt鏦ꡬc餖  s(mᛴ\u0000◄d腑t84C⟐坯VṊ뉙'噱Ꝕ珽GC顀?허0ꞹ&돇䛭C䷫](": 2.4303828213012387E-20,
-                                                                                 "y撔Z외放+}ḑ骈ᙝ&\u0016`G便2|-e]঳?QF㜹YF\"㿒緄햷㈟塚䷦ୀጤlM蘸N㾆▛럪㞂tᕬ镈쇝喠l amcxPnm\u001a᱋<\/]_]ﻹ瞧?H": false,
-                                                                                 "ፏ氏묢뜚I[♺뽛x?0H봬Wpn꨹Ra䝿쌑{㴂ni祻윸A'y|⺴ᚘ庌9{$恲{톽=m#@6ᨧfgs44陎J#<Ễ쨓瀵❩a୛㷉㙉ܸ◠냔嬯~呄籁羥镳": false,
-                                                                                 "㘱{<頬22?IF@곊I겂嶻L᝛D{@r쒂?IAᣧ洪惒誸b徂z췺꾍㠭\\刊%禨쌐ⶣ仵\\P[:47;<ᇅ<\/": {
-                                                                                  "^U釳-v㢈ꗝ◄菘rᜨi;起kR犺䵫\u0000锍쁙m-ԙ!lḃ꛸뻾F(W귛y": "#ᠺH㸢5v8_洑C",
-                                                                                  "䔵໳$ᙠ6菞\u206e摎q圩P|慍sV4:㜾(I溞I?": -6569206717947549676,
-                                                                                  "透Ꞃ緵퇝8 >e㺰\"'㌢ƐW\u0004瞕>0?V鷵엳": true,
-                                                                                  "뤥G\\迋䠿[庩'꼡\u001aiᩮV쯁ᳪ䦪Ô;倱ନ뛁誈": null,
-                                                                                  "쥹䄆䚟Q榁䎐᢭<\/2㕣p}HW蟔|䃏꿈ꚉ锳2Pb7㙑Tⅹᵅ": {
-                                                                                   "Y?֭$>#cVBꩨ:>eL蒁務": {
-                                                                                    "86柡0po 䏚&-捑Ћ祌<\/휃-G*㶢הּ쩍s㶟餇c걺yu꽎還5*턧簕Og婥SꝐ": null,
-                                                                                    "a+葞h٥ࠆ裈嗫ﵢ5輙퀟ᛜ,QDﹼ⟶Y騠锪E_|x죗j侵;m蜫轘趥?븅w5+mi콛L": {
-                                                                                     ";⯭ﱢ!买F⽍柤鶂n䵣V㫚墱2렾ELEl⣆": [
-                                                                                      true,
-                                                                                      -3.6479311868339015E-18,
-                                                                                      -7270785619461995400,
-                                                                                      3.334081886177621E18,
-                                                                                      2.581457786298155E18,
-                                                                                      -6.605252412954115E-20,
-                                                                                      -3.9232347037744167E-20,
-                                                                                      {
-                                                                                       "B6㊕.k1": null,
-                                                                                       "ZAꄮJ鮷ᳱo갘硥鈠䠒츼": {
-                                                                                        "ᕅ}럡}.@y陪鶁r業'援퀉x䉴ﵴl퍘):씭脴ᥞhiꃰblﲂ䡲엕8߇M㶭0燋標挝-?PCwe⾕J碻Ᾱ䬈䈥뷰憵賣뵓痬+": {"a췩v礗X⋈耓ፊf罅靮!㔽YYᣓw澍33⎔芲F|\"䜏T↮輦挑6ᓘL侘?ￆ]덆1R௯✎餘6ꏽ<\/௨\\?q喷ꁫj~@ulq": {"嗫欆뾔Xꆹ4H㌋F嵧]ࠎ]㠖1ꞤT<$m뫏O i댳0䲝i": {"?෩?\u20cd슮|ꯆjs{?d7?eNs⢚嫥氂䡮쎱:鑵롟2hJꎒﯭ鱢3춲亄:뼣v䊭諱Yj択cVmR䩃㘬T\"N홝*ै%x^F\\_s9보zz4淗?q": [
-                                                                                         null,
-                                                                                         "?",
-                                                                                         2941869570821073737,
-                                                                                         "{5{殇0䝾g6밖퍋臩綹R$䖭j紋釰7sXI繳漪행y",
-                                                                                         false,
-                                                                                         "aH磂?뛡#惇d婅?Fe,쐘+늵䍘\"3r瘆唊勐j⳧࠴ꇓ<\/唕윈x⬌讣䋵%拗ᛆⰿ妴᝔M2㳗必꧂淲?ゥ젯檢<8끒MidX䏒3᳻Q▮佐UT|⤪봦靏⊏",
-                                                                                         [[{
-                                                                                          "颉(&뜸귙{y^\"P퟉춝Ჟ䮭D顡9=?}Y誱<$b뱣RvO8cH煉＠tk~4ǂ⤧⩝屋SS;J{vV#剤餓ᯅc?#a6D,s": [
-                                                                                           -7.8781018564821536E16,
-                                                                                           true,
-                                                                                           [
-                                                                                            -2.28770899315832371E18,
-                                                                                            false,
-                                                                                            -1.0863912140143876E-20,
-                                                                                            -6282721572097446995,
-                                                                                            6767121921199223078,
-                                                                                            -2545487755405567831,
-                                                                                            false,
-                                                                                            null,
-                                                                                            -9065970397975641765,
-                                                                                            [
-                                                                                             -5.928721243413937E-20,
-                                                                                             {"6촊\u001a홯kB0w撨燠룉{绎6⳹!턍贑y▾鱧ժ[;7ᨷ∀*땒䪮1x霆Hᩭ☔\"r䝐7毟ᝰr惃3ꉭE+>僒澐": [
-                                                                                              "Ta쎩aƝt쵯ⰪVb",
-                                                                                              [
-                                                                                               -5222472249213580702,
-                                                                                               null,
-                                                                                               -2851641861541559595,
-                                                                                               null,
-                                                                                               4808804630502809099,
-                                                                                               5657671602244269874,
-                                                                                               "5犲﨣4mᥣ?yf젫꾯|䋬잁$`Iⳉﴷ扳兝,'c",
-                                                                                               false,
-                                                                                               [
-                                                                                                null,
-                                                                                                {
-                                                                                                 "DyUIN쎾M仼惀⮥裎岶泭lh扠\u001e礼.tEC癯튻@_Qd4c5S熯A<\/＼6U윲蹴Q=%푫汹\\\u20614b[௒C⒥Xe⊇囙b,服3ss땊뢍i~逇PA쇸1": -2.63273619193485312E17,
-                                                                                                 "Mq꺋貘k휕=nK硍뫞輩>㾆~἞ࡹ긐榵l⋙Hw뮢帋M엳뢯v⅃^": 1877913476688465125,
-                                                                                                 "ᶴ뻗`~筗免⚽টW˃⽝b犳䓺Iz篤p;乨A\u20ef쩏?疊m㝀컩뫡b탔鄃ᾈV(遢珳=뎲ିeF仢䆡谨8t0醄7㭧瘵⻰컆r厡궥d)a阄፷Ed&c﯄伮1p": null,
-                                                                                                 "⯁w4曢\"(欷輡": "\"M᭫]䣒頳B\\燧ࠃN㡇j姈g⊸⺌忉ꡥF矉স%^",
-                                                                                                 "㣡Oᄦ昵⫮Y祎S쐐級㭻撥>{I$": -378474210562741663,
-                                                                                                 "䛒掷留Q%쓗1*1J*끓헩ᦢ﫫哉쩧EↅIcꅡ\\?ⴊl귛顮4": false,
-                                                                                                 "寔愆샠5]䗄IH贈=d﯊/偶?ॊn%晥D視N򗘈'᫂⚦|X쵩넽z질tskxDQ莮Aoﱻ뛓": true,
-                                                                                                 "钣xp?&\u001e侉/y䴼~?U篔蘚缣/I畚?Q绊": -3034854258736382234,
-                                                                                                 "꺲໣眀)⿷J暘pИfAV삕쳭Nꯗ4々'唄ⶑ伻㷯騑倭D*Ok꧁3b␽_<\/챣Xm톰ၕ䆄`*fl㭀暮滠毡?": [
-                                                                                                  "D男p`V뙸擨忝븪9c麺`淂⢦Yw⡢+kzܖ\fY1䬡H歁)벾Z♤溊-혰셢?1<-\u0005;搢Tᐁle\\ᛵߓﭩ榩<QF;t=?Qꀞ",
-                                                                                                  [
-                                                                                                   null,
-                                                                                                   [{"-췫揲ᬨ墊臸<ࠒH跥 㔭쥃㫯W=z[wধ╌<~yW楄S!⑻h즓lĖN￧篌W듷튗乵᪪템먵Pf悥ᘀk䷭焼\\讄r擁鐬y6VF<\/6랿p)麡ꁠ㪁\"pழe": [
-                                                                                                    "#幎杴颒嶈)ㄛJ.嶤26_⋌东챯ꠉ⤋ؚ/⏚%秼Q룠QGztﾺ㎷អI翰Xp睔鍜ꨍ",
-                                                                                                    {",T?": [
-                                                                                                     false,
-                                                                                                     [[
-                                                                                                      true,
-                                                                                                      7974824014498027996,
-                                                                                                      false,
-                                                                                                      [
-                                                                                                       4.3305464880956252E18,
-                                                                                                       {
-                                                                                                        "᱿W^A]'rᮢ)鏥z餝;Hu\\Fk?ﴺ?IG浅-䙧>訝-xJ;巡8깊蠝ﻓU$K": {
-                                                                                                         "Vꕡ諅搓W=斸s︪vﲜ츧$)iꡟ싉e寳?ጭムVથ嵬i楝Fg<\/Z|៪ꩆ-5'@ꃱ80!燱R쇤t糳]罛逇dṌ֣XHiͦ{": true,
-                                                                                                         "Ya矲C멗Q9膲墅携휻c\\딶G甔<\/.齵휴": -1.1456247877031811E-19,
-                                                                                                         "z#.OO￝J": -8263224695871959017,
-                                                                                                         "崍_3夼ᮟ1F븍뽯ᦓ鴭V豈Ь": [{
-                                                                                                          "N蒬74": null,
-                                                                                                          "yuB?厅vK笗!ᔸcXQ旦컶P-녫mﾵ麟_": "1R@ 톘xa_|﩯遘s槞d!d껀筤⬫薐焵먑D{\\6k共倌☀G~AS_D\"딟쬚뮥馲렓쓠攥WTMܭ8nX㩴䕅檹E\u0007ﭨN 2 ℆涐ꥏ꠵3▙玽|됨_\u2048",
-                                                                                                          "恐A C䧩G": {":M큣5e들\\ꍀ恼ᔄ靸|I﨏$)n": {
-                                                                                                           "|U䬫㟯SKV6ꛤ㗮\bn봻䲄fＸT:㾯쳤'笓0b/ೢC쳖?2浓uO.䰴": "ཐ꼋e?``,ᚇ慐^8ꜙNM䂱\u0001IᖙꝧM'vKdꌊH牮r\\O@䊷ᓵ쀆(fy聻i툺\"?<\/峧ࣞ⓺ᤤ쵒߯ꎺ騬?)刦\u2072l慪y꺜ﲖTj+u",
-                                                                                                           "뽫<G;稳UL⸙q2n쵿C396炿J蓡z⣁zဩSOU?<\/뙍oE큸O鿅෴ꍈEm#\"[瑦⤫ᝆgl⡗q8\"큘덥係@ᆤ=\u0001爖羝췀㸩b9\\jeqt㟿㮸龾m㳳긄": {
-                                                                                                            "9\"V霟釜{/o0嫲C咀-饷䈍[녩)\r䤴tMW\\龟ϣ^ي㪙忩䞞N湆Y笕)萨ꖤ誥煽:14⫻57U$擒䲐薡Qvↇ櫲현誧?nஷ6": {"l웾䌵.䅋䦝ic碳g[糲Ƿ-ឈᚱ4쑧\u0004C࿼\u0018&쬑?멲<\/fD_檼픃pd쪼n㕊渪V䛉m揈W儅톳뗳䓆7㭽諤T煠Ney?0᪵鈑&": [
-                                                                                                             false,
-                                                                                                             null,
-                                                                                                             {
-                                                                                                              "\r;鼶j᠂꼍RLz~♔9gf?ӡ浐": -1.4843072575250897E-19,
-                                                                                                              "&ꊒ\"ꋟ䝭E诮ﯚO?SW뒁훪mb旙⎕ᗕ⶙|ᷤ5y4甥": "j5|庠t铱?v 횋0\"'rxz䃢杺Ɜ!\u0002",
-                                                                                                              "Q ၩ㟧": {"Hﬔ\u2058䪠틙izZㅛ탟H^ﶲA??R6呠Z솋R.࿶g8": [
-                                                                                                               -8762672252886298799,
-                                                                                                               -1.9486830507000208E17,
-                                                                                                               null,
-                                                                                                               -7157359405410123024,
-                                                                                                               null,
-                                                                                                               null,
-                                                                                                               -995856734219489233,
-                                                                                                               "呧㫹A4!",
-                                                                                                               null,
-                                                                                                               -1.9105609358624648E-19,
-                                                                                                               5888184370445333848,
-                                                                                                               2.25460605078245E-19,
-                                                                                                               2.5302739297121987E18,
-                                                                                                               "뢹sbEf捵2丯?뗾耸(Wd띙SବꭖrtU?筤P똙QpbbKqaE$来V웰3i/lK퉜,8︸e= g螓t竦컼?.寋8鵗",
-                                                                                                               7377742975895263424,
-                                                                                                               2.4218442017790503E-19,
-                                                                                                               {
-                                                                                                                "y꒚ཫ쨘醬킃糟}yTSt䡀⇂뿽4ൢ戰U": [[
-                                                                                                                 3600537227234741875,
-                                                                                                                 4435474101760273035,
-                                                                                                                 -1.42274517007951795E18,
-                                                                                                                 -5567915915496026866,
-                                                                                                                 null,
-                                                                                                                 null,
-                                                                                                                 [
-                                                                                                                  -3204084299154861161,
-                                                                                                                  {
-                                                                                                                   "7梧慸憏.a瘎\u00041U鵮Ck֨d惥耍ⳡY,⭏써E垁FFI鱑ⳬ줢7⧵Bﴠ耘줕햸q컴~*瑍W.떛ࡆ@'᐀+轳": -961121410259132975,
-                                                                                                                   "⥅]l黭㣓绶;!!⎃=朼㐿e&ἂ繤C﯀l䝣㌀6TM쑮w懃ꡡ#ᤆ䰓,墼湼゙뽸㲿䧽쫨xᵖ듨<\/ T0峸iQ:溫脐\\\"쎪ὴ砇宖^M泼큥➅鈫@ᄟ༩\u2008⥼": true,
-                                                                                                                   "⩐\"籽汎P싯鲘蟼sRᐯ䅩\u0019R(kRᖁ&ಌ 0\"鳶!馼YH": null,
-                                                                                                                   "鮼ꚇ싋։刟\rRLd步Nⴗ5Eࡆ訛갚[I醵NC(郴ṉy5D뤺౳QY壯5苴y훨(W\\Cଇ姚C艄깹\u001c歷㋵ZC᥂": [
-                                                                                                                    -6806235313106257498,
-                                                                                                                    null,
-                                                                                                                    "}N⸿讽sꚪ;\\p繇j苄䫨\u20e7%5x?t#",
-                                                                                                                    {
-                                                                                                                     "O〗k<墻yV$ఁrs-c1ఌ唪.C7_Yobᦜ褷'b帰mㄑl⌅": {"qB뗗擄3隂5뺍櫂䱟e촸P/鏩,3掁ꗩ=冉棓㑉|˞F襴뿴,:㞦<퓂⧙礞♗g뚎ᛩ<\/뉽ⶳ⸻A?_x2I㽝勒*I홱鍧粿~曟㤙2绥Ly6+썃uu鿜בf큘|歍ࣖÉ": [
-                                                                                                                      ">hh䈵w>1ⲏ쐭V[ⅎ\\헑벑F_㖝⠗㫇h恽;῝汰ᱼ瀖J옆9RR셏vsZ柺鶶툤r뢱橾/ꉇ囦FGm\"謗ꉦ⨶쒿⥡%]鵩#ᖣ_蹎 u5|祥?O",
-                                                                                                                      null,
-                                                                                                                      2.0150326776036215E-19,
-                                                                                                                      null,
-                                                                                                                      true,
-                                                                                                                      false,
-                                                                                                                      true,
-                                                                                                                      {"\fa᭶P捤WWc᠟f뚉ᬏ퓗ⳀW睹5:HXH=q7x찙X$)모r뚥ᆟ!Jﳸf": [
-                                                                                                                       -2995806398034583407,
-                                                                                                                       [
-                                                                                                                        6441377066589744683,
-                                                                                                                        "Mﶒ醹i)Gἦ廃s6몞 KJ౹礎VZ螺费힀\u0000冺업{谥'꡾뱻:.ꘘ굄奉攼Di᷑K鶲y繈욊阓v㻘}枭캗e矮1c?휐\"4\u0005厑莔뀾墓낝⽴洗ṹ䇃糞@b1\u0016즽Y轹",
-                                                                                                                        {
-                                                                                                                         "1⽕⌰鉟픏M㤭n⧴ỼD#%鐘⊯쿼稁븣몐紧ᅇ㓕ᛖcw嬀~ഌ㖓(0r⧦Q䑕髍ര铂㓻R儮\"@ꇱm❈௿᦯頌8}㿹犴?xn잆꥽R": 2.07321075750427366E18,
-                                                                                                                         "˳b18㗈䃟柵Z曆VTAu7+㛂cb0﯑Wp執<\/臋뭡뚋刼틮荋벲TLP预庰܈G\\O@VD'鱃#乖끺*鑪ꬳ?Mޞdﭹ{␇圯쇜㼞顄︖Y홡g": [{
-                                                                                                                          "0a,FZ": true,
-                                                                                                                          "2z̬蝣ꧦ驸\u0006L↛Ḣ4๚뿀'?lcwᄧ㐮!蓚䃦-|7.飑挴.樵*+1ﮊ\u0010ꛌ%貨啺/JdM:똍!FBe?鰴㨗0O财I藻ʔWA᫓G쳛u`<\/I": [{
-                                                                                                                           "$τ5V鴐a뾆両環iZp頻යn븃v": -4869131188151215571,
-                                                                                                                           "*즢[⦃b礞R◚nΰꕢH=귰燙[yc誘g䆌?ଜ臛": {
-                                                                                                                            "洤湌鲒)⟻\\䥳va}PeAMnＮ[": "㐳ɪ/(軆lZR,Cp殍ȮN啷\"3B婴?i=r$펽ᤐ쀸",
-                                                                                                                            "阄R4㒿㯔ڀ69ZᲦ2癁핌噗P崜#\\-쭍袛&鐑/$4童V꩑_ZHA澢fZ3": {"x;P{긳:G閉:9?活H": [
-                                                                                                                             "繺漮6?z犞焃슳\">ỏ[Ⳛ䌜녏䂹>聵⼶煜Y桥[泥뚩MvK$4jtﾛ",
-                                                                                                                             "E#갶霠좭㦻ୗ먵F+䪀o蝒ba쮎4X㣵 h",
-                                                                                                                             -335836610224228782,
-                                                                                                                             null,
-                                                                                                                             null,
-                                                                                                                             [
-                                                                                                                              "r1᫩0>danjY짿bs{",
-                                                                                                                              [
-                                                                                                                               -9.594464059325631E-23,
-                                                                                                                               1.0456894622831624E-20,
-                                                                                                                               null,
-                                                                                                                               5.803973284253454E-20,
-                                                                                                                               -8141787905188892123,
-                                                                                                                               true,
-                                                                                                                               -4735305442504973382,
-                                                                                                                               9.513150514479281E-20,
-                                                                                                                               "7넳$螔忷㶪}䪪l짴\u0007鹁P鰚HF銏ZJﳴ/⍎1ᷓ忉睇ᜋ쓈x뵠m䷐窥Ꮤ^\u0019ᶌ偭#ヂt☆၃pᎍ臶䟱5$䰵&๵分숝]䝈뉍♂坎\u0011<>",
-                                                                                                                               "C蒑貑藁lﰰ}X喇몛;t밿O7/᯹f\u0015kI嘦<ዴ㟮ᗎZ`GWퟩ瑹࡮ᅴB꿊칈??R校s脚",
-                                                                                                                               {
-                                                                                                                                "9珵戬+AU^洘拻ቒy柭床'粙XG鞕᠜繀伪%]hC,$輙?Ut乖Qm떚W8઼}~q⠪rU䤶CQ痗ig@#≲t샌f㈥酧l;y闥ZH斦e⸬]j⸗?ঢ拻퀆滌": null,
-                                                                                                                                "畯}㧢J罚帐VX㨑>1ꢶkT⿄蘥㝑o|<嗸層沈挄GEOM@-䞚䧰$만峬輏䠱V✩5宸-揂D'㗪yP掶7b⠟J㕻SfP?d}v㼂Ꮕ'猘": {
-                                                                                                                                 "陓y잀v>╪": null,
-                                                                                                                                 "鬿L+7:됑Y=焠U;킻䯌잫!韎ஔ\f": {
-                                                                                                                                  "駫WmGጶ": {
-                                                                                                                                   "\\~m6狩K": -2586304199791962143,
-                                                                                                                                   "ႜࠀ%͑l⿅D.瑢Dk%0紪dḨTI픸%뗜☓s榗኉\"?V籄7w髄♲쟗翛歂E䤓皹t ?)ᄟ鬲鐜6C": {
-                                                                                                                                    "_췤a圷1\u000eB-XOy缿請∎$`쳌eZ~杁튻/蜞`塣৙\"⪰\"沒l}蕌\\롃荫氌.望wZ|o!)Hn獝qg}": null,
-                                                                                                                                    "kOSܧ䖨钨:಼鉝ꭝO醧S`십`ꓭ쭁ﯢN&Et㺪馻㍢ⅳ㢺崡ຊ蜚锫\\%ahx켨|ż劻ꎄ㢄쐟A躊᰹p譞綨Ir쿯\u0016ﵚOd럂*僨郀N*b㕷63z": {
-                                                                                                                                     ":L5r+T㡲": [{
-                                                                                                                                      "VK泓돲ᮙRy㓤➙Ⱗ38oi}LJቨ7Ó㹡৘*q)1豢⛃e᫛뙪壥镇枝7G藯g㨛oI䄽 孂L缊ꋕ'EN`": -2148138481412096818,
-                                                                                                                                      "`⛝ᘑ$(खꊲ⤖ᄁꤒ䦦3=)]Y㢌跨NĴ驳줟秠++d孳>8ᎊ떩EꡣSv룃 쯫أ?#E|᭙㎐?zv:5祉^⋑V": [
-                                                                                                                                       -1.4691944435285607E-19,
-                                                                                                                                       3.4128661569395795E17,
-                                                                                                                                       "㐃촗^G9佭龶n募8R厞eEw⺡_ㆱ%⼨D뉄퉠2ꩵᛅⳍ搿L팹Lවn=\"慉념ᛮy>!`g!풲晴[/;?[v겁軇}⤳⤁핏∌T㽲R홓遉㓥",
-                                                                                                                                       "愰_⮹T䓒妒閤둥?0aB@㈧g焻-#~跬x<\/舁P݄ꐡ=\\׳P\u0015jᳪᢁq;㯏l%᭗;砢觨▝,謁ꍰGy?躤O黩퍋Y㒝a擯\n7覌똟_䔡]fJ晋IAS",
-                                                                                                                                       4367930106786121250,
-                                                                                                                                       -4.9421193149720582E17,
-                                                                                                                                       null,
-                                                                                                                                       {
-                                                                                                                                        ";ﾸ똾柉곟ⰺKpፇ䱻ฺ䖝{o~h!ｅꁿ઻욄ښ\u0002y?xUd\u207c悜ꌭ": [
-                                                                                                                                         1.6010824122815255E-19,
-                                                                                                                                         [
-                                                                                                                                          "宨︩9앉檥pr쇷?WxLb",
-                                                                                                                                          "氇9】J玚\u000f옛呲~ 輠1D嬛,*mW3?n휂糊γ虻*ᴫ꾠?q凐趗Ko↦GT铮",
-                                                                                                                                          "㶢ថmO㍔k'诔栀Z蛟}GZ钹D",
-                                                                                                                                          false,
-                                                                                                                                          -6.366995517736813E-20,
-                                                                                                                                          -4894479530745302899,
-                                                                                                                                          null,
-                                                                                                                                          "V%᫡II璅䅛䓎풹ﱢ/pU9se되뛞x梔~C)䨧䩻蜺(g㘚R?/Ự[忓C뾠ࢤc왈邠买?嫥挤풜隊枕",
-                                                                                                                                          ",v碍喔㌲쟚蔚톬៓ꭶ",
-                                                                                                                                          3.9625444752577524E-19,
-                                                                                                                                          null,
-                                                                                                                                          [
-                                                                                                                                           "kO8란뿒䱕馔b臻⍟隨\"㜮鲣Yq5m퐔<u뷆c譆\u001bN?<",
-                                                                                                                                           [{
-                                                                                                                                            ";涉c蒀ᴧN䘱䤳 ÿꭷ,핉dSTDB>K#ꢘug㼈ᝦ=P^6탲@䧔%$CqSw铜랊0&m⟭<\/a逎ym\u0013vᯗ": true,
-                                                                                                                                            "洫`|XN뤮\u0018詞=紩鴘_sX)㯅鿻Ố싹": 7.168252736947373E-20,
-                                                                                                                                            "ꛊ饤ﴏ袁(逊+~⽫얢鈮艬O힉7D筗S곯w操I斞᠈븘蓷x": [[[[
-                                                                                                                                             -7.3136069426336952E18,
-                                                                                                                                             -2.13572396712722688E18,
-                                                                                                                                             {
-                                                                                                                                              "硢3㇩R:o칢行E<=\u0018ၬYuH!\u00044U%卝炼2>\u001eSi$⓷ꒈ'렢gᙫ番ꯒ㛹럥嶀澈v;葷鄕x蓎\\惩+稘UEᖸﳊ㊈壋N嫿⏾挎,袯苷ኢ\\x|3c": 7540762493381776411,
-                                                                                                                                              "?!*^ᢏ窯?\u0001ڔꙃw虜돳FgJ?&⨫*uo籤:?}ꃹ=ٴ惨瓜Z媊@ત戹㔏똩Ԛ耦Wt轁\\枒^\\ꩵ}}}ꀣD\\]6M_⌫)H豣:36섘㑜": {
-                                                                                                                                               ";홗ᰰU஋㙛`D왔ཿЃS회爁\u001b-㢈`봆?盂㛣듿ᦾ蒽_AD~EEຆ㊋(eNwk=Rɠ峭q\"5Ἠ婾^>'ls\n8QAK<l_⭨穟": [
-                                                                                                                                                true,
-                                                                                                                                                true,
-                                                                                                                                                {"ﳷm箅6qⷈ?ﲈ憟b۷⫉἞V뚴少U呡瓴ꉆs~嘵得㌶4XR漊": [
-                                                                                                                                                 "폆介fM暪$9K[ㄇ샍큳撦g撟恸jҐF㹹aj bHᘀ踉ꎐＣ粄 a?\u000fK즉郝 幨9D舢槷Xh뵎u훩Ꜿ턾ƅ埂P埆k멀{䢹~?D<\/꼢XR\u001b〱䝽꼨i㘀ḟ㚺A-挸",
-                                                                                                                                                 false,
-                                                                                                                                                 null,
-                                                                                                                                                 -1.1710758021294953E-20,
-                                                                                                                                                 3996737830256461142,
-                                                                                                                                                 true,
-                                                                                                                                                 null,
-                                                                                                                                                 -8271596984134071193,
-                                                                                                                                                 "_1G퉁텑m䮔鰼6멲Nmꇩſt쓟튍N许FDj+3^ﶜ⎸\u0019⤕橥!\"s-뾞lz北׸ꍚ랬)?l⻮고i䑰\u001f䪬",
-                                                                                                                                                 4.459124464204517E-19,
-                                                                                                                                                 -4.0967172848578447E18,
-                                                                                                                                                 5643211135841796287,
-                                                                                                                                                 -9.482336221192844E-19,
-                                                                                                                                                 "౪冏釶9D?s螭X榈枸j2秀v]泌鰚岒聵轀쌶i텽qMbL]R,",
-                                                                                                                                                 null,
-                                                                                                                                                 [
-                                                                                                                                                  null,
-                                                                                                                                                  {"M쪊ꯪ@;\u0011罙ꕅ<e᝺|爑Yⵝ<\/&ᩎ<腊ሑᮔ੃F豭": [
-                                                                                                                                                   "^0࡟1볏P폋ፏ杈F⨥Iꂴ\"z磣VⅡ=8퀝2]䢹h1\u0017{jT<I煛5%D셍S⑙⅏J*샐 巙ດ;᧡䙞",
-                                                                                                                                                   [{
-                                                                                                                                                    "'㶡큾鄧`跊\"gV[?u᭒Ʊ髷%葉굵a띦N켧Qﯳy%y䩟髒L䯜S䵳r絅肾킂ၐ'ꔦg긓a'@혔যW谁ᝬF栩ŷ+7w鞚": 6.3544416675584832E17,
-                                                                                                                                                    "苎脷v改hm쏵|㋊g_ᔐ 뒨蹨峟썎㷸|Ο刢?Gͨ옛-?GꦱIEYUX4?%ꘋᆊ㱺": -2.8418378709165287E-19,
-                                                                                                                                                    "誰?(H]N맘]k洳\"q蒧蘞!R퐫\\(Q$T5N堍⫣윿6|럦속︅ﭗ(": [
-                                                                                                                                                     "峩_\u0003A瘘?✓[硫䎯ၽuጭ\"@Y綅첞m榾=贮9R벿῜Z",
-                                                                                                                                                     null,
-                                                                                                                                                     "䰉㗹㷾Iaᝃqcp쓘὾൫Q|ﵓ<\/ḙ>)- Q䲌mo펹L_칍樖庫9꩝쪹ᘹ䑖瀍aK ?*趤f뭓廝p=磕",
-                                                                                                                                                     "哑z懅ᤏ-ꍹux쀭",
-                                                                                                                                                     [
-                                                                                                                                                      true,
-                                                                                                                                                      3998739591332339511,
-                                                                                                                                                      "ጻ㙙?᳸aK<\/囩U`B3袗ﱱ?\"/k鏔䍧2l@쿎VZ쨎/6ꃭ脥|B?31+on颼-ꮧ,O嫚m ࡭`KH葦:粘i]aSU쓙$쐂f+詛頖b",
-                                                                                                                                                      [{"^<9<箝&絡;%i﫡2攑紴\\켉h쓙-柂䚝ven\u20f7浯-Ꮏ\r^훁䓚헬\u000e?\\ㅡֺJ떷VOt": [{
-                                                                                                                                                       "-௄卶k㘆혐஽y⎱㢬sS઄+^瞥h;ᾷj;抭\u0003밫f<\/5Ⱗ裏_朻%*[-撵䷮彈-芈": {
-                                                                                                                                                        "㩩p3篊G|宮hz䑊o곥j^Co0": [
-                                                                                                                                                         653239109285256503,
-                                                                                                                                                         {"궲?|\":N1ۿ氃NZ#깩:쇡o8킗ࡊ[\"됸Po핇1(6鰏$膓}⽐*)渽J'DN<썙긘毦끲Ys칖": {
-                                                                                                                                                          "2Pr?Xjㆠ?搮/?㓦柖馃5뚣Nᦼ|铢r衴㩖\"甝湗ܝ憍": "\"뾯i띇筝牻$珲/4ka $匝휴译zbAᩁꇸ瑅&뵲衯ꎀᆿ7@ꈋ'ᶨH@ᠴl+",
-                                                                                                                                                          "7뢽뚐v?4^ꊥ_⪛.>pởr渲<\/⢕疻c\"g䇘vU剺dஔ鮥꒚(dv祴X⼹\\a8y5坆": true,
-                                                                                                                                                          "o뼄B욞羁hr﷔폘뒚⿛U5pꪴfg!6\\\"爑쏍䢱W<ﶕ\\텣珇oI/BK뺡'谑♟[Ut븷亮g(\"t⡎有?ꬊ躺翁艩nl F⤿蠜": 1695826030502619742,
-                                                                                                                                                          "ۊ깖>ࡹ햹^ⵕ쌾BnN〳2C䌕tʬ]찠?ݾ2饺蹳ぶꌭ訍\"◹ᬁD鯎4e滨T輀ﵣ੃3\u20f3킙D瘮g\\擦+泙ၧ 鬹ﯨַ肋7놷郟lP冝{ߒhড়r5,꓋": null,
-                                                                                                                                                          "ΉN$y{}2\\N﹯ⱙK'8ɜͣwt,．钟廣䎘ꆚk媄_": null,
-                                                                                                                                                          "䎥eᾆᝦ읉,Jުn岪㥐s搖謽䚔5t㯏㰳㱊ZhD䃭f絕s鋡篟a`Q鬃┦鸳n_靂(E4迠_觅뷝_宪D(NL疶hL追V熑%]v肫=惂!㇫5⬒\u001f喺4랪옑": {
-                                                                                                                                                           "2a輍85먙R㮧㚪Sm}E2yꆣꫨrRym㐱膶ᔨ\\t綾A☰.焄뙗9<쫷챻䒵셴᭛䮜.<\/慌꽒9叻Ok䰊Z㥪幸k": [
-                                                                                                                                                            null,
-                                                                                                                                                            true,
-                                                                                                                                                            {"쌞쐍": {
-                                                                                                                                                             "▟GL K2i뛱iＱ\"̠.옛1X$}涺]靎懠ڦ늷?tf灟ݞゟ{": 1.227740268699265E-19,
-                                                                                                                                                             "꒶]퓚%ฬK❅": [{
-                                                                                                                                                              "(ෛ@Ǯっ䧼䵤[aﾃൖvEnAdU렖뗈@볓yꈪ,mԴ|꟢캁(而첸죕CX4Y믅": "2⯩㳿ꢚ훀~迯?᪑\\啚;4X\u20c2襏B箹)俣eỻw䇄",
-                                                                                                                                                              "75༂f詳䅫ꐧ鏿 }3\u20b5'∓䝱虀f菼Iq鈆﨤g퍩)BFa왢d0뮪痮M鋡nw∵謊;ꝧf美箈ḋ*\u001c`퇚퐋䳫$!V#N㹲抗ⱉ珎(V嵟鬒_b㳅\u0019": null,
-                                                                                                                                                              "e_m@(i㜀3ꦗ䕯䭰Oc+-련0뭦⢹苿蟰ꂏSV䰭勢덥.ྈ爑Vd,ᕥ=퀍)vz뱊ꈊB_6듯\"?{㒲&㵞뵫疝돡믈%Qw限,?\r枮\"? N~癃ruࡗdn&": null,
-                                                                                                                                                              "㉹&'Pfs䑜공j<\/?|8oc᧨L7\\pXᭁ 9᪘": -2.423073789014103E18,
-                                                                                                                                                              "䝄瑄䢸穊f盈᥸,B뾧푗횵B1쟢f\u001f凄": "魖⚝2儉j꼂긾껢嗎0ࢇ纬xI4](੓`蕞;픬\fC\"斒\")2櫷I﹥迧",
-                                                                                                                                                              "ퟯ詔x悝령+T?Bg⥄섅kOeQ큼㻴*{E靼6氿L缋\u001c둌๶-㥂2==-츫I즃㠐Lg踞ꙂEG貨鞠\"\u0014d'.缗gI-lIb䋱ᎂDy缦?": null,
-                                                                                                                                                              "紝M㦁犿w浴詟棓쵫G:䜁?V2ힽ7N*n&㖊Nd-'ຊ?-樹DIv⊜)g䑜9뉂ㄹ푍阉~ꅐ쵃#R^\u000bB䌎䦾]p.䀳": [{"ϒ爛\"ꄱ︗竒G䃓-ま帳あ.j)qgu扐徣ਁZ鼗A9A鸦甈!k蔁喙:3T%&㠘+,䷞|챽v䚞문H<\/醯r셓㶾\\a볜卺zE䝷_죤ဵ뿰᎟CB": [
-                                                                                                                                                               6233512720017661219,
-                                                                                                                                                               null,
-                                                                                                                                                               -1638543730522713294,
-                                                                                                                                                               false,
-                                                                                                                                                               -8901187771615024724,
-                                                                                                                                                               [
-                                                                                                                                                                3891351109509829590,
-                                                                                                                                                                true,
-                                                                                                                                                                false,
-                                                                                                                                                                -1.03836679125188032E18,
-                                                                                                                                                                {
-                                                                                                                                                                 "<?起HCᷭ죎劐莇逰/{gs\u0014⽛㰾愫tￖ<솞ڢ됌煲膺਻9x닳x࡭Q訽,ᶭඦtt掾\"秧㺌d˪䙻꫗:ᭈh4緞痐䤴c뫚떩త<?ᕢ謚6]폛O鰐鋛镠贩赟\"<G♷1'": true,
-                                                                                                                                                                 "቙ht4ߝBqꦤ+\u0006멲趫灔)椾": -1100102890585798710,
-                                                                                                                                                                 "総兎곇뇸粟F醇;朠?厱楛㶆ⶏ7r⾛o꯬᳡F\\머幖 㜦\f[搦᥽㮣0䕊?J㊳뀄e㔔+?<n↴复": [
-                                                                                                                                                                  "4~ꉍ羁\\偮(泤叕빜\u0014>j랎:g曞ѕᘼ}链N",
-                                                                                                                                                                  -1.1103819473845426E-19,
-                                                                                                                                                                  true,
-                                                                                                                                                                  [
-                                                                                                                                                                   true,
-                                                                                                                                                                   null,
-                                                                                                                                                                   -7.9091791735309888E17,
-                                                                                                                                                                   true,
-                                                                                                                                                                   {"}蔰鋈+ꐨ啵0?g*사%`J?*": [{
-                                                                                                                                                                    "\"2wG?yn,癷BK\\龞䑞x?蠢": -3.7220345009853505E-19,
-                                                                                                                                                                    ";饹়❀)皋`噿焒j(3⿏w>偍5X<np?<줯<Y]捘!J೸UⳂNे7v௸㛃ᄧ톿䨷鯻v焇=烻TQ!F⦰䣣눿K鷚눁'⭲m捠(䚻": [
-                                                                                                                                                                     "蹕 淜੃b\"+몾ⴕ",
-                                                                                                                                                                     null,
-                                                                                                                                                                     35892237756161615,
-                                                                                                                                                                     {
-                                                                                                                                                                      " 듹㏝)5慁箱&$~:遰쮐<\/堋?% \\勽唅z손帋䘺H髀麡M퇖uz\u0012m諦d᳤콌樝\rX싹̡Ო": -433791617729505482,
-                                                                                                                                                                      "-j溗ࢵcz!:}✽5ഇ,욨ݏs#덫=南浺^}E\\Y\\T*뼈cd꺐cۘ뎁䨸됱K䠴㉿恿逳@wf쏢<\/[L[": -9.3228549642908109E17,
-                                                                                                                                                                      "Ms킭u஗%\\u⍎/家欲ἅ答㓽/꯳齳|㭘Pr\"v<\/禇䔆$GA䊻˔-:틊[h?倬荤ᾞ৳.Gw\u000b": [
-                                                                                                                                                                       "0宜塙I@䏴蝉\\Uy뒅=2<h暒K._贡璐Yi檻_⮵uᐝ㘗聠[f\u0015힢Hꔮ}጑;誏yf0\"\u20cc?(=q斠➽5ꎾ鞘kⲃ",
-                                                                                                                                                                       -2.9234211354411E-19,
-                                                                                                                                                                       false,
-                                                                                                                                                                       true,
-                                                                                                                                                                       {
-                                                                                                                                                                        "\u0011⟴GH_;#怵:\u001c\u0002n1U\\p/왔(┫]hꐚ7\r0䵷첗岷O௷?㝎[殇|J=?韷pᶟ儜犆?5კ1kꍖiH竧뛈ପdmk游y(콪팱꾍k慧 y辣": [
-                                                                                                                                                                         false,
-                                                                                                                                                                         "O\"끍p覈ykv磂㢠㝵~뀬튍lC&4솎䇃:Mj",
-                                                                                                                                                                         -7.009964654003924E-20,
-                                                                                                                                                                         false,
-                                                                                                                                                                         -49306078522414046,
-                                                                                                                                                                         null,
-                                                                                                                                                                         null,
-                                                                                                                                                                         2160432477732354319,
-                                                                                                                                                                         true,
-                                                                                                                                                                         "4횡h+!踹ꐬP鮄{0&뱥M?샍鞅n㮞ᨹ?쒆毪l'箅^ꚥ頛`e㻨52柳⮙嫪࡟딯a.~䵮1f吘N&zȭL榓ۃ鳠5d㟆M@㣥ӋA΍q0縶$",
-                                                                                                                                                                         -3.848996532974368E16,
-                                                                                                                                                                         true,
-                                                                                                                                                                         null,
-                                                                                                                                                                         -3.5240055580952525E18,
-                                                                                                                                                                         {
-                                                                                                                                                                          " vﭷၵ#ce乃5僞?Z D`묨粇ᐔ绠vWL譢u뽀\\J|tⓙt№\"ꨋnT凮ᒩ蝂篝b騩:䢭Hbv읻峨z㹚T趗햆귣학津XiＹ@ᖥK": true,
-                                                                                                                                                                          "!F 醌y䉸W2ꇬ\u0006/䒏7~%9擛햀徉9⛰+?㌘;ꠓX䇻Dfi뼧쒒\u0012F謞՝絺+臕kऍLSQ쌁X쎬幦HZ98蒊枳": "澤令#\u001d抍⛳@N搕퀂[5,✄ꘇ~䘷?\u0011Xꈺ[硸⠘⛯X醪聡x\u0007쌇MiX/|ﾐ뚁K8䁡W)銀q僞綂蔕E",
-                                                                                                                                                                          "6␲䣖R৞@ငg?<\/೴x陙Xꈺ崸⠅ᇾ\\0X,H쟴셭A稂ힿゝF\\쑞\u0012懦(Aᯕ灭~\u0001껮X?逊": 5.7566819207732864E17,
-                                                                                                                                                                          "[c?椓": false,
-                                                                                                                                                                          "k䒇": 2583824107104166717,
-                                                                                                                                                                          "꙯N훙㏅ﮒ燣㨊瞯咽jMxby뻭뵫װ[\"1畈?ৱL": "띣ᔂ魠羓犴ꚃ+|rY",
-                                                                                                                                                                          "녺Z?䬝鉉:?ⳙ瘏Cኯ.Vs[釿䨉쐧\\\\*쵢猒$\\y溔^,㑳": {"藶꺟": [{
-                                                                                                                                                                           "\"d훣N2zq]?'檿죸忷篇ﮟ擤m'9!죶≓p뭻\\ᇷ\f퇶_䰸h๐Q嵃訾㘑従ꯦ䞶jL틊r澵Omᾫ!H䱤팼/;|᭺I7슎YhuXi⚼": -1.352716906472438E-19,
-                                                                                                                                                                           "M⽇倻5J䂫औ᝔楸#J[Fﹱ쫮W誻bWz?}1\"9硪뻶fe": "盬:Ѹ砿획땣T凊(m灦呜ﻝR㿎艴䂵h",
-                                                                                                                                                                           "R띾k힪CH钙_i苮ⰵoᾨ紑퉎7h؉\"柀蝽z0့\"<?嘭$蜝?礲7岇槀묡?V钿T⣜v+솒灚ԛ2米mH?>薙婏聿3aFÆÝ": "2,ꓴg?_섦_>Y쪥션钺;=趘F~?D㨫\bX?㹤+>/믟kᠪ멅쬂Uzỵ]$珧`m雁瑊ඖ鯬cꙉ梢f묛bB",
-                                                                                                                                                                           "♽n$YjKiXX*GO贩鏃豮祴遞K醞眡}ꗨv嵎꼷0୸+M菋eH徸J꣆:⼐悥B켽迚㯃b諂\u000bjꠜ碱逮m8": [
-                                                                                                                                                                            "푷᣺ﻯd8ﱖ嬇ភH鹎⡱᱅0g:果6$GQ췎{vᷧYy-脕x偹砡館⮸C蓼ꏚ=軄H犠G谖ES詤Z蠂3l봟hￒ7䦹1GPQG癸숟~[#駥8zQ뛣J소obg,",
-                                                                                                                                                                            null,
-                                                                                                                                                                            1513751096373485652,
-                                                                                                                                                                            null,
-                                                                                                                                                                            -6.851466660824754E-19,
-                                                                                                                                                                            {"䩂-⴮2ٰK솖풄꾚ႻP앳1H鷛wmR䗂皎칄?醜<\/&ࠧ㬍X濬䵈K`vJ륒Q/IC묛!;$vϑ": {
-                                                                                                                                                                             "@-ꚗxྐྵ@m瘬\u0010U絨ﮌ驐\\켑寛넆T=tQ㭤L연@脸삯e-:⩼u㎳VQ㋱襗ຓ<Ⅶ䌸cML3+\u001e_C)r\\9+Jn\\Pﺔ8蠱檾萅Pq鐳话T䄐I": -1.80683891195530061E18,
-                                                                                                                                                                             "ᷭዻU~ཷsgSJ`᪅'%㖔n5픆桪砳峣3獮枾䌷⊰呀": {
-                                                                                                                                                                              "Ş੉䓰邟自~X耤pl7间懑徛s첦5ਕXexh⬖鎥᐀nNr(J컗｜ૃF\"Q겮葲놔엞^겄+㈆话〾희紐G'E?飕1f❼텬悚泬먐U睬훶Qs": false,
-                                                                                                                                                                              "(\u20dag8큽튣>^Y{뤋.袊䂓;_g]S\u202a꽬L;^'#땏bႌ?C緡<䝲䲝断ꏏ6\u001asD7IK5Wxo8\u0006p弊⼂ꯍ扵\u0003`뵂픋%ꄰ⫙됶l囏尛+䗅E쟇\\": [
-                                                                                                                                                                               true,
-                                                                                                                                                                               {
-                                                                                                                                                                                "\n鱿aK㝡␒㼙2촹f;`쾏qIࡔG}㝷䐍瓰w늮*粅9뒪ㄊCj倡翑閳R渚MiUO~仨䜶RꙀA僈㉋⦋n{㖥0딿벑逦⥻0h薓쯴Ꝼ": [
-                                                                                                                                                                                 5188716534221998369,
-                                                                                                                                                                                 2579413015347802508,
-                                                                                                                                                                                 9.010794400256652E-21,
-                                                                                                                                                                                 -6.5327297761238093E17,
-                                                                                                                                                                                 1.11635352494065523E18,
-                                                                                                                                                                                 -6656281618760253655,
-                                                                                                                                                                                 {
-                                                                                                                                                                                  "": ")?",
-                                                                                                                                                                                  "TWKLꑙ裑꺔UE俸塑炌Ũ᜕-o\"徚#": {"M/癟6!oI51ni퐚=댡>xꍨ\u0004 ?": {
-                                                                                                                                                                                   "皭": {"⢫䋖>u%w잼<䕏꘍P䋵$魋拝U䮎緧皇Y훂&|羋ꋕ잿cJ䨈跓齳5\u001a삱籷I꿾뤔S8㌷繖_Yឯ䲱B턼O歵F\\l醴o_欬6籏=D": [
-                                                                                                                                                                                    false,
-                                                                                                                                                                                    true,
-                                                                                                                                                                                    {"Mt|ꏞD|F궣MQ뵕T,띺k+?㍵i": [
-                                                                                                                                                                                     7828094884540988137,
-                                                                                                                                                                                     false,
-                                                                                                                                                                                     {
-                                                                                                                                                                                      "!༦鯠,&aﳑ>[euJꏽ綷搐B.h": -7648546591767075632,
-                                                                                                                                                                                      "-n켧嘰{7挐毄Y,>❏螵煫乌pv醑Q嶚!|⌝責0왾덢ꏅ蛨S\\)竰'舓Q}A釡5#v": 3344849660672723988,
-                                                                                                                                                                                      "8閪麁V=鈢1녈幬6棉⪮둌\u207d᚛驉ꛃ'r䆉惏ै|bἧﺢᒙ<=穊强s혧eꮿ慩⌡ \\槳W븧J檀C,ᘉ의0俯퀉M;筷ࣴ瓿{늊埂鄧_4揸Nn阼Jੵ˥(社": true,
-                                                                                                                                                                                      "o뼀vw)4A뢵(a䵢)p姃뛸\u000fK#KiQp\u0005ꅍ芅쏅": null,
-                                                                                                                                                                                      "砥$ꥸ┇耽u斮Gc{z빔깎밇\\숰\u001e괷各㶇쵿_ᴄ+h穢p촀Ნ䃬z䝁酳ӂ31xꔄ1_砚W렘G#2葊P ": [
-                                                                                                                                                                                       -3709692921720865059,
-                                                                                                                                                                                       null,
-                                                                                                                                                                                       [
-                                                                                                                                                                                        6669892810652602379,
-                                                                                                                                                                                        -135535375466621127,
-                                                                                                                                                                                        "뎴iO}Z? 馢녱稹ᄾ䐩rSt帤넆&7i騏멗畖9誧鄜'w{Ͻ^2窭외b㑎粖i矪ꦨ탪跣)KEㆹ\u0015V8[W?⽉>'kc$䨘ᮛ뉻٬M5",
-                                                                                                                                                                                        1.10439588726055846E18,
-                                                                                                                                                                                        false,
-                                                                                                                                                                                        -4349729830749729097,
-                                                                                                                                                                                        null,
-                                                                                                                                                                                        [
-                                                                                                                                                                                         false,
-                                                                                                                                                                                         "_蠢㠝^䟪/D녒㡋ỎC䒈판\u0006એq@O펢%;鹐쏌o戥~A[ꡉ濽ỳ&虃᩾荣唙藍茨Ig楡꒻M窓冉?",
-                                                                                                                                                                                         true,
-                                                                                                                                                                                         2.17220752996421728E17,
-                                                                                                                                                                                         -5079714907315156164,
-                                                                                                                                                                                         -9.960375974658589E-20,
-                                                                                                                                                                                         "ᾎ戞༒",
-                                                                                                                                                                                         true,
-                                                                                                                                                                                         false,
-                                                                                                                                                                                         [[
-                                                                                                                                                                                          "ⶉᖌX⧕홇)g엃⹪x뚐癟\u0002",
-                                                                                                                                                                                          -5185853871623955469,
-                                                                                                                                                                                          {
-                                                                                                                                                                                           "L㜤9ợㇶK鐰⋓V뽋˖!斫as|9＂፬䆪?7胜&n薑~": -2.11545634977136992E17,
-                                                                                                                                                                                           "O8뀩D}캖q萂6༣㏗䈓煮吽ਆᎼDᣘ폛;": false,
-                                                                                                                                                                                           "YTᡅ^L㗎cbY$pᣞ縿#fh!ꘂb삵玊颟샞ဢ$䁗鼒몁~rkH^:닮먖츸륈⪺쒉砉?㙓扫㆕꣒`R䢱B酂?C뇞<5Iޚ讳騕S瞦z": null,
-                                                                                                                                                                                           "\\RB?`mG댵鉡幐物䵎有5*e骄T㌓ᛪ琾駒Ku\u001a[柆jUq8⋈5鿋츿myﻗ?雍ux঴?": 5828963951918205428,
-                                                                                                                                                                                           "n0晅:黯 xu씪^퓞cB㎊ᬍ⺘٤փ~B岚3㥕擄vᲂ~F?C䶖@$m~忔S왖㲚?챴⊟W#벌{'㰝I䝠縁s樘\\X뢻9핡I6菍ㄛ8쯶]wॽ0L\"q": null,
-                                                                                                                                                                                           "x增줖j⦦t䏢᎙㛿Yf鼘~꫓恄4惊\u209c": "oOhbᤃ᛽z&Bi犑\\3B㩬劇䄑oŁ쨅孥멁ຖacA㖫借㞝vg싰샂㐜#譞⢤@k]鋰嘘䜾L熶塥_<\/⍾屈ﮊ_mY菹t뙺}Ox=w鮮4S1ꐩמּ'巑",
-                                                                                                                                                                                           "㗓蟵ꂾe蠅匳(JP䗏෸\u0089耀왲": [{
-                                                                                                                                                                                            "ᤃ㵥韎뤽\r?挥O쯡⇔㞚3伖\u0005P⋪\"D궣QLn(⚘罩䩢Ŏv䤘尗뼤됛O淽鋋闚r崩a{4箙{煷m6〈": {
-                                                                                                                                                                                             "l곺1L": {
-                                                                                                                                                                                              "T'ਤ?砅|੬Km]䄩\"(࿶<\/6U爢䫈倔郴l2㴱^줣k'L浖L鰄Rp今鎗⒗C얨M훁㡧ΘX粜뫈N꤇輊㌻켑#㮮샶-䍗룲蠝癜㱐V>=\\I尬癤t=": 7648082845323511446,
-                                                                                                                                                                                              "鋞EP:<\/_`ၧe混ㇹBd⯢㮂驋\\q碽饩跓྿ᴜ+j箿렏㗑yK毢宸p謹h䦹乕U媣\\炤": [[
-                                                                                                                                                                                               "3",
-                                                                                                                                                                                               [
-                                                                                                                                                                                                true,
-                                                                                                                                                                                                3.4058271399411134E-20,
-                                                                                                                                                                                                true,
-                                                                                                                                                                                                "揀+憱f逮@먻BpW曉\u001a㣐⎊$n劈D枤㡞좾\u001aᛁ苔౩闝1B䷒Ṋ݋➐ꀞꐃ磍$t੤_:蘺⮼(#N",
-                                                                                                                                                                                                697483894874368636,
-                                                                                                                                                                                                [
-                                                                                                                                                                                                 "vᘯ锴)0訶}䳅⩚0O壱韈ߜ\u0018*U鍾䏖=䧉뽑单휻ID쿇嘗?ꌸῬ07",
-                                                                                                                                                                                                 -5.4858784319382006E18,
-                                                                                                                                                                                                 7.5467775182251151E18,
-                                                                                                                                                                                                 -8911128589670029195,
-                                                                                                                                                                                                 -7531052386005780140,
-                                                                                                                                                                                                 null,
-                                                                                                                                                                                                 [
-                                                                                                                                                                                                  null,
-                                                                                                                                                                                                  true,
-                                                                                                                                                                                                  [[{
-                                                                                                                                                                                                   "1欯twG<u䝮␽ꇣ_ჟﱴଶ-쪋\"?홺k:莝Ꜫ*⺵꽹댅釔좵}P?=9렿46b\u001c\\S?(筈僦⇶爷谰1ྷa": true,
-                                                                                                                                                                                                   "TҫJYxڪ\\鰔℮혡)m_WVi眪1[71><\/Q:0怯押殃탷聫사<ỗꕧ蚨䡁nDꌕ\u001c녬~蓩<N蹑\"{䫥lKc혁뫖앺:vⵑ": "g槵?",
-                                                                                                                                                                                                   "aꨩ뻃싥렌1`롗}Yg>鲃g儊>ꏡl㻿/⑷*챳6㻜W毤緛ﹺᨪ4\u0013뺚J髬e3쳸䘦伧?恪&{L掾p+꬜M䏊d娘6": {
-                                                                                                                                                                                                    "2p첼양棜h䜢﮶aQ*c扦v︥뮓kC寵횂S銩&ǝ{O*य़iH`U큅ࡓr䩕5ꄸ?`\\᧫?ᮼ?t〟崾훈k薐ì/ｉy꤃뵰z1<\/AQ#뿩8jJ1z@u䕥": 1.82135747285215155E18,
-                                                                                                                                                                                                    "ZdN &=d년ᅆ'쑏ⅉ:烋5&៏ᄂ汎来L㯄固{钧u\\㊏튚e摑&t嗄ꖄUb❌?m䴘熚9EW": [{
-                                                                                                                                                                                                     "ଛ{i*a(": -8.0314147546006822E17,
-                                                                                                                                                                                                     "⫾ꃆY\u000e+W`௸ \"M뒶+\\뷐lKE}(NT킶Yj選篒쁶'jNQ硾(똡\\\"逌ⴍy? IRꜘ὞鄬﨧:M\\f⠋Cꚜ쫊ᚴNV^D䕗ㅖἔIao꿬C⍏8": [
-                                                                                                                                                                                                      287156137829026547,
-                                                                                                                                                                                                      {
-                                                                                                                                                                                                       "H丞N逕<rO䎗:텕<\/䶩샌Sd%^ᵯ눐엑者g䖩똭蕮1U驣?Pⰰ\u001fp(W]67\u0015﫣6굺OR羸#촐F蒈;嘙i✵@_撶y㤏⤍(:᧗뼢༌朆@⏰㤨ꭲ?-n>⯲": {"": {
-                                                                                                                                                                                                        "7-;枮阕梒9ᑄZ": [[[[
-                                                                                                                                                                                                         null,
-                                                                                                                                                                                                         {
-                                                                                                                                                                                                          "": [[[[
-                                                                                                                                                                                                           -7.365909561486078E-19,
-                                                                                                                                                                                                           2948694324944243408,
-                                                                                                                                                                                                           null,
-                                                                                                                                                                                                           [
-                                                                                                                                                                                                            true,
-                                                                                                                                                                                                            "荒\"并孷䂡쵼9o䀘F\u0002龬7⮹Wz%厖/*? a*R枈㌦됾g뒠䤈q딄㺿$쮸tᶎ릑弣^鏎<\/Y鷇驜L鿽<\/춋9Mᲆឨ^<\/庲3'l낢",
-                                                                                                                                                                                                            "c鮦\u001b두\\~?眾ಢu݆綑෪蘛轋◜gȃ<\/ⴃcpkDt誩܅\"Y",
-                                                                                                                                                                                                            [[
-                                                                                                                                                                                                             null,
-                                                                                                                                                                                                             null,
-                                                                                                                                                                                                             [
-                                                                                                                                                                                                              3113744396744005402,
-                                                                                                                                                                                                              true,
-                                                                                                                                                                                                              "v(y",
-                                                                                                                                                                                                              {
-                                                                                                                                                                                                               "AQ幆h쾜O+꺷铀ꛉ練A蚗⼺螔j㌍3꽂楎䥯뎸먩?": null,
-                                                                                                                                                                                                               "蠗渗iz鱖w]擪E": 1.2927828494783804E-17,
-                                                                                                                                                                                                               "튷|䀭n*曎b✿~杤U]Gz鄭kW|㴚#㟗ഠ8u擨": [[
-                                                                                                                                                                                                                true,
-                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                {"⾪壯톽g7?㥜ώQꑐ㦀恃㧽伓\\*᧰閖樧뢇赸N휶䎈pI氇镊maᬠ탷#X?A+kНM ༑᩟؝?5꧎鰜ṚY즫궔 =ঈ;ﳈ?*s|켦蜌wM笙莔": [
-                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                 -3808207793125626469,
-                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                  -469910450345251234,
-                                                                                                                                                                                                                  7852761921290328872,
-                                                                                                                                                                                                                  -2.7979740127017492E18,
-                                                                                                                                                                                                                  1.4458504352519893E-20,
-                                                                                                                                                                                                                  true,
-                                                                                                                                                                                                                  "㽙깹?먏䆢:䴎ۻg殠JBTU⇞}ꄹꗣi#I뵣鉍r혯~脀쏃#釯:场:䔁>䰮o'㼽HZ擓௧nd",
-                                                                                                                                                                                                                  [
-                                                                                                                                                                                                                   974441101787238751,
-                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                   -2.1647718292441327E-19,
-                                                                                                                                                                                                                   1.03602824249831488E18,
-                                                                                                                                                                                                                   [
-                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                    1.0311977941822604E-17,
-                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                    true,
-                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                     "": -3.7019778830816707E18,
-                                                                                                                                                                                                                     "E峾恆茍6xLIm縂0n2视֯J-ᤜz+ᨣ跐mYD豍繹⹺䊓몓ﴀE(@詮(!Y膽#᎙2䟓섣A䈀㟎,囪QbK插wcG湎ꤧtG엝x⥏俎j'A一ᯥ뛙6ㅑ鬀": 8999803005418087004,
-                                                                                                                                                                                                                     "よ殳\\zD⧅%Y泥簳Uꈩ*wRL{3#3FYHା[d岀䉯T稉駅䞘礄P:闈W怏ElB㤍喬赔bG䠼U଄Nw鰯闀楈ePsDꥷ꭬⊊": [
-                                                                                                                                                                                                                      6.77723657904486E-20,
-                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                       "ཚ_뷎꾑蹝q'㾱ꂓ钚蘞慵렜떆`ⴹ⎼櫯]J?[t9Ⓢ !컶躔I᮸uz>3a㠕i,錃L$氰텰@7녫W㸮?羧W뇧ꃞ,N鋮숪2ɼ콏┍䁲6",
-                                                                                                                                                                                                                       "&y?뢶=킕올Za惻HZk>c\u20b58i?ꦶcfBv잉ET9j䡡",
-                                                                                                                                                                                                                       "im珊Ճb칧<D-諂*u2ꡜ췛~䬢(텸ﵦ>校\\뼾쯀",
-                                                                                                                                                                                                                       9.555715121193197E-20,
-                                                                                                                                                                                                                       true,
-                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                        "<㫚v6腓㨭e1㕔&&V∌ᗈT奄5Lጥ>탤?튣瑦㳆ꉰ!(ᙪ㿬擇_n쌯IMΉ㕨␰櫈ᱷ5풔蟹&L.첽e鰷쯃劼﫭b#ﭶ퓀7뷄Wr㢈๧Tʴશ㶑澕鍍%": -1810142373373748101,
-                                                                                                                                                                                                                        "fg晌o?߲ꗄ;>C>?=鑰監侯Kt굅": true,
-                                                                                                                                                                                                                        "䫡蓺ꑷ]C蒹㦘\"1ః@呫\u0014NL䏾eg呮፳,r$裢k>/\\<z": [[
-                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                         "C䡏>?ㄤᇰﻛ쉕1஥'Ċ\" \\_?쨔\"ʾr: 9S䘏禺ᪧꄂ㲄",
-                                                                                                                                                                                                                         [[{
-                                                                                                                                                                                                                          "*硙^+E쌺I1䀖ju?:⦈Ꞓl๴竣迃xKC/饉:\fl\"XTFﾨ蟭,芢<\/骡軺띜hꏘ\u001f銿<棔햳▨(궆*=乥b8\\媦䷀뫝}닶ꇭ(Kej䤑M": [{
-                                                                                                                                                                                                                           "1Ꮼ?>옿I╅C<ގ?ꊌ冉SV5A㢊㶆z-๎玶绢2F뵨@㉌뀌o嶔f9-庒茪珓뷳4": null,
-                                                                                                                                                                                                                           ";lᰳ": "CbB+肻a䄷苝*/볳+/4fq=㰁h6瘉샴4铢Y骐.⌖@哼猎㦞+'gꋸ㒕ߤ㞑(䶒跲ti⑴a硂#No볔",
-                                                                                                                                                                                                                           "t?/jE幸YHT셵⩎K!Eq糦ꗣv刴w\"l$ο:=6:移": {
-                                                                                                                                                                                                                            "z]鑪醊嫗J-Xm銌翁絨c里됏炙Ep㣋鏣똼嚌䀓GP﹖cmf4鹭T䅿꣭姧␸wy6ꦶ;S&(}ᎧKxᾂQ|t뻳k\"d6\"|Ml췆hwLt꼼4$&8Պ褵婶鯀9": {"嵃닢ᒯ'd᧫䳳#NXe3-붋鸿ଢ떓%dK\u0013䲎ꖍYV.裸R⍉rR3蟛\\:젯:南ĺLʆ넕>|텩鴷矔ꋅⒹ{t孶㓑4_": [
-                                                                                                                                                                                                                             true,
-                                                                                                                                                                                                                             null,
-                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                              false,
-                                                                                                                                                                                                                              "l怨콈lᏒ",
-                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                               "0w䲏嬧-:`䉅쉇漧\\܂yㄨb%㽄j7ᦶ涶<": 3.7899452730383747E-19,
-                                                                                                                                                                                                                               "ꯛTẀq纤q嶏V⿣?\"g}ი艹(쥯B T騠I=仵및X": {"KX6颠+&ᅃ^f畒y[": {
-                                                                                                                                                                                                                                "H?뱜^?꤂-⦲1a㋞&ꍃ精Ii᤾챪咽쬘唂쫷<땡劈훫놡o㥂\\ KⴙD秼F氮[{'좴:례晰Iq+I쭥_T綺砸GO煝䟪ᚪ`↹l羉q쐼D꽁ᜅ훦: vUV": true,
-                                                                                                                                                                                                                                "u^yﳍ0㱓#[y뜌앸ꊬL㷩?蕶蘾⻍KӼ": -7931695755102841701,
-                                                                                                                                                                                                                                "䤬轉車>\u001c鴵惋\"$쯃྆⇻n뽀G氠S坪]ಲꨍ捇Qxኻ椕駔\\9ࣼ﫻읜磡煮뺪ᶚ볝l㕆t+sζ": [[[
-                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                  3363739578828074923,
-                                                                                                                                                                                                                                  true,
-                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                   "\"鸣詩 볰㑵gL㯦῅춝旫}ED辗ﮈI쀤-ꧤ|㠦Z\"娑ᕸ4爏騍㣐\"]쳝Af]茛⬻싦o蚁k䢯䩐菽3廇喑ޅ": 4.5017999150704666E17,
-                                                                                                                                                                                                                                   "TYႇ7ʠ值4챳唤~Zo&ݛ": false,
-                                                                                                                                                                                                                                   "`塄J袛㭆끺㳀N㺣`꽐嶥KﯝSVᶔ∲퀠獾N딂X\"ᤏhNﬨvI": {"\u20bb㭘I䖵䰼?sw䂷쇪](泒f\"~;꼪Fԝsᝦ": {"p,'ꉂ軿=A蚶?bƉ㏵䅰諬'LYKL6B깯⋩겦뎙(ᜭ\u0006噣d꾆㗼Z;䄝䚔cd<情@䞂3苼㸲U{)<6&ꩻ钛\u001au〷N숨囖愙j=BXW욕^x芜堏Ῑ爂뛷꒻t✘Q\b": [[
-                                                                                                                                                                                                                                    "籛&ଃ䩹.ꃩ㦔\\C颫#暪&!勹ꇶ놽攺J堬镙~軌C'꾖䣹㮅岃ᙴ鵣",
-                                                                                                                                                                                                                                    4.317829988264744E15,
-                                                                                                                                                                                                                                    6.013585322002147E-20,
-                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                    true,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    -3.084633632357326E-20,
-                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                                     "\"짫愔昻  X\"藣j\"\"먁ཅѻ㘤㬯0晲DU꟒㸃d벀윒l䦾c੻*3": null,
-                                                                                                                                                                                                                                     "谈Wm陧阦咟ฯ歖擓N喴㋐銭rCCnVࢥ^♼Ⅾ젲씗刊S༝+_t赔\\b䚍뉨ꬫ6펛cL䊘᜼<\/澤pF懽&H": [
-                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                       "W\"HDUuΌ퀟M'P4࿰H똆ⰱﮯ<\/凐蘲\"C鴫ﭒж}ꭩ쥾t5yd诪ﮡ퍉ⴰ@?氐醳rj4I6Qt": 6.9090159359219891E17,
-                                                                                                                                                                                                                                       "絛ﳛ⺂": {"諰P㗮聦`ZQ?ꫦh*റcb⧱}埌茥h{棩렛툽o3钛5鮁l7Q榛6_g)ὄ\u0013kj뤬^爖eO4Ⱈ槞鉨ͺ订%qX0T썗嫷$?\\\"봅늆'%": [
-                                                                                                                                                                                                                                        -2.348150870600346E-19,
-                                                                                                                                                                                                                                        [[
-                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                         -6619392047819511778,
-                                                                                                                                                                                                                                         false,
-                                                                                                                                                                                                                                         [[
-                                                                                                                                                                                                                                          -1.2929189982356161E-20,
-                                                                                                                                                                                                                                          1.7417192219309838E-19,
-                                                                                                                                                                                                                                          {"?嵲2࿐2\u0001啑㷳c縯": [
-                                                                                                                                                                                                                                           null,
-                                                                                                                                                                                                                                           [
-                                                                                                                                                                                                                                            false,
-                                                                                                                                                                                                                                            true,
-                                                                                                                                                                                                                                            2578060295690793218,
-                                                                                                                                                                                                                                            {
-                                                                                                                                                                                                                                             "?\"殃呎#㑑F": true,
-                                                                                                                                                                                                                                             "}F炊_殛oU헢兔Ꝉ,赭9703.B数gTz3⏬": {
-                                                                                                                                                                                                                                              "5&t3,햓Mݸᵣ㴵;꣫䩍↳#@뫷䠅+W-ࣇzᓃ鿕ಔ梭?T䮑ꥬ旴]u뫵막bB讍:왳둛lEh=숾鱠p咐$짏#?g⹷ᗊv㷵.斈u頻\u0018-G.": "뽙m-ouࣤ஫牷\"`Ksꕞ筼3HlȨvC堈\"I]㖡玎r먞#'W賜鴇k'c룼髋䆿飉㗆xg巤9;芔cጐ/ax䊨♢큓r吓㸫೼䢗da᩾\"]屣`",
-                                                                                                                                                                                                                                              ":M딪<䢥喠\u0013㖅x9蕐㑂XO]ｆ*Q呰瞊吭VP@9,㨣 D\\穎vˤƩs㜂-曱唅L걬/롬j㈹EB8g<\/섩o渀\"u0y&룣": ">氍緩L/䕑돯Ꟙ蕞^aB뒣+0jK⪄瑨痜LXK^힦1qK{淚t츔X:Vm{2r獁B뾄H첚7氥?쉟䨗ꠂv팳圎踁齀\\",
-                                                                                                                                                                                                                                              "D彤5㢷Gꪻ[lㄆ@὜⓰絳[ଃ獽쮹☒[*0ꑚ㜳": 9022717159376231865,
-                                                                                                                                                                                                                                              "ҖaV銣tW+$魿\u20c3亜~뫡ᙰ禿쨽㏡fṼzE/h": "5臐㋇Ჯ쮺? 昨탰Wﾑ밎#'\"崲钅U?幫뺀⍾@4kh>騧\\0ҾEV=爐͌U捀%ꉼ 㮋<{j]{R>:gԩL\u001c瀈锌ﯲﳡꚒ'⫿E4暍㌗뵉X\"H᝜",
-                                                                                                                                                                                                                                              "ᱚגּ;s醒}犍SἿ㦣&{T$jkB\\\tḮ앾䤹o<避(tW": "vb⯽䴪䮢@|)",
-                                                                                                                                                                                                                                              "⥒퐁껉%惀뗌+녣迺顀q條g⚯i⤭룐M琹j̈́⽜A": -8385214638503106917,
-                                                                                                                                                                                                                                              "逨ꊶZ<\/W⫟솪㎮ᘇb?ꠔi\"H㧺x෷韒Xꫨฟ|]窽\u001a熑}Agn?Mᶖa<rఄ4Ů䢤슲Axģe곖㴤x竾郍B謉鸵k薽M)\"芣眜`菉ꉛ䴺": "鹏^ె캫?3耲]|Ü1䡒㝮]8e?䶍^",
-                                                                                                                                                                                                                                              "뿸樅#P㡊1M룮Uꪭ绢ꑮZ9꽸": {"\nJ^є|3袄ㅐ7⨆銦y睝⋷仴ct?[,<\/ㅬ`?갔髞%揁A೚C": {
-                                                                                                                                                                                                                                               " 䇞3갫䅪": [{
-                                                                                                                                                                                                                                                "0|⩁㑂砕ㅻ": null,
-                                                                                                                                                                                                                                                "D箳᠉`|=⼭)\"*࣊㦏LjO誋": "",
-                                                                                                                                                                                                                                                "ࠚDZmꗥ}ᷴ╈r7헴ȥ4Kp5a)o}鎘门L搰䆓'✎k俎c#T68ӏ⩶6L鎴<r൦$黊BQY㼳\\跿F慮⡨拵贀!甶V喅/": null,
-                                                                                                                                                                                                                                                "ⵣq⳹ﻨLk]晩1*y\\$%}䖶P煑㇆䈦E嫁櫕Y࣓嫨䓏OL낮梚㸇洛洚BYtgl∛S☕䉓宑⋢粚ꔯ꠼붠": ")ꬑ윤`\"Ⱓ<\/婽*Y䔸ᓰ_ﳍt슲坩隥&S糧䛮闵诌豐sh쯽邴*섴؏͎=㯨\"RVힳ,^t\"ac?䤒ꉀxHa=Uꛕ㐙TkF껾",
-                                                                                                                                                                                                                                                "弾cUAF?暤c덽.欀nK앭]r傊䀓ﯳ馽垃[䥛oI0N砊鈥헅Co쟋钄ㅷ㊌뷚7": [
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 "૓鏨?^䆏{\u0006`X䧵儱&롡尙砡\u0006뻝쑬sj▻XfᬶgcㄢV >9韲4$3Ỵ^=쏍煤ፐ돷2䣃%鷠/eQ9頸쥎",
-                                                                                                                                                                                                                                                 2398360204813891033,
-                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                 3.2658897259932633E-19,
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 "?ꚃ8Nn㞷幵d䲳䱲뀙ꪛQ瑓鎴]䩋-鰾捡䳡??掊",
-                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                 -1309779089385483661,
-                                                                                                                                                                                                                                                 "ᦲxu_/yecR.6芏.ᜇ過 ~",
-                                                                                                                                                                                                                                                 -5658779764160586501,
-                                                                                                                                                                                                                                                 "쒌:曠=l썜䢜wk#s蕚\"互㮉m䉤~0듐䋙#G;h숄옥顇෤勹(C7㢅雚㐯L⠅VV簅<",
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 -4.664877097240962E18,
-                                                                                                                                                                                                                                                 -4.1931322262828017E18,
-                                                                                                                                                                                                                                                 {
-                                                                                                                                                                                                                                                  ",": {
-                                                                                                                                                                                                                                                   "v㮟麑䄠뤵g{M띮.\u001bzt뢜뵡0Ǥ龍떟Ᾰ怷ϓRT@Lꀌ樂U㏠⾕e扉|bJg(뵒㠶唺~ꂿ(땉x⻫싉쁊;%0鎻V(o\f,N鏊%nk郼螺": -1.73631993428376141E18,
-                                                                                                                                                                                                                                                   "쟧摑繮Q@Rᕾ㭚㾣4隅待㓎3蒟": [
-                                                                                                                                                                                                                                                    4971487283312058201,
-                                                                                                                                                                                                                                                    8973067552274458613,
-                                                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                                                     "`a揙ᣗ\u0015i<S幼訃锭B0&槩✨[Wp皩[g≊k葾x2ᡆ橲䲢W": true,
-                                                                                                                                                                                                                                                     "kH皈Sꁱq傑u?솹풑~o^F=劣N*reJ沤wW苯7p㼹䎐a=ꮧL㷩냴nWꌑ㞱uu谁lVN珿᤻(e豶5#L쪉ᅄ઄\u0015숟봊P瀚X蓎": false,
-                                                                                                                                                                                                                                                     "䫯דּ〖Sc䛭점L뵾pCꙞ\"엇즓_ﰛ톣ꫀ먩㺣㮠⭴!\\W┏t䖰軅y\u0014~ᇰ렢E7*俜䥪W䀩䷐h봆vjஉ묣༏G39.뼳輼:㮿ᐦA饕TUL}~": [
-                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                      8.8648298810470003E17,
-                                                                                                                                                                                                                                                      5.735561205600924E-20,
-                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                      -102555823658171644,
-                                                                                                                                                                                                                                                      1.2674932032973067E-19,
-                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                       "D胣O㯨\u0017Ku눓㒏텁nᨊ!Ꚇ廫_>Bo¸": 4.3236479112537999E18,
-                                                                                                                                                                                                                                                       "HW&퉡ぁ圍<W)6悰ꠑHEp14xy峑ft\u0005s亘V튉䢮ꦈX嵐꬝?lI_덝춇-6Ss噺Nk-ﮥ큃܁郪*PR(S6╋@仙V懸뺵ﯜV粹": "9䗌斀4㐈^Qs隄硏j\u0003",
-                                                                                                                                                                                                                                                       "Vk鶅C泹筁HX훉朗*r\\z顊誌儖4?n7᏾6몋䎡ﳈ],H頢p蚐㑄P4满E䏩V䬕ญL廂쒬쑨ꆷh迡ꍰ譖墎 ]鹿ฌ7ﶽ冭༽<ꈓS\\l䋮?_ﾕ檒?": -8598528325153980065,
-                                                                                                                                                                                                                                                       "t=q퍣疻тZ\\錅J.镎|nfḷ鴒1厰L灯纜E]୦⥪]Ꮾ'羝p/咩0닳ﳁqﳖཽk ?X1Ft%ś뭢v鋋⺃爵⒗": [[
-                                                                                                                                                                                                                                                        5.0824756359232045E-19,
-                                                                                                                                                                                                                                                        [
-                                                                                                                                                                                                                                                         7.268480839079619E-19,
-                                                                                                                                                                                                                                                         {"탿^굞⧕iј덊ꀛw껩6ꟳXs酚\\>Y?瑡Qy훍q!帰敏s舠㫸zꚗaS歲v`G株巷Jp6킼 (귶鍔⾏⡈>M汐㞍ቴ꙲dv@i㳓ᇆ?黍": [
-                                                                                                                                                                                                                                                          null,
-                                                                                                                                                                                                                                                          4997607199327183467,
-                                                                                                                                                                                                                                                          "E㻎蠫ᐾ高䙟蘬洼旾﫠텛㇛?'M$㣒蔸=A_亀绉앭rN帮",
-                                                                                                                                                                                                                                                          null,
-                                                                                                                                                                                                                                                          [{
-                                                                                                                                                                                                                                                           "Eᑞ)8<Z㡿W镀䛒C생V?0ꯦ+tL)`齳AjB姀XೳD빠㻲ƙgn9⑰ྍ῜&\"㚹>餧A5u&㗾q?": [
-                                                                                                                                                                                                                                                            -1.969987519306507E-19,
-                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                            [
-                                                                                                                                                                                                                                                             3.42437673373841E-20,
-                                                                                                                                                                                                                                                             true,
-                                                                                                                                                                                                                                                             "e걷M墁\"割P␛퍧厀R䱜3ﻴO퓫r﹉⹊",
-                                                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                                                              -8164221302779285367,
-                                                                                                                                                                                                                                                              [
-                                                                                                                                                                                                                                                               true,
-                                                                                                                                                                                                                                                               null,
-                                                                                                                                                                                                                                                               "爘y^-?蘞Ⲽꪓa␅ꍨ}I",
-                                                                                                                                                                                                                                                               1.4645984996724427E-19,
-                                                                                                                                                                                                                                                               [{
-                                                                                                                                                                                                                                                                "tY좗⧑mrzﺝ㿥ⴖ᥷j諅\u0000q賋譁Ꞅ⮱S\nࡣB/큃굪3Zɑ复o<\/;롋": null,
-                                                                                                                                                                                                                                                                "彟h浠_|V4䦭Dᙣ♞u쿻=삮㍦\u001e哀鬌": [{"6횣楠,qʎꗇ鎆빙]㱭R굋鈌%栲j分僅ペ䇰w폦p蛃N溈ꡐꏀ?@(GI뉬$ﮄ9誁ꓚ2e甸ڋ[䁺,\u0011\u001cࢃ=\\+衪䷨ᯕ鬸K": [[
-                                                                                                                                                                                                                                                                 "ㅩ拏鈩勥\u000etgWVXs陂規p狵w퓼{뮵_i\u0002ퟑႢ⬐d6鋫F~챿搟\u0096䚼1ۼ칥0꣯儏=鋷牋ⅈꍞ龐",
-                                                                                                                                                                                                                                                                 -7283717290969427831,
-                                                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                                                                  4911644391234541055,
-                                                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                                                   "I鈒첽P릜朸W徨觘-Hᎄ퐟⓺>8kr1{겵䍃〛ᬡ̨O귑o䝕'쿡鉕p5": "fv粖RN瞖蛐a?q꤄\u001d⸥}'ꣴ犿ꦼ?뤋?鵆쥴덋䡫s矷̄?ඣ/;괱絢oWfV<\/\u202cC,㖦0䑾%n賹g&T;|lj_欂N4w",
-                                                                                                                                                                                                                                                                   "짨䠗;䌕u i+r๏0": [{"9䥁\\఩8\"馇z䇔<\/ႡY3e狚쐡\"ุ6ﰆZ遖c\"Ll:ꮾ疣<\/᭙Ｏ◌납୕湞9⡳Und㫜\u0018^4pj1;䧐儂䗷ୗ>@e톬": {
-                                                                                                                                                                                                                                                                    "a⑂F鋻Q螰'<퇽Q贝瀧{ᘪ,cP&~䮃Z?gＩ彃": [
-                                                                                                                                                                                                                                                                     -1.69158726118025933E18,
-                                                                                                                                                                                                                                                                     [
-                                                                                                                                                                                                                                                                      "궂z簽㔛㮨瘥⤜䛖Gℤ逆Y⪾j08Sn昞ꘔ캻禀鴚P謦b{ꓮmN靐Mᥙ5\"睏2냑I\u0011.L&=?6ᄠ뻷X鸌t刑\"#z)o꫚n쳟줋",
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      7517598198523963704,
-                                                                                                                                                                                                                                                                      "ኑQp襟`uᩄr方]*F48ꔵn俺ሙ9뇒",
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      6645782462773449868,
-                                                                                                                                                                                                                                                                      1219168146640438184,
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                                       ")ယ넌竀Sd䰾zq⫣⏌ʥ\u0010ΐ' |磪&p牢蔑mV蘸૰짬꺵;K": [
-                                                                                                                                                                                                                                                                        -7.539062290108008E-20,
-                                                                                                                                                                                                                                                                        [
-                                                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                                                         false,
-                                                                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                                                         6574577753576444630,
-                                                                                                                                                                                                                                                                         [[
-                                                                                                                                                                                                                                                                          1.2760162530699766E-19,
-                                                                                                                                                                                                                                                                          [
-                                                                                                                                                                                                                                                                           null,
-                                                                                                                                                                                                                                                                           [
-                                                                                                                                                                                                                                                                            "顊\\憎zXB,",
-                                                                                                                                                                                                                                                                            [{
-                                                                                                                                                                                                                                                                             "㇆{CVC9－MN㜋ઘR눽#{h@ퟨ!鼚׼XOvXS\u0017ᝣ=cS+梽៲綆16s덽휐y屬?ᇳG2ᴭ\u00054쫖y룇nKcW̭炦s/鰘ᬽ?J|퓀髣n勌\u0010홠P>j": false,
-                                                                                                                                                                                                                                                                             "箴": [
-                                                                                                                                                                                                                                                                              false,
-                                                                                                                                                                                                                                                                              "鍞j\"ꮾ*엇칬瘫xṬ⭽쩁䃳\"-⋵?ᦽ<cਔ↎⩧%鱩涎삧u9K⦈\"῝ᬑV绩킯愌ṱv@GꝾ跶Ꚇ(?䖃vI᧊xV\r哦j㠒?*=S굤紴ꊀ鹭쬈s<DrIu솹꧑?",
-                                                                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                                                                               ".}S㸼L?t\u000fK⑤s~hU鱜꘦}쪍C滈4ꓗ蛌):ྦ\"顥이⢷ῳYLn\"?fꘌ>댎Ĝ": true,
-                                                                                                                                                                                                                                                                               "Pg帯佃籛n㔠⭹࠳뷏≻࿟3㞱!-쒾!}쭪䃕!籿n涻J5ਲ਼yvy;Rኂ%ᔡጀ裃;M⣼)쵂쑈": 1.80447711803435366E18,
-                                                                                                                                                                                                                                                                               "ꈑC⡂ᑆ㤉壂뎃Xub<\/쀆༈憓ق쨐ק\\": [
-                                                                                                                                                                                                                                                                                7706977185172797197,
-                                                                                                                                                                                                                                                                                {"": {"K╥踮砆NWࡆFy韣7ä밥{|紒︧䃀榫rᩛꦡTSy잺iH8}ퟴ,M?Ʂ勺ᴹ@T@~꾂=I㙕뾰_涀쑜嫴曣8IY?ҿo줫fऒ}\\S\"ᦨ뵼#nDX": {
-                                                                                                                                                                                                                                                                                 "♘k6?଱癫d68?㽚乳䬳-V顷\u0005蝕?\u0018䞊V{邾zじl]雏k臤~ൖH뒐iꢥ]g?.G碄懺䔛p<q꜉S岗_.%": 7688630934772863849,
-                                                                                                                                                                                                                                                                                 "溗摽嗙O㧀,⡢⼰呠ꅧ㓲/葇䢛icc@-r\b渂ꌳ뻨饑觝ᖜ\\鮭\u0014엙㥀᧺@浹W2꛵{W률G溮킀轡䬆g㨑'Q聨៪网Hd\"Q늴ᱢﶨ邮昕纚枑?▰hr羌驀[痹<\/": [
-                                                                                                                                                                                                                                                                                  -1.0189902027934687E-19,
-                                                                                                                                                                                                                                                                                  {"窶椸릎뚻shE\"ꪗႥꎳU矖佟{SJ": [{"-慜x櫹XY-澐ܨ⣷ઢ鯙%Fu\u0000迋▒}᥷L嗭臖oញc넨\u0016/迎1b꯸g뢱㐧蓤䒏8C散삭|\"컪輩鹩\"\\g$zG䥽긷?狸꿭扵㲐:URON&oU8": [
-                                                                                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                                                                                   true,
-                                                                                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                                                                                   -2.8907335031148883E17,
-                                                                                                                                                                                                                                                                                   -3864019407187144121,
-                                                                                                                                                                                                                                                                                   {
-                                                                                                                                                                                                                                                                                    "`빬d⵺4H뜳⧈쓑ohஸ*㶐ﻇ⸕䠵!i䝬﹑h夘▥ꗐ푹갇㵳TA鳠嚵\\B<X}3訒c⋝{*﫢w]璨-g捭\\j໵侠Ei层\u0011": 3.758356090089446E-19,
-                                                                                                                                                                                                                                                                                    "䄘ﮐ)Y놞씃㾱陰큁:{\u2059/S⓴": [[
-                                                                                                                                                                                                                                                                                     null,
-                                                                                                                                                                                                                                                                                     [[
-                                                                                                                                                                                                                                                                                      -3.8256602120220546E-20,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      7202317607724472882,
-                                                                                                                                                                                                                                                                                      "CWQ뚿",
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      false,
-                                                                                                                                                                                                                                                                                      true,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      2857038485417498625,
-                                                                                                                                                                                                                                                                                      6.191302233218633E-20,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      -6795250594296208046,
-                                                                                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                                                                                       true,
-                                                                                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                                                                                        "%ዧ遰Yᚯ⚀x莰愒Vᔈ턗BN洝ꤟA1⍌l콹풪H;OX๫륞쪐ᰚц@͎黾a邬<L厒Xb龃7f웨窂二;": [[
-                                                                                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                                                                                         "耲?䙧㘓F6Xs틭멢.v뚌?鄟恠▽'묺競?WvᆾCtxo?dZ;䨸疎",
-                                                                                                                                                                                                                                                                                         {
-                                                                                                                                                                                                                                                                                          "@hWꉁ&\"빜4礚UO~C;う殩_ꀥ蘁奢^챟k→ᡱKMⵉ<\/Jㅲ붉L͟Q": false,
-                                                                                                                                                                                                                                                                                          "tU뢂8龰I먽7,.Y搽Z툼=&⨥覽K乫햶㠸%#@Z끖愓^⍊⾂몒3E_噆J(廊ឭyd䞜鈬Ћ档'⣘I": {
-                                                                                                                                                                                                                                                                                           "tK*ꔵ銂u艗ԃ쿏∳ꄂ霫X3♢9y?=ⲭdЊb&xy}": [
-                                                                                                                                                                                                                                                                                            -4.097346784534325E-20,
-                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                            6016848468610144624,
-                                                                                                                                                                                                                                                                                            -8194387253692332861,
-                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                            {
-                                                                                                                                                                                                                                                                                             "(祬诀譕쯠娣c봝r?畄kT뼾⌘⎨?noV䏘쥝硎n?": [
-                                                                                                                                                                                                                                                                                              1.82679422844617293E18,
-                                                                                                                                                                                                                                                                                              [
-                                                                                                                                                                                                                                                                                               false,
-                                                                                                                                                                                                                                                                                               2.6849944122427694E18,
-                                                                                                                                                                                                                                                                                               true,
-                                                                                                                                                                                                                                                                                               [
-                                                                                                                                                                                                                                                                                                false,
-                                                                                                                                                                                                                                                                                                {
-                                                                                                                                                                                                                                                                                                 ";0z⭆;화$bਔ瀓\"衱^?잢ᢛ⣿~`ꕉ薸⌳໿湘腌'&:ryБꋥၼ꒥筙꬜긨?X": -3536753685245791530,
-                                                                                                                                                                                                                                                                                                 "c;Y7釚Uꃣ割J༨Y戣w}c峰뢨㽑㫈0N>R$䅒X觨l봜A刊8R梒',}u邩퉕?;91Ea䈈믁G⊶芔h袪&廣㺄j;㡏綽\u001bN頸쳘橆": -2272208444812560733,
-                                                                                                                                                                                                                                                                                                 "拑Wﵚj鵼駳Oࣿ)#㾅顂N傓纝y僱栜'Bꐍ-!KF*ꭇK￤?䈴^:啤wG逭w᧯": "xᣱmYe1ۏ@霄F$ě꧘푫O䤕퀐Pq52憬ꀜ兴㑗ᡚ?L鷝ퟐ뭐zJꑙ}╆ᅨJB]\"袌㺲u8䯆f",
-                                                                                                                                                                                                                                                                                                 "꿽၅㔂긱Ǧ?SI": -1669030251960539193,
-                                                                                                                                                                                                                                                                                                 "쇝ɨ`!葎>瞺瘡驷錶❤ﻮ酜=": -6961311505642101651,
-                                                                                                                                                                                                                                                                                                 "?f7♄꫄Jᡔ훮e읇퍾፣䭴KhखT;Qty}O\\|뫁IῒNe(5惁ꥶㆷY9ﮡ\\ oy⭖-䆩婁m#x봉>Y鈕E疣s驇↙ᙰm<": {"퉻:dꂁ&efￎ쫢[\"돈늖꺙|Ô剐1͖-K:ʚ᭕/;쏖㷛]I痐职4g<Oꗢ뫺N쯂륬J╆.`ᇵP轆&fd$?苅o궓vO侃沲⍩嚅沗 E%⿰얦wi\\*趫": [
-                                                                                                                                                                                                                                                                                                  3504362220185634767,
-                                                                                                                                                                                                                                                                                                  false,
-                                                                                                                                                                                                                                                                                                  "qzX朝qT3軞T垈ꮲQ览ᚻ⻑쎎b驌䵆ꬠ5Fୗ䲁缿ꝁ蒇潇Ltᆄ钯蜀W欥ሺ",
-                                                                                                                                                                                                                                                                                                  "볰ɐ霬)젝鶼kwoc엷荁r \u001d쒷⎹8{%澡K늒?iﺩd=&皼倚J9s@３偛twὡgj䁠흪5⭉⨺役&놎cﺉ㺡N5",
-                                                                                                                                                                                                                                                                                                  false,
-                                                                                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                                                                                  "D0st[ni锹r*0k6ꀎ덇UX2⽼৞䃚粭#)Z桷36P]<\/`",
-                                                                                                                                                                                                                                                                                                  4281410120849816730,
-                                                                                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                                                                                  -3256922126984394461,
-                                                                                                                                                                                                                                                                                                  1.16174580369801549E18,
-                                                                                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                                                                                   " ᆼꤗ~*TN긂<㡴턱℃酰^蘒涯잰淭傛2rൡet쾣䐇m*㸏y\"\\糮᧺qv쌜镜T@yg1譬ﭧﳭ\f": null,
-                                                                                                                                                                                                                                                                                                   "圾ᨿ0xᮛ禵ਗ਼D-㟻ẵ錚e\"赜.˶m)鴑B(I$<\/轴퉯揷⋏⏺*)宓쓌?*橯Lx\\f쩂㞼⇸\"ﺧ軂遳V\\땒\"캘c:G": null,
-                                                                                                                                                                                                                                                                                                   "?﵁_곢翸폈8㿠h열Q2㭛}RY㯕ＹT놂⽻e^B<\/맫ﻇ繱\u0017Gц⟊ᢑﵩS:jt櫣嗒⟰W㴚搦ᅉe[w䋺?藂翙Ⲱ芮䍘╢囥lpdu7r볺I 近qFyᗊ": [
-                                                                                                                                                                                                                                                                                                    "$b脬aﾠ襬育Bگ嵺Pw+'M<\/כֿn䚚v螁bN⒂}褺%lቦ阤\"ꓺᏗM牏,۞Ҷ!矬?ke9銊X괦)䈽틁脽ṫ䈞ᴆ^=Yᗿ遛4I귺⋥%",
-                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                    2.9444482723232051E18,
-                                                                                                                                                                                                                                                                                                    2072621064799640026,
-                                                                                                                                                                                                                                                                                                    "/_뇴뫢j㍒=Nꡦ↍Ժ赒❬톥䨞珯su*媸瀳鷔抡o흺-៳辏勷f绔:䵢搢2",
-                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                    "쒜 E䌐/큁\u0018懺_<\\隺&{wF⤊谼(<죽遠8?@*rᶊGd뻻갇&Ⳇq᣿e࢔t_ꩄ梸O詬C᧧Kꩠ풤9눙醅됞}竸rw?滨ӽK⥿ཊG魲']`๖5㄰",
-                                                                                                                                                                                                                                                                                                    -2375253967958699084,
-                                                                                                                                                                                                                                                                                                    {"嗱⿲\"f億ᝬ": {"v?䚑킡`◤k3,骥曘뒤Oᒱ㲹^圮᠀YT껛&촮P:G/T⣝#튣k3炩蠏k@橈䏷S䧕,熜晬k1鮥玸먚7䤡f绝嗚샴ᥒ~0q拮垑a뻱LⰖ_": [{
-                                                                                                                                                                                                                                                                                                     ":p尢": -6.688985172863383E17,
-                                                                                                                                                                                                                                                                                                     "A0\u0001疠ﻵ爻鼀湶I~W^岀mZx#㍈7r拣$Ꜷ疕≛⦒痋盩Vꬷ᭝ΩQꍪ療鈑A(劽詗ꭅo-獶鑺\"Ⓠ@$j탥;": [
-                                                                                                                                                                                                                                                                                                      8565614620787930994,
-                                                                                                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                                                                                                       "嶗PC?උQ㪣$&j幾㾷h慑 즊慧⪉霄M窊ꁷ'鮕)䊏铨m趦䗲(g罣ЮKVﯦ鏮5囗ﰼ鿦",
-                                                                                                                                                                                                                                                                                                       -7168038789747526632,
-                                                                                                                                                                                                                                                                                                       null,
-                                                                                                                                                                                                                                                                                                       -7.8069738975270288E16,
-                                                                                                                                                                                                                                                                                                       2.25819579241348352E17,
-                                                                                                                                                                                                                                                                                                       -6.5597416611655936E18,
-                                                                                                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                                                                                                        "瘕멦핓+?ﾌZ귢z鍛V": {
-                                                                                                                                                                                                                                                                                                         "ᕾ": 1.7363275204701887E-19,
-                                                                                                                                                                                                                                                                                                         "㭌s뎹㳉": {"\u00187FI6Yf靺+UC쬸麁␲䂿긕R\\ᆮC?Φ耭\rOத际핅홦*베W㸫㯼᡹cㅜ|G㮗\u0013[o`?jHV앝?蒪꩚!퍫ᜦ㌇䚇鿘:@": [
-                                                                                                                                                                                                                                                                                                          "}푛Г콲<䟏C藐呈#2㓋#ྕ፟尿9q竓gI%랙mꍬoa睕贿J咿D_熏Zz皳験I豼B扳ḢQ≖㻹㱣D䝦練2'ᗍ㗣▌砲8罿%హF姦;0悇<\/\"p嚧",
-                                                                                                                                                                                                                                                                                                          -710184373154164247,
-                                                                                                                                                                                                                                                                                                          "Vo쫬⬾ꝫⴷŻ\u0004靎HBꅸ_aVBＨbN>Z4⍜kเꛘZ⥺\\Bʫᇩ鄨魢弞&幟ᓮ2̊盜",
-                                                                                                                                                                                                                                                                                                          -9006004849098116748,
-                                                                                                                                                                                                                                                                                                          -3118404930403695681,
-                                                                                                                                                                                                                                                                                                          {
-                                                                                                                                                                                                                                                                                                           "_彃Y艘-\"Xx㤩㳷瑃?%2䐡鵛o<A?\"顜ᘌΈ;ⷅC洺L蚴蚀voq:,Oo4쪂)": 5719065258177391842,
-                                                                                                                                                                                                                                                                                                           "l륪맽耞塻論倐E㗑/㲕QM辬I\"qi酨玑㖪5q]尾魨鲡ƞY}⮯蠇%衟Fsf윔䐚찤i腳": {"ꢪ'a䣊糈": {"밑/♋S8s㼴5瓹O{댞\"9XﰇlJ近8}q{긧ⓈI᱑꿋腸D瀬H\"ﺬ'3?}\u0014#?丙㑯ᥨ圦',g鑠(樴턇?": [
-                                                                                                                                                                                                                                                                                                            2.5879275511391145E18,
-                                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                                            [
-                                                                                                                                                                                                                                                                                                             "3㼮ꔌ1Gẃ2W龙j͊{1囐㦭9x宠㑝oR䐕犽",
-                                                                                                                                                                                                                                                                                                             1268729930083267852,
-                                                                                                                                                                                                                                                                                                             "땕軚⿦7C",
-                                                                                                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                                                                                                              -3.757935946502082E18,
-                                                                                                                                                                                                                                                                                                              "\"赌'糬_2뭾᝝b",
-                                                                                                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                                                                                                               "(a䕎ጽjҰD4.ᴡ66ԃ畮<\/l`k癸\\㇋ࣆ욯R㫜픉녬挛;ڴ맺`.;焓q淞뮕ٹ趴r蔞ꯔ䟩v粏u5<\/pZ埖Skrvj帛=\u0005aa": null,
-                                                                                                                                                                                                                                                                                                               "璄≩ v몛ᘮ%?:1頌챀H㷪뉮k滘e": [
-                                                                                                                                                                                                                                                                                                                "ꤾ{`c샬왌펡[俊络vmz㪀悫⸹ᷥ5o'㾵 L蹦qjYIYណԠW냁剫<\/W嗂0,}",
-                                                                                                                                                                                                                                                                                                                2.4817616702666762E18,
-                                                                                                                                                                                                                                                                                                                false,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                -8.6036958071260979E17,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                -1.2744078022652468E-19,
-                                                                                                                                                                                                                                                                                                                -4.4752020268429594E17,
-                                                                                                                                                                                                                                                                                                                1.13672865156637872E17,
-                                                                                                                                                                                                                                                                                                                [
-                                                                                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                                                                                 -4.178004168554046E-20,
-                                                                                                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                                                                                                 2927542512798605527,
-                                                                                                                                                                                                                                                                                                                 {
-                                                                                                                                                                                                                                                                                                                  ".ꔓ뉤1䵬cHy汼䊆賓ᐇƩ|樷❇醎㬅4\u0003赵}#yD5膏晹뱓9ꖁ虛J㺕 t䊛膎ؤ": {
-                                                                                                                                                                                                                                                                                                                   "rVtᓸ5^`েN⹻Yv᥋lꌫt拘?<鮰넿ZC?㒽^": {"␪k_:>귵옔夘v*탋职&㳈챗|O钧": [
-                                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                                    "daꧺdᗹ羞쯧H㍤鄳頳<型孒ン냆㹀f4㹰\u000f|C*ሟ鰠(O<ꨭ峹ipຠ*y೧4VQ蔔hV淬{?ᵌEfrI_",
-                                                                                                                                                                                                                                                                                                                    "j;ꗣ밷邍副]ᗓ",
-                                                                                                                                                                                                                                                                                                                    -4299029053086432759,
-                                                                                                                                                                                                                                                                                                                    -5610837526958786727,
-                                                                                                                                                                                                                                                                                                                    [
-                                                                                                                                                                                                                                                                                                                     null,
-                                                                                                                                                                                                                                                                                                                     [
-                                                                                                                                                                                                                                                                                                                      -1.3958390678662759E-19,
-                                                                                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                                                                                       "lh좈T_믝Y\"伨\u001cꔌG爔겕ꫳ晚踍⿻읐T䯎]~e#฽燇\"5hٔ嶰`泯r;ᗜ쮪Q):/t筑,榄&5懶뎫狝(": [{
-                                                                                                                                                                                                                                                                                                                        "2ፁⓛ]r3C攟וּ9賵s⛔6'ஂ|\"ⵈ鶆䐹禝3\"痰ࢤ霏䵩옆䌀?栕r7O簂Isd?K᫜`^讶}z8?z얰T:X倫⨎ꑹ": -6731128077618251511,
-                                                                                                                                                                                                                                                                                                                        "|︦僰~m漿햭\\Y1'Vvخ굇ቍ챢c趖": [null]
-                                                                                                                                                                                                                                                                                                                       }],
-                                                                                                                                                                                                                                                                                                                       "虌魿閆5⛔煊뎰㞤ᗴꥰF䮥蘦䂪樳-K᝷-(^\u20dd_": 2.11318679791770592E17
-                                                                                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                                                                                    ]
-                                                                                                                                                                                                                                                                                                                   ]},
-                                                                                                                                                                                                                                                                                                                   "묗E䀳㧯᳀逞GMc\b墹㓄끖Ơ&U??펌鑍 媋k))ᄊ": null,
-                                                                                                                                                                                                                                                                                                                   "묥7콽벼諌J_DɯﮪM殴䣏,煚ྼ`Y:씧<\/⩫%yf䦀!1Ჶk춎Q米W∠WC跉鬽*ᛱi<?,l<崣炂骵*?8푐៣ⰵ憉⎑.,Nw罣q+ο컆弎": false
-                                                                                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                                                                                  "e[|଀+lꑸ㝈TT?뿿|ꫛ9`㱯䊸楋-곳賨?쳁k棽擋wQ餈⟐Nq[q霩䵀뷮锅ꚢ": 5753148631596678144,
-                                                                                                                                                                                                                                                                                                                  "sᓝ鴻߸d렶ὕ蜗ဟ툑!诉౿": false,
-                                                                                                                                                                                                                                                                                                                  "|4䕳鵻?䈔(]틍/Ui#湻{듲ーMዀt7潔泄Ch⸨}쏣`螧銚㋼壯kⰥQ戵峉갑x辙'첛": "jd䘯$䕌茷!auw眶ㅥ䁣ꆢ民i",
-                                                                                                                                                                                                                                                                                                                  "剖駰ꞫsM2]ᾴ2ࡷ祅拌Av狔꩛'ꓗ킧ꣁ0酜✘O'": false,
-                                                                                                                                                                                                                                                                                                                  "澩뢣ꀁeU~D\\ꮡ킠": "v^YC嚈ί\u0007죋h>㴕L꘻ꀏ쓪\"_g鿄'#t⽙?,Wg㥖|D鑆e⥏쪸僬h鯔咼ඡ;4TK聎졠嫞"
-                                                                                                                                                                                                                                                                                                                 }
-                                                                                                                                                                                                                                                                                                                ]
-                                                                                                                                                                                                                                                                                                               ]
-                                                                                                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                                                                                                            ]
-                                                                                                                                                                                                                                                                                                           ]}}
-                                                                                                                                                                                                                                                                                                          }
-                                                                                                                                                                                                                                                                                                         ]}
-                                                                                                                                                                                                                                                                                                        },
-                                                                                                                                                                                                                                                                                                        "뿋뀾淣截䔲踀&XJ펖꙯^Xb訅ꫥgᬐ>棟S\"혧騾밫겁7-": "擹8C憎W\"쵮yR뢩浗絆䠣簿9䏈引Wcy䤶孖ꯥ;퐌]輩䍐3@{叝 뽸0ᡈ쵡Ⲇ\u001dL匁꧐2F~ݕ㪂@W^靽L襒ᦘ~沦zZ棸!꒲栬R"
-                                                                                                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                                                                                                     ],
-                                                                                                                                                                                                                                                                                                     "Z:덃൛5Iz찇䅄駠㭧蓡K1": "e8᧤좱U%?ⵇ䯿鿝\u0013縮R∱骒EO\u000fg?幤@֗퉙vU`",
-                                                                                                                                                                                                                                                                                                     "䐃쪈埽້=Ij,쭗쓇చ": false
-                                                                                                                                                                                                                                                                                                    }]}}
-                                                                                                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                                                                                 ]}
-                                                                                                                                                                                                                                                                                                }
-                                                                                                                                                                                                                                                                                               ]
-                                                                                                                                                                                                                                                                                              ]
-                                                                                                                                                                                                                                                                                             ],
-                                                                                                                                                                                                                                                                                             "咰긖VM]᝼6䓑쇎琺etDҌ?㞏ꩄ퇫밉gj8蠃\"⩐5䛹1ࣚ㵪": "ക蹊?⎲⧘⾚̀I#\"䈈⦞돷`wo窭戕෱휾䃼)앷嵃꾞稧,Ⴆ윧9S?೗EMk3Მ3+e{⹔Te驨7䵒?타Ulg悳o43"
-                                                                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                                                                           ],
-                                                                                                                                                                                                                                                                                           "zQᤚ纂땺6#ٽ﹧v￿#ࠫ휊冟蹧텈ꃊʆ?&a䥯De潝|쿓pt瓞㭻啹^盚2Ꝋf醪,얏T窧\\Di䕎谄nn父ꋊE": -2914269627845628872,
-                                                                                                                                                                                                                                                                                           "䉩跐|㨻ᷢ㝉B{蓧瞸`I!℄욃힕#ೲᙾ竛ᔺCjk췒늕貭词\u0017署?W딚%(pꍁ⤼띳^=on뺲l䆼bzrﳨ[&j狸䠠=ᜑꦦ\u2061յnj=牲攑)M\\龏": false,
-                                                                                                                                                                                                                                                                                           "뎕y絬᫡⥮Ϙᯑ㌔/NF*˓.,QEzvK!Iwz?|쥾\"ꩻL꼗Bꔧ賴緜s뉣隤茛>ロ?(?^`>冺飒=噸泥⺭Ᲊ婓鎔븜z^坷裮êⓅ໗jM7ﶕ找\\O": 1.376745434746303E-19
-                                                                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                                                                          "䐛r滖w㏤<k;l8ꡔጵ⮂ny辶⋃퍼僮z\"﮲X@t5෼暧퓞猋♅䦖QC鹮|픨( ,>,|Nዜ": false
-                                                                                                                                                                                                                                                                                         }
-                                                                                                                                                                                                                                                                                        ]],
-                                                                                                                                                                                                                                                                                        "@꿙?薕尬 gd晆(띄5躕ﻫS蔺4)떒錸瓍?~": 1665108992286702624,
-                                                                                                                                                                                                                                                                                        "w믍nᏠ=`঺ￆC>'從됐槷䤝眷螄㎻揰扰XￊC贽uჍ낟jKD03T!lDV쀉Ӊy뢖,袛!终캨G?鉮Q)⑗1쾅庅O4ꁉH7?d\u0010蠈줘월ސ粯Q!낇껉6텝|{": null,
-                                                                                                                                                                                                                                                                                        "~˷jg쿤촖쉯y": -5.5527605669177098E18,
-                                                                                                                                                                                                                                                                                        "펅Wᶺzꐆと푭e?4j仪열[D<鈑皶婆䵽ehS?袪;HꍨM뗎ば[(嗏M3q퍟g4y╸鰧茀[Bi盤~﫝唎鋆彺⦊q?B4쉓癚O洙킋툈䶯_?ퟲ": null
-                                                                                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                                                                                     ]]
-                                                                                                                                                                                                                                                                                    ]],
-                                                                                                                                                                                                                                                                                    "꟱Ԕ㍤7曁聯ಃ錐V䷰?v㪃૦~K\"$%请|ꇹn\"k䫛㏨鲨\u2023䄢\u0004[<S8ᐬ뭩脥7U.m࿹:D葍┆2蘸^U'w1젅;䠆ꋪB껮>︊VJ?䶟ាꮈ䗱=깘U빩": -4863152493797013264
-                                                                                                                                                                                                                                                                                   }
-                                                                                                                                                                                                                                                                                  ]}]}
-                                                                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                                                                }}}
-                                                                                                                                                                                                                                                                               ],
-                                                                                                                                                                                                                                                                               "쏷쐲۹퉃~aE唙a챑,9㮹gLHd'䔏|킗㍞䎥&KZYT맵7䥺N<Hp4ꕭ⹠꽐c~皽z": "课|ᖾ䡁廋萄䐪W\u0016&Jn괝b~摓M>ⱳ同莞鿧w\\༌疣n/+ꎥU\"封랾○ퟙAJᭌ?9䛝$?驔9讐짘魡T֯c藳`虉C읇쐦T"
-                                                                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                                                                             ],
-                                                                                                                                                                                                                                                                             "谶개gTR￐>ၵ͚dt晑䉇陏滺}9㉸P漄": -3350307268584339381
-                                                                                                                                                                                                                                                                            }]
-                                                                                                                                                                                                                                                                           ]
-                                                                                                                                                                                                                                                                          ]
-                                                                                                                                                                                                                                                                         ]]
-                                                                                                                                                                                                                                                                        ]
-                                                                                                                                                                                                                                                                       ],
-                                                                                                                                                                                                                                                                       "0y꟭馋X뱔瑇:䌚￐廿jg-懲鸭䷭垤㒬茭u賚찶ಽ+\\mT땱\u20821殑㐄J쩩䭛ꬿNS潔*d\\X,壠뒦e殟%LxG9:摸": 3737064585881894882,
-                                                                                                                                                                                                                                                                       "풵O^-⧧ⅶvѪ8廸鉵㈉ר↝Q㿴뺟EႳvNM:磇>w/៻唎뷭୥!냹D䯙i뵱貁C#⼉NH6`柴ʗ#\\!2䂗Ⱨf?諳.P덈-返I꘶6?8ꐘ": -8934657287877777844,
-                                                                                                                                                                                                                                                                       "溎-蘍寃i诖ര\"汵\"\ftl,?d⼡쾪⺋h匱[,෩I8MҧF{k瓿PA'橸ꩯ綷퉲翓": null
-                                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                                    ],
-                                                                                                                                                                                                                                                                    "ោ係؁<元": 1.7926963090826924E-18
-                                                                                                                                                                                                                                                                   }}]
-                                                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                                                ]]}]
-                                                                                                                                                                                                                                                               }]
-                                                                                                                                                                                                                                                              ]
-                                                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                                                            ]
-                                                                                                                                                                                                                                                           ],
-                                                                                                                                                                                                                                                           "ጩV<\"ڸsOᤘ": 2.0527167903723048E-19
-                                                                                                                                                                                                                                                          }]
-                                                                                                                                                                                                                                                         ]}
-                                                                                                                                                                                                                                                        ]
-                                                                                                                                                                                                                                                       ]],
-                                                                                                                                                                                                                                                       "∳㙰3젴p᧗䱙?`<U὇<\/意E[ᮚAj诂ᒽ阚uv徢ဎ떗尔Ᵹ훀쩑J䐴?⪏=륪ᆩ푰ஓ㐕?럽VK\"X?檨လ齿I/耉A(AWA~⏯稐蹫": false,
-                                                                                                                                                                                                                                                       "偒妝뾇}䀼链i⇃%⋜&璪Ix渥5涧qq棩ᥝ-⠫AA낇yY颕A*裦O|n?䭬혗F": null,
-                                                                                                                                                                                                                                                       "琭CL얭B혆Kॎ`鎃nrsZiժW砏)?p~K~A眱䲏QO妣\u001b\u001b]ᵆᆯ&㐋ᏹ豉뺘$ꭧ#j=C)祤⫢歑1o㒙諩": 7028426989382601021,
-                                                                                                                                                                                                                                                       "쳱冲&ဤ䌏앧h胺-齱H忱8왪RDKᅒ䬋ᔶS*J}ስ漵'㼹뮠9걢9p봋경ጕtởꚳT䶽瘙%춴`@nಆ4<d??#僜ᙤ钴=薔ꭂbLXNam蹈": "樭る蹿= Uurwkn뙧⌲%\"쑃牪\"cq윕o@",
-                                                                                                                                                                                                                                                       "溌[H]焎SLㅁ?뀼䫨災W": 1.1714289118497062E-19,
-                                                                                                                                                                                                                                                       "ﬢp븇剌燇kĔ尘㶿㴞睠꾘Ia;s❺^)$穮?sHᢥ폪l": null
-                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                  "TKnzj5o<\/K㊗ꗣ藠⦪駇>yZA8Ez0,^ᙛ4_0븢\u001ft:~䎼s.bb룦明yNP8弆C偯;⪾짍'蕴뮛": -6976654157771105701,
-                                                                                                                                                                                                                                                  "큵ꦀ\\㇑:nv+뒤燻䀪ﴣ﷍9ᚈ኷K㚊誦撪䚛,ꮪxሲ쳊\u0005HSf?asg昱dqꬌVꙇ㼺'k*'㈈": -5.937042203633044E-20
-                                                                                                                                                                                                                                                 }
-                                                                                                                                                                                                                                                ]
-                                                                                                                                                                                                                                               }],
-                                                                                                                                                                                                                                               "?}\u20e0],s嶳菋@#2u쒴sQS䩗=ꥮ;烌,|ꘔ䘆": "ᅩ영N璠kZ먕眻?2ቲ芋眑D륟渂⸑ﴃIRE]啗`K'"
-                                                                                                                                                                                                                                              }},
-                                                                                                                                                                                                                                              "쨀jmV賂ﰊ姐䂦玞㬙ᏪM᪟Վ씜~`uOn*ॠ8\u000ef6??\\@/?9見d筜ﳋB|S䝬葫㽁o": true
-                                                                                                                                                                                                                                             },
-                                                                                                                                                                                                                                             "즛ꄤ酳艚␂㺘봿㎨iG৕ࡿ?1\"䘓您\u001fSኝ⺿溏zៀ뻤B\u0019?윐a䳵᭱䉺膷d:<\/": 3935553551038864272
-                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                           ]
-                                                                                                                                                                                                                                          ]}
-                                                                                                                                                                                                                                         ]]
-                                                                                                                                                                                                                                        ]]
-                                                                                                                                                                                                                                       ]}
-                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                   ]]}},
-                                                                                                                                                                                                                                   "᥺3h↛!ꋰy\"攜(ெl䪕oUkc1A㘞ᡲ촾ᣫ<\/䒌E㛝潨i{v?W౾H\\RჅpz蝬R脾;v:碽✘↯삞鷱o㸧瑠jcmK7㶧뾥찲n": true,
-                                                                                                                                                                                                                                   "ⶸ?x䊺⬝-䰅≁!e쩆2ꎿ准G踌XXᩯ1߁}0?.헀Z馟;稄\baDꟹ{-寪⚈ꉷ鮸_L7ƽᾚ<\u001bጨA䧆송뇵⨔\\礍뗔d设룱㶉cq{HyぱR㥽吢ſtp": -7985372423148569301,
-                                                                                                                                                                                                                                   "緫#콮IB6<\/=5Eh礹\t8럭@饹韠r㰛斣$甝LV췐a갵'请o0g:^": "䔨(.",
-                                                                                                                                                                                                                                   "띳℡圤pﾝ௄ĝ倧訜B쁟G䙔\"Sb⓮;$$▏S1J뢙SF|赡g*\"Vu䲌y": "䪈&틐),\\kT鬜1풥;뷴'Zေ䩹@J鞽NぼM?坥eWb6榀ƩZڮ淽⺞삳煳xჿ絯8eⶍ羷V}ჿ쎱䄫R뱃9Z>'\u20f1ⓕ䏜齮"
-                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                ]]]
-                                                                                                                                                                                                                               }}
-                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                            ]},
-                                                                                                                                                                                                                            "펮b.h粔폯2npX詫g錰鷇㇒<쐙S値bBi@?镬矉`剔}c2壧ଭfhY깨R()痩⺃a\\⍔?M&ﯟ<劜꺄멊ᄟA\"_=": null
-                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                           "~潹Rqn榢㆓aR鬨侅?䜑亡V_翅㭔(䓷w劸ၳDp䀅<\/ﰎ鶊m䵱팱긽ꆘ<tD쇋>긓准D3掱;o:_ќ)껚콥8곤d矦8nP倥ꃸI": null,
-                                                                                                                                                                                                                           "뾎/Q㣩㫸벯➡㠦◕挮a鶧⋓偼\u00001뱓fm覞n?㛅\"": 2.8515592202045408E17
-                                                                                                                                                                                                                          }],
-                                                                                                                                                                                                                          ",": -5426918750465854828,
-                                                                                                                                                                                                                          "2櫫@0柡g䢻/gꆑ6演&D稒肩Y?艘/놘p{f투`飷ᒉ챻돎<늛䘍ﴡ줰쫄": false,
-                                                                                                                                                                                                                          "8(鸑嵀⵹ퟡ<9㣎Tߗ┘d슒ل蘯&㠦뮮eࠍk砝g 엻": false,
-                                                                                                                                                                                                                          "d-\u208b?0ﳮ嵙'(J`蔿d^踅⤔榥\\J⵲v7": 6.8002426206715341E17,
-                                                                                                                                                                                                                          "ཎ耰큓ꐕ㱷\u0013y=詽I\"盈xm{0쾽倻䉚ષso#鰑/8㸴짯%ꀄ떸b츟*\\鲷礬ZQ兩?np㋄椂榨kc᡹醅3": false,
-                                                                                                                                                                                                                          "싊j20": false
-                                                                                                                                                                                                                         }]]
-                                                                                                                                                                                                                        ]],
-                                                                                                                                                                                                                        "俛\u0017n緽Tu뫉蜍鼟烬.ꭠIⰓ\"Ἀ᜾uC쎆J@古%ꛍm뻨ᾀ画蛐휃T:錖㑸ዚ9죡$": true
-                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                     ],
-                                                                                                                                                                                                                     "㍵⇘ꦖ辈s}㱮慀밒s`\"㞟j:`i픻Z<C1衽$\"-饧?℃\u0010⼒{p飗%R\"䲔\")칀\\%": true,
-                                                                                                                                                                                                                     "苧.8\u00120ݬ仓": 6912164821255417986,
-                                                                                                                                                                                                                     "떎顣俁X;.#Q틝.笂'p쟨唒퐏랩냆¦aⱍ{谐.b我$蜑SH\u000f琾=䟼⣼奔ᜏ攕B&挰繗㝔ꅂ-Qv\\0䶝䚥ぺio［㑮-ᇼ䬰컪ṼiY){데\u0010q螰掻~\n輚x\u0014罺)軴": 3.024364150712629E-20
-                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                  ]
-                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                ]}
-                                                                                                                                                                                                               ]]
-                                                                                                                                                                                                              }
-                                                                                                                                                                                                             ]
-                                                                                                                                                                                                            ]]
-                                                                                                                                                                                                           ]
-                                                                                                                                                                                                          ]]]],
-                                                                                                                                                                                                          "\"凲o肉Iz絾豉J8?i~傠᫽䇂!WD溊J?ᡒvs菆嵹➒淴>섫^諎0Ok{켿歁෣胰a2﨤[탳뚬쎼嫭뉮m": 409440660915023105,
-                                                                                                                                                                                                          "w墄#*ᢄ峠밮jLa`ㆪ꺊漓Lで끎!Agk'ꁛ뢃㯐岬D#㒦": false,
-                                                                                                                                                                                                          "ଦPGI䕺L몥罭ꃑ궩﮶#⮈ᢓӢ䚬p7웼臧%~S菠␌힀6&t䳙y㪘냏\\*;鉏ￊ鿵'嗕pa\"oL쇿꬈Cg": "㶽1灸D⟸䴅ᆤ뉎﷛渤csx 䝔цꬃ锚捬?ຽ+x~꘩uI࡞\u0007栲5呚ẓem?袝\")=㥴䨃pac!/揎Y",
-                                                                                                                                                                                                          "ᷱo\\||뎂몷r篙|#X䦜I#딌媸픕叞RD斳X4t⯩夬=[뭲r=绥jh뷱츝⪘%]⚋܈㖴スH텹m(WO曝劉0~K3c柢Ր㏉着逳~": false,
-                                                                                                                                                                                                          "煽_qb[첑\\륌wE❽ZtCNﭝ+餌ᕜOꛭ": "{ﳾ쉌&s惧ᭁⵆ3䢫;䨞팑꒪흘褀࢖Q䠿V5뭀䎂澻%받u5텸oA⮥U㎦;B䳌wz䕙$ឿ\\௅婺돵⪾퐆\\`Kyौꋟ._\u0006L챯l뇠Hi䧈偒5",
-                                                                                                                                                                                                          "艊佁ࣃ롇䱠爬!*;⨣捎慓q靓|儑ᨋL+迥=6㒺딉6弄3辅J-㕎뛄듘SG㆛(\noAzQꝱ䰩X*ぢO퀌%펠낌mo틮a^<\/F&_눊ᾉ㨦ы4\"8H": 2974648459619059400,
-                                                                                                                                                                                                          "鬙@뎣䫳ၮ끡?){y?5K;TA*k溱䫜J汃ꂯ싔썍\u001dA}룖(<\/^,": false,
-                                                                                                                                                                                                          "몏@QꋦFꊩᒐ뎶lXl垨4^郣|ꮇ;䝴ᝓ}쵲z珖": null
-                                                                                                                                                                                                         }
-                                                                                                                                                                                                        ]]]],
-                                                                                                                                                                                                        ":_=닧弗D䙋暨鏛. 㱻붘䂍J儒&ZK/녩䪜r囁⽯D喠죥7⹌䪥c\u001a\u2076￞妈朹oLk菮F౟覛쐧㮏7T;}蛙2{9\"崓bB<\/⡷룀;즮鿹)丒툃୤뷠5W⊢嶜(fb뭳갣": "E{响1WM"
-                                                                                                                                                                                                       }},
-                                                                                                                                                                                                       "䘨tjJ驳豨?y輊M*᳑梵瞻઻ofQG瑮e": 2.222802939724948E-19,
-                                                                                                                                                                                                       "䮴=❑➶T෋w䞜\"垦ꃼUt\u001dx;B$뵣䙶E↌艣ᡥ!᧟;䱀[䔯k쬃`੍8饙른熏'2_'袻tGf蒭J땟as꯳╖&啒zWࡇᒫYSᏬ\u0014ℑ첥鈤|cG~Pᓮ\">\"": "ႆl\f7V儊㦬nHꄬꨧC{쐢~C⮃⛓嶦vꄎ1w鰠嘩뿠魄&\"_qMⵖ釔녮ꝇ 㝚{糍J哋 cv?-jkﻯྌ鹑L舟r",
-                                                                                                                                                                                                       "龧葆yB✱H盋夔ﶉ?n*0(": "ꧣኆ㢓氥qZZ酒ຜ)鮢樛)X䣆gTSґG텞k.J圬疝롫쯭z L：\\ྤ@w炋塜쿖ᾳy뢀䶃뱝N䥨㚔勇겁#p",
-                                                                                                                                                                                                       "도畎Q娡\"@S/뼋:䵏!P衅촚fVHQs✜ᐫi㻑殡B䜇%믚k*U#濨낄~": "ꍟዕ쳸ꍈ敋&l妏\u0005憡멗瘌uPgᅪm<\/To쯬锩h뒓k"
-                                                                                                                                                                                                      }
-                                                                                                                                                                                                     ]
-                                                                                                                                                                                                    }],
-                                                                                                                                                                                                    "墥홞r绚<\/⸹ⰃB}<躅\\Y;๑@䔸>韫䜲뱀X뗩鿥쩗SI%ﴞ㳕䛇?<\/\u00018x\\&侂9鋙a[LR㋭W胕)⡿8㞙0JF,}?허d1cDMᐃ␛鄝ⱕ%X)!XQ": "ⳍꗳ=橇a;3t⦾꼑仈ူaᚯ⯋ꕃAs鴷N⍕_䎃ꙎAz\u0016䯷\\<࿫>8q{}ｷ?ᣰ}'0ᴕ펓B┦lF#趤厃T?㕊#撹圂䆲"
-                                                                                                                                                                                                   },
-                                                                                                                                                                                                   "܋닐龫論c웑": false,
-                                                                                                                                                                                                   "ㇿ/q\"6-co髨휝C큦#\u001b4~?3䐹E삇<<": 7.600917488140322E-20,
-                                                                                                                                                                                                   "䁝E6?㣖ꃁ间t祗*鑠{ḣV(浾h逇큞=W?ૉ?nꇽ8ꅉຉj으쮺@Ꚅ㰤u]Oyr": "v≁᫸_*όAඤԆl)ۓᦇQ}폠z༏q滚",
-                                                                                                                                                                                                   "ｿ᥊/넺I": true
-                                                                                                                                                                                                  }]]
-                                                                                                                                                                                                 ]
-                                                                                                                                                                                                ]
-                                                                                                                                                                                               ]
-                                                                                                                                                                                              ]]
-                                                                                                                                                                                             },
-                                                                                                                                                                                             "䭑Ik攑\u0002QV烄:芩.麑㟴㘨≕": true,
-                                                                                                                                                                                             "坄꿕C쇻풉~崍%碼\\8\"䬦꣙": null,
-                                                                                                                                                                                             "欌L圬䅘Y8c(♺2?ON}o椳s宥2䉀eJ%闹r冁O^K諭%凞⺉⡻,掜?$ꥉ?略焕찳㯊艼誜4?\"﯎<゛XፈINT:詓 +": -1.0750456770694562E-19,
-                                                                                                                                                                                             "獒àc뜭싼ﺳ뎤K`]p隨LtE": null,
-                                                                                                                                                                                             "甙8䵊神EIꩤ鐯ᢀ,ﵮU䝑u疒ử驺䚿≚ഋ梶秓F`覤譐#짾蔀묊4<媍쬦靪_Yzgcࡶ4k紥`kc[Lﮗ簐*I瀑[⾰L殽鑥_mGȠ<\/|囹灠g桰iri": true,
-                                                                                                                                                                                             "챓ꖙꟻ좝菇ou,嗠0\\jK핻뜠qwQ?ഩ㼕3Y彦b\u009bJ榶N棨f?됦鏖綃6鳵M[OE봨u햏.Ꮁ癜蟳뽲ꩌ뻾rM豈R嗀羫 uDꎚ%": null
-                                                                                                                                                                                            },
-                                                                                                                                                                                            "V傜2<": 7175127699521359521
-                                                                                                                                                                                           }],
-                                                                                                                                                                                           "铫aG切<\/\"ী⊆e<^g࢛)D顝ｎאַ饼\u008c猪繩嵿ﱚCꡬ㻊g엺A엦\u000f暿_f꿤볝㦕桦`蒦䎔j甬%岝rj 糏": "䚢偎눴Au<4箞7礦Iﱔ坠eȧ䪸u䵁p|逹$嗫쨘ꖾ﷐!胠z寓팢^㨔|u8Nሇe텔ꅦ抷]،鹎㳁#༔繁 ",
-                                                                                                                                                                                           "낂乕ꃻ볨ϱ-ꇋ㖍fs⿫)zꜦ/K?솞♞ꑌ宭hJ᤭瑥Fu": false,
-                                                                                                                                                                                           "쟰ぜ魛G\u0003u?`㾕ℾ㣭5螠烶這趩ꖢ:@咕ꐶx뒘느m䰨b痃렐0鳊喵熬딃$摉_~7*ⱦ녯1錾GKhJ惎秴6'H妈Tᧅ窹㺒疄矤铟wላ": null,
-                                                                                                                                                                                           "쯆q4!3錕㲏ⵆ㇛꘷Z瑩뭆\\◪NH\u001d\\㽰U~㯶<\"쑣낞3ᵤ'峉eꢬ;鬹o꣒木X*長PXᘱu\"䠹n惞": null,
-                                                                                                                                                                                           "ᅸ祊\"&ꥴCjࢼ﴿?䡉`U效5殼㮞V昽ꏪ#ﺸ\\&t6x꠹盥꣰a[\u001aꪍSpe鎿蠹": -1.1564713893659811E-19
-                                                                                                                                                                                          }
-                                                                                                                                                                                         ]]
-                                                                                                                                                                                        ]
-                                                                                                                                                                                       ]
-                                                                                                                                                                                      ],
-                                                                                                                                                                                      "羵䥳H,6ⱎ겾|@t\"#햊1|稃 섭)띜=뻔ꡜ???櫎~*ῡ꫌/繣ﻠq": null
-                                                                                                                                                                                     }
-                                                                                                                                                                                    ]}
-                                                                                                                                                                                   ]},
-                                                                                                                                                                                   "츤": false
-                                                                                                                                                                                  }},
-                                                                                                                                                                                  "s": 3.7339341963399598E18
-                                                                                                                                                                                 }
-                                                                                                                                                                                ],
-                                                                                                                                                                                "N,I?1+㢓|ࣱ嶃쩥V2\u0012(4EE虪朶$|w颇v步": "~읢~_,Mzr㐫YB溓E淚\"ⅹ䈔ᏺ抙 b,nt5V㐒J檶ꏨ⻔?",
-                                                                                                                                                                                "Q껑ꡡ}$넎qH煔惍/ez^!ẳF댙䝌馻剁8": "梲;yt钰$i冄}AL%a j뜐奷걳뚾d꿽*ሬuDY3?뮟鼯뮟w㍪틱V",
-                                                                                                                                                                                "o{Q/K O胟㍏zUdꀐm&⨺J舕⾏魸訟㌥[T籨櫉唐킝 aṭ뱫촙莛>碶覆⧬짙쭰ׯdAiH໥벤퐥_恸[ 0e:죃TC弼荎뵁DA:w唵ꣁ": null,
-                                                                                                                                                                                "὏樎䵮軧|?౗aWH쩃1 ꅭsu": null
-                                                                                                                                                                               }
-                                                                                                                                                                              ]
-                                                                                                                                                                             },
-                                                                                                                                                                             "勂\\&m鰈J釮=Ⲽ鳋+䂡郑": null,
-                                                                                                                                                                             "殣b綊倶5㥗惢⳷萢ᑀ䬄镧M^ﱴ3⣢翣n櫻1㨵}ኯ뗙顖Z.Q➷ꮨ뗇\u0004": "ꔙ䁼>n^[GीA䨟AM琢ᒊS쨲w?d㶣젊嘶纝麓+愣a%気ྞSc됓ᔘ:8bM7Xd8㶑臌]Ꙥ0ꐭ쒙䫣挵C薽Dfⵃ떼᷸",
-                                                                                                                                                                             "?紡.셪_෨j\u0013Ox┠$Xᶨ-ᅇo薹-}軫;y毝㪜K㣁?.EV쮱4둽⛻䤜'2盡\u001f60(|e쐰㼎ᦀ㒧-$l@ﻑ坳\u0003䭱响巗WFo5c㧆T턁Y맸♤(": -2.50917882560589088E17
-                                                                                                                                                                            }}
-                                                                                                                                                                           ],
-                                                                                                                                                                           "侸\\릩.᳠뎠狣살cs项䭩畳H1s瀉븇19?.w骴崖㤊h痠볭㞳㞳䁮Ql怠㦵": "@䟴-=7f",
-                                                                                                                                                                           "鹟1x௢+d ;vi䭴FSDS\u0004hꎹ㚍?⒍⦏ў6u,扩@됷Su)Pag휛TᒗV痩!瞏釀ꖞ蘥&ೞ蘐ꭰꞇᝎ": "ah懱Ժ&\u20f7䵅♎඀䞧鿪굛ౕ湚粎蚵ᯋ幌YOE)५襦㊝Y*^\"R+ඈ咷蝶9ꥂ榨艦멎헦閝돶v좛咊E)K㓷ྭr",
-                                                                                                                                                                           "搆q쮦4綱켙셁.f4<\/g<籽늷?#蚴픘:fF\u00051㹉뀭.ᰖ풎f֦Hv蔎㧤.!䭽=鞽]음H:?\"-4": 8.740133984938656E-20
-                                                                                                                                                                          }]}
-                                                                                                                                                                         }
-                                                                                                                                                                        ],
-                                                                                                                                                                        "tVKn딩꘥⊾蹓᤹{\u0003lR꼽ᄲQFᅏ傅ﱋ猢⤊ᔁ,E㓒秤nTතv`♛I\u0000]꫔ṞD\"麵c踝杰X&濿또꣹깳౥葂鿎\\aꡨ?": 3900062609292104525
-                                                                                                                                                                       }
-                                                                                                                                                                      ],
-                                                                                                                                                                      "ਉ샒⊩Lu@S䧰^g": -1.1487677090371648E18,
-                                                                                                                                                                      "⎢k⑊꬗yᏫ7^err糎Dt\u000bJ礯확ㆍ沑ｻꋽe赔㝢^J\u0004笲㿋idra剰-᪉C錇/Ĝ䂾ညS지?~콮gR敉⬹'䧭": 1901472137232418266,
-                                                                                                                                                                      "灗k䶥:?촽贍쓉꓈㒸g獘[뵎\\胕?\u0014_榙p.j稶,$`糉妋0>Fᡰly㘽$?": "]ꙛO赎&#㠃돱剳\"<◆>0誉齐_|z|裵씪>ᐌ㼍\"Z[琕}O?G뚇諦cs⠜撺5cu痑U圲\u001c?鴴計l춥/╓哼䄗茏ꮅ뫈댽A돌롖뤫V窗讬sHd&\nOi;_u"
-                                                                                                                                                                     }
-                                                                                                                                                                    ],
-                                                                                                                                                                    "Uﺗ\\Y\\梷䄬~\u0002": null,
-                                                                                                                                                                    "k\"Y磓ᗔ휎@U冈<\/w컑)[": false,
-                                                                                                                                                                    "曏J蝷⌻덦\u001f㙳s꥓⍟邫P늮쥄c∬ྡྷ舆렮칤Z趣5콡넛A쳨\\뀙骫(棻.*&輛LiIfi{@EA婳KᬰTXT": -4.3088230431977587E17
-                                                                                                                                                                   }]}
-                                                                                                                                                                  ]
-                                                                                                                                                                 ],
-                                                                                                                                                                 "곃㲧<\/dఓꂟs其ࡧ&N葶=?c㠤Ჴ'횠숄臼#\u001a~": false
-                                                                                                                                                                }
-                                                                                                                                                               ]
-                                                                                                                                                              ]}]
-                                                                                                                                                             }]
-                                                                                                                                                            }}
-                                                                                                                                                           ],
-                                                                                                                                                           "2f`⽰E쵟>J笂裭!〛觬囀ۺ쟰#桊l鹛ⲋ|RA_Vx፭gE됓h﵀mfỐ|?juTU档[d⢼⺻p濚7E峿": 5613688852456817133
-                                                                                                                                                          },
-                                                                                                                                                          "濘끶g忮7㏵殬W팕Q曁 뫰)惃廊5%-蹚zYZ樭ﴷQ锘쯤崫gg": true,
-                                                                                                                                                          "絥ᇑ⦏쒓븣爚H.㗊߄o蘵貆ꂚ(쎔O᥉ﮓ]姨Wꁓ!RMA|o퉢THx轮7M껁U즨'i뾘舯o": "跥f꜃?"
-                                                                                                                                                         }}
-                                                                                                                                                        ],
-                                                                                                                                                        "鷰鹮K-9k;ﰰ?_ݦѷ-ꅣ䩨Zꥱ\"mꠟ屎/콑Y╘2&鸞脇㏢ꀇ࠺ⰼ拾喭틮L꽩bt俸墶 [l/웄\"꾦\u20d3iও-&+\u000fQ+໱뵞": -1.296494662286671E-19
-                                                                                                                                                       },
-                                                                                                                                                       "HX੹/⨇୕붷Uﮘ旧\\쾜͔3l鄈磣糂̖䟎Eᐳw橖b῀_딕hu葰窳闹вU颵|染H죶.fP䗮:j䫢\\b뎖i燕ꜚG⮠W-≚뉗l趕": "ଊ칭Oa᡺$IV㷧L\u0019脴셀붿餲햪$迳向쐯켂PqfT\" ?I屉鴼쿕@硙z^鏕㊵M}㚛T젣쓌-W⩐-g%⺵<뮱~빅╴瑿浂脬\u0005왦燲4Ⴭb|D堧 <\/oEQh",
-                                                                                                                                                       "䘶#㥘੐캔f巋ἡAJ䢚쭈ࣨ뫒*mᇊK，ࣺAꑱ\u000bR<\/A\"1a6鵌㯀bh곿w(\"$ꘁ*rಐ趣.d࿩k/抶면䒎9W⊃9": "漩b挋Sw藎\u0000",
-                                                                                                                                                       "畀e㨼mK꙼HglKb,\"'䤜": null
-                                                                                                                                                      }]}]
-                                                                                                                                                     ]
-                                                                                                                                                    ]
-                                                                                                                                                   }]
-                                                                                                                                                  ]}
-                                                                                                                                                 ]
-                                                                                                                                                ]}
-                                                                                                                                               ],
-                                                                                                                                               "歙>駿ꣂ숰Q`J΋方樛(d鱾뼣(뫖턭\u20f9lচ9歌8o]8윶l얶?镖G摄탗6폋폵+g:䱫홊<멀뀿/س|ꭺs걐跶稚W々c㫣⎖": "㣮蔊깚Cꓔ舊|XRf遻㆚︆'쾉췝\\&言",
-                                                                                                                                               "殭\"cށɨꝙ䞘:嬮e潽Y펪㳅/\"O@ࠗ겴]췖YǞ(t>R\"N?梳LD恭=n氯T豰2R諸#N}*灧4}㶊G䍣b얚": null,
-                                                                                                                                               "襞<\/啧 B|싞W瓇)6簭鼡艆lN쩝`|펭佡\\間邝[z릶&쭟愱ꅅ\\T᰽1鯯偐栈4̸s윜R7⒝/똽?치X": "⏊躖Cﱰ2Qẫ脐&இ?%냝悊",
-                                                                                                                                               ",鰧偵셣싹xᎹ힨᯳EṬH㹖9": -4604276727380542356
-                                                                                                                                              }
-                                                                                                                                             }
-                                                                                                                                            ]]]],
-                                                                                                                                            "웺㚑xs}q䭵䪠馯8?LB犯zK'os䚛HZ\"L?셎s^㿧㴘Cv2": null
-                                                                                                                                           }]
-                                                                                                                                          ]
-                                                                                                                                         ]
-                                                                                                                                        ],
-                                                                                                                                        "Kd2Kv+|z": 7367845130646124107,
-                                                                                                                                        "ᦂⶨ?ᝢ 祂些ഷ牢㋇操\"腭䙾㖪\\(y4cE뽺ㆷ쫺ᔖ%zfۻ$ў1柦,㶢9r漢": -3.133230960444846E-20,
-                                                                                                                                        "琘M焀q%㢟f鸯O⣏蓑맕鯊$O噷|)z褫^㢦⠮ꚯ꫞`毕1qꢚ{ĭ䎀বώT\"뱘3G൴?^^of": null
-                                                                                                                                       }
-                                                                                                                                      ],
-                                                                                                                                      "a8V᯺?:ﺃ/8ꉿBq|9啓댚;*i2": null,
-                                                                                                                                      "cpT瀇H珰Ừpೃi鎪Rr␣숬-鹸ҩ䠚z脚цGoN8入y%趌I┽2ឪЀiJNcN)槣/▟6S숆牟\"箑X僛G殱娇葱T%杻:J諹昰qV쨰": 8331037591040855245
-                                                                                                                                     }],
-                                                                                                                                     "G5ᩜ䄗巢껳": true
-                                                                                                                                    }
-                                                                                                                                   },
-                                                                                                                                   "Ồ巢ゕ@_譙A`碫鄐㡥砄㠓(^K": "?܃B혢▦@犑ὺD~T⧁|醁;o=J牌9냚⢽㨘{4觍蚔9#$∺\u0016p囅\\3Xk阖⪚\"UzA穕롬✎➁㭒춺C㣌ဉ\"2瓑员ᅽꝶ뫍}꽚ꞇ鶂舟彺]ꍽJC蝧銉",
-                                                                                                                                   "␆Ě膝\"b-퉐ACR言J謈53~V튥x䜢?ꃽɄY뮩ꚜ": "K/↾e萃}]Bs⾿q룅鷦-膋?m+死^魊镲6",
-                                                                                                                                   "粡霦c枋AHퟁo礼Ke?qWcA趸㡔ꂏ?\u000e춂8iতᦜ婪\u0015㢼nﵿꍻ!ᐴ関\u001d5j㨻gfῩUK5Ju丝tかTI'?㓏t>⼟o a>i}ᰗ;뤕ܝ": false,
-                                                                                                                                   "ꄮ匴껢ꂰ涽+䜨B蛹H䛓-k蕞fu7kL谖,'涃V~챳逋穞cT\"vQ쓕ObaCRQ㓡Ⲯ?轭⫦輢墳?vA餽=h䮇킵n폲퉅喙?\"'1疬V嬗Qd灗'Lự": "6v!s믁㭟㣯獃!磸餠ቂh0C뿯봗F鷭gꖶ~ｺkK<ᦈTt\\跓w㭣횋钘ᆹ듡䑚W䟾X'ꅔ4FL勉Vܴ邨y)2'〚쭉⽵-鞣E,Q.?块",
-                                                                                                                                   "?(˧쩯@崟吋歄K": null
-                                                                                                                                  },
-                                                                                                                                  "Gc럃녧>?2DYI鴿\\륨)澔0ᔬlx'觔7젘⤡縷螩%Sv׫묈/]↱&S h\u0006歋ᑛxi̘}ひY蔯_醨鯘煑橾8?䵎쨋z儬ꁏ*@츾:": null
-                                                                                                                                 }
-                                                                                                                                }
-                                                                                                                               }
-                                                                                                                              ]
-                                                                                                                             ]
-                                                                                                                            ]}
-                                                                                                                           },
-                                                                                                                           "HO츧G": 3.694949578823609E17,
-                                                                                                                           "QC\u0012(翻曇Tf㷟bGBJ옉53\\嚇ᛎD/\u001b夾၉4\"핀@祎)쫆yD\"i먎Vn㿿V1W᨝䶀": -6150931500380982286,
-                                                                                                                           "Z㓮P翸鍱鉼K䋞꘺튿⭁Y": -7704503411315138850,
-                                                                                                                           "]모开ꬖP븣c霤<[3aΠ\"黁䖖䰑뮋ꤦ秽∼㑷冹T+YUt\"싳F↭䖏&鋌": -2.7231911483181824E18,
-                                                                                                                           "tꎖ": -4.9517948741799555E-19,
-                                                                                                                           "䋘즊.⬅IꬃۣQ챢ꄑ黐|f?C⾺|兕읯sC鬸섾整腨솷V": "旆柩l<K髝M戶鯮t:wR2ꉱ`9'l픪*폍芦㊢Pjjo堡^  읇얛嶅있ষ0?F",
-                                                                                                                           "下9T挞\\$yᮇk쌋⼇,ਉ": true,
-                                                                                                                           "櫨:ㆣ,邍lr崕祜㐮烜Z,XXD蕼㉴ kM꯽?P0﹉릗": null,
-                                                                                                                           "gv솠歽閘4镳䗄2澾>쪦sᖸMy㦅울썉瘗㎜檵9ꍂ駓ૉᚿ/u3씅徐拉[Z䞸ࡗ1ꆱ&Ｑ풘?ǂ8\u0011BCDY2볨;鸏": null,
-                                                                                                                           "幫 n煥s쁇펇 왊-$C\"衝:\u0014㣯舼.3뙗Yl⋇\"K迎멎[꽵s}9鉳UK8쐥\"掄㹖h㙈!얄સ?Ꜳ봺R伕UTD媚Ｉ䜘W鏨蔮": -4.150842714188901E-17,
-                                                                                                                           "ﺯ^㄄\b죵@fྉkf颡팋Ꞧ{/Pm0V둳⻿/落韒ꊔᚬ@5螺G\\咸a谆⊪ቧ慷绖?财(鷇u錝F=r၍橢ឳn:^iᴵtD볠覅N赴": null
-                                                                                                                          }]
-                                                                                                                         }]
-                                                                                                                        }
-                                                                                                                       ]
-                                                                                                                      ]}
-                                                                                                                     ]},
-                                                                                                                     "謯?w厓奰T李헗聝ឍ貖o⪇弒L!캶$ᆅ": -4299324168507841322,
-                                                                                                                     "뺊奉_垐浸延몏孄Z舰2i$q붿좾껇d▵餏\"v暜Ҭ섁m￴g>": -1.60911932510533427E18
-                                                                                                                    }
-                                                                                                                   ]
-                                                                                                                  }
-                                                                                                                 ]
-                                                                                                                ]],
-                                                                                                                "퉝꺔㠦楶Pꅱ": 7517896876489142899,
-                                                                                                                "": false
-                                                                                                               }
-                                                                                                              ]},
-                                                                                                              "是u&I狻餼|谖j\"7c됮sסּ-踳鉷`䣷쉄_A艣鳞凃*m⯾☦椿q㎭N溔铉tlㆈ^": 1.93547720203604352E18,
-                                                                                                              "kⲨ\\%vr#\u000bⒺY\\t<\/3﬌R訤='﹠8蝤Ꞵ렴曔r": false
-                                                                                                             }
-                                                                                                            ]},
-                                                                                                            "阨{c?C\u001d~K?鎌Ԭ8烫#뙣P초遗t㭱E­돒䆺}甗[R*1!\\~h㕅᰺@<9JꏏષI䳖栭6綘걹ￌM\"▯是∔v鬽顭⋊譬": "운ﶁK敂(欖C취پ℄爦賾"
-                                                                                                           }
-                                                                                                          }}
-                                                                                                         }],
-                                                                                                         "鷨赼鸙+\\䭣t圙ڹx᜾ČN<\/踘\"S_맶a鷺漇T彚⎲i㈥LT-xA캔$\u001cUH=a0츺l릦": "溣㣂0濕=鉵氬駘>Pꌢpb솇쬤h힊줎獪㪬CrQ矠a&脍꼬爼M茴/΅\u0017弝轼y#Ꞡc6둴=?R崏뷠麖w?"
-                                                                                                        },
-                                                                                                        "閕ᘜ]CT)䵞l9z'xZF{:ؐI/躅匽졁:䟇AGF૸\u001cퟗ9)駬慟ꡒꆒRS״툋A<>\u0010\"ꂔ炃7g덚E৏bꅰ輤]o㱏_뷕ܘ暂\"u": "芢+U^+㢩^鱆8*1鈶鮀\u0002뺰9⬳ꪮlL䃣괟,G8\u20a8DF㉪錖0ㄤ瓶8Nଷd?眡GLc陓\\_죌V쁰ल二?c띦捱 \u0019JC\u0011b⤉zẒT볕\"绣蘨뚋cꡉkI\u001e鳴",
-                                                                                                        "ꃣI'{6u^㡃#཰Kq4逹y൒䧠䵮!㱙/n??{L풓ZET㙠퍿X2᩟綳跠葿㚙w཮x캽扳B唕S|尾}촕%N?o䪨": null,
-                                                                                                        "ⰴFjෟ셈[\u0018辷px?椯\\1<ﲻ栘ᣁ봢憠뉴p": -5263694954586507640
-                                                                                                       }
-                                                                                                      ]
-                                                                                                     ]]
-                                                                                                    ]}
-                                                                                                   ]}]
-                                                                                                  ]
-                                                                                                 ],
-                                                                                                 "?#癘82禩鋆ꊝty?&": -1.9419029518535086E-19
-                                                                                                }
-                                                                                               ]
-                                                                                              ]
-                                                                                             ]}
-                                                                                            ]
-                                                                                           ]
-                                                                                          ],
-                                                                                          "훊榲.|῕戄&.㚏Zꛦ2\"䢥ሆ⤢fV_摕婔?≍Fji冀탆꜕i㏬_ẑKᅢ꫄蔻XWc|饡Siẘ^㲦?羡2ぴ1縁ᙅ?쐉Ou": false
-                                                                                         }]]
-                                                                                        ]}}},
-                                                                                        "慂뗄卓蓔ᐓ匐嚖/颹蘯/翻ㆼL?뇊,텵<\\獷ごCボ": null
-                                                                                       },
-                                                                                       "p溉ᑟi짣z:䒤棇r^٫%G9缑r砌롧.물农g?0׼ሩ4ƸO㣥㯄쩞ጩ": null,
-                                                                                       "껎繥YxK\"F젷쨹뤤1wq轫o?鱑뜀瘊?뎃h灑\\ꛣ}K峐^ኖ⤐林ꉓhy": null
-                                                                                      }
-                                                                                     ],
-                                                                                     "᱀n肓ㄛ\"堻2>m殮'1橌%Ꞵ군=Ӳ鯨9耛<\/n據0u彘8㬇៩f᏿诙]嚊": "䋯쪦S럶匏ㅛ#)O`ሀX_鐪渲⛀㨻宅闩➈ꢙஶDR⪍"
-                                                                                    },
-                                                                                    "tA썓龇 ⋥bj왎录r땽✒롰;羋^\\?툳*┎?썀ma䵳넅U䳆૘〹䆀LQ0\b疀U~u$M}(鵸g⳾i抦뛹?䤈땚검.鹆?ꩡtⶥGĒ;!ቹHS峻B츪켏f5≺": 2366175040075384032,
-                                                                                    "전pJjleb]ួ": -7.5418493141528422E18,
-                                                                                    "n.鎖ጲ\n?,$䪘": true
-                                                                                   },
-                                                                                   "欈Ar㉣螵᪚茩?O)": null
-                                                                                  },
-                                                                                  "쫸M#x}D秱欐K=侫们丐.KꕾxẠ\u001e㿯䣛F܍캗qq8꟞ṢFD훎⵳簕꭛^鳜\u205c٫~⑟~冫ऊ2쫰<\/戲윱o<\"": true
-                                                                                 },
-                                                                                 "㷝聥/T뱂\u0010锕|内䞇x侁≦㭖:M?iM᣿IJe煜dG࣯尃⚩gPt*辂.{磼럾䝪@a\\袛?}ᓺB珼": true
-                                                                                }
-                                                                               }
-                                                                              ]]}]}},
-                                                                              "tn\"6ꫤ샾䄄;銞^%VBPwu묪`Y僑N.↺Ws?3C⤻9唩S䠮ᐴm;sᇷ냞඘B/;툥B?lB∤)G+O9m裢0kC햪䪤": -4.5941249382502277E18,
-                                                                              "ᚔt'\\愫?鵀@\\びꂕP큠<<]煹G-b!S?\nꖽ鼫,ݛ&頺y踦?E揆릱H}햧캡b@手.p탻>췽㣬ꒅ`qe佭P>ᓂ&?u}毚ᜉ蟶頳졪ᎏzl2wO": -2.53561440423275936E17
-                                                                             }]}
-                                                                            }
-                                                                           ]
-                                                                          ]],
-                                                                          "潈촒⿂叡": 5495738871964062986
-                                                                         }
-                                                                        ]]
-                                                                       }
-                                                                      ]
-                                                                     ]}
-                                                                    ]]
-                                                                   ]]
-                                                                  ]}
-                                                                 ]
-                                                                ]},
-                                                                "ႁq킍蓅R`謈蟐ᦏ儂槐僻ﹶ9婌櫞釈~\"%匹躾ɢ뤥>࢟瀴愅?殕节/냔O✬H鲽엢?ᮈੁ⋧d␽㫐zCe*": 2.15062231586689536E17,
-                                                                "㶵Ui曚珰鋪ᾼ臧P{䍏䷪쨑̟A뼿T渠誈䏚D1!잶<\/㡍7?)2l≣穷᛾稝{:;㡹nemיּ訊`G": null,
-                                                                "䀕\"飕辭p圁f#뫆䶷뛮;⛴ᩍ3灚덏ᰝ쎓⦷詵%᜖Մfs⇫(\u001e~P|ﭗCⲾផv湟W첋(텪બT<บSꏉ੗⋲X婵i ӵ⇮?L䬇|ꈏ?졸": 1.548341247351782E-19
-                                                               }
-                                                              ]
-                                                             },
-                                                             "t;:N\u0015q鐦Rt缆{ꮐC?஛㷱敪\\+鲊㉫㓪몗릙竏(氵kYS": "XᰂT?൮ô",
-                                                             "碕飦幑|+ 㚦鏶`镥ꁩ B<\/加륙": -4314053432419755959,
-                                                             "秌孳(p!G?V傫%8ሽ8w;5鲗㦙LI檸\u2098": "zG N볞䆭鎍흘\\ONK3횙<\/樚立圌Q튅k쩎Ff쁋aׂJK銆ઘ즐狩6༥✙䩜篥CzP(聻駇HHퟲ讃%,ά{렍p而刲vy䦅ክ^톺M楒鍢㹳]Mdg2>䤉洞",
-                                                             "踛M젧>忔芿㌜Zk": 2215369545966507819,
-                                                             "씐A`$槭頰퍻^U覒\bG毲aᣴU;8!팲f꜇E⸃_卵{嫏羃X쀳C7뗮m(嚼u N܁谟D劯9]#": true,
-                                                             "ﻩ!뵸-筚P᭛}ἰ履lPh?౮ⶹꆛ穉뎃g萑㑓溢CX뾇G㖬A錟]RKaꄘ]Yo+@䘁's섎襠$^홰}F": null
-                                                            },
-                                                            "粘ꪒ4HXᕘ蹵.$區\r\u001d묁77pPc^y笲Q<\/ꖶ 訍䃍ᨕG?*": 1.73773035935040224E17
-                                                           },
-                                                           "婅拳?bkU;#D矠❴vVN쩆t㜷A풃갮娪a%鮏絪3dAv룒#tm쑬⌛qYwc4|L8KZ;xU⓭㳔밆拓EZ7襨eD|隰ऌ䧼u9Ԣ+]贴P荿": 2.9628516456987075E18
-                                                          }]}}]
-                                                         ]}
-                                                        }}
-                                                       ]}]
-                                                      ],
-                                                      "|g翉F*湹̶\u0005⏐1脉̀eI쩓ᖂ㫱0碞l䴨ꑅ㵽7AtἈ턧yq䳥塑:z:遀ﾼX눔擉)`N3昛oQ셖y-ڨ⾶恢ꈵq^<\/": null,
-                                                      "菹\\랓G^璬x৴뭸ゆUS겧﮷Bꮤ ┉銜᯻0%N7}~f洋坄Xꔼ<\/4妟Vꄟ9:౟곡t킅冩䧉笭裟炂4봋ⱳ叺怊t+怯涗\"0㖈Hq": false,
-                                                      "졬믟'ﺇফ圪쓬멤m邸QLব䗁愍4jvs翙 ྍ꧀艳H-|": null,
-                                                      "컮襱⣱뗠 R毪/鹙꾀%헳8&": -5770986448525107020
-                                                     }
-                                                    ],
-                                                    "B䔚bꐻ뙏姓展槰T-똌鷺tc灿᫽^㓟䏀o3o$꘭趙萬I顩)뇭Ἑ䓝\f@{ᣨ`x3蔛": null
-                                                   }
-                                                  ]
-                                                 ]
-                                                }],
-                                                "⦖扚vWꃱ꥙㾠壢輓{-⎳鹷贏璿䜑bG倛⋐磎c皇皩7a~ﳫU╣Q࠭ꎉS摅姽OW.홌ೞ.": null,
-                                                "蚪eVlH献r}ᮏ믠ﰩꔄ@瑄ⲱ": null,
-                                                "퀭$JWoꩢg역쁍䖔㑺h&ୢtXX愰㱇?㾫I_6 OaB瑈q裿": null,
-                                                "꽦ﲼLyr纛Zdu珍B絟쬴糔?㕂짹䏵e": "ḱ\u2009cX9멀i䶛簆㳀k"
-                                               }
-                                              ]]]],
-                                              "(_ꏮg່澮?ᩑyM<艷\u001aꪽ\\庼뙭Z맷㰩Vm\\lY筺]3㋲2㌩㄀Eਟ䝵⨄쐨ᔟgङHn鐖⤇놋瓇Q탚單oY\"♆臾jHᶈ征ቄ??uㇰA?#1侓": null
-                                             },
-                                             "觓^~ሢ&iI띆g륎ḱ캀.ᓡꀮ胙鈉": 1.0664523593012836E-19,
-                                             "y詭Gbᔶऽs댁U:杜⤎ϲ쁗⮼D醄诿q뙰I#즧v蔎xHᵿt᡽[**?崮耖p缫쿃L菝,봬ꤦC쯵#=X1瞻@OZc鱗CQTx": null
-                                            }
-                                           ]
-                                          }}],
-                                          "剘紁\u0004\\Xn⊠6,တױ;嵣崇}讃iႽ)d1\\䔓": null
-                                         },
-                                         "脨z\"{X,1u찜<'k&@?1}Yn$\u0015Rd輲ｰa쮂굄+B$l": true,
-                                         "諳>*쭮괐䵟Ґ+<箁}빀䅱⡔檏臒hIH脟ꩪC핝ଗP좕\"0i<\/C褻D۞恗+^5?'ꂱ䚫^7}㡠cq6\\쨪ꔞꥢ?纖䫀氮蒫侲빦敶q{A煲G": -6880961710038544266
-                                        }}]
-                                       },
-                                       "5s⨲JvಽῶꭂᄢI.a৊": null,
-                                       "?1q꽏쿻ꛋDR%U娝>DgN乭G": -1.2105047302732358E-19
-                                      }
-                                     ]
-                                    ]},
-                                    "qZz`撋뙹둣j碇쁏\\ꆥ\u0018@藴疰Wz)O{F䶛l᷂绘訥$]뮍夻䢋䩇萿獰樧猵⣭j萶q)$꬚⵷0馢W:Ⱍ!Qoe": -1666634370862219540,
-                                    "t": "=wp|~碎Q鬳Ӎ\\l-<\/^ﳊhn퐖}䍔t碵ḛ혷?靻䊗",
-                                    "邙쇡㯇%#=,E4勃驆V繚q[Y댻XV㡸[逹ᰏ葢B@u=JS5?bLRn얮㍉⏅ﰳ?a6[&큟!藈": 1.2722786745736667E-19
-                                   },
-                                   "X블땨4{ph鵋ꉯ웸 5p簂䦭s_E徔濧d稝~No穔噕뽲)뉈c5M윅>⚋[岦䲟懷恁?鎐꓆ฬ爋獠䜔s{\u001bm鐚儸煛%bﯿXT>ꗘ@8G": 1157841540507770724,
-                                   "媤娪Q杸\u0011SAyᡈ쿯": true,
-                                   "灚^ಸ%걁<\/蛯<O\"-刷㏠R(kO=䢊䅎l䰓팪A絫픧": "譔\\㚄 ?R7㔪G㋉⣰渆?\\#|gN⤴;W칷A׫癮଼ೣ㏳뒜7d恓꾲0扬S0ᆵi/贎ྡn䆋武",
-                                   "萇砇Gこ朦켋Wq`㞲攊*冁~霓L剢zI腧튴T繙Cঅ뫬╈뮜ㄾ䦧촄椘B⊬츩r2f㶱厊8eϬ{挚␯OM焄覤\\(Kӡ>?\"祴坓\\\\'흍": -3.4614808555942579E18,
-                                   "釴U:O湛㴑䀣렑縓\ta)<D8ﭳ槁髭D.L|xs斋敠\"띋早7wᎍ": true,
-                                   "쵈+쬎簨up䓬?q+~\u0019仇뵈᫯3ᵣ恘枰劫㪢u珘-퀭:컙:u`⌿A(9鄦!<珚nj3:Hࣨ巋䀁旸뎈맻v\"\\(곘vO㤰aZe<\/W鹙鄜;l厮둝": null,
-                                   "": -1.2019926774977002E-18,
-                                   "%者O7.Nꪍs梇接z蕜綛<\/䜭\"죊y<曋漵@Ś⹝sD⟓jݗᢜ?z/9ၲMa쨮긗贎8ᔮ㦛;6p뾥໭䭊0B찛+)(Y㿠鸁䕒^옥": "鬃뫤&痽舎J콮藐󽸰ᨨMꈫ髿v<N\\.삒껅я1ꭼ5䴷5쳬臨wj덥"
-                                  }],
-                                  "鷎'㳗@帚妇OAj' 谬f94ǯ(횡ﾋ%io쪖삐좛>(j:숾却䗌gCiB뽬Oyuq輥厁/7)?今hY︺Q": null
-                                 }
-                                ]
-                               ]]]}]
-                              ],
-                              "I笔趠Ph!<ཛྷ㸞诘X$畉F\u0005笷菟.Esr릙!W☆䲖뗷莾뒭U\"䀸犜Uo3Gꯌx4r蔇᡹㧪쨢準<䂀%ࡡꟼ瑍8炝Xs0䀝销?fi쥱ꆝલBB": -8571484181158525797,
-                              "L⦁o#J|\"⽩-㱢d㌛8d\\㶤傩儻E[Y熯)r噤὘勇 }": "e(濨쓌K䧚僒㘍蠤Vᛸ\"络QJL2,嬓왍伢㋒䴿考澰@(㏾`kX$끑эE斡,蜍&~y",
-                              "vj.|统圪ᵮPL?2oŶ`밧\"勃+0ue%⿥绬췈체$6:qa렐Q;~晘3㙘鹑": true,
-                              "ශؙ4獄⶿c︋i⚅:ん閝Ⳙ苆籦kw{䙞셕pC췃ꍬ␜꟯ꚓ酄b힝hwk꭭M鬋8B耳쑘WQ\\偙ac'唀x᪌\u2048*h짎#ፇ鮠뾏ឿ뀌": false,
-                              "⎀jꄒ牺3Ⓝ컴~?親ꕽぼܓ喏瘘!@<튋㐌꿱⩦{a?Yv%⪧笯Uܱ栅E搚i뚬:ꄃx7䙳ꦋ&䓹vq☶I䁘ᾘ涜\\썉뺌Lr%Bc㍜3?ꝭ砿裞]": null,
-                              "⭤뙓z(㡂%亳K䌽꫿AԾ岺㦦㼴輞낚Vꦴw냟鬓㹈뽈+o3譻K1잞": 2091209026076965894,
-                              "ㇲ\t⋇轑ꠤ룫X긒\"zoY읇희wj梐쐑l侸`e%s": -9.9240075473576563E17,
-                              "啸ꮑ㉰!ᚓ}銏": -4.0694813896301194E18,
-                              ">]囋੽EK뇜>_ꀣ緳碖{쐐裔[<ನ\"䇅\"5L?#xTwv#罐\u0005래t应\\N?빗;": "v쮽瞭p뭃"
-                             }
-                            ]],
-                            "斴槾?Z翁\"~慍弞ﻆ=꜡o5鐋dw\"?K蠡i샾ogDﲰ_C*⬟iㇷ4nય蟏[㟉U꽌娛苸 ঢ়操贻洞펻)쿗૊許X⨪VY츚Z䍾㶭~튃ᵦ<\/E臭tve猑x嚢": null,
-                            "锡⛩<\/칥ꈙᬙ蝀&Ꚑ籬■865?_>L詏쿨䈌浿弥爫̫lj&zx<\/C쉾?覯n?": null,
-                            "꾳鑤/꼩d=ᘈn挫ᑩ䰬ZC": "3錢爋6Ƹ䴗v⪿Wr益G韠[\u0010屗9쁡钁u?殢c䳀蓃樄욂NAq赟c튒瘁렶Aૡɚ捍"
-                           }
-                          ]
-                         ]
-                        ]}
-                       ]
-                      ]
-                     }]]]}}
-                    ]}],
-                    "Ej䗳U<\/Q=灒샎䞦,堰頠@褙g_\u0003ꤾfⶽ?퇋!łB〙ד3CC䌴鈌U:뭔咎(Qો臃䡬荋BO7㢝䟸\"Yb": 2.36010731779814E-20,
-                    "逸'0岔j\u000e눘먷翌C츊秦=ꭣ棭ှ;鳸=麱$XP⩉駚橄A\\좱⛌jqv䰞3Ь踌v㳆¹gT┌gvLB賖烡m?@E঳i": null
-                   },
-                   "曺v찘ׁ?&绫O័": 9107241066550187880
-                  }
-                 ]
-                ],
-                "(e屄\u0019昜훕琖b蓘ᬄ0/۲묇Z蘮ဏ⨏蛘胯뢃@㘉8ሪWᨮ⦬ᅳ䅴HI၇쨳z囕陻엣1赳o": true,
-                ",b刈Z,ၠ晐T솝ŕB⩆ou'퐼≃绗雗d譊": null,
-                "a唥KB\"ﳝ肕$u\n^⅄P䟼냉䞸⩪u윗瀱ꔨ#yşs꒬=1|ﲤ爢`t౐튼쳫_Az(Ṋ擬㦷좕耈6": 2099309172767331582,
-                "?㴸U<\/䢔ꯡ阽扆㐤q鐋?f㔫wM嬙-;UV죫嚔픞G&\"Cᗍ䪏풊Q": "VM7疹+陕枡툩窲}翡䖶8欞čsT뮐}璤:jﺋ鎴}HfA൝⧻Zd#Qu茅J髒皣Y-︴[?-~쉜v딏璮㹚䅊﩯<-#\u000e걀h\u0004u抱﵊㼃U<㱷⊱IC進"
-               },
-               "숌dee節鏽邺p넱蹓+e罕U": true
-              }
-             ],
-             "b⧴룏??ᔠ3ぱ>%郿劃翐ꏬꠛW瞳᫏누躨狀ໄy੽\"ីuS=㨞馸k乆E": "トz݈^9R䬑<ﮛG<s~<\/?ⵆᏥ老熷u듷"
-            }}
-           ]
-          }
-         ]}
-        }
-       }
-      }
-     }},
-     "宩j鬅쳜QꝖјy獔Z᭵1v擖}䨿F%cֲ᫺贴m塼딚NP亪\"ￋsa뺯ꘓ2:9뛓༂쌅䊈#>Rꨳ\u000fTT泠纷꽀MR<CBxP񱒫X쇤": -2.22390568492330598E18,
-     "?䯣ᄽ@Z鸅->ᴱ纊:㠭볮?%N56%鈕1䗍䜁a䲗j陇=뿻偂衋࿘ᓸ?ᕵZ+<\/}H耢b䀁z^f$&㝒LkꢳI脚뙛u": 5.694374481577558E-20
-    }]
-   }
-  ]],
-  "obj": {"key": "wrong value"},
-  "퓲꽪m{㶩/뇿#⼢&᭙硞㪔E嚉c樱㬇1a綑᝖DḾ䝩": null
- },
- "key": "6.908319653520691E8",
- "z": {
-  "6U閆崬밺뀫颒myj츥휘:$薈mY햚#rz飏+玭V㭢뾿愴YꖚX亥ᮉ푊\u0006垡㐭룝\"厓ᔧḅ^Sqpv媫\"⤽걒\"˽Ἆ?ꇆ䬔未tv{DV鯀Tἆl凸g\\㈭ĭ즿UH㽤": null,
-  "b茤z\\.N": [[
-   "ZL:ￄዎ*Y|猫劁櫕荾Oj为1糕쪥泏S룂w࡛Ᏺ⸥蚙)",
-   {
-    "\"䬰ỐwD捾V`邀⠕VD㺝sH6[칑.:醥葹*뻵倻aD\"": true,
-    "e浱up蔽Cr෠JK軵xCʨ<뜡癙Y獩ｹ齈X/螗唻?<蘡+뷄㩤쳖3偑犾&\\첊xz坍崦ݻ鍴\"嵥B3㰃詤豺嚼aqJ⑆∥韼@\u000b㢊\u0015L臯.샥": false,
-    "l?Ǩ喳e6㔡$M꼄I,(3᝝縢,䊀疅뉲B㴔傳䂴\u0088㮰钘ꜵ!ᅛ韽>": -5514085325291784739,
-    "o㮚?\"춛㵉<\/﬊ࠃ䃪䝣wp6ἀ䱄[s*S嬈貒pᛥ㰉'돀": [{
-     "(QP윤懊FI<ꃣ『䕷[\"珒嶮?%Ḭ壍಻䇟0荤!藲끹bd浶tl\u2049#쯀@僞": {"i妾8홫": {
-      ",M맃䞛K5nAㆴVN㒊햬$n꩑&ꎝ椞阫?/ṏ세뉪1x쥼㻤㪙`\"$쟒薟B煌܀쨝ଢ଼2掳7㙟鴙X婢\u0002": "Vዉ菈᧷⦌kﮞఈnz*<?੃'ahhCFX(\u0007⮊E㭍䱾Gxꥩr❣.洎",
-      "뻴5bDD큯O傆盓왻U?ꞅꐊN鐭᧢τ\"迳豲8\u001b䃥ꂻ䴺ྸH筴,": {
-       "\"L鸔SE㬡XV&~͎'놅蔞눶l匛?'.K氁\\ƢẨ疇mΊ'꽳&!鹠m'|{P痊 秄쒿u\u00111䋧gϩx7t丗D䊨䠻z0.A0": -1.50139930144708198E18,
-       "8鋂뛷?첒B☚>﷜FM\"荭7ꍀ-VR<\/';䁙E9$䩉\f @s?퍪o3^衴cඎ䧪aK鼟ｑ䆨c{䳠5mᒲՙ蘹ᮩ": {
-        "F㲷JGo⯍P덵x뒳p䘧☔\"+ꨲ吿JfR㔹)4n紬G练Q፞!C|": true,
-        "p^㫮솎oc.೚A㤠??r\u000f)⾽⌲們M2.䴘䩳:⫭胃\\፾@Fᭌ\\K": false,
-        "蟌Tk愙潦伩": {
-         "a<\/@ᾛ慂侇瘎": -7271305752851720826,
-         "艓藬/>၄ṯ,XW~㲆w": {"E痧郶)㜓ha朗!N赻瞉駠uC\u20ad辠<Ve?폱!Im䁎搄:*s 9諚Prᵾ뒰髶B̌qWA8梸vS⫊⢳{t㺲q㺈랊뮣RqK밢쳪": [
-          false,
-          {
-           "\u000b=>x퓮⣫P1ࠫLMMX'M刼唳됤": null,
-           "P쓫晥%k覛ዩIUᇸ滨:噐혲lMR5䋈V梗>%幽u頖\\)쟟": null,
-           "eg+昉~矠䧞难\b?gQ쭷筝\\eꮠNl{ಢ哭|]Mn銌╥zꖘzⱷ⭤ᮜ^": [
-            -1.30142114406914976E17,
-            -1.7555215491128452E-19,
-            null,
-            "渾㨝ߏ牄귛r?돌?w[⚞ӻ~廩輫㼧/",
-            -4.5737191805302129E18,
-            null,
-            "xy࿑M[oc셒竓Ⓔx?뜓y䊦>-D켍(&&?XKkc꩖ﺸᏋ뵞K伕6ী)딀P朁yW揙?훻魢傎EG碸9類៌g踲C⟌aEX舲:z꒸许",
-            3808159498143417627,
-            null,
-            {"m試\u20df1{G8&뚈h홯J<\/": {
-             "3ஸ厠zs#1K7:rᥞoꅔꯧ&띇鵼鞫6跜#赿5l'8{7㕳(b/j\"厢aq籀ꏚ\u0015厼稥": [
-              -2226135764510113982,
-              true,
-              null,
-              {
-               "h%'맞S싅Hs&dl슾W0j鿏MםD놯L~S-㇡R쭬%": null,
-               "⟓咔謡칲\u0000孺ꛭx旑檉㶆?": null,
-               "恇I転;￸B2Y`z\\獓w,놏濐撐埵䂄)!䶢D=ഭ㴟jyY": {
-                "$ࡘt厛毣ൢI芁<겿骫⫦6tr惺a": [
-                 6.385779736989334E-20,
-                 false,
-                 true,
-                 true,
-                 [
-                  -6.891946211462334E-19,
-                  null,
-                  {
-                   "]-\\Ꟑ1/薓❧Ὂ\\l牑\u0007A郃)阜ᇒᓌ-塯`W峬G}SDb㬨Q臉⮻빌O鞟톴첂B㺱<ƈmu챑J㴹㷳픷Oㆩs": {
-                    "\"◉B\"pᶉt骔J꩸ᄇᛐi╰栛K쉷㉯鐩!㈐n칍䟅難>盥y铿e୔蒏M貹ヅ8嘋퀯䉶ጥ㏢殊뻳\"絧╿ꉑ䠥?∃蓊{}㣣Gk긔H1哵峱": false,
-                    "6.瀫cN䇮F㧺?\\椯=ڈT䘆4␘8qv": -3.5687501019676885E-19,
-                    "Q?yऴr혴{஀䳘p惭f1ﹸ䅷䕋贲<ྃᄊ繲hq\\b|#QSTs1c-7(䵢\u2069匏絘ꯉ:l毴汞t戀oෟᵶ뮱፣-醇Jx䙬䐁햢0࣫ᡁgrㄛ": "\u0011_xM/蘇Chv;dhA5.嗀绱V爤ﰦi뵲M",
-                    "⏑[\"ugoy^儣횎~U\\섯겜論l2jw஌yD腅̂\u0019": true,
-                    "ⵯɇ䐲᫿࢚!㯢l샅笶戮1꣖0Xe": null,
-                    "劅f넀識b宁焊E찓橵G!ʱ獓뭔雩괛": [{"p⹣켙[q>燣䍃㞽ᩲx:쓤삘7玑퇼0<\/q璂ᑁ[Z\\3䅵䧳\u0011㤧|妱緒C['췓Yꞟ3Z鳱雼P錻BU씧U`ᢶg蓱>.1ӧ譫'L_5V䏵Ц": [
-                     false,
-                     false,
-                     {"22䂍盥N霂얢<F8꼵7Gసyh뀍g᦭ꄢx硴嬢\u001a?E괆T|;7犟\"Wt%䐩O⨵t&#ᬋK'蜍Ძ揔⾠鲂T멷靃\u0018䓞cE": {"f=䏏츜瞾zw?孡鏣\\铀᫞yẆg(\u0011M6(s2]`ਫ": [[[{
-                      "'y몱纣4S@\\,i㷯럹Ua充Tᣢ9躘Zଞ쥿䐊s<\/刎\\\"뉦-8/": "蜑.X0꭛낢륹i젨ꚁ<8?s볕蝡|Q✬᯦@\\G㑢屿Mn졾J굤⥟JW뤵苑r쁕툄嵵?⾥O",
-                      "^1挲~[n귆誈央碠멪gI洷": -8214236471236116548,
-                      "sሣ%娌暡clr蟜㑓2\u000bS❟_X㨔⚴5~蔷ꀇ|Xu㬖,꤭卹r(g믇쩍%췸앙|栣U\\2]䤉+啠菡ꯎT鉹m\n/`SzDᅼ鞶": 1.1217523390167132E-19,
-                      "u톇=黚\\ ꂮ췵L>躰e9⑩_뵜斌n@B}$괻Yᐱ@䧋V\"☒-諯cV돯ʠ": true,
-                      "Ű螧ᔼ檍鍎땒딜qꄃH뜣<獧ूCY吓⸏>XQ㵡趌o끬k픀빯a(ܵ甏끆୯/6Nᪧ}搚ᆚ짌P牰泱鈷^d꣟#L삀\"㕹襻;k㸊\\f+": true,
-                      "쎣\",|⫝̸阊x庿k잣v庅$鈏괎炔k쬪O_": [
-                       "잩AzZGz3v愠ꉈⵎ?㊱}S尳௏p\r2>췝IP䘈M)w|\u000eE",
-                       -9222726055990423201,
-                       null,
-                       [
-                        false,
-                        {"´킮'뮤쯽Wx讐V,6ᩪ1紲aႈ\u205czD": [
-                         -930994432421097536,
-                         3157232031581030121,
-                         "l貚PY䃛5@䭄<nW\u001e",
-                         [
-                          3.801747732605161E18,
-                          [
-                           null,
-                           false,
-                           {
-                            "": 4.0442013775147072E16,
-                            "2J[sᡪ㞿|n'#廲꯬乞": true,
-                            "B[繰`\\㏏a̼㨀偛㽓<\/꥖ᵈO让\r43⡩徑ﬓ๨ﮕx:㣜o玐ꉟぢC珵὆ᓞ쇓Qs氯였9駵q혃Ljꂔ<\/昺+t䐋༻猙c沪~櫆bpJ9UᏐ:칣妙!皗F4㑄탎䕀櫳振讓": 7.3924182188256287E18,
-                            "H磵ai委曷n柋T<\/勿F&:ꣴfU@㿗榻Lb+?퍄sp\"᪟~>귻m㎮琸f": 1.0318894506812084E-19,
-                            "࢜⩢Ш䧔1肽씮+༎ᣰ闺馺窃䕨8Mƶq腽xc(៯夐J5굄䕁Qj_훨/~価.䢵慯틠퇱豠㼇Qﵘ$DuSp(8Uญ<\/ಟ룴𥳐ݩ$": 8350772684161555590,
-                            "ㆎQ䄾\u001bpᩭ${[諟^^骴᤮b^ㅥI┧T㉇⾞\"绦<AYJ⒃-oF<\/蛎mm;obh婃ᦢ": false,
-                            "䔤䣈?汝.p襟&d㱅\\Jᚠ@?O첁ࢽ휔VR蔩|㒢柺": [[
-                             "-ꕨ岓棻r@鿆^3~䪤Ѐ狼︌ﹲ\\᝸MlE쵠Q+",
-                             null,
-                             false,
-                             3346674396990536343,
-                             null,
-                             {
-                              "": null,
-                              "/䏨S쨑,&繷㉥8C엮赸3馢|뇲{鄎ꗇqFﶉ雕UD躢?Ꟛအ꽡[hᕱᗅ㦋쭞Mユ茍?L槽암V#성唐%㣕嘵\\ڹ(嘏躿&q": [
-                               -1364715155337673920,
-                               false,
-                               -8197733031775379251,
-                               "E팗鮲JwH\\觡܈᜝\"+뉞娂N휗v噙၂깼\u001dD帒l%-斔N",
-                               -3.844267973858711E-20,
-                               [{"쬯(褈Q 蟚뿢 /ⱖ㻥\u0017/?v邘䃡0U.Z1x?鯔V尠8Em<": [[[
-                                null,
-                                [
-                                 null,
-                                 -5841406347577698873,
-                                 "킷\"S⋄籞繗솸ᵣ浵w쑿ퟗ7nᎏx3앙z㘌쿸I葥覯㬏0ᆝb汆狺뷘ႀnꋋ",
-                                 -1227911573141158702,
-                                 {
-                                  "u㉮PᾺV鵸A\\g*ࡗ9슟晭+ͧↀ쿅H\u001c꾣犓}癇恛ᗬ黩䟘X梑鐆e>r䰂f矩'-7䡭桥Dz兔V9谶居㺍ᔊ䩯덲.\u001eL0ὅㅷ釣": [{
-                                   "<쯬J卷^숞u࠯䌗艞R9닪g㐾볎a䂈歖意:%鐔|ﵤ|y}>;2,覂⶚啵tb*仛8乒㓶B࿠㯉戩oX 貘5V嗆렽낁߼4h䧛ꍺM空\\b꿋貼": 8478577078537189402,
-                                   "VD*|吝z~h譺aᯒ": {
-                                    "YI췢K<\/濳xNne玗rJo쾘3핰鴊\"↱AR:ࢷ\"9?\"臁說)?誚ꊏe)_D翾W?&F6J@뺾ꍰNZ醊Z쾈വH嶿?炫㷱鬰M겈<bS}㎥l|刖k": {"H7鷮퇢_k": [
-                                     true,
-                                     "s㟑瀭좾쮀⑁Y찺k맢戲쀸俻ກ6儮끗扖puߖꜻ馶rꈞ痘?3ྚ畊惘䎗\"vv)*臔웅鿈䧲^v,껛㰙J <ᚶ5",
-                                     7950276470944656796,
-                                     4.9392301536234746E17,
-                                     -4796050478201554639,
-                                     "yꬴc<3㻚",
-                                     "o塁\u20a4蒵鮬裢CᴧnB㭱f.",
-                                     false,
-                                     [
-                                      false,
-                                      "㡐弑V?瀆䰺q!출㇞yᘪ꼼(IS~Ka 烿ꟿ샕桤\u0005HQҹ㯪罂q萾⚇懋⦕둡v",
-                                      1862560050083946970,
-                                      "\u20b6[|(뭹gꍒ펉O轄Dl묽]ﯨ髯QEbA㒾m@롴礠㕓2땫n6ْ엘঵篳R잷꙲m색摪|@㿫5aK设f胭r8/NI4춫栵\\꯬2]",
-                                      false,
-                                      {
-                                       "\u000b7*㙛燏.~?䔊p搕e_拺艿뷍f{ꔻ1s驙`$Ė戧?q⋬沭?塷᭚蹀unoa5": {
-                                        "S귯o紞㾕ᅶ侏銇12|ʟ畴iNAo?|Sw$M拲գ㭄紧螆+,梔": null,
-                                        "㭚0?xB疱敻ேBPwv뾃熉(ӠpJ]갢\"Bj'\u0016GE椱<\/zgៅx黢礇h},M9ﴦ?LḨ": "Si B%~㬒E",
-                                        "핇㉊살㍢숨~ȪRo䦅D桺0z]﬽蠆c9ᣨyPP㿷U~㞐?쯟퍸宒뉆U|}㉓郾ࣻ*櫎꼪䁗s?~7\u001e㘔h9{aឋ}:㶒P8": [{"\\R囡쐬nN柋琍؛7칾 :㶃衇徜V 深f1淍♠i?3S角폞^ᆞ\u20e8ṰD\u0007秡+躒臔&-6": {
-                                         "䨑g.fh㔗=8!\"狿ൻLU^뻱g䲚㻐'W}k欤?๒鲇S꧗䫾$ĥ피": -794055816303360636,
-                                         "外頮詋~텡竆繃䏩苨뾺朁꼃瘹f*㉀枙NH/\u2027ꢁ}j묎vペq︉식뜡Od5 N顯ି烅仟Qfㆤ嚢(i䬅c;맧?嶰㩼츱獡?-": {
-                                          "e݆㍡⬬'2㻒?U篲鿄\"隻Ҭ5NꭰꤺBꀈ拾᩺[刯5곑Na램ﴦ዆]㝓qw钄\u001b\"Y洊䗿祏塥迵[⼞⠳P$꠱5먃0轢`": [{"獰E賝﫚b먭N긆Ⰹ史2逶ꜛ?H짉~?P}jj}侷珿_T>᭨b,⻁鈵P䕡䀠८ⱄ홎鄣": {
-                                           "@?k2鶖㋮\"Oರ K㨇廪儲\u0017䍾J?);\b*묀㗠섳햭1MC V": null,
-                                           "UIICP!BUA`ᢈ㋸~袩㗪⾒=fB﮴l1ꡛ죘R辂여ҳ7쮡<䩲`熕8頁": 4481809488267626463,
-                                           "Y?+8먙ᚔ鋳蜩럶1㥔y璜౩`": [
-                                            null,
-                                            1.2850335807501874E-19,
-                                            "~V2",
-                                            2035406654801997866,
-                                            {
-                                             "<숻1>\"": -8062468865199390827,
-                                             "M㿣E]}qwG莎Gn᝶(ꔙ\\D⬲iꇲs寢t駇S뀡ꢜ": false,
-                                             "pꝤ㎏9W%>M;-U璏f(^j1?&RB隧 忓b똊E": "#G?C8.躬ꥯ'?냪#< 渟&헿란zpo왓Kj}鷧XﻘMツb䕖;㪻",
-                                             "vE풤幉xz뱕쫥Ug㦲aH} ᣟp:鬼Yᰟ<Fɋ잣緂頒⺏䉲瑑䅂,C~ޅG!f熢-B7~9Pqࡢ[츑#3ꕎ,Öඳ聁⩅㵧춀뿍xy䌏͂tdj!箧᳆|9蚡돬": -2.54467378964089632E17,
-                                             "䵈䅦5빖,궆-:໿댾仫0ᙚyᦝhqᚄ": null,
-                                             "侯Y\"湛졯劇U셎YX灍ⅸ2伴|筧\\䁒㶶᷏쁑Waᦵᗱ㜏늾膠<Jc63<G\u20fe䇹66僣k0O\"_@U": null,
-                                             "姪y$#s漴JH璌Ӊ脛J㝾펔ﹴoꈶ㚸PD:薠쏖%說ថ蹂1］⾕5튄": {
-                                              "᝾Huw3䮅如쿺䍟嫝]<鰨ݷ?꯯䫓傩|ᐶස媽\\澒≡闢": "Mm\"쏇ᯄ졽\"楇<\/ꥆ흭局n隴@鿣w⠊4P贈徎W㊋;䤞'.팇蒁䡴egpx嗎wஅ獗堮ᛐnˁ︖䀤4噙?໚郝᱋ޘॎt恑姫籕殥陃\"4[ꝬqL4Wꠎx",
-                                              "ℇj遌5B뒚\" U": "硄ꏘ{憠굏:&t䌨m Cઌ쿣鞛XFꠟs䝭ﶃ\"格a0x闊昵吲L\\杚聈aꁸj싹獅\"灟ﱡ馆*굖糠<ꔏ躎",
-                                              "톌賠弳ꟍb\"螖X50sĶ晠3f秂坯Iⓟ:萘": 5.573183333596288E18,
-                                              "%䴺": [[[[
-                                               -6957233336860166165,
-                                               false,
-                                               null,
-                                               {
-                                                "\"\\௮茒袀ᕥ23ୃ괶?䕎.嚲◉㏞L+ᵡ艱hL콇붆@": null,
-                                                "%螥9ꭌ<\/-t": true,
-                                                ",9|耢椸䁓Xk죱\u0015$Ώ鲞[?엢ᝲ혪즈ⴂ▂ℴ㗯\"g뺘\\ꍜ#\u0002ヮ}ሎ芲P[鹮轧@냲䃦=#(": 2.78562909315899616E17,
-                                                "R?H䧰ⵇ<,憰쮼Q總iR>H3镔ᴚ斦\\鏑r*2橱G⼔F/.j": true,
-                                                "RK좬뎂a홠f*f㱉ᮍ⦋潙㨋Gu곌SGI3I뿐\\F',)t`荁蘯囯ﮉ裲뇟쥼_ገ驪▵撏ᕤV": 1.52738225997956557E18,
-                                                "^k굲䪿꠹B逤%F㱢漥O披M㽯镞竇霒i꼂焅륓\u00059=皫之눃\u2047娤閍銤唫ၕb<\/w踲䔼u솆맚,䝒ᝳ'/it": "B餹饴is権ꖪ怯ꦂẉဎt\"!凢谵⧿0\\<=(uL䷍刨쑪>俆揓Cy襸Q힆䆭涷<\/ᐱ0ɧ䗾䚹\\ኜ?ꄢᇘ`䴢{囇}᠈䴥X4퓪檄]ꥷ/3謒ሴn+g騍X",
-                                                "GgG꽬[(嫓몍6\u0004궍宩㙻/>\u0011^辍dT腪hxǑ%ꊇk,8(W⧂結P鬜O": [{
-                                                 "M㴾c>\\ᓲ\u0019V{>ꤩ혙넪㭪躂TS-痴໸闓⍵/徯O.M㏥ʷD囎⧔쁳휤T??鉬뇙=#ꢫ숣BX䭼<\/d똬졬g榿)eꨋﯪ좇첻<?2K)": null,
-                                                 "Z17縬z]愀䖌 ᾋBCg5딒국憍꾓aⲷ턷u:U촳驿?雺楶\u0001\u001c{q*ᰗ苑B@k揰z.*蓗7ረIm\"Oᱍ@7?_": true,
-                                                 "㺃Z<": -4349275766673120695,
-                                                 "휃䠂fa塆ffixKe'덬鏗੄뺾w࠾鑎k땢m*႑햞鐮6攊&虜h黚,Y䱳Sﭼ둺pN6": [
-                                                  false,
-                                                  "IΎ䣲,\"ᬮ˪癘P~Qlnx喁Sᮔ༬˨I珌m䜛酛\u0003iꐸ㦧cQ帲晼D' \\(粋wQcN\\뵰跈",
-                                                  [
-                                                   "D0\\L?M1쥍Kaꏌsd+盌귤憊tz䌣댐בO坂wϢ%ὒgp,Ai⎧ᶆI餾ꦍ棩嘅᳉怴%m]ၶis纖D凜镧o심b U",
-                                                   {
-                                                    "?଼\u0011Rv&^[+匚I趈T媫\u0010.䥤ᆯ1q僤HydⲰl㒽K'ᅾiౕ豲초딨@\u0013J'쪪VD౼P4Ezg#8*㋤W馓]c쿯8": false,
-                                                    "c/擯X5~JmK䵶^쐎ച|B|u[솝(X뚤6v}W㤘⠛aR弌臌쾭諦eⒷ僡-;㩩⭖ⷴ徆龄갬{䱓ᥩ!﯏⊚ᇨ<v燡露`:볉癮꨽り★Ax7Ꮀ譥~舑\\Vꍋ\"$)v": "e&sFF쬘OBd슊寮f蠛জ봞mn~锆竒G脁\"趵G刕䕳&L唽붵<\/I,X팚B⍥X,kԇҗ眄_慡:U附ᓚA蕧>\u001a\u0011\";~쓆BH4坋攊7힪",
-                                                    "iT:L闞椕윚*滛gI≀Wਟඊ'ꢆ縺뱹鮚Nꩁ᧬蕼21줧\\䋯``⍐\\㏱鳨": 1927052677739832894,
-                                                    "쮁缦腃g]礿Y㬙 fヺSɪ꾾N㞈": [
-                                                     null,
-                                                     null,
-                                                     {
-                                                      "!t,灝Y 1䗉罵?c饃호䉂Cᐭ쒘z(즽sZG㬣sഖE4뢜㓕䏞丮Qp簍6EZឪ겛fx'ꩱQ0罣i{k锩*㤴㯞r迎jTⲤ渔m炅肳": [
-                                                       -3.3325685522591933E18,
-                                                       [{"㓁5]A䢕1룥BC?Ꙍ`r룔Ⳛ䙡u伲+\u0001്o": [
-                                                        null,
-                                                        4975309147809803991,
-                                                        null,
-                                                        null,
-                                                        {"T팘8Dﯲ稟MM☻㧚䥧/8ﻥ⥯aXLaH\"顾S☟耲ît7fS෉놁뮔/ꕼ䓈쁺4\\霶䠴ᩢ<\/t4?죵>uD5➶༆쉌럮⢀秙䘥\u20972ETR3濡恆vB? ~鸆\u0005": {
-                                                         "`閖m璝㥉b뜴?Wf;?DV콜\u2020퍉౓擝宏ZMj3mJ먡-傷뱙yח㸷꥿ ໘u=M읝!5吭L4v\\?ǎ7C홫": null,
-                                                         "|": false,
-                                                         "~Ztᛋ䚘\\擭㗝傪W陖+㗶qᵿ蘥ᙄp%䫎)}=⠔6ᮢS湟-螾-mXH?cp": 448751162044282216,
-                                                         "\u209fad놹j檋䇌ᶾ梕㉝bוּ<d䗱:줰M酄\u0000X#_r獢A饓ꍗُKo_跔?ᪧ嵜鼲<": null,
-                                                         "ꆘ)ubI@h@洭Ai㜎䏱k\u0003?T䉐3间%j6j棍j=❁\\U毮ᬹ*8䀔v6cpj⭬~Q꿾뺶펵悡!쩭厝l六㽫6퇓ޭ2>": {"?苴ꩠD䋓帘5騱qﱖPF?☸珗顒yU ᡫcb䫎 S@㥚gꮒ쎘泴멖\\:I鮱TZ듒ᶨQ3+f7캙\"?\f풾\\o杞紟﻽M.⏎靑OP": [
-                                                          -2.6990368911551596E18,
-                                                          [{"䒖@<᰿<\/⽬tTr腞&G%᳊秩蜰擻f㎳?S㵧\r*k뎾-乢겹隷j軛겷0룁鮁": {")DO0腦:춍逿:1㥨่!蛍樋2": [{
-                                                           ",ꌣf侴笾m๫ꆽ?1?U?\u0011ꌈꂇ": {
-                                                            "x捗甠nVq䅦w`CD⦂惺嘴0I#vỵ} \\귂S끴D얾?Ԓj溯\"v餄a": {
-                                                             "@翙c⢃趚痋i\u0015OQ⍝lq돆Y0pࢥ3쉨䜩^<8g懥0w)]䊑n洺o5쭝QL댊랖L镈Qnt⪟㒅십q헎鳒⮤眉ᔹ梠@O縠u泌ㄘb榚癸XޔFtj;iC": false,
-                                                             "I&뱋゘|蓔䔕측瓯%6ᗻHW\\N1貇#?僐ᗜgh᭪o'䗈꽹Rc욏/蔳迄༝!0邔䨷푪8疩)[쭶緄㇈୧ፐ": {
-                                                              "B+:ꉰ`s쾭)빼C羍A䫊pMgjdx䐝Hf9᥸W0!C樃'蘿f䫤סи\u0017Jve? 覝f둀⬣퓉Whk\"஼=չﳐ皆笁BIW虨쫓F廰饞": -642906201042308791,
-                                                              "sb,XcZ<\/m㉹ ;䑷@c䵀s奤⬷7`ꘖ蕘戚?Feb#輜}p4nH⬮eKL트}": [
-                                                               "RK鳗z=袤Pf|[,u욺",
-                                                               "Ẏᏻ罯뉋⺖锅젯㷻{H䰞쬙-쩓D]~\u0013O㳢gb@揶蔉|kᦂ❗!\u001ebM褐sca쨜襒y⺉룓",
-                                                               null,
-                                                               null,
-                                                               true,
-                                                               -1.650777344339075E-19,
-                                                               false,
-                                                               "☑lꄆs힨꤇]'uTന⌳농].1⋔괁沰\"IWഩ\u0019氜8쟇䔻;3衲恋,窌z펏喁횗?4?C넁问?ᥙ橭{稻Ⴗ_썔",
-                                                               "n?]讇빽嗁}1孅9#ꭨ靶v\u0014喈)vw祔}룼쮿I",
-                                                               -2.7033457331882025E18,
-                                                               {
-                                                                ";⚃^㱋x:饬ኡj'꧵T☽O㔬RO婎?향ᒭ搩$渣y4i;(Q>꿘e8q": "j~錘}0g;L萺*;ᕭꄮ0l潛烢5H▄쳂ꏒוֹꙶT犘≫x閦웧v",
-                                                                "~揯\u2018c4職렁E~ᑅቚꈂ?nq뎤.:慹`F햘+%鉎O瀜쟏敛菮⍌浢<\/㮺紿P鳆ࠉ8I-o?#jﮨ7v3Dt赻J9": null,
-                                                                "ࣝW䌈0ꍎqC逖,횅c၃swj;jJS櫍5槗OaB>D踾Y": {"㒰䵝F%?59.㍈cᕨ흕틎ḏ㋩B=9IېⓌ{:9.yw｝呰ㆮ肒᎒tI㾴62\"ዃ抡C﹬B<\/<EO꽓ᇕu&鋫\\禞퐹u꒍.7훯ಶ2䩦͉ᶱf깵ᷣ늎": [
-                                                                 5.5099570884646902E18,
-                                                                 "uQN濿m臇<%?谣鮢s]]x0躩慌闋<;( 鋤.0ᠵd1#벘a:Gs?햷'.)ㅴ䞟琯崈FS@O㌛ᓬ抢큌ើ냷쿟툥IZn[惵ꐧ3뙍[&v憙J>촋jo朣",
-                                                                 [
-                                                                  -7675533242647793366,
-                                                                  {"ᙧ呃:[㒺쳀쌡쏂H稈㢤\u001dᶗGG-{GHྻຊꡃ哸䵬;$?&d\\⥬こN圴됤挨-'ꕮ$PU%?冕눖i魁q騎Q": [
-                                                                   false,
-                                                                   [[
-                                                                    7929823049157504248,
-                                                                    [[
-                                                                     true,
-                                                                     "Z菙\u0017'eꕤ᱕l,0\\X\u001c[=雿8蠬L<\/낲긯W99g톉4ퟋb㝺\u0007劁'!麕Q궈oW:@X၎z蘻m絙璩귓죉+3柚怫tS捇蒣䝠-擶D[0=퉿8)q0ٟ",
-                                                                     "唉\nFA椭穒巯\\䥴䅺鿤S#b迅獘 ﶗ꬘\\?q1qN犠pX꜅^䤊⛤㢌[⬛휖岺q唻ⳡ틍\"㙙Eh@oA賑㗠y必Nꊑᗘ",
-                                                                     -2154220236962890773,
-                                                                     -3.2442003245397908E18,
-                                                                     "Wᄿ筠:瘫퀩?o貸q⊻(᎞KWf宛尨h^残3[U(='橄",
-                                                                     -7857990034281549164,
-                                                                     1.44283696979059942E18,
-                                                                     null,
-                                                                     {"ꫯAw跭喀 ?_9\"Aty背F=9缉ྦྷ@;?^鞀w:uN㘢Rỏ": [
-                                                                      7.393662029337442E15,
-                                                                      3564680942654233068,
-                                                                      [
-                                                                       false,
-                                                                       -5253931502642112194,
-                                                                       "煉\\辎ೆ罍5⒭1䪁䃑s䎢:[e5}峳ﴱn騎3?腳Hyꏃ膼N潭錖,Yᝋ˜YAၓ㬠bG렣䰣:",
-                                                                       true,
-                                                                       null,
-                                                                       {
-                                                                        "⒛'P&%죮|:⫶춞": -3818336746965687085,
-                                                                        "钖m<\/0ݎMtF2Pk=瓰୮洽겎.": [[
-                                                                         -8757574841556350607,
-                                                                         -3045234949333270161,
-                                                                         null,
-                                                                         {
-                                                                          "Ꮬr輳>⫇9hU##w@귪A\\C 鋺㘓ꖐ梒뒬묹㹻+郸嬏윤'+g<\/碴,}ꙫ>손;情d齆J䬁ຩ撛챝탹/R澡7剌tꤼ?ặ!`⏲睤\u00002똥଴⟏": null,
-                                                                          "\u20f2ܹe\\tAꥍư\\x当뿖렉禛;G檳ﯪS૰3~㘠#[J<}{奲 5箉⨔{놁<\/釿抋,嚠/曳m&WaOvT赋皺璑텁": [[
-                                                                           false,
-                                                                           null,
-                                                                           true,
-                                                                           -5.7131445659795661E18,
-                                                                           "萭m䓪D5|3婁ఞ>蠇晼6nﴺPp禽羱DS<睓닫屚삏姿",
-                                                                           true,
-                                                                           [
-                                                                            -8759747687917306831,
-                                                                            {
-                                                                             ">ⓛ\t,odKr{䘠?b퓸C嶈=DyEᙬ@ᴔ쨺芛髿UT퓻春<\/yꏸ>豚W釺N뜨^?꽴﨟5殺ᗃ翐%>퍂ဿ䄸沂Ea;A_\u0005閹殀W+窊?Ꭼd\u0013P汴G5썓揘": 4.342729067882445E-18,
-                                                                             "Q^즾眆@AN\u0011Kb榰냎Y#䝀ꀒᳺ'q暇睵s\"!3#I⊆畼寤@HxJ9": false,
-                                                                             "⿾D[)袨㇩i]웪䀤ᛰMvR<蟏㣨": {"v퇓L㪱ꖣ豛톤\\곱#kDTN": [{
-                                                                              "(쾴䡣,寴ph(C\"㳶w\"憳2s馆E!n!&柄<\/0Pꈗſ?㿳Qd鵔": {"娇堰孹L錮h嵅⛤躏顒?CglN束+쨣ﺜ\\MrH": {"獞䎇둃ቲ弭팭^ꄞ踦涟XK錆쳞ឌ`;੶S炥騞ଋ褂B៎{ڒ䭷ᶼ靜pI荗虶K$": [{"◖S~躘蒉꫿輜譝Q㽙闐@ᢗ¥E榁iء5┄^B[絮跉ᰥ遙PWi3wㄾⵀDJ9!w㞣ᄎ{듒ꓓb6\\篴??c⼰鶹⟧\\鮇ꮇ": [[
-                                                                               654120831325413520,
-                                                                               -1.9562073916357608E-19,
-                                                                               {
-                                                                                "DC(昐衵ἡ긙갵姭|֛[t": 7.6979110359897907E18,
-                                                                                "J␅))嫼❳9Xfd飉j7猬ᩉ+⤻眗벎E鰉Zﾶ63zၝ69}ZᶐL崭ᦥ⡦靚⋛ꎨ~i㨃咊ꧭo䰠阀3C(": -3.5844809362512589E17,
-                                                                                "p꣑팱쒬ꎑ뛡Ꙩ挴恍胔&7ᔈ묒4Hd硶훐㎖zꢼ豍㿢aሃ=<\/湉鵲EӅ%$F!퍶棌孼{O駍਺geu+": ")\u001b잓kŀX쩫A밁®ڣ癦狢)扔弒p}k縕ꩋ,䃉tࣼi",
-                                                                                "ァF肿輸<솄G-䢹䛸ꊏl`Tqꕗ蒞a氷⸅ᴉ蠰]S/{J왲m5{9.uέ~㕚㣹u>x8U讁B덺襪盎QhVS맅킃i识{벂磄Iහ䙅xZy/抍૭Z鲁-霳V据挦ℒ": null,
-                                                                                "㯛|Nꐸb7ⵐb?拠O\u0014ކ?-(EꞨ4ꕷᄤYᯕOW瞺~螸\"욿ќ<u鵵઎⸊倾쑷෻rT⪄牤銱;W殆͢芄ਰ嚝훚샢⊿+㲽": null,
-                                                                                "単逆ົ%_맛d)zJ%3칧_릟#95䌨怡\u001ci턠ॣi冘4赖'ਐ䧐_栔!": {
-                                                                                 "*?2~4㲌᭳쯁ftႷ1#oJ\b䊇镇됔 \u2079x䛁㊝ᮂN;穽跖s휇ᣄ홄傷z⸷(霸!3y뺏M쒿햏۽v㳉tở心3黎v쭻 Rp཮Vr~T?&˴k糒븥쩩r*D": null,
-                                                                                 "8@~홟ꔘk1[": -5570970366240640754,
-                                                                                 "BZt鏦ꡬc餖  s(mᛴ\u0000◄d腑t84C⟐坯VṊ뉙'噱Ꝕ珽GC顀?허0ꞹ&돇䛭C䷫](": 2.4303828213012387E-20,
-                                                                                 "y撔Z외放+}ḑ骈ᙝ&\u0016`G便2|-e]঳?QF㜹YF\"㿒緄햷㈟塚䷦ୀጤlM蘸N㾆▛럪㞂tᕬ镈쇝喠l amcxPnm\u001a᱋<\/]_]ﻹ瞧?H": false,
-                                                                                 "ፏ氏묢뜚I[♺뽛x?0H봬Wpn꨹Ra䝿쌑{㴂ni祻윸A'y|⺴ᚘ庌9{$恲{톽=m#@6ᨧfgs44陎J#<Ễ쨓瀵❩a୛㷉㙉ܸ◠냔嬯~呄籁羥镳": false,
-                                                                                 "㘱{<頬22?IF@곊I겂嶻L᝛D{@r쒂?IAᣧ洪惒誸b徂z췺꾍㠭\\刊%禨쌐ⶣ仵\\P[:47;<ᇅ<\/": {
-                                                                                  "^U釳-v㢈ꗝ◄菘rᜨi;起kR犺䵫\u0000锍쁙m-ԙ!lḃ꛸뻾F(W귛y": "#ᠺH㸢5v8_洑C",
-                                                                                  "䔵໳$ᙠ6菞\u206e摎q圩P|慍sV4:㜾(I溞I?": -6569206717947549676,
-                                                                                  "透Ꞃ緵퇝8 >e㺰\"'㌢ƐW\u0004瞕>0?V鷵엳": true,
-                                                                                  "뤥G\\迋䠿[庩'꼡\u001aiᩮV쯁ᳪ䦪Ô;倱ନ뛁誈": null,
-                                                                                  "쥹䄆䚟Q榁䎐᢭<\/2㕣p}HW蟔|䃏꿈ꚉ锳2Pb7㙑Tⅹᵅ": {
-                                                                                   "Y?֭$>#cVBꩨ:>eL蒁務": {
-                                                                                    "86柡0po 䏚&-捑Ћ祌<\/휃-G*㶢הּ쩍s㶟餇c걺yu꽎還5*턧簕Og婥SꝐ": null,
-                                                                                    "a+葞h٥ࠆ裈嗫ﵢ5輙퀟ᛜ,QDﹼ⟶Y騠锪E_|x죗j侵;m蜫轘趥?븅w5+mi콛L": {
-                                                                                     ";⯭ﱢ!买F⽍柤鶂n䵣V㫚墱2렾ELEl⣆": [
-                                                                                      true,
-                                                                                      -3.6479311868339015E-18,
-                                                                                      -7270785619461995400,
-                                                                                      3.334081886177621E18,
-                                                                                      2.581457786298155E18,
-                                                                                      -6.605252412954115E-20,
-                                                                                      -3.9232347037744167E-20,
-                                                                                      {
-                                                                                       "B6㊕.k1": null,
-                                                                                       "ZAꄮJ鮷ᳱo갘硥鈠䠒츼": {
-                                                                                        "ᕅ}럡}.@y陪鶁r業'援퀉x䉴ﵴl퍘):씭脴ᥞhiꃰblﲂ䡲엕8߇M㶭0燋標挝-?PCwe⾕J碻Ᾱ䬈䈥뷰憵賣뵓痬+": {"a췩v礗X⋈耓ፊf罅靮!㔽YYᣓw澍33⎔芲F|\"䜏T↮輦挑6ᓘL侘?ￆ]덆1R௯✎餘6ꏽ<\/௨\\?q喷ꁫj~@ulq": {"嗫欆뾔Xꆹ4H㌋F嵧]ࠎ]㠖1ꞤT<$m뫏O i댳0䲝i": {"?෩?\u20cd슮|ꯆjs{?d7?eNs⢚嫥氂䡮쎱:鑵롟2hJꎒﯭ鱢3춲亄:뼣v䊭諱Yj択cVmR䩃㘬T\"N홝*ै%x^F\\_s9보zz4淗?q": [
-                                                                                         null,
-                                                                                         "?",
-                                                                                         2941869570821073737,
-                                                                                         "{5{殇0䝾g6밖퍋臩綹R$䖭j紋釰7sXI繳漪행y",
-                                                                                         false,
-                                                                                         "aH磂?뛡#惇d婅?Fe,쐘+늵䍘\"3r瘆唊勐j⳧࠴ꇓ<\/唕윈x⬌讣䋵%拗ᛆⰿ妴᝔M2㳗必꧂淲?ゥ젯檢<8끒MidX䏒3᳻Q▮佐UT|⤪봦靏⊏",
-                                                                                         [[{
-                                                                                          "颉(&뜸귙{y^\"P퟉춝Ჟ䮭D顡9=?}Y誱<$b뱣RvO8cH煉＠tk~4ǂ⤧⩝屋SS;J{vV#剤餓ᯅc?#a6D,s": [
-                                                                                           -7.8781018564821536E16,
-                                                                                           true,
-                                                                                           [
-                                                                                            -2.28770899315832371E18,
-                                                                                            false,
-                                                                                            -1.0863912140143876E-20,
-                                                                                            -6282721572097446995,
-                                                                                            6767121921199223078,
-                                                                                            -2545487755405567831,
-                                                                                            false,
-                                                                                            null,
-                                                                                            -9065970397975641765,
-                                                                                            [
-                                                                                             -5.928721243413937E-20,
-                                                                                             {"6촊\u001a홯kB0w撨燠룉{绎6⳹!턍贑y▾鱧ժ[;7ᨷ∀*땒䪮1x霆Hᩭ☔\"r䝐7毟ᝰr惃3ꉭE+>僒澐": [
-                                                                                              "Ta쎩aƝt쵯ⰪVb",
-                                                                                              [
-                                                                                               -5222472249213580702,
-                                                                                               null,
-                                                                                               -2851641861541559595,
-                                                                                               null,
-                                                                                               4808804630502809099,
-                                                                                               5657671602244269874,
-                                                                                               "5犲﨣4mᥣ?yf젫꾯|䋬잁$`Iⳉﴷ扳兝,'c",
-                                                                                               false,
-                                                                                               [
-                                                                                                null,
-                                                                                                {
-                                                                                                 "DyUIN쎾M仼惀⮥裎岶泭lh扠\u001e礼.tEC癯튻@_Qd4c5S熯A<\/＼6U윲蹴Q=%푫汹\\\u20614b[௒C⒥Xe⊇囙b,服3ss땊뢍i~逇PA쇸1": -2.63273619193485312E17,
-                                                                                                 "Mq꺋貘k휕=nK硍뫞輩>㾆~἞ࡹ긐榵l⋙Hw뮢帋M엳뢯v⅃^": 1877913476688465125,
-                                                                                                 "ᶴ뻗`~筗免⚽টW˃⽝b犳䓺Iz篤p;乨A\u20ef쩏?疊m㝀컩뫡b탔鄃ᾈV(遢珳=뎲ିeF仢䆡谨8t0醄7㭧瘵⻰컆r厡궥d)a阄፷Ed&c﯄伮1p": null,
-                                                                                                 "⯁w4曢\"(欷輡": "\"M᭫]䣒頳B\\燧ࠃN㡇j姈g⊸⺌忉ꡥF矉স%^",
-                                                                                                 "㣡Oᄦ昵⫮Y祎S쐐級㭻撥>{I$": -378474210562741663,
-                                                                                                 "䛒掷留Q%쓗1*1J*끓헩ᦢ﫫哉쩧EↅIcꅡ\\?ⴊl귛顮4": false,
-                                                                                                 "寔愆샠5]䗄IH贈=d﯊/偶?ॊn%晥D視N򗘈'᫂⚦|X쵩넽z질tskxDQ莮Aoﱻ뛓": true,
-                                                                                                 "钣xp?&\u001e侉/y䴼~?U篔蘚缣/I畚?Q绊": -3034854258736382234,
-                                                                                                 "꺲໣眀)⿷J暘pИfAV삕쳭Nꯗ4々'唄ⶑ伻㷯騑倭D*Ok꧁3b␽_<\/챣Xm톰ၕ䆄`*fl㭀暮滠毡?": [
-                                                                                                  "D男p`V뙸擨忝븪9c麺`淂⢦Yw⡢+kzܖ\fY1䬡H歁)벾Z♤溊-혰셢?1<-\u0005;搢Tᐁle\\ᛵߓﭩ榩<QF;t=?Qꀞ",
-                                                                                                  [
-                                                                                                   null,
-                                                                                                   [{"-췫揲ᬨ墊臸<ࠒH跥 㔭쥃㫯W=z[wধ╌<~yW楄S!⑻h즓lĖN￧篌W듷튗乵᪪템먵Pf悥ᘀk䷭焼\\讄r擁鐬y6VF<\/6랿p)麡ꁠ㪁\"pழe": [
-                                                                                                    "#幎杴颒嶈)ㄛJ.嶤26_⋌东챯ꠉ⤋ؚ/⏚%秼Q룠QGztﾺ㎷អI翰Xp睔鍜ꨍ",
-                                                                                                    {",T?": [
-                                                                                                     false,
-                                                                                                     [[
-                                                                                                      true,
-                                                                                                      7974824014498027996,
-                                                                                                      false,
-                                                                                                      [
-                                                                                                       4.3305464880956252E18,
-                                                                                                       {
-                                                                                                        "᱿W^A]'rᮢ)鏥z餝;Hu\\Fk?ﴺ?IG浅-䙧>訝-xJ;巡8깊蠝ﻓU$K": {
-                                                                                                         "Vꕡ諅搓W=斸s︪vﲜ츧$)iꡟ싉e寳?ጭムVથ嵬i楝Fg<\/Z|៪ꩆ-5'@ꃱ80!燱R쇤t糳]罛逇dṌ֣XHiͦ{": true,
-                                                                                                         "Ya矲C멗Q9膲墅携휻c\\딶G甔<\/.齵휴": -1.1456247877031811E-19,
-                                                                                                         "z#.OO￝J": -8263224695871959017,
-                                                                                                         "崍_3夼ᮟ1F븍뽯ᦓ鴭V豈Ь": [{
-                                                                                                          "N蒬74": null,
-                                                                                                          "yuB?厅vK笗!ᔸcXQ旦컶P-녫mﾵ麟_": "1R@ 톘xa_|﩯遘s槞d!d껀筤⬫薐焵먑D{\\6k共倌☀G~AS_D\"딟쬚뮥馲렓쓠攥WTMܭ8nX㩴䕅檹E\u0007ﭨN 2 ℆涐ꥏ꠵3▙玽|됨_\u2048",
-                                                                                                          "恐A C䧩G": {":M큣5e들\\ꍀ恼ᔄ靸|I﨏$)n": {
-                                                                                                           "|U䬫㟯SKV6ꛤ㗮\bn봻䲄fＸT:㾯쳤'笓0b/ೢC쳖?2浓uO.䰴": "ཐ꼋e?``,ᚇ慐^8ꜙNM䂱\u0001IᖙꝧM'vKdꌊH牮r\\O@䊷ᓵ쀆(fy聻i툺\"?<\/峧ࣞ⓺ᤤ쵒߯ꎺ騬?)刦\u2072l慪y꺜ﲖTj+u",
-                                                                                                           "뽫<G;稳UL⸙q2n쵿C396炿J蓡z⣁zဩSOU?<\/뙍oE큸O鿅෴ꍈEm#\"[瑦⤫ᝆgl⡗q8\"큘덥係@ᆤ=\u0001爖羝췀㸩b9\\jeqt㟿㮸龾m㳳긄": {
-                                                                                                            "9\"V霟釜{/o0嫲C咀-饷䈍[녩)\r䤴tMW\\龟ϣ^ي㪙忩䞞N湆Y笕)萨ꖤ誥煽:14⫻57U$擒䲐薡Qvↇ櫲현誧?nஷ6": {"l웾䌵.䅋䦝ic碳g[糲Ƿ-ឈᚱ4쑧\u0004C࿼\u0018&쬑?멲<\/fD_檼픃pd쪼n㕊渪V䛉m揈W儅톳뗳䓆7㭽諤T煠Ney?0᪵鈑&": [
-                                                                                                             false,
-                                                                                                             null,
-                                                                                                             {
-                                                                                                              "\r;鼶j᠂꼍RLz~♔9gf?ӡ浐": -1.4843072575250897E-19,
-                                                                                                              "&ꊒ\"ꋟ䝭E诮ﯚO?SW뒁훪mb旙⎕ᗕ⶙|ᷤ5y4甥": "j5|庠t铱?v 횋0\"'rxz䃢杺Ɜ!\u0002",
-                                                                                                              "Q ၩ㟧": {"Hﬔ\u2058䪠틙izZㅛ탟H^ﶲA??R6呠Z솋R.࿶g8": [
-                                                                                                               -8762672252886298799,
-                                                                                                               -1.9486830507000208E17,
-                                                                                                               null,
-                                                                                                               -7157359405410123024,
-                                                                                                               null,
-                                                                                                               null,
-                                                                                                               -995856734219489233,
-                                                                                                               "呧㫹A4!",
-                                                                                                               null,
-                                                                                                               -1.9105609358624648E-19,
-                                                                                                               5888184370445333848,
-                                                                                                               2.25460605078245E-19,
-                                                                                                               2.5302739297121987E18,
-                                                                                                               "뢹sbEf捵2丯?뗾耸(Wd띙SବꭖrtU?筤P똙QpbbKqaE$来V웰3i/lK퉜,8︸e= g螓t竦컼?.寋8鵗",
-                                                                                                               7377742975895263424,
-                                                                                                               2.4218442017790503E-19,
-                                                                                                               {
-                                                                                                                "y꒚ཫ쨘醬킃糟}yTSt䡀⇂뿽4ൢ戰U": [[
-                                                                                                                 3600537227234741875,
-                                                                                                                 4435474101760273035,
-                                                                                                                 -1.42274517007951795E18,
-                                                                                                                 -5567915915496026866,
-                                                                                                                 null,
-                                                                                                                 null,
-                                                                                                                 [
-                                                                                                                  -3204084299154861161,
-                                                                                                                  {
-                                                                                                                   "7梧慸憏.a瘎\u00041U鵮Ck֨d惥耍ⳡY,⭏써E垁FFI鱑ⳬ줢7⧵Bﴠ耘줕햸q컴~*瑍W.떛ࡆ@'᐀+轳": -961121410259132975,
-                                                                                                                   "⥅]l黭㣓绶;!!⎃=朼㐿e&ἂ繤C﯀l䝣㌀6TM쑮w懃ꡡ#ᤆ䰓,墼湼゙뽸㲿䧽쫨xᵖ듨<\/ T0峸iQ:溫脐\\\"쎪ὴ砇宖^M泼큥➅鈫@ᄟ༩\u2008⥼": true,
-                                                                                                                   "⩐\"籽汎P싯鲘蟼sRᐯ䅩\u0019R(kRᖁ&ಌ 0\"鳶!馼YH": null,
-                                                                                                                   "鮼ꚇ싋։刟\rRLd步Nⴗ5Eࡆ訛갚[I醵NC(郴ṉy5D뤺౳QY壯5苴y훨(W\\Cଇ姚C艄깹\u001c歷㋵ZC᥂": [
-                                                                                                                    -6806235313106257498,
-                                                                                                                    null,
-                                                                                                                    "}N⸿讽sꚪ;\\p繇j苄䫨\u20e7%5x?t#",
-                                                                                                                    {
-                                                                                                                     "O〗k<墻yV$ఁrs-c1ఌ唪.C7_Yobᦜ褷'b帰mㄑl⌅": {"qB뗗擄3隂5뺍櫂䱟e촸P/鏩,3掁ꗩ=冉棓㑉|˞F襴뿴,:㞦<퓂⧙礞♗g뚎ᛩ<\/뉽ⶳ⸻A?_x2I㽝勒*I홱鍧粿~曟㤙2绥Ly6+썃uu鿜בf큘|歍ࣖÉ": [
-                                                                                                                      ">hh䈵w>1ⲏ쐭V[ⅎ\\헑벑F_㖝⠗㫇h恽;῝汰ᱼ瀖J옆9RR셏vsZ柺鶶툤r뢱橾/ꉇ囦FGm\"謗ꉦ⨶쒿⥡%]鵩#ᖣ_蹎 u5|祥?O",
-                                                                                                                      null,
-                                                                                                                      2.0150326776036215E-19,
-                                                                                                                      null,
-                                                                                                                      true,
-                                                                                                                      false,
-                                                                                                                      true,
-                                                                                                                      {"\fa᭶P捤WWc᠟f뚉ᬏ퓗ⳀW睹5:HXH=q7x찙X$)모r뚥ᆟ!Jﳸf": [
-                                                                                                                       -2995806398034583407,
-                                                                                                                       [
-                                                                                                                        6441377066589744683,
-                                                                                                                        "Mﶒ醹i)Gἦ廃s6몞 KJ౹礎VZ螺费힀\u0000冺업{谥'꡾뱻:.ꘘ굄奉攼Di᷑K鶲y繈욊阓v㻘}枭캗e矮1c?휐\"4\u0005厑莔뀾墓낝⽴洗ṹ䇃糞@b1\u0016즽Y轹",
-                                                                                                                        {
-                                                                                                                         "1⽕⌰鉟픏M㤭n⧴ỼD#%鐘⊯쿼稁븣몐紧ᅇ㓕ᛖcw嬀~ഌ㖓(0r⧦Q䑕髍ര铂㓻R儮\"@ꇱm❈௿᦯頌8}㿹犴?xn잆꥽R": 2.07321075750427366E18,
-                                                                                                                         "˳b18㗈䃟柵Z曆VTAu7+㛂cb0﯑Wp執<\/臋뭡뚋刼틮荋벲TLP预庰܈G\\O@VD'鱃#乖끺*鑪ꬳ?Mޞdﭹ{␇圯쇜㼞顄︖Y홡g": [{
-                                                                                                                          "0a,FZ": true,
-                                                                                                                          "2z̬蝣ꧦ驸\u0006L↛Ḣ4๚뿀'?lcwᄧ㐮!蓚䃦-|7.飑挴.樵*+1ﮊ\u0010ꛌ%貨啺/JdM:똍!FBe?鰴㨗0O财I藻ʔWA᫓G쳛u`<\/I": [{
-                                                                                                                           "$τ5V鴐a뾆両環iZp頻යn븃v": -4869131188151215571,
-                                                                                                                           "*즢[⦃b礞R◚nΰꕢH=귰燙[yc誘g䆌?ଜ臛": {
-                                                                                                                            "洤湌鲒)⟻\\䥳va}PeAMnＮ[": "㐳ɪ/(軆lZR,Cp殍ȮN啷\"3B婴?i=r$펽ᤐ쀸",
-                                                                                                                            "阄R4㒿㯔ڀ69ZᲦ2癁핌噗P崜#\\-쭍袛&鐑/$4童V꩑_ZHA澢fZ3": {"x;P{긳:G閉:9?活H": [
-                                                                                                                             "繺漮6?z犞焃슳\">ỏ[Ⳛ䌜녏䂹>聵⼶煜Y桥[泥뚩MvK$4jtﾛ",
-                                                                                                                             "E#갶霠좭㦻ୗ먵F+䪀o蝒ba쮎4X㣵 h",
-                                                                                                                             -335836610224228782,
-                                                                                                                             null,
-                                                                                                                             null,
-                                                                                                                             [
-                                                                                                                              "r1᫩0>danjY짿bs{",
-                                                                                                                              [
-                                                                                                                               -9.594464059325631E-23,
-                                                                                                                               1.0456894622831624E-20,
-                                                                                                                               null,
-                                                                                                                               5.803973284253454E-20,
-                                                                                                                               -8141787905188892123,
-                                                                                                                               true,
-                                                                                                                               -4735305442504973382,
-                                                                                                                               9.513150514479281E-20,
-                                                                                                                               "7넳$螔忷㶪}䪪l짴\u0007鹁P鰚HF銏ZJﳴ/⍎1ᷓ忉睇ᜋ쓈x뵠m䷐窥Ꮤ^\u0019ᶌ偭#ヂt☆၃pᎍ臶䟱5$䰵&๵分숝]䝈뉍♂坎\u0011<>",
-                                                                                                                               "C蒑貑藁lﰰ}X喇몛;t밿O7/᯹f\u0015kI嘦<ዴ㟮ᗎZ`GWퟩ瑹࡮ᅴB꿊칈??R校s脚",
-                                                                                                                               {
-                                                                                                                                "9珵戬+AU^洘拻ቒy柭床'粙XG鞕᠜繀伪%]hC,$輙?Ut乖Qm떚W8઼}~q⠪rU䤶CQ痗ig@#≲t샌f㈥酧l;y闥ZH斦e⸬]j⸗?ঢ拻퀆滌": null,
-                                                                                                                                "畯}㧢J罚帐VX㨑>1ꢶkT⿄蘥㝑o|<嗸層沈挄GEOM@-䞚䧰$만峬輏䠱V✩5宸-揂D'㗪yP掶7b⠟J㕻SfP?d}v㼂Ꮕ'猘": {
-                                                                                                                                 "陓y잀v>╪": null,
-                                                                                                                                 "鬿L+7:됑Y=焠U;킻䯌잫!韎ஔ\f": {
-                                                                                                                                  "駫WmGጶ": {
-                                                                                                                                   "\\~m6狩K": -2586304199791962143,
-                                                                                                                                   "ႜࠀ%͑l⿅D.瑢Dk%0紪dḨTI픸%뗜☓s榗኉\"?V籄7w髄♲쟗翛歂E䤓皹t ?)ᄟ鬲鐜6C": {
-                                                                                                                                    "_췤a圷1\u000eB-XOy缿請∎$`쳌eZ~杁튻/蜞`塣৙\"⪰\"沒l}蕌\\롃荫氌.望wZ|o!)Hn獝qg}": null,
-                                                                                                                                    "kOSܧ䖨钨:಼鉝ꭝO醧S`십`ꓭ쭁ﯢN&Et㺪馻㍢ⅳ㢺崡ຊ蜚锫\\%ahx켨|ż劻ꎄ㢄쐟A躊᰹p譞綨Ir쿯\u0016ﵚOd럂*僨郀N*b㕷63z": {
-                                                                                                                                     ":L5r+T㡲": [{
-                                                                                                                                      "VK泓돲ᮙRy㓤➙Ⱗ38oi}LJቨ7Ó㹡৘*q)1豢⛃e᫛뙪壥镇枝7G藯g㨛oI䄽 孂L缊ꋕ'EN`": -2148138481412096818,
-                                                                                                                                      "`⛝ᘑ$(खꊲ⤖ᄁꤒ䦦3=)]Y㢌跨NĴ驳줟秠++d孳>8ᎊ떩EꡣSv룃 쯫أ?#E|᭙㎐?zv:5祉^⋑V": [
-                                                                                                                                       -1.4691944435285607E-19,
-                                                                                                                                       3.4128661569395795E17,
-                                                                                                                                       "㐃촗^G9佭龶n募8R厞eEw⺡_ㆱ%⼨D뉄퉠2ꩵᛅⳍ搿L팹Lවn=\"慉념ᛮy>!`g!풲晴[/;?[v겁軇}⤳⤁핏∌T㽲R홓遉㓥",
-                                                                                                                                       "愰_⮹T䓒妒閤둥?0aB@㈧g焻-#~跬x<\/舁P݄ꐡ=\\׳P\u0015jᳪᢁq;㯏l%᭗;砢觨▝,謁ꍰGy?躤O黩퍋Y㒝a擯\n7覌똟_䔡]fJ晋IAS",
-                                                                                                                                       4367930106786121250,
-                                                                                                                                       -4.9421193149720582E17,
-                                                                                                                                       null,
-                                                                                                                                       {
-                                                                                                                                        ";ﾸ똾柉곟ⰺKpፇ䱻ฺ䖝{o~h!ｅꁿ઻욄ښ\u0002y?xUd\u207c悜ꌭ": [
-                                                                                                                                         1.6010824122815255E-19,
-                                                                                                                                         [
-                                                                                                                                          "宨︩9앉檥pr쇷?WxLb",
-                                                                                                                                          "氇9】J玚\u000f옛呲~ 輠1D嬛,*mW3?n휂糊γ虻*ᴫ꾠?q凐趗Ko↦GT铮",
-                                                                                                                                          "㶢ថmO㍔k'诔栀Z蛟}GZ钹D",
-                                                                                                                                          false,
-                                                                                                                                          -6.366995517736813E-20,
-                                                                                                                                          -4894479530745302899,
-                                                                                                                                          null,
-                                                                                                                                          "V%᫡II璅䅛䓎풹ﱢ/pU9se되뛞x梔~C)䨧䩻蜺(g㘚R?/Ự[忓C뾠ࢤc왈邠买?嫥挤풜隊枕",
-                                                                                                                                          ",v碍喔㌲쟚蔚톬៓ꭶ",
-                                                                                                                                          3.9625444752577524E-19,
-                                                                                                                                          null,
-                                                                                                                                          [
-                                                                                                                                           "kO8란뿒䱕馔b臻⍟隨\"㜮鲣Yq5m퐔<u뷆c譆\u001bN?<",
-                                                                                                                                           [{
-                                                                                                                                            ";涉c蒀ᴧN䘱䤳 ÿꭷ,핉dSTDB>K#ꢘug㼈ᝦ=P^6탲@䧔%$CqSw铜랊0&m⟭<\/a逎ym\u0013vᯗ": true,
-                                                                                                                                            "洫`|XN뤮\u0018詞=紩鴘_sX)㯅鿻Ố싹": 7.168252736947373E-20,
-                                                                                                                                            "ꛊ饤ﴏ袁(逊+~⽫얢鈮艬O힉7D筗S곯w操I斞᠈븘蓷x": [[[[
-                                                                                                                                             -7.3136069426336952E18,
-                                                                                                                                             -2.13572396712722688E18,
-                                                                                                                                             {
-                                                                                                                                              "硢3㇩R:o칢行E<=\u0018ၬYuH!\u00044U%卝炼2>\u001eSi$⓷ꒈ'렢gᙫ番ꯒ㛹럥嶀澈v;葷鄕x蓎\\惩+稘UEᖸﳊ㊈壋N嫿⏾挎,袯苷ኢ\\x|3c": 7540762493381776411,
-                                                                                                                                              "?!*^ᢏ窯?\u0001ڔꙃw虜돳FgJ?&⨫*uo籤:?}ꃹ=ٴ惨瓜Z媊@ત戹㔏똩Ԛ耦Wt轁\\枒^\\ꩵ}}}ꀣD\\]6M_⌫)H豣:36섘㑜": {
-                                                                                                                                               ";홗ᰰU஋㙛`D왔ཿЃS회爁\u001b-㢈`봆?盂㛣듿ᦾ蒽_AD~EEຆ㊋(eNwk=Rɠ峭q\"5Ἠ婾^>'ls\n8QAK<l_⭨穟": [
-                                                                                                                                                true,
-                                                                                                                                                true,
-                                                                                                                                                {"ﳷm箅6qⷈ?ﲈ憟b۷⫉἞V뚴少U呡瓴ꉆs~嘵得㌶4XR漊": [
-                                                                                                                                                 "폆介fM暪$9K[ㄇ샍큳撦g撟恸jҐF㹹aj bHᘀ踉ꎐＣ粄 a?\u000fK즉郝 幨9D舢槷Xh뵎u훩Ꜿ턾ƅ埂P埆k멀{䢹~?D<\/꼢XR\u001b〱䝽꼨i㘀ḟ㚺A-挸",
-                                                                                                                                                 false,
-                                                                                                                                                 null,
-                                                                                                                                                 -1.1710758021294953E-20,
-                                                                                                                                                 3996737830256461142,
-                                                                                                                                                 true,
-                                                                                                                                                 null,
-                                                                                                                                                 -8271596984134071193,
-                                                                                                                                                 "_1G퉁텑m䮔鰼6멲Nmꇩſt쓟튍N许FDj+3^ﶜ⎸\u0019⤕橥!\"s-뾞lz北׸ꍚ랬)?l⻮고i䑰\u001f䪬",
-                                                                                                                                                 4.459124464204517E-19,
-                                                                                                                                                 -4.0967172848578447E18,
-                                                                                                                                                 5643211135841796287,
-                                                                                                                                                 -9.482336221192844E-19,
-                                                                                                                                                 "౪冏釶9D?s螭X榈枸j2秀v]泌鰚岒聵轀쌶i텽qMbL]R,",
-                                                                                                                                                 null,
-                                                                                                                                                 [
-                                                                                                                                                  null,
-                                                                                                                                                  {"M쪊ꯪ@;\u0011罙ꕅ<e᝺|爑Yⵝ<\/&ᩎ<腊ሑᮔ੃F豭": [
-                                                                                                                                                   "^0࡟1볏P폋ፏ杈F⨥Iꂴ\"z磣VⅡ=8퀝2]䢹h1\u0017{jT<I煛5%D셍S⑙⅏J*샐 巙ດ;᧡䙞",
-                                                                                                                                                   [{
-                                                                                                                                                    "'㶡큾鄧`跊\"gV[?u᭒Ʊ髷%葉굵a띦N켧Qﯳy%y䩟髒L䯜S䵳r絅肾킂ၐ'ꔦg긓a'@혔যW谁ᝬF栩ŷ+7w鞚": 6.3544416675584832E17,
-                                                                                                                                                    "苎脷v改hm쏵|㋊g_ᔐ 뒨蹨峟썎㷸|Ο刢?Gͨ옛-?GꦱIEYUX4?%ꘋᆊ㱺": -2.8418378709165287E-19,
-                                                                                                                                                    "誰?(H]N맘]k洳\"q蒧蘞!R퐫\\(Q$T5N堍⫣윿6|럦속︅ﭗ(": [
-                                                                                                                                                     "峩_\u0003A瘘?✓[硫䎯ၽuጭ\"@Y綅첞m榾=贮9R벿῜Z",
-                                                                                                                                                     null,
-                                                                                                                                                     "䰉㗹㷾Iaᝃqcp쓘὾൫Q|ﵓ<\/ḙ>)- Q䲌mo펹L_칍樖庫9꩝쪹ᘹ䑖瀍aK ?*趤f뭓廝p=磕",
-                                                                                                                                                     "哑z懅ᤏ-ꍹux쀭",
-                                                                                                                                                     [
-                                                                                                                                                      true,
-                                                                                                                                                      3998739591332339511,
-                                                                                                                                                      "ጻ㙙?᳸aK<\/囩U`B3袗ﱱ?\"/k鏔䍧2l@쿎VZ쨎/6ꃭ脥|B?31+on颼-ꮧ,O嫚m ࡭`KH葦:粘i]aSU쓙$쐂f+詛頖b",
-                                                                                                                                                      [{"^<9<箝&絡;%i﫡2攑紴\\켉h쓙-柂䚝ven\u20f7浯-Ꮏ\r^훁䓚헬\u000e?\\ㅡֺJ떷VOt": [{
-                                                                                                                                                       "-௄卶k㘆혐஽y⎱㢬sS઄+^瞥h;ᾷj;抭\u0003밫f<\/5Ⱗ裏_朻%*[-撵䷮彈-芈": {
-                                                                                                                                                        "㩩p3篊G|宮hz䑊o곥j^Co0": [
-                                                                                                                                                         653239109285256503,
-                                                                                                                                                         {"궲?|\":N1ۿ氃NZ#깩:쇡o8킗ࡊ[\"됸Po핇1(6鰏$膓}⽐*)渽J'DN<썙긘毦끲Ys칖": {
-                                                                                                                                                          "2Pr?Xjㆠ?搮/?㓦柖馃5뚣Nᦼ|铢r衴㩖\"甝湗ܝ憍": "\"뾯i띇筝牻$珲/4ka $匝휴译zbAᩁꇸ瑅&뵲衯ꎀᆿ7@ꈋ'ᶨH@ᠴl+",
-                                                                                                                                                          "7뢽뚐v?4^ꊥ_⪛.>pởr渲<\/⢕疻c\"g䇘vU剺dஔ鮥꒚(dv祴X⼹\\a8y5坆": true,
-                                                                                                                                                          "o뼄B욞羁hr﷔폘뒚⿛U5pꪴfg!6\\\"爑쏍䢱W<ﶕ\\텣珇oI/BK뺡'谑♟[Ut븷亮g(\"t⡎有?ꬊ躺翁艩nl F⤿蠜": 1695826030502619742,
-                                                                                                                                                          "ۊ깖>ࡹ햹^ⵕ쌾BnN〳2C䌕tʬ]찠?ݾ2饺蹳ぶꌭ訍\"◹ᬁD鯎4e滨T輀ﵣ੃3\u20f3킙D瘮g\\擦+泙ၧ 鬹ﯨַ肋7놷郟lP冝{ߒhড়r5,꓋": null,
-                                                                                                                                                          "ΉN$y{}2\\N﹯ⱙK'8ɜͣwt,．钟廣䎘ꆚk媄_": null,
-                                                                                                                                                          "䎥eᾆᝦ읉,Jުn岪㥐s搖謽䚔5t㯏㰳㱊ZhD䃭f絕s鋡篟a`Q鬃┦鸳n_靂(E4迠_觅뷝_宪D(NL疶hL追V熑%]v肫=惂!㇫5⬒\u001f喺4랪옑": {
-                                                                                                                                                           "2a輍85먙R㮧㚪Sm}E2yꆣꫨrRym㐱膶ᔨ\\t綾A☰.焄뙗9<쫷챻䒵셴᭛䮜.<\/慌꽒9叻Ok䰊Z㥪幸k": [
-                                                                                                                                                            null,
-                                                                                                                                                            true,
-                                                                                                                                                            {"쌞쐍": {
-                                                                                                                                                             "▟GL K2i뛱iＱ\"̠.옛1X$}涺]靎懠ڦ늷?tf灟ݞゟ{": 1.227740268699265E-19,
-                                                                                                                                                             "꒶]퓚%ฬK❅": [{
-                                                                                                                                                              "(ෛ@Ǯっ䧼䵤[aﾃൖvEnAdU렖뗈@볓yꈪ,mԴ|꟢캁(而첸죕CX4Y믅": "2⯩㳿ꢚ훀~迯?᪑\\啚;4X\u20c2襏B箹)俣eỻw䇄",
-                                                                                                                                                              "75༂f詳䅫ꐧ鏿 }3\u20b5'∓䝱虀f菼Iq鈆﨤g퍩)BFa왢d0뮪痮M鋡nw∵謊;ꝧf美箈ḋ*\u001c`퇚퐋䳫$!V#N㹲抗ⱉ珎(V嵟鬒_b㳅\u0019": null,
-                                                                                                                                                              "e_m@(i㜀3ꦗ䕯䭰Oc+-련0뭦⢹苿蟰ꂏSV䰭勢덥.ྈ爑Vd,ᕥ=퀍)vz뱊ꈊB_6듯\"?{㒲&㵞뵫疝돡믈%Qw限,?\r枮\"? N~癃ruࡗdn&": null,
-                                                                                                                                                              "㉹&'Pfs䑜공j<\/?|8oc᧨L7\\pXᭁ 9᪘": -2.423073789014103E18,
-                                                                                                                                                              "䝄瑄䢸穊f盈᥸,B뾧푗횵B1쟢f\u001f凄": "魖⚝2儉j꼂긾껢嗎0ࢇ纬xI4](੓`蕞;픬\fC\"斒\")2櫷I﹥迧",
-                                                                                                                                                              "ퟯ詔x悝령+T?Bg⥄섅kOeQ큼㻴*{E靼6氿L缋\u001c둌๶-㥂2==-츫I즃㠐Lg踞ꙂEG貨鞠\"\u0014d'.缗gI-lIb䋱ᎂDy缦?": null,
-                                                                                                                                                              "紝M㦁犿w浴詟棓쵫G:䜁?V2ힽ7N*n&㖊Nd-'ຊ?-樹DIv⊜)g䑜9뉂ㄹ푍阉~ꅐ쵃#R^\u000bB䌎䦾]p.䀳": [{"ϒ爛\"ꄱ︗竒G䃓-ま帳あ.j)qgu扐徣ਁZ鼗A9A鸦甈!k蔁喙:3T%&㠘+,䷞|챽v䚞문H<\/醯r셓㶾\\a볜卺zE䝷_죤ဵ뿰᎟CB": [
-                                                                                                                                                               6233512720017661219,
-                                                                                                                                                               null,
-                                                                                                                                                               -1638543730522713294,
-                                                                                                                                                               false,
-                                                                                                                                                               -8901187771615024724,
-                                                                                                                                                               [
-                                                                                                                                                                3891351109509829590,
-                                                                                                                                                                true,
-                                                                                                                                                                false,
-                                                                                                                                                                -1.03836679125188032E18,
-                                                                                                                                                                {
-                                                                                                                                                                 "<?起HCᷭ죎劐莇逰/{gs\u0014⽛㰾愫tￖ<솞ڢ됌煲膺਻9x닳x࡭Q訽,ᶭඦtt掾\"秧㺌d˪䙻꫗:ᭈh4緞痐䤴c뫚떩త<?ᕢ謚6]폛O鰐鋛镠贩赟\"<G♷1'": true,
-                                                                                                                                                                 "቙ht4ߝBqꦤ+\u0006멲趫灔)椾": -1100102890585798710,
-                                                                                                                                                                 "総兎곇뇸粟F醇;朠?厱楛㶆ⶏ7r⾛o꯬᳡F\\머幖 㜦\f[搦᥽㮣0䕊?J㊳뀄e㔔+?<n↴复": [
-                                                                                                                                                                  "4~ꉍ羁\\偮(泤叕빜\u0014>j랎:g曞ѕᘼ}链N",
-                                                                                                                                                                  -1.1103819473845426E-19,
-                                                                                                                                                                  true,
-                                                                                                                                                                  [
-                                                                                                                                                                   true,
-                                                                                                                                                                   null,
-                                                                                                                                                                   -7.9091791735309888E17,
-                                                                                                                                                                   true,
-                                                                                                                                                                   {"}蔰鋈+ꐨ啵0?g*사%`J?*": [{
-                                                                                                                                                                    "\"2wG?yn,癷BK\\龞䑞x?蠢": -3.7220345009853505E-19,
-                                                                                                                                                                    ";饹়❀)皋`噿焒j(3⿏w>偍5X<np?<줯<Y]捘!J೸UⳂNे7v௸㛃ᄧ톿䨷鯻v焇=烻TQ!F⦰䣣눿K鷚눁'⭲m捠(䚻": [
-                                                                                                                                                                     "蹕 淜੃b\"+몾ⴕ",
-                                                                                                                                                                     null,
-                                                                                                                                                                     35892237756161615,
-                                                                                                                                                                     {
-                                                                                                                                                                      " 듹㏝)5慁箱&$~:遰쮐<\/堋?% \\勽唅z손帋䘺H髀麡M퇖uz\u0012m諦d᳤콌樝\rX싹̡Ო": -433791617729505482,
-                                                                                                                                                                      "-j溗ࢵcz!:}✽5ഇ,욨ݏs#덫=南浺^}E\\Y\\T*뼈cd꺐cۘ뎁䨸됱K䠴㉿恿逳@wf쏢<\/[L[": -9.3228549642908109E17,
-                                                                                                                                                                      "Ms킭u஗%\\u⍎/家欲ἅ答㓽/꯳齳|㭘Pr\"v<\/禇䔆$GA䊻˔-:틊[h?倬荤ᾞ৳.Gw\u000b": [
-                                                                                                                                                                       "0宜塙I@䏴蝉\\Uy뒅=2<h暒K._贡璐Yi檻_⮵uᐝ㘗聠[f\u0015힢Hꔮ}጑;誏yf0\"\u20cc?(=q斠➽5ꎾ鞘kⲃ",
-                                                                                                                                                                       -2.9234211354411E-19,
-                                                                                                                                                                       false,
-                                                                                                                                                                       true,
-                                                                                                                                                                       {
-                                                                                                                                                                        "\u0011⟴GH_;#怵:\u001c\u0002n1U\\p/왔(┫]hꐚ7\r0䵷첗岷O௷?㝎[殇|J=?韷pᶟ儜犆?5კ1kꍖiH竧뛈ପdmk游y(콪팱꾍k慧 y辣": [
-                                                                                                                                                                         false,
-                                                                                                                                                                         "O\"끍p覈ykv磂㢠㝵~뀬튍lC&4솎䇃:Mj",
-                                                                                                                                                                         -7.009964654003924E-20,
-                                                                                                                                                                         false,
-                                                                                                                                                                         -49306078522414046,
-                                                                                                                                                                         null,
-                                                                                                                                                                         null,
-                                                                                                                                                                         2160432477732354319,
-                                                                                                                                                                         true,
-                                                                                                                                                                         "4횡h+!踹ꐬP鮄{0&뱥M?샍鞅n㮞ᨹ?쒆毪l'箅^ꚥ頛`e㻨52柳⮙嫪࡟딯a.~䵮1f吘N&zȭL榓ۃ鳠5d㟆M@㣥ӋA΍q0縶$",
-                                                                                                                                                                         -3.848996532974368E16,
-                                                                                                                                                                         true,
-                                                                                                                                                                         null,
-                                                                                                                                                                         -3.5240055580952525E18,
-                                                                                                                                                                         {
-                                                                                                                                                                          " vﭷၵ#ce乃5僞?Z D`묨粇ᐔ绠vWL譢u뽀\\J|tⓙt№\"ꨋnT凮ᒩ蝂篝b騩:䢭Hbv읻峨z㹚T趗햆귣학津XiＹ@ᖥK": true,
-                                                                                                                                                                          "!F 醌y䉸W2ꇬ\u0006/䒏7~%9擛햀徉9⛰+?㌘;ꠓX䇻Dfi뼧쒒\u0012F謞՝絺+臕kऍLSQ쌁X쎬幦HZ98蒊枳": "澤令#\u001d抍⛳@N搕퀂[5,✄ꘇ~䘷?\u0011Xꈺ[硸⠘⛯X醪聡x\u0007쌇MiX/|ﾐ뚁K8䁡W)銀q僞綂蔕E",
-                                                                                                                                                                          "6␲䣖R৞@ငg?<\/೴x陙Xꈺ崸⠅ᇾ\\0X,H쟴셭A稂ힿゝF\\쑞\u0012懦(Aᯕ灭~\u0001껮X?逊": 5.7566819207732864E17,
-                                                                                                                                                                          "[c?椓": false,
-                                                                                                                                                                          "k䒇": 2583824107104166717,
-                                                                                                                                                                          "꙯N훙㏅ﮒ燣㨊瞯咽jMxby뻭뵫װ[\"1畈?ৱL": "띣ᔂ魠羓犴ꚃ+|rY",
-                                                                                                                                                                          "녺Z?䬝鉉:?ⳙ瘏Cኯ.Vs[釿䨉쐧\\\\*쵢猒$\\y溔^,㑳": {"藶꺟": [{
-                                                                                                                                                                           "\"d훣N2zq]?'檿죸忷篇ﮟ擤m'9!죶≓p뭻\\ᇷ\f퇶_䰸h๐Q嵃訾㘑従ꯦ䞶jL틊r澵Omᾫ!H䱤팼/;|᭺I7슎YhuXi⚼": -1.352716906472438E-19,
-                                                                                                                                                                           "M⽇倻5J䂫औ᝔楸#J[Fﹱ쫮W誻bWz?}1\"9硪뻶fe": "盬:Ѹ砿획땣T凊(m灦呜ﻝR㿎艴䂵h",
-                                                                                                                                                                           "R띾k힪CH钙_i苮ⰵoᾨ紑퉎7h؉\"柀蝽z0့\"<?嘭$蜝?礲7岇槀묡?V钿T⣜v+솒灚ԛ2米mH?>薙婏聿3aFÆÝ": "2,ꓴg?_섦_>Y쪥션钺;=趘F~?D㨫\bX?㹤+>/믟kᠪ멅쬂Uzỵ]$珧`m雁瑊ඖ鯬cꙉ梢f묛bB",
-                                                                                                                                                                           "♽n$YjKiXX*GO贩鏃豮祴遞K醞眡}ꗨv嵎꼷0୸+M菋eH徸J꣆:⼐悥B켽迚㯃b諂\u000bjꠜ碱逮m8": [
-                                                                                                                                                                            "푷᣺ﻯd8ﱖ嬇ភH鹎⡱᱅0g:果6$GQ췎{vᷧYy-脕x偹砡館⮸C蓼ꏚ=軄H犠G谖ES詤Z蠂3l봟hￒ7䦹1GPQG癸숟~[#駥8zQ뛣J소obg,",
-                                                                                                                                                                            null,
-                                                                                                                                                                            1513751096373485652,
-                                                                                                                                                                            null,
-                                                                                                                                                                            -6.851466660824754E-19,
-                                                                                                                                                                            {"䩂-⴮2ٰK솖풄꾚ႻP앳1H鷛wmR䗂皎칄?醜<\/&ࠧ㬍X濬䵈K`vJ륒Q/IC묛!;$vϑ": {
-                                                                                                                                                                             "@-ꚗxྐྵ@m瘬\u0010U絨ﮌ驐\\켑寛넆T=tQ㭤L연@脸삯e-:⩼u㎳VQ㋱襗ຓ<Ⅶ䌸cML3+\u001e_C)r\\9+Jn\\Pﺔ8蠱檾萅Pq鐳话T䄐I": -1.80683891195530061E18,
-                                                                                                                                                                             "ᷭዻU~ཷsgSJ`᪅'%㖔n5픆桪砳峣3獮枾䌷⊰呀": {
-                                                                                                                                                                              "Ş੉䓰邟自~X耤pl7间懑徛s첦5ਕXexh⬖鎥᐀nNr(J컗｜ૃF\"Q겮葲놔엞^겄+㈆话〾희紐G'E?飕1f❼텬悚泬먐U睬훶Qs": false,
-                                                                                                                                                                              "(\u20dag8큽튣>^Y{뤋.袊䂓;_g]S\u202a꽬L;^'#땏bႌ?C緡<䝲䲝断ꏏ6\u001asD7IK5Wxo8\u0006p弊⼂ꯍ扵\u0003`뵂픋%ꄰ⫙됶l囏尛+䗅E쟇\\": [
-                                                                                                                                                                               true,
-                                                                                                                                                                               {
-                                                                                                                                                                                "\n鱿aK㝡␒㼙2촹f;`쾏qIࡔG}㝷䐍瓰w늮*粅9뒪ㄊCj倡翑閳R渚MiUO~仨䜶RꙀA僈㉋⦋n{㖥0딿벑逦⥻0h薓쯴Ꝼ": [
-                                                                                                                                                                                 5188716534221998369,
-                                                                                                                                                                                 2579413015347802508,
-                                                                                                                                                                                 9.010794400256652E-21,
-                                                                                                                                                                                 -6.5327297761238093E17,
-                                                                                                                                                                                 1.11635352494065523E18,
-                                                                                                                                                                                 -6656281618760253655,
-                                                                                                                                                                                 {
-                                                                                                                                                                                  "": ")?",
-                                                                                                                                                                                  "TWKLꑙ裑꺔UE俸塑炌Ũ᜕-o\"徚#": {"M/癟6!oI51ni퐚=댡>xꍨ\u0004 ?": {
-                                                                                                                                                                                   "皭": {"⢫䋖>u%w잼<䕏꘍P䋵$魋拝U䮎緧皇Y훂&|羋ꋕ잿cJ䨈跓齳5\u001a삱籷I꿾뤔S8㌷繖_Yឯ䲱B턼O歵F\\l醴o_欬6籏=D": [
-                                                                                                                                                                                    false,
-                                                                                                                                                                                    true,
-                                                                                                                                                                                    {"Mt|ꏞD|F궣MQ뵕T,띺k+?㍵i": [
-                                                                                                                                                                                     7828094884540988137,
-                                                                                                                                                                                     false,
-                                                                                                                                                                                     {
-                                                                                                                                                                                      "!༦鯠,&aﳑ>[euJꏽ綷搐B.h": -7648546591767075632,
-                                                                                                                                                                                      "-n켧嘰{7挐毄Y,>❏螵煫乌pv醑Q嶚!|⌝責0왾덢ꏅ蛨S\\)竰'舓Q}A釡5#v": 3344849660672723988,
-                                                                                                                                                                                      "8閪麁V=鈢1녈幬6棉⪮둌\u207d᚛驉ꛃ'r䆉惏ै|bἧﺢᒙ<=穊强s혧eꮿ慩⌡ \\槳W븧J檀C,ᘉ의0俯퀉M;筷ࣴ瓿{늊埂鄧_4揸Nn阼Jੵ˥(社": true,
-                                                                                                                                                                                      "o뼀vw)4A뢵(a䵢)p姃뛸\u000fK#KiQp\u0005ꅍ芅쏅": null,
-                                                                                                                                                                                      "砥$ꥸ┇耽u斮Gc{z빔깎밇\\숰\u001e괷各㶇쵿_ᴄ+h穢p촀Ნ䃬z䝁酳ӂ31xꔄ1_砚W렘G#2葊P ": [
-                                                                                                                                                                                       -3709692921720865059,
-                                                                                                                                                                                       null,
-                                                                                                                                                                                       [
-                                                                                                                                                                                        6669892810652602379,
-                                                                                                                                                                                        -135535375466621127,
-                                                                                                                                                                                        "뎴iO}Z? 馢녱稹ᄾ䐩rSt帤넆&7i騏멗畖9誧鄜'w{Ͻ^2窭외b㑎粖i矪ꦨ탪跣)KEㆹ\u0015V8[W?⽉>'kc$䨘ᮛ뉻٬M5",
-                                                                                                                                                                                        1.10439588726055846E18,
-                                                                                                                                                                                        false,
-                                                                                                                                                                                        -4349729830749729097,
-                                                                                                                                                                                        null,
-                                                                                                                                                                                        [
-                                                                                                                                                                                         false,
-                                                                                                                                                                                         "_蠢㠝^䟪/D녒㡋ỎC䒈판\u0006એq@O펢%;鹐쏌o戥~A[ꡉ濽ỳ&虃᩾荣唙藍茨Ig楡꒻M窓冉?",
-                                                                                                                                                                                         true,
-                                                                                                                                                                                         2.17220752996421728E17,
-                                                                                                                                                                                         -5079714907315156164,
-                                                                                                                                                                                         -9.960375974658589E-20,
-                                                                                                                                                                                         "ᾎ戞༒",
-                                                                                                                                                                                         true,
-                                                                                                                                                                                         false,
-                                                                                                                                                                                         [[
-                                                                                                                                                                                          "ⶉᖌX⧕홇)g엃⹪x뚐癟\u0002",
-                                                                                                                                                                                          -5185853871623955469,
-                                                                                                                                                                                          {
-                                                                                                                                                                                           "L㜤9ợㇶK鐰⋓V뽋˖!斫as|9＂፬䆪?7胜&n薑~": -2.11545634977136992E17,
-                                                                                                                                                                                           "O8뀩D}캖q萂6༣㏗䈓煮吽ਆᎼDᣘ폛;": false,
-                                                                                                                                                                                           "YTᡅ^L㗎cbY$pᣞ縿#fh!ꘂb삵玊颟샞ဢ$䁗鼒몁~rkH^:닮먖츸륈⪺쒉砉?㙓扫㆕꣒`R䢱B酂?C뇞<5Iޚ讳騕S瞦z": null,
-                                                                                                                                                                                           "\\RB?`mG댵鉡幐物䵎有5*e骄T㌓ᛪ琾駒Ku\u001a[柆jUq8⋈5鿋츿myﻗ?雍ux঴?": 5828963951918205428,
-                                                                                                                                                                                           "n0晅:黯 xu씪^퓞cB㎊ᬍ⺘٤փ~B岚3㥕擄vᲂ~F?C䶖@$m~忔S왖㲚?챴⊟W#벌{'㰝I䝠縁s樘\\X뢻9핡I6菍ㄛ8쯶]wॽ0L\"q": null,
-                                                                                                                                                                                           "x增줖j⦦t䏢᎙㛿Yf鼘~꫓恄4惊\u209c": "oOhbᤃ᛽z&Bi犑\\3B㩬劇䄑oŁ쨅孥멁ຖacA㖫借㞝vg싰샂㐜#譞⢤@k]鋰嘘䜾L熶塥_<\/⍾屈ﮊ_mY菹t뙺}Ox=w鮮4S1ꐩמּ'巑",
-                                                                                                                                                                                           "㗓蟵ꂾe蠅匳(JP䗏෸\u0089耀왲": [{
-                                                                                                                                                                                            "ᤃ㵥韎뤽\r?挥O쯡⇔㞚3伖\u0005P⋪\"D궣QLn(⚘罩䩢Ŏv䤘尗뼤됛O淽鋋闚r崩a{4箙{煷m6〈": {
-                                                                                                                                                                                             "l곺1L": {
-                                                                                                                                                                                              "T'ਤ?砅|੬Km]䄩\"(࿶<\/6U爢䫈倔郴l2㴱^줣k'L浖L鰄Rp今鎗⒗C얨M훁㡧ΘX粜뫈N꤇輊㌻켑#㮮샶-䍗룲蠝癜㱐V>=\\I尬癤t=": 7648082845323511446,
-                                                                                                                                                                                              "鋞EP:<\/_`ၧe混ㇹBd⯢㮂驋\\q碽饩跓྿ᴜ+j箿렏㗑yK毢宸p謹h䦹乕U媣\\炤": [[
-                                                                                                                                                                                               "3",
-                                                                                                                                                                                               [
-                                                                                                                                                                                                true,
-                                                                                                                                                                                                3.4058271399411134E-20,
-                                                                                                                                                                                                true,
-                                                                                                                                                                                                "揀+憱f逮@먻BpW曉\u001a㣐⎊$n劈D枤㡞좾\u001aᛁ苔౩闝1B䷒Ṋ݋➐ꀞꐃ磍$t੤_:蘺⮼(#N",
-                                                                                                                                                                                                697483894874368636,
-                                                                                                                                                                                                [
-                                                                                                                                                                                                 "vᘯ锴)0訶}䳅⩚0O壱韈ߜ\u0018*U鍾䏖=䧉뽑单휻ID쿇嘗?ꌸῬ07",
-                                                                                                                                                                                                 -5.4858784319382006E18,
-                                                                                                                                                                                                 7.5467775182251151E18,
-                                                                                                                                                                                                 -8911128589670029195,
-                                                                                                                                                                                                 -7531052386005780140,
-                                                                                                                                                                                                 null,
-                                                                                                                                                                                                 [
-                                                                                                                                                                                                  null,
-                                                                                                                                                                                                  true,
-                                                                                                                                                                                                  [[{
-                                                                                                                                                                                                   "1欯twG<u䝮␽ꇣ_ჟﱴଶ-쪋\"?홺k:莝Ꜫ*⺵꽹댅釔좵}P?=9렿46b\u001c\\S?(筈僦⇶爷谰1ྷa": true,
-                                                                                                                                                                                                   "TҫJYxڪ\\鰔℮혡)m_WVi眪1[71><\/Q:0怯押殃탷聫사<ỗꕧ蚨䡁nDꌕ\u001c녬~蓩<N蹑\"{䫥lKc혁뫖앺:vⵑ": "g槵?",
-                                                                                                                                                                                                   "aꨩ뻃싥렌1`롗}Yg>鲃g儊>ꏡl㻿/⑷*챳6㻜W毤緛ﹺᨪ4\u0013뺚J髬e3쳸䘦伧?恪&{L掾p+꬜M䏊d娘6": {
-                                                                                                                                                                                                    "2p첼양棜h䜢﮶aQ*c扦v︥뮓kC寵횂S銩&ǝ{O*य़iH`U큅ࡓr䩕5ꄸ?`\\᧫?ᮼ?t〟崾훈k薐ì/ｉy꤃뵰z1<\/AQ#뿩8jJ1z@u䕥": 1.82135747285215155E18,
-                                                                                                                                                                                                    "ZdN &=d년ᅆ'쑏ⅉ:烋5&៏ᄂ汎来L㯄固{钧u\\㊏튚e摑&t嗄ꖄUb❌?m䴘熚9EW": [{
-                                                                                                                                                                                                     "ଛ{i*a(": -8.0314147546006822E17,
-                                                                                                                                                                                                     "⫾ꃆY\u000e+W`௸ \"M뒶+\\뷐lKE}(NT킶Yj選篒쁶'jNQ硾(똡\\\"逌ⴍy? IRꜘ὞鄬﨧:M\\f⠋Cꚜ쫊ᚴNV^D䕗ㅖἔIao꿬C⍏8": [
-                                                                                                                                                                                                      287156137829026547,
-                                                                                                                                                                                                      {
-                                                                                                                                                                                                       "H丞N逕<rO䎗:텕<\/䶩샌Sd%^ᵯ눐엑者g䖩똭蕮1U驣?Pⰰ\u001fp(W]67\u0015﫣6굺OR羸#촐F蒈;嘙i✵@_撶y㤏⤍(:᧗뼢༌朆@⏰㤨ꭲ?-n>⯲": {"": {
-                                                                                                                                                                                                        "7-;枮阕梒9ᑄZ": [[[[
-                                                                                                                                                                                                         null,
-                                                                                                                                                                                                         {
-                                                                                                                                                                                                          "": [[[[
-                                                                                                                                                                                                           -7.365909561486078E-19,
-                                                                                                                                                                                                           2948694324944243408,
-                                                                                                                                                                                                           null,
-                                                                                                                                                                                                           [
-                                                                                                                                                                                                            true,
-                                                                                                                                                                                                            "荒\"并孷䂡쵼9o䀘F\u0002龬7⮹Wz%厖/*? a*R枈㌦됾g뒠䤈q딄㺿$쮸tᶎ릑弣^鏎<\/Y鷇驜L鿽<\/춋9Mᲆឨ^<\/庲3'l낢",
-                                                                                                                                                                                                            "c鮦\u001b두\\~?眾ಢu݆綑෪蘛轋◜gȃ<\/ⴃcpkDt誩܅\"Y",
-                                                                                                                                                                                                            [[
-                                                                                                                                                                                                             null,
-                                                                                                                                                                                                             null,
-                                                                                                                                                                                                             [
-                                                                                                                                                                                                              3113744396744005402,
-                                                                                                                                                                                                              true,
-                                                                                                                                                                                                              "v(y",
-                                                                                                                                                                                                              {
-                                                                                                                                                                                                               "AQ幆h쾜O+꺷铀ꛉ練A蚗⼺螔j㌍3꽂楎䥯뎸먩?": null,
-                                                                                                                                                                                                               "蠗渗iz鱖w]擪E": 1.2927828494783804E-17,
-                                                                                                                                                                                                               "튷|䀭n*曎b✿~杤U]Gz鄭kW|㴚#㟗ഠ8u擨": [[
-                                                                                                                                                                                                                true,
-                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                {"⾪壯톽g7?㥜ώQꑐ㦀恃㧽伓\\*᧰閖樧뢇赸N휶䎈pI氇镊maᬠ탷#X?A+kНM ༑᩟؝?5꧎鰜ṚY즫궔 =ঈ;ﳈ?*s|켦蜌wM笙莔": [
-                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                 -3808207793125626469,
-                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                  -469910450345251234,
-                                                                                                                                                                                                                  7852761921290328872,
-                                                                                                                                                                                                                  -2.7979740127017492E18,
-                                                                                                                                                                                                                  1.4458504352519893E-20,
-                                                                                                                                                                                                                  true,
-                                                                                                                                                                                                                  "㽙깹?먏䆢:䴎ۻg殠JBTU⇞}ꄹꗣi#I뵣鉍r혯~脀쏃#釯:场:䔁>䰮o'㼽HZ擓௧nd",
-                                                                                                                                                                                                                  [
-                                                                                                                                                                                                                   974441101787238751,
-                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                   -2.1647718292441327E-19,
-                                                                                                                                                                                                                   1.03602824249831488E18,
-                                                                                                                                                                                                                   [
-                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                    1.0311977941822604E-17,
-                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                    true,
-                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                     "": -3.7019778830816707E18,
-                                                                                                                                                                                                                     "E峾恆茍6xLIm縂0n2视֯J-ᤜz+ᨣ跐mYD豍繹⹺䊓몓ﴀE(@詮(!Y膽#᎙2䟓섣A䈀㟎,囪QbK插wcG湎ꤧtG엝x⥏俎j'A一ᯥ뛙6ㅑ鬀": 8999803005418087004,
-                                                                                                                                                                                                                     "よ殳\\zD⧅%Y泥簳Uꈩ*wRL{3#3FYHା[d岀䉯T稉駅䞘礄P:闈W怏ElB㤍喬赔bG䠼U଄Nw鰯闀楈ePsDꥷ꭬⊊": [
-                                                                                                                                                                                                                      6.77723657904486E-20,
-                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                       "ཚ_뷎꾑蹝q'㾱ꂓ钚蘞慵렜떆`ⴹ⎼櫯]J?[t9Ⓢ !컶躔I᮸uz>3a㠕i,錃L$氰텰@7녫W㸮?羧W뇧ꃞ,N鋮숪2ɼ콏┍䁲6",
-                                                                                                                                                                                                                       "&y?뢶=킕올Za惻HZk>c\u20b58i?ꦶcfBv잉ET9j䡡",
-                                                                                                                                                                                                                       "im珊Ճb칧<D-諂*u2ꡜ췛~䬢(텸ﵦ>校\\뼾쯀",
-                                                                                                                                                                                                                       9.555715121193197E-20,
-                                                                                                                                                                                                                       true,
-                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                        "<㫚v6腓㨭e1㕔&&V∌ᗈT奄5Lጥ>탤?튣瑦㳆ꉰ!(ᙪ㿬擇_n쌯IMΉ㕨␰櫈ᱷ5풔蟹&L.첽e鰷쯃劼﫭b#ﭶ퓀7뷄Wr㢈๧Tʴશ㶑澕鍍%": -1810142373373748101,
-                                                                                                                                                                                                                        "fg晌o?߲ꗄ;>C>?=鑰監侯Kt굅": true,
-                                                                                                                                                                                                                        "䫡蓺ꑷ]C蒹㦘\"1ః@呫\u0014NL䏾eg呮፳,r$裢k>/\\<z": [[
-                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                         "C䡏>?ㄤᇰﻛ쉕1஥'Ċ\" \\_?쨔\"ʾr: 9S䘏禺ᪧꄂ㲄",
-                                                                                                                                                                                                                         [[{
-                                                                                                                                                                                                                          "*硙^+E쌺I1䀖ju?:⦈Ꞓl๴竣迃xKC/饉:\fl\"XTFﾨ蟭,芢<\/骡軺띜hꏘ\u001f銿<棔햳▨(궆*=乥b8\\媦䷀뫝}닶ꇭ(Kej䤑M": [{
-                                                                                                                                                                                                                           "1Ꮼ?>옿I╅C<ގ?ꊌ冉SV5A㢊㶆z-๎玶绢2F뵨@㉌뀌o嶔f9-庒茪珓뷳4": null,
-                                                                                                                                                                                                                           ";lᰳ": "CbB+肻a䄷苝*/볳+/4fq=㰁h6瘉샴4铢Y骐.⌖@哼猎㦞+'gꋸ㒕ߤ㞑(䶒跲ti⑴a硂#No볔",
-                                                                                                                                                                                                                           "t?/jE幸YHT셵⩎K!Eq糦ꗣv刴w\"l$ο:=6:移": {
-                                                                                                                                                                                                                            "z]鑪醊嫗J-Xm銌翁絨c里됏炙Ep㣋鏣똼嚌䀓GP﹖cmf4鹭T䅿꣭姧␸wy6ꦶ;S&(}ᎧKxᾂQ|t뻳k\"d6\"|Ml췆hwLt꼼4$&8Պ褵婶鯀9": {"嵃닢ᒯ'd᧫䳳#NXe3-붋鸿ଢ떓%dK\u0013䲎ꖍYV.裸R⍉rR3蟛\\:젯:南ĺLʆ넕>|텩鴷矔ꋅⒹ{t孶㓑4_": [
-                                                                                                                                                                                                                             true,
-                                                                                                                                                                                                                             null,
-                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                              false,
-                                                                                                                                                                                                                              "l怨콈lᏒ",
-                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                               "0w䲏嬧-:`䉅쉇漧\\܂yㄨb%㽄j7ᦶ涶<": 3.7899452730383747E-19,
-                                                                                                                                                                                                                               "ꯛTẀq纤q嶏V⿣?\"g}ი艹(쥯B T騠I=仵및X": {"KX6颠+&ᅃ^f畒y[": {
-                                                                                                                                                                                                                                "H?뱜^?꤂-⦲1a㋞&ꍃ精Ii᤾챪咽쬘唂쫷<땡劈훫놡o㥂\\ KⴙD秼F氮[{'좴:례晰Iq+I쭥_T綺砸GO煝䟪ᚪ`↹l羉q쐼D꽁ᜅ훦: vUV": true,
-                                                                                                                                                                                                                                "u^yﳍ0㱓#[y뜌앸ꊬL㷩?蕶蘾⻍KӼ": -7931695755102841701,
-                                                                                                                                                                                                                                "䤬轉車>\u001c鴵惋\"$쯃྆⇻n뽀G氠S坪]ಲꨍ捇Qxኻ椕駔\\9ࣼ﫻읜磡煮뺪ᶚ볝l㕆t+sζ": [[[
-                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                  3363739578828074923,
-                                                                                                                                                                                                                                  true,
-                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                   "\"鸣詩 볰㑵gL㯦῅춝旫}ED辗ﮈI쀤-ꧤ|㠦Z\"娑ᕸ4爏騍㣐\"]쳝Af]茛⬻싦o蚁k䢯䩐菽3廇喑ޅ": 4.5017999150704666E17,
-                                                                                                                                                                                                                                   "TYႇ7ʠ值4챳唤~Zo&ݛ": false,
-                                                                                                                                                                                                                                   "`塄J袛㭆끺㳀N㺣`꽐嶥KﯝSVᶔ∲퀠獾N딂X\"ᤏhNﬨvI": {"\u20bb㭘I䖵䰼?sw䂷쇪](泒f\"~;꼪Fԝsᝦ": {"p,'ꉂ軿=A蚶?bƉ㏵䅰諬'LYKL6B깯⋩겦뎙(ᜭ\u0006噣d꾆㗼Z;䄝䚔cd<情@䞂3苼㸲U{)<6&ꩻ钛\u001au〷N숨囖愙j=BXW욕^x芜堏Ῑ爂뛷꒻t✘Q\b": [[
-                                                                                                                                                                                                                                    "籛&ଃ䩹.ꃩ㦔\\C颫#暪&!勹ꇶ놽攺J堬镙~軌C'꾖䣹㮅岃ᙴ鵣",
-                                                                                                                                                                                                                                    4.317829988264744E15,
-                                                                                                                                                                                                                                    6.013585322002147E-20,
-                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                    true,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    -3.084633632357326E-20,
-                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                    null,
-                                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                                     "\"짫愔昻  X\"藣j\"\"먁ཅѻ㘤㬯0晲DU꟒㸃d벀윒l䦾c੻*3": null,
-                                                                                                                                                                                                                                     "谈Wm陧阦咟ฯ歖擓N喴㋐銭rCCnVࢥ^♼Ⅾ젲씗刊S༝+_t赔\\b䚍뉨ꬫ6펛cL䊘᜼<\/澤pF懽&H": [
-                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                       "W\"HDUuΌ퀟M'P4࿰H똆ⰱﮯ<\/凐蘲\"C鴫ﭒж}ꭩ쥾t5yd诪ﮡ퍉ⴰ@?氐醳rj4I6Qt": 6.9090159359219891E17,
-                                                                                                                                                                                                                                       "絛ﳛ⺂": {"諰P㗮聦`ZQ?ꫦh*റcb⧱}埌茥h{棩렛툽o3钛5鮁l7Q榛6_g)ὄ\u0013kj뤬^爖eO4Ⱈ槞鉨ͺ订%qX0T썗嫷$?\\\"봅늆'%": [
-                                                                                                                                                                                                                                        -2.348150870600346E-19,
-                                                                                                                                                                                                                                        [[
-                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                         -6619392047819511778,
-                                                                                                                                                                                                                                         false,
-                                                                                                                                                                                                                                         [[
-                                                                                                                                                                                                                                          -1.2929189982356161E-20,
-                                                                                                                                                                                                                                          1.7417192219309838E-19,
-                                                                                                                                                                                                                                          {"?嵲2࿐2\u0001啑㷳c縯": [
-                                                                                                                                                                                                                                           null,
-                                                                                                                                                                                                                                           [
-                                                                                                                                                                                                                                            false,
-                                                                                                                                                                                                                                            true,
-                                                                                                                                                                                                                                            2578060295690793218,
-                                                                                                                                                                                                                                            {
-                                                                                                                                                                                                                                             "?\"殃呎#㑑F": true,
-                                                                                                                                                                                                                                             "}F炊_殛oU헢兔Ꝉ,赭9703.B数gTz3⏬": {
-                                                                                                                                                                                                                                              "5&t3,햓Mݸᵣ㴵;꣫䩍↳#@뫷䠅+W-ࣇzᓃ鿕ಔ梭?T䮑ꥬ旴]u뫵막bB讍:왳둛lEh=숾鱠p咐$짏#?g⹷ᗊv㷵.斈u頻\u0018-G.": "뽙m-ouࣤ஫牷\"`Ksꕞ筼3HlȨvC堈\"I]㖡玎r먞#'W賜鴇k'c룼髋䆿飉㗆xg巤9;芔cጐ/ax䊨♢큓r吓㸫೼䢗da᩾\"]屣`",
-                                                                                                                                                                                                                                              ":M딪<䢥喠\u0013㖅x9蕐㑂XO]ｆ*Q呰瞊吭VP@9,㨣 D\\穎vˤƩs㜂-曱唅L걬/롬j㈹EB8g<\/섩o渀\"u0y&룣": ">氍緩L/䕑돯Ꟙ蕞^aB뒣+0jK⪄瑨痜LXK^힦1qK{淚t츔X:Vm{2r獁B뾄H첚7氥?쉟䨗ꠂv팳圎踁齀\\",
-                                                                                                                                                                                                                                              "D彤5㢷Gꪻ[lㄆ@὜⓰絳[ଃ獽쮹☒[*0ꑚ㜳": 9022717159376231865,
-                                                                                                                                                                                                                                              "ҖaV銣tW+$魿\u20c3亜~뫡ᙰ禿쨽㏡fṼzE/h": "5臐㋇Ჯ쮺? 昨탰Wﾑ밎#'\"崲钅U?幫뺀⍾@4kh>騧\\0ҾEV=爐͌U捀%ꉼ 㮋<{j]{R>:gԩL\u001c瀈锌ﯲﳡꚒ'⫿E4暍㌗뵉X\"H᝜",
-                                                                                                                                                                                                                                              "ᱚגּ;s醒}犍SἿ㦣&{T$jkB\\\tḮ앾䤹o<避(tW": "vb⯽䴪䮢@|)",
-                                                                                                                                                                                                                                              "⥒퐁껉%惀뗌+녣迺顀q條g⚯i⤭룐M琹j̈́⽜A": -8385214638503106917,
-                                                                                                                                                                                                                                              "逨ꊶZ<\/W⫟솪㎮ᘇb?ꠔi\"H㧺x෷韒Xꫨฟ|]窽\u001a熑}Agn?Mᶖa<rఄ4Ů䢤슲Axģe곖㴤x竾郍B謉鸵k薽M)\"芣眜`菉ꉛ䴺": "鹏^ె캫?3耲]|Ü1䡒㝮]8e?䶍^",
-                                                                                                                                                                                                                                              "뿸樅#P㡊1M룮Uꪭ绢ꑮZ9꽸": {"\nJ^є|3袄ㅐ7⨆銦y睝⋷仴ct?[,<\/ㅬ`?갔髞%揁A೚C": {
-                                                                                                                                                                                                                                               " 䇞3갫䅪": [{
-                                                                                                                                                                                                                                                "0|⩁㑂砕ㅻ": null,
-                                                                                                                                                                                                                                                "D箳᠉`|=⼭)\"*࣊㦏LjO誋": "",
-                                                                                                                                                                                                                                                "ࠚDZmꗥ}ᷴ╈r7헴ȥ4Kp5a)o}鎘门L搰䆓'✎k俎c#T68ӏ⩶6L鎴<r൦$黊BQY㼳\\跿F慮⡨拵贀!甶V喅/": null,
-                                                                                                                                                                                                                                                "ⵣq⳹ﻨLk]晩1*y\\$%}䖶P煑㇆䈦E嫁櫕Y࣓嫨䓏OL낮梚㸇洛洚BYtgl∛S☕䉓宑⋢粚ꔯ꠼붠": ")ꬑ윤`\"Ⱓ<\/婽*Y䔸ᓰ_ﳍt슲坩隥&S糧䛮闵诌豐sh쯽邴*섴؏͎=㯨\"RVힳ,^t\"ac?䤒ꉀxHa=Uꛕ㐙TkF껾",
-                                                                                                                                                                                                                                                "弾cUAF?暤c덽.欀nK앭]r傊䀓ﯳ馽垃[䥛oI0N砊鈥헅Co쟋钄ㅷ㊌뷚7": [
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 "૓鏨?^䆏{\u0006`X䧵儱&롡尙砡\u0006뻝쑬sj▻XfᬶgcㄢV >9韲4$3Ỵ^=쏍煤ፐ돷2䣃%鷠/eQ9頸쥎",
-                                                                                                                                                                                                                                                 2398360204813891033,
-                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                 3.2658897259932633E-19,
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 "?ꚃ8Nn㞷幵d䲳䱲뀙ꪛQ瑓鎴]䩋-鰾捡䳡??掊",
-                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                 -1309779089385483661,
-                                                                                                                                                                                                                                                 "ᦲxu_/yecR.6芏.ᜇ過 ~",
-                                                                                                                                                                                                                                                 -5658779764160586501,
-                                                                                                                                                                                                                                                 "쒌:曠=l썜䢜wk#s蕚\"互㮉m䉤~0듐䋙#G;h숄옥顇෤勹(C7㢅雚㐯L⠅VV簅<",
-                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                 -4.664877097240962E18,
-                                                                                                                                                                                                                                                 -4.1931322262828017E18,
-                                                                                                                                                                                                                                                 {
-                                                                                                                                                                                                                                                  ",": {
-                                                                                                                                                                                                                                                   "v㮟麑䄠뤵g{M띮.\u001bzt뢜뵡0Ǥ龍떟Ᾰ怷ϓRT@Lꀌ樂U㏠⾕e扉|bJg(뵒㠶唺~ꂿ(땉x⻫싉쁊;%0鎻V(o\f,N鏊%nk郼螺": -1.73631993428376141E18,
-                                                                                                                                                                                                                                                   "쟧摑繮Q@Rᕾ㭚㾣4隅待㓎3蒟": [
-                                                                                                                                                                                                                                                    4971487283312058201,
-                                                                                                                                                                                                                                                    8973067552274458613,
-                                                                                                                                                                                                                                                    {
-                                                                                                                                                                                                                                                     "`a揙ᣗ\u0015i<S幼訃锭B0&槩✨[Wp皩[g≊k葾x2ᡆ橲䲢W": true,
-                                                                                                                                                                                                                                                     "kH皈Sꁱq傑u?솹풑~o^F=劣N*reJ沤wW苯7p㼹䎐a=ꮧL㷩냴nWꌑ㞱uu谁lVN珿᤻(e豶5#L쪉ᅄ઄\u0015숟봊P瀚X蓎": false,
-                                                                                                                                                                                                                                                     "䫯דּ〖Sc䛭점L뵾pCꙞ\"엇즓_ﰛ톣ꫀ먩㺣㮠⭴!\\W┏t䖰軅y\u0014~ᇰ렢E7*俜䥪W䀩䷐h봆vjஉ묣༏G39.뼳輼:㮿ᐦA饕TUL}~": [
-                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                      8.8648298810470003E17,
-                                                                                                                                                                                                                                                      5.735561205600924E-20,
-                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                      -102555823658171644,
-                                                                                                                                                                                                                                                      1.2674932032973067E-19,
-                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                       "D胣O㯨\u0017Ku눓㒏텁nᨊ!Ꚇ廫_>Bo¸": 4.3236479112537999E18,
-                                                                                                                                                                                                                                                       "HW&퉡ぁ圍<W)6悰ꠑHEp14xy峑ft\u0005s亘V튉䢮ꦈX嵐꬝?lI_덝춇-6Ss噺Nk-ﮥ큃܁郪*PR(S6╋@仙V懸뺵ﯜV粹": "9䗌斀4㐈^Qs隄硏j\u0003",
-                                                                                                                                                                                                                                                       "Vk鶅C泹筁HX훉朗*r\\z顊誌儖4?n7᏾6몋䎡ﳈ],H頢p蚐㑄P4满E䏩V䬕ญL廂쒬쑨ꆷh迡ꍰ譖墎 ]鹿ฌ7ﶽ冭༽<ꈓS\\l䋮?_ﾕ檒?": -8598528325153980065,
-                                                                                                                                                                                                                                                       "t=q퍣疻тZ\\錅J.镎|nfḷ鴒1厰L灯纜E]୦⥪]Ꮾ'羝p/咩0닳ﳁqﳖཽk ?X1Ft%ś뭢v鋋⺃爵⒗": [[
-                                                                                                                                                                                                                                                        5.0824756359232045E-19,
-                                                                                                                                                                                                                                                        [
-                                                                                                                                                                                                                                                         7.268480839079619E-19,
-                                                                                                                                                                                                                                                         {"탿^굞⧕iј덊ꀛw껩6ꟳXs酚\\>Y?瑡Qy훍q!帰敏s舠㫸zꚗaS歲v`G株巷Jp6킼 (귶鍔⾏⡈>M汐㞍ቴ꙲dv@i㳓ᇆ?黍": [
-                                                                                                                                                                                                                                                          null,
-                                                                                                                                                                                                                                                          4997607199327183467,
-                                                                                                                                                                                                                                                          "E㻎蠫ᐾ高䙟蘬洼旾﫠텛㇛?'M$㣒蔸=A_亀绉앭rN帮",
-                                                                                                                                                                                                                                                          null,
-                                                                                                                                                                                                                                                          [{
-                                                                                                                                                                                                                                                           "Eᑞ)8<Z㡿W镀䛒C생V?0ꯦ+tL)`齳AjB姀XೳD빠㻲ƙgn9⑰ྍ῜&\"㚹>餧A5u&㗾q?": [
-                                                                                                                                                                                                                                                            -1.969987519306507E-19,
-                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                            [
-                                                                                                                                                                                                                                                             3.42437673373841E-20,
-                                                                                                                                                                                                                                                             true,
-                                                                                                                                                                                                                                                             "e걷M墁\"割P␛퍧厀R䱜3ﻴO퓫r﹉⹊",
-                                                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                                                              -8164221302779285367,
-                                                                                                                                                                                                                                                              [
-                                                                                                                                                                                                                                                               true,
-                                                                                                                                                                                                                                                               null,
-                                                                                                                                                                                                                                                               "爘y^-?蘞Ⲽꪓa␅ꍨ}I",
-                                                                                                                                                                                                                                                               1.4645984996724427E-19,
-                                                                                                                                                                                                                                                               [{
-                                                                                                                                                                                                                                                                "tY좗⧑mrzﺝ㿥ⴖ᥷j諅\u0000q賋譁Ꞅ⮱S\nࡣB/큃굪3Zɑ复o<\/;롋": null,
-                                                                                                                                                                                                                                                                "彟h浠_|V4䦭Dᙣ♞u쿻=삮㍦\u001e哀鬌": [{"6횣楠,qʎꗇ鎆빙]㱭R굋鈌%栲j分僅ペ䇰w폦p蛃N溈ꡐꏀ?@(GI뉬$ﮄ9誁ꓚ2e甸ڋ[䁺,\u0011\u001cࢃ=\\+衪䷨ᯕ鬸K": [[
-                                                                                                                                                                                                                                                                 "ㅩ拏鈩勥\u000etgWVXs陂規p狵w퓼{뮵_i\u0002ퟑႢ⬐d6鋫F~챿搟\u0096䚼1ۼ칥0꣯儏=鋷牋ⅈꍞ龐",
-                                                                                                                                                                                                                                                                 -7283717290969427831,
-                                                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                                                 [
-                                                                                                                                                                                                                                                                  4911644391234541055,
-                                                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                                                   "I鈒첽P릜朸W徨觘-Hᎄ퐟⓺>8kr1{겵䍃〛ᬡ̨O귑o䝕'쿡鉕p5": "fv粖RN瞖蛐a?q꤄\u001d⸥}'ꣴ犿ꦼ?뤋?鵆쥴덋䡫s矷̄?ඣ/;괱絢oWfV<\/\u202cC,㖦0䑾%n賹g&T;|lj_欂N4w",
-                                                                                                                                                                                                                                                                   "짨䠗;䌕u i+r๏0": [{"9䥁\\఩8\"馇z䇔<\/ႡY3e狚쐡\"ุ6ﰆZ遖c\"Ll:ꮾ疣<\/᭙Ｏ◌납୕湞9⡳Und㫜\u0018^4pj1;䧐儂䗷ୗ>@e톬": {
-                                                                                                                                                                                                                                                                    "a⑂F鋻Q螰'<퇽Q贝瀧{ᘪ,cP&~䮃Z?gＩ彃": [
-                                                                                                                                                                                                                                                                     -1.69158726118025933E18,
-                                                                                                                                                                                                                                                                     [
-                                                                                                                                                                                                                                                                      "궂z簽㔛㮨瘥⤜䛖Gℤ逆Y⪾j08Sn昞ꘔ캻禀鴚P謦b{ꓮmN靐Mᥙ5\"睏2냑I\u0011.L&=?6ᄠ뻷X鸌t刑\"#z)o꫚n쳟줋",
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      7517598198523963704,
-                                                                                                                                                                                                                                                                      "ኑQp襟`uᩄr方]*F48ꔵn俺ሙ9뇒",
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      6645782462773449868,
-                                                                                                                                                                                                                                                                      1219168146640438184,
-                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                                       ")ယ넌竀Sd䰾zq⫣⏌ʥ\u0010ΐ' |磪&p牢蔑mV蘸૰짬꺵;K": [
-                                                                                                                                                                                                                                                                        -7.539062290108008E-20,
-                                                                                                                                                                                                                                                                        [
-                                                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                                                         false,
-                                                                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                                                                         true,
-                                                                                                                                                                                                                                                                         6574577753576444630,
-                                                                                                                                                                                                                                                                         [[
-                                                                                                                                                                                                                                                                          1.2760162530699766E-19,
-                                                                                                                                                                                                                                                                          [
-                                                                                                                                                                                                                                                                           null,
-                                                                                                                                                                                                                                                                           [
-                                                                                                                                                                                                                                                                            "顊\\憎zXB,",
-                                                                                                                                                                                                                                                                            [{
-                                                                                                                                                                                                                                                                             "㇆{CVC9－MN㜋ઘR눽#{h@ퟨ!鼚׼XOvXS\u0017ᝣ=cS+梽៲綆16s덽휐y屬?ᇳG2ᴭ\u00054쫖y룇nKcW̭炦s/鰘ᬽ?J|퓀髣n勌\u0010홠P>j": false,
-                                                                                                                                                                                                                                                                             "箴": [
-                                                                                                                                                                                                                                                                              false,
-                                                                                                                                                                                                                                                                              "鍞j\"ꮾ*엇칬瘫xṬ⭽쩁䃳\"-⋵?ᦽ<cਔ↎⩧%鱩涎삧u9K⦈\"῝ᬑV绩킯愌ṱv@GꝾ跶Ꚇ(?䖃vI᧊xV\r哦j㠒?*=S굤紴ꊀ鹭쬈s<DrIu솹꧑?",
-                                                                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                                                                               ".}S㸼L?t\u000fK⑤s~hU鱜꘦}쪍C滈4ꓗ蛌):ྦ\"顥이⢷ῳYLn\"?fꘌ>댎Ĝ": true,
-                                                                                                                                                                                                                                                                               "Pg帯佃籛n㔠⭹࠳뷏≻࿟3㞱!-쒾!}쭪䃕!籿n涻J5ਲ਼yvy;Rኂ%ᔡጀ裃;M⣼)쵂쑈": 1.80447711803435366E18,
-                                                                                                                                                                                                                                                                               "ꈑC⡂ᑆ㤉壂뎃Xub<\/쀆༈憓ق쨐ק\\": [
-                                                                                                                                                                                                                                                                                7706977185172797197,
-                                                                                                                                                                                                                                                                                {"": {"K╥踮砆NWࡆFy韣7ä밥{|紒︧䃀榫rᩛꦡTSy잺iH8}ퟴ,M?Ʂ勺ᴹ@T@~꾂=I㙕뾰_涀쑜嫴曣8IY?ҿo줫fऒ}\\S\"ᦨ뵼#nDX": {
-                                                                                                                                                                                                                                                                                 "♘k6?଱癫d68?㽚乳䬳-V顷\u0005蝕?\u0018䞊V{邾zじl]雏k臤~ൖH뒐iꢥ]g?.G碄懺䔛p<q꜉S岗_.%": 7688630934772863849,
-                                                                                                                                                                                                                                                                                 "溗摽嗙O㧀,⡢⼰呠ꅧ㓲/葇䢛icc@-r\b渂ꌳ뻨饑觝ᖜ\\鮭\u0014엙㥀᧺@浹W2꛵{W률G溮킀轡䬆g㨑'Q聨៪网Hd\"Q늴ᱢﶨ邮昕纚枑?▰hr羌驀[痹<\/": [
-                                                                                                                                                                                                                                                                                  -1.0189902027934687E-19,
-                                                                                                                                                                                                                                                                                  {"窶椸릎뚻shE\"ꪗႥꎳU矖佟{SJ": [{"-慜x櫹XY-澐ܨ⣷ઢ鯙%Fu\u0000迋▒}᥷L嗭臖oញc넨\u0016/迎1b꯸g뢱㐧蓤䒏8C散삭|\"컪輩鹩\"\\g$zG䥽긷?狸꿭扵㲐:URON&oU8": [
-                                                                                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                                                                                   true,
-                                                                                                                                                                                                                                                                                   null,
-                                                                                                                                                                                                                                                                                   -2.8907335031148883E17,
-                                                                                                                                                                                                                                                                                   -3864019407187144121,
-                                                                                                                                                                                                                                                                                   {
-                                                                                                                                                                                                                                                                                    "`빬d⵺4H뜳⧈쓑ohஸ*㶐ﻇ⸕䠵!i䝬﹑h夘▥ꗐ푹갇㵳TA鳠嚵\\B<X}3訒c⋝{*﫢w]璨-g捭\\j໵侠Ei层\u0011": 3.758356090089446E-19,
-                                                                                                                                                                                                                                                                                    "䄘ﮐ)Y놞씃㾱陰큁:{\u2059/S⓴": [[
-                                                                                                                                                                                                                                                                                     null,
-                                                                                                                                                                                                                                                                                     [[
-                                                                                                                                                                                                                                                                                      -3.8256602120220546E-20,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      7202317607724472882,
-                                                                                                                                                                                                                                                                                      "CWQ뚿",
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      false,
-                                                                                                                                                                                                                                                                                      true,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      2857038485417498625,
-                                                                                                                                                                                                                                                                                      6.191302233218633E-20,
-                                                                                                                                                                                                                                                                                      null,
-                                                                                                                                                                                                                                                                                      -6795250594296208046,
-                                                                                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                                                                                       true,
-                                                                                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                                                                                        "%ዧ遰Yᚯ⚀x莰愒Vᔈ턗BN洝ꤟA1⍌l콹풪H;OX๫륞쪐ᰚц@͎黾a邬<L厒Xb龃7f웨窂二;": [[
-                                                                                                                                                                                                                                                                                         null,
-                                                                                                                                                                                                                                                                                         "耲?䙧㘓F6Xs틭멢.v뚌?鄟恠▽'묺競?WvᆾCtxo?dZ;䨸疎",
-                                                                                                                                                                                                                                                                                         {
-                                                                                                                                                                                                                                                                                          "@hWꉁ&\"빜4礚UO~C;う殩_ꀥ蘁奢^챟k→ᡱKMⵉ<\/Jㅲ붉L͟Q": false,
-                                                                                                                                                                                                                                                                                          "tU뢂8龰I먽7,.Y搽Z툼=&⨥覽K乫햶㠸%#@Z끖愓^⍊⾂몒3E_噆J(廊ឭyd䞜鈬Ћ档'⣘I": {
-                                                                                                                                                                                                                                                                                           "tK*ꔵ銂u艗ԃ쿏∳ꄂ霫X3♢9y?=ⲭdЊb&xy}": [
-                                                                                                                                                                                                                                                                                            -4.097346784534325E-20,
-                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                            6016848468610144624,
-                                                                                                                                                                                                                                                                                            -8194387253692332861,
-                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                            {
-                                                                                                                                                                                                                                                                                             "(祬诀譕쯠娣c봝r?畄kT뼾⌘⎨?noV䏘쥝硎n?": [
-                                                                                                                                                                                                                                                                                              1.82679422844617293E18,
-                                                                                                                                                                                                                                                                                              [
-                                                                                                                                                                                                                                                                                               false,
-                                                                                                                                                                                                                                                                                               2.6849944122427694E18,
-                                                                                                                                                                                                                                                                                               true,
-                                                                                                                                                                                                                                                                                               [
-                                                                                                                                                                                                                                                                                                false,
-                                                                                                                                                                                                                                                                                                {
-                                                                                                                                                                                                                                                                                                 ";0z⭆;화$bਔ瀓\"衱^?잢ᢛ⣿~`ꕉ薸⌳໿湘腌'&:ryБꋥၼ꒥筙꬜긨?X": -3536753685245791530,
-                                                                                                                                                                                                                                                                                                 "c;Y7釚Uꃣ割J༨Y戣w}c峰뢨㽑㫈0N>R$䅒X觨l봜A刊8R梒',}u邩퉕?;91Ea䈈믁G⊶芔h袪&廣㺄j;㡏綽\u001bN頸쳘橆": -2272208444812560733,
-                                                                                                                                                                                                                                                                                                 "拑Wﵚj鵼駳Oࣿ)#㾅顂N傓纝y僱栜'Bꐍ-!KF*ꭇK￤?䈴^:啤wG逭w᧯": "xᣱmYe1ۏ@霄F$ě꧘푫O䤕퀐Pq52憬ꀜ兴㑗ᡚ?L鷝ퟐ뭐zJꑙ}╆ᅨJB]\"袌㺲u8䯆f",
-                                                                                                                                                                                                                                                                                                 "꿽၅㔂긱Ǧ?SI": -1669030251960539193,
-                                                                                                                                                                                                                                                                                                 "쇝ɨ`!葎>瞺瘡驷錶❤ﻮ酜=": -6961311505642101651,
-                                                                                                                                                                                                                                                                                                 "?f7♄꫄Jᡔ훮e읇퍾፣䭴KhखT;Qty}O\\|뫁IῒNe(5惁ꥶㆷY9ﮡ\\ oy⭖-䆩婁m#x봉>Y鈕E疣s驇↙ᙰm<": {"퉻:dꂁ&efￎ쫢[\"돈늖꺙|Ô剐1͖-K:ʚ᭕/;쏖㷛]I痐职4g<Oꗢ뫺N쯂륬J╆.`ᇵP轆&fd$?苅o궓vO侃沲⍩嚅沗 E%⿰얦wi\\*趫": [
-                                                                                                                                                                                                                                                                                                  3504362220185634767,
-                                                                                                                                                                                                                                                                                                  false,
-                                                                                                                                                                                                                                                                                                  "qzX朝qT3軞T垈ꮲQ览ᚻ⻑쎎b驌䵆ꬠ5Fୗ䲁缿ꝁ蒇潇Ltᆄ钯蜀W欥ሺ",
-                                                                                                                                                                                                                                                                                                  "볰ɐ霬)젝鶼kwoc엷荁r \u001d쒷⎹8{%澡K늒?iﺩd=&皼倚J9s@３偛twὡgj䁠흪5⭉⨺役&놎cﺉ㺡N5",
-                                                                                                                                                                                                                                                                                                  false,
-                                                                                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                                                                                  "D0st[ni锹r*0k6ꀎ덇UX2⽼৞䃚粭#)Z桷36P]<\/`",
-                                                                                                                                                                                                                                                                                                  4281410120849816730,
-                                                                                                                                                                                                                                                                                                  null,
-                                                                                                                                                                                                                                                                                                  -3256922126984394461,
-                                                                                                                                                                                                                                                                                                  1.16174580369801549E18,
-                                                                                                                                                                                                                                                                                                  {
-                                                                                                                                                                                                                                                                                                   " ᆼꤗ~*TN긂<㡴턱℃酰^蘒涯잰淭傛2rൡet쾣䐇m*㸏y\"\\糮᧺qv쌜镜T@yg1譬ﭧﳭ\f": null,
-                                                                                                                                                                                                                                                                                                   "圾ᨿ0xᮛ禵ਗ਼D-㟻ẵ錚e\"赜.˶m)鴑B(I$<\/轴퉯揷⋏⏺*)宓쓌?*橯Lx\\f쩂㞼⇸\"ﺧ軂遳V\\땒\"캘c:G": null,
-                                                                                                                                                                                                                                                                                                   "?﵁_곢翸폈8㿠h열Q2㭛}RY㯕ＹT놂⽻e^B<\/맫ﻇ繱\u0017Gц⟊ᢑﵩS:jt櫣嗒⟰W㴚搦ᅉe[w䋺?藂翙Ⲱ芮䍘╢囥lpdu7r볺I 近qFyᗊ": [
-                                                                                                                                                                                                                                                                                                    "$b脬aﾠ襬育Bگ嵺Pw+'M<\/כֿn䚚v螁bN⒂}褺%lቦ阤\"ꓺᏗM牏,۞Ҷ!矬?ke9銊X괦)䈽틁脽ṫ䈞ᴆ^=Yᗿ遛4I귺⋥%",
-                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                    2.9444482723232051E18,
-                                                                                                                                                                                                                                                                                                    2072621064799640026,
-                                                                                                                                                                                                                                                                                                    "/_뇴뫢j㍒=Nꡦ↍Ժ赒❬톥䨞珯su*媸瀳鷔抡o흺-៳辏勷f绔:䵢搢2",
-                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                    "쒜 E䌐/큁\u0018懺_<\\隺&{wF⤊谼(<죽遠8?@*rᶊGd뻻갇&Ⳇq᣿e࢔t_ꩄ梸O詬C᧧Kꩠ풤9눙醅됞}竸rw?滨ӽK⥿ཊG魲']`๖5㄰",
-                                                                                                                                                                                                                                                                                                    -2375253967958699084,
-                                                                                                                                                                                                                                                                                                    {"嗱⿲\"f億ᝬ": {"v?䚑킡`◤k3,骥曘뒤Oᒱ㲹^圮᠀YT껛&촮P:G/T⣝#튣k3炩蠏k@橈䏷S䧕,熜晬k1鮥玸먚7䤡f绝嗚샴ᥒ~0q拮垑a뻱LⰖ_": [{
-                                                                                                                                                                                                                                                                                                     ":p尢": -6.688985172863383E17,
-                                                                                                                                                                                                                                                                                                     "A0\u0001疠ﻵ爻鼀湶I~W^岀mZx#㍈7r拣$Ꜷ疕≛⦒痋盩Vꬷ᭝ΩQꍪ療鈑A(劽詗ꭅo-獶鑺\"Ⓠ@$j탥;": [
-                                                                                                                                                                                                                                                                                                      8565614620787930994,
-                                                                                                                                                                                                                                                                                                      [
-                                                                                                                                                                                                                                                                                                       "嶗PC?උQ㪣$&j幾㾷h慑 즊慧⪉霄M窊ꁷ'鮕)䊏铨m趦䗲(g罣ЮKVﯦ鏮5囗ﰼ鿦",
-                                                                                                                                                                                                                                                                                                       -7168038789747526632,
-                                                                                                                                                                                                                                                                                                       null,
-                                                                                                                                                                                                                                                                                                       -7.8069738975270288E16,
-                                                                                                                                                                                                                                                                                                       2.25819579241348352E17,
-                                                                                                                                                                                                                                                                                                       -6.5597416611655936E18,
-                                                                                                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                                                                                                        "瘕멦핓+?ﾌZ귢z鍛V": {
-                                                                                                                                                                                                                                                                                                         "ᕾ": 1.7363275204701887E-19,
-                                                                                                                                                                                                                                                                                                         "㭌s뎹㳉": {"\u00187FI6Yf靺+UC쬸麁␲䂿긕R\\ᆮC?Φ耭\rOத际핅홦*베W㸫㯼᡹cㅜ|G㮗\u0013[o`?jHV앝?蒪꩚!퍫ᜦ㌇䚇鿘:@": [
-                                                                                                                                                                                                                                                                                                          "}푛Г콲<䟏C藐呈#2㓋#ྕ፟尿9q竓gI%랙mꍬoa睕贿J咿D_熏Zz皳験I豼B扳ḢQ≖㻹㱣D䝦練2'ᗍ㗣▌砲8罿%హF姦;0悇<\/\"p嚧",
-                                                                                                                                                                                                                                                                                                          -710184373154164247,
-                                                                                                                                                                                                                                                                                                          "Vo쫬⬾ꝫⴷŻ\u0004靎HBꅸ_aVBＨbN>Z4⍜kเꛘZ⥺\\Bʫᇩ鄨魢弞&幟ᓮ2̊盜",
-                                                                                                                                                                                                                                                                                                          -9006004849098116748,
-                                                                                                                                                                                                                                                                                                          -3118404930403695681,
-                                                                                                                                                                                                                                                                                                          {
-                                                                                                                                                                                                                                                                                                           "_彃Y艘-\"Xx㤩㳷瑃?%2䐡鵛o<A?\"顜ᘌΈ;ⷅC洺L蚴蚀voq:,Oo4쪂)": 5719065258177391842,
-                                                                                                                                                                                                                                                                                                           "l륪맽耞塻論倐E㗑/㲕QM辬I\"qi酨玑㖪5q]尾魨鲡ƞY}⮯蠇%衟Fsf윔䐚찤i腳": {"ꢪ'a䣊糈": {"밑/♋S8s㼴5瓹O{댞\"9XﰇlJ近8}q{긧ⓈI᱑꿋腸D瀬H\"ﺬ'3?}\u0014#?丙㑯ᥨ圦',g鑠(樴턇?": [
-                                                                                                                                                                                                                                                                                                            2.5879275511391145E18,
-                                                                                                                                                                                                                                                                                                            null,
-                                                                                                                                                                                                                                                                                                            [
-                                                                                                                                                                                                                                                                                                             "3㼮ꔌ1Gẃ2W龙j͊{1囐㦭9x宠㑝oR䐕犽",
-                                                                                                                                                                                                                                                                                                             1268729930083267852,
-                                                                                                                                                                                                                                                                                                             "땕軚⿦7C",
-                                                                                                                                                                                                                                                                                                             [
-                                                                                                                                                                                                                                                                                                              -3.757935946502082E18,
-                                                                                                                                                                                                                                                                                                              "\"赌'糬_2뭾᝝b",
-                                                                                                                                                                                                                                                                                                              {
-                                                                                                                                                                                                                                                                                                               "(a䕎ጽjҰD4.ᴡ66ԃ畮<\/l`k癸\\㇋ࣆ욯R㫜픉녬挛;ڴ맺`.;焓q淞뮕ٹ趴r蔞ꯔ䟩v粏u5<\/pZ埖Skrvj帛=\u0005aa": null,
-                                                                                                                                                                                                                                                                                                               "璄≩ v몛ᘮ%?:1頌챀H㷪뉮k滘e": [
-                                                                                                                                                                                                                                                                                                                "ꤾ{`c샬왌펡[俊络vmz㪀悫⸹ᷥ5o'㾵 L蹦qjYIYណԠW냁剫<\/W嗂0,}",
-                                                                                                                                                                                                                                                                                                                2.4817616702666762E18,
-                                                                                                                                                                                                                                                                                                                false,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                -8.6036958071260979E17,
-                                                                                                                                                                                                                                                                                                                null,
-                                                                                                                                                                                                                                                                                                                -1.2744078022652468E-19,
-                                                                                                                                                                                                                                                                                                                -4.4752020268429594E17,
-                                                                                                                                                                                                                                                                                                                1.13672865156637872E17,
-                                                                                                                                                                                                                                                                                                                [
-                                                                                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                                                                                 false,
-                                                                                                                                                                                                                                                                                                                 null,
-                                                                                                                                                                                                                                                                                                                 -4.178004168554046E-20,
-                                                                                                                                                                                                                                                                                                                 true,
-                                                                                                                                                                                                                                                                                                                 2927542512798605527,
-                                                                                                                                                                                                                                                                                                                 {
-                                                                                                                                                                                                                                                                                                                  ".ꔓ뉤1䵬cHy汼䊆賓ᐇƩ|樷❇醎㬅4\u0003赵}#yD5膏晹뱓9ꖁ虛J㺕 t䊛膎ؤ": {
-                                                                                                                                                                                                                                                                                                                   "rVtᓸ5^`েN⹻Yv᥋lꌫt拘?<鮰넿ZC?㒽^": {"␪k_:>귵옔夘v*탋职&㳈챗|O钧": [
-                                                                                                                                                                                                                                                                                                                    false,
-                                                                                                                                                                                                                                                                                                                    "daꧺdᗹ羞쯧H㍤鄳頳<型孒ン냆㹀f4㹰\u000f|C*ሟ鰠(O<ꨭ峹ipຠ*y೧4VQ蔔hV淬{?ᵌEfrI_",
-                                                                                                                                                                                                                                                                                                                    "j;ꗣ밷邍副]ᗓ",
-                                                                                                                                                                                                                                                                                                                    -4299029053086432759,
-                                                                                                                                                                                                                                                                                                                    -5610837526958786727,
-                                                                                                                                                                                                                                                                                                                    [
-                                                                                                                                                                                                                                                                                                                     null,
-                                                                                                                                                                                                                                                                                                                     [
-                                                                                                                                                                                                                                                                                                                      -1.3958390678662759E-19,
-                                                                                                                                                                                                                                                                                                                      {
-                                                                                                                                                                                                                                                                                                                       "lh좈T_믝Y\"伨\u001cꔌG爔겕ꫳ晚踍⿻읐T䯎]~e#฽燇\"5hٔ嶰`泯r;ᗜ쮪Q):/t筑,榄&5懶뎫狝(": [{
-                                                                                                                                                                                                                                                                                                                        "2ፁⓛ]r3C攟וּ9賵s⛔6'ஂ|\"ⵈ鶆䐹禝3\"痰ࢤ霏䵩옆䌀?栕r7O簂Isd?K᫜`^讶}z8?z얰T:X倫⨎ꑹ": -6731128077618251511,
-                                                                                                                                                                                                                                                                                                                        "|︦僰~m漿햭\\Y1'Vvخ굇ቍ챢c趖": [null]
-                                                                                                                                                                                                                                                                                                                       }],
-                                                                                                                                                                                                                                                                                                                       "虌魿閆5⛔煊뎰㞤ᗴꥰF䮥蘦䂪樳-K᝷-(^\u20dd_": 2.11318679791770592E17
-                                                                                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                                                                                    ]
-                                                                                                                                                                                                                                                                                                                   ]},
-                                                                                                                                                                                                                                                                                                                   "묗E䀳㧯᳀逞GMc\b墹㓄끖Ơ&U??펌鑍 媋k))ᄊ": null,
-                                                                                                                                                                                                                                                                                                                   "묥7콽벼諌J_DɯﮪM殴䣏,煚ྼ`Y:씧<\/⩫%yf䦀!1Ჶk춎Q米W∠WC跉鬽*ᛱi<?,l<崣炂骵*?8푐៣ⰵ憉⎑.,Nw罣q+ο컆弎": false
-                                                                                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                                                                                  "e[|଀+lꑸ㝈TT?뿿|ꫛ9`㱯䊸楋-곳賨?쳁k棽擋wQ餈⟐Nq[q霩䵀뷮锅ꚢ": 5753148631596678144,
-                                                                                                                                                                                                                                                                                                                  "sᓝ鴻߸d렶ὕ蜗ဟ툑!诉౿": false,
-                                                                                                                                                                                                                                                                                                                  "|4䕳鵻?䈔(]틍/Ui#湻{듲ーMዀt7潔泄Ch⸨}쏣`螧銚㋼壯kⰥQ戵峉갑x辙'첛": "jd䘯$䕌茷!auw眶ㅥ䁣ꆢ民i",
-                                                                                                                                                                                                                                                                                                                  "剖駰ꞫsM2]ᾴ2ࡷ祅拌Av狔꩛'ꓗ킧ꣁ0酜✘O'": false,
-                                                                                                                                                                                                                                                                                                                  "澩뢣ꀁeU~D\\ꮡ킠": "v^YC嚈ί\u0007죋h>㴕L꘻ꀏ쓪\"_g鿄'#t⽙?,Wg㥖|D鑆e⥏쪸僬h鯔咼ඡ;4TK聎졠嫞"
-                                                                                                                                                                                                                                                                                                                 }
-                                                                                                                                                                                                                                                                                                                ]
-                                                                                                                                                                                                                                                                                                               ]
-                                                                                                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                                                                                                            ]
-                                                                                                                                                                                                                                                                                                           ]}}
-                                                                                                                                                                                                                                                                                                          }
-                                                                                                                                                                                                                                                                                                         ]}
-                                                                                                                                                                                                                                                                                                        },
-                                                                                                                                                                                                                                                                                                        "뿋뀾淣截䔲踀&XJ펖꙯^Xb訅ꫥgᬐ>棟S\"혧騾밫겁7-": "擹8C憎W\"쵮yR뢩浗絆䠣簿9䏈引Wcy䤶孖ꯥ;퐌]輩䍐3@{叝 뽸0ᡈ쵡Ⲇ\u001dL匁꧐2F~ݕ㪂@W^靽L襒ᦘ~沦zZ棸!꒲栬R"
-                                                                                                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                                                                                                     ],
-                                                                                                                                                                                                                                                                                                     "Z:덃൛5Iz찇䅄駠㭧蓡K1": "e8᧤좱U%?ⵇ䯿鿝\u0013縮R∱骒EO\u000fg?幤@֗퉙vU`",
-                                                                                                                                                                                                                                                                                                     "䐃쪈埽້=Ij,쭗쓇చ": false
-                                                                                                                                                                                                                                                                                                    }]}}
-                                                                                                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                                                                                 ]}
-                                                                                                                                                                                                                                                                                                }
-                                                                                                                                                                                                                                                                                               ]
-                                                                                                                                                                                                                                                                                              ]
-                                                                                                                                                                                                                                                                                             ],
-                                                                                                                                                                                                                                                                                             "咰긖VM]᝼6䓑쇎琺etDҌ?㞏ꩄ퇫밉gj8蠃\"⩐5䛹1ࣚ㵪": "ക蹊?⎲⧘⾚̀I#\"䈈⦞돷`wo窭戕෱휾䃼)앷嵃꾞稧,Ⴆ윧9S?೗EMk3Მ3+e{⹔Te驨7䵒?타Ulg悳o43"
-                                                                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                                                                           ],
-                                                                                                                                                                                                                                                                                           "zQᤚ纂땺6#ٽ﹧v￿#ࠫ휊冟蹧텈ꃊʆ?&a䥯De潝|쿓pt瓞㭻啹^盚2Ꝋf醪,얏T窧\\Di䕎谄nn父ꋊE": -2914269627845628872,
-                                                                                                                                                                                                                                                                                           "䉩跐|㨻ᷢ㝉B{蓧瞸`I!℄욃힕#ೲᙾ竛ᔺCjk췒늕貭词\u0017署?W딚%(pꍁ⤼띳^=on뺲l䆼bzrﳨ[&j狸䠠=ᜑꦦ\u2061յnj=牲攑)M\\龏": false,
-                                                                                                                                                                                                                                                                                           "뎕y絬᫡⥮Ϙᯑ㌔/NF*˓.,QEzvK!Iwz?|쥾\"ꩻL꼗Bꔧ賴緜s뉣隤茛>ロ?(?^`>冺飒=噸泥⺭Ᲊ婓鎔븜z^坷裮êⓅ໗jM7ﶕ找\\O": 1.376745434746303E-19
-                                                                                                                                                                                                                                                                                          },
-                                                                                                                                                                                                                                                                                          "䐛r滖w㏤<k;l8ꡔጵ⮂ny辶⋃퍼僮z\"﮲X@t5෼暧퓞猋♅䦖QC鹮|픨( ,>,|Nዜ": false
-                                                                                                                                                                                                                                                                                         }
-                                                                                                                                                                                                                                                                                        ]],
-                                                                                                                                                                                                                                                                                        "@꿙?薕尬 gd晆(띄5躕ﻫS蔺4)떒錸瓍?~": 1665108992286702624,
-                                                                                                                                                                                                                                                                                        "w믍nᏠ=`঺ￆC>'從됐槷䤝眷螄㎻揰扰XￊC贽uჍ낟jKD03T!lDV쀉Ӊy뢖,袛!终캨G?鉮Q)⑗1쾅庅O4ꁉH7?d\u0010蠈줘월ސ粯Q!낇껉6텝|{": null,
-                                                                                                                                                                                                                                                                                        "~˷jg쿤촖쉯y": -5.5527605669177098E18,
-                                                                                                                                                                                                                                                                                        "펅Wᶺzꐆと푭e?4j仪열[D<鈑皶婆䵽ehS?袪;HꍨM뗎ば[(嗏M3q퍟g4y╸鰧茀[Bi盤~﫝唎鋆彺⦊q?B4쉓癚O洙킋툈䶯_?ퟲ": null
-                                                                                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                                                                                     ]]
-                                                                                                                                                                                                                                                                                    ]],
-                                                                                                                                                                                                                                                                                    "꟱Ԕ㍤7曁聯ಃ錐V䷰?v㪃૦~K\"$%请|ꇹn\"k䫛㏨鲨\u2023䄢\u0004[<S8ᐬ뭩脥7U.m࿹:D葍┆2蘸^U'w1젅;䠆ꋪB껮>︊VJ?䶟ាꮈ䗱=깘U빩": -4863152493797013264
-                                                                                                                                                                                                                                                                                   }
-                                                                                                                                                                                                                                                                                  ]}]}
-                                                                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                                                                }}}
-                                                                                                                                                                                                                                                                               ],
-                                                                                                                                                                                                                                                                               "쏷쐲۹퉃~aE唙a챑,9㮹gLHd'䔏|킗㍞䎥&KZYT맵7䥺N<Hp4ꕭ⹠꽐c~皽z": "课|ᖾ䡁廋萄䐪W\u0016&Jn괝b~摓M>ⱳ同莞鿧w\\༌疣n/+ꎥU\"封랾○ퟙAJᭌ?9䛝$?驔9讐짘魡T֯c藳`虉C읇쐦T"
-                                                                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                                                                             ],
-                                                                                                                                                                                                                                                                             "谶개gTR￐>ၵ͚dt晑䉇陏滺}9㉸P漄": -3350307268584339381
-                                                                                                                                                                                                                                                                            }]
-                                                                                                                                                                                                                                                                           ]
-                                                                                                                                                                                                                                                                          ]
-                                                                                                                                                                                                                                                                         ]]
-                                                                                                                                                                                                                                                                        ]
-                                                                                                                                                                                                                                                                       ],
-                                                                                                                                                                                                                                                                       "0y꟭馋X뱔瑇:䌚￐廿jg-懲鸭䷭垤㒬茭u賚찶ಽ+\\mT땱\u20821殑㐄J쩩䭛ꬿNS潔*d\\X,壠뒦e殟%LxG9:摸": 3737064585881894882,
-                                                                                                                                                                                                                                                                       "풵O^-⧧ⅶvѪ8廸鉵㈉ר↝Q㿴뺟EႳvNM:磇>w/៻唎뷭୥!냹D䯙i뵱貁C#⼉NH6`柴ʗ#\\!2䂗Ⱨf?諳.P덈-返I꘶6?8ꐘ": -8934657287877777844,
-                                                                                                                                                                                                                                                                       "溎-蘍寃i诖ര\"汵\"\ftl,?d⼡쾪⺋h匱[,෩I8MҧF{k瓿PA'橸ꩯ綷퉲翓": null
-                                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                                    ],
-                                                                                                                                                                                                                                                                    "ោ係؁<元": 1.7926963090826924E-18
-                                                                                                                                                                                                                                                                   }}]
-                                                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                                                ]]}]
-                                                                                                                                                                                                                                                               }]
-                                                                                                                                                                                                                                                              ]
-                                                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                                                            ]
-                                                                                                                                                                                                                                                           ],
-                                                                                                                                                                                                                                                           "ጩV<\"ڸsOᤘ": 2.0527167903723048E-19
-                                                                                                                                                                                                                                                          }]
-                                                                                                                                                                                                                                                         ]}
-                                                                                                                                                                                                                                                        ]
-                                                                                                                                                                                                                                                       ]],
-                                                                                                                                                                                                                                                       "∳㙰3젴p᧗䱙?`<U὇<\/意E[ᮚAj诂ᒽ阚uv徢ဎ떗尔Ᵹ훀쩑J䐴?⪏=륪ᆩ푰ஓ㐕?럽VK\"X?檨လ齿I/耉A(AWA~⏯稐蹫": false,
-                                                                                                                                                                                                                                                       "偒妝뾇}䀼链i⇃%⋜&璪Ix渥5涧qq棩ᥝ-⠫AA낇yY颕A*裦O|n?䭬혗F": null,
-                                                                                                                                                                                                                                                       "琭CL얭B혆Kॎ`鎃nrsZiժW砏)?p~K~A眱䲏QO妣\u001b\u001b]ᵆᆯ&㐋ᏹ豉뺘$ꭧ#j=C)祤⫢歑1o㒙諩": 7028426989382601021,
-                                                                                                                                                                                                                                                       "쳱冲&ဤ䌏앧h胺-齱H忱8왪RDKᅒ䬋ᔶS*J}ስ漵'㼹뮠9걢9p봋경ጕtởꚳT䶽瘙%춴`@nಆ4<d??#僜ᙤ钴=薔ꭂbLXNam蹈": "樭る蹿= Uurwkn뙧⌲%\"쑃牪\"cq윕o@",
-                                                                                                                                                                                                                                                       "溌[H]焎SLㅁ?뀼䫨災W": 1.1714289118497062E-19,
-                                                                                                                                                                                                                                                       "ﬢp븇剌燇kĔ尘㶿㴞睠꾘Ia;s❺^)$穮?sHᢥ폪l": null
-                                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                                                  },
-                                                                                                                                                                                                                                                  "TKnzj5o<\/K㊗ꗣ藠⦪駇>yZA8Ez0,^ᙛ4_0븢\u001ft:~䎼s.bb룦明yNP8弆C偯;⪾짍'蕴뮛": -6976654157771105701,
-                                                                                                                                                                                                                                                  "큵ꦀ\\㇑:nv+뒤燻䀪ﴣ﷍9ᚈ኷K㚊誦撪䚛,ꮪxሲ쳊\u0005HSf?asg昱dqꬌVꙇ㼺'k*'㈈": -5.937042203633044E-20
-                                                                                                                                                                                                                                                 }
-                                                                                                                                                                                                                                                ]
-                                                                                                                                                                                                                                               }],
-                                                                                                                                                                                                                                               "?}\u20e0],s嶳菋@#2u쒴sQS䩗=ꥮ;烌,|ꘔ䘆": "ᅩ영N璠kZ먕眻?2ቲ芋眑D륟渂⸑ﴃIRE]啗`K'"
-                                                                                                                                                                                                                                              }},
-                                                                                                                                                                                                                                              "쨀jmV賂ﰊ姐䂦玞㬙ᏪM᪟Վ씜~`uOn*ॠ8\u000ef6??\\@/?9見d筜ﳋB|S䝬葫㽁o": true
-                                                                                                                                                                                                                                             },
-                                                                                                                                                                                                                                             "즛ꄤ酳艚␂㺘봿㎨iG৕ࡿ?1\"䘓您\u001fSኝ⺿溏zៀ뻤B\u0019?윐a䳵᭱䉺膷d:<\/": 3935553551038864272
-                                                                                                                                                                                                                                            }
-                                                                                                                                                                                                                                           ]
-                                                                                                                                                                                                                                          ]}
-                                                                                                                                                                                                                                         ]]
-                                                                                                                                                                                                                                        ]]
-                                                                                                                                                                                                                                       ]}
-                                                                                                                                                                                                                                      }
-                                                                                                                                                                                                                                     ]
-                                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                                   ]]}},
-                                                                                                                                                                                                                                   "᥺3h↛!ꋰy\"攜(ெl䪕oUkc1A㘞ᡲ촾ᣫ<\/䒌E㛝潨i{v?W౾H\\RჅpz蝬R脾;v:碽✘↯삞鷱o㸧瑠jcmK7㶧뾥찲n": true,
-                                                                                                                                                                                                                                   "ⶸ?x䊺⬝-䰅≁!e쩆2ꎿ准G踌XXᩯ1߁}0?.헀Z馟;稄\baDꟹ{-寪⚈ꉷ鮸_L7ƽᾚ<\u001bጨA䧆송뇵⨔\\礍뗔d设룱㶉cq{HyぱR㥽吢ſtp": -7985372423148569301,
-                                                                                                                                                                                                                                   "緫#콮IB6<\/=5Eh礹\t8럭@饹韠r㰛斣$甝LV췐a갵'请o0g:^": "䔨(.",
-                                                                                                                                                                                                                                   "띳℡圤pﾝ௄ĝ倧訜B쁟G䙔\"Sb⓮;$$▏S1J뢙SF|赡g*\"Vu䲌y": "䪈&틐),\\kT鬜1풥;뷴'Zေ䩹@J鞽NぼM?坥eWb6榀ƩZڮ淽⺞삳煳xჿ絯8eⶍ羷V}ჿ쎱䄫R뱃9Z>'\u20f1ⓕ䏜齮"
-                                                                                                                                                                                                                                  }
-                                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                                ]]]
-                                                                                                                                                                                                                               }}
-                                                                                                                                                                                                                              }
-                                                                                                                                                                                                                             ]
-                                                                                                                                                                                                                            ]},
-                                                                                                                                                                                                                            "펮b.h粔폯2npX詫g錰鷇㇒<쐙S値bBi@?镬矉`剔}c2壧ଭfhY깨R()痩⺃a\\⍔?M&ﯟ<劜꺄멊ᄟA\"_=": null
-                                                                                                                                                                                                                           },
-                                                                                                                                                                                                                           "~潹Rqn榢㆓aR鬨侅?䜑亡V_翅㭔(䓷w劸ၳDp䀅<\/ﰎ鶊m䵱팱긽ꆘ<tD쇋>긓准D3掱;o:_ќ)껚콥8곤d矦8nP倥ꃸI": null,
-                                                                                                                                                                                                                           "뾎/Q㣩㫸벯➡㠦◕挮a鶧⋓偼\u00001뱓fm覞n?㛅\"": 2.8515592202045408E17
-                                                                                                                                                                                                                          }],
-                                                                                                                                                                                                                          ",": -5426918750465854828,
-                                                                                                                                                                                                                          "2櫫@0柡g䢻/gꆑ6演&D稒肩Y?艘/놘p{f투`飷ᒉ챻돎<늛䘍ﴡ줰쫄": false,
-                                                                                                                                                                                                                          "8(鸑嵀⵹ퟡ<9㣎Tߗ┘d슒ل蘯&㠦뮮eࠍk砝g 엻": false,
-                                                                                                                                                                                                                          "d-\u208b?0ﳮ嵙'(J`蔿d^踅⤔榥\\J⵲v7": 6.8002426206715341E17,
-                                                                                                                                                                                                                          "ཎ耰큓ꐕ㱷\u0013y=詽I\"盈xm{0쾽倻䉚ષso#鰑/8㸴짯%ꀄ떸b츟*\\鲷礬ZQ兩?np㋄椂榨kc᡹醅3": false,
-                                                                                                                                                                                                                          "싊j20": false
-                                                                                                                                                                                                                         }]]
-                                                                                                                                                                                                                        ]],
-                                                                                                                                                                                                                        "俛\u0017n緽Tu뫉蜍鼟烬.ꭠIⰓ\"Ἀ᜾uC쎆J@古%ꛍm뻨ᾀ画蛐휃T:錖㑸ዚ9죡$": true
-                                                                                                                                                                                                                       }
-                                                                                                                                                                                                                      ]
-                                                                                                                                                                                                                     ],
-                                                                                                                                                                                                                     "㍵⇘ꦖ辈s}㱮慀밒s`\"㞟j:`i픻Z<C1衽$\"-饧?℃\u0010⼒{p飗%R\"䲔\")칀\\%": true,
-                                                                                                                                                                                                                     "苧.8\u00120ݬ仓": 6912164821255417986,
-                                                                                                                                                                                                                     "떎顣俁X;.#Q틝.笂'p쟨唒퐏랩냆¦aⱍ{谐.b我$蜑SH\u000f琾=䟼⣼奔ᜏ攕B&挰繗㝔ꅂ-Qv\\0䶝䚥ぺio［㑮-ᇼ䬰컪ṼiY){데\u0010q螰掻~\n輚x\u0014罺)軴": 3.024364150712629E-20
-                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                   ]
-                                                                                                                                                                                                                  ]
-                                                                                                                                                                                                                 ]
-                                                                                                                                                                                                                ]}
-                                                                                                                                                                                                               ]]
-                                                                                                                                                                                                              }
-                                                                                                                                                                                                             ]
-                                                                                                                                                                                                            ]]
-                                                                                                                                                                                                           ]
-                                                                                                                                                                                                          ]]]],
-                                                                                                                                                                                                          "\"凲o肉Iz絾豉J8?i~傠᫽䇂!WD溊J?ᡒvs菆嵹➒淴>섫^諎0Ok{켿歁෣胰a2﨤[탳뚬쎼嫭뉮m": 409440660915023105,
-                                                                                                                                                                                                          "w墄#*ᢄ峠밮jLa`ㆪ꺊漓Lで끎!Agk'ꁛ뢃㯐岬D#㒦": false,
-                                                                                                                                                                                                          "ଦPGI䕺L몥罭ꃑ궩﮶#⮈ᢓӢ䚬p7웼臧%~S菠␌힀6&t䳙y㪘냏\\*;鉏ￊ鿵'嗕pa\"oL쇿꬈Cg": "㶽1灸D⟸䴅ᆤ뉎﷛渤csx 䝔цꬃ锚捬?ຽ+x~꘩uI࡞\u0007栲5呚ẓem?袝\")=㥴䨃pac!/揎Y",
-                                                                                                                                                                                                          "ᷱo\\||뎂몷r篙|#X䦜I#딌媸픕叞RD斳X4t⯩夬=[뭲r=绥jh뷱츝⪘%]⚋܈㖴スH텹m(WO曝劉0~K3c柢Ր㏉着逳~": false,
-                                                                                                                                                                                                          "煽_qb[첑\\륌wE❽ZtCNﭝ+餌ᕜOꛭ": "{ﳾ쉌&s惧ᭁⵆ3䢫;䨞팑꒪흘褀࢖Q䠿V5뭀䎂澻%받u5텸oA⮥U㎦;B䳌wz䕙$ឿ\\௅婺돵⪾퐆\\`Kyौꋟ._\u0006L챯l뇠Hi䧈偒5",
-                                                                                                                                                                                                          "艊佁ࣃ롇䱠爬!*;⨣捎慓q靓|儑ᨋL+迥=6㒺딉6弄3辅J-㕎뛄듘SG㆛(\noAzQꝱ䰩X*ぢO퀌%펠낌mo틮a^<\/F&_눊ᾉ㨦ы4\"8H": 2974648459619059400,
-                                                                                                                                                                                                          "鬙@뎣䫳ၮ끡?){y?5K;TA*k溱䫜J汃ꂯ싔썍\u001dA}룖(<\/^,": false,
-                                                                                                                                                                                                          "몏@QꋦFꊩᒐ뎶lXl垨4^郣|ꮇ;䝴ᝓ}쵲z珖": null
-                                                                                                                                                                                                         }
-                                                                                                                                                                                                        ]]]],
-                                                                                                                                                                                                        ":_=닧弗D䙋暨鏛. 㱻붘䂍J儒&ZK/녩䪜r囁⽯D喠죥7⹌䪥c\u001a\u2076￞妈朹oLk菮F౟覛쐧㮏7T;}蛙2{9\"崓bB<\/⡷룀;즮鿹)丒툃୤뷠5W⊢嶜(fb뭳갣": "E{响1WM"
-                                                                                                                                                                                                       }},
-                                                                                                                                                                                                       "䘨tjJ驳豨?y輊M*᳑梵瞻઻ofQG瑮e": 2.222802939724948E-19,
-                                                                                                                                                                                                       "䮴=❑➶T෋w䞜\"垦ꃼUt\u001dx;B$뵣䙶E↌艣ᡥ!᧟;䱀[䔯k쬃`੍8饙른熏'2_'袻tGf蒭J땟as꯳╖&啒zWࡇᒫYSᏬ\u0014ℑ첥鈤|cG~Pᓮ\">\"": "ႆl\f7V儊㦬nHꄬꨧC{쐢~C⮃⛓嶦vꄎ1w鰠嘩뿠魄&\"_qMⵖ釔녮ꝇ 㝚{糍J哋 cv?-jkﻯྌ鹑L舟r",
-                                                                                                                                                                                                       "龧葆yB✱H盋夔ﶉ?n*0(": "ꧣኆ㢓氥qZZ酒ຜ)鮢樛)X䣆gTSґG텞k.J圬疝롫쯭z L：\\ྤ@w炋塜쿖ᾳy뢀䶃뱝N䥨㚔勇겁#p",
-                                                                                                                                                                                                       "도畎Q娡\"@S/뼋:䵏!P衅촚fVHQs✜ᐫi㻑殡B䜇%믚k*U#濨낄~": "ꍟዕ쳸ꍈ敋&l妏\u0005憡멗瘌uPgᅪm<\/To쯬锩h뒓k"
-                                                                                                                                                                                                      }
-                                                                                                                                                                                                     ]
-                                                                                                                                                                                                    }],
-                                                                                                                                                                                                    "墥홞r绚<\/⸹ⰃB}<躅\\Y;๑@䔸>韫䜲뱀X뗩鿥쩗SI%ﴞ㳕䛇?<\/\u00018x\\&侂9鋙a[LR㋭W胕)⡿8㞙0JF,}?허d1cDMᐃ␛鄝ⱕ%X)!XQ": "ⳍꗳ=橇a;3t⦾꼑仈ူaᚯ⯋ꕃAs鴷N⍕_䎃ꙎAz\u0016䯷\\<࿫>8q{}ｷ?ᣰ}'0ᴕ펓B┦lF#趤厃T?㕊#撹圂䆲"
-                                                                                                                                                                                                   },
-                                                                                                                                                                                                   "܋닐龫論c웑": false,
-                                                                                                                                                                                                   "ㇿ/q\"6-co髨휝C큦#\u001b4~?3䐹E삇<<": 7.600917488140322E-20,
-                                                                                                                                                                                                   "䁝E6?㣖ꃁ间t祗*鑠{ḣV(浾h逇큞=W?ૉ?nꇽ8ꅉຉj으쮺@Ꚅ㰤u]Oyr": "v≁᫸_*όAඤԆl)ۓᦇQ}폠z༏q滚",
-                                                                                                                                                                                                   "ｿ᥊/넺I": true
-                                                                                                                                                                                                  }]]
-                                                                                                                                                                                                 ]
-                                                                                                                                                                                                ]
-                                                                                                                                                                                               ]
-                                                                                                                                                                                              ]]
-                                                                                                                                                                                             },
-                                                                                                                                                                                             "䭑Ik攑\u0002QV烄:芩.麑㟴㘨≕": true,
-                                                                                                                                                                                             "坄꿕C쇻풉~崍%碼\\8\"䬦꣙": null,
-                                                                                                                                                                                             "欌L圬䅘Y8c(♺2?ON}o椳s宥2䉀eJ%闹r冁O^K諭%凞⺉⡻,掜?$ꥉ?略焕찳㯊艼誜4?\"﯎<゛XፈINT:詓 +": -1.0750456770694562E-19,
-                                                                                                                                                                                             "獒àc뜭싼ﺳ뎤K`]p隨LtE": null,
-                                                                                                                                                                                             "甙8䵊神EIꩤ鐯ᢀ,ﵮU䝑u疒ử驺䚿≚ഋ梶秓F`覤譐#짾蔀묊4<媍쬦靪_Yzgcࡶ4k紥`kc[Lﮗ簐*I瀑[⾰L殽鑥_mGȠ<\/|囹灠g桰iri": true,
-                                                                                                                                                                                             "챓ꖙꟻ좝菇ou,嗠0\\jK핻뜠qwQ?ഩ㼕3Y彦b\u009bJ榶N棨f?됦鏖綃6鳵M[OE봨u햏.Ꮁ癜蟳뽲ꩌ뻾rM豈R嗀羫 uDꎚ%": null
-                                                                                                                                                                                            },
-                                                                                                                                                                                            "V傜2<": 7175127699521359521
-                                                                                                                                                                                           }],
-                                                                                                                                                                                           "铫aG切<\/\"ী⊆e<^g࢛)D顝ｎאַ饼\u008c猪繩嵿ﱚCꡬ㻊g엺A엦\u000f暿_f꿤볝㦕桦`蒦䎔j甬%岝rj 糏": "䚢偎눴Au<4箞7礦Iﱔ坠eȧ䪸u䵁p|逹$嗫쨘ꖾ﷐!胠z寓팢^㨔|u8Nሇe텔ꅦ抷]،鹎㳁#༔繁 ",
-                                                                                                                                                                                           "낂乕ꃻ볨ϱ-ꇋ㖍fs⿫)zꜦ/K?솞♞ꑌ宭hJ᤭瑥Fu": false,
-                                                                                                                                                                                           "쟰ぜ魛G\u0003u?`㾕ℾ㣭5螠烶這趩ꖢ:@咕ꐶx뒘느m䰨b痃렐0鳊喵熬딃$摉_~7*ⱦ녯1錾GKhJ惎秴6'H妈Tᧅ窹㺒疄矤铟wላ": null,
-                                                                                                                                                                                           "쯆q4!3錕㲏ⵆ㇛꘷Z瑩뭆\\◪NH\u001d\\㽰U~㯶<\"쑣낞3ᵤ'峉eꢬ;鬹o꣒木X*長PXᘱu\"䠹n惞": null,
-                                                                                                                                                                                           "ᅸ祊\"&ꥴCjࢼ﴿?䡉`U效5殼㮞V昽ꏪ#ﺸ\\&t6x꠹盥꣰a[\u001aꪍSpe鎿蠹": -1.1564713893659811E-19
-                                                                                                                                                                                          }
-                                                                                                                                                                                         ]]
-                                                                                                                                                                                        ]
-                                                                                                                                                                                       ]
-                                                                                                                                                                                      ],
-                                                                                                                                                                                      "羵䥳H,6ⱎ겾|@t\"#햊1|稃 섭)띜=뻔ꡜ???櫎~*ῡ꫌/繣ﻠq": null
-                                                                                                                                                                                     }
-                                                                                                                                                                                    ]}
-                                                                                                                                                                                   ]},
-                                                                                                                                                                                   "츤": false
-                                                                                                                                                                                  }},
-                                                                                                                                                                                  "s": 3.7339341963399598E18
-                                                                                                                                                                                 }
-                                                                                                                                                                                ],
-                                                                                                                                                                                "N,I?1+㢓|ࣱ嶃쩥V2\u0012(4EE虪朶$|w颇v步": "~읢~_,Mzr㐫YB溓E淚\"ⅹ䈔ᏺ抙 b,nt5V㐒J檶ꏨ⻔?",
-                                                                                                                                                                                "Q껑ꡡ}$넎qH煔惍/ez^!ẳF댙䝌馻剁8": "梲;yt钰$i冄}AL%a j뜐奷걳뚾d꿽*ሬuDY3?뮟鼯뮟w㍪틱V",
-                                                                                                                                                                                "o{Q/K O胟㍏zUdꀐm&⨺J舕⾏魸訟㌥[T籨櫉唐킝 aṭ뱫촙莛>碶覆⧬짙쭰ׯdAiH໥벤퐥_恸[ 0e:죃TC弼荎뵁DA:w唵ꣁ": null,
-                                                                                                                                                                                "὏樎䵮軧|?౗aWH쩃1 ꅭsu": null
-                                                                                                                                                                               }
-                                                                                                                                                                              ]
-                                                                                                                                                                             },
-                                                                                                                                                                             "勂\\&m鰈J釮=Ⲽ鳋+䂡郑": null,
-                                                                                                                                                                             "殣b綊倶5㥗惢⳷萢ᑀ䬄镧M^ﱴ3⣢翣n櫻1㨵}ኯ뗙顖Z.Q➷ꮨ뗇\u0004": "ꔙ䁼>n^[GीA䨟AM琢ᒊS쨲w?d㶣젊嘶纝麓+愣a%気ྞSc됓ᔘ:8bM7Xd8㶑臌]Ꙥ0ꐭ쒙䫣挵C薽Dfⵃ떼᷸",
-                                                                                                                                                                             "?紡.셪_෨j\u0013Ox┠$Xᶨ-ᅇo薹-}軫;y毝㪜K㣁?.EV쮱4둽⛻䤜'2盡\u001f60(|e쐰㼎ᦀ㒧-$l@ﻑ坳\u0003䭱响巗WFo5c㧆T턁Y맸♤(": -2.50917882560589088E17
-                                                                                                                                                                            }}
-                                                                                                                                                                           ],
-                                                                                                                                                                           "侸\\릩.᳠뎠狣살cs项䭩畳H1s瀉븇19?.w骴崖㤊h痠볭㞳㞳䁮Ql怠㦵": "@䟴-=7f",
-                                                                                                                                                                           "鹟1x௢+d ;vi䭴FSDS\u0004hꎹ㚍?⒍⦏ў6u,扩@됷Su)Pag휛TᒗV痩!瞏釀ꖞ蘥&ೞ蘐ꭰꞇᝎ": "ah懱Ժ&\u20f7䵅♎඀䞧鿪굛ౕ湚粎蚵ᯋ幌YOE)५襦㊝Y*^\"R+ඈ咷蝶9ꥂ榨艦멎헦閝돶v좛咊E)K㓷ྭr",
-                                                                                                                                                                           "搆q쮦4綱켙셁.f4<\/g<籽늷?#蚴픘:fF\u00051㹉뀭.ᰖ풎f֦Hv蔎㧤.!䭽=鞽]음H:?\"-4": 8.740133984938656E-20
-                                                                                                                                                                          }]}
-                                                                                                                                                                         }
-                                                                                                                                                                        ],
-                                                                                                                                                                        "tVKn딩꘥⊾蹓᤹{\u0003lR꼽ᄲQFᅏ傅ﱋ猢⤊ᔁ,E㓒秤nTතv`♛I\u0000]꫔ṞD\"麵c踝杰X&濿또꣹깳౥葂鿎\\aꡨ?": 3900062609292104525
-                                                                                                                                                                       }
-                                                                                                                                                                      ],
-                                                                                                                                                                      "ਉ샒⊩Lu@S䧰^g": -1.1487677090371648E18,
-                                                                                                                                                                      "⎢k⑊꬗yᏫ7^err糎Dt\u000bJ礯확ㆍ沑ｻꋽe赔㝢^J\u0004笲㿋idra剰-᪉C錇/Ĝ䂾ညS지?~콮gR敉⬹'䧭": 1901472137232418266,
-                                                                                                                                                                      "灗k䶥:?촽贍쓉꓈㒸g獘[뵎\\胕?\u0014_榙p.j稶,$`糉妋0>Fᡰly㘽$?": "]ꙛO赎&#㠃돱剳\"<◆>0誉齐_|z|裵씪>ᐌ㼍\"Z[琕}O?G뚇諦cs⠜撺5cu痑U圲\u001c?鴴計l춥/╓哼䄗茏ꮅ뫈댽A돌롖뤫V窗讬sHd&\nOi;_u"
-                                                                                                                                                                     }
-                                                                                                                                                                    ],
-                                                                                                                                                                    "Uﺗ\\Y\\梷䄬~\u0002": null,
-                                                                                                                                                                    "k\"Y磓ᗔ휎@U冈<\/w컑)[": false,
-                                                                                                                                                                    "曏J蝷⌻덦\u001f㙳s꥓⍟邫P늮쥄c∬ྡྷ舆렮칤Z趣5콡넛A쳨\\뀙骫(棻.*&輛LiIfi{@EA婳KᬰTXT": -4.3088230431977587E17
-                                                                                                                                                                   }]}
-                                                                                                                                                                  ]
-                                                                                                                                                                 ],
-                                                                                                                                                                 "곃㲧<\/dఓꂟs其ࡧ&N葶=?c㠤Ჴ'횠숄臼#\u001a~": false
-                                                                                                                                                                }
-                                                                                                                                                               ]
-                                                                                                                                                              ]}]
-                                                                                                                                                             }]
-                                                                                                                                                            }}
-                                                                                                                                                           ],
-                                                                                                                                                           "2f`⽰E쵟>J笂裭!〛觬囀ۺ쟰#桊l鹛ⲋ|RA_Vx፭gE됓h﵀mfỐ|?juTU档[d⢼⺻p濚7E峿": 5613688852456817133
-                                                                                                                                                          },
-                                                                                                                                                          "濘끶g忮7㏵殬W팕Q曁 뫰)惃廊5%-蹚zYZ樭ﴷQ锘쯤崫gg": true,
-                                                                                                                                                          "絥ᇑ⦏쒓븣爚H.㗊߄o蘵貆ꂚ(쎔O᥉ﮓ]姨Wꁓ!RMA|o퉢THx轮7M껁U즨'i뾘舯o": "跥f꜃?"
-                                                                                                                                                         }}
-                                                                                                                                                        ],
-                                                                                                                                                        "鷰鹮K-9k;ﰰ?_ݦѷ-ꅣ䩨Zꥱ\"mꠟ屎/콑Y╘2&鸞脇㏢ꀇ࠺ⰼ拾喭틮L꽩bt俸墶 [l/웄\"꾦\u20d3iও-&+\u000fQ+໱뵞": -1.296494662286671E-19
-                                                                                                                                                       },
-                                                                                                                                                       "HX੹/⨇୕붷Uﮘ旧\\쾜͔3l鄈磣糂̖䟎Eᐳw橖b῀_딕hu葰窳闹вU颵|染H죶.fP䗮:j䫢\\b뎖i燕ꜚG⮠W-≚뉗l趕": "ଊ칭Oa᡺$IV㷧L\u0019脴셀붿餲햪$迳向쐯켂PqfT\" ?I屉鴼쿕@硙z^鏕㊵M}㚛T젣쓌-W⩐-g%⺵<뮱~빅╴瑿浂脬\u0005왦燲4Ⴭb|D堧 <\/oEQh",
-                                                                                                                                                       "䘶#㥘੐캔f巋ἡAJ䢚쭈ࣨ뫒*mᇊK，ࣺAꑱ\u000bR<\/A\"1a6鵌㯀bh곿w(\"$ꘁ*rಐ趣.d࿩k/抶면䒎9W⊃9": "漩b挋Sw藎\u0000",
-                                                                                                                                                       "畀e㨼mK꙼HglKb,\"'䤜": null
-                                                                                                                                                      }]}]
-                                                                                                                                                     ]
-                                                                                                                                                    ]
-                                                                                                                                                   }]
-                                                                                                                                                  ]}
-                                                                                                                                                 ]
-                                                                                                                                                ]}
-                                                                                                                                               ],
-                                                                                                                                               "歙>駿ꣂ숰Q`J΋方樛(d鱾뼣(뫖턭\u20f9lচ9歌8o]8윶l얶?镖G摄탗6폋폵+g:䱫홊<멀뀿/س|ꭺs걐跶稚W々c㫣⎖": "㣮蔊깚Cꓔ舊|XRf遻㆚︆'쾉췝\\&言",
-                                                                                                                                               "殭\"cށɨꝙ䞘:嬮e潽Y펪㳅/\"O@ࠗ겴]췖YǞ(t>R\"N?梳LD恭=n氯T豰2R諸#N}*灧4}㶊G䍣b얚": null,
-                                                                                                                                               "襞<\/啧 B|싞W瓇)6簭鼡艆lN쩝`|펭佡\\間邝[z릶&쭟愱ꅅ\\T᰽1鯯偐栈4̸s윜R7⒝/똽?치X": "⏊躖Cﱰ2Qẫ脐&இ?%냝悊",
-                                                                                                                                               ",鰧偵셣싹xᎹ힨᯳EṬH㹖9": -4604276727380542356
-                                                                                                                                              }
-                                                                                                                                             }
-                                                                                                                                            ]]]],
-                                                                                                                                            "웺㚑xs}q䭵䪠馯8?LB犯zK'os䚛HZ\"L?셎s^㿧㴘Cv2": null
-                                                                                                                                           }]
-                                                                                                                                          ]
-                                                                                                                                         ]
-                                                                                                                                        ],
-                                                                                                                                        "Kd2Kv+|z": 7367845130646124107,
-                                                                                                                                        "ᦂⶨ?ᝢ 祂些ഷ牢㋇操\"腭䙾㖪\\(y4cE뽺ㆷ쫺ᔖ%zfۻ$ў1柦,㶢9r漢": -3.133230960444846E-20,
-                                                                                                                                        "琘M焀q%㢟f鸯O⣏蓑맕鯊$O噷|)z褫^㢦⠮ꚯ꫞`毕1qꢚ{ĭ䎀বώT\"뱘3G൴?^^of": null
-                                                                                                                                       }
-                                                                                                                                      ],
-                                                                                                                                      "a8V᯺?:ﺃ/8ꉿBq|9啓댚;*i2": null,
-                                                                                                                                      "cpT瀇H珰Ừpೃi鎪Rr␣숬-鹸ҩ䠚z脚цGoN8入y%趌I┽2ឪЀiJNcN)槣/▟6S숆牟\"箑X僛G殱娇葱T%杻:J諹昰qV쨰": 8331037591040855245
-                                                                                                                                     }],
-                                                                                                                                     "G5ᩜ䄗巢껳": true
-                                                                                                                                    }
-                                                                                                                                   },
-                                                                                                                                   "Ồ巢ゕ@_譙A`碫鄐㡥砄㠓(^K": "?܃B혢▦@犑ὺD~T⧁|醁;o=J牌9냚⢽㨘{4觍蚔9#$∺\u0016p囅\\3Xk阖⪚\"UzA穕롬✎➁㭒춺C㣌ဉ\"2瓑员ᅽꝶ뫍}꽚ꞇ鶂舟彺]ꍽJC蝧銉",
-                                                                                                                                   "␆Ě膝\"b-퉐ACR言J謈53~V튥x䜢?ꃽɄY뮩ꚜ": "K/↾e萃}]Bs⾿q룅鷦-膋?m+死^魊镲6",
-                                                                                                                                   "粡霦c枋AHퟁo礼Ke?qWcA趸㡔ꂏ?\u000e춂8iতᦜ婪\u0015㢼nﵿꍻ!ᐴ関\u001d5j㨻gfῩUK5Ju丝tかTI'?㓏t>⼟o a>i}ᰗ;뤕ܝ": false,
-                                                                                                                                   "ꄮ匴껢ꂰ涽+䜨B蛹H䛓-k蕞fu7kL谖,'涃V~챳逋穞cT\"vQ쓕ObaCRQ㓡Ⲯ?轭⫦輢墳?vA餽=h䮇킵n폲퉅喙?\"'1疬V嬗Qd灗'Lự": "6v!s믁㭟㣯獃!磸餠ቂh0C뿯봗F鷭gꖶ~ｺkK<ᦈTt\\跓w㭣횋钘ᆹ듡䑚W䟾X'ꅔ4FL勉Vܴ邨y)2'〚쭉⽵-鞣E,Q.?块",
-                                                                                                                                   "?(˧쩯@崟吋歄K": null
-                                                                                                                                  },
-                                                                                                                                  "Gc럃녧>?2DYI鴿\\륨)澔0ᔬlx'觔7젘⤡縷螩%Sv׫묈/]↱&S h\u0006歋ᑛxi̘}ひY蔯_醨鯘煑橾8?䵎쨋z儬ꁏ*@츾:": null
-                                                                                                                                 }
-                                                                                                                                }
-                                                                                                                               }
-                                                                                                                              ]
-                                                                                                                             ]
-                                                                                                                            ]}
-                                                                                                                           },
-                                                                                                                           "HO츧G": 3.694949578823609E17,
-                                                                                                                           "QC\u0012(翻曇Tf㷟bGBJ옉53\\嚇ᛎD/\u001b夾၉4\"핀@祎)쫆yD\"i먎Vn㿿V1W᨝䶀": -6150931500380982286,
-                                                                                                                           "Z㓮P翸鍱鉼K䋞꘺튿⭁Y": -7704503411315138850,
-                                                                                                                           "]모开ꬖP븣c霤<[3aΠ\"黁䖖䰑뮋ꤦ秽∼㑷冹T+YUt\"싳F↭䖏&鋌": -2.7231911483181824E18,
-                                                                                                                           "tꎖ": -4.9517948741799555E-19,
-                                                                                                                           "䋘즊.⬅IꬃۣQ챢ꄑ黐|f?C⾺|兕읯sC鬸섾整腨솷V": "旆柩l<K髝M戶鯮t:wR2ꉱ`9'l픪*폍芦㊢Pjjo堡^  읇얛嶅있ষ0?F",
-                                                                                                                           "下9T挞\\$yᮇk쌋⼇,ਉ": true,
-                                                                                                                           "櫨:ㆣ,邍lr崕祜㐮烜Z,XXD蕼㉴ kM꯽?P0﹉릗": null,
-                                                                                                                           "gv솠歽閘4镳䗄2澾>쪦sᖸMy㦅울썉瘗㎜檵9ꍂ駓ૉᚿ/u3씅徐拉[Z䞸ࡗ1ꆱ&Ｑ풘?ǂ8\u0011BCDY2볨;鸏": null,
-                                                                                                                           "幫 n煥s쁇펇 왊-$C\"衝:\u0014㣯舼.3뙗Yl⋇\"K迎멎[꽵s}9鉳UK8쐥\"掄㹖h㙈!얄સ?Ꜳ봺R伕UTD媚Ｉ䜘W鏨蔮": -4.150842714188901E-17,
-                                                                                                                           "ﺯ^㄄\b죵@fྉkf颡팋Ꞧ{/Pm0V둳⻿/落韒ꊔᚬ@5螺G\\咸a谆⊪ቧ慷绖?财(鷇u錝F=r၍橢ឳn:^iᴵtD볠覅N赴": null
-                                                                                                                          }]
-                                                                                                                         }]
-                                                                                                                        }
-                                                                                                                       ]
-                                                                                                                      ]}
-                                                                                                                     ]},
-                                                                                                                     "謯?w厓奰T李헗聝ឍ貖o⪇弒L!캶$ᆅ": -4299324168507841322,
-                                                                                                                     "뺊奉_垐浸延몏孄Z舰2i$q붿좾껇d▵餏\"v暜Ҭ섁m￴g>": -1.60911932510533427E18
-                                                                                                                    }
-                                                                                                                   ]
-                                                                                                                  }
-                                                                                                                 ]
-                                                                                                                ]],
-                                                                                                                "퉝꺔㠦楶Pꅱ": 7517896876489142899,
-                                                                                                                "": false
-                                                                                                               }
-                                                                                                              ]},
-                                                                                                              "是u&I狻餼|谖j\"7c됮sסּ-踳鉷`䣷쉄_A艣鳞凃*m⯾☦椿q㎭N溔铉tlㆈ^": 1.93547720203604352E18,
-                                                                                                              "kⲨ\\%vr#\u000bⒺY\\t<\/3﬌R訤='﹠8蝤Ꞵ렴曔r": false
-                                                                                                             }
-                                                                                                            ]},
-                                                                                                            "阨{c?C\u001d~K?鎌Ԭ8烫#뙣P초遗t㭱E­돒䆺}甗[R*1!\\~h㕅᰺@<9JꏏષI䳖栭6綘걹ￌM\"▯是∔v鬽顭⋊譬": "운ﶁK敂(欖C취پ℄爦賾"
-                                                                                                           }
-                                                                                                          }}
-                                                                                                         }],
-                                                                                                         "鷨赼鸙+\\䭣t圙ڹx᜾ČN<\/踘\"S_맶a鷺漇T彚⎲i㈥LT-xA캔$\u001cUH=a0츺l릦": "溣㣂0濕=鉵氬駘>Pꌢpb솇쬤h힊줎獪㪬CrQ矠a&脍꼬爼M茴/΅\u0017弝轼y#Ꞡc6둴=?R崏뷠麖w?"
-                                                                                                        },
-                                                                                                        "閕ᘜ]CT)䵞l9z'xZF{:ؐI/躅匽졁:䟇AGF૸\u001cퟗ9)駬慟ꡒꆒRS״툋A<>\u0010\"ꂔ炃7g덚E৏bꅰ輤]o㱏_뷕ܘ暂\"u": "芢+U^+㢩^鱆8*1鈶鮀\u0002뺰9⬳ꪮlL䃣괟,G8\u20a8DF㉪錖0ㄤ瓶8Nଷd?眡GLc陓\\_죌V쁰ल二?c띦捱 \u0019JC\u0011b⤉zẒT볕\"绣蘨뚋cꡉkI\u001e鳴",
-                                                                                                        "ꃣI'{6u^㡃#཰Kq4逹y൒䧠䵮!㱙/n??{L풓ZET㙠퍿X2᩟綳跠葿㚙w཮x캽扳B唕S|尾}촕%N?o䪨": null,
-                                                                                                        "ⰴFjෟ셈[\u0018辷px?椯\\1<ﲻ栘ᣁ봢憠뉴p": -5263694954586507640
-                                                                                                       }
-                                                                                                      ]
-                                                                                                     ]]
-                                                                                                    ]}
-                                                                                                   ]}]
-                                                                                                  ]
-                                                                                                 ],
-                                                                                                 "?#癘82禩鋆ꊝty?&": -1.9419029518535086E-19
-                                                                                                }
-                                                                                               ]
-                                                                                              ]
-                                                                                             ]}
-                                                                                            ]
-                                                                                           ]
-                                                                                          ],
-                                                                                          "훊榲.|῕戄&.㚏Zꛦ2\"䢥ሆ⤢fV_摕婔?≍Fji冀탆꜕i㏬_ẑKᅢ꫄蔻XWc|饡Siẘ^㲦?羡2ぴ1縁ᙅ?쐉Ou": false
-                                                                                         }]]
-                                                                                        ]}}},
-                                                                                        "慂뗄卓蓔ᐓ匐嚖/颹蘯/翻ㆼL?뇊,텵<\\獷ごCボ": null
-                                                                                       },
-                                                                                       "p溉ᑟi짣z:䒤棇r^٫%G9缑r砌롧.물农g?0׼ሩ4ƸO㣥㯄쩞ጩ": null,
-                                                                                       "껎繥YxK\"F젷쨹뤤1wq轫o?鱑뜀瘊?뎃h灑\\ꛣ}K峐^ኖ⤐林ꉓhy": null
-                                                                                      }
-                                                                                     ],
-                                                                                     "᱀n肓ㄛ\"堻2>m殮'1橌%Ꞵ군=Ӳ鯨9耛<\/n據0u彘8㬇៩f᏿诙]嚊": "䋯쪦S럶匏ㅛ#)O`ሀX_鐪渲⛀㨻宅闩➈ꢙஶDR⪍"
-                                                                                    },
-                                                                                    "tA썓龇 ⋥bj왎录r땽✒롰;羋^\\?툳*┎?썀ma䵳넅U䳆૘〹䆀LQ0\b疀U~u$M}(鵸g⳾i抦뛹?䤈땚검.鹆?ꩡtⶥGĒ;!ቹHS峻B츪켏f5≺": 2366175040075384032,
-                                                                                    "전pJjleb]ួ": -7.5418493141528422E18,
-                                                                                    "n.鎖ጲ\n?,$䪘": true
-                                                                                   },
-                                                                                   "欈Ar㉣螵᪚茩?O)": null
-                                                                                  },
-                                                                                  "쫸M#x}D秱欐K=侫们丐.KꕾxẠ\u001e㿯䣛F܍캗qq8꟞ṢFD훎⵳簕꭛^鳜\u205c٫~⑟~冫ऊ2쫰<\/戲윱o<\"": true
-                                                                                 },
-                                                                                 "㷝聥/T뱂\u0010锕|内䞇x侁≦㭖:M?iM᣿IJe煜dG࣯尃⚩gPt*辂.{磼럾䝪@a\\袛?}ᓺB珼": true
-                                                                                }
-                                                                               }
-                                                                              ]]}]}},
-                                                                              "tn\"6ꫤ샾䄄;銞^%VBPwu묪`Y僑N.↺Ws?3C⤻9唩S䠮ᐴm;sᇷ냞඘B/;툥B?lB∤)G+O9m裢0kC햪䪤": -4.5941249382502277E18,
-                                                                              "ᚔt'\\愫?鵀@\\びꂕP큠<<]煹G-b!S?\nꖽ鼫,ݛ&頺y踦?E揆릱H}햧캡b@手.p탻>췽㣬ꒅ`qe佭P>ᓂ&?u}毚ᜉ蟶頳졪ᎏzl2wO": -2.53561440423275936E17
-                                                                             }]}
-                                                                            }
-                                                                           ]
-                                                                          ]],
-                                                                          "潈촒⿂叡": 5495738871964062986
-                                                                         }
-                                                                        ]]
-                                                                       }
-                                                                      ]
-                                                                     ]}
-                                                                    ]]
-                                                                   ]]
-                                                                  ]}
-                                                                 ]
-                                                                ]},
-                                                                "ႁq킍蓅R`謈蟐ᦏ儂槐僻ﹶ9婌櫞釈~\"%匹躾ɢ뤥>࢟瀴愅?殕节/냔O✬H鲽엢?ᮈੁ⋧d␽㫐zCe*": 2.15062231586689536E17,
-                                                                "㶵Ui曚珰鋪ᾼ臧P{䍏䷪쨑̟A뼿T渠誈䏚D1!잶<\/㡍7?)2l≣穷᛾稝{:;㡹nemיּ訊`G": null,
-                                                                "䀕\"飕辭p圁f#뫆䶷뛮;⛴ᩍ3灚덏ᰝ쎓⦷詵%᜖Մfs⇫(\u001e~P|ﭗCⲾផv湟W첋(텪બT<บSꏉ੗⋲X婵i ӵ⇮?L䬇|ꈏ?졸": 1.548341247351782E-19
-                                                               }
-                                                              ]
-                                                             },
-                                                             "t;:N\u0015q鐦Rt缆{ꮐC?஛㷱敪\\+鲊㉫㓪몗릙竏(氵kYS": "XᰂT?൮ô",
-                                                             "碕飦幑|+ 㚦鏶`镥ꁩ B<\/加륙": -4314053432419755959,
-                                                             "秌孳(p!G?V傫%8ሽ8w;5鲗㦙LI檸\u2098": "zG N볞䆭鎍흘\\ONK3횙<\/樚立圌Q튅k쩎Ff쁋aׂJK銆ઘ즐狩6༥✙䩜篥CzP(聻駇HHퟲ讃%,ά{렍p而刲vy䦅ክ^톺M楒鍢㹳]Mdg2>䤉洞",
-                                                             "踛M젧>忔芿㌜Zk": 2215369545966507819,
-                                                             "씐A`$槭頰퍻^U覒\bG毲aᣴU;8!팲f꜇E⸃_卵{嫏羃X쀳C7뗮m(嚼u N܁谟D劯9]#": true,
-                                                             "ﻩ!뵸-筚P᭛}ἰ履lPh?౮ⶹꆛ穉뎃g萑㑓溢CX뾇G㖬A錟]RKaꄘ]Yo+@䘁's섎襠$^홰}F": null
-                                                            },
-                                                            "粘ꪒ4HXᕘ蹵.$區\r\u001d묁77pPc^y笲Q<\/ꖶ 訍䃍ᨕG?*": 1.73773035935040224E17
-                                                           },
-                                                           "婅拳?bkU;#D矠❴vVN쩆t㜷A풃갮娪a%鮏絪3dAv룒#tm쑬⌛qYwc4|L8KZ;xU⓭㳔밆拓EZ7襨eD|隰ऌ䧼u9Ԣ+]贴P荿": 2.9628516456987075E18
-                                                          }]}}]
-                                                         ]}
-                                                        }}
-                                                       ]}]
-                                                      ],
-                                                      "|g翉F*湹̶\u0005⏐1脉̀eI쩓ᖂ㫱0碞l䴨ꑅ㵽7AtἈ턧yq䳥塑:z:遀ﾼX눔擉)`N3昛oQ셖y-ڨ⾶恢ꈵq^<\/": null,
-                                                      "菹\\랓G^璬x৴뭸ゆUS겧﮷Bꮤ ┉銜᯻0%N7}~f洋坄Xꔼ<\/4妟Vꄟ9:౟곡t킅冩䧉笭裟炂4봋ⱳ叺怊t+怯涗\"0㖈Hq": false,
-                                                      "졬믟'ﺇফ圪쓬멤m邸QLব䗁愍4jvs翙 ྍ꧀艳H-|": null,
-                                                      "컮襱⣱뗠 R毪/鹙꾀%헳8&": -5770986448525107020
-                                                     }
-                                                    ],
-                                                    "B䔚bꐻ뙏姓展槰T-똌鷺tc灿᫽^㓟䏀o3o$꘭趙萬I顩)뇭Ἑ䓝\f@{ᣨ`x3蔛": null
-                                                   }
-                                                  ]
-                                                 ]
-                                                }],
-                                                "⦖扚vWꃱ꥙㾠壢輓{-⎳鹷贏璿䜑bG倛⋐磎c皇皩7a~ﳫU╣Q࠭ꎉS摅姽OW.홌ೞ.": null,
-                                                "蚪eVlH献r}ᮏ믠ﰩꔄ@瑄ⲱ": null,
-                                                "퀭$JWoꩢg역쁍䖔㑺h&ୢtXX愰㱇?㾫I_6 OaB瑈q裿": null,
-                                                "꽦ﲼLyr纛Zdu珍B絟쬴糔?㕂짹䏵e": "ḱ\u2009cX9멀i䶛簆㳀k"
-                                               }
-                                              ]]]],
-                                              "(_ꏮg່澮?ᩑyM<艷\u001aꪽ\\庼뙭Z맷㰩Vm\\lY筺]3㋲2㌩㄀Eਟ䝵⨄쐨ᔟgङHn鐖⤇놋瓇Q탚單oY\"♆臾jHᶈ征ቄ??uㇰA?#1侓": null
-                                             },
-                                             "觓^~ሢ&iI띆g륎ḱ캀.ᓡꀮ胙鈉": 1.0664523593012836E-19,
-                                             "y詭Gbᔶऽs댁U:杜⤎ϲ쁗⮼D醄诿q뙰I#즧v蔎xHᵿt᡽[**?崮耖p缫쿃L菝,봬ꤦC쯵#=X1瞻@OZc鱗CQTx": null
-                                            }
-                                           ]
-                                          }}],
-                                          "剘紁\u0004\\Xn⊠6,တױ;嵣崇}讃iႽ)d1\\䔓": null
-                                         },
-                                         "脨z\"{X,1u찜<'k&@?1}Yn$\u0015Rd輲ｰa쮂굄+B$l": true,
-                                         "諳>*쭮괐䵟Ґ+<箁}빀䅱⡔檏臒hIH脟ꩪC핝ଗP좕\"0i<\/C褻D۞恗+^5?'ꂱ䚫^7}㡠cq6\\쨪ꔞꥢ?纖䫀氮蒫侲빦敶q{A煲G": -6880961710038544266
-                                        }}]
-                                       },
-                                       "5s⨲JvಽῶꭂᄢI.a৊": null,
-                                       "?1q꽏쿻ꛋDR%U娝>DgN乭G": -1.2105047302732358E-19
-                                      }
-                                     ]
-                                    ]},
-                                    "qZz`撋뙹둣j碇쁏\\ꆥ\u0018@藴疰Wz)O{F䶛l᷂绘訥$]뮍夻䢋䩇萿獰樧猵⣭j萶q)$꬚⵷0馢W:Ⱍ!Qoe": -1666634370862219540,
-                                    "t": "=wp|~碎Q鬳Ӎ\\l-<\/^ﳊhn퐖}䍔t碵ḛ혷?靻䊗",
-                                    "邙쇡㯇%#=,E4勃驆V繚q[Y댻XV㡸[逹ᰏ葢B@u=JS5?bLRn얮㍉⏅ﰳ?a6[&큟!藈": 1.2722786745736667E-19
-                                   },
-                                   "X블땨4{ph鵋ꉯ웸 5p簂䦭s_E徔濧d稝~No穔噕뽲)뉈c5M윅>⚋[岦䲟懷恁?鎐꓆ฬ爋獠䜔s{\u001bm鐚儸煛%bﯿXT>ꗘ@8G": 1157841540507770724,
-                                   "媤娪Q杸\u0011SAyᡈ쿯": true,
-                                   "灚^ಸ%걁<\/蛯<O\"-刷㏠R(kO=䢊䅎l䰓팪A絫픧": "譔\\㚄 ?R7㔪G㋉⣰渆?\\#|gN⤴;W칷A׫癮଼ೣ㏳뒜7d恓꾲0扬S0ᆵi/贎ྡn䆋武",
-                                   "萇砇Gこ朦켋Wq`㞲攊*冁~霓L剢zI腧튴T繙Cঅ뫬╈뮜ㄾ䦧촄椘B⊬츩r2f㶱厊8eϬ{挚␯OM焄覤\\(Kӡ>?\"祴坓\\\\'흍": -3.4614808555942579E18,
-                                   "釴U:O湛㴑䀣렑縓\ta)<D8ﭳ槁髭D.L|xs斋敠\"띋早7wᎍ": true,
-                                   "쵈+쬎簨up䓬?q+~\u0019仇뵈᫯3ᵣ恘枰劫㪢u珘-퀭:컙:u`⌿A(9鄦!<珚nj3:Hࣨ巋䀁旸뎈맻v\"\\(곘vO㤰aZe<\/W鹙鄜;l厮둝": null,
-                                   "": -1.2019926774977002E-18,
-                                   "%者O7.Nꪍs梇接z蕜綛<\/䜭\"죊y<曋漵@Ś⹝sD⟓jݗᢜ?z/9ၲMa쨮긗贎8ᔮ㦛;6p뾥໭䭊0B찛+)(Y㿠鸁䕒^옥": "鬃뫤&痽舎J콮藐󽸰ᨨMꈫ髿v<N\\.삒껅я1ꭼ5䴷5쳬臨wj덥"
-                                  }],
-                                  "鷎'㳗@帚妇OAj' 谬f94ǯ(횡ﾋ%io쪖삐좛>(j:숾却䗌gCiB뽬Oyuq輥厁/7)?今hY︺Q": null
-                                 }
-                                ]
-                               ]]]}]
-                              ],
-                              "I笔趠Ph!<ཛྷ㸞诘X$畉F\u0005笷菟.Esr릙!W☆䲖뗷莾뒭U\"䀸犜Uo3Gꯌx4r蔇᡹㧪쨢準<䂀%ࡡꟼ瑍8炝Xs0䀝销?fi쥱ꆝલBB": -8571484181158525797,
-                              "L⦁o#J|\"⽩-㱢d㌛8d\\㶤傩儻E[Y熯)r噤὘勇 }": "e(濨쓌K䧚僒㘍蠤Vᛸ\"络QJL2,嬓왍伢㋒䴿考澰@(㏾`kX$끑эE斡,蜍&~y",
-                              "vj.|统圪ᵮPL?2oŶ`밧\"勃+0ue%⿥绬췈체$6:qa렐Q;~晘3㙘鹑": true,
-                              "ශؙ4獄⶿c︋i⚅:ん閝Ⳙ苆籦kw{䙞셕pC췃ꍬ␜꟯ꚓ酄b힝hwk꭭M鬋8B耳쑘WQ\\偙ac'唀x᪌\u2048*h짎#ፇ鮠뾏ឿ뀌": false,
-                              "⎀jꄒ牺3Ⓝ컴~?親ꕽぼܓ喏瘘!@<튋㐌꿱⩦{a?Yv%⪧笯Uܱ栅E搚i뚬:ꄃx7䙳ꦋ&䓹vq☶I䁘ᾘ涜\\썉뺌Lr%Bc㍜3?ꝭ砿裞]": null,
-                              "⭤뙓z(㡂%亳K䌽꫿AԾ岺㦦㼴輞낚Vꦴw냟鬓㹈뽈+o3譻K1잞": 2091209026076965894,
-                              "ㇲ\t⋇轑ꠤ룫X긒\"zoY읇희wj梐쐑l侸`e%s": -9.9240075473576563E17,
-                              "啸ꮑ㉰!ᚓ}銏": -4.0694813896301194E18,
-                              ">]囋੽EK뇜>_ꀣ緳碖{쐐裔[<ನ\"䇅\"5L?#xTwv#罐\u0005래t应\\N?빗;": "v쮽瞭p뭃"
-                             }
-                            ]],
-                            "斴槾?Z翁\"~慍弞ﻆ=꜡o5鐋dw\"?K蠡i샾ogDﲰ_C*⬟iㇷ4nય蟏[㟉U꽌娛苸 ঢ়操贻洞펻)쿗૊許X⨪VY츚Z䍾㶭~튃ᵦ<\/E臭tve猑x嚢": null,
-                            "锡⛩<\/칥ꈙᬙ蝀&Ꚑ籬■865?_>L詏쿨䈌浿弥爫̫lj&zx<\/C쉾?覯n?": null,
-                            "꾳鑤/꼩d=ᘈn挫ᑩ䰬ZC": "3錢爋6Ƹ䴗v⪿Wr益G韠[\u0010屗9쁡钁u?殢c䳀蓃樄욂NAq赟c튒瘁렶Aૡɚ捍"
-                           }
-                          ]
-                         ]
-                        ]}
-                       ]
-                      ]
-                     }]]]}}
-                    ]}],
-                    "Ej䗳U<\/Q=灒샎䞦,堰頠@褙g_\u0003ꤾfⶽ?퇋!łB〙ד3CC䌴鈌U:뭔咎(Qો臃䡬荋BO7㢝䟸\"Yb": 2.36010731779814E-20,
-                    "逸'0岔j\u000e눘먷翌C츊秦=ꭣ棭ှ;鳸=麱$XP⩉駚橄A\\좱⛌jqv䰞3Ь踌v㳆¹gT┌gvLB賖烡m?@E঳i": null
-                   },
-                   "曺v찘ׁ?&绫O័": 9107241066550187880
-                  }
-                 ]
-                ],
-                "(e屄\u0019昜훕琖b蓘ᬄ0/۲묇Z蘮ဏ⨏蛘胯뢃@㘉8ሪWᨮ⦬ᅳ䅴HI၇쨳z囕陻엣1赳o": true,
-                ",b刈Z,ၠ晐T솝ŕB⩆ou'퐼≃绗雗d譊": null,
-                "a唥KB\"ﳝ肕$u\n^⅄P䟼냉䞸⩪u윗瀱ꔨ#yşs꒬=1|ﲤ爢`t౐튼쳫_Az(Ṋ擬㦷좕耈6": 2099309172767331582,
-                "?㴸U<\/䢔ꯡ阽扆㐤q鐋?f㔫wM嬙-;UV죫嚔픞G&\"Cᗍ䪏풊Q": "VM7疹+陕枡툩窲}翡䖶8欞čsT뮐}璤:jﺋ鎴}HfA൝⧻Zd#Qu茅J髒皣Y-︴[?-~쉜v딏璮㹚䅊﩯<-#\u000e걀h\u0004u抱﵊㼃U<㱷⊱IC進"
-               },
-               "숌dee節鏽邺p넱蹓+e罕U": true
-              }
-             ],
-             "b⧴룏??ᔠ3ぱ>%郿劃翐ꏬꠛW瞳᫏누躨狀ໄy੽\"ីuS=㨞馸k乆E": "トz݈^9R䬑<ﮛG<s~<\/?ⵆᏥ老熷u듷"
-            }}
-           ]
-          }
-         ]}
-        }
-       }
-      }
-     }},
-     "宩j鬅쳜QꝖјy獔Z᭵1v擖}䨿F%cֲ᫺贴m塼딚NP亪\"ￋsa뺯ꘓ2:9뛓༂쌅䊈#>Rꨳ\u000fTT泠纷꽀MR<CBxP񱒫X쇤": -2.22390568492330598E18,
-     "?䯣ᄽ@Z鸅->ᴱ纊:㠭볮?%N56%鈕1䗍䜁a䲗j陇=뿻偂衋࿘ᓸ?ᕵZ+<\/}H耢b䀁z^f$&㝒LkꢳI脚뙛u": 5.694374481577558E-20
-    }]
-   }
-  ]],
-  "obj": {"key": "wrong value"},
-  "퓲꽪m{㶩/뇿#⼢&᭙硞㪔E嚉c樱㬇1a綑᝖DḾ䝩": null
- }
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/webapp.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/webapp.json
deleted file mode 100644
index ee7b0f8..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/webapp.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{"web-app": {
-  "servlet": [   
-    {
-      "servlet-name": "cofaxCDS",
-      "servlet-class": "org.cofax.cds.CDSServlet",
-      "init-param": {
-        "configGlossary:installationAt": "Philadelphia, PA",
-        "configGlossary:adminEmail": "ksm@pobox.com",
-        "configGlossary:poweredBy": "Cofax",
-        "configGlossary:poweredByIcon": "/images/cofax.gif",
-        "configGlossary:staticPath": "/content/static",
-        "templateProcessorClass": "org.cofax.WysiwygTemplate",
-        "templateLoaderClass": "org.cofax.FilesTemplateLoader",
-        "templatePath": "templates",
-        "templateOverridePath": "",
-        "defaultListTemplate": "listTemplate.htm",
-        "defaultFileTemplate": "articleTemplate.htm",
-        "useJSP": false,
-        "jspListTemplate": "listTemplate.jsp",
-        "jspFileTemplate": "articleTemplate.jsp",
-        "cachePackageTagsTrack": 200,
-        "cachePackageTagsStore": 200,
-        "cachePackageTagsRefresh": 60,
-        "cacheTemplatesTrack": 100,
-        "cacheTemplatesStore": 50,
-        "cacheTemplatesRefresh": 15,
-        "cachePagesTrack": 200,
-        "cachePagesStore": 100,
-        "cachePagesRefresh": 10,
-        "cachePagesDirtyRead": 10,
-        "searchEngineListTemplate": "forSearchEnginesList.htm",
-        "searchEngineFileTemplate": "forSearchEngines.htm",
-        "searchEngineRobotsDb": "WEB-INF/robots.db",
-        "useDataStore": true,
-        "dataStoreClass": "org.cofax.SqlDataStore",
-        "redirectionClass": "org.cofax.SqlRedirection",
-        "dataStoreName": "cofax",
-        "dataStoreDriver": "com.microsoft.jdbc.sqlserver.SQLServerDriver",
-        "dataStoreUrl": "jdbc:microsoft:sqlserver://LOCALHOST:1433;DatabaseName=goon",
-        "dataStoreUser": "sa",
-        "dataStorePassword": "dataStoreTestQuery",
-        "dataStoreTestQuery": "SET NOCOUNT ON;select test='test';",
-        "dataStoreLogFile": "/usr/local/tomcat/logs/datastore.log",
-        "dataStoreInitConns": 10,
-        "dataStoreMaxConns": 100,
-        "dataStoreConnUsageLimit": 100,
-        "dataStoreLogLevel": "debug",
-        "maxUrlLength": 500}},
-    {
-      "servlet-name": "cofaxEmail",
-      "servlet-class": "org.cofax.cds.EmailServlet",
-      "init-param": {
-      "mailHost": "mail1",
-      "mailHostOverride": "mail2"}},
-    {
-      "servlet-name": "cofaxAdmin",
-      "servlet-class": "org.cofax.cds.AdminServlet"},
- 
-    {
-      "servlet-name": "fileServlet",
-      "servlet-class": "org.cofax.cds.FileServlet"},
-    {
-      "servlet-name": "cofaxTools",
-      "servlet-class": "org.cofax.cms.CofaxToolsServlet",
-      "init-param": {
-        "templatePath": "toolstemplates/",
-        "log": 1,
-        "logLocation": "/usr/local/tomcat/logs/CofaxTools.log",
-        "logMaxSize": "",
-        "dataLog": 1,
-        "dataLogLocation": "/usr/local/tomcat/logs/dataLog.log",
-        "dataLogMaxSize": "",
-        "removePageCache": "/content/admin/remove?cache=pages&id=",
-        "removeTemplateCache": "/content/admin/remove?cache=templates&id=",
-        "fileTransferFolder": "/usr/local/tomcat/webapps/content/fileTransferFolder",
-        "lookInContext": 1,
-        "adminGroupID": 4,
-        "betaServer": true}}],
-  "servlet-mapping": {
-    "cofaxCDS": "/",
-    "cofaxEmail": "/cofaxutil/aemail/*",
-    "cofaxAdmin": "/admin/*",
-    "fileServlet": "/static/*",
-    "cofaxTools": "/tools/*"},
- 
-  "taglib": {
-    "taglib-uri": "cofax.tld",
-    "taglib-location": "/WEB-INF/tlds/cofax.tld"}}}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/widget.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/widget.json
deleted file mode 100644
index 32690e8..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/data/widget.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{"widget": {
-    "debug": "on",
-    "window": {
-        "title": "Sample Konfabulator Widget",
-        "name": "main_window",
-        "width": 500,
-        "height": 500
-    },
-    "image": { 
-        "src": "Images/Sun.png",
-        "name": "sun1",
-        "hOffset": 250,
-        "vOffset": 250,
-        "alignment": "center"
-    },
-    "text": {
-        "data": "Click Here",
-        "size": 36,
-        "style": "bold",
-        "name": "text1",
-        "hOffset": 250,
-        "vOffset": 100,
-        "alignment": "center",
-        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
-    }
-}}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16be.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16be.json
deleted file mode 100644
index e46dbfb..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16be.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16bebom.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16bebom.json
deleted file mode 100644
index 0a23ae2..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16bebom.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16le.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16le.json
deleted file mode 100644
index 92d5045..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16le.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16lebom.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16lebom.json
deleted file mode 100644
index eaba001..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf16lebom.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32be.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32be.json
deleted file mode 100644
index 9cbb522..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32be.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32bebom.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32bebom.json
deleted file mode 100644
index bde6a99..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32bebom.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32le.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32le.json
deleted file mode 100644
index b00f290..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32le.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32lebom.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32lebom.json
deleted file mode 100644
index d3db39b..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf32lebom.json and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8.json
deleted file mode 100644
index c500c94..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"en":"I can eat glass and it doesn't hurt me.",
-	"zh-Hant":"我能吞下玻璃而不傷身體。",
-	"zh-Hans":"我能吞下玻璃而不伤身体。",
-	"ja":"私はガラスを食べられます。それは私を傷つけません。",
-	"ko":"나는 유리를 먹을 수 있어요. 그래도 아프지 않아요"
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8bom.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8bom.json
deleted file mode 100644
index b9839fe..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/encodings/utf8bom.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-	"en":"I can eat glass and it doesn't hurt me.",
-	"zh-Hant":"我能吞下玻璃而不傷身體。",
-	"zh-Hans":"我能吞下玻璃而不伤身体。",
-	"ja":"私はガラスを食べられます。それは私を傷つけません。",
-	"ko":"나는 유리를 먹을 수 있어요. 그래도 아프지 않아요"
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail1.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail1.json
deleted file mode 100644
index 6216b86..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail1.json
+++ /dev/null
@@ -1 +0,0 @@
-"A JSON payload should be an object or array, not a string."
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail10.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail10.json
deleted file mode 100644
index 5d8c004..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail10.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Extra value after close": true} "misplaced quoted value"
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail11.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail11.json
deleted file mode 100644
index 76eb95b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail11.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Illegal expression": 1 + 2}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail12.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail12.json
deleted file mode 100644
index 77580a4..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail12.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Illegal invocation": alert()}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail13.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail13.json
deleted file mode 100644
index 379406b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail13.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Numbers cannot have leading zeroes": 013}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail14.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail14.json
deleted file mode 100644
index 0ed366b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail14.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Numbers cannot be hex": 0x14}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail15.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail15.json
deleted file mode 100644
index fc8376b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail15.json
+++ /dev/null
@@ -1 +0,0 @@
-["Illegal backslash escape: \x15"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail16.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail16.json
deleted file mode 100644
index 3fe21d4..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail16.json
+++ /dev/null
@@ -1 +0,0 @@
-[\naked]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail17.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail17.json
deleted file mode 100644
index 62b9214..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail17.json
+++ /dev/null
@@ -1 +0,0 @@
-["Illegal backslash escape: \017"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail18.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail18.json
deleted file mode 100644
index edac927..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail18.json
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail19.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail19.json
deleted file mode 100644
index 3b9c46f..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail19.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Missing colon" null}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail2.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail2.json
deleted file mode 100644
index 6b7c11e..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail2.json
+++ /dev/null
@@ -1 +0,0 @@
-["Unclosed array"
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail20.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail20.json
deleted file mode 100644
index 27c1af3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail20.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Double colon":: null}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail21.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail21.json
deleted file mode 100644
index 6247457..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail21.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Comma instead of colon", null}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail22.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail22.json
deleted file mode 100644
index a775258..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail22.json
+++ /dev/null
@@ -1 +0,0 @@
-["Colon instead of comma": false]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail23.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail23.json
deleted file mode 100644
index 494add1..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail23.json
+++ /dev/null
@@ -1 +0,0 @@
-["Bad value", truth]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail24.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail24.json
deleted file mode 100644
index caff239..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail24.json
+++ /dev/null
@@ -1 +0,0 @@
-['single quote']
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail25.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail25.json
deleted file mode 100644
index 8b7ad23..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail25.json
+++ /dev/null
@@ -1 +0,0 @@
-["	tab	character	in	string	"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail26.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail26.json
deleted file mode 100644
index 845d26a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail26.json
+++ /dev/null
@@ -1 +0,0 @@
-["tab\   character\   in\  string\  "]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail27.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail27.json
deleted file mode 100644
index 6b01a2c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail27.json
+++ /dev/null
@@ -1,2 +0,0 @@
-["line
-break"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail28.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail28.json
deleted file mode 100644
index 621a010..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail28.json
+++ /dev/null
@@ -1,2 +0,0 @@
-["line\
-break"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail29.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail29.json
deleted file mode 100644
index 47ec421..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail29.json
+++ /dev/null
@@ -1 +0,0 @@
-[0e]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail3.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail3.json
deleted file mode 100644
index 168c81e..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail3.json
+++ /dev/null
@@ -1 +0,0 @@
-{unquoted_key: "keys must be quoted"}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail30.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail30.json
deleted file mode 100644
index 8ab0bc4..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail30.json
+++ /dev/null
@@ -1 +0,0 @@
-[0e+]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail31.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail31.json
deleted file mode 100644
index 1cce602..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail31.json
+++ /dev/null
@@ -1 +0,0 @@
-[0e+-1]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail32.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail32.json
deleted file mode 100644
index 45cba73..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail32.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Comma instead if closing brace": true,
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail33.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail33.json
deleted file mode 100644
index ca5eb19..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail33.json
+++ /dev/null
@@ -1 +0,0 @@
-["mismatch"}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail4.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail4.json
deleted file mode 100644
index 9de168b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail4.json
+++ /dev/null
@@ -1 +0,0 @@
-["extra comma",]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail5.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail5.json
deleted file mode 100644
index ddf3ce3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail5.json
+++ /dev/null
@@ -1 +0,0 @@
-["double extra comma",,]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail6.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail6.json
deleted file mode 100644
index ed91580..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail6.json
+++ /dev/null
@@ -1 +0,0 @@
-[   , "<-- missing value"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail7.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail7.json
deleted file mode 100644
index 8a96af3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail7.json
+++ /dev/null
@@ -1 +0,0 @@
-["Comma after the close"],
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail8.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail8.json
deleted file mode 100644
index b28479c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail8.json
+++ /dev/null
@@ -1 +0,0 @@
-["Extra close"]]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail9.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail9.json
deleted file mode 100644
index 5815574..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/fail9.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Extra comma": true,}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass1.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass1.json
deleted file mode 100644
index 70e2685..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass1.json
+++ /dev/null
@@ -1,58 +0,0 @@
-[
-    "JSON Test Pattern pass1",
-    {"object with 1 member":["array with 1 element"]},
-    {},
-    [],
-    -42,
-    true,
-    false,
-    null,
-    {
-        "integer": 1234567890,
-        "real": -9876.543210,
-        "e": 0.123456789e-12,
-        "E": 1.234567890E+34,
-        "":  23456789012E66,
-        "zero": 0,
-        "one": 1,
-        "space": " ",
-        "quote": "\"",
-        "backslash": "\\",
-        "controls": "\b\f\n\r\t",
-        "slash": "/ & \/",
-        "alpha": "abcdefghijklmnopqrstuvwyz",
-        "ALPHA": "ABCDEFGHIJKLMNOPQRSTUVWYZ",
-        "digit": "0123456789",
-        "0123456789": "digit",
-        "special": "`1~!@#$%^&*()_+-={':[,]}|;.</>?",
-        "hex": "\u0123\u4567\u89AB\uCDEF\uabcd\uef4A",
-        "true": true,
-        "false": false,
-        "null": null,
-        "array":[  ],
-        "object":{  },
-        "address": "50 St. James Street",
-        "url": "http://www.JSON.org/",
-        "comment": "// /* <!-- --",
-        "# -- --> */": " ",
-        " s p a c e d " :[1,2 , 3
-
-,
-
-4 , 5        ,          6           ,7        ],"compact":[1,2,3,4,5,6,7],
-        "jsontext": "{\"object with 1 member\":[\"array with 1 element\"]}",
-        "quotes": "&#34; \u0022 %22 0x22 034 &#x22;",
-        "\/\\\"\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"
-: "A key can be any string"
-    },
-    0.5 ,98.6
-,
-99.44
-,
-
-1066,
-1e1,
-0.1e1,
-1e-1,
-1e00,2e+00,2e-00
-,"rosebud"]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass2.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass2.json
deleted file mode 100644
index d3c63c7..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass2.json
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass3.json b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass3.json
deleted file mode 100644
index 4528d51..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/pass3.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "JSON Test Pattern pass3": {
-        "The outermost value": "must be an object or array.",
-        "In this test": "It is an object."
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/readme.txt b/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/readme.txt
deleted file mode 100644
index 321d89d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/bin/jsonchecker/readme.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Test suite from http://json.org/JSON_checker/.
-
-If the JSON_checker is working correctly, it must accept all of the pass*.json files and reject all of the fail*.json files.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/doc/CMakeLists.txt
deleted file mode 100644
index 685a00e..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-find_package(Doxygen)
-
-IF(NOT DOXYGEN_FOUND)
-    MESSAGE(STATUS "No Doxygen found. Documentation won't be built")
-ELSE()
-    file(GLOB SOURCES ${CMAKE_SOURCE_DIR}/include/*)
-    file(GLOB MARKDOWN_DOC ${CMAKE_SOURCE_DIR}/doc/*.md)
-    list(APPEND MARKDOWN_DOC ${CMAKE_SOURCE_DIR}/readme.md)
-
-    CONFIGURE_FILE(Doxyfile.in Doxyfile @ONLY)
-
-    add_custom_command(OUTPUT html
-        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-        COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/html
-        DEPENDS ${MARKDOWN_DOC} ${SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-
-    add_custom_target(doc ALL DEPENDS html)
-    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html
-        DESTINATION ${DOC_INSTALL_DIR}
-        COMPONENT doc)
-ENDIF()
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/Doxyfile.in b/third_party/socket.io-client-cpp/lib/rapidjson/doc/Doxyfile.in
deleted file mode 100644
index 6920143..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/Doxyfile.in
+++ /dev/null
@@ -1,2366 +0,0 @@
-# Doxyfile 1.8.7
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = RapidJSON
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         =
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          = "A fast JSON parser/generator for C++ with both SAX/DOM style API"
-
-# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
-# the documentation. The maximum height of the logo should not exceed 55 pixels
-# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
-# to the output directory.
-
-PROJECT_LOGO           =
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@
-
-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = YES
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        =
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    =
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
-# new page for each member. If set to NO, the documentation of a member will be
-# part of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
-
-ALIASES                =
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
-#
-# Note For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
-
-EXTENSION_MAPPING      =
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by by putting a % sign in front of the word
-# or globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = YES
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = NO
-
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = NO
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. When set to YES local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO these classes will be included in the various overviews. This option has
-# no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO these declarations will be
-# included in the documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = NO
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
-# todo list. This list is created by putting \todo commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
-# test list. This list is created by putting \test commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       = $(RAPIDJSON_SECTIONS)
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES the list
-# will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = NO
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    =
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            =
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. Do not use file names with spaces, bibtex cannot handle them. See
-# also \cite for info how to create references.
-
-CITE_BIB_FILES         =
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO doxygen will only warn about wrong or incomplete parameter
-# documentation, but not about the absence of documentation.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces.
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = readme.md \
-                         include/rapidjson/rapidjson.h \
-                         include/ \
-                         doc/features.md \
-                         doc/tutorial.md \
-                         doc/stream.md \
-                         doc/encoding.md \
-                         doc/dom.md \
-                         doc/sax.md \
-                         doc/performance.md \
-                         doc/internals.md \
-                         doc/faq.md
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank the
-# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
-# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
-# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
-# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
-# *.qsf, *.as and *.js.
-
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.inc \
-                         *.md
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                = ./include/rapidjson/msinttypes/
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       =
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        = internal
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           =
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             = ./doc
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-
-INPUT_FILTER           =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-
-FILTER_PATTERNS        =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER ) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS =
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE = readme.md
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = NO
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# compiled with the --with-libclang option.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = NO
-
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            = ./doc/misc/header.html
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            = ./doc/misc/footer.html
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        =
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user-
-# defined cascading style sheet that is included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
-# Doxygen will copy the style sheet file to the output directory. For an example
-# see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  = ./doc/misc/doxygenextra.css
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       =
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the stylesheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = YES
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               =
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler ( hhc.exe). If non-empty
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           =
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated (
-# YES) or that it should be included in the master .chm file ( NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     =
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated (
-# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               =
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   =
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  =
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  =
-
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           =
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = YES
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = YES
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
-# instead of using prerendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     =
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       =
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = YES
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       =
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     =
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         = latex
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. To get the times font for
-# instance you can specify
-# EXTRA_PACKAGES=times
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber. Doxygen will
-# replace them by respectively the title of the page, the current date and time,
-# only the current date, the version number of doxygen, the project name (see
-# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           =
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           =
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES to get a
-# higher quality PDF documentation.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    =
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             =
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
-# Definitions (see http://autogen.sf.net) file that captures the structure of
-# the code including all documentation. Note that this feature is still
-# experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
-# in the source code. If set to NO only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = YES
-
-# If the SEARCH_INCLUDES tag is set to YES the includes files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           =
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  =
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             = \
-	RAPIDJSON_DOXYGEN_RUNNING \
-	RAPIDJSON_NAMESPACE_BEGIN="namespace rapidjson {" \
-	RAPIDJSON_NAMESPACE_END="}" \
-	RAPIDJSON_REMOVEFPTR_(x)=x \
-	RAPIDJSON_ENABLEIF_RETURN(cond,returntype)="RAPIDJSON_REMOVEFPTR_ returntype" \
-	RAPIDJSON_DISABLEIF_RETURN(cond,returntype)="RAPIDJSON_REMOVEFPTR_ returntype"
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      = \
-	RAPIDJSON_NOEXCEPT
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       =
-
-# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
-# class index. If set to NO only the inherited external classes will be listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
-# the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            =
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               =
-
-# If set to YES, the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: NO.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font n the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           =
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot.
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, jpg, gif and svg.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           =
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           =
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           =
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
-# files that are used to generate the various graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_CLEANUP            = YES
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.dot
deleted file mode 100644
index eca0e38..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.dot
+++ /dev/null
@@ -1,65 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-	
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	{
-		node [shape=record, fontsize="8", margin="0.04", height=0.2, color=gray]
-		oldjson [label="\{|\"|m|s|g|\"|:|\"|H|e|l|l|o|\\|n|W|o|r|l|d|!|\"|,|\"|\\|u|0|0|7|3|t|a|r|s|\"|:|1|0|\}", xlabel="Before Parsing"]
-		//newjson [label="\{|\"|<a>m|s|g|\\0|:|\"|<b>H|e|l|l|o|\\n|W|o|r|l|d|!|\\0|\"|,|\"|<c>s|t|a|r|s|\\0|t|a|r|s|:|1|0|\}", xlabel="After Parsing"]
-		newjson [shape=plaintext, label=<
-<table BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="2"><tr>
-<td>{</td>
-<td>"</td><td port="a">m</td><td>s</td><td>g</td><td bgcolor="yellow">\\0</td>
-<td>:</td>
-<td>"</td><td port="b">H</td><td>e</td><td>l</td><td>l</td><td>o</td><td bgcolor="yellow">\\n</td><td bgcolor="yellow">W</td><td bgcolor="yellow">o</td><td bgcolor="yellow">r</td><td bgcolor="yellow">l</td><td bgcolor="yellow">d</td><td bgcolor="yellow">!</td><td bgcolor="yellow">\\0</td><td>"</td>
-<td>,</td>
-<td>"</td><td port="c" bgcolor="yellow">s</td><td bgcolor="yellow">t</td><td bgcolor="yellow">a</td><td bgcolor="yellow">r</td><td bgcolor="yellow">s</td><td bgcolor="yellow">\\0</td><td>t</td><td>a</td><td>r</td><td>s</td>
-<td>:</td>
-<td>1</td><td>0</td>
-<td>}</td>
-</tr></table>
->, xlabel="After Parsing"]
-	}
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Document by In situ Parsing"
-		style=filled
-		fillcolor=gray95
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-		
-		root [label="{object|}", fillcolor=3]
-
-		{			
-			msg [label="{string|<a>}", fillcolor=5]
-			helloworld [label="{string|<a>}", fillcolor=5]
-			stars [label="{string|<a>}", fillcolor=5]
-			ten [label="{number|10}", fillcolor=6]
-		}
-	}
-
-	oldjson -> root [label=" ParseInsitu()" lhead="cluster1"]
-	edge [arrowhead=vee]
-	root -> { msg; stars }
-
-	edge [arrowhead="none"]
-	msg  -> helloworld
-	stars -> ten
-
-	{
-		edge [arrowhead=vee, arrowtail=dot, arrowsize=0.5, dir=both, tailclip=false]
-		msg:a:c -> newjson:a
-		helloworld:a:c -> newjson:b
-		stars:a:c -> newjson:c
-	}
-
-	//oldjson -> newjson [style=invis]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.png
deleted file mode 100644
index 27b2572..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/insituparsing.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.dot
deleted file mode 100644
index 82ebfe1..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.dot
+++ /dev/null
@@ -1,62 +0,0 @@
-digraph {
-    fontname="Inconsolata, Consolas"
-    fontsize=10
-    margin="0,0"
-    penwidth=0.0
-    
-    node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-    edge [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-
-    node [shape = doublecircle]; Start; Finish;
-    node [shape = box; style = "rounded, filled"; fillcolor=white ];
-
-    Start -> ArrayInitial [label=" ["];
-    Start -> ObjectInitial [label=" {"];
-
-    subgraph clusterArray {
-        margin="10,10"
-        style=filled
-        fillcolor=gray95
-        label = "Array"
-        
-        ArrayInitial; Element; ElementDelimiter; ArrayFinish;
-    }
-
-    subgraph clusterObject {
-        margin="10,10"
-        style=filled
-        fillcolor=gray95
-        label = "Object"
-
-        ObjectInitial; MemberKey; KeyValueDelimiter; MemberValue; MemberDelimiter; ObjectFinish;
-    }
-
-    ArrayInitial -> ArrayInitial [label="["];
-    ArrayInitial -> ArrayFinish [label=" ]"];
-    ArrayInitial -> ObjectInitial [label="{", constraint=false];
-    ArrayInitial -> Element [label="string\nfalse\ntrue\nnull\nnumber"];
-
-    Element -> ArrayFinish [label="]"];
-    Element -> ElementDelimiter [label=","];
-
-    ElementDelimiter -> ArrayInitial [label=" ["];
-    ElementDelimiter -> ObjectInitial [label="{"];
-    ElementDelimiter -> Element [label="string\nfalse\ntrue\nnull\nnumber"];
-
-    ObjectInitial -> ObjectFinish [label=" }"];
-    ObjectInitial -> MemberKey [label=" string "];
-
-    MemberKey -> KeyValueDelimiter [label=":"];
-
-    KeyValueDelimiter -> ArrayInitial [label="["];
-    KeyValueDelimiter -> ObjectInitial [label=" {"];
-    KeyValueDelimiter -> MemberValue [label=" string\n false\n true\n null\n number"];
-
-    MemberValue -> ObjectFinish [label="}"];
-    MemberValue -> MemberDelimiter [label=","];
-
-    MemberDelimiter -> MemberKey [label=" string "];
-
-    ArrayFinish -> Finish;
-    ObjectFinish -> Finish;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.png
deleted file mode 100644
index 656f8e7..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/iterative-parser-states-diagram.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.dot
deleted file mode 100644
index a7c1464..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.dot
+++ /dev/null
@@ -1,47 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Before"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		{
-			rank = same
-			b1 [label="{b:number|456}", fillcolor=6]
-			a1 [label="{a:number|123}", fillcolor=6]
-		}
-
-		a1 -> b1 [style="dashed", label="Move", dir=back]
-	}
-
-	subgraph cluster2 {
-		margin="10,10"
-		labeljust="left"
-		label = "After"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		{
-			rank = same
-			b2 [label="{b:null|}", fillcolor=1]
-			a2 [label="{a:number|456}", fillcolor=6]
-		}
-		a2 -> b2 [style=invis, dir=back]
-	}
-	b1 -> b2 [style=invis]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.png
deleted file mode 100644
index bf4938d..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move1.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.dot
deleted file mode 100644
index 7037ea6..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.dot
+++ /dev/null
@@ -1,62 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Before Copying (Hypothetic)"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		c1 [label="{contact:array|}", fillcolor=4]
-		c11 [label="{|}"]
-		c12 [label="{|}"]
-		c13 [shape="none", label="...", style="solid"]
-		o1 [label="{o:object|}", fillcolor=3]
-		ghost [label="{o:object|}", style=invis]
-
-		c1 -> o1 [style="dashed", label="AddMember", constraint=false]
-
-		edge [arrowhead=vee]
-		c1 -> { c11; c12; c13 }
-		o1 -> ghost [style=invis]
-	}
-
-	subgraph cluster2 {
-		margin="10,10"
-		labeljust="left"
-		label = "After Copying (Hypothetic)"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		c2 [label="{contact:array|}", fillcolor=4]
-		c3 [label="{array|}", fillcolor=4]
-		c21 [label="{|}"]
-		c22 [label="{|}"]
-		c23 [shape=none, label="...", style="solid"]
-		o2 [label="{o:object|}", fillcolor=3]
-		cs [label="{string|\"contact\"}", fillcolor=5]
-		c31 [label="{|}"]
-		c32 [label="{|}"]
-		c33 [shape="none", label="...", style="solid"]
-
-		edge [arrowhead=vee]
-		c2 -> { c21; c22; c23 }
-		o2 -> cs
-		cs -> c3 [arrowhead=none]
-		c3 -> { c31; c32; c33 }
-	}
-	ghost -> o2 [style=invis]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.png
deleted file mode 100644
index 1d1f0bf..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move2.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.dot
deleted file mode 100644
index c197b99..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.dot
+++ /dev/null
@@ -1,60 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-	forcelabels=true
-
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Before Moving"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		c1 [label="{contact:array|}", fillcolor=4]
-		c11 [label="{|}"]
-		c12 [label="{|}"]
-		c13 [shape=none, label="...", style="solid"]
-		o1 [label="{o:object|}", fillcolor=3]
-		ghost [label="{o:object|}", style=invis]
-
-		c1 -> o1 [style="dashed", constraint=false, label="AddMember"]
-
-		edge [arrowhead=vee]
-		c1 -> { c11; c12; c13 }
-		o1 -> ghost [style=invis]
-	}
-
-	subgraph cluster2 {
-		margin="10,10"
-		labeljust="left"
-		label = "After Moving"
-		style=filled
-		fillcolor=gray95
-
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-
-		c2 [label="{contact:null|}", fillcolor=1]
-		c3 [label="{array|}", fillcolor=4]
-		c21 [label="{|}"]
-		c22 [label="{|}"]
-		c23 [shape="none", label="...", style="solid"]
-		o2 [label="{o:object|}", fillcolor=3]
-		cs [label="{string|\"contact\"}", fillcolor=5]
-		c2 -> o2 [style="dashed", constraint=false, label="AddMember", style=invis]
-
-		edge [arrowhead=vee]
-		c3 -> { c21; c22; c23 }
-		o2 -> cs
-		cs -> c3 [arrowhead=none]
-	}
-	ghost -> o2 [style=invis]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.png
deleted file mode 100644
index a52ad46..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/move3.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.dot
deleted file mode 100644
index b15941b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.dot
+++ /dev/null
@@ -1,56 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-	
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	{
-		node [shape=record, fontsize="8", margin="0.04", height=0.2, color=gray]
-		normaljson [label="\{|\"|m|s|g|\"|:|\"|H|e|l|l|o|\\|n|W|o|r|l|d|!|\"|,|\"|\\|u|0|0|7|3|t|a|r|s\"|:|1|0|\}"]
-
-		{
-			rank = same
-			msgstring  [label="m|s|g|\\0"]
-			helloworldstring  [label="H|e|l|l|o|\\n|W|o|r|l|d|!|\\0"]
-			starsstring [label="s|t|a|r|s\\0"]
-		}
-	}
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Document by Normal Parsing"
-		style=filled
-		fillcolor=gray95
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-		
-		root [label="{object|}", fillcolor=3]
-
-		{			
-			msg [label="{string|<a>}", fillcolor=5]
-			helloworld [label="{string|<a>}", fillcolor=5]
-			stars [label="{string|<a>}", fillcolor=5]
-			ten [label="{number|10}", fillcolor=6]
-		}
-	}
-
-	normaljson -> root [label=" Parse()" lhead="cluster1"]
-	edge [arrowhead=vee]
-	root -> { msg; stars }
-
-	edge [arrowhead="none"]
-	msg  -> helloworld
-	stars -> ten
-
-	edge [arrowhead=vee, arrowtail=dot, arrowsize=0.5, dir=both, tailclip=false]
-	msg:a:c -> msgstring:w
-	helloworld:a:c -> helloworldstring:w
-	stars:a:c -> starsstring:w
-
-	msgstring -> helloworldstring -> starsstring [style=invis]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.png
deleted file mode 100644
index 7e9ff7d..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/normalparsing.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.dot
deleted file mode 100644
index 28f017a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.dot
+++ /dev/null
@@ -1,54 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-	
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10, arrowhead=normal]
-
-	{
-		node [shape=record, fontsize="8", margin="0.04", height=0.2, color=gray]
-		srcjson [label="\{|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|0|\}"]
-		dstjson [label="\{|p|r|o|j|e|c|t|\"|:|\"|r|a|p|i|d|j|s|o|n|\"|,|\"|s|t|a|r|s|\"|:|1|1|\}"]
-	}
-
-	{
-		node [shape="box", style="filled", fillcolor="gray95"]
-		Document2 [label="(Modified) Document"]
-		Writer
-	}
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Document"
-		style=filled
-		fillcolor=gray95
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-		
-		root [label="{object|}", fillcolor=3]
-
-		{			
-			project [label="{string|\"project\"}", fillcolor=5]
-			rapidjson [label="{string|\"rapidjson\"}", fillcolor=5]
-			stars [label="{string|\"stars\"}", fillcolor=5]
-			ten [label="{number|10}", fillcolor=6]
-		}
-
-		edge [arrowhead=vee]
-		root -> { project; stars }
-
-		edge [arrowhead="none"]
-		project -> rapidjson
-		stars -> ten
-	}
-
-	srcjson -> root [label=" Parse()", lhead="cluster1"]
-
-	ten -> Document2 [label=" Increase \"stars\"", ltail="cluster1" ]
-	Document2  -> Writer [label=" Traverse DOM by Accept()"]
-	Writer -> dstjson [label=" Output to StringBuffer"]
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.png
deleted file mode 100644
index 2443eeb..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/simpledom.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.dot b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.dot
deleted file mode 100644
index 138ddc3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.dot
+++ /dev/null
@@ -1,58 +0,0 @@
-digraph {
-	compound=true
-	fontname="Inconsolata, Consolas"
-	fontsize=10
-	margin="0,0"
-	ranksep=0.2
-	penwidth=0.5
-	
-	node [fontname="Inconsolata, Consolas", fontsize=10, penwidth=0.5]
-	edge [fontname="Inconsolata, Consolas", fontsize=10]
-
-	subgraph cluster1 {
-		margin="10,10"
-		labeljust="left"
-		label = "Document"
-		style=filled
-		fillcolor=gray95
-		node [shape=Mrecord, style=filled, colorscheme=spectral7]
-		
-		root [label="{object|}", fillcolor=3]
-
-		{			
-			hello [label="{string|\"hello\"}", fillcolor=5]
-			t [label="{string|\"t\"}", fillcolor=5]
-			f [label="{string|\"f\"}", fillcolor=5]
-			n [label="{string|\"n\"}", fillcolor=5]
-			i [label="{string|\"i\"}", fillcolor=5]
-			pi [label="{string|\"pi\"}", fillcolor=5]
-			a [label="{string|\"a\"}", fillcolor=5]
-
-			world [label="{string|\"world\"}", fillcolor=5]
-			true [label="{true|}", fillcolor=7]
-			false [label="{false|}", fillcolor=2]
-			null [label="{null|}", fillcolor=1]
-			i1 [label="{number|123}", fillcolor=6]
-			pi1 [label="{number|3.1416}", fillcolor=6]
-			array [label="{array|size=4}", fillcolor=4]
-
-			a1 [label="{number|1}", fillcolor=6]
-			a2 [label="{number|2}", fillcolor=6]
-			a3 [label="{number|3}", fillcolor=6]
-			a4 [label="{number|4}", fillcolor=6]
-		}
-
-		edge [arrowhead=vee]
-		root -> { hello; t; f; n; i; pi; a }		
-		array -> { a1; a2; a3; a4 }
-
-		edge [arrowhead=none]
-		hello -> world
-		t -> true
-		f -> false
-		n -> null
-		i -> i1
-		pi -> pi1
-		a -> array
-	}
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.png
deleted file mode 100644
index a2b0b54..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/diagram/tutorial.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/dom.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/dom.md
deleted file mode 100644
index 33a4db3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/dom.md
+++ /dev/null
@@ -1,272 +0,0 @@
-# DOM
-
-Document Object Model(DOM) is an in-memory representation of JSON for query and manipulation. The basic usage of DOM is described in [Tutorial](doc/tutorial.md). This section will describe some details and more advanced usages.
-
-[TOC]
-
-# Template {#Template}
-
-In the tutorial,  `Value` and `Document` was used. Similarly to `std::string`, these are actually `typedef` of template classes:
-
-~~~~~~~~~~cpp
-namespace rapidjson {
-
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
-class GenericValue {
-    // ...
-};
-
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> >
-class GenericDocument : public GenericValue<Encoding, Allocator> {
-    // ...
-};
-
-typedef GenericValue<UTF8<> > Value;
-typedef GenericDocument<UTF8<> > Document;
-
-} // namespace rapidjson
-~~~~~~~~~~
-
-User can customize these template parameters.
-
-## Encoding {#Encoding}
-
-The `Encoding` parameter specifies the encoding of JSON String value in memory. Possible options are `UTF8`, `UTF16`, `UTF32`. Note that, these 3 types are also template class. `UTF8<>` is `UTF8<char>`, which means using char to store the characters. You may refer to [Encoding](doc/encoding.md) for details.
-
-Suppose a Windows application would query localization strings stored in JSON files. Unicode-enabled functions in Windows use UTF-16 (wide character) encoding. No matter what encoding was used in JSON files, we can store the strings in UTF-16 in memory.
-
-~~~~~~~~~~cpp
-using namespace rapidjson;
-
-typedef GenericDocument<UTF16<> > WDocument;
-typedef GenericValue<UTF16<> > WValue;
-
-FILE* fp = fopen("localization.json", "rb"); // non-Windows use "r"
-
-char readBuffer[256];
-FileReadStream bis(fp, readBuffer, sizeof(readBuffer));
-
-AutoUTFInputStream<unsigned, FileReadStream> eis(bis);  // wraps bis into eis
-
-WDocument d;
-d.ParseStream<0, AutoUTF<unsigned> >(eis);
-
-const WValue locale(L"ja"); // Japanese
-
-MessageBoxW(hWnd, d[locale].GetString(), L"Test", MB_OK);
-~~~~~~~~~~
-
-## Allocator {#Allocator}
-
-The `Allocator` defines which allocator class is used when allocating/deallocating memory for `Document`/`Value`. `Document` owns, or references to an `Allocator` instance. On the other hand, `Value` does not do so, in order to reduce memory consumption.
-
-The default allocator used in `GenericDocument` is `MemoryPoolAllocator`. This allocator actually allocate memory sequentially, and cannot deallocate one by one. This is very suitable when parsing a JSON to generate a DOM tree.
-
-Another allocator is `CrtAllocator`, of which CRT is short for C RunTime library. This allocator simply calls the standard `malloc()`/`realloc()`/`free()`. When there is a lot of add and remove operations, this allocator may be preferred. But this allocator is far less efficient than `MemoryPoolAllocator`.
-
-# Parsing {#Parsing}
-
-`Document` provides several functions for parsing. In below, (1) is the fundamental function, while the others are helpers which call (1).
-
-~~~~~~~~~~cpp
-using namespace rapidjson;
-
-// (1) Fundamental
-template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
-GenericDocument& GenericDocument::ParseStream(InputStream& is);
-
-// (2) Using the same Encoding for stream
-template <unsigned parseFlags, typename InputStream>
-GenericDocument& GenericDocument::ParseStream(InputStream& is);
-
-// (3) Using default parse flags
-template <typename InputStream>
-GenericDocument& GenericDocument::ParseStream(InputStream& is);
-
-// (4) In situ parsing
-template <unsigned parseFlags, typename SourceEncoding>
-GenericDocument& GenericDocument::ParseInsitu(Ch* str);
-
-// (5) In situ parsing, using same Encoding for stream
-template <unsigned parseFlags>
-GenericDocument& GenericDocument::ParseInsitu(Ch* str);
-
-// (6) In situ parsing, using default parse flags
-GenericDocument& GenericDocument::ParseInsitu(Ch* str);
-
-// (7) Normal parsing of a string
-template <unsigned parseFlags, typename SourceEncoding>
-GenericDocument& GenericDocument::Parse(const Ch* str);
-
-// (8) Normal parsing of a string, using same Encoding for stream
-template <unsigned parseFlags>
-GenericDocument& GenericDocument::Parse(const Ch* str);
-
-// (9) Normal parsing of a string, using default parse flags
-GenericDocument& GenericDocument::Parse(const Ch* str);
-~~~~~~~~~~
-
-The examples of [tutorial](doc/tutorial.md) uses (9) for normal parsing of string. The examples of [stream](doc/stream.md) uses the first three. *In situ* parsing will be described soon.
-
-The `parseFlags` are combination of the following bit-flags:
-
-Parse flags                   | Meaning
-------------------------------|-----------------------------------
-`kParseNoFlags`               | No flag is set.
-`kParseDefaultFlags`          | Default parse flags. It is equal to macro `RAPIDJSON_PARSE_DEFAULT_FLAGS`, which is defined as `kParseNoFlags`.
-`kParseInsituFlag`            | In-situ(destructive) parsing.
-`kParseValidateEncodingFlag`  | Validate encoding of JSON strings.
-`kParseIterativeFlag`         | Iterative(constant complexity in terms of function call stack size) parsing.
-`kParseStopWhenDoneFlag`      | After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate `kParseErrorDocumentRootNotSingular` error. Using this flag for parsing multiple JSONs in the same stream.
-`kParseFullPrecisionFlag`     | Parse number in full precision (slower). If this flag is not set, the normal precision (faster) is used. Normal precision has maximum 3 [ULP](http://en.wikipedia.org/wiki/Unit_in_the_last_place) error.
-
-By using a non-type template parameter, instead of a function parameter, C++ compiler can generate code which is optimized for specified combinations, improving speed, and reducing code size (if only using a single specialization). The downside is the flags needed to be determined in compile-time.
-
-The `SourceEncoding` parameter defines what encoding is in the stream. This can be differed to the `Encoding` of the `Document`. See [Transcoding and Validation](#TranscodingAndValidation) section for details.
-
-And the `InputStream` is type of input stream.
-
-## Parse Error {#ParseError}
-
-When the parse processing succeeded, the `Document` contains the parse results. When there is an error, the original DOM is *unchanged*. And the error state of parsing can be obtained by `bool HasParseError()`,  `ParseErrorCode GetParseError()` and `size_t GetParseOffet()`.
-
-Parse Error Code                            | Description
---------------------------------------------|---------------------------------------------------
-`kParseErrorNone`                           | No error.
-`kParseErrorDocumentEmpty`                  | The document is empty.
-`kParseErrorDocumentRootNotSingular`        | The document root must not follow by other values.
-`kParseErrorValueInvalid`                   | Invalid value.
-`kParseErrorObjectMissName`                 | Missing a name for object member.
-`kParseErrorObjectMissColon`                | Missing a colon after a name of object member.
-`kParseErrorObjectMissCommaOrCurlyBracket`  | Missing a comma or `}` after an object member.
-`kParseErrorArrayMissCommaOrSquareBracket`  | Missing a comma or `]` after an array element.
-`kParseErrorStringUnicodeEscapeInvalidHex`  | Incorrect hex digit after `\\u` escape in string.
-`kParseErrorStringUnicodeSurrogateInvalid`  | The surrogate pair in string is invalid.
-`kParseErrorStringEscapeInvalid`            | Invalid escape character in string.
-`kParseErrorStringMissQuotationMark`        | Missing a closing quotation mark in string.
-`kParseErrorStringInvalidEncoding`          | Invalid encoding in string.
-`kParseErrorNumberTooBig`                   | Number too big to be stored in `double`.
-`kParseErrorNumberMissFraction`             | Miss fraction part in number.
-`kParseErrorNumberMissExponent`             | Miss exponent in number.
-
-The offset of error is defined as the character number from beginning of stream. Currently RapidJSON does not keep track of line number.
-
-To get an error message, RapidJSON provided a English messages in `rapidjson/error/en.h`. User can customize it for other locales, or use a custom localization system.
-
-Here shows an example of parse error handling.
-
-~~~~~~~~~~cpp
-// TODO: example
-~~~~~~~~~~
-
-## In Situ Parsing {#InSituParsing}
-
-From [Wikipedia](http://en.wikipedia.org/wiki/In_situ):
-
-> *In situ* ... is a Latin phrase that translates literally to "on site" or "in position". It means "locally", "on site", "on the premises" or "in place" to describe an event where it takes place, and is used in many different contexts.
-> ...
-> (In computer science) An algorithm is said to be an in situ algorithm, or in-place algorithm, if the extra amount of memory required to execute the algorithm is O(1), that is, does not exceed a constant no matter how large the input. For example, heapsort is an in situ sorting algorithm.
-
-In normal parsing process, a large overhead is to decode JSON strings and copy them to other buffers. *In situ* parsing decodes those JSON string at the place where it is stored. It is possible in JSON because the decoded string is always shorter than the one in JSON. In this context, decoding a JSON string means to process the escapes, such as `"\n"`, `"\u1234"`, etc., and add a null terminator (`'\0'`)at the end of string.
-
-The following diagrams compare normal and *in situ* parsing. The JSON string values contain pointers to the decoded string.
-
-![normal parsing](diagram/normalparsing.png)
-
-In normal parsing, the decoded string are copied to freshly allocated buffers. `"\\n"` (2 characters) is decoded as `"\n"` (1 character). `"\\u0073"` (6 characters) is decoded as "s" (1 character).
-
-![instiu parsing](diagram/insituparsing.png)
-
-*In situ* parsing just modified the original JSON. Updated characters are highlighted in the diagram. If the JSON string does not contain escape character, such as `"msg"`, the parsing process merely replace the closing double quotation mark with a null character.
-
-Since *in situ* parsing modify the input, the parsing API needs `char*` instead of `const char*`.
-
-~~~~~~~~~~cpp
-// Read whole file into a buffer
-FILE* fp = fopen("test.json", "r");
-fseek(fp, 0, SEEK_END);
-size_t filesize = (size_t)ftell(fp);
-fseek(fp, 0, SEEK_SET);
-char* buffer = (char*)malloc(filesize + 1);
-size_t readLength = fread(buffer, 1, filesize, fp);
-buffer[readLength] = '\0';
-fclose(fp);
-
-// In situ parsing the buffer into d, buffer will also be modified
-Document d;
-d.ParseInsitu(buffer);
-
-// Query/manipulate the DOM here...
-
-free(buffer);
-// Note: At this point, d may have dangling pointers pointed to the deallocated buffer.
-~~~~~~~~~~
-
-The JSON strings are marked as constant-string. But they may not be really "constant". The life cycle of it depends on the JSON buffer.
-
-In situ parsing minimizes allocation overheads and memory copying. Generally this improves cache coherence, which is an important factor of performance in modern computer.
-
-There are some limitations of *in situ* parsing:
-
-1. The whole JSON is in memory.
-2. The source encoding in stream and target encoding in document must be the same.
-3. The buffer need to be retained until the document is no longer used.
-4. If the DOM need to be used for long period after parsing, and there are few JSON strings in the DOM, retaining the buffer may be a memory waste.
-
-*In situ* parsing is mostly suitable for short-term JSON that only need to be processed once, and then be released from memory. In practice, these situation is very common, for example, deserializing JSON to C++ objects, processing web requests represented in JSON, etc.
-
-## Transcoding and Validation {#TranscodingAndValidation}
-
-RapidJSON supports conversion between Unicode formats (officially termed UCS Transformation Format) internally. During DOM parsing, the source encoding of the stream can be different from the encoding of the DOM. For example, the source stream contains a UTF-8 JSON, while the DOM is using UTF-16 encoding. There is an example code in [EncodedInputStream](doc/stream.md#EncodedInputStream).
-
-When writing a JSON from DOM to output stream, transcoding can also be used. An example is in [EncodedOutputStream](stream.md##EncodedOutputStream).
-
-During transcoding, the source string is decoded to into Unicode code points, and then the code points are encoded in the target format. During decoding, it will validate the byte sequence in the source string. If it is not a valid sequence, the parser will be stopped with `kParseErrorStringInvalidEncoding` error.
-
-When the source encoding of stream is the same as encoding of DOM, by default, the parser will *not* validate the sequence. User may use `kParseValidateEncodingFlag` to force validation.
-
-# Techniques {#Techniques}
-
-Some techniques about using DOM API is discussed here.
-
-## DOM as SAX Event Publisher
-
-In RapidJSON, stringifying a DOM with `Writer` may be look a little bit weired.
-
-~~~~~~~~~~cpp
-// ...
-Writer<StringBuffer> writer(buffer);
-d.Accept(writer);
-~~~~~~~~~~
-
-Actually, `Value::Accept()` is responsible for publishing SAX events about the value to the handler. With this design, `Value` and `Writer` are decoupled. `Value` can generate SAX events, and `Writer` can handle those events.
-
-User may create customer handlers for transforming the DOM into other formats. For example, a handler which converts the DOM into XML.
-
-~~~~~~~~~~cpp
-// TODO: example
-~~~~~~~~~~
-
-For more about SAX events and handler, please refer to [SAX](doc/sax.md).
-
-## User Buffer {#UserBuffer}
-
-Some applications may try to avoid memory allocations whenever possible.
-
-`MemoryPoolAllocator` can support this by letting user to provide a buffer. The buffer can be on the program stack, or a "scratch buffer" which is statically allocated (a static/global array) for storing temporary data.
-
-`MemoryPoolAllocator` will use the user buffer to satisfy allocations. When the user buffer is used up, it will allocate a chunk of memory from the base allocator (by default the `CrtAllocator`).
-
-Here is an example of using stack memory.
-
-~~~~~~~~~~cpp
-char buffer[1024];
-MemoryPoolAllocator allocator(buffer, sizeof(buffer));
-
-Document d(&allocator);
-d.Parse(json);
-~~~~~~~~~~
-
-If the total size of allocation is less than 1024 during parsing, this code does not invoke any heap allocation (via `new` or `malloc()`) at all.
-
-User can query the current memory consumption in bytes via `MemoryPoolAllocator::Size()`. And then user can determine a suitable size of user buffer.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/encoding.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/encoding.md
deleted file mode 100644
index 4d7ca7b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/encoding.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# Encoding
-
-According to [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf),
-
-> (in Introduction) JSON text is a sequence of Unicode code points.
-
-The earlier [RFC4627](http://www.ietf.org/rfc/rfc4627.txt) stated that,
-
-> (in §3) JSON text SHALL be encoded in Unicode.  The default encoding is UTF-8.
-
-> (in §6) JSON may be represented using UTF-8, UTF-16, or UTF-32. When JSON is written in UTF-8, JSON is 8bit compatible.  When JSON is written in UTF-16 or UTF-32, the binary content-transfer-encoding must be used.
-
-RapidJSON supports various encodings. It can also validate the encodings of JSON, and transconding JSON among encodings. All these features are implemented internally, without the need for external libraries (e.g. [ICU](http://site.icu-project.org/)).
-
-[TOC]
-
-# Unicode {#Unicode}
-From [Unicode's official website](http://www.unicode.org/standard/WhatIsUnicode.html):
-> Unicode provides a unique number for every character, 
-> no matter what the platform,
-> no matter what the program,
-> no matter what the language.
-
-Those unique numbers are called code points, which is in the range `0x0` to `0x10FFFF`.
-
-## Unicode Transformation Format {#UTF}
-
-There are various encodings for storing Unicode code points. These are called Unicode Transformation Format (UTF). RapidJSON supports the most commonly used UTFs, including
-
-* UTF-8: 8-bit variable-width encoding. It maps a code point to 1–4 bytes.
-* UTF-16: 16-bit variable-width encoding. It maps a code point to 1–2 16-bit code units (i.e., 2–4 bytes).
-* UTF-32: 32-bit fixed-width encoding. It directly maps a code point to a single 32-bit code unit (i.e. 4 bytes).
-
-For UTF-16 and UTF-32, the byte order (endianness) does matter. Within computer memory, they are often stored in the computer's endianness. However, when it is stored in file or transferred over network, we need to state the byte order of the byte sequence, either little-endian (LE) or big-endian (BE). 
-
-RapidJSON provide these encodings via the structs in `rapidjson/encodings.h`:
-
-~~~~~~~~~~cpp
-namespace rapidjson {
-
-template<typename CharType = char>
-struct UTF8;
-
-template<typename CharType = wchar_t>
-struct UTF16;
-
-template<typename CharType = wchar_t>
-struct UTF16LE;
-
-template<typename CharType = wchar_t>
-struct UTF16BE;
-
-template<typename CharType = unsigned>
-struct UTF32;
-
-template<typename CharType = unsigned>
-struct UTF32LE;
-
-template<typename CharType = unsigned>
-struct UTF32BE;
-
-} // namespace rapidjson
-~~~~~~~~~~
-
-For processing text in memory, we normally use `UTF8`, `UTF16` or `UTF32`. For processing text via I/O, we may use `UTF8`, `UTF16LE`, `UTF16BE`, `UTF32LE` or `UTF32BE`.
-
-When using the DOM-style API, the `Encoding` template parameter in `GenericValue<Encoding>` and `GenericDocument<Encoding>` indicates the encoding to be used to represent JSON string in memory. So normally we will use `UTF8`, `UTF16` or `UTF32` for this template parameter. The choice depends on operating systems and other libraries that the application is using. For example, Windows API represents Unicode characters in UTF-16, while most Linux distributions and applications prefer UTF-8.
-
-Example of UTF-16 DOM declaration:
-
-~~~~~~~~~~cpp
-typedef GenericDocument<UTF16<> > WDocument;
-typedef GenericValue<UTF16<> > WValue;
-~~~~~~~~~~
-
-For a detail example, please check the example in [DOM's Encoding](doc/stream.md#Encoding) section.
-
-## Character Type {#CharacterType}
-
-As shown in the declaration, each encoding has a `CharType` template parameter. Actually, it may be a little bit confusing, but each `CharType` stores a code unit, not a character (code point). As mentioned in previous section, a code point may be encoded to 1–4 code units for UTF-8.
-
-For `UTF16(LE|BE)`, `UTF32(LE|BE)`, the `CharType` must be integer type of at least 2 and 4 bytes  respectively.
-
-Note that C++11 introduces `char16_t` and `char32_t`, which can be used for `UTF16` and `UTF32` respectively.
-
-## AutoUTF {#AutoUTF}
-
-Previous encodings are statically bound in compile-time. In other words, user must know exactly which encodings will be used in the memory or streams. However, sometimes we may need to read/write files of different encodings. The encoding needed to be decided in runtime.
-
-`AutoUTF` is an encoding designed for this purpose. It chooses which encoding to be used according to the input or output stream. Currently, it should be used with `EncodedInputStream` and `EncodedOutputStream`.
-
-## ASCII {#ASCII}
-
-Although the JSON standards did not mention about [ASCII](http://en.wikipedia.org/wiki/ASCII), sometimes we would like to write 7-bit ASCII JSON for applications that cannot handle UTF-8. Since any JSON can represent unicode characters in escaped sequence `\uXXXX`, JSON can always be encoded in ASCII.
-
-Here is an example for writing a UTF-8 DOM into ASCII:
-
-~~~~~~~~~~cpp
-using namespace rapidjson;
-Document d; // UTF8<>
-// ...
-StringBuffer buffer;
-Writer<StringBuffer, Document::EncodingType, ASCII<> > writer(buffer);
-d.Accept(writer);
-std::cout << buffer.GetString();
-~~~~~~~~~~
-
-ASCII can be used in input stream. If the input stream contains bytes with values above 127, it will cause `kParseErrorStringInvalidEncoding` error.
-
-ASCII *cannot* be used in memory (encoding of `Document` or target encoding of `Reader`), as it cannot represent Unicode code points.
-
-# Validation & Transcoding {#ValidationTranscoding}
-
-When RapidJSON parses a JSON, it can validate the input JSON, whether it is a valid sequence of a specified encoding. This option can be turned on by adding `kParseValidateEncodingFlag` in `parseFlags` template parameter.
-
-If the input encoding and output encoding is different, `Reader` and `Writer` will automatically transcode (convert) the text. In this case, `kParseValidateEncodingFlag` is not necessary, as it must decode the input sequence. And if the sequence was unable to be decoded, it must be invalid.
-
-## Transcoder {#Transcoder}
-
-Although the encoding functions in RapidJSON are designed for JSON parsing/generation, user may abuse them for transcoding of non-JSON strings.
-
-Here is an example for transcoding a string from UTF-8 to UTF-16:
-
-~~~~~~~~~~cpp
-#include "rapidjson/encodings.h"
-
-using namespace rapidjson;
-
-const char* s = "..."; // UTF-8 string
-StringStream source(s);
-GenericStringBuffer<UTF16<> > target;
-
-bool hasError = false;
-while (source.Peak() != '\0')
-    if (!Transcoder::Transcode<UTF8<>, UTF16<> >(source, target)) {
-        hasError = true;
-        break;
-    }
-
-if (!hasError) {
-    const wchar_t* t = target.GetString();
-    // ...
-}
-~~~~~~~~~~
-
-You may also use `AutoUTF` and the associated streams for setting source/target encoding in runtime.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/faq.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/faq.md
deleted file mode 100644
index d187055..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/faq.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# FAQ
-
-## General
-
-1. What is RapidJSON?
-
-   RapidJSON is a C++ library for parsing and generating JSON. You may check all [features](doc/features.md) of it.
-
-2. Why is RapidJSON named so?
-
-   It is inspired by [RapidXML](http://rapidxml.sourceforge.net/), which is a fast XML DOM parser.
-
-3. Is RapidJSON similar to RapidXML?
-
-   RapidJSON borrowed some designs of RapidXML, including *in situ* parsing, header-only library. But the two APIs are completely different. Also RapidJSON provide many features that are not in RapidXML.
-
-4. Is RapidJSON free?
-
-   Yes, it is free under MIT license. It can be used in commercial applications. Please check the details in [license.txt](https://github.com/miloyip/rapidjson/blob/master/license.txt).
-
-5. Is RapidJSON small? What are its dependencies? 
-
-   Yes. A simple executable which parses a JSON and prints its statistics is less than 30KB on Windows.
-
-   RapidJSON depends on C++ standard library only.
-
-6. How to install RapidJSON?
-
-   Check [Installation section](http://miloyip.github.io/rapidjson/).
-
-7. Can RapidJSON run on my platform?
-
-   RapidJSON has been tested in many combinations of operating systems, compilers and CPU architecture by the community. But we cannot ensure that it can be run on your particular platform. Building and running the unit test suite will give you the answer.
-
-8. Does RapidJSON support C++03? C++11?
-
-   RapidJSON was firstly implemented for C++03. Later it added optional support of some C++11 features (e.g., move constructor, `noexcept`). RapidJSON shall be compatible with C++03 or C++11 compliant compilers.
-
-9. Does RapidJSON really work in real applications?
-
-   Yes. It is deployed in both client and server real applications. A community member reported that RapidJSON in their system parses 50 million JSONs daily.
-
-10. How RapidJSON is tested?
-
-   RapidJSON contains a unit test suite for automatic testing. [Travis](https://travis-ci.org/miloyip/rapidjson/) will compile and run the unit test suite for all modifications. The test process also uses Valgrind to detect memory leaks.
-
-11. Is RapidJSON well documented?
-
-   RapidJSON provides [user guide and API documentationn](http://miloyip.github.io/rapidjson/index.html).
-
-12. Are there alternatives?
-
-   Yes, there are a lot alternatives. For example, [nativejson-benchmark](https://github.com/miloyip/nativejson-benchmark) has a listing of open-source C/C++ JSON libraries. [json.org](http://www.json.org/) also has a list.
-
-## JSON
-
-1. What is JSON?
-
-   JSON (JavaScript Object Notation) is a lightweight data-interchange format. It uses human readable text format. More details of JSON can be referred to [RFC7159](http://www.ietf.org/rfc/rfc7159.txt) and [ECMA-404](http://www.ecma-international.org/publications/standards/Ecma-404.htm).
-
-2. What are applications of JSON?
-
-   JSON are commonly used in web applications for transferring structured data. It is also used as a file format for data persistence.
-
-2. Does RapidJSON conform to the JSON standard?
-
-   Yes. RapidJSON is fully compliance with [RFC7159](http://www.ietf.org/rfc/rfc7159.txt) and [ECMA-404](http://www.ecma-international.org/publications/standards/Ecma-404.htm). It can handle corner cases, such as supporting null character and surrogate pairs in JSON strings.
-
-3. Does RapidJSON support relaxed syntax?
-
-   Currently no. RapidJSON only support the strict standardized format. Support on related syntax is under discussion in this [issue](https://github.com/miloyip/rapidjson/issues/36).
-
-## DOM and SAX
-
-1. What is DOM style API?
-
-   Document Object Model (DOM) is an in-memory representation of JSON for query and manipulation.
-
-2. What is SAX style API?
-
-   SAX is an event-driven API for parsing and generation.
-
-3. Should I choose DOM or SAX?
-
-   DOM is easy for query and manipulation. SAX is very fast and memory-saving but often more difficult to be applied.
-
-4. What is *in situ* parsing?
-
-   *in situ* parsing decodes the JSON strings directly into the input JSON. This is an optimization which can reduce memory consumption and improve performance, but the input JSON will be modified. Check [in-situ parsing](http://miloyip.github.io/rapidjson/md_doc_dom.html#InSituParsing) for details.
-
-5. When does parsing generate an error?
-
-   The parser generates an error when the input JSON contains invalid syntax, or a value can not be represented (a number is too big), or the handler of parsers terminate the parsing. Check [parse error](http://miloyip.github.io/rapidjson/md_doc_dom.html#ParseError) for details.
-
-6. What error information is provided? 
-
-   The error is stored in `ParseResult`, which includes the error code and offset (number of characters from the beginning of JSON). The error code can be translated into human-readable error message.
-
-7. Why not just using `double` to represent JSON number?
-
-   Some applications use 64-bit unsigned/signed integers. And these integers cannot be converted into `double` without loss of precision. So the parsers detects whether a JSON number is convertible to different types of integers and/or `double`.
-
-## Document/Value (DOM)
-
-1. What is move semantics? Why?
-2. How to copy a value?
-3. Why do I need to provide the length of string?
-4. Why do I need to provide allocator in many DOM manipulation API?
-5. Does it convert between numerical types?
-
-## Reader/Writer (SAX)
-
-1. Why not just `printf` a JSON? Why need a `Writer`? 
-2. Why can't I parse a JSON which is just a number?
-3. Can I pause the parsing process and resume it later?
-
-## Unicode
-
-1. Does it support UTF-8, UTF-16 and other format?
-2. Can it validate the encoding?
-3. What is surrogate pair? Does RapidJSON support it?
-4. Can it handle '\u0000' (null character) in JSON string?
-5. Can I output '\uxxxx' for all non-ASCII character?
-
-## Stream
-
-1. I have a big JSON file. Should I load the whole file to memory?
-2. Can I parse JSON while it is streamed from network?
-3. I don't know what format will the JSON be. How to handle them?
-4. What is BOM? How RapidJSON handle it?
-5. Why little/big endian is related?
-
-## Performance
-
-1. Is RapidJSON really fast?
-2. Why is it fast?
-3. What is SIMD? How it is applied in RapidJSON?
-4. Does it consume a lot of memory?
-5. What is the purpose of being high performance?
-
-## Gossip
-
-1. Who are the developers of RapidJSON?
-2. Why do you develop RapidJSON?
-3. Why there is a long empty period of development?
-4. Why did the repository move from Google Code to GitHub?
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/features.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/features.md
deleted file mode 100644
index 15de259..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/features.md
+++ /dev/null
@@ -1,96 +0,0 @@
-# Features
-
-## General
-
-* Cross-platform
- * Compilers: Visual Studio, gcc, clang, etc.
- * Architectures: x86, x64, ARM, etc.
- * Operating systems: Windows, Mac OS X, Linux, iOS, Android, etc.
-* Easy installation
- * Header files only library. Just copy the headers to your project.
-* Self-contained, minimal dependences
- * No STL, BOOST, etc.
- * Only included `<cstdio>`, `<cstdlib>`, `<cstring>`, `<inttypes.h>`, `<new>`, `<stdint.h>`. 
-* Without C++ exception, RTTI
-* High performance
- * Use template and inline functions to reduce function call overheads.
- * Internal optimized Grisu2 and floating point parsing implementations.
- * Optional SSE2/SSE4.1 support.
-
-## Standard compliance
-
-* RapidJSON should be fully RFC4627/ECMA-404 compliance.
-* Support Unicode surrogate.
-* Support null character (`"\u0000"`)
- * For example, `["Hello\u0000World"]` can be parsed and handled gracefully. There is API for getting/setting lengths of string.
-
-## Unicode
-
-* Support UTF-8, UTF-16, UTF-32 encodings, including little endian and big endian.
- * These encodings are used in input/output streams and in-memory representation.
-* Support automatic detection of encodings in input stream.
-* Support transcoding between encodings internally.
- * For example, you can read a UTF-8 file and let RapidJSON transcode the JSON strings into UTF-16 in the DOM.
-* Support encoding validation internally.
- * For example, you can read a UTF-8 file, and let RapidJSON check whether all JSON strings are valid UTF-8 byte sequence.
-* Support custom character types.
- * By default the character types are `char` for UTF8, `wchar_t` for UTF16, `uint32_t` for UTF32.
-* Support custom encodings.
-
-## API styles
-
-* SAX (Simple API for XML) style API
- * Similar to [SAX](http://en.wikipedia.org/wiki/Simple_API_for_XML), RapidJSON provides a event sequential access parser API (`rapidjson::GenericReader`). It also provides a generator API (`rapidjson::Writer`) which consumes the same set of events.
-* DOM (Document Object Model) style API
- * Similar to [DOM](http://en.wikipedia.org/wiki/Document_Object_Model) for HTML/XML, RapidJSON can parse JSON into a DOM representation (`rapidjson::GenericDocument`), for easy manipulation, and finally stringify back to JSON if needed.
- * The DOM style API (`rapidjson::GenericDocument`) is actually implemented with SAX style API (`rapidjson::GenericReader`). SAX is faster but sometimes DOM is easier. Users can pick their choices according to scenarios.
-
-## Parsing
-
-* Recursive (default) and iterative parser
- * Recursive parser is faster but prone to stack overflow in extreme cases.
- * Iterative parser use custom stack to keep parsing state.
-* Support *in situ* parsing.
- * Parse JSON string values in-place at the source JSON, and then the DOM points to addresses of those strings.
- * Faster than convention parsing: no allocation for strings, no copy (if string does not contain escapes), cache-friendly.
-* Support 32-bit/64-bit signed/unsigned integer and `double` for JSON number type.
-* Support parsing multiple JSONs in input stream (`kParseStopWhenDoneFlag`).
-* Error Handling
- * Support comprehensive error code if parsing failed.
- * Support error message localization.
-
-## DOM (Document)
-
-* RapidJSON checks range of numerical values for conversions.
-* Optimization for string literal
- * Only store pointer instead of copying
-* Optimization for "short" strings
- * Store short string in `Value` internally without additional allocation.
- * For UTF-8 string: maximum 11 characters in 32-bit, 15 characters in 64-bit.
-* Optionally support `std::string` (define `RAPIDJSON_HAS_STDSTRING=1`)
-
-## Generation
-
-* Support `rapidjson::PrettyWriter` for adding newlines and indentations.
-
-## Stream
-
-* Support `rapidjson::GenericStringBuffer` for storing the output JSON as string.
-* Support `rapidjson::FileReadStream` and `rapidjson::FileWriteStream` for input/output `FILE` object.
-* Support custom streams.
-
-## Memory
-
-* Minimize memory overheads for DOM.
- * Each JSON value occupies exactly 16/20 bytes for most 32/64-bit machines (excluding text string).
-* Support fast default allocator.
- * A stack-based allocator (allocate sequentially, prohibit to free individual allocations, suitable for parsing).
- * User can provide a pre-allocated buffer. (Possible to parse a number of JSONs without any CRT allocation)
-* Support standard CRT(C-runtime) allocator.
-* Support custom allocators.
-
-## Miscellaneous
-
-* Some C++11 support (optional)
- * Rvalue reference
- * `noexcept` specifier
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/internals.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/internals.md
deleted file mode 100644
index da60825..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/internals.md
+++ /dev/null
@@ -1,127 +0,0 @@
-# Internals
-
-This section records some design and implementation details.
-
-[TOC]
-
-# Value {#Value}
-
-## Data Layout {#DataLayout}
-
-## Flags {#Flags}
-
-# Allocator {#Allocator}
-
-## MemoryPoolAllocator {#MemoryPoolAllocator}
-
-# Parsing Optimization {#ParsingOptimization}
-
-## Skip Whitespace with SIMD {#SkipwhitespaceWithSIMD}
-
-## Pow10() {#Pow10}
-
-## Local Stream Copy {#LocalStreamCopy}
-
-# Parser {#Parser}
-
-## Iterative Parser {#IterativeParser}
-
-The iterative parser is a recursive descent LL(1) parser
-implemented in a non-recursive manner.
-
-### Grammar {#IterativeParserGrammar}
-
-The grammar used for this parser is based on strict JSON syntax:
-~~~~~~~~~~
-S -> array | object
-array -> [ values ]
-object -> { members }
-values -> non-empty-values | ε
-non-empty-values -> value addition-values
-addition-values -> ε | , non-empty-values
-members -> non-empty-members | ε
-non-empty-members -> member addition-members
-addition-members -> ε | , non-empty-members
-member -> STRING : value
-value -> STRING | NUMBER | NULL | BOOLEAN | object | array
-~~~~~~~~~~
-
-Note that left factoring is applied to non-terminals `values` and `members`
-to make the grammar be LL(1).
-
-### Parsing Table {#IterativeParserParsingTable}
-
-Based on the grammar, we can construct the FIRST and FOLLOW set.
-
-The FIRST set of non-terminals is listed below:
-
-|    NON-TERMINAL   |               FIRST              |
-|:-----------------:|:--------------------------------:|
-|       array       |                 [                |
-|       object      |                 {                |
-|       values      | ε STRING NUMBER NULL BOOLEAN { [ |
-|  addition-values  |              ε COMMA             |
-|      members      |             ε STRING             |
-|  addition-members |              ε COMMA             |
-|       member      |              STRING              |
-|       value       |  STRING NUMBER NULL BOOLEAN { [  |
-|         S         |                [ {               |
-| non-empty-members |              STRING              |
-|  non-empty-values |  STRING NUMBER NULL BOOLEAN { [  |
-
-The FOLLOW set is listed below:
-
-|    NON-TERMINAL   |  FOLLOW |
-|:-----------------:|:-------:|
-|         S         |    $    |
-|       array       | , $ } ] |
-|       object      | , $ } ] |
-|       values      |    ]    |
-|  non-empty-values |    ]    |
-|  addition-values  |    ]    |
-|      members      |    }    |
-| non-empty-members |    }    |
-|  addition-members |    }    |
-|       member      |   , }   |
-|       value       |  , } ]  |
-
-Finally the parsing table can be constructed from FIRST and FOLLOW set:
-
-|    NON-TERMINAL   |           [           |           {           |          ,          | : | ] | } |          STRING         |         NUMBER        |          NULL         |        BOOLEAN        |
-|:-----------------:|:---------------------:|:---------------------:|:-------------------:|:-:|:-:|:-:|:-----------------------:|:---------------------:|:---------------------:|:---------------------:|
-|         S         |         array         |         object        |                     |   |   |   |                         |                       |                       |                       |
-|       array       |       [ values ]      |                       |                     |   |   |   |                         |                       |                       |                       |
-|       object      |                       |      { members }      |                     |   |   |   |                         |                       |                       |                       |
-|       values      |    non-empty-values   |    non-empty-values   |                     |   | ε |   |     non-empty-values    |    non-empty-values   |    non-empty-values   |    non-empty-values   |
-|  non-empty-values | value addition-values | value addition-values |                     |   |   |   |  value addition-values  | value addition-values | value addition-values | value addition-values |
-|  addition-values  |                       |                       |  , non-empty-values |   | ε |   |                         |                       |                       |                       |
-|      members      |                       |                       |                     |   |   | ε |    non-empty-members    |                       |                       |                       |
-| non-empty-members |                       |                       |                     |   |   |   | member addition-members |                       |                       |                       |
-|  addition-members |                       |                       | , non-empty-members |   |   | ε |                         |                       |                       |                       |
-|       member      |                       |                       |                     |   |   |   |      STRING : value     |                       |                       |                       |
-|       value       |         array         |         object        |                     |   |   |   |          STRING         |         NUMBER        |          NULL         |        BOOLEAN        |
-
-There is a great [tool](http://hackingoff.com/compilers/predict-first-follow-set) for above grammar analysis.
-
-### Implementation {#IterativeParserImplementation}
-
-Based on the parsing table, a direct(or conventional) implementation
-that pushes the production body in reverse order
-while generating a production could work.
-
-In RapidJSON, several modifications(or adaptations to current design) are made to a direct implementation.
-
-First, the parsing table is encoded in a state machine in RapidJSON.
-States are constructed by the head and body of production.
-State transitions are constructed by production rules.
-Besides, extra states are added for productions involved with `array` and `object`.
-In this way the generation of array values or object members would be a single state transition,
-rather than several pop/push operations in the direct implementation.
-This also makes the estimation of stack size more easier.
-
-The state diagram is shown as follows:
-
-![State Diagram](diagram/iterative-parser-states-diagram.png)
-
-Second, the iterative parser also keeps track of array's value count and object's member count
-in its internal stack, which may be different from a conventional implementation.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.png b/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.png
deleted file mode 100644
index b3b2f80..0000000
Binary files a/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.png and /dev/null differ
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.svg b/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.svg
deleted file mode 100644
index 9708d5a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/logo/rapidjson.svg
+++ /dev/null
@@ -1,119 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="217.15039"
-   height="60.831055"
-   id="svg2"
-   version="1.1"
-   inkscape:version="0.48.4 r9939"
-   sodipodi:docname="rapidjson.svg">
-  <defs
-     id="defs4">
-    <linearGradient
-       id="linearGradient3801">
-      <stop
-         style="stop-color:#000000;stop-opacity:1;"
-         offset="0"
-         id="stop3803" />
-      <stop
-         style="stop-color:#000000;stop-opacity:0;"
-         offset="1"
-         id="stop3805" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3801"
-       id="linearGradient3807"
-       x1="81.25"
-       y1="52.737183"
-       x2="122.25"
-       y2="52.737183"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.2378503,0,0,1.1662045,-226.99279,64.427324)" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3801"
-       id="linearGradient3935"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(-1.4768835,0,0,2.2904698,246.48785,81.630301)"
-       x1="81.25"
-       y1="52.737183"
-       x2="115.96579"
-       y2="48.439766" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3801"
-       id="linearGradient3947"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.2378503,0,0,1.1662045,-226.99279,-10.072676)"
-       x1="81.25"
-       y1="52.737183"
-       x2="122.25"
-       y2="52.737183" />
-  </defs>
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="2"
-     inkscape:cx="207.8959"
-     inkscape:cy="-3.2283687"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     inkscape:window-width="1920"
-     inkscape:window-height="1137"
-     inkscape:window-x="-8"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     fit-margin-top="10"
-     fit-margin-left="10"
-     fit-margin-right="10"
-     fit-margin-bottom="10" />
-  <metadata
-     id="metadata7">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-39.132812,-38.772339)">
-    <text
-       sodipodi:linespacing="125%"
-       id="text3939"
-       y="79.862183"
-       x="147.5"
-       style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;font-family:Microsoft JhengHei;-inkscape-font-specification:Microsoft JhengHei"
-       xml:space="preserve"><tspan
-         style="font-size:48px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Inconsolata;-inkscape-font-specification:Inconsolata"
-         y="79.862183"
-         x="147.5"
-         id="tspan3941"
-         sodipodi:role="line"><tspan
-           id="tspan3943"
-           style="font-size:42px;font-style:oblique;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;line-height:125%;writing-mode:lr-tb;text-anchor:middle;font-family:Segoe UI;-inkscape-font-specification:Segoe UI Oblique">Rapid</tspan><tspan
-           id="tspan3945"
-           style="font-weight:bold;-inkscape-font-specification:Inconsolata Bold">JSON</tspan></tspan></text>
-  </g>
-</svg>
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/DoxygenLayout.xml b/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/DoxygenLayout.xml
deleted file mode 100644
index b7c9586..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/DoxygenLayout.xml
+++ /dev/null
@@ -1,194 +0,0 @@
-<doxygenlayout version="1.0">
-  <!-- Generated by doxygen 1.8.7 -->
-  <!-- Navigation index tabs for HTML output -->
-  <navindex>
-    <tab type="mainpage" visible="yes" title=""/>
-    <tab type="pages" visible="yes" title="" intro=""/>
-    <tab type="modules" visible="yes" title="" intro=""/>
-    <tab type="namespaces" visible="yes" title="">
-      <tab type="namespacelist" visible="yes" title="" intro=""/>
-      <tab type="namespacemembers" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="classes" visible="yes" title="">
-      <tab type="classlist" visible="yes" title="" intro=""/>
-      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/> 
-      <tab type="hierarchy" visible="yes" title="" intro=""/>
-      <tab type="classmembers" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="files" visible="yes" title="">
-      <tab type="filelist" visible="yes" title="" intro=""/>
-      <tab type="globals" visible="yes" title="" intro=""/>
-    </tab>
-    <tab type="examples" visible="yes" title="" intro=""/>  
-  </navindex>
-
-  <!-- Layout definition for a class page -->
-  <class>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <inheritancegraph visible="$CLASS_GRAPH"/>
-    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
-    <memberdecl>
-      <nestedclasses visible="yes" title=""/>
-      <publictypes title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <publicslots title=""/>
-      <signals title=""/>
-      <publicmethods title=""/>
-      <publicstaticmethods title=""/>
-      <publicattributes title=""/>
-      <publicstaticattributes title=""/>
-      <protectedtypes title=""/>
-      <protectedslots title=""/>
-      <protectedmethods title=""/>
-      <protectedstaticmethods title=""/>
-      <protectedattributes title=""/>
-      <protectedstaticattributes title=""/>
-      <packagetypes title=""/>
-      <packagemethods title=""/>
-      <packagestaticmethods title=""/>
-      <packageattributes title=""/>
-      <packagestaticattributes title=""/>
-      <properties title=""/>
-      <events title=""/>
-      <privatetypes title=""/>
-      <privateslots title=""/>
-      <privatemethods title=""/>
-      <privatestaticmethods title=""/>
-      <privateattributes title=""/>
-      <privatestaticattributes title=""/>
-      <friends title=""/>
-      <related title="" subtitle=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <constructors title=""/>
-      <functions title=""/>
-      <related title=""/>
-      <variables title=""/>
-      <properties title=""/>
-      <events title=""/>
-    </memberdef>
-    <allmemberslink visible="yes"/>
-    <usedfiles visible="$SHOW_USED_FILES"/>
-    <authorsection visible="yes"/>
-  </class>
-
-  <!-- Layout definition for a namespace page -->
-  <namespace>
-    <briefdescription visible="yes"/>
-    <memberdecl>
-      <nestednamespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </namespace>
-
-  <!-- Layout definition for a file page -->
-  <file>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <includegraph visible="$INCLUDE_GRAPH"/>
-    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
-    <sourcelink visible="yes"/>
-    <memberdecl>
-      <classes visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection/>
-  </file>
-
-  <!-- Layout definition for a group page -->
-  <group>
-    <briefdescription visible="yes"/>
-    <groupgraph visible="$GROUP_GRAPHS"/>
-    <memberdecl>
-      <nestedgroups visible="yes" title=""/>
-      <dirs visible="yes" title=""/>
-      <files visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <pagedocs/>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </group>
-
-  <!-- Layout definition for a directory page -->
-  <directory>
-    <briefdescription visible="yes"/>
-    <directorygraph visible="yes"/>
-    <memberdecl>
-      <dirs visible="yes"/>
-      <files visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-  </directory>
-</doxygenlayout>
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/doxygenextra.css b/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/doxygenextra.css
deleted file mode 100644
index 8cc943f..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/doxygenextra.css
+++ /dev/null
@@ -1,260 +0,0 @@
-body code {
-	margin: 0;
-	border: 1px solid #ddd;
-	background-color: #f8f8f8;
-	border-radius: 3px;
-	padding: 0;
-}
-
-a {
-	color: #4183c4;
-}
-
-a.el {
-	font-weight: normal;
-}
-
-body, table, div, p, dl {
-	color: #333333;
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	font-size: 15px;
-	font-style: normal;
-	font-variant: normal;
-	font-weight: normal;
-	line-height: 25.5px;
-}
-
-body {
-	background-color: #eee;
-}
-
-div.header {
-	background-image: none;
-	background-color: white;
-	margin: 0px;
-	border: 0px;
-}
-
-div.headertitle {
-	width: 858px;
-	margin: 30px;
-	padding: 0px;
-}
-
-div.toc {
-	background-color: #f8f8f8;
-	border-color: #ddd;
-	margin-right: 10px;
-	margin-left: 20px;
-}
-div.toc h3 {
-	color: #333333;
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	font-size: 18px;
-	font-style: normal;
-	font-variant: normal;
-	font-weight: normal;
-}
-div.toc li {
-	color: #333333;
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	font-size: 12px;
-	font-style: normal;
-	font-variant: normal;
-	font-weight: normal;
-}
-
-.title {
-	font-size: 2.5em;
-	line-height: 63.75px;
-	border-bottom: 1px solid #ddd;
-	margin-bottom: 15px;
-	margin-left: 0px;
-	margin-right: 0px;
-	margin-top: 0px;
-}
-
-body h1 {
-	font-size: 2em;
-	line-height: 1.7;
-	border-bottom: 1px solid #eee;
-	margin: 1em 0 15px;
-	padding: 0;
-	overflow: hidden;
-}
-
-body h2 {
-	font-size: 1.5em;
-	line-height: 1.7;
-	margin: 1em 0 15px;
-	padding: 0;
-}
-
-pre.fragment {
-	font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
-	font-size: 13px;
-	font-style: normal;
-	font-variant: normal;
-	font-weight: normal;
-	line-height: 19px;
-}
-
-table.doxtable th {
-	background-color: #f8f8f8;
-	color: #333333;
-	font-size: 15px;
-}
-
-table.doxtable td, table.doxtable th {
-	border: 1px solid #ddd;
-}
-
-#doc-content {
-	background-color: #fff;
-	width: 918px;
-	height: auto !important;
-}
-
-div.contents {
-	width: 858px;
-	margin: 30px;
-}
-
-div.line {
-	font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
-	font-size: 13px;
-	font-style: normal;
-	font-variant: normal;
-	font-weight: normal;
-	line-height: 19px;	
-}
-
-tt, code, pre {
-	font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
-	font-size: 12px;
-}
-
-div.fragment {
-	background-color: #f8f8f8;
-	border: 1px solid #ddd;
-	font-size: 13px;
-	line-height: 19px;
-	overflow: auto;
-	padding: 6px 10px;
-	border-radius: 3px;
-}
-
-#topbanner {
-	position: fixed;
-	margin: 15px;
-	z-index: 101;
-}
-
-#projectname
-{
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	font-size: 38px;
-	font-weight: bold;
-	line-height: 63.75px;
-	margin: 0px;
-	padding: 2px 0px;
-}
-    
-#projectbrief
-{
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	font-size: 16px;
-	line-height: 22.4px;
-	margin: 0px 0px 13px 0px;
-	padding: 2px;
-}
-
-/* side bar and search */
-
-#side-nav
-{
-	padding: 10px 0px 20px 20px;
-	border-top: 60px solid #2980b9;
-	background-color: #343131;
-	width: 250px !important;
-	position: fixed
-}
-
-#nav-tree
-{
-	background-color: transparent;
-	background-image: none;
-	height: 100% !important;
-}
-
-#nav-tree .label
-{
-	font-family: Helvetica, arial, freesans, clean, sans-serif, 'Segoe UI Emoji', 'Segoe UI Symbol';
-	line-height: 25.5px;	
-	font-size: 15px;
-}
-
-#nav-tree
-{
-	color: #b3b3b3;
-}
-
-#nav-tree .selected {
-	background-image: none;
-}
-
-#nav-tree a
-{
-	color: #b3b3b3;
-}
-
-#github
-{
-	position: fixed;
-	left: auto;
-	right: auto;
-	width: 250px;
-}
-
-#MSearchBox
-{
-	margin: 20px;
-	left: 40px;
-	right: auto;
-	position: fixed;
-	width: 180px;
-}
-
-#MSearchField
-{
-	width: 121px;
-}
-
-#MSearchResultsWindow
-{
-	left: 45px !important;
-}
-
-#nav-sync
-{
-	display: none;
-}
-
-.ui-resizable .ui-resizable-handle
-{
-	width: 0px;
-}
-
-#nav-path
-{
-	display: none;
-}
-
-/* external link icon */
-div.contents a[href ^= "http"]:after {
-     content: " " url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAVklEQVR4Xn3PgQkAMQhDUXfqTu7kTtkpd5RA8AInfArtQ2iRXFWT2QedAfttj2FsPIOE1eCOlEuoWWjgzYaB/IkeGOrxXhqB+uA9Bfcm0lAZuh+YIeAD+cAqSz4kCMUAAAAASUVORK5CYII=);
-}
-
-.githublogo {
-	content: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyRpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNS1jMDIxIDc5LjE1NDkxMSwgMjAxMy8xMC8yOS0xMTo0NzoxNiAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6RERCMUIwOUY4NkNFMTFFM0FBNTJFRTMzNTJEMUJDNDYiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6RERCMUIwOUU4NkNFMTFFM0FBNTJFRTMzNTJEMUJDNDYiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNiAoTWFjaW50b3NoKSI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkU1MTc4QTJBOTlBMDExRTI5QTE1QkMxMDQ2QTg5MDREIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOkU1MTc4QTJCOTlBMDExRTI5QTE1QkMxMDQ2QTg5MDREIi8+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+jUqS1wAAApVJREFUeNq0l89rE1EQx3e3gVJoSPzZeNEWPKgHoa0HBak0iHiy/4C3WvDmoZ56qJ7txVsPQu8qlqqHIhRKJZceesmhioQEfxTEtsoSpdJg1u/ABJ7Pmc1m8zLwgWTmzcw3L+/te+tHUeQltONgCkyCi2AEDHLsJ6iBMlgHL8FeoqokoA2j4CloRMmtwTmj7erHBXPgCWhG6a3JNXKdCiDl1cidVbXZkJoXQRi5t5BrxwoY71FzU8S4JuAIqFkJ2+BFSlEh525b/hr3+k/AklDkNsf6wTT4yv46KIMNpsy+iMdMc47HNWxbsgVcUn7FmLAzzoFAWDsBx+wVP6bUpp5ewI+DOeUx0Wd9D8F70BTGNjkWtqnhmT1JQAHcUgZd8Lo3rQb1LAT8eJVUfgGvHQigGp+V2Z0iAUUl8QH47kAA1XioxIo+bRN8OG8F/oBjwv+Z1nJgX5jpdzQDw0LCjsPmrcW7I/iHScCAEDj03FtD8A0EyuChHgg4KTlJQF3wZ7WELppnBX+dBFSVpJsOBWi1qiRgSwnOgoyD5hmuJdkWCVhTgnTvW3AgYIFrSbZGh0UW/Io5Vp+DQoK7o80pztWMemZbgxeNwCNwDbw1fIfgGZjhU6xPaJgBV8BdsMw5cbZoHsenwYFxkZzl83xTSKTiviCAfCsJLysH3POfC8m8NegyGAGfLP/VmGmfSChgXroR0RSWjEFv2J/nG84cuKFMf4sTCZqXuJd4KaXFVjEG3+tw4eXbNK/YC9oXXs3O8NY8y99L4BXY5cvLY/Bb2VZ58EOJVcB18DHJq9lRsKr8inyKGVjlmh29mtHs3AHfuhCwy1vXT/Nu2GKQt+UHsGdctyX6eQyNvc+5sfX9Dl7Pe2J/BRgAl2CpwmrsHR0AAAAASUVORK5CYII=);
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/footer.html b/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/footer.html
deleted file mode 100644
index 0984145..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/footer.html
+++ /dev/null
@@ -1,9 +0,0 @@
-<!-- HTML footer for doxygen 1.8.7-->
-<!-- start footer part -->
-<!--BEGIN GENERATE_TREEVIEW-->
-<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
-  <ul>
-    $navpath
-  </ul>
-</div>
-<!--END GENERATE_TREEVIEW-->
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/header.html b/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/header.html
deleted file mode 100644
index 2dbe721..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/misc/header.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<!-- HTML header for doxygen 1.8.7-->
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
-<meta http-equiv="X-UA-Compatible" content="IE=9"/>
-<meta name="generator" content="Doxygen $doxygenversion"/>
-<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
-<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
-<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
-<script type="text/javascript" src="$relpath^jquery.js"></script>
-<script type="text/javascript" src="$relpath^dynsections.js"></script>
-$treeview
-$search
-$mathjax
-<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
-$extrastylesheet
-</head>
-<body>
-<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
-<div id="topbanner"><a href="https://github.com/miloyip/rapidjson" title="RapidJSON GitHub"><i class="githublogo"></i></a></div>
-$searchbox
-<!--END TITLEAREA-->
-<!-- end header part -->
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/performance.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/performance.md
deleted file mode 100644
index 333e50f..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/performance.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# Performance
-
-The old performance article for RapidJSON 0.1 is provided [here](https://code.google.com/p/rapidjson/wiki/Performance).
-
-The (third-party) performance tests have been removed from this repository
-and are now part of a dedicated [native JSON benchmark collection] [1].
-
-This file will be updated with a summary of benchmarking results based on
-the above benchmark collection in the future.
-
-[1]: https://github.com/miloyip/nativejson-benchmark
-
-Additionally, you may refer to the following third-party benchmarks.
-
-## Third-party benchmarks
-
-* [Basic benchmarks for miscellaneous C++ JSON parsers and generators](https://github.com/mloskot/json_benchmark) by Mateusz Loskot (Jun 2013)
- * [casablanca](https://casablanca.codeplex.com/)
- * [json_spirit](https://github.com/cierelabs/json_spirit)
- * [jsoncpp](http://jsoncpp.sourceforge.net/)
- * [libjson](http://sourceforge.net/projects/libjson/)
- * [rapidjson](https://github.com/miloyip/rapidjson/)
- * [QJsonDocument](http://qt-project.org/doc/qt-5.0/qtcore/qjsondocument.html)
- 
-* [JSON Parser Benchmarking](http://chadaustin.me/2013/01/json-parser-benchmarking/) by Chad Austin (Jan 2013)
- * [sajson](https://github.com/chadaustin/sajson)
- * [rapidjson](https://github.com/miloyip/rapidjson/)
- * [vjson](https://code.google.com/p/vjson/)
- * [YAJL](http://lloyd.github.com/yajl/)
- * [Jansson](http://www.digip.org/jansson/)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/sax.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/sax.md
deleted file mode 100644
index 9a6d814..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/sax.md
+++ /dev/null
@@ -1,475 +0,0 @@
-# SAX
-
-The term "SAX" originated from [Simple API for XML](http://en.wikipedia.org/wiki/Simple_API_for_XML). We borrowed this term for JSON parsing and generation.
-
-In RapidJSON, `Reader` (typedef of `GenericReader<...>`) is the SAX-style parser for JSON, and `Writer` (typedef of `GenericWriter<...>`) is the SAX-style generator for JSON.
-
-[TOC]
-
-# Reader {#Reader}
-
-`Reader` parses a JSON from a stream. While it reads characters from the stream, it analyze the characters according to the syntax of JSON, and publish events to a handler.
-
-For example, here is a JSON.
-
-~~~~~~~~~~js
-{
-    "hello": "world",
-    "t": true ,
-    "f": false,
-    "n": null,
-    "i": 123,
-    "pi": 3.1416,
-    "a": [1, 2, 3, 4]
-}
-~~~~~~~~~~
-
-While a `Reader` parses this JSON, it publishes the following events to the handler sequentially:
-
-~~~~~~~~~~
-StartObject()
-Key("hello", 5, true)
-String("world", 5, true)
-Key("t", 1, true)
-Bool(true)
-Key("f", 1, true)
-Bool(false)
-Key("n", 1, true)
-Null()
-Key("i")
-UInt(123)
-Key("pi")
-Double(3.1416)
-Key("a")
-StartArray()
-Uint(1)
-Uint(2)
-Uint(3)
-Uint(4)
-EndArray(4)
-EndObject(7)
-~~~~~~~~~~
-
-These events can be easily matched with the JSON, except some event parameters need further explanation. Let's see the `simplereader` example which produces exactly the same output as above:
-
-~~~~~~~~~~cpp
-#include "rapidjson/reader.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-struct MyHandler {
-    bool Null() { cout << "Null()" << endl; return true; }
-    bool Bool(bool b) { cout << "Bool(" << boolalpha << b << ")" << endl; return true; }
-    bool Int(int i) { cout << "Int(" << i << ")" << endl; return true; }
-    bool Uint(unsigned u) { cout << "Uint(" << u << ")" << endl; return true; }
-    bool Int64(int64_t i) { cout << "Int64(" << i << ")" << endl; return true; }
-    bool Uint64(uint64_t u) { cout << "Uint64(" << u << ")" << endl; return true; }
-    bool Double(double d) { cout << "Double(" << d << ")" << endl; return true; }
-    bool String(const char* str, SizeType length, bool copy) { 
-        cout << "String(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool StartObject() { cout << "StartObject()" << endl; return true; }
-    bool Key(const char* str, SizeType length, bool copy) { 
-        cout << "Key(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool EndObject(SizeType memberCount) { cout << "EndObject(" << memberCount << ")" << endl; return true; }
-    bool StartArray() { cout << "StartArray()" << endl; return true; }
-    bool EndArray(SizeType elementCount) { cout << "EndArray(" << elementCount << ")" << endl; return true; }
-};
-
-void main() {
-    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
-
-    MyHandler handler;
-    Reader reader;
-    StringStream ss(json);
-    reader.Parse(ss, handler);
-}
-~~~~~~~~~~
-
-Note that, RapidJSON uses template to statically bind the `Reader` type and the handler type, instead of using class with virtual functions. This paradigm can improve the performance by inlining functions.
-
-## Handler {#Handler}
-
-As the previous example showed, user needs to implement a handler, which consumes the events (function calls) from `Reader`. The handler must contain the following member functions.
-
-~~~~~~~~~~cpp
-class Handler {
-    bool Null();
-    bool Bool(bool b);
-    bool Int(int i);
-    bool Uint(unsigned i);
-    bool Int64(int64_t i);
-    bool Uint64(uint64_t i);
-    bool Double(double d);
-    bool String(const Ch* str, SizeType length, bool copy);
-    bool StartObject();
-    bool Key(const Ch* str, SizeType length, bool copy);
-    bool EndObject(SizeType memberCount);
-    bool StartArray();
-    bool EndArray(SizeType elementCount);
-};
-~~~~~~~~~~
-
-`Null()` is called when the `Reader` encounters a JSON null value.
-
-`Bool(bool)` is called when the `Reader` encounters a JSON true or false value.
-
-When the `Reader` encounters a JSON number, it chooses a suitable C++ type mapping. And then it calls *one* function out of `Int(int)`, `Uint(unsigned)`, `Int64(int64_t)`, `Uint64(uint64_t)` and `Double(double)`.
-
-`String(const char* str, SizeType length, bool copy)` is called when the `Reader` encounters a string. The first parameter is pointer to the string. The second parameter is the length of the string (excluding the null terminator). Note that RapidJSON supports null character `'\0'` inside a string. If such situation happens, `strlen(str) < length`. The last `copy` indicates whether the handler needs to make a copy of the string. For normal parsing, `copy = true`. Only when *insitu* parsing is used, `copy = false`. And beware that, the character type depends on the target encoding, which will be explained later.
-
-When the `Reader` encounters the beginning of an object, it calls `StartObject()`. An object in JSON is a set of name-value pairs. If the object contains members it first calls `Key()` for the name of member, and then calls functions depending on the type of the value. These calls of name-value pairs repeats until calling `EndObject(SizeType memberCount)`. Note that the `memberCount` parameter is just an aid for the handler, user may not need this parameter.
-
-Array is similar to object but simpler. At the beginning of an array, the `Reader` calls `BeginArary()`. If there is elements, it calls functions according to the types of element. Similarly, in the last call `EndArray(SizeType elementCount)`, the parameter `elementCount` is just an aid for the handler.
-
-Every handler functions returns a `bool`. Normally it should returns `true`. If the handler encounters an error, it can return `false` to notify event publisher to stop further processing.
-
-For example, when we parse a JSON with `Reader` and the handler detected that the JSON does not conform to the required schema, then the handler can return `false` and let the `Reader` stop further parsing. And the `Reader` will be in error state with error code `kParseErrorTermination`.
-
-## GenericReader {#GenericReader}
-
-As mentioned before, `Reader` is a typedef of a template class `GenericReader`:
-
-~~~~~~~~~~cpp
-namespace rapidjson {
-
-template <typename SourceEncoding, typename TargetEncoding, typename Allocator = MemoryPoolAllocator<> >
-class GenericReader {
-    // ...
-};
-
-typedef GenericReader<UTF8<>, UTF8<> > Reader;
-
-} // namespace rapidjson
-~~~~~~~~~~
-
-The `Reader` uses UTF-8 as both source and target encoding. The source encoding means the encoding in the JSON stream. The target encoding means the encoding of the `str` parameter in `String()` calls. For example, to parse a UTF-8 stream and outputs UTF-16 string events, you can define a reader by:
-
-~~~~~~~~~~cpp
-GenericReader<UTF8<>, UTF16<> > reader;
-~~~~~~~~~~
-
-Note that, the default character type of `UTF16` is `wchar_t`. So this `reader`needs to call `String(const wchar_t*, SizeType, bool)` of the handler.
-
-The third template parameter `Allocator` is the allocator type for internal data structure (actually a stack).
-
-## Parsing {#Parsing}
-
-The one and only one function of `Reader` is to parse JSON. 
-
-~~~~~~~~~~cpp
-template <unsigned parseFlags, typename InputStream, typename Handler>
-bool Parse(InputStream& is, Handler& handler);
-
-// with parseFlags = kDefaultParseFlags
-template <typename InputStream, typename Handler>
-bool Parse(InputStream& is, Handler& handler);
-~~~~~~~~~~
-
-If an error occurs during parsing, it will return `false`. User can also calls `bool HasParseEror()`, `ParseErrorCode GetParseErrorCode()` and `size_t GetErrorOffset()` to obtain the error states. Actually `Document` uses these `Reader` functions to obtain parse errors. Please refer to [DOM](doc/dom.md) for details about parse error.
-
-# Writer {#Writer}
-
-`Reader` converts (parses) JSON into events. `Writer` does exactly the opposite. It converts events into JSON. 
-
-`Writer` is very easy to use. If your application only need to converts some data into JSON, it may be a good choice to use `Writer` directly, instead of building a `Document` and then stringifying it with a `Writer`.
-
-In `simplewriter` example, we do exactly the reverse of `simplereader`.
-
-~~~~~~~~~~cpp
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-void main() {
-    StringBuffer s;
-    Writer<StringBuffer> writer(s);
-    
-    writer.StartObject();
-    writer.Key("hello");
-    writer.String("world");
-    writer.Key("t");
-    writer.Bool(true);
-    writer.Key("f");
-    writer.Bool(false);
-    writer.Key("n");
-    writer.Null();
-    writer.Key("i");
-    writer.Uint(123);
-    writer.Key("pi");
-    writer.Double(3.1416);
-    writer.Key("a");
-    writer.StartArray();
-    for (unsigned i = 0; i < 4; i++)
-        writer.Uint(i);
-    writer.EndArray();
-    writer.EndObject();
-
-    cout << s.GetString() << endl;
-}
-~~~~~~~~~~
-
-~~~~~~~~~~
-{"hello":"world","t":true,"f":false,"n":null,"i":123,"pi":3.1416,"a":[0,1,2,3]}
-~~~~~~~~~~
-
-There are two `String()` and `Key()` overloads. One is the same as defined in handler concept with 3 parameters. It can handle string with null characters. Another one is the simpler version used in the above example.
-
-Note that, the example code does not pass any parameters in `EndArray()` and `EndObject()`. An `SizeType` can be passed but it will be simply ignored by `Writer`.
-
-You may doubt that, why not just using `sprintf()` or `std::stringstream` to build a JSON?
-
-There are various reasons:
-1. `Writer` must output a well-formed JSON. If there is incorrect event sequence (e.g. `Int()` just after `StartObject()`), it generates assertion fail in debug mode.
-2. `Writer::String()` can handle string escaping (e.g. converting code point `U+000A` to `\n`) and Unicode transcoding.
-3. `Writer` handles number output consistently.
-4. `Writer` implements the event handler concept. It can be used to handle events from `Reader`, `Document` or other event publisher.
-5. `Writer` can be optimized for different platforms.
-
-Anyway, using `Writer` API is even simpler than generating a JSON by ad hoc methods.
-
-## Template {#WriterTemplate}
-
-`Writer` has a minor design difference to `Reader`. `Writer` is a template class, not a typedef. There is no `GenericWriter`. The following is the declaration.
-
-~~~~~~~~~~cpp
-namespace rapidjson {
-
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename Allocator = CrtAllocator<> >
-class Writer {
-public:
-    Writer(OutputStream& os, Allocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth)
-// ...
-};
-
-} // namespace rapidjson
-~~~~~~~~~~
-
-The `OutputStream` template parameter is the type of output stream. It cannot be deduced and must be specified by user.
-
-The `SourceEncoding` template parameter specifies the encoding to be used in `String(const Ch*, ...)`.
-
-The `TargetEncoding` template parameter specifies the encoding in the output stream.
-
-The last one, `Allocator` is the type of allocator, which is used for allocating internal data structure (a stack).
-
-Besides, the constructor of `Writer` has a `levelDepth` parameter. This parameter affects the initial memory allocated for storing information per hierarchy level.
-
-## PrettyWriter {#PrettyWriter}
-
-While the output of `Writer` is the most condensed JSON without white-spaces, suitable for network transfer or storage, it is not easily readable by human.
-
-Therefore, RapidJSON provides a `PrettyWriter`, which adds indentation and line feeds in the output.
-
-The usage of `PrettyWriter` is exactly the same as `Writer`, expect that `PrettyWriter` provides a `SetIndent(Ch indentChar, unsigned indentCharCount)` function. The default is 4 spaces.
-
-## Completeness and Reset {#CompletenessReset}
-
-A `Writer` can only output a single JSON, which can be any JSON type at the root. Once the singular event for root (e.g. `String()`), or the last matching `EndObject()` or `EndArray()` event, is handled, the output JSON is well-formed and complete. User can detect this state by calling `Writer::IsComplete()`.
-
-When a JSON is complete, the `Writer` cannot accept any new events. Otherwise the output will be invalid (i.e. having more than one root). To reuse the `Writer` object, user can call `Writer::Reset(OutputStream& os)` to reset all internal states of the `Writer` with a new output stream.
-
-# Techniques {#Techniques}
-
-## Parsing JSON to Custom Data Structure {#CustomDataStructure}
-
-`Document`'s parsing capability is completely based on `Reader`. Actually `Document` is a handler which receives events from a reader to build a DOM during parsing.
-
-User may uses `Reader` to build other data structures directly. This eliminates building of DOM, thus reducing memory and improving performance.
-
-In the following `messagereader` example, `ParseMessages()` parses a JSON which should be an object with key-string pairs.
-
-~~~~~~~~~~cpp
-#include "rapidjson/reader.h"
-#include "rapidjson/error/en.h"
-#include <iostream>
-#include <string>
-#include <map>
-
-using namespace std;
-using namespace rapidjson;
-
-typedef map<string, string> MessageMap;
-
-struct MessageHandler
-    : public BaseReaderHandler<UTF8<>, MessageHandler> {
-    MessageHandler() : state_(kExpectObjectStart) {
-    }
-
-    bool StartObject() {
-        switch (state_) {
-        case kExpectObjectStart:
-            state_ = kExpectNameOrObjectEnd;
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    bool String(const char* str, SizeType length, bool) {
-        switch (state_) {
-        case kExpectNameOrObjectEnd:
-            name_ = string(str, length);
-            state_ = kExpectValue;
-            return true;
-        case kExpectValue:
-            messages_.insert(MessageMap::value_type(name_, string(str, length)));
-            state_ = kExpectNameOrObjectEnd;
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    bool EndObject(SizeType) { return state_ == kExpectNameOrObjectEnd; }
-
-    bool Default() { return false; } // All other events are invalid.
-
-    MessageMap messages_;
-    enum State {
-        kExpectObjectStart,
-        kExpectNameOrObjectEnd,
-        kExpectValue,
-    }state_;
-    std::string name_;
-};
-
-void ParseMessages(const char* json, MessageMap& messages) {
-    Reader reader;
-    MessageHandler handler;
-    StringStream ss(json);
-    if (reader.Parse(ss, handler))
-        messages.swap(handler.messages_);   // Only change it if success.
-    else {
-        ParseErrorCode e = reader.GetParseErrorCode();
-        size_t o = reader.GetErrorOffset();
-        cout << "Error: " << GetParseError_En(e) << endl;;
-        cout << " at offset " << o << " near '" << string(json).substr(o, 10) << "...'" << endl;
-    }
-}
-
-int main() {
-    MessageMap messages;
-
-    const char* json1 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\" }";
-    cout << json1 << endl;
-    ParseMessages(json1, messages);
-
-    for (MessageMap::const_iterator itr = messages.begin(); itr != messages.end(); ++itr)
-        cout << itr->first << ": " << itr->second << endl;
-
-    cout << endl << "Parse a JSON with invalid schema." << endl;
-    const char* json2 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\", \"foo\" : {} }";
-    cout << json2 << endl;
-    ParseMessages(json2, messages);
-
-    return 0;
-}
-~~~~~~~~~~
-
-~~~~~~~~~~
-{ "greeting" : "Hello!", "farewell" : "bye-bye!" }
-farewell: bye-bye!
-greeting: Hello!
-
-Parse a JSON with invalid schema.
-{ "greeting" : "Hello!", "farewell" : "bye-bye!", "foo" : {} }
-Error: Terminate parsing due to Handler error.
- at offset 59 near '} }...'
-~~~~~~~~~~
-
-The first JSON (`json1`) was successfully parsed into `MessageMap`. Since `MessageMap` is a `std::map`, the printing order are sorted by the key. This order is different from the JSON's order.
-
-In the second JSON (`json2`), `foo`'s value is an empty object. As it is an object, `MessageHandler::StartObject()` will be called. However, at that moment `state_ = kExpectValue`, so that function returns `false` and cause the parsing process be terminated. The error code is `kParseErrorTermination`.
-
-## Filtering of JSON {#Filtering}
-
-As mentioned earlier, `Writer` can handle the events published by `Reader`. `condense` example simply set a `Writer` as handler of a `Reader`, so it can remove all white-spaces in JSON. `pretty` example uses the same relationship, but replacing `Writer` by `PrettyWriter`. So `pretty` can be used to reformat a JSON with indentation and line feed.
-
-Actually, we can add intermediate layer(s) to filter the contents of JSON via these SAX-style API. For example, `capitalize` example capitalize all strings in a JSON.
-
-~~~~~~~~~~cpp
-#include "rapidjson/reader.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/error/en.h"
-#include <vector>
-#include <cctype>
-
-using namespace rapidjson;
-
-template<typename OutputHandler>
-struct CapitalizeFilter {
-    CapitalizeFilter(OutputHandler& out) : out_(out), buffer_() {
-    }
-
-    bool Null() { return out_.Null(); }
-    bool Bool(bool b) { return out_.Bool(b); }
-    bool Int(int i) { return out_.Int(i); }
-    bool Uint(unsigned u) { return out_.Uint(u); }
-    bool Int64(int64_t i) { return out_.Int64(i); }
-    bool Uint64(uint64_t u) { return out_.Uint64(u); }
-    bool Double(double d) { return out_.Double(d); }
-    bool String(const char* str, SizeType length, bool) { 
-        buffer_.clear();
-        for (SizeType i = 0; i < length; i++)
-            buffer_.push_back(std::toupper(str[i]));
-        return out_.String(&buffer_.front(), length, true); // true = output handler need to copy the string
-    }
-    bool StartObject() { return out_.StartObject(); }
-    bool Key(const char* str, SizeType length, bool copy) { return String(str, length, copy); }
-    bool EndObject(SizeType memberCount) { return out_.EndObject(memberCount); }
-    bool StartArray() { return out_.StartArray(); }
-    bool EndArray(SizeType elementCount) { return out_.EndArray(elementCount); }
-
-    OutputHandler& out_;
-    std::vector<char> buffer_;
-};
-
-int main(int, char*[]) {
-    // Prepare JSON reader and input stream.
-    Reader reader;
-    char readBuffer[65536];
-    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
-
-    // Prepare JSON writer and output stream.
-    char writeBuffer[65536];
-    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
-    Writer<FileWriteStream> writer(os);
-
-    // JSON reader parse from the input stream and let writer generate the output.
-    CapitalizeFilter<Writer<FileWriteStream> > filter(writer);
-    if (!reader.Parse(is, filter)) {
-        fprintf(stderr, "\nError(%u): %s\n", (unsigned)reader.GetErrorOffset(), GetParseError_En(reader.GetParseErrorCode()));
-        return 1;
-    }
-
-    return 0;
-}
-~~~~~~~~~~
-
-Note that, it is incorrect to simply capitalize the JSON as a string. For example:
-~~~~~~~~~~
-["Hello\nWorld"]
-~~~~~~~~~~
-
-Simply capitalizing the whole JSON would contain incorrect escape character:
-~~~~~~~~~~
-["HELLO\NWORLD"]
-~~~~~~~~~~
-
-The correct result by `capitalize`:
-~~~~~~~~~~
-["HELLO\nWORLD"]
-~~~~~~~~~~
-
-More complicated filters can be developed. However, since SAX-style API can only provide information about a single event at a time, user may need to book-keeping the contextual information (e.g. the path from root value, storage of other related values). Some processing may be easier to be implemented in DOM than SAX.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/stream.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/stream.md
deleted file mode 100644
index 94bc10d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/stream.md
+++ /dev/null
@@ -1,374 +0,0 @@
-# Stream
-
-In RapidJSON, `rapidjson::Stream` is a concept for reading/writing JSON. Here we first show how to use streams provided. And then see how to create a custom stream.
-
-[TOC]
-
-# Memory Streams {#MemoryStreams}
-
-Memory streams store JSON in memory.
-
-## StringStream (Input) {#StringStream}
-
-`StringStream` is the most basic input stream. It represents a complete, read-only JSON stored in memory. It is defined in `rapidjson/rapidjson.h`.
-
-~~~~~~~~~~cpp
-#include "rapidjson/document.h" // will include "rapidjson/rapidjson.h"
-
-using namespace rapidjson;
-
-// ...
-const char json[] = "[1, 2, 3, 4]";
-StringStream s(json);
-
-Document d;
-d.ParseStream(s);
-~~~~~~~~~~
-
-Since this is very common usage, `Document::Parse(const char*)` is provided to do exactly the same as above:
-
-~~~~~~~~~~cpp
-// ...
-const char json[] = "[1, 2, 3, 4]";
-Document d;
-d.Parse(json);
-~~~~~~~~~~
-
-Note that, `StringStream` is a typedef of `GenericStringStream<UTF8<> >`, user may use another encodings to represent the character set of the stream.
-
-## StringBuffer (Output) {#StringBuffer}
-
-`StringBuffer` is a simple output stream. It allocates a memory buffer for writing the whole JSON. Use `GetString()` to obtain the buffer.
-
-~~~~~~~~~~cpp
-#include "rapidjson/stringbuffer.h"
-
-StringBuffer buffer;
-Writer<StringBuffer> writer(buffer);
-d.Accept(writer);
-
-const char* output = buffer.GetString();
-~~~~~~~~~~
-
-When the buffer is full, it will increases the capacity automatically. The default capacity is 256 characters (256 bytes for UTF8, 512 bytes for UTF16, etc.). User can provide an allocator and a initial capacity.
-
-~~~~~~~~~~cpp
-StringBuffer buffer1(0, 1024); // Use its allocator, initial size = 1024
-StringBuffer buffer2(allocator, 1024);
-~~~~~~~~~~
-
-By default, `StringBuffer` will instantiate an internal allocator.
-
-Similarly, `StringBuffer` is a typedef of `GenericStringBuffer<UTF8<> >`.
-
-# File Streams {#FileStreams}
-
-When parsing a JSON from file, you may read the whole JSON into memory and use ``StringStream`` above.
-
-However, if the JSON is big, or memory is limited, you can use `FileReadStream`. It only read a part of JSON from file into buffer, and then let the part be parsed. If it runs out of characters in the buffer, it will read the next part from file.
-
-## FileReadStream (Input) {#FileReadStream}
-
-`FileReadStream` reads the file via a `FILE` pointer. And user need to provide a buffer.
-
-~~~~~~~~~~cpp
-#include "rapidjson/filereadstream.h"
-#include <cstdio>
-
-using namespace rapidjson;
-
-FILE* fp = fopen("big.json", "rb"); // non-Windows use "r"
-
-char readBuffer[65536];
-FileReadStream is(fp, readBuffer, sizeof(readBuffer));
-
-Document d;
-d.ParseStream(is);
-
-fclose(fp);
-~~~~~~~~~~
-
-Different from string streams, `FileReadStream` is byte stream. It does not handle encodings. If the file is not UTF-8, the byte stream can be wrapped in a `EncodedInputStream`. It will be discussed very soon.
-
-Apart from reading file, user can also use `FileReadStream` to read `stdin`.
-
-## FileWriteStream (Output) {#FileWriteStream}
-
-`FileWriteStream` is buffered output stream. Its usage is very similar to `FileReadStream`.
-
-~~~~~~~~~~cpp
-#include "rapidjson/filewritestream.h"
-#include <cstdio>
-
-using namespace rapidjson;
-
-Document d;
-d.Parse(json);
-// ...
-
-FILE* fp = fopen("output.json", "wb"); // non-Windows use "w"
-
-char writeBuffer[65536];
-FileWriteStream os(fp, writeBuffer, sizeof(writeBuffer));
-
-Writer<FileWriteStream> writer(os);
-d.Accept(writer);
-
-fclose(fp);
-~~~~~~~~~~
-
-It can also directs the output to `stdout`.
-
-# Encoded Streams {#EncodedStreams}
-
-Encoded streams do not contain JSON itself, but they wrap byte streams to provide basic encoding/decoding function.
-
-As mentioned above, UTF-8 byte streams can be read directly. However, UTF-16 and UTF-32 have endian issue. To handle endian correctly, it needs to convert bytes into characters (e.g. `wchar_t` for UTF-16) while reading, and characters into bytes while writing.
-
-Besides, it also need to handle [byte order mark (BOM)](http://en.wikipedia.org/wiki/Byte_order_mark). When reading from a byte stream, it is needed to detect or just consume the BOM if exists. When writing to a byte stream, it can optionally write BOM.
-
-If the encoding of stream is known in compile-time, you may use `EncodedInputStream` and `EncodedOutputStream`. If the stream can be UTF-8, UTF-16LE, UTF-16BE, UTF-32LE, UTF-32BE JSON, and it is only known in runtime, you may use `AutoUTFInputStream` and `AutoUTFOutputStream`. These streams are defined in `rapidjson/encodedstream.h`.
-
-Note that, these encoded streams can be applied to streams other than file. For example, you may have a file in memory, or a custom byte stream, be wrapped in encoded streams.
-
-## EncodedInputStream {#EncodedInputStream}
-
-`EncodedInputStream` has two template parameters. The first one is a `Encoding` class, such as `UTF8`, `UTF16LE`, defined in `rapidjson/encodings.h`. The second one is the class of stream to be wrapped.
-
-~~~~~~~~~~cpp
-#include "rapidjson/document.h"
-#include "rapidjson/filereadstream.h"   // FileReadStream
-#include "rapidjson/encodedstream.h"    // EncodedInputStream
-#include <cstdio>
-
-using namespace rapidjson;
-
-FILE* fp = fopen("utf16le.json", "rb"); // non-Windows use "r"
-
-char readBuffer[256];
-FileReadStream bis(fp, readBuffer, sizeof(readBuffer));
-
-EncodedInputStream<UTF16LE<>, FileReadStream> eis(bis);  // wraps bis into eis
-
-Document d; // Document is GenericDocument<UTF8<> > 
-d.ParseStream<0, UTF16LE<> >(eis);  // Parses UTF-16LE file into UTF-8 in memory
-
-fclose(fp);
-~~~~~~~~~~
-
-## EncodedOutputStream {#EncodedOutputStream}
-
-`EncodedOutputStream` is similar but it has a `bool putBOM` parameter in the constructor, controlling whether to write BOM into output byte stream.
-
-~~~~~~~~~~cpp
-#include "rapidjson/filewritestream.h"  // FileWriteStream
-#include "rapidjson/encodedstream.h"    // EncodedOutputStream
-#include <cstdio>
-
-Document d;         // Document is GenericDocument<UTF8<> > 
-// ...
-
-FILE* fp = fopen("output_utf32le.json", "wb"); // non-Windows use "w"
-
-char writeBuffer[256];
-FileWriteStream bos(fp, writeBuffer, sizeof(writeBuffer));
-
-typedef EncodedOutputStream<UTF32LE<>, FileWriteStream> OutputStream;
-OutputStream eos(bos, true);   // Write BOM
-
-Writer<OutputStream, UTF32LE<>, UTF8<>> writer(eos);
-d.Accept(writer);   // This generates UTF32-LE file from UTF-8 in memory
-
-fclose(fp);
-~~~~~~~~~~
-
-## AutoUTFInputStream {#AutoUTFInputStream}
-
-Sometimes an application may want to handle all supported JSON encoding. `AutoUTFInputStream` will detection encoding by BOM first. If BOM is unavailable, it will use  characteristics of valid JSON to make detection. If neither method success, it falls back to the UTF type provided in constructor.
-
-Since the characters (code units) may be 8-bit, 16-bit or 32-bit. `AutoUTFInputStream` requires a character type which can hold at least 32-bit. We may use `unsigned`, as in the template parameter:
-
-~~~~~~~~~~cpp
-#include "rapidjson/document.h"
-#include "rapidjson/filereadstream.h"   // FileReadStream
-#include "rapidjson/encodedstream.h"    // AutoUTFInputStream
-#include <cstdio>
-
-using namespace rapidjson;
-
-FILE* fp = fopen("any.json", "rb"); // non-Windows use "r"
-
-char readBuffer[256];
-FileReadStream bis(fp, readBuffer, sizeof(readBuffer));
-
-AutoUTFInputStream<unsigned, FileReadStream> eis(bis);  // wraps bis into eis
-
-Document d;         // Document is GenericDocument<UTF8<> > 
-d.ParseStream<0, AutoUTF<unsigned> >(eis); // This parses any UTF file into UTF-8 in memory
-
-fclose(fp);
-~~~~~~~~~~
-
-When specifying the encoding of stream, uses `AutoUTF<CharType>` as in `ParseStream()` above.
-
-You can obtain the type of UTF via `UTFType GetType()`. And check whether a BOM is found by `HasBOM()`
-
-## AutoUTFOutputStream {#AutoUTFOutputStream}
-
-Similarly, to choose encoding for output during runtime, we can use `AutoUTFOutputStream`. This class is not automatic *per se*. You need to specify the UTF type and whether to write BOM in runtime.
-
-~~~~~~~~~~cpp
-using namespace rapidjson;
-
-void WriteJSONFile(FILE* fp, UTFType type, bool putBOM, const Document& d) {
-    char writeBuffer[256];
-    FileWriteStream bos(fp, writeBuffer, sizeof(writeBuffer));
-
-    typedef AutoUTFOutputStream<unsigned, FileWriteStream> OutputStream;
-    OutputStream eos(bos, type, putBOM);
-    
-    Writer<OutputStream, UTF8<>, AutoUTF<> > writer;
-    d.Accept(writer);
-}
-~~~~~~~~~~
-
-`AutoUTFInputStream` and `AutoUTFOutputStream` is more convenient than `EncodedInputStream` and `EncodedOutputStream`. They just incur a little bit runtime overheads.
-
-# Custom Stream {#CustomStream}
-
-In addition to memory/file streams, user can create their own stream classes which fits RapidJSON's API. For example, you may create network stream, stream from compressed file, etc.
-
-RapidJSON combines different types using templates. A class containing all required interface can be a stream. The Stream interface is defined in comments of `rapidjson/rapidjson.h`:
-
-~~~~~~~~~~cpp
-concept Stream {
-    typename Ch;    //!< Character type of the stream.
-
-    //! Read the current character from stream without moving the read cursor.
-    Ch Peek() const;
-
-    //! Read the current character from stream and moving the read cursor to next character.
-    Ch Take();
-
-    //! Get the current read cursor.
-    //! \return Number of characters read from start.
-    size_t Tell();
-
-    //! Begin writing operation at the current read pointer.
-    //! \return The begin writer pointer.
-    Ch* PutBegin();
-
-    //! Write a character.
-    void Put(Ch c);
-
-    //! Flush the buffer.
-    void Flush();
-
-    //! End the writing operation.
-    //! \param begin The begin write pointer returned by PutBegin().
-    //! \return Number of characters written.
-    size_t PutEnd(Ch* begin);
-}
-~~~~~~~~~~
-
-For input stream, they must implement `Peek()`, `Take()` and `Tell()`.
-For output stream, they must implement `Put()` and `Flush()`. 
-There are two special interface, `PutBegin()` and `PutEnd()`, which are only for *in situ* parsing. Normal streams do not implement them. However, if the interface is not needed for a particular stream, it is still need to a dummy implementation, otherwise will generate compilation error.
-
-## Example: istream wrapper {#ExampleIStreamWrapper}
-
-The following example is a wrapper of `std::istream`, which only implements 3 functions.
-
-~~~~~~~~~~cpp
-class IStreamWrapper {
-public:
-    typedef char Ch;
-
-    IStreamWrapper(std::istream& is) : is_(is) {
-    }
-
-    Ch Peek() const { // 1
-        int c = is_.peek();
-        return c == std::char_traits<char>::eof() ? '\0' : (Ch)c;
-    }
-
-    Ch Take() { // 2
-        int c = is_.get();
-        return c == std::char_traits<char>::eof() ? '\0' : (Ch)c;
-    }
-
-    size_t Tell() const { return (size_t)is_.tellg(); } // 3
-
-    Ch* PutBegin() { assert(false); return 0; }
-    void Put(Ch) { assert(false); }
-    void Flush() { assert(false); }
-    size_t PutEnd(Ch*) { assert(false); return 0; }
-
-private:
-    IStreamWrapper(const IStreamWrapper&);
-    IStreamWrapper& operator=(const IStreamWrapper&);
-
-    std::istream& is_;
-};
-~~~~~~~~~~
-
-User can use it to wrap instances of `std::stringstream`, `std::ifstream`.
-
-~~~~~~~~~~cpp
-const char* json = "[1,2,3,4]";
-std::stringstream ss(json);
-IStreamWrapper is(ss);
-
-Document d;
-d.Parse(is);
-~~~~~~~~~~
-
-Note that, this implementation may not be as efficient as RapidJSON's memory or file streams, due to internal overheads of the standard library.
-
-## Example: ostream wrapper {#ExampleOStreamWrapper}
-
-The following example is a wrapper of `std::istream`, which only implements 2 functions.
-
-~~~~~~~~~~cpp
-class OStreamWrapper {
-public:
-    typedef char Ch;
-
-    OStreamWrapper(std::ostream& os) : os_(os) {
-    }
-
-    Ch Peek() const { assert(false); return '\0'; }
-    Ch Take() { assert(false); return '\0'; }
-    size_t Tell() const {  }
-
-    Ch* PutBegin() { assert(false); return 0; }
-    void Put(Ch c) { os_.put(c); }                  // 1
-    void Flush() { os_.flush(); }                   // 2
-    size_t PutEnd(Ch*) { assert(false); return 0; }
-
-private:
-    OStreamWrapper(const OStreamWrapper&);
-    OStreamWrapper& operator=(const OStreamWrapper&);
-
-    std::ostream& os_;
-};
-~~~~~~~~~~
-
-User can use it to wrap instances of `std::stringstream`, `std::ofstream`.
-
-~~~~~~~~~~cpp
-Document d;
-// ...
-
-std::stringstream ss;
-OSStreamWrapper os(ss);
-
-Writer<OStreamWrapper> writer(os);
-d.Accept(writer);
-~~~~~~~~~~
-
-Note that, this implementation may not be as efficient as RapidJSON's memory or file streams, due to internal overheads of the standard library.
-
-# Summary {#Summary}
-
-This section describes stream classes available in RapidJSON. Memory streams are simple. File stream can reduce the memory required during JSON parsing and generation, if the JSON is stored in file system. Encoded streams converts between byte streams and character streams. Finally, user may create custom streams using a simple interface.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/doc/tutorial.md b/third_party/socket.io-client-cpp/lib/rapidjson/doc/tutorial.md
deleted file mode 100644
index 811833d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/doc/tutorial.md
+++ /dev/null
@@ -1,515 +0,0 @@
-# Tutorial
-
-This tutorial introduces the basics of the Document Object Model(DOM) API.
-
-As shown in [Usage at a glance](@ref index), a JSON can be parsed into DOM, and then the DOM can be queried and modified easily, and finally be converted back to JSON.
-
-[TOC]
-
-# Value & Document {#ValueDocument}
-
-Each JSON value is stored in a type called `Value`. A `Document`, representing the DOM, contains the root `Value` of the DOM tree. All public types and functions of RapidJSON are defined in the `rapidjson` namespace.
-
-# Query Value {#QueryValue}
-
-In this section, we will use excerpt of `example/tutorial/tutorial.cpp`.
-
-Assumes we have a JSON stored in a C string (`const char* json`):
-~~~~~~~~~~js
-{
-    "hello": "world",
-    "t": true ,
-    "f": false,
-    "n": null,
-    "i": 123,
-    "pi": 3.1416,
-    "a": [1, 2, 3, 4]
-}
-~~~~~~~~~~
-
-Parse it into a `Document`:
-~~~~~~~~~~cpp
-#include "rapidjson/document.h"
-
-using namespace rapidjson;
-
-// ...
-Document document;
-document.Parse(json);
-~~~~~~~~~~
-
-The JSON is now parsed into `document` as a *DOM tree*:
-
-![DOM in the tutorial](diagram/tutorial.png)
-
-Since the update to RFC 7159, the root of a conforming JSON document can be any JSON value.  In earlier RFC 4627, only objects or arrays were allowed as root values. In this case, the root is an object.
-~~~~~~~~~~cpp
-assert(document.IsObject());
-~~~~~~~~~~
-
-Let's query whether a `"hello"` member exists in the root object. Since a `Value` can contain different types of value, we may need to verify its type and use suitable API to obtain the value. In this example, `"hello"` member associates with a JSON string.
-~~~~~~~~~~cpp
-assert(document.HasMember("hello"));
-assert(document["hello"].IsString());
-printf("hello = %s\n", document["hello"].GetString());
-~~~~~~~~~~
-
-~~~~~~~~~~
-world
-~~~~~~~~~~
-
-JSON true/false values are represented as `bool`.
-~~~~~~~~~~cpp
-assert(document["t"].IsBool());
-printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
-~~~~~~~~~~
-
-~~~~~~~~~~
-true
-~~~~~~~~~~
-
-JSON null can be queryed by `IsNull()`.
-~~~~~~~~~~cpp
-printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
-~~~~~~~~~~
-
-~~~~~~~~~~
-null
-~~~~~~~~~~
-
-JSON number type represents all numeric values. However, C++ needs more specific type for manipulation.
-
-~~~~~~~~~~cpp
-assert(document["i"].IsNumber());
-
-// In this case, IsUint()/IsInt64()/IsUInt64() also return true.
-assert(document["i"].IsInt());          
-printf("i = %d\n", document["i"].GetInt());
-// Alternative (int)document["i"]
-
-assert(document["pi"].IsNumber());
-assert(document["pi"].IsDouble());
-printf("pi = %g\n", document["pi"].GetDouble());
-~~~~~~~~~~
-
-~~~~~~~~~~
-i = 123
-pi = 3.1416
-~~~~~~~~~~
-
-JSON array contains a number of elements.
-~~~~~~~~~~cpp
-// Using a reference for consecutive access is handy and faster.
-const Value& a = document["a"];
-assert(a.IsArray());
-for (SizeType i = 0; i < a.Size(); i++) // Uses SizeType instead of size_t
-        printf("a[%d] = %d\n", i, a[i].GetInt());
-~~~~~~~~~~
-
-~~~~~~~~~~
-a[0] = 1
-a[1] = 2
-a[2] = 3
-a[3] = 4
-~~~~~~~~~~
-
-Note that, RapidJSON does not automatically convert values between JSON types. If a value is a string, it is invalid to call `GetInt()`, for example. In debug mode it will fail an assertion. In release mode, the behavior is undefined.
-
-In the following, details about querying individual types are discussed.
-
-## Query Array {#QueryArray}
-
-By default, `SizeType` is typedef of `unsigned`. In most systems, array is limited to store up to 2^32-1 elements.
-
-You may access the elements in array by integer literal, for example, `a[0]`, `a[1]`, `a[2]`.
-
-Array is similar to `std::vector`, instead of using indices, you may also use iterator to access all the elements.
-~~~~~~~~~~cpp
-for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
-    printf("%d ", itr->GetInt());
-~~~~~~~~~~
-
-And other familiar query functions:
-* `SizeType Capacity() const`
-* `bool Empty() const`
-
-## Query Object {#QueryObject}
-
-Similar to array, we can access all object members by iterator:
-
-~~~~~~~~~~cpp
-static const char* kTypeNames[] = 
-    { "Null", "False", "True", "Object", "Array", "String", "Number" };
-
-for (Value::ConstMemberIterator itr = document.MemberBegin();
-    itr != document.MemberEnd(); ++itr)
-{
-    printf("Type of member %s is %s\n",
-        itr->name.GetString(), kTypeNames[itr->value.GetType()]);
-}
-~~~~~~~~~~
-
-~~~~~~~~~~
-Type of member hello is String
-Type of member t is True
-Type of member f is False
-Type of member n is Null
-Type of member i is Number
-Type of member pi is Number
-Type of member a is Array
-~~~~~~~~~~
-
-Note that, when `operator[](const char*)` cannot find the member, it will fail an assertion.
-
-If we are unsure whether a member exists, we need to call `HasMember()` before calling `operator[](const char*)`. However, this incurs two lookup. A better way is to call `FindMember()`, which can check the existence of member and obtain its value at once:
-
-~~~~~~~~~~cpp
-Value::ConstMemberIterator itr = document.FindMember("hello");
-if (itr != document.MemberEnd())
-    printf("%s %s\n", itr->value.GetString());
-~~~~~~~~~~
-
-## Querying Number {#QueryNumber}
-
-JSON provide a single numerical type called Number. Number can be integer or real numbers. RFC 4627 says the range of Number is specified by parser.
-
-As C++ provides several integer and floating point number types, the DOM tries to handle these with widest possible range and good performance.
-
-When a Number is parsed, it is stored in the DOM as either one of the following type:
-
-Type       | Description
------------|---------------------------------------
-`unsigned` | 32-bit unsigned integer
-`int`      | 32-bit signed integer
-`uint64_t` | 64-bit unsigned integer
-`int64_t`  | 64-bit signed integer
-`double`   | 64-bit double precision floating point
-
-When querying a number, you can check whether the number can be obtained as target type:
-
-Checking          | Obtaining
-------------------|---------------------
-`bool IsNumber()` | N/A
-`bool IsUint()`   | `unsigned GetUint()`
-`bool IsInt()`    | `int GetInt()`
-`bool IsUint64()` | `uint64_t GetUint()`
-`bool IsInt64()`  | `int64_t GetInt64()`
-`bool IsDouble()` | `double GetDouble()`
-
-Note that, an integer value may be obtained in various ways without conversion. For example, A value `x` containing 123 will make `x.IsInt() == x.IsUint() == x.IsInt64() == x.IsUint64() == true`. But a value `y` containing -3000000000 will only makes `x.IsInt64() == true`.
-
-When obtaining the numeric values, `GetDouble()` will convert internal integer representation to a `double`. Note that, `int` and `unsigned` can be safely convert to `double`, but `int64_t` and `uint64_t` may lose precision (since mantissa of `double` is only 52-bits).
-
-## Query String {#QueryString}
-
-In addition to `GetString()`, the `Value` class also contains `GetStringLength()`. Here explains why.
-
-According to RFC 4627, JSON strings can contain Unicode character `U+0000`, which must be escaped as `"\u0000"`. The problem is that, C/C++ often uses null-terminated string, which treats ``\0'` as the terminator symbol.
-
-To conform RFC 4627, RapidJSON supports string containing `U+0000`. If you need to handle this, you can use `GetStringLength()` API to obtain the correct length of string.
-
-For example, after parsing a the following JSON to `Document d`:
-
-~~~~~~~~~~js
-{ "s" :  "a\u0000b" }
-~~~~~~~~~~
-The correct length of the value `"a\u0000b"` is 3. But `strlen()` returns 1.
-
-`GetStringLength()` can also improve performance, as user may often need to call `strlen()` for allocating buffer.
-
-Besides, `std::string` also support a constructor:
-
-~~~~~~~~~~cpp
-string(const char* s, size_t count);
-~~~~~~~~~~
-
-which accepts the length of string as parameter. This constructor supports storing null character within the string, and should also provide better performance.
-
-## Comparing values
-
-You can use `==` and `!=` to compare values. Two values are equal if and only if they are have same type and contents. You can also compare values with primitive types. Here is an example.
-
-~~~~~~~~~~cpp
-if (document["hello"] == document["n"]) /*...*/;    // Compare values
-if (document["hello"] == "world") /*...*/;          // Compare value with literal string
-if (document["i"] != 123) /*...*/;                  // Compare with integers
-if (document["pi"] != 3.14) /*...*/;                // Compare with double.
-~~~~~~~~~~
-
-Array/object compares their elements/members in order. They are equal if and only if their whole subtrees are equal.
-
-Note that, currently if an object contains duplicated named member, comparing equality with any object is always `false`.
-
-# Create/Modify Values {#CreateModifyValues}
-
-There are several ways to create values. After a DOM tree is created and/or modified, it can be saved as JSON again using `Writer`.
-
-## Change Value Type {#ChangeValueType}
-When creating a Value or Document by default constructor, its type is Null. To change its type, call `SetXXX()` or assignment operator, for example:
-
-~~~~~~~~~~cpp
-Document d; // Null
-d.SetObject();
-
-Value v;    // Null
-v.SetInt(10);
-v = 10;     // Shortcut, same as above
-~~~~~~~~~~
-
-### Overloaded Constructors
-There are also overloaded constructors for several types:
-
-~~~~~~~~~~cpp
-Value b(true);    // calls Value(bool)
-Value i(-123);    // calls Value(int)
-Value u(123u);    // calls Value(unsigned)
-Value d(1.5);     // calls Value(double)
-~~~~~~~~~~
-
-To create empty object or array, you may use `SetObject()`/`SetArray()` after default constructor, or using the `Value(Type)` in one shot:
-
-~~~~~~~~~~cpp
-Value o(kObjectType);
-Value a(kArrayType);
-~~~~~~~~~~
-
-## Move Semantics {#MoveSemantics}
-
-A very special decision during design of RapidJSON is that, assignment of value does not copy the source value to destination value. Instead, the value from source is moved to the destination. For example,
-
-~~~~~~~~~~cpp
-Value a(123);
-Value b(456);
-b = a;         // a becomes a Null value, b becomes number 123.
-~~~~~~~~~~
-
-![Assignment with move semantics.](diagram/move1.png)
-
-Why? What is the advantage of this semantics?
-
-The simple answer is performance. For fixed size JSON types (Number, True, False, Null), copying them is fast and easy. However, For variable size JSON types (String, Array, Object), copying them will incur a lot of overheads. And these overheads are often unnoticed. Especially when we need to create temporary object, copy it to another variable, and then destruct it.
-
-For example, if normal *copy* semantics was used:
-
-~~~~~~~~~~cpp
-Value o(kObjectType);
-{
-    Value contacts(kArrayType);
-    // adding elements to contacts array.
-    // ...
-    o.AddMember("contacts", contacts);  // deep clone contacts (may be with lots of allocations)
-    // destruct contacts.
-}
-~~~~~~~~~~
-
-![Copy semantics makes a lots of copy operations.](diagram/move2.png)
-
-The object `o` needs to allocate a buffer of same size as contacts, makes a deep clone of it, and then finally contacts is destructed. This will incur a lot of unnecessary allocations/deallocations and memory copying.
-
-There are solutions to prevent actual copying these data, such as reference counting and garbage collection(GC).
-
-To make RapidJSON simple and fast, we chose to use *move* semantics for assignment. It is similar to `std::auto_ptr` which transfer ownership during assignment. Move is much faster and simpler, it just destructs the original value, `memcpy()` the source to destination, and finally sets the source as Null type.
-
-So, with move semantics, the above example becomes:
-
-~~~~~~~~~~cpp
-Value o(kObjectType);
-{
-    Value contacts(kArrayType);
-    // adding elements to contacts array.
-    o.AddMember("contacts", contacts);  // just memcpy() of contacts itself to the value of new member (16 bytes)
-    // contacts became Null here. Its destruction is trivial.
-}
-~~~~~~~~~~
-
-![Move semantics makes no copying.](diagram/move3.png)
-
-This is called move assignment operator in C++11. As RapidJSON supports C++03, it adopts move semantics using assignment operator, and all other modifying function like `AddMember()`, `PushBack()`.
-
-### Move semantics and temporary values {#TemporaryValues}
-
-Sometimes, it is convenient to construct a Value in place, before passing it to one of the "moving" functions, like `PushBack()` or `AddMember()`.  As temporary objects can't be converted to proper Value references, the convenience function `Move()` is available:
-
-~~~~~~~~~~cpp
-Value a(kArrayType);
-Document::AllocatorType& allocator = document.GetAllocator();
-// a.PushBack(Value(42), allocator);       // will not compile
-a.PushBack(Value().SetInt(42), allocator); // fluent API
-a.PushBack(Value(42).Move(), allocator);   // same as above
-~~~~~~~~~~
-
-## Create String {#CreateString}
-RapidJSON provide two strategies for storing string.
-
-1. copy-string: allocates a buffer, and then copy the source data into it.
-2. const-string: simply store a pointer of string.
-
-Copy-string is always safe because it owns a copy of the data. Const-string can be used for storing string literal, and in-situ parsing which we will mentioned in Document section.
-
-To make memory allocation customizable, RapidJSON requires user to pass an instance of allocator, whenever an operation may require allocation. This design is needed to prevent storing a allocator (or Document) pointer per Value.
-
-Therefore, when we assign a copy-string, we call this overloaded `SetString()` with allocator:
-
-~~~~~~~~~~cpp
-Document document;
-Value author;
-char buffer[10];
-int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // dynamically created string.
-author.SetString(buffer, len, document.GetAllocator());
-memset(buffer, 0, sizeof(buffer));
-// author.GetString() still contains "Milo Yip" after buffer is destroyed
-~~~~~~~~~~
-
-In this example, we get the allocator from a `Document` instance. This is a common idiom when using RapidJSON. But you may use other instances of allocator.
-
-Besides, the above `SetString()` requires length. This can handle null characters within a string. There is another `SetString()` overloaded function without the length parameter. And it assumes the input is null-terminated and calls a `strlen()`-like function to obtain the length.
-
-Finally, for string literal or string with safe life-cycle can use const-string version of `SetString()`, which lacks allocator parameter.  For string literals (or constant character arrays), simply passing the literal as parameter is safe and efficient:
-
-~~~~~~~~~~cpp
-Value s;
-s.SetString("rapidjson");    // can contain null character, length derived at compile time
-s = "rapidjson";             // shortcut, same as above
-~~~~~~~~~~
-
-For character pointer, the RapidJSON requires to mark it as safe before using it without copying. This can be achieved by using the `StringRef` function:
-
-~~~~~~~~~cpp
-const char * cstr = getenv("USER");
-size_t cstr_len = ...;                 // in case length is available
-Value s;
-// s.SetString(cstr);                  // will not compile
-s.SetString(StringRef(cstr));          // ok, assume safe lifetime, null-terminated
-s = StringRef(cstr);                   // shortcut, same as above
-s.SetString(StringRef(cstr,cstr_len)); // faster, can contain null character
-s = StringRef(cstr,cstr_len);          // shortcut, same as above
-
-~~~~~~~~~
-
-## Modify Array {#ModifyArray}
-Value with array type provides similar APIs as `std::vector`.
-
-* `Clear()`
-* `Reserve(SizeType, Allocator&)`
-* `Value& PushBack(Value&, Allocator&)`
-* `template <typename T> GenericValue& PushBack(T, Allocator&)`
-* `Value& PopBack()`
-* `ValueIterator Erase(ConstValueIterator pos)`
-* `ValueIterator Erase(ConstValueIterator first, ConstValueIterator last)`
-
-Note that, `Reserve(...)` and `PushBack(...)` may allocate memory for the array elements, therefore require an allocator.
-
-Here is an example of `PushBack()`:
-
-~~~~~~~~~~cpp
-Value a(kArrayType);
-Document::AllocatorType& allocator = document.GetAllocator();
-
-for (int i = 5; i <= 10; i++)
-    a.PushBack(i, allocator);   // allocator is needed for potential realloc().
-
-// Fluent interface
-a.PushBack("Lua", allocator).PushBack("Mio", allocator);
-~~~~~~~~~~
-
-Differs from STL, `PushBack()`/`PopBack()` returns the array reference itself. This is called _fluent interface_.
-
-If you want to add a non-constant string or a string without sufficient lifetime (see [Create String](#CreateString)) to the array, you need to create a string Value by using the copy-string API.  To avoid the need for an intermediate variable, you can use a [temporary value](#TemporaryValues) in place:
-
-~~~~~~~~~~cpp
-// in-place Value parameter
-contact.PushBack(Value("copy", document.GetAllocator()).Move(), // copy string
-                 document.GetAllocator());
-
-// explicit parameters
-Value val("key", document.GetAllocator()); // copy string
-contact.PushBack(val, document.GetAllocator());
-~~~~~~~~~~
-
-## Modify Object {#ModifyObject}
-Object is a collection of key-value pairs (members). Each key must be a string value. To modify an object, either add or remove members. THe following APIs are for adding members:
-
-* `Value& AddMember(Value&, Value&, Allocator& allocator)`
-* `Value& AddMember(StringRefType, Value&, Allocator&)`
-* `template <typename T> Value& AddMember(StringRefType, T value, Allocator&)`
-
-Here is an example.
-
-~~~~~~~~~~cpp
-Value contact(kObject);
-contact.AddMember("name", "Milo", document.GetAllocator());
-contact.AddMember("married", true, document.GetAllocator());
-~~~~~~~~~~
-
-The name parameter with `StringRefType` is similar to the interface of `SetString` function for string values. These overloads are used to avoid the need for copying the `name` string, as constant key names are very common in JSON objects.
-
-If you need to create a name from a non-constant string or a string without sufficient lifetime (see [Create String](#CreateString)), you need to create a string Value by using the copy-string API.  To avoid the need for an intermediate variable, you can use a [temporary value](#TemporaryValues) in place:
-
-~~~~~~~~~~cpp
-// in-place Value parameter
-contact.AddMember(Value("copy", document.GetAllocator()).Move(), // copy string
-                  Value().Move(),                                // null value
-                  document.GetAllocator());
-
-// explicit parameters
-Value key("key", document.GetAllocator()); // copy string name
-Value val(42);                             // some value
-contact.AddMember(key, val, document.GetAllocator());
-~~~~~~~~~~
-
-For removing members, there are several choices: 
-
-* `bool RemoveMember(const Ch* name)`: Remove a member by search its name (linear time complexity).
-* `bool RemoveMember(const Value& name)`: same as above but `name` is a Value.
-* `MemberIterator RemoveMember(MemberIterator)`: Remove a member by iterator (_constant_ time complexity).
-* `MemberIterator EraseMember(MemberIterator)`: similar to the above but it preserves order of members (linear time complexity).
-* `MemberIterator EraseMember(MemberIterator first, MemberIterator last)`: remove a range of members, preserves order (linear time complexity).
-
-`MemberIterator RemoveMember(MemberIterator)` uses a "move-last" trick to achieve constant time complexity. Basically the member at iterator is destructed, and then the last element is moved to that position. So the order of the remaining members are changed.
-
-## Deep Copy Value {#DeepCopyValue}
-If we really need to copy a DOM tree, we can use two APIs for deep copy: constructor with allocator, and `CopyFrom()`.
-
-~~~~~~~~~~cpp
-Document d;
-Document::AllocatorType& a = d.GetAllocator();
-Value v1("foo");
-// Value v2(v1); // not allowed
-
-Value v2(v1, a);                      // make a copy
-assert(v1.IsString());                // v1 untouched
-d.SetArray().PushBack(v1, a).PushBack(v2, a);
-assert(v1.IsNull() && v2.IsNull());   // both moved to d
-
-v2.CopyFrom(d, a);                    // copy whole document to v2
-assert(d.IsArray() && d.Size() == 2); // d untouched
-v1.SetObject().AddMember("array", v2, a);
-d.PushBack(v1, a);
-~~~~~~~~~~
-
-## Swap Values {#SwapValues}
-
-`Swap()` is also provided.
-
-~~~~~~~~~~cpp
-Value a(123);
-Value b("Hello");
-a.Swap(b);
-assert(a.IsString());
-assert(b.IsInt());
-~~~~~~~~~~
-
-Swapping two DOM trees is fast (constant time), despite the complexity of the trees.
-
-# What's next {#WhatsNext}
-
-This tutorial shows the basics of DOM tree query and manipulation. There are several important concepts in RapidJSON:
-
-1. [Streams](doc/stream.md) are channels for reading/writing JSON, which can be a in-memory string, or file stream, etc. User can also create their streams.
-2. [Encoding](doc/encoding.md) defines which character encoding is used in streams and memory. RapidJSON also provide Unicode conversion/validation internally.
-3. [DOM](doc/dom.md)'s basics are already covered in this tutorial. Uncover more advanced features such as *in situ* parsing, other parsing options and advanced usages.
-4. [SAX](doc/sax.md) is the foundation of parsing/generating facility in RapidJSON. Learn how to use `Reader`/`Writer` to implement even faster applications. Also try `PrettyWriter` to format the JSON.
-5. [Performance](doc/performance.md) shows some in-house and third-party benchmarks.
-6. [Internals](doc/internals.md) describes some internal designs and techniques of RapidJSON.
-
-You may also refer to the [FAQ](doc/faq.md), API documentation, examples and unit tests.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/example/CMakeLists.txt
deleted file mode 100644
index 6463212..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (c) 2011 Milo Yip (miloyip@gmail.com)
-# Copyright (c) 2013 Rafal Jeczalik (rjeczalik@gmail.com)
-# Distributed under the MIT License (see license.txt file)
-
-set(EXAMPLES
-    capitalize
-    condense
-    messagereader
-    pretty
-    prettyauto
-    serialize
-    simpledom
-    simplereader
-    simplewriter
-    tutorial)
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Weffc++ -Wswitch-default")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra -Weffc++ -Wswitch-default")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
-endif()
-
-foreach (example ${EXAMPLES})
-    add_executable(${example} ${example}/${example}.cpp)
-endforeach()
-
-add_custom_target(examples ALL DEPENDS ${EXAMPLES})
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/capitalize/capitalize.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/capitalize/capitalize.cpp
deleted file mode 100644
index dd94d24..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/capitalize/capitalize.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// JSON condenser exmaple
-
-// This example parses JSON from stdin with validation, 
-// and re-output the JSON content to stdout with all string capitalized, and without whitespace.
-
-#include "rapidjson/reader.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/error/en.h"
-#include <vector>
-#include <cctype>
-
-using namespace rapidjson;
-
-template<typename OutputHandler>
-struct CapitalizeFilter {
-    CapitalizeFilter(OutputHandler& out) : out_(out), buffer_() {}
-
-    bool Null() { return out_.Null(); }
-    bool Bool(bool b) { return out_.Bool(b); }
-    bool Int(int i) { return out_.Int(i); }
-    bool Uint(unsigned u) { return out_.Uint(u); }
-    bool Int64(int64_t i) { return out_.Int64(i); }
-    bool Uint64(uint64_t u) { return out_.Uint64(u); }
-    bool Double(double d) { return out_.Double(d); }
-    bool String(const char* str, SizeType length, bool) { 
-        buffer_.clear();
-        for (SizeType i = 0; i < length; i++)
-            buffer_.push_back(std::toupper(str[i]));
-        return out_.String(&buffer_.front(), length, true); // true = output handler need to copy the string
-    }
-    bool StartObject() { return out_.StartObject(); }
-    bool Key(const char* str, SizeType length, bool copy) { return String(str, length, copy); }
-    bool EndObject(SizeType memberCount) { return out_.EndObject(memberCount); }
-    bool StartArray() { return out_.StartArray(); }
-    bool EndArray(SizeType elementCount) { return out_.EndArray(elementCount); }
-
-    OutputHandler& out_;
-    std::vector<char> buffer_;
-
-private:
-    CapitalizeFilter(const CapitalizeFilter&);
-    CapitalizeFilter& operator=(const CapitalizeFilter&);
-};
-
-int main(int, char*[]) {
-    // Prepare JSON reader and input stream.
-    Reader reader;
-    char readBuffer[65536];
-    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
-
-    // Prepare JSON writer and output stream.
-    char writeBuffer[65536];
-    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
-    Writer<FileWriteStream> writer(os);
-
-    // JSON reader parse from the input stream and let writer generate the output.
-    CapitalizeFilter<Writer<FileWriteStream> > filter(writer);
-    if (!reader.Parse(is, filter)) {
-        fprintf(stderr, "\nError(%u): %s\n", (unsigned)reader.GetErrorOffset(), GetParseError_En(reader.GetParseErrorCode()));
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/condense/condense.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/condense/condense.cpp
deleted file mode 100644
index 05e2007..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/condense/condense.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// JSON condenser exmaple
-
-// This example parses JSON text from stdin with validation, 
-// and re-output the JSON content to stdout without whitespace.
-
-#include "rapidjson/reader.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/error/en.h"
-
-using namespace rapidjson;
-
-int main(int, char*[]) {
-    // Prepare JSON reader and input stream.
-    Reader reader;
-    char readBuffer[65536];
-    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
-
-    // Prepare JSON writer and output stream.
-    char writeBuffer[65536];
-    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
-    Writer<FileWriteStream> writer(os);
-
-    // JSON reader parse from the input stream and let writer generate the output.
-    if (!reader.Parse(is, writer)) {
-        fprintf(stderr, "\nError(%u): %s\n", (unsigned)reader.GetErrorOffset(), GetParseError_En(reader.GetParseErrorCode()));
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/messagereader/messagereader.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/messagereader/messagereader.cpp
deleted file mode 100644
index 436af85..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/messagereader/messagereader.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// Reading a message JSON with Reader (SAX-style API).
-// The JSON should be an object with key-string pairs.
-
-#include "rapidjson/reader.h"
-#include "rapidjson/error/en.h"
-#include <iostream>
-#include <string>
-#include <map>
-
-using namespace std;
-using namespace rapidjson;
-
-typedef map<string, string> MessageMap;
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-struct MessageHandler
-    : public BaseReaderHandler<UTF8<>, MessageHandler> {
-    MessageHandler() : messages_(), state_(kExpectObjectStart), name_() {}
-
-    bool StartObject() {
-        switch (state_) {
-        case kExpectObjectStart:
-            state_ = kExpectNameOrObjectEnd;
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    bool String(const char* str, SizeType length, bool) {
-        switch (state_) {
-        case kExpectNameOrObjectEnd:
-            name_ = string(str, length);
-            state_ = kExpectValue;
-            return true;
-        case kExpectValue:
-            messages_.insert(MessageMap::value_type(name_, string(str, length)));
-            state_ = kExpectNameOrObjectEnd;
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    bool EndObject(SizeType) { return state_ == kExpectNameOrObjectEnd; }
-
-    bool Default() { return false; } // All other events are invalid.
-
-    MessageMap messages_;
-    enum State {
-        kExpectObjectStart,
-        kExpectNameOrObjectEnd,
-        kExpectValue,
-    }state_;
-    std::string name_;
-};
-
-#if defined(__GNUC__)
-RAPIDJSON_DIAG_POP
-#endif
-
-void ParseMessages(const char* json, MessageMap& messages) {
-    Reader reader;
-    MessageHandler handler;
-    StringStream ss(json);
-    if (reader.Parse(ss, handler))
-        messages.swap(handler.messages_);   // Only change it if success.
-    else {
-        ParseErrorCode e = reader.GetParseErrorCode();
-        size_t o = reader.GetErrorOffset();
-        cout << "Error: " << GetParseError_En(e) << endl;;
-        cout << " at offset " << o << " near '" << string(json).substr(o, 10) << "...'" << endl;
-    }
-}
-
-int main() {
-    MessageMap messages;
-
-    const char* json1 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\" }";
-    cout << json1 << endl;
-    ParseMessages(json1, messages);
-
-    for (MessageMap::const_iterator itr = messages.begin(); itr != messages.end(); ++itr)
-        cout << itr->first << ": " << itr->second << endl;
-
-    cout << endl << "Parse a JSON with invalid schema." << endl;
-    const char* json2 = "{ \"greeting\" : \"Hello!\", \"farewell\" : \"bye-bye!\", \"foo\" : {} }";
-    cout << json2 << endl;
-    ParseMessages(json2, messages);
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/pretty/pretty.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/pretty/pretty.cpp
deleted file mode 100644
index 164e388..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/pretty/pretty.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// JSON pretty formatting example
-// This example can only handle UTF-8. For handling other encodings, see prettyauto example.
-
-#include "rapidjson/reader.h"
-#include "rapidjson/prettywriter.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/error/en.h"
-
-using namespace rapidjson;
-
-int main(int, char*[]) {
-    // Prepare reader and input stream.
-    Reader reader;
-    char readBuffer[65536];
-    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
-
-    // Prepare writer and output stream.
-    char writeBuffer[65536];
-    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
-    PrettyWriter<FileWriteStream> writer(os);
-
-    // JSON reader parse from the input stream and let writer generate the output.
-    if (!reader.Parse<kParseValidateEncodingFlag>(is, writer)) {
-        fprintf(stderr, "\nError(%u): %s\n", (unsigned)reader.GetErrorOffset(), GetParseError_En(reader.GetParseErrorCode()));
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/prettyauto/prettyauto.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/prettyauto/prettyauto.cpp
deleted file mode 100644
index 0d30968..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/prettyauto/prettyauto.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// JSON pretty formatting example
-// This example can handle UTF-8/UTF-16LE/UTF-16BE/UTF-32LE/UTF-32BE.
-// The input firstly convert to UTF8, and then write to the original encoding with pretty formatting.
-
-#include "rapidjson/reader.h"
-#include "rapidjson/prettywriter.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"    // NEW
-#include "rapidjson/error/en.h"
-#ifdef _WIN32
-#include <fcntl.h>
-#include <io.h>
-#endif
-
-using namespace rapidjson;
-
-int main(int, char*[]) {
-#ifdef _WIN32
-    // Prevent Windows converting between CR+LF and LF
-    _setmode(_fileno(stdin), _O_BINARY);    // NEW
-    _setmode(_fileno(stdout), _O_BINARY);   // NEW
-#endif
-
-    // Prepare reader and input stream.
-    //Reader reader;
-    GenericReader<AutoUTF<unsigned>, UTF8<> > reader;       // CHANGED
-    char readBuffer[65536];
-    FileReadStream is(stdin, readBuffer, sizeof(readBuffer));
-    AutoUTFInputStream<unsigned, FileReadStream> eis(is);   // NEW
-
-    // Prepare writer and output stream.
-    char writeBuffer[65536];
-    FileWriteStream os(stdout, writeBuffer, sizeof(writeBuffer));
-
-#if 1
-    // Use the same Encoding of the input. Also use BOM according to input.
-    typedef AutoUTFOutputStream<unsigned, FileWriteStream> OutputStream;    // NEW
-    OutputStream eos(os, eis.GetType(), eis.HasBOM());                      // NEW
-    PrettyWriter<OutputStream, UTF8<>, AutoUTF<unsigned> > writer(eos);     // CHANGED
-#else
-    // You may also use static bound encoding type, such as output to UTF-16LE with BOM
-    typedef EncodedOutputStream<UTF16LE<>,FileWriteStream> OutputStream;    // NEW
-    OutputStream eos(os, true);                                             // NEW
-    PrettyWriter<OutputStream, UTF8<>, UTF16LE<> > writer(eos);             // CHANGED
-#endif
-
-    // JSON reader parse from the input stream and let writer generate the output.
-    //if (!reader.Parse<kParseValidateEncodingFlag>(is, writer)) {
-    if (!reader.Parse<kParseValidateEncodingFlag>(eis, writer)) {   // CHANGED
-        fprintf(stderr, "\nError(%u): %s\n", (unsigned)reader.GetErrorOffset(), GetParseError_En(reader.GetParseErrorCode()));
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/serialize/serialize.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/serialize/serialize.cpp
deleted file mode 100644
index 4f9278b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/serialize/serialize.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-// Serialize example
-// This example shows writing JSON string with writer directly.
-
-#include "rapidjson/prettywriter.h" // for stringify JSON
-#include "rapidjson/filestream.h"   // wrapper of C stream for prettywriter as output
-#include <cstdio>
-#include <string>
-#include <vector>
-
-using namespace rapidjson;
-
-class Person {
-public:
-    Person(const std::string& name, unsigned age) : name_(name), age_(age) {}
-    virtual ~Person();
-
-protected:
-    template <typename Writer>
-    void Serialize(Writer& writer) const {
-        // This base class just write out name-value pairs, without wrapping within an object.
-        writer.String("name");
-#ifdef RAPIDJSON_HAS_STDSTRING
-        writer.String(name_);
-#else
-        writer.String(name_.c_str(), (SizeType)name_.length()); // Supplying length of string is faster.
-#endif
-        writer.String("age");
-        writer.Uint(age_);
-    }
-
-private:
-    std::string name_;
-    unsigned age_;
-};
-
-Person::~Person() {
-}
-
-class Education {
-public:
-    Education(const std::string& school, double GPA) : school_(school), GPA_(GPA) {}
-
-    template <typename Writer>
-    void Serialize(Writer& writer) const {
-        writer.StartObject();
-        
-        writer.String("school");
-#ifdef RAPIDJSON_HAS_STDSTRING
-        writer.String(school_);
-#else
-        writer.String(school_.c_str(), (SizeType)school_.length());
-#endif
-
-        writer.String("GPA");
-        writer.Double(GPA_);
-
-        writer.EndObject();
-    }
-
-private:
-    std::string school_;
-    double GPA_;
-};
-
-class Dependent : public Person {
-public:
-    Dependent(const std::string& name, unsigned age, Education* education = 0) : Person(name, age), education_(education) {}
-    Dependent(const Dependent& rhs) : Person(rhs), education_(0) { education_ = (rhs.education_ == 0) ? 0 : new Education(*rhs.education_); }
-    virtual ~Dependent();
-
-    Dependent& operator=(const Dependent& rhs) {
-        if (this == &rhs)
-            return *this;
-        delete education_;
-        education_ = (rhs.education_ == 0) ? 0 : new Education(*rhs.education_);
-        return *this;
-    }
-
-    template <typename Writer>
-    void Serialize(Writer& writer) const {
-        writer.StartObject();
-
-        Person::Serialize(writer);
-
-        writer.String("education");
-        if (education_)
-            education_->Serialize(writer);
-        else
-            writer.Null();
-
-        writer.EndObject();
-    }
-
-private:
-
-    Education *education_;
-};
-
-Dependent::~Dependent() {
-    delete education_; 
-}
-
-class Employee : public Person {
-public:
-    Employee(const std::string& name, unsigned age, bool married) : Person(name, age), dependents_(), married_(married) {}
-    virtual ~Employee();
-
-    void AddDependent(const Dependent& dependent) {
-        dependents_.push_back(dependent);
-    }
-
-    template <typename Writer>
-    void Serialize(Writer& writer) const {
-        writer.StartObject();
-
-        Person::Serialize(writer);
-
-        writer.String("married");
-        writer.Bool(married_);
-
-        writer.String(("dependents"));
-        writer.StartArray();
-        for (std::vector<Dependent>::const_iterator dependentItr = dependents_.begin(); dependentItr != dependents_.end(); ++dependentItr)
-            dependentItr->Serialize(writer);
-        writer.EndArray();
-
-        writer.EndObject();
-    }
-
-private:
-    std::vector<Dependent> dependents_;
-    bool married_;
-};
-
-Employee::~Employee() {
-}
-
-int main(int, char*[]) {
-    std::vector<Employee> employees;
-
-    employees.push_back(Employee("Milo YIP", 34, true));
-    employees.back().AddDependent(Dependent("Lua YIP", 3, new Education("Happy Kindergarten", 3.5)));
-    employees.back().AddDependent(Dependent("Mio YIP", 1));
-
-    employees.push_back(Employee("Percy TSE", 30, false));
-
-    FileStream s(stdout);
-    PrettyWriter<FileStream> writer(s);     // Can also use Writer for condensed formatting
-
-    writer.StartArray();
-    for (std::vector<Employee>::const_iterator employeeItr = employees.begin(); employeeItr != employees.end(); ++employeeItr)
-        employeeItr->Serialize(writer);
-    writer.EndArray();
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/simpledom/simpledom.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/simpledom/simpledom.cpp
deleted file mode 100644
index 8038419..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/simpledom/simpledom.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// JSON simple example
-// This example does not handle errors.
-
-#include "rapidjson/document.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-
-int main() {
-    // 1. Parse a JSON string into DOM.
-    const char* json = "{\"project\":\"rapidjson\",\"stars\":10}";
-    Document d;
-    d.Parse(json);
-
-    // 2. Modify it by DOM.
-    Value& s = d["stars"];
-    s.SetInt(s.GetInt() + 1);
-
-    // 3. Stringify the DOM
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    d.Accept(writer);
-
-    // Output {"project":"rapidjson","stars":11}
-    std::cout << buffer.GetString() << std::endl;
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/simplereader/simplereader.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/simplereader/simplereader.cpp
deleted file mode 100644
index edbdb63..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/simplereader/simplereader.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "rapidjson/reader.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-struct MyHandler {
-    bool Null() { cout << "Null()" << endl; return true; }
-    bool Bool(bool b) { cout << "Bool(" << boolalpha << b << ")" << endl; return true; }
-    bool Int(int i) { cout << "Int(" << i << ")" << endl; return true; }
-    bool Uint(unsigned u) { cout << "Uint(" << u << ")" << endl; return true; }
-    bool Int64(int64_t i) { cout << "Int64(" << i << ")" << endl; return true; }
-    bool Uint64(uint64_t u) { cout << "Uint64(" << u << ")" << endl; return true; }
-    bool Double(double d) { cout << "Double(" << d << ")" << endl; return true; }
-    bool String(const char* str, SizeType length, bool copy) { 
-        cout << "String(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool StartObject() { cout << "StartObject()" << endl; return true; }
-    bool Key(const char* str, SizeType length, bool copy) {
-        cout << "Key(" << str << ", " << length << ", " << boolalpha << copy << ")" << endl;
-        return true;
-    }
-    bool EndObject(SizeType memberCount) { cout << "EndObject(" << memberCount << ")" << endl; return true; }
-    bool StartArray() { cout << "StartArray()" << endl; return true; }
-    bool EndArray(SizeType elementCount) { cout << "EndArray(" << elementCount << ")" << endl; return true; }
-};
-
-int main() {
-    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
-
-    MyHandler handler;
-    Reader reader;
-    StringStream ss(json);
-    reader.Parse(ss, handler);
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/simplewriter/simplewriter.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/simplewriter/simplewriter.cpp
deleted file mode 100644
index f889150..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/simplewriter/simplewriter.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-using namespace std;
-
-int main() {
-    StringBuffer s;
-    Writer<StringBuffer> writer(s);
-    
-    writer.StartObject();
-    writer.String("hello");
-    writer.String("world");
-    writer.String("t");
-    writer.Bool(true);
-    writer.String("f");
-    writer.Bool(false);
-    writer.String("n");
-    writer.Null();
-    writer.String("i");
-    writer.Uint(123);
-    writer.String("pi");
-    writer.Double(3.1416);
-    writer.String("a");
-    writer.StartArray();
-    for (unsigned i = 0; i < 4; i++)
-        writer.Uint(i);
-    writer.EndArray();
-    writer.EndObject();
-
-    cout << s.GetString() << endl;
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/example/tutorial/tutorial.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/example/tutorial/tutorial.cpp
deleted file mode 100644
index 57f94a5..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/example/tutorial/tutorial.cpp
+++ /dev/null
@@ -1,153 +0,0 @@
-// Hello World example
-// This example shows basic usage of DOM-style API.
-
-#include "rapidjson/document.h"     // rapidjson's DOM-style API
-#include "rapidjson/prettywriter.h" // for stringify JSON
-#include "rapidjson/filestream.h"   // wrapper of C stream for prettywriter as output
-#include <cstdio>
-
-using namespace rapidjson;
-using namespace std;
-
-int main(int, char*[]) {
-    ////////////////////////////////////////////////////////////////////////////
-    // 1. Parse a JSON text string to a document.
-
-    const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
-    printf("Original JSON:\n %s\n", json);
-
-    Document document;  // Default template parameter uses UTF8 and MemoryPoolAllocator.
-
-#if 0
-    // "normal" parsing, decode strings to new buffers. Can use other input stream via ParseStream().
-    if (document.Parse(json).HasParseError())
-        return 1;
-#else
-    // In-situ parsing, decode strings directly in the source string. Source must be string.
-    {
-        char buffer[sizeof(json)];
-        memcpy(buffer, json, sizeof(json));
-        if (document.ParseInsitu(buffer).HasParseError())
-            return 1;
-    }
-#endif
-
-    printf("\nParsing to document succeeded.\n");
-
-    ////////////////////////////////////////////////////////////////////////////
-    // 2. Access values in document. 
-
-    printf("\nAccess values in document:\n");
-    assert(document.IsObject());    // Document is a JSON value represents the root of DOM. Root can be either an object or array.
-
-    assert(document.HasMember("hello"));
-    assert(document["hello"].IsString());
-    printf("hello = %s\n", document["hello"].GetString());
-
-    // Since version 0.2, you can use single lookup to check the existing of member and its value:
-    Value::MemberIterator hello = document.FindMember("hello");
-    assert(hello != document.MemberEnd());
-    assert(hello->value.IsString());
-    assert(strcmp("world", hello->value.GetString()) == 0);
-    (void)hello;
-
-    assert(document["t"].IsBool());     // JSON true/false are bool. Can also uses more specific function IsTrue().
-    printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
-
-    assert(document["f"].IsBool());
-    printf("f = %s\n", document["f"].GetBool() ? "true" : "false");
-
-    printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
-
-    assert(document["i"].IsNumber());   // Number is a JSON type, but C++ needs more specific type.
-    assert(document["i"].IsInt());      // In this case, IsUint()/IsInt64()/IsUInt64() also return true.
-    printf("i = %d\n", document["i"].GetInt()); // Alternative (int)document["i"]
-
-    assert(document["pi"].IsNumber());
-    assert(document["pi"].IsDouble());
-    printf("pi = %g\n", document["pi"].GetDouble());
-
-    {
-        const Value& a = document["a"]; // Using a reference for consecutive access is handy and faster.
-        assert(a.IsArray());
-        for (SizeType i = 0; i < a.Size(); i++) // rapidjson uses SizeType instead of size_t.
-            printf("a[%d] = %d\n", i, a[i].GetInt());
-        
-        int y = a[0].GetInt();
-        (void)y;
-
-        // Iterating array with iterators
-        printf("a = ");
-        for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
-            printf("%d ", itr->GetInt());
-        printf("\n");
-    }
-
-    // Iterating object members
-    static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
-    for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
-        printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);
-
-    ////////////////////////////////////////////////////////////////////////////
-    // 3. Modify values in document.
-
-    // Change i to a bigger number
-    {
-        uint64_t f20 = 1;   // compute factorial of 20
-        for (uint64_t j = 1; j <= 20; j++)
-            f20 *= j;
-        document["i"] = f20;    // Alternate form: document["i"].SetUint64(f20)
-        assert(!document["i"].IsInt()); // No longer can be cast as int or uint.
-    }
-
-    // Adding values to array.
-    {
-        Value& a = document["a"];   // This time we uses non-const reference.
-        Document::AllocatorType& allocator = document.GetAllocator();
-        for (int i = 5; i <= 10; i++)
-            a.PushBack(i, allocator);   // May look a bit strange, allocator is needed for potentially realloc. We normally uses the document's.
-
-        // Fluent API
-        a.PushBack("Lua", allocator).PushBack("Mio", allocator);
-    }
-
-    // Making string values.
-
-    // This version of SetString() just store the pointer to the string.
-    // So it is for literal and string that exists within value's life-cycle.
-    {
-        document["hello"] = "rapidjson";    // This will invoke strlen()
-        // Faster version:
-        // document["hello"].SetString("rapidjson", 9);
-    }
-
-    // This version of SetString() needs an allocator, which means it will allocate a new buffer and copy the the string into the buffer.
-    Value author;
-    {
-        char buffer[10];
-        int len = sprintf(buffer, "%s %s", "Milo", "Yip");  // synthetic example of dynamically created string.
-
-        author.SetString(buffer, static_cast<size_t>(len), document.GetAllocator());
-        // Shorter but slower version:
-        // document["hello"].SetString(buffer, document.GetAllocator());
-
-        // Constructor version: 
-        // Value author(buffer, len, document.GetAllocator());
-        // Value author(buffer, document.GetAllocator());
-        memset(buffer, 0, sizeof(buffer)); // For demonstration purpose.
-    }
-    // Variable 'buffer' is unusable now but 'author' has already made a copy.
-    document.AddMember("author", author, document.GetAllocator());
-
-    assert(author.IsNull());        // Move semantic for assignment. After this variable is assigned as a member, the variable becomes null.
-
-    ////////////////////////////////////////////////////////////////////////////
-    // 4. Stringify JSON
-
-    printf("\nModified JSON with reformatting:\n");
-    FileStream f(stdout);
-    PrettyWriter<FileStream> writer(f);
-    document.Accept(writer);    // Accept() traverses the DOM and generates Handler events.
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/allocators.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/allocators.h
deleted file mode 100644
index c0a26ee..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/allocators.h
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ALLOCATORS_H_
-#define RAPIDJSON_ALLOCATORS_H_
-
-#include "rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Allocator
-
-/*! \class rapidjson::Allocator
-    \brief Concept for allocating, resizing and freeing memory block.
-    
-    Note that Malloc() and Realloc() are non-static but Free() is static.
-    
-    So if an allocator need to support Free(), it needs to put its pointer in 
-    the header of memory block.
-
-\code
-concept Allocator {
-    static const bool kNeedFree;    //!< Whether this allocator needs to call Free().
-
-    // Allocate a memory block.
-    // \param size of the memory block in bytes.
-    // \returns pointer to the memory block.
-    void* Malloc(size_t size);
-
-    // Resize a memory block.
-    // \param originalPtr The pointer to current memory block. Null pointer is permitted.
-    // \param originalSize The current size in bytes. (Design issue: since some allocator may not book-keep this, explicitly pass to it can save memory.)
-    // \param newSize the new size in bytes.
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize);
-
-    // Free a memory block.
-    // \param pointer to the memory block. Null pointer is permitted.
-    static void Free(void *ptr);
-};
-\endcode
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// CrtAllocator
-
-//! C-runtime library allocator.
-/*! This class is just wrapper for standard C library memory routines.
-    \note implements Allocator concept
-*/
-class CrtAllocator {
-public:
-    static const bool kNeedFree = true;
-    void* Malloc(size_t size) { return std::malloc(size); }
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) { (void)originalSize; return std::realloc(originalPtr, newSize); }
-    static void Free(void *ptr) { std::free(ptr); }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// MemoryPoolAllocator
-
-//! Default memory allocator used by the parser and DOM.
-/*! This allocator allocate memory blocks from pre-allocated memory chunks. 
-
-    It does not free memory blocks. And Realloc() only allocate new memory.
-
-    The memory chunks are allocated by BaseAllocator, which is CrtAllocator by default.
-
-    User may also supply a buffer as the first chunk.
-
-    If the user-buffer is full then additional chunks are allocated by BaseAllocator.
-
-    The user-buffer is not deallocated by this allocator.
-
-    \tparam BaseAllocator the allocator type for allocating memory chunks. Default is CrtAllocator.
-    \note implements Allocator concept
-*/
-template <typename BaseAllocator = CrtAllocator>
-class MemoryPoolAllocator {
-public:
-    static const bool kNeedFree = false;    //!< Tell users that no need to call Free() with this allocator. (concept Allocator)
-
-    //! Constructor with chunkSize.
-    /*! \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    MemoryPoolAllocator(size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) : 
-        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(0), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
-    {
-    }
-
-    //! Constructor with user-supplied buffer.
-    /*! The user buffer will be used firstly. When it is full, memory pool allocates new chunk with chunk size.
-
-        The user buffer will not be deallocated when this allocator is destructed.
-
-        \param buffer User supplied buffer.
-        \param size Size of the buffer in bytes. It must at least larger than sizeof(ChunkHeader).
-        \param chunkSize The size of memory chunk. The default is kDefaultChunkSize.
-        \param baseAllocator The allocator for allocating memory chunks.
-    */
-    MemoryPoolAllocator(void *buffer, size_t size, size_t chunkSize = kDefaultChunkCapacity, BaseAllocator* baseAllocator = 0) :
-        chunkHead_(0), chunk_capacity_(chunkSize), userBuffer_(buffer), baseAllocator_(baseAllocator), ownBaseAllocator_(0)
-    {
-        RAPIDJSON_ASSERT(buffer != 0);
-        RAPIDJSON_ASSERT(size > sizeof(ChunkHeader));
-        chunkHead_ = reinterpret_cast<ChunkHeader*>(buffer);
-        chunkHead_->capacity = size - sizeof(ChunkHeader);
-        chunkHead_->size = 0;
-        chunkHead_->next = 0;
-    }
-
-    //! Destructor.
-    /*! This deallocates all memory chunks, excluding the user-supplied buffer.
-    */
-    ~MemoryPoolAllocator() {
-        Clear();
-        RAPIDJSON_DELETE(ownBaseAllocator_);
-    }
-
-    //! Deallocates all memory chunks, excluding the user-supplied buffer.
-    void Clear() {
-        while(chunkHead_ != 0 && chunkHead_ != userBuffer_) {
-            ChunkHeader* next = chunkHead_->next;
-            baseAllocator_->Free(chunkHead_);
-            chunkHead_ = next;
-        }
-    }
-
-    //! Computes the total capacity of allocated memory chunks.
-    /*! \return total capacity in bytes.
-    */
-    size_t Capacity() const {
-        size_t capacity = 0;
-        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
-            capacity += c->capacity;
-        return capacity;
-    }
-
-    //! Computes the memory blocks allocated.
-    /*! \return total used bytes.
-    */
-    size_t Size() const {
-        size_t size = 0;
-        for (ChunkHeader* c = chunkHead_; c != 0; c = c->next)
-            size += c->size;
-        return size;
-    }
-
-    //! Allocates a memory block. (concept Allocator)
-    void* Malloc(size_t size) {
-        size = RAPIDJSON_ALIGN(size);
-        if (chunkHead_ == 0 || chunkHead_->size + size > chunkHead_->capacity)
-            AddChunk(chunk_capacity_ > size ? chunk_capacity_ : size);
-
-        void *buffer = reinterpret_cast<char *>(chunkHead_ + 1) + chunkHead_->size;
-        chunkHead_->size += size;
-        return buffer;
-    }
-
-    //! Resizes a memory block (concept Allocator)
-    void* Realloc(void* originalPtr, size_t originalSize, size_t newSize) {
-        if (originalPtr == 0)
-            return Malloc(newSize);
-
-        // Do not shrink if new size is smaller than original
-        if (originalSize >= newSize)
-            return originalPtr;
-
-        // Simply expand it if it is the last allocation and there is sufficient space
-        if (originalPtr == (char *)(chunkHead_ + 1) + chunkHead_->size - originalSize) {
-            size_t increment = static_cast<size_t>(newSize - originalSize);
-            increment = RAPIDJSON_ALIGN(increment);
-            if (chunkHead_->size + increment <= chunkHead_->capacity) {
-                chunkHead_->size += increment;
-                return originalPtr;
-            }
-        }
-
-        // Realloc process: allocate and copy memory, do not free original buffer.
-        void* newBuffer = Malloc(newSize);
-        RAPIDJSON_ASSERT(newBuffer != 0);   // Do not handle out-of-memory explicitly.
-        return std::memcpy(newBuffer, originalPtr, originalSize);
-    }
-
-    //! Frees a memory block (concept Allocator)
-    static void Free(void *ptr) { (void)ptr; } // Do nothing
-
-private:
-    //! Copy constructor is not permitted.
-    MemoryPoolAllocator(const MemoryPoolAllocator& rhs) /* = delete */;
-    //! Copy assignment operator is not permitted.
-    MemoryPoolAllocator& operator=(const MemoryPoolAllocator& rhs) /* = delete */;
-
-    //! Creates a new chunk.
-    /*! \param capacity Capacity of the chunk in bytes.
-    */
-    void AddChunk(size_t capacity) {
-        if (!baseAllocator_)
-            ownBaseAllocator_ = baseAllocator_ = RAPIDJSON_NEW(BaseAllocator());
-        ChunkHeader* chunk = reinterpret_cast<ChunkHeader*>(baseAllocator_->Malloc(sizeof(ChunkHeader) + capacity));
-        chunk->capacity = capacity;
-        chunk->size = 0;
-        chunk->next = chunkHead_;
-        chunkHead_ =  chunk;
-    }
-
-    static const int kDefaultChunkCapacity = 64 * 1024; //!< Default chunk capacity.
-
-    //! Chunk header for perpending to each chunk.
-    /*! Chunks are stored as a singly linked list.
-    */
-    struct ChunkHeader {
-        size_t capacity;    //!< Capacity of the chunk in bytes (excluding the header itself).
-        size_t size;        //!< Current size of allocated memory in bytes.
-        ChunkHeader *next;  //!< Next chunk in the linked list.
-    };
-
-    ChunkHeader *chunkHead_;    //!< Head of the chunk linked-list. Only the head chunk serves allocation.
-    size_t chunk_capacity_;     //!< The minimum capacity of chunk when they are allocated.
-    void *userBuffer_;          //!< User supplied buffer.
-    BaseAllocator* baseAllocator_;  //!< base allocator for allocating memory chunks.
-    BaseAllocator* ownBaseAllocator_;   //!< base allocator created by this object.
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/document.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/document.h
deleted file mode 100644
index 85e2567..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/document.h
+++ /dev/null
@@ -1,1969 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_DOCUMENT_H_
-#define RAPIDJSON_DOCUMENT_H_
-
-/*! \file document.h */
-
-#include "reader.h"
-#include "internal/meta.h"
-#include "internal/strfunc.h"
-#include <new>      // placement new
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#elif defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_HAS_STDSTRING
-
-#ifndef RAPIDJSON_HAS_STDSTRING
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_HAS_STDSTRING 1 // force generation of documentation
-#else
-#define RAPIDJSON_HAS_STDSTRING 0 // no std::string support by default
-#endif
-/*! \def RAPIDJSON_HAS_STDSTRING
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable RapidJSON support for \c std::string
-
-    By defining this preprocessor symbol to \c 1, several convenience functions for using
-    \ref rapidjson::GenericValue with \c std::string are enabled, especially
-    for construction and comparison.
-
-    \hideinitializer
-*/
-#include <string>
-#endif // RAPIDJSON_HAS_STDSTRING
-
-#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-#include <iterator> // std::iterator, std::random_access_iterator_tag
-#endif
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#include <utility> // std::move
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-// Forward declaration.
-template <typename Encoding, typename Allocator>
-class GenericValue;
-
-//! Name-value pair in a JSON object value.
-/*!
-    This class was internal to GenericValue. It used to be a inner struct.
-    But a compiler (IBM XL C/C++ for AIX) have reported to have problem with that so it moved as a namespace scope struct.
-    https://code.google.com/p/rapidjson/issues/detail?id=64
-*/
-template <typename Encoding, typename Allocator> 
-struct GenericMember { 
-    GenericValue<Encoding, Allocator> name;     //!< name of member (must be a string)
-    GenericValue<Encoding, Allocator> value;    //!< value of member.
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericMemberIterator
-
-#ifndef RAPIDJSON_NOMEMBERITERATORCLASS
-
-//! (Constant) member iterator for a JSON object value
-/*!
-    \tparam Const Is this a constant iterator?
-    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
-    \tparam Allocator   Allocator type for allocating memory of object, array and string.
-
-    This class implements a Random Access Iterator for GenericMember elements
-    of a GenericValue, see ISO/IEC 14882:2003(E) C++ standard, 24.1 [lib.iterator.requirements].
-
-    \note This iterator implementation is mainly intended to avoid implicit
-        conversions from iterator values to \c NULL,
-        e.g. from GenericValue::FindMember.
-
-    \note Define \c RAPIDJSON_NOMEMBERITERATORCLASS to fall back to a
-        pointer-based implementation, if your platform doesn't provide
-        the C++ <iterator> header.
-
-    \see GenericMember, GenericValue::MemberIterator, GenericValue::ConstMemberIterator
- */
-template <bool Const, typename Encoding, typename Allocator>
-class GenericMemberIterator
-    : public std::iterator<std::random_access_iterator_tag
-        , typename internal::MaybeAddConst<Const,GenericMember<Encoding,Allocator> >::Type> {
-
-    friend class GenericValue<Encoding,Allocator>;
-    template <bool, typename, typename> friend class GenericMemberIterator;
-
-    typedef GenericMember<Encoding,Allocator> PlainType;
-    typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
-    typedef std::iterator<std::random_access_iterator_tag,ValueType> BaseType;
-
-public:
-    //! Iterator type itself
-    typedef GenericMemberIterator Iterator;
-    //! Constant iterator type
-    typedef GenericMemberIterator<true,Encoding,Allocator>  ConstIterator;
-    //! Non-constant iterator type
-    typedef GenericMemberIterator<false,Encoding,Allocator> NonConstIterator;
-
-    //! Pointer to (const) GenericMember
-    typedef typename BaseType::pointer         Pointer;
-    //! Reference to (const) GenericMember
-    typedef typename BaseType::reference       Reference;
-    //! Signed integer type (e.g. \c ptrdiff_t)
-    typedef typename BaseType::difference_type DifferenceType;
-
-    //! Default constructor (singular value)
-    /*! Creates an iterator pointing to no element.
-        \note All operations, except for comparisons, are undefined on such values.
-     */
-    GenericMemberIterator() : ptr_() {}
-
-    //! Iterator conversions to more const
-    /*!
-        \param it (Non-const) iterator to copy from
-
-        Allows the creation of an iterator from another GenericMemberIterator
-        that is "less const".  Especially, creating a non-constant iterator
-        from a constant iterator are disabled:
-        \li const -> non-const (not ok)
-        \li const -> const (ok)
-        \li non-const -> const (ok)
-        \li non-const -> non-const (ok)
-
-        \note If the \c Const template parameter is already \c false, this
-            constructor effectively defines a regular copy-constructor.
-            Otherwise, the copy constructor is implicitly defined.
-    */
-    GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
-
-    //! @name stepping
-    //@{
-    Iterator& operator++(){ ++ptr_; return *this; }
-    Iterator& operator--(){ --ptr_; return *this; }
-    Iterator  operator++(int){ Iterator old(*this); ++ptr_; return old; }
-    Iterator  operator--(int){ Iterator old(*this); --ptr_; return old; }
-    //@}
-
-    //! @name increment/decrement
-    //@{
-    Iterator operator+(DifferenceType n) const { return Iterator(ptr_+n); }
-    Iterator operator-(DifferenceType n) const { return Iterator(ptr_-n); }
-
-    Iterator& operator+=(DifferenceType n) { ptr_+=n; return *this; }
-    Iterator& operator-=(DifferenceType n) { ptr_-=n; return *this; }
-    //@}
-
-    //! @name relations
-    //@{
-    bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
-    bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
-    bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
-    bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
-    bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
-    bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }
-    //@}
-
-    //! @name dereference
-    //@{
-    Reference operator*() const { return *ptr_; }
-    Pointer   operator->() const { return ptr_; }
-    Reference operator[](DifferenceType n) const { return ptr_[n]; }
-    //@}
-
-    //! Distance
-    DifferenceType operator-(ConstIterator that) const { return ptr_-that.ptr_; }
-
-private:
-    //! Internal constructor from plain pointer
-    explicit GenericMemberIterator(Pointer p) : ptr_(p) {}
-
-    Pointer ptr_; //!< raw pointer
-};
-
-#else // RAPIDJSON_NOMEMBERITERATORCLASS
-
-// class-based member iterator implementation disabled, use plain pointers
-
-template <bool Const, typename Encoding, typename Allocator>
-struct GenericMemberIterator;
-
-//! non-const GenericMemberIterator
-template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<false,Encoding,Allocator> {
-    //! use plain pointer as iterator type
-    typedef GenericMember<Encoding,Allocator>* Iterator;
-};
-//! const GenericMemberIterator
-template <typename Encoding, typename Allocator>
-struct GenericMemberIterator<true,Encoding,Allocator> {
-    //! use plain const pointer as iterator type
-    typedef const GenericMember<Encoding,Allocator>* Iterator;
-};
-
-#endif // RAPIDJSON_NOMEMBERITERATORCLASS
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericStringRef
-
-//! Reference to a constant string (not taking a copy)
-/*!
-    \tparam CharType character type of the string
-
-    This helper class is used to automatically infer constant string
-    references for string literals, especially from \c const \b (!)
-    character arrays.
-
-    The main use is for creating JSON string values without copying the
-    source string via an \ref Allocator.  This requires that the referenced
-    string pointers have a sufficient lifetime, which exceeds the lifetime
-    of the associated GenericValue.
-
-    \b Example
-    \code
-    Value v("foo");   // ok, no need to copy & calculate length
-    const char foo[] = "foo";
-    v.SetString(foo); // ok
-
-    const char* bar = foo;
-    // Value x(bar); // not ok, can't rely on bar's lifetime
-    Value x(StringRef(bar)); // lifetime explicitly guaranteed by user
-    Value y(StringRef(bar, 3));  // ok, explicitly pass length
-    \endcode
-
-    \see StringRef, GenericValue::SetString
-*/
-template<typename CharType>
-struct GenericStringRef {
-    typedef CharType Ch; //!< character type of the string
-
-    //! Create string reference from \c const character array
-    /*!
-        This constructor implicitly creates a constant string reference from
-        a \c const character array.  It has better performance than
-        \ref StringRef(const CharType*) by inferring the string \ref length
-        from the array length, and also supports strings containing null
-        characters.
-
-        \tparam N length of the string, automatically inferred
-
-        \param str Constant character array, lifetime assumed to be longer
-            than the use of the string in e.g. a GenericValue
-
-        \post \ref s == str
-
-        \note Constant complexity.
-        \note There is a hidden, private overload to disallow references to
-            non-const character arrays to be created via this constructor.
-            By this, e.g. function-scope arrays used to be filled via
-            \c snprintf are excluded from consideration.
-            In such cases, the referenced string should be \b copied to the
-            GenericValue instead.
-     */
-    template<SizeType N>
-    GenericStringRef(const CharType (&str)[N]) RAPIDJSON_NOEXCEPT
-        : s(str), length(N-1) {}
-
-    //! Explicitly create string reference from \c const character pointer
-    /*!
-        This constructor can be used to \b explicitly  create a reference to
-        a constant string pointer.
-
-        \see StringRef(const CharType*)
-
-        \param str Constant character pointer, lifetime assumed to be longer
-            than the use of the string in e.g. a GenericValue
-
-        \post \ref s == str
-
-        \note There is a hidden, private overload to disallow references to
-            non-const character arrays to be created via this constructor.
-            By this, e.g. function-scope arrays used to be filled via
-            \c snprintf are excluded from consideration.
-            In such cases, the referenced string should be \b copied to the
-            GenericValue instead.
-     */
-    explicit GenericStringRef(const CharType* str)
-        : s(str), length(internal::StrLen(str)){ RAPIDJSON_ASSERT(s != NULL); }
-
-    //! Create constant string reference from pointer and length
-    /*! \param str constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-        \param len length of the string, excluding the trailing NULL terminator
-
-        \post \ref s == str && \ref length == len
-        \note Constant complexity.
-     */
-    GenericStringRef(const CharType* str, SizeType len)
-        : s(str), length(len) { RAPIDJSON_ASSERT(s != NULL); }
-
-    //! implicit conversion to plain CharType pointer
-    operator const Ch *() const { return s; }
-
-    const Ch* const s; //!< plain CharType pointer
-    const SizeType length; //!< length of the string (excluding the trailing NULL terminator)
-
-private:
-    //! Disallow copy-assignment
-    GenericStringRef operator=(const GenericStringRef&);
-    //! Disallow construction from non-const array
-    template<SizeType N>
-    GenericStringRef(CharType (&str)[N]) /* = delete */;
-};
-
-//! Mark a character pointer as constant string
-/*! Mark a plain character pointer as a "string literal".  This function
-    can be used to avoid copying a character string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-    \tparam CharType Character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-
-    \see GenericValue::GenericValue(StringRefType), GenericValue::operator=(StringRefType), GenericValue::SetString(StringRefType), GenericValue::PushBack(StringRefType, Allocator&), GenericValue::AddMember
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const CharType* str) {
-    return GenericStringRef<CharType>(str, internal::StrLen(str));
-}
-
-//! Mark a character pointer as constant string
-/*! Mark a plain character pointer as a "string literal".  This function
-    can be used to avoid copying a character string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-
-    This version has better performance with supplied length, and also
-    supports string containing null characters.
-
-    \tparam CharType character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \param length The length of source string.
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const CharType* str, size_t length) {
-    return GenericStringRef<CharType>(str, SizeType(length));
-}
-
-#if RAPIDJSON_HAS_STDSTRING
-//! Mark a string object as constant string
-/*! Mark a string object (e.g. \c std::string) as a "string literal".
-    This function can be used to avoid copying a string to be referenced as a
-    value in a JSON GenericValue object, if the string's lifetime is known
-    to be valid long enough.
-
-    \tparam CharType character type of the string
-    \param str Constant string, lifetime assumed to be longer than the use of the string in e.g. a GenericValue
-    \return GenericStringRef string reference object
-    \relatesalso GenericStringRef
-    \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-*/
-template<typename CharType>
-inline GenericStringRef<CharType> StringRef(const std::basic_string<CharType>& str) {
-    return GenericStringRef<CharType>(str.data(), SizeType(str.size()));
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericValue type traits
-namespace internal {
-
-template <typename T, typename Encoding = void, typename Allocator = void>
-struct IsGenericValueImpl : FalseType {};
-
-// select candidates according to nested encoding and allocator types
-template <typename T> struct IsGenericValueImpl<T, typename Void<typename T::EncodingType>::Type, typename Void<typename T::AllocatorType>::Type>
-    : IsBaseOf<GenericValue<typename T::EncodingType, typename T::AllocatorType>, T>::Type {};
-
-// helper to match arbitrary GenericValue instantiations, including derived classes
-template <typename T> struct IsGenericValue : IsGenericValueImpl<T>::Type {};
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericValue
-
-//! Represents a JSON value. Use Value for UTF8 encoding and default allocator.
-/*!
-    A JSON value can be one of 7 types. This class is a variant type supporting
-    these types.
-
-    Use the Value if UTF8 and default allocator
-
-    \tparam Encoding    Encoding of the value. (Even non-string values need to have the same encoding in a document)
-    \tparam Allocator   Allocator type for allocating memory of object, array and string.
-*/
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
-class GenericValue {
-public:
-    //! Name-value pair in an object.
-    typedef GenericMember<Encoding, Allocator> Member;
-    typedef Encoding EncodingType;                  //!< Encoding type from template parameter.
-    typedef Allocator AllocatorType;                //!< Allocator type from template parameter.
-    typedef typename Encoding::Ch Ch;               //!< Character type derived from Encoding.
-    typedef GenericStringRef<Ch> StringRefType;     //!< Reference to a constant string
-    typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterator MemberIterator;  //!< Member iterator for iterating in object.
-    typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterator ConstMemberIterator;  //!< Constant member iterator for iterating in object.
-    typedef GenericValue* ValueIterator;            //!< Value iterator for iterating in array.
-    typedef const GenericValue* ConstValueIterator; //!< Constant value iterator for iterating in array.
-
-    //!@name Constructors and destructor.
-    //@{
-
-    //! Default constructor creates a null value.
-    GenericValue() RAPIDJSON_NOEXCEPT : data_(), flags_(kNullFlag) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericValue(GenericValue&& rhs) RAPIDJSON_NOEXCEPT : data_(rhs.data_), flags_(rhs.flags_) {
-        rhs.flags_ = kNullFlag; // give up contents
-    }
-#endif
-
-private:
-    //! Copy constructor is not permitted.
-    GenericValue(const GenericValue& rhs);
-
-public:
-
-    //! Constructor with JSON value type.
-    /*! This creates a Value of specified type with default content.
-        \param type Type of the value.
-        \note Default content for number is zero.
-    */
-    explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_(), flags_() {
-        static const unsigned defaultFlags[7] = {
-            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
-            kNumberAnyFlag
-        };
-        RAPIDJSON_ASSERT(type <= kNumberType);
-        flags_ = defaultFlags[type];
-
-        // Use ShortString to store empty string.
-        if (type == kStringType)
-            data_.ss.SetLength(0);
-    }
-
-    //! Explicit copy constructor (with allocator)
-    /*! Creates a copy of a Value by using the given Allocator
-        \tparam SourceAllocator allocator of \c rhs
-        \param rhs Value to copy from (read-only)
-        \param allocator Allocator for allocating copied elements and buffers. Commonly use GenericDocument::GetAllocator().
-        \see CopyFrom()
-    */
-    template< typename SourceAllocator >
-    GenericValue(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator & allocator);
-
-    //! Constructor for boolean value.
-    /*! \param b Boolean value
-        \note This constructor is limited to \em real boolean values and rejects
-            implicitly converted types like arbitrary pointers.  Use an explicit cast
-            to \c bool, if you want to construct a boolean JSON value in such cases.
-     */
-#ifndef RAPIDJSON_DOXYGEN_RUNNING // hide SFINAE from Doxygen
-    template <typename T>
-    explicit GenericValue(T b, RAPIDJSON_ENABLEIF((internal::IsSame<T,bool>))) RAPIDJSON_NOEXCEPT
-#else
-    explicit GenericValue(bool b) RAPIDJSON_NOEXCEPT
-#endif
-        : data_(), flags_(b ? kTrueFlag : kFalseFlag) {
-            // safe-guard against failing SFINAE
-            RAPIDJSON_STATIC_ASSERT((internal::IsSame<bool,T>::Value));
-    }
-
-    //! Constructor for int value.
-    explicit GenericValue(int i) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberIntFlag) {
-        data_.n.i64 = i;
-        if (i >= 0)
-            flags_ |= kUintFlag | kUint64Flag;
-    }
-
-    //! Constructor for unsigned value.
-    explicit GenericValue(unsigned u) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberUintFlag) {
-        data_.n.u64 = u; 
-        if (!(u & 0x80000000))
-            flags_ |= kIntFlag | kInt64Flag;
-    }
-
-    //! Constructor for int64_t value.
-    explicit GenericValue(int64_t i64) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberInt64Flag) {
-        data_.n.i64 = i64;
-        if (i64 >= 0) {
-            flags_ |= kNumberUint64Flag;
-            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
-                flags_ |= kUintFlag;
-            if (!(static_cast<uint64_t>(i64) & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-                flags_ |= kIntFlag;
-        }
-        else if (i64 >= static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-            flags_ |= kIntFlag;
-    }
-
-    //! Constructor for uint64_t value.
-    explicit GenericValue(uint64_t u64) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberUint64Flag) {
-        data_.n.u64 = u64;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)))
-            flags_ |= kInt64Flag;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x00000000)))
-            flags_ |= kUintFlag;
-        if (!(u64 & RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x80000000)))
-            flags_ |= kIntFlag;
-    }
-
-    //! Constructor for double value.
-    explicit GenericValue(double d) RAPIDJSON_NOEXCEPT : data_(), flags_(kNumberDoubleFlag) { data_.n.d = d; }
-
-    //! Constructor for constant string (i.e. do not make a copy of string)
-    GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_(), flags_() { SetStringRaw(StringRef(s, length)); }
-
-    //! Constructor for constant string (i.e. do not make a copy of string)
-    explicit GenericValue(StringRefType s) RAPIDJSON_NOEXCEPT : data_(), flags_() { SetStringRaw(s); }
-
-    //! Constructor for copy-string (i.e. do make a copy of string)
-    GenericValue(const Ch* s, SizeType length, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s, length), allocator); }
-
-    //! Constructor for copy-string (i.e. do make a copy of string)
-    GenericValue(const Ch*s, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s), allocator); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Constructor for copy-string from a string object (i.e. do make a copy of string)
-    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-     */
-    GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_(), flags_() { SetStringRaw(StringRef(s), allocator); }
-#endif
-
-    //! Destructor.
-    /*! Need to destruct elements of array, members of object, or copy-string.
-    */
-    ~GenericValue() {
-        if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
-            switch(flags_) {
-            case kArrayFlag:
-                for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
-                    v->~GenericValue();
-                Allocator::Free(data_.a.elements);
-                break;
-
-            case kObjectFlag:
-                for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
-                    m->~Member();
-                Allocator::Free(data_.o.members);
-                break;
-
-            case kCopyStringFlag:
-                Allocator::Free(const_cast<Ch*>(data_.s.str));
-                break;
-
-            default:
-                break;  // Do nothing for other types.
-            }
-        }
-    }
-
-    //@}
-
-    //!@name Assignment operators
-    //@{
-
-    //! Assignment with move semantics.
-    /*! \param rhs Source of the assignment. It will become a null value after assignment.
-    */
-    GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
-        RAPIDJSON_ASSERT(this != &rhs);
-        this->~GenericValue();
-        RawAssign(rhs);
-        return *this;
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move assignment in C++11
-    GenericValue& operator=(GenericValue&& rhs) RAPIDJSON_NOEXCEPT {
-        return *this = rhs.Move();
-    }
-#endif
-
-    //! Assignment of constant string reference (no copy)
-    /*! \param str Constant string reference to be assigned
-        \note This overload is needed to avoid clashes with the generic primitive type assignment overload below.
-        \see GenericStringRef, operator=(T)
-    */
-    GenericValue& operator=(StringRefType str) RAPIDJSON_NOEXCEPT {
-        GenericValue s(str);
-        return *this = s;
-    }
-
-    //! Assignment with primitive types.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param value The value to be assigned.
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref SetString(const Ch*, Allocator&) (for copying) or
-            \ref StringRef() (to explicitly mark the pointer as constant) instead.
-            All other pointer types would implicitly convert to \c bool,
-            use \ref SetBool() instead.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::IsPointer<T>), (GenericValue&))
-    operator=(T value) {
-        GenericValue v(value);
-        return *this = v;
-    }
-
-    //! Deep-copy assignment from Value
-    /*! Assigns a \b copy of the Value to the current Value object
-        \tparam SourceAllocator Allocator type of \c rhs
-        \param rhs Value to copy from (read-only)
-        \param allocator Allocator to use for copying
-     */
-    template <typename SourceAllocator>
-    GenericValue& CopyFrom(const GenericValue<Encoding, SourceAllocator>& rhs, Allocator& allocator) {
-        RAPIDJSON_ASSERT((void*)this != (void const*)&rhs);
-        this->~GenericValue();
-        new (this) GenericValue(rhs, allocator);
-        return *this;
-    }
-
-    //! Exchange the contents of this value with those of other.
-    /*!
-        \param other Another value.
-        \note Constant complexity.
-    */
-    GenericValue& Swap(GenericValue& other) RAPIDJSON_NOEXCEPT {
-        GenericValue temp;
-        temp.RawAssign(*this);
-        RawAssign(other);
-        other.RawAssign(temp);
-        return *this;
-    }
-
-    //! Prepare Value for move semantics
-    /*! \return *this */
-    GenericValue& Move() RAPIDJSON_NOEXCEPT { return *this; }
-    //@}
-
-    //!@name Equal-to and not-equal-to operators
-    //@{
-    //! Equal-to operator
-    /*!
-        \note If an object contains duplicated named member, comparing equality with any object is always \c false.
-        \note Linear time complexity (number of all values in the subtree and total lengths of all strings).
-    */
-    template <typename SourceAllocator>
-    bool operator==(const GenericValue<Encoding, SourceAllocator>& rhs) const {
-        typedef GenericValue<Encoding, SourceAllocator> RhsType;
-        if (GetType() != rhs.GetType())
-            return false;
-
-        switch (GetType()) {
-        case kObjectType: // Warning: O(n^2) inner-loop
-            if (data_.o.size != rhs.data_.o.size)
-                return false;           
-            for (ConstMemberIterator lhsMemberItr = MemberBegin(); lhsMemberItr != MemberEnd(); ++lhsMemberItr) {
-                typename RhsType::ConstMemberIterator rhsMemberItr = rhs.FindMember(lhsMemberItr->name);
-                if (rhsMemberItr == rhs.MemberEnd() || lhsMemberItr->value != rhsMemberItr->value)
-                    return false;
-            }
-            return true;
-            
-        case kArrayType:
-            if (data_.a.size != rhs.data_.a.size)
-                return false;
-            for (SizeType i = 0; i < data_.a.size; i++)
-                if ((*this)[i] != rhs[i])
-                    return false;
-            return true;
-
-        case kStringType:
-            return StringEqual(rhs);
-
-        case kNumberType:
-            if (IsDouble() || rhs.IsDouble())
-                return GetDouble() == rhs.GetDouble(); // May convert one operand from integer to double.
-            else
-                return data_.n.u64 == rhs.data_.n.u64;
-
-        default: // kTrueType, kFalseType, kNullType
-            return true;
-        }
-    }
-
-    //! Equal-to operator with const C-string pointer
-    bool operator==(const Ch* rhs) const { return *this == GenericValue(StringRef(rhs)); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Equal-to operator with string object
-    /*! \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-     */
-    bool operator==(const std::basic_string<Ch>& rhs) const { return *this == GenericValue(StringRef(rhs)); }
-#endif
-
-    //! Equal-to operator with primitive types
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t, \c double, \c true, \c false
-    */
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>,internal::IsGenericValue<T> >), (bool)) operator==(const T& rhs) const { return *this == GenericValue(rhs); }
-
-    //! Not-equal-to operator
-    /*! \return !(*this == rhs)
-     */
-    template <typename SourceAllocator>
-    bool operator!=(const GenericValue<Encoding, SourceAllocator>& rhs) const { return !(*this == rhs); }
-
-    //! Not-equal-to operator with const C-string pointer
-    bool operator!=(const Ch* rhs) const { return !(*this == rhs); }
-
-    //! Not-equal-to operator with arbitrary types
-    /*! \return !(*this == rhs)
-     */
-    template <typename T> RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& rhs) const { return !(*this == rhs); }
-
-    //! Equal-to operator with arbitrary types (symmetric version)
-    /*! \return (rhs == lhs)
-     */
-    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator==(const T& lhs, const GenericValue& rhs) { return rhs == lhs; }
-
-    //! Not-Equal-to operator with arbitrary types (symmetric version)
-    /*! \return !(rhs == lhs)
-     */
-    template <typename T> friend RAPIDJSON_DISABLEIF_RETURN((internal::IsGenericValue<T>), (bool)) operator!=(const T& lhs, const GenericValue& rhs) { return !(rhs == lhs); }
-    //@}
-
-    //!@name Type
-    //@{
-
-    Type GetType()  const { return static_cast<Type>(flags_ & kTypeMask); }
-    bool IsNull()   const { return flags_ == kNullFlag; }
-    bool IsFalse()  const { return flags_ == kFalseFlag; }
-    bool IsTrue()   const { return flags_ == kTrueFlag; }
-    bool IsBool()   const { return (flags_ & kBoolFlag) != 0; }
-    bool IsObject() const { return flags_ == kObjectFlag; }
-    bool IsArray()  const { return flags_ == kArrayFlag; }
-    bool IsNumber() const { return (flags_ & kNumberFlag) != 0; }
-    bool IsInt()    const { return (flags_ & kIntFlag) != 0; }
-    bool IsUint()   const { return (flags_ & kUintFlag) != 0; }
-    bool IsInt64()  const { return (flags_ & kInt64Flag) != 0; }
-    bool IsUint64() const { return (flags_ & kUint64Flag) != 0; }
-    bool IsDouble() const { return (flags_ & kDoubleFlag) != 0; }
-    bool IsString() const { return (flags_ & kStringFlag) != 0; }
-
-    //@}
-
-    //!@name Null
-    //@{
-
-    GenericValue& SetNull() { this->~GenericValue(); new (this) GenericValue(); return *this; }
-
-    //@}
-
-    //!@name Bool
-    //@{
-
-    bool GetBool() const { RAPIDJSON_ASSERT(IsBool()); return flags_ == kTrueFlag; }
-    //!< Set boolean value
-    /*! \post IsBool() == true */
-    GenericValue& SetBool(bool b) { this->~GenericValue(); new (this) GenericValue(b); return *this; }
-
-    //@}
-
-    //!@name Object
-    //@{
-
-    //! Set this value as an empty object.
-    /*! \post IsObject() == true */
-    GenericValue& SetObject() { this->~GenericValue(); new (this) GenericValue(kObjectType); return *this; }
-
-    //! Get the number of members in the object.
-    SizeType MemberCount() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size; }
-
-    //! Check whether the object is empty.
-    bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
-
-    //! Get a value from an object associated with the name.
-    /*! \pre IsObject() == true
-        \tparam T Either \c Ch or \c const \c Ch (template used for disambiguation with \ref operator[](SizeType))
-        \note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.
-        Since 0.2, if the name is not correct, it will assert.
-        If user is unsure whether a member exists, user should use HasMember() first.
-        A better approach is to use FindMember().
-        \note Linear time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
-        GenericValue n(StringRef(name));
-        return (*this)[n];
-    }
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }
-
-    //! Get a value from an object associated with the name.
-    /*! \pre IsObject() == true
-        \tparam SourceAllocator Allocator of the \c name value
-
-        \note Compared to \ref operator[](T*), this version is faster because it does not need a StrLen().
-        And it can also handle strings with embedded null characters.
-
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator member = FindMember(name);
-        if (member != MemberEnd())
-            return member->value;
-        else {
-            RAPIDJSON_ASSERT(false);    // see above note
-            static GenericValue NullValue;
-            return NullValue;
-        }
-    }
-    template <typename SourceAllocator>
-    const GenericValue& operator[](const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this)[name]; }
-
-    //! Const member iterator
-    /*! \pre IsObject() == true */
-    ConstMemberIterator MemberBegin() const { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(data_.o.members); }
-    //! Const \em past-the-end member iterator
-    /*! \pre IsObject() == true */
-    ConstMemberIterator MemberEnd() const   { RAPIDJSON_ASSERT(IsObject()); return ConstMemberIterator(data_.o.members + data_.o.size); }
-    //! Member iterator
-    /*! \pre IsObject() == true */
-    MemberIterator MemberBegin()            { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(data_.o.members); }
-    //! \em Past-the-end member iterator
-    /*! \pre IsObject() == true */
-    MemberIterator MemberEnd()              { RAPIDJSON_ASSERT(IsObject()); return MemberIterator(data_.o.members + data_.o.size); }
-
-    //! Check whether a member exists in the object.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Whether a member with that name exists.
-        \note It is better to use FindMember() directly if you need the obtain the value as well.
-        \note Linear time complexity.
-    */
-    bool HasMember(const Ch* name) const { return FindMember(name) != MemberEnd(); }
-
-    //! Check whether a member exists in the object with GenericValue name.
-    /*!
-        This version is faster because it does not need a StrLen(). It can also handle string with null character.
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Whether a member with that name exists.
-        \note It is better to use FindMember() directly if you need the obtain the value as well.
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    bool HasMember(const GenericValue<Encoding, SourceAllocator>& name) const { return FindMember(name) != MemberEnd(); }
-
-    //! Find member by name.
-    /*!
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Iterator to member, if it exists.
-            Otherwise returns \ref MemberEnd().
-
-        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
-            the requested member doesn't exist. For consistency with e.g.
-            \c std::map, this has been changed to MemberEnd() now.
-        \note Linear time complexity.
-    */
-    MemberIterator FindMember(const Ch* name) {
-        GenericValue n(StringRef(name));
-        return FindMember(n);
-    }
-
-    ConstMemberIterator FindMember(const Ch* name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
-
-    //! Find member by name.
-    /*!
-        This version is faster because it does not need a StrLen(). It can also handle string with null character.
-        \param name Member name to be searched.
-        \pre IsObject() == true
-        \return Iterator to member, if it exists.
-            Otherwise returns \ref MemberEnd().
-
-        \note Earlier versions of Rapidjson returned a \c NULL pointer, in case
-            the requested member doesn't exist. For consistency with e.g.
-            \c std::map, this has been changed to MemberEnd() now.
-        \note Linear time complexity.
-    */
-    template <typename SourceAllocator>
-    MemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(name.IsString());
-        MemberIterator member = MemberBegin();
-        for ( ; member != MemberEnd(); ++member)
-            if (name.StringEqual(member->name))
-                break;
-        return member;
-    }
-    template <typename SourceAllocator> ConstMemberIterator FindMember(const GenericValue<Encoding, SourceAllocator>& name) const { return const_cast<GenericValue&>(*this).FindMember(name); }
-
-    //! Add a member (name-value pair) to the object.
-    /*! \param name A string value as name of member.
-        \param value Value of any type.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note The ownership of \c name and \c value will be transferred to this object on success.
-        \pre  IsObject() && name.IsString()
-        \post name.IsNull() && value.IsNull()
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(GenericValue& name, GenericValue& value, Allocator& allocator) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(name.IsString());
-
-        Object& o = data_.o;
-        if (o.size >= o.capacity) {
-            if (o.capacity == 0) {
-                o.capacity = kDefaultObjectCapacity;
-                o.members = reinterpret_cast<Member*>(allocator.Malloc(o.capacity * sizeof(Member)));
-            }
-            else {
-                SizeType oldCapacity = o.capacity;
-                o.capacity += (oldCapacity + 1) / 2; // grow by factor 1.5
-                o.members = reinterpret_cast<Member*>(allocator.Realloc(o.members, oldCapacity * sizeof(Member), o.capacity * sizeof(Member)));
-            }
-        }
-        o.members[o.size].name.RawAssign(name);
-        o.members[o.size].value.RawAssign(value);
-        o.size++;
-        return *this;
-    }
-
-    //! Add a constant string value as member (name-value pair) to the object.
-    /*! \param name A string value as name of member.
-        \param value constant string reference as value of member.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-        \note This overload is needed to avoid clashes with the generic primitive type AddMember(GenericValue&,T,Allocator&) overload below.
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(GenericValue& name, StringRefType value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-    //! Add any primitive value as member (name-value pair) to the object.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param name A string value as name of member.
-        \param value Value of primitive type \c T as value of member
-        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
-            AddMember(StringRefType, StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized Constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    AddMember(GenericValue& name, T value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericValue& AddMember(GenericValue&& name, GenericValue&& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(GenericValue&& name, GenericValue& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(GenericValue& name, GenericValue&& value, Allocator& allocator) {
-        return AddMember(name, value, allocator);
-    }
-    GenericValue& AddMember(StringRefType name, GenericValue&& value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-
-    //! Add a member (name-value pair) to the object.
-    /*! \param name A constant string reference as name of member.
-        \param value Value of any type.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note The ownership of \c value will be transferred to this object on success.
-        \pre  IsObject()
-        \post value.IsNull()
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(StringRefType name, GenericValue& value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-
-    //! Add a constant string value as member (name-value pair) to the object.
-    /*! \param name A constant string reference as name of member.
-        \param value constant string reference as value of member.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-        \note This overload is needed to avoid clashes with the generic primitive type AddMember(StringRefType,T,Allocator&) overload below.
-        \note Amortized Constant time complexity.
-    */
-    GenericValue& AddMember(StringRefType name, StringRefType value, Allocator& allocator) {
-        GenericValue v(value);
-        return AddMember(name, v, allocator);
-    }
-
-    //! Add any primitive value as member (name-value pair) to the object.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param name A constant string reference as name of member.
-        \param value Value of primitive type \c T as value of member
-        \param allocator Allocator for reallocating memory. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \pre  IsObject()
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref AddMember(StringRefType, GenericValue&, Allocator&) or \ref
-            AddMember(StringRefType, StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized Constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    AddMember(StringRefType name, T value, Allocator& allocator) {
-        GenericValue n(name);
-        return AddMember(n, value, allocator);
-    }
-
-    //! Remove all members in the object.
-    /*! This function do not deallocate memory in the object, i.e. the capacity is unchanged.
-        \note Linear time complexity.
-    */
-    void RemoveAllMembers() {
-        RAPIDJSON_ASSERT(IsObject()); 
-        for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
-            m->~Member();
-        data_.o.size = 0;
-    }
-
-    //! Remove a member in object by its name.
-    /*! \param name Name of member to be removed.
-        \return Whether the member existed.
-        \note This function may reorder the object members. Use \ref
-            EraseMember(ConstMemberIterator) if you need to preserve the
-            relative order of the remaining members.
-        \note Linear time complexity.
-    */
-    bool RemoveMember(const Ch* name) {
-        GenericValue n(StringRef(name));
-        return RemoveMember(n);
-    }
-
-    template <typename SourceAllocator>
-    bool RemoveMember(const GenericValue<Encoding, SourceAllocator>& name) {
-        MemberIterator m = FindMember(name);
-        if (m != MemberEnd()) {
-            RemoveMember(m);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    //! Remove a member in object by iterator.
-    /*! \param m member iterator (obtained by FindMember() or MemberBegin()).
-        \return the new iterator after removal.
-        \note This function may reorder the object members. Use \ref
-            EraseMember(ConstMemberIterator) if you need to preserve the
-            relative order of the remaining members.
-        \note Constant time complexity.
-    */
-    MemberIterator RemoveMember(MemberIterator m) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(data_.o.size > 0);
-        RAPIDJSON_ASSERT(data_.o.members != 0);
-        RAPIDJSON_ASSERT(m >= MemberBegin() && m < MemberEnd());
-
-        MemberIterator last(data_.o.members + (data_.o.size - 1));
-        if (data_.o.size > 1 && m != last) {
-            // Move the last one to this place
-            *m = *last;
-        }
-        else {
-            // Only one left, just destroy
-            m->~Member();
-        }
-        --data_.o.size;
-        return m;
-    }
-
-    //! Remove a member from an object by iterator.
-    /*! \param pos iterator to the member to remove
-        \pre IsObject() == true && \ref MemberBegin() <= \c pos < \ref MemberEnd()
-        \return Iterator following the removed element.
-            If the iterator \c pos refers to the last element, the \ref MemberEnd() iterator is returned.
-        \note This function preserves the relative order of the remaining object
-            members. If you do not need this, use the more efficient \ref RemoveMember(MemberIterator).
-        \note Linear time complexity.
-    */
-    MemberIterator EraseMember(ConstMemberIterator pos) {
-        return EraseMember(pos, pos +1);
-    }
-
-    //! Remove members in the range [first, last) from an object.
-    /*! \param first iterator to the first member to remove
-        \param last  iterator following the last member to remove
-        \pre IsObject() == true && \ref MemberBegin() <= \c first <= \c last <= \ref MemberEnd()
-        \return Iterator following the last removed element.
-        \note This function preserves the relative order of the remaining object
-            members.
-        \note Linear time complexity.
-    */
-    MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterator last) {
-        RAPIDJSON_ASSERT(IsObject());
-        RAPIDJSON_ASSERT(data_.o.size > 0);
-        RAPIDJSON_ASSERT(data_.o.members != 0);
-        RAPIDJSON_ASSERT(first >= MemberBegin());
-        RAPIDJSON_ASSERT(first <= last);
-        RAPIDJSON_ASSERT(last <= MemberEnd());
-
-        MemberIterator pos = MemberBegin() + (first - MemberBegin());
-        for (MemberIterator itr = pos; itr != last; ++itr)
-            itr->~Member();
-        std::memmove(&*pos, &*last, (MemberEnd() - last) * sizeof(Member));
-        data_.o.size -= (last - first);
-        return pos;
-    }
-
-    //@}
-
-    //!@name Array
-    //@{
-
-    //! Set this value as an empty array.
-    /*! \post IsArray == true */
-    GenericValue& SetArray() {  this->~GenericValue(); new (this) GenericValue(kArrayType); return *this; }
-
-    //! Get the number of elements in array.
-    SizeType Size() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size; }
-
-    //! Get the capacity of array.
-    SizeType Capacity() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.capacity; }
-
-    //! Check whether the array is empty.
-    bool Empty() const { RAPIDJSON_ASSERT(IsArray()); return data_.a.size == 0; }
-
-    //! Remove all elements in the array.
-    /*! This function do not deallocate memory in the array, i.e. the capacity is unchanged.
-        \note Linear time complexity.
-    */
-    void Clear() {
-        RAPIDJSON_ASSERT(IsArray()); 
-        for (SizeType i = 0; i < data_.a.size; ++i)
-            data_.a.elements[i].~GenericValue();
-        data_.a.size = 0;
-    }
-
-    //! Get an element from array by index.
-    /*! \pre IsArray() == true
-        \param index Zero-based index of element.
-        \see operator[](T*)
-    */
-    GenericValue& operator[](SizeType index) {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(index < data_.a.size);
-        return data_.a.elements[index];
-    }
-    const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }
-
-    //! Element iterator
-    /*! \pre IsArray() == true */
-    ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements; }
-    //! \em Past-the-end element iterator
-    /*! \pre IsArray() == true */
-    ValueIterator End() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements + data_.a.size; }
-    //! Constant element iterator
-    /*! \pre IsArray() == true */
-    ConstValueIterator Begin() const { return const_cast<GenericValue&>(*this).Begin(); }
-    //! Constant \em past-the-end element iterator
-    /*! \pre IsArray() == true */
-    ConstValueIterator End() const { return const_cast<GenericValue&>(*this).End(); }
-
-    //! Request the array to have enough capacity to store elements.
-    /*! \param newCapacity  The capacity that the array at least need to have.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \note Linear time complexity.
-    */
-    GenericValue& Reserve(SizeType newCapacity, Allocator &allocator) {
-        RAPIDJSON_ASSERT(IsArray());
-        if (newCapacity > data_.a.capacity) {
-            data_.a.elements = (GenericValue*)allocator.Realloc(data_.a.elements, data_.a.capacity * sizeof(GenericValue), newCapacity * sizeof(GenericValue));
-            data_.a.capacity = newCapacity;
-        }
-        return *this;
-    }
-
-    //! Append a GenericValue at the end of the array.
-    /*! \param value        Value to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \post value.IsNull() == true
-        \return The value itself for fluent API.
-        \note The ownership of \c value will be transferred to this array on success.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-        \note Amortized constant time complexity.
-    */
-    GenericValue& PushBack(GenericValue& value, Allocator& allocator) {
-        RAPIDJSON_ASSERT(IsArray());
-        if (data_.a.size >= data_.a.capacity)
-            Reserve(data_.a.capacity == 0 ? kDefaultArrayCapacity : (data_.a.capacity + (data_.a.capacity + 1) / 2), allocator);
-        data_.a.elements[data_.a.size++].RawAssign(value);
-        return *this;
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericValue& PushBack(GenericValue&& value, Allocator& allocator) {
-        return PushBack(value, allocator);
-    }
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-    //! Append a constant string reference at the end of the array.
-    /*! \param value        Constant string reference to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one used previously. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \return The value itself for fluent API.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-        \note Amortized constant time complexity.
-        \see GenericStringRef
-    */
-    GenericValue& PushBack(StringRefType value, Allocator& allocator) {
-        return (*this).template PushBack<StringRefType>(value, allocator);
-    }
-
-    //! Append a primitive value at the end of the array.
-    /*! \tparam T Either \ref Type, \c int, \c unsigned, \c int64_t, \c uint64_t
-        \param value Value of primitive type T to be appended.
-        \param allocator    Allocator for reallocating memory. It must be the same one as used before. Commonly use GenericDocument::GetAllocator().
-        \pre IsArray() == true
-        \return The value itself for fluent API.
-        \note If the number of elements to be appended is known, calls Reserve() once first may be more efficient.
-
-        \note The source type \c T explicitly disallows all pointer types,
-            especially (\c const) \ref Ch*.  This helps avoiding implicitly
-            referencing character strings with insufficient lifetime, use
-            \ref PushBack(GenericValue&, Allocator&) or \ref
-            PushBack(StringRefType, Allocator&).
-            All other pointer types would implicitly convert to \c bool,
-            use an explicit cast instead, if needed.
-        \note Amortized constant time complexity.
-    */
-    template <typename T>
-    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (GenericValue&))
-    PushBack(T value, Allocator& allocator) {
-        GenericValue v(value);
-        return PushBack(v, allocator);
-    }
-
-    //! Remove the last element in the array.
-    /*!
-        \note Constant time complexity.
-    */
-    GenericValue& PopBack() {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(!Empty());
-        data_.a.elements[--data_.a.size].~GenericValue();
-        return *this;
-    }
-
-    //! Remove an element of array by iterator.
-    /*!
-        \param pos iterator to the element to remove
-        \pre IsArray() == true && \ref Begin() <= \c pos < \ref End()
-        \return Iterator following the removed element. If the iterator pos refers to the last element, the End() iterator is returned.
-        \note Linear time complexity.
-    */
-    ValueIterator Erase(ConstValueIterator pos) {
-        return Erase(pos, pos + 1);
-    }
-
-    //! Remove elements in the range [first, last) of the array.
-    /*!
-        \param first iterator to the first element to remove
-        \param last  iterator following the last element to remove
-        \pre IsArray() == true && \ref Begin() <= \c first <= \c last <= \ref End()
-        \return Iterator following the last removed element.
-        \note Linear time complexity.
-    */
-    ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
-        RAPIDJSON_ASSERT(IsArray());
-        RAPIDJSON_ASSERT(data_.a.size > 0);
-        RAPIDJSON_ASSERT(data_.a.elements != 0);
-        RAPIDJSON_ASSERT(first >= Begin());
-        RAPIDJSON_ASSERT(first <= last);
-        RAPIDJSON_ASSERT(last <= End());
-        ValueIterator pos = Begin() + (first - Begin());
-        for (ValueIterator itr = pos; itr != last; ++itr)
-            itr->~GenericValue();       
-        std::memmove(pos, last, (End() - last) * sizeof(GenericValue));
-        data_.a.size -= (last - first);
-        return pos;
-    }
-
-    //@}
-
-    //!@name Number
-    //@{
-
-    int GetInt() const          { RAPIDJSON_ASSERT(flags_ & kIntFlag);   return data_.n.i.i;   }
-    unsigned GetUint() const    { RAPIDJSON_ASSERT(flags_ & kUintFlag);  return data_.n.u.u;   }
-    int64_t GetInt64() const    { RAPIDJSON_ASSERT(flags_ & kInt64Flag); return data_.n.i64; }
-    uint64_t GetUint64() const  { RAPIDJSON_ASSERT(flags_ & kUint64Flag); return data_.n.u64; }
-
-    double GetDouble() const {
-        RAPIDJSON_ASSERT(IsNumber());
-        if ((flags_ & kDoubleFlag) != 0)                return data_.n.d;   // exact type, no conversion.
-        if ((flags_ & kIntFlag) != 0)                   return data_.n.i.i; // int -> double
-        if ((flags_ & kUintFlag) != 0)                  return data_.n.u.u; // unsigned -> double
-        if ((flags_ & kInt64Flag) != 0)                 return (double)data_.n.i64; // int64_t -> double (may lose precision)
-        RAPIDJSON_ASSERT((flags_ & kUint64Flag) != 0);  return (double)data_.n.u64; // uint64_t -> double (may lose precision)
-    }
-
-    GenericValue& SetInt(int i)             { this->~GenericValue(); new (this) GenericValue(i);    return *this; }
-    GenericValue& SetUint(unsigned u)       { this->~GenericValue(); new (this) GenericValue(u);    return *this; }
-    GenericValue& SetInt64(int64_t i64)     { this->~GenericValue(); new (this) GenericValue(i64);  return *this; }
-    GenericValue& SetUint64(uint64_t u64)   { this->~GenericValue(); new (this) GenericValue(u64);  return *this; }
-    GenericValue& SetDouble(double d)       { this->~GenericValue(); new (this) GenericValue(d);    return *this; }
-
-    //@}
-
-    //!@name String
-    //@{
-
-    const Ch* GetString() const { RAPIDJSON_ASSERT(IsString()); return ((flags_ & kInlineStrFlag) ? data_.ss.str : data_.s.str); }
-
-    //! Get the length of string.
-    /*! Since rapidjson permits "\\u0000" in the json string, strlen(v.GetString()) may not equal to v.GetStringLength().
-    */
-    SizeType GetStringLength() const { RAPIDJSON_ASSERT(IsString()); return ((flags_ & kInlineStrFlag) ? (data_.ss.GetLength()) : data_.s.length); }
-
-    //! Set this value as a string without copying source string.
-    /*! This version has better performance with supplied length, and also support string containing null character.
-        \param s source string pointer. 
-        \param length The length of source string, excluding the trailing null terminator.
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() == s && GetStringLength() == length
-        \see SetString(StringRefType)
-    */
-    GenericValue& SetString(const Ch* s, SizeType length) { return SetString(StringRef(s, length)); }
-
-    //! Set this value as a string without copying source string.
-    /*! \param s source string reference
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() == s && GetStringLength() == s.length
-    */
-    GenericValue& SetString(StringRefType s) { this->~GenericValue(); SetStringRaw(s); return *this; }
-
-    //! Set this value as a string by copying from source string.
-    /*! This version has better performance with supplied length, and also support string containing null character.
-        \param s source string. 
-        \param length The length of source string, excluding the trailing null terminator.
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
-    */
-    GenericValue& SetString(const Ch* s, SizeType length, Allocator& allocator) { this->~GenericValue(); SetStringRaw(StringRef(s, length), allocator); return *this; }
-
-    //! Set this value as a string by copying from source string.
-    /*! \param s source string. 
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s && strcmp(GetString(),s) == 0 && GetStringLength() == length
-    */
-    GenericValue& SetString(const Ch* s, Allocator& allocator) { return SetString(s, internal::StrLen(s), allocator); }
-
-#if RAPIDJSON_HAS_STDSTRING
-    //! Set this value as a string by copying from source string.
-    /*! \param s source string.
-        \param allocator Allocator for allocating copied buffer. Commonly use GenericDocument::GetAllocator().
-        \return The value itself for fluent API.
-        \post IsString() == true && GetString() != s.data() && strcmp(GetString(),s.data() == 0 && GetStringLength() == s.size()
-        \note Requires the definition of the preprocessor symbol \ref RAPIDJSON_HAS_STDSTRING.
-    */
-    GenericValue& SetString(const std::basic_string<Ch>& s, Allocator& allocator) { return SetString(s.data(), s.size(), allocator); }
-#endif
-
-    //@}
-
-    //! Generate events of this value to a Handler.
-    /*! This function adopts the GoF visitor pattern.
-        Typical usage is to output this JSON value as JSON text via Writer, which is a Handler.
-        It can also be used to deep clone this value via GenericDocument, which is also a Handler.
-        \tparam Handler type of handler.
-        \param handler An object implementing concept Handler.
-    */
-    template <typename Handler>
-    bool Accept(Handler& handler) const {
-        switch(GetType()) {
-        case kNullType:     return handler.Null();
-        case kFalseType:    return handler.Bool(false);
-        case kTrueType:     return handler.Bool(true);
-
-        case kObjectType:
-            if (!handler.StartObject())
-                return false;
-            for (ConstMemberIterator m = MemberBegin(); m != MemberEnd(); ++m) {
-                RAPIDJSON_ASSERT(m->name.IsString()); // User may change the type of name by MemberIterator.
-                if (!handler.Key(m->name.GetString(), m->name.GetStringLength(), (m->name.flags_ & kCopyFlag) != 0))
-                    return false;
-                if (!m->value.Accept(handler))
-                    return false;
-            }
-            return handler.EndObject(data_.o.size);
-
-        case kArrayType:
-            if (!handler.StartArray())
-                return false;
-            for (GenericValue* v = data_.a.elements; v != data_.a.elements + data_.a.size; ++v)
-                if (!v->Accept(handler))
-                    return false;
-            return handler.EndArray(data_.a.size);
-    
-        case kStringType:
-            return handler.String(GetString(), GetStringLength(), (flags_ & kCopyFlag) != 0);
-    
-        case kNumberType:
-            if (IsInt())            return handler.Int(data_.n.i.i);
-            else if (IsUint())      return handler.Uint(data_.n.u.u);
-            else if (IsInt64())     return handler.Int64(data_.n.i64);
-            else if (IsUint64())    return handler.Uint64(data_.n.u64);
-            else                    return handler.Double(data_.n.d);
-    
-        default:
-            RAPIDJSON_ASSERT(false);
-        }
-        return false;
-    }
-
-private:
-    template <typename, typename> friend class GenericValue;
-    template <typename, typename, typename> friend class GenericDocument;
-
-    enum {
-        kBoolFlag = 0x100,
-        kNumberFlag = 0x200,
-        kIntFlag = 0x400,
-        kUintFlag = 0x800,
-        kInt64Flag = 0x1000,
-        kUint64Flag = 0x2000,
-        kDoubleFlag = 0x4000,
-        kStringFlag = 0x100000,
-        kCopyFlag = 0x200000,
-        kInlineStrFlag = 0x400000,
-
-        // Initial flags of different types.
-        kNullFlag = kNullType,
-        kTrueFlag = kTrueType | kBoolFlag,
-        kFalseFlag = kFalseType | kBoolFlag,
-        kNumberIntFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag,
-        kNumberUintFlag = kNumberType | kNumberFlag | kUintFlag | kUint64Flag | kInt64Flag,
-        kNumberInt64Flag = kNumberType | kNumberFlag | kInt64Flag,
-        kNumberUint64Flag = kNumberType | kNumberFlag | kUint64Flag,
-        kNumberDoubleFlag = kNumberType | kNumberFlag | kDoubleFlag,
-        kNumberAnyFlag = kNumberType | kNumberFlag | kIntFlag | kInt64Flag | kUintFlag | kUint64Flag | kDoubleFlag,
-        kConstStringFlag = kStringType | kStringFlag,
-        kCopyStringFlag = kStringType | kStringFlag | kCopyFlag,
-        kShortStringFlag = kStringType | kStringFlag | kCopyFlag | kInlineStrFlag,
-        kObjectFlag = kObjectType,
-        kArrayFlag = kArrayType,
-
-        kTypeMask = 0xFF    // bitwise-and with mask of 0xFF can be optimized by compiler
-    };
-
-    static const SizeType kDefaultArrayCapacity = 16;
-    static const SizeType kDefaultObjectCapacity = 16;
-
-    struct String {
-        const Ch* str;
-        SizeType length;
-        unsigned hashcode;  //!< reserved
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    // implementation detail: ShortString can represent zero-terminated strings up to MaxSize chars
-    // (excluding the terminating zero) and store a value to determine the length of the contained
-    // string in the last character str[LenPos] by storing "MaxSize - length" there. If the string
-    // to store has the maximal length of MaxSize then str[LenPos] will be 0 and therefore act as
-    // the string terminator as well. For getting the string length back from that value just use
-    // "MaxSize - str[LenPos]".
-    // This allows to store 11-chars strings in 32-bit mode and 15-chars strings in 64-bit mode
-    // inline (for `UTF8`-encoded strings).
-    struct ShortString {
-        enum { MaxChars = sizeof(String) / sizeof(Ch), MaxSize = MaxChars - 1, LenPos = MaxSize };
-        Ch str[MaxChars];
-
-        inline static bool Usable(SizeType len) { return            (MaxSize >= len); }
-        inline void     SetLength(SizeType len) { str[LenPos] = (Ch)(MaxSize -  len); }
-        inline SizeType GetLength() const       { return  (SizeType)(MaxSize -  str[LenPos]); }
-    };  // at most as many bytes as "String" above => 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    // By using proper binary layout, retrieval of different integer types do not need conversions.
-    union Number {
-#if RAPIDJSON_ENDIAN == RAPIDJSON_LITTLEENDIAN
-        struct I {
-            int i;
-            char padding[4];
-        }i;
-        struct U {
-            unsigned u;
-            char padding2[4];
-        }u;
-#else
-        struct I {
-            char padding[4];
-            int i;
-        }i;
-        struct U {
-            char padding2[4];
-            unsigned u;
-        }u;
-#endif
-        int64_t i64;
-        uint64_t u64;
-        double d;
-    };  // 8 bytes
-
-    struct Object {
-        Member* members;
-        SizeType size;
-        SizeType capacity;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    struct Array {
-        GenericValue* elements;
-        SizeType size;
-        SizeType capacity;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    union Data {
-        String s;
-        ShortString ss;
-        Number n;
-        Object o;
-        Array a;
-    };  // 12 bytes in 32-bit mode, 16 bytes in 64-bit mode
-
-    // Initialize this value as array with initial data, without calling destructor.
-    void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
-        flags_ = kArrayFlag;
-        data_.a.elements = (GenericValue*)allocator.Malloc(count * sizeof(GenericValue));
-        std::memcpy(data_.a.elements, values, count * sizeof(GenericValue));
-        data_.a.size = data_.a.capacity = count;
-    }
-
-    //! Initialize this value as object with initial data, without calling destructor.
-    void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
-        flags_ = kObjectFlag;
-        data_.o.members = (Member*)allocator.Malloc(count * sizeof(Member));
-        std::memcpy(data_.o.members, members, count * sizeof(Member));
-        data_.o.size = data_.o.capacity = count;
-    }
-
-    //! Initialize this value as constant string, without calling destructor.
-    void SetStringRaw(StringRefType s) RAPIDJSON_NOEXCEPT {
-        flags_ = kConstStringFlag;
-        data_.s.str = s;
-        data_.s.length = s.length;
-    }
-
-    //! Initialize this value as copy string with initial data, without calling destructor.
-    void SetStringRaw(StringRefType s, Allocator& allocator) {
-        Ch* str = NULL;
-        if(ShortString::Usable(s.length)) {
-            flags_ = kShortStringFlag;
-            data_.ss.SetLength(s.length);
-            str = data_.ss.str;
-        } else {
-            flags_ = kCopyStringFlag;
-            data_.s.length = s.length;
-            str = (Ch *)allocator.Malloc((s.length + 1) * sizeof(Ch));
-            data_.s.str = str;
-        }
-        std::memcpy(str, s, s.length * sizeof(Ch));
-        str[s.length] = '\0';
-    }
-
-    //! Assignment without calling destructor
-    void RawAssign(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
-        data_ = rhs.data_;
-        flags_ = rhs.flags_;
-        rhs.flags_ = kNullFlag;
-    }
-
-    template <typename SourceAllocator>
-    bool StringEqual(const GenericValue<Encoding, SourceAllocator>& rhs) const {
-        RAPIDJSON_ASSERT(IsString());
-        RAPIDJSON_ASSERT(rhs.IsString());
-
-        const SizeType len1 = GetStringLength();
-        const SizeType len2 = rhs.GetStringLength();
-        if(len1 != len2) { return false; }
-
-        const Ch* const str1 = GetString();
-        const Ch* const str2 = rhs.GetString();
-        if(str1 == str2) { return true; } // fast path for constant string
-
-        return (std::memcmp(str1, str2, sizeof(Ch) * len1) == 0);
-    }
-
-    Data data_;
-    unsigned flags_;
-};
-
-//! GenericValue with UTF8 encoding
-typedef GenericValue<UTF8<> > Value;
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericDocument 
-
-//! A document for parsing JSON text as DOM.
-/*!
-    \note implements Handler concept
-    \tparam Encoding Encoding for both parsing and string storage.
-    \tparam Allocator Allocator for allocating memory for the DOM
-    \tparam StackAllocator Allocator for allocating memory for stack during parsing.
-    \warning Although GenericDocument inherits from GenericValue, the API does \b not provide any virtual functions, especially no virtual destructor.  To avoid memory leaks, do not \c delete a GenericDocument object via a pointer to a GenericValue.
-*/
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<>, typename StackAllocator = CrtAllocator>
-class GenericDocument : public GenericValue<Encoding, Allocator> {
-public:
-    typedef typename Encoding::Ch Ch;                       //!< Character type derived from Encoding.
-    typedef GenericValue<Encoding, Allocator> ValueType;    //!< Value type of the document.
-    typedef Allocator AllocatorType;                        //!< Allocator type from template parameter.
-
-    //! Constructor
-    /*! \param allocator        Optional allocator for allocating memory.
-        \param stackCapacity    Optional initial capacity of stack in bytes.
-        \param stackAllocator   Optional allocator for allocating memory for stack.
-    */
-    GenericDocument(Allocator* allocator = 0, size_t stackCapacity = kDefaultStackCapacity, StackAllocator* stackAllocator = 0) : 
-        allocator_(allocator), ownAllocator_(0), stack_(stackAllocator, stackCapacity), parseResult_()
-    {
-        if (!allocator_)
-            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move constructor in C++11
-    GenericDocument(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
-        : ValueType(std::move(rhs)),
-          allocator_(rhs.allocator_),
-          ownAllocator_(rhs.ownAllocator_),
-          stack_(std::move(rhs.stack_)),
-          parseResult_(rhs.parseResult_)
-    {
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.parseResult_ = ParseResult();
-    }
-#endif
-
-    ~GenericDocument() {
-        Destroy();
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    //! Move assignment in C++11
-    GenericDocument& operator=(GenericDocument&& rhs) RAPIDJSON_NOEXCEPT
-    {
-        // The cast to ValueType is necessary here, because otherwise it would
-        // attempt to call GenericValue's templated assignment operator.
-        ValueType::operator=(std::forward<ValueType>(rhs));
-
-        // Calling the destructor here would prematurely call stack_'s destructor
-        Destroy();
-
-        allocator_ = rhs.allocator_;
-        ownAllocator_ = rhs.ownAllocator_;
-        stack_ = std::move(rhs.stack_);
-        parseResult_ = rhs.parseResult_;
-
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.parseResult_ = ParseResult();
-
-        return *this;
-    }
-#endif
-
-    //!@name Parse from stream
-    //!@{
-
-    //! Parse JSON text from an input stream (with Encoding conversion)
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam SourceEncoding Encoding of input stream
-        \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags, typename SourceEncoding, typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        ValueType::SetNull(); // Remove existing root if exist
-        GenericReader<SourceEncoding, Encoding, Allocator> reader(&GetAllocator());
-        ClearStackOnExit scope(*this);
-        parseResult_ = reader.template Parse<parseFlags>(is, *this);
-        if (parseResult_) {
-            RAPIDJSON_ASSERT(stack_.GetSize() == sizeof(ValueType)); // Got one and only one root object
-            this->RawAssign(*stack_.template Pop<ValueType>(1));    // Add this-> to prevent issue 13.
-        }
-        return *this;
-    }
-
-    //! Parse JSON text from an input stream
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags, typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        return ParseStream<parseFlags,Encoding,InputStream>(is);
-    }
-
-    //! Parse JSON text from an input stream (with \ref kParseDefaultFlags)
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \param is Input stream to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <typename InputStream>
-    GenericDocument& ParseStream(InputStream& is) {
-        return ParseStream<kParseDefaultFlags, Encoding, InputStream>(is);
-    }
-    //!@}
-
-    //!@name Parse in-place from mutable string
-    //!@{
-
-    //! Parse JSON text from a mutable string (with Encoding conversion)
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam SourceEncoding Transcoding from input Encoding
-        \param str Mutable zero-terminated string to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags, typename SourceEncoding>
-    GenericDocument& ParseInsitu(Ch* str) {
-        GenericInsituStringStream<Encoding> s(str);
-        return ParseStream<parseFlags | kParseInsituFlag, SourceEncoding>(s);
-    }
-
-    //! Parse JSON text from a mutable string
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \param str Mutable zero-terminated string to be parsed.
-        \return The document itself for fluent API.
-    */
-    template <unsigned parseFlags>
-    GenericDocument& ParseInsitu(Ch* str) {
-        return ParseInsitu<parseFlags, Encoding>(str);
-    }
-
-    //! Parse JSON text from a mutable string (with \ref kParseDefaultFlags)
-    /*! \param str Mutable zero-terminated string to be parsed.
-        \return The document itself for fluent API.
-    */
-    GenericDocument& ParseInsitu(Ch* str) {
-        return ParseInsitu<kParseDefaultFlags, Encoding>(str);
-    }
-    //!@}
-
-    //!@name Parse from read-only string
-    //!@{
-
-    //! Parse JSON text from a read-only string (with Encoding conversion)
-    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
-        \tparam SourceEncoding Transcoding from input Encoding
-        \param str Read-only zero-terminated string to be parsed.
-    */
-    template <unsigned parseFlags, typename SourceEncoding>
-    GenericDocument& Parse(const Ch* str) {
-        RAPIDJSON_ASSERT(!(parseFlags & kParseInsituFlag));
-        GenericStringStream<SourceEncoding> s(str);
-        return ParseStream<parseFlags, SourceEncoding>(s);
-    }
-
-    //! Parse JSON text from a read-only string
-    /*! \tparam parseFlags Combination of \ref ParseFlag (must not contain \ref kParseInsituFlag).
-        \param str Read-only zero-terminated string to be parsed.
-    */
-    template <unsigned parseFlags>
-    GenericDocument& Parse(const Ch* str) {
-        return Parse<parseFlags, Encoding>(str);
-    }
-
-    //! Parse JSON text from a read-only string (with \ref kParseDefaultFlags)
-    /*! \param str Read-only zero-terminated string to be parsed.
-    */
-    GenericDocument& Parse(const Ch* str) {
-        return Parse<kParseDefaultFlags>(str);
-    }
-    //!@}
-
-    //!@name Handling parse errors
-    //!@{
-
-    //! Whether a parse error has occured in the last parsing.
-    bool HasParseError() const { return parseResult_.IsError(); }
-
-    //! Get the \ref ParseErrorCode of last parsing.
-    ParseErrorCode GetParseError() const { return parseResult_.Code(); }
-
-    //! Get the position of last parsing error in input, 0 otherwise.
-    size_t GetErrorOffset() const { return parseResult_.Offset(); }
-
-    //!@}
-
-    //! Get the allocator of this document.
-    Allocator& GetAllocator() { return *allocator_; }
-
-    //! Get the capacity of stack in bytes.
-    size_t GetStackCapacity() const { return stack_.GetCapacity(); }
-
-private:
-    // clear stack on any exit from ParseStream, e.g. due to exception
-    struct ClearStackOnExit {
-        explicit ClearStackOnExit(GenericDocument& d) : d_(d) {}
-        ~ClearStackOnExit() { d_.ClearStack(); }
-    private:
-        ClearStackOnExit(const ClearStackOnExit&);
-        ClearStackOnExit& operator=(const ClearStackOnExit&);
-        GenericDocument& d_;
-    };
-
-    // callers of the following private Handler functions
-    template <typename,typename,typename> friend class GenericReader; // for parsing
-    template <typename, typename> friend class GenericValue; // for deep copying
-
-    // Implementation of Handler
-    bool Null() { new (stack_.template Push<ValueType>()) ValueType(); return true; }
-    bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b); return true; }
-    bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueType(i); return true; }
-    bool Double(double d) { new (stack_.template Push<ValueType>()) ValueType(d); return true; }
-
-    bool String(const Ch* str, SizeType length, bool copy) { 
-        if (copy) 
-            new (stack_.template Push<ValueType>()) ValueType(str, length, GetAllocator());
-        else
-            new (stack_.template Push<ValueType>()) ValueType(str, length);
-        return true;
-    }
-
-    bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(kObjectType); return true; }
-    
-    bool Key(const Ch* str, SizeType length, bool copy) { return String(str, length, copy); }
-
-    bool EndObject(SizeType memberCount) {
-        typename ValueType::Member* members = stack_.template Pop<typename ValueType::Member>(memberCount);
-        stack_.template Top<ValueType>()->SetObjectRaw(members, (SizeType)memberCount, GetAllocator());
-        return true;
-    }
-
-    bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kArrayType); return true; }
-    
-    bool EndArray(SizeType elementCount) {
-        ValueType* elements = stack_.template Pop<ValueType>(elementCount);
-        stack_.template Top<ValueType>()->SetArrayRaw(elements, elementCount, GetAllocator());
-        return true;
-    }
-
-private:
-    //! Prohibit copying
-    GenericDocument(const GenericDocument&);
-    //! Prohibit assignment
-    GenericDocument& operator=(const GenericDocument&);
-
-    void ClearStack() {
-        if (Allocator::kNeedFree)
-            while (stack_.GetSize() > 0)    // Here assumes all elements in stack array are GenericValue (Member is actually 2 GenericValue objects)
-                (stack_.template Pop<ValueType>(1))->~ValueType();
-        else
-            stack_.Clear();
-        stack_.ShrinkToFit();
-    }
-
-    void Destroy() {
-        RAPIDJSON_DELETE(ownAllocator_);
-    }
-
-    static const size_t kDefaultStackCapacity = 1024;
-    Allocator* allocator_;
-    Allocator* ownAllocator_;
-    internal::Stack<StackAllocator> stack_;
-    ParseResult parseResult_;
-};
-
-//! GenericDocument with UTF8 encoding
-typedef GenericDocument<UTF8<> > Document;
-
-// defined here due to the dependency on GenericDocument
-template <typename Encoding, typename Allocator>
-template <typename SourceAllocator>
-inline
-GenericValue<Encoding,Allocator>::GenericValue(const GenericValue<Encoding,SourceAllocator>& rhs, Allocator& allocator)
-{
-    switch (rhs.GetType()) {
-    case kObjectType:
-    case kArrayType: { // perform deep copy via SAX Handler
-            GenericDocument<Encoding,Allocator> d(&allocator);
-            rhs.Accept(d);
-            RawAssign(*d.stack_.template Pop<GenericValue>(1));
-        }
-        break;
-    case kStringType:
-        if (rhs.flags_ == kConstStringFlag) {
-            flags_ = rhs.flags_;
-            data_  = *reinterpret_cast<const Data*>(&rhs.data_);
-        } else {
-            SetStringRaw(StringRef(rhs.GetString(), rhs.GetStringLength()), allocator);
-        }
-        break;
-    default: // kNumberType, kTrueType, kFalseType, kNullType
-        flags_ = rhs.flags_;
-        data_  = *reinterpret_cast<const Data*>(&rhs.data_);
-    }
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(_MSC_VER) || defined(__GNUC__)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_DOCUMENT_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodedstream.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodedstream.h
deleted file mode 100644
index c310d2e..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodedstream.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ENCODEDSTREAM_H_
-#define RAPIDJSON_ENCODEDSTREAM_H_
-
-#include "rapidjson.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Input byte stream wrapper with a statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam InputByteStream Type of input byte stream. For example, FileReadStream.
-*/
-template <typename Encoding, typename InputByteStream>
-class EncodedInputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedInputStream(InputByteStream& is) : is_(is) { 
-        current_ = Encoding::TakeBOM(is_);
-    }
-
-    Ch Peek() const { return current_; }
-    Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
-    size_t Tell() const { return is_.Tell(); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    EncodedInputStream(const EncodedInputStream&);
-    EncodedInputStream& operator=(const EncodedInputStream&);
-
-    InputByteStream& is_;
-    Ch current_;
-};
-
-//! Output byte stream wrapper with statically bound encoding.
-/*!
-    \tparam Encoding The interpretation of encoding of the stream. Either UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE.
-    \tparam InputByteStream Type of input byte stream. For example, FileWriteStream.
-*/
-template <typename Encoding, typename OutputByteStream>
-class EncodedOutputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-public:
-    typedef typename Encoding::Ch Ch;
-
-    EncodedOutputStream(OutputByteStream& os, bool putBOM = true) : os_(os) { 
-        if (putBOM)
-            Encoding::PutBOM(os_);
-    }
-
-    void Put(Ch c) { Encoding::Put(os_, c);  }
-    void Flush() { os_.Flush(); }
-
-    // Not implemented
-    Ch Peek() const { RAPIDJSON_ASSERT(false); }
-    Ch Take() { RAPIDJSON_ASSERT(false);  }
-    size_t Tell() const { RAPIDJSON_ASSERT(false);  return 0; }
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    EncodedOutputStream(const EncodedOutputStream&);
-    EncodedOutputStream& operator=(const EncodedOutputStream&);
-
-    OutputByteStream& os_;
-};
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-//! Input stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for reading.
-    \tparam InputByteStream type of input byte stream to be wrapped.
-*/
-template <typename CharType, typename InputByteStream>
-class AutoUTFInputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param is input stream to be wrapped.
-        \param type UTF encoding type if it is not detected from the stream.
-    */
-    AutoUTFInputStream(InputByteStream& is, UTFType type = kUTF8) : is_(&is), type_(type), hasBOM_(false) {
-        DetectType();
-        static const TakeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Take) };
-        takeFunc_ = f[type_];
-        current_ = takeFunc_(*is_);
-    }
-
-    UTFType GetType() const { return type_; }
-    bool HasBOM() const { return hasBOM_; }
-
-    Ch Peek() const { return current_; }
-    Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
-    size_t Tell() const { return is_->Tell(); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    AutoUTFInputStream(const AutoUTFInputStream&);
-    AutoUTFInputStream& operator=(const AutoUTFInputStream&);
-
-    // Detect encoding type with BOM or RFC 4627
-    void DetectType() {
-        // BOM (Byte Order Mark):
-        // 00 00 FE FF  UTF-32BE
-        // FF FE 00 00  UTF-32LE
-        // FE FF        UTF-16BE
-        // FF FE        UTF-16LE
-        // EF BB BF     UTF-8
-
-        const unsigned char* c = (const unsigned char *)is_->Peek4();
-        if (!c)
-            return;
-
-        unsigned bom = c[0] | (c[1] << 8) | (c[2] << 16) | (c[3] << 24);
-        hasBOM_ = false;
-        if (bom == 0xFFFE0000)                  { type_ = kUTF32BE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
-        else if (bom == 0x0000FEFF)             { type_ = kUTF32LE; hasBOM_ = true; is_->Take(); is_->Take(); is_->Take(); is_->Take(); }
-        else if ((bom & 0xFFFF) == 0xFFFE)      { type_ = kUTF16BE; hasBOM_ = true; is_->Take(); is_->Take();                           }
-        else if ((bom & 0xFFFF) == 0xFEFF)      { type_ = kUTF16LE; hasBOM_ = true; is_->Take(); is_->Take();                           }
-        else if ((bom & 0xFFFFFF) == 0xBFBBEF)  { type_ = kUTF8;    hasBOM_ = true; is_->Take(); is_->Take(); is_->Take();              }
-
-        // RFC 4627: Section 3
-        // "Since the first two characters of a JSON text will always be ASCII
-        // characters [RFC0020], it is possible to determine whether an octet
-        // stream is UTF-8, UTF-16 (BE or LE), or UTF-32 (BE or LE) by looking
-        // at the pattern of nulls in the first four octets."
-        // 00 00 00 xx  UTF-32BE
-        // 00 xx 00 xx  UTF-16BE
-        // xx 00 00 00  UTF-32LE
-        // xx 00 xx 00  UTF-16LE
-        // xx xx xx xx  UTF-8
-
-        if (!hasBOM_) {
-            unsigned pattern = (c[0] ? 1 : 0) | (c[1] ? 2 : 0) | (c[2] ? 4 : 0) | (c[3] ? 8 : 0);
-            switch (pattern) {
-            case 0x08: type_ = kUTF32BE; break;
-            case 0x0A: type_ = kUTF16BE; break;
-            case 0x01: type_ = kUTF32LE; break;
-            case 0x05: type_ = kUTF16LE; break;
-            case 0x0F: type_ = kUTF8;    break;
-            default: break; // Use type defined by user.
-            }
-        }
-
-        // Runtime check whether the size of character type is sufficient. It only perform checks with assertion.
-        switch (type_) {
-        case kUTF8:
-            // Do nothing
-            break;
-        case kUTF16LE:
-        case kUTF16BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-            break;
-        case kUTF32LE:
-        case kUTF32BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-            break;
-        default:
-            RAPIDJSON_ASSERT(false);    // Invalid type
-        }
-    }
-
-    typedef Ch (*TakeFunc)(InputByteStream& is);
-    InputByteStream* is_;
-    UTFType type_;
-    Ch current_;
-    TakeFunc takeFunc_;
-    bool hasBOM_;
-};
-
-//! Output stream wrapper with dynamically bound encoding and automatic encoding detection.
-/*!
-    \tparam CharType Type of character for writing.
-    \tparam InputByteStream type of output byte stream to be wrapped.
-*/
-template <typename CharType, typename OutputByteStream>
-class AutoUTFOutputStream {
-    RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-public:
-    typedef CharType Ch;
-
-    //! Constructor.
-    /*!
-        \param os output stream to be wrapped.
-        \param type UTF encoding type.
-        \param putBOM Whether to write BOM at the beginning of the stream.
-    */
-    AutoUTFOutputStream(OutputByteStream& os, UTFType type, bool putBOM) : os_(&os), type_(type) {
-        // RUntime check whether the size of character type is sufficient. It only perform checks with assertion.
-        switch (type_) {
-        case kUTF16LE:
-        case kUTF16BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 2);
-            break;
-        case kUTF32LE:
-        case kUTF32BE:
-            RAPIDJSON_ASSERT(sizeof(Ch) >= 4);
-            break;
-        case kUTF8:
-            // Do nothing
-            break;
-        default:
-            RAPIDJSON_ASSERT(false);    // Invalid UTFType
-        }
-
-        static const PutFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Put) };
-        putFunc_ = f[type_];
-
-        if (putBOM)
-            PutBOM();
-    }
-
-    UTFType GetType() const { return type_; }
-
-    void Put(Ch c) { putFunc_(*os_, c); }
-    void Flush() { os_->Flush(); } 
-
-    // Not implemented
-    Ch Peek() const { RAPIDJSON_ASSERT(false); }
-    Ch Take() { RAPIDJSON_ASSERT(false); }
-    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    AutoUTFOutputStream(const AutoUTFOutputStream&);
-    AutoUTFOutputStream& operator=(const AutoUTFOutputStream&);
-
-    void PutBOM() { 
-        typedef void (*PutBOMFunc)(OutputByteStream&);
-        static const PutBOMFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(PutBOM) };
-        f[type_](*os_);
-    }
-
-    typedef void (*PutFunc)(OutputByteStream&, Ch);
-
-    OutputByteStream* os_;
-    UTFType type_;
-    PutFunc putFunc_;
-};
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodings.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodings.h
deleted file mode 100644
index 6bc8aec..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/encodings.h
+++ /dev/null
@@ -1,630 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ENCODINGS_H_
-#define RAPIDJSON_ENCODINGS_H_
-
-#include "rapidjson.h"
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4244) // conversion from 'type1' to 'type2', possible loss of data
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#elif defined(__GNUC__)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// Encoding
-
-/*! \class rapidjson::Encoding
-    \brief Concept for encoding of Unicode characters.
-
-\code
-concept Encoding {
-    typename Ch;    //! Type of character. A "character" is actually a code unit in unicode's definition.
-
-    enum { supportUnicode = 1 }; // or 0 if not supporting unicode
-
-    //! \brief Encode a Unicode codepoint to an output stream.
-    //! \param os Output stream.
-    //! \param codepoint An unicode codepoint, ranging from 0x0 to 0x10FFFF inclusively.
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint);
-
-    //! \brief Decode a Unicode codepoint from an input stream.
-    //! \param is Input stream.
-    //! \param codepoint Output of the unicode codepoint.
-    //! \return true if a valid codepoint can be decoded from the stream.
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint);
-
-    //! \brief Validate one Unicode codepoint from an encoded stream.
-    //! \param is Input stream to obtain codepoint.
-    //! \param os Output for copying one codepoint.
-    //! \return true if it is valid.
-    //! \note This function just validating and copying the codepoint without actually decode it.
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os);
-
-    // The following functions are deal with byte streams.
-
-    //! Take a character from input byte stream, skip BOM if exist.
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is);
-
-    //! Take a character from input byte stream.
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is);
-
-    //! Put BOM to output byte stream.
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os);
-
-    //! Put a character to output byte stream.
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c);
-};
-\endcode
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF8
-
-//! UTF-8 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-8
-    http://tools.ietf.org/html/rfc3629
-    \tparam CharType Code unit for storing 8-bit UTF-8 data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct UTF8 {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        if (codepoint <= 0x7F) 
-            os.Put(static_cast<Ch>(codepoint & 0xFF));
-        else if (codepoint <= 0x7FF) {
-            os.Put(static_cast<Ch>(0xC0 | ((codepoint >> 6) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint & 0x3F))));
-        }
-        else if (codepoint <= 0xFFFF) {
-            os.Put(static_cast<Ch>(0xE0 | ((codepoint >> 12) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            os.Put(static_cast<Ch>(0xF0 | ((codepoint >> 18) & 0xFF)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 12) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | ((codepoint >> 6) & 0x3F)));
-            os.Put(static_cast<Ch>(0x80 | (codepoint & 0x3F)));
-        }
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-#define COPY() c = is.Take(); *codepoint = (*codepoint << 6) | ((unsigned char)c & 0x3Fu)
-#define TRANS(mask) result &= ((GetRange((unsigned char)c) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
-        Ch c = is.Take();
-        if (!(c & 0x80)) {
-            *codepoint = (unsigned char)c;
-            return true;
-        }
-
-        unsigned char type = GetRange((unsigned char)c);
-        *codepoint = (0xFF >> type) & (unsigned char)c;
-        bool result = true;
-        switch (type) {
-        case 2: TAIL(); return result;
-        case 3: TAIL(); TAIL(); return result;
-        case 4: COPY(); TRANS(0x50); TAIL(); return result;
-        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
-        case 6: TAIL(); TAIL(); TAIL(); return result;
-        case 10: COPY(); TRANS(0x20); TAIL(); return result;
-        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
-        default: return false;
-        }
-#undef COPY
-#undef TRANS
-#undef TAIL
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-#define COPY() os.Put(c = is.Take())
-#define TRANS(mask) result &= ((GetRange((unsigned char)c) & mask) != 0)
-#define TAIL() COPY(); TRANS(0x70)
-        Ch c;
-        COPY();
-        if (!(c & 0x80))
-            return true;
-
-        bool result = true;
-        switch (GetRange((unsigned char)c)) {
-        case 2: TAIL(); return result;
-        case 3: TAIL(); TAIL(); return result;
-        case 4: COPY(); TRANS(0x50); TAIL(); return result;
-        case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
-        case 6: TAIL(); TAIL(); TAIL(); return result;
-        case 10: COPY(); TRANS(0x20); TAIL(); return result;
-        case 11: COPY(); TRANS(0x60); TAIL(); TAIL(); return result;
-        default: return false;
-        }
-#undef COPY
-#undef TRANS
-#undef TAIL
-    }
-
-    static unsigned char GetRange(unsigned char c) {
-        // Referring to DFA of http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-        // With new mapping 1 -> 0x10, 7 -> 0x20, 9 -> 0x40, such that AND operation can test multiple types.
-        static const unsigned char type[] = {
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-            0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,
-            0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
-            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-            0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
-            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-            10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-        };
-        return type[c];
-    }
-
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        Ch c = Take(is);
-        if ((unsigned char)c != 0xEFu) return c;
-        c = is.Take();
-        if ((unsigned char)c != 0xBBu) return c;
-        c = is.Take();
-        if ((unsigned char)c != 0xBFu) return c;
-        c = is.Take();
-        return c;
-    }
-
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        return is.Take();
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(0xEFu); os.Put(0xBBu); os.Put(0xBFu);
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(c));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF16
-
-//! UTF-16 encoding.
-/*! http://en.wikipedia.org/wiki/UTF-16
-    http://tools.ietf.org/html/rfc2781
-    \tparam CharType Type for storing 16-bit UTF-16 data. Default is wchar_t. C++11 may use char16_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF16LE and UTF16BE, which handle endianness.
-*/
-template<typename CharType = wchar_t>
-struct UTF16 {
-    typedef CharType Ch;
-    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 2);
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-        if (codepoint <= 0xFFFF) {
-            RAPIDJSON_ASSERT(codepoint < 0xD800 || codepoint > 0xDFFF); // Code point itself cannot be surrogate pair 
-            os.Put(static_cast<typename OutputStream::Ch>(codepoint));
-        }
-        else {
-            RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-            unsigned v = codepoint - 0x10000;
-            os.Put(static_cast<typename OutputStream::Ch>((v >> 10) | 0xD800));
-            os.Put((v & 0x3FF) | 0xDC00);
-        }
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-        Ch c = is.Take();
-        if (c < 0xD800 || c > 0xDFFF) {
-            *codepoint = c;
-            return true;
-        }
-        else if (c <= 0xDBFF) {
-            *codepoint = (c & 0x3FF) << 10;
-            c = is.Take();
-            *codepoint |= (c & 0x3FF);
-            *codepoint += 0x10000;
-            return c >= 0xDC00 && c <= 0xDFFF;
-        }
-        return false;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 2);
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 2);
-        Ch c;
-        os.Put(c = is.Take());
-        if (c < 0xD800 || c > 0xDFFF)
-            return true;
-        else if (c <= 0xDBFF) {
-            os.Put(c = is.Take());
-            return c >= 0xDC00 && c <= 0xDFFF;
-        }
-        return false;
-    }
-};
-
-//! UTF-16 little endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16LE : UTF16<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return (unsigned short)c == 0xFEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = (unsigned char)is.Take();
-        c |= (unsigned char)is.Take() << 8;
-        return c;
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(0xFFu); os.Put(0xFEu);
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(c & 0xFFu);
-        os.Put((c >> 8) & 0xFFu);
-    }
-};
-
-//! UTF-16 big endian encoding.
-template<typename CharType = wchar_t>
-struct UTF16BE : UTF16<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return (unsigned short)c == 0xFEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = (unsigned char)is.Take() << 8;
-        c |= (unsigned char)is.Take();
-        return c;
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(0xFEu); os.Put(0xFFu);
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put((c >> 8) & 0xFFu);
-        os.Put(c & 0xFFu);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// UTF32
-
-//! UTF-32 encoding. 
-/*! http://en.wikipedia.org/wiki/UTF-32
-    \tparam CharType Type for storing 32-bit UTF-32 data. Default is unsigned. C++11 may use char32_t instead.
-    \note implements Encoding concept
-
-    \note For in-memory access, no need to concern endianness. The code units and code points are represented by CPU's endianness.
-    For streaming, use UTF32LE and UTF32BE, which handle endianness.
-*/
-template<typename CharType = unsigned>
-struct UTF32 {
-    typedef CharType Ch;
-    RAPIDJSON_STATIC_ASSERT(sizeof(Ch) >= 4);
-
-    enum { supportUnicode = 1 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputStream::Ch) >= 4);
-        RAPIDJSON_ASSERT(codepoint <= 0x10FFFF);
-        os.Put(codepoint);
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-        Ch c = is.Take();
-        *codepoint = c;
-        return c <= 0x10FFFF;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputStream::Ch) >= 4);
-        Ch c;
-        os.Put(c = is.Take());
-        return c <= 0x10FFFF;
-    }
-};
-
-//! UTF-32 little endian enocoding.
-template<typename CharType = unsigned>
-struct UTF32LE : UTF32<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return (unsigned)c == 0x0000FEFFu ? Take(is) : c;
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = (unsigned char)is.Take();
-        c |= (unsigned char)is.Take() << 8;
-        c |= (unsigned char)is.Take() << 16;
-        c |= (unsigned char)is.Take() << 24;
-        return c;
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(0xFFu); os.Put(0xFEu); os.Put(0x00u); os.Put(0x00u);
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(c & 0xFFu);
-        os.Put((c >> 8) & 0xFFu);
-        os.Put((c >> 16) & 0xFFu);
-        os.Put((c >> 24) & 0xFFu);
-    }
-};
-
-//! UTF-32 big endian encoding.
-template<typename CharType = unsigned>
-struct UTF32BE : UTF32<CharType> {
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = Take(is);
-        return (unsigned)c == 0x0000FEFFu ? Take(is) : c; 
-    }
-
-    template <typename InputByteStream>
-    static CharType Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        CharType c = (unsigned char)is.Take() << 24;
-        c |= (unsigned char)is.Take() << 16;
-        c |= (unsigned char)is.Take() << 8;
-        c |= (unsigned char)is.Take();
-        return c;
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(0x00u); os.Put(0x00u); os.Put(0xFEu); os.Put(0xFFu);
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, CharType c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put((c >> 24) & 0xFFu);
-        os.Put((c >> 16) & 0xFFu);
-        os.Put((c >> 8) & 0xFFu);
-        os.Put(c & 0xFFu);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// ASCII
-
-//! ASCII encoding.
-/*! http://en.wikipedia.org/wiki/ASCII
-    \tparam CharType Code unit for storing 7-bit ASCII data. Default is char.
-    \note implements Encoding concept
-*/
-template<typename CharType = char>
-struct ASCII {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 0 };
-
-    template<typename OutputStream>
-    static void Encode(OutputStream& os, unsigned codepoint) {
-        RAPIDJSON_ASSERT(codepoint <= 0x7F);
-        os.Put(static_cast<Ch>(codepoint & 0xFF));
-    }
-
-    template <typename InputStream>
-    static bool Decode(InputStream& is, unsigned* codepoint) {
-        unsigned char c = static_cast<unsigned char>(is.Take());
-        *codepoint = c;
-        return c <= 0X7F;
-    }
-
-    template <typename InputStream, typename OutputStream>
-    static bool Validate(InputStream& is, OutputStream& os) {
-        unsigned char c = is.Take();
-        os.Put(c);
-        return c <= 0x7F;
-    }
-
-    template <typename InputByteStream>
-    static CharType TakeBOM(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        Ch c = Take(is);
-        return c;
-    }
-
-    template <typename InputByteStream>
-    static Ch Take(InputByteStream& is) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename InputByteStream::Ch) == 1);
-        return is.Take();
-    }
-
-    template <typename OutputByteStream>
-    static void PutBOM(OutputByteStream& os) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        (void)os;
-    }
-
-    template <typename OutputByteStream>
-    static void Put(OutputByteStream& os, Ch c) {
-        RAPIDJSON_STATIC_ASSERT(sizeof(typename OutputByteStream::Ch) == 1);
-        os.Put(static_cast<typename OutputByteStream::Ch>(c));
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// AutoUTF
-
-//! Runtime-specified UTF encoding type of a stream.
-enum UTFType {
-    kUTF8 = 0,      //!< UTF-8.
-    kUTF16LE = 1,   //!< UTF-16 little endian.
-    kUTF16BE = 2,   //!< UTF-16 big endian.
-    kUTF32LE = 3,   //!< UTF-32 little endian.
-    kUTF32BE = 4    //!< UTF-32 big endian.
-};
-
-//! Dynamically select encoding according to stream's runtime-specified UTF encoding type.
-/*! \note This class can be used with AutoUTFInputtStream and AutoUTFOutputStream, which provides GetType().
-*/
-template<typename CharType>
-struct AutoUTF {
-    typedef CharType Ch;
-
-    enum { supportUnicode = 1 };
-
-#define RAPIDJSON_ENCODINGS_FUNC(x) UTF8<Ch>::x, UTF16LE<Ch>::x, UTF16BE<Ch>::x, UTF32LE<Ch>::x, UTF32BE<Ch>::x
-
-    template<typename OutputStream>
-    RAPIDJSON_FORCEINLINE static void Encode(OutputStream& os, unsigned codepoint) {
-        typedef void (*EncodeFunc)(OutputStream&, unsigned);
-        static const EncodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Encode) };
-        (*f[os.GetType()])(os, codepoint);
-    }
-
-    template <typename InputStream>
-    RAPIDJSON_FORCEINLINE static bool Decode(InputStream& is, unsigned* codepoint) {
-        typedef bool (*DecodeFunc)(InputStream&, unsigned*);
-        static const DecodeFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Decode) };
-        return (*f[is.GetType()])(is, codepoint);
-    }
-
-    template <typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
-        typedef bool (*ValidateFunc)(InputStream&, OutputStream&);
-        static const ValidateFunc f[] = { RAPIDJSON_ENCODINGS_FUNC(Validate) };
-        return (*f[is.GetType()])(is, os);
-    }
-
-#undef RAPIDJSON_ENCODINGS_FUNC
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Transcoder
-
-//! Encoding conversion.
-template<typename SourceEncoding, typename TargetEncoding>
-struct Transcoder {
-    //! Take one Unicode codepoint from source encoding, convert it to target encoding and put it to the output stream.
-    template<typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
-        unsigned codepoint;
-        if (!SourceEncoding::Decode(is, &codepoint))
-            return false;
-        TargetEncoding::Encode(os, codepoint);
-        return true;
-    }
-
-    //! Validate one Unicode codepoint from an encoded stream.
-    template<typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
-        return Transcode(is, os);   // Since source/target encoding is different, must transcode.
-    }
-};
-
-//! Specialization of Transcoder with same source and target encoding.
-template<typename Encoding>
-struct Transcoder<Encoding, Encoding> {
-    template<typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE static bool Transcode(InputStream& is, OutputStream& os) {
-        os.Put(is.Take());  // Just copy one code unit. This semantic is different from primary template class.
-        return true;
-    }
-    
-    template<typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE static bool Validate(InputStream& is, OutputStream& os) {
-        return Encoding::Validate(is, os);  // source/target encoding are the same
-    }
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#if defined(__GNUC__) || defined(_MSV_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_ENCODINGS_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/en.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/en.h
deleted file mode 100644
index 0171183..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/en.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ERROR_EN_H__
-#define RAPIDJSON_ERROR_EN_H__
-
-#include "error.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Maps error code of parsing into error message.
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \param parseErrorCode Error code obtained in parsing.
-    \return the error message.
-    \note User can make a copy of this function for localization.
-        Using switch-case is safer for future modification of error codes.
-*/
-inline const RAPIDJSON_ERROR_CHARTYPE* GetParseError_En(ParseErrorCode parseErrorCode) {
-    switch (parseErrorCode) {
-        case kParseErrorNone:                           return RAPIDJSON_ERROR_STRING("No error.");
-
-        case kParseErrorDocumentEmpty:                  return RAPIDJSON_ERROR_STRING("The document is empty.");
-        case kParseErrorDocumentRootNotSingular:        return RAPIDJSON_ERROR_STRING("The document root must not follow by other values.");
-    
-        case kParseErrorValueInvalid:                   return RAPIDJSON_ERROR_STRING("Invalid value.");
-    
-        case kParseErrorObjectMissName:                 return RAPIDJSON_ERROR_STRING("Missing a name for object member.");
-        case kParseErrorObjectMissColon:                return RAPIDJSON_ERROR_STRING("Missing a colon after a name of object member.");
-        case kParseErrorObjectMissCommaOrCurlyBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or '}' after an object member.");
-    
-        case kParseErrorArrayMissCommaOrSquareBracket:  return RAPIDJSON_ERROR_STRING("Missing a comma or ']' after an array element.");
-
-        case kParseErrorStringUnicodeEscapeInvalidHex:  return RAPIDJSON_ERROR_STRING("Incorrect hex digit after \\u escape in string.");
-        case kParseErrorStringUnicodeSurrogateInvalid:  return RAPIDJSON_ERROR_STRING("The surrogate pair in string is invalid.");
-        case kParseErrorStringEscapeInvalid:            return RAPIDJSON_ERROR_STRING("Invalid escape character in string.");
-        case kParseErrorStringMissQuotationMark:        return RAPIDJSON_ERROR_STRING("Missing a closing quotation mark in string.");
-        case kParseErrorStringInvalidEncoding:          return RAPIDJSON_ERROR_STRING("Invalid encoding in string.");
-
-        case kParseErrorNumberTooBig:                   return RAPIDJSON_ERROR_STRING("Number too big to be stored in double.");
-        case kParseErrorNumberMissFraction:             return RAPIDJSON_ERROR_STRING("Miss fraction part in number.");
-        case kParseErrorNumberMissExponent:             return RAPIDJSON_ERROR_STRING("Miss exponent in number.");
-
-        case kParseErrorTermination:                    return RAPIDJSON_ERROR_STRING("Terminate parsing due to Handler error.");
-        case kParseErrorUnspecificSyntaxError:          return RAPIDJSON_ERROR_STRING("Unspecific syntax error.");
-
-        default:
-            return RAPIDJSON_ERROR_STRING("Unknown error.");
-    }
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ERROR_EN_H__
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/error.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/error.h
deleted file mode 100644
index 729142a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/error/error.h
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ERROR_ERROR_H__
-#define RAPIDJSON_ERROR_ERROR_H__
-
-/*! \file error.h */
-
-/*! \defgroup RAPIDJSON_ERRORS RapidJSON error handling */
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_CHARTYPE
-
-//! Character type of error messages.
-/*! \ingroup RAPIDJSON_ERRORS
-    The default character type is \c char.
-    On Windows, user can define this macro as \c TCHAR for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_CHARTYPE
-#define RAPIDJSON_ERROR_CHARTYPE char
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ERROR_STRING
-
-//! Macro for converting string literial to \ref RAPIDJSON_ERROR_CHARTYPE[].
-/*! \ingroup RAPIDJSON_ERRORS
-    By default this conversion macro does nothing.
-    On Windows, user can define this macro as \c _T(x) for supporting both
-    unicode/non-unicode settings.
-*/
-#ifndef RAPIDJSON_ERROR_STRING
-#define RAPIDJSON_ERROR_STRING(x) x
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseErrorCode
-
-//! Error code of parsing.
-/*! \ingroup RAPIDJSON_ERRORS
-    \see GenericReader::Parse, GenericReader::GetParseErrorCode
-*/
-enum ParseErrorCode {
-    kParseErrorNone = 0,                        //!< No error.
-
-    kParseErrorDocumentEmpty,                   //!< The document is empty.
-    kParseErrorDocumentRootNotSingular,         //!< The document root must not follow by other values.
-
-    kParseErrorValueInvalid,                    //!< Invalid value.
-
-    kParseErrorObjectMissName,                  //!< Missing a name for object member.
-    kParseErrorObjectMissColon,                 //!< Missing a colon after a name of object member.
-    kParseErrorObjectMissCommaOrCurlyBracket,   //!< Missing a comma or '}' after an object member.
-
-    kParseErrorArrayMissCommaOrSquareBracket,   //!< Missing a comma or ']' after an array element.
-
-    kParseErrorStringUnicodeEscapeInvalidHex,   //!< Incorrect hex digit after \\u escape in string.
-    kParseErrorStringUnicodeSurrogateInvalid,   //!< The surrogate pair in string is invalid.
-    kParseErrorStringEscapeInvalid,             //!< Invalid escape character in string.
-    kParseErrorStringMissQuotationMark,         //!< Missing a closing quotation mark in string.
-    kParseErrorStringInvalidEncoding,           //!< Invalid encoding in string.
-
-    kParseErrorNumberTooBig,                    //!< Number too big to be stored in double.
-    kParseErrorNumberMissFraction,              //!< Miss fraction part in number.
-    kParseErrorNumberMissExponent,              //!< Miss exponent in number.
-
-    kParseErrorTermination,                     //!< Parsing was terminated.
-    kParseErrorUnspecificSyntaxError            //!< Unspecific syntax error.
-};
-
-//! Result of parsing (wraps ParseErrorCode)
-/*!
-    \ingroup RAPIDJSON_ERRORS
-    \code
-        Document doc;
-        ParseResult ok = doc.Parse("[42]");
-        if (!ok) {
-            fprintf(stderr, "JSON parse error: %s (%u)",
-                    GetParseError_En(ok.Code()), ok.Offset());
-            exit(EXIT_FAILURE);
-        }
-    \endcode
-    \see GenericReader::Parse, GenericDocument::Parse
-*/
-struct ParseResult {
-
-    //! Default constructor, no error.
-    ParseResult() : code_(kParseErrorNone), offset_(0) {}
-    //! Constructor to set an error.
-    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}
-
-    //! Get the error code.
-    ParseErrorCode Code() const { return code_; }
-    //! Get the error offset, if \ref IsError(), 0 otherwise.
-    size_t Offset() const { return offset_; }
-
-    //! Conversion to \c bool, returns \c true, iff !\ref IsError().
-    operator bool() const { return !IsError(); }
-    //! Whether the result is an error.
-    bool IsError() const { return code_ != kParseErrorNone; }
-
-    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
-    bool operator==(ParseErrorCode code) const { return code_ == code; }
-    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }
-
-    //! Reset error code.
-    void Clear() { Set(kParseErrorNone); }
-    //! Update error code and offset.
-    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }
-
-private:
-    ParseErrorCode code_;
-    size_t offset_;
-};
-
-//! Function pointer type of GetParseError().
-/*! \ingroup RAPIDJSON_ERRORS
-
-    This is the prototype for \c GetParseError_X(), where \c X is a locale.
-    User can dynamically change locale in runtime, e.g.:
-\code
-    GetParseErrorFunc GetParseError = GetParseError_En; // or whatever
-    const RAPIDJSON_ERROR_CHARTYPE* s = GetParseError(document.GetParseErrorCode());
-\endcode
-*/
-typedef const RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(ParseErrorCode);
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ERROR_ERROR_H__
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filereadstream.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filereadstream.h
deleted file mode 100644
index 4ff4ab9..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filereadstream.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_FILEREADSTREAM_H_
-#define RAPIDJSON_FILEREADSTREAM_H_
-
-#include "rapidjson.h"
-#include <cstdio>
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! File byte stream for input using fread().
-/*!
-    \note implements Stream concept
-*/
-class FileReadStream {
-public:
-    typedef char Ch;    //!< Character type (byte).
-
-    //! Constructor.
-    /*!
-        \param fp File pointer opened for read.
-        \param buffer user-supplied buffer.
-        \param bufferSize size of buffer in bytes. Must >=4 bytes.
-    */
-    FileReadStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferSize_(bufferSize), bufferLast_(0), current_(buffer_), readCount_(0), count_(0), eof_(false) { 
-        RAPIDJSON_ASSERT(fp_ != 0);
-        RAPIDJSON_ASSERT(bufferSize >= 4);
-        Read();
-    }
-
-    Ch Peek() const { return *current_; }
-    Ch Take() { Ch c = *current_; Read(); return c; }
-    size_t Tell() const { return count_ + static_cast<size_t>(current_ - buffer_); }
-
-    // Not implemented
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); } 
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    // For encoding detection only.
-    const Ch* Peek4() const {
-        return (current_ + 4 <= bufferLast_) ? current_ : 0;
-    }
-
-private:
-    void Read() {
-        if (current_ < bufferLast_)
-            ++current_;
-        else if (!eof_) {
-            count_ += readCount_;
-            readCount_ = fread(buffer_, 1, bufferSize_, fp_);
-            bufferLast_ = buffer_ + readCount_ - 1;
-            current_ = buffer_;
-
-            if (readCount_ < bufferSize_) {
-                buffer_[readCount_] = '\0';
-                ++bufferLast_;
-                eof_ = true;
-            }
-        }
-    }
-
-    std::FILE* fp_;
-    Ch *buffer_;
-    size_t bufferSize_;
-    Ch *bufferLast_;
-    Ch *current_;
-    size_t readCount_;
-    size_t count_;  //!< Number of characters read
-    bool eof_;
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filestream.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filestream.h
deleted file mode 100644
index a2e7172..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filestream.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_FILESTREAM_H_
-#define RAPIDJSON_FILESTREAM_H_
-
-#include "rapidjson.h"
-#include <cstdio>
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! (Deprecated) Wrapper of C file stream for input or output.
-/*!
-    This simple wrapper does not check the validity of the stream.
-    \note implements Stream concept
-    \note deprecated: This was only for basic testing in version 0.1, it is found that the performance is very low by using fgetc(). Use FileReadStream instead.
-*/
-class FileStream {
-public:
-    typedef char Ch;    //!< Character type. Only support char.
-
-    FileStream(std::FILE* fp) : fp_(fp), current_('\0'), count_(0) { Read(); }
-    char Peek() const { return current_; }
-    char Take() { char c = current_; Read(); return c; }
-    size_t Tell() const { return count_; }
-    void Put(char c) { fputc(c, fp_); }
-    void Flush() { fflush(fp_); }
-
-    // Not implemented
-    char* PutBegin() { return 0; }
-    size_t PutEnd(char*) { return 0; }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    FileStream(const FileStream&);
-    FileStream& operator=(const FileStream&);
-
-    void Read() {
-        RAPIDJSON_ASSERT(fp_ != 0);
-        int c = fgetc(fp_);
-        if (c != EOF) {
-            current_ = (char)c;
-            count_++;
-        }
-        else if (current_ != '\0')
-            current_ = '\0';
-    }
-
-    std::FILE* fp_;
-    char current_;
-    size_t count_;
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filewritestream.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filewritestream.h
deleted file mode 100644
index 2f4977d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/filewritestream.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_FILEWRITESTREAM_H_
-#define RAPIDJSON_FILEWRITESTREAM_H_
-
-#include "rapidjson.h"
-#include <cstdio>
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Wrapper of C file stream for input using fread().
-/*!
-    \note implements Stream concept
-*/
-class FileWriteStream {
-public:
-    typedef char Ch;    //!< Character type. Only support char.
-
-    FileWriteStream(std::FILE* fp, char* buffer, size_t bufferSize) : fp_(fp), buffer_(buffer), bufferEnd_(buffer + bufferSize), current_(buffer_) { 
-        RAPIDJSON_ASSERT(fp_ != 0);
-    }
-
-    void Put(char c) { 
-        if (current_ >= bufferEnd_)
-            Flush();
-
-        *current_++ = c;
-    }
-
-    void PutN(char c, size_t n) {
-        size_t avail = static_cast<size_t>(bufferEnd_ - current_);
-        while (n > avail) {
-            std::memset(current_, c, avail);
-            current_ += avail;
-            Flush();
-            n -= avail;
-            avail = static_cast<size_t>(bufferEnd_ - current_);
-        }
-
-        if (n > 0) {
-            std::memset(current_, c, n);
-            current_ += n;
-        }
-    }
-
-    void Flush() {
-        if (current_ != buffer_) {
-            fwrite(buffer_, 1, static_cast<size_t>(current_ - buffer_), fp_);
-            current_ = buffer_;
-        }
-    }
-
-    // Not implemented
-    char Peek() const { RAPIDJSON_ASSERT(false); return 0; }
-    char Take() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t Tell() const { RAPIDJSON_ASSERT(false); return 0; }
-    char* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    size_t PutEnd(char*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    FileWriteStream(const FileWriteStream&);
-    FileWriteStream& operator=(const FileWriteStream&);
-
-    std::FILE* fp_;
-    char *buffer_;
-    char *bufferEnd_;
-    char *current_;
-};
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(FileWriteStream& stream, char c, size_t n) {
-    stream.PutN(c, n);
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_FILESTREAM_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/biginteger.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/biginteger.h
deleted file mode 100755
index 3e97920..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/biginteger.h
+++ /dev/null
@@ -1,294 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_BIGINTEGER_H_
-#define RAPIDJSON_BIGINTEGER_H_
-
-#include "../rapidjson.h"
-
-#if defined(_MSC_VER) && defined(_M_AMD64)
-#include <intrin.h> // for _umul128
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-class BigInteger {
-public:
-    typedef uint64_t Type;
-
-    BigInteger(const BigInteger& rhs) : count_(rhs.count_) {
-        std::memcpy(digits_, rhs.digits_, count_ * sizeof(Type));
-    }
-
-    explicit BigInteger(uint64_t u) : count_(1) {
-        digits_[0] = u;
-    }
-
-    BigInteger(const char* decimals, size_t length) : count_(1) {
-        RAPIDJSON_ASSERT(length > 0);
-        digits_[0] = 0;
-        size_t i = 0;
-        const size_t kMaxDigitPerIteration = 19;  // 2^64 = 18446744073709551616 > 10^19
-        while (length >= kMaxDigitPerIteration) {
-            AppendDecimal64(decimals + i, decimals + i + kMaxDigitPerIteration);
-            length -= kMaxDigitPerIteration;
-            i += kMaxDigitPerIteration;
-        }
-
-        if (length > 0)
-            AppendDecimal64(decimals + i, decimals + i + length);
-    }
-
-    BigInteger& operator=(uint64_t u) {
-        digits_[0] = u;            
-        count_ = 1;
-        return *this;
-    }
-
-    BigInteger& operator+=(uint64_t u) {
-        Type backup = digits_[0];
-        digits_[0] += u;
-        for (size_t i = 0; i < count_ - 1; i++) {
-            if (digits_[i] >= backup)
-                return *this; // no carry
-            backup = digits_[i + 1];
-            digits_[i + 1] += 1;
-        }
-
-        // Last carry
-        if (digits_[count_ - 1] < backup)
-            PushBack(1);
-
-        return *this;
-    }
-
-    BigInteger& operator*=(uint64_t u) {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint64_t k = 0;
-        for (size_t i = 0; i < count_; i++) {
-            uint64_t hi;
-            digits_[i] = MulAdd64(digits_[i], u, k, &hi);
-            k = hi;
-        }
-        
-        if (k > 0)
-            PushBack(k);
-
-        return *this;
-    }
-
-    BigInteger& operator*=(uint32_t u) {
-        if (u == 0) return *this = 0;
-        if (u == 1) return *this;
-        if (*this == 1) return *this = u;
-
-        uint32_t k = 0;
-        for (size_t i = 0; i < count_; i++) {
-            const uint64_t c = digits_[i] >> 32;
-            const uint64_t d = digits_[i] & 0xFFFFFFFF;
-            const uint64_t uc = u * c;
-            const uint64_t ud = u * d;
-            const uint64_t p0 = ud + k;
-            const uint64_t p1 = uc + (p0 >> 32);
-            digits_[i] = (p0 & 0xFFFFFFFF) | (p1 << 32);
-            k = p1 >> 32;
-        }
-        
-        if (k > 0)
-            PushBack(k);
-
-        return *this;
-    }
-
-    BigInteger& operator<<=(size_t shift) {
-        if (IsZero() || shift == 0) return *this;
-
-        size_t offset = shift / kTypeBit;
-        size_t interShift = shift % kTypeBit;
-        RAPIDJSON_ASSERT(count_ + offset <= kCapacity);
-
-        if (interShift == 0) {
-            std::memmove(&digits_[count_ - 1 + offset], &digits_[count_ - 1], count_ * sizeof(Type));
-            count_ += offset;
-        }
-        else {
-            digits_[count_] = 0;
-            for (size_t i = count_; i > 0; i--)
-                digits_[i + offset] = (digits_[i] << interShift) | (digits_[i - 1] >> (kTypeBit - interShift));
-            digits_[offset] = digits_[0] << interShift;
-            count_ += offset;
-            if (digits_[count_])
-                count_++;
-        }
-
-        std::memset(digits_, 0, offset * sizeof(Type));
-
-        return *this;
-    }
-
-    bool operator==(const BigInteger& rhs) const {
-        return count_ == rhs.count_ && std::memcmp(digits_, rhs.digits_, count_ * sizeof(Type)) == 0;
-    }
-
-    bool operator==(const Type rhs) const {
-        return count_ == 1 && digits_[0] == rhs;
-    }
-
-    BigInteger& MultiplyPow5(unsigned exp) {
-        static const uint32_t kPow5[12] = {
-            5,
-            5 * 5,
-            5 * 5 * 5,
-            5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
-            5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
-        };
-        if (exp == 0) return *this;
-        for (; exp >= 27; exp -= 27) *this *= RAPIDJSON_UINT64_C2(0X6765C793, 0XFA10079D); // 5^27
-        for (; exp >= 13; exp -= 13) *this *= static_cast<uint32_t>(1220703125u); // 5^13
-        if (exp > 0)                 *this *= kPow5[exp - 1];
-        return *this;
-    }
-
-    // Compute absolute difference of this and rhs.
-    // Return false if this < rhs
-    bool Difference(const BigInteger& rhs, BigInteger* out) const {
-        int cmp = Compare(rhs);
-        if (cmp == 0) {
-            *out = BigInteger(0);
-            return false;
-        }
-        const BigInteger *a, *b;  // Makes a > b
-        bool ret;
-        if (cmp < 0) { a = &rhs; b = this; ret = true; }
-        else         { a = this; b = &rhs; ret = false; }
-
-        Type borrow = 0;
-        for (size_t i = 0; i < a->count_; i++) {
-            Type d = a->digits_[i] - borrow;
-            if (i < b->count_)
-                d -= b->digits_[i];
-            borrow = (d > a->digits_[i]) ? 1 : 0;
-            out->digits_[i] = d;
-            if (d != 0)
-                out->count_ = i + 1;
-        }
-
-        return ret;
-    }
-
-    int Compare(const BigInteger& rhs) const {
-        if (count_ != rhs.count_)
-            return count_ < rhs.count_ ? -1 : 1;
-
-        for (size_t i = count_; i-- > 0;)
-            if (digits_[i] != rhs.digits_[i])
-                return digits_[i] < rhs.digits_[i] ? -1 : 1;
-
-        return 0;
-    }
-
-    size_t GetCount() const { return count_; }
-    Type GetDigit(size_t index) const { RAPIDJSON_ASSERT(index < count_); return digits_[index]; }
-    bool IsZero() const { return count_ == 1 && digits_[0] == 0; }
-
-private:
-    void AppendDecimal64(const char* begin, const char* end) {
-        uint64_t u = ParseUint64(begin, end);
-        if (IsZero())
-            *this = u;
-        else {
-            unsigned exp = static_cast<unsigned>(end - begin);
-            (MultiplyPow5(exp) <<= exp) += u;   // *this = *this * 10^exp + u
-        }
-    }
-
-    void PushBack(Type digit) {
-        RAPIDJSON_ASSERT(count_ < kCapacity);
-        digits_[count_++] = digit;
-    }
-
-    static uint64_t ParseUint64(const char* begin, const char* end) {
-        uint64_t r = 0;
-        for (const char* p = begin; p != end; ++p) {
-            RAPIDJSON_ASSERT(*p >= '0' && *p <= '9');
-            r = r * 10 + (*p - '0');
-        }
-        return r;
-    }
-
-    // Assume a * b + k < 2^128
-    static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* outHigh) {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t low = _umul128(a, b, outHigh) + k;
-        if (low < k)
-            (*outHigh)++;
-        return low;
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p = static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b);
-        p += k;
-        *outHigh = p >> 64;
-        return static_cast<uint64_t>(p);
-#else
-        const uint64_t a0 = a & 0xFFFFFFFF, a1 = a >> 32, b0 = b & 0xFFFFFFFF, b1 = b >> 32;
-        uint64_t x0 = a0 * b0, x1 = a0 * b1, x2 = a1 * b0, x3 = a1 * b1;
-        x1 += (x0 >> 32); // can't give carry
-        x1 += x2;
-        if (x1 < x2)
-            x3 += (static_cast<uint64_t>(1) << 32);
-        uint64_t lo = (x1 << 32) + (x0 & 0xFFFFFFFF);
-        uint64_t hi = x3 + (x1 >> 32);
-
-        lo += k;
-        if (lo < k)
-            hi++;
-        *outHigh = hi;
-        return lo;
-#endif
-    }
-
-    static Type FullAdd(Type a, Type b, bool inCarry, bool* outCarry) {
-        Type c = a + b + (inCarry ? 1 : 0);
-        *outCarry = c < a;
-        return c;
-    }
-
-    static const size_t kBitCount = 3328;  // 64bit * 54 > 10^1000
-    static const size_t kCapacity = kBitCount / sizeof(Type);
-    static const size_t kTypeBit = sizeof(Type) * 8;
-
-    Type digits_[kCapacity];
-    size_t count_;
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_BIGINTEGER_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/diyfp.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/diyfp.h
deleted file mode 100644
index 174b9fa..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/diyfp.h
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DIYFP_H_
-#define RAPIDJSON_DIYFP_H_
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#if defined(_M_AMD64)
-#pragma intrinsic(_BitScanReverse64)
-#endif
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-struct DiyFp {
-    DiyFp() {}
-
-    DiyFp(uint64_t fp, int exp) : f(fp), e(exp) {}
-
-    explicit DiyFp(double d) {
-        union {
-            double d;
-            uint64_t u64;
-        } u = { d };
-
-        int biased_e = (u.u64 & kDpExponentMask) >> kDpSignificandSize;
-        uint64_t significand = (u.u64 & kDpSignificandMask);
-        if (biased_e != 0) {
-            f = significand + kDpHiddenBit;
-            e = biased_e - kDpExponentBias;
-        } 
-        else {
-            f = significand;
-            e = kDpMinExponent + 1;
-        }
-    }
-
-    DiyFp operator-(const DiyFp& rhs) const {
-        return DiyFp(f - rhs.f, e);
-    }
-
-    DiyFp operator*(const DiyFp& rhs) const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        uint64_t h;
-        uint64_t l = _umul128(f, rhs.f, &h);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
-        unsigned __int128 p = static_cast<unsigned __int128>(f) * static_cast<unsigned __int128>(rhs.f);
-        uint64_t h = p >> 64;
-        uint64_t l = static_cast<uint64_t>(p);
-        if (l & (uint64_t(1) << 63)) // rounding
-            h++;
-        return DiyFp(h, e + rhs.e + 64);
-#else
-        const uint64_t M32 = 0xFFFFFFFF;
-        const uint64_t a = f >> 32;
-        const uint64_t b = f & M32;
-        const uint64_t c = rhs.f >> 32;
-        const uint64_t d = rhs.f & M32;
-        const uint64_t ac = a * c;
-        const uint64_t bc = b * c;
-        const uint64_t ad = a * d;
-        const uint64_t bd = b * d;
-        uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
-        tmp += 1U << 31;  /// mult_round
-        return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
-#endif
-    }
-
-    DiyFp Normalize() const {
-#if defined(_MSC_VER) && defined(_M_AMD64)
-        unsigned long index;
-        _BitScanReverse64(&index, f);
-        return DiyFp(f << (63 - index), e - (63 - index));
-#elif defined(__GNUC__) && __GNUC__ >= 4
-        int s = __builtin_clzll(f);
-        return DiyFp(f << s, e - s);
-#else
-        DiyFp res = *this;
-        while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
-            res.f <<= 1;
-            res.e--;
-        }
-        return res;
-#endif
-    }
-
-    DiyFp NormalizeBoundary() const {
-        DiyFp res = *this;
-        while (!(res.f & (kDpHiddenBit << 1))) {
-            res.f <<= 1;
-            res.e--;
-        }
-        res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
-        res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
-        return res;
-    }
-
-    void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
-        DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
-        DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
-        mi.f <<= mi.e - pl.e;
-        mi.e = pl.e;
-        *plus = pl;
-        *minus = mi;
-    }
-
-    double ToDouble() const {
-        union {
-            double d;
-            uint64_t u64;
-        }u;
-        uint64_t significand = f;
-        int exponent = e;
-        while (significand > kDpHiddenBit + kDpSignificandMask) {
-            significand >>= 1;
-            exponent++;
-        }
-        while (exponent > kDpDenormalExponent && (significand & kDpHiddenBit) == 0) {
-            significand <<= 1;
-            exponent--;
-        }
-        if (exponent >= kDpMaxExponent) {
-            u.u64 = kDpExponentMask;    // Infinity
-            return u.d;
-        }
-        else if (exponent < kDpDenormalExponent)
-            return 0.0;
-        const uint64_t be = (exponent == kDpDenormalExponent && (significand & kDpHiddenBit) == 0) ? 0 : 
-            static_cast<uint64_t>(exponent + kDpExponentBias);
-        u.u64 = (significand & kDpSignificandMask) | (be << kDpSignificandSize);
-        return u.d;
-    }
-
-    static const int kDiySignificandSize = 64;
-    static const int kDpSignificandSize = 52;
-    static const int kDpExponentBias = 0x3FF + kDpSignificandSize;
-    static const int kDpMaxExponent = 0x7FF - kDpExponentBias;
-    static const int kDpMinExponent = -kDpExponentBias;
-    static const int kDpDenormalExponent = -kDpExponentBias + 1;
-    static const uint64_t kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    uint64_t f;
-    int e;
-};
-
-inline DiyFp GetCachedPowerByIndex(size_t index) {
-    // 10^-348, 10^-340, ..., 10^340
-    static const uint64_t kCachedPowers_F[] = {
-        RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
-        RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
-        RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
-        RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
-        RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
-        RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
-        RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
-        RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
-        RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
-        RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
-        RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
-        RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
-        RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
-        RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
-        RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
-        RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
-        RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
-        RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
-        RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
-        RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
-        RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
-        RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
-        RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
-        RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
-        RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
-        RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
-        RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
-        RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
-        RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
-        RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
-        RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
-        RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
-        RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
-        RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
-        RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
-        RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
-        RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
-        RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
-        RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
-        RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
-        RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
-        RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
-        RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
-        RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
-    };
-    static const int16_t kCachedPowers_E[] = {
-        -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,
-        -954,  -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,
-        -688,  -661,  -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,
-        -422,  -396,  -369,  -343,  -316,  -289,  -263,  -236,  -210,  -183,
-        -157,  -130,  -103,   -77,   -50,   -24,     3,    30,    56,    83,
-        109,   136,   162,   189,   216,   242,   269,   295,   322,   348,
-        375,   402,   428,   455,   481,   508,   534,   561,   588,   614,
-        641,   667,   694,   720,   747,   774,   800,   827,   853,   880,
-        907,   933,   960,   986,  1013,  1039,  1066
-    };
-    return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
-}
-    
-inline DiyFp GetCachedPower(int e, int* K) {
-
-    //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
-    double dk = (-61 - e) * 0.30102999566398114 + 347;  // dk must be positive, so can do ceiling in positive
-    int k = static_cast<int>(dk);
-    if (k != dk)
-        k++;
-
-    unsigned index = static_cast<unsigned>((k >> 3) + 1);
-    *K = -(-348 + static_cast<int>(index << 3));    // decimal exponent no need lookup table
-
-    return GetCachedPowerByIndex(index);
-}
-
-inline DiyFp GetCachedPower10(int exp, int *outExp) {
-     unsigned index = (exp + 348) / 8;
-     *outExp = -348 + index * 8;
-     return GetCachedPowerByIndex(index);
- }
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DIYFP_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/dtoa.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/dtoa.h
deleted file mode 100644
index c0fa2b8..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/dtoa.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-// This is a C++ header-only implementation of Grisu2 algorithm from the publication:
-// Loitsch, Florian. "Printing floating-point numbers quickly and accurately with
-// integers." ACM Sigplan Notices 45.6 (2010): 233-243.
-
-#ifndef RAPIDJSON_DTOA_
-#define RAPIDJSON_DTOA_
-
-#include "itoa.h" // GetDigitsLut()
-#include "diyfp.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-inline void GrisuRound(char* buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w) {
-    while (rest < wp_w && delta - rest >= ten_kappa &&
-           (rest + ten_kappa < wp_w ||  /// closer
-            wp_w - rest > rest + ten_kappa - wp_w)) {
-        buffer[len - 1]--;
-        rest += ten_kappa;
-    }
-}
-
-inline unsigned CountDecimalDigit32(uint32_t n) {
-    // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
-    if (n < 10) return 1;
-    if (n < 100) return 2;
-    if (n < 1000) return 3;
-    if (n < 10000) return 4;
-    if (n < 100000) return 5;
-    if (n < 1000000) return 6;
-    if (n < 10000000) return 7;
-    if (n < 100000000) return 8;
-    if (n < 1000000000) return 9;
-    return 10;
-}
-
-inline void DigitGen(const DiyFp& W, const DiyFp& Mp, uint64_t delta, char* buffer, int* len, int* K) {
-    static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
-    const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
-    const DiyFp wp_w = Mp - W;
-    uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
-    uint64_t p2 = Mp.f & (one.f - 1);
-    int kappa = CountDecimalDigit32(p1);
-    *len = 0;
-
-    while (kappa > 0) {
-        uint32_t d;
-        switch (kappa) {
-            case 10: d = p1 / 1000000000; p1 %= 1000000000; break;
-            case  9: d = p1 /  100000000; p1 %=  100000000; break;
-            case  8: d = p1 /   10000000; p1 %=   10000000; break;
-            case  7: d = p1 /    1000000; p1 %=    1000000; break;
-            case  6: d = p1 /     100000; p1 %=     100000; break;
-            case  5: d = p1 /      10000; p1 %=      10000; break;
-            case  4: d = p1 /       1000; p1 %=       1000; break;
-            case  3: d = p1 /        100; p1 %=        100; break;
-            case  2: d = p1 /         10; p1 %=         10; break;
-            case  1: d = p1;              p1 =           0; break;
-            default: 
-#if defined(_MSC_VER)
-                __assume(0);
-#elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
-                __builtin_unreachable();
-#else
-                d = 0;
-#endif
-        }
-        if (d || *len)
-            buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
-        kappa--;
-        uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
-        if (tmp <= delta) {
-            *K += kappa;
-            GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
-            return;
-        }
-    }
-
-    // kappa = 0
-    for (;;) {
-        p2 *= 10;
-        delta *= 10;
-        char d = static_cast<char>(p2 >> -one.e);
-        if (d || *len)
-            buffer[(*len)++] = static_cast<char>('0' + d);
-        p2 &= one.f - 1;
-        kappa--;
-        if (p2 < delta) {
-            *K += kappa;
-            GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
-            return;
-        }
-    }
-}
-
-inline void Grisu2(double value, char* buffer, int* length, int* K) {
-    const DiyFp v(value);
-    DiyFp w_m, w_p;
-    v.NormalizedBoundaries(&w_m, &w_p);
-
-    const DiyFp c_mk = GetCachedPower(w_p.e, K);
-    const DiyFp W = v.Normalize() * c_mk;
-    DiyFp Wp = w_p * c_mk;
-    DiyFp Wm = w_m * c_mk;
-    Wm.f++;
-    Wp.f--;
-    DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
-}
-
-inline char* WriteExponent(int K, char* buffer) {
-    if (K < 0) {
-        *buffer++ = '-';
-        K = -K;
-    }
-
-    if (K >= 100) {
-        *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
-        K %= 100;
-        const char* d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else if (K >= 10) {
-        const char* d = GetDigitsLut() + K * 2;
-        *buffer++ = d[0];
-        *buffer++ = d[1];
-    }
-    else
-        *buffer++ = static_cast<char>('0' + static_cast<char>(K));
-
-    return buffer;
-}
-
-inline char* Prettify(char* buffer, int length, int k) {
-    const int kk = length + k;  // 10^(kk-1) <= v < 10^kk
-
-    if (length <= kk && kk <= 21) {
-        // 1234e7 -> 12340000000
-        for (int i = length; i < kk; i++)
-            buffer[i] = '0';
-        buffer[kk] = '.';
-        buffer[kk + 1] = '0';
-        return &buffer[kk + 2];
-    }
-    else if (0 < kk && kk <= 21) {
-        // 1234e-2 -> 12.34
-        std::memmove(&buffer[kk + 1], &buffer[kk], length - kk);
-        buffer[kk] = '.';
-        return &buffer[length + 1];
-    }
-    else if (-6 < kk && kk <= 0) {
-        // 1234e-6 -> 0.001234
-        const int offset = 2 - kk;
-        std::memmove(&buffer[offset], &buffer[0], length);
-        buffer[0] = '0';
-        buffer[1] = '.';
-        for (int i = 2; i < offset; i++)
-            buffer[i] = '0';
-        return &buffer[length + offset];
-    }
-    else if (length == 1) {
-        // 1e30
-        buffer[1] = 'e';
-        return WriteExponent(kk - 1, &buffer[2]);
-    }
-    else {
-        // 1234e30 -> 1.234e33
-        std::memmove(&buffer[2], &buffer[1], length - 1);
-        buffer[1] = '.';
-        buffer[length + 1] = 'e';
-        return WriteExponent(kk - 1, &buffer[0 + length + 2]);
-    }
-}
-
-inline char* dtoa(double value, char* buffer) {
-    if (value == 0) {
-        buffer[0] = '0';
-        buffer[1] = '.';
-        buffer[2] = '0';
-        return &buffer[3];
-    }
-    else {
-        if (value < 0) {
-            *buffer++ = '-';
-            value = -value;
-        }
-        int length, K;
-        Grisu2(value, buffer, &length, &K);
-        return Prettify(buffer, length, K);
-    }
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_DTOA_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/ieee754.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/ieee754.h
deleted file mode 100644
index ab65cc9..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/ieee754.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_IEEE754_
-#define RAPIDJSON_IEEE754_
-
-#include "../rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-class Double {
-public:
-    Double() {}
-    Double(double d) : d(d) {}
-    Double(uint64_t u) : u(u) {}
-
-    double Value() const { return d; }
-    uint64_t Uint64Value() const { return u; }
-
-    double NextPositiveDouble() const {
-        RAPIDJSON_ASSERT(!Sign());
-        return Double(u + 1).Value();
-    }
-
-    double PreviousPositiveDouble() const {
-        RAPIDJSON_ASSERT(!Sign());
-        if (d == 0.0)
-            return 0.0;
-        else
-            return Double(u - 1).Value();
-    }
-
-    bool Sign() const { return (u & kSignMask) != 0; }
-    uint64_t Significand() const { return u & kSignificandMask; }
-    int Exponent() const { return ((u & kExponentMask) >> kSignificandSize) - kExponentBias; }
-
-    bool IsNan() const { return (u & kExponentMask) == kExponentMask && Significand() != 0; }
-    bool IsInf() const { return (u & kExponentMask) == kExponentMask && Significand() == 0; }
-    bool IsNormal() const { return (u & kExponentMask) != 0 || Significand() == 0; }
-
-    uint64_t IntegerSignificand() const { return IsNormal() ? Significand() | kHiddenBit : Significand(); }
-    int IntegerExponent() const { return (IsNormal() ? Exponent() : kDenormalExponent) - kSignificandSize; }
-    uint64_t ToBias() const { return (u & kSignMask) ? ~u + 1 : u | kSignMask; }
-
-    static unsigned EffectiveSignificandSize(int order) {
-        if (order >= -1021)
-            return 53;
-        else if (order <= -1074)
-            return 0;
-        else
-            return order + 1074;
-    }
-
-private:
-    static const int kSignificandSize = 52;
-    static const int kExponentBias = 0x3FF;
-    static const int kDenormalExponent = 1 - kExponentBias;
-    static const uint64_t kSignMask = RAPIDJSON_UINT64_C2(0x80000000, 0x00000000);
-    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    union {
-        double d;
-        uint64_t u;
-    };
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_IEEE754_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/itoa.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/itoa.h
deleted file mode 100644
index 3684f07..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/itoa.h
+++ /dev/null
@@ -1,306 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_ITOA_
-#define RAPIDJSON_ITOA_
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-inline const char* GetDigitsLut() {
-    static const char cDigitsLut[200] = {
-        '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
-        '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
-        '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
-        '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
-        '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
-        '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
-        '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
-        '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
-        '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
-        '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
-    };
-    return cDigitsLut;
-}
-
-inline char* u32toa(uint32_t value, char* buffer) {
-    const char* cDigitsLut = GetDigitsLut();
-
-    if (value < 10000) {
-        const uint32_t d1 = (value / 100) << 1;
-        const uint32_t d2 = (value % 100) << 1;
-        
-        if (value >= 1000)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= 100)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 10)
-            *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-    }
-    else if (value < 100000000) {
-        // value = bbbbcccc
-        const uint32_t b = value / 10000;
-        const uint32_t c = value % 10000;
-        
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-        
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-        
-        if (value >= 10000000)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= 1000000)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= 100000)
-            *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-    }
-    else {
-        // value = aabbbbcccc in decimal
-        
-        const uint32_t a = value / 100000000; // 1 to 42
-        value %= 100000000;
-        
-        if (a >= 10) {
-            const unsigned i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-
-        const uint32_t b = value / 10000; // 0 to 9999
-        const uint32_t c = value % 10000; // 0 to 9999
-        
-        const uint32_t d1 = (b / 100) << 1;
-        const uint32_t d2 = (b % 100) << 1;
-        
-        const uint32_t d3 = (c / 100) << 1;
-        const uint32_t d4 = (c % 100) << 1;
-        
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-    }
-    return buffer;
-}
-
-inline char* i32toa(int32_t value, char* buffer) {
-    if (value < 0) {
-        *buffer++ = '-';
-        value = -value;
-    }
-
-    return u32toa(static_cast<uint32_t>(value), buffer);
-}
-
-inline char* u64toa(uint64_t value, char* buffer) {
-    const char* cDigitsLut = GetDigitsLut();
-    const uint64_t  kTen8 = 100000000;
-    const uint64_t  kTen9 = kTen8 * 10;
-    const uint64_t kTen10 = kTen8 * 100;
-    const uint64_t kTen11 = kTen8 * 1000;
-    const uint64_t kTen12 = kTen8 * 10000;
-    const uint64_t kTen13 = kTen8 * 100000;
-    const uint64_t kTen14 = kTen8 * 1000000;
-    const uint64_t kTen15 = kTen8 * 10000000;
-    const uint64_t kTen16 = kTen8 * kTen8;
-    
-    if (value < kTen8) {
-        uint32_t v = static_cast<uint32_t>(value);
-        if (v < 10000) {
-            const uint32_t d1 = (v / 100) << 1;
-            const uint32_t d2 = (v % 100) << 1;
-            
-            if (v >= 1000)
-                *buffer++ = cDigitsLut[d1];
-            if (v >= 100)
-                *buffer++ = cDigitsLut[d1 + 1];
-            if (v >= 10)
-                *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-        }
-        else {
-            // value = bbbbcccc
-            const uint32_t b = v / 10000;
-            const uint32_t c = v % 10000;
-            
-            const uint32_t d1 = (b / 100) << 1;
-            const uint32_t d2 = (b % 100) << 1;
-            
-            const uint32_t d3 = (c / 100) << 1;
-            const uint32_t d4 = (c % 100) << 1;
-            
-            if (value >= 10000000)
-                *buffer++ = cDigitsLut[d1];
-            if (value >= 1000000)
-                *buffer++ = cDigitsLut[d1 + 1];
-            if (value >= 100000)
-                *buffer++ = cDigitsLut[d2];
-            *buffer++ = cDigitsLut[d2 + 1];
-            
-            *buffer++ = cDigitsLut[d3];
-            *buffer++ = cDigitsLut[d3 + 1];
-            *buffer++ = cDigitsLut[d4];
-            *buffer++ = cDigitsLut[d4 + 1];
-        }
-    }
-    else if (value < kTen16) {
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-        
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-        
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-        
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-        
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-        
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-
-        if (value >= kTen15)
-            *buffer++ = cDigitsLut[d1];
-        if (value >= kTen14)
-            *buffer++ = cDigitsLut[d1 + 1];
-        if (value >= kTen13)
-            *buffer++ = cDigitsLut[d2];
-        if (value >= kTen12)
-            *buffer++ = cDigitsLut[d2 + 1];
-        if (value >= kTen11)
-            *buffer++ = cDigitsLut[d3];
-        if (value >= kTen10)
-            *buffer++ = cDigitsLut[d3 + 1];
-        if (value >= kTen9)
-            *buffer++ = cDigitsLut[d4];
-        if (value >= kTen8)
-            *buffer++ = cDigitsLut[d4 + 1];
-        
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-    }
-    else {
-        const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
-        value %= kTen16;
-        
-        if (a < 10)
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a));
-        else if (a < 100) {
-            const uint32_t i = a << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else if (a < 1000) {
-            *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
-            
-            const uint32_t i = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-        }
-        else {
-            const uint32_t i = (a / 100) << 1;
-            const uint32_t j = (a % 100) << 1;
-            *buffer++ = cDigitsLut[i];
-            *buffer++ = cDigitsLut[i + 1];
-            *buffer++ = cDigitsLut[j];
-            *buffer++ = cDigitsLut[j + 1];
-        }
-        
-        const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
-        const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
-        
-        const uint32_t b0 = v0 / 10000;
-        const uint32_t c0 = v0 % 10000;
-        
-        const uint32_t d1 = (b0 / 100) << 1;
-        const uint32_t d2 = (b0 % 100) << 1;
-        
-        const uint32_t d3 = (c0 / 100) << 1;
-        const uint32_t d4 = (c0 % 100) << 1;
-        
-        const uint32_t b1 = v1 / 10000;
-        const uint32_t c1 = v1 % 10000;
-        
-        const uint32_t d5 = (b1 / 100) << 1;
-        const uint32_t d6 = (b1 % 100) << 1;
-        
-        const uint32_t d7 = (c1 / 100) << 1;
-        const uint32_t d8 = (c1 % 100) << 1;
-        
-        *buffer++ = cDigitsLut[d1];
-        *buffer++ = cDigitsLut[d1 + 1];
-        *buffer++ = cDigitsLut[d2];
-        *buffer++ = cDigitsLut[d2 + 1];
-        *buffer++ = cDigitsLut[d3];
-        *buffer++ = cDigitsLut[d3 + 1];
-        *buffer++ = cDigitsLut[d4];
-        *buffer++ = cDigitsLut[d4 + 1];
-        *buffer++ = cDigitsLut[d5];
-        *buffer++ = cDigitsLut[d5 + 1];
-        *buffer++ = cDigitsLut[d6];
-        *buffer++ = cDigitsLut[d6 + 1];
-        *buffer++ = cDigitsLut[d7];
-        *buffer++ = cDigitsLut[d7 + 1];
-        *buffer++ = cDigitsLut[d8];
-        *buffer++ = cDigitsLut[d8 + 1];
-    }
-    
-    return buffer;
-}
-
-inline char* i64toa(int64_t value, char* buffer) {
-    if (value < 0) {
-        *buffer++ = '-';
-        value = -value;
-    }
-
-    return u64toa(static_cast<uint64_t>(value), buffer);
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_ITOA_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/meta.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/meta.h
deleted file mode 100644
index 226465a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/meta.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_INTERNAL_META_H_
-#define RAPIDJSON_INTERNAL_META_H_
-
-#ifndef RAPIDJSON_RAPIDJSON_H_
-#error <rapidjson.h> not yet included. Do not include this file directly.
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-#if defined(_MSC_VER)
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(6334)
-#endif
-
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-#include <type_traits>
-#endif
-
-//@cond RAPIDJSON_INTERNAL
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-// Helper to wrap/convert arbitrary types to void, useful for arbitrary type matching
-template <typename T> struct Void { typedef void Type; };
-
-///////////////////////////////////////////////////////////////////////////////
-// BoolType, TrueType, FalseType
-//
-template <bool Cond> struct BoolType {
-    static const bool Value = Cond;
-    typedef BoolType Type;
-};
-typedef BoolType<true> TrueType;
-typedef BoolType<false> FalseType;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// SelectIf, BoolExpr, NotExpr, AndExpr, OrExpr
-//
-
-template <bool C> struct SelectIfImpl { template <typename T1, typename T2> struct Apply { typedef T1 Type; }; };
-template <> struct SelectIfImpl<false> { template <typename T1, typename T2> struct Apply { typedef T2 Type; }; };
-template <bool C, typename T1, typename T2> struct SelectIfCond : SelectIfImpl<C>::template Apply<T1,T2> {};
-template <typename C, typename T1, typename T2> struct SelectIf : SelectIfCond<C::Value, T1, T2> {};
-
-template <bool Cond1, bool Cond2> struct AndExprCond : FalseType {};
-template <> struct AndExprCond<true, true> : TrueType {};
-template <bool Cond1, bool Cond2> struct OrExprCond : TrueType {};
-template <> struct OrExprCond<false, false> : FalseType {};
-
-template <typename C> struct BoolExpr : SelectIf<C,TrueType,FalseType>::Type {};
-template <typename C> struct NotExpr  : SelectIf<C,FalseType,TrueType>::Type {};
-template <typename C1, typename C2> struct AndExpr : AndExprCond<C1::Value, C2::Value>::Type {};
-template <typename C1, typename C2> struct OrExpr  : OrExprCond<C1::Value, C2::Value>::Type {};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// AddConst, MaybeAddConst, RemoveConst
-template <typename T> struct AddConst { typedef const T Type; };
-template <bool Constify, typename T> struct MaybeAddConst : SelectIfCond<Constify, const T, T> {};
-template <typename T> struct RemoveConst { typedef T Type; };
-template <typename T> struct RemoveConst<const T> { typedef T Type; };
-
-
-///////////////////////////////////////////////////////////////////////////////
-// IsSame, IsConst, IsMoreConst, IsPointer
-//
-template <typename T, typename U> struct IsSame : FalseType {};
-template <typename T> struct IsSame<T, T> : TrueType {};
-
-template <typename T> struct IsConst : FalseType {};
-template <typename T> struct IsConst<const T> : TrueType {};
-
-template <typename CT, typename T>
-struct IsMoreConst
-    : AndExpr<IsSame<typename RemoveConst<CT>::Type, typename RemoveConst<T>::Type>,
-              BoolType<IsConst<CT>::Value >= IsConst<T>::Value> >::Type {};
-
-template <typename T> struct IsPointer : FalseType {};
-template <typename T> struct IsPointer<T*> : TrueType {};
-
-///////////////////////////////////////////////////////////////////////////////
-// IsBaseOf
-//
-#if RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-template <typename B, typename D> struct IsBaseOf
-    : BoolType< ::std::is_base_of<B,D>::value> {};
-
-#else // simplified version adopted from Boost
-
-template<typename B, typename D> struct IsBaseOfImpl {
-    RAPIDJSON_STATIC_ASSERT(sizeof(B) != 0);
-    RAPIDJSON_STATIC_ASSERT(sizeof(D) != 0);
-
-    typedef char (&Yes)[1];
-    typedef char (&No) [2];
-
-    template <typename T>
-    static Yes Check(const D*, T);
-    static No  Check(const B*, int);
-
-    struct Host {
-        operator const B*() const;
-        operator const D*();
-    };
-
-    enum { Value = (sizeof(Check(Host(), 0)) == sizeof(Yes)) };
-};
-
-template <typename B, typename D> struct IsBaseOf
-    : OrExpr<IsSame<B, D>, BoolExpr<IsBaseOfImpl<B, D> > >::Type {};
-
-#endif // RAPIDJSON_HAS_CXX11_TYPETRAITS
-
-
-//////////////////////////////////////////////////////////////////////////
-// EnableIf / DisableIf
-//
-template <bool Condition, typename T = void> struct EnableIfCond  { typedef T Type; };
-template <typename T> struct EnableIfCond<false, T> { /* empty */ };
-
-template <bool Condition, typename T = void> struct DisableIfCond { typedef T Type; };
-template <typename T> struct DisableIfCond<true, T> { /* empty */ };
-
-template <typename Condition, typename T = void>
-struct EnableIf : EnableIfCond<Condition::Value, T> {};
-
-template <typename Condition, typename T = void>
-struct DisableIf : DisableIfCond<Condition::Value, T> {};
-
-// SFINAE helpers
-struct SfinaeTag {};
-template <typename T> struct RemoveSfinaeTag;
-template <typename T> struct RemoveSfinaeTag<SfinaeTag&(*)(T)> { typedef T Type; };
-
-#define RAPIDJSON_REMOVEFPTR_(type) \
-    typename ::RAPIDJSON_NAMESPACE::internal::RemoveSfinaeTag \
-        < ::RAPIDJSON_NAMESPACE::internal::SfinaeTag&(*) type>::Type
-
-#define RAPIDJSON_ENABLEIF(cond) \
-    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_DISABLEIF(cond) \
-    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond)>::Type * = NULL
-
-#define RAPIDJSON_ENABLEIF_RETURN(cond,returntype) \
-    typename ::RAPIDJSON_NAMESPACE::internal::EnableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond), \
-         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-#define RAPIDJSON_DISABLEIF_RETURN(cond,returntype) \
-    typename ::RAPIDJSON_NAMESPACE::internal::DisableIf \
-        <RAPIDJSON_REMOVEFPTR_(cond), \
-         RAPIDJSON_REMOVEFPTR_(returntype)>::Type
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-//@endcond
-
-#if defined(__GNUC__) || defined(_MSC_VER)
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_INTERNAL_META_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/pow10.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/pow10.h
deleted file mode 100644
index 0252edf..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/pow10.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_POW10_
-#define RAPIDJSON_POW10_
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-//! Computes integer powers of 10 in double (10.0^n).
-/*! This function uses lookup table for fast and accurate results.
-    \param n non-negative exponent. Must <= 308.
-    \return 10.0^n
-*/
-inline double Pow10(int n) {
-    static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
-        1e+0,  
-        1e+1,  1e+2,  1e+3,  1e+4,  1e+5,  1e+6,  1e+7,  1e+8,  1e+9,  1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
-        1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
-        1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
-        1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
-        1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
-        1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
-        1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
-        1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
-        1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
-        1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
-        1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
-        1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
-        1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
-        1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
-        1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
-        1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
-    };
-    RAPIDJSON_ASSERT(n >= 0 && n <= 308);
-    return e[n];
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_POW10_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/stack.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/stack.h
deleted file mode 100644
index 93c5f45..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/stack.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_INTERNAL_STACK_H_
-#define RAPIDJSON_INTERNAL_STACK_H_
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-///////////////////////////////////////////////////////////////////////////////
-// Stack
-
-//! A type-unsafe stack for storing different types of data.
-/*! \tparam Allocator Allocator for allocating stack memory.
-*/
-template <typename Allocator>
-class Stack {
-public:
-    // Optimization note: Do not allocate memory for stack_ in constructor.
-    // Do it lazily when first Push() -> Expand() -> Resize().
-    Stack(Allocator* allocator, size_t stackCapacity) : allocator_(allocator), ownAllocator_(0), stack_(0), stackTop_(0), stackEnd_(0), initialCapacity_(stackCapacity) {
-        RAPIDJSON_ASSERT(stackCapacity > 0);
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Stack(Stack&& rhs)
-        : allocator_(rhs.allocator_),
-          ownAllocator_(rhs.ownAllocator_),
-          stack_(rhs.stack_),
-          stackTop_(rhs.stackTop_),
-          stackEnd_(rhs.stackEnd_),
-          initialCapacity_(rhs.initialCapacity_)
-    {
-        rhs.allocator_ = 0;
-        rhs.ownAllocator_ = 0;
-        rhs.stack_ = 0;
-        rhs.stackTop_ = 0;
-        rhs.stackEnd_ = 0;
-        rhs.initialCapacity_ = 0;
-    }
-#endif
-
-    ~Stack() {
-        Destroy();
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    Stack& operator=(Stack&& rhs) {
-        if (&rhs != this)
-        {
-            Destroy();
-
-            allocator_ = rhs.allocator_;
-            ownAllocator_ = rhs.ownAllocator_;
-            stack_ = rhs.stack_;
-            stackTop_ = rhs.stackTop_;
-            stackEnd_ = rhs.stackEnd_;
-            initialCapacity_ = rhs.initialCapacity_;
-
-            rhs.allocator_ = 0;
-            rhs.ownAllocator_ = 0;
-            rhs.stack_ = 0;
-            rhs.stackTop_ = 0;
-            rhs.stackEnd_ = 0;
-            rhs.initialCapacity_ = 0;
-        }
-        return *this;
-    }
-#endif
-
-    void Clear() { stackTop_ = stack_; }
-
-    void ShrinkToFit() { 
-        if (Empty()) {
-            // If the stack is empty, completely deallocate the memory.
-            Allocator::Free(stack_);
-            stack_ = 0;
-            stackTop_ = 0;
-            stackEnd_ = 0;
-        }
-        else
-            Resize(GetSize());
-    }
-
-    // Optimization note: try to minimize the size of this function for force inline.
-    // Expansion is run very infrequently, so it is moved to another (probably non-inline) function.
-    template<typename T>
-    RAPIDJSON_FORCEINLINE T* Push(size_t count = 1) {
-         // Expand the stack if needed
-        if (stackTop_ + sizeof(T) * count >= stackEnd_)
-            Expand<T>(count);
-
-        T* ret = reinterpret_cast<T*>(stackTop_);
-        stackTop_ += sizeof(T) * count;
-        return ret;
-    }
-
-    template<typename T>
-    T* Pop(size_t count) {
-        RAPIDJSON_ASSERT(GetSize() >= count * sizeof(T));
-        stackTop_ -= count * sizeof(T);
-        return reinterpret_cast<T*>(stackTop_);
-    }
-
-    template<typename T>
-    T* Top() { 
-        RAPIDJSON_ASSERT(GetSize() >= sizeof(T));
-        return reinterpret_cast<T*>(stackTop_ - sizeof(T));
-    }
-
-    template<typename T>
-    T* Bottom() { return (T*)stack_; }
-
-    Allocator& GetAllocator() { return *allocator_; }
-    bool Empty() const { return stackTop_ == stack_; }
-    size_t GetSize() const { return static_cast<size_t>(stackTop_ - stack_); }
-    size_t GetCapacity() const { return static_cast<size_t>(stackEnd_ - stack_); }
-
-private:
-    template<typename T>
-    void Expand(size_t count) {
-        // Only expand the capacity if the current stack exists. Otherwise just create a stack with initial capacity.
-        size_t newCapacity;
-        if (stack_ == 0) {
-            if (!allocator_)
-                ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator());
-            newCapacity = initialCapacity_;
-        } else {
-            newCapacity = GetCapacity();
-            newCapacity += (newCapacity + 1) / 2;
-        }
-        size_t newSize = GetSize() + sizeof(T) * count;
-        if (newCapacity < newSize)
-            newCapacity = newSize;
-
-        Resize(newCapacity);
-    }
-
-    void Resize(size_t newCapacity) {
-        const size_t size = GetSize();  // Backup the current size
-        stack_ = (char*)allocator_->Realloc(stack_, GetCapacity(), newCapacity);
-        stackTop_ = stack_ + size;
-        stackEnd_ = stack_ + newCapacity;
-    }
-
-    void Destroy() {
-        Allocator::Free(stack_);
-        RAPIDJSON_DELETE(ownAllocator_); // Only delete if it is owned by the stack
-    }
-
-    // Prohibit copy constructor & assignment operator.
-    Stack(const Stack&);
-    Stack& operator=(const Stack&);
-
-    Allocator* allocator_;
-    Allocator* ownAllocator_;
-    char *stack_;
-    char *stackTop_;
-    char *stackEnd_;
-    size_t initialCapacity_;
-};
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STACK_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strfunc.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strfunc.h
deleted file mode 100644
index c271dac..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strfunc.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_INTERNAL_STRFUNC_H_
-#define RAPIDJSON_INTERNAL_STRFUNC_H_
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-//! Custom strlen() which works on different character types.
-/*! \tparam Ch Character type (e.g. char, wchar_t, short)
-    \param s Null-terminated input string.
-    \return Number of characters in the string. 
-    \note This has the same semantics as strlen(), the return value is not number of Unicode codepoints.
-*/
-template <typename Ch>
-inline SizeType StrLen(const Ch* s) {
-    const Ch* p = s;
-    while (*p) ++p;
-    return SizeType(p - s);
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_INTERNAL_STRFUNC_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strtod.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strtod.h
deleted file mode 100644
index 1fc6050..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/internal/strtod.h
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_STRTOD_
-#define RAPIDJSON_STRTOD_
-
-#include "../rapidjson.h"
-#include "ieee754.h"
-#include "biginteger.h"
-#include "diyfp.h"
-#include "pow10.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-namespace internal {
-
-inline double FastPath(double significand, int exp) {
-    if (exp < -308)
-        return 0.0;
-    else if (exp >= 0)
-        return significand * internal::Pow10(exp);
-    else
-        return significand / internal::Pow10(-exp);
-}
-
-inline double StrtodNormalPrecision(double d, int p) {
-    if (p < -308) {
-        // Prevent expSum < -308, making Pow10(p) = 0
-        d = FastPath(d, -308);
-        d = FastPath(d, p + 308);
-    }
-    else
-        d = FastPath(d, p);
-    return d;
-}
-
-template <typename T>
-inline T Min3(T a, T b, T c) {
-    T m = a;
-    if (m > b) m = b;
-    if (m > c) m = c;
-    return m;
-}
-
-inline int CheckWithinHalfULP(double b, const BigInteger& d, int dExp, bool* adjustToNegative) {
-    const Double db(b);
-    const uint64_t bInt = db.IntegerSignificand();
-    const int bExp = db.IntegerExponent();
-    const int hExp = bExp - 1;
-
-    int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;
-
-    // Adjust for decimal exponent
-    if (dExp >= 0) {
-        dS_Exp2 += dExp;
-        dS_Exp5 += dExp;
-    }
-    else {
-        bS_Exp2 -= dExp;
-        bS_Exp5 -= dExp;
-        hS_Exp2 -= dExp;
-        hS_Exp5 -= dExp;
-    }
-
-    // Adjust for binary exponent
-    if (bExp >= 0)
-        bS_Exp2 += bExp;
-    else {
-        dS_Exp2 -= bExp;
-        hS_Exp2 -= bExp;
-    }
-
-    // Adjust for half ulp exponent
-    if (hExp >= 0)
-        hS_Exp2 += hExp;
-    else {
-        dS_Exp2 -= hExp;
-        bS_Exp2 -= hExp;
-    }
-
-    // Remove common power of two factor from all three scaled values
-    int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
-    dS_Exp2 -= common_Exp2;
-    bS_Exp2 -= common_Exp2;
-    hS_Exp2 -= common_Exp2;
-
-    BigInteger dS = d;
-    dS.MultiplyPow5(dS_Exp5) <<= dS_Exp2;
-
-    BigInteger bS(bInt);
-    bS.MultiplyPow5(bS_Exp5) <<= bS_Exp2;
-
-    BigInteger hS(1);
-    hS.MultiplyPow5(hS_Exp5) <<= hS_Exp2;
-
-    BigInteger delta(0);
-    *adjustToNegative = dS.Difference(bS, &delta);
-
-    int cmp = delta.Compare(hS);
-    // If delta is within 1/2 ULP, check for special case when significand is power of two.
-    // In this case, need to compare with 1/2h in the lower bound.
-    if (cmp < 0 && *adjustToNegative && // within and dS < bS
-        db.IsNormal() && (bInt & (bInt - 1)) == 0 && // Power of 2
-        db.Uint64Value() != RAPIDJSON_UINT64_C2(0x00100000, 0x00000000)) // minimum normal number must not do this
-    {
-        delta <<= 1;
-        return delta.Compare(hS);
-    }
-    return cmp;
-}
-
-inline bool StrtodFast(double d, int p, double* result) {
-    // Use fast path for string-to-double conversion if possible
-    // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
-    if (p > 22  && p < 22 + 16) {
-        // Fast Path Cases In Disguise
-        d *= internal::Pow10(p - 22);
-        p = 22;
-    }
-
-    if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
-        *result = FastPath(d, p);
-        return true;
-    }
-    else
-        return false;
-}
-
-// Compute an approximation and see if it is within 1/2 ULP
-inline bool StrtodDiyFp(const char* decimals, size_t length, size_t decimalPosition, int exp, double* result) {
-    uint64_t significand = 0;
-    size_t i = 0;   // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999    
-    for (; i < length; i++) {
-        if (significand  >  RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
-            (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
-            break;
-        significand = significand * 10 + (decimals[i] - '0');
-    }
-    
-    if (i < length && decimals[i] >= '5') // Rounding
-        significand++;
-
-    size_t remaining = length - i;
-    const unsigned kUlpShift = 3;
-    const unsigned kUlp = 1 << kUlpShift;
-    int error = (remaining == 0) ? 0 : kUlp / 2;
-
-    DiyFp v(significand, 0);
-    v = v.Normalize();
-    error <<= -v.e;
-
-    const int dExp = (int)decimalPosition - (int)i + exp;
-
-    int actualExp;
-    DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
-    if (actualExp != dExp) {
-        static const DiyFp kPow10[] = {
-            DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60),  // 10^1
-            DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57),  // 10^2
-            DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54),  // 10^3
-            DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50),  // 10^4
-            DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47),  // 10^5
-            DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44),  // 10^6
-            DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40)   // 10^7
-        };
-        int adjustment = dExp - actualExp - 1;
-        RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
-        v = v * kPow10[adjustment];
-        if (length + adjustment > 19) // has more digits than decimal digits in 64-bit
-            error += kUlp / 2;
-    }
-
-    v = v * cachedPower;
-
-    error += kUlp + (error == 0 ? 0 : 1);
-
-    const int oldExp = v.e;
-    v = v.Normalize();
-    error <<= oldExp - v.e;
-
-    const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
-    unsigned precisionSize = 64 - effectiveSignificandSize;
-    if (precisionSize + kUlpShift >= 64) {
-        unsigned scaleExp = (precisionSize + kUlpShift) - 63;
-        v.f >>= scaleExp;
-        v.e += scaleExp; 
-        error = (error >> scaleExp) + 1 + kUlp;
-        precisionSize -= scaleExp;
-    }
-
-    DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
-    const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
-    const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
-    if (precisionBits >= halfWay + error)
-        rounded.f++;
-
-    *result = rounded.ToDouble();
-
-    return halfWay - error >= precisionBits || precisionBits >= halfWay + error;
-}
-
-inline double StrtodBigInteger(double approx, const char* decimals, size_t length, size_t decimalPosition, int exp) {
-    const BigInteger dInt(decimals, length);
-    const int dExp = (int)decimalPosition - (int)length + exp;
-    Double a(approx);
-    for (int i = 0; i < 10; i++) {
-        bool adjustToNegative;
-        int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp, &adjustToNegative);
-        if (cmp < 0)
-            return a.Value();  // within half ULP
-        else if (cmp == 0) {
-            // Round towards even
-            if (a.Significand() & 1)
-                return adjustToNegative ? a.PreviousPositiveDouble() : a.NextPositiveDouble();
-            else
-                return a.Value();
-        }
-        else // adjustment
-            a = adjustToNegative ? a.PreviousPositiveDouble() : a.NextPositiveDouble();
-    }
-
-    // This should not happen, but in case there is really a bug, break the infinite-loop
-    return a.Value();
-}
-
-inline double StrtodFullPrecision(double d, int p, const char* decimals, size_t length, size_t decimalPosition, int exp) {
-    RAPIDJSON_ASSERT(d >= 0.0);
-    RAPIDJSON_ASSERT(length >= 1);
-
-    double result;
-    if (StrtodFast(d, p, &result))
-        return result;
-
-    // Trim leading zeros
-    while (*decimals == '0' && length > 1) {
-        length--;
-        decimals++;
-        decimalPosition--;
-    }
-
-    // Trim trailing zeros
-    while (decimals[length - 1] == '0' && length > 1) {
-        length--;
-        decimalPosition--;
-        exp++;
-    }
-
-    // Trim right-most digits
-    const int kMaxDecimalDigit = 780;
-    if ((int)length > kMaxDecimalDigit) {
-        exp += (int(length) - kMaxDecimalDigit);
-        length = kMaxDecimalDigit;
-    }
-
-    // If too small, underflow to zero
-    if (int(length) + exp < -324)
-        return 0.0;
-
-    if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
-        return result;
-
-    // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
-    return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
-}
-
-} // namespace internal
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STRTOD_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorybuffer.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorybuffer.h
deleted file mode 100644
index 95c68a3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorybuffer.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_MEMORYBUFFER_H_
-#define RAPIDJSON_MEMORYBUFFER_H_
-
-#include "rapidjson.h"
-#include "internal/stack.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedOutputStream or AutoUTFOutputStream.
-
-    It is similar to FileWriteBuffer but the destination is an in-memory buffer instead of a file.
-
-    Differences between MemoryBuffer and StringBuffer:
-    1. StringBuffer has Encoding but MemoryBuffer is only a byte buffer. 
-    2. StringBuffer::GetString() returns a null-terminated string. MemoryBuffer::GetBuffer() returns a buffer without terminator.
-
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Allocator = CrtAllocator>
-struct GenericMemoryBuffer {
-    typedef char Ch; // byte
-
-    GenericMemoryBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
-    void Flush() {}
-
-    void Clear() { stack_.Clear(); }
-    void ShrinkToFit() { stack_.ShrinkToFit(); }
-    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
-    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
-
-    const Ch* GetBuffer() const {
-        return stack_.template Bottom<Ch>();
-    }
-
-    size_t GetSize() const { return stack_.GetSize(); }
-
-    static const size_t kDefaultCapacity = 256;
-    mutable internal::Stack<Allocator> stack_;
-};
-
-typedef GenericMemoryBuffer<> MemoryBuffer;
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(MemoryBuffer& memoryBuffer, char c, size_t n) {
-    std::memset(memoryBuffer.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorystream.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorystream.h
deleted file mode 100644
index f994a12..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/memorystream.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_MEMORYSTREAM_H_
-#define RAPIDJSON_MEMORYSTREAM_H_
-
-#include "rapidjson.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory input byte stream.
-/*!
-    This class is mainly for being wrapped by EncodedInputStream or AutoUTFInputStream.
-
-    It is similar to FileReadBuffer but the source is an in-memory buffer instead of a file.
-
-    Differences between MemoryStream and StringStream:
-    1. StringStream has encoding but MemoryStream is a byte stream.
-    2. MemoryStream needs size of the source buffer and the buffer don't need to be null terminated. StringStream assume null-terminated string as source.
-    3. MemoryStream supports Peek4() for encoding detection. StringStream is specified with an encoding so it should not have Peek4().
-    \note implements Stream concept
-*/
-struct MemoryStream {
-    typedef char Ch; // byte
-
-    MemoryStream(const Ch *src, size_t size) : src_(src), begin_(src), end_(src + size), size_(size) {}
-
-    Ch Peek() const { return (src_ == end_) ? '\0' : *src_; }
-    Ch Take() { return (src_ == end_) ? '\0' : *src_++; }
-    size_t Tell() const { return static_cast<size_t>(src_ - begin_); }
-
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    // For encoding detection only.
-    const Ch* Peek4() const {
-        return Tell() + 4 <= size_ ? src_ : 0;
-    }
-
-    const Ch* src_;     //!< Current read position.
-    const Ch* begin_;   //!< Original head of the string.
-    const Ch* end_;     //!< End of stream.
-    size_t size_;       //!< Size of the stream.
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_MEMORYBUFFER_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/inttypes.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/inttypes.h
deleted file mode 100644
index af713c9..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/inttypes.h
+++ /dev/null
@@ -1,312 +0,0 @@
-// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
-//  Copyright (c) 2006-2013 Alexander Chemeris
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-// 
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-// 
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_INTTYPES_H_ // [
-#define _MSC_INTTYPES_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-#include "stdint.h"
-
-// miloyip: VC supports inttypes.h since VC2013
-#if _MSC_VER >= 1800
-#include <inttypes.h>
-#else
-
-// 7.8 Format conversion of integer types
-
-typedef struct {
-   intmax_t quot;
-   intmax_t rem;
-} imaxdiv_t;
-
-// 7.8.1 Macros for format specifiers
-
-#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
-
-// The fprintf macros for signed integers are:
-#define PRId8       "d"
-#define PRIi8       "i"
-#define PRIdLEAST8  "d"
-#define PRIiLEAST8  "i"
-#define PRIdFAST8   "d"
-#define PRIiFAST8   "i"
-
-#define PRId16       "hd"
-#define PRIi16       "hi"
-#define PRIdLEAST16  "hd"
-#define PRIiLEAST16  "hi"
-#define PRIdFAST16   "hd"
-#define PRIiFAST16   "hi"
-
-#define PRId32       "I32d"
-#define PRIi32       "I32i"
-#define PRIdLEAST32  "I32d"
-#define PRIiLEAST32  "I32i"
-#define PRIdFAST32   "I32d"
-#define PRIiFAST32   "I32i"
-
-#define PRId64       "I64d"
-#define PRIi64       "I64i"
-#define PRIdLEAST64  "I64d"
-#define PRIiLEAST64  "I64i"
-#define PRIdFAST64   "I64d"
-#define PRIiFAST64   "I64i"
-
-#define PRIdMAX     "I64d"
-#define PRIiMAX     "I64i"
-
-#define PRIdPTR     "Id"
-#define PRIiPTR     "Ii"
-
-// The fprintf macros for unsigned integers are:
-#define PRIo8       "o"
-#define PRIu8       "u"
-#define PRIx8       "x"
-#define PRIX8       "X"
-#define PRIoLEAST8  "o"
-#define PRIuLEAST8  "u"
-#define PRIxLEAST8  "x"
-#define PRIXLEAST8  "X"
-#define PRIoFAST8   "o"
-#define PRIuFAST8   "u"
-#define PRIxFAST8   "x"
-#define PRIXFAST8   "X"
-
-#define PRIo16       "ho"
-#define PRIu16       "hu"
-#define PRIx16       "hx"
-#define PRIX16       "hX"
-#define PRIoLEAST16  "ho"
-#define PRIuLEAST16  "hu"
-#define PRIxLEAST16  "hx"
-#define PRIXLEAST16  "hX"
-#define PRIoFAST16   "ho"
-#define PRIuFAST16   "hu"
-#define PRIxFAST16   "hx"
-#define PRIXFAST16   "hX"
-
-#define PRIo32       "I32o"
-#define PRIu32       "I32u"
-#define PRIx32       "I32x"
-#define PRIX32       "I32X"
-#define PRIoLEAST32  "I32o"
-#define PRIuLEAST32  "I32u"
-#define PRIxLEAST32  "I32x"
-#define PRIXLEAST32  "I32X"
-#define PRIoFAST32   "I32o"
-#define PRIuFAST32   "I32u"
-#define PRIxFAST32   "I32x"
-#define PRIXFAST32   "I32X"
-
-#define PRIo64       "I64o"
-#define PRIu64       "I64u"
-#define PRIx64       "I64x"
-#define PRIX64       "I64X"
-#define PRIoLEAST64  "I64o"
-#define PRIuLEAST64  "I64u"
-#define PRIxLEAST64  "I64x"
-#define PRIXLEAST64  "I64X"
-#define PRIoFAST64   "I64o"
-#define PRIuFAST64   "I64u"
-#define PRIxFAST64   "I64x"
-#define PRIXFAST64   "I64X"
-
-#define PRIoMAX     "I64o"
-#define PRIuMAX     "I64u"
-#define PRIxMAX     "I64x"
-#define PRIXMAX     "I64X"
-
-#define PRIoPTR     "Io"
-#define PRIuPTR     "Iu"
-#define PRIxPTR     "Ix"
-#define PRIXPTR     "IX"
-
-// The fscanf macros for signed integers are:
-#define SCNd8       "d"
-#define SCNi8       "i"
-#define SCNdLEAST8  "d"
-#define SCNiLEAST8  "i"
-#define SCNdFAST8   "d"
-#define SCNiFAST8   "i"
-
-#define SCNd16       "hd"
-#define SCNi16       "hi"
-#define SCNdLEAST16  "hd"
-#define SCNiLEAST16  "hi"
-#define SCNdFAST16   "hd"
-#define SCNiFAST16   "hi"
-
-#define SCNd32       "ld"
-#define SCNi32       "li"
-#define SCNdLEAST32  "ld"
-#define SCNiLEAST32  "li"
-#define SCNdFAST32   "ld"
-#define SCNiFAST32   "li"
-
-#define SCNd64       "I64d"
-#define SCNi64       "I64i"
-#define SCNdLEAST64  "I64d"
-#define SCNiLEAST64  "I64i"
-#define SCNdFAST64   "I64d"
-#define SCNiFAST64   "I64i"
-
-#define SCNdMAX     "I64d"
-#define SCNiMAX     "I64i"
-
-#ifdef _WIN64 // [
-#  define SCNdPTR     "I64d"
-#  define SCNiPTR     "I64i"
-#else  // _WIN64 ][
-#  define SCNdPTR     "ld"
-#  define SCNiPTR     "li"
-#endif  // _WIN64 ]
-
-// The fscanf macros for unsigned integers are:
-#define SCNo8       "o"
-#define SCNu8       "u"
-#define SCNx8       "x"
-#define SCNX8       "X"
-#define SCNoLEAST8  "o"
-#define SCNuLEAST8  "u"
-#define SCNxLEAST8  "x"
-#define SCNXLEAST8  "X"
-#define SCNoFAST8   "o"
-#define SCNuFAST8   "u"
-#define SCNxFAST8   "x"
-#define SCNXFAST8   "X"
-
-#define SCNo16       "ho"
-#define SCNu16       "hu"
-#define SCNx16       "hx"
-#define SCNX16       "hX"
-#define SCNoLEAST16  "ho"
-#define SCNuLEAST16  "hu"
-#define SCNxLEAST16  "hx"
-#define SCNXLEAST16  "hX"
-#define SCNoFAST16   "ho"
-#define SCNuFAST16   "hu"
-#define SCNxFAST16   "hx"
-#define SCNXFAST16   "hX"
-
-#define SCNo32       "lo"
-#define SCNu32       "lu"
-#define SCNx32       "lx"
-#define SCNX32       "lX"
-#define SCNoLEAST32  "lo"
-#define SCNuLEAST32  "lu"
-#define SCNxLEAST32  "lx"
-#define SCNXLEAST32  "lX"
-#define SCNoFAST32   "lo"
-#define SCNuFAST32   "lu"
-#define SCNxFAST32   "lx"
-#define SCNXFAST32   "lX"
-
-#define SCNo64       "I64o"
-#define SCNu64       "I64u"
-#define SCNx64       "I64x"
-#define SCNX64       "I64X"
-#define SCNoLEAST64  "I64o"
-#define SCNuLEAST64  "I64u"
-#define SCNxLEAST64  "I64x"
-#define SCNXLEAST64  "I64X"
-#define SCNoFAST64   "I64o"
-#define SCNuFAST64   "I64u"
-#define SCNxFAST64   "I64x"
-#define SCNXFAST64   "I64X"
-
-#define SCNoMAX     "I64o"
-#define SCNuMAX     "I64u"
-#define SCNxMAX     "I64x"
-#define SCNXMAX     "I64X"
-
-#ifdef _WIN64 // [
-#  define SCNoPTR     "I64o"
-#  define SCNuPTR     "I64u"
-#  define SCNxPTR     "I64x"
-#  define SCNXPTR     "I64X"
-#else  // _WIN64 ][
-#  define SCNoPTR     "lo"
-#  define SCNuPTR     "lu"
-#  define SCNxPTR     "lx"
-#  define SCNXPTR     "lX"
-#endif  // _WIN64 ]
-
-#endif // __STDC_FORMAT_MACROS ]
-
-// 7.8.2 Functions for greatest-width integer types
-
-// 7.8.2.1 The imaxabs function
-#define imaxabs _abs64
-
-// 7.8.2.2 The imaxdiv function
-
-// This is modified version of div() function from Microsoft's div.c found
-// in %MSVC.NET%\crt\src\div.c
-#ifdef STATIC_IMAXDIV // [
-static
-#else // STATIC_IMAXDIV ][
-_inline
-#endif // STATIC_IMAXDIV ]
-imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
-{
-   imaxdiv_t result;
-
-   result.quot = numer / denom;
-   result.rem = numer % denom;
-
-   if (numer < 0 && result.rem > 0) {
-      // did division wrong; must fix up
-      ++result.quot;
-      result.rem -= denom;
-   }
-
-   return result;
-}
-
-// 7.8.2.3 The strtoimax and strtoumax functions
-#define strtoimax _strtoi64
-#define strtoumax _strtoui64
-
-// 7.8.2.4 The wcstoimax and wcstoumax functions
-#define wcstoimax _wcstoi64
-#define wcstoumax _wcstoui64
-
-#endif // _MSC_VER >= 1800
-
-#endif // _MSC_INTTYPES_H_ ]
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/stdint.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/stdint.h
deleted file mode 100644
index bbad95a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/msinttypes/stdint.h
+++ /dev/null
@@ -1,296 +0,0 @@
-// ISO C9x  compliant stdint.h for Microsoft Visual Studio
-// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
-// 
-//  Copyright (c) 2006-2013 Alexander Chemeris
-// 
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-// 
-//   1. Redistributions of source code must retain the above copyright notice,
-//      this list of conditions and the following disclaimer.
-// 
-//   2. Redistributions in binary form must reproduce the above copyright
-//      notice, this list of conditions and the following disclaimer in the
-//      documentation and/or other materials provided with the distribution.
-// 
-//   3. Neither the name of the product nor the names of its contributors may
-//      be used to endorse or promote products derived from this software
-//      without specific prior written permission.
-// 
-// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
-// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
-// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
-// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef _MSC_VER // [
-#error "Use this header only with Microsoft Visual C++ compilers!"
-#endif // _MSC_VER ]
-
-#ifndef _MSC_STDINT_H_ // [
-#define _MSC_STDINT_H_
-
-#if _MSC_VER > 1000
-#pragma once
-#endif
-
-// miloyip: Originally Visual Studio 2010 uses its own stdint.h. However it generates warning with INT64_C(), so change to use this file for vs2010.
-#if _MSC_VER >= 1600 // [
-#include <stdint.h>
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-#undef INT8_C
-#undef INT16_C
-#undef INT32_C
-#undef INT64_C
-#undef UINT8_C
-#undef UINT16_C
-#undef UINT32_C
-#undef UINT64_C
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#else // ] _MSC_VER >= 1700 [
-
-#include <limits.h>
-
-// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
-// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
-// or compiler give many errors like this:
-//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
-#ifdef __cplusplus
-extern "C" {
-#endif
-#  include <wchar.h>
-#ifdef __cplusplus
-}
-#endif
-
-// Define _W64 macros to mark types changing their size, like intptr_t.
-#ifndef _W64
-#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
-#     define _W64 __w64
-#  else
-#     define _W64
-#  endif
-#endif
-
-
-// 7.18.1 Integer types
-
-// 7.18.1.1 Exact-width integer types
-
-// Visual Studio 6 and Embedded Visual C++ 4 doesn't
-// realize that, e.g. char has the same size as __int8
-// so we give up on __intX for them.
-#if (_MSC_VER < 1300)
-   typedef signed char       int8_t;
-   typedef signed short      int16_t;
-   typedef signed int        int32_t;
-   typedef unsigned char     uint8_t;
-   typedef unsigned short    uint16_t;
-   typedef unsigned int      uint32_t;
-#else
-   typedef signed __int8     int8_t;
-   typedef signed __int16    int16_t;
-   typedef signed __int32    int32_t;
-   typedef unsigned __int8   uint8_t;
-   typedef unsigned __int16  uint16_t;
-   typedef unsigned __int32  uint32_t;
-#endif
-typedef signed __int64       int64_t;
-typedef unsigned __int64     uint64_t;
-
-
-// 7.18.1.2 Minimum-width integer types
-typedef int8_t    int_least8_t;
-typedef int16_t   int_least16_t;
-typedef int32_t   int_least32_t;
-typedef int64_t   int_least64_t;
-typedef uint8_t   uint_least8_t;
-typedef uint16_t  uint_least16_t;
-typedef uint32_t  uint_least32_t;
-typedef uint64_t  uint_least64_t;
-
-// 7.18.1.3 Fastest minimum-width integer types
-typedef int8_t    int_fast8_t;
-typedef int16_t   int_fast16_t;
-typedef int32_t   int_fast32_t;
-typedef int64_t   int_fast64_t;
-typedef uint8_t   uint_fast8_t;
-typedef uint16_t  uint_fast16_t;
-typedef uint32_t  uint_fast32_t;
-typedef uint64_t  uint_fast64_t;
-
-// 7.18.1.4 Integer types capable of holding object pointers
-#ifdef _WIN64 // [
-   typedef signed __int64    intptr_t;
-   typedef unsigned __int64  uintptr_t;
-#else // _WIN64 ][
-   typedef _W64 signed int   intptr_t;
-   typedef _W64 unsigned int uintptr_t;
-#endif // _WIN64 ]
-
-// 7.18.1.5 Greatest-width integer types
-typedef int64_t   intmax_t;
-typedef uint64_t  uintmax_t;
-
-
-// 7.18.2 Limits of specified-width integer types
-
-#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
-
-// 7.18.2.1 Limits of exact-width integer types
-#define INT8_MIN     ((int8_t)_I8_MIN)
-#define INT8_MAX     _I8_MAX
-#define INT16_MIN    ((int16_t)_I16_MIN)
-#define INT16_MAX    _I16_MAX
-#define INT32_MIN    ((int32_t)_I32_MIN)
-#define INT32_MAX    _I32_MAX
-#define INT64_MIN    ((int64_t)_I64_MIN)
-#define INT64_MAX    _I64_MAX
-#define UINT8_MAX    _UI8_MAX
-#define UINT16_MAX   _UI16_MAX
-#define UINT32_MAX   _UI32_MAX
-#define UINT64_MAX   _UI64_MAX
-
-// 7.18.2.2 Limits of minimum-width integer types
-#define INT_LEAST8_MIN    INT8_MIN
-#define INT_LEAST8_MAX    INT8_MAX
-#define INT_LEAST16_MIN   INT16_MIN
-#define INT_LEAST16_MAX   INT16_MAX
-#define INT_LEAST32_MIN   INT32_MIN
-#define INT_LEAST32_MAX   INT32_MAX
-#define INT_LEAST64_MIN   INT64_MIN
-#define INT_LEAST64_MAX   INT64_MAX
-#define UINT_LEAST8_MAX   UINT8_MAX
-#define UINT_LEAST16_MAX  UINT16_MAX
-#define UINT_LEAST32_MAX  UINT32_MAX
-#define UINT_LEAST64_MAX  UINT64_MAX
-
-// 7.18.2.3 Limits of fastest minimum-width integer types
-#define INT_FAST8_MIN    INT8_MIN
-#define INT_FAST8_MAX    INT8_MAX
-#define INT_FAST16_MIN   INT16_MIN
-#define INT_FAST16_MAX   INT16_MAX
-#define INT_FAST32_MIN   INT32_MIN
-#define INT_FAST32_MAX   INT32_MAX
-#define INT_FAST64_MIN   INT64_MIN
-#define INT_FAST64_MAX   INT64_MAX
-#define UINT_FAST8_MAX   UINT8_MAX
-#define UINT_FAST16_MAX  UINT16_MAX
-#define UINT_FAST32_MAX  UINT32_MAX
-#define UINT_FAST64_MAX  UINT64_MAX
-
-// 7.18.2.4 Limits of integer types capable of holding object pointers
-#ifdef _WIN64 // [
-#  define INTPTR_MIN   INT64_MIN
-#  define INTPTR_MAX   INT64_MAX
-#  define UINTPTR_MAX  UINT64_MAX
-#else // _WIN64 ][
-#  define INTPTR_MIN   INT32_MIN
-#  define INTPTR_MAX   INT32_MAX
-#  define UINTPTR_MAX  UINT32_MAX
-#endif // _WIN64 ]
-
-// 7.18.2.5 Limits of greatest-width integer types
-#define INTMAX_MIN   INT64_MIN
-#define INTMAX_MAX   INT64_MAX
-#define UINTMAX_MAX  UINT64_MAX
-
-// 7.18.3 Limits of other integer types
-
-#ifdef _WIN64 // [
-#  define PTRDIFF_MIN  _I64_MIN
-#  define PTRDIFF_MAX  _I64_MAX
-#else  // _WIN64 ][
-#  define PTRDIFF_MIN  _I32_MIN
-#  define PTRDIFF_MAX  _I32_MAX
-#endif  // _WIN64 ]
-
-#define SIG_ATOMIC_MIN  INT_MIN
-#define SIG_ATOMIC_MAX  INT_MAX
-
-#ifndef SIZE_MAX // [
-#  ifdef _WIN64 // [
-#     define SIZE_MAX  _UI64_MAX
-#  else // _WIN64 ][
-#     define SIZE_MAX  _UI32_MAX
-#  endif // _WIN64 ]
-#endif // SIZE_MAX ]
-
-// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
-#ifndef WCHAR_MIN // [
-#  define WCHAR_MIN  0
-#endif  // WCHAR_MIN ]
-#ifndef WCHAR_MAX // [
-#  define WCHAR_MAX  _UI16_MAX
-#endif  // WCHAR_MAX ]
-
-#define WINT_MIN  0
-#define WINT_MAX  _UI16_MAX
-
-#endif // __STDC_LIMIT_MACROS ]
-
-
-// 7.18.4 Limits of other integer types
-
-#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
-
-// 7.18.4.1 Macros for minimum-width integer constants
-
-#define INT8_C(val)  val##i8
-#define INT16_C(val) val##i16
-#define INT32_C(val) val##i32
-#define INT64_C(val) val##i64
-
-#define UINT8_C(val)  val##ui8
-#define UINT16_C(val) val##ui16
-#define UINT32_C(val) val##ui32
-#define UINT64_C(val) val##ui64
-
-// 7.18.4.2 Macros for greatest-width integer constants
-// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
-// Check out Issue 9 for the details.
-#ifndef INTMAX_C //   [
-#  define INTMAX_C   INT64_C
-#endif // INTMAX_C    ]
-#ifndef UINTMAX_C //  [
-#  define UINTMAX_C  UINT64_C
-#endif // UINTMAX_C   ]
-
-#endif // __STDC_CONSTANT_MACROS ]
-
-#endif // _MSC_VER >= 1600 ]
-
-#endif // _MSC_STDINT_H_ ]
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/prettywriter.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/prettywriter.h
deleted file mode 100644
index 9109f6d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/prettywriter.h
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_PRETTYWRITER_H_
-#define RAPIDJSON_PRETTYWRITER_H_
-
-#include "writer.h"
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Writer with indentation and spacing.
-/*!
-    \tparam OutputStream Type of ouptut os.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator>
-class PrettyWriter : public Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> {
-public:
-    typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator> Base;
-    typedef typename Base::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param allocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    PrettyWriter(OutputStream& os, StackAllocator* allocator = 0, size_t levelDepth = Base::kDefaultLevelDepth) : 
-        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}
-
-    //! Set custom indentation.
-    /*! \param indentChar       Character for indentation. Must be whitespace character (' ', '\\t', '\\n', '\\r').
-        \param indentCharCount  Number of indent characters for each indentation level.
-        \note The default indentation is 4 spaces.
-    */
-    PrettyWriter& SetIndent(Ch indentChar, unsigned indentCharCount) {
-        RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
-        indentChar_ = indentChar;
-        indentCharCount_ = indentCharCount;
-        return *this;
-    }
-
-    /*! @name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()                 { PrettyPrefix(kNullType);   return Base::WriteNull(); }
-    bool Bool(bool b)           { PrettyPrefix(b ? kTrueType : kFalseType); return Base::WriteBool(b); }
-    bool Int(int i)             { PrettyPrefix(kNumberType); return Base::WriteInt(i); }
-    bool Uint(unsigned u)       { PrettyPrefix(kNumberType); return Base::WriteUint(u); }
-    bool Int64(int64_t i64)     { PrettyPrefix(kNumberType); return Base::WriteInt64(i64); }
-    bool Uint64(uint64_t u64)   { PrettyPrefix(kNumberType); return Base::WriteUint64(u64);  }
-    bool Double(double d)       { PrettyPrefix(kNumberType); return Base::WriteDouble(d); }
-
-    bool String(const Ch* str, SizeType length, bool copy = false) {
-        (void)copy;
-        PrettyPrefix(kStringType);
-        return Base::WriteString(str, length);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch>& str) {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject() {
-        PrettyPrefix(kObjectType);
-        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
-        return Base::WriteStartObject();
-    }
-
-    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
-	
-    bool EndObject(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
-        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray);
-        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-        if (!empty) {
-            Base::os_->Put('\n');
-            WriteIndent();
-        }
-        if (!Base::WriteEndObject())
-            return false;
-        if (Base::level_stack_.Empty()) // end of json text
-            Base::os_->Flush();
-        return true;
-    }
-
-    bool StartArray() {
-        PrettyPrefix(kArrayType);
-        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
-        return Base::WriteStartArray();
-    }
-
-    bool EndArray(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
-        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
-        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;
-
-        if (!empty) {
-            Base::os_->Put('\n');
-            WriteIndent();
-        }
-        if (!Base::WriteEndArray())
-            return false;
-        if (Base::level_stack_.Empty()) // end of json text
-            Base::os_->Flush();
-        return true;
-    }
-
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
-    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
-
-    //@}
-protected:
-    void PrettyPrefix(Type type) {
-        (void)type;
-        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
-            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();
-
-            if (level->inArray) {
-                if (level->valueCount > 0) {
-                    Base::os_->Put(','); // add comma if it is not the first element in array
-                    Base::os_->Put('\n');
-                }
-                else
-                    Base::os_->Put('\n');
-                WriteIndent();
-            }
-            else {  // in object
-                if (level->valueCount > 0) {
-                    if (level->valueCount % 2 == 0) {
-                        Base::os_->Put(',');
-                        Base::os_->Put('\n');
-                    }
-                    else {
-                        Base::os_->Put(':');
-                        Base::os_->Put(' ');
-                    }
-                }
-                else
-                    Base::os_->Put('\n');
-
-                if (level->valueCount % 2 == 0)
-                    WriteIndent();
-            }
-            if (!level->inArray && level->valueCount % 2 == 0)
-                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-            level->valueCount++;
-        }
-        else {
-            RAPIDJSON_ASSERT(!Base::hasRoot_);  // Should only has one and only one root.
-            Base::hasRoot_ = true;
-        }
-    }
-
-    void WriteIndent()  {
-        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
-        PutN(*Base::os_, indentChar_, count);
-    }
-
-    Ch indentChar_;
-    unsigned indentCharCount_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    PrettyWriter(const PrettyWriter&);
-    PrettyWriter& operator=(const PrettyWriter&);
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/rapidjson.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/rapidjson.h
deleted file mode 100644
index 70ef3fe..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/rapidjson.h
+++ /dev/null
@@ -1,629 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_RAPIDJSON_H_
-#define RAPIDJSON_RAPIDJSON_H_
-
-// Copyright (c) 2011 Milo Yip (miloyip@gmail.com)
-// Version 0.1
-
-/*!\file rapidjson.h
-    \brief common definitions and configuration
-
-    \see RAPIDJSON_CONFIG
- */
-
-/*! \defgroup RAPIDJSON_CONFIG RapidJSON configuration
-    \brief Configuration macros for library features
-
-    Some RapidJSON features are configurable to adapt the library to a wide
-    variety of platforms, environments and usage scenarios.  Most of the
-    features can be configured in terms of overriden or predefined
-    preprocessor macros at compile-time.
-
-    Some additional customization is available in the \ref RAPIDJSON_ERRORS APIs.
-
-    \note These macros should be given on the compiler command-line
-          (where applicable)  to avoid inconsistent values when compiling
-          different translation units of a single application.
- */
-
-#include <cstdlib>  // malloc(), realloc(), free(), size_t
-#include <cstring>  // memset(), memcpy(), memmove(), memcmp()
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NAMESPACE_(BEGIN|END)
-/*! \def RAPIDJSON_NAMESPACE
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace
-
-    In order to avoid symbol clashes and/or "One Definition Rule" errors
-    between multiple inclusions of (different versions of) RapidJSON in
-    a single binary, users can customize the name of the main RapidJSON
-    namespace.
-
-    In case of a single nesting level, defining \c RAPIDJSON_NAMESPACE
-    to a custom name (e.g. \c MyRapidJSON) is sufficient.  If multiple
-    levels are needed, both \ref RAPIDJSON_NAMESPACE_BEGIN and \ref
-    RAPIDJSON_NAMESPACE_END need to be defined as well:
-
-    \code
-    // in some .cpp file
-    #define RAPIDJSON_NAMESPACE my::rapidjson
-    #define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapidjson {
-    #define RAPIDJSON_NAMESPACE_END   } }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson
- */
-/*! \def RAPIDJSON_NAMESPACE_BEGIN
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (opening expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-/*! \def RAPIDJSON_NAMESPACE_END
-    \ingroup RAPIDJSON_CONFIG
-    \brief   provide custom rapidjson namespace (closing expression)
-    \see RAPIDJSON_NAMESPACE
-*/
-#ifndef RAPIDJSON_NAMESPACE
-#define RAPIDJSON_NAMESPACE rapidjson
-#endif
-#ifndef RAPIDJSON_NAMESPACE_BEGIN
-#define RAPIDJSON_NAMESPACE_BEGIN namespace RAPIDJSON_NAMESPACE {
-#endif
-#ifndef RAPIDJSON_NAMESPACE_END
-#define RAPIDJSON_NAMESPACE_END }
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_INT64DEFINE
-
-/*! \def RAPIDJSON_NO_INT64DEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief Use external 64-bit integer types.
-
-    RapidJSON requires the 64-bit integer types \c int64_t and  \c uint64_t types
-    to be available at global scope.
-
-    If users have their own definition, define RAPIDJSON_NO_INT64DEFINE to
-    prevent RapidJSON from defining its own types.
-*/
-#ifndef RAPIDJSON_NO_INT64DEFINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#ifdef _MSC_VER
-#include "msinttypes/stdint.h"
-#include "msinttypes/inttypes.h"
-#else
-// Other compilers should have this.
-#include <stdint.h>
-#include <inttypes.h>
-#endif
-//!@endcond
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_INT64DEFINE
-#endif
-#endif // RAPIDJSON_NO_INT64TYPEDEF
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_FORCEINLINE
-
-#ifndef RAPIDJSON_FORCEINLINE
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#ifdef _MSC_VER
-#define RAPIDJSON_FORCEINLINE __forceinline
-#elif defined(__GNUC__) && __GNUC__ >= 4
-#define RAPIDJSON_FORCEINLINE __attribute__((always_inline))
-#else
-#define RAPIDJSON_FORCEINLINE
-#endif
-//!@endcond
-#endif // RAPIDJSON_FORCEINLINE
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ENDIAN
-#define RAPIDJSON_LITTLEENDIAN  0   //!< Little endian machine
-#define RAPIDJSON_BIGENDIAN     1   //!< Big endian machine
-
-//! Endianness of the machine.
-/*!
-    \def RAPIDJSON_ENDIAN
-    \ingroup RAPIDJSON_CONFIG
-
-    GCC 4.6 provided macro for detecting endianness of the target machine. But other
-    compilers may not have this. User can define RAPIDJSON_ENDIAN to either
-    \ref RAPIDJSON_LITTLEENDIAN or \ref RAPIDJSON_BIGENDIAN.
-
-    Default detection implemented with reference to
-    \li https://gcc.gnu.org/onlinedocs/gcc-4.6.0/cpp/Common-Predefined-Macros.html
-    \li http://www.boost.org/doc/libs/1_42_0/boost/detail/endian.hpp
-*/
-#ifndef RAPIDJSON_ENDIAN
-// Detect with GCC 4.6's macro
-#  ifdef __BYTE_ORDER__
-#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
-#    endif // __BYTE_ORDER__
-// Detect with GLIBC's endian.h
-#  elif defined(__GLIBC__)
-#    include <endian.h>
-#    if (__BYTE_ORDER == __LITTLE_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#    elif (__BYTE_ORDER == __BIG_ENDIAN)
-#      define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#    else
-#      error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.
-#   endif // __GLIBC__
-// Detect with _LITTLE_ENDIAN and _BIG_ENDIAN macro
-#  elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-// Detect with architecture macros
-#  elif defined(__sparc) || defined(__sparc__) || defined(_POWER) || defined(__powerpc__) || defined(__ppc__) || defined(__hpux) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) || defined(__s390__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_BIGENDIAN
-#  elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) || defined(_M_IX86) || defined(_M_IA64) || defined(_M_ALPHA) || defined(__amd64) || defined(__amd64__) || defined(_M_AMD64) || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || defined(__bfin__)
-#    define RAPIDJSON_ENDIAN RAPIDJSON_LITTLEENDIAN
-#  elif defined(RAPIDJSON_DOXYGEN_RUNNING)
-#    define RAPIDJSON_ENDIAN
-#  else
-#    error Unknown machine endianess detected. User needs to define RAPIDJSON_ENDIAN.   
-#  endif
-#endif // RAPIDJSON_ENDIAN
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_64BIT
-
-//! Whether using 64-bit architecture
-#ifndef RAPIDJSON_64BIT
-#if defined(__LP64__) || defined(_WIN64)
-#define RAPIDJSON_64BIT 1
-#else
-#define RAPIDJSON_64BIT 0
-#endif
-#endif // RAPIDJSON_64BIT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ALIGN
-
-//! Data alignment of the machine.
-/*! \ingroup RAPIDJSON_CONFIG
-    \param x pointer to align
-
-    Some machines require strict data alignment. Currently the default uses 4 bytes
-    alignment. User can customize by defining the RAPIDJSON_ALIGN function macro.,
-*/
-#ifndef RAPIDJSON_ALIGN
-#define RAPIDJSON_ALIGN(x) ((x + 3u) & ~3u)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_UINT64_C2
-
-//! Construct a 64-bit literal by a pair of 32-bit integer.
-/*!
-    64-bit literal with or without ULL suffix is prone to compiler warnings.
-    UINT64_C() is C macro which cause compilation problems.
-    Use this macro to define 64-bit constants by a pair of 32-bit integer.
-*/
-#ifndef RAPIDJSON_UINT64_C2
-#define RAPIDJSON_UINT64_C2(high32, low32) ((static_cast<uint64_t>(high32) << 32) | static_cast<uint64_t>(low32))
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_SSE2/RAPIDJSON_SSE42/RAPIDJSON_SIMD
-
-/*! \def RAPIDJSON_SIMD
-    \ingroup RAPIDJSON_CONFIG
-    \brief Enable SSE2/SSE4.2 optimization.
-
-    RapidJSON supports optimized implementations for some parsing operations
-    based on the SSE2 or SSE4.2 SIMD extensions on modern Intel-compatible
-    processors.
-
-    To enable these optimizations, two different symbols can be defined;
-    \code
-    // Enable SSE2 optimization.
-    #define RAPIDJSON_SSE2
-
-    // Enable SSE4.2 optimization.
-    #define RAPIDJSON_SSE42
-    \endcode
-
-    \c RAPIDJSON_SSE42 takes precedence, if both are defined.
-
-    If any of these symbols is defined, RapidJSON defines the macro
-    \c RAPIDJSON_SIMD to indicate the availability of the optimized code.
-*/
-#if defined(RAPIDJSON_SSE2) || defined(RAPIDJSON_SSE42) \
-    || defined(RAPIDJSON_DOXYGEN_RUNNING)
-#define RAPIDJSON_SIMD
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_NO_SIZETYPEDEFINE
-
-#ifndef RAPIDJSON_NO_SIZETYPEDEFINE
-/*! \def RAPIDJSON_NO_SIZETYPEDEFINE
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-provided \c SizeType definition.
-
-    In order to avoid using 32-bit size types for indexing strings and arrays,
-    define this preprocessor symbol and provide the type rapidjson::SizeType
-    before including RapidJSON:
-    \code
-    #define RAPIDJSON_NO_SIZETYPEDEFINE
-    namespace rapidjson { typedef ::std::size_t SizeType; }
-    #include "rapidjson/..."
-    \endcode
-
-    \see rapidjson::SizeType
-*/
-#ifdef RAPIDJSON_DOXYGEN_RUNNING
-#define RAPIDJSON_NO_SIZETYPEDEFINE
-#endif
-RAPIDJSON_NAMESPACE_BEGIN
-//! Size type (for string lengths, array sizes, etc.)
-/*! RapidJSON uses 32-bit array/string indices even on 64-bit platforms,
-    instead of using \c size_t. Users may override the SizeType by defining
-    \ref RAPIDJSON_NO_SIZETYPEDEFINE.
-*/
-typedef unsigned SizeType;
-RAPIDJSON_NAMESPACE_END
-#endif
-
-// always import std::size_t to rapidjson namespace
-RAPIDJSON_NAMESPACE_BEGIN
-using std::size_t;
-RAPIDJSON_NAMESPACE_END
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_ASSERT
-
-//! Assertion.
-/*! \ingroup RAPIDJSON_CONFIG
-    By default, rapidjson uses C \c assert() for internal assertions.
-    User can override it by defining RAPIDJSON_ASSERT(x) macro.
-
-    \note Parsing errors are handled and can be customized by the
-          \ref RAPIDJSON_ERRORS APIs.
-*/
-#ifndef RAPIDJSON_ASSERT
-#include <cassert>
-#define RAPIDJSON_ASSERT(x) assert(x)
-#endif // RAPIDJSON_ASSERT
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_STATIC_ASSERT
-
-// Adopt from boost
-#ifndef RAPIDJSON_STATIC_ASSERT
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-RAPIDJSON_NAMESPACE_BEGIN
-template <bool x> struct STATIC_ASSERTION_FAILURE;
-template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
-template<int x> struct StaticAssertTest {};
-RAPIDJSON_NAMESPACE_END
-
-#define RAPIDJSON_JOIN(X, Y) RAPIDJSON_DO_JOIN(X, Y)
-#define RAPIDJSON_DO_JOIN(X, Y) RAPIDJSON_DO_JOIN2(X, Y)
-#define RAPIDJSON_DO_JOIN2(X, Y) X##Y
-
-#if defined(__GNUC__)
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))
-#else
-#define RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE 
-#endif
-//!@endcond
-
-/*! \def RAPIDJSON_STATIC_ASSERT
-    \brief (Internal) macro to check for conditions at compile-time
-    \param x compile-time condition
-    \hideinitializer
- */
-#define RAPIDJSON_STATIC_ASSERT(x) \
-    typedef ::RAPIDJSON_NAMESPACE::StaticAssertTest< \
-      sizeof(::RAPIDJSON_NAMESPACE::STATIC_ASSERTION_FAILURE<bool(x) >)> \
-    RAPIDJSON_JOIN(StaticAssertTypedef, __LINE__) RAPIDJSON_STATIC_ASSERT_UNUSED_ATTRIBUTE
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Helpers
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-
-#define RAPIDJSON_MULTILINEMACRO_BEGIN do {  
-#define RAPIDJSON_MULTILINEMACRO_END \
-} while((void)0, 0)
-
-// adopted from Boost
-#define RAPIDJSON_VERSION_CODE(x,y,z) \
-  (((x)*100000) + ((y)*100) + (z))
-
-// token stringification
-#define RAPIDJSON_STRINGIFY(x) RAPIDJSON_DO_STRINGIFY(x)
-#define RAPIDJSON_DO_STRINGIFY(x) #x
-
-///////////////////////////////////////////////////////////////////////////////
-// RAPIDJSON_DIAG_PUSH/POP, RAPIDJSON_DIAG_OFF
-
-#if defined(__GNUC__)
-#define RAPIDJSON_GNUC \
-    RAPIDJSON_VERSION_CODE(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
-#endif
-
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,2,0))
-
-#define RAPIDJSON_PRAGMA(x) _Pragma(RAPIDJSON_STRINGIFY(x))
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(GCC diagnostic x)
-#define RAPIDJSON_DIAG_OFF(x) \
-    RAPIDJSON_DIAG_PRAGMA(ignored RAPIDJSON_STRINGIFY(RAPIDJSON_JOIN(-W,x)))
-
-// push/pop support in Clang and GCC>=4.6
-#if defined(__clang__) || (defined(RAPIDJSON_GNUC) && RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0))
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-#else // GCC >= 4.2, < 4.6
-#define RAPIDJSON_DIAG_PUSH /* ignored */
-#define RAPIDJSON_DIAG_POP /* ignored */
-#endif
-
-#elif defined(_MSC_VER)
-
-// pragma (MSVC specific)
-#define RAPIDJSON_PRAGMA(x) __pragma(x)
-#define RAPIDJSON_DIAG_PRAGMA(x) RAPIDJSON_PRAGMA(warning(x))
-
-#define RAPIDJSON_DIAG_OFF(x) RAPIDJSON_DIAG_PRAGMA(disable: x)
-#define RAPIDJSON_DIAG_PUSH RAPIDJSON_DIAG_PRAGMA(push)
-#define RAPIDJSON_DIAG_POP  RAPIDJSON_DIAG_PRAGMA(pop)
-
-#else
-
-#define RAPIDJSON_DIAG_OFF(x) /* ignored */
-#define RAPIDJSON_DIAG_PUSH   /* ignored */
-#define RAPIDJSON_DIAG_POP    /* ignored */
-
-#endif // RAPIDJSON_DIAG_*
-
-///////////////////////////////////////////////////////////////////////////////
-// C++11 features
-
-#ifndef RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#if defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS __has_feature(cxx_rvalue_references) && \
-    (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__) && __GLIBCXX__ >= 20080306)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,3,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__)) || \
-      (defined(_MSC_VER) && _MSC_VER >= 1600)
-
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 1
-#else
-#define RAPIDJSON_HAS_CXX11_RVALUE_REFS 0
-#endif
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#ifndef RAPIDJSON_HAS_CXX11_NOEXCEPT
-#if defined(__clang__)
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT __has_feature(cxx_noexcept)
-#elif (defined(RAPIDJSON_GNUC) && (RAPIDJSON_GNUC >= RAPIDJSON_VERSION_CODE(4,6,0)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-//    (defined(_MSC_VER) && _MSC_VER >= ????) // not yet supported
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 1
-#else
-#define RAPIDJSON_HAS_CXX11_NOEXCEPT 0
-#endif
-#endif
-#if RAPIDJSON_HAS_CXX11_NOEXCEPT
-#define RAPIDJSON_NOEXCEPT noexcept
-#else
-#define RAPIDJSON_NOEXCEPT /* noexcept */
-#endif // RAPIDJSON_HAS_CXX11_NOEXCEPT
-
-// no automatic detection, yet
-#ifndef RAPIDJSON_HAS_CXX11_TYPETRAITS
-#define RAPIDJSON_HAS_CXX11_TYPETRAITS 0
-#endif
-
-//!@endcond
-
-///////////////////////////////////////////////////////////////////////////////
-// new/delete
-
-#ifndef RAPIDJSON_NEW
-///! customization point for global \c new
-#define RAPIDJSON_NEW(x) new x
-#endif
-#ifndef RAPIDJSON_DELETE
-///! customization point for global \c delete
-#define RAPIDJSON_DELETE(x) delete x
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Allocators and Encodings
-
-#include "allocators.h"
-#include "encodings.h"
-
-/*! \namespace rapidjson
-    \brief main RapidJSON namespace
-    \see RAPIDJSON_NAMESPACE
-*/
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//  Stream
-
-/*! \class rapidjson::Stream
-    \brief Concept for reading and writing characters.
-
-    For read-only stream, no need to implement PutBegin(), Put(), Flush() and PutEnd().
-
-    For write-only stream, only need to implement Put() and Flush().
-
-\code
-concept Stream {
-    typename Ch;    //!< Character type of the stream.
-
-    //! Read the current character from stream without moving the read cursor.
-    Ch Peek() const;
-
-    //! Read the current character from stream and moving the read cursor to next character.
-    Ch Take();
-
-    //! Get the current read cursor.
-    //! \return Number of characters read from start.
-    size_t Tell();
-
-    //! Begin writing operation at the current read pointer.
-    //! \return The begin writer pointer.
-    Ch* PutBegin();
-
-    //! Write a character.
-    void Put(Ch c);
-
-    //! Flush the buffer.
-    void Flush();
-
-    //! End the writing operation.
-    //! \param begin The begin write pointer returned by PutBegin().
-    //! \return Number of characters written.
-    size_t PutEnd(Ch* begin);
-}
-\endcode
-*/
-
-//! Provides additional information for stream.
-/*!
-    By using traits pattern, this type provides a default configuration for stream.
-    For custom stream, this type can be specialized for other configuration.
-    See TEST(Reader, CustomStringStream) in readertest.cpp for example.
-*/
-template<typename Stream>
-struct StreamTraits {
-    //! Whether to make local copy of stream for optimization during parsing.
-    /*!
-        By default, for safety, streams do not use local copy optimization.
-        Stream that can be copied fast should specialize this, like StreamTraits<StringStream>.
-    */
-    enum { copyOptimization = 0 };
-};
-
-//! Put N copies of a character to a stream.
-template<typename Stream, typename Ch>
-inline void PutN(Stream& stream, Ch c, size_t n) {
-    for (size_t i = 0; i < n; i++)
-        stream.Put(c);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// StringStream
-
-//! Read-only string stream.
-/*! \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericStringStream {
-    typedef typename Encoding::Ch Ch;
-
-    GenericStringStream(const Ch *src) : src_(src), head_(src) {}
-
-    Ch Peek() const { return *src_; }
-    Ch Take() { return *src_++; }
-    size_t Tell() const { return static_cast<size_t>(src_ - head_); }
-
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-    const Ch* src_;     //!< Current read position.
-    const Ch* head_;    //!< Original head of the string.
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
-};
-
-//! String stream with UTF8 encoding.
-typedef GenericStringStream<UTF8<> > StringStream;
-
-///////////////////////////////////////////////////////////////////////////////
-// InsituStringStream
-
-//! A read-write string stream.
-/*! This string stream is particularly designed for in-situ parsing.
-    \note implements Stream concept
-*/
-template <typename Encoding>
-struct GenericInsituStringStream {
-    typedef typename Encoding::Ch Ch;
-
-    GenericInsituStringStream(Ch *src) : src_(src), dst_(0), head_(src) {}
-
-    // Read
-    Ch Peek() { return *src_; }
-    Ch Take() { return *src_++; }
-    size_t Tell() { return static_cast<size_t>(src_ - head_); }
-
-    // Write
-    void Put(Ch c) { RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
-
-    Ch* PutBegin() { return dst_ = src_; }
-    size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
-    void Flush() {}
-
-    Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
-    void Pop(size_t count) { dst_ -= count; }
-
-    Ch* src_;
-    Ch* dst_;
-    Ch* head_;
-};
-
-template <typename Encoding>
-struct StreamTraits<GenericInsituStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
-};
-
-//! Insitu string stream with UTF8 encoding.
-typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
-
-///////////////////////////////////////////////////////////////////////////////
-// Type
-
-//! Type of JSON value
-enum Type {
-    kNullType = 0,      //!< null
-    kFalseType = 1,     //!< false
-    kTrueType = 2,      //!< true
-    kObjectType = 3,    //!< object
-    kArrayType = 4,     //!< array 
-    kStringType = 5,    //!< string
-    kNumberType = 6     //!< number
-};
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/reader.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/reader.h
deleted file mode 100644
index 5f54581..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/reader.h
+++ /dev/null
@@ -1,1444 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_READER_H_
-#define RAPIDJSON_READER_H_
-
-/*! \file reader.h */
-
-#include "rapidjson.h"
-#include "encodings.h"
-#include "internal/meta.h"
-#include "internal/stack.h"
-#include "internal/strtod.h"
-
-#if defined(RAPIDJSON_SIMD) && defined(_MSC_VER)
-#include <intrin.h>
-#pragma intrinsic(_BitScanForward)
-#endif
-#ifdef RAPIDJSON_SSE42
-#include <nmmintrin.h>
-#elif defined(RAPIDJSON_SSE2)
-#include <emmintrin.h>
-#endif
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127)  // conditional expression is constant
-RAPIDJSON_DIAG_OFF(4702)  // unreachable code
-#endif
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define RAPIDJSON_NOTHING /* deliberately empty */
-#ifndef RAPIDJSON_PARSE_ERROR_EARLY_RETURN
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN(value) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    if (HasParseError()) { return value; } \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-#define RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID \
-    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(RAPIDJSON_NOTHING)
-//!@endcond
-
-/*! \def RAPIDJSON_PARSE_ERROR_NORETURN
-    \ingroup RAPIDJSON_ERRORS
-    \brief Macro to indicate a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    This macros can be used as a customization point for the internal
-    error handling mechanism of RapidJSON.
-
-    A common usage model is to throw an exception instead of requiring the
-    caller to explicitly check the \ref rapidjson::GenericReader::Parse's
-    return value:
-
-    \code
-    #define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode,offset) \
-       throw ParseException(parseErrorCode, #parseErrorCode, offset)
-
-    #include <stdexcept>               // std::runtime_error
-    #include "rapidjson/error/error.h" // rapidjson::ParseResult
-
-    struct ParseException : std::runtime_error, rapidjson::ParseResult {
-      ParseException(rapidjson::ParseErrorCode code, const char* msg, size_t offset)
-        : std::runtime_error(msg), ParseResult(code, offset) {}
-    };
-
-    #include "rapidjson/reader.h"
-    \endcode
-
-    \see RAPIDJSON_PARSE_ERROR, rapidjson::GenericReader::Parse
- */
-#ifndef RAPIDJSON_PARSE_ERROR_NORETURN
-#define RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    RAPIDJSON_ASSERT(!HasParseError()); /* Error can only be assigned once */ \
-    SetParseError(parseErrorCode, offset); \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-/*! \def RAPIDJSON_PARSE_ERROR
-    \ingroup RAPIDJSON_ERRORS
-    \brief (Internal) macro to indicate and handle a parse error.
-    \param parseErrorCode \ref rapidjson::ParseErrorCode of the error
-    \param offset  position of the error in JSON input (\c size_t)
-
-    Invokes RAPIDJSON_PARSE_ERROR_NORETURN and stops the parsing.
-
-    \see RAPIDJSON_PARSE_ERROR_NORETURN
-    \hideinitializer
- */
-#ifndef RAPIDJSON_PARSE_ERROR
-#define RAPIDJSON_PARSE_ERROR(parseErrorCode, offset) \
-    RAPIDJSON_MULTILINEMACRO_BEGIN \
-    RAPIDJSON_PARSE_ERROR_NORETURN(parseErrorCode, offset); \
-    RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID; \
-    RAPIDJSON_MULTILINEMACRO_END
-#endif
-
-#include "error/error.h" // ParseErrorCode, ParseResult
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-// ParseFlag
-
-/*! \def RAPIDJSON_PARSE_DEFAULT_FLAGS 
-    \ingroup RAPIDJSON_CONFIG
-    \brief User-defined kParseDefaultFlags definition.
-
-    User can define this as any \c ParseFlag combinations.
-*/
-#ifndef RAPIDJSON_PARSE_DEFAULT_FLAGS
-#define RAPIDJSON_PARSE_DEFAULT_FLAGS kParseNoFlags
-#endif
-
-//! Combination of parseFlags
-/*! \see Reader::Parse, Document::Parse, Document::ParseInsitu, Document::ParseStream
- */
-enum ParseFlag {
-    kParseNoFlags = 0,              //!< No flags are set.
-    kParseInsituFlag = 1,           //!< In-situ(destructive) parsing.
-    kParseValidateEncodingFlag = 2, //!< Validate encoding of JSON strings.
-    kParseIterativeFlag = 4,        //!< Iterative(constant complexity in terms of function call stack size) parsing.
-    kParseStopWhenDoneFlag = 8,     //!< After parsing a complete JSON root from stream, stop further processing the rest of stream. When this flag is used, parser will not generate kParseErrorDocumentRootNotSingular error.
-    kParseFullPrecisionFlag = 16,   //!< Parse number in full precision (but slower).
-    kParseDefaultFlags = RAPIDJSON_PARSE_DEFAULT_FLAGS  //!< Default parse flags. Can be customized by defining RAPIDJSON_PARSE_DEFAULT_FLAGS
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Handler
-
-/*! \class rapidjson::Handler
-    \brief Concept for receiving events from GenericReader upon parsing.
-    The functions return true if no error occurs. If they return false, 
-    the event publisher should terminate the process.
-\code
-concept Handler {
-    typename Ch;
-
-    bool Null();
-    bool Bool(bool b);
-    bool Int(int i);
-    bool Uint(unsigned i);
-    bool Int64(int64_t i);
-    bool Uint64(uint64_t i);
-    bool Double(double d);
-    bool String(const Ch* str, SizeType length, bool copy);
-    bool StartObject();
-    bool Key(const Ch* str, SizeType length, bool copy);
-    bool EndObject(SizeType memberCount);
-    bool StartArray();
-    bool EndArray(SizeType elementCount);
-};
-\endcode
-*/
-///////////////////////////////////////////////////////////////////////////////
-// BaseReaderHandler
-
-//! Default implementation of Handler.
-/*! This can be used as base class of any reader handler.
-    \note implements Handler concept
-*/
-template<typename Encoding = UTF8<>, typename Derived = void>
-struct BaseReaderHandler {
-    typedef typename Encoding::Ch Ch;
-
-    typedef typename internal::SelectIf<internal::IsSame<Derived, void>, BaseReaderHandler, Derived>::Type Override;
-
-    bool Default() { return true; }
-    bool Null() { return static_cast<Override&>(*this).Default(); }
-    bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
-    bool Int(int) { return static_cast<Override&>(*this).Default(); }
-    bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
-    bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
-    bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
-    bool Double(double) { return static_cast<Override&>(*this).Default(); }
-    bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*this).Default(); }
-    bool StartObject() { return static_cast<Override&>(*this).Default(); }
-    bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Override&>(*this).String(str, len, copy); }
-    bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(); }
-    bool StartArray() { return static_cast<Override&>(*this).Default(); }
-    bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// StreamLocalCopy
-
-namespace internal {
-
-template<typename Stream, int = StreamTraits<Stream>::copyOptimization>
-class StreamLocalCopy;
-
-//! Do copy optimization.
-template<typename Stream>
-class StreamLocalCopy<Stream, 1> {
-public:
-    StreamLocalCopy(Stream& original) : s(original), original_(original) {}
-    ~StreamLocalCopy() { original_ = s; }
-
-    Stream s;
-
-private:
-    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
-
-    Stream& original_;
-};
-
-//! Keep reference.
-template<typename Stream>
-class StreamLocalCopy<Stream, 0> {
-public:
-    StreamLocalCopy(Stream& original) : s(original) {}
-
-    Stream& s;
-
-private:
-    StreamLocalCopy& operator=(const StreamLocalCopy&) /* = delete */;
-};
-
-} // namespace internal
-
-///////////////////////////////////////////////////////////////////////////////
-// SkipWhitespace
-
-//! Skip the JSON white spaces in a stream.
-/*! \param is A input stream for skipping white spaces.
-    \note This function has SSE2/SSE4.2 specialization.
-*/
-template<typename InputStream>
-void SkipWhitespace(InputStream& is) {
-    internal::StreamLocalCopy<InputStream> copy(is);
-    InputStream& s(copy.s);
-
-    while (s.Peek() == ' ' || s.Peek() == '\n' || s.Peek() == '\r' || s.Peek() == '\t')
-        s.Take();
-}
-
-#ifdef RAPIDJSON_SSE42
-//! Skip whitespace with SSE 4.2 pcmpistrm instruction, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char* p) {
-	// Fast return for single non-whitespace
-	if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-		++p;
-	else
-		return p;
-
-	// 16-byte align to the next boundary
-	const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);
-	while (p != nextAligned)
-		if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-			++p;
-		else
-			return p;
-
-    // The rest of string using SIMD
-	static const char whitespace[16] = " \n\r\t";
-	const __m128i w = _mm_load_si128((const __m128i *)&whitespace[0]);
-
-    for (;; p += 16) {
-        const __m128i s = _mm_load_si128((const __m128i *)p);
-        const unsigned r = _mm_cvtsi128_si32(_mm_cmpistrm(w, s, _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK | _SIDD_NEGATIVE_POLARITY));
-        if (r != 0) {   // some of characters is non-whitespace
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-            unsigned long offset;
-            _BitScanForward(&offset, r);
-            return p + offset;
-#else
-            return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-}
-
-#elif defined(RAPIDJSON_SSE2)
-
-//! Skip whitespace with SSE2 instructions, testing 16 8-byte characters at once.
-inline const char *SkipWhitespace_SIMD(const char* p) {
-	// Fast return for single non-whitespace
-	if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-		++p;
-	else
-		return p;
-
-    // 16-byte align to the next boundary
-	const char* nextAligned = reinterpret_cast<const char*>((reinterpret_cast<size_t>(p) + 15) & ~15);
-	while (p != nextAligned)
-		if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t')
-			++p;
-		else
-			return p;
-
-    // The rest of string
-	static const char whitespaces[4][17] = {
-		"                ",
-		"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
-		"\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r",
-		"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t"};
-
-		const __m128i w0 = _mm_loadu_si128((const __m128i *)&whitespaces[0][0]);
-		const __m128i w1 = _mm_loadu_si128((const __m128i *)&whitespaces[1][0]);
-		const __m128i w2 = _mm_loadu_si128((const __m128i *)&whitespaces[2][0]);
-		const __m128i w3 = _mm_loadu_si128((const __m128i *)&whitespaces[3][0]);
-
-    for (;; p += 16) {
-        const __m128i s = _mm_load_si128((const __m128i *)p);
-        __m128i x = _mm_cmpeq_epi8(s, w0);
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w1));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w2));
-        x = _mm_or_si128(x, _mm_cmpeq_epi8(s, w3));
-        unsigned short r = (unsigned short)~_mm_movemask_epi8(x);
-        if (r != 0) {   // some of characters may be non-whitespace
-#ifdef _MSC_VER         // Find the index of first non-whitespace
-            unsigned long offset;
-            _BitScanForward(&offset, r);
-            return p + offset;
-#else
-            return p + __builtin_ffs(r) - 1;
-#endif
-        }
-    }
-}
-
-#endif // RAPIDJSON_SSE2
-
-#ifdef RAPIDJSON_SIMD
-//! Template function specialization for InsituStringStream
-template<> inline void SkipWhitespace(InsituStringStream& is) { 
-    is.src_ = const_cast<char*>(SkipWhitespace_SIMD(is.src_));
-}
-
-//! Template function specialization for StringStream
-template<> inline void SkipWhitespace(StringStream& is) {
-    is.src_ = SkipWhitespace_SIMD(is.src_);
-}
-#endif // RAPIDJSON_SIMD
-
-///////////////////////////////////////////////////////////////////////////////
-// GenericReader
-
-//! SAX-style JSON parser. Use \ref Reader for UTF8 encoding and default allocator.
-/*! GenericReader parses JSON text from a stream, and send events synchronously to an 
-    object implementing Handler concept.
-
-    It needs to allocate a stack for storing a single decoded string during 
-    non-destructive parsing.
-
-    For in-situ parsing, the decoded string is directly written to the source 
-    text string, no temporary buffer is required.
-
-    A GenericReader object can be reused for parsing multiple JSON text.
-    
-    \tparam SourceEncoding Encoding of the input stream.
-    \tparam TargetEncoding Encoding of the parse output.
-    \tparam StackAllocator Allocator type for stack.
-*/
-template <typename SourceEncoding, typename TargetEncoding, typename StackAllocator = CrtAllocator>
-class GenericReader {
-public:
-    typedef typename SourceEncoding::Ch Ch; //!< SourceEncoding character type
-
-    //! Constructor.
-    /*! \param stackAllocator Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
-        \param stackCapacity stack capacity in bytes for storing a single decoded string.  (Only use for non-destructive parsing)
-    */
-    GenericReader(StackAllocator* stackAllocator = 0, size_t stackCapacity = kDefaultStackCapacity) : stack_(stackAllocator, stackCapacity), parseResult_() {}
-
-    //! Parse JSON text.
-    /*! \tparam parseFlags Combination of \ref ParseFlag.
-        \tparam InputStream Type of input stream, implementing Stream concept.
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult Parse(InputStream& is, Handler& handler) {
-        if (parseFlags & kParseIterativeFlag)
-            return IterativeParse<parseFlags>(is, handler);
-
-        parseResult_.Clear();
-
-        ClearStackOnExit scope(*this);
-
-        SkipWhitespace(is);
-
-        if (is.Peek() == '\0') {
-            RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentEmpty, is.Tell());
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-        }
-        else {
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-
-            if (!(parseFlags & kParseStopWhenDoneFlag)) {
-                SkipWhitespace(is);
-
-                if (is.Peek() != '\0') {
-                    RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorDocumentRootNotSingular, is.Tell());
-                    RAPIDJSON_PARSE_ERROR_EARLY_RETURN(parseResult_);
-                }
-            }
-        }
-
-        return parseResult_;
-    }
-
-    //! Parse JSON text (with \ref kParseDefaultFlags)
-    /*! \tparam InputStream Type of input stream, implementing Stream concept
-        \tparam Handler Type of handler, implementing Handler concept.
-        \param is Input stream to be parsed.
-        \param handler The handler to receive events.
-        \return Whether the parsing is successful.
-    */
-    template <typename InputStream, typename Handler>
-    ParseResult Parse(InputStream& is, Handler& handler) {
-        return Parse<kParseDefaultFlags>(is, handler);
-    }
-
-    //! Whether a parse error has occured in the last parsing.
-    bool HasParseError() const { return parseResult_.IsError(); }
-    
-    //! Get the \ref ParseErrorCode of last parsing.
-    ParseErrorCode GetParseErrorCode() const { return parseResult_.Code(); }
-
-    //! Get the position of last parsing error in input, 0 otherwise.
-    size_t GetErrorOffset() const { return parseResult_.Offset(); }
-
-protected:
-    void SetParseError(ParseErrorCode code, size_t offset) { parseResult_.Set(code, offset); }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    GenericReader(const GenericReader&);
-    GenericReader& operator=(const GenericReader&);
-
-    void ClearStack() { stack_.Clear(); }
-
-    // clear stack on any exit from ParseStream, e.g. due to exception
-    struct ClearStackOnExit {
-        explicit ClearStackOnExit(GenericReader& r) : r_(r) {}
-        ~ClearStackOnExit() { r_.ClearStack(); }
-    private:
-        GenericReader& r_;
-        ClearStackOnExit(const ClearStackOnExit&);
-        ClearStackOnExit& operator=(const ClearStackOnExit&);
-    };
-
-    // Parse object: { string : value, ... }
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseObject(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == '{');
-        is.Take();  // Skip '{'
-        
-        if (!handler.StartObject())
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-
-        SkipWhitespace(is);
-
-        if (is.Peek() == '}') {
-            is.Take();
-            if (!handler.EndObject(0))  // empty object
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-            return;
-        }
-
-        for (SizeType memberCount = 0;;) {
-            if (is.Peek() != '"')
-                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
-
-            ParseString<parseFlags>(is, handler, true);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            SkipWhitespace(is);
-
-            if (is.Take() != ':')
-                RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
-
-            SkipWhitespace(is);
-
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            SkipWhitespace(is);
-
-            ++memberCount;
-
-            switch (is.Take()) {
-                case ',': SkipWhitespace(is); break;
-                case '}': 
-                    if (!handler.EndObject(memberCount))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                    return;
-                default:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
-            }
-        }
-    }
-
-    // Parse array: [ value, ... ]
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseArray(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == '[');
-        is.Take();  // Skip '['
-        
-        if (!handler.StartArray())
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        
-        SkipWhitespace(is);
-
-        if (is.Peek() == ']') {
-            is.Take();
-            if (!handler.EndArray(0)) // empty array
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-            return;
-        }
-
-        for (SizeType elementCount = 0;;) {
-            ParseValue<parseFlags>(is, handler);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-
-            ++elementCount;
-            SkipWhitespace(is);
-
-            switch (is.Take()) {
-                case ',': SkipWhitespace(is); break;
-                case ']': 
-                    if (!handler.EndArray(elementCount))
-                        RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-                    return;
-                default:  RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
-            }
-        }
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNull(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 'n');
-        is.Take();
-
-        if (is.Take() == 'u' && is.Take() == 'l' && is.Take() == 'l') {
-            if (!handler.Null())
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseTrue(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 't');
-        is.Take();
-
-        if (is.Take() == 'r' && is.Take() == 'u' && is.Take() == 'e') {
-            if (!handler.Bool(true))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
-    }
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseFalse(InputStream& is, Handler& handler) {
-        RAPIDJSON_ASSERT(is.Peek() == 'f');
-        is.Take();
-
-        if (is.Take() == 'a' && is.Take() == 'l' && is.Take() == 's' && is.Take() == 'e') {
-            if (!handler.Bool(false))
-                RAPIDJSON_PARSE_ERROR(kParseErrorTermination, is.Tell());
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, is.Tell() - 1);
-    }
-
-    // Helper function to parse four hexidecimal digits in \uXXXX in ParseString().
-    template<typename InputStream>
-    unsigned ParseHex4(InputStream& is) {
-        unsigned codepoint = 0;
-        for (int i = 0; i < 4; i++) {
-            Ch c = is.Take();
-            codepoint <<= 4;
-            codepoint += static_cast<unsigned>(c);
-            if (c >= '0' && c <= '9')
-                codepoint -= '0';
-            else if (c >= 'A' && c <= 'F')
-                codepoint -= 'A' - 10;
-            else if (c >= 'a' && c <= 'f')
-                codepoint -= 'a' - 10;
-            else {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorStringUnicodeEscapeInvalidHex, is.Tell() - 1);
-                RAPIDJSON_PARSE_ERROR_EARLY_RETURN(0);
-            }
-        }
-        return codepoint;
-    }
-
-    template <typename CharType>
-    class StackStream {
-    public:
-        typedef CharType Ch;
-
-        StackStream(internal::Stack<StackAllocator>& stack) : stack_(stack), length_(0) {}
-        RAPIDJSON_FORCEINLINE void Put(Ch c) {
-            *stack_.template Push<Ch>() = c;
-            ++length_;
-        }
-        size_t Length() const { return length_; }
-        Ch* Pop() {
-            return stack_.template Pop<Ch>(length_);
-        }
-
-    private:
-        StackStream(const StackStream&);
-        StackStream& operator=(const StackStream&);
-
-        internal::Stack<StackAllocator>& stack_;
-        SizeType length_;
-    };
-
-    // Parse string and generate String event. Different code paths for kParseInsituFlag.
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseString(InputStream& is, Handler& handler, bool isKey = false) {
-        internal::StreamLocalCopy<InputStream> copy(is);
-        InputStream& s(copy.s);
-
-        bool success = false;
-        if (parseFlags & kParseInsituFlag) {
-            typename InputStream::Ch *head = s.PutBegin();
-            ParseStringToStream<parseFlags, SourceEncoding, SourceEncoding>(s, s);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            size_t length = s.PutEnd(head) - 1;
-            RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
-            const typename TargetEncoding::Ch* const str = (typename TargetEncoding::Ch*)head;
-            success = (isKey ? handler.Key(str, SizeType(length), false) : handler.String(str, SizeType(length), false));
-        }
-        else {
-            StackStream<typename TargetEncoding::Ch> stackStream(stack_);
-            ParseStringToStream<parseFlags, SourceEncoding, TargetEncoding>(s, stackStream);
-            RAPIDJSON_PARSE_ERROR_EARLY_RETURN_VOID;
-            SizeType length = static_cast<SizeType>(stackStream.Length()) - 1;
-            const typename TargetEncoding::Ch* const str = stackStream.Pop();
-            success = (isKey ? handler.Key(str, length, true) : handler.String(str, length, true));
-        }
-        if (!success)
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
-    }
-
-    // Parse string to an output is
-    // This function handles the prefix/suffix double quotes, escaping, and optional encoding validation.
-    template<unsigned parseFlags, typename SEncoding, typename TEncoding, typename InputStream, typename OutputStream>
-    RAPIDJSON_FORCEINLINE void ParseStringToStream(InputStream& is, OutputStream& os) {
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-        static const char escape[256] = {
-            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/', 
-            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0, 
-            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0, 
-            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
-        };
-#undef Z16
-//!@endcond
-
-        RAPIDJSON_ASSERT(is.Peek() == '\"');
-        is.Take();  // Skip '\"'
-
-        for (;;) {
-            Ch c = is.Peek();
-            if (c == '\\') {    // Escape
-                is.Take();
-                Ch e = is.Take();
-                if ((sizeof(Ch) == 1 || unsigned(e) < 256) && escape[(unsigned char)e]) {
-                    os.Put(escape[(unsigned char)e]);
-                }
-                else if (e == 'u') {    // Unicode
-                    unsigned codepoint = ParseHex4(is);
-                    if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
-                        // Handle UTF-16 surrogate pair
-                        if (is.Take() != '\\' || is.Take() != 'u')
-                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);
-                        unsigned codepoint2 = ParseHex4(is);
-                        if (codepoint2 < 0xDC00 || codepoint2 > 0xDFFF)
-                            RAPIDJSON_PARSE_ERROR(kParseErrorStringUnicodeSurrogateInvalid, is.Tell() - 2);
-                        codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
-                    }
-                    TEncoding::Encode(os, codepoint);
-                }
-                else
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell() - 1);
-            }
-            else if (c == '"') {    // Closing double quote
-                is.Take();
-                os.Put('\0');   // null-terminate the string
-                return;
-            }
-            else if (c == '\0')
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringMissQuotationMark, is.Tell() - 1);
-            else if ((unsigned)c < 0x20) // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
-                RAPIDJSON_PARSE_ERROR(kParseErrorStringEscapeInvalid, is.Tell() - 1);
-            else {
-                if (parseFlags & kParseValidateEncodingFlag ? 
-                    !Transcoder<SEncoding, TEncoding>::Validate(is, os) : 
-                    !Transcoder<SEncoding, TEncoding>::Transcode(is, os))
-                    RAPIDJSON_PARSE_ERROR(kParseErrorStringInvalidEncoding, is.Tell());
-            }
-        }
-    }
-
-    template<typename InputStream, bool backup>
-    class NumberStream;
-
-    template<typename InputStream>
-    class NumberStream<InputStream, false> {
-    public:
-        NumberStream(GenericReader& reader, InputStream& s) : is(s) { (void)reader;  }
-        ~NumberStream() {}
-
-        RAPIDJSON_FORCEINLINE Ch Peek() const { return is.Peek(); }
-        RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
-        RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
-        size_t Tell() { return is.Tell(); }
-        size_t Length() { return 0; }
-        const char* Pop() { return 0; }
-
-    protected:
-        NumberStream& operator=(const NumberStream&);
-
-        InputStream& is;
-    };
-
-    template<typename InputStream>
-    class NumberStream<InputStream, true> : public NumberStream<InputStream, false> {
-        typedef NumberStream<InputStream, false> Base;
-    public:
-        NumberStream(GenericReader& reader, InputStream& is) : NumberStream<InputStream, false>(reader, is), stackStream(reader.stack_) {}
-        ~NumberStream() {}
-
-        RAPIDJSON_FORCEINLINE Ch TakePush() {
-            stackStream.Put((char)Base::is.Peek());
-            return Base::is.Take();
-        }
-
-        size_t Length() { return stackStream.Length(); }
-
-        const char* Pop() {
-            stackStream.Put('\0');
-            return stackStream.Pop();
-        }
-
-    private:
-        StackStream<char> stackStream;
-    };
-
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseNumber(InputStream& is, Handler& handler) {
-        internal::StreamLocalCopy<InputStream> copy(is);
-        NumberStream<InputStream, (parseFlags & kParseFullPrecisionFlag) != 0> s(*this, copy.s);
-
-        // Parse minus
-        bool minus = false;
-        if (s.Peek() == '-') {
-            minus = true;
-            s.Take();
-        }
-
-        // Parse int: zero / ( digit1-9 *DIGIT )
-        unsigned i = 0;
-        uint64_t i64 = 0;
-        bool use64bit = false;
-        int significandDigit = 0;
-        if (s.Peek() == '0') {
-            i = 0;
-            s.TakePush();
-        }
-        else if (s.Peek() >= '1' && s.Peek() <= '9') {
-            i = static_cast<unsigned>(s.TakePush() - '0');
-
-            if (minus)
-                while (s.Peek() >= '0' && s.Peek() <= '9') {
-                    if (i >= 214748364) { // 2^31 = 2147483648
-                        if (i != 214748364 || s.Peek() > '8') {
-                            i64 = i;
-                            use64bit = true;
-                            break;
-                        }
-                    }
-                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-            else
-                while (s.Peek() >= '0' && s.Peek() <= '9') {
-                    if (i >= 429496729) { // 2^32 - 1 = 4294967295
-                        if (i != 429496729 || s.Peek() > '5') {
-                            i64 = i;
-                            use64bit = true;
-                            break;
-                        }
-                    }
-                    i = i * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-        }
-        else
-            RAPIDJSON_PARSE_ERROR(kParseErrorValueInvalid, s.Tell());
-
-        // Parse 64bit int
-        bool useDouble = false;
-        double d = 0.0;
-        if (use64bit) {
-            if (minus) 
-                while (s.Peek() >= '0' && s.Peek() <= '9') {                    
-                     if (i64 >= RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC)) // 2^63 = 9223372036854775808
-                        if (i64 != RAPIDJSON_UINT64_C2(0x0CCCCCCC, 0xCCCCCCCC) || s.Peek() > '8') {
-                            d = i64;
-                            useDouble = true;
-                            break;
-                        }
-                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-            else
-                while (s.Peek() >= '0' && s.Peek() <= '9') {                    
-                    if (i64 >= RAPIDJSON_UINT64_C2(0x19999999, 0x99999999)) // 2^64 - 1 = 18446744073709551615
-                        if (i64 != RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) || s.Peek() > '5') {
-                            d = i64;
-                            useDouble = true;
-                            break;
-                        }
-                    i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                    significandDigit++;
-                }
-        }
-
-        // Force double for big integer
-        if (useDouble) {
-            while (s.Peek() >= '0' && s.Peek() <= '9') {
-                if (d >= 1.7976931348623157e307) // DBL_MAX / 10.0
-                    RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());
-                d = d * 10 + (s.TakePush() - '0');
-            }
-        }
-
-        // Parse frac = decimal-point 1*DIGIT
-        int expFrac = 0;
-        size_t decimalPosition;
-        if (s.Peek() == '.') {
-            s.Take();
-            decimalPosition = s.Length();
-
-            if (!(s.Peek() >= '0' && s.Peek() <= '9'))
-                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissFraction, s.Tell());
-
-            if (!useDouble) {
-#if RAPIDJSON_64BIT
-                // Use i64 to store significand in 64-bit architecture
-                if (!use64bit)
-                    i64 = i;
-        
-                while (s.Peek() >= '0' && s.Peek() <= '9') {
-                    if (i64 > RAPIDJSON_UINT64_C2(0x1FFFFF, 0xFFFFFFFF)) // 2^53 - 1 for fast path
-                        break;
-                    else {
-                        i64 = i64 * 10 + static_cast<unsigned>(s.TakePush() - '0');
-                        --expFrac;
-                        if (i64 != 0)
-                            significandDigit++;
-                    }
-                }
-
-                d = (double)i64;
-#else
-                // Use double to store significand in 32-bit architecture
-                d = use64bit ? (double)i64 : (double)i;
-#endif
-                useDouble = true;
-            }
-
-            while (s.Peek() >= '0' && s.Peek() <= '9') {
-                if (significandDigit < 17) {
-                    d = d * 10.0 + (s.TakePush() - '0');
-                    --expFrac;
-                    if (d != 0.0)
-                        significandDigit++;
-                }
-                else
-                    s.TakePush();
-            }
-        }
-        else
-            decimalPosition = s.Length(); // decimal position at the end of integer.
-
-        // Parse exp = e [ minus / plus ] 1*DIGIT
-        int exp = 0;
-        if (s.Peek() == 'e' || s.Peek() == 'E') {
-            if (!useDouble) {
-                d = use64bit ? i64 : i;
-                useDouble = true;
-            }
-            s.Take();
-
-            bool expMinus = false;
-            if (s.Peek() == '+')
-                s.Take();
-            else if (s.Peek() == '-') {
-                s.Take();
-                expMinus = true;
-            }
-
-            if (s.Peek() >= '0' && s.Peek() <= '9') {
-                exp = s.Take() - '0';
-                while (s.Peek() >= '0' && s.Peek() <= '9') {
-                    exp = exp * 10 + (s.Take() - '0');
-                    if (exp > 308 && !expMinus) // exp > 308 should be rare, so it should be checked first.
-                        RAPIDJSON_PARSE_ERROR(kParseErrorNumberTooBig, s.Tell());
-                }
-            }
-            else
-                RAPIDJSON_PARSE_ERROR(kParseErrorNumberMissExponent, s.Tell());
-
-            if (expMinus)
-                exp = -exp;
-        }
-
-        // Finish parsing, call event according to the type of number.
-        bool cont = true;
-        size_t length = s.Length();
-        const char* decimal = s.Pop();  // Pop stack no matter if it will be used or not.
-
-        if (useDouble) {
-            int p = exp + expFrac;
-            if (parseFlags & kParseFullPrecisionFlag)
-                d = internal::StrtodFullPrecision(d, p, decimal, length, decimalPosition, exp);
-            else
-                d = internal::StrtodNormalPrecision(d, p);
-
-            cont = handler.Double(minus ? -d : d);
-        }
-        else {
-            if (use64bit) {
-                if (minus)
-                    cont = handler.Int64(-(int64_t)i64);
-                else
-                    cont = handler.Uint64(i64);
-            }
-            else {
-                if (minus)
-                    cont = handler.Int(-(int)i);
-                else
-                    cont = handler.Uint(i);
-            }
-        }
-        if (!cont)
-            RAPIDJSON_PARSE_ERROR(kParseErrorTermination, s.Tell());
-    }
-
-    // Parse any JSON value
-    template<unsigned parseFlags, typename InputStream, typename Handler>
-    void ParseValue(InputStream& is, Handler& handler) {
-        switch (is.Peek()) {
-            case 'n': ParseNull  <parseFlags>(is, handler); break;
-            case 't': ParseTrue  <parseFlags>(is, handler); break;
-            case 'f': ParseFalse <parseFlags>(is, handler); break;
-            case '"': ParseString<parseFlags>(is, handler); break;
-            case '{': ParseObject<parseFlags>(is, handler); break;
-            case '[': ParseArray <parseFlags>(is, handler); break;
-            default : ParseNumber<parseFlags>(is, handler);
-        }
-    }
-
-    // Iterative Parsing
-
-    // States
-    enum IterativeParsingState {
-        IterativeParsingStartState = 0,
-        IterativeParsingFinishState,
-        IterativeParsingErrorState,
-
-        // Object states
-        IterativeParsingObjectInitialState,
-        IterativeParsingMemberKeyState,
-        IterativeParsingKeyValueDelimiterState,
-        IterativeParsingMemberValueState,
-        IterativeParsingMemberDelimiterState,
-        IterativeParsingObjectFinishState,
-
-        // Array states
-        IterativeParsingArrayInitialState,
-        IterativeParsingElementState,
-        IterativeParsingElementDelimiterState,
-        IterativeParsingArrayFinishState,
-
-        // Single value state
-        IterativeParsingValueState,
-
-        cIterativeParsingStateCount
-    };
-
-    // Tokens
-    enum Token {
-        LeftBracketToken = 0,
-        RightBracketToken,
-
-        LeftCurlyBracketToken,
-        RightCurlyBracketToken,
-
-        CommaToken,
-        ColonToken,
-
-        StringToken,
-        FalseToken,
-        TrueToken,
-        NullToken,
-        NumberToken,
-
-        kTokenCount
-    };
-
-    RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) {
-
-//!@cond RAPIDJSON_HIDDEN_FROM_DOXYGEN
-#define N NumberToken
-#define N16 N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N
-        // Maps from ASCII to Token
-        static const unsigned char tokenMap[256] = {
-            N16, // 00~0F
-            N16, // 10~1F
-            N, N, StringToken, N, N, N, N, N, N, N, N, N, CommaToken, N, N, N, // 20~2F
-            N, N, N, N, N, N, N, N, N, N, ColonToken, N, N, N, N, N, // 30~3F
-            N16, // 40~4F
-            N, N, N, N, N, N, N, N, N, N, N, LeftBracketToken, N, RightBracketToken, N, N, // 50~5F
-            N, N, N, N, N, N, FalseToken, N, N, N, N, N, N, N, NullToken, N, // 60~6F
-            N, N, N, N, TrueToken, N, N, N, N, N, N, LeftCurlyBracketToken, N, RightCurlyBracketToken, N, N, // 70~7F
-            N16, N16, N16, N16, N16, N16, N16, N16 // 80~FF
-        };
-#undef N
-#undef N16
-//!@endcond
-        
-        if (sizeof(Ch) == 1 || unsigned(c) < 256)
-            return (Token)tokenMap[(unsigned char)c];
-        else
-            return NumberToken;
-    }
-
-    RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativeParsingState state, Token token) {
-        // current state x one lookahead token -> new state
-        static const char G[cIterativeParsingStateCount][kTokenCount] = {
-            // Start
-            {
-                IterativeParsingArrayInitialState,  // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingObjectInitialState, // Left curly bracket
-                IterativeParsingErrorState,         // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingValueState,         // String
-                IterativeParsingValueState,         // False
-                IterativeParsingValueState,         // True
-                IterativeParsingValueState,         // Null
-                IterativeParsingValueState          // Number
-            },
-            // Finish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // Error(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // ObjectInitial
-            {
-                IterativeParsingErrorState,         // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingErrorState,         // Left curly bracket
-                IterativeParsingObjectFinishState,  // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingMemberKeyState,     // String
-                IterativeParsingErrorState,         // False
-                IterativeParsingErrorState,         // True
-                IterativeParsingErrorState,         // Null
-                IterativeParsingErrorState          // Number
-            },
-            // MemberKey
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingKeyValueDelimiterState, // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // KeyValueDelimiter
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push MemberValue state)
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push MemberValue state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingMemberValueState,       // String
-                IterativeParsingMemberValueState,       // False
-                IterativeParsingMemberValueState,       // True
-                IterativeParsingMemberValueState,       // Null
-                IterativeParsingMemberValueState        // Number
-            },
-            // MemberValue
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingObjectFinishState,      // Right curly bracket
-                IterativeParsingMemberDelimiterState,   // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // MemberDelimiter
-            {
-                IterativeParsingErrorState,         // Left bracket
-                IterativeParsingErrorState,         // Right bracket
-                IterativeParsingErrorState,         // Left curly bracket
-                IterativeParsingErrorState,         // Right curly bracket
-                IterativeParsingErrorState,         // Comma
-                IterativeParsingErrorState,         // Colon
-                IterativeParsingMemberKeyState,     // String
-                IterativeParsingErrorState,         // False
-                IterativeParsingErrorState,         // True
-                IterativeParsingErrorState,         // Null
-                IterativeParsingErrorState          // Number
-            },
-            // ObjectFinish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // ArrayInitial
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-                IterativeParsingArrayFinishState,       // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingElementState,           // String
-                IterativeParsingElementState,           // False
-                IterativeParsingElementState,           // True
-                IterativeParsingElementState,           // Null
-                IterativeParsingElementState            // Number
-            },
-            // Element
-            {
-                IterativeParsingErrorState,             // Left bracket
-                IterativeParsingArrayFinishState,       // Right bracket
-                IterativeParsingErrorState,             // Left curly bracket
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingElementDelimiterState,  // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingErrorState,             // String
-                IterativeParsingErrorState,             // False
-                IterativeParsingErrorState,             // True
-                IterativeParsingErrorState,             // Null
-                IterativeParsingErrorState              // Number
-            },
-            // ElementDelimiter
-            {
-                IterativeParsingArrayInitialState,      // Left bracket(push Element state)
-                IterativeParsingErrorState,             // Right bracket
-                IterativeParsingObjectInitialState,     // Left curly bracket(push Element state)
-                IterativeParsingErrorState,             // Right curly bracket
-                IterativeParsingErrorState,             // Comma
-                IterativeParsingErrorState,             // Colon
-                IterativeParsingElementState,           // String
-                IterativeParsingElementState,           // False
-                IterativeParsingElementState,           // True
-                IterativeParsingElementState,           // Null
-                IterativeParsingElementState            // Number
-            },
-            // ArrayFinish(sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            },
-            // Single Value (sink state)
-            {
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState, IterativeParsingErrorState,
-                IterativeParsingErrorState
-            }
-        }; // End of G
-
-        return (IterativeParsingState)G[state][token];
-    }
-
-    // Make an advance in the token stream and state based on the candidate destination state which was returned by Transit().
-    // May return a new state on state pop.
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    RAPIDJSON_FORCEINLINE IterativeParsingState Transit(IterativeParsingState src, Token token, IterativeParsingState dst, InputStream& is, Handler& handler) {
-        switch (dst) {
-        case IterativeParsingStartState:
-            RAPIDJSON_ASSERT(false);
-            return IterativeParsingErrorState;
-
-        case IterativeParsingFinishState:
-            return dst;
-
-        case IterativeParsingErrorState:
-            return dst;
-
-        case IterativeParsingObjectInitialState:
-        case IterativeParsingArrayInitialState:
-        {
-            // Push the state(Element or MemeberValue) if we are nested in another array or value of member.
-            // In this way we can get the correct state on ObjectFinish or ArrayFinish by frame pop.
-            IterativeParsingState n = src;
-            if (src == IterativeParsingArrayInitialState || src == IterativeParsingElementDelimiterState)
-                n = IterativeParsingElementState;
-            else if (src == IterativeParsingKeyValueDelimiterState)
-                n = IterativeParsingMemberValueState;
-            // Push current state.
-            *stack_.template Push<SizeType>(1) = n;
-            // Initialize and push the member/element count.
-            *stack_.template Push<SizeType>(1) = 0;
-            // Call handler
-            bool hr = (dst == IterativeParsingObjectInitialState) ? handler.StartObject() : handler.StartArray();
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return dst;
-            }
-        }
-
-        case IterativeParsingMemberKeyState:
-            ParseString<parseFlags>(is, handler, true);
-            if (HasParseError())
-                return IterativeParsingErrorState;
-            else
-                return dst;
-
-        case IterativeParsingKeyValueDelimiterState:
-            if (token == ColonToken) {
-                is.Take();
-                return dst;
-            }
-            else
-                return IterativeParsingErrorState;
-
-        case IterativeParsingMemberValueState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return dst;
-
-        case IterativeParsingElementState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return dst;
-
-        case IterativeParsingMemberDelimiterState:
-        case IterativeParsingElementDelimiterState:
-            is.Take();
-            // Update member/element count.
-            *stack_.template Top<SizeType>() = *stack_.template Top<SizeType>() + 1;
-            return dst;
-
-        case IterativeParsingObjectFinishState:
-        {
-            // Get member count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the object is not empty, count the last member.
-            if (src == IterativeParsingMemberValueState)
-                ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-                n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndObject(c);
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return n;
-            }
-        }
-
-        case IterativeParsingArrayFinishState:
-        {
-            // Get element count.
-            SizeType c = *stack_.template Pop<SizeType>(1);
-            // If the array is not empty, count the last element.
-            if (src == IterativeParsingElementState)
-                ++c;
-            // Restore the state.
-            IterativeParsingState n = static_cast<IterativeParsingState>(*stack_.template Pop<SizeType>(1));
-            // Transit to Finish state if this is the topmost scope.
-            if (n == IterativeParsingStartState)
-                n = IterativeParsingFinishState;
-            // Call handler
-            bool hr = handler.EndArray(c);
-            // On handler short circuits the parsing.
-            if (!hr) {
-                RAPIDJSON_PARSE_ERROR_NORETURN(kParseErrorTermination, is.Tell());
-                return IterativeParsingErrorState;
-            }
-            else {
-                is.Take();
-                return n;
-            }
-        }
-
-        case IterativeParsingValueState:
-            // Must be non-compound value. Or it would be ObjectInitial or ArrayInitial state.
-            ParseValue<parseFlags>(is, handler);
-            if (HasParseError()) {
-                return IterativeParsingErrorState;
-            }
-            return IterativeParsingFinishState;
-
-        default:
-            RAPIDJSON_ASSERT(false);
-            return IterativeParsingErrorState;
-        }
-    }
-
-    template <typename InputStream>
-    void HandleError(IterativeParsingState src, InputStream& is) {
-        if (HasParseError()) {
-            // Error flag has been set.
-            return;
-        }
-        
-        switch (src) {
-        case IterativeParsingStartState:            RAPIDJSON_PARSE_ERROR(kParseErrorDocumentEmpty, is.Tell());
-        case IterativeParsingFinishState:           RAPIDJSON_PARSE_ERROR(kParseErrorDocumentRootNotSingular, is.Tell());
-        case IterativeParsingObjectInitialState:
-        case IterativeParsingMemberDelimiterState:  RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissName, is.Tell());
-        case IterativeParsingMemberKeyState:        RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissColon, is.Tell());
-        case IterativeParsingMemberValueState:      RAPIDJSON_PARSE_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, is.Tell());
-        case IterativeParsingElementState:          RAPIDJSON_PARSE_ERROR(kParseErrorArrayMissCommaOrSquareBracket, is.Tell());
-        default:                                    RAPIDJSON_PARSE_ERROR(kParseErrorUnspecificSyntaxError, is.Tell());
-        }       
-    }
-
-    template <unsigned parseFlags, typename InputStream, typename Handler>
-    ParseResult IterativeParse(InputStream& is, Handler& handler) {
-        parseResult_.Clear();
-        ClearStackOnExit scope(*this);
-        IterativeParsingState state = IterativeParsingStartState;
-
-        SkipWhitespace(is);
-        while (is.Peek() != '\0') {
-            Token t = Tokenize(is.Peek());
-            IterativeParsingState n = Predict(state, t);
-            IterativeParsingState d = Transit<parseFlags>(state, t, n, is, handler);
-
-            if (d == IterativeParsingErrorState) {
-                HandleError(state, is);
-                break;
-            }
-
-            state = d;
-
-            // Do not further consume streams if a root JSON has been parsed.
-            if ((parseFlags & kParseStopWhenDoneFlag) && state == IterativeParsingFinishState)
-                break;
-
-            SkipWhitespace(is);
-        }
-
-        // Handle the end of file.
-        if (state != IterativeParsingFinishState)
-            HandleError(state, is);
-
-        return parseResult_;
-    }
-
-    static const size_t kDefaultStackCapacity = 256;    //!< Default stack capacity in bytes for storing a single decoded string.
-    internal::Stack<StackAllocator> stack_;  //!< A stack for storing decoded string temporarily during non-destructive parsing.
-    ParseResult parseResult_;
-}; // class GenericReader
-
-//! Reader with UTF8 encoding and default allocator.
-typedef GenericReader<UTF8<>, UTF8<> > Reader;
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_READER_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/stringbuffer.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/stringbuffer.h
deleted file mode 100644
index db00af3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/stringbuffer.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_STRINGBUFFER_H_
-#define RAPIDJSON_STRINGBUFFER_H_
-
-#include "rapidjson.h"
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-#include <utility> // std::move
-#endif
-
-#include "internal/stack.h"
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! Represents an in-memory output stream.
-/*!
-    \tparam Encoding Encoding of the stream.
-    \tparam Allocator type for allocating memory buffer.
-    \note implements Stream concept
-*/
-template <typename Encoding, typename Allocator = CrtAllocator>
-class GenericStringBuffer {
-public:
-    typedef typename Encoding::Ch Ch;
-
-    GenericStringBuffer(Allocator* allocator = 0, size_t capacity = kDefaultCapacity) : stack_(allocator, capacity) {}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    GenericStringBuffer(GenericStringBuffer&& rhs) : stack_(std::move(rhs.stack_)) {}
-    GenericStringBuffer& operator=(GenericStringBuffer&& rhs) {
-        if (&rhs != this)
-            stack_ = std::move(rhs.stack_);
-        return *this;
-    }
-#endif
-
-    void Put(Ch c) { *stack_.template Push<Ch>() = c; }
-    void Flush() {}
-
-    void Clear() { stack_.Clear(); }
-    void ShrinkToFit() {
-        // Push and pop a null terminator. This is safe.
-        *stack_.template Push<Ch>() = '\0';
-        stack_.ShrinkToFit();
-        stack_.template Pop<Ch>(1);
-    }
-    Ch* Push(size_t count) { return stack_.template Push<Ch>(count); }
-    void Pop(size_t count) { stack_.template Pop<Ch>(count); }
-
-    const Ch* GetString() const {
-        // Push and pop a null terminator. This is safe.
-        *stack_.template Push<Ch>() = '\0';
-        stack_.template Pop<Ch>(1);
-
-        return stack_.template Bottom<Ch>();
-    }
-
-    size_t GetSize() const { return stack_.GetSize(); }
-
-    static const size_t kDefaultCapacity = 256;
-    mutable internal::Stack<Allocator> stack_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    GenericStringBuffer(const GenericStringBuffer&);
-    GenericStringBuffer& operator=(const GenericStringBuffer&);
-};
-
-//! String buffer with UTF8 encoding
-typedef GenericStringBuffer<UTF8<> > StringBuffer;
-
-//! Implement specialized version of PutN() with memset() for better performance.
-template<>
-inline void PutN(GenericStringBuffer<UTF8<> >& stream, char c, size_t n) {
-    std::memset(stream.stack_.Push<char>(n), c, n * sizeof(c));
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#endif // RAPIDJSON_STRINGBUFFER_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/writer.h b/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/writer.h
deleted file mode 100644
index 44d8b1d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/include/rapidjson/writer.h
+++ /dev/null
@@ -1,401 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef RAPIDJSON_WRITER_H_
-#define RAPIDJSON_WRITER_H_
-
-#include "rapidjson.h"
-#include "internal/stack.h"
-#include "internal/strfunc.h"
-#include "internal/dtoa.h"
-#include "internal/itoa.h"
-#include "stringbuffer.h"
-#include <new>      // placement new
-
-#if RAPIDJSON_HAS_STDSTRING
-#include <string>
-#endif
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(4127) // conditional expression is constant
-#endif
-
-RAPIDJSON_NAMESPACE_BEGIN
-
-//! JSON writer
-/*! Writer implements the concept Handler.
-    It generates JSON text by events to an output os.
-
-    User may programmatically calls the functions of a writer to generate JSON text.
-
-    On the other side, a writer can also be passed to objects that generates events, 
-
-    for example Reader::Parse() and Document::Accept().
-
-    \tparam OutputStream Type of output stream.
-    \tparam SourceEncoding Encoding of source string.
-    \tparam TargetEncoding Encoding of output stream.
-    \tparam StackAllocator Type of allocator for allocating memory of stack.
-    \note implements Handler concept
-*/
-template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator>
-class Writer {
-public:
-    typedef typename SourceEncoding::Ch Ch;
-
-    //! Constructor
-    /*! \param os Output stream.
-        \param stackAllocator User supplied allocator. If it is null, it will create a private one.
-        \param levelDepth Initial capacity of stack.
-    */
-    explicit
-    Writer(OutputStream& os, StackAllocator* stackAllocator = 0, size_t levelDepth = kDefaultLevelDepth) : 
-        os_(&os), level_stack_(stackAllocator, levelDepth * sizeof(Level)), hasRoot_(false) {}
-
-    explicit
-    Writer(StackAllocator* allocator = 0, size_t levelDepth = kDefaultLevelDepth) :
-        os_(0), level_stack_(allocator, levelDepth * sizeof(Level)), hasRoot_(false) {}
-
-    //! Reset the writer with a new stream.
-    /*!
-        This function reset the writer with a new stream and default settings,
-        in order to make a Writer object reusable for output multiple JSONs.
-
-        \param os New output stream.
-        \code
-        Writer<OutputStream> writer(os1);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-
-        writer.Reset(os2);
-        writer.StartObject();
-        // ...
-        writer.EndObject();
-        \endcode
-    */
-    void Reset(OutputStream& os) {
-        os_ = &os;
-        hasRoot_ = false;
-        level_stack_.Clear();
-    }
-
-    //! Checks whether the output is a complete JSON.
-    /*!
-        A complete JSON has a complete root object or array.
-    */
-    bool IsComplete() const {
-        return hasRoot_ && level_stack_.Empty();
-    }
-
-    /*!@name Implementation of Handler
-        \see Handler
-    */
-    //@{
-
-    bool Null()                 { Prefix(kNullType);   return WriteNull(); }
-    bool Bool(bool b)           { Prefix(b ? kTrueType : kFalseType); return WriteBool(b); }
-    bool Int(int i)             { Prefix(kNumberType); return WriteInt(i); }
-    bool Uint(unsigned u)       { Prefix(kNumberType); return WriteUint(u); }
-    bool Int64(int64_t i64)     { Prefix(kNumberType); return WriteInt64(i64); }
-    bool Uint64(uint64_t u64)   { Prefix(kNumberType); return WriteUint64(u64); }
-
-    //! Writes the given \c double value to the stream
-    /*!
-        \param d The value to be written.
-        \return Whether it is succeed.
-    */
-    bool Double(double d)       { Prefix(kNumberType); return WriteDouble(d); }
-
-    bool String(const Ch* str, SizeType length, bool copy = false) {
-        (void)copy;
-        Prefix(kStringType);
-        return WriteString(str, length);
-    }
-
-#if RAPIDJSON_HAS_STDSTRING
-    bool String(const std::basic_string<Ch>& str) {
-      return String(str.data(), SizeType(str.size()));
-    }
-#endif
-
-    bool StartObject() {
-        Prefix(kObjectType);
-        new (level_stack_.template Push<Level>()) Level(false);
-        return WriteStartObject();
-    }
-
-    bool Key(const Ch* str, SizeType length, bool copy = false) { return String(str, length, copy); }
-	
-    bool EndObject(SizeType memberCount = 0) {
-        (void)memberCount;
-        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
-        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
-        level_stack_.template Pop<Level>(1);
-        bool ret = WriteEndObject();
-        if (level_stack_.Empty())   // end of json text
-            os_->Flush();
-        return ret;
-    }
-
-    bool StartArray() {
-        Prefix(kArrayType);
-        new (level_stack_.template Push<Level>()) Level(true);
-        return WriteStartArray();
-    }
-
-    bool EndArray(SizeType elementCount = 0) {
-        (void)elementCount;
-        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
-        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
-        level_stack_.template Pop<Level>(1);
-        bool ret = WriteEndArray();
-        if (level_stack_.Empty())   // end of json text
-            os_->Flush();
-        return ret;
-    }
-    //@}
-
-    /*! @name Convenience extensions */
-    //@{
-
-    //! Simpler but slower overload.
-    bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
-    bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
-
-    //@}
-
-protected:
-    //! Information for each nested level
-    struct Level {
-        Level(bool inArray_) : valueCount(0), inArray(inArray_) {}
-        size_t valueCount;  //!< number of values in this level
-        bool inArray;       //!< true if in array, otherwise in object
-    };
-
-    static const size_t kDefaultLevelDepth = 32;
-
-    bool WriteNull()  {
-        os_->Put('n'); os_->Put('u'); os_->Put('l'); os_->Put('l'); return true;
-    }
-
-    bool WriteBool(bool b)  {
-        if (b) {
-            os_->Put('t'); os_->Put('r'); os_->Put('u'); os_->Put('e');
-        }
-        else {
-            os_->Put('f'); os_->Put('a'); os_->Put('l'); os_->Put('s'); os_->Put('e');
-        }
-        return true;
-    }
-
-    bool WriteInt(int i) {
-        char buffer[11];
-        const char* end = internal::i32toa(i, buffer);
-        for (const char* p = buffer; p != end; ++p)
-            os_->Put(*p);
-        return true;
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        const char* end = internal::u32toa(u, buffer);
-        for (const char* p = buffer; p != end; ++p)
-            os_->Put(*p);
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        char buffer[21];
-        const char* end = internal::i64toa(i64, buffer);
-        for (const char* p = buffer; p != end; ++p)
-            os_->Put(*p);
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char* end = internal::u64toa(u64, buffer);
-        for (char* p = buffer; p != end; ++p)
-            os_->Put(*p);
-        return true;
-    }
-
-    bool WriteDouble(double d) {
-        char buffer[25];
-        char* end = internal::dtoa(d, buffer);
-        for (char* p = buffer; p != end; ++p)
-            os_->Put(*p);
-        return true;
-    }
-
-    bool WriteString(const Ch* str, SizeType length)  {
-        static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-        static const char escape[256] = {
-#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
-            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
-              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
-            Z16, Z16,                                                                       // 30~4F
-              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
-            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
-#undef Z16
-        };
-
-        os_->Put('\"');
-        GenericStringStream<SourceEncoding> is(str);
-        while (is.Tell() < length) {
-            const Ch c = is.Peek();
-            if (!TargetEncoding::supportUnicode && (unsigned)c >= 0x80) {
-                // Unicode escaping
-                unsigned codepoint;
-                if (!SourceEncoding::Decode(is, &codepoint))
-                    return false;
-                os_->Put('\\');
-                os_->Put('u');
-                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
-                    os_->Put(hexDigits[(codepoint >> 12) & 15]);
-                    os_->Put(hexDigits[(codepoint >>  8) & 15]);
-                    os_->Put(hexDigits[(codepoint >>  4) & 15]);
-                    os_->Put(hexDigits[(codepoint      ) & 15]);
-                }
-                else if (codepoint >= 0x010000 && codepoint <= 0x10FFFF)    {
-                    // Surrogate pair
-                    unsigned s = codepoint - 0x010000;
-                    unsigned lead = (s >> 10) + 0xD800;
-                    unsigned trail = (s & 0x3FF) + 0xDC00;
-                    os_->Put(hexDigits[(lead >> 12) & 15]);
-                    os_->Put(hexDigits[(lead >>  8) & 15]);
-                    os_->Put(hexDigits[(lead >>  4) & 15]);
-                    os_->Put(hexDigits[(lead      ) & 15]);
-                    os_->Put('\\');
-                    os_->Put('u');
-                    os_->Put(hexDigits[(trail >> 12) & 15]);
-                    os_->Put(hexDigits[(trail >>  8) & 15]);
-                    os_->Put(hexDigits[(trail >>  4) & 15]);
-                    os_->Put(hexDigits[(trail      ) & 15]);                    
-                }
-                else
-                    return false;   // invalid code point
-            }
-            else if ((sizeof(Ch) == 1 || (unsigned)c < 256) && escape[(unsigned char)c])  {
-                is.Take();
-                os_->Put('\\');
-                os_->Put(escape[(unsigned char)c]);
-                if (escape[(unsigned char)c] == 'u') {
-                    os_->Put('0');
-                    os_->Put('0');
-                    os_->Put(hexDigits[(unsigned char)c >> 4]);
-                    os_->Put(hexDigits[(unsigned char)c & 0xF]);
-                }
-            }
-            else
-                Transcoder<SourceEncoding, TargetEncoding>::Transcode(is, *os_);
-        }
-        os_->Put('\"');
-        return true;
-    }
-
-    bool WriteStartObject() { os_->Put('{'); return true; }
-    bool WriteEndObject()   { os_->Put('}'); return true; }
-    bool WriteStartArray()  { os_->Put('['); return true; }
-    bool WriteEndArray()    { os_->Put(']'); return true; }
-
-    void Prefix(Type type) {
-        (void)type;
-        if (level_stack_.GetSize() != 0) { // this value is not at root
-            Level* level = level_stack_.template Top<Level>();
-            if (level->valueCount > 0) {
-                if (level->inArray) 
-                    os_->Put(','); // add comma if it is not the first element in array
-                else  // in object
-                    os_->Put((level->valueCount % 2 == 0) ? ',' : ':');
-            }
-            if (!level->inArray && level->valueCount % 2 == 0)
-                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
-            level->valueCount++;
-        }
-        else {
-            RAPIDJSON_ASSERT(!hasRoot_);    // Should only has one and only one root.
-            hasRoot_ = true;
-        }
-    }
-
-    OutputStream* os_;
-    internal::Stack<StackAllocator> level_stack_;
-    bool hasRoot_;
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    Writer(const Writer&);
-    Writer& operator=(const Writer&);
-};
-
-// Full specialization for StringStream to prevent memory copying
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt(int i) {
-    char *buffer = os_->Push(11);
-    const char* end = internal::i32toa(i, buffer);
-    os_->Pop(11 - (end - buffer));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
-    char *buffer = os_->Push(10);
-    const char* end = internal::u32toa(u, buffer);
-    os_->Pop(10 - (end - buffer));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
-    char *buffer = os_->Push(21);
-    const char* end = internal::i64toa(i64, buffer);
-    os_->Pop(21 - (end - buffer));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
-    char *buffer = os_->Push(20);
-    const char* end = internal::u64toa(u, buffer);
-    os_->Pop(20 - (end - buffer));
-    return true;
-}
-
-template<>
-inline bool Writer<StringBuffer>::WriteDouble(double d) {
-    char *buffer = os_->Push(25);
-    char* end = internal::dtoa(d, buffer);
-    os_->Pop(25 - (end - buffer));
-    return true;
-}
-
-RAPIDJSON_NAMESPACE_END
-
-#ifdef _MSC_VER
-RAPIDJSON_DIAG_POP
-#endif
-
-#endif // RAPIDJSON_RAPIDJSON_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/license.txt b/third_party/socket.io-client-cpp/lib/rapidjson/license.txt
deleted file mode 100644
index fba5ec2..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/license.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (C) 2011 Milo Yip
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/readme.md b/third_party/socket.io-client-cpp/lib/rapidjson/readme.md
deleted file mode 100644
index 72abc8b..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/readme.md
+++ /dev/null
@@ -1,119 +0,0 @@
-![](doc/logo/rapidjson.png)
-## A fast JSON parser/generator for C++ with both SAX/DOM style API 
-
-Copyright (c) 2011-2014 Milo Yip (miloyip@gmail.com)
-
-* [RapidJSON GitHub](https://github.com/miloyip/rapidjson/)
-* [RapidJSON Documentation](http://miloyip.github.io/rapidjson/)
-
-## Build status
-
-| [Linux][lin-link] | [Windows][win-link] |
-| :---------------: | :-----------------: |
-| ![lin-badge]      | ![win-badge]        |
-
-[lin-badge]: https://travis-ci.org/miloyip/rapidjson.png "Travis build status"
-[lin-link]:  https://travis-ci.org/miloyip/rapidjson "Travis build status"
-[win-badge]: https://ci.appveyor.com/api/projects/status/u658dcuwxo14a8m9/branch/master?svg=true "AppVeyor build status"
-[win-link]:  https://ci.appveyor.com/project/miloyip/rapidjson/branch/master "AppVeyor build status"
-
-## Introduction
-
-RapidJSON is a JSON parser and generator for C++. It was inspired by [RapidXml](http://rapidxml.sourceforge.net/).
-
-* RapidJSON is small but complete. It supports both SAX and DOM style API. The SAX parser is only a half thousand lines of code.
-
-* RapidJSON is fast. Its performance can be comparable to `strlen()`. It also optionally supports SSE2/SSE4.1 for acceleration.
-
-* RapidJSON is self-contained. It does not depend on external libraries such as BOOST. It even does not depend on STL.
-
-* RapidJSON is memory friendly. Each JSON value occupies exactly 16/20 bytes for most 32/64-bit machines (excluding text string). By default it uses a fast memory allocator, and the parser allocates memory compactly during parsing.
-
-* RapidJSON is Unicode friendly. It supports UTF-8, UTF-16, UTF-32 (LE & BE), and their detection, validation and transcoding internally. For example, you can read a UTF-8 file and let RapidJSON transcode the JSON strings into UTF-16 in the DOM. It also supports surrogates and "\u0000" (null character).
-
-More features can be read [here](doc/features.md).
-
-JSON(JavaScript Object Notation) is a light-weight data exchange format. RapidJSON should be in fully compliance with RFC7159/ECMA-404. More information about JSON can be obtained at
-* [Introducing JSON](http://json.org/)
-* [RFC7159: The JavaScript Object Notation (JSON) Data Interchange Format](http://www.ietf.org/rfc/rfc7159.txt)
-* [Standard ECMA-404: The JSON Data Interchange Format](http://www.ecma-international.org/publications/standards/Ecma-404.htm)
-
-## Compatibility
-
-RapidJSON is cross-platform. Some platform/compiler combinations which have been tested are shown as follows.
-* Visual C++ 2008/2010/2013 on Windows (32/64-bit)
-* GNU C++ 3.8.x on Cygwin
-* Clang 3.4 on Mac OS X (32/64-bit) and iOS
-* Clang 3.4 on Android NDK
-
-Users can build and run the unit tests on their platform/compiler.
-
-## Installation
-
-RapidJSON is a header-only C++ library. Just copy the `include/rapidjson` folder to system or project's include path.
-
-RapidJSON uses following software as its dependencies:
-* [CMake](http://www.cmake.org) as a general build tool
-* (optional)[Doxygen](http://www.doxygen.org) to build documentation
-* (optional)[googletest](https://code.google.com/p/googletest/) for unit and performance testing
-
-To generate user documentation and run tests please proceed with the steps below:
-
-1. Execute `git submodule update --init` to get the files of thirdparty submodules (google test).
-2. Create directory called `build` in rapidjson source directory.
-3. Change to `build` directory and run `cmake ..` command to configure your build. Windows users can do the same with cmake-gui application.
-4. On Windows, build the solution found in the build directory. On Linux, run `make` from the build directory.
-
-On successfull build you will find compiled test and example binaries in `bin`
-directory. The generated documentation will be available in `doc/html`
-directory of the build tree. To run tests after finished build please run `make
-test` or `ctest` from your build tree. You can get detailed output using `ctest
--V` command.
-
-It is possible to install library system-wide by running `make install` command
-from the build tree with administrative privileges. This will install all files
-according to system preferences.  Once RapidJSON is installed, it is possible
-to use it from other CMake projects by adding `find_package(RapidJSON)` line to
-your CMakeLists.txt.
-
-## Usage at a glance
-
-This simple example parses a JSON string into a document (DOM), make a simple modification of the DOM, and finally stringify the DOM to a JSON string.
-
-~~~~~~~~~~cpp
-// rapidjson/example/simpledom/simpledom.cpp`
-#include "rapidjson/document.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-#include <iostream>
-
-using namespace rapidjson;
-
-int main() {
-    // 1. Parse a JSON string into DOM.
-    const char* json = "{\"project\":\"rapidjson\",\"stars\":10}";
-    Document d;
-    d.Parse(json);
-
-    // 2. Modify it by DOM.
-    Value& s = d["stars"];
-    s.SetInt(s.GetInt() + 1);
-
-    // 3. Stringify the DOM
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    d.Accept(writer);
-
-    // Output {"project":"rapidjson","stars":11}
-    std::cout << buffer.GetString() << std::endl;
-    return 0;
-}
-~~~~~~~~~~
-
-Note that this example did not handle potential errors.
-
-The following diagram shows the process.
-
-![simpledom](doc/diagram/simpledom.png)
-
-More [examples](https://github.com/miloyip/rapidjson/tree/master/example) are available.
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/test/CMakeLists.txt
deleted file mode 100644
index c698af4..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/CMakeLists.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-find_package(GTestSrc)
-
-IF(GTESTSRC_FOUND)
-    enable_testing()
-
-    if (WIN32 AND (NOT CYGWIN) AND (NOT MINGW))
-        set(gtest_disable_pthreads ON)
-        set(gtest_force_shared_crt ON)
-    endif()
-
-    add_subdirectory(${GTEST_SOURCE_DIR} ${CMAKE_BINARY_DIR}/googletest)
-    include_directories(${GTEST_INCLUDE_DIR})
-
-    set(TEST_LIBRARIES gtest gtest_main)
-
-    add_custom_target(tests ALL)
-    add_subdirectory(perftest)
-    add_subdirectory(unittest)
-
-ENDIF(GTESTSRC_FOUND)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/CMakeLists.txt
deleted file mode 100644
index 4121bf9..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-set(PERFTEST_SOURCES
-    misctest.cpp
-    perftest.cpp
-    platformtest.cpp
-    rapidjsontest.cpp)
-
-add_executable(perftest ${PERFTEST_SOURCES})
-target_link_libraries(perftest ${TEST_LIBRARIES})
-
-add_dependencies(tests perftest)
-
-IF(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug"))
-add_test(NAME perftest
-    COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/perftest
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
-ENDIF()
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/misctest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/misctest.cpp
deleted file mode 100644
index 3edadda..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/misctest.cpp
+++ /dev/null
@@ -1,980 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "perftest.h"
-
-#if TEST_MISC
-
-#define __STDC_FORMAT_MACROS
-#include "rapidjson/stringbuffer.h"
-
-#define protected public
-#include "rapidjson/writer.h"
-#undef private
-
-class Misc : public PerfTest {
-};
-
-// Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
-
-#define UTF8_ACCEPT 0
-#define UTF8_REJECT 12
-
-static const unsigned char utf8d[] = {
-    // The first part of the table maps bytes to character classes that
-    // to reduce the size of the transition table and create bitmasks.
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-    10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-
-    // The second part is a transition table that maps a combination
-    // of a state of the automaton and a character class to a state.
-    0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
-    12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
-    12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
-    12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
-    12,36,12,12,12,12,12,12,12,12,12,12, 
-};
-
-static unsigned inline decode(unsigned* state, unsigned* codep, unsigned byte) {
-    unsigned type = utf8d[byte];
-
-    *codep = (*state != UTF8_ACCEPT) ?
-        (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
-
-    *state = utf8d[256 + *state + type];
-    return *state;
-}
-
-static bool IsUTF8(unsigned char* s) {
-    unsigned codepoint, state = 0;
-
-    while (*s)
-        decode(&state, &codepoint, *s++);
-
-    return state == UTF8_ACCEPT;
-}
-
-TEST_F(Misc, Hoehrmann_IsUTF8) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        EXPECT_TRUE(IsUTF8((unsigned char*)json_));
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// CountDecimalDigit: Count number of decimal places
-
-inline unsigned CountDecimalDigit_naive(unsigned n) {
-    unsigned count = 1;
-    while (n >= 10) {
-        n /= 10;
-        count++;
-    }
-    return count;
-}
-
-inline unsigned CountDecimalDigit_enroll4(unsigned n) {
-    unsigned count = 1;
-    while (n >= 10000) {
-        n /= 10000u;
-        count += 4;
-    }
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    return count + 3;
-}
-
-inline unsigned CountDecimalDigit64_enroll4(uint64_t n) {
-    unsigned count = 1;
-    while (n >= 10000) {
-        n /= 10000u;
-        count += 4;
-    }
-    if (n < 10) return count;
-    if (n < 100) return count + 1;
-    if (n < 1000) return count + 2;
-    return count + 3;
-}
-
-inline unsigned CountDecimalDigit_fast(unsigned n) {
-    static const uint32_t powers_of_10[] = {
-        0,
-        10,
-        100,
-        1000,
-        10000,
-        100000,
-        1000000,
-        10000000,
-        100000000,
-        1000000000
-    };
-
-#if defined(_M_IX86) || defined(_M_X64)
-    unsigned long i = 0;
-    _BitScanReverse(&i, n | 1);
-    uint32_t t = (i + 1) * 1233 >> 12;
-#elif defined(__GNUC__)
-    uint32_t t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
-#else
-#error
-#endif
-    return t - (n < powers_of_10[t]) + 1;
-}
-
-inline unsigned CountDecimalDigit64_fast(uint64_t n) {
-    static const uint64_t powers_of_10[] = {
-        0,
-        10,
-        100,
-        1000,
-        10000,
-        100000,
-        1000000,
-        10000000,
-        100000000,
-        1000000000,
-        10000000000,
-        100000000000,
-        1000000000000,
-        10000000000000,
-        100000000000000,
-        1000000000000000,
-        10000000000000000,
-        100000000000000000,
-        1000000000000000000,
-        10000000000000000000U
-    };
-
-#if defined(_M_IX86)
-    uint64_t m = n | 1;
-    unsigned long i = 0;
-    if (_BitScanReverse(&i, m >> 32))
-        i += 32;
-    else
-        _BitScanReverse(&i, m & 0xFFFFFFFF);
-    uint32_t t = (i + 1) * 1233 >> 12;
-#elif defined(_M_X64)
-    unsigned long i = 0;
-    _BitScanReverse64(&i, n | 1);
-    uint32_t t = (i + 1) * 1233 >> 12;
-#elif defined(__GNUC__)
-    uint32_t t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12;
-#else
-#error
-#endif
-
-    return t - (n < powers_of_10[t]) + 1;
-}
-
-#if 0
-// Exhaustive, very slow
-TEST_F(Misc, CountDecimalDigit_Verify) {
-    unsigned i = 0;
-    do {
-        if (i % (65536 * 256) == 0)
-            printf("%u\n", i);
-        ASSERT_EQ(CountDecimalDigit_enroll4(i), CountDecimalDigit_fast(i));
-        i++;
-    } while (i != 0);
-}
-
-static const unsigned kDigits10Trial = 1000000000u;
-TEST_F(Misc, CountDecimalDigit_naive) {
-    unsigned sum = 0;
-    for (unsigned i = 0; i < kDigits10Trial; i++)
-        sum += CountDecimalDigit_naive(i);
-    printf("%u\n", sum);
-}
-
-TEST_F(Misc, CountDecimalDigit_enroll4) {
-    unsigned sum = 0;
-    for (unsigned i = 0; i < kDigits10Trial; i++)
-        sum += CountDecimalDigit_enroll4(i);
-    printf("%u\n", sum);
-}
-
-TEST_F(Misc, CountDecimalDigit_fast) {
-    unsigned sum = 0;
-    for (unsigned i = 0; i < kDigits10Trial; i++)
-        sum += CountDecimalDigit_fast(i);
-    printf("%u\n", sum);
-}
-#endif
-
-TEST_F(Misc, CountDecimalDigit64_VerifyFast) {
-    uint64_t i = 1, j;
-    do {
-        //printf("%" PRIu64 "\n", i);
-        ASSERT_EQ(CountDecimalDigit64_enroll4(i), CountDecimalDigit64_fast(i));
-        j = i;
-        i *= 3;
-    } while (j < i);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// integer-to-string conversion
-
-// https://gist.github.com/anonymous/7179097
-static const int randval[] ={
-     936116,  369532,  453755,  -72860,  209713,  268347,  435278, -360266, -416287, -182064,
-    -644712,  944969,  640463, -366588,  471577,  -69401, -744294, -505829,  923883,  831785,
-    -601136, -636767, -437054,  591718,  100758,  231907, -719038,  973540, -605220,  506659,
-    -871653,  462533,  764843, -919138,  404305, -630931, -288711, -751454, -173726, -718208,
-     432689, -281157,  360737,  659827,   19174, -376450,  769984, -858198,  439127,  734703,
-    -683426,       7,  386135,  186997, -643900, -744422, -604708, -629545,   42313, -933592,
-    -635566,  182308,  439024, -367219,  -73924, -516649,  421935, -470515,  413507,  -78952,
-    -427917, -561158,  737176,   94538,  572322,  405217,  709266, -357278, -908099, -425447,
-     601119,  750712, -862285, -177869,  900102,  384877,  157859, -641680,  503738, -702558,
-     278225,  463290,  268378, -212840,  580090,  347346, -473985, -950968, -114547, -839893,
-    -738032, -789424,  409540,  493495,  432099,  119755,  905004, -174834,  338266,  234298,
-      74641, -965136, -754593,  685273,  466924,  920560,  385062,  796402,  -67229,  994864,
-     376974,  299869, -647540, -128724,  469890, -163167, -547803, -743363,  486463, -621028,
-     612288,   27459, -514224,  126342,  -66612,  803409, -777155, -336453, -284002,  472451,
-     342390, -163630,  908356, -456147, -825607,  268092, -974715,  287227,  227890, -524101,
-     616370, -782456,  922098, -624001, -813690,  171605, -192962,  796151,  707183,  -95696,
-     -23163, -721260,  508892,  430715,  791331,  482048, -996102,  863274,  275406,   -8279,
-    -556239, -902076,  268647, -818565,  260069, -798232, -172924, -566311, -806503, -885992,
-     813969,  -78468,  956632,  304288,  494867, -508784,  381751,  151264,  762953,   76352,
-     594902,  375424,  271700, -743062,  390176,  924237,  772574,  676610,  435752, -153847,
-       3959, -971937, -294181, -538049, -344620, -170136,   19120, -703157,  868152, -657961,
-    -818631,  219015, -872729, -940001, -956570,  880727, -345910,  942913, -942271, -788115,
-     225294,  701108, -517736, -416071,  281940,  488730,  942698,  711494,  838382, -892302,
-    -533028,  103052,  528823,  901515,  949577,  159364,  718227, -241814, -733661, -462928,
-    -495829,  165170,  513580, -629188, -509571, -459083,  198437,   77198, -644612,  811276,
-    -422298, -860842,  -52584,  920369,  686424, -530667, -243476,   49763,  345866, -411960,
-    -114863,  470810, -302860,  683007, -509080,       2, -174981, -772163,  -48697,  447770,
-    -268246,  213268,  269215,   78810, -236340, -639140, -864323,  505113, -986569, -325215,
-     541859,  163070, -819998, -645161, -583336,  573414,  696417, -132375,       3, -294501,
-     320435,  682591,  840008,  351740,  426951,  609354,  898154, -943254,  227321, -859793,
-    -727993,   44137, -497965, -782239,   14955, -746080, -243366,    9837, -233083,  606507,
-    -995864, -615287, -994307,  602715,  770771, -315040,  610860,  446102, -307120,  710728,
-    -590392, -230474, -762625, -637525,  134963, -202700, -766902, -985541,  218163,  682009,
-     926051,  525156,  -61195,  403211, -810098,  245539, -431733,  179998, -806533,  745943,
-     447597,  131973, -187130,  826019,  286107, -937230, -577419,   20254,  681802, -340500,
-     323080,  266283, -667617,  309656,  416386,  611863,  759991, -534257,  523112, -634892,
-    -169913, -204905, -909867, -882185, -944908,  741811, -717675,  967007, -317396,  407230,
-    -412805,  792905,  994873,  744793, -456797,  713493,  355232,  116900, -945199,  880539,
-     342505, -580824, -262273,  982968, -349497, -735488,  311767, -455191,  570918,  389734,
-    -958386,   10262,  -99267,  155481,  304210,  204724,  704367, -144893, -233664, -671441,
-     896849,  408613,  762236,  322697,  981321,  688476,   13663, -970704, -379507,  896412,
-     977084,  348869,  875948,  341348,  318710,  512081,    6163,  669044,  833295,  811883,
-     708756, -802534, -536057,  608413, -389625, -694603,  541106, -110037,  720322, -540581,
-     645420,   32980,   62442,  510157, -981870,  -87093, -325960, -500494, -718291,  -67889,
-     991501,  374804,  769026, -978869,  294747,  714623,  413327, -199164,  671368,  804789,
-    -362507,  798196, -170790, -568895, -869379,   62020, -316693, -837793,  644994,  -39341,
-    -417504, -243068, -957756,   99072,  622234, -739992,  225668,    8863, -505910,   82483,
-    -559244,  241572,    1315,  -36175,  -54990,  376813,     -11,  162647, -688204, -486163,
-     -54934, -197470,  744223, -762707,  732540,  996618,  351561, -445933, -898491,  486531,
-     456151,   15276,  290186, -817110,  -52995,  313046, -452533,  -96267,   94470, -500176,
-    -818026, -398071, -810548, -143325, -819741,    1338, -897676, -101577, -855445,   37309,
-     285742,  953804, -777927, -926962, -811217, -936744, -952245, -802300, -490188, -964953,
-    -552279,  329142, -570048, -505756,  682898, -381089,  -14352,  175138,  152390, -582268,
-    -485137,  717035,  805329,  239572, -730409,  209643, -184403, -385864,  675086,  819648,
-     629058, -527109, -488666, -171981,  532788,  552441,  174666,  984921,  766514,  758787,
-     716309,  338801, -978004, -412163,  876079, -734212,  789557, -160491, -522719,   56644,
-       -991, -286038,  -53983,  663740,  809812,  919889, -717502, -137704,  220511,  184396,
-    -825740, -588447,  430870,  124309,  135956,  558662, -307087, -788055, -451328,  812260,
-     931601,  324347, -482989, -117858, -278861,  189068, -172774,  929057,  293787,  198161,
-    -342386,  -47173,  906555, -759955,  -12779,  777604,  -97869,  899320,  927486,  -25284,
-    -848550,  259450, -485856,  -17820,      88,  171400,  235492, -326783, -340793,  886886,
-     112428, -246280,    5979,  648444, -114982,  991013,  -56489,   -9497,  419706,  632820,
-    -341664,  393926, -848977,  -22538,  257307,  773731, -905319,  491153,  734883, -868212,
-    -951053,  644458, -580758,  764735,  584316,  297077,   28852, -397710, -953669,  201772,
-     879050, -198237, -588468,  448102, -116837,  770007, -231812,  642906, -582166, -885828,
-          9,  305082, -996577,  303559,   75008, -772956, -447960,  599825, -295552,  870739,
-    -386278, -950300,  485359, -457081,  629461, -850276,  550496, -451755, -620841,  -11766,
-    -950137,  832337,   28711, -273398, -507197,   91921, -271360, -705991, -753220, -388968,
-     967945,  340434, -320883, -662793, -554617, -574568,  477946,   -6148, -129519,  689217,
-     920020, -656315, -974523, -212525,   80921, -612532,  645096,  545655,  655713, -591631,
-    -307385, -816688, -618823, -113713,  526430,  673063,  735916, -809095, -850417,  639004,
-     432281, -388185,  270708,  860146,  -39902, -786157, -258180, -246169, -966720, -264957,
-     548072, -306010,  -57367, -635665,  933824,   70553, -989936, -488741,   72411, -452509,
-     529831,  956277,  449019, -577850, -360986, -803418,   48833,  296073,  203430,  609591,
-     715483,  470964,  658106, -718254,  -96424,  790163,  334739,  181070, -373578,       5,
-    -435088,  329841,  330939, -256602,  394355,  912412,  231910,  927278, -661933,  788539,
-    -769664, -893274,  -96856,  298205,  901043, -608122, -527430,  183618, -553963,  -35246,
-    -393924,  948832, -483198,  594501,   35460, -407007,   93494, -336881, -634072,  984205,
-    -812161,  944664,  -31062,  753872,  823933,  -69566,   50445,  290147,   85134,   34706,
-     551902,  405202, -991246,  -84642,  154341,  316432, -695101, -651588,   -5030,  137564,
-    -294665,  332541,  528307,  -90572, -344923,  523766, -758498, -968047,  339028,  494578,
-     593129, -725773,   31834, -718406, -208638,  159665,   -2043,  673344, -442767,   75816,
-     755442,  769257, -158730, -410272,  691688,  589550, -878398, -184121,  460679,  346312,
-     294163, -544602,  653308,  254167, -276979,   52073, -892684,  887653,  -41222,  983065,
-     -68258, -408799,  -99069, -674069, -863635,  -32890,  622757, -743862,   40872,   -4837,
-    -967228,  522370, -903951, -818669,  524459,  514702,  925801,   20007, -299229,  579348,
-     626021,  430089,  348139, -562692, -607728, -130606, -928451, -424793, -458647, -448892,
-    -312230,  143337,  109746,  880042, -339658, -785614,  938995,  540916,  118429,  661351,
-    -402967,  404729,  -40918, -976535,  743230,  713110,  440182, -381314, -499252,   74613,
-     193652,  912717,  491323,  583633,  324691,  459397,  281253,  195540,   -2764, -888651,
-     892449,  132663, -478373, -430002, -314551,  527826,  247165,  557966,  554778,  481531,
-    -946634,  431685, -769059, -348371,  174046,  184597, -354867,  584422,  227390, -850397,
-    -542924, -849093, -737769,  325359,  736314,  269101,  767940,  674809,   81413, -447458,
-     445076,  189072,  906218,  502688, -718476, -863827, -731381,  100660,  623249,  710008,
-     572060,  922203,  685740,   55096,  263394, -243695, -353910, -516788,  388471,  455165,
-     844103, -643772,  363976,  268875, -899450,  104470,  104029, -238874, -274659,  732969,
-    -676443,  953291, -916289, -861849, -242344,  958083, -479593, -970395,  799831,  277841,
-    -243236, -283462, -201510,  166263, -259105, -575706,  878926,  891064,  895297,  655262,
-     -34807, -809833,  -89281,  342585,  554920,       1,  902141, -333425,  139703,  852318,
-    -618438,  329498, -932596, -692836, -513372,  733656, -523411,   85779,  500478, -682697,
-    -502836,  138776,  156341, -420037, -557964, -556378,  710993,  -50383, -877159,  916334,
-     132996,  583516, -603392, -111615,  -12288, -780214,  476780,  123327,  137607,  519956,
-     745837,   17358, -158581,  -53490
-};
-static const size_t randvalCount = sizeof(randval) / sizeof(randval[0]);
-static const size_t kItoaTrialCount = 10000;
-
-static const char digits[201] =
-"0001020304050607080910111213141516171819"
-"2021222324252627282930313233343536373839"
-"4041424344454647484950515253545556575859"
-"6061626364656667686970717273747576777879"
-"8081828384858687888990919293949596979899";
-
-// Prevent code being optimized out
-//#define OUTPUT_LENGTH(length) printf("", length)
-#define OUTPUT_LENGTH(length) printf("%u\n", (unsigned)length)
-
-template<typename OutputStream>
-class Writer1 {
-public:
-    Writer1() : os_() {}
-    Writer1(OutputStream& os) : os_(&os) {}
-
-    void Reset(OutputStream& os) {
-        os_ = &os;
-    }
-
-    bool WriteInt(int i) {
-        if (i < 0) {
-            os_->Put('-');
-            i = -i;
-        }
-        return WriteUint((unsigned)i);
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        char *p = buffer;
-        do {
-            *p++ = char(u % 10) + '0';
-            u /= 10;
-        } while (u > 0);
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        if (i64 < 0) {
-            os_->Put('-');
-            i64 = -i64;
-        }
-        WriteUint64((uint64_t)i64);
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char *p = buffer;
-        do {
-            *p++ = char(u64 % 10) + '0';
-            u64 /= 10;
-        } while (u64 > 0);
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-private:
-    OutputStream* os_;
-};
-
-template<>
-bool Writer1<rapidjson::StringBuffer>::WriteUint(unsigned u) {
-    char buffer[10];
-    char* p = buffer;
-    do {
-        *p++ = char(u % 10) + '0';
-        u /= 10;
-    } while (u > 0);
-
-    char* d = os_->Push(p - buffer);
-    do {
-        --p;
-        *d++ = *p;
-    } while (p != buffer);
-    return true;
-}
-
-// Using digits LUT to reduce divsion/modulo
-template<typename OutputStream>
-class Writer2 {
-public:
-    Writer2() : os_() {}
-    Writer2(OutputStream& os) : os_(&os) {}
-
-    void Reset(OutputStream& os) {
-        os_ = &os;
-    }
-
-    bool WriteInt(int i) {
-        if (i < 0) {
-            os_->Put('-');
-            i = -i;
-        }
-        return WriteUint((unsigned)i);
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        char* p = buffer;
-        while (u >= 100) {
-            const unsigned i = (u % 100) << 1;
-            u /= 100;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-        if (u < 10)
-            *p++ = char(u) + '0';
-        else {
-            const unsigned i = u << 1;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        if (i64 < 0) {
-            os_->Put('-');
-            i64 = -i64;
-        }
-        WriteUint64((uint64_t)i64);
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char* p = buffer;
-        while (u64 >= 100) {
-            const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
-            u64 /= 100;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-        if (u64 < 10)
-            *p++ = char(u64) + '0';
-        else {
-            const unsigned i = static_cast<unsigned>(u64) << 1;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-private:
-    OutputStream* os_;
-};
-
-// First pass to count digits
-template<typename OutputStream>
-class Writer3 {
-public:
-    Writer3() : os_() {}
-    Writer3(OutputStream& os) : os_(&os) {}
-
-    void Reset(OutputStream& os) {
-        os_ = &os;
-    }
-
-    bool WriteInt(int i) {
-        if (i < 0) {
-            os_->Put('-');
-            i = -i;
-        }
-        return WriteUint((unsigned)i);
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        char *p = buffer;
-        do {
-            *p++ = char(u % 10) + '0';
-            u /= 10;
-        } while (u > 0);
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        if (i64 < 0) {
-            os_->Put('-');
-            i64 = -i64;
-        }
-        WriteUint64((uint64_t)i64);
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char *p = buffer;
-        do {
-            *p++ = char(u64 % 10) + '0';
-            u64 /= 10;
-        } while (u64 > 0);
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-private:
-    void WriteUintReverse(char* d, unsigned u) {
-        do {
-            *--d = char(u % 10) + '0';
-            u /= 10;
-        } while (u > 0);
-    }
-
-    void WriteUint64Reverse(char* d, uint64_t u) {
-        do {
-            *--d = char(u % 10) + '0';
-            u /= 10;
-        } while (u > 0);
-    }
-
-    OutputStream* os_;
-};
-
-template<>
-inline bool Writer3<rapidjson::StringBuffer>::WriteUint(unsigned u) {
-    unsigned digit = CountDecimalDigit_fast(u);
-    WriteUintReverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer3<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
-    unsigned digit = CountDecimalDigit_fast(u);
-    WriteUintReverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer3<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
-    unsigned digit = CountDecimalDigit64_fast(u);
-    WriteUint64Reverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer3<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
-    unsigned digit = CountDecimalDigit64_fast(u);
-    WriteUint64Reverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-// Using digits LUT to reduce divsion/modulo, two passes
-template<typename OutputStream>
-class Writer4 {
-public:
-    Writer4() : os_() {}
-    Writer4(OutputStream& os) : os_(&os) {}
-
-    void Reset(OutputStream& os) {
-        os_ = &os;
-    }
-
-    bool WriteInt(int i) {
-        if (i < 0) {
-            os_->Put('-');
-            i = -i;
-        }
-        return WriteUint((unsigned)i);
-    }
-
-    bool WriteUint(unsigned u) {
-        char buffer[10];
-        char* p = buffer;
-        while (u >= 100) {
-            const unsigned i = (u % 100) << 1;
-            u /= 100;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-        if (u < 10)
-            *p++ = char(u) + '0';
-        else {
-            const unsigned i = u << 1;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-    bool WriteInt64(int64_t i64) {
-        if (i64 < 0) {
-            os_->Put('-');
-            i64 = -i64;
-        }
-        WriteUint64((uint64_t)i64);
-        return true;
-    }
-
-    bool WriteUint64(uint64_t u64) {
-        char buffer[20];
-        char* p = buffer;
-        while (u64 >= 100) {
-            const unsigned i = static_cast<unsigned>(u64 % 100) << 1;
-            u64 /= 100;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-        if (u64 < 10)
-            *p++ = char(u64) + '0';
-        else {
-            const unsigned i = static_cast<unsigned>(u64) << 1;
-            *p++ = digits[i + 1];
-            *p++ = digits[i];
-        }
-
-        do {
-            --p;
-            os_->Put(*p);
-        } while (p != buffer);
-        return true;
-    }
-
-private:
-    void WriteUintReverse(char* d, unsigned u) {
-        while (u >= 100) {
-            const unsigned i = (u % 100) << 1;
-            u /= 100;
-            *--d = digits[i + 1];
-            *--d = digits[i];
-        }
-        if (u < 10) {
-            *--d = char(u) + '0';
-        }
-        else {
-            const unsigned i = u << 1;
-            *--d = digits[i + 1];
-            *--d = digits[i];
-        }
-    }
-
-    void WriteUint64Reverse(char* d, uint64_t u) {
-        while (u >= 100) {
-            const unsigned i = (u % 100) << 1;
-            u /= 100;
-            *--d = digits[i + 1];
-            *--d = digits[i];
-        }
-        if (u < 10) {
-            *--d = char(u) + '0';
-        }
-        else {
-            const unsigned i = u << 1;
-            *--d = digits[i + 1];
-            *--d = digits[i];
-        }
-    }
-
-    OutputStream* os_;
-};
-
-template<>
-inline bool Writer4<rapidjson::StringBuffer>::WriteUint(unsigned u) {
-    unsigned digit = CountDecimalDigit_fast(u);
-    WriteUintReverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer4<rapidjson::InsituStringStream>::WriteUint(unsigned u) {
-    unsigned digit = CountDecimalDigit_fast(u);
-    WriteUintReverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer4<rapidjson::StringBuffer>::WriteUint64(uint64_t u) {
-    unsigned digit = CountDecimalDigit64_fast(u);
-    WriteUint64Reverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template<>
-inline bool Writer4<rapidjson::InsituStringStream>::WriteUint64(uint64_t u) {
-    unsigned digit = CountDecimalDigit64_fast(u);
-    WriteUint64Reverse(os_->Push(digit) + digit, u);
-    return true;
-}
-
-template <typename Writer>
-void itoa_Writer_StringBufferVerify() {
-    rapidjson::StringBuffer sb;
-    Writer writer(sb);
-    for (int j = 0; j < randvalCount; j++) {
-        char buffer[32];
-        sprintf(buffer, "%d", randval[j]);
-        writer.WriteInt(randval[j]);
-        ASSERT_STREQ(buffer, sb.GetString());
-        sb.Clear();
-    }
-}
-
-template <typename Writer>
-void itoa_Writer_InsituStringStreamVerify() {
-    Writer writer;
-    for (int j = 0; j < randvalCount; j++) {
-        char buffer[32];
-        sprintf(buffer, "%d", randval[j]);
-        char buffer2[32];
-        rapidjson::InsituStringStream ss(buffer2);
-        writer.Reset(ss);
-        char* begin = ss.PutBegin();
-        writer.WriteInt(randval[j]);
-        ss.Put('\0');
-        ss.PutEnd(begin);
-        ASSERT_STREQ(buffer, buffer2);
-    }
-}
-
-template <typename Writer>
-void itoa_Writer_StringBuffer() {
-    size_t length = 0;
-
-    rapidjson::StringBuffer sb;
-    Writer writer(sb);
-
-    for (size_t i = 0; i < kItoaTrialCount; i++) {
-        for (size_t j = 0; j < randvalCount; j++) {
-            writer.WriteInt(randval[j]);
-            length += sb.GetSize();
-            sb.Clear();
-        }
-    }
-    OUTPUT_LENGTH(length);
-}
-
-template <typename Writer>
-void itoa_Writer_InsituStringStream() {
-    size_t length = 0;
-
-    char buffer[32];
-    Writer writer;
-    for (size_t i = 0; i < kItoaTrialCount; i++) {
-        for (size_t j = 0; j < randvalCount; j++) {
-            rapidjson::InsituStringStream ss(buffer);
-            writer.Reset(ss);
-            char* begin = ss.PutBegin();
-            writer.WriteInt(randval[j]);
-            length += ss.PutEnd(begin);
-        }
-    }
-    OUTPUT_LENGTH(length);
-};
-
-template <typename Writer>
-void itoa64_Writer_StringBufferVerify() {
-    rapidjson::StringBuffer sb;
-    Writer writer(sb);
-    for (size_t j = 0; j < randvalCount; j++) {
-        char buffer[32];
-        int64_t x = randval[j] * randval[j];
-        sprintf(buffer, "%" PRIi64, x);
-        writer.WriteInt64(x);
-        ASSERT_STREQ(buffer, sb.GetString());
-        sb.Clear();
-    }
-}
-
-template <typename Writer>
-void itoa64_Writer_InsituStringStreamVerify() {
-    Writer writer;
-    for (size_t j = 0; j < randvalCount; j++) {
-        char buffer[32];
-        int64_t x = randval[j] * randval[j];
-        sprintf(buffer, "%" PRIi64, x);
-        char buffer2[32];
-        rapidjson::InsituStringStream ss(buffer2);
-        writer.Reset(ss);
-        char* begin = ss.PutBegin();
-        writer.WriteInt64(x);
-        ss.Put('\0');
-        ss.PutEnd(begin);
-        ASSERT_STREQ(buffer, buffer2);
-    }
-}
-
-template <typename Writer>
-void itoa64_Writer_StringBuffer() {
-    size_t length = 0;
-
-    rapidjson::StringBuffer sb;
-    Writer writer(sb);
-
-    for (size_t i = 0; i < kItoaTrialCount; i++) {
-        for (size_t j = 0; j < randvalCount; j++) {
-            writer.WriteInt64(randval[j] * randval[j]);
-            length += sb.GetSize();
-            sb.Clear();
-        }
-    }
-    OUTPUT_LENGTH(length);
-}
-
-template <typename Writer>
-void itoa64_Writer_InsituStringStream() {
-    size_t length = 0;
-
-    char buffer[32];
-    Writer writer;
-    for (size_t i = 0; i < kItoaTrialCount; i++) {
-        for (size_t j = 0; j < randvalCount; j++) {
-            rapidjson::InsituStringStream ss(buffer);
-            writer.Reset(ss);
-            char* begin = ss.PutBegin();
-            writer.WriteInt64(randval[j] * randval[j]);
-            length += ss.PutEnd(begin);
-        }
-    }
-    OUTPUT_LENGTH(length);
-};
-
-// Full specialization for InsituStringStream to prevent memory copying 
-// (normally we will not use InsituStringStream for writing, just for testing)
-
-namespace rapidjson {
-
-template<>
-bool rapidjson::Writer<InsituStringStream>::WriteInt(int i) {
-    char *buffer = os_->Push(11);
-    const char* end = internal::i32toa(i, buffer);
-    os_->Pop(11 - (end - buffer));
-    return true;
-}
-
-template<>
-bool Writer<InsituStringStream>::WriteUint(unsigned u) {
-    char *buffer = os_->Push(10);
-    const char* end = internal::u32toa(u, buffer);
-    os_->Pop(10 - (end - buffer));
-    return true;
-}
-
-template<>
-bool Writer<InsituStringStream>::WriteInt64(int64_t i64) {
-    char *buffer = os_->Push(21);
-    const char* end = internal::i64toa(i64, buffer);
-    os_->Pop(21 - (end - buffer));
-    return true;
-}
-
-template<>
-bool Writer<InsituStringStream>::WriteUint64(uint64_t u) {
-    char *buffer = os_->Push(20);
-    const char* end = internal::u64toa(u, buffer);
-    os_->Pop(20 - (end - buffer));
-    return true;
-}
-
-} // namespace rapidjson
-
-TEST_F(Misc, itoa_Writer_StringBufferVerify) { itoa_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer1_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer2_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer3_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer4_StringBufferVerify) { itoa_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer1_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer2_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer3_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer4_InsituStringStreamVerify) { itoa_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer_StringBuffer) { itoa_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer1_StringBuffer) { itoa_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer2_StringBuffer) { itoa_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer3_StringBuffer) { itoa_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer4_StringBuffer) { itoa_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa_Writer_InsituStringStream) { itoa_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer1_InsituStringStream) { itoa_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer2_InsituStringStream) { itoa_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer3_InsituStringStream) { itoa_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa_Writer4_InsituStringStream) { itoa_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
-
-TEST_F(Misc, itoa64_Writer_StringBufferVerify) { itoa64_Writer_StringBufferVerify<rapidjson::Writer<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer1_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer1<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer2_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer2<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer3_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer3<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer4_StringBufferVerify) { itoa64_Writer_StringBufferVerify<Writer4<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer1_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer1<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer2_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer2<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer3_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer3<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer4_InsituStringStreamVerify) { itoa64_Writer_InsituStringStreamVerify<Writer4<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer_StringBuffer) { itoa64_Writer_StringBuffer<rapidjson::Writer<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer1_StringBuffer) { itoa64_Writer_StringBuffer<Writer1<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer2_StringBuffer) { itoa64_Writer_StringBuffer<Writer2<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer3_StringBuffer) { itoa64_Writer_StringBuffer<Writer3<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer4_StringBuffer) { itoa64_Writer_StringBuffer<Writer4<rapidjson::StringBuffer> >(); }
-TEST_F(Misc, itoa64_Writer_InsituStringStream) { itoa64_Writer_InsituStringStream<rapidjson::Writer<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer1_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer1<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer2_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer2<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer3_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer3<rapidjson::InsituStringStream> >(); }
-TEST_F(Misc, itoa64_Writer4_InsituStringStream) { itoa64_Writer_InsituStringStream<Writer4<rapidjson::InsituStringStream> >(); }
-
-#endif // TEST_MISC
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.cpp
deleted file mode 100644
index 4366e1c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "perftest.h"
-
-int main(int argc, char **argv) {
-#if _MSC_VER
-    _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
-    //void *testWhetherMemoryLeakDetectionWorks = malloc(1);
-#endif
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.h b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.h
deleted file mode 100644
index 2fca203..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/perftest.h
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef PERFTEST_H_
-#define PERFTEST_H_
-
-#define TEST_RAPIDJSON  1
-#define TEST_PLATFORM   0
-#define TEST_MISC       0
-
-#define TEST_VERSION_CODE(x,y,z) \
-  (((x)*100000) + ((y)*100) + (z))
-
-// __SSE2__ and __SSE4_2__ are recognized by gcc, clang, and the Intel compiler.
-// We use -march=native with gmake to enable -msse2 and -msse4.2, if supported.
-#if defined(__SSE4_2__)
-#  define RAPIDJSON_SSE42
-#elif defined(__SSE2__)
-#  define RAPIDJSON_SSE2
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// Google Test
-
-#ifdef __cplusplus
-
-// gtest indirectly included inttypes.h, without __STDC_CONSTANT_MACROS.
-#ifndef __STDC_CONSTANT_MACROS
-#  define __STDC_CONSTANT_MACROS 1 // required by C++ standard
-#endif
-
-#if defined(__clang__) || defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-#if defined(__clang__) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-#pragma GCC diagnostic push
-#endif
-#pragma GCC diagnostic ignored "-Weffc++"
-#endif
-
-#include "gtest/gtest.h"
-
-#if defined(__clang__) || defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-#pragma GCC diagnostic pop
-#endif
-
-#ifdef _MSC_VER
-#define _CRTDBG_MAP_ALLOC
-#include <crtdbg.h>
-#pragma warning(disable : 4996) // 'function': was declared deprecated
-#endif
-
-//! Base class for all performance tests
-class PerfTest : public ::testing::Test {
-public:
-    PerfTest() : filename_(), json_(), length_(), whitespace_(), whitespace_length_() {}
-
-    virtual void SetUp() {
-        FILE *fp = fopen(filename_ = "data/sample.json", "rb");
-        if (!fp) 
-            fp = fopen(filename_ = "../../bin/data/sample.json", "rb");
-        ASSERT_TRUE(fp != 0);
-
-        fseek(fp, 0, SEEK_END);
-        length_ = (size_t)ftell(fp);
-        fseek(fp, 0, SEEK_SET);
-        json_ = (char*)malloc(length_ + 1);
-        ASSERT_EQ(length_, fread(json_, 1, length_, fp));
-        json_[length_] = '\0';
-        fclose(fp);
-
-        // whitespace test
-        whitespace_length_ = 1024 * 1024;
-        whitespace_ = (char *)malloc(whitespace_length_  + 4);
-        char *p = whitespace_;
-        for (size_t i = 0; i < whitespace_length_; i += 4) {
-            *p++ = ' ';
-            *p++ = '\n';
-            *p++ = '\r';
-            *p++ = '\t';
-        }
-        *p++ = '[';
-        *p++ = '0';
-        *p++ = ']';
-        *p++ = '\0';
-    }
-
-    virtual void TearDown() {
-        free(json_);
-        free(whitespace_);
-        json_ = 0;
-        whitespace_ = 0;
-    }
-
-private:
-    PerfTest(const PerfTest&);
-    PerfTest& operator=(const PerfTest&);
-
-protected:
-    const char* filename_;
-    char *json_;
-    size_t length_;
-    char *whitespace_;
-    size_t whitespace_length_;
-
-    static const size_t kTrialCount = 1000;
-};
-
-#endif // __cplusplus
-
-#endif // PERFTEST_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/platformtest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/platformtest.cpp
deleted file mode 100644
index 30b690c..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/platformtest.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "perftest.h"
-
-// This file is for giving the performance characteristics of the platform (compiler/OS/CPU).
-
-#if TEST_PLATFORM
-
-#include <cmath>
-#include <fcntl.h>
-
-// Windows
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-// UNIX
-#if defined(unix) || defined(__unix__) || defined(__unix)
-#include <unistd.h>
-#ifdef _POSIX_MAPPED_FILES
-#include <sys/mman.h>
-#endif
-#endif
-
-class Platform : public PerfTest {
-public:
-    virtual void SetUp() {
-        PerfTest::SetUp();
-
-        // temp buffer for testing
-        temp_ = (char *)malloc(length_ + 1);
-        memcpy(temp_, json_, length_);
-        checkSum_ = CheckSum();
-    }
-
-    char CheckSum() {
-        char c = 0;
-        for (size_t i = 0; i < length_; ++i)
-            c += temp_[i];
-        return c;
-    }
-
-    virtual void TearDown() {
-        PerfTest::TearDown();
-        free(temp_);
-    }
-
-protected:
-    char *temp_;
-    char checkSum_;
-};
-
-TEST_F(Platform, CheckSum) {
-    for (int i = 0; i < kTrialCount; i++)
-        EXPECT_EQ(checkSum_, CheckSum());
-}
-
-TEST_F(Platform, strlen) {
-    for (int i = 0; i < kTrialCount; i++) {
-        size_t l = strlen(json_);
-        EXPECT_EQ(length_, l);
-    }
-}
-
-TEST_F(Platform, memcmp) {
-    for (int i = 0; i < kTrialCount; i++) {
-        EXPECT_EQ(0, memcmp(temp_, json_, length_));
-    }
-}
-
-TEST_F(Platform, pow) {
-    double sum = 0;
-    for (int i = 0; i < kTrialCount * kTrialCount; i++)
-        sum += pow(10.0, i & 255);
-    EXPECT_GT(sum, 0.0);
-}
-
-TEST_F(Platform, Whitespace_strlen) {
-    for (int i = 0; i < kTrialCount; i++) {
-        size_t l = strlen(whitespace_);
-        EXPECT_GT(l, whitespace_length_);
-    }       
-}
-
-TEST_F(Platform, Whitespace_strspn) {
-    for (int i = 0; i < kTrialCount; i++) {
-        size_t l = strspn(whitespace_, " \n\r\t");
-        EXPECT_EQ(whitespace_length_, l);
-    }       
-}
-
-TEST_F(Platform, fread) {
-    for (int i = 0; i < kTrialCount; i++) {
-        FILE *fp = fopen(filename_, "rb");
-        ASSERT_EQ(length_, fread(temp_, 1, length_, fp));
-        EXPECT_EQ(checkSum_, CheckSum());
-        fclose(fp);
-    }
-}
-
-#ifdef _MSC_VER
-TEST_F(Platform, read) {
-    for (int i = 0; i < kTrialCount; i++) {
-        int fd = _open(filename_, _O_BINARY | _O_RDONLY);
-        ASSERT_NE(-1, fd);
-        ASSERT_EQ(length_, _read(fd, temp_, length_));
-        EXPECT_EQ(checkSum_, CheckSum());
-        _close(fd);
-    }
-}
-#else
-TEST_F(Platform, read) {
-    for (int i = 0; i < kTrialCount; i++) {
-        int fd = open(filename_, O_RDONLY);
-        ASSERT_NE(-1, fd);
-        ASSERT_EQ(length_, read(fd, temp_, length_));
-        EXPECT_EQ(checkSum_, CheckSum());
-        close(fd);
-    }
-}
-#endif
-
-#ifdef _WIN32
-TEST_F(Platform, MapViewOfFile) {
-    for (int i = 0; i < kTrialCount; i++) {
-        HANDLE file = CreateFile(filename_, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-        ASSERT_NE(INVALID_HANDLE_VALUE, file);
-        HANDLE mapObject = CreateFileMapping(file, NULL, PAGE_READONLY, 0, length_, NULL);
-        ASSERT_NE(INVALID_HANDLE_VALUE, mapObject);
-        void *p = MapViewOfFile(mapObject, FILE_MAP_READ, 0, 0, length_);
-        ASSERT_TRUE(p != NULL);
-        EXPECT_EQ(checkSum_, CheckSum());
-        ASSERT_TRUE(UnmapViewOfFile(p) == TRUE);
-        ASSERT_TRUE(CloseHandle(mapObject) == TRUE);
-        ASSERT_TRUE(CloseHandle(file) == TRUE);
-    }
-}
-#endif
-
-#ifdef _POSIX_MAPPED_FILES
-TEST_F(Platform, mmap) {
-    for (int i = 0; i < kTrialCount; i++) {
-        int fd = open(filename_, O_RDONLY);
-        ASSERT_NE(-1, fd);
-        void *p = mmap(NULL, length_, PROT_READ, MAP_PRIVATE, fd, 0);
-        ASSERT_TRUE(p != NULL);
-        EXPECT_EQ(checkSum_, CheckSum());
-        munmap(p, length_);
-        close(fd);
-    }
-}
-#endif
-
-#endif // TEST_PLATFORM
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/rapidjsontest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/rapidjsontest.cpp
deleted file mode 100644
index 74bdf27..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/perftest/rapidjsontest.cpp
+++ /dev/null
@@ -1,361 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "perftest.h"
-
-#if TEST_RAPIDJSON
-
-#include "rapidjson/rapidjson.h"
-#include "rapidjson/document.h"
-#include "rapidjson/prettywriter.h"
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/filestream.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/encodedstream.h"
-#include "rapidjson/memorystream.h"
-
-#ifdef RAPIDJSON_SSE2
-#define SIMD_SUFFIX(name) name##_SSE2
-#elif defined(RAPIDJSON_SSE42)
-#define SIMD_SUFFIX(name) name##_SSE42
-#else
-#define SIMD_SUFFIX(name) name
-#endif
-
-using namespace rapidjson;
-
-class RapidJson : public PerfTest {
-public:
-    RapidJson() : temp_(), doc_() {}
-
-    virtual void SetUp() {
-        PerfTest::SetUp();
-
-        // temp buffer for insitu parsing.
-        temp_ = (char *)malloc(length_ + 1);
-
-        // Parse as a document
-        EXPECT_FALSE(doc_.Parse(json_).IsNull());
-    }
-
-    virtual void TearDown() {
-        PerfTest::TearDown();
-        free(temp_);
-    }
-
-private:
-    RapidJson(const RapidJson&);
-    RapidJson& operator=(const RapidJson&);
-
-protected:
-    char *temp_;
-    Document doc_;
-};
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseInsitu_DummyHandler)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        InsituStringStream s(temp_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseInsituFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseInsitu_DummyHandler_ValidateEncoding)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        InsituStringStream s(temp_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseInsituFlag | kParseValidateEncodingFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringStream s(json_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_FullPrecision)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringStream s(json_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseFullPrecisionFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterative_DummyHandler)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringStream s(json_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseIterativeFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParseIterativeInsitu_DummyHandler)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        InsituStringStream s(temp_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseIterativeFlag|kParseInsituFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_ValidateEncoding)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringStream s(json_);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_TRUE(reader.Parse<kParseValidateEncodingFlag>(s, h));
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseInsitu_MemoryPoolAllocator)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        Document doc;
-        doc.ParseInsitu(temp_);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseIterativeInsitu_MemoryPoolAllocator)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        Document doc;
-        doc.ParseInsitu<kParseIterativeFlag>(temp_);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParse_MemoryPoolAllocator)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        Document doc;
-        doc.Parse(json_);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseIterative_MemoryPoolAllocator)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        Document doc;
-        doc.Parse<kParseIterativeFlag>(json_);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParse_CrtAllocator)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        memcpy(temp_, json_, length_ + 1);
-        GenericDocument<UTF8<>, CrtAllocator> doc;
-        doc.Parse(temp_);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseEncodedInputStream_MemoryStream)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        MemoryStream ms(json_, length_);
-        EncodedInputStream<UTF8<>, MemoryStream> is(ms);
-        Document doc;
-        doc.ParseStream<0, UTF8<> >(is);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(DocumentParseAutoUTFInputStream_MemoryStream)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        MemoryStream ms(json_, length_);
-        AutoUTFInputStream<unsigned, MemoryStream> is(ms);
-        Document doc;
-        doc.ParseStream<0, AutoUTF<unsigned> >(is);
-        ASSERT_TRUE(doc.IsObject());
-    }
-}
-
-template<typename T>
-size_t Traverse(const T& value) {
-    size_t count = 1;
-    switch(value.GetType()) {
-        case kObjectType:
-            for (typename T::ConstMemberIterator itr = value.MemberBegin(); itr != value.MemberEnd(); ++itr) {
-                count++;    // name
-                count += Traverse(itr->value);
-            }
-            break;
-
-        case kArrayType:
-            for (typename T::ConstValueIterator itr = value.Begin(); itr != value.End(); ++itr)
-                count += Traverse(*itr);
-            break;
-
-        default:
-            // Do nothing.
-            break;
-    }
-    return count;
-}
-
-TEST_F(RapidJson, DocumentTraverse) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        size_t count = Traverse(doc_);
-        EXPECT_EQ(4339u, count);
-        //if (i == 0)
-        //  std::cout << count << std::endl;
-    }
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-struct ValueCounter : public BaseReaderHandler<> {
-    ValueCounter() : count_(1) {}   // root
-
-    bool EndObject(SizeType memberCount) { count_ += memberCount * 2; return true; }
-    bool EndArray(SizeType elementCount) { count_ += elementCount; return true; }
-
-    SizeType count_;
-};
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
-
-TEST_F(RapidJson, DocumentAccept) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        ValueCounter counter;
-        doc_.Accept(counter);
-        EXPECT_EQ(4339u, counter.count_);
-    }
-}
-
-struct NullStream {
-    NullStream() /*: length_(0)*/ {}
-    void Put(char) { /*++length_;*/ }
-    void Flush() {}
-    //size_t length_;
-};
-
-TEST_F(RapidJson, Writer_NullStream) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        NullStream s;
-        Writer<NullStream> writer(s);
-        doc_.Accept(writer);
-        //if (i == 0)
-        //  std::cout << s.length_ << std::endl;
-    }
-}
-
-TEST_F(RapidJson, Writer_StringBuffer) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringBuffer s(0, 1024 * 1024);
-        Writer<StringBuffer> writer(s);
-        doc_.Accept(writer);
-        const char* str = s.GetString();
-        (void)str;
-        //if (i == 0)
-        //  std::cout << strlen(str) << std::endl;
-    }
-}
-
-TEST_F(RapidJson, PrettyWriter_StringBuffer) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringBuffer s(0, 2048 * 1024);
-        PrettyWriter<StringBuffer> writer(s);
-        writer.SetIndent(' ', 1);
-        doc_.Accept(writer);
-        const char* str = s.GetString();
-        (void)str;
-        //if (i == 0)
-        //  std::cout << strlen(str) << std::endl;
-    }
-}
-
-TEST_F(RapidJson, internal_Pow10) {
-    double sum = 0;
-    for (size_t i = 0; i < kTrialCount * kTrialCount; i++)
-        sum += internal::Pow10(int(i & 255));
-    EXPECT_GT(sum, 0.0);
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(Whitespace)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        Document doc;
-        ASSERT_TRUE(doc.Parse(whitespace_).IsArray());
-    }       
-}
-
-TEST_F(RapidJson, UTF8_Validate) {
-    NullStream os;
-
-    for (size_t i = 0; i < kTrialCount; i++) {
-        StringStream is(json_);
-        bool result = true;
-        while (is.Peek() != '\0')
-            result &= UTF8<>::Validate(is, os);
-        EXPECT_TRUE(result);
-    }
-}
-
-// Deprecated.
-//TEST_F(RapidJson, FileStream_Read) {
-//  for (size_t i = 0; i < kTrialCount; i++) {
-//      FILE *fp = fopen(filename_, "rb");
-//      FileStream s(fp);
-//      while (s.Take() != '\0')
-//          ;
-//      fclose(fp);
-//  }
-//}
-
-TEST_F(RapidJson, FileReadStream) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        FILE *fp = fopen(filename_, "rb");
-        char buffer[65536];
-        FileReadStream s(fp, buffer, sizeof(buffer));
-        while (s.Take() != '\0')
-            ;
-        fclose(fp);
-    }
-}
-
-TEST_F(RapidJson, SIMD_SUFFIX(ReaderParse_DummyHandler_FileReadStream)) {
-    for (size_t i = 0; i < kTrialCount; i++) {
-        FILE *fp = fopen(filename_, "rb");
-        char buffer[65536];
-        FileReadStream s(fp, buffer, sizeof(buffer));
-        BaseReaderHandler<> h;
-        Reader reader;
-        reader.Parse(s, h);
-        fclose(fp);
-    }
-}
-
-#endif // TEST_RAPIDJSON
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/CMakeLists.txt
deleted file mode 100644
index 5e4a3e9..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/CMakeLists.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-set(UNITTEST_SOURCES
-    bigintegertest.cpp
-    documenttest.cpp
-    encodedstreamtest.cpp
-    encodingstest.cpp
-    filestreamtest.cpp
-    jsoncheckertest.cpp
-    namespacetest.cpp
-    readertest.cpp
-    stringbuffertest.cpp
-    strtodtest.cpp
-    unittest.cpp
-    valuetest.cpp
-    writertest.cpp)
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Weffc++ -Wswitch-default")
-elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Weffc++ -Wswitch-default")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
-endif()
-
-add_library(namespacetest STATIC namespacetest.cpp)
-
-add_executable(unittest ${UNITTEST_SOURCES})
-target_link_libraries(unittest ${TEST_LIBRARIES} namespacetest)
-
-add_dependencies(tests unittest)
-
-add_test(NAME unittest
-    COMMAND ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unittest
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
-
-if(NOT MSVC)
-    add_test(NAME valgrind_unittest
-        COMMAND valgrind --leak-check=full --error-exitcode=1 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/unittest
-        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
-
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        add_test(NAME symbol_check
-        COMMAND sh -c "objdump -t -C libnamespacetest.a | grep rapidjson ; test $? -ne 0"
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    endif(CMAKE_BUILD_TYPE STREQUAL "Debug")
-
-endif(NOT MSVC)
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/bigintegertest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/bigintegertest.cpp
deleted file mode 100644
index e7b3b8f..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/bigintegertest.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-#include "rapidjson/internal/biginteger.h"
-
-using namespace rapidjson::internal;
-
-#define BIGINTEGER_LITERAL(s) BigInteger(s, sizeof(s) - 1)
-
-static const BigInteger kZero(0);
-static const BigInteger kOne(1);
-static const BigInteger kUint64Max = BIGINTEGER_LITERAL("18446744073709551615");
-static const BigInteger kTwo64 = BIGINTEGER_LITERAL("18446744073709551616");
-
-TEST(BigInteger, Constructor) {
-    EXPECT_TRUE(kZero.IsZero());
-    EXPECT_TRUE(kZero == kZero);
-    EXPECT_TRUE(kZero == BIGINTEGER_LITERAL("0"));
-    EXPECT_TRUE(kZero == BIGINTEGER_LITERAL("00"));
-
-    const BigInteger a(123);
-    EXPECT_TRUE(a == a);
-    EXPECT_TRUE(a == BIGINTEGER_LITERAL("123"));
-    EXPECT_TRUE(a == BIGINTEGER_LITERAL("0123"));
-
-    EXPECT_EQ(2u, kTwo64.GetCount());
-    EXPECT_EQ(0u, kTwo64.GetDigit(0));
-    EXPECT_EQ(1u, kTwo64.GetDigit(1));
-}
-
-TEST(BigInteger, AddUint64) {
-    BigInteger a = kZero;
-    a += 0u;
-    EXPECT_TRUE(kZero == a);
-
-    a += 1u;
-    EXPECT_TRUE(kOne == a);
-
-    a += 1u;
-    EXPECT_TRUE(BigInteger(2) == a);
-
-    EXPECT_TRUE(BigInteger(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF)) == kUint64Max);
-    BigInteger b = kUint64Max;
-    b += 1u;
-    EXPECT_TRUE(kTwo64 == b);
-    b += RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
-    EXPECT_TRUE(BIGINTEGER_LITERAL("36893488147419103231") == b);
-}
-
-TEST(BigInteger, MultiplyUint64) {
-    BigInteger a = kZero;
-    a *= static_cast <uint64_t>(0);
-    EXPECT_TRUE(kZero == a);
-    a *= static_cast <uint64_t>(123);
-    EXPECT_TRUE(kZero == a);
-
-    BigInteger b = kOne;
-    b *= static_cast<uint64_t>(1);
-    EXPECT_TRUE(kOne == b);
-    b *= static_cast<uint64_t>(0);
-    EXPECT_TRUE(kZero == b);
-
-    BigInteger c(123);
-    c *= static_cast<uint64_t>(456u);
-    EXPECT_TRUE(BigInteger(123u * 456u) == c);
-    c *= RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
-    EXPECT_TRUE(BIGINTEGER_LITERAL("1034640981606221330982120") == c);
-    c *= RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF);
-    EXPECT_TRUE(BIGINTEGER_LITERAL("19085757395861596536664473018420572782123800") == c);
-}
-
-TEST(BigInteger, MultiplyUint32) {
-    BigInteger a = kZero;
-    a *= static_cast <uint32_t>(0);
-    EXPECT_TRUE(kZero == a);
-    a *= static_cast <uint32_t>(123);
-    EXPECT_TRUE(kZero == a);
-
-    BigInteger b = kOne;
-    b *= static_cast<uint32_t>(1);
-    EXPECT_TRUE(kOne == b);
-    b *= static_cast<uint32_t>(0);
-    EXPECT_TRUE(kZero == b);
-
-    BigInteger c(123);
-    c *= static_cast<uint32_t>(456u);
-    EXPECT_TRUE(BigInteger(123u * 456u) == c);
-    c *= 0xFFFFFFFFu;
-    EXPECT_TRUE(BIGINTEGER_LITERAL("240896125641960") == c);
-    c *= 0xFFFFFFFFu;
-    EXPECT_TRUE(BIGINTEGER_LITERAL("1034640981124429079698200") == c);
-}
-
-TEST(BigInteger, LeftShift) {
-    BigInteger a = kZero;
-    a <<= 1;
-    EXPECT_TRUE(kZero == a);
-    a <<= 64;
-    EXPECT_TRUE(kZero == a);
-
-    a = BigInteger(123);
-    a <<= 0;
-    EXPECT_TRUE(BigInteger(123) == a);
-    a <<= 1;
-    EXPECT_TRUE(BigInteger(246) == a);
-    a <<= 64;
-    EXPECT_TRUE(BIGINTEGER_LITERAL("4537899042132549697536") == a);
-    a <<= 99;
-    EXPECT_TRUE(BIGINTEGER_LITERAL("2876235222267216943024851750785644982682875244576768") == a);
-}
-
-TEST(BigInteger, Compare) {
-    EXPECT_EQ(0, kZero.Compare(kZero));
-    EXPECT_EQ(1, kOne.Compare(kZero));
-    EXPECT_EQ(-1, kZero.Compare(kOne));
-    EXPECT_EQ(0, kUint64Max.Compare(kUint64Max));
-    EXPECT_EQ(0, kTwo64.Compare(kTwo64));
-    EXPECT_EQ(-1, kUint64Max.Compare(kTwo64));
-    EXPECT_EQ(1, kTwo64.Compare(kUint64Max));
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/documenttest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/documenttest.cpp
deleted file mode 100644
index 93f7a3d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/documenttest.cpp
+++ /dev/null
@@ -1,488 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/document.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/encodedstream.h"
-#include "rapidjson/stringbuffer.h"
-#include <sstream>
-
-using namespace rapidjson;
-
-template <typename Allocator, typename StackAllocator>
-void ParseTest() {
-    typedef GenericDocument<UTF8<>, Allocator, StackAllocator> DocumentType;
-    typedef typename DocumentType::ValueType ValueType;
-    DocumentType doc;
-
-    doc.Parse(" { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ");
-
-    EXPECT_TRUE(doc.IsObject());
-
-    EXPECT_TRUE(doc.HasMember("hello"));
-    const ValueType& hello = doc["hello"];
-    EXPECT_TRUE(hello.IsString());
-    EXPECT_STREQ("world", hello.GetString());
-
-    EXPECT_TRUE(doc.HasMember("t"));
-    const ValueType& t = doc["t"];
-    EXPECT_TRUE(t.IsTrue());
-
-    EXPECT_TRUE(doc.HasMember("f"));
-    const ValueType& f = doc["f"];
-    EXPECT_TRUE(f.IsFalse());
-
-    EXPECT_TRUE(doc.HasMember("n"));
-    const ValueType& n = doc["n"];
-    EXPECT_TRUE(n.IsNull());
-
-    EXPECT_TRUE(doc.HasMember("i"));
-    const ValueType& i = doc["i"];
-    EXPECT_TRUE(i.IsNumber());
-    EXPECT_EQ(123, i.GetInt());
-
-    EXPECT_TRUE(doc.HasMember("pi"));
-    const ValueType& pi = doc["pi"];
-    EXPECT_TRUE(pi.IsNumber());
-    EXPECT_EQ(3.1416, pi.GetDouble());
-
-    EXPECT_TRUE(doc.HasMember("a"));
-    const ValueType& a = doc["a"];
-    EXPECT_TRUE(a.IsArray());
-    EXPECT_EQ(4u, a.Size());
-    for (SizeType i = 0; i < 4; i++)
-        EXPECT_EQ(i + 1, a[i].GetUint());
-}
-
-TEST(Document, Parse) {
-    ParseTest<MemoryPoolAllocator<>, CrtAllocator>();
-    ParseTest<MemoryPoolAllocator<>, MemoryPoolAllocator<> >();
-    ParseTest<CrtAllocator, MemoryPoolAllocator<> >();
-    ParseTest<CrtAllocator, CrtAllocator>();
-}
-
-static FILE* OpenEncodedFile(const char* filename) {
-    char buffer[1024];
-    sprintf(buffer, "encodings/%s", filename);
-    FILE *fp = fopen(buffer, "rb");
-    if (!fp) {
-        sprintf(buffer, "../../bin/encodings/%s", filename);
-        fp = fopen(buffer, "rb");
-    }
-    return fp;
-}
-
-TEST(Document, ParseStream_EncodedInputStream) {
-    // UTF8 -> UTF16
-    FILE* fp = OpenEncodedFile("utf8.json");
-    char buffer[256];
-    FileReadStream bis(fp, buffer, sizeof(buffer));
-    EncodedInputStream<UTF8<>, FileReadStream> eis(bis);
-
-    GenericDocument<UTF16<> > d;
-    d.ParseStream<0, UTF8<> >(eis);
-    EXPECT_FALSE(d.HasParseError());
-
-    fclose(fp);
-
-    wchar_t expected[] = L"I can eat glass and it doesn't hurt me.";
-    GenericValue<UTF16<> >& v = d[L"en"];
-    EXPECT_TRUE(v.IsString());
-    EXPECT_EQ(sizeof(expected) / sizeof(wchar_t) - 1, v.GetStringLength());
-    EXPECT_EQ(0, StrCmp(expected, v.GetString()));
-
-    // UTF16 -> UTF8 in memory
-    StringBuffer bos;
-    typedef EncodedOutputStream<UTF8<>, StringBuffer> OutputStream;
-    OutputStream eos(bos, false);   // Not writing BOM
-    Writer<OutputStream, UTF16<>, UTF8<> > writer(eos);
-    d.Accept(writer);
-
-    {
-        // Condense the original file and compare.
-        FILE *fp = OpenEncodedFile("utf8.json");
-        FileReadStream is(fp, buffer, sizeof(buffer));
-        Reader reader;
-        StringBuffer bos2;
-        Writer<StringBuffer> writer(bos2);
-        reader.Parse(is, writer);
-
-        EXPECT_EQ(bos.GetSize(), bos2.GetSize());
-        EXPECT_EQ(0, memcmp(bos.GetString(), bos2.GetString(), bos2.GetSize()));
-    }
-}
-
-TEST(Document, ParseStream_AutoUTFInputStream) {
-    // Any -> UTF8
-    FILE* fp = OpenEncodedFile("utf32be.json");
-    char buffer[256];
-    FileReadStream bis(fp, buffer, sizeof(buffer));
-    AutoUTFInputStream<unsigned, FileReadStream> eis(bis);
-
-    Document d;
-    d.ParseStream<0, AutoUTF<unsigned> >(eis);
-    EXPECT_FALSE(d.HasParseError());
-
-    fclose(fp);
-
-    char expected[] = "I can eat glass and it doesn't hurt me.";
-    Value& v = d["en"];
-    EXPECT_TRUE(v.IsString());
-    EXPECT_EQ(sizeof(expected) - 1, v.GetStringLength());
-    EXPECT_EQ(0, StrCmp(expected, v.GetString()));
-
-    // UTF8 -> UTF8 in memory
-    StringBuffer bos;
-    Writer<StringBuffer> writer(bos);
-    d.Accept(writer);
-
-    {
-        // Condense the original file and compare.
-        FILE *fp = OpenEncodedFile("utf8.json");
-        FileReadStream is(fp, buffer, sizeof(buffer));
-        Reader reader;
-        StringBuffer bos2;
-        Writer<StringBuffer> writer(bos2);
-        reader.Parse(is, writer);
-
-        EXPECT_EQ(bos.GetSize(), bos2.GetSize());
-        EXPECT_EQ(0, memcmp(bos.GetString(), bos2.GetString(), bos2.GetSize()));
-    }
-}
-
-TEST(Document, Swap) {
-    Document d1;
-    Document::AllocatorType& a = d1.GetAllocator();
-
-    d1.SetArray().PushBack(1, a).PushBack(2, a);
-
-    Value o;
-    o.SetObject().AddMember("a", 1, a);
-
-    // Swap between Document and Value
-    d1.Swap(o);
-    EXPECT_TRUE(d1.IsObject());
-    EXPECT_TRUE(o.IsArray());
-
-    // Swap between Document and Document
-    Document d2;
-    d2.SetArray().PushBack(3, a);
-    d1.Swap(d2);
-    EXPECT_TRUE(d1.IsArray());
-    EXPECT_TRUE(d2.IsObject());
-}
-
-// This should be slow due to assignment in inner-loop.
-struct OutputStringStream : public std::ostringstream {
-    typedef char Ch;
-
-    void Put(char c) {
-        put(c);
-    }
-    void Flush() {}
-};
-
-TEST(Document, AcceptWriter) {
-    Document doc;
-    doc.Parse(" { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ");
-
-    OutputStringStream os;
-    Writer<OutputStringStream> writer(os);
-    doc.Accept(writer);
-
-    EXPECT_EQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3,4]}", os.str());
-}
-
-// Issue 226: Value of string type should not point to NULL
-TEST(Document, AssertAcceptInvalidNameType) {
-    Document doc;
-    doc.SetObject();
-    doc.AddMember("a", 0, doc.GetAllocator());
-    doc.FindMember("a")->name.SetNull(); // Change name to non-string type.
-
-    OutputStringStream os;
-    Writer<OutputStringStream> writer(os);
-    ASSERT_THROW(doc.Accept(writer), AssertException);
-}
-
-// Issue 44:    SetStringRaw doesn't work with wchar_t
-TEST(Document, UTF16_Document) {
-    GenericDocument< UTF16<> > json;
-    json.Parse<kParseValidateEncodingFlag>(L"[{\"created_at\":\"Wed Oct 30 17:13:20 +0000 2012\"}]");
-
-    ASSERT_TRUE(json.IsArray());
-    GenericValue< UTF16<> >& v = json[0];
-    ASSERT_TRUE(v.IsObject());
-
-    GenericValue< UTF16<> >& s = v[L"created_at"];
-    ASSERT_TRUE(s.IsString());
-
-    EXPECT_EQ(0, wcscmp(L"Wed Oct 30 17:13:20 +0000 2012", s.GetString()));
-}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#include <type_traits>
-
-TEST(Document, Traits) {
-    static_assert(std::is_constructible<Document>::value, "");
-    static_assert(std::is_default_constructible<Document>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_copy_constructible<Document>::value, "");
-#endif
-    static_assert(std::is_move_constructible<Document>::value, "");
-
-    static_assert(!std::is_nothrow_constructible<Document>::value, "");
-    static_assert(!std::is_nothrow_default_constructible<Document>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_nothrow_copy_constructible<Document>::value, "");
-    static_assert(std::is_nothrow_move_constructible<Document>::value, "");
-#endif
-
-    static_assert(std::is_assignable<Document,Document>::value, "");
-#ifndef _MSC_VER
-  static_assert(!std::is_copy_assignable<Document>::value, "");
-#endif
-    static_assert(std::is_move_assignable<Document>::value, "");
-
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_assignable<Document, Document>::value, "");
-#endif
-    static_assert(!std::is_nothrow_copy_assignable<Document>::value, "");
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_move_assignable<Document>::value, "");
-#endif
-
-    static_assert( std::is_destructible<Document>::value, "");
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_destructible<Document>::value, "");
-#endif
-}
-
-template <typename Allocator>
-struct DocumentMove: public ::testing::Test {
-};
-
-typedef ::testing::Types< CrtAllocator, MemoryPoolAllocator<> > MoveAllocatorTypes;
-TYPED_TEST_CASE(DocumentMove, MoveAllocatorTypes);
-
-TYPED_TEST(DocumentMove, MoveConstructor) {
-    typedef TypeParam Allocator;
-    typedef GenericDocument<UTF8<>, Allocator> Document;
-    Allocator allocator;
-
-    Document a(&allocator);
-    a.Parse("[\"one\", \"two\", \"three\"]");
-    EXPECT_FALSE(a.HasParseError());
-    EXPECT_TRUE(a.IsArray());
-    EXPECT_EQ(3u, a.Size());
-    EXPECT_EQ(&a.GetAllocator(), &allocator);
-
-    // Document b(a); // does not compile (!is_copy_constructible)
-    Document b(std::move(a));
-    EXPECT_TRUE(a.IsNull());
-    EXPECT_TRUE(b.IsArray());
-    EXPECT_EQ(3u, b.Size());
-    EXPECT_EQ(&a.GetAllocator(), (void*)0);
-    EXPECT_EQ(&b.GetAllocator(), &allocator);
-
-    b.Parse("{\"Foo\": \"Bar\", \"Baz\": 42}");
-    EXPECT_FALSE(b.HasParseError());
-    EXPECT_TRUE(b.IsObject());
-    EXPECT_EQ(2u, b.MemberCount());
-
-    // Document c = a; // does not compile (!is_copy_constructible)
-    Document c = std::move(b);
-    EXPECT_TRUE(b.IsNull());
-    EXPECT_TRUE(c.IsObject());
-    EXPECT_EQ(2u, c.MemberCount());
-    EXPECT_EQ(&b.GetAllocator(), (void*)0);
-    EXPECT_EQ(&c.GetAllocator(), &allocator);
-}
-
-TYPED_TEST(DocumentMove, MoveConstructorParseError) {
-    typedef TypeParam Allocator;
-    typedef GenericDocument<UTF8<>, Allocator> Document;
-
-    ParseResult noError;
-    Document a;
-    a.Parse("{ 4 = 4]");
-    ParseResult error(a.GetParseError(), a.GetErrorOffset());
-    EXPECT_TRUE(a.HasParseError());
-    EXPECT_NE(error.Code(), noError.Code());
-    EXPECT_NE(error.Offset(), noError.Offset());
-
-    Document b(std::move(a));
-    EXPECT_FALSE(a.HasParseError());
-    EXPECT_TRUE(b.HasParseError());
-    EXPECT_EQ(a.GetParseError(), noError.Code());
-    EXPECT_EQ(b.GetParseError(), error.Code());
-    EXPECT_EQ(a.GetErrorOffset(), noError.Offset());
-    EXPECT_EQ(b.GetErrorOffset(), error.Offset());
-
-    Document c(std::move(b));
-    EXPECT_FALSE(b.HasParseError());
-    EXPECT_TRUE(c.HasParseError());
-    EXPECT_EQ(b.GetParseError(), noError.Code());
-    EXPECT_EQ(c.GetParseError(), error.Code());
-    EXPECT_EQ(b.GetErrorOffset(), noError.Offset());
-    EXPECT_EQ(c.GetErrorOffset(), error.Offset());
-}
-
-// This test does not properly use parsing, just for testing.
-// It must call ClearStack() explicitly to prevent memory leak.
-// But here we cannot as ClearStack() is private.
-#if 0
-TYPED_TEST(DocumentMove, MoveConstructorStack) {
-    typedef TypeParam Allocator;
-    typedef UTF8<> Encoding;
-    typedef GenericDocument<Encoding, Allocator> Document;
-
-    Document a;
-    size_t defaultCapacity = a.GetStackCapacity();
-
-    // Trick Document into getting GetStackCapacity() to return non-zero
-    typedef GenericReader<Encoding, Encoding, Allocator> Reader;
-    Reader reader(&a.GetAllocator());
-    GenericStringStream<Encoding> is("[\"one\", \"two\", \"three\"]");
-    reader.template Parse<kParseDefaultFlags>(is, a);
-    size_t capacity = a.GetStackCapacity();
-    EXPECT_GT(capacity, 0u);
-
-    Document b(std::move(a));
-    EXPECT_EQ(a.GetStackCapacity(), defaultCapacity);
-    EXPECT_EQ(b.GetStackCapacity(), capacity);
-
-    Document c = std::move(b);
-    EXPECT_EQ(b.GetStackCapacity(), defaultCapacity);
-    EXPECT_EQ(c.GetStackCapacity(), capacity);
-}
-#endif
-
-TYPED_TEST(DocumentMove, MoveAssignment) {
-    typedef TypeParam Allocator;
-    typedef GenericDocument<UTF8<>, Allocator> Document;
-    Allocator allocator;
-
-    Document a(&allocator);
-    a.Parse("[\"one\", \"two\", \"three\"]");
-    EXPECT_FALSE(a.HasParseError());
-    EXPECT_TRUE(a.IsArray());
-    EXPECT_EQ(3u, a.Size());
-    EXPECT_EQ(&a.GetAllocator(), &allocator);
-
-    // Document b; b = a; // does not compile (!is_copy_assignable)
-    Document b;
-    b = std::move(a);
-    EXPECT_TRUE(a.IsNull());
-    EXPECT_TRUE(b.IsArray());
-    EXPECT_EQ(3u, b.Size());
-    EXPECT_EQ(&a.GetAllocator(), (void*)0);
-    EXPECT_EQ(&b.GetAllocator(), &allocator);
-
-    b.Parse("{\"Foo\": \"Bar\", \"Baz\": 42}");
-    EXPECT_FALSE(b.HasParseError());
-    EXPECT_TRUE(b.IsObject());
-    EXPECT_EQ(2u, b.MemberCount());
-
-    // Document c; c = a; // does not compile (see static_assert)
-    Document c;
-    c = std::move(b);
-    EXPECT_TRUE(b.IsNull());
-    EXPECT_TRUE(c.IsObject());
-    EXPECT_EQ(2u, c.MemberCount());
-    EXPECT_EQ(&b.GetAllocator(), (void*)0);
-    EXPECT_EQ(&c.GetAllocator(), &allocator);
-}
-
-TYPED_TEST(DocumentMove, MoveAssignmentParseError) {
-    typedef TypeParam Allocator;
-    typedef GenericDocument<UTF8<>, Allocator> Document;
-
-    ParseResult noError;
-    Document a;
-    a.Parse("{ 4 = 4]");
-    ParseResult error(a.GetParseError(), a.GetErrorOffset());
-    EXPECT_TRUE(a.HasParseError());
-    EXPECT_NE(error.Code(), noError.Code());
-    EXPECT_NE(error.Offset(), noError.Offset());
-
-    Document b;
-    b = std::move(a);
-    EXPECT_FALSE(a.HasParseError());
-    EXPECT_TRUE(b.HasParseError());
-    EXPECT_EQ(a.GetParseError(), noError.Code());
-    EXPECT_EQ(b.GetParseError(), error.Code());
-    EXPECT_EQ(a.GetErrorOffset(), noError.Offset());
-    EXPECT_EQ(b.GetErrorOffset(), error.Offset());
-
-    Document c;
-    c = std::move(b);
-    EXPECT_FALSE(b.HasParseError());
-    EXPECT_TRUE(c.HasParseError());
-    EXPECT_EQ(b.GetParseError(), noError.Code());
-    EXPECT_EQ(c.GetParseError(), error.Code());
-    EXPECT_EQ(b.GetErrorOffset(), noError.Offset());
-    EXPECT_EQ(c.GetErrorOffset(), error.Offset());
-}
-
-// This test does not properly use parsing, just for testing.
-// It must call ClearStack() explicitly to prevent memory leak.
-// But here we cannot as ClearStack() is private.
-#if 0
-TYPED_TEST(DocumentMove, MoveAssignmentStack) {
-    typedef TypeParam Allocator;
-    typedef UTF8<> Encoding;
-    typedef GenericDocument<Encoding, Allocator> Document;
-
-    Document a;
-    size_t defaultCapacity = a.GetStackCapacity();
-
-    // Trick Document into getting GetStackCapacity() to return non-zero
-    typedef GenericReader<Encoding, Encoding, Allocator> Reader;
-    Reader reader(&a.GetAllocator());
-    GenericStringStream<Encoding> is("[\"one\", \"two\", \"three\"]");
-    reader.template Parse<kParseDefaultFlags>(is, a);
-    size_t capacity = a.GetStackCapacity();
-    EXPECT_GT(capacity, 0u);
-
-    Document b;
-    b = std::move(a);
-    EXPECT_EQ(a.GetStackCapacity(), defaultCapacity);
-    EXPECT_EQ(b.GetStackCapacity(), capacity);
-
-    Document c;
-    c = std::move(b);
-    EXPECT_EQ(b.GetStackCapacity(), defaultCapacity);
-    EXPECT_EQ(c.GetStackCapacity(), capacity);
-}
-#endif
-
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-// Issue 22: Memory corruption via operator=
-// Fixed by making unimplemented assignment operator private.
-//TEST(Document, Assignment) {
-//  Document d1;
-//  Document d2;
-//  d1 = d2;
-//}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodedstreamtest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodedstreamtest.cpp
deleted file mode 100644
index 3580608..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodedstreamtest.cpp
+++ /dev/null
@@ -1,296 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/memorystream.h"
-#include "rapidjson/memorybuffer.h"
-
-using namespace rapidjson;
-
-class EncodedStreamTest : public ::testing::Test {
-public:
-    EncodedStreamTest() : json_(), length_() {}
-
-    virtual void SetUp() {
-        json_ = ReadFile("utf8.json", true, &length_);
-    }
-
-    virtual void TearDown() {
-        free(json_);
-        json_ = 0;
-    }
-
-private:
-    EncodedStreamTest(const EncodedStreamTest&);
-    EncodedStreamTest& operator=(const EncodedStreamTest&);
-    
-protected:
-    static FILE* Open(const char* filename) {
-        char buffer[1024];
-        sprintf(buffer, "encodings/%s", filename);
-        FILE *fp = fopen(buffer, "rb");
-        if (!fp) {
-            sprintf(buffer, "../../bin/encodings/%s", filename);
-            fp = fopen(buffer, "rb");
-        }
-        return fp;
-    }
-
-    static char *ReadFile(const char* filename, bool appendPath, size_t* outLength) {
-        FILE *fp = appendPath ? Open(filename) : fopen(filename, "rb");
-
-        if (!fp) {
-            *outLength = 0;
-            return 0;
-        }
-
-        fseek(fp, 0, SEEK_END);
-        *outLength = (size_t)ftell(fp);
-        fseek(fp, 0, SEEK_SET);
-        char* buffer = (char*)malloc(*outLength + 1);
-        size_t readLength = fread(buffer, 1, *outLength, fp);
-        buffer[readLength] = '\0';
-        fclose(fp);
-        return buffer;
-    }
-
-    template <typename FileEncoding, typename MemoryEncoding>
-    void TestEncodedInputStream(const char* filename) {
-        // Test FileReadStream
-        {
-            char buffer[16];
-            FILE *fp = Open(filename);
-            ASSERT_TRUE(fp != 0);
-            FileReadStream fs(fp, buffer, sizeof(buffer));
-            EncodedInputStream<FileEncoding, FileReadStream> eis(fs);
-            StringStream s(json_);
-
-            while (eis.Peek() != '\0') {
-                unsigned expected, actual;
-                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
-                EXPECT_TRUE(MemoryEncoding::Decode(eis, &actual));
-                EXPECT_EQ(expected, actual);
-            }
-            EXPECT_EQ('\0', s.Peek());
-            fclose(fp);
-        }
-
-        // Test MemoryStream
-        {
-            size_t size;
-            char* data = ReadFile(filename, true, &size);
-            MemoryStream ms(data, size);
-            EncodedInputStream<FileEncoding, MemoryStream> eis(ms);
-            StringStream s(json_);
-
-            while (eis.Peek() != '\0') {
-                unsigned expected, actual;
-                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
-                EXPECT_TRUE(MemoryEncoding::Decode(eis, &actual));
-                EXPECT_EQ(expected, actual);
-            }
-            EXPECT_EQ('\0', s.Peek());
-            free(data);
-        }
-    }
-
-    void TestAutoUTFInputStream(const char *filename) {
-        // Test FileReadStream
-        {
-            char buffer[16];
-            FILE *fp = Open(filename);
-            ASSERT_TRUE(fp != 0);
-            FileReadStream fs(fp, buffer, sizeof(buffer));
-            AutoUTFInputStream<unsigned, FileReadStream> eis(fs);
-            StringStream s(json_);
-            while (eis.Peek() != '\0') {
-                unsigned expected, actual;
-                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
-                EXPECT_TRUE(AutoUTF<unsigned>::Decode(eis, &actual));
-                EXPECT_EQ(expected, actual);
-            }
-            EXPECT_EQ('\0', s.Peek());
-            fclose(fp);
-        }
-
-        // Test MemoryStream
-        {
-            size_t size;
-            char* data = ReadFile(filename, true, &size);
-            MemoryStream ms(data, size);
-            AutoUTFInputStream<unsigned, MemoryStream> eis(ms);
-            StringStream s(json_);
-
-            while (eis.Peek() != '\0') {
-                unsigned expected, actual;
-                EXPECT_TRUE(UTF8<>::Decode(s, &expected));
-                EXPECT_TRUE(AutoUTF<unsigned>::Decode(eis, &actual));
-                EXPECT_EQ(expected, actual);
-            }
-            EXPECT_EQ('\0', s.Peek());
-            free(data);
-        }
-    }
-
-    template <typename FileEncoding, typename MemoryEncoding>
-    void TestEncodedOutputStream(const char* expectedFilename, bool putBOM) {
-        // Test FileWriteStream
-        {
-            char filename[L_tmpnam];
-            FILE* fp = TempFile(filename);
-            char buffer[16];
-            FileWriteStream os(fp, buffer, sizeof(buffer));
-            EncodedOutputStream<FileEncoding, FileWriteStream> eos(os, putBOM);
-            StringStream s(json_);
-            while (s.Peek() != '\0') {
-                bool success = Transcoder<UTF8<>, MemoryEncoding>::Transcode(s, eos);
-                EXPECT_TRUE(success);
-            }
-            eos.Flush();
-            fclose(fp);
-            EXPECT_TRUE(CompareFile(filename, expectedFilename));
-            remove(filename);
-        }
-
-        // Test MemoryBuffer
-        {
-            MemoryBuffer mb;
-            EncodedOutputStream<FileEncoding, MemoryBuffer> eos(mb, putBOM);
-            StringStream s(json_);
-            while (s.Peek() != '\0') {
-                bool success = Transcoder<UTF8<>, MemoryEncoding>::Transcode(s, eos);
-                EXPECT_TRUE(success);
-            }
-            eos.Flush();
-            EXPECT_TRUE(CompareBufferFile(mb.GetBuffer(), mb.GetSize(), expectedFilename));
-        }
-    }
-
-    void TestAutoUTFOutputStream(UTFType type, bool putBOM, const char *expectedFilename) {
-        // Test FileWriteStream
-        {
-            char filename[L_tmpnam];
-            FILE* fp = TempFile(filename);
-
-            char buffer[16];
-            FileWriteStream os(fp, buffer, sizeof(buffer));
-            AutoUTFOutputStream<unsigned, FileWriteStream> eos(os, type, putBOM);
-            StringStream s(json_);
-            while (s.Peek() != '\0') {
-                bool success = Transcoder<UTF8<>, AutoUTF<unsigned> >::Transcode(s, eos);
-                EXPECT_TRUE(success);
-            }
-            eos.Flush();
-            fclose(fp);
-            EXPECT_TRUE(CompareFile(filename, expectedFilename));
-            remove(filename);
-        }
-
-        // Test MemoryBuffer
-        {
-            MemoryBuffer mb;
-            AutoUTFOutputStream<unsigned, MemoryBuffer> eos(mb, type, putBOM);
-            StringStream s(json_);
-            while (s.Peek() != '\0') {
-                bool success = Transcoder<UTF8<>, AutoUTF<unsigned> >::Transcode(s, eos);
-                EXPECT_TRUE(success);
-            }
-            eos.Flush();
-            EXPECT_TRUE(CompareBufferFile(mb.GetBuffer(), mb.GetSize(), expectedFilename));
-        }
-    }
-
-    bool CompareFile(const char* filename, const char* expectedFilename) {
-        size_t actualLength, expectedLength;
-        char* actualBuffer = ReadFile(filename, false, &actualLength);
-        char* expectedBuffer = ReadFile(expectedFilename, true, &expectedLength);
-        bool ret = (expectedLength == actualLength) && memcmp(expectedBuffer, actualBuffer, actualLength) == 0;
-        free(actualBuffer);
-        free(expectedBuffer);
-        return ret;
-    }
-
-    bool CompareBufferFile(const char* actualBuffer, size_t actualLength, const char* expectedFilename) {
-        size_t expectedLength;
-        char* expectedBuffer = ReadFile(expectedFilename, true, &expectedLength);
-        bool ret = (expectedLength == actualLength) && memcmp(expectedBuffer, actualBuffer, actualLength) == 0;
-        free(expectedBuffer);
-        return ret;
-    }
-
-    char *json_;
-    size_t length_;
-};
-
-TEST_F(EncodedStreamTest, EncodedInputStream) {
-    TestEncodedInputStream<UTF8<>,    UTF8<>  >("utf8.json");
-    TestEncodedInputStream<UTF8<>,    UTF8<>  >("utf8bom.json");
-    TestEncodedInputStream<UTF16LE<>, UTF16<> >("utf16le.json");
-    TestEncodedInputStream<UTF16LE<>, UTF16<> >("utf16lebom.json");
-    TestEncodedInputStream<UTF16BE<>, UTF16<> >("utf16be.json");
-    TestEncodedInputStream<UTF16BE<>, UTF16<> >("utf16bebom.json");
-    TestEncodedInputStream<UTF32LE<>, UTF32<> >("utf32le.json");
-    TestEncodedInputStream<UTF32LE<>, UTF32<> >("utf32lebom.json");
-    TestEncodedInputStream<UTF32BE<>, UTF32<> >("utf32be.json");
-    TestEncodedInputStream<UTF32BE<>, UTF32<> >("utf32bebom.json");
-}
-
-TEST_F(EncodedStreamTest, AutoUTFInputStream) {
-    TestAutoUTFInputStream("utf8.json");
-    TestAutoUTFInputStream("utf8bom.json");
-    TestAutoUTFInputStream("utf16le.json");
-    TestAutoUTFInputStream("utf16lebom.json");
-    TestAutoUTFInputStream("utf16be.json");
-    TestAutoUTFInputStream("utf16bebom.json");
-    TestAutoUTFInputStream("utf32le.json");
-    TestAutoUTFInputStream("utf32lebom.json");
-    TestAutoUTFInputStream("utf32be.json");
-    TestAutoUTFInputStream("utf32bebom.json");
-}
-
-TEST_F(EncodedStreamTest, EncodedOutputStream) {
-    TestEncodedOutputStream<UTF8<>,     UTF8<>  >("utf8.json",      false);
-    TestEncodedOutputStream<UTF8<>,     UTF8<>  >("utf8bom.json",   true);
-    TestEncodedOutputStream<UTF16LE<>,  UTF16<> >("utf16le.json",   false);
-    TestEncodedOutputStream<UTF16LE<>,  UTF16<> >("utf16lebom.json",true);
-    TestEncodedOutputStream<UTF16BE<>,  UTF16<> >("utf16be.json",   false);
-    TestEncodedOutputStream<UTF16BE<>,  UTF16<> >("utf16bebom.json",true);
-    TestEncodedOutputStream<UTF32LE<>,  UTF32<> >("utf32le.json",   false);
-    TestEncodedOutputStream<UTF32LE<>,  UTF32<> >("utf32lebom.json",true);
-    TestEncodedOutputStream<UTF32BE<>,  UTF32<> >("utf32be.json",   false);
-    TestEncodedOutputStream<UTF32BE<>,  UTF32<> >("utf32bebom.json",true);
-}
-
-TEST_F(EncodedStreamTest, AutoUTFOutputStream) {
-    TestAutoUTFOutputStream(kUTF8,      false,  "utf8.json");
-    TestAutoUTFOutputStream(kUTF8,      true,   "utf8bom.json");
-    TestAutoUTFOutputStream(kUTF16LE,   false,  "utf16le.json");
-    TestAutoUTFOutputStream(kUTF16LE,   true,   "utf16lebom.json");
-    TestAutoUTFOutputStream(kUTF16BE,   false,  "utf16be.json");
-    TestAutoUTFOutputStream(kUTF16BE,   true,   "utf16bebom.json");
-    TestAutoUTFOutputStream(kUTF32LE,   false,  "utf32le.json");
-    TestAutoUTFOutputStream(kUTF32LE,   true,   "utf32lebom.json");
-    TestAutoUTFOutputStream(kUTF32BE,   false,  "utf32be.json");
-    TestAutoUTFOutputStream(kUTF32BE,   true,   "utf32bebom.json");
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodingstest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodingstest.cpp
deleted file mode 100644
index 3beebe6..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/encodingstest.cpp
+++ /dev/null
@@ -1,432 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"
-#include "rapidjson/stringbuffer.h"
-
-using namespace rapidjson;
-
-// Verification of encoders/decoders with Hoehrmann's UTF8 decoder
-
-// http://www.unicode.org/Public/UNIDATA/Blocks.txt
-static const unsigned kCodepointRanges[] = {
-    0x0000,     0x007F,     // Basic Latin
-    0x0080,     0x00FF,     // Latin-1 Supplement
-    0x0100,     0x017F,     // Latin Extended-A
-    0x0180,     0x024F,     // Latin Extended-B
-    0x0250,     0x02AF,     // IPA Extensions
-    0x02B0,     0x02FF,     // Spacing Modifier Letters
-    0x0300,     0x036F,     // Combining Diacritical Marks
-    0x0370,     0x03FF,     // Greek and Coptic
-    0x0400,     0x04FF,     // Cyrillic
-    0x0500,     0x052F,     // Cyrillic Supplement
-    0x0530,     0x058F,     // Armenian
-    0x0590,     0x05FF,     // Hebrew
-    0x0600,     0x06FF,     // Arabic
-    0x0700,     0x074F,     // Syriac
-    0x0750,     0x077F,     // Arabic Supplement
-    0x0780,     0x07BF,     // Thaana
-    0x07C0,     0x07FF,     // NKo
-    0x0800,     0x083F,     // Samaritan
-    0x0840,     0x085F,     // Mandaic
-    0x0900,     0x097F,     // Devanagari
-    0x0980,     0x09FF,     // Bengali
-    0x0A00,     0x0A7F,     // Gurmukhi
-    0x0A80,     0x0AFF,     // Gujarati
-    0x0B00,     0x0B7F,     // Oriya
-    0x0B80,     0x0BFF,     // Tamil
-    0x0C00,     0x0C7F,     // Telugu
-    0x0C80,     0x0CFF,     // Kannada
-    0x0D00,     0x0D7F,     // Malayalam
-    0x0D80,     0x0DFF,     // Sinhala
-    0x0E00,     0x0E7F,     // Thai
-    0x0E80,     0x0EFF,     // Lao
-    0x0F00,     0x0FFF,     // Tibetan
-    0x1000,     0x109F,     // Myanmar
-    0x10A0,     0x10FF,     // Georgian
-    0x1100,     0x11FF,     // Hangul Jamo
-    0x1200,     0x137F,     // Ethiopic
-    0x1380,     0x139F,     // Ethiopic Supplement
-    0x13A0,     0x13FF,     // Cherokee
-    0x1400,     0x167F,     // Unified Canadian Aboriginal Syllabics
-    0x1680,     0x169F,     // Ogham
-    0x16A0,     0x16FF,     // Runic
-    0x1700,     0x171F,     // Tagalog
-    0x1720,     0x173F,     // Hanunoo
-    0x1740,     0x175F,     // Buhid
-    0x1760,     0x177F,     // Tagbanwa
-    0x1780,     0x17FF,     // Khmer
-    0x1800,     0x18AF,     // Mongolian
-    0x18B0,     0x18FF,     // Unified Canadian Aboriginal Syllabics Extended
-    0x1900,     0x194F,     // Limbu
-    0x1950,     0x197F,     // Tai Le
-    0x1980,     0x19DF,     // New Tai Lue
-    0x19E0,     0x19FF,     // Khmer Symbols
-    0x1A00,     0x1A1F,     // Buginese
-    0x1A20,     0x1AAF,     // Tai Tham
-    0x1B00,     0x1B7F,     // Balinese
-    0x1B80,     0x1BBF,     // Sundanese
-    0x1BC0,     0x1BFF,     // Batak
-    0x1C00,     0x1C4F,     // Lepcha
-    0x1C50,     0x1C7F,     // Ol Chiki
-    0x1CD0,     0x1CFF,     // Vedic Extensions
-    0x1D00,     0x1D7F,     // Phonetic Extensions
-    0x1D80,     0x1DBF,     // Phonetic Extensions Supplement
-    0x1DC0,     0x1DFF,     // Combining Diacritical Marks Supplement
-    0x1E00,     0x1EFF,     // Latin Extended Additional
-    0x1F00,     0x1FFF,     // Greek Extended
-    0x2000,     0x206F,     // General Punctuation
-    0x2070,     0x209F,     // Superscripts and Subscripts
-    0x20A0,     0x20CF,     // Currency Symbols
-    0x20D0,     0x20FF,     // Combining Diacritical Marks for Symbols
-    0x2100,     0x214F,     // Letterlike Symbols
-    0x2150,     0x218F,     // Number Forms
-    0x2190,     0x21FF,     // Arrows
-    0x2200,     0x22FF,     // Mathematical Operators
-    0x2300,     0x23FF,     // Miscellaneous Technical
-    0x2400,     0x243F,     // Control Pictures
-    0x2440,     0x245F,     // Optical Character Recognition
-    0x2460,     0x24FF,     // Enclosed Alphanumerics
-    0x2500,     0x257F,     // Box Drawing
-    0x2580,     0x259F,     // Block Elements
-    0x25A0,     0x25FF,     // Geometric Shapes
-    0x2600,     0x26FF,     // Miscellaneous Symbols
-    0x2700,     0x27BF,     // Dingbats
-    0x27C0,     0x27EF,     // Miscellaneous Mathematical Symbols-A
-    0x27F0,     0x27FF,     // Supplemental Arrows-A
-    0x2800,     0x28FF,     // Braille Patterns
-    0x2900,     0x297F,     // Supplemental Arrows-B
-    0x2980,     0x29FF,     // Miscellaneous Mathematical Symbols-B
-    0x2A00,     0x2AFF,     // Supplemental Mathematical Operators
-    0x2B00,     0x2BFF,     // Miscellaneous Symbols and Arrows
-    0x2C00,     0x2C5F,     // Glagolitic
-    0x2C60,     0x2C7F,     // Latin Extended-C
-    0x2C80,     0x2CFF,     // Coptic
-    0x2D00,     0x2D2F,     // Georgian Supplement
-    0x2D30,     0x2D7F,     // Tifinagh
-    0x2D80,     0x2DDF,     // Ethiopic Extended
-    0x2DE0,     0x2DFF,     // Cyrillic Extended-A
-    0x2E00,     0x2E7F,     // Supplemental Punctuation
-    0x2E80,     0x2EFF,     // CJK Radicals Supplement
-    0x2F00,     0x2FDF,     // Kangxi Radicals
-    0x2FF0,     0x2FFF,     // Ideographic Description Characters
-    0x3000,     0x303F,     // CJK Symbols and Punctuation
-    0x3040,     0x309F,     // Hiragana
-    0x30A0,     0x30FF,     // Katakana
-    0x3100,     0x312F,     // Bopomofo
-    0x3130,     0x318F,     // Hangul Compatibility Jamo
-    0x3190,     0x319F,     // Kanbun
-    0x31A0,     0x31BF,     // Bopomofo Extended
-    0x31C0,     0x31EF,     // CJK Strokes
-    0x31F0,     0x31FF,     // Katakana Phonetic Extensions
-    0x3200,     0x32FF,     // Enclosed CJK Letters and Months
-    0x3300,     0x33FF,     // CJK Compatibility
-    0x3400,     0x4DBF,     // CJK Unified Ideographs Extension A
-    0x4DC0,     0x4DFF,     // Yijing Hexagram Symbols
-    0x4E00,     0x9FFF,     // CJK Unified Ideographs
-    0xA000,     0xA48F,     // Yi Syllables
-    0xA490,     0xA4CF,     // Yi Radicals
-    0xA4D0,     0xA4FF,     // Lisu
-    0xA500,     0xA63F,     // Vai
-    0xA640,     0xA69F,     // Cyrillic Extended-B
-    0xA6A0,     0xA6FF,     // Bamum
-    0xA700,     0xA71F,     // Modifier Tone Letters
-    0xA720,     0xA7FF,     // Latin Extended-D
-    0xA800,     0xA82F,     // Syloti Nagri
-    0xA830,     0xA83F,     // Common Indic Number Forms
-    0xA840,     0xA87F,     // Phags-pa
-    0xA880,     0xA8DF,     // Saurashtra
-    0xA8E0,     0xA8FF,     // Devanagari Extended
-    0xA900,     0xA92F,     // Kayah Li
-    0xA930,     0xA95F,     // Rejang
-    0xA960,     0xA97F,     // Hangul Jamo Extended-A
-    0xA980,     0xA9DF,     // Javanese
-    0xAA00,     0xAA5F,     // Cham
-    0xAA60,     0xAA7F,     // Myanmar Extended-A
-    0xAA80,     0xAADF,     // Tai Viet
-    0xAB00,     0xAB2F,     // Ethiopic Extended-A
-    0xABC0,     0xABFF,     // Meetei Mayek
-    0xAC00,     0xD7AF,     // Hangul Syllables
-    0xD7B0,     0xD7FF,     // Hangul Jamo Extended-B
-    //0xD800,       0xDB7F,     // High Surrogates
-    //0xDB80,       0xDBFF,     // High Private Use Surrogates
-    //0xDC00,       0xDFFF,     // Low Surrogates
-    0xE000,     0xF8FF,     // Private Use Area
-    0xF900,     0xFAFF,     // CJK Compatibility Ideographs
-    0xFB00,     0xFB4F,     // Alphabetic Presentation Forms
-    0xFB50,     0xFDFF,     // Arabic Presentation Forms-A
-    0xFE00,     0xFE0F,     // Variation Selectors
-    0xFE10,     0xFE1F,     // Vertical Forms
-    0xFE20,     0xFE2F,     // Combining Half Marks
-    0xFE30,     0xFE4F,     // CJK Compatibility Forms
-    0xFE50,     0xFE6F,     // Small Form Variants
-    0xFE70,     0xFEFF,     // Arabic Presentation Forms-B
-    0xFF00,     0xFFEF,     // Halfwidth and Fullwidth Forms
-    0xFFF0,     0xFFFF,     // Specials
-    0x10000,    0x1007F,    // Linear B Syllabary
-    0x10080,    0x100FF,    // Linear B Ideograms
-    0x10100,    0x1013F,    // Aegean Numbers
-    0x10140,    0x1018F,    // Ancient Greek Numbers
-    0x10190,    0x101CF,    // Ancient Symbols
-    0x101D0,    0x101FF,    // Phaistos Disc
-    0x10280,    0x1029F,    // Lycian
-    0x102A0,    0x102DF,    // Carian
-    0x10300,    0x1032F,    // Old Italic
-    0x10330,    0x1034F,    // Gothic
-    0x10380,    0x1039F,    // Ugaritic
-    0x103A0,    0x103DF,    // Old Persian
-    0x10400,    0x1044F,    // Deseret
-    0x10450,    0x1047F,    // Shavian
-    0x10480,    0x104AF,    // Osmanya
-    0x10800,    0x1083F,    // Cypriot Syllabary
-    0x10840,    0x1085F,    // Imperial Aramaic
-    0x10900,    0x1091F,    // Phoenician
-    0x10920,    0x1093F,    // Lydian
-    0x10A00,    0x10A5F,    // Kharoshthi
-    0x10A60,    0x10A7F,    // Old South Arabian
-    0x10B00,    0x10B3F,    // Avestan
-    0x10B40,    0x10B5F,    // Inscriptional Parthian
-    0x10B60,    0x10B7F,    // Inscriptional Pahlavi
-    0x10C00,    0x10C4F,    // Old Turkic
-    0x10E60,    0x10E7F,    // Rumi Numeral Symbols
-    0x11000,    0x1107F,    // Brahmi
-    0x11080,    0x110CF,    // Kaithi
-    0x12000,    0x123FF,    // Cuneiform
-    0x12400,    0x1247F,    // Cuneiform Numbers and Punctuation
-    0x13000,    0x1342F,    // Egyptian Hieroglyphs
-    0x16800,    0x16A3F,    // Bamum Supplement
-    0x1B000,    0x1B0FF,    // Kana Supplement
-    0x1D000,    0x1D0FF,    // Byzantine Musical Symbols
-    0x1D100,    0x1D1FF,    // Musical Symbols
-    0x1D200,    0x1D24F,    // Ancient Greek Musical Notation
-    0x1D300,    0x1D35F,    // Tai Xuan Jing Symbols
-    0x1D360,    0x1D37F,    // Counting Rod Numerals
-    0x1D400,    0x1D7FF,    // Mathematical Alphanumeric Symbols
-    0x1F000,    0x1F02F,    // Mahjong Tiles
-    0x1F030,    0x1F09F,    // Domino Tiles
-    0x1F0A0,    0x1F0FF,    // Playing Cards
-    0x1F100,    0x1F1FF,    // Enclosed Alphanumeric Supplement
-    0x1F200,    0x1F2FF,    // Enclosed Ideographic Supplement
-    0x1F300,    0x1F5FF,    // Miscellaneous Symbols And Pictographs
-    0x1F600,    0x1F64F,    // Emoticons
-    0x1F680,    0x1F6FF,    // Transport And Map Symbols
-    0x1F700,    0x1F77F,    // Alchemical Symbols
-    0x20000,    0x2A6DF,    // CJK Unified Ideographs Extension B
-    0x2A700,    0x2B73F,    // CJK Unified Ideographs Extension C
-    0x2B740,    0x2B81F,    // CJK Unified Ideographs Extension D
-    0x2F800,    0x2FA1F,    // CJK Compatibility Ideographs Supplement
-    0xE0000,    0xE007F,    // Tags
-    0xE0100,    0xE01EF,    // Variation Selectors Supplement
-    0xF0000,    0xFFFFF,    // Supplementary Private Use Area-A
-    0x100000,   0x10FFFF,   // Supplementary Private Use Area-B
-    0xFFFFFFFF
-};
-
-// Copyright (c) 2008-2010 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-// See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
-
-#define UTF8_ACCEPT 0u
-#define UTF8_REJECT 12u
-
-static const unsigned char utf8d[] = {
-    // The first part of the table maps bytes to character classes that
-    // to reduce the size of the transition table and create bitmasks.
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-    10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8,
-
-    // The second part is a transition table that maps a combination
-    // of a state of the automaton and a character class to a state.
-    0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12,
-    12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12,
-    12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12,
-    12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12,
-    12,36,12,12,12,12,12,12,12,12,12,12, 
-};
-
-static unsigned inline decode(unsigned* state, unsigned* codep, unsigned byte) {
-    unsigned type = utf8d[byte];
-
-    *codep = (*state != UTF8_ACCEPT) ?
-        (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
-
-    *state = utf8d[256 + *state + type];
-    return *state;
-}
-
-//static bool IsUTF8(unsigned char* s) {
-//  unsigned codepoint, state = 0;
-//
-//  while (*s)
-//      decode(&state, &codepoint, *s++);
-//
-//  return state == UTF8_ACCEPT;
-//}
-
-TEST(EncodingsTest, UTF8) {
-    StringBuffer os, os2;
-    for (const unsigned* range = kCodepointRanges; *range != 0xFFFFFFFF; range += 2) {
-        for (unsigned codepoint = range[0]; codepoint <= range[1]; ++codepoint) {
-            os.Clear();
-            UTF8<>::Encode(os, codepoint);
-            const char* encodedStr = os.GetString();
-
-            // Decode with Hoehrmann
-            {
-                unsigned decodedCodepoint = 0;
-                unsigned state = 0;
-
-                unsigned decodedCount = 0;
-                for (const char* s = encodedStr; *s; ++s)
-                    if (!decode(&state, &decodedCodepoint, (unsigned char)*s)) {
-                        EXPECT_EQ(codepoint, decodedCodepoint);
-                        decodedCount++;
-                    }
-
-                if (*encodedStr)                // This decoder cannot handle U+0000
-                    EXPECT_EQ(1u, decodedCount);    // Should only contain one code point
-
-                EXPECT_EQ(UTF8_ACCEPT, state);
-                if (UTF8_ACCEPT != state)
-                    std::cout << std::hex << codepoint << " " << decodedCodepoint << std::endl;
-            }
-
-            // Decode
-            {
-                StringStream is(encodedStr);
-                unsigned decodedCodepoint;
-                bool result = UTF8<>::Decode(is, &decodedCodepoint);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(codepoint, decodedCodepoint);
-                if (!result || codepoint != decodedCodepoint)
-                    std::cout << std::hex << codepoint << " " << decodedCodepoint << std::endl;
-            }
-
-            // Validate
-            {
-                StringStream is(encodedStr);
-                os2.Clear();
-                bool result = UTF8<>::Validate(is, os2);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(0, StrCmp(encodedStr, os2.GetString()));
-            }
-        }
-    }
-}
-
-TEST(EncodingsTest, UTF16) {
-    GenericStringBuffer<UTF16<> > os, os2;
-    GenericStringBuffer<UTF8<> > utf8os;
-    for (const unsigned* range = kCodepointRanges; *range != 0xFFFFFFFF; range += 2) {
-        for (unsigned codepoint = range[0]; codepoint <= range[1]; ++codepoint) {
-            os.Clear();
-            UTF16<>::Encode(os, codepoint);
-            const UTF16<>::Ch* encodedStr = os.GetString();
-
-            // Encode with Hoehrmann's code
-            if (codepoint != 0) // cannot handle U+0000
-            {
-                // encode with UTF8<> first
-                utf8os.Clear();
-                UTF8<>::Encode(utf8os, codepoint);
-
-                // transcode from UTF8 to UTF16 with Hoehrmann's code
-                unsigned decodedCodepoint = 0;
-                unsigned state = 0;
-                UTF16<>::Ch buffer[3], *p = &buffer[0];
-                for (const char* s = utf8os.GetString(); *s; ++s) {
-                    if (!decode(&state, &decodedCodepoint, (unsigned char)*s))
-                        break;
-                }
-
-                if (codepoint <= 0xFFFF)
-                    *p++ = static_cast<UTF16<>::Ch>(decodedCodepoint);
-                else {
-                    // Encode code points above U+FFFF as surrogate pair.
-                    *p++ = static_cast<UTF16<>::Ch>(0xD7C0 + (decodedCodepoint >> 10));
-                    *p++ = static_cast<UTF16<>::Ch>(0xDC00 + (decodedCodepoint & 0x3FF));
-                }
-                *p++ = '\0';
-
-                EXPECT_EQ(0, StrCmp(buffer, encodedStr));
-            }
-
-            // Decode
-            {
-                GenericStringStream<UTF16<> > is(encodedStr);
-                unsigned decodedCodepoint;
-                bool result = UTF16<>::Decode(is, &decodedCodepoint);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(codepoint, decodedCodepoint);         
-                if (!result || codepoint != decodedCodepoint)
-                    std::cout << std::hex << codepoint << " " << decodedCodepoint << std::endl;
-            }
-
-            // Validate
-            {
-                GenericStringStream<UTF16<> > is(encodedStr);
-                os2.Clear();
-                bool result = UTF16<>::Validate(is, os2);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(0, StrCmp(encodedStr, os2.GetString()));
-            }
-        }
-    }
-}
-
-TEST(EncodingsTest, UTF32) {
-    GenericStringBuffer<UTF32<> > os, os2;
-    for (const unsigned* range = kCodepointRanges; *range != 0xFFFFFFFF; range += 2) {
-        for (unsigned codepoint = range[0]; codepoint <= range[1]; ++codepoint) {
-            os.Clear();
-            UTF32<>::Encode(os, codepoint);
-            const UTF32<>::Ch* encodedStr = os.GetString();
-
-            // Decode
-            {
-                GenericStringStream<UTF32<> > is(encodedStr);
-                unsigned decodedCodepoint;
-                bool result = UTF32<>::Decode(is, &decodedCodepoint);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(codepoint, decodedCodepoint);         
-                if (!result || codepoint != decodedCodepoint)
-                    std::cout << std::hex << codepoint << " " << decodedCodepoint << std::endl;
-            }
-
-            // Validate
-            {
-                GenericStringStream<UTF32<> > is(encodedStr);
-                os2.Clear();
-                bool result = UTF32<>::Validate(is, os2);
-                EXPECT_TRUE(result);
-                EXPECT_EQ(0, StrCmp(encodedStr, os2.GetString()));
-            }
-        }
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/filestreamtest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/filestreamtest.cpp
deleted file mode 100644
index a176332..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/filestreamtest.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/filestream.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"
-
-using namespace rapidjson;
-
-class FileStreamTest : public ::testing::Test {
-public:
-    FileStreamTest() : filename_(), json_(), length_() {}
-
-    virtual void SetUp() {
-        FILE *fp = fopen(filename_ = "data/sample.json", "rb");
-        if (!fp) 
-            fp = fopen(filename_ = "../../bin/data/sample.json", "rb");
-        ASSERT_TRUE(fp != 0);
-
-        fseek(fp, 0, SEEK_END);
-        length_ = (size_t)ftell(fp);
-        fseek(fp, 0, SEEK_SET);
-        json_ = (char*)malloc(length_ + 1);
-        size_t readLength = fread(json_, 1, length_, fp);
-        json_[readLength] = '\0';
-        fclose(fp);
-    }
-
-    virtual void TearDown() {
-        free(json_);
-        json_ = 0;
-    }
-
-private:
-    FileStreamTest(const FileStreamTest&);
-    FileStreamTest& operator=(const FileStreamTest&);
-    
-protected:
-    const char* filename_;
-    char *json_;
-    size_t length_;
-};
-
-// Deprecated
-//TEST_F(FileStreamTest, FileStream_Read) {
-//  FILE *fp = fopen(filename_, "rb");
-//  ASSERT_TRUE(fp != 0);
-//  FileStream s(fp);
-//
-//  for (size_t i = 0; i < length_; i++) {
-//      EXPECT_EQ(json_[i], s.Peek());
-//      EXPECT_EQ(json_[i], s.Peek());  // 2nd time should be the same
-//      EXPECT_EQ(json_[i], s.Take());
-//  }
-//
-//  EXPECT_EQ(length_, s.Tell());
-//  EXPECT_EQ('\0', s.Peek());
-//
-//  fclose(fp);
-//}
-
-TEST_F(FileStreamTest, FileReadStream) {
-    FILE *fp = fopen(filename_, "rb");
-    ASSERT_TRUE(fp != 0);
-    char buffer[65536];
-    FileReadStream s(fp, buffer, sizeof(buffer));
-
-    for (size_t i = 0; i < length_; i++) {
-        EXPECT_EQ(json_[i], s.Peek());
-        EXPECT_EQ(json_[i], s.Peek());  // 2nd time should be the same
-        EXPECT_EQ(json_[i], s.Take());
-    }
-
-    EXPECT_EQ(length_, s.Tell());
-    EXPECT_EQ('\0', s.Peek());
-
-    fclose(fp);
-}
-
-TEST_F(FileStreamTest, FileWriteStream) {
-    char filename[L_tmpnam];
-    FILE* fp = TempFile(filename);
-
-    char buffer[65536];
-    FileWriteStream os(fp, buffer, sizeof(buffer));
-    for (size_t i = 0; i < length_; i++)
-        os.Put(json_[i]);
-    os.Flush();
-    fclose(fp);
-
-    // Read it back to verify
-    fp = fopen(filename, "rb");
-    FileReadStream is(fp, buffer, sizeof(buffer));
-
-    for (size_t i = 0; i < length_; i++)
-        EXPECT_EQ(json_[i], is.Take());
-
-    EXPECT_EQ(length_, is.Tell());
-    fclose(fp);
-
-    //std::cout << filename << std::endl;
-    remove(filename);
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/jsoncheckertest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/jsoncheckertest.cpp
deleted file mode 100644
index caa1b8a..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/jsoncheckertest.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-#include "rapidjson/document.h"
-
-using namespace rapidjson;
-
-static char* ReadFile(const char* filename, size_t& length) {
-    FILE *fp = fopen(filename, "rb");
-    if (!fp)
-        fp = fopen(filename, "rb");
-    if (!fp)
-        return 0;
-
-    fseek(fp, 0, SEEK_END);
-    length = (size_t)ftell(fp);
-    fseek(fp, 0, SEEK_SET);
-    char* json = (char*)malloc(length + 1);
-    size_t readLength = fread(json, 1, length, fp);
-    json[readLength] = '\0';
-    fclose(fp);
-    return json;
-}
-
-TEST(JsonChecker, Reader) {
-    char filename[256];
-
-    // jsonchecker/failXX.json
-    for (int i = 1; i <= 33; i++) {
-        if (i == 1) // fail1.json is valid in rapidjson, which has no limitation on type of root element (RFC 7159).
-            continue;
-        if (i == 18)    // fail18.json is valid in rapidjson, which has no limitation on depth of nesting.
-            continue;
-
-        sprintf(filename, "jsonchecker/fail%d.json", i);
-        size_t length;
-        char* json = ReadFile(filename, length);
-        if (!json) {
-            sprintf(filename, "../../bin/jsonchecker/fail%d.json", i);
-            json = ReadFile(filename, length);
-            if (!json) {
-                printf("jsonchecker file %s not found", filename);
-                ADD_FAILURE();
-                continue;
-            }
-        }
-
-        GenericDocument<UTF8<>, CrtAllocator> document; // Use Crt allocator to check exception-safety (no memory leak)
-        document.Parse((const char*)json);
-        EXPECT_TRUE(document.HasParseError());
-
-        document.Parse<kParseIterativeFlag>((const char*)json);
-        EXPECT_TRUE(document.HasParseError());
-
-        free(json);
-    }
-
-    // passX.json
-    for (int i = 1; i <= 3; i++) {
-        sprintf(filename, "jsonchecker/pass%d.json", i);
-        size_t length;
-        char* json = ReadFile(filename, length);
-        if (!json) {
-            sprintf(filename, "../../bin/jsonchecker/pass%d.json", i);
-            json = ReadFile(filename, length);
-            if (!json) {
-                printf("jsonchecker file %s not found", filename);
-                continue;
-            }
-        }
-
-        GenericDocument<UTF8<>, CrtAllocator> document; // Use Crt allocator to check exception-safety (no memory leak)
-        document.Parse((const char*)json);
-        EXPECT_FALSE(document.HasParseError());
-
-        document.Parse<kParseIterativeFlag>((const char*)json);
-        EXPECT_FALSE(document.HasParseError());
-
-        free(json);
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/namespacetest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/namespacetest.cpp
deleted file mode 100644
index ed74ae3..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/namespacetest.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-// test another instantiation of RapidJSON in a different namespace 
-
-#define RAPIDJSON_NAMESPACE my::rapid::json
-#define RAPIDJSON_NAMESPACE_BEGIN namespace my { namespace rapid { namespace json {
-#define RAPIDJSON_NAMESPACE_END } } }
-
-// include lots of RapidJSON files
-
-#include "rapidjson/document.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/filereadstream.h"
-#include "rapidjson/filewritestream.h"
-#include "rapidjson/encodedstream.h"
-#include "rapidjson/stringbuffer.h"
-
-static const char json[] = "{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3,4]}";
-
-TEST(NamespaceTest,Using) {
-    using namespace RAPIDJSON_NAMESPACE;
-    typedef GenericDocument<UTF8<>, CrtAllocator> DocumentType;
-    DocumentType doc;
-
-    doc.Parse(json);
-    EXPECT_TRUE(!doc.HasParseError());
-}
-
-TEST(NamespaceTest,Direct) {
-    typedef RAPIDJSON_NAMESPACE::Document Document;
-    typedef RAPIDJSON_NAMESPACE::Reader Reader;
-    typedef RAPIDJSON_NAMESPACE::StringStream StringStream;
-    typedef RAPIDJSON_NAMESPACE::StringBuffer StringBuffer;
-    typedef RAPIDJSON_NAMESPACE::Writer<StringBuffer> WriterType;
-
-    StringStream s(json);
-    StringBuffer buffer;
-    WriterType writer(buffer);
-    buffer.ShrinkToFit();
-    Reader reader;
-    reader.Parse(s, writer);
-
-    EXPECT_STREQ(json, buffer.GetString());
-    EXPECT_EQ(sizeof(json)-1, buffer.GetSize());
-    EXPECT_TRUE(writer.IsComplete());
-
-    Document doc;
-    doc.Parse(buffer.GetString());
-    EXPECT_TRUE(!doc.HasParseError());
-
-    buffer.Clear();
-    writer.Reset(buffer);
-    doc.Accept(writer);
-    EXPECT_STREQ(json, buffer.GetString());
-    EXPECT_TRUE(writer.IsComplete());
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/readertest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/readertest.cpp
deleted file mode 100644
index 64904b0..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/readertest.cpp
+++ /dev/null
@@ -1,1173 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-#include "rapidjson/reader.h"
-#include "rapidjson/internal/dtoa.h"
-#include "rapidjson/internal/itoa.h"
-#include "rapidjson/memorystream.h"
-
-using namespace rapidjson;
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_PUSH
-RAPIDJSON_DIAG_OFF(effc++)
-#endif
-
-template<bool expect>
-struct ParseBoolHandler : BaseReaderHandler<UTF8<>, ParseBoolHandler<expect> > {
-    ParseBoolHandler() : step_(0) {}
-    bool Default() { ADD_FAILURE(); return false; }
-    // gcc 4.8.x generates warning in EXPECT_EQ(bool, bool) on this gtest version.
-    // Workaround with EXPECT_TRUE().
-    bool Bool(bool b) { /*EXPECT_EQ(expect, b); */EXPECT_TRUE(expect == b);  ++step_; return true; }
-
-    unsigned step_;
-};
-
-TEST(Reader, ParseTrue) {
-    StringStream s("true");
-    ParseBoolHandler<true> h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(1u, h.step_);
-}
-
-TEST(Reader, ParseFalse) {
-    StringStream s("false");
-    ParseBoolHandler<false> h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(1u, h.step_);
-}
-
-struct ParseIntHandler : BaseReaderHandler<UTF8<>, ParseIntHandler> {
-    ParseIntHandler() : step_(0), actual_() {}
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Int(int i) { actual_ = i; step_++; return true; }
-
-    unsigned step_;
-    int actual_;
-};
-
-struct ParseUintHandler : BaseReaderHandler<UTF8<>, ParseUintHandler> {
-    ParseUintHandler() : step_(0), actual_() {}
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Uint(unsigned i) { actual_ = i; step_++; return true; }
-
-    unsigned step_;
-    unsigned actual_;
-};
-
-struct ParseInt64Handler : BaseReaderHandler<UTF8<>, ParseInt64Handler> {
-    ParseInt64Handler() : step_(0), actual_() {}
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Int64(int64_t i) { actual_ = i; step_++; return true; }
-
-    unsigned step_;
-    int64_t actual_;
-};
-
-struct ParseUint64Handler : BaseReaderHandler<UTF8<>, ParseUint64Handler> {
-    ParseUint64Handler() : step_(0), actual_() {}
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Uint64(uint64_t i) { actual_ = i; step_++; return true; }
-
-    unsigned step_;
-    uint64_t actual_;
-};
-
-struct ParseDoubleHandler : BaseReaderHandler<UTF8<>, ParseDoubleHandler> {
-    ParseDoubleHandler() : step_(0), actual_() {}
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Double(double d) { actual_ = d; step_++; return true; }
-
-    unsigned step_;
-    double actual_;
-};
-
-TEST(Reader, ParseNumber_Integer) {
-#define TEST_INTEGER(Handler, str, x) \
-    { \
-        StringStream s(str); \
-        Handler h; \
-        Reader reader; \
-        reader.Parse(s, h); \
-        EXPECT_EQ(1u, h.step_); \
-        EXPECT_EQ(x, h.actual_); \
-    }
-
-    TEST_INTEGER(ParseUintHandler, "0", 0u);
-    TEST_INTEGER(ParseUintHandler, "123", 123u);
-    TEST_INTEGER(ParseUintHandler, "2147483648", 2147483648u);       // 2^31 - 1 (cannot be stored in int)
-    TEST_INTEGER(ParseUintHandler, "4294967295", 4294967295u);
-
-    TEST_INTEGER(ParseIntHandler, "-123", -123);
-    TEST_INTEGER(ParseIntHandler, "-2147483648", static_cast<int32_t>(0x80000000));     // -2^31 (min of int)
-
-    TEST_INTEGER(ParseUint64Handler, "4294967296", RAPIDJSON_UINT64_C2(1, 0));   // 2^32 (max of unsigned + 1, force to use uint64_t)
-    TEST_INTEGER(ParseUint64Handler, "18446744073709551615", RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF));   // 2^64 - 1 (max of uint64_t)
-
-    TEST_INTEGER(ParseInt64Handler, "-2147483649", static_cast<int64_t>(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0x7FFFFFFF)));   // -2^31 -1 (min of int - 1, force to use int64_t)
-    TEST_INTEGER(ParseInt64Handler, "-9223372036854775808", static_cast<int64_t>(RAPIDJSON_UINT64_C2(0x80000000, 0x00000000)));       // -2^63 (min of int64_t)
-
-    // Random test for uint32_t/int32_t
-    {
-        union {
-            uint32_t u;
-            int32_t i;
-        }u;
-        Random r;
-
-        for (unsigned i = 0; i < 100000; i++) {
-            u.u = r();
-
-            char buffer[32];
-            *internal::u32toa(u.u, buffer) = '\0';
-            TEST_INTEGER(ParseUintHandler, buffer, u.u);
-
-            if (u.i < 0) {
-                *internal::i32toa(u.i, buffer) = '\0';
-                TEST_INTEGER(ParseIntHandler, buffer, u.i);
-            }
-        }
-    }
-
-    // Random test for uint64_t/int64_t
-    {
-        union {
-            uint64_t u;
-            int64_t i;
-        }u;
-        Random r;
-
-        for (unsigned i = 0; i < 100000; i++) {
-            u.u = uint64_t(r()) << 32;
-            u.u |= r();
-
-            char buffer[32];
-            if (u.u >= 4294967296ULL) {
-                *internal::u64toa(u.u, buffer) = '\0';
-                TEST_INTEGER(ParseUint64Handler, buffer, u.u);
-            }
-
-            if (u.i <= -2147483649LL) {
-                *internal::i64toa(u.i, buffer) = '\0';
-                TEST_INTEGER(ParseInt64Handler, buffer, u.i);
-            }
-        }
-    }
-#undef TEST_INTEGER
-}
-
-template<bool fullPrecision>
-static void TestParseDouble() {
-#define TEST_DOUBLE(fullPrecision, str, x) \
-    { \
-        StringStream s(str); \
-        ParseDoubleHandler h; \
-        Reader reader; \
-        ASSERT_EQ(kParseErrorNone, reader.Parse<fullPrecision ? kParseFullPrecisionFlag : 0>(s, h).Code()); \
-        EXPECT_EQ(1u, h.step_); \
-        if (fullPrecision) { \
-            EXPECT_EQ(x, h.actual_); \
-            if (x != h.actual_) \
-            printf("  String: %s\n  Actual: %.17g\nExpected: %.17g\n", str, h.actual_, x); \
-        } \
-        else \
-            EXPECT_DOUBLE_EQ(x, h.actual_); \
-    }
-    
-    TEST_DOUBLE(fullPrecision, "0.0", 0.0);
-    TEST_DOUBLE(fullPrecision, "1.0", 1.0);
-    TEST_DOUBLE(fullPrecision, "-1.0", -1.0);
-    TEST_DOUBLE(fullPrecision, "1.5", 1.5);
-    TEST_DOUBLE(fullPrecision, "-1.5", -1.5);
-    TEST_DOUBLE(fullPrecision, "3.1416", 3.1416);
-    TEST_DOUBLE(fullPrecision, "1E10", 1E10);
-    TEST_DOUBLE(fullPrecision, "1e10", 1e10);
-    TEST_DOUBLE(fullPrecision, "1E+10", 1E+10);
-    TEST_DOUBLE(fullPrecision, "1E-10", 1E-10);
-    TEST_DOUBLE(fullPrecision, "-1E10", -1E10);
-    TEST_DOUBLE(fullPrecision, "-1e10", -1e10);
-    TEST_DOUBLE(fullPrecision, "-1E+10", -1E+10);
-    TEST_DOUBLE(fullPrecision, "-1E-10", -1E-10);
-    TEST_DOUBLE(fullPrecision, "1.234E+10", 1.234E+10);
-    TEST_DOUBLE(fullPrecision, "1.234E-10", 1.234E-10);
-    TEST_DOUBLE(fullPrecision, "1.79769e+308", 1.79769e+308);
-    TEST_DOUBLE(fullPrecision, "2.22507e-308", 2.22507e-308);
-    TEST_DOUBLE(fullPrecision, "-1.79769e+308", -1.79769e+308);
-    TEST_DOUBLE(fullPrecision, "-2.22507e-308", -2.22507e-308);
-    TEST_DOUBLE(fullPrecision, "4.9406564584124654e-324", 4.9406564584124654e-324); // minimum denormal
-    TEST_DOUBLE(fullPrecision, "2.2250738585072009e-308", 2.2250738585072009e-308); // Max subnormal double
-    TEST_DOUBLE(fullPrecision, "2.2250738585072014e-308", 2.2250738585072014e-308); // Min normal positive double
-    TEST_DOUBLE(fullPrecision, "1.7976931348623157e+308", 1.7976931348623157e+308); // Max double
-    TEST_DOUBLE(fullPrecision, "1e-10000", 0.0);                                   // must underflow
-    TEST_DOUBLE(fullPrecision, "18446744073709551616", 18446744073709551616.0);    // 2^64 (max of uint64_t + 1, force to use double)
-    TEST_DOUBLE(fullPrecision, "-9223372036854775809", -9223372036854775809.0);    // -2^63 - 1(min of int64_t + 1, force to use double)
-    TEST_DOUBLE(fullPrecision, "0.9868011474609375", 0.9868011474609375);          // https://github.com/miloyip/rapidjson/issues/120
-    TEST_DOUBLE(fullPrecision, "123e34", 123e34);                                  // Fast Path Cases In Disguise
-    TEST_DOUBLE(fullPrecision, "45913141877270640000.0", 45913141877270640000.0);
-    TEST_DOUBLE(fullPrecision, "2.2250738585072011e-308", 2.2250738585072011e-308); // http://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
-
-    // Since
-    // abs((2^-1022 - 2^-1074) - 2.2250738585072012e-308) = 3.109754131239141401123495768877590405345064751974375599... �� 10^-324
-    // abs((2^-1022) - 2.2250738585072012e-308) = 1.830902327173324040642192159804623318305533274168872044... �� 10 ^ -324
-    // So 2.2250738585072012e-308 should round to 2^-1022 = 2.2250738585072014e-308
-    TEST_DOUBLE(fullPrecision, "2.2250738585072012e-308", 2.2250738585072014e-308); // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
-
-    // More closer to normal/subnormal boundary
-    // boundary = 2^-1022 - 2^-1075 = 2.225073858507201136057409796709131975934819546351645648... �� 10^-308
-    TEST_DOUBLE(fullPrecision, "2.22507385850720113605740979670913197593481954635164564e-308", 2.2250738585072009e-308);
-    TEST_DOUBLE(fullPrecision, "2.22507385850720113605740979670913197593481954635164565e-308", 2.2250738585072014e-308);
-
-    // 1.0 is in (1.0 - 2^-54, 1.0 + 2^-53)
-    // 1.0 - 2^-54 = 0.999999999999999944488848768742172978818416595458984375
-    TEST_DOUBLE(fullPrecision, "0.999999999999999944488848768742172978818416595458984375", 1.0); // round to even
-    TEST_DOUBLE(fullPrecision, "0.999999999999999944488848768742172978818416595458984374", 0.99999999999999989); // previous double
-    TEST_DOUBLE(fullPrecision, "0.999999999999999944488848768742172978818416595458984376", 1.0); // next double
-    // 1.0 + 2^-53 = 1.00000000000000011102230246251565404236316680908203125
-    TEST_DOUBLE(fullPrecision, "1.00000000000000011102230246251565404236316680908203125", 1.0); // round to even
-    TEST_DOUBLE(fullPrecision, "1.00000000000000011102230246251565404236316680908203124", 1.0); // previous double
-    TEST_DOUBLE(fullPrecision, "1.00000000000000011102230246251565404236316680908203126", 1.00000000000000022); // next double
-
-    {
-        char n1e308[310];   // '1' followed by 308 '0'
-        n1e308[0] = '1';
-        for (int i = 1; i < 309; i++)
-            n1e308[i] = '0';
-        n1e308[309] = '\0';
-        TEST_DOUBLE(fullPrecision, n1e308, 1E308);
-    }
-
-#if 0 // Very slow
-    static const unsigned count = 10000000;
-    // Random test for double
-    {
-        Random r;
-
-        for (unsigned i = 0; i < count; i++) {
-            internal::Double d;
-            do {
-                // Need to call r() in two statements for cross-platform coherent sequence.
-                uint64_t u = uint64_t(r()) << 32;
-                u |= uint64_t(r());
-                d = internal::Double(u);
-            } while (d.IsNan() || d.IsInf()/* || !d.IsNormal()*/);  // Also work for subnormal now
-
-            char buffer[32];
-            *internal::dtoa(d.Value(), buffer) = '\0';
-            TEST_DOUBLE(fullPrecision, buffer, d.Value());
-        }
-    }
-#endif
-
-#undef TEST_DOUBLE
-}
-
-TEST(Reader, ParseNumber_NormalPrecisionDouble) {
-    TestParseDouble<false>();
-}
-
-TEST(Reader, ParseNumber_FullPrecisionDouble) {
-    TestParseDouble<true>();
-}
-
-TEST(Reader, ParseNumber_NormalPrecisionError) {
-    static unsigned count = 1000000;
-    Random r;
-
-    double ulpSum = 0.0;
-    double ulpMax = 0.0;
-    for (unsigned i = 0; i < count; i++) {
-        internal::Double e, a;
-        do {
-            // Need to call r() in two statements for cross-platform coherent sequence.
-            uint64_t u = uint64_t(r()) << 32;
-            u |= uint64_t(r());
-            e = u;
-        } while (e.IsNan() || e.IsInf() || !e.IsNormal());
-
-        char buffer[32];
-        *internal::dtoa(e.Value(), buffer) = '\0';
-
-        StringStream s(buffer);
-        ParseDoubleHandler h;
-        Reader reader;
-        ASSERT_EQ(kParseErrorNone, reader.Parse(s, h).Code());
-        EXPECT_EQ(1u, h.step_);
-
-        a = h.actual_;
-        uint64_t bias1 = e.ToBias();
-        uint64_t bias2 = a.ToBias();
-        double ulp = bias1 >= bias2 ? bias1 - bias2 : bias2 - bias1;
-        ulpMax = std::max(ulpMax, ulp);
-        ulpSum += ulp;
-    }
-    printf("ULP Average = %g, Max = %g \n", ulpSum / count, ulpMax);
-}
-
-TEST(Reader, ParseNumber_Error) {
-#define TEST_NUMBER_ERROR(errorCode, str) \
-    { \
-        char buffer[1001]; \
-        sprintf(buffer, "%s", str); \
-        InsituStringStream s(buffer); \
-        BaseReaderHandler<> h; \
-        Reader reader; \
-        EXPECT_FALSE(reader.Parse(s, h)); \
-        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
-    }
-
-    // Number too big to be stored in double.
-    {
-        char n1e309[311];   // '1' followed by 309 '0'
-        n1e309[0] = '1';
-        for (int i = 1; i < 310; i++)
-            n1e309[i] = '0';
-        n1e309[310] = '\0';
-        TEST_NUMBER_ERROR(kParseErrorNumberTooBig, n1e309);
-    }
-    TEST_NUMBER_ERROR(kParseErrorNumberTooBig, "1e309");
-
-    // Miss fraction part in number.
-    TEST_NUMBER_ERROR(kParseErrorNumberMissFraction, "1.");
-    TEST_NUMBER_ERROR(kParseErrorNumberMissFraction, "1.a");
-
-    // Miss exponent in number.
-    TEST_NUMBER_ERROR(kParseErrorNumberMissExponent, "1e");
-    TEST_NUMBER_ERROR(kParseErrorNumberMissExponent, "1e_");
-
-#undef TEST_NUMBER_ERROR
-}
-
-template <typename Encoding>
-struct ParseStringHandler : BaseReaderHandler<Encoding, ParseStringHandler<Encoding> > {
-    ParseStringHandler() : str_(0), length_(0), copy_() {}
-    ~ParseStringHandler() { EXPECT_TRUE(str_ != 0); if (copy_) free(const_cast<typename Encoding::Ch*>(str_)); }
-    
-    ParseStringHandler(const ParseStringHandler&);
-    ParseStringHandler& operator=(const ParseStringHandler&);
-
-    bool Default() { ADD_FAILURE(); return false; }
-    bool String(const typename Encoding::Ch* str, size_t length, bool copy) { 
-        EXPECT_EQ(0, str_);
-        if (copy) {
-            str_ = (typename Encoding::Ch*)malloc((length + 1) * sizeof(typename Encoding::Ch));
-            memcpy(const_cast<typename Encoding::Ch*>(str_), str, (length + 1) * sizeof(typename Encoding::Ch));
-        }
-        else
-            str_ = str;
-        length_ = length; 
-        copy_ = copy;
-        return true;
-    }
-
-    const typename Encoding::Ch* str_;
-    size_t length_;
-    bool copy_;
-};
-
-TEST(Reader, ParseString) {
-#define TEST_STRING(Encoding, e, x) \
-    { \
-        Encoding::Ch* buffer = StrDup(x); \
-        GenericInsituStringStream<Encoding> is(buffer); \
-        ParseStringHandler<Encoding> h; \
-        GenericReader<Encoding, Encoding> reader; \
-        reader.Parse<kParseInsituFlag | kParseValidateEncodingFlag>(is, h); \
-        EXPECT_EQ(0, StrCmp<Encoding::Ch>(e, h.str_)); \
-        EXPECT_EQ(StrLen(e), h.length_); \
-        free(buffer); \
-        GenericStringStream<Encoding> s(x); \
-        ParseStringHandler<Encoding> h2; \
-        GenericReader<Encoding, Encoding> reader2; \
-        reader2.Parse(s, h2); \
-        EXPECT_EQ(0, StrCmp<Encoding::Ch>(e, h2.str_)); \
-        EXPECT_EQ(StrLen(e), h2.length_); \
-    }
-
-    // String constant L"\xXX" can only specify character code in bytes, which is not endianness-neutral. 
-    // And old compiler does not support u"" and U"" string literal. So here specify string literal by array of Ch.
-    // In addition, GCC 4.8 generates -Wnarrowing warnings when character code >= 128 are assigned to signed integer types.
-    // Therefore, utype is added for declaring unsigned array, and then cast it to Encoding::Ch.
-#define ARRAY(...) { __VA_ARGS__ }
-#define TEST_STRINGARRAY(Encoding, utype, array, x) \
-    { \
-        static const utype ue[] = array; \
-        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
-        TEST_STRING(Encoding, e, x); \
-    }
-
-#define TEST_STRINGARRAY2(Encoding, utype, earray, xarray) \
-    { \
-        static const utype ue[] = earray; \
-        static const utype xe[] = xarray; \
-        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
-        static const Encoding::Ch* x = reinterpret_cast<const Encoding::Ch *>(&xe[0]); \
-        TEST_STRING(Encoding, e, x); \
-    }
-
-    TEST_STRING(UTF8<>, "", "\"\"");
-    TEST_STRING(UTF8<>, "Hello", "\"Hello\"");
-    TEST_STRING(UTF8<>, "Hello\nWorld", "\"Hello\\nWorld\"");
-    TEST_STRING(UTF8<>, "\"\\/\b\f\n\r\t", "\"\\\"\\\\/\\b\\f\\n\\r\\t\"");
-    TEST_STRING(UTF8<>, "\x24", "\"\\u0024\"");         // Dollar sign U+0024
-    TEST_STRING(UTF8<>, "\xC2\xA2", "\"\\u00A2\"");     // Cents sign U+00A2
-    TEST_STRING(UTF8<>, "\xE2\x82\xAC", "\"\\u20AC\""); // Euro sign U+20AC
-    TEST_STRING(UTF8<>, "\xF0\x9D\x84\x9E", "\"\\uD834\\uDD1E\"");  // G clef sign U+1D11E
-
-    // UTF16
-    TEST_STRING(UTF16<>, L"", L"\"\"");
-    TEST_STRING(UTF16<>, L"Hello", L"\"Hello\"");
-    TEST_STRING(UTF16<>, L"Hello\nWorld", L"\"Hello\\nWorld\"");
-    TEST_STRING(UTF16<>, L"\"\\/\b\f\n\r\t", L"\"\\\"\\\\/\\b\\f\\n\\r\\t\"");
-    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x0024, 0x0000), L"\"\\u0024\"");
-    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x00A2, 0x0000), L"\"\\u00A2\"");  // Cents sign U+00A2
-    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0x20AC, 0x0000), L"\"\\u20AC\"");  // Euro sign U+20AC
-    TEST_STRINGARRAY(UTF16<>, wchar_t, ARRAY(0xD834, 0xDD1E, 0x0000), L"\"\\uD834\\uDD1E\"");   // G clef sign U+1D11E
-
-    // UTF32
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('\0'), ARRAY('\"', '\"', '\0'));
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('H', 'e', 'l', 'l', 'o', '\0'), ARRAY('\"', 'H', 'e', 'l', 'l', 'o', '\"', '\0'));
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('H', 'e', 'l', 'l', 'o', '\n', 'W', 'o', 'r', 'l', 'd', '\0'), ARRAY('\"', 'H', 'e', 'l', 'l', 'o', '\\', 'n', 'W', 'o', 'r', 'l', 'd', '\"', '\0'));
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY('\"', '\\', '/', '\b', '\f', '\n', '\r', '\t', '\0'), ARRAY('\"', '\\', '\"', '\\', '\\', '/', '\\', 'b', '\\', 'f', '\\', 'n', '\\', 'r', '\\', 't', '\"', '\0'));
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x00024, 0x0000), ARRAY('\"', '\\', 'u', '0', '0', '2', '4', '\"', '\0'));
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x000A2, 0x0000), ARRAY('\"', '\\', 'u', '0', '0', 'A', '2', '\"', '\0'));   // Cents sign U+00A2
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x020AC, 0x0000), ARRAY('\"', '\\', 'u', '2', '0', 'A', 'C', '\"', '\0'));   // Euro sign U+20AC
-    TEST_STRINGARRAY2(UTF32<>, unsigned, ARRAY(0x1D11E, 0x0000), ARRAY('\"', '\\', 'u', 'D', '8', '3', '4', '\\', 'u', 'D', 'D', '1', 'E', '\"', '\0'));    // G clef sign U+1D11E
-
-#undef TEST_STRINGARRAY
-#undef ARRAY
-#undef TEST_STRING
-
-    // Support of null character in string
-    {
-        StringStream s("\"Hello\\u0000World\"");
-        const char e[] = "Hello\0World";
-        ParseStringHandler<UTF8<> > h;
-        Reader reader;
-        reader.Parse(s, h);
-        EXPECT_EQ(0, memcmp(e, h.str_, h.length_ + 1));
-        EXPECT_EQ(11u, h.length_);
-    }
-}
-
-TEST(Reader, ParseString_Transcoding) {
-    const char* x = "\"Hello\"";
-    const wchar_t* e = L"Hello";
-    GenericStringStream<UTF8<> > is(x);
-    GenericReader<UTF8<>, UTF16<> > reader;
-    ParseStringHandler<UTF16<> > h;
-    reader.Parse(is, h);
-    EXPECT_EQ(0, StrCmp<UTF16<>::Ch>(e, h.str_));
-    EXPECT_EQ(StrLen(e), h.length_);
-}
-
-TEST(Reader, ParseString_NonDestructive) {
-    StringStream s("\"Hello\\nWorld\"");
-    ParseStringHandler<UTF8<> > h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(0, StrCmp("Hello\nWorld", h.str_));
-    EXPECT_EQ(11u, h.length_);
-}
-
-ParseErrorCode TestString(const char* str) {
-    StringStream s(str);
-    BaseReaderHandler<> h;
-    Reader reader;
-    reader.Parse<kParseValidateEncodingFlag>(s, h);
-    return reader.GetParseErrorCode();
-}
-
-TEST(Reader, ParseString_Error) {
-#define TEST_STRING_ERROR(errorCode, str)\
-        EXPECT_EQ(errorCode, TestString(str))
-
-#define ARRAY(...) { __VA_ARGS__ }
-#define TEST_STRINGENCODING_ERROR(Encoding, utype, array) \
-    { \
-        static const utype ue[] = array; \
-        static const Encoding::Ch* e = reinterpret_cast<const Encoding::Ch *>(&ue[0]); \
-        EXPECT_EQ(kParseErrorStringInvalidEncoding, TestString(e));\
-    }
-
-    // Invalid escape character in string.
-    TEST_STRING_ERROR(kParseErrorStringEscapeInvalid, "[\"\\a\"]");
-
-    // Incorrect hex digit after \\u escape in string.
-    TEST_STRING_ERROR(kParseErrorStringUnicodeEscapeInvalidHex, "[\"\\uABCG\"]");
-
-    // The surrogate pair in string is invalid.
-    TEST_STRING_ERROR(kParseErrorStringUnicodeSurrogateInvalid, "[\"\\uD800X\"]");
-    TEST_STRING_ERROR(kParseErrorStringUnicodeSurrogateInvalid, "[\"\\uD800\\uFFFF\"]");
-
-    // Missing a closing quotation mark in string.
-    TEST_STRING_ERROR(kParseErrorStringMissQuotationMark, "[\"Test]");
-
-    // http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
-
-    // 3  Malformed sequences 
-
-    // 3.1 Unexpected continuation bytes
-    {
-         char e[] = { '[', '\"', 0, '\"', ']', '\0' };
-         for (unsigned char c = 0x80u; c <= 0xBFu; c++) {
-            e[2] = c;
-            ParseErrorCode error = TestString(e);
-            EXPECT_EQ(kParseErrorStringInvalidEncoding, error);
-            if (error != kParseErrorStringInvalidEncoding)
-                std::cout << (unsigned)(unsigned char)c << std::endl;
-         }
-    }
-
-    // 3.2 Lonely start characters, 3.5 Impossible bytes
-    {
-        char e[] = { '[', '\"', 0, ' ', '\"', ']', '\0' };
-        for (unsigned c = 0xC0u; c <= 0xFFu; c++) {
-            e[2] = (char)c;
-            TEST_STRING_ERROR(kParseErrorStringInvalidEncoding, e);
-        }
-    }
-
-    // 4  Overlong sequences 
-
-    // 4.1  Examples of an overlong ASCII character
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xC0u, 0xAFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x80u, 0xAFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x80u, 0x80u, 0xAFu, '\"', ']', '\0'));
-
-    // 4.2  Maximum overlong sequences 
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xC1u, 0xBFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x9Fu, 0xBFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x8Fu, 0xBFu, 0xBFu, '\"', ']', '\0'));
-
-    // 4.3  Overlong representation of the NUL character 
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xC0u, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xE0u, 0x80u, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xF0u, 0x80u, 0x80u, 0x80u, '\"', ']', '\0'));
-
-    // 5  Illegal code positions
-
-    // 5.1 Single UTF-16 surrogates
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xA0u, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xADu, 0xBFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xAEu, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xAFu, 0xBFu, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xB0u, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xBEu, 0x80u, '\"', ']', '\0'));
-    TEST_STRINGENCODING_ERROR(UTF8<>, unsigned char, ARRAY('[', '\"', 0xEDu, 0xBFu, 0xBFu, '\"', ']', '\0'));
-
-#undef ARRAY
-#undef TEST_STRINGARRAY_ERROR
-}
-
-template <unsigned count>
-struct ParseArrayHandler : BaseReaderHandler<UTF8<>, ParseArrayHandler<count> > {
-    ParseArrayHandler() : step_(0) {}
-
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Uint(unsigned i) { EXPECT_EQ(step_, i); step_++; return true; }
-    bool StartArray() { EXPECT_EQ(0u, step_); step_++; return true; }
-    bool EndArray(SizeType) { step_++; return true; }
-
-    unsigned step_;
-};
-
-TEST(Reader, ParseEmptyArray) {
-    char *json = StrDup("[ ] ");
-    InsituStringStream s(json);
-    ParseArrayHandler<0> h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(2u, h.step_);
-    free(json);
-}
-
-TEST(Reader, ParseArray) {
-    char *json = StrDup("[1, 2, 3, 4]");
-    InsituStringStream s(json);
-    ParseArrayHandler<4> h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(6u, h.step_);
-    free(json);
-}
-
-TEST(Reader, ParseArray_Error) {
-#define TEST_ARRAY_ERROR(errorCode, str) \
-    { \
-        char buffer[1001]; \
-        strncpy(buffer, str, 1000); \
-        InsituStringStream s(buffer); \
-        BaseReaderHandler<> h; \
-        GenericReader<UTF8<>, UTF8<>, CrtAllocator> reader; \
-        EXPECT_FALSE(reader.Parse(s, h)); \
-        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
-    }
-
-    // Missing a comma or ']' after an array element.
-    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1");
-    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1}");
-    TEST_ARRAY_ERROR(kParseErrorArrayMissCommaOrSquareBracket, "[1 2]");
-
-#undef TEST_ARRAY_ERROR
-}
-
-struct ParseObjectHandler : BaseReaderHandler<UTF8<>, ParseObjectHandler> {
-    ParseObjectHandler() : step_(0) {}
-
-    bool Default() { ADD_FAILURE(); return false; }
-    bool Null() { EXPECT_EQ(8u, step_); step_++; return true; }
-    bool Bool(bool b) { 
-        switch(step_) {
-            case 4: EXPECT_TRUE(b); step_++; return true;
-            case 6: EXPECT_FALSE(b); step_++; return true;
-            default: ADD_FAILURE(); return false;
-        }
-    }
-    bool Int(int i) { 
-        switch(step_) {
-            case 10: EXPECT_EQ(123, i); step_++; return true;
-            case 15: EXPECT_EQ(1, i); step_++; return true;
-            case 16: EXPECT_EQ(2, i); step_++; return true;
-            case 17: EXPECT_EQ(3, i); step_++; return true;
-            default: ADD_FAILURE(); return false;
-        }
-    }
-    bool Uint(unsigned i) { return Int(i); }
-    bool Double(double d) { EXPECT_EQ(12u, step_); EXPECT_EQ(3.1416, d); step_++; return true; }
-    bool String(const char* str, size_t, bool) { 
-        switch(step_) {
-            case 1: EXPECT_STREQ("hello", str); step_++; return true;
-            case 2: EXPECT_STREQ("world", str); step_++; return true;
-            case 3: EXPECT_STREQ("t", str); step_++; return true;
-            case 5: EXPECT_STREQ("f", str); step_++; return true;
-            case 7: EXPECT_STREQ("n", str); step_++; return true;
-            case 9: EXPECT_STREQ("i", str); step_++; return true;
-            case 11: EXPECT_STREQ("pi", str); step_++; return true;
-            case 13: EXPECT_STREQ("a", str); step_++; return true;
-            default: ADD_FAILURE(); return false;
-        }
-    }
-    bool StartObject() { EXPECT_EQ(0u, step_); step_++; return true; }
-    bool EndObject(SizeType memberCount) { EXPECT_EQ(19u, step_); EXPECT_EQ(7u, memberCount); step_++; return true; }
-    bool StartArray() { EXPECT_EQ(14u, step_); step_++; return true; }
-    bool EndArray(SizeType elementCount) { EXPECT_EQ(18u, step_); EXPECT_EQ(3u, elementCount); step_++; return true; }
-
-    unsigned step_;
-};
-
-TEST(Reader, ParseObject) {
-    const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ";
-
-    // Insitu
-    {
-        char* json2 = StrDup(json);
-        InsituStringStream s(json2);
-        ParseObjectHandler h;
-        Reader reader;
-        reader.Parse<kParseInsituFlag>(s, h);
-        EXPECT_EQ(20u, h.step_);
-        free(json2);
-    }
-
-    // Normal
-    {
-        StringStream s(json);
-        ParseObjectHandler h;
-        Reader reader;
-        reader.Parse(s, h);
-        EXPECT_EQ(20u, h.step_);
-    }
-}
-
-struct ParseEmptyObjectHandler : BaseReaderHandler<UTF8<>, ParseEmptyObjectHandler> {
-    ParseEmptyObjectHandler() : step_(0) {}
-
-    bool Default() { ADD_FAILURE(); return false; }
-    bool StartObject() { EXPECT_EQ(0u, step_); step_++; return true; }
-    bool EndObject(SizeType) { EXPECT_EQ(1u, step_); step_++; return true; }
-
-    unsigned step_;
-};
-
-TEST(Reader, Parse_EmptyObject) {
-    StringStream s("{ } ");
-    ParseEmptyObjectHandler h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(2u, h.step_);
-}
-
-struct ParseMultipleRootHandler : BaseReaderHandler<UTF8<>, ParseMultipleRootHandler> {
-    ParseMultipleRootHandler() : step_(0) {}
-
-    bool Default() { ADD_FAILURE(); return false; }
-    bool StartObject() { EXPECT_EQ(0u, step_); step_++; return true; }
-    bool EndObject(SizeType) { EXPECT_EQ(1u, step_); step_++; return true; }
-    bool StartArray() { EXPECT_EQ(2u, step_); step_++; return true; }
-    bool EndArray(SizeType) { EXPECT_EQ(3u, step_); step_++; return true; }
-
-    unsigned step_;
-};
-
-template <unsigned parseFlags>
-void TestMultipleRoot() {
-    StringStream s("{}[] a");
-    ParseMultipleRootHandler h;
-    Reader reader;
-    EXPECT_TRUE(reader.Parse<parseFlags>(s, h));
-    EXPECT_EQ(2u, h.step_);
-    EXPECT_TRUE(reader.Parse<parseFlags>(s, h));
-    EXPECT_EQ(4u, h.step_);
-    EXPECT_EQ(' ', s.Take());
-    EXPECT_EQ('a', s.Take());
-}
-
-TEST(Reader, Parse_MultipleRoot) {
-    TestMultipleRoot<kParseStopWhenDoneFlag>();
-}
-
-TEST(Reader, ParseIterative_MultipleRoot) {
-    TestMultipleRoot<kParseIterativeFlag | kParseStopWhenDoneFlag>();
-}
-
-template <unsigned parseFlags>
-void TestInsituMultipleRoot() {
-    char* buffer = strdup("{}[] a");
-    InsituStringStream s(buffer);
-    ParseMultipleRootHandler h;
-    Reader reader;
-    EXPECT_TRUE(reader.Parse<kParseInsituFlag | parseFlags>(s, h));
-    EXPECT_EQ(2u, h.step_);
-    EXPECT_TRUE(reader.Parse<kParseInsituFlag | parseFlags>(s, h));
-    EXPECT_EQ(4u, h.step_);
-    EXPECT_EQ(' ', s.Take());
-    EXPECT_EQ('a', s.Take());
-    free(buffer);
-}
-
-TEST(Reader, ParseInsitu_MultipleRoot) {
-    TestInsituMultipleRoot<kParseStopWhenDoneFlag>();
-}
-
-TEST(Reader, ParseInsituIterative_MultipleRoot) {
-    TestInsituMultipleRoot<kParseIterativeFlag | kParseStopWhenDoneFlag>();
-}
-
-#define TEST_ERROR(errorCode, str) \
-    { \
-        char buffer[1001]; \
-        strncpy(buffer, str, 1000); \
-        InsituStringStream s(buffer); \
-        BaseReaderHandler<> h; \
-        Reader reader; \
-        EXPECT_FALSE(reader.Parse(s, h)); \
-        EXPECT_EQ(errorCode, reader.GetParseErrorCode());\
-    }
-
-TEST(Reader, ParseDocument_Error) {
-    // The document is empty.
-    TEST_ERROR(kParseErrorDocumentEmpty, "");
-    TEST_ERROR(kParseErrorDocumentEmpty, " ");
-    TEST_ERROR(kParseErrorDocumentEmpty, " \n");
-
-    // The document root must not follow by other values.
-    TEST_ERROR(kParseErrorDocumentRootNotSingular, "[] 0");
-    TEST_ERROR(kParseErrorDocumentRootNotSingular, "{} 0");
-    TEST_ERROR(kParseErrorDocumentRootNotSingular, "null []");
-    TEST_ERROR(kParseErrorDocumentRootNotSingular, "0 {}");
-}
-
-TEST(Reader, ParseValue_Error) {
-    // Invalid value.
-    TEST_ERROR(kParseErrorValueInvalid, "nulL");
-    TEST_ERROR(kParseErrorValueInvalid, "truE");
-    TEST_ERROR(kParseErrorValueInvalid, "falsE");
-    TEST_ERROR(kParseErrorValueInvalid, "a]");
-    TEST_ERROR(kParseErrorValueInvalid, ".1");
-}
-
-TEST(Reader, ParseObject_Error) {
-    // Missing a name for object member.
-    TEST_ERROR(kParseErrorObjectMissName, "{1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{null:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{true:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{false:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{1:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{[]:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{{}:1}");
-    TEST_ERROR(kParseErrorObjectMissName, "{xyz:1}");
-
-    // Missing a colon after a name of object member.
-    TEST_ERROR(kParseErrorObjectMissColon, "{\"a\" 1}");
-    TEST_ERROR(kParseErrorObjectMissColon, "{\"a\",1}");
-
-    // Must be a comma or '}' after an object member
-    TEST_ERROR(kParseErrorObjectMissCommaOrCurlyBracket, "{\"a\":1]");
-
-    // This tests that MemoryStream is checking the length in Peek().
-    {
-        MemoryStream ms("{\"a\"", 1);
-        BaseReaderHandler<> h;
-        Reader reader;
-        EXPECT_FALSE(reader.Parse<kParseStopWhenDoneFlag>(ms, h));
-        EXPECT_EQ(kParseErrorObjectMissName, reader.GetParseErrorCode());
-    }
-}
-
-#undef TEST_ERROR
-
-TEST(Reader, SkipWhitespace) {
-    StringStream ss(" A \t\tB\n \n\nC\r\r \rD \t\n\r E");
-    const char* expected = "ABCDE";
-    for (size_t i = 0; i < 5; i++) {
-        SkipWhitespace(ss);
-        EXPECT_EQ(expected[i], ss.Take());
-    }
-}
-
-// Test implementing a stream without copy stream optimization.
-// Clone from GenericStringStream except that copy constructor is disabled.
-template <typename Encoding>
-class CustomStringStream {
-public:
-    typedef typename Encoding::Ch Ch;
-
-    CustomStringStream(const Ch *src) : src_(src), head_(src) {}
-
-    Ch Peek() const { return *src_; }
-    Ch Take() { return *src_++; }
-    size_t Tell() const { return static_cast<size_t>(src_ - head_); }
-
-    Ch* PutBegin() { RAPIDJSON_ASSERT(false); return 0; }
-    void Put(Ch) { RAPIDJSON_ASSERT(false); }
-    void Flush() { RAPIDJSON_ASSERT(false); }
-    size_t PutEnd(Ch*) { RAPIDJSON_ASSERT(false); return 0; }
-
-private:
-    // Prohibit copy constructor & assignment operator.
-    CustomStringStream(const CustomStringStream&);
-    CustomStringStream& operator=(const CustomStringStream&);
-
-    const Ch* src_;     //!< Current read position.
-    const Ch* head_;    //!< Original head of the string.
-};
-
-// If the following code is compiled, it should generate compilation error as predicted.
-// Because CustomStringStream<> is not copyable via making copy constructor private.
-#if 0
-namespace rapidjson {
-
-template <typename Encoding>
-struct StreamTraits<CustomStringStream<Encoding> > {
-    enum { copyOptimization = 1 };
-};
-
-} // namespace rapidjson
-#endif 
-
-TEST(Reader, CustomStringStream) {
-    const char* json = "{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ";
-    CustomStringStream<UTF8<char> > s(json);
-    ParseObjectHandler h;
-    Reader reader;
-    reader.Parse(s, h);
-    EXPECT_EQ(20u, h.step_);
-}
-
-#include <sstream>
-
-class IStreamWrapper {
-public:
-    typedef char Ch;
-
-    IStreamWrapper(std::istream& is) : is_(is) {}
-
-    Ch Peek() const {
-        int c = is_.peek();
-        return c == std::char_traits<char>::eof() ? '\0' : (Ch)c;
-    }
-
-    Ch Take() { 
-        int c = is_.get();
-        return c == std::char_traits<char>::eof() ? '\0' : (Ch)c;
-    }
-
-    size_t Tell() const { return (size_t)is_.tellg(); }
-
-    Ch* PutBegin() { assert(false); return 0; }
-    void Put(Ch) { assert(false); }
-    void Flush() { assert(false); }
-    size_t PutEnd(Ch*) { assert(false); return 0; }
-
-private:
-    IStreamWrapper(const IStreamWrapper&);
-    IStreamWrapper& operator=(const IStreamWrapper&);
-
-    std::istream& is_;
-};
-
-TEST(Reader, Parse_IStreamWrapper_StringStream) {
-    const char* json = "[1,2,3,4]";
-
-    std::stringstream ss(json);
-    IStreamWrapper is(ss);
-
-    Reader reader;
-    ParseArrayHandler<4> h;
-    reader.Parse(is, h);
-    EXPECT_FALSE(reader.HasParseError());   
-}
-
-// Test iterative parsing.
-
-#define TESTERRORHANDLING(text, errorCode, offset)\
-{\
-    StringStream json(text); \
-    BaseReaderHandler<> handler; \
-    Reader reader; \
-    reader.Parse<kParseIterativeFlag>(json, handler); \
-    EXPECT_TRUE(reader.HasParseError()); \
-    EXPECT_EQ(errorCode, reader.GetParseErrorCode()); \
-    EXPECT_EQ(offset, reader.GetErrorOffset()); \
-}
-
-TEST(Reader, IterativeParsing_ErrorHandling) {
-    TESTERRORHANDLING("{\"a\": a}", kParseErrorValueInvalid, 6u);
-
-    TESTERRORHANDLING("", kParseErrorDocumentEmpty, 0u);
-    TESTERRORHANDLING("{}{}", kParseErrorDocumentRootNotSingular, 2u);
-
-    TESTERRORHANDLING("{1}", kParseErrorObjectMissName, 1u);
-    TESTERRORHANDLING("{\"a\", 1}", kParseErrorObjectMissColon, 4u);
-    TESTERRORHANDLING("{\"a\"}", kParseErrorObjectMissColon, 4u);
-    TESTERRORHANDLING("{\"a\": 1", kParseErrorObjectMissCommaOrCurlyBracket, 7u);
-    TESTERRORHANDLING("[1 2 3]", kParseErrorArrayMissCommaOrSquareBracket, 3u);
-}
-
-template<typename Encoding = UTF8<> >
-struct IterativeParsingReaderHandler {
-    typedef typename Encoding::Ch Ch;
-
-    const static int LOG_NULL = -1;
-    const static int LOG_BOOL = -2;
-    const static int LOG_INT = -3;
-    const static int LOG_UINT = -4;
-    const static int LOG_INT64 = -5;
-    const static int LOG_UINT64 = -6;
-    const static int LOG_DOUBLE = -7;
-    const static int LOG_STRING = -8;
-    const static int LOG_STARTOBJECT = -9;
-    const static int LOG_KEY = -10;
-    const static int LOG_ENDOBJECT = -11;
-    const static int LOG_STARTARRAY = -12;
-    const static int LOG_ENDARRAY = -13;
-
-    const static size_t LogCapacity = 256;
-    int Logs[LogCapacity];
-    size_t LogCount;
-
-    IterativeParsingReaderHandler() : LogCount(0) {
-    }
-
-    bool Null() { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_NULL; return true; }
-
-    bool Bool(bool) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_BOOL; return true; }
-
-    bool Int(int) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_INT; return true; }
-
-    bool Uint(unsigned) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_INT; return true; }
-
-    bool Int64(int64_t) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_INT64; return true; }
-
-    bool Uint64(uint64_t) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_UINT64; return true; }
-
-    bool Double(double) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_DOUBLE; return true; }
-
-    bool String(const Ch*, SizeType, bool) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_STRING; return true; }
-
-    bool StartObject() { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_STARTOBJECT; return true; }
-
-    bool Key (const Ch*, SizeType, bool) { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_KEY; return true; }
-	
-    bool EndObject(SizeType c) {
-        RAPIDJSON_ASSERT(LogCount < LogCapacity);
-        Logs[LogCount++] = LOG_ENDOBJECT;
-        Logs[LogCount++] = (int)c;
-        return true;
-    }
-
-    bool StartArray() { RAPIDJSON_ASSERT(LogCount < LogCapacity); Logs[LogCount++] = LOG_STARTARRAY; return true; }
-
-    bool EndArray(SizeType c) {
-        RAPIDJSON_ASSERT(LogCount < LogCapacity);
-        Logs[LogCount++] = LOG_ENDARRAY;
-        Logs[LogCount++] = (int)c;
-        return true;
-    }
-};
-
-TEST(Reader, IterativeParsing_General) {
-    {
-        StringStream is("[1, {\"k\": [1, 2]}, null, false, true, \"string\", 1.2]");
-        Reader reader;
-        IterativeParsingReaderHandler<> handler;
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_FALSE(r.IsError());
-        EXPECT_FALSE(reader.HasParseError());
-
-        int e[] = {
-            handler.LOG_STARTARRAY,
-            handler.LOG_INT,
-            handler.LOG_STARTOBJECT,
-            handler.LOG_KEY,
-            handler.LOG_STARTARRAY,
-            handler.LOG_INT,
-            handler.LOG_INT,
-            handler.LOG_ENDARRAY, 2,
-            handler.LOG_ENDOBJECT, 1,
-            handler.LOG_NULL,
-            handler.LOG_BOOL,
-            handler.LOG_BOOL,
-            handler.LOG_STRING,
-            handler.LOG_DOUBLE,
-            handler.LOG_ENDARRAY, 7
-        };
-
-        EXPECT_EQ(sizeof(e) / sizeof(int), handler.LogCount);
-
-        for (size_t i = 0; i < handler.LogCount; ++i) {
-            EXPECT_EQ(e[i], handler.Logs[i]) << "i = " << i;
-        }
-    }
-}
-
-TEST(Reader, IterativeParsing_Count) {
-    {
-        StringStream is("[{}, {\"k\": 1}, [1], []]");
-        Reader reader;
-        IterativeParsingReaderHandler<> handler;
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_FALSE(r.IsError());
-        EXPECT_FALSE(reader.HasParseError());
-
-        int e[] = {
-            handler.LOG_STARTARRAY,
-            handler.LOG_STARTOBJECT,
-            handler.LOG_ENDOBJECT, 0,
-            handler.LOG_STARTOBJECT,
-            handler.LOG_KEY,
-            handler.LOG_INT,
-            handler.LOG_ENDOBJECT, 1,
-            handler.LOG_STARTARRAY,
-            handler.LOG_INT,
-            handler.LOG_ENDARRAY, 1,
-            handler.LOG_STARTARRAY,
-            handler.LOG_ENDARRAY, 0,
-            handler.LOG_ENDARRAY, 4
-        };
-
-        EXPECT_EQ(sizeof(e) / sizeof(int), handler.LogCount);
-
-        for (size_t i = 0; i < handler.LogCount; ++i) {
-            EXPECT_EQ(e[i], handler.Logs[i]) << "i = " << i;
-        }
-    }
-}
-
-// Test iterative parsing on kParseErrorTermination.
-struct HandlerTerminateAtStartObject : public IterativeParsingReaderHandler<> {
-    bool StartObject() { return false; }
-};
-
-struct HandlerTerminateAtStartArray : public IterativeParsingReaderHandler<> {
-    bool StartArray() { return false; }
-};
-
-struct HandlerTerminateAtEndObject : public IterativeParsingReaderHandler<> {
-    bool EndObject(SizeType) { return false; }
-};
-
-struct HandlerTerminateAtEndArray : public IterativeParsingReaderHandler<> {
-    bool EndArray(SizeType) { return false; }
-};
-
-TEST(Reader, IterativeParsing_ShortCircuit) {
-    {
-        HandlerTerminateAtStartObject handler;
-        Reader reader;
-        StringStream is("[1, {}]");
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_TRUE(reader.HasParseError());
-        EXPECT_EQ(kParseErrorTermination, r.Code());
-        EXPECT_EQ(4u, r.Offset());
-    }
-
-    {
-        HandlerTerminateAtStartArray handler;
-        Reader reader;
-        StringStream is("{\"a\": []}");
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_TRUE(reader.HasParseError());
-        EXPECT_EQ(kParseErrorTermination, r.Code());
-        EXPECT_EQ(6u, r.Offset());
-    }
-
-    {
-        HandlerTerminateAtEndObject handler;
-        Reader reader;
-        StringStream is("[1, {}]");
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_TRUE(reader.HasParseError());
-        EXPECT_EQ(kParseErrorTermination, r.Code());
-        EXPECT_EQ(5u, r.Offset());
-    }
-
-    {
-        HandlerTerminateAtEndArray handler;
-        Reader reader;
-        StringStream is("{\"a\": []}");
-
-        ParseResult r = reader.Parse<kParseIterativeFlag>(is, handler);
-
-        EXPECT_TRUE(reader.HasParseError());
-        EXPECT_EQ(kParseErrorTermination, r.Code());
-        EXPECT_EQ(7u, r.Offset());
-    }
-}
-
-#ifdef __GNUC__
-RAPIDJSON_DIAG_POP
-#endif
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/stringbuffertest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/stringbuffertest.cpp
deleted file mode 100644
index 71e0caf..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/stringbuffertest.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/stringbuffer.h"
-#include "rapidjson/writer.h"
-
-using namespace rapidjson;
-
-TEST(StringBuffer, InitialSize) {
-    StringBuffer buffer;
-    EXPECT_EQ(0u, buffer.GetSize());
-    EXPECT_STREQ("", buffer.GetString());
-}
-
-TEST(StringBuffer, Put) {
-    StringBuffer buffer;
-    buffer.Put('A');
-
-    EXPECT_EQ(1u, buffer.GetSize());
-    EXPECT_STREQ("A", buffer.GetString());
-}
-
-TEST(StringBuffer, Clear) {
-    StringBuffer buffer;
-    buffer.Put('A');
-    buffer.Put('B');
-    buffer.Put('C');
-    buffer.Clear();
-
-    EXPECT_EQ(0u, buffer.GetSize());
-    EXPECT_STREQ("", buffer.GetString());
-}
-
-TEST(StringBuffer, Push) {
-    StringBuffer buffer;
-    buffer.Push(5);
-
-    EXPECT_EQ(5u, buffer.GetSize());
-}
-
-TEST(StringBuffer, Pop) {
-    StringBuffer buffer;
-    buffer.Put('A');
-    buffer.Put('B');
-    buffer.Put('C');
-    buffer.Put('D');
-    buffer.Put('E');
-    buffer.Pop(3);
-
-    EXPECT_EQ(2u, buffer.GetSize());
-    EXPECT_STREQ("AB", buffer.GetString());
-}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#include <type_traits>
-
-TEST(StringBuffer, Traits) {
-    static_assert( std::is_constructible<StringBuffer>::value, "");
-    static_assert( std::is_default_constructible<StringBuffer>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_copy_constructible<StringBuffer>::value, "");
-#endif
-    static_assert( std::is_move_constructible<StringBuffer>::value, "");
-
-    static_assert(!std::is_nothrow_constructible<StringBuffer>::value, "");
-    static_assert(!std::is_nothrow_default_constructible<StringBuffer>::value, "");
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1800
-    static_assert(!std::is_nothrow_copy_constructible<StringBuffer>::value, "");
-    static_assert(!std::is_nothrow_move_constructible<StringBuffer>::value, "");
-#endif
-
-    static_assert( std::is_assignable<StringBuffer,StringBuffer>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_copy_assignable<StringBuffer>::value, "");
-#endif
-    static_assert( std::is_move_assignable<StringBuffer>::value, "");
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1800
-    static_assert(!std::is_nothrow_assignable<StringBuffer, StringBuffer>::value, "");
-#endif
-
-    static_assert(!std::is_nothrow_copy_assignable<StringBuffer>::value, "");
-    static_assert(!std::is_nothrow_move_assignable<StringBuffer>::value, "");
-
-    static_assert( std::is_destructible<StringBuffer>::value, "");
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_destructible<StringBuffer>::value, "");
-#endif
-}
-
-TEST(StringBuffer, MoveConstructor) {
-    StringBuffer x;
-    x.Put('A');
-    x.Put('B');
-    x.Put('C');
-    x.Put('D');
-
-    EXPECT_EQ(4u, x.GetSize());
-    EXPECT_STREQ("ABCD", x.GetString());
-
-    // StringBuffer y(x); // does not compile (!is_copy_constructible)
-    StringBuffer y(std::move(x));
-    EXPECT_EQ(0u, x.GetSize());
-    EXPECT_EQ(4u, y.GetSize());
-    EXPECT_STREQ("ABCD", y.GetString());
-
-    // StringBuffer z = y; // does not compile (!is_copy_assignable)
-    StringBuffer z = std::move(y);
-    EXPECT_EQ(0u, y.GetSize());
-    EXPECT_EQ(4u, z.GetSize());
-    EXPECT_STREQ("ABCD", z.GetString());
-}
-
-TEST(StringBuffer, MoveAssignment) {
-    StringBuffer x;
-    x.Put('A');
-    x.Put('B');
-    x.Put('C');
-    x.Put('D');
-
-    EXPECT_EQ(4u, x.GetSize());
-    EXPECT_STREQ("ABCD", x.GetString());
-
-    StringBuffer y;
-    // y = x; // does not compile (!is_copy_assignable)
-    y = std::move(x);
-    EXPECT_EQ(0u, x.GetSize());
-    EXPECT_EQ(4u, y.GetSize());
-    EXPECT_STREQ("ABCD", y.GetString());
-}
-
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/strtodtest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/strtodtest.cpp
deleted file mode 100644
index d8849be..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/strtodtest.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-#include "rapidjson/internal/strtod.h"
-
-#define BIGINTEGER_LITERAL(s) BigInteger(s, sizeof(s) - 1)
-
-using namespace rapidjson::internal;
-
-TEST(Strtod, CheckApproximationCase) {
-    static const int kSignificandSize = 52;
-    static const int kExponentBias = 0x3FF;
-    static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000);
-    static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF);
-    static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000);
-
-    // http://www.exploringbinary.com/using-integers-to-check-a-floating-point-approximation/
-    // Let b = 0x1.465a72e467d88p-149
-    //       = 5741268244528520 x 2^-201
-    union {
-        double d;
-        uint64_t u;
-    }u;
-    u.u = 0x465a72e467d88 | ((static_cast<uint64_t>(-149 + kExponentBias)) << kSignificandSize);
-    const double b = u.d;
-    const uint64_t bInt = (u.u & kSignificandMask) | kHiddenBit;
-    const int bExp = ((u.u & kExponentMask) >> kSignificandSize) - kExponentBias - kSignificandSize;
-    EXPECT_DOUBLE_EQ(1.7864e-45, b);
-    EXPECT_EQ(RAPIDJSON_UINT64_C2(0x001465a7, 0x2e467d88), bInt);
-    EXPECT_EQ(-201, bExp);
-
-    // Let d = 17864 x 10-49
-    const char dInt[] = "17864";
-    const int dExp = -49;
-
-    // Let h = 2^(bExp-1)
-    const int hExp = bExp - 1;
-    EXPECT_EQ(-202, hExp);
-
-    int dS_Exp2 = 0;
-    int dS_Exp5 = 0;
-    int bS_Exp2 = 0;
-    int bS_Exp5 = 0;
-    int hS_Exp2 = 0;
-    int hS_Exp5 = 0;
-
-    // Adjust for decimal exponent
-    if (dExp >= 0) {
-        dS_Exp2 += dExp;
-        dS_Exp5 += dExp;
-    }
-    else {
-        bS_Exp2 -= dExp;
-        bS_Exp5 -= dExp;
-        hS_Exp2 -= dExp;
-        hS_Exp5 -= dExp;
-    }
-
-    // Adjust for binary exponent
-    if (bExp >= 0)
-        bS_Exp2 += bExp;
-    else {
-        dS_Exp2 -= bExp;
-        hS_Exp2 -= bExp;
-    }
-
-    // Adjust for half ulp exponent
-    if (hExp >= 0)
-        hS_Exp2 += hExp;
-    else {
-        dS_Exp2 -= hExp;
-        bS_Exp2 -= hExp;
-    }
-
-    // Remove common power of two factor from all three scaled values
-    int common_Exp2 = std::min(dS_Exp2, std::min(bS_Exp2, hS_Exp2));
-    dS_Exp2 -= common_Exp2;
-    bS_Exp2 -= common_Exp2;
-    hS_Exp2 -= common_Exp2;
-
-    EXPECT_EQ(153, dS_Exp2);
-    EXPECT_EQ(0, dS_Exp5);
-    EXPECT_EQ(1, bS_Exp2);
-    EXPECT_EQ(49, bS_Exp5);
-    EXPECT_EQ(0, hS_Exp2);
-    EXPECT_EQ(49, hS_Exp5);
-
-    BigInteger dS = BIGINTEGER_LITERAL(dInt);
-    dS.MultiplyPow5(dS_Exp5) <<= dS_Exp2;
-
-    BigInteger bS(bInt);
-    bS.MultiplyPow5(bS_Exp5) <<= bS_Exp2;
-
-    BigInteger hS(1);
-    hS.MultiplyPow5(hS_Exp5) <<= hS_Exp2;
-
-    EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994138521801764465966248930731085529088") == dS);
-    EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994122305215569213032722473144531250000") == bS);
-    EXPECT_TRUE(BIGINTEGER_LITERAL("17763568394002504646778106689453125") == hS);
-
-    EXPECT_EQ(1, dS.Compare(bS));
-    
-    BigInteger delta(0);
-    EXPECT_FALSE(dS.Difference(bS, &delta));
-    EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta);
-    EXPECT_TRUE(bS.Difference(dS, &delta));
-    EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta);
-
-    EXPECT_EQ(-1, delta.Compare(hS));
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.cpp
deleted file mode 100644
index 4604d9d..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-int main(int argc, char **argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-
-#if _MSC_VER
-    _CrtMemState memoryState = { 0 };
-    _CrtMemCheckpoint(&memoryState);
-    //_CrtSetBreakAlloc(X);
-    //void *testWhetherMemoryLeakDetectionWorks = malloc(1);
-#endif
-
-    int ret = RUN_ALL_TESTS();
-
-#if _MSC_VER
-    // Current gtest constantly leak 2 blocks at exit
-    _CrtMemDumpAllObjectsSince(&memoryState);
-#endif
-    return ret;
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.h b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.h
deleted file mode 100644
index 800fbab..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/unittest.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#ifndef UNITTEST_H_
-#define UNITTEST_H_
-
-
-// gtest indirectly included inttypes.h, without __STDC_CONSTANT_MACROS.
-#ifndef __STDC_CONSTANT_MACROS
-#  define __STDC_CONSTANT_MACROS 1 // required by C++ standard
-#endif
-
-#ifdef _MSC_VER
-#define _CRTDBG_MAP_ALLOC
-#include <crtdbg.h>
-#pragma warning(disable : 4996) // 'function': was declared deprecated
-#endif
-
-#if defined(__clang__) || defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
-#if defined(__clang__) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-#pragma GCC diagnostic push
-#endif
-#pragma GCC diagnostic ignored "-Weffc++"
-#endif
-
-#include "gtest/gtest.h"
-#include <stdexcept>
-
-#if defined(__clang__) || defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
-#pragma GCC diagnostic pop
-#endif
-
-template <typename Ch>
-inline unsigned StrLen(const Ch* s) {
-    const Ch* p = s;
-    while (*p) p++;
-    return unsigned(p - s);
-}
-
-template<typename Ch>
-inline int StrCmp(const Ch* s1, const Ch* s2) {
-    while(*s1 && (*s1 == *s2)) { s1++; s2++; }
-    return (unsigned)*s1 < (unsigned)*s2 ? -1 : (unsigned)*s1 > (unsigned)*s2;
-}
-
-template <typename Ch>
-inline Ch* StrDup(const Ch* str) {
-    size_t bufferSize = sizeof(Ch) * (StrLen(str) + 1);
-    Ch* buffer = (Ch*)malloc(bufferSize);
-    memcpy(buffer, str, bufferSize);
-    return buffer;
-}
-
-inline FILE* TempFile(char *filename) {
-#if _MSC_VER
-    filename = tmpnam(filename);
-
-    // For Visual Studio, tmpnam() adds a backslash in front. Remove it.
-    if (filename[0] == '\\')
-        for (int i = 0; filename[i] != '\0'; i++)
-            filename[i] = filename[i + 1];
-        
-    return fopen(filename, "wb");
-#else
-    strcpy(filename, "/tmp/fileXXXXXX");
-    int fd = mkstemp(filename);
-    return fdopen(fd, "w");
-#endif
-}
-
-// Use exception for catching assert
-#if _MSC_VER
-#pragma warning(disable : 4127)
-#endif
-
-class AssertException : public std::logic_error {
-public:
-    AssertException(const char* w) : std::logic_error(w) {}
-};
-
-#define RAPIDJSON_ASSERT(x) if (!(x)) throw AssertException(RAPIDJSON_STRINGIFY(x))
-
-class Random {
-public:
-    Random(unsigned seed = 0) : mSeed(seed) {}
-
-    unsigned operator()() {
-        mSeed = 214013 * mSeed + 2531011;
-        return mSeed;
-    }
-
-private:
-    unsigned mSeed;
-};
-
-#endif // UNITTEST_H_
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/valuetest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/valuetest.cpp
deleted file mode 100644
index b2647c0..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/valuetest.cpp
+++ /dev/null
@@ -1,1239 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-#include "rapidjson/document.h"
-#include <algorithm>
-
-using namespace rapidjson;
-
-TEST(Value, DefaultConstructor) {
-    Value x;
-    EXPECT_EQ(kNullType, x.GetType());
-    EXPECT_TRUE(x.IsNull());
-
-    //std::cout << "sizeof(Value): " << sizeof(x) << std::endl;
-}
-
-// Should not pass compilation
-//TEST(Value, copy_constructor) {
-//  Value x(1234);
-//  Value y = x;
-//}
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-#include <type_traits>
-
-TEST(Value, Traits) {
-    typedef GenericValue<UTF8<>, CrtAllocator> Value;
-    static_assert(std::is_constructible<Value>::value, "");
-    static_assert(std::is_default_constructible<Value>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_copy_constructible<Value>::value, "");
-#endif
-    static_assert(std::is_move_constructible<Value>::value, "");
-
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_constructible<Value>::value, "");
-    static_assert(std::is_nothrow_default_constructible<Value>::value, "");
-    static_assert(!std::is_nothrow_copy_constructible<Value>::value, "");
-    static_assert(std::is_nothrow_move_constructible<Value>::value, "");
-#endif
-
-    static_assert(std::is_assignable<Value,Value>::value, "");
-#ifndef _MSC_VER
-    static_assert(!std::is_copy_assignable<Value>::value, "");
-#endif
-    static_assert(std::is_move_assignable<Value>::value, "");
-
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_assignable<Value, Value>::value, "");
-#endif
-    static_assert(!std::is_nothrow_copy_assignable<Value>::value, "");
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_move_assignable<Value>::value, "");
-#endif
-
-    static_assert(std::is_destructible<Value>::value, "");
-#ifndef _MSC_VER
-    static_assert(std::is_nothrow_destructible<Value>::value, "");
-#endif
-}
-
-TEST(Value, MoveConstructor) {
-    typedef GenericValue<UTF8<>, CrtAllocator> Value;
-    Value::AllocatorType allocator;
-
-    Value x((Value(kArrayType)));
-    x.Reserve(4u, allocator);
-    x.PushBack(1, allocator).PushBack(2, allocator).PushBack(3, allocator).PushBack(4, allocator);
-    EXPECT_TRUE(x.IsArray());
-    EXPECT_EQ(4u, x.Size());
-
-    // Value y(x); // does not compile (!is_copy_constructible)
-    Value y(std::move(x));
-    EXPECT_TRUE(x.IsNull());
-    EXPECT_TRUE(y.IsArray());
-    EXPECT_EQ(4u, y.Size());
-
-    // Value z = y; // does not compile (!is_copy_assignable)
-    Value z = std::move(y);
-    EXPECT_TRUE(y.IsNull());
-    EXPECT_TRUE(z.IsArray());
-    EXPECT_EQ(4u, z.Size());
-}
-
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-
-TEST(Value, AssignmentOperator) {
-    Value x(1234);
-    Value y;
-    y = x;
-    EXPECT_TRUE(x.IsNull());    // move semantic
-    EXPECT_EQ(1234, y.GetInt());
-
-    y = 5678;
-    EXPECT_TRUE(y.IsInt());
-    EXPECT_EQ(5678, y.GetInt());
-
-    x = "Hello";
-    EXPECT_TRUE(x.IsString());
-    EXPECT_STREQ(x.GetString(),"Hello");
-
-    y = StringRef(x.GetString(),x.GetStringLength());
-    EXPECT_TRUE(y.IsString());
-    EXPECT_EQ(y.GetString(),x.GetString());
-    EXPECT_EQ(y.GetStringLength(),x.GetStringLength());
-
-    static char mstr[] = "mutable";
-    // y = mstr; // should not compile
-    y = StringRef(mstr);
-    EXPECT_TRUE(y.IsString());
-    EXPECT_EQ(y.GetString(),mstr);
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    // C++11 move assignment
-    x = Value("World");
-    EXPECT_TRUE(x.IsString());
-    EXPECT_STREQ("World", x.GetString());
-
-    x = std::move(y);
-    EXPECT_TRUE(y.IsNull());
-    EXPECT_TRUE(x.IsString());
-    EXPECT_EQ(x.GetString(), mstr);
-
-    y = std::move(Value().SetInt(1234));
-    EXPECT_TRUE(y.IsInt());
-    EXPECT_EQ(1234, y);
-#endif // RAPIDJSON_HAS_CXX11_RVALUE_REFS
-}
-
-template <typename A, typename B> 
-void TestEqual(const A& a, const B& b) {
-    EXPECT_TRUE (a == b);
-    EXPECT_FALSE(a != b);
-    EXPECT_TRUE (b == a);
-    EXPECT_FALSE(b != a);
-}
-
-template <typename A, typename B> 
-void TestUnequal(const A& a, const B& b) {
-    EXPECT_FALSE(a == b);
-    EXPECT_TRUE (a != b);
-    EXPECT_FALSE(b == a);
-    EXPECT_TRUE (b != a);
-}
-
-TEST(Value, EqualtoOperator) {
-    Value::AllocatorType allocator;
-    Value x(kObjectType);
-    x.AddMember("hello", "world", allocator)
-        .AddMember("t", Value(true).Move(), allocator)
-        .AddMember("f", Value(false).Move(), allocator)
-        .AddMember("n", Value(kNullType).Move(), allocator)
-        .AddMember("i", 123, allocator)
-        .AddMember("pi", 3.14, allocator)
-        .AddMember("a", Value(kArrayType).Move().PushBack(1, allocator).PushBack(2, allocator).PushBack(3, allocator), allocator);
-
-    // Test templated operator==() and operator!=()
-    TestEqual(x["hello"], "world");
-    const char* cc = "world";
-    TestEqual(x["hello"], cc);
-    char* c = strdup("world");
-    TestEqual(x["hello"], c);
-    free(c);
-
-    TestEqual(x["t"], true);
-    TestEqual(x["f"], false);
-    TestEqual(x["i"], 123);
-    TestEqual(x["pi"], 3.14);
-
-    // Test operator==() (including different allocators)
-    CrtAllocator crtAllocator;
-    GenericValue<UTF8<>, CrtAllocator> y;
-    GenericDocument<UTF8<>, CrtAllocator> z(&crtAllocator);
-    y.CopyFrom(x, crtAllocator);
-    z.CopyFrom(y, z.GetAllocator());
-    TestEqual(x, y);
-    TestEqual(y, z);
-    TestEqual(z, x);
-
-    // Swapping member order should be fine.
-    EXPECT_TRUE(y.RemoveMember("t"));
-    TestUnequal(x, y);
-    TestUnequal(z, y);
-    EXPECT_TRUE(z.RemoveMember("t"));
-    TestUnequal(x, z);
-    TestEqual(y, z);
-    y.AddMember("t", true, crtAllocator);
-    z.AddMember("t", true, z.GetAllocator());
-    TestEqual(x, y);
-    TestEqual(y, z);
-    TestEqual(z, x);
-
-    // Issue #129: compare Uint64
-    x.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFF0));
-    y.SetUint64(RAPIDJSON_UINT64_C2(0xFFFFFFFF, 0xFFFFFFFF));
-    TestUnequal(x, y);
-}
-
-template <typename Value>
-void TestCopyFrom() {
-    typename Value::AllocatorType a;
-    Value v1(1234);
-    Value v2(v1, a); // deep copy constructor
-    EXPECT_TRUE(v1.GetType() == v2.GetType());
-    EXPECT_EQ(v1.GetInt(), v2.GetInt());
-
-    v1.SetString("foo");
-    v2.CopyFrom(v1, a);
-    EXPECT_TRUE(v1.GetType() == v2.GetType());
-    EXPECT_STREQ(v1.GetString(), v2.GetString());
-    EXPECT_EQ(v1.GetString(), v2.GetString()); // string NOT copied
-
-    v1.SetArray().PushBack(1234, a);
-    v2.CopyFrom(v1, a);
-    EXPECT_TRUE(v2.IsArray());
-    EXPECT_EQ(v1.Size(), v2.Size());
-
-    v1.PushBack(Value().SetString("foo", a), a); // push string copy
-    EXPECT_TRUE(v1.Size() != v2.Size());
-    v2.CopyFrom(v1, a);
-    EXPECT_TRUE(v1.Size() == v2.Size());
-    EXPECT_STREQ(v1[1].GetString(), v2[1].GetString());
-    EXPECT_NE(v1[1].GetString(), v2[1].GetString()); // string got copied
-}
-
-TEST(Value, CopyFrom) {
-    TestCopyFrom<Value>();
-    TestCopyFrom<GenericValue<UTF8<>, CrtAllocator> >();
-}
-
-TEST(Value, Swap) {
-    Value v1(1234);
-    Value v2(kObjectType);
-
-    EXPECT_EQ(&v1, &v1.Swap(v2));
-    EXPECT_TRUE(v1.IsObject());
-    EXPECT_TRUE(v2.IsInt());
-    EXPECT_EQ(1234, v2.GetInt());
-}
-
-TEST(Value, Null) {
-    // Default constructor
-    Value x;
-    EXPECT_EQ(kNullType, x.GetType());
-    EXPECT_TRUE(x.IsNull());
-
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsNumber());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // Constructor with type
-    Value y(kNullType);
-    EXPECT_TRUE(y.IsNull());
-
-    // SetNull();
-    Value z(true);
-    z.SetNull();
-    EXPECT_TRUE(z.IsNull());
-}
-
-TEST(Value, True) {
-    // Constructor with bool
-    Value x(true);
-    EXPECT_EQ(kTrueType, x.GetType());
-    EXPECT_TRUE(x.GetBool());
-    EXPECT_TRUE(x.IsBool());
-    EXPECT_TRUE(x.IsTrue());
-
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsNumber());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // Constructor with type
-    Value y(kTrueType);
-    EXPECT_TRUE(y.IsTrue());
-
-    // SetBool()
-    Value z;
-    z.SetBool(true);
-    EXPECT_TRUE(z.IsTrue());
-}
-
-TEST(Value, False) {
-    // Constructor with bool
-    Value x(false);
-    EXPECT_EQ(kFalseType, x.GetType());
-    EXPECT_TRUE(x.IsBool());
-    EXPECT_TRUE(x.IsFalse());
-
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.GetBool());
-    //EXPECT_FALSE((bool)x);
-    EXPECT_FALSE(x.IsNumber());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // Constructor with type
-    Value y(kFalseType);
-    EXPECT_TRUE(y.IsFalse());
-
-    // SetBool()
-    Value z;
-    z.SetBool(false);
-    EXPECT_TRUE(z.IsFalse());
-}
-
-TEST(Value, Int) {
-    // Constructor with int
-    Value x(1234);
-    EXPECT_EQ(kNumberType, x.GetType());
-    EXPECT_EQ(1234, x.GetInt());
-    EXPECT_EQ(1234u, x.GetUint());
-    EXPECT_EQ(1234, x.GetInt64());
-    EXPECT_EQ(1234u, x.GetUint64());
-    EXPECT_EQ(1234, x.GetDouble());
-    //EXPECT_EQ(1234, (int)x);
-    //EXPECT_EQ(1234, (unsigned)x);
-    //EXPECT_EQ(1234, (int64_t)x);
-    //EXPECT_EQ(1234, (uint64_t)x);
-    //EXPECT_EQ(1234, (double)x);
-    EXPECT_TRUE(x.IsNumber());
-    EXPECT_TRUE(x.IsInt());
-    EXPECT_TRUE(x.IsUint());
-    EXPECT_TRUE(x.IsInt64());
-    EXPECT_TRUE(x.IsUint64());
-
-    EXPECT_FALSE(x.IsDouble());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    Value nx(-1234);
-    EXPECT_EQ(-1234, nx.GetInt());
-    EXPECT_EQ(-1234, nx.GetInt64());
-    EXPECT_TRUE(nx.IsInt());
-    EXPECT_TRUE(nx.IsInt64());
-    EXPECT_FALSE(nx.IsUint());
-    EXPECT_FALSE(nx.IsUint64());
-
-    // Constructor with type
-    Value y(kNumberType);
-    EXPECT_TRUE(y.IsNumber());
-    EXPECT_TRUE(y.IsInt());
-    EXPECT_EQ(0, y.GetInt());
-
-    // SetInt()
-    Value z;
-    z.SetInt(1234);
-    EXPECT_EQ(1234, z.GetInt());
-
-    // operator=(int)
-    z = 5678;
-    EXPECT_EQ(5678, z.GetInt());
-}
-
-TEST(Value, Uint) {
-    // Constructor with int
-    Value x(1234u);
-    EXPECT_EQ(kNumberType, x.GetType());
-    EXPECT_EQ(1234, x.GetInt());
-    EXPECT_EQ(1234u, x.GetUint());
-    EXPECT_EQ(1234, x.GetInt64());
-    EXPECT_EQ(1234u, x.GetUint64());
-    EXPECT_TRUE(x.IsNumber());
-    EXPECT_TRUE(x.IsInt());
-    EXPECT_TRUE(x.IsUint());
-    EXPECT_TRUE(x.IsInt64());
-    EXPECT_TRUE(x.IsUint64());
-    EXPECT_EQ(1234.0, x.GetDouble());   // Number can always be cast as double but !IsDouble().
-
-    EXPECT_FALSE(x.IsDouble());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // SetUint()
-    Value z;
-    z.SetUint(1234);
-    EXPECT_EQ(1234u, z.GetUint());
-
-    // operator=(unsigned)
-    z = 5678u;
-    EXPECT_EQ(5678u, z.GetUint());
-
-    z = 2147483648u;    // 2^31, cannot cast as int
-    EXPECT_EQ(2147483648u, z.GetUint());
-    EXPECT_FALSE(z.IsInt());
-    EXPECT_TRUE(z.IsInt64());   // Issue 41: Incorrect parsing of unsigned int number types
-}
-
-TEST(Value, Int64) {
-    // Constructor with int
-    Value x(int64_t(1234LL));
-    EXPECT_EQ(kNumberType, x.GetType());
-    EXPECT_EQ(1234, x.GetInt());
-    EXPECT_EQ(1234u, x.GetUint());
-    EXPECT_EQ(1234, x.GetInt64());
-    EXPECT_EQ(1234u, x.GetUint64());
-    EXPECT_TRUE(x.IsNumber());
-    EXPECT_TRUE(x.IsInt());
-    EXPECT_TRUE(x.IsUint());
-    EXPECT_TRUE(x.IsInt64());
-    EXPECT_TRUE(x.IsUint64());
-
-    EXPECT_FALSE(x.IsDouble());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    Value nx(int64_t(-1234LL));
-    EXPECT_EQ(-1234, nx.GetInt());
-    EXPECT_EQ(-1234, nx.GetInt64());
-    EXPECT_TRUE(nx.IsInt());
-    EXPECT_TRUE(nx.IsInt64());
-    EXPECT_FALSE(nx.IsUint());
-    EXPECT_FALSE(nx.IsUint64());
-
-    // SetInt64()
-    Value z;
-    z.SetInt64(1234);
-    EXPECT_EQ(1234, z.GetInt64());
-
-    z.SetInt64(2147483648LL);   // 2^31, cannot cast as int
-    EXPECT_FALSE(z.IsInt());
-    EXPECT_TRUE(z.IsUint());
-
-    z.SetInt64(4294967296LL);   // 2^32, cannot cast as uint
-    EXPECT_FALSE(z.IsInt());
-    EXPECT_FALSE(z.IsUint());
-}
-
-TEST(Value, Uint64) {
-    // Constructor with int
-    Value x(uint64_t(1234LL));
-    EXPECT_EQ(kNumberType, x.GetType());
-    EXPECT_EQ(1234, x.GetInt());
-    EXPECT_EQ(1234u, x.GetUint());
-    EXPECT_EQ(1234, x.GetInt64());
-    EXPECT_EQ(1234u, x.GetUint64());
-    EXPECT_TRUE(x.IsNumber());
-    EXPECT_TRUE(x.IsInt());
-    EXPECT_TRUE(x.IsUint());
-    EXPECT_TRUE(x.IsInt64());
-    EXPECT_TRUE(x.IsUint64());
-
-    EXPECT_FALSE(x.IsDouble());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // SetUint64()
-    Value z;
-    z.SetUint64(1234);
-    EXPECT_EQ(1234u, z.GetUint64());
-
-    z.SetUint64(2147483648LL);  // 2^31, cannot cast as int
-    EXPECT_FALSE(z.IsInt());
-    EXPECT_TRUE(z.IsUint());
-    EXPECT_TRUE(z.IsInt64());
-
-    z.SetUint64(4294967296LL);  // 2^32, cannot cast as uint
-    EXPECT_FALSE(z.IsInt());
-    EXPECT_FALSE(z.IsUint());
-    EXPECT_TRUE(z.IsInt64());
-
-    z.SetUint64(9223372036854775808uLL);    // 2^63 cannot cast as int64
-    EXPECT_FALSE(z.IsInt64());
-
-    // Issue 48
-    EXPECT_EQ(9223372036854775808uLL, z.GetUint64());
-}
-
-TEST(Value, Double) {
-    // Constructor with double
-    Value x(12.34);
-    EXPECT_EQ(kNumberType, x.GetType());
-    EXPECT_EQ(12.34, x.GetDouble());
-    EXPECT_TRUE(x.IsNumber());
-    EXPECT_TRUE(x.IsDouble());
-
-    EXPECT_FALSE(x.IsInt());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    // SetDouble()
-    Value z;
-    z.SetDouble(12.34);
-    EXPECT_EQ(12.34, z.GetDouble());
-
-    z = 56.78;
-    EXPECT_EQ(56.78, z.GetDouble());
-}
-
-TEST(Value, String) {
-    // Construction with const string
-    Value x("Hello", 5); // literal
-    EXPECT_EQ(kStringType, x.GetType());
-    EXPECT_TRUE(x.IsString());
-    EXPECT_STREQ("Hello", x.GetString());
-    EXPECT_EQ(5u, x.GetStringLength());
-
-    EXPECT_FALSE(x.IsNumber());
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsObject());
-    EXPECT_FALSE(x.IsArray());
-
-    static const char cstr[] = "World"; // const array
-    Value(cstr).Swap(x);
-    EXPECT_TRUE(x.IsString());
-    EXPECT_EQ(x.GetString(), cstr);
-    EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1);
-
-    static char mstr[] = "Howdy"; // non-const array
-    // Value(mstr).Swap(x); // should not compile
-    Value(StringRef(mstr)).Swap(x);
-    EXPECT_TRUE(x.IsString());
-    EXPECT_EQ(x.GetString(), mstr);
-    EXPECT_EQ(x.GetStringLength(), sizeof(mstr)-1);
-    strncpy(mstr,"Hello", sizeof(mstr));
-    EXPECT_STREQ(x.GetString(), "Hello");
-
-    const char* pstr = cstr;
-    //Value(pstr).Swap(x); // should not compile
-    Value(StringRef(pstr)).Swap(x);
-    EXPECT_TRUE(x.IsString());
-    EXPECT_EQ(x.GetString(), cstr);
-    EXPECT_EQ(x.GetStringLength(), sizeof(cstr)-1);
-
-    char* mpstr = mstr;
-    Value(StringRef(mpstr,sizeof(mstr)-1)).Swap(x);
-    EXPECT_TRUE(x.IsString());
-    EXPECT_EQ(x.GetString(), mstr);
-    EXPECT_EQ(x.GetStringLength(), 5u);
-    EXPECT_STREQ(x.GetString(), "Hello");
-
-    // Constructor with copy string
-    MemoryPoolAllocator<> allocator;
-    Value c(x.GetString(), x.GetStringLength(), allocator);
-    EXPECT_NE(x.GetString(), c.GetString());
-    EXPECT_EQ(x.GetStringLength(), c.GetStringLength());
-    EXPECT_STREQ(x.GetString(), c.GetString());
-    //x.SetString("World");
-    x.SetString("World", 5);
-    EXPECT_STREQ("Hello", c.GetString());
-    EXPECT_EQ(5u, c.GetStringLength());
-
-    // Constructor with type
-    Value y(kStringType);
-    EXPECT_TRUE(y.IsString());
-    EXPECT_STREQ("", y.GetString());    // Empty string should be "" instead of 0 (issue 226)
-    EXPECT_EQ(0u, y.GetStringLength());
-
-    // SetConsttring()
-    Value z;
-    z.SetString("Hello");
-    EXPECT_TRUE(x.IsString());
-    z.SetString("Hello", 5);
-    EXPECT_STREQ("Hello", z.GetString());
-    EXPECT_STREQ("Hello", z.GetString());
-    EXPECT_EQ(5u, z.GetStringLength());
-
-    z.SetString("Hello");
-    EXPECT_TRUE(z.IsString());
-    EXPECT_STREQ("Hello", z.GetString());
-
-    //z.SetString(mstr); // should not compile
-    //z.SetString(pstr); // should not compile
-    z.SetString(StringRef(mstr));
-    EXPECT_TRUE(z.IsString());
-    EXPECT_STREQ(z.GetString(), mstr);
-
-    z.SetString(cstr);
-    EXPECT_TRUE(z.IsString());
-    EXPECT_EQ(cstr, z.GetString());
-
-    z = cstr;
-    EXPECT_TRUE(z.IsString());
-    EXPECT_EQ(cstr, z.GetString());
-
-    // SetString()
-    char s[] = "World";
-    Value w;
-    w.SetString(s, (SizeType)strlen(s), allocator);
-    s[0] = '\0';
-    EXPECT_STREQ("World", w.GetString());
-    EXPECT_EQ(5u, w.GetStringLength());
-
-#if RAPIDJSON_HAS_STDSTRING
-    {
-        std::string str = "Hello World";
-        str[5] = '\0';
-        EXPECT_STREQ(str.data(),"Hello"); // embedded '\0'
-        EXPECT_EQ(str.size(), 11u);
-
-        // no copy
-        Value vs0(StringRef(str));
-        EXPECT_TRUE(vs0.IsString());
-        EXPECT_EQ(vs0.GetString(), str.data());
-        EXPECT_EQ(vs0.GetStringLength(), str.size());
-        TestEqual(vs0, str);
-
-        // do copy
-        Value vs1(str, allocator);
-        EXPECT_TRUE(vs1.IsString());
-        EXPECT_NE(vs1.GetString(), str.data());
-        EXPECT_NE(vs1.GetString(), str); // not equal due to embedded '\0'
-        EXPECT_EQ(vs1.GetStringLength(), str.size());
-        TestEqual(vs1, str);
-
-        // SetString
-        str = "World";
-        vs0.SetNull().SetString(str, allocator);
-        EXPECT_TRUE(vs0.IsString());
-        EXPECT_STREQ(vs0.GetString(), str.c_str());
-        EXPECT_EQ(vs0.GetStringLength(), str.size());
-        TestEqual(str, vs0);
-        TestUnequal(str, vs1);
-
-        // vs1 = str; // should not compile
-        vs1 = StringRef(str);
-        TestEqual(str, vs1);
-        TestEqual(vs0, vs1);
-    }
-#endif // RAPIDJSON_HAS_STDSTRING
-}
-
-// Issue 226: Value of string type should not point to NULL
-TEST(Value, SetStringNullException) {
-    Value v;
-    EXPECT_THROW(v.SetString(0, 0), AssertException);
-}
-
-TEST(Value, Array) {
-    Value x(kArrayType);
-    const Value& y = x;
-    Value::AllocatorType allocator;
-
-    EXPECT_EQ(kArrayType, x.GetType());
-    EXPECT_TRUE(x.IsArray());
-    EXPECT_TRUE(x.Empty());
-    EXPECT_EQ(0u, x.Size());
-    EXPECT_TRUE(y.IsArray());
-    EXPECT_TRUE(y.Empty());
-    EXPECT_EQ(0u, y.Size());
-
-    EXPECT_FALSE(x.IsNull());
-    EXPECT_FALSE(x.IsBool());
-    EXPECT_FALSE(x.IsFalse());
-    EXPECT_FALSE(x.IsTrue());
-    EXPECT_FALSE(x.IsString());
-    EXPECT_FALSE(x.IsObject());
-
-    // PushBack()
-    Value v;
-    x.PushBack(v, allocator);
-    v.SetBool(true);
-    x.PushBack(v, allocator);
-    v.SetBool(false);
-    x.PushBack(v, allocator);
-    v.SetInt(123);
-    x.PushBack(v, allocator);
-    //x.PushBack((const char*)"foo", allocator); // should not compile
-    x.PushBack("foo", allocator);
-
-    EXPECT_FALSE(x.Empty());
-    EXPECT_EQ(5u, x.Size());
-    EXPECT_FALSE(y.Empty());
-    EXPECT_EQ(5u, y.Size());
-    EXPECT_TRUE(x[SizeType(0)].IsNull());
-    EXPECT_TRUE(x[1].IsTrue());
-    EXPECT_TRUE(x[2].IsFalse());
-    EXPECT_TRUE(x[3].IsInt());
-    EXPECT_EQ(123, x[3].GetInt());
-    EXPECT_TRUE(y[SizeType(0)].IsNull());
-    EXPECT_TRUE(y[1].IsTrue());
-    EXPECT_TRUE(y[2].IsFalse());
-    EXPECT_TRUE(y[3].IsInt());
-    EXPECT_EQ(123, y[3].GetInt());
-    EXPECT_TRUE(y[4].IsString());
-    EXPECT_STREQ("foo", y[4].GetString());
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    // PushBack(GenericValue&&, Allocator&);
-    {
-        Value y(kArrayType);
-        y.PushBack(Value(true), allocator);
-        y.PushBack(std::move(Value(kArrayType).PushBack(Value(1), allocator).PushBack("foo", allocator)), allocator);
-        EXPECT_EQ(2u, y.Size());
-        EXPECT_TRUE(y[0].IsTrue());
-        EXPECT_TRUE(y[1].IsArray());
-        EXPECT_EQ(2u, y[1].Size());
-        EXPECT_TRUE(y[1][0].IsInt());
-        EXPECT_TRUE(y[1][1].IsString());
-    }
-#endif
-
-    // iterator
-    Value::ValueIterator itr = x.Begin();
-    EXPECT_TRUE(itr != x.End());
-    EXPECT_TRUE(itr->IsNull());
-    ++itr;
-    EXPECT_TRUE(itr != x.End());
-    EXPECT_TRUE(itr->IsTrue());
-    ++itr;
-    EXPECT_TRUE(itr != x.End());
-    EXPECT_TRUE(itr->IsFalse());
-    ++itr;
-    EXPECT_TRUE(itr != x.End());
-    EXPECT_TRUE(itr->IsInt());
-    EXPECT_EQ(123, itr->GetInt());
-    ++itr;
-    EXPECT_TRUE(itr != x.End());
-    EXPECT_TRUE(itr->IsString());
-    EXPECT_STREQ("foo", itr->GetString());
-
-    // const iterator
-    Value::ConstValueIterator citr = y.Begin();
-    EXPECT_TRUE(citr != y.End());
-    EXPECT_TRUE(citr->IsNull());
-    ++citr;
-    EXPECT_TRUE(citr != y.End());
-    EXPECT_TRUE(citr->IsTrue());
-    ++citr;
-    EXPECT_TRUE(citr != y.End());
-    EXPECT_TRUE(citr->IsFalse());
-    ++citr;
-    EXPECT_TRUE(citr != y.End());
-    EXPECT_TRUE(citr->IsInt());
-    EXPECT_EQ(123, citr->GetInt());
-    ++citr;
-    EXPECT_TRUE(citr != y.End());
-    EXPECT_TRUE(citr->IsString());
-    EXPECT_STREQ("foo", citr->GetString());
-
-    // PopBack()
-    x.PopBack();
-    EXPECT_EQ(4u, x.Size());
-    EXPECT_TRUE(y[SizeType(0)].IsNull());
-    EXPECT_TRUE(y[1].IsTrue());
-    EXPECT_TRUE(y[2].IsFalse());
-    EXPECT_TRUE(y[3].IsInt());
-
-    // Clear()
-    x.Clear();
-    EXPECT_TRUE(x.Empty());
-    EXPECT_EQ(0u, x.Size());
-    EXPECT_TRUE(y.Empty());
-    EXPECT_EQ(0u, y.Size());
-
-    // Erase(ValueIterator)
-
-    // Use array of array to ensure removed elements' destructor is called.
-    // [[0],[1],[2],...]
-    for (int i = 0; i < 10; i++)
-        x.PushBack(Value(kArrayType).PushBack(i, allocator).Move(), allocator);
-
-    // Erase the first
-    itr = x.Erase(x.Begin());
-    EXPECT_EQ(x.Begin(), itr);
-    EXPECT_EQ(9u, x.Size());
-    for (int i = 0; i < 9; i++)
-        EXPECT_EQ(i + 1, x[i][0].GetInt());
-
-    // Ease the last
-    itr = x.Erase(x.End() - 1);
-    EXPECT_EQ(x.End(), itr);
-    EXPECT_EQ(8u, x.Size());
-    for (int i = 0; i < 8; i++)
-        EXPECT_EQ(i + 1, x[i][0].GetInt());
-
-    // Erase the middle
-    itr = x.Erase(x.Begin() + 4);
-    EXPECT_EQ(x.Begin() + 4, itr);
-    EXPECT_EQ(7u, x.Size());
-    for (int i = 0; i < 4; i++)
-        EXPECT_EQ(i + 1, x[i][0].GetInt());
-    for (int i = 4; i < 7; i++)
-        EXPECT_EQ(i + 2, x[i][0].GetInt());
-
-    // Erase(ValueIterator, ValueIterator)
-    // Exhaustive test with all 0 <= first < n, first <= last <= n cases
-    const unsigned n = 10;
-    for (unsigned first = 0; first < n; first++) {
-        for (unsigned last = first; last <= n; last++) {
-            x.Clear();
-            for (unsigned i = 0; i < n; i++)
-                x.PushBack(Value(kArrayType).PushBack(i, allocator).Move(), allocator);
-            
-            itr = x.Erase(x.Begin() + first, x.Begin() + last);
-            if (last == n)
-                EXPECT_EQ(x.End(), itr);
-            else
-                EXPECT_EQ(x.Begin() + first, itr);
-
-            size_t removeCount = last - first;
-            EXPECT_EQ(n - removeCount, x.Size());
-            for (unsigned i = 0; i < first; i++)
-                EXPECT_EQ(i, x[i][0].GetUint());
-            for (unsigned i = first; i < n - removeCount; i++)
-                EXPECT_EQ(i + removeCount, x[i][0].GetUint());
-        }
-    }
-
-    // Working in gcc without C++11, but VS2013 cannot compile. To be diagnosed.
-    // http://en.wikipedia.org/wiki/Erase-remove_idiom
-    x.Clear();
-    for (int i = 0; i < 10; i++)
-        if (i % 2 == 0)
-            x.PushBack(i, allocator);
-        else
-            x.PushBack(Value(kNullType).Move(), allocator);
-
-    const Value null(kNullType);
-    x.Erase(std::remove(x.Begin(), x.End(), null), x.End());
-    EXPECT_EQ(5u, x.Size());
-    for (int i = 0; i < 5; i++)
-        EXPECT_EQ(i * 2, x[i]);
-
-    // SetArray()
-    Value z;
-    z.SetArray();
-    EXPECT_TRUE(z.IsArray());
-    EXPECT_TRUE(z.Empty());
-}
-
-TEST(Value, Object) {
-    Value x(kObjectType);
-    const Value& y = x; // const version
-    Value::AllocatorType allocator;
-
-    EXPECT_EQ(kObjectType, x.GetType());
-    EXPECT_TRUE(x.IsObject());
-    EXPECT_TRUE(x.ObjectEmpty());
-    EXPECT_EQ(0u, x.MemberCount());
-    EXPECT_EQ(kObjectType, y.GetType());
-    EXPECT_TRUE(y.IsObject());
-    EXPECT_TRUE(y.ObjectEmpty());
-    EXPECT_EQ(0u, y.MemberCount());
-
-    // AddMember()
-    x.AddMember("A", "Apple", allocator);
-    EXPECT_FALSE(x.ObjectEmpty());
-    EXPECT_EQ(1u, x.MemberCount());
-
-    Value value("Banana", 6);
-    x.AddMember("B", "Banana", allocator);
-    EXPECT_EQ(2u, x.MemberCount());
-
-    // AddMember<T>(StringRefType, T, Allocator)
-    {
-        Value o(kObjectType);
-        o.AddMember("true", true, allocator);
-        o.AddMember("false", false, allocator);
-        o.AddMember("int", -1, allocator);
-        o.AddMember("uint", 1u, allocator);
-        o.AddMember("int64", INT64_C(-4294967296), allocator);
-        o.AddMember("uint64", UINT64_C(4294967296), allocator);
-        o.AddMember("double", 3.14, allocator);
-        o.AddMember("string", "Jelly", allocator);
-
-        EXPECT_TRUE(o["true"].GetBool());
-        EXPECT_FALSE(o["false"].GetBool());
-        EXPECT_EQ(-1, o["int"].GetInt());
-        EXPECT_EQ(1u, o["uint"].GetUint());
-        EXPECT_EQ(INT64_C(-4294967296), o["int64"].GetInt64());
-        EXPECT_EQ(UINT64_C(4294967296), o["uint64"].GetUint64());
-        EXPECT_STREQ("Jelly",o["string"].GetString());
-        EXPECT_EQ(8u, o.MemberCount());
-    }
-
-    // AddMember<T>(Value&, T, Allocator)
-    {
-        Value o(kObjectType);
-
-        Value n("s");
-        o.AddMember(n, "string", allocator);
-        EXPECT_EQ(1u, o.MemberCount());
-
-        Value count("#");
-        o.AddMember(count, o.MemberCount(), allocator);
-        EXPECT_EQ(2u, o.MemberCount());
-    }
-
-#if RAPIDJSON_HAS_CXX11_RVALUE_REFS
-    // AddMember(GenericValue&&, ...) variants
-    {
-        Value o(kObjectType);
-        o.AddMember(Value("true"), Value(true), allocator);
-        o.AddMember(Value("false"), Value(false).Move(), allocator);    // value is lvalue ref
-        o.AddMember(Value("int").Move(), Value(-1), allocator);         // name is lvalue ref
-        o.AddMember("uint", std::move(Value().SetUint(1u)), allocator); // name is literal, value is rvalue
-        EXPECT_TRUE(o["true"].GetBool());
-        EXPECT_FALSE(o["false"].GetBool());
-        EXPECT_EQ(-1, o["int"].GetInt());
-        EXPECT_EQ(1u, o["uint"].GetUint());
-        EXPECT_EQ(4u, o.MemberCount());
-    }
-#endif
-
-    // Tests a member with null character
-    Value name;
-    const Value C0D("C\0D", 3);
-    name.SetString(C0D.GetString(), 3);
-    value.SetString("CherryD", 7);
-    x.AddMember(name, value, allocator);
-
-    // HasMember()
-    EXPECT_TRUE(x.HasMember("A"));
-    EXPECT_TRUE(x.HasMember("B"));
-    EXPECT_TRUE(y.HasMember("A"));
-    EXPECT_TRUE(y.HasMember("B"));
-
-    name.SetString("C\0D");
-    EXPECT_TRUE(x.HasMember(name));
-    EXPECT_TRUE(y.HasMember(name));
-
-    GenericValue<UTF8<>, CrtAllocator> othername("A");
-    EXPECT_TRUE(x.HasMember(othername));
-    EXPECT_TRUE(y.HasMember(othername));
-    othername.SetString("C\0D");
-    EXPECT_TRUE(x.HasMember(othername));
-    EXPECT_TRUE(y.HasMember(othername));
-
-    // operator[]
-    EXPECT_STREQ("Apple", x["A"].GetString());
-    EXPECT_STREQ("Banana", x["B"].GetString());
-    EXPECT_STREQ("CherryD", x[C0D].GetString());
-    EXPECT_STREQ("CherryD", x[othername].GetString());
-
-    // const operator[]
-    EXPECT_STREQ("Apple", y["A"].GetString());
-    EXPECT_STREQ("Banana", y["B"].GetString());
-    EXPECT_STREQ("CherryD", y[C0D].GetString());
-
-    // member iterator
-    Value::MemberIterator itr = x.MemberBegin(); 
-    EXPECT_TRUE(itr != x.MemberEnd());
-    EXPECT_STREQ("A", itr->name.GetString());
-    EXPECT_STREQ("Apple", itr->value.GetString());
-    ++itr;
-    EXPECT_TRUE(itr != x.MemberEnd());
-    EXPECT_STREQ("B", itr->name.GetString());
-    EXPECT_STREQ("Banana", itr->value.GetString());
-    ++itr;
-    EXPECT_TRUE(itr != x.MemberEnd());
-    EXPECT_TRUE(memcmp(itr->name.GetString(), "C\0D", 4) == 0);
-    EXPECT_STREQ("CherryD", itr->value.GetString());
-    ++itr;
-    EXPECT_FALSE(itr != x.MemberEnd());
-
-    // const member iterator
-    Value::ConstMemberIterator citr = y.MemberBegin(); 
-    EXPECT_TRUE(citr != y.MemberEnd());
-    EXPECT_STREQ("A", citr->name.GetString());
-    EXPECT_STREQ("Apple", citr->value.GetString());
-    ++citr;
-    EXPECT_TRUE(citr != y.MemberEnd());
-    EXPECT_STREQ("B", citr->name.GetString());
-    EXPECT_STREQ("Banana", citr->value.GetString());
-    ++citr;
-    EXPECT_TRUE(citr != y.MemberEnd());
-    EXPECT_TRUE(memcmp(citr->name.GetString(), "C\0D", 4) == 0);
-    EXPECT_STREQ("CherryD", citr->value.GetString());
-    ++citr;
-    EXPECT_FALSE(citr != y.MemberEnd());
-
-    // member iterator conversions/relations
-    itr  = x.MemberBegin();
-    citr = x.MemberBegin(); // const conversion
-    TestEqual(itr, citr);
-    EXPECT_TRUE(itr < x.MemberEnd());
-    EXPECT_FALSE(itr > y.MemberEnd());
-    EXPECT_TRUE(citr < x.MemberEnd());
-    EXPECT_FALSE(citr > y.MemberEnd());
-    ++citr;
-    TestUnequal(itr, citr);
-    EXPECT_FALSE(itr < itr);
-    EXPECT_TRUE(itr < citr);
-    EXPECT_FALSE(itr > itr);
-    EXPECT_TRUE(citr > itr);
-    EXPECT_EQ(1, citr - x.MemberBegin());
-    EXPECT_EQ(0, itr - y.MemberBegin());
-    itr += citr - x.MemberBegin();
-    EXPECT_EQ(1, itr - y.MemberBegin());
-    TestEqual(citr, itr);
-    EXPECT_TRUE(itr <= citr);
-    EXPECT_TRUE(citr <= itr);
-    itr++;
-    EXPECT_TRUE(itr >= citr);
-    EXPECT_FALSE(citr >= itr);
-
-    // RemoveMember()
-    x.RemoveMember("A");
-    EXPECT_FALSE(x.HasMember("A"));
-
-    x.RemoveMember("B");
-    EXPECT_FALSE(x.HasMember("B"));
-
-    x.RemoveMember(othername);
-    EXPECT_FALSE(x.HasMember(name));
-
-    EXPECT_TRUE(x.MemberBegin() == x.MemberEnd());
-
-    // EraseMember(ConstMemberIterator)
-
-    // Use array members to ensure removed elements' destructor is called.
-    // { "a": [0], "b": [1],[2],...]
-    const char keys[][2] = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" };
-    for (int i = 0; i < 10; i++)
-        x.AddMember(keys[i], Value(kArrayType).PushBack(i, allocator), allocator);
-
-    // MemberCount, iterator difference
-    EXPECT_EQ(x.MemberCount(), SizeType(x.MemberEnd() - x.MemberBegin()));
-
-    // Erase the first
-    itr = x.EraseMember(x.MemberBegin());
-    EXPECT_FALSE(x.HasMember(keys[0]));
-    EXPECT_EQ(x.MemberBegin(), itr);
-    EXPECT_EQ(9u, x.MemberCount());
-    for (; itr != x.MemberEnd(); ++itr) {
-        int i = (itr - x.MemberBegin()) + 1;
-        EXPECT_STREQ(itr->name.GetString(), keys[i]);
-        EXPECT_EQ(i, itr->value[0].GetInt());
-    }
-
-    // Erase the last
-    itr = x.EraseMember(x.MemberEnd() - 1);
-    EXPECT_FALSE(x.HasMember(keys[9]));
-    EXPECT_EQ(x.MemberEnd(), itr);
-    EXPECT_EQ(8u, x.MemberCount());
-    for (; itr != x.MemberEnd(); ++itr) {
-        int i = (itr - x.MemberBegin()) + 1;
-        EXPECT_STREQ(itr->name.GetString(), keys[i]);
-        EXPECT_EQ(i, itr->value[0].GetInt());
-    }
-
-    // Erase the middle
-    itr = x.EraseMember(x.MemberBegin() + 4);
-    EXPECT_FALSE(x.HasMember(keys[5]));
-    EXPECT_EQ(x.MemberBegin() + 4, itr);
-    EXPECT_EQ(7u, x.MemberCount());
-    for (; itr != x.MemberEnd(); ++itr) {
-        int i = (itr - x.MemberBegin());
-        i += (i<4) ? 1 : 2;
-        EXPECT_STREQ(itr->name.GetString(), keys[i]);
-        EXPECT_EQ(i, itr->value[0].GetInt());
-    }
-
-    // EraseMember(ConstMemberIterator, ConstMemberIterator)
-    // Exhaustive test with all 0 <= first < n, first <= last <= n cases
-    const unsigned n = 10;
-    for (unsigned first = 0; first < n; first++) {
-        for (unsigned last = first; last <= n; last++) {
-            Value(kObjectType).Swap(x);
-            for (unsigned i = 0; i < n; i++)
-                x.AddMember(keys[i], Value(kArrayType).PushBack(i, allocator), allocator);
-
-            itr = x.EraseMember(x.MemberBegin() + first, x.MemberBegin() + last);
-            if (last == n)
-                EXPECT_EQ(x.MemberEnd(), itr);
-            else
-                EXPECT_EQ(x.MemberBegin() + first, itr);
-
-            size_t removeCount = last - first;
-            EXPECT_EQ(n - removeCount, x.MemberCount());
-            for (unsigned i = 0; i < first; i++)
-                EXPECT_EQ(i, x[keys[i]][0].GetUint());
-            for (unsigned i = first; i < n - removeCount; i++)
-                EXPECT_EQ(i + removeCount, x[keys[i+removeCount]][0].GetUint());
-        }
-    }
-
-    // RemoveAllMembers()
-    x.RemoveAllMembers();
-    EXPECT_TRUE(x.ObjectEmpty());
-    EXPECT_EQ(0u, x.MemberCount());
-
-    // SetObject()
-    Value z;
-    z.SetObject();
-    EXPECT_TRUE(z.IsObject());
-}
-
-TEST(Value, BigNestedArray) {
-    MemoryPoolAllocator<> allocator;
-    Value x(kArrayType);
-    static const SizeType  n = 200;
-
-    for (SizeType i = 0; i < n; i++) {
-        Value y(kArrayType);
-        for (SizeType  j = 0; j < n; j++) {
-            Value number((int)(i * n + j));
-            y.PushBack(number, allocator);
-        }
-        x.PushBack(y, allocator);
-    }
-
-    for (SizeType i = 0; i < n; i++)
-        for (SizeType j = 0; j < n; j++) {
-            EXPECT_TRUE(x[i][j].IsInt());
-            EXPECT_EQ((int)(i * n + j), x[i][j].GetInt());
-        }
-}
-
-TEST(Value, BigNestedObject) {
-    MemoryPoolAllocator<> allocator;
-    Value x(kObjectType);
-    static const SizeType n = 200;
-
-    for (SizeType i = 0; i < n; i++) {
-        char name1[10];
-        sprintf(name1, "%d", i);
-
-        // Value name(name1); // should not compile
-        Value name(name1, (SizeType)strlen(name1), allocator);
-        Value object(kObjectType);
-
-        for (SizeType j = 0; j < n; j++) {
-            char name2[10];
-            sprintf(name2, "%d", j);
-
-            Value name(name2, (SizeType)strlen(name2), allocator);
-            Value number((int)(i * n + j));
-            object.AddMember(name, number, allocator);
-        }
-
-        // x.AddMember(name1, object, allocator); // should not compile
-        x.AddMember(name, object, allocator);
-    }
-
-    for (SizeType i = 0; i < n; i++) {
-        char name1[10];
-        sprintf(name1, "%d", i);
-        
-        for (SizeType j = 0; j < n; j++) {
-            char name2[10];
-            sprintf(name2, "%d", j);
-            x[name1];
-            EXPECT_EQ((int)(i * n + j), x[name1][name2].GetInt());
-        }
-    }
-}
-
-// Issue 18: Error removing last element of object
-// http://code.google.com/p/rapidjson/issues/detail?id=18
-TEST(Value, RemoveLastElement) {
-    rapidjson::Document doc;
-    rapidjson::Document::AllocatorType& allocator = doc.GetAllocator();
-    rapidjson::Value objVal(rapidjson::kObjectType);        
-    objVal.AddMember("var1", 123, allocator);       
-    objVal.AddMember("var2", "444", allocator);
-    objVal.AddMember("var3", 555, allocator);
-    EXPECT_TRUE(objVal.HasMember("var3"));
-    objVal.RemoveMember("var3");    // Assertion here in r61
-    EXPECT_FALSE(objVal.HasMember("var3"));
-}
-
-// Issue 38:    Segmentation fault with CrtAllocator
-TEST(Document, CrtAllocator) {
-    typedef GenericValue<UTF8<>, CrtAllocator> V;
-
-    V::AllocatorType allocator;
-    V o(kObjectType);
-    o.AddMember("x", 1, allocator); // Should not call destructor on uninitialized name/value of newly allocated members.
-
-    V a(kArrayType);
-    a.PushBack(1, allocator);   // Should not call destructor on uninitialized Value of newly allocated elements.
-}
-
-static void TestShortStringOptimization(const char* str) {
-    const rapidjson::SizeType len = (rapidjson::SizeType)strlen(str);
-	
-    rapidjson::Document doc;
-    rapidjson::Value val;
-    val.SetString(str, len, doc.GetAllocator());
-	
-	EXPECT_EQ(val.GetStringLength(), len);
-	EXPECT_STREQ(val.GetString(), str);
-}
-
-TEST(Value, AllocateShortString) {
-	TestShortStringOptimization("");                 // edge case: empty string
-	TestShortStringOptimization("12345678");         // regular case for short strings: 8 chars
-	TestShortStringOptimization("12345678901");      // edge case: 11 chars in 32-bit mode (=> short string)
-	TestShortStringOptimization("123456789012");     // edge case: 12 chars in 32-bit mode (=> regular string)
-	TestShortStringOptimization("123456789012345");  // edge case: 15 chars in 64-bit mode (=> short string)
-	TestShortStringOptimization("1234567890123456"); // edge case: 16 chars in 64-bit mode (=> regular string)
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/writertest.cpp b/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/writertest.cpp
deleted file mode 100644
index 0ef1423..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/test/unittest/writertest.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-// Copyright (C) 2011 Milo Yip
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include "unittest.h"
-
-#include "rapidjson/document.h"
-#include "rapidjson/reader.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/stringbuffer.h"
-
-using namespace rapidjson;
-
-TEST(Writer, Compact) {
-    StringStream s("{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ");
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    buffer.ShrinkToFit();
-    Reader reader;
-    reader.Parse<0>(s, writer);
-    EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3]}", buffer.GetString());
-    EXPECT_EQ(77u, buffer.GetSize());
-    EXPECT_TRUE(writer.IsComplete());
-}
-
-// json -> parse -> writer -> json
-#define TEST_ROUNDTRIP(json) \
-    { \
-        StringStream s(json); \
-        StringBuffer buffer; \
-        Writer<StringBuffer> writer(buffer); \
-        Reader reader; \
-        reader.Parse<0>(s, writer); \
-        EXPECT_STREQ(json, buffer.GetString()); \
-        EXPECT_TRUE(writer.IsComplete()); \
-    }
-
-TEST(Writer, Root) {
-    TEST_ROUNDTRIP("null");
-    TEST_ROUNDTRIP("true");
-    TEST_ROUNDTRIP("false");
-    TEST_ROUNDTRIP("0");
-    TEST_ROUNDTRIP("\"foo\"");
-    TEST_ROUNDTRIP("[]");
-    TEST_ROUNDTRIP("{}");
-}
-
-TEST(Writer, Int) {
-    TEST_ROUNDTRIP("[-1]");
-    TEST_ROUNDTRIP("[-123]");
-    TEST_ROUNDTRIP("[-2147483648]");
-}
-
-TEST(Writer, UInt) {
-    TEST_ROUNDTRIP("[0]");
-    TEST_ROUNDTRIP("[1]");
-    TEST_ROUNDTRIP("[123]");
-    TEST_ROUNDTRIP("[2147483647]");
-    TEST_ROUNDTRIP("[4294967295]");
-}
-
-TEST(Writer, Int64) {
-    TEST_ROUNDTRIP("[-1234567890123456789]");
-    TEST_ROUNDTRIP("[-9223372036854775808]");
-}
-
-TEST(Writer, Uint64) {
-    TEST_ROUNDTRIP("[1234567890123456789]");
-    TEST_ROUNDTRIP("[9223372036854775807]");
-}
-
-TEST(Writer, String) {
-    TEST_ROUNDTRIP("[\"Hello\"]");
-    TEST_ROUNDTRIP("[\"Hello\\u0000World\"]");
-    TEST_ROUNDTRIP("[\"\\\"\\\\/\\b\\f\\n\\r\\t\"]");
-}
-
-TEST(Writer, Double) {
-    TEST_ROUNDTRIP("[1.2345,1.2345678,0.123456789012,1234567.8]");
-
-}
-
-TEST(Writer, Transcode) {
-    const char json[] = "{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3],\"dollar\":\"\x24\",\"cents\":\"\xC2\xA2\",\"euro\":\"\xE2\x82\xAC\",\"gclef\":\"\xF0\x9D\x84\x9E\"}";
-
-    // UTF8 -> UTF16 -> UTF8
-    {
-        StringStream s(json);
-        StringBuffer buffer;
-        Writer<StringBuffer, UTF16<>, UTF8<> > writer(buffer);
-        GenericReader<UTF8<>, UTF16<> > reader;
-        reader.Parse(s, writer);
-        EXPECT_STREQ(json, buffer.GetString());
-    }
-
-    // UTF8 -> UTF8 -> ASCII -> UTF8 -> UTF8
-    {
-        StringStream s(json);
-        StringBuffer buffer;
-        Writer<StringBuffer, UTF8<>, ASCII<> > writer(buffer);
-        Reader reader;
-        reader.Parse(s, writer);
-
-        StringBuffer buffer2;
-        Writer<StringBuffer> writer2(buffer2);
-        GenericReader<ASCII<>, UTF8<> > reader2;
-        StringStream s2(buffer.GetString());
-        reader2.Parse(s2, writer2);
-
-        EXPECT_STREQ(json, buffer2.GetString());
-    }
-}
-
-#include <sstream>
-
-class OStreamWrapper {
-public:
-    typedef char Ch;
-
-    OStreamWrapper(std::ostream& os) : os_(os) {}
-
-    Ch Peek() const { assert(false); return '\0'; }
-    Ch Take() { assert(false); return '\0'; }
-    size_t Tell() const { return 0; }
-
-    Ch* PutBegin() { assert(false); return 0; }
-    void Put(Ch c) { os_.put(c); }
-    void Flush() { os_.flush(); }
-    size_t PutEnd(Ch*) { assert(false); return 0; }
-
-private:
-    OStreamWrapper(const OStreamWrapper&);
-    OStreamWrapper& operator=(const OStreamWrapper&);
-
-    std::ostream& os_;
-};
-
-TEST(Writer, OStreamWrapper) {
-    StringStream s("{ \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3] } ");
-    
-    std::stringstream ss;
-    OStreamWrapper os(ss);
-    
-    Writer<OStreamWrapper> writer(os);
-
-    Reader reader;
-    reader.Parse<0>(s, writer);
-    
-    std::string actual = ss.str();
-    EXPECT_STREQ("{\"hello\":\"world\",\"t\":true,\"f\":false,\"n\":null,\"i\":123,\"pi\":3.1416,\"a\":[1,2,3]}", actual.c_str());
-}
-
-TEST(Writer, AssertRootMayBeAnyValue) {
-#define T(x)\
-    {\
-        StringBuffer buffer;\
-        Writer<StringBuffer> writer(buffer);\
-        EXPECT_TRUE(x);\
-    }
-    T(writer.Bool(false));
-    T(writer.Bool(true));
-    T(writer.Null());
-    T(writer.Int(0));
-    T(writer.Uint(0));
-    T(writer.Int64(0));
-    T(writer.Uint64(0));
-    T(writer.Double(0));
-    T(writer.String("foo"));
-#undef T
-}
-
-TEST(Writer, AssertIncorrectObjectLevel) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    writer.StartObject();
-    writer.EndObject();
-    ASSERT_THROW(writer.EndObject(), AssertException);
-}
-
-TEST(Writer, AssertIncorrectArrayLevel) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    writer.StartArray();
-    writer.EndArray();
-    ASSERT_THROW(writer.EndArray(), AssertException);
-}
-
-TEST(Writer, AssertIncorrectEndObject) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    writer.StartObject();
-    ASSERT_THROW(writer.EndArray(), AssertException);
-}
-
-TEST(Writer, AssertIncorrectEndArray) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    writer.StartObject();
-    ASSERT_THROW(writer.EndArray(), AssertException);
-}
-
-TEST(Writer, AssertObjectKeyNotString) {
-#define T(x)\
-    {\
-        StringBuffer buffer;\
-        Writer<StringBuffer> writer(buffer);\
-        writer.StartObject();\
-        ASSERT_THROW(x, AssertException); \
-    }
-    T(writer.Bool(false));
-    T(writer.Bool(true));
-    T(writer.Null());
-    T(writer.Int(0));
-    T(writer.Uint(0));
-    T(writer.Int64(0));
-    T(writer.Uint64(0));
-    T(writer.Double(0));
-    T(writer.StartObject());
-    T(writer.StartArray());
-#undef T
-}
-
-TEST(Writer, AssertMultipleRoot) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-
-    writer.StartObject();
-    writer.EndObject();
-    ASSERT_THROW(writer.StartObject(), AssertException);
-
-    writer.Reset(buffer);
-    writer.Null();
-    ASSERT_THROW(writer.Int(0), AssertException);
-
-    writer.Reset(buffer);
-    writer.String("foo");
-    ASSERT_THROW(writer.StartArray(), AssertException);
-
-    writer.Reset(buffer);
-    writer.StartArray();
-    writer.EndArray();
-    //ASSERT_THROW(writer.Double(3.14), AssertException);
-}
-
-TEST(Writer, RootObjectIsComplete) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    EXPECT_FALSE(writer.IsComplete());
-    writer.StartObject();
-    EXPECT_FALSE(writer.IsComplete());
-    writer.String("foo");
-    EXPECT_FALSE(writer.IsComplete());
-    writer.Int(1);
-    EXPECT_FALSE(writer.IsComplete());
-    writer.EndObject();
-    EXPECT_TRUE(writer.IsComplete());
-}
-
-TEST(Writer, RootArrayIsComplete) {
-    StringBuffer buffer;
-    Writer<StringBuffer> writer(buffer);
-    EXPECT_FALSE(writer.IsComplete());
-    writer.StartArray();
-    EXPECT_FALSE(writer.IsComplete());
-    writer.String("foo");
-    EXPECT_FALSE(writer.IsComplete());
-    writer.Int(1);
-    EXPECT_FALSE(writer.IsComplete());
-    writer.EndArray();
-    EXPECT_TRUE(writer.IsComplete());
-}
-
-TEST(Writer, RootValueIsComplete) {
-#define T(x)\
-    {\
-        StringBuffer buffer;\
-        Writer<StringBuffer> writer(buffer);\
-        EXPECT_FALSE(writer.IsComplete()); \
-        x; \
-        EXPECT_TRUE(writer.IsComplete()); \
-    }
-    T(writer.Null());
-    T(writer.Bool(true));
-    T(writer.Bool(false));
-    T(writer.Int(0));
-    T(writer.Uint(0));
-    T(writer.Int64(0));
-    T(writer.Uint64(0));
-    T(writer.Double(0));
-    T(writer.String(""));
-#undef T
-}
diff --git a/third_party/socket.io-client-cpp/lib/rapidjson/travis-doxygen.sh b/third_party/socket.io-client-cpp/lib/rapidjson/travis-doxygen.sh
deleted file mode 100755
index 0e715a7..0000000
--- a/third_party/socket.io-client-cpp/lib/rapidjson/travis-doxygen.sh
+++ /dev/null
@@ -1,120 +0,0 @@
-#!/bin/bash
-# Update Doxygen documentation after push to 'master'.
-# Author: @pah
-
-set -e
-
-DOXYGEN_VER=doxygen-1.8.7
-DOXYGEN_TAR=${DOXYGEN_VER}.linux.bin.tar.gz
-DOXYGEN_URL="http://ftp.stack.nl/pub/users/dimitri/${DOXYGEN_TAR}"
-DOXYGEN_BIN="/usr/local/bin/doxygen"
-
-: ${GITHUB_REPO:="miloyip/rapidjson"}
-GITHUB_HOST="github.com"
-GITHUB_CLONE="git://${GITHUB_HOST}/${GITHUB_REPO}"
-GITHUB_URL="https://${GITHUB_HOST}/${GITHUB_PUSH-${GITHUB_REPO}}"
-
-# if not set, ignore password
-#GIT_ASKPASS="${TRAVIS_BUILD_DIR}/gh_ignore_askpass.sh"
-
-skip() {
-	echo "$@" 1>&2
-	echo "Exiting..." 1>&2
-	exit 0
-}
-
-abort() {
-	echo "Error: $@" 1>&2
-	echo "Exiting..." 1>&2
-	exit 1
-}
-
-# TRAVIS_BUILD_DIR not set, exiting
-[ -d "${TRAVIS_BUILD_DIR-/nonexistent}" ] || \
-	abort '${TRAVIS_BUILD_DIR} not set or nonexistent.'
-
-# check for pull-requests
-[ "${TRAVIS_PULL_REQUEST}" = "false" ] || \
-	skip "Not running Doxygen for pull-requests."
-
-# check for branch name
-[ "${TRAVIS_BRANCH}" = "master" ] || \
-	skip "Running Doxygen only for updates on 'master' branch (current: ${TRAVIS_BRANCH})."
-
-# check for job number
-[ "${TRAVIS_JOB_NUMBER}" = "${TRAVIS_BUILD_NUMBER}.1" ] || \
-	skip "Running Doxygen only on first job of build ${TRAVIS_BUILD_NUMBER} (current: ${TRAVIS_JOB_NUMBER})."
-
-# install doxygen binary distribution
-doxygen_install()
-{
-	wget -O - "${DOXYGEN_URL}" | \
-		tar xz -C ${TMPDIR-/tmp} ${DOXYGEN_VER}/bin/doxygen
-    export PATH="${TMPDIR-/tmp}/${DOXYGEN_VER}/bin:$PATH"
-}
-
-doxygen_run()
-{
-	cd "${TRAVIS_BUILD_DIR}";
-	doxygen ${TRAVIS_BUILD_DIR}/build/doc/Doxyfile;
-}
-
-gh_pages_prepare()
-{
-	cd "${TRAVIS_BUILD_DIR}/build/doc";
-	[ ! -d "html" ] || \
-		abort "Doxygen target directory already exists."
-	git --version
-	git clone --single-branch -b gh-pages "${GITHUB_CLONE}" html
-	cd html
-	# setup git config (with defaults)
-	git config user.name "${GIT_NAME-travis}"
-	git config user.email "${GIT_EMAIL-"travis@localhost"}"
-	# clean working dir
-	rm -f .git/index
-	git clean -df
-}
-
-gh_pages_commit() {
-	cd "${TRAVIS_BUILD_DIR}/build/doc/html";
-	git add --all;
-	git diff-index --quiet HEAD || git commit -m "Automatic doxygen build";
-}
-
-gh_setup_askpass() {
-	cat > ${GIT_ASKPASS} <<EOF
-#!/bin/bash
-echo
-exit 0
-EOF
-	chmod a+x "$GIT_ASKPASS"
-}
-
-gh_pages_push() {
-	# check for secure variables
-	[ "${TRAVIS_SECURE_ENV_VARS}" = "true" ] || \
-		skip "Secure variables not available, not updating GitHub pages."
-	# check for GitHub access token
-	[ "${GH_TOKEN+set}" = set ] || \
-		skip "GitHub access token not available, not updating GitHub pages."
-	[ "${#GH_TOKEN}" -eq 40 ] || \
-		abort "GitHub token invalid: found ${#GH_TOKEN} characters, expected 40."
-
-	cd "${TRAVIS_BUILD_DIR}/build/doc/html";
-	# setup credentials (hide in "set -x" mode)
-	git remote set-url --push origin "${GITHUB_URL}"
-	git config credential.helper 'store'
-	# ( set +x ; git config credential.username "${GH_TOKEN}" )
-	( set +x ; [ -f ${HOME}/.git-credentials ] || \
-			( echo "https://${GH_TOKEN}:@${GITHUB_HOST}" > ${HOME}/.git-credentials ; \
-			 chmod go-rw ${HOME}/.git-credentials ) )
-	# push to GitHub
-	git push origin gh-pages
-}
-
-doxygen_install
-gh_pages_prepare
-doxygen_run
-gh_pages_commit
-gh_pages_push
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/.gitattributes b/third_party/socket.io-client-cpp/lib/websocketpp/.gitattributes
deleted file mode 100644
index a9e4fc7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/.gitattributes
+++ /dev/null
@@ -1,18 +0,0 @@
-# Lineendings
-*.sln       eol=crlf
-*.vcproj    eol=crlf
-*.vcxproj*  eol=crlf
-
-# Whitespace rules
-# strict (no trailing, no tabs)
-*.cpp       whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
-*.hpp       whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
-*.c         whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
-*.h         whitespace=trailing-space,space-before-tab,tab-in-indent,cr-at-eol
-
-# normal (no trailing)
-*.sql       whitespace=trailing-space,space-before-tab,cr-at-eol
-*.txt       whitespace=trailing-space,space-before-tab,cr-at-eol
-
-# special files which must ignore whitespace
-*.patch     whitespace=-trailing-space
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/.gitignore b/third_party/socket.io-client-cpp/lib/websocketpp/.gitignore
deleted file mode 100644
index 1d0c715..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/.gitignore
+++ /dev/null
@@ -1,94 +0,0 @@
-# make .git* files visible to git
-!.gitignore
-!.gitattributes
-
-.DS_Store
-
-#vim stuff
-*~
-*.swp
-
-*.o
-*.so
-*.so.?
-*.so.?.?.?
-*.a
-*.dylib
-lib/*
-
-# CMake
-*.cmake
-*.dir
-CMakeFiles
-INSTALL.*
-ZERO_CHECK.*
-CMakeCache.txt
-install_manifest.txt
-
-# Windows/Visual Studio
-*.vcproj*
-*.sln
-*.suo
-*.ncb
-*/Debug/*
-*/*/Debug/*
-bin/Debug
-*/Release/*
-*/*/Release/*
-*/RelWithDebInfo/*
-*/*/RelWithDebInfo/*
-
-# explicitly allow this path with /debug/ in it
-!websocketpp/transport/debug/*
-
-objs_shared/
-objs_static/
-
-examples/chat_server/chat_server
-examples/echo_server/echo_server
-examples/chat_client/chat_client
-examples/echo_client/echo_client
-test/basic/tests
-libwebsocketpp.dylib.0.1.0
-
-websocketpp.xcodeproj/xcuserdata/*
-websocketpp.xcodeproj/project.xcworkspace/xcuserdata/*
-policy_based_notes.hpp
-
-examples/echo_server_tls/echo_server_tls
-
-examples/fuzzing_client/fuzzing_client
-
-examples/stress_client/stress_client
-
-examples/broadcast_server_tls/broadcast_server
-
-test/basic/perf
-
-examples/echo_server_tls/echo_server_tls
-
-examples/concurrent_server/concurrent_server
-
-examples/fuzzing_server_tls/fuzzing_server
-
-examples/wsperf/wsperf
-
-.sconsign.dblite
-
-build/
-doxygen/
-examples/wsperf/wsperf_client
-
-*.out
-
-*.log
-*.opensdf
-*.sdf
-*.vcxproj
-*.vcxproj.filters
-*.user
-install
-Makefile
-bin
-
-Testing/Temporary/CTestCostData.txt
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/.travis.yml b/third_party/socket.io-client-cpp/lib/websocketpp/.travis.yml
deleted file mode 100644
index a2aa970..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/.travis.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-language: cpp
-compiler:
-  - gcc
-before_install:
- #- sudo apt-get install libboost-chrono1.48-dev libboost-regex1.48-dev libboost-system1.48-dev libboost-thread1.48-dev libboost-test1.48-dev libboost-random1.48-dev -y
- - sudo add-apt-repository -y ppa:boost-latest/ppa && sudo apt-get update -q && sudo apt-get install -y libboost-chrono1.55-dev libboost-random1.55-dev libboost-regex1.55-dev libboost-system1.55-dev libboost-thread1.55-dev libboost-test1.55-dev
-env:
-  global:
-    - BOOST_INCLUDES=/usr/include
-    - BOOST_LIBS=/usr/lib/x86_64-linux-gnu
-script: scons -j 2 && scons test
-branches:
-  only:
-    - master
-    - develop
-notifications:
-  recipients:
-    - travis@zaphoyd.com
-  email:
-    on_success: change
-    on_failure: always
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/CMakeLists.txt
deleted file mode 100644
index 4f93e24..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/CMakeLists.txt
+++ /dev/null
@@ -1,282 +0,0 @@
-
-############ Setup project and cmake
-# Minimum cmake requirement. We should require a quite recent
-# cmake for the dependency find macros etc. to be up to date.
-cmake_minimum_required (VERSION 2.8.8)
-
-############ Paths
-
-set (WEBSOCKETPP_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
-set (WEBSOCKETPP_INCLUDE ${WEBSOCKETPP_ROOT}/websocketpp)
-set (WEBSOCKETPP_BUILD_ROOT ${CMAKE_CURRENT_BINARY_DIR})
-set (WEBSOCKETPP_BIN ${WEBSOCKETPP_BUILD_ROOT}/bin)
-set (WEBSOCKETPP_LIB ${WEBSOCKETPP_BUILD_ROOT}/lib)
-
-# CMake install step prefix. I assume linux users want the prefix to
-# be the default /usr or /usr/local so this is only adjusted on Windows.
-# This must be set prior to any call to project or it will not be read correctly.
-# - Windows: Build the INSTALL project in your solution file.
-# - Linux/OSX: make install.
-if (WIN32)
-    set (CMAKE_INSTALL_PREFIX "${WEBSOCKETPP_ROOT}/install" CACHE PATH "")
-endif ()
-
-############ Project name and version
-set (WEBSOCKETPP_MAJOR_VERSION 0)
-set (WEBSOCKETPP_MINOR_VERSION 8)
-set (WEBSOCKETPP_PATCH_VERSION 2)
-set (WEBSOCKETPP_VERSION ${WEBSOCKETPP_MAJOR_VERSION}.${WEBSOCKETPP_MINOR_VERSION}.${WEBSOCKETPP_PATCH_VERSION})
-
-if(POLICY CMP0048)
-  cmake_policy(GET CMP0048 _version_policy)
-endif()
-
-if(_version_allowed STREQUAL NEW)
-  project (websocketpp VERSION ${WEBSOCKETPP_VERSION})
-else()
-  project (websocketpp)
-endif()
-
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-set(INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")
-if (WIN32 AND NOT CYGWIN)
-  set (DEF_INSTALL_CMAKE_DIR cmake)
-else ()
-  set (DEF_INSTALL_CMAKE_DIR lib/cmake/websocketpp)
-endif ()
-set (INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
-
-# Make relative paths absolute (needed later on)
-foreach (p INCLUDE CMAKE)
-  set (var INSTALL_${p}_DIR)
-  if (NOT IS_ABSOLUTE "${${var}}")
-    set (${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
-  endif ()
-endforeach ()
-
-# Set CMake library search policy
-if (COMMAND cmake_policy)
-    cmake_policy (SET CMP0003 NEW)
-    cmake_policy (SET CMP0005 NEW)
-endif ()
-
-# Disable unnecessary build types
-set (CMAKE_CONFIGURATION_TYPES "Release;RelWithDebInfo;Debug" CACHE STRING "Configurations" FORCE)
-
-# Include our cmake macros
-set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
-include (CMakeHelpers)
-
-
-############  Build customization
-
-# Override from command line "CMake -D<OPTION>=TRUE/FALSE/0/1/ON/OFF"
-option (ENABLE_CPP11 "Build websocketpp with CPP11 features enabled." TRUE)
-option (BUILD_EXAMPLES "Build websocketpp examples." FALSE)
-option (BUILD_TESTS "Build websocketpp tests." FALSE)
-
-if (BUILD_TESTS OR BUILD_EXAMPLES)
-
-    enable_testing ()
-
-    ############ Compiler specific setup
-
-    set (WEBSOCKETPP_PLATFORM_LIBS "")
-    set (WEBSOCKETPP_PLATFORM_TLS_LIBS "")
-    set (WEBSOCKETPP_BOOST_LIBS "")
-
-    # VC9 and C++11 reasoning
-    if (ENABLE_CPP11 AND MSVC AND MSVC90)
-        message("* Detected Visual Studio 9 2008, disabling C++11 support.")
-        set (ENABLE_CPP11 FALSE)
-    endif ()
-
-    # Detect clang. Not officially reported by cmake.
-    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-v" ERROR_VARIABLE CXX_VER_STDERR)
-    if ("${CXX_VER_STDERR}" MATCHES ".*clang.*")
-        set (CMAKE_COMPILER_IS_CLANGXX 1)
-    endif ()
-
-    # C++11 defines
-    if (ENABLE_CPP11)
-        if (MSVC)
-            add_definitions (-D_WEBSOCKETPP_CPP11_FUNCTIONAL_)
-            add_definitions (-D_WEBSOCKETPP_CPP11_SYSTEM_ERROR_)
-            add_definitions (-D_WEBSOCKETPP_CPP11_RANDOM_DEVICE_)
-            add_definitions (-D_WEBSOCKETPP_CPP11_MEMORY_)
-        else()
-            add_definitions (-D_WEBSOCKETPP_CPP11_STL_)
-        endif()
-    endif ()
-
-    # Visual studio
-    if (MSVC)
-        set (WEBSOCKETPP_BOOST_LIBS system thread)
-        set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL /Gy /GF /Ox /Ob2 /Ot /Oi /MP /arch:SSE2 /fp:fast")
-        set (CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /INCREMENTAL:NO /OPT:REF /OPT:ICF")
-        add_definitions (/W3 /wd4996 /wd4995 /wd4355)
-        add_definitions (-DUNICODE -D_UNICODE)
-        add_definitions (-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS)
-        add_definitions (-DNOMINMAX)
-    endif ()
-
-    # g++
-    if (CMAKE_COMPILER_IS_GNUCXX)
-        if (NOT APPLE)
-            set (WEBSOCKETPP_PLATFORM_LIBS pthread rt)
-        else()
-            set (WEBSOCKETPP_PLATFORM_LIBS pthread)
-        endif()
-        set (WEBSOCKETPP_PLATFORM_TLS_LIBS ssl crypto)
-        set (WEBSOCKETPP_BOOST_LIBS system thread)
-        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-        if (NOT APPLE)
-            add_definitions (-DNDEBUG -Wall -Wcast-align) # todo: should we use CMAKE_C_FLAGS for these?
-        endif ()
-
-        # Try to detect version. Note: Not tested!
-        execute_process (COMMAND ${CMAKE_CXX_COMPILER} "-dumpversion" OUTPUT_VARIABLE GCC_VERSION)
-        if ("${GCC_VERSION}" STRGREATER "4.4.0")
-            message("* C++11 support partially enabled due to GCC version ${GCC_VERSION}")
-            set (WEBSOCKETPP_BOOST_LIBS system thread)
-        endif ()
-    endif ()
-
-    # clang
-    if (CMAKE_COMPILER_IS_CLANGXX)
-        if (NOT APPLE)
-            set (WEBSOCKETPP_PLATFORM_LIBS pthread rt)
-        else()
-            set (WEBSOCKETPP_PLATFORM_LIBS pthread)
-        endif()
-        set (WEBSOCKETPP_PLATFORM_TLS_LIBS ssl crypto)
-        set (WEBSOCKETPP_BOOST_LIBS system thread)
-        set (CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-std=c++0x -stdlib=libc++") # todo: is libc++ really needed here?
-        if (NOT APPLE)
-            add_definitions (-DNDEBUG -Wall -Wno-padded) # todo: should we use CMAKE_C_FLAGS for these?
-        endif ()
-    endif ()
-
-    # OSX, can override above.
-    if (APPLE)
-        add_definitions (-DNDEBUG -Wall)
-    endif ()
-
-    if (BUILD_EXAMPLES)
-        list (APPEND WEBSOCKETPP_BOOST_LIBS random)
-    endif()
-
-    if (BUILD_TESTS)
-        list (APPEND WEBSOCKETPP_BOOST_LIBS unit_test_framework)
-    endif()
-
-    ############ Dependencies
-
-    # Set BOOST_ROOT env variable or pass with cmake -DBOOST_ROOT=path.
-    # BOOST_ROOT can also be defined by a previous run from cmake cache.
-    if (NOT "$ENV{BOOST_ROOT_CPP11}" STREQUAL "")
-        # Scons documentation for BOOST_ROOT_CPP11:
-        # "look for optional second boostroot compiled with clang's libc++ STL library
-        # this prevents warnings/errors when linking code built with two different
-        # incompatible STL libraries."
-        file (TO_CMAKE_PATH "$ENV{BOOST_ROOT_CPP11}" BOOST_ROOT)
-        set (BOOST_ROOT ${BOOST_ROOT} CACHE PATH "BOOST_ROOT dependency path" FORCE)
-    endif ()
-    if ("${BOOST_ROOT}" STREQUAL "")
-        file (TO_CMAKE_PATH "$ENV{BOOST_ROOT}" BOOST_ROOT)
-        # Cache BOOST_ROOT for runs that do not define $ENV{BOOST_ROOT}.
-        set (BOOST_ROOT ${BOOST_ROOT} CACHE PATH "BOOST_ROOT dependency path" FORCE)
-    endif ()
-
-    message ("* Configuring Boost")
-    message (STATUS "-- Using BOOST_ROOT")
-    message (STATUS "       " ${BOOST_ROOT})
-
-    if (MSVC)
-        set (Boost_USE_MULTITHREADED TRUE)
-        set (Boost_USE_STATIC_LIBS TRUE)
-    else ()
-        set (Boost_USE_MULTITHREADED FALSE)
-        set (Boost_USE_STATIC_LIBS FALSE)
-    endif ()
-
-	if (BOOST_STATIC)
-		set (Boost_USE_STATIC_LIBS TRUE)
-	endif ()
-
-    if (NOT Boost_USE_STATIC_LIBS)
-        add_definitions (-DBOOST_TEST_DYN_LINK)
-    endif ()
-
-    set (Boost_FIND_REQUIRED TRUE)
-    set (Boost_FIND_QUIETLY TRUE)
-    set (Boost_DEBUG FALSE)
-    set (Boost_USE_MULTITHREADED TRUE)
-    set (Boost_ADDITIONAL_VERSIONS "1.39.0" "1.40.0" "1.41.0" "1.42.0" "1.43.0" "1.44.0" "1.46.1") # todo: someone who knows better spesify these!
-
-    find_package (Boost 1.39.0 COMPONENTS "${WEBSOCKETPP_BOOST_LIBS}")
-
-    if (Boost_FOUND)
-        # Boost is a project wide global dependency.
-        include_directories (${Boost_INCLUDE_DIRS})
-        link_directories (${Boost_LIBRARY_DIRS})
-
-        # Pretty print status
-        message (STATUS "-- Include Directories")
-        foreach (include_dir ${Boost_INCLUDE_DIRS})
-            message (STATUS "       " ${include_dir})
-        endforeach ()
-        message (STATUS "-- Library Directories")
-        foreach (library_dir ${Boost_LIBRARY_DIRS})
-            message (STATUS "       " ${library_dir})
-        endforeach ()
-        message (STATUS "-- Libraries")
-        foreach (boost_lib ${Boost_LIBRARIES})
-            message (STATUS "       " ${boost_lib})
-        endforeach ()
-        message ("")
-    else ()
-        message (FATAL_ERROR "Failed to find required dependency: boost")
-    endif ()
-
-    find_package(OpenSSL)
-    find_package(ZLIB)
-endif()
-
-############ Add projects
-
-# Add main library
-add_subdirectory (websocketpp)
-
-# Add examples
-if (BUILD_EXAMPLES)
-    include_subdirs ("examples")
-endif ()
-
-# Add tests
-if (BUILD_TESTS)
-    include_subdirs ("test")
-endif ()
-
-print_used_build_config()
-
-export (PACKAGE websocketpp)
-
-include(CMakePackageConfigHelpers)
-configure_package_config_file(websocketpp-config.cmake.in
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-config.cmake"
-  PATH_VARS INSTALL_INCLUDE_DIR
-  INSTALL_DESTINATION "${INSTALL_CMAKE_DIR}"
-  NO_CHECK_REQUIRED_COMPONENTS_MACRO
-)
-write_basic_package_version_file("${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-configVersion.cmake"
-  VERSION ${WEBSOCKETPP_VERSION}
-  COMPATIBILITY ExactVersion)
-
-# Install the websocketpp-config.cmake and websocketpp-configVersion.cmake
-install (FILES
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-config.cmake"
-  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-configVersion.cmake"
-  DESTINATION "${INSTALL_CMAKE_DIR}" COMPONENT dev)
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/COPYING b/third_party/socket.io-client-cpp/lib/websocketpp/COPYING
deleted file mode 100644
index f8cc5ba..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/COPYING
+++ /dev/null
@@ -1,145 +0,0 @@
-Main Library:
-
-Copyright (c) 2014, Peter Thorson. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the WebSocket++ Project nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Bundled Libraries:
-
-****** Base 64 Library (base64/base64.hpp) ******
-base64.hpp is a repackaging of the base64.cpp and base64.h files into a
-single header suitable for use as a header only library. This conversion was
-done by Peter Thorson (webmaster@zaphoyd.com) in 2012. All modifications to
-the code are redistributed under the same license as the original, which is
-listed below.
-
-base64.cpp and base64.h
-
-Copyright (C) 2004-2008 René Nyffenegger
-
-This source code is provided 'as-is', without any express or implied
-warranty. In no event will the author be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this source code must not be misrepresented; you must not
-  claim that you wrote the original source code. If you use this source code
-  in a product, an acknowledgment in the product documentation would be
-  appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-  misrepresented as being the original source code.
-
-3. This notice may not be removed or altered from any source distribution.
-
-René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-****** SHA1 Library (sha1/sha1.hpp) ******
-sha1.hpp is a repackaging of the sha1.cpp and sha1.h files from the shallsha1
-library (http://code.google.com/p/smallsha1/) into a single header suitable for
-use as a header only library. This conversion was done by Peter Thorson
-(webmaster@zaphoyd.com) in 2013. All modifications to the code are redistributed
-under the same license as the original, which is listed below.
-
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Micael Hildenborg nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-****** MD5 Library (common/md5.hpp) ******
-md5.hpp is a reformulation of the md5.h and md5.c code from
-http://www.opensource.apple.com/source/cups/cups-59/cups/md5.c to allow it to
-function as a component of a header only library. This conversion was done by
-Peter Thorson (webmaster@zaphoyd.com) in 2012 for the WebSocket++ project. The
-changes are released under the same license as the original (listed below)
-
-Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
-
-This software is provided 'as-is', without any express or implied
-warranty.  In no event will the authors be held liable for any damages
-arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose,
-including commercial applications, and to alter it and redistribute it
-freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-
-L. Peter Deutsch
-ghost@aladdin.com
-
-****** UTF8 Validation logic (utf8_validation.hpp) ******
-utf8_validation.hpp is adapted from code originally written by Bjoern Hoehrmann
-<bjoern@hoehrmann.de>. See http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for
-details.
-
-The original license:
-
-Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/Doxyfile b/third_party/socket.io-client-cpp/lib/websocketpp/Doxyfile
deleted file mode 100644
index 20b695c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/Doxyfile
+++ /dev/null
@@ -1,2355 +0,0 @@
-# Doxyfile 1.8.8
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = WebSocket++
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         = 0.8.2
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          = "C++ websocket client/server library"
-
-# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
-# the documentation. The maximum height of the logo should not exceed 55 pixels
-# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
-# to the output directory.
-
-PROJECT_LOGO           = 
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = doxygen
-
-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = 
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = YES
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        = 
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    = 
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
-# new page for each member. If set to NO, the documentation of a member will be
-# part of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
-
-ALIASES                = 
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              = 
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
-#
-# Note For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
-
-EXTENSION_MAPPING      = 
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by by putting a % sign in front of the word
-# or globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = YES
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = NO
-
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. When set to YES local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO these classes will be included in the various overviews. This option has
-# no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO these declarations will be
-# included in the documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = NO
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
-# todo list. This list is created by putting \todo commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
-# test list. This list is created by putting \test commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       = 
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES the list
-# will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    = 
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            = 
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. See also \cite for info how to create references.
-
-CITE_BIB_FILES         = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO doxygen will only warn about wrong or incomplete parameter
-# documentation, but not about the absence of documentation.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces.
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = readme.md \
-                         changelog.md \
-                         roadmap.md \
-                         websocketpp \
-                         tutorials \
-                         docs
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank the
-# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
-# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
-# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
-# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
-# *.qsf, *.as and *.js.
-
-FILE_PATTERNS          = 
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                = build
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       = 
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        = 
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           = 
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = 
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             = 
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-
-INPUT_FILTER           = 
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-
-FILTER_PATTERNS        = 
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER ) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS = 
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = YES
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = YES
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# compiled with the --with-libclang option.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = YES
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            = 
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            = 
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        = 
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# cascading style sheets that are included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
-# Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra stylesheet files is of importance (e.g. the last
-# stylesheet in the list overrules the setting of the previous ones in the
-# list). For an example see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  = docs/manual.css
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       = 
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the stylesheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 236
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 0
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 148
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = NO
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               = 
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler ( hhc.exe). If non-empty
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           = 
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated (
-# YES) or that it should be included in the master .chm file ( NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     = 
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated (
-# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               = 
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   = 
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  = 
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  = 
-
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           = 
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = NO
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
-# instead of using prerendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     = 
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       = 
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = YES
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       = 
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     = 
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = YES
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         = latex
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. To get the times font for
-# instance you can specify
-# EXTRA_PACKAGES=times
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         = 
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
-# for the replacement values of the other commands the user is refered to
-# HTML_HEADER.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           = 
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
-# LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           = 
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      = 
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES to get a
-# higher quality PDF documentation.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    = 
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             = 
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
-# Definitions (see http://autogen.sf.net) file that captures the structure of
-# the code including all documentation. Note that this feature is still
-# experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
-# in the source code. If set to NO only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = NO
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = NO
-
-# If the SEARCH_INCLUDES tag is set to YES the includes files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           = 
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  = 
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             = 
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      = 
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               = 
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       = 
-
-# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
-# class index. If set to NO only the inherited external classes will be listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
-# the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            = 
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               = 
-
-# If set to YES, the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: NO.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           = 
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot.
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, jpg, gif and svg.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               = 
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           = 
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           = 
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           = 
-
-# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-PLANTUML_JAR_PATH      = 
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
-# files that are used to generate the various graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_CLEANUP            = YES
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/SConstruct b/third_party/socket.io-client-cpp/lib/websocketpp/SConstruct
deleted file mode 100644
index ae3df10..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/SConstruct
+++ /dev/null
@@ -1,285 +0,0 @@
-import os, sys, commands
-env = Environment(ENV = os.environ)
-
-# figure out a better way to configure this
-if os.environ.has_key('CXX'):
-    env['CXX'] = os.environ['CXX']
-
-if os.environ.has_key('DEBUG'):
-    env['DEBUG'] = os.environ['DEBUG']
-
-if os.environ.has_key('CXXFLAGS'):
-    #env['CXXFLAGS'] = os.environ['CXXFLAGS']
-    env.Append(CXXFLAGS = os.environ['CXXFLAGS'])
-
-if os.environ.has_key('LINKFLAGS'):
-    #env['LDFLAGS'] = os.environ['LDFLAGS']
-    env.Append(LINKFLAGS = os.environ['LINKFLAGS'])
-
-## Boost
-##
-## Note: You need to either set BOOSTROOT to the root of a stock Boost distribution
-## or set BOOST_INCLUDES and BOOST_LIBS if Boost comes with your OS distro e.g. and
-## needs BOOST_INCLUDES=/usr/include/boost and BOOST_LIBS=/usr/lib like Ubuntu.
-##
-if os.environ.has_key('BOOSTROOT'):
-    os.environ['BOOST_ROOT'] = os.environ['BOOSTROOT']
-
-if os.environ.has_key('BOOST_ROOT'):
-   env['BOOST_INCLUDES'] = os.environ['BOOST_ROOT']
-   env['BOOST_LIBS'] = os.path.join(os.environ['BOOST_ROOT'], 'stage', 'lib')
-elif os.environ.has_key('BOOST_INCLUDES') and os.environ.has_key('BOOST_LIBS'):
-   env['BOOST_INCLUDES'] = os.environ['BOOST_INCLUDES']
-   env['BOOST_LIBS'] = os.environ['BOOST_LIBS']
-else:
-   raise SCons.Errors.UserError, "Neither BOOST_ROOT, nor BOOST_INCLUDES + BOOST_LIBS was set!"
-
-## Custom OpenSSL
-if os.environ.has_key('OPENSSL_PATH'):
-   env.Append(CPPPATH = os.path.join(os.environ['OPENSSL_PATH'], 'include'))
-   env.Append(LIBPATH = os.environ['OPENSSL_PATH'])
-
-if os.environ.has_key('WSPP_ENABLE_CPP11'):
-   env['WSPP_ENABLE_CPP11'] = True
-else:
-   env['WSPP_ENABLE_CPP11'] = False
-
-boost_linkshared = False
-
-def boostlibs(libnames,localenv):
-   if localenv['PLATFORM'].startswith('win'):
-      # Win/VC++ supports autolinking. nothing to do.
-      # http://www.boost.org/doc/libs/1_49_0/more/getting_started/windows.html#auto-linking
-      return []
-   else:
-      libs = []
-      prefix = localenv['SHLIBPREFIX'] if boost_linkshared else localenv['LIBPREFIX']
-      suffix = localenv['SHLIBSUFFIX'] if boost_linkshared else localenv['LIBSUFFIX']
-      for name in libnames:
-         lib = File(os.path.join(localenv['BOOST_LIBS'], '%sboost_%s%s' % (prefix, name, suffix)))
-         libs.append(lib)
-      return libs
-
-if env['PLATFORM'].startswith('win'):
-   env.Append(CPPDEFINES = ['WIN32',
-                            'NDEBUG',
-                            'WIN32_LEAN_AND_MEAN',
-                            '_WIN32_WINNT=0x0600',
-                            '_CONSOLE',
-                            'BOOST_TEST_DYN_LINK',
-                            'NOMINMAX',
-                            '_WEBSOCKETPP_CPP11_MEMORY_',
-                            '_WEBSOCKETPP_CPP11_FUNCTIONAL_'])
-   arch_flags  = '/arch:SSE2'
-   opt_flags   = '/Ox /Oi /fp:fast'
-   warn_flags  = '/W3 /wd4996 /wd4995 /wd4355'
-   env['CCFLAGS'] = '%s /EHsc /GR /GS- /MD /nologo %s %s' % (warn_flags, arch_flags, opt_flags)
-   env['LINKFLAGS'] = '/INCREMENTAL:NO /MANIFEST /NOLOGO /OPT:REF /OPT:ICF /MACHINE:X86'
-elif env['PLATFORM'] == 'posix':
-   if env.has_key('DEBUG'):
-      env.Append(CCFLAGS = ['-g', '-O0'])
-   else:
-      env.Append(CPPDEFINES = ['NDEBUG'])
-      env.Append(CCFLAGS = ['-O1', '-fomit-frame-pointer'])
-   env.Append(CCFLAGS = ['-Wall'])
-   #env['LINKFLAGS'] = ''
-elif env['PLATFORM'] == 'darwin':
-   if not os.environ.has_key('CXX'):
-      env['CXX'] = "clang++"
-   if env.has_key('DEBUG'):
-      env.Append(CCFLAGS = ['-g', '-O0'])
-   else:
-      env.Append(CPPDEFINES = ['NDEBUG'])
-      env.Append(CCFLAGS = ['-O1', '-fomit-frame-pointer'])
-   env.Append(CCFLAGS = ['-Wall'])
-   #env['LINKFLAGS'] = ''
-
-if env['PLATFORM'].startswith('win'):
-   #env['LIBPATH'] = env['BOOST_LIBS']
-   pass
-else:
-   env.Append(LIBPATH = ['/usr/lib', '/usr/local/lib'])
-
-# Compiler specific warning flags
-if env['CXX'].startswith('g++'):
-   #env.Append(CCFLAGS = ['-Wconversion'])
-   env.Append(CCFLAGS = ['-Wcast-align'])
-   env.Append(CCFLAGS = ['-Wshadow'])
-   env.Append(CCFLAGS = ['-Wunused-parameter'])
-elif env['CXX'].startswith('clang++'):
-   #env.Append(CCFLAGS = ['-Wcast-align'])
-   #env.Append(CCFLAGS = ['-Wglobal-constructors'])
-   #env.Append(CCFLAGS = ['-Wconversion'])
-   env.Append(CCFLAGS = ['-Wno-padded'])
-   env.Append(CCFLAGS = ['-Wshadow'])
-   env.Append(CCFLAGS = ['-Wunused-parameter'])
-
-   env.Append(CCFLAGS = ['-Wsometimes-uninitialized'])
-   env.Append(CCFLAGS = ['-Wuninitialized'])
-
-   #env.Append(CCFLAGS = ['-Weverything'])
-   #env.Append(CCFLAGS = ['-Wno-documentation'])
-   #env.Append(CCFLAGS = ['-Wno-weak-vtables'])
-   #env.Append(CCFLAGS = ['-Wno-global-constructors'])
-   #env.Append(CCFLAGS = ['-Wno-sign-conversion'])
-   #env.Append(CCFLAGS = ['-Wno-exit-time-destructors'])
-
-
-
-
-   # Wpadded
-   # Wsign-conversion
-   #
-
-platform_libs = []
-tls_libs = []
-
-tls_build = False
-
-if env['PLATFORM'] == 'posix':
-   platform_libs = ['pthread', 'rt']
-   tls_libs = ['ssl', 'crypto']
-   tls_build = True
-elif env['PLATFORM'] == 'darwin':
-   tls_libs = ['ssl', 'crypto']
-   tls_build = True
-elif env['PLATFORM'].startswith('win'):
-   # Win/VC++ supports autolinking. nothing to do.
-   pass
-
-## Append WebSocket++ path
-env.Append(CPPPATH = ['#'])
-
-##### Set up C++11 environment
-polyfill_libs = [] # boost libraries used as drop in replacements for incomplete
-                   # C++11 STL implementations
-env_cpp11 = env.Clone ()
-
-if env_cpp11['CXX'].startswith('g++'):
-   # TODO: check g++ version
-   GCC_VERSION = commands.getoutput(env_cpp11['CXX'] + ' -dumpversion')
-
-   if GCC_VERSION > "4.4.0":
-      print "C++11 build environment partially enabled"
-      env_cpp11.Append(WSPP_CPP11_ENABLED = "true",CXXFLAGS = ['-std=c++0x'],TOOLSET = ['g++'],CPPDEFINES = ['_WEBSOCKETPP_CPP11_STL_'])
-   else:
-      print "C++11 build environment is not supported on this version of G++"
-elif env_cpp11['CXX'].startswith('clang++'):
-   print "C++11 build environment enabled"
-   env.Append(CXXFLANGS = ['-stdlib=libc++'],LINKFLAGS=['-stdlib=libc++'])
-   env_cpp11.Append(WSPP_CPP11_ENABLED = "true",CXXFLAGS = ['-std=c++0x','-stdlib=libc++'],LINKFLAGS = ['-stdlib=libc++'],TOOLSET = ['clang++'],CPPDEFINES = ['_WEBSOCKETPP_CPP11_STL_'])
-
-   # look for optional second boostroot compiled with clang's libc++ STL library
-   # this prevents warnings/errors when linking code built with two different
-   # incompatible STL libraries.
-   if os.environ.has_key('BOOST_ROOT_CPP11'):
-      env_cpp11['BOOST_INCLUDES'] = os.environ['BOOST_ROOT_CPP11']
-      env_cpp11['BOOST_LIBS'] = os.path.join(os.environ['BOOST_ROOT_CPP11'], 'stage', 'lib')
-   elif os.environ.has_key('BOOST_INCLUDES_CPP11') and os.environ.has_key('BOOST_LIBS_CPP11'):
-      env_cpp11['BOOST_INCLUDES'] = os.environ['BOOST_INCLUDES_CPP11']
-      env_cpp11['BOOST_LIBS'] = os.environ['BOOST_LIBS_CPP11']
-else:
-   print "C++11 build environment disabled"
-
-# if the build system is known to allow the isystem modifier for library include
-# values then use it for the boost libraries. Otherwise just add them to the
-# regular CPPPATH values.
-if env['CXX'].startswith('g++') or env['CXX'].startswith('clang'):
-    env.Append(CPPFLAGS = '-isystem ' + env['BOOST_INCLUDES'])
-else:
-    env.Append(CPPPATH = [env['BOOST_INCLUDES']])
-env.Append(LIBPATH = [env['BOOST_LIBS']])
-
-# if the build system is known to allow the isystem modifier for library include
-# values then use it for the boost libraries. Otherwise just add them to the
-# regular CPPPATH values.
-if env_cpp11['CXX'].startswith('g++') or env_cpp11['CXX'].startswith('clang'):
-    env_cpp11.Append(CPPFLAGS = '-isystem ' + env_cpp11['BOOST_INCLUDES'])
-else:
-    env_cpp11.Append(CPPPATH = [env_cpp11['BOOST_INCLUDES']])
-env_cpp11.Append(LIBPATH = [env_cpp11['BOOST_LIBS']])
-
-releasedir = 'build/release/'
-debugdir = 'build/debug/'
-testdir = 'build/test/'
-builddir = releasedir
-
-Export('env')
-Export('env_cpp11')
-Export('platform_libs')
-Export('boostlibs')
-Export('tls_libs')
-Export('polyfill_libs')
-
-## END OF CONFIG !!
-
-## TARGETS:
-
-if not env['PLATFORM'].startswith('win'):
-    # Unit tests, add test folders with SConscript files to to_test list.
-    to_test = ['utility','http','logger','random','processors','message_buffer','extension','transport/iostream','transport/asio','roles','endpoint','connection','transport'] #,'http','processors','connection'
-
-    for t in to_test:
-       new_tests = SConscript('#/test/'+t+'/SConscript',variant_dir = testdir + t, duplicate = 0)
-       for a in new_tests:
-          new_alias = Alias('test', [a], a.abspath)
-          AlwaysBuild(new_alias)
-
-# Main test application
-#main = SConscript('#/examples/dev/SConscript',variant_dir = builddir + 'dev',duplicate = 0)
-
-# echo_server
-echo_server = SConscript('#/examples/echo_server/SConscript',variant_dir = builddir + 'echo_server',duplicate = 0)
-
-# echo_client
-echo_client = SConscript('#/examples/echo_client/SConscript',variant_dir = builddir + 'echo_client',duplicate = 0)
-
-# print_client
-print_client = SConscript('#/examples/print_client/SConscript',variant_dir = builddir + 'print_client',duplicate = 0)
-
-# echo_server_tls
-if tls_build:
-    echo_server_tls = SConscript('#/examples/echo_server_tls/SConscript',variant_dir = builddir + 'echo_server_tls',duplicate = 0)
-    echo_server_both = SConscript('#/examples/echo_server_both/SConscript',variant_dir = builddir + 'echo_server_both',duplicate = 0)
-    print_client_tls = SConscript('#/examples/print_client_tls/SConscript',variant_dir = builddir + 'print_client_tls',duplicate = 0)
-
-# broadcast_server
-broadcast_server = SConscript('#/examples/broadcast_server/SConscript',variant_dir = builddir + 'broadcast_server',duplicate = 0)
-
-# testee_server
-testee_server = SConscript('#/examples/testee_server/SConscript',variant_dir = builddir + 'testee_server',duplicate = 0)
-
-# testee_client
-testee_client = SConscript('#/examples/testee_client/SConscript',variant_dir = builddir + 'testee_client',duplicate = 0)
-
-# scratch_client
-scratch_client = SConscript('#/examples/scratch_client/SConscript',variant_dir = builddir + 'scratch_client',duplicate = 0)
-
-# scratch_server
-scratch_server = SConscript('#/examples/scratch_server/SConscript',variant_dir = builddir + 'scratch_server',duplicate = 0)
-
-
-# debug_client
-debug_client = SConscript('#/examples/debug_client/SConscript',variant_dir = builddir + 'debug_client',duplicate = 0)
-
-# debug_server
-debug_server = SConscript('#/examples/debug_server/SConscript',variant_dir = builddir + 'debug_server',duplicate = 0)
-
-# subprotocol_server
-subprotocol_server = SConscript('#/examples/subprotocol_server/SConscript',variant_dir = builddir + 'subprotocol_server',duplicate = 0)
-
-# telemetry_server
-telemetry_server = SConscript('#/examples/telemetry_server/SConscript',variant_dir = builddir + 'telemetry_server',duplicate = 0)
-
-# external_io_service
-external_io_service = SConscript('#/examples/external_io_service/SConscript',variant_dir = builddir + 'external_io_service',duplicate = 0)
-
-if not env['PLATFORM'].startswith('win'):
-    # iostream_server
-    iostream_server = SConscript('#/examples/iostream_server/SConscript',variant_dir = builddir + 'iostream_server',duplicate = 0)
-
-    # telemetry_client
-    telemetry_client = SConscript('#/examples/telemetry_client/SConscript',variant_dir = builddir + 'telemetry_client',duplicate = 0)
-
-    # print_server
-    print_server = SConscript('#/examples/print_server/SConscript',variant_dir = builddir + 'print_server',duplicate = 0)
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/changelog.md b/third_party/socket.io-client-cpp/lib/websocketpp/changelog.md
deleted file mode 100644
index 3488a19..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/changelog.md
+++ /dev/null
@@ -1,444 +0,0 @@
-HEAD
-
-0.8.2 - 2020-04-19
-- Examples: Update print_client_tls example to remove use of deprecated
-  OpenSSL functions.
-- Compatibility: Removes the use of make_shared in a number of cases where
-  it would be incompatible with newer versions of ASIO. Thank you Stefan
-  Floeren for the patch. #810 #814 #862 #843 #794 #808
-- CMake: Update cmake installer to better handle dependencies when using
-  g++ on MacOS. Thank you Luca Palano for reporting and a patch. #831
-- CMake: Update cmake installer to use a variable for the include directory
-  improving the ability of the install to be customized. THank you Schrijvers
-  Luc and Gianfranco Costamanga for reporting and a patch. #842
-
-0.8.1 - 2018-07-16
-Note: This release does not change library behavior. It only corrects issues
-in the installer and test system.
-- Test Suite: Adjust test suite to match behavior introduced in 0.8.0. Thank
-  you Gianfranco Costamagna for reporting and a patch. #731
-- CMake: Update cmake installer to only install library files globally.
-  Thank you Gianfraco Costamanga for reporting and a patch. #732
-
-0.8.0 - 2018-07-12
-- Examples: Add `print_client` example. This demonstrates a minimal non-TLS
-  client that connects to a server and prints out the messages it receives.
-- Examples: Add `print_client_tls` example. This demonstrates a minimal TLS
-  client, including basic support via Asio+OpenSSL for certificate chain
-  and hostname verification.
-- Feature: Add getter for all headers to the HTTP parsers. This allows a
-  wrapping library to enumerate all headers to send upstream. Thank you Jupp
-  Müller for reporting and an initial pull request.
-- Improvement: Move the `socket_init_handler` to execute as a part of `init_asio`
-  rather than connection `pre_init`. This allows setting of socket options prior
-  to the bind/listen/accept system calls. Thank you ChristianRobl3D for
-  reporting #530.
-- Improvement: Timers in transport integration tests should only fail if their
-  own test times out, rather than any test. #643 Thank you Alex Korotkin for
-  reporting and a patch.
-- Improvement: Preserve transport layer error codes in more cases, particularly
-  during calls to `endpoint::listen`. #652 Thank you vadz for reporting and
-  patches.
-- Compatibility: Make sure the chrono library used by Boost/Asio is in sync
-  with what the websocketpp is using. Thank you Flow86 for reporting and a
-  patch.
-- Compatibility: Update `telemetry_client` to use a slightly more cross platform
-  method of sleeping. Should work on windows now. Thank you Meir Yanovich for
-  reporting.
-- Compatibility: Updated permessage-deflate support to reflect that the zlib
-  library does not actually support a sliding window size of 256 bits. 
-  WebSocket++ will no longer negotiate 256 bit deflate windows. If the user
-  of the library tries to request a 256 bit window a 512 bit window will be
-  specified instead (This was the previous behavior). #596 #653 Thank you 
-  Vinnie Falco and Gianfranco Costamagna for reporting.
-- Compatibility: Better error handling and logging in cases where extension
-  requests parse correctly but negotiation fails.
-- Compatibility: Removed custom handling of `SSL_R_SHORT_READ` error condition.
-  This error code no longer exists in modern versions of OpenSSL and causes
-  a build error. It wasn't being used for anything particularly important
-  (slightly improving error reporting) and there isn't a great replacement.
-  #599 Thank you Gianfranco Costamagna for reporting.
-- Compatibility: Add missing `<stdint>` headers. Fixes issues with g++ 5.4.0.
-  #638 Thank you Alex Korotkin for reporting and a patch.
-- Compatibility: Remove the use of `std::auto_ptr` and `std::binary_function`
-  from builds with C++11 or later. These features are deprecated and were
-  removed entirely in C++17. This change allows building WebSocket++ on
-  C++17 compilers. #592 Thank you Michal Fojtak for reporting and a patch
-- Compatibility: Add 1014 close code and adds missing descriptions for codes
-  1012 and 1013. #589 Thank you jbwdevries and ronneke1996 for reporting and
-  patches.
-- Compatibility: Add hooks to support `mingw-std-threads` C++11 thread and mutex
-  polyfill library as an alternative to Boost. #608 Thank you Peter Taylor for
-  reporting and an initial patch.
-- Compatibility: Changed the handshake connection token to 'Upgrade' from
-  'upgrade'. Technically this header is supposed to be processed case
-  insensitively. In practice, there are browsers (such as Edge) that don't do
-  this and they tend to use the uppercase value used as an example in RFC6455.
-  Thank you Johann Bauer for reporting and a patch. #727
-- Bug: Store loggers in shared pointers to avoid crashes related to connections
-  trying to write logs entries after their respective endpoint has been
-  deallocated. Thank you Thalhammer for reporting and Jupp Müller for the 
-  patch. #539 #501
-- Bug: Change default listen backlog from 0 to `socket_base::max_connections`.
-  #549. Thank you derwassi and zwelab for reporting and na1pir for providing
-  access to hardware to debug the issue.
-- Bug: Fix a crash in the accept loop when `get_connection` fails. #551 Thank you
-  Walter Gray for a patch.
-- Bug/Documentation: Fix incorrect example code that used 
-  `websocketpp::lib::error_code` instead of `websocketpp::exception`. Thank you
-  heretic13 for reporting
-- Bug: Fix uninitialized shared pointer in Asio transport test suite. #647
-  Thank you Alex Korotkin for reporting and a patch.
-- Bug: Fix a thread safety issue in the permessage-deflate extension that
-  caused message corruption when sending compressed messages from a different
-  thread than the main I/O thread. #615 Thank you KyleNyenhuis and Pieter De 
-  Gendt for reporting and a patch.
-- Bug: Fix an undefined behavior issue performing a 64 bit wide shift on a 64
-  bit value. #636 Thank you Gregor Jasny for reporting and a patch
-- Bug: Fix some compile issues with ASIO_STANDALONE. #662 #665 Thank you
-  chronoxor and Guillaume Egles for reporting and patches.
-
-0.7.0 - 2016-02-22
-- MINOR BREAKING SOCKET POLICY CHANGE: Asio transport socket policy method 
-  `cancel_socket` will now return `lib::asio::error_code` instead of `void`.
-  Custom Asio transport socket policies will need to be updated accordingly.
-  This does not affect anyone using the bundled socket policies.
-- Feature: Basic support for the permessage-deflate extension. #344
-- Feature: Allow accessing the local endpoint when using the Asio transport.
-  This allows inspection of the address and port in cases where they are chosen
-  by the operating system rather than the user. Thank you Andreas Weis and 
-  Muzahid Hussain for reporting and related code. #458
-- Feature: Add support for subprotocols in Hybi00. Thank you Lukas Obermann
-  for reporting and a patch. #518
-- Feature: Adds `tcp_pre_bind handler` to Asio transport. This allows setting
-  arbitrary socket options after the listen acceptor has been created but before
-  the socket bind has been performed. #634 #439 Thank you Gregor Jasny for
-  the patch.
-- Improvement: Better automatic std::chrono feature detection for Visual Studio
-- Improvement: Major refactoring to bundled CMake build system. CMake can now be
-  used to build all of the examples and the test suite. Thank you Thijs Wenker
-  for a significant portion of this code. #378, #435, #449
-- Improvement: In build environments where `lib::error_code` and 
-  `lib::asio::error_code` match (such as using `boost::asio` with 
-  `boost::system_error` or standalone asio with `std::system_error`, transport
-  errors are passed through natively rather than being reported as a translated 
-  `pass_through` error type.
-- Improvement: Add a `get_transport_error` method to Asio transport connections
-  to allow retrieving a machine readable native transport error.
-- Improvement: Add `connection::get_response`, `connection::get_response_code`,
-  and `connection::get_response_msg` methods to allow accessing additional
-  information about the HTTP responses that WebSocket++ sends. #465 Thank you
-  Flow86 for reporting.
-- Improvement: Removes use of empty strings ("") in favor of `string::clear()`
-  and `string::empty()`. This avoids generating unnecessary temporary objects.
-  #468 Thank you Vladislav Yaroslavlev for reporting and a patch.
-- Documentation: Adds an example demonstrating the use of external `io_service`
-- Documentation: Adds a simple `echo_client` example.
-- Documentation: Begins migration of the web based user manual into Doxygen.
-- Bug: Fix memory leak when `init_asio` produces an error. #454 Thank you Mark 
-  Grimes for reporting and fixing.
-- Bug: Fix crash when processing a specially crafted HTTP header. Thank you Eli 
-  Fidler for reporting, test cases, and a patch. #456
-- Bug: Fix an issue where standalone Asio builds that use TLS would not compile
-  due to lingering boost code. #448 Thank you mjsp for reporting
-- Bug: Fix an issue where canceling a socket could throw an exception on some
-  older Windows XP platforms. It now prints an appropriate set of log messages
-  instead. Thank you Thijs Wenker for reporting and researching solutions. #460
-- Bug: Fix an issue where deferred HTTP connections that start sending a very 
-  long response before their HTTP handler ends would result in a second set of
-  HTTP headers being injected into the output. Thank you Kevin Smith for
-  reporting and providing test case details. #443
-- Bug: Fix an issue where the wrong type of strand was being created. Thank you 
-  Bastien Brunnenstein for reporting and a patch. #462
-- Bug: Fix an issue where TLS includes were broken for Asio Standalone builds.
-  Thank you giachi and Bastien Brunnenstein for reporting. #491
-- Bug: Remove the use of cached read and write handlers in the Asio transport.
-  This feature caused memory leaks when the `io_service` the connection was
-  running on was abruptly stopped. There isn't a clean and safe way of using
-  this optimization without global state and the associated locks. The locks
-  perform worse. Thank you Xavier Gibert for reporting, test cases, and code.
-  Fixes #490.
-- Bug: Fix a heap buffer overflow when checking very short URIs. Thank you 
-  Xavier Gibert for reporting and a patch #524
-- Compatibility: Fixes a number of build & config issues on Visual Studio 2015
-- Compatibility: Removes non-standards compliant masking behavior. #395, #469
-- Compatibility: Replace deprecated use of `auto_ptr` on systems where 
-  `unique_ptr` is available.
-
-0.6.0 - 2015-06-02
-- MINOR BREAKING TRANSPORT POLICY CHANGE: Custom transport policies will now be
-  required to include a new method `void set_uri(uri_ptr u)`. An implementation
-  is not required. The stub transport policy includes an example stub method
-  that can be added to any existing custom transport policy to fulfill this
-  requirement. This does not affect anyone using the bundled transports or
-  configs.
-- MINOR BREAKING SOCKET POLICY CHANGE: Custom asio transport socket policies 
-  will now be required to include a new method `void set_uri(uri_ptr u)`. Like
-  with the transport layer, an implementation is not required. This does not 
-  affect anyone using the bundled socket policies.
-- MINOR BREAKING DEPENDENCY CHANGE: When using Boost versions greater than or 
-  equal to 1.49 in C++03 mode, `libboost-chrono` is needed now instead of 
-  `libboost-date_time`. Users with C++11 compilers or using Boost versions 1.48
-  and earlier are not affected. Note: This change affects the bundled unit test
-  suite.
-- Feature: WebSocket++ Asio transport policy can now be used with the standalone
-  version of Asio (1.8.0+) when a C++11 compiler and standard library are 
-  present. This means that it is possible now to use WebSocket++'s Asio
-  transport entirely without Boost. Thank you Robert Seiler for proof of concept
-  code that was used as a guide for this implementation. Fixes #324 
-- Feature: Adds a vectored/scatter-gather write handler to the iostream
-  transport.
-- Feature: Adds the ability to defer sending an HTTP response until sometime
-  after the `http_handler` is run. This allows processing of long running http
-  handlers to defer their response until it is ready without blocking the
-  network thread. references #425
-- Improvement: `echo_server_tls` has been update to demonstrate how to configure
-  it for Mozilla's recommended intermediate and modern TLS security profiles.
-- Improvement: `endpoint::set_timer` now uses a steady clock provided by 
-  `boost::chrono` or `std::chrono` where available instead of the non-monotonic
-  system clock. Thank you breyed for reporting. fixes #241
-- Improvement: Outgoing TLS connections to servers using the SNI extension to
-  choose a certificate will now work. Thank you moozzyk for reporting. 
-  Fixes #400
-- Improvement: Removes an unnecessary mutex lock in `get_con_from_hdl`.
-- Cleanup: Asio transport policy has been refactored to remove many Boost
-  dependencies. On C++03 compilers the `boost::noncopyable` dependency has been
-  removed and the `boost::date_time` dependency has been replaced with the newer
-  `boost::chrono` when possible. On C++11 compilers the `boost::aligned_storage`
-  and `boost::date_time` dependencies are gone, replaced with equivalent C++11
-  standard library features.
-- Bug: Fixes a potential dangling pointer and inconsistent error message
-  handling in `websocketpp::exception`. #432 Thank you Tom Swirly for the fix.
-
-0.5.1 - 2015-02-27
-- Bug: Fixes an issue where some frame data was counted against the max header
-  size limit, resulting in connections that included a lot of frame data
-  immediately after the opening handshake to fail.
-- Bug: Fix a typo in the name of the set method for `max_http_body_size`. #406
-  Thank you jplatte for reporting.
-
-0.5.0 - 2015-01-22
-- BREAKING UTILITY CHANGE: Deprecated methods `http::parser::parse_headers`,
-  `http::response::parse_complete`, and `http::request::parse_complete` have
-  been removed.
-- Security: Disabled SSLv3 in example servers.
-- Feature: Adds basic support for accessing HTTP request bodies in the http
-  handler. #181
-- Feature: Adds the ability to register a shutdown handler when using the
-  iostream transport. This provides a clean interface for triggering the shut
-  down of external sockets and other cleanup without hooking in to higher level
-  WebSocket handlers.
-- Feature: Adds the ability to register a write handler when using the iostream
-  transport. This handler can be used to handle transport output in place of
-  registering an ostream to write to.
-- Feature: Adds a new logging policy that outputs to syslog. #386 Thank you Tom
-  Hughes for submitting the initial version of this policy.
-- Improvement: Message payload logging now prints text for text messages rather
-  than binary.
-- Improvement: Overhaul of handshake state machine. Should make it impossible
-  for exceptions to bubble out of transport methods like `io_service::run`.
-- Improvement: Overhaul of handshake error reporting. Fail handler error codes
-  will be more detailed and precise. Adds new [fail] and [http] logging channels
-  that log failed websocket connections and successful HTTP connections
-  respectively. A new aggregate channel package, `alevel::access_core`, allows
-  enabling connect, disconnect, fail, and http together. Successful HTTP
-  connections will no longer trigger a fail handler.
-- Improvement: Ability to terminate connection during an http handler to cleanly
-  suppress the default outgoing HTTP response.
-- Documentation: Add Sending & Receiving Messages step to chapter one of the
-  `utility_client` tutorial. Update `utility_client` example to match.
-- Cleanup: Removes unused files & STL includes. Adds required STL includes.
-  Normalizes include order.
-- Bug: Fixes a fatal state error when a handshake response is completed
-  immediately after that handshake times out. #389
-- Bug: MinGW fixes; C++11 feature detection, localtime use. #393 Thank you
-  Schebb for reporting, code, and testing.
-- Bug: Fixes an issue where `websocketpp::exception::what()` could return an out
-  of scope pointer. #397 Thank you fabioang for reporting.
-- Bug: Fixes an issue where endpoints were not reset properly after a call to
-  `endpoint::listen` failed. #390 Thank you wyyqyl for reporting.
-
-0.4.0 - 2014-11-04
-- BREAKING API CHANGE: All WebSocket++ methods now throw an exception of type
-  `websocketpp::exception` which derives from `std::exception`. This normalizes
-  all exception types under the standard exception hierarchy and allows
-  WebSocket++ exceptions to be caught in the same statement as others. The error
-  code that was previously thrown is wrapped in the exception object and can be
-  accessed via the `websocketpp::exception::code()` method.
-- BREAKING API CHANGE: Custom logging policies have some new required
-  constructors that take generic config settings rather than pointers to
-  std::ostreams. This allows writing logging policies that do not involve the
-  use of std::ostream. This does not affect anyone using the built in logging
-  policies.
-- BREAKING UTILITY CHANGE: `websocketpp::lib::net::htonll` and
-  `websocketpp::lib::net::ntohll` have been prefixed with an underscore to avoid
-  conflicts with similarly named macros in some operating systems. If you are
-  using the WebSocket++ provided 64 bit host/network byte order functions you
-  will need to switch to the prefixed versions.
-- BREAKING UTILITY CHANGE: The signature of `base64_encode` has changed from
-  `websocketpp::base64_encode(unsigned char const *, unsigned int)` to
-  `websocketpp::base64_encode(unsigned char const *, size_t)`.
-- BREAKING UTILITY CHANGE: The signature of `sha1::calc` has changed from
-  `websocketpp::sha1::calc(void const *, int, unsigned char *)` to
-  `websocketpp::sha1::calc(void const *, size_t, unsigned char *)`
-- Feature: Adds incomplete `minimal_server` and `minimal_client` configs that
-  can be used to build custom configs without pulling in the dependencies of
-  `core` or `core_client`. These configs will offer a stable base config to
-  future-proof custom configs.
-- Improvement: Core library no longer has std::iostream as a dependency.
-  std::iostream is still required for the optional iostream logging policy and
-  iostream transport.
-- Bug: C++11 Chrono support was being incorrectly detected by the `boost_config`
-  header. Thank you Max Dmitrichenko for reporting and a patch.
-- Bug: use of `std::put_time` is now guarded by a unique flag rather than a
-  chrono library flag. Thank you Max Dmitrichenko for reporting.
-- Bug: Fixes non-thread safe use of std::localtime. #347 #383
-- Compatibility: Adjust usage of std::min to be more compatible with systems
-  that define a min(...) macro.
-- Compatibility: Removes unused parameters from all library, test, and example
-  code. This assists with those developing with -Werror and -Wunused-parameter
-  #376
-- Compatibility: Renames ntohll and htonll methods to avoid conflicts with
-  platform specific macros. #358 #381, #382 Thank you logotype, unphased,
-  svendjo
-- Cleanup: Removes unused functions, fixes variable shadow warnings, normalizes
-  all whitespace in library, examples, and tests to 4 spaces. #376
-
-0.3.0 - 2014-08-10
-- Feature: Adds `start_perpetual` and `stop_perpetual` methods to asio transport
-  These may be used to replace manually managed `asio::io_service::work` objects
-- Feature: Allow setting pong and handshake timeouts at runtime.
-- Feature: Allows changing the listen backlog queue length.
-- Feature: Split tcp init into pre and post init.
-- Feature: Adds URI method to extract query string from URI. Thank you Banaan
-  for code. #298
-- Feature: Adds a compile time switch to asio transport config to disable
-  certain multithreading features (some locks, asio strands)
-- Feature: Adds the ability to pause reading on a connection. Paused connections
-  will not read more data from their socket, allowing TCP flow control to work
-  without blocking the main thread.
-- Feature: Adds the ability to specify whether or not to use the `SO_REUSEADDR`
-  TCP socket option. The default for this value has been changed from `true` to
-  `false`.
-- Feature: Adds the ability to specify a maximum message size.
-- Feature: Adds `close::status::get_string(...)` method to look up a human
-  readable string given a close code value.
-- Feature: Adds `connection::read_all(...)` method to iostream transport as a
-  convenience method for reading all data into the connection buffer without the
-  end user needing to manually loop on `read_some`.
-- Improvement: Open, close, and pong timeouts can be disabled entirely by
-  setting their duration to 0.
-- Improvement: Numerous performance improvements. Including: tuned default
-  buffer sizes based on profiling, caching of handler binding for async
-  reads/writes, non-malloc allocators for read/write handlers, disabling of a
-  number of questionably useful range sanity checks in tight inner loops.
-- Improvement: Cleaned up the handling of TLS related errors. TLS errors will
-  now be reported with more detail on the info channel rather than all being
-  `tls_short_read` or `pass_through`. In addition, many cases where a TLS short
-  read was in fact expected are no longer classified as errors. Expected TLS
-  short reads and quasi-expected socket shutdown related errors will no longer
-  be reported as unclean WebSocket shutdowns to the application. Information
-  about them will remain in the info error channel for debugging purposes.
-- Improvement: `start_accept` and `listen` errors are now reported to the caller
-  either via an exception or an ec parameter.
-- Improvement: Outgoing writes are now batched for improved message throughput
-  and reduced system call and TCP frame overhead.
-- Bug: Fix some cases of calls to empty lib::function objects.
-- Bug: Fix memory leak of connection objects due to cached handlers holding on to
-  reference counted pointers. #310 Thank you otaras for reporting.
-- Bug: Fix issue with const endpoint accessors (such as `get_user_agent`) not
-  compiling due to non-const mutex use. #292 Thank you logofive for reporting.
-- Bug: Fix handler allocation crash with multithreaded `io_service`.
-- Bug: Fixes incorrect whitespace handling in header parsing. #301 Thank you
-  Wolfram Schroers for reporting
-- Bug: Fix a crash when parsing empty HTTP headers. Thank you Thingol for
-  reporting.
-- Bug: Fix a crash following use of the `stop_listening` function. Thank you
-  Thingol for reporting.
-- Bug: Fix use of variable names that shadow function parameters. The library
-  should compile cleanly with -Wshadow now. Thank you giszo for reporting. #318
-- Bug: Fix an issue where `set_open_handshake_timeout` was ignored by server
-  code. Thank you Robin Rowe for reporting.
-- Bug: Fix an issue where custom timeout values weren't being propagated from
-  endpoints to new connections.
-- Bug: Fix a number of memory leaks related to server connection failures. #323
-  #333 #334 #335 Thank you droppy and aydany for reporting and patches.
-  reporting.
-- Compatibility: Fix compile time conflict with Visual Studio's MIN/MAX macros.
-  Thank you Robin Rowe for reporting.
-- Documentation: Examples and test suite build system now defaults to clang on
-  OS X
-
-0.3.0-alpha4 - 2013-10-11
-- HTTP requests ending normally are no longer logged as errors. Thank you Banaan
-  for reporting. #294
-- Eliminates spurious expired timers in certain error conditions. Thank you
-  Banaan for reporting. #295
-- Consolidates all bundled library licenses into the COPYING file. #294
-- Updates bundled sha1 library to one with a cleaner interface and more
-  straight-forward license. Thank you lotodore for reporting and Evgeni Golov
-  for reviewing. #294
-- Re-introduces strands to asio transport, allowing `io_service` thread pools to
-  be used (with some limitations).
-- Removes endpoint code that kept track of a connection list that was never used
-  anywhere. Removes a lock and reduces connection creation/deletion complexity
-  from O(log n) to O(1) in the number of connections.
-- A number of internal changes to transport APIs
-- Deprecates iostream transport `readsome` in favor of `read_some` which is more
-  consistent with the naming of the rest of the library.
-- Adds preliminary signaling to iostream transport of eof and fatal transport
-  errors
-- Updates transport code to use shared pointers rather than raw pointers to
-  prevent asio from retaining pointers to connection methods after the
-  connection goes out of scope. #293 Thank you otaras for reporting.
-- Fixes an issue where custom headers couldn't be set for client connections
-  Thank you Jerry Win and Wolfram Schroers for reporting.
-- Fixes a compile error on visual studio when using interrupts. Thank you Javier
-  Rey Neira for reporting this.
-- Adds new 1012 and 1013 close codes per IANA registry
-- Add `set_remote_endpoint` method to iostream transport.
-- Add `set_secure` method to iostream transport.
-- Fix typo in .gitattributes file. Thank you jstarasov for reporting this. #280
-- Add missing locale include. Thank you Toninoso for reporting this. #281
-- Refactors `asio_transport` endpoint and adds full documentation and exception
-  free varients of all methods.
-- Removes `asio_transport` endpoint method cancel(). Use `stop_listen()` instead
-- Wrap internal `io_service` `run_one()` method
-- Suppress error when trying to shut down a connection that was already closed
-
-0.3.0-alpha3 - 2013-07-16
-- Minor refactor to bundled sha1 library
-- HTTP header comparisons are now case insensitive. #220, #275
-- Refactors URI to be exception free and not use regular expressions. This
-  eliminates the dependency on boost or C++11 regex libraries allowing native
-  C++11 usage on GCC 4.4 and higher and significantly reduces staticly built
-  binary sizes.
-- Updates handling of Server and User-Agent headers to better handle custom
-  settings and allow suppression of these headers for security purposes.
-- Fix issue where pong timeout handler always fired. Thank you Steven Klassen
-  for reporting this bug.
-- Add ping and pong endpoint wrapper methods
-- Add `get_request()` pass through method to connection to allow calling methods
-  specific to the HTTP policy in use.
-- Fix issue compile error with `WEBSOCKETPP_STRICT_MASKING` enabled and another
-  issue where `WEBSOCKETPP_STRICT_MASKING` was not applied to incoming messages.
-  Thank you Petter Norby for reporting and testing these bugs. #264
-- Add additional macro guards for use with boost_config. Thank you breyed
-  for testing and code. #261
-
-0.3.0-alpha2 - 2013-06-09
-- Fix a regression that caused servers being sent two close frames in a row
-  to end a connection uncleanly. #259
-- Fix a regression that caused spurious frames following a legitimate close
-  frames to erroneously trigger handlers. #258
-- Change default HTTP response error code when no http_handler is defined from
-  500/Internal Server Error to 426/Upgrade Required
-- Remove timezone from logger timestamp to work around issues with the Windows
-  implementation of strftime. Thank you breyed for testing and code. #257
-- Switch integer literals to char literals to improve VCPP compatibility.
-  Thank you breyed for testing and code. #257
-- Add MSVCPP warning suppression for the bundled SHA1 library. Thank you breyed
-  for testing and code. #257
-
-0.3.0-alpha1 - 2013-06-09
-- Initial Release
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/config.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/config.dox
deleted file mode 100644
index 4a811c5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/config.dox
+++ /dev/null
@@ -1,138 +0,0 @@
-/** \page reference.config Config Reference
-
-WebSocket++ uses a config template parameter to supply a number of compile type policy types and default numerical values for buffer sizes, timeouts, security behavior, etc. Swapping policies allows changing certain core library behavior designed to be pluggable.
-
-A custom config can be made standalone or can subclass one of the bundled configs and just override a few things.
-
-__Example__
-```
-// some config options may require additional includes or dependencies.
-// syslog logging policy, for example, requires <syslog.h>, 
-// the permessage deflate settings require zlib.
-#include <websocketpp/logger/syslog.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-// Custom server config based on bundled asio config
-struct custom_server_config : public websocketpp::config::asio {
-	// Replace default stream logger with a syslog logger
-	typedef websocketpp::log::syslog<concurrency_type, websocketpp::log::elevel> elog_type;
-	typedef websocketpp::log::syslog<concurrency_type, websocketpp::log::alevel> alog_type;
-
-	// Reduce read buffer size to optimize for small messages
-	static const size_t connection_read_buffer_size = 1024;
-
-	// enable permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::server<custom_server_config> server_endpoint_type;
-```
-
-Core Config Options
--------------------
-
-### Policies
-
-Policies are classes used to allow clean swapping of behavior without changing the core library
-
-| Typedef Name              | Effect                                 |
-| ------------------------- | -------------------------------------- |
-| concurrency_type          | Concurrency policy                     |
-| elog_type                 | Error logger type                      |
-| alog_type                 | Access logger type                     |
-| request_type              | HTTP request type                      |
-| response_type             | HTTP response type                     |
-| message_type              | Type to deliver recieved messages      |
-| con_msg_manager_type      | Connection level message manager       |
-| endpoint_msg_manager_type | Endpoint level message manager         |
-| rng_type                  | Random Number Generation policy        |
-| transport_type            | Transport policy to use                |
-| endpoint_base             | User overridable Endpoint base class   |
-| connection_base           | User overridable Connection base class |
-
-### Timeouts Values
-
-These represent the length of time (in ms) before the given operation is aborted
-
-| Field                   | Type | Default | Operation                   |
-| ----------------------- | ---- | ------- | --------------------------- |
-| timeout_open_handshake  | long | 5000    | Opening handshake           |
-| timeout_close_handshake | long | 5000    | Closing handshake           |
-| timeout_pong            | long | 5000    | No pong recieved after ping |
-
-### Performance tuning
-
-| Field                       | Type   | Default  | Meaning                                                            |
-| --------------------------- | ------ | -------- | ------------------------------------------------------------------ |
-| connection_read_buffer_size | size_t | 16384    | Size of the per-connection read buffer                             |
-| enable_multithreading       | bool   | true     | Disabling may reduce locking overhead for single threaded programs |
-
-#### Connection Read Buffer
-
-Each connection has an internal buffer of this size. A larger value will result in fewer trips through the library and less CPU overhead at the expense of increased memory usage per connection.
-
-If your application primarily deals in very large messages you may want to try setting this value higher.
-
-If your application has a lot of connections or primarily deals in small messages you may want to try setting this smaller.
-
-### Security settings
-
-| Field                  | Type   | Default | Effect                                 |
-| ---------------------- | ------ | ------- | -------------------------------------- |
-| drop_on_protocol_error | bool   | false   | Omit close handshake on protocol error |
-| silent_close           | bool   | false   | Don't return close codes or reasons    |
-| max_message_size       | size_t | 32MB    | WebSocket max message size limit       |
-| max_http_body_size     | size_t | 32MB    | HTTP Parser's max body size limit      |
-
-#### Drop on protocol error
-Drop connections on protocol error rather than sending a close frame. Off by default. This may result in legitimate messages near the error being dropped as well. It may free up resources otherwise spent dealing with misbehaving clients.
-
-#### Silent Close
-Silence close suppresses the return of detailed connection close information during the closing handshake. This information is useful for debugging and presenting useful errors to end users but may be undesirable for security reasons in some production environments. Close reasons could be used by an attacker to confirm that the endpoint is out of resources or be used to identify the WebSocket implementation in use.
-
-Note: this will suppress *all* close codes, including those explicitly sent by local applications.
-
-#### Max message size
-Default value for the processor's maximum message size. Maximum message size determines the point at which the library will drop a connection with the message_too_big protocol error.
-
-#### Max HTTP header size
-Maximum body size determines the point at which the library will abort reading an HTTP message body and return the 413/request entity too large error.
-
-Transport Config Options
-------------------------
-
-### Policies
-
-Policies are classes used to allow clean swapping of behavior without changing the core library
-
-| Typedef Name     | Effect             |
-| ---------------- | ------------------ |
-| concurrency_type | Concurrency Policy |
-| elog_type        | Error logger type  |
-| alog_type        | Access logger type |
-| request_type     | HTTP request type  |
-| response_type    | HTTP response type |
-
-### Timeouts Values
-
-These represent the length of time (in ms) before the given operation is aborted
-
-| Field                    | Type | Default | Operation                                     |
-| ------------------------ | ---- | ------- | --------------------------------------------- |
-| timeout_socket_pre_init  | long | 5000    | Transport dependent                           |
-| timeout_proxy            | long | 5000    | Proxy handshake                               |
-| timeout_socket_post_init | long | 5000    | Transport dependent (commonly: TLS handshake) |
-| timeout_dns_resolve      | long | 5000    | DNS resolution                                |
-| timeout_connect          | long | 5000    | TCP Connect                                   |
-| timeout_socket_shutdown  | long | 5000    | Socket shutdown                               |
-
-### Performance tuning
-
-| Field                       | Type   | Default  | Meaning                                                            |
-| --------------------------- | ------ | -------- | ------------------------------------------------------------------ |
-| enable_multithreading       | bool   | true     | Disabling may reduce locking overhead for single threaded programs |
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/faq.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/faq.dox
deleted file mode 100644
index 9f417ec..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/faq.dox
+++ /dev/null
@@ -1,162 +0,0 @@
-/** \page faq FAQ
-
-## General Library Usage
-
-### Can a handler be changed after a connection is established? Can one be removed?
-Yes, but not globally.
-
-Handlers assigned to endpoints will be automatically copied to the connections created by that endpoint. Changing a handler on an endpoint will only affect future connections.
-
-Once a particular connection is created, it's handlers can be changed individually by calling the `set_*_handler` methods. Once changed, all future events of that type for that connection will use the new handler.
-
-To remove a handler that was previously set, call the set method with `nullptr` or `NULL`.
-
-### Can I reject or conditionally accept a connection
-Yes. The `validate` handler is called after the initial handshake has been recieved but before WebSocket++ has responded. This gives you the opportunity to inspect the incoming connection request, its headers, origin, subprotocols, and the remote endpoint IP. Return `true` from the validate handler to accept the connection and `false` to reject it.
-
-To set a custom HTTP error message for your rejection, use `websocketpp::connection::set_status` and (optionally) `websocketpp::connection::set_body()` to set the HTTP status code and error message body text. If you do not set body text a message will be generated automatically based on the status code.
-
-### How do I negotiate subprotocols?
-WebSocket connections may offer a particular subprotocol they want to use. The WebSocket protocol does not define the meaning or interpretation of the subprotocol. This interpretation is left up to the individual application endpoints.
-
-WebSocket++ servers can read the requested subprotocols during the `validate` handler by calling `websocketpp::connection::get_requested_subprotocols`. The list is ordered by client priority. You may optionally choose one of these subprotocols with `websocketpp::connection::select_subprotocol`. The handshake will then complete and let the client know which one was chosen. If you do not choose any, the "blank"/empty/none subprotocol will be used.
-
-WebSocket++ clients can add a subprotocol to an outgoing connection by calling `websocketpp::connection::add_subprotocol` before calling `websocketpp::client::connect`. The order of adding will be interpreted as the order of preference.
-
-In both caases, after the connection has been established, the selected subprotocol is available via the `websocketpp::connection::get_subprotocol` method.
-
-Note: some browsers will allow the connection to continue if they requested a subprotocol and your server doesn't select one. Others will reject the connection. 
-
-### How do I cleanly exit an Asio transport based program
-
-The Asio transport based clients and servers use the Asio library's underlying `io_service` to handle asyncronous networking operations. The standard behavior of the io_service is to run until there are no async operations left and then return. WebSocket++, when using the Asio transport, behaves like a standard Asio application. If you want your WebSocket++/Asio based program to stop network operations and cleanly close all sockets you will want to do the following:
-
-- For servers, call `websocketpp::transport::asio::endpoint::stop_listening` to initiate the closing of the server listening socket.
-- For clients, if you have engaged perpetual mode with `websocketpp::transport::asio::endpoint::start_perpetual`, disable it with `websocketpp::transport::asio::endpoint::stop_perpetual`.
-- For both, run `websocketpp::endpoint::close` or `websocketpp::connection::close` on all currently outstanding connections. This will initiate the WebSocket closing handshake for these connections
-- Wait. Asio is asyncronous. When the calls to the above methods (stop_listening, close, etc) complete the server *will still be listening*, the connections *will still be active* until the io_service gets around to asyncronously processing the socket and WebSocket protocol closing handshakes. The `io_service::run` method will exit cleanly and automatically when all operations are complete.
-
-__WARNING__: Asio's `io_service` has a method called `stop`. WebSocket++ wraps this method as `websocketpp::transport::asio::endpoint::stop`. While this operation has a benign sounding name, it is a powerful and destructive operation that should only be used in special cases. If you are using `io_service::stop` or `endpoint::stop` without a very good reason your program is likely broken and may exhibit erratic behavior. Specifically, `io_service::stop` stops the processing of events entirely. This does not give current operations (such as socket closing handshakes) the opportunity to finish. It will leave your sockets in a dangling state that may invoke operating system level timeouts or other errors.
-
-__Special cases__:
-- If your client uses the `start_perpetual` method it will prevent the io_service from exiting even if it has nothing to do. This is useful if you want a client endpoint to idle in the background to allow new connections to be formed on demand rather than generating a new endpoint for each.
-- If you are using an external io_service and/or are placing non-WebSocket++ operations on the `io_service` those operations may keep the `io_service` open even after all WebSocket++ operations have completed.
-- If you are using `poll`/`poll_one`/`run_one` or otherwise manually driving the `io_service` event loop you may need to adjust usage to make sure you are correctly recognizing the "done with work" and "not done but idling / `io_service::work`" cases.
-
-### Is there a way to check the validity of a `connection_hdl`?
-
-Sometimes, not generally though, because there isn’t a way to check if a TCP connection is valid.
-
-You can try upgrading your hdl to a full connection_ptr using `websocketpp::endpoint::get_con_from_hdl`. If this fails, the hdl is definitely invalid. If it succeeds it may or may not be. The only way to tell definitively is to try and send something (either a message or a ping).
-
-If you handle errors from methods like send, ping, close, etc correctly then you shouldn’t have to worry about accidentally sending to dead connections. The send/ping/pong/close methods will set or throw a specific error in the case that you tried to send something but the connection was closed/gone/etc.
-
-### How do I fix the "address is in use" error when trying to restart my server?
-
-Normally, for security purposes, operating systems prevent programs from listening on sockets created by other programs. When your program crashes and restarts, the new instance is a different program from the perspective of the operating system. As such it can’t listen on the socket address/port that the previous program was using until after a timeout occurs to make sure the old program was done with it.
-
-The first step for handling this is to make sure that you provide a method (signal handler, admin websocket message, etc) to perform a clean server shutdown. There is a question elsewhere in this FAQ that describes the steps necessary for this.
-
-The clean close strategy won't help in the case of crashes or other abnormal closures. An option to consider for these cases is the use of the SO_REUSEADDR socket option. This instructs the OS to not request an exclusive lock on the socket. This means that after your program crashes the replacement you start can immediately listen on that address/port combo again.
-
-__Please note__: how this works exactly depends on your operating system. Additionally, not exclusively locking your listening socket could allow hijacking by other programs if you are running in a shared resource environment. For development this is generally no problem. For a production environment, think carefully about the security model. `websocketpp::transport::asio::endpoint::set_reuse_addr` is the method to do this. You must specify this setting before calling `websocketpp::transport::asio::endpoint::listen`.
-
-### How do I send and recieve binary messages?
-
-When supported by the remote endpoint, WebSocket++ allows reading and sending messages in the two formats specified in RFC6455, UTF8 text and binary. WebSocket++ performs UTF8 validation on all outgoing text messages to ensure that they meet the specification. Binary messages do not have any additional processing and their interpretation is left entirely to the library user.
-
-To determine the type of an incoming message, use `websocketpp::message_buffer::message::get_opcode`. The relevant return values are `websocketpp::frame::opcode::text` and `websocketpp::frame::opcode::binary`. There is no difference in how payloads are retrieved between these modes, only in how WebSocket++ validated the contents and how the library user is to interpret the data.
-
-To specify the type of an outgoing message, use the frame opcode values listed above as the second op parameter for `websocketpp::connection::send`. There are two relevant overloads of send. One that takes a `std::string` and defaults to op=text. The other that takes a `void const *` and a `size_t` length and defaults to op=binary. Note: You can send binary messages via the string overload and text messages via the void * overload. In the case that you are manually building a message buffer rather than using the automatic send member functions, you can pass the opcode in as a parameter to the message buffer constructor or user the `websocketpp::message_buffer::message::set_opcode` member function to set or re-set it later.
-
-## Dependency Management
-
-### Can WebSocket++ be used without Boost?
-Yes. WebSocket++ only uses Boost features as polyfills for C++11 language features and libraries. If you have a C++11 compiler and standard library you can use WebSocket++ without Boost. In most cases setting your build environment to use the C++11 (or later) language dialect is sufficient to enable this mode of use.
-
-With less common compilers (and sometimes very recently release compilers) there may be specific issues with certain libraries that aren't automatically detected by the library. For these situations there are additional defines available to fine tune which C++11 libraries and features are used. TODO: more details about them.
-
-For the iostream/raw transport the C++11 standard library is sufficient. For the Asio based transports, there is no C++11 library that provides the networking capabilaties that Asio does. As such even with a C++11 build system, you will need a standalone copy of Asio to use if Boost Asio is not available.
-
-MinGW users who want to avoid Boost should also consult the nearby question about MinGW compatibility.
-
-### Can WebSocket++ be used with standalone Asio
-Yes. The process is the same as used with standalone Asio itself. Define `ASIO_STANDALONE` before including Asio or WebSocket++ headers. You will need to download a copy of the Asio headers separately (http://www.think-async.com) and make sure they are in your build system's include path.
-
-### Can WebSocket++ be used without TLS or OpenSSL?
-Yes. When using the iostream/raw transport, there are no TLS features and OpenSSL is not required. When using the Asio transport TLS features are optional. You only need OpenSSL if you want to use TLS. You can only make or recieve encrypted connections (https/wss) if you have enabled TLS features.
-
-Whether an Asio endpoint uses TLS or not is determined by its config template parameter. The default bundled `websocketpp::config::asio` and `websocketpp::config::asio_client` configs do not support TLS, the `websocketpp::config::asio_tls` and `websocketpp::config::asio_tls_client` do.
-
-The `<websocketpp/config/asio.hpp>` and `<websocketpp/config/asio_client.hpp>` headers will include both the TLS and non-TLS varients of their respective configs and require the presence of OpenSSL. The `<websocketpp/config/asio_no_tls.hpp>` and `<websocketpp/config/asio_no_tls_client.hpp>` headers will include only the non-TLS configs and do not require OpenSSL.
-
-### Build issues with TLS on recent versions of OS X
-Mac OS X ships a severely outdated version of the OpenSSL library. To securely use TLS with WebSocket++ on OS X you will need to install a modern version of OpenSSL via homebrew or compiling from source.
-
-### Can WebSocket++ be used with MinGW
-Generally, yes. Note that in C++11 mode MinGW does not currently support the C++11 STL `<thread>` library. WebSocket++ requires a thread/mutex library. Options include Boost thread (the default when a compatible C++11 `<thread>` can't be found) or `mingw-std-threads` (https://github.com/meganz/mingw-std-threads) by including those headers and defining `_WEBSOCKETPP_MINGW_THREAD_`.
-
-## Compression
-
-### How do I use permessage-deflate in version 0.6.0-permessagedeflate and 0.7.0?
-
-These versions of the library require a custom config to use the permessage-deflate extension. Here is a minimal example of such a custom config. You can also integrate these lines into an existing custom config.
-
-Note that in these versions there is no fine grained control over which connections are compressed or not. Clients will request compression with the default settings and use it if the server supports it. Servers will accept whatever parameters clients request.
-
-Outgoing messages by default will be compressed if compression was auto-negotiated during the handshake. There is an option to force a specific message to be sent uncompressed even if compression was negotiated. This may be useful for sending data that you know to be compressed already (images, zip files, etc).
-
-
-__Server Example__
-```
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-struct deflate_server_config : public websocketpp::config::asio {
-	// ... additional custom config if you need it for other things
-
-	/// permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::server<deflate_server_config> server_endpoint_type;
-```
-
-__Client Example__
-```
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-struct deflate_client_config : public websocketpp::config::asio_client {
-	// ... additional custom config if you need it for other things
-
-	/// permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::client<deflate_client_config> client_endpoint_type;
-```
-
-## Security
-
-### Is it possible to terminate a malicious connection quickly, without tying up resources performing clean close steps, 
-
-Yes. The library will automatically detect and terminate connections that violate the WebSocket protocol. In cases where the library believes the remote endpoint to be malicious or sufficiently broken to be unlikely to understand or process the closing handshake, it will be omited.
-
-If your application detects conditions above the protocol level that you believe to be malicious, for example, if you recognize an IP from a known denial of service attack, you can close the connection with two different levels of urgency. Use the standard `websocketpp::endpoint::close` or `websocketpp::connection::close` methods with one of the following special close codes:
-- `websocketpp::close::status::omit_handshake`: Omits the closing handshake, but cleanly closes the TCP connection.
-- `websocketpp::close::status::force_tcp_drop`: Forcibly drop the TCP connection.
-
-Please note that usage of these disconnect methods results in a violation of the WebSocket protocol and may have negative reprocusions for the remote endpoint with respect to network timeouts. Please use caution when using them.
-
-## Build Issues
-
-### Getting compile errors related to `std::chrono`, `boost::chrono`, `waitable_timer`, or `steady_clock`
-
-Your build system may be confused about whether it is supposed to be using `boost::chrono` or `std::chrono`. Boost automatically detects this setup on some compilers but not others. Defining `BOOST_ASIO_HAS_STD_CHRONO` can help. See http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/overview/cpp2011/chrono.html for more details.
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/getting_started.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/getting_started.dox
deleted file mode 100644
index d9a74c0..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/getting_started.dox
+++ /dev/null
@@ -1,27 +0,0 @@
-/** \page getting_started Getting Started
-
-WebSocket++ code is available on github at https://github.com/zaphoyd/websocketpp
-The official project homepage lives at http://www.zaphoyd.com/websocketpp
-
-The git repository is organized into several directories:
-
-- **docs**: This documentation
-- **examples**: Example programs that demonstrate how to build basic versions of some commonly used patterns for WebSocket clients and servers.
-- **test**: Unit tests that confirm that the code you have works properly and help detect platform specific issues.
-- **tutorials**: Detailed walkthroughs of a select set of the example programs.
-- **websocketpp**: All of the library code and default configuration files.
-
-WebSocket++ is a header only library. You can start using it by including the websocketpp source directory in your project's include path and including the appropriate WebSocket++ headers in your program. You may also need to include and/or link to appropriate Boost/system libraries. TODO: More information: Building a program with WebSocket++, Walkthroughs of the example programs
-
-WebSocket++ includes cmake and scons scripts for building the examples and unit tests. Neither system is needed unless you want to build tests or examples in an automated fashion.
-
-__Usage questions__ should be posted to the project mailing list at http://groups.google.com/group/websocketpp/ or the IRC channel (\#websocketpp on freenode).
-
-__Bugs and issues__ should be posted to the project GitHub issues queue: https://github.com/zaphoyd/websocketpp/issues.
-
-__Pull requests__ on GitHub are welcome. Please make them against the `develop` branch.
-
-WebSocket++ is written and maintained by Peter Thorson. You can contact me via GitHub messaging, IRC, or via email at websocket@zaphoyd.com.
-
-*/
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/handlers.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/handlers.dox
deleted file mode 100644
index d5abeb6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/handlers.dox
+++ /dev/null
@@ -1,165 +0,0 @@
-/** \page reference.handlers Handler Reference
-
-Handlers allow WebSocket++ programs to receive notifications about events
-that happen in relation to their connections. Some handlers also behave as
-hooks that give the program a chance to modify state or adjust settings before
-the connection continues.
-
-Handlers are registered by calling the appropriate `set_*_handler` method on either an
-endpoint or connection. The * refers to the name of the handler (as 
-specified in the signature field below). For example, to set the open handler,
-call `set_open_handler(...)`.
-
-Setting handlers on an endpoint will result in them being copied as the default
-handler to all new connections created by that endpoint. Changing an endpoint's
-handlers will not affect connections that are already in progress. This includes
-connections that are in the listening state. As such, it is important to set any
-endpoint handlers before you call `endpoint::start_accept` or else the handlers
-will not be attached to your first connection.
-
-Setting handlers on a connection will result in the handler being changed for
-that connection only, starting at the next time that handler is called. This can
-be used to change the handler during a connection.
-
-Connection Handlers
--------------------
-
-These handlers will be called at most once per connection in the order specified below.
-
-### Socket Init Handler
-
-| Event                 | Signature                                             | Availability         |
-| --------------------- | ----------------------------------------------------- | -------------------- |
-| Socket initialization | `socket_init(connection_hdl, asio::ip::tcp::socket&)` | 0.3.0 Asio Transport |
-
-This hook is triggered after the socket has been initialized but before a connection is established. 
-It allows setting arbitrary socket options before connections are sent/recieved.
-
-### TCP Pre-init Handler
-
-| Event                         | Signature                      | Availability         |
-| ----------------------------- | ------------------------------ | -------------------- |
-| TCP established, no data sent | `tcp_pre_init(connection_hdl)` | 0.3.0 Asio Transport |
-
-This hook is triggered after the TCP connection is established, but before any pre-WebSocket-handshake 
-operations have been run. Common pre-handshake operations include TLS handshakes and proxy connections.
-
-### TCP Post-init Handler
-
-| Event                   | Signature                                  | Availability                  |
-| ----------------------- | ------------------------------------------ | ----------------------------- |
-| Request for TLS context | `tls_context_ptr tls_init(connection_hdl)` | 0.3.0 Asio Transport with TLS |
-
-This hook is triggered before the TLS handshake to request the TLS context to use. You must 
-return a pointer to a configured TLS conext to continue. This provides the opportuinity to 
-set up the TLS settings, certificates, etc.
-
-### Validate Handler
-
-| Event                                 | Signature                       | Availability                 |
-| ------------------------------------- | ------------------------------- | ---------------------------- |
-| Hook to accept or reject a connection | `bool validate(connection_hdl)` | 0.3.0 Core, Server role only |
-
-This hook is triggered for servers during the opening handshake after the request has been 
-processed but before the response has been sent. It gives a program the opportunity to inspect
-headers and other connection details and either accept or reject the connection. Validate happens
-before the open or fail handler.
-
-Return true to accept the connection, false to reject. If no validate handler is registered, 
-all connections will be accepted.
-
-### Open Connection Handler
-
-| Event                     | Signature              | Availability |
-| ------------------------- | ---------------------- | ------------ |
-| Successful new connection | `open(connection_hdl)` | 0.3.0 Core   |
-
-Either open or fail will be called for each connection. Never both. All
-connections that begin with an open handler call will also have a matching
-close handler call when the connection ends.
-
-### Fail Connection Handler
-
-| Event                               | Signature              | Availability |
-| ----------------------------------- | ---------------------- | ------------ |
-| Connection failed (before opening)  | `fail(connection_hdl)` | 0.3.0 Core   |
-
-Either open or fail will be called for each connection. Never both. Connections
-that fail will never have a close handler called.
-
-### Close Connection Handler
-
-| Event                             | Signature               | Availability |
-| --------------------------------- | ----------------------- | ------------ |
-| Connection closed (after opening) | `close(connection_hdl)` | 0.3.0 Core   |
-
-Close will be called exactly once for every connection that open was called for.
-Close is not called for failed connections.
-
-Message Handlers
-----------------
-
-These handers are called in response to incoming messages or message like events. They only will be called while the connection is in the open state.
-
-### Message Handler
-
-| Event                 | Signature                              | Availability |
-| --------------------- | -------------------------------------- | ------------ |
-| Data message recieved | `message(connection_hdl, message_ptr)` | 0.3.0 Core   |
-
-Applies to all non-control messages, including both text and binary opcodes. The
-`message_ptr` type and its API depends on your endpoint type and its config.
-
-### Ping Handler
-
-| Event         | Signature                                | Availability |
-| ------------- | ---------------------------------------- | ------------ |
-| Ping recieved | `bool ping(connection_hdl, std::string)` | 0.3.0 Core   |
-
-Second (string) argument is the binary ping payload. Handler return value
-indicates whether or not to respond to the ping with a pong. If no ping handler
-is set, WebSocket++ will respond with a pong containing the same binary data as
-the ping (Per requirements in RFC6455).
-
-### Pong Handler
-
-| Event         | Signature                           | Availability |
-| ------------- | ----------------------------------- | ------------ |
-| Pong recieved | `pong(connection_hdl, std::string)` | 0.3.0 Core   |
-
-Second (string) argument is the binary pong payload.
-
-### Pong Timeout Handler
-
-| Event                              | Signature                                   | Availability                             |
-| ---------------------------------- | ------------------------------------------- | ---------------------------------------- |
-| Timed out while waiting for a pong | `pong_timeout(connection_hdl, std::string)` | 0.3.0 Core, transport with timer support |
-
-Triggered if there is no response to a ping after the configured duration. The second
-(string) argument is the binary payload of the unanswered ping.
-
-### HTTP Handler
-
-| Event                 | Signature             | Availability                 |
-| --------------------- | --------------------- | ---------------------------- |
-| HTTP request recieved | `http(connection_hdl` | 0.3.0 Core, Server role only |
-
-Called when HTTP requests that are not WebSocket handshake upgrade requests are
-recieved. Allows responding to regular HTTP requests. If no handler is registered
-a 426/Upgrade Required error is returned.
-
-### Interrupt Handler
-
-| Event                               | Signature                   | Availability |
-| ----------------------------------- | --------------------------- | ------------ |
-| Connection was manually interrupted | `interrupt(connection_hdl)` | 0.3.0 Core   |
-
-Interrupt events can be triggered by calling `endpoint::interrupt` or `connection::interrupt`. 
-Interrupt is similar to a timer event with duration zero but with lower overhead. It is useful
-for single threaded programs to allow breaking up a very long handler into multiple parts and 
-for multi threaded programs as a way for worker threads to signale to the main/network thread 
-that an event is ready.
-
-todo: write low and high watermark handlers
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/logging.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/logging.dox
deleted file mode 100644
index bdf8a7f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/logging.dox
+++ /dev/null
@@ -1,102 +0,0 @@
-/** \page reference.logging Logging Reference
-
-WebSocket++ has the capability of logging events during the lifetime of the connections that it processes. Each endpoint has two independent logging interfaces that are used by all connections created by that endpoint. The first is an access interface that allows logging routine events in the life of a connection (such as connect/disconnect and receipt of messages). The other is an error interface that allows logging non-routine problems or errors. Each interface has a number of different named channels that can be toggled on and off independently.
-
-Exactly how these logs are processed and where they are written to depends on which logging policy is in use. Several logging policies are included by default and you can write your own policy if you need something more specialized. Selecting a policy is done via the  \subpage reference.config "endpoint config".
-
-Common functionality (all policies)
------------------------------------
-
-### Logging Channels
-
-Each logging interface is divided into 32 named channels. Log messages are written to a specific interface on a specific channel. Which log messages are actually printed is determined by which channels are enabled or not. Channels can be enabled or disabled either at compile time or at runtime.
-
-### Enabling and Disabling Channels
-
-Channels disabled at compile time are removed from the code entirely (assuming correct compiler optimization settings) and are not available for runtime enabling or disabling. To disable channels at compile time, use the `alog_level` and `elog_level` values within your \subpage reference.config "endpoint config". Channels not disabled at compile time can be enabled or disabled at runtime using the `websocketpp::endpoint::set_access_channels()`, `websocketpp::endpoint::clear_access_channels()`, `websocketpp::endpoint::set_error_channels()`, and `websocketpp::endpoint::clear_error_channels()` methods.
-
-The set and clear functions act only on the channels specified. `set_access_channels(log::alevel::connect)` will enable logging of new connections. Following this with `set_access_channels(log::alevel::disconnect)` will enable logging of disconnections in addition to connections. Use `clear*` functions to disable a specific channel. Channels may be combined using bitwise operations to create aggregate packages of channels that may be set or cleared at once. Default packages include `websocketpp::log::alevel::all`, `websocketpp::log::elevel::all`, `websocketpp::log::alevel::none`, `websocketpp::log::elevel::none`. These represent all possible access/error channels and no access/error channels respectively. For convenience, setting none is aliased to clearing all.
-
-### Examples
-
-__Disable all__
-
-`clear_access_channels(log::alevel::all)`
-
-__Disable all (alternative method)__
-
-`set_access_channels(log::alevel::none)`
-
-__Multiple channels at once__
-
-`log::alevel::message_payload | log::alevel::message_payload`
-
-__All except one__
-
-`log::alevel::all ^ log::alevel::message_payload`
-
-__Default settings__
-
-By default, only debug/development logging is disabled.
-
-### Access to underlying loggers
-
-Logging interfaces may be directly accessed via their associated endpoint or connection using get_alog() and get_elog(). This allows access to methods specific to the chosen logging policy. 
-
-Basic Logging (Default Policy)
-------------------------------
-
-The basic logging policy (`websocketpp::log::basic`) writes logs to a std::ostream. By default, access logs are written to stdout and error logs are written to stderr. Each logging interface may be optionally redirected to an arbitrary C++ stream (including file streams) using the `websocketpp::log::basic::set_ostream()` method.
-
-Syslog Logging
---------------
-
-The syslog logging policy (`websocketpp::log::syslog`) logs to POSIX syslog. It is included in the header `<websocketpp/logger/syslog.hpp>`. It requires a system with `<syslog.h>`.
-
-Stub Logging
-------------
-
-The stub logging policy (`websocketpp::log::stub`) implements the logging policy interface but ignores all input and provides no output. It can be used to stub out the logging system in tests or to completely disable and remove nearly all logging related code. 
-
-The stub logger also provides documentation for the minimal required interface to build a custom logging policy.
-
-Log level reference
--------------------
-
-### Error Logging Levels
-
-Each of these channels is in the namespace `websocketpp::log::elevel`
-
-| Level   | Description                                                                                                                |
-| ------- | -------------------------------------------------------------------------------------------------------------------------- |
-| none    | Special aggregate value representing "no levels"                                                                           |
-| devel   | Low level debugging information (warning: very chatty). Requires debug or custom config.                                   |
-| library | Information about unusual system states or other minor internal library problems, less chatty than devel.                  |
-| info    | Information about minor configuration problems or additional information about other warnings.                             |
-| warn    | Information about important problems not severe enough to terminate connections.                                           |
-| rerror  | Recoverable error. Recovery may mean cleanly closing the connection with an appropriate error code to the remote endpoint. |
-| fatal   | Unrecoverable error. This error will trigger immediate unclean termination of the connection or endpoint.                  |
-| all     | Special aggregate value representing "all levels"                                                                          |
-
-### Access Logging Levels
-
-Each of these channels is in the namespace `websocketpp::log::alevel`
-
-| Level           | Description                                                                                        |
-| --------------- | -------------------------------------------------------------------------------------------------- |
-| none            | Special aggregate value representing "no levels"                                                   |
-| connect         | One line for each new connection that includes a host of information including: the remote address, websocket version, requested resource, http code, remote user agent |
-| disconnect      | One line for each connection that is closed. Includes closing codes and reasons                    |
-| control         | One line per control message                                                                       |
-| frame_header    | One line per frame, includes the full frame header                                                 |
-| frame_payload   | One line per frame, includes the full message payload (warning: lots of output for large messages) |
-| message_header  | Reserved                                                                                           |
-| message_payload | Reserved                                                                                           |
-| endpoint        | Reserved                                                                                           |
-| debug_handshake | Extra information about opening handshakes                                                         |
-| debug_close     | Extra information about closing handshakes                                                         |
-| devel           | Development messages (warning: very chatty). Requires debug or custom config.                      |
-| app             | Special channel for application specific logs. Not used by the library.                            |
-| all             | Special aggregate value representing "all levels"                                                  |
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.css b/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.css
deleted file mode 100644
index 7c40b18..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.css
+++ /dev/null
@@ -1,22 +0,0 @@
-.tabs, .tabs2, .tabs3, .navpath ul {
-    background-image: none;
-    background-color: #333;
-    border: none;
-    border-bottom: 1px solid #575757;
-}
-
-.tablist li, .navpath li {
-    background-image: none;
-    background-color: #333;
-}
-
-.tablist a, .navpath li.navelem a {
-    color: #ccc;
-    text-shadow: 0px 1px 1px black;
-}
-
-.tablist a:hover, .navpath li.navelem a:hover {
-    background-image: none;
-    background-color: #444;
-    color: #ccc;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.dox
deleted file mode 100644
index 2aa5da6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/manual.dox
+++ /dev/null
@@ -1,23 +0,0 @@
-/** \mainpage
-
-WebSocket++ is a C++ library that can be used to implement WebSocket functionality. The goals of the project are to provide a WebSocket implementation that is portable, flexible, lightweight, low level, and high performance.
-
-WebSocket++ does not intend to be used alone as a web application framework or full featured web services platform. As such the components, examples, and performance tuning are geared towards operation as a WebSocket client or server. There are some minimal convenience features that stray from this (for example the ability to respond to HTTP requests other than WebSocket Upgrades) but these are not the focus of the project. In particular WebSocket++ does not intend to implement any non-WebSocket related fallback options (ajax / long polling / comet / etc).
-
-In order to remain compact and improve portability, the WebSocket++ project strives to reduce or eliminate external dependencies where possible and appropriate. WebSocket++ core has no dependencies other than the C++11 standard library. For non-C++11 compilers the Boost libraries provide drop in polyfills for the C++11 functionality used.
-
-WebSocket++ implements a pluggable data transport component. The default component allows reduced functionality by using STL iostream or raw byte shuffling via reading and writing char buffers. This component has no non-STL dependencies and can be used in a C++11 environment without Boost. Also included is an Asio based transport component that provides full featured network client/server functionality. This component requires either Boost Asio or a C++11 compiler and standalone Asio. As an advanced option, WebSocket++ supports custom transport layers if you want to provide your own using another library.
-
-In order to accommodate the wide variety of use cases WebSocket++ has collected, the library is built in a way that most of the major components are loosely coupled and can be swapped out and replaced. WebSocket++ will attempt to track the future development of the WebSocket protocol and any extensions as they are developed.
-
-- \subpage getting_started "Getting Started"
-- \subpage faq "FAQ"
-- \subpage tutorials "Tutorials"
-- \subpage md_changelog "Change Log / Version History"
-- Reference
- - \subpage reference.handlers "Handler Reference"
- - \subpage reference.config "Config Reference"
- - \subpage reference.logging "Logging Reference"
-
-*/
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_broadcast_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_broadcast_server.cpp
deleted file mode 100644
index 955d711..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_broadcast_server.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <set>
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-class broadcast_server {
-public:
-    broadcast_server() {
-        m_server.init_asio();
-                
-        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
-        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
-        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
-    }
-    
-    void on_open(connection_hdl hdl) {
-        m_connections.insert(hdl);
-    }
-    
-    void on_close(connection_hdl hdl) {
-        m_connections.erase(hdl);
-    }
-    
-    void on_message(connection_hdl hdl, server::message_ptr msg) {
-        for (auto it : m_connections) {
-            m_server.send(it,msg);
-        }
-    }
-
-    void run(uint16_t port) {
-        m_server.listen(port);
-        m_server.start_accept();
-        m_server.run();
-    }
-private:
-    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
-
-    server m_server;
-    con_list m_connections;
-};
-
-int main() {
-    broadcast_server server;
-    server.run(9002);
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_count_server_thread.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_count_server_thread.cpp
deleted file mode 100644
index a30af99..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/simple_count_server_thread.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include <functional>
-#include <mutex>
-#include <set>
-#include <thread>
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-
-class count_server {
-public:
-    count_server() : m_count(0) {
-        m_server.init_asio();
-                
-        m_server.set_open_handler(bind(&count_server::on_open,this,_1));
-        m_server.set_close_handler(bind(&count_server::on_close,this,_1));
-    }
-    
-    void on_open(connection_hdl hdl) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_connections.insert(hdl);
-    }
-    
-    void on_close(connection_hdl hdl) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        m_connections.erase(hdl);
-    }
-    
-    void count() {
-        while (1) {
-            sleep(1);
-            m_count++;
-            
-            std::stringstream ss;
-            ss << m_count;
-            
-            std::lock_guard<std::mutex> lock(m_mutex);    
-            for (auto it : m_connections) {
-                m_server.send(it,ss.str(),websocketpp::frame::opcode::text);
-            }
-        }
-    }
-    
-    void run(uint16_t port) {
-        m_server.listen(port);
-        m_server.start_accept();
-        m_server.run();
-    }
-private:
-    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
-    
-    int m_count;
-    server m_server;
-    con_list m_connections;
-    std::mutex m_mutex;
-};
-
-int main() {
-    count_server server;
-    std::thread t(std::bind(&count_server::count,&server));
-    server.run(9002);
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/docs/tutorials.dox b/third_party/socket.io-client-cpp/lib/websocketpp/docs/tutorials.dox
deleted file mode 100644
index 8751e97..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/docs/tutorials.dox
+++ /dev/null
@@ -1,10 +0,0 @@
-/** \page tutorials Tutorials
-
-These tutorials are works in progress, some are more complete than others.
-
-- \subpage md_tutorials_utility_client_utility_client
-- \subpage md_tutorials_utility_server_utility_server
-- \subpage md_tutorials_broadcast_tutorial_broadcast_tutorial
-- \subpage md_tutorials_chat_tutorial_chat_tutorial
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/CMakeLists.txt
deleted file mode 100644
index 2f77e7b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (associative_storage)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/associative_storage.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/associative_storage.cpp
deleted file mode 100644
index 2ac8494..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/associative_storage/associative_storage.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include <iostream>
-#include <map>
-#include <exception>
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-struct connection_data {
-    int sessionid;
-    std::string name;
-};
-
-class print_server {
-public:
-    print_server() : m_next_sessionid(1) {
-        m_server.init_asio();
-
-        m_server.set_open_handler(bind(&print_server::on_open,this,::_1));
-        m_server.set_close_handler(bind(&print_server::on_close,this,::_1));
-        m_server.set_message_handler(bind(&print_server::on_message,this,::_1,::_2));
-    }
-
-    void on_open(connection_hdl hdl) {
-        connection_data data;
-
-        data.sessionid = m_next_sessionid++;
-        data.name.clear();
-
-        m_connections[hdl] = data;
-    }
-
-    void on_close(connection_hdl hdl) {
-        connection_data& data = get_data_from_hdl(hdl);
-
-        std::cout << "Closing connection " << data.name
-                  << " with sessionid " << data.sessionid << std::endl;
-
-        m_connections.erase(hdl);
-    }
-
-    void on_message(connection_hdl hdl, server::message_ptr msg) {
-        connection_data& data = get_data_from_hdl(hdl);
-
-        if (data.name.empty()) {
-            data.name = msg->get_payload();
-            std::cout << "Setting name of connection with sessionid "
-                      << data.sessionid << " to " << data.name << std::endl;
-        } else {
-            std::cout << "Got a message from connection " << data.name
-                      << " with sessionid " << data.sessionid << std::endl;
-        }
-    }
-
-    connection_data& get_data_from_hdl(connection_hdl hdl) {
-        auto it = m_connections.find(hdl);
-
-        if (it == m_connections.end()) {
-            // this connection is not in the list. This really shouldn't happen
-            // and probably means something else is wrong.
-            throw std::invalid_argument("No data available for session");
-        }
-
-        return it->second;
-    }
-
-    void run(uint16_t port) {
-        m_server.listen(port);
-        m_server.start_accept();
-        m_server.run();
-    }
-private:
-    typedef std::map<connection_hdl,connection_data,std::owner_less<connection_hdl>> con_list;
-
-    int m_next_sessionid;
-    server m_server;
-    con_list m_connections;
-};
-
-int main() {
-    print_server server;
-    server.run(9002);
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/CMakeLists.txt
deleted file mode 100644
index 5fb5fe3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (broadcast_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/SConscript
deleted file mode 100644
index 5786f57..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Broadcast Server example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('broadcast_server', ["broadcast_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','thread'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('broadcast_server', ["broadcast_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/broadcast_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/broadcast_server.cpp
deleted file mode 100644
index b02e7cd..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/broadcast_server/broadcast_server.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-#include <websocketpp/config/asio_no_tls.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-#include <set>
-
-/*#include <boost/thread.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition_variable.hpp>*/
-#include <websocketpp/common/thread.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-using websocketpp::lib::thread;
-using websocketpp::lib::mutex;
-using websocketpp::lib::lock_guard;
-using websocketpp::lib::unique_lock;
-using websocketpp::lib::condition_variable;
-
-/* on_open insert connection_hdl into channel
- * on_close remove connection_hdl from channel
- * on_message queue send to all channels
- */
-
-enum action_type {
-    SUBSCRIBE,
-    UNSUBSCRIBE,
-    MESSAGE
-};
-
-struct action {
-    action(action_type t, connection_hdl h) : type(t), hdl(h) {}
-    action(action_type t, connection_hdl h, server::message_ptr m)
-      : type(t), hdl(h), msg(m) {}
-
-    action_type type;
-    websocketpp::connection_hdl hdl;
-    server::message_ptr msg;
-};
-
-class broadcast_server {
-public:
-    broadcast_server() {
-        // Initialize Asio Transport
-        m_server.init_asio();
-
-        // Register handler callbacks
-        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
-        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
-        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
-    }
-
-    void run(uint16_t port) {
-        // listen on specified port
-        m_server.listen(port);
-
-        // Start the server accept loop
-        m_server.start_accept();
-
-        // Start the ASIO io_service run loop
-        try {
-            m_server.run();
-        } catch (const std::exception & e) {
-            std::cout << e.what() << std::endl;
-        }
-    }
-
-    void on_open(connection_hdl hdl) {
-        {
-            lock_guard<mutex> guard(m_action_lock);
-            //std::cout << "on_open" << std::endl;
-            m_actions.push(action(SUBSCRIBE,hdl));
-        }
-        m_action_cond.notify_one();
-    }
-
-    void on_close(connection_hdl hdl) {
-        {
-            lock_guard<mutex> guard(m_action_lock);
-            //std::cout << "on_close" << std::endl;
-            m_actions.push(action(UNSUBSCRIBE,hdl));
-        }
-        m_action_cond.notify_one();
-    }
-
-    void on_message(connection_hdl hdl, server::message_ptr msg) {
-        // queue message up for sending by processing thread
-        {
-            lock_guard<mutex> guard(m_action_lock);
-            //std::cout << "on_message" << std::endl;
-            m_actions.push(action(MESSAGE,hdl,msg));
-        }
-        m_action_cond.notify_one();
-    }
-
-    void process_messages() {
-        while(1) {
-            unique_lock<mutex> lock(m_action_lock);
-
-            while(m_actions.empty()) {
-                m_action_cond.wait(lock);
-            }
-
-            action a = m_actions.front();
-            m_actions.pop();
-
-            lock.unlock();
-
-            if (a.type == SUBSCRIBE) {
-                lock_guard<mutex> guard(m_connection_lock);
-                m_connections.insert(a.hdl);
-            } else if (a.type == UNSUBSCRIBE) {
-                lock_guard<mutex> guard(m_connection_lock);
-                m_connections.erase(a.hdl);
-            } else if (a.type == MESSAGE) {
-                lock_guard<mutex> guard(m_connection_lock);
-
-                con_list::iterator it;
-                for (it = m_connections.begin(); it != m_connections.end(); ++it) {
-                    m_server.send(*it,a.msg);
-                }
-            } else {
-                // undefined.
-            }
-        }
-    }
-private:
-    typedef std::set<connection_hdl,std::owner_less<connection_hdl> > con_list;
-
-    server m_server;
-    con_list m_connections;
-    std::queue<action> m_actions;
-
-    mutex m_action_lock;
-    mutex m_connection_lock;
-    condition_variable m_action_cond;
-};
-
-int main() {
-    try {
-    broadcast_server server_instance;
-
-    // Start a thread to run the processing loop
-    thread t(bind(&broadcast_server::process_messages,&server_instance));
-
-    // Run the asio loop with the main thread
-    server_instance.run(9002);
-
-    t.join();
-
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/CMakeLists.txt
deleted file mode 100644
index 651208a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-if (OPENSSL_FOUND)
-
-init_target (debug_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_openssl()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/SConscript
deleted file mode 100644
index 781db83..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Debug client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env_cpp11.Program('debug_client', ["debug_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env.Program('debug_client', ["debug_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/debug_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/debug_client.cpp
deleted file mode 100644
index d3e9153..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_client/debug_client.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** ====== WARNING ========
- * This example is presently used as a scratch space. It may or may not be broken
- * at any given time.
- */
-
-#include <websocketpp/config/asio_client.hpp>
-
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-#include <chrono>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef websocketpp::config::asio_tls_client::message_type::ptr message_ptr;
-typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
-typedef client::connection_ptr connection_ptr;
-
-
-
-class perftest {
-public:
-    typedef perftest type;
-    typedef std::chrono::duration<int,std::micro> dur_type;
-
-    perftest () {
-        m_endpoint.set_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
-
-        // Initialize ASIO
-        m_endpoint.init_asio();
-
-        // Register our handlers
-        m_endpoint.set_socket_init_handler(bind(&type::on_socket_init,this,::_1));
-        //m_endpoint.set_tls_init_handler(bind(&type::on_tls_init,this,::_1));
-        m_endpoint.set_message_handler(bind(&type::on_message,this,::_1,::_2));
-        m_endpoint.set_open_handler(bind(&type::on_open,this,::_1));
-        m_endpoint.set_close_handler(bind(&type::on_close,this,::_1));
-        m_endpoint.set_fail_handler(bind(&type::on_fail,this,::_1));
-    }
-
-    void start(std::string uri) {
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            m_endpoint.get_alog().write(websocketpp::log::alevel::app,ec.message());
-            return;
-        }
-
-        //con->set_proxy("http://humupdates.uchicago.edu:8443");
-
-        m_endpoint.connect(con);
-
-        // Start the ASIO io_service run loop
-        m_start = std::chrono::high_resolution_clock::now();
-        m_endpoint.run();
-    }
-
-    void on_socket_init(websocketpp::connection_hdl) {
-        m_socket_init = std::chrono::high_resolution_clock::now();
-    }
-
-    context_ptr on_tls_init(websocketpp::connection_hdl) {
-        m_tls_init = std::chrono::high_resolution_clock::now();
-        context_ptr ctx = websocketpp::lib::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::tlsv1);
-
-        try {
-            ctx->set_options(boost::asio::ssl::context::default_workarounds |
-                             boost::asio::ssl::context::no_sslv2 |
-                             boost::asio::ssl::context::no_sslv3 |
-                             boost::asio::ssl::context::single_dh_use);
-        } catch (std::exception& e) {
-            std::cout << e.what() << std::endl;
-        }
-        return ctx;
-    }
-
-    void on_fail(websocketpp::connection_hdl hdl) {
-        client::connection_ptr con = m_endpoint.get_con_from_hdl(hdl);
-        
-        std::cout << "Fail handler" << std::endl;
-        std::cout << con->get_state() << std::endl;
-        std::cout << con->get_local_close_code() << std::endl;
-        std::cout << con->get_local_close_reason() << std::endl;
-        std::cout << con->get_remote_close_code() << std::endl;
-        std::cout << con->get_remote_close_reason() << std::endl;
-        std::cout << con->get_ec() << " - " << con->get_ec().message() << std::endl;
-    }
-
-    void on_open(websocketpp::connection_hdl hdl) {
-        m_open = std::chrono::high_resolution_clock::now();
-        m_endpoint.send(hdl, "", websocketpp::frame::opcode::text);
-    }
-    void on_message(websocketpp::connection_hdl hdl, message_ptr) {
-        m_message = std::chrono::high_resolution_clock::now();
-        m_endpoint.close(hdl,websocketpp::close::status::going_away,"");
-    }
-    void on_close(websocketpp::connection_hdl) {
-        m_close = std::chrono::high_resolution_clock::now();
-
-        std::cout << "Socket Init: " << std::chrono::duration_cast<dur_type>(m_socket_init-m_start).count() << std::endl;
-        std::cout << "TLS Init: " << std::chrono::duration_cast<dur_type>(m_tls_init-m_start).count() << std::endl;
-        std::cout << "Open: " << std::chrono::duration_cast<dur_type>(m_open-m_start).count() << std::endl;
-        std::cout << "Message: " << std::chrono::duration_cast<dur_type>(m_message-m_start).count() << std::endl;
-        std::cout << "Close: " << std::chrono::duration_cast<dur_type>(m_close-m_start).count() << std::endl;
-    }
-private:
-    client m_endpoint;
-
-    std::chrono::high_resolution_clock::time_point m_start;
-    std::chrono::high_resolution_clock::time_point m_socket_init;
-    std::chrono::high_resolution_clock::time_point m_tls_init;
-    std::chrono::high_resolution_clock::time_point m_open;
-    std::chrono::high_resolution_clock::time_point m_message;
-    std::chrono::high_resolution_clock::time_point m_close;
-};
-
-int main(int argc, char* argv[]) {
-    std::string uri = "wss://echo.websocket.org";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-    try {
-        perftest endpoint;
-        endpoint.start(uri);
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    } catch (std::exception const & e) {
-        std::cout << e.what() << std::endl;
-    } catch (...) {
-        std::cout << "other exception" << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/CMakeLists.txt
deleted file mode 100644
index d134d31..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (debug_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/SConscript
deleted file mode 100644
index 4d02261..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Debug server example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('debug_server', ["debug_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('debug_server', ["debug_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/debug_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/debug_server.cpp
deleted file mode 100644
index 8d1ff0e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/debug_server/debug_server.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** ====== WARNING ========
- * This example is presently used as a scratch space. It may or may not be broken
- * at any given time.
- */
-
-#include <websocketpp/config/debug_asio_no_tls.hpp>
-
-// Custom logger
-#include <websocketpp/logger/syslog.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-
-////////////////////////////////////////////////////////////////////////////////
-///////////////// Custom Config for debugging custom policies //////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-struct debug_custom : public websocketpp::config::debug_asio {
-    typedef debug_custom type;
-    typedef debug_asio base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    /// Custom Logging policies
-    /*typedef websocketpp::log::syslog<concurrency_type,
-        websocketpp::log::elevel> elog_type;
-    typedef websocketpp::log::syslog<concurrency_type,
-        websocketpp::log::alevel> alog_type;
-    */
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-    
-    static const long timeout_open_handshake = 0;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-typedef websocketpp::server<debug_custom> server;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef server::message_ptr message_ptr;
-
-bool validate(server *, websocketpp::connection_hdl) {
-    //sleep(6);
-    return true;
-}
-
-void on_http(server* s, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    std::string res = con->get_request_body();
-
-    std::stringstream ss;
-    ss << "got HTTP request with " << res.size() << " bytes of body data.";
-
-    con->set_body(ss.str());
-    con->set_status(websocketpp::http::status_code::ok);
-}
-
-void on_fail(server* s, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-    
-    std::cout << "Fail handler: " << con->get_ec() << " " << con->get_ec().message()  << std::endl;
-}
-
-void on_close(websocketpp::connection_hdl) {
-    std::cout << "Close handler" << std::endl;
-}
-
-// Define a callback to handle incoming messages
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: " 
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-int main() {
-    // Create a server endpoint
-    server echo_server;
-
-    try {
-        // Set logging settings
-        echo_server.set_access_channels(websocketpp::log::alevel::all);
-        echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
-
-        // Initialize ASIO
-        echo_server.init_asio();
-        echo_server.set_reuse_addr(true);
-
-        // Register our message handler
-        echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
-
-        echo_server.set_http_handler(bind(&on_http,&echo_server,::_1));
-        echo_server.set_fail_handler(bind(&on_fail,&echo_server,::_1));
-        echo_server.set_close_handler(&on_close);
-
-        echo_server.set_validate_handler(bind(&validate,&echo_server,::_1));
-
-        // Listen on port 9012
-        echo_server.listen(9012);
-
-        // Start the server accept loop
-        echo_server.start_accept();
-
-        // Start the ASIO io_service run loop
-        echo_server.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    } catch (const std::exception & e) {
-        std::cout << e.what() << std::endl;
-    } catch (...) {
-        std::cout << "other exception" << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/CMakeLists.txt
deleted file mode 100644
index f820c6b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-#init_target (dev)
-
-#build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-#link_boost ()
-#final_target ()
-
-#set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/SConscript
deleted file mode 100644
index 34ddac2..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/SConscript
+++ /dev/null
@@ -1,18 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system','timer','chrono'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('main', ["main.cpp"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/main.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/main.cpp
deleted file mode 100644
index 79d7bf1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/dev/main.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-//#ifndef _WEBSOCKETPP_CPP11_STL_
-//    #define _WEBSOCKETPP_CPP11_STL_
-//#endif
-
-#include <random>
-#include <boost/timer/timer.hpp>
-
-#include <websocketpp/config/core.hpp>
-
-//#include <websocketpp/security/none.hpp>
-
-//#include <websocketpp/concurrency/none.hpp>
-//#include <websocketpp/concurrency/stl.hpp>
-
-//#include <websocketpp/transport/iostream.hpp>
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-#include <sstream>
-
-//typedef websocketpp::concurrency::stl concurrency;
-//typedef websocketpp::transport::iostream<concurrency> transport;
-//typedef websocketpp::server<concurrency,transport> server;
-typedef websocketpp::server<websocketpp::config::core> server;
-
-/*class handler : public server::handler {
-    bool validate(connection_ptr con) {
-        std::cout << "handler validate" << std::endl;
-        if (con->get_origin() != "http://www.example.com") {
-            con->set_status(websocketpp::http::status_code::FORBIDDEN);
-            return false;
-        }
-        return true;
-    }
-
-    void http(connection_ptr con) {
-        std::cout << "handler http" << std::endl;
-    }
-
-    void on_load(connection_ptr con, ptr old_handler) {
-        std::cout << "handler on_load" << std::endl;
-    }
-    void on_unload(connection_ptr con, ptr new_handler) {
-        std::cout << "handler on_unload" << std::endl;
-    }
-
-    void on_open(connection_ptr con) {
-        std::cout << "handler on_open" << std::endl;
-    }
-    void on_fail(connection_ptr con) {
-        std::cout << "handler on_fail" << std::endl;
-    }
-
-    void on_message(connection_ptr con, message_ptr msg) {
-        std::cout << "handler on_message" << std::endl;
-
-
-    }
-
-    void on_close(connection_ptr con) {
-        std::cout << "handler on_close" << std::endl;
-    }
-};*/
-
-int main() {
-    typedef websocketpp::message_buffer::message<websocketpp::message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_man_type;
-
-    con_msg_man_type::ptr manager = websocketpp::lib::make_shared<con_msg_man_type>();
-
-    size_t foo = 1024;
-
-    message_type::ptr input = manager->get_message(websocketpp::frame::opcode::TEXT,foo);
-    message_type::ptr output = manager->get_message(websocketpp::frame::opcode::TEXT,foo);
-    websocketpp::frame::masking_key_type key;
-
-    std::random_device dev;
-
-
-
-    key.i = 0x12345678;
-
-    double m = 18094238402394.0824923;
-
-    /*std::cout << "Some Math" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        for (int i = 0; i < foo; i++) {
-            m /= 1.001;
-        }
-
-    }*/
-
-    std::cout << m << std::endl;
-
-    std::cout << "Random Gen" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        input->get_raw_payload().replace(0,foo,foo,'\0');
-        output->get_raw_payload().replace(0,foo,foo,'\0');
-    }
-
-    std::cout << "Out of place accelerated" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        websocketpp::frame::word_mask_exact(reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), reinterpret_cast<uint8_t*>(const_cast<char*>(output->get_raw_payload().data())), foo, key);
-    }
-
-    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
-    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
-
-    input->get_raw_payload().replace(0,foo,foo,'\0');
-    output->get_raw_payload().replace(0,foo,foo,'\0');
-
-    std::cout << "In place accelerated" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        websocketpp::frame::word_mask_exact(reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), reinterpret_cast<uint8_t*>(const_cast<char*>(input->get_raw_payload().data())), foo, key);
-    }
-
-    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
-    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
-
-    input->get_raw_payload().replace(0,foo,foo,'\0');
-    output->get_raw_payload().replace(0,foo,foo,'\0');
-    std::cout << "Out of place byte by byte" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        websocketpp::frame::byte_mask(input->get_raw_payload().begin(), input->get_raw_payload().end(), output->get_raw_payload().begin(), key);
-    }
-
-    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
-    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
-
-    input->get_raw_payload().replace(0,foo,foo,'\0');
-    output->get_raw_payload().replace(0,foo,foo,'\0');
-    std::cout << "In place byte by byte" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        websocketpp::frame::byte_mask(input->get_raw_payload().begin(), input->get_raw_payload().end(), input->get_raw_payload().begin(), key);
-    }
-
-    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
-    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
-
-    input->get_raw_payload().replace(0,foo,foo,'a');
-    output->get_raw_payload().replace(0,foo,foo,'b');
-    std::cout << "Copy" << std::endl;
-    {
-        boost::timer::auto_cpu_timer t;
-
-        std::copy(input->get_raw_payload().begin(), input->get_raw_payload().end(), output->get_raw_payload().begin());
-    }
-
-    std::cout << websocketpp::utility::to_hex(input->get_payload().c_str(),20) << std::endl;
-    std::cout << websocketpp::utility::to_hex(output->get_payload().c_str(),20) << std::endl;
-
-    /*server::handler::ptr h(new handler());
-
-    server test_server(h);
-    server::connection_ptr con;
-
-    std::stringstream output;
-
-    test_server.register_ostream(&output);
-
-    con = test_server.get_connection();
-
-    con->start();
-
-    //foo.handle_accept(con,true);
-
-    std::stringstream input;
-    input << "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    //input << "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-    input >> *con;
-
-    std::stringstream input2;
-    input2 << "messageabc2";
-    input2 >> *con;
-
-    std::stringstream input3;
-    input3 << "messageabc3";
-    input3 >> *con;
-
-    std::stringstream input4;
-    input4 << "close";
-    input4 >> *con;
-
-    std::cout << "connection output:" << std::endl;
-    std::cout << output.str() << std::endl;*/
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/CMakeLists.txt
deleted file mode 100644
index 1fdf39e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (echo_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/SConscript
deleted file mode 100644
index 0e41108..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## echo_client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env_cpp11.Program('echo_client', ["echo_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env.Program('echo_client', ["echo_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/echo_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/echo_client.cpp
deleted file mode 100644
index 59af661..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_client/echo_client.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2016, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
-
-// This message handler will be invoked once for each incoming message. It
-// prints the message and then sends a copy of the message back to the server.
-void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-
-    websocketpp::lib::error_code ec;
-
-    c->send(hdl, msg->get_payload(), msg->get_opcode(), ec);
-    if (ec) {
-        std::cout << "Echo failed because: " << ec.message() << std::endl;
-    }
-}
-
-int main(int argc, char* argv[]) {
-    // Create a client endpoint
-    client c;
-
-    std::string uri = "ws://localhost:9002";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-    try {
-        // Set logging to be pretty verbose (everything except message payloads)
-        c.set_access_channels(websocketpp::log::alevel::all);
-        c.clear_access_channels(websocketpp::log::alevel::frame_payload);
-
-        // Initialize ASIO
-        c.init_asio();
-
-        // Register our message handler
-        c.set_message_handler(bind(&on_message,&c,::_1,::_2));
-
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = c.get_connection(uri, ec);
-        if (ec) {
-            std::cout << "could not create connection because: " << ec.message() << std::endl;
-            return 0;
-        }
-
-        // Note that connect here only requests a connection. No network messages are
-        // exchanged until the event loop starts running in the next line.
-        c.connect(con);
-
-        // Start the ASIO io_service run loop
-        // this will cause a single connection to be made to the server. c.run()
-        // will exit when this connection is closed.
-        c.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/CMakeLists.txt
deleted file mode 100644
index a48be52..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (echo_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/SConscript
deleted file mode 100644
index a297885..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('echo_server', ["echo_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('echo_server', ["echo_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_handler.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_handler.hpp
deleted file mode 100644
index f55b867..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_handler.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2012, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP
-#define WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP
-
-class echo_handler : public server::handler {
-    void on_message(connection_ptr con, std::string msg) {
-        con->write(msg);
-    }
-};
-
-#endif // WEBSOCKETPP_ECHO_SERVER_HANDLER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_server.cpp
deleted file mode 100644
index d234009..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server/echo_server.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#include <websocketpp/config/asio_no_tls.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef server::message_ptr message_ptr;
-
-// Define a callback to handle incoming messages
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-    // check for a special command to instruct the server to stop listening so
-    // it can be cleanly exited.
-    if (msg->get_payload() == "stop-listening") {
-        s->stop_listening();
-        return;
-    }
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: "
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-int main() {
-    // Create a server endpoint
-    server echo_server;
-
-    try {
-        // Set logging settings
-        echo_server.set_access_channels(websocketpp::log::alevel::all);
-        echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
-
-        // Initialize Asio
-        echo_server.init_asio();
-
-        // Register our message handler
-        echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
-
-        // Listen on port 9002
-        echo_server.listen(9002);
-
-        // Start the server accept loop
-        echo_server.start_accept();
-
-        // Start the ASIO io_service run loop
-        echo_server.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    } catch (...) {
-        std::cout << "other exception" << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/CMakeLists.txt
deleted file mode 100644
index 83c50dc..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-
-if (OPENSSL_FOUND)
-
-init_target (echo_server_both)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_openssl()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/SConscript
deleted file mode 100644
index d1ecf20..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Combo plain+tls echo server
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env_cpp11.Program('echo_server_both', ["echo_server_both.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env.Program('echo_server_both', ["echo_server_both.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/echo_server_both.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/echo_server_both.cpp
deleted file mode 100644
index 2c2c4ea..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/echo_server_both.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <websocketpp/config/asio.hpp>
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-
-// define types for two different server endpoints, one for each config we are
-// using
-typedef websocketpp::server<websocketpp::config::asio> server_plain;
-typedef websocketpp::server<websocketpp::config::asio_tls> server_tls;
-
-// alias some of the bind related functions as they are a bit long
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// type of the ssl context pointer is long so alias it
-typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
-
-// The shared on_message handler takes a template parameter so the function can
-// resolve any endpoint dependent types like message_ptr or connection_ptr
-template <typename EndpointType>
-void on_message(EndpointType* s, websocketpp::connection_hdl hdl,
-    typename EndpointType::message_ptr msg)
-{
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: "
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-// No change to TLS init methods from echo_server_tls
-std::string get_password() {
-    return "test";
-}
-
-context_ptr on_tls_init(websocketpp::connection_hdl hdl) {
-    std::cout << "on_tls_init called with hdl: " << hdl.lock().get() << std::endl;
-    context_ptr ctx(new boost::asio::ssl::context(boost::asio::ssl::context::tlsv1));
-
-    try {
-        ctx->set_options(boost::asio::ssl::context::default_workarounds |
-                         boost::asio::ssl::context::no_sslv2 |
-                         boost::asio::ssl::context::no_sslv3 |
-                         boost::asio::ssl::context::single_dh_use);
-        ctx->set_password_callback(bind(&get_password));
-        ctx->use_certificate_chain_file("server.pem");
-        ctx->use_private_key_file("server.pem", boost::asio::ssl::context::pem);
-    } catch (std::exception& e) {
-        std::cout << e.what() << std::endl;
-    }
-    return ctx;
-}
-
-int main() {
-    // set up an external io_service to run both endpoints on. This is not
-    // strictly necessary, but simplifies thread management a bit.
-    boost::asio::io_service ios;
-
-    // set up plain endpoint
-    server_plain endpoint_plain;
-    // initialize asio with our external io_service rather than an internal one
-    endpoint_plain.init_asio(&ios);
-    endpoint_plain.set_message_handler(
-        bind(&on_message<server_plain>,&endpoint_plain,::_1,::_2));
-    endpoint_plain.listen(80);
-    endpoint_plain.start_accept();
-
-    // set up tls endpoint
-    server_tls endpoint_tls;
-    endpoint_tls.init_asio(&ios);
-    endpoint_tls.set_message_handler(
-        bind(&on_message<server_tls>,&endpoint_tls,::_1,::_2));
-    // TLS endpoint has an extra handler for the tls init
-    endpoint_tls.set_tls_init_handler(bind(&on_tls_init,::_1));
-    // tls endpoint listens on a different port
-    endpoint_tls.listen(443);
-    endpoint_tls.start_accept();
-
-    // Start the ASIO io_service run loop running both endpoints
-    ios.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/server.pem b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/server.pem
deleted file mode 100644
index 9f679a4..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_both/server.pem
+++ /dev/null
@@ -1,58 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,A0ED66EF872A48A9
-
-gXuvKojXzApVhhPVNdRliiajbC4PtwQG5c8TA7JADLgwOR7o9t6KtXEr37bDRpvB
-9aO9P+SJaK5OOp3XKPGthOdqv+tvCRTlmzmC8GjPLBX389DWT2xoGu7JkGwDtdSm
-rnF49Rlp5bfjpACk5xKNiKeDo1CWfeEJzw9Kto0g+5eMaEdors64oPzjXs3geA2g
-TxCJSHv9qSX6++pCLKKCUTbyzidAxV/Zb0AAubt5V40QKqX4HhSwwstFnTaX3tlb
-3QOdY+y04VIkM6d7qN5W8M7NzRkMpZ1qBpQcUMpkhQcRzWP2wub5AAff9D2GntRd
-4Dz1vn3u41U3Okdr0CNj+iH7byCzuokoAhk6ZQEN6WB+GTpGgfBXdtUZrfpb0MKm
-UNYP5AF2AmUqJRXhViTDVtu/V2tHF3LGuNT+W2Dz+spFZEq0byEO0N858eR0dikc
-6jOASvNQbSwD0+mkgBC1gXKKU3ngj2gpJUwljeACdWFd8N2egrZfyI05CmX7vPNC
-NXbs7k2buWNdjP4/D8IM+HDVidWzQa/kG/qokXKqllem9Egg37lUucwnP3cX2/Hw
-U2mfaBWzeZtqc+GqRp08rYIql+Reai3sUYlQMnNk01prVY47UQb+dxuqjaxGV5Xx
-Xkx0s2mfQnNRjL4S7Hjhqelufi6GpkCQ2EGsPpA+6K1ztZ0ame9Q2BE1SXeM/6vU
-rxT5nRrCxueyXAyQSGcqMX9//gSeK8WWBqG/c1IAMVDa0NWrJeOJhSziE+ta3B0m
-bHAPBY6vh0iB3lLdRlbUOPbC6R1TpxMOs+6Vbs2+OTifFpvOVymEoZq/nroyg68P
-vn5uCKogwWA7o8EArf/UTlIwWJmH9bgILdZKld4wMel2HQg16RDzm+mEXAJi52a/
-FC+fgfphdxltmUJ+rqOyR4AHULjaTWUQqTIB6sdlzgmES1nXAiE71zX//KFqomar
-O60SPPk3C1bs0x5DsvmGJa8SIfDhyd+D7NPyqwEKqrZsaotYGklNkfqxa6pa8mrc
-ejxquW1PK4FvBk26+osu5a90Jih0PcQM7DUMMr2WHdTiMSXWAiK2ToYF8Itt25Qv
-Cd0CsSYw9CJkXNr1u1+mObheaY9QYOmztnSJLy4ZO2JsMhqNwuAueIcwmhXOREq7
-kzlnGMgJcuSeAS/OBNj8Zgx0c7QQ0kzc+YmnOCsqoMtPsu/CsXJ4iJiM3Tki/2jT
-bywrTiQwE6R3a/87GREOREX+WLicZBWX3k9/4tBL5XSe1p5wPpuIRQUDvAGNfNHP
-JN7kujDF4SehilF1qtvCygAwvxHFDj+EwhXKNDKJzoZZIM15rAk3k92n2j6nz1qH
-a3xOU05yydOlO6F6w51I1QoDddmkzCRNB0TeO3D6rekHsCK1aDWmC+qRcm2ZFtVz
-sY6fdZN2NEmMQokIh9Opi1f8CSYSizPESMzdu2SF0xVO9n/IGIkn1ksK04O2BZo0
-X3LBPHLfCRsQNY1eF17bj07fYU2oPZKs/XzJiwxkqK6LFvpeAVaYrtg9fqRO/UVe
-QhUIj3BL550ocEpa15xLehLrmwzYiW5zwGjSHQ4EgZluGLCwyKGTh4QswEJRA9Rt
------END RSA PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIE0DCCA7igAwIBAgIJAM5MuKJezXq0MA0GCSqGSIb3DQEBBQUAMIGgMQswCQYD
-VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xGDAW
-BgNVBAoTD1phcGhveWQgU3R1ZGlvczEUMBIGA1UECxMLV2ViU29ja2V0KysxFjAU
-BgNVBAMTDVBldGVyIFRob3Jzb24xJDAiBgkqhkiG9w0BCQEWFXdlYm1hc3RlckB6
-YXBob3lkLmNvbTAeFw0xMTExMTUyMTIwMDZaFw0xMjExMTQyMTIwMDZaMIGgMQsw
-CQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28x
-GDAWBgNVBAoTD1phcGhveWQgU3R1ZGlvczEUMBIGA1UECxMLV2ViU29ja2V0Kysx
-FjAUBgNVBAMTDVBldGVyIFRob3Jzb24xJDAiBgkqhkiG9w0BCQEWFXdlYm1hc3Rl
-ckB6YXBob3lkLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANR0
-tdwAnIB8I9qRZ7QbzEWY95RpM7GIn0u/9oH90PzdHiE0rXSkKT+yw3XUzH0iw5t0
-5dEwSC+srSP5Vm4cA6kXc94agVVaPW89tGcdP4fHptCruSrzQsDXELCPl5UUvMpA
-YUcGisdXYPN/EeOoqb9wKWxoW5mREsyyeWWS89fYN5qU/d0QpbSvEWghqLbL/ZS2
-hOlXT9LufOeA+vHiV1/T/h5xC7ecIH02YDQw1EnqxbPmkLPcWThztLS9FiufNDRM
-Rhcoaj2b9VDHvDwdbeA0T5v5qNdG34LaapYOelxzQMOtM0f9Dgqehodyxl2qm9mR
-lq432dlOEzDnVCPNHwECAwEAAaOCAQkwggEFMB0GA1UdDgQWBBTTPKfNMnKOykhv
-+vKS7vql5JsMyzCB1QYDVR0jBIHNMIHKgBTTPKfNMnKOykhv+vKS7vql5JsMy6GB
-pqSBozCBoDELMAkGA1UEBhMCVVMxETAPBgNVBAgTCElsbGlub2lzMRAwDgYDVQQH
-EwdDaGljYWdvMRgwFgYDVQQKEw9aYXBob3lkIFN0dWRpb3MxFDASBgNVBAsTC1dl
-YlNvY2tldCsrMRYwFAYDVQQDEw1QZXRlciBUaG9yc29uMSQwIgYJKoZIhvcNAQkB
-FhV3ZWJtYXN0ZXJAemFwaG95ZC5jb22CCQDOTLiiXs16tDAMBgNVHRMEBTADAQH/
-MA0GCSqGSIb3DQEBBQUAA4IBAQB+SH0s/hrv5VYqgX6SNLzxdSLvCVsUkCdTpxwY
-wOJ84XmYcXDMhKDtZqLtOtN6pfEwVusFlC9mkieuunztCnWNmsSG83RuljJPjFSi
-1d4Id4bKEQkQ4cfnjoHKivRrViWLnxuNnLzC6tpyGH/35kKWhhr6T58AXerFgVw3
-mHvLPTr1DuhdAZA0ZuvuseVAFFAjI3RetSySwHJE3ak8KswDVfLi6E3XxMVsIWTS
-/iFsC2WwoZQlljya2V/kRYIhu+uCdqJ01wunn2BvmURPSgr4GTBF0FQ9JGpNbXxM
-TAU7oQJgyFc5sCcuEgPTO0dWVQTvdZVgay4tkmduKDRkmJBF
------END CERTIFICATE-----
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/CMakeLists.txt
deleted file mode 100644
index 99f0c14..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-
-if (OPENSSL_FOUND)
-
-init_target (echo_server_tls)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_openssl()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/SConscript
deleted file mode 100644
index e24cc4c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env_cpp11.Program('echo_server_tls', ["echo_server_tls.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env.Program('echo_server_tls', ["echo_server_tls.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/dh.pem b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/dh.pem
deleted file mode 100644
index 6b1c74d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/dh.pem
+++ /dev/null
@@ -1,8 +0,0 @@
------BEGIN DH PARAMETERS-----
-MIIBCAKCAQEAqxMGKZB8YNV8WQnbJWwwwmifc+PfVRtd1FN5v5aQSsf6dpjX3Zlh
-N1NmgecsQyg4u2EWe4Umta10QzCgYaxf6QdTCg7iprLzFNw7IvWYbQ6du12NMGDr
-hmwA6KQKwbTgPL6mSlSlcK2wTP2FzxDTNffFu10cB/6Fj4kdQjPG0c1Koz/z7OOq
-BuDElJLClS8rjp3z1xvrc7gX95dFa2KaKgOAYDkpe8tfHRhHfJeIVS/whH9hzx6r
-OBg+E5K9JyvayrUoKgPeptRKCqo8A4YevtMLpRxMup0nMUgAIv6+BGTwPAFpwgl/
-8UIVcvjh1v95PwGDM/Q8yvIBJznBYk/e2wIBAg==
------END DH PARAMETERS-----
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/echo_server_tls.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/echo_server_tls.cpp
deleted file mode 100644
index 3d704f5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/echo_server_tls.cpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
- /**
-  * NOTES
-  *
-  * This example uses a number of standard classes through the websocketpp::lib
-  * namespace. This is to allow easy switching between Boost, the C++11 STL, and 
-  * the standalone Asio library. Your program need not use these namespaces if
-  * you do not need this sort of flexibility.
-  */
-
-#include <websocketpp/config/asio.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-
-typedef websocketpp::server<websocketpp::config::asio_tls> server;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef websocketpp::config::asio::message_type::ptr message_ptr;
-typedef websocketpp::lib::shared_ptr<websocketpp::lib::asio::ssl::context> context_ptr;
-
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: "
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-void on_http(server* s, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-    
-    con->set_body("Hello World!");
-    con->set_status(websocketpp::http::status_code::ok);
-}
-
-std::string get_password() {
-    return "test";
-}
-
-// See https://wiki.mozilla.org/Security/Server_Side_TLS for more details about
-// the TLS modes. The code below demonstrates how to implement both the modern
-enum tls_mode {
-    MOZILLA_INTERMEDIATE = 1,
-    MOZILLA_MODERN = 2
-};
-
-context_ptr on_tls_init(tls_mode mode, websocketpp::connection_hdl hdl) {
-    namespace asio = websocketpp::lib::asio;
-
-    std::cout << "on_tls_init called with hdl: " << hdl.lock().get() << std::endl;
-    std::cout << "using TLS mode: " << (mode == MOZILLA_MODERN ? "Mozilla Modern" : "Mozilla Intermediate") << std::endl;
-
-    context_ptr ctx = websocketpp::lib::make_shared<asio::ssl::context>(asio::ssl::context::sslv23);
-
-    try {
-        if (mode == MOZILLA_MODERN) {
-            // Modern disables TLSv1
-            ctx->set_options(asio::ssl::context::default_workarounds |
-                             asio::ssl::context::no_sslv2 |
-                             asio::ssl::context::no_sslv3 |
-                             asio::ssl::context::no_tlsv1 |
-                             asio::ssl::context::single_dh_use);
-        } else {
-            ctx->set_options(asio::ssl::context::default_workarounds |
-                             asio::ssl::context::no_sslv2 |
-                             asio::ssl::context::no_sslv3 |
-                             asio::ssl::context::single_dh_use);
-        }
-        ctx->set_password_callback(bind(&get_password));
-        ctx->use_certificate_chain_file("server.pem");
-        ctx->use_private_key_file("server.pem", asio::ssl::context::pem);
-        
-        // Example method of generating this file:
-        // `openssl dhparam -out dh.pem 2048`
-        // Mozilla Intermediate suggests 1024 as the minimum size to use
-        // Mozilla Modern suggests 2048 as the minimum size to use.
-        ctx->use_tmp_dh_file("dh.pem");
-        
-        std::string ciphers;
-        
-        if (mode == MOZILLA_MODERN) {
-            ciphers = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK";
-        } else {
-            ciphers = "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA";
-        }
-        
-        if (SSL_CTX_set_cipher_list(ctx->native_handle() , ciphers.c_str()) != 1) {
-            std::cout << "Error setting cipher list" << std::endl;
-        }
-    } catch (std::exception& e) {
-        std::cout << "Exception: " << e.what() << std::endl;
-    }
-    return ctx;
-}
-
-int main() {
-    // Create a server endpoint
-    server echo_server;
-
-    // Initialize ASIO
-    echo_server.init_asio();
-
-    // Register our message handler
-    echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
-    echo_server.set_http_handler(bind(&on_http,&echo_server,::_1));
-    echo_server.set_tls_init_handler(bind(&on_tls_init,MOZILLA_INTERMEDIATE,::_1));
-
-    // Listen on port 9002
-    echo_server.listen(9002);
-
-    // Start the server accept loop
-    echo_server.start_accept();
-
-    // Start the ASIO io_service run loop
-    echo_server.run();
-
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/server.pem b/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/server.pem
deleted file mode 100644
index da233f5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/echo_server_tls/server.pem
+++ /dev/null
@@ -1,57 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDMYjHlTUeUGSys
-Fz5PZcvgS3gojBlEAOu2gXFQDcJ7kq6dJ4jKsPaH1Q5jAtEDkU/el8otzfacOgyp
-2ZxioRimpmcORWGU0bKJcenh4ZQ1oK1CQObjeYk1YgE7H8/sBetSdtL4n1rB8LIz
-AV/k6kwSZFu3/lSmc6g09H4efSKGKVBcVOjBamcvFGVH4KhM2NyL+ffeV5H2Ucxk
-ipyhpr4uxEoC3EV60sQxloqZb+upBM0LS4kVvaYMcn39XkUx3Z8FwN5+hFGwsWda
-tU8zDxEuRMrZxG7mwDXLBGehtQvoJIVMQbOuwBQcgAbsVyy1dxV3aczbLX0iGEuG
-eBhdFE+BAgMBAAECggEAQaPn0nUXYAEVz89HO8i9ybNzS9Jy6txA18SK1+MTawyY
-9/AShsZ+5vEORc5JwpOQyzSEwmE7qsEaABLbnvGOMTeQMY0m4dzXMj1bmCgSqYaJ
-HpYpkTUfU/2913dIF81u3nU7HI5RX6gmEyuF2MdG10FUE6ujFDJg+2DqgHA//kYD
-hkXFinVS2PuZs8d5xdzpF0aCIWTuOc+Fgsyhdm/lZRIzFdID45YUVuPIN2uh+GkM
-ENp/r1x7dPlDRqiL1ufP0mTQGs26S5kQSF8W0BClkOIOgmrhSON4+Vqhqx+ki/7w
-RY+7mmgdvt0uzYT+Lk2cDw4f89Rsh7rR1EieBpQ2YQKBgQDq6zAHWfweJmkugT0w
-HzI0UKfcOdzlJBwMu6tSgSHU99dnXlTwQY8sG7vtfRekokoo7XY4JsSk1n6E9OVy
-4UKuEvU1+llDGxtvHxEEGOAgwB8wxMuY4uNYgDVhTlUzr2ERcet7FOIGzxEWzSsg
-5vgnTQfyMzAh5/6k8CsHVI4u2wKBgQDeuYVCgg555lcc5rvTFxfU15d3fweSd78+
-akgIBaXAlFbxI+5znGPmKG/ii4N2XObC8B568fA2nIxw6M1xgbKyvvmN3ECYiqWv
-bx8x6Vg5Slg0vJr+DrPgvIKbOWEEKF/cfpTeeVLP0gUBT63mA3qezuRx1r0JJr7A
-k9a4Td9j0wKBgDmRQMfMaVgKGaRnz1LHkkn3qerx0wvj+Wu1YZpqQpwp0ANovm/R
-4P/yG+9qxCx4CKxW5K2F8pJibcavLLsmMGzwAF8l5lHnhqWIe2cBoYrlCb+tuibR
-Et1RLcOWqpJr2+GmhQo4Z9s7SvjHdlYtw4n9+oCDwrvMWj6ZDDJTqjQZAoGAEhRt
-RODZ2/texvHT/Wa6gISfvwuIydL+q0plXoFW2zMve5O3H5tqYJyXuIQqv8j60og7
-cS+CmGxM2j2Lr9MfdnMaPvHKLJfUq1ER7zNJ/hyS3HUS/9yhrXSgBYm63mOIpJWB
-8C1ZE5Ww4lJdg3Z01b9lu/f6kGucwHU/0OZBZBECgYAQ+dl2kKKd+lQ9O/LVz7oD
-goQMPYF+QZcEhY4vlYKkWVtR2A0CiY6XeTi6vO/qVUt/ht+UO3XIJFOjGV1VyORQ
-Bhibfstxl5s59jGlns5y5QqcRKzCiX74BKG0xQUtHgga7Od6L+GJKbJAPBfncYwW
-U7Tfwwi0WbbgQoy5Xr/5gg==
------END PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIFBTCCAu2gAwIBAgICEAEwDQYJKoZIhvcNAQELBQAwgYIxCzAJBgNVBAYTAlVT
-MQswCQYDVQQIDAJJTDEUMBIGA1UECgwLV2ViU29ja2V0KysxKjAoBgNVBAsMIVdl
-YlNvY2tldCsrIENlcnRpZmljYXRlIEF1dGhvcml0eTEkMCIGA1UEAwwbV2ViU29j
-a2V0KysgSW50ZXJtZWRpYXRlIENBMB4XDTE2MDYwODEyNDUxMloXDTI2MDYwNjEy
-NDUxMlowfjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAklMMRAwDgYDVQQHDAdDaGlj
-YWdvMRQwEgYDVQQKDAtXZWJTb2NrZXQrKzEgMB4GA1UECwwXV2ViU29ja2V0Kysg
-VExTIEV4YW1wbGUxGDAWBgNVBAMMD3dlYnNvY2tldHBwLm9yZzCCASIwDQYJKoZI
-hvcNAQEBBQADggEPADCCAQoCggEBAMxiMeVNR5QZLKwXPk9ly+BLeCiMGUQA67aB
-cVANwnuSrp0niMqw9ofVDmMC0QORT96Xyi3N9pw6DKnZnGKhGKamZw5FYZTRsolx
-6eHhlDWgrUJA5uN5iTViATsfz+wF61J20vifWsHwsjMBX+TqTBJkW7f+VKZzqDT0
-fh59IoYpUFxU6MFqZy8UZUfgqEzY3Iv5995XkfZRzGSKnKGmvi7ESgLcRXrSxDGW
-iplv66kEzQtLiRW9pgxyff1eRTHdnwXA3n6EUbCxZ1q1TzMPES5EytnEbubANcsE
-Z6G1C+gkhUxBs67AFByABuxXLLV3FXdpzNstfSIYS4Z4GF0UT4ECAwEAAaOBhzCB
-hDALBgNVHQ8EBAMCBDAwEwYDVR0lBAwwCgYIKwYBBQUHAwEwYAYDVR0RBFkwV4IP
-d2Vic29ja2V0cHAub3JnghN3d3cud2Vic29ja2V0cHAub3Jnghl1dGlsaXRpZXMu
-d2Vic29ja2V0cHAub3JnghRkb2NzLndlYnNvY2tldHBwLm9yZzANBgkqhkiG9w0B
-AQsFAAOCAgEAelJvIWFikBU3HVoP0icuoezTHGqABPLCeooTC/GELq7lHCFEjiqW
-p96Zc3vrk+0Z0tkYy3E0fpuzPtlTUhBzO3fMF41FpB5ix3W/tH9YJvrozlIuDD1I
-IEusxomeeiMRbyYpX/gkSOO74ylCzMEQVzleMNdpzpeXOg0Kp5z2JNShdEoT7eMR
-qkJQJjMdL6QeXUqWNvX1Zqb8v6VeWGWjuu/cl374P8D8bjn89VwZQ5HFqoLOhI5v
-XEYsMViZWwLSMcfWTU2Rdi0RxUZQVciLP/3GQROR1/0/e1J1kd7GsRWQMZcU20Vy
-jXBVAiWhW1bgd0XOrrFILsAmnBtinEJiE+h5UC4ksZtwWf9x1IhXGlpb9bmD4+Ud
-93wmqytPXBFL6wwlj4IYjjy0gU6xP6h7nwhHXnBlwFWGDpe8Cco9qgyJxJxBTtj9
-MbBv+BSLXJoniDASdk6RIqCjPWZtWbQ7j5mIKV0bdJQZpBX553QOy8AoIpJE32An
-FzR0SSCHOCgSAbqtM8CvLO6mquEJunmwKQx6xfos5N6ee+D+JtUFTw04TrjZUzFs
-Z7v3SN/N4Hd13iTBDSu4XY/tJYICvTRLYNrzQRh/XEVbEEVxXhL8rxNn5aL1pqrV
-yEnvHXrnSXWxTif1K+hS2HfTkQ6d1GjglvmwkoBqBHuRH0OJ1VguTqM=
------END CERTIFICATE-----
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/CMakeLists.txt
deleted file mode 100644
index 78fa7d2..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (enriched_storage)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/enriched_storage.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/enriched_storage.cpp
deleted file mode 100644
index fb23319..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/enriched_storage/enriched_storage.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <iostream>
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-struct connection_data {
-    int sessionid;
-    std::string name;
-};
-
-struct custom_config : public websocketpp::config::asio {
-    // pull default settings from our core config
-    typedef websocketpp::config::asio core;
-    
-    typedef core::concurrency_type concurrency_type;
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-    typedef core::rng_type rng_type;
-    typedef core::transport_type transport_type;
-    typedef core::endpoint_base endpoint_base;
-    
-    // Set a custom connection_base class
-    typedef connection_data connection_base;
-};
-
-typedef websocketpp::server<custom_config> server;
-typedef server::connection_ptr connection_ptr;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-class print_server {
-public:
-    print_server() : m_next_sessionid(1) {
-        m_server.init_asio();
-                
-        m_server.set_open_handler(bind(&print_server::on_open,this,::_1));
-        m_server.set_close_handler(bind(&print_server::on_close,this,::_1));
-        m_server.set_message_handler(bind(&print_server::on_message,this,::_1,::_2));
-    }
-    
-    void on_open(connection_hdl hdl) {
-        connection_ptr con = m_server.get_con_from_hdl(hdl);
-        
-        con->sessionid = m_next_sessionid++;
-    }
-    
-    void on_close(connection_hdl hdl) {
-        connection_ptr con = m_server.get_con_from_hdl(hdl);
-        
-        std::cout << "Closing connection " << con->name 
-                  << " with sessionid " << con->sessionid << std::endl;
-    }
-    
-    void on_message(connection_hdl hdl, server::message_ptr msg) {
-        connection_ptr con = m_server.get_con_from_hdl(hdl);
-        
-        if (con->name.empty()) {
-            con->name = msg->get_payload();
-            std::cout << "Setting name of connection with sessionid " 
-                      << con->sessionid << " to " << con->name << std::endl;
-        } else {
-            std::cout << "Got a message from connection " << con->name 
-                      << " with sessionid " << con->sessionid << std::endl;
-        }
-    }
-    
-    void run(uint16_t port) {
-        m_server.listen(port);
-        m_server.start_accept();
-        m_server.run();
-    }
-private:
-    int m_next_sessionid;
-    server m_server;
-};
-
-int main() {
-    print_server server;
-    server.run(9002);
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/CMakeLists.txt
deleted file mode 100644
index 5223da1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (external_io_service)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/SConscript
deleted file mode 100644
index beb7c1c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('external_io_service', ["external_io_service.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('external_io_service', ["external_io_service.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/external_io_service.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/external_io_service.cpp
deleted file mode 100644
index 7372d59..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/external_io_service.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "tcp_echo_server.hpp"
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-typedef websocketpp::server<websocketpp::config::asio> ws_echo_server;
-
-// Define a callback to handle incoming messages
-void on_message(ws_echo_server* s, websocketpp::connection_hdl hdl, ws_echo_server::message_ptr msg) {
-    std::cout << "on_message called with hdl: " << hdl.lock().get()
-              << " and message: " << msg->get_payload()
-              << std::endl;
-
-    // check for a special command to instruct the server to stop listening so
-    // it can be cleanly exited.
-    if (msg->get_payload() == "stop-listening") {
-        s->stop_listening();
-        return;
-    }
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: "
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-int main() {
-    asio::io_service service;
-
-    // Add a TCP echo server on port 9003
-    tcp_echo_server custom_http_server(service, 9003);
-
-    // Add a WebSocket echo server on port 9002
-    ws_echo_server ws_server;
-    ws_server.set_access_channels(websocketpp::log::alevel::all);
-    ws_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
-
-    // The only difference in this code between an internal and external
-    // io_service is the different constructor to init_asio
-    ws_server.init_asio(&service);
-
-    // Register our message handler
-    ws_server.set_message_handler(bind(&on_message,&ws_server,::_1,::_2));
-    ws_server.listen(9002);
-    ws_server.start_accept();
-
-    // TODO: add a timer?
-
-    // Start the Asio io_service run loop for all
-    service.run();
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/tcp_echo_server.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/tcp_echo_server.hpp
deleted file mode 100644
index ef4ce18..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/external_io_service/tcp_echo_server.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
- 
-/**
- * TCP Echo Server
- *
- * This file defines a simple TCP Echo Server. It is adapted from the Asio
- * example: cpp03/echo/async_tcp_echo_server.cpp
- */ 
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/functional.hpp>
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-namespace asio = websocketpp::lib::asio;
-
-struct tcp_echo_session : websocketpp::lib::enable_shared_from_this<tcp_echo_session> {
-    typedef websocketpp::lib::shared_ptr<tcp_echo_session> ptr;
-    
-    tcp_echo_session(asio::io_service & service) : m_socket(service) {}
-
-    void start() {
-        m_socket.async_read_some(asio::buffer(m_buffer, sizeof(m_buffer)),
-            websocketpp::lib::bind(
-                &tcp_echo_session::handle_read, shared_from_this(), _1, _2));
-    }
-    
-    void handle_read(const asio::error_code & ec, size_t transferred) {
-        if (!ec) {
-            asio::async_write(m_socket,
-                asio::buffer(m_buffer, transferred),
-                    bind(&tcp_echo_session::handle_write, shared_from_this(), _1));
-        }
-    }
-    
-    void handle_write(const asio::error_code & ec) {
-        if (!ec) {
-            m_socket.async_read_some(asio::buffer(m_buffer, sizeof(m_buffer)),
-                bind(&tcp_echo_session::handle_read, shared_from_this(), _1, _2));
-        }
-    }
-
-    asio::ip::tcp::socket m_socket;
-    char m_buffer[1024];
-};
-
-struct tcp_echo_server {
-    tcp_echo_server(asio::io_service & service, short port)
-        : m_service(service)
-        , m_acceptor(service, asio::ip::tcp::endpoint(asio::ip::tcp::v6(), port))
-    {
-        this->start_accept();
-    }
-    
-    void start_accept() {
-        tcp_echo_session::ptr new_session(new tcp_echo_session(m_service));
-        m_acceptor.async_accept(new_session->m_socket,
-            bind(&tcp_echo_server::handle_accept, this, new_session, _1));
-    }
-    
-    void handle_accept(tcp_echo_session::ptr new_session, const asio::error_code & ec) {
-        if (!ec) {
-            new_session->start();
-        }
-        start_accept();
-    }
-
-    asio::io_service & m_service;
-    asio::ip::tcp::acceptor m_acceptor;
-};
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/CMakeLists.txt
deleted file mode 100644
index 45917d5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (handler_switch)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/handler_switch.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/handler_switch.cpp
deleted file mode 100644
index c2cf6ff..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/handler_switch/handler_switch.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <iostream>
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-using websocketpp::lib::ref;
-
-void custom_on_msg(server & s, connection_hdl hdl, server::message_ptr msg) {
-        std::cout << "Message sent to custom handler" << std::endl;
-}
-
-void default_on_msg(server & s, connection_hdl hdl, server::message_ptr msg) {
-    std::cout << "Message sent to default handler" << std::endl;
-
-    if (msg->get_payload() == "upgrade") {
-        // Upgrade our connection_hdl to a full connection_ptr
-        server::connection_ptr con = s.get_con_from_hdl(hdl);
-
-        // Change the on message handler for this connection only to
-        // custom_on_mesage
-        con->set_message_handler(bind(&custom_on_msg,ref(s),::_1,::_2));
-        std::cout << "Upgrading connection to custom handler" << std::endl;
-    }
-}
-
-int main() {
-    server s;
-
-    s.set_message_handler(bind(&default_on_msg,ref(s),::_1,::_2));
-
-    s.init_asio();
-    s.listen(9002);
-    s.start_accept();
-
-    s.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/CMakeLists.txt
deleted file mode 100644
index 962d909..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (iostream_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/SConscript
deleted file mode 100644
index dc90834..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## iostream server example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('iostream_server', ["iostream_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('iostream_server', ["iostream_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/iostream_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/iostream_server.cpp
deleted file mode 100644
index 4fc5c1d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/iostream_server/iostream_server.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <websocketpp/config/core.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <iostream>
-#include <fstream>
-
-typedef websocketpp::server<websocketpp::config::core> server;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef server::message_ptr message_ptr;
-
-// Define a callback to handle incoming messages
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    if (msg->get_opcode() == websocketpp::frame::opcode::text) {
-        s->get_alog().write(websocketpp::log::alevel::app,
-                    "Text Message Received: "+msg->get_payload());
-    } else {
-        s->get_alog().write(websocketpp::log::alevel::app,
-                    "Binary Message Received: "+websocketpp::utility::to_hex(msg->get_payload()));
-    }
-
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        s->get_alog().write(websocketpp::log::alevel::app,
-                    std::string("Echo Failed: ")+e.what());
-    }
-}
-
-int main() {
-    server s;
-    std::ofstream log;
-
-    try {
-        // set up access channels to only log interesting things
-        s.clear_access_channels(websocketpp::log::alevel::all);
-        s.set_access_channels(websocketpp::log::alevel::connect);
-        s.set_access_channels(websocketpp::log::alevel::disconnect);
-        s.set_access_channels(websocketpp::log::alevel::app);
-
-        // Log to a file rather than stdout, as we are using stdout for real
-        // output
-        log.open("output.log");
-        s.get_alog().set_ostream(&log);
-        s.get_elog().set_ostream(&log);
-
-        // print all output to stdout
-        s.register_ostream(&std::cout);
-
-        // Register our message handler
-        s.set_message_handler(bind(&on_message,&s,::_1,::_2));
-
-        server::connection_ptr con = s.get_connection();
-
-        con->start();
-
-        // C++ iostream's don't support the idea of asynchronous i/o. As such
-        // there are two input strategies demonstrated here. Buffered I/O will
-        // read from stdin in chunks until EOF. This works very well for
-        // replaying canned connections as would be done in automated testing.
-        //
-        // If the server is being used live however, assuming input is being
-        // piped from elsewhere in realtime, this strategy will result in small
-        // messages being buffered forever. The non-buffered strategy below
-        // reads characters from stdin one at a time. This is inefficient and
-        // for more serious uses should be replaced with a platform specific
-        // asyncronous i/o technique like select, poll, IOCP, etc
-        bool buffered_io = false;
-
-        if (buffered_io) {
-            std::cin >> *con;
-            con->eof();
-        } else {
-            char a;
-            while(std::cin.get(a)) {
-                con->read_some(&a,1);
-            }
-            con->eof();
-        }
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-    log.close();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/CMakeLists.txt
deleted file mode 100644
index 98b975a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (print_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/SConscript
deleted file mode 100644
index 8da4ce5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Print client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('print_client', ["print_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('print_client', ["print_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/print_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/print_client.cpp
deleted file mode 100644
index 7ba6e5f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client/print_client.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2016, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
-	std::cout << msg->get_payload() << std::endl;
-}
-
-int main(int argc, char* argv[]) {
-    client c;
-
-    std::string uri = "ws://localhost:9002";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-	try {
-        // Set logging to be pretty verbose (everything except message payloads)
-        c.set_access_channels(websocketpp::log::alevel::all);
-        c.clear_access_channels(websocketpp::log::alevel::frame_payload);
-        c.set_error_channels(websocketpp::log::elevel::all);
-
-        // Initialize ASIO
-        c.init_asio();
-
-        // Register our message handler
-        c.set_message_handler(&on_message);
-
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = c.get_connection(uri, ec);
-        if (ec) {
-            std::cout << "could not create connection because: " << ec.message() << std::endl;
-            return 0;
-        }
-
-        // Note that connect here only requests a connection. No network messages are
-        // exchanged until the event loop starts running in the next line.
-        c.connect(con);
-
-        // Start the ASIO io_service run loop
-        // this will cause a single connection to be made to the server. c.run()
-        // will exit when this connection is closed.
-        c.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/CMakeLists.txt
deleted file mode 100644
index 18ea753..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-if (OPENSSL_FOUND)
-
-init_target (print_client_tls)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_openssl()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/SConscript
deleted file mode 100644
index 01b0114..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Print client tls example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env_cpp11.Program('print_client_tls', ["print_client_tls.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env.Program('print_client_tls', ["print_client_tls.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/ca-chain.cert.pem b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/ca-chain.cert.pem
deleted file mode 100644
index 12e233b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/ca-chain.cert.pem
+++ /dev/null
@@ -1,66 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFxTCCA62gAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwYDELMAkGA1UEBhMCVVMx
-CzAJBgNVBAgMAklMMRAwDgYDVQQHDAdDaGljYWdvMRQwEgYDVQQKDAtXZWJTb2Nr
-ZXQrKzEcMBoGA1UEAwwTV2ViU29ja2V0KysgUm9vdCBDQTAeFw0xNjA1MjUxMzU4
-MjdaFw0yNjA1MjMxMzU4MjdaMIGCMQswCQYDVQQGEwJVUzELMAkGA1UECAwCSUwx
-FDASBgNVBAoMC1dlYlNvY2tldCsrMSowKAYDVQQLDCFXZWJTb2NrZXQrKyBDZXJ0
-aWZpY2F0ZSBBdXRob3JpdHkxJDAiBgNVBAMMG1dlYlNvY2tldCsrIEludGVybWVk
-aWF0ZSBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMNaFAzlx0KJ
-gG15yRHI3xn9+B1woHG4uuOr124Sk1JllPcO3enusgIYTMl0FiYYW9CsyPoe4L0P
-wflbz20vDDjxmXG+NPgjuYmnPaq7q2JXYz+cShv9+o60EIwEIe+EWk1ZQs9YSdQ0
-r4UOxGVq6eEuWJi8Wh02cbnxdjwvrk7lTMFVY+z5EX8cCj6Tbrd0lyIf/0X8OkOb
-q2HOqqzTgT2apBCWCEW6grW6rtMOoDx93BOZDBEGz39sJ5i8AQ8XIdYCdUcOMdJU
-SCAw/MMyFTHXhv8hJdG5GcDSfc7woB9xRUf8UHuCH0nYkTb260TWvyDCYJy001ko
-SWoRbh2hVgPqQ9FTDMzMTY8T8C5u3BRfGN5PHuSPhwfHv/p1g4uPnltDBe4CNtOs
-wu8w1wbrr3uI7qETnqOzbXlcT7o4rCrrRQqLbNOssf2mMH+Phq6dINjXpZjiAhO0
-SURtBMmQdAZcQkGStzFitEkb2Py5LEIxQ068i8RCowTyD9+/jbO1fZyxJ4X8TDUe
-Xx48xWnu0i4f8/9ldnWLwX9h3ilaZVsr7buNYJoMlz+v73TQoWKSybJ2SMe/Cddj
-OZCy5r1UakuZhX6n1ScD/hbO8FEfmQRpAywYajyU4dZ9XMbf5bo6OAUqlJ2f4yYh
-VAy5mi1JHfD5PiJN90j79GXXvtBTJc4hAgMBAAGjZjBkMB0GA1UdDgQWBBTKMn5O
-3NUPpztL1bAz8UCsOBLpkjAfBgNVHSMEGDAWgBTNBBKZQN694xplMGyMruXFv27o
-eTASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B
-AQsFAAOCAgEAyNkZUEAdP73th4/RLu0d2foMiIqKlcvw3JsW0tto3MT5lvQ5UugH
-OwluhWhnMLE0KsknQd7/p4ZwyZugWAYjGcDydp0GDIDfNBBEOQkOAL23KkYiRFqt
-VPBTZi9S7P2MJLY0j94liIg94nikhz/0q7JxxWFlvSHUjwZxXrbFjfZRPOS1vIq/
-/VK2QjUsdIXE3NOPYfQwd9FpG2YS8ZcMeipwNYVAs2FBEeWzGH1j6i2hP8FFBDYP
-0LTvJYOJvlCeyIvPBjKk9461/Z4CPJcKtKC59onQmiqSK/Juak/bpPoY7jJ228KG
-bEBzClIEHgbDiBewFTHbyOWhW2ySRLOGsPeqKDSbm4J1N5rfKnrSQB9PfOmWoRfJ
-vqPlXFSlpdgD4j/WnEumpvt78fT+cn+AkRG8tE5DQrCWZTK47TSWn902Fm0A19Rl
-pSbE9qsulXurOqEuOOayrzcUmbZ/jkU+wj+/tN4Gl8K98WbjcXvwz0sRL3SgRRrI
-awUdaGWKQHrTJNEOTisepUAuHVDmvuQz0j/Ru+PbB9K3GcKY6X6+o1c2JBC1V6KX
-aHHZQ+xPm+VEa1pG/QVHGpt2AbGUQlXwDYtOIRwEhO27tFbH8Q68s2cMLYjsF5gd
-MWuMYCPkFv10/V2f2lAIPSEzw2pldIGERcb4VG4xuD0qU+HH/aAID7k=
------END CERTIFICATE-----
------BEGIN CERTIFICATE-----
-MIIFpjCCA46gAwIBAgIJAL42eqbfw976MA0GCSqGSIb3DQEBCwUAMGAxCzAJBgNV
-BAYTAlVTMQswCQYDVQQIDAJJTDEQMA4GA1UEBwwHQ2hpY2FnbzEUMBIGA1UECgwL
-V2ViU29ja2V0KysxHDAaBgNVBAMME1dlYlNvY2tldCsrIFJvb3QgQ0EwHhcNMTYw
-NTI1MTM1MTUzWhcNMzYwNTIwMTM1MTUzWjBgMQswCQYDVQQGEwJVUzELMAkGA1UE
-CAwCSUwxEDAOBgNVBAcMB0NoaWNhZ28xFDASBgNVBAoMC1dlYlNvY2tldCsrMRww
-GgYDVQQDDBNXZWJTb2NrZXQrKyBSb290IENBMIICIjANBgkqhkiG9w0BAQEFAAOC
-Ag8AMIICCgKCAgEA4QjJ0v5yri+pAN67I/XPz88D8oIczCW96CIuwc44aDC9Kptb
-9iY8xwbGCyQsFZ/1IQ74QfnXZSwq8EwedcBIdcyHdBu6qtNkCVKeDIZAMBef6Hx+
-tWSe1op3sDbUlT8NHiTxZCZWk/2/yIi8yPzQTi4y1vF04vvrQS5RFomCz17kdyOa
-NdxO5p+I4afdoVKtzA1aHoBqdTe7vzM3eww4AxKfgIEDdIuOGDiglI/b/frlwiOi
-SfTOsPzu52TOPW2d1Ad5BG4GuMpnTUOVnc8j18w9LdeXO0J10oVyCmwiPuzFCcDB
-g1xvVr5TXzIZ5J+qlso7+mUfZGH+nxOT7Tc78o1EvX6JbfQAI2PrpcksmJfFnN4l
-4XnXDW/eKl8AlLUr/cW5axAfql4QHJoBCZcfYldQpMoL5R1ikLtY53cOJpycFoWm
-1IEfkLBZ4C1old+KoaErG0+Aur8/kwAJGMnmMvZqGZ5pgXtVipOLy5TKuS6ZKO8g
-MRzalaF/naiu3pF+/sctaqkAPvOr65WrANNGxTQ93ePdyuT6sOEUKXxaXcTtAOOM
-5FCgX8dPxkOACxTrxppvb+bYmYL9GIuYDGYxSRu3Fm+04eXIh+uCqcuWPQuRPc5t
-VXvk/M0fPaJvKfP6lRAoE5Dp4qPRvL6tRVtOXfP6d+O+yGnxRoLKAW7ejoMCAwEA
-AaNjMGEwHQYDVR0OBBYEFM0EEplA3r3jGmUwbIyu5cW/buh5MB8GA1UdIwQYMBaA
-FM0EEplA3r3jGmUwbIyu5cW/buh5MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
-BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQAQ4eY4LhW795wl9XuDVg2vOFTYmIS0
-OxrunFX4f3RjddbIbXzYmQ0cJ8pJ5l7eGYcg/DYQRY4Tk6LjXMs9VhIU10akqLS4
-qGE+Bmp3Jhu5NxZbKkY+k+kTAA1LYxFCjGjSV0v5QNLFULDAmGer2zWwU5DcDwwq
-8yWyBuI974UyE/49/TeckfqwBrb90LL2lFEwoL86XZK2IZMPyMBC/S1X5P/Kc15Q
-d8lwOPS5AirFkkrzs/px+mRia5U1uWKIPRLq9Medvjf8HR8SFWq9eRtkxiLaWyRv
-HBVyVRKCubCZR8psVLK/zrF+Bc+Hr9aAi3TuqTKjIOI7hrq5oJcJpebZDNoBIqoj
-kab13WcRwG+BQvuK1CEkd1aq8Nh2GX6Reb2Zv82/WntgP1a0sztbIGgrUBYQryb5
-HF79v4e2byY613SiQ3lz+g/AWxaZsYH80/Zl+hEwEtU4fFz34Jcv9Kvda1JpknBT
-Fi63ugfoNeNriO02AReMmDvuBG3X8RF1UQyBoTU3uZuW7X26MizEjiVCK9qaOLED
-WDSEoyKLe4JKd387CVlsCY8K/6fBlFTI/hJhggDz8pZFj3n2irUI44kjgOmoxOrW
-JY2jgY89AEMN9yOKkyQGara8pF9IJxTQ7jurYnWcUbompWeybJRwvWN0h+tGV+bd
-l/aq/5LwL3fVpg==
------END CERTIFICATE-----
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/print_client_tls.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/print_client_tls.cpp
deleted file mode 100644
index 469d9c6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_client_tls/print_client_tls.cpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/*
- * Copyright (c) 2016, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/config/asio_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-
-typedef websocketpp::client<websocketpp::config::asio_tls_client> client;
-typedef websocketpp::lib::shared_ptr<websocketpp::lib::asio::ssl::context> context_ptr;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
-    std::cout << msg->get_payload() << std::endl;
-}
-
-/// Verify that one of the subject alternative names matches the given hostname
-bool verify_subject_alternative_name(const char * hostname, X509 * cert) {
-    STACK_OF(GENERAL_NAME) * san_names = NULL;
-    
-    san_names = (STACK_OF(GENERAL_NAME) *) X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
-    if (san_names == NULL) {
-        return false;
-    }
-    
-    int san_names_count = sk_GENERAL_NAME_num(san_names);
-    
-    bool result = false;
-    
-    for (int i = 0; i < san_names_count; i++) {
-        const GENERAL_NAME * current_name = sk_GENERAL_NAME_value(san_names, i);
-        
-        if (current_name->type != GEN_DNS) {
-            continue;
-        }
-        
-        char const * dns_name = (char const *) ASN1_STRING_get0_data(current_name->d.dNSName);
-        
-        // Make sure there isn't an embedded NUL character in the DNS name
-        if (ASN1_STRING_length(current_name->d.dNSName) != strlen(dns_name)) {
-            break;
-        }
-        // Compare expected hostname with the CN
-        result = (strcasecmp(hostname, dns_name) == 0);
-    }
-    sk_GENERAL_NAME_pop_free(san_names, GENERAL_NAME_free);
-    
-    return result;
-}
-
-/// Verify that the certificate common name matches the given hostname
-bool verify_common_name(char const * hostname, X509 * cert) {
-    // Find the position of the CN field in the Subject field of the certificate
-    int common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name(cert), NID_commonName, -1);
-    if (common_name_loc < 0) {
-        return false;
-    }
-    
-    // Extract the CN field
-    X509_NAME_ENTRY * common_name_entry = X509_NAME_get_entry(X509_get_subject_name(cert), common_name_loc);
-    if (common_name_entry == NULL) {
-        return false;
-    }
-    
-    // Convert the CN field to a C string
-    ASN1_STRING * common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
-    if (common_name_asn1 == NULL) {
-        return false;
-    }
-    
-    char const * common_name_str = (char const *) ASN1_STRING_get0_data(common_name_asn1);
-    
-    // Make sure there isn't an embedded NUL character in the CN
-    if (ASN1_STRING_length(common_name_asn1) != strlen(common_name_str)) {
-        return false;
-    }
-    
-    // Compare expected hostname with the CN
-    return (strcasecmp(hostname, common_name_str) == 0);
-}
-
-/**
- * This code is derived from examples and documentation found ato00po
- * http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/example/cpp03/ssl/client.cpp
- * and
- * https://github.com/iSECPartners/ssl-conservatory
- */
-bool verify_certificate(const char * hostname, bool preverified, boost::asio::ssl::verify_context& ctx) {
-    // The verify callback can be used to check whether the certificate that is
-    // being presented is valid for the peer. For example, RFC 2818 describes
-    // the steps involved in doing this for HTTPS. Consult the OpenSSL
-    // documentation for more details. Note that the callback is called once
-    // for each certificate in the certificate chain, starting from the root
-    // certificate authority.
-
-    // Retrieve the depth of the current cert in the chain. 0 indicates the
-    // actual server cert, upon which we will perform extra validation
-    // (specifically, ensuring that the hostname matches. For other certs we
-    // will use the 'preverified' flag from Asio, which incorporates a number of
-    // non-implementation specific OpenSSL checking, such as the formatting of
-    // certs and the trusted status based on the CA certs we imported earlier.
-    int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle());
-
-    // if we are on the final cert and everything else checks out, ensure that
-    // the hostname is present on the list of SANs or the common name (CN).
-    if (depth == 0 && preverified) {
-        X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
-        
-        if (verify_subject_alternative_name(hostname, cert)) {
-            return true;
-        } else if (verify_common_name(hostname, cert)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    return preverified;
-}
-
-/// TLS Initialization handler
-/**
- * WebSocket++ core and the Asio Transport do not handle TLS context creation
- * and setup. This callback is provided so that the end user can set up their
- * TLS context using whatever settings make sense for their application.
- *
- * As Asio and OpenSSL do not provide great documentation for the very common
- * case of connect and actually perform basic verification of server certs this
- * example includes a basic implementation (using Asio and OpenSSL) of the
- * following reasonable default settings and verification steps:
- *
- * - Disable SSLv2 and SSLv3
- * - Load trusted CA certificates and verify the server cert is trusted.
- * - Verify that the hostname matches either the common name or one of the
- *   subject alternative names on the certificate.
- *
- * This is not meant to be an exhaustive reference implimentation of a perfect
- * TLS client, but rather a reasonable starting point for building a secure
- * TLS encrypted WebSocket client.
- *
- * If any TLS, Asio, or OpenSSL experts feel that these settings are poor
- * defaults or there are critically missing steps please open a GitHub issue
- * or drop a line on the project mailing list.
- *
- * Note the bundled CA cert ca-chain.cert.pem is the CA cert that signed the
- * cert bundled with echo_server_tls. You can use print_client_tls with this
- * CA cert to connect to echo_server_tls as long as you use /etc/hosts or
- * something equivilent to spoof one of the names on that cert 
- * (websocketpp.org, for example).
- */
-context_ptr on_tls_init(const char * hostname, websocketpp::connection_hdl) {
-    context_ptr ctx = websocketpp::lib::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);
-
-    try {
-        ctx->set_options(boost::asio::ssl::context::default_workarounds |
-                         boost::asio::ssl::context::no_sslv2 |
-                         boost::asio::ssl::context::no_sslv3 |
-                         boost::asio::ssl::context::single_dh_use);
-
-
-        ctx->set_verify_mode(boost::asio::ssl::verify_peer);
-        ctx->set_verify_callback(bind(&verify_certificate, hostname, ::_1, ::_2));
-
-        // Here we load the CA certificates of all CA's that this client trusts.
-        ctx->load_verify_file("ca-chain.cert.pem");
-    } catch (std::exception& e) {
-        std::cout << e.what() << std::endl;
-    }
-    return ctx;
-}
-
-int main(int argc, char* argv[]) {
-    client c;
-
-    std::string hostname = "localhost";
-    std::string port = "9002";
-
-
-    if (argc == 3) {
-        hostname = argv[1];
-        port = argv[2];
-    } else {
-        std::cout << "Usage: print_server_tls <hostname> <port>" << std::endl;
-        return 1;
-    }
-    
-    std::string uri = "wss://" + hostname + ":" + port;
-
-    try {
-        // Set logging to be pretty verbose (everything except message payloads)
-        c.set_access_channels(websocketpp::log::alevel::all);
-        c.clear_access_channels(websocketpp::log::alevel::frame_payload);
-        c.set_error_channels(websocketpp::log::elevel::all);
-
-        // Initialize ASIO
-        c.init_asio();
-
-        // Register our message handler
-        c.set_message_handler(&on_message);
-        c.set_tls_init_handler(bind(&on_tls_init, hostname.c_str(), ::_1));
-
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = c.get_connection(uri, ec);
-        if (ec) {
-            std::cout << "could not create connection because: " << ec.message() << std::endl;
-            return 0;
-        }
-
-        // Note that connect here only requests a connection. No network messages are
-        // exchanged until the event loop starts running in the next line.
-        c.connect(con);
-
-        c.get_alog().write(websocketpp::log::alevel::app, "Connecting to " + uri);
-
-        // Start the ASIO io_service run loop
-        // this will cause a single connection to be made to the server. c.run()
-        // will exit when this connection is closed.
-        c.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/CMakeLists.txt
deleted file mode 100644
index 32c6e0f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (print_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/SConscript
deleted file mode 100644
index 4f0e492..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Print server example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('print_server', ["print_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('print_server', ["print_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/print_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/print_server.cpp
deleted file mode 100644
index 5f6f444..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/print_server/print_server.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <iostream>
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-void on_message(websocketpp::connection_hdl, server::message_ptr msg) {
-        std::cout << msg->get_payload() << std::endl;
-}
-
-int main() {
-    server print_server;
-
-    print_server.set_message_handler(&on_message);
-    print_server.set_access_channels(websocketpp::log::alevel::all);
-    print_server.set_error_channels(websocketpp::log::elevel::all);
-
-    print_server.init_asio();
-    print_server.listen(9002);
-    print_server.start_accept();
-
-    print_server.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/SConscript
deleted file mode 100644
index 6e7b2ef..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Scratch client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   prgs += env_cpp11.Program('scratch_client', ["scratch_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('utility_client', ["utility_client.cpp"], LIBS = ALL_LIBS)
-   
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/scratch_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/scratch_client.cpp
deleted file mode 100644
index a6a1fbc..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_client/scratch_client.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-    
-    void on_close(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Closed";
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        std::stringstream s;
-        s << "close code: " << con->get_remote_close_code() << " (" 
-          << websocketpp::close::status::get_string(con->get_remote_close_code()) 
-          << "), close reason: " << con->get_remote_close_reason();
-        m_error_reason = s.str();
-    }
-
-    websocketpp::connection_hdl get_hdl() const {
-        return m_hdl;
-    }
-    
-    int get_id() const {
-        return m_id;
-    }
-    
-    std::string get_status() const {
-        return m_status;
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason);
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
-    }
-
-    ~websocket_endpoint() {
-        m_endpoint.stop_perpetual();
-        
-        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
-            if (it->second->get_status() != "Open") {
-                // Only close open connections
-                continue;
-            }
-            
-            std::cout << "> Closing connection " << it->second->get_id() << std::endl;
-            
-            websocketpp::lib::error_code ec;
-            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
-            if (ec) {
-                std::cout << "> Error closing connection " << it->second->get_id() << ": "  
-                          << ec.message() << std::endl;
-            }
-        }
-        
-        m_thread->join();
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr(new connection_metadata(new_id, con->get_handle(), uri));
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_close_handler(websocketpp::lib::bind(
-            &connection_metadata::on_close,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    void close(int id, websocketpp::close::status::value code, std::string reason) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
-        if (ec) {
-            std::cout << "> Error initiating close: " << ec.message() << std::endl;
-        }
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,5) == "close") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            int close_code = websocketpp::close::status::normal;
-            std::string reason;
-            
-            ss >> cmd >> id >> close_code;
-            std::getline(ss,reason);
-            
-            endpoint.close(id, close_code, reason);
-        }  else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/SConscript
deleted file mode 100644
index bf90f74..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## Scratch server example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs] + ['z']
-   prgs += env_cpp11.Program('scratch_server', ["scratch_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','regex','random'],env) + [platform_libs] + [polyfill_libs] + [tls_libs] + ['z']
-   prgs += env.Program('scratch_server', ["scratch_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/scratch_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/scratch_server.cpp
deleted file mode 100644
index 901ae8e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/scratch_server/scratch_server.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/**
- * This example is presently used as a scratch space. It may or may not be broken
- * at any given time.
- */
-
-#include <iostream>
-
-#include <websocketpp/config/debug_asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-struct deflate_config : public websocketpp::config::debug_core {
-    typedef deflate_config type;
-    typedef debug_core base;
-    
-    typedef base::concurrency_type concurrency_type;
-    
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-    
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-    
-    typedef base::rng_type rng_type;
-    
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint 
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config> 
-        transport_type;
-        
-    /// permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::server<deflate_config> server;
-
-typedef server::message_ptr message_ptr;
-
-// Define a callback to handle incoming messages
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    /*std::cout << "on_message called with hdl: " << hdl.lock().get() 
-              << " and message (" << msg->get_payload().size() << "): " << msg->get_payload()
-              << std::endl;
-    */
-    try {
-        s->send(hdl, msg->get_payload(), msg->get_opcode());
-    } catch (websocketpp::exception const & e) {
-        std::cout << "Echo failed because: " 
-                  << "(" << e.what() << ")" << std::endl;
-    }
-}
-
-int main(int argc, char * argv[]) {
-	// Create a server endpoint
-    server echo_server;
-	
-	try {
-        // Set logging settings        
-        if (argc > 1 && std::string(argv[1]) == "-d") {
-            echo_server.set_access_channels(websocketpp::log::alevel::all);
-            echo_server.set_error_channels(websocketpp::log::elevel::all);
-        } else {
-            echo_server.set_access_channels(websocketpp::log::alevel::none);
-            echo_server.set_error_channels(websocketpp::log::elevel::none);
-        }
-        
-        // Initialize ASIO
-        echo_server.init_asio();
-        
-        // Register our message handler
-        using websocketpp::lib::placeholders::_1;
-        using websocketpp::lib::placeholders::_2;
-        echo_server.set_message_handler(bind(&on_message,&echo_server,_1,_2));
-        
-        // Listen on port 9002
-        echo_server.listen(9002);
-        
-        // Start the server accept loop
-        echo_server.start_accept();
-	    
-	    // Start the ASIO io_service run loop
-        echo_server.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    } catch (const std::exception & e) {
-        std::cout << e.what() << std::endl;
-    } catch (...) {
-        std::cout << "other exception" << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/CMakeLists.txt
deleted file mode 100644
index 5828edb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (simple_broadcast_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/simple_broadcast_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/simple_broadcast_server.cpp
deleted file mode 100644
index 7c48476..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/simple_broadcast_server/simple_broadcast_server.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <set>
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-class broadcast_server {
-public:
-    broadcast_server() {
-        m_server.init_asio();
-
-        m_server.set_open_handler(bind(&broadcast_server::on_open,this,::_1));
-        m_server.set_close_handler(bind(&broadcast_server::on_close,this,::_1));
-        m_server.set_message_handler(bind(&broadcast_server::on_message,this,::_1,::_2));
-    }
-
-    void on_open(connection_hdl hdl) {
-        m_connections.insert(hdl);
-    }
-
-    void on_close(connection_hdl hdl) {
-        m_connections.erase(hdl);
-    }
-
-    void on_message(connection_hdl hdl, server::message_ptr msg) {
-        for (auto it : m_connections) {
-            m_server.send(it,msg);
-        }
-    }
-
-    void run(uint16_t port) {
-        m_server.listen(port);
-        m_server.start_accept();
-        m_server.run();
-    }
-private:
-    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
-
-    server m_server;
-    con_list m_connections;
-};
-
-int main() {
-    broadcast_server server;
-    server.run(9002);
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/CMakeLists.txt
deleted file mode 100644
index 439fdf1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (sip_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/README.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/README.txt
deleted file mode 100644
index ce3271c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/README.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-Checkout the project from git
-
-At the top level, run cmake:
-
-  cmake -G 'Unix Makefiles' \
-     -D BUILD_EXAMPLES=ON \
-     -D WEBSOCKETPP_ROOT=/tmp/cm1 \
-     -D ENABLE_CPP11=OFF .
-
-and then make the example:
-
-  make -C examples/sip_client
-
-Now run it:
-
-  bin/sip_client ws://ws-server:80
-
-It has been tested against the repro SIP proxy from reSIProcate
-
-  http://www.resiprocate.org/WebRTC_and_SIP_Over_WebSockets
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/SConscript
deleted file mode 100644
index fafe7b4..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## SIP client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('sip_client', ["sip_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('sip_client', ["sip_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/sip_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/sip_client.cpp
deleted file mode 100644
index 66fa857..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/sip_client/sip_client.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include <condition_variable>
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-
-#include <boost/thread/thread.hpp>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
-
-// Create a server endpoint
-client sip_client;
-
-
-bool received;
-
-void on_open(client* c, websocketpp::connection_hdl hdl) {
-    // now it is safe to use the connection
-    std::cout << "connection ready" << std::endl;
-
-    received=false;
-    // Send a SIP OPTIONS message to the server:
-    std::string SIP_msg="OPTIONS sip:carol@chicago.com SIP/2.0\r\nVia: SIP/2.0/WS df7jal23ls0d.invalid;rport;branch=z9hG4bKhjhs8ass877\r\nMax-Forwards: 70\r\nTo: <sip:carol@chicago.com>\r\nFrom: Alice <sip:alice@atlanta.com>;tag=1928301774\r\nCall-ID: a84b4c76e66710\r\nCSeq: 63104 OPTIONS\r\nContact: <sip:alice@pc33.atlanta.com>\r\nAccept: application/sdp\r\nContent-Length: 0\r\n\r\n";
-    sip_client.send(hdl, SIP_msg.c_str(), websocketpp::frame::opcode::text);
-}
-
-void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
-    client::connection_ptr con = sip_client.get_con_from_hdl(hdl);
-
-    std::cout << "Received a reply:" << std::endl;
-    fwrite(msg->get_payload().c_str(), msg->get_payload().size(), 1, stdout);
-    received=true;
-}
-
-int main(int argc, char* argv[]) {
-
-    std::string uri = "ws://localhost:9001";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-    try {
-        // We expect there to be a lot of errors, so suppress them
-        sip_client.clear_access_channels(websocketpp::log::alevel::all);
-        sip_client.clear_error_channels(websocketpp::log::elevel::all);
-
-        // Initialize ASIO
-        sip_client.init_asio();
-
-        // Register our handlers
-        sip_client.set_open_handler(bind(&on_open,&sip_client,::_1));
-        sip_client.set_message_handler(bind(&on_message,&sip_client,::_1,::_2));
-
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = sip_client.get_connection(uri, ec);
-
-        // Specify the SIP subprotocol:
-        con->add_subprotocol("sip");
-
-        sip_client.connect(con);
-
-        // Start the ASIO io_service run loop
-        sip_client.run();
-
-        while(!received) {
-            boost::this_thread::sleep(boost::posix_time::milliseconds(100));
-        }
-
-        std::cout << "done" << std::endl;
-
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/CMakeLists.txt
deleted file mode 100644
index fa911eb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (subprotocol_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/SConscript
deleted file mode 100644
index e97535c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('subprotocol_server', ["subprotocol_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('subprotocol_server', ["subprotocol_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/subprotocol_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/subprotocol_server.cpp
deleted file mode 100644
index 9593c01..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/subprotocol_server/subprotocol_server.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <iostream>
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-using websocketpp::connection_hdl;
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-using websocketpp::lib::ref;
-
-
-bool validate(server & s, connection_hdl hdl) {
-    server::connection_ptr con = s.get_con_from_hdl(hdl);
-
-    std::cout << "Cache-Control: " << con->get_request_header("Cache-Control") << std::endl;
-
-    const std::vector<std::string> & subp_requests = con->get_requested_subprotocols();
-    std::vector<std::string>::const_iterator it;
-
-    for (it = subp_requests.begin(); it != subp_requests.end(); ++it) {
-        std::cout << "Requested: " << *it << std::endl;
-    }
-
-    if (subp_requests.size() > 0) {
-        con->select_subprotocol(subp_requests[0]);
-    }
-
-    return true;
-}
-
-int main() {
-    try {
-        server s;
-
-        s.set_validate_handler(bind(&validate,ref(s),::_1));
-
-        s.init_asio();
-        s.listen(9005);
-        s.start_accept();
-
-        s.run();
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/CMakeLists.txt
deleted file mode 100644
index 04462e9..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (telemetry_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/SConscript
deleted file mode 100644
index 62396a5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Telemetry client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('telemetry_client', ["telemetry_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('telemetry_client', ["telemetry_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/telemetry_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/telemetry_client.cpp
deleted file mode 100644
index f0f7fae..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_client/telemetry_client.cpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-// This header pulls in the WebSocket++ abstracted thread support that will
-// select between boost::thread and std::thread based on how the build system
-// is configured.
-#include <websocketpp/common/thread.hpp>
-
-/**
- * Define a semi-cross platform helper method that waits/sleeps for a bit.
- */
-void wait_a_bit() {
-#ifdef WIN32
-    Sleep(1000);
-#else
-    sleep(1);
-#endif
-}
-
-/**
- * The telemetry client connects to a WebSocket server and sends a message every
- * second containing an integer count. This example can be used as the basis for
- * programs where a client connects and pushes data for logging, stress/load
- * testing, etc.
- */
-class telemetry_client {
-public:
-    typedef websocketpp::client<websocketpp::config::asio_client> client;
-    typedef websocketpp::lib::lock_guard<websocketpp::lib::mutex> scoped_lock;
-
-    telemetry_client() : m_open(false),m_done(false) {
-        // set up access channels to only log interesting things
-        m_client.clear_access_channels(websocketpp::log::alevel::all);
-        m_client.set_access_channels(websocketpp::log::alevel::connect);
-        m_client.set_access_channels(websocketpp::log::alevel::disconnect);
-        m_client.set_access_channels(websocketpp::log::alevel::app);
-
-        // Initialize the Asio transport policy
-        m_client.init_asio();
-
-        // Bind the handlers we are using
-        using websocketpp::lib::placeholders::_1;
-        using websocketpp::lib::bind;
-        m_client.set_open_handler(bind(&telemetry_client::on_open,this,_1));
-        m_client.set_close_handler(bind(&telemetry_client::on_close,this,_1));
-        m_client.set_fail_handler(bind(&telemetry_client::on_fail,this,_1));
-    }
-
-    // This method will block until the connection is complete
-    void run(const std::string & uri) {
-        // Create a new connection to the given URI
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = m_client.get_connection(uri, ec);
-        if (ec) {
-            m_client.get_alog().write(websocketpp::log::alevel::app,
-                    "Get Connection Error: "+ec.message());
-            return;
-        }
-
-        // Grab a handle for this connection so we can talk to it in a thread
-        // safe manor after the event loop starts.
-        m_hdl = con->get_handle();
-
-        // Queue the connection. No DNS queries or network connections will be
-        // made until the io_service event loop is run.
-        m_client.connect(con);
-
-        // Create a thread to run the ASIO io_service event loop
-        websocketpp::lib::thread asio_thread(&client::run, &m_client);
-
-        // Create a thread to run the telemetry loop
-        websocketpp::lib::thread telemetry_thread(&telemetry_client::telemetry_loop,this);
-
-        asio_thread.join();
-        telemetry_thread.join();
-    }
-
-    // The open handler will signal that we are ready to start sending telemetry
-    void on_open(websocketpp::connection_hdl) {
-        m_client.get_alog().write(websocketpp::log::alevel::app,
-            "Connection opened, starting telemetry!");
-
-        scoped_lock guard(m_lock);
-        m_open = true;
-    }
-
-    // The close handler will signal that we should stop sending telemetry
-    void on_close(websocketpp::connection_hdl) {
-        m_client.get_alog().write(websocketpp::log::alevel::app,
-            "Connection closed, stopping telemetry!");
-
-        scoped_lock guard(m_lock);
-        m_done = true;
-    }
-
-    // The fail handler will signal that we should stop sending telemetry
-    void on_fail(websocketpp::connection_hdl) {
-        m_client.get_alog().write(websocketpp::log::alevel::app,
-            "Connection failed, stopping telemetry!");
-
-        scoped_lock guard(m_lock);
-        m_done = true;
-    }
-
-    void telemetry_loop() {
-        uint64_t count = 0;
-        std::stringstream val;
-        websocketpp::lib::error_code ec;
-
-        while(1) {
-            bool wait = false;
-
-            {
-                scoped_lock guard(m_lock);
-                // If the connection has been closed, stop generating telemetry
-                if (m_done) {break;}
-
-                // If the connection hasn't been opened yet wait a bit and retry
-                if (!m_open) {
-                    wait = true;
-                }
-            }
-
-            if (wait) {
-                wait_a_bit();
-                continue;
-            }
-
-            val.str("");
-            val << "count is " << count++;
-
-            m_client.get_alog().write(websocketpp::log::alevel::app, val.str());
-            m_client.send(m_hdl,val.str(),websocketpp::frame::opcode::text,ec);
-
-            // The most likely error that we will get is that the connection is
-            // not in the right state. Usually this means we tried to send a
-            // message to a connection that was closed or in the process of
-            // closing. While many errors here can be easily recovered from,
-            // in this simple example, we'll stop the telemetry loop.
-            if (ec) {
-                m_client.get_alog().write(websocketpp::log::alevel::app,
-                    "Send Error: "+ec.message());
-                break;
-            }
-
-            wait_a_bit();
-        }
-    }
-private:
-    client m_client;
-    websocketpp::connection_hdl m_hdl;
-    websocketpp::lib::mutex m_lock;
-    bool m_open;
-    bool m_done;
-};
-
-int main(int argc, char* argv[]) {
-    telemetry_client c;
-
-    std::string uri = "ws://localhost:9002";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-    c.run(uri);
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/CMakeLists.txt
deleted file mode 100644
index 845fe86..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (telemetry_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/SConscript
deleted file mode 100644
index 1b8ff22..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Main development example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('telemetry_server', ["telemetry_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('telemetry_server', ["telemetry_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/index.html b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/index.html
deleted file mode 100644
index def50dd..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/index.html
+++ /dev/null
@@ -1,85 +0,0 @@
-<!doctype html>
-<html>
-<head>
-<title>WebSocket++ Telemetry Client</title>
-</head>
-<body>
-
-<script type="text/javascript">
-var ws;
-var url;
-
-function connect() {
-	url = document.getElementById("server_url").value;
-	
-	if ("WebSocket" in window) {
-		ws = new WebSocket(url);
-	} else if ("MozWebSocket" in window) {
-		ws = new MozWebSocket(url);
-	} else {
-		document.getElementById("messages").innerHTML += "This Browser does not support WebSockets<br />";
-		return;
-	}
-	ws.onopen = function(e) {
-		document.getElementById("messages").innerHTML += "Client: A connection to "+ws.url+" has been opened.<br />";
-		
-		document.getElementById("server_url").disabled = true;
-		document.getElementById("toggle_connect").innerHTML = "Disconnect";
-	};
-	
-	ws.onerror = function(e) {
-		document.getElementById("messages").innerHTML += "Client: An error occured, see console log for more details.<br />";
-		console.log(e);
-	};
-	
-	ws.onclose = function(e) {
-		document.getElementById("messages").innerHTML += "Client: The connection to "+url+" was closed. ["+e.code+(e.reason != "" ? ","+e.reason : "")+"]<br />";
-	    cleanup_disconnect();
-	};
-	
-	ws.onmessage = function(e) {
-		document.getElementById("messages").innerHTML += "Server: "+e.data+"<br />";
-	};
-}
-
-function disconnect() {
-	ws.close();
-	cleanup_disconnect();
-}
-
-function cleanup_disconnect() {
-    document.getElementById("server_url").disabled = false;
-	document.getElementById("toggle_connect").innerHTML = "Connect";
-}
-
-function toggle_connect() {
-	if (document.getElementById("server_url").disabled === false) {
-		connect();
-	} else {
-		disconnect();
-	}
-}
-</script>
-
-<style>
-body,html {
-	margin: 0px;
-	padding: 0px;
-}
-#controls {
-	float:right;
-	background-color: #999;
-}
-
-</style>
-
-<div id="controls">
-	<div id="server">
-	<input type="text" name="server_url" id="server_url" value="ws://localhost:9002" /><br />
-	<button id="toggle_connect" onclick="toggle_connect();">Connect</button>
-	</div>
-</div>
-<div id="messages"></div>
-
-</body>
-</html>
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/telemetry_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/telemetry_server.cpp
deleted file mode 100644
index 3f8e604..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/telemetry_server/telemetry_server.cpp
+++ /dev/null
@@ -1,203 +0,0 @@
-#include <websocketpp/config/asio_no_tls.hpp>
-
-#include <websocketpp/server.hpp>
-
-#include <fstream>
-#include <iostream>
-#include <set>
-#include <streambuf>
-#include <string>
-
-/**
- * The telemetry server accepts connections and sends a message every second to
- * each client containing an integer count. This example can be used as the
- * basis for programs that expose a stream of telemetry data for logging,
- * dashboards, etc.
- *
- * This example uses the timer based concurrency method and is self contained
- * and singled threaded. Refer to telemetry client for an example of a similar
- * telemetry setup using threads rather than timers.
- *
- * This example also includes an example simple HTTP server that serves a web
- * dashboard displaying the count. This simple design is suitable for use 
- * delivering a small number of files to a small number of clients. It is ideal
- * for cases like embedded dashboards that don't want the complexity of an extra
- * HTTP server to serve static files.
- *
- * This design *will* fall over under high traffic or DoS conditions. In such
- * cases you are much better off proxying to a real HTTP server for the http
- * requests.
- */
-class telemetry_server {
-public:
-    typedef websocketpp::connection_hdl connection_hdl;
-    typedef websocketpp::server<websocketpp::config::asio> server;
-
-    telemetry_server() : m_count(0) {
-        // set up access channels to only log interesting things
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.set_access_channels(websocketpp::log::alevel::access_core);
-        m_endpoint.set_access_channels(websocketpp::log::alevel::app);
-
-        // Initialize the Asio transport policy
-        m_endpoint.init_asio();
-
-        // Bind the handlers we are using
-        using websocketpp::lib::placeholders::_1;
-        using websocketpp::lib::bind;
-        m_endpoint.set_open_handler(bind(&telemetry_server::on_open,this,_1));
-        m_endpoint.set_close_handler(bind(&telemetry_server::on_close,this,_1));
-        m_endpoint.set_http_handler(bind(&telemetry_server::on_http,this,_1));
-    }
-
-    void run(std::string docroot, uint16_t port) {
-        std::stringstream ss;
-        ss << "Running telemetry server on port "<< port <<" using docroot=" << docroot;
-        m_endpoint.get_alog().write(websocketpp::log::alevel::app,ss.str());
-        
-        m_docroot = docroot;
-        
-        // listen on specified port
-        m_endpoint.listen(port);
-
-        // Start the server accept loop
-        m_endpoint.start_accept();
-
-        // Set the initial timer to start telemetry
-        set_timer();
-
-        // Start the ASIO io_service run loop
-        try {
-            m_endpoint.run();
-        } catch (websocketpp::exception const & e) {
-            std::cout << e.what() << std::endl;
-        }
-    }
-
-    void set_timer() {
-        m_timer = m_endpoint.set_timer(
-            1000,
-            websocketpp::lib::bind(
-                &telemetry_server::on_timer,
-                this,
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void on_timer(websocketpp::lib::error_code const & ec) {
-        if (ec) {
-            // there was an error, stop telemetry
-            m_endpoint.get_alog().write(websocketpp::log::alevel::app,
-                    "Timer Error: "+ec.message());
-            return;
-        }
-        
-        std::stringstream val;
-        val << "count is " << m_count++;
-        
-        // Broadcast count to all connections
-        con_list::iterator it;
-        for (it = m_connections.begin(); it != m_connections.end(); ++it) {
-            m_endpoint.send(*it,val.str(),websocketpp::frame::opcode::text);
-        }
-        
-        // set timer for next telemetry check
-        set_timer();
-    }
-
-    void on_http(connection_hdl hdl) {
-        // Upgrade our connection handle to a full connection_ptr
-        server::connection_ptr con = m_endpoint.get_con_from_hdl(hdl);
-    
-        std::ifstream file;
-        std::string filename = con->get_resource();
-        std::string response;
-    
-        m_endpoint.get_alog().write(websocketpp::log::alevel::app,
-            "http request1: "+filename);
-    
-        if (filename == "/") {
-            filename = m_docroot+"index.html";
-        } else {
-            filename = m_docroot+filename.substr(1);
-        }
-        
-        m_endpoint.get_alog().write(websocketpp::log::alevel::app,
-            "http request2: "+filename);
-    
-        file.open(filename.c_str(), std::ios::in);
-        if (!file) {
-            // 404 error
-            std::stringstream ss;
-        
-            ss << "<!doctype html><html><head>"
-               << "<title>Error 404 (Resource not found)</title><body>"
-               << "<h1>Error 404</h1>"
-               << "<p>The requested URL " << filename << " was not found on this server.</p>"
-               << "</body></head></html>";
-        
-            con->set_body(ss.str());
-            con->set_status(websocketpp::http::status_code::not_found);
-            return;
-        }
-    
-        file.seekg(0, std::ios::end);
-        response.reserve(file.tellg());
-        file.seekg(0, std::ios::beg);
-    
-        response.assign((std::istreambuf_iterator<char>(file)),
-                        std::istreambuf_iterator<char>());
-    
-        con->set_body(response);
-        con->set_status(websocketpp::http::status_code::ok);
-    }
-
-    void on_open(connection_hdl hdl) {
-        m_connections.insert(hdl);
-    }
-
-    void on_close(connection_hdl hdl) {
-        m_connections.erase(hdl);
-    }
-private:
-    typedef std::set<connection_hdl,std::owner_less<connection_hdl>> con_list;
-    
-    server m_endpoint;
-    con_list m_connections;
-    server::timer_ptr m_timer;
-    
-    std::string m_docroot;
-    
-    // Telemetry data
-    uint64_t m_count;
-};
-
-int main(int argc, char* argv[]) {
-    telemetry_server s;
-
-    std::string docroot;
-    uint16_t port = 9002;
-
-    if (argc == 1) {
-        std::cout << "Usage: telemetry_server [documentroot] [port]" << std::endl;
-        return 1;
-    }
-    
-    if (argc >= 2) {
-        docroot = std::string(argv[1]);
-    }
-        
-    if (argc >= 3) {
-        int i = atoi(argv[2]);
-        if (i <= 0 || i > 65535) {
-            std::cout << "invalid port" << std::endl;
-            return 1;
-        }
-        
-        port = uint16_t(i);
-    }
-
-    s.run(docroot, port);
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/CMakeLists.txt
deleted file mode 100644
index e89fcc7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-if (ZLIB_FOUND)
-
-init_target (testee_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_zlib()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/SConscript
deleted file mode 100644
index 64f0ef1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Autobahn test client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env_cpp11.Program('testee_client', ["testee_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env.Program('testee_client', ["testee_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/testee_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/testee_client.cpp
deleted file mode 100644
index b66e633..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_client/testee_client.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-#include <iostream>
-
-struct deflate_config : public websocketpp::config::asio_client {
-    typedef deflate_config type;
-    typedef asio_client base;
-    
-    typedef base::concurrency_type concurrency_type;
-    
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-    
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-    
-    typedef base::rng_type rng_type;
-    
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint 
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config> 
-        transport_type;
-        
-    /// permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::client<deflate_config> client;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
-
-int case_count = 0;
-
-void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
-    client::connection_ptr con = c->get_con_from_hdl(hdl);
-
-    if (con->get_resource() == "/getCaseCount") {
-        std::cout << "Detected " << msg->get_payload() << " test cases."
-                  << std::endl;
-        case_count = atoi(msg->get_payload().c_str());
-    } else {
-        c->send(hdl, msg->get_payload(), msg->get_opcode());
-    }
-}
-
-int main(int argc, char* argv[]) {
-    // Create a server endpoint
-    client c;
-
-    std::string uri = "ws://localhost:9001";
-
-    if (argc == 2) {
-        uri = argv[1];
-    }
-
-    try {
-        // We expect there to be a lot of errors, so suppress them
-        c.clear_access_channels(websocketpp::log::alevel::all);
-        c.clear_error_channels(websocketpp::log::elevel::all);
-
-        // Initialize ASIO
-        c.init_asio();
-
-        // Register our handlers
-        c.set_message_handler(bind(&on_message,&c,::_1,::_2));
-
-        websocketpp::lib::error_code ec;
-        client::connection_ptr con = c.get_connection(uri+"/getCaseCount", ec);
-        c.connect(con);
-
-        // Start the ASIO io_service run loop
-        c.run();
-
-        std::cout << "case count: " << case_count << std::endl;
-
-        for (int i = 1; i <= case_count; i++) {
-            c.reset();
-
-            std::stringstream url;
-
-            url << uri << "/runCase?case=" << i << "&agent="
-                << websocketpp::user_agent;
-
-            con = c.get_connection(url.str(), ec);
-
-            c.connect(con);
-
-            c.run();
-        }
-
-        std::cout << "done" << std::endl;
-
-    } catch (websocketpp::exception const & e) {
-        std::cout << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/CMakeLists.txt
deleted file mode 100644
index c95e42d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-if (ZLIB_FOUND)
-
-init_target (testee_server)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_zlib()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
-endif()
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/SConscript
deleted file mode 100644
index 3c75f4f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Autobahn Testee Server
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env_cpp11.Program('testee_server', ["testee_server.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system'],env) + [platform_libs] + [polyfill_libs] + ['z']
-   prgs += env.Program('testee_server', ["testee_server.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/testee_server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/testee_server.cpp
deleted file mode 100644
index 9ac9a7d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/testee_server/testee_server.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-#include <iostream>
-
-struct testee_config : public websocketpp::config::asio {
-    // pull default settings from our core config
-    typedef websocketpp::config::asio core;
-
-    typedef core::concurrency_type concurrency_type;
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-    typedef core::rng_type rng_type;
-    typedef core::endpoint_base endpoint_base;
-
-    static bool const enable_multithreading = true;
-
-    struct transport_config : public core::transport_config {
-        typedef core::concurrency_type concurrency_type;
-        typedef core::elog_type elog_type;
-        typedef core::alog_type alog_type;
-        typedef core::request_type request_type;
-        typedef core::response_type response_type;
-
-        static bool const enable_multithreading = true;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-
-    static const websocketpp::log::level elog_level =
-        websocketpp::log::elevel::none;
-    static const websocketpp::log::level alog_level =
-        websocketpp::log::alevel::none;
-        
-    /// permessage_compress extension
-    struct permessage_deflate_config {};
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-typedef websocketpp::server<testee_config> server;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-// pull out the type of messages sent by our config
-typedef server::message_ptr message_ptr;
-
-// Define a callback to handle incoming messages
-void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    s->send(hdl, msg->get_payload(), msg->get_opcode());
-}
-
-void on_socket_init(websocketpp::connection_hdl, boost::asio::ip::tcp::socket & s) {
-    boost::asio::ip::tcp::no_delay option(true);
-    s.set_option(option);
-}
-
-int main(int argc, char * argv[]) {
-    // Create a server endpoint
-    server testee_server;
-
-    short port = 9002;
-    size_t num_threads = 1;
-
-    if (argc == 3) {
-        port = atoi(argv[1]);
-        num_threads = atoi(argv[2]);
-    }
-
-    try {
-        // Total silence
-        testee_server.clear_access_channels(websocketpp::log::alevel::all);
-        testee_server.clear_error_channels(websocketpp::log::alevel::all);
-
-        // Initialize ASIO
-        testee_server.init_asio();
-        testee_server.set_reuse_addr(true);
-
-        // Register our message handler
-        testee_server.set_message_handler(bind(&on_message,&testee_server,::_1,::_2));
-        testee_server.set_socket_init_handler(bind(&on_socket_init,::_1,::_2));
-
-        // Listen on specified port with extended listen backlog
-        testee_server.set_listen_backlog(8192);
-        testee_server.listen(port);
-
-        // Start the server accept loop
-        testee_server.start_accept();
-
-        // Start the ASIO io_service run loop
-        if (num_threads == 1) {
-            testee_server.run();
-        } else {
-            typedef websocketpp::lib::shared_ptr<websocketpp::lib::thread> thread_ptr;
-            std::vector<thread_ptr> ts;
-            for (size_t i = 0; i < num_threads; i++) {
-                ts.push_back(websocketpp::lib::make_shared<websocketpp::lib::thread>(&server::run, &testee_server));
-            }
-
-            for (size_t i = 0; i < num_threads; i++) {
-                ts[i]->join();
-            }
-        }
-
-    } catch (websocketpp::exception const & e) {
-        std::cout << "exception: " << e.what() << std::endl;
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/CMakeLists.txt
deleted file mode 100644
index fbfd868..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (utility_client)
-
-build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/SConscript
deleted file mode 100644
index 6e6cd8c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## Utility client example
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-prgs = []
-
-# if a C++11 environment is available build using that, otherwise use boost
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   ALL_LIBS = boostlibs(['system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   prgs += env_cpp11.Program('utility_client', ["utility_client.cpp"], LIBS = ALL_LIBS)
-else:
-   ALL_LIBS = boostlibs(['system','random'],env) + [platform_libs] + [polyfill_libs]
-   prgs += env.Program('utility_client', ["utility_client.cpp"], LIBS = ALL_LIBS)
-
-Return('prgs')
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/utility_client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/utility_client.cpp
deleted file mode 100644
index aa43b8e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/examples/utility_client/utility_client.cpp
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-    
-    void on_close(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Closed";
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        std::stringstream s;
-        s << "close code: " << con->get_remote_close_code() << " (" 
-          << websocketpp::close::status::get_string(con->get_remote_close_code()) 
-          << "), close reason: " << con->get_remote_close_reason();
-        m_error_reason = s.str();
-    }
-
-    void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
-        if (msg->get_opcode() == websocketpp::frame::opcode::text) {
-            m_messages.push_back("<< " + msg->get_payload());
-        } else {
-            m_messages.push_back("<< " + websocketpp::utility::to_hex(msg->get_payload()));
-        }
-    }
-
-    websocketpp::connection_hdl get_hdl() const {
-        return m_hdl;
-    }
-    
-    int get_id() const {
-        return m_id;
-    }
-    
-    std::string get_status() const {
-        return m_status;
-    }
-
-    void record_sent_message(std::string message) {
-        m_messages.push_back(">> " + message);
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-    std::vector<std::string> m_messages;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason) << "\n";
-    out << "> Messages Processed: (" << data.m_messages.size() << ") \n";
-
-    std::vector<std::string>::const_iterator it;
-    for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
-        out << *it << "\n";
-    }
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
-    }
-
-    ~websocket_endpoint() {
-        m_endpoint.stop_perpetual();
-        
-        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
-            if (it->second->get_status() != "Open") {
-                // Only close open connections
-                continue;
-            }
-            
-            std::cout << "> Closing connection " << it->second->get_id() << std::endl;
-            
-            websocketpp::lib::error_code ec;
-            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
-            if (ec) {
-                std::cout << "> Error closing connection " << it->second->get_id() << ": "  
-                          << ec.message() << std::endl;
-            }
-        }
-        
-        m_thread->join();
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_close_handler(websocketpp::lib::bind(
-            &connection_metadata::on_close,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_message_handler(websocketpp::lib::bind(
-            &connection_metadata::on_message,
-            metadata_ptr,
-            websocketpp::lib::placeholders::_1,
-            websocketpp::lib::placeholders::_2
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    void close(int id, websocketpp::close::status::value code, std::string reason) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
-        if (ec) {
-            std::cout << "> Error initiating close: " << ec.message() << std::endl;
-        }
-    }
-
-    void send(int id, std::string message) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
-        if (ec) {
-            std::cout << "> Error sending message: " << ec.message() << std::endl;
-            return;
-        }
-        
-        metadata_it->second->record_sent_message(message);
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "send <connection id> <message>\n"
-                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,4) == "send") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            std::string message;
-            
-            ss >> cmd >> id;
-            std::getline(ss,message);
-            
-            endpoint.send(id, message);
-        } else if (input.substr(0,5) == "close") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            int close_code = websocketpp::close::status::normal;
-            std::string reason;
-            
-            ss >> cmd >> id >> close_code;
-            std::getline(ss,reason);
-            
-            endpoint.close(id, close_code, reason);
-        } else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/readme.md b/third_party/socket.io-client-cpp/lib/websocketpp/readme.md
deleted file mode 100644
index 6cc6085..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/readme.md
+++ /dev/null
@@ -1,49 +0,0 @@
-WebSocket++ (0.8.2)
-==========================
-
-WebSocket++ is a header only C++ library that implements RFC6455 The WebSocket
-Protocol. It allows integrating WebSocket client and server functionality into
-C++ programs. It uses interchangeable network transport modules including one
-based on raw char buffers, one based on C++ iostreams, and one based on Asio 
-(either via Boost or standalone). End users can write additional transport
-policies to support other networking or event libraries as needed.
-
-Major Features
-==============
-* Full support for RFC6455
-* Partial support for Hixie 76 / Hybi 00, 07-17 draft specs (server only)
-* Message/event based interface
-* Supports secure WebSockets (TLS), IPv6, and explicit proxies.
-* Flexible dependency management (C++11 Standard Library or Boost)
-* Interchangeable network transport modules (raw, iostream, Asio, or custom)
-* Portable/cross platform (Posix/Windows, 32/64bit, Intel/ARM/PPC)
-* Thread-safe
-
-Get Involved
-============
-
-[![Build Status](https://travis-ci.org/zaphoyd/websocketpp.png)](https://travis-ci.org/zaphoyd/websocketpp)
-
-**Project Website**
-http://www.zaphoyd.com/websocketpp/
-
-**User Manual**
-http://docs.websocketpp.org/
-
-**GitHub Repository**
-https://github.com/zaphoyd/websocketpp/
-
-GitHub pull requests should be submitted to the `develop` branch.
-
-**Announcements Mailing List**
-http://groups.google.com/group/websocketpp-announcements/
-
-**IRC Channel**
- #websocketpp (freenode)
-
-**Discussion / Development / Support Mailing List / Forum**
-http://groups.google.com/group/websocketpp/
-
-Author
-======
-Peter Thorson - websocketpp@zaphoyd.com
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/roadmap.md b/third_party/socket.io-client-cpp/lib/websocketpp/roadmap.md
deleted file mode 100644
index b35c54a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/roadmap.md
+++ /dev/null
@@ -1,43 +0,0 @@
-Complete & Tested:
-- Server and client roles pass all Autobahn v0.5.9 test suite tests strictly
-- Streaming UTF8 validation
-- random number generation
-- iostream based transport
-- C++11 support
-- LLVM/Clang support
-- GCC support
-- 64 bit support
-- 32 bit support
-- Logging
-- Client role
-- message_handler
-- ping_handler
-- pong_handler
-- open_handler
-- close_handler
-- echo_server & echo_server_tls
-- External io_service support
-- TLS support
-- exception/error handling
-- Timeouts
-- Subprotocol negotiation
-- validate_handler
-- Hybi 00/Hixie 76 legacy protocol support
-- Outgoing Proxy Support
-- socket_init_handler
-- tls_init_handler
-- tcp_init_handler
-
-Ongoing work
-- Performance tuning
-- PowerPC support
-- Visual Studio / Windows support
-- CMake build/install support
-- http_handler
-
-Future feature roadmap
-- Extension support
-- permessage_compress extension
-- Message buffer pool
-- flow control
-- tutorials & documentation
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/CMakeLists.txt
deleted file mode 100644
index cc501c7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (test_connection)
-
-build_test (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/SConscript
deleted file mode 100644
index 4ed7a4e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/SConscript
+++ /dev/null
@@ -1,25 +0,0 @@
-## connection unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
-
-objs = env.Object('connection_boost.o', ["connection.cpp"], LIBS = BOOST_LIBS)
-objs = env.Object('connection_tu2_boost.o', ["connection_tu2.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_connection_boost', ["connection_boost.o","connection_tu2_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('connection_stl.o', ["connection.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('connection_tu2_stl.o', ["connection_tu2.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_connection_stl', ["connection_stl.o","connection_tu2_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection.cpp
deleted file mode 100644
index cb7b69a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection.cpp
+++ /dev/null
@@ -1,533 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE connection
-#include <boost/test/unit_test.hpp>
-
-#include "connection_tu2.hpp"
-
-// Include special debugging transport
-//#include <websocketpp/config/minimal_client.hpp>
-#include <websocketpp/transport/debug/endpoint.hpp>
-
-// NOTE: these tests currently test against hardcoded output values. I am not
-// sure how problematic this will be. If issues arise like order of headers the
-// output should be parsed by http::response and have values checked directly
-
-BOOST_AUTO_TEST_CASE( basic_http_request ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 426 Upgrade Required\r\nServer: " +
-                         std::string(websocketpp::user_agent)+"\r\n\r\n";
-
-    std::string o2 = run_server_test(input);
-
-    BOOST_CHECK(o2 == output);
-}
-
-struct connection_extension {
-    connection_extension() : extension_value(5) {}
-
-    int extension_method() {
-        return extension_value;
-    }
-
-    bool is_server() const {
-        return false;
-    }
-
-    int extension_value;
-};
-
-struct stub_config : public websocketpp::config::core {
-    typedef core::concurrency_type concurrency_type;
-
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-
-    typedef core::rng_type rng_type;
-
-    typedef core::transport_type transport_type;
-
-    typedef core::endpoint_base endpoint_base;
-    typedef connection_extension connection_base;
-};
-
-struct debug_config_client : public websocketpp::config::core {
-    typedef debug_config_client type;
-    
-    typedef core::concurrency_type concurrency_type;
-
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    struct transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::elog_type elog_type;
-        typedef type::alog_type alog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-
-        /// Controls compile time enabling/disabling of thread syncronization
-        /// code Disabling can provide a minor performance improvement to single
-        /// threaded applications
-        static bool const enable_multithreading = true;
-
-        /// Default timer values (in ms)
-        static const long timeout_socket_pre_init = 5000;
-        static const long timeout_proxy = 5000;
-        static const long timeout_socket_post_init = 5000;
-        static const long timeout_connect = 5000;
-        static const long timeout_socket_shutdown = 5000;
-    };
-
-    /// Transport Endpoint Component
-    typedef websocketpp::transport::debug::endpoint<transport_config>
-        transport_type;
-
-    typedef core::endpoint_base endpoint_base;
-    typedef connection_extension connection_base;
-    
-    static const websocketpp::log::level elog_level = websocketpp::log::elevel::none;
-    static const websocketpp::log::level alog_level = websocketpp::log::alevel::none;
-};
-
-struct connection_setup {
-    connection_setup(bool p_is_server)
-            : alog(websocketpp::lib::make_shared<stub_config::alog_type>())
-            , elog(websocketpp::lib::make_shared<stub_config::elog_type>())
-            , c(p_is_server, "", alog, elog, rng) {}
-
-    websocketpp::lib::error_code ec;
-    websocketpp::lib::shared_ptr<stub_config::alog_type> alog;
-    websocketpp::lib::shared_ptr<stub_config::elog_type> elog;
-    stub_config::rng_type rng;
-    websocketpp::connection<stub_config> c;
-};
-
-typedef websocketpp::client<debug_config_client> debug_client;
-typedef websocketpp::server<debug_config_client> debug_server;
-
-/*void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    s->send(hdl, msg->get_payload(), msg->get_opcode());
-}*/
-
-void validate_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    s->send(hdl, msg->get_payload(), msg->get_opcode());
-}
-
-bool validate_set_ua(server* s, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-    con->replace_header("Server","foo");
-    return true;
-}
-
-void http_func(server* s, websocketpp::connection_hdl hdl) {
-    using namespace websocketpp::http;
-
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    std::string res = con->get_resource();
-
-    con->set_body(res);
-    con->set_status(status_code::ok);
-
-    BOOST_CHECK_EQUAL(con->get_response_code(), status_code::ok);
-    BOOST_CHECK_EQUAL(con->get_response_msg(), status_code::get_string(status_code::ok));
-}
-
-void defer_http_func(server* s, bool * deferred, websocketpp::connection_hdl hdl) {
-    *deferred = true;
-    
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-    
-    websocketpp::lib::error_code ec = con->defer_http_response();
-    BOOST_CHECK_EQUAL(ec, websocketpp::lib::error_code());
-}
-
-void check_on_fail(server* s, websocketpp::lib::error_code ec, bool & called, 
-    websocketpp::connection_hdl hdl)
-{
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    BOOST_CHECK_EQUAL(ec, con->get_ec());
-    called = true;
-}
-
-void on_open_print(server* s, websocketpp::connection_hdl hdl)
-{
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    std::cout << con->get_uri() << std::endl;
-}
-
-void fail_on_open(websocketpp::connection_hdl) {
-    BOOST_CHECK(false);
-}
-void fail_on_http(websocketpp::connection_hdl) {
-    BOOST_CHECK(false);
-}
-
-BOOST_AUTO_TEST_CASE( connection_extensions ) {
-    connection_setup env(true);
-
-    BOOST_CHECK( env.c.extension_value == 5 );
-    BOOST_CHECK( env.c.extension_method() == 5 );
-
-    BOOST_CHECK( env.c.is_server() == true );
-}
-
-BOOST_AUTO_TEST_CASE( basic_websocket_request ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: ";
-    output+=websocketpp::user_agent;
-    output+="\r\nUpgrade: websocket\r\n\r\n";
-
-    server s;
-    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
-
-    BOOST_CHECK(run_server_test(s,input) == output);
-}
-
-BOOST_AUTO_TEST_CASE( http_request ) {
-    std::string input = "GET /foo/bar HTTP/1.1\r\nHost: www.example.com\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 200 OK\r\nContent-Length: 8\r\nServer: ";
-    output+=websocketpp::user_agent;
-    output+="\r\n\r\n/foo/bar";
-
-    server s;
-    s.set_http_handler(bind(&http_func,&s,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( deferred_http_request ) {
-    std::string input = "GET /foo/bar HTTP/1.1\r\nHost: www.example.com\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 200 OK\r\nContent-Length: 8\r\nServer: ";
-    output+=websocketpp::user_agent;
-    output+="\r\n\r\n/foo/bar";
-
-    server s;
-    server::connection_ptr con;
-    bool deferred = false;
-    s.set_http_handler(bind(&defer_http_func,&s, &deferred,::_1));
-
-    s.clear_access_channels(websocketpp::log::alevel::all);
-    s.clear_error_channels(websocketpp::log::elevel::all);
-    
-    std::stringstream ostream;
-    s.register_ostream(&ostream);
-
-    con = s.get_connection();
-    con->start();
-    
-    BOOST_CHECK(!deferred);
-    BOOST_CHECK_EQUAL(ostream.str(), "");
-    con->read_some(input.data(),input.size());
-    BOOST_CHECK(deferred);
-    BOOST_CHECK_EQUAL(ostream.str(), "");
-
-    con->set_body(con->get_resource());
-    con->set_status(websocketpp::http::status_code::ok);
-    
-    websocketpp::lib::error_code ec;
-    s.send_http_response(con->get_handle(),ec);
-    BOOST_CHECK_EQUAL(ec, websocketpp::lib::error_code());
-    BOOST_CHECK_EQUAL(ostream.str(), output);
-    con->send_http_response(ec);
-    BOOST_CHECK_EQUAL(ec, make_error_code(websocketpp::error::invalid_state));
-    
-}
-
-BOOST_AUTO_TEST_CASE( request_no_server_header ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nUpgrade: websocket\r\n\r\n";
-
-    server s;
-    s.set_user_agent("");
-    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( request_no_server_header_override ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
-
-    server s;
-    s.set_user_agent("");
-    s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
-    s.set_validate_handler(bind(&validate_set_ua,&s,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( basic_client_websocket ) {
-    std::string uri = "ws://localhost";
-
-    //std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string ref = "GET / HTTP/1.1\r\nConnection: Upgrade\r\nFoo: Bar\r\nHost: localhost\r\nSec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\nSec-WebSocket-Version: 13\r\nUpgrade: websocket\r\nUser-Agent: foo\r\n\r\n";
-
-    std::stringstream output;
-
-    client e;
-    e.set_access_channels(websocketpp::log::alevel::none);
-    e.set_error_channels(websocketpp::log::elevel::none);
-    e.set_user_agent("foo");
-    e.register_ostream(&output);
-
-    client::connection_ptr con;
-    websocketpp::lib::error_code ec;
-    con = e.get_connection(uri, ec);
-    con->append_header("Foo","Bar");
-    e.connect(con);
-
-    BOOST_CHECK_EQUAL(ref, output.str());
-}
-
-BOOST_AUTO_TEST_CASE( set_max_message_size ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
-    
-    // After the handshake, add a single frame with a message that is too long.
-    char frame0[10] = {char(0x82), char(0x83), 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01};
-    input.append(frame0, 10);
-    
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
-
-    // After the handshake, add a single frame with a close message with message too big
-    // error code.
-    char frame1[4] = {char(0x88), 0x19, 0x03, char(0xf1)};
-    output.append(frame1, 4);
-    output.append("A message was too large");
-
-    server s;
-    s.set_user_agent("");
-    s.set_validate_handler(bind(&validate_set_ua,&s,::_1));
-    s.set_max_message_size(2);
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( websocket_fail_parse_error ) {
-    std::string input = "asdf\r\n\r\n";
-
-    server s;
-    websocketpp::lib::error_code ec = make_error_code(websocketpp::error::http_parse_error);
-    bool called = false;
-    s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-
-    run_server_test(s,input,false);
-    BOOST_CHECK(called);
-}
-
-BOOST_AUTO_TEST_CASE( websocket_fail_invalid_version ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: foo\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-
-    server s;
-    websocketpp::lib::error_code ec = make_error_code(websocketpp::error::invalid_version);
-    bool called = false;
-    s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-
-    run_server_test(s,input,false);
-    BOOST_CHECK(called);
-}
-
-BOOST_AUTO_TEST_CASE( websocket_fail_unsupported_version ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 12\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-
-    server s;
-    websocketpp::lib::error_code ec = make_error_code(websocketpp::error::unsupported_version);
-    bool called = false;
-    s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-
-    run_server_test(s,input,false);
-    BOOST_CHECK(called);
-}
-
-// BOOST_AUTO_TEST_CASE( websocket_fail_invalid_uri ) {
-//     std::string input = "GET http://345.123.123.123/foo HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-
-//     server s;
-//     websocketpp::lib::error_code ec = make_error_code(websocketpp::error::unsupported_version);
-//     bool called = false;
-//     s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-//     s.set_open_handler(bind(&on_open_print,&s,::_1));
-
-//     std::cout << run_server_test(s,input,true) << std::endl;
-//     BOOST_CHECK(called);
-// }
-
-// BOOST_AUTO_TEST_CASE( websocket_fail_invalid_uri_http ) {
-//     std::string input = "GET http://345.123.123.123/foo HTTP/1.1\r\nHost: www.example.com\r\nOrigin: http://www.example.com\r\n\r\n";
-
-//     server s;
-//     websocketpp::lib::error_code ec = make_error_code(websocketpp::error::unsupported_version);
-//     bool called = false;
-//     s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-//     s.set_open_handler(bind(&on_open_print,&s,::_1));
-
-//     std::cout << run_server_test(s,input,true) << std::endl;
-//     BOOST_CHECK(called);
-// }
-
-BOOST_AUTO_TEST_CASE( websocket_fail_upgrade_required ) {
-    std::string input = "GET /foo/bar HTTP/1.1\r\nHost: www.example.com\r\nOrigin: http://www.example.com\r\n\r\n";
-
-    server s;
-    websocketpp::lib::error_code ec = make_error_code(websocketpp::error::upgrade_required);
-    bool called = false;
-    s.set_fail_handler(bind(&check_on_fail,&s,ec,websocketpp::lib::ref(called),::_1));
-
-    run_server_test(s,input,false);
-    BOOST_CHECK(called);
-}
-
-// TODO: set max message size in client endpoint test case
-// TODO: set max message size mid connection test case
-// TODO: [maybe] set max message size in open handler
-
-
-
-// BOOST_AUTO_TEST_CASE( user_reject_origin ) {
-//     std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example2.com\r\n\r\n";
-//     std::string output = "HTTP/1.1 403 Forbidden\r\nServer: "+websocketpp::USER_AGENT+"\r\n\r\n";
-
-//     BOOST_CHECK(run_server_test(input) == output);
-// }
-
-// BOOST_AUTO_TEST_CASE( basic_text_message ) {
-//     std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-
-//     unsigned char frames[8] = {0x82,0x82,0xFF,0xFF,0xFF,0xFF,0xD5,0xD5};
-//     input.append(reinterpret_cast<char*>(frames),8);
-
-//     std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: "+websocketpp::USER_AGENT+"\r\nUpgrade: websocket\r\n\r\n**";
-
-//     BOOST_CHECK( run_server_test(input) == output);
-// }
-
-
-
-
-
-
-BOOST_AUTO_TEST_CASE( client_handshake_timeout_race1 ) {
-    debug_client c;
-
-    websocketpp::lib::error_code ec;
-    debug_client::connection_ptr con = c.get_connection("ws://localhost:9002", ec);
-
-    BOOST_CHECK(!ec);
-
-    // This test the case where a handshake times out immediately before the 
-    // handler that would have completed it gets invoked. This situation happens
-    // when clients are connecting to overloaded servers and on servers that are
-    // overloaded. 
-    c.connect(con);
-    
-    con->expire_timer(websocketpp::lib::error_code());
-    // Fullfil the write to simulate the write completing immediately after
-    // timer expires
-    con->fullfil_write();
-    
-    BOOST_CHECK_EQUAL(con->get_ec(), make_error_code(websocketpp::error::open_handshake_timeout));
-}
-
-BOOST_AUTO_TEST_CASE( client_handshake_timeout_race2 ) {
-    debug_client c;
-
-    websocketpp::lib::error_code ec;
-    debug_client::connection_ptr con = c.get_connection("ws://localhost:9002", ec);
-
-    BOOST_CHECK(!ec);
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ICX+Yqv66kxgM0FcWaLWlFLwTAI=\r\nServer: foo\r\nUpgrade: websocket\r\n\r\n";
-
-    // This test the case where a handshake times out immediately before the 
-    // handler that would have completed it gets invoked. This situation happens
-    // when clients are connecting to overloaded servers and on servers that are
-    // overloaded. 
-    c.connect(con);
-    con->fullfil_write();
-    
-    con->expire_timer(websocketpp::lib::error_code());
-    // Read valid handshake to simulate receiving the handshake response
-    // immediately after the timer expires
-    con->read_all(output.data(),output.size());
-    
-    BOOST_CHECK_EQUAL(con->get_ec(), make_error_code(websocketpp::error::open_handshake_timeout));
-}
-
-BOOST_AUTO_TEST_CASE( server_handshake_timeout_race1 ) {
-    debug_server s;
-
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\n\r\n";
-
-    debug_server::connection_ptr con = s.get_connection();
-    con->start();
-    
-    con->expire_timer(websocketpp::lib::error_code());
-    // Read handshake immediately after timer expire
-    con->read_all(input.data(), input.size());
-    
-    BOOST_CHECK_EQUAL(con->get_ec(), make_error_code(websocketpp::error::open_handshake_timeout));
-}
-
-BOOST_AUTO_TEST_CASE( server_handshake_timeout_race2 ) {
-    debug_server s;
-
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\n\r\n";
-
-    debug_server::connection_ptr con = s.get_connection();
-    con->start();
-    
-    con->read_all(input.data(), input.size());
-    
-    con->expire_timer(websocketpp::lib::error_code());
-    // Complete write immediately after timer expire
-    con->fullfil_write();
-    
-    BOOST_CHECK_EQUAL(con->get_ec(), make_error_code(websocketpp::error::open_handshake_timeout));
-}
-
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.cpp
deleted file mode 100644
index 5409624..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include "connection_tu2.hpp"
-
-void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    s->send(hdl, msg->get_payload(), msg->get_opcode());
-}
-
-std::string run_server_test(std::string input, bool log) {
-    server test_server;
-    return run_server_test(test_server,input,log);
-}
-
-std::string run_server_test(server & s, std::string input, bool log) {
-    server::connection_ptr con;
-    std::stringstream output;
-
-    if (log) {
-        s.set_access_channels(websocketpp::log::alevel::all);
-        s.set_error_channels(websocketpp::log::elevel::all);
-    } else {
-        s.clear_access_channels(websocketpp::log::alevel::all);
-        s.clear_error_channels(websocketpp::log::elevel::all);
-    }
-
-    s.register_ostream(&output);
-
-    con = s.get_connection();
-    con->start();
-
-    std::stringstream channel;
-
-    channel << input;
-    channel >> *con;
-
-    return output.str();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.hpp
deleted file mode 100644
index 8990ce0..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/connection/connection_tu2.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <iostream>
-#include <sstream>
-
-// Test Environment:
-// server, no TLS, no locks, iostream based transport
-#include <websocketpp/config/debug.hpp>
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/server.hpp>
-#include <websocketpp/client.hpp>
-
-typedef websocketpp::server<websocketpp::config::core> server;
-/// NOTE: the "server" config is being used for the client here because we don't
-/// want to pull in the real RNG. A better way to do this might be a custom
-/// client config with the RNG explicitly stubbed out.
-typedef websocketpp::client<websocketpp::config::core> client;
-typedef websocketpp::config::core::message_type::ptr message_ptr;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg);
-std::string run_server_test(std::string input, bool log = false);
-std::string run_server_test(server & s, std::string input, bool log = false);
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/CMakeLists.txt
deleted file mode 100644
index 1b25353..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-if (OPENSSL_FOUND)
-
-init_target (test_endpoint)
-
-build_test (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-link_openssl ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-endif()
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/SConscript
deleted file mode 100644
index 5cb3ede..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## endpoint unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + [tls_libs]
-
-objs = env.Object('endpoint_boost.o', ["endpoint.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_endpoint_boost', ["endpoint_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   objs += env_cpp11.Object('endpoint_stl.o', ["endpoint.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_endpoint_stl', ["endpoint_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/endpoint.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/endpoint.cpp
deleted file mode 100644
index b4c429e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/endpoint/endpoint.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE endpoint
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <sstream>
-
-#include <websocketpp/config/asio.hpp>
-#include <websocketpp/server.hpp>
-
-BOOST_AUTO_TEST_CASE( construct_server_iostream ) {
-    websocketpp::server<websocketpp::config::core> s;
-}
-
-BOOST_AUTO_TEST_CASE( construct_server_asio_plain ) {
-    websocketpp::server<websocketpp::config::asio> s;
-}
-
-BOOST_AUTO_TEST_CASE( construct_server_asio_tls ) {
-    websocketpp::server<websocketpp::config::asio_tls> s;
-}
-
-BOOST_AUTO_TEST_CASE( initialize_server_asio ) {
-    websocketpp::server<websocketpp::config::asio> s;
-    s.init_asio();
-}
-
-BOOST_AUTO_TEST_CASE( initialize_server_asio_external ) {
-    websocketpp::server<websocketpp::config::asio> s;
-    boost::asio::io_service ios;
-    s.init_asio(&ios);
-}
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-BOOST_AUTO_TEST_CASE( move_construct_server_core ) {
-    websocketpp::server<websocketpp::config::core> s1;
-    
-    websocketpp::server<websocketpp::config::core> s2(std::move(s1));
-}
-
-/*
-// temporary disable because library doesn't pass
-BOOST_AUTO_TEST_CASE( emplace ) {
-    std::stringstream out1;
-    std::stringstream out2;
-    
-    std::vector<websocketpp::server<websocketpp::config::asio_tls>> v;
-    
-    v.emplace_back();
-    v.emplace_back();
-    
-    v[0].get_alog().set_ostream(&out1);
-    v[0].get_alog().set_ostream(&out2);
-    
-    v[0].get_alog().write(websocketpp::log::alevel::app,"devel0");
-    v[1].get_alog().write(websocketpp::log::alevel::app,"devel1");
-    BOOST_CHECK( out1.str().size() > 0 );
-    BOOST_CHECK( out2.str().size() > 0 );
-}*/
-
-#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
-
-struct endpoint_extension {
-    endpoint_extension() : extension_value(5) {}
-
-    int extension_method() {
-        return extension_value;
-    }
-
-    bool is_server() const {
-        return false;
-    }
-
-    int extension_value;
-};
-
-struct stub_config : public websocketpp::config::core {
-    typedef core::concurrency_type concurrency_type;
-
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-
-    typedef core::rng_type rng_type;
-
-    typedef core::transport_type transport_type;
-
-    typedef endpoint_extension endpoint_base;
-};
-
-BOOST_AUTO_TEST_CASE( endpoint_extensions ) {
-    websocketpp::server<stub_config> s;
-
-    BOOST_CHECK_EQUAL( s.extension_value, 5 );
-    BOOST_CHECK_EQUAL( s.extension_method(), 5 );
-
-    BOOST_CHECK( s.is_server() );
-}
-
-BOOST_AUTO_TEST_CASE( listen_after_listen_failure ) {
-    using websocketpp::transport::asio::error::make_error_code;
-    using websocketpp::transport::asio::error::pass_through;
-
-    websocketpp::server<websocketpp::config::asio> server1;
-    websocketpp::server<websocketpp::config::asio> server2;
-
-    websocketpp::lib::error_code ec;
-
-    server1.init_asio();
-    server2.init_asio();
-
-    boost::asio::ip::tcp::endpoint ep1(boost::asio::ip::address::from_string("127.0.0.1"), 12345);
-    boost::asio::ip::tcp::endpoint ep2(boost::asio::ip::address::from_string("127.0.0.1"), 23456);
-
-    server1.listen(ep1, ec);
-    BOOST_CHECK(!ec);
-
-    // This should return some sort of problem. Usually either "pass through" or
-    // a more specific address in use error. It is hard to capture the full range
-    // of 'correctly wrong' values.
-    server2.listen(ep1, ec);
-    BOOST_REQUIRE(ec);
-
-    server2.listen(ep2, ec);
-    BOOST_CHECK(!ec);
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/CMakeLists.txt
deleted file mode 100644
index 9cb8f8a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-# Extension Tests
-file (GLOB SOURCE extension.cpp)
-
-init_target (test_extension)
-build_executable (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-if ( ZLIB_FOUND )
-
-# Permessage-deflate tests
-file (GLOB SOURCE permessage_deflate.cpp)
-
-init_target (test_permessage_deflate)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_zlib()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-endif ( ZLIB_FOUND )
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/SConscript
deleted file mode 100644
index d8b425f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/SConscript
+++ /dev/null
@@ -1,27 +0,0 @@
-## http unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + ['z']
-
-objs = env.Object('extension_boost.o', ["extension.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('permessage_deflate_boost.o', ["permessage_deflate.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_extension_boost', ["extension_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_permessage_deflate_boost', ["permessage_deflate_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
-   objs += env_cpp11.Object('extension_stl.o', ["extension.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('permessage_deflate_stl.o', ["permessage_deflate.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_extension_stl', ["extension_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_permessage_deflate_stl', ["permessage_deflate_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/extension.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/extension.cpp
deleted file mode 100644
index 5439c07..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/extension.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE extension
-#include <boost/test/unit_test.hpp>
-
-#include <string>
-
-#include <websocketpp/extensions/extension.hpp>
-
-BOOST_AUTO_TEST_CASE( blank ) {
-    BOOST_CHECK( true );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/permessage_deflate.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/permessage_deflate.cpp
deleted file mode 100644
index 805afcc..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/extension/permessage_deflate.cpp
+++ /dev/null
@@ -1,752 +0,0 @@
-/*
- * Copyright (c) 2013, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE permessage_deflate
-#include <boost/test/unit_test.hpp>
-
-#include <websocketpp/error.hpp>
-
-#include <websocketpp/extensions/extension.hpp>
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-#include <string>
-
-#include <websocketpp/utilities.hpp>
-#include <iostream>
-
-class config {};
-
-typedef websocketpp::extensions::permessage_deflate::enabled<config> enabled_type;
-typedef websocketpp::extensions::permessage_deflate::disabled<config> disabled_type;
-
-struct ext_vars {
-    enabled_type exts;
-    enabled_type extc;
-    websocketpp::lib::error_code ec;
-    websocketpp::err_str_pair esp;
-    websocketpp::http::attribute_list attr;
-};
-namespace pmde = websocketpp::extensions::permessage_deflate::error;
-namespace pmd_mode = websocketpp::extensions::permessage_deflate::mode;
-
-// Ensure the disabled extension behaves appropriately disabled
-
-BOOST_AUTO_TEST_CASE( disabled_is_disabled ) {
-    disabled_type exts;
-    BOOST_CHECK( !exts.is_implemented() );
-}
-
-BOOST_AUTO_TEST_CASE( disabled_is_off ) {
-    disabled_type exts;
-    BOOST_CHECK( !exts.is_enabled() );
-}
-
-// Ensure the enabled version actually works
-
-BOOST_AUTO_TEST_CASE( enabled_is_enabled ) {
-    ext_vars v;
-    BOOST_CHECK( v.exts.is_implemented() );
-    BOOST_CHECK( v.extc.is_implemented() );
-}
-
-
-BOOST_AUTO_TEST_CASE( enabled_starts_disabled ) {
-    ext_vars v;
-    BOOST_CHECK( !v.exts.is_enabled() );
-    BOOST_CHECK( !v.extc.is_enabled() );
-}
-
-BOOST_AUTO_TEST_CASE( negotiation_empty_attr ) {
-    ext_vars v;
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( negotiation_invalid_attr ) {
-    ext_vars v;
-    v.attr["foo"] = "bar";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( !v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attributes) );
-    BOOST_CHECK_EQUAL( v.esp.second, "");
-}
-
-// Negotiate server_no_context_takeover
-BOOST_AUTO_TEST_CASE( negotiate_server_no_context_takeover_invalid ) {
-    ext_vars v;
-    v.attr["server_no_context_takeover"] = "foo";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( !v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
-    BOOST_CHECK_EQUAL( v.esp.second, "");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_no_context_takeover ) {
-    ext_vars v;
-    v.attr["server_no_context_takeover"].clear();
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_no_context_takeover_server_initiated ) {
-    ext_vars v;
-
-    v.exts.enable_server_no_context_takeover();
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover");
-}
-
-// Negotiate client_no_context_takeover
-BOOST_AUTO_TEST_CASE( negotiate_client_no_context_takeover_invalid ) {
-    ext_vars v;
-    v.attr["client_no_context_takeover"] = "foo";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( !v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
-    BOOST_CHECK_EQUAL( v.esp.second, "");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_no_context_takeover ) {
-    ext_vars v;
-    v.attr["client_no_context_takeover"].clear();
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_no_context_takeover");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_no_context_takeover_server_initiated ) {
-    ext_vars v;
-
-    v.exts.enable_client_no_context_takeover();
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_no_context_takeover");
-}
-
-
-// Negotiate server_max_window_bits
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_invalid ) {
-    ext_vars v;
-
-    std::vector<std::string> values;
-    values.push_back("");
-    values.push_back("foo");
-    values.push_back("7");
-    values.push_back("16");
-
-    std::vector<std::string>::const_iterator it;
-    for (it = values.begin(); it != values.end(); ++it) {
-        v.attr["server_max_window_bits"] = *it;
-
-        v.esp = v.exts.negotiate(v.attr);
-        BOOST_CHECK( !v.exts.is_enabled() );
-        BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
-        BOOST_CHECK_EQUAL( v.esp.second, "");
-    }
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_valid ) {
-    ext_vars v;
-    
-    // confirm that a request for a value of 8 is interpreted as 9
-    v.attr["server_max_window_bits"] = "8";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-
-    v.attr["server_max_window_bits"] = "9";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-
-
-    v.attr["server_max_window_bits"] = "15";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( invalid_set_server_max_window_bits ) {
-    ext_vars v;
-
-    v.ec = v.exts.set_server_max_window_bits(7,pmd_mode::decline);
-    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
-
-    v.ec = v.exts.set_server_max_window_bits(16,pmd_mode::decline);
-    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_decline ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::decline);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_accept_8 ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::accept);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_accept ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::accept);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_largest_8 ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::largest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_largest ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::largest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_smallest_8 ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::smallest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_server_max_window_bits_smallest ) {
-    ext_vars v;
-    v.attr["server_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_server_max_window_bits(15,pmd_mode::smallest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=9");
-}
-
-// Negotiate server_max_window_bits
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_invalid ) {
-    ext_vars v;
-
-    std::vector<std::string> values;
-    values.push_back("foo");
-    values.push_back("7");
-    values.push_back("16");
-
-    std::vector<std::string>::const_iterator it;
-    for (it = values.begin(); it != values.end(); ++it) {
-        v.attr["client_max_window_bits"] = *it;
-
-        v.esp = v.exts.negotiate(v.attr);
-        BOOST_CHECK( !v.exts.is_enabled() );
-        BOOST_CHECK_EQUAL( v.esp.first, pmde::make_error_code(pmde::invalid_attribute_value) );
-        BOOST_CHECK_EQUAL( v.esp.second, "");
-    }
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_valid ) {
-    ext_vars v;
-
-    v.attr["client_max_window_bits"].clear();
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-
-    v.attr["client_max_window_bits"] = "8";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-
-    v.attr["client_max_window_bits"] = "9";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-
-    v.attr["client_max_window_bits"] = "15";
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( invalid_set_client_max_window_bits ) {
-    ext_vars v;
-
-    v.ec = v.exts.set_client_max_window_bits(7,pmd_mode::decline);
-    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
-
-    v.ec = v.exts.set_client_max_window_bits(16,pmd_mode::decline);
-    BOOST_CHECK_EQUAL(v.ec,pmde::make_error_code(pmde::invalid_max_window_bits));
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_decline_8 ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_client_max_window_bits(8,pmd_mode::decline);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_decline ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_client_max_window_bits(9,pmd_mode::decline);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_accept_8 ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::accept);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_accept ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::accept);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_largest_8 ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::largest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_largest ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::largest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_smallest_8 ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "8";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::smallest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_client_max_window_bits_smallest ) {
-    ext_vars v;
-    v.attr["client_max_window_bits"] = "9";
-
-    v.ec = v.exts.set_client_max_window_bits(15,pmd_mode::smallest);
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_max_window_bits=9");
-}
-
-
-// Combinations with 2
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated1 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["client_no_context_takeover"].clear();
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; client_no_context_takeover");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated2 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; server_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated3 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated4 ) {
-    ext_vars v;
-
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_no_context_takeover; server_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated5 ) {
-    ext_vars v;
-
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_no_context_takeover; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_two_client_initiated6 ) {
-    ext_vars v;
-
-    v.attr["server_max_window_bits"] = "10";
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_max_window_bits=10; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated1 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; client_no_context_takeover; server_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated2 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; client_no_context_takeover; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated3 ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; server_max_window_bits=10; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_three_client_initiated4 ) {
-    ext_vars v;
-
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; client_no_context_takeover; server_max_window_bits=10; client_max_window_bits=10");
-}
-
-BOOST_AUTO_TEST_CASE( negotiate_four_client_initiated ) {
-    ext_vars v;
-
-    v.attr["server_no_context_takeover"].clear();
-    v.attr["client_no_context_takeover"].clear();
-    v.attr["server_max_window_bits"] = "10";
-    v.attr["client_max_window_bits"] = "10";
-
-    v.esp = v.exts.negotiate(v.attr);
-    BOOST_CHECK( v.exts.is_enabled() );
-    BOOST_CHECK_EQUAL( v.esp.first, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( v.esp.second, "permessage-deflate; server_no_context_takeover; client_no_context_takeover; server_max_window_bits=10; client_max_window_bits=10");
-}
-
-// Compression
-BOOST_AUTO_TEST_CASE( compress_data ) {
-    ext_vars v;
-
-    std::string compress_in = "Hello";
-    std::string compress_out;
-    std::string decompress_out;
-
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.compress(compress_in,compress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(compress_out.data()),compress_out.size(),decompress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( compress_in, decompress_out );
-}
-
-BOOST_AUTO_TEST_CASE( compress_data_multiple ) {
-    ext_vars v;
-
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    for (int i = 0; i < 2; i++) {
-        std::string compress_in = "Hello";
-        std::string compress_out;
-        std::string decompress_out;
-
-        v.ec = v.exts.compress(compress_in,compress_out);
-        BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-        v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(compress_out.data()),compress_out.size(),decompress_out);
-        BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-        BOOST_CHECK_EQUAL( compress_in, decompress_out );
-    }
-}
-
-BOOST_AUTO_TEST_CASE( compress_data_large ) {
-    ext_vars v;
-
-    std::string compress_in(600,'*');
-    std::string compress_out;
-    std::string decompress_out;
-
-    websocketpp::http::attribute_list alist;
-
-    alist["server_max_window_bits"] = "9";
-    v.exts.set_server_max_window_bits(9,websocketpp::extensions::permessage_deflate::mode::smallest);
-
-    v.exts.negotiate(alist);
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.compress(compress_in,compress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(compress_out.data()),compress_out.size(),decompress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( compress_in, decompress_out );
-}
-
-BOOST_AUTO_TEST_CASE( compress_data_no_context_takeover ) {
-    ext_vars v;
-
-    std::string compress_in = "Hello";
-    std::string compress_out1;
-    std::string compress_out2;
-    std::string decompress_out;
-
-    websocketpp::http::attribute_list alist;
-
-    alist["server_no_context_takeover"].clear();
-    v.exts.enable_server_no_context_takeover();
-
-    v.exts.negotiate(alist);
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.compress(compress_in,compress_out1);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(
-        reinterpret_cast<const uint8_t *>(compress_out1.data()),
-        compress_out1.size(),
-        decompress_out
-    );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( compress_in, decompress_out );
-
-    decompress_out.clear();
-
-    v.ec = v.exts.compress(compress_in,compress_out2);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(
-        reinterpret_cast<const uint8_t *>(compress_out2.data()),
-        compress_out2.size(),
-        decompress_out
-    );
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( compress_in, decompress_out );
-
-    BOOST_CHECK_EQUAL( compress_out1, compress_out2 );
-}
-
-BOOST_AUTO_TEST_CASE( compress_empty ) {
-    ext_vars v;
-
-    std::string compress_in;
-    std::string compress_out;
-    std::string decompress_out;
-
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.compress(compress_in,compress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(compress_out.data()),compress_out.size(),decompress_out);
-
-    compress_out.clear();
-    decompress_out.clear();
-
-    v.ec = v.exts.compress(compress_in,compress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(reinterpret_cast<const uint8_t *>(compress_out.data()),compress_out.size(),decompress_out);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( compress_in, decompress_out );
-}
-
-/// @todo: more compression tests
-/**
- * - compress at different compression levels
- */
-
-// Decompression
-BOOST_AUTO_TEST_CASE( decompress_data ) {
-    ext_vars v;
-
-    uint8_t in[11] = {0xf2, 0x48, 0xcd, 0xc9, 0xc9, 0x07, 0x00, 0x00, 0x00, 0xff, 0xff};
-    std::string out;
-    std::string reference = "Hello";
-
-    v.ec = v.exts.init(true);
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-
-    v.ec = v.exts.decompress(in,11,out);
-
-    BOOST_CHECK_EQUAL( v.ec, websocketpp::lib::error_code() );
-    BOOST_CHECK_EQUAL( out, reference );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/http/CMakeLists.txt
deleted file mode 100644
index e005477..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-
-file (GLOB SOURCE_FILES parser.cpp)
-
-init_target (test_http)
-
-build_test (${TARGET_NAME} ${SOURCE_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/http/SConscript
deleted file mode 100644
index 0a24a87..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## http unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework'],env) + [platform_libs]
-
-objs = env.Object('parser_boost.o', ["parser.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_http_boost', ["parser_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('parser_stl.o', ["parser.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_http_stl', ["parser_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser.cpp
deleted file mode 100644
index b6e0d37..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser.cpp
+++ /dev/null
@@ -1,1141 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE http_parser
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-BOOST_AUTO_TEST_CASE( is_token_char ) {
-    // Valid characters
-
-    // misc
-    BOOST_CHECK( websocketpp::http::is_token_char('!') );
-    BOOST_CHECK( websocketpp::http::is_token_char('#') );
-    BOOST_CHECK( websocketpp::http::is_token_char('$') );
-    BOOST_CHECK( websocketpp::http::is_token_char('%') );
-    BOOST_CHECK( websocketpp::http::is_token_char('&') );
-    BOOST_CHECK( websocketpp::http::is_token_char('\'') );
-    BOOST_CHECK( websocketpp::http::is_token_char('*') );
-    BOOST_CHECK( websocketpp::http::is_token_char('+') );
-    BOOST_CHECK( websocketpp::http::is_token_char('-') );
-    BOOST_CHECK( websocketpp::http::is_token_char('.') );
-    BOOST_CHECK( websocketpp::http::is_token_char('^') );
-    BOOST_CHECK( websocketpp::http::is_token_char('_') );
-    BOOST_CHECK( websocketpp::http::is_token_char('`') );
-    BOOST_CHECK( websocketpp::http::is_token_char('~') );
-
-    // numbers
-    for (int i = 0x30; i < 0x3a; i++) {
-        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
-    }
-
-    // upper
-    for (int i = 0x41; i < 0x5b; i++) {
-        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
-    }
-
-    // lower
-    for (int i = 0x61; i < 0x7b; i++) {
-        BOOST_CHECK( websocketpp::http::is_token_char((unsigned char)(i)) );
-    }
-
-    // invalid characters
-
-    // lower unprintable
-    for (int i = 0; i < 33; i++) {
-        BOOST_CHECK( !websocketpp::http::is_token_char((unsigned char)(i)) );
-    }
-
-    // misc
-    BOOST_CHECK( !websocketpp::http::is_token_char('(') );
-    BOOST_CHECK( !websocketpp::http::is_token_char(')') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('<') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('>') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('@') );
-    BOOST_CHECK( !websocketpp::http::is_token_char(',') );
-    BOOST_CHECK( !websocketpp::http::is_token_char(';') );
-    BOOST_CHECK( !websocketpp::http::is_token_char(':') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('\\') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('"') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('/') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('[') );
-    BOOST_CHECK( !websocketpp::http::is_token_char(']') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('?') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('=') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('{') );
-    BOOST_CHECK( !websocketpp::http::is_token_char('}') );
-
-    // upper unprintable and out of ascii range
-    for (int i = 127; i < 256; i++) {
-        BOOST_CHECK( !websocketpp::http::is_token_char((unsigned char)(i)) );
-    }
-
-    // is not
-    BOOST_CHECK( !websocketpp::http::is_not_token_char('!') );
-    BOOST_CHECK( websocketpp::http::is_not_token_char('(') );
-}
-
-BOOST_AUTO_TEST_CASE( extract_token ) {
-    std::string d1 = "foo";
-    std::string d2 = " foo ";
-
-    std::pair<std::string,std::string::const_iterator> ret;
-
-    ret = websocketpp::http::parser::extract_token(d1.begin(),d1.end());
-    BOOST_CHECK( ret.first == "foo" );
-    BOOST_CHECK( ret.second == d1.begin()+3 );
-
-    ret = websocketpp::http::parser::extract_token(d2.begin(),d2.end());
-    BOOST_CHECK( ret.first.empty() );
-    BOOST_CHECK( ret.second == d2.begin()+0 );
-
-    ret = websocketpp::http::parser::extract_token(d2.begin()+1,d2.end());
-    BOOST_CHECK( ret.first == "foo" );
-    BOOST_CHECK( ret.second == d2.begin()+4 );
-}
-
-BOOST_AUTO_TEST_CASE( extract_quoted_string ) {
-    std::string d1 = "\"foo\"";
-    std::string d2 = "\"foo\\\"bar\\\"baz\"";
-    std::string d3 = "\"foo\"     ";
-    std::string d4;
-    std::string d5 = "foo";
-
-    std::pair<std::string,std::string::const_iterator> ret;
-
-    using websocketpp::http::parser::extract_quoted_string;
-
-    ret = extract_quoted_string(d1.begin(),d1.end());
-    BOOST_CHECK( ret.first == "foo" );
-    BOOST_CHECK( ret.second == d1.end() );
-
-    ret = extract_quoted_string(d2.begin(),d2.end());
-    BOOST_CHECK( ret.first == "foo\"bar\"baz" );
-    BOOST_CHECK( ret.second == d2.end() );
-
-    ret = extract_quoted_string(d3.begin(),d3.end());
-    BOOST_CHECK( ret.first == "foo" );
-    BOOST_CHECK( ret.second == d3.begin()+5 );
-
-    ret = extract_quoted_string(d4.begin(),d4.end());
-    BOOST_CHECK( ret.first.empty() );
-    BOOST_CHECK( ret.second == d4.begin() );
-
-    ret = extract_quoted_string(d5.begin(),d5.end());
-    BOOST_CHECK( ret.first.empty() );
-    BOOST_CHECK( ret.second == d5.begin() );
-}
-
-BOOST_AUTO_TEST_CASE( extract_all_lws ) {
-    std::string d1 = " foo     bar";
-    d1.append(1,char(9));
-    d1.append("baz\r\n d\r\n  \r\n  e\r\nf");
-
-    std::string::const_iterator ret;
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin(),d1.end());
-    BOOST_CHECK( ret == d1.begin()+1 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+1,d1.end());
-    BOOST_CHECK( ret == d1.begin()+1 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+4,d1.end());
-    BOOST_CHECK( ret == d1.begin()+9 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+12,d1.end());
-    BOOST_CHECK( ret == d1.begin()+13 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+16,d1.end());
-    BOOST_CHECK( ret == d1.begin()+19 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+20,d1.end());
-    BOOST_CHECK( ret == d1.begin()+28 );
-
-    ret = websocketpp::http::parser::extract_all_lws(d1.begin()+29,d1.end());
-    BOOST_CHECK( ret == d1.begin()+29 );
-}
-
-BOOST_AUTO_TEST_CASE( extract_attributes_blank ) {
-    std::string s;
-
-    websocketpp::http::attribute_list a;
-    std::string::const_iterator it;
-
-    it = websocketpp::http::parser::extract_attributes(s.begin(),s.end(),a);
-    BOOST_CHECK( it == s.begin() );
-    BOOST_CHECK_EQUAL( a.size(), 0 );
-}
-
-BOOST_AUTO_TEST_CASE( extract_attributes_simple ) {
-    std::string s = "foo";
-
-    websocketpp::http::attribute_list a;
-    std::string::const_iterator it;
-
-    it = websocketpp::http::parser::extract_attributes(s.begin(),s.end(),a);
-    BOOST_CHECK( it == s.end() );
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("foo") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("foo")->second, "" );
-}
-
-BOOST_AUTO_TEST_CASE( extract_parameters ) {
-    std::string s1;
-    std::string s2 = "foo";
-    std::string s3 = " foo \r\nAbc";
-    std::string s4 = "  \r\n   foo  ";
-    std::string s5 = "foo,bar";
-    std::string s6 = "foo;bar";
-    std::string s7 = "foo;baz,bar";
-    std::string s8 = "foo;bar;baz";
-    std::string s9 = "foo;bar=baz";
-    std::string s10 = "foo;bar=baz;boo";
-    std::string s11 = "foo;bar=baz;boo,bob";
-    std::string s12 = "foo;bar=\"a b c\"";
-    std::string s13 = "foo;bar=\"a \\\"b\\\" c\"";
-
-
-    std::string sx = "foo;bar=\"a \\\"b\\\" c\"";
-    websocketpp::http::parameter_list p;
-    websocketpp::http::attribute_list a;
-    std::string::const_iterator it;
-
-    using websocketpp::http::parser::extract_parameters;
-
-    it = extract_parameters(s1.begin(),s1.end(),p);
-    BOOST_CHECK( it == s1.begin() );
-
-    p.clear();
-    it = extract_parameters(s2.begin(),s2.end(),p);
-    BOOST_CHECK( it == s2.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s3.begin(),s3.end(),p);
-    BOOST_CHECK( it == s3.begin()+5 );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s4.begin(),s4.end(),p);
-    BOOST_CHECK( it == s4.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s5.begin(),s5.end(),p);
-    BOOST_CHECK( it == s5.end() );
-    BOOST_CHECK_EQUAL( p.size(), 2 );
-    BOOST_CHECK( p[0].first == "foo" );
-    BOOST_CHECK_EQUAL( p[0].second.size(), 0 );
-    BOOST_CHECK( p[1].first == "bar" );
-    BOOST_CHECK_EQUAL( p[1].second.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s6.begin(),s6.end(),p);
-    BOOST_CHECK( it == s6.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "" );
-
-    p.clear();
-    it = extract_parameters(s7.begin(),s7.end(),p);
-    BOOST_CHECK( it == s7.end() );
-    BOOST_CHECK_EQUAL( p.size(), 2 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("baz") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("baz")->second, "" );
-    BOOST_CHECK( p[1].first == "bar" );
-    a = p[1].second;
-    BOOST_CHECK_EQUAL( a.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s8.begin(),s8.end(),p);
-    BOOST_CHECK( it == s8.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 2 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "" );
-    BOOST_CHECK( a.find("baz") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("baz")->second, "" );
-
-    p.clear();
-    it = extract_parameters(s9.begin(),s9.end(),p);
-    BOOST_CHECK( it == s9.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
-
-    p.clear();
-    it = extract_parameters(s10.begin(),s10.end(),p);
-    BOOST_CHECK( it == s10.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 2 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
-    BOOST_CHECK( a.find("boo") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("boo")->second, "" );
-
-    p.clear();
-    it = extract_parameters(s11.begin(),s11.end(),p);
-    BOOST_CHECK( it == s11.end() );
-    BOOST_CHECK_EQUAL( p.size(), 2 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 2 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "baz" );
-    BOOST_CHECK( a.find("boo") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("boo")->second, "" );
-    a = p[1].second;
-    BOOST_CHECK_EQUAL( a.size(), 0 );
-
-    p.clear();
-    it = extract_parameters(s12.begin(),s12.end(),p);
-    BOOST_CHECK( it == s12.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "a b c" );
-
-    p.clear();
-    it = extract_parameters(s13.begin(),s13.end(),p);
-    BOOST_CHECK( it == s13.end() );
-    BOOST_CHECK_EQUAL( p.size(), 1 );
-    BOOST_CHECK( p[0].first == "foo" );
-    a = p[0].second;
-    BOOST_CHECK_EQUAL( a.size(), 1 );
-    BOOST_CHECK( a.find("bar") != a.end() );
-    BOOST_CHECK_EQUAL( a.find("bar")->second, "a \"b\" c" );
-}
-
-BOOST_AUTO_TEST_CASE( strip_lws ) {
-    std::string test1 = "foo";
-    std::string test2 = " foo ";
-    std::string test3 = "foo ";
-    std::string test4 = " foo";
-    std::string test5 = "    foo     ";
-    std::string test6 = "  \r\n  foo     ";
-    std::string test7 = "  \t  foo     ";
-    std::string test8 = "  \t       ";
-    std::string test9 = " \n\r";
-
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test1), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test2), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test3), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test4), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test5), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test6), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test7), "foo" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test8), "" );
-    BOOST_CHECK_EQUAL( websocketpp::http::parser::strip_lws(test9), "" );
-}
-
-BOOST_AUTO_TEST_CASE( case_insensitive_headers ) {
-    websocketpp::http::parser::parser r;
-
-    r.replace_header("foo","bar");
-
-    BOOST_CHECK_EQUAL( r.get_header("foo"), "bar" );
-    BOOST_CHECK_EQUAL( r.get_header("FOO"), "bar" );
-    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar" );
-}
-
-BOOST_AUTO_TEST_CASE( case_insensitive_headers_overwrite ) {
-    websocketpp::http::parser::parser r;
-
-    r.replace_header("foo","bar");
-
-    BOOST_CHECK_EQUAL( r.get_header("foo"), "bar" );
-    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar" );
-
-    r.replace_header("Foo","baz");
-
-    BOOST_CHECK_EQUAL( r.get_header("foo"), "baz" );
-    BOOST_CHECK_EQUAL( r.get_header("Foo"), "baz" );
-
-    r.remove_header("FoO");
-
-    BOOST_CHECK_EQUAL( r.get_header("foo"), "" );
-    BOOST_CHECK_EQUAL( r.get_header("Foo"), "" );
-}
-
-BOOST_AUTO_TEST_CASE( blank_consume ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw;
-
-    bool exception = false;
-
-    try {
-        r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( r.ready() == false );
-}
-
-BOOST_AUTO_TEST_CASE( blank_request ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "\r\n\r\n";
-
-    bool exception = false;
-
-    try {
-        r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == true );
-    BOOST_CHECK( r.ready() == false );
-}
-
-BOOST_AUTO_TEST_CASE( bad_request_no_host ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\n\r\n";
-
-    bool exception = false;
-
-    try {
-        r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == true );
-    BOOST_CHECK( r.ready() == false );
-}
-
-BOOST_AUTO_TEST_CASE( basic_request ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( basic_request_with_body ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\nContent-Length: 5\r\n\r\nabcdef";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 65 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-    BOOST_CHECK_EQUAL( r.get_header("Content-Length"), "5" );
-    BOOST_CHECK_EQUAL( r.get_body(), "abcde" );
-    
-    BOOST_CHECK_EQUAL( r.get_headers().size(), 2);
-    
-    websocketpp::http::parser::header_list::const_iterator it = r.get_headers().begin();
-    
-    BOOST_CHECK_EQUAL( it->first, "Content-Length");
-    BOOST_CHECK_EQUAL( it->second, "5");
-    
-    it++;
-    
-    BOOST_CHECK_EQUAL( it->first, "Host");
-    BOOST_CHECK_EQUAL( it->second, "www.example.com");
-}
-
-BOOST_AUTO_TEST_CASE( basic_request_with_body_split ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\nContent-Length: 6\r\n\r\nabc";
-    std::string raw2 = "def";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-        pos += r.consume(raw2.c_str(),raw2.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 66 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-    BOOST_CHECK_EQUAL( r.get_header("Content-Length"), "6" );
-    BOOST_CHECK_EQUAL( r.get_body(), "abcdef" );
-}
-
-
-
-BOOST_AUTO_TEST_CASE( trailing_body_characters ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\na";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( trailing_body_characters_beyond_max_lenth ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-    raw.append(websocketpp::http::max_header_size,'*');
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( basic_split1 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\n";
-    std::string raw2 = "Host: www.example.com\r\n\r\na";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-        pos += r.consume(raw2.c_str(),raw2.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( basic_split2 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r";
-    std::string raw2 = "\n\r\na";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-        pos += r.consume(raw2.c_str(),raw2.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( max_header_len ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw(websocketpp::http::max_header_size-1,'*');
-    raw += "\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (const websocketpp::http::exception& e) {
-        if (e.m_error_code == websocketpp::http::status_code::request_header_fields_too_large) {
-            exception = true;
-        }
-    }
-
-    BOOST_CHECK( exception == true );
-}
-
-BOOST_AUTO_TEST_CASE( max_header_len_split ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw(websocketpp::http::max_header_size-1,'*');
-    std::string raw2(2,'*');
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-        pos += r.consume(raw2.c_str(),raw2.size());
-    } catch (const websocketpp::http::exception& e) {
-        if (e.m_error_code == websocketpp::http::status_code::request_header_fields_too_large) {
-            exception = true;
-        }
-    }
-
-    BOOST_CHECK( exception == true );
-}
-
-BOOST_AUTO_TEST_CASE( max_body_len ) {
-    websocketpp::http::parser::request r;
-    
-    r.set_max_body_size(5);
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\nContent-Length: 6\r\n\r\nabcdef";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (websocketpp::http::exception const & e) {
-        exception = true;
-        BOOST_CHECK_EQUAL(e.m_error_code,websocketpp::http::status_code::request_entity_too_large);
-    }
-
-    BOOST_CHECK_EQUAL(r.get_max_body_size(),5);
-    BOOST_CHECK( exception == true );
-}
-
-BOOST_AUTO_TEST_CASE( firefox_full_request ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK( pos == 482 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK( r.get_version() == "HTTP/1.1" );
-    BOOST_CHECK( r.get_method() == "GET" );
-    BOOST_CHECK( r.get_uri() == "/" );
-    BOOST_CHECK( r.get_header("Host") == "localhost:5000" );
-    BOOST_CHECK( r.get_header("User-Agent") == "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0" );
-    BOOST_CHECK( r.get_header("Accept") == "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" );
-    BOOST_CHECK( r.get_header("Accept-Language") == "en-us,en;q=0.5" );
-    BOOST_CHECK( r.get_header("Accept-Encoding") == "gzip, deflate" );
-    BOOST_CHECK( r.get_header("Connection") == "keep-alive, Upgrade" );
-    BOOST_CHECK( r.get_header("Sec-WebSocket-Version") == "8" );
-    BOOST_CHECK( r.get_header("Sec-WebSocket-Origin") == "http://zaphoyd.com" );
-    BOOST_CHECK( r.get_header("Sec-WebSocket-Key") == "pFik//FxwFk0riN4ZiPFjQ==" );
-    BOOST_CHECK( r.get_header("Pragma") == "no-cache" );
-    BOOST_CHECK( r.get_header("Cache-Control") == "no-cache" );
-    BOOST_CHECK( r.get_header("Upgrade") == "websocket" );
-}
-
-BOOST_AUTO_TEST_CASE( bad_method ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GE]T / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-
-    try {
-        r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == true );
-}
-
-BOOST_AUTO_TEST_CASE( bad_header_name ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHo]st: www.example.com\r\n\r\n";
-
-    bool exception = false;
-
-    try {
-        r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == true );
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.0\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 41 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.0" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( new_http_version1 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.12\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 42 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.12" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( new_http_version2 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/12.12\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 43 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/12.12" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-}
-
-/* commented out due to not being implemented yet
-
-BOOST_AUTO_TEST_CASE( new_http_version3 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTPS/12.12\r\nHost: www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == true );
-}*/
-
-BOOST_AUTO_TEST_CASE( header_whitespace1 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost:  www.example.com \r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 43 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( header_whitespace2 ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost:www.example.com\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 40 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "www.example.com" );
-}
-
-BOOST_AUTO_TEST_CASE( header_aggregation ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\nFoo: bar\r\nFoo: bat\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos = r.consume(raw.c_str(),raw.size());
-    } catch (...) {
-        exception = true;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 61 );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( r.get_uri(), "/" );
-    BOOST_CHECK_EQUAL( r.get_header("Foo"), "bar, bat" );
-}
-
-BOOST_AUTO_TEST_CASE( wikipedia_example_response ) {
-    websocketpp::http::parser::response r;
-
-    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 159 );
-    BOOST_CHECK( r.headers_ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
-    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
-    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
-    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
-}
-
-BOOST_AUTO_TEST_CASE( wikipedia_example_response_trailing ) {
-    websocketpp::http::parser::response r;
-
-    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
-    raw += "a";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 159 );
-    BOOST_CHECK( r.headers_ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
-    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
-    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
-    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
-}
-
-BOOST_AUTO_TEST_CASE( wikipedia_example_response_trailing_large ) {
-    websocketpp::http::parser::response r;
-
-    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
-    raw.append(websocketpp::http::max_header_size,'*');
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 159 );
-    BOOST_CHECK( r.headers_ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
-    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
-    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
-    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
-}
-
-BOOST_AUTO_TEST_CASE( response_with_non_standard_lws ) {
-    websocketpp::http::parser::response r;
-
-    std::string raw = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept:HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\nSec-WebSocket-Protocol: chat\r\n\r\n";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 158 );
-    BOOST_CHECK( r.headers_ready() );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::switching_protocols );
-    BOOST_CHECK_EQUAL( r.get_status_msg(), "Switching Protocols" );
-    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket" );
-    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Accept"), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=" );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "chat" );
-}
-
-BOOST_AUTO_TEST_CASE( plain_http_response ) {
-    websocketpp::http::parser::response r;
-
-    std::string raw = "HTTP/1.1 200 OK\r\nDate: Thu, 10 May 2012 11:59:25 GMT\r\nServer: Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch\r\nLast-Modified: Tue, 30 Mar 2010 17:41:28 GMT\r\nETag: \"16799d-55-4830823a78200\"\r\nAccept-Ranges: bytes\r\nContent-Length: 85\r\nVary: Accept-Encoding\r\nContent-Type: text/html\r\n\r\n<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(raw.c_str(),raw.size());
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK( exception == false );
-    BOOST_CHECK_EQUAL( pos, 405 );
-    BOOST_CHECK( r.headers_ready() == true );
-    BOOST_CHECK( r.ready() == true );
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1" );
-    BOOST_CHECK_EQUAL( r.get_status_code(), websocketpp::http::status_code::ok );
-    BOOST_CHECK_EQUAL( r.get_status_msg(), "OK" );
-    BOOST_CHECK_EQUAL( r.get_header("Date"), "Thu, 10 May 2012 11:59:25 GMT" );
-    BOOST_CHECK_EQUAL( r.get_header("Server"), "Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch" );
-    BOOST_CHECK_EQUAL( r.get_header("Last-Modified"), "Tue, 30 Mar 2010 17:41:28 GMT" );
-    BOOST_CHECK_EQUAL( r.get_header("ETag"), "\"16799d-55-4830823a78200\"" );
-    BOOST_CHECK_EQUAL( r.get_header("Accept-Ranges"), "bytes" );
-    BOOST_CHECK_EQUAL( r.get_header("Content-Length"), "85" );
-    BOOST_CHECK_EQUAL( r.get_header("Vary"), "Accept-Encoding" );
-    BOOST_CHECK_EQUAL( r.get_header("Content-Type"), "text/html" );
-    BOOST_CHECK_EQUAL( r.get_body(), "<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>" );
-}
-
-BOOST_AUTO_TEST_CASE( parse_istream ) {
-    websocketpp::http::parser::response r;
-
-    std::stringstream s;
-
-    s << "HTTP/1.1 200 OK\r\nDate: Thu, 10 May 2012 11:59:25 GMT\r\nServer: Apache/2.2.21 (Unix) mod_ssl/2.2.21 OpenSSL/0.9.8r DAV/2 PHP/5.3.8 with Suhosin-Patch\r\nLast-Modified: Tue, 30 Mar 2010 17:41:28 GMT\r\nETag: \"16799d-55-4830823a78200\"\r\nAccept-Ranges: bytes\r\nContent-Length: 85\r\nVary: Accept-Encoding\r\nContent-Type: text/html\r\n\r\n<!doctype html>\n<html>\n<head>\n<title>Thor</title>\n</head>\n<body> \n<p>Thor</p>\n</body>";
-
-    bool exception = false;
-    size_t pos = 0;
-
-    try {
-        pos += r.consume(s);
-    } catch (std::exception &e) {
-        exception = true;
-        std::cout << e.what() << std::endl;
-    }
-
-    BOOST_CHECK_EQUAL( exception, false );
-    BOOST_CHECK_EQUAL( pos, 405 );
-    BOOST_CHECK_EQUAL( r.headers_ready(), true );
-    BOOST_CHECK_EQUAL( r.ready(), true );
-}
-
-BOOST_AUTO_TEST_CASE( write_request_basic ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\n\r\n";
-
-    r.set_version("HTTP/1.1");
-    r.set_method("GET");
-    r.set_uri("/");
-
-    BOOST_CHECK_EQUAL( r.raw(), raw );
-}
-
-BOOST_AUTO_TEST_CASE( write_request_with_header ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "GET / HTTP/1.1\r\nHost: http://example.com\r\n\r\n";
-
-    r.set_version("HTTP/1.1");
-    r.set_method("GET");
-    r.set_uri("/");
-    r.replace_header("Host","http://example.com");
-
-    BOOST_CHECK_EQUAL( r.raw(), raw );
-}
-
-BOOST_AUTO_TEST_CASE( write_request_with_body ) {
-    websocketpp::http::parser::request r;
-
-    std::string raw = "POST / HTTP/1.1\r\nContent-Length: 48\r\nContent-Type: application/x-www-form-urlencoded\r\nHost: http://example.com\r\n\r\nlicenseID=string&content=string&paramsXML=string";
-
-    r.set_version("HTTP/1.1");
-    r.set_method("POST");
-    r.set_uri("/");
-    r.replace_header("Host","http://example.com");
-    r.replace_header("Content-Type","application/x-www-form-urlencoded");
-    r.set_body("licenseID=string&content=string&paramsXML=string");
-
-    BOOST_CHECK_EQUAL( r.raw(), raw );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser_perf.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser_perf.cpp
deleted file mode 100644
index 0c76bc7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/http/parser_perf.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <websocketpp/http/parser.hpp>
-
-#include <chrono>
-
-class scoped_timer {
-public:
-    scoped_timer(std::string i) : m_id(i),m_start(std::chrono::steady_clock::now()) {
-        std::cout << "Clock " << i << ": ";
-    }
-    ~scoped_timer() {
-        std::chrono::nanoseconds time_taken = std::chrono::steady_clock::now()-m_start;
-
-        //nanoseconds_per_test
-
-        //tests_per_second
-
-        //1000000000.0/(double(time_taken.count())/1000.0)
-
-        std::cout << 1000000000.0/(double(time_taken.count())/1000.0) << std::endl;
-
-        //std::cout << (1.0/double(time_taken.count())) * double(1000000000*1000) << std::endl;
-    }
-
-private:
-    std::string m_id;
-    std::chrono::steady_clock::time_point m_start;
-};
-
-int main() {
-    std::string raw = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
-
-    std::string firefox = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string firefox1 = "GET / HTTP/1.1\r\nHost: localhost:5000\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:10.0) Gecko/20100101 Firefox/10.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\n";
-
-    std::string firefox2 = "Accept-Encoding: gzip, deflate\r\nConnection: keep-alive, Upgrade\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Origin: http://zaphoyd.com\r\nSec-WebSocket-Key: pFik//FxwFk0riN4ZiPFjQ==\r\nPragma: no-cache\r\nCache-Control: no-cache\r\nUpgrade: websocket\r\n\r\n";
-
-    {
-        scoped_timer timer("Simplest 1 chop");
-        for (int i = 0; i < 1000; i++) {
-            websocketpp::http::parser::request r;
-
-            try {
-                r.consume(raw.c_str(),raw.size());
-            } catch (...) {
-                std::cout << "exception" << std::endl;
-            }
-
-            if (!r.ready()) {
-                std::cout << "error" << std::endl;
-                break;
-            }
-        }
-    }
-
-    {
-        scoped_timer timer("FireFox, 1 chop, consume old");
-        for (int i = 0; i < 1000; i++) {
-            websocketpp::http::parser::request r;
-
-            try {
-                r.consume2(firefox.c_str(),firefox.size());
-            } catch (...) {
-                std::cout << "exception" << std::endl;
-            }
-
-            if (!r.ready()) {
-                std::cout << "error" << std::endl;
-                break;
-            }
-        }
-    }
-
-    {
-        scoped_timer timer("FireFox, 1 chop");
-        for (int i = 0; i < 1000; i++) {
-            websocketpp::http::parser::request r;
-
-            try {
-                r.consume(firefox.c_str(),firefox.size());
-            } catch (...) {
-                std::cout << "exception" << std::endl;
-            }
-
-            if (!r.ready()) {
-                std::cout << "error" << std::endl;
-                break;
-            }
-        }
-    }
-
-
-
-    {
-        scoped_timer timer("FireFox, 2 chop");
-        for (int i = 0; i < 1000; i++) {
-            websocketpp::http::parser::request r;
-
-            try {
-                r.consume(firefox1.c_str(),firefox1.size());
-                r.consume(firefox2.c_str(),firefox2.size());
-            } catch (...) {
-                std::cout << "exception" << std::endl;
-            }
-
-            if (!r.ready()) {
-                std::cout << "error" << std::endl;
-                break;
-            }
-        }
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/CMakeLists.txt
deleted file mode 100644
index 42d8b7c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-file (GLOB SOURCE_FILES *.cpp)
-file (GLOB HEADER_FILES *.hpp)
-
-init_target (test_logger)
-
-build_test (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
-
-link_boost ()
-final_target ()
-
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/SConscript
deleted file mode 100644
index 81d6076..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/SConscript
+++ /dev/null
@@ -1,23 +0,0 @@
-## logger unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
-
-objs = env.Object('logger_basic_boost.o', ["basic.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('logger_basic_boost', ["logger_basic_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('logger_basic_stl.o', ["basic.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('logger_basic_stl', ["logger_basic_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/basic.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/basic.cpp
deleted file mode 100644
index a730535..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/logger/basic.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE basic_log
-#include <boost/test/unit_test.hpp>
-
-#include <string>
-
-#include <websocketpp/logger/basic.hpp>
-#include <websocketpp/concurrency/none.hpp>
-#include <websocketpp/concurrency/basic.hpp>
-
-typedef websocketpp::log::basic<websocketpp::concurrency::basic,websocketpp::log::alevel> basic_access_log_type;
-
-BOOST_AUTO_TEST_CASE( is_token_char ) {
-    typedef websocketpp::log::basic<websocketpp::concurrency::none,websocketpp::log::elevel> error_log;
-
-    error_log elog;
-
-    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::info ) == true );
-    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::warn ) == true );
-    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::rerror ) == true );
-    BOOST_CHECK( elog.static_test(websocketpp::log::elevel::fatal ) == true );
-
-    elog.set_channels(websocketpp::log::elevel::info);
-
-    elog.write(websocketpp::log::elevel::info,"Information");
-    elog.write(websocketpp::log::elevel::warn,"A warning");
-    elog.write(websocketpp::log::elevel::rerror,"A error");
-    elog.write(websocketpp::log::elevel::fatal,"A critical error");
-}
-
-BOOST_AUTO_TEST_CASE( access_clear ) {
-    typedef websocketpp::log::basic<websocketpp::concurrency::none,websocketpp::log::alevel> access_log;
-
-    std::stringstream out;
-    access_log logger(0xffffffff,&out);
-
-    // clear all channels
-    logger.clear_channels(0xffffffff);
-
-    // writes shouldn't happen
-    logger.write(websocketpp::log::alevel::devel,"devel");
-    //std::cout << "|" << out.str() << "|" << std::endl;
-    BOOST_CHECK( out.str().size() == 0 );
-}
-
-BOOST_AUTO_TEST_CASE( basic_concurrency ) {
-    typedef websocketpp::log::basic<websocketpp::concurrency::basic,websocketpp::log::alevel> access_log;
-
-    std::stringstream out;
-    access_log logger(0xffffffff,&out);
-
-    logger.set_channels(0xffffffff);
-
-    logger.write(websocketpp::log::alevel::devel,"devel");
-    //std::cout << "|" << out.str() << "|" << std::endl;
-    BOOST_CHECK( out.str().size() > 0 );
-}
-
-
-BOOST_AUTO_TEST_CASE( copy_constructor ) {
-    std::stringstream out;
-
-    basic_access_log_type logger1(0xffffffff,&out);
-    basic_access_log_type logger2(logger1);
-
-    logger2.set_channels(0xffffffff);
-    logger2.write(websocketpp::log::alevel::devel,"devel");
-    BOOST_CHECK( out.str().size() > 0 );
-}
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-BOOST_AUTO_TEST_CASE( move_constructor ) {
-    std::stringstream out;
-
-    basic_access_log_type logger1(0xffffffff,&out);
-    basic_access_log_type logger2(std::move(logger1));
-
-    logger2.set_channels(0xffffffff);
-    logger2.write(websocketpp::log::alevel::devel,"devel");
-    BOOST_CHECK( out.str().size() > 0 );
-}
-
-// Emplace requires move assignment, which logger doesn't support right now
-// due to const members. This is pretty irritating and will probably result in
-// the const members being removed. For now though this test will fail to
-// compile
-/*BOOST_AUTO_TEST_CASE( emplace ) {
-    std::stringstream out1;
-    std::stringstream out2;
-
-    std::vector<basic_access_log_type> v;
-
-    v.emplace_back(websocketpp::log::level(0xffffffff),&out1);
-    v.emplace_back(websocketpp::log::level(0xffffffff),&out2);
-
-    v[0].set_channels(0xffffffff);
-    v[1].set_channels(0xffffffff);
-    v[0].write(websocketpp::log::alevel::devel,"devel");
-    v[1].write(websocketpp::log::alevel::devel,"devel");
-    BOOST_CHECK( out1.str().size() > 0 );
-    BOOST_CHECK( out2.str().size() > 0 );
-}*/
-#endif // #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-
-// As long as there are const member variables these can't exist
-// These remain commented as they are useful for testing the deleted operators
-/*BOOST_AUTO_TEST_CASE( copy_assign ) {
-    basic_access_log_type logger1;
-    basic_access_log_type logger2;
-
-    logger2 = logger1;
-}
-
-BOOST_AUTO_TEST_CASE( move_assign ) {
-    basic_access_log_type logger1;
-    basic_access_log_type logger2;
-
-    logger2 = std::move(logger1);
-}*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/CMakeLists.txt
deleted file mode 100644
index cd17e55..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test alloc message buffer strategy
-file (GLOB SOURCE alloc.cpp)
-
-init_target (test_message_alloc)
-build_executable (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test message buffers
-file (GLOB SOURCE message.cpp)
-
-init_target (test_message_buffer)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/SConscript
deleted file mode 100644
index 2ef6d71..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/SConscript
+++ /dev/null
@@ -1,27 +0,0 @@
-## message_buffer unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
-
-objs = env.Object('message_boost.o', ["message.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('alloc_boost.o', ["alloc.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_message_boost', ["message_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_alloc_boost', ["alloc_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('message_stl.o', ["message.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('alloc_stl.o', ["alloc.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_message_stl', ["message_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_alloc_stl', ["alloc_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/alloc.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/alloc.cpp
deleted file mode 100644
index 9f6ba2a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/alloc.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE message_buffer_alloc
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/message_buffer/alloc.hpp>
-
-template <template <class> class con_msg_manager>
-struct stub {
-    typedef websocketpp::lib::shared_ptr<stub> ptr;
-
-    typedef con_msg_manager<stub> con_msg_man_type;
-    typedef typename con_msg_man_type::ptr con_msg_man_ptr;
-    typedef typename con_msg_man_type::weak_ptr con_msg_man_weak_ptr;
-
-    stub(con_msg_man_ptr manager, websocketpp::frame::opcode::value op, size_t size = 128)
-      : m_opcode(op)
-      , m_manager(manager)
-      , m_size(size) {}
-
-    bool recycle() {
-        con_msg_man_ptr shared = m_manager.lock();
-
-        if (shared) {
-            return shared->recycle(this);
-        } else {
-            return false;
-        }
-    }
-
-    websocketpp::frame::opcode::value   m_opcode;
-    con_msg_man_weak_ptr                m_manager;
-    size_t                              m_size;
-};
-
-BOOST_AUTO_TEST_CASE( basic_get_message ) {
-    typedef stub<websocketpp::message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_man_type;
-
-    con_msg_man_type::ptr manager(new con_msg_man_type());
-    message_type::ptr msg = manager->get_message(websocketpp::frame::opcode::TEXT,512);
-
-    BOOST_CHECK(msg);
-    BOOST_CHECK(msg->m_opcode == websocketpp::frame::opcode::TEXT);
-    BOOST_CHECK(msg->m_manager.lock() == manager);
-    BOOST_CHECK(msg->m_size == 512);
-}
-
-BOOST_AUTO_TEST_CASE( basic_get_manager ) {
-    typedef stub<websocketpp::message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_man_type;
-    typedef websocketpp::message_buffer::alloc::endpoint_msg_manager
-        <con_msg_man_type> endpoint_manager_type;
-
-    endpoint_manager_type em;
-    con_msg_man_type::ptr manager = em.get_manager();
-    message_type::ptr msg = manager->get_message(websocketpp::frame::opcode::TEXT,512);
-
-    BOOST_CHECK(msg);
-    BOOST_CHECK(msg->m_opcode == websocketpp::frame::opcode::TEXT);
-    BOOST_CHECK(msg->m_manager.lock() == manager);
-    BOOST_CHECK(msg->m_size == 512);
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/message.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/message.cpp
deleted file mode 100644
index 1fb12d3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/message.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE message
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/message_buffer/message.hpp>
-
-template <typename message>
-struct stub {
-    typedef websocketpp::lib::weak_ptr<stub> weak_ptr;
-    typedef websocketpp::lib::shared_ptr<stub> ptr;
-
-    stub() : recycled(false) {}
-
-    bool recycle(message *) {
-        this->recycled = true;
-        return false;
-    }
-
-    bool recycled;
-};
-
-BOOST_AUTO_TEST_CASE( basic_size_check ) {
-    typedef websocketpp::message_buffer::message<stub> message_type;
-    typedef stub<message_type> stub_type;
-
-    stub_type::ptr s(new stub_type());
-    message_type::ptr msg(new message_type(s,websocketpp::frame::opcode::TEXT,500));
-
-    BOOST_CHECK(msg->get_payload().capacity() >= 500);
-}
-
-BOOST_AUTO_TEST_CASE( recycle ) {
-    typedef websocketpp::message_buffer::message<stub> message_type;
-    typedef stub<message_type> stub_type;
-
-    stub_type::ptr s(new stub_type());
-    message_type::ptr msg(new message_type(s,websocketpp::frame::opcode::TEXT,500));
-
-    BOOST_CHECK(s->recycled == false);
-    BOOST_CHECK(msg->recycle() == false);
-    BOOST_CHECK(s->recycled == true);
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/pool.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/pool.cpp
deleted file mode 100644
index 2ecf875..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/message_buffer/pool.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_00_processor
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/hybi00.hpp>
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    websocketpp::http::parser::request r;
-    websocketpp::http::parser::response response;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","WjN}|M(6");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(p.validate_handshake(r));
-
-    websocketpp::uri_ptr u;
-    bool exception;
-
-    try {
-        u = p.get_uri(r);
-    } catch (const websocketpp::uri_exception& e) {
-        exception = true;
-    }
-
-    BOOST_CHECK(exception == false);
-    BOOST_CHECK(u->get_secure() == false);
-    BOOST_CHECK(u->get_host() == "www.example.com");
-    BOOST_CHECK(u->get_resource() == "/");
-    BOOST_CHECK(u->get_port() == websocketpp::URI_DEFAULT_PORT);
-
-    p.process_handshake(r,response);
-
-    BOOST_CHECK(response.get_header("Connection") == "Upgrade");
-    BOOST_CHECK(response.get_header("Upgrade") == "websocket");
-    BOOST_CHECK(response.get_header("Sec-WebSocket-Origin") == "http://example.com");
-
-    BOOST_CHECK(response.get_header("Sec-WebSocket-Location") == "ws://www.example.com/");
-    BOOST_CHECK(response.get_header("Sec-WebSocket-Key3") == "n`9eBk9z$R8pOtVb");
-}
-
-BOOST_AUTO_TEST_CASE( non_get_method ) {
-    websocketpp::http::parser::request r;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-
-    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(!p.validate_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    websocketpp::http::parser::request r;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-
-    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(!p.validate_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
-    websocketpp::http::parser::request r;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(!p.validate_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
-    websocketpp::http::parser::request r;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(!p.validate_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( bad_host ) {
-    websocketpp::http::parser::request r;
-    websocketpp::processor::hybi00<websocketpp::http::parser::request,websocketpp::http::parser::response> p(false);
-    websocketpp::uri_ptr u;
-    bool exception = false;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-    r.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    BOOST_CHECK(!p.validate_handshake(r));
-
-    try {
-        u = p.get_uri(r);
-    } catch (const websocketpp::uri_exception& e) {
-        exception = true;
-    }
-
-    BOOST_CHECK(exception == true);
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/CMakeLists.txt
deleted file mode 100644
index 42b0468..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/CMakeLists.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-# Generic processor tests
-file (GLOB SOURCE processor.cpp)
-
-init_target (test_processor)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Hybi00 processor tests
-file (GLOB SOURCE hybi00.cpp)
-
-init_target (test_processor_hybi00)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Hybi07 processor tests
-file (GLOB SOURCE hybi07.cpp)
-
-init_target (test_processor_hybi07)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Hybi08 processor tests
-file (GLOB SOURCE hybi08.cpp)
-
-init_target (test_processor_hybi08)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-if (ZLIB_FOUND)
-
-# Hybi13 processor tests
-file (GLOB SOURCE hybi13.cpp)
-
-init_target (test_processor_hybi13)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_zlib()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Permessage compression extension processor tests
-file (GLOB SOURCE extension_permessage_compress.cpp)
-
-init_target (test_processor_extension_permessage_compress)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_zlib()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-endif ( ZLIB_FOUND )
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/SConscript
deleted file mode 100644
index 406a7ed..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/SConscript
+++ /dev/null
@@ -1,47 +0,0 @@
-## processor unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs] + ['z']
-
-objs = env.Object('test_processor_boost.o', ["processor.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('test_hybi13_boost.o', ["hybi13.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('test_hybi08_boost.o', ["hybi08.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('test_hybi07_boost.o', ["hybi07.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('test_hybi00_boost.o', ["hybi00.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('test_extension_permessage_compress_boost.o', ["extension_permessage_compress.cpp"], LIBS = BOOST_LIBS)
-
-prgs = env.Program('test_processor_boost', ["test_processor_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_hybi13_boost', ["test_hybi13_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_hybi08_boost', ["test_hybi08_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_hybi07_boost', ["test_hybi07_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_hybi00_boost', ["test_hybi00_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_extension_permessage_compress_boost', ["test_extension_permessage_compress_boost.o"], LIBS = BOOST_LIBS + ['z'])
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs] + ['z']
-   # no C++11 features are used in processor so there are no C++11 versions of
-   # these tests.
-   objs += env_cpp11.Object('test_processor_stl.o', ["processor.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('test_hybi13_stl.o', ["hybi13.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('test_hybi08_stl.o', ["hybi08.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('test_hybi07_stl.o', ["hybi07.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('test_hybi00_stl.o', ["hybi00.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('test_extension_permessage_compress_stl.o', ["extension_permessage_compress.cpp"], LIBS = BOOST_LIBS_CPP11 + ['z'])
-
-   prgs += env_cpp11.Program('test_processor_stl', ["test_processor_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_hybi13_stl', ["test_hybi13_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_hybi08_stl', ["test_hybi08_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_hybi07_stl', ["test_hybi07_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_hybi00_stl', ["test_hybi00_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_extension_permessage_compress_stl', ["test_extension_permessage_compress_stl.o"], LIBS = BOOST_LIBS_CPP11 + ['z'])
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/extension_permessage_compress.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/extension_permessage_compress.cpp
deleted file mode 100644
index 7f26a9d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/extension_permessage_compress.cpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE extension_permessage_deflate
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-#include <websocketpp/common/memory.hpp>
-
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-struct config {
-    typedef websocketpp::http::parser::request request_type;
-};
-typedef websocketpp::extensions::permessage_deflate::enabled<config>
-    compressor_type;
-
-using namespace websocketpp;
-
-BOOST_AUTO_TEST_CASE( deflate_init ) {
-    /*compressor_type compressor;
-    websocketpp::http::parser::attribute_list attributes;
-    std::pair<lib::error_code,std::string> neg_ret;
-
-    neg_ret = compressor.negotiate(attributes);
-
-    BOOST_CHECK_EQUAL( neg_ret.first,
-        extensions::permessage_deflate::error::invalid_parameters );*/
-
-    /**
-     * Window size is primarily controlled by the writer. A stream can only be
-     * read by a window size equal to or greater than the one use to compress
-     * it initially. The default windows size is also the maximum window size.
-     * Thus:
-     *
-     * Outbound window size can be limited unilaterally under the assumption
-     * that the opposite end will be using the default (maximum size which can
-     * read anything)
-     *
-     * Inbound window size must be limited by asking the remote endpoint to
-     * do so and it agreeing.
-     *
-     * Context takeover is also primarily controlled by the writer. If the
-     * compressor does not clear its context between messages then the reader
-     * can't either.
-     *
-     * Outbound messages may clear context between messages unilaterally.
-     * Inbound messages must retain state unless the remote endpoint signals
-     * otherwise.
-     *
-     * Negotiation options:
-     * Client must choose from the following options:
-     * - whether or not to request an inbound window limit
-     * - whether or not to signal that it will honor an outbound window limit
-     * - whether or not to request that the server disallow context takeover
-     *
-     * Server must answer in the following ways
-     * - If client requested a window size limit, is the window size limit
-     *   acceptable?
-     * - If client allows window limit requests, should we send one?
-     * - If client requested no context takeover, should we accept?
-     *
-     *
-     *
-     * All Defaults
-     * Req: permessage-compress; method=deflate
-     * Ans: permessage-compress; method=deflate
-     *
-     * # Client wants to limit the size of inbound windows from server
-     * permessage-compress; method="deflate; s2c_max_window_bits=8, deflate"
-     * Ans: permessage-compress; method="deflate; s2c_max_window_bits=8"
-     * OR
-     * Ans: permessage-compress; method=deflate
-     *
-     * # Server wants to limit the size of inbound windows from client
-     * Client:
-     * permessage-compress; method="deflate; c2s_max_window_bits, deflate"
-     *
-     * Server:
-     * permessage-compress; method="deflate; c2s_max_window_bits=8"
-     *
-     * # Client wants to
-     *
-     *
-     *
-     *
-     *
-     *
-     */
-
-
-
-
-   /* processor::extensions::deflate_method d(true);
-    http::parser::attribute_list attributes;
-    lib::error_code ec;
-
-    attributes.push_back(http::parser::attribute("foo","bar"));
-    ec = d.init(attributes);
-    BOOST_CHECK(ec == processor::extensions::error::unknown_method_parameter);
-
-    attributes.clear();
-    attributes.push_back(http::parser::attribute("s2c_max_window_bits","bar"));
-    ec = d.init(attributes);
-    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
-
-    attributes.clear();
-    attributes.push_back(http::parser::attribute("s2c_max_window_bits","7"));
-    ec = d.init(attributes);
-    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
-
-    attributes.clear();
-    attributes.push_back(http::parser::attribute("s2c_max_window_bits","16"));
-    ec = d.init(attributes);
-    BOOST_CHECK(ec == processor::extensions::error::invalid_algorithm_settings);
-
-    attributes.clear();
-    attributes.push_back(http::parser::attribute("s2c_max_window_bits","9"));
-    ec = d.init(attributes);
-    BOOST_CHECK( !ec);
-
-    attributes.clear();
-    ec = d.init(attributes);
-    BOOST_CHECK( !ec);
-
-    processor::extensions::deflate_engine de;
-
-    unsigned char test_in[] = "HelloHelloHelloHello";
-    unsigned char test_out[30];
-
-    uLongf test_out_size = 30;
-
-    int ret;
-
-    ret = compress(test_out, &test_out_size, test_in, 20);
-
-    std::cout << ret << std::endl
-              << websocketpp::utility::to_hex(test_in,20) << std::endl
-              << websocketpp::utility::to_hex(test_out,test_out_size) << std::endl;
-
-    std::string input = "Hello";
-    std::string output;
-    ec = de.compress(input,output);
-
-    BOOST_CHECK( ec == processor::extensions::error::uninitialized );
-
-    //std::cout << ec.message() << websocketpp::utility::to_hex(output) << std::endl;
-
-    ec = de.init(15,15,Z_DEFAULT_COMPRESSION,8,Z_FIXED);
-    //ec = de.init();
-    BOOST_CHECK( !ec );
-
-    ec = de.compress(input,output);
-    std::cout << ec.message() << std::endl
-              << websocketpp::utility::to_hex(input) << std::endl
-              << websocketpp::utility::to_hex(output) << std::endl;
-
-    output.clear();
-
-    ec = de.compress(input,output);
-    std::cout << ec.message() << std::endl
-              << websocketpp::utility::to_hex(input) << std::endl
-              << websocketpp::utility::to_hex(output) << std::endl;
-
-    input = output;
-    output.clear();
-    ec = de.decompress(input,output);
-    std::cout << ec.message() << std::endl
-              << websocketpp::utility::to_hex(input) << std::endl
-              << websocketpp::utility::to_hex(output) << std::endl;
-    */
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi00.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi00.cpp
deleted file mode 100644
index e6ad530..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi00.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_00_processor
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/hybi00.hpp>
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-
-struct stub_config {
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-
-    typedef websocketpp::message_buffer::message
-        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-        
-    static const size_t max_message_size = 16000000;
-};
-
-struct processor_setup {
-    processor_setup(bool server)
-      : msg_manager(new stub_config::con_msg_manager_type())
-      , p(false,server,msg_manager) {}
-
-    websocketpp::lib::error_code ec;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::request_type req;
-    stub_config::response_type res;
-    websocketpp::processor::hybi00<stub_config> p;
-};
-
-typedef stub_config::message_type::ptr message_ptr;
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","WjN}|M(6");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    env.ec = env.p.validate_handshake(env.req);
-    BOOST_CHECK(!env.ec);
-
-    websocketpp::uri_ptr u;
-
-    BOOST_CHECK_NO_THROW( u = env.p.get_uri(env.req) );
-
-    BOOST_CHECK_EQUAL(u->get_secure(), false);
-    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
-    BOOST_CHECK_EQUAL(u->get_resource(), "/");
-    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
-
-    env.p.process_handshake(env.req,"",env.res);
-
-    BOOST_CHECK_EQUAL(env.res.get_header("Connection"), "Upgrade");
-    BOOST_CHECK_EQUAL(env.res.get_header("Upgrade"), "WebSocket");
-    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Origin"), "http://example.com");
-
-    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Location"), "ws://www.example.com/");
-    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Key3"), "n`9eBk9z$R8pOtVb");
-}
-
-BOOST_AUTO_TEST_CASE( non_get_method ) {
-    processor_setup env(true);
-
-    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_method );
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_version );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( bad_host ) {
-    processor_setup env(true);
-    websocketpp::uri_ptr u;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nOrigin: http://example.com\r\nSec-WebSocket-Key1: 3e6b263  4 17 80\r\nSec-WebSocket-Key2: 17  9 G`ZD9   2 2b 7X 3 /r90\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-    env.req.replace_header("Sec-WebSocket-Key3","janelle!");
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK( !env.p.validate_handshake(env.req) );
-
-    BOOST_CHECK( !env.p.get_uri(env.req)->get_valid() );
-}
-
-BOOST_AUTO_TEST_CASE( extract_subprotocols ) {
-    processor_setup env(true);
-
-    std::vector<std::string> subps;
-
-    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
-    BOOST_CHECK_EQUAL( subps.size(), 0 );
-}
-
-BOOST_AUTO_TEST_CASE( prepare_data_frame_null ) {
-    processor_setup env(true);
-
-    message_ptr in = env.msg_manager->get_message();
-    message_ptr out = env.msg_manager->get_message();
-    message_ptr invalid;
-
-
-    // empty pointers arguements should return sane error
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,invalid), websocketpp::processor::error::invalid_arguments );
-
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(in,invalid), websocketpp::processor::error::invalid_arguments );
-
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,out), websocketpp::processor::error::invalid_arguments );
-
-    // test valid opcodes
-    // text (1) should be the only valid opcode
-    for (int i = 0; i < 0xF; i++) {
-        in->set_opcode(websocketpp::frame::opcode::value(i));
-
-        env.ec = env.p.prepare_data_frame(in,out);
-
-        if (i != 1) {
-            BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode );
-        } else {
-            BOOST_CHECK_NE( env.ec, websocketpp::processor::error::invalid_opcode );
-        }
-    }
-
-    /*
-     * TODO: tests for invalid UTF8
-    char buf[2] = {0x00, 0x00};
-
-    in->set_opcode(websocketpp::frame::opcode::text);
-    in->set_payload("foo");
-
-    env.ec = env.p.prepare_data_frame(in,out);
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_payload );
-    */
-}
-
-BOOST_AUTO_TEST_CASE( prepare_data_frame ) {
-    processor_setup env(true);
-
-    message_ptr in = env.msg_manager->get_message();
-    message_ptr out = env.msg_manager->get_message();
-
-    in->set_opcode(websocketpp::frame::opcode::text);
-    in->set_payload("foo");
-
-    env.ec = env.p.prepare_data_frame(in,out);
-
-    unsigned char raw_header[1] = {0x00};
-    unsigned char raw_payload[4] = {0x66,0x6f,0x6f,0xff};
-
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( out->get_header(), std::string(reinterpret_cast<char*>(raw_header),1) );
-    BOOST_CHECK_EQUAL( out->get_payload(), std::string(reinterpret_cast<char*>(raw_payload),4) );
-}
-
-
-BOOST_AUTO_TEST_CASE( empty_consume ) {
-    uint8_t frame[2] = {0x00,0x00};
-
-    processor_setup env(true);
-
-    size_t ret = env.p.consume(frame,0,env.ec);
-
-    BOOST_CHECK_EQUAL( ret, 0);
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( empty_frame ) {
-    uint8_t frame[2] = {0x00, 0xff};
-
-    processor_setup env(true);
-
-    size_t ret = env.p.consume(frame,2,env.ec);
-
-    BOOST_CHECK_EQUAL( ret, 2);
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "" );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( short_frame ) {
-    uint8_t frame[5] = {0x00, 0x66, 0x6f, 0x6f, 0xff};
-
-    processor_setup env(true);
-
-    size_t ret = env.p.consume(frame,5,env.ec);
-
-    BOOST_CHECK_EQUAL( ret, 5);
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "foo" );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi07.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi07.cpp
deleted file mode 100644
index fe2cb07..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi07.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_07_processor
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/hybi07.hpp>
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-#include <websocketpp/random/none.hpp>
-
-struct stub_config {
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-
-    typedef websocketpp::message_buffer::message
-        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    static const size_t max_message_size = 16000000;
-
-    /// Extension related config
-    static const bool enable_extensions = false;
-
-    /// Extension specific config
-
-    /// permessage_compress_config
-    struct permessage_deflate_config {
-        typedef stub_config::request_type request_type;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK(!ec);
-
-    websocketpp::uri_ptr u;
-
-    u = p.get_uri(r);
-
-    BOOST_CHECK(u->get_valid());
-    BOOST_CHECK(!u->get_secure());
-    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
-    BOOST_CHECK_EQUAL(u->get_resource(), "/");
-    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
-
-    p.process_handshake(r,"",response);
-
-    BOOST_CHECK_EQUAL(response.get_header("Connection"), "Upgrade");
-    BOOST_CHECK_EQUAL(response.get_header("Upgrade"), "websocket");
-    BOOST_CHECK_EQUAL(response.get_header("Sec-WebSocket-Accept"), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
-}
-
-BOOST_AUTO_TEST_CASE( non_get_method ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_method );
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_version );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( bad_host ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi07<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( !ec );
-
-    BOOST_CHECK( !p.get_uri(r)->get_valid() );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi08.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi08.cpp
deleted file mode 100644
index 5b0737f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi08.cpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_08_processor
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/hybi08.hpp>
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-#include <websocketpp/random/none.hpp>
-
-struct stub_config {
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-
-    typedef websocketpp::message_buffer::message
-        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    static const size_t max_message_size = 16000000;
-
-    /// Extension related config
-    static const bool enable_extensions = false;
-
-    /// Extension specific config
-
-    /// permessage_deflate_config
-    struct permessage_deflate_config {
-        typedef stub_config::request_type request_type;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-};
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK(!ec);
-
-    websocketpp::uri_ptr u;
-
-    u = p.get_uri(r);
-
-    BOOST_CHECK(u->get_valid() == true);
-    BOOST_CHECK(u->get_secure() == false);
-    BOOST_CHECK(u->get_host() == "www.example.com");
-    BOOST_CHECK(u->get_resource() == "/");
-    BOOST_CHECK(u->get_port() == websocketpp::uri_default_port);
-
-    p.process_handshake(r,"",response);
-
-    BOOST_CHECK(response.get_header("Connection") == "Upgrade");
-    BOOST_CHECK(response.get_header("Upgrade") == "websocket");
-    BOOST_CHECK(response.get_header("Sec-WebSocket-Accept") == "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
-}
-
-BOOST_AUTO_TEST_CASE( non_get_method ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::rng_type rng;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_method );
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::invalid_http_version );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( ec == websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( bad_host ) {
-    stub_config::request_type r;
-    stub_config::response_type response;
-    stub_config::con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    websocketpp::processor::hybi08<stub_config> p(false,true,msg_manager,rng);
-    websocketpp::uri_ptr u;
-    websocketpp::lib::error_code ec;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == p.get_version());
-    ec = p.validate_handshake(r);
-    BOOST_CHECK( !ec );
-
-    u = p.get_uri(r);
-
-    BOOST_CHECK( !u->get_valid() );
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi13.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi13.cpp
deleted file mode 100644
index 96d00be..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/hybi13.cpp
+++ /dev/null
@@ -1,693 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_13_processor
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/hybi13.hpp>
-
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-#include <websocketpp/random/none.hpp>
-
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-#include <websocketpp/extensions/permessage_deflate/enabled.hpp>
-
-struct stub_config {
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-
-    typedef websocketpp::message_buffer::message
-        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    struct permessage_deflate_config {
-        typedef stub_config::request_type request_type;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    static const size_t max_message_size = 16000000;
-    static const bool enable_extensions = false;
-};
-
-struct stub_config_ext {
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-
-    typedef websocketpp::message_buffer::message
-        <websocketpp::message_buffer::alloc::con_msg_manager> message_type;
-    typedef websocketpp::message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    struct permessage_deflate_config {
-        typedef stub_config_ext::request_type request_type;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::enabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    static const size_t max_message_size = 16000000;
-    static const bool enable_extensions = true;
-};
-
-typedef stub_config::con_msg_manager_type con_msg_manager_type;
-typedef stub_config::message_type::ptr message_ptr;
-
-// Set up a structure that constructs new copies of all of the support structure
-// for using connection processors
-struct processor_setup {
-    processor_setup(bool server)
-      : msg_manager(new con_msg_manager_type())
-      , p(false,server,msg_manager,rng) {}
-
-    websocketpp::lib::error_code ec;
-    con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    stub_config::request_type req;
-    stub_config::response_type res;
-    websocketpp::processor::hybi13<stub_config> p;
-};
-
-struct processor_setup_ext {
-    processor_setup_ext(bool server)
-      : msg_manager(new con_msg_manager_type())
-      , p(false,server,msg_manager,rng) {}
-
-    websocketpp::lib::error_code ec;
-    con_msg_manager_type::ptr msg_manager;
-    stub_config::rng_type rng;
-    stub_config::request_type req;
-    stub_config::response_type res;
-    websocketpp::processor::hybi13<stub_config_ext> p;
-};
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK(!env.p.validate_handshake(env.req));
-
-    websocketpp::uri_ptr u;
-
-    BOOST_CHECK_NO_THROW( u = env.p.get_uri(env.req) );
-
-    BOOST_CHECK_EQUAL(u->get_secure(), false);
-    BOOST_CHECK_EQUAL(u->get_host(), "www.example.com");
-    BOOST_CHECK_EQUAL(u->get_resource(), "/");
-    BOOST_CHECK_EQUAL(u->get_port(), websocketpp::uri_default_port);
-
-    env.p.process_handshake(env.req,"",env.res);
-
-    BOOST_CHECK_EQUAL(env.res.get_header("Connection"), "Upgrade");
-    BOOST_CHECK_EQUAL(env.res.get_header("Upgrade"), "websocket");
-    BOOST_CHECK_EQUAL(env.res.get_header("Sec-WebSocket-Accept"), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
-}
-
-BOOST_AUTO_TEST_CASE( non_get_method ) {
-    processor_setup env(true);
-
-    std::string handshake = "POST / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK( env.p.validate_handshake(env.req) == websocketpp::processor::error::invalid_http_method );
-}
-
-BOOST_AUTO_TEST_CASE( old_http_version ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.0\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(env.req));
-    BOOST_CHECK_EQUAL(websocketpp::processor::get_websocket_version(env.req), env.p.get_version());
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::invalid_http_version );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key1 ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
-    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( missing_handshake_key2 ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
-    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
-    BOOST_CHECK_EQUAL( env.p.validate_handshake(env.req), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( bad_host ) {
-    processor_setup env(true);
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com:70000\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: foo\r\n\r\n";
-
-    env.req.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK( websocketpp::processor::is_websocket_handshake(env.req) );
-    BOOST_CHECK_EQUAL( websocketpp::processor::get_websocket_version(env.req), env.p.get_version() );
-    BOOST_CHECK( !env.p.validate_handshake(env.req) );
-    BOOST_CHECK( !env.p.get_uri(env.req)->get_valid() );
-}
-
-// FRAME TESTS TO DO
-//
-// unmasked, 0 length, binary
-// 0x82 0x00
-//
-// masked, 0 length, binary
-// 0x82 0x80
-//
-// unmasked, 0 length, text
-// 0x81 0x00
-//
-// masked, 0 length, text
-// 0x81 0x80
-
-BOOST_AUTO_TEST_CASE( frame_empty_binary_unmasked ) {
-    uint8_t frame[2] = {0x82, 0x00};
-
-    // all in one chunk
-    processor_setup env1(false);
-
-    size_t ret1 = env1.p.consume(frame,2,env1.ec);
-
-    BOOST_CHECK_EQUAL( ret1, 2 );
-    BOOST_CHECK( !env1.ec );
-    BOOST_CHECK_EQUAL( env1.p.ready(), true );
-
-    // two separate chunks
-    processor_setup env2(false);
-
-    BOOST_CHECK_EQUAL( env2.p.consume(frame,1,env2.ec), 1 );
-    BOOST_CHECK( !env2.ec );
-    BOOST_CHECK_EQUAL( env2.p.ready(), false );
-
-    BOOST_CHECK_EQUAL( env2.p.consume(frame+1,1,env2.ec), 1 );
-    BOOST_CHECK( !env2.ec );
-    BOOST_CHECK_EQUAL( env2.p.ready(), true );
-}
-
-BOOST_AUTO_TEST_CASE( frame_small_binary_unmasked ) {
-    processor_setup env(false);
-
-    uint8_t frame[4] = {0x82, 0x02, 0x2A, 0x2A};
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env.p.consume(frame,4,env.ec), 4 );
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-
-    message_ptr foo = env.p.get_message();
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( foo->get_payload(), "**" );
-
-}
-
-BOOST_AUTO_TEST_CASE( frame_extended_binary_unmasked ) {
-    processor_setup env(false);
-
-    uint8_t frame[130] = {0x82, 0x7E, 0x00, 0x7E};
-    frame[0] = 0x82;
-    frame[1] = 0x7E;
-    frame[2] = 0x00;
-    frame[3] = 0x7E;
-    std::fill_n(frame+4,126,0x2A);
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env.p.consume(frame,130,env.ec), 130 );
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-
-    message_ptr foo = env.p.get_message();
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( foo->get_payload().size(), 126 );
-}
-
-BOOST_AUTO_TEST_CASE( frame_jumbo_binary_unmasked ) {
-    processor_setup env(false);
-
-    uint8_t frame[130] = {0x82, 0x7E, 0x00, 0x7E};
-    std::fill_n(frame+4,126,0x2A);
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env.p.consume(frame,130,env.ec), 130 );
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-
-    message_ptr foo = env.p.get_message();
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( foo->get_payload().size(), 126 );
-}
-
-BOOST_AUTO_TEST_CASE( control_frame_too_large ) {
-    processor_setup env(false);
-
-    uint8_t frame[130] = {0x88, 0x7E, 0x00, 0x7E};
-    std::fill_n(frame+4,126,0x2A);
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_GT( env.p.consume(frame,130,env.ec), 0 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::control_too_big  );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( rsv_bits_used ) {
-    uint8_t frame[3][2] = {{0x90, 0x00},
-                           {0xA0, 0x00},
-                           {0xC0, 0x00}};
-
-    for (int i = 0; i < 3; i++) {
-        processor_setup env(false);
-
-        BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-        BOOST_CHECK_GT( env.p.consume(frame[i],2,env.ec), 0 );
-        BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_rsv_bit  );
-        BOOST_CHECK_EQUAL( env.p.ready(), false );
-    }
-}
-
-
-BOOST_AUTO_TEST_CASE( reserved_opcode_used ) {
-    uint8_t frame[10][2] = {{0x83, 0x00},
-                            {0x84, 0x00},
-                            {0x85, 0x00},
-                            {0x86, 0x00},
-                            {0x87, 0x00},
-                            {0x8B, 0x00},
-                            {0x8C, 0x00},
-                            {0x8D, 0x00},
-                            {0x8E, 0x00},
-                            {0x8F, 0x00}};
-
-    for (int i = 0; i < 10; i++) {
-        processor_setup env(false);
-
-        BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-        BOOST_CHECK_GT( env.p.consume(frame[i],2,env.ec), 0 );
-        BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode  );
-        BOOST_CHECK_EQUAL( env.p.ready(), false );
-    }
-}
-
-BOOST_AUTO_TEST_CASE( fragmented_control_message ) {
-    processor_setup env(false);
-
-    uint8_t frame[2] = {0x08, 0x00};
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_GT( env.p.consume(frame,2,env.ec), 0 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::fragmented_control );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( fragmented_binary_message ) {
-    processor_setup env0(false);
-    processor_setup env1(false);
-
-    uint8_t frame0[6] = {0x02, 0x01, 0x2A, 0x80, 0x01, 0x2A};
-    uint8_t frame1[8] = {0x02, 0x01, 0x2A, 0x89, 0x00, 0x80, 0x01, 0x2A};
-
-    // read fragmented message in one chunk
-    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env0.p.consume(frame0,6,env0.ec), 6 );
-    BOOST_CHECK( !env0.ec );
-    BOOST_CHECK_EQUAL( env0.p.ready(), true );
-    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
-
-    // read fragmented message in two chunks
-    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env0.p.consume(frame0,3,env0.ec), 3 );
-    BOOST_CHECK( !env0.ec );
-    BOOST_CHECK_EQUAL( env0.p.ready(), false );
-    BOOST_CHECK_EQUAL( env0.p.consume(frame0+3,3,env0.ec), 3 );
-    BOOST_CHECK( !env0.ec );
-    BOOST_CHECK_EQUAL( env0.p.ready(), true );
-    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
-
-    // read fragmented message with control message in between
-    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env0.p.consume(frame1,8,env0.ec), 5 );
-    BOOST_CHECK( !env0.ec );
-    BOOST_CHECK_EQUAL( env0.p.ready(), true );
-    BOOST_CHECK_EQUAL( env0.p.get_message()->get_opcode(), websocketpp::frame::opcode::PING);
-    BOOST_CHECK_EQUAL( env0.p.consume(frame1+5,3,env0.ec), 3 );
-    BOOST_CHECK( !env0.ec );
-    BOOST_CHECK_EQUAL( env0.p.ready(), true );
-    BOOST_CHECK_EQUAL( env0.p.get_message()->get_payload(), "**" );
-
-    // read lone continuation frame
-    BOOST_CHECK_EQUAL( env0.p.get_message(), message_ptr() );
-    BOOST_CHECK_GT( env0.p.consume(frame0+3,3,env0.ec), 0);
-    BOOST_CHECK_EQUAL( env0.ec, websocketpp::processor::error::invalid_continuation );
-
-    // read two start frames in a row
-    BOOST_CHECK_EQUAL( env1.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env1.p.consume(frame0,3,env1.ec), 3);
-    BOOST_CHECK( !env1.ec );
-    BOOST_CHECK_GT( env1.p.consume(frame0,3,env1.ec), 0);
-    BOOST_CHECK_EQUAL( env1.ec, websocketpp::processor::error::invalid_continuation );
-}
-
-BOOST_AUTO_TEST_CASE( unmasked_client_frame ) {
-    processor_setup env(true);
-
-    uint8_t frame[2] = {0x82, 0x00};
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_GT( env.p.consume(frame,2,env.ec), 0 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::masking_required );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( masked_server_frame ) {
-    processor_setup env(false);
-
-    uint8_t frame[8] = {0x82, 0x82, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0xD5};
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_GT( env.p.consume(frame,8,env.ec), 0 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::masking_forbidden );
-    BOOST_CHECK_EQUAL( env.p.ready(), false );
-}
-
-BOOST_AUTO_TEST_CASE( frame_small_binary_masked ) {
-    processor_setup env(true);
-
-    uint8_t frame[8] = {0x82, 0x82, 0xFF, 0xFF, 0xFF, 0xFF, 0xD5, 0xD5};
-
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env.p.consume(frame,8,env.ec), 8 );
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "**" );
-}
-
-BOOST_AUTO_TEST_CASE( masked_fragmented_binary_message ) {
-    processor_setup env(true);
-
-    uint8_t frame0[14] = {0x02, 0x81, 0xAB, 0x23, 0x98, 0x45, 0x81,
-                         0x80, 0x81, 0xB8, 0x34, 0x12, 0xFF, 0x92};
-
-    // read fragmented message in one chunk
-    BOOST_CHECK_EQUAL( env.p.get_message(), message_ptr() );
-    BOOST_CHECK_EQUAL( env.p.consume(frame0,14,env.ec), 14 );
-    BOOST_CHECK( !env.ec );
-    BOOST_CHECK_EQUAL( env.p.ready(), true );
-    BOOST_CHECK_EQUAL( env.p.get_message()->get_payload(), "**" );
-}
-
-BOOST_AUTO_TEST_CASE( prepare_data_frame ) {
-    processor_setup env(true);
-
-    message_ptr in = env.msg_manager->get_message();
-    message_ptr out = env.msg_manager->get_message();
-    message_ptr invalid;
-
-    // empty pointers arguements should return sane error
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,invalid), websocketpp::processor::error::invalid_arguments );
-
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(in,invalid), websocketpp::processor::error::invalid_arguments );
-
-    BOOST_CHECK_EQUAL( env.p.prepare_data_frame(invalid,out), websocketpp::processor::error::invalid_arguments );
-
-    // test valid opcodes
-    // control opcodes should return an error, data ones shouldn't
-    for (int i = 0; i < 0xF; i++) {
-        in->set_opcode(websocketpp::frame::opcode::value(i));
-
-        env.ec = env.p.prepare_data_frame(in,out);
-
-        if (websocketpp::frame::opcode::is_control(in->get_opcode())) {
-            BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::invalid_opcode );
-        } else {
-            BOOST_CHECK_NE( env.ec, websocketpp::processor::error::invalid_opcode );
-        }
-    }
-
-
-    //in.set_payload("foo");
-
-    //e = prepare_data_frame(in,out);
-
-
-}
-
-BOOST_AUTO_TEST_CASE( single_frame_message_too_large ) {
-    processor_setup env(true);
-    
-    env.p.set_max_message_size(3);
-    
-    uint8_t frame0[10] = {0x82, 0x84, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01};
-
-    // read message that is one byte too large
-    BOOST_CHECK_EQUAL( env.p.consume(frame0,10,env.ec), 6 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::message_too_big );
-}
-
-BOOST_AUTO_TEST_CASE( multiple_frame_message_too_large ) {
-    processor_setup env(true);
-    
-    env.p.set_max_message_size(4);
-    
-    uint8_t frame0[8] = {0x02, 0x82, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01};
-    uint8_t frame1[9] = {0x80, 0x83, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01};
-
-    // read first message frame with size under the limit
-    BOOST_CHECK_EQUAL( env.p.consume(frame0,8,env.ec), 8 );
-    BOOST_CHECK( !env.ec );
-    
-    // read second message frame that puts the size over the limit
-    BOOST_CHECK_EQUAL( env.p.consume(frame1,9,env.ec), 6 );
-    BOOST_CHECK_EQUAL( env.ec, websocketpp::processor::error::message_too_big );
-}
-
-
-
-BOOST_AUTO_TEST_CASE( client_handshake_request ) {
-    processor_setup env(false);
-
-    websocketpp::uri_ptr u(new websocketpp::uri("ws://localhost/"));
-
-    env.p.client_handshake_request(env.req,u, std::vector<std::string>());
-
-    BOOST_CHECK_EQUAL( env.req.get_method(), "GET" );
-    BOOST_CHECK_EQUAL( env.req.get_version(), "HTTP/1.1");
-    BOOST_CHECK_EQUAL( env.req.get_uri(), "/");
-
-    BOOST_CHECK_EQUAL( env.req.get_header("Host"), "localhost");
-    BOOST_CHECK_EQUAL( env.req.get_header("Sec-WebSocket-Version"), "13");
-    BOOST_CHECK_EQUAL( env.req.get_header("Connection"), "Upgrade");
-    BOOST_CHECK_EQUAL( env.req.get_header("Upgrade"), "websocket");
-}
-
-// TODO:
-// test cases
-// - adding headers
-// - adding Upgrade header
-// - adding Connection header
-// - adding Sec-WebSocket-Version, Sec-WebSocket-Key, or Host header
-// - other Sec* headers?
-// - User Agent header?
-
-// Origin support
-// Subprotocol requests
-
-//websocketpp::uri_ptr u(new websocketpp::uri("ws://localhost/"));
-    //env.p.client_handshake_request(env.req,u);
-
-BOOST_AUTO_TEST_CASE( client_handshake_response_404 ) {
-    processor_setup env(false);
-
-    std::string res = "HTTP/1.1 404 Not Found\r\n\r\n";
-    env.res.consume(res.data(),res.size());
-
-    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::invalid_http_status );
-}
-
-BOOST_AUTO_TEST_CASE( client_handshake_response_no_upgrade ) {
-    processor_setup env(false);
-
-    std::string res = "HTTP/1.1 101 Switching Protocols\r\n\r\n";
-    env.res.consume(res.data(),res.size());
-
-    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( client_handshake_response_no_connection ) {
-    processor_setup env(false);
-
-    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\n\r\n";
-    env.res.consume(res.data(),res.size());
-
-    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( client_handshake_response_no_accept ) {
-    processor_setup env(false);
-
-    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\nConnection: bar, UpGrAdE\r\n\r\n";
-    env.res.consume(res.data(),res.size());
-
-    BOOST_CHECK_EQUAL( env.p.validate_server_handshake_response(env.req,env.res), websocketpp::processor::error::missing_required_header );
-}
-
-BOOST_AUTO_TEST_CASE( client_handshake_response ) {
-    processor_setup env(false);
-
-    env.req.append_header("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
-
-    std::string res = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: foo, wEbsOckEt\r\nConnection: bar, UpGrAdE\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n";
-    env.res.consume(res.data(),res.size());
-
-    BOOST_CHECK( !env.p.validate_server_handshake_response(env.req,env.res) );
-}
-
-BOOST_AUTO_TEST_CASE( extensions_disabled ) {
-    processor_setup env(true);
-
-    env.req.replace_header("Sec-WebSocket-Extensions","");
-
-    std::pair<websocketpp::lib::error_code,std::string> neg_results;
-    neg_results = env.p.negotiate_extensions(env.req);
-
-    BOOST_CHECK_EQUAL( neg_results.first, websocketpp::processor::error::extensions_disabled );
-    BOOST_CHECK_EQUAL( neg_results.second, "" );
-}
-
-BOOST_AUTO_TEST_CASE( extension_negotiation_blank ) {
-    processor_setup_ext env(true);
-
-    env.req.replace_header("Sec-WebSocket-Extensions","");
-
-    std::pair<websocketpp::lib::error_code,std::string> neg_results;
-    neg_results = env.p.negotiate_extensions(env.req);
-
-    BOOST_CHECK( !neg_results.first );
-    BOOST_CHECK_EQUAL( neg_results.second, "" );
-}
-
-BOOST_AUTO_TEST_CASE( extension_negotiation_unknown ) {
-    processor_setup_ext env(true);
-
-    env.req.replace_header("Sec-WebSocket-Extensions","foo");
-
-    std::pair<websocketpp::lib::error_code,std::string> neg_results;
-    neg_results = env.p.negotiate_extensions(env.req);
-
-    BOOST_CHECK( !neg_results.first );
-    BOOST_CHECK_EQUAL( neg_results.second, "" );
-}
-
-BOOST_AUTO_TEST_CASE( extract_subprotocols_empty ) {
-    processor_setup env(true);
-    std::vector<std::string> subps;
-
-    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
-    BOOST_CHECK_EQUAL( subps.size(), 0 );
-}
-
-BOOST_AUTO_TEST_CASE( extract_subprotocols_one ) {
-    processor_setup env(true);
-    std::vector<std::string> subps;
-
-    env.req.replace_header("Sec-WebSocket-Protocol","foo");
-
-    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
-    BOOST_REQUIRE_EQUAL( subps.size(), 1 );
-    BOOST_CHECK_EQUAL( subps[0], "foo" );
-}
-
-BOOST_AUTO_TEST_CASE( extract_subprotocols_multiple ) {
-    processor_setup env(true);
-    std::vector<std::string> subps;
-
-    env.req.replace_header("Sec-WebSocket-Protocol","foo,bar");
-
-    BOOST_CHECK( !env.p.extract_subprotocols(env.req,subps) );
-    BOOST_REQUIRE_EQUAL( subps.size(), 2 );
-    BOOST_CHECK_EQUAL( subps[0], "foo" );
-    BOOST_CHECK_EQUAL( subps[1], "bar" );
-}
-
-BOOST_AUTO_TEST_CASE( extract_subprotocols_invalid) {
-    processor_setup env(true);
-    std::vector<std::string> subps;
-
-    env.req.replace_header("Sec-WebSocket-Protocol","foo,bar,,,,");
-
-    BOOST_CHECK_EQUAL( env.p.extract_subprotocols(env.req,subps), websocketpp::processor::error::make_error_code(websocketpp::processor::error::subprotocol_parse_error) );
-    BOOST_CHECK_EQUAL( subps.size(), 0 );
-}
-
-BOOST_AUTO_TEST_CASE( extension_negotiation_permessage_deflate ) {
-    processor_setup_ext env(true);
-
-    env.req.replace_header("Sec-WebSocket-Extensions",
-        "permessage-deflate; client_max_window_bits");
-
-    std::pair<websocketpp::lib::error_code,std::string> neg_results;
-    neg_results = env.p.negotiate_extensions(env.req);
-
-    BOOST_CHECK( !neg_results.first );
-    BOOST_CHECK_EQUAL( neg_results.second, "permessage-deflate" );
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/processor.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/processor.cpp
deleted file mode 100644
index 2c4e706..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/processors/processor.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE processors
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/processors/processor.hpp>
-#include <websocketpp/http/request.hpp>
-
-BOOST_AUTO_TEST_CASE( exact_match ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( non_match ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(!websocketpp::processor::is_websocket_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( ci_exact_match ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: UpGrAde\r\nUpgrade: WebSocket\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( non_exact_match1 ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade,foo\r\nUpgrade: websocket,foo\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( non_exact_match2 ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: keep-alive,Upgrade,foo\r\nUpgrade: foo,websocket,bar\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::is_websocket_handshake(r));
-}
-
-BOOST_AUTO_TEST_CASE( version_blank ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 0);
-}
-
-BOOST_AUTO_TEST_CASE( version_7 ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 7\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 7);
-}
-
-BOOST_AUTO_TEST_CASE( version_8 ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 8\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 8);
-}
-
-BOOST_AUTO_TEST_CASE( version_13 ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == 13);
-}
-
-BOOST_AUTO_TEST_CASE( version_non_numeric ) {
-    websocketpp::http::parser::request r;
-
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nUpgrade: websocket\r\nSec-WebSocket-Version: abc\r\n\r\n";
-
-    r.consume(handshake.c_str(),handshake.size());
-
-    BOOST_CHECK(websocketpp::processor::get_websocket_version(r) == -1);
-}
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/random/CMakeLists.txt
deleted file mode 100644
index 1fd459d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test RNG policy none
-file (GLOB SOURCE none.cpp)
-
-init_target (test_random_none)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test RNG policy random_device
-file (GLOB SOURCE random_device.cpp)
-
-init_target (test_random_random_device)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/random/SConscript
deleted file mode 100644
index 3cadc9e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/SConscript
+++ /dev/null
@@ -1,27 +0,0 @@
-## random number generation unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','random','system'],env) + [platform_libs]
-
-objs = env.Object('random_none_boost.o', ["none.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('random_device_boost.o', ["random_device.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_random_none_boost', ["random_none_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_random_device_boost', ["random_device_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('random_none_stl.o', ["none.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('random_device_stl.o', ["random_device.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_random_none_stl', ["random_none_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_random_device_stl', ["random_device_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/none.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/random/none.cpp
deleted file mode 100644
index b27b239..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/none.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE random_none
-#include <boost/test/unit_test.hpp>
-
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/random/none.hpp>
-
-BOOST_AUTO_TEST_CASE( does_it_compile ) {
-    websocketpp::random::none::int_generator<int32_t> rng;
-
-    int32_t foo = rng();
-
-    BOOST_CHECK( foo == 0 );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/random_device.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/random/random_device.cpp
deleted file mode 100644
index b3ce3a5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/random/random_device.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE random_device
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/random/random_device.hpp>
-#include <websocketpp/concurrency/none.hpp>
-
-BOOST_AUTO_TEST_CASE( compiles ) {
-    websocketpp::random::random_device::int_generator<int32_t,websocketpp::concurrency::none> rng;
-
-    bool e = false;
-
-    try {
-        int32_t foo = rng();
-        std::cout << foo << std::endl;
-    } catch (...) {
-        e = true;
-    }
-
-    BOOST_CHECK( e == false );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/CMakeLists.txt
deleted file mode 100644
index 5d41137..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-# Test client role
-file (GLOB SOURCE client.cpp)
-
-init_target (test_roles_client)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test server role
-file (GLOB SOURCE server.cpp)
-
-init_target (test_roles_server)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/SConscript
deleted file mode 100644
index e86107e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/SConscript
+++ /dev/null
@@ -1,27 +0,0 @@
-## role unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system','random'],env) + [platform_libs]
-
-objs = env.Object('client_boost.o', ["client.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('server_boost.o', ["server.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_client_boost', ["client_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_server_boost', ["server_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('client_stl.o', ["client.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('server_stl.o', ["server.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_client_stl', ["client_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_server_stl', ["server_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/client.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/client.cpp
deleted file mode 100644
index 9aab3ee..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/client.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE client
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include <websocketpp/random/random_device.hpp>
-
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/http/request.hpp>
-
-struct stub_config : public websocketpp::config::core {
-    typedef core::concurrency_type concurrency_type;
-
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-
-    //typedef core::rng_type rng_type;
-    typedef websocketpp::random::random_device::int_generator<uint32_t,concurrency_type> rng_type;
-
-    typedef core::transport_type transport_type;
-
-    typedef core::endpoint_base endpoint_base;
-
-    static const websocketpp::log::level elog_level = websocketpp::log::elevel::none;
-    static const websocketpp::log::level alog_level = websocketpp::log::alevel::none;
-};
-
-typedef websocketpp::client<stub_config> client;
-typedef client::connection_ptr connection_ptr;
-
-BOOST_AUTO_TEST_CASE( invalid_uri ) {
-    client c;
-    websocketpp::lib::error_code ec;
-
-    connection_ptr con = c.get_connection("foo", ec);
-
-    BOOST_CHECK_EQUAL( ec , websocketpp::error::make_error_code(websocketpp::error::invalid_uri) );
-}
-
-BOOST_AUTO_TEST_CASE( unsecure_endpoint ) {
-    client c;
-    websocketpp::lib::error_code ec;
-
-    connection_ptr con = c.get_connection("wss://localhost/", ec);
-
-    BOOST_CHECK_EQUAL( ec , websocketpp::error::make_error_code(websocketpp::error::endpoint_not_secure) );
-}
-
-BOOST_AUTO_TEST_CASE( get_connection ) {
-    client c;
-    websocketpp::lib::error_code ec;
-
-    connection_ptr con = c.get_connection("ws://localhost/", ec);
-
-    BOOST_CHECK( con );
-    BOOST_CHECK_EQUAL( con->get_host() , "localhost" );
-    BOOST_CHECK_EQUAL( con->get_port() , 80 );
-    BOOST_CHECK_EQUAL( con->get_secure() , false );
-    BOOST_CHECK_EQUAL( con->get_resource() , "/" );
-}
-
-BOOST_AUTO_TEST_CASE( connect_con ) {
-    client c;
-    websocketpp::lib::error_code ec;
-    std::stringstream out;
-    std::string o;
-
-    c.register_ostream(&out);
-
-    connection_ptr con = c.get_connection("ws://localhost/", ec);
-    c.connect(con);
-
-    o = out.str();
-    websocketpp::http::parser::request r;
-    r.consume(o.data(),o.size());
-
-    BOOST_CHECK( r.ready() );
-    BOOST_CHECK_EQUAL( r.get_method(), "GET");
-    BOOST_CHECK_EQUAL( r.get_version(), "HTTP/1.1");
-    BOOST_CHECK_EQUAL( r.get_uri(), "/");
-
-    BOOST_CHECK_EQUAL( r.get_header("Host"), "localhost");
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Version"), "13");
-    BOOST_CHECK_EQUAL( r.get_header("Connection"), "Upgrade");
-    BOOST_CHECK_EQUAL( r.get_header("Upgrade"), "websocket");
-
-    // Key is randomly generated & User-Agent will change so just check that
-    // they are not empty.
-    BOOST_CHECK_NE( r.get_header("Sec-WebSocket-Key"), "");
-    BOOST_CHECK_NE( r.get_header("User-Agent"), "" );
-
-    // connection should have written out an opening handshake request and be in
-    // the read response internal state
-
-    // TODO: more tests related to reading the HTTP response
-    std::stringstream channel2;
-    channel2 << "e\r\n\r\n";
-    channel2 >> *con;
-}
-
-BOOST_AUTO_TEST_CASE( select_subprotocol ) {
-    client c;
-    websocketpp::lib::error_code ec;
-    using websocketpp::error::make_error_code;
-
-    connection_ptr con = c.get_connection("ws://localhost/", ec);
-
-    BOOST_CHECK( con );
-
-    con->select_subprotocol("foo",ec);
-    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::server_only) );
-    BOOST_CHECK_THROW( con->select_subprotocol("foo") , websocketpp::exception );
-}
-
-BOOST_AUTO_TEST_CASE( add_subprotocols_invalid ) {
-    client c;
-    websocketpp::lib::error_code ec;
-    using websocketpp::error::make_error_code;
-
-    connection_ptr con = c.get_connection("ws://localhost/", ec);
-    BOOST_CHECK( con );
-
-    con->add_subprotocol("",ec);
-    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::invalid_subprotocol) );
-    BOOST_CHECK_THROW( con->add_subprotocol("") , websocketpp::exception );
-
-    con->add_subprotocol("foo,bar",ec);
-    BOOST_CHECK_EQUAL( ec , make_error_code(websocketpp::error::invalid_subprotocol) );
-    BOOST_CHECK_THROW( con->add_subprotocol("foo,bar") , websocketpp::exception );
-}
-
-BOOST_AUTO_TEST_CASE( add_subprotocols ) {
-    client c;
-    websocketpp::lib::error_code ec;
-    std::stringstream out;
-    std::string o;
-
-    c.register_ostream(&out);
-
-    connection_ptr con = c.get_connection("ws://localhost/", ec);
-    BOOST_CHECK( con );
-
-    con->add_subprotocol("foo",ec);
-    BOOST_CHECK( !ec );
-
-    BOOST_CHECK_NO_THROW( con->add_subprotocol("bar") );
-
-    c.connect(con);
-
-    o = out.str();
-    websocketpp::http::parser::request r;
-    r.consume(o.data(),o.size());
-
-    BOOST_CHECK( r.ready() );
-    BOOST_CHECK_EQUAL( r.get_header("Sec-WebSocket-Protocol"), "foo, bar");
-}
-
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/server.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/server.cpp
deleted file mode 100644
index 5f3d436..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/roles/server.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE server
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-// Test Environment:
-// server, no TLS, no locks, iostream based transport
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/server.hpp>
-
-typedef websocketpp::server<websocketpp::config::core> server;
-typedef websocketpp::config::core::message_type::ptr message_ptr;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-/*struct stub_config : public websocketpp::config::core {
-    typedef core::concurrency_type concurrency_type;
-
-    typedef core::request_type request_type;
-    typedef core::response_type response_type;
-
-    typedef core::message_type message_type;
-    typedef core::con_msg_manager_type con_msg_manager_type;
-    typedef core::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef core::alog_type alog_type;
-    typedef core::elog_type elog_type;
-
-    typedef core::rng_type rng_type;
-
-    typedef core::transport_type transport_type;
-
-    typedef core::endpoint_base endpoint_base;
-};*/
-
-/* Run server and return output test rig */
-std::string run_server_test(server& s, std::string input) {
-    server::connection_ptr con;
-    std::stringstream output;
-
-    s.register_ostream(&output);
-    s.clear_access_channels(websocketpp::log::alevel::all);
-    s.clear_error_channels(websocketpp::log::elevel::all);
-
-    con = s.get_connection();
-    con->start();
-
-    std::stringstream channel;
-
-    channel << input;
-    channel >> *con;
-
-    return output.str();
-}
-
-/* handler library*/
-void echo_func(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
-    s->send(hdl, msg->get_payload(), msg->get_opcode());
-}
-
-bool validate_func_subprotocol(server* s, std::string* out, std::string accept,
-    websocketpp::connection_hdl hdl)
-{
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    std::stringstream o;
-
-    const std::vector<std::string> & protocols = con->get_requested_subprotocols();
-    std::vector<std::string>::const_iterator it;
-
-    for (it = protocols.begin(); it != protocols.end(); ++it) {
-        o << *it << ",";
-    }
-
-    *out = o.str();
-
-    if (!accept.empty()) {
-        con->select_subprotocol(accept);
-    }
-
-    return true;
-}
-
-void open_func_subprotocol(server* s, std::string* out, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-
-    *out = con->get_subprotocol();
-}
-
-/* Tests */
-BOOST_AUTO_TEST_CASE( basic_websocket_request ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    server s;
-    s.set_user_agent("test");
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( invalid_websocket_version ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: a\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-    std::string output = "HTTP/1.1 400 Bad Request\r\nServer: test\r\n\r\n";
-
-    server s;
-    s.set_user_agent("test");
-    //s.set_message_handler(bind(&echo_func,&s,::_1,::_2));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( unimplemented_websocket_version ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 14\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\n\r\n";
-
-    std::string output = "HTTP/1.1 400 Bad Request\r\nSec-WebSocket-Version: 0,7,8,13\r\nServer: test\r\n\r\n";
-
-    server s;
-    s.set_user_agent("test");
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-}
-
-BOOST_AUTO_TEST_CASE( list_subprotocol_empty ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string subprotocol;
-
-    server s;
-    s.set_user_agent("test");
-    s.set_open_handler(bind(&open_func_subprotocol,&s,&subprotocol,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-    BOOST_CHECK_EQUAL(subprotocol, "");
-}
-
-BOOST_AUTO_TEST_CASE( list_subprotocol_one ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string validate;
-    std::string open;
-
-    server s;
-    s.set_user_agent("test");
-    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"",::_1));
-    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-    BOOST_CHECK_EQUAL(validate, "foo,");
-    BOOST_CHECK_EQUAL(open, "");
-}
-
-BOOST_AUTO_TEST_CASE( accept_subprotocol_one ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: foo\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string validate;
-    std::string open;
-
-    server s;
-    s.set_user_agent("test");
-    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"foo",::_1));
-    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-    BOOST_CHECK_EQUAL(validate, "foo,");
-    BOOST_CHECK_EQUAL(open, "foo");
-}
-
-BOOST_AUTO_TEST_CASE( accept_subprotocol_invalid ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo\r\n\r\n";
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: foo\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string validate;
-    std::string open;
-
-    server s;
-    s.set_user_agent("test");
-    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"foo2",::_1));
-    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
-
-    std::string o;
-
-    BOOST_CHECK_THROW(o = run_server_test(s,input), websocketpp::exception);
-}
-
-BOOST_AUTO_TEST_CASE( accept_subprotocol_two ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example.com\r\nSec-WebSocket-Protocol: foo, bar\r\n\r\n";
-
-    std::string output = "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\nSec-WebSocket-Protocol: bar\r\nServer: test\r\nUpgrade: websocket\r\n\r\n";
-
-    std::string validate;
-    std::string open;
-
-    server s;
-    s.set_user_agent("test");
-    s.set_validate_handler(bind(&validate_func_subprotocol,&s,&validate,"bar",::_1));
-    s.set_open_handler(bind(&open_func_subprotocol,&s,&open,::_1));
-
-    BOOST_CHECK_EQUAL(run_server_test(s,input), output);
-    BOOST_CHECK_EQUAL(validate, "foo,bar,");
-    BOOST_CHECK_EQUAL(open, "bar");
-}
-
-/*BOOST_AUTO_TEST_CASE( user_reject_origin ) {
-    std::string input = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nOrigin: http://www.example2.com\r\n\r\n";
-    std::string output = "HTTP/1.1 403 Forbidden\r\nServer: test\r\n\r\n";
-
-    server s;
-    s.set_user_agent("test");
-
-    BOOST_CHECK(run_server_test(s,input) == output);
-}*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/CMakeLists.txt
deleted file mode 100644
index 6b44d98..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/CMakeLists.txt
+++ /dev/null
@@ -1,71 +0,0 @@
-if (OPENSSL_FOUND)
-
-# Test transport integration
-file (GLOB SOURCE integration.cpp)
-
-init_target (test_transport)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_openssl()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test transport asio timers
-file (GLOB SOURCE asio/timers.cpp)
-
-init_target (test_transport_asio_timers)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_openssl()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test transport asio security
-file (GLOB SOURCE asio/security.cpp)
-
-init_target (test_transport_asio_security)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-link_openssl()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-endif()
-
-# Test transport iostream base
-file (GLOB SOURCE iostream/base.cpp)
-
-init_target (test_transport_iostream_base)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test transport iostream endpoint
-file (GLOB SOURCE iostream/endpoint.cpp)
-
-init_target (test_transport_iostream_endpoint)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test transport iostream connection
-file (GLOB SOURCE iostream/connection.cpp)
-
-init_target (test_transport_iostream_connection)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test transport asio base
-file (GLOB SOURCE asio/base.cpp)
-
-init_target (test_transport_asio_base)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/SConscript
deleted file mode 100644
index 71b31b6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/SConscript
+++ /dev/null
@@ -1,24 +0,0 @@
-## transport integration tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system','thread','random','chrono'],env) + [platform_libs] + [tls_libs]
-
-objs = env.Object('boost_integration.o', ["integration.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_boost_integration', ["boost_integration.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   objs += env_cpp11.Object('stl_integration.o', ["integration.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_stl_integration', ["stl_integration.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/SConscript
deleted file mode 100644
index f8185e5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/SConscript
+++ /dev/null
@@ -1,32 +0,0 @@
-## asio transport unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-Import('tls_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system','thread','chrono'],env) + [platform_libs] + [tls_libs]
-
-objs = env.Object('base_boost.o', ["base.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('timers_boost.o', ["timers.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('security_boost.o', ["security.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_base_boost', ["base_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_timers_boost', ["timers_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_security_boost', ["security_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework','system'],env_cpp11) + [platform_libs] + [polyfill_libs] + [tls_libs]
-   objs += env_cpp11.Object('base_stl.o', ["base.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('timers_stl.o', ["timers.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('security_stl.o', ["security.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_base_stl', ["base_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_timers_stl', ["timers_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_security_stl', ["security_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/base.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/base.cpp
deleted file mode 100644
index e9f96ae..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/base.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_asio_base
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include <websocketpp/transport/asio/base.hpp>
-
-BOOST_AUTO_TEST_CASE( blank_error ) {
-    websocketpp::lib::error_code ec;
-
-    BOOST_CHECK( !ec );
-}
-
-BOOST_AUTO_TEST_CASE( asio_error ) {
-    using websocketpp::transport::asio::error::make_error_code;
-    using websocketpp::transport::asio::error::general;
-
-    websocketpp::lib::error_code ec = make_error_code(general);
-
-    BOOST_CHECK( ec == general );
-    BOOST_CHECK( ec.value() == 1 );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/security.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/security.cpp
deleted file mode 100644
index a75e2a8..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/security.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_asio_base
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include <websocketpp/common/type_traits.hpp>
-
-#include <websocketpp/transport/asio/security/none.hpp>
-#include <websocketpp/transport/asio/security/tls.hpp>
-
-template <typename base>
-struct dummy_con : public base {
-	websocketpp::lib::error_code test() {
-		return this->translate_ec(websocketpp::lib::asio::error_code());
-	}
-};
-
-BOOST_AUTO_TEST_CASE( translated_ec_none ) {
-    dummy_con<websocketpp::transport::asio::basic_socket::connection> tscon;
-
-	// If the current configuration settings result in the library error type and the asio
-	// error type being the same, then the code should pass through natively. Otherwise
-	// we should get a generic pass through error.
-	if(websocketpp::lib::is_same<websocketpp::lib::error_code,websocketpp::lib::asio::error_code>::value) {
-    	BOOST_CHECK_EQUAL( tscon.test(), websocketpp::lib::error_code() );
-    } else {
-    	BOOST_CHECK_EQUAL( tscon.test(), websocketpp::transport::error::make_error_code(websocketpp::transport::error::pass_through) );
-    }
-}
-
-BOOST_AUTO_TEST_CASE( translated_ec_tls ) {
-    dummy_con<websocketpp::transport::asio::tls_socket::connection> tscon;
-
-	// If the current configuration settings result in the library error type and the asio
-	// error type being the same, then the code should pass through natively. Otherwise
-	// we should get a generic pass through error.
-	if(websocketpp::lib::is_same<websocketpp::lib::error_code,websocketpp::lib::asio::error_code>::value) {
-    	BOOST_CHECK_EQUAL( tscon.test(), websocketpp::lib::error_code() );
-    } else {
-    	BOOST_CHECK_EQUAL( tscon.test(), websocketpp::transport::error::make_error_code(websocketpp::transport::error::pass_through) );
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/timers.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/timers.cpp
deleted file mode 100644
index aa03d61..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/asio/timers.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_asio_timers
-#include <boost/test/unit_test.hpp>
-
-#include <exception>
-#include <iostream>
-
-#include <websocketpp/common/thread.hpp>
-
-#include <websocketpp/transport/asio/endpoint.hpp>
-#include <websocketpp/transport/asio/security/tls.hpp>
-
-// Concurrency
-#include <websocketpp/concurrency/none.hpp>
-
-// HTTP
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-// Loggers
-#include <websocketpp/logger/stub.hpp>
-//#include <websocketpp/logger/basic.hpp>
-
-#include <boost/asio.hpp>
-
-// Accept a connection, read data, and discard until EOF
-void run_dummy_server(int port) {
-    using boost::asio::ip::tcp;
-
-    try {
-        boost::asio::io_service io_service;
-        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), port));
-        tcp::socket socket(io_service);
-
-        acceptor.accept(socket);
-        for (;;) {
-            char data[512];
-            boost::system::error_code ec;
-            socket.read_some(boost::asio::buffer(data), ec);
-            if (ec == boost::asio::error::eof) {
-                break;
-            } else if (ec) {
-                // other error
-                throw ec;
-            }
-        }
-    } catch (std::exception & e) {
-        std::cout << e.what() << std::endl;
-    } catch (boost::system::error_code & ec) {
-        std::cout << ec.message() << std::endl;
-    }
-}
-
-// Wait for the specified time period then fail the test
-void run_test_timer(long value) {
-    boost::asio::io_service ios;
-    boost::asio::deadline_timer t(ios,boost::posix_time::milliseconds(value));
-    boost::system::error_code ec;
-    t.wait(ec);
-    BOOST_FAIL( "Test timed out" );
-}
-
-struct config {
-    typedef websocketpp::concurrency::none concurrency_type;
-    //typedef websocketpp::log::basic<concurrency_type,websocketpp::log::alevel> alog_type;
-    typedef websocketpp::log::stub alog_type;
-    typedef websocketpp::log::stub elog_type;
-    typedef websocketpp::http::parser::request request_type;
-    typedef websocketpp::http::parser::response response_type;
-    typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
-
-    static const bool enable_multithreading = true;
-
-    static const long timeout_socket_pre_init = 1000;
-    static const long timeout_proxy = 1000;
-    static const long timeout_socket_post_init = 1000;
-    static const long timeout_dns_resolve = 1000;
-    static const long timeout_connect = 1000;
-    static const long timeout_socket_shutdown = 1000;
-};
-
-// Mock context that does no validation
-typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
-context_ptr on_tls_init(websocketpp::connection_hdl) {
-    return context_ptr(new boost::asio::ssl::context(boost::asio::ssl::context::sslv23));
-}
-
-// Mock connection
-struct mock_con: public websocketpp::transport::asio::connection<config> {
-    typedef websocketpp::transport::asio::connection<config> base;
-
-    mock_con(bool a, const websocketpp::lib::shared_ptr<config::alog_type>& b,
-             const websocketpp::lib::shared_ptr<config::elog_type>& c)
-            : base(a,b,c) {}
-
-    void start() {
-        base::init(websocketpp::lib::bind(&mock_con::handle_start,this,
-            websocketpp::lib::placeholders::_1));
-    }
-
-    void handle_start(const websocketpp::lib::error_code& ec) {
-        using websocketpp::transport::asio::socket::make_error_code;
-        using websocketpp::transport::asio::socket::error::tls_handshake_timeout;
-
-        BOOST_CHECK_EQUAL( ec, make_error_code(tls_handshake_timeout) );
-
-        base::cancel_socket();
-    }
-};
-
-typedef websocketpp::transport::asio::connection<config> con_type;
-typedef websocketpp::lib::shared_ptr<mock_con> connection_ptr;
-
-struct mock_endpoint : public websocketpp::transport::asio::endpoint<config> {
-    typedef websocketpp::transport::asio::endpoint<config> base;
-
-    mock_endpoint()
-        : alog(websocketpp::lib::make_shared<config::alog_type>())
-        , elog(websocketpp::lib::make_shared<config::elog_type>())
-    {
-        alog->set_channels(websocketpp::log::alevel::all);
-        base::init_logging(alog,elog);
-        init_asio();
-    }
-
-    void connect(std::string u) {
-        m_con.reset(new mock_con(false,alog,elog));
-        websocketpp::uri_ptr uri(new websocketpp::uri(u));
-
-        BOOST_CHECK( uri->get_valid() );
-        BOOST_CHECK_EQUAL( base::init(m_con), websocketpp::lib::error_code() );
-
-        base::async_connect(
-            m_con,
-            uri,
-            websocketpp::lib::bind(
-                &mock_endpoint::handle_connect,
-                this,
-                m_con,
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void handle_connect(connection_ptr con, websocketpp::lib::error_code const & ec)
-    {
-        BOOST_CHECK( !ec );
-        con->start();
-    }
-
-    connection_ptr m_con;
-    websocketpp::lib::shared_ptr<config::alog_type> alog;
-    websocketpp::lib::shared_ptr<config::elog_type> elog;
-};
-
-BOOST_AUTO_TEST_CASE( tls_handshake_timeout ) {
-    websocketpp::lib::thread dummy_server(websocketpp::lib::bind(&run_dummy_server,9005));
-    websocketpp::lib::thread timer(websocketpp::lib::bind(&run_test_timer,5000));
-    dummy_server.detach();
-    timer.detach();
-
-    sleep(1); // give the server thread some time to start
-
-    mock_endpoint endpoint;
-    endpoint.set_tls_init_handler(&on_tls_init);
-    endpoint.connect("wss://localhost:9005");
-    endpoint.run();
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/hybi_util.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/hybi_util.cpp
deleted file mode 100644
index 309bf37..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/hybi_util.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE hybi_util
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include "../../src/processors/hybi_util.hpp"
-#include "../../src/network_utilities.hpp"
-
-BOOST_AUTO_TEST_CASE( circshift_0 ) {
-    if (sizeof(size_t) == 8) {
-        size_t test = 0x0123456789abcdef;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,0);
-
-        BOOST_CHECK( test == 0x0123456789abcdef);
-    } else {
-        size_t test = 0x01234567;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,0);
-
-        BOOST_CHECK( test == 0x01234567);
-    }
-}
-
-BOOST_AUTO_TEST_CASE( circshift_1 ) {
-    if (sizeof(size_t) == 8) {
-        size_t test = 0x0123456789abcdef;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,1);
-
-        BOOST_CHECK( test == 0xef0123456789abcd);
-    } else {
-        size_t test = 0x01234567;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,1);
-
-        BOOST_CHECK( test == 0x67012345);
-    }
-}
-
-BOOST_AUTO_TEST_CASE( circshift_2 ) {
-    if (sizeof(size_t) == 8) {
-        size_t test = 0x0123456789abcdef;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,2);
-
-        BOOST_CHECK( test == 0xcdef0123456789ab);
-    } else {
-        size_t test = 0x01234567;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,2);
-
-        BOOST_CHECK( test == 0x45670123);
-    }
-}
-
-BOOST_AUTO_TEST_CASE( circshift_3 ) {
-    if (sizeof(size_t) == 8) {
-        size_t test = 0x0123456789abcdef;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,3);
-
-        BOOST_CHECK( test == 0xabcdef0123456789);
-    } else {
-        size_t test = 0x01234567;
-
-        test = websocketpp::processor::hybi_util::circshift_prepared_key(test,3);
-
-        BOOST_CHECK( test == 0x23456701);
-    }
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/integration.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/integration.cpp
deleted file mode 100644
index c083cfd..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/integration.cpp
+++ /dev/null
@@ -1,651 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_integration
-#include <boost/test/unit_test.hpp>
-
-#include <websocketpp/common/thread.hpp>
-
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/config/core_client.hpp>
-#include <websocketpp/config/asio.hpp>
-#include <websocketpp/config/asio_client.hpp>
-#include <websocketpp/config/debug_asio.hpp>
-#include <websocketpp/server.hpp>
-#include <websocketpp/client.hpp>
-
-struct config : public websocketpp::config::asio_client {
-    typedef config type;
-    typedef websocketpp::config::asio base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-
-    //static const websocketpp::log::level elog_level = websocketpp::log::elevel::all;
-    //static const websocketpp::log::level alog_level = websocketpp::log::alevel::all;
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 500;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 500;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 500;
-};
-
-struct config_tls : public websocketpp::config::asio_tls_client {
-    typedef config type;
-    typedef websocketpp::config::asio base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-
-    //static const websocketpp::log::level elog_level = websocketpp::log::elevel::all;
-    //static const websocketpp::log::level alog_level = websocketpp::log::alevel::all;
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 500;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 500;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 500;
-};
-
-typedef websocketpp::server<config> server;
-typedef websocketpp::client<config> client;
-
-typedef websocketpp::server<config_tls> server_tls;
-typedef websocketpp::client<config_tls> client_tls;
-
-typedef websocketpp::server<websocketpp::config::core> iostream_server;
-typedef websocketpp::client<websocketpp::config::core_client> iostream_client;
-
-using websocketpp::lib::placeholders::_1;
-using websocketpp::lib::placeholders::_2;
-using websocketpp::lib::bind;
-
-template <typename T>
-void close_after_timeout(T & e, websocketpp::connection_hdl hdl, long timeout) {
-    sleep(timeout);
-
-    websocketpp::lib::error_code ec;
-    e.close(hdl,websocketpp::close::status::normal,"",ec);
-    BOOST_CHECK(!ec);
-}
-
-void run_server(server * s, int port, bool log = false) {
-    if (log) {
-        s->set_access_channels(websocketpp::log::alevel::all);
-        s->set_error_channels(websocketpp::log::elevel::all);
-    } else {
-        s->clear_access_channels(websocketpp::log::alevel::all);
-        s->clear_error_channels(websocketpp::log::elevel::all);
-    }
-
-    s->init_asio();
-    s->set_reuse_addr(true);
-
-    s->listen(port);
-    s->start_accept();
-    s->run();
-}
-
-void run_client(client & c, std::string uri, bool log = false) {
-    if (log) {
-        c.set_access_channels(websocketpp::log::alevel::all);
-        c.set_error_channels(websocketpp::log::elevel::all);
-    } else {
-        c.clear_access_channels(websocketpp::log::alevel::all);
-        c.clear_error_channels(websocketpp::log::elevel::all);
-    }
-    websocketpp::lib::error_code ec;
-    c.init_asio(ec);
-    c.set_reuse_addr(true);
-    BOOST_CHECK(!ec);
-
-    client::connection_ptr con = c.get_connection(uri,ec);
-    BOOST_CHECK( !ec );
-    c.connect(con);
-
-    c.run();
-}
-
-void run_client_and_mark(client * c, bool * flag, websocketpp::lib::mutex * mutex) {
-    c->run();
-    BOOST_CHECK( true );
-    websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(*mutex);
-    *flag = true;
-    BOOST_CHECK( true );
-}
-
-void run_time_limited_client(client & c, std::string uri, long timeout,
-    bool log)
-{
-    if (log) {
-        c.set_access_channels(websocketpp::log::alevel::all);
-        c.set_error_channels(websocketpp::log::elevel::all);
-    } else {
-        c.clear_access_channels(websocketpp::log::alevel::all);
-        c.clear_error_channels(websocketpp::log::elevel::all);
-    }
-    c.init_asio();
-
-    websocketpp::lib::error_code ec;
-    client::connection_ptr con = c.get_connection(uri,ec);
-    BOOST_CHECK( !ec );
-    c.connect(con);
-
-    websocketpp::lib::thread tthread(websocketpp::lib::bind(
-        &close_after_timeout<client>,
-        websocketpp::lib::ref(c),
-        con->get_handle(),
-        timeout
-    ));
-    tthread.detach();
-
-    c.run();
-}
-
-void run_dummy_server(int port) {
-    using boost::asio::ip::tcp;
-
-    try {
-        boost::asio::io_service io_service;
-        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v6(), port));
-        tcp::socket socket(io_service);
-
-        acceptor.accept(socket);
-        for (;;) {
-            char data[512];
-            boost::system::error_code ec;
-            socket.read_some(boost::asio::buffer(data), ec);
-            if (ec == boost::asio::error::eof) {
-                break;
-            } else if (ec) {
-                // other error
-                throw ec;
-            }
-        }
-    } catch (std::exception & e) {
-        std::cout << e.what() << std::endl;
-    } catch (boost::system::error_code & ec) {
-        std::cout << ec.message() << std::endl;
-    }
-}
-
-void run_dummy_client(std::string port) {
-    using boost::asio::ip::tcp;
-
-    try {
-        boost::asio::io_service io_service;
-        tcp::resolver resolver(io_service);
-        tcp::resolver::query query("localhost", port);
-        tcp::resolver::iterator iterator = resolver.resolve(query);
-        tcp::socket socket(io_service);
-
-        boost::asio::connect(socket, iterator);
-        for (;;) {
-            char data[512];
-            boost::system::error_code ec;
-            socket.read_some(boost::asio::buffer(data), ec);
-            if (ec == boost::asio::error::eof) {
-                break;
-            } else if (ec) {
-                // other error
-                throw ec;
-            }
-        }
-    } catch (std::exception & e) {
-        std::cout << e.what() << std::endl;
-    } catch (boost::system::error_code & ec) {
-        std::cout << ec.message() << std::endl;
-    }
-}
-
-bool on_ping(server * s, websocketpp::connection_hdl, std::string) {
-    s->get_alog().write(websocketpp::log::alevel::app,"got ping");
-    return false;
-}
-
-void cancel_on_open(server * s, websocketpp::connection_hdl) {
-    s->stop_listening();
-}
-
-void stop_on_close(server * s, websocketpp::connection_hdl hdl) {
-    server::connection_ptr con = s->get_con_from_hdl(hdl);
-    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
-    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
-    s->stop();
-}
-
-template <typename T>
-void ping_on_open(T * c, std::string payload, websocketpp::connection_hdl hdl) {
-    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
-    websocketpp::lib::error_code ec;
-    con->ping(payload,ec);
-    BOOST_CHECK_EQUAL(ec, websocketpp::lib::error_code());
-}
-
-void fail_on_pong(websocketpp::connection_hdl, std::string) {
-    BOOST_FAIL( "expected no pong handler" );
-}
-
-void fail_on_pong_timeout(websocketpp::connection_hdl, std::string) {
-    BOOST_FAIL( "expected no pong timeout" );
-}
-
-void req_pong(std::string expected_payload, websocketpp::connection_hdl,
-    std::string payload)
-{
-    BOOST_CHECK_EQUAL( expected_payload, payload );
-}
-
-void fail_on_open(websocketpp::connection_hdl) {
-    BOOST_FAIL( "expected no open handler" );
-}
-
-void delay(websocketpp::connection_hdl, long duration) {
-    sleep(duration);
-}
-
-template <typename T>
-void check_ec(T * c, websocketpp::lib::error_code ec,
-    websocketpp::connection_hdl hdl)
-{
-    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
-    BOOST_CHECK_EQUAL( con->get_ec(), ec );
-    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
-    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
-}
-
-template <typename T>
-void check_ec_and_stop(T * e, websocketpp::lib::error_code ec,
-    websocketpp::connection_hdl hdl)
-{
-    typename T::connection_ptr con = e->get_con_from_hdl(hdl);
-    BOOST_CHECK_EQUAL( con->get_ec(), ec );
-    //BOOST_CHECK_EQUAL( con->get_local_close_code(), websocketpp::close::status::normal );
-    //BOOST_CHECK_EQUAL( con->get_remote_close_code(), websocketpp::close::status::normal );
-    e->stop();
-}
-
-template <typename T>
-void req_pong_timeout(T * c, std::string expected_payload,
-    websocketpp::connection_hdl hdl, std::string payload)
-{
-    typename T::connection_ptr con = c->get_con_from_hdl(hdl);
-    BOOST_CHECK_EQUAL( payload, expected_payload );
-    con->close(websocketpp::close::status::normal,"");
-}
-
-template <typename T>
-void close(T * e, websocketpp::connection_hdl hdl) {
-    e->get_con_from_hdl(hdl)->close(websocketpp::close::status::normal,"");
-}
-
-class test_deadline_timer
-{
-public:
-    test_deadline_timer(int seconds)
-    : m_timer(m_io_service, boost::posix_time::seconds(seconds))
-    {
-        m_timer.async_wait(bind(&test_deadline_timer::expired, this, ::_1));
-        std::size_t (boost::asio::io_service::*run)() = &boost::asio::io_service::run;
-        m_timer_thread = websocketpp::lib::thread(websocketpp::lib::bind(run, &m_io_service));
-    }
-    ~test_deadline_timer()
-    {
-        m_timer.cancel();
-        m_timer_thread.join();
-    }
-
-  private:
-    void expired(const boost::system::error_code & ec)
-    {
-        if (ec == boost::asio::error::operation_aborted)
-            return;
-        BOOST_CHECK(!ec);
-        BOOST_FAIL("Test timed out");
-    }
-
-    boost::asio::io_service m_io_service;
-    boost::asio::deadline_timer m_timer;
-    websocketpp::lib::thread m_timer_thread;
-};
-
-BOOST_AUTO_TEST_CASE( pong_no_timeout ) {
-    server s;
-    client c;
-
-    s.set_close_handler(bind(&stop_on_close,&s,::_1));
-
-    // send a ping when the connection is open
-    c.set_open_handler(bind(&ping_on_open<client>,&c,"foo",::_1));
-    // require that a pong with matching payload is received
-    c.set_pong_handler(bind(&req_pong,"foo",::_1,::_2));
-    // require that a pong timeout is NOT received
-    c.set_pong_timeout_handler(bind(&fail_on_pong_timeout,::_1,::_2));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-
-    sleep(1); // give the server thread some time to start
-
-    // Run a client that closes the connection after 1 seconds
-    run_time_limited_client(c, "http://localhost:9005", 1, false);
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( pong_timeout ) {
-    server s;
-    client c;
-
-    s.set_ping_handler(bind(&on_ping, &s,::_1,::_2));
-    s.set_close_handler(bind(&stop_on_close,&s,::_1));
-
-    c.set_fail_handler(bind(&check_ec<client>,&c,
-        websocketpp::lib::error_code(),::_1));
-
-    c.set_pong_handler(bind(&fail_on_pong,::_1,::_2));
-    c.set_open_handler(bind(&ping_on_open<client>,&c,"foo",::_1));
-    c.set_pong_timeout_handler(bind(&req_pong_timeout<client>,&c,"foo",::_1,::_2));
-    c.set_close_handler(bind(&check_ec<client>,&c,
-        websocketpp::lib::error_code(),::_1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-    sleep(1); // give the server thread some time to start
-
-    test_deadline_timer deadline(10);
-
-    run_client(c, "http://localhost:9005",false);
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( client_open_handshake_timeout ) {
-    client c;
-
-    // set open handler to fail test
-    c.set_open_handler(bind(&fail_on_open,::_1));
-    // set fail hander to test for the right fail error code
-    c.set_fail_handler(bind(&check_ec<client>,&c,
-        websocketpp::error::open_handshake_timeout,::_1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_dummy_server,9005));
-    sthread.detach();
-
-    sleep(1); // give the server thread some time to start
-
-    test_deadline_timer deadline(10);
-
-    run_client(c, "http://localhost:9005");
-}
-
-BOOST_AUTO_TEST_CASE( server_open_handshake_timeout ) {
-    server s;
-
-    // set open handler to fail test
-    s.set_open_handler(bind(&fail_on_open,::_1));
-    // set fail hander to test for the right fail error code
-    s.set_fail_handler(bind(&check_ec_and_stop<server>,&s,
-        websocketpp::error::open_handshake_timeout,::_1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-
-    test_deadline_timer deadline(10);
-
-    sleep(1); // give the server thread some time to start
-
-    run_dummy_client("9005");
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( client_self_initiated_close_handshake_timeout ) {
-    server s;
-    client c;
-
-    // on open server sleeps for longer than the timeout
-    // on open client sends close handshake
-    // client handshake timer should be triggered
-    s.set_open_handler(bind(&delay,::_1,1));
-    s.set_close_handler(bind(&stop_on_close,&s,::_1));
-
-    c.set_open_handler(bind(&close<client>,&c,::_1));
-    c.set_close_handler(bind(&check_ec<client>,&c,
-        websocketpp::error::close_handshake_timeout,::_1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-
-    test_deadline_timer deadline(10);
-
-    sleep(1); // give the server thread some time to start
-
-    run_client(c, "http://localhost:9005", false);
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( client_peer_initiated_close_handshake_timeout ) {
-    // on open server sends close
-    // client should ack normally and then wait
-    // server leaves TCP connection open
-    // client handshake timer should be triggered
-
-    // TODO: how to make a mock server that leaves the TCP connection open?
-}
-
-BOOST_AUTO_TEST_CASE( server_self_initiated_close_handshake_timeout ) {
-    server s;
-    client c;
-
-    // on open server sends close
-    // on open client sleeps for longer than the timeout
-    // server handshake timer should be triggered
-
-    s.set_open_handler(bind(&close<server>,&s,::_1));
-    s.set_close_handler(bind(&check_ec_and_stop<server>,&s,
-        websocketpp::error::close_handshake_timeout,::_1));
-
-    c.set_open_handler(bind(&delay,::_1,1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-    test_deadline_timer deadline(10);
-
-    sleep(1); // give the server thread some time to start
-
-    run_client(c, "http://localhost:9005", false);
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( client_runs_out_of_work ) {
-    client c;
-
-    test_deadline_timer deadline(3);
-
-    websocketpp::lib::error_code ec;
-    c.init_asio(ec);
-    BOOST_CHECK(!ec);
-
-    c.run();
-
-    // This test checks that an io_service with no work ends immediately.
-    BOOST_CHECK(true);
-}
-
-
-
-
-BOOST_AUTO_TEST_CASE( client_is_perpetual ) {
-    client c;
-    bool flag = false;
-    websocketpp::lib::mutex mutex;
-
-    websocketpp::lib::error_code ec;
-    c.init_asio(ec);
-    BOOST_CHECK(!ec);
-
-    c.start_perpetual();
-
-    websocketpp::lib::thread cthread(websocketpp::lib::bind(&run_client_and_mark,&c,&flag,&mutex));
-
-    sleep(1);
-
-    {
-        // Checks that the thread hasn't exited yet
-        websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(mutex);
-        BOOST_CHECK( !flag );
-    }
-
-    c.stop_perpetual();
-
-    sleep(1);
-
-    {
-        // Checks that the thread has exited
-        websocketpp::lib::lock_guard<websocketpp::lib::mutex> lock(mutex);
-        BOOST_CHECK( flag );
-    }
-
-    cthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( client_failed_connection ) {
-    client c;
-
-    run_time_limited_client(c,"http://localhost:9005", 5, false);
-}
-
-BOOST_AUTO_TEST_CASE( stop_listening ) {
-    server s;
-    client c;
-
-    // the first connection stops the server from listening
-    s.set_open_handler(bind(&cancel_on_open,&s,::_1));
-
-    // client immediately closes after opening a connection
-    c.set_open_handler(bind(&close<client>,&c,::_1));
-
-    websocketpp::lib::thread sthread(websocketpp::lib::bind(&run_server,&s,9005,false));
-    test_deadline_timer deadline(5);
-
-    sleep(1); // give the server thread some time to start
-
-    run_client(c, "http://localhost:9005", false);
-
-    sthread.join();
-}
-
-BOOST_AUTO_TEST_CASE( pause_reading ) {
-    iostream_server s;
-    std::string handshake = "GET / HTTP/1.1\r\nHost: www.example.com\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n";
-    char buffer[2] = { char(0x81), char(0x80) };
-
-    // suppress output (it needs a place to go to avoid error but we don't care what it is)
-    std::stringstream null_output;
-    s.register_ostream(&null_output);
-
-    iostream_server::connection_ptr con = s.get_connection();
-    con->start();
-
-    // read handshake, should work
-    BOOST_CHECK_EQUAL( con->read_some(handshake.data(), handshake.length()), handshake.length());
-
-    // pause reading and try again. The first read should work, the second should return 0
-    // the first read was queued already after the handshake so it will go through because
-    // reading wasn't paused when it was queued. The byte it reads wont be enough to
-    // complete the frame so another read will be requested. This one wont actually happen
-    // because the connection is paused now.
-    con->pause_reading();
-    BOOST_CHECK_EQUAL( con->read_some(buffer, 1), 1);
-    BOOST_CHECK_EQUAL( con->read_some(buffer+1, 1), 0);
-    // resume reading and try again. Should work this time because the resume should have
-    // re-queued a read.
-    con->resume_reading();
-    BOOST_CHECK_EQUAL( con->read_some(buffer+1, 1), 1);
-}
-
-
-BOOST_AUTO_TEST_CASE( server_connection_cleanup ) {
-    server_tls s;
-}
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-BOOST_AUTO_TEST_CASE( move_construct_transport ) {
-    server s1;
-    
-    server s2(std::move(s1));
-}
-#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/SConscript
deleted file mode 100644
index 9e74c2f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/SConscript
+++ /dev/null
@@ -1,31 +0,0 @@
-## iostream transport unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
-
-objs = env.Object('iostream_base_boost.o', ["base.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('iostream_connection_boost.o', ["connection.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('iostream_endpoint_boost.o', ["endpoint.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_iostream_base_boost', ["iostream_base_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_iostream_connection_boost', ["iostream_connection_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_iostream_endpoint_boost', ["iostream_endpoint_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('iostream_base_stl.o', ["base.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('iostream_connection_stl.o', ["connection.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('iostream_endpoint_stl.o', ["endpoint.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_iostream_base_stl', ["iostream_base_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_iostream_connection_stl', ["iostream_connection_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_iostream_endpoint_stl', ["iostream_endpoint_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/base.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/base.cpp
deleted file mode 100644
index a7eefc2..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/base.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_iostream_base
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-BOOST_AUTO_TEST_CASE( placeholder ) {}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/connection.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/connection.cpp
deleted file mode 100644
index f2aaff9..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/connection.cpp
+++ /dev/null
@@ -1,619 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_iostream_connection
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <cstring>
-#include <string>
-
-#include <websocketpp/common/memory.hpp>
-
-#include <websocketpp/error.hpp>
-#include <websocketpp/transport/iostream/connection.hpp>
-
-// Policies
-#include <websocketpp/concurrency/basic.hpp>
-#include <websocketpp/logger/basic.hpp>
-
-struct config {
-    typedef websocketpp::concurrency::basic concurrency_type;
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::elevel> elog_type;
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::alevel> alog_type;
-};
-
-typedef websocketpp::transport::iostream::connection<config> iostream_con;
-
-using websocketpp::transport::iostream::error::make_error_code;
-
-struct stub_con : public iostream_con {
-    typedef stub_con type;
-    typedef websocketpp::lib::shared_ptr<type> ptr;
-    typedef iostream_con::timer_ptr timer_ptr;
-
-    stub_con(bool is_server, const websocketpp::lib::shared_ptr<config::alog_type>& a, const websocketpp::lib::shared_ptr<config::elog_type>& e)
-        : iostream_con(is_server,a,e)
-        // Set the error to a known code that is unused by the library
-        // This way we can easily confirm that the handler was run at all.
-        , ec(websocketpp::error::make_error_code(websocketpp::error::test))
-        , indef_read_total(0)
-    {}
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return websocketpp::lib::static_pointer_cast<type>(iostream_con::get_shared());
-    }
-
-    void write(std::string msg) {
-        iostream_con::async_write(
-            msg.data(),
-            msg.size(),
-            websocketpp::lib::bind(
-                &stub_con::handle_op,
-                type::get_shared(),
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void write(std::vector<websocketpp::transport::buffer> & bufs) {
-        iostream_con::async_write(
-            bufs,
-            websocketpp::lib::bind(
-                &stub_con::handle_op,
-                type::get_shared(),
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void async_read_at_least(size_t num_bytes, char *buf, size_t len)
-    {
-        iostream_con::async_read_at_least(
-            num_bytes,
-            buf,
-            len,
-            websocketpp::lib::bind(
-                &stub_con::handle_op,
-                type::get_shared(),
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void handle_op(websocketpp::lib::error_code const & e) {
-        ec = e;
-    }
-
-    void async_read_indef(size_t num_bytes, char *buf, size_t len)
-    {
-        indef_read_size = num_bytes;
-        indef_read_buf = buf;
-        indef_read_len = len;
-
-        indef_read();
-    }
-
-    void indef_read() {
-        iostream_con::async_read_at_least(
-            indef_read_size,
-            indef_read_buf,
-            indef_read_len,
-            websocketpp::lib::bind(
-                &stub_con::handle_indef,
-                type::get_shared(),
-                websocketpp::lib::placeholders::_1,
-                websocketpp::lib::placeholders::_2
-            )
-        );
-    }
-
-    void handle_indef(websocketpp::lib::error_code const & e, size_t amt_read) {
-        ec = e;
-        indef_read_total += amt_read;
-
-        indef_read();
-    }
-
-    void shutdown() {
-        iostream_con::async_shutdown(
-            websocketpp::lib::bind(
-                &stub_con::handle_async_shutdown,
-                type::get_shared(),
-                websocketpp::lib::placeholders::_1
-            )
-        );
-    }
-
-    void handle_async_shutdown(websocketpp::lib::error_code const & e) {
-        ec = e;
-    }
-
-    websocketpp::lib::error_code ec;
-    size_t indef_read_size;
-    char * indef_read_buf;
-    size_t indef_read_len;
-    size_t indef_read_total;
-};
-
-// Stubs
-websocketpp::lib::shared_ptr<config::alog_type> alogger = websocketpp::lib::make_shared<config::alog_type>();
-websocketpp::lib::shared_ptr<config::elog_type> elogger = websocketpp::lib::make_shared<config::elog_type>();
-
-BOOST_AUTO_TEST_CASE( const_methods ) {
-    iostream_con::ptr con(new iostream_con(true,alogger,elogger));
-
-    BOOST_CHECK( !con->is_secure() );
-    BOOST_CHECK_EQUAL( con->get_remote_endpoint(), "iostream transport" );
-}
-
-BOOST_AUTO_TEST_CASE( write_before_output_method_set ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    con->write("foo");
-    BOOST_CHECK( con->ec == make_error_code(websocketpp::transport::iostream::error::output_stream_required) );
-
-    std::vector<websocketpp::transport::buffer> bufs;
-    con->write(bufs);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::iostream::error::output_stream_required) );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_ostream ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    std::stringstream output;
-
-    con->register_ostream(&output);
-
-    con->write("foo");
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output.str(), "foo" );
-}
-
-websocketpp::lib::error_code write_handler(std::string & o, websocketpp::connection_hdl, char const * buf, size_t len) {
-    o += std::string(buf,len);
-    return websocketpp::lib::error_code();
-}
-
-websocketpp::lib::error_code vector_write_handler(std::string & o, websocketpp::connection_hdl, std::vector<websocketpp::transport::buffer> const & bufs) {
-    std::vector<websocketpp::transport::buffer>::const_iterator it;
-    for (it = bufs.begin(); it != bufs.end(); it++) {
-        o += std::string((*it).buf, (*it).len);
-    }
-
-    return websocketpp::lib::error_code();
-}
-
-websocketpp::lib::error_code write_handler_error(websocketpp::connection_hdl, char const *, size_t) {
-    return make_error_code(websocketpp::transport::error::general);
-}
-
-BOOST_AUTO_TEST_CASE( async_write_handler ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    std::string output;
-
-    con->set_write_handler(websocketpp::lib::bind(
-        &write_handler,
-        websocketpp::lib::ref(output),
-        websocketpp::lib::placeholders::_1,
-        websocketpp::lib::placeholders::_2,
-        websocketpp::lib::placeholders::_3
-    ));
-    con->write("foo");
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL(output, "foo");
-}
-
-BOOST_AUTO_TEST_CASE( async_write_handler_error ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    con->set_write_handler(&write_handler_error);
-    con->write("foo");
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::general) );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_0_ostream ) {
-    std::stringstream output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->register_ostream(&output);
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output.str(), "" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_0_write_handler ) {
-    std::string output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    con->set_write_handler(websocketpp::lib::bind(
-        &write_handler,
-        websocketpp::lib::ref(output),
-        websocketpp::lib::placeholders::_1,
-        websocketpp::lib::placeholders::_2,
-        websocketpp::lib::placeholders::_3
-    ));
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output, "" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_1_ostream ) {
-    std::stringstream output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->register_ostream(&output);
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    std::string foo = "foo";
-
-    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output.str(), "foo" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_1_write_handler ) {
-    std::string output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->set_write_handler(websocketpp::lib::bind(
-        &write_handler,
-        websocketpp::lib::ref(output),
-        websocketpp::lib::placeholders::_1,
-        websocketpp::lib::placeholders::_2,
-        websocketpp::lib::placeholders::_3
-    ));
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    std::string foo = "foo";
-
-    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output, "foo" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_2_ostream ) {
-    std::stringstream output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->register_ostream(&output);
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    std::string foo = "foo";
-    std::string bar = "bar";
-
-    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
-    bufs.push_back(websocketpp::transport::buffer(bar.data(),bar.size()));
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output.str(), "foobar" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_2_write_handler ) {
-    std::string output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->set_write_handler(websocketpp::lib::bind(
-        &write_handler,
-        websocketpp::lib::ref(output),
-        websocketpp::lib::placeholders::_1,
-        websocketpp::lib::placeholders::_2,
-        websocketpp::lib::placeholders::_3
-    ));
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    std::string foo = "foo";
-    std::string bar = "bar";
-
-    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
-    bufs.push_back(websocketpp::transport::buffer(bar.data(),bar.size()));
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output, "foobar" );
-}
-
-BOOST_AUTO_TEST_CASE( async_write_vector_2_vector_write_handler ) {
-    std::string output;
-
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    con->set_vector_write_handler(websocketpp::lib::bind(
-        &vector_write_handler,
-        websocketpp::lib::ref(output),
-        websocketpp::lib::placeholders::_1,
-        websocketpp::lib::placeholders::_2
-    ));
-
-    std::vector<websocketpp::transport::buffer> bufs;
-
-    std::string foo = "foo";
-    std::string bar = "bar";
-
-    bufs.push_back(websocketpp::transport::buffer(foo.data(),foo.size()));
-    bufs.push_back(websocketpp::transport::buffer(bar.data(),bar.size()));
-
-    con->write(bufs);
-
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( output, "foobar" );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least_too_much ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[10];
-
-    con->async_read_at_least(11,buf,10);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::iostream::error::invalid_num_bytes) );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least_double_read ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[10];
-
-    con->async_read_at_least(5,buf,10);
-    con->async_read_at_least(5,buf,10);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::iostream::error::double_read) );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[10];
-
-    memset(buf,'x',10);
-
-    con->async_read_at_least(5,buf,10);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    std::stringstream channel;
-    channel << "abcd";
-    channel >> *con;
-    BOOST_CHECK_EQUAL( channel.tellg(), -1 );
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    std::stringstream channel2;
-    channel2 << "e";
-    channel2 >> *con;
-    BOOST_CHECK_EQUAL( channel2.tellg(), -1 );
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
-
-    std::stringstream channel3;
-    channel3 << "f";
-    channel3 >> *con;
-    BOOST_CHECK_EQUAL( channel3.tellg(), 0 );
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
-    con->async_read_at_least(1,buf+5,5);
-    channel3 >> *con;
-    BOOST_CHECK_EQUAL( channel3.tellg(), -1 );
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdefxxxx" );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least2 ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[10];
-
-    memset(buf,'x',10);
-
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    std::stringstream channel;
-    channel << "abcdefg";
-    channel >> *con;
-    BOOST_CHECK_EQUAL( channel.tellg(), 5 );
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
-
-    con->async_read_at_least(1,buf+5,5);
-    channel >> *con;
-    BOOST_CHECK_EQUAL( channel.tellg(), -1 );
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdefgxxx" );
-}
-
-void timer_callback_stub(websocketpp::lib::error_code const &) {}
-
-BOOST_AUTO_TEST_CASE( set_timer ) {
-   stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    stub_con::timer_ptr tp = con->set_timer(1000,timer_callback_stub);
-
-    BOOST_CHECK( !tp );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least_read_some ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[10];
-    memset(buf,'x',10);
-
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    char input[10] = "abcdefg";
-    BOOST_CHECK_EQUAL(con->read_some(input,5), 5);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
-
-    BOOST_CHECK_EQUAL(con->read_some(input+5,2), 0);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdexxxxx" );
-
-    con->async_read_at_least(1,buf+5,5);
-    BOOST_CHECK_EQUAL(con->read_some(input+5,2), 2);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "abcdefgxxx" );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least_read_some_indef ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[20];
-    memset(buf,'x',20);
-
-    con->async_read_indef(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    // here we expect to return early from read some because the outstanding
-    // read was for 5 bytes and we were called with 10.
-    char input[11] = "aaaaabbbbb";
-    BOOST_CHECK_EQUAL(con->read_some(input,10), 5);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "aaaaaxxxxx" );
-    BOOST_CHECK_EQUAL( con->indef_read_total, 5 );
-
-    // A subsequent read should read 5 more because the indef read refreshes
-    // itself. The new read will start again at the beginning of the buffer.
-    BOOST_CHECK_EQUAL(con->read_some(input+5,5), 5);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
-    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
-}
-
-BOOST_AUTO_TEST_CASE( async_read_at_least_read_all ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    char buf[20];
-    memset(buf,'x',20);
-
-    con->async_read_indef(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-
-    char input[11] = "aaaaabbbbb";
-    BOOST_CHECK_EQUAL(con->read_all(input,10), 10);
-    BOOST_CHECK( !con->ec );
-    BOOST_CHECK_EQUAL( std::string(buf,10), "bbbbbxxxxx" );
-    BOOST_CHECK_EQUAL( con->indef_read_total, 10 );
-}
-
-BOOST_AUTO_TEST_CASE( eof_flag ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    char buf[10];
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    con->eof();
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::eof) );
-}
-
-BOOST_AUTO_TEST_CASE( fatal_error_flag ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    char buf[10];
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    con->fatal_error();
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::pass_through) );
-}
-
-BOOST_AUTO_TEST_CASE( shutdown ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    con->shutdown();
-    BOOST_CHECK_EQUAL( con->ec, websocketpp::lib::error_code() );
-}
-
-websocketpp::lib::error_code sd_handler(websocketpp::connection_hdl) {
-    return make_error_code(websocketpp::transport::error::general);
-}
-
-BOOST_AUTO_TEST_CASE( shutdown_handler ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    con->set_shutdown_handler(&sd_handler);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    con->shutdown();
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::general) );
-}
-
-BOOST_AUTO_TEST_CASE( clear_handler ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    con->set_shutdown_handler(&sd_handler);
-    con->set_shutdown_handler(NULL);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    con->shutdown();
-    BOOST_CHECK_EQUAL( con->ec, websocketpp::lib::error_code() );
-}
-
-BOOST_AUTO_TEST_CASE( shared_pointer_memory_cleanup ) {
-    stub_con::ptr con(new stub_con(true,alogger,elogger));
-
-    BOOST_CHECK_EQUAL(con.use_count(), 1);
-
-    char buf[10];
-    memset(buf,'x',10);
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::error::test) );
-    BOOST_CHECK_EQUAL(con.use_count(), 2);
-
-    char input[10] = "foo";
-    con->read_some(input,3);
-    BOOST_CHECK_EQUAL(con.use_count(), 2);
-
-    con->read_some(input,2);
-    BOOST_CHECK_EQUAL( std::string(buf,10), "foofoxxxxx" );
-    BOOST_CHECK_EQUAL(con.use_count(), 1);
-
-    con->async_read_at_least(5,buf,5);
-    BOOST_CHECK_EQUAL(con.use_count(), 2);
-
-    con->eof();
-    BOOST_CHECK_EQUAL( con->ec, make_error_code(websocketpp::transport::error::eof) );
-    BOOST_CHECK_EQUAL(con.use_count(), 1);
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/endpoint.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/endpoint.cpp
deleted file mode 100644
index ded9967..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/transport/iostream/endpoint.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE transport_iostream_endpoint
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-
-#include <websocketpp/transport/iostream/endpoint.hpp>
-
-BOOST_AUTO_TEST_CASE( placeholder ) {}
-
-/*BOOST_AUTO_TEST_CASE( blank_error ) {
-    websocketpp::lib::error_code ec;
-
-    BOOST_CHECK( !ec );
-}*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/CMakeLists.txt
deleted file mode 100644
index 3903f13..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/CMakeLists.txt
+++ /dev/null
@@ -1,53 +0,0 @@
-# Test close utilities
-file (GLOB SOURCE close.cpp)
-
-init_target (test_close)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test error utilities
-file (GLOB SOURCE error.cpp)
-
-init_target (test_error)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test frame utilities
-file (GLOB SOURCE frame.cpp)
-
-init_target (test_frame)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test sha1 utilities
-file (GLOB SOURCE sha1.cpp)
-
-init_target (test_sha1)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test uri utilities
-file (GLOB SOURCE uri.cpp)
-
-init_target (test_uri)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
-
-# Test misc utilities
-file (GLOB SOURCE utilities.cpp)
-
-init_target (test_utilities)
-build_test (${TARGET_NAME} ${SOURCE})
-link_boost ()
-final_target ()
-set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "test")
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/SConscript b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/SConscript
deleted file mode 100644
index 80e9ef6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/SConscript
+++ /dev/null
@@ -1,40 +0,0 @@
-## utility unit tests
-##
-
-Import('env')
-Import('env_cpp11')
-Import('boostlibs')
-Import('platform_libs')
-Import('polyfill_libs')
-
-env = env.Clone ()
-env_cpp11 = env_cpp11.Clone ()
-
-BOOST_LIBS = boostlibs(['unit_test_framework','system'],env) + [platform_libs]
-
-objs = env.Object('uri_boost.o', ["uri.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('utilities_boost.o', ["utilities.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('close_boost.o', ["close.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('sha1_boost.o', ["sha1.cpp"], LIBS = BOOST_LIBS)
-objs += env.Object('error_boost.o', ["error.cpp"], LIBS = BOOST_LIBS)
-prgs = env.Program('test_uri_boost', ["uri_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_utility_boost', ["utilities_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_frame', ["frame.cpp"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_close_boost', ["close_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_sha1_boost', ["sha1_boost.o"], LIBS = BOOST_LIBS)
-prgs += env.Program('test_error_boost', ["error_boost.o"], LIBS = BOOST_LIBS)
-
-if env_cpp11.has_key('WSPP_CPP11_ENABLED'):
-   BOOST_LIBS_CPP11 = boostlibs(['unit_test_framework'],env_cpp11) + [platform_libs] + [polyfill_libs]
-   objs += env_cpp11.Object('utilities_stl.o', ["utilities.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('uri_stl.o', ["uri.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('close_stl.o', ["close.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('sha1_stl.o', ["sha1.cpp"], LIBS = BOOST_LIBS_CPP11)
-   objs += env_cpp11.Object('error_stl.o', ["error.cpp"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_utility_stl', ["utilities_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_uri_stl', ["uri_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_close_stl', ["close_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_sha1_stl', ["sha1_stl.o"], LIBS = BOOST_LIBS_CPP11)
-   prgs += env_cpp11.Program('test_error_stl', ["error_stl.o"], LIBS = BOOST_LIBS_CPP11)
-
-Return('prgs')
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/close.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/close.cpp
deleted file mode 100644
index 50f9f78..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/close.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE close
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/close.hpp>
-#include <websocketpp/utilities.hpp>
-
-using namespace websocketpp;
-
-BOOST_AUTO_TEST_CASE( reserved_values ) {
-    BOOST_CHECK( !close::status::reserved(999) );
-    BOOST_CHECK( close::status::reserved(1004) );
-    BOOST_CHECK( close::status::reserved(1016) );
-    BOOST_CHECK( close::status::reserved(2999) );
-    BOOST_CHECK( !close::status::reserved(1000) );
-}
-
-BOOST_AUTO_TEST_CASE( invalid_values ) {
-    BOOST_CHECK( close::status::invalid(0) );
-    BOOST_CHECK( close::status::invalid(999) );
-    BOOST_CHECK( !close::status::invalid(1000) );
-    BOOST_CHECK( close::status::invalid(1005) );
-    BOOST_CHECK( close::status::invalid(1006) );
-    BOOST_CHECK( close::status::invalid(1015) );
-    BOOST_CHECK( !close::status::invalid(2999) );
-    BOOST_CHECK( !close::status::invalid(3000) );
-    BOOST_CHECK( close::status::invalid(5000) );
-}
-
-BOOST_AUTO_TEST_CASE( value_extraction ) {
-    lib::error_code ec;
-    std::string payload = "oo";
-
-    // Value = 1000
-    payload[0] = 0x03;
-    payload[1] = char(0xe8);
-    BOOST_CHECK( close::extract_code(payload,ec) == close::status::normal );
-    BOOST_CHECK( !ec );
-
-    // Value = 1004
-    payload[0] = 0x03;
-    payload[1] = char(0xec);
-    BOOST_CHECK( close::extract_code(payload,ec) == 1004 );
-    BOOST_CHECK( ec == error::reserved_close_code );
-
-    // Value = 1005
-    payload[0] = 0x03;
-    payload[1] = char(0xed);
-    BOOST_CHECK( close::extract_code(payload,ec) == close::status::no_status );
-    BOOST_CHECK( ec == error::invalid_close_code );
-
-    // Value = 3000
-    payload[0] = 0x0b;
-    payload[1] = char(0xb8);
-    BOOST_CHECK( close::extract_code(payload,ec) == 3000 );
-    BOOST_CHECK( !ec );
-}
-
-BOOST_AUTO_TEST_CASE( extract_empty ) {
-    lib::error_code ec;
-    std::string payload;
-
-    BOOST_CHECK( close::extract_code(payload,ec) == close::status::no_status );
-    BOOST_CHECK( !ec );
-}
-
-BOOST_AUTO_TEST_CASE( extract_short ) {
-    lib::error_code ec;
-    std::string payload = "0";
-
-    BOOST_CHECK( close::extract_code(payload,ec) == close::status::protocol_error );
-    BOOST_CHECK( ec == error::bad_close_code );
-}
-
-BOOST_AUTO_TEST_CASE( extract_reason ) {
-    lib::error_code ec;
-    std::string payload = "00Foo";
-
-    BOOST_CHECK( close::extract_reason(payload,ec) == "Foo" );
-    BOOST_CHECK( !ec );
-
-    payload.clear();
-    BOOST_CHECK( close::extract_reason(payload,ec).empty() );
-    BOOST_CHECK( !ec );
-
-    payload = "00";
-    BOOST_CHECK( close::extract_reason(payload,ec).empty() );
-    BOOST_CHECK( !ec );
-
-    payload = "000";
-    payload[2] = char(0xFF);
-
-    close::extract_reason(payload,ec);
-    BOOST_CHECK( ec == error::invalid_utf8 );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/error.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/error.cpp
deleted file mode 100644
index 1379a95..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/error.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE error
-#include <boost/test/unit_test.hpp>
-
-#include <websocketpp/error.hpp>
-
-BOOST_AUTO_TEST_CASE( constructing_exceptions ) {
-    websocketpp::lib::error_code test_ec = websocketpp::error::make_error_code(websocketpp::error::test);
-    websocketpp::lib::error_code general_ec = websocketpp::error::make_error_code(websocketpp::error::general);
-
-    websocketpp::exception b("foo");
-    websocketpp::exception c("foo",test_ec);
-    websocketpp::exception d("");
-    websocketpp::exception e("",test_ec);
-
-    BOOST_CHECK_EQUAL(b.what(),"foo");
-    BOOST_CHECK_EQUAL(b.code(),general_ec);
-
-    BOOST_CHECK_EQUAL(c.what(),"foo");
-    BOOST_CHECK_EQUAL(c.code(),test_ec);
-
-    BOOST_CHECK_EQUAL(d.what(),"Generic error");
-    BOOST_CHECK_EQUAL(d.code(),general_ec);
-
-    BOOST_CHECK_EQUAL(e.what(),"Test Error");
-    BOOST_CHECK_EQUAL(e.code(),test_ec);
-}
-
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/frame.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/frame.cpp
deleted file mode 100644
index 879c2ef..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/frame.cpp
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE frame
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/frame.hpp>
-#include <websocketpp/utilities.hpp>
-
-using namespace websocketpp;
-
-BOOST_AUTO_TEST_CASE( basic_bits ) {
-    frame::basic_header h1(0x00,0x00); // all false
-    frame::basic_header h2(0xF0,0x80); // all true
-
-    // Read Values
-    BOOST_CHECK( frame::get_fin(h1) == false );
-    BOOST_CHECK( frame::get_rsv1(h1) == false );
-    BOOST_CHECK( frame::get_rsv2(h1) == false );
-    BOOST_CHECK( frame::get_rsv3(h1) == false );
-    BOOST_CHECK( frame::get_masked(h1) == false );
-
-    BOOST_CHECK( frame::get_fin(h2) == true );
-    BOOST_CHECK( frame::get_rsv1(h2) == true );
-    BOOST_CHECK( frame::get_rsv2(h2) == true );
-    BOOST_CHECK( frame::get_rsv3(h2) == true );
-    BOOST_CHECK( frame::get_masked(h2) == true );
-
-    // Set Values
-    frame::set_fin(h1,true);
-    BOOST_CHECK( h1.b0 == 0x80 );
-
-    frame::set_rsv1(h1,true);
-    BOOST_CHECK( h1.b0 == 0xC0 );
-
-    frame::set_rsv2(h1,true);
-    BOOST_CHECK( h1.b0 == 0xE0 );
-
-    frame::set_rsv3(h1,true);
-    BOOST_CHECK( h1.b0 == 0xF0 );
-
-    frame::set_masked(h1,true);
-    BOOST_CHECK( h1.b1 == 0x80 );
-}
-
-BOOST_AUTO_TEST_CASE( basic_constructors ) {
-    // Read Values
-    frame::basic_header h1(frame::opcode::TEXT,12,true,false);
-    BOOST_CHECK( frame::get_opcode(h1) == frame::opcode::TEXT );
-    BOOST_CHECK( frame::get_basic_size(h1) == 12 );
-    BOOST_CHECK( frame::get_fin(h1) == true );
-    BOOST_CHECK( frame::get_rsv1(h1) == false );
-    BOOST_CHECK( frame::get_rsv2(h1) == false );
-    BOOST_CHECK( frame::get_rsv3(h1) == false );
-    BOOST_CHECK( frame::get_masked(h1) == false );
-
-    frame::basic_header h2(frame::opcode::BINARY,0,false,false,false,true);
-    BOOST_CHECK( frame::get_opcode(h2) == frame::opcode::BINARY );
-    BOOST_CHECK( frame::get_basic_size(h2) == 0 );
-    BOOST_CHECK( frame::get_fin(h2) == false );
-    BOOST_CHECK( frame::get_rsv1(h2) == false );
-    BOOST_CHECK( frame::get_rsv2(h2) == true );
-    BOOST_CHECK( frame::get_rsv3(h2) == false );
-    BOOST_CHECK( frame::get_masked(h2) == false );
-}
-
-BOOST_AUTO_TEST_CASE( basic_size ) {
-    frame::basic_header h1(0x00,0x00); // length 0
-    frame::basic_header h2(0x00,0x01); // length 1
-    frame::basic_header h3(0x00,0x7D); // length 125
-    frame::basic_header h4(0x00,0x7E); // length 126
-    frame::basic_header h5(0x00,0x7F); // length 127
-    frame::basic_header h6(0x00,0x80); // length 0, mask bit set
-
-    BOOST_CHECK( frame::get_basic_size(h1) == 0 );
-    BOOST_CHECK( frame::get_basic_size(h2) == 1 );
-    BOOST_CHECK( frame::get_basic_size(h3) == 125 );
-    BOOST_CHECK( frame::get_basic_size(h4) == 126 );
-    BOOST_CHECK( frame::get_basic_size(h5) == 127 );
-    BOOST_CHECK( frame::get_basic_size(h6) == 0 );
-
-    /*frame::set_basic_size(h1,1);
-    BOOST_CHECK( h1.b1 == 0x01 );
-
-    frame::set_basic_size(h1,125);
-    BOOST_CHECK( h1.b1 == 0x7D );
-
-    frame::set_basic_size(h1,126);
-    BOOST_CHECK( h1.b1 == 0x7E );
-
-    frame::set_basic_size(h1,127);
-    BOOST_CHECK( h1.b1 == 0x7F );
-
-    frame::set_basic_size(h1,0);
-    BOOST_CHECK( h1.b1 == 0x00 );*/
-}
-
-BOOST_AUTO_TEST_CASE( basic_header_length ) {
-    frame::basic_header h1(0x82,0x00); // short binary frame, unmasked
-    frame::basic_header h2(0x82,0x80); // short binary frame, masked
-    frame::basic_header h3(0x82,0x7E); // medium binary frame, unmasked
-    frame::basic_header h4(0x82,0xFE); // medium binary frame, masked
-    frame::basic_header h5(0x82,0x7F); // jumbo binary frame, unmasked
-    frame::basic_header h6(0x82,0xFF); // jumbo binary frame, masked
-
-    BOOST_CHECK( frame::get_header_len(h1) == 2);
-    BOOST_CHECK( frame::get_header_len(h2) == 6);
-    BOOST_CHECK( frame::get_header_len(h3) == 4);
-    BOOST_CHECK( frame::get_header_len(h4) == 8);
-    BOOST_CHECK( frame::get_header_len(h5) == 10);
-    BOOST_CHECK( frame::get_header_len(h6) == 14);
-}
-
-BOOST_AUTO_TEST_CASE( basic_opcode ) {
-    frame::basic_header h1(0x00,0x00);
-
-    BOOST_CHECK( is_control(frame::opcode::CONTINUATION) == false);
-    BOOST_CHECK( is_control(frame::opcode::TEXT) == false);
-    BOOST_CHECK( is_control(frame::opcode::BINARY) == false);
-    BOOST_CHECK( is_control(frame::opcode::CLOSE) == true);
-    BOOST_CHECK( is_control(frame::opcode::PING) == true);
-    BOOST_CHECK( is_control(frame::opcode::PONG) == true);
-
-    BOOST_CHECK( frame::get_opcode(h1) == frame::opcode::CONTINUATION );
-}
-
-BOOST_AUTO_TEST_CASE( extended_header_basics ) {
-    frame::extended_header h1;
-    uint8_t h1_solution[12] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-    frame::extended_header h2(uint16_t(255));
-    uint8_t h2_solution[12] = {0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
-                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-    frame::extended_header h3(uint16_t(256),htonl(0x8040201));
-    uint8_t h3_solution[12] = {0x01, 0x00, 0x08, 0x04, 0x02, 0x01,
-                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-    frame::extended_header h4(uint64_t(0x0807060504030201LL));
-    uint8_t h4_solution[12] = {0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
-                               0x02, 0x01, 0x00, 0x00, 0x00, 0x00};
-
-    frame::extended_header h5(uint64_t(0x0807060504030201LL),htonl(0x8040201));
-    uint8_t h5_solution[12] = {0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
-                               0x02, 0x01, 0x08, 0x04, 0x02, 0x01};
-
-    BOOST_CHECK( std::equal(h1_solution,h1_solution+12,h1.bytes) );
-    BOOST_CHECK( std::equal(h2_solution,h2_solution+12,h2.bytes) );
-    BOOST_CHECK( std::equal(h3_solution,h3_solution+12,h3.bytes) );
-    BOOST_CHECK( std::equal(h4_solution,h4_solution+12,h4.bytes) );
-    BOOST_CHECK( std::equal(h5_solution,h5_solution+12,h5.bytes) );
-}
-
-BOOST_AUTO_TEST_CASE( extended_header_extractors ) {
-    frame::basic_header h1(0x00,0x7E);
-    frame::extended_header e1(uint16_t(255));
-    BOOST_CHECK( get_extended_size(e1) == 255 );
-    BOOST_CHECK( get_payload_size(h1,e1) == 255 );
-    BOOST_CHECK( get_masking_key_offset(h1) == 2 );
-    BOOST_CHECK( get_masking_key(h1,e1).i == 0 );
-
-    frame::basic_header h2(0x00,0x7F);
-    frame::extended_header e2(uint64_t(0x0807060504030201LL));
-    BOOST_CHECK( get_jumbo_size(e2) == 0x0807060504030201LL );
-    BOOST_CHECK( get_payload_size(h2,e2) == 0x0807060504030201LL );
-    BOOST_CHECK( get_masking_key_offset(h2) == 8 );
-    BOOST_CHECK( get_masking_key(h2,e2).i == 0 );
-
-    frame::basic_header h3(0x00,0xFE);
-    frame::extended_header e3(uint16_t(255),0x08040201);
-    BOOST_CHECK( get_extended_size(e3) == 255 );
-    BOOST_CHECK( get_payload_size(h3,e3) == 255 );
-    BOOST_CHECK( get_masking_key_offset(h3) == 2 );
-    BOOST_CHECK( get_masking_key(h3,e3).i == 0x08040201 );
-
-    frame::basic_header h4(0x00,0xFF);
-    frame::extended_header e4(uint64_t(0x0807060504030201LL),0x08040201);
-    BOOST_CHECK( get_jumbo_size(e4) == 0x0807060504030201LL );
-    BOOST_CHECK( get_payload_size(h4,e4) == 0x0807060504030201LL );
-    BOOST_CHECK( get_masking_key_offset(h4) == 8 );
-    BOOST_CHECK( get_masking_key(h4,e4).i == 0x08040201 );
-
-    frame::basic_header h5(0x00,0x7D);
-    frame::extended_header e5;
-    BOOST_CHECK( get_payload_size(h5,e5) == 125 );
-}
-
-BOOST_AUTO_TEST_CASE( header_preparation ) {
-    frame::basic_header h1(0x81,0xFF); //
-    frame::extended_header e1(uint64_t(0xFFFFFLL),htonl(0xD5FB70EE));
-    std::string p1 = prepare_header(h1, e1);
-    uint8_t s1[14] = {0x81, 0xFF,
-                     0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF,
-                     0xD5, 0xFB, 0x70, 0xEE};
-
-    BOOST_CHECK( p1.size() == 14);
-    BOOST_CHECK( std::equal(p1.begin(),p1.end(),reinterpret_cast<char*>(s1)) );
-
-    frame::basic_header h2(0x81,0x7E); //
-    frame::extended_header e2(uint16_t(255));
-    std::string p2 = prepare_header(h2, e2);
-    uint8_t s2[4] = {0x81, 0x7E, 0x00, 0xFF};
-
-    BOOST_CHECK( p2.size() == 4);
-    BOOST_CHECK( std::equal(p2.begin(),p2.end(),reinterpret_cast<char*>(s2)) );
-}
-
-BOOST_AUTO_TEST_CASE( prepare_masking_key ) {
-    frame::masking_key_type key;
-
-    key.i = htonl(0x12345678);
-
-    if (sizeof(size_t) == 8) {
-        BOOST_CHECK(
-            frame::prepare_masking_key(key) == lib::net::_htonll(0x1234567812345678LL)
-        );
-    } else {
-        BOOST_CHECK( frame::prepare_masking_key(key) == htonl(0x12345678) );
-    }
-}
-
-BOOST_AUTO_TEST_CASE( prepare_masking_key2 ) {
-    frame::masking_key_type key;
-
-    key.i = htonl(0xD5FB70EE);
-
-    // One call
-    if (sizeof(size_t) == 8) {
-        BOOST_CHECK(
-            frame::prepare_masking_key(key) == lib::net::_htonll(0xD5FB70EED5FB70EELL)
-        );
-    } else {
-        BOOST_CHECK( frame::prepare_masking_key(key) == htonl(0xD5FB70EE) );
-    }
-}
-
-// TODO: figure out a way to run/test both 4 and 8 byte versions.
-BOOST_AUTO_TEST_CASE( circshift ) {
-    /*if (sizeof(size_t) == 8) {
-        size_t test = 0x0123456789abcdef;
-
-        BOOST_CHECK( frame::circshift_prepared_key(test,0) == 0x0123456789abcdef);
-        BOOST_CHECK( frame::circshift_prepared_key(test,1) == 0xef0123456789abcd);
-        BOOST_CHECK( frame::circshift_prepared_key(test,2) == 0xcdef0123456789ab);
-        BOOST_CHECK( frame::circshift_prepared_key(test,3) == 0xabcdef0123456789);
-    } else {
-        size_t test = 0x01234567;
-
-        BOOST_CHECK( frame::circshift_prepared_key(test,0) == 0x01234567);
-        BOOST_CHECK( frame::circshift_prepared_key(test,1) == 0x67012345);
-        BOOST_CHECK( frame::circshift_prepared_key(test,2) == 0x45670123);
-        BOOST_CHECK( frame::circshift_prepared_key(test,3) == 0x23456701);
-    }*/
-}
-
-BOOST_AUTO_TEST_CASE( block_byte_mask ) {
-    uint8_t input[15] = {0x00, 0x00, 0x00, 0x00,
-                         0x00, 0x00, 0x00, 0x00,
-                         0x00, 0x00, 0x00, 0x00,
-                         0x00, 0x00, 0x00};
-
-    uint8_t output[15];
-
-    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    byte_mask(input,input+15,output,key);
-
-    BOOST_CHECK( std::equal(output,output+15,masked) );
-}
-
-BOOST_AUTO_TEST_CASE( block_byte_mask_inplace ) {
-    uint8_t buffer[15] = {0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00};
-
-    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    byte_mask(buffer,buffer+15,key);
-
-    BOOST_CHECK( std::equal(buffer,buffer+15,masked) );
-}
-
-BOOST_AUTO_TEST_CASE( block_word_mask ) {
-    uint8_t input[15] =  {0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00};
-
-    uint8_t output[15];
-
-    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    word_mask_exact(input,output,15,key);
-
-    BOOST_CHECK( std::equal(output,output+15,masked) );
-}
-
-BOOST_AUTO_TEST_CASE( block_word_mask_inplace ) {
-    uint8_t buffer[15] = {0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00, 0x00,
-                          0x00, 0x00, 0x00};
-
-    uint8_t masked[15] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    word_mask_exact(buffer,15,key);
-
-    BOOST_CHECK( std::equal(buffer,buffer+15,masked) );
-}
-
-BOOST_AUTO_TEST_CASE( continuous_word_mask ) {
-    uint8_t input[16];
-    uint8_t output[16];
-
-    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x00};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    // One call
-    size_t pkey,pkey_temp;
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(input,16,0x00);
-    std::fill_n(output,16,0x00);
-    frame::word_mask_circ(input,output,15,pkey);
-    BOOST_CHECK( std::equal(output,output+16,masked) );
-
-    // calls not split on word boundaries
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(input,16,0x00);
-    std::fill_n(output,16,0x00);
-
-    pkey_temp = frame::word_mask_circ(input,output,7,pkey);
-    BOOST_CHECK( std::equal(output,output+7,masked) );
-    BOOST_CHECK( pkey_temp == frame::circshift_prepared_key(pkey,3) );
-
-    pkey_temp = frame::word_mask_circ(input+7,output+7,8,pkey_temp);
-    BOOST_CHECK( std::equal(output,output+16,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-}
-
-BOOST_AUTO_TEST_CASE( continuous_byte_mask ) {
-    uint8_t input[16];
-    uint8_t output[16];
-
-    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x00};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    // One call
-    size_t pkey,pkey_temp;
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(input,16,0x00);
-    std::fill_n(output,16,0x00);
-    frame::byte_mask_circ(input,output,15,pkey);
-    BOOST_CHECK( std::equal(output,output+16,masked) );
-
-    // calls not split on word boundaries
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(input,16,0x00);
-    std::fill_n(output,16,0x00);
-
-    pkey_temp = frame::byte_mask_circ(input,output,7,pkey);
-    BOOST_CHECK( std::equal(output,output+7,masked) );
-    BOOST_CHECK( pkey_temp == frame::circshift_prepared_key(pkey,3) );
-
-    pkey_temp = frame::byte_mask_circ(input+7,output+7,8,pkey_temp);
-    BOOST_CHECK( std::equal(output,output+16,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-}
-
-BOOST_AUTO_TEST_CASE( continuous_word_mask_inplace ) {
-    uint8_t buffer[16];
-
-    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x00};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    // One call
-    size_t pkey,pkey_temp;
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(buffer,16,0x00);
-    frame::word_mask_circ(buffer,15,pkey);
-    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
-
-    // calls not split on word boundaries
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(buffer,16,0x00);
-
-    pkey_temp = frame::word_mask_circ(buffer,7,pkey);
-    BOOST_CHECK( std::equal(buffer,buffer+7,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-
-    pkey_temp = frame::word_mask_circ(buffer+7,8,pkey_temp);
-    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-}
-
-BOOST_AUTO_TEST_CASE( continuous_byte_mask_inplace ) {
-    uint8_t buffer[16];
-
-    uint8_t masked[16] = {0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x03,
-                          0x00, 0x01, 0x02, 0x00};
-
-    frame::masking_key_type key;
-    key.c[0] = 0x00;
-    key.c[1] = 0x01;
-    key.c[2] = 0x02;
-    key.c[3] = 0x03;
-
-    // One call
-    size_t pkey,pkey_temp;
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(buffer,16,0x00);
-    frame::byte_mask_circ(buffer,15,pkey);
-    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
-
-    // calls not split on word boundaries
-    pkey = frame::prepare_masking_key(key);
-    std::fill_n(buffer,16,0x00);
-
-    pkey_temp = frame::byte_mask_circ(buffer,7,pkey);
-    BOOST_CHECK( std::equal(buffer,buffer+7,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-
-    pkey_temp = frame::byte_mask_circ(buffer+7,8,pkey_temp);
-    BOOST_CHECK( std::equal(buffer,buffer+16,masked) );
-    BOOST_CHECK_EQUAL( pkey_temp, frame::circshift_prepared_key(pkey,3) );
-}
-
-BOOST_AUTO_TEST_CASE( continuous_word_mask2 ) {
-    uint8_t buffer[12] = {0xA6, 0x15, 0x97, 0xB9,
-                          0x81, 0x50, 0xAC, 0xBA,
-                          0x9C, 0x1C, 0x9F, 0xF4};
-
-    uint8_t unmasked[12] = {0x48, 0x65, 0x6C, 0x6C,
-                            0x6F, 0x20, 0x57, 0x6F,
-                            0x72, 0x6C, 0x64, 0x21};
-
-    frame::masking_key_type key;
-    key.c[0] = 0xEE;
-    key.c[1] = 0x70;
-    key.c[2] = 0xFB;
-    key.c[3] = 0xD5;
-
-    // One call
-    size_t pkey;
-    pkey = frame::prepare_masking_key(key);
-    frame::word_mask_circ(buffer,12,pkey);
-    BOOST_CHECK( std::equal(buffer,buffer+12,unmasked) );
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/sha1.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/sha1.cpp
deleted file mode 100644
index ab25f97..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/sha1.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE sha1
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/sha1/sha1.hpp>
-#include <websocketpp/utilities.hpp>
-
-BOOST_AUTO_TEST_SUITE ( sha1 )
-
-BOOST_AUTO_TEST_CASE( sha1_test_a ) {
-    unsigned char hash[20];
-    unsigned char reference[20] = {0xa9, 0x99, 0x3e, 0x36, 0x47,
-                                   0x06, 0x81, 0x6a, 0xba, 0x3e,
-                                   0x25, 0x71, 0x78, 0x50, 0xc2,
-                                   0x6c, 0x9c, 0xd0, 0xd8, 0x9d};
-
-    websocketpp::sha1::calc("abc",3,hash);
-
-    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
-}
-
-BOOST_AUTO_TEST_CASE( sha1_test_b ) {
-    unsigned char hash[20];
-    unsigned char reference[20] = {0x84, 0x98, 0x3e, 0x44, 0x1c,
-                                   0x3b, 0xd2, 0x6e, 0xba, 0xae,
-                                   0x4a, 0xa1, 0xf9, 0x51, 0x29,
-                                   0xe5, 0xe5, 0x46, 0x70, 0xf1};
-
-    websocketpp::sha1::calc(
-        "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",56,hash);
-
-    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
-}
-
-BOOST_AUTO_TEST_CASE( sha1_test_c ) {
-    std::string input;
-    unsigned char hash[20];
-    unsigned char reference[20] = {0x34, 0xaa, 0x97, 0x3c, 0xd4,
-                                   0xc4, 0xda, 0xa4, 0xf6, 0x1e,
-                                   0xeb, 0x2b, 0xdb, 0xad, 0x27,
-                                   0x31, 0x65, 0x34, 0x01, 0x6f};
-
-    for (int i = 0; i < 1000000; i++) {
-        input += 'a';
-    }
-
-    websocketpp::sha1::calc(input.c_str(),input.size(),hash);
-
-    BOOST_CHECK_EQUAL_COLLECTIONS(hash, hash+20, reference, reference+20);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/uri.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/uri.cpp
deleted file mode 100644
index 2b0c886..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/uri.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE uri
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/uri.hpp>
-
-// Test a regular valid ws URI
-BOOST_AUTO_TEST_CASE( uri_valid ) {
-    websocketpp::uri uri("ws://localhost:9000/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( !uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "ws");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-    BOOST_CHECK_EQUAL( uri.get_query(), "" );
-}
-
-// Test a regular valid ws URI
-BOOST_AUTO_TEST_CASE( uri_valid_no_port_unsecure ) {
-    websocketpp::uri uri("ws://localhost/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( !uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "ws");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 80 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-}
-
-// Valid URI with no port (secure)
-BOOST_AUTO_TEST_CASE( uri_valid_no_port_secure ) {
-    websocketpp::uri uri("wss://localhost/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 443 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-}
-
-// Valid URI with no resource
-BOOST_AUTO_TEST_CASE( uri_valid_no_resource ) {
-    websocketpp::uri uri("wss://localhost:9000");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
-}
-
-// Valid URI IPv6 Literal
-BOOST_AUTO_TEST_CASE( uri_valid_ipv6_literal ) {
-    websocketpp::uri uri("wss://[::1]:9000/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "::1");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-}
-
-// Valid URI with more complicated host
-BOOST_AUTO_TEST_CASE( uri_valid_2 ) {
-    websocketpp::uri uri("wss://thor-websocket.zaphoyd.net:88/");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "thor-websocket.zaphoyd.net");
-    BOOST_CHECK_EQUAL( uri.get_port(), 88 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
-}
-
-
-// Invalid URI (port too long)
-BOOST_AUTO_TEST_CASE( uri_invalid_long_port ) {
-    websocketpp::uri uri("wss://localhost:900000/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid URI (bogus scheme method)
-BOOST_AUTO_TEST_CASE( uri_invalid_scheme ) {
-    websocketpp::uri uri("foo://localhost:9000/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Valid URI (http method)
-BOOST_AUTO_TEST_CASE( uri_http_scheme ) {
-    websocketpp::uri uri("http://localhost:9000/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( !uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "http");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-}
-
-// Valid URI IPv4 literal
-BOOST_AUTO_TEST_CASE( uri_valid_ipv4_literal ) {
-    websocketpp::uri uri("wss://127.0.0.1:9000/chat");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "127.0.0.1");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat" );
-}
-
-// Valid URI complicated resource path
-BOOST_AUTO_TEST_CASE( uri_valid_3 ) {
-    websocketpp::uri uri("wss://localhost:9000/chat/foo/bar");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss");
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat/foo/bar" );
-}
-
-// Invalid URI broken method separator
-BOOST_AUTO_TEST_CASE( uri_invalid_method_separator ) {
-    websocketpp::uri uri("wss:/localhost:9000/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid URI port > 65535
-BOOST_AUTO_TEST_CASE( uri_invalid_gt_16_bit_port ) {
-    websocketpp::uri uri("wss:/localhost:70000/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid URI includes uri fragment
-BOOST_AUTO_TEST_CASE( uri_invalid_fragment ) {
-    websocketpp::uri uri("wss:/localhost:70000/chat#foo");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid URI with no brackets around IPv6 literal
-BOOST_AUTO_TEST_CASE( uri_invalid_bad_v6_literal_1 ) {
-    websocketpp::uri uri("wss://::1/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid URI with port and no brackets around IPv6 literal
-BOOST_AUTO_TEST_CASE( uri_invalid_bad_v6_literal_2 ) {
-    websocketpp::uri uri("wss://::1:2009/chat");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Valid URI complicated resource path with query
-BOOST_AUTO_TEST_CASE( uri_valid_4 ) {
-    websocketpp::uri uri("wss://localhost:9000/chat/foo/bar?foo=bar");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
-    BOOST_CHECK_EQUAL( uri.get_host(), "localhost");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/chat/foo/bar?foo=bar" );
-    BOOST_CHECK_EQUAL( uri.get_query(), "foo=bar" );
-}
-
-// Valid URI with a mapped v4 ipv6 literal
-BOOST_AUTO_TEST_CASE( uri_valid_v4_mapped ) {
-    websocketpp::uri uri("wss://[0000:0000:0000:0000:0000:0000:192.168.1.1]:9000/");
-
-    BOOST_CHECK( uri.get_valid() );
-    BOOST_CHECK( uri.get_secure() );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
-    BOOST_CHECK_EQUAL( uri.get_host(), "0000:0000:0000:0000:0000:0000:192.168.1.1");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
-}
-
-// Valid URI with a v6 address with mixed case
-BOOST_AUTO_TEST_CASE( uri_valid_v6_mixed_case ) {
-    websocketpp::uri uri("wss://[::10aB]:9000/");
-
-    BOOST_CHECK( uri.get_valid() == true );
-    BOOST_CHECK( uri.get_secure() == true );
-    BOOST_CHECK_EQUAL( uri.get_scheme(), "wss" );
-    BOOST_CHECK_EQUAL( uri.get_host(), "::10aB");
-    BOOST_CHECK_EQUAL( uri.get_port(), 9000 );
-    BOOST_CHECK_EQUAL( uri.get_resource(), "/" );
-}
-
-// Valid URI with a v6 address with mixed case
-BOOST_AUTO_TEST_CASE( uri_invalid_no_scheme ) {
-    websocketpp::uri uri("myserver.com");
-
-    BOOST_CHECK( !uri.get_valid() );
-}
-
-// Invalid IPv6 literal
-/*BOOST_AUTO_TEST_CASE( uri_invalid_v6_nonhex ) {
-    websocketpp::uri uri("wss://[g::1]:9000/");
-
-    BOOST_CHECK( uri.get_valid() == false );
-}*/
-
-// TODO: tests for the other two constructors
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/utilities.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/utilities.cpp
deleted file mode 100644
index 8cbb8c3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/test/utility/utilities.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2011, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-//#define BOOST_TEST_DYN_LINK
-#define BOOST_TEST_MODULE utility
-#include <boost/test/unit_test.hpp>
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/utilities.hpp>
-
-BOOST_AUTO_TEST_SUITE ( utility )
-
-BOOST_AUTO_TEST_CASE( substr_found ) {
-    std::string haystack = "abc123";
-    std::string needle = "abc";
-
-    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) ==haystack.begin());
-}
-
-BOOST_AUTO_TEST_CASE( substr_found_ci ) {
-    std::string haystack = "abc123";
-    std::string needle = "aBc";
-
-    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) ==haystack.begin());
-}
-
-BOOST_AUTO_TEST_CASE( substr_not_found ) {
-    std::string haystack = "abd123";
-    std::string needle = "abcd";
-
-    BOOST_CHECK(websocketpp::utility::ci_find_substr(haystack,needle) == haystack.end());
-}
-
-BOOST_AUTO_TEST_CASE( to_lower ) {
-    std::string in = "AbCd";
-
-    BOOST_CHECK_EQUAL(websocketpp::utility::to_lower(in), "abcd");
-}
-
-BOOST_AUTO_TEST_CASE( string_replace_all ) {
-    std::string source = "foo \"bar\" baz";
-    std::string dest = "foo \\\"bar\\\" baz";
-
-    using websocketpp::utility::string_replace_all;
-    BOOST_CHECK_EQUAL(string_replace_all(source,"\"","\\\""),dest);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/broadcast_tutorial/broadcast_tutorial.md b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/broadcast_tutorial/broadcast_tutorial.md
deleted file mode 100644
index 02e5001..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/broadcast_tutorial/broadcast_tutorial.md
+++ /dev/null
@@ -1,17 +0,0 @@
-Broadcast Tutorial
-==================
-
-This tutorial will dig into some more nitty gritty details on how to build high
-scalability, high performance websocket servers for broadcast like workflows.
-
-Will go into features like:
-- minimizing work done in handlers
-- using asio thread pool mode
-- teaming multiple endpoints
-- setting accept queue depth
-- tuning compile time buffer sizes
-- prepared messages
-- flow control
-- basic operating system level tuning, particularly increasing file descriptor limits.
-- measuring performance with wsperf / autobahn
-- tuning permessage-deflate compression settings
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/chat_tutorial/chat_tutorial.md b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/chat_tutorial/chat_tutorial.md
deleted file mode 100644
index 042837c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/chat_tutorial/chat_tutorial.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Chat Tutorial
-=============
-
-Goals of this tutorial:
-- Implement a realtime websocket chat server
-
-
-Server
-- Nicknames
-- Channels
-- Subprotocol
-- Origin restrictions
-- HTTP statistics page
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step1.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step1.cpp
deleted file mode 100644
index 9c8fad9..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step1.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <iostream>
-#include <string>
-
-int main() {
-    bool done = false;
-    std::string input;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout 
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step2.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step2.cpp
deleted file mode 100644
index a1e5796..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step2.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-#include <string>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-int main() {
-    bool done = false;
-    std::string input;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step3.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step3.cpp
deleted file mode 100644
index 82e652f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step3.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <iostream>
-#include <string>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
-    }
-private:
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout 
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step4.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step4.cpp
deleted file mode 100644
index 73aee65..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step4.cpp
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason);
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-
-/*
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a
-
-clang++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_thread.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_random.a
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/Documents/websocketpp/ -I/Users/zaphoyd/Documents/boost_1_53_0_libcpp/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/Documents/boost_1_53_0_libcpp/stage/lib/libboost_system.a
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step5.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step5.cpp
deleted file mode 100644
index 3e57b3c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step5.cpp
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-    
-    void on_close(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Closed";
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        std::stringstream s;
-        s << "close code: " << con->get_remote_close_code() << " (" 
-          << websocketpp::close::status::get_string(con->get_remote_close_code()) 
-          << "), close reason: " << con->get_remote_close_reason();
-        m_error_reason = s.str();
-    }
-
-    websocketpp::connection_hdl get_hdl() const {
-        return m_hdl;
-    }
-    
-    int get_id() const {
-        return m_id;
-    }
-    
-    std::string get_status() const {
-        return m_status;
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason);
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
-    }
-
-    ~websocket_endpoint() {
-        m_endpoint.stop_perpetual();
-        
-        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
-            if (it->second->get_status() != "Open") {
-                // Only close open connections
-                continue;
-            }
-            
-            std::cout << "> Closing connection " << it->second->get_id() << std::endl;
-            
-            websocketpp::lib::error_code ec;
-            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
-            if (ec) {
-                std::cout << "> Error closing connection " << it->second->get_id() << ": "  
-                          << ec.message() << std::endl;
-            }
-        }
-        
-        m_thread->join();
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_close_handler(websocketpp::lib::bind(
-            &connection_metadata::on_close,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    void close(int id, websocketpp::close::status::value code, std::string reason) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
-        if (ec) {
-            std::cout << "> Error initiating close: " << ec.message() << std::endl;
-        }
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,5) == "close") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            int close_code = websocketpp::close::status::normal;
-            std::string reason;
-            
-            ss >> cmd >> id >> close_code;
-            std::getline(ss,reason);
-            
-            endpoint.close(id, close_code, reason);
-        }  else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-
-/*
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a
-
-clang++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_thread.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_random.a
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/Documents/websocketpp/ -I/Users/zaphoyd/Documents/boost_1_53_0_libcpp/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/Documents/boost_1_53_0_libcpp/stage/lib/libboost_system.a
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step6.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step6.cpp
deleted file mode 100644
index 208b95d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/step6.cpp
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility client tutorial.
-// Additional related material can be found in the tutorials/utility_client
-// directory of the WebSocket++ repository.
-
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-    
-    void on_close(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Closed";
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        std::stringstream s;
-        s << "close code: " << con->get_remote_close_code() << " (" 
-          << websocketpp::close::status::get_string(con->get_remote_close_code()) 
-          << "), close reason: " << con->get_remote_close_reason();
-        m_error_reason = s.str();
-    }
-
-    void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
-        if (msg->get_opcode() == websocketpp::frame::opcode::text) {
-            m_messages.push_back("<< " + msg->get_payload());
-        } else {
-            m_messages.push_back("<< " + websocketpp::utility::to_hex(msg->get_payload()));
-        }
-    }
-
-    websocketpp::connection_hdl get_hdl() const {
-        return m_hdl;
-    }
-    
-    int get_id() const {
-        return m_id;
-    }
-    
-    std::string get_status() const {
-        return m_status;
-    }
-
-    void record_sent_message(std::string message) {
-        m_messages.push_back(">> " + message);
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-    std::vector<std::string> m_messages;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason) << "\n";
-    out << "> Messages Processed: (" << data.m_messages.size() << ") \n";
-
-    std::vector<std::string>::const_iterator it;
-    for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
-        out << *it << "\n";
-    }
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
-    }
-
-    ~websocket_endpoint() {
-        m_endpoint.stop_perpetual();
-        
-        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
-            if (it->second->get_status() != "Open") {
-                // Only close open connections
-                continue;
-            }
-            
-            std::cout << "> Closing connection " << it->second->get_id() << std::endl;
-            
-            websocketpp::lib::error_code ec;
-            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
-            if (ec) {
-                std::cout << "> Error closing connection " << it->second->get_id() << ": "  
-                          << ec.message() << std::endl;
-            }
-        }
-        
-        m_thread->join();
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_close_handler(websocketpp::lib::bind(
-            &connection_metadata::on_close,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_message_handler(websocketpp::lib::bind(
-            &connection_metadata::on_message,
-            metadata_ptr,
-            websocketpp::lib::placeholders::_1,
-            websocketpp::lib::placeholders::_2
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    void close(int id, websocketpp::close::status::value code, std::string reason) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
-        if (ec) {
-            std::cout << "> Error initiating close: " << ec.message() << std::endl;
-        }
-    }
-
-    void send(int id, std::string message) {
-        websocketpp::lib::error_code ec;
-        
-        con_list::iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            std::cout << "> No connection found with id " << id << std::endl;
-            return;
-        }
-        
-        m_endpoint.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
-        if (ec) {
-            std::cout << "> Error sending message: " << ec.message() << std::endl;
-            return;
-        }
-        
-        metadata_it->second->record_sent_message(message);
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "send <connection id> <message>\n"
-                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,4) == "send") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            std::string message;
-            
-            ss >> cmd >> id;
-            std::getline(ss,message);
-            
-            endpoint.send(id, message);
-        } else if (input.substr(0,5) == "close") {
-            std::stringstream ss(input);
-            
-            std::string cmd;
-            int id;
-            int close_code = websocketpp::close::status::normal;
-            std::string reason;
-            
-            ss >> cmd >> id >> close_code;
-            std::getline(ss,reason);
-            
-            endpoint.close(id, close_code, reason);
-        } else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-
-/*
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a
-
-clang++ -I/Users/zaphoyd/software/websocketpp/ -I/Users/zaphoyd/software/boost_1_55_0/ step4.cpp /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_system.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_thread.a /Users/zaphoyd/software/boost_1_55_0/stage/lib/libboost_random.a
-
-clang++ -std=c++11 -stdlib=libc++ -I/Users/zaphoyd/Documents/websocketpp/ -I/Users/zaphoyd/Documents/boost_1_53_0_libcpp/ -D_WEBSOCKETPP_CPP11_STL_ step4.cpp /Users/zaphoyd/Documents/boost_1_53_0_libcpp/stage/lib/libboost_system.a
-
-*/
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/utility_client.md b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/utility_client.md
deleted file mode 100644
index 696113d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_client/utility_client.md
+++ /dev/null
@@ -1,862 +0,0 @@
-Utility Client Example Application Tutorial
-===========================================
-
-Chapter 1: Initial Setup & Basics
----------------------------------
-
-Setting up the basic types, opening and closing connections, sending and receiving messages.
-
-### Step 1
-
-A basic program loop that prompts the user for a command and then processes it. In this tutorial we will modify this program to perform tasks and retrieve data from a remote server over a WebSocket connection.
-
-#### Build
-`clang++ step1.cpp`
-
-#### Code so far
-
-*note* A code snapshot for each step is present next to this tutorial file in the git repository.
-
-~~~{.cpp}
-#include <iostream>
-#include <string>
-
-int main() {
-    bool done = false;
-    std::string input;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-~~~
-
-### Step 2
-
-_Add WebSocket++ includes and set up an endpoint type._
-
-WebSocket++ includes two major object types. The endpoint and the connection. The
-endpoint creates and launches new connections and maintains default settings for
-those connections. Endpoints also manage any shared network resources.
-
-The connection stores information specific to each WebSocket session.
-
-> **Note:** Once a connection is launched, there is no link between the endpoint and the connection. All default settings are copied into the new connection by the endpoint. Changing default settings on an endpoint will only affect future connections.
-Connections do not maintain a link back to their associated endpoint. Endpoints do not maintain a list of outstanding connections. If your application needs to iterate over all connections it will need to maintain a list of them itself.
-
-WebSocket++ endpoints are built by combining an endpoint role with an endpoint config. There are two different types of endpoint roles, one each for the client and server roles in a WebSocket session. This is a client tutorial so we will use the client role `websocketpp::client` which is provided by the `<websocketpp/client.hpp>` header.
-
-> ##### Terminology: Endpoint Config
-> WebSocket++ endpoints have a group of settings that may be configured at compile time via the `config` template parameter. A config is a struct that contains types and static constants that are used to produce an endpoint with specific properties. Depending on which config is being used the endpoint will have different methods available and may have additional third party dependencies.
-
-The endpoint role takes a template parameter called `config` that is used to configure the behavior of endpoint at compile time. For this example we are going to use a default config provided by the library called `asio_client`, provided by `<websocketpp/config/asio_no_tls_client.hpp>`. This is a client config that uses boost::asio to provide network transport and does not support TLS based security. Later on we will discuss how to introduce TLS based security into a WebSocket++ application, more about the other stock configs, and how to build your own custom configs.
-
-Combine a config with an endpoint role to produce a fully configured endpoint. This type will be used frequently so I would recommend a typedef here.
-
-`typedef websocketpp::client<websocketpp::config::asio_client> client`
-
-#### Build
-Adding WebSocket++ has added a few dependencies to our program that must be addressed in the build system. Firstly, the WebSocket++ and Boost library headers must be in the include search path of your build system. How exactly this is done depends on where you have the WebSocket++ headers installed and what build system you are using.
-
-In addition to the new headers, boost::asio depends on the `boost_system` shared library. This will need to be added (either as a static or dynamic) to the linker. Refer to your build environment documentation for instructions on linking to shared libraries.
-
-`clang++ step2.cpp -lboost_system`
-
-#### Code so far
-~~~{.cpp}
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <iostream>
-#include <string>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-int main() {
-    bool done = false;
-    std::string input;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-~~~
-
-### Step 3
-
-_Create endpoint wrapper object that handles initialization and setting up the background thread._
-
-In order to process user input while network processing occurs in the background we are going to use a separate thread for the WebSocket++ processing loop. This leaves the main thread free to process foreground user input. In order to enable simple RAII style resource management for our thread and endpoint we will use a wrapper object that configures them both in its constructor.
-
-> ##### Terminology: websocketpp::lib namespace
-> WebSocket++ is designed to be used with a C++11 standard library. As this is not universally available in popular build systems the Boost libraries may be used as polyfills for the C++11 standard library in C++98 build environments. The `websocketpp::lib` namespace is used by the library and its associated examples to abstract away the distinctions between the two. `websocketpp::lib::shared_ptr` will evaluate to `std::shared_ptr` in a C++11 environment and `boost::shared_ptr` otherwise.
->
-> This tutorial uses the `websocketpp::lib` wrappers because it doesn't know what the build environment of the reader is. For your applications, unless you are interested in similar portability, are free to use the boost or std versions of these types directly.
->
->[TODO: link to more information about websocketpp::lib namespace and C++11 setup]
-
-Within the `websocket_endpoint` constructor several things happen:
-
-First, we set the endpoint logging behavior to silent by clearing all of the access and error logging channels. [TODO: link to more information about logging]
-~~~{.cpp}
-m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-~~~
-
-Next, we initialize the transport system underlying the endpoint and set it to perpetual mode. In perpetual mode the endpoint's processing loop will not exit automatically when it has no connections. This is important because we want this endpoint to remain active while our application is running and process requests for new WebSocket connections on demand as we need them. Both of these methods are specific to the asio transport. They will not be  necessary or present in endpoints that use a non-asio config.
-~~~{.cpp}
-m_endpoint.init_asio();
-m_endpoint.start_perpetual();
-~~~
-
-Finally, we launch a thread to run the `run` method of our client endpoint. While the endpoint is running it will process connection tasks (read and deliver incoming messages, frame and send outgoing messages, etc). Because it is running in perpetual mode, when there are no connections active it will wait for a new connection.
-~~~{.cpp}
-m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
-~~~
-
-#### Build
-
-Now that our client endpoint template is actually instantiated a few more linker dependencies will show up. In particular, WebSocket clients require a cryptographically secure random number generator. WebSocket++ is able to use either `boost_random` or the C++11 standard library <random> for this purpose. Because this example also uses threads, if we do not have C++11 std::thread available we will need to include `boost_thread`.
-
-##### Clang (C++98 & boost)
-`clang++ step3.cpp -lboost_system -lboost_random -lboost_thread`
-
-##### Clang (C++11)
-`clang++ -std=c++0x -stdlib=libc++ step3.cpp -lboost_system -D_WEBSOCKETPP_CPP11_STL_`
-
-##### G++ (C++98 & Boost)
-`g++ step3.cpp -lboost_system -lboost_random -lboost_thread`
-
-##### G++ v4.6+ (C++11)
-`g++ -std=c++0x step3.cpp -lboost_system -D_WEBSOCKETPP_CPP11_STL_`
-
-#### Code so far
-
-~~~{.cpp}
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <iostream>
-#include <string>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
-    }
-private:
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else {
-            std::cout << "Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-~~~
-
-### Step 4
-
-_Opening WebSocket connections_
-
-This step adds two new commands to utility_client. The ability to open a new connection and the ability to view information about a previously opened connection. Every connection that gets opened will be assigned an integer connection id that the user of the program can use to interact with that connection.
-
-#### New Connection Metadata Object
-
-In order to track information about each connection a `connection_metadata` object is defined. This object stores the numeric connection id and a number of fields that will be filled in as the connection is processed. Initially this includes the state of the connection (opening, open, failed, closed, etc), the original URI connected to, an identifying value from the server, and a description of the reason for connection failure/closure. Future steps will add more information to this metadata object.
-
-#### Update `websocket_endpoint`
-
-The `websocket_endpoint` object has gained some new data members and methods. It now tracks a mapping between connection IDs and their associated metadata as well as the next sequential ID number to hand out. The `connect()` method initiates a new connection. The `get_metadata` method retrieves metadata given an ID.
-
-#### The connect method
-A new WebSocket connection is initiated via a three step process. First, a connection request is created by `endpoint::get_connection(uri)`. Next, the connection request is configured. Lastly, the connection request is submitted back to the endpoint via `endpoint::connect()` which adds it to the queue of new connections to make.
-
-> ##### Terminology `connection_ptr`
-> WebSocket++ keeps track of connection related resources using a reference counted shared pointer. The type of this pointer is `endpoint::connection_ptr`. A `connection_ptr` allows direct access to information about the connection and allows changing connection settings. Because of this direct access and their internal resource management role within the library it is not safe for end applications to use `connection_ptr` except in the specific circumstances detailed below.
->
-> **When is it safe to use `connection_ptr`?**
-> - After `endpoint::get_connection(...)` and before `endpoint::connect()`: `get_connection` returns a `connection_ptr`. It is safe to use this pointer to configure your new connection. Once you submit the connection to `connect` you may no longer use the `connection_ptr` and should discard it immediately for optimal memory management.
-> - During a handler: WebSocket++ allows you to register hooks / callbacks / event handlers for specific events that happen during a connection's lifetime. During the invocation of one of these handlers the library guarantees that it is safe to use a `connection_ptr` for the connection associated with the currently running handler.
-
-> ##### Terminology `connection_hdl`
-> Because of the limited thread safety of the `connection_ptr` the library also provides a more flexible connection identifier, the `connection_hdl`. The `connection_hdl` has type `websocketpp::connection_hdl` and it is defined in `<websocketpp/common/connection_hdl.hpp>`. Note that unlike `connection_ptr` this is not dependent on the type or config of the endpoint. Code that simply stores or transmits `connection_hdl` but does not use them can include only the header above and can treat its hdls like values.
->
-> Connection handles are not used directly. They are used by endpoint methods to identify the target of the desired action. For example, the endpoint method that sends a new message will take as a parameter the hdl of the connection to send the message to.
->
-> **When is it safe to use `connection_hdl`?**
-> `connection_hdl`s may be used at any time from any thread. They may be copied and stored in containers. Deleting a hdl will not affect the connection in any way. Handles may be upgraded to a `connection_ptr` during a handler call by using `endpoint::get_con_from_hdl()`. The resulting `connection_ptr` is safe to use for the duration of that handler invocation.
->
-> **`connection_hdl` FAQs**
-> - `connection_hdl`s are guaranteed to be unique within a program. Multiple endpoints in a single program will always create connections with unique handles.
-> - Using a `connection_hdl` with a different endpoint than the one that created its associated connection will result in undefined behavior.
-> - Using a `connection_hdl` whose associated connection has been closed or deleted is safe. The endpoint will return a specific error saying the operation couldn't be completed because the associated connection doesn't exist.
-> [TODO: more here? link to a connection_hdl FAQ elsewhere?]
-
-`websocket_endpoint::connect()` begins by calling `endpoint::get_connection()` using a uri passed as a parameter. Additionally, an error output value is passed to capture any errors that might occur during. If an error does occur an error notice is printed along with a descriptive message and the -1 / 'invalid' value is returned as the new ID.
-
-> ###### Terminology: `error handling: exceptions vs error_code`
-> WebSocket++ uses the error code system defined by the C++11 `<system_error>` library. It can optionally fall back to a similar system provided by the Boost libraries. All user facing endpoint methods that can fail take an `error_code` in an output parameter and store the error that occured there before returning. An empty/default constructed value is returned in the case of success.
->
-> **Exception throwing varients**
-> All user facing endpoint methods that take and use an `error_code` parameter have a version that throws an exception instead. These methods are identical in function and signature except for the lack of the final ec parameter. The type of the exception thrown is `websocketpp::exception`. This type derives from `std::exception` so it can be caught by catch blocks grabbing generic `std::exception`s. The `websocketpp::exception::code()` method may be used to extract the machine readable `error_code` value from an exception.
->
-> For clarity about error handling the utility_client example uses exclusively the exception free varients of these methods. Your application may choose to use either.
-
-If connection creation succeeds, the next sequential connection ID is generated and a `connection_metadata` object is inserted into the connection list under that ID. Initially the metadata object stores the connection ID, the `connection_hdl`, and the URI the connection was opened to.
-
-~~~{.cpp}
-int new_id = m_next_id++;
-metadata_ptr metadata(new connection_metadata(new_id, con->get_handle(), uri));
-m_connection_list[new_id] = metadata;
-~~~
-
-Next, the connection request is configured. For this step the only configuration we will do is setting up a few default handlers. Later on we will return and demonstrate some more detailed configuration that can happen here (setting user agents, origin, proxies, custom headers, subprotocols, etc).
-
-> ##### Terminology: Registering handlers
-> WebSocket++ provides a number of execution points where you can register to have a handler run. Which of these points are available to your endpoint will depend on its config. TLS handlers will not exist on non-TLS endpoints for example. A complete list of handlers can be found at  http://www.zaphoyd.com/websocketpp/manual/reference/handler-list.
->
-> Handlers can be registered at the endpoint level and at the connection level. Endpoint handlers are copied into new connections as they are created. Changing an endpoint handler will affect only future connections. Handlers registered at the connection level will be bound to that specific connection only.
->
-> The signature of handler binding methods is the same for endpoints and connections. The format is: `set_*_handler(...)`. Where * is the name of the handler. For example, `set_open_handler(...)` will set the handler to be called when a new connection is open. `set_fail_handler(...)` will set the handler to be called when a connection fails to connect.
->
-> All handlers take one argument, a callable type that can be converted to a `std::function` with the correct count and type of arguments. You can pass free functions, functors, and Lambdas with matching argument lists as handlers. In addition, you can use `std::bind` (or `boost::bind`) to register functions with non-matching argument lists. This is useful for passing additional parameters not present in the handler signature or member functions that need to carry a 'this' pointer.
->
-> The function signature of each handler can be looked up in the list above in the manual. In general, all handlers include the `connection_hdl` identifying which connection this even is associated with as the first parameter. Some handlers (such as the message handler) include additional parameters. Most handlers have a void return value but some (`validate`, `ping`, `tls_init`) do not. The specific meanings of the return values are documented in the handler list linked above.
-
-`utility_client` registers an open and a fail handler. We will use these to track whether each connection was successfully opened or failed. If it successfully opens, we will gather some information from the opening handshake and store it with our connection metadata.
-
-In this example we are going to set connection specific handlers that are bound directly to the metadata object associated with our connection. This allows us to avoid performing a lookup in each handler to find the metadata object we plan to update which is a bit more efficient.
-
-Lets look at the parameters being sent to bind in detail:
-
-~~~{.cpp}
-con->set_open_handler(websocketpp::lib::bind(
-    &connection_metadata::on_open,
-    metadata,
-    &m_endpoint,
-    websocketpp::lib::placeholders::_1
-));
-~~~
-
-`&connection_metadata::on_open` is the address of the `on_open` member function of the `connection_metadata` class. `metadata_ptr` is a pointer to the `connection_metadata` object associated with this class. It will be used as the object on which the `on_open` member function will be called. `&m_endpoint` is the address of the endpoint in use. This parameter will be passed as-is to the `on_open` method. Lastly, `websocketpp::lib::placeholders::_1` is a placeholder indicating that the bound function should take one additional argument to be filled in at a later time. WebSocket++ will fill in this placeholder with the `connection_hdl` when it invokes the handler.
-
-Finally, we call `endpoint::connect()` on our configured connection request and return the new connection ID.
-
-#### Handler Member Functions
-
-The open handler we registered, `connection_metadata::on_open`, sets the status metadata field to "Open" and retrieves the value of the "Server" header from the remote endpoint's HTTP response and stores it in the metadata object. Servers often set an identifying string in this header.
-
-The fail handler we registered, `connection_metadata::on_fail`, sets the status metadata field to "Failed", the server field similarly to `on_open`, and retrieves the error code describing why the connection failed. The human readable message associated with that error code is saved to the metadata object.
-
-#### New Commands
-
-Two new commands have been set up. "connect [uri]" will pass the URI to the `websocket_endpoint` connect method and report an error or the connection ID of the new connection. "show [connection id]" will retrieve and print out the metadata associated with that connection. The help text has been updated accordingly.
-
-~~~{.cpp}
-} else if (input.substr(0,7) == "connect") {
-    int id = endpoint.connect(input.substr(8));
-    if (id != -1) {
-        std::cout << "> Created connection with id " << id << std::endl;
-    }
-} else if (input.substr(0,4) == "show") {
-    int id = atoi(input.substr(5).c_str());
-
-    connection_metadata::ptr metadata = endpoint.get_metadata(id);
-    if (metadata) {
-        std::cout << *metadata << std::endl;
-    } else {
-        std::cout << "> Unknown connection id " << id << std::endl;
-    }
-}
-~~~
-
-#### Build
-
-There are no changes to the build instructions from step 3
-
-#### Run
-
-~~~
-Enter Command: connect not a websocket uri
-> Connect initialization error: invalid uri
-Enter Command: show 0
-> Unknown connection id 0
-Enter Command: connect ws://echo.websocket.org
-> Created connection with id 0
-Enter Command: show 0
-> URI: ws://echo.websocket.org
-> Status: Open
-> Remote Server: Kaazing Gateway
-> Error/close reason: N/A
-Enter Command: connect ws://wikipedia.org
-> Created connection with id 1
-Enter Command: show 1
-> URI: ws://wikipedia.org
-> Status: Failed
-> Remote Server: Apache
-> Error/close reason: Invalid HTTP status.
-~~~
-
-#### Code so far
-
-~~~{.cpp}
-#include <websocketpp/config/asio_no_tls_client.hpp>
-#include <websocketpp/client.hpp>
-
-#include <websocketpp/common/thread.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <cstdlib>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sstream>
-
-typedef websocketpp::client<websocketpp::config::asio_client> client;
-
-class connection_metadata {
-public:
-    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
-
-    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
-      : m_id(id)
-      , m_hdl(hdl)
-      , m_status("Connecting")
-      , m_uri(uri)
-      , m_server("N/A")
-    {}
-
-    void on_open(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Open";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-    }
-
-    void on_fail(client * c, websocketpp::connection_hdl hdl) {
-        m_status = "Failed";
-
-        client::connection_ptr con = c->get_con_from_hdl(hdl);
-        m_server = con->get_response_header("Server");
-        m_error_reason = con->get_ec().message();
-    }
-
-    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
-private:
-    int m_id;
-    websocketpp::connection_hdl m_hdl;
-    std::string m_status;
-    std::string m_uri;
-    std::string m_server;
-    std::string m_error_reason;
-};
-
-std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
-    out << "> URI: " << data.m_uri << "\n"
-        << "> Status: " << data.m_status << "\n"
-        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
-        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason);
-
-    return out;
-}
-
-class websocket_endpoint {
-public:
-    websocket_endpoint () : m_next_id(0) {
-        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
-        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);
-
-        m_endpoint.init_asio();
-        m_endpoint.start_perpetual();
-
-        m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
-    }
-
-    int connect(std::string const & uri) {
-        websocketpp::lib::error_code ec;
-
-        client::connection_ptr con = m_endpoint.get_connection(uri, ec);
-
-        if (ec) {
-            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
-            return -1;
-        }
-
-        int new_id = m_next_id++;
-        connection_metadata::ptr metadata_ptr(new connection_metadata(new_id, con->get_handle(), uri));
-        m_connection_list[new_id] = metadata_ptr;
-
-        con->set_open_handler(websocketpp::lib::bind(
-            &connection_metadata::on_open,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-        con->set_fail_handler(websocketpp::lib::bind(
-            &connection_metadata::on_fail,
-            metadata_ptr,
-            &m_endpoint,
-            websocketpp::lib::placeholders::_1
-        ));
-
-        m_endpoint.connect(con);
-
-        return new_id;
-    }
-
-    connection_metadata::ptr get_metadata(int id) const {
-        con_list::const_iterator metadata_it = m_connection_list.find(id);
-        if (metadata_it == m_connection_list.end()) {
-            return connection_metadata::ptr();
-        } else {
-            return metadata_it->second;
-        }
-    }
-private:
-    typedef std::map<int,connection_metadata::ptr> con_list;
-
-    client m_endpoint;
-    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
-
-    con_list m_connection_list;
-    int m_next_id;
-};
-
-int main() {
-    bool done = false;
-    std::string input;
-    websocket_endpoint endpoint;
-
-    while (!done) {
-        std::cout << "Enter Command: ";
-        std::getline(std::cin, input);
-
-        if (input == "quit") {
-            done = true;
-        } else if (input == "help") {
-            std::cout
-                << "\nCommand List:\n"
-                << "connect <ws uri>\n"
-                << "show <connection id>\n"
-                << "help: Display this help text\n"
-                << "quit: Exit the program\n"
-                << std::endl;
-        } else if (input.substr(0,7) == "connect") {
-            int id = endpoint.connect(input.substr(8));
-            if (id != -1) {
-                std::cout << "> Created connection with id " << id << std::endl;
-            }
-        } else if (input.substr(0,4) == "show") {
-            int id = atoi(input.substr(5).c_str());
-
-            connection_metadata::ptr metadata = endpoint.get_metadata(id);
-            if (metadata) {
-                std::cout << *metadata << std::endl;
-            } else {
-                std::cout << "> Unknown connection id " << id << std::endl;
-            }
-        } else {
-            std::cout << "> Unrecognized Command" << std::endl;
-        }
-    }
-
-    return 0;
-}
-~~~
-
-### Step 5
-
-_Closing connections_
-
-This step adds a command that allows you to close a WebSocket connection and adjusts the quit command so that it cleanly closes all outstanding connections before quitting.
-
-#### Getting connection close information out of WebSocket++
-
-> ##### Terminology: WebSocket close codes & reasons
-> The WebSocket close handshake involves an exchange of optional machine readable close codes and human readable reason strings. Each endpoint sends independent close details. The codes are short integers. The reasons are UTF8 text strings of at most 125 characters. More details about valid close code ranges and the meaning of each code can be found at https://tools.ietf.org/html/rfc6455#section-7.4
-
-The `websocketpp::close::status` namespace contains named constants for all of the IANA defined close codes. It also includes free functions to determine whether a value is reserved or invalid and to convert a code to a human readable text representation.
-
-During the close handler call WebSocket++ connections offer the following methods for accessing close handshake information:
-
-- `connection::get_remote_close_code()`: Get the close code as reported by the remote endpoint
-- `connection::get_remote_close_reason()`: Get the close reason as reported by the remote endpoint
-- `connection::get_local_close_code()`: Get the close code that this endpoint sent.
-- `connection::get_local_close_reason()`: Get the close reason that this endpoint sent.
-- `connection::get_ec()`: Get a more detailed/specific WebSocket++ `error_code` indicating what library error (if any) ultimately resulted in the connection closure.
-
-*Note:* there are some special close codes that will report a code that was not actually sent on the wire. For example 1005/"no close code" indicates that the endpoint omitted a close code entirely and 1006/"abnormal close" indicates that there was a problem that resulted in the connection closing without having performed a close handshake.
-
-#### Add close handler
-
-The `connection_metadata::on_close` method is added. This method retrieves the close code and reason from the closing handshake and stores it in the local error reason field.
-
-~~~{.cpp}
-void on_close(client * c, websocketpp::connection_hdl hdl) {
-    m_status = "Closed";
-    client::connection_ptr con = c->get_con_from_hdl(hdl);
-    std::stringstream s;
-    s << "close code: " << con->get_remote_close_code() << " (" 
-      << websocketpp::close::status::get_string(con->get_remote_close_code()) 
-      << "), close reason: " << con->get_remote_close_reason();
-    m_error_reason = s.str();
-}
-~~~
-
-Similarly to `on_open` and `on_fail`, `websocket_endpoint::connect` registers this close handler when a new connection is made.
-
-#### Add close method to `websocket_endpoint`
-
-This method starts by looking up the given connection ID in the connection list.  Next a close request is sent to the connection's handle with the specified WebSocket close code. This is done by calling `endpoint::close`. This is a thread safe method that is used to asynchronously dispatch a close signal to the connection with the given handle. When the operation is complete the connection's close handler will be triggered.
-
-~~~{.cpp}
-void close(int id, websocketpp::close::status::value code) {
-    websocketpp::lib::error_code ec;
-    
-    con_list::iterator metadata_it = m_connection_list.find(id);
-    if (metadata_it == m_connection_list.end()) {
-        std::cout << "> No connection found with id " << id << std::endl;
-        return;
-    }
-    
-    m_endpoint.close(metadata_it->second->get_hdl(), code, "", ec);
-    if (ec) {
-        std::cout << "> Error initiating close: " << ec.message() << std::endl;
-    }
-}
-~~~
-
-#### Add close option to the command loop and help message
-
-A close option is added to the command loop. It takes a connection ID and optionally a close code and a close reason. If no code is specified the default of 1000/Normal is used. If no reason is specified, none is sent. The `endpoint::close` method will do some error checking and abort the close request if you try and send an invalid code or a reason with invalid UTF8 formatting. Reason strings longer than 125 characters will be truncated.
-
-An entry is also added to the help system to describe how the new command may be used.
-
-~~~{.cpp}
-else if (input.substr(0,5) == "close") {
-    std::stringstream ss(input);
-    
-    std::string cmd;
-    int id;
-    int close_code = websocketpp::close::status::normal;
-    std::string reason;
-    
-    ss >> cmd >> id >> close_code;
-    std::getline(ss,reason);
-    
-    endpoint.close(id, close_code, reason);
-}
-~~~
-
-#### Close all outstanding connections in `websocket_endpoint` destructor
-
-Until now quitting the program left outstanding connections and the WebSocket++ network thread in a lurch. Now that we have a method of closing connections we can clean this up properly.
-
-The destructor for `websocket_endpoint` now stops perpetual mode (so the run thread exits after the last connection is closed) and iterates through the list of open connections and requests a clean close for each. Finally, the run thread is joined which causes the program to wait until those connection closes complete.
-
-~~~{.cpp}
-~websocket_endpoint() {
-    m_endpoint.stop_perpetual();
-    
-    for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
-        if (it->second->get_status() != "Open") {
-            // Only close open connections
-            continue;
-        }
-        
-        std::cout << "> Closing connection " << it->second->get_id() << std::endl;
-        
-        websocketpp::lib::error_code ec;
-        m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
-        if (ec) {
-            std::cout << "> Error closing connection " << it->second->get_id() << ": "  
-                      << ec.message() << std::endl;
-        }
-    }
-    
-    m_thread->join();
-}
-~~~
-
-#### Build
-
-There are no changes to the build instructions from step 4
-
-#### Run
-
-~~~
-Enter Command: connect ws://localhost:9002
-> Created connection with id 0
-Enter Command: close 0 1001 example message
-Enter Command: show 0
-> URI: ws://localhost:9002
-> Status: Closed
-> Remote Server: WebSocket++/0.4.0
-> Error/close reason: close code: 1001 (Going away), close reason:  example message
-Enter Command: connect ws://localhost:9002
-> Created connection with id 1
-Enter Command: close 1 1006
-> Error initiating close: Invalid close code used
-Enter Command: quit
-> Closing connection 1
-~~~
-
-### Step 6
-
-_Sending and receiving messages_
-
-This step adds a command to send a message on a given connection and updates the show command to print a transcript of all sent and received messages for that connection.
-
-> ##### Terminology: WebSocket message types (opcodes)
-> WebSocket messages have types indicated by their opcode. The protocol currently specifies two different opcodes for data messages, text and binary. Text messages represent UTF8 text and will be validated as such. Binary messages represent raw binary bytes and are passed through directly with no validation. 
->
-> WebSocket++ provides the values `websocketpp::frame::opcode::text` and `websocketpp::frame::opcode::binary` that can be used to direct how outgoing messages should be sent and to check how incoming messages are formatted.
-
-#### Sending Messages
-
-Messages are sent using `endpoint::send`. This is a thread safe method that may be called from anywhere to queue a message for sending on the specified connection. There are three send overloads for use with different scenarios. 
-
-Each method takes a `connection_hdl` to indicate which connection to send the message on as well as a `frame::opcode::value` to indicate which opcode to label the message as. All overloads are also available with an exception free varient that fills in a a status/error code instead of throwing.
-
-The first overload, `connection_hdl hdl, std::string const & payload, frame::opcode::value op`, takes a `std::string`. The string contents are copied into an internal buffer and can be safely modified after calling send.
-
-The second overload, `connection_hdl hdl, void const * payload, size_t len, frame::opcode::value op`, takes a void * buffer and length. The buffer contents are copied and can be safely modified after calling send.
-
-The third overload, `connection_hdl hdl, message_ptr msg`, takes a WebSocket++ `message_ptr`. This overload allows a message to be constructed in place before the call to send. It also may allow a single message buffer to be sent multiple times, including to multiple connections, without copying. Whether or not this actually happens depends on other factors such as whether compression is enabled. The contents of the message buffer may not be safely modified after being sent.
-
-> ###### Terminology: Outgoing WebSocket message queueing & flow control
-> In many configurations, such as when the Asio based transport is in use, WebSocket++ is an asynchronous system. As such the `endpoint::send` method may return before any bytes are actually written to the outgoing socket. In cases where send is called multiple times in quick succession messages may be coalesced and sent in the same operation or even the same TCP packet. When this happens the message boundaries are preserved (each call to send will produce a separate message).
->
-> In the case of applications that call send from inside a handler this means that no messages will be written to the socket until that handler returns. If you are planning to send many messages in this manor or need a message to be written on the wire before continuing you should look into using multiple threads or the built in timer/interrupt handler functionality.
->
-> If the outgoing socket link is slow messages may build up in this queue. You can use `connection::get_buffered_amount` to query the current size of the written message queue to decide if you want to change your sending behavior.
-
-#### Add send method to `websocket_endpoint`
-
-Like the close method, send will start by looking up the given connection ID in the connection list.  Next a send request is sent to the connection's handle with the specified WebSocket message and the text opcode. Finally, we record the sent message with our connection metadata object so later our show connection command can print a list of messages sent.
-
-~~~{.cpp}
-void send(int id, std::string message) {
-    websocketpp::lib::error_code ec;
-    
-    con_list::iterator metadata_it = m_connection_list.find(id);
-    if (metadata_it == m_connection_list.end()) {
-        std::cout << "> No connection found with id " << id << std::endl;
-        return;
-    }
-    
-    m_endpoint.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
-    if (ec) {
-        std::cout << "> Error sending message: " << ec.message() << std::endl;
-        return;
-    }
-    
-    metadata_it->second->record_sent_message(message);
-}
-~~~
-
-#### Add send option to the command loop and help message
-
-A send option is added to the command loop. It takes a connection ID and a text message to send. An entry is also added to the help system to describe how the new command may be used.
-
-~~~{.cpp}
-else if (input.substr(0,4) == "send") {
-    std::stringstream ss(input);
-        
-        std::string cmd;
-        int id;
-        std::string message = "";
-        
-        ss >> cmd >> id;
-        std::getline(ss,message);
-        
-        endpoint.send(id, message);
-}
-~~~
-
-#### Add glue to `connection_metadata` for storing sent messages
-
-In order to store messages sent on this connection some code is added to `connection_metadata`. This includes a new data member `std::vector<std::string> m_messages` to keep track of all messages sent and received as well as a method for adding a sent message in that list:
-
-~~~{.cpp}
-void record_sent_message(std::string message) {
-    m_messages.push_back(">> " + message);
-}
-~~~
-
-Finally the connection metadata output operator is updated to also print a list of processed messages:
-
-~~~{.cpp}
-out << "> Messages Processed: (" << data.m_messages.size() << ") \n";
-
-std::vector<std::string>::const_iterator it;
-for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
-    out << *it << "\n";
-}
-~~~
-
-#### Receiving Messages
-
-Messages are received by registering a message handler. This handler will be called once per message received and its signature is `void on_message(websocketpp::connection_hdl hdl, endpoint::message_ptr msg)`. The `connection_hdl`, like the similar parameter from the other handlers is a handle for the connection that the message was received on. The `message_ptr` is a pointer to an object that can be queried for the message payload, opcode, and other metadata. Note that the message_ptr type, as well as its underlying message type, is dependent on how your endpoint is configured and may be different for different configs.
-
-#### Add a message handler to method to `connection_metadata`
-
-The message receiving behave that we are implementing will be to collect all messages sent and received and to print them in order when the show connection command is run. The sent messages are already being added to that list. Now we add a message handler that pushes received messages to the list as well. Text messages are pushed as-is. Binary messages are first converted to printable hexadecimal format.
-
-~~~{.cpp}
-void on_message(websocketpp::connection_hdl hdl, client::message_ptr msg) {
-    if (msg->get_opcode() == websocketpp::frame::opcode::text) {
-        m_messages.push_back(msg->get_payload());
-    } else {
-        m_messages.push_back(websocketpp::utility::to_hex(msg->get_payload()));
-    }
-}
-~~~
-
-In order to have this handler called when new messages are received we also register it with our connection. Note that unlike most other handlers, the message handler has two parameters and thus needs two placeholders.
-
-~~~{.cpp}
-con->set_message_handler(websocketpp::lib::bind(
-    &connection_metadata::on_message,
-    metadata_ptr,
-    websocketpp::lib::placeholders::_1,
-    websocketpp::lib::placeholders::_2
-));
-~~~
-
-#### Build
-
-There are no changes to the build instructions from step 5
-
-#### Run
-
-In this example run we are connecting to the WebSocket++ example echo_server. This server will repeat any message we send back to it. You can also try testing this with the echo server at `ws://echo.websocket.org` with similar results.
-
-~~~
-Enter Command: connect ws://localhost:9002
-> Created connection with id 0
-Enter Command: send 0 example message
-Enter Command: show 0
-> URI: ws://localhost:9002
-> Status: Open
-> Remote Server: WebSocket++/0.4.0
-> Error/close reason: N/A
-> Messages Processed: (2)
->>  example message
-<<  example message
-~~~
-
-### Step 7
-
-_Using TLS / Secure WebSockets_
-
-- Change the includes
-- link to the new library dependencies
-- Switch the config
-- add the `tls_init_handler`
-- configure the SSL context for desired security level
-- mixing secure and non-secure connections in one application.
-
-Chapter 2: Intermediate Features
---------------------------------
-
-### Step 8
-
-_Intermediate level features_
-
-- Subprotocol negotiation
-- Setting and reading custom headers
-- Ping and Pong
-- Proxies?
-- Setting user agent
-- Setting Origin
-- Timers and security
-- Close behavior
-- Send one message to all connections
-
-
-### Misc stuff not sure if it should be included here or elsewhere?
-
-core websocket++ control flow.
-A handshake, followed by a split into 2 independent control strands
-- Handshake
--- use information specified before the call to endpoint::connect to construct a WebSocket handshake request.
--- Pass the WebSocket handshake request to the transport policy. The transport policy determines how to get these bytes to the endpoint playing the server role. Depending on which transport policy your endpoint uses this method will be different.
--- Receive a handshake response from the underlying transport. This is parsed and checked for conformance to RFC6455. If the validation fails, the fail handler is called. Otherwise the open handler is called.
-- At this point control splits into two separate strands. One that reads new bytes from the transport policy on the incoming channle, the other that accepts new messages from the local application for framing and writing to the outgoing transport channel.
-- Read strand
--- Read and process new bytes from transport
--- If the bytes contain at least one complete message dispatch each message by calling the appropriate handler. This is either the message handler for data messages, or ping/pong/close handlers for each respective control message. If no handler is registered for a particular message it is ignored.
--- Ask the transport layer for more bytes
-- Write strand
--- Wait for messages from the application
--- Perform error checking on message input,
--- Frame message per RFC6455
--- Queue message for sending
--- Pass all outstanding messages to the transport policy for output
--- When there are no messages left to send, return to waiting
-
-Important observations
-Handlers run in line with library processing which has several implications applications should be aware of:
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step1.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step1.cpp
deleted file mode 100644
index c0e4643..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step1.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility server tutorial.
-// Additional related material can be found in the tutorials/utility_server
-// directory of the WebSocket++ repository.
-
-// The ASIO_STANDALONE define is necessary to use the standalone version of Asio.
-// Remove if you are using Boost Asio.
-#define ASIO_STANDALONE
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-#include <functional>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-class utility_server {
-public:
-    utility_server() {
-         // Set logging settings
-        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
-        m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
-
-        // Initialize Asio
-        m_endpoint.init_asio();
-    }
-
-    void run() {
-        // Listen on port 9002
-        m_endpoint.listen(9002);
-
-        // Queues a connection accept operation
-        m_endpoint.start_accept();
-
-        // Start the Asio io_service run loop
-        m_endpoint.run();
-    }
-private:
-    server m_endpoint;
-};
-
-int main() {
-    utility_server s;
-    s.run();
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step2.cpp b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step2.cpp
deleted file mode 100644
index a2815bb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/step2.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-// **NOTE:** This file is a snapshot of the WebSocket++ utility server tutorial.
-// Additional related material can be found in the tutorials/utility_server
-// directory of the WebSocket++ repository.
-
-// The ASIO_STANDALONE define is necessary to use the standalone version of Asio.
-// Remove if you are using Boost Asio.
-#define ASIO_STANDALONE
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-#include <functional>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-class utility_server {
-public:
-    utility_server() {
-         // Set logging settings
-        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
-        m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
-
-        // Initialize Asio
-        m_endpoint.init_asio();
-
-        // Set the default message handler to the echo handler
-        m_endpoint.set_message_handler(std::bind(
-            &utility_server::echo_handler, this,
-            std::placeholders::_1, std::placeholders::_2
-        ));
-    }
-
-    void echo_handler(websocketpp::connection_hdl hdl, server::message_ptr msg) {
-        // write a new message
-        m_endpoint.send(hdl, msg->get_payload(), msg->get_opcode());
-    }
-
-    void run() {
-        // Listen on port 9002
-        m_endpoint.listen(9002);
-
-        // Queues a connection accept operation
-        m_endpoint.start_accept();
-
-        // Start the Asio io_service run loop
-        m_endpoint.run();
-    }
-private:
-    server m_endpoint;
-};
-
-int main() {
-    utility_server s;
-    s.run();
-    return 0;
-}
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/utility_server.md b/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/utility_server.md
deleted file mode 100644
index 1c7ee3f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/tutorials/utility_server/utility_server.md
+++ /dev/null
@@ -1,181 +0,0 @@
-Utility Server Example Application Tutorial
-===========================================
-
-Introduction
-------------
-
-This tutorial provides a step by step discussion of building a basic WebSocket++ server. The final product of this tutorial is the utility_server example application from the example section. This server demonstrates the following features:
-
-- Use Asio Transport for networking
-- Accept multiple WebSocket connections at once
-- Read incoming messages and perform a few basic actions (echo, broadcast, telemetry, server commands) based on the path
-- Use validate handler to reject connections to invalid paths
-- Serve basic HTTP responses with the http handler
-- Gracefully exit the server
-- Encrypt connections with TLS
-
-This tutorial is current as of the 0.6.x version of the library.
-
-Chapter 1: Initial Setup & Basics
----------------------------------
-
-### Step 1
-
-_Add WebSocket++ includes and set up a a server endpoint type._
-
-WebSocket++ includes two major object types. The endpoint and the connection. The
-endpoint creates and launches new connections and maintains default settings for
-those connections. Endpoints also manage any shared network resources.
-
-The connection stores information specific to each WebSocket session.
-
-> **Note:** Once a connection is launched, there is no link between the endpoint and the connection. All default settings are copied into the new connection by the endpoint. Changing default settings on an endpoint will only affect future connections.
-Connections do not maintain a link back to their associated endpoint. Endpoints do not maintain a list of outstanding connections. If your application needs to iterate over all connections it will need to maintain a list of them itself.
-
-WebSocket++ endpoints are built by combining an endpoint role with an endpoint config. There are two different types of endpoint roles, one each for the client and server roles in a WebSocket session. This is a server tutorial so we will use the server role `websocketpp::server` which is provided by the `<websocketpp/server.hpp>` header.
-
-> #### Terminology: Endpoint Config
-> WebSocket++ endpoints have a group of settings that may be configured at compile time via the `config` template parameter. A config is a struct that contains types and static constants that are used to produce an endpoint with specific properties. Depending on which config is being used the endpoint will have different methods available and may have additional third party dependencies.
-
-The endpoint role takes a template parameter called `config` that is used to configure the behavior of endpoint at compile time. For this example we are going to use a default config provided by the library called `asio`, provided by `<websocketpp/config/asio_no_tls.hpp>`. This is a server config that uses the Asio library to provide network transport and does not support TLS based security. Later on we will discuss how to introduce TLS based security into a WebSocket++ application, more about the other stock configs, and how to build your own custom configs.
-
-Combine a config with an endpoint role to produce a fully configured endpoint. This type will be used frequently so I would recommend a typedef here.
-
-`typedef websocketpp::server<websocketpp::config::asio> server`
-
-#### `utility_server` constructor
-
-This endpoint type will be the base of the utility_server object that will keep track of the state of the server. Within the `utility_server` constructor several things happen:
-
-First, we adjust the endpoint logging behavior to include all error logging channels and all access logging channels except the frame payload, which is particularly noisy and generally useful only for debugging. [TODO: link to more information about logging]
-
-~~~{.cpp}
-m_endpoint.set_error_channels(websocketpp::log::elevel::all);
-m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
-~~~
-
-Next, we initialize the transport system underlying the endpoint. This method is specific to the Asio transport not WebSocket++ core. It will not be necessary or present in endpoints that use a non-asio config.
-
-> **Note:** This example uses an internal Asio `io_service` that is managed by the endpoint itself. This is a simple arrangement suitable for programs where WebSocket++ is the only code using Asio. If you have an existing program that already manages an `io_service` object or want to build a new program where WebSocket++ handlers share an io_service with other handlers you can pass the `io_service` you want WebSocket++ to register its handlers on to the `init_asio()` method and it will use it instead of generating and managing its own. [TODO: FAQ link instead?]
-
-~~~{.cpp}
-m_endpoint.init_asio();
-~~~
-
-#### `utility_server::run` method
-
-In addition to the constructor, we also add a run method that sets up the listening socket, begins accepting connections, starts the Asio io_service event loop.
-
-~~~{.cpp}
-// Listen on port 9002
-m_endpoint.listen(9002);
-
-// Queues a connection accept operation
-m_endpoint.start_accept();
-
-// Start the Asio io_service run loop
-m_endpoint.run();
-~~~
-
-The final line, `m_endpoint.run();`, will block until the endpoint is instructed to stop listening for new connections. While running it will listen for and process new connections as well as accept and process new data and control messages for existing connections. WebSocket++ uses Asio in an asyncronous mode where multiple connections can be similtaneously serviced efficiently within a single thread.
-
-#### Build
-Adding WebSocket++ has added a few dependencies to our program that must be addressed in the build system. Firstly, the WebSocket++ library headers need must be in the include search path of your build system. How exactly this is done depends on where you have the WebSocket++ headers installed what build system you are using.
-
-For the rest of this tutorial we are going to assume a C++11 build environment. WebSocket++ will work with pre-C++11 systems if your build system has access to a recent version of the Boost library headers.
-
-Finally, to use the Asio transport config we need to bring in the Asio library. There are two options here. If you have access to a C++11 build environment the standalone version from http://think-async.com is a good option. This header only library does not bring in any special dependencies and ensures you have the latest version of Asio. If you do not have a C++11 build environment or already have brought in the Boost libraries you can also use the version of Asio bundled with Boost.
-
-To use standalone Asio, make sure the Asio headers are in your include path and define ASIO_STANDALONE. To use Boost Asio, make sure the Boost headers are in your include path and that you are linking to the boost_system library.
-
-`c++ -std=c++11 step1.cpp` (Asio Standalone)
-OR
-`c++ -std=c++11 step1.cpp -lboost_system` (Boost Asio)
-
-#### Code so far
-```cpp
-// The ASIO_STANDALONE define is necessary to use the standalone version of Asio.
-// Remove if you are using Boost Asio.
-#define ASIO_STANDALONE
-
-#include <websocketpp/config/asio_no_tls.hpp>
-#include <websocketpp/server.hpp>
-
-#include <functional>
-
-typedef websocketpp::server<websocketpp::config::asio> server;
-
-class utility_server {
-public:
-    utility_server() {
-         // Set logging settings
-        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
-        m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
-
-        // Initialize Asio
-        m_endpoint.init_asio();
-    }
-
-    void run() {
-        // Listen on port 9002
-        m_endpoint.listen(9002);
-
-        // Queues a connection accept operation
-        m_endpoint.start_accept();
-
-        // Start the Asio io_service run loop
-        m_endpoint.run();
-    }
-private:
-    server m_endpoint;
-};
-
-int main() {
-    utility_server s;
-    s.run();
-    return 0;
-}
-```
-
-### Step 2
-
-_Set up a message handler to echo all replies back to the original user_
-
-#### Setting a message handler
-
-> ###### Terminology: Registering handlers
-> WebSocket++ provides a number of execution points where you can register to have a handler run. Which of these points are available to your endpoint will depend on its config. TLS handlers will not exist on non-TLS endpoints for example. A complete list of handlers can be found at  http://www.zaphoyd.com/websocketpp/manual/reference/handler-list.
->
-> Handlers can be registered at the endpoint level and at the connection level. Endpoint handlers are copied into new connections as they are created. Changing an endpoint handler will affect only future connections. Handlers registered at the connection level will be bound to that specific connection only.
->
-> The signature of handler binding methods is the same for endpoints and connections. The format is: `set_*_handler(...)`. Where * is the name of the handler. For example, `set_open_handler(...)` will set the handler to be called when a new connection is open. `set_fail_handler(...)` will set the handler to be called when a connection fails to connect.
->
-> All handlers take one argument, a callable type that can be converted to a `std::function` with the correct count and type of arguments. You can pass free functions, functors, and Lambdas with matching argument lists as handlers. In addition, you can use `std::bind` (or `boost::bind`) to register functions with non-matching argument lists. This is useful for passing additional parameters not present in the handler signature or member functions that need to carry a 'this' pointer.
->
-> The function signature of each handler can be looked up in the list above in the manual. In general, all handlers include the `connection_hdl` identifying which connection this even is associated with as the first parameter. Some handlers (such as the message handler) include additional parameters. Most handlers have a void return value but some (`validate`, `ping`, `tls_init`) do not. The specific meanings of the return values are documented in the handler list linked above.
-
-
-### Step 3
-
-_error handling_
-
-
-### Step 4
-
-_Set up open and close handlers and a connection data structure_
-
-### Step 5
-
-_Change the message handler for connections based on URI and add a validate handler to reject invalid URIs_
-
-### Step 6
-
-_Add some Admin commands (report total clients, cleanly shut down server)_
-
-### Step 7
-
-_Add some Broadcast commands_
-
-### Step 8
-
-_Add TLS_
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp-config.cmake.in b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp-config.cmake.in
deleted file mode 100644
index 3fbce3b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp-config.cmake.in
+++ /dev/null
@@ -1,14 +0,0 @@
-# - Config file for the websocketpp package
-# It defines the following variables
-#  WEBSOCKETPP_FOUND - indicates that the module was found
-#  WEBSOCKETPP_INCLUDE_DIR - include directories
-
-@PACKAGE_INIT@
-set_and_check(WEBSOCKETPP_INCLUDE_DIR "@PACKAGE_INSTALL_INCLUDE_DIR@")
-set(WEBSOCKETPP_FOUND TRUE)
-
-#This is a bit of a hack, but it works well. It also allows continued support of CMake 2.8
-if(${CMAKE_VERSION} VERSION_GREATER 3.0.0 OR ${CMAKE_VERSION} VERSION_EQUAL 3.0.0)
-  add_library(websocketpp::websocketpp INTERFACE IMPORTED)
-  set_target_properties(websocketpp::websocketpp PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${WEBSOCKETPP_INCLUDE_DIR}")
-endif()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/CMakeLists.txt b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/CMakeLists.txt
deleted file mode 100644
index 3ea8cc1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-init_target("websocketpp")
-final_target ()
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/base64/base64.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/base64/base64.hpp
deleted file mode 100644
index ff1561d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/base64/base64.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-    ******
-    base64.hpp is a repackaging of the base64.cpp and base64.h files into a
-    single header suitable for use as a header only library. This conversion was
-    done by Peter Thorson (webmaster@zaphoyd.com) in 2012. All modifications to
-    the code are redistributed under the same license as the original, which is
-    listed below.
-    ******
-
-   base64.cpp and base64.h
-
-   Copyright (C) 2004-2008 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-*/
-
-#ifndef _BASE64_HPP_
-#define _BASE64_HPP_
-
-#include <string>
-
-namespace websocketpp {
-
-static std::string const base64_chars =
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789+/";
-
-/// Test whether a character is a valid base64 character
-/**
- * @param c The character to test
- * @return true if c is a valid base64 character
- */
-static inline bool is_base64(unsigned char c) {
-    return (c == 43 || // +
-           (c >= 47 && c <= 57) || // /-9
-           (c >= 65 && c <= 90) || // A-Z
-           (c >= 97 && c <= 122)); // a-z
-}
-
-/// Encode a char buffer into a base64 string
-/**
- * @param input The input data
- * @param len The length of input in bytes
- * @return A base64 encoded string representing input
- */
-inline std::string base64_encode(unsigned char const * input, size_t len) {
-    std::string ret;
-    int i = 0;
-    int j = 0;
-    unsigned char char_array_3[3];
-    unsigned char char_array_4[4];
-
-    while (len--) {
-        char_array_3[i++] = *(input++);
-        if (i == 3) {
-            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) +
-                              ((char_array_3[1] & 0xf0) >> 4);
-            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) +
-                              ((char_array_3[2] & 0xc0) >> 6);
-            char_array_4[3] = char_array_3[2] & 0x3f;
-
-            for(i = 0; (i <4) ; i++) {
-                ret += base64_chars[char_array_4[i]];
-            }
-            i = 0;
-        }
-    }
-
-    if (i) {
-        for(j = i; j < 3; j++) {
-            char_array_3[j] = '\0';
-        }
-
-        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
-        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) +
-                          ((char_array_3[1] & 0xf0) >> 4);
-        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) +
-                          ((char_array_3[2] & 0xc0) >> 6);
-        char_array_4[3] = char_array_3[2] & 0x3f;
-
-        for (j = 0; (j < i + 1); j++) {
-            ret += base64_chars[char_array_4[j]];
-        }
-
-        while((i++ < 3)) {
-            ret += '=';
-        }
-    }
-
-    return ret;
-}
-
-/// Encode a string into a base64 string
-/**
- * @param input The input data
- * @return A base64 encoded string representing input
- */
-inline std::string base64_encode(std::string const & input) {
-    return base64_encode(
-        reinterpret_cast<const unsigned char *>(input.data()),
-        input.size()
-    );
-}
-
-/// Decode a base64 encoded string into a string of raw bytes
-/**
- * @param input The base64 encoded input data
- * @return A string representing the decoded raw bytes
- */
-inline std::string base64_decode(std::string const & input) {
-    size_t in_len = input.size();
-    int i = 0;
-    int j = 0;
-    int in_ = 0;
-    unsigned char char_array_4[4], char_array_3[3];
-    std::string ret;
-
-    while (in_len-- && ( input[in_] != '=') && is_base64(input[in_])) {
-        char_array_4[i++] = input[in_]; in_++;
-        if (i ==4) {
-            for (i = 0; i <4; i++) {
-                char_array_4[i] = static_cast<unsigned char>(base64_chars.find(char_array_4[i]));
-            }
-
-            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-            for (i = 0; (i < 3); i++) {
-                ret += char_array_3[i];
-            }
-            i = 0;
-        }
-    }
-
-    if (i) {
-        for (j = i; j <4; j++)
-            char_array_4[j] = 0;
-
-        for (j = 0; j <4; j++)
-            char_array_4[j] = static_cast<unsigned char>(base64_chars.find(char_array_4[j]));
-
-        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
-        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
-        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
-
-        for (j = 0; (j < i - 1); j++) {
-            ret += static_cast<std::string::value_type>(char_array_3[j]);
-        }
-    }
-
-    return ret;
-}
-
-} // namespace websocketpp
-
-#endif // _BASE64_HPP_
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/client.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/client.hpp
deleted file mode 100644
index 8782d7e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/client.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CLIENT_HPP
-#define WEBSOCKETPP_CLIENT_HPP
-
-#include <websocketpp/roles/client_endpoint.hpp>
-
-#endif //WEBSOCKETPP_CLIENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/close.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/close.hpp
deleted file mode 100644
index 276498e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/close.hpp
+++ /dev/null
@@ -1,353 +0,0 @@
-
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CLOSE_HPP
-#define WEBSOCKETPP_CLOSE_HPP
-
-/** \file
- * A package of types and methods for manipulating WebSocket close codes.
- */
-
-#include <websocketpp/error.hpp>
-#include <websocketpp/common/network.hpp>
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/utf8_validator.hpp>
-
-#include <string>
-
-namespace websocketpp {
-/// A package of types and methods for manipulating WebSocket close codes.
-namespace close {
-/// A package of types and methods for manipulating WebSocket close status'
-namespace status {
-    /// The type of a close code value.
-    typedef uint16_t value;
-
-    /// A blank value for internal use.
-    static value const blank = 0;
-
-    /// Close the connection without a WebSocket close handshake.
-    /**
-     * This special value requests that the WebSocket connection be closed
-     * without performing the WebSocket closing handshake. This does not comply
-     * with RFC6455, but should be safe to do if necessary. This could be useful
-     * for clients that need to disconnect quickly and cannot afford the
-     * complete handshake.
-     */
-    static value const omit_handshake = 1;
-
-    /// Close the connection with a forced TCP drop.
-    /**
-     * This special value requests that the WebSocket connection be closed by
-     * forcibly dropping the TCP connection. This will leave the other side of
-     * the connection with a broken connection and some expensive timeouts. this
-     * should not be done except in extreme cases or in cases of malicious
-     * remote endpoints.
-     */
-    static value const force_tcp_drop = 2;
-
-    /// Normal closure, meaning that the purpose for which the connection was
-    /// established has been fulfilled.
-    static value const normal = 1000;
-
-    /// The endpoint was "going away", such as a server going down or a browser
-    /// navigating away from a page.
-    static value const going_away = 1001;
-
-    /// A protocol error occurred.
-    static value const protocol_error = 1002;
-
-    /// The connection was terminated because an endpoint received a type of
-    /// data it cannot accept.
-    /**
-     * (e.g., an endpoint that understands only text data MAY send this if it
-     * receives a binary message).
-     */
-    static value const unsupported_data = 1003;
-
-    /// A dummy value to indicate that no status code was received.
-    /**
-     * This value is illegal on the wire.
-     */
-    static value const no_status = 1005;
-
-    /// A dummy value to indicate that the connection was closed abnormally.
-    /**
-     * In such a case there was no close frame to extract a value from. This
-     * value is illegal on the wire.
-     */
-    static value const abnormal_close = 1006;
-
-    /// An endpoint received message data inconsistent with its type.
-    /**
-     * For example: Invalid UTF8 bytes in a text message.
-     */
-    static value const invalid_payload = 1007;
-
-    /// An endpoint received a message that violated its policy.
-    /**
-     * This is a generic status code that can be returned when there is no other
-     * more suitable status code (e.g., 1003 or 1009) or if there is a need to
-     * hide specific details about the policy.
-     */
-    static value const policy_violation = 1008;
-
-    /// An endpoint received a message too large to process.
-    static value const message_too_big = 1009;
-
-    /// A client expected the server to accept a required extension request
-    /**
-     * The list of extensions that are needed SHOULD appear in the /reason/ part
-     * of the Close frame. Note that this status code is not used by the server,
-     * because it can fail the WebSocket handshake instead.
-     */
-    static value const extension_required = 1010;
-
-    /// An endpoint encountered an unexpected condition that prevented it from
-    /// fulfilling the request.
-    static value const internal_endpoint_error = 1011;
-
-    /// Indicates that the service is restarted. A client may reconnect and if
-    /// if it chooses to do so, should reconnect using a randomized delay of
-    /// 5-30s
-    static value const service_restart = 1012;
-
-    /// Indicates that the service is experiencing overload. A client should
-    /// only connect to a different IP (when there are multiple for the target)
-    /// or reconnect to the same IP upon user action.
-    static value const try_again_later = 1013;
-
-    /// Indicates that the server was acting as a gateway or proxy and received
-    /// an invalid response from the upstream server. This is similar to 502
-    /// HTTP Status Code.
-    static value const bad_gateway = 1014;
-
-    /// An endpoint failed to perform a TLS handshake
-    /**
-     * Designated for use in applications expecting a status code to indicate
-     * that the connection was closed due to a failure to perform a TLS
-     * handshake (e.g., the server certificate can't be verified). This value is
-     * illegal on the wire.
-     */
-    static value const tls_handshake = 1015;
-    
-    /// A generic subprotocol error
-    /**
-     * Indicates that a subprotocol error occurred. Typically this involves
-     * receiving a message that is not formatted as a valid message for the
-     * subprotocol in use.
-     */
-    static value const subprotocol_error = 3000;
-    
-    /// A invalid subprotocol data
-    /**
-     * Indicates that data was received that violated the specification of the
-     * subprotocol in use.
-     */
-    static value const invalid_subprotocol_data = 3001;
-
-    /// First value in range reserved for future protocol use
-    static value const rsv_start = 1016;
-    /// Last value in range reserved for future protocol use
-    static value const rsv_end = 2999;
-
-    /// Test whether a close code is in a reserved range
-    /**
-     * @param [in] code The code to test
-     * @return Whether or not code is reserved
-     */
-    inline bool reserved(value code) {
-        return ((code >= rsv_start && code <= rsv_end) ||
-                code == 1004);
-    }
-
-    /// First value in range that is always invalid on the wire
-    static value const invalid_low = 999;
-    /// Last value in range that is always invalid on the wire
-    static value const invalid_high = 5000;
-
-    /// Test whether a close code is invalid on the wire
-    /**
-     * @param [in] code The code to test
-     * @return Whether or not code is invalid on the wire
-     */
-    inline bool invalid(value code) {
-        return (code <= invalid_low || code >= invalid_high ||
-                code == no_status || code == abnormal_close ||
-                code == tls_handshake);
-    }
-
-    /// Determine if the code represents an unrecoverable error
-    /**
-     * There is a class of errors for which once they are discovered normal
-     * WebSocket functionality can no longer occur. This function determines
-     * if a given code is one of these values. This information is used to
-     * determine if the system has the capability of waiting for a close
-     * acknowledgement or if it should drop the TCP connection immediately
-     * after sending its close frame.
-     *
-     * @param [in] code The value to test.
-     * @return True if the code represents an unrecoverable error
-     */
-    inline bool terminal(value code) {
-        return (code == protocol_error || code == invalid_payload ||
-                code == policy_violation || code == message_too_big ||
-                 code == internal_endpoint_error);
-    }
-    
-    /// Return a human readable interpretation of a WebSocket close code
-    /**
-     * See https://tools.ietf.org/html/rfc6455#section-7.4 for more details.
-     *
-     * @since 0.3.0
-     *
-     * @param [in] code The code to look up.
-     * @return A human readable interpretation of the code.
-     */
-    inline std::string get_string(value code) {
-        switch (code) {
-            case normal:
-                return "Normal close";
-            case going_away:
-                return "Going away";
-            case protocol_error:
-                return "Protocol error";
-            case unsupported_data:
-                return "Unsupported data";
-            case no_status:
-                return "No status set";
-            case abnormal_close:
-                return "Abnormal close";
-            case invalid_payload:
-                return "Invalid payload";
-            case policy_violation:
-                return "Policy violoation";
-            case message_too_big:
-                return "Message too big";
-            case extension_required:
-                return "Extension required";
-            case internal_endpoint_error:
-                return "Internal endpoint error";
-            case service_restart:
-                return "Service restart";
-            case try_again_later:
-                return "Try again later";
-            case bad_gateway:
-                return "Bad gateway";
-            case tls_handshake:
-                return "TLS handshake failure";
-            case subprotocol_error:
-                return "Generic subprotocol error";
-            case invalid_subprotocol_data:
-                return "Invalid subprotocol data";
-            default:
-                return "Unknown";
-        }
-    }
-} // namespace status
-
-/// Type used to convert close statuses between integer and wire representations
-union code_converter {
-    uint16_t i;
-    char c[2];
-};
-
-/// Extract a close code value from a close payload
-/**
- * If there is no close value (ie string is empty) status::no_status is
- * returned. If a code couldn't be extracted (usually do to a short or
- * otherwise mangled payload) status::protocol_error is returned and the ec
- * value is flagged as an error. Note that this case is different than the case
- * where protocol error is received over the wire.
- *
- * If the value is in an invalid or reserved range ec is set accordingly.
- *
- * @param [in] payload Close frame payload value received over the wire.
- * @param [out] ec Set to indicate what error occurred, if any.
- * @return The extracted value
- */
-inline status::value extract_code(std::string const & payload, lib::error_code
-    & ec)
-{
-    ec = lib::error_code();
-
-    if (payload.size() == 0) {
-        return status::no_status;
-    } else if (payload.size() == 1) {
-        ec = make_error_code(error::bad_close_code);
-        return status::protocol_error;
-    }
-
-    code_converter val;
-
-    val.c[0] = payload[0];
-    val.c[1] = payload[1];
-
-    status::value code(ntohs(val.i));
-
-    if (status::invalid(code)) {
-        ec = make_error_code(error::invalid_close_code);
-    }
-
-    if (status::reserved(code)) {
-        ec = make_error_code(error::reserved_close_code);
-    }
-
-    return code;
-}
-
-/// Extract the reason string from a close payload
-/**
- * The string should be a valid UTF8 message. error::invalid_utf8 will be set if
- * the function extracts a reason that is not valid UTF8.
- *
- * @param [in] payload The payload string to extract a reason from.
- * @param [out] ec Set to indicate what error occurred, if any.
- * @return The reason string.
- */
-inline std::string extract_reason(std::string const & payload, lib::error_code
-    & ec)
-{
-    std::string reason;
-    ec = lib::error_code();
-
-    if (payload.size() > 2) {
-        reason.append(payload.begin()+2,payload.end());
-    }
-
-    if (!websocketpp::utf8_validator::validate(reason)) {
-        ec = make_error_code(error::invalid_utf8);
-    }
-
-    return reason;
-}
-
-} // namespace close
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CLOSE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio.hpp
deleted file mode 100644
index 3c8fa13..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio.hpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_ASIO_HPP
-#define WEBSOCKETPP_COMMON_ASIO_HPP
-
-// This file goes to some length to preserve compatibility with versions of 
-// boost older than 1.49 (where the first modern steady_timer timer based on 
-// boost/std chrono was introduced.
-//
-// For the versions older than 1.49, the deadline_timer is used instead. this
-// brings in dependencies on boost date_time and it has a different interface
-// that is normalized by the `lib::asio::is_neg` and `lib::asio::milliseconds`
-// wrappers provided by this file.
-//
-// The primary reason for this continued support is that boost 1.48 is the
-// default and not easily changeable version of boost supplied by the package
-// manager of popular Linux distributions like Ubuntu 12.04 LTS. Once the need
-// for this has passed this should be cleaned up and simplified.
-
-#ifdef ASIO_STANDALONE
-    #include <asio/version.hpp>
-    
-    #if (ASIO_VERSION/100000) == 1 && ((ASIO_VERSION/100)%1000) < 8
-        static_assert(false, "The minimum version of standalone Asio is 1.8.0");
-    #endif
-    
-    #include <asio.hpp>
-    #include <asio/steady_timer.hpp>
-    #include <websocketpp/common/chrono.hpp> 
-#else
-    #include <boost/version.hpp>
-    
-    // See note above about boost <1.49 compatibility. If we are running on 
-    // boost > 1.48 pull in the steady timer and chrono library
-    #if (BOOST_VERSION/100000) == 1 && ((BOOST_VERSION/100)%1000) > 48
-        #include <boost/asio/steady_timer.hpp>
-        #include <websocketpp/common/chrono.hpp>
-    #endif
-    
-    #include <boost/asio.hpp>
-    #include <boost/system/error_code.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef ASIO_STANDALONE
-    namespace asio {
-        using namespace ::asio;
-        // Here we assume that we will be using std::error_code with standalone
-        // Asio. This is probably a good assumption, but it is possible in rare
-        // cases that local Asio versions would be used.
-        using std::errc;
-        
-        // See note above about boost <1.49 compatibility. Because we require
-        // a standalone Asio version of 1.8+ we are guaranteed to have 
-        // steady_timer available. By convention we require the chrono library
-        // (either boost or std) for use with standalone Asio.
-        template <typename T>
-        bool is_neg(T duration) {
-            return duration.count() < 0;
-        }
-        inline lib::chrono::milliseconds milliseconds(long duration) {
-            return lib::chrono::milliseconds(duration);
-        }
-    } // namespace asio
-    
-#else
-    namespace asio {
-        using namespace boost::asio;
-        
-        // See note above about boost <1.49 compatibility
-        #if (BOOST_VERSION/100000) == 1 && ((BOOST_VERSION/100)%1000) > 48
-            // Using boost::asio >=1.49 so we use chrono and steady_timer
-            template <typename T>
-            bool is_neg(T duration) {
-                return duration.count() < 0;
-            }
-
-            // If boost believes it has std::chrono available it will use it
-            // so we should also use it for things that relate to boost, even
-            // if the library would otherwise use boost::chrono.
-            #if defined(BOOST_ASIO_HAS_STD_CHRONO)
-                inline std::chrono::milliseconds milliseconds(long duration) {
-                    return std::chrono::milliseconds(duration);
-                }
-            #else
-                inline lib::chrono::milliseconds milliseconds(long duration) {
-                    return lib::chrono::milliseconds(duration);
-                }
-            #endif
-        #else
-            // Using boost::asio <1.49 we pretend a deadline timer is a steady
-            // timer and wrap the negative detection and duration conversion
-            // appropriately.
-            typedef boost::asio::deadline_timer steady_timer;
-            
-            template <typename T>
-            bool is_neg(T duration) {
-                return duration.is_negative();
-            }
-            inline boost::posix_time::time_duration milliseconds(long duration) {
-                return boost::posix_time::milliseconds(duration);
-            }
-        #endif
-        
-        using boost::system::error_code;
-        namespace errc = boost::system::errc;
-    } // namespace asio
-#endif
-
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_ASIO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio_ssl.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio_ssl.hpp
deleted file mode 100644
index 6989283..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/asio_ssl.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_ASIO_SSL_HPP
-#define WEBSOCKETPP_COMMON_ASIO_SSL_HPP
-
-// NOTE: This file must be included before common/asio.hpp
-
-#ifdef ASIO_STANDALONE
-    #include <asio/ssl.hpp>
-#else
-    #include <boost/asio/ssl.hpp>
-#endif
-
-#endif // WEBSOCKETPP_COMMON_ASIO_SSL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/chrono.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/chrono.hpp
deleted file mode 100644
index 975ee04..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/chrono.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_CHRONO_HPP
-#define WEBSOCKETPP_COMMON_CHRONO_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 functional header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_CHRONO_
-    #ifndef _WEBSOCKETPP_CPP11_CHRONO_
-        #define _WEBSOCKETPP_CPP11_CHRONO_
-    #endif
-#endif
-
-// If we're on Visual Studio 2012 or higher and haven't explicitly disabled
-// the use of C++11 chrono header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1700 && !defined _WEBSOCKETPP_NO_CPP11_CHRONO_
-    #ifndef _WEBSOCKETPP_CPP11_CHRONO_
-        #define _WEBSOCKETPP_CPP11_CHRONO_
-    #endif
-#endif
-
-#ifdef _WEBSOCKETPP_CPP11_CHRONO_
-    #include <chrono>
-#else
-    #include <boost/chrono.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_CHRONO_
-    namespace chrono = std::chrono;
-#else
-    namespace chrono = boost::chrono;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_CHRONO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/connection_hdl.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/connection_hdl.hpp
deleted file mode 100644
index 1044c88..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/connection_hdl.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_CONNECTION_HDL_HPP
-#define WEBSOCKETPP_COMMON_CONNECTION_HDL_HPP
-
-#include <websocketpp/common/memory.hpp>
-
-namespace websocketpp {
-
-/// A handle to uniquely identify a connection.
-/**
- * This type uniquely identifies a connection. It is implemented as a weak
- * pointer to the connection in question. This provides uniqueness across
- * multiple endpoints and ensures that IDs never conflict or run out.
- *
- * It is safe to make copies of this handle, store those copies in containers,
- * and use them from other threads.
- *
- * This handle can be upgraded to a full shared_ptr using
- * `endpoint::get_con_from_hdl()` from within a handler fired by the connection
- * that owns the handler.
- */
-typedef lib::weak_ptr<void> connection_hdl;
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_CONNECTION_HDL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/cpp11.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/cpp11.hpp
deleted file mode 100644
index 492a3b8..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/cpp11.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_CPP11_HPP
-#define WEBSOCKETPP_COMMON_CPP11_HPP
-
-/**
- * This header sets up some constants based on the state of C++11 support
- */
-
-// Hide clang feature detection from other compilers
-#ifndef __has_feature         // Optional of course.
-  #define __has_feature(x) 0  // Compatibility with non-clang compilers.
-#endif
-#ifndef __has_extension
-  #define __has_extension __has_feature // Compatibility with pre-3.0 compilers.
-#endif
-
-// The code below attempts to use information provided by the build system or
-// user supplied defines to selectively enable C++11 language and library
-// features. In most cases features that are targeted individually may also be
-// selectively disabled via an associated _WEBSOCKETPP_NOXXX_ define.
-
-#if defined(_WEBSOCKETPP_CPP11_STL_) || __cplusplus >= 201103L || defined(_WEBSOCKETPP_CPP11_STRICT_)
-    // This check tests for blanket c++11 coverage. It can be activated in one
-    // of three ways. Either the compiler itself reports that it is a full 
-    // C++11 compiler via the __cplusplus macro or the user/build system
-    // supplies one of the two preprocessor defines below:
-    
-    // This is defined to allow other WebSocket++ common headers to enable
-    // C++11 features when they are detected by this file rather than
-    // duplicating the above logic in every common header.
-    #define _WEBSOCKETPP_CPP11_INTERNAL_
-    
-    // _WEBSOCKETPP_CPP11_STRICT_
-    //
-    // This define reports to WebSocket++ that 100% of the language and library
-    // features of C++11 are available. Using this define on a non-C++11
-    // compiler will result in problems.
-    
-    // _WEBSOCKETPP_CPP11_STL_ 
-    //
-    // This define enables *most* C++11 options that were implemented early on
-    // by compilers. It is typically used for compilers that have many, but not
-    // all C++11 features. It should be safe to use on GCC 4.7-4.8 and perhaps
-    // earlier. 
-    #ifndef _WEBSOCKETPP_NOEXCEPT_TOKEN_
-        #define _WEBSOCKETPP_NOEXCEPT_TOKEN_ noexcept
-    #endif
-    #ifndef _WEBSOCKETPP_CONSTEXPR_TOKEN_
-        #define _WEBSOCKETPP_CONSTEXPR_TOKEN_ constexpr
-    #endif
-    #ifndef _WEBSOCKETPP_INITIALIZER_LISTS_
-        #define _WEBSOCKETPP_INITIALIZER_LISTS_
-    #endif
-    #ifndef _WEBSOCKETPP_NULLPTR_TOKEN_
-        #define _WEBSOCKETPP_NULLPTR_TOKEN_ nullptr
-    #endif
-    #ifndef _WEBSOCKETPP_MOVE_SEMANTICS_
-        #define _WEBSOCKETPP_MOVE_SEMANTICS_
-    #endif
-    #ifndef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-        #define _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    #endif
-    
-    #ifndef __GNUC__
-        // GCC as of version 4.9 (latest) does not support std::put_time yet.
-        // so ignore it
-        #define _WEBSOCKETPP_PUTTIME_
-    #endif
-#else
-    // In the absence of a blanket define, try to use compiler versions or
-    // feature testing macros to selectively enable what we can.
-
-    // Test for noexcept
-    #ifndef _WEBSOCKETPP_NOEXCEPT_TOKEN_
-        #ifdef _WEBSOCKETPP_NOEXCEPT_
-            // build system says we have noexcept
-            #define _WEBSOCKETPP_NOEXCEPT_TOKEN_ noexcept
-        #else
-            #if __has_feature(cxx_noexcept)
-                // clang feature detect says we have noexcept
-                #define _WEBSOCKETPP_NOEXCEPT_TOKEN_ noexcept
-            #elif defined(_MSC_VER) && _MSC_VER >= 1900
-            	// Visual Studio 2015+ has noexcept
-                #define _WEBSOCKETPP_NOEXCEPT_TOKEN_ noexcept
-            #else
-                // assume we don't have noexcept
-                #define _WEBSOCKETPP_NOEXCEPT_TOKEN_
-            #endif
-        #endif
-    #endif
-
-    // Test for constexpr
-    #ifndef _WEBSOCKETPP_CONSTEXPR_TOKEN_
-        #ifdef _WEBSOCKETPP_CONSTEXPR_
-            // build system says we have constexpr
-            #define _WEBSOCKETPP_CONSTEXPR_TOKEN_ constexpr
-        #else
-            #if __has_feature(cxx_constexpr)
-                // clang feature detect says we have constexpr
-                #define _WEBSOCKETPP_CONSTEXPR_TOKEN_ constexpr
-            #elif defined(_MSC_VER) && _MSC_VER >= 1900
-            	// Visual Studio 2015+ has constexpr
-                #define _WEBSOCKETPP_CONSTEXPR_TOKEN_ constexpr
-            #else
-                // assume we don't have constexpr
-                #define _WEBSOCKETPP_CONSTEXPR_TOKEN_
-            #endif
-        #endif
-    #endif
-
-    // Enable initializer lists on clang when available.
-    #if __has_feature(cxx_generalized_initializers) && !defined(_WEBSOCKETPP_INITIALIZER_LISTS_)
-        #define _WEBSOCKETPP_INITIALIZER_LISTS_
-    #endif
-    
-    // Test for nullptr
-    #ifndef _WEBSOCKETPP_NULLPTR_TOKEN_
-        #ifdef _WEBSOCKETPP_NULLPTR_
-            // build system says we have nullptr
-            #define _WEBSOCKETPP_NULLPTR_TOKEN_ nullptr
-        #else
-            #if __has_feature(cxx_nullptr)
-                // clang feature detect says we have nullptr
-                #define _WEBSOCKETPP_NULLPTR_TOKEN_ nullptr
-            #elif defined(_MSC_VER) &&_MSC_VER >= 1600
-                // Visual Studio version that has nullptr
-                #define _WEBSOCKETPP_NULLPTR_TOKEN_ nullptr
-            #else
-                // assume we don't have nullptr
-                #define _WEBSOCKETPP_NULLPTR_TOKEN_ 0
-            #endif
-        #endif
-    #endif
-#endif
-
-#endif // WEBSOCKETPP_COMMON_CPP11_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/functional.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/functional.hpp
deleted file mode 100644
index d332dd1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/functional.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_FUNCTIONAL_HPP
-#define WEBSOCKETPP_COMMON_FUNCTIONAL_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 functional header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_FUNCTIONAL_
-    #ifndef _WEBSOCKETPP_CPP11_FUNCTIONAL_
-        #define _WEBSOCKETPP_CPP11_FUNCTIONAL_
-    #endif
-#endif
-
-// If we're on Visual Studio 2010 or higher and haven't explicitly disabled
-// the use of C++11 functional header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1600 && !defined _WEBSOCKETPP_NO_CPP11_FUNCTIONAL_
-    #ifndef _WEBSOCKETPP_CPP11_FUNCTIONAL_
-        #define _WEBSOCKETPP_CPP11_FUNCTIONAL_
-    #endif
-#endif
-
-
-
-#ifdef _WEBSOCKETPP_CPP11_FUNCTIONAL_
-    #include <functional>
-#else
-    #include <boost/bind.hpp>
-    #include <boost/function.hpp>
-    #include <boost/ref.hpp>
-#endif
-
-
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_FUNCTIONAL_
-    using std::function;
-    using std::bind;
-    using std::ref;
-    namespace placeholders = std::placeholders;
-
-    // There are some cases where a C++11 compiler balks at using std::ref
-    // but a C++03 compiler using boost function requires boost::ref. As such
-    // lib::ref is not useful in these cases. Instead this macro allows the use
-    // of boost::ref in the case of a boost compile or no reference wrapper at
-    // all in the case of a C++11 compile
-    #define _WEBSOCKETPP_REF(x) x
-
-    template <typename T>
-    void clear_function(T & x) {
-        x = nullptr;
-    }
-#else
-    using boost::function;
-    using boost::bind;
-    using boost::ref;
-    namespace placeholders {
-        /// \todo this feels hacky, is there a better way?
-        using ::_1;
-        using ::_2;
-        using ::_3;
-    }
-
-    // See above definition for more details on what this is and why it exists
-    #define _WEBSOCKETPP_REF(x) boost::ref(x)
-
-    template <typename T>
-    void clear_function(T & x) {
-        x.clear();
-    }
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_FUNCTIONAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/md5.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/md5.hpp
deleted file mode 100644
index 279725f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/md5.hpp
+++ /dev/null
@@ -1,448 +0,0 @@
-/*
-  md5.hpp is a reformulation of the md5.h and md5.c code from
-  http://www.opensource.apple.com/source/cups/cups-59/cups/md5.c to allow it to
-  function as a component of a header only library. This conversion was done by
-  Peter Thorson (webmaster@zaphoyd.com) in 2012 for the WebSocket++ project. The
-  changes are released under the same license as the original (listed below)
-*/
-/*
-  Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  L. Peter Deutsch
-  ghost@aladdin.com
-
- */
-/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
-/*
-  Independent implementation of MD5 (RFC 1321).
-
-  This code implements the MD5 Algorithm defined in RFC 1321, whose
-  text is available at
-    http://www.ietf.org/rfc/rfc1321.txt
-  The code is derived from the text of the RFC, including the test suite
-  (section A.5) but excluding the rest of Appendix A.  It does not include
-  any code or documentation that is identified in the RFC as being
-  copyrighted.
-
-  The original and principal author of md5.h is L. Peter Deutsch
-  <ghost@aladdin.com>.  Other authors are noted in the change history
-  that follows (in reverse chronological order):
-
-  2002-04-13 lpd Removed support for non-ANSI compilers; removed
-    references to Ghostscript; clarified derivation from RFC 1321;
-    now handles byte order either statically or dynamically.
-  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
-  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
-    added conditionalization for C++ compilation from Martin
-    Purschke <purschke@bnl.gov>.
-  1999-05-03 lpd Original version.
- */
-
-#ifndef WEBSOCKETPP_COMMON_MD5_HPP
-#define WEBSOCKETPP_COMMON_MD5_HPP
-
-/*
- * This package supports both compile-time and run-time determination of CPU
- * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
- * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
- * defined as non-zero, the code will be compiled to run only on big-endian
- * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
- * run on either big- or little-endian CPUs, but will run slightly less
- * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
- */
-
-#include <stddef.h>
-#include <string>
-#include <cstring>
-
-namespace websocketpp {
-/// Provides MD5 hashing functionality
-namespace md5 {
-
-typedef unsigned char md5_byte_t; /* 8-bit byte */
-typedef unsigned int md5_word_t; /* 32-bit word */
-
-/* Define the state of the MD5 Algorithm. */
-typedef struct md5_state_s {
-    md5_word_t count[2];    /* message length in bits, lsw first */
-    md5_word_t abcd[4];     /* digest buffer */
-    md5_byte_t buf[64];     /* accumulate block */
-} md5_state_t;
-
-/* Initialize the algorithm. */
-inline void md5_init(md5_state_t *pms);
-
-/* Append a string to the message. */
-inline void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t nbytes);
-
-/* Finish the message and return the digest. */
-inline void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
-
-#undef ZSW_MD5_BYTE_ORDER   /* 1 = big-endian, -1 = little-endian, 0 = unknown */
-#ifdef ARCH_IS_BIG_ENDIAN
-#  define ZSW_MD5_BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
-#else
-#  define ZSW_MD5_BYTE_ORDER 0
-#endif
-
-#define ZSW_MD5_T_MASK ((md5_word_t)~0)
-#define ZSW_MD5_T1 /* 0xd76aa478 */ (ZSW_MD5_T_MASK ^ 0x28955b87)
-#define ZSW_MD5_T2 /* 0xe8c7b756 */ (ZSW_MD5_T_MASK ^ 0x173848a9)
-#define ZSW_MD5_T3    0x242070db
-#define ZSW_MD5_T4 /* 0xc1bdceee */ (ZSW_MD5_T_MASK ^ 0x3e423111)
-#define ZSW_MD5_T5 /* 0xf57c0faf */ (ZSW_MD5_T_MASK ^ 0x0a83f050)
-#define ZSW_MD5_T6    0x4787c62a
-#define ZSW_MD5_T7 /* 0xa8304613 */ (ZSW_MD5_T_MASK ^ 0x57cfb9ec)
-#define ZSW_MD5_T8 /* 0xfd469501 */ (ZSW_MD5_T_MASK ^ 0x02b96afe)
-#define ZSW_MD5_T9    0x698098d8
-#define ZSW_MD5_T10 /* 0x8b44f7af */ (ZSW_MD5_T_MASK ^ 0x74bb0850)
-#define ZSW_MD5_T11 /* 0xffff5bb1 */ (ZSW_MD5_T_MASK ^ 0x0000a44e)
-#define ZSW_MD5_T12 /* 0x895cd7be */ (ZSW_MD5_T_MASK ^ 0x76a32841)
-#define ZSW_MD5_T13    0x6b901122
-#define ZSW_MD5_T14 /* 0xfd987193 */ (ZSW_MD5_T_MASK ^ 0x02678e6c)
-#define ZSW_MD5_T15 /* 0xa679438e */ (ZSW_MD5_T_MASK ^ 0x5986bc71)
-#define ZSW_MD5_T16    0x49b40821
-#define ZSW_MD5_T17 /* 0xf61e2562 */ (ZSW_MD5_T_MASK ^ 0x09e1da9d)
-#define ZSW_MD5_T18 /* 0xc040b340 */ (ZSW_MD5_T_MASK ^ 0x3fbf4cbf)
-#define ZSW_MD5_T19    0x265e5a51
-#define ZSW_MD5_T20 /* 0xe9b6c7aa */ (ZSW_MD5_T_MASK ^ 0x16493855)
-#define ZSW_MD5_T21 /* 0xd62f105d */ (ZSW_MD5_T_MASK ^ 0x29d0efa2)
-#define ZSW_MD5_T22    0x02441453
-#define ZSW_MD5_T23 /* 0xd8a1e681 */ (ZSW_MD5_T_MASK ^ 0x275e197e)
-#define ZSW_MD5_T24 /* 0xe7d3fbc8 */ (ZSW_MD5_T_MASK ^ 0x182c0437)
-#define ZSW_MD5_T25    0x21e1cde6
-#define ZSW_MD5_T26 /* 0xc33707d6 */ (ZSW_MD5_T_MASK ^ 0x3cc8f829)
-#define ZSW_MD5_T27 /* 0xf4d50d87 */ (ZSW_MD5_T_MASK ^ 0x0b2af278)
-#define ZSW_MD5_T28    0x455a14ed
-#define ZSW_MD5_T29 /* 0xa9e3e905 */ (ZSW_MD5_T_MASK ^ 0x561c16fa)
-#define ZSW_MD5_T30 /* 0xfcefa3f8 */ (ZSW_MD5_T_MASK ^ 0x03105c07)
-#define ZSW_MD5_T31    0x676f02d9
-#define ZSW_MD5_T32 /* 0x8d2a4c8a */ (ZSW_MD5_T_MASK ^ 0x72d5b375)
-#define ZSW_MD5_T33 /* 0xfffa3942 */ (ZSW_MD5_T_MASK ^ 0x0005c6bd)
-#define ZSW_MD5_T34 /* 0x8771f681 */ (ZSW_MD5_T_MASK ^ 0x788e097e)
-#define ZSW_MD5_T35    0x6d9d6122
-#define ZSW_MD5_T36 /* 0xfde5380c */ (ZSW_MD5_T_MASK ^ 0x021ac7f3)
-#define ZSW_MD5_T37 /* 0xa4beea44 */ (ZSW_MD5_T_MASK ^ 0x5b4115bb)
-#define ZSW_MD5_T38    0x4bdecfa9
-#define ZSW_MD5_T39 /* 0xf6bb4b60 */ (ZSW_MD5_T_MASK ^ 0x0944b49f)
-#define ZSW_MD5_T40 /* 0xbebfbc70 */ (ZSW_MD5_T_MASK ^ 0x4140438f)
-#define ZSW_MD5_T41    0x289b7ec6
-#define ZSW_MD5_T42 /* 0xeaa127fa */ (ZSW_MD5_T_MASK ^ 0x155ed805)
-#define ZSW_MD5_T43 /* 0xd4ef3085 */ (ZSW_MD5_T_MASK ^ 0x2b10cf7a)
-#define ZSW_MD5_T44    0x04881d05
-#define ZSW_MD5_T45 /* 0xd9d4d039 */ (ZSW_MD5_T_MASK ^ 0x262b2fc6)
-#define ZSW_MD5_T46 /* 0xe6db99e5 */ (ZSW_MD5_T_MASK ^ 0x1924661a)
-#define ZSW_MD5_T47    0x1fa27cf8
-#define ZSW_MD5_T48 /* 0xc4ac5665 */ (ZSW_MD5_T_MASK ^ 0x3b53a99a)
-#define ZSW_MD5_T49 /* 0xf4292244 */ (ZSW_MD5_T_MASK ^ 0x0bd6ddbb)
-#define ZSW_MD5_T50    0x432aff97
-#define ZSW_MD5_T51 /* 0xab9423a7 */ (ZSW_MD5_T_MASK ^ 0x546bdc58)
-#define ZSW_MD5_T52 /* 0xfc93a039 */ (ZSW_MD5_T_MASK ^ 0x036c5fc6)
-#define ZSW_MD5_T53    0x655b59c3
-#define ZSW_MD5_T54 /* 0x8f0ccc92 */ (ZSW_MD5_T_MASK ^ 0x70f3336d)
-#define ZSW_MD5_T55 /* 0xffeff47d */ (ZSW_MD5_T_MASK ^ 0x00100b82)
-#define ZSW_MD5_T56 /* 0x85845dd1 */ (ZSW_MD5_T_MASK ^ 0x7a7ba22e)
-#define ZSW_MD5_T57    0x6fa87e4f
-#define ZSW_MD5_T58 /* 0xfe2ce6e0 */ (ZSW_MD5_T_MASK ^ 0x01d3191f)
-#define ZSW_MD5_T59 /* 0xa3014314 */ (ZSW_MD5_T_MASK ^ 0x5cfebceb)
-#define ZSW_MD5_T60    0x4e0811a1
-#define ZSW_MD5_T61 /* 0xf7537e82 */ (ZSW_MD5_T_MASK ^ 0x08ac817d)
-#define ZSW_MD5_T62 /* 0xbd3af235 */ (ZSW_MD5_T_MASK ^ 0x42c50dca)
-#define ZSW_MD5_T63    0x2ad7d2bb
-#define ZSW_MD5_T64 /* 0xeb86d391 */ (ZSW_MD5_T_MASK ^ 0x14792c6e)
-
-static void md5_process(md5_state_t *pms, md5_byte_t const * data /*[64]*/) {
-    md5_word_t
-    a = pms->abcd[0], b = pms->abcd[1],
-    c = pms->abcd[2], d = pms->abcd[3];
-    md5_word_t t;
-#if ZSW_MD5_BYTE_ORDER > 0
-    /* Define storage only for big-endian CPUs. */
-    md5_word_t X[16];
-#else
-    /* Define storage for little-endian or both types of CPUs. */
-    md5_word_t xbuf[16];
-    md5_word_t const * X;
-#endif
-
-    {
-#if ZSW_MD5_BYTE_ORDER == 0
-    /*
-     * Determine dynamically whether this is a big-endian or
-     * little-endian machine, since we can use a more efficient
-     * algorithm on the latter.
-     */
-    static int const w = 1;
-
-    if (*((md5_byte_t const *)&w)) /* dynamic little-endian */
-#endif
-#if ZSW_MD5_BYTE_ORDER <= 0     /* little-endian */
-    {
-        /*
-         * On little-endian machines, we can process properly aligned
-         * data without copying it.
-         */
-        if (!((data - (md5_byte_t const *)0) & 3)) {
-        /* data are properly aligned */
-        X = (md5_word_t const *)data;
-        } else {
-        /* not aligned */
-        std::memcpy(xbuf, data, 64);
-        X = xbuf;
-        }
-    }
-#endif
-#if ZSW_MD5_BYTE_ORDER == 0
-    else            /* dynamic big-endian */
-#endif
-#if ZSW_MD5_BYTE_ORDER >= 0     /* big-endian */
-    {
-        /*
-         * On big-endian machines, we must arrange the bytes in the
-         * right order.
-         */
-        const md5_byte_t *xp = data;
-        int i;
-
-#  if ZSW_MD5_BYTE_ORDER == 0
-        X = xbuf;       /* (dynamic only) */
-#  else
-#    define xbuf X      /* (static only) */
-#  endif
-        for (i = 0; i < 16; ++i, xp += 4)
-        xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
-    }
-#endif
-    }
-
-#define ZSW_MD5_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
-
-    /* Round 1. */
-    /* Let [abcd k s i] denote the operation
-       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
-#define ZSW_MD5_F(x, y, z) (((x) & (y)) | (~(x) & (z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + ZSW_MD5_F(b,c,d) + X[k] + Ti;\
-  a = ZSW_MD5_ROTATE_LEFT(t, s) + b
-    /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  7,  ZSW_MD5_T1);
-    SET(d, a, b, c,  1, 12,  ZSW_MD5_T2);
-    SET(c, d, a, b,  2, 17,  ZSW_MD5_T3);
-    SET(b, c, d, a,  3, 22,  ZSW_MD5_T4);
-    SET(a, b, c, d,  4,  7,  ZSW_MD5_T5);
-    SET(d, a, b, c,  5, 12,  ZSW_MD5_T6);
-    SET(c, d, a, b,  6, 17,  ZSW_MD5_T7);
-    SET(b, c, d, a,  7, 22,  ZSW_MD5_T8);
-    SET(a, b, c, d,  8,  7,  ZSW_MD5_T9);
-    SET(d, a, b, c,  9, 12, ZSW_MD5_T10);
-    SET(c, d, a, b, 10, 17, ZSW_MD5_T11);
-    SET(b, c, d, a, 11, 22, ZSW_MD5_T12);
-    SET(a, b, c, d, 12,  7, ZSW_MD5_T13);
-    SET(d, a, b, c, 13, 12, ZSW_MD5_T14);
-    SET(c, d, a, b, 14, 17, ZSW_MD5_T15);
-    SET(b, c, d, a, 15, 22, ZSW_MD5_T16);
-#undef SET
-
-     /* Round 2. */
-     /* Let [abcd k s i] denote the operation
-          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
-#define ZSW_MD5_G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + ZSW_MD5_G(b,c,d) + X[k] + Ti;\
-  a = ZSW_MD5_ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  1,  5, ZSW_MD5_T17);
-    SET(d, a, b, c,  6,  9, ZSW_MD5_T18);
-    SET(c, d, a, b, 11, 14, ZSW_MD5_T19);
-    SET(b, c, d, a,  0, 20, ZSW_MD5_T20);
-    SET(a, b, c, d,  5,  5, ZSW_MD5_T21);
-    SET(d, a, b, c, 10,  9, ZSW_MD5_T22);
-    SET(c, d, a, b, 15, 14, ZSW_MD5_T23);
-    SET(b, c, d, a,  4, 20, ZSW_MD5_T24);
-    SET(a, b, c, d,  9,  5, ZSW_MD5_T25);
-    SET(d, a, b, c, 14,  9, ZSW_MD5_T26);
-    SET(c, d, a, b,  3, 14, ZSW_MD5_T27);
-    SET(b, c, d, a,  8, 20, ZSW_MD5_T28);
-    SET(a, b, c, d, 13,  5, ZSW_MD5_T29);
-    SET(d, a, b, c,  2,  9, ZSW_MD5_T30);
-    SET(c, d, a, b,  7, 14, ZSW_MD5_T31);
-    SET(b, c, d, a, 12, 20, ZSW_MD5_T32);
-#undef SET
-
-     /* Round 3. */
-     /* Let [abcd k s t] denote the operation
-          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
-#define ZSW_MD5_H(x, y, z) ((x) ^ (y) ^ (z))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + ZSW_MD5_H(b,c,d) + X[k] + Ti;\
-  a = ZSW_MD5_ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  5,  4, ZSW_MD5_T33);
-    SET(d, a, b, c,  8, 11, ZSW_MD5_T34);
-    SET(c, d, a, b, 11, 16, ZSW_MD5_T35);
-    SET(b, c, d, a, 14, 23, ZSW_MD5_T36);
-    SET(a, b, c, d,  1,  4, ZSW_MD5_T37);
-    SET(d, a, b, c,  4, 11, ZSW_MD5_T38);
-    SET(c, d, a, b,  7, 16, ZSW_MD5_T39);
-    SET(b, c, d, a, 10, 23, ZSW_MD5_T40);
-    SET(a, b, c, d, 13,  4, ZSW_MD5_T41);
-    SET(d, a, b, c,  0, 11, ZSW_MD5_T42);
-    SET(c, d, a, b,  3, 16, ZSW_MD5_T43);
-    SET(b, c, d, a,  6, 23, ZSW_MD5_T44);
-    SET(a, b, c, d,  9,  4, ZSW_MD5_T45);
-    SET(d, a, b, c, 12, 11, ZSW_MD5_T46);
-    SET(c, d, a, b, 15, 16, ZSW_MD5_T47);
-    SET(b, c, d, a,  2, 23, ZSW_MD5_T48);
-#undef SET
-
-     /* Round 4. */
-     /* Let [abcd k s t] denote the operation
-          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
-#define ZSW_MD5_I(x, y, z) ((y) ^ ((x) | ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + ZSW_MD5_I(b,c,d) + X[k] + Ti;\
-  a = ZSW_MD5_ROTATE_LEFT(t, s) + b
-     /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  6, ZSW_MD5_T49);
-    SET(d, a, b, c,  7, 10, ZSW_MD5_T50);
-    SET(c, d, a, b, 14, 15, ZSW_MD5_T51);
-    SET(b, c, d, a,  5, 21, ZSW_MD5_T52);
-    SET(a, b, c, d, 12,  6, ZSW_MD5_T53);
-    SET(d, a, b, c,  3, 10, ZSW_MD5_T54);
-    SET(c, d, a, b, 10, 15, ZSW_MD5_T55);
-    SET(b, c, d, a,  1, 21, ZSW_MD5_T56);
-    SET(a, b, c, d,  8,  6, ZSW_MD5_T57);
-    SET(d, a, b, c, 15, 10, ZSW_MD5_T58);
-    SET(c, d, a, b,  6, 15, ZSW_MD5_T59);
-    SET(b, c, d, a, 13, 21, ZSW_MD5_T60);
-    SET(a, b, c, d,  4,  6, ZSW_MD5_T61);
-    SET(d, a, b, c, 11, 10, ZSW_MD5_T62);
-    SET(c, d, a, b,  2, 15, ZSW_MD5_T63);
-    SET(b, c, d, a,  9, 21, ZSW_MD5_T64);
-#undef SET
-
-     /* Then perform the following additions. (That is increment each
-        of the four registers by the value it had before this block
-        was started.) */
-    pms->abcd[0] += a;
-    pms->abcd[1] += b;
-    pms->abcd[2] += c;
-    pms->abcd[3] += d;
-}
-
-void md5_init(md5_state_t *pms) {
-    pms->count[0] = pms->count[1] = 0;
-    pms->abcd[0] = 0x67452301;
-    pms->abcd[1] = /*0xefcdab89*/ ZSW_MD5_T_MASK ^ 0x10325476;
-    pms->abcd[2] = /*0x98badcfe*/ ZSW_MD5_T_MASK ^ 0x67452301;
-    pms->abcd[3] = 0x10325476;
-}
-
-void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t nbytes) {
-    md5_byte_t const * p = data;
-    size_t left = nbytes;
-    int offset = (pms->count[0] >> 3) & 63;
-    md5_word_t nbits = (md5_word_t)(nbytes << 3);
-
-    if (nbytes <= 0)
-    return;
-
-    /* Update the message length. */
-    pms->count[1] += nbytes >> 29;
-    pms->count[0] += nbits;
-    if (pms->count[0] < nbits)
-    pms->count[1]++;
-
-    /* Process an initial partial block. */
-    if (offset) {
-    int copy = (offset + nbytes > 64 ? 64 - offset : static_cast<int>(nbytes));
-
-    std::memcpy(pms->buf + offset, p, copy);
-    if (offset + copy < 64)
-        return;
-    p += copy;
-    left -= copy;
-    md5_process(pms, pms->buf);
-    }
-
-    /* Process full blocks. */
-    for (; left >= 64; p += 64, left -= 64)
-    md5_process(pms, p);
-
-    /* Process a final partial block. */
-    if (left)
-    std::memcpy(pms->buf, p, left);
-}
-
-void md5_finish(md5_state_t *pms, md5_byte_t digest[16]) {
-    static md5_byte_t const pad[64] = {
-    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    };
-    md5_byte_t data[8];
-    int i;
-
-    /* Save the length before padding. */
-    for (i = 0; i < 8; ++i)
-    data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
-    /* Pad to 56 bytes mod 64. */
-    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
-    /* Append the length. */
-    md5_append(pms, data, 8);
-    for (i = 0; i < 16; ++i)
-    digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
-}
-
-// some convenience c++ functions
-inline std::string md5_hash_string(std::string const & s) {
-    char digest[16];
-
-    md5_state_t state;
-
-    md5_init(&state);
-    md5_append(&state, (md5_byte_t const *)s.c_str(), s.size());
-    md5_finish(&state, (md5_byte_t *)digest);
-
-    std::string ret;
-    ret.resize(16);
-    std::copy(digest,digest+16,ret.begin());
-
-    return ret;
-}
-
-const char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
-
-inline std::string md5_hash_hex(std::string const & input) {
-    std::string hash = md5_hash_string(input);
-    std::string hex;
-
-    for (size_t i = 0; i < hash.size(); i++) {
-        hex.push_back(hexval[((hash[i] >> 4) & 0xF)]);
-        hex.push_back(hexval[(hash[i]) & 0x0F]);
-    }
-
-    return hex;
-}
-
-} // md5
-} // websocketpp
-
-#endif // WEBSOCKETPP_COMMON_MD5_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/memory.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/memory.hpp
deleted file mode 100644
index 42048e3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/memory.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_MEMORY_HPP
-#define WEBSOCKETPP_COMMON_MEMORY_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 memory header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_MEMORY_
-    #ifndef _WEBSOCKETPP_CPP11_MEMORY_
-        #define _WEBSOCKETPP_CPP11_MEMORY_
-    #endif
-#endif
-
-// If we're on Visual Studio 2010 or higher and haven't explicitly disabled
-// the use of C++11 functional header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1600 && !defined _WEBSOCKETPP_NO_CPP11_MEMORY_
-    #ifndef _WEBSOCKETPP_CPP11_MEMORY_
-        #define _WEBSOCKETPP_CPP11_MEMORY_
-    #endif
-#endif
-
-
-
-#ifdef _WEBSOCKETPP_CPP11_MEMORY_
-    #include <memory>
-#else
-    #include <boost/shared_ptr.hpp>
-	#include <boost/make_shared.hpp>
-    #include <boost/scoped_array.hpp>
-    #include <boost/enable_shared_from_this.hpp>
-    #include <boost/pointer_cast.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_MEMORY_
-    using std::shared_ptr;
-    using std::weak_ptr;
-    using std::enable_shared_from_this;
-    using std::static_pointer_cast;
-    using std::make_shared;
-    using std::unique_ptr;
-
-    typedef std::unique_ptr<unsigned char[]> unique_ptr_uchar_array;
-#else
-    using boost::shared_ptr;
-    using boost::weak_ptr;
-    using std::auto_ptr;
-    using boost::enable_shared_from_this;
-    using boost::static_pointer_cast;
-    using boost::make_shared;
-
-    typedef boost::scoped_array<unsigned char> unique_ptr_uchar_array;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_MEMORY_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/network.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/network.hpp
deleted file mode 100644
index 26a4cb9..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/network.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_NETWORK_HPP
-#define WEBSOCKETPP_COMMON_NETWORK_HPP
-
-// For ntohs and htons
-#if defined(_WIN32)
-    #include <winsock2.h>
-#else
-    //#include <arpa/inet.h>
-    #include <netinet/in.h>
-#endif
-
-#include <websocketpp/common/stdint.hpp>
-
-namespace websocketpp {
-namespace lib {
-namespace net {
-
-inline bool is_little_endian() {
-    short int val = 0x1;
-    char *ptr = reinterpret_cast<char *>(&val);
-    return (ptr[0] == 1);
-}
-
-#define TYP_INIT 0
-#define TYP_SMLE 1
-#define TYP_BIGE 2
-
-/// Convert 64 bit value to network byte order
-/**
- * This method is prefixed to avoid conflicts with operating system level
- * macros for this functionality.
- *
- * TODO: figure out if it would be beneficial to use operating system level
- * macros for this.
- *
- * @param src The integer in host byte order
- * @return src converted to network byte order
- */
-inline uint64_t _htonll(uint64_t src) {
-    static int typ = TYP_INIT;
-    unsigned char c;
-    union {
-        uint64_t ull;
-        unsigned char c[8];
-    } x;
-    if (typ == TYP_INIT) {
-        x.ull = 0x01;
-        typ = (x.c[7] == 0x01ULL) ? TYP_BIGE : TYP_SMLE;
-    }
-    if (typ == TYP_BIGE)
-        return src;
-    x.ull = src;
-    c = x.c[0]; x.c[0] = x.c[7]; x.c[7] = c;
-    c = x.c[1]; x.c[1] = x.c[6]; x.c[6] = c;
-    c = x.c[2]; x.c[2] = x.c[5]; x.c[5] = c;
-    c = x.c[3]; x.c[3] = x.c[4]; x.c[4] = c;
-    return x.ull;
-}
-
-/// Convert 64 bit value to host byte order
-/**
- * This method is prefixed to avoid conflicts with operating system level
- * macros for this functionality.
- *
- * TODO: figure out if it would be beneficial to use operating system level
- * macros for this.
- *
- * @param src The integer in network byte order
- * @return src converted to host byte order
- */
-inline uint64_t _ntohll(uint64_t src) {
-    return _htonll(src);
-}
-
-} // net
-} // lib
-} // websocketpp
-
-#endif // WEBSOCKETPP_COMMON_NETWORK_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/platforms.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/platforms.hpp
deleted file mode 100644
index 8779857..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/platforms.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_PLATFORMS_HPP
-#define WEBSOCKETPP_COMMON_PLATFORMS_HPP
-
-/**
- * This header contains any platform specific preprocessor adjustments that
- * don't fit somewhere else better.
- */
-
-#if defined(_WIN32) && !defined(NOMINMAX)
-    // don't define min and max macros that conflict with std::min and std::max
-    #define NOMINMAX
-#endif
-
-// Bump up the variadic parameter max for Visual Studio 2012
-#if defined(_MSC_VER) && _MSC_VER == 1700
-    #define _VARIADIC_MAX 8
-#endif
-
-#endif // WEBSOCKETPP_COMMON_PLATFORMS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/random.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/random.hpp
deleted file mode 100644
index ddf9969..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/random.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_RANDOM_DEVICE_HPP
-#define WEBSOCKETPP_COMMON_RANDOM_DEVICE_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 random header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_RANDOM_DEVICE_
-    #ifndef _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-        #define _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-    #endif
-#endif
-
-
-// If we're on Visual Studio 2010 or higher and haven't explicitly disabled
-// the use of C++11 random header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1600 && !defined _WEBSOCKETPP_NO_CPP11_MEMORY_
-    #ifndef _WEBSOCKETPP_CPP11_MEMORY_
-        #define _WEBSOCKETPP_CPP11_MEMORY_
-    #endif
-#endif
-
-
-
-#ifdef _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-    #include <random>
-#else
-    #include <boost/version.hpp>
-
-    #if (BOOST_VERSION/100000) == 1 && ((BOOST_VERSION/100)%1000) > 46
-        #include <boost/random/uniform_int_distribution.hpp>
-        #include <boost/random/random_device.hpp>
-    #elif (BOOST_VERSION/100000) == 1 && ((BOOST_VERSION/100)%1000) >= 43
-        #include <boost/nondet_random.hpp>
-    #else
-        // TODO: static_assert(false, "Could not find a suitable random_device")
-    #endif
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-    using std::random_device;
-    using std::uniform_int_distribution;
-#else
-    using boost::random::random_device;
-    using boost::random::uniform_int_distribution;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_RANDOM_DEVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/regex.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/regex.hpp
deleted file mode 100644
index 326635d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/regex.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_REGEX_HPP
-#define WEBSOCKETPP_COMMON_REGEX_HPP
-
-#if defined _WEBSOCKETPP_CPP11_STL_ && !defined _WEBSOCKETPP_NO_CPP11_REGEX_
-    #ifndef _WEBSOCKETPP_CPP11_REGEX_
-        #define _WEBSOCKETPP_CPP11_REGEX_
-    #endif
-#endif
-
-#ifdef _WEBSOCKETPP_CPP11_REGEX_
-    #include <regex>
-#else
-    #include <boost/regex.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_REGEX_
-    using std::cmatch;
-    using std::regex;
-    using std::regex_match;
-#else
-    using boost::cmatch;
-    using boost::regex;
-    using boost::regex_match;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_REGEX_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/stdint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/stdint.hpp
deleted file mode 100644
index ec48ea7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/stdint.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_STDINT_HPP
-#define WEBSOCKETPP_COMMON_STDINT_HPP
-
-#ifndef __STDC_LIMIT_MACROS
-    #define __STDC_LIMIT_MACROS 1
-#endif
-
-#if defined (_WIN32) && defined (_MSC_VER) && (_MSC_VER < 1600)
-    #include <boost/cstdint.hpp>
-
-    using boost::int8_t;
-    using boost::int_least8_t;
-    using boost::int_fast8_t;
-    using boost::uint8_t;
-    using boost::uint_least8_t;
-    using boost::uint_fast8_t;
-
-    using boost::int16_t;
-    using boost::int_least16_t;
-    using boost::int_fast16_t;
-    using boost::uint16_t;
-    using boost::uint_least16_t;
-    using boost::uint_fast16_t;
-
-    using boost::int32_t;
-    using boost::int_least32_t;
-    using boost::int_fast32_t;
-    using boost::uint32_t;
-    using boost::uint_least32_t;
-    using boost::uint_fast32_t;
-
-    #ifndef BOOST_NO_INT64_T
-    using boost::int64_t;
-    using boost::int_least64_t;
-    using boost::int_fast64_t;
-    using boost::uint64_t;
-    using boost::uint_least64_t;
-    using boost::uint_fast64_t;
-    #endif
-    using boost::intmax_t;
-    using boost::uintmax_t;
-#else
-    #include <stdint.h>
-#endif
-
-#endif // WEBSOCKETPP_COMMON_STDINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/system_error.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/system_error.hpp
deleted file mode 100644
index e5aea25..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/system_error.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_SYSTEM_ERROR_HPP
-#define WEBSOCKETPP_COMMON_SYSTEM_ERROR_HPP
-
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 system_error header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_SYSTEM_ERROR_
-    #ifndef _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-        #define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-    #endif
-#endif
-
-// If we're on Visual Studio 2010 or higher and haven't explicitly disabled
-// the use of C++11 system_error header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1600 && !defined _WEBSOCKETPP_NO_CPP11_SYSTEM_ERROR_
-    #ifndef _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-        #define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-    #endif
-#endif
-
-
-
-#ifdef _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-    #include <system_error>
-#else
-    #include <boost/system/error_code.hpp>
-    #include <boost/system/system_error.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-    using std::errc;
-    using std::error_code;
-    using std::error_category;
-    using std::error_condition;
-    using std::system_error;
-    #define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_ namespace std {
-    #define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_ }
-#else
-    namespace errc = boost::system::errc;
-    using boost::system::error_code;
-    using boost::system::error_category;
-    using boost::system::error_condition;
-    using boost::system::system_error;
-    #define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_ namespace boost { namespace system {
-    #define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_ }}
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_SYSTEM_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/thread.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/thread.hpp
deleted file mode 100644
index 1b0472a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/thread.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_THREAD_HPP
-#define WEBSOCKETPP_COMMON_THREAD_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we autodetect C++11 and haven't been explicitly instructed to not use
-// C++11 threads, then set the defines that instructs the rest of this header
-// to use C++11 <thread> and <mutex>
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_THREAD_
-    // MinGW by default does not support C++11 thread/mutex so even if the
-    // internal check for C++11 passes, ignore it if we are on MinGW
-    #if (!defined(__MINGW32__) && !defined(__MINGW64__))
-        #ifndef _WEBSOCKETPP_CPP11_THREAD_
-            #define _WEBSOCKETPP_CPP11_THREAD_
-        #endif
-    #endif
-#endif
-
-// If we're on Visual Studio 2013 or higher and haven't explicitly disabled
-// the use of C++11 thread header then prefer it to boost.
-#if defined(_MSC_VER) && _MSC_VER >= 1800 && !defined _WEBSOCKETPP_NO_CPP11_THREAD_
-    #ifndef _WEBSOCKETPP_CPP11_THREAD_
-        #define _WEBSOCKETPP_CPP11_THREAD_
-    #endif
-#endif
-
-#if defined(_WEBSOCKETPP_MINGW_THREAD_)
-    #include <mingw-threads/mingw.thread.h>
-    #include <mingw-threads/mingw.mutex.h>
-    #include <mingw-threads/mingw.condition_variable.h>
-#elif defined(_WEBSOCKETPP_CPP11_THREAD_)
-    #include <thread>
-    #include <mutex>
-    #include <condition_variable>
-#else
-    #include <boost/thread.hpp>
-    #include <boost/thread/mutex.hpp>
-    #include <boost/thread/condition_variable.hpp>
-#endif
-
-namespace websocketpp {
-namespace lib {
-
-#if defined(_WEBSOCKETPP_CPP11_THREAD_) || defined(_WEBSOCKETPP_MINGW_THREAD_)
-    using std::mutex;
-    using std::lock_guard;
-    using std::thread;
-    using std::unique_lock;
-    using std::condition_variable;
-#else
-    using boost::mutex;
-    using boost::lock_guard;
-    using boost::thread;
-    using boost::unique_lock;
-    using boost::condition_variable;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_THREAD_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/time.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/time.hpp
deleted file mode 100644
index 571688e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/time.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_TIME_HPP
-#define WEBSOCKETPP_COMMON_TIME_HPP
-
-#include <ctime>
-
-namespace websocketpp {
-namespace lib {
-
-// Code in this header was inspired by the following article and includes some
-// code from the related project g2log. The g2log code is public domain licensed
-// http://kjellkod.wordpress.com/2013/01/22/exploring-c11-part-2-localtime-and-time-again/
-
-/// Thread safe cross platform localtime
-inline std::tm localtime(std::time_t const & time) {
-    std::tm tm_snapshot;
-#if (defined(__MINGW32__) || defined(__MINGW64__))
-    memcpy(&tm_snapshot, ::localtime(&time), sizeof(std::tm));
-#elif (defined(WIN32) || defined(_WIN32) || defined(__WIN32__))
-    localtime_s(&tm_snapshot, &time); 
-#else
-    localtime_r(&time, &tm_snapshot); // POSIX  
-#endif
-    return tm_snapshot;
-}
-
-} // lib
-} // websocketpp
-
-#endif // WEBSOCKETPP_COMMON_TIME_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/type_traits.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/type_traits.hpp
deleted file mode 100644
index c89b82b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/common/type_traits.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_COMMON_TYPE_TRAITS_HPP
-#define WEBSOCKETPP_COMMON_TYPE_TRAITS_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-
-// If we've determined that we're in full C++11 mode and the user hasn't
-// explicitly disabled the use of C++11 functional header, then prefer it to
-// boost.
-#if defined _WEBSOCKETPP_CPP11_INTERNAL_ && !defined _WEBSOCKETPP_NO_CPP11_TYPE_TRAITS_
-    #ifndef _WEBSOCKETPP_CPP11_TYPE_TRAITS_
-        #define _WEBSOCKETPP_CPP11_TYPE_TRAITS_
-    #endif
-#endif
-
-
-#ifdef _WEBSOCKETPP_CPP11_TYPE_TRAITS_
-    #include <type_traits>
-#else
-    #include <boost/aligned_storage.hpp>
-#endif
-
-
-
-namespace websocketpp {
-namespace lib {
-
-#ifdef _WEBSOCKETPP_CPP11_TYPE_TRAITS_
-    using std::aligned_storage;
-    using std::is_same;
-#else
-    using boost::aligned_storage;
-    using boost::is_same;
-#endif
-
-} // namespace lib
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_COMMON_TYPE_TRAITS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/basic.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/basic.hpp
deleted file mode 100644
index 1943ad7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/basic.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONCURRENCY_BASIC_HPP
-#define WEBSOCKETPP_CONCURRENCY_BASIC_HPP
-
-#include <websocketpp/common/thread.hpp>
-
-namespace websocketpp {
-namespace concurrency {
-
-/// Concurrency policy that uses std::mutex / boost::mutex
-class basic {
-public:
-    typedef lib::mutex mutex_type;
-    typedef lib::lock_guard<mutex_type> scoped_lock_type;
-};
-
-} // namespace concurrency
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONCURRENCY_BASIC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/none.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/none.hpp
deleted file mode 100644
index da9aa41..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/concurrency/none.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONCURRENCY_NONE_HPP
-#define WEBSOCKETPP_CONCURRENCY_NONE_HPP
-
-namespace websocketpp {
-
-/// Concurrency handling support
-namespace concurrency {
-
-/// Implementation for no-op locking primitives
-namespace none_impl {
-/// A fake mutex implementation that does nothing
-class fake_mutex {
-public:
-    fake_mutex() {}
-    ~fake_mutex() {}
-};
-
-/// A fake lock guard implementation that does nothing
-class fake_lock_guard {
-public:
-    explicit fake_lock_guard(fake_mutex) {}
-    ~fake_lock_guard() {}
-};
-} // namespace none_impl
-
-/// Stub concurrency policy that implements the interface using no-ops.
-/**
- * This policy documents the concurrency policy interface using no-ops. It can
- * be used as a reference or base for building a new concurrency policy. It can
- * also be used as is to disable all locking for endpoints used in purely single
- * threaded programs.
- */
-class none {
-public:
-    /// The type of a mutex primitive
-    /**
-     * std::mutex is an example.
-     */
-    typedef none_impl::fake_mutex mutex_type;
-
-    /// The type of a scoped/RAII lock primitive.
-    /**
-     * The scoped lock constructor should take a mutex_type as a parameter,
-     * acquire that lock, and release it in its destructor. std::lock_guard is
-     * an example.
-     */
-    typedef none_impl::fake_lock_guard scoped_lock_type;
-};
-
-} // namespace concurrency
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONCURRENCY_ASYNC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio.hpp
deleted file mode 100644
index d28d0fb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_TLS_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_TLS_HPP
-
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-#include <websocketpp/transport/asio/security/tls.hpp>
-
-// Pull in non-tls config
-#include <websocketpp/config/asio_no_tls.hpp>
-
-// Define TLS config
-namespace websocketpp {
-namespace config {
-
-/// Server config with asio transport and TLS enabled
-struct asio_tls : public core {
-    typedef asio_tls type;
-    typedef core base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_TLS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_client.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_client.hpp
deleted file mode 100644
index 1cb594d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_client.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_TLS_CLIENT_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_TLS_CLIENT_HPP
-
-#include <websocketpp/config/core_client.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-#include <websocketpp/transport/asio/security/tls.hpp>
-
-// Pull in non-tls config
-#include <websocketpp/config/asio_no_tls_client.hpp>
-
-// Define TLS config
-namespace websocketpp {
-namespace config {
-
-/// Client config with asio transport and TLS enabled
-struct asio_tls_client : public core_client {
-    typedef asio_tls_client type;
-    typedef core_client base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_TLS_CLIENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls.hpp
deleted file mode 100644
index 6c1357f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_HPP
-
-#include <websocketpp/config/core.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Server config with asio transport and TLS disabled
-struct asio : public core {
-    typedef asio type;
-    typedef core base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls_client.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls_client.hpp
deleted file mode 100644
index 6e3f7ba..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/asio_no_tls_client.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_CLIENT_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_CLIENT_HPP
-
-#include <websocketpp/config/core_client.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Client config with asio transport and TLS disabled
-struct asio_client : public core_client {
-    typedef asio_client type;
-    typedef core_client base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_CLIENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/boost_config.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/boost_config.hpp
deleted file mode 100644
index 57671cc..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/boost_config.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
- // This header defines WebSocket++ macros for C++11 compatibility based on the 
- // Boost.Config library. This will correctly configure most target platforms
- // simply by including this header before any other WebSocket++ header.
-
-#ifndef WEBSOCKETPP_CONFIG_BOOST_CONFIG_HPP
-#define WEBSOCKETPP_CONFIG_BOOST_CONFIG_HPP
-
-#include <boost/config.hpp>
-
-//  _WEBSOCKETPP_CPP11_MEMORY_ and _WEBSOCKETPP_CPP11_FUNCTIONAL_ presently
-//  only work if either both or neither is defined.
-#if !defined BOOST_NO_CXX11_SMART_PTR && !defined BOOST_NO_CXX11_HDR_FUNCTIONAL
-    #define _WEBSOCKETPP_CPP11_MEMORY_
-    #define _WEBSOCKETPP_CPP11_FUNCTIONAL_
-#endif
-
-#ifdef BOOST_ASIO_HAS_STD_CHRONO
-    #define _WEBSOCKETPP_CPP11_CHRONO_
-#endif
-
-#ifndef BOOST_NO_CXX11_HDR_RANDOM
-    #define _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-#endif
-
-#ifndef BOOST_NO_CXX11_HDR_REGEX
-    #define _WEBSOCKETPP_CPP11_REGEX_
-#endif
-
-#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
-    #define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
-#endif
-
-#ifndef BOOST_NO_CXX11_HDR_THREAD
-    #define _WEBSOCKETPP_CPP11_THREAD_
-#endif
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    #define _WEBSOCKETPP_INITIALIZER_LISTS_
-#endif
-
-#define _WEBSOCKETPP_NOEXCEPT_TOKEN_  BOOST_NOEXCEPT
-#define _WEBSOCKETPP_CONSTEXPR_TOKEN_  BOOST_CONSTEXPR
-// TODO: nullptr support
-
-#endif // WEBSOCKETPP_CONFIG_BOOST_CONFIG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core.hpp
deleted file mode 100644
index 93981aa..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core.hpp
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_CORE_HPP
-#define WEBSOCKETPP_CONFIG_CORE_HPP
-
-// Non-Policy common stuff
-#include <websocketpp/common/platforms.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-
-// Concurrency
-#include <websocketpp/concurrency/basic.hpp>
-
-// Transport
-#include <websocketpp/transport/iostream/endpoint.hpp>
-
-// HTTP
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-// Messages
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-
-// Loggers
-#include <websocketpp/logger/basic.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-// RNG
-#include <websocketpp/random/none.hpp>
-
-// User stub base classes
-#include <websocketpp/endpoint_base.hpp>
-#include <websocketpp/connection_base.hpp>
-
-// Extensions
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Server config with iostream transport
-struct core {
-    typedef core type;
-
-    // Concurrency policy
-    typedef websocketpp::concurrency::basic concurrency_type;
-
-    // HTTP Parser Policies
-    typedef http::parser::request request_type;
-    typedef http::parser::response response_type;
-
-    // Message Policies
-    typedef message_buffer::message<message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-    typedef message_buffer::alloc::endpoint_msg_manager<con_msg_manager_type>
-        endpoint_msg_manager_type;
-
-    /// Logging policies
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::elevel> elog_type;
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::alevel> alog_type;
-
-    /// RNG policies
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    /// Controls compile time enabling/disabling of thread syncronization
-    /// code Disabling can provide a minor performance improvement to single
-    /// threaded applications
-    static bool const enable_multithreading = true;
-
-    struct transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::elog_type elog_type;
-        typedef type::alog_type alog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-
-        /// Controls compile time enabling/disabling of thread syncronization
-        /// code Disabling can provide a minor performance improvement to single
-        /// threaded applications
-        static bool const enable_multithreading = true;
-
-        /// Default timer values (in ms)
-
-        /// Length of time to wait for socket pre-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use
-         */
-        static const long timeout_socket_pre_init = 5000;
-
-        /// Length of time to wait before a proxy handshake is aborted
-        static const long timeout_proxy = 5000;
-
-        /// Length of time to wait for socket post-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use.
-         * Often this means the TLS handshake
-         */
-        static const long timeout_socket_post_init = 5000;
-
-        /// Length of time to wait for dns resolution
-        static const long timeout_dns_resolve = 5000;
-
-        /// Length of time to wait for TCP connect
-        static const long timeout_connect = 5000;
-
-        /// Length of time to wait for socket shutdown
-        static const long timeout_socket_shutdown = 5000;
-    };
-
-    /// Transport Endpoint Component
-    typedef websocketpp::transport::iostream::endpoint<transport_config>
-        transport_type;
-
-    /// User overridable Endpoint base class
-    typedef websocketpp::endpoint_base endpoint_base;
-    /// User overridable Connection base class
-    typedef websocketpp::connection_base connection_base;
-
-    /// Default timer values (in ms)
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 5000;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 5000;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 5000;
-
-    /// WebSocket Protocol version to use as a client
-    /**
-     * What version of the WebSocket Protocol to use for outgoing client
-     * connections. Setting this to a value other than 13 (RFC6455) is not
-     * recommended.
-     */
-    static const int client_version = 13; // RFC6455
-
-    /// Default static error logging channels
-    /**
-     * Which error logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level errors
-     */
-    static const websocketpp::log::level elog_level =
-        websocketpp::log::elevel::all ^ websocketpp::log::elevel::devel;
-
-    /// Default static access logging channels
-    /**
-     * Which access logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level access messages
-     */
-    static const websocketpp::log::level alog_level =
-        websocketpp::log::alevel::all ^ websocketpp::log::alevel::devel;
-
-    /// Size of the per-connection read buffer
-    /**
-     * Each connection has an internal buffer of this size. A larger value will
-     * result in fewer trips through the library and less CPU overhead at the
-     * expense of increased memory usage per connection.
-     *
-     * If your application primarily deals in very large messages you may want
-     * to try setting this value higher.
-     *
-     * If your application has a lot of connections or primarily deals in small
-     * messages you may want to try setting this smaller.
-     */
-    static const size_t connection_read_buffer_size = 16384;
-
-    /// Drop connections immediately on protocol error.
-    /**
-     * Drop connections on protocol error rather than sending a close frame.
-     * Off by default. This may result in legit messages near the error being
-     * dropped as well. It may free up resources otherwise spent dealing with
-     * misbehaving clients.
-     */
-    static const bool drop_on_protocol_error = false;
-
-    /// Suppresses the return of detailed connection close information
-    /**
-     * Silence close suppresses the return of detailed connection close
-     * information during the closing handshake. This information is useful
-     * for debugging and presenting useful errors to end users but may be
-     * undesirable for security reasons in some production environments.
-     * Close reasons could be used by an attacker to confirm that the endpoint
-     * is out of resources or be used to identify the WebSocket implementation
-     * in use.
-     *
-     * Note: this will suppress *all* close codes, including those explicitly
-     * sent by local applications.
-     */
-    static const bool silent_close = false;
-
-    /// Default maximum message size
-    /**
-     * Default value for the processor's maximum message size. Maximum message size
-     * determines the point at which the library will fail a connection with the 
-     * message_too_big protocol error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.3.0
-     */
-    static const size_t max_message_size = 32000000;
-    
-    /// Default maximum http body size
-    /**
-     * Default value for the http parser's maximum body size. Maximum body size
-     * determines the point at which the library will abort reading an HTTP
-     * connection with the 413/request entity too large error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.5.0
-     */
-    static const size_t max_http_body_size = 32000000;
-
-    /// Global flag for enabling/disabling extensions
-    static const bool enable_extensions = true;
-
-    /// Extension specific settings:
-
-    /// permessage_compress extension
-    struct permessage_deflate_config {
-        typedef core::request_type request_type;
-
-        /// If the remote endpoint requests that we reset the compression
-        /// context after each message should we honor the request?
-        static const bool allow_disabling_context_takeover = true;
-
-        /// If the remote endpoint requests that we reduce the size of the
-        /// LZ77 sliding window size this is the lowest value that will be
-        /// allowed. Values range from 8 to 15. A value of 8 means we will
-        /// allow any possible window size. A value of 15 means do not allow
-        /// negotiation of the window size (ie require the default).
-        static const uint8_t minimum_outgoing_window_bits = 8;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    /// Autonegotiate permessage-deflate
-    /**
-     * Automatically enables the permessage-deflate extension.
-     *
-     * For clients this results in a permessage-deflate extension request being
-     * sent with every request rather than requiring it to be requested manually
-     *
-     * For servers this results in accepting the first set of extension settings
-     * requested by the client that we understand being used. The alternative is
-     * requiring the extension to be manually negotiated in `validate`. With
-     * auto-negotiate on, you may still override the auto-negotiate manually if
-     * needed.
-     */
-    //static const bool autonegotiate_compression = false;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_CORE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core_client.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core_client.hpp
deleted file mode 100644
index dadf8a4..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/core_client.hpp
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_CORE_CLIENT_HPP
-#define WEBSOCKETPP_CONFIG_CORE_CLIENT_HPP
-
-// Non-Policy common stuff
-#include <websocketpp/common/platforms.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-
-// Concurrency
-#ifndef _WEBSOCKETPP_NO_THREADING_
-#include <websocketpp/concurrency/basic.hpp>
-#else
-#include <websocketpp/concurrency/none.hpp>
-#endif
-
-// Transport
-#include <websocketpp/transport/iostream/endpoint.hpp>
-
-// HTTP
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-// Messages
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-
-// Loggers
-#include <websocketpp/logger/basic.hpp>
-
-// RNG
-#include <websocketpp/random/random_device.hpp>
-
-// User stub base classes
-#include <websocketpp/endpoint_base.hpp>
-#include <websocketpp/connection_base.hpp>
-
-// Extensions
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Client config with iostream transport
-struct core_client {
-    typedef core_client type;
-
-    // Concurrency policy
-#ifndef _WEBSOCKETPP_NO_THREADING_
-    typedef websocketpp::concurrency::basic concurrency_type;
-#else
-    typedef websocketpp::concurrency::none concurrency_type;
-#endif
-
-    // HTTP Parser Policies
-    typedef http::parser::request request_type;
-    typedef http::parser::response response_type;
-
-    // Message Policies
-    typedef message_buffer::message<message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-    typedef message_buffer::alloc::endpoint_msg_manager<con_msg_manager_type>
-        endpoint_msg_manager_type;
-
-    /// Logging policies
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::elevel> elog_type;
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::alevel> alog_type;
-
-    /// RNG policies
-    typedef websocketpp::random::random_device::int_generator<uint32_t,
-        concurrency_type> rng_type;
-
-    /// Controls compile time enabling/disabling of thread syncronization code
-    /// Disabling can provide a minor performance improvement to single threaded
-    /// applications
-    static bool const enable_multithreading = true;
-
-    struct transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::elog_type elog_type;
-        typedef type::alog_type alog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-
-        /// Controls compile time enabling/disabling of thread syncronization
-        /// code Disabling can provide a minor performance improvement to single
-        /// threaded applications
-        static bool const enable_multithreading = true;
-
-        /// Default timer values (in ms)
-
-        /// Length of time to wait for socket pre-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use
-         */
-        static const long timeout_socket_pre_init = 5000;
-
-        /// Length of time to wait before a proxy handshake is aborted
-        static const long timeout_proxy = 5000;
-
-        /// Length of time to wait for socket post-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use.
-         * Often this means the TLS handshake
-         */
-        static const long timeout_socket_post_init = 5000;
-
-        /// Length of time to wait for dns resolution
-        static const long timeout_dns_resolve = 5000;
-
-        /// Length of time to wait for TCP connect
-        static const long timeout_connect = 5000;
-
-        /// Length of time to wait for socket shutdown
-        static const long timeout_socket_shutdown = 5000;
-    };
-
-    /// Transport Endpoint Component
-    typedef websocketpp::transport::iostream::endpoint<transport_config>
-        transport_type;
-
-    /// User overridable Endpoint base class
-    typedef websocketpp::endpoint_base endpoint_base;
-    /// User overridable Connection base class
-    typedef websocketpp::connection_base connection_base;
-
-    /// Default timer values (in ms)
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 5000;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 5000;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 5000;
-
-    /// WebSocket Protocol version to use as a client
-    /**
-     * What version of the WebSocket Protocol to use for outgoing client
-     * connections. Setting this to a value other than 13 (RFC6455) is not
-     * recommended.
-     */
-    static const int client_version = 13; // RFC6455
-
-    /// Default static error logging channels
-    /**
-     * Which error logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level errors
-     */
-    static const websocketpp::log::level elog_level =
-        websocketpp::log::elevel::all ^ websocketpp::log::elevel::devel;
-
-    /// Default static access logging channels
-    /**
-     * Which access logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level access messages
-     */
-    static const websocketpp::log::level alog_level =
-        websocketpp::log::alevel::all ^ websocketpp::log::alevel::devel;
-
-    ///
-    static const size_t connection_read_buffer_size = 16384;
-
-    /// Drop connections immediately on protocol error.
-    /**
-     * Drop connections on protocol error rather than sending a close frame.
-     * Off by default. This may result in legit messages near the error being
-     * dropped as well. It may free up resources otherwise spent dealing with
-     * misbehaving clients.
-     */
-    static const bool drop_on_protocol_error = false;
-
-    /// Suppresses the return of detailed connection close information
-    /**
-     * Silence close suppresses the return of detailed connection close
-     * information during the closing handshake. This information is useful
-     * for debugging and presenting useful errors to end users but may be
-     * undesirable for security reasons in some production environments.
-     * Close reasons could be used by an attacker to confirm that the endpoint
-     * is out of resources or be used to identify the WebSocket implementation
-     * in use.
-     *
-     * Note: this will suppress *all* close codes, including those explicitly
-     * sent by local applications.
-     */
-    static const bool silent_close = false;
-
-    /// Default maximum message size
-    /**
-     * Default value for the processor's maximum message size. Maximum message size
-     * determines the point at which the library will fail a connection with the 
-     * message_too_big protocol error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.3.0
-     */
-    static const size_t max_message_size = 32000000;
-
-    /// Default maximum http body size
-    /**
-     * Default value for the http parser's maximum body size. Maximum body size
-     * determines the point at which the library will abort reading an HTTP
-     * connection with the 413/request entity too large error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.5.0
-     */
-    static const size_t max_http_body_size = 32000000;
-
-    /// Global flag for enabling/disabling extensions
-    static const bool enable_extensions = true;
-
-    /// Extension specific settings:
-
-    /// permessage_deflate extension
-    struct permessage_deflate_config {
-        typedef core_client::request_type request_type;
-
-        /// If the remote endpoint requests that we reset the compression
-        /// context after each message should we honor the request?
-        static const bool allow_disabling_context_takeover = true;
-
-        /// If the remote endpoint requests that we reduce the size of the
-        /// LZ77 sliding window size this is the lowest value that will be
-        /// allowed. Values range from 8 to 15. A value of 8 means we will
-        /// allow any possible window size. A value of 15 means do not allow
-        /// negotiation of the window size (ie require the default).
-        static const uint8_t minimum_outgoing_window_bits = 8;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    /// Autonegotiate permessage-compress
-    /**
-     * Automatically enables the permessage-compress extension.
-     *
-     * For clients this results in a permessage-compress extension request being
-     * sent with every request rather than requiring it to be requested manually
-     *
-     * For servers this results in accepting the first set of extension settings
-     * requested by the client that we understand being used. The alternative is
-     * requiring the extension to be manually negotiated in `validate`. With
-     * auto-negotiate on, you may still override the auto-negotiate manually if
-     * needed.
-     */
-    //static const bool autonegotiate_compression = false;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_CORE_CLIENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug.hpp
deleted file mode 100644
index 223f72f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_DEBUG_HPP
-#define WEBSOCKETPP_CONFIG_DEBUG_HPP
-
-
-
-// Non-Policy common stuff
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-
-// Concurrency
-#include <websocketpp/concurrency/basic.hpp>
-
-// Transport
-#include <websocketpp/transport/iostream/endpoint.hpp>
-
-// HTTP
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-// Messages
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-
-// Loggers
-#include <websocketpp/logger/basic.hpp>
-
-// RNG
-#include <websocketpp/random/none.hpp>
-
-// User stub base classes
-#include <websocketpp/endpoint_base.hpp>
-#include <websocketpp/connection_base.hpp>
-
-// Extensions
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Client/Server debug config with iostream transport
-struct debug_core {
-    typedef debug_core type;
-
-    // Concurrency policy
-    typedef websocketpp::concurrency::basic concurrency_type;
-
-    // HTTP Parser Policies
-    typedef http::parser::request request_type;
-    typedef http::parser::response response_type;
-
-    // Message Policies
-    typedef message_buffer::message<message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-    typedef message_buffer::alloc::endpoint_msg_manager<con_msg_manager_type>
-        endpoint_msg_manager_type;
-
-    /// Logging policies
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::elevel> elog_type;
-    typedef websocketpp::log::basic<concurrency_type,
-        websocketpp::log::alevel> alog_type;
-
-    /// RNG policies
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    /// Controls compile time enabling/disabling of thread syncronization
-    /// code Disabling can provide a minor performance improvement to single
-    /// threaded applications
-    static bool const enable_multithreading = true;
-
-    struct transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::elog_type elog_type;
-        typedef type::alog_type alog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-
-        /// Controls compile time enabling/disabling of thread syncronization
-        /// code Disabling can provide a minor performance improvement to single
-        /// threaded applications
-        static bool const enable_multithreading = true;
-
-        /// Default timer values (in ms)
-
-        /// Length of time to wait for socket pre-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use
-         */
-        static const long timeout_socket_pre_init = 5000;
-
-        /// Length of time to wait before a proxy handshake is aborted
-        static const long timeout_proxy = 5000;
-
-        /// Length of time to wait for socket post-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use.
-         * Often this means the TLS handshake
-         */
-        static const long timeout_socket_post_init = 5000;
-
-        /// Length of time to wait for dns resolution
-        static const long timeout_dns_resolve = 5000;
-
-        /// Length of time to wait for TCP connect
-        static const long timeout_connect = 5000;
-
-        /// Length of time to wait for socket shutdown
-        static const long timeout_socket_shutdown = 5000;
-    };
-
-    /// Transport Endpoint Component
-    typedef websocketpp::transport::iostream::endpoint<transport_config>
-        transport_type;
-
-    /// User overridable Endpoint base class
-    typedef websocketpp::endpoint_base endpoint_base;
-    /// User overridable Connection base class
-    typedef websocketpp::connection_base connection_base;
-
-    /// Default timer values (in ms)
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 5000;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 5000;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 5000;
-
-    /// WebSocket Protocol version to use as a client
-    /**
-     * What version of the WebSocket Protocol to use for outgoing client
-     * connections. Setting this to a value other than 13 (RFC6455) is not
-     * recommended.
-     */
-    static const int client_version = 13; // RFC6455
-
-    /// Default static error logging channels
-    /**
-     * Which error logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level errors
-     */
-    static const websocketpp::log::level elog_level =
-        websocketpp::log::elevel::all;
-
-    /// Default static access logging channels
-    /**
-     * Which access logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level access messages
-     */
-    static const websocketpp::log::level alog_level =
-        websocketpp::log::alevel::all;
-
-    ///
-    static const size_t connection_read_buffer_size = 16384;
-
-    /// Drop connections immediately on protocol error.
-    /**
-     * Drop connections on protocol error rather than sending a close frame.
-     * Off by default. This may result in legit messages near the error being
-     * dropped as well. It may free up resources otherwise spent dealing with
-     * misbehaving clients.
-     */
-    static const bool drop_on_protocol_error = false;
-
-    /// Suppresses the return of detailed connection close information
-    /**
-     * Silence close suppresses the return of detailed connection close
-     * information during the closing handshake. This information is useful
-     * for debugging and presenting useful errors to end users but may be
-     * undesirable for security reasons in some production environments.
-     * Close reasons could be used by an attacker to confirm that the endpoint
-     * is out of resources or be used to identify the WebSocket implementation
-     * in use.
-     *
-     * Note: this will suppress *all* close codes, including those explicitly
-     * sent by local applications.
-     */
-    static const bool silent_close = false;
-
-    /// Default maximum message size
-    /**
-     * Default value for the processor's maximum message size. Maximum message size
-     * determines the point at which the library will fail a connection with the 
-     * message_too_big protocol error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.3.0
-     */
-    static const size_t max_message_size = 32000000;
-
-    /// Default maximum http body size
-    /**
-     * Default value for the http parser's maximum body size. Maximum body size
-     * determines the point at which the library will abort reading an HTTP
-     * connection with the 413/request entity too large error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.5.0
-     */
-    static const size_t max_http_body_size = 32000000;
-
-    /// Global flag for enabling/disabling extensions
-    static const bool enable_extensions = true;
-
-    /// Extension specific settings:
-
-    /// permessage_compress extension
-    struct permessage_deflate_config {
-        typedef type::request_type request_type;
-
-        /// If the remote endpoint requests that we reset the compression
-        /// context after each message should we honor the request?
-        static const bool allow_disabling_context_takeover = true;
-
-        /// If the remote endpoint requests that we reduce the size of the
-        /// LZ77 sliding window size this is the lowest value that will be
-        /// allowed. Values range from 8 to 15. A value of 8 means we will
-        /// allow any possible window size. A value of 15 means do not allow
-        /// negotiation of the window size (ie require the default).
-        static const uint8_t minimum_outgoing_window_bits = 8;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    /// Autonegotiate permessage-deflate
-    /**
-     * Automatically enables the permessage-deflate extension.
-     *
-     * For clients this results in a permessage-deflate extension request being
-     * sent with every request rather than requiring it to be requested manually
-     *
-     * For servers this results in accepting the first set of extension settings
-     * requested by the client that we understand being used. The alternative is
-     * requiring the extension to be manually negotiated in `validate`. With
-     * auto-negotiate on, you may still override the auto-negotiate manually if
-     * needed.
-     */
-    //static const bool autonegotiate_compression = false;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_CORE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio.hpp
deleted file mode 100644
index a57c736..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_TLS_DEBUG_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_TLS_DEBUG_HPP
-
-#include <websocketpp/config/debug.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-#include <websocketpp/transport/asio/security/tls.hpp>
-
-// Pull in non-tls config
-#include <websocketpp/config/debug_asio_no_tls.hpp>
-
-// Define TLS config
-namespace websocketpp {
-namespace config {
-
-/// Client/Server debug config with asio transport and TLS enabled
-struct debug_asio_tls : public debug_core {
-    typedef debug_asio_tls type;
-    typedef debug_core base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::tls_socket::endpoint socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_TLS_DEBUG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio_no_tls.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio_no_tls.hpp
deleted file mode 100644
index b3dc83b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/debug_asio_no_tls.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_ASIO_DEBUG_HPP
-#define WEBSOCKETPP_CONFIG_ASIO_DEBUG_HPP
-
-#include <websocketpp/config/debug.hpp>
-#include <websocketpp/transport/asio/endpoint.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Client/Server debug config with asio transport and TLS disabled
-struct debug_asio : public debug_core {
-    typedef debug_asio type;
-    typedef debug_core base;
-
-    typedef base::concurrency_type concurrency_type;
-
-    typedef base::request_type request_type;
-    typedef base::response_type response_type;
-
-    typedef base::message_type message_type;
-    typedef base::con_msg_manager_type con_msg_manager_type;
-    typedef base::endpoint_msg_manager_type endpoint_msg_manager_type;
-
-    typedef base::alog_type alog_type;
-    typedef base::elog_type elog_type;
-
-    typedef base::rng_type rng_type;
-
-    struct transport_config : public base::transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::alog_type alog_type;
-        typedef type::elog_type elog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-        typedef websocketpp::transport::asio::basic_socket::endpoint
-            socket_type;
-    };
-
-    typedef websocketpp::transport::asio::endpoint<transport_config>
-        transport_type;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_ASIO_DEBUG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_client.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_client.hpp
deleted file mode 100644
index 72528cd..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_client.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_MINIMAL_CLIENT_HPP
-#define WEBSOCKETPP_CONFIG_MINIMAL_CLIENT_HPP
-
-#include <websocketpp/config/minimal_server.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Client config with minimal dependencies
-/**
- * This config strips out as many dependencies as possible. It is suitable for
- * use as a base class for custom configs that want to implement or choose their
- * own policies for components that even the core config includes.
- *
- * NOTE: this config stubs out enough that it cannot be used directly. You must
- * supply at least a transport policy and a cryptographically secure random 
- * number generation policy for a config based on `minimal_client` to do 
- * anything useful.
- *
- * Present dependency list for minimal_server config:
- *
- * C++98 STL:
- * <algorithm>
- * <map>
- * <sstream>
- * <string>
- * <vector>
- *
- * C++11 STL or Boost
- * <memory>
- * <functional>
- * <system_error>
- *
- * Operating System:
- * <stdint.h> or <boost/cstdint.hpp>
- * <netinet/in.h> or <winsock2.h> (for ntohl.. could potentially bundle this)
- *
- * @since 0.4.0-dev
- */
-typedef minimal_server minimal_client;
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_MINIMAL_CLIENT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_server.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_server.hpp
deleted file mode 100644
index dd1aedb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/config/minimal_server.hpp
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONFIG_MINIMAL_HPP
-#define WEBSOCKETPP_CONFIG_MINIMAL_HPP
-
-// Non-Policy common stuff
-#include <websocketpp/common/platforms.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-
-// Concurrency
-#include <websocketpp/concurrency/none.hpp>
-
-// Transport
-#include <websocketpp/transport/stub/endpoint.hpp>
-
-// HTTP
-#include <websocketpp/http/request.hpp>
-#include <websocketpp/http/response.hpp>
-
-// Messages
-#include <websocketpp/message_buffer/message.hpp>
-#include <websocketpp/message_buffer/alloc.hpp>
-
-// Loggers
-#include <websocketpp/logger/stub.hpp>
-
-// RNG
-#include <websocketpp/random/none.hpp>
-
-// User stub base classes
-#include <websocketpp/endpoint_base.hpp>
-#include <websocketpp/connection_base.hpp>
-
-// Extensions
-#include <websocketpp/extensions/permessage_deflate/disabled.hpp>
-
-namespace websocketpp {
-namespace config {
-
-/// Server config with minimal dependencies
-/**
- * This config strips out as many dependencies as possible. It is suitable for
- * use as a base class for custom configs that want to implement or choose their
- * own policies for components that even the core config includes.
- *
- * NOTE: this config stubs out enough that it cannot be used directly. You must
- * supply at least a transport policy for a config based on `minimal_server` to
- * do anything useful.
- *
- * Present dependency list for minimal_server config:
- *
- * C++98 STL:
- * <algorithm>
- * <map>
- * <sstream>
- * <string>
- * <vector>
- *
- * C++11 STL or Boost
- * <memory>
- * <functional>
- * <system_error>
- *
- * Operating System:
- * <stdint.h> or <boost/cstdint.hpp>
- * <netinet/in.h> or <winsock2.h> (for ntohl.. could potentially bundle this)
- *
- * @since 0.4.0-dev
- */
-struct minimal_server {
-    typedef minimal_server type;
-
-    // Concurrency policy
-    typedef websocketpp::concurrency::none concurrency_type;
-
-    // HTTP Parser Policies
-    typedef http::parser::request request_type;
-    typedef http::parser::response response_type;
-
-    // Message Policies
-    typedef message_buffer::message<message_buffer::alloc::con_msg_manager>
-        message_type;
-    typedef message_buffer::alloc::con_msg_manager<message_type>
-        con_msg_manager_type;
-    typedef message_buffer::alloc::endpoint_msg_manager<con_msg_manager_type>
-        endpoint_msg_manager_type;
-
-    /// Logging policies
-    typedef websocketpp::log::stub elog_type;
-    typedef websocketpp::log::stub alog_type;
-
-    /// RNG policies
-    typedef websocketpp::random::none::int_generator<uint32_t> rng_type;
-
-    /// Controls compile time enabling/disabling of thread syncronization
-    /// code Disabling can provide a minor performance improvement to single
-    /// threaded applications
-    static bool const enable_multithreading = true;
-
-    struct transport_config {
-        typedef type::concurrency_type concurrency_type;
-        typedef type::elog_type elog_type;
-        typedef type::alog_type alog_type;
-        typedef type::request_type request_type;
-        typedef type::response_type response_type;
-
-        /// Controls compile time enabling/disabling of thread syncronization
-        /// code Disabling can provide a minor performance improvement to single
-        /// threaded applications
-        static bool const enable_multithreading = true;
-
-        /// Default timer values (in ms)
-
-        /// Length of time to wait for socket pre-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use
-         */
-        static const long timeout_socket_pre_init = 5000;
-
-        /// Length of time to wait before a proxy handshake is aborted
-        static const long timeout_proxy = 5000;
-
-        /// Length of time to wait for socket post-initialization
-        /**
-         * Exactly what this includes depends on the socket policy in use.
-         * Often this means the TLS handshake
-         */
-        static const long timeout_socket_post_init = 5000;
-
-        /// Length of time to wait for dns resolution
-        static const long timeout_dns_resolve = 5000;
-
-        /// Length of time to wait for TCP connect
-        static const long timeout_connect = 5000;
-
-        /// Length of time to wait for socket shutdown
-        static const long timeout_socket_shutdown = 5000;
-    };
-
-    /// Transport Endpoint Component
-    typedef websocketpp::transport::stub::endpoint<transport_config>
-        transport_type;
-
-    /// User overridable Endpoint base class
-    typedef websocketpp::endpoint_base endpoint_base;
-    /// User overridable Connection base class
-    typedef websocketpp::connection_base connection_base;
-
-    /// Default timer values (in ms)
-
-    /// Length of time before an opening handshake is aborted
-    static const long timeout_open_handshake = 5000;
-    /// Length of time before a closing handshake is aborted
-    static const long timeout_close_handshake = 5000;
-    /// Length of time to wait for a pong after a ping
-    static const long timeout_pong = 5000;
-
-    /// WebSocket Protocol version to use as a client
-    /**
-     * What version of the WebSocket Protocol to use for outgoing client
-     * connections. Setting this to a value other than 13 (RFC6455) is not
-     * recommended.
-     */
-    static const int client_version = 13; // RFC6455
-
-    /// Default static error logging channels
-    /**
-     * Which error logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level errors
-     */
-    static const websocketpp::log::level elog_level =
-        websocketpp::log::elevel::none;
-
-    /// Default static access logging channels
-    /**
-     * Which access logging channels to enable at compile time. Channels not
-     * enabled here will be unable to be selected by programs using the library.
-     * This option gives an optimizing compiler the ability to remove entirely
-     * code to test whether or not to print out log messages on a certain
-     * channel
-     *
-     * Default is all except for development/debug level access messages
-     */
-    static const websocketpp::log::level alog_level =
-        websocketpp::log::alevel::none;
-
-    ///
-    static const size_t connection_read_buffer_size = 16384;
-
-    /// Drop connections immediately on protocol error.
-    /**
-     * Drop connections on protocol error rather than sending a close frame.
-     * Off by default. This may result in legit messages near the error being
-     * dropped as well. It may free up resources otherwise spent dealing with
-     * misbehaving clients.
-     */
-    static const bool drop_on_protocol_error = false;
-
-    /// Suppresses the return of detailed connection close information
-    /**
-     * Silence close suppresses the return of detailed connection close
-     * information during the closing handshake. This information is useful
-     * for debugging and presenting useful errors to end users but may be
-     * undesirable for security reasons in some production environments.
-     * Close reasons could be used by an attacker to confirm that the endpoint
-     * is out of resources or be used to identify the WebSocket implementation
-     * in use.
-     *
-     * Note: this will suppress *all* close codes, including those explicitly
-     * sent by local applications.
-     */
-    static const bool silent_close = false;
-
-    /// Default maximum message size
-    /**
-     * Default value for the processor's maximum message size. Maximum message size
-     * determines the point at which the library will fail a connection with the 
-     * message_too_big protocol error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.4.0-alpha1
-     */
-    static const size_t max_message_size = 32000000;
-
-    /// Default maximum http body size
-    /**
-     * Default value for the http parser's maximum body size. Maximum body size
-     * determines the point at which the library will abort reading an HTTP
-     * connection with the 413/request entity too large error.
-     *
-     * The default is 32MB
-     *
-     * @since 0.5.0
-     */
-    static const size_t max_http_body_size = 32000000;
-
-    /// Global flag for enabling/disabling extensions
-    static const bool enable_extensions = true;
-
-    /// Extension specific settings:
-
-    /// permessage_compress extension
-    struct permessage_deflate_config {
-        typedef core::request_type request_type;
-
-        /// If the remote endpoint requests that we reset the compression
-        /// context after each message should we honor the request?
-        static const bool allow_disabling_context_takeover = true;
-
-        /// If the remote endpoint requests that we reduce the size of the
-        /// LZ77 sliding window size this is the lowest value that will be
-        /// allowed. Values range from 8 to 15. A value of 8 means we will
-        /// allow any possible window size. A value of 15 means do not allow
-        /// negotiation of the window size (ie require the default).
-        static const uint8_t minimum_outgoing_window_bits = 8;
-    };
-
-    typedef websocketpp::extensions::permessage_deflate::disabled
-        <permessage_deflate_config> permessage_deflate_type;
-
-    /// Autonegotiate permessage-deflate
-    /**
-     * Automatically enables the permessage-deflate extension.
-     *
-     * For clients this results in a permessage-deflate extension request being
-     * sent with every request rather than requiring it to be requested manually
-     *
-     * For servers this results in accepting the first set of extension settings
-     * requested by the client that we understand being used. The alternative is
-     * requiring the extension to be manually negotiated in `validate`. With
-     * auto-negotiate on, you may still override the auto-negotiate manually if
-     * needed.
-     */
-    //static const bool autonegotiate_compression = false;
-};
-
-} // namespace config
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONFIG_MINIMAL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection.hpp
deleted file mode 100644
index d019fce..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection.hpp
+++ /dev/null
@@ -1,1642 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONNECTION_HPP
-#define WEBSOCKETPP_CONNECTION_HPP
-
-#include <websocketpp/close.hpp>
-#include <websocketpp/error.hpp>
-#include <websocketpp/frame.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-#include <websocketpp/processors/processor.hpp>
-#include <websocketpp/transport/base/connection.hpp>
-#include <websocketpp/http/constants.hpp>
-
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/functional.hpp>
-
-#include <queue>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-
-/// The type and function signature of an open handler
-/**
- * The open handler is called once for every successful WebSocket connection
- * attempt. Either the fail handler or the open handler will be called for each
- * WebSocket connection attempt. HTTP Connections that did not attempt to
- * upgrade the connection to the WebSocket protocol will trigger the http
- * handler instead of fail/open.
- */
-typedef lib::function<void(connection_hdl)> open_handler;
-
-/// The type and function signature of a close handler
-/**
- * The close handler is called once for every successfully established
- * connection after it is no longer capable of sending or receiving new messages
- *
- * The close handler will be called exactly once for every connection for which
- * the open handler was called.
- */
-typedef lib::function<void(connection_hdl)> close_handler;
-
-/// The type and function signature of a fail handler
-/**
- * The fail handler is called once for every unsuccessful WebSocket connection
- * attempt. Either the fail handler or the open handler will be called for each
- * WebSocket connection attempt. HTTP Connections that did not attempt to
- * upgrade the connection to the WebSocket protocol will trigger the http
- * handler instead of fail/open.
- */
-typedef lib::function<void(connection_hdl)> fail_handler;
-
-/// The type and function signature of an interrupt handler
-/**
- * The interrupt handler is called when a connection receives an interrupt
- * request from the application. Interrupts allow the application to trigger a
- * handler to be run in the absense of a WebSocket level handler trigger (like
- * a new message).
- *
- * This is typically used by another application thread to schedule some tasks
- * that can only be run from within the handler chain for thread safety reasons.
- */
-typedef lib::function<void(connection_hdl)> interrupt_handler;
-
-/// The type and function signature of a ping handler
-/**
- * The ping handler is called when the connection receives a WebSocket ping
- * control frame. The string argument contains the ping payload. The payload is
- * a binary string up to 126 bytes in length. The ping handler returns a bool,
- * true if a pong response should be sent, false if the pong response should be
- * suppressed.
- */
-typedef lib::function<bool(connection_hdl,std::string)> ping_handler;
-
-/// The type and function signature of a pong handler
-/**
- * The pong handler is called when the connection receives a WebSocket pong
- * control frame. The string argument contains the pong payload. The payload is
- * a binary string up to 126 bytes in length.
- */
-typedef lib::function<void(connection_hdl,std::string)> pong_handler;
-
-/// The type and function signature of a pong timeout handler
-/**
- * The pong timeout handler is called when a ping goes unanswered by a pong for
- * longer than the locally specified timeout period.
- */
-typedef lib::function<void(connection_hdl,std::string)> pong_timeout_handler;
-
-/// The type and function signature of a validate handler
-/**
- * The validate handler is called after a WebSocket handshake has been received
- * and processed but before it has been accepted. This gives the application a
- * chance to implement connection details specific policies for accepting
- * connections and the ability to negotiate extensions and subprotocols.
- *
- * The validate handler return value indicates whether or not the connection
- * should be accepted. Additional methods may be called during the function to
- * set response headers, set HTTP return/error codes, etc.
- */
-typedef lib::function<bool(connection_hdl)> validate_handler;
-
-/// The type and function signature of a http handler
-/**
- * The http handler is called when an HTTP connection is made that does not
- * attempt to upgrade the connection to the WebSocket protocol. This allows
- * WebSocket++ servers to respond to these requests with regular HTTP responses.
- *
- * This can be used to deliver error pages & dashboards and to deliver static
- * files such as the base HTML & JavaScript for an otherwise single page
- * WebSocket application.
- *
- * Note: WebSocket++ is designed to be a high performance WebSocket server. It
- * is not tuned to provide a full featured, high performance, HTTP web server
- * solution. The HTTP handler is appropriate only for low volume HTTP traffic.
- * If you expect to serve high volumes of HTTP traffic a dedicated HTTP web
- * server is strongly recommended.
- *
- * The default HTTP handler will return a 426 Upgrade Required error. Custom
- * handlers may override the response status code to deliver any type of
- * response.
- */
-typedef lib::function<void(connection_hdl)> http_handler;
-
-//
-typedef lib::function<void(lib::error_code const & ec, size_t bytes_transferred)> read_handler;
-typedef lib::function<void(lib::error_code const & ec)> write_frame_handler;
-
-// constants related to the default WebSocket protocol versions available
-#ifdef _WEBSOCKETPP_INITIALIZER_LISTS_ // simplified C++11 version
-    /// Container that stores the list of protocol versions supported
-    /**
-     * @todo Move this to configs to allow compile/runtime disabling or enabling
-     * of protocol versions
-     */
-    static std::vector<int> const versions_supported = {0,7,8,13};
-#else
-    /// Helper array to get around lack of initializer lists pre C++11
-    static int const helper[] = {0,7,8,13};
-    /// Container that stores the list of protocol versions supported
-    /**
-     * @todo Move this to configs to allow compile/runtime disabling or enabling
-     * of protocol versions
-     */
-    static std::vector<int> const versions_supported(helper,helper+4);
-#endif
-
-namespace session {
-namespace state {
-    // externally visible session state (states based on the RFC)
-    enum value {
-        connecting = 0,
-        open = 1,
-        closing = 2,
-        closed = 3
-    };
-} // namespace state
-
-
-namespace fail {
-namespace status {
-    enum value {
-        GOOD = 0,           // no failure yet!
-        SYSTEM = 1,         // system call returned error, check that code
-        WEBSOCKET = 2,      // websocket close codes contain error
-        UNKNOWN = 3,        // No failure information is available
-        TIMEOUT_TLS = 4,    // TLS handshake timed out
-        TIMEOUT_WS = 5      // WS handshake timed out
-    };
-} // namespace status
-} // namespace fail
-
-namespace internal_state {
-    // More granular internal states. These are used for multi-threaded
-    // connection synchronization and preventing values that are not yet or no
-    // longer available from being used.
-
-    enum value {
-        USER_INIT = 0,
-        TRANSPORT_INIT = 1,
-        READ_HTTP_REQUEST = 2,
-        WRITE_HTTP_REQUEST = 3,
-        READ_HTTP_RESPONSE = 4,
-        WRITE_HTTP_RESPONSE = 5,
-        PROCESS_HTTP_REQUEST = 6,
-        PROCESS_CONNECTION = 7
-    };
-} // namespace internal_state
-
-
-namespace http_state {
-    // states to keep track of the progress of http connections
-
-    enum value {
-        init = 0,
-        deferred = 1,
-        headers_written = 2,
-        body_written = 3,
-        closed = 4
-    };
-} // namespace http_state
-
-} // namespace session
-
-/// Represents an individual WebSocket connection
-template <typename config>
-class connection
- : public config::transport_type::transport_con_type
- , public config::connection_base
-{
-public:
-    /// Type of this connection
-    typedef connection<config> type;
-    /// Type of a shared pointer to this connection
-    typedef lib::shared_ptr<type> ptr;
-    /// Type of a weak pointer to this connection
-    typedef lib::weak_ptr<type> weak_ptr;
-
-    /// Type of the concurrency component of this connection
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of the access logging policy
-    typedef typename config::alog_type alog_type;
-    /// Type of the error logging policy
-    typedef typename config::elog_type elog_type;
-
-    /// Type of the transport component of this connection
-    typedef typename config::transport_type::transport_con_type
-        transport_con_type;
-    /// Type of a shared pointer to the transport component of this connection
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    typedef lib::function<void(ptr)> termination_handler;
-
-    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
-    typedef typename concurrency_type::mutex_type mutex_type;
-
-    typedef typename config::request_type request_type;
-    typedef typename config::response_type response_type;
-
-    typedef typename config::message_type message_type;
-    typedef typename message_type::ptr message_ptr;
-
-    typedef typename config::con_msg_manager_type con_msg_manager_type;
-    typedef typename con_msg_manager_type::ptr con_msg_manager_ptr;
-
-    /// Type of RNG
-    typedef typename config::rng_type rng_type;
-
-    typedef processor::processor<config> processor_type;
-    typedef lib::shared_ptr<processor_type> processor_ptr;
-
-    // Message handler (needs to know message type)
-    typedef lib::function<void(connection_hdl,message_ptr)> message_handler;
-
-    /// Type of a pointer to a transport timer handle
-    typedef typename transport_con_type::timer_ptr timer_ptr;
-
-    // Misc Convenience Types
-    typedef session::internal_state::value istate_type;
-
-private:
-    enum terminate_status {
-        failed = 1,
-        closed,
-        unknown
-    };
-public:
-
-    explicit connection(bool p_is_server, std::string const & ua, const lib::shared_ptr<alog_type>& alog,
-                        const lib::shared_ptr<elog_type>& elog, rng_type & rng)
-      : transport_con_type(p_is_server, alog, elog)
-      , m_handle_read_frame(lib::bind(
-            &type::handle_read_frame,
-            this,
-            lib::placeholders::_1,
-            lib::placeholders::_2
-        ))
-      , m_write_frame_handler(lib::bind(
-            &type::handle_write_frame,
-            this,
-            lib::placeholders::_1
-        ))
-      , m_user_agent(ua)
-      , m_open_handshake_timeout_dur(config::timeout_open_handshake)
-      , m_close_handshake_timeout_dur(config::timeout_close_handshake)
-      , m_pong_timeout_dur(config::timeout_pong)
-      , m_max_message_size(config::max_message_size)
-      , m_state(session::state::connecting)
-      , m_internal_state(session::internal_state::USER_INIT)
-      , m_msg_manager(new con_msg_manager_type())
-      , m_send_buffer_size(0)
-      , m_write_flag(false)
-      , m_read_flag(true)
-      , m_is_server(p_is_server)
-      , m_alog(alog)
-      , m_elog(elog)
-      , m_rng(rng)
-      , m_local_close_code(close::status::abnormal_close)
-      , m_remote_close_code(close::status::abnormal_close)
-      , m_is_http(false)
-      , m_http_state(session::http_state::init)
-      , m_was_clean(false)
-    {
-        m_alog->write(log::alevel::devel,"connection constructor");
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return lib::static_pointer_cast<type>(transport_con_type::get_shared());
-    }
-
-    ///////////////////////////
-    // Set Handler Callbacks //
-    ///////////////////////////
-
-    /// Set open handler
-    /**
-     * The open handler is called after the WebSocket handshake is complete and
-     * the connection is considered OPEN.
-     *
-     * @param h The new open_handler
-     */
-    void set_open_handler(open_handler h) {
-        m_open_handler = h;
-    }
-
-    /// Set close handler
-    /**
-     * The close handler is called immediately after the connection is closed.
-     *
-     * @param h The new close_handler
-     */
-    void set_close_handler(close_handler h) {
-        m_close_handler = h;
-    }
-
-    /// Set fail handler
-    /**
-     * The fail handler is called whenever the connection fails while the
-     * handshake is bring processed.
-     *
-     * @param h The new fail_handler
-     */
-    void set_fail_handler(fail_handler h) {
-        m_fail_handler = h;
-    }
-
-    /// Set ping handler
-    /**
-     * The ping handler is called whenever the connection receives a ping
-     * control frame. The ping payload is included.
-     *
-     * The ping handler's return time controls whether or not a pong is
-     * sent in response to this ping. Returning false will suppress the
-     * return pong. If no ping handler is set a pong will be sent.
-     *
-     * @param h The new ping_handler
-     */
-    void set_ping_handler(ping_handler h) {
-        m_ping_handler = h;
-    }
-
-    /// Set pong handler
-    /**
-     * The pong handler is called whenever the connection receives a pong
-     * control frame. The pong payload is included.
-     *
-     * @param h The new pong_handler
-     */
-    void set_pong_handler(pong_handler h) {
-        m_pong_handler = h;
-    }
-
-    /// Set pong timeout handler
-    /**
-     * If the transport component being used supports timers, the pong timeout
-     * handler is called whenever a pong control frame is not received with the
-     * configured timeout period after the application sends a ping.
-     *
-     * The config setting `timeout_pong` controls the length of the timeout
-     * period. It is specified in milliseconds.
-     *
-     * This can be used to probe the health of the remote endpoint's WebSocket
-     * implementation. This does not guarantee that the remote application
-     * itself is still healthy but can be a useful diagnostic.
-     *
-     * Note: receipt of this callback doesn't mean the pong will never come.
-     * This functionality will not suppress delivery of the pong in question
-     * should it arrive after the timeout.
-     *
-     * @param h The new pong_timeout_handler
-     */
-    void set_pong_timeout_handler(pong_timeout_handler h) {
-        m_pong_timeout_handler = h;
-    }
-
-    /// Set interrupt handler
-    /**
-     * The interrupt handler is called whenever the connection is manually
-     * interrupted by the application.
-     *
-     * @param h The new interrupt_handler
-     */
-    void set_interrupt_handler(interrupt_handler h) {
-        m_interrupt_handler = h;
-    }
-
-    /// Set http handler
-    /**
-     * The http handler is called after an HTTP request other than a WebSocket
-     * upgrade request is received. It allows a WebSocket++ server to respond
-     * to regular HTTP requests on the same port as it processes WebSocket
-     * connections. This can be useful for hosting error messages, flash
-     * policy files, status pages, and other simple HTTP responses. It is not
-     * intended to be used as a primary web server.
-     *
-     * @param h The new http_handler
-     */
-    void set_http_handler(http_handler h) {
-        m_http_handler = h;
-    }
-
-    /// Set validate handler
-    /**
-     * The validate handler is called after a WebSocket handshake has been
-     * parsed but before a response is returned. It provides the application
-     * a chance to examine the request and determine whether or not it wants
-     * to accept the connection.
-     *
-     * Returning false from the validate handler will reject the connection.
-     * If no validate handler is present, all connections will be allowed.
-     *
-     * @param h The new validate_handler
-     */
-    void set_validate_handler(validate_handler h) {
-        m_validate_handler = h;
-    }
-
-    /// Set message handler
-    /**
-     * The message handler is called after a new message has been received.
-     *
-     * @param h The new message_handler
-     */
-    void set_message_handler(message_handler h) {
-        m_message_handler = h;
-    }
-
-    //////////////////////////////////////////
-    // Connection timeouts and other limits //
-    //////////////////////////////////////////
-
-    /// Set open handshake timeout
-    /**
-     * Sets the length of time the library will wait after an opening handshake
-     * has been initiated before cancelling it. This can be used to prevent
-     * excessive wait times for outgoing clients or excessive resource usage
-     * from broken clients or DoS attacks on servers.
-     *
-     * Connections that time out will have their fail handlers called with the
-     * open_handshake_timeout error code.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_open_handshake'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the open handshake timeout in ms
-     */
-    void set_open_handshake_timeout(long dur) {
-        m_open_handshake_timeout_dur = dur;
-    }
-
-    /// Set close handshake timeout
-    /**
-     * Sets the length of time the library will wait after a closing handshake
-     * has been initiated before cancelling it. This can be used to prevent
-     * excessive wait times for outgoing clients or excessive resource usage
-     * from broken clients or DoS attacks on servers.
-     *
-     * Connections that time out will have their close handlers called with the
-     * close_handshake_timeout error code.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_close_handshake'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the close handshake timeout in ms
-     */
-    void set_close_handshake_timeout(long dur) {
-        m_close_handshake_timeout_dur = dur;
-    }
-
-    /// Set pong timeout
-    /**
-     * Sets the length of time the library will wait for a pong response to a
-     * ping. This can be used as a keepalive or to detect broken  connections.
-     *
-     * Pong responses that time out will have the pong timeout handler called.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_pong'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the pong timeout in ms
-     */
-    void set_pong_timeout(long dur) {
-        m_pong_timeout_dur = dur;
-    }
-
-    /// Get maximum message size
-    /**
-     * Get maximum message size. Maximum message size determines the point at 
-     * which the connection will fail with the message_too_big protocol error.
-     *
-     * The default is set by the endpoint that creates the connection.
-     *
-     * @since 0.3.0
-     */
-    size_t get_max_message_size() const {
-        return m_max_message_size;
-    }
-    
-    /// Set maximum message size
-    /**
-     * Set maximum message size. Maximum message size determines the point at 
-     * which the connection will fail with the message_too_big protocol error. 
-     * This value may be changed during the connection.
-     *
-     * The default is set by the endpoint that creates the connection.
-     *
-     * @since 0.3.0
-     *
-     * @param new_value The value to set as the maximum message size.
-     */
-    void set_max_message_size(size_t new_value) {
-        m_max_message_size = new_value;
-        if (m_processor) {
-            m_processor->set_max_message_size(new_value);
-        }
-    }
-    
-    /// Get maximum HTTP message body size
-    /**
-     * Get maximum HTTP message body size. Maximum message body size determines
-     * the point at which the connection will stop reading an HTTP request whose
-     * body is too large.
-     *
-     * The default is set by the endpoint that creates the connection.
-     *
-     * @since 0.5.0
-     *
-     * @return The maximum HTTP message body size
-     */
-    size_t get_max_http_body_size() const {
-        return m_request.get_max_body_size();
-    }
-    
-    /// Set maximum HTTP message body size
-    /**
-     * Set maximum HTTP message body size. Maximum message body size determines
-     * the point at which the connection will stop reading an HTTP request whose
-     * body is too large.
-     *
-     * The default is set by the endpoint that creates the connection.
-     *
-     * @since 0.5.0
-     *
-     * @param new_value The value to set as the maximum message size.
-     */
-    void set_max_http_body_size(size_t new_value) {
-        m_request.set_max_body_size(new_value);
-    }
-
-    //////////////////////////////////
-    // Uncategorized public methods //
-    //////////////////////////////////
-
-    /// Get the size of the outgoing write buffer (in payload bytes)
-    /**
-     * Retrieves the number of bytes in the outgoing write buffer that have not
-     * already been dispatched to the transport layer. This represents the bytes
-     * that are presently cancelable without uncleanly ending the websocket
-     * connection
-     *
-     * This method invokes the m_write_lock mutex
-     *
-     * @return The current number of bytes in the outgoing send buffer.
-     */
-    size_t get_buffered_amount() const;
-
-    /// Get the size of the outgoing write buffer (in payload bytes)
-    /**
-     * @deprecated use `get_buffered_amount` instead
-     */
-    size_t buffered_amount() const {
-        return get_buffered_amount();
-    }
-
-    ////////////////////
-    // Action Methods //
-    ////////////////////
-
-    /// Create a message and then add it to the outgoing send queue
-    /**
-     * Convenience method to send a message given a payload string and
-     * optionally an opcode. Default opcode is utf8 text.
-     *
-     * This method locks the m_write_lock mutex
-     *
-     * @param payload The payload string to generated the message with
-     *
-     * @param op The opcode to generated the message with. Default is
-     * frame::opcode::text
-     */
-    lib::error_code send(std::string const & payload, frame::opcode::value op =
-        frame::opcode::text);
-
-    /// Send a message (raw array overload)
-    /**
-     * Convenience method to send a message given a raw array and optionally an
-     * opcode. Default opcode is binary.
-     *
-     * This method locks the m_write_lock mutex
-     *
-     * @param payload A pointer to the array containing the bytes to send.
-     *
-     * @param len Length of the array.
-     *
-     * @param op The opcode to generated the message with. Default is
-     * frame::opcode::binary
-     */
-    lib::error_code send(void const * payload, size_t len, frame::opcode::value
-        op = frame::opcode::binary);
-
-    /// Add a message to the outgoing send queue
-    /**
-     * If presented with a prepared message it is added without validation or
-     * framing. If presented with an unprepared message it is validated, framed,
-     * and then added
-     *
-     * Errors are returned via an exception
-     * \todo make exception system_error rather than error_code
-     *
-     * This method invokes the m_write_lock mutex
-     *
-     * @param msg A message_ptr to the message to send.
-     */
-    lib::error_code send(message_ptr msg);
-
-    /// Asyncronously invoke handler::on_inturrupt
-    /**
-     * Signals to the connection to asyncronously invoke the on_inturrupt
-     * callback for this connection's handler once it is safe to do so.
-     *
-     * When the on_inturrupt handler callback is called it will be from
-     * within the transport event loop with all the thread safety features
-     * guaranteed by the transport to regular handlers
-     *
-     * Multiple inturrupt signals can be active at once on the same connection
-     *
-     * @return An error code
-     */
-    lib::error_code interrupt();
-    
-    /// Transport inturrupt callback
-    void handle_interrupt();
-    
-    /// Pause reading of new data
-    /**
-     * Signals to the connection to halt reading of new data. While reading is paused, 
-     * the connection will stop reading from its associated socket. In turn this will 
-     * result in TCP based flow control kicking in and slowing data flow from the remote
-     * endpoint.
-     *
-     * This is useful for applications that push new requests to a queue to be processed
-     * by another thread and need a way to signal when their request queue is full without
-     * blocking the network processing thread.
-     *
-     * Use `resume_reading()` to resume.
-     *
-     * If supported by the transport this is done asynchronously. As such reading may not
-     * stop until the current read operation completes. Typically you can expect to
-     * receive no more bytes after initiating a read pause than the size of the read 
-     * buffer.
-     *
-     * If reading is paused for this connection already nothing is changed.
-     */
-    lib::error_code pause_reading();
-
-    /// Pause reading callback
-    void handle_pause_reading();
-
-    /// Resume reading of new data
-    /**
-     * Signals to the connection to resume reading of new data after it was paused by
-     * `pause_reading()`.
-     *
-     * If reading is not paused for this connection already nothing is changed.
-     */
-    lib::error_code resume_reading();
-
-    /// Resume reading callback
-    void handle_resume_reading();
-
-    /// Send a ping
-    /**
-     * Initiates a ping with the given payload/
-     *
-     * There is no feedback directly from ping except in cases of immediately
-     * detectable errors. Feedback will be provided via on_pong or
-     * on_pong_timeout callbacks.
-     *
-     * Ping locks the m_write_lock mutex
-     *
-     * @param payload Payload to be used for the ping
-     */
-    void ping(std::string const & payload);
-
-    /// exception free variant of ping
-    void ping(std::string const & payload, lib::error_code & ec);
-
-    /// Utility method that gets called back when the ping timer expires
-    void handle_pong_timeout(std::string payload, lib::error_code const & ec);
-
-    /// Send a pong
-    /**
-     * Initiates a pong with the given payload.
-     *
-     * There is no feedback from a pong once sent.
-     *
-     * Pong locks the m_write_lock mutex
-     *
-     * @param payload Payload to be used for the pong
-     */
-    void pong(std::string const & payload);
-
-    /// exception free variant of pong
-    void pong(std::string const & payload, lib::error_code & ec);
-
-    /// Close the connection
-    /**
-     * Initiates the close handshake process.
-     *
-     * If close returns successfully the connection will be in the closing
-     * state and no additional messages may be sent. All messages sent prior
-     * to calling close will be written out before the connection is closed.
-     *
-     * If no reason is specified none will be sent. If no code is specified
-     * then no code will be sent.
-     *
-     * The handler's on_close callback will be called once the close handshake
-     * is complete.
-     *
-     * Reasons will be automatically truncated to the maximum length (123 bytes)
-     * if necessary.
-     *
-     * @param code The close code to send
-     * @param reason The close reason to send
-     */
-    void close(close::status::value const code, std::string const & reason);
-
-    /// exception free variant of close
-    void close(close::status::value const code, std::string const & reason,
-        lib::error_code & ec);
-
-    ////////////////////////////////////////////////
-    // Pass-through access to the uri information //
-    ////////////////////////////////////////////////
-
-    /// Returns the secure flag from the connection URI
-    /**
-     * This value is available after the HTTP request has been fully read and
-     * may be called from any thread.
-     *
-     * @return Whether or not the connection URI is flagged secure.
-     */
-    bool get_secure() const;
-
-    /// Returns the host component of the connection URI
-    /**
-     * This value is available after the HTTP request has been fully read and
-     * may be called from any thread.
-     *
-     * @return The host component of the connection URI
-     */
-    std::string const & get_host() const;
-
-    /// Returns the resource component of the connection URI
-    /**
-     * This value is available after the HTTP request has been fully read and
-     * may be called from any thread.
-     *
-     * @return The resource component of the connection URI
-     */
-    std::string const & get_resource() const;
-
-    /// Returns the port component of the connection URI
-    /**
-     * This value is available after the HTTP request has been fully read and
-     * may be called from any thread.
-     *
-     * @return The port component of the connection URI
-     */
-    uint16_t get_port() const;
-
-    /// Gets the connection URI
-    /**
-     * This should really only be called by internal library methods unless you
-     * really know what you are doing.
-     *
-     * @return A pointer to the connection's URI
-     */
-    uri_ptr get_uri() const;
-
-    /// Sets the connection URI
-    /**
-     * This should really only be called by internal library methods unless you
-     * really know what you are doing.
-     *
-     * @param uri The new URI to set
-     */
-    void set_uri(uri_ptr uri);
-
-    /////////////////////////////
-    // Subprotocol negotiation //
-    /////////////////////////////
-
-    /// Gets the negotated subprotocol
-    /**
-     * Retrieves the subprotocol that was negotiated during the handshake. This
-     * method is valid in the open handler and later.
-     *
-     * @return The negotiated subprotocol
-     */
-    std::string const & get_subprotocol() const;
-
-    /// Gets all of the subprotocols requested by the client
-    /**
-     * Retrieves the subprotocols that were requested during the handshake. This
-     * method is valid in the validate handler and later.
-     *
-     * @return A vector of the requested subprotocol
-     */
-    std::vector<std::string> const & get_requested_subprotocols() const;
-
-    /// Adds the given subprotocol string to the request list (exception free)
-    /**
-     * Adds a subprotocol to the list to send with the opening handshake. This
-     * may be called multiple times to request more than one. If the server
-     * supports one of these, it may choose one. If so, it will return it
-     * in it's handshake reponse and the value will be available via
-     * get_subprotocol(). Subprotocol requests should be added in order of
-     * preference.
-     *
-     * @param request The subprotocol to request
-     * @param ec A reference to an error code that will be filled in the case of
-     * errors
-     */
-    void add_subprotocol(std::string const & request, lib::error_code & ec);
-
-    /// Adds the given subprotocol string to the request list
-    /**
-     * Adds a subprotocol to the list to send with the opening handshake. This
-     * may be called multiple times to request more than one. If the server
-     * supports one of these, it may choose one. If so, it will return it
-     * in it's handshake reponse and the value will be available via
-     * get_subprotocol(). Subprotocol requests should be added in order of
-     * preference.
-     *
-     * @param request The subprotocol to request
-     */
-    void add_subprotocol(std::string const & request);
-
-    /// Select a subprotocol to use (exception free)
-    /**
-     * Indicates which subprotocol should be used for this connection. Valid
-     * only during the validate handler callback. Subprotocol selected must have
-     * been requested by the client. Consult get_requested_subprotocols() for a
-     * list of valid subprotocols.
-     *
-     * This member function is valid on server endpoints/connections only
-     *
-     * @param value The subprotocol to select
-     * @param ec A reference to an error code that will be filled in the case of
-     * errors
-     */
-    void select_subprotocol(std::string const & value, lib::error_code & ec);
-
-    /// Select a subprotocol to use
-    /**
-     * Indicates which subprotocol should be used for this connection. Valid
-     * only during the validate handler callback. Subprotocol selected must have
-     * been requested by the client. Consult get_requested_subprotocols() for a
-     * list of valid subprotocols.
-     *
-     * This member function is valid on server endpoints/connections only
-     *
-     * @param value The subprotocol to select
-     */
-    void select_subprotocol(std::string const & value);
-
-    /////////////////////////////////////////////////////////////
-    // Pass-through access to the request and response objects //
-    /////////////////////////////////////////////////////////////
-
-    /// Retrieve a request header
-    /**
-     * Retrieve the value of a header from the handshake HTTP request.
-     *
-     * @param key Name of the header to get
-     * @return The value of the header
-     */
-    std::string const & get_request_header(std::string const & key) const;
-
-    /// Retrieve a request body
-    /**
-     * Retrieve the value of the request body. This value is typically used with
-     * PUT and POST requests to upload files or other data. Only HTTP
-     * connections will ever have bodies. WebSocket connection's will always
-     * have blank bodies.
-     *
-     * @return The value of the request body.
-     */
-    std::string const & get_request_body() const;
-
-    /// Retrieve a response header
-    /**
-     * Retrieve the value of a header from the handshake HTTP request.
-     *
-     * @param key Name of the header to get
-     * @return The value of the header
-     */
-    std::string const & get_response_header(std::string const & key) const;
-
-    /// Get response HTTP status code
-    /**
-     * Gets the response status code 
-     *
-     * @since 0.7.0
-     *
-     * @return The response status code sent
-     */
-    http::status_code::value get_response_code() const {
-        return m_response.get_status_code();
-    }
-
-    /// Get response HTTP status message
-    /**
-     * Gets the response status message 
-     *
-     * @since 0.7.0
-     *
-     * @return The response status message sent
-     */
-    std::string const & get_response_msg() const {
-        return m_response.get_status_msg();
-    }
-    
-    /// Set response status code and message
-    /**
-     * Sets the response status code to `code` and looks up the corresponding
-     * message for standard codes. Non-standard codes will be entered as Unknown
-     * use set_status(status_code::value,std::string) overload to set both
-     * values explicitly.
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks.
-     *
-     * @param code Code to set
-     * @param msg Message to set
-     * @see websocketpp::http::response::set_status
-     */
-    void set_status(http::status_code::value code);
-
-    /// Set response status code and message
-    /**
-     * Sets the response status code and message to independent custom values.
-     * use set_status(status_code::value) to set the code and have the standard
-     * message be automatically set.
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks.
-     *
-     * @param code Code to set
-     * @param msg Message to set
-     * @see websocketpp::http::response::set_status
-     */
-    void set_status(http::status_code::value code, std::string const & msg);
-
-    /// Set response body content
-    /**
-     * Set the body content of the HTTP response to the parameter string. Note
-     * set_body will also set the Content-Length HTTP header to the appropriate
-     * value. If you want the Content-Length header to be something else set it
-     * to something else after calling set_body
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks.
-     *
-     * @param value String data to include as the body content.
-     * @see websocketpp::http::response::set_body
-     */
-    void set_body(std::string const & value);
-
-    /// Append a header
-    /**
-     * If a header with this name already exists the value will be appended to
-     * the existing header to form a comma separated list of values. Use
-     * `connection::replace_header` to overwrite existing values.
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks, or to a client connection before connect has been called.
-     *
-     * @param key Name of the header to set
-     * @param val Value to add
-     * @see replace_header
-     * @see websocketpp::http::parser::append_header
-     */
-    void append_header(std::string const & key, std::string const & val);
-
-    /// Replace a header
-    /**
-     * If a header with this name already exists the old value will be replaced
-     * Use `connection::append_header` to append to a list of existing values.
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks, or to a client connection before connect has been called.
-     *
-     * @param key Name of the header to set
-     * @param val Value to set
-     * @see append_header
-     * @see websocketpp::http::parser::replace_header
-     */
-    void replace_header(std::string const & key, std::string const & val);
-
-    /// Remove a header
-    /**
-     * Removes a header from the response.
-     *
-     * This member function is valid only from the http() and validate() handler
-     * callbacks, or to a client connection before connect has been called.
-     *
-     * @param key The name of the header to remove
-     * @see websocketpp::http::parser::remove_header
-     */
-    void remove_header(std::string const & key);
-
-    /// Get request object
-    /**
-     * Direct access to request object. This can be used to call methods of the
-     * request object that are not part of the standard request API that
-     * connection wraps.
-     *
-     * Note use of this method involves using behavior specific to the
-     * configured HTTP policy. Such behavior may not work with alternate HTTP
-     * policies.
-     *
-     * @since 0.3.0-alpha3
-     *
-     * @return A const reference to the raw request object
-     */
-    request_type const & get_request() const {
-        return m_request;
-    }
-    
-    /// Get response object
-    /**
-     * Direct access to the HTTP response sent or received as a part of the
-     * opening handshake. This can be used to call methods of the response
-     * object that are not part of the standard request API that connection
-     * wraps.
-     *
-     * Note use of this method involves using behavior specific to the
-     * configured HTTP policy. Such behavior may not work with alternate HTTP
-     * policies.
-     *
-     * @since 0.7.0
-     *
-     * @return A const reference to the raw response object
-     */
-    response_type const & get_response() const {
-        return m_response;
-    }
-    
-    /// Defer HTTP Response until later (Exception free)
-    /**
-     * Used in the http handler to defer the HTTP response for this connection
-     * until later. Handshake timers will be canceled and the connection will be
-     * left open until `send_http_response` or an equivalent is called.
-     *
-     * Warning: deferred connections won't time out and as a result can tie up
-     * resources.
-     *
-     * @since 0.6.0
-     *
-     * @return A status code, zero on success, non-zero otherwise
-     */
-    lib::error_code defer_http_response();
-    
-    /// Send deferred HTTP Response (exception free)
-    /**
-     * Sends an http response to an HTTP connection that was deferred. This will
-     * send a complete response including all headers, status line, and body
-     * text. The connection will be closed afterwards.
-     *
-     * @since 0.6.0
-     *
-     * @param ec A status code, zero on success, non-zero otherwise
-     */
-    void send_http_response(lib::error_code & ec);
-    
-    /// Send deferred HTTP Response
-    void send_http_response();
-    
-    // TODO HTTPNBIO: write_headers
-    // function that processes headers + status so far and writes it to the wire
-    // beginning the HTTP response body state. This method will ignore anything
-    // in the response body.
-    
-    // TODO HTTPNBIO: write_body_message
-    // queues the specified message_buffer for async writing
-    
-    // TODO HTTPNBIO: finish connection
-    //
-    
-    // TODO HTTPNBIO: write_response
-    // Writes the whole response, headers + body and closes the connection
-    
-    
-
-    /////////////////////////////////////////////////////////////
-    // Pass-through access to the other connection information //
-    /////////////////////////////////////////////////////////////
-
-    /// Get Connection Handle
-    /**
-     * The connection handle is a token that can be shared outside the
-     * WebSocket++ core for the purposes of identifying a connection and
-     * sending it messages.
-     *
-     * @return A handle to the connection
-     */
-    connection_hdl get_handle() const {
-        return m_connection_hdl;
-    }
-
-    /// Get whether or not this connection is part of a server or client
-    /**
-     * @return whether or not the connection is attached to a server endpoint
-     */
-    bool is_server() const {
-        return m_is_server;
-    }
-
-    /// Return the same origin policy origin value from the opening request.
-    /**
-     * This value is available after the HTTP request has been fully read and
-     * may be called from any thread.
-     *
-     * @return The connection's origin value from the opening handshake.
-     */
-    std::string const & get_origin() const;
-
-    /// Return the connection state.
-    /**
-     * Values can be connecting, open, closing, and closed
-     *
-     * @return The connection's current state.
-     */
-    session::state::value get_state() const;
-
-
-    /// Get the WebSocket close code sent by this endpoint.
-    /**
-     * @return The WebSocket close code sent by this endpoint.
-     */
-    close::status::value get_local_close_code() const {
-        return m_local_close_code;
-    }
-
-    /// Get the WebSocket close reason sent by this endpoint.
-    /**
-     * @return The WebSocket close reason sent by this endpoint.
-     */
-    std::string const & get_local_close_reason() const {
-        return m_local_close_reason;
-    }
-
-    /// Get the WebSocket close code sent by the remote endpoint.
-    /**
-     * @return The WebSocket close code sent by the remote endpoint.
-     */
-    close::status::value get_remote_close_code() const {
-        return m_remote_close_code;
-    }
-
-    /// Get the WebSocket close reason sent by the remote endpoint.
-    /**
-     * @return The WebSocket close reason sent by the remote endpoint.
-     */
-    std::string const & get_remote_close_reason() const {
-        return m_remote_close_reason;
-    }
-
-    /// Get the internal error code for a closed/failed connection
-    /**
-     * Retrieves a machine readable detailed error code indicating the reason
-     * that the connection was closed or failed. Valid only after the close or
-     * fail handler is called.
-     *
-     * @return Error code indicating the reason the connection was closed or
-     * failed
-     */
-    lib::error_code get_ec() const {
-        return m_ec;
-    }
-
-    /// Get a message buffer
-    /**
-     * Warning: The API related to directly sending message buffers may change
-     * before the 1.0 release. If you plan to use it, please keep an eye on any
-     * breaking changes notifications in future release notes. Also if you have
-     * any feedback about usage and capabilities now is a great time to provide
-     * it.
-     *
-     * Message buffers are used to store message payloads and other message
-     * metadata.
-     *
-     * The size parameter is a hint only. Your final payload does not need to
-     * match it. There may be some performance benefits if the initial size
-     * guess is equal to or slightly higher than the final payload size.
-     *
-     * @param op The opcode for the new message
-     * @param size A hint to optimize the initial allocation of payload space.
-     * @return A new message buffer
-     */
-    message_ptr get_message(websocketpp::frame::opcode::value op, size_t size)
-        const
-    {
-        return m_msg_manager->get_message(op, size);
-    }
-
-    ////////////////////////////////////////////////////////////////////////
-    // The remaining public member functions are for internal/policy use  //
-    // only. Do not call from application code unless you understand what //
-    // you are doing.                                                     //
-    ////////////////////////////////////////////////////////////////////////
-
-    
-
-    void read_handshake(size_t num_bytes);
-
-    void handle_read_handshake(lib::error_code const & ec,
-        size_t bytes_transferred);
-    void handle_read_http_response(lib::error_code const & ec,
-        size_t bytes_transferred);
-
-    
-    void handle_write_http_response(lib::error_code const & ec);
-    void handle_send_http_request(lib::error_code const & ec);
-
-    void handle_open_handshake_timeout(lib::error_code const & ec);
-    void handle_close_handshake_timeout(lib::error_code const & ec);
-
-    void handle_read_frame(lib::error_code const & ec, size_t bytes_transferred);
-    void read_frame();
-
-    /// Get array of WebSocket protocol versions that this connection supports.
-    std::vector<int> const & get_supported_versions() const;
-
-    /// Sets the handler for a terminating connection. Should only be used
-    /// internally by the endpoint class.
-    void set_termination_handler(termination_handler new_handler);
-
-    void terminate(lib::error_code const & ec);
-    void handle_terminate(terminate_status tstat, lib::error_code const & ec);
-
-    /// Checks if there are frames in the send queue and if there are sends one
-    /**
-     * \todo unit tests
-     *
-     * This method locks the m_write_lock mutex
-     */
-    void write_frame();
-
-    /// Process the results of a frame write operation and start the next write
-    /**
-     * \todo unit tests
-     *
-     * This method locks the m_write_lock mutex
-     *
-     * @param terminate Whether or not to terminate the connection upon
-     * completion of this write.
-     *
-     * @param ec A status code from the transport layer, zero on success,
-     * non-zero otherwise.
-     */
-    void handle_write_frame(lib::error_code const & ec);
-// protected:
-    // This set of methods would really like to be protected, but doing so 
-    // requires that the endpoint be able to friend the connection. This is 
-    // allowed with C++11, but not prior versions
-
-    /// Start the connection state machine
-    void start();
-
-    /// Set Connection Handle
-    /**
-     * The connection handle is a token that can be shared outside the
-     * WebSocket++ core for the purposes of identifying a connection and
-     * sending it messages.
-     *
-     * @param hdl A connection_hdl that the connection will use to refer
-     * to itself.
-     */
-    void set_handle(connection_hdl hdl) {
-        m_connection_hdl = hdl;
-        transport_con_type::set_handle(hdl);
-    }
-protected:
-    void handle_transport_init(lib::error_code const & ec);
-
-    /// Set m_processor based on information in m_request. Set m_response
-    /// status and return an error code indicating status.
-    lib::error_code initialize_processor();
-
-    /// Perform WebSocket handshake validation of m_request using m_processor.
-    /// set m_response and return an error code indicating status.
-    lib::error_code process_handshake_request();
-private:
-    
-
-    /// Completes m_response, serializes it, and sends it out on the wire.
-    void write_http_response(lib::error_code const & ec);
-
-    /// Sends an opening WebSocket connect request
-    void send_http_request();
-
-    /// Alternate path for write_http_response in error conditions
-    void write_http_response_error(lib::error_code const & ec);
-
-    /// Process control message
-    /**
-     *
-     */
-    void process_control_frame(message_ptr msg);
-
-    /// Send close acknowledgement
-    /**
-     * If no arguments are present no close code/reason will be specified.
-     *
-     * Note: the close code/reason values provided here may be overrided by
-     * other settings (such as silent close).
-     *
-     * @param code The close code to send
-     * @param reason The close reason to send
-     * @return A status code, zero on success, non-zero otherwise
-     */
-    lib::error_code send_close_ack(close::status::value code =
-        close::status::blank, std::string const & reason = std::string());
-
-    /// Send close frame
-    /**
-     * If no arguments are present no close code/reason will be specified.
-     *
-     * Note: the close code/reason values provided here may be overrided by
-     * other settings (such as silent close).
-     *
-     * The ack flag determines what to do in the case of a blank status and
-     * whether or not to terminate the TCP connection after sending it.
-     *
-     * @param code The close code to send
-     * @param reason The close reason to send
-     * @param ack Whether or not this is an acknowledgement close frame
-     * @return A status code, zero on success, non-zero otherwise
-     */
-    lib::error_code send_close_frame(close::status::value code =
-        close::status::blank, std::string const & reason = std::string(), bool ack = false,
-        bool terminal = false);
-
-    /// Get a pointer to a new WebSocket protocol processor for a given version
-    /**
-     * @param version Version number of the WebSocket protocol to get a
-     * processor for. Negative values indicate invalid/unknown versions and will
-     * always return a null ptr
-     *
-     * @return A shared_ptr to a new instance of the appropriate processor or a
-     * null ptr if there is no installed processor that matches the version
-     * number.
-     */
-    processor_ptr get_processor(int version) const;
-
-    /// Add a message to the write queue
-    /**
-     * Adds a message to the write queue and updates any associated shared state
-     *
-     * Must be called while holding m_write_lock
-     *
-     * @todo unit tests
-     *
-     * @param msg The message to push
-     */
-    void write_push(message_ptr msg);
-
-    /// Pop a message from the write queue
-    /**
-     * Removes and returns a message from the write queue and updates any
-     * associated shared state.
-     *
-     * Must be called while holding m_write_lock
-     *
-     * @todo unit tests
-     *
-     * @return the message_ptr at the front of the queue
-     */
-    message_ptr write_pop();
-
-    /// Prints information about the incoming connection to the access log
-    /**
-     * Prints information about the incoming connection to the access log.
-     * Includes: connection type, websocket version, remote endpoint, user agent
-     * path, status code.
-     */
-    void log_open_result();
-
-    /// Prints information about a connection being closed to the access log
-    /**
-     * Includes: local and remote close codes and reasons
-     */
-    void log_close_result();
-
-    /// Prints information about a connection being failed to the access log
-    /**
-     * Includes: error code and message for why it was failed
-     */
-    void log_fail_result();
-    
-    /// Prints information about HTTP connections
-    /**
-     * Includes: TODO
-     */
-    void log_http_result();
-
-    /// Prints information about an arbitrary error code on the specified channel
-    template <typename error_type>
-    void log_err(log::level l, char const * msg, error_type const & ec) {
-        std::stringstream s;
-        s << msg << " error: " << ec << " (" << ec.message() << ")";
-        m_elog->write(l, s.str());
-    }
-
-    // internal handler functions
-    read_handler            m_handle_read_frame;
-    write_frame_handler     m_write_frame_handler;
-
-    // static settings
-    std::string const       m_user_agent;
-
-    /// Pointer to the connection handle
-    connection_hdl          m_connection_hdl;
-
-    /// Handler objects
-    open_handler            m_open_handler;
-    close_handler           m_close_handler;
-    fail_handler            m_fail_handler;
-    ping_handler            m_ping_handler;
-    pong_handler            m_pong_handler;
-    pong_timeout_handler    m_pong_timeout_handler;
-    interrupt_handler       m_interrupt_handler;
-    http_handler            m_http_handler;
-    validate_handler        m_validate_handler;
-    message_handler         m_message_handler;
-
-    /// constant values
-    long                    m_open_handshake_timeout_dur;
-    long                    m_close_handshake_timeout_dur;
-    long                    m_pong_timeout_dur;
-    size_t                  m_max_message_size;
-
-    /// External connection state
-    /**
-     * Lock: m_connection_state_lock
-     */
-    session::state::value   m_state;
-
-    /// Internal connection state
-    /**
-     * Lock: m_connection_state_lock
-     */
-    istate_type             m_internal_state;
-
-    mutable mutex_type      m_connection_state_lock;
-
-    /// The lock used to protect the message queue
-    /**
-     * Serializes access to the write queue as well as shared state within the
-     * processor.
-     */
-    mutex_type              m_write_lock;
-
-    // connection resources
-    char                    m_buf[config::connection_read_buffer_size];
-    size_t                  m_buf_cursor;
-    termination_handler     m_termination_handler;
-    con_msg_manager_ptr     m_msg_manager;
-    timer_ptr               m_handshake_timer;
-    timer_ptr               m_ping_timer;
-
-    /// @todo this is not memory efficient. this value is not used after the
-    /// handshake.
-    std::string m_handshake_buffer;
-
-    /// Pointer to the processor object for this connection
-    /**
-     * The processor provides functionality that is specific to the WebSocket
-     * protocol version that the client has negotiated. It also contains all of
-     * the state necessary to encode and decode the incoming and outgoing
-     * WebSocket byte streams
-     *
-     * Use of the prepare_data_frame method requires lock: m_write_lock
-     */
-    processor_ptr           m_processor;
-
-    /// Queue of unsent outgoing messages
-    /**
-     * Lock: m_write_lock
-     */
-    std::queue<message_ptr> m_send_queue;
-
-    /// Size in bytes of the outstanding payloads in the write queue
-    /**
-     * Lock: m_write_lock
-     */
-    size_t m_send_buffer_size;
-
-    /// buffer holding the various parts of the current message being writen
-    /**
-     * Lock m_write_lock
-     */
-    std::vector<transport::buffer> m_send_buffer;
-
-    /// a list of pointers to hold on to the messages being written to keep them
-    /// from going out of scope before the write is complete.
-    std::vector<message_ptr> m_current_msgs;
-
-    /// True if there is currently an outstanding transport write
-    /**
-     * Lock m_write_lock
-     */
-    bool m_write_flag;
-
-    /// True if this connection is presently reading new data
-    bool m_read_flag;
-
-    // connection data
-    request_type            m_request;
-    response_type           m_response;
-    uri_ptr                 m_uri;
-    std::string             m_subprotocol;
-
-    // connection data that might not be necessary to keep around for the life
-    // of the whole connection.
-    std::vector<std::string> m_requested_subprotocols;
-
-    bool const              m_is_server;
-    const lib::shared_ptr<alog_type> m_alog;
-    const lib::shared_ptr<elog_type> m_elog;
-
-    rng_type & m_rng;
-
-    // Close state
-    /// Close code that was sent on the wire by this endpoint
-    close::status::value    m_local_close_code;
-
-    /// Close reason that was sent on the wire by this endpoint
-    std::string             m_local_close_reason;
-
-    /// Close code that was received on the wire from the remote endpoint
-    close::status::value    m_remote_close_code;
-
-    /// Close reason that was received on the wire from the remote endpoint
-    std::string             m_remote_close_reason;
-
-    /// Detailed internal error code
-    lib::error_code m_ec;
-    
-    /// A flag that gets set once it is determined that the connection is an
-    /// HTTP connection and not a WebSocket one.
-    bool m_is_http;
-    
-    /// A flag that gets set when the completion of an http connection is
-    /// deferred until later.
-    session::http_state::value m_http_state;
-
-    bool m_was_clean;
-};
-
-} // namespace websocketpp
-
-#include <websocketpp/impl/connection_impl.hpp>
-
-#endif // WEBSOCKETPP_CONNECTION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection_base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection_base.hpp
deleted file mode 100644
index 2e70096..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/connection_base.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONNECTION_BASE_HPP
-#define WEBSOCKETPP_CONNECTION_BASE_HPP
-
-namespace websocketpp {
-
-/// Stub for user supplied base class.
-class connection_base {};
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONNECTION_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint.hpp
deleted file mode 100644
index c124b1d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint.hpp
+++ /dev/null
@@ -1,700 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_ENDPOINT_HPP
-#define WEBSOCKETPP_ENDPOINT_HPP
-
-#include <websocketpp/connection.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-#include <websocketpp/version.hpp>
-
-#include <string>
-
-namespace websocketpp {
-
-/// Creates and manages connections associated with a WebSocket endpoint
-template <typename connection, typename config>
-class endpoint : public config::transport_type, public config::endpoint_base {
-public:
-    // Import appropriate types from our helper class
-    // See endpoint_types for more details.
-    typedef endpoint<connection,config> type;
-
-    /// Type of the transport component of this endpoint
-    typedef typename config::transport_type transport_type;
-    /// Type of the concurrency component of this endpoint
-    typedef typename config::concurrency_type concurrency_type;
-
-    /// Type of the connections that this endpoint creates
-    typedef connection connection_type;
-    /// Shared pointer to connection_type
-    typedef typename connection_type::ptr connection_ptr;
-    /// Weak pointer to connection type
-    typedef typename connection_type::weak_ptr connection_weak_ptr;
-
-    /// Type of the transport component of the connections that this endpoint
-    /// creates
-    typedef typename transport_type::transport_con_type transport_con_type;
-    /// Type of a shared pointer to the transport component of the connections
-    /// that this endpoint creates.
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    /// Type of message_handler
-    typedef typename connection_type::message_handler message_handler;
-    /// Type of message pointers that this endpoint uses
-    typedef typename connection_type::message_ptr message_ptr;
-
-    /// Type of error logger
-    typedef typename config::elog_type elog_type;
-    /// Type of access logger
-    typedef typename config::alog_type alog_type;
-
-    /// Type of our concurrency policy's scoped lock object
-    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
-    /// Type of our concurrency policy's mutex object
-    typedef typename concurrency_type::mutex_type mutex_type;
-
-    /// Type of RNG
-    typedef typename config::rng_type rng_type;
-
-    // TODO: organize these
-    typedef typename connection_type::termination_handler termination_handler;
-
-    // This would be ideal. Requires C++11 though
-    //friend connection;
-
-    explicit endpoint(bool p_is_server)
-      : m_alog(new alog_type(config::alog_level, log::channel_type_hint::access))
-      , m_elog(new elog_type(config::elog_level, log::channel_type_hint::error))
-      , m_user_agent(::websocketpp::user_agent)
-      , m_open_handshake_timeout_dur(config::timeout_open_handshake)
-      , m_close_handshake_timeout_dur(config::timeout_close_handshake)
-      , m_pong_timeout_dur(config::timeout_pong)
-      , m_max_message_size(config::max_message_size)
-      , m_max_http_body_size(config::max_http_body_size)
-      , m_is_server(p_is_server)
-    {
-        m_alog->set_channels(config::alog_level);
-        m_elog->set_channels(config::elog_level);
-
-        m_alog->write(log::alevel::devel, "endpoint constructor");
-
-        transport_type::init_logging(m_alog, m_elog);
-    }
-
-
-    /// Destructor
-    ~endpoint<connection,config>() {}
-
-    #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-        // no copy constructor because endpoints are not copyable
-        endpoint(endpoint &) = delete;
-    
-        // no copy assignment operator because endpoints are not copyable
-        endpoint & operator=(endpoint const &) = delete;
-    #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-    #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-        /// Move constructor
-        endpoint(endpoint && o) 
-         : config::transport_type(std::move(o))
-         , config::endpoint_base(std::move(o))
-         , m_alog(std::move(o.m_alog))
-         , m_elog(std::move(o.m_elog))
-         , m_user_agent(std::move(o.m_user_agent))
-         , m_open_handler(std::move(o.m_open_handler))
-         
-         , m_close_handler(std::move(o.m_close_handler))
-         , m_fail_handler(std::move(o.m_fail_handler))
-         , m_ping_handler(std::move(o.m_ping_handler))
-         , m_pong_handler(std::move(o.m_pong_handler))
-         , m_pong_timeout_handler(std::move(o.m_pong_timeout_handler))
-         , m_interrupt_handler(std::move(o.m_interrupt_handler))
-         , m_http_handler(std::move(o.m_http_handler))
-         , m_validate_handler(std::move(o.m_validate_handler))
-         , m_message_handler(std::move(o.m_message_handler))
-
-         , m_open_handshake_timeout_dur(o.m_open_handshake_timeout_dur)
-         , m_close_handshake_timeout_dur(o.m_close_handshake_timeout_dur)
-         , m_pong_timeout_dur(o.m_pong_timeout_dur)
-         , m_max_message_size(o.m_max_message_size)
-         , m_max_http_body_size(o.m_max_http_body_size)
-
-         , m_rng(std::move(o.m_rng))
-         , m_is_server(o.m_is_server)         
-        {}
-
-    #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-        // no move assignment operator because of const member variables
-        endpoint & operator=(endpoint &&) = delete;
-    #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-    #endif // _WEBSOCKETPP_MOVE_SEMANTICS_
-
-
-    /// Returns the user agent string that this endpoint will use
-    /**
-     * Returns the user agent string that this endpoint will use when creating
-     * new connections.
-     *
-     * The default value for this version is stored in websocketpp::user_agent
-     *
-     * @return The user agent string.
-     */
-    std::string get_user_agent() const {
-        scoped_lock_type guard(m_mutex);
-        return m_user_agent;
-    }
-
-    /// Sets the user agent string that this endpoint will use
-    /**
-     * Sets the identifier that this endpoint will use when creating new
-     * connections. Changing this value will only affect future connections.
-     * For client endpoints this will be sent as the "User-Agent" header in
-     * outgoing requests. For server endpoints this will be sent in the "Server"
-     * response header.
-     *
-     * Setting this value to the empty string will suppress the use of the
-     * Server and User-Agent headers. This is typically done to hide
-     * implementation details for security purposes.
-     *
-     * For best results set this before accepting or opening connections.
-     *
-     * The default value for this version is stored in websocketpp::user_agent
-     *
-     * This can be overridden on an individual connection basis by setting a
-     * custom "Server" header during the validate handler or "User-Agent"
-     * header on a connection before calling connect().
-     *
-     * @param ua The string to set the user agent to.
-     */
-    void set_user_agent(std::string const & ua) {
-        scoped_lock_type guard(m_mutex);
-        m_user_agent = ua;
-    }
-
-    /// Returns whether or not this endpoint is a server.
-    /**
-     * @return Whether or not this endpoint is a server
-     */
-    bool is_server() const {
-        return m_is_server;
-    }
-
-    /********************************/
-    /* Pass-through logging adaptor */
-    /********************************/
-
-    /// Set Access logging channel
-    /**
-     * Set the access logger's channel value. The value is a number whose
-     * interpretation depends on the logging policy in use.
-     *
-     * @param channels The channel value(s) to set
-     */
-    void set_access_channels(log::level channels) {
-        m_alog->set_channels(channels);
-    }
-
-    /// Clear Access logging channels
-    /**
-     * Clear the access logger's channel value. The value is a number whose
-     * interpretation depends on the logging policy in use.
-     *
-     * @param channels The channel value(s) to clear
-     */
-    void clear_access_channels(log::level channels) {
-        m_alog->clear_channels(channels);
-    }
-
-    /// Set Error logging channel
-    /**
-     * Set the error logger's channel value. The value is a number whose
-     * interpretation depends on the logging policy in use.
-     *
-     * @param channels The channel value(s) to set
-     */
-    void set_error_channels(log::level channels) {
-        m_elog->set_channels(channels);
-    }
-
-    /// Clear Error logging channels
-    /**
-     * Clear the error logger's channel value. The value is a number whose
-     * interpretation depends on the logging policy in use.
-     *
-     * @param channels The channel value(s) to clear
-     */
-    void clear_error_channels(log::level channels) {
-        m_elog->clear_channels(channels);
-    }
-
-    /// Get reference to access logger
-    /**
-     * @return A reference to the access logger
-     */
-    alog_type & get_alog() {
-        return *m_alog;
-    }
-
-    /// Get reference to error logger
-    /**
-     * @return A reference to the error logger
-     */
-    elog_type & get_elog() {
-        return *m_elog;
-    }
-
-    /*************************/
-    /* Set Handler functions */
-    /*************************/
-
-    void set_open_handler(open_handler h) {
-        m_alog->write(log::alevel::devel,"set_open_handler");
-        scoped_lock_type guard(m_mutex);
-        m_open_handler = h;
-    }
-    void set_close_handler(close_handler h) {
-        m_alog->write(log::alevel::devel,"set_close_handler");
-        scoped_lock_type guard(m_mutex);
-        m_close_handler = h;
-    }
-    void set_fail_handler(fail_handler h) {
-        m_alog->write(log::alevel::devel,"set_fail_handler");
-        scoped_lock_type guard(m_mutex);
-        m_fail_handler = h;
-    }
-    void set_ping_handler(ping_handler h) {
-        m_alog->write(log::alevel::devel,"set_ping_handler");
-        scoped_lock_type guard(m_mutex);
-        m_ping_handler = h;
-    }
-    void set_pong_handler(pong_handler h) {
-        m_alog->write(log::alevel::devel,"set_pong_handler");
-        scoped_lock_type guard(m_mutex);
-        m_pong_handler = h;
-    }
-    void set_pong_timeout_handler(pong_timeout_handler h) {
-        m_alog->write(log::alevel::devel,"set_pong_timeout_handler");
-        scoped_lock_type guard(m_mutex);
-        m_pong_timeout_handler = h;
-    }
-    void set_interrupt_handler(interrupt_handler h) {
-        m_alog->write(log::alevel::devel,"set_interrupt_handler");
-        scoped_lock_type guard(m_mutex);
-        m_interrupt_handler = h;
-    }
-    void set_http_handler(http_handler h) {
-        m_alog->write(log::alevel::devel,"set_http_handler");
-        scoped_lock_type guard(m_mutex);
-        m_http_handler = h;
-    }
-    void set_validate_handler(validate_handler h) {
-        m_alog->write(log::alevel::devel,"set_validate_handler");
-        scoped_lock_type guard(m_mutex);
-        m_validate_handler = h;
-    }
-    void set_message_handler(message_handler h) {
-        m_alog->write(log::alevel::devel,"set_message_handler");
-        scoped_lock_type guard(m_mutex);
-        m_message_handler = h;
-    }
-
-    //////////////////////////////////////////
-    // Connection timeouts and other limits //
-    //////////////////////////////////////////
-
-    /// Set open handshake timeout
-    /**
-     * Sets the length of time the library will wait after an opening handshake
-     * has been initiated before cancelling it. This can be used to prevent
-     * excessive wait times for outgoing clients or excessive resource usage
-     * from broken clients or DoS attacks on servers.
-     *
-     * Connections that time out will have their fail handlers called with the
-     * open_handshake_timeout error code.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_open_handshake'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the open handshake timeout in ms
-     */
-    void set_open_handshake_timeout(long dur) {
-        scoped_lock_type guard(m_mutex);
-        m_open_handshake_timeout_dur = dur;
-    }
-
-    /// Set close handshake timeout
-    /**
-     * Sets the length of time the library will wait after a closing handshake
-     * has been initiated before cancelling it. This can be used to prevent
-     * excessive wait times for outgoing clients or excessive resource usage
-     * from broken clients or DoS attacks on servers.
-     *
-     * Connections that time out will have their close handlers called with the
-     * close_handshake_timeout error code.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_close_handshake'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the close handshake timeout in ms
-     */
-    void set_close_handshake_timeout(long dur) {
-        scoped_lock_type guard(m_mutex);
-        m_close_handshake_timeout_dur = dur;
-    }
-
-    /// Set pong timeout
-    /**
-     * Sets the length of time the library will wait for a pong response to a
-     * ping. This can be used as a keepalive or to detect broken  connections.
-     *
-     * Pong responses that time out will have the pong timeout handler called.
-     *
-     * The default value is specified via the compile time config value
-     * 'timeout_pong'. The default value in the core config
-     * is 5000ms. A value of 0 will disable the timer entirely.
-     *
-     * To be effective, the transport you are using must support timers. See
-     * the documentation for your transport policy for details about its
-     * timer support.
-     *
-     * @param dur The length of the pong timeout in ms
-     */
-    void set_pong_timeout(long dur) {
-        scoped_lock_type guard(m_mutex);
-        m_pong_timeout_dur = dur;
-    }
-
-    /// Get default maximum message size
-    /**
-     * Get the default maximum message size that will be used for new 
-     * connections created by this endpoint. The maximum message size determines
-     * the point at which the connection will fail a connection with the 
-     * message_too_big protocol error.
-     *
-     * The default is set by the max_message_size value from the template config
-     *
-     * @since 0.3.0
-     */
-    size_t get_max_message_size() const {
-        return m_max_message_size;
-    }
-    
-    /// Set default maximum message size
-    /**
-     * Set the default maximum message size that will be used for new 
-     * connections created by this endpoint. Maximum message size determines the
-     * point at which the connection will fail a connection with the
-     * message_too_big protocol error.
-     *
-     * The default is set by the max_message_size value from the template config
-     *
-     * @since 0.3.0
-     *
-     * @param new_value The value to set as the maximum message size.
-     */
-    void set_max_message_size(size_t new_value) {
-        m_max_message_size = new_value;
-    }
-
-    /// Get maximum HTTP message body size
-    /**
-     * Get maximum HTTP message body size. Maximum message body size determines
-     * the point at which the connection will stop reading an HTTP request whose
-     * body is too large.
-     *
-     * The default is set by the max_http_body_size value from the template
-     * config
-     *
-     * @since 0.5.0
-     *
-     * @return The maximum HTTP message body size
-     */
-    size_t get_max_http_body_size() const {
-        return m_max_http_body_size;
-    }
-    
-    /// Set maximum HTTP message body size
-    /**
-     * Set maximum HTTP message body size. Maximum message body size determines
-     * the point at which the connection will stop reading an HTTP request whose
-     * body is too large.
-     *
-     * The default is set by the max_http_body_size value from the template
-     * config
-     *
-     * @since 0.5.1
-     *
-     * @param new_value The value to set as the maximum message size.
-     */
-    void set_max_http_body_size(size_t new_value) {
-        m_max_http_body_size = new_value;
-    }
-
-    /*************************************/
-    /* Connection pass through functions */
-    /*************************************/
-
-    /**
-     * These functions act as adaptors to their counterparts in connection. They
-     * can produce one additional type of error, the bad_connection error, that
-     * indicates that the conversion from connection_hdl to connection_ptr
-     * failed due to the connection not existing anymore. Each method has a
-     * default and an exception free varient.
-     */
-
-    void interrupt(connection_hdl hdl, lib::error_code & ec);
-    void interrupt(connection_hdl hdl);
-
-    /// Pause reading of new data (exception free)
-    /**
-     * Signals to the connection to halt reading of new data. While reading is 
-     * paused, the connection will stop reading from its associated socket. In
-     * turn this will result in TCP based flow control kicking in and slowing
-     * data flow from the remote endpoint.
-     *
-     * This is useful for applications that push new requests to a queue to be 
-     * processed by another thread and need a way to signal when their request
-     * queue is full without blocking the network processing thread.
-     *
-     * Use `resume_reading()` to resume.
-     *
-     * If supported by the transport this is done asynchronously. As such
-     * reading may not stop until the current read operation completes. 
-     * Typically you can expect to receive no more bytes after initiating a read
-     * pause than the size of the read buffer.
-     *
-     * If reading is paused for this connection already nothing is changed.
-     */
-    void pause_reading(connection_hdl hdl, lib::error_code & ec);
-    
-    /// Pause reading of new data
-    void pause_reading(connection_hdl hdl);
-
-    /// Resume reading of new data (exception free)
-    /**
-     * Signals to the connection to resume reading of new data after it was 
-     * paused by `pause_reading()`.
-     *
-     * If reading is not paused for this connection already nothing is changed.
-     */
-    void resume_reading(connection_hdl hdl, lib::error_code & ec);
-
-    /// Resume reading of new data
-    void resume_reading(connection_hdl hdl);
-
-    /// Send deferred HTTP Response
-    /**
-     * Sends an http response to an HTTP connection that was deferred. This will
-     * send a complete response including all headers, status line, and body
-     * text. The connection will be closed afterwards.
-     *
-     * Exception free variant
-     *
-     * @since 0.6.0
-     *
-     * @param hdl The connection to send the response on
-     * @param ec A status code, zero on success, non-zero otherwise
-     */
-    void send_http_response(connection_hdl hdl, lib::error_code & ec);
-        
-    /// Send deferred HTTP Response (exception free)
-    /**
-     * Sends an http response to an HTTP connection that was deferred. This will
-     * send a complete response including all headers, status line, and body
-     * text. The connection will be closed afterwards.
-     *
-     * Exception variant
-     *
-     * @since 0.6.0
-     *
-     * @param hdl The connection to send the response on
-     */
-    void send_http_response(connection_hdl hdl);
-
-    /// Create a message and add it to the outgoing send queue (exception free)
-    /**
-     * Convenience method to send a message given a payload string and an opcode
-     *
-     * @param [in] hdl The handle identifying the connection to send via.
-     * @param [in] payload The payload string to generated the message with
-     * @param [in] op The opcode to generated the message with.
-     * @param [out] ec A code to fill in for errors
-     */
-    void send(connection_hdl hdl, std::string const & payload,
-        frame::opcode::value op, lib::error_code & ec);
-    /// Create a message and add it to the outgoing send queue
-    /**
-     * Convenience method to send a message given a payload string and an opcode
-     *
-     * @param [in] hdl The handle identifying the connection to send via.
-     * @param [in] payload The payload string to generated the message with
-     * @param [in] op The opcode to generated the message with.
-     * @param [out] ec A code to fill in for errors
-     */
-    void send(connection_hdl hdl, std::string const & payload,
-        frame::opcode::value op);
-
-    void send(connection_hdl hdl, void const * payload, size_t len,
-        frame::opcode::value op, lib::error_code & ec);
-    void send(connection_hdl hdl, void const * payload, size_t len,
-        frame::opcode::value op);
-
-    void send(connection_hdl hdl, message_ptr msg, lib::error_code & ec);
-    void send(connection_hdl hdl, message_ptr msg);
-
-    void close(connection_hdl hdl, close::status::value const code,
-        std::string const & reason, lib::error_code & ec);
-    void close(connection_hdl hdl, close::status::value const code,
-        std::string const & reason);
-
-    /// Send a ping to a specific connection
-    /**
-     * @since 0.3.0-alpha3
-     *
-     * @param [in] hdl The connection_hdl of the connection to send to.
-     * @param [in] payload The payload string to send.
-     * @param [out] ec A reference to an error code to fill in
-     */
-    void ping(connection_hdl hdl, std::string const & payload,
-        lib::error_code & ec);
-    /// Send a ping to a specific connection
-    /**
-     * Exception variant of `ping`
-     *
-     * @since 0.3.0-alpha3
-     *
-     * @param [in] hdl The connection_hdl of the connection to send to.
-     * @param [in] payload The payload string to send.
-     */
-    void ping(connection_hdl hdl, std::string const & payload);
-
-    /// Send a pong to a specific connection
-    /**
-     * @since 0.3.0-alpha3
-     *
-     * @param [in] hdl The connection_hdl of the connection to send to.
-     * @param [in] payload The payload string to send.
-     * @param [out] ec A reference to an error code to fill in
-     */
-    void pong(connection_hdl hdl, std::string const & payload,
-        lib::error_code & ec);
-    /// Send a pong to a specific connection
-    /**
-     * Exception variant of `pong`
-     *
-     * @since 0.3.0-alpha3
-     *
-     * @param [in] hdl The connection_hdl of the connection to send to.
-     * @param [in] payload The payload string to send.
-     */
-    void pong(connection_hdl hdl, std::string const & payload);
-
-    /// Retrieves a connection_ptr from a connection_hdl (exception free)
-    /**
-     * Converting a weak pointer to shared_ptr is not thread safe because the
-     * pointer could be deleted at any time.
-     *
-     * NOTE: This method may be called by handler to upgrade its handle to a
-     * full connection_ptr. That full connection may then be used safely for the
-     * remainder of the handler body. get_con_from_hdl and the resulting
-     * connection_ptr are NOT safe to use outside the handler loop.
-     *
-     * @param hdl The connection handle to translate
-     *
-     * @return the connection_ptr. May be NULL if the handle was invalid.
-     */
-    connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code & ec) {
-        connection_ptr con = lib::static_pointer_cast<connection_type>(
-            hdl.lock());
-        if (!con) {
-            ec = error::make_error_code(error::bad_connection);
-        }
-        return con;
-    }
-
-    /// Retrieves a connection_ptr from a connection_hdl (exception version)
-    connection_ptr get_con_from_hdl(connection_hdl hdl) {
-        lib::error_code ec;
-        connection_ptr con = this->get_con_from_hdl(hdl,ec);
-        if (ec) {
-            throw exception(ec);
-        }
-        return con;
-    }
-protected:
-    connection_ptr create_connection();
-
-    lib::shared_ptr<alog_type> m_alog;
-    lib::shared_ptr<elog_type> m_elog;
-private:
-    // dynamic settings
-    std::string                 m_user_agent;
-
-    open_handler                m_open_handler;
-    close_handler               m_close_handler;
-    fail_handler                m_fail_handler;
-    ping_handler                m_ping_handler;
-    pong_handler                m_pong_handler;
-    pong_timeout_handler        m_pong_timeout_handler;
-    interrupt_handler           m_interrupt_handler;
-    http_handler                m_http_handler;
-    validate_handler            m_validate_handler;
-    message_handler             m_message_handler;
-
-    long                        m_open_handshake_timeout_dur;
-    long                        m_close_handshake_timeout_dur;
-    long                        m_pong_timeout_dur;
-    size_t                      m_max_message_size;
-    size_t                      m_max_http_body_size;
-
-    rng_type m_rng;
-
-    // static settings
-    bool const                  m_is_server;
-
-    // endpoint state
-    mutable mutex_type          m_mutex;
-};
-
-} // namespace websocketpp
-
-#include <websocketpp/impl/endpoint_impl.hpp>
-
-#endif // WEBSOCKETPP_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint_base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint_base.hpp
deleted file mode 100644
index 1ad1a44..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/endpoint_base.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_ENDPOINT_BASE_HPP
-#define WEBSOCKETPP_ENDPOINT_BASE_HPP
-
-namespace websocketpp {
-
-/// Stub for user supplied base class.
-class endpoint_base {};
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_ENDPOINT_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/error.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/error.hpp
deleted file mode 100644
index 562fb6e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/error.hpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_ERROR_HPP
-#define WEBSOCKETPP_ERROR_HPP
-
-#include <exception>
-#include <string>
-#include <utility>
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-namespace websocketpp {
-
-/// Combination error code / string type for returning two values
-typedef std::pair<lib::error_code,std::string> err_str_pair;
-
-/// Library level error codes
-namespace error {
-enum value {
-    /// Catch-all library error
-    general = 1,
-
-    /// send attempted when endpoint write queue was full
-    send_queue_full,
-
-    /// Attempted an operation using a payload that was improperly formatted
-    /// ex: invalid UTF8 encoding on a text message.
-    payload_violation,
-
-    /// Attempted to open a secure connection with an insecure endpoint
-    endpoint_not_secure,
-
-    /// Attempted an operation that required an endpoint that is no longer
-    /// available. This is usually because the endpoint went out of scope
-    /// before a connection that it created.
-    endpoint_unavailable,
-
-    /// An invalid uri was supplied
-    invalid_uri,
-
-    /// The endpoint is out of outgoing message buffers
-    no_outgoing_buffers,
-
-    /// The endpoint is out of incoming message buffers
-    no_incoming_buffers,
-
-    /// The connection was in the wrong state for this operation
-    invalid_state,
-
-    /// Unable to parse close code
-    bad_close_code,
-
-    /// Close code is in a reserved range
-    reserved_close_code,
-
-    /// Close code is invalid
-    invalid_close_code,
-
-    /// Invalid UTF-8
-    invalid_utf8,
-
-    /// Invalid subprotocol
-    invalid_subprotocol,
-
-    /// An operation was attempted on a connection that did not exist or was
-    /// already deleted.
-    bad_connection,
-
-    /// Unit testing utility error code
-    test,
-
-    /// Connection creation attempted failed
-    con_creation_failed,
-
-    /// Selected subprotocol was not requested by the client
-    unrequested_subprotocol,
-
-    /// Attempted to use a client specific feature on a server endpoint
-    client_only,
-
-    /// Attempted to use a server specific feature on a client endpoint
-    server_only,
-
-    /// HTTP connection ended
-    http_connection_ended,
-
-    /// WebSocket opening handshake timed out
-    open_handshake_timeout,
-
-    /// WebSocket close handshake timed out
-    close_handshake_timeout,
-
-    /// Invalid port in URI
-    invalid_port,
-
-    /// An async accept operation failed because the underlying transport has been
-    /// requested to not listen for new connections anymore.
-    async_accept_not_listening,
-
-    /// The requested operation was canceled
-    operation_canceled,
-
-    /// Connection rejected
-    rejected,
-
-    /// Upgrade Required. This happens if an HTTP request is made to a
-    /// WebSocket++ server that doesn't implement an http handler
-    upgrade_required,
-
-    /// Invalid WebSocket protocol version
-    invalid_version,
-
-    /// Unsupported WebSocket protocol version
-    unsupported_version,
-
-    /// HTTP parse error
-    http_parse_error,
-    
-    /// Extension negotiation failed
-    extension_neg_failed
-}; // enum value
-
-
-class category : public lib::error_category {
-public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case error::general:
-                return "Generic error";
-            case error::send_queue_full:
-                return "send queue full";
-            case error::payload_violation:
-                return "payload violation";
-            case error::endpoint_not_secure:
-                return "endpoint not secure";
-            case error::endpoint_unavailable:
-                return "endpoint not available";
-            case error::invalid_uri:
-                return "invalid uri";
-            case error::no_outgoing_buffers:
-                return "no outgoing message buffers";
-            case error::no_incoming_buffers:
-                return "no incoming message buffers";
-            case error::invalid_state:
-                return "invalid state";
-            case error::bad_close_code:
-                return "Unable to extract close code";
-            case error::invalid_close_code:
-                return "Extracted close code is in an invalid range";
-            case error::reserved_close_code:
-                return "Extracted close code is in a reserved range";
-            case error::invalid_utf8:
-                return "Invalid UTF-8";
-            case error::invalid_subprotocol:
-                return "Invalid subprotocol";
-            case error::bad_connection:
-                return "Bad Connection";
-            case error::test:
-                return "Test Error";
-            case error::con_creation_failed:
-                return "Connection creation attempt failed";
-            case error::unrequested_subprotocol:
-                return "Selected subprotocol was not requested by the client";
-            case error::client_only:
-                return "Feature not available on server endpoints";
-            case error::server_only:
-                return "Feature not available on client endpoints";
-            case error::http_connection_ended:
-                return "HTTP connection ended";
-            case error::open_handshake_timeout:
-                return "The opening handshake timed out";
-            case error::close_handshake_timeout:
-                return "The closing handshake timed out";
-            case error::invalid_port:
-                return "Invalid URI port";
-            case error::async_accept_not_listening:
-                return "Async Accept not listening";
-            case error::operation_canceled:
-                return "Operation canceled";
-            case error::rejected:
-                return "Connection rejected";
-            case error::upgrade_required:
-                return "Upgrade required";
-            case error::invalid_version:
-                return "Invalid version";
-            case error::unsupported_version:
-                return "Unsupported version";
-            case error::http_parse_error:
-                return "HTTP parse error";
-            case error::extension_neg_failed:
-                return "Extension negotiation failed";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-inline const lib::error_category& get_category() {
-    static category instance;
-    return instance;
-}
-
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace websocketpp
-
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-namespace websocketpp {
-
-class exception : public std::exception {
-public:
-    exception(std::string const & msg, lib::error_code ec = make_error_code(error::general))
-      : m_msg(msg.empty() ? ec.message() : msg), m_code(ec)
-    {}
-
-    explicit exception(lib::error_code ec)
-      : m_msg(ec.message()), m_code(ec)
-    {}
-
-    ~exception() throw() {}
-
-    virtual char const * what() const throw() {
-        return m_msg.c_str();
-    }
-
-    lib::error_code code() const throw() {
-        return m_code;
-    }
-
-    const std::string m_msg;
-    lib::error_code m_code;
-};
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_ERROR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/extension.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/extension.hpp
deleted file mode 100644
index f5fbd9f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/extension.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_EXTENSION_HPP
-#define WEBSOCKETPP_EXTENSION_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-
-/**
- * Some generic information about extensions
- *
- * Each extension object has an implemented flag. It can be retrieved by calling
- * is_implemented(). This compile time flag indicates whether or not the object
- * in question actually implements the extension or if it is a placeholder stub
- *
- * Each extension object also has an enabled flag. It can be retrieved by
- * calling is_enabled(). This runtime flag indicates whether or not the
- * extension has been negotiated for this connection.
- */
-namespace extensions {
-
-namespace error {
-enum value {
-    /// Catch all
-    general = 1,
-
-    /// Extension disabled
-    disabled
-};
-
-class category : public lib::error_category {
-public:
-    category() {}
-
-    const char *name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.extension";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic extension error";
-            case disabled:
-                return "Use of methods from disabled extension";
-            default:
-                return "Unknown permessage-compress error";
-        }
-    }
-};
-
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace extensions
-} // namespace websocketpp
-
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum
-    <websocketpp::extensions::error::value>
-{
-    static const bool value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif // WEBSOCKETPP_EXTENSION_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/disabled.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/disabled.hpp
deleted file mode 100644
index 6573095..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/disabled.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_EXTENSION_PERMESSAGE_DEFLATE_DISABLED_HPP
-#define WEBSOCKETPP_EXTENSION_PERMESSAGE_DEFLATE_DISABLED_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <websocketpp/http/constants.hpp>
-#include <websocketpp/extensions/extension.hpp>
-
-#include <map>
-#include <string>
-#include <utility>
-
-namespace websocketpp {
-namespace extensions {
-namespace permessage_deflate {
-
-/// Stub class for use when disabling permessage_deflate extension
-/**
- * This class is a stub that implements the permessage_deflate interface
- * with minimal dependencies. It is used to disable permessage_deflate
- * functionality at compile time without loading any unnecessary code.
- */
-template <typename config>
-class disabled {
-    typedef std::pair<lib::error_code,std::string> err_str_pair;
-
-public:
-    /// Negotiate extension
-    /**
-     * The disabled extension always fails the negotiation with a disabled
-     * error.
-     *
-     * @param offer Attribute from client's offer
-     * @return Status code and value to return to remote endpoint
-     */
-    err_str_pair negotiate(http::attribute_list const &) {
-        return make_pair(make_error_code(error::disabled),std::string());
-    }
-
-    /// Initialize state
-    /**
-     * For the disabled extension state initialization is a no-op.
-     *
-     * @param is_server True to initialize as a server, false for a client.
-     * @return A code representing the error that occurred, if any
-     */
-    lib::error_code init(bool) {
-        return lib::error_code();
-    }
-
-    /// Returns true if the extension is capable of providing
-    /// permessage_deflate functionality
-    bool is_implemented() const {
-        return false;
-    }
-
-    /// Returns true if permessage_deflate functionality is active for this
-    /// connection
-    bool is_enabled() const {
-        return false;
-    }
-
-    /// Generate extension offer
-    /**
-     * Creates an offer string to include in the Sec-WebSocket-Extensions
-     * header of outgoing client requests.
-     *
-     * @return A WebSocket extension offer string for this extension
-     */
-    std::string generate_offer() const {
-        return "";
-    }
-
-    /// Compress bytes
-    /**
-     * @param [in] in String to compress
-     * @param [out] out String to append compressed bytes to
-     * @return Error or status code
-     */
-    lib::error_code compress(std::string const &, std::string &) {
-        return make_error_code(error::disabled);
-    }
-
-    /// Decompress bytes
-    /**
-     * @param buf Byte buffer to decompress
-     * @param len Length of buf
-     * @param out String to append decompressed bytes to
-     * @return Error or status code
-     */
-    lib::error_code decompress(uint8_t const *, size_t, std::string &) {
-        return make_error_code(error::disabled);
-    }
-};
-
-} // namespace permessage_deflate
-} // namespace extensions
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_EXTENSION_PERMESSAGE_DEFLATE_DISABLED_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/enabled.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/enabled.hpp
deleted file mode 100644
index d05403a..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/extensions/permessage_deflate/enabled.hpp
+++ /dev/null
@@ -1,817 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
-#define WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
-
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/platforms.hpp>
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/error.hpp>
-
-#include <websocketpp/extensions/extension.hpp>
-
-#include "zlib.h"
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace extensions {
-
-/// Implementation of RFC 7692, the permessage-deflate WebSocket extension
-/**
- * ### permessage-deflate interface
- *
- * **init**\n
- * `lib::error_code init(bool is_server)`\n
- * Performs initialization
- *
- * **is_implimented**\n
- * `bool is_implimented()`\n
- * Returns whether or not the object impliments the extension or not
- *
- * **is_enabled**\n
- * `bool is_enabled()`\n
- * Returns whether or not the extension was negotiated for the current
- * connection
- *
- * **generate_offer**\n
- * `std::string generate_offer() const`\n
- * Create an extension offer string based on local policy
- *
- * **validate_response**\n
- * `lib::error_code validate_response(http::attribute_list const & response)`\n
- * Negotiate the parameters of extension use
- *
- * **negotiate**\n
- * `err_str_pair negotiate(http::attribute_list const & attributes)`\n
- * Negotiate the parameters of extension use
- *
- * **compress**\n
- * `lib::error_code compress(std::string const & in, std::string & out)`\n
- * Compress the bytes in `in` and append them to `out`
- *
- * **decompress**\n
- * `lib::error_code decompress(uint8_t const * buf, size_t len, std::string &
- * out)`\n
- * Decompress `len` bytes from `buf` and append them to string `out`
- */
-namespace permessage_deflate {
-
-/// Permessage deflate error values
-namespace error {
-enum value {
-    /// Catch all
-    general = 1,
-
-    /// Invalid extension attributes
-    invalid_attributes,
-
-    /// Invalid extension attribute value
-    invalid_attribute_value,
-
-    /// Invalid megotiation mode
-    invalid_mode,
-
-    /// Unsupported extension attributes
-    unsupported_attributes,
-
-    /// Invalid value for max_window_bits
-    invalid_max_window_bits,
-
-    /// ZLib Error
-    zlib_error,
-
-    /// Uninitialized
-    uninitialized,
-};
-
-/// Permessage-deflate error category
-class category : public lib::error_category {
-public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.extension.permessage-deflate";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic permessage-compress error";
-            case invalid_attributes:
-                return "Invalid extension attributes";
-            case invalid_attribute_value:
-                return "Invalid extension attribute value";
-            case invalid_mode:
-                return "Invalid permessage-deflate negotiation mode";
-            case unsupported_attributes:
-                return "Unsupported extension attributes";
-            case invalid_max_window_bits:
-                return "Invalid value for max_window_bits";
-            case zlib_error:
-                return "A zlib function returned an error";
-            case uninitialized:
-                return "Deflate extension must be initialized before use";
-            default:
-                return "Unknown permessage-compress error";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the permessage-deflate error category
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-/// Create an error code in the permessage-deflate category
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace permessage_deflate
-} // namespace extensions
-} // namespace websocketpp
-
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum
-    <websocketpp::extensions::permessage_deflate::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-namespace websocketpp {
-namespace extensions {
-namespace permessage_deflate {
-
-/// Default value for server_max_window_bits as defined by RFC 7692
-static uint8_t const default_server_max_window_bits = 15;
-/// Minimum value for server_max_window_bits as defined by RFC 7692
-/**
- * NOTE: A value of 8 is not actually supported by zlib, the deflate
- * library that WebSocket++ uses. To preserve backwards compatibility
- * with RFC 7692 and previous versions of the library a value of 8
- * is accepted by the library but will always be negotiated as 9.
- */
-static uint8_t const min_server_max_window_bits = 8;
-/// Maximum value for server_max_window_bits as defined by RFC 7692
-static uint8_t const max_server_max_window_bits = 15;
-
-/// Default value for client_max_window_bits as defined by RFC 7692
-static uint8_t const default_client_max_window_bits = 15;
-/// Minimum value for client_max_window_bits as defined by RFC 7692
-/**
- * NOTE: A value of 8 is not actually supported by zlib, the deflate
- * library that WebSocket++ uses. To preserve backwards compatibility
- * with RFC 7692 and previous versions of the library a value of 8
- * is accepted by the library but will always be negotiated as 9.
- */
-static uint8_t const min_client_max_window_bits = 8;
-/// Maximum value for client_max_window_bits as defined by RFC 7692
-static uint8_t const max_client_max_window_bits = 15;
-
-namespace mode {
-enum value {
-    /// Accept any value the remote endpoint offers
-    accept = 1,
-    /// Decline any value the remote endpoint offers. Insist on defaults.
-    decline,
-    /// Use the largest value common to both offers
-    largest,
-    /// Use the smallest value common to both offers
-    smallest
-};
-} // namespace mode
-
-template <typename config>
-class enabled {
-public:
-    enabled()
-      : m_enabled(false)
-      , m_server_no_context_takeover(false)
-      , m_client_no_context_takeover(false)
-      , m_server_max_window_bits(15)
-      , m_client_max_window_bits(15)
-      , m_server_max_window_bits_mode(mode::accept)
-      , m_client_max_window_bits_mode(mode::accept)
-      , m_initialized(false)
-      , m_compress_buffer_size(8192)
-    {
-        m_dstate.zalloc = Z_NULL;
-        m_dstate.zfree = Z_NULL;
-        m_dstate.opaque = Z_NULL;
-
-        m_istate.zalloc = Z_NULL;
-        m_istate.zfree = Z_NULL;
-        m_istate.opaque = Z_NULL;
-        m_istate.avail_in = 0;
-        m_istate.next_in = Z_NULL;
-    }
-
-    ~enabled() {
-        if (!m_initialized) {
-            return;
-        }
-
-        int ret = deflateEnd(&m_dstate);
-
-        if (ret != Z_OK) {
-            //std::cout << "error cleaning up zlib compression state"
-            //          << std::endl;
-        }
-
-        ret = inflateEnd(&m_istate);
-
-        if (ret != Z_OK) {
-            //std::cout << "error cleaning up zlib decompression state"
-            //          << std::endl;
-        }
-    }
-
-    /// Initialize zlib state
-    /**
-     * Note: this should be called *after* the negotiation methods. It will use
-     * information from the negotiation to determine how to initialize the zlib
-     * data structures.
-     *
-     * @todo memory level, strategy, etc are hardcoded
-     *
-     * @param is_server True to initialize as a server, false for a client.
-     * @return A code representing the error that occurred, if any
-     */
-    lib::error_code init(bool is_server) {
-        uint8_t deflate_bits;
-        uint8_t inflate_bits;
-
-        if (is_server) {
-            deflate_bits = m_server_max_window_bits;
-            inflate_bits = m_client_max_window_bits;
-        } else {
-            deflate_bits = m_client_max_window_bits;
-            inflate_bits = m_server_max_window_bits;
-        }
-
-        int ret = deflateInit2(
-            &m_dstate,
-            Z_DEFAULT_COMPRESSION,
-            Z_DEFLATED,
-            -1*deflate_bits,
-            4, // memory level 1-9
-            Z_DEFAULT_STRATEGY
-        );
-
-        if (ret != Z_OK) {
-            return make_error_code(error::zlib_error);
-        }
-
-        ret = inflateInit2(
-            &m_istate,
-            -1*inflate_bits
-        );
-
-        if (ret != Z_OK) {
-            return make_error_code(error::zlib_error);
-        }
-
-        m_compress_buffer.reset(new unsigned char[m_compress_buffer_size]);
-        m_decompress_buffer.reset(new unsigned char[m_compress_buffer_size]);
-        if ((m_server_no_context_takeover && is_server) ||
-            (m_client_no_context_takeover && !is_server))
-        {
-            m_flush = Z_FULL_FLUSH;
-        } else {
-            m_flush = Z_SYNC_FLUSH;
-        }
-        m_initialized = true;
-        return lib::error_code();
-    }
-
-    /// Test if this object implements the permessage-deflate specification
-    /**
-     * Because this object does implieent it, it will always return true.
-     *
-     * @return Whether or not this object implements permessage-deflate
-     */
-    bool is_implemented() const {
-        return true;
-    }
-
-    /// Test if the extension was negotiated for this connection
-    /**
-     * Retrieves whether or not this extension is in use based on the initial
-     * handshake extension negotiations.
-     *
-     * @return Whether or not the extension is in use
-     */
-    bool is_enabled() const {
-        return m_enabled;
-    }
-
-    /// Reset server's outgoing LZ77 sliding window for each new message
-    /**
-     * Enabling this setting will cause the server's compressor to reset the
-     * compression state (the LZ77 sliding window) for every message. This
-     * means that the compressor will not look back to patterns in previous
-     * messages to improve compression. This will reduce the compression
-     * efficiency for large messages somewhat and small messages drastically.
-     *
-     * This option may reduce server compressor memory usage and client
-     * decompressor memory usage.
-     * @todo Document to what extent memory usage will be reduced
-     *
-     * For clients, this option is dependent on server support. Enabling it
-     * via this method does not guarantee that it will be successfully
-     * negotiated, only that it will be requested.
-     *
-     * For servers, no client support is required. Enabling this option on a
-     * server will result in its use. The server will signal to clients that
-     * the option will be in use so they can optimize resource usage if they
-     * are able.
-     */
-    void enable_server_no_context_takeover() {
-        m_server_no_context_takeover = true;
-    }
-
-    /// Reset client's outgoing LZ77 sliding window for each new message
-    /**
-     * Enabling this setting will cause the client's compressor to reset the
-     * compression state (the LZ77 sliding window) for every message. This
-     * means that the compressor will not look back to patterns in previous
-     * messages to improve compression. This will reduce the compression
-     * efficiency for large messages somewhat and small messages drastically.
-     *
-     * This option may reduce client compressor memory usage and server
-     * decompressor memory usage.
-     * @todo Document to what extent memory usage will be reduced
-     *
-     * This option is supported by all compliant clients and servers. Enabling
-     * it via either endpoint should be sufficient to ensure it is used.
-     */
-    void enable_client_no_context_takeover() {
-        m_client_no_context_takeover = true;
-    }
-
-    /// Limit server LZ77 sliding window size
-    /**
-     * The bits setting is the base 2 logarithm of the maximum window size that
-     * the server must use to compress outgoing messages. The permitted range
-     * is 9 to 15 inclusive. 9 represents a 512 byte window and 15 a 32KiB
-     * window. The default setting is 15.
-     *
-     * Mode Options:
-     * - accept: Accept whatever the remote endpoint offers.
-     * - decline: Decline any offers to deviate from the defaults
-     * - largest: Accept largest window size acceptable to both endpoints
-     * - smallest: Accept smallest window size acceptiable to both endpoints
-     *
-     * This setting is dependent on server support. A client requesting this
-     * setting may be rejected by the server or have the exact value used
-     * adjusted by the server. A server may unilaterally set this value without
-     * client support.
-     *
-     * NOTE: The permessage-deflate spec specifies that a value of 8 is allowed.
-     * Prior to version 0.8.0 a value of 8 was also allowed by this library.
-     * zlib, the deflate compression library that WebSocket++ uses has always
-     * silently adjusted a value of 8 to 9. In recent versions of zlib (1.2.9 
-     * and greater) a value of 8 is now explicitly rejected. WebSocket++ 0.8.0
-     * continues to perform the 8->9 conversion for backwards compatibility
-     * purposes but this should be considered deprecated functionality.
-     *
-     * @param bits The size to request for the outgoing window size
-     * @param mode The mode to use for negotiating this parameter
-     * @return A status code
-     */
-    lib::error_code set_server_max_window_bits(uint8_t bits, mode::value mode) {
-        if (bits < min_server_max_window_bits || bits > max_server_max_window_bits) {
-            return error::make_error_code(error::invalid_max_window_bits);
-        }
-
-        // See note in doc comment above about what is happening here
-        if (bits == 8) {
-            bits = 9;
-        }
-
-        m_server_max_window_bits = bits;
-        m_server_max_window_bits_mode = mode;
-
-        return lib::error_code();
-    }
-
-    /// Limit client LZ77 sliding window size
-    /**
-     * The bits setting is the base 2 logarithm of the window size that the
-     * client must use to compress outgoing messages. The permitted range is 9
-     * to 15 inclusive. 9 represents a 512 byte window and 15 a 32KiB window.
-     * The default setting is 15.
-     *
-     * Mode Options:
-     * - accept: Accept whatever the remote endpoint offers.
-     * - decline: Decline any offers to deviate from the defaults
-     * - largest: Accept largest window size acceptable to both endpoints
-     * - smallest: Accept smallest window size acceptiable to both endpoints
-     *
-     * This setting is dependent on client support. A client may limit its own
-     * outgoing window size unilaterally. A server may only limit the client's
-     * window size if the remote client supports that feature.
-     *
-     * NOTE: The permessage-deflate spec specifies that a value of 8 is allowed.
-     * Prior to version 0.8.0 a value of 8 was also allowed by this library.
-     * zlib, the deflate compression library that WebSocket++ uses has always
-     * silently adjusted a value of 8 to 9. In recent versions of zlib (1.2.9 
-     * and greater) a value of 8 is now explicitly rejected. WebSocket++ 0.8.0
-     * continues to perform the 8->9 conversion for backwards compatibility
-     * purposes but this should be considered deprecated functionality.
-     *
-     * @param bits The size to request for the outgoing window size
-     * @param mode The mode to use for negotiating this parameter
-     * @return A status code
-     */
-    lib::error_code set_client_max_window_bits(uint8_t bits, mode::value mode) {
-        if (bits < min_client_max_window_bits || bits > max_client_max_window_bits) {
-            return error::make_error_code(error::invalid_max_window_bits);
-        }
-
-        // See note in doc comment above about what is happening here
-        if (bits == 8) {
-            bits = 9;
-        }
-
-        m_client_max_window_bits = bits;
-        m_client_max_window_bits_mode = mode;
-
-        return lib::error_code();
-    }
-
-    /// Generate extension offer
-    /**
-     * Creates an offer string to include in the Sec-WebSocket-Extensions
-     * header of outgoing client requests.
-     *
-     * @return A WebSocket extension offer string for this extension
-     */
-    std::string generate_offer() const {
-        // TODO: this should be dynamically generated based on user settings
-        return "permessage-deflate; client_no_context_takeover; client_max_window_bits";
-    }
-
-    /// Validate extension response
-    /**
-     * Confirm that the server has negotiated settings compatible with our
-     * original offer and apply those settings to the extension state.
-     *
-     * @param response The server response attribute list to validate
-     * @return Validation error or 0 on success
-     */
-    lib::error_code validate_offer(http::attribute_list const &) {
-        return lib::error_code();
-    }
-
-    /// Negotiate extension
-    /**
-     * Confirm that the client's extension negotiation offer has settings
-     * compatible with local policy. If so, generate a reply and apply those
-     * settings to the extension state.
-     *
-     * @param offer Attribute from client's offer
-     * @return Status code and value to return to remote endpoint
-     */
-    err_str_pair negotiate(http::attribute_list const & offer) {
-        err_str_pair ret;
-
-        http::attribute_list::const_iterator it;
-        for (it = offer.begin(); it != offer.end(); ++it) {
-            if (it->first == "server_no_context_takeover") {
-                negotiate_server_no_context_takeover(it->second,ret.first);
-            } else if (it->first == "client_no_context_takeover") {
-                negotiate_client_no_context_takeover(it->second,ret.first);
-            } else if (it->first == "server_max_window_bits") {
-                negotiate_server_max_window_bits(it->second,ret.first);
-            } else if (it->first == "client_max_window_bits") {
-                negotiate_client_max_window_bits(it->second,ret.first);
-            } else {
-                ret.first = make_error_code(error::invalid_attributes);
-            }
-
-            if (ret.first) {
-                break;
-            }
-        }
-
-        if (ret.first == lib::error_code()) {
-            m_enabled = true;
-            ret.second = generate_response();
-        }
-
-        return ret;
-    }
-
-    /// Compress bytes
-    /**
-     * @todo: avail_in/out is 32 bit, need to fix for cases of >32 bit frames
-     * on 64 bit machines.
-     *
-     * @param [in] in String to compress
-     * @param [out] out String to append compressed bytes to
-     * @return Error or status code
-     */
-    lib::error_code compress(std::string const & in, std::string & out) {
-        if (!m_initialized) {
-            return make_error_code(error::uninitialized);
-        }
-
-        size_t output;
-
-        if (in.empty()) {
-            uint8_t buf[6] = {0x02, 0x00, 0x00, 0x00, 0xff, 0xff};
-            out.append((char *)(buf),6);
-            return lib::error_code();
-        }
-
-        m_dstate.avail_in = in.size();
-        m_dstate.next_in = (unsigned char *)(const_cast<char *>(in.data()));
-
-        do {
-            // Output to local buffer
-            m_dstate.avail_out = m_compress_buffer_size;
-            m_dstate.next_out = m_compress_buffer.get();
-
-            deflate(&m_dstate, m_flush);
-
-            output = m_compress_buffer_size - m_dstate.avail_out;
-
-            out.append((char *)(m_compress_buffer.get()),output);
-        } while (m_dstate.avail_out == 0);
-
-        return lib::error_code();
-    }
-
-    /// Decompress bytes
-    /**
-     * @param buf Byte buffer to decompress
-     * @param len Length of buf
-     * @param out String to append decompressed bytes to
-     * @return Error or status code
-     */
-    lib::error_code decompress(uint8_t const * buf, size_t len, std::string &
-        out)
-    {
-        if (!m_initialized) {
-            return make_error_code(error::uninitialized);
-        }
-
-        int ret;
-
-        m_istate.avail_in = len;
-        m_istate.next_in = const_cast<unsigned char *>(buf);
-
-        do {
-            m_istate.avail_out = m_compress_buffer_size;
-            m_istate.next_out = m_decompress_buffer.get();
-
-            ret = inflate(&m_istate, Z_SYNC_FLUSH);
-
-            if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
-                return make_error_code(error::zlib_error);
-            }
-
-            out.append(
-                reinterpret_cast<char *>(m_decompress_buffer.get()),
-                m_compress_buffer_size - m_istate.avail_out
-            );
-        } while (m_istate.avail_out == 0);
-
-        return lib::error_code();
-    }
-private:
-    /// Generate negotiation response
-    /**
-     * @return Generate extension negotiation reponse string to send to client
-     */
-    std::string generate_response() {
-        std::string ret = "permessage-deflate";
-
-        if (m_server_no_context_takeover) {
-            ret += "; server_no_context_takeover";
-        }
-
-        if (m_client_no_context_takeover) {
-            ret += "; client_no_context_takeover";
-        }
-
-        if (m_server_max_window_bits < default_server_max_window_bits) {
-            std::stringstream s;
-            s << int(m_server_max_window_bits);
-            ret += "; server_max_window_bits="+s.str();
-        }
-
-        if (m_client_max_window_bits < default_client_max_window_bits) {
-            std::stringstream s;
-            s << int(m_client_max_window_bits);
-            ret += "; client_max_window_bits="+s.str();
-        }
-
-        return ret;
-    }
-
-    /// Negotiate server_no_context_takeover attribute
-    /**
-     * @param [in] value The value of the attribute from the offer
-     * @param [out] ec A reference to the error code to return errors via
-     */
-    void negotiate_server_no_context_takeover(std::string const & value,
-        lib::error_code & ec)
-    {
-        if (!value.empty()) {
-            ec = make_error_code(error::invalid_attribute_value);
-            return;
-        }
-
-        m_server_no_context_takeover = true;
-    }
-
-    /// Negotiate client_no_context_takeover attribute
-    /**
-     * @param [in] value The value of the attribute from the offer
-     * @param [out] ec A reference to the error code to return errors via
-     */
-    void negotiate_client_no_context_takeover(std::string const & value,
-        lib::error_code & ec)
-    {
-        if (!value.empty()) {
-            ec = make_error_code(error::invalid_attribute_value);
-            return;
-        }
-
-        m_client_no_context_takeover = true;
-    }
-
-    /// Negotiate server_max_window_bits attribute
-    /**
-     * When this method starts, m_server_max_window_bits will contain the server's
-     * preferred value and m_server_max_window_bits_mode will contain the mode the
-     * server wants to use to for negotiation. `value` contains the value the
-     * client requested that we use.
-     *
-     * options:
-     * - decline (ignore value, offer our default instead)
-     * - accept (use the value requested by the client)
-     * - largest (use largest value acceptable to both)
-     * - smallest (use smallest possible value)
-     *
-     * NOTE: As a value of 8 is no longer explicitly supported by zlib but might
-     * be requested for negotiation by an older client/server, if the result of
-     * the negotiation would be to send a value of 8, a value of 9 is offered
-     * instead. This ensures that WebSocket++ will only ever negotiate connections
-     * with compression settings explicitly supported by zlib.
-     *
-     * @param [in] value The value of the attribute from the offer
-     * @param [out] ec A reference to the error code to return errors via
-     */
-    void negotiate_server_max_window_bits(std::string const & value,
-        lib::error_code & ec)
-    {
-        uint8_t bits = uint8_t(atoi(value.c_str()));
-
-        if (bits < min_server_max_window_bits || bits > max_server_max_window_bits) {
-            ec = make_error_code(error::invalid_attribute_value);
-            m_server_max_window_bits = default_server_max_window_bits;
-            return;
-        }
-
-        switch (m_server_max_window_bits_mode) {
-            case mode::decline:
-                m_server_max_window_bits = default_server_max_window_bits;
-                break;
-            case mode::accept:
-                m_server_max_window_bits = bits;
-                break;
-            case mode::largest:
-                m_server_max_window_bits = std::min(bits,m_server_max_window_bits);
-                break;
-            case mode::smallest:
-                m_server_max_window_bits = min_server_max_window_bits;
-                break;
-            default:
-                ec = make_error_code(error::invalid_mode);
-                m_server_max_window_bits = default_server_max_window_bits;
-        }
-
-        // See note in doc comment
-        if (m_server_max_window_bits == 8) {
-            m_server_max_window_bits = 9;
-        }
-    }
-
-    /// Negotiate client_max_window_bits attribute
-    /**
-     * When this method starts, m_client_max_window_bits and m_c2s_max_window_mode
-     * will contain the server's preferred values for window size and
-     * negotiation mode.
-     *
-     * options:
-     * - decline (ignore value, offer our default instead)
-     * - accept (use the value requested by the client)
-     * - largest (use largest value acceptable to both)
-     * - smallest (use smallest possible value)
-     *
-     * NOTE: As a value of 8 is no longer explicitly supported by zlib but might
-     * be requested for negotiation by an older client/server, if the result of
-     * the negotiation would be to send a value of 8, a value of 9 is offered
-     * instead. This ensures that WebSocket++ will only ever negotiate connections
-     * with compression settings explicitly supported by zlib.
-     *
-     * @param [in] value The value of the attribute from the offer
-     * @param [out] ec A reference to the error code to return errors via
-     */
-    void negotiate_client_max_window_bits(std::string const & value,
-            lib::error_code & ec)
-    {
-        uint8_t bits = uint8_t(atoi(value.c_str()));
-
-        if (value.empty()) {
-            bits = default_client_max_window_bits;
-        } else if (bits < min_client_max_window_bits ||
-                   bits > max_client_max_window_bits)
-        {
-            ec = make_error_code(error::invalid_attribute_value);
-            m_client_max_window_bits = default_client_max_window_bits;
-            return;
-        }
-
-        switch (m_client_max_window_bits_mode) {
-            case mode::decline:
-                m_client_max_window_bits = default_client_max_window_bits;
-                break;
-            case mode::accept:
-                m_client_max_window_bits = bits;
-                break;
-            case mode::largest:
-                m_client_max_window_bits = std::min(bits,m_client_max_window_bits);
-                break;
-            case mode::smallest:
-                m_client_max_window_bits = min_client_max_window_bits;
-                break;
-            default:
-                ec = make_error_code(error::invalid_mode);
-                m_client_max_window_bits = default_client_max_window_bits;
-        }
-
-        // See note in doc comment
-        if (m_client_max_window_bits == 8) {
-            m_client_max_window_bits = 9;
-        }
-    }
-
-    bool m_enabled;
-    bool m_server_no_context_takeover;
-    bool m_client_no_context_takeover;
-    uint8_t m_server_max_window_bits;
-    uint8_t m_client_max_window_bits;
-    mode::value m_server_max_window_bits_mode;
-    mode::value m_client_max_window_bits_mode;
-
-    bool m_initialized;
-    int m_flush;
-    size_t m_compress_buffer_size;
-    lib::unique_ptr_uchar_array m_compress_buffer;
-    lib::unique_ptr_uchar_array m_decompress_buffer;
-    z_stream m_dstate;
-    z_stream m_istate;
-};
-
-} // namespace permessage_deflate
-} // namespace extensions
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/frame.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/frame.hpp
deleted file mode 100644
index 18a990b..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/frame.hpp
+++ /dev/null
@@ -1,864 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_FRAME_HPP
-#define WEBSOCKETPP_FRAME_HPP
-
-#include <algorithm>
-#include <string>
-
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/network.hpp>
-
-#include <websocketpp/utilities.hpp>
-
-namespace websocketpp {
-/// Data structures and utility functions for manipulating WebSocket frames
-/**
- * namespace frame provides a number of data structures and utility functions
- * for reading, writing, and manipulating binary encoded WebSocket frames.
- */
-namespace frame {
-
-/// Minimum length of a WebSocket frame header.
-static unsigned int const BASIC_HEADER_LENGTH = 2;
-/// Maximum length of a WebSocket header
-static unsigned int const MAX_HEADER_LENGTH = 14;
-/// Maximum length of the variable portion of the WebSocket header
-static unsigned int const MAX_EXTENDED_HEADER_LENGTH = 12;
-
-/// Two byte conversion union
-union uint16_converter {
-    uint16_t i;
-    uint8_t  c[2];
-};
-
-/// Four byte conversion union
-union uint32_converter {
-    uint32_t i;
-    uint8_t c[4];
-};
-
-/// Eight byte conversion union
-union uint64_converter {
-    uint64_t i;
-    uint8_t  c[8];
-};
-
-/// Constants and utility functions related to WebSocket opcodes
-/**
- * WebSocket Opcodes are 4 bits. See RFC6455 section 5.2.
- */
-namespace opcode {
-    enum value {
-        continuation = 0x0,
-        text = 0x1,
-        binary = 0x2,
-        rsv3 = 0x3,
-        rsv4 = 0x4,
-        rsv5 = 0x5,
-        rsv6 = 0x6,
-        rsv7 = 0x7,
-        close = 0x8,
-        ping = 0x9,
-        pong = 0xA,
-        control_rsvb = 0xB,
-        control_rsvc = 0xC,
-        control_rsvd = 0xD,
-        control_rsve = 0xE,
-        control_rsvf = 0xF,
-
-        CONTINUATION = 0x0,
-        TEXT = 0x1,
-        BINARY = 0x2,
-        RSV3 = 0x3,
-        RSV4 = 0x4,
-        RSV5 = 0x5,
-        RSV6 = 0x6,
-        RSV7 = 0x7,
-        CLOSE = 0x8,
-        PING = 0x9,
-        PONG = 0xA,
-        CONTROL_RSVB = 0xB,
-        CONTROL_RSVC = 0xC,
-        CONTROL_RSVD = 0xD,
-        CONTROL_RSVE = 0xE,
-        CONTROL_RSVF = 0xF
-    };
-
-    /// Check if an opcode is reserved
-    /**
-     * @param v The opcode to test.
-     * @return Whether or not the opcode is reserved.
-     */
-    inline bool reserved(value v) {
-        return (v >= rsv3 && v <= rsv7) ||
-               (v >= control_rsvb && v <= control_rsvf);
-    }
-
-    /// Check if an opcode is invalid
-    /**
-     * Invalid opcodes are negative or require greater than 4 bits to store.
-     *
-     * @param v The opcode to test.
-     * @return Whether or not the opcode is invalid.
-     */
-    inline bool invalid(value v) {
-        return (v > 0xF || v < 0);
-    }
-
-    /// Check if an opcode is for a control frame
-    /**
-     * @param v The opcode to test.
-     * @return Whether or not the opcode is a control opcode.
-     */
-    inline bool is_control(value v) {
-        return v >= 0x8;
-    }
-}
-
-/// Constants related to frame and payload limits
-namespace limits {
-    /// Minimum length of a WebSocket frame header.
-    static unsigned int const basic_header_length = 2;
-
-    /// Maximum length of a WebSocket header
-    static unsigned int const max_header_length = 14;
-
-    /// Maximum length of the variable portion of the WebSocket header
-    static unsigned int const max_extended_header_length = 12;
-
-    /// Maximum size of a basic WebSocket payload
-    static uint8_t const payload_size_basic = 125;
-
-    /// Maximum size of an extended WebSocket payload (basic payload = 126)
-    static uint16_t const payload_size_extended = 0xFFFF; // 2^16, 65535
-
-    /// Maximum size of a jumbo WebSocket payload (basic payload = 127)
-    static uint64_t const payload_size_jumbo = 0x7FFFFFFFFFFFFFFFLL;//2^63
-
-    /// Maximum size of close frame reason
-    /**
-     * This is payload_size_basic - 2 bytes (as first two bytes are used for
-     * the close code
-     */
-    static uint8_t const close_reason_size = 123;
-}
-
-
-// masks for fields in the basic header
-static uint8_t const BHB0_OPCODE = 0x0F;
-static uint8_t const BHB0_RSV3 = 0x10;
-static uint8_t const BHB0_RSV2 = 0x20;
-static uint8_t const BHB0_RSV1 = 0x40;
-static uint8_t const BHB0_FIN = 0x80;
-
-static uint8_t const BHB1_PAYLOAD = 0x7F;
-static uint8_t const BHB1_MASK = 0x80;
-
-static uint8_t const payload_size_code_16bit = 0x7E; // 126
-static uint8_t const payload_size_code_64bit = 0x7F; // 127
-
-typedef uint32_converter masking_key_type;
-
-/// The constant size component of a WebSocket frame header
-struct basic_header {
-    basic_header() : b0(0x00),b1(0x00) {}
-
-    basic_header(uint8_t p0, uint8_t p1) : b0(p0), b1(p1) {}
-
-    basic_header(opcode::value op, uint64_t size, bool fin, bool mask,
-        bool rsv1 = false, bool rsv2 = false, bool rsv3 = false) : b0(0x00),
-        b1(0x00)
-    {
-        if (fin) {
-            b0 |= BHB0_FIN;
-        }
-        if (rsv1) {
-            b0 |= BHB0_RSV1;
-        }
-        if (rsv2) {
-            b0 |= BHB0_RSV2;
-        }
-        if (rsv3) {
-            b0 |= BHB0_RSV3;
-        }
-        b0 |= (op & BHB0_OPCODE);
-
-        if (mask) {
-            b1 |= BHB1_MASK;
-        }
-
-        uint8_t basic_value;
-
-        if (size <= limits::payload_size_basic) {
-            basic_value = static_cast<uint8_t>(size);
-        } else if (size <= limits::payload_size_extended) {
-            basic_value = payload_size_code_16bit;
-        } else {
-            basic_value = payload_size_code_64bit;
-        }
-
-
-        b1 |= basic_value;
-    }
-
-    uint8_t b0;
-    uint8_t b1;
-};
-
-/// The variable size component of a WebSocket frame header
-struct extended_header {
-    extended_header() {
-        std::fill_n(this->bytes,MAX_EXTENDED_HEADER_LENGTH,0x00);
-    }
-
-    extended_header(uint64_t payload_size) {
-        std::fill_n(this->bytes,MAX_EXTENDED_HEADER_LENGTH,0x00);
-
-        copy_payload(payload_size);
-    }
-
-    extended_header(uint64_t payload_size, uint32_t masking_key) {
-        std::fill_n(this->bytes,MAX_EXTENDED_HEADER_LENGTH,0x00);
-
-        // Copy payload size
-        int offset = copy_payload(payload_size);
-
-        // Copy Masking Key
-        uint32_converter temp32;
-        temp32.i = masking_key;
-        std::copy(temp32.c,temp32.c+4,bytes+offset);
-    }
-
-    uint8_t bytes[MAX_EXTENDED_HEADER_LENGTH];
-private:
-    int copy_payload(uint64_t payload_size) {
-        int payload_offset = 0;
-
-        if (payload_size <= limits::payload_size_basic) {
-            payload_offset = 8;
-        } else if (payload_size <= limits::payload_size_extended) {
-            payload_offset = 6;
-        }
-
-        uint64_converter temp64;
-        temp64.i = lib::net::_htonll(payload_size);
-        std::copy(temp64.c+payload_offset,temp64.c+8,bytes);
-
-        return 8-payload_offset;
-    }
-};
-
-bool get_fin(basic_header const &h);
-void set_fin(basic_header &h, bool value);
-bool get_rsv1(basic_header const &h);
-void set_rsv1(basic_header &h, bool value);
-bool get_rsv2(basic_header const &h);
-void set_rsv2(basic_header &h, bool value);
-bool get_rsv3(basic_header const &h);
-void set_rsv3(basic_header &h, bool value);
-opcode::value get_opcode(basic_header const &h);
-bool get_masked(basic_header const &h);
-void set_masked(basic_header &h, bool value);
-uint8_t get_basic_size(basic_header const &);
-size_t get_header_len(basic_header const &);
-unsigned int get_masking_key_offset(basic_header const &);
-
-std::string write_header(basic_header const &, extended_header const &);
-masking_key_type get_masking_key(basic_header const &, extended_header const &);
-uint16_t get_extended_size(extended_header const &);
-uint64_t get_jumbo_size(extended_header const &);
-uint64_t get_payload_size(basic_header const &, extended_header const &);
-
-size_t prepare_masking_key(masking_key_type const & key);
-size_t circshift_prepared_key(size_t prepared_key, size_t offset);
-
-// Functions for performing xor based masking and unmasking
-template <typename input_iter, typename output_iter>
-void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type
-    const & key, size_t key_offset = 0);
-template <typename iter_type>
-void byte_mask(iter_type b, iter_type e, masking_key_type const & key,
-    size_t key_offset = 0);
-void word_mask_exact(uint8_t * input, uint8_t * output, size_t length,
-    masking_key_type const & key);
-void word_mask_exact(uint8_t * data, size_t length, masking_key_type const &
-    key);
-size_t word_mask_circ(uint8_t * input, uint8_t * output, size_t length,
-    size_t prepared_key);
-size_t word_mask_circ(uint8_t * data, size_t length, size_t prepared_key);
-
-/// Check whether the frame's FIN bit is set.
-/**
- * @param [in] h The basic header to extract from.
- * @return True if the header's fin bit is set.
- */
-inline bool get_fin(basic_header const & h) {
-    return ((h.b0 & BHB0_FIN) == BHB0_FIN);
-}
-
-/// Set the frame's FIN bit
-/**
- * @param [out] h Header to set.
- * @param [in] value Value to set it to.
- */
-inline void set_fin(basic_header & h, bool value) {
-    h.b0 = (value ? h.b0 | BHB0_FIN : h.b0 & ~BHB0_FIN);
-}
-
-/// check whether the frame's RSV1 bit is set
-/**
- * @param [in] h The basic header to extract from.
- * @return True if the header's RSV1 bit is set.
- */
-inline bool get_rsv1(const basic_header &h) {
-    return ((h.b0 & BHB0_RSV1) == BHB0_RSV1);
-}
-
-/// Set the frame's RSV1 bit
-/**
- * @param [out] h Header to set.
- * @param [in] value Value to set it to.
- */
-inline void set_rsv1(basic_header &h, bool value) {
-    h.b0 = (value ? h.b0 | BHB0_RSV1 : h.b0 & ~BHB0_RSV1);
-}
-
-/// check whether the frame's RSV2 bit is set
-/**
- * @param [in] h The basic header to extract from.
- * @return True if the header's RSV2 bit is set.
- */
-inline bool get_rsv2(const basic_header &h) {
-    return ((h.b0 & BHB0_RSV2) == BHB0_RSV2);
-}
-
-/// Set the frame's RSV2 bit
-/**
- * @param [out] h Header to set.
- * @param [in] value Value to set it to.
- */
-inline void set_rsv2(basic_header &h, bool value) {
-    h.b0 = (value ? h.b0 | BHB0_RSV2 : h.b0 & ~BHB0_RSV2);
-}
-
-/// check whether the frame's RSV3 bit is set
-/**
- * @param [in] h The basic header to extract from.
- * @return True if the header's RSV3 bit is set.
- */
-inline bool get_rsv3(const basic_header &h) {
-    return ((h.b0 & BHB0_RSV3) == BHB0_RSV3);
-}
-
-/// Set the frame's RSV3 bit
-/**
- * @param [out] h Header to set.
- * @param [in] value Value to set it to.
- */
-inline void set_rsv3(basic_header &h, bool value) {
-    h.b0 = (value ? h.b0 | BHB0_RSV3 : h.b0 & ~BHB0_RSV3);
-}
-
-/// Extract opcode from basic header
-/**
- * @param [in] h The basic header to extract from.
- * @return The opcode value of the header.
- */
-inline opcode::value get_opcode(const basic_header &h) {
-    return opcode::value(h.b0 & BHB0_OPCODE);
-}
-
-/// check whether the frame is masked
-/**
- * @param [in] h The basic header to extract from.
- * @return True if the header mask bit is set.
- */
-inline bool get_masked(basic_header const & h) {
-    return ((h.b1 & BHB1_MASK) == BHB1_MASK);
-}
-
-/// Set the frame's MASK bit
-/**
- * @param [out] h Header to set.
- * @param value Value to set it to.
- */
-inline void set_masked(basic_header & h, bool value) {
-    h.b1 = (value ? h.b1 | BHB1_MASK : h.b1 & ~BHB1_MASK);
-}
-
-/// Extracts the raw payload length specified in the basic header
-/**
- * A basic WebSocket frame header contains a 7 bit value that represents the
- * payload size. There are two reserved values that are used to indicate that
- * the actual payload size will not fit in 7 bits and that the full payload
- * size is included in a separate field. The values are as follows:
- *
- * PAYLOAD_SIZE_CODE_16BIT (0x7E) indicates that the actual payload is less
- * than 16 bit
- *
- * PAYLOAD_SIZE_CODE_64BIT (0x7F) indicates that the actual payload is less
- * than 63 bit
- *
- * @param [in] h Basic header to read value from.
- * @return The exact size encoded in h.
- */
-inline uint8_t get_basic_size(const basic_header &h) {
-    return h.b1 & BHB1_PAYLOAD;
-}
-
-/// Calculates the full length of the header based on the first bytes.
-/**
- * A WebSocket frame header always has at least two bytes. Encoded within the
- * first two bytes is all the information necessary to calculate the full
- * (variable) header length. get_header_len() calculates the full header
- * length for the given two byte basic header.
- *
- * @param h Basic frame header to extract size from.
- * @return Full length of the extended header.
- */
-inline size_t get_header_len(basic_header const & h) {
-    // TODO: check extensions?
-
-    // masking key offset represents the space used for the extended length
-    // fields
-    size_t size = BASIC_HEADER_LENGTH + get_masking_key_offset(h);
-
-    // If the header is masked there is a 4 byte masking key
-    if (get_masked(h)) {
-        size += 4;
-    }
-
-    return size;
-}
-
-/// Calculate the offset location of the masking key within the extended header
-/**
- * Calculate the offset location of the masking key within the extended header
- * using information from its corresponding basic header
- *
- * @param h Corresponding basic header to calculate from.
- *
- * @return byte offset of the first byte of the masking key
- */
-inline unsigned int get_masking_key_offset(const basic_header &h) {
-    if (get_basic_size(h) == payload_size_code_16bit) {
-        return 2;
-    } else if (get_basic_size(h) == payload_size_code_64bit) {
-        return 8;
-    } else {
-        return 0;
-    }
-}
-
-/// Generate a properly sized contiguous string that encodes a full frame header
-/**
- * Copy the basic header h and extended header e into a properly sized
- * contiguous frame header string for the purposes of writing out to the wire.
- *
- * @param h The basic header to include
- * @param e The extended header to include
- *
- * @return A contiguous string containing h and e
- */
-inline std::string prepare_header(const basic_header &h, const
-    extended_header &e)
-{
-    std::string ret;
-
-    ret.push_back(char(h.b0));
-    ret.push_back(char(h.b1));
-    ret.append(
-        reinterpret_cast<const char*>(e.bytes),
-        get_header_len(h)-BASIC_HEADER_LENGTH
-    );
-
-    return ret;
-}
-
-/// Extract the masking key from a frame header
-/**
- * Note that while read and written as an integer at times, this value is not
- * an integer and should never be interpreted as one. Big and little endian
- * machines will generate and store masking keys differently without issue as
- * long as the integer values remain irrelivant.
- *
- * @param h The basic header to extract from
- * @param e The extended header to extract from
- *
- * @return The masking key as an integer.
- */
-inline masking_key_type get_masking_key(const basic_header &h, const
-    extended_header &e)
-{
-    masking_key_type temp32;
-
-    if (!get_masked(h)) {
-        temp32.i = 0;
-    } else {
-        unsigned int offset = get_masking_key_offset(h);
-        std::copy(e.bytes+offset,e.bytes+offset+4,temp32.c);
-    }
-
-    return temp32;
-}
-
-/// Extract the extended size field from an extended header
-/**
- * It is the responsibility of the caller to verify that e is a valid extended
- * header. This function assumes that e contains an extended payload size.
- *
- * @param e The extended header to extract from
- *
- * @return The size encoded in the extended header in host byte order
- */
-inline uint16_t get_extended_size(const extended_header &e) {
-    uint16_converter temp16;
-    std::copy(e.bytes,e.bytes+2,temp16.c);
-    return ntohs(temp16.i);
-}
-
-/// Extract the jumbo size field from an extended header
-/**
- * It is the responsibility of the caller to verify that e is a valid extended
- * header. This function assumes that e contains a jumbo payload size.
- *
- * @param e The extended header to extract from
- *
- * @return The size encoded in the extended header in host byte order
- */
-inline uint64_t get_jumbo_size(const extended_header &e) {
-    uint64_converter temp64;
-    std::copy(e.bytes,e.bytes+8,temp64.c);
-    return lib::net::_ntohll(temp64.i);
-}
-
-/// Extract the full payload size field from a WebSocket header
-/**
- * It is the responsibility of the caller to verify that h and e together
- * represent a valid WebSocket frame header. This function assumes only that h
- * and e are valid. It uses information in the basic header to determine where
- * to look for the payload_size
- *
- * @param h The basic header to extract from
- * @param e The extended header to extract from
- *
- * @return The size encoded in the combined header in host byte order.
- */
-inline uint64_t get_payload_size(const basic_header &h, const
-    extended_header &e)
-{
-    uint8_t val = get_basic_size(h);
-
-    if (val <= limits::payload_size_basic) {
-        return val;
-    } else if (val == payload_size_code_16bit) {
-        return get_extended_size(e);
-    } else {
-        return get_jumbo_size(e);
-    }
-}
-
-/// Extract a masking key into a value the size of a machine word.
-/**
- * Machine word size must be 4 or 8.
- *
- * @param key Masking key to extract from
- *
- * @return prepared key as a machine word
- */
-inline size_t prepare_masking_key(const masking_key_type& key) {
-    size_t low_bits = static_cast<size_t>(key.i);
-
-    if (sizeof(size_t) == 8) {
-        uint64_t high_bits = static_cast<size_t>(key.i);
-        return static_cast<size_t>((high_bits << 32) | low_bits);
-    } else {
-        return low_bits;
-    }
-}
-
-/// circularly shifts the supplied prepared masking key by offset bytes
-/**
- * Prepared_key must be the output of prepare_masking_key with the associated
- * restrictions on the machine word size. offset must be greater than or equal
- * to zero and less than sizeof(size_t).
- */
-inline size_t circshift_prepared_key(size_t prepared_key, size_t offset) {
-    if (offset == 0) {
-        return prepared_key;
-    }
-    if (lib::net::is_little_endian()) {
-        size_t temp = prepared_key << (sizeof(size_t)-offset)*8;
-        return (prepared_key >> offset*8) | temp;
-    } else {
-        size_t temp = prepared_key >> (sizeof(size_t)-offset)*8;
-        return (prepared_key << offset*8) | temp;
-    }
-}
-
-/// Byte by byte mask/unmask
-/**
- * Iterator based byte by byte masking and unmasking for WebSocket payloads.
- * Performs masking in place using the supplied key offset by the supplied
- * offset number of bytes.
- *
- * This function is simple and can be done in place on input with arbitrary
- * lengths and does not vary based on machine word size. It is slow.
- *
- * @param b Beginning iterator to start masking
- *
- * @param e Ending iterator to end masking
- *
- * @param o Beginning iterator to store masked results
- *
- * @param key 32 bit key to mask with.
- *
- * @param key_offset offset value to start masking at.
- */
-template <typename input_iter, typename output_iter>
-void byte_mask(input_iter first, input_iter last, output_iter result,
-    masking_key_type const & key, size_t key_offset)
-{
-    size_t key_index = key_offset%4;
-    while (first != last) {
-        *result = *first ^ key.c[key_index++];
-        key_index %= 4;
-        ++result;
-        ++first;
-    }
-}
-
-/// Byte by byte mask/unmask (in place)
-/**
- * Iterator based byte by byte masking and unmasking for WebSocket payloads.
- * Performs masking in place using the supplied key offset by the supplied
- * offset number of bytes.
- *
- * This function is simple and can be done in place on input with arbitrary
- * lengths and does not vary based on machine word size. It is slow.
- *
- * @param b Beginning iterator to start masking
- *
- * @param e Ending iterator to end masking
- *
- * @param key 32 bit key to mask with.
- *
- * @param key_offset offset value to start masking at.
- */
-template <typename iter_type>
-void byte_mask(iter_type b, iter_type e, masking_key_type const & key,
-    size_t key_offset)
-{
-    byte_mask(b,e,b,key,key_offset);
-}
-
-/// Exact word aligned mask/unmask
-/**
- * Balanced combination of byte by byte and circular word by word masking.
- * Best used to mask complete messages at once. Has much higher setup costs than
- * word_mask_circ but works with exact sized buffers.
- *
- * Buffer based word by word masking and unmasking for WebSocket payloads.
- * Masking is done in word by word chunks with the remainder not divisible by
- * the word size done byte by byte.
- *
- * input and output must both be at least length bytes. Exactly length bytes
- * will be written.
- *
- * @param input buffer to mask or unmask
- *
- * @param output buffer to store the output. May be the same as input.
- *
- * @param length length of data buffer
- *
- * @param key Masking key to use
- */
-inline void word_mask_exact(uint8_t* input, uint8_t* output, size_t length,
-    const masking_key_type& key)
-{
-    size_t prepared_key = prepare_masking_key(key);
-    size_t n = length/sizeof(size_t);
-    size_t* input_word = reinterpret_cast<size_t*>(input);
-    size_t* output_word = reinterpret_cast<size_t*>(output);
-
-    for (size_t i = 0; i < n; i++) {
-        output_word[i] = input_word[i] ^ prepared_key;
-    }
-
-    for (size_t i = n*sizeof(size_t); i < length; i++) {
-        output[i] = input[i] ^ key.c[i%4];
-    }
-}
-
-/// Exact word aligned mask/unmask (in place)
-/**
- * In place version of word_mask_exact
- *
- * @see word_mask_exact
- *
- * @param data buffer to read and write from
- *
- * @param length length of data buffer
- *
- * @param key Masking key to use
- */
-inline void word_mask_exact(uint8_t* data, size_t length, const
-    masking_key_type& key)
-{
-    word_mask_exact(data,data,length,key);
-}
-
-/// Circular word aligned mask/unmask
-/**
- * Performs a circular mask/unmask in word sized chunks using pre-prepared keys
- * that store state between calls. Best for providing streaming masking or
- * unmasking of small chunks at a time of a larger message. Requires that the
- * underlying allocated size of the data buffer be a multiple of the word size.
- * Data in the buffer after `length` will be overwritten only with the same
- * values that were originally present.
- *
- * Buffer based word by word masking and unmasking for WebSocket payloads.
- * Performs masking in place using the supplied key. Casts the data buffer to
- * an array of size_t's and performs masking word by word. The underlying
- * buffer size must be a muliple of the word size.
- *
- * word_mask returns a copy of prepared_key circularly shifted based on the
- * length value. The returned value may be fed back into word_mask when more
- * data is available.
- *
- * input and output must both have length at least:
- *    ceil(length/sizeof(size_t))*sizeof(size_t)
- * Exactly that many bytes will be written, although only exactly length bytes
- * will be changed (trailing bytes will be replaced without masking)
- *
- * @param data Character buffer to mask
- *
- * @param length Length of data
- *
- * @param prepared_key Prepared key to use.
- *
- * @return the prepared_key shifted to account for the input length
- */
-inline size_t word_mask_circ(uint8_t * input, uint8_t * output, size_t length,
-    size_t prepared_key)
-{
-    size_t n = length / sizeof(size_t); // whole words
-    size_t l = length - (n * sizeof(size_t)); // remaining bytes
-    size_t * input_word = reinterpret_cast<size_t *>(input);
-    size_t * output_word = reinterpret_cast<size_t *>(output);
-
-    // mask word by word
-    for (size_t i = 0; i < n; i++) {
-        output_word[i] = input_word[i] ^ prepared_key;
-    }
-
-    // mask partial word at the end
-    size_t start = length - l;
-    uint8_t * byte_key = reinterpret_cast<uint8_t *>(&prepared_key);
-    for (size_t i = 0; i < l; ++i) {
-        output[start+i] = input[start+i] ^ byte_key[i];
-    }
-
-    return circshift_prepared_key(prepared_key,l);
-}
-
-/// Circular word aligned mask/unmask (in place)
-/**
- * In place version of word_mask_circ
- *
- * @see word_mask_circ
- *
- * @param data Character buffer to read from and write to
- *
- * @param length Length of data
- *
- * @param prepared_key Prepared key to use.
- *
- * @return the prepared_key shifted to account for the input length
- */
-inline size_t word_mask_circ(uint8_t* data, size_t length, size_t prepared_key){
-    return word_mask_circ(data,data,length,prepared_key);
-}
-
-/// Circular byte aligned mask/unmask
-/**
- * Performs a circular mask/unmask in byte sized chunks using pre-prepared keys
- * that store state between calls. Best for providing streaming masking or
- * unmasking of small chunks at a time of a larger message. Requires that the
- * underlying allocated size of the data buffer be a multiple of the word size.
- * Data in the buffer after `length` will be overwritten only with the same
- * values that were originally present.
- *
- * word_mask returns a copy of prepared_key circularly shifted based on the
- * length value. The returned value may be fed back into byte_mask when more
- * data is available.
- *
- * @param data Character buffer to mask
- *
- * @param length Length of data
- *
- * @param prepared_key Prepared key to use.
- *
- * @return the prepared_key shifted to account for the input length
- */
-inline size_t byte_mask_circ(uint8_t * input, uint8_t * output, size_t length,
-    size_t prepared_key)
-{
-    uint32_converter key;
-    key.i = prepared_key;
-
-    for (size_t i = 0; i < length; ++i) {
-        output[i] = input[i] ^ key.c[i % 4];
-    }
-
-    return circshift_prepared_key(prepared_key,length % 4);
-}
-
-/// Circular byte aligned mask/unmask (in place)
-/**
- * In place version of byte_mask_circ
- *
- * @see byte_mask_circ
- *
- * @param data Character buffer to read from and write to
- *
- * @param length Length of data
- *
- * @param prepared_key Prepared key to use.
- *
- * @return the prepared_key shifted to account for the input length
- */
-inline size_t byte_mask_circ(uint8_t* data, size_t length, size_t prepared_key){
-    return byte_mask_circ(data,data,length,prepared_key);
-}
-
-} // namespace frame
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_FRAME_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/constants.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/constants.hpp
deleted file mode 100644
index f946cb3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/constants.hpp
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_CONSTANTS_HPP
-#define HTTP_CONSTANTS_HPP
-
-#include <exception>
-#include <map>
-#include <string>
-#include <vector>
-#include <utility>
-
-namespace websocketpp {
-/// HTTP handling support
-namespace http {
-    /// The type of an HTTP attribute list
-    /**
-     * The attribute list is an unordered key/value map. Encoded attribute
-     * values are delimited by semicolons.
-     */
-    typedef std::map<std::string,std::string> attribute_list;
-
-    /// The type of an HTTP parameter list
-    /**
-     * The parameter list is an ordered pairing of a parameter and its
-     * associated attribute list. Encoded parameter values are delimited by
-     * commas.
-     */
-    typedef std::vector< std::pair<std::string,attribute_list> > parameter_list;
-
-    /// Literal value of the HTTP header delimiter
-    static char const header_delimiter[] = "\r\n";
-
-    /// Literal value of the HTTP header separator
-    static char const header_separator[] = ":";
-
-    /// Literal value of an empty header
-    static std::string const empty_header;
-
-    /// Maximum size in bytes before rejecting an HTTP header as too big.
-    size_t const max_header_size = 16000;
-    
-    /// Default Maximum size in bytes for HTTP message bodies.
-    size_t const max_body_size = 32000000;
-
-    /// Number of bytes to use for temporary istream read buffers
-    size_t const istream_buffer = 512;
-
-    /// invalid HTTP token characters
-    /**
-     * 0x00 - 0x32, 0x7f-0xff
-     * ( ) < > @ , ; : \ " / [ ] ? = { }
-     */
-    static char const header_token[] = {
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..0f
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 10..1f
-        0,1,0,1,1,1,1,1,0,0,1,1,0,1,1,0, // 20..2f
-        1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 30..3f
-        0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 40..4f
-        1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1, // 50..5f
-        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 60..6f
-        1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0, // 70..7f
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 80..8f
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 90..9f
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // a0..af
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // b0..bf
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // c0..cf
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // d0..df
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // e0..ef
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // f0..ff
-    };
-
-    /// Is the character a token
-    inline bool is_token_char(unsigned char c) {
-        return (header_token[c] == 1);
-    }
-
-    /// Is the character a non-token
-    inline bool is_not_token_char(unsigned char c) {
-        return !header_token[c];
-    }
-
-    /// Is the character whitespace
-    /**
-     * whitespace is space (32) or horizontal tab (9)
-     */
-    inline bool is_whitespace_char(unsigned char c) {
-        return (c == 9 || c == 32);
-    }
-
-    /// Is the character non-whitespace
-    inline bool is_not_whitespace_char(unsigned char c) {
-        return (c != 9 && c != 32);
-    }
-
-    /// HTTP Status codes
-    namespace status_code {
-        enum value {
-            uninitialized = 0,
-
-            continue_code = 100,
-            switching_protocols = 101,
-
-            ok = 200,
-            created = 201,
-            accepted = 202,
-            non_authoritative_information = 203,
-            no_content = 204,
-            reset_content = 205,
-            partial_content = 206,
-
-            multiple_choices = 300,
-            moved_permanently = 301,
-            found = 302,
-            see_other = 303,
-            not_modified = 304,
-            use_proxy = 305,
-            temporary_redirect = 307,
-
-            bad_request = 400,
-            unauthorized = 401,
-            payment_required = 402,
-            forbidden = 403,
-            not_found = 404,
-            method_not_allowed = 405,
-            not_acceptable = 406,
-            proxy_authentication_required = 407,
-            request_timeout = 408,
-            conflict = 409,
-            gone = 410,
-            length_required = 411,
-            precondition_failed = 412,
-            request_entity_too_large = 413,
-            request_uri_too_long = 414,
-            unsupported_media_type = 415,
-            request_range_not_satisfiable = 416,
-            expectation_failed = 417,
-            im_a_teapot = 418,
-            upgrade_required = 426,
-            precondition_required = 428,
-            too_many_requests = 429,
-            request_header_fields_too_large = 431,
-
-            internal_server_error = 500,
-            not_implemented = 501,
-            bad_gateway = 502,
-            service_unavailable = 503,
-            gateway_timeout = 504,
-            http_version_not_supported = 505,
-            not_extended = 510,
-            network_authentication_required = 511
-        };
-
-        // TODO: should this be inline?
-        inline std::string get_string(value c) {
-            switch (c) {
-                case uninitialized:
-                    return "Uninitialized";
-                case continue_code:
-                    return "Continue";
-                case switching_protocols:
-                    return "Switching Protocols";
-                case ok:
-                    return "OK";
-                case created:
-                    return "Created";
-                case accepted:
-                    return "Accepted";
-                case non_authoritative_information:
-                    return "Non Authoritative Information";
-                case no_content:
-                    return "No Content";
-                case reset_content:
-                    return "Reset Content";
-                case partial_content:
-                    return "Partial Content";
-                case multiple_choices:
-                    return "Multiple Choices";
-                case moved_permanently:
-                    return "Moved Permanently";
-                case found:
-                    return "Found";
-                case see_other:
-                    return "See Other";
-                case not_modified:
-                    return "Not Modified";
-                case use_proxy:
-                    return "Use Proxy";
-                case temporary_redirect:
-                    return "Temporary Redirect";
-                case bad_request:
-                    return "Bad Request";
-                case unauthorized:
-                    return "Unauthorized";
-                case payment_required:
-                    return "Payment Required";
-                case forbidden:
-                    return "Forbidden";
-                case not_found:
-                    return "Not Found";
-                case method_not_allowed:
-                    return "Method Not Allowed";
-                case not_acceptable:
-                    return "Not Acceptable";
-                case proxy_authentication_required:
-                    return "Proxy Authentication Required";
-                case request_timeout:
-                    return "Request Timeout";
-                case conflict:
-                    return "Conflict";
-                case gone:
-                    return "Gone";
-                case length_required:
-                    return "Length Required";
-                case precondition_failed:
-                    return "Precondition Failed";
-                case request_entity_too_large:
-                    return "Request Entity Too Large";
-                case request_uri_too_long:
-                    return "Request-URI Too Long";
-                case unsupported_media_type:
-                    return "Unsupported Media Type";
-                case request_range_not_satisfiable:
-                    return "Requested Range Not Satisfiable";
-                case expectation_failed:
-                    return "Expectation Failed";
-                case im_a_teapot:
-                    return "I'm a teapot";
-                case upgrade_required:
-                    return "Upgrade Required";
-                case precondition_required:
-                    return "Precondition Required";
-                case too_many_requests:
-                    return "Too Many Requests";
-                case request_header_fields_too_large:
-                    return "Request Header Fields Too Large";
-                case internal_server_error:
-                    return "Internal Server Error";
-                case not_implemented:
-                    return "Not Implemented";
-                case bad_gateway:
-                    return "Bad Gateway";
-                case service_unavailable:
-                    return "Service Unavailable";
-                case gateway_timeout:
-                    return "Gateway Timeout";
-                case http_version_not_supported:
-                    return "HTTP Version Not Supported";
-                case not_extended:
-                    return "Not Extended";
-                case network_authentication_required:
-                    return "Network Authentication Required";
-                default:
-                    return "Unknown";
-            }
-        }
-    }
-
-    class exception : public std::exception {
-    public:
-        exception(const std::string& log_msg,
-                  status_code::value error_code,
-                  const std::string& error_msg = std::string(),
-                  const std::string& body = std::string())
-          : m_msg(log_msg)
-          , m_error_msg(error_msg)
-          , m_body(body)
-          , m_error_code(error_code) {}
-
-        ~exception() throw() {}
-
-        virtual const char* what() const throw() {
-            return m_msg.c_str();
-        }
-
-        std::string         m_msg;
-        std::string         m_error_msg;
-        std::string         m_body;
-        status_code::value  m_error_code;
-    };
-}
-}
-
-#endif // HTTP_CONSTANTS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/parser.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/parser.hpp
deleted file mode 100644
index fd24adb..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/parser.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_IMPL_HPP
-#define HTTP_PARSER_IMPL_HPP
-
-#include <algorithm>
-#include <cstdlib>
-#include <istream>
-#include <sstream>
-#include <string>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-inline void parser::set_version(std::string const & version) {
-    m_version = version;
-}
-
-inline std::string const & parser::get_header(std::string const & key) const {
-    header_list::const_iterator h = m_headers.find(key);
-
-    if (h == m_headers.end()) {
-        return empty_header;
-    } else {
-        return h->second;
-    }
-}
-
-inline bool parser::get_header_as_plist(std::string const & key,
-    parameter_list & out) const
-{
-    header_list::const_iterator it = m_headers.find(key);
-
-    if (it == m_headers.end() || it->second.size() == 0) {
-        return false;
-    }
-
-    return this->parse_parameter_list(it->second,out);
-}
-
-inline void parser::append_header(std::string const & key, std::string const &
-    val)
-{
-    if (std::find_if(key.begin(),key.end(),is_not_token_char) != key.end()) {
-        throw exception("Invalid header name",status_code::bad_request);
-    }
-
-    if (this->get_header(key).empty()) {
-        m_headers[key] = val;
-    } else {
-        m_headers[key] += ", " + val;
-    }
-}
-
-inline void parser::replace_header(std::string const & key, std::string const &
-    val)
-{
-    m_headers[key] = val;
-}
-
-inline void parser::remove_header(std::string const & key) {
-    m_headers.erase(key);
-}
-
-inline void parser::set_body(std::string const & value) {
-    if (value.size() == 0) {
-        remove_header("Content-Length");
-        m_body.clear();
-        return;
-    }
-
-    // TODO: should this method respect the max size? If so how should errors
-    // be indicated?
-
-    std::stringstream len;
-    len << value.size();
-    replace_header("Content-Length", len.str());
-    m_body = value;
-}
-
-inline bool parser::parse_parameter_list(std::string const & in,
-    parameter_list & out) const
-{
-    if (in.size() == 0) {
-        return false;
-    }
-
-    std::string::const_iterator it;
-    it = extract_parameters(in.begin(),in.end(),out);
-    return (it == in.begin());
-}
-
-inline bool parser::prepare_body() {
-    if (!get_header("Content-Length").empty()) {
-        std::string const & cl_header = get_header("Content-Length");
-        char * end;
-        
-        // TODO: not 100% sure what the compatibility of this method is. Also,
-        // I believe this will only work up to 32bit sizes. Is there a need for
-        // > 4GiB HTTP payloads?
-        m_body_bytes_needed = std::strtoul(cl_header.c_str(),&end,10);
-        
-        if (m_body_bytes_needed > m_body_bytes_max) {
-            throw exception("HTTP message body too large",
-                status_code::request_entity_too_large);
-        }
-        
-        m_body_encoding = body_encoding::plain;
-        return true;
-    } else if (get_header("Transfer-Encoding") == "chunked") {
-        // TODO
-        //m_body_encoding = body_encoding::chunked;
-        return false;
-    } else {
-        return false;
-    }
-}
-
-inline size_t parser::process_body(char const * buf, size_t len) {
-    if (m_body_encoding == body_encoding::plain) {
-        size_t processed = (std::min)(m_body_bytes_needed,len);
-        m_body.append(buf,processed);
-        m_body_bytes_needed -= processed;
-        return processed;
-    } else if (m_body_encoding == body_encoding::chunked) {
-        // TODO: 
-        throw exception("Unexpected body encoding",
-            status_code::internal_server_error);
-    } else {
-        throw exception("Unexpected body encoding",
-            status_code::internal_server_error);
-    }
-}
-
-inline void parser::process_header(std::string::iterator begin,
-    std::string::iterator end)
-{
-    std::string::iterator cursor = std::search(
-        begin,
-        end,
-        header_separator,
-        header_separator + sizeof(header_separator) - 1
-    );
-
-    if (cursor == end) {
-        throw exception("Invalid header line",status_code::bad_request);
-    }
-
-    append_header(strip_lws(std::string(begin,cursor)),
-                  strip_lws(std::string(cursor+sizeof(header_separator)-1,end)));
-}
-
-inline header_list const & parser::get_headers() const {
-    return m_headers;
-}
-
-inline std::string parser::raw_headers() const {
-    std::stringstream raw;
-
-    header_list::const_iterator it;
-    for (it = m_headers.begin(); it != m_headers.end(); it++) {
-        raw << it->first << ": " << it->second << "\r\n";
-    }
-
-    return raw.str();
-}
-
-
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#endif // HTTP_PARSER_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/request.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/request.hpp
deleted file mode 100644
index 311a620..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/request.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_REQUEST_IMPL_HPP
-#define HTTP_PARSER_REQUEST_IMPL_HPP
-
-#include <algorithm>
-#include <sstream>
-#include <string>
-
-#include <websocketpp/http/parser.hpp>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-inline size_t request::consume(char const * buf, size_t len) {
-    size_t bytes_processed;
-    
-    if (m_ready) {return 0;}
-    
-    if (m_body_bytes_needed > 0) {
-        bytes_processed = process_body(buf,len);
-        if (body_ready()) {
-            m_ready = true;
-        }
-        return bytes_processed;
-    }
-
-    // copy new header bytes into buffer
-    m_buf->append(buf,len);
-
-    // Search for delimiter in buf. If found read until then. If not read all
-    std::string::iterator begin = m_buf->begin();
-    std::string::iterator end;
-
-    for (;;) {
-        // search for line delimiter
-        end = std::search(
-            begin,
-            m_buf->end(),
-            header_delimiter,
-            header_delimiter+sizeof(header_delimiter)-1
-        );
-        
-        m_header_bytes += (end-begin+sizeof(header_delimiter));
-        
-        if (m_header_bytes > max_header_size) {
-            // exceeded max header size
-            throw exception("Maximum header size exceeded.",
-                status_code::request_header_fields_too_large);
-        }
-
-        if (end == m_buf->end()) {
-            // we are out of bytes. Discard the processed bytes and copy the
-            // remaining unprecessed bytes to the beginning of the buffer
-            std::copy(begin,end,m_buf->begin());
-            m_buf->resize(static_cast<std::string::size_type>(end-begin));
-            m_header_bytes -= m_buf->size();
-
-            return len;
-        }
-
-        //the range [begin,end) now represents a line to be processed.
-        if (end-begin == 0) {
-            // we got a blank line
-            if (m_method.empty() || get_header("Host").empty()) {
-                throw exception("Incomplete Request",status_code::bad_request);
-            }
-
-            bytes_processed = (
-                len - static_cast<std::string::size_type>(m_buf->end()-end)
-                    + sizeof(header_delimiter) - 1
-            );
-
-            // frees memory used temporarily during request parsing
-            m_buf.reset();
-
-            // if this was not an upgrade request and has a content length
-            // continue capturing content-length bytes and expose them as a 
-            // request body.
-            
-            if (prepare_body()) {
-                bytes_processed += process_body(buf+bytes_processed,len-bytes_processed);
-                if (body_ready()) {
-                    m_ready = true;
-                }
-                return bytes_processed;
-            } else {
-                m_ready = true;
-
-                // return number of bytes processed (starting bytes - bytes left)
-                return bytes_processed;
-            }
-        } else {
-            if (m_method.empty()) {
-                this->process(begin,end);
-            } else {
-                this->process_header(begin,end);
-            }
-        }
-
-        begin = end+(sizeof(header_delimiter)-1);
-    }
-}
-
-inline std::string request::raw() const {
-    // TODO: validation. Make sure all required fields have been set?
-    std::stringstream ret;
-
-    ret << m_method << " " << m_uri << " " << get_version() << "\r\n";
-    ret << raw_headers() << "\r\n" << m_body;
-
-    return ret.str();
-}
-
-inline std::string request::raw_head() const {
-    // TODO: validation. Make sure all required fields have been set?
-    std::stringstream ret;
-
-    ret << m_method << " " << m_uri << " " << get_version() << "\r\n";
-    ret << raw_headers() << "\r\n";
-
-    return ret.str();
-}
-
-inline void request::set_method(std::string const & method) {
-    if (std::find_if(method.begin(),method.end(),is_not_token_char) != method.end()) {
-        throw exception("Invalid method token.",status_code::bad_request);
-    }
-
-    m_method = method;
-}
-
-inline void request::set_uri(std::string const & uri) {
-    // TODO: validation?
-    m_uri = uri;
-}
-
-inline void request::process(std::string::iterator begin, std::string::iterator
-    end)
-{
-    std::string::iterator cursor_start = begin;
-    std::string::iterator cursor_end = std::find(begin,end,' ');
-
-    if (cursor_end == end) {
-        throw exception("Invalid request line1",status_code::bad_request);
-    }
-
-    set_method(std::string(cursor_start,cursor_end));
-
-    cursor_start = cursor_end+1;
-    cursor_end = std::find(cursor_start,end,' ');
-
-    if (cursor_end == end) {
-        throw exception("Invalid request line2",status_code::bad_request);
-    }
-
-    set_uri(std::string(cursor_start,cursor_end));
-    set_version(std::string(cursor_end+1,end));
-}
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#endif // HTTP_PARSER_REQUEST_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/response.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/response.hpp
deleted file mode 100644
index 4400cda..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/impl/response.hpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_RESPONSE_IMPL_HPP
-#define HTTP_PARSER_RESPONSE_IMPL_HPP
-
-#include <algorithm>
-#include <istream>
-#include <sstream>
-#include <string>
-
-#include <websocketpp/http/parser.hpp>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-inline size_t response::consume(char const * buf, size_t len) {
-    if (m_state == DONE) {return 0;}
-
-    if (m_state == BODY) {
-        return this->process_body(buf,len);
-    }
-
-    // copy new header bytes into buffer
-    m_buf->append(buf,len);
-
-    // Search for delimiter in buf. If found read until then. If not read all
-    std::string::iterator begin = m_buf->begin();
-    std::string::iterator end = begin;
-
-
-    for (;;) {
-        // search for delimiter
-        end = std::search(
-            begin,
-            m_buf->end(),
-            header_delimiter,
-            header_delimiter + sizeof(header_delimiter) - 1
-        );
-
-        m_header_bytes += (end-begin+sizeof(header_delimiter));
-        
-        if (m_header_bytes > max_header_size) {
-            // exceeded max header size
-            throw exception("Maximum header size exceeded.",
-                status_code::request_header_fields_too_large);
-        }
-
-        if (end == m_buf->end()) {
-            // we are out of bytes. Discard the processed bytes and copy the
-            // remaining unprecessed bytes to the beginning of the buffer
-            std::copy(begin,end,m_buf->begin());
-            m_buf->resize(static_cast<std::string::size_type>(end-begin));
-
-            m_read += len;
-            m_header_bytes -= m_buf->size();
-
-            return len;
-        }
-
-        //the range [begin,end) now represents a line to be processed.
-
-        if (end-begin == 0) {
-            // we got a blank line
-            if (m_state == RESPONSE_LINE) {
-                throw exception("Incomplete Request",status_code::bad_request);
-            }
-
-            // TODO: grab content-length
-            std::string length = get_header("Content-Length");
-
-            if (length.empty()) {
-                // no content length found, read indefinitely
-                m_read = 0;
-            } else {
-                std::istringstream ss(length);
-
-                if ((ss >> m_read).fail()) {
-                    throw exception("Unable to parse Content-Length header",
-                                    status_code::bad_request);
-                }
-            }
-
-            m_state = BODY;
-
-            // calc header bytes processed (starting bytes - bytes left)
-            size_t read = (
-                len - static_cast<std::string::size_type>(m_buf->end() - end)
-                + sizeof(header_delimiter) - 1
-            );
-
-            // if there were bytes left process them as body bytes
-            if (read < len) {
-                read += this->process_body(buf+read,(len-read));
-            }
-
-            // frees memory used temporarily during header parsing
-            m_buf.reset();
-
-            return read;
-        } else {
-            if (m_state == RESPONSE_LINE) {
-                this->process(begin,end);
-                m_state = HEADERS;
-            } else {
-                this->process_header(begin,end);
-            }
-        }
-
-        begin = end+(sizeof(header_delimiter) - 1);
-    }
-}
-
-inline size_t response::consume(std::istream & s) {
-    char buf[istream_buffer];
-    size_t bytes_read;
-    size_t bytes_processed;
-    size_t total = 0;
-
-    while (s.good()) {
-        s.getline(buf,istream_buffer);
-        bytes_read = static_cast<size_t>(s.gcount());
-
-        if (s.fail() || s.eof()) {
-            bytes_processed = this->consume(buf,bytes_read);
-            total += bytes_processed;
-
-            if (bytes_processed != bytes_read) {
-                // problem
-                break;
-            }
-        } else if (s.bad()) {
-            // problem
-            break;
-        } else {
-            // the delimiting newline was found. Replace the trailing null with
-            // the newline that was discarded, since our raw consume function
-            // expects the newline to be be there.
-            buf[bytes_read-1] = '\n';
-            bytes_processed = this->consume(buf,bytes_read);
-            total += bytes_processed;
-
-            if (bytes_processed != bytes_read) {
-                // problem
-                break;
-            }
-        }
-    }
-
-    return total;
-}
-
-inline std::string response::raw() const {
-    // TODO: validation. Make sure all required fields have been set?
-
-    std::stringstream ret;
-
-    ret << get_version() << " " << m_status_code << " " << m_status_msg;
-    ret << "\r\n" << raw_headers() << "\r\n";
-
-    ret << m_body;
-
-    return ret.str();
-}
-
-inline void response::set_status(status_code::value code) {
-    // TODO: validation?
-    m_status_code = code;
-    m_status_msg = get_string(code);
-}
-
-inline void response::set_status(status_code::value code, std::string const &
-    msg)
-{
-    // TODO: validation?
-    m_status_code = code;
-    m_status_msg = msg;
-}
-
-inline void response::process(std::string::iterator begin,
-    std::string::iterator end)
-{
-    std::string::iterator cursor_start = begin;
-    std::string::iterator cursor_end = std::find(begin,end,' ');
-
-    if (cursor_end == end) {
-        throw exception("Invalid response line",status_code::bad_request);
-    }
-
-    set_version(std::string(cursor_start,cursor_end));
-
-    cursor_start = cursor_end+1;
-    cursor_end = std::find(cursor_start,end,' ');
-
-    if (cursor_end == end) {
-        throw exception("Invalid request line",status_code::bad_request);
-    }
-
-    int code;
-
-    std::istringstream ss(std::string(cursor_start,cursor_end));
-
-    if ((ss >> code).fail()) {
-        throw exception("Unable to parse response code",status_code::bad_request);
-    }
-
-    set_status(status_code::value(code),std::string(cursor_end+1,end));
-}
-
-inline size_t response::process_body(char const * buf, size_t len) {
-    // If no content length was set then we read forever and never set m_ready
-    if (m_read == 0) {
-        //m_body.append(buf,len);
-        //return len;
-        m_state = DONE;
-        return 0;
-    }
-
-    // Otherwise m_read is the number of bytes left.
-    size_t to_read;
-
-    if (len >= m_read) {
-        // if we have more bytes than we need read, read only the amount needed
-        // then set done state
-        to_read = m_read;
-        m_state = DONE;
-    } else {
-        // we need more bytes than are available, read them all
-        to_read = len;
-    }
-
-    m_body.append(buf,to_read);
-    m_read -= to_read;
-    return to_read;
-}
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#endif // HTTP_PARSER_RESPONSE_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/parser.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/parser.hpp
deleted file mode 100644
index 9d309ec..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/parser.hpp
+++ /dev/null
@@ -1,629 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_HPP
-#define HTTP_PARSER_HPP
-
-#include <algorithm>
-#include <map>
-#include <string>
-#include <utility>
-
-#include <websocketpp/utilities.hpp>
-#include <websocketpp/http/constants.hpp>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-namespace state {
-    enum value {
-        method,
-        resource,
-        version,
-        headers
-    };
-}
-
-namespace body_encoding {
-    enum value {
-        unknown,
-        plain,
-        chunked
-    };
-}
-
-typedef std::map<std::string, std::string, utility::ci_less > header_list;
-
-/// Read and return the next token in the stream
-/**
- * Read until a non-token character is found and then return the token and
- * iterator to the next character to read
- *
- * @param begin An iterator to the beginning of the sequence
- * @param end An iterator to the end of the sequence
- * @return A pair containing the token and an iterator to the next character in
- * the stream
- */
-template <typename InputIterator>
-std::pair<std::string,InputIterator> extract_token(InputIterator begin,
-    InputIterator end)
-{
-    InputIterator it = std::find_if(begin,end,&is_not_token_char);
-    return std::make_pair(std::string(begin,it),it);
-}
-
-/// Read and return the next quoted string in the stream
-/**
- * Read a double quoted string starting at `begin`. The quotes themselves are
- * stripped. The quoted value is returned along with an iterator to the next
- * character to read
- *
- * @param begin An iterator to the beginning of the sequence
- * @param end An iterator to the end of the sequence
- * @return A pair containing the string read and an iterator to the next
- * character in the stream
- */
-template <typename InputIterator>
-std::pair<std::string,InputIterator> extract_quoted_string(InputIterator begin,
-    InputIterator end)
-{
-    std::string s;
-
-    if (end == begin) {
-        return std::make_pair(s,begin);
-    }
-
-    if (*begin != '"') {
-        return std::make_pair(s,begin);
-    }
-
-    InputIterator cursor = begin+1;
-    InputIterator marker = cursor;
-
-    cursor = std::find(cursor,end,'"');
-
-    while (cursor != end) {
-        // either this is the end or a quoted string
-        if (*(cursor-1) == '\\') {
-            s.append(marker,cursor-1);
-            s.append(1,'"');
-            ++cursor;
-            marker = cursor;
-        } else {
-            s.append(marker,cursor);
-            ++cursor;
-            return std::make_pair(s,cursor);
-        }
-
-        cursor = std::find(cursor,end,'"');
-    }
-
-    return std::make_pair("",begin);
-}
-
-/// Read and discard one unit of linear whitespace
-/**
- * Read one unit of linear white space and return the iterator to the character
- * afterwards. If `begin` is returned, no whitespace was extracted.
- *
- * @param begin An iterator to the beginning of the sequence
- * @param end An iterator to the end of the sequence
- * @return An iterator to the character after the linear whitespace read
- */
-template <typename InputIterator>
-InputIterator extract_lws(InputIterator begin, InputIterator end) {
-    InputIterator it = begin;
-
-    // strip leading CRLF
-    if (end-begin > 2 && *begin == '\r' && *(begin+1) == '\n' &&
-        is_whitespace_char(static_cast<unsigned char>(*(begin+2))))
-    {
-        it+=3;
-    }
-
-    it = std::find_if(it,end,&is_not_whitespace_char);
-    return it;
-}
-
-/// Read and discard linear whitespace
-/**
- * Read linear white space until a non-lws character is read and return an
- * iterator to that character. If `begin` is returned, no whitespace was
- * extracted.
- *
- * @param begin An iterator to the beginning of the sequence
- * @param end An iterator to the end of the sequence
- * @return An iterator to the character after the linear whitespace read
- */
-template <typename InputIterator>
-InputIterator extract_all_lws(InputIterator begin, InputIterator end) {
-    InputIterator old_it;
-    InputIterator new_it = begin;
-
-    do {
-        // Pull value from previous iteration
-        old_it = new_it;
-
-        // look ahead another pass
-        new_it = extract_lws(old_it,end);
-    } while (new_it != end && old_it != new_it);
-
-    return new_it;
-}
-
-/// Extract HTTP attributes
-/**
- * An http attributes list is a semicolon delimited list of key value pairs in
- * the format: *( ";" attribute "=" value ) where attribute is a token and value
- * is a token or quoted string.
- *
- * Attributes extracted are appended to the supplied attributes list
- * `attributes`.
- *
- * @param [in] begin An iterator to the beginning of the sequence
- * @param [in] end An iterator to the end of the sequence
- * @param [out] attributes A reference to the attributes list to append
- * attribute/value pairs extracted to
- * @return An iterator to the character after the last atribute read
- */
-template <typename InputIterator>
-InputIterator extract_attributes(InputIterator begin, InputIterator end,
-    attribute_list & attributes)
-{
-    InputIterator cursor;
-    bool first = true;
-
-    if (begin == end) {
-        return begin;
-    }
-
-    cursor = begin;
-    std::pair<std::string,InputIterator> ret;
-
-    while (cursor != end) {
-        std::string name;
-
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end) {
-            break;
-        }
-
-        if (first) {
-            // ignore this check for the very first pass
-            first = false;
-        } else {
-            if (*cursor == ';') {
-                // advance past the ';'
-                ++cursor;
-            } else {
-                // non-semicolon in this position indicates end end of the
-                // attribute list, break and return.
-                break;
-            }
-        }
-
-        cursor = http::parser::extract_all_lws(cursor,end);
-        ret = http::parser::extract_token(cursor,end);
-
-        if (ret.first.empty()) {
-            // error: expected a token
-            return begin;
-        } else {
-            name = ret.first;
-            cursor = ret.second;
-        }
-
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end || *cursor != '=') {
-            // if there is an equals sign, read the attribute value. Otherwise
-            // record a blank value and continue
-            attributes[name].clear();
-            continue;
-        }
-
-        // advance past the '='
-        ++cursor;
-
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end) {
-            // error: expected a token or quoted string
-            return begin;
-        }
-
-        ret = http::parser::extract_quoted_string(cursor,end);
-        if (ret.second != cursor) {
-            attributes[name] = ret.first;
-            cursor = ret.second;
-            continue;
-        }
-
-        ret = http::parser::extract_token(cursor,end);
-        if (ret.first.empty()) {
-            // error : expected token or quoted string
-            return begin;
-        } else {
-            attributes[name] = ret.first;
-            cursor = ret.second;
-        }
-    }
-
-    return cursor;
-}
-
-/// Extract HTTP parameters
-/**
- * An http parameters list is a comma delimited list of tokens followed by
- * optional semicolon delimited attributes lists.
- *
- * Parameters extracted are appended to the supplied parameters list
- * `parameters`.
- *
- * @param [in] begin An iterator to the beginning of the sequence
- * @param [in] end An iterator to the end of the sequence
- * @param [out] parameters A reference to the parameters list to append
- * paramter values extracted to
- * @return An iterator to the character after the last parameter read
- */
-template <typename InputIterator>
-InputIterator extract_parameters(InputIterator begin, InputIterator end,
-    parameter_list &parameters)
-{
-    InputIterator cursor;
-
-    if (begin == end) {
-        // error: expected non-zero length range
-        return begin;
-    }
-
-    cursor = begin;
-    std::pair<std::string,InputIterator> ret;
-
-    /**
-     * LWS
-     * token
-     * LWS
-     * *(";" method-param)
-     * LWS
-     * ,=loop again
-     */
-    while (cursor != end) {
-        std::string parameter_name;
-        attribute_list attributes;
-
-        // extract any stray whitespace
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end) {break;}
-
-        ret = http::parser::extract_token(cursor,end);
-
-        if (ret.first.empty()) {
-            // error: expected a token
-            return begin;
-        } else {
-            parameter_name = ret.first;
-            cursor = ret.second;
-        }
-
-        // Safe break point, insert parameter with blank attributes and exit
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end) {
-            //parameters[parameter_name] = attributes;
-            parameters.push_back(std::make_pair(parameter_name,attributes));
-            break;
-        }
-
-        // If there is an attribute list, read it in
-        if (*cursor == ';') {
-            InputIterator acursor;
-
-            ++cursor;
-            acursor = http::parser::extract_attributes(cursor,end,attributes);
-
-            if (acursor == cursor) {
-                // attribute extraction ended in syntax error
-                return begin;
-            }
-
-            cursor = acursor;
-        }
-
-        // insert parameter into output list
-        //parameters[parameter_name] = attributes;
-        parameters.push_back(std::make_pair(parameter_name,attributes));
-
-        cursor = http::parser::extract_all_lws(cursor,end);
-        if (cursor == end) {break;}
-
-        // if next char is ',' then read another parameter, else stop
-        if (*cursor != ',') {
-            break;
-        }
-
-        // advance past comma
-        ++cursor;
-
-        if (cursor == end) {
-            // expected more bytes after a comma
-            return begin;
-        }
-    }
-
-    return cursor;
-}
-
-inline std::string strip_lws(std::string const & input) {
-    std::string::const_iterator begin = extract_all_lws(input.begin(),input.end());
-    if (begin == input.end()) {
-        return std::string();
-    }
-
-    std::string::const_reverse_iterator rbegin = extract_all_lws(input.rbegin(),input.rend());
-    if (rbegin == input.rend()) {
-        return std::string();
-    }
-
-    return std::string(begin,rbegin.base());
-}
-
-/// Base HTTP parser
-/**
- * Includes methods and data elements common to all types of HTTP messages such
- * as headers, versions, bodies, etc.
- */
-class parser {
-public:
-    parser()
-      : m_header_bytes(0)
-      , m_body_bytes_needed(0)
-      , m_body_bytes_max(max_body_size)
-      , m_body_encoding(body_encoding::unknown) {}
-    
-    /// Get the HTTP version string
-    /**
-     * @return The version string for this parser
-     */
-    std::string const & get_version() const {
-        return m_version;
-    }
-
-    /// Set HTTP parser Version
-    /**
-     * Input should be in format: HTTP/x.y where x and y are positive integers.
-     * @todo Does this method need any validation?
-     *
-     * @param [in] version The value to set the HTTP version to.
-     */
-    void set_version(std::string const & version);
-
-    /// Get the value of an HTTP header
-    /**
-     * @todo Make this method case insensitive.
-     *
-     * @param [in] key The name/key of the header to get.
-     * @return The value associated with the given HTTP header key.
-     */
-    std::string const & get_header(std::string const & key) const;
-
-    /// Extract an HTTP parameter list from a parser header.
-    /**
-     * If the header requested doesn't exist or exists and is empty the
-     * parameter list is valid (but empty).
-     *
-     * @param [in] key The name/key of the HTTP header to use as input.
-     * @param [out] out The parameter list to store extracted parameters in.
-     * @return Whether or not the input was a valid parameter list.
-     */
-    bool get_header_as_plist(std::string const & key, parameter_list & out)
-        const;
-
-    /// Return a list of all HTTP headers
-    /**
-     * Return a list of all HTTP headers
-     *
-     * @since 0.8.0
-     *
-     * @return A list of all HTTP headers
-     */
-    header_list const & get_headers() const;
-
-    /// Append a value to an existing HTTP header
-    /**
-     * This method will set the value of the HTTP header `key` with the
-     * indicated value. If a header with the name `key` already exists, `val`
-     * will be appended to the existing value.
-     *
-     * @todo Make this method case insensitive.
-     * @todo Should there be any restrictions on which keys are allowed?
-     * @todo Exception free varient
-     *
-     * @see replace_header
-     *
-     * @param [in] key The name/key of the header to append to.
-     * @param [in] val The value to append.
-     */
-    void append_header(std::string const & key, std::string const & val);
-
-    /// Set a value for an HTTP header, replacing an existing value
-    /**
-     * This method will set the value of the HTTP header `key` with the
-     * indicated value. If a header with the name `key` already exists, `val`
-     * will replace the existing value.
-     *
-     * @todo Make this method case insensitive.
-     * @todo Should there be any restrictions on which keys are allowed?
-     * @todo Exception free varient
-     *
-     * @see append_header
-     *
-     * @param [in] key The name/key of the header to append to.
-     * @param [in] val The value to append.
-     */
-    void replace_header(std::string const & key, std::string const & val);
-
-    /// Remove a header from the parser
-    /**
-     * Removes the header entirely from the parser. This is different than
-     * setting the value of the header to blank.
-     *
-     * @todo Make this method case insensitive.
-     *
-     * @param [in] key The name/key of the header to remove.
-     */
-    void remove_header(std::string const & key);
-
-    /// Get HTTP body
-    /**
-     * Gets the body of the HTTP object
-     *
-     * @return The body of the HTTP message.
-     */
-    std::string const & get_body() const {
-        return m_body;
-    }
-
-    /// Set body content
-    /**
-     * Set the body content of the HTTP response to the parameter string. Note
-     * set_body will also set the Content-Length HTTP header to the appropriate
-     * value. If you want the Content-Length header to be something else, do so
-     * via replace_header("Content-Length") after calling set_body()
-     *
-     * @param value String data to include as the body content.
-     */
-    void set_body(std::string const & value);
-
-    /// Get body size limit
-    /**
-     * Retrieves the maximum number of bytes to parse & buffer before canceling
-     * a request.
-     *
-     * @since 0.5.0
-     *
-     * @return The maximum length of a message body.
-     */
-    size_t get_max_body_size() const {
-        return m_body_bytes_max;
-    }
-
-    /// Set body size limit
-    /**
-     * Set the maximum number of bytes to parse and buffer before canceling a
-     * request.
-     *
-     * @since 0.5.0
-     *
-     * @param value The size to set the max body length to.
-     */
-    void set_max_body_size(size_t value) {
-        m_body_bytes_max = value;
-    }
-
-    /// Extract an HTTP parameter list from a string.
-    /**
-     * @param [in] in The input string.
-     * @param [out] out The parameter list to store extracted parameters in.
-     * @return Whether or not the input was a valid parameter list.
-     */
-    bool parse_parameter_list(std::string const & in, parameter_list & out)
-        const;
-protected:
-    /// Process a header line
-    /**
-     * @todo Update this method to be exception free.
-     *
-     * @param [in] begin An iterator to the beginning of the sequence.
-     * @param [in] end An iterator to the end of the sequence.
-     */
-    void process_header(std::string::iterator begin, std::string::iterator end);
-
-    /// Prepare the parser to begin parsing body data
-    /**
-     * Inspects headers to determine if the message has a body that needs to be
-     * read. If so, sets up the necessary state, otherwise returns false. If
-     * this method returns true and loading the message body is desired call
-     * `process_body` until it returns zero bytes or an error.
-     *
-     * Must not be called until after all headers have been processed.
-     *
-     * @since 0.5.0
-     *
-     * @return True if more bytes are needed to load the body, false otherwise.
-     */
-    bool prepare_body();
-
-    /// Process body data
-    /**
-     * Parses body data.
-     *
-     * @since 0.5.0
-     *
-     * @param [in] begin An iterator to the beginning of the sequence.
-     * @param [in] end An iterator to the end of the sequence.
-     * @return The number of bytes processed
-     */
-    size_t process_body(char const * buf, size_t len);
-
-    /// Check if the parser is done parsing the body
-    /**
-     * Behavior before a call to `prepare_body` is undefined.
-     *
-     * @since 0.5.0
-     *
-     * @return True if the message body has been completed loaded.
-     */
-    bool body_ready() const {
-        return (m_body_bytes_needed == 0);
-    }
-
-    /// Generate and return the HTTP headers as a string
-    /**
-     * Each headers will be followed by the \r\n sequence including the last one.
-     * A second \r\n sequence (blank header) is not appended by this method
-     *
-     * @return The HTTP headers as a string.
-     */
-    std::string raw_headers() const;
-
-    std::string m_version;
-    header_list m_headers;
-    
-    size_t                  m_header_bytes;
-    
-    std::string             m_body;
-    size_t                  m_body_bytes_needed;
-    size_t                  m_body_bytes_max;
-    body_encoding::value    m_body_encoding;
-};
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#include <websocketpp/http/impl/parser.hpp>
-
-#endif // HTTP_PARSER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/request.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/request.hpp
deleted file mode 100644
index 3355c99..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/request.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_REQUEST_HPP
-#define HTTP_PARSER_REQUEST_HPP
-
-#include <string>
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/http/parser.hpp>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-/// Stores, parses, and manipulates HTTP requests
-/**
- * http::request provides the following functionality for working with HTTP
- * requests.
- *
- * - Initialize request via manually setting each element
- * - Initialize request via reading raw bytes and parsing
- * - Once initialized, access individual parsed elements
- * - Once initialized, read entire request as raw bytes
- */
-class request : public parser {
-public:
-    typedef request type;
-    typedef lib::shared_ptr<type> ptr;
-
-    request()
-      : m_buf(lib::make_shared<std::string>())
-      , m_ready(false) {}
-
-    /// Process bytes in the input buffer
-    /**
-     * Process up to len bytes from input buffer buf. Returns the number of
-     * bytes processed. Bytes left unprocessed means bytes left over after the
-     * final header delimiters.
-     *
-     * Consume is a streaming processor. It may be called multiple times on one
-     * request and the full headers need not be available before processing can
-     * begin. If the end of the request was reached during this call to consume
-     * the ready flag will be set. Further calls to consume once ready will be
-     * ignored.
-     *
-     * Consume will throw an http::exception in the case of an error. Typical
-     * error reasons include malformed requests, incomplete requests, and max
-     * header size being reached.
-     *
-     * @param buf Pointer to byte buffer
-     * @param len Size of byte buffer
-     * @return Number of bytes processed.
-     */
-    size_t consume(char const * buf, size_t len);
-
-    /// Returns whether or not the request is ready for reading.
-    bool ready() const {
-        return m_ready;
-    }
-
-    /// Returns the full raw request (including the body)
-    std::string raw() const;
-    
-    /// Returns the raw request headers only (similar to an HTTP HEAD request)
-    std::string raw_head() const;
-
-    /// Set the HTTP method. Must be a valid HTTP token
-    void set_method(std::string const & method);
-
-    /// Return the request method
-    std::string const & get_method() const {
-        return m_method;
-    }
-
-    /// Set the HTTP uri. Must be a valid HTTP uri
-    void set_uri(std::string const & uri);
-
-    /// Return the requested URI
-    std::string const & get_uri() const {
-        return m_uri;
-    }
-
-private:
-    /// Helper function for message::consume. Process request line
-    void process(std::string::iterator begin, std::string::iterator end);
-
-    lib::shared_ptr<std::string>    m_buf;
-    std::string                     m_method;
-    std::string                     m_uri;
-    bool                            m_ready;
-};
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#include <websocketpp/http/impl/request.hpp>
-
-#endif // HTTP_PARSER_REQUEST_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/response.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/response.hpp
deleted file mode 100644
index e724a3d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/http/response.hpp
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef HTTP_PARSER_RESPONSE_HPP
-#define HTTP_PARSER_RESPONSE_HPP
-
-#include <iostream>
-#include <string>
-
-#include <websocketpp/http/parser.hpp>
-
-namespace websocketpp {
-namespace http {
-namespace parser {
-
-/// Stores, parses, and manipulates HTTP responses
-/**
- * http::response provides the following functionality for working with HTTP
- * responses.
- *
- * - Initialize response via manually setting each element
- * - Initialize response via reading raw bytes and parsing
- * - Once initialized, access individual parsed elements
- * - Once initialized, read entire response as raw bytes
- *
- * http::response checks for header completeness separately from the full
- * response. Once the header is complete, the Content-Length header is read to
- * determine when to stop reading body bytes. If no Content-Length is present
- * ready() will never return true. It is the responsibility of the caller to
- * consume to determine when the response is complete (ie when the connection
- * terminates, or some other metric).
- */
-class response : public parser {
-public:
-    typedef response type;
-    typedef lib::shared_ptr<type> ptr;
-
-    response()
-      : m_read(0)
-      , m_buf(lib::make_shared<std::string>())
-      , m_status_code(status_code::uninitialized)
-      , m_state(RESPONSE_LINE) {}
-
-    /// Process bytes in the input buffer
-    /**
-     * Process up to len bytes from input buffer buf. Returns the number of
-     * bytes processed. Bytes left unprocessed means bytes left over after the
-     * final header delimiters.
-     *
-     * Consume is a streaming processor. It may be called multiple times on one
-     * response and the full headers need not be available before processing can
-     * begin. If the end of the response was reached during this call to consume
-     * the ready flag will be set. Further calls to consume once ready will be
-     * ignored.
-     *
-     * Consume will throw an http::exception in the case of an error. Typical
-     * error reasons include malformed responses, incomplete responses, and max
-     * header size being reached.
-     *
-     * @param buf Pointer to byte buffer
-     * @param len Size of byte buffer
-     * @return Number of bytes processed.
-     */
-    size_t consume(char const * buf, size_t len);
-
-    /// Process bytes in the input buffer (istream version)
-    /**
-     * Process bytes from istream s. Returns the number of bytes processed. 
-     * Bytes left unprocessed means bytes left over after the final header
-     * delimiters.
-     *
-     * Consume is a streaming processor. It may be called multiple times on one
-     * response and the full headers need not be available before processing can
-     * begin. If the end of the response was reached during this call to consume
-     * the ready flag will be set. Further calls to consume once ready will be
-     * ignored.
-     *
-     * Consume will throw an http::exception in the case of an error. Typical
-     * error reasons include malformed responses, incomplete responses, and max
-     * header size being reached.
-     *
-     * @param buf Pointer to byte buffer
-     * @param len Size of byte buffer
-     * @return Number of bytes processed.
-     */
-    size_t consume(std::istream & s);
-
-    /// Returns true if the response is ready.
-    /**
-     * @note will never return true if the content length header is not present
-     */
-    bool ready() const {
-        return m_state == DONE;
-    }
-
-    /// Returns true if the response headers are fully parsed.
-    bool headers_ready() const {
-        return (m_state == BODY || m_state == DONE);
-    }
-
-    /// Returns the full raw response
-    std::string raw() const;
-
-    /// Set response status code and message
-    /**
-     * Sets the response status code to `code` and looks up the corresponding
-     * message for standard codes. Non-standard codes will be entered as Unknown
-     * use set_status(status_code::value,std::string) overload to set both
-     * values explicitly.
-     *
-     * @param code Code to set
-     * @param msg Message to set
-     */
-    void set_status(status_code::value code);
-
-    /// Set response status code and message
-    /**
-     * Sets the response status code and message to independent custom values.
-     * use set_status(status_code::value) to set the code and have the standard
-     * message be automatically set.
-     *
-     * @param code Code to set
-     * @param msg Message to set
-     */
-    void set_status(status_code::value code, std::string const & msg);
-
-    /// Return the response status code
-    status_code::value get_status_code() const {
-        return m_status_code;
-    }
-
-    /// Return the response status message
-    const std::string& get_status_msg() const {
-        return m_status_msg;
-    }
-private:
-    /// Helper function for consume. Process response line
-    void process(std::string::iterator begin, std::string::iterator end);
-
-    /// Helper function for processing body bytes
-    size_t process_body(char const * buf, size_t len);
-
-    enum state {
-        RESPONSE_LINE = 0,
-        HEADERS = 1,
-        BODY = 2,
-        DONE = 3
-    };
-
-    std::string                     m_status_msg;
-    size_t                          m_read;
-    lib::shared_ptr<std::string>    m_buf;
-    status_code::value              m_status_code;
-    state                           m_state;
-
-};
-
-} // namespace parser
-} // namespace http
-} // namespace websocketpp
-
-#include <websocketpp/http/impl/response.hpp>
-
-#endif // HTTP_PARSER_RESPONSE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/connection_impl.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/connection_impl.hpp
deleted file mode 100644
index bf88c95..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/connection_impl.hpp
+++ /dev/null
@@ -1,2375 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CONNECTION_IMPL_HPP
-#define WEBSOCKETPP_CONNECTION_IMPL_HPP
-
-#include <websocketpp/processors/hybi00.hpp>
-#include <websocketpp/processors/hybi07.hpp>
-#include <websocketpp/processors/hybi08.hpp>
-#include <websocketpp/processors/hybi13.hpp>
-
-#include <websocketpp/processors/processor.hpp>
-
-#include <websocketpp/common/platforms.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <algorithm>
-#include <exception>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace websocketpp {
-
-namespace istate = session::internal_state;
-
-template <typename config>
-void connection<config>::set_termination_handler(
-    termination_handler new_handler)
-{
-    m_alog->write(log::alevel::devel,
-        "connection set_termination_handler");
-
-    //scoped_lock_type lock(m_connection_state_lock);
-
-    m_termination_handler = new_handler;
-}
-
-template <typename config>
-std::string const & connection<config>::get_origin() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_processor->get_origin(m_request);
-}
-
-template <typename config>
-size_t connection<config>::get_buffered_amount() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_send_buffer_size;
-}
-
-template <typename config>
-session::state::value connection<config>::get_state() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_state;
-}
-
-template <typename config>
-lib::error_code connection<config>::send(std::string const & payload,
-    frame::opcode::value op)
-{
-    message_ptr msg = m_msg_manager->get_message(op,payload.size());
-    msg->append_payload(payload);
-    msg->set_compressed(true);
-
-    return send(msg);
-}
-
-template <typename config>
-lib::error_code connection<config>::send(void const * payload, size_t len,
-    frame::opcode::value op)
-{
-    message_ptr msg = m_msg_manager->get_message(op,len);
-    msg->append_payload(payload,len);
-
-    return send(msg);
-}
-
-template <typename config>
-lib::error_code connection<config>::send(typename config::message_type::ptr msg)
-{
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection send");
-    }
-
-    {
-        scoped_lock_type lock(m_connection_state_lock);
-        if (m_state != session::state::open) {
-           return error::make_error_code(error::invalid_state);
-        }
-    }
-
-    message_ptr outgoing_msg;
-    bool needs_writing = false;
-
-    if (msg->get_prepared()) {
-        outgoing_msg = msg;
-
-        scoped_lock_type lock(m_write_lock);
-        write_push(outgoing_msg);
-        needs_writing = !m_write_flag && !m_send_queue.empty();
-    } else {
-        outgoing_msg = m_msg_manager->get_message();
-
-        if (!outgoing_msg) {
-            return error::make_error_code(error::no_outgoing_buffers);
-        }
-
-        scoped_lock_type lock(m_write_lock);
-        lib::error_code ec = m_processor->prepare_data_frame(msg,outgoing_msg);
-
-        if (ec) {
-            return ec;
-        }
-
-        write_push(outgoing_msg);
-        needs_writing = !m_write_flag && !m_send_queue.empty();
-    }
-
-    if (needs_writing) {
-        transport_con_type::dispatch(lib::bind(
-            &type::write_frame,
-            type::get_shared()
-        ));
-    }
-
-    return lib::error_code();
-}
-
-template <typename config>
-void connection<config>::ping(std::string const& payload, lib::error_code& ec) {
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection ping");
-    }
-
-    {
-        scoped_lock_type lock(m_connection_state_lock);
-        if (m_state != session::state::open) {
-            std::stringstream ss;
-            ss << "connection::ping called from invalid state " << m_state;
-            m_alog->write(log::alevel::devel,ss.str());
-            ec = error::make_error_code(error::invalid_state);
-            return;
-        }
-    }
-
-    message_ptr msg = m_msg_manager->get_message();
-    if (!msg) {
-        ec = error::make_error_code(error::no_outgoing_buffers);
-        return;
-    }
-
-    ec = m_processor->prepare_ping(payload,msg);
-    if (ec) {return;}
-
-    // set ping timer if we are listening for one
-    if (m_pong_timeout_handler) {
-        // Cancel any existing timers
-        if (m_ping_timer) {
-            m_ping_timer->cancel();
-        }
-
-        if (m_pong_timeout_dur > 0) {
-            m_ping_timer = transport_con_type::set_timer(
-                m_pong_timeout_dur,
-                lib::bind(
-                    &type::handle_pong_timeout,
-                    type::get_shared(),
-                    payload,
-                    lib::placeholders::_1
-                )
-            );
-        }
-
-        if (!m_ping_timer) {
-            // Our transport doesn't support timers
-            m_elog->write(log::elevel::warn,"Warning: a pong_timeout_handler is \
-                set but the transport in use does not support timeouts.");
-        }
-    }
-
-    bool needs_writing = false;
-    {
-        scoped_lock_type lock(m_write_lock);
-        write_push(msg);
-        needs_writing = !m_write_flag && !m_send_queue.empty();
-    }
-
-    if (needs_writing) {
-        transport_con_type::dispatch(lib::bind(
-            &type::write_frame,
-            type::get_shared()
-        ));
-    }
-
-    ec = lib::error_code();
-}
-
-template<typename config>
-void connection<config>::ping(std::string const & payload) {
-    lib::error_code ec;
-    ping(payload,ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-template<typename config>
-void connection<config>::handle_pong_timeout(std::string payload,
-    lib::error_code const & ec)
-{
-    if (ec) {
-        if (ec == transport::error::operation_aborted) {
-            // ignore, this is expected
-            return;
-        }
-
-        m_elog->write(log::elevel::devel,"pong_timeout error: "+ec.message());
-        return;
-    }
-
-    if (m_pong_timeout_handler) {
-        m_pong_timeout_handler(m_connection_hdl,payload);
-    }
-}
-
-template <typename config>
-void connection<config>::pong(std::string const& payload, lib::error_code& ec) {
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection pong");
-    }
-
-    {
-        scoped_lock_type lock(m_connection_state_lock);
-        if (m_state != session::state::open) {
-            std::stringstream ss;
-            ss << "connection::pong called from invalid state " << m_state;
-            m_alog->write(log::alevel::devel,ss.str());
-            ec = error::make_error_code(error::invalid_state);
-            return;
-        }
-    }
-
-    message_ptr msg = m_msg_manager->get_message();
-    if (!msg) {
-        ec = error::make_error_code(error::no_outgoing_buffers);
-        return;
-    }
-
-    ec = m_processor->prepare_pong(payload,msg);
-    if (ec) {return;}
-
-    bool needs_writing = false;
-    {
-        scoped_lock_type lock(m_write_lock);
-        write_push(msg);
-        needs_writing = !m_write_flag && !m_send_queue.empty();
-    }
-
-    if (needs_writing) {
-        transport_con_type::dispatch(lib::bind(
-            &type::write_frame,
-            type::get_shared()
-        ));
-    }
-
-    ec = lib::error_code();
-}
-
-template<typename config>
-void connection<config>::pong(std::string const & payload) {
-    lib::error_code ec;
-    pong(payload,ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-template <typename config>
-void connection<config>::close(close::status::value const code,
-    std::string const & reason, lib::error_code & ec)
-{
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection close");
-    }
-
-    // Truncate reason to maximum size allowable in a close frame.
-    std::string tr(reason,0,std::min<size_t>(reason.size(),
-        frame::limits::close_reason_size));
-
-    scoped_lock_type lock(m_connection_state_lock);
-
-    if (m_state != session::state::open) {
-       ec = error::make_error_code(error::invalid_state);
-       return;
-    }
-
-    ec = this->send_close_frame(code,tr,false,close::status::terminal(code));
-}
-
-template<typename config>
-void connection<config>::close(close::status::value const code,
-    std::string const & reason)
-{
-    lib::error_code ec;
-    close(code,reason,ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-/// Trigger the on_interrupt handler
-/**
- * This is thread safe if the transport is thread safe
- */
-template <typename config>
-lib::error_code connection<config>::interrupt() {
-    m_alog->write(log::alevel::devel,"connection connection::interrupt");
-    return transport_con_type::interrupt(
-        lib::bind(
-            &type::handle_interrupt,
-            type::get_shared()
-        )
-    );
-}
-
-
-template <typename config>
-void connection<config>::handle_interrupt() {
-    if (m_interrupt_handler) {
-        m_interrupt_handler(m_connection_hdl);
-    }
-}
-
-template <typename config>
-lib::error_code connection<config>::pause_reading() {
-    m_alog->write(log::alevel::devel,"connection connection::pause_reading");
-    return transport_con_type::dispatch(
-        lib::bind(
-            &type::handle_pause_reading,
-            type::get_shared()
-        )
-    );
-}
-
-/// Pause reading handler. Not safe to call directly
-template <typename config>
-void connection<config>::handle_pause_reading() {
-    m_alog->write(log::alevel::devel,"connection connection::handle_pause_reading");
-    m_read_flag = false;
-}
-
-template <typename config>
-lib::error_code connection<config>::resume_reading() {
-    m_alog->write(log::alevel::devel,"connection connection::resume_reading");
-    return transport_con_type::dispatch(
-        lib::bind(
-            &type::handle_resume_reading,
-            type::get_shared()
-        )
-    );
-}
-
-/// Resume reading helper method. Not safe to call directly
-template <typename config>
-void connection<config>::handle_resume_reading() {
-   m_read_flag = true;
-   read_frame();
-}
-
-
-
-
-
-
-
-
-
-
-
-template <typename config>
-bool connection<config>::get_secure() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_uri->get_secure();
-}
-
-template <typename config>
-std::string const & connection<config>::get_host() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_uri->get_host();
-}
-
-template <typename config>
-std::string const & connection<config>::get_resource() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_uri->get_resource();
-}
-
-template <typename config>
-uint16_t connection<config>::get_port() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_uri->get_port();
-}
-
-template <typename config>
-uri_ptr connection<config>::get_uri() const {
-    //scoped_lock_type lock(m_connection_state_lock);
-    return m_uri;
-}
-
-template <typename config>
-void connection<config>::set_uri(uri_ptr uri) {
-    //scoped_lock_type lock(m_connection_state_lock);
-    m_uri = uri;
-}
-
-
-
-
-
-
-template <typename config>
-std::string const & connection<config>::get_subprotocol() const {
-    return m_subprotocol;
-}
-
-template <typename config>
-std::vector<std::string> const &
-connection<config>::get_requested_subprotocols() const {
-    return m_requested_subprotocols;
-}
-
-template <typename config>
-void connection<config>::add_subprotocol(std::string const & value,
-    lib::error_code & ec)
-{
-    if (m_is_server) {
-        ec = error::make_error_code(error::client_only);
-        return;
-    }
-
-    // If the value is empty or has a non-RFC2616 token character it is invalid.
-    if (value.empty() || std::find_if(value.begin(),value.end(),
-                                      http::is_not_token_char) != value.end())
-    {
-        ec = error::make_error_code(error::invalid_subprotocol);
-        return;
-    }
-
-    m_requested_subprotocols.push_back(value);
-}
-
-template <typename config>
-void connection<config>::add_subprotocol(std::string const & value) {
-    lib::error_code ec;
-    this->add_subprotocol(value,ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-
-template <typename config>
-void connection<config>::select_subprotocol(std::string const & value,
-    lib::error_code & ec)
-{
-    if (!m_is_server) {
-        ec = error::make_error_code(error::server_only);
-        return;
-    }
-
-    if (value.empty()) {
-        ec = lib::error_code();
-        return;
-    }
-
-    std::vector<std::string>::iterator it;
-
-    it = std::find(m_requested_subprotocols.begin(),
-                   m_requested_subprotocols.end(),
-                   value);
-
-    if (it == m_requested_subprotocols.end()) {
-        ec = error::make_error_code(error::unrequested_subprotocol);
-        return;
-    }
-
-    m_subprotocol = value;
-}
-
-template <typename config>
-void connection<config>::select_subprotocol(std::string const & value) {
-    lib::error_code ec;
-    this->select_subprotocol(value,ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-
-template <typename config>
-std::string const &
-connection<config>::get_request_header(std::string const & key) const {
-    return m_request.get_header(key);
-}
-
-template <typename config>
-std::string const &
-connection<config>::get_request_body() const {
-    return m_request.get_body();
-}
-
-template <typename config>
-std::string const &
-connection<config>::get_response_header(std::string const & key) const {
-    return m_response.get_header(key);
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::set_status(http::status_code::value code)
-{
-    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
-        throw exception("Call to set_status from invalid state",
-                      error::make_error_code(error::invalid_state));
-    }
-    m_response.set_status(code);
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::set_status(http::status_code::value code,
-    std::string const & msg)
-{
-    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
-        throw exception("Call to set_status from invalid state",
-                      error::make_error_code(error::invalid_state));
-    }
-
-    m_response.set_status(code,msg);
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::set_body(std::string const & value) {
-    if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
-        throw exception("Call to set_status from invalid state",
-                      error::make_error_code(error::invalid_state));
-    }
-
-    m_response.set_body(value);
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::append_header(std::string const & key,
-    std::string const & val)
-{
-    if (m_is_server) {
-        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
-            // we are setting response headers for an incoming server connection
-            m_response.append_header(key,val);
-        } else {
-            throw exception("Call to append_header from invalid state",
-                      error::make_error_code(error::invalid_state));
-        }
-    } else {
-        if (m_internal_state == istate::USER_INIT) {
-            // we are setting initial headers for an outgoing client connection
-            m_request.append_header(key,val);
-        } else {
-            throw exception("Call to append_header from invalid state",
-                      error::make_error_code(error::invalid_state));
-        }
-    }
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::replace_header(std::string const & key,
-    std::string const & val)
-{
-    if (m_is_server) {
-        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
-            // we are setting response headers for an incoming server connection
-            m_response.replace_header(key,val);
-        } else {
-            throw exception("Call to replace_header from invalid state",
-                        error::make_error_code(error::invalid_state));
-        }
-    } else {
-        if (m_internal_state == istate::USER_INIT) {
-            // we are setting initial headers for an outgoing client connection
-            m_request.replace_header(key,val);
-        } else {
-            throw exception("Call to replace_header from invalid state",
-                        error::make_error_code(error::invalid_state));
-        }
-    }
-}
-
-// TODO: EXCEPTION_FREE
-template <typename config>
-void connection<config>::remove_header(std::string const & key)
-{
-    if (m_is_server) {
-        if (m_internal_state == istate::PROCESS_HTTP_REQUEST) {
-            // we are setting response headers for an incoming server connection
-            m_response.remove_header(key);
-        } else {
-            throw exception("Call to remove_header from invalid state",
-                        error::make_error_code(error::invalid_state));
-        }
-    } else {
-        if (m_internal_state == istate::USER_INIT) {
-            // we are setting initial headers for an outgoing client connection
-            m_request.remove_header(key);
-        } else {
-            throw exception("Call to remove_header from invalid state",
-                        error::make_error_code(error::invalid_state));
-        }
-    }
-}
-
-/// Defer HTTP Response until later
-/**
- * Used in the http handler to defer the HTTP response for this connection
- * until later. Handshake timers will be canceled and the connection will be
- * left open until `send_http_response` or an equivalent is called.
- *
- * Warning: deferred connections won't time out and as a result can tie up
- * resources.
- *
- * @return A status code, zero on success, non-zero otherwise
- */
-template <typename config>
-lib::error_code connection<config>::defer_http_response() {
-    // Cancel handshake timer, otherwise the connection will time out and we'll
-    // close the connection before the app has a chance to send a response.
-    if (m_handshake_timer) {
-        m_handshake_timer->cancel();
-        m_handshake_timer.reset();
-    }
-    
-    // Do something to signal deferral
-    m_http_state = session::http_state::deferred;
-    
-    return lib::error_code();
-}
-
-/// Send deferred HTTP Response (exception free)
-/**
- * Sends an http response to an HTTP connection that was deferred. This will
- * send a complete response including all headers, status line, and body
- * text. The connection will be closed afterwards.
- *
- * @since 0.6.0
- *
- * @param ec A status code, zero on success, non-zero otherwise
- */
-template <typename config>
-void connection<config>::send_http_response(lib::error_code & ec) {
-    {
-        scoped_lock_type lock(m_connection_state_lock);
-        if (m_http_state != session::http_state::deferred) {
-            ec = error::make_error_code(error::invalid_state);
-            return;
-        }
-    
-        m_http_state = session::http_state::body_written;
-    }
-    
-    this->write_http_response(lib::error_code());
-    ec = lib::error_code();
-}
-
-template <typename config>
-void connection<config>::send_http_response() {
-    lib::error_code ec;
-    this->send_http_response(ec);
-    if (ec) {
-        throw exception(ec);
-    }
-}
-
-
-
-
-/******** logic thread ********/
-
-template <typename config>
-void connection<config>::start() {
-    m_alog->write(log::alevel::devel,"connection start");
-
-    if (m_internal_state != istate::USER_INIT) {
-        m_alog->write(log::alevel::devel,"Start called in invalid state");
-        this->terminate(error::make_error_code(error::invalid_state));
-        return;
-    }
-
-    m_internal_state = istate::TRANSPORT_INIT;
-
-    // Depending on how the transport implements init this function may return
-    // immediately and call handle_transport_init later or call
-    // handle_transport_init from this function.
-    transport_con_type::init(
-        lib::bind(
-            &type::handle_transport_init,
-            type::get_shared(),
-            lib::placeholders::_1
-        )
-    );
-}
-
-template <typename config>
-void connection<config>::handle_transport_init(lib::error_code const & ec) {
-    m_alog->write(log::alevel::devel,"connection handle_transport_init");
-
-    lib::error_code ecm = ec;
-
-    if (m_internal_state != istate::TRANSPORT_INIT) {
-        m_alog->write(log::alevel::devel,
-          "handle_transport_init must be called from transport init state");
-        ecm = error::make_error_code(error::invalid_state);
-    }
-
-    if (ecm) {
-        std::stringstream s;
-        s << "handle_transport_init received error: "<< ecm.message();
-        m_elog->write(log::elevel::rerror,s.str());
-
-        this->terminate(ecm);
-        return;
-    }
-
-    // At this point the transport is ready to read and write bytes.
-    if (m_is_server) {
-        m_internal_state = istate::READ_HTTP_REQUEST;
-        this->read_handshake(1);
-    } else {
-        // We are a client. Set the processor to the version specified in the
-        // config file and send a handshake request.
-        m_internal_state = istate::WRITE_HTTP_REQUEST;
-        m_processor = get_processor(config::client_version);
-        this->send_http_request();
-    }
-}
-
-template <typename config>
-void connection<config>::read_handshake(size_t num_bytes) {
-    m_alog->write(log::alevel::devel,"connection read_handshake");
-
-    if (m_open_handshake_timeout_dur > 0) {
-        m_handshake_timer = transport_con_type::set_timer(
-            m_open_handshake_timeout_dur,
-            lib::bind(
-                &type::handle_open_handshake_timeout,
-                type::get_shared(),
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    transport_con_type::async_read_at_least(
-        num_bytes,
-        m_buf,
-        config::connection_read_buffer_size,
-        lib::bind(
-            &type::handle_read_handshake,
-            type::get_shared(),
-            lib::placeholders::_1,
-            lib::placeholders::_2
-        )
-    );
-}
-
-// All exit paths for this function need to call write_http_response() or submit
-// a new read request with this function as the handler.
-template <typename config>
-void connection<config>::handle_read_handshake(lib::error_code const & ec,
-    size_t bytes_transferred)
-{
-    m_alog->write(log::alevel::devel,"connection handle_read_handshake");
-
-    lib::error_code ecm = ec;
-
-    if (!ecm) {
-        scoped_lock_type lock(m_connection_state_lock);
-        
-        if (m_state == session::state::connecting) {
-             if (m_internal_state != istate::READ_HTTP_REQUEST) {
-                ecm = error::make_error_code(error::invalid_state);
-             }
-        } else if (m_state == session::state::closed) {
-            // The connection was canceled while the response was being sent,
-            // usually by the handshake timer. This is basically expected
-            // (though hopefully rare) and there is nothing we can do so ignore.
-            m_alog->write(log::alevel::devel,
-                "handle_read_handshake invoked after connection was closed");
-            return;
-        } else {
-            ecm = error::make_error_code(error::invalid_state);
-        }
-    }
-
-    if (ecm) {
-        if (ecm == transport::error::eof && m_state == session::state::closed) {
-            // we expect to get eof if the connection is closed already
-            m_alog->write(log::alevel::devel,
-                    "got (expected) eof/state error from closed con");
-            return;
-        }
-        
-        log_err(log::elevel::rerror,"handle_read_handshake",ecm);
-        this->terminate(ecm);
-        return;
-    }
-
-    // Boundaries checking. TODO: How much of this should be done?
-    if (bytes_transferred > config::connection_read_buffer_size) {
-        m_elog->write(log::elevel::fatal,"Fatal boundaries checking error.");
-        this->terminate(make_error_code(error::general));
-        return;
-    }
-
-    size_t bytes_processed = 0;
-    try {
-        bytes_processed = m_request.consume(m_buf,bytes_transferred);
-    } catch (http::exception &e) {
-        // All HTTP exceptions will result in this request failing and an error
-        // response being returned. No more bytes will be read in this con.
-        m_response.set_status(e.m_error_code,e.m_error_msg);
-        this->write_http_response_error(error::make_error_code(error::http_parse_error));
-        return;
-    }
-
-    // More paranoid boundaries checking.
-    // TODO: Is this overkill?
-    if (bytes_processed > bytes_transferred) {
-        m_elog->write(log::elevel::fatal,"Fatal boundaries checking error.");
-        this->terminate(make_error_code(error::general));
-        return;
-    }
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        std::stringstream s;
-        s << "bytes_transferred: " << bytes_transferred
-          << " bytes, bytes processed: " << bytes_processed << " bytes";
-        m_alog->write(log::alevel::devel,s.str());
-    }
-
-    if (m_request.ready()) {
-        lib::error_code processor_ec = this->initialize_processor();
-        if (processor_ec) {
-            this->write_http_response_error(processor_ec);
-            return;
-        }
-
-        if (m_processor && m_processor->get_version() == 0) {
-            // Version 00 has an extra requirement to read some bytes after the
-            // handshake
-            if (bytes_transferred-bytes_processed >= 8) {
-                m_request.replace_header(
-                    "Sec-WebSocket-Key3",
-                    std::string(m_buf+bytes_processed,m_buf+bytes_processed+8)
-                );
-                bytes_processed += 8;
-            } else {
-                // TODO: need more bytes
-                m_alog->write(log::alevel::devel,"short key3 read");
-                m_response.set_status(http::status_code::internal_server_error);
-                this->write_http_response_error(processor::error::make_error_code(processor::error::short_key3));
-                return;
-            }
-        }
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,m_request.raw());
-            if (!m_request.get_header("Sec-WebSocket-Key3").empty()) {
-                m_alog->write(log::alevel::devel,
-                    utility::to_hex(m_request.get_header("Sec-WebSocket-Key3")));
-            }
-        }
-
-        // The remaining bytes in m_buf are frame data. Copy them to the
-        // beginning of the buffer and note the length. They will be read after
-        // the handshake completes and before more bytes are read.
-        std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
-        m_buf_cursor = bytes_transferred-bytes_processed;
-
-
-        m_internal_state = istate::PROCESS_HTTP_REQUEST;
-        
-        // We have the complete request. Process it.
-        lib::error_code handshake_ec = this->process_handshake_request();
-        
-        // Write a response if this is a websocket connection or if it is an
-        // HTTP connection for which the response has not been deferred or
-        // started yet by a different system (i.e. still in init state).
-        if (!m_is_http || m_http_state == session::http_state::init) {
-            this->write_http_response(handshake_ec);
-        }
-    } else {
-        // read at least 1 more byte
-        transport_con_type::async_read_at_least(
-            1,
-            m_buf,
-            config::connection_read_buffer_size,
-            lib::bind(
-                &type::handle_read_handshake,
-                type::get_shared(),
-                lib::placeholders::_1,
-                lib::placeholders::_2
-            )
-        );
-    }
-}
-
-// write_http_response requires the request to be fully read and the connection
-// to be in the PROCESS_HTTP_REQUEST state. In some cases we can detect errors
-// before the request is fully read (specifically at a point where we aren't
-// sure if the hybi00 key3 bytes need to be read). This method sets the correct
-// state and calls write_http_response
-template <typename config>
-void connection<config>::write_http_response_error(lib::error_code const & ec) {
-    if (m_internal_state != istate::READ_HTTP_REQUEST) {
-        m_alog->write(log::alevel::devel,
-            "write_http_response_error called in invalid state");
-        this->terminate(error::make_error_code(error::invalid_state));
-        return;
-    }
-    
-    m_internal_state = istate::PROCESS_HTTP_REQUEST;
-    
-    this->write_http_response(ec);
-}
-
-// All exit paths for this function need to call write_http_response() or submit
-// a new read request with this function as the handler.
-template <typename config>
-void connection<config>::handle_read_frame(lib::error_code const & ec,
-    size_t bytes_transferred)
-{
-    //m_alog->write(log::alevel::devel,"connection handle_read_frame");
-
-    lib::error_code ecm = ec;
-
-    if (!ecm && m_internal_state != istate::PROCESS_CONNECTION) {
-        ecm = error::make_error_code(error::invalid_state);
-    }
-
-    if (ecm) {
-        log::level echannel = log::elevel::rerror;
-        
-        if (ecm == transport::error::eof) {
-            if (m_state == session::state::closed) {
-                // we expect to get eof if the connection is closed already
-                // just ignore it
-                m_alog->write(log::alevel::devel,"got eof from closed con");
-                return;
-            } else if (m_state == session::state::closing && !m_is_server) {
-                // If we are a client we expect to get eof in the closing state,
-                // this is a signal to terminate our end of the connection after
-                // the closing handshake
-                terminate(lib::error_code());
-                return;
-            }
-        } else if (ecm == error::invalid_state) {
-            // In general, invalid state errors in the closed state are the
-            // result of handlers that were in the system already when the state
-            // changed and should be ignored as they pose no problems and there
-            // is nothing useful that we can do about them.
-            if (m_state == session::state::closed) {
-                m_alog->write(log::alevel::devel,
-                    "handle_read_frame: got invalid istate in closed state");
-                return;
-            }
-        } else if (ecm == transport::error::action_after_shutdown) {
-            echannel = log::elevel::info;
-        } else {
-            // TODO: more generally should we do something different here in the
-            // case that m_state is cosed? Are errors after the connection is
-            // already closed really an rerror?
-        }
-        
-        
-        
-        log_err(echannel, "handle_read_frame", ecm);
-        this->terminate(ecm);
-        return;
-    }
-
-    // Boundaries checking. TODO: How much of this should be done?
-    /*if (bytes_transferred > config::connection_read_buffer_size) {
-        m_elog->write(log::elevel::fatal,"Fatal boundaries checking error");
-        this->terminate(make_error_code(error::general));
-        return;
-    }*/
-
-    size_t p = 0;
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        std::stringstream s;
-        s << "p = " << p << " bytes transferred = " << bytes_transferred;
-        m_alog->write(log::alevel::devel,s.str());
-    }
-
-    while (p < bytes_transferred) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            std::stringstream s;
-            s << "calling consume with " << bytes_transferred-p << " bytes";
-            m_alog->write(log::alevel::devel,s.str());
-        }
-
-        lib::error_code consume_ec;
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            std::stringstream s;
-            s << "Processing Bytes: " << utility::to_hex(reinterpret_cast<uint8_t*>(m_buf)+p,bytes_transferred-p);
-            m_alog->write(log::alevel::devel,s.str());
-        }
-
-        p += m_processor->consume(
-            reinterpret_cast<uint8_t*>(m_buf)+p,
-            bytes_transferred-p,
-            consume_ec
-        );
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            std::stringstream s;
-            s << "bytes left after consume: " << bytes_transferred-p;
-            m_alog->write(log::alevel::devel,s.str());
-        }
-        if (consume_ec) {
-            log_err(log::elevel::rerror, "consume", consume_ec);
-
-            if (config::drop_on_protocol_error) {
-                this->terminate(consume_ec);
-                return;
-            } else {
-                lib::error_code close_ec;
-                this->close(
-                    processor::error::to_ws(consume_ec),
-                    consume_ec.message(),
-                    close_ec
-                );
-
-                if (close_ec) {
-                    log_err(log::elevel::fatal, "Protocol error close frame ", close_ec);
-                    this->terminate(close_ec);
-                    return;
-                }
-            }
-            return;
-        }
-
-        if (m_processor->ready()) {
-            if (m_alog->static_test(log::alevel::devel)) {
-                std::stringstream s;
-                s << "Complete message received. Dispatching";
-                m_alog->write(log::alevel::devel,s.str());
-            }
-
-            message_ptr msg = m_processor->get_message();
-
-            if (!msg) {
-                m_alog->write(log::alevel::devel, "null message from m_processor");
-            } else if (!is_control(msg->get_opcode())) {
-                // data message, dispatch to user
-                if (m_state != session::state::open) {
-                    m_elog->write(log::elevel::warn, "got non-close frame while closing");
-                } else if (m_message_handler) {
-                    m_message_handler(m_connection_hdl, msg);
-                }
-            } else {
-                process_control_frame(msg);
-            }
-        }
-    }
-
-    read_frame();
-}
-
-/// Issue a new transport read unless reading is paused.
-template <typename config>
-void connection<config>::read_frame() {
-    if (!m_read_flag) {
-        return;
-    }
-    
-    transport_con_type::async_read_at_least(
-        // std::min wont work with undefined static const values.
-        // TODO: is there a more elegant way to do this?
-        // Need to determine if requesting 1 byte or the exact number of bytes
-        // is better here. 1 byte lets us be a bit more responsive at a
-        // potential expense of additional runs through handle_read_frame
-        /*(m_processor->get_bytes_needed() > config::connection_read_buffer_size ?
-         config::connection_read_buffer_size : m_processor->get_bytes_needed())*/
-        1,
-        m_buf,
-        config::connection_read_buffer_size,
-        m_handle_read_frame
-    );
-}
-
-template <typename config>
-lib::error_code connection<config>::initialize_processor() {
-    m_alog->write(log::alevel::devel,"initialize_processor");
-
-    // if it isn't a websocket handshake nothing to do.
-    if (!processor::is_websocket_handshake(m_request)) {
-        return lib::error_code();
-    }
-
-    int version = processor::get_websocket_version(m_request);
-
-    if (version < 0) {
-        m_alog->write(log::alevel::devel, "BAD REQUEST: can't determine version");
-        m_response.set_status(http::status_code::bad_request);
-        return error::make_error_code(error::invalid_version);
-    }
-
-    m_processor = get_processor(version);
-
-    // if the processor is not null we are done
-    if (m_processor) {
-        return lib::error_code();
-    }
-
-    // We don't have a processor for this version. Return bad request
-    // with Sec-WebSocket-Version header filled with values we do accept
-    m_alog->write(log::alevel::devel, "BAD REQUEST: no processor for version");
-    m_response.set_status(http::status_code::bad_request);
-
-    std::stringstream ss;
-    std::string sep;
-    std::vector<int>::const_iterator it;
-    for (it = versions_supported.begin(); it != versions_supported.end(); it++)
-    {
-        ss << sep << *it;
-        sep = ",";
-    }
-
-    m_response.replace_header("Sec-WebSocket-Version",ss.str());
-    return error::make_error_code(error::unsupported_version);
-}
-
-template <typename config>
-lib::error_code connection<config>::process_handshake_request() {
-    m_alog->write(log::alevel::devel,"process handshake request");
-
-    if (!processor::is_websocket_handshake(m_request)) {
-        // this is not a websocket handshake. Process as plain HTTP
-        m_alog->write(log::alevel::devel,"HTTP REQUEST");
-
-        // extract URI from request
-        m_uri = processor::get_uri_from_host(
-            m_request,
-            (transport_con_type::is_secure() ? "https" : "http")
-        );
-
-        if (!m_uri->get_valid()) {
-            m_alog->write(log::alevel::devel, "Bad request: failed to parse uri");
-            m_response.set_status(http::status_code::bad_request);
-            return error::make_error_code(error::invalid_uri);
-        }
-
-        if (m_http_handler) {
-            m_is_http = true;
-            m_http_handler(m_connection_hdl);
-            
-            if (m_state == session::state::closed) {
-                return error::make_error_code(error::http_connection_ended);
-            }
-        } else {
-            set_status(http::status_code::upgrade_required);
-            return error::make_error_code(error::upgrade_required);
-        }
-
-        return lib::error_code();
-    }
-
-    lib::error_code ec = m_processor->validate_handshake(m_request);
-
-    // Validate: make sure all required elements are present.
-    if (ec){
-        // Not a valid handshake request
-        m_alog->write(log::alevel::devel, "Bad request " + ec.message());
-        m_response.set_status(http::status_code::bad_request);
-        return ec;
-    }
-
-    // Read extension parameters and set up values necessary for the end user
-    // to complete extension negotiation.
-    std::pair<lib::error_code,std::string> neg_results;
-    neg_results = m_processor->negotiate_extensions(m_request);
-
-    if (neg_results.first == processor::error::make_error_code(processor::error::extension_parse_error)) {
-        // There was a fatal error in extension parsing that should result in
-        // a failed connection attempt.
-        m_elog->write(log::elevel::info, "Bad request: " + neg_results.first.message());
-        m_response.set_status(http::status_code::bad_request);
-        return neg_results.first;
-    } else if (neg_results.first) {
-        // There was a fatal error in extension processing that is probably our
-        // fault. Consider extension negotiation to have failed and continue as
-        // if extensions were not supported
-        m_elog->write(log::elevel::info, 
-            "Extension negotiation failed: " + neg_results.first.message());
-    } else {
-        // extension negotiation succeeded, set response header accordingly
-        // we don't send an empty extensions header because it breaks many
-        // clients.
-        if (neg_results.second.size() > 0) {
-            m_response.replace_header("Sec-WebSocket-Extensions",
-                neg_results.second);
-        }
-    }
-
-    // extract URI from request
-    m_uri = m_processor->get_uri(m_request);
-
-
-    if (!m_uri->get_valid()) {
-        m_alog->write(log::alevel::devel, "Bad request: failed to parse uri");
-        m_response.set_status(http::status_code::bad_request);
-        return error::make_error_code(error::invalid_uri);
-    }
-
-    // extract subprotocols
-    lib::error_code subp_ec = m_processor->extract_subprotocols(m_request,
-        m_requested_subprotocols);
-
-    if (subp_ec) {
-        // should we do anything?
-    }
-
-    // Ask application to validate the connection
-    if (!m_validate_handler || m_validate_handler(m_connection_hdl)) {
-        m_response.set_status(http::status_code::switching_protocols);
-
-        // Write the appropriate response headers based on request and
-        // processor version
-        ec = m_processor->process_handshake(m_request,m_subprotocol,m_response);
-
-        if (ec) {
-            std::stringstream s;
-            s << "Processing error: " << ec << "(" << ec.message() << ")";
-            m_alog->write(log::alevel::devel, s.str());
-
-            m_response.set_status(http::status_code::internal_server_error);
-            return ec;
-        }
-    } else {
-        // User application has rejected the handshake
-        m_alog->write(log::alevel::devel, "USER REJECT");
-
-        // Use Bad Request if the user handler did not provide a more
-        // specific http response error code.
-        // TODO: is there a better default?
-        if (m_response.get_status_code() == http::status_code::uninitialized) {
-            m_response.set_status(http::status_code::bad_request);
-        }
-        
-        return error::make_error_code(error::rejected);
-    }
-
-    return lib::error_code();
-}
-
-template <typename config>
-void connection<config>::write_http_response(lib::error_code const & ec) {
-    m_alog->write(log::alevel::devel,"connection write_http_response");
-
-    if (ec == error::make_error_code(error::http_connection_ended)) {
-        m_alog->write(log::alevel::http,"An HTTP handler took over the connection.");
-        return;
-    }
-
-    if (m_response.get_status_code() == http::status_code::uninitialized) {
-        m_response.set_status(http::status_code::internal_server_error);
-        m_ec = error::make_error_code(error::general);
-    } else {
-        m_ec = ec;
-    }
-
-    m_response.set_version("HTTP/1.1");
-
-    // Set server header based on the user agent settings
-    if (m_response.get_header("Server").empty()) {
-        if (!m_user_agent.empty()) {
-            m_response.replace_header("Server",m_user_agent);
-        } else {
-            m_response.remove_header("Server");
-        }
-    }
-
-    // have the processor generate the raw bytes for the wire (if it exists)
-    if (m_processor) {
-        m_handshake_buffer = m_processor->get_raw(m_response);
-    } else {
-        // a processor wont exist for raw HTTP responses.
-        m_handshake_buffer = m_response.raw();
-    }
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"Raw Handshake response:\n"+m_handshake_buffer);
-        if (!m_response.get_header("Sec-WebSocket-Key3").empty()) {
-            m_alog->write(log::alevel::devel,
-                utility::to_hex(m_response.get_header("Sec-WebSocket-Key3")));
-        }
-    }
-
-    // write raw bytes
-    transport_con_type::async_write(
-        m_handshake_buffer.data(),
-        m_handshake_buffer.size(),
-        lib::bind(
-            &type::handle_write_http_response,
-            type::get_shared(),
-            lib::placeholders::_1
-        )
-    );
-}
-
-template <typename config>
-void connection<config>::handle_write_http_response(lib::error_code const & ec) {
-    m_alog->write(log::alevel::devel,"handle_write_http_response");
-
-    lib::error_code ecm = ec;
-
-    if (!ecm) {
-        scoped_lock_type lock(m_connection_state_lock);
-        
-        if (m_state == session::state::connecting) {
-             if (m_internal_state != istate::PROCESS_HTTP_REQUEST) {
-                ecm = error::make_error_code(error::invalid_state);
-             }
-        } else if (m_state == session::state::closed) {
-            // The connection was canceled while the response was being sent,
-            // usually by the handshake timer. This is basically expected
-            // (though hopefully rare) and there is nothing we can do so ignore.
-            m_alog->write(log::alevel::devel,
-                "handle_write_http_response invoked after connection was closed");
-            return;
-        } else {
-            ecm = error::make_error_code(error::invalid_state);
-        }
-    }
-
-    if (ecm) {
-        if (ecm == transport::error::eof && m_state == session::state::closed) {
-            // we expect to get eof if the connection is closed already
-            m_alog->write(log::alevel::devel,
-                    "got (expected) eof/state error from closed con");
-            return;
-        }
-        
-        log_err(log::elevel::rerror,"handle_write_http_response",ecm);
-        this->terminate(ecm);
-        return;
-    }
-
-    if (m_handshake_timer) {
-        m_handshake_timer->cancel();
-        m_handshake_timer.reset();
-    }
-
-    if (m_response.get_status_code() != http::status_code::switching_protocols)
-    {
-        /*if (m_processor || m_ec == error::http_parse_error || 
-            m_ec == error::invalid_version || m_ec == error::unsupported_version
-            || m_ec == error::upgrade_required)
-        {*/
-        if (!m_is_http) {
-            std::stringstream s;
-            s << "Handshake ended with HTTP error: "
-              << m_response.get_status_code();
-            m_elog->write(log::elevel::rerror,s.str());
-        } else {
-            // if this was not a websocket connection, we have written
-            // the expected response and the connection can be closed.
-            
-            this->log_http_result();
-            
-            if (m_ec) {
-                m_alog->write(log::alevel::devel,
-                    "got to writing HTTP results with m_ec set: "+m_ec.message());
-            }
-            m_ec = make_error_code(error::http_connection_ended);
-        }        
-        
-        this->terminate(m_ec);
-        return;
-    }
-
-    this->log_open_result();
-
-    m_internal_state = istate::PROCESS_CONNECTION;
-    m_state = session::state::open;
-
-    if (m_open_handler) {
-        m_open_handler(m_connection_hdl);
-    }
-
-    this->handle_read_frame(lib::error_code(), m_buf_cursor);
-}
-
-template <typename config>
-void connection<config>::send_http_request() {
-    m_alog->write(log::alevel::devel,"connection send_http_request");
-
-    // TODO: origin header?
-
-    // Have the protocol processor fill in the appropriate fields based on the
-    // selected client version
-    if (m_processor) {
-        lib::error_code ec;
-        ec = m_processor->client_handshake_request(m_request,m_uri,
-            m_requested_subprotocols);
-
-        if (ec) {
-            log_err(log::elevel::fatal,"Internal library error: Processor",ec);
-            return;
-        }
-    } else {
-        m_elog->write(log::elevel::fatal,"Internal library error: missing processor");
-        return;
-    }
-
-    // Unless the user has overridden the user agent, send generic WS++ UA.
-    if (m_request.get_header("User-Agent").empty()) {
-        if (!m_user_agent.empty()) {
-            m_request.replace_header("User-Agent",m_user_agent);
-        } else {
-            m_request.remove_header("User-Agent");
-        }
-    }
-
-    m_handshake_buffer = m_request.raw();
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"Raw Handshake request:\n"+m_handshake_buffer);
-    }
-
-    if (m_open_handshake_timeout_dur > 0) {
-        m_handshake_timer = transport_con_type::set_timer(
-            m_open_handshake_timeout_dur,
-            lib::bind(
-                &type::handle_open_handshake_timeout,
-                type::get_shared(),
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    transport_con_type::async_write(
-        m_handshake_buffer.data(),
-        m_handshake_buffer.size(),
-        lib::bind(
-            &type::handle_send_http_request,
-            type::get_shared(),
-            lib::placeholders::_1
-        )
-    );
-}
-
-template <typename config>
-void connection<config>::handle_send_http_request(lib::error_code const & ec) {
-    m_alog->write(log::alevel::devel,"handle_send_http_request");
-
-    lib::error_code ecm = ec;
-
-    if (!ecm) {
-        scoped_lock_type lock(m_connection_state_lock);
-        
-        if (m_state == session::state::connecting) {
-             if (m_internal_state != istate::WRITE_HTTP_REQUEST) {
-                ecm = error::make_error_code(error::invalid_state);
-             } else {
-                m_internal_state = istate::READ_HTTP_RESPONSE;
-             }
-        } else if (m_state == session::state::closed) {
-            // The connection was canceled while the response was being sent,
-            // usually by the handshake timer. This is basically expected
-            // (though hopefully rare) and there is nothing we can do so ignore.
-            m_alog->write(log::alevel::devel,
-                "handle_send_http_request invoked after connection was closed");
-            return;
-        } else {
-            ecm = error::make_error_code(error::invalid_state);
-        }
-    }
-
-    if (ecm) {
-        if (ecm == transport::error::eof && m_state == session::state::closed) {
-            // we expect to get eof if the connection is closed already
-            m_alog->write(log::alevel::devel,
-                    "got (expected) eof/state error from closed con");
-            return;
-        }
-        
-        log_err(log::elevel::rerror,"handle_send_http_request",ecm);
-        this->terminate(ecm);
-        return;
-    }
-
-    transport_con_type::async_read_at_least(
-        1,
-        m_buf,
-        config::connection_read_buffer_size,
-        lib::bind(
-            &type::handle_read_http_response,
-            type::get_shared(),
-            lib::placeholders::_1,
-            lib::placeholders::_2
-        )
-    );
-}
-
-template <typename config>
-void connection<config>::handle_read_http_response(lib::error_code const & ec,
-    size_t bytes_transferred)
-{
-    m_alog->write(log::alevel::devel,"handle_read_http_response");
-
-    lib::error_code ecm = ec;
-
-    if (!ecm) {
-        scoped_lock_type lock(m_connection_state_lock);
-        
-        if (m_state == session::state::connecting) {
-            if (m_internal_state != istate::READ_HTTP_RESPONSE) {
-                ecm = error::make_error_code(error::invalid_state);
-            }
-        } else if (m_state == session::state::closed) {
-            // The connection was canceled while the response was being sent,
-            // usually by the handshake timer. This is basically expected
-            // (though hopefully rare) and there is nothing we can do so ignore.
-            m_alog->write(log::alevel::devel,
-                "handle_read_http_response invoked after connection was closed");
-            return;
-        } else {
-            ecm = error::make_error_code(error::invalid_state);
-        }
-    }
-
-    if (ecm) {
-        if (ecm == transport::error::eof && m_state == session::state::closed) {
-            // we expect to get eof if the connection is closed already
-            m_alog->write(log::alevel::devel,
-                    "got (expected) eof/state error from closed con");
-            return;
-        }
-        
-        log_err(log::elevel::rerror,"handle_read_http_response",ecm);
-        this->terminate(ecm);
-        return;
-    }
-    
-    size_t bytes_processed = 0;
-    // TODO: refactor this to use error codes rather than exceptions
-    try {
-        bytes_processed = m_response.consume(m_buf,bytes_transferred);
-    } catch (http::exception & e) {
-        m_elog->write(log::elevel::rerror,
-            std::string("error in handle_read_http_response: ")+e.what());
-        this->terminate(make_error_code(error::general));
-        return;
-    }
-
-    m_alog->write(log::alevel::devel,std::string("Raw response: ")+m_response.raw());
-
-    if (m_response.headers_ready()) {
-        if (m_handshake_timer) {
-            m_handshake_timer->cancel();
-            m_handshake_timer.reset();
-        }
-
-        lib::error_code validate_ec = m_processor->validate_server_handshake_response(
-            m_request,
-            m_response
-        );
-        if (validate_ec) {
-            log_err(log::elevel::rerror,"Server handshake response",validate_ec);
-            this->terminate(validate_ec);
-            return;
-        }
-
-        // Read extension parameters and set up values necessary for the end
-        // user to complete extension negotiation.
-        std::pair<lib::error_code,std::string> neg_results;
-        neg_results = m_processor->negotiate_extensions(m_response);
-
-        if (neg_results.first) {
-            // There was a fatal error in extension negotiation. For the moment
-            // kill all connections that fail extension negotiation.
-            
-            // TODO: deal with cases where the response is well formed but 
-            // doesn't match the options requested by the client. Its possible
-            // that the best behavior in this cases is to log and continue with
-            // an unextended connection.
-            m_alog->write(log::alevel::devel, "Extension negotiation failed: "
-                + neg_results.first.message());
-            this->terminate(make_error_code(error::extension_neg_failed));
-            // TODO: close connection with reason 1010 (and list extensions)
-        }
-
-        // response is valid, connection can now be assumed to be open      
-        m_internal_state = istate::PROCESS_CONNECTION;
-        m_state = session::state::open;
-
-        this->log_open_result();
-
-        if (m_open_handler) {
-            m_open_handler(m_connection_hdl);
-        }
-
-        // The remaining bytes in m_buf are frame data. Copy them to the
-        // beginning of the buffer and note the length. They will be read after
-        // the handshake completes and before more bytes are read.
-        std::copy(m_buf+bytes_processed,m_buf+bytes_transferred,m_buf);
-        m_buf_cursor = bytes_transferred-bytes_processed;
-
-        this->handle_read_frame(lib::error_code(), m_buf_cursor);
-    } else {
-        transport_con_type::async_read_at_least(
-            1,
-            m_buf,
-            config::connection_read_buffer_size,
-            lib::bind(
-                &type::handle_read_http_response,
-                type::get_shared(),
-                lib::placeholders::_1,
-                lib::placeholders::_2
-            )
-        );
-    }
-}
-
-template <typename config>
-void connection<config>::handle_open_handshake_timeout(
-    lib::error_code const & ec)
-{
-    if (ec == transport::error::operation_aborted) {
-        m_alog->write(log::alevel::devel,"open handshake timer cancelled");
-    } else if (ec) {
-        m_alog->write(log::alevel::devel,
-            "open handle_open_handshake_timeout error: "+ec.message());
-        // TODO: ignore or fail here?
-    } else {
-        m_alog->write(log::alevel::devel,"open handshake timer expired");
-        terminate(make_error_code(error::open_handshake_timeout));
-    }
-}
-
-template <typename config>
-void connection<config>::handle_close_handshake_timeout(
-    lib::error_code const & ec)
-{
-    if (ec == transport::error::operation_aborted) {
-        m_alog->write(log::alevel::devel,"asio close handshake timer cancelled");
-    } else if (ec) {
-        m_alog->write(log::alevel::devel,
-            "asio open handle_close_handshake_timeout error: "+ec.message());
-        // TODO: ignore or fail here?
-    } else {
-        m_alog->write(log::alevel::devel, "asio close handshake timer expired");
-        terminate(make_error_code(error::close_handshake_timeout));
-    }
-}
-
-template <typename config>
-void connection<config>::terminate(lib::error_code const & ec) {
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection terminate");
-    }
-
-    // Cancel close handshake timer
-    if (m_handshake_timer) {
-        m_handshake_timer->cancel();
-        m_handshake_timer.reset();
-    }
-
-    terminate_status tstat = unknown;
-    if (ec) {
-        m_ec = ec;
-        m_local_close_code = close::status::abnormal_close;
-        m_local_close_reason = ec.message();
-    }
-
-    // TODO: does any of this need a mutex?
-    if (m_is_http) {
-        m_http_state = session::http_state::closed;
-    }
-    if (m_state == session::state::connecting) {
-        m_state = session::state::closed;
-        tstat = failed;
-        
-        // Log fail result here before socket is shut down and we can't get
-        // the remote address, etc anymore
-        if (m_ec != error::http_connection_ended) {
-            log_fail_result();
-        }
-    } else if (m_state != session::state::closed) {
-        m_state = session::state::closed;
-        tstat = closed;
-    } else {
-        m_alog->write(log::alevel::devel,
-            "terminate called on connection that was already terminated");
-        return;
-    }
-
-    // TODO: choose between shutdown and close based on error code sent
-
-    transport_con_type::async_shutdown(
-        lib::bind(
-            &type::handle_terminate,
-            type::get_shared(),
-            tstat,
-            lib::placeholders::_1
-        )
-    );
-}
-
-template <typename config>
-void connection<config>::handle_terminate(terminate_status tstat,
-    lib::error_code const & ec)
-{
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection handle_terminate");
-    }
-
-    if (ec) {
-        // there was an error actually shutting down the connection
-        log_err(log::elevel::devel,"handle_terminate",ec);
-    }
-
-    // clean shutdown
-    if (tstat == failed) {
-        if (m_ec != error::http_connection_ended) {
-            if (m_fail_handler) {
-                m_fail_handler(m_connection_hdl);
-            }
-        }
-    } else if (tstat == closed) {
-        if (m_close_handler) {
-            m_close_handler(m_connection_hdl);
-        }
-        log_close_result();
-    } else {
-        m_elog->write(log::elevel::rerror,"Unknown terminate_status");
-    }
-
-    // call the termination handler if it exists
-    // if it exists it might (but shouldn't) refer to a bad memory location.
-    // If it does, we don't care and should catch and ignore it.
-    if (m_termination_handler) {
-        try {
-            m_termination_handler(type::get_shared());
-        } catch (std::exception const & e) {
-            m_elog->write(log::elevel::warn,
-                std::string("termination_handler call failed. Reason was: ")+e.what());
-        }
-    }
-}
-
-template <typename config>
-void connection<config>::write_frame() {
-    //m_alog->write(log::alevel::devel,"connection write_frame");
-
-    {
-        scoped_lock_type lock(m_write_lock);
-
-        // Check the write flag. If true, there is an outstanding transport
-        // write already. In this case we just return. The write handler will
-        // start a new write if the write queue isn't empty. If false, we set
-        // the write flag and proceed to initiate a transport write.
-        if (m_write_flag) {
-            return;
-        }
-
-        // pull off all the messages that are ready to write.
-        // stop if we get a message marked terminal
-        message_ptr next_message = write_pop();
-        while (next_message) {
-            m_current_msgs.push_back(next_message);
-            if (!next_message->get_terminal()) {
-                next_message = write_pop();
-            } else {
-                next_message = message_ptr();
-            }
-        }
-        
-        if (m_current_msgs.empty()) {
-            // there was nothing to send
-            return;
-        } else {
-            // At this point we own the next messages to be sent and are
-            // responsible for holding the write flag until they are 
-            // successfully sent or there is some error
-            m_write_flag = true;
-        }
-    }
-
-    typename std::vector<message_ptr>::iterator it;
-    for (it = m_current_msgs.begin(); it != m_current_msgs.end(); ++it) {
-        std::string const & header = (*it)->get_header();
-        std::string const & payload = (*it)->get_payload();
-
-        m_send_buffer.push_back(transport::buffer(header.c_str(),header.size()));
-        m_send_buffer.push_back(transport::buffer(payload.c_str(),payload.size()));   
-    }
-
-    // Print detailed send stats if those log levels are enabled
-    if (m_alog->static_test(log::alevel::frame_header)) {
-    if (m_alog->dynamic_test(log::alevel::frame_header)) {
-        std::stringstream general,header,payload;
-        
-        general << "Dispatching write containing " << m_current_msgs.size()
-                <<" message(s) containing ";
-        header << "Header Bytes: \n";
-        payload << "Payload Bytes: \n";
-        
-        size_t hbytes = 0;
-        size_t pbytes = 0;
-        
-        for (size_t i = 0; i < m_current_msgs.size(); i++) {
-            hbytes += m_current_msgs[i]->get_header().size();
-            pbytes += m_current_msgs[i]->get_payload().size();
-
-            
-            header << "[" << i << "] (" 
-                   << m_current_msgs[i]->get_header().size() << ") " 
-                   << utility::to_hex(m_current_msgs[i]->get_header()) << "\n";
-
-            if (m_alog->static_test(log::alevel::frame_payload)) {
-            if (m_alog->dynamic_test(log::alevel::frame_payload)) {
-                payload << "[" << i << "] (" 
-                        << m_current_msgs[i]->get_payload().size() << ") ["<<m_current_msgs[i]->get_opcode()<<"] "
-                        << (m_current_msgs[i]->get_opcode() == frame::opcode::text ? 
-                                m_current_msgs[i]->get_payload() : 
-                                utility::to_hex(m_current_msgs[i]->get_payload())
-                           ) 
-                        << "\n";
-            }
-            }  
-        }
-        
-        general << hbytes << " header bytes and " << pbytes << " payload bytes";
-        
-        m_alog->write(log::alevel::frame_header,general.str());
-        m_alog->write(log::alevel::frame_header,header.str());
-        m_alog->write(log::alevel::frame_payload,payload.str());
-    }
-    }
-
-    transport_con_type::async_write(
-        m_send_buffer,
-        m_write_frame_handler
-    );
-}
-
-template <typename config>
-void connection<config>::handle_write_frame(lib::error_code const & ec)
-{
-    if (m_alog->static_test(log::alevel::devel)) {
-        m_alog->write(log::alevel::devel,"connection handle_write_frame");
-    }
-
-    bool terminal = m_current_msgs.back()->get_terminal();
-
-    m_send_buffer.clear();
-    m_current_msgs.clear();
-    // TODO: recycle instead of deleting
-
-    if (ec) {
-        log_err(log::elevel::fatal,"handle_write_frame",ec);
-        this->terminate(ec);
-        return;
-    }
-
-    if (terminal) {
-        this->terminate(lib::error_code());
-        return;
-    }
-
-    bool needs_writing = false;
-    {
-        scoped_lock_type lock(m_write_lock);
-
-        // release write flag
-        m_write_flag = false;
-
-        needs_writing = !m_send_queue.empty();
-    }
-
-    if (needs_writing) {
-        transport_con_type::dispatch(lib::bind(
-            &type::write_frame,
-            type::get_shared()
-        ));
-    }
-}
-
-template <typename config>
-std::vector<int> const & connection<config>::get_supported_versions() const
-{
-    return versions_supported;
-}
-
-template <typename config>
-void connection<config>::process_control_frame(typename config::message_type::ptr msg)
-{
-    m_alog->write(log::alevel::devel,"process_control_frame");
-
-    frame::opcode::value op = msg->get_opcode();
-    lib::error_code ec;
-
-    std::stringstream s;
-    s << "Control frame received with opcode " << op;
-    m_alog->write(log::alevel::control,s.str());
-
-    if (m_state == session::state::closed) {
-        m_elog->write(log::elevel::warn,"got frame in state closed");
-        return;
-    }
-    if (op != frame::opcode::CLOSE && m_state != session::state::open) {
-        m_elog->write(log::elevel::warn,"got non-close frame in state closing");
-        return;
-    }
-
-    if (op == frame::opcode::PING) {
-        bool should_reply = true;
-
-        if (m_ping_handler) {
-            should_reply = m_ping_handler(m_connection_hdl, msg->get_payload());
-        }
-
-        if (should_reply) {
-            this->pong(msg->get_payload(),ec);
-            if (ec) {
-                log_err(log::elevel::devel,"Failed to send response pong",ec);
-            }
-        }
-    } else if (op == frame::opcode::PONG) {
-        if (m_pong_handler) {
-            m_pong_handler(m_connection_hdl, msg->get_payload());
-        }
-        if (m_ping_timer) {
-            m_ping_timer->cancel();
-        }
-    } else if (op == frame::opcode::CLOSE) {
-        m_alog->write(log::alevel::devel,"got close frame");
-        // record close code and reason somewhere
-
-        m_remote_close_code = close::extract_code(msg->get_payload(),ec);
-        if (ec) {
-            s.str("");
-            if (config::drop_on_protocol_error) {
-                s << "Received invalid close code " << m_remote_close_code
-                  << " dropping connection per config.";
-                m_elog->write(log::elevel::devel,s.str());
-                this->terminate(ec);
-            } else {
-                s << "Received invalid close code " << m_remote_close_code
-                  << " sending acknowledgement and closing";
-                m_elog->write(log::elevel::devel,s.str());
-                ec = send_close_ack(close::status::protocol_error,
-                    "Invalid close code");
-                if (ec) {
-                    log_err(log::elevel::devel,"send_close_ack",ec);
-                }
-            }
-            return;
-        }
-
-        m_remote_close_reason = close::extract_reason(msg->get_payload(),ec);
-        if (ec) {
-            if (config::drop_on_protocol_error) {
-                m_elog->write(log::elevel::devel,
-                    "Received invalid close reason. Dropping connection per config");
-                this->terminate(ec);
-            } else {
-                m_elog->write(log::elevel::devel,
-                    "Received invalid close reason. Sending acknowledgement and closing");
-                ec = send_close_ack(close::status::protocol_error,
-                    "Invalid close reason");
-                if (ec) {
-                    log_err(log::elevel::devel,"send_close_ack",ec);
-                }
-            }
-            return;
-        }
-
-        if (m_state == session::state::open) {
-            s.str("");
-            s << "Received close frame with code " << m_remote_close_code
-              << " and reason " << m_remote_close_reason;
-            m_alog->write(log::alevel::devel,s.str());
-
-            ec = send_close_ack();
-            if (ec) {
-                log_err(log::elevel::devel,"send_close_ack",ec);
-            }
-        } else if (m_state == session::state::closing && !m_was_clean) {
-            // ack of our close
-            m_alog->write(log::alevel::devel, "Got acknowledgement of close");
-
-            m_was_clean = true;
-
-            // If we are a server terminate the connection now. Clients should
-            // leave the connection open to give the server an opportunity to
-            // initiate the TCP close. The client's timer will handle closing
-            // its side of the connection if the server misbehaves.
-            //
-            // TODO: different behavior if the underlying transport doesn't
-            // support timers?
-            if (m_is_server) {
-                terminate(lib::error_code());
-            }
-        } else {
-            // spurious, ignore
-            m_elog->write(log::elevel::devel, "Got close frame in wrong state");
-        }
-    } else {
-        // got an invalid control opcode
-        m_elog->write(log::elevel::devel, "Got control frame with invalid opcode");
-        // initiate protocol error shutdown
-    }
-}
-
-template <typename config>
-lib::error_code connection<config>::send_close_ack(close::status::value code,
-    std::string const & reason)
-{
-    return send_close_frame(code,reason,true,m_is_server);
-}
-
-template <typename config>
-lib::error_code connection<config>::send_close_frame(close::status::value code,
-    std::string const & reason, bool ack, bool terminal)
-{
-    m_alog->write(log::alevel::devel,"send_close_frame");
-
-    // check for special codes
-
-    // If silent close is set, respect it and blank out close information
-    // Otherwise use whatever has been specified in the parameters. If
-    // parameters specifies close::status::blank then determine what to do
-    // based on whether or not this is an ack. If it is not an ack just
-    // send blank info. If it is an ack then echo the close information from
-    // the remote endpoint.
-    if (config::silent_close) {
-        m_alog->write(log::alevel::devel,"closing silently");
-        m_local_close_code = close::status::no_status;
-        m_local_close_reason.clear();
-    } else if (code != close::status::blank) {
-        m_alog->write(log::alevel::devel,"closing with specified codes");
-        m_local_close_code = code;
-        m_local_close_reason = reason;
-    } else if (!ack) {
-        m_alog->write(log::alevel::devel,"closing with no status code");
-        m_local_close_code = close::status::no_status;
-        m_local_close_reason.clear();
-    } else if (m_remote_close_code == close::status::no_status) {
-        m_alog->write(log::alevel::devel,
-            "acknowledging a no-status close with normal code");
-        m_local_close_code = close::status::normal;
-        m_local_close_reason.clear();
-    } else {
-        m_alog->write(log::alevel::devel,"acknowledging with remote codes");
-        m_local_close_code = m_remote_close_code;
-        m_local_close_reason = m_remote_close_reason;
-    }
-
-    std::stringstream s;
-    s << "Closing with code: " << m_local_close_code << ", and reason: "
-      << m_local_close_reason;
-    m_alog->write(log::alevel::devel,s.str());
-
-    message_ptr msg = m_msg_manager->get_message();
-    if (!msg) {
-        return error::make_error_code(error::no_outgoing_buffers);
-    }
-
-    lib::error_code ec = m_processor->prepare_close(m_local_close_code,
-        m_local_close_reason,msg);
-    if (ec) {
-        return ec;
-    }
-
-    // Messages flagged terminal will result in the TCP connection being dropped
-    // after the message has been written. This is typically used when servers
-    // send an ack and when any endpoint encounters a protocol error
-    if (terminal) {
-        msg->set_terminal(true);
-    }
-
-    m_state = session::state::closing;
-
-    if (ack) {
-        m_was_clean = true;
-    }
-
-    // Start a timer so we don't wait forever for the acknowledgement close
-    // frame
-    if (m_close_handshake_timeout_dur > 0) {
-        m_handshake_timer = transport_con_type::set_timer(
-            m_close_handshake_timeout_dur,
-            lib::bind(
-                &type::handle_close_handshake_timeout,
-                type::get_shared(),
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    bool needs_writing = false;
-    {
-        scoped_lock_type lock(m_write_lock);
-        write_push(msg);
-        needs_writing = !m_write_flag && !m_send_queue.empty();
-    }
-
-    if (needs_writing) {
-        transport_con_type::dispatch(lib::bind(
-            &type::write_frame,
-            type::get_shared()
-        ));
-    }
-
-    return lib::error_code();
-}
-
-template <typename config>
-typename connection<config>::processor_ptr
-connection<config>::get_processor(int version) const {
-    // TODO: allow disabling certain versions
-    
-    processor_ptr p;
-    
-    switch (version) {
-        case 0:
-            p = lib::make_shared<processor::hybi00<config> >(
-                transport_con_type::is_secure(),
-                m_is_server,
-                m_msg_manager
-            );
-            break;
-        case 7:
-            p = lib::make_shared<processor::hybi07<config> >(
-                transport_con_type::is_secure(),
-                m_is_server,
-                m_msg_manager,
-                lib::ref(m_rng)
-            );
-            break;
-        case 8:
-            p = lib::make_shared<processor::hybi08<config> >(
-                transport_con_type::is_secure(),
-                m_is_server,
-                m_msg_manager,
-                lib::ref(m_rng)
-            );
-            break;
-        case 13:
-            p = lib::make_shared<processor::hybi13<config> >(
-                transport_con_type::is_secure(),
-                m_is_server,
-                m_msg_manager,
-                lib::ref(m_rng)
-            );
-            break;
-        default:
-            return p;
-    }
-    
-    // Settings not configured by the constructor
-    p->set_max_message_size(m_max_message_size);
-    
-    return p;
-}
-
-template <typename config>
-void connection<config>::write_push(typename config::message_type::ptr msg)
-{
-    if (!msg) {
-        return;
-    }
-
-    m_send_buffer_size += msg->get_payload().size();
-    m_send_queue.push(msg);
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        std::stringstream s;
-        s << "write_push: message count: " << m_send_queue.size()
-          << " buffer size: " << m_send_buffer_size;
-        m_alog->write(log::alevel::devel,s.str());
-    }
-}
-
-template <typename config>
-typename config::message_type::ptr connection<config>::write_pop()
-{
-    message_ptr msg;
-
-    if (m_send_queue.empty()) {
-        return msg;
-    }
-
-    msg = m_send_queue.front();
-
-    m_send_buffer_size -= msg->get_payload().size();
-    m_send_queue.pop();
-
-    if (m_alog->static_test(log::alevel::devel)) {
-        std::stringstream s;
-        s << "write_pop: message count: " << m_send_queue.size()
-          << " buffer size: " << m_send_buffer_size;
-        m_alog->write(log::alevel::devel,s.str());
-    }
-    return msg;
-}
-
-template <typename config>
-void connection<config>::log_open_result()
-{
-    std::stringstream s;
-
-    int version;
-    if (!processor::is_websocket_handshake(m_request)) {
-        version = -1;
-    } else {
-        version = processor::get_websocket_version(m_request);
-    }
-
-    // Connection Type
-    s << (version == -1 ? "HTTP" : "WebSocket") << " Connection ";
-
-    // Remote endpoint address
-    s << transport_con_type::get_remote_endpoint() << " ";
-
-    // Version string if WebSocket
-    if (version != -1) {
-        s << "v" << version << " ";
-    }
-
-    // User Agent
-    std::string ua = m_request.get_header("User-Agent");
-    if (ua.empty()) {
-        s << "\"\" ";
-    } else {
-        // check if there are any quotes in the user agent
-        s << "\"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
-    }
-
-    // URI
-    s << (m_uri ? m_uri->get_resource() : "NULL") << " ";
-
-    // Status code
-    s << m_response.get_status_code();
-
-    m_alog->write(log::alevel::connect,s.str());
-}
-
-template <typename config>
-void connection<config>::log_close_result()
-{
-    std::stringstream s;
-
-    s << "Disconnect "
-      << "close local:[" << m_local_close_code
-      << (m_local_close_reason.empty() ? "" : ","+m_local_close_reason)
-      << "] remote:[" << m_remote_close_code
-      << (m_remote_close_reason.empty() ? "" : ","+m_remote_close_reason) << "]";
-
-    m_alog->write(log::alevel::disconnect,s.str());
-}
-
-template <typename config>
-void connection<config>::log_fail_result()
-{
-    std::stringstream s;
-    
-    int version = processor::get_websocket_version(m_request);
-
-    // Connection Type
-    s << "WebSocket Connection ";
-
-    // Remote endpoint address & WebSocket version
-    s << transport_con_type::get_remote_endpoint();
-    if (version < 0) {
-        s << " -";
-    } else {
-        s << " v" << version;
-    }
-
-    // User Agent
-    std::string ua = m_request.get_header("User-Agent");
-    if (ua.empty()) {
-        s << " \"\" ";
-    } else {
-        // check if there are any quotes in the user agent
-        s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
-    }
-
-    // URI
-    s << (m_uri ? m_uri->get_resource() : "-");
-
-    // HTTP Status code
-    s  << " " << m_response.get_status_code();
-    
-    // WebSocket++ error code & reason
-    s << " " << m_ec << " " << m_ec.message();
-
-    m_alog->write(log::alevel::fail,s.str());
-}
-
-template <typename config>
-void connection<config>::log_http_result() {
-    std::stringstream s;
-
-    if (processor::is_websocket_handshake(m_request)) {
-        m_alog->write(log::alevel::devel,"Call to log_http_result for WebSocket");
-        return;
-    }  
-
-    // Connection Type
-    s << (m_request.get_header("host").empty() ? "-" : m_request.get_header("host"))
-      << " " << transport_con_type::get_remote_endpoint()
-      << " \"" << m_request.get_method() 
-      << " " << (m_uri ? m_uri->get_resource() : "-") 
-      << " " << m_request.get_version() << "\" " << m_response.get_status_code()
-      << " " << m_response.get_body().size();
-    
-    // User Agent
-    std::string ua = m_request.get_header("User-Agent");
-    if (ua.empty()) {
-        s << " \"\" ";
-    } else {
-        // check if there are any quotes in the user agent
-        s << " \"" << utility::string_replace_all(ua,"\"","\\\"") << "\" ";
-    }
-
-    m_alog->write(log::alevel::http,s.str());
-}
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_CONNECTION_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/endpoint_impl.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/endpoint_impl.hpp
deleted file mode 100644
index 2aac1d9..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/endpoint_impl.hpp
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_ENDPOINT_IMPL_HPP
-#define WEBSOCKETPP_ENDPOINT_IMPL_HPP
-
-#include <string>
-
-namespace websocketpp {
-
-template <typename connection, typename config>
-typename endpoint<connection,config>::connection_ptr
-endpoint<connection,config>::create_connection() {
-    m_alog->write(log::alevel::devel,"create_connection");
-    //scoped_lock_type lock(m_state_lock);
-
-    /*if (m_state == STOPPING || m_state == STOPPED) {
-        return connection_ptr();
-    }*/
-
-    //scoped_lock_type guard(m_mutex);
-    // Create a connection on the heap and manage it using a shared pointer
-    connection_ptr con = lib::make_shared<connection_type>(m_is_server,
-        m_user_agent, m_alog, m_elog, lib::ref(m_rng));
-
-    connection_weak_ptr w(con);
-
-    // Create a weak pointer on the heap using that shared_ptr.
-    // Cast that weak pointer to void* and manage it using another shared_ptr
-    // connection_hdl hdl(reinterpret_cast<void*>(new connection_weak_ptr(con)));
-
-    con->set_handle(w);
-
-    // Copy default handlers from the endpoint
-    con->set_open_handler(m_open_handler);
-    con->set_close_handler(m_close_handler);
-    con->set_fail_handler(m_fail_handler);
-    con->set_ping_handler(m_ping_handler);
-    con->set_pong_handler(m_pong_handler);
-    con->set_pong_timeout_handler(m_pong_timeout_handler);
-    con->set_interrupt_handler(m_interrupt_handler);
-    con->set_http_handler(m_http_handler);
-    con->set_validate_handler(m_validate_handler);
-    con->set_message_handler(m_message_handler);
-
-    if (m_open_handshake_timeout_dur != config::timeout_open_handshake) {
-        con->set_open_handshake_timeout(m_open_handshake_timeout_dur);
-    }
-    if (m_close_handshake_timeout_dur != config::timeout_close_handshake) {
-        con->set_close_handshake_timeout(m_close_handshake_timeout_dur);
-    }
-    if (m_pong_timeout_dur != config::timeout_pong) {
-        con->set_pong_timeout(m_pong_timeout_dur);
-    }
-    if (m_max_message_size != config::max_message_size) {
-        con->set_max_message_size(m_max_message_size);
-    }
-    con->set_max_http_body_size(m_max_http_body_size);
-
-    lib::error_code ec;
-
-    ec = transport_type::init(con);
-    if (ec) {
-        m_elog->write(log::elevel::fatal,ec.message());
-        return connection_ptr();
-    }
-
-    return con;
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::interrupt(connection_hdl hdl, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-
-    m_alog->write(log::alevel::devel,"Interrupting connection");
-
-    ec = con->interrupt();
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::interrupt(connection_hdl hdl) {
-    lib::error_code ec;
-    interrupt(hdl,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::pause_reading(connection_hdl hdl, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-
-    ec = con->pause_reading();
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::pause_reading(connection_hdl hdl) {
-    lib::error_code ec;
-    pause_reading(hdl,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::resume_reading(connection_hdl hdl, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-
-    ec = con->resume_reading();
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::resume_reading(connection_hdl hdl) {
-    lib::error_code ec;
-    resume_reading(hdl,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send_http_response(connection_hdl hdl,
-    lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    con->send_http_response(ec);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send_http_response(connection_hdl hdl) {
-    lib::error_code ec;
-    send_http_response(hdl,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, std::string const & payload,
-    frame::opcode::value op, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-
-    ec = con->send(payload,op);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, std::string const & payload,
-    frame::opcode::value op)
-{
-    lib::error_code ec;
-    send(hdl,payload,op,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, void const * payload,
-    size_t len, frame::opcode::value op, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    ec = con->send(payload,len,op);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, void const * payload,
-    size_t len, frame::opcode::value op)
-{
-    lib::error_code ec;
-    send(hdl,payload,len,op,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, message_ptr msg,
-    lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    ec = con->send(msg);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::send(connection_hdl hdl, message_ptr msg) {
-    lib::error_code ec;
-    send(hdl,msg,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::close(connection_hdl hdl, close::status::value
-    const code, std::string const & reason,
-    lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    con->close(code,reason,ec);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::close(connection_hdl hdl, close::status::value
-    const code, std::string const & reason)
-{
-    lib::error_code ec;
-    close(hdl,code,reason,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::ping(connection_hdl hdl, std::string const &
-    payload, lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    con->ping(payload,ec);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::ping(connection_hdl hdl, std::string const & payload)
-{
-    lib::error_code ec;
-    ping(hdl,payload,ec);
-    if (ec) { throw exception(ec); }
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::pong(connection_hdl hdl, std::string const & payload,
-    lib::error_code & ec)
-{
-    connection_ptr con = get_con_from_hdl(hdl,ec);
-    if (ec) {return;}
-    con->pong(payload,ec);
-}
-
-template <typename connection, typename config>
-void endpoint<connection,config>::pong(connection_hdl hdl, std::string const & payload)
-{
-    lib::error_code ec;
-    pong(hdl,payload,ec);
-    if (ec) { throw exception(ec); }
-}
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_ENDPOINT_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/utilities_impl.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/utilities_impl.hpp
deleted file mode 100644
index 6f86e22..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/impl/utilities_impl.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_UTILITIES_IMPL_HPP
-#define WEBSOCKETPP_UTILITIES_IMPL_HPP
-
-#include <algorithm>
-#include <string>
-
-namespace websocketpp {
-namespace utility {
-
-inline std::string to_lower(std::string const & in) {
-    std::string out = in;
-    std::transform(out.begin(),out.end(),out.begin(),::tolower);
-    return out;
-}
-
-inline std::string to_hex(std::string const & input) {
-    std::string output;
-    std::string hex = "0123456789ABCDEF";
-
-    for (size_t i = 0; i < input.size(); i++) {
-        output += hex[(input[i] & 0xF0) >> 4];
-        output += hex[input[i] & 0x0F];
-        output += " ";
-    }
-
-    return output;
-}
-
-inline std::string to_hex(uint8_t const * input, size_t length) {
-    std::string output;
-    std::string hex = "0123456789ABCDEF";
-
-    for (size_t i = 0; i < length; i++) {
-        output += hex[(input[i] & 0xF0) >> 4];
-        output += hex[input[i] & 0x0F];
-        output += " ";
-    }
-
-    return output;
-}
-
-inline std::string to_hex(const char* input,size_t length) {
-    return to_hex(reinterpret_cast<const uint8_t*>(input),length);
-}
-
-inline std::string string_replace_all(std::string subject, std::string const &
-    search, std::string const & replace)
-{
-    size_t pos = 0;
-    while((pos = subject.find(search, pos)) != std::string::npos) {
-         subject.replace(pos, search.length(), replace);
-         pos += replace.length();
-    }
-    return subject;
-}
-
-} // namespace utility
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_UTILITIES_IMPL_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/basic.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/basic.hpp
deleted file mode 100644
index 8451413..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/basic.hpp
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_LOGGER_BASIC_HPP
-#define WEBSOCKETPP_LOGGER_BASIC_HPP
-
-/* Need a way to print a message to the log
- *
- * - timestamps
- * - channels
- * - thread safe
- * - output to stdout or file
- * - selective output channels, both compile time and runtime
- * - named channels
- * - ability to test whether a log message will be printed at compile time
- *
- */
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/stdint.hpp>
-#include <websocketpp/common/time.hpp>
-
-#include <ctime>
-#include <iostream>
-#include <iomanip>
-#include <string>
-
-namespace websocketpp {
-namespace log {
-
-/// Basic logger that outputs to an ostream
-template <typename concurrency, typename names>
-class basic {
-public:
-    basic<concurrency,names>(channel_type_hint::value h =
-        channel_type_hint::access)
-      : m_static_channels(0xffffffff)
-      , m_dynamic_channels(0)
-      , m_out(h == channel_type_hint::error ? &std::cerr : &std::cout) {}
-
-    basic<concurrency,names>(std::ostream * out)
-      : m_static_channels(0xffffffff)
-      , m_dynamic_channels(0)
-      , m_out(out) {}
-
-    basic<concurrency,names>(level c, channel_type_hint::value h =
-        channel_type_hint::access)
-      : m_static_channels(c)
-      , m_dynamic_channels(0)
-      , m_out(h == channel_type_hint::error ? &std::cerr : &std::cout) {}
-
-    basic<concurrency,names>(level c, std::ostream * out)
-      : m_static_channels(c)
-      , m_dynamic_channels(0)
-      , m_out(out) {}
-
-    /// Destructor
-    ~basic<concurrency,names>() {}
-
-    /// Copy constructor
-    basic<concurrency,names>(basic<concurrency,names> const & other)
-     : m_static_channels(other.m_static_channels)
-     , m_dynamic_channels(other.m_dynamic_channels)
-     , m_out(other.m_out)
-    {}
-    
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    // no copy assignment operator because of const member variables
-    basic<concurrency,names> & operator=(basic<concurrency,names> const &) = delete;
-#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-    /// Move constructor
-    basic<concurrency,names>(basic<concurrency,names> && other)
-     : m_static_channels(other.m_static_channels)
-     , m_dynamic_channels(other.m_dynamic_channels)
-     , m_out(other.m_out)
-    {}
-
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    // no move assignment operator because of const member variables
-    basic<concurrency,names> & operator=(basic<concurrency,names> &&) = delete;
-#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
-
-    void set_ostream(std::ostream * out = &std::cout) {
-        m_out = out;
-    }
-
-    void set_channels(level channels) {
-        if (channels == names::none) {
-            clear_channels(names::all);
-            return;
-        }
-
-        scoped_lock_type lock(m_lock);
-        m_dynamic_channels |= (channels & m_static_channels);
-    }
-
-    void clear_channels(level channels) {
-        scoped_lock_type lock(m_lock);
-        m_dynamic_channels &= ~channels;
-    }
-
-    /// Write a string message to the given channel
-    /**
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level channel, std::string const & msg) {
-        scoped_lock_type lock(m_lock);
-        if (!this->dynamic_test(channel)) { return; }
-        *m_out << "[" << timestamp << "] "
-                  << "[" << names::channel_name(channel) << "] "
-                  << msg << "\n";
-        m_out->flush();
-    }
-
-    /// Write a cstring message to the given channel
-    /**
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level channel, char const * msg) {
-        scoped_lock_type lock(m_lock);
-        if (!this->dynamic_test(channel)) { return; }
-        *m_out << "[" << timestamp << "] "
-                  << "[" << names::channel_name(channel) << "] "
-                  << msg << "\n";
-        m_out->flush();
-    }
-
-    _WEBSOCKETPP_CONSTEXPR_TOKEN_ bool static_test(level channel) const {
-        return ((channel & m_static_channels) != 0);
-    }
-
-    bool dynamic_test(level channel) {
-        return ((channel & m_dynamic_channels) != 0);
-    }
-
-protected:
-    typedef typename concurrency::scoped_lock_type scoped_lock_type;
-    typedef typename concurrency::mutex_type mutex_type;
-    mutex_type m_lock;
-
-private:
-    // The timestamp does not include the time zone, because on Windows with the
-    // default registry settings, the time zone would be written out in full,
-    // which would be obnoxiously verbose.
-    //
-    // TODO: find a workaround for this or make this format user settable
-    static std::ostream & timestamp(std::ostream & os) {
-        std::time_t t = std::time(NULL);
-        std::tm lt = lib::localtime(t);
-        #ifdef _WEBSOCKETPP_PUTTIME_
-            return os << std::put_time(&lt,"%Y-%m-%d %H:%M:%S");
-        #else // Falls back to strftime, which requires a temporary copy of the string.
-            char buffer[20];
-            size_t result = std::strftime(buffer,sizeof(buffer),"%Y-%m-%d %H:%M:%S",&lt);
-            return os << (result == 0 ? "Unknown" : buffer);
-        #endif
-    }
-
-    level const m_static_channels;
-    level m_dynamic_channels;
-    std::ostream * m_out;
-};
-
-} // log
-} // websocketpp
-
-#endif // WEBSOCKETPP_LOGGER_BASIC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/levels.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/levels.hpp
deleted file mode 100644
index cd7ccd6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/levels.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_LOGGER_LEVELS_HPP
-#define WEBSOCKETPP_LOGGER_LEVELS_HPP
-
-#include <websocketpp/common/stdint.hpp>
-
-namespace websocketpp {
-namespace log {
-
-/// Type of a channel package
-typedef uint32_t level;
-
-/// Package of values for hinting at the nature of a given logger.
-/**
- * Used by the library to signal to the logging class a hint that it can use to
- * set itself up. For example, the `access` hint indicates that it is an access
- * log that might be suitable for being printed to an access log file or to cout
- * whereas `error` might be suitable for an error log file or cerr. 
- */
-struct channel_type_hint {
-    /// Type of a channel type hint value
-    typedef uint32_t value;
-    
-    /// No information
-    static value const none = 0;
-    /// Access log
-    static value const access = 1;
-    /// Error log
-    static value const error = 2;
-};
-
-/// Package of log levels for logging errors
-struct elevel {
-    /// Special aggregate value representing "no levels"
-    static level const none = 0x0;
-    /// Low level debugging information (warning: very chatty)
-    static level const devel = 0x1;
-    /// Information about unusual system states or other minor internal library
-    /// problems, less chatty than devel.
-    static level const library = 0x2;
-    /// Information about minor configuration problems or additional information
-    /// about other warnings.
-    static level const info = 0x4;
-    /// Information about important problems not severe enough to terminate
-    /// connections.
-    static level const warn = 0x8;
-    /// Recoverable error. Recovery may mean cleanly closing the connection with
-    /// an appropriate error code to the remote endpoint.
-    static level const rerror = 0x10;
-    /// Unrecoverable error. This error will trigger immediate unclean
-    /// termination of the connection or endpoint.
-    static level const fatal = 0x20;
-    /// Special aggregate value representing "all levels"
-    static level const all = 0xffffffff;
-
-    /// Get the textual name of a channel given a channel id
-    /**
-     * The id must be that of a single channel. Passing an aggregate channel
-     * package results in undefined behavior.
-     *
-     * @param channel The channel id to look up.
-     *
-     * @return The name of the specified channel.
-     */
-    static char const * channel_name(level channel) {
-        switch(channel) {
-            case devel:
-                return "devel";
-            case library:
-                return "library";
-            case info:
-                return "info";
-            case warn:
-                return "warning";
-            case rerror:
-                return "error";
-            case fatal:
-                return "fatal";
-            default:
-                return "unknown";
-        }
-    }
-};
-
-/// Package of log levels for logging access events
-struct alevel {
-    /// Special aggregate value representing "no levels"
-    static level const none = 0x0;
-    /// Information about new connections
-    /**
-     * One line for each new connection that includes a host of information
-     * including: the remote address, websocket version, requested resource,
-     * http code, remote user agent
-     */
-    static level const connect = 0x1;
-    /// One line for each closed connection. Includes closing codes and reasons.
-    static level const disconnect = 0x2;
-    /// One line per control frame
-    static level const control = 0x4;
-    /// One line per frame, includes the full frame header
-    static level const frame_header = 0x8;
-    /// One line per frame, includes the full message payload (warning: chatty)
-    static level const frame_payload = 0x10;
-    /// Reserved
-    static level const message_header = 0x20;
-    /// Reserved
-    static level const message_payload = 0x40;
-    /// Reserved
-    static level const endpoint = 0x80;
-    /// Extra information about opening handshakes
-    static level const debug_handshake = 0x100;
-    /// Extra information about closing handshakes
-    static level const debug_close = 0x200;
-    /// Development messages (warning: very chatty)
-    static level const devel = 0x400;
-    /// Special channel for application specific logs. Not used by the library.
-    static level const app = 0x800;
-    /// Access related to HTTP requests
-    static level const http = 0x1000;
-    /// One line for each failed WebSocket connection with details
-    static level const fail = 0x2000;
-    /// Aggregate package representing the commonly used core access channels
-    /// Connect, Disconnect, Fail, and HTTP
-    static level const access_core = 0x00003003;
-    /// Special aggregate value representing "all levels"
-    static level const all = 0xffffffff;
-
-    /// Get the textual name of a channel given a channel id
-    /**
-     * Get the textual name of a channel given a channel id. The id must be that
-     * of a single channel. Passing an aggregate channel package results in
-     * undefined behavior.
-     *
-     * @param channel The channelid to look up.
-     *
-     * @return The name of the specified channel.
-     */
-    static char const * channel_name(level channel) {
-        switch(channel) {
-            case connect:
-                return "connect";
-            case disconnect:
-                return "disconnect";
-            case control:
-                return "control";
-            case frame_header:
-                return "frame_header";
-            case frame_payload:
-                return "frame_payload";
-            case message_header:
-                return "message_header";
-            case message_payload:
-                return "message_payload";
-            case endpoint:
-                return "endpoint";
-            case debug_handshake:
-                return "debug_handshake";
-            case debug_close:
-                return "debug_close";
-            case devel:
-                return "devel";
-            case app:
-                return "application";
-            case http:
-                return "http";
-            case fail:
-                return "fail";
-            default:
-                return "unknown";
-        }
-    }
-};
-
-} // logger
-} // websocketpp
-
-#endif //WEBSOCKETPP_LOGGER_LEVELS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/stub.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/stub.hpp
deleted file mode 100644
index 2db6da7..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/stub.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_LOGGER_STUB_HPP
-#define WEBSOCKETPP_LOGGER_STUB_HPP
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/cpp11.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace log {
-
-/// Stub logger that ignores all input
-class stub {
-public:
-    /// Construct the logger
-    /**
-     * @param hint A channel type specific hint for how to construct the logger
-     */
-    explicit stub(channel_type_hint::value) {}
-
-    /// Construct the logger
-    /**
-     * @param default_channels A set of channels to statically enable
-     * @param hint A channel type specific hint for how to construct the logger
-     */
-    stub(level, channel_type_hint::value) {}
-    _WEBSOCKETPP_CONSTEXPR_TOKEN_ stub() {}
-
-    /// Dynamically enable the given list of channels
-    /**
-     * All operations on the stub logger are no-ops and all arguments are
-     * ignored
-     *
-     * @param channels The package of channels to enable
-     */
-    void set_channels(level) {}
-
-    /// Dynamically disable the given list of channels
-    /**
-     * All operations on the stub logger are no-ops and all arguments are
-     * ignored
-     *
-     * @param channels The package of channels to disable
-     */
-    void clear_channels(level) {}
-
-    /// Write a string message to the given channel
-    /**
-     * Writing on the stub logger is a no-op and all arguments are ignored
-     *
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level, std::string const &) {}
-
-    /// Write a cstring message to the given channel
-    /**
-     * Writing on the stub logger is a no-op and all arguments are ignored
-     *
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level, char const *) {}
-
-    /// Test whether a channel is statically enabled
-    /**
-     * The stub logger has no channels so all arguments are ignored and
-     * `static_test` always returns false.
-     *
-     * @param channel The package of channels to test
-     */
-    _WEBSOCKETPP_CONSTEXPR_TOKEN_ bool static_test(level) const {
-        return false;
-    }
-
-    /// Test whether a channel is dynamically enabled
-    /**
-     * The stub logger has no channels so all arguments are ignored and
-     * `dynamic_test` always returns false.
-     *
-     * @param channel The package of channels to test
-     */
-    bool dynamic_test(level) {
-        return false;
-    }
-};
-
-} // log
-} // websocketpp
-
-#endif // WEBSOCKETPP_LOGGER_STUB_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/syslog.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/syslog.hpp
deleted file mode 100644
index 513abee..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/logger/syslog.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- *
- * The initial version of this logging policy was contributed to the WebSocket++
- * project by Tom Hughes.
- */
-
-#ifndef WEBSOCKETPP_LOGGER_SYSLOG_HPP
-#define WEBSOCKETPP_LOGGER_SYSLOG_HPP
-
-#include <syslog.h>
-
-#include <websocketpp/logger/basic.hpp>
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-namespace websocketpp {
-namespace log {
-
-/// Basic logger that outputs to syslog
-template <typename concurrency, typename names>
-class syslog : public basic<concurrency, names> {
-public:
-    typedef basic<concurrency, names> base;
-
-    /// Construct the logger
-    /**
-     * @param hint A channel type specific hint for how to construct the logger
-     */
-    syslog<concurrency,names>(channel_type_hint::value hint =
-        channel_type_hint::access)
-      : basic<concurrency,names>(hint), m_channel_type_hint(hint) {}
-
-    /// Construct the logger
-    /**
-     * @param channels A set of channels to statically enable
-     * @param hint A channel type specific hint for how to construct the logger
-     */
-    syslog<concurrency,names>(level channels, channel_type_hint::value hint =
-        channel_type_hint::access)
-      : basic<concurrency,names>(channels, hint), m_channel_type_hint(hint) {}
-
-    /// Write a string message to the given channel
-    /**
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level channel, std::string const & msg) {
-        write(channel, msg.c_str());
-    }
-
-    /// Write a cstring message to the given channel
-    /**
-     * @param channel The channel to write to
-     * @param msg The message to write
-     */
-    void write(level channel, char const * msg) {
-        scoped_lock_type lock(base::m_lock);
-        if (!this->dynamic_test(channel)) { return; }
-        ::syslog(syslog_priority(channel), "[%s] %s",
-            names::channel_name(channel), msg);
-    }
-private:
-    typedef typename base::scoped_lock_type scoped_lock_type;
-
-    /// The default level is used for all access logs and any error logs that
-    /// don't trivially map to one of the standard syslog levels.
-    static int const default_level = LOG_INFO;
-
-    /// retrieve the syslog priority code given a WebSocket++ channel
-    /**
-     * @param channel The level to look up
-     * @return The syslog level associated with `channel`
-     */
-    int syslog_priority(level channel) const {
-        if (m_channel_type_hint == channel_type_hint::access) {
-            return syslog_priority_access(channel);
-        } else {
-            return syslog_priority_error(channel);
-        }
-    }
-
-    /// retrieve the syslog priority code given a WebSocket++ error channel
-    /**
-     * @param channel The level to look up
-     * @return The syslog level associated with `channel`
-     */
-    int syslog_priority_error(level channel) const {
-        switch (channel) {
-            case elevel::devel:
-                return LOG_DEBUG;
-            case elevel::library:
-                return LOG_DEBUG;
-            case elevel::info:
-                return LOG_INFO;
-            case elevel::warn:
-                return LOG_WARNING;
-            case elevel::rerror:
-                return LOG_ERR;
-            case elevel::fatal:
-                return LOG_CRIT;
-            default:
-                return default_level;
-        }
-    }
-
-    /// retrieve the syslog priority code given a WebSocket++ access channel
-    /**
-     * @param channel The level to look up
-     * @return The syslog level associated with `channel`
-     */
-    _WEBSOCKETPP_CONSTEXPR_TOKEN_ int syslog_priority_access(level) const {
-        return default_level;
-    }
-
-    channel_type_hint::value m_channel_type_hint;
-};
-
-} // log
-} // websocketpp
-
-#endif // WEBSOCKETPP_LOGGER_SYSLOG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/alloc.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/alloc.hpp
deleted file mode 100644
index 75d8976..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/alloc.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
-#define WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/frame.hpp>
-
-namespace websocketpp {
-namespace message_buffer {
-namespace alloc {
-
-/// A connection message manager that allocates a new message for each
-/// request.
-template <typename message>
-class con_msg_manager
-  : public lib::enable_shared_from_this<con_msg_manager<message> >
-{
-public:
-    typedef con_msg_manager<message> type;
-    typedef lib::shared_ptr<con_msg_manager> ptr;
-    typedef lib::weak_ptr<con_msg_manager> weak_ptr;
-
-    typedef typename message::ptr message_ptr;
-
-    /// Get an empty message buffer
-    /**
-     * @return A shared pointer to an empty new message
-     */
-    message_ptr get_message() {
-        return message_ptr(lib::make_shared<message>(type::shared_from_this()));
-    }
-
-    /// Get a message buffer with specified size and opcode
-    /**
-     * @param op The opcode to use
-     * @param size Minimum size in bytes to request for the message payload.
-     *
-     * @return A shared pointer to a new message with specified size.
-     */
-    message_ptr get_message(frame::opcode::value op,size_t size) {
-        return message_ptr(lib::make_shared<message>(type::shared_from_this(),op,size));
-    }
-
-    /// Recycle a message
-    /**
-     * This method shouldn't be called. If it is, return false to indicate an
-     * error. The rest of the method recycle chain should notice this and free
-     * the memory.
-     *
-     * @param msg The message to be recycled.
-     *
-     * @return true if the message was successfully recycled, false otherwse.
-     */
-    bool recycle(message *) {
-        return false;
-    }
-};
-
-/// An endpoint message manager that allocates a new manager for each
-/// connection.
-template <typename con_msg_manager>
-class endpoint_msg_manager {
-public:
-    typedef typename con_msg_manager::ptr con_msg_man_ptr;
-
-    /// Get a pointer to a connection message manager
-    /**
-     * @return A pointer to the requested connection message manager.
-     */
-    con_msg_man_ptr get_manager() const {
-        return con_msg_man_ptr(lib::make_shared<con_msg_manager>());
-    }
-};
-
-} // namespace alloc
-} // namespace message_buffer
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/message.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/message.hpp
deleted file mode 100644
index da36e20..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/message.hpp
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_MESSAGE_BUFFER_MESSAGE_HPP
-#define WEBSOCKETPP_MESSAGE_BUFFER_MESSAGE_HPP
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/frame.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace message_buffer {
-
-/* # message:
- * object that stores a message while it is being sent or received. Contains
- * the message payload itself, the message header, the extension data, and the
- * opcode.
- *
- * # connection_message_manager:
- * An object that manages all of the message_buffers associated with a given
- * connection. Implements the get_message_buffer(size) method that returns
- * a message buffer at least size bytes long.
- *
- * Message buffers are reference counted with shared ownership semantics. Once
- * requested from the manager the requester and it's associated downstream code
- * may keep a pointer to the message indefinitely at a cost of extra resource
- * usage. Once the reference count drops to the point where the manager is the
- * only reference the messages is recycled using whatever method is implemented
- * in the manager.
- *
- * # endpoint_message_manager:
- * An object that manages connection_message_managers. Implements the
- * get_message_manager() method. This is used once by each connection to
- * request the message manager that they are supposed to use to manage message
- * buffers for their own use.
- *
- * TYPES OF CONNECTION_MESSAGE_MANAGERS
- * - allocate a message with the exact size every time one is requested
- * - maintain a pool of pre-allocated messages and return one when needed.
- *   Recycle previously used messages back into the pool
- *
- * TYPES OF ENDPOINT_MESSAGE_MANAGERS
- *  - allocate a new connection manager for each connection. Message pools
- *    become connection specific. This increases memory usage but improves
- *    concurrency.
- *  - allocate a single connection manager and share a pointer to it with all
- *    connections created by this endpoint. The message pool will be shared
- *    among all connections, improving memory usage and performance at the cost
- *    of reduced concurrency
- */
-
-
-/// Represents a buffer for a single WebSocket message.
-/**
- *
- *
- */
-template <template<class> class con_msg_manager>
-class message {
-public:
-    typedef lib::shared_ptr<message> ptr;
-
-    typedef con_msg_manager<message> con_msg_man_type;
-    typedef typename con_msg_man_type::ptr con_msg_man_ptr;
-    typedef typename con_msg_man_type::weak_ptr con_msg_man_weak_ptr;
-
-    /// Construct an empty message
-    /**
-     * Construct an empty message
-     */
-    message(const con_msg_man_ptr manager)
-      : m_manager(manager)
-      , m_prepared(false)
-      , m_fin(true)
-      , m_terminal(false)
-      , m_compressed(false) {}
-
-    /// Construct a message and fill in some values
-    /**
-     *
-     */
-    message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size = 128)
-      : m_manager(manager)
-      , m_opcode(op)
-      , m_prepared(false)
-      , m_fin(true)
-      , m_terminal(false)
-      , m_compressed(false)
-    {
-        m_payload.reserve(size);
-    }
-
-    /// Return whether or not the message has been prepared for sending
-    /**
-     * The prepared flag indicates that the message has been prepared by a
-     * websocket protocol processor and is ready to be written to the wire.
-     *
-     * @return whether or not the message has been prepared for sending
-     */
-    bool get_prepared() const {
-        return m_prepared;
-    }
-
-    /// Set or clear the flag that indicates that the message has been prepared
-    /**
-     * This flag should not be set by end user code without a very good reason.
-     *
-     * @param value The value to set the prepared flag to
-     */
-    void set_prepared(bool value) {
-        m_prepared = value;
-    }
-
-    /// Return whether or not the message is flagged as compressed
-    /**
-     * @return whether or not the message is/should be compressed
-     */
-    bool get_compressed() const {
-        return m_compressed;
-    }
-
-    /// Set or clear the compression flag
-    /**
-     * Setting the compression flag indicates that the data in this message
-     * would benefit from compression. If both endpoints negotiate a compression
-     * extension WebSocket++ will attempt to compress messages with this flag.
-     * Setting this flag does not guarantee that the message will be compressed.
-     *
-     * @param value The value to set the compressed flag to
-     */
-    void set_compressed(bool value) {
-        m_compressed = value;
-    }
-
-    /// Get whether or not the message is terminal
-    /**
-     * Messages can be flagged as terminal, which results in the connection
-     * being close after they are written rather than the implementation going
-     * on to the next message in the queue. This is typically used internally
-     * for close messages only.
-     *
-     * @return Whether or not this message is marked terminal
-     */
-    bool get_terminal() const {
-        return m_terminal;
-    }
-
-    /// Set the terminal flag
-    /**
-     * This flag should not be set by end user code without a very good reason.
-     *
-     * @see get_terminal()
-     *
-     * @param value The value to set the terminal flag to.
-     */
-    void set_terminal(bool value) {
-        m_terminal = value;
-    }
-    /// Read the fin bit
-    /**
-     * A message with the fin bit set will be sent as the last message of its
-     * sequence. A message with the fin bit cleared will require subsequent
-     * frames of opcode continuation until one of them has the fin bit set.
-     *
-     * The remote end likely will not deliver any bytes until the frame with the fin
-     * bit set has been received.
-     *
-     * @return Whether or not the fin bit is set
-     */
-    bool get_fin() const {
-        return m_fin;
-    }
-
-    /// Set the fin bit
-    /**
-     * @see get_fin for a more detailed explaination of the fin bit
-     *
-     * @param value The value to set the fin bit to.
-     */
-    void set_fin(bool value) {
-        m_fin = value;
-    }
-
-    /// Return the message opcode
-    frame::opcode::value get_opcode() const {
-        return m_opcode;
-    }
-
-    /// Set the opcode
-    void set_opcode(frame::opcode::value op) {
-        m_opcode = op;
-    }
-
-    /// Return the prepared frame header
-    /**
-     * This value is typically set by a websocket protocol processor
-     * and shouldn't be tampered with.
-     */
-    std::string const & get_header() const {
-        return m_header;
-    }
-
-    /// Set prepared frame header
-    /**
-     * Under normal circumstances this should not be called by end users
-     *
-     * @param header A string to set the header to.
-     */
-    void set_header(std::string const & header) {
-        m_header = header;
-    }
-
-    std::string const & get_extension_data() const {
-        return m_extension_data;
-    }
-
-    /// Get a reference to the payload string
-    /**
-     * @return A const reference to the message's payload string
-     */
-    std::string const & get_payload() const {
-        return m_payload;
-    }
-
-    /// Get a non-const reference to the payload string
-    /**
-     * @return A reference to the message's payload string
-     */
-    std::string & get_raw_payload() {
-        return m_payload;
-    }
-
-    /// Set payload data
-    /**
-     * Set the message buffer's payload to the given value.
-     *
-     * @param payload A string to set the payload to.
-     */
-    void set_payload(std::string const & payload) {
-        m_payload = payload;
-    }
-
-    /// Set payload data
-    /**
-     * Set the message buffer's payload to the given value.
-     *
-     * @param payload A pointer to a data array to set to.
-     * @param len The length of new payload in bytes.
-     */
-    void set_payload(void const * payload, size_t len) {
-        m_payload.reserve(len);
-        char const * pl = static_cast<char const *>(payload);
-        m_payload.assign(pl, pl + len);
-    }
-
-    /// Append payload data
-    /**
-     * Append data to the message buffer's payload.
-     *
-     * @param payload A string containing the data array to append.
-     */
-    void append_payload(std::string const & payload) {
-        m_payload.append(payload);
-    }
-
-    /// Append payload data
-    /**
-     * Append data to the message buffer's payload.
-     *
-     * @param payload A pointer to a data array to append
-     * @param len The length of payload in bytes
-     */
-    void append_payload(void const * payload, size_t len) {
-        m_payload.reserve(m_payload.size()+len);
-        m_payload.append(static_cast<char const *>(payload),len);
-    }
-
-    /// Recycle the message
-    /**
-     * A request to recycle this message was received. Forward that request to
-     * the connection message manager for processing. Errors and exceptions
-     * from the manager's recycle member function should be passed back up the
-     * call chain. The caller to message::recycle will deal with them.
-     *
-     * Recycle must *only* be called by the message shared_ptr's destructor.
-     * Once recycled successfully, ownership of the memory has been passed to
-     * another system and must not be accessed again.
-     *
-     * @return true if the message was successfully recycled, false otherwise.
-     */
-    bool recycle() {
-        con_msg_man_ptr shared = m_manager.lock();
-
-        if (shared) {
-            return shared->recycle(this);
-        } else {
-            return false;
-        }
-    }
-private:
-    con_msg_man_weak_ptr        m_manager;
-    std::string                 m_header;
-    std::string                 m_extension_data;
-    std::string                 m_payload;
-    frame::opcode::value        m_opcode;
-    bool                        m_prepared;
-    bool                        m_fin;
-    bool                        m_terminal;
-    bool                        m_compressed;
-};
-
-} // namespace message_buffer
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_MESSAGE_BUFFER_MESSAGE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/pool.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/pool.hpp
deleted file mode 100644
index 3af9e02..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/message_buffer/pool.hpp
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
-#define WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
-
-#include <websocketpp/common/memory.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace message_buffer {
-
-/* # message:
- * object that stores a message while it is being sent or received. Contains
- * the message payload itself, the message header, the extension data, and the
- * opcode.
- *
- * # connection_message_manager:
- * An object that manages all of the message_buffers associated with a given
- * connection. Implements the get_message_buffer(size) method that returns
- * a message buffer at least size bytes long.
- *
- * Message buffers are reference counted with shared ownership semantics. Once
- * requested from the manager the requester and it's associated downstream code
- * may keep a pointer to the message indefinitely at a cost of extra resource
- * usage. Once the reference count drops to the point where the manager is the
- * only reference the messages is recycled using whatever method is implemented
- * in the manager.
- *
- * # endpoint_message_manager:
- * An object that manages connection_message_managers. Implements the
- * get_message_manager() method. This is used once by each connection to
- * request the message manager that they are supposed to use to manage message
- * buffers for their own use.
- *
- * TYPES OF CONNECTION_MESSAGE_MANAGERS
- * - allocate a message with the exact size every time one is requested
- * - maintain a pool of pre-allocated messages and return one when needed.
- *   Recycle previously used messages back into the pool
- *
- * TYPES OF ENDPOINT_MESSAGE_MANAGERS
- *  - allocate a new connection manager for each connection. Message pools
- *    become connection specific. This increases memory usage but improves
- *    concurrency.
- *  - allocate a single connection manager and share a pointer to it with all
- *    connections created by this endpoint. The message pool will be shared
- *    among all connections, improving memory usage and performance at the cost
- *    of reduced concurrency
- */
-
-/// Custom deleter for use in shared_ptrs to message.
-/**
- * This is used to catch messages about to be deleted and offer the manager the
- * ability to recycle them instead. Message::recycle will return true if it was
- * successfully recycled and false otherwise. In the case of exceptions or error
- * this deleter frees the memory.
- */
-template <typename T>
-void message_deleter(T* msg) {
-    try {
-        if (!msg->recycle()) {
-            delete msg;
-        }
-    } catch (...) {
-        // TODO: is there a better way to ensure this function doesn't throw?
-        delete msg;
-    }
-}
-
-/// Represents a buffer for a single WebSocket message.
-/**
- *
- *
- */
-template <typename con_msg_manager>
-class message {
-public:
-    typedef lib::shared_ptr<message> ptr;
-
-    typedef typename con_msg_manager::weak_ptr con_msg_man_ptr;
-
-    message(con_msg_man_ptr manager, size_t size = 128)
-      : m_manager(manager)
-      , m_payload(size) {}
-
-    frame::opcode::value get_opcode() const {
-        return m_opcode;
-    }
-    const std::string& get_header() const {
-        return m_header;
-    }
-    const std::string& get_extension_data() const {
-        return m_extension_data;
-    }
-    const std::string& get_payload() const {
-        return m_payload;
-    }
-
-    /// Recycle the message
-    /**
-     * A request to recycle this message was received. Forward that request to
-     * the connection message manager for processing. Errors and exceptions
-     * from the manager's recycle member function should be passed back up the
-     * call chain. The caller to message::recycle will deal with them.
-     *
-     * Recycle must *only* be called by the message shared_ptr's destructor.
-     * Once recycled successfully, ownership of the memory has been passed to
-     * another system and must not be accessed again.
-     *
-     * @return true if the message was successfully recycled, false otherwise.
-     */
-    bool recycle() {
-        typename con_msg_manager::ptr shared = m_manager.lock();
-
-        if (shared) {
-            return shared->(recycle(this));
-        } else {
-            return false;
-        }
-    }
-private:
-    con_msg_man_ptr             m_manager;
-
-    frame::opcode::value        m_opcode;
-    std::string                 m_header;
-    std::string                 m_extension_data;
-    std::string                 m_payload;
-};
-
-namespace alloc {
-
-/// A connection message manager that allocates a new message for each
-/// request.
-template <typename message>
-class con_msg_manager {
-public:
-    typedef lib::shared_ptr<con_msg_manager> ptr;
-    typedef lib::weak_ptr<con_msg_manager> weak_ptr;
-
-    typedef typename message::ptr message_ptr;
-
-    /// Get a message buffer with specified size
-    /**
-     * @param size Minimum size in bytes to request for the message payload.
-     *
-     * @return A shared pointer to a new message with specified size.
-     */
-    message_ptr get_message(size_t size) const {
-        return lib::make_shared<message>(size);
-    }
-
-    /// Recycle a message
-    /**
-     * This method shouldn't be called. If it is, return false to indicate an
-     * error. The rest of the method recycle chain should notice this and free
-     * the memory.
-     *
-     * @param msg The message to be recycled.
-     *
-     * @return true if the message was successfully recycled, false otherwse.
-     */
-    bool recycle(message * msg) {
-        return false;
-    }
-};
-
-/// An endpoint message manager that allocates a new manager for each
-/// connection.
-template <typename con_msg_manager>
-class endpoint_msg_manager {
-public:
-    typedef typename con_msg_manager::ptr con_msg_man_ptr;
-
-    /// Get a pointer to a connection message manager
-    /**
-     * @return A pointer to the requested connection message manager.
-     */
-    con_msg_man_ptr get_manager() const {
-        return lib::make_shared<con_msg_manager>();
-    }
-};
-
-} // namespace alloc
-
-namespace pool {
-
-/// A connection messages manager that maintains a pool of messages that is
-/// used to fulfill get_message requests.
-class con_msg_manager {
-
-};
-
-/// An endpoint manager that maintains a shared pool of connection managers
-/// and returns an appropriate one for the requesting connection.
-class endpoint_msg_manager {
-
-};
-
-} // namespace pool
-
-} // namespace message_buffer
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_MESSAGE_BUFFER_ALLOC_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/base.hpp
deleted file mode 100644
index 4c123df..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/base.hpp
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_BASE_HPP
-#define WEBSOCKETPP_PROCESSOR_BASE_HPP
-
-#include <websocketpp/close.hpp>
-#include <websocketpp/utilities.hpp>
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace processor {
-
-/// Constants related to processing WebSocket connections
-namespace constants {
-
-static char const upgrade_token[] = "websocket";
-static char const connection_token[] = "Upgrade";
-static char const handshake_guid[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-
-} // namespace constants
-
-
-/// Processor class related error codes
-namespace error_cat {
-enum value {
-    BAD_REQUEST = 0, // Error was the result of improperly formatted user input
-    INTERNAL_ERROR = 1, // Error was a logic error internal to WebSocket++
-    PROTOCOL_VIOLATION = 2,
-    MESSAGE_TOO_BIG = 3,
-    PAYLOAD_VIOLATION = 4 // Error was due to receiving invalid payload data
-};
-} // namespace error_cat
-
-/// Error code category and codes used by all processor types
-namespace error {
-enum processor_errors {
-    /// Catch-all error for processor policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// Error was the result of improperly formatted user input
-    bad_request,
-
-    /// Processor encountered a protocol violation in an incoming message
-    protocol_violation,
-
-    /// Processor encountered a message that was too large
-    message_too_big,
-
-    /// Processor encountered invalid payload data.
-    invalid_payload,
-
-    /// The processor method was called with invalid arguments
-    invalid_arguments,
-
-    /// Opcode was invalid for requested operation
-    invalid_opcode,
-
-    /// Control frame too large
-    control_too_big,
-
-    /// Illegal use of reserved bit
-    invalid_rsv_bit,
-
-    /// Fragmented control message
-    fragmented_control,
-
-    /// Continuation without message
-    invalid_continuation,
-
-    /// Clients may not send unmasked frames
-    masking_required,
-
-    /// Servers may not send masked frames
-    masking_forbidden,
-
-    /// Payload length not minimally encoded
-    non_minimal_encoding,
-
-    /// Not supported on 32 bit systems
-    requires_64bit,
-
-    /// Invalid UTF-8 encoding
-    invalid_utf8,
-
-    /// Operation required not implemented functionality
-    not_implemented,
-
-    /// Invalid HTTP method
-    invalid_http_method,
-
-    /// Invalid HTTP version
-    invalid_http_version,
-
-    /// Invalid HTTP status
-    invalid_http_status,
-
-    /// Missing Required Header
-    missing_required_header,
-
-    /// Embedded SHA-1 library error
-    sha1_library,
-
-    /// No support for this feature in this protocol version.
-    no_protocol_support,
-
-    /// Reserved close code used
-    reserved_close_code,
-
-    /// Invalid close code used
-    invalid_close_code,
-
-    /// Using a reason requires a close code
-    reason_requires_code,
-
-    /// Error parsing subprotocols
-    subprotocol_parse_error,
-
-    /// Error parsing extensions
-    extension_parse_error,
-
-    /// Extension related operation was ignored because extensions are disabled
-    extensions_disabled,
-    
-    /// Short Ke3 read. Hybi00 requires a third key to be read from the 8 bytes
-    /// after the handshake. Less than 8 bytes were read.
-    short_key3
-};
-
-/// Category for processor errors
-class processor_category : public lib::error_category {
-public:
-    processor_category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.processor";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case error::general:
-                return "Generic processor error";
-            case error::bad_request:
-                return "invalid user input";
-            case error::protocol_violation:
-                return "Generic protocol violation";
-            case error::message_too_big:
-                return "A message was too large";
-            case error::invalid_payload:
-                return "A payload contained invalid data";
-            case error::invalid_arguments:
-                return "invalid function arguments";
-            case error::invalid_opcode:
-                return "invalid opcode";
-            case error::control_too_big:
-                return "Control messages are limited to fewer than 125 characters";
-            case error::invalid_rsv_bit:
-                return "Invalid use of reserved bits";
-            case error::fragmented_control:
-                return "Control messages cannot be fragmented";
-            case error::invalid_continuation:
-                return "Invalid message continuation";
-            case error::masking_required:
-                return "Clients may not send unmasked frames";
-            case error::masking_forbidden:
-                return "Servers may not send masked frames";
-            case error::non_minimal_encoding:
-                return "Payload length was not minimally encoded";
-            case error::requires_64bit:
-                return "64 bit frames are not supported on 32 bit systems";
-            case error::invalid_utf8:
-                return "Invalid UTF8 encoding";
-            case error::not_implemented:
-                return "Operation required not implemented functionality";
-            case error::invalid_http_method:
-                return "Invalid HTTP method.";
-            case error::invalid_http_version:
-                return "Invalid HTTP version.";
-            case error::invalid_http_status:
-                return "Invalid HTTP status.";
-            case error::missing_required_header:
-                return "A required HTTP header is missing";
-            case error::sha1_library:
-                return "SHA-1 library error";
-            case error::no_protocol_support:
-                return "The WebSocket protocol version in use does not support this feature";
-            case error::reserved_close_code:
-                return "Reserved close code used";
-            case error::invalid_close_code:
-                return "Invalid close code used";
-            case error::reason_requires_code:
-                return "Using a close reason requires a valid close code";
-            case error::subprotocol_parse_error:
-                return "Error parsing subprotocol header";
-            case error::extension_parse_error:
-                return "Error parsing extension header";
-            case error::extensions_disabled:
-                return "Extensions are disabled";
-            case error::short_key3:
-                return "Short Hybi00 Key 3 read";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the processor error category
-inline lib::error_category const & get_processor_category() {
-    static processor_category instance;
-    return instance;
-}
-
-/// Create an error code with the given value and the processor category
-inline lib::error_code make_error_code(error::processor_errors e) {
-    return lib::error_code(static_cast<int>(e), get_processor_category());
-}
-
-/// Converts a processor error_code into a websocket close code
-/**
- * Looks up the appropriate WebSocket close code that should be sent after an
- * error of this sort occurred.
- *
- * If the error is not in the processor category close::status::blank is
- * returned.
- *
- * If the error isn't normally associated with reasons to close a connection
- * (such as errors intended to be used internally or delivered to client
- * applications, ex: invalid arguments) then
- * close::status::internal_endpoint_error is returned.
- */
-inline close::status::value to_ws(lib::error_code ec) {
-    if (ec.category() != get_processor_category()) {
-        return close::status::blank;
-    }
-
-    switch (ec.value()) {
-        case error::protocol_violation:
-        case error::control_too_big:
-        case error::invalid_opcode:
-        case error::invalid_rsv_bit:
-        case error::fragmented_control:
-        case error::invalid_continuation:
-        case error::masking_required:
-        case error::masking_forbidden:
-        case error::reserved_close_code:
-        case error::invalid_close_code:
-            return close::status::protocol_error;
-        case error::invalid_payload:
-        case error::invalid_utf8:
-            return close::status::invalid_payload;
-        case error::message_too_big:
-            return close::status::message_too_big;
-        default:
-            return close::status::internal_endpoint_error;
-    }
-}
-
-} // namespace error
-} // namespace processor
-} // namespace websocketpp
-
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::processor::error::processor_errors>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif //WEBSOCKETPP_PROCESSOR_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi00.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi00.hpp
deleted file mode 100644
index 95ad9df..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi00.hpp
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_HYBI00_HPP
-#define WEBSOCKETPP_PROCESSOR_HYBI00_HPP
-
-#include <websocketpp/frame.hpp>
-#include <websocketpp/http/constants.hpp>
-
-#include <websocketpp/utf8_validator.hpp>
-#include <websocketpp/common/network.hpp>
-#include <websocketpp/common/md5.hpp>
-#include <websocketpp/common/platforms.hpp>
-
-#include <websocketpp/processors/processor.hpp>
-
-#include <algorithm>
-#include <cstdlib>
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace processor {
-
-/// Processor for Hybi Draft version 00
-/**
- * There are many differences between Hybi 00 and Hybi 13
- */
-template <typename config>
-class hybi00 : public processor<config> {
-public:
-    typedef processor<config> base;
-
-    typedef typename config::request_type request_type;
-    typedef typename config::response_type response_type;
-
-    typedef typename config::message_type message_type;
-    typedef typename message_type::ptr message_ptr;
-
-    typedef typename config::con_msg_manager_type::ptr msg_manager_ptr;
-
-    explicit hybi00(bool secure, bool p_is_server, msg_manager_ptr manager)
-      : processor<config>(secure, p_is_server)
-      , msg_hdr(0x00)
-      , msg_ftr(0xff)
-      , m_state(HEADER)
-      , m_msg_manager(manager) {}
-
-    int get_version() const {
-        return 0;
-    }
-
-    lib::error_code validate_handshake(request_type const & r) const {
-        if (r.get_method() != "GET") {
-            return make_error_code(error::invalid_http_method);
-        }
-
-        if (r.get_version() != "HTTP/1.1") {
-            return make_error_code(error::invalid_http_version);
-        }
-
-        // required headers
-        // Host is required by HTTP/1.1
-        // Connection is required by is_websocket_handshake
-        // Upgrade is required by is_websocket_handshake
-        if (r.get_header("Sec-WebSocket-Key1").empty() ||
-            r.get_header("Sec-WebSocket-Key2").empty() ||
-            r.get_header("Sec-WebSocket-Key3").empty())
-        {
-            return make_error_code(error::missing_required_header);
-        }
-
-        return lib::error_code();
-    }
-
-    lib::error_code process_handshake(request_type const & req,
-        std::string const & subprotocol, response_type & res) const
-    {
-        char key_final[16];
-
-        // copy key1 into final key
-        decode_client_key(req.get_header("Sec-WebSocket-Key1"), &key_final[0]);
-
-        // copy key2 into final key
-        decode_client_key(req.get_header("Sec-WebSocket-Key2"), &key_final[4]);
-
-        // copy key3 into final key
-        // key3 should be exactly 8 bytes. If it is more it will be truncated
-        // if it is less the final key will almost certainly be wrong.
-        // TODO: decide if it is best to silently fail here or produce some sort
-        //       of warning or exception.
-        std::string const & key3 = req.get_header("Sec-WebSocket-Key3");
-        std::copy(key3.c_str(),
-                  key3.c_str()+(std::min)(static_cast<size_t>(8), key3.size()),
-                  &key_final[8]);
-
-        res.append_header(
-            "Sec-WebSocket-Key3",
-            md5::md5_hash_string(std::string(key_final,16))
-        );
-
-        res.append_header("Upgrade","WebSocket");
-        res.append_header("Connection","Upgrade");
-
-        // Echo back client's origin unless our local application set a
-        // more restrictive one.
-        if (res.get_header("Sec-WebSocket-Origin").empty()) {
-            res.append_header("Sec-WebSocket-Origin",req.get_header("Origin"));
-        }
-
-        // Echo back the client's request host unless our local application
-        // set a different one.
-        if (res.get_header("Sec-WebSocket-Location").empty()) {
-            uri_ptr uri = get_uri(req);
-            res.append_header("Sec-WebSocket-Location",uri->str());
-        }
-
-        if (!subprotocol.empty()) {
-            res.replace_header("Sec-WebSocket-Protocol",subprotocol);
-        }
-
-        return lib::error_code();
-    }
-
-    /// Fill in a set of request headers for a client connection request
-    /**
-     * The Hybi 00 processor only implements incoming connections so this will
-     * always return an error.
-     *
-     * @param [out] req  Set of headers to fill in
-     * @param [in] uri The uri being connected to
-     * @param [in] subprotocols The list of subprotocols to request
-     */
-    lib::error_code client_handshake_request(request_type &, uri_ptr,
-        std::vector<std::string> const &) const
-    {
-        return error::make_error_code(error::no_protocol_support);
-    }
-
-    /// Validate the server's response to an outgoing handshake request
-    /**
-     * The Hybi 00 processor only implements incoming connections so this will
-     * always return an error.
-     *
-     * @param req The original request sent
-     * @param res The reponse to generate
-     * @return An error code, 0 on success, non-zero for other errors
-     */
-    lib::error_code validate_server_handshake_response(request_type const &,
-        response_type &) const
-    {
-        return error::make_error_code(error::no_protocol_support);
-    }
-
-    std::string get_raw(response_type const & res) const {
-        response_type temp = res;
-        temp.remove_header("Sec-WebSocket-Key3");
-        return temp.raw() + res.get_header("Sec-WebSocket-Key3");
-    }
-
-    std::string const & get_origin(request_type const & r) const {
-        return r.get_header("Origin");
-    }
-
-    /// Extracts requested subprotocols from a handshake request
-    /**
-     * hybi00 does support subprotocols
-     * https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00#section-1.9
-     *
-     * @param [in] req The request to extract from
-     * @param [out] subprotocol_list A reference to a vector of strings to store
-     * the results in.
-     */
-    lib::error_code extract_subprotocols(request_type const & req,
-        std::vector<std::string> & subprotocol_list)
-    {
-        if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
-            http::parameter_list p;
-
-             if (!req.get_header_as_plist("Sec-WebSocket-Protocol",p)) {
-                 http::parameter_list::const_iterator it;
-
-                 for (it = p.begin(); it != p.end(); ++it) {
-                     subprotocol_list.push_back(it->first);
-                 }
-             } else {
-                 return error::make_error_code(error::subprotocol_parse_error);
-             }
-        }
-        return lib::error_code();
-    }
-
-    uri_ptr get_uri(request_type const & request) const {
-        std::string h = request.get_header("Host");
-
-        size_t last_colon = h.rfind(":");
-        size_t last_sbrace = h.rfind("]");
-
-        // no : = hostname with no port
-        // last : before ] = ipv6 literal with no port
-        // : with no ] = hostname with port
-        // : after ] = ipv6 literal with port
-
-        if (last_colon == std::string::npos ||
-            (last_sbrace != std::string::npos && last_sbrace > last_colon))
-        {
-            return lib::make_shared<uri>(base::m_secure, h, request.get_uri());
-        } else {
-            return lib::make_shared<uri>(base::m_secure,
-                                   h.substr(0,last_colon),
-                                   h.substr(last_colon+1),
-                                   request.get_uri());
-        }
-
-        // TODO: check if get_uri is a full uri
-    }
-
-    /// Get hybi00 handshake key3
-    /**
-     * @todo This doesn't appear to be used anymore. It might be able to be
-     * removed
-     */
-    std::string get_key3() const {
-        return "";
-    }
-
-    /// Process new websocket connection bytes
-    size_t consume(uint8_t * buf, size_t len, lib::error_code & ec) {
-        // if in state header we are expecting a 0x00 byte, if we don't get one
-        // it is a fatal error
-        size_t p = 0; // bytes processed
-        size_t l = 0;
-
-        ec = lib::error_code();
-
-        while (p < len) {
-            if (m_state == HEADER) {
-                if (buf[p] == msg_hdr) {
-                    p++;
-                    m_msg_ptr = m_msg_manager->get_message(frame::opcode::text,1);
-
-                    if (!m_msg_ptr) {
-                        ec = make_error_code(websocketpp::error::no_incoming_buffers);
-                        m_state = FATAL_ERROR;
-                    } else {
-                        m_state = PAYLOAD;
-                    }
-                } else {
-                    ec = make_error_code(error::protocol_violation);
-                    m_state = FATAL_ERROR;
-                }
-            } else if (m_state == PAYLOAD) {
-                uint8_t *it = std::find(buf+p,buf+len,msg_ftr);
-
-                // 0    1    2    3    4    5
-                // 0x00 0x23 0x23 0x23 0xff 0xXX
-
-                // Copy payload bytes into message
-                l = static_cast<size_t>(it-(buf+p));
-                m_msg_ptr->append_payload(buf+p,l);
-                p += l;
-
-                if (it != buf+len) {
-                    // message is done, copy it and the trailing
-                    p++;
-                    // TODO: validation
-                    m_state = READY;
-                }
-            } else {
-                // TODO
-                break;
-            }
-        }
-        // If we get one, we create a new message and move to application state
-
-        // if in state application we are copying bytes into the output message
-        // and validating them for UTF8 until we hit a 0xff byte. Once we hit
-        // 0x00, the message is complete and is dispatched. Then we go back to
-        // header state.
-
-        //ec = make_error_code(error::not_implemented);
-        return p;
-    }
-
-    bool ready() const {
-        return (m_state == READY);
-    }
-
-    bool get_error() const {
-        return false;
-    }
-
-    message_ptr get_message() {
-        message_ptr ret = m_msg_ptr;
-        m_msg_ptr = message_ptr();
-        m_state = HEADER;
-        return ret;
-    }
-
-    /// Prepare a message for writing
-    /**
-     * Performs validation, masking, compression, etc. will return an error if
-     * there was an error, otherwise msg will be ready to be written
-     */
-    virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
-    {
-        if (!in || !out) {
-            return make_error_code(error::invalid_arguments);
-        }
-
-        // TODO: check if the message is prepared already
-
-        // validate opcode
-        if (in->get_opcode() != frame::opcode::text) {
-            return make_error_code(error::invalid_opcode);
-        }
-
-        std::string& i = in->get_raw_payload();
-        //std::string& o = out->get_raw_payload();
-
-        // validate payload utf8
-        if (!utf8_validator::validate(i)) {
-            return make_error_code(error::invalid_payload);
-        }
-
-        // generate header
-        out->set_header(std::string(reinterpret_cast<char const *>(&msg_hdr),1));
-
-        // process payload
-        out->set_payload(i);
-        out->append_payload(std::string(reinterpret_cast<char const *>(&msg_ftr),1));
-
-        // hybi00 doesn't support compression
-        // hybi00 doesn't have masking
-
-        out->set_prepared(true);
-
-        return lib::error_code();
-    }
-
-    /// Prepare a ping frame
-    /**
-     * Hybi 00 doesn't support pings so this will always return an error
-     *
-     * @param in The string to use for the ping payload
-     * @param out The message buffer to prepare the ping in.
-     * @return Status code, zero on success, non-zero on failure
-     */
-    lib::error_code prepare_ping(std::string const &, message_ptr) const
-    {
-        return lib::error_code(error::no_protocol_support);
-    }
-
-    /// Prepare a pong frame
-    /**
-     * Hybi 00 doesn't support pongs so this will always return an error
-     *
-     * @param in The string to use for the pong payload
-     * @param out The message buffer to prepare the pong in.
-     * @return Status code, zero on success, non-zero on failure
-     */
-    lib::error_code prepare_pong(std::string const &, message_ptr) const
-    {
-        return lib::error_code(error::no_protocol_support);
-    }
-
-    /// Prepare a close frame
-    /**
-     * Hybi 00 doesn't support the close code or reason so these parameters are
-     * ignored.
-     *
-     * @param code The close code to send
-     * @param reason The reason string to send
-     * @param out The message buffer to prepare the fame in
-     * @return Status code, zero on success, non-zero on failure
-     */
-    lib::error_code prepare_close(close::status::value, std::string const &, 
-        message_ptr out) const
-    {
-        if (!out) {
-            return lib::error_code(error::invalid_arguments);
-        }
-
-        std::string val;
-        val.append(1,'\xff');
-        val.append(1,'\x00');
-        out->set_payload(val);
-        out->set_prepared(true);
-
-        return lib::error_code();
-    }
-private:
-    void decode_client_key(std::string const & key, char * result) const {
-        unsigned int spaces = 0;
-        std::string digits;
-        uint32_t num;
-
-        // key2
-        for (size_t i = 0; i < key.size(); i++) {
-            if (key[i] == ' ') {
-                spaces++;
-            } else if (key[i] >= '0' && key[i] <= '9') {
-                digits += key[i];
-            }
-        }
-
-        num = static_cast<uint32_t>(strtoul(digits.c_str(), NULL, 10));
-        if (spaces > 0 && num > 0) {
-            num = htonl(num/spaces);
-            std::copy(reinterpret_cast<char*>(&num),
-                      reinterpret_cast<char*>(&num)+4,
-                      result);
-        } else {
-            std::fill(result,result+4,0);
-        }
-    }
-
-    enum state {
-        HEADER = 0,
-        PAYLOAD = 1,
-        READY = 2,
-        FATAL_ERROR = 3
-    };
-
-    uint8_t const msg_hdr;
-    uint8_t const msg_ftr;
-
-    state m_state;
-
-    msg_manager_ptr m_msg_manager;
-    message_ptr m_msg_ptr;
-    utf8_validator::validator m_validator;
-};
-
-} // namespace processor
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_PROCESSOR_HYBI00_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi07.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi07.hpp
deleted file mode 100644
index 14b67c2..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi07.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_HYBI07_HPP
-#define WEBSOCKETPP_PROCESSOR_HYBI07_HPP
-
-#include <websocketpp/processors/hybi08.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace processor {
-
-/// Processor for Hybi Draft version 07
-/**
- * The primary difference between 07 and 08 is a version number.
- */
-template <typename config>
-class hybi07 : public hybi08<config> {
-public:
-    typedef typename config::request_type request_type;
-
-    typedef typename config::con_msg_manager_type::ptr msg_manager_ptr;
-    typedef typename config::rng_type rng_type;
-
-    explicit hybi07(bool secure, bool p_is_server, msg_manager_ptr manager, rng_type& rng)
-      : hybi08<config>(secure, p_is_server, manager, rng) {}
-
-    /// Fill in a set of request headers for a client connection request
-    /**
-     * The Hybi 07 processor only implements incoming connections so this will
-     * always return an error.
-     *
-     * @param [out] req  Set of headers to fill in
-     * @param [in] uri The uri being connected to
-     * @param [in] subprotocols The list of subprotocols to request
-     */
-    lib::error_code client_handshake_request(request_type &, uri_ptr,
-        std::vector<std::string> const &) const
-    {
-        return error::make_error_code(error::no_protocol_support);
-    }
-
-    int get_version() const {
-        return 7;
-    }
-private:
-};
-
-} // namespace processor
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_PROCESSOR_HYBI07_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi08.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi08.hpp
deleted file mode 100644
index 15f6e65..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi08.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_HYBI08_HPP
-#define WEBSOCKETPP_PROCESSOR_HYBI08_HPP
-
-#include <websocketpp/processors/hybi13.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace processor {
-
-/// Processor for Hybi Draft version 08
-/**
- * The primary difference between 08 and 13 is a different origin header name
- */
-template <typename config>
-class hybi08 : public hybi13<config> {
-public:
-    typedef hybi08<config> type;
-    typedef typename config::request_type request_type;
-
-    typedef typename config::con_msg_manager_type::ptr msg_manager_ptr;
-    typedef typename config::rng_type rng_type;
-
-    explicit hybi08(bool secure, bool p_is_server, msg_manager_ptr manager, rng_type& rng)
-      : hybi13<config>(secure, p_is_server, manager, rng) {}
-
-    /// Fill in a set of request headers for a client connection request
-    /**
-     * The Hybi 08 processor only implements incoming connections so this will
-     * always return an error.
-     *
-     * @param [out] req  Set of headers to fill in
-     * @param [in] uri The uri being connected to
-     * @param [in] subprotocols The list of subprotocols to request
-     */
-    lib::error_code client_handshake_request(request_type &, uri_ptr,
-        std::vector<std::string> const &) const
-    {
-        return error::make_error_code(error::no_protocol_support);
-    }
-
-    int get_version() const {
-        return 8;
-    }
-
-    std::string const & get_origin(request_type const & r) const {
-        return r.get_header("Sec-WebSocket-Origin");
-    }
-private:
-};
-
-} // namespace processor
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_PROCESSOR_HYBI08_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi13.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi13.hpp
deleted file mode 100644
index ca12439..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/hybi13.hpp
+++ /dev/null
@@ -1,1078 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_HYBI13_HPP
-#define WEBSOCKETPP_PROCESSOR_HYBI13_HPP
-
-#include <websocketpp/processors/processor.hpp>
-
-#include <websocketpp/frame.hpp>
-#include <websocketpp/http/constants.hpp>
-
-#include <websocketpp/utf8_validator.hpp>
-#include <websocketpp/sha1/sha1.hpp>
-#include <websocketpp/base64/base64.hpp>
-
-#include <websocketpp/common/network.hpp>
-#include <websocketpp/common/platforms.hpp>
-
-#include <algorithm>
-#include <cassert>
-#include <string>
-#include <vector>
-#include <utility>
-
-namespace websocketpp {
-namespace processor {
-
-/// Processor for Hybi version 13 (RFC6455)
-template <typename config>
-class hybi13 : public processor<config> {
-public:
-    typedef processor<config> base;
-
-    typedef typename config::request_type request_type;
-    typedef typename config::response_type response_type;
-
-    typedef typename config::message_type message_type;
-    typedef typename message_type::ptr message_ptr;
-
-    typedef typename config::con_msg_manager_type msg_manager_type;
-    typedef typename msg_manager_type::ptr msg_manager_ptr;
-    typedef typename config::rng_type rng_type;
-
-    typedef typename config::permessage_deflate_type permessage_deflate_type;
-
-    typedef std::pair<lib::error_code,std::string> err_str_pair;
-
-    explicit hybi13(bool secure, bool p_is_server, msg_manager_ptr manager, rng_type& rng)
-      : processor<config>(secure, p_is_server)
-      , m_msg_manager(manager)
-      , m_rng(rng)
-    {
-        reset_headers();
-    }
-
-    int get_version() const {
-        return 13;
-    }
-
-    bool has_permessage_deflate() const {
-        return m_permessage_deflate.is_implemented();
-    }
-
-    err_str_pair negotiate_extensions(request_type const & request) {
-        return negotiate_extensions_helper(request);
-    }
-    
-    err_str_pair negotiate_extensions(response_type const & response) {
-        return negotiate_extensions_helper(response);
-    }
-    
-    /// Extension negotiation helper function
-    /**
-     * This exists mostly because the code for requests and responses is
-     * identical and I can't have virtual template methods.
-     */
-    template <typename header_type>
-    err_str_pair negotiate_extensions_helper(header_type const & header) {
-        err_str_pair ret;
-
-        // Respect blanket disabling of all extensions and don't even parse
-        // the extension header
-        if (!config::enable_extensions) {
-            ret.first = make_error_code(error::extensions_disabled);
-            return ret;
-        }
-
-        http::parameter_list p;
-
-        bool error = header.get_header_as_plist("Sec-WebSocket-Extensions",p);
-
-        if (error) {
-            ret.first = make_error_code(error::extension_parse_error);
-            return ret;
-        }
-
-        // If there are no extensions parsed then we are done!
-        if (p.size() == 0) {
-            return ret;
-        }
-
-        http::parameter_list::const_iterator it;
-
-        // look through the list of extension requests to find the first
-        // one that we can accept.
-        if (m_permessage_deflate.is_implemented()) {
-            err_str_pair neg_ret;
-            for (it = p.begin(); it != p.end(); ++it) {
-                // not a permessage-deflate extension request, ignore
-                if (it->first != "permessage-deflate") {
-                    continue;
-                }
-
-                // if we have already successfully negotiated this extension
-                // then skip any other requests to negotiate the same one
-                // with different parameters 
-                if (m_permessage_deflate.is_enabled()) {
-                    continue;
-                }
-                
-                // attempt to negotiate this offer
-                neg_ret = m_permessage_deflate.negotiate(it->second);
-
-                if (neg_ret.first) {
-                    // negotiation offer failed. Do nothing. We will continue
-                    // searching for a permessage-deflate config that succeeds
-                    continue;
-                }
-
-                // Negotiation tentatively succeeded
-
-                // Actually try to initialize the extension before we
-                // deem negotiation complete
-                lib::error_code ec = m_permessage_deflate.init(base::m_server);
-
-                if (ec) {
-                    // Negotiation succeeded but initialization failed this is 
-                    // an error that should stop negotiation of permessage 
-                    // deflate. Return the reason for the init failure
-
-                    ret.first = ec;
-                    break;
-                } else {
-                    // Successfully initialized, push the negotiated response into
-                    // the reply and stop looking for additional permessage-deflate
-                    // extensions
-                    ret.second += neg_ret.second;
-                    break;
-                }
-            }
-        }
-
-        // support for future extensions would go here. Should check the value of 
-        // ret.first before continuing. Might need to consider whether failure of
-        // negotiation of an earlier extension should stop negotiation of subsequent
-        // ones
-
-        return ret;
-    }
-
-    lib::error_code validate_handshake(request_type const & r) const {
-        if (r.get_method() != "GET") {
-            return make_error_code(error::invalid_http_method);
-        }
-
-        if (r.get_version() != "HTTP/1.1") {
-            return make_error_code(error::invalid_http_version);
-        }
-
-        // required headers
-        // Host is required by HTTP/1.1
-        // Connection is required by is_websocket_handshake
-        // Upgrade is required by is_websocket_handshake
-        if (r.get_header("Sec-WebSocket-Key").empty()) {
-            return make_error_code(error::missing_required_header);
-        }
-
-        return lib::error_code();
-    }
-
-    /* TODO: the 'subprotocol' parameter may need to be expanded into a more
-     * generic struct if other user input parameters to the processed handshake
-     * are found.
-     */
-    lib::error_code process_handshake(request_type const & request, 
-        std::string const & subprotocol, response_type & response) const
-    {
-        std::string server_key = request.get_header("Sec-WebSocket-Key");
-
-        lib::error_code ec = process_handshake_key(server_key);
-
-        if (ec) {
-            return ec;
-        }
-
-        response.replace_header("Sec-WebSocket-Accept",server_key);
-        response.append_header("Upgrade",constants::upgrade_token);
-        response.append_header("Connection",constants::connection_token);
-
-        if (!subprotocol.empty()) {
-            response.replace_header("Sec-WebSocket-Protocol",subprotocol);
-        }
-
-        return lib::error_code();
-    }
-
-    /// Fill in a set of request headers for a client connection request
-    /**
-     * @param [out] req  Set of headers to fill in
-     * @param [in] uri The uri being connected to
-     * @param [in] subprotocols The list of subprotocols to request
-     */
-    lib::error_code client_handshake_request(request_type & req, uri_ptr
-        uri, std::vector<std::string> const & subprotocols) const
-    {
-        req.set_method("GET");
-        req.set_uri(uri->get_resource());
-        req.set_version("HTTP/1.1");
-
-        req.append_header("Upgrade","websocket");
-        req.append_header("Connection","Upgrade");
-        req.replace_header("Sec-WebSocket-Version","13");
-        req.replace_header("Host",uri->get_host_port());
-
-        if (!subprotocols.empty()) {
-            std::ostringstream result;
-            std::vector<std::string>::const_iterator it = subprotocols.begin();
-            result << *it++;
-            while (it != subprotocols.end()) {
-                result << ", " << *it++;
-            }
-
-            req.replace_header("Sec-WebSocket-Protocol",result.str());
-        }
-
-        // Generate handshake key
-        frame::uint32_converter conv;
-        unsigned char raw_key[16];
-
-        for (int i = 0; i < 4; i++) {
-            conv.i = m_rng();
-            std::copy(conv.c,conv.c+4,&raw_key[i*4]);
-        }
-
-        req.replace_header("Sec-WebSocket-Key",base64_encode(raw_key, 16));
-
-        if (m_permessage_deflate.is_implemented()) {
-            std::string offer = m_permessage_deflate.generate_offer();
-            if (!offer.empty()) {
-                req.replace_header("Sec-WebSocket-Extensions",offer);
-            }
-        }
-
-        return lib::error_code();
-    }
-
-    /// Validate the server's response to an outgoing handshake request
-    /**
-     * @param req The original request sent
-     * @param res The reponse to generate
-     * @return An error code, 0 on success, non-zero for other errors
-     */
-    lib::error_code validate_server_handshake_response(request_type const & req,
-        response_type& res) const
-    {
-        // A valid response has an HTTP 101 switching protocols code
-        if (res.get_status_code() != http::status_code::switching_protocols) {
-            return error::make_error_code(error::invalid_http_status);
-        }
-
-        // And the upgrade token in an upgrade header
-        std::string const & upgrade_header = res.get_header("Upgrade");
-        if (utility::ci_find_substr(upgrade_header, constants::upgrade_token,
-            sizeof(constants::upgrade_token)-1) == upgrade_header.end())
-        {
-            return error::make_error_code(error::missing_required_header);
-        }
-
-        // And the websocket token in the connection header
-        std::string const & con_header = res.get_header("Connection");
-        if (utility::ci_find_substr(con_header, constants::connection_token,
-            sizeof(constants::connection_token)-1) == con_header.end())
-        {
-            return error::make_error_code(error::missing_required_header);
-        }
-
-        // And has a valid Sec-WebSocket-Accept value
-        std::string key = req.get_header("Sec-WebSocket-Key");
-        lib::error_code ec = process_handshake_key(key);
-
-        if (ec || key != res.get_header("Sec-WebSocket-Accept")) {
-            return error::make_error_code(error::missing_required_header);
-        }
-
-        // check extensions
-
-        return lib::error_code();
-    }
-
-    std::string get_raw(response_type const & res) const {
-        return res.raw();
-    }
-
-    std::string const & get_origin(request_type const & r) const {
-        return r.get_header("Origin");
-    }
-
-    lib::error_code extract_subprotocols(request_type const & req,
-        std::vector<std::string> & subprotocol_list)
-    {
-        if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
-            http::parameter_list p;
-
-             if (!req.get_header_as_plist("Sec-WebSocket-Protocol",p)) {
-                 http::parameter_list::const_iterator it;
-
-                 for (it = p.begin(); it != p.end(); ++it) {
-                     subprotocol_list.push_back(it->first);
-                 }
-             } else {
-                 return error::make_error_code(error::subprotocol_parse_error);
-             }
-        }
-        return lib::error_code();
-    }
-
-    uri_ptr get_uri(request_type const & request) const {
-        return get_uri_from_host(request,(base::m_secure ? "wss" : "ws"));
-    }
-
-    /// Process new websocket connection bytes
-    /**
-     *
-     * Hybi 13 data streams represent a series of variable length frames. Each
-     * frame is made up of a series of fixed length fields. The lengths of later
-     * fields are contained in earlier fields. The first field length is fixed
-     * by the spec.
-     *
-     * This processor represents a state machine that keeps track of what field
-     * is presently being read and how many more bytes are needed to complete it
-     *
-     *
-     *
-     *
-     * Read two header bytes
-     *   Extract full frame length.
-     *   Read extra header bytes
-     * Validate frame header (including extension validate)
-     * Read extension data into extension message state object
-     * Read payload data into payload
-     *
-     * @param buf Input buffer
-     *
-     * @param len Length of input buffer
-     *
-     * @return Number of bytes processed or zero on error
-     */
-    size_t consume(uint8_t * buf, size_t len, lib::error_code & ec) {
-        size_t p = 0;
-
-        ec = lib::error_code();
-
-        //std::cout << "consume: " << utility::to_hex(buf,len) << std::endl;
-
-        // Loop while we don't have a message ready and we still have bytes
-        // left to process.
-        while (m_state != READY && m_state != FATAL_ERROR &&
-               (p < len || m_bytes_needed == 0))
-        {
-            if (m_state == HEADER_BASIC) {
-                p += this->copy_basic_header_bytes(buf+p,len-p);
-
-                if (m_bytes_needed > 0) {
-                    continue;
-                }
-
-                ec = this->validate_incoming_basic_header(
-                    m_basic_header, base::m_server, !m_data_msg.msg_ptr
-                );
-                if (ec) {break;}
-
-                // extract full header size and adjust consume state accordingly
-                m_state = HEADER_EXTENDED;
-                m_cursor = 0;
-                m_bytes_needed = frame::get_header_len(m_basic_header) -
-                    frame::BASIC_HEADER_LENGTH;
-            } else if (m_state == HEADER_EXTENDED) {
-                p += this->copy_extended_header_bytes(buf+p,len-p);
-
-                if (m_bytes_needed > 0) {
-                    continue;
-                }
-
-                ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
-                if (ec){break;}
-
-                m_state = APPLICATION;
-                m_bytes_needed = static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
-
-                // check if this frame is the start of a new message and set up
-                // the appropriate message metadata.
-                frame::opcode::value op = frame::get_opcode(m_basic_header);
-
-                // TODO: get_message failure conditions
-
-                if (frame::opcode::is_control(op)) {
-                    m_control_msg = msg_metadata(
-                        m_msg_manager->get_message(op,m_bytes_needed),
-                        frame::get_masking_key(m_basic_header,m_extended_header)
-                    );
-
-                    m_current_msg = &m_control_msg;
-                } else {
-                    if (!m_data_msg.msg_ptr) {
-                        if (m_bytes_needed > base::m_max_message_size) {
-                            ec = make_error_code(error::message_too_big);
-                            break;
-                        }
-                        
-                        m_data_msg = msg_metadata(
-                            m_msg_manager->get_message(op,m_bytes_needed),
-                            frame::get_masking_key(m_basic_header,m_extended_header)
-                        );
-                        
-                        if (m_permessage_deflate.is_enabled()) {
-                            m_data_msg.msg_ptr->set_compressed(frame::get_rsv1(m_basic_header));
-                        }
-                    } else {
-                        // Fetch the underlying payload buffer from the data message we
-                        // are writing into.
-                        std::string & out = m_data_msg.msg_ptr->get_raw_payload();
-                        
-                        if (out.size() + m_bytes_needed > base::m_max_message_size) {
-                            ec = make_error_code(error::message_too_big);
-                            break;
-                        }
-                        
-                        // Each frame starts a new masking key. All other state
-                        // remains between frames.
-                        m_data_msg.prepared_key = prepare_masking_key(
-                            frame::get_masking_key(
-                                m_basic_header,
-                                m_extended_header
-                            )
-                        );
-                        
-                        out.reserve(out.size() + m_bytes_needed);
-                    }
-                    m_current_msg = &m_data_msg;
-                }
-            } else if (m_state == EXTENSION) {
-                m_state = APPLICATION;
-            } else if (m_state == APPLICATION) {
-                size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
-
-                if (bytes_to_process > 0) {
-                    p += this->process_payload_bytes(buf+p,bytes_to_process,ec);
-
-                    if (ec) {break;}
-                }
-
-                if (m_bytes_needed > 0) {
-                    continue;
-                }
-
-                // If this was the last frame in the message set the ready flag.
-                // Otherwise, reset processor state to read additional frames.
-                if (frame::get_fin(m_basic_header)) {
-                    ec = finalize_message();
-                    if (ec) {
-                        break;
-                    }
-                } else {
-                    this->reset_headers();
-                }
-            } else {
-                // shouldn't be here
-                ec = make_error_code(error::general);
-                return 0;
-            }
-        }
-
-        return p;
-    }
-
-    /// Perform any finalization actions on an incoming message
-    /**
-     * Called after the full message is received. Provides the opportunity for
-     * extensions to complete any data post processing as well as final UTF8
-     * validation checks for text messages.
-     *
-     * @return A code indicating errors, if any
-     */
-    lib::error_code finalize_message() {
-        std::string & out = m_current_msg->msg_ptr->get_raw_payload();
-
-        // if the frame is compressed, append the compression
-        // trailer and flush the compression buffer.
-        if (m_permessage_deflate.is_enabled()
-            && m_current_msg->msg_ptr->get_compressed())
-        {
-            uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
-
-            // Decompress current buffer into the message buffer
-            lib::error_code ec;
-            ec = m_permessage_deflate.decompress(trailer,4,out);
-            if (ec) {
-                return ec;
-            }
-        }
-
-        // ensure that text messages end on a valid UTF8 code point
-        if (frame::get_opcode(m_basic_header) == frame::opcode::TEXT) {
-            if (!m_current_msg->validator.complete()) {
-                return make_error_code(error::invalid_utf8);
-            }
-        }
-
-        m_state = READY;
-
-        return lib::error_code();
-    }
-
-    void reset_headers() {
-        m_state = HEADER_BASIC;
-        m_bytes_needed = frame::BASIC_HEADER_LENGTH;
-
-        m_basic_header.b0 = 0x00;
-        m_basic_header.b1 = 0x00;
-
-        std::fill_n(
-            m_extended_header.bytes,
-            frame::MAX_EXTENDED_HEADER_LENGTH,
-            0x00
-        );
-    }
-
-    /// Test whether or not the processor has a message ready
-    bool ready() const {
-        return (m_state == READY);
-    }
-
-    message_ptr get_message() {
-        if (!ready()) {
-            return message_ptr();
-        }
-        message_ptr ret = m_current_msg->msg_ptr;
-        m_current_msg->msg_ptr.reset();
-
-        if (frame::opcode::is_control(ret->get_opcode())) {
-            m_control_msg.msg_ptr.reset();
-        } else {
-            m_data_msg.msg_ptr.reset();
-        }
-
-        this->reset_headers();
-
-        return ret;
-    }
-
-    /// Test whether or not the processor is in a fatal error state.
-    bool get_error() const {
-        return m_state == FATAL_ERROR;
-    }
-
-    size_t get_bytes_needed() const {
-        return m_bytes_needed;
-    }
-
-    /// Prepare a user data message for writing
-    /**
-     * Performs validation, masking, compression, etc. will return an error if
-     * there was an error, otherwise msg will be ready to be written
-     *
-     * TODO: tests
-     *
-     * @param in An unprepared message to prepare
-     * @param out A message to be overwritten with the prepared message
-     * @return error code
-     */
-    virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
-    {
-        if (!in || !out) {
-            return make_error_code(error::invalid_arguments);
-        }
-
-        frame::opcode::value op = in->get_opcode();
-
-        // validate opcode: only regular data frames
-        if (frame::opcode::is_control(op)) {
-            return make_error_code(error::invalid_opcode);
-        }
-
-        std::string& i = in->get_raw_payload();
-        std::string& o = out->get_raw_payload();
-
-        // validate payload utf8
-        if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
-            return make_error_code(error::invalid_payload);
-        }
-
-        frame::masking_key_type key;
-        bool masked = !base::m_server;
-        bool compressed = m_permessage_deflate.is_enabled()
-                          && in->get_compressed();
-        bool fin = in->get_fin();
-
-        if (masked) {
-            // Generate masking key.
-            key.i = m_rng();
-        } else {
-            key.i = 0;
-        }
-
-        // prepare payload
-        if (compressed) {
-            // compress and store in o after header.
-            m_permessage_deflate.compress(i,o);
-
-            if (o.size() < 4) {
-                return make_error_code(error::general);
-            }
-
-            // Strip trailing 4 0x00 0x00 0xff 0xff bytes before writing to the
-            // wire
-            o.resize(o.size()-4);
-
-            // mask in place if necessary
-            if (masked) {
-                this->masked_copy(o,o,key);
-            }
-        } else {
-            // no compression, just copy data into the output buffer
-            o.resize(i.size());
-
-            // if we are masked, have the masking function write to the output
-            // buffer directly to avoid another copy. If not masked, copy
-            // directly without masking.
-            if (masked) {
-                this->masked_copy(i,o,key);
-            } else {
-                std::copy(i.begin(),i.end(),o.begin());
-            }
-        }
-
-        // generate header
-        frame::basic_header h(op,o.size(),fin,masked,compressed);
-
-        if (masked) {
-            frame::extended_header e(o.size(),key.i);
-            out->set_header(frame::prepare_header(h,e));
-        } else {
-            frame::extended_header e(o.size());
-            out->set_header(frame::prepare_header(h,e));
-        }
-
-        out->set_prepared(true);
-        out->set_opcode(op);
-
-        return lib::error_code();
-    }
-
-    /// Get URI
-    lib::error_code prepare_ping(std::string const & in, message_ptr out) const {
-        return this->prepare_control(frame::opcode::PING,in,out);
-    }
-
-    lib::error_code prepare_pong(std::string const & in, message_ptr out) const {
-        return this->prepare_control(frame::opcode::PONG,in,out);
-    }
-
-    virtual lib::error_code prepare_close(close::status::value code,
-        std::string const & reason, message_ptr out) const
-    {
-        if (close::status::reserved(code)) {
-            return make_error_code(error::reserved_close_code);
-        }
-
-        if (close::status::invalid(code) && code != close::status::no_status) {
-            return make_error_code(error::invalid_close_code);
-        }
-
-        if (code == close::status::no_status && reason.size() > 0) {
-            return make_error_code(error::reason_requires_code);
-        }
-
-        if (reason.size() > frame:: limits::payload_size_basic-2) {
-            return make_error_code(error::control_too_big);
-        }
-
-        std::string payload;
-
-        if (code != close::status::no_status) {
-            close::code_converter val;
-            val.i = htons(code);
-
-            payload.resize(reason.size()+2);
-
-            payload[0] = val.c[0];
-            payload[1] = val.c[1];
-
-            std::copy(reason.begin(),reason.end(),payload.begin()+2);
-        }
-
-        return this->prepare_control(frame::opcode::CLOSE,payload,out);
-    }
-protected:
-    /// Convert a client handshake key into a server response key in place
-    lib::error_code process_handshake_key(std::string & key) const {
-        key.append(constants::handshake_guid);
-
-        unsigned char message_digest[20];
-        sha1::calc(key.c_str(),key.length(),message_digest);
-        key = base64_encode(message_digest,20);
-
-        return lib::error_code();
-    }
-
-    /// Reads bytes from buf into m_basic_header
-    size_t copy_basic_header_bytes(uint8_t const * buf, size_t len) {
-        if (len == 0 || m_bytes_needed == 0) {
-            return 0;
-        }
-
-        if (len > 1) {
-            // have at least two bytes
-            if (m_bytes_needed == 2) {
-                m_basic_header.b0 = buf[0];
-                m_basic_header.b1 = buf[1];
-                m_bytes_needed -= 2;
-                return 2;
-            } else {
-                m_basic_header.b1 = buf[0];
-                m_bytes_needed--;
-                return 1;
-            }
-        } else {
-            // have exactly one byte
-            if (m_bytes_needed == 2) {
-                m_basic_header.b0 = buf[0];
-                m_bytes_needed--;
-                return 1;
-            } else {
-                m_basic_header.b1 = buf[0];
-                m_bytes_needed--;
-                return 1;
-            }
-        }
-    }
-
-    /// Reads bytes from buf into m_extended_header
-    size_t copy_extended_header_bytes(uint8_t const * buf, size_t len) {
-        size_t bytes_to_read = (std::min)(m_bytes_needed,len);
-
-        std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
-        m_cursor += bytes_to_read;
-        m_bytes_needed -= bytes_to_read;
-
-        return bytes_to_read;
-    }
-
-    /// Reads bytes from buf into message payload
-    /**
-     * This function performs unmasking and uncompression, validates the
-     * decoded bytes, and writes them to the appropriate message buffer.
-     *
-     * This member function will use the input buffer as stratch space for its
-     * work. The raw input bytes will not be preserved. This applies only to the
-     * bytes actually needed. At most min(m_bytes_needed,len) will be processed.
-     *
-     * @param buf Input/working buffer
-     * @param len Length of buf
-     * @return Number of bytes processed or zero in case of an error
-     */
-    size_t process_payload_bytes(uint8_t * buf, size_t len, lib::error_code& ec)
-    {
-        // unmask if masked
-        if (frame::get_masked(m_basic_header)) {
-            m_current_msg->prepared_key = frame::byte_mask_circ(
-                buf, len, m_current_msg->prepared_key);
-            // TODO: SIMD masking
-        }
-
-        std::string & out = m_current_msg->msg_ptr->get_raw_payload();
-        size_t offset = out.size();
-
-        // decompress message if needed.
-        if (m_permessage_deflate.is_enabled()
-            && m_current_msg->msg_ptr->get_compressed())
-        {
-            // Decompress current buffer into the message buffer
-            ec = m_permessage_deflate.decompress(buf,len,out);
-            if (ec) {
-                return 0;
-            }
-        } else {
-            // No compression, straight copy
-            out.append(reinterpret_cast<char *>(buf),len);
-        }
-
-        // validate unmasked, decompressed values
-        if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
-            if (!m_current_msg->validator.decode(out.begin()+offset,out.end())) {
-                ec = make_error_code(error::invalid_utf8);
-                return 0;
-            }
-        }
-
-        m_bytes_needed -= len;
-
-        return len;
-    }
-
-    /// Validate an incoming basic header
-    /**
-     * Validates an incoming hybi13 basic header.
-     *
-     * @param h The basic header to validate
-     * @param is_server Whether or not the endpoint that received this frame
-     * is a server.
-     * @param new_msg Whether or not this is the first frame of the message
-     * @return 0 on success or a non-zero error code on failure
-     */
-    lib::error_code validate_incoming_basic_header(frame::basic_header const & h,
-        bool is_server, bool new_msg) const
-    {
-        frame::opcode::value op = frame::get_opcode(h);
-
-        // Check control frame size limit
-        if (frame::opcode::is_control(op) &&
-            frame::get_basic_size(h) > frame::limits::payload_size_basic)
-        {
-            return make_error_code(error::control_too_big);
-        }
-
-        // Check that RSV bits are clear
-        // The only RSV bits allowed are rsv1 if the permessage_compress
-        // extension is enabled for this connection and the message is not
-        // a control message.
-        //
-        // TODO: unit tests for this
-        if (frame::get_rsv1(h) && (!m_permessage_deflate.is_enabled()
-                || frame::opcode::is_control(op)))
-        {
-            return make_error_code(error::invalid_rsv_bit);
-        }
-
-        if (frame::get_rsv2(h) || frame::get_rsv3(h)) {
-            return make_error_code(error::invalid_rsv_bit);
-        }
-
-        // Check for reserved opcodes
-        if (frame::opcode::reserved(op)) {
-            return make_error_code(error::invalid_opcode);
-        }
-
-        // Check for invalid opcodes
-        // TODO: unit tests for this?
-        if (frame::opcode::invalid(op)) {
-            return make_error_code(error::invalid_opcode);
-        }
-
-        // Check for fragmented control message
-        if (frame::opcode::is_control(op) && !frame::get_fin(h)) {
-            return make_error_code(error::fragmented_control);
-        }
-
-        // Check for continuation without an active message
-        if (new_msg && op == frame::opcode::CONTINUATION) {
-            return make_error_code(error::invalid_continuation);
-        }
-
-        // Check for new data frame when expecting continuation
-        if (!new_msg && !frame::opcode::is_control(op) &&
-            op != frame::opcode::CONTINUATION)
-        {
-            return make_error_code(error::invalid_continuation);
-        }
-
-        // Servers should reject any unmasked frames from clients.
-        // Clients should reject any masked frames from servers.
-        if (is_server && !frame::get_masked(h)) {
-            return make_error_code(error::masking_required);
-        } else if (!is_server && frame::get_masked(h)) {
-            return make_error_code(error::masking_forbidden);
-        }
-
-        return lib::error_code();
-    }
-
-    /// Validate an incoming extended header
-    /**
-     * Validates an incoming hybi13 full header.
-     *
-     * @todo unit test for the >32 bit frames on 32 bit systems case
-     *
-     * @param h The basic header to validate
-     * @param e The extended header to validate
-     * @return An error_code, non-zero values indicate why the validation
-     * failed
-     */
-    lib::error_code validate_incoming_extended_header(frame::basic_header h,
-        frame::extended_header e) const
-    {
-        uint8_t basic_size = frame::get_basic_size(h);
-        uint64_t payload_size = frame::get_payload_size(h,e);
-
-        // Check for non-minimally encoded payloads
-        if (basic_size == frame::payload_size_code_16bit &&
-            payload_size <= frame::limits::payload_size_basic)
-        {
-            return make_error_code(error::non_minimal_encoding);
-        }
-
-        if (basic_size == frame::payload_size_code_64bit &&
-            payload_size <= frame::limits::payload_size_extended)
-        {
-            return make_error_code(error::non_minimal_encoding);
-        }
-
-        // Check for >32bit frames on 32 bit systems
-        if (sizeof(size_t) == 4 && (payload_size >> 32)) {
-            return make_error_code(error::requires_64bit);
-        }
-
-        return lib::error_code();
-    }
-
-    /// Copy and mask/unmask in one operation
-    /**
-     * Reads input from one string and writes unmasked output to another.
-     *
-     * @param [in] i The input string.
-     * @param [out] o The output string.
-     * @param [in] key The masking key to use for masking/unmasking
-     */
-    void masked_copy (std::string const & i, std::string & o,
-        frame::masking_key_type key) const
-    {
-        frame::byte_mask(i.begin(),i.end(),o.begin(),key);
-        // TODO: SIMD masking
-    }
-
-    /// Generic prepare control frame with opcode and payload.
-    /**
-     * Internal control frame building method. Handles validation, masking, etc
-     *
-     * @param op The control opcode to use
-     * @param payload The payload to use
-     * @param out The message buffer to store the prepared frame in
-     * @return Status code, zero on success, non-zero on error
-     */
-    lib::error_code prepare_control(frame::opcode::value op,
-        std::string const & payload, message_ptr out) const
-    {
-        if (!out) {
-            return make_error_code(error::invalid_arguments);
-        }
-
-        if (!frame::opcode::is_control(op)) {
-            return make_error_code(error::invalid_opcode);
-        }
-
-        if (payload.size() > frame::limits::payload_size_basic) {
-            return make_error_code(error::control_too_big);
-        }
-
-        frame::masking_key_type key;
-        bool masked = !base::m_server;
-
-        frame::basic_header h(op,payload.size(),true,masked);
-
-        std::string & o = out->get_raw_payload();
-        o.resize(payload.size());
-
-        if (masked) {
-            // Generate masking key.
-            key.i = m_rng();
-
-            frame::extended_header e(payload.size(),key.i);
-            out->set_header(frame::prepare_header(h,e));
-            this->masked_copy(payload,o,key);
-        } else {
-            frame::extended_header e(payload.size());
-            out->set_header(frame::prepare_header(h,e));
-            std::copy(payload.begin(),payload.end(),o.begin());
-        }
-    
-        out->set_opcode(op);
-        out->set_prepared(true);
-
-        return lib::error_code();
-    }
-
-    enum state {
-        HEADER_BASIC = 0,
-        HEADER_EXTENDED = 1,
-        EXTENSION = 2,
-        APPLICATION = 3,
-        READY = 4,
-        FATAL_ERROR = 5
-    };
-
-    /// This data structure holds data related to processing a message, such as
-    /// the buffer it is being written to, its masking key, its UTF8 validation
-    /// state, and sometimes its compression state.
-    struct msg_metadata {
-        msg_metadata() {}
-        msg_metadata(message_ptr m, size_t p) : msg_ptr(m),prepared_key(p) {}
-        msg_metadata(message_ptr m, frame::masking_key_type p)
-          : msg_ptr(m)
-          , prepared_key(prepare_masking_key(p)) {}
-
-        message_ptr msg_ptr;        // pointer to the message data buffer
-        size_t      prepared_key;   // prepared masking key
-        utf8_validator::validator validator; // utf8 validation state
-    };
-
-    // Basic header of the frame being read
-    frame::basic_header m_basic_header;
-
-    // Pointer to a manager that can create message buffers for us.
-    msg_manager_ptr m_msg_manager;
-
-    // Number of bytes needed to complete the current operation
-    size_t m_bytes_needed;
-
-    // Number of extended header bytes read
-    size_t m_cursor;
-
-    // Metadata for the current data msg
-    msg_metadata m_data_msg;
-    // Metadata for the current control msg
-    msg_metadata m_control_msg;
-
-    // Pointer to the metadata associated with the frame being read
-    msg_metadata * m_current_msg;
-
-    // Extended header of current frame
-    frame::extended_header m_extended_header;
-
-    rng_type & m_rng;
-
-    // Overall state of the processor
-    state m_state;
-
-    // Extensions
-    permessage_deflate_type m_permessage_deflate;
-};
-
-} // namespace processor
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_PROCESSOR_HYBI13_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/processor.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/processor.hpp
deleted file mode 100644
index 5131cc4..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/processors/processor.hpp
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_PROCESSOR_HPP
-#define WEBSOCKETPP_PROCESSOR_HPP
-
-#include <websocketpp/processors/base.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <websocketpp/close.hpp>
-#include <websocketpp/utilities.hpp>
-#include <websocketpp/uri.hpp>
-
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace websocketpp {
-/// Processors encapsulate the protocol rules specific to each WebSocket version
-/**
- * The processors namespace includes a number of free functions that operate on
- * various WebSocket related data structures and perform processing that is not
- * related to specific versions of the protocol.
- *
- * It also includes the abstract interface for the protocol specific processing
- * engines. These engines wrap all of the logic necessary for parsing and
- * validating WebSocket handshakes and messages of specific protocol version
- * and set of allowed extensions.
- *
- * An instance of a processor represents the state of a single WebSocket
- * connection of the associated version. One processor instance is needed per
- * logical WebSocket connection.
- */
-namespace processor {
-
-/// Determine whether or not a generic HTTP request is a WebSocket handshake
-/**
- * @param r The HTTP request to read.
- *
- * @return True if the request is a WebSocket handshake, false otherwise
- */
-template <typename request_type>
-bool is_websocket_handshake(request_type& r) {
-    using utility::ci_find_substr;
-
-    std::string const & upgrade_header = r.get_header("Upgrade");
-
-    if (ci_find_substr(upgrade_header, constants::upgrade_token,
-        sizeof(constants::upgrade_token)-1) == upgrade_header.end())
-    {
-        return false;
-    }
-
-    std::string const & con_header = r.get_header("Connection");
-
-    if (ci_find_substr(con_header, constants::connection_token,
-        sizeof(constants::connection_token)-1) == con_header.end())
-    {
-        return false;
-    }
-
-    return true;
-}
-
-/// Extract the version from a WebSocket handshake request
-/**
- * A blank version header indicates a spec before versions were introduced.
- * The only such versions in shipping products are Hixie Draft 75 and Hixie
- * Draft 76. Draft 75 is present in Chrome 4-5 and Safari 5.0.0, Draft 76 (also
- * known as hybi 00 is present in Chrome 6-13 and Safari 5.0.1+. As
- * differentiating between these two sets of browsers is very difficult and
- * Safari 5.0.1+ accounts for the vast majority of cases in the wild this
- * function assumes that all handshakes without a valid version header are
- * Hybi 00.
- *
- * @param r The WebSocket handshake request to read.
- *
- * @return The WebSocket handshake version or -1 if there was an extraction
- * error.
- */
-template <typename request_type>
-int get_websocket_version(request_type& r) {
-    if (!r.ready()) {
-        return -2;
-    }
-    
-    if (r.get_header("Sec-WebSocket-Version").empty()) {
-        return 0;
-    }
-
-    int version;
-    std::istringstream ss(r.get_header("Sec-WebSocket-Version"));
-
-    if ((ss >> version).fail()) {
-        return -1;
-    }
-
-    return version;
-}
-
-/// Extract a URI ptr from the host header of the request
-/**
- * @param request The request to extract the Host header from.
- *
- * @param scheme The scheme under which this request was received (ws, wss,
- * http, https, etc)
- *
- * @return A uri_pointer that encodes the value of the host header.
- */
-template <typename request_type>
-uri_ptr get_uri_from_host(request_type & request, std::string scheme) {
-    std::string h = request.get_header("Host");
-
-    size_t last_colon = h.rfind(":");
-    size_t last_sbrace = h.rfind("]");
-
-    // no : = hostname with no port
-    // last : before ] = ipv6 literal with no port
-    // : with no ] = hostname with port
-    // : after ] = ipv6 literal with port
-    if (last_colon == std::string::npos ||
-        (last_sbrace != std::string::npos && last_sbrace > last_colon))
-    {
-        return lib::make_shared<uri>(scheme, h, request.get_uri());
-    } else {
-        return lib::make_shared<uri>(scheme,
-                               h.substr(0,last_colon),
-                               h.substr(last_colon+1),
-                               request.get_uri());
-    }
-}
-
-/// WebSocket protocol processor abstract base class
-template <typename config>
-class processor {
-public:
-    typedef processor<config> type;
-    typedef typename config::request_type request_type;
-    typedef typename config::response_type response_type;
-    typedef typename config::message_type::ptr message_ptr;
-    typedef std::pair<lib::error_code,std::string> err_str_pair;
-
-    explicit processor(bool secure, bool p_is_server)
-      : m_secure(secure)
-      , m_server(p_is_server)
-      , m_max_message_size(config::max_message_size)
-    {}
-
-    virtual ~processor() {}
-
-    /// Get the protocol version of this processor
-    virtual int get_version() const = 0;
-
-    /// Get maximum message size
-    /**
-     * Get maximum message size. Maximum message size determines the point at which the
-     * processor will fail a connection with the message_too_big protocol error.
-     *
-     * The default is retrieved from the max_message_size value from the template config
-     *
-     * @since 0.3.0
-     */
-    size_t get_max_message_size() const {
-        return m_max_message_size;
-    }
-    
-    /// Set maximum message size
-    /**
-     * Set maximum message size. Maximum message size determines the point at which the
-     * processor will fail a connection with the message_too_big protocol error.
-     *
-     * The default is retrieved from the max_message_size value from the template config
-     *
-     * @since 0.3.0
-     *
-     * @param new_value The value to set as the maximum message size.
-     */
-    void set_max_message_size(size_t new_value) {
-        m_max_message_size = new_value;
-    }
-
-    /// Returns whether or not the permessage_compress extension is implemented
-    /**
-     * Compile time flag that indicates whether this processor has implemented
-     * the permessage_compress extension. By default this is false.
-     */
-    virtual bool has_permessage_compress() const {
-        return false;
-    }
-
-    /// Initializes extensions based on the Sec-WebSocket-Extensions header
-    /**
-     * Reads the Sec-WebSocket-Extensions header and determines if any of the
-     * requested extensions are supported by this processor. If they are their
-     * settings data is initialized and an extension string to send to the
-     * is returned.
-     *
-     * @param request The request or response headers to look at.
-     */
-    virtual err_str_pair negotiate_extensions(request_type const &) {
-        return err_str_pair();
-    }
-    
-    /// Initializes extensions based on the Sec-WebSocket-Extensions header
-    /**
-     * Reads the Sec-WebSocket-Extensions header and determines if any of the
-     * requested extensions were accepted by the server. If they are their
-     * settings data is initialized. If they are not a list of required
-     * extensions (if any) is returned. This list may be sent back to the server
-     * as a part of the 1010/Extension required close code.
-     *
-     * @param response The request or response headers to look at.
-     */
-    virtual err_str_pair negotiate_extensions(response_type const &) {
-        return err_str_pair();
-    }
-
-    /// validate a WebSocket handshake request for this version
-    /**
-     * @param request The WebSocket handshake request to validate.
-     * is_websocket_handshake(request) must be true and
-     * get_websocket_version(request) must equal this->get_version().
-     *
-     * @return A status code, 0 on success, non-zero for specific sorts of
-     * failure
-     */
-    virtual lib::error_code validate_handshake(request_type const & request) const = 0;
-
-    /// Calculate the appropriate response for this websocket request
-    /**
-     * @param req The request to process
-     *
-     * @param subprotocol The subprotocol in use
-     *
-     * @param res The response to store the processed response in
-     *
-     * @return An error code, 0 on success, non-zero for other errors
-     */
-    virtual lib::error_code process_handshake(request_type const & req,
-        std::string const & subprotocol, response_type& res) const = 0;
-
-    /// Fill in an HTTP request for an outgoing connection handshake
-    /**
-     * @param req The request to process.
-     *
-     * @return An error code, 0 on success, non-zero for other errors
-     */
-    virtual lib::error_code client_handshake_request(request_type & req,
-        uri_ptr uri, std::vector<std::string> const & subprotocols) const = 0;
-
-    /// Validate the server's response to an outgoing handshake request
-    /**
-     * @param req The original request sent
-     * @param res The reponse to generate
-     * @return An error code, 0 on success, non-zero for other errors
-     */
-    virtual lib::error_code validate_server_handshake_response(request_type
-        const & req, response_type & res) const = 0;
-
-    /// Given a completed response, get the raw bytes to put on the wire
-    virtual std::string get_raw(response_type const & request) const = 0;
-
-    /// Return the value of the header containing the CORS origin.
-    virtual std::string const & get_origin(request_type const & request) const = 0;
-
-    /// Extracts requested subprotocols from a handshake request
-    /**
-     * Extracts a list of all subprotocols that the client has requested in the
-     * given opening handshake request.
-     *
-     * @param [in] req The request to extract from
-     * @param [out] subprotocol_list A reference to a vector of strings to store
-     * the results in.
-     */
-    virtual lib::error_code extract_subprotocols(const request_type & req,
-        std::vector<std::string> & subprotocol_list) = 0;
-
-    /// Extracts client uri from a handshake request
-    virtual uri_ptr get_uri(request_type const & request) const = 0;
-
-    /// process new websocket connection bytes
-    /**
-     * WebSocket connections are a continous stream of bytes that must be
-     * interpreted by a protocol processor into discrete frames.
-     *
-     * @param buf Buffer from which bytes should be read.
-     * @param len Length of buffer
-     * @param ec Reference to an error code to return any errors in
-     * @return Number of bytes processed
-     */
-    virtual size_t consume(uint8_t *buf, size_t len, lib::error_code & ec) = 0;
-
-    /// Checks if there is a message ready
-    /**
-     * Checks if the most recent consume operation processed enough bytes to
-     * complete a new WebSocket message. The message can be retrieved by calling
-     * get_message() which will reset the internal state to not-ready and allow
-     * consume to read more bytes.
-     *
-     * @return Whether or not a message is ready.
-     */
-    virtual bool ready() const = 0;
-
-    /// Retrieves the most recently processed message
-    /**
-     * Retrieves a shared pointer to the recently completed message if there is
-     * one. If ready() returns true then there is a message available.
-     * Retrieving the message with get_message will reset the state of ready.
-     * As such, each new message may be retrieved only once. Calling get_message
-     * when there is no message available will result in a null pointer being
-     * returned.
-     *
-     * @return A pointer to the most recently processed message or a null shared
-     *         pointer.
-     */
-    virtual message_ptr get_message() = 0;
-
-    /// Tests whether the processor is in a fatal error state
-    virtual bool get_error() const = 0;
-
-    /// Retrieves the number of bytes presently needed by the processor
-    /// This value may be used as a hint to the transport layer as to how many
-    /// bytes to wait for before running consume again.
-    virtual size_t get_bytes_needed() const {
-        return 1;
-    }
-
-    /// Prepare a data message for writing
-    /**
-     * Performs validation, masking, compression, etc. will return an error if
-     * there was an error, otherwise msg will be ready to be written
-     */
-    virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out) = 0;
-
-    /// Prepare a ping frame
-    /**
-     * Ping preparation is entirely state free. There is no payload validation
-     * other than length. Payload need not be UTF-8.
-     *
-     * @param in The string to use for the ping payload
-     * @param out The message buffer to prepare the ping in.
-     * @return Status code, zero on success, non-zero on failure
-     */
-    virtual lib::error_code prepare_ping(std::string const & in, message_ptr out) const 
-        = 0;
-
-    /// Prepare a pong frame
-    /**
-     * Pong preparation is entirely state free. There is no payload validation
-     * other than length. Payload need not be UTF-8.
-     *
-     * @param in The string to use for the pong payload
-     * @param out The message buffer to prepare the pong in.
-     * @return Status code, zero on success, non-zero on failure
-     */
-    virtual lib::error_code prepare_pong(std::string const & in, message_ptr out) const 
-        = 0;
-
-    /// Prepare a close frame
-    /**
-     * Close preparation is entirely state free. The code and reason are both
-     * subject to validation. Reason must be valid UTF-8. Code must be a valid
-     * un-reserved WebSocket close code. Use close::status::no_status to
-     * indicate no code. If no code is supplied a reason may not be specified.
-     *
-     * @param code The close code to send
-     * @param reason The reason string to send
-     * @param out The message buffer to prepare the fame in
-     * @return Status code, zero on success, non-zero on failure
-     */
-    virtual lib::error_code prepare_close(close::status::value code,
-        std::string const & reason, message_ptr out) const = 0;
-protected:
-    bool const m_secure;
-    bool const m_server;
-    size_t m_max_message_size;
-};
-
-} // namespace processor
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_PROCESSOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/none.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/none.hpp
deleted file mode 100644
index 2163e6f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/none.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_RANDOM_NONE_HPP
-#define WEBSOCKETPP_RANDOM_NONE_HPP
-
-namespace websocketpp {
-/// Random number generation policies
-namespace random {
-/// Stub RNG policy that always returns 0
-namespace none {
-
-/// Thread safe stub "random" integer generator.
-/**
- * This template class provides a random integer stub. The interface mimics the
- * WebSocket++ RNG generator classes but the generater function always returns
- * zero. This can be used to stub out the RNG for unit and performance testing.
- *
- * Call operator() to generate the next number
- */
-template <typename int_type>
-class int_generator {
-    public:
-        int_generator() {}
-
-        /// advances the engine's state and returns the generated value
-        int_type operator()() {
-            return 0;
-        }
-};
-
-} // namespace none
-} // namespace random
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_RANDOM_NONE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/random_device.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/random_device.hpp
deleted file mode 100644
index 91e7dd1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/random/random_device.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_RANDOM_RANDOM_DEVICE_HPP
-#define WEBSOCKETPP_RANDOM_RANDOM_DEVICE_HPP
-
-#include <websocketpp/common/random.hpp>
-
-namespace websocketpp {
-namespace random {
-/// RNG policy based on std::random_device or boost::random_device
-namespace random_device {
-
-/// Thread safe non-deterministic random integer generator.
-/**
- * This template class provides thread safe non-deterministic random integer
- * generation. Numbers are produced in a uniformly distributed range from the
- * smallest to largest value that int_type can store.
- *
- * Thread-safety is provided via locking based on the concurrency template
- * parameter.
- *
- * Non-deterministic RNG is provided via websocketpp::lib which uses either
- * C++11 or Boost 1.47+'s random_device class.
- *
- * Call operator() to generate the next number
- */
-template <typename int_type, typename concurrency>
-class int_generator {
-    public:
-        typedef typename concurrency::scoped_lock_type scoped_lock_type;
-        typedef typename concurrency::mutex_type mutex_type;
-
-        /// constructor
-        //mac TODO: figure out if signed types present a range problem
-        int_generator() {}
-
-        /// advances the engine's state and returns the generated value
-        int_type operator()() {
-            scoped_lock_type guard(m_lock);
-            return m_dis(m_rng);
-        }
-    private:
-
-
-        lib::random_device m_rng;
-        lib::uniform_int_distribution<int_type> m_dis;
-
-        mutex_type m_lock;
-};
-
-} // namespace random_device
-} // namespace random
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_RANDOM_RANDOM_DEVICE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/client_endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/client_endpoint.hpp
deleted file mode 100644
index 4d0c433..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/client_endpoint.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_CLIENT_ENDPOINT_HPP
-#define WEBSOCKETPP_CLIENT_ENDPOINT_HPP
-
-#include <websocketpp/endpoint.hpp>
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/system_error.hpp>
-
-#include <string>
-
-namespace websocketpp {
-
-/// Client endpoint role based on the given config
-/**
- *
- */
-template <typename config>
-class client : public endpoint<connection<config>,config> {
-public:
-    /// Type of this endpoint
-    typedef client<config> type;
-
-    /// Type of the endpoint concurrency component
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of the endpoint transport component
-    typedef typename config::transport_type transport_type;
-
-    /// Type of the connections this server will create
-    typedef connection<config> connection_type;
-    /// Type of a shared pointer to the connections this server will create
-    typedef typename connection_type::ptr connection_ptr;
-
-    /// Type of the connection transport component
-    typedef typename transport_type::transport_con_type transport_con_type;
-    /// Type of a shared pointer to the connection transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    /// Type of the endpoint component of this server
-    typedef endpoint<connection_type,config> endpoint_type;
-
-    friend class connection<config>;
-
-    explicit client() : endpoint_type(false)
-    {
-        endpoint_type::m_alog->write(log::alevel::devel, "client constructor");
-    }
-
-    /// Get a new connection
-    /**
-     * Creates and returns a pointer to a new connection to the given URI
-     * suitable for passing to connect(connection_ptr). This method allows
-     * applying connection specific settings before performing the opening
-     * handshake.
-     *
-     * @param [in] location URI to open the connection to as a uri_ptr
-     * @param [out] ec An status code indicating failure reasons, if any
-     *
-     * @return A connection_ptr to the new connection
-     */
-    connection_ptr get_connection(uri_ptr location, lib::error_code & ec) {
-        if (location->get_secure() && !transport_type::is_secure()) {
-            ec = error::make_error_code(error::endpoint_not_secure);
-            return connection_ptr();
-        }
-
-        connection_ptr con = endpoint_type::create_connection();
-
-        if (!con) {
-            ec = error::make_error_code(error::con_creation_failed);
-            return con;
-        }
-
-        con->set_uri(location);
-
-        ec = lib::error_code();
-        return con;
-    }
-
-    /// Get a new connection (string version)
-    /**
-     * Creates and returns a pointer to a new connection to the given URI
-     * suitable for passing to connect(connection_ptr). This overload allows
-     * default construction of the uri_ptr from a standard string.
-     *
-     * @param [in] u URI to open the connection to as a string
-     * @param [out] ec An status code indicating failure reasons, if any
-     *
-     * @return A connection_ptr to the new connection
-     */
-    connection_ptr get_connection(std::string const & u, lib::error_code & ec) {
-        uri_ptr location = lib::make_shared<uri>(u);
-
-        if (!location->get_valid()) {
-            ec = error::make_error_code(error::invalid_uri);
-            return connection_ptr();
-        }
-
-        return get_connection(location, ec);
-    }
-
-    /// Begin the connection process for the given connection
-    /**
-     * Initiates the opening connection handshake for connection con. Exact
-     * behavior depends on the underlying transport policy.
-     *
-     * @param con The connection to connect
-     *
-     * @return The pointer to the connection originally passed in.
-     */
-    connection_ptr connect(connection_ptr con) {
-        // Ask transport to perform a connection
-        transport_type::async_connect(
-            lib::static_pointer_cast<transport_con_type>(con),
-            con->get_uri(),
-            lib::bind(
-                &type::handle_connect,
-                this,
-                con,
-                lib::placeholders::_1
-            )
-        );
-
-        return con;
-    }
-private:
-    // handle_connect
-    void handle_connect(connection_ptr con, lib::error_code const & ec) {
-        if (ec) {
-            con->terminate(ec);
-
-            endpoint_type::m_elog->write(log::elevel::rerror,
-                    "handle_connect error: "+ec.message());
-        } else {
-            endpoint_type::m_alog->write(log::alevel::connect,
-                "Successful connection");
-
-            con->start();
-        }
-    }
-};
-
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_CLIENT_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/server_endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/server_endpoint.hpp
deleted file mode 100644
index 9cc652f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/roles/server_endpoint.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_SERVER_ENDPOINT_HPP
-#define WEBSOCKETPP_SERVER_ENDPOINT_HPP
-
-#include <websocketpp/endpoint.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/system_error.hpp>
-
-namespace websocketpp {
-
-/// Server endpoint role based on the given config
-/**
- *
- */
-template <typename config>
-class server : public endpoint<connection<config>,config> {
-public:
-    /// Type of this endpoint
-    typedef server<config> type;
-
-    /// Type of the endpoint concurrency component
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of the endpoint transport component
-    typedef typename config::transport_type transport_type;
-
-    /// Type of the connections this server will create
-    typedef connection<config> connection_type;
-    /// Type of a shared pointer to the connections this server will create
-    typedef typename connection_type::ptr connection_ptr;
-
-    /// Type of the connection transport component
-    typedef typename transport_type::transport_con_type transport_con_type;
-    /// Type of a shared pointer to the connection transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    /// Type of the endpoint component of this server
-    typedef endpoint<connection_type,config> endpoint_type;
-
-    friend class connection<config>;
-
-    explicit server() : endpoint_type(true)
-    {
-        endpoint_type::m_alog->write(log::alevel::devel, "server constructor");
-    }
-
-    /// Destructor
-    ~server<config>() {}
-
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    // no copy constructor because endpoints are not copyable
-    server<config>(server<config> &) = delete;
-
-    // no copy assignment operator because endpoints are not copyable
-    server<config> & operator=(server<config> const &) = delete;
-#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-    /// Move constructor
-    server<config>(server<config> && o) : endpoint<connection<config>,config>(std::move(o)) {}
-
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    // no move assignment operator because of const member variables
-    server<config> & operator=(server<config> &&) = delete;
-#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
-
-    /// Create and initialize a new connection
-    /**
-     * The connection will be initialized and ready to begin. Call its start()
-     * method to begin the processing loop.
-     *
-     * Note: The connection must either be started or terminated using
-     * connection::terminate in order to avoid memory leaks.
-     *
-     * @return A pointer to the new connection.
-     */
-    connection_ptr get_connection() {
-        return endpoint_type::create_connection();
-    }
-
-    /// Starts the server's async connection acceptance loop (exception free)
-    /**
-     * Initiates the server connection acceptance loop. Must be called after
-     * listen. This method will have no effect until the underlying io_service
-     * starts running. It may be called after the io_service is already running.
-     *
-     * Refer to documentation for the transport policy you are using for
-     * instructions on how to stop this acceptance loop.
-     *
-     * @param [out] ec A status code indicating an error, if any.
-     */
-    void start_accept(lib::error_code & ec) {
-        if (!transport_type::is_listening()) {
-            ec = error::make_error_code(error::async_accept_not_listening);
-            return;
-        }
-        
-        ec = lib::error_code();
-        connection_ptr con = get_connection();
-
-        if (!con) {
-          ec = error::make_error_code(error::con_creation_failed);
-          return;
-        }
-
-        transport_type::async_accept(
-            lib::static_pointer_cast<transport_con_type>(con),
-            lib::bind(&type::handle_accept,this,con,lib::placeholders::_1),
-            ec
-        );
-
-        if (ec && con) {
-            // If the connection was constructed but the accept failed,
-            // terminate the connection to prevent memory leaks
-            con->terminate(lib::error_code());
-        }
-    }
-
-    /// Starts the server's async connection acceptance loop
-    /**
-     * Initiates the server connection acceptance loop. Must be called after
-     * listen. This method will have no effect until the underlying io_service
-     * starts running. It may be called after the io_service is already running.
-     *
-     * Refer to documentation for the transport policy you are using for
-     * instructions on how to stop this acceptance loop.
-     */
-    void start_accept() {
-        lib::error_code ec;
-        start_accept(ec);
-        if (ec) {
-            throw exception(ec);
-        }
-    }
-
-    /// Handler callback for start_accept
-    void handle_accept(connection_ptr con, lib::error_code const & ec) {
-        if (ec) {
-            con->terminate(ec);
-
-            if (ec == error::operation_canceled) {
-                endpoint_type::m_elog->write(log::elevel::info,
-                    "handle_accept error: "+ec.message());
-            } else {
-                endpoint_type::m_elog->write(log::elevel::rerror,
-                    "handle_accept error: "+ec.message());
-            }
-        } else {
-            con->start();
-        }
-
-        lib::error_code start_ec;
-        start_accept(start_ec);
-        if (start_ec == error::async_accept_not_listening) {
-            endpoint_type::m_elog->write(log::elevel::info,
-                "Stopping acceptance of new connections because the underlying transport is no longer listening.");
-        } else if (start_ec) {
-            endpoint_type::m_elog->write(log::elevel::rerror,
-                "Restarting async_accept loop failed: "+ec.message());
-        }
-    }
-};
-
-} // namespace websocketpp
-
-#endif //WEBSOCKETPP_SERVER_ENDPOINT_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/server.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/server.hpp
deleted file mode 100644
index 342fa8c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/server.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_SERVER_HPP
-#define WEBSOCKETPP_SERVER_HPP
-
-#include <websocketpp/roles/server_endpoint.hpp>
-
-#endif //WEBSOCKETPP_SERVER_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/sha1/sha1.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/sha1/sha1.hpp
deleted file mode 100644
index 6b48d95..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/sha1/sha1.hpp
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
-*****
-sha1.hpp is a repackaging of the sha1.cpp and sha1.h files from the smallsha1
-library (http://code.google.com/p/smallsha1/) into a single header suitable for
-use as a header only library. This conversion was done by Peter Thorson
-(webmaster@zaphoyd.com) in 2013. All modifications to the code are redistributed
-under the same license as the original, which is listed below.
-*****
-
- Copyright (c) 2011, Micael Hildenborg
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Micael Hildenborg nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY Micael Hildenborg ''AS IS'' AND ANY
- EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL Micael Hildenborg BE LIABLE FOR ANY
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef SHA1_DEFINED
-#define SHA1_DEFINED
-
-namespace websocketpp {
-namespace sha1 {
-
-namespace { // local
-
-// Rotate an integer value to left.
-inline unsigned int rol(unsigned int value, unsigned int steps) {
-    return ((value << steps) | (value >> (32 - steps)));
-}
-
-// Sets the first 16 integers in the buffert to zero.
-// Used for clearing the W buffert.
-inline void clearWBuffert(unsigned int * buffert)
-{
-    for (int pos = 16; --pos >= 0;)
-    {
-        buffert[pos] = 0;
-    }
-}
-
-inline void innerHash(unsigned int * result, unsigned int * w)
-{
-    unsigned int a = result[0];
-    unsigned int b = result[1];
-    unsigned int c = result[2];
-    unsigned int d = result[3];
-    unsigned int e = result[4];
-
-    int round = 0;
-
-    #define sha1macro(func,val) \
-    { \
-        const unsigned int t = rol(a, 5) + (func) + e + val + w[round]; \
-        e = d; \
-        d = c; \
-        c = rol(b, 30); \
-        b = a; \
-        a = t; \
-    }
-
-    while (round < 16)
-    {
-        sha1macro((b & c) | (~b & d), 0x5a827999)
-        ++round;
-    }
-    while (round < 20)
-    {
-        w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-        sha1macro((b & c) | (~b & d), 0x5a827999)
-        ++round;
-    }
-    while (round < 40)
-    {
-        w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-        sha1macro(b ^ c ^ d, 0x6ed9eba1)
-        ++round;
-    }
-    while (round < 60)
-    {
-        w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-        sha1macro((b & c) | (b & d) | (c & d), 0x8f1bbcdc)
-        ++round;
-    }
-    while (round < 80)
-    {
-        w[round] = rol((w[round - 3] ^ w[round - 8] ^ w[round - 14] ^ w[round - 16]), 1);
-        sha1macro(b ^ c ^ d, 0xca62c1d6)
-        ++round;
-    }
-
-    #undef sha1macro
-
-    result[0] += a;
-    result[1] += b;
-    result[2] += c;
-    result[3] += d;
-    result[4] += e;
-}
-
-} // namespace
-
-/// Calculate a SHA1 hash
-/**
- * @param src points to any kind of data to be hashed.
- * @param bytelength the number of bytes to hash from the src pointer.
- * @param hash should point to a buffer of at least 20 bytes of size for storing
- * the sha1 result in.
- */
-inline void calc(void const * src, size_t bytelength, unsigned char * hash) {
-    // Init the result array.
-    unsigned int result[5] = { 0x67452301, 0xefcdab89, 0x98badcfe,
-                               0x10325476, 0xc3d2e1f0 };
-
-    // Cast the void src pointer to be the byte array we can work with.
-    unsigned char const * sarray = (unsigned char const *) src;
-
-    // The reusable round buffer
-    unsigned int w[80];
-
-    // Loop through all complete 64byte blocks.
-
-    size_t endCurrentBlock;
-    size_t currentBlock = 0;
-
-    if (bytelength >= 64) {
-        size_t const endOfFullBlocks = bytelength - 64;
-
-        while (currentBlock <= endOfFullBlocks) {
-            endCurrentBlock = currentBlock + 64;
-
-            // Init the round buffer with the 64 byte block data.
-            for (int roundPos = 0; currentBlock < endCurrentBlock; currentBlock += 4)
-            {
-                // This line will swap endian on big endian and keep endian on
-                // little endian.
-                w[roundPos++] = (unsigned int) sarray[currentBlock + 3]
-                        | (((unsigned int) sarray[currentBlock + 2]) << 8)
-                        | (((unsigned int) sarray[currentBlock + 1]) << 16)
-                        | (((unsigned int) sarray[currentBlock]) << 24);
-            }
-            innerHash(result, w);
-        }
-    }
-
-    // Handle the last and not full 64 byte block if existing.
-    endCurrentBlock = bytelength - currentBlock;
-    clearWBuffert(w);
-    size_t lastBlockBytes = 0;
-    for (;lastBlockBytes < endCurrentBlock; ++lastBlockBytes) {
-        w[lastBlockBytes >> 2] |= (unsigned int) sarray[lastBlockBytes + currentBlock] << ((3 - (lastBlockBytes & 3)) << 3);
-    }
-
-    w[lastBlockBytes >> 2] |= 0x80 << ((3 - (lastBlockBytes & 3)) << 3);
-    if (endCurrentBlock >= 56) {
-        innerHash(result, w);
-        clearWBuffert(w);
-    }
-    w[15] = bytelength << 3;
-    innerHash(result, w);
-
-    // Store hash in result pointer, and make sure we get in in the correct
-    // order on both endian models.
-    for (int hashByte = 20; --hashByte >= 0;) {
-        hash[hashByte] = (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;
-    }
-}
-
-} // namespace sha1
-} // namespace websocketpp
-
-#endif // SHA1_DEFINED
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/base.hpp
deleted file mode 100644
index b945fe1..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/base.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_ASIO_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_ASIO_BASE_HPP
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/type_traits.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-/// Transport policy that uses asio
-/**
- * This policy uses a single asio io_service to provide transport
- * services to a WebSocket++ endpoint.
- */
-namespace asio {
-
-// Class to manage the memory to be used for handler-based custom allocation.
-// It contains a single block of memory which may be returned for allocation
-// requests. If the memory is in use when an allocation request is made, the
-// allocator delegates allocation to the global heap.
-class handler_allocator {
-public:
-    static const size_t size = 1024;
-    
-    handler_allocator() : m_in_use(false) {}
-
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-	handler_allocator(handler_allocator const & cpy) = delete;
-	handler_allocator & operator =(handler_allocator const &) = delete;
-#endif
-
-    void * allocate(std::size_t memsize) {
-        if (!m_in_use && memsize < size) {
-            m_in_use = true;
-            return static_cast<void*>(&m_storage);
-        } else {
-            return ::operator new(memsize);
-        }
-    }
-
-    void deallocate(void * pointer) {
-        if (pointer == &m_storage) {
-            m_in_use = false;
-        } else {
-            ::operator delete(pointer);
-        }
-    }
-
-private:
-    // Storage space used for handler-based custom memory allocation.
-    lib::aligned_storage<size>::type m_storage;
-
-    // Whether the handler-based custom allocation storage has been used.
-    bool m_in_use;
-};
-
-// Wrapper class template for handler objects to allow handler memory
-// allocation to be customised. Calls to operator() are forwarded to the
-// encapsulated handler.
-template <typename Handler>
-class custom_alloc_handler {
-public:
-    custom_alloc_handler(handler_allocator& a, Handler h)
-      : allocator_(a),
-        handler_(h)
-    {}
-
-    template <typename Arg1>
-    void operator()(Arg1 arg1) {
-        handler_(arg1);
-    }
-
-    template <typename Arg1, typename Arg2>
-    void operator()(Arg1 arg1, Arg2 arg2) {
-        handler_(arg1, arg2);
-    }
-
-    friend void* asio_handler_allocate(std::size_t size,
-        custom_alloc_handler<Handler> * this_handler)
-    {
-        return this_handler->allocator_.allocate(size);
-    }
-
-    friend void asio_handler_deallocate(void* pointer, std::size_t /*size*/,
-        custom_alloc_handler<Handler> * this_handler)
-    {
-        this_handler->allocator_.deallocate(pointer);
-    }
-
-private:
-    handler_allocator & allocator_;
-    Handler handler_;
-};
-
-// Helper function to wrap a handler object to add custom allocation.
-template <typename Handler>
-inline custom_alloc_handler<Handler> make_custom_alloc_handler(
-    handler_allocator & a, Handler h)
-{
-    return custom_alloc_handler<Handler>(a, h);
-}
-
-
-
-
-
-
-
-// Forward declaration of class endpoint so that it can be friended/referenced
-// before being included.
-template <typename config>
-class endpoint;
-
-typedef lib::function<void (lib::asio::error_code const & ec,
-    size_t bytes_transferred)> async_read_handler;
-
-typedef lib::function<void (lib::asio::error_code const & ec,
-    size_t bytes_transferred)> async_write_handler;
-
-typedef lib::function<void (lib::error_code const & ec)> pre_init_handler;
-
-// handle_timer: dynamic parameters, multiple copies
-// handle_proxy_write
-// handle_proxy_read
-// handle_async_write
-// handle_pre_init
-
-
-/// Asio transport errors
-namespace error {
-enum value {
-    /// Catch-all error for transport policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// async_read_at_least call requested more bytes than buffer can store
-    invalid_num_bytes,
-
-    /// there was an error in the underlying transport library
-    pass_through,
-
-    /// The connection to the requested proxy server failed
-    proxy_failed,
-
-    /// Invalid Proxy URI
-    proxy_invalid,
-
-    /// Invalid host or service
-    invalid_host_service
-};
-
-/// Asio transport error category
-class category : public lib::error_category {
-public:
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport.asio";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case error::general:
-                return "Generic asio transport policy error";
-            case error::invalid_num_bytes:
-                return "async_read_at_least call requested more bytes than buffer can store";
-            case error::pass_through:
-                return "Underlying Transport Error";
-            case error::proxy_failed:
-                return "Proxy connection failed";
-            case error::proxy_invalid:
-                return "Invalid proxy URI";
-            case error::invalid_host_service:
-                return "Invalid host or service";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the asio transport error category
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-/// Create an error code with the given value and the asio transport category
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::transport::asio::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-#endif // WEBSOCKETPP_TRANSPORT_ASIO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/connection.hpp
deleted file mode 100644
index 57dda74..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/connection.hpp
+++ /dev/null
@@ -1,1197 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_ASIO_CON_HPP
-#define WEBSOCKETPP_TRANSPORT_ASIO_CON_HPP
-
-#include <websocketpp/transport/asio/base.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-#include <websocketpp/http/constants.hpp>
-
-#include <websocketpp/base64/base64.hpp>
-#include <websocketpp/error.hpp>
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/chrono.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/connection_hdl.hpp>
-
-#include <istream>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace transport {
-namespace asio {
-
-typedef lib::function<void(connection_hdl)> tcp_init_handler;
-
-/// Asio based connection transport component
-/**
- * transport::asio::connection implements a connection transport component using
- * Asio that works with the transport::asio::endpoint endpoint transport
- * component.
- */
-template <typename config>
-class connection : public config::socket_type::socket_con_type {
-public:
-    /// Type of this connection transport component
-    typedef connection<config> type;
-    /// Type of a shared pointer to this connection transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of the socket connection component
-    typedef typename config::socket_type::socket_con_type socket_con_type;
-    /// Type of a shared pointer to the socket connection component
-    typedef typename socket_con_type::ptr socket_con_ptr;
-    /// Type of this transport's access logging policy
-    typedef typename config::alog_type alog_type;
-    /// Type of this transport's error logging policy
-    typedef typename config::elog_type elog_type;
-
-    typedef typename config::request_type request_type;
-    typedef typename request_type::ptr request_ptr;
-    typedef typename config::response_type response_type;
-    typedef typename response_type::ptr response_ptr;
-
-    /// Type of a pointer to the Asio io_service being used
-    typedef lib::asio::io_service * io_service_ptr;
-    /// Type of a pointer to the Asio io_service::strand being used
-    typedef lib::shared_ptr<lib::asio::io_service::strand> strand_ptr;
-    /// Type of a pointer to the Asio timer class
-    typedef lib::shared_ptr<lib::asio::steady_timer> timer_ptr;
-
-    // connection is friends with its associated endpoint to allow the endpoint
-    // to call private/protected utility methods that we don't want to expose
-    // to the public api.
-    friend class endpoint<config>;
-
-    // generate and manage our own io_service
-    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
-      : m_is_server(is_server)
-      , m_alog(alog)
-      , m_elog(elog)
-    {
-        m_alog->write(log::alevel::devel,"asio con transport constructor");
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return lib::static_pointer_cast<type>(socket_con_type::get_shared());
-    }
-
-    bool is_secure() const {
-        return socket_con_type::is_secure();
-    }
-
-    /// Set uri hook
-    /**
-     * Called by the endpoint as a connection is being established to provide
-     * the uri being connected to to the transport layer.
-     *
-     * This transport policy doesn't use the uri except to forward it to the 
-     * socket layer.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr u) {
-        socket_con_type::set_uri(u);
-    }
-
-    /// Sets the tcp pre init handler
-    /**
-     * The tcp pre init handler is called after the raw tcp connection has been
-     * established but before any additional wrappers (proxy connects, TLS
-     * handshakes, etc) have been performed.
-     *
-     * @since 0.3.0
-     *
-     * @param h The handler to call on tcp pre init.
-     */
-    void set_tcp_pre_init_handler(tcp_init_handler h) {
-        m_tcp_pre_init_handler = h;
-    }
-
-    /// Sets the tcp pre init handler (deprecated)
-    /**
-     * The tcp pre init handler is called after the raw tcp connection has been
-     * established but before any additional wrappers (proxy connects, TLS
-     * handshakes, etc) have been performed.
-     *
-     * @deprecated Use set_tcp_pre_init_handler instead
-     *
-     * @param h The handler to call on tcp pre init.
-     */
-    void set_tcp_init_handler(tcp_init_handler h) {
-        set_tcp_pre_init_handler(h);
-    }
-
-    /// Sets the tcp post init handler
-    /**
-     * The tcp post init handler is called after the tcp connection has been
-     * established and all additional wrappers (proxy connects, TLS handshakes,
-     * etc have been performed. This is fired before any bytes are read or any
-     * WebSocket specific handshake logic has been performed.
-     *
-     * @since 0.3.0
-     *
-     * @param h The handler to call on tcp post init.
-     */
-    void set_tcp_post_init_handler(tcp_init_handler h) {
-        m_tcp_post_init_handler = h;
-    }
-
-    /// Set the proxy to connect through (exception free)
-    /**
-     * The URI passed should be a complete URI including scheme. For example:
-     * http://proxy.example.com:8080/
-     *
-     * The proxy must be set up as an explicit (CONNECT) proxy allowed to
-     * connect to the port you specify. Traffic to the proxy is not encrypted.
-     *
-     * @param uri The full URI of the proxy to connect to.
-     *
-     * @param ec A status value
-     */
-    void set_proxy(std::string const & uri, lib::error_code & ec) {
-        // TODO: return errors for illegal URIs here?
-        // TODO: should https urls be illegal for the moment?
-        m_proxy = uri;
-        m_proxy_data = lib::make_shared<proxy_data>();
-        ec = lib::error_code();
-    }
-
-    /// Set the proxy to connect through (exception)
-    void set_proxy(std::string const & uri) {
-        lib::error_code ec;
-        set_proxy(uri,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Set the basic auth credentials to use (exception free)
-    /**
-     * The URI passed should be a complete URI including scheme. For example:
-     * http://proxy.example.com:8080/
-     *
-     * The proxy must be set up as an explicit proxy
-     *
-     * @param username The username to send
-     *
-     * @param password The password to send
-     *
-     * @param ec A status value
-     */
-    void set_proxy_basic_auth(std::string const & username, std::string const &
-        password, lib::error_code & ec)
-    {
-        if (!m_proxy_data) {
-            ec = make_error_code(websocketpp::error::invalid_state);
-            return;
-        }
-
-        // TODO: username can't contain ':'
-        std::string val = "Basic "+base64_encode(username + ":" + password);
-        m_proxy_data->req.replace_header("Proxy-Authorization",val);
-        ec = lib::error_code();
-    }
-
-    /// Set the basic auth credentials to use (exception)
-    void set_proxy_basic_auth(std::string const & username, std::string const &
-        password)
-    {
-        lib::error_code ec;
-        set_proxy_basic_auth(username,password,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Set the proxy timeout duration (exception free)
-    /**
-     * Duration is in milliseconds. Default value is based on the transport
-     * config
-     *
-     * @param duration The number of milliseconds to wait before aborting the
-     * proxy connection.
-     *
-     * @param ec A status value
-     */
-    void set_proxy_timeout(long duration, lib::error_code & ec) {
-        if (!m_proxy_data) {
-            ec = make_error_code(websocketpp::error::invalid_state);
-            return;
-        }
-
-        m_proxy_data->timeout_proxy = duration;
-        ec = lib::error_code();
-    }
-
-    /// Set the proxy timeout duration (exception)
-    void set_proxy_timeout(long duration) {
-        lib::error_code ec;
-        set_proxy_timeout(duration,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    std::string const & get_proxy() const {
-        return m_proxy;
-    }
-
-    /// Get the remote endpoint address
-    /**
-     * The iostream transport has no information about the ultimate remote
-     * endpoint. It will return the string "iostream transport". To indicate
-     * this.
-     *
-     * TODO: allow user settable remote endpoint addresses if this seems useful
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint() const {
-        lib::error_code ec;
-
-        std::string ret = socket_con_type::get_remote_endpoint(ec);
-
-        if (ec) {
-            m_elog->write(log::elevel::info,ret);
-            return "Unknown";
-        } else {
-            return ret;
-        }
-    }
-
-    /// Get the connection handle
-    connection_hdl get_handle() const {
-        return m_connection_hdl;
-    }
-
-    /// Call back a function after a period of time.
-    /**
-     * Sets a timer that calls back a function after the specified period of
-     * milliseconds. Returns a handle that can be used to cancel the timer.
-     * A cancelled timer will return the error code error::operation_aborted
-     * A timer that expired will return no error.
-     *
-     * @param duration Length of time to wait in milliseconds
-     *
-     * @param callback The function to call back when the timer has expired
-     *
-     * @return A handle that can be used to cancel the timer if it is no longer
-     * needed.
-     */
-    timer_ptr set_timer(long duration, timer_handler callback) {
-        timer_ptr new_timer(
-            new lib::asio::steady_timer(
-                *m_io_service,
-                lib::asio::milliseconds(duration))
-        );
-
-        if (config::enable_multithreading) {
-            new_timer->async_wait(m_strand->wrap(lib::bind(
-                &type::handle_timer, get_shared(),
-                new_timer,
-                callback,
-                lib::placeholders::_1
-            )));
-        } else {
-            new_timer->async_wait(lib::bind(
-                &type::handle_timer, get_shared(),
-                new_timer,
-                callback,
-                lib::placeholders::_1
-            ));
-        }
-
-        return new_timer;
-    }
-
-    /// Timer callback
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * TODO: candidate for protected status
-     *
-     * @param post_timer Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec The status code
-     */
-    void handle_timer(timer_ptr, timer_handler callback,
-        lib::asio::error_code const & ec)
-    {
-        if (ec) {
-            if (ec == lib::asio::error::operation_aborted) {
-                callback(make_error_code(transport::error::operation_aborted));
-            } else {
-                log_err(log::elevel::info,"asio handle_timer",ec);
-                callback(make_error_code(error::pass_through));
-            }
-        } else {
-            callback(lib::error_code());
-        }
-    }
-
-    /// Get a pointer to this connection's strand
-    strand_ptr get_strand() {
-        return m_strand;
-    }
-
-    /// Get the internal transport error code for a closed/failed connection
-    /**
-     * Retrieves a machine readable detailed error code indicating the reason
-     * that the connection was closed or failed. Valid only after the close or
-     * fail handler is called.
-     *
-     * Primarily used if you are using mismatched asio / system_error
-     * implementations such as `boost::asio` with `std::system_error`. In these
-     * cases the transport error type is different than the library error type
-     * and some WebSocket++ functions that return transport errors via the 
-     * library error code type will be coerced into a catch all `pass_through`
-     * or `tls_error` error. This method will return the original machine 
-     * readable transport error in the native type.
-     *
-     * @since 0.7.0
-     *
-     * @return Error code indicating the reason the connection was closed or 
-     * failed
-     */
-    lib::asio::error_code get_transport_ec() const {
-        return m_tec;
-    }
-
-    /// Initialize transport for reading
-    /**
-     * init_asio is called once immediately after construction to initialize
-     * Asio components to the io_service
-     *
-     * The transport initialization sequence consists of the following steps:
-     * - Pre-init: the underlying socket is initialized to the point where
-     * bytes may be written. No bytes are actually written in this stage
-     * - Proxy negotiation: if a proxy is set, a request is made to it to start
-     * a tunnel to the final destination. This stage ends when the proxy is
-     * ready to forward the
-     * next byte to the remote endpoint.
-     * - Post-init: Perform any i/o with the remote endpoint, such as setting up
-     * tunnels for encryption. This stage ends when the connection is ready to
-     * read or write the WebSocket handshakes. At this point the original
-     * callback function is called.
-     */
-protected:
-    void init(init_handler callback) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection init");
-        }
-
-        // TODO: pre-init timeout. Right now no implemented socket policies
-        // actually have an asyncronous pre-init
-
-        socket_con_type::pre_init(
-            lib::bind(
-                &type::handle_pre_init,
-                get_shared(),
-                callback,
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    /// initialize the proxy buffers and http parsers
-    /**
-     *
-     * @param authority The address of the server we want the proxy to tunnel to
-     * in the format of a URI authority (host:port)
-     *
-     * @return Status code indicating what errors occurred, if any
-     */
-    lib::error_code proxy_init(std::string const & authority) {
-        if (!m_proxy_data) {
-            return websocketpp::error::make_error_code(
-                websocketpp::error::invalid_state);
-        }
-        m_proxy_data->req.set_version("HTTP/1.1");
-        m_proxy_data->req.set_method("CONNECT");
-
-        m_proxy_data->req.set_uri(authority);
-        m_proxy_data->req.replace_header("Host",authority);
-
-        return lib::error_code();
-    }
-
-    /// Finish constructing the transport
-    /**
-     * init_asio is called once immediately after construction to initialize
-     * Asio components to the io_service.
-     *
-     * @param io_service A pointer to the io_service to register with this
-     * connection
-     *
-     * @return Status code for the success or failure of the initialization
-     */
-    lib::error_code init_asio (io_service_ptr io_service) {
-        m_io_service = io_service;
-
-        if (config::enable_multithreading) {
-            m_strand.reset(new lib::asio::io_service::strand(*io_service));
-        }
-
-        lib::error_code ec = socket_con_type::init_asio(io_service, m_strand,
-            m_is_server);
-
-        return ec;
-    }
-
-    void handle_pre_init(init_handler callback, lib::error_code const & ec) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection handle pre_init");
-        }
-
-        if (m_tcp_pre_init_handler) {
-            m_tcp_pre_init_handler(m_connection_hdl);
-        }
-
-        if (ec) {
-            callback(ec);
-        }
-
-        // If we have a proxy set issue a proxy connect, otherwise skip to
-        // post_init
-        if (!m_proxy.empty()) {
-            proxy_write(callback);
-        } else {
-            post_init(callback);
-        }
-    }
-
-    void post_init(init_handler callback) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection post_init");
-        }
-
-        timer_ptr post_timer;
-        
-        if (config::timeout_socket_post_init > 0) {
-            post_timer = set_timer(
-                config::timeout_socket_post_init,
-                lib::bind(
-                    &type::handle_post_init_timeout,
-                    get_shared(),
-                    post_timer,
-                    callback,
-                    lib::placeholders::_1
-                )
-            );
-        }
-
-        socket_con_type::post_init(
-            lib::bind(
-                &type::handle_post_init,
-                get_shared(),
-                post_timer,
-                callback,
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    /// Post init timeout callback
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * @param post_timer Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec The status code
-     */
-    void handle_post_init_timeout(timer_ptr, init_handler callback,
-        lib::error_code const & ec)
-    {
-        lib::error_code ret_ec;
-
-        if (ec) {
-            if (ec == transport::error::operation_aborted) {
-                m_alog->write(log::alevel::devel,
-                    "asio post init timer cancelled");
-                return;
-            }
-
-            log_err(log::elevel::devel,"asio handle_post_init_timeout",ec);
-            ret_ec = ec;
-        } else {
-            if (socket_con_type::get_ec()) {
-                ret_ec = socket_con_type::get_ec();
-            } else {
-                ret_ec = make_error_code(transport::error::timeout);
-            }
-        }
-
-        m_alog->write(log::alevel::devel, "Asio transport post-init timed out");
-        cancel_socket_checked();
-        callback(ret_ec);
-    }
-
-    /// Post init timeout callback
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * @param post_timer Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec The status code
-     */
-    void handle_post_init(timer_ptr post_timer, init_handler callback,
-        lib::error_code const & ec)
-    {
-        if (ec == transport::error::operation_aborted ||
-            (post_timer && lib::asio::is_neg(post_timer->expires_from_now())))
-        {
-            m_alog->write(log::alevel::devel,"post_init cancelled");
-            return;
-        }
-
-        if (post_timer) {
-            post_timer->cancel();
-        }
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection handle_post_init");
-        }
-
-        if (m_tcp_post_init_handler) {
-            m_tcp_post_init_handler(m_connection_hdl);
-        }
-
-        callback(ec);
-    }
-
-    void proxy_write(init_handler callback) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection proxy_write");
-        }
-
-        if (!m_proxy_data) {
-            m_elog->write(log::elevel::library,
-                "assertion failed: !m_proxy_data in asio::connection::proxy_write");
-            callback(make_error_code(error::general));
-            return;
-        }
-
-        m_proxy_data->write_buf = m_proxy_data->req.raw();
-
-        m_bufs.push_back(lib::asio::buffer(m_proxy_data->write_buf.data(),
-                                           m_proxy_data->write_buf.size()));
-
-        m_alog->write(log::alevel::devel,m_proxy_data->write_buf);
-
-        // Set a timer so we don't wait forever for the proxy to respond
-        m_proxy_data->timer = this->set_timer(
-            m_proxy_data->timeout_proxy,
-            lib::bind(
-                &type::handle_proxy_timeout,
-                get_shared(),
-                callback,
-                lib::placeholders::_1
-            )
-        );
-
-        // Send proxy request
-        if (config::enable_multithreading) {
-            lib::asio::async_write(
-                socket_con_type::get_next_layer(),
-                m_bufs,
-                m_strand->wrap(lib::bind(
-                    &type::handle_proxy_write, get_shared(),
-                    callback,
-                    lib::placeholders::_1
-                ))
-            );
-        } else {
-            lib::asio::async_write(
-                socket_con_type::get_next_layer(),
-                m_bufs,
-                lib::bind(
-                    &type::handle_proxy_write, get_shared(),
-                    callback,
-                    lib::placeholders::_1
-                )
-            );
-        }
-    }
-
-    void handle_proxy_timeout(init_handler callback, lib::error_code const & ec)
-    {
-        if (ec == transport::error::operation_aborted) {
-            m_alog->write(log::alevel::devel,
-                "asio handle_proxy_write timer cancelled");
-            return;
-        } else if (ec) {
-            log_err(log::elevel::devel,"asio handle_proxy_write",ec);
-            callback(ec);
-        } else {
-            m_alog->write(log::alevel::devel,
-                "asio handle_proxy_write timer expired");
-            cancel_socket_checked();
-            callback(make_error_code(transport::error::timeout));
-        }
-    }
-
-    void handle_proxy_write(init_handler callback,
-        lib::asio::error_code const & ec)
-    {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,
-                "asio connection handle_proxy_write");
-        }
-
-        m_bufs.clear();
-
-        // Timer expired or the operation was aborted for some reason.
-        // Whatever aborted it will be issuing the callback so we are safe to
-        // return
-        if (ec == lib::asio::error::operation_aborted ||
-            lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
-        {
-            m_elog->write(log::elevel::devel,"write operation aborted");
-            return;
-        }
-
-        if (ec) {
-            log_err(log::elevel::info,"asio handle_proxy_write",ec);
-            m_proxy_data->timer->cancel();
-            callback(make_error_code(error::pass_through));
-            return;
-        }
-
-        proxy_read(callback);
-    }
-
-    void proxy_read(init_handler callback) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection proxy_read");
-        }
-
-        if (!m_proxy_data) {
-            m_elog->write(log::elevel::library,
-                "assertion failed: !m_proxy_data in asio::connection::proxy_read");
-            m_proxy_data->timer->cancel();
-            callback(make_error_code(error::general));
-            return;
-        }
-
-        if (config::enable_multithreading) {
-            lib::asio::async_read_until(
-                socket_con_type::get_next_layer(),
-                m_proxy_data->read_buf,
-                "\r\n\r\n",
-                m_strand->wrap(lib::bind(
-                    &type::handle_proxy_read, get_shared(),
-                    callback,
-                    lib::placeholders::_1, lib::placeholders::_2
-                ))
-            );
-        } else {
-            lib::asio::async_read_until(
-                socket_con_type::get_next_layer(),
-                m_proxy_data->read_buf,
-                "\r\n\r\n",
-                lib::bind(
-                    &type::handle_proxy_read, get_shared(),
-                    callback,
-                    lib::placeholders::_1, lib::placeholders::_2
-                )
-            );
-        }
-    }
-
-    /// Proxy read callback
-    /**
-     * @param init_handler The function to call back
-     * @param ec The status code
-     * @param bytes_transferred The number of bytes read
-     */
-    void handle_proxy_read(init_handler callback,
-        lib::asio::error_code const & ec, size_t)
-    {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,
-                "asio connection handle_proxy_read");
-        }
-
-        // Timer expired or the operation was aborted for some reason.
-        // Whatever aborted it will be issuing the callback so we are safe to
-        // return
-        if (ec == lib::asio::error::operation_aborted ||
-            lib::asio::is_neg(m_proxy_data->timer->expires_from_now()))
-        {
-            m_elog->write(log::elevel::devel,"read operation aborted");
-            return;
-        }
-
-        // At this point there is no need to wait for the timer anymore
-        m_proxy_data->timer->cancel();
-
-        if (ec) {
-            m_elog->write(log::elevel::info,
-                "asio handle_proxy_read error: "+ec.message());
-            callback(make_error_code(error::pass_through));
-        } else {
-            if (!m_proxy_data) {
-                m_elog->write(log::elevel::library,
-                    "assertion failed: !m_proxy_data in asio::connection::handle_proxy_read");
-                callback(make_error_code(error::general));
-                return;
-            }
-
-            std::istream input(&m_proxy_data->read_buf);
-
-            m_proxy_data->res.consume(input);
-
-            if (!m_proxy_data->res.headers_ready()) {
-                // we read until the headers were done in theory but apparently
-                // they aren't. Internal endpoint error.
-                callback(make_error_code(error::general));
-                return;
-            }
-
-            m_alog->write(log::alevel::devel,m_proxy_data->res.raw());
-
-            if (m_proxy_data->res.get_status_code() != http::status_code::ok) {
-                // got an error response back
-                // TODO: expose this error in a programmatically accessible way?
-                // if so, see below for an option on how to do this.
-                std::stringstream s;
-                s << "Proxy connection error: "
-                  << m_proxy_data->res.get_status_code()
-                  << " ("
-                  << m_proxy_data->res.get_status_msg()
-                  << ")";
-                m_elog->write(log::elevel::info,s.str());
-                callback(make_error_code(error::proxy_failed));
-                return;
-            }
-
-            // we have successfully established a connection to the proxy, now
-            // we can continue and the proxy will transparently forward the
-            // WebSocket connection.
-
-            // TODO: decide if we want an on_proxy callback that would allow
-            // access to the proxy response.
-
-            // free the proxy buffers and req/res objects as they aren't needed
-            // anymore
-            m_proxy_data.reset();
-
-            // Continue with post proxy initialization
-            post_init(callback);
-        }
-    }
-
-    /// read at least num_bytes bytes into buf and then call handler.
-    void async_read_at_least(size_t num_bytes, char *buf, size_t len,
-        read_handler handler)
-    {
-        if (m_alog->static_test(log::alevel::devel)) {
-            std::stringstream s;
-            s << "asio async_read_at_least: " << num_bytes;
-            m_alog->write(log::alevel::devel,s.str());
-        }
-
-        // TODO: safety vs speed ?
-        // maybe move into an if devel block
-        /*if (num_bytes > len) {
-            m_elog->write(log::elevel::devel,
-                "asio async_read_at_least error::invalid_num_bytes");
-            handler(make_error_code(transport::error::invalid_num_bytes),
-                size_t(0));
-            return;
-        }*/
-
-        if (config::enable_multithreading) {
-            lib::asio::async_read(
-                socket_con_type::get_socket(),
-                lib::asio::buffer(buf,len),
-                lib::asio::transfer_at_least(num_bytes),
-                m_strand->wrap(make_custom_alloc_handler(
-                    m_read_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_read, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                ))
-            );
-        } else {
-            lib::asio::async_read(
-                socket_con_type::get_socket(),
-                lib::asio::buffer(buf,len),
-                lib::asio::transfer_at_least(num_bytes),
-                make_custom_alloc_handler(
-                    m_read_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_read, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                )
-            );    
-        }
-        
-    }
-
-    void handle_async_read(read_handler handler, lib::asio::error_code const & ec,
-        size_t bytes_transferred)
-    {
-        m_alog->write(log::alevel::devel, "asio con handle_async_read");
-
-        // translate asio error codes into more lib::error_codes
-        lib::error_code tec;
-        if (ec == lib::asio::error::eof) {
-            tec = make_error_code(transport::error::eof);
-        } else if (ec) {
-            // We don't know much more about the error at this point. As our
-            // socket/security policy if it knows more:
-            tec = socket_con_type::translate_ec(ec);
-            m_tec = ec;
-
-            if (tec == transport::error::tls_error ||
-                tec == transport::error::pass_through)
-            {
-                // These are aggregate/catch all errors. Log some human readable
-                // information to the info channel to give library users some
-                // more details about why the upstream method may have failed.
-                log_err(log::elevel::info,"asio async_read_at_least",ec);
-            }
-        }
-        if (handler) {
-            handler(tec,bytes_transferred);
-        } else {
-            // This can happen in cases where the connection is terminated while
-            // the transport is waiting on a read.
-            m_alog->write(log::alevel::devel,
-                "handle_async_read called with null read handler");
-        }
-    }
-
-    /// Initiate a potentially asyncronous write of the given buffer
-    void async_write(const char* buf, size_t len, write_handler handler) {
-        m_bufs.push_back(lib::asio::buffer(buf,len));
-
-        if (config::enable_multithreading) {
-            lib::asio::async_write(
-                socket_con_type::get_socket(),
-                m_bufs,
-                m_strand->wrap(make_custom_alloc_handler(
-                    m_write_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_write, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                ))
-            );
-        } else {
-            lib::asio::async_write(
-                socket_con_type::get_socket(),
-                m_bufs,
-                make_custom_alloc_handler(
-                    m_write_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_write, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                )
-            );
-        }
-    }
-
-    /// Initiate a potentially asyncronous write of the given buffers
-    void async_write(std::vector<buffer> const & bufs, write_handler handler) {
-        std::vector<buffer>::const_iterator it;
-
-        for (it = bufs.begin(); it != bufs.end(); ++it) {
-            m_bufs.push_back(lib::asio::buffer((*it).buf,(*it).len));
-        }
-
-        if (config::enable_multithreading) {
-            lib::asio::async_write(
-                socket_con_type::get_socket(),
-                m_bufs,
-                m_strand->wrap(make_custom_alloc_handler(
-                    m_write_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_write, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                ))
-            );
-        } else {
-            lib::asio::async_write(
-                socket_con_type::get_socket(),
-                m_bufs,
-                make_custom_alloc_handler(
-                    m_write_handler_allocator,
-                    lib::bind(
-                        &type::handle_async_write, get_shared(),
-                        handler,
-                        lib::placeholders::_1, lib::placeholders::_2
-                    )
-                )
-            );
-        }
-    }
-
-    /// Async write callback
-    /**
-     * @param ec The status code
-     * @param bytes_transferred The number of bytes read
-     */
-    void handle_async_write(write_handler handler, lib::asio::error_code const & ec, size_t) {
-        m_bufs.clear();
-        lib::error_code tec;
-        if (ec) {
-            log_err(log::elevel::info,"asio async_write",ec);
-            tec = make_error_code(transport::error::pass_through);
-        }
-        if (handler) {
-            handler(tec);
-        } else {
-            // This can happen in cases where the connection is terminated while
-            // the transport is waiting on a read.
-            m_alog->write(log::alevel::devel,
-                "handle_async_write called with null write handler");
-        }
-    }
-
-    /// Set Connection Handle
-    /**
-     * See common/connection_hdl.hpp for information
-     *
-     * @param hdl A connection_hdl that the transport will use to refer
-     * to itself
-     */
-    void set_handle(connection_hdl hdl) {
-        m_connection_hdl = hdl;
-        socket_con_type::set_handle(hdl);
-    }
-
-    /// Trigger the on_interrupt handler
-    /**
-     * This needs to be thread safe
-     */
-    lib::error_code interrupt(interrupt_handler handler) {
-        if (config::enable_multithreading) {
-            m_io_service->post(m_strand->wrap(handler));
-        } else {
-            m_io_service->post(handler);
-        }
-        return lib::error_code();
-    }
-
-    lib::error_code dispatch(dispatch_handler handler) {
-        if (config::enable_multithreading) {
-            m_io_service->post(m_strand->wrap(handler));
-        } else {
-            m_io_service->post(handler);
-        }
-        return lib::error_code();
-    }
-
-    /*void handle_interrupt(interrupt_handler handler) {
-        handler();
-    }*/
-
-    /// close and clean up the underlying socket
-    void async_shutdown(shutdown_handler callback) {
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,"asio connection async_shutdown");
-        }
-
-        timer_ptr shutdown_timer;
-        shutdown_timer = set_timer(
-            config::timeout_socket_shutdown,
-            lib::bind(
-                &type::handle_async_shutdown_timeout,
-                get_shared(),
-                shutdown_timer,
-                callback,
-                lib::placeholders::_1
-            )
-        );
-
-        socket_con_type::async_shutdown(
-            lib::bind(
-                &type::handle_async_shutdown,
-                get_shared(),
-                shutdown_timer,
-                callback,
-                lib::placeholders::_1
-            )
-        );
-    }
-
-    /// Async shutdown timeout handler
-    /**
-     * @param shutdown_timer A pointer to the timer to keep it in scope
-     * @param callback The function to call back
-     * @param ec The status code
-     */
-    void handle_async_shutdown_timeout(timer_ptr, init_handler callback, 
-        lib::error_code const & ec)
-    {
-        lib::error_code ret_ec;
-
-        if (ec) {
-            if (ec == transport::error::operation_aborted) {
-                m_alog->write(log::alevel::devel,
-                    "asio socket shutdown timer cancelled");
-                return;
-            }
-
-            log_err(log::elevel::devel,"asio handle_async_shutdown_timeout",ec);
-            ret_ec = ec;
-        } else {
-            ret_ec = make_error_code(transport::error::timeout);
-        }
-
-        m_alog->write(log::alevel::devel,
-            "Asio transport socket shutdown timed out");
-        cancel_socket_checked();
-        callback(ret_ec);
-    }
-
-    void handle_async_shutdown(timer_ptr shutdown_timer, shutdown_handler
-        callback, lib::asio::error_code const & ec)
-    {
-        if (ec == lib::asio::error::operation_aborted ||
-            lib::asio::is_neg(shutdown_timer->expires_from_now()))
-        {
-            m_alog->write(log::alevel::devel,"async_shutdown cancelled");
-            return;
-        }
-
-        shutdown_timer->cancel();
-
-        lib::error_code tec;
-        if (ec) {
-            if (ec == lib::asio::error::not_connected) {
-                // The socket was already closed when we tried to close it. This
-                // happens periodically (usually if a read or write fails
-                // earlier and if it is a real error will be caught at another
-                // level of the stack.
-            } else {
-                // We don't know anything more about this error, give our
-                // socket/security policy a crack at it.
-                tec = socket_con_type::translate_ec(ec);
-                m_tec = ec;
-
-                // all other errors are effectively pass through errors of
-				// some sort so print some detail on the info channel for
-				// library users to look up if needed.
-				log_err(log::elevel::info,"asio async_shutdown",ec);
-            }
-        } else {
-            if (m_alog->static_test(log::alevel::devel)) {
-                m_alog->write(log::alevel::devel,
-                    "asio con handle_async_shutdown");
-            }
-        }
-        callback(tec);
-    }
-
-    /// Cancel the underlying socket and log any errors
-    void cancel_socket_checked() {
-        lib::asio::error_code cec = socket_con_type::cancel_socket();
-        if (cec) {
-            if (cec == lib::asio::error::operation_not_supported) {
-                // cancel not supported on this OS, ignore and log at dev level
-                m_alog->write(log::alevel::devel, "socket cancel not supported");
-            } else {
-                log_err(log::elevel::warn, "socket cancel failed", cec);
-            }
-        }
-    }
-
-private:
-    /// Convenience method for logging the code and message for an error_code
-    template <typename error_type>
-    void log_err(log::level l, const char * msg, const error_type & ec) {
-        std::stringstream s;
-        s << msg << " error: " << ec << " (" << ec.message() << ")";
-        m_elog->write(l,s.str());
-    }
-
-    // static settings
-    const bool m_is_server;
-    lib::shared_ptr<alog_type> m_alog;
-    lib::shared_ptr<elog_type> m_elog;
-
-    struct proxy_data {
-        proxy_data() : timeout_proxy(config::timeout_proxy) {}
-
-        request_type req;
-        response_type res;
-        std::string write_buf;
-        lib::asio::streambuf read_buf;
-        long timeout_proxy;
-        timer_ptr timer;
-    };
-
-    std::string m_proxy;
-    lib::shared_ptr<proxy_data> m_proxy_data;
-
-    // transport resources
-    io_service_ptr  m_io_service;
-    strand_ptr      m_strand;
-    connection_hdl  m_connection_hdl;
-
-    std::vector<lib::asio::const_buffer> m_bufs;
-
-    /// Detailed internal error code
-    lib::asio::error_code m_tec;
-
-    // Handlers
-    tcp_init_handler    m_tcp_pre_init_handler;
-    tcp_init_handler    m_tcp_post_init_handler;
-
-    handler_allocator   m_read_handler_allocator;
-    handler_allocator   m_write_handler_allocator;
-};
-
-
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_ASIO_CON_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/endpoint.hpp
deleted file mode 100644
index 94509ad..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/endpoint.hpp
+++ /dev/null
@@ -1,1182 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_ASIO_HPP
-#define WEBSOCKETPP_TRANSPORT_ASIO_HPP
-
-#include <websocketpp/transport/base/endpoint.hpp>
-#include <websocketpp/transport/asio/connection.hpp>
-#include <websocketpp/transport/asio/security/none.hpp>
-
-#include <websocketpp/uri.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/functional.hpp>
-
-#include <sstream>
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-namespace asio {
-
-/// Asio based endpoint transport component
-/**
- * transport::asio::endpoint implements an endpoint transport component using
- * Asio.
- */
-template <typename config>
-class endpoint : public config::socket_type {
-public:
-    /// Type of this endpoint transport component
-    typedef endpoint<config> type;
-
-    /// Type of the concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of the socket policy
-    typedef typename config::socket_type socket_type;
-    /// Type of the error logging policy
-    typedef typename config::elog_type elog_type;
-    /// Type of the access logging policy
-    typedef typename config::alog_type alog_type;
-
-    /// Type of the socket connection component
-    typedef typename socket_type::socket_con_type socket_con_type;
-    /// Type of a shared pointer to the socket connection component
-    typedef typename socket_con_type::ptr socket_con_ptr;
-
-    /// Type of the connection transport component associated with this
-    /// endpoint transport component
-    typedef asio::connection<config> transport_con_type;
-    /// Type of a shared pointer to the connection transport component
-    /// associated with this endpoint transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    /// Type of a pointer to the ASIO io_service being used
-    typedef lib::asio::io_service * io_service_ptr;
-    /// Type of a shared pointer to the acceptor being used
-    typedef lib::shared_ptr<lib::asio::ip::tcp::acceptor> acceptor_ptr;
-    /// Type of a shared pointer to the resolver being used
-    typedef lib::shared_ptr<lib::asio::ip::tcp::resolver> resolver_ptr;
-    /// Type of timer handle
-    typedef lib::shared_ptr<lib::asio::steady_timer> timer_ptr;
-    /// Type of a shared pointer to an io_service work object
-    typedef lib::shared_ptr<lib::asio::io_service::work> work_ptr;
-
-    /// Type of socket pre-bind handler
-    typedef lib::function<lib::error_code(acceptor_ptr)> tcp_pre_bind_handler;
-
-    // generate and manage our own io_service
-    explicit endpoint()
-      : m_io_service(NULL)
-      , m_external_io_service(false)
-      , m_listen_backlog(lib::asio::socket_base::max_connections)
-      , m_reuse_addr(false)
-      , m_state(UNINITIALIZED)
-    {
-        //std::cout << "transport::asio::endpoint constructor" << std::endl;
-    }
-
-    ~endpoint() {
-        // clean up our io_service if we were initialized with an internal one.
-
-        // Explicitly destroy local objects
-        m_acceptor.reset();
-        m_resolver.reset();
-        m_work.reset();
-        if (m_state != UNINITIALIZED && !m_external_io_service) {
-            delete m_io_service;
-        }
-    }
-
-    /// transport::asio objects are moveable but not copyable or assignable.
-    /// The following code sets this situation up based on whether or not we
-    /// have C++11 support or not
-#ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-    endpoint(const endpoint & src) = delete;
-    endpoint& operator= (const endpoint & rhs) = delete;
-#else
-private:
-    endpoint(const endpoint & src);
-    endpoint & operator= (const endpoint & rhs);
-public:
-#endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
-
-#ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
-    endpoint (endpoint && src)
-      : config::socket_type(std::move(src))
-      , m_tcp_pre_init_handler(src.m_tcp_pre_init_handler)
-      , m_tcp_post_init_handler(src.m_tcp_post_init_handler)
-      , m_io_service(src.m_io_service)
-      , m_external_io_service(src.m_external_io_service)
-      , m_acceptor(src.m_acceptor)
-      , m_listen_backlog(lib::asio::socket_base::max_connections)
-      , m_reuse_addr(src.m_reuse_addr)
-      , m_elog(src.m_elog)
-      , m_alog(src.m_alog)
-      , m_state(src.m_state)
-    {
-        src.m_io_service = NULL;
-        src.m_external_io_service = false;
-        src.m_acceptor = NULL;
-        src.m_state = UNINITIALIZED;
-    }
-
-    /*endpoint & operator= (const endpoint && rhs) {
-        if (this != &rhs) {
-            m_io_service = rhs.m_io_service;
-            m_external_io_service = rhs.m_external_io_service;
-            m_acceptor = rhs.m_acceptor;
-            m_listen_backlog = rhs.m_listen_backlog;
-            m_reuse_addr = rhs.m_reuse_addr;
-            m_state = rhs.m_state;
-
-            rhs.m_io_service = NULL;
-            rhs.m_external_io_service = false;
-            rhs.m_acceptor = NULL;
-            rhs.m_listen_backlog = lib::asio::socket_base::max_connections;
-            rhs.m_state = UNINITIALIZED;
-            
-            // TODO: this needs to be updated
-        }
-        return *this;
-    }*/
-#endif // _WEBSOCKETPP_MOVE_SEMANTICS_
-
-    /// Return whether or not the endpoint produces secure connections.
-    bool is_secure() const {
-        return socket_type::is_secure();
-    }
-
-    /// initialize asio transport with external io_service (exception free)
-    /**
-     * Initialize the ASIO transport policy for this endpoint using the provided
-     * io_service object. asio_init must be called exactly once on any endpoint
-     * that uses transport::asio before it can be used.
-     *
-     * @param ptr A pointer to the io_service to use for asio events
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void init_asio(io_service_ptr ptr, lib::error_code & ec) {
-        if (m_state != UNINITIALIZED) {
-            m_elog->write(log::elevel::library,
-                "asio::init_asio called from the wrong state");
-            using websocketpp::error::make_error_code;
-            ec = make_error_code(websocketpp::error::invalid_state);
-            return;
-        }
-
-        m_alog->write(log::alevel::devel,"asio::init_asio");
-
-        m_io_service = ptr;
-        m_external_io_service = true;
-        m_acceptor.reset(new lib::asio::ip::tcp::acceptor(*m_io_service));
-
-        m_state = READY;
-        ec = lib::error_code();
-    }
-
-    /// initialize asio transport with external io_service
-    /**
-     * Initialize the ASIO transport policy for this endpoint using the provided
-     * io_service object. asio_init must be called exactly once on any endpoint
-     * that uses transport::asio before it can be used.
-     *
-     * @param ptr A pointer to the io_service to use for asio events
-     */
-    void init_asio(io_service_ptr ptr) {
-        lib::error_code ec;
-        init_asio(ptr,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Initialize asio transport with internal io_service (exception free)
-    /**
-     * This method of initialization will allocate and use an internally managed
-     * io_service.
-     *
-     * @see init_asio(io_service_ptr ptr)
-     *
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void init_asio(lib::error_code & ec) {
-        // Use a smart pointer until the call is successful and ownership has 
-        // successfully been taken. Use unique_ptr when available.
-        // TODO: remove the use of auto_ptr when C++98/03 support is no longer
-        //       necessary.
-#ifdef _WEBSOCKETPP_CPP11_MEMORY_
-        lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
-#else
-        lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
-#endif
-        init_asio(service.get(), ec);
-        if( !ec ) service.release(); // Call was successful, transfer ownership
-        m_external_io_service = false;
-    }
-
-    /// Initialize asio transport with internal io_service
-    /**
-     * This method of initialization will allocate and use an internally managed
-     * io_service.
-     *
-     * @see init_asio(io_service_ptr ptr)
-     */
-    void init_asio() {
-        // Use a smart pointer until the call is successful and ownership has 
-        // successfully been taken. Use unique_ptr when available.
-        // TODO: remove the use of auto_ptr when C++98/03 support is no longer
-        //       necessary.
-#ifdef _WEBSOCKETPP_CPP11_MEMORY_
-        lib::unique_ptr<lib::asio::io_service> service(new lib::asio::io_service());
-#else
-        lib::auto_ptr<lib::asio::io_service> service(new lib::asio::io_service());
-#endif
-        init_asio( service.get() );
-        // If control got this far without an exception, then ownership has successfully been taken
-        service.release();
-        m_external_io_service = false;
-    }
-
-    /// Sets the tcp pre bind handler
-    /**
-     * The tcp pre bind handler is called after the listen acceptor has
-     * been created but before the socket bind is performed.
-     *
-     * @since 0.8.0
-     *
-     * @param h The handler to call on tcp pre bind init.
-     */
-    void set_tcp_pre_bind_handler(tcp_pre_bind_handler h) {
-        m_tcp_pre_bind_handler = h;
-    }
-
-    /// Sets the tcp pre init handler
-    /**
-     * The tcp pre init handler is called after the raw tcp connection has been
-     * established but before any additional wrappers (proxy connects, TLS
-     * handshakes, etc) have been performed.
-     *
-     * @since 0.3.0
-     *
-     * @param h The handler to call on tcp pre init.
-     */
-    void set_tcp_pre_init_handler(tcp_init_handler h) {
-        m_tcp_pre_init_handler = h;
-    }
-
-    /// Sets the tcp pre init handler (deprecated)
-    /**
-     * The tcp pre init handler is called after the raw tcp connection has been
-     * established but before any additional wrappers (proxy connects, TLS
-     * handshakes, etc) have been performed.
-     *
-     * @deprecated Use set_tcp_pre_init_handler instead
-     *
-     * @param h The handler to call on tcp pre init.
-     */
-    void set_tcp_init_handler(tcp_init_handler h) {
-        set_tcp_pre_init_handler(h);
-    }
-
-    /// Sets the tcp post init handler
-    /**
-     * The tcp post init handler is called after the tcp connection has been
-     * established and all additional wrappers (proxy connects, TLS handshakes,
-     * etc have been performed. This is fired before any bytes are read or any
-     * WebSocket specific handshake logic has been performed.
-     *
-     * @since 0.3.0
-     *
-     * @param h The handler to call on tcp post init.
-     */
-    void set_tcp_post_init_handler(tcp_init_handler h) {
-        m_tcp_post_init_handler = h;
-    }
-
-    /// Sets the maximum length of the queue of pending connections.
-    /**
-     * Sets the maximum length of the queue of pending connections. Increasing
-     * this will allow WebSocket++ to queue additional incoming connections.
-     * Setting it higher may prevent failed connections at high connection rates
-     * but may cause additional latency.
-     *
-     * For this value to take effect you may need to adjust operating system
-     * settings.
-     *
-     * New values affect future calls to listen only.
-     *
-     * The default value is specified as *::asio::socket_base::max_connections
-     * which uses the operating system defined maximum queue length. Your OS
-     * may restrict or silently lower this value. A value of zero may cause
-     * all connections to be rejected.
-     *
-     * @since 0.3.0
-     *
-     * @param backlog The maximum length of the queue of pending connections
-     */
-    void set_listen_backlog(int backlog) {
-        m_listen_backlog = backlog;
-    }
-
-    /// Sets whether to use the SO_REUSEADDR flag when opening listening sockets
-    /**
-     * Specifies whether or not to use the SO_REUSEADDR TCP socket option. What
-     * this flag does depends on your operating system.
-     *
-     * Please consult operating system documentation for more details. There
-     * may be security consequences to enabling this option.
-     *
-     * New values affect future calls to listen only so set this value prior to
-     * calling listen.
-     *
-     * The default is false.
-     *
-     * @since 0.3.0
-     *
-     * @param value Whether or not to use the SO_REUSEADDR option
-     */
-    void set_reuse_addr(bool value) {
-        m_reuse_addr = value;
-    }
-
-    /// Retrieve a reference to the endpoint's io_service
-    /**
-     * The io_service may be an internal or external one. This may be used to
-     * call methods of the io_service that are not explicitly wrapped by the
-     * endpoint.
-     *
-     * This method is only valid after the endpoint has been initialized with
-     * `init_asio`. No error will be returned if it isn't.
-     *
-     * @return A reference to the endpoint's io_service
-     */
-    lib::asio::io_service & get_io_service() {
-        return *m_io_service;
-    }
-    
-    /// Get local TCP endpoint
-    /**
-     * Extracts the local endpoint from the acceptor. This represents the
-     * address that WebSocket++ is listening on.
-     *
-     * Sets a bad_descriptor error if the acceptor is not currently listening
-     * or otherwise unavailable.
-     * 
-     * @since 0.7.0
-     *
-     * @param ec Set to indicate what error occurred, if any.
-     * @return The local endpoint
-     */
-    lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code & ec) {
-        if (m_acceptor) {
-            return m_acceptor->local_endpoint(ec);
-        } else {
-            ec = lib::asio::error::make_error_code(lib::asio::error::bad_descriptor);
-            return lib::asio::ip::tcp::endpoint();
-        }
-    }
-
-    /// Set up endpoint for listening manually (exception free)
-    /**
-     * Bind the internal acceptor using the specified settings. The endpoint
-     * must have been initialized by calling init_asio before listening.
-     *
-     * @param ep An endpoint to read settings from
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void listen(lib::asio::ip::tcp::endpoint const & ep, lib::error_code & ec)
-    {
-        if (m_state != READY) {
-            m_elog->write(log::elevel::library,
-                "asio::listen called from the wrong state");
-            using websocketpp::error::make_error_code;
-            ec = make_error_code(websocketpp::error::invalid_state);
-            return;
-        }
-
-        m_alog->write(log::alevel::devel,"asio::listen");
-
-        lib::asio::error_code bec;
-
-        m_acceptor->open(ep.protocol(),bec);
-        if (bec) {ec = clean_up_listen_after_error(bec);return;}
-        
-        m_acceptor->set_option(lib::asio::socket_base::reuse_address(m_reuse_addr),bec);
-        if (bec) {ec = clean_up_listen_after_error(bec);return;}
-        
-        // if a TCP pre-bind handler is present, run it
-        if (m_tcp_pre_bind_handler) {
-            ec = m_tcp_pre_bind_handler(m_acceptor);
-            if (ec) {
-                ec = clean_up_listen_after_error(ec);
-                return;
-            }
-        }
-        
-        m_acceptor->bind(ep,bec);
-        if (bec) {ec = clean_up_listen_after_error(bec);return;}
-        
-        m_acceptor->listen(m_listen_backlog,bec);
-        if (bec) {ec = clean_up_listen_after_error(bec);return;}
-        
-        // Success
-        m_state = LISTENING;
-        ec = lib::error_code();
-    }
-
-
-
-    /// Set up endpoint for listening manually
-    /**
-     * Bind the internal acceptor using the settings specified by the endpoint e
-     *
-     * @param ep An endpoint to read settings from
-     */
-    void listen(lib::asio::ip::tcp::endpoint const & ep) {
-        lib::error_code ec;
-        listen(ep,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Set up endpoint for listening with protocol and port (exception free)
-    /**
-     * Bind the internal acceptor using the given internet protocol and port.
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * Common options include:
-     * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
-     * - IPv4 only: lib::asio::ip::tcp::v4()
-     *
-     * @param internet_protocol The internet protocol to use.
-     * @param port The port to listen on.
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    template <typename InternetProtocol>
-    void listen(InternetProtocol const & internet_protocol, uint16_t port,
-        lib::error_code & ec)
-    {
-        lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
-        listen(ep,ec);
-    }
-
-    /// Set up endpoint for listening with protocol and port
-    /**
-     * Bind the internal acceptor using the given internet protocol and port.
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * Common options include:
-     * - IPv6 with mapped IPv4 for dual stack hosts lib::asio::ip::tcp::v6()
-     * - IPv4 only: lib::asio::ip::tcp::v4()
-     *
-     * @param internet_protocol The internet protocol to use.
-     * @param port The port to listen on.
-     */
-    template <typename InternetProtocol>
-    void listen(InternetProtocol const & internet_protocol, uint16_t port)
-    {
-        lib::asio::ip::tcp::endpoint ep(internet_protocol, port);
-        listen(ep);
-    }
-
-    /// Set up endpoint for listening on a port (exception free)
-    /**
-     * Bind the internal acceptor using the given port. The IPv6 protocol with
-     * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
-     * the overload that allows specifying the protocol explicitly.
-     *
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * @param port The port to listen on.
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void listen(uint16_t port, lib::error_code & ec) {
-        listen(lib::asio::ip::tcp::v6(), port, ec);
-    }
-
-    /// Set up endpoint for listening on a port
-    /**
-     * Bind the internal acceptor using the given port. The IPv6 protocol with
-     * mapped IPv4 for dual stack hosts will be used. If you need IPv4 only use
-     * the overload that allows specifying the protocol explicitly.
-     *
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * @param port The port to listen on.
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void listen(uint16_t port) {
-        listen(lib::asio::ip::tcp::v6(), port);
-    }
-
-    /// Set up endpoint for listening on a host and service (exception free)
-    /**
-     * Bind the internal acceptor using the given host and service. More details
-     * about what host and service can be are available in the Asio
-     * documentation for ip::basic_resolver_query::basic_resolver_query's
-     * constructors.
-     *
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * @param host A string identifying a location. May be a descriptive name or
-     * a numeric address string.
-     * @param service A string identifying the requested service. This may be a
-     * descriptive name or a numeric string corresponding to a port number.
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void listen(std::string const & host, std::string const & service,
-        lib::error_code & ec)
-    {
-        using lib::asio::ip::tcp;
-        tcp::resolver r(*m_io_service);
-        tcp::resolver::query query(host, service);
-        tcp::resolver::iterator endpoint_iterator = r.resolve(query);
-        tcp::resolver::iterator end;
-        if (endpoint_iterator == end) {
-            m_elog->write(log::elevel::library,
-                "asio::listen could not resolve the supplied host or service");
-            ec = make_error_code(error::invalid_host_service);
-            return;
-        }
-        listen(*endpoint_iterator,ec);
-    }
-
-    /// Set up endpoint for listening on a host and service
-    /**
-     * Bind the internal acceptor using the given host and service. More details
-     * about what host and service can be are available in the Asio
-     * documentation for ip::basic_resolver_query::basic_resolver_query's
-     * constructors.
-     *
-     * The endpoint must have been initialized by calling init_asio before
-     * listening.
-     *
-     * @param host A string identifying a location. May be a descriptive name or
-     * a numeric address string.
-     * @param service A string identifying the requested service. This may be a
-     * descriptive name or a numeric string corresponding to a port number.
-     * @param ec Set to indicate what error occurred, if any.
-     */
-    void listen(std::string const & host, std::string const & service)
-    {
-        lib::error_code ec;
-        listen(host,service,ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Stop listening (exception free)
-    /**
-     * Stop listening and accepting new connections. This will not end any
-     * existing connections.
-     *
-     * @since 0.3.0-alpha4
-     * @param ec A status code indicating an error, if any.
-     */
-    void stop_listening(lib::error_code & ec) {
-        if (m_state != LISTENING) {
-            m_elog->write(log::elevel::library,
-                "asio::listen called from the wrong state");
-            using websocketpp::error::make_error_code;
-            ec = make_error_code(websocketpp::error::invalid_state);
-            return;
-        }
-
-        m_acceptor->close();
-        m_state = READY;
-        ec = lib::error_code();
-    }
-
-    /// Stop listening
-    /**
-     * Stop listening and accepting new connections. This will not end any
-     * existing connections.
-     *
-     * @since 0.3.0-alpha4
-     */
-    void stop_listening() {
-        lib::error_code ec;
-        stop_listening(ec);
-        if (ec) { throw exception(ec); }
-    }
-
-    /// Check if the endpoint is listening
-    /**
-     * @return Whether or not the endpoint is listening.
-     */
-    bool is_listening() const {
-        return (m_state == LISTENING);
-    }
-
-    /// wraps the run method of the internal io_service object
-    std::size_t run() {
-        return m_io_service->run();
-    }
-
-    /// wraps the run_one method of the internal io_service object
-    /**
-     * @since 0.3.0-alpha4
-     */
-    std::size_t run_one() {
-        return m_io_service->run_one();
-    }
-
-    /// wraps the stop method of the internal io_service object
-    void stop() {
-        m_io_service->stop();
-    }
-
-    /// wraps the poll method of the internal io_service object
-    std::size_t poll() {
-        return m_io_service->poll();
-    }
-
-    /// wraps the poll_one method of the internal io_service object
-    std::size_t poll_one() {
-        return m_io_service->poll_one();
-    }
-
-    /// wraps the reset method of the internal io_service object
-    void reset() {
-        m_io_service->reset();
-    }
-
-    /// wraps the stopped method of the internal io_service object
-    bool stopped() const {
-        return m_io_service->stopped();
-    }
-
-    /// Marks the endpoint as perpetual, stopping it from exiting when empty
-    /**
-     * Marks the endpoint as perpetual. Perpetual endpoints will not
-     * automatically exit when they run out of connections to process. To stop
-     * a perpetual endpoint call `end_perpetual`.
-     *
-     * An endpoint may be marked perpetual at any time by any thread. It must be
-     * called either before the endpoint has run out of work or before it was
-     * started
-     *
-     * @since 0.3.0
-     */
-    void start_perpetual() {
-        m_work.reset(new lib::asio::io_service::work(*m_io_service));
-    }
-
-    /// Clears the endpoint's perpetual flag, allowing it to exit when empty
-    /**
-     * Clears the endpoint's perpetual flag. This will cause the endpoint's run
-     * method to exit normally when it runs out of connections. If there are
-     * currently active connections it will not end until they are complete.
-     *
-     * @since 0.3.0
-     */
-    void stop_perpetual() {
-        m_work.reset();
-    }
-
-    /// Call back a function after a period of time.
-    /**
-     * Sets a timer that calls back a function after the specified period of
-     * milliseconds. Returns a handle that can be used to cancel the timer.
-     * A cancelled timer will return the error code error::operation_aborted
-     * A timer that expired will return no error.
-     *
-     * @param duration Length of time to wait in milliseconds
-     * @param callback The function to call back when the timer has expired
-     * @return A handle that can be used to cancel the timer if it is no longer
-     * needed.
-     */
-    timer_ptr set_timer(long duration, timer_handler callback) {
-        timer_ptr new_timer = lib::make_shared<lib::asio::steady_timer>(
-            *m_io_service,
-             lib::asio::milliseconds(duration)
-        );
-
-        new_timer->async_wait(
-            lib::bind(
-                &type::handle_timer,
-                this,
-                new_timer,
-                callback,
-                lib::placeholders::_1
-            )
-        );
-
-        return new_timer;
-    }
-
-    /// Timer handler
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * @param t Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec A status code indicating an error, if any.
-     */
-    void handle_timer(timer_ptr, timer_handler callback,
-        lib::asio::error_code const & ec)
-    {
-        if (ec) {
-            if (ec == lib::asio::error::operation_aborted) {
-                callback(make_error_code(transport::error::operation_aborted));
-            } else {
-                m_elog->write(log::elevel::info,
-                    "asio handle_timer error: "+ec.message());
-                log_err(log::elevel::info,"asio handle_timer",ec);
-                callback(socket_con_type::translate_ec(ec));
-            }
-        } else {
-            callback(lib::error_code());
-        }
-    }
-
-    /// Accept the next connection attempt and assign it to con (exception free)
-    /**
-     * @param tcon The connection to accept into.
-     * @param callback The function to call when the operation is complete.
-     * @param ec A status code indicating an error, if any.
-     */
-    void async_accept(transport_con_ptr tcon, accept_handler callback,
-        lib::error_code & ec)
-    {
-        if (m_state != LISTENING || !m_acceptor) {
-            using websocketpp::error::make_error_code;
-            ec = make_error_code(websocketpp::error::async_accept_not_listening);
-            return;
-        }
-
-        m_alog->write(log::alevel::devel, "asio::async_accept");
-
-        if (config::enable_multithreading) {
-            m_acceptor->async_accept(
-                tcon->get_raw_socket(),
-                tcon->get_strand()->wrap(lib::bind(
-                    &type::handle_accept,
-                    this,
-                    callback,
-                    lib::placeholders::_1
-                ))
-            );
-        } else {
-            m_acceptor->async_accept(
-                tcon->get_raw_socket(),
-                lib::bind(
-                    &type::handle_accept,
-                    this,
-                    callback,
-                    lib::placeholders::_1
-                )
-            );
-        }
-    }
-
-    /// Accept the next connection attempt and assign it to con.
-    /**
-     * @param tcon The connection to accept into.
-     * @param callback The function to call when the operation is complete.
-     */
-    void async_accept(transport_con_ptr tcon, accept_handler callback) {
-        lib::error_code ec;
-        async_accept(tcon,callback,ec);
-        if (ec) { throw exception(ec); }
-    }
-protected:
-    /// Initialize logging
-    /**
-     * The loggers are located in the main endpoint class. As such, the
-     * transport doesn't have direct access to them. This method is called
-     * by the endpoint constructor to allow shared logging from the transport
-     * component. These are raw pointers to member variables of the endpoint.
-     * In particular, they cannot be used in the transport constructor as they
-     * haven't been constructed yet, and cannot be used in the transport
-     * destructor as they will have been destroyed by then.
-     */
-    void init_logging(const lib::shared_ptr<alog_type>& a, const lib::shared_ptr<elog_type>& e) {
-        m_alog = a;
-        m_elog = e;
-    }
-
-    void handle_accept(accept_handler callback, lib::asio::error_code const & 
-        asio_ec)
-    {
-        lib::error_code ret_ec;
-
-        m_alog->write(log::alevel::devel, "asio::handle_accept");
-
-        if (asio_ec) {
-            if (asio_ec == lib::asio::errc::operation_canceled) {
-                ret_ec = make_error_code(websocketpp::error::operation_canceled);
-            } else {
-                log_err(log::elevel::info,"asio handle_accept",asio_ec);
-                ret_ec = socket_con_type::translate_ec(asio_ec);
-            }
-        }
-
-        callback(ret_ec);
-    }
-
-    /// Initiate a new connection
-    // TODO: there have to be some more failure conditions here
-    void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb) {
-        using namespace lib::asio::ip;
-
-        // Create a resolver
-        if (!m_resolver) {
-            m_resolver.reset(new lib::asio::ip::tcp::resolver(*m_io_service));
-        }
-
-        tcon->set_uri(u);
-
-        std::string proxy = tcon->get_proxy();
-        std::string host;
-        std::string port;
-
-        if (proxy.empty()) {
-            host = u->get_host();
-            port = u->get_port_str();
-        } else {
-            lib::error_code ec;
-
-            uri_ptr pu = lib::make_shared<uri>(proxy);
-
-            if (!pu->get_valid()) {
-                cb(make_error_code(error::proxy_invalid));
-                return;
-            }
-
-            ec = tcon->proxy_init(u->get_authority());
-            if (ec) {
-                cb(ec);
-                return;
-            }
-
-            host = pu->get_host();
-            port = pu->get_port_str();
-        }
-
-        tcp::resolver::query query(host,port);
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,
-                "starting async DNS resolve for "+host+":"+port);
-        }
-
-        timer_ptr dns_timer;
-
-        dns_timer = tcon->set_timer(
-            config::timeout_dns_resolve,
-            lib::bind(
-                &type::handle_resolve_timeout,
-                this,
-                dns_timer,
-                cb,
-                lib::placeholders::_1
-            )
-        );
-
-        if (config::enable_multithreading) {
-            m_resolver->async_resolve(
-                query,
-                tcon->get_strand()->wrap(lib::bind(
-                    &type::handle_resolve,
-                    this,
-                    tcon,
-                    dns_timer,
-                    cb,
-                    lib::placeholders::_1,
-                    lib::placeholders::_2
-                ))
-            );
-        } else {
-            m_resolver->async_resolve(
-                query,
-                lib::bind(
-                    &type::handle_resolve,
-                    this,
-                    tcon,
-                    dns_timer,
-                    cb,
-                    lib::placeholders::_1,
-                    lib::placeholders::_2
-                )
-            );
-        }
-    }
-
-    /// DNS resolution timeout handler
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * @param dns_timer Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec A status code indicating an error, if any.
-     */
-    void handle_resolve_timeout(timer_ptr, connect_handler callback,
-        lib::error_code const & ec)
-    {
-        lib::error_code ret_ec;
-
-        if (ec) {
-            if (ec == transport::error::operation_aborted) {
-                m_alog->write(log::alevel::devel,
-                    "asio handle_resolve_timeout timer cancelled");
-                return;
-            }
-
-            log_err(log::elevel::devel,"asio handle_resolve_timeout",ec);
-            ret_ec = ec;
-        } else {
-            ret_ec = make_error_code(transport::error::timeout);
-        }
-
-        m_alog->write(log::alevel::devel,"DNS resolution timed out");
-        m_resolver->cancel();
-        callback(ret_ec);
-    }
-
-    void handle_resolve(transport_con_ptr tcon, timer_ptr dns_timer,
-        connect_handler callback, lib::asio::error_code const & ec,
-        lib::asio::ip::tcp::resolver::iterator iterator)
-    {
-        if (ec == lib::asio::error::operation_aborted ||
-            lib::asio::is_neg(dns_timer->expires_from_now()))
-        {
-            m_alog->write(log::alevel::devel,"async_resolve cancelled");
-            return;
-        }
-
-        dns_timer->cancel();
-
-        if (ec) {
-            log_err(log::elevel::info,"asio async_resolve",ec);
-            callback(socket_con_type::translate_ec(ec));
-            return;
-        }
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            std::stringstream s;
-            s << "Async DNS resolve successful. Results: ";
-
-            lib::asio::ip::tcp::resolver::iterator it, end;
-            for (it = iterator; it != end; ++it) {
-                s << (*it).endpoint() << " ";
-            }
-
-            m_alog->write(log::alevel::devel,s.str());
-        }
-
-        m_alog->write(log::alevel::devel,"Starting async connect");
-
-        timer_ptr con_timer;
-
-        con_timer = tcon->set_timer(
-            config::timeout_connect,
-            lib::bind(
-                &type::handle_connect_timeout,
-                this,
-                tcon,
-                con_timer,
-                callback,
-                lib::placeholders::_1
-            )
-        );
-
-        if (config::enable_multithreading) {
-            lib::asio::async_connect(
-                tcon->get_raw_socket(),
-                iterator,
-                tcon->get_strand()->wrap(lib::bind(
-                    &type::handle_connect,
-                    this,
-                    tcon,
-                    con_timer,
-                    callback,
-                    lib::placeholders::_1
-                ))
-            );
-        } else {
-            lib::asio::async_connect(
-                tcon->get_raw_socket(),
-                iterator,
-                lib::bind(
-                    &type::handle_connect,
-                    this,
-                    tcon,
-                    con_timer,
-                    callback,
-                    lib::placeholders::_1
-                )
-            );
-        }
-    }
-
-    /// Asio connect timeout handler
-    /**
-     * The timer pointer is included to ensure the timer isn't destroyed until
-     * after it has expired.
-     *
-     * @param tcon Pointer to the transport connection that is being connected
-     * @param con_timer Pointer to the timer in question
-     * @param callback The function to call back
-     * @param ec A status code indicating an error, if any.
-     */
-    void handle_connect_timeout(transport_con_ptr tcon, timer_ptr,
-        connect_handler callback, lib::error_code const & ec)
-    {
-        lib::error_code ret_ec;
-
-        if (ec) {
-            if (ec == transport::error::operation_aborted) {
-                m_alog->write(log::alevel::devel,
-                    "asio handle_connect_timeout timer cancelled");
-                return;
-            }
-
-            log_err(log::elevel::devel,"asio handle_connect_timeout",ec);
-            ret_ec = ec;
-        } else {
-            ret_ec = make_error_code(transport::error::timeout);
-        }
-
-        m_alog->write(log::alevel::devel,"TCP connect timed out");
-        tcon->cancel_socket_checked();
-        callback(ret_ec);
-    }
-
-    void handle_connect(transport_con_ptr tcon, timer_ptr con_timer,
-        connect_handler callback, lib::asio::error_code const & ec)
-    {
-        if (ec == lib::asio::error::operation_aborted ||
-            lib::asio::is_neg(con_timer->expires_from_now()))
-        {
-            m_alog->write(log::alevel::devel,"async_connect cancelled");
-            return;
-        }
-
-        con_timer->cancel();
-
-        if (ec) {
-            log_err(log::elevel::info,"asio async_connect",ec);
-            callback(socket_con_type::translate_ec(ec));
-            return;
-        }
-
-        if (m_alog->static_test(log::alevel::devel)) {
-            m_alog->write(log::alevel::devel,
-                "Async connect to "+tcon->get_remote_endpoint()+" successful.");
-        }
-
-        callback(lib::error_code());
-    }
-
-    /// Initialize a connection
-    /**
-     * init is called by an endpoint once for each newly created connection.
-     * It's purpose is to give the transport policy the chance to perform any
-     * transport specific initialization that couldn't be done via the default
-     * constructor.
-     *
-     * @param tcon A pointer to the transport portion of the connection.
-     *
-     * @return A status code indicating the success or failure of the operation
-     */
-    lib::error_code init(transport_con_ptr tcon) {
-        m_alog->write(log::alevel::devel, "transport::asio::init");
-
-        // Initialize the connection socket component
-        socket_type::init(lib::static_pointer_cast<socket_con_type,
-            transport_con_type>(tcon));
-
-        lib::error_code ec;
-
-        ec = tcon->init_asio(m_io_service);
-        if (ec) {return ec;}
-
-        tcon->set_tcp_pre_init_handler(m_tcp_pre_init_handler);
-        tcon->set_tcp_post_init_handler(m_tcp_post_init_handler);
-
-        return lib::error_code();
-    }
-private:
-    /// Convenience method for logging the code and message for an error_code
-    template <typename error_type>
-    void log_err(log::level l, char const * msg, error_type const & ec) {
-        std::stringstream s;
-        s << msg << " error: " << ec << " (" << ec.message() << ")";
-        m_elog->write(l,s.str());
-    }
-
-    /// Helper for cleaning up in the listen method after an error
-    template <typename error_type>
-    lib::error_code clean_up_listen_after_error(error_type const & ec) {
-        if (m_acceptor->is_open()) {
-            m_acceptor->close();
-        }
-        log_err(log::elevel::info,"asio listen",ec);
-        return socket_con_type::translate_ec(ec);
-    }
-
-    enum state {
-        UNINITIALIZED = 0,
-        READY = 1,
-        LISTENING = 2
-    };
-
-    // Handlers
-    tcp_pre_bind_handler    m_tcp_pre_bind_handler;
-    tcp_init_handler    m_tcp_pre_init_handler;
-    tcp_init_handler    m_tcp_post_init_handler;
-
-    // Network Resources
-    io_service_ptr      m_io_service;
-    bool                m_external_io_service;
-    acceptor_ptr        m_acceptor;
-    resolver_ptr        m_resolver;
-    work_ptr            m_work;
-
-    // Network constants
-    int                 m_listen_backlog;
-    bool                m_reuse_addr;
-
-    lib::shared_ptr<elog_type> m_elog;
-    lib::shared_ptr<alog_type> m_alog;
-
-    // Transport state
-    state               m_state;
-};
-
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_ASIO_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/base.hpp
deleted file mode 100644
index 0f08f40..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/base.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_ASIO_SOCKET_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_ASIO_SOCKET_BASE_HPP
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/connection_hdl.hpp>
-
-#include <string>
-
-// Interface that sockets/security policies must implement
-
-/*
- * Endpoint Interface
- *
- * bool is_secure() const;
- * @return Whether or not the endpoint creates secure connections
- *
- * lib::error_code init(socket_con_ptr scon);
- * Called by the transport after a new connection is created to initialize
- * the socket component of the connection.
- * @param scon Pointer to the socket component of the connection
- * @return Error code (empty on success)
- */
-
-
-// Connection
-// TODO
-// set_hostname(std::string hostname)
-// pre_init(init_handler);
-// post_init(init_handler);
-
-namespace websocketpp {
-namespace transport {
-namespace asio {
-namespace socket {
-
-typedef lib::function<void(lib::asio::error_code const &)> shutdown_handler;
-
-/**
- * The transport::asio::socket::* classes are a set of security/socket related
- * policies and support code for the ASIO transport types.
- */
-
-/// Errors related to asio transport sockets
-namespace error {
-    enum value {
-        /// Catch-all error for security policy errors that don't fit in other
-        /// categories
-        security = 1,
-
-        /// Catch-all error for socket component errors that don't fit in other
-        /// categories
-        socket,
-
-        /// A function was called in a state that it was illegal to do so.
-        invalid_state,
-
-        /// The application was prompted to provide a TLS context and it was
-        /// empty or otherwise invalid
-        invalid_tls_context,
-
-        /// TLS Handshake Timeout
-        tls_handshake_timeout,
-
-        /// pass_through from underlying library
-        pass_through,
-
-        /// Required tls_init handler not present
-        missing_tls_init_handler,
-
-        /// TLS Handshake Failed
-        tls_handshake_failed,
-        
-        /// Failed to set TLS SNI hostname
-        tls_failed_sni_hostname
-    };
-} // namespace error
-
-/// Error category related to asio transport socket policies
-class socket_category : public lib::error_category {
-public:
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport.asio.socket";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case error::security:
-                return "Security policy error";
-            case error::socket:
-                return "Socket component error";
-            case error::invalid_state:
-                return "Invalid state";
-            case error::invalid_tls_context:
-                return "Invalid or empty TLS context supplied";
-            case error::tls_handshake_timeout:
-                return "TLS handshake timed out";
-            case error::pass_through:
-                return "Pass through from socket policy";
-            case error::missing_tls_init_handler:
-                return "Required tls_init handler not present.";
-            case error::tls_handshake_failed:
-                return "TLS handshake failed";
-            case error::tls_failed_sni_hostname:
-                return "Failed to set TLS SNI hostname";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-inline lib::error_category const & get_socket_category() {
-    static socket_category instance;
-    return instance;
-}
-
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_socket_category());
-}
-
-/// Type of asio transport socket policy initialization handlers
-typedef lib::function<void(const lib::error_code&)> init_handler;
-
-} // namespace socket
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_ASIO_SOCKET_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/none.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/none.hpp
deleted file mode 100644
index 6c7d352..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/none.hpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_SECURITY_NONE_HPP
-#define WEBSOCKETPP_TRANSPORT_SECURITY_NONE_HPP
-
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-#include <websocketpp/transport/asio/security/base.hpp>
-
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <sstream>
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-namespace asio {
-/// A socket policy for the asio transport that implements a plain, unencrypted
-/// socket
-namespace basic_socket {
-
-/// The signature of the socket init handler for this socket policy
-typedef lib::function<void(connection_hdl,lib::asio::ip::tcp::socket&)>
-    socket_init_handler;
-
-/// Basic Asio connection socket component
-/**
- * transport::asio::basic_socket::connection implements a connection socket
- * component using Asio ip::tcp::socket.
- */
-class connection : public lib::enable_shared_from_this<connection> {
-public:
-    /// Type of this connection socket component
-    typedef connection type;
-    /// Type of a shared pointer to this connection socket component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of a pointer to the Asio io_service being used
-    typedef lib::asio::io_service* io_service_ptr;
-    /// Type of a pointer to the Asio io_service strand being used
-    typedef lib::shared_ptr<lib::asio::io_service::strand> strand_ptr;
-    /// Type of the ASIO socket being used
-    typedef lib::asio::ip::tcp::socket socket_type;
-    /// Type of a shared pointer to the socket being used.
-    typedef lib::shared_ptr<socket_type> socket_ptr;
-
-    explicit connection() : m_state(UNINITIALIZED) {
-        //std::cout << "transport::asio::basic_socket::connection constructor"
-        //          << std::endl;
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return shared_from_this();
-    }
-
-    /// Check whether or not this connection is secure
-    /**
-     * @return Whether or not this connection is secure
-     */
-    bool is_secure() const {
-        return false;
-    }
-
-    /// Set the socket initialization handler
-    /**
-     * The socket initialization handler is called after the socket object is
-     * created but before it is used. This gives the application a chance to
-     * set any Asio socket options it needs.
-     *
-     * @param h The new socket_init_handler
-     */
-    void set_socket_init_handler(socket_init_handler h) {
-        m_socket_init_handler = h;
-    }
-
-    /// Retrieve a pointer to the underlying socket
-    /**
-     * This is used internally. It can also be used to set socket options, etc
-     */
-    lib::asio::ip::tcp::socket & get_socket() {
-        return *m_socket;
-    }
-
-    /// Retrieve a pointer to the underlying socket
-    /**
-     * This is used internally.
-     */
-    lib::asio::ip::tcp::socket & get_next_layer() {
-        return *m_socket;
-    }
-
-    /// Retrieve a pointer to the underlying socket
-    /**
-     * This is used internally. It can also be used to set socket options, etc
-     */
-    lib::asio::ip::tcp::socket & get_raw_socket() {
-        return *m_socket;
-    }
-
-    /// Get the remote endpoint address
-    /**
-     * The iostream transport has no information about the ultimate remote
-     * endpoint. It will return the string "iostream transport". To indicate
-     * this.
-     *
-     * TODO: allow user settable remote endpoint addresses if this seems useful
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint(lib::error_code & ec) const {
-        std::stringstream s;
-
-        lib::asio::error_code aec;
-        lib::asio::ip::tcp::endpoint ep = m_socket->remote_endpoint(aec);
-
-        if (aec) {
-            ec = error::make_error_code(error::pass_through);
-            s << "Error getting remote endpoint: " << aec
-               << " (" << aec.message() << ")";
-            return s.str();
-        } else {
-            ec = lib::error_code();
-            s << ep;
-            return s.str();
-        }
-    }
-protected:
-    /// Perform one time initializations
-    /**
-     * init_asio is called once immediately after construction to initialize
-     * Asio components to the io_service
-     *
-     * @param service A pointer to the endpoint's io_service
-     * @param strand A shared pointer to the connection's asio strand
-     * @param is_server Whether or not the endpoint is a server or not.
-     */
-    lib::error_code init_asio (io_service_ptr service, strand_ptr, bool)
-    {
-        if (m_state != UNINITIALIZED) {
-            return socket::make_error_code(socket::error::invalid_state);
-        }
-
-        m_socket.reset(new lib::asio::ip::tcp::socket(*service));
-
-        if (m_socket_init_handler) {
-            m_socket_init_handler(m_hdl, *m_socket);
-        }
-
-        m_state = READY;
-
-        return lib::error_code();
-    }
-
-    /// Set uri hook
-    /**
-     * Called by the transport as a connection is being established to provide
-     * the uri being connected to to the security/socket layer.
-     *
-     * This socket policy doesn't use the uri so it is ignored.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr) {}
-
-    /// Pre-initialize security policy
-    /**
-     * Called by the transport after a new connection is created to initialize
-     * the socket component of the connection. This method is not allowed to
-     * write any bytes to the wire. This initialization happens before any
-     * proxies or other intermediate wrappers are negotiated.
-     *
-     * @param callback Handler to call back with completion information
-     */
-    void pre_init(init_handler callback) {
-        if (m_state != READY) {
-            callback(socket::make_error_code(socket::error::invalid_state));
-            return;
-        }
-
-        m_state = READING;
-
-        callback(lib::error_code());
-    }
-
-    /// Post-initialize security policy
-    /**
-     * Called by the transport after all intermediate proxies have been
-     * negotiated. This gives the security policy the chance to talk with the
-     * real remote endpoint for a bit before the websocket handshake.
-     *
-     * @param callback Handler to call back with completion information
-     */
-    void post_init(init_handler callback) {
-        callback(lib::error_code());
-    }
-
-    /// Sets the connection handle
-    /**
-     * The connection handle is passed to any handlers to identify the
-     * connection
-     *
-     * @param hdl The new handle
-     */
-    void set_handle(connection_hdl hdl) {
-        m_hdl = hdl;
-    }
-
-    /// Cancel all async operations on this socket
-    /**
-     * Attempts to cancel all async operations on this socket and reports any
-     * failures.
-     *
-     * NOTE: Windows XP and earlier do not support socket cancellation.
-     *
-     * @return The error that occurred, if any.
-     */
-    lib::asio::error_code cancel_socket() {
-        lib::asio::error_code ec;
-        m_socket->cancel(ec);
-        return ec;
-    }
-
-    void async_shutdown(socket::shutdown_handler h) {
-        lib::asio::error_code ec;
-        m_socket->shutdown(lib::asio::ip::tcp::socket::shutdown_both, ec);
-        h(ec);
-    }
-
-    lib::error_code get_ec() const {
-        return lib::error_code();
-    }
-
-public:
-    /// Translate any security policy specific information about an error code
-    /**
-     * Translate_ec takes an Asio error code and attempts to convert its value 
-     * to an appropriate websocketpp error code. In the case that the Asio and
-     * Websocketpp error types are the same (such as using boost::asio and
-     * boost::system_error or using standalone asio and std::system_error the
-     * code will be passed through natively.
-     *
-     * In the case of a mismatch (boost::asio with std::system_error) a
-     * translated code will be returned. The plain socket policy does not have 
-     * any additional information so all such errors will be reported as the
-     * generic transport pass_through error.
-     *
-     * @since 0.3.0
-     *
-     * @param ec The error code to translate_ec
-     * @return The translated error code
-     */
-    template <typename ErrorCodeType>
-    static
-    lib::error_code translate_ec(ErrorCodeType) {
-        // We don't know any more information about this error so pass through
-        return make_error_code(transport::error::pass_through);
-    }
-
-    static
-    /// Overload of translate_ec to catch cases where lib::error_code is the 
-    /// same type as lib::asio::error_code
-    lib::error_code translate_ec(lib::error_code ec) {
-        // We don't know any more information about this error, but the error is
-        // the same type as the one we are translating to, so pass through
-        // untranslated.
-        return ec;
-    }
-private:
-    enum state {
-        UNINITIALIZED = 0,
-        READY = 1,
-        READING = 2
-    };
-
-    socket_ptr          m_socket;
-    state               m_state;
-
-    connection_hdl      m_hdl;
-    socket_init_handler m_socket_init_handler;
-};
-
-/// Basic ASIO endpoint socket component
-/**
- * transport::asio::basic_socket::endpoint implements an endpoint socket
- * component that uses Boost ASIO's ip::tcp::socket.
- */
-class endpoint {
-public:
-    /// The type of this endpoint socket component
-    typedef endpoint type;
-
-    /// The type of the corresponding connection socket component
-    typedef connection socket_con_type;
-    /// The type of a shared pointer to the corresponding connection socket
-    /// component.
-    typedef socket_con_type::ptr socket_con_ptr;
-
-    explicit endpoint() {}
-
-    /// Checks whether the endpoint creates secure connections
-    /**
-     * @return Whether or not the endpoint creates secure connections
-     */
-    bool is_secure() const {
-        return false;
-    }
-
-    /// Set socket init handler
-    /**
-     * The socket init handler is called after a connection's socket is created
-     * but before it is used. This gives the end application an opportunity to
-     * set asio socket specific parameters.
-     *
-     * @param h The new socket_init_handler
-     */
-    void set_socket_init_handler(socket_init_handler h) {
-        m_socket_init_handler = h;
-    }
-protected:
-    /// Initialize a connection
-    /**
-     * Called by the transport after a new connection is created to initialize
-     * the socket component of the connection.
-     *
-     * @param scon Pointer to the socket component of the connection
-     *
-     * @return Error code (empty on success)
-     */
-    lib::error_code init(socket_con_ptr scon) {
-        scon->set_socket_init_handler(m_socket_init_handler);
-        return lib::error_code();
-    }
-private:
-    socket_init_handler m_socket_init_handler;
-};
-
-} // namespace basic_socket
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_SECURITY_NONE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/tls.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/tls.hpp
deleted file mode 100644
index 04ac379..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/asio/security/tls.hpp
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_SECURITY_TLS_HPP
-#define WEBSOCKETPP_TRANSPORT_SECURITY_TLS_HPP
-
-#include <websocketpp/transport/asio/security/base.hpp>
-
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/common/asio_ssl.hpp>
-#include <websocketpp/common/asio.hpp>
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/memory.hpp>
-
-#include <sstream>
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-namespace asio {
-/// A socket policy for the asio transport that implements a TLS encrypted
-/// socket by wrapping with an asio::ssl::stream
-namespace tls_socket {
-
-/// The signature of the socket_init_handler for this socket policy
-typedef lib::function<void(connection_hdl,lib::asio::ssl::stream<
-    lib::asio::ip::tcp::socket>&)> socket_init_handler;
-/// The signature of the tls_init_handler for this socket policy
-typedef lib::function<lib::shared_ptr<lib::asio::ssl::context>(connection_hdl)>
-    tls_init_handler;
-
-/// TLS enabled Asio connection socket component
-/**
- * transport::asio::tls_socket::connection implements a secure connection socket
- * component that uses Asio's ssl::stream to wrap an ip::tcp::socket.
- */
-class connection : public lib::enable_shared_from_this<connection> {
-public:
-    /// Type of this connection socket component
-    typedef connection type;
-    /// Type of a shared pointer to this connection socket component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of the ASIO socket being used
-    typedef lib::asio::ssl::stream<lib::asio::ip::tcp::socket> socket_type;
-    /// Type of a shared pointer to the ASIO socket being used
-    typedef lib::shared_ptr<socket_type> socket_ptr;
-    /// Type of a pointer to the ASIO io_service being used
-    typedef lib::asio::io_service * io_service_ptr;
-    /// Type of a pointer to the ASIO io_service strand being used
-    typedef lib::shared_ptr<lib::asio::io_service::strand> strand_ptr;
-    /// Type of a shared pointer to the ASIO TLS context being used
-    typedef lib::shared_ptr<lib::asio::ssl::context> context_ptr;
-
-    explicit connection() {
-        //std::cout << "transport::asio::tls_socket::connection constructor"
-        //          << std::endl;
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return shared_from_this();
-    }
-
-    /// Check whether or not this connection is secure
-    /**
-     * @return Whether or not this connection is secure
-     */
-    bool is_secure() const {
-        return true;
-    }
-
-    /// Retrieve a pointer to the underlying socket
-    /**
-     * This is used internally. It can also be used to set socket options, etc
-     */
-    socket_type::lowest_layer_type & get_raw_socket() {
-        return m_socket->lowest_layer();
-    }
-
-    /// Retrieve a pointer to the layer below the ssl stream
-    /**
-     * This is used internally.
-     */
-    socket_type::next_layer_type & get_next_layer() {
-        return m_socket->next_layer();
-    }
-
-    /// Retrieve a pointer to the wrapped socket
-    /**
-     * This is used internally.
-     */
-    socket_type & get_socket() {
-        return *m_socket;
-    }
-
-    /// Set the socket initialization handler
-    /**
-     * The socket initialization handler is called after the socket object is
-     * created but before it is used. This gives the application a chance to
-     * set any ASIO socket options it needs.
-     *
-     * @param h The new socket_init_handler
-     */
-    void set_socket_init_handler(socket_init_handler h) {
-        m_socket_init_handler = h;
-    }
-
-    /// Set TLS init handler
-    /**
-     * The tls init handler is called when needed to request a TLS context for
-     * the library to use. A TLS init handler must be set and it must return a
-     * valid TLS context in order for this endpoint to be able to initialize
-     * TLS connections
-     *
-     * @param h The new tls_init_handler
-     */
-    void set_tls_init_handler(tls_init_handler h) {
-        m_tls_init_handler = h;
-    }
-
-    /// Get the remote endpoint address
-    /**
-     * The iostream transport has no information about the ultimate remote
-     * endpoint. It will return the string "iostream transport". To indicate
-     * this.
-     *
-     * TODO: allow user settable remote endpoint addresses if this seems useful
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint(lib::error_code & ec) const {
-        std::stringstream s;
-
-        lib::asio::error_code aec;
-        lib::asio::ip::tcp::endpoint ep = m_socket->lowest_layer().remote_endpoint(aec);
-
-        if (aec) {
-            ec = error::make_error_code(error::pass_through);
-            s << "Error getting remote endpoint: " << aec
-               << " (" << aec.message() << ")";
-            return s.str();
-        } else {
-            ec = lib::error_code();
-            s << ep;
-            return s.str();
-        }
-    }
-protected:
-    /// Perform one time initializations
-    /**
-     * init_asio is called once immediately after construction to initialize
-     * Asio components to the io_service
-     *
-     * @param service A pointer to the endpoint's io_service
-     * @param strand A pointer to the connection's strand
-     * @param is_server Whether or not the endpoint is a server or not.
-     */
-    lib::error_code init_asio (io_service_ptr service, strand_ptr strand,
-        bool is_server)
-    {
-        if (!m_tls_init_handler) {
-            return socket::make_error_code(socket::error::missing_tls_init_handler);
-        }
-        m_context = m_tls_init_handler(m_hdl);
-
-        if (!m_context) {
-            return socket::make_error_code(socket::error::invalid_tls_context);
-        }
-        m_socket.reset(new socket_type(*service, *m_context));
-
-        if (m_socket_init_handler) {
-            m_socket_init_handler(m_hdl, get_socket());
-        }
-
-        m_io_service = service;
-        m_strand = strand;
-        m_is_server = is_server;
-
-        return lib::error_code();
-    }
-
-    /// Set hostname hook
-    /**
-     * Called by the transport as a connection is being established to provide
-     * the hostname being connected to to the security/socket layer.
-     *
-     * This socket policy uses the hostname to set the appropriate TLS SNI
-     * header.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr u) {
-        m_uri = u;
-    }
-
-    /// Pre-initialize security policy
-    /**
-     * Called by the transport after a new connection is created to initialize
-     * the socket component of the connection. This method is not allowed to
-     * write any bytes to the wire. This initialization happens before any
-     * proxies or other intermediate wrappers are negotiated.
-     *
-     * @param callback Handler to call back with completion information
-     */
-    void pre_init(init_handler callback) {
-        // TODO: is this the best way to check whether this function is 
-        //       available in the version of OpenSSL being used?
-        // TODO: consider case where host is an IP address
-#if OPENSSL_VERSION_NUMBER >= 0x90812f
-        if (!m_is_server) {
-            // For clients on systems with a suitable OpenSSL version, set the
-            // TLS SNI hostname header so connecting to TLS servers using SNI
-            // will work.
-            long res = SSL_set_tlsext_host_name(
-                get_socket().native_handle(), m_uri->get_host().c_str());
-            if (!(1 == res)) {
-                callback(socket::make_error_code(socket::error::tls_failed_sni_hostname));
-            }
-        }
-#endif
-
-        callback(lib::error_code());
-    }
-
-    /// Post-initialize security policy
-    /**
-     * Called by the transport after all intermediate proxies have been
-     * negotiated. This gives the security policy the chance to talk with the
-     * real remote endpoint for a bit before the websocket handshake.
-     *
-     * @param callback Handler to call back with completion information
-     */
-    void post_init(init_handler callback) {
-        m_ec = socket::make_error_code(socket::error::tls_handshake_timeout);
-
-        // TLS handshake
-        if (m_strand) {
-            m_socket->async_handshake(
-                get_handshake_type(),
-                m_strand->wrap(lib::bind(
-                    &type::handle_init, get_shared(),
-                    callback,
-                    lib::placeholders::_1
-                ))
-            );
-        } else {
-            m_socket->async_handshake(
-                get_handshake_type(),
-                lib::bind(
-                    &type::handle_init, get_shared(),
-                    callback,
-                    lib::placeholders::_1
-                )
-            );
-        }
-    }
-
-    /// Sets the connection handle
-    /**
-     * The connection handle is passed to any handlers to identify the
-     * connection
-     *
-     * @param hdl The new handle
-     */
-    void set_handle(connection_hdl hdl) {
-        m_hdl = hdl;
-    }
-
-    void handle_init(init_handler callback,lib::asio::error_code const & ec) {
-        if (ec) {
-            m_ec = socket::make_error_code(socket::error::tls_handshake_failed);
-        } else {
-            m_ec = lib::error_code();
-        }
-
-        callback(m_ec);
-    }
-
-    lib::error_code get_ec() const {
-        return m_ec;
-    }
-
-    /// Cancel all async operations on this socket
-    /**
-     * Attempts to cancel all async operations on this socket and reports any
-     * failures.
-     *
-     * NOTE: Windows XP and earlier do not support socket cancellation.
-     *
-     * @return The error that occurred, if any.
-     */
-    lib::asio::error_code cancel_socket() {
-        lib::asio::error_code ec;
-        get_raw_socket().cancel(ec);
-        return ec;
-    }
-
-    void async_shutdown(socket::shutdown_handler callback) {
-        if (m_strand) {
-            m_socket->async_shutdown(m_strand->wrap(callback));
-        } else {
-            m_socket->async_shutdown(callback);
-        }
-    }
-
-public:
-    /// Translate any security policy specific information about an error code
-    /**
-     * Translate_ec takes an Asio error code and attempts to convert its value
-     * to an appropriate websocketpp error code. In the case that the Asio and
-     * Websocketpp error types are the same (such as using boost::asio and
-     * boost::system_error or using standalone asio and std::system_error the
-     * code will be passed through natively.
-     *
-     * In the case of a mismatch (boost::asio with std::system_error) a
-     * translated code will be returned. Any error that is determined to be
-     * related to TLS but does not have a more specific websocketpp error code
-     * is returned under the catch all error `tls_error`. Non-TLS related errors
-     * are returned as the transport generic error `pass_through`
-     *
-     * @since 0.3.0
-     *
-     * @param ec The error code to translate_ec
-     * @return The translated error code
-     */
-    template <typename ErrorCodeType>
-    static
-    lib::error_code translate_ec(ErrorCodeType ec) {
-        if (ec.category() == lib::asio::error::get_ssl_category()) {
-            // We know it is a TLS related error, but otherwise don't know more.
-            // Pass through as TLS generic.
-            return make_error_code(transport::error::tls_error);
-        } else {
-            // We don't know any more information about this error so pass
-            // through
-            return make_error_code(transport::error::pass_through);
-        }
-    }
-
-    static
-    /// Overload of translate_ec to catch cases where lib::error_code is the
-    /// same type as lib::asio::error_code
-    lib::error_code translate_ec(lib::error_code ec) {
-        return ec;
-    }
-private:
-    socket_type::handshake_type get_handshake_type() {
-        if (m_is_server) {
-            return lib::asio::ssl::stream_base::server;
-        } else {
-            return lib::asio::ssl::stream_base::client;
-        }
-    }
-
-    io_service_ptr      m_io_service;
-    strand_ptr          m_strand;
-    context_ptr         m_context;
-    socket_ptr          m_socket;
-    uri_ptr             m_uri;
-    bool                m_is_server;
-
-    lib::error_code     m_ec;
-
-    connection_hdl      m_hdl;
-    socket_init_handler m_socket_init_handler;
-    tls_init_handler    m_tls_init_handler;
-};
-
-/// TLS enabled Asio endpoint socket component
-/**
- * transport::asio::tls_socket::endpoint implements a secure endpoint socket
- * component that uses Asio's ssl::stream to wrap an ip::tcp::socket.
- */
-class endpoint {
-public:
-    /// The type of this endpoint socket component
-    typedef endpoint type;
-
-    /// The type of the corresponding connection socket component
-    typedef connection socket_con_type;
-    /// The type of a shared pointer to the corresponding connection socket
-    /// component.
-    typedef socket_con_type::ptr socket_con_ptr;
-
-    explicit endpoint() {}
-
-    /// Checks whether the endpoint creates secure connections
-    /**
-     * @return Whether or not the endpoint creates secure connections
-     */
-    bool is_secure() const {
-        return true;
-    }
-
-    /// Set socket init handler
-    /**
-     * The socket init handler is called after a connection's socket is created
-     * but before it is used. This gives the end application an opportunity to
-     * set asio socket specific parameters.
-     *
-     * @param h The new socket_init_handler
-     */
-    void set_socket_init_handler(socket_init_handler h) {
-        m_socket_init_handler = h;
-    }
-
-    /// Set TLS init handler
-    /**
-     * The tls init handler is called when needed to request a TLS context for
-     * the library to use. A TLS init handler must be set and it must return a
-     * valid TLS context in order for this endpoint to be able to initialize
-     * TLS connections
-     *
-     * @param h The new tls_init_handler
-     */
-    void set_tls_init_handler(tls_init_handler h) {
-        m_tls_init_handler = h;
-    }
-protected:
-    /// Initialize a connection
-    /**
-     * Called by the transport after a new connection is created to initialize
-     * the socket component of the connection.
-     *
-     * @param scon Pointer to the socket component of the connection
-     *
-     * @return Error code (empty on success)
-     */
-    lib::error_code init(socket_con_ptr scon) {
-        scon->set_socket_init_handler(m_socket_init_handler);
-        scon->set_tls_init_handler(m_tls_init_handler);
-        return lib::error_code();
-    }
-
-private:
-    socket_init_handler m_socket_init_handler;
-    tls_init_handler m_tls_init_handler;
-};
-
-} // namespace tls_socket
-} // namespace asio
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_SECURITY_TLS_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/connection.hpp
deleted file mode 100644
index f76d409..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/connection.hpp
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
-#define WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
-
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-#include <string>
-
-namespace websocketpp {
-/// Transport policies provide network connectivity and timers
-/**
- * ### Connection Interface
- *
- * Transport connection components needs to provide:
- *
- * **init**\n
- * `void init(init_handler handler)`\n
- * Called once shortly after construction to give the policy the chance to
- * perform one time initialization. When complete, the policy must call the
- * supplied `init_handler` to continue setup. The handler takes one argument
- * with the error code if any. If an error is returned here setup will fail and
- * the connection will be aborted or terminated.
- *
- * WebSocket++ will call init only once. The transport must call `handler`
- * exactly once.
- *
- * **async_read_at_least**\n
- * `void async_read_at_least(size_t num_bytes, char *buf, size_t len,
- * read_handler handler)`\n
- * start an async read for at least num_bytes and at most len
- * bytes into buf. Call handler when done with number of bytes read.
- *
- * WebSocket++ promises to have only one async_read_at_least in flight at a
- * time. The transport must promise to only call read_handler once per async
- * read.
- *
- * **async_write**\n
- * `void async_write(const char* buf, size_t len, write_handler handler)`\n
- * `void async_write(std::vector<buffer> & bufs, write_handler handler)`\n
- * Start a write of all of the data in buf or bufs. In second case data is
- * written sequentially and in place without copying anything to a temporary
- * location.
- *
- * Websocket++ promises to have only one async_write in flight at a time.
- * The transport must promise to only call the write_handler once per async
- * write
- *
- * **set_handle**\n
- * `void set_handle(connection_hdl hdl)`\n
- * Called by WebSocket++ to let this policy know the hdl to the connection. It
- * may be stored for later use or ignored/discarded. This handle should be used
- * if the policy adds any connection handlers. Connection handlers must be
- * called with the handle as the first argument so that the handler code knows
- * which connection generated the callback.
- *
- * **set_timer**\n
- * `timer_ptr set_timer(long duration, timer_handler handler)`\n
- * WebSocket++ uses the timers provided by the transport policy as the
- * implementation of timers is often highly coupled with the implementation of
- * the networking event loops.
- *
- * Transport timer support is an optional feature. A transport method may elect
- * to implement a dummy timer object and have this method return an empty
- * pointer. If so, all timer related features of WebSocket++ core will be
- * disabled. This includes many security features designed to prevent denial of
- * service attacks. Use timer-free transport policies with caution.
- *
- * **get_remote_endpoint**\n
- * `std::string get_remote_endpoint()`\n
- * retrieve address of remote endpoint
- *
- * **is_secure**\n
- * `void is_secure()`\n
- * whether or not the connection to the remote endpoint is secure
- *
- * **dispatch**\n
- * `lib::error_code dispatch(dispatch_handler handler)`: invoke handler within
- * the transport's event system if it uses one. Otherwise, this method should
- * simply call `handler` immediately.
- *
- * **async_shutdown**\n
- * `void async_shutdown(shutdown_handler handler)`\n
- * Perform any cleanup necessary (if any). Call `handler` when complete.
- */
-namespace transport {
-
-/// The type and signature of the callback passed to the init hook
-typedef lib::function<void(lib::error_code const &)> init_handler;
-
-/// The type and signature of the callback passed to the read method
-typedef lib::function<void(lib::error_code const &,size_t)> read_handler;
-
-/// The type and signature of the callback passed to the write method
-typedef lib::function<void(lib::error_code const &)> write_handler;
-
-/// The type and signature of the callback passed to the read method
-typedef lib::function<void(lib::error_code const &)> timer_handler;
-
-/// The type and signature of the callback passed to the shutdown method
-typedef lib::function<void(lib::error_code const &)> shutdown_handler;
-
-/// The type and signature of the callback passed to the interrupt method
-typedef lib::function<void()> interrupt_handler;
-
-/// The type and signature of the callback passed to the dispatch method
-typedef lib::function<void()> dispatch_handler;
-
-/// A simple utility buffer class
-struct buffer {
-    buffer(char const * b, size_t l) : buf(b),len(l) {}
-
-    char const * buf;
-    size_t len;
-};
-
-/// Generic transport related errors
-namespace error {
-enum value {
-    /// Catch-all error for transport policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// underlying transport pass through
-    pass_through,
-
-    /// async_read_at_least call requested more bytes than buffer can store
-    invalid_num_bytes,
-
-    /// async_read called while another async_read was in progress
-    double_read,
-
-    /// Operation aborted
-    operation_aborted,
-
-    /// Operation not supported
-    operation_not_supported,
-
-    /// End of file
-    eof,
-
-    /// TLS short read
-    tls_short_read,
-
-    /// Timer expired
-    timeout,
-
-    /// read or write after shutdown
-    action_after_shutdown,
-
-    /// Other TLS error
-    tls_error
-};
-
-class category : public lib::error_category {
-    public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic transport policy error";
-            case pass_through:
-                return "Underlying Transport Error";
-            case invalid_num_bytes:
-                return "async_read_at_least call requested more bytes than buffer can store";
-            case operation_aborted:
-                return "The operation was aborted";
-            case operation_not_supported:
-                return "The operation is not supported by this transport";
-            case eof:
-                return "End of File";
-            case tls_short_read:
-                return "TLS Short Read";
-            case timeout:
-                return "Timer Expired";
-            case action_after_shutdown:
-                return "A transport action was requested after shutdown";
-            case tls_error:
-                return "Generic TLS related error";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace transport
-} // namespace websocketpp
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::transport::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif // WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/endpoint.hpp
deleted file mode 100644
index 4ed3e70..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/base/endpoint.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_BASE_HPP
-
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/system_error.hpp>
-
-namespace websocketpp {
-/// Transport policies provide network connectivity and timers
-/**
- * ### Endpoint Interface
- *
- * Transport endpoint components needs to provide:
- *
- * **init**\n
- * `lib::error_code init(transport_con_ptr tcon)`\n
- * init is called by an endpoint once for each newly created connection.
- * It's purpose is to give the transport policy the chance to perform any
- * transport specific initialization that couldn't be done via the default
- * constructor.
- *
- * **is_secure**\n
- * `bool is_secure() const`\n
- * Test whether the transport component of this endpoint is capable of secure
- * connections.
- *
- * **async_connect**\n
- * `void async_connect(transport_con_ptr tcon, uri_ptr location,
- *  connect_handler handler)`\n
- * Initiate a connection to `location` using the given connection `tcon`. `tcon`
- * is a pointer to the transport connection component of the connection. When
- * complete, `handler` should be called with the the connection's
- * `connection_hdl` and any error that occurred.
- *
- * **init_logging**
- * `void init_logging(const lib::shared_ptr<alog_type>& a, const lib::shared_ptr<elog_type>& e)`\n
- * Called once after construction to provide pointers to the endpoint's access
- * and error loggers. These may be stored and used to log messages or ignored.
- */
-namespace transport {
-
-/// The type and signature of the callback passed to the accept method
-typedef lib::function<void(lib::error_code const &)> accept_handler;
-
-/// The type and signature of the callback passed to the connect method
-typedef lib::function<void(lib::error_code const &)> connect_handler;
-
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/base.hpp
deleted file mode 100644
index 2e477b5..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/base.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_DEBUG_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_DEBUG_BASE_HPP
-
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/cpp11.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-/// Debug transport policy that is used for various mocking and stubbing duties
-/// in unit tests.
-namespace debug {
-
-/// debug transport errors
-namespace error {
-enum value {
-    /// Catch-all error for transport policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// not implemented
-    not_implemented,
-    
-    invalid_num_bytes,
-    
-    double_read
-};
-
-/// debug transport error category
-class category : public lib::error_category {
-    public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport.debug";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic stub transport policy error";
-            case not_implemented:
-                return "feature not implemented";
-            case invalid_num_bytes:
-                return "Invalid number of bytes";
-            case double_read:
-                return "Read while another read was outstanding";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the debug transport error category
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-/// Get an error code with the given value and the debug transport category
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace debug
-} // namespace transport
-} // namespace websocketpp
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::transport::debug::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif // WEBSOCKETPP_TRANSPORT_DEBUG_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/connection.hpp
deleted file mode 100644
index ce13969..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/connection.hpp
+++ /dev/null
@@ -1,412 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_DEBUG_CON_HPP
-#define WEBSOCKETPP_TRANSPORT_DEBUG_CON_HPP
-
-#include <websocketpp/transport/debug/base.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-
-#include <websocketpp/uri.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/platforms.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace transport {
-namespace debug {
-
-/// Empty timer class to stub out for timer functionality that stub
-/// transport doesn't support
-struct timer {
-    void cancel() {}
-};
-
-template <typename config>
-class connection : public lib::enable_shared_from_this< connection<config> > {
-public:
-    /// Type of this connection transport component
-    typedef connection<config> type;
-    /// Type of a shared pointer to this connection transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// transport concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this transport's access logging policy
-    typedef typename config::alog_type alog_type;
-    /// Type of this transport's error logging policy
-    typedef typename config::elog_type elog_type;
-
-    // Concurrency policy types
-    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
-    typedef typename concurrency_type::mutex_type mutex_type;
-
-    typedef lib::shared_ptr<timer> timer_ptr;
-
-    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
-      : m_reading(false), m_is_server(is_server), m_alog(alog), m_elog(elog)
-    {
-        m_alog->write(log::alevel::devel,"debug con transport constructor");
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return type::shared_from_this();
-    }
-
-    /// Set whether or not this connection is secure
-    /**
-     * Todo: docs
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not this connection is secure.
-     */
-    void set_secure(bool) {}
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * TODO: docs
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return false;
-    }
-
-    /// Set uri hook
-    /**
-     * Called by the endpoint as a connection is being established to provide
-     * the uri being connected to to the transport layer.
-     *
-     * Implementation is optional and can be ignored if the transport has no
-     * need for this information.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr) {}
-
-    /// Set human readable remote endpoint address
-    /**
-     * Sets the remote endpoint address returned by `get_remote_endpoint`. This
-     * value should be a human readable string that describes the remote
-     * endpoint. Typically an IP address or hostname, perhaps with a port. But
-     * may be something else depending on the nature of the underlying
-     * transport.
-     *
-     * If none is set a default is returned.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value The remote endpoint address to set.
-     */
-    void set_remote_endpoint(std::string) {}
-
-    /// Get human readable remote endpoint address
-    /**
-     * TODO: docs
-     *
-     * This value is used in access and error logs and is available to the end
-     * application for including in user facing interfaces and messages.
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint() const {
-        return "unknown (debug transport)";
-    }
-
-    /// Get the connection handle
-    /**
-     * @return The handle for this connection.
-     */
-    connection_hdl get_handle() const {
-        return connection_hdl();
-    }
-
-    /// Call back a function after a period of time.
-    /**
-     * Timers are not implemented in this transport. The timer pointer will
-     * always be empty. The handler will never be called.
-     *
-     * @param duration Length of time to wait in milliseconds
-     * @param callback The function to call back when the timer has expired
-     * @return A handle that can be used to cancel the timer if it is no longer
-     * needed.
-     */
-    timer_ptr set_timer(long, timer_handler handler) {
-        m_alog->write(log::alevel::devel,"debug connection set timer");
-        m_timer_handler = handler;
-        return timer_ptr();
-    }
-    
-    /// Manual input supply (read all)
-    /**
-     * Similar to read_some, but continues to read until all bytes in the
-     * supplied buffer have been read or the connection runs out of read
-     * requests.
-     *
-     * This method still may not read all of the bytes in the input buffer. if
-     * it doesn't it indicates that the connection was most likely closed or
-     * is in an error state where it is no longer accepting new input.
-     *
-     * @since 0.3.0
-     *
-     * @param buf Char buffer to read into the websocket
-     * @param len Length of buf
-     * @return The number of characters from buf actually read.
-     */
-    size_t read_all(char const * buf, size_t len) {        
-        size_t total_read = 0;
-        size_t temp_read = 0;
-
-        do {
-            temp_read = this->read_some_impl(buf+total_read,len-total_read);
-            total_read += temp_read;
-        } while (temp_read != 0 && total_read < len);
-
-        return total_read;
-    }
-    
-    // debug stuff to invoke the async handlers
-    void expire_timer(lib::error_code const & ec) {
-        m_timer_handler(ec);
-    }
-    
-    void fullfil_write() {
-        m_write_handler(lib::error_code());
-    }
-protected:
-    /// Initialize the connection transport
-    /**
-     * Initialize the connection's transport component.
-     *
-     * @param handler The `init_handler` to call when initialization is done
-     */
-    void init(init_handler handler) {
-        m_alog->write(log::alevel::devel,"debug connection init");
-        handler(lib::error_code());
-    }
-
-    /// Initiate an async_read for at least num_bytes bytes into buf
-    /**
-     * Initiates an async_read request for at least num_bytes bytes. The input
-     * will be read into buf. A maximum of len bytes will be input. When the
-     * operation is complete, handler will be called with the status and number
-     * of bytes read.
-     *
-     * This method may or may not call handler from within the initial call. The
-     * application should be prepared to accept either.
-     *
-     * The application should never call this method a second time before it has
-     * been called back for the first read. If this is done, the second read
-     * will be called back immediately with a double_read error.
-     *
-     * If num_bytes or len are zero handler will be called back immediately
-     * indicating success.
-     *
-     * @param num_bytes Don't call handler until at least this many bytes have
-     * been read.
-     * @param buf The buffer to read bytes into
-     * @param len The size of buf. At maximum, this many bytes will be read.
-     * @param handler The callback to invoke when the operation is complete or
-     * ends in an error
-     */
-    void async_read_at_least(size_t num_bytes, char * buf, size_t len,
-        read_handler handler)
-    {
-        std::stringstream s;
-        s << "debug_con async_read_at_least: " << num_bytes;
-        m_alog->write(log::alevel::devel,s.str());
-
-        if (num_bytes > len) {
-            handler(make_error_code(error::invalid_num_bytes),size_t(0));
-            return;
-        }
-
-        if (m_reading == true) {
-            handler(make_error_code(error::double_read),size_t(0));
-            return;
-        }
-
-        if (num_bytes == 0 || len == 0) {
-            handler(lib::error_code(),size_t(0));
-            return;
-        }
-
-        m_buf = buf;
-        m_len = len;
-        m_bytes_needed = num_bytes;
-        m_read_handler = handler;
-        m_cursor = 0;
-        m_reading = true;
-    }
-
-    /// Asyncronous Transport Write
-    /**
-     * Write len bytes in buf to the output stream. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success.
-     *
-     * @param buf buffer to read bytes from
-     * @param len number of bytes to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(char const *, size_t, write_handler handler) {
-        m_alog->write(log::alevel::devel,"debug_con async_write");
-        m_write_handler = handler;
-    }
-
-    /// Asyncronous Transport Write (scatter-gather)
-    /**
-     * Write a sequence of buffers to the output stream. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success.
-     *
-     * @param bufs vector of buffers to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(std::vector<buffer> const &, write_handler handler) {
-        m_alog->write(log::alevel::devel,"debug_con async_write buffer list");
-        m_write_handler = handler;
-    }
-
-    /// Set Connection Handle
-    /**
-     * @param hdl The new handle
-     */
-    void set_handle(connection_hdl) {}
-
-    /// Call given handler back within the transport's event system (if present)
-    /**
-     * Invoke a callback within the transport's event system if it has one. If
-     * it doesn't, the handler will be invoked immediately before this function
-     * returns.
-     *
-     * @param handler The callback to invoke
-     *
-     * @return Whether or not the transport was able to register the handler for
-     * callback.
-     */
-    lib::error_code dispatch(dispatch_handler handler) {
-        handler();
-        return lib::error_code();
-    }
-
-    /// Perform cleanup on socket shutdown_handler
-    /**
-     * @param h The `shutdown_handler` to call back when complete
-     */
-    void async_shutdown(shutdown_handler handler) {
-        handler(lib::error_code());
-    }
-    
-    size_t read_some_impl(char const * buf, size_t len) {
-        m_alog->write(log::alevel::devel,"debug_con read_some");
-
-        if (!m_reading) {
-            m_elog->write(log::elevel::devel,"write while not reading");
-            return 0;
-        }
-
-        size_t bytes_to_copy = (std::min)(len,m_len-m_cursor);
-
-        std::copy(buf,buf+bytes_to_copy,m_buf+m_cursor);
-
-        m_cursor += bytes_to_copy;
-
-        if (m_cursor >= m_bytes_needed) {
-            complete_read(lib::error_code());
-        }
-
-        return bytes_to_copy;
-    }
-
-    /// Signal that a requested read is complete
-    /**
-     * Sets the reading flag to false and returns the handler that should be
-     * called back with the result of the read. The cursor position that is sent
-     * is whatever the value of m_cursor is.
-     *
-     * It MUST NOT be called when m_reading is false.
-     * it MUST be called while holding the read lock
-     *
-     * It is important to use this method rather than directly setting/calling
-     * m_read_handler back because this function makes sure to delete the
-     * locally stored handler which contains shared pointers that will otherwise
-     * cause circular reference based memory leaks.
-     *
-     * @param ec The error code to forward to the read handler
-     */
-    void complete_read(lib::error_code const & ec) {
-        m_reading = false;
-
-        read_handler handler = m_read_handler;
-        m_read_handler = read_handler();
-
-        handler(ec,m_cursor);
-    }
-private:
-    timer_handler m_timer_handler;
-    
-    // Read space (Protected by m_read_mutex)
-    char *          m_buf;
-    size_t          m_len;
-    size_t          m_bytes_needed;
-    read_handler    m_read_handler;
-    size_t          m_cursor;
-
-    // transport resources
-    connection_hdl  m_connection_hdl;
-    write_handler   m_write_handler;
-    shutdown_handler    m_shutdown_handler;
-
-    bool            m_reading;
-    bool const      m_is_server;
-    bool            m_is_secure;
-    lib::shared_ptr<alog_type>     m_alog;
-    lib::shared_ptr<elog_type>     m_elog;
-    std::string     m_remote_endpoint;
-};
-
-
-} // namespace debug
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_DEBUG_CON_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/endpoint.hpp
deleted file mode 100644
index adc89b3..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/debug/endpoint.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_DEBUG_HPP
-#define WEBSOCKETPP_TRANSPORT_DEBUG_HPP
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/transport/base/endpoint.hpp>
-#include <websocketpp/transport/debug/connection.hpp>
-
-namespace websocketpp {
-namespace transport {
-namespace debug {
-
-template <typename config>
-class endpoint {
-public:
-    /// Type of this endpoint transport component
-    typedef endpoint type;
-    /// Type of a pointer to this endpoint transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of this endpoint's concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this endpoint's error logging policy
-    typedef typename config::elog_type elog_type;
-    /// Type of this endpoint's access logging policy
-    typedef typename config::alog_type alog_type;
-
-    /// Type of this endpoint transport component's associated connection
-    /// transport component.
-    typedef debug::connection<config> transport_con_type;
-    /// Type of a shared pointer to this endpoint transport component's
-    /// associated connection transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    // generate and manage our own io_service
-    explicit endpoint()
-    {
-        //std::cout << "transport::iostream::endpoint constructor" << std::endl;
-    }
-
-    /// Set whether or not endpoint can create secure connections
-    /**
-     * TODO: docs
-     *
-     * Setting this value only indicates whether or not the endpoint is capable
-     * of producing and managing secure connections. Connections produced by
-     * this endpoint must also be individually flagged as secure if they are.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not the endpoint can create secure connections.
-     */
-    void set_secure(bool) {}
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * TODO: docs
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return false;
-    }
-protected:
-    /// Initialize logging
-    /**
-     * The loggers are located in the main endpoint class. As such, the
-     * transport doesn't have direct access to them. This method is called
-     * by the endpoint constructor to allow shared logging from the transport
-     * component. These are raw pointers to member variables of the endpoint.
-     * In particular, they cannot be used in the transport constructor as they
-     * haven't been constructed yet, and cannot be used in the transport
-     * destructor as they will have been destroyed by then.
-     *
-     * @param a A pointer to the access logger to use.
-     * @param e A pointer to the error logger to use.
-     */
-    void init_logging(lib::shared_ptr<alog_type>, lib::shared_ptr<elog_type>) {}
-
-    /// Initiate a new connection
-    /**
-     * @param tcon A pointer to the transport connection component of the
-     * connection to connect.
-     * @param u A URI pointer to the URI to connect to.
-     * @param cb The function to call back with the results when complete.
-     */
-    void async_connect(transport_con_ptr, uri_ptr, connect_handler cb) {
-        cb(lib::error_code());
-    }
-
-    /// Initialize a connection
-    /**
-     * Init is called by an endpoint once for each newly created connection.
-     * It's purpose is to give the transport policy the chance to perform any
-     * transport specific initialization that couldn't be done via the default
-     * constructor.
-     *
-     * @param tcon A pointer to the transport portion of the connection.
-     * @return A status code indicating the success or failure of the operation
-     */
-    lib::error_code init(transport_con_ptr) {
-        return lib::error_code();
-    }
-private:
-
-};
-
-} // namespace debug
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_DEBUG_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/base.hpp
deleted file mode 100644
index f878398..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/base.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_IOSTREAM_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_IOSTREAM_BASE_HPP
-
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/cpp11.hpp>
-#include <websocketpp/common/functional.hpp>
-#include <websocketpp/common/connection_hdl.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace transport {
-/// Transport policy that uses STL iostream for I/O and does not support timers
-namespace iostream {
-
-/// The type and signature of the callback used by iostream transport to write
-typedef lib::function<lib::error_code(connection_hdl, char const *, size_t)>
-    write_handler;
-
-/// The type and signature of the callback used by iostream transport to perform
-/// vectored writes.
-/**
- * If a vectored write handler is not set the standard write handler will be
- * called multiple times.
- */
-typedef lib::function<lib::error_code(connection_hdl, std::vector<transport::buffer> const
-    & bufs)> vector_write_handler;
-
-/// The type and signature of the callback used by iostream transport to signal
-/// a transport shutdown.
-typedef lib::function<lib::error_code(connection_hdl)> shutdown_handler;
-
-/// iostream transport errors
-namespace error {
-enum value {
-    /// Catch-all error for transport policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// async_read_at_least call requested more bytes than buffer can store
-    invalid_num_bytes,
-
-    /// async_read called while another async_read was in progress
-    double_read,
-
-    /// An operation that requires an output stream was attempted before
-    /// setting one.
-    output_stream_required,
-
-    /// stream error
-    bad_stream
-};
-
-/// iostream transport error category
-class category : public lib::error_category {
-    public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport.iostream";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic iostream transport policy error";
-            case invalid_num_bytes:
-                return "async_read_at_least call requested more bytes than buffer can store";
-            case double_read:
-                return "Async read already in progress";
-            case output_stream_required:
-                return "An output stream to be set before async_write can be used";
-            case bad_stream:
-                return "A stream operation returned ios::bad";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the iostream transport error category
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-/// Get an error code with the given value and the iostream transport category
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace iostream
-} // namespace transport
-} // namespace websocketpp
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::transport::iostream::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif // WEBSOCKETPP_TRANSPORT_IOSTREAM_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/connection.hpp
deleted file mode 100644
index 899a3e2..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/connection.hpp
+++ /dev/null
@@ -1,714 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
-#define WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
-
-#include <websocketpp/transport/iostream/base.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-
-#include <websocketpp/uri.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/platforms.hpp>
-
-#include <algorithm>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace transport {
-namespace iostream {
-
-/// Empty timer class to stub out for timer functionality that iostream
-/// transport doesn't support
-struct timer {
-    void cancel() {}
-};
-
-template <typename config>
-class connection : public lib::enable_shared_from_this< connection<config> > {
-public:
-    /// Type of this connection transport component
-    typedef connection<config> type;
-    /// Type of a shared pointer to this connection transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// transport concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this transport's access logging policy
-    typedef typename config::alog_type alog_type;
-    /// Type of this transport's error logging policy
-    typedef typename config::elog_type elog_type;
-
-    // Concurrency policy types
-    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
-    typedef typename concurrency_type::mutex_type mutex_type;
-
-    typedef lib::shared_ptr<timer> timer_ptr;
-
-    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
-      : m_output_stream(NULL)
-      , m_reading(false)
-      , m_is_server(is_server)
-      , m_is_secure(false)
-      , m_alog(alog)
-      , m_elog(elog)
-      , m_remote_endpoint("iostream transport")
-    {
-        m_alog->write(log::alevel::devel,"iostream con transport constructor");
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return type::shared_from_this();
-    }
-
-    /// Register a std::ostream with the transport for writing output
-    /**
-     * Register a std::ostream with the transport. All future writes will be
-     * done to this output stream.
-     *
-     * @param o A pointer to the ostream to use for output.
-     */
-    void register_ostream(std::ostream * o) {
-        // TODO: lock transport state?
-        scoped_lock_type lock(m_read_mutex);
-        m_output_stream = o;
-    }
-
-    /// Set uri hook
-    /**
-     * Called by the endpoint as a connection is being established to provide
-     * the uri being connected to to the transport layer.
-     *
-     * This transport policy doesn't use the uri so it is ignored.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr) {}
-
-    /// Overloaded stream input operator
-    /**
-     * Attempts to read input from the given stream into the transport. Bytes
-     * will be extracted from the input stream to fulfill any pending reads.
-     * Input in this manner will only read until the current read buffer has
-     * been filled. Then it will signal the library to process the input. If the
-     * library's input handler adds a new async_read, additional bytes will be
-     * read, otherwise the input operation will end.
-     *
-     * When this function returns one of the following conditions is true:
-     * - There is no outstanding read operation
-     * - There are no more bytes available in the input stream
-     *
-     * You can use tellg() on the input stream to determine if all of the input
-     * bytes were read or not.
-     *
-     * If there is no pending read operation when the input method is called, it
-     * will return immediately and tellg() will not have changed.
-     */
-    friend std::istream & operator>> (std::istream & in, type & t) {
-        // this serializes calls to external read.
-        scoped_lock_type lock(t.m_read_mutex);
-
-        t.read(in);
-
-        return in;
-    }
-
-    /// Manual input supply (read some)
-    /**
-     * Copies bytes from buf into WebSocket++'s input buffers. Bytes will be
-     * copied from the supplied buffer to fulfill any pending library reads. It
-     * will return the number of bytes successfully processed. If there are no
-     * pending reads read_some will return immediately. Not all of the bytes may
-     * be able to be read in one call.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param buf Char buffer to read into the websocket
-     * @param len Length of buf
-     * @return The number of characters from buf actually read.
-     */
-    size_t read_some(char const * buf, size_t len) {
-        // this serializes calls to external read.
-        scoped_lock_type lock(m_read_mutex);
-
-        return this->read_some_impl(buf,len);
-    }
-
-    /// Manual input supply (read all)
-    /**
-     * Similar to read_some, but continues to read until all bytes in the
-     * supplied buffer have been read or the connection runs out of read
-     * requests.
-     *
-     * This method still may not read all of the bytes in the input buffer. if
-     * it doesn't it indicates that the connection was most likely closed or
-     * is in an error state where it is no longer accepting new input.
-     *
-     * @since 0.3.0
-     *
-     * @param buf Char buffer to read into the websocket
-     * @param len Length of buf
-     * @return The number of characters from buf actually read.
-     */
-    size_t read_all(char const * buf, size_t len) {
-        // this serializes calls to external read.
-        scoped_lock_type lock(m_read_mutex);
-
-        size_t total_read = 0;
-        size_t temp_read = 0;
-
-        do {
-            temp_read = this->read_some_impl(buf+total_read,len-total_read);
-            total_read += temp_read;
-        } while (temp_read != 0 && total_read < len);
-
-        return total_read;
-    }
-
-    /// Manual input supply (DEPRECATED)
-    /**
-     * @deprecated DEPRECATED in favor of read_some()
-     * @see read_some()
-     */
-    size_t readsome(char const * buf, size_t len) {
-        return this->read_some(buf,len);
-    }
-
-    /// Signal EOF
-    /**
-     * Signals to the transport that data stream being read has reached EOF and
-     * that no more bytes may be read or written to/from the transport.
-     *
-     * @since 0.3.0-alpha4
-     */
-    void eof() {
-        // this serializes calls to external read.
-        scoped_lock_type lock(m_read_mutex);
-
-        if (m_reading) {
-            complete_read(make_error_code(transport::error::eof));
-        }
-    }
-
-    /// Signal transport error
-    /**
-     * Signals to the transport that a fatal data stream error has occurred and
-     * that no more bytes may be read or written to/from the transport.
-     *
-     * @since 0.3.0-alpha4
-     */
-    void fatal_error() {
-        // this serializes calls to external read.
-        scoped_lock_type lock(m_read_mutex);
-
-        if (m_reading) {
-            complete_read(make_error_code(transport::error::pass_through));
-        }
-    }
-
-    /// Set whether or not this connection is secure
-    /**
-     * The iostream transport does not provide any security features. As such
-     * it defaults to returning false when `is_secure` is called. However, the
-     * iostream transport may be used to wrap an external socket API that may
-     * provide secure transport. This method allows that external API to flag
-     * whether or not this connection is secure so that users of the WebSocket++
-     * API will get more accurate information.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not this connection is secure.
-     */
-    void set_secure(bool value) {
-        m_is_secure = value;
-    }
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * iostream transport will return false always because it has no information
-     * about the ultimate remote endpoint. This may or may not be accurate
-     * depending on the real source of bytes being input. The `set_secure`
-     * method may be used to flag connections that are secured by an external
-     * API
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return m_is_secure;
-    }
-
-    /// Set human readable remote endpoint address
-    /**
-     * Sets the remote endpoint address returned by `get_remote_endpoint`. This
-     * value should be a human readable string that describes the remote
-     * endpoint. Typically an IP address or hostname, perhaps with a port. But
-     * may be something else depending on the nature of the underlying
-     * transport.
-     *
-     * If none is set the default is "iostream transport".
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value The remote endpoint address to set.
-     */
-    void set_remote_endpoint(std::string value) {
-        m_remote_endpoint = value;
-    }
-
-    /// Get human readable remote endpoint address
-    /**
-     * The iostream transport has no information about the ultimate remote
-     * endpoint. It will return the string "iostream transport". The
-     * `set_remote_endpoint` method may be used by external network code to set
-     * a more accurate value.
-     *
-     * This value is used in access and error logs and is available to the end
-     * application for including in user facing interfaces and messages.
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint() const {
-        return m_remote_endpoint;
-    }
-
-    /// Get the connection handle
-    /**
-     * @return The handle for this connection.
-     */
-    connection_hdl get_handle() const {
-        return m_connection_hdl;
-    }
-
-    /// Call back a function after a period of time.
-    /**
-     * Timers are not implemented in this transport. The timer pointer will
-     * always be empty. The handler will never be called.
-     *
-     * @param duration Length of time to wait in milliseconds
-     * @param callback The function to call back when the timer has expired
-     * @return A handle that can be used to cancel the timer if it is no longer
-     * needed.
-     */
-    timer_ptr set_timer(long, timer_handler) {
-        return timer_ptr();
-    }
-
-    /// Sets the write handler
-    /**
-     * The write handler is called when the iostream transport receives data
-     * that needs to be written to the appropriate output location. This handler
-     * can be used in place of registering an ostream for output.
-     *
-     * The signature of the handler is
-     * `lib::error_code (connection_hdl, char const *, size_t)` The
-     * code returned will be reported and logged by the core library.
-     *
-     * See also, set_vector_write_handler, for an optional write handler that
-     * allows more efficient handling of multiple writes at once.
-     *
-     * @see set_vector_write_handler
-     *
-     * @since 0.5.0
-     *
-     * @param h The handler to call when data is to be written.
-     */
-    void set_write_handler(write_handler h) {
-        m_write_handler = h;
-    }
-
-    /// Sets the vectored write handler
-    /**
-     * The vectored write handler is called when the iostream transport receives
-     * multiple chunks of data that need to be written to the appropriate output
-     * location. This handler can be used in conjunction with the write_handler
-     * in place of registering an ostream for output.
-     *
-     * The sequence of buffers represents bytes that should be written
-     * consecutively and it is suggested to group the buffers into as few next
-     * layer packets as possible. Vector write is used to allow implementations
-     * that support it to coalesce writes into a single TCP packet or TLS
-     * segment for improved efficiency.
-     *
-     * This is an optional handler. If it is not defined then multiple calls
-     * will be made to the standard write handler.
-     *
-     * The signature of the handler is
-     * `lib::error_code (connection_hdl, std::vector<websocketpp::transport::buffer>
-     * const & bufs)`. The code returned will be reported and logged by the core
-     * library. The `websocketpp::transport::buffer` type is a struct with two
-     * data members. buf (char const *) and len (size_t).
-     *
-     * @since 0.6.0
-     *
-     * @param h The handler to call when vectored data is to be written.
-     */
-    void set_vector_write_handler(vector_write_handler h) {
-        m_vector_write_handler = h;
-    }
-
-    /// Sets the shutdown handler
-    /**
-     * The shutdown handler is called when the iostream transport receives a
-     * notification from the core library that it is finished with all read and
-     * write operations and that the underlying transport can be cleaned up.
-     *
-     * If you are using iostream transport with another socket library, this is
-     * a good time to close/shutdown the socket for this connection.
-     *
-     * The signature of the handler is `lib::error_code (connection_hdl)`. The
-     * code returned will be reported and logged by the core library.
-     *
-     * @since 0.5.0
-     *
-     * @param h The handler to call on connection shutdown.
-     */
-    void set_shutdown_handler(shutdown_handler h) {
-        m_shutdown_handler = h;
-    }
-protected:
-    /// Initialize the connection transport
-    /**
-     * Initialize the connection's transport component.
-     *
-     * @param handler The `init_handler` to call when initialization is done
-     */
-    void init(init_handler handler) {
-        m_alog->write(log::alevel::devel,"iostream connection init");
-        handler(lib::error_code());
-    }
-
-    /// Initiate an async_read for at least num_bytes bytes into buf
-    /**
-     * Initiates an async_read request for at least num_bytes bytes. The input
-     * will be read into buf. A maximum of len bytes will be input. When the
-     * operation is complete, handler will be called with the status and number
-     * of bytes read.
-     *
-     * This method may or may not call handler from within the initial call. The
-     * application should be prepared to accept either.
-     *
-     * The application should never call this method a second time before it has
-     * been called back for the first read. If this is done, the second read
-     * will be called back immediately with a double_read error.
-     *
-     * If num_bytes or len are zero handler will be called back immediately
-     * indicating success.
-     *
-     * @param num_bytes Don't call handler until at least this many bytes have
-     * been read.
-     * @param buf The buffer to read bytes into
-     * @param len The size of buf. At maximum, this many bytes will be read.
-     * @param handler The callback to invoke when the operation is complete or
-     * ends in an error
-     */
-    void async_read_at_least(size_t num_bytes, char *buf, size_t len,
-        read_handler handler)
-    {
-        std::stringstream s;
-        s << "iostream_con async_read_at_least: " << num_bytes;
-        m_alog->write(log::alevel::devel,s.str());
-
-        if (num_bytes > len) {
-            handler(make_error_code(error::invalid_num_bytes),size_t(0));
-            return;
-        }
-
-        if (m_reading == true) {
-            handler(make_error_code(error::double_read),size_t(0));
-            return;
-        }
-
-        if (num_bytes == 0 || len == 0) {
-            handler(lib::error_code(),size_t(0));
-            return;
-        }
-
-        m_buf = buf;
-        m_len = len;
-        m_bytes_needed = num_bytes;
-        m_read_handler = handler;
-        m_cursor = 0;
-        m_reading = true;
-    }
-
-    /// Asyncronous Transport Write
-    /**
-     * Write len bytes in buf to the output method. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success. Other possible errors (not exhaustive)
-     * output_stream_required: No output stream was registered to write to
-     * bad_stream: a ostream pass through error
-     *
-     * This method will attempt to write to the registered ostream first. If an
-     * ostream is not registered it will use the write handler. If neither are
-     * registered then an error is passed up to the connection.
-     *
-     * @param buf buffer to read bytes from
-     * @param len number of bytes to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(char const * buf, size_t len, transport::write_handler
-        handler)
-    {
-        m_alog->write(log::alevel::devel,"iostream_con async_write");
-        // TODO: lock transport state?
-
-        lib::error_code ec;
-
-        if (m_output_stream) {
-            m_output_stream->write(buf,len);
-
-            if (m_output_stream->bad()) {
-                ec = make_error_code(error::bad_stream);
-            }
-        } else if (m_write_handler) {
-            ec = m_write_handler(m_connection_hdl, buf, len);
-        } else {
-            ec = make_error_code(error::output_stream_required);
-        }
-
-        handler(ec);
-    }
-
-    /// Asyncronous Transport Write (scatter-gather)
-    /**
-     * Write a sequence of buffers to the output method. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success. Other possible errors (not exhaustive)
-     * output_stream_required: No output stream was registered to write to
-     * bad_stream: a ostream pass through error
-     *
-     * This method will attempt to write to the registered ostream first. If an
-     * ostream is not registered it will use the write handler. If neither are
-     * registered then an error is passed up to the connection.
-     *
-     * @param bufs vector of buffers to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(std::vector<buffer> const & bufs, transport::write_handler
-        handler)
-    {
-        m_alog->write(log::alevel::devel,"iostream_con async_write buffer list");
-        // TODO: lock transport state?
-
-        lib::error_code ec;
-
-        if (m_output_stream) {
-            std::vector<buffer>::const_iterator it;
-            for (it = bufs.begin(); it != bufs.end(); it++) {
-                m_output_stream->write((*it).buf,(*it).len);
-
-                if (m_output_stream->bad()) {
-                    ec = make_error_code(error::bad_stream);
-                    break;
-                }
-            }
-        } else if (m_vector_write_handler) {
-            ec = m_vector_write_handler(m_connection_hdl, bufs);
-        } else if (m_write_handler) {
-            std::vector<buffer>::const_iterator it;
-            for (it = bufs.begin(); it != bufs.end(); it++) {
-                ec = m_write_handler(m_connection_hdl, (*it).buf, (*it).len);
-                if (ec) {break;}
-            }
-
-        } else {
-            ec = make_error_code(error::output_stream_required);
-        }
-
-        handler(ec);
-    }
-
-    /// Set Connection Handle
-    /**
-     * @param hdl The new handle
-     */
-    void set_handle(connection_hdl hdl) {
-        m_connection_hdl = hdl;
-    }
-
-    /// Call given handler back within the transport's event system (if present)
-    /**
-     * Invoke a callback within the transport's event system if it has one. If
-     * it doesn't, the handler will be invoked immediately before this function
-     * returns.
-     *
-     * @param handler The callback to invoke
-     *
-     * @return Whether or not the transport was able to register the handler for
-     * callback.
-     */
-    lib::error_code dispatch(dispatch_handler handler) {
-        handler();
-        return lib::error_code();
-    }
-
-    /// Perform cleanup on socket shutdown_handler
-    /**
-     * If a shutdown handler is set, call it and pass through its return error
-     * code. Otherwise assume there is nothing to do and pass through a success
-     * code.
-     *
-     * @param handler The `shutdown_handler` to call back when complete
-     */
-    void async_shutdown(transport::shutdown_handler handler) {
-        lib::error_code ec;
-
-        if (m_shutdown_handler) {
-            ec = m_shutdown_handler(m_connection_hdl);
-        }
-
-        handler(ec);
-    }
-private:
-    void read(std::istream &in) {
-        m_alog->write(log::alevel::devel,"iostream_con read");
-
-        while (in.good()) {
-            if (!m_reading) {
-                m_elog->write(log::elevel::devel,"write while not reading");
-                break;
-            }
-
-            in.read(m_buf+m_cursor,static_cast<std::streamsize>(m_len-m_cursor));
-
-            if (in.gcount() == 0) {
-                m_elog->write(log::elevel::devel,"read zero bytes");
-                break;
-            }
-
-            m_cursor += static_cast<size_t>(in.gcount());
-
-            // TODO: error handling
-            if (in.bad()) {
-                m_reading = false;
-                complete_read(make_error_code(error::bad_stream));
-            }
-
-            if (m_cursor >= m_bytes_needed) {
-                m_reading = false;
-                complete_read(lib::error_code());
-            }
-        }
-    }
-
-    size_t read_some_impl(char const * buf, size_t len) {
-        m_alog->write(log::alevel::devel,"iostream_con read_some");
-
-        if (!m_reading) {
-            m_elog->write(log::elevel::devel,"write while not reading");
-            return 0;
-        }
-
-        size_t bytes_to_copy = (std::min)(len,m_len-m_cursor);
-
-        std::copy(buf,buf+bytes_to_copy,m_buf+m_cursor);
-
-        m_cursor += bytes_to_copy;
-
-        if (m_cursor >= m_bytes_needed) {
-            complete_read(lib::error_code());
-        }
-
-        return bytes_to_copy;
-    }
-
-    /// Signal that a requested read is complete
-    /**
-     * Sets the reading flag to false and returns the handler that should be
-     * called back with the result of the read. The cursor position that is sent
-     * is whatever the value of m_cursor is.
-     *
-     * It MUST NOT be called when m_reading is false.
-     * it MUST be called while holding the read lock
-     *
-     * It is important to use this method rather than directly setting/calling
-     * m_read_handler back because this function makes sure to delete the
-     * locally stored handler which contains shared pointers that will otherwise
-     * cause circular reference based memory leaks.
-     *
-     * @param ec The error code to forward to the read handler
-     */
-    void complete_read(lib::error_code const & ec) {
-        m_reading = false;
-
-        read_handler handler = m_read_handler;
-        m_read_handler = read_handler();
-
-        handler(ec,m_cursor);
-    }
-
-    // Read space (Protected by m_read_mutex)
-    char *          m_buf;
-    size_t          m_len;
-    size_t          m_bytes_needed;
-    read_handler    m_read_handler;
-    size_t          m_cursor;
-
-    // transport resources
-    std::ostream *  m_output_stream;
-    connection_hdl  m_connection_hdl;
-    write_handler   m_write_handler;
-    vector_write_handler m_vector_write_handler;
-    shutdown_handler    m_shutdown_handler;
-
-    bool            m_reading;
-    bool const      m_is_server;
-    bool            m_is_secure;
-    lib::shared_ptr<alog_type>     m_alog;
-    lib::shared_ptr<elog_type>     m_elog;
-    std::string     m_remote_endpoint;
-
-    // This lock ensures that only one thread can edit read data for this
-    // connection. This is a very coarse lock that is basically locked all the
-    // time. The nature of the connection is such that it cannot be
-    // parallelized, the locking is here to prevent intra-connection concurrency
-    // in order to allow inter-connection concurrency.
-    mutex_type      m_read_mutex;
-};
-
-
-} // namespace iostream
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_IOSTREAM_CON_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/endpoint.hpp
deleted file mode 100644
index 14cba72..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/iostream/endpoint.hpp
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_IOSTREAM_HPP
-#define WEBSOCKETPP_TRANSPORT_IOSTREAM_HPP
-
-#include <websocketpp/transport/base/endpoint.hpp>
-#include <websocketpp/transport/iostream/connection.hpp>
-
-#include <websocketpp/uri.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/memory.hpp>
-
-#include <ostream>
-
-namespace websocketpp {
-namespace transport {
-namespace iostream {
-
-template <typename config>
-class endpoint {
-public:
-    /// Type of this endpoint transport component
-    typedef endpoint type;
-    /// Type of a pointer to this endpoint transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of this endpoint's concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this endpoint's error logging policy
-    typedef typename config::elog_type elog_type;
-    /// Type of this endpoint's access logging policy
-    typedef typename config::alog_type alog_type;
-
-    /// Type of this endpoint transport component's associated connection
-    /// transport component.
-    typedef iostream::connection<config> transport_con_type;
-    /// Type of a shared pointer to this endpoint transport component's
-    /// associated connection transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    // generate and manage our own io_service
-    explicit endpoint() : m_output_stream(NULL), m_is_secure(false)
-    {
-        //std::cout << "transport::iostream::endpoint constructor" << std::endl;
-    }
-
-    /// Register a default output stream
-    /**
-     * The specified output stream will be assigned to future connections as the
-     * default output stream.
-     *
-     * @param o The ostream to use as the default output stream.
-     */
-    void register_ostream(std::ostream * o) {
-        m_alog->write(log::alevel::devel,"register_ostream");
-        m_output_stream = o;
-    }
-
-    /// Set whether or not endpoint can create secure connections
-    /**
-     * The iostream transport does not provide any security features. As such
-     * it defaults to returning false when `is_secure` is called. However, the
-     * iostream transport may be used to wrap an external socket API that may
-     * provide secure transport. This method allows that external API to flag
-     * whether or not it can create secure connections so that users of the
-     * WebSocket++ API will get more accurate information.
-     *
-     * Setting this value only indicates whether or not the endpoint is capable
-     * of producing and managing secure connections. Connections produced by
-     * this endpoint must also be individually flagged as secure if they are.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not the endpoint can create secure connections.
-     */
-    void set_secure(bool value) {
-        m_is_secure = value;
-    }
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * iostream transport will return false by default because it has no
-     * information about the ultimate remote endpoint. This may or may not be
-     * accurate depending on the real source of bytes being input. `set_secure`
-     * may be used by a wrapper API to correct the return value in the case that
-     * secure connections are in fact possible.
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return m_is_secure;
-    }
-    
-    /// Sets the write handler
-    /**
-     * The write handler is called when the iostream transport receives data
-     * that needs to be written to the appropriate output location. This handler
-     * can be used in place of registering an ostream for output.
-     *
-     * The signature of the handler is 
-     * `lib::error_code (connection_hdl, char const *, size_t)` The
-     * code returned will be reported and logged by the core library.
-     *
-     * @since 0.5.0
-     *
-     * @param h The handler to call on connection shutdown.
-     */
-    void set_write_handler(write_handler h) {
-        m_write_handler = h;
-    }
-    
-    /// Sets the shutdown handler
-    /**
-     * The shutdown handler is called when the iostream transport receives a
-     * notification from the core library that it is finished with all read and
-     * write operations and that the underlying transport can be cleaned up.
-     *
-     * If you are using iostream transport with another socket library, this is
-     * a good time to close/shutdown the socket for this connection.
-     *
-     * The signature of the handler is lib::error_code (connection_hdl). The
-     * code returned will be reported and logged by the core library.
-     *
-     * @since 0.5.0
-     *
-     * @param h The handler to call on connection shutdown.
-     */
-    void set_shutdown_handler(shutdown_handler h) {
-        m_shutdown_handler = h;
-    }
-protected:
-    /// Initialize logging
-    /**
-     * The loggers are located in the main endpoint class. As such, the
-     * transport doesn't have direct access to them. This method is called
-     * by the endpoint constructor to allow shared logging from the transport
-     * component. These are raw pointers to member variables of the endpoint.
-     * In particular, they cannot be used in the transport constructor as they
-     * haven't been constructed yet, and cannot be used in the transport
-     * destructor as they will have been destroyed by then.
-     *
-     * @param a A pointer to the access logger to use.
-     * @param e A pointer to the error logger to use.
-     */
-    void init_logging(lib::shared_ptr<alog_type> a, lib::shared_ptr<elog_type> e) {
-        m_elog = e;
-        m_alog = a;
-    }
-
-    /// Initiate a new connection
-    /**
-     * @param tcon A pointer to the transport connection component of the
-     * connection to connect.
-     * @param u A URI pointer to the URI to connect to.
-     * @param cb The function to call back with the results when complete.
-     */
-    void async_connect(transport_con_ptr, uri_ptr, connect_handler cb) {
-        cb(lib::error_code());
-    }
-
-    /// Initialize a connection
-    /**
-     * Init is called by an endpoint once for each newly created connection.
-     * It's purpose is to give the transport policy the chance to perform any
-     * transport specific initialization that couldn't be done via the default
-     * constructor.
-     *
-     * @param tcon A pointer to the transport portion of the connection.
-     * @return A status code indicating the success or failure of the operation
-     */
-    lib::error_code init(transport_con_ptr tcon) {
-        tcon->register_ostream(m_output_stream);
-        if (m_shutdown_handler) {
-            tcon->set_shutdown_handler(m_shutdown_handler);
-        }
-        if (m_write_handler) {
-            tcon->set_write_handler(m_write_handler);
-        }
-        return lib::error_code();
-    }
-private:
-    std::ostream *  m_output_stream;
-    shutdown_handler m_shutdown_handler;
-    write_handler   m_write_handler;
-    
-    lib::shared_ptr<elog_type>     m_elog;
-    lib::shared_ptr<alog_type>     m_alog;
-    bool            m_is_secure;
-};
-
-
-} // namespace iostream
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_IOSTREAM_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/base.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/base.hpp
deleted file mode 100644
index 754981e..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/base.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_STUB_BASE_HPP
-#define WEBSOCKETPP_TRANSPORT_STUB_BASE_HPP
-
-#include <websocketpp/common/system_error.hpp>
-#include <websocketpp/common/cpp11.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace transport {
-/// Stub transport policy that has no input or output.
-namespace stub {
-
-/// stub transport errors
-namespace error {
-enum value {
-    /// Catch-all error for transport policy errors that don't fit in other
-    /// categories
-    general = 1,
-
-    /// not implemented
-    not_implemented
-};
-
-/// stub transport error category
-class category : public lib::error_category {
-    public:
-    category() {}
-
-    char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
-        return "websocketpp.transport.stub";
-    }
-
-    std::string message(int value) const {
-        switch(value) {
-            case general:
-                return "Generic stub transport policy error";
-            case not_implemented:
-                return "feature not implemented";
-            default:
-                return "Unknown";
-        }
-    }
-};
-
-/// Get a reference to a static copy of the stub transport error category
-inline lib::error_category const & get_category() {
-    static category instance;
-    return instance;
-}
-
-/// Get an error code with the given value and the stub transport category
-inline lib::error_code make_error_code(error::value e) {
-    return lib::error_code(static_cast<int>(e), get_category());
-}
-
-} // namespace error
-} // namespace stub
-} // namespace transport
-} // namespace websocketpp
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
-template<> struct is_error_code_enum<websocketpp::transport::stub::error::value>
-{
-    static bool const value = true;
-};
-_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
-
-#endif // WEBSOCKETPP_TRANSPORT_STUB_BASE_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/connection.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/connection.hpp
deleted file mode 100644
index 5bbbf0d..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/connection.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_STUB_CON_HPP
-#define WEBSOCKETPP_TRANSPORT_STUB_CON_HPP
-
-#include <websocketpp/transport/stub/base.hpp>
-
-#include <websocketpp/transport/base/connection.hpp>
-
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/common/connection_hdl.hpp>
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/platforms.hpp>
-
-#include <string>
-#include <vector>
-
-namespace websocketpp {
-namespace transport {
-namespace stub {
-
-/// Empty timer class to stub out for timer functionality that stub
-/// transport doesn't support
-struct timer {
-    void cancel() {}
-};
-
-template <typename config>
-class connection : public lib::enable_shared_from_this< connection<config> > {
-public:
-    /// Type of this connection transport component
-    typedef connection<config> type;
-    /// Type of a shared pointer to this connection transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// transport concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this transport's access logging policy
-    typedef typename config::alog_type alog_type;
-    /// Type of this transport's error logging policy
-    typedef typename config::elog_type elog_type;
-
-    // Concurrency policy types
-    typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
-    typedef typename concurrency_type::mutex_type mutex_type;
-
-    typedef lib::shared_ptr<timer> timer_ptr;
-
-    explicit connection(bool is_server, const lib::shared_ptr<alog_type> & alog, const lib::shared_ptr<elog_type> & elog)
-      : m_alog(alog), m_elog(elog)
-    {
-        m_alog->write(log::alevel::devel,"stub con transport constructor");
-    }
-
-    /// Get a shared pointer to this component
-    ptr get_shared() {
-        return type::shared_from_this();
-    }
-
-    /// Set whether or not this connection is secure
-    /**
-     * Todo: docs
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not this connection is secure.
-     */
-    void set_secure(bool value) {}
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * TODO: docs
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return false;
-    }
-
-    /// Set uri hook
-    /**
-     * Called by the endpoint as a connection is being established to provide
-     * the uri being connected to to the transport layer.
-     *
-     * Implementation is optional and can be ignored if the transport has no
-     * need for this information.
-     *
-     * @since 0.6.0
-     *
-     * @param u The uri to set
-     */
-    void set_uri(uri_ptr) {}
-
-    /// Set human readable remote endpoint address
-    /**
-     * Sets the remote endpoint address returned by `get_remote_endpoint`. This
-     * value should be a human readable string that describes the remote
-     * endpoint. Typically an IP address or hostname, perhaps with a port. But
-     * may be something else depending on the nature of the underlying
-     * transport.
-     *
-     * If none is set a default is returned.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value The remote endpoint address to set.
-     */
-    void set_remote_endpoint(std::string value) {}
-
-    /// Get human readable remote endpoint address
-    /**
-     * TODO: docs
-     *
-     * This value is used in access and error logs and is available to the end
-     * application for including in user facing interfaces and messages.
-     *
-     * @return A string identifying the address of the remote endpoint
-     */
-    std::string get_remote_endpoint() const {
-        return "unknown (stub transport)";
-    }
-
-    /// Get the connection handle
-    /**
-     * @return The handle for this connection.
-     */
-    connection_hdl get_handle() const {
-        return connection_hdl();
-    }
-
-    /// Call back a function after a period of time.
-    /**
-     * Timers are not implemented in this transport. The timer pointer will
-     * always be empty. The handler will never be called.
-     *
-     * @param duration Length of time to wait in milliseconds
-     * @param callback The function to call back when the timer has expired
-     * @return A handle that can be used to cancel the timer if it is no longer
-     * needed.
-     */
-    timer_ptr set_timer(long duration, timer_handler handler) {
-        return timer_ptr();
-    }
-protected:
-    /// Initialize the connection transport
-    /**
-     * Initialize the connection's transport component.
-     *
-     * @param handler The `init_handler` to call when initialization is done
-     */
-    void init(init_handler handler) {
-        m_alog->write(log::alevel::devel,"stub connection init");
-        handler(make_error_code(error::not_implemented));
-    }
-
-    /// Initiate an async_read for at least num_bytes bytes into buf
-    /**
-     * Initiates an async_read request for at least num_bytes bytes. The input
-     * will be read into buf. A maximum of len bytes will be input. When the
-     * operation is complete, handler will be called with the status and number
-     * of bytes read.
-     *
-     * This method may or may not call handler from within the initial call. The
-     * application should be prepared to accept either.
-     *
-     * The application should never call this method a second time before it has
-     * been called back for the first read. If this is done, the second read
-     * will be called back immediately with a double_read error.
-     *
-     * If num_bytes or len are zero handler will be called back immediately
-     * indicating success.
-     *
-     * @param num_bytes Don't call handler until at least this many bytes have
-     * been read.
-     * @param buf The buffer to read bytes into
-     * @param len The size of buf. At maximum, this many bytes will be read.
-     * @param handler The callback to invoke when the operation is complete or
-     * ends in an error
-     */
-    void async_read_at_least(size_t num_bytes, char * buf, size_t len,
-        read_handler handler)
-    {
-        m_alog->write(log::alevel::devel, "stub_con async_read_at_least");
-        handler(make_error_code(error::not_implemented), 0);
-    }
-
-    /// Asyncronous Transport Write
-    /**
-     * Write len bytes in buf to the output stream. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success.
-     *
-     * @param buf buffer to read bytes from
-     * @param len number of bytes to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(char const * buf, size_t len, write_handler handler) {
-        m_alog->write(log::alevel::devel,"stub_con async_write");
-        handler(make_error_code(error::not_implemented));
-    }
-
-    /// Asyncronous Transport Write (scatter-gather)
-    /**
-     * Write a sequence of buffers to the output stream. Call handler to report
-     * success or failure. handler may or may not be called during async_write,
-     * but it must be safe for this to happen.
-     *
-     * Will return 0 on success.
-     *
-     * @param bufs vector of buffers to write
-     * @param handler Callback to invoke with operation status.
-     */
-    void async_write(std::vector<buffer> const & bufs, write_handler handler) {
-        m_alog->write(log::alevel::devel,"stub_con async_write buffer list");
-        handler(make_error_code(error::not_implemented));
-    }
-
-    /// Set Connection Handle
-    /**
-     * @param hdl The new handle
-     */
-    void set_handle(connection_hdl hdl) {}
-
-    /// Call given handler back within the transport's event system (if present)
-    /**
-     * Invoke a callback within the transport's event system if it has one. If
-     * it doesn't, the handler will be invoked immediately before this function
-     * returns.
-     *
-     * @param handler The callback to invoke
-     *
-     * @return Whether or not the transport was able to register the handler for
-     * callback.
-     */
-    lib::error_code dispatch(dispatch_handler handler) {
-        handler();
-        return lib::error_code();
-    }
-
-    /// Perform cleanup on socket shutdown_handler
-    /**
-     * @param h The `shutdown_handler` to call back when complete
-     */
-    void async_shutdown(shutdown_handler handler) {
-        handler(lib::error_code());
-    }
-private:
-    // member variables!
-    lib::shared_ptr<alog_type> m_alog;
-    lib::shared_ptr<elog_type> m_elog;
-};
-
-
-} // namespace stub
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_STUB_CON_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/endpoint.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/endpoint.hpp
deleted file mode 100644
index 3bbb78f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/transport/stub/endpoint.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_TRANSPORT_STUB_HPP
-#define WEBSOCKETPP_TRANSPORT_STUB_HPP
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/logger/levels.hpp>
-
-#include <websocketpp/transport/base/endpoint.hpp>
-#include <websocketpp/transport/stub/connection.hpp>
-
-namespace websocketpp {
-namespace transport {
-namespace stub {
-
-template <typename config>
-class endpoint {
-public:
-    /// Type of this endpoint transport component
-    typedef endpoint type;
-    /// Type of a pointer to this endpoint transport component
-    typedef lib::shared_ptr<type> ptr;
-
-    /// Type of this endpoint's concurrency policy
-    typedef typename config::concurrency_type concurrency_type;
-    /// Type of this endpoint's error logging policy
-    typedef typename config::elog_type elog_type;
-    /// Type of this endpoint's access logging policy
-    typedef typename config::alog_type alog_type;
-
-    /// Type of this endpoint transport component's associated connection
-    /// transport component.
-    typedef stub::connection<config> transport_con_type;
-    /// Type of a shared pointer to this endpoint transport component's
-    /// associated connection transport component
-    typedef typename transport_con_type::ptr transport_con_ptr;
-
-    // generate and manage our own io_service
-    explicit endpoint()
-    {
-        //std::cout << "transport::iostream::endpoint constructor" << std::endl;
-    }
-
-    /// Set whether or not endpoint can create secure connections
-    /**
-     * TODO: docs
-     *
-     * Setting this value only indicates whether or not the endpoint is capable
-     * of producing and managing secure connections. Connections produced by
-     * this endpoint must also be individually flagged as secure if they are.
-     *
-     * @since 0.3.0-alpha4
-     *
-     * @param value Whether or not the endpoint can create secure connections.
-     */
-    void set_secure(bool value) {}
-
-    /// Tests whether or not the underlying transport is secure
-    /**
-     * TODO: docs
-     *
-     * @return Whether or not the underlying transport is secure
-     */
-    bool is_secure() const {
-        return false;
-    }
-protected:
-    /// Initialize logging
-    /**
-     * The loggers are located in the main endpoint class. As such, the
-     * transport doesn't have direct access to them. This method is called
-     * by the endpoint constructor to allow shared logging from the transport
-     * component. These are raw pointers to member variables of the endpoint.
-     * In particular, they cannot be used in the transport constructor as they
-     * haven't been constructed yet, and cannot be used in the transport
-     * destructor as they will have been destroyed by then.
-     *
-     * @param a A pointer to the access logger to use.
-     * @param e A pointer to the error logger to use.
-     */
-    void init_logging(alog_type * a, elog_type * e) {}
-
-    /// Initiate a new connection
-    /**
-     * @param tcon A pointer to the transport connection component of the
-     * connection to connect.
-     * @param u A URI pointer to the URI to connect to.
-     * @param cb The function to call back with the results when complete.
-     */
-    void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb) {
-        cb(make_error_code(error::not_implemented));
-    }
-
-    /// Initialize a connection
-    /**
-     * Init is called by an endpoint once for each newly created connection.
-     * It's purpose is to give the transport policy the chance to perform any
-     * transport specific initialization that couldn't be done via the default
-     * constructor.
-     *
-     * @param tcon A pointer to the transport portion of the connection.
-     * @return A status code indicating the success or failure of the operation
-     */
-    lib::error_code init(transport_con_ptr tcon) {
-        return make_error_code(error::not_implemented);
-    }
-private:
-
-};
-
-} // namespace stub
-} // namespace transport
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_TRANSPORT_STUB_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/uri.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/uri.hpp
deleted file mode 100644
index c0b8b0c..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/uri.hpp
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_URI_HPP
-#define WEBSOCKETPP_URI_HPP
-
-#include <websocketpp/error.hpp>
-
-#include <websocketpp/common/memory.hpp>
-#include <websocketpp/common/stdint.hpp>
-
-#include <algorithm>
-#include <sstream>
-#include <string>
-
-namespace websocketpp {
-
-// TODO: figure out why this fixes horrible linking errors.
-
-/// Default port for ws://
-static uint16_t const uri_default_port = 80;
-/// Default port for wss://
-static uint16_t const uri_default_secure_port = 443;
-
-class uri {
-public:
-    explicit uri(std::string const & uri_string) : m_valid(false) {
-        std::string::const_iterator it;
-        std::string::const_iterator temp;
-
-        int state = 0;
-
-        it = uri_string.begin();
-        size_t uri_len = uri_string.length();
-
-        if (uri_len >= 7 && std::equal(it,it+6,"wss://")) {
-            m_secure = true;
-            m_scheme = "wss";
-            it += 6;
-        } else if (uri_len >= 6 && std::equal(it,it+5,"ws://")) {
-            m_secure = false;
-            m_scheme = "ws";
-            it += 5;
-        } else if (uri_len >= 8 && std::equal(it,it+7,"http://")) {
-            m_secure = false;
-            m_scheme = "http";
-            it += 7;
-        } else if (uri_len >= 9 && std::equal(it,it+8,"https://")) {
-            m_secure = true;
-            m_scheme = "https";
-            it += 8;
-        } else {
-            return;
-        }
-
-        // extract host.
-        // either a host string
-        // an IPv4 address
-        // or an IPv6 address
-        if (*it == '[') {
-            ++it;
-            // IPv6 literal
-            // extract IPv6 digits until ]
-
-            // TODO: this doesn't work on g++... not sure why
-            //temp = std::find(it,it2,']');
-
-            temp = it;
-            while (temp != uri_string.end()) {
-                if (*temp == ']') {
-                    break;
-                }
-                ++temp;
-            }
-
-            if (temp == uri_string.end()) {
-                return;
-            } else {
-                // validate IPv6 literal parts
-                // can contain numbers, a-f and A-F
-                m_host.append(it,temp);
-            }
-            it = temp+1;
-            if (it == uri_string.end()) {
-                state = 2;
-            } else if (*it == '/') {
-                state = 2;
-                ++it;
-            } else if (*it == ':') {
-                state = 1;
-                ++it;
-            } else {
-                // problem
-                return;
-            }
-        } else {
-            // IPv4 or hostname
-            // extract until : or /
-            while (state == 0) {
-                if (it == uri_string.end()) {
-                    state = 2;
-                    break;
-                } else if (*it == '/') {
-                    state = 2;
-                } else if (*it == ':') {
-                    // end hostname start port
-                    state = 1;
-                } else {
-                    m_host += *it;
-                }
-                ++it;
-            }
-        }
-
-        // parse port
-        std::string port;
-        while (state == 1) {
-            if (it == uri_string.end()) {
-                // state is not used after this point presently.
-                // this should be re-enabled if it ever is needed in a future
-                // refactoring
-                //state = 3;
-                break;
-            } else if (*it == '/') {
-                state = 3;
-            } else {
-                port += *it;
-            }
-            ++it;
-        }
-
-        lib::error_code ec;
-        m_port = get_port_from_string(port, ec);
-
-        if (ec) {
-            return;
-        }
-
-        m_resource = "/";
-        m_resource.append(it,uri_string.end());
-
-
-        m_valid = true;
-    }
-
-    uri(bool secure, std::string const & host, uint16_t port,
-        std::string const & resource)
-      : m_scheme(secure ? "wss" : "ws")
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_port(port)
-      , m_secure(secure)
-      , m_valid(true) {}
-
-    uri(bool secure, std::string const & host, std::string const & resource)
-      : m_scheme(secure ? "wss" : "ws")
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_port(secure ? uri_default_secure_port : uri_default_port)
-      , m_secure(secure)
-      , m_valid(true) {}
-
-    uri(bool secure, std::string const & host, std::string const & port,
-        std::string const & resource)
-      : m_scheme(secure ? "wss" : "ws")
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_secure(secure)
-    {
-        lib::error_code ec;
-        m_port = get_port_from_string(port,ec);
-        m_valid = !ec;
-    }
-
-    uri(std::string const & scheme, std::string const & host, uint16_t port,
-        std::string const & resource)
-      : m_scheme(scheme)
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_port(port)
-      , m_secure(scheme == "wss" || scheme == "https")
-      , m_valid(true) {}
-
-    uri(std::string scheme, std::string const & host, std::string const & resource)
-      : m_scheme(scheme)
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_port((scheme == "wss" || scheme == "https") ? uri_default_secure_port : uri_default_port)
-      , m_secure(scheme == "wss" || scheme == "https")
-      , m_valid(true) {}
-
-    uri(std::string const & scheme, std::string const & host,
-        std::string const & port, std::string const & resource)
-      : m_scheme(scheme)
-      , m_host(host)
-      , m_resource(resource.empty() ? "/" : resource)
-      , m_secure(scheme == "wss" || scheme == "https")
-    {
-        lib::error_code ec;
-        m_port = get_port_from_string(port,ec);
-        m_valid = !ec;
-    }
-
-    bool get_valid() const {
-        return m_valid;
-    }
-
-    bool get_secure() const {
-        return m_secure;
-    }
-
-    std::string const & get_scheme() const {
-        return m_scheme;
-    }
-
-    std::string const & get_host() const {
-        return m_host;
-    }
-
-    std::string get_host_port() const {
-        if (m_port == (m_secure ? uri_default_secure_port : uri_default_port)) {
-            return m_host;
-        } else {
-            std::stringstream p;
-            p << m_host << ":" << m_port;
-            return p.str();
-        }
-    }
-
-    std::string get_authority() const {
-        std::stringstream p;
-        p << m_host << ":" << m_port;
-        return p.str();
-    }
-
-    uint16_t get_port() const {
-        return m_port;
-    }
-
-    std::string get_port_str() const {
-        std::stringstream p;
-        p << m_port;
-        return p.str();
-    }
-
-    std::string const & get_resource() const {
-        return m_resource;
-    }
-
-    std::string str() const {
-        std::stringstream s;
-
-        s << m_scheme << "://" << m_host;
-
-        if (m_port != (m_secure ? uri_default_secure_port : uri_default_port)) {
-            s << ":" << m_port;
-        }
-
-        s << m_resource;
-        return s.str();
-    }
-
-    /// Return the query portion
-    /**
-     * Returns the query portion (after the ?) of the URI or an empty string if
-     * there is none.
-     *
-     * @return query portion of the URI.
-     */
-    std::string get_query() const {
-        std::size_t found = m_resource.find('?');
-        if (found != std::string::npos) {
-            return m_resource.substr(found + 1);
-        } else {
-            return "";
-        }
-    }
-
-    // get fragment
-
-    // hi <3
-
-    // get the string representation of this URI
-
-    //std::string base() const; // is this still needed?
-
-    // setter methods set some or all (in the case of parse) based on the input.
-    // These functions throw a uri_exception on failure.
-    /*void set_uri(const std::string& uri);
-
-    void set_secure(bool secure);
-    void set_host(const std::string& host);
-    void set_port(uint16_t port);
-    void set_port(const std::string& port);
-    void set_resource(const std::string& resource);*/
-private:
-    uint16_t get_port_from_string(std::string const & port, lib::error_code &
-        ec) const
-    {
-        ec = lib::error_code();
-
-        if (port.empty()) {
-            return (m_secure ? uri_default_secure_port : uri_default_port);
-        }
-
-        unsigned int t_port = static_cast<unsigned int>(atoi(port.c_str()));
-
-        if (t_port > 65535) {
-            ec = error::make_error_code(error::invalid_port);
-        }
-
-        if (t_port == 0) {
-            ec = error::make_error_code(error::invalid_port);
-        }
-
-        return static_cast<uint16_t>(t_port);
-    }
-
-    std::string m_scheme;
-    std::string m_host;
-    std::string m_resource;
-    uint16_t    m_port;
-    bool        m_secure;
-    bool        m_valid;
-};
-
-/// Pointer to a URI
-typedef lib::shared_ptr<uri> uri_ptr;
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_URI_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utf8_validator.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utf8_validator.hpp
deleted file mode 100644
index c057da6..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utf8_validator.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * The following code is adapted from code originally written by Bjoern
- * Hoehrmann <bjoern@hoehrmann.de>. See
- * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
- *
- * The original license:
- *
- * Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
-*/
-
-#ifndef UTF8_VALIDATOR_HPP
-#define UTF8_VALIDATOR_HPP
-
-#include <websocketpp/common/stdint.hpp>
-
-#include <string>
-
-namespace websocketpp {
-namespace utf8_validator {
-
-/// State that represents a valid utf8 input sequence
-static unsigned int const utf8_accept = 0;
-/// State that represents an invalid utf8 input sequence
-static unsigned int const utf8_reject = 1;
-
-/// Lookup table for the UTF8 decode state machine
-static uint8_t const utf8d[] = {
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf
-  8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df
-  0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef
-  0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff
-  0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2
-  1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4
-  1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6
-  1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8
-};
-
-/// Decode the next byte of a UTF8 sequence
-/**
- * @param [out] state The decoder state to advance
- * @param [out] codep The codepoint to fill in
- * @param [in] byte The byte to input
- * @return The ending state of the decode operation
- */
-inline uint32_t decode(uint32_t * state, uint32_t * codep, uint8_t byte) {
-  uint32_t type = utf8d[byte];
-
-  *codep = (*state != utf8_accept) ?
-    (byte & 0x3fu) | (*codep << 6) :
-    (0xff >> type) & (byte);
-
-  *state = utf8d[256 + *state*16 + type];
-  return *state;
-}
-
-/// Provides streaming UTF8 validation functionality
-class validator {
-public:
-    /// Construct and initialize the validator
-    validator() : m_state(utf8_accept),m_codepoint(0) {}
-
-    /// Advance the state of the validator with the next input byte
-    /**
-     * @param byte The byte to advance the validation state with
-     * @return Whether or not the byte resulted in a validation error.
-     */
-    bool consume (uint8_t byte) {
-        if (utf8_validator::decode(&m_state,&m_codepoint,byte) == utf8_reject) {
-            return false;
-        }
-        return true;
-    }
-
-    /// Advance validator state with input from an iterator pair
-    /**
-     * @param begin Input iterator to the start of the input range
-     * @param end Input iterator to the end of the input range
-     * @return Whether or not decoding the bytes resulted in a validation error.
-     */
-    template <typename iterator_type>
-    bool decode (iterator_type begin, iterator_type end) {
-        for (iterator_type it = begin; it != end; ++it) {
-            unsigned int result = utf8_validator::decode(
-                &m_state,
-                &m_codepoint,
-                static_cast<uint8_t>(*it)
-            );
-
-            if (result == utf8_reject) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /// Return whether the input sequence ended on a valid utf8 codepoint
-    /**
-     * @return Whether or not the input sequence ended on a valid codepoint.
-     */
-    bool complete() {
-        return m_state == utf8_accept;
-    }
-
-    /// Reset the validator to decode another message
-    void reset() {
-        m_state = utf8_accept;
-        m_codepoint = 0;
-    }
-private:
-    uint32_t    m_state;
-    uint32_t    m_codepoint;
-};
-
-/// Validate a UTF8 string
-/**
- * convenience function that creates a validator, validates a complete string
- * and returns the result.
- */
-inline bool validate(std::string const & s) {
-    validator v;
-    if (!v.decode(s.begin(),s.end())) {
-        return false;
-    }
-    return v.complete();
-}
-
-} // namespace utf8_validator
-} // namespace websocketpp
-
-#endif // UTF8_VALIDATOR_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utilities.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utilities.hpp
deleted file mode 100644
index b983c9f..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/utilities.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2014, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_UTILITIES_HPP
-#define WEBSOCKETPP_UTILITIES_HPP
-
-#include <websocketpp/common/stdint.hpp>
-
-#include <algorithm>
-#include <string>
-#include <locale>
-
-namespace websocketpp {
-/// Generic non-websocket specific utility functions and data structures
-namespace utility {
-
-/// Helper functor for case insensitive find
-/**
- * Based on code from
- * http://stackoverflow.com/questions/3152241/case-insensitive-stdstring-find
- *
- * templated version of my_equal so it could work with both char and wchar_t
- */
-template<typename charT>
-struct my_equal {
-    /// Construct the functor with the given locale
-    /**
-     * @param [in] loc The locale to use for determining the case of values
-     */
-    my_equal(std::locale const & loc ) : m_loc(loc) {}
-
-    /// Perform a case insensitive comparison
-    /**
-     * @param ch1 The first value to compare
-     * @param ch2 The second value to compare
-     * @return Whether or not the two values are equal when both are converted
-     *         to uppercase using the given locale.
-     */
-    bool operator()(charT ch1, charT ch2) {
-        return std::toupper(ch1, m_loc) == std::toupper(ch2, m_loc);
-    }
-private:
-    std::locale const & m_loc;
-};
-
-/// Helper less than functor for case insensitive find
-/**
- * Based on code from
- * http://stackoverflow.com/questions/3152241/case-insensitive-stdstring-find
- */
-struct ci_less {
-    // case-independent (ci) compare_less binary function
-    struct nocase_compare {
-        bool operator() (unsigned char const & c1, unsigned char const & c2) const {
-            return tolower (c1) < tolower (c2);
-        }
-    };
-    bool operator() (std::string const & s1, std::string const & s2) const {
-        return std::lexicographical_compare
-            (s1.begin (), s1.end (),   // source range
-            s2.begin (), s2.end (),   // dest range
-            nocase_compare ());  // comparison
-    }
-};
-
-/// Find substring (case insensitive)
-/**
- * @param [in] haystack The string to search in
- * @param [in] needle The string to search for
- * @param [in] loc The locale to use for determining the case of values.
- *             Defaults to the current locale.
- * @return An iterator to the first element of the first occurrance of needle in
- *         haystack. If the sequence is not found, the function returns
- *         haystack.end()
- */
-template<typename T>
-typename T::const_iterator ci_find_substr(T const & haystack, T const & needle,
-    std::locale const & loc = std::locale())
-{
-    return std::search( haystack.begin(), haystack.end(),
-        needle.begin(), needle.end(), my_equal<typename T::value_type>(loc) );
-}
-
-/// Find substring (case insensitive)
-/**
- * @todo Is this still used? This method may not make sense.. should use
- * iterators or be less generic. As is it is too tightly coupled to std::string
- *
- * @param [in] haystack The string to search in
- * @param [in] needle The string to search for as a char array of values
- * @param [in] size Length of needle
- * @param [in] loc The locale to use for determining the case of values.
- *             Defaults to the current locale.
- * @return An iterator to the first element of the first occurrance of needle in
- *         haystack. If the sequence is not found, the function returns
- *         haystack.end()
- */
-template<typename T>
-typename T::const_iterator ci_find_substr(T const & haystack,
-    typename T::value_type const * needle, typename T::size_type size,
-    std::locale const & loc = std::locale())
-{
-    return std::search( haystack.begin(), haystack.end(),
-        needle, needle+size, my_equal<typename T::value_type>(loc) );
-}
-
-/// Convert a string to lowercase
-/**
- * @param [in] in The string to convert
- * @return The converted string
- */
-std::string to_lower(std::string const & in);
-
-/// Replace all occurrances of a substring with another
-/**
- * @param [in] subject The string to search in
- * @param [in] search The string to search for
- * @param [in] replace The string to replace with
- * @return A copy of `subject` with all occurances of `search` replaced with
- *         `replace`
- */
-std::string string_replace_all(std::string subject, std::string const & search,
-                               std::string const & replace);
-
-/// Convert std::string to ascii printed string of hex digits
-/**
- * @param [in] input The string to print
- * @return A copy of `input` converted to the printable representation of the
- *         hex values of its data.
- */
-std::string to_hex(std::string const & input);
-
-/// Convert byte array (uint8_t) to ascii printed string of hex digits
-/**
- * @param [in] input The byte array to print
- * @param [in] length The length of input
- * @return A copy of `input` converted to the printable representation of the
- *         hex values of its data.
- */
-std::string to_hex(uint8_t const * input, size_t length);
-
-/// Convert char array to ascii printed string of hex digits
-/**
- * @param [in] input The char array to print
- * @param [in] length The length of input
- * @return A copy of `input` converted to the printable representation of the
- *         hex values of its data.
- */
-std::string to_hex(char const * input, size_t length);
-
-} // namespace utility
-} // namespace websocketpp
-
-#include <websocketpp/impl/utilities_impl.hpp>
-
-#endif // WEBSOCKETPP_UTILITIES_HPP
diff --git a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/version.hpp b/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/version.hpp
deleted file mode 100644
index 5766546..0000000
--- a/third_party/socket.io-client-cpp/lib/websocketpp/websocketpp/version.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2015, Peter Thorson. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the WebSocket++ Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef WEBSOCKETPP_VERSION_HPP
-#define WEBSOCKETPP_VERSION_HPP
-
-/// Namespace for the WebSocket++ project
-namespace websocketpp {
-
-/*
- other places where version information is kept
- - readme.md
- - changelog.md
- - Doxyfile
- - CMakeLists.txt
-*/
-
-/// Library major version number
-static int const major_version = 0;
-/// Library minor version number
-static int const minor_version = 8;
-/// Library patch version number
-static int const patch_version = 2;
-/// Library pre-release flag
-/**
- * This is a textual flag indicating the type and number for pre-release
- * versions (dev, alpha, beta, rc). This will be blank for release versions.
- */
-
-static char const prerelease_flag[] = "";
-
-/// Default user agent string
-static char const user_agent[] = "WebSocket++/0.8.2";
-
-} // namespace websocketpp
-
-#endif // WEBSOCKETPP_VERSION_HPP
diff --git a/third_party/socket.io-client-cpp/sioclientConfig.cmake.in b/third_party/socket.io-client-cpp/sioclientConfig.cmake.in
deleted file mode 100644
index a28fad8..0000000
--- a/third_party/socket.io-client-cpp/sioclientConfig.cmake.in
+++ /dev/null
@@ -1,7 +0,0 @@
-
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-@_find_dependency_calls@
-
-include("${CMAKE_CURRENT_LIST_DIR}/sioclientTargets.cmake")
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/src/internal/sio_client_impl.cpp b/third_party/socket.io-client-cpp/src/internal/sio_client_impl.cpp
deleted file mode 100644
index 02ccead..0000000
--- a/third_party/socket.io-client-cpp/src/internal/sio_client_impl.cpp
+++ /dev/null
@@ -1,659 +0,0 @@
-//
-//  sio_client_impl.cpp
-//  SioChatDemo
-//
-//  Created by Melo Yao on 4/3/15.
-//  Copyright (c) 2015 Melo Yao. All rights reserved.
-//
-
-#include "sio_client_impl.h"
-#include <functional>
-#include <sstream>
-#include <chrono>
-#include <mutex>
-#include <cmath>
-// Comment this out to disable handshake logging to stdout
-#if (DEBUG || _DEBUG) && !defined(SIO_DISABLE_LOGGING)
-#define LOG(x) std::cout << x
-#else
-#define LOG(x)
-#endif
-
-#if SIO_TLS
-// If using Asio's SSL support, you will also need to add this #include.
-// Source: http://think-async.com/Asio/asio-1.10.6/doc/asio/using.html
-// #include <asio/ssl/impl/src.hpp>
-#endif
-
-using std::chrono::milliseconds;
-using namespace std;
-
-namespace sio
-{
-    /*************************public:*************************/
-    client_impl::client_impl(client_options const& options) :
-        m_ping_interval(0),
-        m_ping_timeout(0),
-        m_network_thread(),
-        m_con_state(con_closed),
-        m_reconn_delay(5000),
-        m_reconn_delay_max(25000),
-        m_reconn_attempts(0xFFFFFFFF),
-        m_reconn_made(0)
-    {
-        using websocketpp::log::alevel;
-#ifndef DEBUG
-        m_client.clear_access_channels(alevel::all);
-        m_client.set_access_channels(alevel::connect|alevel::disconnect|alevel::app);
-#endif
-        // Initialize the Asio transport policy
-        if (options.io_context != nullptr) {
-            m_client.init_asio(options.io_context);
-        } else {
-            m_client.init_asio();
-        }
-
-        // Bind the clients we are using
-        using std::placeholders::_1;
-        using std::placeholders::_2;
-        m_client.set_open_handler(std::bind(&client_impl::on_open,this,_1));
-        m_client.set_close_handler(std::bind(&client_impl::on_close,this,_1));
-        m_client.set_fail_handler(std::bind(&client_impl::on_fail,this,_1));
-        m_client.set_message_handler(std::bind(&client_impl::on_message,this,_1,_2));
-#if SIO_TLS
-        m_client.set_tls_init_handler(std::bind(&client_impl::on_tls_init,this,_1));
-#endif
-        m_packet_mgr.set_decode_callback(std::bind(&client_impl::on_decode,this,_1));
-
-        m_packet_mgr.set_encode_callback(std::bind(&client_impl::on_encode,this,_1,_2));
-    }
-    
-    client_impl::~client_impl()
-    {
-        this->sockets_invoke_void(&sio::socket::on_close);
-        sync_close();
-    }
-	
-    void client_impl::set_proxy_basic_auth(const std::string& uri, const std::string& username, const std::string& password)
-    {
-        m_proxy_base_url = uri;
-        m_proxy_basic_username = username;
-        m_proxy_basic_password = password;
-    }
-    
-    void client_impl::connect(const string& uri, const map<string,string>& query, const map<string, string>& headers, const message::ptr& auth)
-    {
-        if(m_reconn_timer)
-        {
-            m_reconn_timer->cancel();
-            m_reconn_timer.reset();
-        }
-        if(m_network_thread)
-        {
-            if(m_con_state == con_closing||m_con_state == con_closed)
-            {
-                //if client is closing, join to wait.
-                //if client is closed, still need to join,
-                //but in closed case,join will return immediately.
-                m_network_thread->join();
-                m_network_thread.reset();//defensive
-            }
-            else
-            {
-                //if we are connected, do nothing.
-                return;
-            }
-        }
-        m_con_state = con_opening;
-        m_base_url = uri;
-        m_reconn_made = 0;
-
-        string query_str;
-        for(map<string,string>::const_iterator it=query.begin();it!=query.end();++it){
-            query_str.append("&");
-            query_str.append(it->first);
-            query_str.append("=");
-            string query_str_value=encode_query_string(it->second);
-            query_str.append(query_str_value);
-        }
-        m_query_string=move(query_str);
-
-        m_http_headers = headers;
-        m_auth = auth;
-
-        this->reset_states();
-        m_abort_retries = false;
-        m_client.get_io_service().dispatch(std::bind(&client_impl::connect_impl,this,uri,m_query_string));
-        m_network_thread.reset(new thread(std::bind(&client_impl::run_loop,this)));//uri lifecycle?
-
-    }
-
-    socket::ptr const& client_impl::socket(string const& nsp)
-    {
-        lock_guard<mutex> guard(m_socket_mutex);
-        string aux;
-        if(nsp == "")
-        {
-            aux = "/";
-        }
-        else if( nsp[0] != '/')
-        {
-            aux.append("/",1);
-            aux.append(nsp);
-        }
-        else
-        {
-            aux = nsp;
-        }
-
-        auto it = m_sockets.find(aux);
-        if(it!= m_sockets.end())
-        {
-            return it->second;
-        }
-        else
-        {
-            pair<const string, socket::ptr> p(aux,shared_ptr<sio::socket>(new sio::socket(this,aux,m_auth)));
-            return (m_sockets.insert(p).first)->second;
-        }
-    }
-
-    void client_impl::close()
-    {
-        m_con_state = con_closing;
-        m_abort_retries = true;
-        this->sockets_invoke_void(&sio::socket::close);
-        m_client.get_io_service().dispatch(std::bind(&client_impl::close_impl, this,close::status::normal,"End by user"));
-    }
-
-    void client_impl::sync_close()
-    {
-        m_con_state = con_closing;
-        m_abort_retries = true;
-        this->sockets_invoke_void(&sio::socket::close);
-        m_client.get_io_service().dispatch(std::bind(&client_impl::close_impl, this,close::status::normal,"End by user"));
-        if(m_network_thread)
-        {
-            m_network_thread->join();
-            m_network_thread.reset();
-        }
-    }
-
-    void client_impl::set_logs_default()
-    {
-        m_client.clear_access_channels(websocketpp::log::alevel::all);
-        m_client.set_access_channels(websocketpp::log::alevel::connect | websocketpp::log::alevel::disconnect | websocketpp::log::alevel::app);
-    }
-
-    void client_impl::set_logs_quiet()
-    {
-        m_client.clear_access_channels(websocketpp::log::alevel::all);
-    }
-
-    void client_impl::set_logs_verbose()
-    {
-        m_client.set_access_channels(websocketpp::log::alevel::all);
-    }
-
-    /*************************protected:*************************/
-    void client_impl::send(packet& p)
-    {
-        m_packet_mgr.encode(p);
-    }
-
-    void client_impl::remove_socket(string const& nsp)
-    {
-        lock_guard<mutex> guard(m_socket_mutex);
-        auto it = m_sockets.find(nsp);
-        if(it!= m_sockets.end())
-        {
-            m_sockets.erase(it);
-        }
-    }
-
-    asio::io_service& client_impl::get_io_service()
-    {
-        return m_client.get_io_service();
-    }
-
-    void client_impl::on_socket_closed(string const& nsp)
-    {
-        if(m_socket_close_listener)m_socket_close_listener(nsp);
-    }
-
-    void client_impl::on_socket_opened(string const& nsp)
-    {
-        if(m_socket_open_listener)m_socket_open_listener(nsp);
-    }
-
-    /*************************private:*************************/
-    void client_impl::run_loop()
-    {
-
-        m_client.run();
-        m_client.reset();
-        m_client.get_alog().write(websocketpp::log::alevel::devel,
-                                  "run loop end");
-    }
-
-    void client_impl::connect_impl(const string& uri, const string& queryString)
-    {
-        do{
-            websocketpp::uri uo(uri);
-            ostringstream ss;
-#if SIO_TLS
-            ss<<"wss://";
-#else
-            ss<<"ws://";
-#endif
-            const std::string host(uo.get_host());
-            // As per RFC2732, literal IPv6 address should be enclosed in "[" and "]".
-            if(host.find(':')!=std::string::npos){
-                ss<<"["<<uo.get_host()<<"]";
-            } else {
-                ss<<uo.get_host();
-            }
-
-            // If a resource path was included in the URI, use that, otherwise
-            // use the default /socket.io/.
-            const std::string path(uo.get_resource() == "/" ? "/socket.io/" : uo.get_resource());
-
-            ss<<":"<<uo.get_port()<<path<<"?EIO=4&transport=websocket";
-            if(m_sid.size()>0){
-                ss<<"&sid="<<m_sid;
-            }
-            ss<<"&t="<<time(NULL)<<queryString;
-            lib::error_code ec;
-            client_type::connection_ptr con = m_client.get_connection(ss.str(), ec);
-            if (ec) {
-                m_client.get_alog().write(websocketpp::log::alevel::app,
-                                          "Get Connection Error: "+ec.message());
-                break;
-            }
-
-            for( auto&& header: m_http_headers ) {
-                con->replace_header(header.first, header.second);
-            }
-			
-            if (!m_proxy_base_url.empty()) {
-                con->set_proxy(m_proxy_base_url, ec);
-                if (ec) {
-                    m_client.get_alog().write(websocketpp::log::alevel::app,
-                                    "Set Proxy Error: " + ec.message());
-                    break;
-                }
-                if (!m_proxy_basic_username.empty()) {
-                    con->set_proxy_basic_auth(m_proxy_basic_username, m_proxy_basic_password, ec);
-                    if (ec) {
-                        m_client.get_alog().write(websocketpp::log::alevel::app,
-                                    "Set Proxy Basic Auth Error: " + ec.message());
-                        break;
-                    }
-                }
-            }
-
-            m_client.connect(con);
-            return;
-        }
-        while(0);
-        if(m_fail_listener)
-        {
-            m_fail_listener();
-        }
-    }
-
-    void client_impl::close_impl(close::status::value const& code,string const& reason)
-    {
-        LOG("Close by reason:"<<reason << endl);
-        if(m_reconn_timer)
-        {
-            m_reconn_timer->cancel();
-            m_reconn_timer.reset();
-        }
-        if (m_con.expired())
-        {
-            cerr << "Error: No active session" << endl;
-        }
-        else
-        {
-            lib::error_code ec;
-            m_client.close(m_con, code, reason, ec);
-        }
-    }
-
-    void client_impl::send_impl(shared_ptr<const string> const& payload_ptr,frame::opcode::value opcode)
-    {
-        if(m_con_state == con_opened)
-        {
-            lib::error_code ec;
-            m_client.send(m_con,*payload_ptr,opcode,ec);
-            if(ec)
-            {
-                cerr<<"Send failed,reason:"<< ec.message()<<endl;
-            }
-        }
-    }
-
-    void client_impl::timeout_ping(const asio::error_code &ec)
-    {
-        if(ec)
-        {
-            return;
-        }
-        LOG("Ping timeout"<<endl);
-        m_client.get_io_service().dispatch(std::bind(&client_impl::close_impl, this,close::status::policy_violation,"Ping timeout"));
-    }
-
-    void client_impl::timeout_reconnect(asio::error_code const& ec)
-    {
-        if(ec)
-        {
-            return;
-        }
-        if(m_con_state == con_closed)
-        {
-            m_con_state = con_opening;
-            m_reconn_made++;
-            this->reset_states();
-            LOG("Reconnecting..."<<endl);
-            if(m_reconnecting_listener) m_reconnecting_listener();
-            m_client.get_io_service().dispatch(std::bind(&client_impl::connect_impl,this,m_base_url,m_query_string));
-        }
-    }
-
-    unsigned client_impl::next_delay() const
-    {
-        //no jitter, fixed power root.
-        unsigned reconn_made = min<unsigned>(m_reconn_made,32);//protect the pow result to be too big.
-        return static_cast<unsigned>(min<double>(m_reconn_delay * pow(1.5,reconn_made),m_reconn_delay_max));
-    }
-
-    socket::ptr client_impl::get_socket_locked(string const& nsp)
-    {
-        lock_guard<mutex> guard(m_socket_mutex);
-        auto it = m_sockets.find(nsp);
-        if(it != m_sockets.end())
-        {
-            return it->second;
-        }
-        else
-        {
-            return socket::ptr();
-        }
-    }
-
-    void client_impl::sockets_invoke_void(void (sio::socket::*fn)(void))
-    {
-        map<const string,socket::ptr> socks;
-        {
-            lock_guard<mutex> guard(m_socket_mutex);
-            socks.insert(m_sockets.begin(),m_sockets.end());
-        }
-        for (auto it = socks.begin(); it!=socks.end(); ++it) {
-            ((*(it->second)).*fn)();
-        }
-    }
-
-    void client_impl::on_fail(connection_hdl)
-    {
-        if (m_con_state == con_closing) {
-            LOG("Connection failed while closing." << endl);
-            this->close();
-            return;
-        }
-
-        m_con.reset();
-        m_con_state = con_closed;
-        this->sockets_invoke_void(&sio::socket::on_disconnect);
-        LOG("Connection failed." << endl);
-        if(m_reconn_made<m_reconn_attempts && !m_abort_retries)
-        {
-            LOG("Reconnect for attempt:"<<m_reconn_made<<endl);
-            unsigned delay = this->next_delay();
-            if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);
-            m_reconn_timer.reset(new asio::steady_timer(m_client.get_io_service()));
-            asio::error_code ec;
-            m_reconn_timer->expires_from_now(milliseconds(delay), ec);
-            m_reconn_timer->async_wait(std::bind(&client_impl::timeout_reconnect,this, std::placeholders::_1));
-        }
-        else
-        {
-            if(m_fail_listener)m_fail_listener();
-        }
-    }
-    
-    void client_impl::on_open(connection_hdl con)
-    {
-        if (m_con_state == con_closing) {
-            LOG("Connection opened while closing." << endl);
-            this->close();
-            return;
-        }
-
-        LOG("Connected." << endl);
-        m_con_state = con_opened;
-        m_con = con;
-        m_reconn_made = 0;
-        this->sockets_invoke_void(&sio::socket::on_open);
-        this->socket("");
-        if(m_open_listener)m_open_listener();
-    }
-    
-    void client_impl::on_close(connection_hdl con)
-    {
-        LOG("Client Disconnected." << endl);
-        con_state m_con_state_was = m_con_state;
-        m_con_state = con_closed;
-        lib::error_code ec;
-        close::status::value code = close::status::normal;
-        client_type::connection_ptr conn_ptr  = m_client.get_con_from_hdl(con, ec);
-        if (ec) {
-            LOG("OnClose get conn failed"<<ec<<endl);
-        }
-        else
-        {
-            code = conn_ptr->get_local_close_code();
-        }
-        
-        m_con.reset();
-        this->clear_timers();
-        client::close_reason reason;
-
-        // If we initiated the close, no matter what the close status was,
-        // we'll consider it a normal close. (When using TLS, we can
-        // sometimes get a TLS Short Read error when closing.)
-        if(code == close::status::normal || m_con_state_was == con_closing)
-        {
-            this->sockets_invoke_void(&sio::socket::on_disconnect);
-            reason = client::close_reason_normal;
-        }
-        else
-        {
-            this->sockets_invoke_void(&sio::socket::on_disconnect);
-            if(m_reconn_made<m_reconn_attempts && !m_abort_retries)
-            {
-                LOG("Reconnect for attempt:"<<m_reconn_made<<endl);
-                unsigned delay = this->next_delay();
-                if(m_reconnect_listener) m_reconnect_listener(m_reconn_made,delay);
-                m_reconn_timer.reset(new asio::steady_timer(m_client.get_io_service()));
-                asio::error_code ec;
-                m_reconn_timer->expires_from_now(milliseconds(delay), ec);
-                m_reconn_timer->async_wait(std::bind(&client_impl::timeout_reconnect,this, std::placeholders::_1));
-                return;
-            }
-            reason = client::close_reason_drop;
-        }
-        
-        if(m_close_listener)
-        {
-            m_close_listener(reason);
-        }
-    }
-    
-    void client_impl::on_message(connection_hdl, client_type::message_ptr msg)
-    {
-        // Parse the incoming message according to socket.IO rules
-        m_packet_mgr.put_payload(msg->get_payload());
-    }
-    
-    void client_impl::on_handshake(message::ptr const& message)
-    {
-        if(message && message->get_flag() == message::flag_object)
-        {
-            const object_message* obj_ptr =static_cast<object_message*>(message.get());
-            const map<string,message::ptr>* values = &(obj_ptr->get_map());
-            auto it = values->find("sid");
-            if (it!= values->end()) {
-                m_sid = static_pointer_cast<string_message>(it->second)->get_string();
-            }
-            else
-            {
-                goto failed;
-            }
-            it = values->find("pingInterval");
-            if (it!= values->end()&&it->second->get_flag() == message::flag_integer) {
-                m_ping_interval = (unsigned)static_pointer_cast<int_message>(it->second)->get_int();
-            }
-            else
-            {
-                m_ping_interval = 25000;
-            }
-            it = values->find("pingTimeout");
-
-            if (it!=values->end()&&it->second->get_flag() == message::flag_integer) {
-                m_ping_timeout = (unsigned) static_pointer_cast<int_message>(it->second)->get_int();
-            }
-            else
-            {
-                m_ping_timeout = 60000;
-            }
-
-            // Start ping timeout
-            update_ping_timeout_timer();
-
-            return;
-        }
-failed:
-        //just close it.
-        m_client.get_io_service().dispatch(std::bind(&client_impl::close_impl, this,close::status::policy_violation,"Handshake error"));
-    }
-
-    void client_impl::on_ping()
-    {
-        // Reply with pong packet.
-        packet p(packet::frame_pong);
-        m_packet_mgr.encode(p, [&](bool /*isBin*/,shared_ptr<const string> payload)
-        {
-            this->m_client.send(this->m_con, *payload, frame::opcode::text);
-        });
-
-        // Reset the ping timeout.
-        update_ping_timeout_timer();
-    }
-
-    void client_impl::on_decode(packet const& p)
-    {
-        switch(p.get_frame())
-        {
-        case packet::frame_message:
-        {
-	    // Special event for sid sync
-            if (p.get_type() == packet::type_connect) {
-                auto message = p.get_message();
-                if (message && message->get_flag() == message::flag_object)
-                {
-                    const object_message* obj_ptr = static_cast<object_message*>(message.get());
-                    const std::map<std::string, message::ptr>* values = &(obj_ptr->get_map());
-                    auto it = values->find("sid");
-                    if (it != values->end()) {
-                        m_sid = std::static_pointer_cast<string_message>(it->second)->get_string();
-                    }
-                }
-            }
-            socket::ptr so_ptr = get_socket_locked(p.get_nsp());
-            if(so_ptr)so_ptr->on_message_packet(p);
-            break;
-        }
-        case packet::frame_open:
-            this->on_handshake(p.get_message());
-            break;
-        case packet::frame_close:
-            //FIXME how to deal?
-            this->close_impl(close::status::abnormal_close, "End by server");
-            break;
-        case packet::frame_ping:
-            this->on_ping();
-            break;
-
-        default:
-            break;
-        }
-    }
-    
-    void client_impl::on_encode(bool isBinary,shared_ptr<const string> const& payload)
-    {
-        LOG("encoded payload length:"<<payload->length()<<endl);
-        m_client.get_io_service().dispatch(std::bind(&client_impl::send_impl,this,payload,isBinary?frame::opcode::binary:frame::opcode::text));
-    }
-    
-    void client_impl::clear_timers()
-    {
-        LOG("clear timers"<<endl);
-        asio::error_code ec;
-        if(m_ping_timeout_timer)
-        {
-            m_ping_timeout_timer->cancel(ec);
-            m_ping_timeout_timer.reset();
-        }
-    }
-
-    void client_impl::update_ping_timeout_timer() {
-        if (!m_ping_timeout_timer) {
-            m_ping_timeout_timer = std::unique_ptr<asio::steady_timer>(new asio::steady_timer(get_io_service()));
-        }
-
-        asio::error_code ec;
-        m_ping_timeout_timer->expires_from_now(milliseconds(m_ping_interval + m_ping_timeout), ec);
-        m_ping_timeout_timer->async_wait(std::bind(&client_impl::timeout_ping, this, std::placeholders::_1));
-    }
-    
-    void client_impl::reset_states()
-    {
-        m_client.reset();
-        m_sid.clear();
-        m_packet_mgr.reset();
-    }
-    
-#if SIO_TLS
-    client_impl::context_ptr client_impl::on_tls_init(connection_hdl conn)
-    {
-        context_ptr ctx = context_ptr(new  asio::ssl::context(asio::ssl::context::tls));
-        asio::error_code ec;
-        ctx->set_options(asio::ssl::context::default_workarounds |
-                         asio::ssl::context::no_tlsv1 |
-                         asio::ssl::context::no_tlsv1_1 |
-                         asio::ssl::context::single_dh_use,ec);
-        if(ec)
-        {
-            cerr<<"Init tls failed,reason:"<< ec.message()<<endl;
-        }
-        
-        return ctx;
-    }
-#endif
-
-    std::string client_impl::encode_query_string(const std::string &query){
-        ostringstream ss;
-        ss << std::hex;
-        // Percent-encode (RFC3986) non-alphanumeric characters.
-        for(const char c : query){
-            if((c >= 'a' && c <= 'z') || (c>= 'A' && c<= 'Z') || (c >= '0' && c<= '9')){
-                ss << c;
-            } else {
-                ss << '%' << std::uppercase << std::setw(2) << int((unsigned char) c) << std::nouppercase;
-            }
-        }
-        ss << std::dec;
-        return ss.str();
-    }
-}
diff --git a/third_party/socket.io-client-cpp/src/internal/sio_client_impl.h b/third_party/socket.io-client-cpp/src/internal/sio_client_impl.h
deleted file mode 100644
index f4f02aa..0000000
--- a/third_party/socket.io-client-cpp/src/internal/sio_client_impl.h
+++ /dev/null
@@ -1,253 +0,0 @@
-#ifndef SIO_CLIENT_IMPL_H
-#define SIO_CLIENT_IMPL_H
-
-#include <cstdint>
-#ifdef _WIN32
-#define _WEBSOCKETPP_CPP11_THREAD_
-//#define _WEBSOCKETPP_CPP11_RANDOM_DEVICE_
-#define _WEBSOCKETPP_NO_CPP11_FUNCTIONAL_
-#define INTIALIZER(__TYPE__)
-#else
-#define _WEBSOCKETPP_CPP11_STL_ 1
-#define INTIALIZER(__TYPE__) (__TYPE__)
-#endif
-#include <websocketpp/client.hpp>
-#if _DEBUG || DEBUG
-#if SIO_TLS
-#include <websocketpp/config/debug_asio.hpp>
-typedef websocketpp::config::debug_asio_tls client_config;
-#else
-#include <websocketpp/config/debug_asio_no_tls.hpp>
-typedef websocketpp::config::debug_asio client_config;
-#endif //SIO_TLS
-#else
-#if SIO_TLS
-#include <websocketpp/config/asio_client.hpp>
-typedef websocketpp::config::asio_tls_client client_config;
-#else
-#include <websocketpp/config/asio_no_tls_client.hpp>
-typedef websocketpp::config::asio_client client_config;
-#endif //SIO_TLS
-#endif //DEBUG
-
-#if SIO_TLS
-#include <asio/ssl/context.hpp>
-#endif
-
-#include <asio/steady_timer.hpp>
-#include <asio/error_code.hpp>
-#include <asio/io_service.hpp>
-
-#include <atomic>
-#include <memory>
-#include <map>
-#include <thread>
-#include "../sio_client.h"
-#include "sio_packet.h"
-
-namespace sio
-{
-    using namespace websocketpp;
-    
-    typedef websocketpp::client<client_config> client_type;
-    
-    class client_impl {
-        
-    protected:
-        enum con_state
-        {
-            con_opening,
-            con_opened,
-            con_closing,
-            con_closed
-        };
-        
-        client_impl(client_options const& options);
-        
-        ~client_impl();
-        
-        //set listeners and event bindings.
-#define SYNTHESIS_SETTER(__TYPE__,__FIELD__) \
-    void set_##__FIELD__(__TYPE__ const& l) \
-        { m_##__FIELD__ = l;}
-        
-        SYNTHESIS_SETTER(client::con_listener,open_listener)
-        
-        SYNTHESIS_SETTER(client::con_listener,fail_listener)
-
-        SYNTHESIS_SETTER(client::reconnect_listener,reconnect_listener)
-
-        SYNTHESIS_SETTER(client::con_listener,reconnecting_listener)
-        
-        SYNTHESIS_SETTER(client::close_listener,close_listener)
-        
-        SYNTHESIS_SETTER(client::socket_listener,socket_open_listener)
-        
-        SYNTHESIS_SETTER(client::socket_listener,socket_close_listener)
-        
-#undef SYNTHESIS_SETTER
-        
-        
-        void clear_con_listeners()
-        {
-            m_open_listener = nullptr;
-            m_close_listener = nullptr;
-            m_fail_listener = nullptr;
-            m_reconnect_listener = nullptr;
-            m_reconnecting_listener = nullptr;
-        }
-        
-        void clear_socket_listeners()
-        {
-            m_socket_open_listener = nullptr;
-            m_socket_close_listener = nullptr;
-        }
-        
-        // Client Functions - such as send, etc.
-        void connect(const std::string& uri, const std::map<std::string, std::string>& queryString,
-                     const std::map<std::string, std::string>& httpExtraHeaders, const message::ptr& auth);
-        
-        sio::socket::ptr const& socket(const std::string& nsp);
-        
-        // Closes the connection
-        void close();
-        
-        void sync_close();
-        
-        bool opened() const { return m_con_state == con_opened; }
-        
-        std::string const& get_sessionid() const { return m_sid; }
-
-        void set_reconnect_attempts(unsigned attempts) {m_reconn_attempts = attempts;}
-
-        void set_reconnect_delay(unsigned millis) {m_reconn_delay = millis;if(m_reconn_delay_max<millis) m_reconn_delay_max = millis;}
-
-        void set_reconnect_delay_max(unsigned millis) {m_reconn_delay_max = millis;if(m_reconn_delay>millis) m_reconn_delay = millis;}
-
-        void set_logs_default();
-
-        void set_logs_quiet();
-
-        void set_logs_verbose();
-		
-        void set_proxy_basic_auth(const std::string& uri, const std::string& username, const std::string& password);
-
-    protected:
-        void send(packet& p);
-        
-        void remove_socket(std::string const& nsp);
-        
-        asio::io_service& get_io_service();
-        
-        void on_socket_closed(std::string const& nsp);
-        
-        void on_socket_opened(std::string const& nsp);
-        
-    private:
-        void run_loop();
-
-        void connect_impl(const std::string& uri, const std::string& query);
-
-        void close_impl(close::status::value const& code,std::string const& reason);
-        
-        void send_impl(std::shared_ptr<const std::string> const&  payload_ptr,frame::opcode::value opcode);
-        
-        void ping(const asio::error_code& ec);
-        
-        void timeout_ping(const asio::error_code& ec);
-
-        void timeout_reconnect(asio::error_code const& ec);
-
-        unsigned next_delay() const;
-
-        socket::ptr get_socket_locked(std::string const& nsp);
-        
-        void sockets_invoke_void(void (sio::socket::*fn)(void));
-        
-        void on_decode(packet const& pack);
-        void on_encode(bool isBinary,shared_ptr<const string> const& payload);
-        
-        //websocket callbacks
-        void on_fail(connection_hdl con);
-
-        void on_open(connection_hdl con);
-
-        void on_close(connection_hdl con);
-
-        void on_message(connection_hdl con, client_type::message_ptr msg);
-
-        //socketio callbacks
-        void on_handshake(message::ptr const& message);
-
-        void on_ping();
-
-        void reset_states();
-
-        void clear_timers();
-
-        void update_ping_timeout_timer();
-        
-        #if SIO_TLS
-        typedef websocketpp::lib::shared_ptr<asio::ssl::context> context_ptr;
-        
-        context_ptr on_tls_init(connection_hdl con);
-        #endif
-        
-        // Percent encode query string
-        std::string encode_query_string(const std::string &query);
-
-        // Connection pointer for client functions.
-        connection_hdl m_con;
-        client_type m_client;
-        // Socket.IO server settings
-        std::string m_sid;
-        std::string m_base_url;
-        std::string m_query_string;
-        std::map<std::string, std::string> m_http_headers;
-        message::ptr m_auth;
-        std::string m_proxy_base_url;
-        std::string m_proxy_basic_username;
-        std::string m_proxy_basic_password;
-
-        unsigned int m_ping_interval;
-        unsigned int m_ping_timeout;
-        
-        std::unique_ptr<std::thread> m_network_thread;
-        
-        packet_manager m_packet_mgr;
-        
-        std::unique_ptr<asio::steady_timer> m_ping_timeout_timer;
-
-        std::unique_ptr<asio::steady_timer> m_reconn_timer;
-        
-        con_state m_con_state;
-        
-        client::con_listener m_open_listener;
-        client::con_listener m_fail_listener;
-        client::con_listener m_reconnecting_listener;
-        client::reconnect_listener m_reconnect_listener;
-        client::close_listener m_close_listener;
-        
-        client::socket_listener m_socket_open_listener;
-        client::socket_listener m_socket_close_listener;
-        
-        std::map<const std::string,socket::ptr> m_sockets;
-        
-        std::mutex m_socket_mutex;
-
-        unsigned m_reconn_delay;
-
-        unsigned m_reconn_delay_max;
-
-        unsigned m_reconn_attempts;
-
-        unsigned m_reconn_made;
-
-        std::atomic<bool> m_abort_retries { false };
-
-        friend class sio::client;
-        friend class sio::socket;
-    };
-}
-#endif // SIO_CLIENT_IMPL_H
-
diff --git a/third_party/socket.io-client-cpp/src/internal/sio_packet.cpp b/third_party/socket.io-client-cpp/src/internal/sio_packet.cpp
deleted file mode 100644
index 4b81098..0000000
--- a/third_party/socket.io-client-cpp/src/internal/sio_packet.cpp
+++ /dev/null
@@ -1,510 +0,0 @@
-//
-//  sio_packet.cpp
-//
-//  Created by Melo Yao on 3/22/15.
-//
-
-#include "sio_packet.h"
-#include <rapidjson/document.h>
-#include <rapidjson/encodedstream.h>
-#include <rapidjson/writer.h>
-#include <cassert>
-
-#define kBIN_PLACE_HOLDER "_placeholder"
-
-namespace sio
-{
-    using namespace rapidjson;
-    using namespace std;
-    void accept_message(message const& msg,Value& val, Document& doc,vector<shared_ptr<const string> >& buffers);
-
-	void accept_bool_message(bool_message const& msg, Value& val)
-	{
-		val.SetBool(msg.get_bool());
-	}
-
-	void accept_null_message(Value& val)
-	{
-		val.SetNull();
-	}
-
-    void accept_int_message(int_message const& msg, Value& val)
-    {
-        val.SetInt64(msg.get_int());
-    }
-
-    void accept_double_message(double_message const& msg, Value& val)
-    {
-        val.SetDouble(msg.get_double());
-    }
-
-    void accept_string_message(string_message const& msg, Value& val)
-    {
-        val.SetString(msg.get_string().data(),(SizeType) msg.get_string().length());
-    }
-
-
-    void accept_binary_message(binary_message const& msg,Value& val,Document& doc,vector<shared_ptr<const string> >& buffers)
-    {
-        val.SetObject();
-        Value boolVal;
-        boolVal.SetBool(true);
-        val.AddMember(kBIN_PLACE_HOLDER, boolVal, doc.GetAllocator());
-        Value numVal;
-        numVal.SetInt((int)buffers.size());
-        val.AddMember("num", numVal, doc.GetAllocator());
-        buffers.push_back(msg.get_binary());
-    }
-
-    void accept_array_message(array_message const& msg,Value& val,Document& doc,vector<shared_ptr<const string> >& buffers)
-    {
-        val.SetArray();
-        for (vector<message::ptr>::const_iterator it = msg.get_vector().begin(); it!=msg.get_vector().end(); ++it) {
-            Value child;
-            accept_message(*(*it), child, doc,buffers);
-            val.PushBack(child, doc.GetAllocator());
-        }
-    }
-
-    void accept_object_message(object_message const& msg,Value& val,Document& doc,vector<shared_ptr<const string> >& buffers)
-    {
-        val.SetObject();
-        for (map<string,message::ptr>::const_iterator it = msg.get_map().begin(); it!= msg.get_map().end(); ++it) {
-            Value nameVal;
-            nameVal.SetString(it->first.data(), (SizeType)it->first.length(), doc.GetAllocator());
-            Value valueVal;
-            accept_message(*(it->second), valueVal, doc,buffers);
-            val.AddMember(nameVal, valueVal, doc.GetAllocator());
-        }
-    }
-
-    void accept_message(message const& msg,Value& val, Document& doc,vector<shared_ptr<const string> >& buffers)
-    {
-        const message* msg_ptr = &msg;
-        switch(msg.get_flag())
-        {
-        case message::flag_integer:
-        {
-            accept_int_message(*(static_cast<const int_message*>(msg_ptr)), val);
-            break;
-        }
-        case message::flag_double:
-        {
-            accept_double_message(*(static_cast<const double_message*>(msg_ptr)), val);
-            break;
-        }
-        case message::flag_string:
-        {
-            accept_string_message(*(static_cast<const string_message*>(msg_ptr)), val);
-            break;
-        }
-		case message::flag_boolean:
-		{
-			accept_bool_message(*(static_cast<const bool_message*>(msg_ptr)), val);
-			break;
-		}
-		case message::flag_null:
-		{
-			accept_null_message(val);
-			break;
-		}
-        case message::flag_binary:
-        {
-            accept_binary_message(*(static_cast<const binary_message*>(msg_ptr)), val,doc,buffers);
-            break;
-        }
-        case message::flag_array:
-        {
-            accept_array_message(*(static_cast<const array_message*>(msg_ptr)), val,doc,buffers);
-            break;
-        }
-        case message::flag_object:
-        {
-            accept_object_message(*(static_cast<const object_message*>(msg_ptr)), val,doc,buffers);
-            break;
-        }
-        default:
-            break;
-        }
-    }
-
-    message::ptr from_json(Value const& value, vector<shared_ptr<const string> > const& buffers)
-    {
-        if(value.IsInt64())
-        {
-            return int_message::create(value.GetInt64());
-        }
-        else if(value.IsDouble())
-        {
-            return double_message::create(value.GetDouble());
-        }
-        else if(value.IsString())
-        {
-            string str(value.GetString(),value.GetStringLength());
-            return string_message::create(str);
-        }
-        else if(value.IsArray())
-        {
-            message::ptr ptr = array_message::create();
-            for (SizeType i = 0; i< value.Size(); ++i) {
-                static_cast<array_message*>(ptr.get())->get_vector().push_back(from_json(value[i],buffers));
-            }
-            return ptr;
-        }
-        else if(value.IsObject())
-        {
-            //binary placeholder
-            auto mem_it = value.FindMember(kBIN_PLACE_HOLDER);
-            if (mem_it!=value.MemberEnd() && mem_it->value.GetBool()) {
-
-                int num = value["num"].GetInt();
-                if(num >= 0 && num < static_cast<int>(buffers.size()))
-                {
-                    return binary_message::create(buffers[num]);
-                }
-                return message::ptr();
-            }
-            //real object message.
-            message::ptr ptr = object_message::create();
-            for (auto it = value.MemberBegin();it!=value.MemberEnd();++it)
-            {
-                if(it->name.IsString())
-                {
-                    string key(it->name.GetString(),it->name.GetStringLength());
-                    static_cast<object_message*>(ptr.get())->get_map()[key] = from_json(it->value,buffers);
-                }
-            }
-            return ptr;
-        }
-		else if(value.IsBool())
-		{
-			return bool_message::create(value.GetBool());
-		}
-		else if(value.IsNull())
-		{
-			return null_message::create();
-		}
-        return message::ptr();
-    }
-
-    packet::packet(string const& nsp,message::ptr const& msg,int pack_id, bool isAck):
-        _frame(frame_message),
-        _type((isAck?type_ack : type_event) | type_undetermined),
-        _nsp(nsp),
-        _pack_id(pack_id),
-        _message(msg),
-        _pending_buffers(0)
-    {
-        assert((!isAck
-                || (isAck&&pack_id>=0)));
-    }
-
-    packet::packet(type type,string const& nsp, message::ptr const& msg):
-        _frame(frame_message),
-        _type(type),
-        _nsp(nsp),
-        _pack_id(-1),
-        _message(msg),
-        _pending_buffers(0)
-    {
-
-    }
-
-    packet::packet(packet::frame_type frame):
-        _frame(frame),
-        _type(type_undetermined),
-        _pack_id(-1),
-        _pending_buffers(0)
-    {
-
-    }
-
-    packet::packet():
-        _type(type_undetermined),
-        _pack_id(-1),
-        _pending_buffers(0)
-    {
-
-    }
-
-
-    bool packet::is_binary_message(string const& payload_ptr)
-    {
-        return payload_ptr.size()>0 && payload_ptr[0] == frame_message;
-    }
-
-    bool packet::is_text_message(string const& payload_ptr)
-    {
-        return payload_ptr.size()>0 && payload_ptr[0] == (frame_message + '0');
-    }
-
-    bool packet::is_message(string const& payload_ptr)
-    {
-        return is_binary_message(payload_ptr) || is_text_message(payload_ptr);
-    }
-
-    bool packet::parse_buffer(const string &buf_payload)
-    {
-        if (_pending_buffers > 0) {
-            assert(is_binary_message(buf_payload));//this is ensured by outside.
-            _buffers.push_back(std::make_shared<string>(buf_payload.data(),buf_payload.size()));
-            _pending_buffers--;
-            if (_pending_buffers == 0) {
-
-                Document doc;
-                doc.Parse<0>(_buffers.front()->data());
-                _buffers.erase(_buffers.begin());
-                _message = from_json(doc, _buffers);
-                _buffers.clear();
-                return false;
-            }
-            return true;
-        }
-        return false;
-    }
-
-    bool packet::parse(const string& payload_ptr)
-    {
-        assert(!is_binary_message(payload_ptr)); //this is ensured by outside
-        _frame = (packet::frame_type) (payload_ptr[0] - '0');
-        _message.reset();
-        _pack_id = -1;
-        _buffers.clear();
-        _pending_buffers = 0;
-        size_t pos = 1;
-        if (_frame == frame_message) {
-            _type = (packet::type)(payload_ptr[pos] - '0');
-            if(_type < type_min || _type > type_max)
-            {
-                return false;
-            }
-            pos++;
-            if (_type == type_binary_event || _type == type_binary_ack) {
-                size_t score_pos = payload_ptr.find('-');
-                _pending_buffers = static_cast<unsigned>(std::stoul(payload_ptr.substr(pos, score_pos - pos)));
-                pos = score_pos+1;
-            }
-        }
-
-        size_t nsp_json_pos = payload_ptr.find_first_of("{[\"/",pos,4);
-        if(nsp_json_pos==string::npos)//no namespace and no message,the end.
-        {
-            _nsp = "/";
-            return false;
-        }
-        size_t json_pos = nsp_json_pos;
-        if(payload_ptr[nsp_json_pos] == '/')//nsp_json_pos is start of nsp
-        {
-            size_t comma_pos = payload_ptr.find_first_of(",");//end of nsp
-            if(comma_pos == string::npos)//packet end with nsp
-            {
-                _nsp = payload_ptr.substr(nsp_json_pos);
-                return false;
-            }
-            else//we have a message, maybe the message have an id.
-            {
-                _nsp = payload_ptr.substr(nsp_json_pos,comma_pos - nsp_json_pos);
-                pos = comma_pos+1;//start of the message
-                json_pos = payload_ptr.find_first_of("\"[{", pos, 3);//start of the json part of message
-                if(json_pos == string::npos)
-                {
-                    //no message,the end
-                    //assume if there's no message, there's no message id.
-                    return false;
-                }
-            }
-        }
-        else
-        {
-            _nsp = "/";
-        }
-
-        if(pos<json_pos)//we've got pack id.
-        {
-            _pack_id = std::stoi(payload_ptr.substr(pos,json_pos - pos));
-        }
-        if (_frame == frame_message && (_type == type_binary_event || _type == type_binary_ack)) {
-            //parse later when all buffers are arrived.
-            _buffers.push_back(make_shared<string>(payload_ptr.data() + json_pos, payload_ptr.length() - json_pos));
-            return true;
-        }
-        else
-        {
-            Document doc;
-            doc.Parse<0>(payload_ptr.data()+json_pos);
-            _message = from_json(doc, vector<shared_ptr<const string> >());
-            return false;
-        }
-
-    }
-
-    bool packet::accept(string& payload_ptr, vector<shared_ptr<const string> >&buffers)
-    {
-        char frame_char = _frame+'0';
-        payload_ptr.append(&frame_char,1);
-        if (_frame!=frame_message) {
-            return false;
-        }
-        bool hasMessage = false;
-        Document doc;
-        if (_message) {
-            accept_message(*_message, doc, doc, buffers);
-            hasMessage = true;
-        }
-        bool hasBinary = buffers.size()>0;
-        _type = _type&(~type_undetermined);
-        if(_type == type_event)
-        {
-            _type = hasBinary?type_binary_event:type_event;
-        }
-        else if(_type == type_ack)
-        {
-            _type = hasBinary? type_binary_ack : type_ack;
-        }
-        ostringstream ss;
-        ss.precision(8);
-        ss<<_type;
-        if (hasBinary) {
-            ss<<buffers.size()<<"-";
-        }
-        if(_nsp.size()>0 && _nsp!="/")
-        {
-            ss<<_nsp;
-            if (hasMessage || _pack_id>=0) {
-                ss<<",";
-            }
-        }
-
-        if(_pack_id>=0)
-        {
-            ss<<_pack_id;
-        }
-
-        payload_ptr.append(ss.str());
-        if (hasMessage)
-        {
-            StringBuffer buffer;
-            Writer<StringBuffer> writer(buffer);
-            doc.Accept(writer);
-            payload_ptr.append(buffer.GetString(),buffer.GetSize());
-        }
-        return hasBinary;
-    }
-
-    packet::frame_type packet::get_frame() const
-    {
-        return _frame;
-    }
-
-    packet::type packet::get_type() const
-    {
-        assert((_type & type_undetermined) == 0);
-        return (type)_type;
-    }
-
-    string const& packet::get_nsp() const
-    {
-        return _nsp;
-    }
-
-    message::ptr const& packet::get_message() const
-    {
-        return _message;
-    }
-
-    unsigned packet::get_pack_id() const
-    {
-        return _pack_id;
-    }
-
-
-    void packet_manager::set_decode_callback(function<void (packet const&)> const& decode_callback)
-    {
-        m_decode_callback = decode_callback;
-    }
-
-    void packet_manager::set_encode_callback(function<void (bool,shared_ptr<const string> const&)> const& encode_callback)
-    {
-        m_encode_callback = encode_callback;
-    }
-
-    void packet_manager::reset()
-    {
-        m_partial_packet.reset();
-    }
-
-    void packet_manager::encode(packet& pack,encode_callback_function const& override_encode_callback) const
-    {
-        shared_ptr<string> ptr = make_shared<string>();
-        vector<shared_ptr<const string> > buffers;
-        const encode_callback_function *cb_ptr = &m_encode_callback;
-        if(override_encode_callback)
-        {
-            cb_ptr = &override_encode_callback;
-        }
-        if(pack.accept(*ptr,buffers))
-        {
-            if((*cb_ptr))
-            {
-                (*cb_ptr)(false,ptr);
-            }
-            for(auto it = buffers.begin();it!=buffers.end();++it)
-            {
-                if((*cb_ptr))
-                {
-                    (*cb_ptr)(true,*it);
-                }
-            }
-        }
-        else
-        {
-            if((*cb_ptr))
-            {
-                (*cb_ptr)(false,ptr);
-            }
-        }
-    }
-
-    void packet_manager::put_payload(string const& payload)
-    {
-        unique_ptr<packet> p;
-        do
-        {
-            if(packet::is_text_message(payload))
-            {
-                p.reset(new packet());
-                if(p->parse(payload))
-                {
-                    m_partial_packet = std::move(p);
-                }
-                else
-                {
-                    break;
-                }
-            }
-            else if(packet::is_binary_message(payload))
-            {
-                if(m_partial_packet)
-                {
-                    if(!m_partial_packet->parse_buffer(payload))
-                    {
-                        p = std::move(m_partial_packet);
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                p.reset(new packet());
-                p->parse(payload);
-                break;
-            }
-            return;
-        }while(0);
-
-        if(m_decode_callback)
-        {
-            m_decode_callback(*p);
-        }
-    }
-}
diff --git a/third_party/socket.io-client-cpp/src/internal/sio_packet.h b/third_party/socket.io-client-cpp/src/internal/sio_packet.h
deleted file mode 100644
index c43a0ae..0000000
--- a/third_party/socket.io-client-cpp/src/internal/sio_packet.h
+++ /dev/null
@@ -1,106 +0,0 @@
-//
-//  sio_packet.h
-//
-//  Created by Melo Yao on 3/19/15.
-//
-
-#ifndef SIO_PACKET_H
-#define SIO_PACKET_H
-#include <sstream>
-#include "../sio_message.h"
-#include <functional>
-
-namespace sio
-{
-    using namespace std;
-    
-    class packet
-    {
-    public:
-        enum frame_type
-        {
-            frame_open = 0,
-            frame_close = 1,
-            frame_ping = 2,
-            frame_pong = 3,
-            frame_message = 4,
-            frame_upgrade = 5,
-            frame_noop = 6
-        };
-        
-        enum type
-        {
-            type_min = 0,
-            type_connect = 0,
-            type_disconnect = 1,
-            type_event = 2,
-            type_ack = 3,
-            type_error = 4,
-            type_binary_event = 5,
-            type_binary_ack = 6,
-            type_max = 6,
-            type_undetermined = 0x10 //undetermined mask bit
-        };
-    private:
-        frame_type _frame;
-        int _type;
-        string _nsp;
-        int _pack_id;
-        message::ptr _message;
-        unsigned _pending_buffers;
-        vector<shared_ptr<const string> > _buffers;
-    public:
-        packet(string const& nsp,message::ptr const& msg,int pack_id = -1,bool isAck = false);//message type constructor.
-        
-        packet(frame_type frame);
-        
-        packet(type type,string const& nsp= string(),message::ptr const& msg = message::ptr());//other message types constructor.
-        //empty constructor for parse.
-        packet();
-        
-        frame_type get_frame() const;
-        
-        type get_type() const;
-        
-        bool parse(string const& payload_ptr);//return true if need to parse buffer.
-        
-        bool parse_buffer(string const& buf_payload);
-        
-        bool accept(string& payload_ptr, vector<shared_ptr<const string> >&buffers); //return true if has binary buffers.
-        
-        string const& get_nsp() const;
-        
-        message::ptr const& get_message() const;
-        
-        unsigned get_pack_id() const;
-        
-        static bool is_message(string const& payload_ptr);
-        static bool is_text_message(string const& payload_ptr);
-        static bool is_binary_message(string const& payload_ptr);
-    };
-    
-    class packet_manager
-    {
-    public:
-        typedef function<void (bool,shared_ptr<const string> const&)> encode_callback_function;
-        typedef  function<void (packet const&)> decode_callback_function;
-        
-        void set_decode_callback(decode_callback_function const& decode_callback);
-
-        void set_encode_callback(encode_callback_function const& encode_callback);
-        
-        void encode(packet& pack,encode_callback_function const& override_encode_callback = encode_callback_function()) const;
-        
-        void put_payload(string const& payload);
-        
-        void reset();
-        
-    private:
-        decode_callback_function m_decode_callback;
-        
-        encode_callback_function m_encode_callback;
-        
-        std::unique_ptr<packet> m_partial_packet;
-    };
-}
-#endif
diff --git a/third_party/socket.io-client-cpp/src/sio_client.cpp b/third_party/socket.io-client-cpp/src/sio_client.cpp
deleted file mode 100644
index 1cdb7f7..0000000
--- a/third_party/socket.io-client-cpp/src/sio_client.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-//  sio_client.h
-//
-//  Created by Melo Yao on 3/25/15.
-//
-
-#include "sio_client.h"
-#include "internal/sio_client_impl.h"
-
-using namespace websocketpp;
-using std::stringstream;
-
-namespace sio
-{
-    client::client() : m_impl(new client_impl({})) {}
-    
-    client::client(client_options const& options):
-        m_impl(new client_impl(options))
-    {
-    }
-    
-    client::~client()
-    {
-        delete m_impl;
-    }
-    
-    void client::set_open_listener(con_listener const& l)
-    {
-        m_impl->set_open_listener(l);
-    }
-    
-    void client::set_fail_listener(con_listener const& l)
-    {
-        m_impl->set_fail_listener(l);
-    }
-    
-    void client::set_close_listener(close_listener const& l)
-    {
-        m_impl->set_close_listener(l);
-    }
-    
-    void client::set_socket_open_listener(socket_listener const& l)
-    {
-        m_impl->set_socket_open_listener(l);
-    }
-    
-    void client::set_reconnect_listener(reconnect_listener const& l)
-    {
-        m_impl->set_reconnect_listener(l);
-    }
-
-    void client::set_reconnecting_listener(con_listener const& l)
-    {
-        m_impl->set_reconnecting_listener(l);
-    }
-
-    void client::set_socket_close_listener(socket_listener const& l)
-    {
-        m_impl->set_socket_close_listener(l);
-    }
-    
-    void client::clear_con_listeners()
-    {
-        m_impl->clear_con_listeners();
-    }
-    
-    void client::clear_socket_listeners()
-    {
-        m_impl->clear_socket_listeners();
-    }
-	
-    void client::set_proxy_basic_auth(const std::string& uri, const std::string& username, const std::string& password)
-    {
-        m_impl->set_proxy_basic_auth(uri, username, password);
-    }
-
-    void client::connect(const std::string& uri)
-    {
-        m_impl->connect(uri, {}, {}, {});
-    }
-
-    void client::connect(const std::string& uri, const message::ptr& auth)
-    {
-        m_impl->connect(uri, {}, {}, auth);
-    }
-
-    void client::connect(const std::string& uri, const std::map<string,string>& query)
-    {
-        m_impl->connect(uri, query, {}, {});
-    }
-
-    void client::connect(const std::string& uri, const std::map<string,string>& query, const message::ptr& auth)
-    {
-        m_impl->connect(uri, query, {}, auth);
-    }
-
-    void client::connect(const std::string& uri, const std::map<std::string,std::string>& query,
-                         const std::map<std::string,std::string>& http_extra_headers)
-    {
-        m_impl->connect(uri, query, http_extra_headers, {});
-    }
-
-    void client::connect(const std::string& uri, const std::map<std::string,std::string>& query,
-                         const std::map<std::string,std::string>& http_extra_headers, const message::ptr& auth)
-    {
-        m_impl->connect(uri, query, http_extra_headers, auth);
-    }
-    
-    socket::ptr const& client::socket(const std::string& nsp)
-    {
-        return m_impl->socket(nsp);
-    }
-    
-    // Closes the connection
-    void client::close()
-    {
-        m_impl->close();
-    }
-    
-    void client::sync_close()
-    {
-        m_impl->sync_close();
-    }
-    
-    bool client::opened() const
-    {
-        return m_impl->opened();
-    }
-    
-    std::string const& client::get_sessionid() const
-    {
-        return m_impl->get_sessionid();
-    }
-
-    void client::set_reconnect_attempts(int attempts)
-    {
-        m_impl->set_reconnect_attempts(attempts);
-    }
-
-    void client::set_reconnect_delay(unsigned millis)
-    {
-        m_impl->set_reconnect_delay(millis);
-    }
-
-    void client::set_reconnect_delay_max(unsigned millis)
-    {
-        m_impl->set_reconnect_delay_max(millis);
-    }
-
-    void client::set_logs_default()
-    {
-        m_impl->set_logs_default();
-    }
-
-    void client::set_logs_quiet()
-    {
-        m_impl->set_logs_quiet();
-    }
-
-    void client::set_logs_verbose()
-    {
-        m_impl->set_logs_verbose();
-    }
-
-}
diff --git a/third_party/socket.io-client-cpp/src/sio_client.h b/third_party/socket.io-client-cpp/src/sio_client.h
deleted file mode 100644
index a8cbb9f..0000000
--- a/third_party/socket.io-client-cpp/src/sio_client.h
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-//  sio_client.h
-//
-//  Created by Melo Yao on 3/25/15.
-//
-
-#ifndef SIO_CLIENT_H
-#define SIO_CLIENT_H
-#include <string>
-#include <functional>
-#include "sio_message.h"
-#include "sio_socket.h"
-
-namespace asio {
-    class io_context;
-}
-
-namespace sio
-{
-    class client_impl;
-
-    struct client_options {
-        asio::io_context* io_context = nullptr;
-    };
-    
-    class client {
-    public:
-        enum close_reason
-        {
-            close_reason_normal,
-            close_reason_drop
-        };
-        
-        typedef std::function<void(void)> con_listener;
-        
-        typedef std::function<void(close_reason const& reason)> close_listener;
-
-        typedef std::function<void(unsigned, unsigned)> reconnect_listener;
-        
-        typedef std::function<void(std::string const& nsp)> socket_listener;
-        
-        client();
-        client(client_options const& options);
-        ~client();
-        
-        //set listeners and event bindings.
-        void set_open_listener(con_listener const& l);
-        
-        void set_fail_listener(con_listener const& l);
-        
-        void set_reconnecting_listener(con_listener const& l);
-
-        void set_reconnect_listener(reconnect_listener const& l);
-
-        void set_close_listener(close_listener const& l);
-        
-        void set_socket_open_listener(socket_listener const& l);
-        
-        void set_socket_close_listener(socket_listener const& l);
-        
-        void clear_con_listeners();
-        
-        void clear_socket_listeners();
-        
-        // Client Functions - such as send, etc.
-        void connect(const std::string& uri);
-
-        void connect(const std::string& uri, const message::ptr& auth);
-
-        void connect(const std::string& uri, const std::map<std::string,std::string>& query);
-
-        void connect(const std::string& uri, const std::map<std::string,std::string>& query, const message::ptr& auth);
-
-        void connect(const std::string& uri, const std::map<std::string,std::string>& query,
-                     const std::map<std::string,std::string>& http_extra_headers);
-
-        void connect(const std::string& uri, const std::map<std::string,std::string>& query,
-                     const std::map<std::string,std::string>& http_extra_headers, const message::ptr& auth);
-
-        void set_reconnect_attempts(int attempts);
-
-        void set_reconnect_delay(unsigned millis);
-
-        void set_reconnect_delay_max(unsigned millis);
-
-        void set_logs_default();
-
-        void set_logs_quiet();
-
-        void set_logs_verbose();
-
-        sio::socket::ptr const& socket(const std::string& nsp = "");
-        
-        // Closes the connection
-        void close();
-        
-        void sync_close();
-        
-        void set_proxy_basic_auth(const std::string& uri, const std::string& username, const std::string& password);
-		
-        bool opened() const;
-        
-        std::string const& get_sessionid() const;
-        
-    private:
-        //disable copy constructor and assign operator.
-        client(client const&){}
-        void operator=(client const&){}
-        
-        client_impl* m_impl;
-    };
-    
-}
-
-
-#endif // __SIO_CLIENT__H__
diff --git a/third_party/socket.io-client-cpp/src/sio_message.h b/third_party/socket.io-client-cpp/src/sio_message.h
deleted file mode 100644
index 2801699..0000000
--- a/third_party/socket.io-client-cpp/src/sio_message.h
+++ /dev/null
@@ -1,569 +0,0 @@
-//
-//  sio_message.h
-//
-//  Created by Melo Yao on 3/25/15.
-//
-
-#ifndef __SIO_MESSAGE_H__
-#define __SIO_MESSAGE_H__
-#include <string>
-#include <memory>
-#include <vector>
-#include <map>
-#include <cassert>
-#include <type_traits>
-namespace sio
-{
-    class message
-    {
-    public:
-        enum flag
-        {
-            flag_integer,
-            flag_double,
-            flag_string,
-            flag_binary,
-            flag_array,
-            flag_object,
-            flag_boolean,
-            flag_null
-        };
-
-        virtual ~message(){};
-
-        class list;
-
-        flag get_flag() const
-        {
-            return _flag;
-        }
-
-        typedef std::shared_ptr<message> ptr;
-
-        virtual bool get_bool() const
-        {
-            assert(false);
-            return false;
-        }
-
-        virtual int64_t get_int() const
-        {
-            assert(false);
-            return 0;
-        }
-
-        virtual double get_double() const
-        {
-            assert(false);
-            return 0;
-        }
-
-        virtual std::string const& get_string() const
-        {
-            assert(false);
-            static std::string s_empty_string;
-            s_empty_string.clear();
-            return s_empty_string;
-        }
-
-        virtual std::shared_ptr<const std::string> const& get_binary() const
-        {
-            assert(false);
-            static std::shared_ptr<const std::string> s_empty_binary;
-            s_empty_binary = nullptr;
-            return s_empty_binary;
-        }
-
-        virtual const std::vector<ptr>& get_vector() const
-        {
-            assert(false);
-            static std::vector<ptr> s_empty_vector;
-            s_empty_vector.clear();
-            return s_empty_vector;
-        }
-
-        virtual std::vector<ptr>& get_vector()
-        {
-            assert(false);
-            static std::vector<ptr> s_empty_vector;
-            s_empty_vector.clear();
-            return s_empty_vector;
-        }
-
-        virtual const std::map<std::string,message::ptr>& get_map() const
-        {
-            assert(false);
-            static std::map<std::string,message::ptr> s_empty_map;
-            s_empty_map.clear();
-            return s_empty_map;
-        }
-
-        virtual std::map<std::string,message::ptr>& get_map()
-        {
-            assert(false);
-            static std::map<std::string,message::ptr> s_empty_map;
-            s_empty_map.clear();
-            return s_empty_map;
-        }
-    private:
-        flag _flag;
-
-    protected:
-        message(flag f):_flag(f){}
-    };
-
-    class null_message : public message
-    {
-    protected:
-        null_message()
-            :message(flag_null)
-        {
-        }
-
-    public:
-        static message::ptr create()
-        {
-            return ptr(new null_message());
-        }
-    };
-
-    class bool_message : public message
-    {
-        bool _v;
-
-    protected:
-        bool_message(bool v)
-            :message(flag_boolean),_v(v)
-        {
-        }
-
-    public:
-        static message::ptr create(bool v)
-        {
-            return ptr(new bool_message(v));
-        }
-
-        bool get_bool() const
-        {
-            return _v;
-        }
-    };
-
-    class int_message : public message
-    {
-        int64_t _v;
-    protected:
-        int_message(int64_t v)
-            :message(flag_integer),_v(v)
-        {
-        }
-
-    public:
-        static message::ptr create(int64_t v)
-        {
-            return ptr(new int_message(v));
-        }
-
-        int64_t get_int() const
-        {
-            return _v;
-        }
-
-        double get_double() const//add double accessor for integer.
-        {
-            return static_cast<double>(_v);
-        }
-    };
-
-    class double_message : public message
-    {
-        double _v;
-        double_message(double v)
-            :message(flag_double),_v(v)
-        {
-        }
-
-    public:
-        static message::ptr create(double v)
-        {
-            return ptr(new double_message(v));
-        }
-
-        double get_double() const
-        {
-            return _v;
-        }
-    };
-
-    class string_message : public message
-    {
-        std::string _v;
-        string_message(std::string const& v)
-            :message(flag_string),_v(v)
-        {
-        }
-
-        string_message(std::string&& v)
-            :message(flag_string),_v(std::move(v))
-        {
-        }
-    public:
-        static message::ptr create(std::string const& v)
-        {
-            return ptr(new string_message(v));
-        }
-
-        static message::ptr create(std::string&& v)
-        {
-            return ptr(new string_message(std::move(v)));
-        }
-
-        std::string const& get_string() const
-        {
-            return _v;
-        }
-    };
-
-    class binary_message : public message
-    {
-        std::shared_ptr<const std::string> _v;
-        binary_message(std::shared_ptr<const std::string> const& v)
-            :message(flag_binary),_v(v)
-        {
-        }
-    public:
-        static message::ptr create(std::shared_ptr<const std::string> const& v)
-        {
-            return ptr(new binary_message(v));
-        }
-
-        std::shared_ptr<const std::string> const& get_binary() const
-        {
-            return _v;
-        }
-    };
-
-    class array_message : public message
-    {
-        std::vector<message::ptr> _v;
-        array_message():message(flag_array)
-        {
-        }
-
-    public:
-        static message::ptr create()
-        {
-            return ptr(new array_message());
-        }
-
-        void push(message::ptr const& message)
-        {
-            if(message)
-                _v.push_back(message);
-        }
-
-        void push(const std::string& text)
-        {
-            _v.push_back(string_message::create(text));
-        }
-
-        void push(std::string&& text)
-        {
-            _v.push_back(string_message::create(std::move(text)));
-        }
-
-        void push(std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                _v.push_back(binary_message::create(binary));
-        }
-
-        void push(std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                _v.push_back(binary_message::create(binary));
-        }
-
-        void insert(size_t pos,message::ptr const& message)
-        {
-            _v.insert(_v.begin()+pos, message);
-        }
-
-        void insert(size_t pos,const std::string& text)
-        {
-            _v.insert(_v.begin()+pos, string_message::create(text));
-        }
-
-        void insert(size_t pos,std::string&& text)
-        {
-            _v.insert(_v.begin()+pos, string_message::create(std::move(text)));
-        }
-
-        void insert(size_t pos,std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                _v.insert(_v.begin()+pos, binary_message::create(binary));
-        }
-
-        void insert(size_t pos,std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                _v.insert(_v.begin()+pos, binary_message::create(binary));
-        }
-
-        size_t size() const
-        {
-            return _v.size();
-        }
-
-        const message::ptr& at(size_t i) const
-        {
-            return _v[i];
-        }
-
-        const message::ptr& operator[] (size_t i) const
-        {
-            return _v[i];
-        }
-
-        std::vector<ptr>& get_vector()
-        {
-            return _v;
-        }
-
-        const std::vector<ptr>& get_vector() const
-        {
-            return _v;
-        }
-    };
-
-    class object_message : public message
-    {
-        std::map<std::string,message::ptr> _v;
-        object_message() : message(flag_object)
-        {
-        }
-    public:
-        static message::ptr create()
-        {
-            return ptr(new object_message());
-        }
-
-        void insert(const std::string & key,message::ptr const& message)
-        {
-            _v[key] = message;
-        }
-
-        void insert(const std::string & key,const std::string& text)
-        {
-            _v[key] = string_message::create(text);
-        }
-
-        void insert(const std::string & key,std::string&& text)
-        {
-            _v[key] = string_message::create(std::move(text));
-        }
-
-        void insert(const std::string & key,std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                _v[key] = binary_message::create(binary);
-        }
-
-        void insert(const std::string & key,std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                _v[key] = binary_message::create(binary);
-        }
-
-        bool has(const std::string & key)
-        {
-            return _v.find(key) != _v.end();
-        }
-
-        const message::ptr& at(const std::string & key) const
-        {
-            static std::shared_ptr<message> not_found;
-
-            std::map<std::string,message::ptr>::const_iterator it = _v.find(key);
-            if (it != _v.cend()) return it->second;
-            return not_found;
-        }
-
-        const message::ptr& operator[] (const std::string & key) const
-        {
-            return at(key);
-        }
-
-        bool has(const std::string & key) const
-        {
-            return _v.find(key) != _v.end();
-        }
-
-        std::map<std::string,message::ptr>& get_map()
-        {
-            return _v;
-        }
-
-        const std::map<std::string,message::ptr>& get_map() const
-        {
-            return _v;
-        }
-    };
-
-    class message::list
-    {
-    public:
-        list()
-        {
-        }
-
-        list(std::nullptr_t)
-        {
-        }
-
-        list(message::list&& rhs):
-            m_vector(std::move(rhs.m_vector))
-        {
-
-        }
-
-        list & operator= (const message::list && rhs)
-        {
-            m_vector = std::move(rhs.m_vector);
-            return *this;
-        }
-
-        template <typename T>
-        list(T&& content,
-            typename std::enable_if<std::is_same<std::vector<message::ptr>,typename std::remove_reference<T>::type>::value>::type* = 0):
-            m_vector(std::forward<T>(content))
-        {
-        }
-
-        list(message::list const& rhs):
-            m_vector(rhs.m_vector)
-        {
-
-        }
-
-        list(message::ptr const& message)
-        {
-            if(message)
-                m_vector.push_back(message);
-
-        }
-
-        list(const std::string& text)
-        {
-            m_vector.push_back(string_message::create(text));
-        }
-
-        list(std::string&& text)
-        {
-            m_vector.push_back(string_message::create(std::move(text)));
-        }
-
-        list(std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                m_vector.push_back(binary_message::create(binary));
-        }
-
-        list(std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                m_vector.push_back(binary_message::create(binary));
-        }
-
-        void push(message::ptr const& message)
-        {
-            if(message)
-                m_vector.push_back(message);
-        }
-
-        void push(const std::string& text)
-        {
-            m_vector.push_back(string_message::create(text));
-        }
-
-        void push(std::string&& text)
-        {
-            m_vector.push_back(string_message::create(std::move(text)));
-        }
-
-        void push(std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                m_vector.push_back(binary_message::create(binary));
-        }
-
-        void push(std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                m_vector.push_back(binary_message::create(binary));
-        }
-
-        void insert(size_t pos,message::ptr const& message)
-        {
-            m_vector.insert(m_vector.begin()+pos, message);
-        }
-
-        void insert(size_t pos,const std::string& text)
-        {
-            m_vector.insert(m_vector.begin()+pos, string_message::create(text));
-        }
-
-        void insert(size_t pos,std::string&& text)
-        {
-            m_vector.insert(m_vector.begin()+pos, string_message::create(std::move(text)));
-        }
-
-        void insert(size_t pos,std::shared_ptr<std::string> const& binary)
-        {
-            if(binary)
-                m_vector.insert(m_vector.begin()+pos, binary_message::create(binary));
-        }
-
-        void insert(size_t pos,std::shared_ptr<const std::string> const& binary)
-        {
-            if(binary)
-                m_vector.insert(m_vector.begin()+pos, binary_message::create(binary));
-        }
-
-        size_t size() const
-        {
-            return m_vector.size();
-        }
-
-        const message::ptr& at(size_t i) const
-        {
-            return m_vector[i];
-        }
-
-        const message::ptr& operator[] (size_t i) const
-        {
-            return m_vector[i];
-        }
-
-        message::ptr to_array_message(std::string const& event_name) const
-        {
-            message::ptr arr = array_message::create();
-            arr->get_vector().push_back(string_message::create(event_name));
-            arr->get_vector().insert(arr->get_vector().end(),m_vector.begin(),m_vector.end());
-            return arr;
-        }
-
-        message::ptr to_array_message() const
-        {
-            message::ptr arr = array_message::create();
-            arr->get_vector().insert(arr->get_vector().end(),m_vector.begin(),m_vector.end());
-            return arr;
-        }
-
-    private:
-        std::vector<message::ptr> m_vector;
-    };
-}
-
-#endif
diff --git a/third_party/socket.io-client-cpp/src/sio_socket.cpp b/third_party/socket.io-client-cpp/src/sio_socket.cpp
deleted file mode 100644
index f89429f..0000000
--- a/third_party/socket.io-client-cpp/src/sio_socket.cpp
+++ /dev/null
@@ -1,638 +0,0 @@
-#include "sio_socket.h"
-#include "internal/sio_packet.h"
-#include "internal/sio_client_impl.h"
-#include <asio/steady_timer.hpp>
-#include <asio/error_code.hpp>
-#include <queue>
-#include <chrono>
-#include <cstdarg>
-#include <functional>
-
-#if (DEBUG || _DEBUG) && !defined(SIO_DISABLE_LOGGING)
-#define LOG(x) std::cout << x
-#else
-#define LOG(x)
-#endif
-
-#define NULL_GUARD(_x_)  \
-    if(_x_ == NULL) return
-
-namespace sio
-{
-    class event_adapter
-    {
-    public:
-        static void adapt_func(socket::event_listener_aux  const& func, event& event)
-        {
-            func(event.get_name(),event.get_message(),event.need_ack(),event.get_ack_message_impl());
-        }
-        
-        static inline socket::event_listener do_adapt(socket::event_listener_aux const& func)
-        {
-            return std::bind(&event_adapter::adapt_func, func,std::placeholders::_1);
-        }
-        
-        static inline event create_event(std::string const& nsp,std::string const& name,message::list&& message,bool need_ack)
-        {
-            return event(nsp,name,message,need_ack);
-        }
-    };
-    
-    const std::string& event::get_nsp() const
-    {
-        return m_nsp;
-    }
-    
-    const std::string& event::get_name() const
-    {
-        return m_name;
-    }
-    
-    const message::ptr& event::get_message() const
-    {
-        if(m_messages.size()>0)
-            return m_messages[0];
-        else
-        {
-            static message::ptr null_ptr;
-            return null_ptr;
-        }
-    }
-
-    const message::list& event::get_messages() const
-    {
-        return m_messages;
-    }
-    
-    bool event::need_ack() const
-    {
-        return m_need_ack;
-    }
-    
-    void event::put_ack_message(message::list const& ack_message)
-    {
-        if(m_need_ack)
-            m_ack_message = std::move(ack_message);
-    }
-    
-    inline
-    event::event(std::string const& nsp,std::string const& name,message::list&& messages,bool need_ack):
-        m_nsp(nsp),
-        m_name(name),
-        m_messages(std::move(messages)),
-        m_need_ack(need_ack)
-    {
-    }
-
-    inline
-    event::event(std::string const& nsp,std::string const& name,message::list const& messages,bool need_ack):
-        m_nsp(nsp),
-        m_name(name),
-        m_messages(messages),
-        m_need_ack(need_ack)
-    {
-    }
-    
-    message::list const& event::get_ack_message() const
-    {
-        return m_ack_message;
-    }
-    
-    inline
-    message::list& event::get_ack_message_impl()
-    {
-        return m_ack_message;
-    }
-    
-    class socket::impl
-    {
-    public:
-        
-        impl(client_impl *, std::string const&, message::ptr const&);
-        ~impl();
-        
-        void on(std::string const& event_name,event_listener_aux const& func);
-        
-        void on(std::string const& event_name,event_listener const& func);
-        
-        void on_any(event_listener_aux const& func);
-
-        void on_any(event_listener const& func);
-
-        void off(std::string const& event_name);
-        
-        void off_all();
-        
-#define SYNTHESIS_SETTER(__TYPE__,__FIELD__) \
-    void set_##__FIELD__(__TYPE__ const& l) \
-        { m_##__FIELD__ = l;}
-        
-        SYNTHESIS_SETTER(error_listener, error_listener) //socket io errors
-        
-#undef SYNTHESIS_SETTER
-        
-        void on_error(error_listener const& l);
-        
-        void off_error();
-        
-        void close();
-        
-        void emit(std::string const& name, message::list const& msglist, std::function<void (message::list const&)> const& ack);
-        
-        std::string const& get_namespace() const {return m_nsp;}
-        
-    protected:
-        void on_connected();
-        
-        void on_close();
-        
-        void on_open();
-        
-        void on_message_packet(packet const& packet);
-        
-        void on_disconnect();
-        
-    private:
-        
-        // Message Parsing callbacks.
-        void on_socketio_event(const std::string& nsp, int msgId,const std::string& name, message::list&& message);
-        void on_socketio_ack(int msgId, message::list const& message);
-        void on_socketio_error(message::ptr const& err_message);
-        
-        event_listener get_bind_listener_locked(string const& event);
-        
-        void ack(int msgId,string const& name,message::list const& ack_message);
-        
-        void timeout_connection(const asio::error_code &ec);
-        
-        void send_connect();
-        
-        void send_packet(packet& p);
-        
-        static event_listener s_null_event_listener;
-        
-        static unsigned int s_global_event_id;
-        
-        sio::client_impl *m_client;
-        
-        bool m_connected;
-        std::string m_nsp;
-        message::ptr m_auth;
-        
-        std::map<unsigned int, std::function<void (message::list const&)> > m_acks;
-        
-        std::map<std::string, event_listener> m_event_binding;
-        
-        event_listener m_event_listener;
-
-        error_listener m_error_listener;
-        
-        std::unique_ptr<asio::steady_timer> m_connection_timer;
-        
-        std::queue<packet> m_packet_queue;
-        
-        std::mutex m_event_mutex;
-
-		std::mutex m_packet_mutex;
-        
-        friend class socket;
-    };
-    
-    void socket::impl::on(std::string const& event_name,event_listener_aux const& func)
-    {
-        this->on(event_name,event_adapter::do_adapt(func));
-    }
-    
-    void socket::impl::on(std::string const& event_name,event_listener const& func)
-    {
-        std::lock_guard<std::mutex> guard(m_event_mutex);
-        m_event_binding[event_name] = func;
-    }
-    
-    void socket::impl::on_any(event_listener_aux const& func)
-    {
-        m_event_listener = event_adapter::do_adapt(func);
-    }
-    
-    void socket::impl::on_any(event_listener const& func)
-    {
-        m_event_listener = func;
-    }
-
-    void socket::impl::off(std::string const& event_name)
-    {
-        std::lock_guard<std::mutex> guard(m_event_mutex);
-        auto it = m_event_binding.find(event_name);
-        if(it!=m_event_binding.end())
-        {
-            m_event_binding.erase(it);
-        }
-    }
-    
-    void socket::impl::off_all()
-    {
-        std::lock_guard<std::mutex> guard(m_event_mutex);
-        m_event_binding.clear();
-    }
-    
-    void socket::impl::on_error(error_listener const& l)
-    {
-        m_error_listener = l;
-    }
-    
-    void socket::impl::off_error()
-    {
-        m_error_listener = nullptr;
-    }
-    
-    socket::impl::impl(client_impl *client, std::string const& nsp, message::ptr const& auth):
-        m_client(client),
-        m_connected(false),
-        m_nsp(nsp),
-        m_auth(auth)
-    {
-        NULL_GUARD(client);
-        if(m_client->opened())
-        {
-            send_connect();
-        }
-    }
-    
-    socket::impl::~impl()
-    {
-        
-    }
-    
-    unsigned int socket::impl::s_global_event_id = 1;
-    
-    void socket::impl::emit(std::string const& name, message::list const& msglist, std::function<void (message::list const&)> const& ack)
-    {
-        NULL_GUARD(m_client);
-        message::ptr msg_ptr = msglist.to_array_message(name);
-        int pack_id;
-        if(ack)
-        {
-            pack_id = s_global_event_id++;
-            std::lock_guard<std::mutex> guard(m_event_mutex);
-            m_acks[pack_id] = ack;
-        }
-        else
-        {
-            pack_id = -1;
-        }
-        packet p(m_nsp, msg_ptr,pack_id);
-        send_packet(p);
-    }
-    
-    void socket::impl::send_connect()
-    {
-        NULL_GUARD(m_client);
-        packet p(packet::type_connect, m_nsp, m_auth);
-        m_client->send(p);
-        m_connection_timer.reset(new asio::steady_timer(m_client->get_io_service()));
-        asio::error_code ec;
-        m_connection_timer->expires_from_now(std::chrono::milliseconds(20000), ec);
-        m_connection_timer->async_wait(std::bind(&socket::impl::timeout_connection,this, std::placeholders::_1));
-    }
-    
-    void socket::impl::close()
-    {
-        NULL_GUARD(m_client);
-        if(m_connected)
-        {
-            packet p(packet::type_disconnect,m_nsp);
-            send_packet(p);
-            
-            if(!m_connection_timer)
-            {
-                m_connection_timer.reset(new asio::steady_timer(m_client->get_io_service()));
-            }
-            asio::error_code ec;
-            m_connection_timer->expires_from_now(std::chrono::milliseconds(3000), ec);
-            m_connection_timer->async_wait(std::bind(&socket::impl::on_close, this));
-        }
-    }
-    
-    void socket::impl::on_connected()
-    {
-        if(m_connection_timer)
-        {
-            m_connection_timer->cancel();
-            m_connection_timer.reset();
-        }
-        if(!m_connected)
-        {
-            m_connected = true;
-            m_client->on_socket_opened(m_nsp);
-
-            while (true) {
-				m_packet_mutex.lock();
-				if(m_packet_queue.empty())
-				{
-					m_packet_mutex.unlock();
-					return;
-				}
-				sio::packet front_pack = std::move(m_packet_queue.front());
-                m_packet_queue.pop();
-				m_packet_mutex.unlock();
-				m_client->send(front_pack);
-            }
-        }
-    }
-    
-    void socket::impl::on_close()
-    {
-        NULL_GUARD(m_client);
-        sio::client_impl *client = m_client;
-        m_client = NULL;
-
-        if(m_connection_timer)
-        {
-            m_connection_timer->cancel();
-            m_connection_timer.reset();
-        }
-        m_connected = false;
-		{
-			std::lock_guard<std::mutex> guard(m_packet_mutex);
-			while (!m_packet_queue.empty()) {
-				m_packet_queue.pop();
-			}
-		}
-        client->on_socket_closed(m_nsp);
-        client->remove_socket(m_nsp);
-    }
-    
-    void socket::impl::on_open()
-    {
-        send_connect();
-    }
-    
-    void socket::impl::on_disconnect()
-    {
-        NULL_GUARD(m_client);
-        if(m_connected)
-        {
-            m_connected = false;
-			std::lock_guard<std::mutex> guard(m_packet_mutex);
-            while (!m_packet_queue.empty()) {
-                m_packet_queue.pop();
-            }
-        }
-    }
-    
-    void socket::impl::on_message_packet(packet const& p)
-    {
-        NULL_GUARD(m_client);
-        if(p.get_nsp() == m_nsp)
-        {
-            switch (p.get_type())
-            {
-            // Connect open
-            case packet::type_connect:
-            {
-                LOG("Received Message type (Connect)"<<std::endl);
-
-                this->on_connected();
-                break;
-            }
-            case packet::type_disconnect:
-            {
-                LOG("Received Message type (Disconnect)"<<std::endl);
-                this->on_close();
-                break;
-            }
-            case packet::type_event:
-            case packet::type_binary_event:
-            {
-                LOG("Received Message type (Event)"<<std::endl);
-                const message::ptr ptr = p.get_message();
-                if(ptr->get_flag() == message::flag_array)
-                {
-                    const array_message* array_ptr = static_cast<const array_message*>(ptr.get());
-                    if(array_ptr->get_vector().size() >= 1&&array_ptr->get_vector()[0]->get_flag() == message::flag_string)
-                    {
-                        const string_message* name_ptr = static_cast<const string_message*>(array_ptr->get_vector()[0].get());
-                        message::list mlist;
-                        for(size_t i = 1;i<array_ptr->get_vector().size();++i)
-                        {
-                            mlist.push(array_ptr->get_vector()[i]);
-                        }
-                        this->on_socketio_event(p.get_nsp(), p.get_pack_id(),name_ptr->get_string(), std::move(mlist));
-                    }
-                }
-
-                break;
-            }
-                // Ack
-            case packet::type_ack:
-            case packet::type_binary_ack:
-            {
-                LOG("Received Message type (ACK)"<<std::endl);
-                const message::ptr ptr = p.get_message();
-                if(ptr->get_flag() == message::flag_array)
-                {
-					message::list msglist(ptr->get_vector());
-					this->on_socketio_ack(p.get_pack_id(),msglist);
-                }
-				else
-				{
-					this->on_socketio_ack(p.get_pack_id(),message::list(ptr));
-				}
-                break;
-            }
-                // Error
-            case packet::type_error:
-            {
-                LOG("Received Message type (ERROR)"<<std::endl);
-                this->on_socketio_error(p.get_message());
-                break;
-            }
-            default:
-                break;
-            }
-        }
-    }
-    
-    void socket::impl::on_socketio_event(const std::string& nsp,int msgId,const std::string& name, message::list && message)
-    {
-        bool needAck = msgId >= 0;
-        event ev = event_adapter::create_event(nsp,name, std::move(message),needAck);
-        event_listener func = this->get_bind_listener_locked(name);
-        if(func)func(ev);
-        if (m_event_listener) m_event_listener(ev);
-        if(needAck)
-        {
-            this->ack(msgId, name, ev.get_ack_message());
-        }
-    }
-    
-    void socket::impl::ack(int msgId, const string &, const message::list &ack_message)
-    {
-        packet p(m_nsp, ack_message.to_array_message(),msgId,true);
-        send_packet(p);
-    }
-    
-    void socket::impl::on_socketio_ack(int msgId, message::list const& message)
-    {
-        std::function<void (message::list const&)> l;
-        {
-            std::lock_guard<std::mutex> guard(m_event_mutex);
-            auto it = m_acks.find(msgId);
-            if(it!=m_acks.end())
-            {
-                l = it->second;
-                m_acks.erase(it);
-            }
-        }
-        if(l)l(message);
-    }
-    
-    void socket::impl::on_socketio_error(message::ptr const& err_message)
-    {
-        if(m_error_listener)m_error_listener(err_message);
-    }
-    
-    void socket::impl::timeout_connection(const asio::error_code &ec)
-    {
-        NULL_GUARD(m_client);
-        if(ec)
-        {
-            return;
-        }
-        m_connection_timer.reset();
-        LOG("Connection timeout,close socket."<<std::endl);
-        //Should close socket if no connected message arrive.Otherwise we'll never ask for open again.
-        this->on_close();
-    }
-    
-    void socket::impl::send_packet(sio::packet &p)
-    {
-        NULL_GUARD(m_client);
-        if(m_connected)
-        {
-            while (true) {
-				m_packet_mutex.lock();
-				if(m_packet_queue.empty())
-				{
-					m_packet_mutex.unlock();
-					break;
-				}
-				sio::packet front_pack = std::move(m_packet_queue.front());
-                m_packet_queue.pop();
-				m_packet_mutex.unlock();
-				m_client->send(front_pack);
-            }
-            m_client->send(p);
-        }
-        else
-        {
-			std::lock_guard<std::mutex> guard(m_packet_mutex);
-            m_packet_queue.push(p);
-        }
-    }
-    
-    socket::event_listener socket::impl::get_bind_listener_locked(const string &event)
-    {
-        std::lock_guard<std::mutex> guard(m_event_mutex);
-        auto it = m_event_binding.find(event);
-        if(it!=m_event_binding.end())
-        {
-            return it->second;
-        }
-        return socket::event_listener();
-    }
-    
-    socket::socket(client_impl* client,std::string const& nsp,message::ptr const& auth):
-        m_impl(new impl(client,nsp,auth))
-    {
-    }
-    
-    socket::~socket()
-    {
-        delete m_impl;
-    }
-    
-    void socket::on(std::string const& event_name,event_listener const& func)
-    {
-        m_impl->on(event_name, func);
-    }
-    
-    void socket::on(std::string const& event_name,event_listener_aux const& func)
-    {
-        m_impl->on(event_name, func);
-    }
-    
-    void socket::on_any(event_listener_aux const& func)
-    {
-        m_impl->on_any(func);
-    }
-    
-    void socket::on_any(event_listener const& func)
-    {
-        m_impl->on_any(func);
-    }
-
-    void socket::off(std::string const& event_name)
-    {
-        m_impl->off(event_name);
-    }
-    
-    void socket::off_all()
-    {
-        m_impl->off_all();
-    }
-    
-    void socket::close()
-    {
-        m_impl->close();
-    }
-    
-    void socket::on_error(error_listener const& l)
-    {
-        m_impl->on_error(l);
-    }
-    
-    void socket::off_error()
-    {
-        m_impl->off_error();
-    }
-
-    void socket::emit(std::string const& name, message::list const& msglist, std::function<void (message::list const&)> const& ack)
-    {
-        m_impl->emit(name, msglist,ack);
-    }
-    
-    std::string const& socket::get_namespace() const
-    {
-        return m_impl->get_namespace();
-    }
-    
-    void socket::on_connected()
-    {
-        m_impl->on_connected();
-    }
-    
-    void socket::on_close()
-    {
-        m_impl->on_close();
-    }
-    
-    void socket::on_open()
-    {
-        m_impl->on_open();
-    }
-    
-    void socket::on_message_packet(packet const& p)
-    {
-        m_impl->on_message_packet(p);
-    }
-    
-    void socket::on_disconnect()
-    {
-        m_impl->on_disconnect();
-    }
-}
-
-
-
-
diff --git a/third_party/socket.io-client-cpp/src/sio_socket.h b/third_party/socket.io-client-cpp/src/sio_socket.h
deleted file mode 100644
index 9e2e529..0000000
--- a/third_party/socket.io-client-cpp/src/sio_socket.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef SIO_SOCKET_H
-#define SIO_SOCKET_H
-#include "sio_message.h"
-#include <functional>
-namespace sio
-{
-    class event_adapter;
-    
-    class event
-    {
-    public:
-        const std::string& get_nsp() const;
-        
-        const std::string& get_name() const;
-        
-        const message::ptr& get_message() const;
-
-        const message::list& get_messages() const;
-        
-        bool need_ack() const;
-        
-        void put_ack_message(message::list const& ack_message);
-        
-        message::list const& get_ack_message() const;
-        
-    protected:
-        event(std::string const& nsp,std::string const& name,message::list const& messages,bool need_ack);
-        event(std::string const& nsp,std::string const& name,message::list&& messages,bool need_ack);
-
-        message::list& get_ack_message_impl();
-        
-    private:
-        const std::string m_nsp;
-        const std::string m_name;
-        const message::list m_messages;
-        const bool m_need_ack;
-        message::list m_ack_message;
-        
-        friend class event_adapter;
-    };
-    
-    class client_impl;
-    class packet;
-    
-    //The name 'socket' is taken from concept of official socket.io.
-    class socket
-    {
-    public:
-        typedef std::function<void(const std::string& name,message::ptr const& message,bool need_ack, message::list& ack_message)> event_listener_aux;
-        
-        typedef std::function<void(event& event)> event_listener;
-        
-        typedef std::function<void(message::ptr const& message)> error_listener;
-        
-        typedef std::shared_ptr<socket> ptr;
-        
-        ~socket();
-        
-        void on(std::string const& event_name,event_listener const& func);
-        
-        void on(std::string const& event_name,event_listener_aux const& func);
-        
-        void off(std::string const& event_name);
-        
-        void on_any(event_listener const& func);
-
-        void on_any(event_listener_aux const& func);
-
-        void off_all();
-        
-        void close();
-        
-        void on_error(error_listener const& l);
-        
-        void off_error();
-
-        void emit(std::string const& name, message::list const& msglist = nullptr, std::function<void (message::list const&)> const& ack = nullptr);
-        
-        std::string const& get_namespace() const;
-        
-    protected:
-        socket(client_impl*,std::string const&,message::ptr const&);
-
-        void on_connected();
-        
-        void on_close();
-        
-        void on_open();
-        
-        void on_disconnect();
-        
-        void on_message_packet(packet const& p);
-        
-        friend class client_impl;
-        
-    private:
-        //disable copy constructor and assign operator.
-        socket(socket const&){}
-        void operator=(socket const&){}
-
-        class impl;
-        impl *m_impl;
-    };
-}
-#endif // SIO_SOCKET_H
diff --git a/third_party/socket.io-client-cpp/test/CMakeLists.txt b/third_party/socket.io-client-cpp/test/CMakeLists.txt
deleted file mode 100644
index f3c6695..0000000
--- a/third_party/socket.io-client-cpp/test/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-include(FetchContent)
-
-FetchContent_Declare(
-  Catch2
-  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-  GIT_TAG        v3.3.2
-)
-FetchContent_MakeAvailable(Catch2)
-
-find_package(Threads REQUIRED)
-
-add_executable(sio_test sio_test.cpp)
-target_link_libraries(sio_test PRIVATE Catch2::Catch2WithMain sioclient Threads::Threads)
-add_test(sioclient_test sio_test)
diff --git a/third_party/socket.io-client-cpp/test/echo_server/.gitignore b/third_party/socket.io-client-cpp/test/echo_server/.gitignore
deleted file mode 100644
index 3c3629e..0000000
--- a/third_party/socket.io-client-cpp/test/echo_server/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-node_modules
diff --git a/third_party/socket.io-client-cpp/test/echo_server/index.js b/third_party/socket.io-client-cpp/test/echo_server/index.js
deleted file mode 100644
index 049066b..0000000
--- a/third_party/socket.io-client-cpp/test/echo_server/index.js
+++ /dev/null
@@ -1,37 +0,0 @@
-var port = 3000;
-
-var io = require('socket.io')().listen(port);
-console.log("Listening on port " + port);
-
-/* Socket.IO events */
-io.on("connection", function(socket){
-    console.log("new connection");
-    socket.on('test_text', (...args) => {
-        console.log("test text event received.", args);
-    });
-
-    socket.on('test_binary', (...args) => {
-        console.log("test binary event received", args);
-      if(args[0] instanceof Buffer)
-      {
-        console.log("test binary event received,binary length:"+ args[0].length);
-      }
-    });
-
-    socket.on('test ack',function()
-    {
-       var args =Array.prototype.slice.call(arguments);
-      if('object' == typeof args[0])
-      {
-        console.log("test combo received,object:");
-        console.log(JSON.stringify(args[0]));
-      }
-      if(args.length>1 && 'function' == typeof args[args.length - 1])
-      {
-        console.log('need ack for test combo');
-        var fn = args[args.length - 1];
-        fn('Got bin length:' + args[0].bin.length);//invoke ack callback function.
-      }
-    });
-
-  });
\ No newline at end of file
diff --git a/third_party/socket.io-client-cpp/test/echo_server/package-lock.json b/third_party/socket.io-client-cpp/test/echo_server/package-lock.json
deleted file mode 100644
index 15ee0cb..0000000
--- a/third_party/socket.io-client-cpp/test/echo_server/package-lock.json
+++ /dev/null
@@ -1,165 +0,0 @@
-{
-    "name": "echo_server",
-    "version": "0.0.0",
-    "lockfileVersion": 1,
-    "requires": true,
-    "dependencies": {
-        "@types/component-emitter": {
-            "version": "1.2.10",
-            "resolved": "https://registry.npmjs.org/@types/component-emitter/-/component-emitter-1.2.10.tgz",
-            "integrity": "sha512-bsjleuRKWmGqajMerkzox19aGbscQX5rmmvvXl3wlIp5gMG1HgkiwPxsN5p070fBDKTNSPgojVbuY1+HWMbFhg=="
-        },
-        "@types/cookie": {
-            "version": "0.4.0",
-            "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.4.0.tgz",
-            "integrity": "sha512-y7mImlc/rNkvCRmg8gC3/lj87S7pTUIJ6QGjwHR9WQJcFs+ZMTOaoPrkdFA/YdbuqVEmEbb5RdhVxMkAcgOnpg=="
-        },
-        "@types/cors": {
-            "version": "2.8.9",
-            "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.9.tgz",
-            "integrity": "sha512-zurD1ibz21BRlAOIKP8yhrxlqKx6L9VCwkB5kMiP6nZAhoF5MvC7qS1qPA7nRcr1GJolfkQC7/EAL4hdYejLtg=="
-        },
-        "@types/node": {
-            "version": "14.14.20",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.20.tgz",
-            "integrity": "sha512-Y93R97Ouif9JEOWPIUyU+eyIdyRqQR0I8Ez1dzku4hDx34NWh4HbtIc3WNzwB1Y9ULvNGeu5B8h8bVL5cAk4/A=="
-        },
-        "accepts": {
-            "version": "1.3.7",
-            "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
-            "integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
-            "requires": {
-                "mime-types": "~2.1.24",
-                "negotiator": "0.6.2"
-            }
-        },
-        "base64-arraybuffer": {
-            "version": "0.1.4",
-            "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.4.tgz",
-            "integrity": "sha1-mBjHngWbE1X5fgQooBfIOOkLqBI="
-        },
-        "base64id": {
-            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
-            "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog=="
-        },
-        "component-emitter": {
-            "version": "1.3.0",
-            "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz",
-            "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg=="
-        },
-        "cookie": {
-            "version": "0.4.1",
-            "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.1.tgz",
-            "integrity": "sha512-ZwrFkGJxUR3EIoXtO+yVE69Eb7KlixbaeAWfBQB9vVsNn/o+Yw69gBWSSDK825hQNdN+wF8zELf3dFNl/kxkUA=="
-        },
-        "cors": {
-            "version": "2.8.5",
-            "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
-            "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
-            "requires": {
-                "object-assign": "^4",
-                "vary": "^1"
-            }
-        },
-        "debug": {
-            "version": "4.3.1",
-            "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
-            "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
-            "requires": {
-                "ms": "2.1.2"
-            }
-        },
-        "engine.io": {
-            "version": "4.0.6",
-            "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-4.0.6.tgz",
-            "integrity": "sha512-rf7HAVZpcRrcKEKddgIzYUnwg0g5HE1RvJaTLwkcfJmce4g+po8aMuE6vxzp6JwlK8FEq/vi0KWN6tA585DjaA==",
-            "requires": {
-                "accepts": "~1.3.4",
-                "base64id": "2.0.0",
-                "cookie": "~0.4.1",
-                "cors": "~2.8.5",
-                "debug": "~4.3.1",
-                "engine.io-parser": "~4.0.0",
-                "ws": "~7.4.2"
-            }
-        },
-        "engine.io-parser": {
-            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-4.0.2.tgz",
-            "integrity": "sha512-sHfEQv6nmtJrq6TKuIz5kyEKH/qSdK56H/A+7DnAuUPWosnIZAS2NHNcPLmyjtY3cGS/MqJdZbUjW97JU72iYg==",
-            "requires": {
-                "base64-arraybuffer": "0.1.4"
-            }
-        },
-        "mime-db": {
-            "version": "1.45.0",
-            "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.45.0.tgz",
-            "integrity": "sha512-CkqLUxUk15hofLoLyljJSrukZi8mAtgd+yE5uO4tqRZsdsAJKv0O+rFMhVDRJgozy+yG6md5KwuXhD4ocIoP+w=="
-        },
-        "mime-types": {
-            "version": "2.1.28",
-            "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.28.tgz",
-            "integrity": "sha512-0TO2yJ5YHYr7M2zzT7gDU1tbwHxEUWBCLt0lscSNpcdAfFyJOVEpRYNS7EXVcTLNj/25QO8gulHC5JtTzSE2UQ==",
-            "requires": {
-                "mime-db": "1.45.0"
-            }
-        },
-        "ms": {
-            "version": "2.1.2",
-            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-            "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
-        },
-        "negotiator": {
-            "version": "0.6.2",
-            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.2.tgz",
-            "integrity": "sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw=="
-        },
-        "object-assign": {
-            "version": "4.1.1",
-            "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-            "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM="
-        },
-        "socket.io": {
-            "version": "3.0.5",
-            "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-3.0.5.tgz",
-            "integrity": "sha512-5yWQ43P/4IttmPCGKDQ3CVocBiJWGpibyhYJxgUhf69EHMzmK8XW0DkmHIoYdLmZaVZJyiEkUqpeC7rSCIqekw==",
-            "requires": {
-                "@types/cookie": "^0.4.0",
-                "@types/cors": "^2.8.8",
-                "@types/node": "^14.14.10",
-                "accepts": "~1.3.4",
-                "base64id": "~2.0.0",
-                "debug": "~4.3.1",
-                "engine.io": "~4.0.6",
-                "socket.io-adapter": "~2.0.3",
-                "socket.io-parser": "~4.0.3"
-            }
-        },
-        "socket.io-adapter": {
-            "version": "2.0.3",
-            "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.0.3.tgz",
-            "integrity": "sha512-2wo4EXgxOGSFueqvHAdnmi5JLZzWqMArjuP4nqC26AtLh5PoCPsaRbRdah2xhcwTAMooZfjYiNVNkkmmSMaxOQ=="
-        },
-        "socket.io-parser": {
-            "version": "4.0.5",
-            "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.0.5.tgz",
-            "integrity": "sha512-sNjbT9dX63nqUFIOv95tTVm6elyIU4RvB1m8dOeZt+IgWwcWklFDOdmGcfo3zSiRsnR/3pJkjY5lfoGqEe4Eig==",
-            "requires": {
-                "@types/component-emitter": "^1.2.10",
-                "component-emitter": "~1.3.0",
-                "debug": "~4.3.1"
-            }
-        },
-        "vary": {
-            "version": "1.1.2",
-            "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-            "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw="
-        },
-        "ws": {
-            "version": "7.4.6",
-            "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz",
-            "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A=="
-        }
-    }
-}
diff --git a/third_party/socket.io-client-cpp/test/echo_server/package.json b/third_party/socket.io-client-cpp/test/echo_server/package.json
deleted file mode 100644
index b980f3c..0000000
--- a/third_party/socket.io-client-cpp/test/echo_server/package.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-    "name": "echo_server",
-    "author": "Melo Yao",
-    "version": "0.0.0",
-    "dependencies": {
-        "socket.io": "^3.0.5"
-    }
-}
diff --git a/third_party/socket.io-client-cpp/test/json.hpp b/third_party/socket.io-client-cpp/test/json.hpp
deleted file mode 100644
index 89fd9a4..0000000
--- a/third_party/socket.io-client-cpp/test/json.hpp
+++ /dev/null
@@ -1,4955 +0,0 @@
-/*!
-@file
-@copyright The code is licensed under the MIT License
-           <http://opensource.org/licenses/MIT>,
-           Copyright (c) 2013-2015 Niels Lohmann.
-@author Niels Lohmann <http://nlohmann.me>
-@see https://github.com/nlohmann/json
-*/
-
-#ifndef _NLOHMANN_JSON
-#define _NLOHMANN_JSON
-
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <functional>
-#include <initializer_list>
-#include <iomanip>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <map>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-*/
-namespace nlohmann
-{
-
-
-// Helper to determine whether there's a key_type for T.
-// http://stackoverflow.com/a/7728728/266378
-template<typename T>
-struct has_mapped_type
-{
-  private:
-    template<typename C> static char test(typename C::mapped_type*);
-    template<typename C> static int  test(...);
-  public:
-    enum { value = sizeof(test<T>(0)) == sizeof(char) };
-};
-
-/*!
-@brief JSON
-
-@tparam ObjectType         type for JSON objects
-                           (@c std::map by default)
-@tparam ArrayType          type for JSON arrays
-                           (@c std::vector by default)
-@tparam StringType         type for JSON strings and object keys
-                           (@c std::string by default)
-@tparam BooleanType        type for JSON booleans
-                           (@c bool by default)
-@tparam NumberIntegerType  type for JSON integer numbers
-                           (@c int64_t by default)
-@tparam NumberFloatType    type for JSON floating-point numbers
-                           (@c double by default)
-@tparam AllocatorType      type of the allocator to use
-                           (@c std::allocator by default)
-
-@note ObjectType trick from http://stackoverflow.com/a/9860911
-
-@see RFC 7159 <http://rfc7159.net/rfc7159>
-@see ECMA 404 <http://www.ecma-international.org/publications/standards/Ecma-404.htm>
-*/
-template <
-    template<typename U, typename V, typename... Args> class ObjectType = std::map,
-    template<typename U, typename... Args> class ArrayType = std::vector,
-    class StringType = std::string,
-    class BooleanType = bool,
-    class NumberIntegerType = int64_t,
-    class NumberFloatType = double,
-    template<typename U> class AllocatorType = std::allocator
-    >
-class basic_json
-{
-  public:
-    /////////////////////
-    // container types //
-    /////////////////////
-
-    // forward declarations
-    class iterator;
-    class const_iterator;
-    class reverse_iterator;
-    class const_reverse_iterator;
-
-    /*!
-    @brief the type of elements in a basic_json container
-    @ingroup container
-    */
-    using value_type = basic_json;
-
-    /*!
-    @brief the type of an element reference
-    @ingroup container
-    */
-    using reference = value_type&;
-
-    /*!
-    @brief the type of an element const reference
-    @ingroup container
-    */
-    using const_reference = const value_type&;
-
-    /*!
-    @brief a type to represent differences between iterators
-    @ingroup container
-    */
-    using difference_type = std::ptrdiff_t;
-
-    /*!
-    @brief a type to represent container sizes
-    @ingroup container
-    */
-    using size_type = std::size_t;
-
-    /// the allocator type
-    using allocator_type = AllocatorType<basic_json>;
-
-    /// the type of an element pointer
-    using pointer = typename std::allocator_traits<allocator_type>::pointer;
-    /// the type of an element const pointer
-    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
-
-    /*!
-    @brief an iterator for a basic_json container
-    @ingroup container
-    */
-    using iterator = basic_json::iterator;
-
-    /*!
-    @brief a const iterator for a basic_json container
-    @ingroup container
-    */
-    using const_iterator = basic_json::const_iterator;
-
-    /*!
-    @brief a reverse iterator for a basic_json container
-    @ingroup reversiblecontainer
-    */
-    using reverse_iterator = basic_json::reverse_iterator;
-
-    /*!
-    @brief a const reverse iterator for a basic_json container
-    @ingroup reversiblecontainer
-    */
-    using const_reverse_iterator = basic_json::const_reverse_iterator;
-
-
-    /// returns the allocator associated with the container
-    inline static allocator_type get_allocator()
-    {
-        return allocator_type();
-    }
-
-
-    ///////////////////////////
-    // JSON value data types //
-    ///////////////////////////
-
-    /// a type for an object
-    using object_t = ObjectType<StringType, basic_json>;
-    /// a type for an array
-    using array_t = ArrayType<basic_json>;
-    /// a type for a string
-    using string_t = StringType;
-    /// a type for a boolean
-    using boolean_t = BooleanType;
-    /// a type for a number (integer)
-    using number_integer_t = NumberIntegerType;
-    /// a type for a number (floating-point)
-    using number_float_t = NumberFloatType;
-    /// a type for list initialization
-    using list_init_t = std::initializer_list<basic_json>;
-
-
-    ////////////////////////
-    // JSON value storage //
-    ////////////////////////
-
-    /// a JSON value
-    union json_value
-    {
-        /// object (stored with pointer to save storage)
-        object_t* object;
-        /// array (stored with pointer to save storage)
-        array_t* array;
-        /// string (stored with pointer to save storage)
-        string_t* string;
-        /// bolean
-        boolean_t boolean;
-        /// number (integer)
-        number_integer_t number_integer;
-        /// number (floating-point)
-        number_float_t number_float;
-
-        /// default constructor (for null values)
-        json_value() = default;
-        /// constructor for booleans
-        json_value(boolean_t v) : boolean(v) {}
-        /// constructor for numbers (integer)
-        json_value(number_integer_t v) : number_integer(v) {}
-        /// constructor for numbers (floating-point)
-        json_value(number_float_t v) : number_float(v) {}
-    };
-
-
-    /////////////////////////////////
-    // JSON value type enumeration //
-    /////////////////////////////////
-
-    /// JSON value type enumeration
-    enum class value_t : uint8_t
-    {
-        null,           ///< null value
-        object,         ///< object (unordered set of name/value pairs)
-        array,          ///< array (ordered collection of values)
-        string,         ///< string value
-        boolean,        ///< boolean value
-        number_integer, ///< number value (integer)
-        number_float    ///< number value (floating-point)
-    };
-
-    /*!
-    @brief comparison operator for JSON value types
-
-    Returns an ordering that is similar to Python:
-    - order: null < boolean < number < object < array < string
-    - furthermore, each type is not smaller than itself
-    */
-    friend bool operator<(const value_t lhs, const value_t rhs)
-    {
-        // no type is smaller than itself
-        if (lhs == rhs)
-        {
-            return false;
-        }
-
-        switch (lhs)
-        {
-            case (value_t::null):
-            {
-                // nulls are smaller than all other types
-                return true;
-            }
-
-            case (value_t::boolean):
-            {
-                // only nulls are smaller than booleans
-                return (rhs != value_t::null);
-            }
-
-            case (value_t::number_float):
-            case (value_t::number_integer):
-            {
-                switch (rhs)
-                {
-                    // numbers are smaller than objects, arrays, and string
-                    case (value_t::object):
-                    case (value_t::array):
-                    case (value_t::string):
-                    {
-                        return true;
-                    }
-
-                    default:
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            case (value_t::object):
-            {
-                switch (rhs)
-                {
-                    // objects are smaller than arrays and string
-                    case (value_t::array):
-                    case (value_t::string):
-                    {
-                        return true;
-                    }
-
-                    default:
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            case (value_t::array):
-            {
-                // arrays are smaller than strings
-                return (rhs == value_t::string);
-            }
-
-            default:
-            {
-                // a string is not smaller than any other types
-                return false;
-            }
-        }
-    }
-
-
-    //////////////////
-    // constructors //
-    //////////////////
-
-    /*!
-    @brief create an empty value with a given type
-    @param value  the type to create an value of
-
-    @exception std::bad_alloc  if allocation for object, array, or string fails.
-    */
-    inline basic_json(const value_t value)
-        : m_type(value)
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                break;
-            }
-
-            case (value_t::object):
-            {
-                AllocatorType<object_t> alloc;
-                m_value.object = alloc.allocate(1);
-                alloc.construct(m_value.object);
-                break;
-            }
-
-            case (value_t::array):
-            {
-                AllocatorType<array_t> alloc;
-                m_value.array = alloc.allocate(1);
-                alloc.construct(m_value.array);
-                break;
-            }
-
-            case (value_t::string):
-            {
-                AllocatorType<string_t> alloc;
-                m_value.string = alloc.allocate(1);
-                alloc.construct(m_value.string, "");
-                break;
-            }
-
-            case (value_t::boolean):
-            {
-                m_value.boolean = boolean_t(false);
-                break;
-            }
-
-            case (value_t::number_integer):
-            {
-                m_value.number_integer = number_integer_t(0);
-                break;
-            }
-
-            case (value_t::number_float):
-            {
-                m_value.number_float = number_float_t(0.0);
-                break;
-            }
-        }
-    }
-
-    /*!
-    @brief create a null object (implicitly)
-    @ingroup container
-    */
-    inline basic_json() noexcept = default;
-
-    /// create a null object (explicitly)
-    inline basic_json(std::nullptr_t) noexcept
-        : m_type(value_t::null)
-    {}
-
-    /// create an object (explicit)
-    inline basic_json(const object_t& value)
-        : m_type(value_t::object)
-    {
-        AllocatorType<object_t> alloc;
-        m_value.object = alloc.allocate(1);
-        alloc.construct(m_value.object, value);
-    }
-
-    /// create an object (implicit)
-    template <class V, typename
-              std::enable_if<
-                  std::is_constructible<typename object_t::key_type, typename V::key_type>::value and
-                  std::is_constructible<basic_json, typename V::mapped_type>::value, int>::type
-              = 0>
-    inline basic_json(const V& value)
-        : m_type(value_t::object)
-    {
-        AllocatorType<object_t> alloc;
-        m_value.object = alloc.allocate(1);
-        using std::begin;
-        using std::end;
-        alloc.construct(m_value.object, begin(value), end(value));
-    }
-
-    /// create an array (explicit)
-    inline basic_json(const array_t& value)
-        : m_type(value_t::array)
-    {
-        AllocatorType<array_t> alloc;
-        m_value.array = alloc.allocate(1);
-        alloc.construct(m_value.array, value);
-    }
-
-    /// create an array (implicit)
-    template <class V, typename
-              std::enable_if<
-                  not std::is_same<V, basic_json::iterator>::value and
-                  not std::is_same<V, basic_json::const_iterator>::value and
-                  not std::is_same<V, basic_json::reverse_iterator>::value and
-                  not std::is_same<V, basic_json::const_reverse_iterator>::value and
-                  not std::is_same<V, typename array_t::iterator>::value and
-                  not std::is_same<V, typename array_t::const_iterator>::value and
-                  std::is_constructible<basic_json, typename V::value_type>::value, int>::type
-              = 0>
-    inline basic_json(const V& value)
-        : m_type(value_t::array)
-    {
-        AllocatorType<array_t> alloc;
-        m_value.array = alloc.allocate(1);
-        using std::begin;
-        using std::end;
-        alloc.construct(m_value.array, begin(value), end(value));
-    }
-
-    /// create a string (explicit)
-    inline basic_json(const string_t& value)
-        : m_type(value_t::string)
-    {
-        AllocatorType<string_t> alloc;
-        m_value.string = alloc.allocate(1);
-        alloc.construct(m_value.string, value);
-    }
-
-    /// create a string (explicit)
-    inline basic_json(const typename string_t::value_type* value)
-        : m_type(value_t::string)
-    {
-        AllocatorType<string_t> alloc;
-        m_value.string = alloc.allocate(1);
-        alloc.construct(m_value.string, value);
-    }
-
-    /// create a string (implicit)
-    template <class V, typename
-              std::enable_if<
-                  std::is_constructible<string_t, V>::value, int>::type
-              = 0>
-    inline basic_json(const V& value)
-        : basic_json(string_t(value))
-    {}
-
-    /// create a boolean (explicit)
-    inline basic_json(boolean_t value)
-        : m_type(value_t::boolean), m_value(value)
-    {}
-
-    /// create an integer number (explicit)
-    inline basic_json(const number_integer_t& value)
-        : m_type(value_t::number_integer), m_value(value)
-    {}
-
-    /// create an integer number (implicit)
-    template<typename T, typename
-             std::enable_if<
-                 std::is_constructible<number_integer_t, T>::value and
-                 std::numeric_limits<T>::is_integer, T>::type
-             = 0>
-    inline basic_json(const T value) noexcept
-        : m_type(value_t::number_integer), m_value(number_integer_t(value))
-    {}
-
-    /// create a floating-point number (explicit)
-    inline basic_json(const number_float_t& value)
-        : m_type(value_t::number_float), m_value(value)
-    {}
-
-    /// create a floating-point number (implicit)
-    template<typename T, typename = typename
-             std::enable_if<
-                 std::is_constructible<number_float_t, T>::value and
-                 std::is_floating_point<T>::value>::type
-             >
-    inline basic_json(const T value) noexcept
-        : m_type(value_t::number_float), m_value(number_float_t(value))
-    {}
-
-    /// create a container (array or object) from an initializer list
-    inline basic_json(list_init_t l, bool type_deduction = true, value_t manual_type = value_t::array)
-    {
-        // the initializer list could describe an object
-        bool is_object = true;
-
-        // check if each element is an array with two elements whose first element
-        // is a string
-        for (const auto& element : l)
-        {
-            if ((element.m_final and element.m_type == value_t::array)
-                    or (element.m_type != value_t::array or element.size() != 2
-                        or element[0].m_type != value_t::string))
-            {
-                // we found an element that makes it impossible to use the
-                // initializer list as object
-                is_object = false;
-                break;
-            }
-        }
-
-        // adjust type if type deduction is not wanted
-        if (not type_deduction)
-        {
-            // mark this object's type as final
-            m_final = true;
-
-            // if array is wanted, do not create an object though possible
-            if (manual_type == value_t::array)
-            {
-                is_object = false;
-            }
-
-            // if object is wanted but impossible, throw an exception
-            if (manual_type == value_t::object and not is_object)
-            {
-                throw std::logic_error("cannot create JSON object from initializer list");
-            }
-        }
-
-        if (is_object)
-        {
-            // the initializer list is a list of pairs -> create object
-            m_type = value_t::object;
-            AllocatorType<object_t> alloc;
-            m_value.object = alloc.allocate(1);
-            alloc.construct(m_value.object);
-
-            for (auto& element : l)
-            {
-                m_value.object->emplace(std::move(*(element[0].m_value.string)), std::move(element[1]));
-            }
-        }
-        else
-        {
-            // the initializer list describes an array -> create array
-            m_type = value_t::array;
-            AllocatorType<array_t> alloc;
-            m_value.array = alloc.allocate(1);
-            alloc.construct(m_value.array, std::move(l));
-        }
-    }
-
-    /// explicitly create an array from an initializer list
-    inline static basic_json array(list_init_t l = list_init_t())
-    {
-        return basic_json(l, false, value_t::array);
-    }
-
-    /// explicitly create an object from an initializer list
-    inline static basic_json object(list_init_t l = list_init_t())
-    {
-        return basic_json(l, false, value_t::object);
-    }
-
-    /// construct an array with count copies of given value
-    inline basic_json(size_type count, const basic_json& other)
-        : m_type(value_t::array)
-    {
-        AllocatorType<array_t> alloc;
-        m_value.array = alloc.allocate(1);
-        alloc.construct(m_value.array, count, other);
-    }
-
-    /// construct a JSON container given an iterator range
-    template <class T, typename
-              std::enable_if<
-                  std::is_same<T, basic_json::iterator>::value or
-                  std::is_same<T, basic_json::const_iterator>::value
-                  , int>::type
-              = 0>
-    inline basic_json(T first, T last)
-    {
-        // make sure iterator fits the current value
-        if (first.m_object != last.m_object or
-                first.m_object->m_type != last.m_object->m_type)
-        {
-            throw std::runtime_error("iterators are not compatible");
-        }
-
-        // set the type
-        m_type = first.m_object->m_type;
-
-        // check if iterator range is complete for non-compound values
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            case value_t::number_float:
-            case value_t::boolean:
-            case value_t::string:
-            {
-                if (first.m_it.generic_iterator != 0 or last.m_it.generic_iterator != 1)
-                {
-                    throw std::out_of_range("iterators out of range");
-                }
-                break;
-            }
-
-            default:
-            {
-                break;
-            }
-        }
-
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            {
-                m_value.number_integer = first.m_object->m_value.number_integer;
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                m_value.number_float = first.m_object->m_value.number_float;
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                m_value.boolean = first.m_object->m_value.boolean;
-                break;
-            }
-
-            case value_t::string:
-            {
-                AllocatorType<string_t> alloc;
-                m_value.string = alloc.allocate(1);
-                alloc.construct(m_value.string, *first.m_object->m_value.string);
-                break;
-            }
-
-            case value_t::object:
-            {
-                AllocatorType<object_t> alloc;
-                m_value.object = alloc.allocate(1);
-                alloc.construct(m_value.object, first.m_it.object_iterator, last.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                AllocatorType<array_t> alloc;
-                m_value.array = alloc.allocate(1);
-                alloc.construct(m_value.array, first.m_it.array_iterator, last.m_it.array_iterator);
-                break;
-            }
-
-            default:
-            {
-                throw std::runtime_error("cannot use construct with iterators from " + first.m_object->type_name());
-            }
-        }
-    }
-
-    ///////////////////////////////////////
-    // other constructors and destructor //
-    ///////////////////////////////////////
-
-    /*!
-    @brief copy constructor
-
-    @exception std::bad_alloc  if allocation for object, array, or string fails.
-
-    @ingroup container
-    */
-    inline basic_json(const basic_json& other)
-        : m_type(other.m_type)
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                break;
-            }
-
-            case (value_t::object):
-            {
-                AllocatorType<object_t> alloc;
-                m_value.object = alloc.allocate(1);
-                alloc.construct(m_value.object, *other.m_value.object);
-                break;
-            }
-
-            case (value_t::array):
-            {
-                AllocatorType<array_t> alloc;
-                m_value.array = alloc.allocate(1);
-                alloc.construct(m_value.array, *other.m_value.array);
-                break;
-            }
-
-            case (value_t::string):
-            {
-                AllocatorType<string_t> alloc;
-                m_value.string = alloc.allocate(1);
-                alloc.construct(m_value.string, *other.m_value.string);
-                break;
-            }
-
-            case (value_t::boolean):
-            {
-                m_value.boolean = other.m_value.boolean;
-                break;
-            }
-
-            case (value_t::number_integer):
-            {
-                m_value.number_integer = other.m_value.number_integer;
-                break;
-            }
-
-            case (value_t::number_float):
-            {
-                m_value.number_float = other.m_value.number_float;
-                break;
-            }
-        }
-    }
-
-    /// move constructor
-    inline basic_json(basic_json&& other) noexcept
-        : m_type(std::move(other.m_type)),
-          m_value(std::move(other.m_value))
-    {
-        // invalidate payload
-        other.m_type = value_t::null;
-        other.m_value = {};
-    }
-
-    /*!
-    @brief copy assignment
-    @ingroup container
-    */
-    inline reference& operator=(basic_json other) noexcept (
-        std::is_nothrow_move_constructible<value_t>::value and
-        std::is_nothrow_move_assignable<value_t>::value and
-        std::is_nothrow_move_constructible<json_value>::value and
-        std::is_nothrow_move_assignable<json_value>::value
-    )
-    {
-        std::swap(m_type, other.m_type);
-        std::swap(m_value, other.m_value);
-        return *this;
-    }
-
-    /*!
-    @brief destructor
-    @ingroup container
-    */
-    inline ~basic_json() noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::object):
-            {
-                AllocatorType<object_t> alloc;
-                alloc.destroy(m_value.object);
-                alloc.deallocate(m_value.object, 1);
-                m_value.object = nullptr;
-                break;
-            }
-
-            case (value_t::array):
-            {
-                AllocatorType<array_t> alloc;
-                alloc.destroy(m_value.array);
-                alloc.deallocate(m_value.array, 1);
-                m_value.array = nullptr;
-                break;
-            }
-
-            case (value_t::string):
-            {
-                AllocatorType<string_t> alloc;
-                alloc.destroy(m_value.string);
-                alloc.deallocate(m_value.string, 1);
-                m_value.string = nullptr;
-                break;
-            }
-
-            default:
-            {
-                // all other types need no specific destructor
-                break;
-            }
-        }
-    }
-
-
-  public:
-    ///////////////////////
-    // object inspection //
-    ///////////////////////
-
-    /*!
-    @brief serialization
-
-    Serialization function for JSON objects. The function tries to mimick
-    Python's @p json.dumps() function, and currently supports its @p indent
-    parameter.
-
-    @param indent  sif indent is nonnegative, then array elements and object
-    members will be pretty-printed with that indent level. An indent level of 0
-    will only insert newlines. -1 (the default) selects the most compact
-    representation
-
-    @see https://docs.python.org/2/library/json.html#json.dump
-    */
-    inline string_t dump(const int indent = -1) const noexcept
-    {
-        if (indent >= 0)
-        {
-            return dump(true, static_cast<unsigned int>(indent));
-        }
-        else
-        {
-            return dump(false, 0);
-        }
-    }
-
-    /// return the type of the object (explicit)
-    inline value_t type() const noexcept
-    {
-        return m_type;
-    }
-
-    // return whether value is null
-    inline bool is_null() const noexcept
-    {
-        return m_type == value_t::null;
-    }
-
-    // return whether value is boolean
-    inline bool is_boolean() const noexcept
-    {
-        return m_type == value_t::boolean;
-    }
-
-    // return whether value is number
-    inline bool is_number() const noexcept
-    {
-        return (m_type == value_t::number_integer) or (m_type == value_t::number_float);
-    }
-
-    // return whether value is object
-    inline bool is_object() const noexcept
-    {
-        return m_type == value_t::object;
-    }
-
-    // return whether value is array
-    inline bool is_array() const noexcept
-    {
-        return m_type == value_t::array;
-    }
-
-    // return whether value is string
-    inline bool is_string() const noexcept
-    {
-        return m_type == value_t::string;
-    }
-
-    /// return the type of the object (implicit)
-    inline operator value_t() const noexcept
-    {
-        return m_type;
-    }
-
-  private:
-    //////////////////////
-    // value conversion //
-    //////////////////////
-
-    /// get an object (explicit)
-    template <class T, typename
-              std::enable_if<
-                  std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
-                  std::is_convertible<basic_json, typename T::mapped_type>::value
-                  , int>::type = 0>
-    inline T get_impl(T*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::object):
-            {
-                return T(m_value.object->begin(), m_value.object->end());
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    /// get an object (explicit)
-    inline object_t get_impl(object_t*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::object):
-            {
-                return *(m_value.object);
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to object");
-            }
-        }
-    }
-
-    /// get an array (explicit)
-    template <class T, typename
-              std::enable_if<
-                  std::is_convertible<basic_json, typename T::value_type>::value and
-                  not std::is_same<basic_json, typename T::value_type>::value and
-                  not std::is_arithmetic<T>::value and
-                  not std::is_convertible<std::string, T>::value and
-                  not has_mapped_type<T>::value
-                  , int>::type = 0>
-    inline T get_impl(T*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::array):
-            {
-                T to_vector;
-                std::transform(m_value.array->begin(), m_value.array->end(),
-                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
-                {
-                    return i.get<typename T::value_type>();
-                });
-                return to_vector;
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    /// get an array (explicit)
-    template <class T, typename
-              std::enable_if<
-                  std::is_convertible<basic_json, T>::value and
-                  not std::is_same<basic_json, T>::value
-                  , int>::type = 0>
-    inline std::vector<T> get_impl(std::vector<T>*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::array):
-            {
-                std::vector<T> to_vector;
-                to_vector.reserve(m_value.array->size());
-                std::transform(m_value.array->begin(), m_value.array->end(),
-                               std::inserter(to_vector, to_vector.end()), [](basic_json i)
-                {
-                    return i.get<T>();
-                });
-                return to_vector;
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    /// get an array (explicit)
-    template <class T, typename
-              std::enable_if<
-                  std::is_same<basic_json, typename T::value_type>::value and
-                  not has_mapped_type<T>::value
-                  , int>::type = 0>
-    inline T get_impl(T*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::array):
-            {
-                return T(m_value.array->begin(), m_value.array->end());
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    inline array_t get_impl(array_t*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::array):
-            {
-                return *(m_value.array);
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to array");
-            }
-        }
-    }
-
-    /// get a string (explicit)
-    template <typename T, typename
-              std::enable_if<
-                  std::is_convertible<string_t, T>::value
-                  , int>::type = 0>
-    inline T get_impl(T*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::string):
-            {
-                return *m_value.string;
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    /// get a number (explicit)
-    template<typename T, typename
-             std::enable_if<
-                 std::is_arithmetic<T>::value
-                 , int>::type = 0>
-    inline T get_impl(T*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::number_integer):
-            {
-                return static_cast<T>(m_value.number_integer);
-            }
-            case (value_t::number_float):
-            {
-                return static_cast<T>(m_value.number_float);
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(T).name());
-            }
-        }
-    }
-
-    /// get a boolean (explicit)
-    inline boolean_t get_impl(boolean_t*) const
-    {
-        switch (m_type)
-        {
-            case (value_t::boolean):
-            {
-                return m_value.boolean;
-            }
-            default:
-            {
-                throw std::logic_error("cannot cast " + type_name() + " to " + typeid(boolean_t).name());
-            }
-        }
-    }
-
-  public:
-    /// get a value (explicit)
-    // <http://stackoverflow.com/a/8315197/266378>
-    template<typename T>
-    inline T get() const
-    {
-        return get_impl(static_cast<T*>(nullptr));
-    }
-
-    /// get a value (implicit)
-    template<typename T>
-    inline operator T() const
-    {
-        return get<T>();
-    }
-
-
-    ////////////////////
-    // element access //
-    ////////////////////
-
-    /// access specified element with bounds checking
-    inline reference at(size_type idx)
-    {
-        // at only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use at with " + type_name());
-        }
-
-        return m_value.array->at(idx);
-    }
-
-    /// access specified element with bounds checking
-    inline const_reference at(size_type idx) const
-    {
-        // at only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use at with " + type_name());
-        }
-
-        return m_value.array->at(idx);
-    }
-
-    /// access specified element with bounds checking
-    inline reference at(const typename object_t::key_type& key)
-    {
-        // at only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use at with " + type_name());
-        }
-
-        return m_value.object->at(key);
-    }
-
-    /// access specified element with bounds checking
-    inline const_reference at(const typename object_t::key_type& key) const
-    {
-        // at only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use at with " + type_name());
-        }
-
-        return m_value.object->at(key);
-    }
-
-    /// access specified element
-    inline reference operator[](size_type idx)
-    {
-        // implicitly convert null to object
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::array;
-            AllocatorType<array_t> alloc;
-            m_value.array = alloc.allocate(1);
-            alloc.construct(m_value.array);
-        }
-
-        // [] only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        for (size_t i = m_value.array->size(); i <= idx; ++i)
-        {
-            m_value.array->push_back(basic_json());
-        }
-
-        return m_value.array->operator[](idx);
-    }
-
-    /// access specified element
-    inline const_reference operator[](size_type idx) const
-    {
-        // at only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        return m_value.array->operator[](idx);
-    }
-
-    /// access specified element
-    inline reference operator[](const typename object_t::key_type& key)
-    {
-        // implicitly convert null to object
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::object;
-            AllocatorType<object_t> alloc;
-            m_value.object = alloc.allocate(1);
-            alloc.construct(m_value.object);
-        }
-
-        // [] only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        return m_value.object->operator[](key);
-    }
-
-    /// access specified element
-    inline const_reference operator[](const typename object_t::key_type& key) const
-    {
-        // at only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        return m_value.object->operator[](key);
-    }
-
-    /// access specified element (needed for clang)
-    template<typename T, std::size_t n>
-    inline reference operator[](const T (&key)[n])
-    {
-        // implicitly convert null to object
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::object;
-            AllocatorType<object_t> alloc;
-            m_value.object = alloc.allocate(1);
-            alloc.construct(m_value.object);
-        }
-
-        // at only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        return m_value.object->operator[](key);
-    }
-
-    /// access specified element (needed for clang)
-    template<typename T, std::size_t n>
-    inline const_reference operator[](const T (&key)[n]) const
-    {
-        // at only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use [] with " + type_name());
-        }
-
-        return m_value.object->operator[](key);
-    }
-
-    /// access the first element
-    inline reference front()
-    {
-        return *begin();
-    }
-
-    /// access the first element
-    inline const_reference front() const
-    {
-        return *cbegin();
-    }
-
-    /// access the last element
-    inline reference back()
-    {
-        auto tmp = end();
-        --tmp;
-        return *tmp;
-    }
-
-    /// access the last element
-    inline const_reference back() const
-    {
-        auto tmp = cend();
-        --tmp;
-        return *tmp;
-    }
-
-    /// remove element given an iterator
-    template <class T, typename
-              std::enable_if<
-                  std::is_same<T, basic_json::iterator>::value or
-                  std::is_same<T, basic_json::const_iterator>::value
-                  , int>::type
-              = 0>
-    inline T erase(T pos)
-    {
-        // make sure iterator fits the current value
-        if (this != pos.m_object or m_type != pos.m_object->m_type)
-        {
-            throw std::runtime_error("iterator does not fit current value");
-        }
-
-        T result = end();
-
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            case value_t::number_float:
-            case value_t::boolean:
-            case value_t::string:
-            {
-                if (pos.m_it.generic_iterator != 0)
-                {
-                    throw std::out_of_range("iterator out of range");
-                }
-
-                if (m_type == value_t::string)
-                {
-                    delete m_value.string;
-                    m_value.string = nullptr;
-                }
-
-                m_type = value_t::null;
-                break;
-            }
-
-            case value_t::object:
-            {
-                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
-                break;
-            }
-
-            default:
-            {
-                throw std::runtime_error("cannot use erase with " + type_name());
-            }
-        }
-
-        return result;
-    }
-
-    /// remove elements given an iterator range
-    template <class T, typename
-              std::enable_if<
-                  std::is_same<T, basic_json::iterator>::value or
-                  std::is_same<T, basic_json::const_iterator>::value
-                  , int>::type
-              = 0>
-    inline T erase(T first, T last)
-    {
-        // make sure iterator fits the current value
-        if (this != first.m_object or this != last.m_object or
-                m_type != first.m_object->m_type or m_type != last.m_object->m_type)
-        {
-            throw std::runtime_error("iterators do not fit current value");
-        }
-
-        T result = end();
-
-        switch (m_type)
-        {
-            case value_t::number_integer:
-            case value_t::number_float:
-            case value_t::boolean:
-            case value_t::string:
-            {
-                if (first.m_it.generic_iterator != 0 or last.m_it.generic_iterator != 1)
-                {
-                    throw std::out_of_range("iterators out of range");
-                }
-
-                if (m_type == value_t::string)
-                {
-                    delete m_value.string;
-                    m_value.string = nullptr;
-                }
-
-                m_type = value_t::null;
-                break;
-            }
-
-            case value_t::object:
-            {
-                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
-                                              last.m_it.object_iterator);
-                break;
-            }
-
-            case value_t::array:
-            {
-                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
-                                             last.m_it.array_iterator);
-                break;
-            }
-
-            default:
-            {
-                throw std::runtime_error("cannot use erase with " + type_name());
-            }
-        }
-
-        return result;
-    }
-
-    /// remove element from an object given a key
-    inline size_type erase(const typename object_t::key_type& key)
-    {
-        // this erase only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use erase with " + type_name());
-        }
-
-        return m_value.object->erase(key);
-    }
-
-    /// remove element from an array given an index
-    inline void erase(const size_type idx)
-    {
-        // this erase only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use erase with " + type_name());
-        }
-
-        if (idx >= size())
-        {
-            throw std::out_of_range("index out of range");
-        }
-
-        m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
-    }
-
-    /// find an element in an object
-    inline iterator find(typename object_t::key_type key)
-    {
-        auto result = end();
-
-        if (m_type == value_t::object)
-        {
-            result.m_it.object_iterator = m_value.object->find(key);
-        }
-
-        return result;
-    }
-
-    /// find an element in an object
-    inline const_iterator find(typename object_t::key_type key) const
-    {
-        auto result = cend();
-
-        if (m_type == value_t::object)
-        {
-            result.m_it.object_iterator = m_value.object->find(key);
-        }
-
-        return result;
-    }
-
-    /// returns the number of occurrences of a key in an object
-    inline size_type count(typename object_t::key_type key) const
-    {
-        // return 0 for all nonobject types
-        return (m_type == value_t::object) ? m_value.object->count(key) : 0;
-    }
-
-
-    ///////////////
-    // iterators //
-    ///////////////
-
-    /*!
-    @brief returns an iterator to the first element
-    @ingroup container
-    */
-    inline iterator begin() noexcept
-    {
-        iterator result(this);
-        result.set_begin();
-        return result;
-    }
-
-    /*!
-    @brief returns a const iterator to the first element
-    @ingroup container
-    */
-    inline const_iterator begin() const noexcept
-    {
-        return cbegin();
-    }
-
-    /*!
-    @brief returns a const iterator to the first element
-    @ingroup container
-    */
-    inline const_iterator cbegin() const noexcept
-    {
-        const_iterator result(this);
-        result.set_begin();
-        return result;
-    }
-
-    /*!
-    @brief returns an iterator to one past the last element
-    @ingroup container
-    */
-    inline iterator end() noexcept
-    {
-        iterator result(this);
-        result.set_end();
-        return result;
-    }
-
-    /*!
-    @brief returns a const iterator to one past the last element
-    @ingroup container
-    */
-    inline const_iterator end() const noexcept
-    {
-        return cend();
-    }
-
-    /*!
-    @brief returns a const iterator to one past the last element
-    @ingroup container
-    */
-    inline const_iterator cend() const noexcept
-    {
-        const_iterator result(this);
-        result.set_end();
-        return result;
-    }
-
-    /*!
-    @brief returns a reverse iterator to the first element
-    @ingroup reversiblecontainer
-    */
-    inline reverse_iterator rbegin() noexcept
-    {
-        return reverse_iterator(end());
-    }
-
-    /*!
-    @brief returns a const reverse iterator to the first element
-    @ingroup reversiblecontainer
-    */
-    inline const_reverse_iterator rbegin() const noexcept
-    {
-        return crbegin();
-    }
-
-    /*!
-    @brief returns a reverse iterator to one past the last element
-    @ingroup reversiblecontainer
-    */
-    inline reverse_iterator rend() noexcept
-    {
-        return reverse_iterator(begin());
-    }
-
-    /*!
-    @brief returns a const reverse iterator to one past the last element
-    @ingroup reversiblecontainer
-    */
-    inline const_reverse_iterator rend() const noexcept
-    {
-        return crend();
-    }
-
-    /*!
-    @brief returns a const reverse iterator to the first element
-    @ingroup reversiblecontainer
-    */
-    inline const_reverse_iterator crbegin() const noexcept
-    {
-        return const_reverse_iterator(cend());
-    }
-
-    /*!
-    @brief returns a const reverse iterator to one past the last element
-    @ingroup reversiblecontainer
-    */
-    inline const_reverse_iterator crend() const noexcept
-    {
-        return const_reverse_iterator(cbegin());
-    }
-
-
-    //////////////
-    // capacity //
-    //////////////
-
-    /*!
-    @brief checks whether the container is empty
-    @ingroup container
-    */
-    inline bool empty() const noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                return true;
-            }
-
-            case (value_t::array):
-            {
-                return m_value.array->empty();
-            }
-
-            case (value_t::object):
-            {
-                return m_value.object->empty();
-            }
-
-            default:
-            {
-                // all other types are nonempty
-                return false;
-            }
-        }
-    }
-
-    /*!
-    @brief returns the number of elements
-    @ingroup container
-    */
-    inline size_type size() const noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                return 0;
-            }
-
-            case (value_t::array):
-            {
-                return m_value.array->size();
-            }
-
-            case (value_t::object):
-            {
-                return m_value.object->size();
-            }
-
-            default:
-            {
-                // all other types have size 1
-                return 1;
-            }
-        }
-    }
-
-    /*!
-    @brief returns the maximum possible number of elements
-    @ingroup container
-    */
-    inline size_type max_size() const noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                return 0;
-            }
-
-            case (value_t::array):
-            {
-                return m_value.array->max_size();
-            }
-
-            case (value_t::object):
-            {
-                return m_value.object->max_size();
-            }
-
-            default:
-            {
-                // all other types have max_size 1
-                return 1;
-            }
-        }
-    }
-
-
-    ///////////////
-    // modifiers //
-    ///////////////
-
-    /// clears the contents
-    inline void clear() noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                break;
-            }
-
-            case (value_t::number_integer):
-            {
-                m_value.number_integer = 0;
-                break;
-            }
-
-            case (value_t::number_float):
-            {
-                m_value.number_float = 0.0;
-                break;
-            }
-
-            case (value_t::boolean):
-            {
-                m_value.boolean = false;
-                break;
-            }
-
-            case (value_t::string):
-            {
-                m_value.string->clear();
-                break;
-            }
-
-            case (value_t::array):
-            {
-                m_value.array->clear();
-                break;
-            }
-
-            case (value_t::object):
-            {
-                m_value.object->clear();
-                break;
-            }
-        }
-    }
-
-    /// add an object to an array
-    inline void push_back(basic_json&& value)
-    {
-        // push_back only works for null objects or arrays
-        if (not(m_type == value_t::null or m_type == value_t::array))
-        {
-            throw std::runtime_error("cannot add element to " + type_name());
-        }
-
-        // transform null object into an array
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::array;
-            AllocatorType<array_t> alloc;
-            m_value.array = alloc.allocate(1);
-            alloc.construct(m_value.array);
-        }
-
-        // add element to array (move semantics)
-        m_value.array->push_back(std::move(value));
-        // invalidate object
-        value.m_type = value_t::null;
-    }
-
-    /// add an object to an array
-    inline reference operator+=(basic_json&& value)
-    {
-        push_back(std::move(value));
-        return *this;
-    }
-
-    /// add an object to an array
-    inline void push_back(const basic_json& value)
-    {
-        // push_back only works for null objects or arrays
-        if (not(m_type == value_t::null or m_type == value_t::array))
-        {
-            throw std::runtime_error("cannot add element to " + type_name());
-        }
-
-        // transform null object into an array
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::array;
-            AllocatorType<array_t> alloc;
-            m_value.array = alloc.allocate(1);
-            alloc.construct(m_value.array);
-        }
-
-        // add element to array
-        m_value.array->push_back(value);
-    }
-
-    /// add an object to an array
-    inline reference operator+=(const basic_json& value)
-    {
-        push_back(value);
-        return *this;
-    }
-
-    /// add an object to an object
-    inline void push_back(const typename object_t::value_type& value)
-    {
-        // push_back only works for null objects or objects
-        if (not(m_type == value_t::null or m_type == value_t::object))
-        {
-            throw std::runtime_error("cannot add element to " + type_name());
-        }
-
-        // transform null object into an object
-        if (m_type == value_t::null)
-        {
-            m_type = value_t::object;
-            AllocatorType<object_t> alloc;
-            m_value.object = alloc.allocate(1);
-            alloc.construct(m_value.object);
-        }
-
-        // add element to array
-        m_value.object->insert(value);
-    }
-
-    /// add an object to an object
-    inline reference operator+=(const typename object_t::value_type& value)
-    {
-        push_back(value);
-        return operator[](value.first);
-    }
-
-    /*!
-    @brief exchanges the values
-    @ingroup container
-    */
-    inline void swap(reference other) noexcept (
-        std::is_nothrow_move_constructible<value_t>::value and
-        std::is_nothrow_move_assignable<value_t>::value and
-        std::is_nothrow_move_constructible<json_value>::value and
-        std::is_nothrow_move_assignable<json_value>::value
-    )
-    {
-        std::swap(m_type, other.m_type);
-        std::swap(m_value, other.m_value);
-    }
-
-    /// swaps the contents
-    inline void swap(array_t& other)
-    {
-        // swap only works for arrays
-        if (m_type != value_t::array)
-        {
-            throw std::runtime_error("cannot use swap with " + type_name());
-        }
-
-        // swap arrays
-        std::swap(*(m_value.array), other);
-    }
-
-    /// swaps the contents
-    inline void swap(object_t& other)
-    {
-        // swap only works for objects
-        if (m_type != value_t::object)
-        {
-            throw std::runtime_error("cannot use swap with " + type_name());
-        }
-
-        // swap arrays
-        std::swap(*(m_value.object), other);
-    }
-
-    /// swaps the contents
-    inline void swap(string_t& other)
-    {
-        // swap only works for strings
-        if (m_type != value_t::string)
-        {
-            throw std::runtime_error("cannot use swap with " + type_name());
-        }
-
-        // swap arrays
-        std::swap(*(m_value.string), other);
-    }
-
-
-    //////////////////////////////////////////
-    // lexicographical comparison operators //
-    //////////////////////////////////////////
-
-    /*!
-    @brief comparison: equal
-    @ingroup container
-    */
-    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
-    {
-        switch (lhs.type())
-        {
-            case (value_t::array):
-            {
-                if (rhs.type() == value_t::array)
-                {
-                    return *lhs.m_value.array == *rhs.m_value.array;
-                }
-                break;
-            }
-            case (value_t::object):
-            {
-                if (rhs.type() == value_t::object)
-                {
-                    return *lhs.m_value.object == *rhs.m_value.object;
-                }
-                break;
-            }
-            case (value_t::null):
-            {
-                if (rhs.type() == value_t::null)
-                {
-                    return true;
-                }
-                break;
-            }
-            case (value_t::string):
-            {
-                if (rhs.type() == value_t::string)
-                {
-                    return *lhs.m_value.string == *rhs.m_value.string;
-                }
-                break;
-            }
-            case (value_t::boolean):
-            {
-                if (rhs.type() == value_t::boolean)
-                {
-                    return lhs.m_value.boolean == rhs.m_value.boolean;
-                }
-                break;
-            }
-            case (value_t::number_integer):
-            {
-                if (rhs.type() == value_t::number_integer)
-                {
-                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
-                }
-                if (rhs.type() == value_t::number_float)
-                {
-                    return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_float);
-                }
-                break;
-            }
-            case (value_t::number_float):
-            {
-                if (rhs.type() == value_t::number_integer)
-                {
-                    return approx(lhs.m_value.number_float, static_cast<number_float_t>(rhs.m_value.number_integer));
-                }
-                if (rhs.type() == value_t::number_float)
-                {
-                    return approx(lhs.m_value.number_float, rhs.m_value.number_float);
-                }
-                break;
-            }
-        }
-
-        return false;
-    }
-
-    /*!
-    @brief comparison: not equal
-    @ingroup container
-    */
-    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return not (lhs == rhs);
-    }
-
-    /// comparison: less than
-    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
-    {
-        switch (lhs.type())
-        {
-            case (value_t::array):
-            {
-                if (rhs.type() == value_t::array)
-                {
-                    return *lhs.m_value.array < *rhs.m_value.array;
-                }
-                break;
-            }
-            case (value_t::object):
-            {
-                if (rhs.type() == value_t::object)
-                {
-                    return *lhs.m_value.object < *rhs.m_value.object;
-                }
-                break;
-            }
-            case (value_t::null):
-            {
-                if (rhs.type() == value_t::null)
-                {
-                    return false;
-                }
-                break;
-            }
-            case (value_t::string):
-            {
-                if (rhs.type() == value_t::string)
-                {
-                    return *lhs.m_value.string < *rhs.m_value.string;
-                }
-                break;
-            }
-            case (value_t::boolean):
-            {
-                if (rhs.type() == value_t::boolean)
-                {
-                    return lhs.m_value.boolean < rhs.m_value.boolean;
-                }
-                break;
-            }
-            case (value_t::number_integer):
-            {
-                if (rhs.type() == value_t::number_integer)
-                {
-                    return lhs.m_value.number_integer < rhs.m_value.number_integer;
-                }
-                if (rhs.type() == value_t::number_float)
-                {
-                    return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_float);
-                }
-                break;
-            }
-            case (value_t::number_float):
-            {
-                if (rhs.type() == value_t::number_integer)
-                {
-                    return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
-                }
-                if (rhs.type() == value_t::number_float)
-                {
-                    return lhs.m_value.number_float < rhs.m_value.number_float;
-                }
-                break;
-            }
-        }
-
-        // We only reach this line if we cannot compare values. In that case,
-        // we compare types.
-        return lhs.type() < rhs.type();
-    }
-
-    /// comparison: less than or equal
-    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return not (rhs < lhs);
-    }
-
-    /// comparison: greater than
-    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
-    {
-        return not (lhs <= rhs);
-    }
-
-    /// comparison: greater than or equal
-    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
-    {
-        return not (lhs < rhs);
-    }
-
-
-    ///////////////////
-    // serialization //
-    ///////////////////
-
-    /// serialize to stream
-    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
-    {
-        // read width member and use it as indentation parameter if nonzero
-        const int indentation = (o.width() == 0) ? -1 : o.width();
-
-        o << j.dump(indentation);
-        return o;
-    }
-
-    /// serialize to stream
-    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
-    {
-        // read width member and use it as indentation parameter if nonzero
-        const int indentation = (o.width() == 0) ? -1 : o.width();
-
-        o << j.dump(indentation);
-        return o;
-    }
-
-
-    /////////////////////
-    // deserialization //
-    /////////////////////
-
-    /// deserialize from string
-    static basic_json parse(const string_t& s)
-    {
-        return parser(s).parse();
-    }
-
-    /// deserialize from stream
-    static basic_json parse(std::istream& i)
-    {
-        return parser(i).parse();
-    }
-
-    /// deserialize from stream
-    friend std::istream& operator>>(std::istream& i, basic_json& j)
-    {
-        j = parser(i).parse();
-        return i;
-    }
-
-    /// deserialize from stream
-    friend std::istream& operator<<(basic_json& j, std::istream& i)
-    {
-        j = parser(i).parse();
-        return i;
-    }
-
-
-  private:
-    ///////////////////////////
-    // convenience functions //
-    ///////////////////////////
-
-    /// return the type as string
-    inline string_t type_name() const noexcept
-    {
-        switch (m_type)
-        {
-            case (value_t::null):
-            {
-                return "null";
-            }
-
-            case (value_t::object):
-            {
-                return "object";
-            }
-
-            case (value_t::array):
-            {
-                return "array";
-            }
-
-            case (value_t::string):
-            {
-                return "string";
-            }
-
-            case (value_t::boolean):
-            {
-                return "boolean";
-            }
-
-            default:
-            {
-                return "number";
-            }
-        }
-    }
-
-    /*!
-    @brief escape a string
-
-    Escape a string by replacing certain special characters by a sequence of an
-    escape character (backslash) and another character and other control
-    characters by a sequence of "\u" followed by a four-digit hex
-    representation.
-
-    @param s  the string to escape
-    @return escaped string
-    */
-    static string_t escape_string(const string_t& s) noexcept
-    {
-        // create a result string of at least the size than s
-        string_t result;
-        result.reserve(s.size());
-
-        for (const auto c : s)
-        {
-            switch (c)
-            {
-                // quotation mark (0x22)
-                case '"':
-                {
-                    result += "\\\"";
-                    break;
-                }
-
-                // reverse solidus (0x5c)
-                case '\\':
-                {
-                    result += "\\\\";
-                    break;
-                }
-
-                // backspace (0x08)
-                case '\b':
-                {
-                    result += "\\b";
-                    break;
-                }
-
-                // formfeed (0x0c)
-                case '\f':
-                {
-                    result += "\\f";
-                    break;
-                }
-
-                // newline (0x0a)
-                case '\n':
-                {
-                    result += "\\n";
-                    break;
-                }
-
-                // carriage return (0x0d)
-                case '\r':
-                {
-                    result += "\\r";
-                    break;
-                }
-
-                // horizontal tab (0x09)
-                case '\t':
-                {
-                    result += "\\t";
-                    break;
-                }
-
-                default:
-                {
-                    if (c >= 0 and c <= 0x1f)
-                    {
-                        // control characters (everything between 0x00 and 0x1f)
-                        // -> create four-digit hex representation
-                        std::stringstream ss;
-                        ss << "\\u" << std::hex << std::setw(4) << std::setfill('0') << int(c);
-                        result += ss.str();
-                    }
-                    else
-                    {
-                        // all other characters are added as-is
-                        result.append(1, c);
-                    }
-                    break;
-                }
-            }
-        }
-
-        return result;
-    }
-
-
-    /*!
-    @brief internal implementation of the serialization function
-
-    This function is called by the public member function dump and organizes
-    the serializaion internally. The indentation level is propagated as
-    additional parameter. In case of arrays and objects, the function is called
-    recursively. Note that
-
-    - strings and object keys are escaped using escape_string()
-    - integer numbers are converted to a string before output using
-      std::to_string()
-    - floating-point numbers are converted to a string using "%g" format
-
-    @param prettyPrint    whether the output shall be pretty-printed
-    @param indentStep     the indent level
-    @param currentIndent  the current indent level (only used internally)
-    */
-    inline string_t dump(const bool prettyPrint, const unsigned int indentStep,
-                         const unsigned int currentIndent = 0) const noexcept
-    {
-        // variable to hold indentation for recursive calls
-        auto new_indent = currentIndent;
-
-        // helper function to return whitespace as indentation
-        const auto indent = [prettyPrint, &new_indent]()
-        {
-            return prettyPrint ? string_t(new_indent, ' ') : string_t();
-        };
-
-        switch (m_type)
-        {
-            case (value_t::object):
-            {
-                if (m_value.object->empty())
-                {
-                    return "{}";
-                }
-
-                string_t result = "{";
-
-                // increase indentation
-                if (prettyPrint)
-                {
-                    new_indent += indentStep;
-                    result += "\n";
-                }
-
-                for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)
-                {
-                    if (i != m_value.object->cbegin())
-                    {
-                        result += prettyPrint ? ",\n" : ",";
-                    }
-                    result += indent() + "\"" + escape_string(i->first) + "\":" + (prettyPrint ? " " : "")
-                              + i->second.dump(prettyPrint, indentStep, new_indent);
-                }
-
-                // decrease indentation
-                if (prettyPrint)
-                {
-                    new_indent -= indentStep;
-                    result += "\n";
-                }
-
-                return result + indent() + "}";
-            }
-
-            case (value_t::array):
-            {
-                if (m_value.array->empty())
-                {
-                    return "[]";
-                }
-
-                string_t result = "[";
-
-                // increase indentation
-                if (prettyPrint)
-                {
-                    new_indent += indentStep;
-                    result += "\n";
-                }
-
-                for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)
-                {
-                    if (i != m_value.array->cbegin())
-                    {
-                        result += prettyPrint ? ",\n" : ",";
-                    }
-                    result += indent() + i->dump(prettyPrint, indentStep, new_indent);
-                }
-
-                // decrease indentation
-                if (prettyPrint)
-                {
-                    new_indent -= indentStep;
-                    result += "\n";
-                }
-
-                return result + indent() + "]";
-            }
-
-            case (value_t::string):
-            {
-                return string_t("\"") + escape_string(*m_value.string) + "\"";
-            }
-
-            case (value_t::boolean):
-            {
-                return m_value.boolean ? "true" : "false";
-            }
-
-            case (value_t::number_integer):
-            {
-                return std::to_string(m_value.number_integer);
-            }
-
-            case (value_t::number_float):
-            {
-                // 15 digits of precision allows round-trip IEEE 754
-                // string->double->string
-                const auto sz = static_cast<unsigned int>(std::snprintf(nullptr, 0, "%.15g", m_value.number_float));
-                std::vector<char> buf(sz + 1);
-                std::snprintf(&buf[0], buf.size(), "%.15g", m_value.number_float);
-                return string_t(buf.data());
-            }
-
-            default:
-            {
-                return "null";
-            }
-        }
-    }
-
-    /// "equality" comparison for floating point numbers
-    template<typename T>
-    inline static bool approx(const T a, const T b)
-    {
-        return not (a > b or a < b);
-    }
-
-
-  private:
-    //////////////////////
-    // member variables //
-    //////////////////////
-
-    /// the type of the current element
-    value_t m_type = value_t::null;
-
-    /// whether the type of JSON object may change later
-    bool m_final = false;
-
-    /// the value of the current element
-    json_value m_value = {};
-
-
-  private:
-    ///////////////
-    // iterators //
-    ///////////////
-
-    /// an iterator value
-    template<typename array_iterator_t, typename object_iterator_t>
-    union internal_iterator
-    {
-        /// iterator for JSON objects
-        object_iterator_t object_iterator;
-        /// iterator for JSON arrays
-        array_iterator_t array_iterator;
-        /// generic iteraotr for all other value types
-        difference_type generic_iterator;
-
-        /// default constructor
-        internal_iterator() : generic_iterator(-1) {}
-    };
-
-  public:
-    /// a random access iterator for the basic_json class
-    class iterator : public std::iterator<std::random_access_iterator_tag, basic_json>
-    {
-        // allow basic_json class to access m_it
-        friend class basic_json;
-
-      public:
-        /// the type of the values when the iterator is dereferenced
-        using value_type = basic_json::value_type;
-        /// a type to represent differences between iterators
-        using difference_type = basic_json::difference_type;
-        /// defines a pointer to the type iterated over (value_type)
-        using pointer = basic_json::pointer;
-        /// defines a reference to the type iterated over (value_type)
-        using reference = basic_json::reference;
-        /// the category of the iterator
-        using iterator_category = std::bidirectional_iterator_tag;
-
-        /// default constructor
-        inline iterator() = default;
-
-        /// constructor for a given JSON instance
-        inline iterator(pointer object) noexcept : m_object(object)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = typename object_t::iterator();
-                    break;
-                }
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = typename array_t::iterator();
-                    break;
-                }
-                default:
-                {
-                    m_it.generic_iterator = -1;
-                    break;
-                }
-            }
-        }
-
-        /// copy constructor
-        inline iterator(const iterator& other) noexcept
-            : m_object(other.m_object), m_it(other.m_it)
-        {}
-
-        /// copy assignment
-        inline iterator& operator=(iterator other) noexcept (
-            std::is_nothrow_move_constructible<pointer>::value and
-            std::is_nothrow_move_assignable<pointer>::value and
-            std::is_nothrow_move_constructible<internal_iterator<typename array_t::iterator, typename object_t::iterator>>::value
-            and
-            std::is_nothrow_move_assignable<internal_iterator<typename array_t::iterator, typename object_t::iterator>>::value
-        )
-        {
-            std::swap(m_object, other.m_object);
-            std::swap(m_it, other.m_it);
-            return *this;
-        }
-
-      private:
-        /// set the iterator to the first value
-        inline void set_begin() noexcept
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = m_object->m_value.object->begin();
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = m_object->m_value.array->begin();
-                    break;
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    // set to end so begin()==end() is true: null is empty
-                    m_it.generic_iterator = 1;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator = 0;
-                    break;
-                }
-            }
-        }
-
-        /// set the iterator past the last value
-        inline void set_end() noexcept
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = m_object->m_value.object->end();
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = m_object->m_value.array->end();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator = 1;
-                    break;
-                }
-            }
-        }
-
-      public:
-        /// return a reference to the value pointed to by the iterator
-        inline reference operator*()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return m_it.object_iterator->second;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return *m_it.array_iterator;
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    throw std::out_of_range("cannot get value");
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == 0)
-                    {
-                        return *m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// dereference the iterator
-        inline pointer operator->()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return &(m_it.object_iterator->second);
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return &*m_it.array_iterator;
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    throw std::out_of_range("cannot get value");
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == 0)
-                    {
-                        return m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// post-increment (it++)
-        inline iterator operator++(int)
-        {
-            auto result = *this;
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator++;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator++;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator++;
-                    break;
-                }
-            }
-
-            return result;
-        }
-
-        /// pre-increment (++it)
-        inline iterator& operator++()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    ++m_it.object_iterator;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    ++m_it.array_iterator;
-                    break;
-                }
-
-                default:
-                {
-                    ++m_it.generic_iterator;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// post-decrement (it--)
-        inline iterator operator--(int)
-        {
-            auto result = *this;
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator--;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator--;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator--;
-                    break;
-                }
-            }
-
-            return result;
-        }
-
-        /// pre-decrement (--it)
-        inline iterator& operator--()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    --m_it.object_iterator;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    --m_it.array_iterator;
-                    break;
-                }
-
-                default:
-                {
-                    --m_it.generic_iterator;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// comparison: equal
-        inline bool operator==(const iterator& other) const
-        {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
-                throw std::domain_error("cannot compare iterators of different containers");
-            }
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return (m_it.object_iterator == other.m_it.object_iterator);
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return (m_it.array_iterator == other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.generic_iterator == other.m_it.generic_iterator);
-                }
-            }
-        }
-
-        /// comparison: not equal
-        inline bool operator!=(const iterator& other) const
-        {
-            return not operator==(other);
-        }
-
-        /// comparison: smaller
-        inline bool operator<(const iterator& other) const
-        {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
-                throw std::domain_error("cannot compare iterators of different containers");
-            }
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator< for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return (m_it.array_iterator < other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.generic_iterator < other.m_it.generic_iterator);
-                }
-            }
-        }
-
-        /// comparison: less than or equal
-        inline bool operator<=(const iterator& other) const
-        {
-            return not other.operator < (*this);
-        }
-
-        /// comparison: greater than
-        inline bool operator>(const iterator& other) const
-        {
-            return not operator<=(other);
-        }
-
-        /// comparison: greater than or equal
-        inline bool operator>=(const iterator& other) const
-        {
-            return not operator<(other);
-        }
-
-        /// add to iterator
-        inline iterator& operator+=(difference_type i)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator+= for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator += i;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator += i;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// subtract from iterator
-        inline iterator& operator-=(difference_type i)
-        {
-            return operator+=(-i);
-        }
-
-        /// add to iterator
-        inline iterator operator+(difference_type i)
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
-
-        /// subtract from iterator
-        inline iterator operator-(difference_type i)
-        {
-            auto result = *this;
-            result -= i;
-            return result;
-        }
-
-        /// return difference
-        inline difference_type operator-(const iterator& other) const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator- for object iterators");
-                    return 0;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return m_it.array_iterator - other.m_it.array_iterator;
-                }
-
-                default:
-                {
-                    return m_it.generic_iterator - other.m_it.generic_iterator;
-                }
-            }
-        }
-
-        /// access to successor
-        inline reference operator[](difference_type n)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator[] for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return *(m_it.array_iterator + n);
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    throw std::out_of_range("cannot get value");
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == -n)
-                    {
-                        return *m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// return the key of an object iterator
-        inline typename object_t::key_type key() const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return m_it.object_iterator->first;
-                }
-
-                default:
-                {
-                    throw std::domain_error("cannot use key() for non-object iterators");
-                }
-            }
-        }
-
-        /// return the key of an iterator
-        inline reference value()
-        {
-            return operator*();
-        }
-
-      private:
-        /// associated JSON instance
-        pointer m_object = nullptr;
-        /// the actual iterator of the associated instance
-        internal_iterator<typename array_t::iterator, typename object_t::iterator> m_it;
-    };
-
-    /// a const random access iterator for the basic_json class
-    class const_iterator : public std::iterator<std::random_access_iterator_tag, const basic_json>
-    {
-        // allow basic_json class to access m_it
-        friend class basic_json;
-
-      public:
-        /// the type of the values when the iterator is dereferenced
-        using value_type = basic_json::value_type;
-        /// a type to represent differences between iterators
-        using difference_type = basic_json::difference_type;
-        /// defines a pointer to the type iterated over (value_type)
-        using pointer = basic_json::const_pointer;
-        /// defines a reference to the type iterated over (value_type)
-        using reference = basic_json::const_reference;
-        /// the category of the iterator
-        using iterator_category = std::bidirectional_iterator_tag;
-
-        /// default constructor
-        inline const_iterator() = default;
-
-        /// constructor for a given JSON instance
-        inline const_iterator(pointer object) noexcept : m_object(object)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = typename object_t::const_iterator();
-                    break;
-                }
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = typename array_t::const_iterator();
-                    break;
-                }
-                default:
-                {
-                    m_it.generic_iterator = -1;
-                    break;
-                }
-            }
-        }
-
-        /// copy constructor given a nonconst iterator
-        inline const_iterator(const iterator& other) noexcept : m_object(other.m_object)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = other.m_it.object_iterator;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = other.m_it.array_iterator;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator = other.m_it.generic_iterator;
-                    break;
-                }
-            }
-        }
-
-        /// copy constructor
-        inline const_iterator(const const_iterator& other) noexcept
-            : m_object(other.m_object), m_it(other.m_it)
-        {}
-
-        /// copy assignment
-        inline const_iterator& operator=(const_iterator other) noexcept(
-            std::is_nothrow_move_constructible<pointer>::value and
-            std::is_nothrow_move_assignable<pointer>::value and
-            std::is_nothrow_move_constructible<internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator>>::value
-            and
-            std::is_nothrow_move_assignable<internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator>>::value
-        )
-        {
-            std::swap(m_object, other.m_object);
-            std::swap(m_it, other.m_it);
-            return *this;
-        }
-
-      private:
-        /// set the iterator to the first value
-        inline void set_begin() noexcept
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = m_object->m_value.object->cbegin();
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = m_object->m_value.array->cbegin();
-                    break;
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    // set to end so begin()==end() is true: null is empty
-                    m_it.generic_iterator = 1;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator = 0;
-                    break;
-                }
-            }
-        }
-
-        /// set the iterator past the last value
-        inline void set_end() noexcept
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator = m_object->m_value.object->cend();
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator = m_object->m_value.array->cend();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator = 1;
-                    break;
-                }
-            }
-        }
-
-      public:
-        /// return a reference to the value pointed to by the iterator
-        inline reference operator*() const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return m_it.object_iterator->second;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return *m_it.array_iterator;
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    throw std::out_of_range("cannot get value");
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == 0)
-                    {
-                        return *m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// dereference the iterator
-        inline pointer operator->() const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return &(m_it.object_iterator->second);
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return &*m_it.array_iterator;
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == 0)
-                    {
-                        return m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// post-increment (it++)
-        inline const_iterator operator++(int)
-        {
-            auto result = *this;
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator++;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator++;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator++;
-                    break;
-                }
-            }
-
-            return result;
-        }
-
-        /// pre-increment (++it)
-        inline const_iterator& operator++()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    ++m_it.object_iterator;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    ++m_it.array_iterator;
-                    break;
-                }
-
-                default:
-                {
-                    ++m_it.generic_iterator;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// post-decrement (it--)
-        inline const_iterator operator--(int)
-        {
-            auto result = *this;
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    m_it.object_iterator--;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator--;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator--;
-                    break;
-                }
-            }
-
-            return result;
-        }
-
-        /// pre-decrement (--it)
-        inline const_iterator& operator--()
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    --m_it.object_iterator;
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    --m_it.array_iterator;
-                    break;
-                }
-
-                default:
-                {
-                    --m_it.generic_iterator;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// comparison: equal
-        inline bool operator==(const const_iterator& other) const
-        {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
-                throw std::domain_error("cannot compare iterators of different containers");
-            }
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return (m_it.object_iterator == other.m_it.object_iterator);
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return (m_it.array_iterator == other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.generic_iterator == other.m_it.generic_iterator);
-                }
-            }
-        }
-
-        /// comparison: not equal
-        inline bool operator!=(const const_iterator& other) const
-        {
-            return not operator==(other);
-        }
-
-        /// comparison: smaller
-        inline bool operator<(const const_iterator& other) const
-        {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
-                throw std::domain_error("cannot compare iterators of different containers");
-            }
-
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator< for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return (m_it.array_iterator < other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.generic_iterator < other.m_it.generic_iterator);
-                }
-            }
-        }
-
-        /// comparison: less than or equal
-        inline bool operator<=(const const_iterator& other) const
-        {
-            return not other.operator < (*this);
-        }
-
-        /// comparison: greater than
-        inline bool operator>(const const_iterator& other) const
-        {
-            return not operator<=(other);
-        }
-
-        /// comparison: greater than or equal
-        inline bool operator>=(const const_iterator& other) const
-        {
-            return not operator<(other);
-        }
-
-        /// add to iterator
-        inline const_iterator& operator+=(difference_type i)
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator+= for object iterators");
-                    break;
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    m_it.array_iterator += i;
-                    break;
-                }
-
-                default:
-                {
-                    m_it.generic_iterator += i;
-                    break;
-                }
-            }
-
-            return *this;
-        }
-
-        /// subtract from iterator
-        inline const_iterator& operator-=(difference_type i)
-        {
-            return operator+=(-i);
-        }
-
-        /// add to iterator
-        inline const_iterator operator+(difference_type i)
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
-
-        /// subtract from iterator
-        inline const_iterator operator-(difference_type i)
-        {
-            auto result = *this;
-            result -= i;
-            return result;
-        }
-
-        /// return difference
-        inline difference_type operator-(const const_iterator& other) const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator- for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return m_it.array_iterator - other.m_it.array_iterator;
-                }
-
-                default:
-                {
-                    return m_it.generic_iterator - other.m_it.generic_iterator;
-                }
-            }
-        }
-
-        /// access to successor
-        inline reference operator[](difference_type n) const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    throw std::domain_error("cannot use operator[] for object iterators");
-                }
-
-                case (basic_json::value_t::array):
-                {
-                    return *(m_it.array_iterator + n);
-                }
-
-                case (basic_json::value_t::null):
-                {
-                    throw std::out_of_range("cannot get value");
-                }
-
-                default:
-                {
-                    if (m_it.generic_iterator == -n)
-                    {
-                        return *m_object;
-                    }
-                    else
-                    {
-                        throw std::out_of_range("cannot get value");
-                    }
-                }
-            }
-        }
-
-        /// return the key of an object iterator
-        inline typename object_t::key_type key() const
-        {
-            switch (m_object->m_type)
-            {
-                case (basic_json::value_t::object):
-                {
-                    return m_it.object_iterator->first;
-                }
-
-                default:
-                {
-                    throw std::domain_error("cannot use key() for non-object iterators");
-                }
-            }
-        }
-
-        /// return the value of an iterator
-        inline reference value() const
-        {
-            return operator*();
-        }
-
-      private:
-        /// associated JSON instance
-        pointer m_object = nullptr;
-        /// the actual iterator of the associated instance
-        internal_iterator<typename array_t::const_iterator, typename object_t::const_iterator> m_it;
-    };
-
-    /// a reverse random access iterator for the basic_json class
-    class reverse_iterator : private std::reverse_iterator<basic_json::iterator>
-    {
-      public:
-        inline reverse_iterator(const typename std::reverse_iterator<basic_json::iterator>::iterator_type&
-                                it)
-            : std::reverse_iterator<basic_json::iterator>(it) {}
-
-        /// return the key of an object iterator
-        inline typename object_t::key_type key() const
-        {
-            return this->base().key();
-        }
-
-        /// return the value of an iterator
-        inline reference value() const
-        {
-            return this->base().operator * ();
-        }
-    };
-
-    /// a const reverse random access iterator for the basic_json class
-    class const_reverse_iterator : private std::reverse_iterator<basic_json::const_iterator>
-    {
-      public:
-        inline const_reverse_iterator(const typename
-                                      std::reverse_iterator<basic_json::const_iterator>::iterator_type& it)
-            : std::reverse_iterator<basic_json::const_iterator>(it) {}
-
-        /// return the key of an object iterator
-        inline typename object_t::key_type key() const
-        {
-            return this->base().key();
-        }
-
-        /// return the value of an iterator
-        inline const_reference value() const
-        {
-            return this->base().operator * ();
-        }
-    };
-
-
-  private:
-    //////////////////////
-    // lexer and parser //
-    //////////////////////
-
-    /*!
-    @brief lexical analysis
-
-    This class organizes the lexical analysis during JSON deserialization. The
-    core of it is a scanner generated by re2c <http://re2c.org> that processes
-    a buffer and recognizes tokens according to RFC 7159 and ECMA-404.
-    */
-    class lexer
-    {
-      public:
-        /// token types for the parser
-        enum class token_type
-        {
-            uninitialized,    ///< indicating the scanner is uninitialized
-            literal_true,     ///< the "true" literal
-            literal_false,    ///< the "false" literal
-            literal_null,     ///< the "null" literal
-            value_string,     ///< a string - use get_string() for actual value
-            value_number,     ///< a number - use get_number() for actual value
-            begin_array,      ///< the character for array begin "["
-            begin_object,     ///< the character for object begin "{"
-            end_array,        ///< the character for array end "]"
-            end_object,       ///< the character for object end "}"
-            name_separator,   ///< the name separator ":"
-            value_separator,  ///< the value separator ","
-            parse_error,      ///< indicating a parse error
-            end_of_input      ///< indicating the end of the input buffer
-        };
-
-        /// the char type to use in the lexer
-        using lexer_char_t = unsigned char;
-
-        /// constructor with a given buffer
-        inline lexer(const string_t& s) noexcept
-            : m_stream(nullptr), m_buffer(s)
-        {
-            m_content = reinterpret_cast<const lexer_char_t*>(s.c_str());
-            m_start = m_cursor = m_content;
-            m_limit = m_content + s.size();
-        }
-        inline lexer(std::istream* s) noexcept
-            : m_stream(s)
-        {
-            getline(*m_stream, m_buffer);
-            m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
-            m_start = m_cursor = m_content;
-            m_limit = m_content + m_buffer.size();
-        }
-
-        /// default constructor
-        inline lexer() = default;
-
-        /*!
-        @brief create a string from a Unicode code point
-
-        @param codepoint1  the code point (can be high surrogate)
-        @param codepoint2  the code point (can be low surrogate or 0)
-        @return string representation of the code point
-        @exception std::out_of_range if code point is >0x10ffff
-        @exception std::invalid_argument if the low surrogate is invalid
-
-        @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
-        */
-        inline static string_t to_unicode(const std::size_t codepoint1,
-                                          const std::size_t codepoint2 = 0)
-        {
-            string_t result;
-
-            // calculate the codepoint from the given code points
-            std::size_t codepoint = codepoint1;
-            if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
-            {
-                if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
-                {
-                    codepoint =
-                        // high surrogate occupies the most significant 22 bits
-                        (codepoint1 << 10)
-                        // low surrogate occupies the least significant 15 bits
-                        + codepoint2
-                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                        // in the result so we have to substract with:
-                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                        - 0x35FDC00;
-                }
-                else
-                {
-                    throw std::invalid_argument("missing or wrong low surrogate");
-                }
-            }
-
-            if (codepoint <= 0x7f)
-            {
-                // 1-byte characters: 0xxxxxxx (ASCII)
-                result.append(1, static_cast<typename string_t::value_type>(codepoint));
-            }
-            else if (codepoint <= 0x7ff)
-            {
-                // 2-byte characters: 110xxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0xffff)
-            {
-                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0x10ffff)
-            {
-                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else
-            {
-                throw std::out_of_range("code points above 0x10FFFF are invalid");
-            }
-
-            return result;
-        }
-
-        /// return name of values of type token_type
-        inline static std::string token_type_name(token_type t) noexcept
-        {
-            switch (t)
-            {
-                case (token_type::uninitialized):
-                    return "<uninitialized>";
-                case (token_type::literal_true):
-                    return "true literal";
-                case (token_type::literal_false):
-                    return "false literal";
-                case (token_type::literal_null):
-                    return "null literal";
-                case (token_type::value_string):
-                    return "string literal";
-                case (token_type::value_number):
-                    return "number literal";
-                case (token_type::begin_array):
-                    return "[";
-                case (token_type::begin_object):
-                    return "{";
-                case (token_type::end_array):
-                    return "]";
-                case (token_type::end_object):
-                    return "}";
-                case (token_type::name_separator):
-                    return ":";
-                case (token_type::value_separator):
-                    return ",";
-                case (token_type::end_of_input):
-                    return "<end of input>";
-                default:
-                    return "<parse error>";
-            }
-        }
-
-        /*!
-        This function implements a scanner for JSON. It is specified using
-        regular expressions that try to follow RFC 7159 and ECMA-404 as close
-        as possible. These regular expressions are then translated into a
-        deterministic finite automaton (DFA) by the tool re2c
-        <http://re2c.org>. As a result, the translated code for this function
-        consists of a large block of code with goto jumps.
-
-        @return the class of the next token read from the buffer
-        */
-        inline token_type scan() noexcept
-        {
-            // pointer for backtracking information
-            m_marker = nullptr;
-
-            // remember the begin of the token
-            m_start = m_cursor;
-
-
-            {
-                lexer_char_t yych;
-                unsigned int yyaccept = 0;
-                static const unsigned char yybm[] =
-                {
-                    0,  64,  64,  64,  64,  64,  64,  64,
-                    64,  96,  96,  64,  64,  96,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    96,  64,   0,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    192, 192, 192, 192, 192, 192, 192, 192,
-                    192, 192,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,   0,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                    64,  64,  64,  64,  64,  64,  64,  64,
-                };
-
-                if ((m_limit - m_cursor) < 5)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '9')
-                {
-                    if (yych <= ' ')
-                    {
-                        if (yych <= '\n')
-                        {
-                            if (yych <= 0x00)
-                            {
-                                goto basic_json_parser_27;
-                            }
-                            if (yych <= 0x08)
-                            {
-                                goto basic_json_parser_29;
-                            }
-                            if (yych >= '\n')
-                            {
-                                goto basic_json_parser_4;
-                            }
-                        }
-                        else
-                        {
-                            if (yych == '\r')
-                            {
-                                goto basic_json_parser_2;
-                            }
-                            if (yych <= 0x1F)
-                            {
-                                goto basic_json_parser_29;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        if (yych <= ',')
-                        {
-                            if (yych == '"')
-                            {
-                                goto basic_json_parser_26;
-                            }
-                            if (yych <= '+')
-                            {
-                                goto basic_json_parser_29;
-                            }
-                            goto basic_json_parser_14;
-                        }
-                        else
-                        {
-                            if (yych <= '-')
-                            {
-                                goto basic_json_parser_22;
-                            }
-                            if (yych <= '/')
-                            {
-                                goto basic_json_parser_29;
-                            }
-                            if (yych <= '0')
-                            {
-                                goto basic_json_parser_23;
-                            }
-                            goto basic_json_parser_25;
-                        }
-                    }
-                }
-                else
-                {
-                    if (yych <= 'm')
-                    {
-                        if (yych <= '\\')
-                        {
-                            if (yych <= ':')
-                            {
-                                goto basic_json_parser_16;
-                            }
-                            if (yych == '[')
-                            {
-                                goto basic_json_parser_6;
-                            }
-                            goto basic_json_parser_29;
-                        }
-                        else
-                        {
-                            if (yych <= ']')
-                            {
-                                goto basic_json_parser_8;
-                            }
-                            if (yych == 'f')
-                            {
-                                goto basic_json_parser_21;
-                            }
-                            goto basic_json_parser_29;
-                        }
-                    }
-                    else
-                    {
-                        if (yych <= 'z')
-                        {
-                            if (yych <= 'n')
-                            {
-                                goto basic_json_parser_18;
-                            }
-                            if (yych == 't')
-                            {
-                                goto basic_json_parser_20;
-                            }
-                            goto basic_json_parser_29;
-                        }
-                        else
-                        {
-                            if (yych <= '{')
-                            {
-                                goto basic_json_parser_10;
-                            }
-                            if (yych == '}')
-                            {
-                                goto basic_json_parser_12;
-                            }
-                            goto basic_json_parser_29;
-                        }
-                    }
-                }
-basic_json_parser_2:
-                ++m_cursor;
-                yych = *m_cursor;
-                goto basic_json_parser_5;
-basic_json_parser_3:
-                {
-                    return scan();
-                }
-basic_json_parser_4:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-basic_json_parser_5:
-                if (yybm[0 + yych] & 32)
-                {
-                    goto basic_json_parser_4;
-                }
-                goto basic_json_parser_3;
-basic_json_parser_6:
-                ++m_cursor;
-                {
-                    return token_type::begin_array;
-                }
-basic_json_parser_8:
-                ++m_cursor;
-                {
-                    return token_type::end_array;
-                }
-basic_json_parser_10:
-                ++m_cursor;
-                {
-                    return token_type::begin_object;
-                }
-basic_json_parser_12:
-                ++m_cursor;
-                {
-                    return token_type::end_object;
-                }
-basic_json_parser_14:
-                ++m_cursor;
-                {
-                    return token_type::value_separator;
-                }
-basic_json_parser_16:
-                ++m_cursor;
-                {
-                    return token_type::name_separator;
-                }
-basic_json_parser_18:
-                yyaccept = 0;
-                yych = *(m_marker = ++m_cursor);
-                if (yych == 'u')
-                {
-                    goto basic_json_parser_59;
-                }
-basic_json_parser_19:
-                {
-                    return token_type::parse_error;
-                }
-basic_json_parser_20:
-                yyaccept = 0;
-                yych = *(m_marker = ++m_cursor);
-                if (yych == 'r')
-                {
-                    goto basic_json_parser_55;
-                }
-                goto basic_json_parser_19;
-basic_json_parser_21:
-                yyaccept = 0;
-                yych = *(m_marker = ++m_cursor);
-                if (yych == 'a')
-                {
-                    goto basic_json_parser_50;
-                }
-                goto basic_json_parser_19;
-basic_json_parser_22:
-                yych = *++m_cursor;
-                if (yych <= '/')
-                {
-                    goto basic_json_parser_19;
-                }
-                if (yych <= '0')
-                {
-                    goto basic_json_parser_49;
-                }
-                if (yych <= '9')
-                {
-                    goto basic_json_parser_40;
-                }
-                goto basic_json_parser_19;
-basic_json_parser_23:
-                yyaccept = 1;
-                yych = *(m_marker = ++m_cursor);
-                if (yych <= 'D')
-                {
-                    if (yych == '.')
-                    {
-                        goto basic_json_parser_42;
-                    }
-                }
-                else
-                {
-                    if (yych <= 'E')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                }
-basic_json_parser_24:
-                {
-                    return token_type::value_number;
-                }
-basic_json_parser_25:
-                yyaccept = 1;
-                yych = *(m_marker = ++m_cursor);
-                goto basic_json_parser_41;
-basic_json_parser_26:
-                yyaccept = 0;
-                yych = *(m_marker = ++m_cursor);
-                if (yych <= 0x00)
-                {
-                    goto basic_json_parser_19;
-                }
-                goto basic_json_parser_31;
-basic_json_parser_27:
-                ++m_cursor;
-                {
-                    return token_type::end_of_input;
-                }
-basic_json_parser_29:
-                yych = *++m_cursor;
-                goto basic_json_parser_19;
-basic_json_parser_30:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-basic_json_parser_31:
-                if (yybm[0 + yych] & 64)
-                {
-                    goto basic_json_parser_30;
-                }
-                if (yych <= 0x00)
-                {
-                    goto basic_json_parser_32;
-                }
-                if (yych <= '"')
-                {
-                    goto basic_json_parser_34;
-                }
-                goto basic_json_parser_33;
-basic_json_parser_32:
-                m_cursor = m_marker;
-                if (yyaccept == 0)
-                {
-                    goto basic_json_parser_19;
-                }
-                else
-                {
-                    goto basic_json_parser_24;
-                }
-basic_json_parser_33:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= 'e')
-                {
-                    if (yych <= '/')
-                    {
-                        if (yych == '"')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        if (yych <= '.')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        goto basic_json_parser_30;
-                    }
-                    else
-                    {
-                        if (yych <= '\\')
-                        {
-                            if (yych <= '[')
-                            {
-                                goto basic_json_parser_32;
-                            }
-                            goto basic_json_parser_30;
-                        }
-                        else
-                        {
-                            if (yych == 'b')
-                            {
-                                goto basic_json_parser_30;
-                            }
-                            goto basic_json_parser_32;
-                        }
-                    }
-                }
-                else
-                {
-                    if (yych <= 'q')
-                    {
-                        if (yych <= 'f')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        if (yych == 'n')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= 's')
-                        {
-                            if (yych <= 'r')
-                            {
-                                goto basic_json_parser_30;
-                            }
-                            goto basic_json_parser_32;
-                        }
-                        else
-                        {
-                            if (yych <= 't')
-                            {
-                                goto basic_json_parser_30;
-                            }
-                            if (yych <= 'u')
-                            {
-                                goto basic_json_parser_36;
-                            }
-                            goto basic_json_parser_32;
-                        }
-                    }
-                }
-basic_json_parser_34:
-                ++m_cursor;
-                {
-                    return token_type::value_string;
-                }
-basic_json_parser_36:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '@')
-                {
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= ':')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-                else
-                {
-                    if (yych <= 'F')
-                    {
-                        goto basic_json_parser_37;
-                    }
-                    if (yych <= '`')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= 'g')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-basic_json_parser_37:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '@')
-                {
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= ':')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-                else
-                {
-                    if (yych <= 'F')
-                    {
-                        goto basic_json_parser_38;
-                    }
-                    if (yych <= '`')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= 'g')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-basic_json_parser_38:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '@')
-                {
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= ':')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-                else
-                {
-                    if (yych <= 'F')
-                    {
-                        goto basic_json_parser_39;
-                    }
-                    if (yych <= '`')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych >= 'g')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-basic_json_parser_39:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '@')
-                {
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= '9')
-                    {
-                        goto basic_json_parser_30;
-                    }
-                    goto basic_json_parser_32;
-                }
-                else
-                {
-                    if (yych <= 'F')
-                    {
-                        goto basic_json_parser_30;
-                    }
-                    if (yych <= '`')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 'f')
-                    {
-                        goto basic_json_parser_30;
-                    }
-                    goto basic_json_parser_32;
-                }
-basic_json_parser_40:
-                yyaccept = 1;
-                m_marker = ++m_cursor;
-                if ((m_limit - m_cursor) < 3)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-basic_json_parser_41:
-                if (yybm[0 + yych] & 128)
-                {
-                    goto basic_json_parser_40;
-                }
-                if (yych <= 'D')
-                {
-                    if (yych != '.')
-                    {
-                        goto basic_json_parser_24;
-                    }
-                }
-                else
-                {
-                    if (yych <= 'E')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    goto basic_json_parser_24;
-                }
-basic_json_parser_42:
-                yych = *++m_cursor;
-                if (yych <= '/')
-                {
-                    goto basic_json_parser_32;
-                }
-                if (yych <= '9')
-                {
-                    goto basic_json_parser_47;
-                }
-                goto basic_json_parser_32;
-basic_json_parser_43:
-                yych = *++m_cursor;
-                if (yych <= ',')
-                {
-                    if (yych != '+')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                }
-                else
-                {
-                    if (yych <= '-')
-                    {
-                        goto basic_json_parser_44;
-                    }
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= '9')
-                    {
-                        goto basic_json_parser_45;
-                    }
-                    goto basic_json_parser_32;
-                }
-basic_json_parser_44:
-                yych = *++m_cursor;
-                if (yych <= '/')
-                {
-                    goto basic_json_parser_32;
-                }
-                if (yych >= ':')
-                {
-                    goto basic_json_parser_32;
-                }
-basic_json_parser_45:
-                ++m_cursor;
-                if (m_limit <= m_cursor)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= '/')
-                {
-                    goto basic_json_parser_24;
-                }
-                if (yych <= '9')
-                {
-                    goto basic_json_parser_45;
-                }
-                goto basic_json_parser_24;
-basic_json_parser_47:
-                yyaccept = 1;
-                m_marker = ++m_cursor;
-                if ((m_limit - m_cursor) < 3)
-                {
-                    yyfill();
-                };
-                yych = *m_cursor;
-                if (yych <= 'D')
-                {
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_24;
-                    }
-                    if (yych <= '9')
-                    {
-                        goto basic_json_parser_47;
-                    }
-                    goto basic_json_parser_24;
-                }
-                else
-                {
-                    if (yych <= 'E')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    goto basic_json_parser_24;
-                }
-basic_json_parser_49:
-                yyaccept = 1;
-                yych = *(m_marker = ++m_cursor);
-                if (yych <= 'D')
-                {
-                    if (yych == '.')
-                    {
-                        goto basic_json_parser_42;
-                    }
-                    goto basic_json_parser_24;
-                }
-                else
-                {
-                    if (yych <= 'E')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_43;
-                    }
-                    goto basic_json_parser_24;
-                }
-basic_json_parser_50:
-                yych = *++m_cursor;
-                if (yych != 'l')
-                {
-                    goto basic_json_parser_32;
-                }
-                yych = *++m_cursor;
-                if (yych != 's')
-                {
-                    goto basic_json_parser_32;
-                }
-                yych = *++m_cursor;
-                if (yych != 'e')
-                {
-                    goto basic_json_parser_32;
-                }
-                ++m_cursor;
-                {
-                    return token_type::literal_false;
-                }
-basic_json_parser_55:
-                yych = *++m_cursor;
-                if (yych != 'u')
-                {
-                    goto basic_json_parser_32;
-                }
-                yych = *++m_cursor;
-                if (yych != 'e')
-                {
-                    goto basic_json_parser_32;
-                }
-                ++m_cursor;
-                {
-                    return token_type::literal_true;
-                }
-basic_json_parser_59:
-                yych = *++m_cursor;
-                if (yych != 'l')
-                {
-                    goto basic_json_parser_32;
-                }
-                yych = *++m_cursor;
-                if (yych != 'l')
-                {
-                    goto basic_json_parser_32;
-                }
-                ++m_cursor;
-                {
-                    return token_type::literal_null;
-                }
-            }
-
-
-        }
-
-        /// append data from the stream to the internal buffer
-        inline void yyfill() noexcept
-        {
-            if (not m_stream or not * m_stream)
-            {
-                return;
-            }
-
-            const ssize_t offset_start = m_start - m_content;
-            const ssize_t offset_marker = m_marker - m_start;
-            const ssize_t offset_cursor = m_cursor - m_start;
-
-            m_buffer.erase(0, static_cast<size_t>(offset_start));
-            std::string line;
-            std::getline(*m_stream, line);
-            m_buffer += line;
-
-            m_content = reinterpret_cast<const lexer_char_t*>(m_buffer.c_str());
-            m_start  = m_content;
-            m_marker = m_start + offset_marker;
-            m_cursor = m_start + offset_cursor;
-            m_limit  = m_start + m_buffer.size() - 1;
-        }
-
-        /// return string representation of last read token
-        inline string_t get_token() const noexcept
-        {
-            return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
-                            static_cast<size_t>(m_cursor - m_start));
-        }
-
-        /*!
-        @brief return string value for string tokens
-
-        The function iterates the characters between the opening and closing
-        quotes of the string value. The complete string is the range
-        [m_start,m_cursor). Consequently, we iterate from m_start+1 to
-        m_cursor-1.
-
-        We differentiate two cases:
-
-        1. Escaped characters. In this case, a new character is constructed
-           according to the nature of the escape. Some escapes create new
-           characters (e.g., @c "\\n" is replaced by @c "\n"), some are copied
-           as is (e.g., @c "\\\\"). Furthermore, Unicode escapes of the shape
-           @c "\\uxxxx" need special care. In this case, to_unicode takes care
-           of the construction of the values.
-        2. Unescaped characters are copied as is.
-
-        @return string value of current token without opening and closing quotes
-        @exception std::out_of_range if to_unicode fails
-        */
-        inline string_t get_string() const
-        {
-            string_t result;
-            result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
-
-            // iterate the result between the quotes
-            for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
-            {
-                // process escaped characters
-                if (*i == '\\')
-                {
-                    // read next character
-                    ++i;
-
-                    switch (*i)
-                    {
-                        // the default escapes
-                        case 't':
-                        {
-                            result += "\t";
-                            break;
-                        }
-                        case 'b':
-                        {
-                            result += "\b";
-                            break;
-                        }
-                        case 'f':
-                        {
-                            result += "\f";
-                            break;
-                        }
-                        case 'n':
-                        {
-                            result += "\n";
-                            break;
-                        }
-                        case 'r':
-                        {
-                            result += "\r";
-                            break;
-                        }
-
-                        // characters that are not "un"escsaped
-                        case '\\':
-                        {
-                            result += "\\\\";
-                            break;
-                        }
-                        case '/':
-                        {
-                            result += "\\/";
-                            break;
-                        }
-                        case '"':
-                        {
-                            result += "\\\"";
-                            break;
-                        }
-
-                        // unicode
-                        case 'u':
-                        {
-                            // get code xxxx from uxxxx
-                            auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
-                                                          4).c_str(), nullptr, 16);
-
-                            if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
-                            {
-                                // make sure there is a subsequent unicode
-                                if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
-                                {
-                                    throw std::invalid_argument("missing low surrogate");
-                                }
-
-                                // get code yyyy from uxxxx\uyyyy
-                                auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
-                                                               (i + 7), 4).c_str(), nullptr, 16);
-                                result += to_unicode(codepoint, codepoint2);
-                                // skip the next 11 characters (xxxx\uyyyy)
-                                i += 11;
-                            }
-                            else
-                            {
-                                // add unicode character(s)
-                                result += to_unicode(codepoint);
-                                // skip the next four characters (xxxx)
-                                i += 4;
-                            }
-                            break;
-                        }
-                    }
-                }
-                else
-                {
-                    // all other characters are just copied to the end of the
-                    // string
-                    result.append(1, static_cast<typename string_t::value_type>(*i));
-                }
-            }
-
-            return result;
-        }
-
-        /*!
-        @brief return number value for number tokens
-
-        This function translates the last token into a floating point number.
-        The pointer m_begin points to the beginning of the parsed number. We
-        pass this pointer to std::strtod which sets endptr to the first
-        character past the converted number. If this pointer is not the same as
-        m_cursor, then either more or less characters have been used during the
-        comparison. This can happen for inputs like "01" which will be treated
-        like number 0 followed by number 1.
-
-        @return the result of the number conversion or NAN if the conversion
-        read past the current token. The latter case needs to be treated by the
-        caller function.
-
-        @exception std::range_error if passed value is out of range
-        */
-        inline number_float_t get_number() const
-        {
-            // conversion
-            typename string_t::value_type* endptr;
-            const auto float_val = std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start),
-                                               &endptr);
-
-            // return float_val if the whole number was translated and NAN
-            // otherwise
-            return (reinterpret_cast<lexer_char_t*>(endptr) == m_cursor) ? float_val : NAN;
-        }
-
-      private:
-        /// optional input stream
-        std::istream* m_stream;
-        /// the buffer
-        string_t m_buffer;
-        /// the buffer pointer
-        const lexer_char_t* m_content = nullptr;
-        /// pointer to the beginning of the current symbol
-        const lexer_char_t* m_start = nullptr;
-        /// pointer for backtracking information
-        const lexer_char_t* m_marker = nullptr;
-        /// pointer to the current symbol
-        const lexer_char_t* m_cursor = nullptr;
-        /// pointer to the end of the buffer
-        const lexer_char_t* m_limit = nullptr;
-    };
-
-    /*!
-    @brief syntax analysis
-    */
-    class parser
-    {
-      public:
-        /// constructor for strings
-        inline parser(const string_t& s) : m_lexer(s)
-        {
-            // read first token
-            get_token();
-        }
-
-        /// a parser reading from an input stream
-        inline parser(std::istream& _is) : m_lexer(&_is)
-        {
-            // read first token
-            get_token();
-        }
-
-        /// public parser interface
-        inline basic_json parse()
-        {
-            basic_json result = parse_internal();
-
-            expect(lexer::token_type::end_of_input);
-
-            return result;
-        }
-
-      private:
-        /// the actual parser
-        inline basic_json parse_internal()
-        {
-            switch (last_token)
-            {
-                case (lexer::token_type::begin_object):
-                {
-                    // explicitly set result to object to cope with {}
-                    basic_json result(value_t::object);
-
-                    // read next token
-                    get_token();
-
-                    // closing } -> we are done
-                    if (last_token == lexer::token_type::end_object)
-                    {
-                        get_token();
-                        return result;
-                    }
-
-                    // otherwise: parse key-value pairs
-                    do
-                    {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
-                        {
-                            get_token();
-                        }
-
-                        // store key
-                        expect(lexer::token_type::value_string);
-                        const auto key = m_lexer.get_string();
-
-                        // parse separator (:)
-                        get_token();
-                        expect(lexer::token_type::name_separator);
-
-                        // parse value
-                        get_token();
-                        result[key] = parse_internal();
-                    }
-                    while (last_token == lexer::token_type::value_separator);
-
-                    // closing }
-                    expect(lexer::token_type::end_object);
-                    get_token();
-
-                    return result;
-                }
-
-                case (lexer::token_type::begin_array):
-                {
-                    // explicitly set result to object to cope with []
-                    basic_json result(value_t::array);
-
-                    // read next token
-                    get_token();
-
-                    // closing ] -> we are done
-                    if (last_token == lexer::token_type::end_array)
-                    {
-                        get_token();
-                        return result;
-                    }
-
-                    // otherwise: parse values
-                    do
-                    {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
-                        {
-                            get_token();
-                        }
-
-                        // parse value
-                        result.push_back(parse_internal());
-                    }
-                    while (last_token == lexer::token_type::value_separator);
-
-                    // closing ]
-                    expect(lexer::token_type::end_array);
-                    get_token();
-
-                    return result;
-                }
-
-                case (lexer::token_type::literal_null):
-                {
-                    get_token();
-                    return basic_json(nullptr);
-                }
-
-                case (lexer::token_type::value_string):
-                {
-                    const auto s = m_lexer.get_string();
-                    get_token();
-                    return basic_json(s);
-                }
-
-                case (lexer::token_type::literal_true):
-                {
-                    get_token();
-                    return basic_json(true);
-                }
-
-                case (lexer::token_type::literal_false):
-                {
-                    get_token();
-                    return basic_json(false);
-                }
-
-                case (lexer::token_type::value_number):
-                {
-                    auto float_val = m_lexer.get_number();
-
-                    // NAN is returned if token could not be translated
-                    // completely
-                    if (std::isnan(float_val))
-                    {
-                        throw std::invalid_argument(std::string("parse error - ") +
-                                                    m_lexer.get_token() + " is not a number");
-                    }
-
-                    get_token();
-
-                    // check if conversion loses precision
-                    const auto int_val = static_cast<number_integer_t>(float_val);
-                    if (approx(float_val, static_cast<number_float_t>(int_val)))
-                    {
-                        // we basic_json not lose precision -> return int
-                        return basic_json(int_val);
-                    }
-                    else
-                    {
-                        // we would lose precision -> returnfloat
-                        return basic_json(float_val);
-                    }
-                }
-
-                default:
-                {
-                    std::string error_msg = "parse error - unexpected \'";
-                    error_msg += m_lexer.get_token();
-                    error_msg += "\' (";
-                    error_msg += lexer::token_type_name(last_token) + ")";
-                    throw std::invalid_argument(error_msg);
-                }
-            }
-        }
-
-        /// get next token from lexer
-        inline typename lexer::token_type get_token()
-        {
-            last_token = m_lexer.scan();
-            return last_token;
-        }
-
-        inline void expect(typename lexer::token_type t) const
-        {
-            if (t != last_token)
-            {
-                std::string error_msg = "parse error - unexpected \'";
-                error_msg += m_lexer.get_token();
-                error_msg += "\' (" + lexer::token_type_name(last_token);
-                error_msg += "); expected " + lexer::token_type_name(t);
-                throw std::invalid_argument(error_msg);
-            }
-        }
-
-      private:
-        /// the type of the last read token
-        typename lexer::token_type last_token = lexer::token_type::uninitialized;
-        /// the lexer
-        lexer m_lexer;
-    };
-};
-
-
-/////////////
-// presets //
-/////////////
-
-/// default JSON class
-using json = basic_json<>;
-}
-
-
-/////////////////////////
-// nonmember functions //
-/////////////////////////
-
-// specialization of std::swap, and std::hash
-namespace std
-{
-/*!
-@brief exchanges the values of two JSON objects
-@ingroup container
-*/
-template <>
-inline void swap(nlohmann::json& j1,
-                 nlohmann::json& j2) noexcept(
-                     is_nothrow_move_constructible<nlohmann::json>::value and
-                     is_nothrow_move_assignable<nlohmann::json>::value
-                 )
-{
-    j1.swap(j2);
-}
-
-/// hash value for JSON objects
-template <>
-struct hash<nlohmann::json>
-{
-    /// return a hash value for a JSON object
-    inline std::size_t operator()(const nlohmann::json& j) const
-    {
-        // a naive hashing via the string representation
-        const auto& h = hash<nlohmann::json::string_t>();
-        return h(j.dump());
-    }
-};
-}
-
-/*!
-This operator implements a user-defined string literal for JSON objects. It can
-be used by adding \p "_json" to a string literal and returns a JSON object if
-no parse error occurred.
-
-@param s  a string representation of a JSON object
-@return a JSON object
-*/
-inline nlohmann::json operator "" _json(const char* s, std::size_t)
-{
-    return nlohmann::json::parse(reinterpret_cast<nlohmann::json::string_t::value_type*>
-                                 (const_cast<char*>(s)));
-}
-
-#endif
diff --git a/third_party/socket.io-client-cpp/test/sio_test.cpp b/third_party/socket.io-client-cpp/test/sio_test.cpp
deleted file mode 100644
index 3901f05..0000000
--- a/third_party/socket.io-client-cpp/test/sio_test.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-//
-//  sio_test_sample.cpp
-//
-//  Created by Melo Yao on 3/24/15.
-//
-
-#include <sio_client.h>
-#include <internal/sio_packet.h>
-#include <functional>
-#include <iostream>
-#include <thread>
-
-#include <catch2/catch_test_macros.hpp>
-
-#ifndef _WIN32
-#include "json.hpp" //nlohmann::json cannot build in MSVC
-#endif
-
-using namespace sio;
-
-TEST_CASE( "test_packet_construct_1" )
-{
-    packet p("/nsp",nullptr,1001,true);
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_message() == nullptr);
-    CHECK(p.get_nsp() == std::string("/nsp"));
-    CHECK(p.get_pack_id() == 1001);
-}
-
-TEST_CASE( "test_packet_construct_2" )
-{
-    packet p(packet::frame_ping);
-    CHECK(p.get_frame() == packet::frame_ping);
-    CHECK(p.get_message() == nullptr);
-    CHECK(p.get_nsp() == std::string(""));
-    CHECK(p.get_pack_id() == 0xFFFFFFFF);
-}
-
-TEST_CASE( "test_packet_construct_3" )
-{
-    packet p(packet::type_connect,"/nsp",nullptr);
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_type() == packet::type_connect);
-    CHECK(p.get_message() == nullptr);
-    CHECK(p.get_nsp() == std::string("/nsp"));
-    CHECK(p.get_pack_id() == 0xFFFFFFFF);
-}
-
-TEST_CASE( "test_packet_accept_1" )
-{
-    packet p(packet::type_connect,"/nsp",nullptr);
-    std::string payload;
-    std::vector<std::shared_ptr<const std::string> > buffers;
-    p.accept(payload,buffers);
-    CHECK(buffers.size() == 0);
-    CHECK(payload == "40/nsp");
-    INFO("outputing payload:" << payload);
-}
-
-TEST_CASE( "test_packet_accept_2" )
-{
-    packet p(packet::frame_ping);
-    std::string payload;
-    std::vector<std::shared_ptr<const std::string> > buffers;
-    p.accept(payload,buffers);
-    CHECK(buffers.size() == 0);
-    CHECK(payload == "2");
-    INFO("outputing payload:" << payload);
-}
-
-TEST_CASE( "test_packet_accept_3" )
-{
-    message::ptr array = array_message::create();
-    array->get_vector().push_back(string_message::create("event"));
-    array->get_vector().push_back(string_message::create("text"));
-    packet p("/nsp",array,1001,true);
-    std::string payload;
-    std::vector<std::shared_ptr<const std::string> > buffers;
-    p.accept(payload,buffers);
-    CHECK(p.get_type() == packet::type_ack);
-    CHECK(buffers.size() == 0);
-    CHECK(payload == "43/nsp,1001[\"event\",\"text\"]");
-    INFO("outputing payload:" << payload);
-}
-
-#ifndef _WIN32
-TEST_CASE( "test_packet_accept_4" )
-{
-    message::ptr binObj = object_message::create();
-    binObj->get_map()["desc"] = string_message::create("Bin of 100 bytes");
-    char bin[100];
-    memset(bin,0,100*sizeof(char));
-    binObj->get_map()["bin1"] = binary_message::create(std::shared_ptr<const std::string>(new std::string(bin,100)));
-    char bin2[50];
-    memset(bin2,1,50*sizeof(char));
-    binObj->get_map()["bin2"] = binary_message::create(std::make_shared<const std::string>(bin2,50));
-
-    packet p("/nsp",binObj,1001,false);
-    std::string payload;
-    std::vector<std::shared_ptr<const std::string> > buffers;
-    p.accept(payload,buffers);
-    CHECK(p.get_type() == packet::type_binary_event);
-    REQUIRE(buffers.size() == 2);
-    size_t json_start = payload.find("{");
-    REQUIRE(json_start!=std::string::npos);
-    std::string header = payload.substr(0,json_start);
-    CHECK(header=="452-/nsp,1001");
-    INFO("outputing payload:" << payload);
-    std::string json = payload.substr(json_start);
-    nlohmann::json j = nlohmann::json::parse(json);
-    CHECK(j["desc"].get<std::string>() == "Bin of 100 bytes");
-    INFO("outputing payload desc::" << j["desc"].get<std::string>());
-    CHECK((bool)j["bin1"]["_placeholder"]);
-    INFO("outputing payload bin1:" << j["bin1"].dump());
-    CHECK((bool)j["bin2"]["_placeholder"]);
-    INFO("outputing payload bin2:" << j["bin2"].dump());
-    int bin1Num = j["bin1"]["num"].get<int>();
-    char numchar[] = {0,0};
-    numchar[0] = bin1Num+'0';
-    CHECK(buffers[bin1Num]->length()==100);
-    INFO("outputing payload bin1 num:" << numchar);
-    CHECK(buffers[bin1Num]->at(50)==0);
-    CHECK(buffers[bin1Num]->at(0) == 0);
-    int bin2Num = j["bin2"]["num"].get<int>();
-    numchar[0] = bin2Num+'0';
-    CHECK(buffers[bin2Num]->length()==50);
-    INFO("outputing payload bin2 num:" << numchar);
-    CHECK(buffers[bin2Num]->at(25)==1);
-    CHECK(buffers[bin2Num]->at(0) == 1);
-}
-#endif
-
-TEST_CASE( "test_packet_parse_1" )
-{
-    packet p;
-    bool hasbin = p.parse("42/nsp,1001[\"event\",\"text\"]");
-    CHECK(!hasbin);
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_type() == packet::type_event);
-    CHECK(p.get_nsp() == "/nsp");
-    CHECK(p.get_pack_id() == 1001);
-    CHECK(p.get_message()->get_flag() == message::flag_array);
-    REQUIRE(p.get_message()->get_vector()[0]->get_flag() == message::flag_string);
-    CHECK(p.get_message()->get_vector()[0]->get_string() == "event");
-    REQUIRE(p.get_message()->get_vector()[1]->get_flag() == message::flag_string);
-    CHECK(p.get_message()->get_vector()[1]->get_string() == "text");
-
-    hasbin = p.parse("431111[\"ack\",{\"count\":5}]");
-    CHECK(!hasbin);
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_type() == packet::type_ack);
-    CHECK(p.get_pack_id() == 1111);
-    CHECK(p.get_nsp() == "/");
-    CHECK(p.get_message()->get_flag() == message::flag_array);
-    REQUIRE(p.get_message()->get_vector()[0]->get_flag() == message::flag_string);
-    CHECK(p.get_message()->get_vector()[0]->get_string() == "ack");
-    REQUIRE(p.get_message()->get_vector()[1]->get_flag() == message::flag_object);
-    CHECK(p.get_message()->get_vector()[1]->get_map()["count"]->get_int() == 5);
-}
-
-TEST_CASE( "test_packet_parse_2" )
-{
-    packet p;
-    bool hasbin = p.parse("3");
-    CHECK(!hasbin);
-    CHECK(p.get_frame() == packet::frame_pong);
-    CHECK(!p.get_message());
-    CHECK(p.get_nsp() == "/");
-    CHECK(p.get_pack_id() == -1);
-    hasbin = p.parse("2");
-
-    CHECK(!hasbin);
-    CHECK(p.get_frame() == packet::frame_ping);
-    CHECK(!p.get_message());
-    CHECK(p.get_nsp() == "/");
-    CHECK(p.get_pack_id() == -1);
-}
-
-TEST_CASE( "test_packet_parse_3" )
-{
-    packet p;
-    bool hasbin = p.parse("40/nsp");
-    CHECK(!hasbin);
-    CHECK(p.get_type() == packet::type_connect);
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_nsp() == "/nsp");
-    CHECK(p.get_pack_id() == -1);
-    CHECK(!p.get_message());
-    p.parse("40");
-    CHECK(p.get_type() == packet::type_connect);
-    CHECK(p.get_nsp() == "/");
-    CHECK(p.get_pack_id() == -1);
-    CHECK(!p.get_message());
-    p.parse("44\"error\"");
-    CHECK(p.get_type() == packet::type_error);
-    CHECK(p.get_nsp() == "/");
-    CHECK(p.get_pack_id() == -1);
-    CHECK(p.get_message()->get_flag() == message::flag_string);
-    p.parse("44/nsp,\"error\"");
-    CHECK(p.get_type() == packet::type_error);
-    CHECK(p.get_nsp() == "/nsp");
-    CHECK(p.get_pack_id() == -1);
-    CHECK(p.get_message()->get_flag() == message::flag_string);
-}
-
-TEST_CASE( "test_packet_parse_4" )
-{
-    packet p;
-    bool hasbin = p.parse("452-/nsp,101[\"bin_event\",[{\"_placeholder\":true,\"num\":1},{\"_placeholder\":true,\"num\":0},\"text\"]]");
-    CHECK(hasbin);
-    char buf[100];
-    buf[0] = packet::frame_message;
-    memset(buf + 1,0,99);
-
-    std::string bufstr(buf,100);
-    std::string bufstr2(buf,50);
-    CHECK(p.parse_buffer(bufstr));
-    CHECK(!p.parse_buffer(bufstr2));
-
-    CHECK(p.get_frame() == packet::frame_message);
-    CHECK(p.get_nsp() == "/nsp");
-    CHECK(p.get_pack_id() == 101);
-    message::ptr msg = p.get_message();
-    REQUIRE(msg);
-    REQUIRE(msg->get_flag() == message::flag_array);
-    CHECK(msg->get_vector()[0]->get_string() == "bin_event");
-    message::ptr array = msg->get_vector()[1];
-    REQUIRE(array->get_flag() == message::flag_array);
-    REQUIRE(array->get_vector()[0]->get_flag() == message::flag_binary);
-    REQUIRE(array->get_vector()[1]->get_flag() == message::flag_binary);
-    REQUIRE(array->get_vector()[2]->get_flag() == message::flag_string);
-    CHECK(array->get_vector()[0]->get_binary()->size() == 50);
-    CHECK(array->get_vector()[1]->get_binary()->size() == 100);
-    CHECK(array->get_vector()[2]->get_string() == "text");
-
-}